?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[XFRM]: skb_cow_data() does not set proper owner for new skbs.
[linux-2.6/verdex.git] / drivers / media / dvb / ttusb-dec / ttusb_dec.c
blob505bdaff5a7eea16ff148ba87d9f74d7ea93043b
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 static 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 static 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);
Verdex Pro support