1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * DVB USB framework
4  *
5  * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.de>
6  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
7  */
8 
9 #include "dvb_usb_common.h"
10 #include <media/media-device.h>
11 
12 static int dvb_usbv2_disable_rc_polling;
13 module_param_named(disable_rc_polling, dvb_usbv2_disable_rc_polling, int, 0644);
14 MODULE_PARM_DESC(disable_rc_polling,
15 		"disable remote control polling (default: 0)");
16 static int dvb_usb_force_pid_filter_usage;
17 module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage,
18 		int, 0444);
19 MODULE_PARM_DESC(force_pid_filter_usage,
20 		"force all DVB USB devices to use a PID filter, if any (default: 0)");
21 
dvb_usbv2_download_firmware(struct dvb_usb_device * d,const char * name)22 static int dvb_usbv2_download_firmware(struct dvb_usb_device *d,
23 		const char *name)
24 {
25 	int ret;
26 	const struct firmware *fw;
27 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
28 
29 	if (!d->props->download_firmware) {
30 		ret = -EINVAL;
31 		goto err;
32 	}
33 
34 	ret = request_firmware(&fw, name, &d->udev->dev);
35 	if (ret < 0) {
36 		dev_err(&d->udev->dev,
37 				"%s: Did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\n",
38 				KBUILD_MODNAME, name, ret);
39 		goto err;
40 	}
41 
42 	dev_info(&d->udev->dev, "%s: downloading firmware from file '%s'\n",
43 			KBUILD_MODNAME, name);
44 
45 	ret = d->props->download_firmware(d, fw);
46 	release_firmware(fw);
47 	if (ret < 0)
48 		goto err;
49 
50 	return ret;
51 err:
52 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
53 	return ret;
54 }
55 
dvb_usbv2_i2c_init(struct dvb_usb_device * d)56 static int dvb_usbv2_i2c_init(struct dvb_usb_device *d)
57 {
58 	int ret;
59 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
60 
61 	if (!d->props->i2c_algo)
62 		return 0;
63 
64 	strscpy(d->i2c_adap.name, d->name, sizeof(d->i2c_adap.name));
65 	d->i2c_adap.algo = d->props->i2c_algo;
66 	d->i2c_adap.dev.parent = &d->udev->dev;
67 	i2c_set_adapdata(&d->i2c_adap, d);
68 
69 	ret = i2c_add_adapter(&d->i2c_adap);
70 	if (ret < 0) {
71 		d->i2c_adap.algo = NULL;
72 		goto err;
73 	}
74 
75 	return 0;
76 err:
77 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
78 	return ret;
79 }
80 
dvb_usbv2_i2c_exit(struct dvb_usb_device * d)81 static int dvb_usbv2_i2c_exit(struct dvb_usb_device *d)
82 {
83 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
84 
85 	if (d->i2c_adap.algo)
86 		i2c_del_adapter(&d->i2c_adap);
87 
88 	return 0;
89 }
90 
91 #if IS_ENABLED(CONFIG_RC_CORE)
dvb_usb_read_remote_control(struct work_struct * work)92 static void dvb_usb_read_remote_control(struct work_struct *work)
93 {
94 	struct dvb_usb_device *d = container_of(work,
95 			struct dvb_usb_device, rc_query_work.work);
96 	int ret;
97 
98 	/*
99 	 * When the parameter has been set to 1 via sysfs while the
100 	 * driver was running, or when bulk mode is enabled after IR init.
101 	 */
102 	if (dvb_usbv2_disable_rc_polling || d->rc.bulk_mode) {
103 		d->rc_polling_active = false;
104 		return;
105 	}
106 
107 	ret = d->rc.query(d);
108 	if (ret < 0) {
109 		dev_err(&d->udev->dev, "%s: rc.query() failed=%d\n",
110 				KBUILD_MODNAME, ret);
111 		d->rc_polling_active = false;
112 		return; /* stop polling */
113 	}
114 
115 	schedule_delayed_work(&d->rc_query_work,
116 			msecs_to_jiffies(d->rc.interval));
117 }
118 
dvb_usbv2_remote_init(struct dvb_usb_device * d)119 static int dvb_usbv2_remote_init(struct dvb_usb_device *d)
120 {
121 	int ret;
122 	struct rc_dev *dev;
123 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
124 
125 	if (dvb_usbv2_disable_rc_polling || !d->props->get_rc_config)
126 		return 0;
127 
128 	d->rc.map_name = d->rc_map;
129 	ret = d->props->get_rc_config(d, &d->rc);
130 	if (ret < 0)
131 		goto err;
132 
133 	/* disable rc when there is no keymap defined */
134 	if (!d->rc.map_name)
135 		return 0;
136 
137 	dev = rc_allocate_device(d->rc.driver_type);
138 	if (!dev) {
139 		ret = -ENOMEM;
140 		goto err;
141 	}
142 
143 	dev->dev.parent = &d->udev->dev;
144 	dev->device_name = d->name;
145 	usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
146 	strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
147 	dev->input_phys = d->rc_phys;
148 	usb_to_input_id(d->udev, &dev->input_id);
149 	dev->driver_name = d->props->driver_name;
150 	dev->map_name = d->rc.map_name;
151 	dev->allowed_protocols = d->rc.allowed_protos;
152 	dev->change_protocol = d->rc.change_protocol;
153 	dev->timeout = d->rc.timeout;
154 	dev->priv = d;
155 
156 	ret = rc_register_device(dev);
157 	if (ret < 0) {
158 		rc_free_device(dev);
159 		goto err;
160 	}
161 
162 	d->rc_dev = dev;
163 
164 	/* start polling if needed */
165 	if (d->rc.query && !d->rc.bulk_mode) {
166 		/* initialize a work queue for handling polling */
167 		INIT_DELAYED_WORK(&d->rc_query_work,
168 				dvb_usb_read_remote_control);
169 		dev_info(&d->udev->dev,
170 				"%s: schedule remote query interval to %d msecs\n",
171 				KBUILD_MODNAME, d->rc.interval);
172 		schedule_delayed_work(&d->rc_query_work,
173 				msecs_to_jiffies(d->rc.interval));
174 		d->rc_polling_active = true;
175 	}
176 
177 	return 0;
178 err:
179 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
180 	return ret;
181 }
182 
dvb_usbv2_remote_exit(struct dvb_usb_device * d)183 static int dvb_usbv2_remote_exit(struct dvb_usb_device *d)
184 {
185 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
186 
187 	if (d->rc_dev) {
188 		cancel_delayed_work_sync(&d->rc_query_work);
189 		rc_unregister_device(d->rc_dev);
190 		d->rc_dev = NULL;
191 	}
192 
193 	return 0;
194 }
195 #else
196 	#define dvb_usbv2_remote_init(args...) 0
197 	#define dvb_usbv2_remote_exit(args...)
198 #endif
199 
dvb_usb_data_complete(struct usb_data_stream * stream,u8 * buf,size_t len)200 static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buf,
201 		size_t len)
202 {
203 	struct dvb_usb_adapter *adap = stream->user_priv;
204 	dvb_dmx_swfilter(&adap->demux, buf, len);
205 }
206 
dvb_usb_data_complete_204(struct usb_data_stream * stream,u8 * buf,size_t len)207 static void dvb_usb_data_complete_204(struct usb_data_stream *stream, u8 *buf,
208 		size_t len)
209 {
210 	struct dvb_usb_adapter *adap = stream->user_priv;
211 	dvb_dmx_swfilter_204(&adap->demux, buf, len);
212 }
213 
dvb_usb_data_complete_raw(struct usb_data_stream * stream,u8 * buf,size_t len)214 static void dvb_usb_data_complete_raw(struct usb_data_stream *stream, u8 *buf,
215 		size_t len)
216 {
217 	struct dvb_usb_adapter *adap = stream->user_priv;
218 	dvb_dmx_swfilter_raw(&adap->demux, buf, len);
219 }
220 
dvb_usbv2_adapter_stream_init(struct dvb_usb_adapter * adap)221 static int dvb_usbv2_adapter_stream_init(struct dvb_usb_adapter *adap)
222 {
223 	dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
224 			adap->id);
225 
226 	adap->stream.udev = adap_to_d(adap)->udev;
227 	adap->stream.user_priv = adap;
228 	adap->stream.complete = dvb_usb_data_complete;
229 
230 	return usb_urb_initv2(&adap->stream, &adap->props->stream);
231 }
232 
dvb_usbv2_adapter_stream_exit(struct dvb_usb_adapter * adap)233 static int dvb_usbv2_adapter_stream_exit(struct dvb_usb_adapter *adap)
234 {
235 	dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
236 			adap->id);
237 
238 	return usb_urb_exitv2(&adap->stream);
239 }
240 
dvb_usb_start_feed(struct dvb_demux_feed * dvbdmxfeed)241 static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
242 {
243 	struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
244 	struct dvb_usb_device *d = adap_to_d(adap);
245 	int ret = 0;
246 	struct usb_data_stream_properties stream_props;
247 	dev_dbg(&d->udev->dev,
248 			"%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
249 			__func__, adap->id, adap->active_fe, dvbdmxfeed->type,
250 			adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
251 			dvbdmxfeed->pid, dvbdmxfeed->index);
252 
253 	/* wait init is done */
254 	wait_on_bit(&adap->state_bits, ADAP_INIT, TASK_UNINTERRUPTIBLE);
255 
256 	if (adap->active_fe == -1)
257 		return -EINVAL;
258 
259 	/* skip feed setup if we are already feeding */
260 	if (adap->feed_count++ > 0)
261 		goto skip_feed_start;
262 
263 	/* set 'streaming' status bit */
264 	set_bit(ADAP_STREAMING, &adap->state_bits);
265 
266 	/* resolve input and output streaming parameters */
267 	if (d->props->get_stream_config) {
268 		memcpy(&stream_props, &adap->props->stream,
269 				sizeof(struct usb_data_stream_properties));
270 		ret = d->props->get_stream_config(adap->fe[adap->active_fe],
271 				&adap->ts_type, &stream_props);
272 		if (ret)
273 			dev_err(&d->udev->dev,
274 					"%s: get_stream_config() failed=%d\n",
275 					KBUILD_MODNAME, ret);
276 	} else {
277 		stream_props = adap->props->stream;
278 	}
279 
280 	switch (adap->ts_type) {
281 	case DVB_USB_FE_TS_TYPE_204:
282 		adap->stream.complete = dvb_usb_data_complete_204;
283 		break;
284 	case DVB_USB_FE_TS_TYPE_RAW:
285 		adap->stream.complete = dvb_usb_data_complete_raw;
286 		break;
287 	case DVB_USB_FE_TS_TYPE_188:
288 	default:
289 		adap->stream.complete = dvb_usb_data_complete;
290 		break;
291 	}
292 
293 	/* submit USB streaming packets */
294 	usb_urb_submitv2(&adap->stream, &stream_props);
295 
296 	/* enable HW PID filter */
297 	if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
298 		ret = adap->props->pid_filter_ctrl(adap, 1);
299 		if (ret)
300 			dev_err(&d->udev->dev,
301 					"%s: pid_filter_ctrl() failed=%d\n",
302 					KBUILD_MODNAME, ret);
303 	}
304 
305 	/* ask device to start streaming */
306 	if (d->props->streaming_ctrl) {
307 		ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 1);
308 		if (ret)
309 			dev_err(&d->udev->dev,
310 					"%s: streaming_ctrl() failed=%d\n",
311 					KBUILD_MODNAME, ret);
312 	}
313 skip_feed_start:
314 
315 	/* add PID to device HW PID filter */
316 	if (adap->pid_filtering && adap->props->pid_filter) {
317 		ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
318 				dvbdmxfeed->pid, 1);
319 		if (ret)
320 			dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
321 					KBUILD_MODNAME, ret);
322 	}
323 
324 	if (ret)
325 		dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
326 	return ret;
327 }
328 
dvb_usb_stop_feed(struct dvb_demux_feed * dvbdmxfeed)329 static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
330 {
331 	struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
332 	struct dvb_usb_device *d = adap_to_d(adap);
333 	int ret = 0;
334 	dev_dbg(&d->udev->dev,
335 			"%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
336 			__func__, adap->id, adap->active_fe, dvbdmxfeed->type,
337 			adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
338 			dvbdmxfeed->pid, dvbdmxfeed->index);
339 
340 	if (adap->active_fe == -1)
341 		return -EINVAL;
342 
343 	/* remove PID from device HW PID filter */
344 	if (adap->pid_filtering && adap->props->pid_filter) {
345 		ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
346 				dvbdmxfeed->pid, 0);
347 		if (ret)
348 			dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
349 					KBUILD_MODNAME, ret);
350 	}
351 
352 	/* we cannot stop streaming until last PID is removed */
353 	if (--adap->feed_count > 0)
354 		goto skip_feed_stop;
355 
356 	/* ask device to stop streaming */
357 	if (d->props->streaming_ctrl) {
358 		ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 0);
359 		if (ret)
360 			dev_err(&d->udev->dev,
361 					"%s: streaming_ctrl() failed=%d\n",
362 					KBUILD_MODNAME, ret);
363 	}
364 
365 	/* disable HW PID filter */
366 	if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
367 		ret = adap->props->pid_filter_ctrl(adap, 0);
368 		if (ret)
369 			dev_err(&d->udev->dev,
370 					"%s: pid_filter_ctrl() failed=%d\n",
371 					KBUILD_MODNAME, ret);
372 	}
373 
374 	/* kill USB streaming packets */
375 	usb_urb_killv2(&adap->stream);
376 
377 	/* clear 'streaming' status bit */
378 	clear_bit(ADAP_STREAMING, &adap->state_bits);
379 	smp_mb__after_atomic();
380 	wake_up_bit(&adap->state_bits, ADAP_STREAMING);
381 skip_feed_stop:
382 
383 	if (ret)
384 		dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
385 	return ret;
386 }
387 
dvb_usbv2_media_device_init(struct dvb_usb_adapter * adap)388 static int dvb_usbv2_media_device_init(struct dvb_usb_adapter *adap)
389 {
390 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
391 	struct media_device *mdev;
392 	struct dvb_usb_device *d = adap_to_d(adap);
393 	struct usb_device *udev = d->udev;
394 
395 	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
396 	if (!mdev)
397 		return -ENOMEM;
398 
399 	media_device_usb_init(mdev, udev, d->name);
400 
401 	dvb_register_media_controller(&adap->dvb_adap, mdev);
402 
403 	dev_info(&d->udev->dev, "media controller created\n");
404 #endif
405 	return 0;
406 }
407 
dvb_usbv2_media_device_register(struct dvb_usb_adapter * adap)408 static int dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
409 {
410 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
411 	return media_device_register(adap->dvb_adap.mdev);
412 #else
413 	return 0;
414 #endif
415 }
416 
dvb_usbv2_media_device_unregister(struct dvb_usb_adapter * adap)417 static void dvb_usbv2_media_device_unregister(struct dvb_usb_adapter *adap)
418 {
419 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
420 
421 	if (!adap->dvb_adap.mdev)
422 		return;
423 
424 	media_device_unregister(adap->dvb_adap.mdev);
425 	media_device_cleanup(adap->dvb_adap.mdev);
426 	kfree(adap->dvb_adap.mdev);
427 	adap->dvb_adap.mdev = NULL;
428 
429 #endif
430 }
431 
dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter * adap)432 static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
433 {
434 	int ret;
435 	struct dvb_usb_device *d = adap_to_d(adap);
436 
437 	dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
438 
439 	ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner,
440 			&d->udev->dev, d->props->adapter_nr);
441 	if (ret < 0) {
442 		dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n",
443 				__func__, ret);
444 		goto err_dvb_register_adapter;
445 	}
446 
447 	adap->dvb_adap.priv = adap;
448 
449 	ret = dvb_usbv2_media_device_init(adap);
450 	if (ret < 0) {
451 		dev_dbg(&d->udev->dev, "%s: dvb_usbv2_media_device_init() failed=%d\n",
452 				__func__, ret);
453 		goto err_dvb_register_mc;
454 	}
455 
456 	if (d->props->read_mac_address) {
457 		ret = d->props->read_mac_address(adap,
458 				adap->dvb_adap.proposed_mac);
459 		if (ret < 0)
460 			goto err_dvb_dmx_init;
461 
462 		dev_info(&d->udev->dev, "%s: MAC address: %pM\n",
463 				KBUILD_MODNAME, adap->dvb_adap.proposed_mac);
464 	}
465 
466 	adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
467 	adap->demux.priv             = adap;
468 	adap->demux.filternum        = 0;
469 	adap->demux.filternum        = adap->max_feed_count;
470 	adap->demux.feednum          = adap->demux.filternum;
471 	adap->demux.start_feed       = dvb_usb_start_feed;
472 	adap->demux.stop_feed        = dvb_usb_stop_feed;
473 	adap->demux.write_to_decoder = NULL;
474 	ret = dvb_dmx_init(&adap->demux);
475 	if (ret < 0) {
476 		dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n",
477 				KBUILD_MODNAME, ret);
478 		goto err_dvb_dmx_init;
479 	}
480 
481 	adap->dmxdev.filternum       = adap->demux.filternum;
482 	adap->dmxdev.demux           = &adap->demux.dmx;
483 	adap->dmxdev.capabilities    = 0;
484 	ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
485 	if (ret < 0) {
486 		dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n",
487 				KBUILD_MODNAME, ret);
488 		goto err_dvb_dmxdev_init;
489 	}
490 
491 	ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
492 	if (ret < 0) {
493 		dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n",
494 				KBUILD_MODNAME, ret);
495 		goto err_dvb_net_init;
496 	}
497 
498 	return 0;
499 err_dvb_net_init:
500 	dvb_dmxdev_release(&adap->dmxdev);
501 err_dvb_dmxdev_init:
502 	dvb_dmx_release(&adap->demux);
503 err_dvb_dmx_init:
504 	dvb_usbv2_media_device_unregister(adap);
505 err_dvb_register_mc:
506 	dvb_unregister_adapter(&adap->dvb_adap);
507 err_dvb_register_adapter:
508 	adap->dvb_adap.priv = NULL;
509 	return ret;
510 }
511 
dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter * adap)512 static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
513 {
514 	dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
515 			adap->id);
516 
517 	if (adap->dvb_adap.priv) {
518 		dvb_net_release(&adap->dvb_net);
519 		adap->demux.dmx.close(&adap->demux.dmx);
520 		dvb_dmxdev_release(&adap->dmxdev);
521 		dvb_dmx_release(&adap->demux);
522 		dvb_unregister_adapter(&adap->dvb_adap);
523 	}
524 
525 	return 0;
526 }
527 
dvb_usbv2_device_power_ctrl(struct dvb_usb_device * d,int onoff)528 static int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
529 {
530 	int ret;
531 
532 	if (onoff)
533 		d->powered++;
534 	else
535 		d->powered--;
536 
537 	if (d->powered == 0 || (onoff && d->powered == 1)) {
538 		/* when switching from 1 to 0 or from 0 to 1 */
539 		dev_dbg(&d->udev->dev, "%s: power=%d\n", __func__, onoff);
540 		if (d->props->power_ctrl) {
541 			ret = d->props->power_ctrl(d, onoff);
542 			if (ret < 0)
543 				goto err;
544 		}
545 	}
546 
547 	return 0;
548 err:
549 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
550 	return ret;
551 }
552 
dvb_usb_fe_init(struct dvb_frontend * fe)553 static int dvb_usb_fe_init(struct dvb_frontend *fe)
554 {
555 	int ret;
556 	struct dvb_usb_adapter *adap = fe->dvb->priv;
557 	struct dvb_usb_device *d = adap_to_d(adap);
558 	dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
559 			fe->id);
560 
561 	if (!adap->suspend_resume_active) {
562 		adap->active_fe = fe->id;
563 		set_bit(ADAP_INIT, &adap->state_bits);
564 	}
565 
566 	ret = dvb_usbv2_device_power_ctrl(d, 1);
567 	if (ret < 0)
568 		goto err;
569 
570 	if (d->props->frontend_ctrl) {
571 		ret = d->props->frontend_ctrl(fe, 1);
572 		if (ret < 0)
573 			goto err;
574 	}
575 
576 	if (adap->fe_init[fe->id]) {
577 		ret = adap->fe_init[fe->id](fe);
578 		if (ret < 0)
579 			goto err;
580 	}
581 err:
582 	if (!adap->suspend_resume_active) {
583 		clear_bit(ADAP_INIT, &adap->state_bits);
584 		smp_mb__after_atomic();
585 		wake_up_bit(&adap->state_bits, ADAP_INIT);
586 	}
587 
588 	dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
589 	return ret;
590 }
591 
dvb_usb_fe_sleep(struct dvb_frontend * fe)592 static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
593 {
594 	int ret;
595 	struct dvb_usb_adapter *adap = fe->dvb->priv;
596 	struct dvb_usb_device *d = adap_to_d(adap);
597 	dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
598 			fe->id);
599 
600 	if (!adap->suspend_resume_active) {
601 		set_bit(ADAP_SLEEP, &adap->state_bits);
602 		wait_on_bit(&adap->state_bits, ADAP_STREAMING,
603 				TASK_UNINTERRUPTIBLE);
604 	}
605 
606 	if (adap->fe_sleep[fe->id]) {
607 		ret = adap->fe_sleep[fe->id](fe);
608 		if (ret < 0)
609 			goto err;
610 	}
611 
612 	if (d->props->frontend_ctrl) {
613 		ret = d->props->frontend_ctrl(fe, 0);
614 		if (ret < 0)
615 			goto err;
616 	}
617 
618 	ret = dvb_usbv2_device_power_ctrl(d, 0);
619 
620 err:
621 	if (!adap->suspend_resume_active) {
622 		adap->active_fe = -1;
623 		clear_bit(ADAP_SLEEP, &adap->state_bits);
624 		smp_mb__after_atomic();
625 		wake_up_bit(&adap->state_bits, ADAP_SLEEP);
626 	}
627 
628 	dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
629 	return ret;
630 }
631 
dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter * adap)632 static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
633 {
634 	int ret, i, count_registered = 0;
635 	struct dvb_usb_device *d = adap_to_d(adap);
636 	dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
637 
638 	memset(adap->fe, 0, sizeof(adap->fe));
639 	adap->active_fe = -1;
640 
641 	if (d->props->frontend_attach) {
642 		ret = d->props->frontend_attach(adap);
643 		if (ret < 0) {
644 			dev_dbg(&d->udev->dev,
645 					"%s: frontend_attach() failed=%d\n",
646 					__func__, ret);
647 			goto err_dvb_frontend_detach;
648 		}
649 	} else {
650 		dev_dbg(&d->udev->dev, "%s: frontend_attach() do not exists\n",
651 				__func__);
652 		ret = 0;
653 		goto err;
654 	}
655 
656 	for (i = 0; i < MAX_NO_OF_FE_PER_ADAP && adap->fe[i]; i++) {
657 		adap->fe[i]->id = i;
658 		/* re-assign sleep and wakeup functions */
659 		adap->fe_init[i] = adap->fe[i]->ops.init;
660 		adap->fe[i]->ops.init = dvb_usb_fe_init;
661 		adap->fe_sleep[i] = adap->fe[i]->ops.sleep;
662 		adap->fe[i]->ops.sleep = dvb_usb_fe_sleep;
663 
664 		ret = dvb_register_frontend(&adap->dvb_adap, adap->fe[i]);
665 		if (ret < 0) {
666 			dev_err(&d->udev->dev,
667 					"%s: frontend%d registration failed\n",
668 					KBUILD_MODNAME, i);
669 			goto err_dvb_unregister_frontend;
670 		}
671 
672 		count_registered++;
673 	}
674 
675 	if (d->props->tuner_attach) {
676 		ret = d->props->tuner_attach(adap);
677 		if (ret < 0) {
678 			dev_dbg(&d->udev->dev, "%s: tuner_attach() failed=%d\n",
679 					__func__, ret);
680 			goto err_dvb_unregister_frontend;
681 		}
682 	}
683 
684 	ret = dvb_create_media_graph(&adap->dvb_adap, true);
685 	if (ret < 0)
686 		goto err_dvb_unregister_frontend;
687 
688 	ret = dvb_usbv2_media_device_register(adap);
689 
690 	return ret;
691 
692 err_dvb_unregister_frontend:
693 	for (i = count_registered - 1; i >= 0; i--)
694 		dvb_unregister_frontend(adap->fe[i]);
695 
696 err_dvb_frontend_detach:
697 	for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
698 		if (adap->fe[i]) {
699 			dvb_frontend_detach(adap->fe[i]);
700 			adap->fe[i] = NULL;
701 		}
702 	}
703 
704 err:
705 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
706 	return ret;
707 }
708 
dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter * adap)709 static int dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter *adap)
710 {
711 	int ret, i;
712 	struct dvb_usb_device *d = adap_to_d(adap);
713 
714 	dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
715 
716 	for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
717 		if (adap->fe[i]) {
718 			dvb_unregister_frontend(adap->fe[i]);
719 			dvb_frontend_detach(adap->fe[i]);
720 		}
721 	}
722 
723 	if (d->props->tuner_detach) {
724 		ret = d->props->tuner_detach(adap);
725 		if (ret < 0) {
726 			dev_dbg(&d->udev->dev, "%s: tuner_detach() failed=%d\n",
727 					__func__, ret);
728 		}
729 	}
730 
731 	if (d->props->frontend_detach) {
732 		ret = d->props->frontend_detach(adap);
733 		if (ret < 0) {
734 			dev_dbg(&d->udev->dev,
735 					"%s: frontend_detach() failed=%d\n",
736 					__func__, ret);
737 		}
738 	}
739 
740 	return 0;
741 }
742 
dvb_usbv2_adapter_init(struct dvb_usb_device * d)743 static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
744 {
745 	struct dvb_usb_adapter *adap;
746 	int ret, i, adapter_count;
747 
748 	/* resolve adapter count */
749 	adapter_count = d->props->num_adapters;
750 	if (d->props->get_adapter_count) {
751 		ret = d->props->get_adapter_count(d);
752 		if (ret < 0)
753 			goto err;
754 
755 		adapter_count = ret;
756 	}
757 
758 	for (i = 0; i < adapter_count; i++) {
759 		adap = &d->adapter[i];
760 		adap->id = i;
761 		adap->props = &d->props->adapter[i];
762 
763 		/* speed - when running at FULL speed we need a HW PID filter */
764 		if (d->udev->speed == USB_SPEED_FULL &&
765 				!(adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
766 			dev_err(&d->udev->dev,
767 					"%s: this USB2.0 device cannot be run on a USB1.1 port (it lacks a hardware PID filter)\n",
768 					KBUILD_MODNAME);
769 			ret = -ENODEV;
770 			goto err;
771 		} else if ((d->udev->speed == USB_SPEED_FULL &&
772 				adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
773 				(adap->props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
774 			dev_info(&d->udev->dev,
775 					"%s: will use the device's hardware PID filter (table count: %d)\n",
776 					KBUILD_MODNAME,
777 					adap->props->pid_filter_count);
778 			adap->pid_filtering  = 1;
779 			adap->max_feed_count = adap->props->pid_filter_count;
780 		} else {
781 			dev_info(&d->udev->dev,
782 					"%s: will pass the complete MPEG2 transport stream to the software demuxer\n",
783 					KBUILD_MODNAME);
784 			adap->pid_filtering  = 0;
785 			adap->max_feed_count = 255;
786 		}
787 
788 		if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
789 				adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
790 			dev_info(&d->udev->dev,
791 					"%s: PID filter enabled by module option\n",
792 					KBUILD_MODNAME);
793 			adap->pid_filtering  = 1;
794 			adap->max_feed_count = adap->props->pid_filter_count;
795 		}
796 
797 		ret = dvb_usbv2_adapter_stream_init(adap);
798 		if (ret)
799 			goto err;
800 
801 		ret = dvb_usbv2_adapter_dvb_init(adap);
802 		if (ret)
803 			goto err;
804 
805 		ret = dvb_usbv2_adapter_frontend_init(adap);
806 		if (ret)
807 			goto err;
808 
809 		/* use exclusive FE lock if there is multiple shared FEs */
810 		if (adap->fe[1])
811 			adap->dvb_adap.mfe_shared = 1;
812 	}
813 
814 	return 0;
815 err:
816 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
817 	return ret;
818 }
819 
dvb_usbv2_adapter_exit(struct dvb_usb_device * d)820 static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
821 {
822 	int i;
823 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
824 
825 	for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
826 		if (d->adapter[i].props) {
827 			dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
828 			dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
829 			dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
830 			dvb_usbv2_media_device_unregister(&d->adapter[i]);
831 		}
832 	}
833 
834 	return 0;
835 }
836 
837 /* general initialization functions */
dvb_usbv2_exit(struct dvb_usb_device * d)838 static int dvb_usbv2_exit(struct dvb_usb_device *d)
839 {
840 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
841 
842 	dvb_usbv2_remote_exit(d);
843 	dvb_usbv2_adapter_exit(d);
844 	dvb_usbv2_i2c_exit(d);
845 
846 	return 0;
847 }
848 
dvb_usbv2_init(struct dvb_usb_device * d)849 static int dvb_usbv2_init(struct dvb_usb_device *d)
850 {
851 	int ret;
852 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
853 
854 	dvb_usbv2_device_power_ctrl(d, 1);
855 
856 	if (d->props->read_config) {
857 		ret = d->props->read_config(d);
858 		if (ret < 0)
859 			goto err;
860 	}
861 
862 	ret = dvb_usbv2_i2c_init(d);
863 	if (ret < 0)
864 		goto err;
865 
866 	ret = dvb_usbv2_adapter_init(d);
867 	if (ret < 0)
868 		goto err;
869 
870 	if (d->props->init) {
871 		ret = d->props->init(d);
872 		if (ret < 0)
873 			goto err;
874 	}
875 
876 	ret = dvb_usbv2_remote_init(d);
877 	if (ret < 0)
878 		goto err;
879 
880 	dvb_usbv2_device_power_ctrl(d, 0);
881 
882 	return 0;
883 err:
884 	dvb_usbv2_device_power_ctrl(d, 0);
885 	dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
886 	return ret;
887 }
888 
dvb_usbv2_probe(struct usb_interface * intf,const struct usb_device_id * id)889 int dvb_usbv2_probe(struct usb_interface *intf,
890 		const struct usb_device_id *id)
891 {
892 	int ret;
893 	struct dvb_usb_device *d;
894 	struct usb_device *udev = interface_to_usbdev(intf);
895 	struct dvb_usb_driver_info *driver_info =
896 			(struct dvb_usb_driver_info *) id->driver_info;
897 
898 	dev_dbg(&udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
899 			intf->cur_altsetting->desc.bInterfaceNumber);
900 
901 	if (!id->driver_info) {
902 		dev_err(&udev->dev, "%s: driver_info failed\n", KBUILD_MODNAME);
903 		ret = -ENODEV;
904 		goto err;
905 	}
906 
907 	d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
908 	if (!d) {
909 		dev_err(&udev->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
910 		ret = -ENOMEM;
911 		goto err;
912 	}
913 
914 	d->intf = intf;
915 	d->name = driver_info->name;
916 	d->rc_map = driver_info->rc_map;
917 	d->udev = udev;
918 	d->props = driver_info->props;
919 
920 	if (intf->cur_altsetting->desc.bInterfaceNumber !=
921 			d->props->bInterfaceNumber) {
922 		ret = -ENODEV;
923 		goto err_kfree_d;
924 	}
925 
926 	mutex_init(&d->usb_mutex);
927 	mutex_init(&d->i2c_mutex);
928 
929 	if (d->props->size_of_priv) {
930 		d->priv = kzalloc(d->props->size_of_priv, GFP_KERNEL);
931 		if (!d->priv) {
932 			dev_err(&d->udev->dev, "%s: kzalloc() failed\n",
933 					KBUILD_MODNAME);
934 			ret = -ENOMEM;
935 			goto err_kfree_d;
936 		}
937 	}
938 
939 	if (d->props->probe) {
940 		ret = d->props->probe(d);
941 		if (ret)
942 			goto err_kfree_priv;
943 	}
944 
945 	if (d->props->identify_state) {
946 		const char *name = NULL;
947 		ret = d->props->identify_state(d, &name);
948 		if (ret == COLD) {
949 			dev_info(&d->udev->dev,
950 					"%s: found a '%s' in cold state\n",
951 					KBUILD_MODNAME, d->name);
952 
953 			if (!name)
954 				name = d->props->firmware;
955 
956 			ret = dvb_usbv2_download_firmware(d, name);
957 			if (ret == 0) {
958 				/* device is warm, continue initialization */
959 				;
960 			} else if (ret == RECONNECTS_USB) {
961 				/*
962 				 * USB core will call disconnect() and then
963 				 * probe() as device reconnects itself from the
964 				 * USB bus. disconnect() will release all driver
965 				 * resources and probe() is called for 'new'
966 				 * device. As 'new' device is warm we should
967 				 * never go here again.
968 				 */
969 				goto exit;
970 			} else {
971 				goto err_free_all;
972 			}
973 		} else if (ret != WARM) {
974 			goto err_free_all;
975 		}
976 	}
977 
978 	dev_info(&d->udev->dev, "%s: found a '%s' in warm state\n",
979 			KBUILD_MODNAME, d->name);
980 
981 	ret = dvb_usbv2_init(d);
982 	if (ret < 0)
983 		goto err_free_all;
984 
985 	dev_info(&d->udev->dev,
986 			"%s: '%s' successfully initialized and connected\n",
987 			KBUILD_MODNAME, d->name);
988 exit:
989 	usb_set_intfdata(intf, d);
990 
991 	return 0;
992 err_free_all:
993 	dvb_usbv2_exit(d);
994 	if (d->props->disconnect)
995 		d->props->disconnect(d);
996 err_kfree_priv:
997 	kfree(d->priv);
998 err_kfree_d:
999 	kfree(d);
1000 err:
1001 	dev_dbg(&udev->dev, "%s: failed=%d\n", __func__, ret);
1002 	return ret;
1003 }
1004 EXPORT_SYMBOL(dvb_usbv2_probe);
1005 
dvb_usbv2_disconnect(struct usb_interface * intf)1006 void dvb_usbv2_disconnect(struct usb_interface *intf)
1007 {
1008 	struct dvb_usb_device *d = usb_get_intfdata(intf);
1009 	const char *devname = kstrdup(dev_name(&d->udev->dev), GFP_KERNEL);
1010 	const char *drvname = d->name;
1011 
1012 	dev_dbg(&d->udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
1013 			intf->cur_altsetting->desc.bInterfaceNumber);
1014 
1015 	if (d->props->exit)
1016 		d->props->exit(d);
1017 
1018 	dvb_usbv2_exit(d);
1019 
1020 	if (d->props->disconnect)
1021 		d->props->disconnect(d);
1022 
1023 	kfree(d->priv);
1024 	kfree(d);
1025 
1026 	pr_info("%s: '%s:%s' successfully deinitialized and disconnected\n",
1027 		KBUILD_MODNAME, drvname, devname);
1028 	kfree(devname);
1029 }
1030 EXPORT_SYMBOL(dvb_usbv2_disconnect);
1031 
dvb_usbv2_suspend(struct usb_interface * intf,pm_message_t msg)1032 int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
1033 {
1034 	struct dvb_usb_device *d = usb_get_intfdata(intf);
1035 	int ret = 0, i, active_fe;
1036 	struct dvb_frontend *fe;
1037 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
1038 
1039 	/* stop remote controller poll */
1040 	if (d->rc_polling_active)
1041 		cancel_delayed_work_sync(&d->rc_query_work);
1042 
1043 	for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
1044 		active_fe = d->adapter[i].active_fe;
1045 		if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1046 			fe = d->adapter[i].fe[active_fe];
1047 			d->adapter[i].suspend_resume_active = true;
1048 
1049 			if (d->props->streaming_ctrl)
1050 				d->props->streaming_ctrl(fe, 0);
1051 
1052 			/* stop usb streaming */
1053 			usb_urb_killv2(&d->adapter[i].stream);
1054 
1055 			ret = dvb_frontend_suspend(fe);
1056 		}
1057 	}
1058 
1059 	return ret;
1060 }
1061 EXPORT_SYMBOL(dvb_usbv2_suspend);
1062 
dvb_usbv2_resume_common(struct dvb_usb_device * d)1063 static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
1064 {
1065 	int ret = 0, i, active_fe;
1066 	struct dvb_frontend *fe;
1067 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
1068 
1069 	for (i = 0; i < MAX_NO_OF_ADAPTER_PER_DEVICE; i++) {
1070 		active_fe = d->adapter[i].active_fe;
1071 		if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1072 			fe = d->adapter[i].fe[active_fe];
1073 
1074 			ret = dvb_frontend_resume(fe);
1075 
1076 			/* resume usb streaming */
1077 			usb_urb_submitv2(&d->adapter[i].stream, NULL);
1078 
1079 			if (d->props->streaming_ctrl)
1080 				d->props->streaming_ctrl(fe, 1);
1081 
1082 			d->adapter[i].suspend_resume_active = false;
1083 		}
1084 	}
1085 
1086 	/* start remote controller poll */
1087 	if (d->rc_polling_active)
1088 		schedule_delayed_work(&d->rc_query_work,
1089 				msecs_to_jiffies(d->rc.interval));
1090 
1091 	return ret;
1092 }
1093 
dvb_usbv2_resume(struct usb_interface * intf)1094 int dvb_usbv2_resume(struct usb_interface *intf)
1095 {
1096 	struct dvb_usb_device *d = usb_get_intfdata(intf);
1097 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
1098 
1099 	return dvb_usbv2_resume_common(d);
1100 }
1101 EXPORT_SYMBOL(dvb_usbv2_resume);
1102 
dvb_usbv2_reset_resume(struct usb_interface * intf)1103 int dvb_usbv2_reset_resume(struct usb_interface *intf)
1104 {
1105 	struct dvb_usb_device *d = usb_get_intfdata(intf);
1106 	int ret;
1107 	dev_dbg(&d->udev->dev, "%s:\n", __func__);
1108 
1109 	dvb_usbv2_device_power_ctrl(d, 1);
1110 
1111 	if (d->props->init)
1112 		d->props->init(d);
1113 
1114 	ret = dvb_usbv2_resume_common(d);
1115 
1116 	dvb_usbv2_device_power_ctrl(d, 0);
1117 
1118 	return ret;
1119 }
1120 EXPORT_SYMBOL(dvb_usbv2_reset_resume);
1121 
1122 MODULE_VERSION("2.0");
1123 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
1124 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1125 MODULE_DESCRIPTION("DVB USB common");
1126 MODULE_LICENSE("GPL");
1127