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.v4l2_buf.sequence = dev->v4l2->field_count++;
437 if (dev->v4l2->progressive)
438 buf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
439 else
440 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
441 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
442
443 vb2_buffer_done(&buf->vb, 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 return 0;
843 }
844 }
845
846 /* Usage lock check functions */
res_get(struct em28xx * dev,enum v4l2_buf_type f_type)847 static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
848 {
849 int res_type = get_ressource(f_type);
850
851 /* is it free? */
852 if (dev->resources & res_type) {
853 /* no, someone else uses it */
854 return -EBUSY;
855 }
856
857 /* it's free, grab it */
858 dev->resources |= res_type;
859 em28xx_videodbg("res: get %d\n", res_type);
860 return 0;
861 }
862
res_free(struct em28xx * dev,enum v4l2_buf_type f_type)863 static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
864 {
865 int res_type = get_ressource(f_type);
866
867 dev->resources &= ~res_type;
868 em28xx_videodbg("res: put %d\n", res_type);
869 }
870
871 /* ------------------------------------------------------------------
872 Videobuf2 operations
873 ------------------------------------------------------------------*/
874
queue_setup(struct vb2_queue * vq,const struct v4l2_format * fmt,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],void * alloc_ctxs[])875 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
876 unsigned int *nbuffers, unsigned int *nplanes,
877 unsigned int sizes[], void *alloc_ctxs[])
878 {
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 em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
905 struct em28xx_v4l2 *v4l2 = dev->v4l2;
906 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
907 unsigned long size;
908
909 em28xx_videodbg("%s, field=%d\n", __func__, vb->v4l2_buf.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(&buf->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 int rc = 0;
929
930 em28xx_videodbg("%s\n", __func__);
931
932 /* Make sure streaming is not already in progress for this type
933 of filehandle (e.g. video, vbi) */
934 rc = res_get(dev, vq->type);
935 if (rc)
936 return rc;
937
938 if (v4l2->streaming_users == 0) {
939 /* First active streaming user, so allocate all the URBs */
940
941 /* Allocate the USB bandwidth */
942 em28xx_set_alternate(dev);
943
944 /* Needed, since GPIO might have disabled power of
945 some i2c device
946 */
947 em28xx_wake_i2c(dev);
948
949 v4l2->capture_type = -1;
950 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
951 dev->analog_xfer_bulk,
952 EM28XX_NUM_BUFS,
953 dev->max_pkt_size,
954 dev->packet_multiplier,
955 em28xx_urb_data_copy);
956 if (rc < 0)
957 return rc;
958
959 /*
960 * djh: it's not clear whether this code is still needed. I'm
961 * leaving it in here for now entirely out of concern for
962 * backward compatibility (the old code did it)
963 */
964
965 /* Ask tuner to go to analog or radio mode */
966 memset(&f, 0, sizeof(f));
967 f.frequency = v4l2->frequency;
968 if (vq->owner && vq->owner->vdev->vfl_type == VFL_TYPE_RADIO)
969 f.type = V4L2_TUNER_RADIO;
970 else
971 f.type = V4L2_TUNER_ANALOG_TV;
972 v4l2_device_call_all(&v4l2->v4l2_dev,
973 0, tuner, s_frequency, &f);
974 }
975
976 v4l2->streaming_users++;
977
978 return rc;
979 }
980
em28xx_stop_streaming(struct vb2_queue * vq)981 static void em28xx_stop_streaming(struct vb2_queue *vq)
982 {
983 struct em28xx *dev = vb2_get_drv_priv(vq);
984 struct em28xx_v4l2 *v4l2 = dev->v4l2;
985 struct em28xx_dmaqueue *vidq = &dev->vidq;
986 unsigned long flags = 0;
987
988 em28xx_videodbg("%s\n", __func__);
989
990 res_free(dev, vq->type);
991
992 if (v4l2->streaming_users-- == 1) {
993 /* Last active user, so shutdown all the URBS */
994 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
995 }
996
997 spin_lock_irqsave(&dev->slock, flags);
998 if (dev->usb_ctl.vid_buf != NULL) {
999 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb, VB2_BUF_STATE_ERROR);
1000 dev->usb_ctl.vid_buf = NULL;
1001 }
1002 while (!list_empty(&vidq->active)) {
1003 struct em28xx_buffer *buf;
1004
1005 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
1006 list_del(&buf->list);
1007 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1008 }
1009 spin_unlock_irqrestore(&dev->slock, flags);
1010 }
1011
em28xx_stop_vbi_streaming(struct vb2_queue * vq)1012 void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
1013 {
1014 struct em28xx *dev = vb2_get_drv_priv(vq);
1015 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1016 struct em28xx_dmaqueue *vbiq = &dev->vbiq;
1017 unsigned long flags = 0;
1018
1019 em28xx_videodbg("%s\n", __func__);
1020
1021 res_free(dev, vq->type);
1022
1023 if (v4l2->streaming_users-- == 1) {
1024 /* Last active user, so shutdown all the URBS */
1025 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1026 }
1027
1028 spin_lock_irqsave(&dev->slock, flags);
1029 if (dev->usb_ctl.vbi_buf != NULL) {
1030 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb, VB2_BUF_STATE_ERROR);
1031 dev->usb_ctl.vbi_buf = NULL;
1032 }
1033 while (!list_empty(&vbiq->active)) {
1034 struct em28xx_buffer *buf;
1035
1036 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
1037 list_del(&buf->list);
1038 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1039 }
1040 spin_unlock_irqrestore(&dev->slock, flags);
1041 }
1042
1043 static void
buffer_queue(struct vb2_buffer * vb)1044 buffer_queue(struct vb2_buffer *vb)
1045 {
1046 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1047 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
1048 struct em28xx_dmaqueue *vidq = &dev->vidq;
1049 unsigned long flags = 0;
1050
1051 em28xx_videodbg("%s\n", __func__);
1052 buf->mem = vb2_plane_vaddr(vb, 0);
1053 buf->length = vb2_plane_size(vb, 0);
1054
1055 spin_lock_irqsave(&dev->slock, flags);
1056 list_add_tail(&buf->list, &vidq->active);
1057 spin_unlock_irqrestore(&dev->slock, flags);
1058 }
1059
1060 static struct vb2_ops em28xx_video_qops = {
1061 .queue_setup = queue_setup,
1062 .buf_prepare = buffer_prepare,
1063 .buf_queue = buffer_queue,
1064 .start_streaming = em28xx_start_analog_streaming,
1065 .stop_streaming = em28xx_stop_streaming,
1066 .wait_prepare = vb2_ops_wait_prepare,
1067 .wait_finish = vb2_ops_wait_finish,
1068 };
1069
em28xx_vb2_setup(struct em28xx * dev)1070 static int em28xx_vb2_setup(struct em28xx *dev)
1071 {
1072 int rc;
1073 struct vb2_queue *q;
1074 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1075
1076 /* Setup Videobuf2 for Video capture */
1077 q = &v4l2->vb_vidq;
1078 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1079 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1080 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1081 q->drv_priv = dev;
1082 q->buf_struct_size = sizeof(struct em28xx_buffer);
1083 q->ops = &em28xx_video_qops;
1084 q->mem_ops = &vb2_vmalloc_memops;
1085
1086 rc = vb2_queue_init(q);
1087 if (rc < 0)
1088 return rc;
1089
1090 /* Setup Videobuf2 for VBI capture */
1091 q = &v4l2->vb_vbiq;
1092 q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1093 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
1094 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1095 q->drv_priv = dev;
1096 q->buf_struct_size = sizeof(struct em28xx_buffer);
1097 q->ops = &em28xx_vbi_qops;
1098 q->mem_ops = &vb2_vmalloc_memops;
1099
1100 rc = vb2_queue_init(q);
1101 if (rc < 0)
1102 return rc;
1103
1104 return 0;
1105 }
1106
1107 /********************* v4l2 interface **************************************/
1108
video_mux(struct em28xx * dev,int index)1109 static void video_mux(struct em28xx *dev, int index)
1110 {
1111 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
1112
1113 dev->ctl_input = index;
1114 dev->ctl_ainput = INPUT(index)->amux;
1115 dev->ctl_aoutput = INPUT(index)->aout;
1116
1117 if (!dev->ctl_aoutput)
1118 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1119
1120 v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
1121 INPUT(index)->vmux, 0, 0);
1122
1123 if (dev->board.has_msp34xx) {
1124 if (dev->i2s_speed) {
1125 v4l2_device_call_all(v4l2_dev, 0, audio,
1126 s_i2s_clock_freq, dev->i2s_speed);
1127 }
1128 /* Note: this is msp3400 specific */
1129 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1130 dev->ctl_ainput,
1131 MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
1132 }
1133
1134 if (dev->board.adecoder != EM28XX_NOADECODER) {
1135 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1136 dev->ctl_ainput, dev->ctl_aoutput, 0);
1137 }
1138
1139 em28xx_audio_analog_set(dev);
1140 }
1141
em28xx_ctrl_notify(struct v4l2_ctrl * ctrl,void * priv)1142 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
1143 {
1144 struct em28xx *dev = priv;
1145
1146 /*
1147 * In the case of non-AC97 volume controls, we still need
1148 * to do some setups at em28xx, in order to mute/unmute
1149 * and to adjust audio volume. However, the value ranges
1150 * should be checked by the corresponding V4L subdriver.
1151 */
1152 switch (ctrl->id) {
1153 case V4L2_CID_AUDIO_MUTE:
1154 dev->mute = ctrl->val;
1155 em28xx_audio_analog_set(dev);
1156 break;
1157 case V4L2_CID_AUDIO_VOLUME:
1158 dev->volume = ctrl->val;
1159 em28xx_audio_analog_set(dev);
1160 break;
1161 }
1162 }
1163
em28xx_s_ctrl(struct v4l2_ctrl * ctrl)1164 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
1165 {
1166 struct em28xx_v4l2 *v4l2 =
1167 container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler);
1168 struct em28xx *dev = v4l2->dev;
1169 int ret = -EINVAL;
1170
1171 switch (ctrl->id) {
1172 case V4L2_CID_AUDIO_MUTE:
1173 dev->mute = ctrl->val;
1174 ret = em28xx_audio_analog_set(dev);
1175 break;
1176 case V4L2_CID_AUDIO_VOLUME:
1177 dev->volume = ctrl->val;
1178 ret = em28xx_audio_analog_set(dev);
1179 break;
1180 case V4L2_CID_CONTRAST:
1181 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1182 break;
1183 case V4L2_CID_BRIGHTNESS:
1184 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1185 break;
1186 case V4L2_CID_SATURATION:
1187 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1188 break;
1189 case V4L2_CID_BLUE_BALANCE:
1190 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1191 break;
1192 case V4L2_CID_RED_BALANCE:
1193 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1194 break;
1195 case V4L2_CID_SHARPNESS:
1196 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
1197 break;
1198 }
1199
1200 return (ret < 0) ? ret : 0;
1201 }
1202
1203 static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
1204 .s_ctrl = em28xx_s_ctrl,
1205 };
1206
size_to_scale(struct em28xx * dev,unsigned int width,unsigned int height,unsigned int * hscale,unsigned int * vscale)1207 static void size_to_scale(struct em28xx *dev,
1208 unsigned int width, unsigned int height,
1209 unsigned int *hscale, unsigned int *vscale)
1210 {
1211 unsigned int maxw = norm_maxw(dev);
1212 unsigned int maxh = norm_maxh(dev);
1213
1214 *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1215 if (*hscale > EM28XX_HVSCALE_MAX)
1216 *hscale = EM28XX_HVSCALE_MAX;
1217
1218 *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1219 if (*vscale > EM28XX_HVSCALE_MAX)
1220 *vscale = EM28XX_HVSCALE_MAX;
1221 }
1222
scale_to_size(struct em28xx * dev,unsigned int hscale,unsigned int vscale,unsigned int * width,unsigned int * height)1223 static void scale_to_size(struct em28xx *dev,
1224 unsigned int hscale, unsigned int vscale,
1225 unsigned int *width, unsigned int *height)
1226 {
1227 unsigned int maxw = norm_maxw(dev);
1228 unsigned int maxh = norm_maxh(dev);
1229
1230 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1231 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1232 }
1233
1234 /* ------------------------------------------------------------------
1235 IOCTL vidioc handling
1236 ------------------------------------------------------------------*/
1237
vidioc_g_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)1238 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1239 struct v4l2_format *f)
1240 {
1241 struct em28xx *dev = video_drvdata(file);
1242 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1243
1244 f->fmt.pix.width = v4l2->width;
1245 f->fmt.pix.height = v4l2->height;
1246 f->fmt.pix.pixelformat = v4l2->format->fourcc;
1247 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
1248 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
1249 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1250
1251 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1252 if (v4l2->progressive)
1253 f->fmt.pix.field = V4L2_FIELD_NONE;
1254 else
1255 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1256 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1257 return 0;
1258 }
1259
format_by_fourcc(unsigned int fourcc)1260 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1261 {
1262 unsigned int i;
1263
1264 for (i = 0; i < ARRAY_SIZE(format); i++)
1265 if (format[i].fourcc == fourcc)
1266 return &format[i];
1267
1268 return NULL;
1269 }
1270
vidioc_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)1271 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1272 struct v4l2_format *f)
1273 {
1274 struct em28xx *dev = video_drvdata(file);
1275 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1276 unsigned int width = f->fmt.pix.width;
1277 unsigned int height = f->fmt.pix.height;
1278 unsigned int maxw = norm_maxw(dev);
1279 unsigned int maxh = norm_maxh(dev);
1280 unsigned int hscale, vscale;
1281 struct em28xx_fmt *fmt;
1282
1283 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1284 if (!fmt) {
1285 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1286 f->fmt.pix.pixelformat);
1287 return -EINVAL;
1288 }
1289
1290 if (dev->board.is_em2800) {
1291 /* the em2800 can only scale down to 50% */
1292 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1293 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1294 /*
1295 * MaxPacketSize for em2800 is too small to capture at full
1296 * resolution use half of maxw as the scaler can only scale
1297 * to 50%
1298 */
1299 if (width == maxw && height == maxh)
1300 width /= 2;
1301 } else {
1302 /* width must even because of the YUYV format
1303 height must be even because of interlacing */
1304 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1305 1, 0);
1306 }
1307
1308 size_to_scale(dev, width, height, &hscale, &vscale);
1309 scale_to_size(dev, hscale, vscale, &width, &height);
1310
1311 f->fmt.pix.width = width;
1312 f->fmt.pix.height = height;
1313 f->fmt.pix.pixelformat = fmt->fourcc;
1314 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
1315 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1316 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1317 if (v4l2->progressive)
1318 f->fmt.pix.field = V4L2_FIELD_NONE;
1319 else
1320 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1321 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1322 f->fmt.pix.priv = 0;
1323
1324 return 0;
1325 }
1326
em28xx_set_video_format(struct em28xx * dev,unsigned int fourcc,unsigned width,unsigned height)1327 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1328 unsigned width, unsigned height)
1329 {
1330 struct em28xx_fmt *fmt;
1331 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1332
1333 fmt = format_by_fourcc(fourcc);
1334 if (!fmt)
1335 return -EINVAL;
1336
1337 v4l2->format = fmt;
1338 v4l2->width = width;
1339 v4l2->height = height;
1340
1341 /* set new image size */
1342 size_to_scale(dev, v4l2->width, v4l2->height,
1343 &v4l2->hscale, &v4l2->vscale);
1344
1345 em28xx_resolution_set(dev);
1346
1347 return 0;
1348 }
1349
vidioc_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)1350 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1351 struct v4l2_format *f)
1352 {
1353 struct em28xx *dev = video_drvdata(file);
1354 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1355
1356 if (vb2_is_busy(&v4l2->vb_vidq))
1357 return -EBUSY;
1358
1359 vidioc_try_fmt_vid_cap(file, priv, f);
1360
1361 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1362 f->fmt.pix.width, f->fmt.pix.height);
1363 }
1364
vidioc_g_std(struct file * file,void * priv,v4l2_std_id * norm)1365 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1366 {
1367 struct em28xx *dev = video_drvdata(file);
1368
1369 *norm = dev->v4l2->norm;
1370
1371 return 0;
1372 }
1373
vidioc_querystd(struct file * file,void * priv,v4l2_std_id * norm)1374 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1375 {
1376 struct em28xx *dev = video_drvdata(file);
1377
1378 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
1379
1380 return 0;
1381 }
1382
vidioc_s_std(struct file * file,void * priv,v4l2_std_id norm)1383 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1384 {
1385 struct em28xx *dev = video_drvdata(file);
1386 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1387 struct v4l2_format f;
1388
1389 if (norm == v4l2->norm)
1390 return 0;
1391
1392 if (v4l2->streaming_users > 0)
1393 return -EBUSY;
1394
1395 v4l2->norm = norm;
1396
1397 /* Adjusts width/height, if needed */
1398 f.fmt.pix.width = 720;
1399 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
1400 vidioc_try_fmt_vid_cap(file, priv, &f);
1401
1402 /* set new image size */
1403 v4l2->width = f.fmt.pix.width;
1404 v4l2->height = f.fmt.pix.height;
1405 size_to_scale(dev, v4l2->width, v4l2->height,
1406 &v4l2->hscale, &v4l2->vscale);
1407
1408 em28xx_resolution_set(dev);
1409 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
1410
1411 return 0;
1412 }
1413
vidioc_g_parm(struct file * file,void * priv,struct v4l2_streamparm * p)1414 static int vidioc_g_parm(struct file *file, void *priv,
1415 struct v4l2_streamparm *p)
1416 {
1417 struct em28xx *dev = video_drvdata(file);
1418 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1419 int rc = 0;
1420
1421 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1422 if (dev->board.is_webcam)
1423 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
1424 video, g_parm, p);
1425 else
1426 v4l2_video_std_frame_period(v4l2->norm,
1427 &p->parm.capture.timeperframe);
1428
1429 return rc;
1430 }
1431
vidioc_s_parm(struct file * file,void * priv,struct v4l2_streamparm * p)1432 static int vidioc_s_parm(struct file *file, void *priv,
1433 struct v4l2_streamparm *p)
1434 {
1435 struct em28xx *dev = video_drvdata(file);
1436
1437 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1438 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1439 0, video, s_parm, p);
1440 }
1441
1442 static const char *iname[] = {
1443 [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1444 [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1445 [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1446 [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1447 [EM28XX_VMUX_SVIDEO] = "S-Video",
1448 [EM28XX_VMUX_TELEVISION] = "Television",
1449 [EM28XX_VMUX_CABLE] = "Cable TV",
1450 [EM28XX_VMUX_DVB] = "DVB",
1451 [EM28XX_VMUX_DEBUG] = "for debug only",
1452 };
1453
vidioc_enum_input(struct file * file,void * priv,struct v4l2_input * i)1454 static int vidioc_enum_input(struct file *file, void *priv,
1455 struct v4l2_input *i)
1456 {
1457 struct em28xx *dev = video_drvdata(file);
1458 unsigned int n;
1459
1460 n = i->index;
1461 if (n >= MAX_EM28XX_INPUT)
1462 return -EINVAL;
1463 if (0 == INPUT(n)->type)
1464 return -EINVAL;
1465
1466 i->index = n;
1467 i->type = V4L2_INPUT_TYPE_CAMERA;
1468
1469 strcpy(i->name, iname[INPUT(n)->type]);
1470
1471 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1472 (EM28XX_VMUX_CABLE == INPUT(n)->type))
1473 i->type = V4L2_INPUT_TYPE_TUNER;
1474
1475 i->std = dev->v4l2->vdev.tvnorms;
1476 /* webcams do not have the STD API */
1477 if (dev->board.is_webcam)
1478 i->capabilities = 0;
1479
1480 return 0;
1481 }
1482
vidioc_g_input(struct file * file,void * priv,unsigned int * i)1483 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1484 {
1485 struct em28xx *dev = video_drvdata(file);
1486
1487 *i = dev->ctl_input;
1488
1489 return 0;
1490 }
1491
vidioc_s_input(struct file * file,void * priv,unsigned int i)1492 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1493 {
1494 struct em28xx *dev = video_drvdata(file);
1495
1496 if (i >= MAX_EM28XX_INPUT)
1497 return -EINVAL;
1498 if (0 == INPUT(i)->type)
1499 return -EINVAL;
1500
1501 video_mux(dev, i);
1502 return 0;
1503 }
1504
vidioc_g_audio(struct file * file,void * priv,struct v4l2_audio * a)1505 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1506 {
1507 struct em28xx *dev = video_drvdata(file);
1508
1509 switch (a->index) {
1510 case EM28XX_AMUX_VIDEO:
1511 strcpy(a->name, "Television");
1512 break;
1513 case EM28XX_AMUX_LINE_IN:
1514 strcpy(a->name, "Line In");
1515 break;
1516 case EM28XX_AMUX_VIDEO2:
1517 strcpy(a->name, "Television alt");
1518 break;
1519 case EM28XX_AMUX_PHONE:
1520 strcpy(a->name, "Phone");
1521 break;
1522 case EM28XX_AMUX_MIC:
1523 strcpy(a->name, "Mic");
1524 break;
1525 case EM28XX_AMUX_CD:
1526 strcpy(a->name, "CD");
1527 break;
1528 case EM28XX_AMUX_AUX:
1529 strcpy(a->name, "Aux");
1530 break;
1531 case EM28XX_AMUX_PCM_OUT:
1532 strcpy(a->name, "PCM");
1533 break;
1534 default:
1535 return -EINVAL;
1536 }
1537
1538 a->index = dev->ctl_ainput;
1539 a->capability = V4L2_AUDCAP_STEREO;
1540
1541 return 0;
1542 }
1543
vidioc_s_audio(struct file * file,void * priv,const struct v4l2_audio * a)1544 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1545 {
1546 struct em28xx *dev = video_drvdata(file);
1547
1548 if (a->index >= MAX_EM28XX_INPUT)
1549 return -EINVAL;
1550 if (0 == INPUT(a->index)->type)
1551 return -EINVAL;
1552
1553 dev->ctl_ainput = INPUT(a->index)->amux;
1554 dev->ctl_aoutput = INPUT(a->index)->aout;
1555
1556 if (!dev->ctl_aoutput)
1557 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1558
1559 return 0;
1560 }
1561
vidioc_g_tuner(struct file * file,void * priv,struct v4l2_tuner * t)1562 static int vidioc_g_tuner(struct file *file, void *priv,
1563 struct v4l2_tuner *t)
1564 {
1565 struct em28xx *dev = video_drvdata(file);
1566
1567 if (0 != t->index)
1568 return -EINVAL;
1569
1570 strcpy(t->name, "Tuner");
1571
1572 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1573 return 0;
1574 }
1575
vidioc_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * t)1576 static int vidioc_s_tuner(struct file *file, void *priv,
1577 const struct v4l2_tuner *t)
1578 {
1579 struct em28xx *dev = video_drvdata(file);
1580
1581 if (0 != t->index)
1582 return -EINVAL;
1583
1584 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1585 return 0;
1586 }
1587
vidioc_g_frequency(struct file * file,void * priv,struct v4l2_frequency * f)1588 static int vidioc_g_frequency(struct file *file, void *priv,
1589 struct v4l2_frequency *f)
1590 {
1591 struct em28xx *dev = video_drvdata(file);
1592 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1593
1594 if (0 != f->tuner)
1595 return -EINVAL;
1596
1597 f->frequency = v4l2->frequency;
1598 return 0;
1599 }
1600
vidioc_s_frequency(struct file * file,void * priv,const struct v4l2_frequency * f)1601 static int vidioc_s_frequency(struct file *file, void *priv,
1602 const struct v4l2_frequency *f)
1603 {
1604 struct v4l2_frequency new_freq = *f;
1605 struct em28xx *dev = video_drvdata(file);
1606 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1607
1608 if (0 != f->tuner)
1609 return -EINVAL;
1610
1611 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1612 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1613 v4l2->frequency = new_freq.frequency;
1614
1615 return 0;
1616 }
1617
1618 #ifdef CONFIG_VIDEO_ADV_DEBUG
vidioc_g_chip_info(struct file * file,void * priv,struct v4l2_dbg_chip_info * chip)1619 static int vidioc_g_chip_info(struct file *file, void *priv,
1620 struct v4l2_dbg_chip_info *chip)
1621 {
1622 struct em28xx *dev = video_drvdata(file);
1623
1624 if (chip->match.addr > 1)
1625 return -EINVAL;
1626 if (chip->match.addr == 1)
1627 strlcpy(chip->name, "ac97", sizeof(chip->name));
1628 else
1629 strlcpy(chip->name,
1630 dev->v4l2->v4l2_dev.name, sizeof(chip->name));
1631 return 0;
1632 }
1633
em28xx_reg_len(int reg)1634 static int em28xx_reg_len(int reg)
1635 {
1636 switch (reg) {
1637 case EM28XX_R40_AC97LSB:
1638 case EM28XX_R30_HSCALELOW:
1639 case EM28XX_R32_VSCALELOW:
1640 return 2;
1641 default:
1642 return 1;
1643 }
1644 }
1645
vidioc_g_register(struct file * file,void * priv,struct v4l2_dbg_register * reg)1646 static int vidioc_g_register(struct file *file, void *priv,
1647 struct v4l2_dbg_register *reg)
1648 {
1649 struct em28xx *dev = video_drvdata(file);
1650 int ret;
1651
1652 if (reg->match.addr > 1)
1653 return -EINVAL;
1654 if (reg->match.addr) {
1655 ret = em28xx_read_ac97(dev, reg->reg);
1656 if (ret < 0)
1657 return ret;
1658
1659 reg->val = ret;
1660 reg->size = 1;
1661 return 0;
1662 }
1663
1664 /* Match host */
1665 reg->size = em28xx_reg_len(reg->reg);
1666 if (reg->size == 1) {
1667 ret = em28xx_read_reg(dev, reg->reg);
1668
1669 if (ret < 0)
1670 return ret;
1671
1672 reg->val = ret;
1673 } else {
1674 __le16 val = 0;
1675
1676 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1677 reg->reg, (char *)&val, 2);
1678 if (ret < 0)
1679 return ret;
1680
1681 reg->val = le16_to_cpu(val);
1682 }
1683
1684 return 0;
1685 }
1686
vidioc_s_register(struct file * file,void * priv,const struct v4l2_dbg_register * reg)1687 static int vidioc_s_register(struct file *file, void *priv,
1688 const struct v4l2_dbg_register *reg)
1689 {
1690 struct em28xx *dev = video_drvdata(file);
1691 __le16 buf;
1692
1693 if (reg->match.addr > 1)
1694 return -EINVAL;
1695 if (reg->match.addr)
1696 return em28xx_write_ac97(dev, reg->reg, reg->val);
1697
1698 /* Match host */
1699 buf = cpu_to_le16(reg->val);
1700
1701 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1702 em28xx_reg_len(reg->reg));
1703 }
1704 #endif
1705
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * cap)1706 static int vidioc_querycap(struct file *file, void *priv,
1707 struct v4l2_capability *cap)
1708 {
1709 struct video_device *vdev = video_devdata(file);
1710 struct em28xx *dev = video_drvdata(file);
1711 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1712
1713 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1714 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1715 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1716
1717 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1718 cap->device_caps = V4L2_CAP_READWRITE |
1719 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1720 else if (vdev->vfl_type == VFL_TYPE_RADIO)
1721 cap->device_caps = V4L2_CAP_RADIO;
1722 else
1723 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1724
1725 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
1726 cap->device_caps |= V4L2_CAP_AUDIO;
1727
1728 if (dev->tuner_type != TUNER_ABSENT)
1729 cap->device_caps |= V4L2_CAP_TUNER;
1730
1731 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1732 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1733 if (video_is_registered(&v4l2->vbi_dev))
1734 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1735 if (video_is_registered(&v4l2->radio_dev))
1736 cap->capabilities |= V4L2_CAP_RADIO;
1737 return 0;
1738 }
1739
vidioc_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)1740 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1741 struct v4l2_fmtdesc *f)
1742 {
1743 if (unlikely(f->index >= ARRAY_SIZE(format)))
1744 return -EINVAL;
1745
1746 strlcpy(f->description, format[f->index].name, sizeof(f->description));
1747 f->pixelformat = format[f->index].fourcc;
1748
1749 return 0;
1750 }
1751
vidioc_enum_framesizes(struct file * file,void * priv,struct v4l2_frmsizeenum * fsize)1752 static int vidioc_enum_framesizes(struct file *file, void *priv,
1753 struct v4l2_frmsizeenum *fsize)
1754 {
1755 struct em28xx *dev = video_drvdata(file);
1756 struct em28xx_fmt *fmt;
1757 unsigned int maxw = norm_maxw(dev);
1758 unsigned int maxh = norm_maxh(dev);
1759
1760 fmt = format_by_fourcc(fsize->pixel_format);
1761 if (!fmt) {
1762 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1763 fsize->pixel_format);
1764 return -EINVAL;
1765 }
1766
1767 if (dev->board.is_em2800) {
1768 if (fsize->index > 1)
1769 return -EINVAL;
1770 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1771 fsize->discrete.width = maxw / (1 + fsize->index);
1772 fsize->discrete.height = maxh / (1 + fsize->index);
1773 return 0;
1774 }
1775
1776 if (fsize->index != 0)
1777 return -EINVAL;
1778
1779 /* Report a continuous range */
1780 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1781 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1782 &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1783 if (fsize->stepwise.min_width < 48)
1784 fsize->stepwise.min_width = 48;
1785 if (fsize->stepwise.min_height < 38)
1786 fsize->stepwise.min_height = 38;
1787 fsize->stepwise.max_width = maxw;
1788 fsize->stepwise.max_height = maxh;
1789 fsize->stepwise.step_width = 1;
1790 fsize->stepwise.step_height = 1;
1791 return 0;
1792 }
1793
1794 /* RAW VBI ioctls */
1795
vidioc_g_fmt_vbi_cap(struct file * file,void * priv,struct v4l2_format * format)1796 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1797 struct v4l2_format *format)
1798 {
1799 struct em28xx *dev = video_drvdata(file);
1800 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1801
1802 format->fmt.vbi.samples_per_line = v4l2->vbi_width;
1803 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1804 format->fmt.vbi.offset = 0;
1805 format->fmt.vbi.flags = 0;
1806 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1807 format->fmt.vbi.count[0] = v4l2->vbi_height;
1808 format->fmt.vbi.count[1] = v4l2->vbi_height;
1809 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1810
1811 /* Varies by video standard (NTSC, PAL, etc.) */
1812 if (v4l2->norm & V4L2_STD_525_60) {
1813 /* NTSC */
1814 format->fmt.vbi.start[0] = 10;
1815 format->fmt.vbi.start[1] = 273;
1816 } else if (v4l2->norm & V4L2_STD_625_50) {
1817 /* PAL */
1818 format->fmt.vbi.start[0] = 6;
1819 format->fmt.vbi.start[1] = 318;
1820 }
1821
1822 return 0;
1823 }
1824
1825 /* ----------------------------------------------------------- */
1826 /* RADIO ESPECIFIC IOCTLS */
1827 /* ----------------------------------------------------------- */
1828
radio_g_tuner(struct file * file,void * priv,struct v4l2_tuner * t)1829 static int radio_g_tuner(struct file *file, void *priv,
1830 struct v4l2_tuner *t)
1831 {
1832 struct em28xx *dev = video_drvdata(file);
1833
1834 if (unlikely(t->index > 0))
1835 return -EINVAL;
1836
1837 strcpy(t->name, "Radio");
1838
1839 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1840
1841 return 0;
1842 }
1843
radio_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * t)1844 static int radio_s_tuner(struct file *file, void *priv,
1845 const struct v4l2_tuner *t)
1846 {
1847 struct em28xx *dev = video_drvdata(file);
1848
1849 if (0 != t->index)
1850 return -EINVAL;
1851
1852 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1853
1854 return 0;
1855 }
1856
1857 /*
1858 * em28xx_free_v4l2() - Free struct em28xx_v4l2
1859 *
1860 * @ref: struct kref for struct em28xx_v4l2
1861 *
1862 * Called when all users of struct em28xx_v4l2 are gone
1863 */
em28xx_free_v4l2(struct kref * ref)1864 static void em28xx_free_v4l2(struct kref *ref)
1865 {
1866 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
1867
1868 v4l2->dev->v4l2 = NULL;
1869 kfree(v4l2);
1870 }
1871
1872 /*
1873 * em28xx_v4l2_open()
1874 * inits the device and starts isoc transfer
1875 */
em28xx_v4l2_open(struct file * filp)1876 static int em28xx_v4l2_open(struct file *filp)
1877 {
1878 struct video_device *vdev = video_devdata(filp);
1879 struct em28xx *dev = video_drvdata(filp);
1880 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1881 enum v4l2_buf_type fh_type = 0;
1882 int ret;
1883
1884 switch (vdev->vfl_type) {
1885 case VFL_TYPE_GRABBER:
1886 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1887 break;
1888 case VFL_TYPE_VBI:
1889 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1890 break;
1891 case VFL_TYPE_RADIO:
1892 break;
1893 default:
1894 return -EINVAL;
1895 }
1896
1897 em28xx_videodbg("open dev=%s type=%s users=%d\n",
1898 video_device_node_name(vdev), v4l2_type_names[fh_type],
1899 v4l2->users);
1900
1901 if (mutex_lock_interruptible(&dev->lock))
1902 return -ERESTARTSYS;
1903
1904 ret = v4l2_fh_open(filp);
1905 if (ret) {
1906 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n",
1907 __func__, ret);
1908 mutex_unlock(&dev->lock);
1909 return ret;
1910 }
1911
1912 if (v4l2->users == 0) {
1913 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
1914
1915 if (vdev->vfl_type != VFL_TYPE_RADIO)
1916 em28xx_resolution_set(dev);
1917
1918 /*
1919 * Needed, since GPIO might have disabled power
1920 * of some i2c devices
1921 */
1922 em28xx_wake_i2c(dev);
1923 }
1924
1925 if (vdev->vfl_type == VFL_TYPE_RADIO) {
1926 em28xx_videodbg("video_open: setting radio device\n");
1927 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
1928 }
1929
1930 kref_get(&dev->ref);
1931 kref_get(&v4l2->ref);
1932 v4l2->users++;
1933
1934 mutex_unlock(&dev->lock);
1935
1936 return 0;
1937 }
1938
1939 /*
1940 * em28xx_v4l2_fini()
1941 * unregisters the v4l2,i2c and usb devices
1942 * called when the device gets disconected or at module unload
1943 */
em28xx_v4l2_fini(struct em28xx * dev)1944 static int em28xx_v4l2_fini(struct em28xx *dev)
1945 {
1946 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1947
1948 if (dev->is_audio_only) {
1949 /* Shouldn't initialize IR for this interface */
1950 return 0;
1951 }
1952
1953 if (!dev->has_video) {
1954 /* This device does not support the v4l2 extension */
1955 return 0;
1956 }
1957
1958 if (v4l2 == NULL)
1959 return 0;
1960
1961 em28xx_info("Closing video extension\n");
1962
1963 mutex_lock(&dev->lock);
1964
1965 v4l2_device_disconnect(&v4l2->v4l2_dev);
1966
1967 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1968
1969 if (video_is_registered(&v4l2->radio_dev)) {
1970 em28xx_info("V4L2 device %s deregistered\n",
1971 video_device_node_name(&v4l2->radio_dev));
1972 video_unregister_device(&v4l2->radio_dev);
1973 }
1974 if (video_is_registered(&v4l2->vbi_dev)) {
1975 em28xx_info("V4L2 device %s deregistered\n",
1976 video_device_node_name(&v4l2->vbi_dev));
1977 video_unregister_device(&v4l2->vbi_dev);
1978 }
1979 if (video_is_registered(&v4l2->vdev)) {
1980 em28xx_info("V4L2 device %s deregistered\n",
1981 video_device_node_name(&v4l2->vdev));
1982 video_unregister_device(&v4l2->vdev);
1983 }
1984
1985 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
1986 v4l2_device_unregister(&v4l2->v4l2_dev);
1987
1988 if (v4l2->clk) {
1989 v4l2_clk_unregister_fixed(v4l2->clk);
1990 v4l2->clk = NULL;
1991 }
1992
1993 kref_put(&v4l2->ref, em28xx_free_v4l2);
1994
1995 mutex_unlock(&dev->lock);
1996
1997 kref_put(&dev->ref, em28xx_free_device);
1998
1999 return 0;
2000 }
2001
em28xx_v4l2_suspend(struct em28xx * dev)2002 static int em28xx_v4l2_suspend(struct em28xx *dev)
2003 {
2004 if (dev->is_audio_only)
2005 return 0;
2006
2007 if (!dev->has_video)
2008 return 0;
2009
2010 em28xx_info("Suspending video extension\n");
2011 em28xx_stop_urbs(dev);
2012 return 0;
2013 }
2014
em28xx_v4l2_resume(struct em28xx * dev)2015 static int em28xx_v4l2_resume(struct em28xx *dev)
2016 {
2017 if (dev->is_audio_only)
2018 return 0;
2019
2020 if (!dev->has_video)
2021 return 0;
2022
2023 em28xx_info("Resuming video extension\n");
2024 /* what do we do here */
2025 return 0;
2026 }
2027
2028 /*
2029 * em28xx_v4l2_close()
2030 * stops streaming and deallocates all resources allocated by the v4l2
2031 * calls and ioctls
2032 */
em28xx_v4l2_close(struct file * filp)2033 static int em28xx_v4l2_close(struct file *filp)
2034 {
2035 struct em28xx *dev = video_drvdata(filp);
2036 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2037 int errCode;
2038
2039 em28xx_videodbg("users=%d\n", v4l2->users);
2040
2041 vb2_fop_release(filp);
2042 mutex_lock(&dev->lock);
2043
2044 if (v4l2->users == 1) {
2045 /* No sense to try to write to the device */
2046 if (dev->disconnected)
2047 goto exit;
2048
2049 /* Save some power by putting tuner to sleep */
2050 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2051
2052 /* do this before setting alternate! */
2053 em28xx_set_mode(dev, EM28XX_SUSPEND);
2054
2055 /* set alternate 0 */
2056 dev->alt = 0;
2057 em28xx_videodbg("setting alternate 0\n");
2058 errCode = usb_set_interface(dev->udev, 0, 0);
2059 if (errCode < 0) {
2060 em28xx_errdev("cannot change alternate number to "
2061 "0 (error=%i)\n", errCode);
2062 }
2063 }
2064
2065 exit:
2066 v4l2->users--;
2067 kref_put(&v4l2->ref, em28xx_free_v4l2);
2068 mutex_unlock(&dev->lock);
2069 kref_put(&dev->ref, em28xx_free_device);
2070
2071 return 0;
2072 }
2073
2074 static const struct v4l2_file_operations em28xx_v4l_fops = {
2075 .owner = THIS_MODULE,
2076 .open = em28xx_v4l2_open,
2077 .release = em28xx_v4l2_close,
2078 .read = vb2_fop_read,
2079 .poll = vb2_fop_poll,
2080 .mmap = vb2_fop_mmap,
2081 .unlocked_ioctl = video_ioctl2,
2082 };
2083
2084 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2085 .vidioc_querycap = vidioc_querycap,
2086 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2087 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2088 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2089 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
2090 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2091 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2092 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2093 .vidioc_enum_framesizes = vidioc_enum_framesizes,
2094 .vidioc_g_audio = vidioc_g_audio,
2095 .vidioc_s_audio = vidioc_s_audio,
2096
2097 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2098 .vidioc_create_bufs = vb2_ioctl_create_bufs,
2099 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
2100 .vidioc_querybuf = vb2_ioctl_querybuf,
2101 .vidioc_qbuf = vb2_ioctl_qbuf,
2102 .vidioc_dqbuf = vb2_ioctl_dqbuf,
2103
2104 .vidioc_g_std = vidioc_g_std,
2105 .vidioc_querystd = vidioc_querystd,
2106 .vidioc_s_std = vidioc_s_std,
2107 .vidioc_g_parm = vidioc_g_parm,
2108 .vidioc_s_parm = vidioc_s_parm,
2109 .vidioc_enum_input = vidioc_enum_input,
2110 .vidioc_g_input = vidioc_g_input,
2111 .vidioc_s_input = vidioc_s_input,
2112 .vidioc_streamon = vb2_ioctl_streamon,
2113 .vidioc_streamoff = vb2_ioctl_streamoff,
2114 .vidioc_g_tuner = vidioc_g_tuner,
2115 .vidioc_s_tuner = vidioc_s_tuner,
2116 .vidioc_g_frequency = vidioc_g_frequency,
2117 .vidioc_s_frequency = vidioc_s_frequency,
2118 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2119 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2120 #ifdef CONFIG_VIDEO_ADV_DEBUG
2121 .vidioc_g_chip_info = vidioc_g_chip_info,
2122 .vidioc_g_register = vidioc_g_register,
2123 .vidioc_s_register = vidioc_s_register,
2124 #endif
2125 };
2126
2127 static const struct video_device em28xx_video_template = {
2128 .fops = &em28xx_v4l_fops,
2129 .ioctl_ops = &video_ioctl_ops,
2130 .release = video_device_release_empty,
2131 .tvnorms = V4L2_STD_ALL,
2132 };
2133
2134 static const struct v4l2_file_operations radio_fops = {
2135 .owner = THIS_MODULE,
2136 .open = em28xx_v4l2_open,
2137 .release = em28xx_v4l2_close,
2138 .unlocked_ioctl = video_ioctl2,
2139 };
2140
2141 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2142 .vidioc_querycap = vidioc_querycap,
2143 .vidioc_g_tuner = radio_g_tuner,
2144 .vidioc_s_tuner = radio_s_tuner,
2145 .vidioc_g_frequency = vidioc_g_frequency,
2146 .vidioc_s_frequency = vidioc_s_frequency,
2147 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2148 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2149 #ifdef CONFIG_VIDEO_ADV_DEBUG
2150 .vidioc_g_chip_info = vidioc_g_chip_info,
2151 .vidioc_g_register = vidioc_g_register,
2152 .vidioc_s_register = vidioc_s_register,
2153 #endif
2154 };
2155
2156 static struct video_device em28xx_radio_template = {
2157 .fops = &radio_fops,
2158 .ioctl_ops = &radio_ioctl_ops,
2159 .release = video_device_release_empty,
2160 };
2161
2162 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2163 static unsigned short saa711x_addrs[] = {
2164 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */
2165 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */
2166 I2C_CLIENT_END };
2167
2168 static unsigned short tvp5150_addrs[] = {
2169 0xb8 >> 1,
2170 0xba >> 1,
2171 I2C_CLIENT_END
2172 };
2173
2174 static unsigned short msp3400_addrs[] = {
2175 0x80 >> 1,
2176 0x88 >> 1,
2177 I2C_CLIENT_END
2178 };
2179
2180 /******************************** usb interface ******************************/
2181
em28xx_vdev_init(struct em28xx * dev,struct video_device * vfd,const struct video_device * template,const char * type_name)2182 static void em28xx_vdev_init(struct em28xx *dev,
2183 struct video_device *vfd,
2184 const struct video_device *template,
2185 const char *type_name)
2186 {
2187 *vfd = *template;
2188 vfd->v4l2_dev = &dev->v4l2->v4l2_dev;
2189 vfd->lock = &dev->lock;
2190 if (dev->board.is_webcam)
2191 vfd->tvnorms = 0;
2192
2193 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2194 dev->name, type_name);
2195
2196 video_set_drvdata(vfd, dev);
2197 }
2198
em28xx_tuner_setup(struct em28xx * dev,unsigned short tuner_addr)2199 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
2200 {
2201 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2202 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev;
2203 struct tuner_setup tun_setup;
2204 struct v4l2_frequency f;
2205
2206 memset(&tun_setup, 0, sizeof(tun_setup));
2207
2208 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2209 tun_setup.tuner_callback = em28xx_tuner_callback;
2210
2211 if (dev->board.radio.type) {
2212 tun_setup.type = dev->board.radio.type;
2213 tun_setup.addr = dev->board.radio_addr;
2214
2215 v4l2_device_call_all(v4l2_dev,
2216 0, tuner, s_type_addr, &tun_setup);
2217 }
2218
2219 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2220 tun_setup.type = dev->tuner_type;
2221 tun_setup.addr = tuner_addr;
2222
2223 v4l2_device_call_all(v4l2_dev,
2224 0, tuner, s_type_addr, &tun_setup);
2225 }
2226
2227 if (dev->board.tda9887_conf) {
2228 struct v4l2_priv_tun_config tda9887_cfg;
2229
2230 tda9887_cfg.tuner = TUNER_TDA9887;
2231 tda9887_cfg.priv = &dev->board.tda9887_conf;
2232
2233 v4l2_device_call_all(v4l2_dev,
2234 0, tuner, s_config, &tda9887_cfg);
2235 }
2236
2237 if (dev->tuner_type == TUNER_XC2028) {
2238 struct v4l2_priv_tun_config xc2028_cfg;
2239 struct xc2028_ctrl ctl;
2240
2241 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2242 memset(&ctl, 0, sizeof(ctl));
2243
2244 em28xx_setup_xc3028(dev, &ctl);
2245
2246 xc2028_cfg.tuner = TUNER_XC2028;
2247 xc2028_cfg.priv = &ctl;
2248
2249 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2250 }
2251
2252 /* configure tuner */
2253 f.tuner = 0;
2254 f.type = V4L2_TUNER_ANALOG_TV;
2255 f.frequency = 9076; /* just a magic number */
2256 v4l2->frequency = f.frequency;
2257 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
2258 }
2259
em28xx_v4l2_init(struct em28xx * dev)2260 static int em28xx_v4l2_init(struct em28xx *dev)
2261 {
2262 u8 val;
2263 int ret;
2264 unsigned int maxw;
2265 struct v4l2_ctrl_handler *hdl;
2266 struct em28xx_v4l2 *v4l2;
2267
2268 if (dev->is_audio_only) {
2269 /* Shouldn't initialize IR for this interface */
2270 return 0;
2271 }
2272
2273 if (!dev->has_video) {
2274 /* This device does not support the v4l2 extension */
2275 return 0;
2276 }
2277
2278 em28xx_info("Registering V4L2 extension\n");
2279
2280 mutex_lock(&dev->lock);
2281
2282 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2283 if (v4l2 == NULL) {
2284 em28xx_info("em28xx_v4l: memory allocation failed\n");
2285 mutex_unlock(&dev->lock);
2286 return -ENOMEM;
2287 }
2288 kref_init(&v4l2->ref);
2289 v4l2->dev = dev;
2290 dev->v4l2 = v4l2;
2291
2292 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev);
2293 if (ret < 0) {
2294 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2295 goto err;
2296 }
2297
2298 hdl = &v4l2->ctrl_handler;
2299 v4l2_ctrl_handler_init(hdl, 8);
2300 v4l2->v4l2_dev.ctrl_handler = hdl;
2301
2302 if (dev->board.is_webcam)
2303 v4l2->progressive = true;
2304
2305 /*
2306 * Default format, used for tvp5150 or saa711x output formats
2307 */
2308 v4l2->vinmode = 0x10;
2309 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED |
2310 EM28XX_VINCTRL_CCIR656_ENABLE;
2311
2312 /* request some modules */
2313
2314 if (dev->board.has_msp34xx)
2315 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2316 &dev->i2c_adap[dev->def_i2c_bus],
2317 "msp3400", 0, msp3400_addrs);
2318
2319 if (dev->board.decoder == EM28XX_SAA711X)
2320 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2321 &dev->i2c_adap[dev->def_i2c_bus],
2322 "saa7115_auto", 0, saa711x_addrs);
2323
2324 if (dev->board.decoder == EM28XX_TVP5150)
2325 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2326 &dev->i2c_adap[dev->def_i2c_bus],
2327 "tvp5150", 0, tvp5150_addrs);
2328
2329 if (dev->board.adecoder == EM28XX_TVAUDIO)
2330 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2331 &dev->i2c_adap[dev->def_i2c_bus],
2332 "tvaudio", dev->board.tvaudio_addr, NULL);
2333
2334 /* Initialize tuner and camera */
2335
2336 if (dev->board.tuner_type != TUNER_ABSENT) {
2337 unsigned short tuner_addr = dev->board.tuner_addr;
2338 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
2339
2340 if (dev->board.radio.type)
2341 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2342 &dev->i2c_adap[dev->def_i2c_bus],
2343 "tuner", dev->board.radio_addr,
2344 NULL);
2345
2346 if (has_demod)
2347 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2348 &dev->i2c_adap[dev->def_i2c_bus],
2349 "tuner", 0,
2350 v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2351 if (tuner_addr == 0) {
2352 enum v4l2_i2c_tuner_type type =
2353 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2354 struct v4l2_subdev *sd;
2355
2356 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2357 &dev->i2c_adap[dev->def_i2c_bus],
2358 "tuner", 0,
2359 v4l2_i2c_tuner_addrs(type));
2360
2361 if (sd)
2362 tuner_addr = v4l2_i2c_subdev_addr(sd);
2363 } else {
2364 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2365 &dev->i2c_adap[dev->def_i2c_bus],
2366 "tuner", tuner_addr, NULL);
2367 }
2368
2369 em28xx_tuner_setup(dev, tuner_addr);
2370 }
2371
2372 if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2373 em28xx_init_camera(dev);
2374
2375 /* Configure audio */
2376 ret = em28xx_audio_setup(dev);
2377 if (ret < 0) {
2378 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
2379 __func__, ret);
2380 goto unregister_dev;
2381 }
2382 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2383 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2384 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2385 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2386 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
2387 } else {
2388 /* install the em28xx notify callback */
2389 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
2390 em28xx_ctrl_notify, dev);
2391 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
2392 em28xx_ctrl_notify, dev);
2393 }
2394
2395 /* wake i2c devices */
2396 em28xx_wake_i2c(dev);
2397
2398 /* init video dma queues */
2399 INIT_LIST_HEAD(&dev->vidq.active);
2400 INIT_LIST_HEAD(&dev->vbiq.active);
2401
2402 if (dev->board.has_msp34xx) {
2403 /* Send a reset to other chips via gpio */
2404 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2405 if (ret < 0) {
2406 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2407 __func__, ret);
2408 goto unregister_dev;
2409 }
2410 msleep(3);
2411
2412 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2413 if (ret < 0) {
2414 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2415 __func__, ret);
2416 goto unregister_dev;
2417 }
2418 msleep(3);
2419 }
2420
2421 /* set default norm */
2422 v4l2->norm = V4L2_STD_PAL;
2423 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
2424 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
2425
2426 /* Analog specific initialization */
2427 v4l2->format = &format[0];
2428
2429 maxw = norm_maxw(dev);
2430 /* MaxPacketSize for em2800 is too small to capture at full resolution
2431 * use half of maxw as the scaler can only scale to 50% */
2432 if (dev->board.is_em2800)
2433 maxw /= 2;
2434
2435 em28xx_set_video_format(dev, format[0].fourcc,
2436 maxw, norm_maxh(dev));
2437
2438 video_mux(dev, 0);
2439
2440 /* Audio defaults */
2441 dev->mute = 1;
2442 dev->volume = 0x1f;
2443
2444 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
2445 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2446 em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2447 (EM28XX_XCLK_AUDIO_UNMUTE | val));
2448
2449 em28xx_set_outfmt(dev);
2450
2451 /* Add image controls */
2452 /* NOTE: at this point, the subdevices are already registered, so bridge
2453 * controls are only added/enabled when no subdevice provides them */
2454 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2455 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2456 V4L2_CID_CONTRAST,
2457 0, 0x1f, 1, CONTRAST_DEFAULT);
2458 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2459 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2460 V4L2_CID_BRIGHTNESS,
2461 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
2462 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2463 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2464 V4L2_CID_SATURATION,
2465 0, 0x1f, 1, SATURATION_DEFAULT);
2466 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2467 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2468 V4L2_CID_BLUE_BALANCE,
2469 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
2470 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2471 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2472 V4L2_CID_RED_BALANCE,
2473 -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
2474 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2475 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2476 V4L2_CID_SHARPNESS,
2477 0, 0x0f, 1, SHARPNESS_DEFAULT);
2478
2479 /* Reset image controls */
2480 em28xx_colorlevels_set_default(dev);
2481 v4l2_ctrl_handler_setup(hdl);
2482 ret = hdl->error;
2483 if (ret)
2484 goto unregister_dev;
2485
2486 /* allocate and fill video video_device struct */
2487 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
2488 mutex_init(&v4l2->vb_queue_lock);
2489 mutex_init(&v4l2->vb_vbi_queue_lock);
2490 v4l2->vdev.queue = &v4l2->vb_vidq;
2491 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
2492
2493 /* disable inapplicable ioctls */
2494 if (dev->board.is_webcam) {
2495 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2496 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2497 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
2498 } else {
2499 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
2500 }
2501 if (dev->tuner_type == TUNER_ABSENT) {
2502 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2503 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2504 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2505 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
2506 }
2507 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2508 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2509 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
2510 }
2511
2512 /* register v4l2 video video_device */
2513 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
2514 video_nr[dev->devno]);
2515 if (ret) {
2516 em28xx_errdev("unable to register video device (error=%i).\n",
2517 ret);
2518 goto unregister_dev;
2519 }
2520
2521 /* Allocate and fill vbi video_device struct */
2522 if (em28xx_vbi_supported(dev) == 1) {
2523 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2524 "vbi");
2525
2526 v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2527 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
2528
2529 /* disable inapplicable ioctls */
2530 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
2531 if (dev->tuner_type == TUNER_ABSENT) {
2532 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2533 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2534 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2535 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
2536 }
2537 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2538 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2539 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
2540 }
2541
2542 /* register v4l2 vbi video_device */
2543 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
2544 vbi_nr[dev->devno]);
2545 if (ret < 0) {
2546 em28xx_errdev("unable to register vbi device\n");
2547 goto unregister_dev;
2548 }
2549 }
2550
2551 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2552 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2553 "radio");
2554 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
2555 radio_nr[dev->devno]);
2556 if (ret < 0) {
2557 em28xx_errdev("can't register radio device\n");
2558 goto unregister_dev;
2559 }
2560 em28xx_info("Registered radio device as %s\n",
2561 video_device_node_name(&v4l2->radio_dev));
2562 }
2563
2564 em28xx_info("V4L2 video device registered as %s\n",
2565 video_device_node_name(&v4l2->vdev));
2566
2567 if (video_is_registered(&v4l2->vbi_dev))
2568 em28xx_info("V4L2 VBI device registered as %s\n",
2569 video_device_node_name(&v4l2->vbi_dev));
2570
2571 /* Save some power by putting tuner to sleep */
2572 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2573
2574 /* initialize videobuf2 stuff */
2575 em28xx_vb2_setup(dev);
2576
2577 em28xx_info("V4L2 extension successfully initialized\n");
2578
2579 kref_get(&dev->ref);
2580
2581 mutex_unlock(&dev->lock);
2582 return 0;
2583
2584 unregister_dev:
2585 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2586 v4l2_device_unregister(&v4l2->v4l2_dev);
2587 err:
2588 dev->v4l2 = NULL;
2589 kref_put(&v4l2->ref, em28xx_free_v4l2);
2590 mutex_unlock(&dev->lock);
2591 return ret;
2592 }
2593
2594 static struct em28xx_ops v4l2_ops = {
2595 .id = EM28XX_V4L2,
2596 .name = "Em28xx v4l2 Extension",
2597 .init = em28xx_v4l2_init,
2598 .fini = em28xx_v4l2_fini,
2599 .suspend = em28xx_v4l2_suspend,
2600 .resume = em28xx_v4l2_resume,
2601 };
2602
em28xx_video_register(void)2603 static int __init em28xx_video_register(void)
2604 {
2605 return em28xx_register_extension(&v4l2_ops);
2606 }
2607
em28xx_video_unregister(void)2608 static void __exit em28xx_video_unregister(void)
2609 {
2610 em28xx_unregister_extension(&v4l2_ops);
2611 }
2612
2613 module_init(em28xx_video_register);
2614 module_exit(em28xx_video_unregister);
2615