On Thursday 24 July 2008, Misbah khan wrote: > > Hi all ... > > I am uploading the source code which is doing the following :- > > 1. mapping cpld register using ioremap coping the data to circular buffer > and remapping it to user space . > > 2. It can also map kernel virtual dma memory to user space if compiled > conditionally . > > following is the problem which i am facing ... > > 1. It is somitimes giving following kernel panic .... > > nable to handle kernel NULL pointer dereference at virtual address 00000000 > pgd = c0004000 > [00000000] *pgd=00000000 > Internal error: Oops: 17 [#1] > Modules linked in: fluke_driver tstamp sig_router mvci_spi mvci_sf_pcd > mvci_sci_unidir_s1 mvci_sci_diff mvci_sci_bidir_s > 1 mvci_rtmd_s1 mvci_kwiso_s1 mvci_kw1281_s1 mvci_kh_s1 mvci_j1850 > mvci_gm_sbc mvci_diagh_s1 g_ether mvci_dcl mvci_can1 f > pga_conf arcotg_udc adc_dac keypad(F) splc501_lcd(F) cpld > CPU: 0 > PC is at cascade+0x64/0x8c > LR is at __init_begin+0x3fff8000/0x30 > pc : [<c00484ac>] lr : [<00000000>] Tainted: GF > sp : c0293ea8 ip : 0040b000 fp : c0293ecc > r10: 8001d9f0 r9 : c0292000 r8 : 00000001 > r7 : c0292000 r6 : 0000000c r5 : c02fa048 r4 : 00000000 > r3 : c02fa2f8 r2 : 0000261a r1 : bf01ab70 r0 : c02fa2f8 > Flags: Nzcv IRQs off FIQs on Mode SVC_32 Segment kernel > Control: C5387F > Table: 8698C000 DAC: 00000017 > Process swapper (pid: 0, stack limit = 0xc0292250) > Stack: (0xc0293ea8 to 0xc0294000) > 3ea0: bf01ab70 c02fb440 0000000a 00000000 c02fa048 > 0000000a > 3ec0: c0293efc c0293ed0 c0048810 c0048454 c0293eec c0293ee0 c002a30c > 00000001 > 3ee0: c02f9e44 0000000a 00000002 00000001 c0293f1c c0293f00 c00442a0 > c0048794 > 3f00: c0293f2c 0000001d c0294740 00000000 c0293f2c c0293f20 c00446d4 > c0044254 > 3f20: c0293f4c c0293f30 c00217b0 c0044698 c0293f5c ffffffff 0000ffff > 00000001 > 3f40: c0293fa4 c0293f50 c00209e4 c0021770 00000001 00000001 c0292000 > 00000000 > 3f60: c0022068 c0292000 c0298c44 c03121c0 8001da24 4107b364 8001d9f0 > c0293fa4 > 3f80: c0293fa8 c0293f98 c0021d48 c002209c 60000013 ffffffff c0293fbc > c0293fa8 > 3fa0: c0021d48 c0022074 c02faae0 c02f292c c0293fcc c0293fc0 c00202e0 > c0021d24 > 3fc0: c0293ff4 c0293fd0 c0008848 c00202b4 c00083c4 00000000 00000000 > c02f29a8 > 3fe0: 00000000 00c5387d 00000000 c0293ff8 80008030 c00086e0 00000000 > 00000000 > Backtrace: > [<c0048448>] (cascade+0x0/0x8c) from [<c0048810>] > (run_timer_softirq+0x88/0x1e8) > r6 = 0000000A r5 = C02FA048 r4 = 00000000 > [<c0048788>] (run_timer_softirq+0x0/0x1e8) from [<c00442a0>] > (__do_softirq+0x58/0xc8) > r8 = 00000001 r7 = 00000002 r6 = 0000000A r5 = C02F9E44 > r4 = 00000001 > [<c0044248>] (__do_softirq+0x0/0xc8) from [<c00446d4>] (irq_exit+0x48/0x5c) > r6 = 00000000 r5 = C0294740 r4 = 0000001D > [<c004468c>] (irq_exit+0x0/0x5c) from [<c00217b0>] (asm_do_IRQ+0x4c/0x64) > [<c0021764>] (asm_do_IRQ+0x0/0x64) from [<c00209e4>] (__irq_svc+0x44/0x80) > r6 = 00000001 r5 = 0000FFFF r4 = FFFFFFFF > [<c0022068>] (default_idle+0x0/0x3c) from [<c0021d48>] (cpu_idle+0x30/0x5c) > [<c0021d18>] (cpu_idle+0x0/0x5c) from [<c00202e0>] (rest_init+0x38/0x40) > r5 = C02F292C r4 = C02FAAE0 > [<c00202a8>] (rest_init+0x0/0x40) from [<c0008848>] > (start_kernel+0x174/0x1c0) > [<c00086d4>] (start_kernel+0x0/0x1c0) from [<80008030>] (0x80008030) > Code: e1530005 15822000 ebffffb6 e1a0e004 (e5944000) > <0>Kernel panic - not syncing: Aiee, killing interrupt handler! > > > also when i run it on X86 PC i am able to get the data and no panic where in > on the board it is giving the above error .... > > 2. I can raed the data using the user application when i run it on X86 PC > where in i cant able to read the data when i run it on the board the data i > was getting was always '/0' filled buffer . > > > Here is the compilete code ............. > > > static int McBSP_DriverOpen(struct inode *inode,struct file *file) > { > /* Reintialize file operation structure */ > file->f_op=&fluke_fops; >
this is already set. > printk(KERN_DEBUG" fluke driver open success \n"); > > if (device_open_count == 0) > { > device_open_count = 1; > > /* Reset the read and write index*/ > buf_index_area.write_index=0; > buf_index_area.read_index=-1; > buf_index_area.count_index=0; > > #ifdef SIMULATION > /* Initialize the Timer */ > init_timer(&fluke_timer); > fluke_timer.expires = jiffies + (HZ*10);//Timer will Expire > after 60 sec > fluke_timer.data = 0; > fluke_timer.function = (void *)timer_func; > add_timer(&fluke_timer); > #endif > } > > return 0; > } Using the count in this way is racy, best write the code so that it can allow multiple opens. > irqreturn_t DataAcqIntHandler(int irq,void *dev_id, struct pt_regs *regs) > { > printk(KERN_ALERT" In Interrupt Handler\n"); > /* Data present status is set to wake up the read call */ > data_present_status=1; > > /* Wake up the blocked Select call */ > wake_up_interruptible(&wait_queue); > > #ifndef SIMULATION > /* Clear the interrupt in the interrupt pending registor */ > cpi->ic_scprrh |=DATA_ACQ_INT_CLEAR; > #endif > > return IRQ_HANDLED; > > }/* End of PpsIntrHandler() */ The interrupt handler should be able to deal with shared interrupts, and needs to check if the interrupt came from this device, returning IRQ_NONE otherwise. > static int __init McBSP_DriverInit(void) > { > unsigned int virt_addr = 0; > int mem = 0; > > //buf_area = vmalloc(sizeof(circularbuffer_S)); > //if(!buf_area) > //{ > // printk(KERN_ALERT"vmalloc failed \n"); > // return -1; > //} > > #if 0 > /* > * Allocate memory for the circular buffer in the DMA coherent area > * and algin it in the Cache > */ > mem = L1_CACHE_ALIGN(sizeof(circularbuffer_S)); > > buf_ptr = (char *)dma_alloc_coherent(NULL, mem, &dma_addr,GFP_KERNEL); no need for the cast. > printk(KERN_INFO" buf_ptr = 0x%x \n",(int )buf_ptr); > if(NULL == buf_ptr ) > { > printk(KERN_ALERT" Allocation of Memory failure "); > return -1; > } > > buf_area = (circularbuffer_S *)(((unsigned int )buf_ptr + PAGE_SIZE - > 1) \ > & PAGE_MASK); > > printk(KERN_INFO" buf_area = 0x%x \n",(int )buf_area); > > if(NULL == buf_area) > { > printk(KERN_ALERT" Circular buffer memory not allocated \n"); > return -1; > } > > /* Marking the Pages as reserved */ > for (virt_addr = (unsigned int)buf_area; \ > virt_addr < (unsigned int )buf_area + sizeof(circularbuffer_S);\ > virt_addr += PAGE_SIZE) > { > /* Set the pages as reserved */ > SetPageReserved(virt_to_page(virt_addr)); > //mem_map_reserve(virt_to_page(virt_addr)); > } no need for SetPageReserved, it already is marked as in use through the allocation. > phy_addr = virt_to_phys(buf_ptr); You can't use virt_to_phys to get the dma address. You also don't need that because you already have it in dma_addr. > printk(KERN_INFO"Allocated Memory for Circular Buffer at physical > 0x0%x\n",phy_addr); > > #else > > buf_area = ioremap(0xB2000000,0x4000); //(0xB2000000,0x4000); > //(7700000,900000); > if(!buf_area) > { > printk(KERN_ALERT"ioremap failed \n"); > return -1; > } Don't hardcode the numbers here, you should get the values from the device tree, and use of_iomap(). > printk(" Ioremap mapped to virtual 0x0%x \n",buf_area); > *((unsigned int *)buf_area) = 0xa5a5a5a5; > printk(" Ioremap data 0x0%x \n",*((unsigned int *)buf_area + 0)); > > #endif > > /* Device major number is registered to set the driver entry point */ > if(register_chrdev(MAJOR_NO,MODULE_NAME, &fluke_fops)==0) > { > printk(KERN_DEBUG" Fluke driver registeration success \n"); > > } > else > { > printk(KERN_ALERT" Fluke driver registeration failed \n"); > return -1; > } Since it's just one device, it's easier to use a misc_device. > /* > * Register Data Acq interrupt request with specified irq and install > the > * handler > */ > if(request_irq(DATA_ACQ_INT,(void *)DataAcqIntHandler, SA_INTERRUPT, > MODULE_NAME, NULL)==0) > { > printk(KERN_DEBUG" Data Acq interrupt request returns success > \n"); > } > else > { > printk(KERN_DEBUG" Data Acq interrupt request failed \n"); > unregister_chrdev(MAJOR_NO,MODULE_NAME); > return -1; > > } hardcoding interrupt numbers is broken, interrupt numbers are relative to one interrupt controller. Use irq_of_parse_and_map. > static int McBSP_DriverIoctl(struct inode *inode, struct file *file,\ > > unsigned int cmd, unsigned long param) > { > int i; > daq_t daq_param; > > printk(KERN_DEBUG"In ioctl command \n"); > > switch(cmd) > { > case START_ACQ_DATA: > > if(copy_from_user(&daq_param,(void > *)param,sizeof(daq_param))) > { > > return -1; > } > > /* For Simulation we are writing the data */ > if(WriteBuf() < 0) > { > printk(" Writing to the memory failure \n"); > return -1; > } > > /* Wait for the Interrupt to occur */ > wait_event_interruptible( wait_queue, > data_present_status !=0); > > printk("Read Index before read > %d\n",buf_index_area.read_index); > data_present_status=0; Racy, you could have multiple threads doing this ioctl. Moreover, you should not block in an ioctl but rather implement a poll() function for waiting. > buf_index_area.read_index++; > buf_index_area.read_index%=NO_FRAMES; > > if(buf_index_area.read_index > ==((buf_index_area.write_index +1) % > NO_FRAMES)) > //if(buf_index_area.read_index == > buf_index_area.write_index ) > { > printk("Read failure because read and write > index are same\n"); > return -1; > } > > /* Decrement the count index to indicate the data > availibility */ > down(&mutex); > buf_index_area.count_index--; > up(&mutex); New drivers should not use semaphores (up/down) in places where they can use real mutexes (mutex_lock/mutex_unlock). > static int McBSP_DriverMmap(struct file *file,struct vm_area_struct *vma) > { > > unsigned long start = vma->vm_start; > unsigned long size = vma->vm_end - vma->vm_start; //0x900000; > unsigned long phy_add = virt_to_phys(buf_ptr); //0x7700000; virt_to_phys doesn't work on vmalloc memory. > int ret = 0; > > /* Make the mmaped area noncacheable */ > vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > > /* Set the Flags to give permissions to Mmaped area */ > vma->vm_flags |=VM_RESERVED; > vma->vm_flags |=VM_READ; > vma->vm_flags |=VM_WRITE; > vma->vm_flags |=VM_IO; > //vma->vm_flags |=VM_SHARED; > //vma->vm_flags |=VM_LOCKED; For memory, you typically want to set vm_page_prot to use non-guarded mapping, so that user space accesses are faster. Not sure if VM_IO is right for vmalloc. Arnd <>< _______________________________________________ Linuxppc-embedded mailing list Linuxppc-embedded@ozlabs.org https://ozlabs.org/mailman/listinfo/linuxppc-embedded