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
, 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 */
141 // fixme: fix this for vflip != 0
143 saa7146_write(dev
, PROT_ADDR1
, 0);
144 saa7146_write(dev
, MC2
, (MASK_02
|MASK_18
));
146 /* write the address of the rps-program */
147 saa7146_write(dev
, RPS_ADDR0
, dev
->d_rps0
.dma_handle
);
149 saa7146_write(dev
, MC1
, (MASK_12
| MASK_28
));
152 printk("vdma%d.base_even: 0x%08x\n", 1,saa7146_read(dev,BASE_EVEN1));
153 printk("vdma%d.base_odd: 0x%08x\n", 1,saa7146_read(dev,BASE_ODD1));
154 printk("vdma%d.prot_addr: 0x%08x\n", 1,saa7146_read(dev,PROT_ADDR1));
155 printk("vdma%d.base_page: 0x%08x\n", 1,saa7146_read(dev,BASE_PAGE1));
156 printk("vdma%d.pitch: 0x%08x\n", 1,saa7146_read(dev,PITCH1));
157 printk("vdma%d.num_line_byte: 0x%08x\n", 1,saa7146_read(dev,NUM_LINE_BYTE1));
160 del_timer(&q
->timeout
);
164 void saa7146_buffer_timeout(unsigned long data
)
166 struct saa7146_dmaqueue
*q
= (struct saa7146_dmaqueue
*)data
;
167 struct saa7146_dev
*dev
= q
->dev
;
170 DEB_EE(("dev:%p, dmaq:%p\n", dev
, q
));
172 spin_lock_irqsave(&dev
->slock
,flags
);
174 DEB_D(("timeout on %p\n", q
->curr
));
175 saa7146_buffer_finish(dev
,q
,VIDEOBUF_ERROR
);
178 /* we don't restart the transfer here like other drivers do. when
179 a streaming capture is disabled, the timeout function will be
180 called for the current buffer. if we activate the next buffer now,
181 we mess up our capture logic. if a timeout occurs on another buffer,
182 then something is seriously broken before, so no need to buffer the
183 next capture IMHO... */
185 saa7146_buffer_next(dev,q);
187 spin_unlock_irqrestore(&dev
->slock
,flags
);
190 /********************************************************************************/
191 /* file operations */
193 static int fops_open(struct file
*file
)
195 struct video_device
*vdev
= video_devdata(file
);
196 struct saa7146_dev
*dev
= video_drvdata(file
);
197 struct saa7146_fh
*fh
= NULL
;
200 enum v4l2_buf_type type
;
202 DEB_EE(("file:%p, dev:%s\n", file
, video_device_node_name(vdev
)));
204 if (mutex_lock_interruptible(&saa7146_devices_lock
))
207 DEB_D(("using: %p\n",dev
));
209 type
= vdev
->vfl_type
== VFL_TYPE_GRABBER
210 ? V4L2_BUF_TYPE_VIDEO_CAPTURE
211 : V4L2_BUF_TYPE_VBI_CAPTURE
;
213 /* check if an extension is registered */
214 if( NULL
== dev
->ext
) {
215 DEB_S(("no extension registered for this device.\n"));
220 /* allocate per open data */
221 fh
= kzalloc(sizeof(*fh
),GFP_KERNEL
);
223 DEB_S(("cannot allocate memory for per open data.\n"));
228 file
->private_data
= fh
;
232 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
233 DEB_S(("initializing vbi...\n"));
234 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
235 result
= saa7146_vbi_uops
.open(dev
,file
);
236 if (dev
->ext_vv_data
->vbi_fops
.open
)
237 dev
->ext_vv_data
->vbi_fops
.open(file
);
239 DEB_S(("initializing video...\n"));
240 result
= saa7146_video_uops
.open(dev
,file
);
247 if( 0 == try_module_get(dev
->ext
->module
)) {
254 if (fh
&& result
!= 0) {
256 file
->private_data
= NULL
;
258 mutex_unlock(&saa7146_devices_lock
);
262 static int fops_release(struct file
*file
)
264 struct saa7146_fh
*fh
= file
->private_data
;
265 struct saa7146_dev
*dev
= fh
->dev
;
267 DEB_EE(("file:%p\n", file
));
269 if (mutex_lock_interruptible(&saa7146_devices_lock
))
272 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
273 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
274 saa7146_vbi_uops
.release(dev
,file
);
275 if (dev
->ext_vv_data
->vbi_fops
.release
)
276 dev
->ext_vv_data
->vbi_fops
.release(file
);
278 saa7146_video_uops
.release(dev
,file
);
281 module_put(dev
->ext
->module
);
282 file
->private_data
= NULL
;
285 mutex_unlock(&saa7146_devices_lock
);
290 static int fops_mmap(struct file
*file
, struct vm_area_struct
* vma
)
292 struct saa7146_fh
*fh
= file
->private_data
;
293 struct videobuf_queue
*q
;
296 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
297 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, vma:%p\n",file
, vma
));
301 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
302 DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, vma:%p\n",file
, vma
));
311 return videobuf_mmap_mapper(q
,vma
);
314 static unsigned int fops_poll(struct file
*file
, struct poll_table_struct
*wait
)
316 struct saa7146_fh
*fh
= file
->private_data
;
317 struct videobuf_buffer
*buf
= NULL
;
318 struct videobuf_queue
*q
;
320 DEB_EE(("file:%p, poll:%p\n",file
, wait
));
322 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
323 if( 0 == fh
->vbi_q
.streaming
)
324 return videobuf_poll_stream(file
, &fh
->vbi_q
, wait
);
327 DEB_D(("using video queue.\n"));
331 if (!list_empty(&q
->stream
))
332 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
335 DEB_D(("buf == NULL!\n"));
339 poll_wait(file
, &buf
->done
, wait
);
340 if (buf
->state
== VIDEOBUF_DONE
|| buf
->state
== VIDEOBUF_ERROR
) {
341 DEB_D(("poll succeeded!\n"));
342 return POLLIN
|POLLRDNORM
;
345 DEB_D(("nothing to poll for, buf->state:%d\n",buf
->state
));
349 static ssize_t
fops_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
351 struct saa7146_fh
*fh
= file
->private_data
;
354 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
355 // DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, data:%p, count:%lun", file, data, (unsigned long)count));
356 return saa7146_video_uops
.read(file
,data
,count
,ppos
);
358 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
359 // DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, data:%p, count:%lu\n", file, data, (unsigned long)count));
360 if (fh
->dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
361 return saa7146_vbi_uops
.read(file
,data
,count
,ppos
);
372 static ssize_t
fops_write(struct file
*file
, const char __user
*data
, size_t count
, loff_t
*ppos
)
374 struct saa7146_fh
*fh
= file
->private_data
;
377 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
379 case V4L2_BUF_TYPE_VBI_CAPTURE
:
380 if (fh
->dev
->ext_vv_data
->vbi_fops
.write
)
381 return fh
->dev
->ext_vv_data
->vbi_fops
.write(file
, data
, count
, ppos
);
390 static const struct v4l2_file_operations video_fops
=
392 .owner
= THIS_MODULE
,
394 .release
= fops_release
,
399 .ioctl
= video_ioctl2
,
402 static void vv_callback(struct saa7146_dev
*dev
, unsigned long status
)
406 DEB_INT(("dev:%p, isr:0x%08x\n",dev
,(u32
)status
));
408 if (0 != (isr
& (MASK_27
))) {
409 DEB_INT(("irq: RPS0 (0x%08x).\n",isr
));
410 saa7146_video_uops
.irq_done(dev
,isr
);
413 if (0 != (isr
& (MASK_28
))) {
414 u32 mc2
= saa7146_read(dev
, MC2
);
415 if( 0 != (mc2
& MASK_15
)) {
416 DEB_INT(("irq: RPS1 vbi workaround (0x%08x).\n",isr
));
417 wake_up(&dev
->vv_data
->vbi_wq
);
418 saa7146_write(dev
,MC2
, MASK_31
);
421 DEB_INT(("irq: RPS1 (0x%08x).\n",isr
));
422 saa7146_vbi_uops
.irq_done(dev
,isr
);
426 int saa7146_vv_devinit(struct saa7146_dev
*dev
)
428 return v4l2_device_register(&dev
->pci
->dev
, &dev
->v4l2_dev
);
430 EXPORT_SYMBOL_GPL(saa7146_vv_devinit
);
432 int saa7146_vv_init(struct saa7146_dev
* dev
, struct saa7146_ext_vv
*ext_vv
)
434 struct saa7146_vv
*vv
;
436 vv
= kzalloc(sizeof(struct saa7146_vv
), GFP_KERNEL
);
438 ERR(("out of memory. aborting.\n"));
441 ext_vv
->ops
= saa7146_video_ioctl_ops
;
442 ext_vv
->core_ops
= &saa7146_video_ioctl_ops
;
444 DEB_EE(("dev:%p\n",dev
));
446 /* set default values for video parts of the saa7146 */
447 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
449 /* enable video-port pins */
450 saa7146_write(dev
, MC1
, (MASK_10
| MASK_26
));
452 /* save per-device extension data (one extension can
453 handle different devices that might need different
454 configuration data) */
455 dev
->ext_vv_data
= ext_vv
;
457 vv
->d_clipping
.cpu_addr
= pci_alloc_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, &vv
->d_clipping
.dma_handle
);
458 if( NULL
== vv
->d_clipping
.cpu_addr
) {
459 ERR(("out of memory. aborting.\n"));
463 memset(vv
->d_clipping
.cpu_addr
, 0x0, SAA7146_CLIPPING_MEM
);
465 saa7146_video_uops
.init(dev
,vv
);
466 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
467 saa7146_vbi_uops
.init(dev
,vv
);
470 dev
->vv_callback
= &vv_callback
;
474 EXPORT_SYMBOL_GPL(saa7146_vv_init
);
476 int saa7146_vv_release(struct saa7146_dev
* dev
)
478 struct saa7146_vv
*vv
= dev
->vv_data
;
480 DEB_EE(("dev:%p\n",dev
));
482 v4l2_device_unregister(&dev
->v4l2_dev
);
483 pci_free_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, vv
->d_clipping
.cpu_addr
, vv
->d_clipping
.dma_handle
);
486 dev
->vv_callback
= NULL
;
490 EXPORT_SYMBOL_GPL(saa7146_vv_release
);
492 int saa7146_register_device(struct video_device
**vid
, struct saa7146_dev
* dev
,
493 char *name
, int type
)
495 struct video_device
*vfd
;
499 DEB_EE(("dev:%p, name:'%s', type:%d\n",dev
,name
,type
));
501 // released by vfd->release
502 vfd
= video_device_alloc();
506 vfd
->fops
= &video_fops
;
507 vfd
->ioctl_ops
= &dev
->ext_vv_data
->ops
;
508 vfd
->release
= video_device_release
;
510 for (i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
511 vfd
->tvnorms
|= dev
->ext_vv_data
->stds
[i
].id
;
512 strlcpy(vfd
->name
, name
, sizeof(vfd
->name
));
513 video_set_drvdata(vfd
, dev
);
515 err
= video_register_device(vfd
, type
, -1);
517 ERR(("cannot register v4l2 device. skipping.\n"));
518 video_device_release(vfd
);
522 INFO(("%s: registered device %s [v4l2]\n",
523 dev
->name
, video_device_node_name(vfd
)));
528 EXPORT_SYMBOL_GPL(saa7146_register_device
);
530 int saa7146_unregister_device(struct video_device
**vid
, struct saa7146_dev
* dev
)
532 DEB_EE(("dev:%p\n",dev
));
534 video_unregister_device(*vid
);
539 EXPORT_SYMBOL_GPL(saa7146_unregister_device
);
541 static int __init
saa7146_vv_init_module(void)
547 static void __exit
saa7146_vv_cleanup_module(void)
551 module_init(saa7146_vv_init_module
);
552 module_exit(saa7146_vv_cleanup_module
);
554 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
555 MODULE_DESCRIPTION("video4linux driver for saa7146-based hardware");
556 MODULE_LICENSE("GPL");