projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: Yet another (third) dt3155 driver PCI/video4linux compliant
[deliverable/linux.git] / drivers / staging / dt3155v4l / dt3155v4l.c
CommitLineData
d42bffb8
MM		 1#include <media/v4l2-dev.h>
2#include <media/videobuf-core.h>
3#include <media/v4l2-ioctl.h>
4#include <linux/pci.h>
5#include <linux/version.h>
6#include <linux/stringify.h>
7#include <media/videobuf-dma-contig.h>
8#include <linux/kthread.h>
9
10#include "dt3155v4l.h"
11#include "dt3155-bufs.h"
12
13#define DT3155_VENDOR_ID 0x8086
14#define DT3155_DEVICE_ID 0x1223
15
16/* global initializers (for all boards) */
17#ifdef CONFIG_DT3155_CCIR
18static const u8 csr2_init = VT_50HZ;
19#define DT3155_CURRENT_NORM V4L2_STD_625_50
20static const unsigned int img_width = 768;
21static const unsigned int img_height = 576;
22static const unsigned int frames_per_sec = 25;
23static const struct v4l2_fmtdesc frame_std[] = {
24 {
25 .index = 0,
26 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
27 .flags = 0,
28 .description = "CCIR/50Hz 8 bits gray",
29 .pixelformat = V4L2_PIX_FMT_GREY,
30 },
31};
32#else
33static const u8 csr2_init = VT_60HZ;
34#define DT3155_CURRENT_NORM V4L2_STD_525_60
35static const unsigned int img_width = 640;
36static const unsigned int img_height = 480;
37static const unsigned int frames_per_sec = 30;
38static const struct v4l2_fmtdesc frame_std[] = {
39 {
40 .index = 0,
41 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
42 .flags = 0,
43 .description = "RS-170/60Hz 8 bits gray",
44 .pixelformat = V4L2_PIX_FMT_GREY,
45 },
46};
47#endif
48
49#define NUM_OF_FORMATS ARRAY_SIZE(frame_std)
50
51static u8 config_init = ACQ_MODE_EVEN;
52
53/**
54 * read_i2c_reg - reads an internal i2c register
55 *
56 * @addr: dt3155 mmio base address
57 * @index: index (internal address) of register to read
58 * @data: pointer to byte the read data will be placed in
59 *
60 * returns: zero on success or error code
61 *
62 * This function starts reading the specified (by index) register
63 * and busy waits for the process to finish. The result is placed
64 * in a byte pointed by data.
65 */
66static int
67read_i2c_reg(void *addr, u8 index, u8 *data)
68{
69 u32 tmp = index;
70
71 iowrite32((tmp<<17) | IIC_READ, addr + IIC_CSR2);
72 mmiowb();
73 udelay(45); /* wait at least 43 usec for NEW_CYCLE to clear */
74 if (ioread32(addr + IIC_CSR2) & NEW_CYCLE) {
75 /* error: NEW_CYCLE not cleared */
76 printk(KERN_ERR "dt3155: NEW_CYCLE not cleared\n");
77 return -EIO;
78 }
79 tmp = ioread32(addr + IIC_CSR1);
80 if (tmp & DIRECT_ABORT) {
81 /* error: DIRECT_ABORT set */
82 printk(KERN_ERR "dt3155: DIRECT_ABORT set\n");
83 /* reset DIRECT_ABORT bit */
84 iowrite32(DIRECT_ABORT, addr + IIC_CSR1);
85 return -EIO;
86 }
87 *data = tmp>>24;
88 return 0;
89}
90
91/**
92 * write_i2c_reg - writes to an internal i2c register
93 *
94 * @addr: dt3155 mmio base address
95 * @index: index (internal address) of register to read
96 * @data: data to be written
97 *
98 * returns: zero on success or error code
99 *
100 * This function starts writting the specified (by index) register
101 * and busy waits for the process to finish.
102 */
103static int
104write_i2c_reg(void *addr, u8 index, u8 data)
105{
106 u32 tmp = index;
107
108 iowrite32((tmp<<17) | IIC_WRITE | data, addr + IIC_CSR2);
109 mmiowb();
110 udelay(65); /* wait at least 63 usec for NEW_CYCLE to clear */
111 if (ioread32(addr + IIC_CSR2) & NEW_CYCLE) {
112 /* error: NEW_CYCLE not cleared */
113 printk(KERN_ERR "dt3155: NEW_CYCLE not cleared\n");
114 return -EIO;
115 }
116 if (ioread32(addr + IIC_CSR1) & DIRECT_ABORT) {
117 /* error: DIRECT_ABORT set */
118 printk(KERN_ERR "dt3155: DIRECT_ABORT set\n");
119 /* reset DIRECT_ABORT bit */
120 iowrite32(DIRECT_ABORT, addr + IIC_CSR1);
121 return -EIO;
122 }
123 return 0;
124}
125
126/**
127 * write_i2c_reg_nowait - writes to an internal i2c register
128 *
129 * @addr: dt3155 mmio base address
130 * @index: index (internal address) of register to read
131 * @data: data to be written
132 *
133 * This function starts writting the specified (by index) register
134 * and then returns.
135 */
136void
137write_i2c_reg_nowait(void *addr, u8 index, u8 data)
138{
139 u32 tmp = index;
140
141 iowrite32((tmp<<17) | IIC_WRITE | data, addr + IIC_CSR2);
142 mmiowb();
143}
144
145/**
146 * wait_i2c_reg - waits the read/write to finish
147 *
148 * @addr: dt3155 mmio base address
149 *
150 * returns: zero on success or error code
151 *
152 * This function waits reading/writting to finish.
153 */
154static int
155wait_i2c_reg(void *addr)
156{
157 if (ioread32(addr + IIC_CSR2) & NEW_CYCLE)
158 udelay(65); /* wait at least 63 usec for NEW_CYCLE to clear */
159 if (ioread32(addr + IIC_CSR2) & NEW_CYCLE) {
160 /* error: NEW_CYCLE not cleared */
161 printk(KERN_ERR "dt3155: NEW_CYCLE not cleared\n");
162 return -EIO;
163 }
164 if (ioread32(addr + IIC_CSR1) & DIRECT_ABORT) {
165 /* error: DIRECT_ABORT set */
166 printk(KERN_ERR "dt3155: DIRECT_ABORT set\n");
167 /* reset DIRECT_ABORT bit */
168 iowrite32(DIRECT_ABORT, addr + IIC_CSR1);
169 return -EIO;
170 }
171 return 0;
172}
173
174/*
175 * global pointers to a list of 4MB chunks reserved at driver
176 * load, broken down to contiguous buffers of 768 * 576 bytes
177 * each to form a pool of buffers for allocations
178 * FIXME: add spinlock to protect moves between alloc/free lists
179 */
180static struct dt3155_fifo *dt3155_chunks; /* list of 4MB chuncks */
181static struct dt3155_fifo *dt3155_free_bufs; /* list of free buffers */
182static struct dt3155_fifo *dt3155_alloc_bufs; /* list of allocated buffers */
183
184/* same as in <drivers/media/video/videobuf-dma-contig.c> */
185struct videobuf_dma_contig_memory {
186 u32 magic;
187 void *vaddr;
188 dma_addr_t dma_handle;
189 unsigned long size;
190 int is_userptr;
191};
192
193#define MAGIC_DC_MEM 0x0733ac61
194#define MAGIC_CHECK(is, should) \
195 if (unlikely((is) != (should))) { \
196 pr_err("magic mismatch: %x expected %x\n", (is), (should)); \
197 BUG(); \
198 }
199
200/* helper functions to allocate/free buffers from the pool */
201static void *
202dt3155_alloc_buffer(struct device *dev, size_t size, dma_addr_t *dma_handle,
203 gfp_t flag)
204{
205 struct dt3155_buf *buf;
206
207 if (size > DT3155_BUF_SIZE)
208 return NULL;
209 size = DT3155_BUF_SIZE; /* same for CCIR & RS-170 */
210 buf = dt3155_get_buf(dt3155_free_bufs);
211 if (!buf)
212 return NULL;
213 buf->dma = dma_map_single(dev, buf->cpu, size, DMA_FROM_DEVICE);
214 if (dma_mapping_error(dev, buf->dma)) {
215 dt3155_put_buf(buf, dt3155_free_bufs);
216 return NULL;
217 }
218 dt3155_put_buf(buf, dt3155_alloc_bufs);
219 *dma_handle = buf->dma;
220 return buf->cpu;
221}
222
223static void
224dt3155_free_buffer(struct device *dev, size_t size, void *cpu_addr,
225 dma_addr_t dma_handle)
226{
227 struct dt3155_buf *buf, *last;
228 int found = 0;
229
230 if (!cpu_addr) /* to free NULL is OK */
231 return;
232 last = dt3155_get_buf(dt3155_alloc_bufs);
233 if (!last) {
234 printk(KERN_ERR "dt3155: %s(): no alloc buffers\n", __func__);
235 return;
236 }
237 dt3155_put_buf(last, dt3155_alloc_bufs);
238 do {
239 buf = dt3155_get_buf(dt3155_alloc_bufs);
240 if (buf->cpu == cpu_addr && buf->dma == dma_handle) {
241 found = 1;
242 break;
243 }
244 dt3155_put_buf(buf, dt3155_alloc_bufs);
245 } while (buf != last);
246 if (!found) {
247 printk(KERN_ERR "dt3155: %s(): buffer not found\n", __func__);
248 return;
249 }
250 size = DT3155_BUF_SIZE; /* same for CCIR & RS-170 */
251 dma_unmap_single(dev, dma_handle, size, DMA_FROM_DEVICE);
252 dt3155_put_buf(buf, dt3155_free_bufs);
253}
254
255/* same as videobuf_dma_contig_user_get() */
256static int
257dt3155_dma_contig_user_get(struct videobuf_dma_contig_memory *mem,
258 struct videobuf_buffer *vb)
259{
260 struct mm_struct *mm = current->mm;
261 struct vm_area_struct *vma;
262 unsigned long prev_pfn, this_pfn;
263 unsigned long pages_done, user_address;
264 int ret;
265
266 mem->size = PAGE_ALIGN(vb->size);
267 mem->is_userptr = 0;
268 ret = -EINVAL;
269
270 down_read(&mm->mmap_sem);
271
272 vma = find_vma(mm, vb->baddr);
273 if (!vma)
274 goto out_up;
275
276 if ((vb->baddr + mem->size) > vma->vm_end)
277 goto out_up;
278
279 pages_done = 0;
280 prev_pfn = 0; /* kill warning */
281 user_address = vb->baddr;
282
283 while (pages_done < (mem->size >> PAGE_SHIFT)) {
284 ret = follow_pfn(vma, user_address, &this_pfn);
285 if (ret)
286 break;
287
288 if (pages_done == 0)
289 mem->dma_handle = this_pfn << PAGE_SHIFT;
290 else if (this_pfn != (prev_pfn + 1))
291 ret = -EFAULT;
292
293 if (ret)
294 break;
295
296 prev_pfn = this_pfn;
297 user_address += PAGE_SIZE;
298 pages_done++;
299 }
300
301 if (!ret)
302 mem->is_userptr = 1;
303
304 out_up:
305 up_read(&current->mm->mmap_sem);
306
307 return ret;
308}
309
310/* same as videobuf_dma_contig_user_put() */
311static void
312dt3155_dma_contig_user_put(struct videobuf_dma_contig_memory *mem)
313{
314 mem->is_userptr = 0;
315 mem->dma_handle = 0;
316 mem->size = 0;
317}
318
319/* same as videobuf_iolock() but uses allocations from the pool */
320static int
321dt3155_iolock(struct videobuf_queue *q, struct videobuf_buffer *vb,
322 struct v4l2_framebuffer *fbuf)
323{
324 struct videobuf_dma_contig_memory *mem = vb->priv;
325
326 BUG_ON(!mem);
327 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
328
329 switch (vb->memory) {
330 case V4L2_MEMORY_MMAP:
331 dev_dbg(q->dev, "%s memory method MMAP\n", __func__);
332
333 /* All handling should be done by __videobuf_mmap_mapper() */
334 if (!mem->vaddr) {
335 dev_err(q->dev, "memory is not alloced/mmapped.\n");
336 return -EINVAL;
337 }
338 break;
339 case V4L2_MEMORY_USERPTR:
340 dev_dbg(q->dev, "%s memory method USERPTR\n", __func__);
341
342 /* handle pointer from user space */
343 if (vb->baddr)
344 return dt3155_dma_contig_user_get(mem, vb);
345
346 /* allocate memory for the read() method */
347 mem->size = PAGE_ALIGN(vb->size);
348 mem->vaddr = dt3155_alloc_buffer(q->dev, mem->size,
349 &mem->dma_handle, GFP_KERNEL);
350 if (!mem->vaddr) {
351 dev_err(q->dev, "dma_alloc_coherent %ld failed\n",
352 mem->size);
353 return -ENOMEM;
354 }
355
356 dev_dbg(q->dev, "dma_alloc_coherent data is at %p (%ld)\n",
357 mem->vaddr, mem->size);
358 break;
359 case V4L2_MEMORY_OVERLAY:
360 default:
361 dev_dbg(q->dev, "%s memory method OVERLAY/unknown\n",
362 __func__);
363 return -EINVAL;
364 }
365
366 return 0;
367}
368
369/* same as videobuf_dma_contig_free() but uses the pool */
370void
371dt3155_dma_contig_free(struct videobuf_queue *q, struct videobuf_buffer *buf)
372{
373 struct videobuf_dma_contig_memory *mem = buf->priv;
374
375 /* mmapped memory can't be freed here, otherwise mmapped region
376 would be released, while still needed. In this case, the memory
377 release should happen inside videobuf_vm_close().
378 So, it should free memory only if the memory were allocated for
379 read() operation.
380 */
381 if (buf->memory != V4L2_MEMORY_USERPTR)
382 return;
383
384 if (!mem)
385 return;
386
387 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
388
389 /* handle user space pointer case */
390 if (buf->baddr) {
391 dt3155_dma_contig_user_put(mem);
392 return;
393 }
394
395 /* read() method */
396 dt3155_free_buffer(q->dev, mem->size, mem->vaddr, mem->dma_handle);
397 mem->vaddr = NULL;
398}
399
400/* same as videobuf_vm_open() */
401static void
402dt3155_vm_open(struct vm_area_struct *vma)
403{
404 struct videobuf_mapping *map = vma->vm_private_data;
405
406 dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n",
407 map, map->count, vma->vm_start, vma->vm_end);
408
409 map->count++;
410}
411
412/* same as videobuf_vm_close(), but free to the pool */
413static void
414dt3155_vm_close(struct vm_area_struct *vma)
415{
416 struct videobuf_mapping *map = vma->vm_private_data;
417 struct videobuf_queue *q = map->q;
418 int i;
419
420 dev_dbg(map->q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n",
421 map, map->count, vma->vm_start, vma->vm_end);
422
423 map->count--;
424 if (0 == map->count) {
425 struct videobuf_dma_contig_memory *mem;
426
427 dev_dbg(map->q->dev, "munmap %p q=%p\n", map, q);
428 mutex_lock(&q->vb_lock);
429
430 /* We need first to cancel streams, before unmapping */
431 if (q->streaming)
432 videobuf_queue_cancel(q);
433
434 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
435 if (NULL == q->bufs[i])
436 continue;
437
438 if (q->bufs[i]->map != map)
439 continue;
440
441 mem = q->bufs[i]->priv;
442 if (mem) {
443 /* This callback is called only if kernel has
444 allocated memory and this memory is mmapped.
445 In this case, memory should be freed,
446 in order to do memory unmap.
447 */
448
449 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
450
451 /* vfree is not atomic - can't be
452 called with IRQ's disabled
453 */
454 dev_dbg(map->q->dev, "buf[%d] freeing %p\n",
455 i, mem->vaddr);
456
457 dt3155_free_buffer(q->dev, mem->size,
458 mem->vaddr, mem->dma_handle);
459 mem->vaddr = NULL;
460 }
461
462 q->bufs[i]->map = NULL;
463 q->bufs[i]->baddr = 0;
464 }
465
466 kfree(map);
467
468 mutex_unlock(&q->vb_lock);
469 }
470}
471
472static const struct vm_operations_struct dt3155_vm_ops = {
473 .open = dt3155_vm_open,
474 .close = dt3155_vm_close,
475};
476
477/* same as videobuf_mmap_mapper(), but allocates from the pool */
478static int
479dt3155_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma)
480{
481 struct videobuf_dma_contig_memory *mem;
482 struct videobuf_mapping *map;
483 unsigned int first;
484 int retval;
485 unsigned long size, offset = vma->vm_pgoff << PAGE_SHIFT;
486
487 dev_dbg(q->dev, "%s\n", __func__);
488 if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
489 return -EINVAL;
490
491 /* look for first buffer to map */
492 for (first = 0; first < VIDEO_MAX_FRAME; first++) {
493 if (!q->bufs[first])
494 continue;
495
496 if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
497 continue;
498 if (q->bufs[first]->boff == offset)
499 break;
500 }
501 if (VIDEO_MAX_FRAME == first) {
502 dev_dbg(q->dev, "invalid user space offset [offset=0x%lx]\n",
503 offset);
504 return -EINVAL;
505 }
506
507 /* create mapping + update buffer list */
508 map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
509 if (!map)
510 return -ENOMEM;
511
512 q->bufs[first]->map = map;
513 map->start = vma->vm_start;
514 map->end = vma->vm_end;
515 map->q = q;
516
517 q->bufs[first]->baddr = vma->vm_start;
518
519 mem = q->bufs[first]->priv;
520 BUG_ON(!mem);
521 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
522
523 mem->size = PAGE_ALIGN(q->bufs[first]->bsize);
524 mem->vaddr = dt3155_alloc_buffer(q->dev, mem->size,
525 &mem->dma_handle, GFP_KERNEL);
526 if (!mem->vaddr) {
527 dev_err(q->dev, "dma_alloc_coherent size %ld failed\n",
528 mem->size);
529 goto error;
530 }
531 dev_dbg(q->dev, "dma_alloc_coherent data is at addr %p (size %ld)\n",
532 mem->vaddr, mem->size);
533
534 /* Try to remap memory */
535
536 size = vma->vm_end - vma->vm_start;
537 size = (size < mem->size) ? size : mem->size;
538
539 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
540 retval = remap_pfn_range(vma, vma->vm_start,
541 mem->dma_handle >> PAGE_SHIFT,
542 size, vma->vm_page_prot);
543 if (retval) {
544 dev_err(q->dev, "mmap: remap failed with error %d. ", retval);
545 dt3155_free_buffer(q->dev, mem->size,
546 mem->vaddr, mem->dma_handle);
547 goto error;
548 }
549
550 vma->vm_ops = &dt3155_vm_ops;
551 vma->vm_flags |= VM_DONTEXPAND;
552 vma->vm_private_data = map;
553
554 dev_dbg(q->dev, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
555 map, q, vma->vm_start, vma->vm_end,
556 (long int) q->bufs[first]->bsize,
557 vma->vm_pgoff, first);
558
559 dt3155_vm_open(vma);
560
561 return 0;
562
563error:
564 kfree(map);
565 return -ENOMEM;
566}
567
568static int
569dt3155_sync_for_cpu(struct videobuf_queue *q, struct videobuf_buffer *vb)
570{
571 struct dt3155_priv *pd = q->priv_data;
572 struct videobuf_dma_contig_memory *mem = vb->priv;
573
574 BUG_ON(!mem);
575 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
576
577 pci_dma_sync_single_for_cpu(pd->pdev, mem->dma_handle,
578 mem->size, PCI_DMA_FROMDEVICE);
579 return 0;
580}
581
582static int
583dt3155_sync_for_device(struct videobuf_queue *q, struct videobuf_buffer *vb)
584{
585 struct dt3155_priv *pd = q->priv_data;
586 struct videobuf_dma_contig_memory *mem = vb->priv;
587
588 BUG_ON(!mem);
589 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
590
591 pci_dma_sync_single_for_device(pd->pdev, mem->dma_handle,
592 mem->size, PCI_DMA_FROMDEVICE);
593 return 0;
594}
595
596/*
597 * same as videobuf_queue_dma_contig_init(), but after
598 * initialisation overwrites videobuf_iolock() and
599 * videobuf_mmap_mapper() with our customized versions
600 * as well as adds sync() method
601 */
602static void
603dt3155_queue_dma_contig_init(struct videobuf_queue *q,
604 struct videobuf_queue_ops *ops,
605 struct device *dev,
606 spinlock_t *irqlock,
607 enum v4l2_buf_type type,
608 enum v4l2_field field,
609 unsigned int msize,
610 void *priv)
611{
612 videobuf_queue_dma_contig_init(q, ops, dev, irqlock,
613 type, field, msize, priv);
614 /* overwrite with our methods */
615 q->int_ops->iolock = dt3155_iolock;
616 q->int_ops->mmap_mapper = dt3155_mmap_mapper;
617 q->int_ops->sync = dt3155_sync_for_cpu;
618}
619
620static int
621dt3155_start_acq(struct dt3155_priv *pd)
622{
623 struct videobuf_buffer *vb = pd->curr_buf;
624 dma_addr_t dma_addr;
625
626 dma_addr = videobuf_to_dma_contig(vb);
627 iowrite32(dma_addr, pd->regs + EVEN_DMA_START);
628 iowrite32(dma_addr + vb->width, pd->regs + ODD_DMA_START);
629 iowrite32(vb->width, pd->regs + EVEN_DMA_STRIDE);
630 iowrite32(vb->width, pd->regs + ODD_DMA_STRIDE);
631 /* enable interrupts, clear all irq flags */
632 iowrite32(FLD_START_EN | FLD_END_ODD_EN | FLD_START |
633 FLD_END_EVEN | FLD_END_ODD, pd->regs + INT_CSR);
634 iowrite32(FIFO_EN | SRST | FLD_CRPT_ODD | FLD_CRPT_EVEN |
635 FLD_DN_ODD | FLD_DN_EVEN | CAP_CONT_EVEN | CAP_CONT_ODD,
636 pd->regs + CSR1);
637 wait_i2c_reg(pd->regs);
638 write_i2c_reg(pd->regs, CONFIG, pd->config);
639 write_i2c_reg(pd->regs, EVEN_CSR, CSR_ERROR | CSR_DONE);
640 write_i2c_reg(pd->regs, ODD_CSR, CSR_ERROR | CSR_DONE);
641
642 /* start the board */
643 write_i2c_reg(pd->regs, CSR2, pd->csr2 | BUSY_EVEN | BUSY_ODD);
644 return 0; /* success */
645}
646
647static int
648dt3155_stop_acq(struct dt3155_priv *pd)
649{
650 int tmp;
651
652 /* stop the board */
653 wait_i2c_reg(pd->regs);
654 write_i2c_reg(pd->regs, CSR2, pd->csr2);
655
656 /* disable all irqs, clear all irq flags */
657 iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD, pd->regs + INT_CSR);
658 write_i2c_reg(pd->regs, EVEN_CSR, CSR_ERROR | CSR_DONE);
659 write_i2c_reg(pd->regs, ODD_CSR, CSR_ERROR | CSR_DONE);
660 tmp = ioread32(pd->regs + CSR1) & (FLD_CRPT_EVEN | FLD_CRPT_ODD);
661 if (tmp)
662 printk(KERN_ERR "dt3155: corrupted field %u\n", tmp);
663 iowrite32(FIFO_EN | SRST | FLD_CRPT_ODD | FLD_CRPT_EVEN |
664 FLD_DN_ODD | FLD_DN_EVEN | CAP_CONT_EVEN | CAP_CONT_ODD,
665 pd->regs + CSR1);
666 return 0;
667}
668
669/* Locking: Caller holds q->vb_lock */
670static int
671dt3155_buf_setup(struct videobuf_queue *q, unsigned int *count,
672 unsigned int *size)
673{
674 *size = img_width * img_height;
675 return 0;
676}
677
678/* Locking: Caller holds q->vb_lock */
679static int
680dt3155_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
681 enum v4l2_field field)
682{
683 int ret = 0;
684
685 vb->width = img_width;
686 vb->height = img_height;
687 vb->size = img_width * img_height;
688 vb->field = field;
689 if (vb->state == VIDEOBUF_NEEDS_INIT)
690 ret = videobuf_iolock(q, vb, NULL);
691 if (ret) {
692 vb->state = VIDEOBUF_ERROR;
693 printk(KERN_ERR "ERROR: videobuf_iolock() failed\n");
694 videobuf_dma_contig_free(q, vb);
695 } else
696 vb->state = VIDEOBUF_PREPARED;
697 return ret;
698}
699
700/* Locking: Caller holds q->vb_lock & q->irqlock */
701static void
702dt3155_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
703{
704 struct dt3155_priv *pd = q->priv_data;
705
706 if (vb->state != VIDEOBUF_NEEDS_INIT) {
707 vb->state = VIDEOBUF_QUEUED;
708 dt3155_sync_for_device(q, vb);
709 list_add_tail(&vb->queue, &pd->dmaq);
710 wake_up_interruptible_sync(&pd->do_dma);
711 } else
712 vb->state = VIDEOBUF_ERROR;
713}
714
715/* Locking: Caller holds q->vb_lock */
716static void
717dt3155_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
718{
719 if (vb->state == VIDEOBUF_ACTIVE)
720 videobuf_waiton(vb, 0, 0); /* FIXME: cannot be interrupted */
721 dt3155_dma_contig_free(q, vb);
722 vb->state = VIDEOBUF_NEEDS_INIT;
723}
724
725static struct videobuf_queue_ops vbq_ops = {
726 .buf_setup = dt3155_buf_setup,
727 .buf_prepare = dt3155_buf_prepare,
728 .buf_queue = dt3155_buf_queue,
729 .buf_release = dt3155_buf_release,
730};
731
732static irqreturn_t
733dt3155_irq_handler_even(int irq, void *dev_id)
734{
735 struct dt3155_priv *ipd = dev_id;
736 struct videobuf_buffer *ivb;
737 dma_addr_t dma_addr;
738 u32 tmp;
739
740 tmp = ioread32(ipd->regs + INT_CSR) & (FLD_START | FLD_END_ODD);
741 if (!tmp)
742 return IRQ_NONE; /* not our irq */
743 if ((tmp & FLD_START) && !(tmp & FLD_END_ODD)) {
744 iowrite32(FLD_START_EN | FLD_END_ODD_EN | FLD_START,
745 ipd->regs + INT_CSR);
746 ipd->field_count++;
747 return IRQ_HANDLED; /* start of field irq */
748 }
749 if ((tmp & FLD_START) && (tmp & FLD_END_ODD)) {
750 if (!ipd->stats.start_before_end++)
751 printk(KERN_ERR "dt3155: irq: START before END\n");
752 }
753 /* check for corrupted fields */
754/* write_i2c_reg(ipd->regs, EVEN_CSR, CSR_ERROR | CSR_DONE); */
755/* write_i2c_reg(ipd->regs, ODD_CSR, CSR_ERROR | CSR_DONE); */
756 tmp = ioread32(ipd->regs + CSR1) & (FLD_CRPT_EVEN | FLD_CRPT_ODD);
757 if (tmp) {
758 if (!ipd->stats.corrupted_fields++)
759 printk(KERN_ERR "dt3155: corrupted field %u\n", tmp);
760 iowrite32(FIFO_EN | SRST | FLD_CRPT_ODD | FLD_CRPT_EVEN |
761 FLD_DN_ODD | FLD_DN_EVEN |
762 CAP_CONT_EVEN | CAP_CONT_ODD,
763 ipd->regs + CSR1);
764 mmiowb();
765 }
766
767 spin_lock(&ipd->lock);
768 if (ipd->curr_buf && ipd->curr_buf->state == VIDEOBUF_ACTIVE) {
769 if (waitqueue_active(&ipd->curr_buf->done)) {
770 do_gettimeofday(&ipd->curr_buf->ts);
771 ipd->curr_buf->field_count = ipd->field_count;
772 ipd->curr_buf->state = VIDEOBUF_DONE;
773 wake_up(&ipd->curr_buf->done);
774 } else {
775 ivb = ipd->curr_buf;
776 goto load_dma;
777 }
778 } else
779 goto stop_dma;
780 if (list_empty(&ipd->dmaq))
781 goto stop_dma;
782 ivb = list_first_entry(&ipd->dmaq, typeof(*ivb), queue);
783 list_del(&ivb->queue);
784 if (ivb->state == VIDEOBUF_QUEUED) {
785 ivb->state = VIDEOBUF_ACTIVE;
786 ipd->curr_buf = ivb;
787 } else
788 goto stop_dma;
789load_dma:
790 dma_addr = videobuf_to_dma_contig(ivb);
791 iowrite32(dma_addr, ipd->regs + EVEN_DMA_START);
792 iowrite32(dma_addr + ivb->width, ipd->regs + ODD_DMA_START);
793 iowrite32(ivb->width, ipd->regs + EVEN_DMA_STRIDE);
794 iowrite32(ivb->width, ipd->regs + ODD_DMA_STRIDE);
795 mmiowb();
796 /* enable interrupts, clear all irq flags */
797 iowrite32(FLD_START_EN | FLD_END_ODD_EN | FLD_START |
798 FLD_END_EVEN | FLD_END_ODD, ipd->regs + INT_CSR);
799 spin_unlock(&ipd->lock);
800 return IRQ_HANDLED;
801
802stop_dma:
803 ipd->curr_buf = NULL;
804 /* stop the board */
805 write_i2c_reg_nowait(ipd->regs, CSR2, ipd->csr2);
806 /* disable interrupts, clear all irq flags */
807 iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD, ipd->regs + INT_CSR);
808 spin_unlock(&ipd->lock);
809 return IRQ_HANDLED;
810}
811
812static int
813dt3155_threadfn(void *arg)
814{
815 struct dt3155_priv *pd = arg;
816 struct videobuf_buffer *vb;
817 unsigned long flags;
818
819 while (1) {
820 wait_event_interruptible(pd->do_dma,
821 kthread_should_stop() || !list_empty(&pd->dmaq));
822 if (kthread_should_stop())
823 break;
824
825 spin_lock_irqsave(&pd->lock, flags);
826 if (pd->curr_buf) /* dma is active */
827 goto done;
828 if (list_empty(&pd->dmaq)) /* no empty biffers */
829 goto done;
830 vb = list_first_entry(&pd->dmaq, typeof(*vb), queue);
831 list_del(&vb->queue);
832 if (vb->state == VIDEOBUF_QUEUED) {
833 vb->state = VIDEOBUF_ACTIVE;
834 pd->curr_buf = vb;
835 spin_unlock_irqrestore(&pd->lock, flags);
836 /* start dma */
837 dt3155_start_acq(pd);
838 continue;
839 } else
840 printk(KERN_DEBUG "%s(): This is a BUG\n", __func__);
841done:
842 spin_unlock_irqrestore(&pd->lock, flags);
843 }
844 return 0;
845}
846
847static int
848dt3155_open(struct file *filp)
849{
850 int ret = 0;
851 struct dt3155_priv *pd = video_drvdata(filp);
852
853 printk(KERN_INFO "dt3155: open(): minor: %i\n", pd->vdev->minor);
854
855 if (mutex_lock_interruptible(&pd->mux) == -EINTR)
856 return -ERESTARTSYS;
857 if (!pd->users) {
858 pd->vidq = kzalloc(sizeof(*pd->vidq), GFP_KERNEL);
859 if (!pd->vidq) {
860 printk(KERN_ERR "dt3155: error: alloc queue\n");
861 ret = -ENOMEM;
862 goto err_alloc_queue;
863 }
864 dt3155_queue_dma_contig_init(pd->vidq, &vbq_ops,
865 &pd->pdev->dev, &pd->lock,
866 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
867 sizeof(struct videobuf_buffer), pd);
868 /* disable all irqs, clear all irq flags */
869 iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD,
870 pd->regs + INT_CSR);
871 pd->irq_handler = dt3155_irq_handler_even;
872 ret = request_irq(pd->pdev->irq, pd->irq_handler,
873 IRQF_SHARED, DT3155_NAME, pd);
874 if (ret) {
875 printk(KERN_ERR "dt3155: error: request_irq\n");
876 goto err_request_irq;
877 }
878 pd->curr_buf = NULL;
879 pd->thread = kthread_run(dt3155_threadfn, pd,
880 "dt3155_thread_%i", pd->vdev->minor);
881 if (IS_ERR(pd->thread)) {
882 printk(KERN_ERR "dt3155: kthread_run() failed\n");
883 ret = PTR_ERR(pd->thread);
884 goto err_thread;
885 }
886 pd->field_count = 0;
887 }
888 pd->users++;
889 goto done;
890err_thread:
891 free_irq(pd->pdev->irq, pd);
892err_request_irq:
893 kfree(pd->vidq);
894 pd->vidq = NULL;
895err_alloc_queue:
896done:
897 mutex_unlock(&pd->mux);
898 return ret;
899}
900
901static int
902dt3155_release(struct file *filp)
903{
904 struct dt3155_priv *pd = video_drvdata(filp);
905 struct videobuf_buffer *tmp;
906 unsigned long flags;
907 int ret = 0;
908
909 printk(KERN_INFO "dt3155: release(): minor: %i\n", pd->vdev->minor);
910
911 if (mutex_lock_interruptible(&pd->mux) == -EINTR)
912 return -ERESTARTSYS;
913 pd->users--;
914 BUG_ON(pd->users < 0);
915 if (pd->acq_fp == filp) {
916 spin_lock_irqsave(&pd->lock, flags);
917 INIT_LIST_HEAD(&pd->dmaq); /* queue is emptied */
918 tmp = pd->curr_buf;
919 spin_unlock_irqrestore(&pd->lock, flags);
920 if (tmp)
921 videobuf_waiton(tmp, 0, 1); /* block, interruptible */
922 dt3155_stop_acq(pd);
923 videobuf_stop(pd->vidq);
924 pd->acq_fp = NULL;
925 }
926 if (!pd->users) {
927 kthread_stop(pd->thread);
928 free_irq(pd->pdev->irq, pd);
929 kfree(pd->vidq);
930 pd->vidq = NULL;
931 }
932 mutex_unlock(&pd->mux);
933 return ret;
934}
935
936static ssize_t
937dt3155_read(struct file *filp, char __user *user, size_t size, loff_t *loff)
938{
939 struct dt3155_priv *pd = video_drvdata(filp);
940 int ret;
941
942 if (mutex_lock_interruptible(&pd->mux) == -EINTR)
943 return -ERESTARTSYS;
944 if (!pd->acq_fp)
945 pd->acq_fp = filp;
946 else if (pd->acq_fp != filp) {
947 ret = -EBUSY;
948 goto done;
949 }
950 ret = videobuf_read_stream(pd->vidq, user, size, loff, 0,
951 filp->f_flags & O_NONBLOCK);
952done:
953 mutex_unlock(&pd->mux);
954 return ret;
955}
956
957static unsigned int
958dt3155_poll(struct file *filp, struct poll_table_struct *polltbl)
959{
960 struct dt3155_priv *pd = video_drvdata(filp);
961
962 return videobuf_poll_stream(filp, pd->vidq, polltbl);
963}
964
965static int
966dt3155_mmap(struct file *filp, struct vm_area_struct *vma)
967{
968 struct dt3155_priv *pd = video_drvdata(filp);
969
970 return videobuf_mmap_mapper(pd->vidq, vma);
971}
972
973static const struct v4l2_file_operations dt3155_fops = {
974 .owner = THIS_MODULE,
975 .open = dt3155_open,
976 .release = dt3155_release,
977 .read = dt3155_read,
978 .poll = dt3155_poll,
979 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
980 .mmap = dt3155_mmap,
981};
982
983static int
984dt3155_ioc_streamon(struct file *filp, void *p, enum v4l2_buf_type type)
985{
986 struct dt3155_priv *pd = video_drvdata(filp);
987 int ret = -ERESTARTSYS;
988
989 if (mutex_lock_interruptible(&pd->mux) == -EINTR)
990 return ret;
991 if (!pd->acq_fp) {
992 ret = videobuf_streamon(pd->vidq);
993 if (ret)
994 goto unlock;
995 pd->acq_fp = filp;
996 wake_up_interruptible_sync(&pd->do_dma);
997 } else if (pd->acq_fp == filp) {
998 ret = videobuf_streamon(pd->vidq);
999 if (!ret)
1000 wake_up_interruptible_sync(&pd->do_dma);
1001 } else
1002 ret = -EBUSY;
1003unlock:
1004 mutex_unlock(&pd->mux);
1005 return ret;
1006}
1007
1008static int
1009dt3155_ioc_streamoff(struct file *filp, void *p, enum v4l2_buf_type type)
1010{
1011 struct dt3155_priv *pd = video_drvdata(filp);
1012 struct videobuf_buffer *tmp;
1013 unsigned long flags;
1014 int ret;
1015
1016 ret = videobuf_streamoff(pd->vidq);
1017 if (ret)
1018 return ret;
1019 spin_lock_irqsave(&pd->lock, flags);
1020 tmp = pd->curr_buf;
1021 spin_unlock_irqrestore(&pd->lock, flags);
1022 if (tmp)
1023 videobuf_waiton(tmp, 0, 1); /* block, interruptible */
1024 return ret;
1025}
1026
1027static int
1028dt3155_ioc_querycap(struct file *filp, void *p, struct v4l2_capability *cap)
1029{
1030 struct dt3155_priv *pd = video_drvdata(filp);
1031
1032 strcpy(cap->driver, DT3155_NAME);
1033 strcpy(cap->card, DT3155_NAME " frame grabber");
1034 sprintf(cap->bus_info, "PCI:%s", pci_name(pd->pdev));
1035 cap->version =
1036 KERNEL_VERSION(DT3155_VER_MAJ, DT3155_VER_MIN, DT3155_VER_EXT);
1037 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1038#ifdef CONFIG_DT3155_STREAMING
1039 V4L2_CAP_STREAMING;
1040#else
1041 V4L2_CAP_READWRITE;
1042#endif
1043 return 0;
1044}
1045
1046static int
1047dt3155_ioc_enum_fmt_vid_cap(struct file *filp, void *p, struct v4l2_fmtdesc *f)
1048{
1049 if (f->index >= NUM_OF_FORMATS)
1050 return -EINVAL;
1051 *f = frame_std[f->index];
1052 return 0;
1053}
1054
1055static int
1056dt3155_ioc_g_fmt_vid_cap(struct file *filp, void *p, struct v4l2_format *f)
1057{
1058 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1059 return -EINVAL;
1060 f->fmt.pix.width = img_width;
1061 f->fmt.pix.height = img_height;
1062 f->fmt.pix.pixelformat = V4L2_PIX_FMT_GREY;
1063 f->fmt.pix.field = V4L2_FIELD_NONE;
1064 f->fmt.pix.bytesperline = f->fmt.pix.width;
1065 f->fmt.pix.sizeimage = f->fmt.pix.width * f->fmt.pix.height;
1066 f->fmt.pix.colorspace = 0;
1067 f->fmt.pix.priv = 0;
1068 return 0;
1069}
1070
1071static int
1072dt3155_ioc_try_fmt_vid_cap(struct file *filp, void *p, struct v4l2_format *f)
1073{
1074 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1075 return -EINVAL;
1076 if (f->fmt.pix.width == img_width &&
1077 f->fmt.pix.height == img_height &&
1078 f->fmt.pix.pixelformat == V4L2_PIX_FMT_GREY &&
1079 f->fmt.pix.field == V4L2_FIELD_NONE &&
1080 f->fmt.pix.bytesperline == f->fmt.pix.width &&
1081 f->fmt.pix.sizeimage == f->fmt.pix.width * f->fmt.pix.height)
1082 return 0;
1083 else
1084 return -EINVAL;
1085}
1086
1087static int
1088dt3155_ioc_s_fmt_vid_cap(struct file *filp, void *p, struct v4l2_format *f)
1089{
1090 return dt3155_ioc_g_fmt_vid_cap(filp, p, f);
1091}
1092
1093static int
1094dt3155_ioc_reqbufs(struct file *filp, void *p, struct v4l2_requestbuffers *b)
1095{
1096 struct dt3155_priv *pd = video_drvdata(filp);
1097 struct videobuf_queue *q = pd->vidq;
1098
1099 if (b->memory != V4L2_MEMORY_MMAP)
1100 return -EINVAL;
1101 if (b->count)
1102 return videobuf_reqbufs(q, b);
1103 else { /* FIXME: is it necessary? */
1104 printk(KERN_DEBUG "dt3155: request to free buffers\n");
1105 return videobuf_mmap_free(q);
1106 }
1107}
1108
1109static int
1110dt3155_ioc_querybuf(struct file *filp, void *p, struct v4l2_buffer *b)
1111{
1112 struct dt3155_priv *pd = video_drvdata(filp);
1113 struct videobuf_queue *q = pd->vidq;
1114
1115 return videobuf_querybuf(q, b);
1116}
1117
1118static int
1119dt3155_ioc_qbuf(struct file *filp, void *p, struct v4l2_buffer *b)
1120{
1121 struct dt3155_priv *pd = video_drvdata(filp);
1122 struct videobuf_queue *q = pd->vidq;
1123
1124 return videobuf_qbuf(q, b);
1125}
1126
1127static int
1128dt3155_ioc_dqbuf(struct file *filp, void *p, struct v4l2_buffer *b)
1129{
1130 struct dt3155_priv *pd = video_drvdata(filp);
1131 struct videobuf_queue *q = pd->vidq;
1132
1133 return videobuf_dqbuf(q, b, filp->f_flags & O_NONBLOCK);
1134}
1135
1136static int
1137dt3155_ioc_querystd(struct file *filp, void *p, v4l2_std_id *norm)
1138{
1139 *norm = DT3155_CURRENT_NORM;
1140 return 0;
1141}
1142
1143static int
1144dt3155_ioc_g_std(struct file *filp, void *p, v4l2_std_id *norm)
1145{
1146 *norm = DT3155_CURRENT_NORM;
1147 return 0;
1148}
1149
1150static int
1151dt3155_ioc_s_std(struct file *filp, void *p, v4l2_std_id *norm)
1152{
1153 if (*norm & DT3155_CURRENT_NORM)
1154 return 0;
1155 return -EINVAL;
1156}
1157
1158static int
1159dt3155_ioc_enum_input(struct file *filp, void *p, struct v4l2_input *input)
1160{
1161 if (input->index)
1162 return -EINVAL;
1163 strcpy(input->name, "Coax in");
1164 input->type = V4L2_INPUT_TYPE_CAMERA;
1165 input->std = V4L2_STD_ALL;
1166 input->status = 0;/* FIXME: add sync detection & V4L2_IN_ST_NO_H_LOCK */
1167 return 0;
1168}
1169
1170static int
1171dt3155_ioc_g_input(struct file *filp, void *p, unsigned int *i)
1172{
1173 *i = 0;
1174 return 0;
1175}
1176
1177static int
1178dt3155_ioc_s_input(struct file *filp, void *p, unsigned int i)
1179{
1180 if (i)
1181 return -EINVAL;
1182 return 0;
1183}
1184
1185static int
1186dt3155_ioc_g_parm(struct file *filp, void *p, struct v4l2_streamparm *parms)
1187{
1188 if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1189 return -EINVAL;
1190 parms->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1191 parms->parm.capture.capturemode = 0;
1192 parms->parm.capture.timeperframe.numerator = 1001;
1193 parms->parm.capture.timeperframe.denominator = frames_per_sec * 1000;
1194 parms->parm.capture.extendedmode = 0;
1195 parms->parm.capture.readbuffers = 1;
1196 return 0;
1197}
1198
1199static int
1200dt3155_ioc_s_parm(struct file *filp, void *p, struct v4l2_streamparm *parms)
1201{
1202 if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1203 return -EINVAL;
1204 parms->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1205 parms->parm.capture.capturemode = 0;
1206 parms->parm.capture.timeperframe.numerator = 1001;
1207 parms->parm.capture.timeperframe.denominator = frames_per_sec * 1000;
1208 parms->parm.capture.extendedmode = 0;
1209 parms->parm.capture.readbuffers = 1;
1210 return 0;
1211}
1212
1213static const struct v4l2_ioctl_ops dt3155_ioctl_ops = {
1214 .vidioc_streamon = dt3155_ioc_streamon,
1215 .vidioc_streamoff = dt3155_ioc_streamoff,
1216 .vidioc_querycap = dt3155_ioc_querycap,
1217/*
1218 .vidioc_g_priority = dt3155_ioc_g_priority,
1219 .vidioc_s_priority = dt3155_ioc_s_priority,
1220*/
1221 .vidioc_enum_fmt_vid_cap = dt3155_ioc_enum_fmt_vid_cap,
1222 .vidioc_try_fmt_vid_cap = dt3155_ioc_try_fmt_vid_cap,
1223 .vidioc_g_fmt_vid_cap = dt3155_ioc_g_fmt_vid_cap,
1224 .vidioc_s_fmt_vid_cap = dt3155_ioc_s_fmt_vid_cap,
1225 .vidioc_reqbufs = dt3155_ioc_reqbufs,
1226 .vidioc_querybuf = dt3155_ioc_querybuf,
1227 .vidioc_qbuf = dt3155_ioc_qbuf,
1228 .vidioc_dqbuf = dt3155_ioc_dqbuf,
1229 .vidioc_querystd = dt3155_ioc_querystd,
1230 .vidioc_g_std = dt3155_ioc_g_std,
1231 .vidioc_s_std = dt3155_ioc_s_std,
1232 .vidioc_enum_input = dt3155_ioc_enum_input,
1233 .vidioc_g_input = dt3155_ioc_g_input,
1234 .vidioc_s_input = dt3155_ioc_s_input,
1235/*
1236 .vidioc_queryctrl = dt3155_ioc_queryctrl,
1237 .vidioc_g_ctrl = dt3155_ioc_g_ctrl,
1238 .vidioc_s_ctrl = dt3155_ioc_s_ctrl,
1239 .vidioc_querymenu = dt3155_ioc_querymenu,
1240 .vidioc_g_ext_ctrls = dt3155_ioc_g_ext_ctrls,
1241 .vidioc_s_ext_ctrls = dt3155_ioc_s_ext_ctrls,
1242*/
1243 .vidioc_g_parm = dt3155_ioc_g_parm,
1244 .vidioc_s_parm = dt3155_ioc_s_parm,
1245/*
1246 .vidioc_cropcap = dt3155_ioc_cropcap,
1247 .vidioc_g_crop = dt3155_ioc_g_crop,
1248 .vidioc_s_crop = dt3155_ioc_s_crop,
1249 .vidioc_enum_framesizes = dt3155_ioc_enum_framesizes,
1250 .vidioc_enum_frameintervals = dt3155_ioc_enum_frameintervals,
1251#ifdef CONFIG_VIDEO_V4L1_COMPAT
1252 .vidiocgmbuf = iocgmbuf,
1253#endif
1254*/
1255};
1256
1257static int __devinit
1258dt3155_init_board(struct pci_dev *dev)
1259{
1260 int i;
1261 u8 tmp;
1262 struct dt3155_buf *buf;
1263 struct dt3155_priv *pd = pci_get_drvdata(dev);
1264 pci_set_master(dev); /* dt3155 needs it */
1265
1266 /* resetting the adapter */
1267 iowrite32(FLD_CRPT_ODD | FLD_CRPT_EVEN | FLD_DN_ODD | FLD_DN_EVEN,
1268 pd->regs + CSR1);
1269 mmiowb();
1270 msleep(10);
1271
1272 /* initializing adaper registers */
1273 iowrite32(FIFO_EN | SRST, pd->regs + CSR1);
1274 mmiowb();
1275 iowrite32(0xEEEEEE01, pd->regs + EVEN_PIXEL_FMT);
1276 iowrite32(0xEEEEEE01, pd->regs + ODD_PIXEL_FMT);
1277 iowrite32(0x00000020, pd->regs + FIFO_TRIGER);
1278 iowrite32(0x00000103, pd->regs + XFER_MODE);
1279 iowrite32(0, pd->regs + RETRY_WAIT_CNT);
1280 iowrite32(0, pd->regs + INT_CSR);
1281 iowrite32(1, pd->regs + EVEN_FLD_MASK);
1282 iowrite32(1, pd->regs + ODD_FLD_MASK);
1283 iowrite32(0, pd->regs + MASK_LENGTH);
1284 iowrite32(0x0005007C, pd->regs + FIFO_FLAG_CNT);
1285 iowrite32(0x01010101, pd->regs + IIC_CLK_DUR);
1286 mmiowb();
1287
1288 /* verifying that we have a DT3155 board (not just a SAA7116 chip) */
1289 read_i2c_reg(pd->regs, DT_ID, &tmp);
1290 if (tmp != DT3155_ID)
1291 return -ENODEV;
1292
1293 /* initialize AD LUT */
1294 write_i2c_reg(pd->regs, AD_ADDR, 0);
1295 for (i = 0; i < 256; i++)
1296 write_i2c_reg(pd->regs, AD_LUT, i);
1297
1298 /* initialize ADC references */
1299 /* FIXME: pos_ref & neg_ref depend on VT_50HZ */
1300 write_i2c_reg(pd->regs, AD_ADDR, AD_CMD_REG);
1301 write_i2c_reg(pd->regs, AD_CMD, VIDEO_CNL_1 | SYNC_CNL_1 | SYNC_LVL_3);
1302 write_i2c_reg(pd->regs, AD_ADDR, AD_POS_REF);
1303 write_i2c_reg(pd->regs, AD_CMD, 34);
1304 write_i2c_reg(pd->regs, AD_ADDR, AD_NEG_REF);
1305 write_i2c_reg(pd->regs, AD_CMD, 0);
1306
1307 /* initialize PM LUT */
1308 write_i2c_reg(pd->regs, CONFIG, pd->config | PM_LUT_PGM);
1309 for (i = 0; i < 256; i++) {
1310 write_i2c_reg(pd->regs, PM_LUT_ADDR, i);
1311 write_i2c_reg(pd->regs, PM_LUT_DATA, i);
1312 }
1313 write_i2c_reg(pd->regs, CONFIG, pd->config | PM_LUT_PGM | PM_LUT_SEL);
1314 for (i = 0; i < 256; i++) {
1315 write_i2c_reg(pd->regs, PM_LUT_ADDR, i);
1316 write_i2c_reg(pd->regs, PM_LUT_DATA, i);
1317 }
1318 write_i2c_reg(pd->regs, CONFIG, pd->config); /* ACQ_MODE_EVEN */
1319
1320 /* select chanel 1 for input and set sync level */
1321 write_i2c_reg(pd->regs, AD_ADDR, AD_CMD_REG);
1322 write_i2c_reg(pd->regs, AD_CMD, VIDEO_CNL_1 | SYNC_CNL_1 | SYNC_LVL_3);
1323
1324 /* allocate and pci_map memory, and initialize the DMA machine */
1325 buf = dt3155_get_buf(dt3155_free_bufs);
1326 if (!buf) {
1327 printk(KERN_ERR "dt3155: dt3155_get_buf "
1328 "(in dt3155_init_board) failed\n");
1329 return -ENOMEM;
1330 }
1331 buf->dma = pci_map_single(dev, buf->cpu,
1332 DT3155_BUF_SIZE, PCI_DMA_FROMDEVICE);
1333 if (pci_dma_mapping_error(dev, buf->dma)) {
1334 printk(KERN_ERR "dt3155: pci_map_single failed\n");
1335 dt3155_put_buf(buf, dt3155_free_bufs);
1336 return -ENOMEM;
1337 }
1338 iowrite32(buf->dma, pd->regs + EVEN_DMA_START);
1339 iowrite32(buf->dma, pd->regs + ODD_DMA_START);
1340 iowrite32(0, pd->regs + EVEN_DMA_STRIDE);
1341 iowrite32(0, pd->regs + ODD_DMA_STRIDE);
1342
1343 /* Perform a pseudo even field acquire */
1344 iowrite32(FIFO_EN | SRST | CAP_CONT_ODD, pd->regs + CSR1);
1345 write_i2c_reg(pd->regs, CSR2, pd->csr2 | SYNC_SNTL);
1346 write_i2c_reg(pd->regs, CONFIG, pd->config);
1347 write_i2c_reg(pd->regs, EVEN_CSR, CSR_SNGL);
1348 write_i2c_reg(pd->regs, CSR2, pd->csr2 | BUSY_EVEN | SYNC_SNTL);
1349 msleep(100);
1350 read_i2c_reg(pd->regs, CSR2, &tmp);
1351 write_i2c_reg(pd->regs, EVEN_CSR, CSR_ERROR | CSR_SNGL | CSR_DONE);
1352 write_i2c_reg(pd->regs, ODD_CSR, CSR_ERROR | CSR_SNGL | CSR_DONE);
1353 write_i2c_reg(pd->regs, CSR2, pd->csr2);
1354 iowrite32(FIFO_EN | SRST | FLD_DN_EVEN | FLD_DN_ODD, pd->regs + CSR1);
1355
1356 /* pci_unmap and deallocate memory */
1357 pci_unmap_single(dev, buf->dma, DT3155_BUF_SIZE, PCI_DMA_FROMDEVICE);
1358 dt3155_put_buf(buf, dt3155_free_bufs);
1359 if (tmp & BUSY_EVEN) {
1360 printk(KERN_ERR "dt3155: BUSY_EVEN not cleared\n");
1361 return -EIO;
1362 }
1363 return 0;
1364}
1365
1366static struct video_device dt3155_vdev = {
1367 .name = DT3155_NAME,
1368 .fops = &dt3155_fops,
1369 .ioctl_ops = &dt3155_ioctl_ops,
1370 .minor = -1,
1371 .release = video_device_release,
1372 .tvnorms = V4L2_STD_ALL,
1373 .current_norm = DT3155_CURRENT_NORM,
1374};
1375
1376static int __devinit
1377dt3155_probe(struct pci_dev *dev, const struct pci_device_id *id)
1378{
1379 int err = -ENODEV;
1380 struct dt3155_priv *pd;
1381
1382 printk(KERN_INFO "dt3155: probe()\n");
1383 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
1384 printk(KERN_ERR "dt3155: cannot set dma_mask\n");
1385 return -ENODEV;
1386 }
1387 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
1388 if (!pd) {
1389 printk(KERN_ERR "dt3155: cannot allocate dt3155_priv\n");
1390 return -ENOMEM;
1391 }
1392 pd->vdev = video_device_alloc();
1393 if (!pd->vdev) {
1394 printk(KERN_ERR "dt3155: cannot allocate vdp structure\n");
1395 goto err_video_device_alloc;
1396 }
1397 *pd->vdev = dt3155_vdev;
1398 pci_set_drvdata(dev, pd); /* for use in dt3155_remove() */
1399 video_set_drvdata(pd->vdev, pd); /* for use in video_fops */
1400 pd->users = 0;
1401 pd->acq_fp = NULL;
1402 pd->pdev = dev;
1403 INIT_LIST_HEAD(&pd->dmaq);
1404 init_waitqueue_head(&pd->do_dma);
1405 mutex_init(&pd->mux);
1406 pd->csr2 = csr2_init;
1407 pd->config = config_init;
1408 err = pci_enable_device(pd->pdev);
1409 if (err) {
1410 printk(KERN_ERR "dt3155: pci_dev not enabled\n");
1411 goto err_enable_dev;
1412 }
1413 err = pci_request_region(pd->pdev, 0, pci_name(pd->pdev));
1414 if (err)
1415 goto err_req_region;
1416 pd->regs = pci_iomap(pd->pdev, 0, pci_resource_len(pd->pdev, 0));
1417 if (!pd->regs) {
1418 err = -ENOMEM;
1419 printk(KERN_ERR "dt3155: pci_iomap failed\n");
1420 goto err_pci_iomap;
1421 }
1422 err = dt3155_init_board(pd->pdev);
1423 if (err) {
1424 printk(KERN_ERR "dt3155: dt3155_init_board failed\n");
1425 goto err_init_board;
1426 }
1427 err = video_register_device(pd->vdev, VFL_TYPE_GRABBER, -1);
1428 if (err) {
1429 printk(KERN_ERR "dt3155: Cannot register video device\n");
1430 goto err_init_board;
1431 }
1432 printk(KERN_INFO "dt3155: /dev/video%i is ready\n", pd->vdev->minor);
1433 return 0; /* success */
1434
1435err_init_board:
1436 pci_iounmap(pd->pdev, pd->regs);
1437err_pci_iomap:
1438 pci_release_region(pd->pdev, 0);
1439err_req_region:
1440 pci_disable_device(pd->pdev);
1441err_enable_dev:
1442 video_device_release(pd->vdev);
1443err_video_device_alloc:
1444 kfree(pd);
1445 return err;
1446}
1447
1448static void __devexit
1449dt3155_remove(struct pci_dev *dev)
1450{
1451 struct dt3155_priv *pd = pci_get_drvdata(dev);
1452
1453 printk(KERN_INFO "dt3155: remove()\n");
1454 video_unregister_device(pd->vdev);
1455 pci_iounmap(dev, pd->regs);
1456 pci_release_region(pd->pdev, 0);
1457 pci_disable_device(pd->pdev);
1458 /*
1459 * video_device_release() is invoked automatically
1460 * see: struct video_device dt3155_vdev
1461 */
1462 kfree(pd);
1463}
1464
1465static DEFINE_PCI_DEVICE_TABLE(pci_ids) = {
1466 { PCI_DEVICE(DT3155_VENDOR_ID, DT3155_DEVICE_ID) },
1467 { 0, /* zero marks the end */ },
1468};
1469MODULE_DEVICE_TABLE(pci, pci_ids);
1470
1471static struct pci_driver pci_driver = {
1472 .name = DT3155_NAME,
1473 .id_table = pci_ids,
1474 .probe = dt3155_probe,
1475 .remove = __devexit_p(dt3155_remove),
1476};
1477
1478static int __init
1479dt3155_init_module(void)
1480{
1481 int err;
1482
1483 printk(KERN_INFO "dt3155: ==================\n");
1484 printk(KERN_INFO "dt3155: init()\n");
1485 dt3155_chunks = dt3155_init_chunks_fifo();
1486 if (!dt3155_chunks) {
1487 err = -ENOMEM;
1488 printk(KERN_ERR "dt3155: cannot init dt3155_chunks_fifo\n");
1489 goto err_init_chunks_fifo;
1490 }
1491 dt3155_free_bufs = dt3155_init_ibufs_fifo(dt3155_chunks,
1492 DT3155_BUF_SIZE);
1493 if (!dt3155_free_bufs) {
1494 err = -ENOMEM;
1495 printk(KERN_ERR "dt3155: cannot dt3155_init_ibufs_fifo\n");
1496 goto err_init_ibufs_fifo;
1497 }
1498 dt3155_alloc_bufs = dt3155_init_fifo();
1499 if (!dt3155_alloc_bufs) {
1500 err = -ENOMEM;
1501 printk(KERN_ERR "dt3155: cannot dt3155_init_fifo\n");
1502 goto err_init_fifo;
1503 }
1504 err = pci_register_driver(&pci_driver);
1505 if (err) {
1506 printk(KERN_ERR "dt3155: cannot register pci_driver\n");
1507 goto err_register_driver;
1508 }
1509 return 0; /* succes */
1510err_register_driver:
1511 dt3155_free_fifo(dt3155_alloc_bufs);
1512err_init_fifo:
1513 dt3155_free_ibufs_fifo(dt3155_free_bufs);
1514err_init_ibufs_fifo:
1515 dt3155_free_chunks_fifo(dt3155_chunks);
1516err_init_chunks_fifo:
1517 return err;
1518}
1519
1520static void __exit
1521dt3155_exit_module(void)
1522{
1523 pci_unregister_driver(&pci_driver);
1524 dt3155_free_fifo(dt3155_alloc_bufs);
1525 dt3155_free_ibufs_fifo(dt3155_free_bufs);
1526 dt3155_free_chunks_fifo(dt3155_chunks);
1527 printk(KERN_INFO "dt3155: exit()\n");
1528 printk(KERN_INFO "dt3155: ==================\n");
1529}
1530
1531module_init(dt3155_init_module);
1532module_exit(dt3155_exit_module);
1533
1534MODULE_DESCRIPTION("video4linux pci-driver for dt3155 frame grabber");
1535MODULE_AUTHOR("Marin Mitov <mitov@issp.bas.bg>");
1536MODULE_VERSION(DT3155_VERSION);
1537MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.078506 seconds and 5 git commands to generate.