1 /* 2 em28xx-vbi.c - VBI driver for em28xx 3 4 Copyright (C) 2009 Devin Heitmueller <dheitmueller@kernellabs.com> 5 6 This work was sponsored by EyeMagnet Limited. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 21 02110-1301, USA. 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/hardirq.h> 27 #include <linux/init.h> 28 29 #include "em28xx.h" 30 31 static unsigned int vbibufs = 5; 32 module_param(vbibufs, int, 0644); 33 MODULE_PARM_DESC(vbibufs, "number of vbi buffers, range 2-32"); 34 35 static unsigned int vbi_debug; 36 module_param(vbi_debug, int, 0644); 37 MODULE_PARM_DESC(vbi_debug, "enable debug messages [vbi]"); 38 39 #define dprintk(level, fmt, arg...) if (vbi_debug >= level) \ 40 printk(KERN_DEBUG "%s: " fmt, dev->core->name , ## arg) 41 42 /* ------------------------------------------------------------------ */ 43 44 static void 45 free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf) 46 { 47 struct em28xx_fh *fh = vq->priv_data; 48 struct em28xx *dev = fh->dev; 49 unsigned long flags = 0; 50 if (in_interrupt()) 51 BUG(); 52 53 /* We used to wait for the buffer to finish here, but this didn't work 54 because, as we were keeping the state as VIDEOBUF_QUEUED, 55 videobuf_queue_cancel marked it as finished for us. 56 (Also, it could wedge forever if the hardware was misconfigured.) 57 58 This should be safe; by the time we get here, the buffer isn't 59 queued anymore. If we ever start marking the buffers as 60 VIDEOBUF_ACTIVE, it won't be, though. 61 */ 62 spin_lock_irqsave(&dev->slock, flags); 63 if (dev->isoc_ctl.vbi_buf == buf) 64 dev->isoc_ctl.vbi_buf = NULL; 65 spin_unlock_irqrestore(&dev->slock, flags); 66 67 videobuf_vmalloc_free(&buf->vb); 68 buf->vb.state = VIDEOBUF_NEEDS_INIT; 69 } 70 71 static int 72 vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size) 73 { 74 struct em28xx_fh *fh = q->priv_data; 75 struct em28xx *dev = fh->dev; 76 77 *size = dev->vbi_width * dev->vbi_height * 2; 78 79 if (0 == *count) 80 *count = vbibufs; 81 if (*count < 2) 82 *count = 2; 83 if (*count > 32) 84 *count = 32; 85 return 0; 86 } 87 88 static int 89 vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, 90 enum v4l2_field field) 91 { 92 struct em28xx_fh *fh = q->priv_data; 93 struct em28xx *dev = fh->dev; 94 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb); 95 int rc = 0; 96 97 buf->vb.size = dev->vbi_width * dev->vbi_height * 2; 98 99 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 100 return -EINVAL; 101 102 buf->vb.width = dev->vbi_width; 103 buf->vb.height = dev->vbi_height; 104 buf->vb.field = field; 105 106 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 107 rc = videobuf_iolock(q, &buf->vb, NULL); 108 if (rc < 0) 109 goto fail; 110 } 111 112 buf->vb.state = VIDEOBUF_PREPARED; 113 return 0; 114 115 fail: 116 free_buffer(q, buf); 117 return rc; 118 } 119 120 static void 121 vbi_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) 122 { 123 struct em28xx_buffer *buf = container_of(vb, 124 struct em28xx_buffer, 125 vb); 126 struct em28xx_fh *fh = vq->priv_data; 127 struct em28xx *dev = fh->dev; 128 struct em28xx_dmaqueue *vbiq = &dev->vbiq; 129 130 buf->vb.state = VIDEOBUF_QUEUED; 131 list_add_tail(&buf->vb.queue, &vbiq->active); 132 } 133 134 static void vbi_release(struct videobuf_queue *q, struct videobuf_buffer *vb) 135 { 136 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb); 137 free_buffer(q, buf); 138 } 139 140 struct videobuf_queue_ops em28xx_vbi_qops = { 141 .buf_setup = vbi_setup, 142 .buf_prepare = vbi_prepare, 143 .buf_queue = vbi_queue, 144 .buf_release = vbi_release, 145 }; 146