1 #include <media/saa7146_vv.h>
3 /****************************************************************************/
4 /* resource management functions, shamelessly stolen from saa7134 driver */
6 int saa7146_res_get(struct saa7146_fh
*fh
, unsigned int bit
)
8 struct saa7146_dev
*dev
= fh
->dev
;
9 struct saa7146_vv
*vv
= dev
->vv_data
;
11 if (fh
->resources
& bit
) {
12 DEB_D(("already allocated! want: 0x%02x, cur:0x%02x\n",bit
,vv
->resources
));
13 /* have it already allocated */
18 mutex_lock(&dev
->lock
);
19 if (vv
->resources
& bit
) {
20 DEB_D(("locked! vv->resources:0x%02x, we want:0x%02x\n",vv
->resources
,bit
));
21 /* no, someone else uses it */
22 mutex_unlock(&dev
->lock
);
25 /* it's free, grab it */
28 DEB_D(("res: get 0x%02x, cur:0x%02x\n",bit
,vv
->resources
));
29 mutex_unlock(&dev
->lock
);
33 void saa7146_res_free(struct saa7146_fh
*fh
, unsigned int bits
)
35 struct saa7146_dev
*dev
= fh
->dev
;
36 struct saa7146_vv
*vv
= dev
->vv_data
;
38 BUG_ON((fh
->resources
& bits
) != bits
);
40 mutex_lock(&dev
->lock
);
41 fh
->resources
&= ~bits
;
42 vv
->resources
&= ~bits
;
43 DEB_D(("res: put 0x%02x, cur:0x%02x\n",bits
,vv
->resources
));
44 mutex_unlock(&dev
->lock
);
48 /********************************************************************************/
49 /* common dma functions */
51 void saa7146_dma_free(struct saa7146_dev
*dev
,struct videobuf_queue
*q
,
52 struct saa7146_buf
*buf
)
54 struct videobuf_dmabuf
*dma
=videobuf_to_dma(&buf
->vb
);
55 DEB_EE(("dev:%p, buf:%p\n",dev
,buf
));
57 BUG_ON(in_interrupt());
59 videobuf_waiton(&buf
->vb
,0,0);
60 videobuf_dma_unmap(q
->dev
, dma
);
61 videobuf_dma_free(dma
);
62 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
66 /********************************************************************************/
67 /* common buffer functions */
69 int saa7146_buffer_queue(struct saa7146_dev
*dev
,
70 struct saa7146_dmaqueue
*q
,
71 struct saa7146_buf
*buf
)
73 assert_spin_locked(&dev
->slock
);
74 DEB_EE(("dev:%p, dmaq:%p, buf:%p\n", dev
, q
, buf
));
78 if (NULL
== q
->curr
) {
80 DEB_D(("immediately activating buffer %p\n", buf
));
81 buf
->activate(dev
,buf
,NULL
);
83 list_add_tail(&buf
->vb
.queue
,&q
->queue
);
84 buf
->vb
.state
= VIDEOBUF_QUEUED
;
85 DEB_D(("adding buffer %p to queue. (active buffer present)\n", buf
));
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", buf
, q
->queue
.prev
,q
->queue
.next
));
131 buf
->activate(dev
,buf
,next
);
133 DEB_INT(("no next buffer. stopping.\n"));
135 /* turn off video-dma3 */
136 saa7146_write(dev
,MC1
, MASK_20
);
138 /* nothing to do -- just prevent next video-dma1 transfer
139 by lowering the protection address */
142 saa7146_write(dev
, PROT_ADDR1
, 0);
143 saa7146_write(dev
, MC2
, (MASK_02
|MASK_18
));
145 /* write the address of the rps-program */
146 saa7146_write(dev
, RPS_ADDR0
, dev
->d_rps0
.dma_handle
);
148 saa7146_write(dev
, MC1
, (MASK_12
| MASK_28
));
151 printk("vdma%d.base_even: 0x%08x\n", 1,saa7146_read(dev,BASE_EVEN1));
152 printk("vdma%d.base_odd: 0x%08x\n", 1,saa7146_read(dev,BASE_ODD1));
153 printk("vdma%d.prot_addr: 0x%08x\n", 1,saa7146_read(dev,PROT_ADDR1));
154 printk("vdma%d.base_page: 0x%08x\n", 1,saa7146_read(dev,BASE_PAGE1));
155 printk("vdma%d.pitch: 0x%08x\n", 1,saa7146_read(dev,PITCH1));
156 printk("vdma%d.num_line_byte: 0x%08x\n", 1,saa7146_read(dev,NUM_LINE_BYTE1));
159 del_timer(&q
->timeout
);
163 void saa7146_buffer_timeout(unsigned long data
)
165 struct saa7146_dmaqueue
*q
= (struct saa7146_dmaqueue
*)data
;
166 struct saa7146_dev
*dev
= q
->dev
;
169 DEB_EE(("dev:%p, dmaq:%p\n", dev
, q
));
171 spin_lock_irqsave(&dev
->slock
,flags
);
173 DEB_D(("timeout on %p\n", q
->curr
));
174 saa7146_buffer_finish(dev
,q
,VIDEOBUF_ERROR
);
177 /* we don't restart the transfer here like other drivers do. when
178 a streaming capture is disabled, the timeout function will be
179 called for the current buffer. if we activate the next buffer now,
180 we mess up our capture logic. if a timeout occurs on another buffer,
181 then something is seriously broken before, so no need to buffer the
182 next capture IMHO... */
184 saa7146_buffer_next(dev,q);
186 spin_unlock_irqrestore(&dev
->slock
,flags
);
189 /********************************************************************************/
190 /* file operations */
192 static int fops_open(struct file
*file
)
194 struct video_device
*vdev
= video_devdata(file
);
195 struct saa7146_dev
*dev
= video_drvdata(file
);
196 struct saa7146_fh
*fh
= NULL
;
199 enum v4l2_buf_type type
;
201 DEB_EE(("file:%p, dev:%s\n", file
, video_device_node_name(vdev
)));
203 if (mutex_lock_interruptible(&saa7146_devices_lock
))
206 DEB_D(("using: %p\n",dev
));
208 type
= vdev
->vfl_type
== VFL_TYPE_GRABBER
209 ? V4L2_BUF_TYPE_VIDEO_CAPTURE
210 : V4L2_BUF_TYPE_VBI_CAPTURE
;
212 /* check if an extension is registered */
213 if( NULL
== dev
->ext
) {
214 DEB_S(("no extension registered for this device.\n"));
219 /* allocate per open data */
220 fh
= kzalloc(sizeof(*fh
),GFP_KERNEL
);
222 DEB_S(("cannot allocate memory for per open data.\n"));
227 file
->private_data
= fh
;
231 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
232 DEB_S(("initializing vbi...\n"));
233 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
234 result
= saa7146_vbi_uops
.open(dev
,file
);
235 if (dev
->ext_vv_data
->vbi_fops
.open
)
236 dev
->ext_vv_data
->vbi_fops
.open(file
);
238 DEB_S(("initializing video...\n"));
239 result
= saa7146_video_uops
.open(dev
,file
);
246 if( 0 == try_module_get(dev
->ext
->module
)) {
253 if (fh
&& result
!= 0) {
255 file
->private_data
= NULL
;
257 mutex_unlock(&saa7146_devices_lock
);
261 static int fops_release(struct file
*file
)
263 struct saa7146_fh
*fh
= file
->private_data
;
264 struct saa7146_dev
*dev
= fh
->dev
;
266 DEB_EE(("file:%p\n", file
));
268 if (mutex_lock_interruptible(&saa7146_devices_lock
))
271 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
272 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
273 saa7146_vbi_uops
.release(dev
,file
);
274 if (dev
->ext_vv_data
->vbi_fops
.release
)
275 dev
->ext_vv_data
->vbi_fops
.release(file
);
277 saa7146_video_uops
.release(dev
,file
);
280 module_put(dev
->ext
->module
);
281 file
->private_data
= NULL
;
284 mutex_unlock(&saa7146_devices_lock
);
289 static int fops_mmap(struct file
*file
, struct vm_area_struct
* vma
)
291 struct saa7146_fh
*fh
= file
->private_data
;
292 struct videobuf_queue
*q
;
295 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
296 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, vma:%p\n",file
, vma
));
300 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
301 DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, vma:%p\n",file
, vma
));
310 return videobuf_mmap_mapper(q
,vma
);
313 static unsigned int fops_poll(struct file
*file
, struct poll_table_struct
*wait
)
315 struct saa7146_fh
*fh
= file
->private_data
;
316 struct videobuf_buffer
*buf
= NULL
;
317 struct videobuf_queue
*q
;
319 DEB_EE(("file:%p, poll:%p\n",file
, wait
));
321 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
322 if( 0 == fh
->vbi_q
.streaming
)
323 return videobuf_poll_stream(file
, &fh
->vbi_q
, wait
);
326 DEB_D(("using video queue.\n"));
330 if (!list_empty(&q
->stream
))
331 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
334 DEB_D(("buf == NULL!\n"));
338 poll_wait(file
, &buf
->done
, wait
);
339 if (buf
->state
== VIDEOBUF_DONE
|| buf
->state
== VIDEOBUF_ERROR
) {
340 DEB_D(("poll succeeded!\n"));
341 return POLLIN
|POLLRDNORM
;
344 DEB_D(("nothing to poll for, buf->state:%d\n",buf
->state
));
348 static ssize_t
fops_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
350 struct saa7146_fh
*fh
= file
->private_data
;
353 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
354 // DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, data:%p, count:%lun", file, data, (unsigned long)count));
355 return saa7146_video_uops
.read(file
,data
,count
,ppos
);
357 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
358 // DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, data:%p, count:%lu\n", file, data, (unsigned long)count));
359 if (fh
->dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
360 return saa7146_vbi_uops
.read(file
,data
,count
,ppos
);
371 static ssize_t
fops_write(struct file
*file
, const char __user
*data
, size_t count
, loff_t
*ppos
)
373 struct saa7146_fh
*fh
= file
->private_data
;
376 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
378 case V4L2_BUF_TYPE_VBI_CAPTURE
:
379 if (fh
->dev
->ext_vv_data
->vbi_fops
.write
)
380 return fh
->dev
->ext_vv_data
->vbi_fops
.write(file
, data
, count
, ppos
);
389 static const struct v4l2_file_operations video_fops
=
391 .owner
= THIS_MODULE
,
393 .release
= fops_release
,
398 .ioctl
= video_ioctl2
,
401 static void vv_callback(struct saa7146_dev
*dev
, unsigned long status
)
405 DEB_INT(("dev:%p, isr:0x%08x\n",dev
,(u32
)status
));
407 if (0 != (isr
& (MASK_27
))) {
408 DEB_INT(("irq: RPS0 (0x%08x).\n",isr
));
409 saa7146_video_uops
.irq_done(dev
,isr
);
412 if (0 != (isr
& (MASK_28
))) {
413 u32 mc2
= saa7146_read(dev
, MC2
);
414 if( 0 != (mc2
& MASK_15
)) {
415 DEB_INT(("irq: RPS1 vbi workaround (0x%08x).\n",isr
));
416 wake_up(&dev
->vv_data
->vbi_wq
);
417 saa7146_write(dev
,MC2
, MASK_31
);
420 DEB_INT(("irq: RPS1 (0x%08x).\n",isr
));
421 saa7146_vbi_uops
.irq_done(dev
,isr
);
425 int saa7146_vv_init(struct saa7146_dev
* dev
, struct saa7146_ext_vv
*ext_vv
)
427 struct saa7146_vv
*vv
;
430 err
= v4l2_device_register(&dev
->pci
->dev
, &dev
->v4l2_dev
);
434 vv
= kzalloc(sizeof(struct saa7146_vv
), GFP_KERNEL
);
436 ERR(("out of memory. aborting.\n"));
439 ext_vv
->ops
= saa7146_video_ioctl_ops
;
440 ext_vv
->core_ops
= &saa7146_video_ioctl_ops
;
442 DEB_EE(("dev:%p\n",dev
));
444 /* set default values for video parts of the saa7146 */
445 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
447 /* enable video-port pins */
448 saa7146_write(dev
, MC1
, (MASK_10
| MASK_26
));
450 /* save per-device extension data (one extension can
451 handle different devices that might need different
452 configuration data) */
453 dev
->ext_vv_data
= ext_vv
;
455 vv
->d_clipping
.cpu_addr
= pci_alloc_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, &vv
->d_clipping
.dma_handle
);
456 if( NULL
== vv
->d_clipping
.cpu_addr
) {
457 ERR(("out of memory. aborting.\n"));
461 memset(vv
->d_clipping
.cpu_addr
, 0x0, SAA7146_CLIPPING_MEM
);
463 saa7146_video_uops
.init(dev
,vv
);
464 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
465 saa7146_vbi_uops
.init(dev
,vv
);
468 dev
->vv_callback
= &vv_callback
;
472 EXPORT_SYMBOL_GPL(saa7146_vv_init
);
474 int saa7146_vv_release(struct saa7146_dev
* dev
)
476 struct saa7146_vv
*vv
= dev
->vv_data
;
478 DEB_EE(("dev:%p\n",dev
));
480 v4l2_device_unregister(&dev
->v4l2_dev
);
481 pci_free_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, vv
->d_clipping
.cpu_addr
, vv
->d_clipping
.dma_handle
);
484 dev
->vv_callback
= NULL
;
488 EXPORT_SYMBOL_GPL(saa7146_vv_release
);
490 int saa7146_register_device(struct video_device
**vid
, struct saa7146_dev
* dev
,
491 char *name
, int type
)
493 struct video_device
*vfd
;
497 DEB_EE(("dev:%p, name:'%s', type:%d\n",dev
,name
,type
));
499 // released by vfd->release
500 vfd
= video_device_alloc();
504 vfd
->fops
= &video_fops
;
505 vfd
->ioctl_ops
= &dev
->ext_vv_data
->ops
;
506 vfd
->release
= video_device_release
;
508 for (i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
509 vfd
->tvnorms
|= dev
->ext_vv_data
->stds
[i
].id
;
510 strlcpy(vfd
->name
, name
, sizeof(vfd
->name
));
511 video_set_drvdata(vfd
, dev
);
513 err
= video_register_device(vfd
, type
, -1);
515 ERR(("cannot register v4l2 device. skipping.\n"));
516 video_device_release(vfd
);
520 INFO(("%s: registered device %s [v4l2]\n",
521 dev
->name
, video_device_node_name(vfd
)));
526 EXPORT_SYMBOL_GPL(saa7146_register_device
);
528 int saa7146_unregister_device(struct video_device
**vid
, struct saa7146_dev
* dev
)
530 DEB_EE(("dev:%p\n",dev
));
532 video_unregister_device(*vid
);
537 EXPORT_SYMBOL_GPL(saa7146_unregister_device
);
539 static int __init
saa7146_vv_init_module(void)
545 static void __exit
saa7146_vv_cleanup_module(void)
549 module_init(saa7146_vv_init_module
);
550 module_exit(saa7146_vv_cleanup_module
);
552 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
553 MODULE_DESCRIPTION("video4linux driver for saa7146-based hardware");
554 MODULE_LICENSE("GPL");