1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Driver for the Auvitek USB bridge
4  *
5  *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
6  */
7 
8 #include "au0828.h"
9 
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/init.h>
13 #include <linux/device.h>
14 #include <media/v4l2-common.h>
15 #include <media/tuner.h>
16 
17 #include "au8522.h"
18 #include "xc5000.h"
19 #include "mxl5007t.h"
20 #include "tda18271.h"
21 
22 static int preallocate_big_buffers;
23 module_param_named(preallocate_big_buffers, preallocate_big_buffers, int, 0644);
24 MODULE_PARM_DESC(preallocate_big_buffers, "Preallocate the larger transfer buffers at module load time");
25 
26 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
27 
28 #define _AU0828_BULKPIPE 0x83
29 #define _BULKPIPESIZE 0xe522
30 
31 static u8 hauppauge_hvr950q_led_states[] = {
32 	0x00, /* off */
33 	0x02, /* yellow */
34 	0x04, /* green */
35 };
36 
37 static struct au8522_led_config hauppauge_hvr950q_led_cfg = {
38 	.gpio_output = 0x00e0,
39 	.gpio_output_enable  = 0x6006,
40 	.gpio_output_disable = 0x0660,
41 
42 	.gpio_leds = 0x00e2,
43 	.led_states  = hauppauge_hvr950q_led_states,
44 	.num_led_states = sizeof(hauppauge_hvr950q_led_states),
45 
46 	.vsb8_strong   = 20 /* dB */ * 10,
47 	.qam64_strong  = 25 /* dB */ * 10,
48 	.qam256_strong = 32 /* dB */ * 10,
49 };
50 
51 static struct au8522_config hauppauge_hvr950q_config = {
52 	.demod_address = 0x8e >> 1,
53 	.status_mode   = AU8522_DEMODLOCKING,
54 	.qam_if        = AU8522_IF_6MHZ,
55 	.vsb_if        = AU8522_IF_6MHZ,
56 	.led_cfg       = &hauppauge_hvr950q_led_cfg,
57 };
58 
59 static struct au8522_config fusionhdtv7usb_config = {
60 	.demod_address = 0x8e >> 1,
61 	.status_mode   = AU8522_DEMODLOCKING,
62 	.qam_if        = AU8522_IF_6MHZ,
63 	.vsb_if        = AU8522_IF_6MHZ,
64 };
65 
66 static struct au8522_config hauppauge_woodbury_config = {
67 	.demod_address = 0x8e >> 1,
68 	.status_mode   = AU8522_DEMODLOCKING,
69 	.qam_if        = AU8522_IF_4MHZ,
70 	.vsb_if        = AU8522_IF_3_25MHZ,
71 };
72 
73 static struct xc5000_config hauppauge_xc5000a_config = {
74 	.i2c_address      = 0x61,
75 	.if_khz           = 6000,
76 	.chip_id          = XC5000A,
77 	.output_amp       = 0x8f,
78 };
79 
80 static struct xc5000_config hauppauge_xc5000c_config = {
81 	.i2c_address      = 0x61,
82 	.if_khz           = 6000,
83 	.chip_id          = XC5000C,
84 	.output_amp       = 0x8f,
85 };
86 
87 static struct mxl5007t_config mxl5007t_hvr950q_config = {
88 	.xtal_freq_hz = MxL_XTAL_24_MHZ,
89 	.if_freq_hz = MxL_IF_6_MHZ,
90 };
91 
92 static struct tda18271_config hauppauge_woodbury_tunerconfig = {
93 	.gate    = TDA18271_GATE_DIGITAL,
94 };
95 
96 static void au0828_restart_dvb_streaming(struct work_struct *work);
97 
98 static void au0828_bulk_timeout(struct timer_list *t)
99 {
100 	struct au0828_dev *dev = from_timer(dev, t, bulk_timeout);
101 
102 	dprintk(1, "%s called\n", __func__);
103 	dev->bulk_timeout_running = 0;
104 	schedule_work(&dev->restart_streaming);
105 }
106 
107 /*-------------------------------------------------------------------*/
108 static void urb_completion(struct urb *purb)
109 {
110 	struct au0828_dev *dev = purb->context;
111 	int ptype = usb_pipetype(purb->pipe);
112 	unsigned char *ptr;
113 
114 	dprintk(2, "%s: %d\n", __func__, purb->actual_length);
115 
116 	if (!dev) {
117 		dprintk(2, "%s: no dev!\n", __func__);
118 		return;
119 	}
120 
121 	if (!dev->urb_streaming) {
122 		dprintk(2, "%s: not streaming!\n", __func__);
123 		return;
124 	}
125 
126 	if (ptype != PIPE_BULK) {
127 		pr_err("%s: Unsupported URB type %d\n",
128 		       __func__, ptype);
129 		return;
130 	}
131 
132 	/* See if the stream is corrupted (to work around a hardware
133 	   bug where the stream gets misaligned */
134 	ptr = purb->transfer_buffer;
135 	if (purb->actual_length > 0 && ptr[0] != 0x47) {
136 		dprintk(1, "Need to restart streaming %02x len=%d!\n",
137 			ptr[0], purb->actual_length);
138 		schedule_work(&dev->restart_streaming);
139 		return;
140 	} else if (dev->bulk_timeout_running == 1) {
141 		/* The URB handler has fired, so cancel timer which would
142 		 * restart endpoint if we hadn't
143 		 */
144 		dprintk(1, "%s cancelling bulk timeout\n", __func__);
145 		dev->bulk_timeout_running = 0;
146 		del_timer(&dev->bulk_timeout);
147 	}
148 
149 	/* Feed the transport payload into the kernel demux */
150 	dvb_dmx_swfilter_packets(&dev->dvb.demux,
151 		purb->transfer_buffer, purb->actual_length / 188);
152 
153 	/* Clean the buffer before we requeue */
154 	memset(purb->transfer_buffer, 0, URB_BUFSIZE);
155 
156 	/* Requeue URB */
157 	usb_submit_urb(purb, GFP_ATOMIC);
158 }
159 
160 static int stop_urb_transfer(struct au0828_dev *dev)
161 {
162 	int i;
163 
164 	dprintk(2, "%s()\n", __func__);
165 
166 	if (!dev->urb_streaming)
167 		return 0;
168 
169 	if (dev->bulk_timeout_running == 1) {
170 		dev->bulk_timeout_running = 0;
171 		del_timer(&dev->bulk_timeout);
172 	}
173 
174 	dev->urb_streaming = false;
175 	for (i = 0; i < URB_COUNT; i++) {
176 		if (dev->urbs[i]) {
177 			usb_kill_urb(dev->urbs[i]);
178 			if (!preallocate_big_buffers)
179 				kfree(dev->urbs[i]->transfer_buffer);
180 
181 			usb_free_urb(dev->urbs[i]);
182 		}
183 	}
184 
185 	return 0;
186 }
187 
188 static int start_urb_transfer(struct au0828_dev *dev)
189 {
190 	struct urb *purb;
191 	int i, ret;
192 
193 	dprintk(2, "%s()\n", __func__);
194 
195 	if (dev->urb_streaming) {
196 		dprintk(2, "%s: bulk xfer already running!\n", __func__);
197 		return 0;
198 	}
199 
200 	for (i = 0; i < URB_COUNT; i++) {
201 
202 		dev->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
203 		if (!dev->urbs[i])
204 			return -ENOMEM;
205 
206 		purb = dev->urbs[i];
207 
208 		if (preallocate_big_buffers)
209 			purb->transfer_buffer = dev->dig_transfer_buffer[i];
210 		else
211 			purb->transfer_buffer = kzalloc(URB_BUFSIZE,
212 					GFP_KERNEL);
213 
214 		if (!purb->transfer_buffer) {
215 			usb_free_urb(purb);
216 			dev->urbs[i] = NULL;
217 			ret = -ENOMEM;
218 			pr_err("%s: failed big buffer allocation, err = %d\n",
219 			       __func__, ret);
220 			return ret;
221 		}
222 
223 		purb->status = -EINPROGRESS;
224 		usb_fill_bulk_urb(purb,
225 				  dev->usbdev,
226 				  usb_rcvbulkpipe(dev->usbdev,
227 					_AU0828_BULKPIPE),
228 				  purb->transfer_buffer,
229 				  URB_BUFSIZE,
230 				  urb_completion,
231 				  dev);
232 
233 	}
234 
235 	for (i = 0; i < URB_COUNT; i++) {
236 		ret = usb_submit_urb(dev->urbs[i], GFP_ATOMIC);
237 		if (ret != 0) {
238 			stop_urb_transfer(dev);
239 			pr_err("%s: failed urb submission, err = %d\n",
240 			       __func__, ret);
241 			return ret;
242 		}
243 	}
244 
245 	dev->urb_streaming = true;
246 
247 	/* If we don't valid data within 1 second, restart stream */
248 	mod_timer(&dev->bulk_timeout, jiffies + (HZ));
249 	dev->bulk_timeout_running = 1;
250 
251 	return 0;
252 }
253 
254 static void au0828_start_transport(struct au0828_dev *dev)
255 {
256 	au0828_write(dev, 0x608, 0x90);
257 	au0828_write(dev, 0x609, 0x72);
258 	au0828_write(dev, 0x60a, 0x71);
259 	au0828_write(dev, 0x60b, 0x01);
260 
261 }
262 
263 static void au0828_stop_transport(struct au0828_dev *dev, int full_stop)
264 {
265 	if (full_stop) {
266 		au0828_write(dev, 0x608, 0x00);
267 		au0828_write(dev, 0x609, 0x00);
268 		au0828_write(dev, 0x60a, 0x00);
269 	}
270 	au0828_write(dev, 0x60b, 0x00);
271 }
272 
273 static int au0828_dvb_start_feed(struct dvb_demux_feed *feed)
274 {
275 	struct dvb_demux *demux = feed->demux;
276 	struct au0828_dev *dev = demux->priv;
277 	struct au0828_dvb *dvb = &dev->dvb;
278 	int ret = 0;
279 
280 	dprintk(1, "%s()\n", __func__);
281 
282 	if (!demux->dmx.frontend)
283 		return -EINVAL;
284 
285 	if (dvb->frontend) {
286 		mutex_lock(&dvb->lock);
287 		dvb->start_count++;
288 		dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
289 			dvb->start_count, dvb->stop_count);
290 		if (dvb->feeding++ == 0) {
291 			/* Start transport */
292 			au0828_start_transport(dev);
293 			ret = start_urb_transfer(dev);
294 			if (ret < 0) {
295 				au0828_stop_transport(dev, 0);
296 				dvb->feeding--;	/* We ran out of memory... */
297 			}
298 		}
299 		mutex_unlock(&dvb->lock);
300 	}
301 
302 	return ret;
303 }
304 
305 static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
306 {
307 	struct dvb_demux *demux = feed->demux;
308 	struct au0828_dev *dev = demux->priv;
309 	struct au0828_dvb *dvb = &dev->dvb;
310 	int ret = 0;
311 
312 	dprintk(1, "%s()\n", __func__);
313 
314 	if (dvb->frontend) {
315 		cancel_work_sync(&dev->restart_streaming);
316 
317 		mutex_lock(&dvb->lock);
318 		dvb->stop_count++;
319 		dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
320 			dvb->start_count, dvb->stop_count);
321 		if (dvb->feeding > 0) {
322 			dvb->feeding--;
323 			if (dvb->feeding == 0) {
324 				/* Stop transport */
325 				ret = stop_urb_transfer(dev);
326 				au0828_stop_transport(dev, 0);
327 			}
328 		}
329 		mutex_unlock(&dvb->lock);
330 	}
331 
332 	return ret;
333 }
334 
335 static void au0828_restart_dvb_streaming(struct work_struct *work)
336 {
337 	struct au0828_dev *dev = container_of(work, struct au0828_dev,
338 					      restart_streaming);
339 	struct au0828_dvb *dvb = &dev->dvb;
340 
341 	if (!dev->urb_streaming)
342 		return;
343 
344 	dprintk(1, "Restarting streaming...!\n");
345 
346 	mutex_lock(&dvb->lock);
347 
348 	/* Stop transport */
349 	stop_urb_transfer(dev);
350 	au0828_stop_transport(dev, 1);
351 
352 	/* Start transport */
353 	au0828_start_transport(dev);
354 	start_urb_transfer(dev);
355 
356 	mutex_unlock(&dvb->lock);
357 }
358 
359 static int au0828_set_frontend(struct dvb_frontend *fe)
360 {
361 	struct au0828_dev *dev = fe->dvb->priv;
362 	struct au0828_dvb *dvb = &dev->dvb;
363 	int ret, was_streaming;
364 
365 	mutex_lock(&dvb->lock);
366 	was_streaming = dev->urb_streaming;
367 	if (was_streaming) {
368 		au0828_stop_transport(dev, 1);
369 
370 		/*
371 		 * We can't hold a mutex here, as the restart_streaming
372 		 * kthread may also hold it.
373 		 */
374 		mutex_unlock(&dvb->lock);
375 		cancel_work_sync(&dev->restart_streaming);
376 		mutex_lock(&dvb->lock);
377 
378 		stop_urb_transfer(dev);
379 	}
380 	mutex_unlock(&dvb->lock);
381 
382 	ret = dvb->set_frontend(fe);
383 
384 	if (was_streaming) {
385 		mutex_lock(&dvb->lock);
386 		au0828_start_transport(dev);
387 		start_urb_transfer(dev);
388 		mutex_unlock(&dvb->lock);
389 	}
390 
391 	return ret;
392 }
393 
394 static int dvb_register(struct au0828_dev *dev)
395 {
396 	struct au0828_dvb *dvb = &dev->dvb;
397 	int result;
398 
399 	dprintk(1, "%s()\n", __func__);
400 
401 	if (preallocate_big_buffers) {
402 		int i;
403 		for (i = 0; i < URB_COUNT; i++) {
404 			dev->dig_transfer_buffer[i] = kzalloc(URB_BUFSIZE,
405 					GFP_KERNEL);
406 
407 			if (!dev->dig_transfer_buffer[i]) {
408 				result = -ENOMEM;
409 
410 				pr_err("failed buffer allocation (errno = %d)\n",
411 				       result);
412 				goto fail_adapter;
413 			}
414 		}
415 	}
416 
417 	INIT_WORK(&dev->restart_streaming, au0828_restart_dvb_streaming);
418 
419 	/* register adapter */
420 	result = dvb_register_adapter(&dvb->adapter,
421 				      KBUILD_MODNAME, THIS_MODULE,
422 				      &dev->usbdev->dev, adapter_nr);
423 	if (result < 0) {
424 		pr_err("dvb_register_adapter failed (errno = %d)\n",
425 		       result);
426 		goto fail_adapter;
427 	}
428 
429 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
430 	dvb->adapter.mdev = dev->media_dev;
431 #endif
432 
433 	dvb->adapter.priv = dev;
434 
435 	/* register frontend */
436 	result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
437 	if (result < 0) {
438 		pr_err("dvb_register_frontend failed (errno = %d)\n",
439 		       result);
440 		goto fail_frontend;
441 	}
442 
443 	/* Hook dvb frontend */
444 	dvb->set_frontend = dvb->frontend->ops.set_frontend;
445 	dvb->frontend->ops.set_frontend = au0828_set_frontend;
446 
447 	/* register demux stuff */
448 	dvb->demux.dmx.capabilities =
449 		DMX_TS_FILTERING | DMX_SECTION_FILTERING |
450 		DMX_MEMORY_BASED_FILTERING;
451 	dvb->demux.priv       = dev;
452 	dvb->demux.filternum  = 256;
453 	dvb->demux.feednum    = 256;
454 	dvb->demux.start_feed = au0828_dvb_start_feed;
455 	dvb->demux.stop_feed  = au0828_dvb_stop_feed;
456 	result = dvb_dmx_init(&dvb->demux);
457 	if (result < 0) {
458 		pr_err("dvb_dmx_init failed (errno = %d)\n", result);
459 		goto fail_dmx;
460 	}
461 
462 	dvb->dmxdev.filternum    = 256;
463 	dvb->dmxdev.demux        = &dvb->demux.dmx;
464 	dvb->dmxdev.capabilities = 0;
465 	result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
466 	if (result < 0) {
467 		pr_err("dvb_dmxdev_init failed (errno = %d)\n", result);
468 		goto fail_dmxdev;
469 	}
470 
471 	dvb->fe_hw.source = DMX_FRONTEND_0;
472 	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
473 	if (result < 0) {
474 		pr_err("add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
475 		       result);
476 		goto fail_fe_hw;
477 	}
478 
479 	dvb->fe_mem.source = DMX_MEMORY_FE;
480 	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
481 	if (result < 0) {
482 		pr_err("add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
483 		       result);
484 		goto fail_fe_mem;
485 	}
486 
487 	result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
488 	if (result < 0) {
489 		pr_err("connect_frontend failed (errno = %d)\n", result);
490 		goto fail_fe_conn;
491 	}
492 
493 	/* register network adapter */
494 	dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
495 
496 	dvb->start_count = 0;
497 	dvb->stop_count = 0;
498 
499 	result = dvb_create_media_graph(&dvb->adapter, false);
500 	if (result < 0)
501 		goto fail_create_graph;
502 
503 	return 0;
504 
505 fail_create_graph:
506 	dvb_net_release(&dvb->net);
507 fail_fe_conn:
508 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
509 fail_fe_mem:
510 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
511 fail_fe_hw:
512 	dvb_dmxdev_release(&dvb->dmxdev);
513 fail_dmxdev:
514 	dvb_dmx_release(&dvb->demux);
515 fail_dmx:
516 	dvb_unregister_frontend(dvb->frontend);
517 fail_frontend:
518 	dvb_frontend_detach(dvb->frontend);
519 	dvb_unregister_adapter(&dvb->adapter);
520 fail_adapter:
521 
522 	if (preallocate_big_buffers) {
523 		int i;
524 		for (i = 0; i < URB_COUNT; i++)
525 			kfree(dev->dig_transfer_buffer[i]);
526 	}
527 
528 	return result;
529 }
530 
531 void au0828_dvb_unregister(struct au0828_dev *dev)
532 {
533 	struct au0828_dvb *dvb = &dev->dvb;
534 
535 	dprintk(1, "%s()\n", __func__);
536 
537 	if (dvb->frontend == NULL)
538 		return;
539 
540 	cancel_work_sync(&dev->restart_streaming);
541 
542 	dvb_net_release(&dvb->net);
543 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
544 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
545 	dvb_dmxdev_release(&dvb->dmxdev);
546 	dvb_dmx_release(&dvb->demux);
547 	dvb_unregister_frontend(dvb->frontend);
548 	dvb_frontend_detach(dvb->frontend);
549 	dvb_unregister_adapter(&dvb->adapter);
550 
551 	if (preallocate_big_buffers) {
552 		int i;
553 		for (i = 0; i < URB_COUNT; i++)
554 			kfree(dev->dig_transfer_buffer[i]);
555 	}
556 	dvb->frontend = NULL;
557 }
558 
559 /* All the DVB attach calls go here, this function gets modified
560  * for each new card. No other function in this file needs
561  * to change.
562  */
563 int au0828_dvb_register(struct au0828_dev *dev)
564 {
565 	struct au0828_dvb *dvb = &dev->dvb;
566 	int ret;
567 
568 	dprintk(1, "%s()\n", __func__);
569 
570 	/* init frontend */
571 	switch (dev->boardnr) {
572 	case AU0828_BOARD_HAUPPAUGE_HVR850:
573 	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
574 		dvb->frontend = dvb_attach(au8522_attach,
575 				&hauppauge_hvr950q_config,
576 				&dev->i2c_adap);
577 		if (dvb->frontend != NULL)
578 			switch (dev->board.tuner_type) {
579 			default:
580 			case TUNER_XC5000:
581 				dvb_attach(xc5000_attach, dvb->frontend,
582 					   &dev->i2c_adap,
583 					   &hauppauge_xc5000a_config);
584 				break;
585 			case TUNER_XC5000C:
586 				dvb_attach(xc5000_attach, dvb->frontend,
587 					   &dev->i2c_adap,
588 					   &hauppauge_xc5000c_config);
589 				break;
590 			}
591 		break;
592 	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
593 		dvb->frontend = dvb_attach(au8522_attach,
594 				&hauppauge_hvr950q_config,
595 				&dev->i2c_adap);
596 		if (dvb->frontend != NULL)
597 			dvb_attach(mxl5007t_attach, dvb->frontend,
598 				   &dev->i2c_adap, 0x60,
599 				   &mxl5007t_hvr950q_config);
600 		break;
601 	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
602 		dvb->frontend = dvb_attach(au8522_attach,
603 				&hauppauge_woodbury_config,
604 				&dev->i2c_adap);
605 		if (dvb->frontend != NULL)
606 			dvb_attach(tda18271_attach, dvb->frontend,
607 				   0x60, &dev->i2c_adap,
608 				   &hauppauge_woodbury_tunerconfig);
609 		break;
610 	case AU0828_BOARD_DVICO_FUSIONHDTV7:
611 		dvb->frontend = dvb_attach(au8522_attach,
612 				&fusionhdtv7usb_config,
613 				&dev->i2c_adap);
614 		if (dvb->frontend != NULL) {
615 			dvb_attach(xc5000_attach, dvb->frontend,
616 				&dev->i2c_adap,
617 				&hauppauge_xc5000a_config);
618 		}
619 		break;
620 	default:
621 		pr_warn("The frontend of your DVB/ATSC card isn't supported yet\n");
622 		break;
623 	}
624 	if (NULL == dvb->frontend) {
625 		pr_err("%s() Frontend initialization failed\n",
626 		       __func__);
627 		return -1;
628 	}
629 	/* define general-purpose callback pointer */
630 	dvb->frontend->callback = au0828_tuner_callback;
631 
632 	/* register everything */
633 	ret = dvb_register(dev);
634 	if (ret < 0) {
635 		if (dvb->frontend->ops.release)
636 			dvb->frontend->ops.release(dvb->frontend);
637 		dvb->frontend = NULL;
638 		return ret;
639 	}
640 
641 	timer_setup(&dev->bulk_timeout, au0828_bulk_timeout, 0);
642 
643 	return 0;
644 }
645 
646 void au0828_dvb_suspend(struct au0828_dev *dev)
647 {
648 	struct au0828_dvb *dvb = &dev->dvb;
649 	int rc;
650 
651 	if (dvb->frontend) {
652 		if (dev->urb_streaming) {
653 			cancel_work_sync(&dev->restart_streaming);
654 			/* Stop transport */
655 			mutex_lock(&dvb->lock);
656 			stop_urb_transfer(dev);
657 			au0828_stop_transport(dev, 1);
658 			mutex_unlock(&dvb->lock);
659 			dev->need_urb_start = true;
660 		}
661 		/* suspend frontend - does tuner and fe to sleep */
662 		rc = dvb_frontend_suspend(dvb->frontend);
663 		pr_info("au0828_dvb_suspend(): Suspending DVB fe %d\n", rc);
664 	}
665 }
666 
667 void au0828_dvb_resume(struct au0828_dev *dev)
668 {
669 	struct au0828_dvb *dvb = &dev->dvb;
670 	int rc;
671 
672 	if (dvb->frontend) {
673 		/* resume frontend - does fe and tuner init */
674 		rc = dvb_frontend_resume(dvb->frontend);
675 		pr_info("au0828_dvb_resume(): Resuming DVB fe %d\n", rc);
676 		if (dev->need_urb_start) {
677 			/* Start transport */
678 			mutex_lock(&dvb->lock);
679 			au0828_start_transport(dev);
680 			start_urb_transfer(dev);
681 			mutex_unlock(&dvb->lock);
682 		}
683 	}
684 }
685