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