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