?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux/fpc-iii.git] / drivers / media / pci / cx25821 / cx25821-video.c
blobd270819fd8751417bb6fb60c2af1483e23a8a19a
1 /*
2 * Driver for the Conexant CX25821 PCIe bridge
3 *
4 * Copyright (C) 2009 Conexant Systems Inc.
5 * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
6 * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
7 * Parts adapted/taken from Eduardo Moscoso Rubino
8 * Copyright (C) 2009 Eduardo Moscoso Rubino <moscoso@TopoLogica.com>
9 *
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 *
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29 #include "cx25821-video.h"
30
31 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
32 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
33 MODULE_LICENSE("GPL");
34
35 static unsigned int video_nr[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET };
36
37 module_param_array(video_nr, int, NULL, 0444);
38
39 MODULE_PARM_DESC(video_nr, "video device numbers");
40
41 static unsigned int video_debug = VIDEO_DEBUG;
42 module_param(video_debug, int, 0644);
43 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
44
45 static unsigned int irq_debug;
46 module_param(irq_debug, int, 0644);
47 MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
48
49 static unsigned int vid_limit = 16;
50 module_param(vid_limit, int, 0644);
51 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
52
53 #define FORMAT_FLAGS_PACKED 0x01
54
55 static const struct cx25821_fmt formats[] = {
56 {
57 .name = "4:1:1, packed, Y41P",
58 .fourcc = V4L2_PIX_FMT_Y41P,
59 .depth = 12,
60 .flags = FORMAT_FLAGS_PACKED,
61 }, {
62 .name = "4:2:2, packed, YUYV",
63 .fourcc = V4L2_PIX_FMT_YUYV,
64 .depth = 16,
65 .flags = FORMAT_FLAGS_PACKED,
66 },
67 };
68
69 static const struct cx25821_fmt *cx25821_format_by_fourcc(unsigned int fourcc)
70 {
71 unsigned int i;
72
73 for (i = 0; i < ARRAY_SIZE(formats); i++)
74 if (formats[i].fourcc == fourcc)
75 return formats + i;
76 return NULL;
77 }
78
79 void cx25821_video_wakeup(struct cx25821_dev *dev, struct cx25821_dmaqueue *q,
80 u32 count)
81 {
82 struct cx25821_buffer *buf;
83 int bc;
84
85 for (bc = 0;; bc++) {
86 if (list_empty(&q->active)) {
87 dprintk(1, "bc=%d (=0: active empty)\n", bc);
88 break;
89 }
90
91 buf = list_entry(q->active.next, struct cx25821_buffer,
92 vb.queue);
93
94 /* count comes from the hw and it is 16bit wide --
95 * this trick handles wrap-arounds correctly for
96 * up to 32767 buffers in flight... */
97 if ((s16) (count - buf->count) < 0)
98 break;
99
100 v4l2_get_timestamp(&buf->vb.ts);
101 buf->vb.state = VIDEOBUF_DONE;
102 list_del(&buf->vb.queue);
103 wake_up(&buf->vb.done);
104 }
105
106 if (list_empty(&q->active))
107 del_timer(&q->timeout);
108 else
109 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
110 if (bc != 1)
111 pr_err("%s: %d buffers handled (should be 1)\n", __func__, bc);
112 }
113
114 int cx25821_start_video_dma(struct cx25821_dev *dev,
115 struct cx25821_dmaqueue *q,
116 struct cx25821_buffer *buf,
117 const struct sram_channel *channel)
118 {
119 int tmp = 0;
120
121 /* setup fifo + format */
122 cx25821_sram_channel_setup(dev, channel, buf->bpl, buf->risc.dma);
123
124 /* reset counter */
125 cx_write(channel->gpcnt_ctl, 3);
126 q->count = 1;
127
128 /* enable irq */
129 cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | (1 << channel->i));
130 cx_set(channel->int_msk, 0x11);
131
132 /* start dma */
133 cx_write(channel->dma_ctl, 0x11); /* FIFO and RISC enable */
134
135 /* make sure upstream setting if any is reversed */
136 tmp = cx_read(VID_CH_MODE_SEL);
137 cx_write(VID_CH_MODE_SEL, tmp & 0xFFFFFE00);
138
139 return 0;
140 }
141
142 static int cx25821_restart_video_queue(struct cx25821_dev *dev,
143 struct cx25821_dmaqueue *q,
144 const struct sram_channel *channel)
145 {
146 struct cx25821_buffer *buf, *prev;
147 struct list_head *item;
148
149 if (!list_empty(&q->active)) {
150 buf = list_entry(q->active.next, struct cx25821_buffer,
151 vb.queue);
152
153 cx25821_start_video_dma(dev, q, buf, channel);
154
155 list_for_each(item, &q->active) {
156 buf = list_entry(item, struct cx25821_buffer, vb.queue);
157 buf->count = q->count++;
158 }
159
160 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
161 return 0;
162 }
163
164 prev = NULL;
165 for (;;) {
166 if (list_empty(&q->queued))
167 return 0;
168
169 buf = list_entry(q->queued.next, struct cx25821_buffer,
170 vb.queue);
171
172 if (NULL == prev) {
173 list_move_tail(&buf->vb.queue, &q->active);
174 cx25821_start_video_dma(dev, q, buf, channel);
175 buf->vb.state = VIDEOBUF_ACTIVE;
176 buf->count = q->count++;
177 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
178 } else if (prev->vb.width == buf->vb.width &&
179 prev->vb.height == buf->vb.height &&
180 prev->fmt == buf->fmt) {
181 list_move_tail(&buf->vb.queue, &q->active);
182 buf->vb.state = VIDEOBUF_ACTIVE;
183 buf->count = q->count++;
184 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
185 prev->risc.jmp[2] = cpu_to_le32(0); /* Bits 63 - 32 */
186 } else {
187 return 0;
188 }
189 prev = buf;
190 }
191 }
192
193 static void cx25821_vid_timeout(unsigned long data)
194 {
195 struct cx25821_data *timeout_data = (struct cx25821_data *)data;
196 struct cx25821_dev *dev = timeout_data->dev;
197 const struct sram_channel *channel = timeout_data->channel;
198 struct cx25821_dmaqueue *q = &dev->channels[channel->i].dma_vidq;
199 struct cx25821_buffer *buf;
200 unsigned long flags;
201
202 /* cx25821_sram_channel_dump(dev, channel); */
203 cx_clear(channel->dma_ctl, 0x11);
204
205 spin_lock_irqsave(&dev->slock, flags);
206 while (!list_empty(&q->active)) {
207 buf = list_entry(q->active.next, struct cx25821_buffer,
208 vb.queue);
209 list_del(&buf->vb.queue);
210
211 buf->vb.state = VIDEOBUF_ERROR;
212 wake_up(&buf->vb.done);
213 }
214
215 cx25821_restart_video_queue(dev, q, channel);
216 spin_unlock_irqrestore(&dev->slock, flags);
217 }
218
219 int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status)
220 {
221 u32 count = 0;
222 int handled = 0;
223 u32 mask;
224 const struct sram_channel *channel = dev->channels[chan_num].sram_channels;
225
226 mask = cx_read(channel->int_msk);
227 if (0 == (status & mask))
228 return handled;
229
230 cx_write(channel->int_stat, status);
231
232 /* risc op code error */
233 if (status & (1 << 16)) {
234 pr_warn("%s, %s: video risc op code error\n",
235 dev->name, channel->name);
236 cx_clear(channel->dma_ctl, 0x11);
237 cx25821_sram_channel_dump(dev, channel);
238 }
239
240 /* risc1 y */
241 if (status & FLD_VID_DST_RISC1) {
242 spin_lock(&dev->slock);
243 count = cx_read(channel->gpcnt);
244 cx25821_video_wakeup(dev, &dev->channels[channel->i].dma_vidq,
245 count);
246 spin_unlock(&dev->slock);
247 handled++;
248 }
249
250 /* risc2 y */
251 if (status & 0x10) {
252 dprintk(2, "stopper video\n");
253 spin_lock(&dev->slock);
254 cx25821_restart_video_queue(dev,
255 &dev->channels[channel->i].dma_vidq, channel);
256 spin_unlock(&dev->slock);
257 handled++;
258 }
259 return handled;
260 }
261
262 static int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count,
263 unsigned int *size)
264 {
265 struct cx25821_channel *chan = q->priv_data;
266
267 *size = chan->fmt->depth * chan->width * chan->height >> 3;
268
269 if (0 == *count)
270 *count = 32;
271
272 if (*size * *count > vid_limit * 1024 * 1024)
273 *count = (vid_limit * 1024 * 1024) / *size;
274
275 return 0;
276 }
277
278 static int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
279 enum v4l2_field field)
280 {
281 struct cx25821_channel *chan = q->priv_data;
282 struct cx25821_dev *dev = chan->dev;
283 struct cx25821_buffer *buf =
284 container_of(vb, struct cx25821_buffer, vb);
285 int rc, init_buffer = 0;
286 u32 line0_offset;
287 struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
288 int bpl_local = LINE_SIZE_D1;
289
290 BUG_ON(NULL == chan->fmt);
291 if (chan->width < 48 || chan->width > 720 ||
292 chan->height < 32 || chan->height > 576)
293 return -EINVAL;
294
295 buf->vb.size = (chan->width * chan->height * chan->fmt->depth) >> 3;
296
297 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
298 return -EINVAL;
299
300 if (buf->fmt != chan->fmt ||
301 buf->vb.width != chan->width ||
302 buf->vb.height != chan->height || buf->vb.field != field) {
303 buf->fmt = chan->fmt;
304 buf->vb.width = chan->width;
305 buf->vb.height = chan->height;
306 buf->vb.field = field;
307 init_buffer = 1;
308 }
309
310 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
311 init_buffer = 1;
312 rc = videobuf_iolock(q, &buf->vb, NULL);
313 if (0 != rc) {
314 printk(KERN_DEBUG pr_fmt("videobuf_iolock failed!\n"));
315 goto fail;
316 }
317 }
318
319 dprintk(1, "init_buffer=%d\n", init_buffer);
320
321 if (init_buffer) {
322 if (chan->pixel_formats == PIXEL_FRMT_411)
323 buf->bpl = (buf->fmt->depth * buf->vb.width) >> 3;
324 else
325 buf->bpl = (buf->fmt->depth >> 3) * (buf->vb.width);
326
327 if (chan->pixel_formats == PIXEL_FRMT_411) {
328 bpl_local = buf->bpl;
329 } else {
330 bpl_local = buf->bpl; /* Default */
331
332 if (chan->use_cif_resolution) {
333 if (dev->tvnorm & V4L2_STD_625_50)
334 bpl_local = 352 << 1;
335 else
336 bpl_local = chan->cif_width << 1;
337 }
338 }
339
340 switch (buf->vb.field) {
341 case V4L2_FIELD_TOP:
342 cx25821_risc_buffer(dev->pci, &buf->risc,
343 dma->sglist, 0, UNSET,
344 buf->bpl, 0, buf->vb.height);
345 break;
346 case V4L2_FIELD_BOTTOM:
347 cx25821_risc_buffer(dev->pci, &buf->risc,
348 dma->sglist, UNSET, 0,
349 buf->bpl, 0, buf->vb.height);
350 break;
351 case V4L2_FIELD_INTERLACED:
352 /* All other formats are top field first */
353 line0_offset = 0;
354 dprintk(1, "top field first\n");
355
356 cx25821_risc_buffer(dev->pci, &buf->risc,
357 dma->sglist, line0_offset,
358 bpl_local, bpl_local, bpl_local,
359 buf->vb.height >> 1);
360 break;
361 case V4L2_FIELD_SEQ_TB:
362 cx25821_risc_buffer(dev->pci, &buf->risc,
363 dma->sglist,
364 0, buf->bpl * (buf->vb.height >> 1),
365 buf->bpl, 0, buf->vb.height >> 1);
366 break;
367 case V4L2_FIELD_SEQ_BT:
368 cx25821_risc_buffer(dev->pci, &buf->risc,
369 dma->sglist,
370 buf->bpl * (buf->vb.height >> 1), 0,
371 buf->bpl, 0, buf->vb.height >> 1);
372 break;
373 default:
374 BUG();
375 }
376 }
377
378 dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
379 buf, buf->vb.i, chan->width, chan->height, chan->fmt->depth,
380 chan->fmt->name, (unsigned long)buf->risc.dma);
381
382 buf->vb.state = VIDEOBUF_PREPARED;
383
384 return 0;
385
386 fail:
387 cx25821_free_buffer(q, buf);
388 return rc;
389 }
390
391 static void cx25821_buffer_release(struct videobuf_queue *q,
392 struct videobuf_buffer *vb)
393 {
394 struct cx25821_buffer *buf =
395 container_of(vb, struct cx25821_buffer, vb);
396
397 cx25821_free_buffer(q, buf);
398 }
399
400 static int cx25821_video_mmap(struct file *file, struct vm_area_struct *vma)
401 {
402 struct cx25821_channel *chan = video_drvdata(file);
403
404 return videobuf_mmap_mapper(&chan->vidq, vma);
405 }
406
407
408 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
409 {
410 struct cx25821_buffer *buf =
411 container_of(vb, struct cx25821_buffer, vb);
412 struct cx25821_buffer *prev;
413 struct cx25821_channel *chan = vq->priv_data;
414 struct cx25821_dev *dev = chan->dev;
415 struct cx25821_dmaqueue *q = &dev->channels[chan->id].dma_vidq;
416
417 /* add jump to stopper */
418 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
419 buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
420 buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
421
422 dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
423
424 if (!list_empty(&q->queued)) {
425 list_add_tail(&buf->vb.queue, &q->queued);
426 buf->vb.state = VIDEOBUF_QUEUED;
427 dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf,
428 buf->vb.i);
429
430 } else if (list_empty(&q->active)) {
431 list_add_tail(&buf->vb.queue, &q->active);
432 cx25821_start_video_dma(dev, q, buf, chan->sram_channels);
433 buf->vb.state = VIDEOBUF_ACTIVE;
434 buf->count = q->count++;
435 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
436 dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
437 buf, buf->vb.i, buf->count, q->count);
438 } else {
439 prev = list_entry(q->active.prev, struct cx25821_buffer,
440 vb.queue);
441 if (prev->vb.width == buf->vb.width
442 && prev->vb.height == buf->vb.height
443 && prev->fmt == buf->fmt) {
444 list_add_tail(&buf->vb.queue, &q->active);
445 buf->vb.state = VIDEOBUF_ACTIVE;
446 buf->count = q->count++;
447 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
448
449 /* 64 bit bits 63-32 */
450 prev->risc.jmp[2] = cpu_to_le32(0);
451 dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n",
452 buf, buf->vb.i, buf->count);
453
454 } else {
455 list_add_tail(&buf->vb.queue, &q->queued);
456 buf->vb.state = VIDEOBUF_QUEUED;
457 dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf,
458 buf->vb.i);
459 }
460 }
461
462 if (list_empty(&q->active))
463 dprintk(2, "active queue empty!\n");
464 }
465
466 static struct videobuf_queue_ops cx25821_video_qops = {
467 .buf_setup = cx25821_buffer_setup,
468 .buf_prepare = cx25821_buffer_prepare,
469 .buf_queue = buffer_queue,
470 .buf_release = cx25821_buffer_release,
471 };
472
473 static ssize_t video_read(struct file *file, char __user * data, size_t count,
474 loff_t *ppos)
475 {
476 struct v4l2_fh *fh = file->private_data;
477 struct cx25821_channel *chan = video_drvdata(file);
478 struct cx25821_dev *dev = chan->dev;
479 int err = 0;
480
481 if (mutex_lock_interruptible(&dev->lock))
482 return -ERESTARTSYS;
483 if (chan->streaming_fh && chan->streaming_fh != fh) {
484 err = -EBUSY;
485 goto unlock;
486 }
487 chan->streaming_fh = fh;
488
489 err = videobuf_read_one(&chan->vidq, data, count, ppos,
490 file->f_flags & O_NONBLOCK);
491 unlock:
492 mutex_unlock(&dev->lock);
493 return err;
494 }
495
496 static unsigned int video_poll(struct file *file,
497 struct poll_table_struct *wait)
498 {
499 struct cx25821_channel *chan = video_drvdata(file);
500 unsigned long req_events = poll_requested_events(wait);
501 unsigned int res = v4l2_ctrl_poll(file, wait);
502
503 if (req_events & (POLLIN | POLLRDNORM))
504 res |= videobuf_poll_stream(file, &chan->vidq, wait);
505 return res;
506
507 /* This doesn't belong in poll(). This can be done
508 * much better with vb2. We keep this code here as a
509 * reminder.
510 if ((res & POLLIN) && buf->vb.state == VIDEOBUF_DONE) {
511 struct cx25821_dev *dev = chan->dev;
512
513 if (dev && chan->use_cif_resolution) {
514 u8 cam_id = *((char *)buf->vb.baddr + 3);
515 memcpy((char *)buf->vb.baddr,
516 (char *)buf->vb.baddr + (chan->width * 2),
517 (chan->width * 2));
518 *((char *)buf->vb.baddr + 3) = cam_id;
519 }
520 }
521 */
522 }
523
524 static int video_release(struct file *file)
525 {
526 struct cx25821_channel *chan = video_drvdata(file);
527 struct v4l2_fh *fh = file->private_data;
528 struct cx25821_dev *dev = chan->dev;
529 const struct sram_channel *sram_ch =
530 dev->channels[0].sram_channels;
531
532 mutex_lock(&dev->lock);
533 /* stop the risc engine and fifo */
534 cx_write(sram_ch->dma_ctl, 0); /* FIFO and RISC disable */
535
536 /* stop video capture */
537 if (chan->streaming_fh == fh) {
538 videobuf_queue_cancel(&chan->vidq);
539 chan->streaming_fh = NULL;
540 }
541
542 if (chan->vidq.read_buf) {
543 cx25821_buffer_release(&chan->vidq, chan->vidq.read_buf);
544 kfree(chan->vidq.read_buf);
545 }
546
547 videobuf_mmap_free(&chan->vidq);
548 mutex_unlock(&dev->lock);
549
550 return v4l2_fh_release(file);
551 }
552
553 /* VIDEO IOCTLS */
554
555 static int cx25821_vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
556 struct v4l2_fmtdesc *f)
557 {
558 if (unlikely(f->index >= ARRAY_SIZE(formats)))
559 return -EINVAL;
560
561 strlcpy(f->description, formats[f->index].name, sizeof(f->description));
562 f->pixelformat = formats[f->index].fourcc;
563
564 return 0;
565 }
566
567 static int cx25821_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
568 struct v4l2_format *f)
569 {
570 struct cx25821_channel *chan = video_drvdata(file);
571
572 f->fmt.pix.width = chan->width;
573 f->fmt.pix.height = chan->height;
574 f->fmt.pix.field = chan->vidq.field;
575 f->fmt.pix.pixelformat = chan->fmt->fourcc;
576 f->fmt.pix.bytesperline = (chan->width * chan->fmt->depth) >> 3;
577 f->fmt.pix.sizeimage = chan->height * f->fmt.pix.bytesperline;
578 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
579 f->fmt.pix.priv = 0;
580
581 return 0;
582 }
583
584 static int cx25821_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
585 struct v4l2_format *f)
586 {
587 struct cx25821_channel *chan = video_drvdata(file);
588 struct cx25821_dev *dev = chan->dev;
589 const struct cx25821_fmt *fmt;
590 enum v4l2_field field = f->fmt.pix.field;
591 unsigned int maxh;
592 unsigned w;
593
594 fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
595 if (NULL == fmt)
596 return -EINVAL;
597 maxh = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
598
599 w = f->fmt.pix.width;
600 if (field != V4L2_FIELD_BOTTOM)
601 field = V4L2_FIELD_TOP;
602 if (w < 352) {
603 w = 176;
604 f->fmt.pix.height = maxh / 4;
605 } else if (w < 720) {
606 w = 352;
607 f->fmt.pix.height = maxh / 2;
608 } else {
609 w = 720;
610 f->fmt.pix.height = maxh;
611 field = V4L2_FIELD_INTERLACED;
612 }
613 f->fmt.pix.field = field;
614 f->fmt.pix.width = w;
615 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
616 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
617 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
618 f->fmt.pix.priv = 0;
619
620 return 0;
621 }
622
623 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
624 struct v4l2_format *f)
625 {
626 struct cx25821_channel *chan = video_drvdata(file);
627 struct cx25821_dev *dev = chan->dev;
628 int pix_format = PIXEL_FRMT_422;
629 int err;
630
631 err = cx25821_vidioc_try_fmt_vid_cap(file, priv, f);
632
633 if (0 != err)
634 return err;
635
636 chan->fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
637 chan->vidq.field = f->fmt.pix.field;
638 chan->width = f->fmt.pix.width;
639 chan->height = f->fmt.pix.height;
640
641 if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
642 pix_format = PIXEL_FRMT_411;
643 else
644 pix_format = PIXEL_FRMT_422;
645
646 cx25821_set_pixel_format(dev, SRAM_CH00, pix_format);
647
648 /* check if cif resolution */
649 if (chan->width == 320 || chan->width == 352)
650 chan->use_cif_resolution = 1;
651 else
652 chan->use_cif_resolution = 0;
653
654 chan->cif_width = chan->width;
655 medusa_set_resolution(dev, chan->width, SRAM_CH00);
656 return 0;
657 }
658
659 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
660 {
661 struct cx25821_channel *chan = video_drvdata(file);
662
663 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
664 return -EINVAL;
665
666 if (chan->streaming_fh && chan->streaming_fh != priv)
667 return -EBUSY;
668 chan->streaming_fh = priv;
669
670 return videobuf_streamon(&chan->vidq);
671 }
672
673 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
674 {
675 struct cx25821_channel *chan = video_drvdata(file);
676
677 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
678 return -EINVAL;
679
680 if (chan->streaming_fh && chan->streaming_fh != priv)
681 return -EBUSY;
682 if (chan->streaming_fh == NULL)
683 return 0;
684
685 chan->streaming_fh = NULL;
686 return videobuf_streamoff(&chan->vidq);
687 }
688
689 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
690 {
691 int ret_val = 0;
692 struct cx25821_channel *chan = video_drvdata(file);
693
694 ret_val = videobuf_dqbuf(&chan->vidq, p, file->f_flags & O_NONBLOCK);
695 p->sequence = chan->dma_vidq.count;
696
697 return ret_val;
698 }
699
700 static int vidioc_log_status(struct file *file, void *priv)
701 {
702 struct cx25821_channel *chan = video_drvdata(file);
703 struct cx25821_dev *dev = chan->dev;
704 const struct sram_channel *sram_ch = chan->sram_channels;
705 u32 tmp = 0;
706
707 tmp = cx_read(sram_ch->dma_ctl);
708 pr_info("Video input 0 is %s\n",
709 (tmp & 0x11) ? "streaming" : "stopped");
710 return 0;
711 }
712
713
714 static int cx25821_vidioc_querycap(struct file *file, void *priv,
715 struct v4l2_capability *cap)
716 {
717 struct cx25821_channel *chan = video_drvdata(file);
718 struct cx25821_dev *dev = chan->dev;
719 const u32 cap_input = V4L2_CAP_VIDEO_CAPTURE |
720 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
721 const u32 cap_output = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_READWRITE;
722
723 strcpy(cap->driver, "cx25821");
724 strlcpy(cap->card, cx25821_boards[dev->board].name, sizeof(cap->card));
725 sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
726 if (chan->id >= VID_CHANNEL_NUM)
727 cap->device_caps = cap_output;
728 else
729 cap->device_caps = cap_input;
730 cap->capabilities = cap_input | cap_output | V4L2_CAP_DEVICE_CAPS;
731 return 0;
732 }
733
734 static int cx25821_vidioc_reqbufs(struct file *file, void *priv,
735 struct v4l2_requestbuffers *p)
736 {
737 struct cx25821_channel *chan = video_drvdata(file);
738
739 return videobuf_reqbufs(&chan->vidq, p);
740 }
741
742 static int cx25821_vidioc_querybuf(struct file *file, void *priv,
743 struct v4l2_buffer *p)
744 {
745 struct cx25821_channel *chan = video_drvdata(file);
746
747 return videobuf_querybuf(&chan->vidq, p);
748 }
749
750 static int cx25821_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
751 {
752 struct cx25821_channel *chan = video_drvdata(file);
753
754 return videobuf_qbuf(&chan->vidq, p);
755 }
756
757 static int cx25821_vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
758 {
759 struct cx25821_channel *chan = video_drvdata(file);
760
761 *tvnorms = chan->dev->tvnorm;
762 return 0;
763 }
764
765 static int cx25821_vidioc_s_std(struct file *file, void *priv,
766 v4l2_std_id tvnorms)
767 {
768 struct cx25821_channel *chan = video_drvdata(file);
769 struct cx25821_dev *dev = chan->dev;
770
771 if (dev->tvnorm == tvnorms)
772 return 0;
773
774 dev->tvnorm = tvnorms;
775 chan->width = 720;
776 chan->height = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
777
778 medusa_set_videostandard(dev);
779
780 return 0;
781 }
782
783 static int cx25821_vidioc_enum_input(struct file *file, void *priv,
784 struct v4l2_input *i)
785 {
786 if (i->index)
787 return -EINVAL;
788
789 i->type = V4L2_INPUT_TYPE_CAMERA;
790 i->std = CX25821_NORMS;
791 strcpy(i->name, "Composite");
792 return 0;
793 }
794
795 static int cx25821_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
796 {
797 *i = 0;
798 return 0;
799 }
800
801 static int cx25821_vidioc_s_input(struct file *file, void *priv, unsigned int i)
802 {
803 return i ? -EINVAL : 0;
804 }
805
806 static int cx25821_s_ctrl(struct v4l2_ctrl *ctrl)
807 {
808 struct cx25821_channel *chan =
809 container_of(ctrl->handler, struct cx25821_channel, hdl);
810 struct cx25821_dev *dev = chan->dev;
811
812 switch (ctrl->id) {
813 case V4L2_CID_BRIGHTNESS:
814 medusa_set_brightness(dev, ctrl->val, chan->id);
815 break;
816 case V4L2_CID_HUE:
817 medusa_set_hue(dev, ctrl->val, chan->id);
818 break;
819 case V4L2_CID_CONTRAST:
820 medusa_set_contrast(dev, ctrl->val, chan->id);
821 break;
822 case V4L2_CID_SATURATION:
823 medusa_set_saturation(dev, ctrl->val, chan->id);
824 break;
825 default:
826 return -EINVAL;
827 }
828 return 0;
829 }
830
831 static int cx25821_vidioc_enum_output(struct file *file, void *priv,
832 struct v4l2_output *o)
833 {
834 if (o->index)
835 return -EINVAL;
836
837 o->type = V4L2_INPUT_TYPE_CAMERA;
838 o->std = CX25821_NORMS;
839 strcpy(o->name, "Composite");
840 return 0;
841 }
842
843 static int cx25821_vidioc_g_output(struct file *file, void *priv, unsigned int *o)
844 {
845 *o = 0;
846 return 0;
847 }
848
849 static int cx25821_vidioc_s_output(struct file *file, void *priv, unsigned int o)
850 {
851 return o ? -EINVAL : 0;
852 }
853
854 static int cx25821_vidioc_try_fmt_vid_out(struct file *file, void *priv,
855 struct v4l2_format *f)
856 {
857 struct cx25821_channel *chan = video_drvdata(file);
858 struct cx25821_dev *dev = chan->dev;
859 const struct cx25821_fmt *fmt;
860
861 fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
862 if (NULL == fmt)
863 return -EINVAL;
864 f->fmt.pix.width = 720;
865 f->fmt.pix.height = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
866 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
867 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
868 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
869 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
870 f->fmt.pix.priv = 0;
871 return 0;
872 }
873
874 static int vidioc_s_fmt_vid_out(struct file *file, void *priv,
875 struct v4l2_format *f)
876 {
877 struct cx25821_channel *chan = video_drvdata(file);
878 int err;
879
880 err = cx25821_vidioc_try_fmt_vid_out(file, priv, f);
881
882 if (0 != err)
883 return err;
884
885 chan->fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
886 chan->vidq.field = f->fmt.pix.field;
887 chan->width = f->fmt.pix.width;
888 chan->height = f->fmt.pix.height;
889 if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
890 chan->pixel_formats = PIXEL_FRMT_411;
891 else
892 chan->pixel_formats = PIXEL_FRMT_422;
893 return 0;
894 }
895
896 static ssize_t video_write(struct file *file, const char __user *data, size_t count,
897 loff_t *ppos)
898 {
899 struct cx25821_channel *chan = video_drvdata(file);
900 struct cx25821_dev *dev = chan->dev;
901 struct v4l2_fh *fh = file->private_data;
902 int err = 0;
903
904 if (mutex_lock_interruptible(&dev->lock))
905 return -ERESTARTSYS;
906 if (chan->streaming_fh && chan->streaming_fh != fh) {
907 err = -EBUSY;
908 goto unlock;
909 }
910 if (!chan->streaming_fh) {
911 err = cx25821_vidupstream_init(chan, chan->pixel_formats);
912 if (err)
913 goto unlock;
914 chan->streaming_fh = fh;
915 }
916
917 err = cx25821_write_frame(chan, data, count);
918 count -= err;
919 *ppos += err;
920
921 unlock:
922 mutex_unlock(&dev->lock);
923 return err;
924 }
925
926 static int video_out_release(struct file *file)
927 {
928 struct cx25821_channel *chan = video_drvdata(file);
929 struct cx25821_dev *dev = chan->dev;
930 struct v4l2_fh *fh = file->private_data;
931
932 mutex_lock(&dev->lock);
933 if (chan->streaming_fh == fh) {
934 cx25821_stop_upstream_video(chan);
935 chan->streaming_fh = NULL;
936 }
937 mutex_unlock(&dev->lock);
938
939 return v4l2_fh_release(file);
940 }
941
942 static const struct v4l2_ctrl_ops cx25821_ctrl_ops = {
943 .s_ctrl = cx25821_s_ctrl,
944 };
945
946 static const struct v4l2_file_operations video_fops = {
947 .owner = THIS_MODULE,
948 .open = v4l2_fh_open,
949 .release = video_release,
950 .read = video_read,
951 .poll = video_poll,
952 .mmap = cx25821_video_mmap,
953 .unlocked_ioctl = video_ioctl2,
954 };
955
956 static const struct v4l2_ioctl_ops video_ioctl_ops = {
957 .vidioc_querycap = cx25821_vidioc_querycap,
958 .vidioc_enum_fmt_vid_cap = cx25821_vidioc_enum_fmt_vid_cap,
959 .vidioc_g_fmt_vid_cap = cx25821_vidioc_g_fmt_vid_cap,
960 .vidioc_try_fmt_vid_cap = cx25821_vidioc_try_fmt_vid_cap,
961 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
962 .vidioc_reqbufs = cx25821_vidioc_reqbufs,
963 .vidioc_querybuf = cx25821_vidioc_querybuf,
964 .vidioc_qbuf = cx25821_vidioc_qbuf,
965 .vidioc_dqbuf = vidioc_dqbuf,
966 .vidioc_g_std = cx25821_vidioc_g_std,
967 .vidioc_s_std = cx25821_vidioc_s_std,
968 .vidioc_enum_input = cx25821_vidioc_enum_input,
969 .vidioc_g_input = cx25821_vidioc_g_input,
970 .vidioc_s_input = cx25821_vidioc_s_input,
971 .vidioc_streamon = vidioc_streamon,
972 .vidioc_streamoff = vidioc_streamoff,
973 .vidioc_log_status = vidioc_log_status,
974 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
975 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
976 };
977
978 static const struct video_device cx25821_video_device = {
979 .name = "cx25821-video",
980 .fops = &video_fops,
981 .release = video_device_release_empty,
982 .minor = -1,
983 .ioctl_ops = &video_ioctl_ops,
984 .tvnorms = CX25821_NORMS,
985 };
986
987 static const struct v4l2_file_operations video_out_fops = {
988 .owner = THIS_MODULE,
989 .open = v4l2_fh_open,
990 .write = video_write,
991 .release = video_out_release,
992 .unlocked_ioctl = video_ioctl2,
993 };
994
995 static const struct v4l2_ioctl_ops video_out_ioctl_ops = {
996 .vidioc_querycap = cx25821_vidioc_querycap,
997 .vidioc_enum_fmt_vid_out = cx25821_vidioc_enum_fmt_vid_cap,
998 .vidioc_g_fmt_vid_out = cx25821_vidioc_g_fmt_vid_cap,
999 .vidioc_try_fmt_vid_out = cx25821_vidioc_try_fmt_vid_out,
1000 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
1001 .vidioc_g_std = cx25821_vidioc_g_std,
1002 .vidioc_s_std = cx25821_vidioc_s_std,
1003 .vidioc_enum_output = cx25821_vidioc_enum_output,
1004 .vidioc_g_output = cx25821_vidioc_g_output,
1005 .vidioc_s_output = cx25821_vidioc_s_output,
1006 .vidioc_log_status = vidioc_log_status,
1007 };
1008
1009 static const struct video_device cx25821_video_out_device = {
1010 .name = "cx25821-video",
1011 .fops = &video_out_fops,
1012 .release = video_device_release_empty,
1013 .minor = -1,
1014 .ioctl_ops = &video_out_ioctl_ops,
1015 .tvnorms = CX25821_NORMS,
1016 };
1017
1018 void cx25821_video_unregister(struct cx25821_dev *dev, int chan_num)
1019 {
1020 cx_clear(PCI_INT_MSK, 1);
1021
1022 if (video_is_registered(&dev->channels[chan_num].vdev)) {
1023 video_unregister_device(&dev->channels[chan_num].vdev);
1024 v4l2_ctrl_handler_free(&dev->channels[chan_num].hdl);
1025
1026 btcx_riscmem_free(dev->pci,
1027 &dev->channels[chan_num].dma_vidq.stopper);
1028 }
1029 }
1030
1031 int cx25821_video_register(struct cx25821_dev *dev)
1032 {
1033 int err;
1034 int i;
1035
1036 /* initial device configuration */
1037 dev->tvnorm = V4L2_STD_NTSC_M;
1038
1039 spin_lock_init(&dev->slock);
1040
1041 for (i = 0; i < MAX_VID_CHANNEL_NUM - 1; ++i) {
1042 struct cx25821_channel *chan = &dev->channels[i];
1043 struct video_device *vdev = &chan->vdev;
1044 struct v4l2_ctrl_handler *hdl = &chan->hdl;
1045 bool is_output = i > SRAM_CH08;
1046
1047 if (i == SRAM_CH08) /* audio channel */
1048 continue;
1049
1050 if (!is_output) {
1051 v4l2_ctrl_handler_init(hdl, 4);
1052 v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
1053 V4L2_CID_BRIGHTNESS, 0, 10000, 1, 6200);
1054 v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
1055 V4L2_CID_CONTRAST, 0, 10000, 1, 5000);
1056 v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
1057 V4L2_CID_SATURATION, 0, 10000, 1, 5000);
1058 v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
1059 V4L2_CID_HUE, 0, 10000, 1, 5000);
1060 if (hdl->error) {
1061 err = hdl->error;
1062 goto fail_unreg;
1063 }
1064 err = v4l2_ctrl_handler_setup(hdl);
1065 if (err)
1066 goto fail_unreg;
1067 } else {
1068 chan->out = &dev->vid_out_data[i - SRAM_CH09];
1069 chan->out->chan = chan;
1070 }
1071
1072 cx25821_risc_stopper(dev->pci, &chan->dma_vidq.stopper,
1073 chan->sram_channels->dma_ctl, 0x11, 0);
1074
1075 chan->sram_channels = &cx25821_sram_channels[i];
1076 chan->width = 720;
1077 if (dev->tvnorm & V4L2_STD_625_50)
1078 chan->height = 576;
1079 else
1080 chan->height = 480;
1081
1082 if (chan->pixel_formats == PIXEL_FRMT_411)
1083 chan->fmt = cx25821_format_by_fourcc(V4L2_PIX_FMT_Y41P);
1084 else
1085 chan->fmt = cx25821_format_by_fourcc(V4L2_PIX_FMT_YUYV);
1086
1087 cx_write(chan->sram_channels->int_stat, 0xffffffff);
1088
1089 INIT_LIST_HEAD(&chan->dma_vidq.active);
1090 INIT_LIST_HEAD(&chan->dma_vidq.queued);
1091
1092 chan->timeout_data.dev = dev;
1093 chan->timeout_data.channel = &cx25821_sram_channels[i];
1094 chan->dma_vidq.timeout.function = cx25821_vid_timeout;
1095 chan->dma_vidq.timeout.data = (unsigned long)&chan->timeout_data;
1096 init_timer(&chan->dma_vidq.timeout);
1097
1098 if (!is_output)
1099 videobuf_queue_sg_init(&chan->vidq, &cx25821_video_qops, &dev->pci->dev,
1100 &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1101 V4L2_FIELD_INTERLACED, sizeof(struct cx25821_buffer),
1102 chan, &dev->lock);
1103
1104 /* register v4l devices */
1105 *vdev = is_output ? cx25821_video_out_device : cx25821_video_device;
1106 vdev->v4l2_dev = &dev->v4l2_dev;
1107 if (!is_output)
1108 vdev->ctrl_handler = hdl;
1109 else
1110 vdev->vfl_dir = VFL_DIR_TX;
1111 vdev->lock = &dev->lock;
1112 set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags);
1113 snprintf(vdev->name, sizeof(vdev->name), "%s #%d", dev->name, i);
1114 video_set_drvdata(vdev, chan);
1115
1116 err = video_register_device(vdev, VFL_TYPE_GRABBER,
1117 video_nr[dev->nr]);
1118
1119 if (err < 0)
1120 goto fail_unreg;
1121 }
1122
1123 /* set PCI interrupt */
1124 cx_set(PCI_INT_MSK, 0xff);
1125
1126 return 0;
1127
1128 fail_unreg:
1129 while (i >= 0)
1130 cx25821_video_unregister(dev, i--);
1131 return err;
1132 }
Linux with added FPC-III support