1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3 #include <media/saa7146_vv.h>
5 /****************************************************************************/
6 /* resource management functions, shamelessly stolen from saa7134 driver */
8 int saa7146_res_get(struct saa7146_fh
*fh
, unsigned int bit
)
10 struct saa7146_dev
*dev
= fh
->dev
;
11 struct saa7146_vv
*vv
= dev
->vv_data
;
13 if (fh
->resources
& bit
) {
14 DEB_D("already allocated! want: 0x%02x, cur:0x%02x\n",
16 /* have it already allocated */
21 if (vv
->resources
& bit
) {
22 DEB_D("locked! vv->resources:0x%02x, we want:0x%02x\n",
24 /* no, someone else uses it */
27 /* it's free, grab it */
30 DEB_D("res: get 0x%02x, cur:0x%02x\n", bit
, vv
->resources
);
34 void saa7146_res_free(struct saa7146_fh
*fh
, unsigned int bits
)
36 struct saa7146_dev
*dev
= fh
->dev
;
37 struct saa7146_vv
*vv
= dev
->vv_data
;
39 BUG_ON((fh
->resources
& bits
) != bits
);
41 fh
->resources
&= ~bits
;
42 vv
->resources
&= ~bits
;
43 DEB_D("res: put 0x%02x, cur:0x%02x\n", bits
, vv
->resources
);
47 /********************************************************************************/
48 /* common dma functions */
50 void saa7146_dma_free(struct saa7146_dev
*dev
,struct videobuf_queue
*q
,
51 struct saa7146_buf
*buf
)
53 struct videobuf_dmabuf
*dma
=videobuf_to_dma(&buf
->vb
);
54 DEB_EE("dev:%p, buf:%p\n", dev
, buf
);
56 BUG_ON(in_interrupt());
58 videobuf_waiton(q
, &buf
->vb
, 0, 0);
59 videobuf_dma_unmap(q
->dev
, dma
);
60 videobuf_dma_free(dma
);
61 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
65 /********************************************************************************/
66 /* common buffer functions */
68 int saa7146_buffer_queue(struct saa7146_dev
*dev
,
69 struct saa7146_dmaqueue
*q
,
70 struct saa7146_buf
*buf
)
72 assert_spin_locked(&dev
->slock
);
73 DEB_EE("dev:%p, dmaq:%p, buf:%p\n", dev
, q
, buf
);
77 if (NULL
== q
->curr
) {
79 DEB_D("immediately activating buffer %p\n", buf
);
80 buf
->activate(dev
,buf
,NULL
);
82 list_add_tail(&buf
->vb
.queue
,&q
->queue
);
83 buf
->vb
.state
= VIDEOBUF_QUEUED
;
84 DEB_D("adding buffer %p to queue. (active buffer present)\n",
90 void saa7146_buffer_finish(struct saa7146_dev
*dev
,
91 struct saa7146_dmaqueue
*q
,
94 assert_spin_locked(&dev
->slock
);
95 DEB_EE("dev:%p, dmaq:%p, state:%d\n", dev
, q
, state
);
96 DEB_EE("q->curr:%p\n", q
->curr
);
100 /* finish current buffer */
101 if (NULL
== q
->curr
) {
102 DEB_D("aiii. no current buffer\n");
106 q
->curr
->vb
.state
= state
;
107 do_gettimeofday(&q
->curr
->vb
.ts
);
108 wake_up(&q
->curr
->vb
.done
);
113 void saa7146_buffer_next(struct saa7146_dev
*dev
,
114 struct saa7146_dmaqueue
*q
, int vbi
)
116 struct saa7146_buf
*buf
,*next
= NULL
;
120 DEB_INT("dev:%p, dmaq:%p, vbi:%d\n", dev
, q
, vbi
);
122 assert_spin_locked(&dev
->slock
);
123 if (!list_empty(&q
->queue
)) {
124 /* activate next one from queue */
125 buf
= list_entry(q
->queue
.next
,struct saa7146_buf
,vb
.queue
);
126 list_del(&buf
->vb
.queue
);
127 if (!list_empty(&q
->queue
))
128 next
= list_entry(q
->queue
.next
,struct saa7146_buf
, vb
.queue
);
130 DEB_INT("next buffer: buf:%p, prev:%p, next:%p\n",
131 buf
, q
->queue
.prev
, q
->queue
.next
);
132 buf
->activate(dev
,buf
,next
);
134 DEB_INT("no next buffer. stopping.\n");
136 /* turn off video-dma3 */
137 saa7146_write(dev
,MC1
, MASK_20
);
139 /* nothing to do -- just prevent next video-dma1 transfer
140 by lowering the protection address */
142 // fixme: fix this for vflip != 0
144 saa7146_write(dev
, PROT_ADDR1
, 0);
145 saa7146_write(dev
, MC2
, (MASK_02
|MASK_18
));
147 /* write the address of the rps-program */
148 saa7146_write(dev
, RPS_ADDR0
, dev
->d_rps0
.dma_handle
);
150 saa7146_write(dev
, MC1
, (MASK_12
| MASK_28
));
153 printk("vdma%d.base_even: 0x%08x\n", 1,saa7146_read(dev,BASE_EVEN1));
154 printk("vdma%d.base_odd: 0x%08x\n", 1,saa7146_read(dev,BASE_ODD1));
155 printk("vdma%d.prot_addr: 0x%08x\n", 1,saa7146_read(dev,PROT_ADDR1));
156 printk("vdma%d.base_page: 0x%08x\n", 1,saa7146_read(dev,BASE_PAGE1));
157 printk("vdma%d.pitch: 0x%08x\n", 1,saa7146_read(dev,PITCH1));
158 printk("vdma%d.num_line_byte: 0x%08x\n", 1,saa7146_read(dev,NUM_LINE_BYTE1));
161 del_timer(&q
->timeout
);
165 void saa7146_buffer_timeout(unsigned long data
)
167 struct saa7146_dmaqueue
*q
= (struct saa7146_dmaqueue
*)data
;
168 struct saa7146_dev
*dev
= q
->dev
;
171 DEB_EE("dev:%p, dmaq:%p\n", dev
, q
);
173 spin_lock_irqsave(&dev
->slock
,flags
);
175 DEB_D("timeout on %p\n", q
->curr
);
176 saa7146_buffer_finish(dev
,q
,VIDEOBUF_ERROR
);
179 /* we don't restart the transfer here like other drivers do. when
180 a streaming capture is disabled, the timeout function will be
181 called for the current buffer. if we activate the next buffer now,
182 we mess up our capture logic. if a timeout occurs on another buffer,
183 then something is seriously broken before, so no need to buffer the
184 next capture IMHO... */
186 saa7146_buffer_next(dev,q);
188 spin_unlock_irqrestore(&dev
->slock
,flags
);
191 /********************************************************************************/
192 /* file operations */
194 static int fops_open(struct file
*file
)
196 struct video_device
*vdev
= video_devdata(file
);
197 struct saa7146_dev
*dev
= video_drvdata(file
);
198 struct saa7146_fh
*fh
= NULL
;
201 enum v4l2_buf_type type
;
203 DEB_EE("file:%p, dev:%s\n", file
, video_device_node_name(vdev
));
205 if (mutex_lock_interruptible(&saa7146_devices_lock
))
208 DEB_D("using: %p\n", dev
);
210 type
= vdev
->vfl_type
== VFL_TYPE_GRABBER
211 ? V4L2_BUF_TYPE_VIDEO_CAPTURE
212 : V4L2_BUF_TYPE_VBI_CAPTURE
;
214 /* check if an extension is registered */
215 if( NULL
== dev
->ext
) {
216 DEB_S("no extension registered for this device\n");
221 /* allocate per open data */
222 fh
= kzalloc(sizeof(*fh
),GFP_KERNEL
);
224 DEB_S("cannot allocate memory for per open data\n");
229 file
->private_data
= fh
;
233 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
234 DEB_S("initializing vbi...\n");
235 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
236 result
= saa7146_vbi_uops
.open(dev
,file
);
237 if (dev
->ext_vv_data
->vbi_fops
.open
)
238 dev
->ext_vv_data
->vbi_fops
.open(file
);
240 DEB_S("initializing video...\n");
241 result
= saa7146_video_uops
.open(dev
,file
);
248 if( 0 == try_module_get(dev
->ext
->module
)) {
255 if (fh
&& result
!= 0) {
257 file
->private_data
= NULL
;
259 mutex_unlock(&saa7146_devices_lock
);
263 static int fops_release(struct file
*file
)
265 struct saa7146_fh
*fh
= file
->private_data
;
266 struct saa7146_dev
*dev
= fh
->dev
;
268 DEB_EE("file:%p\n", file
);
270 if (mutex_lock_interruptible(&saa7146_devices_lock
))
273 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
274 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
275 saa7146_vbi_uops
.release(dev
,file
);
276 if (dev
->ext_vv_data
->vbi_fops
.release
)
277 dev
->ext_vv_data
->vbi_fops
.release(file
);
279 saa7146_video_uops
.release(dev
,file
);
282 module_put(dev
->ext
->module
);
283 file
->private_data
= NULL
;
286 mutex_unlock(&saa7146_devices_lock
);
291 static int fops_mmap(struct file
*file
, struct vm_area_struct
* vma
)
293 struct saa7146_fh
*fh
= file
->private_data
;
294 struct videobuf_queue
*q
;
297 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
298 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, vma:%p\n",
303 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
304 DEB_EE("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, vma:%p\n",
314 return videobuf_mmap_mapper(q
,vma
);
317 static unsigned int fops_poll(struct file
*file
, struct poll_table_struct
*wait
)
319 struct saa7146_fh
*fh
= file
->private_data
;
320 struct videobuf_buffer
*buf
= NULL
;
321 struct videobuf_queue
*q
;
323 DEB_EE("file:%p, poll:%p\n", file
, wait
);
325 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
326 if( 0 == fh
->vbi_q
.streaming
)
327 return videobuf_poll_stream(file
, &fh
->vbi_q
, wait
);
330 DEB_D("using video queue\n");
334 if (!list_empty(&q
->stream
))
335 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
338 DEB_D("buf == NULL!\n");
342 poll_wait(file
, &buf
->done
, wait
);
343 if (buf
->state
== VIDEOBUF_DONE
|| buf
->state
== VIDEOBUF_ERROR
) {
344 DEB_D("poll succeeded!\n");
345 return POLLIN
|POLLRDNORM
;
348 DEB_D("nothing to poll for, buf->state:%d\n", buf
->state
);
352 static ssize_t
fops_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
354 struct saa7146_fh
*fh
= file
->private_data
;
357 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
359 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, data:%p, count:%lun",
360 file, data, (unsigned long)count);
362 return saa7146_video_uops
.read(file
,data
,count
,ppos
);
363 case V4L2_BUF_TYPE_VBI_CAPTURE
:
365 DEB_EE("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, data:%p, count:%lu\n",
366 file, data, (unsigned long)count);
368 if (fh
->dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
369 return saa7146_vbi_uops
.read(file
,data
,count
,ppos
);
377 static ssize_t
fops_write(struct file
*file
, const char __user
*data
, size_t count
, loff_t
*ppos
)
379 struct saa7146_fh
*fh
= file
->private_data
;
382 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
384 case V4L2_BUF_TYPE_VBI_CAPTURE
:
385 if (fh
->dev
->ext_vv_data
->vbi_fops
.write
)
386 return fh
->dev
->ext_vv_data
->vbi_fops
.write(file
, data
, count
, ppos
);
395 static const struct v4l2_file_operations video_fops
=
397 .owner
= THIS_MODULE
,
399 .release
= fops_release
,
404 .unlocked_ioctl
= video_ioctl2
,
407 static void vv_callback(struct saa7146_dev
*dev
, unsigned long status
)
411 DEB_INT("dev:%p, isr:0x%08x\n", dev
, (u32
)status
);
413 if (0 != (isr
& (MASK_27
))) {
414 DEB_INT("irq: RPS0 (0x%08x)\n", isr
);
415 saa7146_video_uops
.irq_done(dev
,isr
);
418 if (0 != (isr
& (MASK_28
))) {
419 u32 mc2
= saa7146_read(dev
, MC2
);
420 if( 0 != (mc2
& MASK_15
)) {
421 DEB_INT("irq: RPS1 vbi workaround (0x%08x)\n", isr
);
422 wake_up(&dev
->vv_data
->vbi_wq
);
423 saa7146_write(dev
,MC2
, MASK_31
);
426 DEB_INT("irq: RPS1 (0x%08x)\n", isr
);
427 saa7146_vbi_uops
.irq_done(dev
,isr
);
431 int saa7146_vv_init(struct saa7146_dev
* dev
, struct saa7146_ext_vv
*ext_vv
)
433 struct saa7146_vv
*vv
;
436 err
= v4l2_device_register(&dev
->pci
->dev
, &dev
->v4l2_dev
);
440 vv
= kzalloc(sizeof(struct saa7146_vv
), GFP_KERNEL
);
442 ERR("out of memory. aborting.\n");
445 ext_vv
->ops
= saa7146_video_ioctl_ops
;
446 ext_vv
->core_ops
= &saa7146_video_ioctl_ops
;
448 DEB_EE("dev:%p\n", dev
);
450 /* set default values for video parts of the saa7146 */
451 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
453 /* enable video-port pins */
454 saa7146_write(dev
, MC1
, (MASK_10
| MASK_26
));
456 /* save per-device extension data (one extension can
457 handle different devices that might need different
458 configuration data) */
459 dev
->ext_vv_data
= ext_vv
;
461 vv
->d_clipping
.cpu_addr
= pci_alloc_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, &vv
->d_clipping
.dma_handle
);
462 if( NULL
== vv
->d_clipping
.cpu_addr
) {
463 ERR("out of memory. aborting.\n");
467 memset(vv
->d_clipping
.cpu_addr
, 0x0, SAA7146_CLIPPING_MEM
);
469 saa7146_video_uops
.init(dev
,vv
);
470 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
471 saa7146_vbi_uops
.init(dev
,vv
);
474 dev
->vv_callback
= &vv_callback
;
478 EXPORT_SYMBOL_GPL(saa7146_vv_init
);
480 int saa7146_vv_release(struct saa7146_dev
* dev
)
482 struct saa7146_vv
*vv
= dev
->vv_data
;
484 DEB_EE("dev:%p\n", dev
);
486 v4l2_device_unregister(&dev
->v4l2_dev
);
487 pci_free_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, vv
->d_clipping
.cpu_addr
, vv
->d_clipping
.dma_handle
);
490 dev
->vv_callback
= NULL
;
494 EXPORT_SYMBOL_GPL(saa7146_vv_release
);
496 int saa7146_register_device(struct video_device
**vid
, struct saa7146_dev
* dev
,
497 char *name
, int type
)
499 struct video_device
*vfd
;
503 DEB_EE("dev:%p, name:'%s', type:%d\n", dev
, name
, type
);
505 // released by vfd->release
506 vfd
= video_device_alloc();
510 vfd
->fops
= &video_fops
;
511 vfd
->ioctl_ops
= &dev
->ext_vv_data
->ops
;
512 vfd
->release
= video_device_release
;
513 vfd
->lock
= &dev
->v4l2_lock
;
515 for (i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
516 vfd
->tvnorms
|= dev
->ext_vv_data
->stds
[i
].id
;
517 strlcpy(vfd
->name
, name
, sizeof(vfd
->name
));
518 video_set_drvdata(vfd
, dev
);
520 err
= video_register_device(vfd
, type
, -1);
522 ERR("cannot register v4l2 device. skipping.\n");
523 video_device_release(vfd
);
527 pr_info("%s: registered device %s [v4l2]\n",
528 dev
->name
, video_device_node_name(vfd
));
533 EXPORT_SYMBOL_GPL(saa7146_register_device
);
535 int saa7146_unregister_device(struct video_device
**vid
, struct saa7146_dev
* dev
)
537 DEB_EE("dev:%p\n", dev
);
539 video_unregister_device(*vid
);
544 EXPORT_SYMBOL_GPL(saa7146_unregister_device
);
546 static int __init
saa7146_vv_init_module(void)
552 static void __exit
saa7146_vv_cleanup_module(void)
556 module_init(saa7146_vv_init_module
);
557 module_exit(saa7146_vv_cleanup_module
);
559 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
560 MODULE_DESCRIPTION("video4linux driver for saa7146-based hardware");
561 MODULE_LICENSE("GPL");