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