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