1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/init.h>
19#include <linux/list.h>
20#include <linux/module.h>
21#include <linux/moduleparam.h>
22#include <linux/kmod.h>
23#include <linux/kernel.h>
24#include <linux/slab.h>
25#include <linux/interrupt.h>
26#include <linux/delay.h>
27#include <linux/kthread.h>
28#include <asm/div64.h>
29
30#include "cx23885.h"
31#include "cx23885-video.h"
32#include <media/v4l2-common.h>
33#include <media/v4l2-ioctl.h>
34#include <media/v4l2-event.h>
35#include "cx23885-ioctl.h"
36#include "tuner-xc2028.h"
37
38#include <media/cx25840.h>
39
40MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
41MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
42MODULE_LICENSE("GPL");
43
44
45
46static unsigned int video_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
47static unsigned int vbi_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
48
49module_param_array(video_nr, int, NULL, 0444);
50module_param_array(vbi_nr, int, NULL, 0444);
51
52MODULE_PARM_DESC(video_nr, "video device numbers");
53MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
54
55static unsigned int video_debug;
56module_param(video_debug, int, 0644);
57MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
58
59static unsigned int irq_debug;
60module_param(irq_debug, int, 0644);
61MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
62
63static unsigned int vid_limit = 16;
64module_param(vid_limit, int, 0644);
65MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
66
67#define dprintk(level, fmt, arg...)\
68 do { if (video_debug >= level)\
69 printk(KERN_DEBUG "%s: " fmt, dev->name, ## arg);\
70 } while (0)
71
72
73
74
75#define FORMAT_FLAGS_PACKED 0x01
76static struct cx23885_fmt formats[] = {
77 {
78 .name = "4:2:2, packed, YUYV",
79 .fourcc = V4L2_PIX_FMT_YUYV,
80 .depth = 16,
81 .flags = FORMAT_FLAGS_PACKED,
82 }
83};
84
85static struct cx23885_fmt *format_by_fourcc(unsigned int fourcc)
86{
87 unsigned int i;
88
89 for (i = 0; i < ARRAY_SIZE(formats); i++)
90 if (formats[i].fourcc == fourcc)
91 return formats+i;
92 return NULL;
93}
94
95
96
97void cx23885_video_wakeup(struct cx23885_dev *dev,
98 struct cx23885_dmaqueue *q, u32 count)
99{
100 struct cx23885_buffer *buf;
101
102 if (list_empty(&q->active))
103 return;
104 buf = list_entry(q->active.next,
105 struct cx23885_buffer, queue);
106
107 buf->vb.v4l2_buf.sequence = q->count++;
108 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
109 dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.v4l2_buf.index,
110 count, q->count);
111 list_del(&buf->queue);
112 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
113}
114
115int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
116{
117 dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
118 __func__,
119 (unsigned int)norm,
120 v4l2_norm_to_name(norm));
121
122 if (dev->tvnorm != norm) {
123 if (vb2_is_busy(&dev->vb2_vidq) || vb2_is_busy(&dev->vb2_vbiq) ||
124 vb2_is_busy(&dev->vb2_mpegq))
125 return -EBUSY;
126 }
127
128 dev->tvnorm = norm;
129
130 call_all(dev, video, s_std, norm);
131
132 return 0;
133}
134
135static struct video_device *cx23885_vdev_init(struct cx23885_dev *dev,
136 struct pci_dev *pci,
137 struct video_device *template,
138 char *type)
139{
140 struct video_device *vfd;
141 dprintk(1, "%s()\n", __func__);
142
143 vfd = video_device_alloc();
144 if (NULL == vfd)
145 return NULL;
146 *vfd = *template;
147 vfd->v4l2_dev = &dev->v4l2_dev;
148 vfd->release = video_device_release;
149 vfd->lock = &dev->lock;
150 snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
151 cx23885_boards[dev->board].name, type);
152 video_set_drvdata(vfd, dev);
153 return vfd;
154}
155
156int cx23885_flatiron_write(struct cx23885_dev *dev, u8 reg, u8 data)
157{
158
159 u8 buf[] = { reg, data };
160
161 struct i2c_msg msg = { .addr = 0x98 >> 1,
162 .flags = 0, .buf = buf, .len = 2 };
163
164 return i2c_transfer(&dev->i2c_bus[2].i2c_adap, &msg, 1);
165}
166
167u8 cx23885_flatiron_read(struct cx23885_dev *dev, u8 reg)
168{
169
170 int ret;
171 u8 b0[] = { reg };
172 u8 b1[] = { 0 };
173
174 struct i2c_msg msg[] = {
175 { .addr = 0x98 >> 1, .flags = 0, .buf = b0, .len = 1 },
176 { .addr = 0x98 >> 1, .flags = I2C_M_RD, .buf = b1, .len = 1 }
177 };
178
179 ret = i2c_transfer(&dev->i2c_bus[2].i2c_adap, &msg[0], 2);
180 if (ret != 2)
181 printk(KERN_ERR "%s() error\n", __func__);
182
183 return b1[0];
184}
185
186static void cx23885_flatiron_dump(struct cx23885_dev *dev)
187{
188 int i;
189 dprintk(1, "Flatiron dump\n");
190 for (i = 0; i < 0x24; i++) {
191 dprintk(1, "FI[%02x] = %02x\n", i,
192 cx23885_flatiron_read(dev, i));
193 }
194}
195
196static int cx23885_flatiron_mux(struct cx23885_dev *dev, int input)
197{
198 u8 val;
199 dprintk(1, "%s(input = %d)\n", __func__, input);
200
201 if (input == 1)
202 val = cx23885_flatiron_read(dev, CH_PWR_CTRL1) & ~FLD_CH_SEL;
203 else if (input == 2)
204 val = cx23885_flatiron_read(dev, CH_PWR_CTRL1) | FLD_CH_SEL;
205 else
206 return -EINVAL;
207
208 val |= 0x20;
209
210 cx23885_flatiron_write(dev, CH_PWR_CTRL1, val);
211
212
213 cx23885_flatiron_write(dev, CH_PWR_CTRL2, 0);
214
215 if (video_debug)
216 cx23885_flatiron_dump(dev);
217
218 return 0;
219}
220
221static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
222{
223 dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
224 __func__,
225 input, INPUT(input)->vmux,
226 INPUT(input)->gpio0, INPUT(input)->gpio1,
227 INPUT(input)->gpio2, INPUT(input)->gpio3);
228 dev->input = input;
229
230 if (dev->board == CX23885_BOARD_MYGICA_X8506 ||
231 dev->board == CX23885_BOARD_MAGICPRO_PROHDTVE2 ||
232 dev->board == CX23885_BOARD_MYGICA_X8507) {
233
234 if (INPUT(input)->type == CX23885_VMUX_TELEVISION)
235 cx23885_gpio_clear(dev, GPIO_0);
236 }
237
238
239 v4l2_subdev_call(dev->sd_cx25840, video, s_routing,
240 INPUT(input)->vmux, 0, 0);
241
242 if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1800) ||
243 (dev->board == CX23885_BOARD_MPX885) ||
244 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1250) ||
245 (dev->board == CX23885_BOARD_HAUPPAUGE_IMPACTVCBE) ||
246 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
247 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111) ||
248 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
249 (dev->board == CX23885_BOARD_MYGICA_X8507) ||
250 (dev->board == CX23885_BOARD_AVERMEDIA_HC81R)) {
251
252 v4l2_subdev_call(dev->sd_cx25840, audio, s_routing,
253 INPUT(input)->amux, 0, 0);
254
255 if (INPUT(input)->amux == CX25840_AUDIO7)
256 cx23885_flatiron_mux(dev, 1);
257 else if (INPUT(input)->amux == CX25840_AUDIO6)
258 cx23885_flatiron_mux(dev, 2);
259 }
260
261 return 0;
262}
263
264static int cx23885_audio_mux(struct cx23885_dev *dev, unsigned int input)
265{
266 dprintk(1, "%s(input=%d)\n", __func__, input);
267
268
269
270
271
272
273
274
275
276
277 if (INPUT(input)->amux == CX25840_AUDIO7)
278 cx23885_flatiron_mux(dev, 1);
279 else if (INPUT(input)->amux == CX25840_AUDIO6)
280 cx23885_flatiron_mux(dev, 2);
281 else {
282
283 cx23885_flatiron_mux(dev, 1);
284 }
285
286 return 0;
287}
288
289
290static int cx23885_start_video_dma(struct cx23885_dev *dev,
291 struct cx23885_dmaqueue *q,
292 struct cx23885_buffer *buf)
293{
294 dprintk(1, "%s()\n", __func__);
295
296
297 cx_clear(VID_A_DMA_CTL, 0x11);
298
299
300 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
301 buf->bpl, buf->risc.dma);
302
303
304 cx_write(VID_A_GPCNT_CTL, 3);
305 q->count = 0;
306
307
308 cx23885_irq_add_enable(dev, 0x01);
309 cx_set(VID_A_INT_MSK, 0x000011);
310
311
312 cx_set(DEV_CNTRL2, (1<<5));
313 cx_set(VID_A_DMA_CTL, 0x11);
314
315 return 0;
316}
317
318static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
319 unsigned int *num_buffers, unsigned int *num_planes,
320 unsigned int sizes[], void *alloc_ctxs[])
321{
322 struct cx23885_dev *dev = q->drv_priv;
323
324 *num_planes = 1;
325 sizes[0] = (dev->fmt->depth * dev->width * dev->height) >> 3;
326 alloc_ctxs[0] = dev->alloc_ctx;
327 return 0;
328}
329
330static int buffer_prepare(struct vb2_buffer *vb)
331{
332 struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
333 struct cx23885_buffer *buf =
334 container_of(vb, struct cx23885_buffer, vb);
335 u32 line0_offset, line1_offset;
336 struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
337 int field_tff;
338
339 buf->bpl = (dev->width * dev->fmt->depth) >> 3;
340
341 if (vb2_plane_size(vb, 0) < dev->height * buf->bpl)
342 return -EINVAL;
343 vb2_set_plane_payload(vb, 0, dev->height * buf->bpl);
344
345 switch (dev->field) {
346 case V4L2_FIELD_TOP:
347 cx23885_risc_buffer(dev->pci, &buf->risc,
348 sgt->sgl, 0, UNSET,
349 buf->bpl, 0, dev->height);
350 break;
351 case V4L2_FIELD_BOTTOM:
352 cx23885_risc_buffer(dev->pci, &buf->risc,
353 sgt->sgl, UNSET, 0,
354 buf->bpl, 0, dev->height);
355 break;
356 case V4L2_FIELD_INTERLACED:
357 if (dev->tvnorm & V4L2_STD_525_60)
358
359 field_tff = 1;
360 else
361 field_tff = 0;
362
363 if (cx23885_boards[dev->board].force_bff)
364
365 field_tff = 0;
366
367 if (field_tff) {
368
369 dprintk(1, "%s() Creating TFF/NTSC risc\n",
370 __func__);
371 line0_offset = buf->bpl;
372 line1_offset = 0;
373 } else {
374
375 dprintk(1, "%s() Creating BFF/PAL/SECAM risc\n",
376 __func__);
377 line0_offset = 0;
378 line1_offset = buf->bpl;
379 }
380 cx23885_risc_buffer(dev->pci, &buf->risc,
381 sgt->sgl, line0_offset,
382 line1_offset,
383 buf->bpl, buf->bpl,
384 dev->height >> 1);
385 break;
386 case V4L2_FIELD_SEQ_TB:
387 cx23885_risc_buffer(dev->pci, &buf->risc,
388 sgt->sgl,
389 0, buf->bpl * (dev->height >> 1),
390 buf->bpl, 0,
391 dev->height >> 1);
392 break;
393 case V4L2_FIELD_SEQ_BT:
394 cx23885_risc_buffer(dev->pci, &buf->risc,
395 sgt->sgl,
396 buf->bpl * (dev->height >> 1), 0,
397 buf->bpl, 0,
398 dev->height >> 1);
399 break;
400 default:
401 BUG();
402 }
403 dprintk(2, "[%p/%d] buffer_init - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
404 buf, buf->vb.v4l2_buf.index,
405 dev->width, dev->height, dev->fmt->depth, dev->fmt->name,
406 (unsigned long)buf->risc.dma);
407 return 0;
408}
409
410static void buffer_finish(struct vb2_buffer *vb)
411{
412 struct cx23885_buffer *buf = container_of(vb,
413 struct cx23885_buffer, vb);
414
415 cx23885_free_buffer(vb->vb2_queue->drv_priv, buf);
416}
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439static void buffer_queue(struct vb2_buffer *vb)
440{
441 struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
442 struct cx23885_buffer *buf = container_of(vb,
443 struct cx23885_buffer, vb);
444 struct cx23885_buffer *prev;
445 struct cx23885_dmaqueue *q = &dev->vidq;
446 unsigned long flags;
447
448
449 buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 12);
450 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
451 buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 12);
452 buf->risc.jmp[2] = cpu_to_le32(0);
453
454 spin_lock_irqsave(&dev->slock, flags);
455 if (list_empty(&q->active)) {
456 list_add_tail(&buf->queue, &q->active);
457 dprintk(2, "[%p/%d] buffer_queue - first active\n",
458 buf, buf->vb.v4l2_buf.index);
459 } else {
460 buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
461 prev = list_entry(q->active.prev, struct cx23885_buffer,
462 queue);
463 list_add_tail(&buf->queue, &q->active);
464 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
465 dprintk(2, "[%p/%d] buffer_queue - append to active\n",
466 buf, buf->vb.v4l2_buf.index);
467 }
468 spin_unlock_irqrestore(&dev->slock, flags);
469}
470
471static int cx23885_start_streaming(struct vb2_queue *q, unsigned int count)
472{
473 struct cx23885_dev *dev = q->drv_priv;
474 struct cx23885_dmaqueue *dmaq = &dev->vidq;
475 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
476 struct cx23885_buffer, queue);
477
478 cx23885_start_video_dma(dev, dmaq, buf);
479 return 0;
480}
481
482static void cx23885_stop_streaming(struct vb2_queue *q)
483{
484 struct cx23885_dev *dev = q->drv_priv;
485 struct cx23885_dmaqueue *dmaq = &dev->vidq;
486 unsigned long flags;
487
488 cx_clear(VID_A_DMA_CTL, 0x11);
489 spin_lock_irqsave(&dev->slock, flags);
490 while (!list_empty(&dmaq->active)) {
491 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
492 struct cx23885_buffer, queue);
493
494 list_del(&buf->queue);
495 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
496 }
497 spin_unlock_irqrestore(&dev->slock, flags);
498}
499
500static struct vb2_ops cx23885_video_qops = {
501 .queue_setup = queue_setup,
502 .buf_prepare = buffer_prepare,
503 .buf_finish = buffer_finish,
504 .buf_queue = buffer_queue,
505 .wait_prepare = vb2_ops_wait_prepare,
506 .wait_finish = vb2_ops_wait_finish,
507 .start_streaming = cx23885_start_streaming,
508 .stop_streaming = cx23885_stop_streaming,
509};
510
511
512
513
514static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
515 struct v4l2_format *f)
516{
517 struct cx23885_dev *dev = video_drvdata(file);
518
519 f->fmt.pix.width = dev->width;
520 f->fmt.pix.height = dev->height;
521 f->fmt.pix.field = dev->field;
522 f->fmt.pix.pixelformat = dev->fmt->fourcc;
523 f->fmt.pix.bytesperline =
524 (f->fmt.pix.width * dev->fmt->depth) >> 3;
525 f->fmt.pix.sizeimage =
526 f->fmt.pix.height * f->fmt.pix.bytesperline;
527 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
528
529 return 0;
530}
531
532static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
533 struct v4l2_format *f)
534{
535 struct cx23885_dev *dev = video_drvdata(file);
536 struct cx23885_fmt *fmt;
537 enum v4l2_field field;
538 unsigned int maxw, maxh;
539
540 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
541 if (NULL == fmt)
542 return -EINVAL;
543
544 field = f->fmt.pix.field;
545 maxw = norm_maxw(dev->tvnorm);
546 maxh = norm_maxh(dev->tvnorm);
547
548 if (V4L2_FIELD_ANY == field) {
549 field = (f->fmt.pix.height > maxh/2)
550 ? V4L2_FIELD_INTERLACED
551 : V4L2_FIELD_BOTTOM;
552 }
553
554 switch (field) {
555 case V4L2_FIELD_TOP:
556 case V4L2_FIELD_BOTTOM:
557 maxh = maxh / 2;
558 break;
559 case V4L2_FIELD_INTERLACED:
560 case V4L2_FIELD_SEQ_TB:
561 case V4L2_FIELD_SEQ_BT:
562 break;
563 default:
564 field = V4L2_FIELD_INTERLACED;
565 break;
566 }
567
568 f->fmt.pix.field = field;
569 v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
570 &f->fmt.pix.height, 32, maxh, 0, 0);
571 f->fmt.pix.bytesperline =
572 (f->fmt.pix.width * fmt->depth) >> 3;
573 f->fmt.pix.sizeimage =
574 f->fmt.pix.height * f->fmt.pix.bytesperline;
575 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
576
577 return 0;
578}
579
580static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
581 struct v4l2_format *f)
582{
583 struct cx23885_dev *dev = video_drvdata(file);
584 struct v4l2_mbus_framefmt mbus_fmt;
585 int err;
586
587 dprintk(2, "%s()\n", __func__);
588 err = vidioc_try_fmt_vid_cap(file, priv, f);
589
590 if (0 != err)
591 return err;
592
593 if (vb2_is_busy(&dev->vb2_vidq) || vb2_is_busy(&dev->vb2_vbiq) ||
594 vb2_is_busy(&dev->vb2_mpegq))
595 return -EBUSY;
596
597 dev->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
598 dev->width = f->fmt.pix.width;
599 dev->height = f->fmt.pix.height;
600 dev->field = f->fmt.pix.field;
601 dprintk(2, "%s() width=%d height=%d field=%d\n", __func__,
602 dev->width, dev->height, dev->field);
603 v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
604 call_all(dev, video, s_mbus_fmt, &mbus_fmt);
605 v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt);
606
607 f->fmt.pix.field = dev->field;
608 return 0;
609}
610
611static int vidioc_querycap(struct file *file, void *priv,
612 struct v4l2_capability *cap)
613{
614 struct cx23885_dev *dev = video_drvdata(file);
615 struct video_device *vdev = video_devdata(file);
616
617 strcpy(cap->driver, "cx23885");
618 strlcpy(cap->card, cx23885_boards[dev->board].name,
619 sizeof(cap->card));
620 sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
621 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING | V4L2_CAP_AUDIO;
622 if (dev->tuner_type != TUNER_ABSENT)
623 cap->device_caps |= V4L2_CAP_TUNER;
624 if (vdev->vfl_type == VFL_TYPE_VBI)
625 cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
626 else
627 cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
628 cap->capabilities = cap->device_caps | V4L2_CAP_VBI_CAPTURE |
629 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_DEVICE_CAPS;
630 return 0;
631}
632
633static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
634 struct v4l2_fmtdesc *f)
635{
636 if (unlikely(f->index >= ARRAY_SIZE(formats)))
637 return -EINVAL;
638
639 strlcpy(f->description, formats[f->index].name,
640 sizeof(f->description));
641 f->pixelformat = formats[f->index].fourcc;
642
643 return 0;
644}
645
646static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
647{
648 struct cx23885_dev *dev = video_drvdata(file);
649 dprintk(1, "%s()\n", __func__);
650
651 *id = dev->tvnorm;
652 return 0;
653}
654
655static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms)
656{
657 struct cx23885_dev *dev = video_drvdata(file);
658 dprintk(1, "%s()\n", __func__);
659
660 return cx23885_set_tvnorm(dev, tvnorms);
661}
662
663int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
664{
665 static const char *iname[] = {
666 [CX23885_VMUX_COMPOSITE1] = "Composite1",
667 [CX23885_VMUX_COMPOSITE2] = "Composite2",
668 [CX23885_VMUX_COMPOSITE3] = "Composite3",
669 [CX23885_VMUX_COMPOSITE4] = "Composite4",
670 [CX23885_VMUX_SVIDEO] = "S-Video",
671 [CX23885_VMUX_COMPONENT] = "Component",
672 [CX23885_VMUX_TELEVISION] = "Television",
673 [CX23885_VMUX_CABLE] = "Cable TV",
674 [CX23885_VMUX_DVB] = "DVB",
675 [CX23885_VMUX_DEBUG] = "for debug only",
676 };
677 unsigned int n;
678 dprintk(1, "%s()\n", __func__);
679
680 n = i->index;
681 if (n >= MAX_CX23885_INPUT)
682 return -EINVAL;
683
684 if (0 == INPUT(n)->type)
685 return -EINVAL;
686
687 i->index = n;
688 i->type = V4L2_INPUT_TYPE_CAMERA;
689 strcpy(i->name, iname[INPUT(n)->type]);
690 i->std = CX23885_NORMS;
691 if ((CX23885_VMUX_TELEVISION == INPUT(n)->type) ||
692 (CX23885_VMUX_CABLE == INPUT(n)->type)) {
693 i->type = V4L2_INPUT_TYPE_TUNER;
694 i->audioset = 4;
695 } else {
696
697 i->audioset = 3;
698 }
699
700 if (dev->input == n) {
701
702
703
704
705
706 call_all(dev, video, g_input_status, &i->status);
707 }
708
709 return 0;
710}
711
712static int vidioc_enum_input(struct file *file, void *priv,
713 struct v4l2_input *i)
714{
715 struct cx23885_dev *dev = video_drvdata(file);
716 dprintk(1, "%s()\n", __func__);
717 return cx23885_enum_input(dev, i);
718}
719
720int cx23885_get_input(struct file *file, void *priv, unsigned int *i)
721{
722 struct cx23885_dev *dev = video_drvdata(file);
723
724 *i = dev->input;
725 dprintk(1, "%s() returns %d\n", __func__, *i);
726 return 0;
727}
728
729static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
730{
731 return cx23885_get_input(file, priv, i);
732}
733
734int cx23885_set_input(struct file *file, void *priv, unsigned int i)
735{
736 struct cx23885_dev *dev = video_drvdata(file);
737
738 dprintk(1, "%s(%d)\n", __func__, i);
739
740 if (i >= MAX_CX23885_INPUT) {
741 dprintk(1, "%s() -EINVAL\n", __func__);
742 return -EINVAL;
743 }
744
745 if (INPUT(i)->type == 0)
746 return -EINVAL;
747
748 cx23885_video_mux(dev, i);
749
750
751
752 cx23885_audio_mux(dev, i);
753 return 0;
754}
755
756static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
757{
758 return cx23885_set_input(file, priv, i);
759}
760
761static int vidioc_log_status(struct file *file, void *priv)
762{
763 struct cx23885_dev *dev = video_drvdata(file);
764
765 call_all(dev, core, log_status);
766 return 0;
767}
768
769static int cx23885_query_audinput(struct file *file, void *priv,
770 struct v4l2_audio *i)
771{
772 struct cx23885_dev *dev = video_drvdata(file);
773 static const char *iname[] = {
774 [0] = "Baseband L/R 1",
775 [1] = "Baseband L/R 2",
776 [2] = "TV",
777 };
778 unsigned int n;
779 dprintk(1, "%s()\n", __func__);
780
781 n = i->index;
782 if (n >= 3)
783 return -EINVAL;
784
785 memset(i, 0, sizeof(*i));
786 i->index = n;
787 strcpy(i->name, iname[n]);
788 i->capability = V4L2_AUDCAP_STEREO;
789 return 0;
790
791}
792
793static int vidioc_enum_audinput(struct file *file, void *priv,
794 struct v4l2_audio *i)
795{
796 return cx23885_query_audinput(file, priv, i);
797}
798
799static int vidioc_g_audinput(struct file *file, void *priv,
800 struct v4l2_audio *i)
801{
802 struct cx23885_dev *dev = video_drvdata(file);
803
804 if ((CX23885_VMUX_TELEVISION == INPUT(dev->input)->type) ||
805 (CX23885_VMUX_CABLE == INPUT(dev->input)->type))
806 i->index = 2;
807 else
808 i->index = dev->audinput;
809 dprintk(1, "%s(input=%d)\n", __func__, i->index);
810
811 return cx23885_query_audinput(file, priv, i);
812}
813
814static int vidioc_s_audinput(struct file *file, void *priv,
815 const struct v4l2_audio *i)
816{
817 struct cx23885_dev *dev = video_drvdata(file);
818
819 if ((CX23885_VMUX_TELEVISION == INPUT(dev->input)->type) ||
820 (CX23885_VMUX_CABLE == INPUT(dev->input)->type)) {
821 return i->index != 2 ? -EINVAL : 0;
822 }
823 if (i->index > 1)
824 return -EINVAL;
825
826 dprintk(1, "%s(%d)\n", __func__, i->index);
827
828 dev->audinput = i->index;
829
830
831
832 cx23885_flatiron_mux(dev, dev->audinput + 1);
833 return 0;
834}
835
836static int vidioc_g_tuner(struct file *file, void *priv,
837 struct v4l2_tuner *t)
838{
839 struct cx23885_dev *dev = video_drvdata(file);
840
841 if (dev->tuner_type == TUNER_ABSENT)
842 return -EINVAL;
843 if (0 != t->index)
844 return -EINVAL;
845
846 strcpy(t->name, "Television");
847
848 call_all(dev, tuner, g_tuner, t);
849 return 0;
850}
851
852static int vidioc_s_tuner(struct file *file, void *priv,
853 const struct v4l2_tuner *t)
854{
855 struct cx23885_dev *dev = video_drvdata(file);
856
857 if (dev->tuner_type == TUNER_ABSENT)
858 return -EINVAL;
859 if (0 != t->index)
860 return -EINVAL;
861
862 call_all(dev, tuner, s_tuner, t);
863
864 return 0;
865}
866
867static int vidioc_g_frequency(struct file *file, void *priv,
868 struct v4l2_frequency *f)
869{
870 struct cx23885_dev *dev = video_drvdata(file);
871
872 if (dev->tuner_type == TUNER_ABSENT)
873 return -EINVAL;
874
875 f->type = V4L2_TUNER_ANALOG_TV;
876 f->frequency = dev->freq;
877
878 call_all(dev, tuner, g_frequency, f);
879
880 return 0;
881}
882
883static int cx23885_set_freq(struct cx23885_dev *dev, const struct v4l2_frequency *f)
884{
885 struct v4l2_ctrl *mute;
886 int old_mute_val = 1;
887
888 if (dev->tuner_type == TUNER_ABSENT)
889 return -EINVAL;
890 if (unlikely(f->tuner != 0))
891 return -EINVAL;
892
893 dev->freq = f->frequency;
894
895
896 mute = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_AUDIO_MUTE);
897 if (mute) {
898 old_mute_val = v4l2_ctrl_g_ctrl(mute);
899 if (!old_mute_val)
900 v4l2_ctrl_s_ctrl(mute, 1);
901 }
902
903 call_all(dev, tuner, s_frequency, f);
904
905
906 msleep(100);
907
908
909 if (old_mute_val == 0)
910 v4l2_ctrl_s_ctrl(mute, old_mute_val);
911
912 return 0;
913}
914
915static int cx23885_set_freq_via_ops(struct cx23885_dev *dev,
916 const struct v4l2_frequency *f)
917{
918 struct v4l2_ctrl *mute;
919 int old_mute_val = 1;
920 struct vb2_dvb_frontend *vfe;
921 struct dvb_frontend *fe;
922
923 struct analog_parameters params = {
924 .mode = V4L2_TUNER_ANALOG_TV,
925 .audmode = V4L2_TUNER_MODE_STEREO,
926 .std = dev->tvnorm,
927 .frequency = f->frequency
928 };
929
930 dev->freq = f->frequency;
931
932
933 mute = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_AUDIO_MUTE);
934 if (mute) {
935 old_mute_val = v4l2_ctrl_g_ctrl(mute);
936 if (!old_mute_val)
937 v4l2_ctrl_s_ctrl(mute, 1);
938 }
939
940
941 dprintk(1, "%s() frequency=%d tuner=%d std=0x%llx\n", __func__,
942 params.frequency, f->tuner, params.std);
943
944 vfe = vb2_dvb_get_frontend(&dev->ts2.frontends, 1);
945 if (!vfe) {
946 return -EINVAL;
947 }
948
949 fe = vfe->dvb.frontend;
950
951 if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
952 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
953 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111))
954 fe = &dev->ts1.analog_fe;
955
956 if (fe && fe->ops.tuner_ops.set_analog_params) {
957 call_all(dev, video, s_std, dev->tvnorm);
958 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
959 }
960 else
961 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
962
963
964 msleep(100);
965
966
967 if (old_mute_val == 0)
968 v4l2_ctrl_s_ctrl(mute, old_mute_val);
969
970 return 0;
971}
972
973int cx23885_set_frequency(struct file *file, void *priv,
974 const struct v4l2_frequency *f)
975{
976 struct cx23885_dev *dev = video_drvdata(file);
977 int ret;
978
979 switch (dev->board) {
980 case CX23885_BOARD_HAUPPAUGE_HVR1255:
981 case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
982 case CX23885_BOARD_HAUPPAUGE_HVR1850:
983 ret = cx23885_set_freq_via_ops(dev, f);
984 break;
985 default:
986 ret = cx23885_set_freq(dev, f);
987 }
988
989 return ret;
990}
991
992static int vidioc_s_frequency(struct file *file, void *priv,
993 const struct v4l2_frequency *f)
994{
995 return cx23885_set_frequency(file, priv, f);
996}
997
998
999
1000int cx23885_video_irq(struct cx23885_dev *dev, u32 status)
1001{
1002 u32 mask, count;
1003 int handled = 0;
1004
1005 mask = cx_read(VID_A_INT_MSK);
1006 if (0 == (status & mask))
1007 return handled;
1008
1009 cx_write(VID_A_INT_STAT, status);
1010
1011
1012 if ((status & VID_BC_MSK_OPC_ERR) ||
1013 (status & VID_BC_MSK_SYNC) ||
1014 (status & VID_BC_MSK_OF)) {
1015
1016 if (status & VID_BC_MSK_OPC_ERR) {
1017 dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n",
1018 VID_BC_MSK_OPC_ERR);
1019 printk(KERN_WARNING "%s: video risc op code error\n",
1020 dev->name);
1021 cx23885_sram_channel_dump(dev,
1022 &dev->sram_channels[SRAM_CH01]);
1023 }
1024
1025 if (status & VID_BC_MSK_SYNC)
1026 dprintk(7, " (VID_BC_MSK_SYNC 0x%08x) "
1027 "video lines miss-match\n",
1028 VID_BC_MSK_SYNC);
1029
1030 if (status & VID_BC_MSK_OF)
1031 dprintk(7, " (VID_BC_MSK_OF 0x%08x) fifo overflow\n",
1032 VID_BC_MSK_OF);
1033
1034 }
1035
1036
1037 if (status & VID_BC_MSK_RISCI1) {
1038 spin_lock(&dev->slock);
1039 count = cx_read(VID_A_GPCNT);
1040 cx23885_video_wakeup(dev, &dev->vidq, count);
1041 spin_unlock(&dev->slock);
1042 handled++;
1043 }
1044
1045
1046 handled += cx23885_vbi_irq(dev, status);
1047
1048 return handled;
1049}
1050
1051
1052
1053
1054static const struct v4l2_file_operations video_fops = {
1055 .owner = THIS_MODULE,
1056 .open = v4l2_fh_open,
1057 .release = vb2_fop_release,
1058 .read = vb2_fop_read,
1059 .poll = vb2_fop_poll,
1060 .unlocked_ioctl = video_ioctl2,
1061 .mmap = vb2_fop_mmap,
1062};
1063
1064static const struct v4l2_ioctl_ops video_ioctl_ops = {
1065 .vidioc_querycap = vidioc_querycap,
1066 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1067 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1068 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1069 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1070 .vidioc_g_fmt_vbi_cap = cx23885_vbi_fmt,
1071 .vidioc_try_fmt_vbi_cap = cx23885_vbi_fmt,
1072 .vidioc_s_fmt_vbi_cap = cx23885_vbi_fmt,
1073 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1074 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1075 .vidioc_querybuf = vb2_ioctl_querybuf,
1076 .vidioc_qbuf = vb2_ioctl_qbuf,
1077 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1078 .vidioc_streamon = vb2_ioctl_streamon,
1079 .vidioc_streamoff = vb2_ioctl_streamoff,
1080 .vidioc_s_std = vidioc_s_std,
1081 .vidioc_g_std = vidioc_g_std,
1082 .vidioc_enum_input = vidioc_enum_input,
1083 .vidioc_g_input = vidioc_g_input,
1084 .vidioc_s_input = vidioc_s_input,
1085 .vidioc_log_status = vidioc_log_status,
1086 .vidioc_g_tuner = vidioc_g_tuner,
1087 .vidioc_s_tuner = vidioc_s_tuner,
1088 .vidioc_g_frequency = vidioc_g_frequency,
1089 .vidioc_s_frequency = vidioc_s_frequency,
1090#ifdef CONFIG_VIDEO_ADV_DEBUG
1091 .vidioc_g_chip_info = cx23885_g_chip_info,
1092 .vidioc_g_register = cx23885_g_register,
1093 .vidioc_s_register = cx23885_s_register,
1094#endif
1095 .vidioc_enumaudio = vidioc_enum_audinput,
1096 .vidioc_g_audio = vidioc_g_audinput,
1097 .vidioc_s_audio = vidioc_s_audinput,
1098 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1099 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1100};
1101
1102static struct video_device cx23885_vbi_template;
1103static struct video_device cx23885_video_template = {
1104 .name = "cx23885-video",
1105 .fops = &video_fops,
1106 .ioctl_ops = &video_ioctl_ops,
1107 .tvnorms = CX23885_NORMS,
1108};
1109
1110void cx23885_video_unregister(struct cx23885_dev *dev)
1111{
1112 dprintk(1, "%s()\n", __func__);
1113 cx23885_irq_remove(dev, 0x01);
1114
1115 if (dev->vbi_dev) {
1116 if (video_is_registered(dev->vbi_dev))
1117 video_unregister_device(dev->vbi_dev);
1118 else
1119 video_device_release(dev->vbi_dev);
1120 dev->vbi_dev = NULL;
1121 }
1122 if (dev->video_dev) {
1123 if (video_is_registered(dev->video_dev))
1124 video_unregister_device(dev->video_dev);
1125 else
1126 video_device_release(dev->video_dev);
1127 dev->video_dev = NULL;
1128 }
1129
1130 if (dev->audio_dev)
1131 cx23885_audio_unregister(dev);
1132}
1133
1134int cx23885_video_register(struct cx23885_dev *dev)
1135{
1136 struct vb2_queue *q;
1137 int err;
1138
1139 dprintk(1, "%s()\n", __func__);
1140
1141
1142 cx23885_vbi_template = cx23885_video_template;
1143 strcpy(cx23885_vbi_template.name, "cx23885-vbi");
1144
1145 dev->tvnorm = V4L2_STD_NTSC_M;
1146 dev->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV);
1147 dev->field = V4L2_FIELD_INTERLACED;
1148 dev->width = 720;
1149 dev->height = norm_maxh(dev->tvnorm);
1150
1151
1152 INIT_LIST_HEAD(&dev->vidq.active);
1153
1154
1155 INIT_LIST_HEAD(&dev->vbiq.active);
1156
1157 cx23885_irq_add_enable(dev, 0x01);
1158
1159 if ((TUNER_ABSENT != dev->tuner_type) &&
1160 ((dev->tuner_bus == 0) || (dev->tuner_bus == 1))) {
1161 struct v4l2_subdev *sd = NULL;
1162
1163 if (dev->tuner_addr)
1164 sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1165 &dev->i2c_bus[dev->tuner_bus].i2c_adap,
1166 "tuner", dev->tuner_addr, NULL);
1167 else
1168 sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1169 &dev->i2c_bus[dev->tuner_bus].i2c_adap,
1170 "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV));
1171 if (sd) {
1172 struct tuner_setup tun_setup;
1173
1174 memset(&tun_setup, 0, sizeof(tun_setup));
1175 tun_setup.mode_mask = T_ANALOG_TV;
1176 tun_setup.type = dev->tuner_type;
1177 tun_setup.addr = v4l2_i2c_subdev_addr(sd);
1178 tun_setup.tuner_callback = cx23885_tuner_callback;
1179
1180 v4l2_subdev_call(sd, tuner, s_type_addr, &tun_setup);
1181
1182 if ((dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXTV1200) ||
1183 (dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXPVR2200)) {
1184 struct xc2028_ctrl ctrl = {
1185 .fname = XC2028_DEFAULT_FIRMWARE,
1186 .max_len = 64
1187 };
1188 struct v4l2_priv_tun_config cfg = {
1189 .tuner = dev->tuner_type,
1190 .priv = &ctrl
1191 };
1192 v4l2_subdev_call(sd, tuner, s_config, &cfg);
1193 }
1194
1195 if (dev->board == CX23885_BOARD_AVERMEDIA_HC81R) {
1196 struct xc2028_ctrl ctrl = {
1197 .fname = "xc3028L-v36.fw",
1198 .max_len = 64
1199 };
1200 struct v4l2_priv_tun_config cfg = {
1201 .tuner = dev->tuner_type,
1202 .priv = &ctrl
1203 };
1204 v4l2_subdev_call(sd, tuner, s_config, &cfg);
1205 }
1206 }
1207 }
1208
1209
1210 mutex_lock(&dev->lock);
1211 cx23885_set_tvnorm(dev, dev->tvnorm);
1212 cx23885_video_mux(dev, 0);
1213 cx23885_audio_mux(dev, 0);
1214 mutex_unlock(&dev->lock);
1215
1216 q = &dev->vb2_vidq;
1217 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1218 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1219 q->gfp_flags = GFP_DMA32;
1220 q->min_buffers_needed = 2;
1221 q->drv_priv = dev;
1222 q->buf_struct_size = sizeof(struct cx23885_buffer);
1223 q->ops = &cx23885_video_qops;
1224 q->mem_ops = &vb2_dma_sg_memops;
1225 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1226 q->lock = &dev->lock;
1227
1228 err = vb2_queue_init(q);
1229 if (err < 0)
1230 goto fail_unreg;
1231
1232 q = &dev->vb2_vbiq;
1233 q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1234 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1235 q->gfp_flags = GFP_DMA32;
1236 q->min_buffers_needed = 2;
1237 q->drv_priv = dev;
1238 q->buf_struct_size = sizeof(struct cx23885_buffer);
1239 q->ops = &cx23885_vbi_qops;
1240 q->mem_ops = &vb2_dma_sg_memops;
1241 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1242 q->lock = &dev->lock;
1243
1244 err = vb2_queue_init(q);
1245 if (err < 0)
1246 goto fail_unreg;
1247
1248
1249 dev->video_dev = cx23885_vdev_init(dev, dev->pci,
1250 &cx23885_video_template, "video");
1251 dev->video_dev->queue = &dev->vb2_vidq;
1252 err = video_register_device(dev->video_dev, VFL_TYPE_GRABBER,
1253 video_nr[dev->nr]);
1254 if (err < 0) {
1255 printk(KERN_INFO "%s: can't register video device\n",
1256 dev->name);
1257 goto fail_unreg;
1258 }
1259 printk(KERN_INFO "%s: registered device %s [v4l2]\n",
1260 dev->name, video_device_node_name(dev->video_dev));
1261
1262
1263 dev->vbi_dev = cx23885_vdev_init(dev, dev->pci,
1264 &cx23885_vbi_template, "vbi");
1265 dev->vbi_dev->queue = &dev->vb2_vbiq;
1266 err = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
1267 vbi_nr[dev->nr]);
1268 if (err < 0) {
1269 printk(KERN_INFO "%s: can't register vbi device\n",
1270 dev->name);
1271 goto fail_unreg;
1272 }
1273 printk(KERN_INFO "%s: registered device %s\n",
1274 dev->name, video_device_node_name(dev->vbi_dev));
1275
1276
1277 dev->audio_dev = cx23885_audio_register(dev);
1278
1279 return 0;
1280
1281fail_unreg:
1282 cx23885_video_unregister(dev);
1283 return err;
1284}
1285
