projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] tvp5150: Add pad-level subdev operations
[deliverable/linux.git] / drivers / media / usb / em28xx / em28xx-video.c
CommitLineData
a6c2ba28 1/*
6ea54d93
DSL		 2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
3 video capture devices
a6c2ba28 4
f7abcd38
MCC		 5 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 Markus Rechberger <mrechberger@gmail.com>
2e7c6dc3 7 Mauro Carvalho Chehab <mchehab@infradead.org>
f7abcd38 8 Sascha Sommer <saschasommer@freenet.de>
0fa4a402 9 Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
a6c2ba28 10
439090d7
MCC		 11 Some parts based on SN9C10x PC Camera Controllers GPL driver made
12 by Luca Risolia <luca.risolia@studio.unibo.it>
13
a6c2ba28 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>
e5589bef 33#include <linux/bitmap.h>
a6c2ba28 34#include <linux/usb.h>
a6c2ba28 35#include <linux/i2c.h>
6d35c8f6 36#include <linux/mm.h>
1e4baed3 37#include <linux/mutex.h>
5a0e3ad6 38#include <linux/slab.h>
a6c2ba28 39
f7abcd38 40#include "em28xx.h"
01c28193 41#include "em28xx-v4l.h"
c0477ad9 42#include <media/v4l2-common.h>
35ea11ff 43#include <media/v4l2-ioctl.h>
50fdf40f 44#include <media/v4l2-event.h>
25dd1652 45#include <media/v4l2-clk.h>
d647f0b7 46#include <media/drv-intf/msp3400.h>
ed086314 47#include <media/tuner.h>
a6c2ba28 48
f7abcd38
MCC		 49#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
50 "Markus Rechberger <mrechberger@gmail.com>, " \
2e7c6dc3 51 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
f7abcd38 52 "Sascha Sommer <saschasommer@freenet.de>"
a6c2ba28 53
0560f337
MCC		 54static unsigned int isoc_debug;
55module_param(isoc_debug, int, 0644);
56MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
57
58static unsigned int disable_vbi;
59module_param(disable_vbi, int, 0644);
60MODULE_PARM_DESC(disable_vbi, "disable vbi support");
61
62static int alt;
63module_param(alt, int, 0644);
64MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
65
3acf2809 66#define em28xx_videodbg(fmt, arg...) do {\
4ac97914
MCC		 67 if (video_debug) \
68 printk(KERN_INFO "%s %s :"fmt, \
d80e134d 69 dev->name, __func__ , ##arg); } while (0)
a6c2ba28 70
6ea54d93
DSL		 71#define em28xx_isocdbg(fmt, arg...) \
72do {\
73 if (isoc_debug) { \
ad0ebb96 74 printk(KERN_INFO "%s %s :"fmt, \
6ea54d93
DSL		 75 dev->name, __func__ , ##arg); \
76 } \
77 } while (0)
ad0ebb96 78
a6c2ba28 79MODULE_AUTHOR(DRIVER_AUTHOR);
d8992b09 80MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
a6c2ba28 81MODULE_LICENSE("GPL");
1990d50b 82MODULE_VERSION(EM28XX_VERSION);
a6c2ba28 83
e507e0e5
FS		 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
d3829fad
DH		 92static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
93static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
94static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
0be43754 95
e5589bef
MCC		 96module_param_array(video_nr, int, NULL, 0444);
97module_param_array(vbi_nr, int, NULL, 0444);
0be43754 98module_param_array(radio_nr, int, NULL, 0444);
0be43754
MCC		 99MODULE_PARM_DESC(video_nr, "video device numbers");
100MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
101MODULE_PARM_DESC(radio_nr, "radio device numbers");
596d92d5 102
ff699e6b 103static unsigned int video_debug;
6ea54d93
DSL		 104module_param(video_debug, int, 0644);
105MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
a6c2ba28 106
bddcf633
MCC		 107/* supported video standards */
108static struct em28xx_fmt format[] = {
109 {
58fc1ce3 110 .name = "16 bpp YUY2, 4:2:2, packed",
bddcf633
MCC		 111 .fourcc = V4L2_PIX_FMT_YUYV,
112 .depth = 16,
3fbf9309 113 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V,
43cb9fe3 114 }, {
58fc1ce3 115 .name = "16 bpp RGB 565, LE",
43cb9fe3
MCC		 116 .fourcc = V4L2_PIX_FMT_RGB565,
117 .depth = 16,
58fc1ce3
MCC		 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,
bddcf633
MCC		 139 },
140};
141
25c61e4c
FS		 142/*FIXME: maxw should be dependent of alt mode */
143static inline unsigned int norm_maxw(struct em28xx *dev)
144{
d7dc18da
FS		 145 struct em28xx_v4l2 *v4l2 = dev->v4l2;
146
25c61e4c 147 if (dev->board.is_webcam)
d7dc18da 148 return v4l2->sensor_xres;
25c61e4c
FS		 149
150 if (dev->board.max_range_640_480)
151 return 640;
152
153 return 720;
154}
155
156static inline unsigned int norm_maxh(struct em28xx *dev)
157{
52faaf78
FS		 158 struct em28xx_v4l2 *v4l2 = dev->v4l2;
159
25c61e4c 160 if (dev->board.is_webcam)
d7dc18da 161 return v4l2->sensor_yres;
25c61e4c
FS		 162
163 if (dev->board.max_range_640_480)
164 return 480;
165
52faaf78 166 return (v4l2->norm & V4L2_STD_625_50) ? 576 : 480;
25c61e4c
FS		 167}
168
01c28193 169static int em28xx_vbi_supported(struct em28xx *dev)
0560f337
MCC		 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 */
01c28193 192static void em28xx_wake_i2c(struct em28xx *dev)
0560f337 193{
95d2608b 194 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
fdf1bc9f 195
95d2608b
FS		 196 v4l2_device_call_all(v4l2_dev, 0, core, reset, 0);
197 v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
fdf1bc9f 198 INPUT(dev->ctl_input)->vmux, 0, 0);
0560f337
MCC		 199}
200
01c28193 201static int em28xx_colorlevels_set_default(struct em28xx *dev)
0560f337
MCC		 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
01c28193 219static int em28xx_set_outfmt(struct em28xx *dev)
0560f337
MCC		 220{
221 int ret;
222 u8 fmt, vinctrl;
753aee77 223 struct em28xx_v4l2 *v4l2 = dev->v4l2;
0560f337 224
06e20672 225 fmt = v4l2->format->reg;
0560f337
MCC		 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
9297285e 241 ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, v4l2->vinmode);
0560f337
MCC		 242 if (ret < 0)
243 return ret;
244
9297285e 245 vinctrl = v4l2->vinctl;
0560f337
MCC		 246 if (em28xx_vbi_supported(dev) == 1) {
247 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
248 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
753aee77
FS		 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);
52faaf78 251 if (v4l2->norm & V4L2_STD_525_60) {
0560f337
MCC		 252 /* NTSC */
253 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
52faaf78 254 } else if (v4l2->norm & V4L2_STD_625_50) {
0560f337
MCC		 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
263static 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
275static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
fdf1bc9f 276 u16 width, u16 height)
0560f337
MCC		 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",
fdf1bc9f 284 hstart, vstart,
0560f337
MCC		 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
302static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
303{
cba8e9b3 304 u8 mode = 0x00;
0560f337
MCC		 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 }
cba8e9b3 323 return em28xx_write_reg(dev, EM28XX_R26_COMPR, mode);
0560f337
MCC		 324}
325
326/* FIXME: this only function read values from dev */
01c28193 327static int em28xx_resolution_set(struct em28xx *dev)
0560f337 328{
753aee77
FS		 329 struct em28xx_v4l2 *v4l2 = dev->v4l2;
330 int width = norm_maxw(dev);
331 int height = norm_maxh(dev);
0560f337
MCC		 332
333 /* Properly setup VBI */
753aee77 334 v4l2->vbi_width = 720;
52faaf78 335 if (v4l2->norm & V4L2_STD_525_60)
753aee77 336 v4l2->vbi_height = 12;
0560f337 337 else
753aee77 338 v4l2->vbi_height = 18;
0560f337
MCC		 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
753aee77 356 return em28xx_scaler_set(dev, v4l2->hscale, v4l2->vscale);
0560f337
MCC		 357}
358
359/* Set USB alternate setting for analog video */
01c28193 360static int em28xx_set_alternate(struct em28xx *dev)
0560f337 361{
753aee77 362 struct em28xx_v4l2 *v4l2 = dev->v4l2;
0560f337
MCC		 363 int errCode;
364 int i;
753aee77 365 unsigned int min_pkt_size = v4l2->width * 2 + 4;
0560f337
MCC		 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 */
753aee77 382 if (v4l2->width * 2 * v4l2->height > 720 * 240 * 2)
0560f337
MCC		 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
398set_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",
fdf1bc9f 407 min_pkt_size, dev->alt);
0560f337
MCC		 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",
fdf1bc9f 413 dev->alt, dev->max_pkt_size);
961717b4 414 errCode = usb_set_interface(dev->udev, dev->ifnum, dev->alt);
0560f337
MCC		 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
ad0ebb96
MCC		 423/* ------------------------------------------------------------------
424 DMA and thread functions
425 ------------------------------------------------------------------*/
426
427/*
948a49aa 428 * Finish the current buffer
ad0ebb96 429 */
948a49aa
FS		 430static inline void finish_buffer(struct em28xx *dev,
431 struct em28xx_buffer *buf)
ad0ebb96 432{
d3829fad
DH		 433 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
434
2d700715 435 buf->vb.sequence = dev->v4l2->field_count++;
662c97cf 436 if (dev->v4l2->progressive)
2d700715 437 buf->vb.field = V4L2_FIELD_NONE;
662c97cf 438 else
2d700715 439 buf->vb.field = V4L2_FIELD_INTERLACED;
d6dd645e 440 buf->vb.vb2_buf.timestamp = ktime_get_ns();
d3829fad 441
2d700715 442 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
ad0ebb96
MCC		 443}
444
445/*
36016a35 446 * Copy picture data from USB buffer to videobuf buffer
ad0ebb96
MCC		 447 */
448static void em28xx_copy_video(struct em28xx *dev,
ad0ebb96 449 struct em28xx_buffer *buf,
36016a35 450 unsigned char *usb_buf,
4078d625 451 unsigned long len)
ad0ebb96 452{
58159171 453 struct em28xx_v4l2 *v4l2 = dev->v4l2;
ad0ebb96 454 void *fieldstart, *startwrite, *startread;
f245e549 455 int linesdone, currlinedone, offset, lencopy, remain;
58159171 456 int bytesperline = v4l2->width << 1;
ad0ebb96 457
d3829fad
DH		 458 if (buf->pos + len > buf->length)
459 len = buf->length - buf->pos;
ad0ebb96 460
36016a35 461 startread = usb_buf;
ad0ebb96
MCC		 462 remain = len;
463
58159171 464 if (v4l2->progressive || buf->top_field)
36016a35 465 fieldstart = buf->vb_buf;
c02ec71b 466 else /* interlaced mode, even nr. of lines */
36016a35 467 fieldstart = buf->vb_buf + bytesperline;
ad0ebb96 468
8732533b
FS		 469 linesdone = buf->pos / bytesperline;
470 currlinedone = buf->pos % bytesperline;
c2a6b54a 471
58159171 472 if (v4l2->progressive)
c2a6b54a
MCC		 473 offset = linesdone * bytesperline + currlinedone;
474 else
475 offset = linesdone * bytesperline * 2 + currlinedone;
476
ad0ebb96 477 startwrite = fieldstart + offset;
44dc733c 478 lencopy = bytesperline - currlinedone;
ad0ebb96
MCC		 479 lencopy = lencopy > remain ? remain : lencopy;
480
d3829fad 481 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
7983b773 482 em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n",
fdf1bc9f 483 ((char *)startwrite + lencopy) -
d3829fad
DH		 484 ((char *)buf->vb_buf + buf->length));
485 remain = (char *)buf->vb_buf + buf->length -
36016a35 486 (char *)startwrite;
a1a6ee74 487 lencopy = remain;
d7aa8020 488 }
e0fadfd3
AT		 489 if (lencopy <= 0)
490 return;
d7aa8020 491 memcpy(startwrite, startread, lencopy);
ad0ebb96
MCC		 492
493 remain -= lencopy;
494
495 while (remain > 0) {
58159171 496 if (v4l2->progressive)
c02ec71b
FS		 497 startwrite += lencopy;
498 else
499 startwrite += lencopy + bytesperline;
ad0ebb96 500 startread += lencopy;
44dc733c 501 if (bytesperline > remain)
ad0ebb96
MCC		 502 lencopy = remain;
503 else
44dc733c 504 lencopy = bytesperline;
ad0ebb96 505
36016a35 506 if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
d3829fad 507 buf->length) {
7983b773 508 em28xx_isocdbg("Overflow of %zu bytes past buffer end"
e3ba4d34 509 "(2)\n",
f245e549 510 ((char *)startwrite + lencopy) -
d3829fad
DH		 511 ((char *)buf->vb_buf + buf->length));
512 lencopy = remain = (char *)buf->vb_buf + buf->length -
513 (char *)startwrite;
d7aa8020 514 }
f245e549
MCC		 515 if (lencopy <= 0)
516 break;
d7aa8020
AT		 517
518 memcpy(startwrite, startread, lencopy);
ad0ebb96
MCC		 519
520 remain -= lencopy;
521 }
522
8732533b 523 buf->pos += len;
ad0ebb96
MCC		 524}
525
36016a35
FS		 526/*
527 * Copy VBI data from USB buffer to videobuf buffer
528 */
28abf083 529static void em28xx_copy_vbi(struct em28xx *dev,
8732533b 530 struct em28xx_buffer *buf,
36016a35 531 unsigned char *usb_buf,
4078d625 532 unsigned long len)
28abf083 533{
36016a35 534 unsigned int offset;
28abf083 535
d3829fad
DH		 536 if (buf->pos + len > buf->length)
537 len = buf->length - buf->pos;
28abf083 538
8732533b 539 offset = buf->pos;
28abf083 540 /* Make sure the bottom field populates the second half of the frame */
36016a35 541 if (buf->top_field == 0)
753aee77 542 offset += dev->v4l2->vbi_width * dev->v4l2->vbi_height;
28abf083 543
36016a35 544 memcpy(buf->vb_buf + offset, usb_buf, len);
8732533b 545 buf->pos += len;
28abf083
DH		 546}
547
f245e549 548static inline void print_err_status(struct em28xx *dev,
fdf1bc9f 549 int packet, int status)
ad0ebb96
MCC		 550{
551 char *errmsg = "Unknown";
552
f245e549 553 switch (status) {
ad0ebb96
MCC		 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 }
f245e549 579 if (packet < 0) {
ad0ebb96
MCC		 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/*
24a6d849 588 * get the next available buffer from dma queue
ad0ebb96 589 */
24a6d849
FS		 590static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
591 struct em28xx_dmaqueue *dma_q)
ad0ebb96 592{
24a6d849 593 struct em28xx_buffer *buf;
ad0ebb96 594
dbecb44c
MCC		 595 if (list_empty(&dma_q->active)) {
596 em28xx_isocdbg("No active queue to serve\n");
24a6d849 597 return NULL;
28abf083
DH		 598 }
599
600 /* Get the next buffer */
d3829fad 601 buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
25985edc 602 /* Cleans up buffer - Useful for testing for frame/URB loss */
d3829fad 603 list_del(&buf->list);
8732533b 604 buf->pos = 0;
d3829fad 605 buf->vb_buf = buf->mem;
cb784724 606
24a6d849 607 return buf;
ad0ebb96
MCC		 608}
609
e04c00d9
FS		 610/*
611 * Finish the current buffer if completed and prepare for the next field
612 */
613static struct em28xx_buffer *
614finish_field_prepare_next(struct em28xx *dev,
615 struct em28xx_buffer *buf,
616 struct em28xx_dmaqueue *dma_q)
617{
58159171
FS		 618 struct em28xx_v4l2 *v4l2 = dev->v4l2;
619
f0e38230 620 if (v4l2->progressive || v4l2->top_field) { /* Brand new frame */
e04c00d9
FS		 621 if (buf != NULL)
622 finish_buffer(dev, buf);
623 buf = get_next_buf(dev, dma_q);
624 }
625 if (buf != NULL) {
f0e38230 626 buf->top_field = v4l2->top_field;
e04c00d9
FS		 627 buf->pos = 0;
628 }
629
630 return buf;
631}
632
227b7c90
FS		 633/*
634 * Process data packet according to the em2710/em2750/em28xx frame data format
635 */
636static inline void process_frame_data_em28xx(struct em28xx *dev,
637 unsigned char *data_pkt,
638 unsigned int data_len)
da52a55c 639{
753aee77 640 struct em28xx_v4l2 *v4l2 = dev->v4l2;
227b7c90
FS		 641 struct em28xx_buffer *buf = dev->usb_ctl.vid_buf;
642 struct em28xx_buffer *vbi_buf = dev->usb_ctl.vbi_buf;
da52a55c 643 struct em28xx_dmaqueue *dma_q = &dev->vidq;
28abf083 644 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
227b7c90
FS		 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) */
f0e38230
FS		 660 v4l2->capture_type = 0;
661 v4l2->vbi_read = 0;
227b7c90 662 em28xx_isocdbg("VBI START HEADER !!!\n");
f0e38230 663 v4l2->top_field = !(data_pkt[2] & 1);
227b7c90
FS		 664 data_pkt += 4;
665 data_len -= 4;
666 } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
667 /* Field start (VBI disabled) */
f0e38230 668 v4l2->capture_type = 2;
227b7c90 669 em28xx_isocdbg("VIDEO START HEADER !!!\n");
f0e38230 670 v4l2->top_field = !(data_pkt[2] & 1);
227b7c90
FS		 671 data_pkt += 4;
672 data_len -= 4;
673 }
674 }
675 /* NOTE: With bulk transfers, intermediate data packets
676 * have no continuation header */
677
f0e38230 678 if (v4l2->capture_type == 0) {
227b7c90
FS		 679 vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
680 dev->usb_ctl.vbi_buf = vbi_buf;
f0e38230 681 v4l2->capture_type = 1;
227b7c90
FS		 682 }
683
f0e38230 684 if (v4l2->capture_type == 1) {
753aee77 685 int vbi_size = v4l2->vbi_width * v4l2->vbi_height;
f0e38230
FS		 686 int vbi_data_len = ((v4l2->vbi_read + data_len) > vbi_size) ?
687 (vbi_size - v4l2->vbi_read) : data_len;
227b7c90
FS		 688
689 /* Copy VBI data */
690 if (vbi_buf != NULL)
691 em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
f0e38230 692 v4l2->vbi_read += vbi_data_len;
227b7c90
FS		 693
694 if (vbi_data_len < data_len) {
695 /* Continue with copying video data */
f0e38230 696 v4l2->capture_type = 2;
227b7c90
FS		 697 data_pkt += vbi_data_len;
698 data_len -= vbi_data_len;
699 }
700 }
701
f0e38230 702 if (v4l2->capture_type == 2) {
227b7c90
FS		 703 buf = finish_field_prepare_next(dev, buf, dma_q);
704 dev->usb_ctl.vid_buf = buf;
f0e38230 705 v4l2->capture_type = 3;
227b7c90
FS		 706 }
707
f0e38230 708 if (v4l2->capture_type == 3 && buf != NULL && data_len > 0)
227b7c90
FS		 709 em28xx_copy_video(dev, buf, data_pkt, data_len);
710}
711
e507e0e5
FS		 712/*
713 * Process data packet according to the em25xx/em276x/7x/8x frame data format
714 */
715static 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;
f0e38230 721 struct em28xx_v4l2 *v4l2 = dev->v4l2;
7e6c8c19 722 bool frame_end = false;
e507e0e5
FS		 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)) {
f0e38230 730 v4l2->top_field = !(data_pkt[1] &
e507e0e5
FS		 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
227b7c90
FS		 769/* Processes and copies the URB data content (video and VBI data) */
770static 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;
da52a55c
DH		 775
776 if (!dev)
777 return 0;
778
2665c299 779 if (dev->disconnected)
da52a55c
DH		 780 return 0;
781
1653cb0c 782 if (urb->status < 0)
da52a55c 783 print_err_status(dev, -1, urb->status);
da52a55c 784
4601cc39
FS		 785 xfer_bulk = usb_pipebulk(urb->pipe);
786
4601cc39
FS		 787 if (xfer_bulk) /* bulk */
788 num_packets = 1;
789 else /* isoc */
790 num_packets = urb->number_of_packets;
da52a55c 791
4601cc39
FS		 792 for (i = 0; i < num_packets; i++) {
793 if (xfer_bulk) { /* bulk */
227b7c90 794 usb_data_len = urb->actual_length;
4601cc39 795
227b7c90 796 usb_data_pkt = urb->transfer_buffer;
4601cc39
FS		 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
227b7c90
FS		 805 usb_data_len = urb->iso_frame_desc[i].actual_length;
806 if (usb_data_len > dev->max_pkt_size) {
4601cc39 807 em28xx_isocdbg("packet bigger than packet size");
da52a55c 808 continue;
4601cc39 809 }
da52a55c 810
227b7c90
FS		 811 usb_data_pkt = urb->transfer_buffer +
812 urb->iso_frame_desc[i].offset;
da52a55c 813 }
4601cc39 814
227b7c90 815 if (usb_data_len == 0) {
4601cc39
FS		 816 /* NOTE: happens very often with isoc transfers */
817 /* em28xx_usbdbg("packet %d is empty",i); - spammy */
da52a55c
DH		 818 continue;
819 }
820
e507e0e5
FS		 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
da52a55c 828 }
227b7c90 829 return 1;
da52a55c
DH		 830}
831
d3829fad
DH		 832static 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();
d3829fad
DH		 841 }
842}
843
844/* Usage lock check functions */
845static 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
861static 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
ad0ebb96 869/* ------------------------------------------------------------------
d3829fad 870 Videobuf2 operations
ad0ebb96
MCC		 871 ------------------------------------------------------------------*/
872
df9ecb0c 873static int queue_setup(struct vb2_queue *vq,
d3829fad
DH		 874 unsigned int *nbuffers, unsigned int *nplanes,
875 unsigned int sizes[], void *alloc_ctxs[])
ad0ebb96 876{
d3829fad 877 struct em28xx *dev = vb2_get_drv_priv(vq);
753aee77 878 struct em28xx_v4l2 *v4l2 = dev->v4l2;
df9ecb0c 879 unsigned long size =
06e20672 880 (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
ad0ebb96 881
df9ecb0c
HV		 882 if (*nplanes)
883 return sizes[0] < size ? -EINVAL : 0;
d3829fad
DH		 884 *nplanes = 1;
885 sizes[0] = size;
ad0ebb96
MCC		 886 return 0;
887}
888
d3829fad
DH		 889static int
890buffer_prepare(struct vb2_buffer *vb)
ad0ebb96 891{
2d700715 892 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
d3829fad 893 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
753aee77 894 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d3829fad 895 unsigned long size;
ad0ebb96 896
2d700715 897 em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field);
3b5fa928 898
06e20672 899 size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
3b5fa928 900
d3829fad
DH		 901 if (vb2_plane_size(vb, 0) < size) {
902 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
903 __func__, vb2_plane_size(vb, 0), size);
904 return -EINVAL;
905 }
2d700715 906 vb2_set_plane_payload(vb, 0, size);
d3829fad
DH		 907
908 return 0;
ad0ebb96
MCC		 909}
910
d3829fad 911int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
ad0ebb96 912{
d3829fad 913 struct em28xx *dev = vb2_get_drv_priv(vq);
f0e38230 914 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d3829fad 915 struct v4l2_frequency f;
2d700715 916 struct v4l2_fh *owner;
d3829fad 917 int rc = 0;
ad0ebb96 918
d3829fad 919 em28xx_videodbg("%s\n", __func__);
ad0ebb96 920
d3829fad
DH		 921 /* Make sure streaming is not already in progress for this type
922 of filehandle (e.g. video, vbi) */
923 rc = res_get(dev, vq->type);
924 if (rc)
925 return rc;
ad0ebb96 926
8139a4d5 927 if (v4l2->streaming_users == 0) {
d3829fad 928 /* First active streaming user, so allocate all the URBs */
ad0ebb96 929
d3829fad
DH		 930 /* Allocate the USB bandwidth */
931 em28xx_set_alternate(dev);
ad0ebb96 932
d3829fad
DH		 933 /* Needed, since GPIO might have disabled power of
934 some i2c device
935 */
936 em28xx_wake_i2c(dev);
ad0ebb96 937
f0e38230 938 v4l2->capture_type = -1;
960da93b
FS		 939 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
940 dev->analog_xfer_bulk,
941 EM28XX_NUM_BUFS,
942 dev->max_pkt_size,
943 dev->packet_multiplier,
944 em28xx_urb_data_copy);
f245e549 945 if (rc < 0)
032f1ddf 946 return rc;
ad0ebb96 947
d3829fad
DH		 948 /*
949 * djh: it's not clear whether this code is still needed. I'm
950 * leaving it in here for now entirely out of concern for
951 * backward compatibility (the old code did it)
952 */
953
954 /* Ask tuner to go to analog or radio mode */
955 memset(&f, 0, sizeof(f));
3854b0d8 956 f.frequency = v4l2->frequency;
2d700715
JS		 957 owner = (struct v4l2_fh *)vq->owner;
958 if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO)
d3829fad
DH		 959 f.type = V4L2_TUNER_RADIO;
960 else
961 f.type = V4L2_TUNER_ANALOG_TV;
f0e38230 962 v4l2_device_call_all(&v4l2->v4l2_dev,
95d2608b 963 0, tuner, s_frequency, &f);
13d52fe4
MCC		 964
965 /* Enable video stream at TV decoder */
966 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1);
d3829fad 967 }
ad0ebb96 968
8139a4d5 969 v4l2->streaming_users++;
032f1ddf 970
ad0ebb96
MCC		 971 return rc;
972}
973
e37559b2 974static void em28xx_stop_streaming(struct vb2_queue *vq)
d3829fad
DH		 975{
976 struct em28xx *dev = vb2_get_drv_priv(vq);
8139a4d5 977 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d3829fad
DH		 978 struct em28xx_dmaqueue *vidq = &dev->vidq;
979 unsigned long flags = 0;
980
981 em28xx_videodbg("%s\n", __func__);
982
983 res_free(dev, vq->type);
984
8139a4d5 985 if (v4l2->streaming_users-- == 1) {
13d52fe4
MCC		 986 /* Disable video stream at TV decoder */
987 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
988
d3829fad
DH		 989 /* Last active user, so shutdown all the URBS */
990 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
991 }
992
993 spin_lock_irqsave(&dev->slock, flags);
627530c3 994 if (dev->usb_ctl.vid_buf != NULL) {
2d700715
JS		 995 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf,
996 VB2_BUF_STATE_ERROR);
627530c3
FS		 997 dev->usb_ctl.vid_buf = NULL;
998 }
d3829fad
DH		 999 while (!list_empty(&vidq->active)) {
1000 struct em28xx_buffer *buf;
fdf1bc9f 1001
d3829fad
DH		 1002 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
1003 list_del(&buf->list);
2d700715 1004 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
d3829fad 1005 }
d3829fad 1006 spin_unlock_irqrestore(&dev->slock, flags);
d3829fad
DH		 1007}
1008
e37559b2 1009void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
ad0ebb96 1010{
d3829fad 1011 struct em28xx *dev = vb2_get_drv_priv(vq);
8139a4d5 1012 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d3829fad
DH		 1013 struct em28xx_dmaqueue *vbiq = &dev->vbiq;
1014 unsigned long flags = 0;
1015
1016 em28xx_videodbg("%s\n", __func__);
1017
1018 res_free(dev, vq->type);
ad0ebb96 1019
8139a4d5 1020 if (v4l2->streaming_users-- == 1) {
13d52fe4
MCC		 1021 /* Disable video stream at TV decoder */
1022 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
1023
d3829fad
DH		 1024 /* Last active user, so shutdown all the URBS */
1025 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1026 }
1027
1028 spin_lock_irqsave(&dev->slock, flags);
627530c3 1029 if (dev->usb_ctl.vbi_buf != NULL) {
2d700715
JS		 1030 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf,
1031 VB2_BUF_STATE_ERROR);
627530c3
FS		 1032 dev->usb_ctl.vbi_buf = NULL;
1033 }
d3829fad
DH		 1034 while (!list_empty(&vbiq->active)) {
1035 struct em28xx_buffer *buf;
fdf1bc9f 1036
d3829fad
DH		 1037 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
1038 list_del(&buf->list);
2d700715 1039 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
d3829fad 1040 }
d3829fad 1041 spin_unlock_irqrestore(&dev->slock, flags);
ad0ebb96
MCC		 1042}
1043
d3829fad
DH		 1044static void
1045buffer_queue(struct vb2_buffer *vb)
ad0ebb96 1046{
2d700715 1047 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
d3829fad 1048 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
2d700715
JS		 1049 struct em28xx_buffer *buf =
1050 container_of(vbuf, struct em28xx_buffer, vb);
d3829fad
DH		 1051 struct em28xx_dmaqueue *vidq = &dev->vidq;
1052 unsigned long flags = 0;
ad0ebb96 1053
d3829fad
DH		 1054 em28xx_videodbg("%s\n", __func__);
1055 buf->mem = vb2_plane_vaddr(vb, 0);
1056 buf->length = vb2_plane_size(vb, 0);
ad0ebb96 1057
d3829fad
DH		 1058 spin_lock_irqsave(&dev->slock, flags);
1059 list_add_tail(&buf->list, &vidq->active);
1060 spin_unlock_irqrestore(&dev->slock, flags);
ad0ebb96
MCC		 1061}
1062
d3829fad
DH		 1063static struct vb2_ops em28xx_video_qops = {
1064 .queue_setup = queue_setup,
ad0ebb96
MCC		 1065 .buf_prepare = buffer_prepare,
1066 .buf_queue = buffer_queue,
d3829fad
DH		 1067 .start_streaming = em28xx_start_analog_streaming,
1068 .stop_streaming = em28xx_stop_streaming,
1069 .wait_prepare = vb2_ops_wait_prepare,
1070 .wait_finish = vb2_ops_wait_finish,
ad0ebb96 1071};
a6c2ba28 1072
01c28193 1073static int em28xx_vb2_setup(struct em28xx *dev)
d3829fad
DH		 1074{
1075 int rc;
1076 struct vb2_queue *q;
27a36df6 1077 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d3829fad
DH		 1078
1079 /* Setup Videobuf2 for Video capture */
27a36df6 1080 q = &v4l2->vb_vidq;
d3829fad 1081 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ef85cd9c 1082 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
ade48681 1083 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
d3829fad
DH		 1084 q->drv_priv = dev;
1085 q->buf_struct_size = sizeof(struct em28xx_buffer);
1086 q->ops = &em28xx_video_qops;
1087 q->mem_ops = &vb2_vmalloc_memops;
1088
1089 rc = vb2_queue_init(q);
1090 if (rc < 0)
1091 return rc;
1092
1093 /* Setup Videobuf2 for VBI capture */
27a36df6 1094 q = &v4l2->vb_vbiq;
d3829fad
DH		 1095 q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1096 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
ade48681 1097 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
d3829fad
DH		 1098 q->drv_priv = dev;
1099 q->buf_struct_size = sizeof(struct em28xx_buffer);
1100 q->ops = &em28xx_vbi_qops;
1101 q->mem_ops = &vb2_vmalloc_memops;
1102
1103 rc = vb2_queue_init(q);
1104 if (rc < 0)
1105 return rc;
1106
1107 return 0;
1108}
1109
6ea54d93 1110/********************* v4l2 interface **************************************/
a6c2ba28 1111
eac94356
MCC		 1112static void video_mux(struct em28xx *dev, int index)
1113{
95d2608b 1114 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
fdf1bc9f 1115
eac94356
MCC		 1116 dev->ctl_input = index;
1117 dev->ctl_ainput = INPUT(index)->amux;
35ae6f04 1118 dev->ctl_aoutput = INPUT(index)->aout;
eac94356 1119
e879b8eb
MCC		 1120 if (!dev->ctl_aoutput)
1121 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1122
95d2608b 1123 v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
fdf1bc9f 1124 INPUT(index)->vmux, 0, 0);
eac94356 1125
505b6d0b 1126 if (dev->board.has_msp34xx) {
6ea54d93 1127 if (dev->i2s_speed) {
95d2608b 1128 v4l2_device_call_all(v4l2_dev, 0, audio,
fdf1bc9f 1129 s_i2s_clock_freq, dev->i2s_speed);
6ea54d93 1130 }
2474ed44 1131 /* Note: this is msp3400 specific */
95d2608b 1132 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
fdf1bc9f
MCC		 1133 dev->ctl_ainput,
1134 MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
eac94356 1135 }
539c96d0 1136
2bd1d9eb 1137 if (dev->board.adecoder != EM28XX_NOADECODER) {
95d2608b 1138 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
fdf1bc9f 1139 dev->ctl_ainput, dev->ctl_aoutput, 0);
2bd1d9eb
VW		 1140 }
1141
00b8730f 1142 em28xx_audio_analog_set(dev);
eac94356
MCC		 1143}
1144
01c28193 1145static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
a98f6af9 1146{
081b945e 1147 struct em28xx *dev = priv;
a98f6af9 1148
081b945e
HV		 1149 /*
1150 * In the case of non-AC97 volume controls, we still need
1151 * to do some setups at em28xx, in order to mute/unmute
1152 * and to adjust audio volume. However, the value ranges
1153 * should be checked by the corresponding V4L subdriver.
1154 */
195a4ef6
MCC		 1155 switch (ctrl->id) {
1156 case V4L2_CID_AUDIO_MUTE:
081b945e
HV		 1157 dev->mute = ctrl->val;
1158 em28xx_audio_analog_set(dev);
1159 break;
195a4ef6 1160 case V4L2_CID_AUDIO_VOLUME:
081b945e
HV		 1161 dev->volume = ctrl->val;
1162 em28xx_audio_analog_set(dev);
1163 break;
a6c2ba28 1164 }
195a4ef6 1165}
a6c2ba28 1166
081b945e 1167static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
195a4ef6 1168{
abc1308f
FS		 1169 struct em28xx_v4l2 *v4l2 =
1170 container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler);
1171 struct em28xx *dev = v4l2->dev;
8f8b113a 1172 int ret = -EINVAL;
a98f6af9 1173
195a4ef6
MCC		 1174 switch (ctrl->id) {
1175 case V4L2_CID_AUDIO_MUTE:
081b945e 1176 dev->mute = ctrl->val;
8f8b113a 1177 ret = em28xx_audio_analog_set(dev);
a98f6af9 1178 break;
195a4ef6 1179 case V4L2_CID_AUDIO_VOLUME:
081b945e 1180 dev->volume = ctrl->val;
8f8b113a
FS		 1181 ret = em28xx_audio_analog_set(dev);
1182 break;
1183 case V4L2_CID_CONTRAST:
1184 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1185 break;
1186 case V4L2_CID_BRIGHTNESS:
1187 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1188 break;
1189 case V4L2_CID_SATURATION:
1190 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1191 break;
1192 case V4L2_CID_BLUE_BALANCE:
1193 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1194 break;
1195 case V4L2_CID_RED_BALANCE:
1196 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1197 break;
1198 case V4L2_CID_SHARPNESS:
1199 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
a98f6af9 1200 break;
195a4ef6 1201 }
a98f6af9 1202
8f8b113a 1203 return (ret < 0) ? ret : 0;
195a4ef6 1204}
a6c2ba28 1205
8068eb88 1206static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
081b945e
HV		 1207 .s_ctrl = em28xx_s_ctrl,
1208};
1209
6b09a21c 1210static void size_to_scale(struct em28xx *dev,
fdf1bc9f 1211 unsigned int width, unsigned int height,
195a4ef6
MCC		 1212 unsigned int *hscale, unsigned int *vscale)
1213{
55699964
MCC		 1214 unsigned int maxw = norm_maxw(dev);
1215 unsigned int maxh = norm_maxh(dev);
195a4ef6
MCC		 1216
1217 *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
81685327
FS		 1218 if (*hscale > EM28XX_HVSCALE_MAX)
1219 *hscale = EM28XX_HVSCALE_MAX;
195a4ef6
MCC		 1220
1221 *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
81685327
FS		 1222 if (*vscale > EM28XX_HVSCALE_MAX)
1223 *vscale = EM28XX_HVSCALE_MAX;
a6c2ba28 1224}
1225
b8374138
FS		 1226static void scale_to_size(struct em28xx *dev,
1227 unsigned int hscale, unsigned int vscale,
1228 unsigned int *width, unsigned int *height)
1229{
1230 unsigned int maxw = norm_maxw(dev);
1231 unsigned int maxh = norm_maxh(dev);
1232
1233 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1234 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1235}
1236
195a4ef6
MCC		 1237/* ------------------------------------------------------------------
1238 IOCTL vidioc handling
1239 ------------------------------------------------------------------*/
1240
78b526a4 1241static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1242 struct v4l2_format *f)
a6c2ba28 1243{
917ba6b0 1244 struct em28xx *dev = video_drvdata(file);
753aee77 1245 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1246
753aee77
FS		 1247 f->fmt.pix.width = v4l2->width;
1248 f->fmt.pix.height = v4l2->height;
06e20672
FS		 1249 f->fmt.pix.pixelformat = v4l2->format->fourcc;
1250 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
753aee77 1251 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
195a4ef6 1252 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
e5589bef 1253
195a4ef6 1254 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
58159171 1255 if (v4l2->progressive)
c2a6b54a
MCC		 1256 f->fmt.pix.field = V4L2_FIELD_NONE;
1257 else
58159171 1258 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
195a4ef6 1259 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
195a4ef6 1260 return 0;
a6c2ba28 1261}
1262
bddcf633
MCC		 1263static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1264{
1265 unsigned int i;
1266
1267 for (i = 0; i < ARRAY_SIZE(format); i++)
1268 if (format[i].fourcc == fourcc)
1269 return &format[i];
1270
1271 return NULL;
1272}
1273
78b526a4 1274static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1275 struct v4l2_format *f)
a6c2ba28 1276{
917ba6b0 1277 struct em28xx *dev = video_drvdata(file);
58159171 1278 struct em28xx_v4l2 *v4l2 = dev->v4l2;
ccb83408
TP		 1279 unsigned int width = f->fmt.pix.width;
1280 unsigned int height = f->fmt.pix.height;
195a4ef6
MCC		 1281 unsigned int maxw = norm_maxw(dev);
1282 unsigned int maxh = norm_maxh(dev);
1283 unsigned int hscale, vscale;
bddcf633
MCC		 1284 struct em28xx_fmt *fmt;
1285
1286 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1287 if (!fmt) {
1288 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1289 f->fmt.pix.pixelformat);
1290 return -EINVAL;
1291 }
195a4ef6 1292
55699964 1293 if (dev->board.is_em2800) {
195a4ef6 1294 /* the em2800 can only scale down to 50% */
ccb83408
TP		 1295 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1296 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
d3829fad
DH		 1297 /*
1298 * MaxPacketSize for em2800 is too small to capture at full
1299 * resolution use half of maxw as the scaler can only scale
1300 * to 50%
1301 */
1020d13d
SS		 1302 if (width == maxw && height == maxh)
1303 width /= 2;
ccb83408
TP		 1304 } else {
1305 /* width must even because of the YUYV format
1306 height must be even because of interlacing */
e3ba4d34
DH		 1307 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1308 1, 0);
195a4ef6 1309 }
a225452e 1310
6b09a21c 1311 size_to_scale(dev, width, height, &hscale, &vscale);
46f85978 1312 scale_to_size(dev, hscale, vscale, &width, &height);
a6c2ba28 1313
195a4ef6
MCC		 1314 f->fmt.pix.width = width;
1315 f->fmt.pix.height = height;
bddcf633 1316 f->fmt.pix.pixelformat = fmt->fourcc;
e6066dba 1317 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
bddcf633 1318 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
195a4ef6 1319 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
58159171 1320 if (v4l2->progressive)
c2a6b54a
MCC		 1321 f->fmt.pix.field = V4L2_FIELD_NONE;
1322 else
58159171 1323 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
c2a6b54a 1324 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
51dd4d70 1325 f->fmt.pix.priv = 0;
a6c2ba28 1326
a6c2ba28 1327 return 0;
1328}
1329
ed5f1431
MCC		 1330static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1331 unsigned width, unsigned height)
1332{
1333 struct em28xx_fmt *fmt;
753aee77 1334 struct em28xx_v4l2 *v4l2 = dev->v4l2;
ed5f1431 1335
ed5f1431
MCC		 1336 fmt = format_by_fourcc(fourcc);
1337 if (!fmt)
1338 return -EINVAL;
1339
06e20672 1340 v4l2->format = fmt;
753aee77
FS		 1341 v4l2->width = width;
1342 v4l2->height = height;
ed5f1431
MCC		 1343
1344 /* set new image size */
753aee77 1345 size_to_scale(dev, v4l2->width, v4l2->height,
fdf1bc9f 1346 &v4l2->hscale, &v4l2->vscale);
ed5f1431 1347
ed5f1431
MCC		 1348 em28xx_resolution_set(dev);
1349
1350 return 0;
1351}
1352
78b526a4 1353static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1354 struct v4l2_format *f)
a6c2ba28 1355{
d3829fad 1356 struct em28xx *dev = video_drvdata(file);
8139a4d5 1357 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1358
c7854c2c 1359 if (vb2_is_busy(&v4l2->vb_vidq))
d3829fad 1360 return -EBUSY;
a225452e 1361
efc52a94
MCC		 1362 vidioc_try_fmt_vid_cap(file, priv, f);
1363
0499a5aa 1364 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
ed5f1431 1365 f->fmt.pix.width, f->fmt.pix.height);
195a4ef6
MCC		 1366}
1367
19bf0038
DH		 1368static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1369{
917ba6b0 1370 struct em28xx *dev = video_drvdata(file);
19bf0038 1371
52faaf78 1372 *norm = dev->v4l2->norm;
19bf0038
DH		 1373
1374 return 0;
1375}
1376
d56ae6fb
MCC		 1377static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1378{
917ba6b0 1379 struct em28xx *dev = video_drvdata(file);
d56ae6fb 1380
95d2608b 1381 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
d56ae6fb
MCC		 1382
1383 return 0;
1384}
1385
314527ac 1386static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
195a4ef6 1387{
917ba6b0 1388 struct em28xx *dev = video_drvdata(file);
753aee77 1389 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6 1390 struct v4l2_format f;
195a4ef6 1391
52faaf78 1392 if (norm == v4l2->norm)
d8c95c08 1393 return 0;
195a4ef6 1394
8139a4d5 1395 if (v4l2->streaming_users > 0)
d8c95c08 1396 return -EBUSY;
d8c95c08 1397
52faaf78 1398 v4l2->norm = norm;
a6c2ba28 1399
195a4ef6 1400 /* Adjusts width/height, if needed */
d8c95c08 1401 f.fmt.pix.width = 720;
314527ac 1402 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
78b526a4 1403 vidioc_try_fmt_vid_cap(file, priv, &f);
a6c2ba28 1404
195a4ef6 1405 /* set new image size */
753aee77
FS		 1406 v4l2->width = f.fmt.pix.width;
1407 v4l2->height = f.fmt.pix.height;
1408 size_to_scale(dev, v4l2->width, v4l2->height,
fdf1bc9f 1409 &v4l2->hscale, &v4l2->vscale);
a6c2ba28 1410
195a4ef6 1411 em28xx_resolution_set(dev);
8774bed9 1412 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
a6c2ba28 1413
195a4ef6
MCC		 1414 return 0;
1415}
9e31ced8 1416
d96ecda6
MCC		 1417static int vidioc_g_parm(struct file *file, void *priv,
1418 struct v4l2_streamparm *p)
1419{
917ba6b0 1420 struct em28xx *dev = video_drvdata(file);
52faaf78 1421 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d96ecda6
MCC		 1422 int rc = 0;
1423
86ff7f1d 1424 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
d96ecda6 1425 if (dev->board.is_webcam)
52faaf78 1426 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
d96ecda6
MCC		 1427 video, g_parm, p);
1428 else
52faaf78 1429 v4l2_video_std_frame_period(v4l2->norm,
fdf1bc9f 1430 &p->parm.capture.timeperframe);
d96ecda6
MCC		 1431
1432 return rc;
1433}
1434
1435static int vidioc_s_parm(struct file *file, void *priv,
1436 struct v4l2_streamparm *p)
1437{
917ba6b0 1438 struct em28xx *dev = video_drvdata(file);
d96ecda6 1439
86ff7f1d 1440 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
95d2608b
FS		 1441 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1442 0, video, s_parm, p);
d96ecda6
MCC		 1443}
1444
195a4ef6
MCC		 1445static const char *iname[] = {
1446 [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1447 [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1448 [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1449 [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1450 [EM28XX_VMUX_SVIDEO] = "S-Video",
1451 [EM28XX_VMUX_TELEVISION] = "Television",
1452 [EM28XX_VMUX_CABLE] = "Cable TV",
1453 [EM28XX_VMUX_DVB] = "DVB",
1454 [EM28XX_VMUX_DEBUG] = "for debug only",
1455};
9e31ced8 1456
195a4ef6 1457static int vidioc_enum_input(struct file *file, void *priv,
fdf1bc9f 1458 struct v4l2_input *i)
195a4ef6 1459{
917ba6b0 1460 struct em28xx *dev = video_drvdata(file);
195a4ef6 1461 unsigned int n;
9e31ced8 1462
195a4ef6
MCC		 1463 n = i->index;
1464 if (n >= MAX_EM28XX_INPUT)
1465 return -EINVAL;
1466 if (0 == INPUT(n)->type)
1467 return -EINVAL;
9e31ced8 1468
195a4ef6
MCC		 1469 i->index = n;
1470 i->type = V4L2_INPUT_TYPE_CAMERA;
a6c2ba28 1471
195a4ef6 1472 strcpy(i->name, iname[INPUT(n)->type]);
a6c2ba28 1473
195a4ef6 1474 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
fdf1bc9f 1475 (EM28XX_VMUX_CABLE == INPUT(n)->type))
195a4ef6
MCC		 1476 i->type = V4L2_INPUT_TYPE_TUNER;
1477
d4352f36 1478 i->std = dev->v4l2->vdev.tvnorms;
d8c95c08
HV		 1479 /* webcams do not have the STD API */
1480 if (dev->board.is_webcam)
1481 i->capabilities = 0;
195a4ef6
MCC		 1482
1483 return 0;
a6c2ba28 1484}
1485
195a4ef6 1486static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
a6c2ba28 1487{
917ba6b0 1488 struct em28xx *dev = video_drvdata(file);
a6c2ba28 1489
195a4ef6
MCC		 1490 *i = dev->ctl_input;
1491
1492 return 0;
1493}
1494
1495static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1496{
917ba6b0 1497 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1498
1499 if (i >= MAX_EM28XX_INPUT)
1500 return -EINVAL;
1501 if (0 == INPUT(i)->type)
1502 return -EINVAL;
a225452e 1503
96371fc8 1504 video_mux(dev, i);
195a4ef6
MCC		 1505 return 0;
1506}
1507
1508static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1509{
917ba6b0 1510 struct em28xx *dev = video_drvdata(file);
195a4ef6 1511
35ae6f04
MCC		 1512 switch (a->index) {
1513 case EM28XX_AMUX_VIDEO:
195a4ef6 1514 strcpy(a->name, "Television");
35ae6f04
MCC		 1515 break;
1516 case EM28XX_AMUX_LINE_IN:
195a4ef6 1517 strcpy(a->name, "Line In");
35ae6f04
MCC		 1518 break;
1519 case EM28XX_AMUX_VIDEO2:
1520 strcpy(a->name, "Television alt");
1521 break;
1522 case EM28XX_AMUX_PHONE:
1523 strcpy(a->name, "Phone");
1524 break;
1525 case EM28XX_AMUX_MIC:
1526 strcpy(a->name, "Mic");
1527 break;
1528 case EM28XX_AMUX_CD:
1529 strcpy(a->name, "CD");
1530 break;
1531 case EM28XX_AMUX_AUX:
1532 strcpy(a->name, "Aux");
1533 break;
1534 case EM28XX_AMUX_PCM_OUT:
1535 strcpy(a->name, "PCM");
1536 break;
1537 default:
1538 return -EINVAL;
1539 }
6ea54d93 1540
35ae6f04 1541 a->index = dev->ctl_ainput;
195a4ef6 1542 a->capability = V4L2_AUDCAP_STEREO;
195a4ef6
MCC		 1543
1544 return 0;
1545}
1546
0e8025b9 1547static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
195a4ef6 1548{
917ba6b0 1549 struct em28xx *dev = video_drvdata(file);
195a4ef6 1550
24c3c415
MCC		 1551 if (a->index >= MAX_EM28XX_INPUT)
1552 return -EINVAL;
1553 if (0 == INPUT(a->index)->type)
1554 return -EINVAL;
1555
35ae6f04
MCC		 1556 dev->ctl_ainput = INPUT(a->index)->amux;
1557 dev->ctl_aoutput = INPUT(a->index)->aout;
e879b8eb
MCC		 1558
1559 if (!dev->ctl_aoutput)
1560 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
efc52a94 1561
195a4ef6
MCC		 1562 return 0;
1563}
1564
195a4ef6 1565static int vidioc_g_tuner(struct file *file, void *priv,
fdf1bc9f 1566 struct v4l2_tuner *t)
a6c2ba28 1567{
917ba6b0 1568 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1569
1570 if (0 != t->index)
1571 return -EINVAL;
1572
1573 strcpy(t->name, "Tuner");
1574
95d2608b 1575 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
195a4ef6 1576 return 0;
a6c2ba28 1577}
1578
195a4ef6 1579static int vidioc_s_tuner(struct file *file, void *priv,
fdf1bc9f 1580 const struct v4l2_tuner *t)
a6c2ba28 1581{
917ba6b0 1582 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1583
1584 if (0 != t->index)
1585 return -EINVAL;
1586
95d2608b 1587 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
195a4ef6 1588 return 0;
a6c2ba28 1589}
1590
195a4ef6 1591static int vidioc_g_frequency(struct file *file, void *priv,
fdf1bc9f 1592 struct v4l2_frequency *f)
195a4ef6 1593{
917ba6b0 1594 struct em28xx *dev = video_drvdata(file);
3854b0d8 1595 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1596
20deebfe
HV		 1597 if (0 != f->tuner)
1598 return -EINVAL;
1599
3854b0d8 1600 f->frequency = v4l2->frequency;
195a4ef6
MCC		 1601 return 0;
1602}
1603
1604static int vidioc_s_frequency(struct file *file, void *priv,
fdf1bc9f 1605 const struct v4l2_frequency *f)
a6c2ba28 1606{
95d2608b 1607 struct v4l2_frequency new_freq = *f;
917ba6b0 1608 struct em28xx *dev = video_drvdata(file);
95d2608b 1609 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6
MCC		 1610
1611 if (0 != f->tuner)
1612 return -EINVAL;
1613
95d2608b
FS		 1614 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1615 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
3854b0d8 1616 v4l2->frequency = new_freq.frequency;
a6c2ba28 1617
195a4ef6
MCC		 1618 return 0;
1619}
a6c2ba28 1620
cd634f1b 1621#ifdef CONFIG_VIDEO_ADV_DEBUG
96b03d2a 1622static int vidioc_g_chip_info(struct file *file, void *priv,
fdf1bc9f 1623 struct v4l2_dbg_chip_info *chip)
3b2d17b4 1624{
917ba6b0 1625 struct em28xx *dev = video_drvdata(file);
3b2d17b4
HV		 1626
1627 if (chip->match.addr > 1)
1628 return -EINVAL;
1629 if (chip->match.addr == 1)
1630 strlcpy(chip->name, "ac97", sizeof(chip->name));
1631 else
95d2608b
FS		 1632 strlcpy(chip->name,
1633 dev->v4l2->v4l2_dev.name, sizeof(chip->name));
3b2d17b4
HV		 1634 return 0;
1635}
1636
35deba32
FS		 1637static int em28xx_reg_len(int reg)
1638{
1639 switch (reg) {
1640 case EM28XX_R40_AC97LSB:
1641 case EM28XX_R30_HSCALELOW:
1642 case EM28XX_R32_VSCALELOW:
1643 return 2;
1644 default:
1645 return 1;
1646 }
1647}
14983d81 1648
1e7ad56f 1649static int vidioc_g_register(struct file *file, void *priv,
aecde8b5 1650 struct v4l2_dbg_register *reg)
1e7ad56f 1651{
917ba6b0 1652 struct em28xx *dev = video_drvdata(file);
1e7ad56f
MCC		 1653 int ret;
1654
abca2056
HV		 1655 if (reg->match.addr > 1)
1656 return -EINVAL;
1657 if (reg->match.addr) {
531c98e7 1658 ret = em28xx_read_ac97(dev, reg->reg);
531c98e7
MCC		 1659 if (ret < 0)
1660 return ret;
1661
1662 reg->val = ret;
aecde8b5 1663 reg->size = 1;
531c98e7 1664 return 0;
14983d81 1665 }
1e7ad56f 1666
14983d81 1667 /* Match host */
aecde8b5
HV		 1668 reg->size = em28xx_reg_len(reg->reg);
1669 if (reg->size == 1) {
1e7ad56f 1670 ret = em28xx_read_reg(dev, reg->reg);
efc52a94 1671
1e7ad56f
MCC		 1672 if (ret < 0)
1673 return ret;
1674
1675 reg->val = ret;
1676 } else {
aecde8b5 1677 __le16 val = 0;
fdf1bc9f 1678
01c28193 1679 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1e7ad56f
MCC		 1680 reg->reg, (char *)&val, 2);
1681 if (ret < 0)
1682 return ret;
1683
aecde8b5 1684 reg->val = le16_to_cpu(val);
1e7ad56f
MCC		 1685 }
1686
1687 return 0;
1688}
1689
1690static int vidioc_s_register(struct file *file, void *priv,
977ba3b1 1691 const struct v4l2_dbg_register *reg)
1e7ad56f 1692{
917ba6b0 1693 struct em28xx *dev = video_drvdata(file);
aecde8b5 1694 __le16 buf;
1e7ad56f 1695
abca2056 1696 if (reg->match.addr > 1)
3b2d17b4 1697 return -EINVAL;
abca2056
HV		 1698 if (reg->match.addr)
1699 return em28xx_write_ac97(dev, reg->reg, reg->val);
531c98e7 1700
14983d81 1701 /* Match host */
aecde8b5 1702 buf = cpu_to_le16(reg->val);
1e7ad56f 1703
0499a5aa 1704 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
efc52a94 1705 em28xx_reg_len(reg->reg));
1e7ad56f
MCC		 1706}
1707#endif
1708
195a4ef6 1709static int vidioc_querycap(struct file *file, void *priv,
fdf1bc9f 1710 struct v4l2_capability *cap)
a6c2ba28 1711{
ef74a0b9 1712 struct video_device *vdev = video_devdata(file);
917ba6b0 1713 struct em28xx *dev = video_drvdata(file);
ef74a0b9 1714 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6
MCC		 1715
1716 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1717 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
cb97716f 1718 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
195a4ef6 1719
a9d79fe5
HV		 1720 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1721 cap->device_caps = V4L2_CAP_READWRITE |
1722 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1723 else if (vdev->vfl_type == VFL_TYPE_RADIO)
1724 cap->device_caps = V4L2_CAP_RADIO;
1725 else
1d179eee 1726 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
0414614a 1727
920f1e4a 1728 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
a9d79fe5 1729 cap->device_caps |= V4L2_CAP_AUDIO;
6c428b57 1730
ed086314 1731 if (dev->tuner_type != TUNER_ABSENT)
a9d79fe5 1732 cap->device_caps |= V4L2_CAP_TUNER;
195a4ef6 1733
a9d79fe5
HV		 1734 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1735 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
d4352f36 1736 if (video_is_registered(&v4l2->vbi_dev))
1d179eee 1737 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
d4352f36 1738 if (video_is_registered(&v4l2->radio_dev))
a9d79fe5 1739 cap->capabilities |= V4L2_CAP_RADIO;
195a4ef6 1740 return 0;
c0477ad9
MCC		 1741}
1742
78b526a4 1743static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1744 struct v4l2_fmtdesc *f)
a6c2ba28 1745{
bddcf633 1746 if (unlikely(f->index >= ARRAY_SIZE(format)))
c0477ad9 1747 return -EINVAL;
195a4ef6 1748
bddcf633
MCC		 1749 strlcpy(f->description, format[f->index].name, sizeof(f->description));
1750 f->pixelformat = format[f->index].fourcc;
195a4ef6
MCC		 1751
1752 return 0;
c0477ad9
MCC		 1753}
1754
1c5c5068
MCC		 1755static int vidioc_enum_framesizes(struct file *file, void *priv,
1756 struct v4l2_frmsizeenum *fsize)
1757{
917ba6b0 1758 struct em28xx *dev = video_drvdata(file);
1c5c5068
MCC		 1759 struct em28xx_fmt *fmt;
1760 unsigned int maxw = norm_maxw(dev);
1761 unsigned int maxh = norm_maxh(dev);
1762
1763 fmt = format_by_fourcc(fsize->pixel_format);
1764 if (!fmt) {
1765 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1766 fsize->pixel_format);
1767 return -EINVAL;
1768 }
1769
1770 if (dev->board.is_em2800) {
1771 if (fsize->index > 1)
1772 return -EINVAL;
1773 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1774 fsize->discrete.width = maxw / (1 + fsize->index);
1775 fsize->discrete.height = maxh / (1 + fsize->index);
1776 return 0;
1777 }
1778
1779 if (fsize->index != 0)
1780 return -EINVAL;
1781
1782 /* Report a continuous range */
1783 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
6c3598e6
FS		 1784 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1785 &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1786 if (fsize->stepwise.min_width < 48)
1787 fsize->stepwise.min_width = 48;
1788 if (fsize->stepwise.min_height < 38)
1789 fsize->stepwise.min_height = 38;
1c5c5068
MCC		 1790 fsize->stepwise.max_width = maxw;
1791 fsize->stepwise.max_height = maxh;
1792 fsize->stepwise.step_width = 1;
1793 fsize->stepwise.step_height = 1;
1794 return 0;
1795}
1796
28abf083
DH		 1797/* RAW VBI ioctls */
1798
1799static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1800 struct v4l2_format *format)
1801{
917ba6b0 1802 struct em28xx *dev = video_drvdata(file);
753aee77 1803 struct em28xx_v4l2 *v4l2 = dev->v4l2;
66d9cbad 1804
753aee77 1805 format->fmt.vbi.samples_per_line = v4l2->vbi_width;
28abf083
DH		 1806 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1807 format->fmt.vbi.offset = 0;
1808 format->fmt.vbi.flags = 0;
66d9cbad 1809 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
753aee77
FS		 1810 format->fmt.vbi.count[0] = v4l2->vbi_height;
1811 format->fmt.vbi.count[1] = v4l2->vbi_height;
2a221d34 1812 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
28abf083
DH		 1813
1814 /* Varies by video standard (NTSC, PAL, etc.) */
52faaf78 1815 if (v4l2->norm & V4L2_STD_525_60) {
66d9cbad
DH		 1816 /* NTSC */
1817 format->fmt.vbi.start[0] = 10;
1818 format->fmt.vbi.start[1] = 273;
52faaf78 1819 } else if (v4l2->norm & V4L2_STD_625_50) {
66d9cbad
DH		 1820 /* PAL */
1821 format->fmt.vbi.start[0] = 6;
1822 format->fmt.vbi.start[1] = 318;
1823 }
28abf083
DH		 1824
1825 return 0;
1826}
1827
0be43754
MCC		 1828/* ----------------------------------------------------------- */
1829/* RADIO ESPECIFIC IOCTLS */
1830/* ----------------------------------------------------------- */
1831
0be43754
MCC		 1832static int radio_g_tuner(struct file *file, void *priv,
1833 struct v4l2_tuner *t)
1834{
917ba6b0 1835 struct em28xx *dev = video_drvdata(file);
0be43754
MCC		 1836
1837 if (unlikely(t->index > 0))
1838 return -EINVAL;
1839
1840 strcpy(t->name, "Radio");
0be43754 1841
95d2608b 1842 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
efc52a94 1843
0be43754
MCC		 1844 return 0;
1845}
1846
0be43754 1847static int radio_s_tuner(struct file *file, void *priv,
2f73c7c5 1848 const struct v4l2_tuner *t)
0be43754 1849{
917ba6b0 1850 struct em28xx *dev = video_drvdata(file);
0be43754
MCC		 1851
1852 if (0 != t->index)
1853 return -EINVAL;
1854
95d2608b 1855 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
0be43754
MCC		 1856
1857 return 0;
1858}
1859
95d2608b
FS		 1860/*
1861 * em28xx_free_v4l2() - Free struct em28xx_v4l2
1862 *
1863 * @ref: struct kref for struct em28xx_v4l2
1864 *
1865 * Called when all users of struct em28xx_v4l2 are gone
1866 */
f472c0b5 1867static void em28xx_free_v4l2(struct kref *ref)
95d2608b
FS		 1868{
1869 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
1870
abc1308f 1871 v4l2->dev->v4l2 = NULL;
95d2608b
FS		 1872 kfree(v4l2);
1873}
1874
195a4ef6
MCC		 1875/*
1876 * em28xx_v4l2_open()
1877 * inits the device and starts isoc transfer
1878 */
bec43661 1879static int em28xx_v4l2_open(struct file *filp)
195a4ef6 1880{
63b0d5ad
LP		 1881 struct video_device *vdev = video_devdata(filp);
1882 struct em28xx *dev = video_drvdata(filp);
95d2608b 1883 struct em28xx_v4l2 *v4l2 = dev->v4l2;
63b0d5ad 1884 enum v4l2_buf_type fh_type = 0;
3c0f90e1 1885 int ret;
2d50f847 1886
63b0d5ad
LP		 1887 switch (vdev->vfl_type) {
1888 case VFL_TYPE_GRABBER:
1889 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1890 break;
1891 case VFL_TYPE_VBI:
1892 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1893 break;
4e170240
FS		 1894 case VFL_TYPE_RADIO:
1895 break;
1896 default:
1897 return -EINVAL;
63b0d5ad 1898 }
818a557e 1899
8e2c8717
FS		 1900 em28xx_videodbg("open dev=%s type=%s users=%d\n",
1901 video_device_node_name(vdev), v4l2_type_names[fh_type],
1902 v4l2->users);
2d50f847 1903
876cb14d
HV		 1904 if (mutex_lock_interruptible(&dev->lock))
1905 return -ERESTARTSYS;
3c0f90e1
FS		 1906
1907 ret = v4l2_fh_open(filp);
1908 if (ret) {
1909 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n",
1910 __func__, ret);
876cb14d 1911 mutex_unlock(&dev->lock);
3c0f90e1 1912 return ret;
195a4ef6 1913 }
9aeb4b05 1914
8e2c8717 1915 if (v4l2->users == 0) {
c67ec53f 1916 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2d50f847 1917
4e170240
FS		 1918 if (vdev->vfl_type != VFL_TYPE_RADIO)
1919 em28xx_resolution_set(dev);
1920
1921 /*
1922 * Needed, since GPIO might have disabled power
1923 * of some i2c devices
c67ec53f 1924 */
1a23f81b 1925 em28xx_wake_i2c(dev);
2d50f847 1926 }
d3829fad
DH		 1927
1928 if (vdev->vfl_type == VFL_TYPE_RADIO) {
0be43754 1929 em28xx_videodbg("video_open: setting radio device\n");
95d2608b 1930 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
0be43754 1931 }
2d50f847 1932
47677e51 1933 kref_get(&dev->ref);
95d2608b 1934 kref_get(&v4l2->ref);
8e2c8717 1935 v4l2->users++;
2d50f847 1936
876cb14d 1937 mutex_unlock(&dev->lock);
c67ec53f 1938
d3829fad 1939 return 0;
2d50f847 1940}
e5589bef 1941
a6c2ba28 1942/*
01c28193 1943 * em28xx_v4l2_fini()
195a4ef6
MCC		 1944 * unregisters the v4l2,i2c and usb devices
1945 * called when the device gets disconected or at module unload
1946*/
01c28193 1947static int em28xx_v4l2_fini(struct em28xx *dev)
a6c2ba28 1948{
95d2608b
FS		 1949 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1950
822b8dea
MCC		 1951 if (dev->is_audio_only) {
1952 /* Shouldn't initialize IR for this interface */
1953 return 0;
1954 }
1955
01c28193
MCC		 1956 if (!dev->has_video) {
1957 /* This device does not support the v4l2 extension */
1958 return 0;
1959 }
a6c2ba28 1960
95d2608b
FS		 1961 if (v4l2 == NULL)
1962 return 0;
1963
0418ca60 1964 em28xx_info("Closing video extension\n");
aa929ad7 1965
ebbfbc20
MCC		 1966 mutex_lock(&dev->lock);
1967
95d2608b 1968 v4l2_device_disconnect(&v4l2->v4l2_dev);
5ad10de6 1969
23e8642c
FS		 1970 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1971
d4352f36 1972 if (video_is_registered(&v4l2->radio_dev)) {
e847022a 1973 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1974 video_device_node_name(&v4l2->radio_dev));
1975 video_unregister_device(&v4l2->radio_dev);
0be43754 1976 }
d4352f36 1977 if (video_is_registered(&v4l2->vbi_dev)) {
38c7c036 1978 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1979 video_device_node_name(&v4l2->vbi_dev));
1980 video_unregister_device(&v4l2->vbi_dev);
0be43754 1981 }
d4352f36 1982 if (video_is_registered(&v4l2->vdev)) {
38c7c036 1983 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1984 video_device_node_name(&v4l2->vdev));
1985 video_unregister_device(&v4l2->vdev);
0be43754 1986 }
01c28193 1987
abc1308f 1988 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
95d2608b 1989 v4l2_device_unregister(&v4l2->v4l2_dev);
103f18a2 1990
2c52a2fc
FS		 1991 if (v4l2->clk) {
1992 v4l2_clk_unregister_fixed(v4l2->clk);
1993 v4l2->clk = NULL;
25dd1652
FS		 1994 }
1995
95d2608b
FS		 1996 kref_put(&v4l2->ref, em28xx_free_v4l2);
1997
ebbfbc20 1998 mutex_unlock(&dev->lock);
95d2608b 1999
47677e51 2000 kref_put(&dev->ref, em28xx_free_device);
5ad10de6 2001
01c28193 2002 return 0;
195a4ef6 2003}
a6c2ba28 2004
a61f6811
SK		 2005static int em28xx_v4l2_suspend(struct em28xx *dev)
2006{
2007 if (dev->is_audio_only)
2008 return 0;
2009
2010 if (!dev->has_video)
2011 return 0;
2012
32e63f03 2013 em28xx_info("Suspending video extension\n");
a61f6811
SK		 2014 em28xx_stop_urbs(dev);
2015 return 0;
2016}
2017
2018static int em28xx_v4l2_resume(struct em28xx *dev)
2019{
2020 if (dev->is_audio_only)
2021 return 0;
2022
2023 if (!dev->has_video)
2024 return 0;
2025
32e63f03 2026 em28xx_info("Resuming video extension\n");
a61f6811
SK		 2027 /* what do we do here */
2028 return 0;
2029}
2030
195a4ef6
MCC		 2031/*
2032 * em28xx_v4l2_close()
6ea54d93
DSL		 2033 * stops streaming and deallocates all resources allocated by the v4l2
2034 * calls and ioctls
195a4ef6 2035 */
bec43661 2036static int em28xx_v4l2_close(struct file *filp)
195a4ef6 2037{
917ba6b0 2038 struct em28xx *dev = video_drvdata(filp);
95d2608b 2039 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6 2040 int errCode;
a6c2ba28 2041
8e2c8717 2042 em28xx_videodbg("users=%d\n", v4l2->users);
8c873d31 2043
8e2c8717
FS		 2044 vb2_fop_release(filp);
2045 mutex_lock(&dev->lock);
747dba7d 2046
8e2c8717 2047 if (v4l2->users == 1) {
47677e51
MCC		 2048 /* No sense to try to write to the device */
2049 if (dev->disconnected)
01c28193 2050 goto exit;
a6c2ba28 2051
eb6c9634 2052 /* Save some power by putting tuner to sleep */
95d2608b 2053 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
eb6c9634 2054
d7aa8020 2055 /* do this before setting alternate! */
2fe3e2ee 2056 em28xx_set_mode(dev, EM28XX_SUSPEND);
d7aa8020 2057
195a4ef6
MCC		 2058 /* set alternate 0 */
2059 dev->alt = 0;
2060 em28xx_videodbg("setting alternate 0\n");
2061 errCode = usb_set_interface(dev->udev, 0, 0);
2062 if (errCode < 0) {
2063 em28xx_errdev("cannot change alternate number to "
2064 "0 (error=%i)\n", errCode);
2065 }
9aeb4b05 2066 }
28abf083 2067
01c28193 2068exit:
8e2c8717 2069 v4l2->users--;
95d2608b 2070 kref_put(&v4l2->ref, em28xx_free_v4l2);
876cb14d 2071 mutex_unlock(&dev->lock);
47677e51
MCC		 2072 kref_put(&dev->ref, em28xx_free_device);
2073
195a4ef6
MCC		 2074 return 0;
2075}
a6c2ba28 2076
bec43661 2077static const struct v4l2_file_operations em28xx_v4l_fops = {
195a4ef6
MCC		 2078 .owner = THIS_MODULE,
2079 .open = em28xx_v4l2_open,
2080 .release = em28xx_v4l2_close,
d3829fad
DH		 2081 .read = vb2_fop_read,
2082 .poll = vb2_fop_poll,
2083 .mmap = vb2_fop_mmap,
0499a5aa 2084 .unlocked_ioctl = video_ioctl2,
195a4ef6 2085};
17cbe2e5 2086
a399810c 2087static const struct v4l2_ioctl_ops video_ioctl_ops = {
195a4ef6 2088 .vidioc_querycap = vidioc_querycap,
78b526a4
HV		 2089 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2090 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2091 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2092 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
28abf083 2093 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2a221d34 2094 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
aab34618 2095 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1c5c5068 2096 .vidioc_enum_framesizes = vidioc_enum_framesizes,
195a4ef6
MCC		 2097 .vidioc_g_audio = vidioc_g_audio,
2098 .vidioc_s_audio = vidioc_s_audio,
195a4ef6 2099
d3829fad
DH		 2100 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2101 .vidioc_create_bufs = vb2_ioctl_create_bufs,
2102 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
2103 .vidioc_querybuf = vb2_ioctl_querybuf,
2104 .vidioc_qbuf = vb2_ioctl_qbuf,
2105 .vidioc_dqbuf = vb2_ioctl_dqbuf,
2106
19bf0038 2107 .vidioc_g_std = vidioc_g_std,
d56ae6fb 2108 .vidioc_querystd = vidioc_querystd,
195a4ef6 2109 .vidioc_s_std = vidioc_s_std,
d96ecda6
MCC		 2110 .vidioc_g_parm = vidioc_g_parm,
2111 .vidioc_s_parm = vidioc_s_parm,
195a4ef6
MCC		 2112 .vidioc_enum_input = vidioc_enum_input,
2113 .vidioc_g_input = vidioc_g_input,
2114 .vidioc_s_input = vidioc_s_input,
d3829fad
DH		 2115 .vidioc_streamon = vb2_ioctl_streamon,
2116 .vidioc_streamoff = vb2_ioctl_streamoff,
195a4ef6
MCC		 2117 .vidioc_g_tuner = vidioc_g_tuner,
2118 .vidioc_s_tuner = vidioc_s_tuner,
2119 .vidioc_g_frequency = vidioc_g_frequency,
2120 .vidioc_s_frequency = vidioc_s_frequency,
50fdf40f
HV		 2121 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2122 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1e7ad56f 2123#ifdef CONFIG_VIDEO_ADV_DEBUG
96b03d2a 2124 .vidioc_g_chip_info = vidioc_g_chip_info,
1e7ad56f
MCC		 2125 .vidioc_g_register = vidioc_g_register,
2126 .vidioc_s_register = vidioc_s_register,
2127#endif
a399810c
HV		 2128};
2129
2130static const struct video_device em28xx_video_template = {
e847022a
FS		 2131 .fops = &em28xx_v4l_fops,
2132 .ioctl_ops = &video_ioctl_ops,
d4352f36 2133 .release = video_device_release_empty,
e847022a 2134 .tvnorms = V4L2_STD_ALL,
a6c2ba28 2135};
2136
bec43661 2137static const struct v4l2_file_operations radio_fops = {
a399810c
HV		 2138 .owner = THIS_MODULE,
2139 .open = em28xx_v4l2_open,
2140 .release = em28xx_v4l2_close,
8fd0bda5 2141 .unlocked_ioctl = video_ioctl2,
a399810c
HV		 2142};
2143
2144static const struct v4l2_ioctl_ops radio_ioctl_ops = {
a9d79fe5 2145 .vidioc_querycap = vidioc_querycap,
0be43754 2146 .vidioc_g_tuner = radio_g_tuner,
0be43754 2147 .vidioc_s_tuner = radio_s_tuner,
0be43754
MCC		 2148 .vidioc_g_frequency = vidioc_g_frequency,
2149 .vidioc_s_frequency = vidioc_s_frequency,
50fdf40f
HV		 2150 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2151 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1e7ad56f 2152#ifdef CONFIG_VIDEO_ADV_DEBUG
430c73fa 2153 .vidioc_g_chip_info = vidioc_g_chip_info,
1e7ad56f
MCC		 2154 .vidioc_g_register = vidioc_g_register,
2155 .vidioc_s_register = vidioc_s_register,
2156#endif
0be43754
MCC		 2157};
2158
a399810c 2159static struct video_device em28xx_radio_template = {
e847022a
FS		 2160 .fops = &radio_fops,
2161 .ioctl_ops = &radio_ioctl_ops,
d4352f36 2162 .release = video_device_release_empty,
a399810c
HV		 2163};
2164
b64f8e9a
MCC		 2165/* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2166static unsigned short saa711x_addrs[] = {
2167 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */
2168 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */
2169 I2C_CLIENT_END };
2170
2171static unsigned short tvp5150_addrs[] = {
2172 0xb8 >> 1,
2173 0xba >> 1,
2174 I2C_CLIENT_END
2175};
2176
2177static unsigned short msp3400_addrs[] = {
2178 0x80 >> 1,
2179 0x88 >> 1,
2180 I2C_CLIENT_END
2181};
2182
6ea54d93 2183/******************************** usb interface ******************************/
a6c2ba28 2184
d4352f36
HV		 2185static void em28xx_vdev_init(struct em28xx *dev,
2186 struct video_device *vfd,
2187 const struct video_device *template,
2188 const char *type_name)
0be43754 2189{
f2cf250a 2190 *vfd = *template;
95d2608b 2191 vfd->v4l2_dev = &dev->v4l2->v4l2_dev;
0499a5aa 2192 vfd->lock = &dev->lock;
d8c95c08
HV		 2193 if (dev->board.is_webcam)
2194 vfd->tvnorms = 0;
0be43754
MCC		 2195
2196 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2197 dev->name, type_name);
2198
63b0d5ad 2199 video_set_drvdata(vfd, dev);
0be43754
MCC		 2200}
2201
3319e6f8 2202static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
0560f337 2203{
3854b0d8
FS		 2204 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2205 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev;
2206 struct tuner_setup tun_setup;
2207 struct v4l2_frequency f;
0560f337 2208
0560f337
MCC		 2209 memset(&tun_setup, 0, sizeof(tun_setup));
2210
2211 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2212 tun_setup.tuner_callback = em28xx_tuner_callback;
2213
2214 if (dev->board.radio.type) {
2215 tun_setup.type = dev->board.radio.type;
2216 tun_setup.addr = dev->board.radio_addr;
2217
95d2608b
FS		 2218 v4l2_device_call_all(v4l2_dev,
2219 0, tuner, s_type_addr, &tun_setup);
0560f337
MCC		 2220 }
2221
2222 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2223 tun_setup.type = dev->tuner_type;
3319e6f8 2224 tun_setup.addr = tuner_addr;
0560f337 2225
95d2608b
FS		 2226 v4l2_device_call_all(v4l2_dev,
2227 0, tuner, s_type_addr, &tun_setup);
0560f337
MCC		 2228 }
2229
6867bd5a 2230 if (dev->board.tda9887_conf) {
0560f337
MCC		 2231 struct v4l2_priv_tun_config tda9887_cfg;
2232
2233 tda9887_cfg.tuner = TUNER_TDA9887;
6867bd5a 2234 tda9887_cfg.priv = &dev->board.tda9887_conf;
0560f337 2235
95d2608b
FS		 2236 v4l2_device_call_all(v4l2_dev,
2237 0, tuner, s_config, &tda9887_cfg);
0560f337
MCC		 2238 }
2239
2240 if (dev->tuner_type == TUNER_XC2028) {
2241 struct v4l2_priv_tun_config xc2028_cfg;
2242 struct xc2028_ctrl ctl;
2243
2244 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2245 memset(&ctl, 0, sizeof(ctl));
2246
2247 em28xx_setup_xc3028(dev, &ctl);
2248
2249 xc2028_cfg.tuner = TUNER_XC2028;
2250 xc2028_cfg.priv = &ctl;
2251
95d2608b 2252 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
0560f337
MCC		 2253 }
2254
2255 /* configure tuner */
2256 f.tuner = 0;
2257 f.type = V4L2_TUNER_ANALOG_TV;
2258 f.frequency = 9076; /* just a magic number */
3854b0d8 2259 v4l2->frequency = f.frequency;
95d2608b 2260 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
0560f337
MCC		 2261}
2262
01c28193 2263static int em28xx_v4l2_init(struct em28xx *dev)
1a23f81b 2264{
081b945e 2265 u8 val;
2e5ef2df 2266 int ret;
1020d13d 2267 unsigned int maxw;
abc1308f 2268 struct v4l2_ctrl_handler *hdl;
95d2608b 2269 struct em28xx_v4l2 *v4l2;
b64f8e9a 2270
822b8dea
MCC		 2271 if (dev->is_audio_only) {
2272 /* Shouldn't initialize IR for this interface */
2273 return 0;
2274 }
2275
01c28193 2276 if (!dev->has_video) {
b64f8e9a
MCC		 2277 /* This device does not support the v4l2 extension */
2278 return 0;
2279 }
2e5ef2df 2280
9634614f 2281 em28xx_info("Registering V4L2 extension\n");
1a23f81b 2282
01c28193
MCC		 2283 mutex_lock(&dev->lock);
2284
95d2608b
FS		 2285 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2286 if (v4l2 == NULL) {
2287 em28xx_info("em28xx_v4l: memory allocation failed\n");
2288 mutex_unlock(&dev->lock);
2289 return -ENOMEM;
2290 }
2291 kref_init(&v4l2->ref);
abc1308f 2292 v4l2->dev = dev;
95d2608b
FS		 2293 dev->v4l2 = v4l2;
2294
2295 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev);
b64f8e9a
MCC		 2296 if (ret < 0) {
2297 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2298 goto err;
2299 }
2300
abc1308f 2301 hdl = &v4l2->ctrl_handler;
b64f8e9a 2302 v4l2_ctrl_handler_init(hdl, 8);
95d2608b 2303 v4l2->v4l2_dev.ctrl_handler = hdl;
b64f8e9a 2304
58159171 2305 if (dev->board.is_webcam)
7e6c8c19 2306 v4l2->progressive = true;
58159171 2307
b64f8e9a
MCC		 2308 /*
2309 * Default format, used for tvp5150 or saa711x output formats
2310 */
9297285e
FS		 2311 v4l2->vinmode = 0x10;
2312 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED |
2313 EM28XX_VINCTRL_CCIR656_ENABLE;
b64f8e9a
MCC		 2314
2315 /* request some modules */
2316
2317 if (dev->board.has_msp34xx)
95d2608b
FS		 2318 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2319 &dev->i2c_adap[dev->def_i2c_bus],
2320 "msp3400", 0, msp3400_addrs);
b64f8e9a
MCC		 2321
2322 if (dev->board.decoder == EM28XX_SAA711X)
95d2608b
FS		 2323 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2324 &dev->i2c_adap[dev->def_i2c_bus],
2325 "saa7115_auto", 0, saa711x_addrs);
b64f8e9a
MCC		 2326
2327 if (dev->board.decoder == EM28XX_TVP5150)
95d2608b
FS		 2328 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2329 &dev->i2c_adap[dev->def_i2c_bus],
2330 "tvp5150", 0, tvp5150_addrs);
b64f8e9a
MCC		 2331
2332 if (dev->board.adecoder == EM28XX_TVAUDIO)
95d2608b
FS		 2333 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2334 &dev->i2c_adap[dev->def_i2c_bus],
2335 "tvaudio", dev->board.tvaudio_addr, NULL);
b64f8e9a
MCC		 2336
2337 /* Initialize tuner and camera */
2338
2339 if (dev->board.tuner_type != TUNER_ABSENT) {
3319e6f8 2340 unsigned short tuner_addr = dev->board.tuner_addr;
6867bd5a 2341 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
b64f8e9a
MCC		 2342
2343 if (dev->board.radio.type)
95d2608b 2344 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2345 &dev->i2c_adap[dev->def_i2c_bus],
2346 "tuner", dev->board.radio_addr,
2347 NULL);
b64f8e9a
MCC		 2348
2349 if (has_demod)
95d2608b 2350 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2351 &dev->i2c_adap[dev->def_i2c_bus],
2352 "tuner", 0,
2353 v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
3319e6f8 2354 if (tuner_addr == 0) {
b64f8e9a
MCC		 2355 enum v4l2_i2c_tuner_type type =
2356 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2357 struct v4l2_subdev *sd;
2358
95d2608b 2359 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2360 &dev->i2c_adap[dev->def_i2c_bus],
2361 "tuner", 0,
2362 v4l2_i2c_tuner_addrs(type));
b64f8e9a
MCC		 2363
2364 if (sd)
3319e6f8 2365 tuner_addr = v4l2_i2c_subdev_addr(sd);
b64f8e9a 2366 } else {
95d2608b
FS		 2367 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2368 &dev->i2c_adap[dev->def_i2c_bus],
3319e6f8 2369 "tuner", tuner_addr, NULL);
b64f8e9a 2370 }
3319e6f8
FS		 2371
2372 em28xx_tuner_setup(dev, tuner_addr);
b64f8e9a
MCC		 2373 }
2374
d86bc65a
FS		 2375 if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2376 em28xx_init_camera(dev);
b64f8e9a
MCC		 2377
2378 /* Configure audio */
2379 ret = em28xx_audio_setup(dev);
2380 if (ret < 0) {
2381 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
fdf1bc9f 2382 __func__, ret);
b64f8e9a
MCC		 2383 goto unregister_dev;
2384 }
2385 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2386 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
fdf1bc9f 2387 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
b64f8e9a 2388 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
fdf1bc9f 2389 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
b64f8e9a
MCC		 2390 } else {
2391 /* install the em28xx notify callback */
2392 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
fdf1bc9f 2393 em28xx_ctrl_notify, dev);
b64f8e9a 2394 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
fdf1bc9f 2395 em28xx_ctrl_notify, dev);
b64f8e9a
MCC		 2396 }
2397
2398 /* wake i2c devices */
2399 em28xx_wake_i2c(dev);
2400
2401 /* init video dma queues */
2402 INIT_LIST_HEAD(&dev->vidq.active);
2403 INIT_LIST_HEAD(&dev->vbiq.active);
2404
2405 if (dev->board.has_msp34xx) {
2406 /* Send a reset to other chips via gpio */
2407 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2408 if (ret < 0) {
2409 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2410 __func__, ret);
2411 goto unregister_dev;
2412 }
2413 msleep(3);
2414
2415 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2416 if (ret < 0) {
2417 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2418 __func__, ret);
2419 goto unregister_dev;
2420 }
2421 msleep(3);
2422 }
2423
24c3c415 2424 /* set default norm */
52faaf78 2425 v4l2->norm = V4L2_STD_PAL;
8774bed9 2426 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
58159171 2427 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
24c3c415 2428
1a23f81b 2429 /* Analog specific initialization */
06e20672 2430 v4l2->format = &format[0];
1020d13d
SS		 2431
2432 maxw = norm_maxw(dev);
d3829fad
DH		 2433 /* MaxPacketSize for em2800 is too small to capture at full resolution
2434 * use half of maxw as the scaler can only scale to 50% */
2435 if (dev->board.is_em2800)
2436 maxw /= 2;
1020d13d 2437
ed5f1431 2438 em28xx_set_video_format(dev, format[0].fourcc,
1020d13d 2439 maxw, norm_maxh(dev));
ed5f1431 2440
96371fc8 2441 video_mux(dev, 0);
24c3c415
MCC		 2442
2443 /* Audio defaults */
2444 dev->mute = 1;
2445 dev->volume = 0x1f;
1a23f81b 2446
1a23f81b 2447/* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
a1a6ee74
NS		 2448 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2449 em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2450 (EM28XX_XCLK_AUDIO_UNMUTE | val));
1a23f81b 2451
1a23f81b 2452 em28xx_set_outfmt(dev);
1a23f81b 2453
8f8b113a
FS		 2454 /* Add image controls */
2455 /* NOTE: at this point, the subdevices are already registered, so bridge
2456 * controls are only added/enabled when no subdevice provides them */
ad298055
FS		 2457 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2458 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2459 V4L2_CID_CONTRAST,
2460 0, 0x1f, 1, CONTRAST_DEFAULT);
ad298055
FS		 2461 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2462 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2463 V4L2_CID_BRIGHTNESS,
2464 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
ad298055
FS		 2465 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2466 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2467 V4L2_CID_SATURATION,
2468 0, 0x1f, 1, SATURATION_DEFAULT);
ad298055
FS		 2469 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2470 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2471 V4L2_CID_BLUE_BALANCE,
2472 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
ad298055
FS		 2473 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2474 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2475 V4L2_CID_RED_BALANCE,
2476 -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
ad298055
FS		 2477 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2478 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2479 V4L2_CID_SHARPNESS,
2480 0, 0x0f, 1, SHARPNESS_DEFAULT);
2481
2482 /* Reset image controls */
2483 em28xx_colorlevels_set_default(dev);
ad298055
FS		 2484 v4l2_ctrl_handler_setup(hdl);
2485 ret = hdl->error;
b64f8e9a
MCC		 2486 if (ret)
2487 goto unregister_dev;
8f8b113a 2488
818a557e 2489 /* allocate and fill video video_device struct */
d4352f36 2490 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
27a36df6
FS		 2491 mutex_init(&v4l2->vb_queue_lock);
2492 mutex_init(&v4l2->vb_vbi_queue_lock);
d4352f36
HV		 2493 v4l2->vdev.queue = &v4l2->vb_vidq;
2494 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
818a557e 2495
6e46daba
FS		 2496 /* disable inapplicable ioctls */
2497 if (dev->board.is_webcam) {
d4352f36
HV		 2498 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2499 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2500 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
3bc85cce 2501 } else {
d4352f36 2502 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
6e46daba 2503 }
66df67b7 2504 if (dev->tuner_type == TUNER_ABSENT) {
d4352f36
HV		 2505 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2506 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2507 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2508 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
66df67b7 2509 }
920f1e4a 2510 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
d4352f36
HV		 2511 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2512 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
c2dcef83 2513 }
6e46daba 2514
818a557e 2515 /* register v4l2 video video_device */
d4352f36 2516 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
fdf1bc9f 2517 video_nr[dev->devno]);
818a557e
MCC		 2518 if (ret) {
2519 em28xx_errdev("unable to register video device (error=%i).\n",
2520 ret);
b64f8e9a 2521 goto unregister_dev;
818a557e
MCC		 2522 }
2523
2524 /* Allocate and fill vbi video_device struct */
290c0cfa 2525 if (em28xx_vbi_supported(dev) == 1) {
d4352f36
HV		 2526 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2527 "vbi");
818a557e 2528
d4352f36
HV		 2529 v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2530 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
d3829fad 2531
66df67b7 2532 /* disable inapplicable ioctls */
d4352f36 2533 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
66df67b7 2534 if (dev->tuner_type == TUNER_ABSENT) {
d4352f36
HV		 2535 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2536 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2537 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2538 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
66df67b7 2539 }
920f1e4a 2540 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
d4352f36
HV		 2541 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2542 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
c2dcef83 2543 }
66df67b7 2544
290c0cfa 2545 /* register v4l2 vbi video_device */
d4352f36 2546 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
290c0cfa
DH		 2547 vbi_nr[dev->devno]);
2548 if (ret < 0) {
2549 em28xx_errdev("unable to register vbi device\n");
b64f8e9a 2550 goto unregister_dev;
290c0cfa 2551 }
818a557e
MCC		 2552 }
2553
2554 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
d4352f36
HV		 2555 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2556 "radio");
2557 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
818a557e
MCC		 2558 radio_nr[dev->devno]);
2559 if (ret < 0) {
2560 em28xx_errdev("can't register radio device\n");
b64f8e9a 2561 goto unregister_dev;
818a557e 2562 }
38c7c036 2563 em28xx_info("Registered radio device as %s\n",
d4352f36 2564 video_device_node_name(&v4l2->radio_dev));
818a557e
MCC		 2565 }
2566
38c7c036 2567 em28xx_info("V4L2 video device registered as %s\n",
d4352f36 2568 video_device_node_name(&v4l2->vdev));
290c0cfa 2569
d4352f36 2570 if (video_is_registered(&v4l2->vbi_dev))
38c7c036 2571 em28xx_info("V4L2 VBI device registered as %s\n",
d4352f36 2572 video_device_node_name(&v4l2->vbi_dev));
818a557e 2573
b64f8e9a 2574 /* Save some power by putting tuner to sleep */
95d2608b 2575 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
b64f8e9a
MCC		 2576
2577 /* initialize videobuf2 stuff */
2578 em28xx_vb2_setup(dev);
2579
9634614f
MCC		 2580 em28xx_info("V4L2 extension successfully initialized\n");
2581
47677e51
MCC		 2582 kref_get(&dev->ref);
2583
01c28193 2584 mutex_unlock(&dev->lock);
818a557e 2585 return 0;
b64f8e9a
MCC		 2586
2587unregister_dev:
abc1308f 2588 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
95d2608b 2589 v4l2_device_unregister(&v4l2->v4l2_dev);
b64f8e9a 2590err:
95d2608b
FS		 2591 dev->v4l2 = NULL;
2592 kref_put(&v4l2->ref, em28xx_free_v4l2);
01c28193 2593 mutex_unlock(&dev->lock);
b64f8e9a 2594 return ret;
818a557e 2595}
01c28193
MCC		 2596
2597static struct em28xx_ops v4l2_ops = {
2598 .id = EM28XX_V4L2,
2599 .name = "Em28xx v4l2 Extension",
2600 .init = em28xx_v4l2_init,
2601 .fini = em28xx_v4l2_fini,
a61f6811
SK		 2602 .suspend = em28xx_v4l2_suspend,
2603 .resume = em28xx_v4l2_resume,
01c28193
MCC		 2604};
2605
2606static int __init em28xx_video_register(void)
2607{
2608 return em28xx_register_extension(&v4l2_ops);
2609}
2610
2611static void __exit em28xx_video_unregister(void)
2612{
2613 em28xx_unregister_extension(&v4l2_ops);
2614}
2615
2616module_init(em28xx_video_register);
2617module_exit(em28xx_video_unregister);
Linux kernel - Deliverables
This page took 1.280744 seconds and 5 git commands to generate.