3 Copyright 1996,2002,2005 Gregory D. Hager, Alfred A. Rizzi, Noah J. Cowan,
4 Jason Lapenta, Scott Smedley, Greg Sharp
6 This file is part of the DT3155 Device Driver.
8 The DT3155 Device Driver is free software; you can redistribute it
9 and/or modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2 of the
11 License, or (at your option) any later version.
13 The DT3155 Device Driver is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with the DT3155 Device Driver; if not, write to the Free
20 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25 Date Programmer Description of changes made
26 -------------------------------------------------------------------
28 10-Oct-2001 SS port to 2.4 kernel
29 02-Apr-2002 SS Mods to use allocator as a standalone module;
30 Merged John Roll's changes (john@cfa.harvard.edu)
31 to make work with multiple boards.
32 02-Jul-2002 SS Merged James Rose's chages (rosejr@purdue.edu) to:
33 * fix successive interrupt-driven captures
34 * add select/poll support.
35 10-Jul-2002 GCS Add error check when ndevices > MAXBOARDS.
36 02-Aug-2002 GCS Fix field mode so that odd (lower) field is stored
37 in lower half of buffer.
38 05-Aug-2005 SS port to 2.6 kernel.
39 26-Oct-2009 SS port to 2.6.30 kernel.
43 ** appended "mem=124" in lilo.conf to allow for 4megs free on my 128meg system.
44 * using allocator.c and allocator.h from o'reilly book (alessandro rubini)
45 ftp://ftp.systemy.it/pub/develop (see README.allocator)
47 + might want to get rid of MAXboards for allocating initial buffer.
48 confusing and not necessary
50 + in cleanup_module the MOD_IN_USE looks like it is check after it should
52 * GFP_DMA should not be set with a PCI system (pg 291)
54 - NJC why are only two buffers allowed? (see isr, approx line 358)
58 extern void printques(int);
60 #include <linux/module.h>
61 #include <linux/interrupt.h>
62 #include <linux/pci.h>
63 #include <linux/types.h>
64 #include <linux/poll.h>
65 #include <linux/sched.h>
66 #include <linux/smp_lock.h>
69 #include <asm/uaccess.h>
72 #include "dt3155_drv.h"
73 #include "dt3155_isr.h"
74 #include "dt3155_io.h"
75 #include "allocator.h"
78 MODULE_LICENSE("GPL");
80 /* Error variable. Zero means no error. */
83 #ifndef PCI_DEVICE_ID_INTEL_7116
84 #define PCI_DEVICE_ID_INTEL_7116 0x1223
87 #define DT3155_VENDORID PCI_VENDOR_ID_INTEL
88 #define DT3155_DEVICEID PCI_DEVICE_ID_INTEL_7116
92 #define DT_3155_DEBUG_MSG(x,y) printk(x,y)
94 #define DT_3155_DEBUG_MSG(x,y)
97 /* wait queue for interrupts */
98 wait_queue_head_t dt3155_read_wait_queue[MAXBOARDS];
100 #define DT_3155_SUCCESS 0
101 #define DT_3155_FAILURE -EIO
103 /* set to dynamicaly allocate, but it is tunable: */
104 /* insmod DT_3155 dt3155 dt3155_major=XX */
105 int dt3155_major = 0;
107 /* The minor numbers are 0 and 1 ... they are not tunable.
108 * They are used as the indices for the structure vectors,
109 * and register address vectors
112 /* Global structures and variables */
114 /* Status of each device */
115 struct dt3155_status dt3155_status[MAXBOARDS];
117 /* kernel logical address of the board */
118 u8 *dt3155_lbase[MAXBOARDS] = { NULL
123 /* DT3155 registers */
124 u8 *dt3155_bbase = NULL; /* kernel logical address of the *
126 u32 dt3155_dev_open[MAXBOARDS] = {0
137 * Stops interrupt generation right away and resets the status
138 * to idle. I don't know why this works and the other way doesn't.
141 static void quick_stop (int minor)
143 // TODO: scott was here
145 ReadMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
146 /* disable interrupts */
147 int_csr_r.fld.FLD_END_EVE_EN = 0;
148 int_csr_r.fld.FLD_END_ODD_EN = 0;
149 WriteMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
151 dt3155_status[minor].state &= ~(DT3155_STATE_STOP|0xff);
152 /* mark the system stopped: */
153 dt3155_status[minor].state |= DT3155_STATE_IDLE;
154 dt3155_fbuffer[minor]->stop_acquire = 0;
155 dt3155_fbuffer[minor]->even_stopped = 0;
157 dt3155_status[minor].state |= DT3155_STATE_STOP;
158 dt3155_status[minor].fbuffer.stop_acquire = 1;
164 /*****************************************************
165 * dt3155_isr() Interrupt service routien
167 * - looks like this isr supports IRQ sharing (or could) JML
168 * - Assumes irq's are disabled, via SA_INTERRUPT flag
169 * being set in request_irq() call from init_module()
170 *****************************************************/
171 static void dt3155_isr(int irq, void *dev_id, struct pt_regs *regs)
178 /* find out who issued the interrupt */
179 for (index = 0; index < ndevices; index++) {
180 if(dev_id == (void*) &dt3155_status[index])
187 /* hopefully we should not get here */
188 if (minor < 0 || minor >= MAXBOARDS) {
189 printk(KERN_ERR "dt3155_isr called with invalid dev_id\n");
193 /* Check for corruption and set a flag if so */
194 ReadMReg((dt3155_lbase[minor] + CSR1), csr1_r.reg);
196 if ((csr1_r.fld.FLD_CRPT_EVE) || (csr1_r.fld.FLD_CRPT_ODD))
198 /* TODO: this should probably stop acquisition */
199 /* and set some flags so that dt3155_read */
200 /* returns an error next time it is called */
201 dt3155_errno = DT_ERR_CORRUPT;
202 printk("dt3155: corrupt field\n");
206 ReadMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
208 /* Handle the even field ... */
209 if (int_csr_r.fld.FLD_END_EVE)
211 if ((dt3155_status[minor].state & DT3155_STATE_MODE) ==
214 dt3155_fbuffer[minor]->frame_count++;
217 ReadI2C(dt3155_lbase[minor], EVEN_CSR, &i2c_even_csr.reg);
219 /* Clear the interrupt? */
220 int_csr_r.fld.FLD_END_EVE = 1;
222 /* disable the interrupt if last field */
223 if (dt3155_fbuffer[minor]->stop_acquire)
225 printk("dt3155: even stopped.\n");
226 dt3155_fbuffer[minor]->even_stopped = 1;
227 if (i2c_even_csr.fld.SNGL_EVE)
229 int_csr_r.fld.FLD_END_EVE_EN = 0;
233 i2c_even_csr.fld.SNGL_EVE = 1;
237 WriteMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
239 /* Set up next DMA if we are doing FIELDS */
240 if ((dt3155_status[minor].state & DT3155_STATE_MODE) ==
243 /* GCS (Aug 2, 2002) -- In field mode, dma the odd field
244 into the lower half of the buffer */
245 const u32 stride = dt3155_status[minor].config.cols;
246 buffer_addr = dt3155_fbuffer[minor]->
247 frame_info[dt3155_fbuffer[minor]->active_buf].addr
248 + (DT3155_MAX_ROWS / 2) * stride;
249 local_save_flags(flags);
251 wake_up_interruptible(&dt3155_read_wait_queue[minor]);
253 /* Set up the DMA address for the next field */
254 local_irq_restore(flags);
255 WriteMReg((dt3155_lbase[minor] + ODD_DMA_START), buffer_addr);
258 /* Check for errors. */
259 i2c_even_csr.fld.DONE_EVE = 1;
260 if (i2c_even_csr.fld.ERROR_EVE)
261 dt3155_errno = DT_ERR_OVERRUN;
263 WriteI2C(dt3155_lbase[minor], EVEN_CSR, i2c_even_csr.reg);
265 /* Note that we actually saw an even field meaning */
266 /* that subsequent odd field complete the frame */
267 dt3155_fbuffer[minor]->even_happened = 1;
269 /* recording the time that the even field finished, this should be */
270 /* about time in the middle of the frame */
271 do_gettimeofday(&(dt3155_fbuffer[minor]->
272 frame_info[dt3155_fbuffer[minor]->
277 /* ... now handle the odd field */
278 if (int_csr_r.fld.FLD_END_ODD)
280 ReadI2C(dt3155_lbase[minor], ODD_CSR, &i2c_odd_csr.reg);
282 /* Clear the interrupt? */
283 int_csr_r.fld.FLD_END_ODD = 1;
285 if (dt3155_fbuffer[minor]->even_happened ||
286 (dt3155_status[minor].state & DT3155_STATE_MODE) ==
289 dt3155_fbuffer[minor]->frame_count++;
292 if (dt3155_fbuffer[minor]->stop_acquire &&
293 dt3155_fbuffer[minor]->even_stopped)
295 printk(KERN_DEBUG "dt3155: stopping odd..\n");
296 if (i2c_odd_csr.fld.SNGL_ODD)
298 /* disable interrupts */
299 int_csr_r.fld.FLD_END_ODD_EN = 0;
300 dt3155_status[minor].state &= ~(DT3155_STATE_STOP|0xff);
302 /* mark the system stopped: */
303 dt3155_status[minor].state |= DT3155_STATE_IDLE;
304 dt3155_fbuffer[minor]->stop_acquire = 0;
305 dt3155_fbuffer[minor]->even_stopped = 0;
307 printk(KERN_DEBUG "dt3155: state is now %x\n",
308 dt3155_status[minor].state);
312 i2c_odd_csr.fld.SNGL_ODD = 1;
316 WriteMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
318 /* if the odd field has been acquired, then */
319 /* change the next dma location for both fields */
320 /* and wake up the process if sleeping */
321 if (dt3155_fbuffer[minor]->even_happened ||
322 (dt3155_status[minor].state & DT3155_STATE_MODE) ==
326 local_save_flags(flags);
332 if (dt3155_fbuffer[minor]->nbuffers > 2)
334 if (!are_empty_buffers(minor))
336 /* The number of active + locked buffers is
337 * at most 2, and since there are none empty, there
338 * must be at least nbuffers-2 ready buffers.
339 * This is where we 'drop frames', oldest first. */
340 push_empty(pop_ready(minor), minor);
343 /* The ready_que can't be full, since we know
344 * there is one active buffer right now, so it's safe
345 * to push the active buf on the ready_que. */
346 push_ready(minor, dt3155_fbuffer[minor]->active_buf);
347 /* There's at least 1 empty -- make it active */
348 dt3155_fbuffer[minor]->active_buf = pop_empty(minor);
349 dt3155_fbuffer[minor]->
350 frame_info[dt3155_fbuffer[minor]->
351 active_buf].tag = ++unique_tag;
353 else /* nbuffers == 2, special case */
354 { /* There is 1 active buffer.
355 * If there is a locked buffer, keep the active buffer
356 * the same -- that means we drop a frame.
358 if (dt3155_fbuffer[minor]->locked_buf < 0)
361 dt3155_fbuffer[minor]->active_buf);
362 if (are_empty_buffers(minor))
364 dt3155_fbuffer[minor]->active_buf =
368 { /* no empty or locked buffers, so use a readybuf */
369 dt3155_fbuffer[minor]->active_buf =
379 dt3155_fbuffer[minor]->even_happened = 0;
381 wake_up_interruptible(&dt3155_read_wait_queue[minor]);
383 local_irq_restore(flags);
387 /* Set up the DMA address for the next frame/field */
388 buffer_addr = dt3155_fbuffer[minor]->
389 frame_info[dt3155_fbuffer[minor]->active_buf].addr;
390 if ((dt3155_status[minor].state & DT3155_STATE_MODE) ==
393 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_START), buffer_addr);
397 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_START), buffer_addr);
399 WriteMReg((dt3155_lbase[minor] + ODD_DMA_START), buffer_addr
400 + dt3155_status[minor].config.cols);
403 /* Do error checking */
404 i2c_odd_csr.fld.DONE_ODD = 1;
405 if (i2c_odd_csr.fld.ERROR_ODD)
406 dt3155_errno = DT_ERR_OVERRUN;
408 WriteI2C(dt3155_lbase[minor], ODD_CSR, i2c_odd_csr.reg);
412 /* If we get here, the Odd Field wasn't it either... */
413 printk("neither even nor odd. shared perhaps?\n");
416 /*****************************************************
417 * init_isr(int minor)
418 * turns on interupt generation for the card
419 * designated by "minor".
420 * It is called *only* from inside ioctl().
421 *****************************************************/
422 static void dt3155_init_isr(int minor)
424 const u32 stride = dt3155_status[minor].config.cols;
426 switch (dt3155_status[minor].state & DT3155_STATE_MODE)
428 case DT3155_STATE_FLD:
430 even_dma_start_r = dt3155_status[minor].
431 fbuffer.frame_info[dt3155_status[minor].fbuffer.active_buf].addr;
432 even_dma_stride_r = 0;
433 odd_dma_stride_r = 0;
435 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_START),
437 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_STRIDE),
439 WriteMReg((dt3155_lbase[minor] + ODD_DMA_STRIDE),
444 case DT3155_STATE_FRAME:
447 even_dma_start_r = dt3155_status[minor].
448 fbuffer.frame_info[dt3155_status[minor].fbuffer.active_buf].addr;
449 odd_dma_start_r = even_dma_start_r + stride;
450 even_dma_stride_r = stride;
451 odd_dma_stride_r = stride;
453 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_START),
455 WriteMReg((dt3155_lbase[minor] + ODD_DMA_START),
457 WriteMReg((dt3155_lbase[minor] + EVEN_DMA_STRIDE),
459 WriteMReg((dt3155_lbase[minor] + ODD_DMA_STRIDE),
465 /* 50/60 Hz should be set before this point but let's make sure it is */
468 ReadI2C(dt3155_lbase[minor], CSR2, &i2c_csr2.reg);
469 i2c_csr2.fld.HZ50 = FORMAT50HZ;
470 WriteI2C(dt3155_lbase[minor], CSR2, i2c_csr2.reg);
472 /* enable busmaster chip, clear flags */
476 * shouldn't we be concered with continuous values of
477 * DT3155_SNAP & DT3155_ACQ here? (SS)
481 csr1_r.fld.CAP_CONT_EVE = 1; /* use continuous capture bits to */
482 csr1_r.fld.CAP_CONT_ODD = 1; /* enable */
483 csr1_r.fld.FLD_DN_EVE = 1; /* writing a 1 clears flags */
484 csr1_r.fld.FLD_DN_ODD = 1;
485 csr1_r.fld.SRST = 1; /* reset - must be 1 */
486 csr1_r.fld.FIFO_EN = 1; /* fifo control - must be 1 */
487 csr1_r.fld.FLD_CRPT_EVE = 1; /* writing a 1 clears flags */
488 csr1_r.fld.FLD_CRPT_ODD = 1;
490 WriteMReg((dt3155_lbase[minor] + CSR1),csr1_r.reg);
492 /* Enable interrupts at the end of each field */
495 int_csr_r.fld.FLD_END_EVE_EN = 1;
496 int_csr_r.fld.FLD_END_ODD_EN = 1;
497 int_csr_r.fld.FLD_START_EN = 0;
499 WriteMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
501 /* start internal BUSY bits */
503 ReadI2C(dt3155_lbase[minor], CSR2, &i2c_csr2.reg);
504 i2c_csr2.fld.BUSY_ODD = 1;
505 i2c_csr2.fld.BUSY_EVE = 1;
506 WriteI2C(dt3155_lbase[minor], CSR2, i2c_csr2.reg);
508 /* Now its up to the interrupt routine!! */
514 /*****************************************************
517 *****************************************************/
518 static int dt3155_ioctl(struct inode *inode,
523 int minor = MINOR(inode->i_rdev); /* What device are we ioctl()'ing? */
525 if (minor >= MAXBOARDS || minor < 0)
528 /* make sure it is valid command */
529 if (_IOC_NR(cmd) > DT3155_IOC_MAXNR)
531 printk("DT3155: invalid IOCTL(0x%x)\n",cmd);
532 printk("DT3155: Valid commands (0x%x), (0x%x), (0x%x), (0x%x), (0x%x)\n",
533 (unsigned int)DT3155_GET_CONFIG,
534 (unsigned int)DT3155_SET_CONFIG,
535 (unsigned int)DT3155_START,
536 (unsigned int)DT3155_STOP,
537 (unsigned int)DT3155_FLUSH);
543 case DT3155_SET_CONFIG:
545 if (dt3155_status[minor].state != DT3155_STATE_IDLE)
549 struct dt3155_config tmp;
550 if (copy_from_user((void *)&tmp, (void *) arg, sizeof(tmp)))
552 /* check for valid settings */
553 if (tmp.rows > DT3155_MAX_ROWS ||
554 tmp.cols > DT3155_MAX_COLS ||
555 (tmp.acq_mode != DT3155_MODE_FRAME &&
556 tmp.acq_mode != DT3155_MODE_FIELD) ||
557 (tmp.continuous != DT3155_SNAP &&
558 tmp.continuous != DT3155_ACQ))
562 dt3155_status[minor].config = tmp;
566 case DT3155_GET_CONFIG:
568 if (copy_to_user((void *) arg, (void *) &dt3155_status[minor],
569 sizeof(struct dt3155_status)))
573 case DT3155_FLUSH: /* Flushes the buffers -- ensures fresh data */
575 if (dt3155_status[minor].state != DT3155_STATE_IDLE)
577 return dt3155_flush(minor);
581 if (dt3155_status[minor].state & DT3155_STATE_STOP ||
582 dt3155_status[minor].fbuffer.stop_acquire)
585 if (dt3155_status[minor].state == DT3155_STATE_IDLE)
589 if (copy_to_user((void *) arg, (void *) &dt3155_status[minor],
590 sizeof(struct dt3155_status)))
596 if (dt3155_status[minor].state != DT3155_STATE_IDLE)
599 dt3155_status[minor].fbuffer.stop_acquire = 0;
600 dt3155_status[minor].fbuffer.frame_count = 0;
602 /* Set the MODE in the status -- we default to FRAME */
603 if (dt3155_status[minor].config.acq_mode == DT3155_MODE_FIELD)
605 dt3155_status[minor].state = DT3155_STATE_FLD;
609 dt3155_status[minor].state = DT3155_STATE_FRAME;
612 dt3155_init_isr(minor);
613 if (copy_to_user((void *) arg, (void *) &dt3155_status[minor],
614 sizeof(struct dt3155_status)))
620 printk("DT3155: invalid IOCTL(0x%x)\n",cmd);
621 printk("DT3155: Valid commands (0x%x), (0x%x), (0x%x), (0x%x), (0x%x)\n",
622 (unsigned int)DT3155_GET_CONFIG,
623 (unsigned int)DT3155_SET_CONFIG,
624 DT3155_START, DT3155_STOP, DT3155_FLUSH);
631 /*****************************************************
634 * only allow the user to mmap the registers and buffer
635 * It is quite possible that this is broken, since the
636 * addition of of the capacity for two cards!!!!!!!!
637 * It *looks* like it should work but since I'm not
638 * sure how to use it, I'm not actually sure. (NJC? ditto by SS)
639 *****************************************************/
640 static int dt3155_mmap (struct file * file, struct vm_area_struct * vma)
642 /* which device are we mmapping? */
643 int minor = MINOR(file->f_dentry->d_inode->i_rdev);
644 unsigned long offset;
645 offset = vma->vm_pgoff << PAGE_SHIFT;
647 if (offset >= __pa(high_memory) || (file->f_flags & O_SYNC))
648 vma->vm_flags |= VM_IO;
650 /* Don't try to swap out physical pages.. */
651 vma->vm_flags |= VM_RESERVED;
653 /* they are mapping the registers or the buffer */
654 if ((offset == dt3155_status[minor].reg_addr &&
655 vma->vm_end - vma->vm_start == PCI_PAGE_SIZE) ||
656 (offset == dt3155_status[minor].mem_addr &&
657 vma->vm_end - vma->vm_start == dt3155_status[minor].mem_size))
659 if (remap_pfn_range(vma,
661 offset >> PAGE_SHIFT,
662 vma->vm_end - vma->vm_start,
663 vma->vm_page_prot)) {
664 printk("DT3155: remap_page_range() failed.\n");
670 printk("DT3155: dt3155_mmap() bad call.\n");
678 /*****************************************************
681 * Our special open code.
682 * MOD_INC_USE_COUNT make sure that the driver memory is not freed
683 * while the device is in use.
684 *****************************************************/
685 static int dt3155_open(struct inode* inode, struct file* filep)
687 int minor = MINOR(inode->i_rdev); /* what device are we opening? */
688 if (dt3155_dev_open[minor]) {
689 printk ("DT3155: Already opened by another process.\n");
693 if (dt3155_status[minor].device_installed==0)
695 printk("DT3155 Open Error: No such device dt3155 minor number %d\n",
700 if (dt3155_status[minor].state != DT3155_STATE_IDLE) {
701 printk ("DT3155: Not in idle state (state = %x)\n",
702 dt3155_status[minor].state);
706 printk("DT3155: Device opened.\n");
708 dt3155_dev_open[minor] = 1 ;
712 /* Disable ALL interrupts */
714 WriteMReg((dt3155_lbase[minor] + INT_CSR), int_csr_r.reg);
716 init_waitqueue_head(&(dt3155_read_wait_queue[minor]));
722 /*****************************************************
725 * Now decrement the use count.
727 *****************************************************/
728 static int dt3155_close(struct inode *inode, struct file *filep)
732 minor = MINOR(inode->i_rdev); /* which device are we closing */
733 if (!dt3155_dev_open[minor])
735 printk("DT3155: attempt to CLOSE a not OPEN device\n");
739 dt3155_dev_open[minor] = 0;
741 if (dt3155_status[minor].state != DT3155_STATE_IDLE)
749 /*****************************************************
752 *****************************************************/
753 static ssize_t dt3155_read(struct file *filep, char __user *buf,
754 size_t count, loff_t *ppos)
756 /* which device are we reading from? */
757 int minor = MINOR(filep->f_dentry->d_inode->i_rdev);
760 struct frame_info *frame_info;
762 /* TODO: this should check the error flag and */
763 /* return an error on hardware failures */
764 if (count != sizeof(struct dt3155_read))
766 printk("DT3155 ERROR (NJC): count is not right\n");
771 /* Hack here -- I'm going to allow reading even when idle.
772 * this is so that the frames can be read after STOP has
773 * been called. Leaving it here, commented out, as a reminder
774 * for a short while to make sure there are no problems.
775 * Note that if the driver is not opened in non_blocking mode,
776 * and the device is idle, then it could sit here forever! */
778 /* if (dt3155_status[minor].state == DT3155_STATE_IDLE)*/
781 /* non-blocking reads should return if no data */
782 if (filep->f_flags & O_NDELAY)
784 if ((frame_index = dt3155_get_ready_buffer(minor)) < 0) {
785 /*printk("dt3155: no buffers available (?)\n");*/
786 /* printques(minor); */
793 * sleep till data arrives , or we get interrupted.
794 * Note that wait_event_interruptible() does not actually
795 * sleep/wait if it's condition evaluates to true upon entry.
797 wait_event_interruptible(dt3155_read_wait_queue[minor],
798 (frame_index = dt3155_get_ready_buffer(minor))
803 printk ("DT3155: read: interrupted\n");
810 frame_info = &dt3155_status[minor].fbuffer.frame_info[frame_index];
812 /* make this an offset */
813 offset = frame_info->addr - dt3155_status[minor].mem_addr;
815 put_user(offset, (unsigned int *) buf);
817 put_user(dt3155_status[minor].fbuffer.frame_count, (unsigned int *) buf);
819 put_user(dt3155_status[minor].state, (unsigned int *) buf);
821 if (copy_to_user(buf, frame_info, sizeof(*frame_info)))
824 return sizeof(struct dt3155_read);
827 static unsigned int dt3155_poll (struct file * filp, poll_table *wait)
829 int minor = MINOR(filp->f_dentry->d_inode->i_rdev);
831 if (!is_ready_buf_empty(minor))
832 return POLLIN | POLLRDNORM;
834 poll_wait (filp, &dt3155_read_wait_queue[minor], wait);
840 dt3155_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
845 ret = dt3155_ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
851 /*****************************************************
852 * file operations supported by DT3155 driver
853 * needed by init_module
855 *****************************************************/
856 static struct file_operations dt3155_fops = {
858 .unlocked_ioctl = dt3155_unlocked_ioctl,
862 .release = dt3155_close
866 /*****************************************************
869 * PCI has been totally reworked in 2.1..
870 *****************************************************/
871 static int find_PCI (void)
873 struct pci_dev *pci_dev = NULL;
874 int error, pci_index = 0;
875 unsigned short rev_device;
879 while ((pci_dev = pci_get_device
880 (DT3155_VENDORID, DT3155_DEVICEID, pci_dev)) != NULL)
884 /* Is it really there? */
886 pci_read_config_word(pci_dev, PCI_CLASS_DEVICE, &rev_device)))
890 DT_3155_DEBUG_MSG("DT3155: Device number %d \n", pci_index);
892 /* Make sure the driver was compiled with enough buffers to handle
894 if (pci_index > MAXBOARDS) {
895 printk("DT3155: ERROR - found %d devices, but driver only configured "
897 "DT3155: Please change MAXBOARDS in dt3155.h\n",
898 pci_index, MAXBOARDS);
902 /* Now, just go out and make sure that this/these device(s) is/are
903 actually mapped into the kernel address space */
904 if ((error = pci_read_config_dword(pci_dev, PCI_BASE_ADDRESS_0,
907 printk("DT3155: Was not able to find device \n");
911 DT_3155_DEBUG_MSG("DT3155: Base address 0 for device is %lx \n", base);
912 dt3155_status[pci_index-1].reg_addr = base;
914 /* Remap the base address to a logical address through which we
916 dt3155_lbase[pci_index - 1] = ioremap(base,PCI_PAGE_SIZE);
917 dt3155_status[pci_index - 1].reg_addr = base;
918 DT_3155_DEBUG_MSG("DT3155: New logical address is %p \n",
919 dt3155_lbase[pci_index-1]);
920 if (!dt3155_lbase[pci_index-1])
922 printk("DT3155: Unable to remap control registers\n");
926 if ((error = pci_read_config_byte(pci_dev, PCI_INTERRUPT_LINE, &irq)))
928 printk("DT3155: Was not able to find device \n");
932 DT_3155_DEBUG_MSG("DT3155: IRQ is %d \n",irq);
933 dt3155_status[pci_index-1].irq = irq;
934 /* Set flag: kth device found! */
935 dt3155_status[pci_index-1].device_installed = 1;
936 printk("DT3155: Installing device %d w/irq %d and address %p\n",
938 dt3155_status[pci_index-1].irq,
939 dt3155_lbase[pci_index-1]);
942 ndevices = pci_index;
944 return DT_3155_SUCCESS;
947 pci_dev_put(pci_dev);
948 return DT_3155_FAILURE;
951 u32 allocatorAddr = 0;
953 /*****************************************************
955 *****************************************************/
956 int init_module(void)
960 char *devname[MAXBOARDS];
962 devname[0] = "dt3155a";
964 devname[1] = "dt3155b";
967 printk("DT3155: Loading module...\n");
969 /* Register the device driver */
970 rcode = register_chrdev(dt3155_major, "dt3155", &dt3155_fops);
973 printk(KERN_INFO "DT3155: register_chrdev failed \n");
977 if(dt3155_major == 0)
978 dt3155_major = rcode; /* dynamic */
981 /* init the status variables. */
982 /* DMA memory is taken care of in setup_buffers() */
983 for (index = 0; index < MAXBOARDS; index++)
985 dt3155_status[index].config.acq_mode = DT3155_MODE_FRAME;
986 dt3155_status[index].config.continuous = DT3155_ACQ;
987 dt3155_status[index].config.cols = DT3155_MAX_COLS;
988 dt3155_status[index].config.rows = DT3155_MAX_ROWS;
989 dt3155_status[index].state = DT3155_STATE_IDLE;
991 /* find_PCI() will check if devices are installed; */
992 /* first assume they're not: */
993 dt3155_status[index].mem_addr = 0;
994 dt3155_status[index].mem_size = 0;
995 dt3155_status[index].state = DT3155_STATE_IDLE;
996 dt3155_status[index].device_installed = 0;
999 /* Now let's find the hardware. find_PCI() will set ndevices to the
1000 * number of cards found in this machine. */
1002 if ((rcode = find_PCI()) != DT_3155_SUCCESS)
1004 printk("DT3155 error: find_PCI() failed to find dt3155 board(s)\n");
1005 unregister_chrdev(dt3155_major, "dt3155");
1010 /* Ok, time to setup the frame buffers */
1011 if((rcode = dt3155_setup_buffers(&allocatorAddr)) < 0)
1013 printk("DT3155: Error: setting up buffer not large enough.");
1014 unregister_chrdev(dt3155_major, "dt3155");
1018 /* If we are this far, then there is enough RAM */
1019 /* for the buffers: Print the configuration. */
1020 for( index = 0; index < ndevices; index++)
1022 printk("DT3155: Device = %d; acq_mode = %d; "
1023 "continuous = %d; cols = %d; rows = %d;\n",
1025 dt3155_status[index].config.acq_mode,
1026 dt3155_status[index].config.continuous,
1027 dt3155_status[index].config.cols,
1028 dt3155_status[index].config.rows);
1029 printk("DT3155: m_addr = 0x%x; m_size = %ld; "
1030 "state = %d; device_installed = %d\n",
1031 dt3155_status[index].mem_addr,
1032 (long int)dt3155_status[index].mem_size,
1033 dt3155_status[index].state,
1034 dt3155_status[index].device_installed);
1037 /* Disable ALL interrupts */
1039 for( index = 0; index < ndevices; index++)
1041 WriteMReg((dt3155_lbase[index] + INT_CSR), int_csr_r.reg);
1042 if(dt3155_status[index].device_installed)
1045 * This driver *looks* like it can handle sharing interrupts,
1046 * but I can't actually test myself. I've had reports that it
1047 * DOES work so I'll enable it for now. This comment will remain
1048 * as a reminder in case any problems arise. (SS)
1050 /* in older kernels flags are: SA_SHIRQ | SA_INTERRUPT */
1051 rcode = request_irq(dt3155_status[index].irq, (void *)dt3155_isr,
1052 IRQF_SHARED | IRQF_DISABLED, devname[index],
1053 (void*) &dt3155_status[index]);
1056 printk("DT3155: minor %d request_irq failed for IRQ %d\n",
1057 index, dt3155_status[index].irq);
1058 unregister_chrdev(dt3155_major, "dt3155");
1064 printk("DT3155: finished loading\n");
1069 /*****************************************************
1070 * cleanup_module(void)
1072 *****************************************************/
1073 void cleanup_module(void)
1077 printk("DT3155: cleanup_module called\n");
1079 /* removed DMA allocated with the allocator */
1080 #ifdef STANDALONE_ALLOCATOR
1081 if (allocatorAddr != 0)
1082 allocator_free_dma(allocatorAddr);
1084 allocator_cleanup();
1087 unregister_chrdev(dt3155_major, "dt3155");
1089 for(index = 0; index < ndevices; index++)
1091 if(dt3155_status[index].device_installed == 1)
1093 printk("DT3155: Freeing irq %d for device %d\n",
1094 dt3155_status[index].irq, index);
1095 free_irq(dt3155_status[index].irq, (void*)&dt3155_status[index]);