1 #include <media/saa7146_vv.h>
3 #define BOARD_CAN_DO_VBI(dev) (dev->revision != 0 && dev->vv_data->vbi_minor != -1)
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",bit
,vv
->resources
));
15 /* have it already allocated */
20 mutex_lock(&dev
->lock
);
21 if (vv
->resources
& bit
) {
22 DEB_D(("locked! vv->resources:0x%02x, we want:0x%02x\n",vv
->resources
,bit
));
23 /* no, someone else uses it */
24 mutex_unlock(&dev
->lock
);
27 /* it's free, grab it */
30 DEB_D(("res: get 0x%02x, cur:0x%02x\n",bit
,vv
->resources
));
31 mutex_unlock(&dev
->lock
);
35 void saa7146_res_free(struct saa7146_fh
*fh
, unsigned int bits
)
37 struct saa7146_dev
*dev
= fh
->dev
;
38 struct saa7146_vv
*vv
= dev
->vv_data
;
40 if ((fh
->resources
& bits
) != bits
)
43 mutex_lock(&dev
->lock
);
44 fh
->resources
&= ~bits
;
45 vv
->resources
&= ~bits
;
46 DEB_D(("res: put 0x%02x, cur:0x%02x\n",bits
,vv
->resources
));
47 mutex_unlock(&dev
->lock
);
51 /********************************************************************************/
52 /* common dma functions */
54 void saa7146_dma_free(struct saa7146_dev
*dev
,struct saa7146_buf
*buf
)
56 DEB_EE(("dev:%p, buf:%p\n",dev
,buf
));
61 videobuf_waiton(&buf
->vb
,0,0);
62 videobuf_dma_pci_unmap(dev
->pci
, &buf
->vb
.dma
);
63 videobuf_dma_free(&buf
->vb
.dma
);
64 buf
->vb
.state
= STATE_NEEDS_INIT
;
68 /********************************************************************************/
69 /* common buffer functions */
71 int saa7146_buffer_queue(struct saa7146_dev
*dev
,
72 struct saa7146_dmaqueue
*q
,
73 struct saa7146_buf
*buf
)
75 assert_spin_locked(&dev
->slock
);
76 DEB_EE(("dev:%p, dmaq:%p, buf:%p\n", dev
, q
, buf
));
80 if (NULL
== q
->curr
) {
82 DEB_D(("immediately activating buffer %p\n", buf
));
83 buf
->activate(dev
,buf
,NULL
);
85 list_add_tail(&buf
->vb
.queue
,&q
->queue
);
86 buf
->vb
.state
= STATE_QUEUED
;
87 DEB_D(("adding buffer %p to queue. (active buffer present)\n", buf
));
92 void saa7146_buffer_finish(struct saa7146_dev
*dev
,
93 struct saa7146_dmaqueue
*q
,
96 assert_spin_locked(&dev
->slock
);
97 DEB_EE(("dev:%p, dmaq:%p, state:%d\n", dev
, q
, state
));
98 DEB_EE(("q->curr:%p\n",q
->curr
));
102 /* finish current buffer */
103 if (NULL
== q
->curr
) {
104 DEB_D(("aiii. no current buffer\n"));
108 q
->curr
->vb
.state
= state
;
109 do_gettimeofday(&q
->curr
->vb
.ts
);
110 wake_up(&q
->curr
->vb
.done
);
115 void saa7146_buffer_next(struct saa7146_dev
*dev
,
116 struct saa7146_dmaqueue
*q
, int vbi
)
118 struct saa7146_buf
*buf
,*next
= NULL
;
122 DEB_INT(("dev:%p, dmaq:%p, vbi:%d\n", dev
, q
, vbi
));
124 assert_spin_locked(&dev
->slock
);
125 if (!list_empty(&q
->queue
)) {
126 /* activate next one from queue */
127 buf
= list_entry(q
->queue
.next
,struct saa7146_buf
,vb
.queue
);
128 list_del(&buf
->vb
.queue
);
129 if (!list_empty(&q
->queue
))
130 next
= list_entry(q
->queue
.next
,struct saa7146_buf
, vb
.queue
);
132 DEB_INT(("next buffer: buf:%p, prev:%p, next:%p\n", buf
, q
->queue
.prev
,q
->queue
.next
));
133 buf
->activate(dev
,buf
,next
);
135 DEB_INT(("no next buffer. stopping.\n"));
137 /* turn off video-dma3 */
138 saa7146_write(dev
,MC1
, MASK_20
);
140 /* nothing to do -- just prevent next video-dma1 transfer
141 by lowering the protection address */
143 // fixme: fix this for vflip != 0
145 saa7146_write(dev
, PROT_ADDR1
, 0);
146 saa7146_write(dev
, MC2
, (MASK_02
|MASK_18
));
148 /* write the address of the rps-program */
149 saa7146_write(dev
, RPS_ADDR0
, dev
->d_rps0
.dma_handle
);
151 saa7146_write(dev
, MC1
, (MASK_12
| MASK_28
));
154 printk("vdma%d.base_even: 0x%08x\n", 1,saa7146_read(dev,BASE_EVEN1));
155 printk("vdma%d.base_odd: 0x%08x\n", 1,saa7146_read(dev,BASE_ODD1));
156 printk("vdma%d.prot_addr: 0x%08x\n", 1,saa7146_read(dev,PROT_ADDR1));
157 printk("vdma%d.base_page: 0x%08x\n", 1,saa7146_read(dev,BASE_PAGE1));
158 printk("vdma%d.pitch: 0x%08x\n", 1,saa7146_read(dev,PITCH1));
159 printk("vdma%d.num_line_byte: 0x%08x\n", 1,saa7146_read(dev,NUM_LINE_BYTE1));
162 del_timer(&q
->timeout
);
166 void saa7146_buffer_timeout(unsigned long data
)
168 struct saa7146_dmaqueue
*q
= (struct saa7146_dmaqueue
*)data
;
169 struct saa7146_dev
*dev
= q
->dev
;
172 DEB_EE(("dev:%p, dmaq:%p\n", dev
, q
));
174 spin_lock_irqsave(&dev
->slock
,flags
);
176 DEB_D(("timeout on %p\n", q
->curr
));
177 saa7146_buffer_finish(dev
,q
,STATE_ERROR
);
180 /* we don't restart the transfer here like other drivers do. when
181 a streaming capture is disabled, the timeout function will be
182 called for the current buffer. if we activate the next buffer now,
183 we mess up our capture logic. if a timeout occurs on another buffer,
184 then something is seriously broken before, so no need to buffer the
185 next capture IMHO... */
187 saa7146_buffer_next(dev,q);
189 spin_unlock_irqrestore(&dev
->slock
,flags
);
192 /********************************************************************************/
193 /* file operations */
195 static int fops_open(struct inode
*inode
, struct file
*file
)
197 unsigned int minor
= iminor(inode
);
198 struct saa7146_dev
*h
= NULL
, *dev
= NULL
;
199 struct list_head
*list
;
200 struct saa7146_fh
*fh
= NULL
;
203 enum v4l2_buf_type type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
205 DEB_EE(("inode:%p, file:%p, minor:%d\n",inode
,file
,minor
));
207 if (mutex_lock_interruptible(&saa7146_devices_lock
))
210 list_for_each(list
,&saa7146_devices
) {
211 h
= list_entry(list
, struct saa7146_dev
, item
);
212 if( NULL
== h
->vv_data
) {
213 DEB_D(("device %p has not registered video devices.\n",h
));
216 DEB_D(("trying: %p @ major %d,%d\n",h
,h
->vv_data
->video_minor
,h
->vv_data
->vbi_minor
));
218 if (h
->vv_data
->video_minor
== minor
) {
221 if (h
->vv_data
->vbi_minor
== minor
) {
222 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
227 DEB_S(("no such video device.\n"));
232 DEB_D(("using: %p\n",dev
));
234 /* check if an extension is registered */
235 if( NULL
== dev
->ext
) {
236 DEB_S(("no extension registered for this device.\n"));
241 /* allocate per open data */
242 fh
= kzalloc(sizeof(*fh
),GFP_KERNEL
);
244 DEB_S(("cannot allocate memory for per open data.\n"));
249 file
->private_data
= fh
;
253 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
254 DEB_S(("initializing vbi...\n"));
255 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
256 result
= saa7146_vbi_uops
.open(dev
,file
);
257 if (dev
->ext_vv_data
->vbi_fops
.open
)
258 dev
->ext_vv_data
->vbi_fops
.open(inode
, file
);
260 DEB_S(("initializing video...\n"));
261 result
= saa7146_video_uops
.open(dev
,file
);
268 if( 0 == try_module_get(dev
->ext
->module
)) {
275 if( fh
!= 0 && result
!= 0 ) {
277 file
->private_data
= NULL
;
279 mutex_unlock(&saa7146_devices_lock
);
283 static int fops_release(struct inode
*inode
, struct file
*file
)
285 struct saa7146_fh
*fh
= file
->private_data
;
286 struct saa7146_dev
*dev
= fh
->dev
;
288 DEB_EE(("inode:%p, file:%p\n",inode
,file
));
290 if (mutex_lock_interruptible(&saa7146_devices_lock
))
293 if( fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
294 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
295 saa7146_vbi_uops
.release(dev
,file
);
296 if (dev
->ext_vv_data
->vbi_fops
.release
)
297 dev
->ext_vv_data
->vbi_fops
.release(inode
, file
);
299 saa7146_video_uops
.release(dev
,file
);
302 module_put(dev
->ext
->module
);
303 file
->private_data
= NULL
;
306 mutex_unlock(&saa7146_devices_lock
);
311 int saa7146_video_do_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, void *arg
);
312 static int fops_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
315 DEB_EE(("inode:%p, file:%p, cmd:%d, arg:%li\n",inode, file, cmd, arg));
317 return video_usercopy(inode
, file
, cmd
, arg
, saa7146_video_do_ioctl
);
320 static int fops_mmap(struct file
*file
, struct vm_area_struct
* vma
)
322 struct saa7146_fh
*fh
= file
->private_data
;
323 struct videobuf_queue
*q
;
326 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
327 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, vma:%p\n",file
, vma
));
331 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
332 DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, vma:%p\n",file
, vma
));
341 return videobuf_mmap_mapper(q
,vma
);
344 static unsigned int fops_poll(struct file
*file
, struct poll_table_struct
*wait
)
346 struct saa7146_fh
*fh
= file
->private_data
;
347 struct videobuf_buffer
*buf
= NULL
;
348 struct videobuf_queue
*q
;
350 DEB_EE(("file:%p, poll:%p\n",file
, wait
));
352 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
353 if( 0 == fh
->vbi_q
.streaming
)
354 return videobuf_poll_stream(file
, &fh
->vbi_q
, wait
);
357 DEB_D(("using video queue.\n"));
361 if (!list_empty(&q
->stream
))
362 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
365 DEB_D(("buf == NULL!\n"));
369 poll_wait(file
, &buf
->done
, wait
);
370 if (buf
->state
== STATE_DONE
|| buf
->state
== STATE_ERROR
) {
371 DEB_D(("poll succeeded!\n"));
372 return POLLIN
|POLLRDNORM
;
375 DEB_D(("nothing to poll for, buf->state:%d\n",buf
->state
));
379 static ssize_t
fops_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
381 struct saa7146_fh
*fh
= file
->private_data
;
384 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
385 // DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: file:%p, data:%p, count:%lun", file, data, (unsigned long)count));
386 return saa7146_video_uops
.read(file
,data
,count
,ppos
);
388 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
389 // DEB_EE(("V4L2_BUF_TYPE_VBI_CAPTURE: file:%p, data:%p, count:%lu\n", file, data, (unsigned long)count));
390 if (fh
->dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
391 return saa7146_vbi_uops
.read(file
,data
,count
,ppos
);
402 static ssize_t
fops_write(struct file
*file
, const char __user
*data
, size_t count
, loff_t
*ppos
)
404 struct saa7146_fh
*fh
= file
->private_data
;
407 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
409 case V4L2_BUF_TYPE_VBI_CAPTURE
:
410 if (fh
->dev
->ext_vv_data
->vbi_fops
.write
)
411 return fh
->dev
->ext_vv_data
->vbi_fops
.write(file
, data
, count
, ppos
);
420 static struct file_operations video_fops
=
422 .owner
= THIS_MODULE
,
424 .release
= fops_release
,
433 static void vv_callback(struct saa7146_dev
*dev
, unsigned long status
)
437 DEB_INT(("dev:%p, isr:0x%08x\n",dev
,(u32
)status
));
439 if (0 != (isr
& (MASK_27
))) {
440 DEB_INT(("irq: RPS0 (0x%08x).\n",isr
));
441 saa7146_video_uops
.irq_done(dev
,isr
);
444 if (0 != (isr
& (MASK_28
))) {
445 u32 mc2
= saa7146_read(dev
, MC2
);
446 if( 0 != (mc2
& MASK_15
)) {
447 DEB_INT(("irq: RPS1 vbi workaround (0x%08x).\n",isr
));
448 wake_up(&dev
->vv_data
->vbi_wq
);
449 saa7146_write(dev
,MC2
, MASK_31
);
452 DEB_INT(("irq: RPS1 (0x%08x).\n",isr
));
453 saa7146_vbi_uops
.irq_done(dev
,isr
);
457 static struct video_device device_template
=
459 .hardware
= VID_HARDWARE_SAA7146
,
464 int saa7146_vv_init(struct saa7146_dev
* dev
, struct saa7146_ext_vv
*ext_vv
)
466 struct saa7146_vv
*vv
= kzalloc (sizeof(struct saa7146_vv
),GFP_KERNEL
);
468 ERR(("out of memory. aborting.\n"));
472 DEB_EE(("dev:%p\n",dev
));
474 /* set default values for video parts of the saa7146 */
475 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
477 /* enable video-port pins */
478 saa7146_write(dev
, MC1
, (MASK_10
| MASK_26
));
480 /* save per-device extension data (one extension can
481 handle different devices that might need different
482 configuration data) */
483 dev
->ext_vv_data
= ext_vv
;
485 vv
->video_minor
= -1;
488 vv
->d_clipping
.cpu_addr
= pci_alloc_consistent(dev
->pci
, SAA7146_CLIPPING_MEM
, &vv
->d_clipping
.dma_handle
);
489 if( NULL
== vv
->d_clipping
.cpu_addr
) {
490 ERR(("out of memory. aborting.\n"));
494 memset(vv
->d_clipping
.cpu_addr
, 0x0, SAA7146_CLIPPING_MEM
);
496 saa7146_video_uops
.init(dev
,vv
);
497 if (dev
->ext_vv_data
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
498 saa7146_vbi_uops
.init(dev
,vv
);
501 dev
->vv_callback
= &vv_callback
;
506 int saa7146_vv_release(struct saa7146_dev
* dev
)
508 struct saa7146_vv
*vv
= dev
->vv_data
;
510 DEB_EE(("dev:%p\n",dev
));
512 pci_free_consistent(dev
->pci
, SAA7146_RPS_MEM
, vv
->d_clipping
.cpu_addr
, vv
->d_clipping
.dma_handle
);
515 dev
->vv_callback
= NULL
;
520 int saa7146_register_device(struct video_device
**vid
, struct saa7146_dev
* dev
,
521 char *name
, int type
)
523 struct saa7146_vv
*vv
= dev
->vv_data
;
524 struct video_device
*vfd
;
526 DEB_EE(("dev:%p, name:'%s', type:%d\n",dev
,name
,type
));
528 // released by vfd->release
529 vfd
= video_device_alloc();
533 memcpy(vfd
, &device_template
, sizeof(struct video_device
));
534 strlcpy(vfd
->name
, name
, sizeof(vfd
->name
));
535 vfd
->release
= video_device_release
;
538 // fixme: -1 should be an insmod parameter *for the extension* (like "video_nr");
539 if (video_register_device(vfd
, type
, -1) < 0) {
540 ERR(("cannot register v4l2 device. skipping.\n"));
544 if( VFL_TYPE_GRABBER
== type
) {
545 vv
->video_minor
= vfd
->minor
;
546 INFO(("%s: registered device video%d [v4l2]\n",
547 dev
->name
, vfd
->minor
& 0x1f));
549 vv
->vbi_minor
= vfd
->minor
;
550 INFO(("%s: registered device vbi%d [v4l2]\n",
551 dev
->name
, vfd
->minor
& 0x1f));
558 int saa7146_unregister_device(struct video_device
**vid
, struct saa7146_dev
* dev
)
560 struct saa7146_vv
*vv
= dev
->vv_data
;
562 DEB_EE(("dev:%p\n",dev
));
564 if( VFL_TYPE_GRABBER
== (*vid
)->type
) {
565 vv
->video_minor
= -1;
570 video_unregister_device(*vid
);
576 static int __init
saa7146_vv_init_module(void)
582 static void __exit
saa7146_vv_cleanup_module(void)
586 module_init(saa7146_vv_init_module
);
587 module_exit(saa7146_vv_cleanup_module
);
589 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
590 MODULE_DESCRIPTION("video4linux driver for saa7146-based hardware");
591 MODULE_LICENSE("GPL");