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