Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
96de0e25 | 2 | * TerraTec Cinergy T²/qanu USB2 DVB-T adapter. |
1da177e4 LT |
3 | * |
4 | * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and | |
5 | * Holger Waechtler <holger@qanu.de> | |
6 | * | |
7 | * Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
22 | * | |
23 | */ | |
24 | ||
1da177e4 LT |
25 | #include <linux/init.h> |
26 | #include <linux/module.h> | |
1da177e4 LT |
27 | #include <linux/slab.h> |
28 | #include <linux/usb.h> | |
1da177e4 LT |
29 | #include <linux/input.h> |
30 | #include <linux/dvb/frontend.h> | |
3593cab5 | 31 | #include <linux/mutex.h> |
f23f6e08 | 32 | #include <linux/mm.h> |
6473d160 | 33 | #include <asm/io.h> |
1da177e4 LT |
34 | |
35 | #include "dmxdev.h" | |
36 | #include "dvb_demux.h" | |
37 | #include "dvb_net.h" | |
38 | ||
1da177e4 LT |
39 | #ifdef CONFIG_DVB_CINERGYT2_TUNING |
40 | #define STREAM_URB_COUNT (CONFIG_DVB_CINERGYT2_STREAM_URB_COUNT) | |
41 | #define STREAM_BUF_SIZE (CONFIG_DVB_CINERGYT2_STREAM_BUF_SIZE) | |
42 | #define QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_QUERY_INTERVAL) | |
43 | #ifdef CONFIG_DVB_CINERGYT2_ENABLE_RC_INPUT_DEVICE | |
44 | #define RC_QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_RC_QUERY_INTERVAL) | |
45 | #define ENABLE_RC (1) | |
46 | #endif | |
47 | #else | |
48 | #define STREAM_URB_COUNT (32) | |
49 | #define STREAM_BUF_SIZE (512) /* bytes */ | |
50 | #define ENABLE_RC (1) | |
6d78933c | 51 | #define RC_QUERY_INTERVAL (50) /* milliseconds */ |
1da177e4 LT |
52 | #define QUERY_INTERVAL (333) /* milliseconds */ |
53 | #endif | |
54 | ||
55 | #define DRIVER_NAME "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver" | |
56 | ||
57 | static int debug; | |
58 | module_param_named(debug, debug, int, 0644); | |
59 | MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); | |
60 | ||
78e92006 JG |
61 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
62 | ||
1da177e4 LT |
63 | #define dprintk(level, args...) \ |
64 | do { \ | |
65 | if ((debug & level)) { \ | |
367cb704 | 66 | printk("%s: %s(): ", KBUILD_MODNAME, \ |
0592e8d3 | 67 | __func__); \ |
1da177e4 LT |
68 | printk(args); } \ |
69 | } while (0) | |
70 | ||
71 | enum cinergyt2_ep1_cmd { | |
72 | CINERGYT2_EP1_PID_TABLE_RESET = 0x01, | |
73 | CINERGYT2_EP1_PID_SETUP = 0x02, | |
74 | CINERGYT2_EP1_CONTROL_STREAM_TRANSFER = 0x03, | |
75 | CINERGYT2_EP1_SET_TUNER_PARAMETERS = 0x04, | |
76 | CINERGYT2_EP1_GET_TUNER_STATUS = 0x05, | |
77 | CINERGYT2_EP1_START_SCAN = 0x06, | |
78 | CINERGYT2_EP1_CONTINUE_SCAN = 0x07, | |
79 | CINERGYT2_EP1_GET_RC_EVENTS = 0x08, | |
80 | CINERGYT2_EP1_SLEEP_MODE = 0x09 | |
81 | }; | |
82 | ||
83 | struct dvbt_set_parameters_msg { | |
84 | uint8_t cmd; | |
f34ec12a | 85 | __le32 freq; |
1da177e4 | 86 | uint8_t bandwidth; |
f34ec12a | 87 | __le16 tps; |
1da177e4 LT |
88 | uint8_t flags; |
89 | } __attribute__((packed)); | |
90 | ||
91 | struct dvbt_get_status_msg { | |
f34ec12a | 92 | __le32 freq; |
1da177e4 | 93 | uint8_t bandwidth; |
f34ec12a | 94 | __le16 tps; |
1da177e4 | 95 | uint8_t flags; |
f34ec12a | 96 | __le16 gain; |
1da177e4 | 97 | uint8_t snr; |
f34ec12a AV |
98 | __le32 viterbi_error_rate; |
99 | __le32 rs_error_rate; | |
100 | __le32 uncorrected_block_count; | |
1da177e4 LT |
101 | uint8_t lock_bits; |
102 | uint8_t prev_lock_bits; | |
103 | } __attribute__((packed)); | |
104 | ||
105 | static struct dvb_frontend_info cinergyt2_fe_info = { | |
106 | .name = DRIVER_NAME, | |
107 | .type = FE_OFDM, | |
108 | .frequency_min = 174000000, | |
109 | .frequency_max = 862000000, | |
110 | .frequency_stepsize = 166667, | |
111 | .caps = FE_CAN_INVERSION_AUTO | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | | |
112 | FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | | |
113 | FE_CAN_FEC_AUTO | | |
114 | FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO | | |
115 | FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | | |
116 | FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER | FE_CAN_MUTE_TS | |
117 | }; | |
118 | ||
119 | struct cinergyt2 { | |
120 | struct dvb_demux demux; | |
121 | struct usb_device *udev; | |
3593cab5 | 122 | struct mutex sem; |
1e4597e8 | 123 | struct mutex wq_sem; |
fdc53a6d | 124 | struct dvb_adapter adapter; |
1da177e4 LT |
125 | struct dvb_device *fedev; |
126 | struct dmxdev dmxdev; | |
127 | struct dvb_net dvbnet; | |
128 | ||
129 | int streaming; | |
130 | int sleeping; | |
131 | ||
132 | struct dvbt_set_parameters_msg param; | |
133 | struct dvbt_get_status_msg status; | |
c4028958 | 134 | struct delayed_work query_work; |
1da177e4 LT |
135 | |
136 | wait_queue_head_t poll_wq; | |
137 | int pending_fe_events; | |
e4acba3c | 138 | int disconnect_pending; |
f34ec12a | 139 | unsigned int uncorrected_block_count; |
e4acba3c | 140 | atomic_t inuse; |
1da177e4 LT |
141 | |
142 | void *streambuf; | |
143 | dma_addr_t streambuf_dmahandle; | |
144 | struct urb *stream_urb [STREAM_URB_COUNT]; | |
145 | ||
146 | #ifdef ENABLE_RC | |
b7df3910 DT |
147 | struct input_dev *rc_input_dev; |
148 | char phys[64]; | |
c4028958 | 149 | struct delayed_work rc_query_work; |
1da177e4 | 150 | int rc_input_event; |
f34ec12a | 151 | __le32 rc_last_code; |
6d78933c | 152 | unsigned long last_event_jiffies; |
1da177e4 LT |
153 | #endif |
154 | }; | |
155 | ||
156 | enum { | |
157 | CINERGYT2_RC_EVENT_TYPE_NONE = 0x00, | |
158 | CINERGYT2_RC_EVENT_TYPE_NEC = 0x01, | |
159 | CINERGYT2_RC_EVENT_TYPE_RC5 = 0x02 | |
160 | }; | |
161 | ||
162 | struct cinergyt2_rc_event { | |
163 | char type; | |
f34ec12a | 164 | __le32 value; |
1da177e4 LT |
165 | } __attribute__((packed)); |
166 | ||
6d78933c | 167 | static const uint32_t rc_keys[] = { |
1da177e4 LT |
168 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xfe01eb04, KEY_POWER, |
169 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xfd02eb04, KEY_1, | |
170 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xfc03eb04, KEY_2, | |
171 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xfb04eb04, KEY_3, | |
172 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xfa05eb04, KEY_4, | |
173 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf906eb04, KEY_5, | |
174 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf807eb04, KEY_6, | |
175 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf708eb04, KEY_7, | |
176 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf609eb04, KEY_8, | |
177 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf50aeb04, KEY_9, | |
178 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf30ceb04, KEY_0, | |
179 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf40beb04, KEY_VIDEO, | |
180 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf20deb04, KEY_REFRESH, | |
181 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf10eeb04, KEY_SELECT, | |
182 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xf00feb04, KEY_EPG, | |
183 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xef10eb04, KEY_UP, | |
184 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xeb14eb04, KEY_DOWN, | |
185 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xee11eb04, KEY_LEFT, | |
186 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xec13eb04, KEY_RIGHT, | |
187 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xed12eb04, KEY_OK, | |
188 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xea15eb04, KEY_TEXT, | |
189 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe916eb04, KEY_INFO, | |
190 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe817eb04, KEY_RED, | |
191 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe718eb04, KEY_GREEN, | |
192 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe619eb04, KEY_YELLOW, | |
193 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe51aeb04, KEY_BLUE, | |
194 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe31ceb04, KEY_VOLUMEUP, | |
195 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe11eeb04, KEY_VOLUMEDOWN, | |
196 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe21deb04, KEY_MUTE, | |
197 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe41beb04, KEY_CHANNELUP, | |
198 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xe01feb04, KEY_CHANNELDOWN, | |
199 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xbf40eb04, KEY_PAUSE, | |
200 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xb34ceb04, KEY_PLAY, | |
201 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xa758eb04, KEY_RECORD, | |
202 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xab54eb04, KEY_PREVIOUS, | |
203 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xb748eb04, KEY_STOP, | |
204 | CINERGYT2_RC_EVENT_TYPE_NEC, 0xa35ceb04, KEY_NEXT | |
205 | }; | |
206 | ||
207 | static int cinergyt2_command (struct cinergyt2 *cinergyt2, | |
208 | char *send_buf, int send_buf_len, | |
209 | char *recv_buf, int recv_buf_len) | |
210 | { | |
211 | int actual_len; | |
212 | char dummy; | |
213 | int ret; | |
214 | ||
215 | ret = usb_bulk_msg(cinergyt2->udev, usb_sndbulkpipe(cinergyt2->udev, 1), | |
216 | send_buf, send_buf_len, &actual_len, 1000); | |
217 | ||
218 | if (ret) | |
219 | dprintk(1, "usb_bulk_msg (send) failed, err %i\n", ret); | |
220 | ||
221 | if (!recv_buf) | |
222 | recv_buf = &dummy; | |
223 | ||
224 | ret = usb_bulk_msg(cinergyt2->udev, usb_rcvbulkpipe(cinergyt2->udev, 1), | |
225 | recv_buf, recv_buf_len, &actual_len, 1000); | |
226 | ||
227 | if (ret) | |
228 | dprintk(1, "usb_bulk_msg (read) failed, err %i\n", ret); | |
229 | ||
230 | return ret ? ret : actual_len; | |
231 | } | |
232 | ||
233 | static void cinergyt2_control_stream_transfer (struct cinergyt2 *cinergyt2, int enable) | |
234 | { | |
235 | char buf [] = { CINERGYT2_EP1_CONTROL_STREAM_TRANSFER, enable ? 1 : 0 }; | |
236 | cinergyt2_command(cinergyt2, buf, sizeof(buf), NULL, 0); | |
237 | } | |
238 | ||
239 | static void cinergyt2_sleep (struct cinergyt2 *cinergyt2, int sleep) | |
240 | { | |
241 | char buf [] = { CINERGYT2_EP1_SLEEP_MODE, sleep ? 1 : 0 }; | |
242 | cinergyt2_command(cinergyt2, buf, sizeof(buf), NULL, 0); | |
243 | cinergyt2->sleeping = sleep; | |
244 | } | |
245 | ||
7d12e780 | 246 | static void cinergyt2_stream_irq (struct urb *urb); |
1da177e4 LT |
247 | |
248 | static int cinergyt2_submit_stream_urb (struct cinergyt2 *cinergyt2, struct urb *urb) | |
249 | { | |
250 | int err; | |
251 | ||
252 | usb_fill_bulk_urb(urb, | |
253 | cinergyt2->udev, | |
254 | usb_rcvbulkpipe(cinergyt2->udev, 0x2), | |
255 | urb->transfer_buffer, | |
256 | STREAM_BUF_SIZE, | |
257 | cinergyt2_stream_irq, | |
258 | cinergyt2); | |
259 | ||
260 | if ((err = usb_submit_urb(urb, GFP_ATOMIC))) | |
261 | dprintk(1, "urb submission failed (err = %i)!\n", err); | |
262 | ||
263 | return err; | |
264 | } | |
265 | ||
7d12e780 | 266 | static void cinergyt2_stream_irq (struct urb *urb) |
1da177e4 LT |
267 | { |
268 | struct cinergyt2 *cinergyt2 = urb->context; | |
269 | ||
270 | if (urb->actual_length > 0) | |
271 | dvb_dmx_swfilter(&cinergyt2->demux, | |
272 | urb->transfer_buffer, urb->actual_length); | |
273 | ||
274 | if (cinergyt2->streaming) | |
275 | cinergyt2_submit_stream_urb(cinergyt2, urb); | |
276 | } | |
277 | ||
278 | static void cinergyt2_free_stream_urbs (struct cinergyt2 *cinergyt2) | |
279 | { | |
280 | int i; | |
281 | ||
282 | for (i=0; i<STREAM_URB_COUNT; i++) | |
4064fe43 | 283 | usb_free_urb(cinergyt2->stream_urb[i]); |
1da177e4 | 284 | |
574780d5 | 285 | usb_buffer_free(cinergyt2->udev, STREAM_URB_COUNT*STREAM_BUF_SIZE, |
1da177e4 LT |
286 | cinergyt2->streambuf, cinergyt2->streambuf_dmahandle); |
287 | } | |
288 | ||
289 | static int cinergyt2_alloc_stream_urbs (struct cinergyt2 *cinergyt2) | |
290 | { | |
291 | int i; | |
292 | ||
574780d5 | 293 | cinergyt2->streambuf = usb_buffer_alloc(cinergyt2->udev, STREAM_URB_COUNT*STREAM_BUF_SIZE, |
e94b1766 | 294 | GFP_KERNEL, &cinergyt2->streambuf_dmahandle); |
1da177e4 LT |
295 | if (!cinergyt2->streambuf) { |
296 | dprintk(1, "failed to alloc consistent stream memory area, bailing out!\n"); | |
297 | return -ENOMEM; | |
298 | } | |
299 | ||
300 | memset(cinergyt2->streambuf, 0, STREAM_URB_COUNT*STREAM_BUF_SIZE); | |
301 | ||
302 | for (i=0; i<STREAM_URB_COUNT; i++) { | |
303 | struct urb *urb; | |
304 | ||
305 | if (!(urb = usb_alloc_urb(0, GFP_ATOMIC))) { | |
306 | dprintk(1, "failed to alloc consistent stream urbs, bailing out!\n"); | |
307 | cinergyt2_free_stream_urbs(cinergyt2); | |
308 | return -ENOMEM; | |
309 | } | |
310 | ||
311 | urb->transfer_buffer = cinergyt2->streambuf + i * STREAM_BUF_SIZE; | |
312 | urb->transfer_buffer_length = STREAM_BUF_SIZE; | |
313 | ||
314 | cinergyt2->stream_urb[i] = urb; | |
315 | } | |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
320 | static void cinergyt2_stop_stream_xfer (struct cinergyt2 *cinergyt2) | |
321 | { | |
322 | int i; | |
323 | ||
324 | cinergyt2_control_stream_transfer(cinergyt2, 0); | |
325 | ||
326 | for (i=0; i<STREAM_URB_COUNT; i++) | |
4064fe43 | 327 | usb_kill_urb(cinergyt2->stream_urb[i]); |
1da177e4 LT |
328 | } |
329 | ||
330 | static int cinergyt2_start_stream_xfer (struct cinergyt2 *cinergyt2) | |
331 | { | |
332 | int i, err; | |
333 | ||
334 | for (i=0; i<STREAM_URB_COUNT; i++) { | |
335 | if ((err = cinergyt2_submit_stream_urb(cinergyt2, cinergyt2->stream_urb[i]))) { | |
336 | cinergyt2_stop_stream_xfer(cinergyt2); | |
337 | dprintk(1, "failed urb submission (%i: err = %i)!\n", i, err); | |
338 | return err; | |
339 | } | |
340 | } | |
341 | ||
342 | cinergyt2_control_stream_transfer(cinergyt2, 1); | |
343 | return 0; | |
344 | } | |
345 | ||
346 | static int cinergyt2_start_feed(struct dvb_demux_feed *dvbdmxfeed) | |
347 | { | |
348 | struct dvb_demux *demux = dvbdmxfeed->demux; | |
349 | struct cinergyt2 *cinergyt2 = demux->priv; | |
350 | ||
475d5263 JS |
351 | if (cinergyt2->disconnect_pending) |
352 | return -EAGAIN; | |
353 | if (mutex_lock_interruptible(&cinergyt2->sem)) | |
1da177e4 LT |
354 | return -ERESTARTSYS; |
355 | ||
356 | if (cinergyt2->streaming == 0) | |
357 | cinergyt2_start_stream_xfer(cinergyt2); | |
358 | ||
359 | cinergyt2->streaming++; | |
3593cab5 | 360 | mutex_unlock(&cinergyt2->sem); |
1da177e4 LT |
361 | return 0; |
362 | } | |
363 | ||
364 | static int cinergyt2_stop_feed(struct dvb_demux_feed *dvbdmxfeed) | |
365 | { | |
366 | struct dvb_demux *demux = dvbdmxfeed->demux; | |
367 | struct cinergyt2 *cinergyt2 = demux->priv; | |
368 | ||
475d5263 JS |
369 | if (cinergyt2->disconnect_pending) |
370 | return -EAGAIN; | |
371 | if (mutex_lock_interruptible(&cinergyt2->sem)) | |
1da177e4 LT |
372 | return -ERESTARTSYS; |
373 | ||
374 | if (--cinergyt2->streaming == 0) | |
375 | cinergyt2_stop_stream_xfer(cinergyt2); | |
376 | ||
3593cab5 | 377 | mutex_unlock(&cinergyt2->sem); |
1da177e4 LT |
378 | return 0; |
379 | } | |
380 | ||
381 | /** | |
382 | * convert linux-dvb frontend parameter set into TPS. | |
383 | * See ETSI ETS-300744, section 4.6.2, table 9 for details. | |
384 | * | |
385 | * This function is probably reusable and may better get placed in a support | |
386 | * library. | |
387 | * | |
388 | * We replace errornous fields by default TPS fields (the ones with value 0). | |
389 | */ | |
390 | static uint16_t compute_tps (struct dvb_frontend_parameters *p) | |
391 | { | |
392 | struct dvb_ofdm_parameters *op = &p->u.ofdm; | |
393 | uint16_t tps = 0; | |
394 | ||
395 | switch (op->code_rate_HP) { | |
396 | case FEC_2_3: | |
397 | tps |= (1 << 7); | |
398 | break; | |
399 | case FEC_3_4: | |
400 | tps |= (2 << 7); | |
401 | break; | |
402 | case FEC_5_6: | |
403 | tps |= (3 << 7); | |
404 | break; | |
405 | case FEC_7_8: | |
406 | tps |= (4 << 7); | |
407 | break; | |
408 | case FEC_1_2: | |
409 | case FEC_AUTO: | |
410 | default: | |
411 | /* tps |= (0 << 7) */; | |
412 | } | |
413 | ||
414 | switch (op->code_rate_LP) { | |
415 | case FEC_2_3: | |
416 | tps |= (1 << 4); | |
417 | break; | |
418 | case FEC_3_4: | |
419 | tps |= (2 << 4); | |
420 | break; | |
421 | case FEC_5_6: | |
422 | tps |= (3 << 4); | |
423 | break; | |
424 | case FEC_7_8: | |
425 | tps |= (4 << 4); | |
426 | break; | |
427 | case FEC_1_2: | |
428 | case FEC_AUTO: | |
429 | default: | |
430 | /* tps |= (0 << 4) */; | |
431 | } | |
432 | ||
433 | switch (op->constellation) { | |
434 | case QAM_16: | |
435 | tps |= (1 << 13); | |
436 | break; | |
437 | case QAM_64: | |
438 | tps |= (2 << 13); | |
439 | break; | |
440 | case QPSK: | |
441 | default: | |
442 | /* tps |= (0 << 13) */; | |
443 | } | |
444 | ||
445 | switch (op->transmission_mode) { | |
446 | case TRANSMISSION_MODE_8K: | |
447 | tps |= (1 << 0); | |
448 | break; | |
449 | case TRANSMISSION_MODE_2K: | |
450 | default: | |
451 | /* tps |= (0 << 0) */; | |
452 | } | |
453 | ||
454 | switch (op->guard_interval) { | |
455 | case GUARD_INTERVAL_1_16: | |
456 | tps |= (1 << 2); | |
457 | break; | |
458 | case GUARD_INTERVAL_1_8: | |
459 | tps |= (2 << 2); | |
460 | break; | |
461 | case GUARD_INTERVAL_1_4: | |
462 | tps |= (3 << 2); | |
463 | break; | |
464 | case GUARD_INTERVAL_1_32: | |
465 | default: | |
466 | /* tps |= (0 << 2) */; | |
467 | } | |
468 | ||
469 | switch (op->hierarchy_information) { | |
470 | case HIERARCHY_1: | |
471 | tps |= (1 << 10); | |
472 | break; | |
473 | case HIERARCHY_2: | |
474 | tps |= (2 << 10); | |
475 | break; | |
476 | case HIERARCHY_4: | |
477 | tps |= (3 << 10); | |
478 | break; | |
479 | case HIERARCHY_NONE: | |
480 | default: | |
481 | /* tps |= (0 << 10) */; | |
482 | } | |
483 | ||
484 | return tps; | |
485 | } | |
486 | ||
487 | static int cinergyt2_open (struct inode *inode, struct file *file) | |
488 | { | |
489 | struct dvb_device *dvbdev = file->private_data; | |
490 | struct cinergyt2 *cinergyt2 = dvbdev->priv; | |
475d5263 | 491 | int err = -EAGAIN; |
1da177e4 | 492 | |
475d5263 JS |
493 | if (cinergyt2->disconnect_pending) |
494 | goto out; | |
495 | err = mutex_lock_interruptible(&cinergyt2->wq_sem); | |
496 | if (err) | |
1e4597e8 | 497 | goto out; |
e4acba3c | 498 | |
475d5263 JS |
499 | err = mutex_lock_interruptible(&cinergyt2->sem); |
500 | if (err) | |
1e4597e8 | 501 | goto out_unlock1; |
1da177e4 | 502 | |
1e4597e8 ON |
503 | if ((err = dvb_generic_open(inode, file))) |
504 | goto out_unlock2; | |
1da177e4 LT |
505 | |
506 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) { | |
507 | cinergyt2_sleep(cinergyt2, 0); | |
508 | schedule_delayed_work(&cinergyt2->query_work, HZ/2); | |
509 | } | |
510 | ||
e4acba3c DF |
511 | atomic_inc(&cinergyt2->inuse); |
512 | ||
1e4597e8 | 513 | out_unlock2: |
3593cab5 | 514 | mutex_unlock(&cinergyt2->sem); |
1e4597e8 ON |
515 | out_unlock1: |
516 | mutex_unlock(&cinergyt2->wq_sem); | |
517 | out: | |
518 | return err; | |
1da177e4 LT |
519 | } |
520 | ||
e4acba3c DF |
521 | static void cinergyt2_unregister(struct cinergyt2 *cinergyt2) |
522 | { | |
77cc5319 MR |
523 | dvb_net_release(&cinergyt2->dvbnet); |
524 | dvb_dmxdev_release(&cinergyt2->dmxdev); | |
525 | dvb_dmx_release(&cinergyt2->demux); | |
e4acba3c DF |
526 | dvb_unregister_device(cinergyt2->fedev); |
527 | dvb_unregister_adapter(&cinergyt2->adapter); | |
528 | ||
529 | cinergyt2_free_stream_urbs(cinergyt2); | |
530 | kfree(cinergyt2); | |
531 | } | |
532 | ||
1da177e4 LT |
533 | static int cinergyt2_release (struct inode *inode, struct file *file) |
534 | { | |
535 | struct dvb_device *dvbdev = file->private_data; | |
536 | struct cinergyt2 *cinergyt2 = dvbdev->priv; | |
537 | ||
1e4597e8 | 538 | mutex_lock(&cinergyt2->wq_sem); |
1da177e4 | 539 | |
e4acba3c | 540 | if (!cinergyt2->disconnect_pending && (file->f_flags & O_ACCMODE) != O_RDONLY) { |
1e4597e8 ON |
541 | cancel_rearming_delayed_work(&cinergyt2->query_work); |
542 | ||
543 | mutex_lock(&cinergyt2->sem); | |
1da177e4 | 544 | cinergyt2_sleep(cinergyt2, 1); |
1e4597e8 | 545 | mutex_unlock(&cinergyt2->sem); |
1da177e4 LT |
546 | } |
547 | ||
1e4597e8 | 548 | mutex_unlock(&cinergyt2->wq_sem); |
1da177e4 | 549 | |
e4acba3c DF |
550 | if (atomic_dec_and_test(&cinergyt2->inuse) && cinergyt2->disconnect_pending) { |
551 | warn("delayed unregister in release"); | |
552 | cinergyt2_unregister(cinergyt2); | |
553 | } | |
554 | ||
1da177e4 LT |
555 | return dvb_generic_release(inode, file); |
556 | } | |
557 | ||
558 | static unsigned int cinergyt2_poll (struct file *file, struct poll_table_struct *wait) | |
559 | { | |
560 | struct dvb_device *dvbdev = file->private_data; | |
561 | struct cinergyt2 *cinergyt2 = dvbdev->priv; | |
b930e1d8 | 562 | unsigned int mask = 0; |
e4acba3c | 563 | |
475d5263 JS |
564 | if (cinergyt2->disconnect_pending) |
565 | return -EAGAIN; | |
566 | if (mutex_lock_interruptible(&cinergyt2->sem)) | |
e4acba3c DF |
567 | return -ERESTARTSYS; |
568 | ||
1da177e4 | 569 | poll_wait(file, &cinergyt2->poll_wq, wait); |
e4acba3c | 570 | |
b930e1d8 | 571 | if (cinergyt2->pending_fe_events != 0) |
fd174c67 | 572 | mask |= (POLLIN | POLLRDNORM | POLLPRI); |
774dd5d9 | 573 | |
3593cab5 | 574 | mutex_unlock(&cinergyt2->sem); |
e4acba3c | 575 | |
b930e1d8 | 576 | return mask; |
1da177e4 LT |
577 | } |
578 | ||
579 | ||
580 | static int cinergyt2_ioctl (struct inode *inode, struct file *file, | |
581 | unsigned cmd, unsigned long arg) | |
582 | { | |
583 | struct dvb_device *dvbdev = file->private_data; | |
584 | struct cinergyt2 *cinergyt2 = dvbdev->priv; | |
585 | struct dvbt_get_status_msg *stat = &cinergyt2->status; | |
586 | fe_status_t status = 0; | |
587 | ||
588 | switch (cmd) { | |
589 | case FE_GET_INFO: | |
590 | return copy_to_user((void __user*) arg, &cinergyt2_fe_info, | |
591 | sizeof(struct dvb_frontend_info)); | |
592 | ||
593 | case FE_READ_STATUS: | |
594 | if (0xffff - le16_to_cpu(stat->gain) > 30) | |
595 | status |= FE_HAS_SIGNAL; | |
596 | if (stat->lock_bits & (1 << 6)) | |
597 | status |= FE_HAS_LOCK; | |
598 | if (stat->lock_bits & (1 << 5)) | |
599 | status |= FE_HAS_SYNC; | |
600 | if (stat->lock_bits & (1 << 4)) | |
601 | status |= FE_HAS_CARRIER; | |
602 | if (stat->lock_bits & (1 << 1)) | |
603 | status |= FE_HAS_VITERBI; | |
604 | ||
605 | return copy_to_user((void __user*) arg, &status, sizeof(status)); | |
606 | ||
607 | case FE_READ_BER: | |
608 | return put_user(le32_to_cpu(stat->viterbi_error_rate), | |
609 | (__u32 __user *) arg); | |
610 | ||
611 | case FE_READ_SIGNAL_STRENGTH: | |
612 | return put_user(0xffff - le16_to_cpu(stat->gain), | |
613 | (__u16 __user *) arg); | |
614 | ||
615 | case FE_READ_SNR: | |
616 | return put_user((stat->snr << 8) | stat->snr, | |
617 | (__u16 __user *) arg); | |
618 | ||
619 | case FE_READ_UNCORRECTED_BLOCKS: | |
2c3f11b2 SW |
620 | { |
621 | uint32_t unc_count; | |
1da177e4 | 622 | |
f34ec12a AV |
623 | if (mutex_lock_interruptible(&cinergyt2->sem)) |
624 | return -ERESTARTSYS; | |
625 | unc_count = cinergyt2->uncorrected_block_count; | |
626 | cinergyt2->uncorrected_block_count = 0; | |
627 | mutex_unlock(&cinergyt2->sem); | |
2c3f11b2 SW |
628 | |
629 | /* UNC are already converted to host byte order... */ | |
630 | return put_user(unc_count,(__u32 __user *) arg); | |
631 | } | |
1da177e4 LT |
632 | case FE_SET_FRONTEND: |
633 | { | |
634 | struct dvbt_set_parameters_msg *param = &cinergyt2->param; | |
635 | struct dvb_frontend_parameters p; | |
636 | int err; | |
637 | ||
638 | if ((file->f_flags & O_ACCMODE) == O_RDONLY) | |
639 | return -EPERM; | |
640 | ||
641 | if (copy_from_user(&p, (void __user*) arg, sizeof(p))) | |
642 | return -EFAULT; | |
643 | ||
475d5263 JS |
644 | if (cinergyt2->disconnect_pending) |
645 | return -EAGAIN; | |
646 | if (mutex_lock_interruptible(&cinergyt2->sem)) | |
1da177e4 LT |
647 | return -ERESTARTSYS; |
648 | ||
649 | param->cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS; | |
650 | param->tps = cpu_to_le16(compute_tps(&p)); | |
651 | param->freq = cpu_to_le32(p.frequency / 1000); | |
652 | param->bandwidth = 8 - p.u.ofdm.bandwidth - BANDWIDTH_8_MHZ; | |
653 | ||
654 | stat->lock_bits = 0; | |
655 | cinergyt2->pending_fe_events++; | |
656 | wake_up_interruptible(&cinergyt2->poll_wq); | |
657 | ||
658 | err = cinergyt2_command(cinergyt2, | |
659 | (char *) param, sizeof(*param), | |
660 | NULL, 0); | |
661 | ||
3593cab5 | 662 | mutex_unlock(&cinergyt2->sem); |
1da177e4 LT |
663 | |
664 | return (err < 0) ? err : 0; | |
665 | } | |
666 | ||
667 | case FE_GET_FRONTEND: | |
668 | /** | |
669 | * trivial to implement (see struct dvbt_get_status_msg). | |
670 | * equivalent to FE_READ ioctls, but needs | |
671 | * TPS -> linux-dvb parameter set conversion. Feel free | |
672 | * to implement this and send us a patch if you need this | |
673 | * functionality. | |
674 | */ | |
675 | break; | |
676 | ||
677 | case FE_GET_EVENT: | |
678 | { | |
679 | /** | |
680 | * for now we only fill the status field. the parameters | |
681 | * are trivial to fill as soon FE_GET_FRONTEND is done. | |
682 | */ | |
683 | struct dvb_frontend_event __user *e = (void __user *) arg; | |
684 | if (cinergyt2->pending_fe_events == 0) { | |
685 | if (file->f_flags & O_NONBLOCK) | |
686 | return -EWOULDBLOCK; | |
687 | wait_event_interruptible(cinergyt2->poll_wq, | |
688 | cinergyt2->pending_fe_events > 0); | |
689 | } | |
690 | cinergyt2->pending_fe_events = 0; | |
691 | return cinergyt2_ioctl(inode, file, FE_READ_STATUS, | |
692 | (unsigned long) &e->status); | |
693 | } | |
694 | ||
695 | default: | |
696 | ; | |
697 | } | |
698 | ||
699 | return -EINVAL; | |
700 | } | |
701 | ||
702 | static int cinergyt2_mmap(struct file *file, struct vm_area_struct *vma) | |
703 | { | |
704 | struct dvb_device *dvbdev = file->private_data; | |
705 | struct cinergyt2 *cinergyt2 = dvbdev->priv; | |
706 | int ret = 0; | |
707 | ||
708 | lock_kernel(); | |
709 | ||
710 | if (vma->vm_flags & (VM_WRITE | VM_EXEC)) { | |
711 | ret = -EPERM; | |
712 | goto bailout; | |
713 | } | |
714 | ||
715 | if (vma->vm_end > vma->vm_start + STREAM_URB_COUNT * STREAM_BUF_SIZE) { | |
716 | ret = -EINVAL; | |
717 | goto bailout; | |
718 | } | |
719 | ||
720 | vma->vm_flags |= (VM_IO | VM_DONTCOPY); | |
721 | vma->vm_file = file; | |
722 | ||
723 | ret = remap_pfn_range(vma, vma->vm_start, | |
724 | virt_to_phys(cinergyt2->streambuf) >> PAGE_SHIFT, | |
725 | vma->vm_end - vma->vm_start, | |
726 | vma->vm_page_prot) ? -EAGAIN : 0; | |
727 | bailout: | |
728 | unlock_kernel(); | |
729 | return ret; | |
730 | } | |
731 | ||
732 | static struct file_operations cinergyt2_fops = { | |
733 | .owner = THIS_MODULE, | |
734 | .ioctl = cinergyt2_ioctl, | |
735 | .poll = cinergyt2_poll, | |
736 | .open = cinergyt2_open, | |
737 | .release = cinergyt2_release, | |
738 | .mmap = cinergyt2_mmap | |
739 | }; | |
740 | ||
741 | static struct dvb_device cinergyt2_fe_template = { | |
742 | .users = ~0, | |
743 | .writers = 1, | |
744 | .readers = (~0)-1, | |
745 | .fops = &cinergyt2_fops | |
746 | }; | |
747 | ||
748 | #ifdef ENABLE_RC | |
b7df3910 | 749 | |
c4028958 | 750 | static void cinergyt2_query_rc (struct work_struct *work) |
1da177e4 | 751 | { |
c4028958 DH |
752 | struct cinergyt2 *cinergyt2 = |
753 | container_of(work, struct cinergyt2, rc_query_work.work); | |
6d78933c | 754 | char buf[1] = { CINERGYT2_EP1_GET_RC_EVENTS }; |
1da177e4 | 755 | struct cinergyt2_rc_event rc_events[12]; |
6d78933c | 756 | int n, len, i; |
1da177e4 | 757 | |
3593cab5 | 758 | if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem)) |
1da177e4 LT |
759 | return; |
760 | ||
761 | len = cinergyt2_command(cinergyt2, buf, sizeof(buf), | |
6d78933c JS |
762 | (char *) rc_events, sizeof(rc_events)); |
763 | if (len < 0) | |
764 | goto out; | |
765 | if (len == 0) { | |
766 | if (time_after(jiffies, cinergyt2->last_event_jiffies + | |
767 | msecs_to_jiffies(150))) { | |
768 | /* stop key repeat */ | |
769 | if (cinergyt2->rc_input_event != KEY_MAX) { | |
770 | dprintk(1, "rc_input_event=%d Up\n", cinergyt2->rc_input_event); | |
b7df3910 | 771 | input_report_key(cinergyt2->rc_input_dev, |
6d78933c | 772 | cinergyt2->rc_input_event, 0); |
b07b4783 | 773 | input_sync(cinergyt2->rc_input_dev); |
6d78933c JS |
774 | cinergyt2->rc_input_event = KEY_MAX; |
775 | } | |
f34ec12a | 776 | cinergyt2->rc_last_code = cpu_to_le32(~0); |
6d78933c JS |
777 | } |
778 | goto out; | |
779 | } | |
780 | cinergyt2->last_event_jiffies = jiffies; | |
1da177e4 | 781 | |
6d78933c JS |
782 | for (n = 0; n < (len / sizeof(rc_events[0])); n++) { |
783 | dprintk(1, "rc_events[%d].value = %x, type=%x\n", | |
784 | n, le32_to_cpu(rc_events[n].value), rc_events[n].type); | |
38b32d62 | 785 | |
1da177e4 | 786 | if (rc_events[n].type == CINERGYT2_RC_EVENT_TYPE_NEC && |
f34ec12a | 787 | rc_events[n].value == cpu_to_le32(~0)) { |
6d78933c | 788 | /* keyrepeat bit -> just repeat last rc_input_event */ |
1da177e4 LT |
789 | } else { |
790 | cinergyt2->rc_input_event = KEY_MAX; | |
b7df3910 | 791 | for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3) { |
6d78933c JS |
792 | if (rc_keys[i + 0] == rc_events[n].type && |
793 | rc_keys[i + 1] == le32_to_cpu(rc_events[n].value)) { | |
794 | cinergyt2->rc_input_event = rc_keys[i + 2]; | |
1da177e4 LT |
795 | break; |
796 | } | |
797 | } | |
798 | } | |
799 | ||
800 | if (cinergyt2->rc_input_event != KEY_MAX) { | |
6d78933c | 801 | if (rc_events[n].value == cinergyt2->rc_last_code && |
f34ec12a | 802 | cinergyt2->rc_last_code != cpu_to_le32(~0)) { |
6d78933c JS |
803 | /* emit a key-up so the double event is recognized */ |
804 | dprintk(1, "rc_input_event=%d UP\n", cinergyt2->rc_input_event); | |
b7df3910 | 805 | input_report_key(cinergyt2->rc_input_dev, |
6d78933c JS |
806 | cinergyt2->rc_input_event, 0); |
807 | } | |
808 | dprintk(1, "rc_input_event=%d\n", cinergyt2->rc_input_event); | |
b7df3910 | 809 | input_report_key(cinergyt2->rc_input_dev, |
6d78933c | 810 | cinergyt2->rc_input_event, 1); |
b07b4783 | 811 | input_sync(cinergyt2->rc_input_dev); |
6d78933c | 812 | cinergyt2->rc_last_code = rc_events[n].value; |
1da177e4 LT |
813 | } |
814 | } | |
815 | ||
6d78933c | 816 | out: |
1da177e4 LT |
817 | schedule_delayed_work(&cinergyt2->rc_query_work, |
818 | msecs_to_jiffies(RC_QUERY_INTERVAL)); | |
819 | ||
3593cab5 | 820 | mutex_unlock(&cinergyt2->sem); |
1da177e4 | 821 | } |
b7df3910 DT |
822 | |
823 | static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) | |
824 | { | |
825 | struct input_dev *input_dev; | |
826 | int i; | |
b07b4783 | 827 | int err; |
b7df3910 | 828 | |
b07b4783 | 829 | input_dev = input_allocate_device(); |
b7df3910 DT |
830 | if (!input_dev) |
831 | return -ENOMEM; | |
832 | ||
833 | usb_make_path(cinergyt2->udev, cinergyt2->phys, sizeof(cinergyt2->phys)); | |
834 | strlcat(cinergyt2->phys, "/input0", sizeof(cinergyt2->phys)); | |
835 | cinergyt2->rc_input_event = KEY_MAX; | |
f34ec12a | 836 | cinergyt2->rc_last_code = cpu_to_le32(~0); |
c4028958 | 837 | INIT_DELAYED_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc); |
b7df3910 DT |
838 | |
839 | input_dev->name = DRIVER_NAME " remote control"; | |
840 | input_dev->phys = cinergyt2->phys; | |
7b19ada2 | 841 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); |
db93a82f | 842 | for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3) |
b7df3910 DT |
843 | set_bit(rc_keys[i + 2], input_dev->keybit); |
844 | input_dev->keycodesize = 0; | |
845 | input_dev->keycodemax = 0; | |
ef7b8b72 | 846 | input_dev->id.bustype = BUS_USB; |
f34ec12a AV |
847 | input_dev->id.vendor = le16_to_cpu(cinergyt2->udev->descriptor.idVendor); |
848 | input_dev->id.product = le16_to_cpu(cinergyt2->udev->descriptor.idProduct); | |
ef7b8b72 | 849 | input_dev->id.version = 1; |
2c8a3a33 | 850 | input_dev->dev.parent = &cinergyt2->udev->dev; |
b7df3910 | 851 | |
b07b4783 DT |
852 | err = input_register_device(input_dev); |
853 | if (err) { | |
854 | input_free_device(input_dev); | |
855 | return err; | |
856 | } | |
857 | ||
858 | cinergyt2->rc_input_dev = input_dev; | |
b7df3910 | 859 | schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); |
7b5603e0 DM |
860 | |
861 | return 0; | |
b7df3910 DT |
862 | } |
863 | ||
864 | static void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) | |
865 | { | |
1e4597e8 | 866 | cancel_rearming_delayed_work(&cinergyt2->rc_query_work); |
b7df3910 DT |
867 | input_unregister_device(cinergyt2->rc_input_dev); |
868 | } | |
869 | ||
870 | static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) | |
871 | { | |
1e4597e8 | 872 | cancel_rearming_delayed_work(&cinergyt2->rc_query_work); |
b7df3910 DT |
873 | } |
874 | ||
875 | static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) | |
876 | { | |
877 | schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2); | |
878 | } | |
879 | ||
880 | #else | |
881 | ||
882 | static inline int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) { return 0; } | |
883 | static inline void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) { } | |
884 | static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) { } | |
885 | static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) { } | |
886 | ||
887 | #endif /* ENABLE_RC */ | |
1da177e4 | 888 | |
c4028958 | 889 | static void cinergyt2_query (struct work_struct *work) |
1da177e4 | 890 | { |
c4028958 DH |
891 | struct cinergyt2 *cinergyt2 = |
892 | container_of(work, struct cinergyt2, query_work.work); | |
1da177e4 LT |
893 | char cmd [] = { CINERGYT2_EP1_GET_TUNER_STATUS }; |
894 | struct dvbt_get_status_msg *s = &cinergyt2->status; | |
895 | uint8_t lock_bits; | |
1da177e4 | 896 | |
3593cab5 | 897 | if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem)) |
1da177e4 LT |
898 | return; |
899 | ||
1da177e4 LT |
900 | lock_bits = s->lock_bits; |
901 | ||
902 | cinergyt2_command(cinergyt2, cmd, sizeof(cmd), (char *) s, sizeof(*s)); | |
903 | ||
f34ec12a AV |
904 | cinergyt2->uncorrected_block_count += |
905 | le32_to_cpu(s->uncorrected_block_count); | |
1da177e4 LT |
906 | |
907 | if (lock_bits != s->lock_bits) { | |
908 | wake_up_interruptible(&cinergyt2->poll_wq); | |
909 | cinergyt2->pending_fe_events++; | |
910 | } | |
911 | ||
912 | schedule_delayed_work(&cinergyt2->query_work, | |
913 | msecs_to_jiffies(QUERY_INTERVAL)); | |
914 | ||
3593cab5 | 915 | mutex_unlock(&cinergyt2->sem); |
1da177e4 LT |
916 | } |
917 | ||
918 | static int cinergyt2_probe (struct usb_interface *intf, | |
919 | const struct usb_device_id *id) | |
920 | { | |
921 | struct cinergyt2 *cinergyt2; | |
6d78933c | 922 | int err; |
1da177e4 | 923 | |
dd00cc48 | 924 | if (!(cinergyt2 = kzalloc (sizeof(struct cinergyt2), GFP_KERNEL))) { |
1da177e4 LT |
925 | dprintk(1, "out of memory?!?\n"); |
926 | return -ENOMEM; | |
927 | } | |
928 | ||
1da177e4 LT |
929 | usb_set_intfdata (intf, (void *) cinergyt2); |
930 | ||
3593cab5 | 931 | mutex_init(&cinergyt2->sem); |
1e4597e8 | 932 | mutex_init(&cinergyt2->wq_sem); |
1da177e4 | 933 | init_waitqueue_head (&cinergyt2->poll_wq); |
c4028958 | 934 | INIT_DELAYED_WORK(&cinergyt2->query_work, cinergyt2_query); |
1da177e4 LT |
935 | |
936 | cinergyt2->udev = interface_to_usbdev(intf); | |
937 | cinergyt2->param.cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS; | |
938 | ||
939 | if (cinergyt2_alloc_stream_urbs (cinergyt2) < 0) { | |
940 | dprintk(1, "unable to allocate stream urbs\n"); | |
941 | kfree(cinergyt2); | |
942 | return -ENOMEM; | |
943 | } | |
944 | ||
78e92006 JG |
945 | err = dvb_register_adapter(&cinergyt2->adapter, DRIVER_NAME, |
946 | THIS_MODULE, &cinergyt2->udev->dev, | |
947 | adapter_nr); | |
948 | if (err < 0) { | |
a064fad3 AQ |
949 | kfree(cinergyt2); |
950 | return err; | |
951 | } | |
1da177e4 LT |
952 | |
953 | cinergyt2->demux.priv = cinergyt2; | |
954 | cinergyt2->demux.filternum = 256; | |
955 | cinergyt2->demux.feednum = 256; | |
956 | cinergyt2->demux.start_feed = cinergyt2_start_feed; | |
957 | cinergyt2->demux.stop_feed = cinergyt2_stop_feed; | |
958 | cinergyt2->demux.dmx.capabilities = DMX_TS_FILTERING | | |
959 | DMX_SECTION_FILTERING | | |
960 | DMX_MEMORY_BASED_FILTERING; | |
961 | ||
962 | if ((err = dvb_dmx_init(&cinergyt2->demux)) < 0) { | |
963 | dprintk(1, "dvb_dmx_init() failed (err = %d)\n", err); | |
964 | goto bailout; | |
965 | } | |
966 | ||
967 | cinergyt2->dmxdev.filternum = cinergyt2->demux.filternum; | |
968 | cinergyt2->dmxdev.demux = &cinergyt2->demux.dmx; | |
969 | cinergyt2->dmxdev.capabilities = 0; | |
970 | ||
fdc53a6d | 971 | if ((err = dvb_dmxdev_init(&cinergyt2->dmxdev, &cinergyt2->adapter)) < 0) { |
1da177e4 LT |
972 | dprintk(1, "dvb_dmxdev_init() failed (err = %d)\n", err); |
973 | goto bailout; | |
974 | } | |
975 | ||
fdc53a6d | 976 | if (dvb_net_init(&cinergyt2->adapter, &cinergyt2->dvbnet, &cinergyt2->demux.dmx)) |
1da177e4 LT |
977 | dprintk(1, "dvb_net_init() failed!\n"); |
978 | ||
fdc53a6d | 979 | dvb_register_device(&cinergyt2->adapter, &cinergyt2->fedev, |
1da177e4 LT |
980 | &cinergyt2_fe_template, cinergyt2, |
981 | DVB_DEVICE_FRONTEND); | |
982 | ||
b7df3910 DT |
983 | err = cinergyt2_register_rc(cinergyt2); |
984 | if (err) | |
985 | goto bailout; | |
1da177e4 | 986 | |
1da177e4 LT |
987 | return 0; |
988 | ||
989 | bailout: | |
77cc5319 | 990 | dvb_net_release(&cinergyt2->dvbnet); |
1da177e4 LT |
991 | dvb_dmxdev_release(&cinergyt2->dmxdev); |
992 | dvb_dmx_release(&cinergyt2->demux); | |
b7df3910 DT |
993 | dvb_unregister_adapter(&cinergyt2->adapter); |
994 | cinergyt2_free_stream_urbs(cinergyt2); | |
1da177e4 LT |
995 | kfree(cinergyt2); |
996 | return -ENOMEM; | |
997 | } | |
998 | ||
999 | static void cinergyt2_disconnect (struct usb_interface *intf) | |
1000 | { | |
1001 | struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf); | |
1002 | ||
b7df3910 | 1003 | cinergyt2_unregister_rc(cinergyt2); |
1e4597e8 | 1004 | cancel_rearming_delayed_work(&cinergyt2->query_work); |
e4acba3c DF |
1005 | wake_up_interruptible(&cinergyt2->poll_wq); |
1006 | ||
1da177e4 | 1007 | cinergyt2->demux.dmx.close(&cinergyt2->demux.dmx); |
e4acba3c | 1008 | cinergyt2->disconnect_pending = 1; |
1da177e4 | 1009 | |
e4acba3c DF |
1010 | if (!atomic_read(&cinergyt2->inuse)) |
1011 | cinergyt2_unregister(cinergyt2); | |
1da177e4 LT |
1012 | } |
1013 | ||
a2910689 | 1014 | static int cinergyt2_suspend (struct usb_interface *intf, pm_message_t state) |
1da177e4 LT |
1015 | { |
1016 | struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf); | |
1017 | ||
475d5263 JS |
1018 | if (cinergyt2->disconnect_pending) |
1019 | return -EAGAIN; | |
1020 | if (mutex_lock_interruptible(&cinergyt2->wq_sem)) | |
1da177e4 LT |
1021 | return -ERESTARTSYS; |
1022 | ||
9b7cc429 MCC |
1023 | cinergyt2_suspend_rc(cinergyt2); |
1024 | cancel_rearming_delayed_work(&cinergyt2->query_work); | |
1e4597e8 | 1025 | |
9b7cc429 MCC |
1026 | mutex_lock(&cinergyt2->sem); |
1027 | if (cinergyt2->streaming) | |
1028 | cinergyt2_stop_stream_xfer(cinergyt2); | |
1029 | cinergyt2_sleep(cinergyt2, 1); | |
1030 | mutex_unlock(&cinergyt2->sem); | |
1da177e4 | 1031 | |
1597f1f6 ON |
1032 | mutex_unlock(&cinergyt2->wq_sem); |
1033 | ||
1da177e4 LT |
1034 | return 0; |
1035 | } | |
1036 | ||
1037 | static int cinergyt2_resume (struct usb_interface *intf) | |
1038 | { | |
1039 | struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf); | |
1040 | struct dvbt_set_parameters_msg *param = &cinergyt2->param; | |
475d5263 | 1041 | int err = -EAGAIN; |
1da177e4 | 1042 | |
475d5263 JS |
1043 | if (cinergyt2->disconnect_pending) |
1044 | goto out; | |
1045 | err = mutex_lock_interruptible(&cinergyt2->wq_sem); | |
1046 | if (err) | |
1e4597e8 ON |
1047 | goto out; |
1048 | ||
475d5263 JS |
1049 | err = mutex_lock_interruptible(&cinergyt2->sem); |
1050 | if (err) | |
1e4597e8 ON |
1051 | goto out_unlock1; |
1052 | ||
1da177e4 LT |
1053 | if (!cinergyt2->sleeping) { |
1054 | cinergyt2_sleep(cinergyt2, 0); | |
1055 | cinergyt2_command(cinergyt2, (char *) param, sizeof(*param), NULL, 0); | |
1056 | if (cinergyt2->streaming) | |
1057 | cinergyt2_start_stream_xfer(cinergyt2); | |
1058 | schedule_delayed_work(&cinergyt2->query_work, HZ/2); | |
1059 | } | |
1060 | ||
b7df3910 DT |
1061 | cinergyt2_resume_rc(cinergyt2); |
1062 | ||
3593cab5 | 1063 | mutex_unlock(&cinergyt2->sem); |
1e4597e8 ON |
1064 | out_unlock1: |
1065 | mutex_unlock(&cinergyt2->wq_sem); | |
1066 | out: | |
1067 | return err; | |
1da177e4 LT |
1068 | } |
1069 | ||
1070 | static const struct usb_device_id cinergyt2_table [] __devinitdata = { | |
1071 | { USB_DEVICE(0x0ccd, 0x0038) }, | |
1072 | { 0 } | |
1073 | }; | |
1074 | ||
1075 | MODULE_DEVICE_TABLE(usb, cinergyt2_table); | |
1076 | ||
1077 | static struct usb_driver cinergyt2_driver = { | |
1da177e4 LT |
1078 | .name = "cinergyT2", |
1079 | .probe = cinergyt2_probe, | |
1080 | .disconnect = cinergyt2_disconnect, | |
1081 | .suspend = cinergyt2_suspend, | |
1082 | .resume = cinergyt2_resume, | |
1083 | .id_table = cinergyt2_table | |
1084 | }; | |
1085 | ||
1086 | static int __init cinergyt2_init (void) | |
1087 | { | |
1088 | int err; | |
1089 | ||
1090 | if ((err = usb_register(&cinergyt2_driver)) < 0) | |
1091 | dprintk(1, "usb_register() failed! (err %i)\n", err); | |
1092 | ||
1093 | return err; | |
1094 | } | |
1095 | ||
1096 | static void __exit cinergyt2_exit (void) | |
1097 | { | |
1098 | usb_deregister(&cinergyt2_driver); | |
1099 | } | |
1100 | ||
1101 | module_init (cinergyt2_init); | |
1102 | module_exit (cinergyt2_exit); | |
1103 | ||
1104 | MODULE_LICENSE("GPL"); | |
1105 | MODULE_AUTHOR("Holger Waechtler, Daniel Mack"); |