diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/media/dvb/ttusb-dec/ttusb_dec.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/media/dvb/ttusb-dec/ttusb_dec.c')
-rw-r--r-- | drivers/media/dvb/ttusb-dec/ttusb_dec.c | 1744 |
1 files changed, 1744 insertions, 0 deletions
diff --git a/drivers/media/dvb/ttusb-dec/ttusb_dec.c b/drivers/media/dvb/ttusb-dec/ttusb_dec.c new file mode 100644 index 000000000000..64e771bd8907 --- /dev/null +++ b/drivers/media/dvb/ttusb-dec/ttusb_dec.c | |||
@@ -0,0 +1,1744 @@ | |||
1 | /* | ||
2 | * TTUSB DEC Driver | ||
3 | * | ||
4 | * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org> | ||
5 | * IR support by Peter Beutner <p.beutner@gmx.net> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
20 | * | ||
21 | */ | ||
22 | |||
23 | #include <asm/semaphore.h> | ||
24 | #include <linux/list.h> | ||
25 | #include <linux/module.h> | ||
26 | #include <linux/moduleparam.h> | ||
27 | #include <linux/pci.h> | ||
28 | #include <linux/slab.h> | ||
29 | #include <linux/spinlock.h> | ||
30 | #include <linux/usb.h> | ||
31 | #include <linux/version.h> | ||
32 | #include <linux/interrupt.h> | ||
33 | #include <linux/firmware.h> | ||
34 | #include <linux/crc32.h> | ||
35 | #include <linux/init.h> | ||
36 | #include <linux/input.h> | ||
37 | |||
38 | #include "dmxdev.h" | ||
39 | #include "dvb_demux.h" | ||
40 | #include "dvb_filter.h" | ||
41 | #include "dvb_frontend.h" | ||
42 | #include "dvb_net.h" | ||
43 | #include "ttusbdecfe.h" | ||
44 | |||
45 | static int debug; | ||
46 | static int output_pva; | ||
47 | static int enable_rc; | ||
48 | |||
49 | module_param(debug, int, 0644); | ||
50 | MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); | ||
51 | module_param(output_pva, int, 0444); | ||
52 | MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)"); | ||
53 | module_param(enable_rc, int, 0644); | ||
54 | MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)"); | ||
55 | |||
56 | #define dprintk if (debug) printk | ||
57 | |||
58 | #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB" | ||
59 | |||
60 | #define COMMAND_PIPE 0x03 | ||
61 | #define RESULT_PIPE 0x04 | ||
62 | #define IN_PIPE 0x08 | ||
63 | #define OUT_PIPE 0x07 | ||
64 | #define IRQ_PIPE 0x0A | ||
65 | |||
66 | #define COMMAND_PACKET_SIZE 0x3c | ||
67 | #define ARM_PACKET_SIZE 0x1000 | ||
68 | #define IRQ_PACKET_SIZE 0x8 | ||
69 | |||
70 | #define ISO_BUF_COUNT 0x04 | ||
71 | #define FRAMES_PER_ISO_BUF 0x04 | ||
72 | #define ISO_FRAME_SIZE 0x0380 | ||
73 | |||
74 | #define MAX_PVA_LENGTH 6144 | ||
75 | |||
76 | enum ttusb_dec_model { | ||
77 | TTUSB_DEC2000T, | ||
78 | TTUSB_DEC2540T, | ||
79 | TTUSB_DEC3000S | ||
80 | }; | ||
81 | |||
82 | enum ttusb_dec_packet_type { | ||
83 | TTUSB_DEC_PACKET_PVA, | ||
84 | TTUSB_DEC_PACKET_SECTION, | ||
85 | TTUSB_DEC_PACKET_EMPTY | ||
86 | }; | ||
87 | |||
88 | enum ttusb_dec_interface { | ||
89 | TTUSB_DEC_INTERFACE_INITIAL, | ||
90 | TTUSB_DEC_INTERFACE_IN, | ||
91 | TTUSB_DEC_INTERFACE_OUT | ||
92 | }; | ||
93 | |||
94 | struct ttusb_dec { | ||
95 | enum ttusb_dec_model model; | ||
96 | char *model_name; | ||
97 | char *firmware_name; | ||
98 | int can_playback; | ||
99 | |||
100 | /* DVB bits */ | ||
101 | struct dvb_adapter *adapter; | ||
102 | struct dmxdev dmxdev; | ||
103 | struct dvb_demux demux; | ||
104 | struct dmx_frontend frontend; | ||
105 | struct dvb_net dvb_net; | ||
106 | struct dvb_frontend* fe; | ||
107 | |||
108 | u16 pid[DMX_PES_OTHER]; | ||
109 | |||
110 | /* USB bits */ | ||
111 | struct usb_device *udev; | ||
112 | u8 trans_count; | ||
113 | unsigned int command_pipe; | ||
114 | unsigned int result_pipe; | ||
115 | unsigned int in_pipe; | ||
116 | unsigned int out_pipe; | ||
117 | unsigned int irq_pipe; | ||
118 | enum ttusb_dec_interface interface; | ||
119 | struct semaphore usb_sem; | ||
120 | |||
121 | void *irq_buffer; | ||
122 | struct urb *irq_urb; | ||
123 | dma_addr_t irq_dma_handle; | ||
124 | void *iso_buffer; | ||
125 | dma_addr_t iso_dma_handle; | ||
126 | struct urb *iso_urb[ISO_BUF_COUNT]; | ||
127 | int iso_stream_count; | ||
128 | struct semaphore iso_sem; | ||
129 | |||
130 | u8 packet[MAX_PVA_LENGTH + 4]; | ||
131 | enum ttusb_dec_packet_type packet_type; | ||
132 | int packet_state; | ||
133 | int packet_length; | ||
134 | int packet_payload_length; | ||
135 | u16 next_packet_id; | ||
136 | |||
137 | int pva_stream_count; | ||
138 | int filter_stream_count; | ||
139 | |||
140 | struct dvb_filter_pes2ts a_pes2ts; | ||
141 | struct dvb_filter_pes2ts v_pes2ts; | ||
142 | |||
143 | u8 v_pes[16 + MAX_PVA_LENGTH]; | ||
144 | int v_pes_length; | ||
145 | int v_pes_postbytes; | ||
146 | |||
147 | struct list_head urb_frame_list; | ||
148 | struct tasklet_struct urb_tasklet; | ||
149 | spinlock_t urb_frame_list_lock; | ||
150 | |||
151 | struct dvb_demux_filter *audio_filter; | ||
152 | struct dvb_demux_filter *video_filter; | ||
153 | struct list_head filter_info_list; | ||
154 | spinlock_t filter_info_list_lock; | ||
155 | |||
156 | struct input_dev rc_input_dev; | ||
157 | |||
158 | int active; /* Loaded successfully */ | ||
159 | }; | ||
160 | |||
161 | struct urb_frame { | ||
162 | u8 data[ISO_FRAME_SIZE]; | ||
163 | int length; | ||
164 | struct list_head urb_frame_list; | ||
165 | }; | ||
166 | |||
167 | struct filter_info { | ||
168 | u8 stream_id; | ||
169 | struct dvb_demux_filter *filter; | ||
170 | struct list_head filter_info_list; | ||
171 | }; | ||
172 | |||
173 | static u16 rc_keys[] = { | ||
174 | KEY_POWER, | ||
175 | KEY_MUTE, | ||
176 | KEY_1, | ||
177 | KEY_2, | ||
178 | KEY_3, | ||
179 | KEY_4, | ||
180 | KEY_5, | ||
181 | KEY_6, | ||
182 | KEY_7, | ||
183 | KEY_8, | ||
184 | KEY_9, | ||
185 | KEY_0, | ||
186 | KEY_CHANNELUP, | ||
187 | KEY_VOLUMEDOWN, | ||
188 | KEY_OK, | ||
189 | KEY_VOLUMEUP, | ||
190 | KEY_CHANNELDOWN, | ||
191 | KEY_PREVIOUS, | ||
192 | KEY_ESC, | ||
193 | KEY_RED, | ||
194 | KEY_GREEN, | ||
195 | KEY_YELLOW, | ||
196 | KEY_BLUE, | ||
197 | KEY_OPTION, | ||
198 | KEY_M, | ||
199 | KEY_RADIO | ||
200 | }; | ||
201 | |||
202 | static void ttusb_dec_set_model(struct ttusb_dec *dec, | ||
203 | enum ttusb_dec_model model); | ||
204 | |||
205 | static void ttusb_dec_handle_irq( struct urb *urb, struct pt_regs *regs) | ||
206 | { | ||
207 | struct ttusb_dec * dec = urb->context; | ||
208 | char *buffer = dec->irq_buffer; | ||
209 | int retval; | ||
210 | |||
211 | switch(urb->status) { | ||
212 | case 0: /*success*/ | ||
213 | break; | ||
214 | case -ECONNRESET: | ||
215 | case -ENOENT: | ||
216 | case -ESHUTDOWN: | ||
217 | case -ETIMEDOUT: | ||
218 | /* this urb is dead, cleanup */ | ||
219 | dprintk("%s:urb shutting down with status: %d\n", | ||
220 | __FUNCTION__, urb->status); | ||
221 | return; | ||
222 | default: | ||
223 | dprintk("%s:nonzero status received: %d\n", | ||
224 | __FUNCTION__,urb->status); | ||
225 | goto exit; | ||
226 | } | ||
227 | |||
228 | if( (buffer[0] == 0x1) && (buffer[2] == 0x15) ) { | ||
229 | /* IR - Event */ | ||
230 | /* this is an fact a bit too simple implementation; | ||
231 | * the box also reports a keyrepeat signal | ||
232 | * (with buffer[3] == 0x40) in an intervall of ~100ms. | ||
233 | * But to handle this correctly we had to imlemenent some | ||
234 | * kind of timer which signals a 'key up' event if no | ||
235 | * keyrepeat signal is recieved for lets say 200ms. | ||
236 | * this should/could be added later ... | ||
237 | * for now lets report each signal as a key down and up*/ | ||
238 | dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]); | ||
239 | input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],1); | ||
240 | input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],0); | ||
241 | input_sync(&dec->rc_input_dev); | ||
242 | } | ||
243 | |||
244 | exit: retval = usb_submit_urb(urb, GFP_ATOMIC); | ||
245 | if(retval) | ||
246 | printk("%s - usb_commit_urb failed with result: %d\n", | ||
247 | __FUNCTION__, retval); | ||
248 | } | ||
249 | |||
250 | static u16 crc16(u16 crc, const u8 *buf, size_t len) | ||
251 | { | ||
252 | u16 tmp; | ||
253 | |||
254 | while (len--) { | ||
255 | crc ^= *buf++; | ||
256 | crc ^= (u8)crc >> 4; | ||
257 | tmp = (u8)crc; | ||
258 | crc ^= (tmp ^ (tmp << 1)) << 4; | ||
259 | } | ||
260 | return crc; | ||
261 | } | ||
262 | |||
263 | static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command, | ||
264 | int param_length, const u8 params[], | ||
265 | int *result_length, u8 cmd_result[]) | ||
266 | { | ||
267 | int result, actual_len, i; | ||
268 | u8 *b; | ||
269 | |||
270 | dprintk("%s\n", __FUNCTION__); | ||
271 | |||
272 | b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL); | ||
273 | if (!b) | ||
274 | return -ENOMEM; | ||
275 | |||
276 | if ((result = down_interruptible(&dec->usb_sem))) { | ||
277 | kfree(b); | ||
278 | printk("%s: Failed to down usb semaphore.\n", __FUNCTION__); | ||
279 | return result; | ||
280 | } | ||
281 | |||
282 | b[0] = 0xaa; | ||
283 | b[1] = ++dec->trans_count; | ||
284 | b[2] = command; | ||
285 | b[3] = param_length; | ||
286 | |||
287 | if (params) | ||
288 | memcpy(&b[4], params, param_length); | ||
289 | |||
290 | if (debug) { | ||
291 | printk("%s: command: ", __FUNCTION__); | ||
292 | for (i = 0; i < param_length + 4; i++) | ||
293 | printk("0x%02X ", b[i]); | ||
294 | printk("\n"); | ||
295 | } | ||
296 | |||
297 | result = usb_bulk_msg(dec->udev, dec->command_pipe, b, | ||
298 | COMMAND_PACKET_SIZE + 4, &actual_len, 1000); | ||
299 | |||
300 | if (result) { | ||
301 | printk("%s: command bulk message failed: error %d\n", | ||
302 | __FUNCTION__, result); | ||
303 | up(&dec->usb_sem); | ||
304 | kfree(b); | ||
305 | return result; | ||
306 | } | ||
307 | |||
308 | result = usb_bulk_msg(dec->udev, dec->result_pipe, b, | ||
309 | COMMAND_PACKET_SIZE + 4, &actual_len, 1000); | ||
310 | |||
311 | if (result) { | ||
312 | printk("%s: result bulk message failed: error %d\n", | ||
313 | __FUNCTION__, result); | ||
314 | up(&dec->usb_sem); | ||
315 | kfree(b); | ||
316 | return result; | ||
317 | } else { | ||
318 | if (debug) { | ||
319 | printk("%s: result: ", __FUNCTION__); | ||
320 | for (i = 0; i < actual_len; i++) | ||
321 | printk("0x%02X ", b[i]); | ||
322 | printk("\n"); | ||
323 | } | ||
324 | |||
325 | if (result_length) | ||
326 | *result_length = b[3]; | ||
327 | if (cmd_result && b[3] > 0) | ||
328 | memcpy(cmd_result, &b[4], b[3]); | ||
329 | |||
330 | up(&dec->usb_sem); | ||
331 | |||
332 | kfree(b); | ||
333 | return 0; | ||
334 | } | ||
335 | } | ||
336 | |||
337 | static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode, | ||
338 | unsigned int *model, unsigned int *version) | ||
339 | { | ||
340 | u8 c[COMMAND_PACKET_SIZE]; | ||
341 | int c_length; | ||
342 | int result; | ||
343 | unsigned int tmp; | ||
344 | |||
345 | dprintk("%s\n", __FUNCTION__); | ||
346 | |||
347 | result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c); | ||
348 | if (result) | ||
349 | return result; | ||
350 | |||
351 | if (c_length >= 0x0c) { | ||
352 | if (mode != NULL) { | ||
353 | memcpy(&tmp, c, 4); | ||
354 | *mode = ntohl(tmp); | ||
355 | } | ||
356 | if (model != NULL) { | ||
357 | memcpy(&tmp, &c[4], 4); | ||
358 | *model = ntohl(tmp); | ||
359 | } | ||
360 | if (version != NULL) { | ||
361 | memcpy(&tmp, &c[8], 4); | ||
362 | *version = ntohl(tmp); | ||
363 | } | ||
364 | return 0; | ||
365 | } else { | ||
366 | return -1; | ||
367 | } | ||
368 | } | ||
369 | |||
370 | static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data) | ||
371 | { | ||
372 | struct ttusb_dec *dec = (struct ttusb_dec *)priv; | ||
373 | |||
374 | dec->audio_filter->feed->cb.ts(data, 188, NULL, 0, | ||
375 | &dec->audio_filter->feed->feed.ts, | ||
376 | DMX_OK); | ||
377 | |||
378 | return 0; | ||
379 | } | ||
380 | |||
381 | static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data) | ||
382 | { | ||
383 | struct ttusb_dec *dec = (struct ttusb_dec *)priv; | ||
384 | |||
385 | dec->video_filter->feed->cb.ts(data, 188, NULL, 0, | ||
386 | &dec->video_filter->feed->feed.ts, | ||
387 | DMX_OK); | ||
388 | |||
389 | return 0; | ||
390 | } | ||
391 | |||
392 | static void ttusb_dec_set_pids(struct ttusb_dec *dec) | ||
393 | { | ||
394 | u8 b[] = { 0x00, 0x00, 0x00, 0x00, | ||
395 | 0x00, 0x00, 0xff, 0xff, | ||
396 | 0xff, 0xff, 0xff, 0xff }; | ||
397 | |||
398 | u16 pcr = htons(dec->pid[DMX_PES_PCR]); | ||
399 | u16 audio = htons(dec->pid[DMX_PES_AUDIO]); | ||
400 | u16 video = htons(dec->pid[DMX_PES_VIDEO]); | ||
401 | |||
402 | dprintk("%s\n", __FUNCTION__); | ||
403 | |||
404 | memcpy(&b[0], &pcr, 2); | ||
405 | memcpy(&b[2], &audio, 2); | ||
406 | memcpy(&b[4], &video, 2); | ||
407 | |||
408 | ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL); | ||
409 | |||
410 | dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO], | ||
411 | ttusb_dec_audio_pes2ts_cb, dec); | ||
412 | dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO], | ||
413 | ttusb_dec_video_pes2ts_cb, dec); | ||
414 | dec->v_pes_length = 0; | ||
415 | dec->v_pes_postbytes = 0; | ||
416 | } | ||
417 | |||
418 | static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length) | ||
419 | { | ||
420 | if (length < 8) { | ||
421 | printk("%s: packet too short - discarding\n", __FUNCTION__); | ||
422 | return; | ||
423 | } | ||
424 | |||
425 | if (length > 8 + MAX_PVA_LENGTH) { | ||
426 | printk("%s: packet too long - discarding\n", __FUNCTION__); | ||
427 | return; | ||
428 | } | ||
429 | |||
430 | switch (pva[2]) { | ||
431 | |||
432 | case 0x01: { /* VideoStream */ | ||
433 | int prebytes = pva[5] & 0x03; | ||
434 | int postbytes = (pva[5] & 0x0c) >> 2; | ||
435 | u16 v_pes_payload_length; | ||
436 | |||
437 | if (output_pva) { | ||
438 | dec->video_filter->feed->cb.ts(pva, length, NULL, 0, | ||
439 | &dec->video_filter->feed->feed.ts, DMX_OK); | ||
440 | return; | ||
441 | } | ||
442 | |||
443 | if (dec->v_pes_postbytes > 0 && | ||
444 | dec->v_pes_postbytes == prebytes) { | ||
445 | memcpy(&dec->v_pes[dec->v_pes_length], | ||
446 | &pva[12], prebytes); | ||
447 | |||
448 | dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, | ||
449 | dec->v_pes_length + prebytes, 1); | ||
450 | } | ||
451 | |||
452 | if (pva[5] & 0x10) { | ||
453 | dec->v_pes[7] = 0x80; | ||
454 | dec->v_pes[8] = 0x05; | ||
455 | |||
456 | dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5); | ||
457 | dec->v_pes[10] = ((pva[8] & 0x3f) << 2) | | ||
458 | ((pva[9] & 0xc0) >> 6); | ||
459 | dec->v_pes[11] = 0x01 | | ||
460 | ((pva[9] & 0x3f) << 2) | | ||
461 | ((pva[10] & 0x80) >> 6); | ||
462 | dec->v_pes[12] = ((pva[10] & 0x7f) << 1) | | ||
463 | ((pva[11] & 0xc0) >> 7); | ||
464 | dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1); | ||
465 | |||
466 | memcpy(&dec->v_pes[14], &pva[12 + prebytes], | ||
467 | length - 12 - prebytes); | ||
468 | dec->v_pes_length = 14 + length - 12 - prebytes; | ||
469 | } else { | ||
470 | dec->v_pes[7] = 0x00; | ||
471 | dec->v_pes[8] = 0x00; | ||
472 | |||
473 | memcpy(&dec->v_pes[9], &pva[8], length - 8); | ||
474 | dec->v_pes_length = 9 + length - 8; | ||
475 | } | ||
476 | |||
477 | dec->v_pes_postbytes = postbytes; | ||
478 | |||
479 | if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 && | ||
480 | dec->v_pes[10 + dec->v_pes[8]] == 0x00 && | ||
481 | dec->v_pes[11 + dec->v_pes[8]] == 0x01) | ||
482 | dec->v_pes[6] = 0x84; | ||
483 | else | ||
484 | dec->v_pes[6] = 0x80; | ||
485 | |||
486 | v_pes_payload_length = htons(dec->v_pes_length - 6 + | ||
487 | postbytes); | ||
488 | memcpy(&dec->v_pes[4], &v_pes_payload_length, 2); | ||
489 | |||
490 | if (postbytes == 0) | ||
491 | dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, | ||
492 | dec->v_pes_length, 1); | ||
493 | |||
494 | break; | ||
495 | } | ||
496 | |||
497 | case 0x02: /* MainAudioStream */ | ||
498 | if (output_pva) { | ||
499 | dec->audio_filter->feed->cb.ts(pva, length, NULL, 0, | ||
500 | &dec->audio_filter->feed->feed.ts, DMX_OK); | ||
501 | return; | ||
502 | } | ||
503 | |||
504 | dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8, | ||
505 | pva[5] & 0x10); | ||
506 | break; | ||
507 | |||
508 | default: | ||
509 | printk("%s: unknown PVA type: %02x.\n", __FUNCTION__, | ||
510 | pva[2]); | ||
511 | break; | ||
512 | } | ||
513 | } | ||
514 | |||
515 | static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet, | ||
516 | int length) | ||
517 | { | ||
518 | struct list_head *item; | ||
519 | struct filter_info *finfo; | ||
520 | struct dvb_demux_filter *filter = NULL; | ||
521 | unsigned long flags; | ||
522 | u8 sid; | ||
523 | |||
524 | sid = packet[1]; | ||
525 | spin_lock_irqsave(&dec->filter_info_list_lock, flags); | ||
526 | for (item = dec->filter_info_list.next; item != &dec->filter_info_list; | ||
527 | item = item->next) { | ||
528 | finfo = list_entry(item, struct filter_info, filter_info_list); | ||
529 | if (finfo->stream_id == sid) { | ||
530 | filter = finfo->filter; | ||
531 | break; | ||
532 | } | ||
533 | } | ||
534 | spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); | ||
535 | |||
536 | if (filter) | ||
537 | filter->feed->cb.sec(&packet[2], length - 2, NULL, 0, | ||
538 | &filter->filter, DMX_OK); | ||
539 | } | ||
540 | |||
541 | static void ttusb_dec_process_packet(struct ttusb_dec *dec) | ||
542 | { | ||
543 | int i; | ||
544 | u16 csum = 0; | ||
545 | u16 packet_id; | ||
546 | |||
547 | if (dec->packet_length % 2) { | ||
548 | printk("%s: odd sized packet - discarding\n", __FUNCTION__); | ||
549 | return; | ||
550 | } | ||
551 | |||
552 | for (i = 0; i < dec->packet_length; i += 2) | ||
553 | csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]); | ||
554 | |||
555 | if (csum) { | ||
556 | printk("%s: checksum failed - discarding\n", __FUNCTION__); | ||
557 | return; | ||
558 | } | ||
559 | |||
560 | packet_id = dec->packet[dec->packet_length - 4] << 8; | ||
561 | packet_id += dec->packet[dec->packet_length - 3]; | ||
562 | |||
563 | if ((packet_id != dec->next_packet_id) && dec->next_packet_id) { | ||
564 | printk("%s: warning: lost packets between %u and %u\n", | ||
565 | __FUNCTION__, dec->next_packet_id - 1, packet_id); | ||
566 | } | ||
567 | |||
568 | if (packet_id == 0xffff) | ||
569 | dec->next_packet_id = 0x8000; | ||
570 | else | ||
571 | dec->next_packet_id = packet_id + 1; | ||
572 | |||
573 | switch (dec->packet_type) { | ||
574 | case TTUSB_DEC_PACKET_PVA: | ||
575 | if (dec->pva_stream_count) | ||
576 | ttusb_dec_process_pva(dec, dec->packet, | ||
577 | dec->packet_payload_length); | ||
578 | break; | ||
579 | |||
580 | case TTUSB_DEC_PACKET_SECTION: | ||
581 | if (dec->filter_stream_count) | ||
582 | ttusb_dec_process_filter(dec, dec->packet, | ||
583 | dec->packet_payload_length); | ||
584 | break; | ||
585 | |||
586 | case TTUSB_DEC_PACKET_EMPTY: | ||
587 | break; | ||
588 | } | ||
589 | } | ||
590 | |||
591 | static void swap_bytes(u8 *b, int length) | ||
592 | { | ||
593 | u8 c; | ||
594 | |||
595 | length -= length % 2; | ||
596 | for (; length; b += 2, length -= 2) { | ||
597 | c = *b; | ||
598 | *b = *(b + 1); | ||
599 | *(b + 1) = c; | ||
600 | } | ||
601 | } | ||
602 | |||
603 | static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b, | ||
604 | int length) | ||
605 | { | ||
606 | swap_bytes(b, length); | ||
607 | |||
608 | while (length) { | ||
609 | switch (dec->packet_state) { | ||
610 | |||
611 | case 0: | ||
612 | case 1: | ||
613 | case 2: | ||
614 | if (*b++ == 0xaa) | ||
615 | dec->packet_state++; | ||
616 | else | ||
617 | dec->packet_state = 0; | ||
618 | |||
619 | length--; | ||
620 | break; | ||
621 | |||
622 | case 3: | ||
623 | if (*b == 0x00) { | ||
624 | dec->packet_state++; | ||
625 | dec->packet_length = 0; | ||
626 | } else if (*b != 0xaa) { | ||
627 | dec->packet_state = 0; | ||
628 | } | ||
629 | |||
630 | b++; | ||
631 | length--; | ||
632 | break; | ||
633 | |||
634 | case 4: | ||
635 | dec->packet[dec->packet_length++] = *b++; | ||
636 | |||
637 | if (dec->packet_length == 2) { | ||
638 | if (dec->packet[0] == 'A' && | ||
639 | dec->packet[1] == 'V') { | ||
640 | dec->packet_type = | ||
641 | TTUSB_DEC_PACKET_PVA; | ||
642 | dec->packet_state++; | ||
643 | } else if (dec->packet[0] == 'S') { | ||
644 | dec->packet_type = | ||
645 | TTUSB_DEC_PACKET_SECTION; | ||
646 | dec->packet_state++; | ||
647 | } else if (dec->packet[0] == 0x00) { | ||
648 | dec->packet_type = | ||
649 | TTUSB_DEC_PACKET_EMPTY; | ||
650 | dec->packet_payload_length = 2; | ||
651 | dec->packet_state = 7; | ||
652 | } else { | ||
653 | printk("%s: unknown packet type: " | ||
654 | "%02x%02x\n", __FUNCTION__, | ||
655 | dec->packet[0], dec->packet[1]); | ||
656 | dec->packet_state = 0; | ||
657 | } | ||
658 | } | ||
659 | |||
660 | length--; | ||
661 | break; | ||
662 | |||
663 | case 5: | ||
664 | dec->packet[dec->packet_length++] = *b++; | ||
665 | |||
666 | if (dec->packet_type == TTUSB_DEC_PACKET_PVA && | ||
667 | dec->packet_length == 8) { | ||
668 | dec->packet_state++; | ||
669 | dec->packet_payload_length = 8 + | ||
670 | (dec->packet[6] << 8) + | ||
671 | dec->packet[7]; | ||
672 | } else if (dec->packet_type == | ||
673 | TTUSB_DEC_PACKET_SECTION && | ||
674 | dec->packet_length == 5) { | ||
675 | dec->packet_state++; | ||
676 | dec->packet_payload_length = 5 + | ||
677 | ((dec->packet[3] & 0x0f) << 8) + | ||
678 | dec->packet[4]; | ||
679 | } | ||
680 | |||
681 | length--; | ||
682 | break; | ||
683 | |||
684 | case 6: { | ||
685 | int remainder = dec->packet_payload_length - | ||
686 | dec->packet_length; | ||
687 | |||
688 | if (length >= remainder) { | ||
689 | memcpy(dec->packet + dec->packet_length, | ||
690 | b, remainder); | ||
691 | dec->packet_length += remainder; | ||
692 | b += remainder; | ||
693 | length -= remainder; | ||
694 | dec->packet_state++; | ||
695 | } else { | ||
696 | memcpy(&dec->packet[dec->packet_length], | ||
697 | b, length); | ||
698 | dec->packet_length += length; | ||
699 | length = 0; | ||
700 | } | ||
701 | |||
702 | break; | ||
703 | } | ||
704 | |||
705 | case 7: { | ||
706 | int tail = 4; | ||
707 | |||
708 | dec->packet[dec->packet_length++] = *b++; | ||
709 | |||
710 | if (dec->packet_type == TTUSB_DEC_PACKET_SECTION && | ||
711 | dec->packet_payload_length % 2) | ||
712 | tail++; | ||
713 | |||
714 | if (dec->packet_length == | ||
715 | dec->packet_payload_length + tail) { | ||
716 | ttusb_dec_process_packet(dec); | ||
717 | dec->packet_state = 0; | ||
718 | } | ||
719 | |||
720 | length--; | ||
721 | break; | ||
722 | } | ||
723 | |||
724 | default: | ||
725 | printk("%s: illegal packet state encountered.\n", | ||
726 | __FUNCTION__); | ||
727 | dec->packet_state = 0; | ||
728 | } | ||
729 | } | ||
730 | } | ||
731 | |||
732 | static void ttusb_dec_process_urb_frame_list(unsigned long data) | ||
733 | { | ||
734 | struct ttusb_dec *dec = (struct ttusb_dec *)data; | ||
735 | struct list_head *item; | ||
736 | struct urb_frame *frame; | ||
737 | unsigned long flags; | ||
738 | |||
739 | while (1) { | ||
740 | spin_lock_irqsave(&dec->urb_frame_list_lock, flags); | ||
741 | if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { | ||
742 | frame = list_entry(item, struct urb_frame, | ||
743 | urb_frame_list); | ||
744 | list_del(&frame->urb_frame_list); | ||
745 | } else { | ||
746 | spin_unlock_irqrestore(&dec->urb_frame_list_lock, | ||
747 | flags); | ||
748 | return; | ||
749 | } | ||
750 | spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags); | ||
751 | |||
752 | ttusb_dec_process_urb_frame(dec, frame->data, frame->length); | ||
753 | kfree(frame); | ||
754 | } | ||
755 | } | ||
756 | |||
757 | static void ttusb_dec_process_urb(struct urb *urb, struct pt_regs *ptregs) | ||
758 | { | ||
759 | struct ttusb_dec *dec = urb->context; | ||
760 | |||
761 | if (!urb->status) { | ||
762 | int i; | ||
763 | |||
764 | for (i = 0; i < FRAMES_PER_ISO_BUF; i++) { | ||
765 | struct usb_iso_packet_descriptor *d; | ||
766 | u8 *b; | ||
767 | int length; | ||
768 | struct urb_frame *frame; | ||
769 | |||
770 | d = &urb->iso_frame_desc[i]; | ||
771 | b = urb->transfer_buffer + d->offset; | ||
772 | length = d->actual_length; | ||
773 | |||
774 | if ((frame = kmalloc(sizeof(struct urb_frame), | ||
775 | GFP_ATOMIC))) { | ||
776 | unsigned long flags; | ||
777 | |||
778 | memcpy(frame->data, b, length); | ||
779 | frame->length = length; | ||
780 | |||
781 | spin_lock_irqsave(&dec->urb_frame_list_lock, | ||
782 | flags); | ||
783 | list_add_tail(&frame->urb_frame_list, | ||
784 | &dec->urb_frame_list); | ||
785 | spin_unlock_irqrestore(&dec->urb_frame_list_lock, | ||
786 | flags); | ||
787 | |||
788 | tasklet_schedule(&dec->urb_tasklet); | ||
789 | } | ||
790 | } | ||
791 | } else { | ||
792 | /* -ENOENT is expected when unlinking urbs */ | ||
793 | if (urb->status != -ENOENT) | ||
794 | dprintk("%s: urb error: %d\n", __FUNCTION__, | ||
795 | urb->status); | ||
796 | } | ||
797 | |||
798 | if (dec->iso_stream_count) | ||
799 | usb_submit_urb(urb, GFP_ATOMIC); | ||
800 | } | ||
801 | |||
802 | static void ttusb_dec_setup_urbs(struct ttusb_dec *dec) | ||
803 | { | ||
804 | int i, j, buffer_offset = 0; | ||
805 | |||
806 | dprintk("%s\n", __FUNCTION__); | ||
807 | |||
808 | for (i = 0; i < ISO_BUF_COUNT; i++) { | ||
809 | int frame_offset = 0; | ||
810 | struct urb *urb = dec->iso_urb[i]; | ||
811 | |||
812 | urb->dev = dec->udev; | ||
813 | urb->context = dec; | ||
814 | urb->complete = ttusb_dec_process_urb; | ||
815 | urb->pipe = dec->in_pipe; | ||
816 | urb->transfer_flags = URB_ISO_ASAP; | ||
817 | urb->interval = 1; | ||
818 | urb->number_of_packets = FRAMES_PER_ISO_BUF; | ||
819 | urb->transfer_buffer_length = ISO_FRAME_SIZE * | ||
820 | FRAMES_PER_ISO_BUF; | ||
821 | urb->transfer_buffer = dec->iso_buffer + buffer_offset; | ||
822 | buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; | ||
823 | |||
824 | for (j = 0; j < FRAMES_PER_ISO_BUF; j++) { | ||
825 | urb->iso_frame_desc[j].offset = frame_offset; | ||
826 | urb->iso_frame_desc[j].length = ISO_FRAME_SIZE; | ||
827 | frame_offset += ISO_FRAME_SIZE; | ||
828 | } | ||
829 | } | ||
830 | } | ||
831 | |||
832 | static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec) | ||
833 | { | ||
834 | int i; | ||
835 | |||
836 | dprintk("%s\n", __FUNCTION__); | ||
837 | |||
838 | if (down_interruptible(&dec->iso_sem)) | ||
839 | return; | ||
840 | |||
841 | dec->iso_stream_count--; | ||
842 | |||
843 | if (!dec->iso_stream_count) { | ||
844 | for (i = 0; i < ISO_BUF_COUNT; i++) | ||
845 | usb_kill_urb(dec->iso_urb[i]); | ||
846 | } | ||
847 | |||
848 | up(&dec->iso_sem); | ||
849 | } | ||
850 | |||
851 | /* Setting the interface of the DEC tends to take down the USB communications | ||
852 | * for a short period, so it's important not to call this function just before | ||
853 | * trying to talk to it. | ||
854 | */ | ||
855 | static int ttusb_dec_set_interface(struct ttusb_dec *dec, | ||
856 | enum ttusb_dec_interface interface) | ||
857 | { | ||
858 | int result = 0; | ||
859 | u8 b[] = { 0x05 }; | ||
860 | |||
861 | if (interface != dec->interface) { | ||
862 | switch (interface) { | ||
863 | case TTUSB_DEC_INTERFACE_INITIAL: | ||
864 | result = usb_set_interface(dec->udev, 0, 0); | ||
865 | break; | ||
866 | case TTUSB_DEC_INTERFACE_IN: | ||
867 | result = ttusb_dec_send_command(dec, 0x80, sizeof(b), | ||
868 | b, NULL, NULL); | ||
869 | if (result) | ||
870 | return result; | ||
871 | result = usb_set_interface(dec->udev, 0, 8); | ||
872 | break; | ||
873 | case TTUSB_DEC_INTERFACE_OUT: | ||
874 | result = usb_set_interface(dec->udev, 0, 1); | ||
875 | break; | ||
876 | } | ||
877 | |||
878 | if (result) | ||
879 | return result; | ||
880 | |||
881 | dec->interface = interface; | ||
882 | } | ||
883 | |||
884 | return 0; | ||
885 | } | ||
886 | |||
887 | static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec) | ||
888 | { | ||
889 | int i, result; | ||
890 | |||
891 | dprintk("%s\n", __FUNCTION__); | ||
892 | |||
893 | if (down_interruptible(&dec->iso_sem)) | ||
894 | return -EAGAIN; | ||
895 | |||
896 | if (!dec->iso_stream_count) { | ||
897 | ttusb_dec_setup_urbs(dec); | ||
898 | |||
899 | dec->packet_state = 0; | ||
900 | dec->v_pes_postbytes = 0; | ||
901 | dec->next_packet_id = 0; | ||
902 | |||
903 | for (i = 0; i < ISO_BUF_COUNT; i++) { | ||
904 | if ((result = usb_submit_urb(dec->iso_urb[i], | ||
905 | GFP_ATOMIC))) { | ||
906 | printk("%s: failed urb submission %d: " | ||
907 | "error %d\n", __FUNCTION__, i, result); | ||
908 | |||
909 | while (i) { | ||
910 | usb_kill_urb(dec->iso_urb[i - 1]); | ||
911 | i--; | ||
912 | } | ||
913 | |||
914 | up(&dec->iso_sem); | ||
915 | return result; | ||
916 | } | ||
917 | } | ||
918 | } | ||
919 | |||
920 | dec->iso_stream_count++; | ||
921 | |||
922 | up(&dec->iso_sem); | ||
923 | |||
924 | return 0; | ||
925 | } | ||
926 | |||
927 | static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
928 | { | ||
929 | struct dvb_demux *dvbdmx = dvbdmxfeed->demux; | ||
930 | struct ttusb_dec *dec = dvbdmx->priv; | ||
931 | u8 b0[] = { 0x05 }; | ||
932 | int result = 0; | ||
933 | |||
934 | dprintk("%s\n", __FUNCTION__); | ||
935 | |||
936 | dprintk(" ts_type:"); | ||
937 | |||
938 | if (dvbdmxfeed->ts_type & TS_DECODER) | ||
939 | dprintk(" TS_DECODER"); | ||
940 | |||
941 | if (dvbdmxfeed->ts_type & TS_PACKET) | ||
942 | dprintk(" TS_PACKET"); | ||
943 | |||
944 | if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY) | ||
945 | dprintk(" TS_PAYLOAD_ONLY"); | ||
946 | |||
947 | dprintk("\n"); | ||
948 | |||
949 | switch (dvbdmxfeed->pes_type) { | ||
950 | |||
951 | case DMX_TS_PES_VIDEO: | ||
952 | dprintk(" pes_type: DMX_TS_PES_VIDEO\n"); | ||
953 | dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; | ||
954 | dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid; | ||
955 | dec->video_filter = dvbdmxfeed->filter; | ||
956 | ttusb_dec_set_pids(dec); | ||
957 | break; | ||
958 | |||
959 | case DMX_TS_PES_AUDIO: | ||
960 | dprintk(" pes_type: DMX_TS_PES_AUDIO\n"); | ||
961 | dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid; | ||
962 | dec->audio_filter = dvbdmxfeed->filter; | ||
963 | ttusb_dec_set_pids(dec); | ||
964 | break; | ||
965 | |||
966 | case DMX_TS_PES_TELETEXT: | ||
967 | dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid; | ||
968 | dprintk(" pes_type: DMX_TS_PES_TELETEXT\n"); | ||
969 | break; | ||
970 | |||
971 | case DMX_TS_PES_PCR: | ||
972 | dprintk(" pes_type: DMX_TS_PES_PCR\n"); | ||
973 | dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; | ||
974 | ttusb_dec_set_pids(dec); | ||
975 | break; | ||
976 | |||
977 | case DMX_TS_PES_OTHER: | ||
978 | dprintk(" pes_type: DMX_TS_PES_OTHER\n"); | ||
979 | break; | ||
980 | |||
981 | default: | ||
982 | dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type); | ||
983 | return -EINVAL; | ||
984 | |||
985 | } | ||
986 | |||
987 | result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL); | ||
988 | if (result) | ||
989 | return result; | ||
990 | |||
991 | dec->pva_stream_count++; | ||
992 | return ttusb_dec_start_iso_xfer(dec); | ||
993 | } | ||
994 | |||
995 | static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
996 | { | ||
997 | struct ttusb_dec *dec = dvbdmxfeed->demux->priv; | ||
998 | u8 b0[] = { 0x00, 0x00, 0x00, 0x01, | ||
999 | 0x00, 0x00, 0x00, 0x00, | ||
1000 | 0x00, 0x00, 0x00, 0x00, | ||
1001 | 0x00, 0x00, 0x00, 0x00, | ||
1002 | 0x00, 0xff, 0x00, 0x00, | ||
1003 | 0x00, 0x00, 0x00, 0x00, | ||
1004 | 0x00, 0x00, 0x00, 0x00, | ||
1005 | 0x00 }; | ||
1006 | u16 pid; | ||
1007 | u8 c[COMMAND_PACKET_SIZE]; | ||
1008 | int c_length; | ||
1009 | int result; | ||
1010 | struct filter_info *finfo; | ||
1011 | unsigned long flags; | ||
1012 | u8 x = 1; | ||
1013 | |||
1014 | dprintk("%s\n", __FUNCTION__); | ||
1015 | |||
1016 | pid = htons(dvbdmxfeed->pid); | ||
1017 | memcpy(&b0[0], &pid, 2); | ||
1018 | memcpy(&b0[4], &x, 1); | ||
1019 | memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1); | ||
1020 | |||
1021 | result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0, | ||
1022 | &c_length, c); | ||
1023 | |||
1024 | if (!result) { | ||
1025 | if (c_length == 2) { | ||
1026 | if (!(finfo = kmalloc(sizeof(struct filter_info), | ||
1027 | GFP_ATOMIC))) | ||
1028 | return -ENOMEM; | ||
1029 | |||
1030 | finfo->stream_id = c[1]; | ||
1031 | finfo->filter = dvbdmxfeed->filter; | ||
1032 | |||
1033 | spin_lock_irqsave(&dec->filter_info_list_lock, flags); | ||
1034 | list_add_tail(&finfo->filter_info_list, | ||
1035 | &dec->filter_info_list); | ||
1036 | spin_unlock_irqrestore(&dec->filter_info_list_lock, | ||
1037 | flags); | ||
1038 | |||
1039 | dvbdmxfeed->priv = finfo; | ||
1040 | |||
1041 | dec->filter_stream_count++; | ||
1042 | return ttusb_dec_start_iso_xfer(dec); | ||
1043 | } | ||
1044 | |||
1045 | return -EAGAIN; | ||
1046 | } else | ||
1047 | return result; | ||
1048 | } | ||
1049 | |||
1050 | static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
1051 | { | ||
1052 | struct dvb_demux *dvbdmx = dvbdmxfeed->demux; | ||
1053 | |||
1054 | dprintk("%s\n", __FUNCTION__); | ||
1055 | |||
1056 | if (!dvbdmx->dmx.frontend) | ||
1057 | return -EINVAL; | ||
1058 | |||
1059 | dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid); | ||
1060 | |||
1061 | switch (dvbdmxfeed->type) { | ||
1062 | |||
1063 | case DMX_TYPE_TS: | ||
1064 | return ttusb_dec_start_ts_feed(dvbdmxfeed); | ||
1065 | break; | ||
1066 | |||
1067 | case DMX_TYPE_SEC: | ||
1068 | return ttusb_dec_start_sec_feed(dvbdmxfeed); | ||
1069 | break; | ||
1070 | |||
1071 | default: | ||
1072 | dprintk(" type: unknown (%d)\n", dvbdmxfeed->type); | ||
1073 | return -EINVAL; | ||
1074 | |||
1075 | } | ||
1076 | } | ||
1077 | |||
1078 | static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
1079 | { | ||
1080 | struct ttusb_dec *dec = dvbdmxfeed->demux->priv; | ||
1081 | u8 b0[] = { 0x00 }; | ||
1082 | |||
1083 | ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL); | ||
1084 | |||
1085 | dec->pva_stream_count--; | ||
1086 | |||
1087 | ttusb_dec_stop_iso_xfer(dec); | ||
1088 | |||
1089 | return 0; | ||
1090 | } | ||
1091 | |||
1092 | static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
1093 | { | ||
1094 | struct ttusb_dec *dec = dvbdmxfeed->demux->priv; | ||
1095 | u8 b0[] = { 0x00, 0x00 }; | ||
1096 | struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv; | ||
1097 | unsigned long flags; | ||
1098 | |||
1099 | b0[1] = finfo->stream_id; | ||
1100 | spin_lock_irqsave(&dec->filter_info_list_lock, flags); | ||
1101 | list_del(&finfo->filter_info_list); | ||
1102 | spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); | ||
1103 | kfree(finfo); | ||
1104 | ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL); | ||
1105 | |||
1106 | dec->filter_stream_count--; | ||
1107 | |||
1108 | ttusb_dec_stop_iso_xfer(dec); | ||
1109 | |||
1110 | return 0; | ||
1111 | } | ||
1112 | |||
1113 | static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed) | ||
1114 | { | ||
1115 | dprintk("%s\n", __FUNCTION__); | ||
1116 | |||
1117 | switch (dvbdmxfeed->type) { | ||
1118 | case DMX_TYPE_TS: | ||
1119 | return ttusb_dec_stop_ts_feed(dvbdmxfeed); | ||
1120 | break; | ||
1121 | |||
1122 | case DMX_TYPE_SEC: | ||
1123 | return ttusb_dec_stop_sec_feed(dvbdmxfeed); | ||
1124 | break; | ||
1125 | } | ||
1126 | |||
1127 | return 0; | ||
1128 | } | ||
1129 | |||
1130 | static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec) | ||
1131 | { | ||
1132 | int i; | ||
1133 | |||
1134 | dprintk("%s\n", __FUNCTION__); | ||
1135 | |||
1136 | for (i = 0; i < ISO_BUF_COUNT; i++) | ||
1137 | if (dec->iso_urb[i]) | ||
1138 | usb_free_urb(dec->iso_urb[i]); | ||
1139 | |||
1140 | pci_free_consistent(NULL, | ||
1141 | ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * | ||
1142 | ISO_BUF_COUNT), | ||
1143 | dec->iso_buffer, dec->iso_dma_handle); | ||
1144 | } | ||
1145 | |||
1146 | static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec) | ||
1147 | { | ||
1148 | int i; | ||
1149 | |||
1150 | dprintk("%s\n", __FUNCTION__); | ||
1151 | |||
1152 | dec->iso_buffer = pci_alloc_consistent(NULL, | ||
1153 | ISO_FRAME_SIZE * | ||
1154 | (FRAMES_PER_ISO_BUF * | ||
1155 | ISO_BUF_COUNT), | ||
1156 | &dec->iso_dma_handle); | ||
1157 | |||
1158 | memset(dec->iso_buffer, 0, | ||
1159 | ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT)); | ||
1160 | |||
1161 | for (i = 0; i < ISO_BUF_COUNT; i++) { | ||
1162 | struct urb *urb; | ||
1163 | |||
1164 | if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) { | ||
1165 | ttusb_dec_free_iso_urbs(dec); | ||
1166 | return -ENOMEM; | ||
1167 | } | ||
1168 | |||
1169 | dec->iso_urb[i] = urb; | ||
1170 | } | ||
1171 | |||
1172 | ttusb_dec_setup_urbs(dec); | ||
1173 | |||
1174 | return 0; | ||
1175 | } | ||
1176 | |||
1177 | static void ttusb_dec_init_tasklet(struct ttusb_dec *dec) | ||
1178 | { | ||
1179 | spin_lock_init(&dec->urb_frame_list_lock); | ||
1180 | INIT_LIST_HEAD(&dec->urb_frame_list); | ||
1181 | tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list, | ||
1182 | (unsigned long)dec); | ||
1183 | } | ||
1184 | |||
1185 | static void ttusb_init_rc( struct ttusb_dec *dec) | ||
1186 | { | ||
1187 | u8 b[] = { 0x00, 0x01 }; | ||
1188 | int i; | ||
1189 | |||
1190 | init_input_dev(&dec->rc_input_dev); | ||
1191 | |||
1192 | dec->rc_input_dev.name = "ttusb_dec remote control"; | ||
1193 | dec->rc_input_dev.evbit[0] = BIT(EV_KEY); | ||
1194 | dec->rc_input_dev.keycodesize = sizeof(u16); | ||
1195 | dec->rc_input_dev.keycodemax = 0x1a; | ||
1196 | dec->rc_input_dev.keycode = rc_keys; | ||
1197 | |||
1198 | for (i = 0; i < sizeof(rc_keys)/sizeof(rc_keys[0]); i++) | ||
1199 | set_bit(rc_keys[i], dec->rc_input_dev.keybit); | ||
1200 | |||
1201 | input_register_device(&dec->rc_input_dev); | ||
1202 | |||
1203 | if(usb_submit_urb(dec->irq_urb,GFP_KERNEL)) { | ||
1204 | printk("%s: usb_submit_urb failed\n",__FUNCTION__); | ||
1205 | } | ||
1206 | /* enable irq pipe */ | ||
1207 | ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL); | ||
1208 | } | ||
1209 | |||
1210 | static void ttusb_dec_init_v_pes(struct ttusb_dec *dec) | ||
1211 | { | ||
1212 | dprintk("%s\n", __FUNCTION__); | ||
1213 | |||
1214 | dec->v_pes[0] = 0x00; | ||
1215 | dec->v_pes[1] = 0x00; | ||
1216 | dec->v_pes[2] = 0x01; | ||
1217 | dec->v_pes[3] = 0xe0; | ||
1218 | } | ||
1219 | |||
1220 | static int ttusb_dec_init_usb(struct ttusb_dec *dec) | ||
1221 | { | ||
1222 | dprintk("%s\n", __FUNCTION__); | ||
1223 | |||
1224 | sema_init(&dec->usb_sem, 1); | ||
1225 | sema_init(&dec->iso_sem, 1); | ||
1226 | |||
1227 | dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE); | ||
1228 | dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE); | ||
1229 | dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE); | ||
1230 | dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE); | ||
1231 | dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE); | ||
1232 | |||
1233 | if(enable_rc) { | ||
1234 | dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
1235 | if(!dec->irq_urb) { | ||
1236 | return -ENOMEM; | ||
1237 | } | ||
1238 | dec->irq_buffer = usb_buffer_alloc(dec->udev,IRQ_PACKET_SIZE, | ||
1239 | SLAB_ATOMIC, &dec->irq_dma_handle); | ||
1240 | if(!dec->irq_buffer) { | ||
1241 | return -ENOMEM; | ||
1242 | } | ||
1243 | usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe, | ||
1244 | dec->irq_buffer, IRQ_PACKET_SIZE, | ||
1245 | ttusb_dec_handle_irq, dec, 1); | ||
1246 | dec->irq_urb->transfer_dma = dec->irq_dma_handle; | ||
1247 | dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; | ||
1248 | } | ||
1249 | |||
1250 | return ttusb_dec_alloc_iso_urbs(dec); | ||
1251 | } | ||
1252 | |||
1253 | static int ttusb_dec_boot_dsp(struct ttusb_dec *dec) | ||
1254 | { | ||
1255 | int i, j, actual_len, result, size, trans_count; | ||
1256 | u8 b0[] = { 0x00, 0x00, 0x00, 0x00, | ||
1257 | 0x00, 0x00, 0x00, 0x00, | ||
1258 | 0x61, 0x00 }; | ||
1259 | u8 b1[] = { 0x61 }; | ||
1260 | u8 *b; | ||
1261 | char idstring[21]; | ||
1262 | u8 *firmware = NULL; | ||
1263 | size_t firmware_size = 0; | ||
1264 | u16 firmware_csum = 0; | ||
1265 | u16 firmware_csum_ns; | ||
1266 | u32 firmware_size_nl; | ||
1267 | u32 crc32_csum, crc32_check, tmp; | ||
1268 | const struct firmware *fw_entry = NULL; | ||
1269 | |||
1270 | dprintk("%s\n", __FUNCTION__); | ||
1271 | |||
1272 | if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) { | ||
1273 | printk(KERN_ERR "%s: Firmware (%s) unavailable.\n", | ||
1274 | __FUNCTION__, dec->firmware_name); | ||
1275 | return 1; | ||
1276 | } | ||
1277 | |||
1278 | firmware = fw_entry->data; | ||
1279 | firmware_size = fw_entry->size; | ||
1280 | |||
1281 | if (firmware_size < 60) { | ||
1282 | printk("%s: firmware size too small for DSP code (%zu < 60).\n", | ||
1283 | __FUNCTION__, firmware_size); | ||
1284 | return -1; | ||
1285 | } | ||
1286 | |||
1287 | /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored | ||
1288 | at offset 56 of file, so use it to check if the firmware file is | ||
1289 | valid. */ | ||
1290 | crc32_csum = crc32(~0L, firmware, 56) ^ ~0L; | ||
1291 | memcpy(&tmp, &firmware[56], 4); | ||
1292 | crc32_check = htonl(tmp); | ||
1293 | if (crc32_csum != crc32_check) { | ||
1294 | printk("%s: crc32 check of DSP code failed (calculated " | ||
1295 | "0x%08x != 0x%08x in file), file invalid.\n", | ||
1296 | __FUNCTION__, crc32_csum, crc32_check); | ||
1297 | return -1; | ||
1298 | } | ||
1299 | memcpy(idstring, &firmware[36], 20); | ||
1300 | idstring[20] = '\0'; | ||
1301 | printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring); | ||
1302 | |||
1303 | firmware_size_nl = htonl(firmware_size); | ||
1304 | memcpy(b0, &firmware_size_nl, 4); | ||
1305 | firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0; | ||
1306 | firmware_csum_ns = htons(firmware_csum); | ||
1307 | memcpy(&b0[6], &firmware_csum_ns, 2); | ||
1308 | |||
1309 | result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL); | ||
1310 | |||
1311 | if (result) | ||
1312 | return result; | ||
1313 | |||
1314 | trans_count = 0; | ||
1315 | j = 0; | ||
1316 | |||
1317 | b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL); | ||
1318 | if (b == NULL) | ||
1319 | return -ENOMEM; | ||
1320 | |||
1321 | for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) { | ||
1322 | size = firmware_size - i; | ||
1323 | if (size > COMMAND_PACKET_SIZE) | ||
1324 | size = COMMAND_PACKET_SIZE; | ||
1325 | |||
1326 | b[j + 0] = 0xaa; | ||
1327 | b[j + 1] = trans_count++; | ||
1328 | b[j + 2] = 0xf0; | ||
1329 | b[j + 3] = size; | ||
1330 | memcpy(&b[j + 4], &firmware[i], size); | ||
1331 | |||
1332 | j += COMMAND_PACKET_SIZE + 4; | ||
1333 | |||
1334 | if (j >= ARM_PACKET_SIZE) { | ||
1335 | result = usb_bulk_msg(dec->udev, dec->command_pipe, b, | ||
1336 | ARM_PACKET_SIZE, &actual_len, | ||
1337 | 100); | ||
1338 | j = 0; | ||
1339 | } else if (size < COMMAND_PACKET_SIZE) { | ||
1340 | result = usb_bulk_msg(dec->udev, dec->command_pipe, b, | ||
1341 | j - COMMAND_PACKET_SIZE + size, | ||
1342 | &actual_len, 100); | ||
1343 | } | ||
1344 | } | ||
1345 | |||
1346 | result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL); | ||
1347 | |||
1348 | kfree(b); | ||
1349 | |||
1350 | return result; | ||
1351 | } | ||
1352 | |||
1353 | static int ttusb_dec_init_stb(struct ttusb_dec *dec) | ||
1354 | { | ||
1355 | int result; | ||
1356 | unsigned int mode, model, version; | ||
1357 | |||
1358 | dprintk("%s\n", __FUNCTION__); | ||
1359 | |||
1360 | result = ttusb_dec_get_stb_state(dec, &mode, &model, &version); | ||
1361 | |||
1362 | if (!result) { | ||
1363 | if (!mode) { | ||
1364 | if (version == 0xABCDEFAB) | ||
1365 | printk(KERN_INFO "ttusb_dec: no version " | ||
1366 | "info in Firmware\n"); | ||
1367 | else | ||
1368 | printk(KERN_INFO "ttusb_dec: Firmware " | ||
1369 | "%x.%02x%c%c\n", | ||
1370 | version >> 24, (version >> 16) & 0xff, | ||
1371 | (version >> 8) & 0xff, version & 0xff); | ||
1372 | |||
1373 | result = ttusb_dec_boot_dsp(dec); | ||
1374 | if (result) | ||
1375 | return result; | ||
1376 | else | ||
1377 | return 1; | ||
1378 | } else { | ||
1379 | /* We can't trust the USB IDs that some firmwares | ||
1380 | give the box */ | ||
1381 | switch (model) { | ||
1382 | case 0x00070008: | ||
1383 | case 0x0007000c: | ||
1384 | ttusb_dec_set_model(dec, TTUSB_DEC3000S); | ||
1385 | break; | ||
1386 | case 0x00070009: | ||
1387 | case 0x00070013: | ||
1388 | ttusb_dec_set_model(dec, TTUSB_DEC2000T); | ||
1389 | break; | ||
1390 | case 0x00070011: | ||
1391 | ttusb_dec_set_model(dec, TTUSB_DEC2540T); | ||
1392 | break; | ||
1393 | default: | ||
1394 | printk(KERN_ERR "%s: unknown model returned " | ||
1395 | "by firmware (%08x) - please report\n", | ||
1396 | __FUNCTION__, model); | ||
1397 | return -1; | ||
1398 | break; | ||
1399 | } | ||
1400 | |||
1401 | if (version >= 0x01770000) | ||
1402 | dec->can_playback = 1; | ||
1403 | |||
1404 | return 0; | ||
1405 | } | ||
1406 | } | ||
1407 | else | ||
1408 | return result; | ||
1409 | } | ||
1410 | |||
1411 | static int ttusb_dec_init_dvb(struct ttusb_dec *dec) | ||
1412 | { | ||
1413 | int result; | ||
1414 | |||
1415 | dprintk("%s\n", __FUNCTION__); | ||
1416 | |||
1417 | if ((result = dvb_register_adapter(&dec->adapter, | ||
1418 | dec->model_name, THIS_MODULE)) < 0) { | ||
1419 | printk("%s: dvb_register_adapter failed: error %d\n", | ||
1420 | __FUNCTION__, result); | ||
1421 | |||
1422 | return result; | ||
1423 | } | ||
1424 | |||
1425 | dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; | ||
1426 | |||
1427 | dec->demux.priv = (void *)dec; | ||
1428 | dec->demux.filternum = 31; | ||
1429 | dec->demux.feednum = 31; | ||
1430 | dec->demux.start_feed = ttusb_dec_start_feed; | ||
1431 | dec->demux.stop_feed = ttusb_dec_stop_feed; | ||
1432 | dec->demux.write_to_decoder = NULL; | ||
1433 | |||
1434 | if ((result = dvb_dmx_init(&dec->demux)) < 0) { | ||
1435 | printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__, | ||
1436 | result); | ||
1437 | |||
1438 | dvb_unregister_adapter(dec->adapter); | ||
1439 | |||
1440 | return result; | ||
1441 | } | ||
1442 | |||
1443 | dec->dmxdev.filternum = 32; | ||
1444 | dec->dmxdev.demux = &dec->demux.dmx; | ||
1445 | dec->dmxdev.capabilities = 0; | ||
1446 | |||
1447 | if ((result = dvb_dmxdev_init(&dec->dmxdev, dec->adapter)) < 0) { | ||
1448 | printk("%s: dvb_dmxdev_init failed: error %d\n", | ||
1449 | __FUNCTION__, result); | ||
1450 | |||
1451 | dvb_dmx_release(&dec->demux); | ||
1452 | dvb_unregister_adapter(dec->adapter); | ||
1453 | |||
1454 | return result; | ||
1455 | } | ||
1456 | |||
1457 | dec->frontend.source = DMX_FRONTEND_0; | ||
1458 | |||
1459 | if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx, | ||
1460 | &dec->frontend)) < 0) { | ||
1461 | printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__, | ||
1462 | result); | ||
1463 | |||
1464 | dvb_dmxdev_release(&dec->dmxdev); | ||
1465 | dvb_dmx_release(&dec->demux); | ||
1466 | dvb_unregister_adapter(dec->adapter); | ||
1467 | |||
1468 | return result; | ||
1469 | } | ||
1470 | |||
1471 | if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx, | ||
1472 | &dec->frontend)) < 0) { | ||
1473 | printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__, | ||
1474 | result); | ||
1475 | |||
1476 | dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); | ||
1477 | dvb_dmxdev_release(&dec->dmxdev); | ||
1478 | dvb_dmx_release(&dec->demux); | ||
1479 | dvb_unregister_adapter(dec->adapter); | ||
1480 | |||
1481 | return result; | ||
1482 | } | ||
1483 | |||
1484 | dvb_net_init(dec->adapter, &dec->dvb_net, &dec->demux.dmx); | ||
1485 | |||
1486 | return 0; | ||
1487 | } | ||
1488 | |||
1489 | static void ttusb_dec_exit_dvb(struct ttusb_dec *dec) | ||
1490 | { | ||
1491 | dprintk("%s\n", __FUNCTION__); | ||
1492 | |||
1493 | dvb_net_release(&dec->dvb_net); | ||
1494 | dec->demux.dmx.close(&dec->demux.dmx); | ||
1495 | dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); | ||
1496 | dvb_dmxdev_release(&dec->dmxdev); | ||
1497 | dvb_dmx_release(&dec->demux); | ||
1498 | if (dec->fe) dvb_unregister_frontend(dec->fe); | ||
1499 | dvb_unregister_adapter(dec->adapter); | ||
1500 | } | ||
1501 | |||
1502 | static void ttusb_dec_exit_rc(struct ttusb_dec *dec) | ||
1503 | { | ||
1504 | |||
1505 | dprintk("%s\n", __FUNCTION__); | ||
1506 | /* we have to check whether the irq URB is already submitted. | ||
1507 | * As the irq is submitted after the interface is changed, | ||
1508 | * this is the best method i figured out. | ||
1509 | * Any others?*/ | ||
1510 | if(dec->interface == TTUSB_DEC_INTERFACE_IN) | ||
1511 | usb_kill_urb(dec->irq_urb); | ||
1512 | |||
1513 | usb_free_urb(dec->irq_urb); | ||
1514 | |||
1515 | usb_buffer_free(dec->udev,IRQ_PACKET_SIZE, | ||
1516 | dec->irq_buffer, dec->irq_dma_handle); | ||
1517 | |||
1518 | input_unregister_device(&dec->rc_input_dev); | ||
1519 | } | ||
1520 | |||
1521 | |||
1522 | static void ttusb_dec_exit_usb(struct ttusb_dec *dec) | ||
1523 | { | ||
1524 | int i; | ||
1525 | |||
1526 | dprintk("%s\n", __FUNCTION__); | ||
1527 | |||
1528 | dec->iso_stream_count = 0; | ||
1529 | |||
1530 | for (i = 0; i < ISO_BUF_COUNT; i++) | ||
1531 | usb_kill_urb(dec->iso_urb[i]); | ||
1532 | |||
1533 | ttusb_dec_free_iso_urbs(dec); | ||
1534 | } | ||
1535 | |||
1536 | static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec) | ||
1537 | { | ||
1538 | struct list_head *item; | ||
1539 | struct urb_frame *frame; | ||
1540 | |||
1541 | tasklet_kill(&dec->urb_tasklet); | ||
1542 | |||
1543 | while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { | ||
1544 | frame = list_entry(item, struct urb_frame, urb_frame_list); | ||
1545 | list_del(&frame->urb_frame_list); | ||
1546 | kfree(frame); | ||
1547 | } | ||
1548 | } | ||
1549 | |||
1550 | static void ttusb_dec_init_filters(struct ttusb_dec *dec) | ||
1551 | { | ||
1552 | INIT_LIST_HEAD(&dec->filter_info_list); | ||
1553 | spin_lock_init(&dec->filter_info_list_lock); | ||
1554 | } | ||
1555 | |||
1556 | static void ttusb_dec_exit_filters(struct ttusb_dec *dec) | ||
1557 | { | ||
1558 | struct list_head *item; | ||
1559 | struct filter_info *finfo; | ||
1560 | |||
1561 | while ((item = dec->filter_info_list.next) != &dec->filter_info_list) { | ||
1562 | finfo = list_entry(item, struct filter_info, filter_info_list); | ||
1563 | list_del(&finfo->filter_info_list); | ||
1564 | kfree(finfo); | ||
1565 | } | ||
1566 | } | ||
1567 | |||
1568 | int fe_send_command(struct dvb_frontend* fe, const u8 command, | ||
1569 | int param_length, const u8 params[], | ||
1570 | int *result_length, u8 cmd_result[]) | ||
1571 | { | ||
1572 | struct ttusb_dec* dec = (struct ttusb_dec*) fe->dvb->priv; | ||
1573 | return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result); | ||
1574 | } | ||
1575 | |||
1576 | struct ttusbdecfe_config fe_config = { | ||
1577 | .send_command = fe_send_command | ||
1578 | }; | ||
1579 | |||
1580 | static int ttusb_dec_probe(struct usb_interface *intf, | ||
1581 | const struct usb_device_id *id) | ||
1582 | { | ||
1583 | struct usb_device *udev; | ||
1584 | struct ttusb_dec *dec; | ||
1585 | |||
1586 | dprintk("%s\n", __FUNCTION__); | ||
1587 | |||
1588 | udev = interface_to_usbdev(intf); | ||
1589 | |||
1590 | if (!(dec = kmalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) { | ||
1591 | printk("%s: couldn't allocate memory.\n", __FUNCTION__); | ||
1592 | return -ENOMEM; | ||
1593 | } | ||
1594 | |||
1595 | usb_set_intfdata(intf, (void *)dec); | ||
1596 | |||
1597 | memset(dec, 0, sizeof(struct ttusb_dec)); | ||
1598 | |||
1599 | switch (le16_to_cpu(id->idProduct)) { | ||
1600 | case 0x1006: | ||
1601 | ttusb_dec_set_model(dec, TTUSB_DEC3000S); | ||
1602 | break; | ||
1603 | |||
1604 | case 0x1008: | ||
1605 | ttusb_dec_set_model(dec, TTUSB_DEC2000T); | ||
1606 | break; | ||
1607 | |||
1608 | case 0x1009: | ||
1609 | ttusb_dec_set_model(dec, TTUSB_DEC2540T); | ||
1610 | break; | ||
1611 | } | ||
1612 | |||
1613 | dec->udev = udev; | ||
1614 | |||
1615 | if (ttusb_dec_init_usb(dec)) | ||
1616 | return 0; | ||
1617 | if (ttusb_dec_init_stb(dec)) { | ||
1618 | ttusb_dec_exit_usb(dec); | ||
1619 | return 0; | ||
1620 | } | ||
1621 | ttusb_dec_init_dvb(dec); | ||
1622 | |||
1623 | dec->adapter->priv = dec; | ||
1624 | switch (le16_to_cpu(id->idProduct)) { | ||
1625 | case 0x1006: | ||
1626 | dec->fe = ttusbdecfe_dvbs_attach(&fe_config); | ||
1627 | break; | ||
1628 | |||
1629 | case 0x1008: | ||
1630 | case 0x1009: | ||
1631 | dec->fe = ttusbdecfe_dvbt_attach(&fe_config); | ||
1632 | break; | ||
1633 | } | ||
1634 | |||
1635 | if (dec->fe == NULL) { | ||
1636 | printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n", | ||
1637 | le16_to_cpu(dec->udev->descriptor.idVendor), | ||
1638 | le16_to_cpu(dec->udev->descriptor.idProduct)); | ||
1639 | } else { | ||
1640 | if (dvb_register_frontend(dec->adapter, dec->fe)) { | ||
1641 | printk("budget-ci: Frontend registration failed!\n"); | ||
1642 | if (dec->fe->ops->release) | ||
1643 | dec->fe->ops->release(dec->fe); | ||
1644 | dec->fe = NULL; | ||
1645 | } | ||
1646 | } | ||
1647 | |||
1648 | ttusb_dec_init_v_pes(dec); | ||
1649 | ttusb_dec_init_filters(dec); | ||
1650 | ttusb_dec_init_tasklet(dec); | ||
1651 | |||
1652 | dec->active = 1; | ||
1653 | |||
1654 | ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN); | ||
1655 | |||
1656 | if(enable_rc) | ||
1657 | ttusb_init_rc(dec); | ||
1658 | |||
1659 | return 0; | ||
1660 | } | ||
1661 | |||
1662 | static void ttusb_dec_disconnect(struct usb_interface *intf) | ||
1663 | { | ||
1664 | struct ttusb_dec *dec = usb_get_intfdata(intf); | ||
1665 | |||
1666 | usb_set_intfdata(intf, NULL); | ||
1667 | |||
1668 | dprintk("%s\n", __FUNCTION__); | ||
1669 | |||
1670 | if (dec->active) { | ||
1671 | ttusb_dec_exit_tasklet(dec); | ||
1672 | ttusb_dec_exit_filters(dec); | ||
1673 | if(enable_rc) | ||
1674 | ttusb_dec_exit_rc(dec); | ||
1675 | ttusb_dec_exit_usb(dec); | ||
1676 | ttusb_dec_exit_dvb(dec); | ||
1677 | } | ||
1678 | |||
1679 | kfree(dec); | ||
1680 | } | ||
1681 | |||
1682 | static void ttusb_dec_set_model(struct ttusb_dec *dec, | ||
1683 | enum ttusb_dec_model model) | ||
1684 | { | ||
1685 | dec->model = model; | ||
1686 | |||
1687 | switch (model) { | ||
1688 | case TTUSB_DEC2000T: | ||
1689 | dec->model_name = "DEC2000-t"; | ||
1690 | dec->firmware_name = "dvb-ttusb-dec-2000t.fw"; | ||
1691 | break; | ||
1692 | |||
1693 | case TTUSB_DEC2540T: | ||
1694 | dec->model_name = "DEC2540-t"; | ||
1695 | dec->firmware_name = "dvb-ttusb-dec-2540t.fw"; | ||
1696 | break; | ||
1697 | |||
1698 | case TTUSB_DEC3000S: | ||
1699 | dec->model_name = "DEC3000-s"; | ||
1700 | dec->firmware_name = "dvb-ttusb-dec-3000s.fw"; | ||
1701 | break; | ||
1702 | } | ||
1703 | } | ||
1704 | |||
1705 | static struct usb_device_id ttusb_dec_table[] = { | ||
1706 | {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */ | ||
1707 | /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */ | ||
1708 | {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */ | ||
1709 | {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */ | ||
1710 | {} | ||
1711 | }; | ||
1712 | |||
1713 | static struct usb_driver ttusb_dec_driver = { | ||
1714 | .name = "ttusb-dec", | ||
1715 | .probe = ttusb_dec_probe, | ||
1716 | .disconnect = ttusb_dec_disconnect, | ||
1717 | .id_table = ttusb_dec_table, | ||
1718 | }; | ||
1719 | |||
1720 | static int __init ttusb_dec_init(void) | ||
1721 | { | ||
1722 | int result; | ||
1723 | |||
1724 | if ((result = usb_register(&ttusb_dec_driver)) < 0) { | ||
1725 | printk("%s: initialisation failed: error %d.\n", __FUNCTION__, | ||
1726 | result); | ||
1727 | return result; | ||
1728 | } | ||
1729 | |||
1730 | return 0; | ||
1731 | } | ||
1732 | |||
1733 | static void __exit ttusb_dec_exit(void) | ||
1734 | { | ||
1735 | usb_deregister(&ttusb_dec_driver); | ||
1736 | } | ||
1737 | |||
1738 | module_init(ttusb_dec_init); | ||
1739 | module_exit(ttusb_dec_exit); | ||
1740 | |||
1741 | MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>"); | ||
1742 | MODULE_DESCRIPTION(DRIVER_NAME); | ||
1743 | MODULE_LICENSE("GPL"); | ||
1744 | MODULE_DEVICE_TABLE(usb, ttusb_dec_table); | ||