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