1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include "em28xx.h"
30
31#include <linux/init.h>
32#include <linux/list.h>
33#include <linux/module.h>
34#include <linux/kernel.h>
35#include <linux/bitmap.h>
36#include <linux/usb.h>
37#include <linux/i2c.h>
38#include <linux/mm.h>
39#include <linux/mutex.h>
40#include <linux/slab.h>
41
42#include "em28xx-v4l.h"
43#include <media/v4l2-common.h>
44#include <media/v4l2-ioctl.h>
45#include <media/v4l2-event.h>
46#include <media/drv-intf/msp3400.h>
47#include <media/tuner.h>
48
49#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
50 "Markus Rechberger <mrechberger@gmail.com>, " \
51 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
52 "Sascha Sommer <saschasommer@freenet.de>"
53
54static unsigned int isoc_debug;
55module_param(isoc_debug, int, 0644);
56MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
57
58static unsigned int disable_vbi;
59module_param(disable_vbi, int, 0644);
60MODULE_PARM_DESC(disable_vbi, "disable vbi support");
61
62static int alt;
63module_param(alt, int, 0644);
64MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
65
66#define em28xx_videodbg(fmt, arg...) do { \
67 if (video_debug) \
68 dev_printk(KERN_DEBUG, &dev->intf->dev, \
69 "video: %s: " fmt, __func__, ## arg); \
70} while (0)
71
72#define em28xx_isocdbg(fmt, arg...) do {\
73 if (isoc_debug) \
74 dev_printk(KERN_DEBUG, &dev->intf->dev, \
75 "isoc: %s: " fmt, __func__, ## arg); \
76} while (0)
77
78MODULE_AUTHOR(DRIVER_AUTHOR);
79MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
80MODULE_LICENSE("GPL");
81MODULE_VERSION(EM28XX_VERSION);
82
83#define EM25XX_FRMDATAHDR_BYTE1 0x02
84#define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE 0x20
85#define EM25XX_FRMDATAHDR_BYTE2_FRAME_END 0x02
86#define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID 0x01
87#define EM25XX_FRMDATAHDR_BYTE2_MASK (EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \
88 EM25XX_FRMDATAHDR_BYTE2_FRAME_END | \
89 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID)
90
91static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
92static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
93static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
94
95module_param_array(video_nr, int, NULL, 0444);
96module_param_array(vbi_nr, int, NULL, 0444);
97module_param_array(radio_nr, int, NULL, 0444);
98MODULE_PARM_DESC(video_nr, "video device numbers");
99MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
100MODULE_PARM_DESC(radio_nr, "radio device numbers");
101
102static unsigned int video_debug;
103module_param(video_debug, int, 0644);
104MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
105
106
107static struct em28xx_fmt format[] = {
108 {
109 .name = "16 bpp YUY2, 4:2:2, packed",
110 .fourcc = V4L2_PIX_FMT_YUYV,
111 .depth = 16,
112 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V,
113 }, {
114 .name = "16 bpp RGB 565, LE",
115 .fourcc = V4L2_PIX_FMT_RGB565,
116 .depth = 16,
117 .reg = EM28XX_OUTFMT_RGB_16_656,
118 }, {
119 .name = "8 bpp Bayer RGRG..GBGB",
120 .fourcc = V4L2_PIX_FMT_SRGGB8,
121 .depth = 8,
122 .reg = EM28XX_OUTFMT_RGB_8_RGRG,
123 }, {
124 .name = "8 bpp Bayer BGBG..GRGR",
125 .fourcc = V4L2_PIX_FMT_SBGGR8,
126 .depth = 8,
127 .reg = EM28XX_OUTFMT_RGB_8_BGBG,
128 }, {
129 .name = "8 bpp Bayer GRGR..BGBG",
130 .fourcc = V4L2_PIX_FMT_SGRBG8,
131 .depth = 8,
132 .reg = EM28XX_OUTFMT_RGB_8_GRGR,
133 }, {
134 .name = "8 bpp Bayer GBGB..RGRG",
135 .fourcc = V4L2_PIX_FMT_SGBRG8,
136 .depth = 8,
137 .reg = EM28XX_OUTFMT_RGB_8_GBGB,
138 }, {
139 .name = "12 bpp YUV411",
140 .fourcc = V4L2_PIX_FMT_YUV411P,
141 .depth = 12,
142 .reg = EM28XX_OUTFMT_YUV411,
143 },
144};
145
146
147static inline unsigned int norm_maxw(struct em28xx *dev)
148{
149 struct em28xx_v4l2 *v4l2 = dev->v4l2;
150
151 if (dev->board.is_webcam)
152 return v4l2->sensor_xres;
153
154 if (dev->board.max_range_640_480)
155 return 640;
156
157 return 720;
158}
159
160static inline unsigned int norm_maxh(struct em28xx *dev)
161{
162 struct em28xx_v4l2 *v4l2 = dev->v4l2;
163
164 if (dev->board.is_webcam)
165 return v4l2->sensor_yres;
166
167 if (dev->board.max_range_640_480)
168 return 480;
169
170 return (v4l2->norm & V4L2_STD_625_50) ? 576 : 480;
171}
172
173static int em28xx_vbi_supported(struct em28xx *dev)
174{
175
176 if (disable_vbi == 1)
177 return 0;
178
179 if (dev->board.is_webcam)
180 return 0;
181
182
183
184 if (dev->chip_id == CHIP_ID_EM2860 ||
185 dev->chip_id == CHIP_ID_EM2883)
186 return 1;
187
188
189 return 0;
190}
191
192
193
194
195
196static void em28xx_wake_i2c(struct em28xx *dev)
197{
198 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
199
200 v4l2_device_call_all(v4l2_dev, 0, core, reset, 0);
201 v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
202 INPUT(dev->ctl_input)->vmux, 0, 0);
203}
204
205static int em28xx_colorlevels_set_default(struct em28xx *dev)
206{
207 em28xx_write_reg(dev, EM28XX_R20_YGAIN, CONTRAST_DEFAULT);
208 em28xx_write_reg(dev, EM28XX_R21_YOFFSET, BRIGHTNESS_DEFAULT);
209 em28xx_write_reg(dev, EM28XX_R22_UVGAIN, SATURATION_DEFAULT);
210 em28xx_write_reg(dev, EM28XX_R23_UOFFSET, BLUE_BALANCE_DEFAULT);
211 em28xx_write_reg(dev, EM28XX_R24_VOFFSET, RED_BALANCE_DEFAULT);
212 em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, SHARPNESS_DEFAULT);
213
214 em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
215 em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
216 em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
217 em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
218 em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
219 em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
220 return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
221}
222
223static int em28xx_set_outfmt(struct em28xx *dev)
224{
225 int ret;
226 u8 fmt, vinctrl;
227 struct em28xx_v4l2 *v4l2 = dev->v4l2;
228
229 fmt = v4l2->format->reg;
230 if (!dev->is_em25xx)
231 fmt |= 0x20;
232
233
234
235
236
237
238
239
240
241 ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
242 if (ret < 0)
243 return ret;
244
245 ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, v4l2->vinmode);
246 if (ret < 0)
247 return ret;
248
249 vinctrl = v4l2->vinctl;
250 if (em28xx_vbi_supported(dev) == 1) {
251 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
252 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
253 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, v4l2->vbi_width/4);
254 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, v4l2->vbi_height);
255 if (v4l2->norm & V4L2_STD_525_60) {
256
257 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
258 } else if (v4l2->norm & V4L2_STD_625_50) {
259
260 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
261 }
262 }
263
264 return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
265}
266
267static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
268 u8 ymin, u8 ymax)
269{
270 em28xx_videodbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
271 xmin, ymin, xmax, ymax);
272
273 em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
274 em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
275 em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
276 return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
277}
278
279static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
280 u16 width, u16 height)
281{
282 u8 cwidth = width >> 2;
283 u8 cheight = height >> 2;
284 u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
285
286
287 em28xx_videodbg("capture area set to (%d,%d): %dx%d\n",
288 hstart, vstart,
289 ((overflow & 2) << 9 | cwidth << 2),
290 ((overflow & 1) << 10 | cheight << 2));
291
292 em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
293 em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
294 em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
295 em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
296 em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
297
298
299
300 if (dev->is_em25xx) {
301 em28xx_write_reg(dev, 0x34, width >> 4);
302 em28xx_write_reg(dev, 0x35, height >> 4);
303 }
304}
305
306static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
307{
308 u8 mode = 0x00;
309
310
311 if (dev->board.is_em2800) {
312 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
313 } else {
314 u8 buf[2];
315
316 buf[0] = h;
317 buf[1] = h >> 8;
318 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
319
320 buf[0] = v;
321 buf[1] = v >> 8;
322 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
323
324
325 mode = (h || v) ? 0x30 : 0x00;
326 }
327 return em28xx_write_reg(dev, EM28XX_R26_COMPR, mode);
328}
329
330
331static int em28xx_resolution_set(struct em28xx *dev)
332{
333 struct em28xx_v4l2 *v4l2 = dev->v4l2;
334 int width = norm_maxw(dev);
335 int height = norm_maxh(dev);
336
337
338 v4l2->vbi_width = 720;
339 if (v4l2->norm & V4L2_STD_525_60)
340 v4l2->vbi_height = 12;
341 else
342 v4l2->vbi_height = 18;
343
344 em28xx_set_outfmt(dev);
345
346 em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
347
348
349
350
351
352
353
354
355 if (em28xx_vbi_supported(dev) == 1)
356 em28xx_capture_area_set(dev, 0, 2, width, height);
357 else
358 em28xx_capture_area_set(dev, 0, 0, width, height);
359
360 return em28xx_scaler_set(dev, v4l2->hscale, v4l2->vscale);
361}
362
363
364static int em28xx_set_alternate(struct em28xx *dev)
365{
366 struct em28xx_v4l2 *v4l2 = dev->v4l2;
367 struct usb_device *udev = interface_to_usbdev(dev->intf);
368 int errCode;
369 int i;
370 unsigned int min_pkt_size = v4l2->width * 2 + 4;
371
372
373
374 dev->alt = 0;
375 if ((alt > 0) && (alt < dev->num_alt)) {
376 em28xx_videodbg("alternate forced to %d\n", dev->alt);
377 dev->alt = alt;
378 goto set_alt;
379 }
380 if (dev->analog_xfer_bulk)
381 goto set_alt;
382
383
384
385
386
387 if (v4l2->width * 2 * v4l2->height > 720 * 240 * 2)
388 min_pkt_size *= 2;
389
390 for (i = 0; i < dev->num_alt; i++) {
391
392 if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
393 dev->alt = i;
394 break;
395
396
397
398 } else if (dev->alt_max_pkt_size_isoc[i] >
399 dev->alt_max_pkt_size_isoc[dev->alt])
400 dev->alt = i;
401 }
402
403set_alt:
404
405
406
407 if (dev->analog_xfer_bulk) {
408 dev->max_pkt_size = 512;
409 dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
410 } else {
411 em28xx_videodbg("minimum isoc packet size: %u (alt=%d)\n",
412 min_pkt_size, dev->alt);
413 dev->max_pkt_size =
414 dev->alt_max_pkt_size_isoc[dev->alt];
415 dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
416 }
417 em28xx_videodbg("setting alternate %d with wMaxPacketSize=%u\n",
418 dev->alt, dev->max_pkt_size);
419 errCode = usb_set_interface(udev, dev->ifnum, dev->alt);
420 if (errCode < 0) {
421 dev_err(&dev->intf->dev,
422 "cannot change alternate number to %d (error=%i)\n",
423 dev->alt, errCode);
424 return errCode;
425 }
426 return 0;
427}
428
429
430
431
432
433
434
435
436static inline void finish_buffer(struct em28xx *dev,
437 struct em28xx_buffer *buf)
438{
439 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
440
441 buf->vb.sequence = dev->v4l2->field_count++;
442 if (dev->v4l2->progressive)
443 buf->vb.field = V4L2_FIELD_NONE;
444 else
445 buf->vb.field = V4L2_FIELD_INTERLACED;
446 buf->vb.vb2_buf.timestamp = ktime_get_ns();
447
448 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
449}
450
451
452
453
454static void em28xx_copy_video(struct em28xx *dev,
455 struct em28xx_buffer *buf,
456 unsigned char *usb_buf,
457 unsigned long len)
458{
459 struct em28xx_v4l2 *v4l2 = dev->v4l2;
460 void *fieldstart, *startwrite, *startread;
461 int linesdone, currlinedone, offset, lencopy, remain;
462 int bytesperline = v4l2->width << 1;
463
464 if (buf->pos + len > buf->length)
465 len = buf->length - buf->pos;
466
467 startread = usb_buf;
468 remain = len;
469
470 if (v4l2->progressive || buf->top_field)
471 fieldstart = buf->vb_buf;
472 else
473 fieldstart = buf->vb_buf + bytesperline;
474
475 linesdone = buf->pos / bytesperline;
476 currlinedone = buf->pos % bytesperline;
477
478 if (v4l2->progressive)
479 offset = linesdone * bytesperline + currlinedone;
480 else
481 offset = linesdone * bytesperline * 2 + currlinedone;
482
483 startwrite = fieldstart + offset;
484 lencopy = bytesperline - currlinedone;
485 lencopy = lencopy > remain ? remain : lencopy;
486
487 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
488 em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n",
489 ((char *)startwrite + lencopy) -
490 ((char *)buf->vb_buf + buf->length));
491 remain = (char *)buf->vb_buf + buf->length -
492 (char *)startwrite;
493 lencopy = remain;
494 }
495 if (lencopy <= 0)
496 return;
497 memcpy(startwrite, startread, lencopy);
498
499 remain -= lencopy;
500
501 while (remain > 0) {
502 if (v4l2->progressive)
503 startwrite += lencopy;
504 else
505 startwrite += lencopy + bytesperline;
506 startread += lencopy;
507 if (bytesperline > remain)
508 lencopy = remain;
509 else
510 lencopy = bytesperline;
511
512 if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
513 buf->length) {
514 em28xx_isocdbg("Overflow of %zu bytes past buffer end(2)\n",
515 ((char *)startwrite + lencopy) -
516 ((char *)buf->vb_buf + buf->length));
517 lencopy = remain = (char *)buf->vb_buf + buf->length -
518 (char *)startwrite;
519 }
520 if (lencopy <= 0)
521 break;
522
523 memcpy(startwrite, startread, lencopy);
524
525 remain -= lencopy;
526 }
527
528 buf->pos += len;
529}
530
531
532
533
534static void em28xx_copy_vbi(struct em28xx *dev,
535 struct em28xx_buffer *buf,
536 unsigned char *usb_buf,
537 unsigned long len)
538{
539 unsigned int offset;
540
541 if (buf->pos + len > buf->length)
542 len = buf->length - buf->pos;
543
544 offset = buf->pos;
545
546 if (buf->top_field == 0)
547 offset += dev->v4l2->vbi_width * dev->v4l2->vbi_height;
548
549 memcpy(buf->vb_buf + offset, usb_buf, len);
550 buf->pos += len;
551}
552
553static inline void print_err_status(struct em28xx *dev,
554 int packet, int status)
555{
556 char *errmsg = "Unknown";
557
558 switch (status) {
559 case -ENOENT:
560 errmsg = "unlinked synchronuously";
561 break;
562 case -ECONNRESET:
563 errmsg = "unlinked asynchronuously";
564 break;
565 case -ENOSR:
566 errmsg = "Buffer error (overrun)";
567 break;
568 case -EPIPE:
569 errmsg = "Stalled (device not responding)";
570 break;
571 case -EOVERFLOW:
572 errmsg = "Babble (bad cable?)";
573 break;
574 case -EPROTO:
575 errmsg = "Bit-stuff error (bad cable?)";
576 break;
577 case -EILSEQ:
578 errmsg = "CRC/Timeout (could be anything)";
579 break;
580 case -ETIME:
581 errmsg = "Device does not respond";
582 break;
583 }
584 if (packet < 0) {
585 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
586 } else {
587 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
588 packet, status, errmsg);
589 }
590}
591
592
593
594
595static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
596 struct em28xx_dmaqueue *dma_q)
597{
598 struct em28xx_buffer *buf;
599
600 if (list_empty(&dma_q->active)) {
601 em28xx_isocdbg("No active queue to serve\n");
602 return NULL;
603 }
604
605
606 buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
607
608 list_del(&buf->list);
609 buf->pos = 0;
610 buf->vb_buf = buf->mem;
611
612 return buf;
613}
614
615
616
617
618static struct em28xx_buffer *
619finish_field_prepare_next(struct em28xx *dev,
620 struct em28xx_buffer *buf,
621 struct em28xx_dmaqueue *dma_q)
622{
623 struct em28xx_v4l2 *v4l2 = dev->v4l2;
624
625 if (v4l2->progressive || v4l2->top_field) {
626 if (buf != NULL)
627 finish_buffer(dev, buf);
628 buf = get_next_buf(dev, dma_q);
629 }
630 if (buf != NULL) {
631 buf->top_field = v4l2->top_field;
632 buf->pos = 0;
633 }
634
635 return buf;
636}
637
638
639
640
641static inline void process_frame_data_em28xx(struct em28xx *dev,
642 unsigned char *data_pkt,
643 unsigned int data_len)
644{
645 struct em28xx_v4l2 *v4l2 = dev->v4l2;
646 struct em28xx_buffer *buf = dev->usb_ctl.vid_buf;
647 struct em28xx_buffer *vbi_buf = dev->usb_ctl.vbi_buf;
648 struct em28xx_dmaqueue *dma_q = &dev->vidq;
649 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
650
651
652
653
654
655 if (data_len >= 4) {
656
657
658 if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
659 data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
660
661 data_pkt += 4;
662 data_len -= 4;
663 } else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
664
665 v4l2->capture_type = 0;
666 v4l2->vbi_read = 0;
667 em28xx_isocdbg("VBI START HEADER !!!\n");
668 v4l2->top_field = !(data_pkt[2] & 1);
669 data_pkt += 4;
670 data_len -= 4;
671 } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
672
673 v4l2->capture_type = 2;
674 em28xx_isocdbg("VIDEO START HEADER !!!\n");
675 v4l2->top_field = !(data_pkt[2] & 1);
676 data_pkt += 4;
677 data_len -= 4;
678 }
679 }
680
681
682
683 if (v4l2->capture_type == 0) {
684 vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
685 dev->usb_ctl.vbi_buf = vbi_buf;
686 v4l2->capture_type = 1;
687 }
688
689 if (v4l2->capture_type == 1) {
690 int vbi_size = v4l2->vbi_width * v4l2->vbi_height;
691 int vbi_data_len = ((v4l2->vbi_read + data_len) > vbi_size) ?
692 (vbi_size - v4l2->vbi_read) : data_len;
693
694
695 if (vbi_buf != NULL)
696 em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
697 v4l2->vbi_read += vbi_data_len;
698
699 if (vbi_data_len < data_len) {
700
701 v4l2->capture_type = 2;
702 data_pkt += vbi_data_len;
703 data_len -= vbi_data_len;
704 }
705 }
706
707 if (v4l2->capture_type == 2) {
708 buf = finish_field_prepare_next(dev, buf, dma_q);
709 dev->usb_ctl.vid_buf = buf;
710 v4l2->capture_type = 3;
711 }
712
713 if (v4l2->capture_type == 3 && buf != NULL && data_len > 0)
714 em28xx_copy_video(dev, buf, data_pkt, data_len);
715}
716
717
718
719
720static inline void process_frame_data_em25xx(struct em28xx *dev,
721 unsigned char *data_pkt,
722 unsigned int data_len)
723{
724 struct em28xx_buffer *buf = dev->usb_ctl.vid_buf;
725 struct em28xx_dmaqueue *dmaq = &dev->vidq;
726 struct em28xx_v4l2 *v4l2 = dev->v4l2;
727 bool frame_end = false;
728
729
730
731
732 if (data_len >= 2) {
733 if ((data_pkt[0] == EM25XX_FRMDATAHDR_BYTE1) &&
734 ((data_pkt[1] & ~EM25XX_FRMDATAHDR_BYTE2_MASK) == 0x00)) {
735 v4l2->top_field = !(data_pkt[1] &
736 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID);
737 frame_end = data_pkt[1] &
738 EM25XX_FRMDATAHDR_BYTE2_FRAME_END;
739 data_pkt += 2;
740 data_len -= 2;
741 }
742
743
744 if (dev->analog_xfer_bulk && frame_end) {
745 buf = finish_field_prepare_next(dev, buf, dmaq);
746 dev->usb_ctl.vid_buf = buf;
747 }
748
749
750
751
752 }
753
754
755 if (buf != NULL && data_len > 0)
756 em28xx_copy_video(dev, buf, data_pkt, data_len);
757
758
759 if (!dev->analog_xfer_bulk && frame_end) {
760 buf = finish_field_prepare_next(dev, buf, dmaq);
761 dev->usb_ctl.vid_buf = buf;
762 }
763
764
765
766
767
768
769
770
771
772}
773
774
775static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
776{
777 int xfer_bulk, num_packets, i;
778 unsigned char *usb_data_pkt;
779 unsigned int usb_data_len;
780
781 if (!dev)
782 return 0;
783
784 if (dev->disconnected)
785 return 0;
786
787 if (urb->status < 0)
788 print_err_status(dev, -1, urb->status);
789
790 xfer_bulk = usb_pipebulk(urb->pipe);
791
792 if (xfer_bulk)
793 num_packets = 1;
794 else
795 num_packets = urb->number_of_packets;
796
797 for (i = 0; i < num_packets; i++) {
798 if (xfer_bulk) {
799 usb_data_len = urb->actual_length;
800
801 usb_data_pkt = urb->transfer_buffer;
802 } else {
803 if (urb->iso_frame_desc[i].status < 0) {
804 print_err_status(dev, i,
805 urb->iso_frame_desc[i].status);
806 if (urb->iso_frame_desc[i].status != -EPROTO)
807 continue;
808 }
809
810 usb_data_len = urb->iso_frame_desc[i].actual_length;
811 if (usb_data_len > dev->max_pkt_size) {
812 em28xx_isocdbg("packet bigger than packet size");
813 continue;
814 }
815
816 usb_data_pkt = urb->transfer_buffer +
817 urb->iso_frame_desc[i].offset;
818 }
819
820 if (usb_data_len == 0) {
821
822
823 continue;
824 }
825
826 if (dev->is_em25xx)
827 process_frame_data_em25xx(dev,
828 usb_data_pkt, usb_data_len);
829 else
830 process_frame_data_em28xx(dev,
831 usb_data_pkt, usb_data_len);
832
833 }
834 return 1;
835}
836
837static int get_ressource(enum v4l2_buf_type f_type)
838{
839 switch (f_type) {
840 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
841 return EM28XX_RESOURCE_VIDEO;
842 case V4L2_BUF_TYPE_VBI_CAPTURE:
843 return EM28XX_RESOURCE_VBI;
844 default:
845 BUG();
846 }
847}
848
849
850static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
851{
852 int res_type = get_ressource(f_type);
853
854
855 if (dev->resources & res_type) {
856
857 return -EBUSY;
858 }
859
860
861 dev->resources |= res_type;
862 em28xx_videodbg("res: get %d\n", res_type);
863 return 0;
864}
865
866static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
867{
868 int res_type = get_ressource(f_type);
869
870 dev->resources &= ~res_type;
871 em28xx_videodbg("res: put %d\n", res_type);
872}
873
874static void em28xx_v4l2_media_release(struct em28xx *dev)
875{
876#ifdef CONFIG_MEDIA_CONTROLLER
877 int i;
878
879 for (i = 0; i < MAX_EM28XX_INPUT; i++) {
880 if (!INPUT(i)->type)
881 return;
882 media_device_unregister_entity(&dev->input_ent[i]);
883 }
884#endif
885}
886
887
888
889
890
891static int em28xx_enable_analog_tuner(struct em28xx *dev)
892{
893#ifdef CONFIG_MEDIA_CONTROLLER
894 struct media_device *mdev = dev->media_dev;
895 struct em28xx_v4l2 *v4l2 = dev->v4l2;
896 struct media_entity *source;
897 struct media_link *link, *found_link = NULL;
898 int ret, active_links = 0;
899
900 if (!mdev || !v4l2->decoder)
901 return 0;
902
903
904
905
906
907
908
909
910 list_for_each_entry(link, &v4l2->decoder->links, list) {
911 if (link->sink->entity == v4l2->decoder) {
912 found_link = link;
913 if (link->flags & MEDIA_LNK_FL_ENABLED)
914 active_links++;
915 break;
916 }
917 }
918
919 if (active_links == 1 || !found_link)
920 return 0;
921
922 source = found_link->source->entity;
923 list_for_each_entry(link, &source->links, list) {
924 struct media_entity *sink;
925 int flags = 0;
926
927 sink = link->sink->entity;
928
929 if (sink == v4l2->decoder)
930 flags = MEDIA_LNK_FL_ENABLED;
931
932 ret = media_entity_setup_link(link, flags);
933 if (ret) {
934 dev_err(&dev->intf->dev,
935 "Couldn't change link %s->%s to %s. Error %d\n",
936 source->name, sink->name,
937 flags ? "enabled" : "disabled",
938 ret);
939 return ret;
940 } else
941 em28xx_videodbg("link %s->%s was %s\n",
942 source->name, sink->name,
943 flags ? "ENABLED" : "disabled");
944 }
945#endif
946 return 0;
947}
948
949static const char * const iname[] = {
950 [EM28XX_VMUX_COMPOSITE] = "Composite",
951 [EM28XX_VMUX_SVIDEO] = "S-Video",
952 [EM28XX_VMUX_TELEVISION] = "Television",
953 [EM28XX_RADIO] = "Radio",
954};
955
956static void em28xx_v4l2_create_entities(struct em28xx *dev)
957{
958#if defined(CONFIG_MEDIA_CONTROLLER)
959 struct em28xx_v4l2 *v4l2 = dev->v4l2;
960 int ret, i;
961
962
963 v4l2->video_pad.flags = MEDIA_PAD_FL_SINK;
964 ret = media_entity_pads_init(&v4l2->vdev.entity, 1, &v4l2->video_pad);
965 if (ret < 0)
966 dev_err(&dev->intf->dev,
967 "failed to initialize video media entity!\n");
968
969 if (em28xx_vbi_supported(dev)) {
970 v4l2->vbi_pad.flags = MEDIA_PAD_FL_SINK;
971 ret = media_entity_pads_init(&v4l2->vbi_dev.entity, 1,
972 &v4l2->vbi_pad);
973 if (ret < 0)
974 dev_err(&dev->intf->dev,
975 "failed to initialize vbi media entity!\n");
976 }
977
978
979 if (dev->board.is_webcam)
980 return;
981
982
983 for (i = 0; i < MAX_EM28XX_INPUT; i++) {
984 struct media_entity *ent = &dev->input_ent[i];
985
986 if (!INPUT(i)->type)
987 break;
988
989 ent->name = iname[INPUT(i)->type];
990 ent->flags = MEDIA_ENT_FL_CONNECTOR;
991 dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
992
993 switch (INPUT(i)->type) {
994 case EM28XX_VMUX_COMPOSITE:
995 ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
996 break;
997 case EM28XX_VMUX_SVIDEO:
998 ent->function = MEDIA_ENT_F_CONN_SVIDEO;
999 break;
1000 default:
1001 if (dev->tuner_type != TUNER_ABSENT)
1002 ent->function = MEDIA_ENT_F_CONN_RF;
1003 break;
1004 }
1005
1006 ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
1007 if (ret < 0)
1008 dev_err(&dev->intf->dev,
1009 "failed to initialize input pad[%d]!\n", i);
1010
1011 ret = media_device_register_entity(dev->media_dev, ent);
1012 if (ret < 0)
1013 dev_err(&dev->intf->dev,
1014 "failed to register input entity %d!\n", i);
1015 }
1016#endif
1017}
1018
1019
1020
1021
1022
1023
1024static int queue_setup(struct vb2_queue *vq,
1025 unsigned int *nbuffers, unsigned int *nplanes,
1026 unsigned int sizes[], struct device *alloc_devs[])
1027{
1028 struct em28xx *dev = vb2_get_drv_priv(vq);
1029 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1030 unsigned long size =
1031 (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1032
1033 if (*nplanes)
1034 return sizes[0] < size ? -EINVAL : 0;
1035 *nplanes = 1;
1036 sizes[0] = size;
1037
1038 em28xx_enable_analog_tuner(dev);
1039
1040 return 0;
1041}
1042
1043static int
1044buffer_prepare(struct vb2_buffer *vb)
1045{
1046 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1047 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1048 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1049 unsigned long size;
1050
1051 em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field);
1052
1053 size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1054
1055 if (vb2_plane_size(vb, 0) < size) {
1056 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
1057 __func__, vb2_plane_size(vb, 0), size);
1058 return -EINVAL;
1059 }
1060 vb2_set_plane_payload(vb, 0, size);
1061
1062 return 0;
1063}
1064
1065int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
1066{
1067 struct em28xx *dev = vb2_get_drv_priv(vq);
1068 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1069 struct v4l2_frequency f;
1070 struct v4l2_fh *owner;
1071 int rc = 0;
1072
1073 em28xx_videodbg("%s\n", __func__);
1074
1075
1076
1077 rc = res_get(dev, vq->type);
1078 if (rc)
1079 return rc;
1080
1081 if (v4l2->streaming_users == 0) {
1082
1083
1084
1085 em28xx_set_alternate(dev);
1086
1087
1088
1089
1090 em28xx_wake_i2c(dev);
1091
1092 v4l2->capture_type = -1;
1093 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
1094 dev->analog_xfer_bulk,
1095 EM28XX_NUM_BUFS,
1096 dev->max_pkt_size,
1097 dev->packet_multiplier,
1098 em28xx_urb_data_copy);
1099 if (rc < 0)
1100 return rc;
1101
1102
1103
1104
1105
1106
1107
1108
1109 memset(&f, 0, sizeof(f));
1110 f.frequency = v4l2->frequency;
1111 owner = (struct v4l2_fh *)vq->owner;
1112 if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO)
1113 f.type = V4L2_TUNER_RADIO;
1114 else
1115 f.type = V4L2_TUNER_ANALOG_TV;
1116 v4l2_device_call_all(&v4l2->v4l2_dev,
1117 0, tuner, s_frequency, &f);
1118
1119
1120 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1);
1121 }
1122
1123 v4l2->streaming_users++;
1124
1125 return rc;
1126}
1127
1128static void em28xx_stop_streaming(struct vb2_queue *vq)
1129{
1130 struct em28xx *dev = vb2_get_drv_priv(vq);
1131 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1132 struct em28xx_dmaqueue *vidq = &dev->vidq;
1133 unsigned long flags = 0;
1134
1135 em28xx_videodbg("%s\n", __func__);
1136
1137 res_free(dev, vq->type);
1138
1139 if (v4l2->streaming_users-- == 1) {
1140
1141 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
1142
1143
1144 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1145 }
1146
1147 spin_lock_irqsave(&dev->slock, flags);
1148 if (dev->usb_ctl.vid_buf != NULL) {
1149 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf,
1150 VB2_BUF_STATE_ERROR);
1151 dev->usb_ctl.vid_buf = NULL;
1152 }
1153 while (!list_empty(&vidq->active)) {
1154 struct em28xx_buffer *buf;
1155
1156 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
1157 list_del(&buf->list);
1158 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1159 }
1160 spin_unlock_irqrestore(&dev->slock, flags);
1161}
1162
1163void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
1164{
1165 struct em28xx *dev = vb2_get_drv_priv(vq);
1166 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1167 struct em28xx_dmaqueue *vbiq = &dev->vbiq;
1168 unsigned long flags = 0;
1169
1170 em28xx_videodbg("%s\n", __func__);
1171
1172 res_free(dev, vq->type);
1173
1174 if (v4l2->streaming_users-- == 1) {
1175
1176 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
1177
1178
1179 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1180 }
1181
1182 spin_lock_irqsave(&dev->slock, flags);
1183 if (dev->usb_ctl.vbi_buf != NULL) {
1184 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf,
1185 VB2_BUF_STATE_ERROR);
1186 dev->usb_ctl.vbi_buf = NULL;
1187 }
1188 while (!list_empty(&vbiq->active)) {
1189 struct em28xx_buffer *buf;
1190
1191 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
1192 list_del(&buf->list);
1193 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1194 }
1195 spin_unlock_irqrestore(&dev->slock, flags);
1196}
1197
1198static void
1199buffer_queue(struct vb2_buffer *vb)
1200{
1201 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1202 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1203 struct em28xx_buffer *buf =
1204 container_of(vbuf, struct em28xx_buffer, vb);
1205 struct em28xx_dmaqueue *vidq = &dev->vidq;
1206 unsigned long flags = 0;
1207
1208 em28xx_videodbg("%s\n", __func__);
1209 buf->mem = vb2_plane_vaddr(vb, 0);
1210 buf->length = vb2_plane_size(vb, 0);
1211
1212 spin_lock_irqsave(&dev->slock, flags);
1213 list_add_tail(&buf->list, &vidq->active);
1214 spin_unlock_irqrestore(&dev->slock, flags);
1215}
1216
1217static const struct vb2_ops em28xx_video_qops = {
1218 .queue_setup = queue_setup,
1219 .buf_prepare = buffer_prepare,
1220 .buf_queue = buffer_queue,
1221 .start_streaming = em28xx_start_analog_streaming,
1222 .stop_streaming = em28xx_stop_streaming,
1223 .wait_prepare = vb2_ops_wait_prepare,
1224 .wait_finish = vb2_ops_wait_finish,
1225};
1226
1227static int em28xx_vb2_setup(struct em28xx *dev)
1228{
1229 int rc;
1230 struct vb2_queue *q;
1231 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1232
1233
1234 q = &v4l2->vb_vidq;
1235 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1236 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1237 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1238 q->drv_priv = dev;
1239 q->buf_struct_size = sizeof(struct em28xx_buffer);
1240 q->ops = &em28xx_video_qops;
1241 q->mem_ops = &vb2_vmalloc_memops;
1242
1243 rc = vb2_queue_init(q);
1244 if (rc < 0)
1245 return rc;
1246
1247
1248 q = &v4l2->vb_vbiq;
1249 q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1250 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
1251 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1252 q->drv_priv = dev;
1253 q->buf_struct_size = sizeof(struct em28xx_buffer);
1254 q->ops = &em28xx_vbi_qops;
1255 q->mem_ops = &vb2_vmalloc_memops;
1256
1257 rc = vb2_queue_init(q);
1258 if (rc < 0)
1259 return rc;
1260
1261 return 0;
1262}
1263
1264
1265
1266static void video_mux(struct em28xx *dev, int index)
1267{
1268 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
1269
1270 dev->ctl_input = index;
1271 dev->ctl_ainput = INPUT(index)->amux;
1272 dev->ctl_aoutput = INPUT(index)->aout;
1273
1274 if (!dev->ctl_aoutput)
1275 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1276
1277 v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
1278 INPUT(index)->vmux, 0, 0);
1279
1280 if (dev->board.has_msp34xx) {
1281 if (dev->i2s_speed) {
1282 v4l2_device_call_all(v4l2_dev, 0, audio,
1283 s_i2s_clock_freq, dev->i2s_speed);
1284 }
1285
1286 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1287 dev->ctl_ainput,
1288 MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
1289 }
1290
1291 if (dev->board.adecoder != EM28XX_NOADECODER) {
1292 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1293 dev->ctl_ainput, dev->ctl_aoutput, 0);
1294 }
1295
1296 em28xx_audio_analog_set(dev);
1297}
1298
1299static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
1300{
1301 struct em28xx *dev = priv;
1302
1303
1304
1305
1306
1307
1308
1309 switch (ctrl->id) {
1310 case V4L2_CID_AUDIO_MUTE:
1311 dev->mute = ctrl->val;
1312 em28xx_audio_analog_set(dev);
1313 break;
1314 case V4L2_CID_AUDIO_VOLUME:
1315 dev->volume = ctrl->val;
1316 em28xx_audio_analog_set(dev);
1317 break;
1318 }
1319}
1320
1321static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
1322{
1323 struct em28xx_v4l2 *v4l2 =
1324 container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler);
1325 struct em28xx *dev = v4l2->dev;
1326 int ret = -EINVAL;
1327
1328 switch (ctrl->id) {
1329 case V4L2_CID_AUDIO_MUTE:
1330 dev->mute = ctrl->val;
1331 ret = em28xx_audio_analog_set(dev);
1332 break;
1333 case V4L2_CID_AUDIO_VOLUME:
1334 dev->volume = ctrl->val;
1335 ret = em28xx_audio_analog_set(dev);
1336 break;
1337 case V4L2_CID_CONTRAST:
1338 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1339 break;
1340 case V4L2_CID_BRIGHTNESS:
1341 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1342 break;
1343 case V4L2_CID_SATURATION:
1344 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1345 break;
1346 case V4L2_CID_BLUE_BALANCE:
1347 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1348 break;
1349 case V4L2_CID_RED_BALANCE:
1350 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1351 break;
1352 case V4L2_CID_SHARPNESS:
1353 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
1354 break;
1355 }
1356
1357 return (ret < 0) ? ret : 0;
1358}
1359
1360static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
1361 .s_ctrl = em28xx_s_ctrl,
1362};
1363
1364static void size_to_scale(struct em28xx *dev,
1365 unsigned int width, unsigned int height,
1366 unsigned int *hscale, unsigned int *vscale)
1367{
1368 unsigned int maxw = norm_maxw(dev);
1369 unsigned int maxh = norm_maxh(dev);
1370
1371 *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1372 if (*hscale > EM28XX_HVSCALE_MAX)
1373 *hscale = EM28XX_HVSCALE_MAX;
1374
1375 *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1376 if (*vscale > EM28XX_HVSCALE_MAX)
1377 *vscale = EM28XX_HVSCALE_MAX;
1378}
1379
1380static void scale_to_size(struct em28xx *dev,
1381 unsigned int hscale, unsigned int vscale,
1382 unsigned int *width, unsigned int *height)
1383{
1384 unsigned int maxw = norm_maxw(dev);
1385 unsigned int maxh = norm_maxh(dev);
1386
1387 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1388 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1389
1390
1391 if (*width < 1)
1392 *width = 1;
1393 if (*height < 1)
1394 *height = 1;
1395}
1396
1397
1398
1399
1400
1401static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1402 struct v4l2_format *f)
1403{
1404 struct em28xx *dev = video_drvdata(file);
1405 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1406
1407 f->fmt.pix.width = v4l2->width;
1408 f->fmt.pix.height = v4l2->height;
1409 f->fmt.pix.pixelformat = v4l2->format->fourcc;
1410 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
1411 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
1412 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1413
1414
1415 if (v4l2->progressive)
1416 f->fmt.pix.field = V4L2_FIELD_NONE;
1417 else
1418 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1419 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1420 return 0;
1421}
1422
1423static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1424{
1425 unsigned int i;
1426
1427 for (i = 0; i < ARRAY_SIZE(format); i++)
1428 if (format[i].fourcc == fourcc)
1429 return &format[i];
1430
1431 return NULL;
1432}
1433
1434static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1435 struct v4l2_format *f)
1436{
1437 struct em28xx *dev = video_drvdata(file);
1438 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1439 unsigned int width = f->fmt.pix.width;
1440 unsigned int height = f->fmt.pix.height;
1441 unsigned int maxw = norm_maxw(dev);
1442 unsigned int maxh = norm_maxh(dev);
1443 unsigned int hscale, vscale;
1444 struct em28xx_fmt *fmt;
1445
1446 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1447 if (!fmt) {
1448 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1449 f->fmt.pix.pixelformat);
1450 return -EINVAL;
1451 }
1452
1453 if (dev->board.is_em2800) {
1454
1455 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1456 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1457
1458
1459
1460
1461
1462 if (width == maxw && height == maxh)
1463 width /= 2;
1464 } else {
1465
1466
1467 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1468 1, 0);
1469 }
1470
1471 if (width < 1)
1472 width = 1;
1473 if (height < 1)
1474 height = 1;
1475
1476 size_to_scale(dev, width, height, &hscale, &vscale);
1477 scale_to_size(dev, hscale, vscale, &width, &height);
1478
1479 f->fmt.pix.width = width;
1480 f->fmt.pix.height = height;
1481 f->fmt.pix.pixelformat = fmt->fourcc;
1482 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
1483 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1484 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1485 if (v4l2->progressive)
1486 f->fmt.pix.field = V4L2_FIELD_NONE;
1487 else
1488 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1489 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1490 f->fmt.pix.priv = 0;
1491
1492 return 0;
1493}
1494
1495static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1496 unsigned width, unsigned height)
1497{
1498 struct em28xx_fmt *fmt;
1499 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1500
1501 fmt = format_by_fourcc(fourcc);
1502 if (!fmt)
1503 return -EINVAL;
1504
1505 v4l2->format = fmt;
1506 v4l2->width = width;
1507 v4l2->height = height;
1508
1509
1510 size_to_scale(dev, v4l2->width, v4l2->height,
1511 &v4l2->hscale, &v4l2->vscale);
1512
1513 em28xx_resolution_set(dev);
1514
1515 return 0;
1516}
1517
1518static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1519 struct v4l2_format *f)
1520{
1521 struct em28xx *dev = video_drvdata(file);
1522 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1523
1524 if (vb2_is_busy(&v4l2->vb_vidq))
1525 return -EBUSY;
1526
1527 vidioc_try_fmt_vid_cap(file, priv, f);
1528
1529 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1530 f->fmt.pix.width, f->fmt.pix.height);
1531}
1532
1533static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1534{
1535 struct em28xx *dev = video_drvdata(file);
1536
1537 *norm = dev->v4l2->norm;
1538
1539 return 0;
1540}
1541
1542static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1543{
1544 struct em28xx *dev = video_drvdata(file);
1545
1546 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
1547
1548 return 0;
1549}
1550
1551static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1552{
1553 struct em28xx *dev = video_drvdata(file);
1554 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1555 struct v4l2_format f;
1556
1557 if (norm == v4l2->norm)
1558 return 0;
1559
1560 if (v4l2->streaming_users > 0)
1561 return -EBUSY;
1562
1563 v4l2->norm = norm;
1564
1565
1566 f.fmt.pix.width = 720;
1567 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
1568 vidioc_try_fmt_vid_cap(file, priv, &f);
1569
1570
1571 v4l2->width = f.fmt.pix.width;
1572 v4l2->height = f.fmt.pix.height;
1573 size_to_scale(dev, v4l2->width, v4l2->height,
1574 &v4l2->hscale, &v4l2->vscale);
1575
1576 em28xx_resolution_set(dev);
1577 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
1578
1579 return 0;
1580}
1581
1582static int vidioc_g_parm(struct file *file, void *priv,
1583 struct v4l2_streamparm *p)
1584{
1585 struct em28xx *dev = video_drvdata(file);
1586 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1587 int rc = 0;
1588
1589 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1590 if (dev->board.is_webcam)
1591 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
1592 video, g_parm, p);
1593 else
1594 v4l2_video_std_frame_period(v4l2->norm,
1595 &p->parm.capture.timeperframe);
1596
1597 return rc;
1598}
1599
1600static int vidioc_s_parm(struct file *file, void *priv,
1601 struct v4l2_streamparm *p)
1602{
1603 struct em28xx *dev = video_drvdata(file);
1604
1605 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1606 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1607 0, video, s_parm, p);
1608}
1609
1610static int vidioc_enum_input(struct file *file, void *priv,
1611 struct v4l2_input *i)
1612{
1613 struct em28xx *dev = video_drvdata(file);
1614 unsigned int n;
1615
1616 n = i->index;
1617 if (n >= MAX_EM28XX_INPUT)
1618 return -EINVAL;
1619 if (0 == INPUT(n)->type)
1620 return -EINVAL;
1621
1622 i->index = n;
1623 i->type = V4L2_INPUT_TYPE_CAMERA;
1624
1625 strcpy(i->name, iname[INPUT(n)->type]);
1626
1627 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type))
1628 i->type = V4L2_INPUT_TYPE_TUNER;
1629
1630 i->std = dev->v4l2->vdev.tvnorms;
1631
1632 if (dev->board.is_webcam)
1633 i->capabilities = 0;
1634
1635 return 0;
1636}
1637
1638static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1639{
1640 struct em28xx *dev = video_drvdata(file);
1641
1642 *i = dev->ctl_input;
1643
1644 return 0;
1645}
1646
1647static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1648{
1649 struct em28xx *dev = video_drvdata(file);
1650
1651 if (i >= MAX_EM28XX_INPUT)
1652 return -EINVAL;
1653 if (0 == INPUT(i)->type)
1654 return -EINVAL;
1655
1656 video_mux(dev, i);
1657 return 0;
1658}
1659
1660static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1661{
1662 struct em28xx *dev = video_drvdata(file);
1663
1664 switch (a->index) {
1665 case EM28XX_AMUX_VIDEO:
1666 strcpy(a->name, "Television");
1667 break;
1668 case EM28XX_AMUX_LINE_IN:
1669 strcpy(a->name, "Line In");
1670 break;
1671 case EM28XX_AMUX_VIDEO2:
1672 strcpy(a->name, "Television alt");
1673 break;
1674 case EM28XX_AMUX_PHONE:
1675 strcpy(a->name, "Phone");
1676 break;
1677 case EM28XX_AMUX_MIC:
1678 strcpy(a->name, "Mic");
1679 break;
1680 case EM28XX_AMUX_CD:
1681 strcpy(a->name, "CD");
1682 break;
1683 case EM28XX_AMUX_AUX:
1684 strcpy(a->name, "Aux");
1685 break;
1686 case EM28XX_AMUX_PCM_OUT:
1687 strcpy(a->name, "PCM");
1688 break;
1689 default:
1690 return -EINVAL;
1691 }
1692
1693 a->index = dev->ctl_ainput;
1694 a->capability = V4L2_AUDCAP_STEREO;
1695
1696 return 0;
1697}
1698
1699static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1700{
1701 struct em28xx *dev = video_drvdata(file);
1702
1703 if (a->index >= MAX_EM28XX_INPUT)
1704 return -EINVAL;
1705 if (0 == INPUT(a->index)->type)
1706 return -EINVAL;
1707
1708 dev->ctl_ainput = INPUT(a->index)->amux;
1709 dev->ctl_aoutput = INPUT(a->index)->aout;
1710
1711 if (!dev->ctl_aoutput)
1712 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1713
1714 return 0;
1715}
1716
1717static int vidioc_g_tuner(struct file *file, void *priv,
1718 struct v4l2_tuner *t)
1719{
1720 struct em28xx *dev = video_drvdata(file);
1721
1722 if (0 != t->index)
1723 return -EINVAL;
1724
1725 strcpy(t->name, "Tuner");
1726
1727 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1728 return 0;
1729}
1730
1731static int vidioc_s_tuner(struct file *file, void *priv,
1732 const struct v4l2_tuner *t)
1733{
1734 struct em28xx *dev = video_drvdata(file);
1735
1736 if (0 != t->index)
1737 return -EINVAL;
1738
1739 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1740 return 0;
1741}
1742
1743static int vidioc_g_frequency(struct file *file, void *priv,
1744 struct v4l2_frequency *f)
1745{
1746 struct em28xx *dev = video_drvdata(file);
1747 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1748
1749 if (0 != f->tuner)
1750 return -EINVAL;
1751
1752 f->frequency = v4l2->frequency;
1753 return 0;
1754}
1755
1756static int vidioc_s_frequency(struct file *file, void *priv,
1757 const struct v4l2_frequency *f)
1758{
1759 struct v4l2_frequency new_freq = *f;
1760 struct em28xx *dev = video_drvdata(file);
1761 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1762
1763 if (0 != f->tuner)
1764 return -EINVAL;
1765
1766 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1767 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1768 v4l2->frequency = new_freq.frequency;
1769
1770 return 0;
1771}
1772
1773#ifdef CONFIG_VIDEO_ADV_DEBUG
1774static int vidioc_g_chip_info(struct file *file, void *priv,
1775 struct v4l2_dbg_chip_info *chip)
1776{
1777 struct em28xx *dev = video_drvdata(file);
1778
1779 if (chip->match.addr > 1)
1780 return -EINVAL;
1781 if (chip->match.addr == 1)
1782 strlcpy(chip->name, "ac97", sizeof(chip->name));
1783 else
1784 strlcpy(chip->name,
1785 dev->v4l2->v4l2_dev.name, sizeof(chip->name));
1786 return 0;
1787}
1788
1789static int em28xx_reg_len(int reg)
1790{
1791 switch (reg) {
1792 case EM28XX_R40_AC97LSB:
1793 case EM28XX_R30_HSCALELOW:
1794 case EM28XX_R32_VSCALELOW:
1795 return 2;
1796 default:
1797 return 1;
1798 }
1799}
1800
1801static int vidioc_g_register(struct file *file, void *priv,
1802 struct v4l2_dbg_register *reg)
1803{
1804 struct em28xx *dev = video_drvdata(file);
1805 int ret;
1806
1807 if (reg->match.addr > 1)
1808 return -EINVAL;
1809 if (reg->match.addr) {
1810 ret = em28xx_read_ac97(dev, reg->reg);
1811 if (ret < 0)
1812 return ret;
1813
1814 reg->val = ret;
1815 reg->size = 1;
1816 return 0;
1817 }
1818
1819
1820 reg->size = em28xx_reg_len(reg->reg);
1821 if (reg->size == 1) {
1822 ret = em28xx_read_reg(dev, reg->reg);
1823
1824 if (ret < 0)
1825 return ret;
1826
1827 reg->val = ret;
1828 } else {
1829 __le16 val = 0;
1830
1831 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1832 reg->reg, (char *)&val, 2);
1833 if (ret < 0)
1834 return ret;
1835
1836 reg->val = le16_to_cpu(val);
1837 }
1838
1839 return 0;
1840}
1841
1842static int vidioc_s_register(struct file *file, void *priv,
1843 const struct v4l2_dbg_register *reg)
1844{
1845 struct em28xx *dev = video_drvdata(file);
1846 __le16 buf;
1847
1848 if (reg->match.addr > 1)
1849 return -EINVAL;
1850 if (reg->match.addr)
1851 return em28xx_write_ac97(dev, reg->reg, reg->val);
1852
1853
1854 buf = cpu_to_le16(reg->val);
1855
1856 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1857 em28xx_reg_len(reg->reg));
1858}
1859#endif
1860
1861static int vidioc_querycap(struct file *file, void *priv,
1862 struct v4l2_capability *cap)
1863{
1864 struct video_device *vdev = video_devdata(file);
1865 struct em28xx *dev = video_drvdata(file);
1866 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1867 struct usb_device *udev = interface_to_usbdev(dev->intf);
1868
1869 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1870 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1871 usb_make_path(udev, cap->bus_info, sizeof(cap->bus_info));
1872
1873 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1874 cap->device_caps = V4L2_CAP_READWRITE |
1875 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1876 else if (vdev->vfl_type == VFL_TYPE_RADIO)
1877 cap->device_caps = V4L2_CAP_RADIO;
1878 else
1879 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1880
1881 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
1882 cap->device_caps |= V4L2_CAP_AUDIO;
1883
1884 if (dev->tuner_type != TUNER_ABSENT)
1885 cap->device_caps |= V4L2_CAP_TUNER;
1886
1887 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1888 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1889 if (video_is_registered(&v4l2->vbi_dev))
1890 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1891 if (video_is_registered(&v4l2->radio_dev))
1892 cap->capabilities |= V4L2_CAP_RADIO;
1893 return 0;
1894}
1895
1896static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1897 struct v4l2_fmtdesc *f)
1898{
1899 if (unlikely(f->index >= ARRAY_SIZE(format)))
1900 return -EINVAL;
1901
1902 strlcpy(f->description, format[f->index].name, sizeof(f->description));
1903 f->pixelformat = format[f->index].fourcc;
1904
1905 return 0;
1906}
1907
1908static int vidioc_enum_framesizes(struct file *file, void *priv,
1909 struct v4l2_frmsizeenum *fsize)
1910{
1911 struct em28xx *dev = video_drvdata(file);
1912 struct em28xx_fmt *fmt;
1913 unsigned int maxw = norm_maxw(dev);
1914 unsigned int maxh = norm_maxh(dev);
1915
1916 fmt = format_by_fourcc(fsize->pixel_format);
1917 if (!fmt) {
1918 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1919 fsize->pixel_format);
1920 return -EINVAL;
1921 }
1922
1923 if (dev->board.is_em2800) {
1924 if (fsize->index > 1)
1925 return -EINVAL;
1926 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1927 fsize->discrete.width = maxw / (1 + fsize->index);
1928 fsize->discrete.height = maxh / (1 + fsize->index);
1929 return 0;
1930 }
1931
1932 if (fsize->index != 0)
1933 return -EINVAL;
1934
1935
1936 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1937 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1938 &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1939 if (fsize->stepwise.min_width < 48)
1940 fsize->stepwise.min_width = 48;
1941 if (fsize->stepwise.min_height < 38)
1942 fsize->stepwise.min_height = 38;
1943 fsize->stepwise.max_width = maxw;
1944 fsize->stepwise.max_height = maxh;
1945 fsize->stepwise.step_width = 1;
1946 fsize->stepwise.step_height = 1;
1947 return 0;
1948}
1949
1950
1951
1952static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1953 struct v4l2_format *format)
1954{
1955 struct em28xx *dev = video_drvdata(file);
1956 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1957
1958 format->fmt.vbi.samples_per_line = v4l2->vbi_width;
1959 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1960 format->fmt.vbi.offset = 0;
1961 format->fmt.vbi.flags = 0;
1962 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1963 format->fmt.vbi.count[0] = v4l2->vbi_height;
1964 format->fmt.vbi.count[1] = v4l2->vbi_height;
1965 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1966
1967
1968 if (v4l2->norm & V4L2_STD_525_60) {
1969
1970 format->fmt.vbi.start[0] = 10;
1971 format->fmt.vbi.start[1] = 273;
1972 } else if (v4l2->norm & V4L2_STD_625_50) {
1973
1974 format->fmt.vbi.start[0] = 6;
1975 format->fmt.vbi.start[1] = 318;
1976 }
1977
1978 return 0;
1979}
1980
1981
1982
1983
1984
1985static int radio_g_tuner(struct file *file, void *priv,
1986 struct v4l2_tuner *t)
1987{
1988 struct em28xx *dev = video_drvdata(file);
1989
1990 if (unlikely(t->index > 0))
1991 return -EINVAL;
1992
1993 strcpy(t->name, "Radio");
1994
1995 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1996
1997 return 0;
1998}
1999
2000static int radio_s_tuner(struct file *file, void *priv,
2001 const struct v4l2_tuner *t)
2002{
2003 struct em28xx *dev = video_drvdata(file);
2004
2005 if (0 != t->index)
2006 return -EINVAL;
2007
2008 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
2009
2010 return 0;
2011}
2012
2013
2014
2015
2016
2017
2018
2019
2020static void em28xx_free_v4l2(struct kref *ref)
2021{
2022 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
2023
2024 v4l2->dev->v4l2 = NULL;
2025 kfree(v4l2);
2026}
2027
2028
2029
2030
2031
2032static int em28xx_v4l2_open(struct file *filp)
2033{
2034 struct video_device *vdev = video_devdata(filp);
2035 struct em28xx *dev = video_drvdata(filp);
2036 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2037 enum v4l2_buf_type fh_type = 0;
2038 int ret;
2039
2040 switch (vdev->vfl_type) {
2041 case VFL_TYPE_GRABBER:
2042 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2043 break;
2044 case VFL_TYPE_VBI:
2045 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
2046 break;
2047 case VFL_TYPE_RADIO:
2048 break;
2049 default:
2050 return -EINVAL;
2051 }
2052
2053 em28xx_videodbg("open dev=%s type=%s users=%d\n",
2054 video_device_node_name(vdev), v4l2_type_names[fh_type],
2055 v4l2->users);
2056
2057 if (mutex_lock_interruptible(&dev->lock))
2058 return -ERESTARTSYS;
2059
2060 ret = v4l2_fh_open(filp);
2061 if (ret) {
2062 dev_err(&dev->intf->dev,
2063 "%s: v4l2_fh_open() returned error %d\n",
2064 __func__, ret);
2065 mutex_unlock(&dev->lock);
2066 return ret;
2067 }
2068
2069 if (v4l2->users == 0) {
2070 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2071
2072 if (vdev->vfl_type != VFL_TYPE_RADIO)
2073 em28xx_resolution_set(dev);
2074
2075
2076
2077
2078
2079 em28xx_wake_i2c(dev);
2080 }
2081
2082 if (vdev->vfl_type == VFL_TYPE_RADIO) {
2083 em28xx_videodbg("video_open: setting radio device\n");
2084 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
2085 }
2086
2087 kref_get(&dev->ref);
2088 kref_get(&v4l2->ref);
2089 v4l2->users++;
2090
2091 mutex_unlock(&dev->lock);
2092
2093 return 0;
2094}
2095
2096
2097
2098
2099
2100
2101static int em28xx_v4l2_fini(struct em28xx *dev)
2102{
2103 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2104
2105 if (dev->is_audio_only) {
2106
2107 return 0;
2108 }
2109
2110 if (!dev->has_video) {
2111
2112 return 0;
2113 }
2114
2115 if (v4l2 == NULL)
2116 return 0;
2117
2118 dev_info(&dev->intf->dev, "Closing video extension\n");
2119
2120 mutex_lock(&dev->lock);
2121
2122 v4l2_device_disconnect(&v4l2->v4l2_dev);
2123
2124 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
2125
2126 em28xx_v4l2_media_release(dev);
2127
2128 if (video_is_registered(&v4l2->radio_dev)) {
2129 dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2130 video_device_node_name(&v4l2->radio_dev));
2131 video_unregister_device(&v4l2->radio_dev);
2132 }
2133 if (video_is_registered(&v4l2->vbi_dev)) {
2134 dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2135 video_device_node_name(&v4l2->vbi_dev));
2136 video_unregister_device(&v4l2->vbi_dev);
2137 }
2138 if (video_is_registered(&v4l2->vdev)) {
2139 dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2140 video_device_node_name(&v4l2->vdev));
2141 video_unregister_device(&v4l2->vdev);
2142 }
2143
2144 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2145 v4l2_device_unregister(&v4l2->v4l2_dev);
2146
2147 kref_put(&v4l2->ref, em28xx_free_v4l2);
2148
2149 mutex_unlock(&dev->lock);
2150
2151 kref_put(&dev->ref, em28xx_free_device);
2152
2153 return 0;
2154}
2155
2156static int em28xx_v4l2_suspend(struct em28xx *dev)
2157{
2158 if (dev->is_audio_only)
2159 return 0;
2160
2161 if (!dev->has_video)
2162 return 0;
2163
2164 dev_info(&dev->intf->dev, "Suspending video extension\n");
2165 em28xx_stop_urbs(dev);
2166 return 0;
2167}
2168
2169static int em28xx_v4l2_resume(struct em28xx *dev)
2170{
2171 if (dev->is_audio_only)
2172 return 0;
2173
2174 if (!dev->has_video)
2175 return 0;
2176
2177 dev_info(&dev->intf->dev, "Resuming video extension\n");
2178
2179 return 0;
2180}
2181
2182
2183
2184
2185
2186
2187static int em28xx_v4l2_close(struct file *filp)
2188{
2189 struct em28xx *dev = video_drvdata(filp);
2190 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2191 struct usb_device *udev = interface_to_usbdev(dev->intf);
2192 int errCode;
2193
2194 em28xx_videodbg("users=%d\n", v4l2->users);
2195
2196 vb2_fop_release(filp);
2197 mutex_lock(&dev->lock);
2198
2199 if (v4l2->users == 1) {
2200
2201 if (dev->disconnected)
2202 goto exit;
2203
2204
2205 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2206
2207
2208 em28xx_set_mode(dev, EM28XX_SUSPEND);
2209
2210
2211 dev->alt = 0;
2212 em28xx_videodbg("setting alternate 0\n");
2213 errCode = usb_set_interface(udev, 0, 0);
2214 if (errCode < 0) {
2215 dev_err(&dev->intf->dev,
2216 "cannot change alternate number to 0 (error=%i)\n",
2217 errCode);
2218 }
2219 }
2220
2221exit:
2222 v4l2->users--;
2223 kref_put(&v4l2->ref, em28xx_free_v4l2);
2224 mutex_unlock(&dev->lock);
2225 kref_put(&dev->ref, em28xx_free_device);
2226
2227 return 0;
2228}
2229
2230static const struct v4l2_file_operations em28xx_v4l_fops = {
2231 .owner = THIS_MODULE,
2232 .open = em28xx_v4l2_open,
2233 .release = em28xx_v4l2_close,
2234 .read = vb2_fop_read,
2235 .poll = vb2_fop_poll,
2236 .mmap = vb2_fop_mmap,
2237 .unlocked_ioctl = video_ioctl2,
2238};
2239
2240static const struct v4l2_ioctl_ops video_ioctl_ops = {
2241 .vidioc_querycap = vidioc_querycap,
2242 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2243 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2244 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2245 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
2246 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2247 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2248 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2249 .vidioc_enum_framesizes = vidioc_enum_framesizes,
2250 .vidioc_g_audio = vidioc_g_audio,
2251 .vidioc_s_audio = vidioc_s_audio,
2252
2253 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2254 .vidioc_create_bufs = vb2_ioctl_create_bufs,
2255 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
2256 .vidioc_querybuf = vb2_ioctl_querybuf,
2257 .vidioc_qbuf = vb2_ioctl_qbuf,
2258 .vidioc_dqbuf = vb2_ioctl_dqbuf,
2259
2260 .vidioc_g_std = vidioc_g_std,
2261 .vidioc_querystd = vidioc_querystd,
2262 .vidioc_s_std = vidioc_s_std,
2263 .vidioc_g_parm = vidioc_g_parm,
2264 .vidioc_s_parm = vidioc_s_parm,
2265 .vidioc_enum_input = vidioc_enum_input,
2266 .vidioc_g_input = vidioc_g_input,
2267 .vidioc_s_input = vidioc_s_input,
2268 .vidioc_streamon = vb2_ioctl_streamon,
2269 .vidioc_streamoff = vb2_ioctl_streamoff,
2270 .vidioc_g_tuner = vidioc_g_tuner,
2271 .vidioc_s_tuner = vidioc_s_tuner,
2272 .vidioc_g_frequency = vidioc_g_frequency,
2273 .vidioc_s_frequency = vidioc_s_frequency,
2274 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2275 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2276#ifdef CONFIG_VIDEO_ADV_DEBUG
2277 .vidioc_g_chip_info = vidioc_g_chip_info,
2278 .vidioc_g_register = vidioc_g_register,
2279 .vidioc_s_register = vidioc_s_register,
2280#endif
2281};
2282
2283static const struct video_device em28xx_video_template = {
2284 .fops = &em28xx_v4l_fops,
2285 .ioctl_ops = &video_ioctl_ops,
2286 .release = video_device_release_empty,
2287 .tvnorms = V4L2_STD_ALL,
2288};
2289
2290static const struct v4l2_file_operations radio_fops = {
2291 .owner = THIS_MODULE,
2292 .open = em28xx_v4l2_open,
2293 .release = em28xx_v4l2_close,
2294 .unlocked_ioctl = video_ioctl2,
2295};
2296
2297static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2298 .vidioc_querycap = vidioc_querycap,
2299 .vidioc_g_tuner = radio_g_tuner,
2300 .vidioc_s_tuner = radio_s_tuner,
2301 .vidioc_g_frequency = vidioc_g_frequency,
2302 .vidioc_s_frequency = vidioc_s_frequency,
2303 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2304 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2305#ifdef CONFIG_VIDEO_ADV_DEBUG
2306 .vidioc_g_chip_info = vidioc_g_chip_info,
2307 .vidioc_g_register = vidioc_g_register,
2308 .vidioc_s_register = vidioc_s_register,
2309#endif
2310};
2311
2312static struct video_device em28xx_radio_template = {
2313 .fops = &radio_fops,
2314 .ioctl_ops = &radio_ioctl_ops,
2315 .release = video_device_release_empty,
2316};
2317
2318
2319static unsigned short saa711x_addrs[] = {
2320 0x4a >> 1, 0x48 >> 1,
2321 0x42 >> 1, 0x40 >> 1,
2322 I2C_CLIENT_END };
2323
2324static unsigned short tvp5150_addrs[] = {
2325 0xb8 >> 1,
2326 0xba >> 1,
2327 I2C_CLIENT_END
2328};
2329
2330static unsigned short msp3400_addrs[] = {
2331 0x80 >> 1,
2332 0x88 >> 1,
2333 I2C_CLIENT_END
2334};
2335
2336
2337
2338static void em28xx_vdev_init(struct em28xx *dev,
2339 struct video_device *vfd,
2340 const struct video_device *template,
2341 const char *type_name)
2342{
2343 *vfd = *template;
2344 vfd->v4l2_dev = &dev->v4l2->v4l2_dev;
2345 vfd->lock = &dev->lock;
2346 if (dev->board.is_webcam)
2347 vfd->tvnorms = 0;
2348
2349 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2350 dev_name(&dev->intf->dev), type_name);
2351
2352 video_set_drvdata(vfd, dev);
2353}
2354
2355static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
2356{
2357 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2358 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev;
2359 struct tuner_setup tun_setup;
2360 struct v4l2_frequency f;
2361
2362 memset(&tun_setup, 0, sizeof(tun_setup));
2363
2364 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2365 tun_setup.tuner_callback = em28xx_tuner_callback;
2366
2367 if (dev->board.radio.type) {
2368 tun_setup.type = dev->board.radio.type;
2369 tun_setup.addr = dev->board.radio_addr;
2370
2371 v4l2_device_call_all(v4l2_dev,
2372 0, tuner, s_type_addr, &tun_setup);
2373 }
2374
2375 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2376 tun_setup.type = dev->tuner_type;
2377 tun_setup.addr = tuner_addr;
2378
2379 v4l2_device_call_all(v4l2_dev,
2380 0, tuner, s_type_addr, &tun_setup);
2381 }
2382
2383 if (dev->board.tda9887_conf) {
2384 struct v4l2_priv_tun_config tda9887_cfg;
2385
2386 tda9887_cfg.tuner = TUNER_TDA9887;
2387 tda9887_cfg.priv = &dev->board.tda9887_conf;
2388
2389 v4l2_device_call_all(v4l2_dev,
2390 0, tuner, s_config, &tda9887_cfg);
2391 }
2392
2393 if (dev->tuner_type == TUNER_XC2028) {
2394 struct v4l2_priv_tun_config xc2028_cfg;
2395 struct xc2028_ctrl ctl;
2396
2397 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2398 memset(&ctl, 0, sizeof(ctl));
2399
2400 em28xx_setup_xc3028(dev, &ctl);
2401
2402 xc2028_cfg.tuner = TUNER_XC2028;
2403 xc2028_cfg.priv = &ctl;
2404
2405 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2406 }
2407
2408
2409 f.tuner = 0;
2410 f.type = V4L2_TUNER_ANALOG_TV;
2411 f.frequency = 9076;
2412 v4l2->frequency = f.frequency;
2413 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
2414}
2415
2416static int em28xx_v4l2_init(struct em28xx *dev)
2417{
2418 u8 val;
2419 int ret;
2420 unsigned int maxw;
2421 struct v4l2_ctrl_handler *hdl;
2422 struct em28xx_v4l2 *v4l2;
2423
2424 if (dev->is_audio_only) {
2425
2426 return 0;
2427 }
2428
2429 if (!dev->has_video) {
2430
2431 return 0;
2432 }
2433
2434 dev_info(&dev->intf->dev, "Registering V4L2 extension\n");
2435
2436 mutex_lock(&dev->lock);
2437
2438 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2439 if (!v4l2) {
2440 mutex_unlock(&dev->lock);
2441 return -ENOMEM;
2442 }
2443 kref_init(&v4l2->ref);
2444 v4l2->dev = dev;
2445 dev->v4l2 = v4l2;
2446
2447#ifdef CONFIG_MEDIA_CONTROLLER
2448 v4l2->v4l2_dev.mdev = dev->media_dev;
2449#endif
2450 ret = v4l2_device_register(&dev->intf->dev, &v4l2->v4l2_dev);
2451 if (ret < 0) {
2452 dev_err(&dev->intf->dev,
2453 "Call to v4l2_device_register() failed!\n");
2454 goto err;
2455 }
2456
2457 hdl = &v4l2->ctrl_handler;
2458 v4l2_ctrl_handler_init(hdl, 8);
2459 v4l2->v4l2_dev.ctrl_handler = hdl;
2460
2461 if (dev->board.is_webcam)
2462 v4l2->progressive = true;
2463
2464
2465
2466
2467 v4l2->vinmode = EM28XX_VINMODE_YUV422_CbYCrY;
2468 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED |
2469 EM28XX_VINCTRL_CCIR656_ENABLE;
2470
2471
2472
2473 if (dev->board.has_msp34xx)
2474 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2475 &dev->i2c_adap[dev->def_i2c_bus],
2476 "msp3400", 0, msp3400_addrs);
2477
2478 if (dev->board.decoder == EM28XX_SAA711X)
2479 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2480 &dev->i2c_adap[dev->def_i2c_bus],
2481 "saa7115_auto", 0, saa711x_addrs);
2482
2483 if (dev->board.decoder == EM28XX_TVP5150)
2484 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2485 &dev->i2c_adap[dev->def_i2c_bus],
2486 "tvp5150", 0, tvp5150_addrs);
2487
2488 if (dev->board.adecoder == EM28XX_TVAUDIO)
2489 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2490 &dev->i2c_adap[dev->def_i2c_bus],
2491 "tvaudio", dev->board.tvaudio_addr, NULL);
2492
2493
2494
2495 if (dev->board.tuner_type != TUNER_ABSENT) {
2496 unsigned short tuner_addr = dev->board.tuner_addr;
2497 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
2498
2499 if (dev->board.radio.type)
2500 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2501 &dev->i2c_adap[dev->def_i2c_bus],
2502 "tuner", dev->board.radio_addr,
2503 NULL);
2504
2505 if (has_demod)
2506 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2507 &dev->i2c_adap[dev->def_i2c_bus],
2508 "tuner", 0,
2509 v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2510 if (tuner_addr == 0) {
2511 enum v4l2_i2c_tuner_type type =
2512 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2513 struct v4l2_subdev *sd;
2514
2515 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2516 &dev->i2c_adap[dev->def_i2c_bus],
2517 "tuner", 0,
2518 v4l2_i2c_tuner_addrs(type));
2519
2520 if (sd)
2521 tuner_addr = v4l2_i2c_subdev_addr(sd);
2522 } else {
2523 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2524 &dev->i2c_adap[dev->def_i2c_bus],
2525 "tuner", tuner_addr, NULL);
2526 }
2527
2528 em28xx_tuner_setup(dev, tuner_addr);
2529 }
2530
2531 if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2532 em28xx_init_camera(dev);
2533
2534
2535 ret = em28xx_audio_setup(dev);
2536 if (ret < 0) {
2537 dev_err(&dev->intf->dev,
2538 "%s: Error while setting audio - error [%d]!\n",
2539 __func__, ret);
2540 goto unregister_dev;
2541 }
2542 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2543 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2544 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2545 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2546 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
2547 } else {
2548
2549 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
2550 em28xx_ctrl_notify, dev);
2551 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
2552 em28xx_ctrl_notify, dev);
2553 }
2554
2555
2556 em28xx_wake_i2c(dev);
2557
2558
2559 INIT_LIST_HEAD(&dev->vidq.active);
2560 INIT_LIST_HEAD(&dev->vbiq.active);
2561
2562 if (dev->board.has_msp34xx) {
2563
2564 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2565 if (ret < 0) {
2566 dev_err(&dev->intf->dev,
2567 "%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2568 __func__, ret);
2569 goto unregister_dev;
2570 }
2571 msleep(3);
2572
2573 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2574 if (ret < 0) {
2575 dev_err(&dev->intf->dev,
2576 "%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2577 __func__, ret);
2578 goto unregister_dev;
2579 }
2580 msleep(3);
2581 }
2582
2583
2584 v4l2->norm = V4L2_STD_PAL;
2585 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
2586 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
2587
2588
2589 v4l2->format = &format[0];
2590
2591 maxw = norm_maxw(dev);
2592
2593
2594 if (dev->board.is_em2800)
2595 maxw /= 2;
2596
2597 em28xx_set_video_format(dev, format[0].fourcc,
2598 maxw, norm_maxh(dev));
2599
2600 video_mux(dev, 0);
2601
2602
2603 dev->mute = 1;
2604 dev->volume = 0x1f;
2605
2606
2607 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2608 em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2609 (EM28XX_XCLK_AUDIO_UNMUTE | val));
2610
2611 em28xx_set_outfmt(dev);
2612
2613
2614
2615
2616 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2617 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2618 V4L2_CID_CONTRAST,
2619 0, 0x1f, 1, CONTRAST_DEFAULT);
2620 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2621 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2622 V4L2_CID_BRIGHTNESS,
2623 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
2624 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2625 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2626 V4L2_CID_SATURATION,
2627 0, 0x1f, 1, SATURATION_DEFAULT);
2628 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2629 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2630 V4L2_CID_BLUE_BALANCE,
2631 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
2632 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2633 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2634 V4L2_CID_RED_BALANCE,
2635 -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
2636 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2637 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2638 V4L2_CID_SHARPNESS,
2639 0, 0x0f, 1, SHARPNESS_DEFAULT);
2640
2641
2642 em28xx_colorlevels_set_default(dev);
2643 v4l2_ctrl_handler_setup(hdl);
2644 ret = hdl->error;
2645 if (ret)
2646 goto unregister_dev;
2647
2648
2649 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
2650 mutex_init(&v4l2->vb_queue_lock);
2651 mutex_init(&v4l2->vb_vbi_queue_lock);
2652 v4l2->vdev.queue = &v4l2->vb_vidq;
2653 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
2654
2655
2656 if (dev->board.is_webcam) {
2657 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2658 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2659 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
2660 } else {
2661 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
2662 }
2663 if (dev->tuner_type == TUNER_ABSENT) {
2664 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2665 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2666 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2667 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
2668 }
2669 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2670 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2671 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
2672 }
2673
2674
2675 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
2676 video_nr[dev->devno]);
2677 if (ret) {
2678 dev_err(&dev->intf->dev,
2679 "unable to register video device (error=%i).\n", ret);
2680 goto unregister_dev;
2681 }
2682
2683
2684 if (em28xx_vbi_supported(dev) == 1) {
2685 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2686 "vbi");
2687
2688 v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2689 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
2690
2691
2692 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
2693 if (dev->tuner_type == TUNER_ABSENT) {
2694 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2695 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2696 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2697 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
2698 }
2699 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2700 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2701 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
2702 }
2703
2704
2705 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
2706 vbi_nr[dev->devno]);
2707 if (ret < 0) {
2708 dev_err(&dev->intf->dev,
2709 "unable to register vbi device\n");
2710 goto unregister_dev;
2711 }
2712 }
2713
2714 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2715 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2716 "radio");
2717 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
2718 radio_nr[dev->devno]);
2719 if (ret < 0) {
2720 dev_err(&dev->intf->dev,
2721 "can't register radio device\n");
2722 goto unregister_dev;
2723 }
2724 dev_info(&dev->intf->dev,
2725 "Registered radio device as %s\n",
2726 video_device_node_name(&v4l2->radio_dev));
2727 }
2728
2729
2730 em28xx_v4l2_create_entities(dev);
2731
2732#ifdef CONFIG_MEDIA_CONTROLLER
2733 ret = v4l2_mc_create_media_graph(dev->media_dev);
2734 if (ret) {
2735 dev_err(&dev->intf->dev,
2736 "failed to create media graph\n");
2737 em28xx_v4l2_media_release(dev);
2738 goto unregister_dev;
2739 }
2740#endif
2741
2742 dev_info(&dev->intf->dev,
2743 "V4L2 video device registered as %s\n",
2744 video_device_node_name(&v4l2->vdev));
2745
2746 if (video_is_registered(&v4l2->vbi_dev))
2747 dev_info(&dev->intf->dev,
2748 "V4L2 VBI device registered as %s\n",
2749 video_device_node_name(&v4l2->vbi_dev));
2750
2751
2752 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2753
2754
2755 em28xx_vb2_setup(dev);
2756
2757 dev_info(&dev->intf->dev,
2758 "V4L2 extension successfully initialized\n");
2759
2760 kref_get(&dev->ref);
2761
2762 mutex_unlock(&dev->lock);
2763 return 0;
2764
2765unregister_dev:
2766 if (video_is_registered(&v4l2->radio_dev)) {
2767 dev_info(&dev->intf->dev,
2768 "V4L2 device %s deregistered\n",
2769 video_device_node_name(&v4l2->radio_dev));
2770 video_unregister_device(&v4l2->radio_dev);
2771 }
2772 if (video_is_registered(&v4l2->vbi_dev)) {
2773 dev_info(&dev->intf->dev,
2774 "V4L2 device %s deregistered\n",
2775 video_device_node_name(&v4l2->vbi_dev));
2776 video_unregister_device(&v4l2->vbi_dev);
2777 }
2778 if (video_is_registered(&v4l2->vdev)) {
2779 dev_info(&dev->intf->dev,
2780 "V4L2 device %s deregistered\n",
2781 video_device_node_name(&v4l2->vdev));
2782 video_unregister_device(&v4l2->vdev);
2783 }
2784
2785 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2786 v4l2_device_unregister(&v4l2->v4l2_dev);
2787err:
2788 dev->v4l2 = NULL;
2789 kref_put(&v4l2->ref, em28xx_free_v4l2);
2790 mutex_unlock(&dev->lock);
2791 return ret;
2792}
2793
2794static struct em28xx_ops v4l2_ops = {
2795 .id = EM28XX_V4L2,
2796 .name = "Em28xx v4l2 Extension",
2797 .init = em28xx_v4l2_init,
2798 .fini = em28xx_v4l2_fini,
2799 .suspend = em28xx_v4l2_suspend,
2800 .resume = em28xx_v4l2_resume,
2801};
2802
2803static int __init em28xx_video_register(void)
2804{
2805 return em28xx_register_extension(&v4l2_ops);
2806}
2807
2808static void __exit em28xx_video_unregister(void)
2809{
2810 em28xx_unregister_extension(&v4l2_ops);
2811}
2812
2813module_init(em28xx_video_register);
2814module_exit(em28xx_video_unregister);
2815