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