projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] em28xx: avoid divide by zero error
[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);
0962a763
MCC		 1235
1236 /* Don't let width or height to be zero */
1237 if (*width < 1)
1238 *width = 1;
1239 if (*height < 1)
1240 *height = 1;
b8374138
FS		 1241}
1242
195a4ef6
MCC		 1243/* ------------------------------------------------------------------
1244 IOCTL vidioc handling
1245 ------------------------------------------------------------------*/
1246
78b526a4 1247static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1248 struct v4l2_format *f)
a6c2ba28 1249{
917ba6b0 1250 struct em28xx *dev = video_drvdata(file);
753aee77 1251 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1252
753aee77
FS		 1253 f->fmt.pix.width = v4l2->width;
1254 f->fmt.pix.height = v4l2->height;
06e20672
FS		 1255 f->fmt.pix.pixelformat = v4l2->format->fourcc;
1256 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
753aee77 1257 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
195a4ef6 1258 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
e5589bef 1259
195a4ef6 1260 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
58159171 1261 if (v4l2->progressive)
c2a6b54a
MCC		 1262 f->fmt.pix.field = V4L2_FIELD_NONE;
1263 else
58159171 1264 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
195a4ef6 1265 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
195a4ef6 1266 return 0;
a6c2ba28 1267}
1268
bddcf633
MCC		 1269static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1270{
1271 unsigned int i;
1272
1273 for (i = 0; i < ARRAY_SIZE(format); i++)
1274 if (format[i].fourcc == fourcc)
1275 return &format[i];
1276
1277 return NULL;
1278}
1279
78b526a4 1280static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1281 struct v4l2_format *f)
a6c2ba28 1282{
917ba6b0 1283 struct em28xx *dev = video_drvdata(file);
58159171 1284 struct em28xx_v4l2 *v4l2 = dev->v4l2;
ccb83408
TP		 1285 unsigned int width = f->fmt.pix.width;
1286 unsigned int height = f->fmt.pix.height;
195a4ef6
MCC		 1287 unsigned int maxw = norm_maxw(dev);
1288 unsigned int maxh = norm_maxh(dev);
1289 unsigned int hscale, vscale;
bddcf633
MCC		 1290 struct em28xx_fmt *fmt;
1291
1292 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1293 if (!fmt) {
1294 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1295 f->fmt.pix.pixelformat);
1296 return -EINVAL;
1297 }
195a4ef6 1298
55699964 1299 if (dev->board.is_em2800) {
195a4ef6 1300 /* the em2800 can only scale down to 50% */
ccb83408
TP		 1301 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1302 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
d3829fad
DH		 1303 /*
1304 * MaxPacketSize for em2800 is too small to capture at full
1305 * resolution use half of maxw as the scaler can only scale
1306 * to 50%
1307 */
1020d13d
SS		 1308 if (width == maxw && height == maxh)
1309 width /= 2;
ccb83408
TP		 1310 } else {
1311 /* width must even because of the YUYV format
1312 height must be even because of interlacing */
e3ba4d34
DH		 1313 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1314 1, 0);
195a4ef6 1315 }
0962a763
MCC		 1316 /* Avoid division by zero at size_to_scale */
1317 if (width < 1)
1318 width = 1;
1319 if (height < 1)
1320 height = 1;
a225452e 1321
6b09a21c 1322 size_to_scale(dev, width, height, &hscale, &vscale);
46f85978 1323 scale_to_size(dev, hscale, vscale, &width, &height);
a6c2ba28 1324
195a4ef6
MCC		 1325 f->fmt.pix.width = width;
1326 f->fmt.pix.height = height;
bddcf633 1327 f->fmt.pix.pixelformat = fmt->fourcc;
e6066dba 1328 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
bddcf633 1329 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
195a4ef6 1330 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
58159171 1331 if (v4l2->progressive)
c2a6b54a
MCC		 1332 f->fmt.pix.field = V4L2_FIELD_NONE;
1333 else
58159171 1334 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
c2a6b54a 1335 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
51dd4d70 1336 f->fmt.pix.priv = 0;
a6c2ba28 1337
a6c2ba28 1338 return 0;
1339}
1340
ed5f1431
MCC		 1341static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1342 unsigned width, unsigned height)
1343{
1344 struct em28xx_fmt *fmt;
753aee77 1345 struct em28xx_v4l2 *v4l2 = dev->v4l2;
ed5f1431 1346
ed5f1431
MCC		 1347 fmt = format_by_fourcc(fourcc);
1348 if (!fmt)
1349 return -EINVAL;
1350
06e20672 1351 v4l2->format = fmt;
753aee77
FS		 1352 v4l2->width = width;
1353 v4l2->height = height;
ed5f1431
MCC		 1354
1355 /* set new image size */
753aee77 1356 size_to_scale(dev, v4l2->width, v4l2->height,
fdf1bc9f 1357 &v4l2->hscale, &v4l2->vscale);
ed5f1431 1358
ed5f1431
MCC		 1359 em28xx_resolution_set(dev);
1360
1361 return 0;
1362}
1363
78b526a4 1364static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1365 struct v4l2_format *f)
a6c2ba28 1366{
d3829fad 1367 struct em28xx *dev = video_drvdata(file);
8139a4d5 1368 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1369
c7854c2c 1370 if (vb2_is_busy(&v4l2->vb_vidq))
d3829fad 1371 return -EBUSY;
a225452e 1372
efc52a94
MCC		 1373 vidioc_try_fmt_vid_cap(file, priv, f);
1374
0499a5aa 1375 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
ed5f1431 1376 f->fmt.pix.width, f->fmt.pix.height);
195a4ef6
MCC		 1377}
1378
19bf0038
DH		 1379static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1380{
917ba6b0 1381 struct em28xx *dev = video_drvdata(file);
19bf0038 1382
52faaf78 1383 *norm = dev->v4l2->norm;
19bf0038
DH		 1384
1385 return 0;
1386}
1387
d56ae6fb
MCC		 1388static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1389{
917ba6b0 1390 struct em28xx *dev = video_drvdata(file);
d56ae6fb 1391
95d2608b 1392 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
d56ae6fb
MCC		 1393
1394 return 0;
1395}
1396
314527ac 1397static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
195a4ef6 1398{
917ba6b0 1399 struct em28xx *dev = video_drvdata(file);
753aee77 1400 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6 1401 struct v4l2_format f;
195a4ef6 1402
52faaf78 1403 if (norm == v4l2->norm)
d8c95c08 1404 return 0;
195a4ef6 1405
8139a4d5 1406 if (v4l2->streaming_users > 0)
d8c95c08 1407 return -EBUSY;
d8c95c08 1408
52faaf78 1409 v4l2->norm = norm;
a6c2ba28 1410
195a4ef6 1411 /* Adjusts width/height, if needed */
d8c95c08 1412 f.fmt.pix.width = 720;
314527ac 1413 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
78b526a4 1414 vidioc_try_fmt_vid_cap(file, priv, &f);
a6c2ba28 1415
195a4ef6 1416 /* set new image size */
753aee77
FS		 1417 v4l2->width = f.fmt.pix.width;
1418 v4l2->height = f.fmt.pix.height;
1419 size_to_scale(dev, v4l2->width, v4l2->height,
fdf1bc9f 1420 &v4l2->hscale, &v4l2->vscale);
a6c2ba28 1421
195a4ef6 1422 em28xx_resolution_set(dev);
8774bed9 1423 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
a6c2ba28 1424
195a4ef6
MCC		 1425 return 0;
1426}
9e31ced8 1427
d96ecda6
MCC		 1428static int vidioc_g_parm(struct file *file, void *priv,
1429 struct v4l2_streamparm *p)
1430{
917ba6b0 1431 struct em28xx *dev = video_drvdata(file);
52faaf78 1432 struct em28xx_v4l2 *v4l2 = dev->v4l2;
d96ecda6
MCC		 1433 int rc = 0;
1434
86ff7f1d 1435 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
d96ecda6 1436 if (dev->board.is_webcam)
52faaf78 1437 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
d96ecda6
MCC		 1438 video, g_parm, p);
1439 else
52faaf78 1440 v4l2_video_std_frame_period(v4l2->norm,
fdf1bc9f 1441 &p->parm.capture.timeperframe);
d96ecda6
MCC		 1442
1443 return rc;
1444}
1445
1446static int vidioc_s_parm(struct file *file, void *priv,
1447 struct v4l2_streamparm *p)
1448{
917ba6b0 1449 struct em28xx *dev = video_drvdata(file);
d96ecda6 1450
86ff7f1d 1451 p->parm.capture.readbuffers = EM28XX_MIN_BUF;
95d2608b
FS		 1452 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1453 0, video, s_parm, p);
d96ecda6
MCC		 1454}
1455
d83a96a5
MCC		 1456static const char * const iname[] = {
1457 [EM28XX_VMUX_COMPOSITE] = "Composite",
1458 [EM28XX_VMUX_SVIDEO] = "S-Video",
195a4ef6 1459 [EM28XX_VMUX_TELEVISION] = "Television",
d83a96a5 1460 [EM28XX_RADIO] = "Radio",
195a4ef6 1461};
9e31ced8 1462
195a4ef6 1463static int vidioc_enum_input(struct file *file, void *priv,
fdf1bc9f 1464 struct v4l2_input *i)
195a4ef6 1465{
917ba6b0 1466 struct em28xx *dev = video_drvdata(file);
195a4ef6 1467 unsigned int n;
9e31ced8 1468
195a4ef6
MCC		 1469 n = i->index;
1470 if (n >= MAX_EM28XX_INPUT)
1471 return -EINVAL;
1472 if (0 == INPUT(n)->type)
1473 return -EINVAL;
9e31ced8 1474
195a4ef6
MCC		 1475 i->index = n;
1476 i->type = V4L2_INPUT_TYPE_CAMERA;
a6c2ba28 1477
195a4ef6 1478 strcpy(i->name, iname[INPUT(n)->type]);
a6c2ba28 1479
d83a96a5 1480 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type))
195a4ef6
MCC		 1481 i->type = V4L2_INPUT_TYPE_TUNER;
1482
d4352f36 1483 i->std = dev->v4l2->vdev.tvnorms;
d8c95c08
HV		 1484 /* webcams do not have the STD API */
1485 if (dev->board.is_webcam)
1486 i->capabilities = 0;
195a4ef6
MCC		 1487
1488 return 0;
a6c2ba28 1489}
1490
195a4ef6 1491static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
a6c2ba28 1492{
917ba6b0 1493 struct em28xx *dev = video_drvdata(file);
a6c2ba28 1494
195a4ef6
MCC		 1495 *i = dev->ctl_input;
1496
1497 return 0;
1498}
1499
1500static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1501{
917ba6b0 1502 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1503
1504 if (i >= MAX_EM28XX_INPUT)
1505 return -EINVAL;
1506 if (0 == INPUT(i)->type)
1507 return -EINVAL;
a225452e 1508
96371fc8 1509 video_mux(dev, i);
195a4ef6
MCC		 1510 return 0;
1511}
1512
1513static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1514{
917ba6b0 1515 struct em28xx *dev = video_drvdata(file);
195a4ef6 1516
35ae6f04
MCC		 1517 switch (a->index) {
1518 case EM28XX_AMUX_VIDEO:
195a4ef6 1519 strcpy(a->name, "Television");
35ae6f04
MCC		 1520 break;
1521 case EM28XX_AMUX_LINE_IN:
195a4ef6 1522 strcpy(a->name, "Line In");
35ae6f04
MCC		 1523 break;
1524 case EM28XX_AMUX_VIDEO2:
1525 strcpy(a->name, "Television alt");
1526 break;
1527 case EM28XX_AMUX_PHONE:
1528 strcpy(a->name, "Phone");
1529 break;
1530 case EM28XX_AMUX_MIC:
1531 strcpy(a->name, "Mic");
1532 break;
1533 case EM28XX_AMUX_CD:
1534 strcpy(a->name, "CD");
1535 break;
1536 case EM28XX_AMUX_AUX:
1537 strcpy(a->name, "Aux");
1538 break;
1539 case EM28XX_AMUX_PCM_OUT:
1540 strcpy(a->name, "PCM");
1541 break;
1542 default:
1543 return -EINVAL;
1544 }
6ea54d93 1545
35ae6f04 1546 a->index = dev->ctl_ainput;
195a4ef6 1547 a->capability = V4L2_AUDCAP_STEREO;
195a4ef6
MCC		 1548
1549 return 0;
1550}
1551
0e8025b9 1552static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
195a4ef6 1553{
917ba6b0 1554 struct em28xx *dev = video_drvdata(file);
195a4ef6 1555
24c3c415
MCC		 1556 if (a->index >= MAX_EM28XX_INPUT)
1557 return -EINVAL;
1558 if (0 == INPUT(a->index)->type)
1559 return -EINVAL;
1560
35ae6f04
MCC		 1561 dev->ctl_ainput = INPUT(a->index)->amux;
1562 dev->ctl_aoutput = INPUT(a->index)->aout;
e879b8eb
MCC		 1563
1564 if (!dev->ctl_aoutput)
1565 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
efc52a94 1566
195a4ef6
MCC		 1567 return 0;
1568}
1569
195a4ef6 1570static int vidioc_g_tuner(struct file *file, void *priv,
fdf1bc9f 1571 struct v4l2_tuner *t)
a6c2ba28 1572{
917ba6b0 1573 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1574
1575 if (0 != t->index)
1576 return -EINVAL;
1577
1578 strcpy(t->name, "Tuner");
1579
95d2608b 1580 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
195a4ef6 1581 return 0;
a6c2ba28 1582}
1583
195a4ef6 1584static int vidioc_s_tuner(struct file *file, void *priv,
fdf1bc9f 1585 const struct v4l2_tuner *t)
a6c2ba28 1586{
917ba6b0 1587 struct em28xx *dev = video_drvdata(file);
195a4ef6
MCC		 1588
1589 if (0 != t->index)
1590 return -EINVAL;
1591
95d2608b 1592 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
195a4ef6 1593 return 0;
a6c2ba28 1594}
1595
195a4ef6 1596static int vidioc_g_frequency(struct file *file, void *priv,
fdf1bc9f 1597 struct v4l2_frequency *f)
195a4ef6 1598{
917ba6b0 1599 struct em28xx *dev = video_drvdata(file);
3854b0d8 1600 struct em28xx_v4l2 *v4l2 = dev->v4l2;
a6c2ba28 1601
20deebfe
HV		 1602 if (0 != f->tuner)
1603 return -EINVAL;
1604
3854b0d8 1605 f->frequency = v4l2->frequency;
195a4ef6
MCC		 1606 return 0;
1607}
1608
1609static int vidioc_s_frequency(struct file *file, void *priv,
fdf1bc9f 1610 const struct v4l2_frequency *f)
a6c2ba28 1611{
95d2608b 1612 struct v4l2_frequency new_freq = *f;
917ba6b0 1613 struct em28xx *dev = video_drvdata(file);
95d2608b 1614 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6
MCC		 1615
1616 if (0 != f->tuner)
1617 return -EINVAL;
1618
95d2608b
FS		 1619 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1620 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
3854b0d8 1621 v4l2->frequency = new_freq.frequency;
a6c2ba28 1622
195a4ef6
MCC		 1623 return 0;
1624}
a6c2ba28 1625
cd634f1b 1626#ifdef CONFIG_VIDEO_ADV_DEBUG
96b03d2a 1627static int vidioc_g_chip_info(struct file *file, void *priv,
fdf1bc9f 1628 struct v4l2_dbg_chip_info *chip)
3b2d17b4 1629{
917ba6b0 1630 struct em28xx *dev = video_drvdata(file);
3b2d17b4
HV		 1631
1632 if (chip->match.addr > 1)
1633 return -EINVAL;
1634 if (chip->match.addr == 1)
1635 strlcpy(chip->name, "ac97", sizeof(chip->name));
1636 else
95d2608b
FS		 1637 strlcpy(chip->name,
1638 dev->v4l2->v4l2_dev.name, sizeof(chip->name));
3b2d17b4
HV		 1639 return 0;
1640}
1641
35deba32
FS		 1642static int em28xx_reg_len(int reg)
1643{
1644 switch (reg) {
1645 case EM28XX_R40_AC97LSB:
1646 case EM28XX_R30_HSCALELOW:
1647 case EM28XX_R32_VSCALELOW:
1648 return 2;
1649 default:
1650 return 1;
1651 }
1652}
14983d81 1653
1e7ad56f 1654static int vidioc_g_register(struct file *file, void *priv,
aecde8b5 1655 struct v4l2_dbg_register *reg)
1e7ad56f 1656{
917ba6b0 1657 struct em28xx *dev = video_drvdata(file);
1e7ad56f
MCC		 1658 int ret;
1659
abca2056
HV		 1660 if (reg->match.addr > 1)
1661 return -EINVAL;
1662 if (reg->match.addr) {
531c98e7 1663 ret = em28xx_read_ac97(dev, reg->reg);
531c98e7
MCC		 1664 if (ret < 0)
1665 return ret;
1666
1667 reg->val = ret;
aecde8b5 1668 reg->size = 1;
531c98e7 1669 return 0;
14983d81 1670 }
1e7ad56f 1671
14983d81 1672 /* Match host */
aecde8b5
HV		 1673 reg->size = em28xx_reg_len(reg->reg);
1674 if (reg->size == 1) {
1e7ad56f 1675 ret = em28xx_read_reg(dev, reg->reg);
efc52a94 1676
1e7ad56f
MCC		 1677 if (ret < 0)
1678 return ret;
1679
1680 reg->val = ret;
1681 } else {
aecde8b5 1682 __le16 val = 0;
fdf1bc9f 1683
01c28193 1684 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1e7ad56f
MCC		 1685 reg->reg, (char *)&val, 2);
1686 if (ret < 0)
1687 return ret;
1688
aecde8b5 1689 reg->val = le16_to_cpu(val);
1e7ad56f
MCC		 1690 }
1691
1692 return 0;
1693}
1694
1695static int vidioc_s_register(struct file *file, void *priv,
977ba3b1 1696 const struct v4l2_dbg_register *reg)
1e7ad56f 1697{
917ba6b0 1698 struct em28xx *dev = video_drvdata(file);
aecde8b5 1699 __le16 buf;
1e7ad56f 1700
abca2056 1701 if (reg->match.addr > 1)
3b2d17b4 1702 return -EINVAL;
abca2056
HV		 1703 if (reg->match.addr)
1704 return em28xx_write_ac97(dev, reg->reg, reg->val);
531c98e7 1705
14983d81 1706 /* Match host */
aecde8b5 1707 buf = cpu_to_le16(reg->val);
1e7ad56f 1708
0499a5aa 1709 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
efc52a94 1710 em28xx_reg_len(reg->reg));
1e7ad56f
MCC		 1711}
1712#endif
1713
195a4ef6 1714static int vidioc_querycap(struct file *file, void *priv,
fdf1bc9f 1715 struct v4l2_capability *cap)
a6c2ba28 1716{
ef74a0b9 1717 struct video_device *vdev = video_devdata(file);
917ba6b0 1718 struct em28xx *dev = video_drvdata(file);
ef74a0b9 1719 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6
MCC		 1720
1721 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1722 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
cb97716f 1723 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
195a4ef6 1724
a9d79fe5
HV		 1725 if (vdev->vfl_type == VFL_TYPE_GRABBER)
1726 cap->device_caps = V4L2_CAP_READWRITE |
1727 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1728 else if (vdev->vfl_type == VFL_TYPE_RADIO)
1729 cap->device_caps = V4L2_CAP_RADIO;
1730 else
1d179eee 1731 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
0414614a 1732
920f1e4a 1733 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
a9d79fe5 1734 cap->device_caps |= V4L2_CAP_AUDIO;
6c428b57 1735
ed086314 1736 if (dev->tuner_type != TUNER_ABSENT)
a9d79fe5 1737 cap->device_caps |= V4L2_CAP_TUNER;
195a4ef6 1738
a9d79fe5
HV		 1739 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1740 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
d4352f36 1741 if (video_is_registered(&v4l2->vbi_dev))
1d179eee 1742 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
d4352f36 1743 if (video_is_registered(&v4l2->radio_dev))
a9d79fe5 1744 cap->capabilities |= V4L2_CAP_RADIO;
195a4ef6 1745 return 0;
c0477ad9
MCC		 1746}
1747
78b526a4 1748static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
fdf1bc9f 1749 struct v4l2_fmtdesc *f)
a6c2ba28 1750{
bddcf633 1751 if (unlikely(f->index >= ARRAY_SIZE(format)))
c0477ad9 1752 return -EINVAL;
195a4ef6 1753
bddcf633
MCC		 1754 strlcpy(f->description, format[f->index].name, sizeof(f->description));
1755 f->pixelformat = format[f->index].fourcc;
195a4ef6
MCC		 1756
1757 return 0;
c0477ad9
MCC		 1758}
1759
1c5c5068
MCC		 1760static int vidioc_enum_framesizes(struct file *file, void *priv,
1761 struct v4l2_frmsizeenum *fsize)
1762{
917ba6b0 1763 struct em28xx *dev = video_drvdata(file);
1c5c5068
MCC		 1764 struct em28xx_fmt *fmt;
1765 unsigned int maxw = norm_maxw(dev);
1766 unsigned int maxh = norm_maxh(dev);
1767
1768 fmt = format_by_fourcc(fsize->pixel_format);
1769 if (!fmt) {
1770 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1771 fsize->pixel_format);
1772 return -EINVAL;
1773 }
1774
1775 if (dev->board.is_em2800) {
1776 if (fsize->index > 1)
1777 return -EINVAL;
1778 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1779 fsize->discrete.width = maxw / (1 + fsize->index);
1780 fsize->discrete.height = maxh / (1 + fsize->index);
1781 return 0;
1782 }
1783
1784 if (fsize->index != 0)
1785 return -EINVAL;
1786
1787 /* Report a continuous range */
1788 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
6c3598e6
FS		 1789 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1790 &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1791 if (fsize->stepwise.min_width < 48)
1792 fsize->stepwise.min_width = 48;
1793 if (fsize->stepwise.min_height < 38)
1794 fsize->stepwise.min_height = 38;
1c5c5068
MCC		 1795 fsize->stepwise.max_width = maxw;
1796 fsize->stepwise.max_height = maxh;
1797 fsize->stepwise.step_width = 1;
1798 fsize->stepwise.step_height = 1;
1799 return 0;
1800}
1801
28abf083
DH		 1802/* RAW VBI ioctls */
1803
1804static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1805 struct v4l2_format *format)
1806{
917ba6b0 1807 struct em28xx *dev = video_drvdata(file);
753aee77 1808 struct em28xx_v4l2 *v4l2 = dev->v4l2;
66d9cbad 1809
753aee77 1810 format->fmt.vbi.samples_per_line = v4l2->vbi_width;
28abf083
DH		 1811 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1812 format->fmt.vbi.offset = 0;
1813 format->fmt.vbi.flags = 0;
66d9cbad 1814 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
753aee77
FS		 1815 format->fmt.vbi.count[0] = v4l2->vbi_height;
1816 format->fmt.vbi.count[1] = v4l2->vbi_height;
2a221d34 1817 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
28abf083
DH		 1818
1819 /* Varies by video standard (NTSC, PAL, etc.) */
52faaf78 1820 if (v4l2->norm & V4L2_STD_525_60) {
66d9cbad
DH		 1821 /* NTSC */
1822 format->fmt.vbi.start[0] = 10;
1823 format->fmt.vbi.start[1] = 273;
52faaf78 1824 } else if (v4l2->norm & V4L2_STD_625_50) {
66d9cbad
DH		 1825 /* PAL */
1826 format->fmt.vbi.start[0] = 6;
1827 format->fmt.vbi.start[1] = 318;
1828 }
28abf083
DH		 1829
1830 return 0;
1831}
1832
0be43754
MCC		 1833/* ----------------------------------------------------------- */
1834/* RADIO ESPECIFIC IOCTLS */
1835/* ----------------------------------------------------------- */
1836
0be43754
MCC		 1837static int radio_g_tuner(struct file *file, void *priv,
1838 struct v4l2_tuner *t)
1839{
917ba6b0 1840 struct em28xx *dev = video_drvdata(file);
0be43754
MCC		 1841
1842 if (unlikely(t->index > 0))
1843 return -EINVAL;
1844
1845 strcpy(t->name, "Radio");
0be43754 1846
95d2608b 1847 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
efc52a94 1848
0be43754
MCC		 1849 return 0;
1850}
1851
0be43754 1852static int radio_s_tuner(struct file *file, void *priv,
2f73c7c5 1853 const struct v4l2_tuner *t)
0be43754 1854{
917ba6b0 1855 struct em28xx *dev = video_drvdata(file);
0be43754
MCC		 1856
1857 if (0 != t->index)
1858 return -EINVAL;
1859
95d2608b 1860 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
0be43754
MCC		 1861
1862 return 0;
1863}
1864
95d2608b
FS		 1865/*
1866 * em28xx_free_v4l2() - Free struct em28xx_v4l2
1867 *
1868 * @ref: struct kref for struct em28xx_v4l2
1869 *
1870 * Called when all users of struct em28xx_v4l2 are gone
1871 */
f472c0b5 1872static void em28xx_free_v4l2(struct kref *ref)
95d2608b
FS		 1873{
1874 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
1875
abc1308f 1876 v4l2->dev->v4l2 = NULL;
95d2608b
FS		 1877 kfree(v4l2);
1878}
1879
195a4ef6
MCC		 1880/*
1881 * em28xx_v4l2_open()
1882 * inits the device and starts isoc transfer
1883 */
bec43661 1884static int em28xx_v4l2_open(struct file *filp)
195a4ef6 1885{
63b0d5ad
LP		 1886 struct video_device *vdev = video_devdata(filp);
1887 struct em28xx *dev = video_drvdata(filp);
95d2608b 1888 struct em28xx_v4l2 *v4l2 = dev->v4l2;
63b0d5ad 1889 enum v4l2_buf_type fh_type = 0;
3c0f90e1 1890 int ret;
2d50f847 1891
63b0d5ad
LP		 1892 switch (vdev->vfl_type) {
1893 case VFL_TYPE_GRABBER:
1894 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1895 break;
1896 case VFL_TYPE_VBI:
1897 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1898 break;
4e170240
FS		 1899 case VFL_TYPE_RADIO:
1900 break;
1901 default:
1902 return -EINVAL;
63b0d5ad 1903 }
818a557e 1904
8e2c8717
FS		 1905 em28xx_videodbg("open dev=%s type=%s users=%d\n",
1906 video_device_node_name(vdev), v4l2_type_names[fh_type],
1907 v4l2->users);
2d50f847 1908
876cb14d
HV		 1909 if (mutex_lock_interruptible(&dev->lock))
1910 return -ERESTARTSYS;
3c0f90e1
FS		 1911
1912 ret = v4l2_fh_open(filp);
1913 if (ret) {
1914 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n",
1915 __func__, ret);
876cb14d 1916 mutex_unlock(&dev->lock);
3c0f90e1 1917 return ret;
195a4ef6 1918 }
9aeb4b05 1919
8e2c8717 1920 if (v4l2->users == 0) {
c67ec53f 1921 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2d50f847 1922
4e170240
FS		 1923 if (vdev->vfl_type != VFL_TYPE_RADIO)
1924 em28xx_resolution_set(dev);
1925
1926 /*
1927 * Needed, since GPIO might have disabled power
1928 * of some i2c devices
c67ec53f 1929 */
1a23f81b 1930 em28xx_wake_i2c(dev);
2d50f847 1931 }
d3829fad
DH		 1932
1933 if (vdev->vfl_type == VFL_TYPE_RADIO) {
0be43754 1934 em28xx_videodbg("video_open: setting radio device\n");
95d2608b 1935 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
0be43754 1936 }
2d50f847 1937
47677e51 1938 kref_get(&dev->ref);
95d2608b 1939 kref_get(&v4l2->ref);
8e2c8717 1940 v4l2->users++;
2d50f847 1941
876cb14d 1942 mutex_unlock(&dev->lock);
c67ec53f 1943
d3829fad 1944 return 0;
2d50f847 1945}
e5589bef 1946
a6c2ba28 1947/*
01c28193 1948 * em28xx_v4l2_fini()
195a4ef6
MCC		 1949 * unregisters the v4l2,i2c and usb devices
1950 * called when the device gets disconected or at module unload
1951*/
01c28193 1952static int em28xx_v4l2_fini(struct em28xx *dev)
a6c2ba28 1953{
95d2608b
FS		 1954 struct em28xx_v4l2 *v4l2 = dev->v4l2;
1955
822b8dea
MCC		 1956 if (dev->is_audio_only) {
1957 /* Shouldn't initialize IR for this interface */
1958 return 0;
1959 }
1960
01c28193
MCC		 1961 if (!dev->has_video) {
1962 /* This device does not support the v4l2 extension */
1963 return 0;
1964 }
a6c2ba28 1965
95d2608b
FS		 1966 if (v4l2 == NULL)
1967 return 0;
1968
0418ca60 1969 em28xx_info("Closing video extension\n");
aa929ad7 1970
ebbfbc20
MCC		 1971 mutex_lock(&dev->lock);
1972
95d2608b 1973 v4l2_device_disconnect(&v4l2->v4l2_dev);
5ad10de6 1974
23e8642c
FS		 1975 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1976
d4352f36 1977 if (video_is_registered(&v4l2->radio_dev)) {
e847022a 1978 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1979 video_device_node_name(&v4l2->radio_dev));
1980 video_unregister_device(&v4l2->radio_dev);
0be43754 1981 }
d4352f36 1982 if (video_is_registered(&v4l2->vbi_dev)) {
38c7c036 1983 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1984 video_device_node_name(&v4l2->vbi_dev));
1985 video_unregister_device(&v4l2->vbi_dev);
0be43754 1986 }
d4352f36 1987 if (video_is_registered(&v4l2->vdev)) {
38c7c036 1988 em28xx_info("V4L2 device %s deregistered\n",
d4352f36
HV		 1989 video_device_node_name(&v4l2->vdev));
1990 video_unregister_device(&v4l2->vdev);
0be43754 1991 }
01c28193 1992
abc1308f 1993 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
95d2608b 1994 v4l2_device_unregister(&v4l2->v4l2_dev);
103f18a2 1995
2c52a2fc
FS		 1996 if (v4l2->clk) {
1997 v4l2_clk_unregister_fixed(v4l2->clk);
1998 v4l2->clk = NULL;
25dd1652
FS		 1999 }
2000
95d2608b
FS		 2001 kref_put(&v4l2->ref, em28xx_free_v4l2);
2002
ebbfbc20 2003 mutex_unlock(&dev->lock);
95d2608b 2004
47677e51 2005 kref_put(&dev->ref, em28xx_free_device);
5ad10de6 2006
01c28193 2007 return 0;
195a4ef6 2008}
a6c2ba28 2009
a61f6811
SK		 2010static int em28xx_v4l2_suspend(struct em28xx *dev)
2011{
2012 if (dev->is_audio_only)
2013 return 0;
2014
2015 if (!dev->has_video)
2016 return 0;
2017
32e63f03 2018 em28xx_info("Suspending video extension\n");
a61f6811
SK		 2019 em28xx_stop_urbs(dev);
2020 return 0;
2021}
2022
2023static int em28xx_v4l2_resume(struct em28xx *dev)
2024{
2025 if (dev->is_audio_only)
2026 return 0;
2027
2028 if (!dev->has_video)
2029 return 0;
2030
32e63f03 2031 em28xx_info("Resuming video extension\n");
a61f6811
SK		 2032 /* what do we do here */
2033 return 0;
2034}
2035
195a4ef6
MCC		 2036/*
2037 * em28xx_v4l2_close()
6ea54d93
DSL		 2038 * stops streaming and deallocates all resources allocated by the v4l2
2039 * calls and ioctls
195a4ef6 2040 */
bec43661 2041static int em28xx_v4l2_close(struct file *filp)
195a4ef6 2042{
917ba6b0 2043 struct em28xx *dev = video_drvdata(filp);
95d2608b 2044 struct em28xx_v4l2 *v4l2 = dev->v4l2;
195a4ef6 2045 int errCode;
a6c2ba28 2046
8e2c8717 2047 em28xx_videodbg("users=%d\n", v4l2->users);
8c873d31 2048
8e2c8717
FS		 2049 vb2_fop_release(filp);
2050 mutex_lock(&dev->lock);
747dba7d 2051
8e2c8717 2052 if (v4l2->users == 1) {
47677e51
MCC		 2053 /* No sense to try to write to the device */
2054 if (dev->disconnected)
01c28193 2055 goto exit;
a6c2ba28 2056
eb6c9634 2057 /* Save some power by putting tuner to sleep */
95d2608b 2058 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
eb6c9634 2059
d7aa8020 2060 /* do this before setting alternate! */
2fe3e2ee 2061 em28xx_set_mode(dev, EM28XX_SUSPEND);
d7aa8020 2062
195a4ef6
MCC		 2063 /* set alternate 0 */
2064 dev->alt = 0;
2065 em28xx_videodbg("setting alternate 0\n");
2066 errCode = usb_set_interface(dev->udev, 0, 0);
2067 if (errCode < 0) {
2068 em28xx_errdev("cannot change alternate number to "
2069 "0 (error=%i)\n", errCode);
2070 }
9aeb4b05 2071 }
28abf083 2072
01c28193 2073exit:
8e2c8717 2074 v4l2->users--;
95d2608b 2075 kref_put(&v4l2->ref, em28xx_free_v4l2);
876cb14d 2076 mutex_unlock(&dev->lock);
47677e51
MCC		 2077 kref_put(&dev->ref, em28xx_free_device);
2078
195a4ef6
MCC		 2079 return 0;
2080}
a6c2ba28 2081
bec43661 2082static const struct v4l2_file_operations em28xx_v4l_fops = {
195a4ef6
MCC		 2083 .owner = THIS_MODULE,
2084 .open = em28xx_v4l2_open,
2085 .release = em28xx_v4l2_close,
d3829fad
DH		 2086 .read = vb2_fop_read,
2087 .poll = vb2_fop_poll,
2088 .mmap = vb2_fop_mmap,
0499a5aa 2089 .unlocked_ioctl = video_ioctl2,
195a4ef6 2090};
17cbe2e5 2091
a399810c 2092static const struct v4l2_ioctl_ops video_ioctl_ops = {
195a4ef6 2093 .vidioc_querycap = vidioc_querycap,
78b526a4
HV		 2094 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2095 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2096 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2097 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
28abf083 2098 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2a221d34 2099 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
aab34618 2100 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1c5c5068 2101 .vidioc_enum_framesizes = vidioc_enum_framesizes,
195a4ef6
MCC		 2102 .vidioc_g_audio = vidioc_g_audio,
2103 .vidioc_s_audio = vidioc_s_audio,
195a4ef6 2104
d3829fad
DH		 2105 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2106 .vidioc_create_bufs = vb2_ioctl_create_bufs,
2107 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
2108 .vidioc_querybuf = vb2_ioctl_querybuf,
2109 .vidioc_qbuf = vb2_ioctl_qbuf,
2110 .vidioc_dqbuf = vb2_ioctl_dqbuf,
2111
19bf0038 2112 .vidioc_g_std = vidioc_g_std,
d56ae6fb 2113 .vidioc_querystd = vidioc_querystd,
195a4ef6 2114 .vidioc_s_std = vidioc_s_std,
d96ecda6
MCC		 2115 .vidioc_g_parm = vidioc_g_parm,
2116 .vidioc_s_parm = vidioc_s_parm,
195a4ef6
MCC		 2117 .vidioc_enum_input = vidioc_enum_input,
2118 .vidioc_g_input = vidioc_g_input,
2119 .vidioc_s_input = vidioc_s_input,
d3829fad
DH		 2120 .vidioc_streamon = vb2_ioctl_streamon,
2121 .vidioc_streamoff = vb2_ioctl_streamoff,
195a4ef6
MCC		 2122 .vidioc_g_tuner = vidioc_g_tuner,
2123 .vidioc_s_tuner = vidioc_s_tuner,
2124 .vidioc_g_frequency = vidioc_g_frequency,
2125 .vidioc_s_frequency = vidioc_s_frequency,
50fdf40f
HV		 2126 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2127 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1e7ad56f 2128#ifdef CONFIG_VIDEO_ADV_DEBUG
96b03d2a 2129 .vidioc_g_chip_info = vidioc_g_chip_info,
1e7ad56f
MCC		 2130 .vidioc_g_register = vidioc_g_register,
2131 .vidioc_s_register = vidioc_s_register,
2132#endif
a399810c
HV		 2133};
2134
2135static const struct video_device em28xx_video_template = {
e847022a
FS		 2136 .fops = &em28xx_v4l_fops,
2137 .ioctl_ops = &video_ioctl_ops,
d4352f36 2138 .release = video_device_release_empty,
e847022a 2139 .tvnorms = V4L2_STD_ALL,
a6c2ba28 2140};
2141
bec43661 2142static const struct v4l2_file_operations radio_fops = {
a399810c
HV		 2143 .owner = THIS_MODULE,
2144 .open = em28xx_v4l2_open,
2145 .release = em28xx_v4l2_close,
8fd0bda5 2146 .unlocked_ioctl = video_ioctl2,
a399810c
HV		 2147};
2148
2149static const struct v4l2_ioctl_ops radio_ioctl_ops = {
a9d79fe5 2150 .vidioc_querycap = vidioc_querycap,
0be43754 2151 .vidioc_g_tuner = radio_g_tuner,
0be43754 2152 .vidioc_s_tuner = radio_s_tuner,
0be43754
MCC		 2153 .vidioc_g_frequency = vidioc_g_frequency,
2154 .vidioc_s_frequency = vidioc_s_frequency,
50fdf40f
HV		 2155 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2156 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1e7ad56f 2157#ifdef CONFIG_VIDEO_ADV_DEBUG
430c73fa 2158 .vidioc_g_chip_info = vidioc_g_chip_info,
1e7ad56f
MCC		 2159 .vidioc_g_register = vidioc_g_register,
2160 .vidioc_s_register = vidioc_s_register,
2161#endif
0be43754
MCC		 2162};
2163
a399810c 2164static struct video_device em28xx_radio_template = {
e847022a
FS		 2165 .fops = &radio_fops,
2166 .ioctl_ops = &radio_ioctl_ops,
d4352f36 2167 .release = video_device_release_empty,
a399810c
HV		 2168};
2169
b64f8e9a
MCC		 2170/* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2171static unsigned short saa711x_addrs[] = {
2172 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */
2173 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */
2174 I2C_CLIENT_END };
2175
2176static unsigned short tvp5150_addrs[] = {
2177 0xb8 >> 1,
2178 0xba >> 1,
2179 I2C_CLIENT_END
2180};
2181
2182static unsigned short msp3400_addrs[] = {
2183 0x80 >> 1,
2184 0x88 >> 1,
2185 I2C_CLIENT_END
2186};
2187
6ea54d93 2188/******************************** usb interface ******************************/
a6c2ba28 2189
d4352f36
HV		 2190static void em28xx_vdev_init(struct em28xx *dev,
2191 struct video_device *vfd,
2192 const struct video_device *template,
2193 const char *type_name)
0be43754 2194{
f2cf250a 2195 *vfd = *template;
95d2608b 2196 vfd->v4l2_dev = &dev->v4l2->v4l2_dev;
0499a5aa 2197 vfd->lock = &dev->lock;
d8c95c08
HV		 2198 if (dev->board.is_webcam)
2199 vfd->tvnorms = 0;
0be43754
MCC		 2200
2201 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2202 dev->name, type_name);
2203
63b0d5ad 2204 video_set_drvdata(vfd, dev);
0be43754
MCC		 2205}
2206
3319e6f8 2207static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
0560f337 2208{
3854b0d8
FS		 2209 struct em28xx_v4l2 *v4l2 = dev->v4l2;
2210 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev;
2211 struct tuner_setup tun_setup;
2212 struct v4l2_frequency f;
0560f337 2213
0560f337
MCC		 2214 memset(&tun_setup, 0, sizeof(tun_setup));
2215
2216 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2217 tun_setup.tuner_callback = em28xx_tuner_callback;
2218
2219 if (dev->board.radio.type) {
2220 tun_setup.type = dev->board.radio.type;
2221 tun_setup.addr = dev->board.radio_addr;
2222
95d2608b
FS		 2223 v4l2_device_call_all(v4l2_dev,
2224 0, tuner, s_type_addr, &tun_setup);
0560f337
MCC		 2225 }
2226
2227 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2228 tun_setup.type = dev->tuner_type;
3319e6f8 2229 tun_setup.addr = tuner_addr;
0560f337 2230
95d2608b
FS		 2231 v4l2_device_call_all(v4l2_dev,
2232 0, tuner, s_type_addr, &tun_setup);
0560f337
MCC		 2233 }
2234
6867bd5a 2235 if (dev->board.tda9887_conf) {
0560f337
MCC		 2236 struct v4l2_priv_tun_config tda9887_cfg;
2237
2238 tda9887_cfg.tuner = TUNER_TDA9887;
6867bd5a 2239 tda9887_cfg.priv = &dev->board.tda9887_conf;
0560f337 2240
95d2608b
FS		 2241 v4l2_device_call_all(v4l2_dev,
2242 0, tuner, s_config, &tda9887_cfg);
0560f337
MCC		 2243 }
2244
2245 if (dev->tuner_type == TUNER_XC2028) {
2246 struct v4l2_priv_tun_config xc2028_cfg;
2247 struct xc2028_ctrl ctl;
2248
2249 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2250 memset(&ctl, 0, sizeof(ctl));
2251
2252 em28xx_setup_xc3028(dev, &ctl);
2253
2254 xc2028_cfg.tuner = TUNER_XC2028;
2255 xc2028_cfg.priv = &ctl;
2256
95d2608b 2257 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
0560f337
MCC		 2258 }
2259
2260 /* configure tuner */
2261 f.tuner = 0;
2262 f.type = V4L2_TUNER_ANALOG_TV;
2263 f.frequency = 9076; /* just a magic number */
3854b0d8 2264 v4l2->frequency = f.frequency;
95d2608b 2265 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
0560f337
MCC		 2266}
2267
01c28193 2268static int em28xx_v4l2_init(struct em28xx *dev)
1a23f81b 2269{
081b945e 2270 u8 val;
2e5ef2df 2271 int ret;
1020d13d 2272 unsigned int maxw;
abc1308f 2273 struct v4l2_ctrl_handler *hdl;
95d2608b 2274 struct em28xx_v4l2 *v4l2;
b64f8e9a 2275
822b8dea
MCC		 2276 if (dev->is_audio_only) {
2277 /* Shouldn't initialize IR for this interface */
2278 return 0;
2279 }
2280
01c28193 2281 if (!dev->has_video) {
b64f8e9a
MCC		 2282 /* This device does not support the v4l2 extension */
2283 return 0;
2284 }
2e5ef2df 2285
9634614f 2286 em28xx_info("Registering V4L2 extension\n");
1a23f81b 2287
01c28193
MCC		 2288 mutex_lock(&dev->lock);
2289
95d2608b
FS		 2290 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2291 if (v4l2 == NULL) {
2292 em28xx_info("em28xx_v4l: memory allocation failed\n");
2293 mutex_unlock(&dev->lock);
2294 return -ENOMEM;
2295 }
2296 kref_init(&v4l2->ref);
abc1308f 2297 v4l2->dev = dev;
95d2608b
FS		 2298 dev->v4l2 = v4l2;
2299
2300 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev);
b64f8e9a
MCC		 2301 if (ret < 0) {
2302 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2303 goto err;
2304 }
2305
abc1308f 2306 hdl = &v4l2->ctrl_handler;
b64f8e9a 2307 v4l2_ctrl_handler_init(hdl, 8);
95d2608b 2308 v4l2->v4l2_dev.ctrl_handler = hdl;
b64f8e9a 2309
58159171 2310 if (dev->board.is_webcam)
7e6c8c19 2311 v4l2->progressive = true;
58159171 2312
b64f8e9a
MCC		 2313 /*
2314 * Default format, used for tvp5150 or saa711x output formats
2315 */
9297285e
FS		 2316 v4l2->vinmode = 0x10;
2317 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED |
2318 EM28XX_VINCTRL_CCIR656_ENABLE;
b64f8e9a
MCC		 2319
2320 /* request some modules */
2321
2322 if (dev->board.has_msp34xx)
95d2608b
FS		 2323 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2324 &dev->i2c_adap[dev->def_i2c_bus],
2325 "msp3400", 0, msp3400_addrs);
b64f8e9a
MCC		 2326
2327 if (dev->board.decoder == EM28XX_SAA711X)
95d2608b
FS		 2328 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2329 &dev->i2c_adap[dev->def_i2c_bus],
2330 "saa7115_auto", 0, saa711x_addrs);
b64f8e9a
MCC		 2331
2332 if (dev->board.decoder == EM28XX_TVP5150)
95d2608b
FS		 2333 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2334 &dev->i2c_adap[dev->def_i2c_bus],
2335 "tvp5150", 0, tvp5150_addrs);
b64f8e9a
MCC		 2336
2337 if (dev->board.adecoder == EM28XX_TVAUDIO)
95d2608b
FS		 2338 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2339 &dev->i2c_adap[dev->def_i2c_bus],
2340 "tvaudio", dev->board.tvaudio_addr, NULL);
b64f8e9a
MCC		 2341
2342 /* Initialize tuner and camera */
2343
2344 if (dev->board.tuner_type != TUNER_ABSENT) {
3319e6f8 2345 unsigned short tuner_addr = dev->board.tuner_addr;
6867bd5a 2346 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
b64f8e9a
MCC		 2347
2348 if (dev->board.radio.type)
95d2608b 2349 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2350 &dev->i2c_adap[dev->def_i2c_bus],
2351 "tuner", dev->board.radio_addr,
2352 NULL);
b64f8e9a
MCC		 2353
2354 if (has_demod)
95d2608b 2355 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2356 &dev->i2c_adap[dev->def_i2c_bus],
2357 "tuner", 0,
2358 v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
3319e6f8 2359 if (tuner_addr == 0) {
b64f8e9a
MCC		 2360 enum v4l2_i2c_tuner_type type =
2361 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2362 struct v4l2_subdev *sd;
2363
95d2608b 2364 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
fdf1bc9f
MCC		 2365 &dev->i2c_adap[dev->def_i2c_bus],
2366 "tuner", 0,
2367 v4l2_i2c_tuner_addrs(type));
b64f8e9a
MCC		 2368
2369 if (sd)
3319e6f8 2370 tuner_addr = v4l2_i2c_subdev_addr(sd);
b64f8e9a 2371 } else {
95d2608b
FS		 2372 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2373 &dev->i2c_adap[dev->def_i2c_bus],
3319e6f8 2374 "tuner", tuner_addr, NULL);
b64f8e9a 2375 }
3319e6f8
FS		 2376
2377 em28xx_tuner_setup(dev, tuner_addr);
b64f8e9a
MCC		 2378 }
2379
d86bc65a
FS		 2380 if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2381 em28xx_init_camera(dev);
b64f8e9a
MCC		 2382
2383 /* Configure audio */
2384 ret = em28xx_audio_setup(dev);
2385 if (ret < 0) {
2386 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
fdf1bc9f 2387 __func__, ret);
b64f8e9a
MCC		 2388 goto unregister_dev;
2389 }
2390 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2391 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
fdf1bc9f 2392 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
b64f8e9a 2393 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
fdf1bc9f 2394 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
b64f8e9a
MCC		 2395 } else {
2396 /* install the em28xx notify callback */
2397 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
fdf1bc9f 2398 em28xx_ctrl_notify, dev);
b64f8e9a 2399 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
fdf1bc9f 2400 em28xx_ctrl_notify, dev);
b64f8e9a
MCC		 2401 }
2402
2403 /* wake i2c devices */
2404 em28xx_wake_i2c(dev);
2405
2406 /* init video dma queues */
2407 INIT_LIST_HEAD(&dev->vidq.active);
2408 INIT_LIST_HEAD(&dev->vbiq.active);
2409
2410 if (dev->board.has_msp34xx) {
2411 /* Send a reset to other chips via gpio */
2412 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2413 if (ret < 0) {
2414 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2415 __func__, ret);
2416 goto unregister_dev;
2417 }
2418 msleep(3);
2419
2420 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2421 if (ret < 0) {
2422 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2423 __func__, ret);
2424 goto unregister_dev;
2425 }
2426 msleep(3);
2427 }
2428
24c3c415 2429 /* set default norm */
52faaf78 2430 v4l2->norm = V4L2_STD_PAL;
8774bed9 2431 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
58159171 2432 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
24c3c415 2433
1a23f81b 2434 /* Analog specific initialization */
06e20672 2435 v4l2->format = &format[0];
1020d13d
SS		 2436
2437 maxw = norm_maxw(dev);
d3829fad
DH		 2438 /* MaxPacketSize for em2800 is too small to capture at full resolution
2439 * use half of maxw as the scaler can only scale to 50% */
2440 if (dev->board.is_em2800)
2441 maxw /= 2;
1020d13d 2442
ed5f1431 2443 em28xx_set_video_format(dev, format[0].fourcc,
1020d13d 2444 maxw, norm_maxh(dev));
ed5f1431 2445
96371fc8 2446 video_mux(dev, 0);
24c3c415
MCC		 2447
2448 /* Audio defaults */
2449 dev->mute = 1;
2450 dev->volume = 0x1f;
1a23f81b 2451
1a23f81b 2452/* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
a1a6ee74
NS		 2453 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2454 em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2455 (EM28XX_XCLK_AUDIO_UNMUTE | val));
1a23f81b 2456
1a23f81b 2457 em28xx_set_outfmt(dev);
1a23f81b 2458
8f8b113a
FS		 2459 /* Add image controls */
2460 /* NOTE: at this point, the subdevices are already registered, so bridge
2461 * controls are only added/enabled when no subdevice provides them */
ad298055
FS		 2462 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2463 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2464 V4L2_CID_CONTRAST,
2465 0, 0x1f, 1, CONTRAST_DEFAULT);
ad298055
FS		 2466 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2467 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2468 V4L2_CID_BRIGHTNESS,
2469 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
ad298055
FS		 2470 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2471 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2472 V4L2_CID_SATURATION,
2473 0, 0x1f, 1, SATURATION_DEFAULT);
ad298055
FS		 2474 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2475 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2476 V4L2_CID_BLUE_BALANCE,
2477 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
ad298055
FS		 2478 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2479 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2480 V4L2_CID_RED_BALANCE,
2481 -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
ad298055
FS		 2482 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2483 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
8f8b113a
FS		 2484 V4L2_CID_SHARPNESS,
2485 0, 0x0f, 1, SHARPNESS_DEFAULT);
2486
2487 /* Reset image controls */
2488 em28xx_colorlevels_set_default(dev);
ad298055
FS		 2489 v4l2_ctrl_handler_setup(hdl);
2490 ret = hdl->error;
b64f8e9a
MCC		 2491 if (ret)
2492 goto unregister_dev;
8f8b113a 2493
818a557e 2494 /* allocate and fill video video_device struct */
d4352f36 2495 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
27a36df6
FS		 2496 mutex_init(&v4l2->vb_queue_lock);
2497 mutex_init(&v4l2->vb_vbi_queue_lock);
d4352f36
HV		 2498 v4l2->vdev.queue = &v4l2->vb_vidq;
2499 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
818a557e 2500
6e46daba
FS		 2501 /* disable inapplicable ioctls */
2502 if (dev->board.is_webcam) {
d4352f36
HV		 2503 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2504 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2505 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
3bc85cce 2506 } else {
d4352f36 2507 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
6e46daba 2508 }
66df67b7 2509 if (dev->tuner_type == TUNER_ABSENT) {
d4352f36
HV		 2510 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2511 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2512 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2513 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
66df67b7 2514 }
920f1e4a 2515 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
d4352f36
HV		 2516 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2517 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
c2dcef83 2518 }
6e46daba 2519
818a557e 2520 /* register v4l2 video video_device */
d4352f36 2521 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
fdf1bc9f 2522 video_nr[dev->devno]);
818a557e
MCC		 2523 if (ret) {
2524 em28xx_errdev("unable to register video device (error=%i).\n",
2525 ret);
b64f8e9a 2526 goto unregister_dev;
818a557e
MCC		 2527 }
2528
2529 /* Allocate and fill vbi video_device struct */
290c0cfa 2530 if (em28xx_vbi_supported(dev) == 1) {
d4352f36
HV		 2531 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2532 "vbi");
818a557e 2533
d4352f36
HV		 2534 v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2535 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
d3829fad 2536
66df67b7 2537 /* disable inapplicable ioctls */
d4352f36 2538 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
66df67b7 2539 if (dev->tuner_type == TUNER_ABSENT) {
d4352f36
HV		 2540 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2541 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2542 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2543 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
66df67b7 2544 }
920f1e4a 2545 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
d4352f36
HV		 2546 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2547 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
c2dcef83 2548 }
66df67b7 2549
290c0cfa 2550 /* register v4l2 vbi video_device */
d4352f36 2551 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
290c0cfa
DH		 2552 vbi_nr[dev->devno]);
2553 if (ret < 0) {
2554 em28xx_errdev("unable to register vbi device\n");
b64f8e9a 2555 goto unregister_dev;
290c0cfa 2556 }
818a557e
MCC		 2557 }
2558
2559 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
d4352f36
HV		 2560 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2561 "radio");
2562 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
818a557e
MCC		 2563 radio_nr[dev->devno]);
2564 if (ret < 0) {
2565 em28xx_errdev("can't register radio device\n");
b64f8e9a 2566 goto unregister_dev;
818a557e 2567 }
38c7c036 2568 em28xx_info("Registered radio device as %s\n",
d4352f36 2569 video_device_node_name(&v4l2->radio_dev));
818a557e
MCC		 2570 }
2571
38c7c036 2572 em28xx_info("V4L2 video device registered as %s\n",
d4352f36 2573 video_device_node_name(&v4l2->vdev));
290c0cfa 2574
d4352f36 2575 if (video_is_registered(&v4l2->vbi_dev))
38c7c036 2576 em28xx_info("V4L2 VBI device registered as %s\n",
d4352f36 2577 video_device_node_name(&v4l2->vbi_dev));
818a557e 2578
b64f8e9a 2579 /* Save some power by putting tuner to sleep */
95d2608b 2580 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
b64f8e9a
MCC		 2581
2582 /* initialize videobuf2 stuff */
2583 em28xx_vb2_setup(dev);
2584
9634614f
MCC		 2585 em28xx_info("V4L2 extension successfully initialized\n");
2586
47677e51
MCC		 2587 kref_get(&dev->ref);
2588
01c28193 2589 mutex_unlock(&dev->lock);
818a557e 2590 return 0;
b64f8e9a
MCC		 2591
2592unregister_dev:
56a7f515
MCC		 2593 if (video_is_registered(&v4l2->radio_dev)) {
2594 em28xx_info("V4L2 device %s deregistered\n",
2595 video_device_node_name(&v4l2->radio_dev));
2596 video_unregister_device(&v4l2->radio_dev);
2597 }
2598 if (video_is_registered(&v4l2->vbi_dev)) {
2599 em28xx_info("V4L2 device %s deregistered\n",
2600 video_device_node_name(&v4l2->vbi_dev));
2601 video_unregister_device(&v4l2->vbi_dev);
2602 }
2603 if (video_is_registered(&v4l2->vdev)) {
2604 em28xx_info("V4L2 device %s deregistered\n",
2605 video_device_node_name(&v4l2->vdev));
2606 video_unregister_device(&v4l2->vdev);
2607 }
2608
abc1308f 2609 v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
95d2608b 2610 v4l2_device_unregister(&v4l2->v4l2_dev);
b64f8e9a 2611err:
95d2608b
FS		 2612 dev->v4l2 = NULL;
2613 kref_put(&v4l2->ref, em28xx_free_v4l2);
01c28193 2614 mutex_unlock(&dev->lock);
b64f8e9a 2615 return ret;
818a557e 2616}
01c28193
MCC		 2617
2618static struct em28xx_ops v4l2_ops = {
2619 .id = EM28XX_V4L2,
2620 .name = "Em28xx v4l2 Extension",
2621 .init = em28xx_v4l2_init,
2622 .fini = em28xx_v4l2_fini,
a61f6811
SK		 2623 .suspend = em28xx_v4l2_suspend,
2624 .resume = em28xx_v4l2_resume,
01c28193
MCC		 2625};
2626
2627static int __init em28xx_video_register(void)
2628{
2629 return em28xx_register_extension(&v4l2_ops);
2630}
2631
2632static void __exit em28xx_video_unregister(void)
2633{
2634 em28xx_unregister_extension(&v4l2_ops);
2635}
2636
2637module_init(em28xx_video_register);
2638module_exit(em28xx_video_unregister);
Linux kernel - Deliverables
This page took 1.054763 seconds and 5 git commands to generate.