projects / deliverable / linux.git / blob
? search:


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