1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // DVB USB compliant linux driver for Conexant USB reference design -
4 // (analog part).
5 //
6 // Copyright (C) 2011, 2017, 2018
7 //	Maciej S. Szmigiero (mail@maciej.szmigiero.name)
8 //
9 // In case there are new analog / DVB-T hybrid devices released in the market
10 // using the same general design as Medion MD95700: a CX25840 video decoder
11 // outputting a BT.656 stream to a USB bridge chip which then forwards it to
12 // the host in isochronous USB packets this code should be made generic, with
13 // board specific bits implemented via separate card structures.
14 //
15 // This is, however, unlikely as the Medion model was released
16 // years ago (in 2005).
17 //
18 // TODO:
19 //  * audio support,
20 //  * finish radio support (requires audio of course),
21 //  * VBI support,
22 //  * controls support
23 
24 #include <linux/bitops.h>
25 #include <linux/device.h>
26 #include <linux/slab.h>
27 #include <linux/string.h>
28 #include <linux/ktime.h>
29 #include <linux/vmalloc.h>
30 #include <media/drv-intf/cx25840.h>
31 #include <media/tuner.h>
32 #include <media/v4l2-fh.h>
33 #include <media/v4l2-ioctl.h>
34 #include <media/v4l2-subdev.h>
35 #include <media/videobuf2-vmalloc.h>
36 
37 #include "cxusb.h"
38 
39 static int cxusb_medion_v_queue_setup(struct vb2_queue *q,
40 				      unsigned int *num_buffers,
41 				      unsigned int *num_planes,
42 				      unsigned int sizes[],
43 				      struct device *alloc_devs[])
44 {
45 	struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
46 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
47 	unsigned int size = cxdev->width * cxdev->height * 2;
48 
49 	if (*num_planes > 0) {
50 		if (*num_planes != 1)
51 			return -EINVAL;
52 
53 		if (sizes[0] < size)
54 			return -EINVAL;
55 	} else {
56 		*num_planes = 1;
57 		sizes[0] = size;
58 	}
59 
60 	return 0;
61 }
62 
63 static int cxusb_medion_v_buf_init(struct vb2_buffer *vb)
64 {
65 	struct dvb_usb_device *dvbdev = vb2_get_drv_priv(vb->vb2_queue);
66 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
67 
68 	cxusb_vprintk(dvbdev, OPS, "buffer init\n");
69 
70 	if (vb2_plane_size(vb, 0) < cxdev->width * cxdev->height * 2)
71 		return -ENOMEM;
72 
73 	cxusb_vprintk(dvbdev, OPS, "buffer OK\n");
74 
75 	return 0;
76 }
77 
78 static void cxusb_auxbuf_init(struct dvb_usb_device *dvbdev,
79 			      struct cxusb_medion_auxbuf *auxbuf,
80 			      u8 *buf, unsigned int len)
81 {
82 	cxusb_vprintk(dvbdev, AUXB, "initializing auxbuf of len %u\n", len);
83 
84 	auxbuf->buf = buf;
85 	auxbuf->len = len;
86 	auxbuf->paylen = 0;
87 }
88 
89 static void cxusb_auxbuf_head_trim(struct dvb_usb_device *dvbdev,
90 				   struct cxusb_medion_auxbuf *auxbuf,
91 				   unsigned int pos)
92 {
93 	if (pos == 0)
94 		return;
95 
96 	if (WARN_ON(pos > auxbuf->paylen))
97 		return;
98 
99 	cxusb_vprintk(dvbdev, AUXB,
100 		      "trimming auxbuf len by %u to %u\n",
101 		      pos, auxbuf->paylen - pos);
102 
103 	memmove(auxbuf->buf, auxbuf->buf + pos, auxbuf->paylen - pos);
104 	auxbuf->paylen -= pos;
105 }
106 
107 static unsigned int cxusb_auxbuf_paylen(struct cxusb_medion_auxbuf *auxbuf)
108 {
109 	return auxbuf->paylen;
110 }
111 
112 static bool cxusb_auxbuf_make_space(struct dvb_usb_device *dvbdev,
113 				    struct cxusb_medion_auxbuf *auxbuf,
114 				    unsigned int howmuch)
115 {
116 	unsigned int freespace;
117 
118 	if (WARN_ON(howmuch >= auxbuf->len))
119 		howmuch = auxbuf->len - 1;
120 
121 	freespace = auxbuf->len - cxusb_auxbuf_paylen(auxbuf);
122 
123 	cxusb_vprintk(dvbdev, AUXB, "freespace is %u\n", freespace);
124 
125 	if (freespace >= howmuch)
126 		return true;
127 
128 	howmuch -= freespace;
129 
130 	cxusb_vprintk(dvbdev, AUXB, "will overwrite %u bytes of buffer\n",
131 		      howmuch);
132 
133 	cxusb_auxbuf_head_trim(dvbdev, auxbuf, howmuch);
134 
135 	return false;
136 }
137 
138 /* returns false if some data was overwritten */
139 static bool cxusb_auxbuf_append_urb(struct dvb_usb_device *dvbdev,
140 				    struct cxusb_medion_auxbuf *auxbuf,
141 				    struct urb *urb)
142 {
143 	unsigned long len;
144 	int i;
145 	bool ret;
146 
147 	for (i = 0, len = 0; i < urb->number_of_packets; i++)
148 		len += urb->iso_frame_desc[i].actual_length;
149 
150 	ret = cxusb_auxbuf_make_space(dvbdev, auxbuf, len);
151 
152 	for (i = 0; i < urb->number_of_packets; i++) {
153 		unsigned int to_copy;
154 
155 		to_copy = urb->iso_frame_desc[i].actual_length;
156 
157 		memcpy(auxbuf->buf + auxbuf->paylen, urb->transfer_buffer +
158 		       urb->iso_frame_desc[i].offset, to_copy);
159 
160 		auxbuf->paylen += to_copy;
161 	}
162 
163 	return ret;
164 }
165 
166 static bool cxusb_auxbuf_copy(struct cxusb_medion_auxbuf *auxbuf,
167 			      unsigned int pos, unsigned char *dest,
168 			      unsigned int len)
169 {
170 	if (pos + len > auxbuf->paylen)
171 		return false;
172 
173 	memcpy(dest, auxbuf->buf + pos, len);
174 
175 	return true;
176 }
177 
178 static bool cxusb_medion_cf_refc_fld_chg(struct dvb_usb_device *dvbdev,
179 					 struct cxusb_bt656_params *bt656,
180 					 bool firstfield,
181 					 unsigned int maxlines,
182 					 unsigned int maxlinesamples,
183 					 unsigned char buf[4])
184 {
185 	bool firstfield_code = (buf[3] & CXUSB_BT656_FIELD_MASK) ==
186 		CXUSB_BT656_FIELD_1;
187 	unsigned int remlines;
188 
189 	if (bt656->line == 0 || firstfield == firstfield_code)
190 		return false;
191 
192 	if (bt656->fmode == LINE_SAMPLES) {
193 		unsigned int remsamples = maxlinesamples -
194 			bt656->linesamples;
195 
196 		cxusb_vprintk(dvbdev, BT656,
197 			      "field %c after line %u field change\n",
198 			      firstfield ? '1' : '2', bt656->line);
199 
200 		if (bt656->buf && remsamples > 0) {
201 			memset(bt656->buf, 0, remsamples);
202 			bt656->buf += remsamples;
203 
204 			cxusb_vprintk(dvbdev, BT656,
205 				      "field %c line %u %u samples still remaining (of %u)\n",
206 				      firstfield ? '1' : '2',
207 				      bt656->line, remsamples,
208 				      maxlinesamples);
209 		}
210 
211 		bt656->line++;
212 	}
213 
214 	remlines = maxlines - bt656->line;
215 	if (bt656->buf && remlines > 0) {
216 		memset(bt656->buf, 0, remlines * maxlinesamples);
217 		bt656->buf += remlines * maxlinesamples;
218 
219 		cxusb_vprintk(dvbdev, BT656,
220 			      "field %c %u lines still remaining (of %u)\n",
221 			      firstfield ? '1' : '2', remlines,
222 			      maxlines);
223 	}
224 
225 	return true;
226 }
227 
228 static void cxusb_medion_cf_refc_start_sch(struct dvb_usb_device *dvbdev,
229 					   struct cxusb_bt656_params *bt656,
230 					   bool firstfield,
231 					   unsigned char buf[4])
232 {
233 	bool firstfield_code = (buf[3] & CXUSB_BT656_FIELD_MASK) ==
234 		CXUSB_BT656_FIELD_1;
235 	bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
236 		CXUSB_BT656_SEAV_SAV;
237 	bool vbi_code = (buf[3] & CXUSB_BT656_VBI_MASK) ==
238 		CXUSB_BT656_VBI_ON;
239 
240 	if (!sav_code || firstfield != firstfield_code)
241 		return;
242 
243 	if (!vbi_code) {
244 		cxusb_vprintk(dvbdev, BT656, "line start @ pos %u\n",
245 			      bt656->pos);
246 
247 		bt656->linesamples = 0;
248 		bt656->fmode = LINE_SAMPLES;
249 	} else {
250 		cxusb_vprintk(dvbdev, BT656, "VBI start @ pos %u\n",
251 			      bt656->pos);
252 
253 		bt656->fmode = VBI_SAMPLES;
254 	}
255 }
256 
257 static void cxusb_medion_cf_refc_line_smpl(struct dvb_usb_device *dvbdev,
258 					   struct cxusb_bt656_params *bt656,
259 					   bool firstfield,
260 					   unsigned int maxlinesamples,
261 					   unsigned char buf[4])
262 {
263 	bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
264 		CXUSB_BT656_SEAV_SAV;
265 	unsigned int remsamples;
266 
267 	if (sav_code)
268 		cxusb_vprintk(dvbdev, BT656,
269 			      "SAV in line samples @ line %u, pos %u\n",
270 			      bt656->line, bt656->pos);
271 
272 	remsamples = maxlinesamples - bt656->linesamples;
273 	if (bt656->buf && remsamples > 0) {
274 		memset(bt656->buf, 0, remsamples);
275 		bt656->buf += remsamples;
276 
277 		cxusb_vprintk(dvbdev, BT656,
278 			      "field %c line %u %u samples still remaining (of %u)\n",
279 			      firstfield ? '1' : '2', bt656->line, remsamples,
280 			      maxlinesamples);
281 	}
282 
283 	bt656->fmode = START_SEARCH;
284 	bt656->line++;
285 }
286 
287 static void cxusb_medion_cf_refc_vbi_smpl(struct dvb_usb_device *dvbdev,
288 					  struct cxusb_bt656_params *bt656,
289 					  unsigned char buf[4])
290 {
291 	bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
292 		CXUSB_BT656_SEAV_SAV;
293 
294 	if (sav_code)
295 		cxusb_vprintk(dvbdev, BT656, "SAV in VBI samples @ pos %u\n",
296 			      bt656->pos);
297 
298 	bt656->fmode = START_SEARCH;
299 }
300 
301 /* returns whether the whole 4-byte code should be skipped in the buffer */
302 static bool cxusb_medion_cf_ref_code(struct dvb_usb_device *dvbdev,
303 				     struct cxusb_bt656_params *bt656,
304 				     bool firstfield,
305 				     unsigned int maxlines,
306 				     unsigned int maxlinesamples,
307 				     unsigned char buf[4])
308 {
309 	if (bt656->fmode == START_SEARCH) {
310 		cxusb_medion_cf_refc_start_sch(dvbdev, bt656, firstfield, buf);
311 	} else if (bt656->fmode == LINE_SAMPLES) {
312 		cxusb_medion_cf_refc_line_smpl(dvbdev, bt656, firstfield,
313 					       maxlinesamples, buf);
314 		return false;
315 	} else if (bt656->fmode == VBI_SAMPLES) {
316 		cxusb_medion_cf_refc_vbi_smpl(dvbdev, bt656, buf);
317 		return false;
318 	}
319 
320 	return true;
321 }
322 
323 static bool cxusb_medion_cs_start_sch(struct dvb_usb_device *dvbdev,
324 				      struct cxusb_medion_auxbuf *auxbuf,
325 				      struct cxusb_bt656_params *bt656,
326 				      unsigned int maxlinesamples)
327 {
328 	unsigned char buf[64];
329 	unsigned int idx;
330 	unsigned int tocheck = clamp_t(size_t, maxlinesamples / 4, 3,
331 				       sizeof(buf));
332 
333 	if (!cxusb_auxbuf_copy(auxbuf, bt656->pos + 1, buf, tocheck))
334 		return false;
335 
336 	for (idx = 0; idx <= tocheck - 3; idx++)
337 		if (memcmp(buf + idx, CXUSB_BT656_PREAMBLE, 3) == 0) {
338 			bt656->pos += (1 + idx);
339 			return true;
340 		}
341 
342 	cxusb_vprintk(dvbdev, BT656, "line %u early start, pos %u\n",
343 		      bt656->line, bt656->pos);
344 
345 	bt656->linesamples = 0;
346 	bt656->fmode = LINE_SAMPLES;
347 
348 	return true;
349 }
350 
351 static void cxusb_medion_cs_line_smpl(struct cxusb_bt656_params *bt656,
352 				      unsigned int maxlinesamples,
353 				      unsigned char val)
354 {
355 	if (bt656->buf)
356 		*(bt656->buf++) = val;
357 
358 	bt656->linesamples++;
359 	bt656->pos++;
360 
361 	if (bt656->linesamples >= maxlinesamples) {
362 		bt656->fmode = START_SEARCH;
363 		bt656->line++;
364 	}
365 }
366 
367 static bool cxusb_medion_copy_samples(struct dvb_usb_device *dvbdev,
368 				      struct cxusb_medion_auxbuf *auxbuf,
369 				      struct cxusb_bt656_params *bt656,
370 				      unsigned int maxlinesamples,
371 				      unsigned char val)
372 {
373 	if (bt656->fmode == START_SEARCH && bt656->line > 0)
374 		return cxusb_medion_cs_start_sch(dvbdev, auxbuf, bt656,
375 						 maxlinesamples);
376 	else if (bt656->fmode == LINE_SAMPLES)
377 		cxusb_medion_cs_line_smpl(bt656, maxlinesamples, val);
378 	else /* TODO: copy VBI samples */
379 		bt656->pos++;
380 
381 	return true;
382 }
383 
384 static bool cxusb_medion_copy_field(struct dvb_usb_device *dvbdev,
385 				    struct cxusb_medion_auxbuf *auxbuf,
386 				    struct cxusb_bt656_params *bt656,
387 				    bool firstfield,
388 				    unsigned int maxlines,
389 				    unsigned int maxlinesmpls)
390 {
391 	while (bt656->line < maxlines) {
392 		unsigned char val;
393 
394 		if (!cxusb_auxbuf_copy(auxbuf, bt656->pos, &val, 1))
395 			break;
396 
397 		if (val == CXUSB_BT656_PREAMBLE[0]) {
398 			unsigned char buf[4];
399 
400 			buf[0] = val;
401 			if (!cxusb_auxbuf_copy(auxbuf, bt656->pos + 1,
402 					       buf + 1, 3))
403 				break;
404 
405 			if (buf[1] == CXUSB_BT656_PREAMBLE[1] &&
406 			    buf[2] == CXUSB_BT656_PREAMBLE[2]) {
407 				/*
408 				 * is this a field change?
409 				 * if so, terminate copying the current field
410 				 */
411 				if (cxusb_medion_cf_refc_fld_chg(dvbdev,
412 								 bt656,
413 								 firstfield,
414 								 maxlines,
415 								 maxlinesmpls,
416 								 buf))
417 					return true;
418 
419 				if (cxusb_medion_cf_ref_code(dvbdev, bt656,
420 							     firstfield,
421 							     maxlines,
422 							     maxlinesmpls,
423 							     buf))
424 					bt656->pos += 4;
425 
426 				continue;
427 			}
428 		}
429 
430 		if (!cxusb_medion_copy_samples(dvbdev, auxbuf, bt656,
431 					       maxlinesmpls, val))
432 			break;
433 	}
434 
435 	if (bt656->line < maxlines) {
436 		cxusb_vprintk(dvbdev, BT656,
437 			      "end of buffer pos = %u, line = %u\n",
438 			      bt656->pos, bt656->line);
439 		return false;
440 	}
441 
442 	return true;
443 }
444 
445 static bool cxusb_medion_v_process_auxbuf(struct cxusb_medion_dev *cxdev,
446 					  bool reset)
447 {
448 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
449 	struct cxusb_bt656_params *bt656 = &cxdev->bt656;
450 
451 	/*
452 	 * if this is a new frame
453 	 * fetch a buffer from list
454 	 */
455 	if (bt656->mode == NEW_FRAME) {
456 		if (!list_empty(&cxdev->buflist)) {
457 			cxdev->vbuf =
458 				list_first_entry(&cxdev->buflist,
459 						 struct cxusb_medion_vbuffer,
460 						 list);
461 			list_del(&cxdev->vbuf->list);
462 		} else {
463 			dev_warn(&dvbdev->udev->dev, "no free buffers\n");
464 		}
465 	}
466 
467 	if (bt656->mode == NEW_FRAME || reset) {
468 		cxusb_vprintk(dvbdev, URB, "will copy field 1\n");
469 		bt656->pos = 0;
470 		bt656->mode = FIRST_FIELD;
471 		bt656->fmode = START_SEARCH;
472 		bt656->line = 0;
473 
474 		if (cxdev->vbuf) {
475 			cxdev->vbuf->vb2.vb2_buf.timestamp = ktime_get_ns();
476 			bt656->buf = vb2_plane_vaddr(&cxdev->vbuf->vb2.vb2_buf,
477 						     0);
478 		}
479 	}
480 
481 	if (bt656->mode == FIRST_FIELD) {
482 		if (!cxusb_medion_copy_field(dvbdev, &cxdev->auxbuf, bt656,
483 					     true, cxdev->height / 2,
484 					     cxdev->width * 2))
485 			return false;
486 
487 		/*
488 		 * do not trim buffer there in case
489 		 * we need to reset the search later
490 		 */
491 
492 		cxusb_vprintk(dvbdev, URB, "will copy field 2\n");
493 		bt656->mode = SECOND_FIELD;
494 		bt656->fmode = START_SEARCH;
495 		bt656->line = 0;
496 	}
497 
498 	if (bt656->mode == SECOND_FIELD) {
499 		if (!cxusb_medion_copy_field(dvbdev, &cxdev->auxbuf, bt656,
500 					     false, cxdev->height / 2,
501 					     cxdev->width * 2))
502 			return false;
503 
504 		cxusb_auxbuf_head_trim(dvbdev, &cxdev->auxbuf, bt656->pos);
505 
506 		bt656->mode = NEW_FRAME;
507 
508 		if (cxdev->vbuf) {
509 			vb2_set_plane_payload(&cxdev->vbuf->vb2.vb2_buf, 0,
510 					      cxdev->width * cxdev->height * 2);
511 
512 			cxdev->vbuf->vb2.field = cxdev->field_order;
513 			cxdev->vbuf->vb2.sequence = cxdev->vbuf_sequence++;
514 
515 			vb2_buffer_done(&cxdev->vbuf->vb2.vb2_buf,
516 					VB2_BUF_STATE_DONE);
517 
518 			cxdev->vbuf = NULL;
519 			cxdev->bt656.buf = NULL;
520 
521 			cxusb_vprintk(dvbdev, URB, "frame done\n");
522 		} else {
523 			cxusb_vprintk(dvbdev, URB, "frame skipped\n");
524 			cxdev->vbuf_sequence++;
525 		}
526 	}
527 
528 	return true;
529 }
530 
531 static bool cxusb_medion_v_complete_handle_urb(struct cxusb_medion_dev *cxdev,
532 					       bool *auxbuf_reset)
533 {
534 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
535 	unsigned int urbn;
536 	struct urb *urb;
537 	int ret;
538 
539 	*auxbuf_reset = false;
540 
541 	urbn = cxdev->nexturb;
542 	if (!test_bit(urbn, &cxdev->urbcomplete))
543 		return false;
544 
545 	clear_bit(urbn, &cxdev->urbcomplete);
546 
547 	do {
548 		cxdev->nexturb++;
549 		cxdev->nexturb %= CXUSB_VIDEO_URBS;
550 		urb = cxdev->streamurbs[cxdev->nexturb];
551 	} while (!urb);
552 
553 	urb = cxdev->streamurbs[urbn];
554 	cxusb_vprintk(dvbdev, URB, "URB %u status = %d\n", urbn, urb->status);
555 
556 	if (urb->status == 0 || urb->status == -EXDEV) {
557 		int i;
558 		unsigned long len;
559 
560 		for (i = 0, len = 0; i < urb->number_of_packets; i++)
561 			len += urb->iso_frame_desc[i].actual_length;
562 
563 		cxusb_vprintk(dvbdev, URB, "URB %u data len = %lu\n", urbn,
564 			      len);
565 
566 		if (len > 0) {
567 			cxusb_vprintk(dvbdev, URB, "appending URB\n");
568 
569 			/*
570 			 * append new data to auxbuf while
571 			 * overwriting old data if necessary
572 			 *
573 			 * if any overwrite happens then we can no
574 			 * longer rely on consistency of the whole
575 			 * data so let's start again the current
576 			 * auxbuf frame assembling process from
577 			 * the beginning
578 			 */
579 			*auxbuf_reset =
580 				!cxusb_auxbuf_append_urb(dvbdev,
581 							 &cxdev->auxbuf,
582 							 urb);
583 		}
584 	}
585 
586 	cxusb_vprintk(dvbdev, URB, "URB %u resubmit\n", urbn);
587 
588 	ret = usb_submit_urb(urb, GFP_KERNEL);
589 	if (ret != 0)
590 		dev_err(&dvbdev->udev->dev,
591 			"unable to resubmit URB %u (%d), you'll have to restart streaming\n",
592 			urbn, ret);
593 
594 	/* next URB is complete already? reschedule us then to handle it */
595 	return test_bit(cxdev->nexturb, &cxdev->urbcomplete);
596 }
597 
598 static void cxusb_medion_v_complete_work(struct work_struct *work)
599 {
600 	struct cxusb_medion_dev *cxdev = container_of(work,
601 						      struct cxusb_medion_dev,
602 						      urbwork);
603 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
604 	bool auxbuf_reset;
605 	bool reschedule;
606 
607 	mutex_lock(cxdev->videodev->lock);
608 
609 	cxusb_vprintk(dvbdev, URB, "worker called, stop_streaming = %d\n",
610 		      (int)cxdev->stop_streaming);
611 
612 	if (cxdev->stop_streaming)
613 		goto unlock;
614 
615 	reschedule = cxusb_medion_v_complete_handle_urb(cxdev, &auxbuf_reset);
616 
617 	if (cxusb_medion_v_process_auxbuf(cxdev, auxbuf_reset))
618 		/* reschedule us until auxbuf no longer can produce any frame */
619 		reschedule = true;
620 
621 	if (reschedule) {
622 		cxusb_vprintk(dvbdev, URB, "rescheduling worker\n");
623 		schedule_work(&cxdev->urbwork);
624 	}
625 
626 unlock:
627 	mutex_unlock(cxdev->videodev->lock);
628 }
629 
630 static void cxusb_medion_v_complete(struct urb *u)
631 {
632 	struct dvb_usb_device *dvbdev = u->context;
633 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
634 	unsigned int i;
635 
636 	for (i = 0; i < CXUSB_VIDEO_URBS; i++)
637 		if (cxdev->streamurbs[i] == u)
638 			break;
639 
640 	if (i >= CXUSB_VIDEO_URBS) {
641 		dev_err(&dvbdev->udev->dev,
642 			"complete on unknown URB\n");
643 		return;
644 	}
645 
646 	cxusb_vprintk(dvbdev, URB, "URB %u complete\n", i);
647 
648 	set_bit(i, &cxdev->urbcomplete);
649 	schedule_work(&cxdev->urbwork);
650 }
651 
652 static void cxusb_medion_urbs_free(struct cxusb_medion_dev *cxdev)
653 {
654 	unsigned int i;
655 
656 	for (i = 0; i < CXUSB_VIDEO_URBS; i++)
657 		if (cxdev->streamurbs[i]) {
658 			kfree(cxdev->streamurbs[i]->transfer_buffer);
659 			usb_free_urb(cxdev->streamurbs[i]);
660 			cxdev->streamurbs[i] = NULL;
661 		}
662 }
663 
664 static void cxusb_medion_return_buffers(struct cxusb_medion_dev *cxdev,
665 					bool requeue)
666 {
667 	struct cxusb_medion_vbuffer *vbuf, *vbuf_tmp;
668 
669 	list_for_each_entry_safe(vbuf, vbuf_tmp, &cxdev->buflist,
670 				 list) {
671 		list_del(&vbuf->list);
672 		vb2_buffer_done(&vbuf->vb2.vb2_buf,
673 				requeue ? VB2_BUF_STATE_QUEUED :
674 				VB2_BUF_STATE_ERROR);
675 	}
676 
677 	if (cxdev->vbuf) {
678 		vb2_buffer_done(&cxdev->vbuf->vb2.vb2_buf,
679 				requeue ? VB2_BUF_STATE_QUEUED :
680 				VB2_BUF_STATE_ERROR);
681 
682 		cxdev->vbuf = NULL;
683 		cxdev->bt656.buf = NULL;
684 	}
685 }
686 
687 static int cxusb_medion_v_ss_auxbuf_alloc(struct cxusb_medion_dev *cxdev,
688 					  int *npackets)
689 {
690 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
691 	u8 *buf;
692 	unsigned int framelen, urblen, auxbuflen;
693 
694 	framelen = (cxdev->width * 2 + 4 + 4) *
695 		(cxdev->height + 50 /* VBI lines */);
696 
697 	/*
698 	 * try to fit a whole frame into each URB, as long as doing so
699 	 * does not require very high order memory allocations
700 	 */
701 	BUILD_BUG_ON(CXUSB_VIDEO_URB_MAX_SIZE / CXUSB_VIDEO_PKT_SIZE >
702 		     CXUSB_VIDEO_MAX_FRAME_PKTS);
703 	*npackets = min_t(int, (framelen + CXUSB_VIDEO_PKT_SIZE - 1) /
704 			  CXUSB_VIDEO_PKT_SIZE,
705 			  CXUSB_VIDEO_URB_MAX_SIZE / CXUSB_VIDEO_PKT_SIZE);
706 	urblen = *npackets * CXUSB_VIDEO_PKT_SIZE;
707 
708 	cxusb_vprintk(dvbdev, URB,
709 		      "each URB will have %d packets for total of %u bytes (%u x %u @ %u)\n",
710 		      *npackets, urblen, (unsigned int)cxdev->width,
711 		      (unsigned int)cxdev->height, framelen);
712 
713 	auxbuflen = framelen + urblen;
714 
715 	buf = vmalloc(auxbuflen);
716 	if (!buf)
717 		return -ENOMEM;
718 
719 	cxusb_auxbuf_init(dvbdev, &cxdev->auxbuf, buf, auxbuflen);
720 
721 	return 0;
722 }
723 
724 static u32 cxusb_medion_norm2field_order(v4l2_std_id norm)
725 {
726 	bool is625 = norm & V4L2_STD_625_50;
727 	bool is525 = norm & V4L2_STD_525_60;
728 
729 	if (!is625 && !is525)
730 		return V4L2_FIELD_NONE;
731 
732 	if (is625 && is525)
733 		return V4L2_FIELD_NONE;
734 
735 	if (is625)
736 		return V4L2_FIELD_SEQ_TB;
737 	else /* is525 */
738 		return V4L2_FIELD_SEQ_BT;
739 }
740 
741 static u32 cxusb_medion_field_order(struct cxusb_medion_dev *cxdev)
742 {
743 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
744 	u32 field;
745 	int ret;
746 	v4l2_std_id norm;
747 
748 	/* TV tuner is PAL-only so it is always TB */
749 	if (cxdev->input == 0)
750 		return V4L2_FIELD_SEQ_TB;
751 
752 	field = cxusb_medion_norm2field_order(cxdev->norm);
753 	if (field != V4L2_FIELD_NONE)
754 		return field;
755 
756 	ret = v4l2_subdev_call(cxdev->cx25840, video, g_std, &norm);
757 	if (ret != 0) {
758 		cxusb_vprintk(dvbdev, OPS,
759 			      "cannot get current standard for input %u\n",
760 			      (unsigned int)cxdev->input);
761 	} else {
762 		field = cxusb_medion_norm2field_order(norm);
763 		if (field != V4L2_FIELD_NONE)
764 			return field;
765 	}
766 
767 	dev_warn(&dvbdev->udev->dev,
768 		 "cannot determine field order for the current standard setup and received signal, using TB\n");
769 	return V4L2_FIELD_SEQ_TB;
770 }
771 
772 static int cxusb_medion_v_start_streaming(struct vb2_queue *q,
773 					  unsigned int count)
774 {
775 	struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
776 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
777 	u8 streamon_params[2] = { 0x03, 0x00 };
778 	int npackets, i;
779 	int ret;
780 
781 	cxusb_vprintk(dvbdev, OPS, "should start streaming\n");
782 
783 	if (cxdev->stop_streaming) {
784 		/* stream is being stopped */
785 		ret = -EBUSY;
786 		goto ret_retbufs;
787 	}
788 
789 	cxdev->field_order = cxusb_medion_field_order(cxdev);
790 
791 	ret = v4l2_subdev_call(cxdev->cx25840, video, s_stream, 1);
792 	if (ret != 0) {
793 		dev_err(&dvbdev->udev->dev,
794 			"unable to start stream (%d)\n", ret);
795 		goto ret_retbufs;
796 	}
797 
798 	ret = cxusb_ctrl_msg(dvbdev, CMD_STREAMING_ON, streamon_params, 2,
799 			     NULL, 0);
800 	if (ret != 0) {
801 		dev_err(&dvbdev->udev->dev,
802 			"unable to start streaming (%d)\n", ret);
803 		goto ret_unstream_cx;
804 	}
805 
806 	ret = cxusb_medion_v_ss_auxbuf_alloc(cxdev, &npackets);
807 	if (ret != 0)
808 		goto ret_unstream_md;
809 
810 	for (i = 0; i < CXUSB_VIDEO_URBS; i++) {
811 		int framen;
812 		u8 *streambuf;
813 		struct urb *surb;
814 
815 		/*
816 		 * TODO: change this to an array of single pages to avoid
817 		 * doing a large continuous allocation when (if)
818 		 * s-g isochronous USB transfers are supported
819 		 */
820 		streambuf = kmalloc(npackets * CXUSB_VIDEO_PKT_SIZE,
821 				    GFP_KERNEL);
822 		if (!streambuf) {
823 			if (i < 2) {
824 				ret = -ENOMEM;
825 				goto ret_freeab;
826 			}
827 			break;
828 		}
829 
830 		surb = usb_alloc_urb(npackets, GFP_KERNEL);
831 		if (!surb) {
832 			kfree(streambuf);
833 			ret = -ENOMEM;
834 			goto ret_freeu;
835 		}
836 
837 		cxdev->streamurbs[i] = surb;
838 		surb->dev = dvbdev->udev;
839 		surb->context = dvbdev;
840 		surb->pipe = usb_rcvisocpipe(dvbdev->udev, 2);
841 
842 		surb->interval = 1;
843 		surb->transfer_flags = URB_ISO_ASAP;
844 
845 		surb->transfer_buffer = streambuf;
846 
847 		surb->complete = cxusb_medion_v_complete;
848 		surb->number_of_packets = npackets;
849 		surb->transfer_buffer_length = npackets * CXUSB_VIDEO_PKT_SIZE;
850 
851 		for (framen = 0; framen < npackets; framen++) {
852 			surb->iso_frame_desc[framen].offset =
853 				CXUSB_VIDEO_PKT_SIZE * framen;
854 
855 			surb->iso_frame_desc[framen].length =
856 				CXUSB_VIDEO_PKT_SIZE;
857 		}
858 	}
859 
860 	cxdev->urbcomplete = 0;
861 	cxdev->nexturb = 0;
862 	cxdev->vbuf_sequence = 0;
863 
864 	cxdev->vbuf = NULL;
865 	cxdev->bt656.mode = NEW_FRAME;
866 	cxdev->bt656.buf = NULL;
867 
868 	for (i = 0; i < CXUSB_VIDEO_URBS; i++)
869 		if (cxdev->streamurbs[i]) {
870 			ret = usb_submit_urb(cxdev->streamurbs[i],
871 					     GFP_KERNEL);
872 			if (ret != 0)
873 				dev_err(&dvbdev->udev->dev,
874 					"URB %d submission failed (%d)\n", i,
875 					ret);
876 		}
877 
878 	return 0;
879 
880 ret_freeu:
881 	cxusb_medion_urbs_free(cxdev);
882 
883 ret_freeab:
884 	vfree(cxdev->auxbuf.buf);
885 
886 ret_unstream_md:
887 	cxusb_ctrl_msg(dvbdev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
888 
889 ret_unstream_cx:
890 	v4l2_subdev_call(cxdev->cx25840, video, s_stream, 0);
891 
892 ret_retbufs:
893 	cxusb_medion_return_buffers(cxdev, true);
894 
895 	return ret;
896 }
897 
898 static void cxusb_medion_v_stop_streaming(struct vb2_queue *q)
899 {
900 	struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
901 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
902 	int ret;
903 	unsigned int i;
904 
905 	cxusb_vprintk(dvbdev, OPS, "should stop streaming\n");
906 
907 	if (WARN_ON(cxdev->stop_streaming))
908 		return;
909 
910 	cxdev->stop_streaming = true;
911 
912 	cxusb_ctrl_msg(dvbdev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
913 
914 	ret = v4l2_subdev_call(cxdev->cx25840, video, s_stream, 0);
915 	if (ret != 0)
916 		dev_err(&dvbdev->udev->dev, "unable to stop stream (%d)\n",
917 			ret);
918 
919 	/* let URB completion run */
920 	mutex_unlock(cxdev->videodev->lock);
921 
922 	for (i = 0; i < CXUSB_VIDEO_URBS; i++)
923 		if (cxdev->streamurbs[i])
924 			usb_kill_urb(cxdev->streamurbs[i]);
925 
926 	flush_work(&cxdev->urbwork);
927 
928 	mutex_lock(cxdev->videodev->lock);
929 
930 	/* free transfer buffer and URB */
931 	vfree(cxdev->auxbuf.buf);
932 
933 	cxusb_medion_urbs_free(cxdev);
934 
935 	cxusb_medion_return_buffers(cxdev, false);
936 
937 	cxdev->stop_streaming = false;
938 }
939 
940 static void cxusub_medion_v_buf_queue(struct vb2_buffer *vb)
941 {
942 	struct vb2_v4l2_buffer *v4l2buf = to_vb2_v4l2_buffer(vb);
943 	struct cxusb_medion_vbuffer *vbuf =
944 		container_of(v4l2buf, struct cxusb_medion_vbuffer, vb2);
945 	struct dvb_usb_device *dvbdev = vb2_get_drv_priv(vb->vb2_queue);
946 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
947 
948 	/* cxusb_vprintk(dvbdev, OPS, "mmmm.. a fresh buffer...\n"); */
949 
950 	list_add_tail(&vbuf->list, &cxdev->buflist);
951 }
952 
953 static const struct vb2_ops cxdev_video_qops = {
954 	.queue_setup = cxusb_medion_v_queue_setup,
955 	.buf_init = cxusb_medion_v_buf_init,
956 	.start_streaming = cxusb_medion_v_start_streaming,
957 	.stop_streaming = cxusb_medion_v_stop_streaming,
958 	.buf_queue = cxusub_medion_v_buf_queue,
959 	.wait_prepare = vb2_ops_wait_prepare,
960 	.wait_finish = vb2_ops_wait_finish
961 };
962 
963 static const __u32 videocaps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
964 	V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
965 static const __u32 radiocaps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
966 
967 static int cxusb_medion_v_querycap(struct file *file, void *fh,
968 				   struct v4l2_capability *cap)
969 {
970 	struct dvb_usb_device *dvbdev = video_drvdata(file);
971 
972 	strscpy(cap->driver, dvbdev->udev->dev.driver->name,
973 		sizeof(cap->driver));
974 	strscpy(cap->card, "Medion 95700", sizeof(cap->card));
975 	usb_make_path(dvbdev->udev, cap->bus_info, sizeof(cap->bus_info));
976 
977 	cap->capabilities = videocaps | radiocaps | V4L2_CAP_DEVICE_CAPS;
978 
979 	return 0;
980 }
981 
982 static int cxusb_medion_v_enum_fmt_vid_cap(struct file *file, void *fh,
983 					   struct v4l2_fmtdesc *f)
984 {
985 	if (f->index != 0)
986 		return -EINVAL;
987 
988 	f->pixelformat = V4L2_PIX_FMT_UYVY;
989 
990 	return 0;
991 }
992 
993 static int cxusb_medion_g_fmt_vid_cap(struct file *file, void *fh,
994 				      struct v4l2_format *f)
995 {
996 	struct dvb_usb_device *dvbdev = video_drvdata(file);
997 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
998 
999 	f->fmt.pix.width = cxdev->width;
1000 	f->fmt.pix.height = cxdev->height;
1001 	f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1002 	f->fmt.pix.field = vb2_start_streaming_called(&cxdev->videoqueue) ?
1003 		cxdev->field_order : cxusb_medion_field_order(cxdev);
1004 	f->fmt.pix.bytesperline = cxdev->width * 2;
1005 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1006 	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
1007 
1008 	return 0;
1009 }
1010 
1011 static int cxusb_medion_try_s_fmt_vid_cap(struct file *file,
1012 					  struct v4l2_format *f,
1013 					  bool isset)
1014 {
1015 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1016 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1017 	struct v4l2_subdev_format subfmt;
1018 	u32 field;
1019 	int ret;
1020 
1021 	if (isset && vb2_is_busy(&cxdev->videoqueue))
1022 		return -EBUSY;
1023 
1024 	field = vb2_start_streaming_called(&cxdev->videoqueue) ?
1025 		cxdev->field_order : cxusb_medion_field_order(cxdev);
1026 
1027 	memset(&subfmt, 0, sizeof(subfmt));
1028 	subfmt.which = isset ? V4L2_SUBDEV_FORMAT_ACTIVE :
1029 		V4L2_SUBDEV_FORMAT_TRY;
1030 	subfmt.format.width = f->fmt.pix.width & ~1;
1031 	subfmt.format.height = f->fmt.pix.height & ~1;
1032 	subfmt.format.code = MEDIA_BUS_FMT_FIXED;
1033 	subfmt.format.field = field;
1034 	subfmt.format.colorspace = V4L2_COLORSPACE_SMPTE170M;
1035 
1036 	ret = v4l2_subdev_call(cxdev->cx25840, pad, set_fmt, NULL, &subfmt);
1037 	if (ret != 0)
1038 		return ret;
1039 
1040 	f->fmt.pix.width = subfmt.format.width;
1041 	f->fmt.pix.height = subfmt.format.height;
1042 	f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1043 	f->fmt.pix.field = field;
1044 	f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1045 	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
1046 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1047 
1048 	if (isset) {
1049 		cxdev->width = f->fmt.pix.width;
1050 		cxdev->height = f->fmt.pix.height;
1051 	}
1052 
1053 	return 0;
1054 }
1055 
1056 static int cxusb_medion_try_fmt_vid_cap(struct file *file, void *fh,
1057 					struct v4l2_format *f)
1058 {
1059 	return cxusb_medion_try_s_fmt_vid_cap(file, f, false);
1060 }
1061 
1062 static int cxusb_medion_s_fmt_vid_cap(struct file *file, void *fh,
1063 				      struct v4l2_format *f)
1064 {
1065 	return cxusb_medion_try_s_fmt_vid_cap(file, f, true);
1066 }
1067 
1068 static const struct {
1069 	struct v4l2_input input;
1070 	u32 inputcfg;
1071 } cxusb_medion_inputs[] = {
1072 	{ .input = { .name = "TV tuner", .type = V4L2_INPUT_TYPE_TUNER,
1073 		     .tuner = 0, .std = V4L2_STD_PAL },
1074 	  .inputcfg = CX25840_COMPOSITE2, },
1075 
1076 	{  .input = { .name = "Composite", .type = V4L2_INPUT_TYPE_CAMERA,
1077 		     .std = V4L2_STD_ALL },
1078 	   .inputcfg = CX25840_COMPOSITE1, },
1079 
1080 	{  .input = { .name = "S-Video", .type = V4L2_INPUT_TYPE_CAMERA,
1081 		      .std = V4L2_STD_ALL },
1082 	   .inputcfg = CX25840_SVIDEO_LUMA3 | CX25840_SVIDEO_CHROMA4 }
1083 };
1084 
1085 #define CXUSB_INPUT_CNT ARRAY_SIZE(cxusb_medion_inputs)
1086 
1087 static int cxusb_medion_enum_input(struct file *file, void *fh,
1088 				   struct v4l2_input *inp)
1089 {
1090 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1091 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1092 	u32 index = inp->index;
1093 
1094 	if (index >= CXUSB_INPUT_CNT)
1095 		return -EINVAL;
1096 
1097 	*inp = cxusb_medion_inputs[index].input;
1098 	inp->index = index;
1099 	inp->capabilities |= V4L2_IN_CAP_STD;
1100 
1101 	if (index == cxdev->input) {
1102 		int ret;
1103 		u32 status = 0;
1104 
1105 		ret = v4l2_subdev_call(cxdev->cx25840, video, g_input_status,
1106 				       &status);
1107 		if (ret != 0)
1108 			dev_warn(&dvbdev->udev->dev,
1109 				 "cx25840 input status query failed (%d)\n",
1110 				 ret);
1111 		else
1112 			inp->status = status;
1113 	}
1114 
1115 	return 0;
1116 }
1117 
1118 static int cxusb_medion_g_input(struct file *file, void *fh,
1119 				unsigned int *i)
1120 {
1121 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1122 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1123 
1124 	*i = cxdev->input;
1125 
1126 	return 0;
1127 }
1128 
1129 static int cxusb_medion_set_norm(struct cxusb_medion_dev *cxdev,
1130 				 v4l2_std_id norm)
1131 {
1132 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
1133 	int ret;
1134 
1135 	cxusb_vprintk(dvbdev, OPS,
1136 		      "trying to set standard for input %u to %lx\n",
1137 		      (unsigned int)cxdev->input,
1138 		      (unsigned long)norm);
1139 
1140 	/* no autodetection support */
1141 	if (norm == V4L2_STD_UNKNOWN)
1142 		return -EINVAL;
1143 
1144 	/* on composite or S-Video any std is acceptable */
1145 	if (cxdev->input != 0) {
1146 		ret = v4l2_subdev_call(cxdev->cx25840, video, s_std, norm);
1147 		if (ret)
1148 			return ret;
1149 
1150 		goto ret_savenorm;
1151 	}
1152 
1153 	/* TV tuner is only able to demodulate PAL */
1154 	if ((norm & ~V4L2_STD_PAL) != 0)
1155 		return -EINVAL;
1156 
1157 	ret = v4l2_subdev_call(cxdev->tda9887, video, s_std, norm);
1158 	if (ret != 0) {
1159 		dev_err(&dvbdev->udev->dev,
1160 			"tda9887 norm setup failed (%d)\n",
1161 			ret);
1162 		return ret;
1163 	}
1164 
1165 	ret = v4l2_subdev_call(cxdev->tuner, video, s_std, norm);
1166 	if (ret != 0) {
1167 		dev_err(&dvbdev->udev->dev,
1168 			"tuner norm setup failed (%d)\n",
1169 			ret);
1170 		return ret;
1171 	}
1172 
1173 	ret = v4l2_subdev_call(cxdev->cx25840, video, s_std, norm);
1174 	if (ret != 0) {
1175 		dev_err(&dvbdev->udev->dev,
1176 			"cx25840 norm setup failed (%d)\n",
1177 			ret);
1178 		return ret;
1179 	}
1180 
1181 ret_savenorm:
1182 	cxdev->norm = norm;
1183 
1184 	return 0;
1185 }
1186 
1187 static int cxusb_medion_s_input(struct file *file, void *fh,
1188 				unsigned int i)
1189 {
1190 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1191 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1192 	int ret;
1193 	v4l2_std_id norm;
1194 
1195 	if (i >= CXUSB_INPUT_CNT)
1196 		return -EINVAL;
1197 
1198 	ret = v4l2_subdev_call(cxdev->cx25840, video, s_routing,
1199 			       cxusb_medion_inputs[i].inputcfg, 0, 0);
1200 	if (ret != 0)
1201 		return ret;
1202 
1203 	cxdev->input = i;
1204 	cxdev->videodev->tvnorms = cxusb_medion_inputs[i].input.std;
1205 
1206 	norm = cxdev->norm & cxusb_medion_inputs[i].input.std;
1207 	if (norm == 0)
1208 		norm = cxusb_medion_inputs[i].input.std;
1209 
1210 	cxusb_medion_set_norm(cxdev, norm);
1211 
1212 	return 0;
1213 }
1214 
1215 static int cxusb_medion_g_tuner(struct file *file, void *fh,
1216 				struct v4l2_tuner *tuner)
1217 {
1218 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1219 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1220 	struct video_device *vdev = video_devdata(file);
1221 	int ret;
1222 
1223 	if (tuner->index != 0)
1224 		return -EINVAL;
1225 
1226 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1227 		tuner->type = V4L2_TUNER_ANALOG_TV;
1228 	else
1229 		tuner->type = V4L2_TUNER_RADIO;
1230 
1231 	tuner->capability = 0;
1232 	tuner->afc = 0;
1233 
1234 	/*
1235 	 * fills:
1236 	 * always: capability (static), rangelow (static), rangehigh (static)
1237 	 * radio mode: afc (may fail silently), rxsubchans (static), audmode
1238 	 */
1239 	ret = v4l2_subdev_call(cxdev->tda9887, tuner, g_tuner, tuner);
1240 	if (ret != 0)
1241 		return ret;
1242 
1243 	/*
1244 	 * fills:
1245 	 * always: capability (static), rangelow (static), rangehigh (static)
1246 	 * radio mode: rxsubchans (always stereo), audmode,
1247 	 * signal (might be wrong)
1248 	 */
1249 	ret = v4l2_subdev_call(cxdev->tuner, tuner, g_tuner, tuner);
1250 	if (ret != 0)
1251 		return ret;
1252 
1253 	tuner->signal = 0;
1254 
1255 	/*
1256 	 * fills: TV mode: capability, rxsubchans, audmode, signal
1257 	 */
1258 	ret = v4l2_subdev_call(cxdev->cx25840, tuner, g_tuner, tuner);
1259 	if (ret != 0)
1260 		return ret;
1261 
1262 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1263 		strscpy(tuner->name, "TV tuner", sizeof(tuner->name));
1264 	else
1265 		strscpy(tuner->name, "Radio tuner", sizeof(tuner->name));
1266 
1267 	memset(tuner->reserved, 0, sizeof(tuner->reserved));
1268 
1269 	return 0;
1270 }
1271 
1272 static int cxusb_medion_s_tuner(struct file *file, void *fh,
1273 				const struct v4l2_tuner *tuner)
1274 {
1275 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1276 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1277 	struct video_device *vdev = video_devdata(file);
1278 	int ret;
1279 
1280 	if (tuner->index != 0)
1281 		return -EINVAL;
1282 
1283 	ret = v4l2_subdev_call(cxdev->tda9887, tuner, s_tuner, tuner);
1284 	if (ret != 0)
1285 		return ret;
1286 
1287 	ret = v4l2_subdev_call(cxdev->tuner, tuner, s_tuner, tuner);
1288 	if (ret != 0)
1289 		return ret;
1290 
1291 	/*
1292 	 * make sure that cx25840 is in a correct TV / radio mode,
1293 	 * since calls above may have changed it for tuner / IF demod
1294 	 */
1295 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1296 		v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1297 	else
1298 		v4l2_subdev_call(cxdev->cx25840, tuner, s_radio);
1299 
1300 	return v4l2_subdev_call(cxdev->cx25840, tuner, s_tuner, tuner);
1301 }
1302 
1303 static int cxusb_medion_g_frequency(struct file *file, void *fh,
1304 				    struct v4l2_frequency *freq)
1305 {
1306 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1307 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1308 
1309 	if (freq->tuner != 0)
1310 		return -EINVAL;
1311 
1312 	return v4l2_subdev_call(cxdev->tuner, tuner, g_frequency, freq);
1313 }
1314 
1315 static int cxusb_medion_s_frequency(struct file *file, void *fh,
1316 				    const struct v4l2_frequency *freq)
1317 {
1318 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1319 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1320 	struct video_device *vdev = video_devdata(file);
1321 	int ret;
1322 
1323 	if (freq->tuner != 0)
1324 		return -EINVAL;
1325 
1326 	ret = v4l2_subdev_call(cxdev->tda9887, tuner, s_frequency, freq);
1327 	if (ret != 0)
1328 		return ret;
1329 
1330 	ret = v4l2_subdev_call(cxdev->tuner, tuner, s_frequency, freq);
1331 	if (ret != 0)
1332 		return ret;
1333 
1334 	/*
1335 	 * make sure that cx25840 is in a correct TV / radio mode,
1336 	 * since calls above may have changed it for tuner / IF demod
1337 	 */
1338 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1339 		v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1340 	else
1341 		v4l2_subdev_call(cxdev->cx25840, tuner, s_radio);
1342 
1343 	return v4l2_subdev_call(cxdev->cx25840, tuner, s_frequency, freq);
1344 }
1345 
1346 static int cxusb_medion_g_std(struct file *file, void *fh,
1347 			      v4l2_std_id *norm)
1348 {
1349 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1350 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1351 
1352 	*norm = cxdev->norm;
1353 
1354 	if (*norm == V4L2_STD_UNKNOWN)
1355 		return -ENODATA;
1356 
1357 	return 0;
1358 }
1359 
1360 static int cxusb_medion_s_std(struct file *file, void *fh,
1361 			      v4l2_std_id norm)
1362 {
1363 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1364 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1365 
1366 	return cxusb_medion_set_norm(cxdev, norm);
1367 }
1368 
1369 static int cxusb_medion_querystd(struct file *file, void *fh,
1370 				 v4l2_std_id *norm)
1371 {
1372 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1373 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1374 	v4l2_std_id norm_mask;
1375 	int ret;
1376 
1377 	/*
1378 	 * make sure we don't have improper std bits set for the TV tuner
1379 	 * (could happen when no signal was present yet after reset)
1380 	 */
1381 	if (cxdev->input == 0)
1382 		norm_mask = V4L2_STD_PAL;
1383 	else
1384 		norm_mask = V4L2_STD_ALL;
1385 
1386 	ret = v4l2_subdev_call(cxdev->cx25840, video, querystd, norm);
1387 	if (ret != 0) {
1388 		cxusb_vprintk(dvbdev, OPS,
1389 			      "cannot get detected standard for input %u\n",
1390 			      (unsigned int)cxdev->input);
1391 		return ret;
1392 	}
1393 
1394 	cxusb_vprintk(dvbdev, OPS, "input %u detected standard is %lx\n",
1395 		      (unsigned int)cxdev->input, (unsigned long)*norm);
1396 	*norm &= norm_mask;
1397 
1398 	return 0;
1399 }
1400 
1401 static int cxusb_medion_log_status(struct file *file, void *fh)
1402 {
1403 	struct dvb_usb_device *dvbdev = video_drvdata(file);
1404 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1405 
1406 	v4l2_device_call_all(&cxdev->v4l2dev, 0, core, log_status);
1407 
1408 	return 0;
1409 }
1410 
1411 static const struct v4l2_ioctl_ops cxusb_video_ioctl = {
1412 	.vidioc_querycap = cxusb_medion_v_querycap,
1413 	.vidioc_enum_fmt_vid_cap = cxusb_medion_v_enum_fmt_vid_cap,
1414 	.vidioc_g_fmt_vid_cap = cxusb_medion_g_fmt_vid_cap,
1415 	.vidioc_s_fmt_vid_cap = cxusb_medion_s_fmt_vid_cap,
1416 	.vidioc_try_fmt_vid_cap = cxusb_medion_try_fmt_vid_cap,
1417 	.vidioc_enum_input = cxusb_medion_enum_input,
1418 	.vidioc_g_input = cxusb_medion_g_input,
1419 	.vidioc_s_input = cxusb_medion_s_input,
1420 	.vidioc_g_tuner = cxusb_medion_g_tuner,
1421 	.vidioc_s_tuner = cxusb_medion_s_tuner,
1422 	.vidioc_g_frequency = cxusb_medion_g_frequency,
1423 	.vidioc_s_frequency = cxusb_medion_s_frequency,
1424 	.vidioc_g_std = cxusb_medion_g_std,
1425 	.vidioc_s_std = cxusb_medion_s_std,
1426 	.vidioc_querystd = cxusb_medion_querystd,
1427 	.vidioc_log_status = cxusb_medion_log_status,
1428 	.vidioc_reqbufs = vb2_ioctl_reqbufs,
1429 	.vidioc_querybuf = vb2_ioctl_querybuf,
1430 	.vidioc_qbuf = vb2_ioctl_qbuf,
1431 	.vidioc_dqbuf = vb2_ioctl_dqbuf,
1432 	.vidioc_create_bufs = vb2_ioctl_create_bufs,
1433 	.vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1434 	.vidioc_streamon = vb2_ioctl_streamon,
1435 	.vidioc_streamoff = vb2_ioctl_streamoff
1436 };
1437 
1438 static const struct v4l2_ioctl_ops cxusb_radio_ioctl = {
1439 	.vidioc_querycap = cxusb_medion_v_querycap,
1440 	.vidioc_g_tuner = cxusb_medion_g_tuner,
1441 	.vidioc_s_tuner = cxusb_medion_s_tuner,
1442 	.vidioc_g_frequency = cxusb_medion_g_frequency,
1443 	.vidioc_s_frequency = cxusb_medion_s_frequency,
1444 	.vidioc_log_status = cxusb_medion_log_status
1445 };
1446 
1447 /*
1448  * in principle, this should be const, but s_io_pin_config is declared
1449  * to take non-const, and gcc complains
1450  */
1451 static struct v4l2_subdev_io_pin_config cxusub_medion_pin_config[] = {
1452 	{ .pin = CX25840_PIN_DVALID_PRGM0, .function = CX25840_PAD_DEFAULT,
1453 	  .strength = CX25840_PIN_DRIVE_MEDIUM },
1454 	{ .pin = CX25840_PIN_PLL_CLK_PRGM7, .function = CX25840_PAD_AUX_PLL },
1455 	{ .pin = CX25840_PIN_HRESET_PRGM2, .function = CX25840_PAD_ACTIVE,
1456 	  .strength = CX25840_PIN_DRIVE_MEDIUM }
1457 };
1458 
1459 int cxusb_medion_analog_init(struct dvb_usb_device *dvbdev)
1460 {
1461 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1462 	u8 tuner_analog_msg_data[] = { 0x9c, 0x60, 0x85, 0x54 };
1463 	struct i2c_msg tuner_analog_msg = { .addr = 0x61, .flags = 0,
1464 					    .buf = tuner_analog_msg_data,
1465 					    .len =
1466 					    sizeof(tuner_analog_msg_data) };
1467 	struct v4l2_subdev_format subfmt;
1468 	int ret;
1469 
1470 	/* switch tuner to analog mode so IF demod will become accessible */
1471 	ret = i2c_transfer(&dvbdev->i2c_adap, &tuner_analog_msg, 1);
1472 	if (ret != 1)
1473 		dev_warn(&dvbdev->udev->dev,
1474 			 "tuner analog switch failed (%d)\n", ret);
1475 
1476 	/*
1477 	 * cx25840 might have lost power during mode switching so we need
1478 	 * to set it again
1479 	 */
1480 	ret = v4l2_subdev_call(cxdev->cx25840, core, reset, 0);
1481 	if (ret != 0)
1482 		dev_warn(&dvbdev->udev->dev,
1483 			 "cx25840 reset failed (%d)\n", ret);
1484 
1485 	ret = v4l2_subdev_call(cxdev->cx25840, video, s_routing,
1486 			       CX25840_COMPOSITE1, 0, 0);
1487 	if (ret != 0)
1488 		dev_warn(&dvbdev->udev->dev,
1489 			 "cx25840 initial input setting failed (%d)\n", ret);
1490 
1491 	/* composite */
1492 	cxdev->input = 1;
1493 	cxdev->videodev->tvnorms = V4L2_STD_ALL;
1494 	cxdev->norm = V4L2_STD_PAL;
1495 
1496 	/* TODO: setup audio samples insertion */
1497 
1498 	ret = v4l2_subdev_call(cxdev->cx25840, core, s_io_pin_config,
1499 			       ARRAY_SIZE(cxusub_medion_pin_config),
1500 			       cxusub_medion_pin_config);
1501 	if (ret != 0)
1502 		dev_warn(&dvbdev->udev->dev,
1503 			 "cx25840 pin config failed (%d)\n", ret);
1504 
1505 	/* make sure that we aren't in radio mode */
1506 	v4l2_subdev_call(cxdev->tda9887, video, s_std, cxdev->norm);
1507 	v4l2_subdev_call(cxdev->tuner, video, s_std, cxdev->norm);
1508 	v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1509 
1510 	memset(&subfmt, 0, sizeof(subfmt));
1511 	subfmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1512 	subfmt.format.width = cxdev->width;
1513 	subfmt.format.height = cxdev->height;
1514 	subfmt.format.code = MEDIA_BUS_FMT_FIXED;
1515 	subfmt.format.field = V4L2_FIELD_SEQ_TB;
1516 	subfmt.format.colorspace = V4L2_COLORSPACE_SMPTE170M;
1517 
1518 	ret = v4l2_subdev_call(cxdev->cx25840, pad, set_fmt, NULL, &subfmt);
1519 	if (ret != 0)
1520 		dev_warn(&dvbdev->udev->dev,
1521 			 "cx25840 format set failed (%d)\n", ret);
1522 
1523 	if (ret == 0) {
1524 		cxdev->width = subfmt.format.width;
1525 		cxdev->height = subfmt.format.height;
1526 	}
1527 
1528 	return 0;
1529 }
1530 
1531 static int cxusb_videoradio_open(struct file *f)
1532 {
1533 	struct dvb_usb_device *dvbdev = video_drvdata(f);
1534 	int ret;
1535 
1536 	/*
1537 	 * no locking needed since this call only modifies analog
1538 	 * state if there are no other analog handles currenly
1539 	 * opened so ops done via them cannot create a conflict
1540 	 */
1541 	ret = cxusb_medion_get(dvbdev, CXUSB_OPEN_ANALOG);
1542 	if (ret != 0)
1543 		return ret;
1544 
1545 	ret = v4l2_fh_open(f);
1546 	if (ret != 0)
1547 		goto ret_release;
1548 
1549 	cxusb_vprintk(dvbdev, OPS, "got open\n");
1550 
1551 	return 0;
1552 
1553 ret_release:
1554 	cxusb_medion_put(dvbdev);
1555 
1556 	return ret;
1557 }
1558 
1559 static int cxusb_videoradio_release(struct file *f)
1560 {
1561 	struct video_device *vdev = video_devdata(f);
1562 	struct dvb_usb_device *dvbdev = video_drvdata(f);
1563 	int ret;
1564 
1565 	cxusb_vprintk(dvbdev, OPS, "got release\n");
1566 
1567 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1568 		ret = vb2_fop_release(f);
1569 	else
1570 		ret = v4l2_fh_release(f);
1571 
1572 	cxusb_medion_put(dvbdev);
1573 
1574 	return ret;
1575 }
1576 
1577 static const struct v4l2_file_operations cxusb_video_fops = {
1578 	.owner = THIS_MODULE,
1579 	.read = vb2_fop_read,
1580 	.poll = vb2_fop_poll,
1581 	.unlocked_ioctl = video_ioctl2,
1582 	.mmap = vb2_fop_mmap,
1583 	.open = cxusb_videoradio_open,
1584 	.release = cxusb_videoradio_release
1585 };
1586 
1587 static const struct v4l2_file_operations cxusb_radio_fops = {
1588 	.owner = THIS_MODULE,
1589 	.unlocked_ioctl = video_ioctl2,
1590 	.open = cxusb_videoradio_open,
1591 	.release = cxusb_videoradio_release
1592 };
1593 
1594 static void cxusb_medion_v4l2_release(struct v4l2_device *v4l2_dev)
1595 {
1596 	struct cxusb_medion_dev *cxdev =
1597 		container_of(v4l2_dev, struct cxusb_medion_dev, v4l2dev);
1598 	struct dvb_usb_device *dvbdev = cxdev->dvbdev;
1599 
1600 	cxusb_vprintk(dvbdev, OPS, "v4l2 device release\n");
1601 
1602 	v4l2_device_unregister(&cxdev->v4l2dev);
1603 
1604 	mutex_destroy(&cxdev->dev_lock);
1605 
1606 	while (completion_done(&cxdev->v4l2_release))
1607 		schedule();
1608 
1609 	complete(&cxdev->v4l2_release);
1610 }
1611 
1612 static void cxusb_medion_videodev_release(struct video_device *vdev)
1613 {
1614 	struct dvb_usb_device *dvbdev = video_get_drvdata(vdev);
1615 
1616 	cxusb_vprintk(dvbdev, OPS, "video device release\n");
1617 
1618 	vb2_queue_release(vdev->queue);
1619 
1620 	video_device_release(vdev);
1621 }
1622 
1623 static int cxusb_medion_register_analog_video(struct dvb_usb_device *dvbdev)
1624 {
1625 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1626 	int ret;
1627 
1628 	cxdev->videoqueue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1629 	cxdev->videoqueue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ |
1630 		VB2_DMABUF;
1631 	cxdev->videoqueue.ops = &cxdev_video_qops;
1632 	cxdev->videoqueue.mem_ops = &vb2_vmalloc_memops;
1633 	cxdev->videoqueue.drv_priv = dvbdev;
1634 	cxdev->videoqueue.buf_struct_size =
1635 		sizeof(struct cxusb_medion_vbuffer);
1636 	cxdev->videoqueue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1637 	cxdev->videoqueue.min_buffers_needed = 6;
1638 	cxdev->videoqueue.lock = &cxdev->dev_lock;
1639 
1640 	ret = vb2_queue_init(&cxdev->videoqueue);
1641 	if (ret) {
1642 		dev_err(&dvbdev->udev->dev,
1643 			"video queue init failed, ret = %d\n", ret);
1644 		return ret;
1645 	}
1646 
1647 	cxdev->videodev = video_device_alloc();
1648 	if (!cxdev->videodev) {
1649 		dev_err(&dvbdev->udev->dev, "video device alloc failed\n");
1650 		ret = -ENOMEM;
1651 		goto ret_qrelease;
1652 	}
1653 
1654 	cxdev->videodev->device_caps = videocaps;
1655 	cxdev->videodev->fops = &cxusb_video_fops;
1656 	cxdev->videodev->v4l2_dev = &cxdev->v4l2dev;
1657 	cxdev->videodev->queue = &cxdev->videoqueue;
1658 	strscpy(cxdev->videodev->name, "cxusb", sizeof(cxdev->videodev->name));
1659 	cxdev->videodev->vfl_dir = VFL_DIR_RX;
1660 	cxdev->videodev->ioctl_ops = &cxusb_video_ioctl;
1661 	cxdev->videodev->tvnorms = V4L2_STD_ALL;
1662 	cxdev->videodev->release = cxusb_medion_videodev_release;
1663 	cxdev->videodev->lock = &cxdev->dev_lock;
1664 	video_set_drvdata(cxdev->videodev, dvbdev);
1665 
1666 	ret = video_register_device(cxdev->videodev, VFL_TYPE_GRABBER, -1);
1667 	if (ret) {
1668 		dev_err(&dvbdev->udev->dev,
1669 			"video device register failed, ret = %d\n", ret);
1670 		goto ret_vrelease;
1671 	}
1672 
1673 	return 0;
1674 
1675 ret_vrelease:
1676 	video_device_release(cxdev->videodev);
1677 
1678 ret_qrelease:
1679 	vb2_queue_release(&cxdev->videoqueue);
1680 
1681 	return ret;
1682 }
1683 
1684 static int cxusb_medion_register_analog_radio(struct dvb_usb_device *dvbdev)
1685 {
1686 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1687 	int ret;
1688 
1689 	cxdev->radiodev = video_device_alloc();
1690 	if (!cxdev->radiodev) {
1691 		dev_err(&dvbdev->udev->dev, "radio device alloc failed\n");
1692 		return -ENOMEM;
1693 	}
1694 
1695 	cxdev->radiodev->device_caps = radiocaps;
1696 	cxdev->radiodev->fops = &cxusb_radio_fops;
1697 	cxdev->radiodev->v4l2_dev = &cxdev->v4l2dev;
1698 	strscpy(cxdev->radiodev->name, "cxusb", sizeof(cxdev->radiodev->name));
1699 	cxdev->radiodev->vfl_dir = VFL_DIR_RX;
1700 	cxdev->radiodev->ioctl_ops = &cxusb_radio_ioctl;
1701 	cxdev->radiodev->release = video_device_release;
1702 	cxdev->radiodev->lock = &cxdev->dev_lock;
1703 	video_set_drvdata(cxdev->radiodev, dvbdev);
1704 
1705 	ret = video_register_device(cxdev->radiodev, VFL_TYPE_RADIO, -1);
1706 	if (ret) {
1707 		dev_err(&dvbdev->udev->dev,
1708 			"radio device register failed, ret = %d\n", ret);
1709 		video_device_release(cxdev->radiodev);
1710 		return ret;
1711 	}
1712 
1713 	return 0;
1714 }
1715 
1716 static int cxusb_medion_register_analog_subdevs(struct dvb_usb_device *dvbdev)
1717 {
1718 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1719 	int ret;
1720 	struct tuner_setup tun_setup;
1721 
1722 	/* attach cx25840 capture chip */
1723 	cxdev->cx25840 = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1724 					     &dvbdev->i2c_adap,
1725 					     "cx25840", 0x44, NULL);
1726 	if (!cxdev->cx25840) {
1727 		dev_err(&dvbdev->udev->dev, "cx25840 not found\n");
1728 		return -ENODEV;
1729 	}
1730 
1731 	/*
1732 	 * Initialize cx25840 chip by calling its subdevice init core op.
1733 	 *
1734 	 * This switches it into the generic mode that disables some of
1735 	 * ivtv-related hacks in the cx25840 driver while allowing setting
1736 	 * of the chip video output configuration (passed in the call below
1737 	 * as the last argument).
1738 	 */
1739 	ret = v4l2_subdev_call(cxdev->cx25840, core, init,
1740 			       CX25840_VCONFIG_FMT_BT656 |
1741 			       CX25840_VCONFIG_RES_8BIT |
1742 			       CX25840_VCONFIG_VBIRAW_DISABLED |
1743 			       CX25840_VCONFIG_ANCDATA_DISABLED |
1744 			       CX25840_VCONFIG_ACTIVE_COMPOSITE |
1745 			       CX25840_VCONFIG_VALID_ANDACTIVE |
1746 			       CX25840_VCONFIG_HRESETW_NORMAL |
1747 			       CX25840_VCONFIG_CLKGATE_NONE |
1748 			       CX25840_VCONFIG_DCMODE_DWORDS);
1749 	if (ret != 0) {
1750 		dev_err(&dvbdev->udev->dev,
1751 			"cx25840 init failed (%d)\n", ret);
1752 		return ret;
1753 	}
1754 
1755 	/* attach analog tuner */
1756 	cxdev->tuner = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1757 					   &dvbdev->i2c_adap,
1758 					   "tuner", 0x61, NULL);
1759 	if (!cxdev->tuner) {
1760 		dev_err(&dvbdev->udev->dev, "tuner not found\n");
1761 		return -ENODEV;
1762 	}
1763 
1764 	/* configure it */
1765 	memset(&tun_setup, 0, sizeof(tun_setup));
1766 	tun_setup.addr = 0x61;
1767 	tun_setup.type = TUNER_PHILIPS_FMD1216ME_MK3;
1768 	tun_setup.mode_mask = T_RADIO | T_ANALOG_TV;
1769 	v4l2_subdev_call(cxdev->tuner, tuner, s_type_addr, &tun_setup);
1770 
1771 	/* attach IF demod */
1772 	cxdev->tda9887 = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1773 					     &dvbdev->i2c_adap,
1774 					     "tuner", 0x43, NULL);
1775 	if (!cxdev->tda9887) {
1776 		dev_err(&dvbdev->udev->dev, "tda9887 not found\n");
1777 		return -ENODEV;
1778 	}
1779 
1780 	return 0;
1781 }
1782 
1783 int cxusb_medion_register_analog(struct dvb_usb_device *dvbdev)
1784 {
1785 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1786 	int ret;
1787 
1788 	mutex_init(&cxdev->dev_lock);
1789 
1790 	init_completion(&cxdev->v4l2_release);
1791 
1792 	cxdev->v4l2dev.release = cxusb_medion_v4l2_release;
1793 
1794 	ret = v4l2_device_register(&dvbdev->udev->dev, &cxdev->v4l2dev);
1795 	if (ret != 0) {
1796 		dev_err(&dvbdev->udev->dev,
1797 			"V4L2 device registration failed, ret = %d\n", ret);
1798 		mutex_destroy(&cxdev->dev_lock);
1799 		return ret;
1800 	}
1801 
1802 	ret = cxusb_medion_register_analog_subdevs(dvbdev);
1803 	if (ret)
1804 		goto ret_unregister;
1805 
1806 	INIT_WORK(&cxdev->urbwork, cxusb_medion_v_complete_work);
1807 	INIT_LIST_HEAD(&cxdev->buflist);
1808 
1809 	cxdev->width = 320;
1810 	cxdev->height = 240;
1811 
1812 	ret = cxusb_medion_register_analog_video(dvbdev);
1813 	if (ret)
1814 		goto ret_unregister;
1815 
1816 	ret = cxusb_medion_register_analog_radio(dvbdev);
1817 	if (ret)
1818 		goto ret_vunreg;
1819 
1820 	return 0;
1821 
1822 ret_vunreg:
1823 	video_unregister_device(cxdev->videodev);
1824 
1825 ret_unregister:
1826 	v4l2_device_put(&cxdev->v4l2dev);
1827 	wait_for_completion(&cxdev->v4l2_release);
1828 
1829 	return ret;
1830 }
1831 
1832 void cxusb_medion_unregister_analog(struct dvb_usb_device *dvbdev)
1833 {
1834 	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1835 
1836 	cxusb_vprintk(dvbdev, OPS, "unregistering analog\n");
1837 
1838 	video_unregister_device(cxdev->radiodev);
1839 	video_unregister_device(cxdev->videodev);
1840 
1841 	v4l2_device_put(&cxdev->v4l2dev);
1842 	wait_for_completion(&cxdev->v4l2_release);
1843 
1844 	cxusb_vprintk(dvbdev, OPS, "analog unregistered\n");
1845 }
1846