Commit | Line | Data |
---|---|---|
c79b339f AP |
1 | /* |
2 | * DVB USB library - provides a generic interface for a DVB USB device driver. | |
3 | * | |
4 | * dvb-usb-init.c | |
5 | * | |
6 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
4e60d951 AP |
9 | * under the terms of the GNU General Public License as published by the |
10 | * Free Software Foundation, version 2. | |
c79b339f AP |
11 | * |
12 | * see Documentation/dvb/README.dvb-usb for more information | |
13 | */ | |
14 | #include "dvb_usb_common.h" | |
15 | ||
c79b339f AP |
16 | int dvb_usb_disable_rc_polling; |
17 | module_param_named(disable_rc_polling, dvb_usb_disable_rc_polling, int, 0644); | |
4e60d951 AP |
18 | MODULE_PARM_DESC(disable_rc_polling, |
19 | "disable remote control polling (default: 0)."); | |
c79b339f AP |
20 | |
21 | static int dvb_usb_force_pid_filter_usage; | |
4e60d951 AP |
22 | module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage, |
23 | int, 0444); | |
24 | MODULE_PARM_DESC(force_pid_filter_usage, "force all dvb-usb-devices to use a" \ | |
25 | " PID filter, if any (default: 0)."); | |
c79b339f | 26 | |
a0d72d24 AP |
27 | int dvb_usb_download_firmware(struct dvb_usb_device *d) |
28 | { | |
29 | int ret; | |
30 | const struct firmware *fw = NULL; | |
31 | const char *name; | |
32 | ||
33 | /* resolve firmware name */ | |
34 | name = d->props.firmware; | |
35 | if (d->props.get_firmware_name) { | |
36 | ret = d->props.get_firmware_name(d, &name); | |
37 | if (ret < 0) | |
38 | return ret; | |
39 | } | |
40 | ||
41 | if (!d->props.download_firmware) { | |
42 | ret = -EINVAL; | |
43 | goto err; | |
44 | } | |
45 | ||
46 | ret = request_firmware(&fw, name, &d->udev->dev); | |
47 | if (ret < 0) { | |
23d8e63a AP |
48 | pr_err("%s: did not find the firmware file. (%s) " \ |
49 | "Please see linux/Documentation/dvb/ for " \ | |
50 | "more details on firmware-problems. (%d)", | |
51 | KBUILD_MODNAME, name, ret); | |
a0d72d24 AP |
52 | goto err; |
53 | } | |
54 | ||
23d8e63a AP |
55 | pr_info("%s: downloading firmware from file '%s'", KBUILD_MODNAME, |
56 | name); | |
a0d72d24 AP |
57 | |
58 | ret = d->props.download_firmware(d, fw); | |
59 | ||
60 | release_firmware(fw); | |
61 | ||
62 | if (ret < 0) | |
63 | goto err; | |
64 | ||
65 | return 0; | |
66 | err: | |
67 | pr_debug("%s: failed=%d\n", __func__, ret); | |
68 | return ret; | |
69 | } | |
70 | ||
a177c72b AP |
71 | int dvb_usb_i2c_init(struct dvb_usb_device *d) |
72 | { | |
73 | int ret = 0; | |
74 | ||
75 | if (!d->props.i2c_algo) | |
76 | return 0; | |
77 | ||
78 | strlcpy(d->i2c_adap.name, d->name, sizeof(d->i2c_adap.name)); | |
79 | d->i2c_adap.algo = d->props.i2c_algo; | |
80 | d->i2c_adap.algo_data = NULL; | |
81 | d->i2c_adap.dev.parent = &d->udev->dev; | |
82 | ||
83 | i2c_set_adapdata(&d->i2c_adap, d); | |
84 | ||
85 | ret = i2c_add_adapter(&d->i2c_adap); | |
86 | if (ret < 0) | |
87 | pr_err("%s: could not add i2c adapter", KBUILD_MODNAME); | |
88 | ||
89 | d->state |= DVB_USB_STATE_I2C; | |
90 | ||
91 | return ret; | |
92 | } | |
93 | ||
94 | int dvb_usb_i2c_exit(struct dvb_usb_device *d) | |
95 | { | |
96 | if (d->state & DVB_USB_STATE_I2C) | |
97 | i2c_del_adapter(&d->i2c_adap); | |
98 | d->state &= ~DVB_USB_STATE_I2C; | |
99 | return 0; | |
100 | } | |
101 | ||
55b1f704 | 102 | static int dvb_usb_adapter_init(struct dvb_usb_device *d) |
c79b339f AP |
103 | { |
104 | struct dvb_usb_adapter *adap; | |
e46c5b66 | 105 | int ret, n, adapter_count; |
c79b339f | 106 | |
5b853004 AP |
107 | /* resolve adapter count */ |
108 | adapter_count = d->props.num_adapters; | |
109 | if (d->props.get_adapter_count) { | |
110 | ret = d->props.get_adapter_count(d); | |
111 | if (ret < 0) | |
112 | goto err; | |
113 | ||
114 | adapter_count = ret; | |
115 | } | |
116 | ||
117 | for (n = 0; n < adapter_count; n++) { | |
c79b339f AP |
118 | adap = &d->adapter[n]; |
119 | adap->dev = d; | |
120 | adap->id = n; | |
121 | ||
4e60d951 AP |
122 | memcpy(&adap->props, &d->props.adapter[n], |
123 | sizeof(struct dvb_usb_adapter_properties)); | |
124 | ||
e46c5b66 AP |
125 | /* speed - when running at FULL speed we need a HW PID filter */ |
126 | if (d->udev->speed == USB_SPEED_FULL && | |
127 | !(adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER)) { | |
23d8e63a AP |
128 | pr_err("%s: this USB2.0 device cannot be run on a " \ |
129 | "USB1.1 port (it lacks a hardware " \ | |
130 | "PID filter)", KBUILD_MODNAME); | |
e46c5b66 AP |
131 | return -ENODEV; |
132 | } else if ((d->udev->speed == USB_SPEED_FULL && | |
133 | adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) || | |
134 | (adap->props.caps & DVB_USB_ADAP_NEED_PID_FILTERING)) { | |
23d8e63a AP |
135 | pr_info("%s: will use the device's hardware PID " \ |
136 | "filter (table count: %d)", | |
137 | KBUILD_MODNAME, | |
138 | adap->props.pid_filter_count); | |
e46c5b66 AP |
139 | adap->pid_filtering = 1; |
140 | adap->max_feed_count = adap->props.pid_filter_count; | |
141 | } else { | |
23d8e63a AP |
142 | pr_info("%s: will pass the complete MPEG2 transport " \ |
143 | "stream to the software demuxer", | |
144 | KBUILD_MODNAME); | |
e46c5b66 AP |
145 | adap->pid_filtering = 0; |
146 | adap->max_feed_count = 255; | |
147 | } | |
c79b339f | 148 | |
e46c5b66 AP |
149 | if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage && |
150 | adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) { | |
23d8e63a AP |
151 | pr_info("%s: pid filter enabled by module option", |
152 | KBUILD_MODNAME); | |
e46c5b66 AP |
153 | adap->pid_filtering = 1; |
154 | adap->max_feed_count = adap->props.pid_filter_count; | |
c79b339f | 155 | } |
c79b339f | 156 | |
4e60d951 AP |
157 | ret = dvb_usb_adapter_stream_init(adap); |
158 | if (ret) | |
159 | return ret; | |
160 | ||
161 | ret = dvb_usb_adapter_dvb_init(adap); | |
162 | if (ret) | |
163 | return ret; | |
164 | ||
165 | ret = dvb_usb_adapter_frontend_init(adap); | |
166 | if (ret) | |
c79b339f | 167 | return ret; |
c79b339f AP |
168 | |
169 | /* use exclusive FE lock if there is multiple shared FEs */ | |
20bb9cc4 | 170 | if (adap->fe[1]) |
c79b339f AP |
171 | adap->dvb_adap.mfe_shared = 1; |
172 | ||
173 | d->num_adapters_initialized++; | |
174 | d->state |= DVB_USB_STATE_DVB; | |
175 | } | |
176 | ||
c79b339f | 177 | return 0; |
5b853004 AP |
178 | err: |
179 | pr_debug("%s: failed=%d\n", __func__, ret); | |
180 | return ret; | |
c79b339f AP |
181 | } |
182 | ||
183 | static int dvb_usb_adapter_exit(struct dvb_usb_device *d) | |
184 | { | |
185 | int n; | |
186 | ||
187 | for (n = 0; n < d->num_adapters_initialized; n++) { | |
188 | dvb_usb_adapter_frontend_exit(&d->adapter[n]); | |
189 | dvb_usb_adapter_dvb_exit(&d->adapter[n]); | |
190 | dvb_usb_adapter_stream_exit(&d->adapter[n]); | |
e80e9af3 | 191 | |
c79b339f AP |
192 | } |
193 | d->num_adapters_initialized = 0; | |
194 | d->state &= ~DVB_USB_STATE_DVB; | |
195 | return 0; | |
196 | } | |
197 | ||
c79b339f AP |
198 | /* general initialization functions */ |
199 | static int dvb_usb_exit(struct dvb_usb_device *d) | |
200 | { | |
19ec2728 | 201 | pr_debug("%s: state before exiting everything: %x\n", __func__, d->state); |
c79b339f AP |
202 | dvb_usb_remote_exit(d); |
203 | dvb_usb_adapter_exit(d); | |
204 | dvb_usb_i2c_exit(d); | |
19ec2728 | 205 | pr_debug("%s: state should be zero now: %x\n", __func__, d->state); |
c79b339f AP |
206 | d->state = DVB_USB_STATE_INIT; |
207 | kfree(d->priv); | |
208 | kfree(d); | |
209 | return 0; | |
210 | } | |
211 | ||
55b1f704 | 212 | static int dvb_usb_init(struct dvb_usb_device *d) |
c79b339f AP |
213 | { |
214 | int ret = 0; | |
215 | ||
c79b339f AP |
216 | d->state = DVB_USB_STATE_INIT; |
217 | ||
c79b339f AP |
218 | /* check the capabilities and set appropriate variables */ |
219 | dvb_usb_device_power_ctrl(d, 1); | |
220 | ||
43402bbd AP |
221 | /* read config */ |
222 | if (d->props.read_config) { | |
223 | ret = d->props.read_config(d); | |
224 | if (ret < 0) | |
225 | goto err; | |
226 | } | |
227 | ||
4e60d951 AP |
228 | ret = dvb_usb_i2c_init(d); |
229 | if (ret == 0) | |
230 | ret = dvb_usb_adapter_init(d); | |
231 | ||
232 | if (ret) { | |
c79b339f AP |
233 | dvb_usb_exit(d); |
234 | return ret; | |
235 | } | |
236 | ||
dc786937 AP |
237 | if (d->props.init) |
238 | d->props.init(d); | |
239 | ||
4e60d951 AP |
240 | ret = dvb_usb_remote_init(d); |
241 | if (ret) | |
23d8e63a AP |
242 | pr_err("%s: could not initialize remote control\n", |
243 | KBUILD_MODNAME); | |
c79b339f AP |
244 | |
245 | dvb_usb_device_power_ctrl(d, 0); | |
246 | ||
247 | return 0; | |
43402bbd AP |
248 | err: |
249 | pr_debug("%s: failed=%d\n", __func__, ret); | |
250 | return ret; | |
c79b339f AP |
251 | } |
252 | ||
c79b339f AP |
253 | int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff) |
254 | { | |
255 | if (onoff) | |
256 | d->powered++; | |
257 | else | |
258 | d->powered--; | |
259 | ||
4e60d951 AP |
260 | if (d->powered == 0 || (onoff && d->powered == 1)) { |
261 | /* when switching from 1 to 0 or from 0 to 1 */ | |
19ec2728 | 262 | pr_debug("%s: power control: %d\n", __func__, onoff); |
c79b339f AP |
263 | if (d->props.power_ctrl) |
264 | return d->props.power_ctrl(d, onoff); | |
265 | } | |
266 | return 0; | |
267 | } | |
268 | ||
269 | /* | |
270 | * USB | |
271 | */ | |
0a867356 | 272 | |
4f208d4e AP |
273 | /* |
274 | * udev, which is used for the firmware downloading, requires we cannot | |
275 | * block during module_init(). module_init() calls USB probe() which | |
276 | * is this routine. Due to that we delay actual operation using workqueue | |
277 | * and return always success here. | |
278 | */ | |
0a867356 | 279 | |
4f208d4e AP |
280 | static void dvb_usbv2_init_work(struct work_struct *work) |
281 | { | |
282 | int ret; | |
283 | struct dvb_usb_device *d = | |
284 | container_of(work, struct dvb_usb_device, probe_work); | |
285 | bool cold = false; | |
496e8278 | 286 | |
4f208d4e | 287 | pr_debug("%s:\n", __func__); |
c79b339f | 288 | |
4f208d4e | 289 | if (d->props.size_of_priv) { |
496e8278 | 290 | d->priv = kzalloc(d->props.size_of_priv, GFP_KERNEL); |
4f208d4e AP |
291 | if (!d->priv) { |
292 | pr_err("%s: kzalloc() failed\n", KBUILD_MODNAME); | |
496e8278 | 293 | ret = -ENOMEM; |
4f208d4e | 294 | goto err_usb_driver_release_interface; |
496e8278 AP |
295 | } |
296 | } | |
c79b339f | 297 | |
496e8278 AP |
298 | if (d->props.identify_state) { |
299 | ret = d->props.identify_state(d); | |
300 | if (ret == 0) { | |
301 | ; | |
302 | } else if (ret == COLD) { | |
303 | cold = true; | |
304 | ret = 0; | |
305 | } else { | |
4f208d4e | 306 | goto err_usb_driver_release_interface; |
496e8278 | 307 | } |
c79b339f AP |
308 | } |
309 | ||
310 | if (cold) { | |
4f208d4e AP |
311 | pr_info("%s: found a '%s' in cold state\n", |
312 | KBUILD_MODNAME, d->name); | |
496e8278 AP |
313 | ret = dvb_usb_download_firmware(d); |
314 | if (ret == 0) { | |
315 | ; | |
316 | } else if (ret == RECONNECTS_USB) { | |
317 | ret = 0; | |
4f208d4e | 318 | goto exit_usb_driver_release_interface; |
496e8278 | 319 | } else { |
4f208d4e | 320 | goto err_usb_driver_release_interface; |
496e8278 | 321 | } |
c79b339f AP |
322 | } |
323 | ||
4f208d4e | 324 | pr_info("%s: found a '%s' in warm state\n", KBUILD_MODNAME, d->name); |
c79b339f | 325 | |
55b1f704 | 326 | ret = dvb_usb_init(d); |
4f208d4e AP |
327 | if (ret < 0) |
328 | goto err_usb_driver_release_interface; | |
c79b339f | 329 | |
4f208d4e AP |
330 | pr_info("%s: '%s' successfully initialized and connected\n", |
331 | KBUILD_MODNAME, d->name); | |
21f5a32e AP |
332 | |
333 | return; | |
4f208d4e AP |
334 | err_usb_driver_release_interface: |
335 | pr_info("%s: '%s' error while loading driver (%d)\n", KBUILD_MODNAME, | |
336 | d->name, ret); | |
337 | exit_usb_driver_release_interface: | |
338 | /* it finally calls .disconnect() which frees mem */ | |
339 | usb_driver_release_interface(to_usb_driver(d->intf->dev.driver), | |
340 | d->intf); | |
21f5a32e AP |
341 | pr_debug("%s: failed=%d\n", __func__, ret); |
342 | return; | |
343 | } | |
344 | ||
6b8c8c40 | 345 | int dvb_usbv2_probe(struct usb_interface *intf, |
21f5a32e AP |
346 | const struct usb_device_id *id) |
347 | { | |
348 | int ret; | |
4f208d4e AP |
349 | struct dvb_usb_device *d; |
350 | struct dvb_usb_driver_info *driver_info = | |
351 | (struct dvb_usb_driver_info *) id->driver_info; | |
21f5a32e | 352 | |
36764037 AP |
353 | pr_debug("%s: bInterfaceNumber=%d\n", __func__, |
354 | intf->cur_altsetting->desc.bInterfaceNumber); | |
4f208d4e AP |
355 | |
356 | if (!id->driver_info) { | |
357 | pr_err("%s: driver_info failed\n", KBUILD_MODNAME); | |
358 | ret = -ENODEV; | |
21f5a32e AP |
359 | goto err; |
360 | } | |
361 | ||
4f208d4e AP |
362 | d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL); |
363 | if (!d) { | |
364 | pr_err("%s: kzalloc() failed\n", KBUILD_MODNAME); | |
365 | ret = -ENOMEM; | |
366 | goto err; | |
367 | } | |
21f5a32e | 368 | |
4f208d4e AP |
369 | d->name = driver_info->name; |
370 | d->rc_map = driver_info->rc_map; | |
371 | d->udev = interface_to_usbdev(intf); | |
372 | d->intf = intf; | |
373 | memcpy(&d->props, driver_info->props, | |
374 | sizeof(struct dvb_usb_device_properties)); | |
36764037 AP |
375 | |
376 | if (d->intf->cur_altsetting->desc.bInterfaceNumber != | |
377 | d->props.bInterfaceNumber) { | |
378 | ret = 0; | |
379 | goto exit_kfree; | |
380 | } | |
381 | ||
4f208d4e AP |
382 | mutex_init(&d->usb_mutex); |
383 | mutex_init(&d->i2c_mutex); | |
384 | INIT_WORK(&d->probe_work, dvb_usbv2_init_work); | |
385 | usb_set_intfdata(intf, d); | |
386 | ret = schedule_work(&d->probe_work); | |
21f5a32e | 387 | if (ret < 0) { |
4f208d4e | 388 | pr_err("%s: schedule_work() failed\n", KBUILD_MODNAME); |
21f5a32e AP |
389 | goto err_kfree; |
390 | } | |
391 | ||
392 | return 0; | |
393 | err_kfree: | |
4f208d4e | 394 | usb_set_intfdata(intf, NULL); |
36764037 | 395 | exit_kfree: |
4f208d4e | 396 | kfree(d); |
21f5a32e AP |
397 | err: |
398 | pr_debug("%s: failed=%d\n", __func__, ret); | |
399 | return ret; | |
400 | } | |
6b8c8c40 | 401 | EXPORT_SYMBOL(dvb_usbv2_probe); |
21f5a32e | 402 | |
6b8c8c40 | 403 | void dvb_usbv2_disconnect(struct usb_interface *intf) |
c79b339f AP |
404 | { |
405 | struct dvb_usb_device *d = usb_get_intfdata(intf); | |
21f5a32e AP |
406 | const char *name = "generic DVB-USB module"; |
407 | ||
4f208d4e AP |
408 | pr_debug("%s:\n", __func__); |
409 | ||
21f5a32e | 410 | /* |
4f208d4e AP |
411 | * FIXME: We should ensure initialization work is finished |
412 | * until exit from this routine (cancel_work_sync / flush_work). | |
413 | * Unfortunately usb_driver_release_interface() call finally goes | |
414 | * here too and in that case we endup deadlock. How to perform | |
415 | * operation conditionally only on disconned / unload? | |
21f5a32e | 416 | */ |
c79b339f AP |
417 | |
418 | usb_set_intfdata(intf, NULL); | |
7dfd1242 AP |
419 | if (d) { |
420 | name = d->name; | |
c79b339f AP |
421 | dvb_usb_exit(d); |
422 | } | |
4f208d4e AP |
423 | |
424 | pr_info("%s: '%s' successfully deinitialized and disconnected\n", | |
425 | KBUILD_MODNAME, name); | |
c79b339f | 426 | } |
6b8c8c40 | 427 | EXPORT_SYMBOL(dvb_usbv2_disconnect); |
c79b339f AP |
428 | |
429 | MODULE_VERSION("1.0"); | |
430 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | |
431 | MODULE_DESCRIPTION("A library module containing commonly used USB and DVB function USB DVB devices"); | |
432 | MODULE_LICENSE("GPL"); |