Merge master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb
[sfrench/cifs-2.6.git] / drivers / media / dvb / ttusb-dec / ttusb_dec.c
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, struct pt_regs *regs)
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, struct pt_regs *ptregs)
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                 if (dec->iso_urb[i])
1139                         usb_free_urb(dec->iso_urb[i]);
1140
1141         pci_free_consistent(NULL,
1142                             ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1143                                               ISO_BUF_COUNT),
1144                             dec->iso_buffer, dec->iso_dma_handle);
1145 }
1146
1147 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1148 {
1149         int i;
1150
1151         dprintk("%s\n", __FUNCTION__);
1152
1153         dec->iso_buffer = pci_alloc_consistent(NULL,
1154                                                ISO_FRAME_SIZE *
1155                                                (FRAMES_PER_ISO_BUF *
1156                                                 ISO_BUF_COUNT),
1157                                                &dec->iso_dma_handle);
1158
1159         memset(dec->iso_buffer, 0,
1160                ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT));
1161
1162         for (i = 0; i < ISO_BUF_COUNT; i++) {
1163                 struct urb *urb;
1164
1165                 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1166                         ttusb_dec_free_iso_urbs(dec);
1167                         return -ENOMEM;
1168                 }
1169
1170                 dec->iso_urb[i] = urb;
1171         }
1172
1173         ttusb_dec_setup_urbs(dec);
1174
1175         return 0;
1176 }
1177
1178 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1179 {
1180         spin_lock_init(&dec->urb_frame_list_lock);
1181         INIT_LIST_HEAD(&dec->urb_frame_list);
1182         tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1183                      (unsigned long)dec);
1184 }
1185
1186 static int ttusb_init_rc( struct ttusb_dec *dec)
1187 {
1188         struct input_dev *input_dev;
1189         u8 b[] = { 0x00, 0x01 };
1190         int i;
1191
1192         usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1193         strlcpy(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1194
1195         dec->rc_input_dev = input_dev = input_allocate_device();
1196         if (!input_dev)
1197                 return -ENOMEM;
1198
1199         input_dev->name = "ttusb_dec remote control";
1200         input_dev->phys = dec->rc_phys;
1201         input_dev->evbit[0] = BIT(EV_KEY);
1202         input_dev->keycodesize = sizeof(u16);
1203         input_dev->keycodemax = 0x1a;
1204         input_dev->keycode = rc_keys;
1205
1206         for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1207                   set_bit(rc_keys[i], input_dev->keybit);
1208
1209         input_register_device(input_dev);
1210
1211         if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1212                 printk("%s: usb_submit_urb failed\n",__FUNCTION__);
1213         /* enable irq pipe */
1214         ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1215
1216         return 0;
1217 }
1218
1219 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1220 {
1221         dprintk("%s\n", __FUNCTION__);
1222
1223         dec->v_pes[0] = 0x00;
1224         dec->v_pes[1] = 0x00;
1225         dec->v_pes[2] = 0x01;
1226         dec->v_pes[3] = 0xe0;
1227 }
1228
1229 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1230 {
1231         dprintk("%s\n", __FUNCTION__);
1232
1233         mutex_init(&dec->usb_mutex);
1234         mutex_init(&dec->iso_mutex);
1235
1236         dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1237         dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1238         dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1239         dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1240         dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1241
1242         if(enable_rc) {
1243                 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1244                 if(!dec->irq_urb) {
1245                         return -ENOMEM;
1246                 }
1247                 dec->irq_buffer = usb_buffer_alloc(dec->udev,IRQ_PACKET_SIZE,
1248                                         SLAB_ATOMIC, &dec->irq_dma_handle);
1249                 if(!dec->irq_buffer) {
1250                         return -ENOMEM;
1251                 }
1252                 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1253                                  dec->irq_buffer, IRQ_PACKET_SIZE,
1254                                  ttusb_dec_handle_irq, dec, 1);
1255                 dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1256                 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1257         }
1258
1259         return ttusb_dec_alloc_iso_urbs(dec);
1260 }
1261
1262 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1263 {
1264         int i, j, actual_len, result, size, trans_count;
1265         u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1266                     0x00, 0x00, 0x00, 0x00,
1267                     0x61, 0x00 };
1268         u8 b1[] = { 0x61 };
1269         u8 *b;
1270         char idstring[21];
1271         u8 *firmware = NULL;
1272         size_t firmware_size = 0;
1273         u16 firmware_csum = 0;
1274         u16 firmware_csum_ns;
1275         u32 firmware_size_nl;
1276         u32 crc32_csum, crc32_check, tmp;
1277         const struct firmware *fw_entry = NULL;
1278
1279         dprintk("%s\n", __FUNCTION__);
1280
1281         if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
1282                 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1283                        __FUNCTION__, dec->firmware_name);
1284                 return 1;
1285         }
1286
1287         firmware = fw_entry->data;
1288         firmware_size = fw_entry->size;
1289
1290         if (firmware_size < 60) {
1291                 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1292                         __FUNCTION__, firmware_size);
1293                 release_firmware(fw_entry);
1294                 return -1;
1295         }
1296
1297         /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1298            at offset 56 of file, so use it to check if the firmware file is
1299            valid. */
1300         crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1301         memcpy(&tmp, &firmware[56], 4);
1302         crc32_check = htonl(tmp);
1303         if (crc32_csum != crc32_check) {
1304                 printk("%s: crc32 check of DSP code failed (calculated "
1305                        "0x%08x != 0x%08x in file), file invalid.\n",
1306                         __FUNCTION__, crc32_csum, crc32_check);
1307                 release_firmware(fw_entry);
1308                 return -1;
1309         }
1310         memcpy(idstring, &firmware[36], 20);
1311         idstring[20] = '\0';
1312         printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1313
1314         firmware_size_nl = htonl(firmware_size);
1315         memcpy(b0, &firmware_size_nl, 4);
1316         firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1317         firmware_csum_ns = htons(firmware_csum);
1318         memcpy(&b0[6], &firmware_csum_ns, 2);
1319
1320         result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1321
1322         if (result) {
1323                 release_firmware(fw_entry);
1324                 return result;
1325         }
1326
1327         trans_count = 0;
1328         j = 0;
1329
1330         b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1331         if (b == NULL) {
1332                 release_firmware(fw_entry);
1333                 return -ENOMEM;
1334         }
1335
1336         for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1337                 size = firmware_size - i;
1338                 if (size > COMMAND_PACKET_SIZE)
1339                         size = COMMAND_PACKET_SIZE;
1340
1341                 b[j + 0] = 0xaa;
1342                 b[j + 1] = trans_count++;
1343                 b[j + 2] = 0xf0;
1344                 b[j + 3] = size;
1345                 memcpy(&b[j + 4], &firmware[i], size);
1346
1347                 j += COMMAND_PACKET_SIZE + 4;
1348
1349                 if (j >= ARM_PACKET_SIZE) {
1350                         result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1351                                               ARM_PACKET_SIZE, &actual_len,
1352                                               100);
1353                         j = 0;
1354                 } else if (size < COMMAND_PACKET_SIZE) {
1355                         result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1356                                               j - COMMAND_PACKET_SIZE + size,
1357                                               &actual_len, 100);
1358                 }
1359         }
1360
1361         result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1362
1363         release_firmware(fw_entry);
1364         kfree(b);
1365
1366         return result;
1367 }
1368
1369 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1370 {
1371         int result;
1372         unsigned int mode, model, version;
1373
1374         dprintk("%s\n", __FUNCTION__);
1375
1376         result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1377
1378         if (!result) {
1379                 if (!mode) {
1380                         if (version == 0xABCDEFAB)
1381                                 printk(KERN_INFO "ttusb_dec: no version "
1382                                        "info in Firmware\n");
1383                         else
1384                                 printk(KERN_INFO "ttusb_dec: Firmware "
1385                                        "%x.%02x%c%c\n",
1386                                        version >> 24, (version >> 16) & 0xff,
1387                                        (version >> 8) & 0xff, version & 0xff);
1388
1389                         result = ttusb_dec_boot_dsp(dec);
1390                         if (result)
1391                                 return result;
1392                         else
1393                                 return 1;
1394                 } else {
1395                         /* We can't trust the USB IDs that some firmwares
1396                            give the box */
1397                         switch (model) {
1398                         case 0x00070001:
1399                         case 0x00070008:
1400                         case 0x0007000c:
1401                                 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1402                                 break;
1403                         case 0x00070009:
1404                         case 0x00070013:
1405                                 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1406                                 break;
1407                         case 0x00070011:
1408                                 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1409                                 break;
1410                         default:
1411                                 printk(KERN_ERR "%s: unknown model returned "
1412                                        "by firmware (%08x) - please report\n",
1413                                        __FUNCTION__, model);
1414                                 return -1;
1415                                 break;
1416                         }
1417
1418                         if (version >= 0x01770000)
1419                                 dec->can_playback = 1;
1420
1421                         return 0;
1422                 }
1423         }
1424         else
1425                 return result;
1426 }
1427
1428 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1429 {
1430         int result;
1431
1432         dprintk("%s\n", __FUNCTION__);
1433
1434         if ((result = dvb_register_adapter(&dec->adapter,
1435                                            dec->model_name, THIS_MODULE, &dec->udev->dev)) < 0) {
1436                 printk("%s: dvb_register_adapter failed: error %d\n",
1437                        __FUNCTION__, result);
1438
1439                 return result;
1440         }
1441
1442         dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1443
1444         dec->demux.priv = (void *)dec;
1445         dec->demux.filternum = 31;
1446         dec->demux.feednum = 31;
1447         dec->demux.start_feed = ttusb_dec_start_feed;
1448         dec->demux.stop_feed = ttusb_dec_stop_feed;
1449         dec->demux.write_to_decoder = NULL;
1450
1451         if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1452                 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1453                        result);
1454
1455                 dvb_unregister_adapter(&dec->adapter);
1456
1457                 return result;
1458         }
1459
1460         dec->dmxdev.filternum = 32;
1461         dec->dmxdev.demux = &dec->demux.dmx;
1462         dec->dmxdev.capabilities = 0;
1463
1464         if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1465                 printk("%s: dvb_dmxdev_init failed: error %d\n",
1466                        __FUNCTION__, result);
1467
1468                 dvb_dmx_release(&dec->demux);
1469                 dvb_unregister_adapter(&dec->adapter);
1470
1471                 return result;
1472         }
1473
1474         dec->frontend.source = DMX_FRONTEND_0;
1475
1476         if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1477                                                   &dec->frontend)) < 0) {
1478                 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1479                        result);
1480
1481                 dvb_dmxdev_release(&dec->dmxdev);
1482                 dvb_dmx_release(&dec->demux);
1483                 dvb_unregister_adapter(&dec->adapter);
1484
1485                 return result;
1486         }
1487
1488         if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1489                                                       &dec->frontend)) < 0) {
1490                 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1491                        result);
1492
1493                 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1494                 dvb_dmxdev_release(&dec->dmxdev);
1495                 dvb_dmx_release(&dec->demux);
1496                 dvb_unregister_adapter(&dec->adapter);
1497
1498                 return result;
1499         }
1500
1501         dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1502
1503         return 0;
1504 }
1505
1506 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1507 {
1508         dprintk("%s\n", __FUNCTION__);
1509
1510         dvb_net_release(&dec->dvb_net);
1511         dec->demux.dmx.close(&dec->demux.dmx);
1512         dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1513         dvb_dmxdev_release(&dec->dmxdev);
1514         dvb_dmx_release(&dec->demux);
1515         if (dec->fe) {
1516                 dvb_unregister_frontend(dec->fe);
1517                 if (dec->fe->ops.release)
1518                         dec->fe->ops.release(dec->fe);
1519         }
1520         dvb_unregister_adapter(&dec->adapter);
1521 }
1522
1523 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1524 {
1525
1526         dprintk("%s\n", __FUNCTION__);
1527         /* we have to check whether the irq URB is already submitted.
1528           * As the irq is submitted after the interface is changed,
1529           * this is the best method i figured out.
1530           * Any others?*/
1531         if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1532                 usb_kill_urb(dec->irq_urb);
1533
1534         usb_free_urb(dec->irq_urb);
1535
1536         usb_buffer_free(dec->udev,IRQ_PACKET_SIZE,
1537                            dec->irq_buffer, dec->irq_dma_handle);
1538
1539         if (dec->rc_input_dev) {
1540                 input_unregister_device(dec->rc_input_dev);
1541                 dec->rc_input_dev = NULL;
1542         }
1543 }
1544
1545
1546 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1547 {
1548         int i;
1549
1550         dprintk("%s\n", __FUNCTION__);
1551
1552         dec->iso_stream_count = 0;
1553
1554         for (i = 0; i < ISO_BUF_COUNT; i++)
1555                 usb_kill_urb(dec->iso_urb[i]);
1556
1557         ttusb_dec_free_iso_urbs(dec);
1558 }
1559
1560 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1561 {
1562         struct list_head *item;
1563         struct urb_frame *frame;
1564
1565         tasklet_kill(&dec->urb_tasklet);
1566
1567         while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1568                 frame = list_entry(item, struct urb_frame, urb_frame_list);
1569                 list_del(&frame->urb_frame_list);
1570                 kfree(frame);
1571         }
1572 }
1573
1574 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1575 {
1576         INIT_LIST_HEAD(&dec->filter_info_list);
1577         spin_lock_init(&dec->filter_info_list_lock);
1578 }
1579
1580 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1581 {
1582         struct list_head *item;
1583         struct filter_info *finfo;
1584
1585         while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1586                 finfo = list_entry(item, struct filter_info, filter_info_list);
1587                 list_del(&finfo->filter_info_list);
1588                 kfree(finfo);
1589         }
1590 }
1591
1592 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1593                            int param_length, const u8 params[],
1594                            int *result_length, u8 cmd_result[])
1595 {
1596         struct ttusb_dec* dec = fe->dvb->priv;
1597         return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1598 }
1599
1600 static struct ttusbdecfe_config fe_config = {
1601         .send_command = fe_send_command
1602 };
1603
1604 static int ttusb_dec_probe(struct usb_interface *intf,
1605                            const struct usb_device_id *id)
1606 {
1607         struct usb_device *udev;
1608         struct ttusb_dec *dec;
1609
1610         dprintk("%s\n", __FUNCTION__);
1611
1612         udev = interface_to_usbdev(intf);
1613
1614         if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1615                 printk("%s: couldn't allocate memory.\n", __FUNCTION__);
1616                 return -ENOMEM;
1617         }
1618
1619         usb_set_intfdata(intf, (void *)dec);
1620
1621         switch (le16_to_cpu(id->idProduct)) {
1622         case 0x1006:
1623                 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1624                 break;
1625
1626         case 0x1008:
1627                 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1628                 break;
1629
1630         case 0x1009:
1631                 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1632                 break;
1633         }
1634
1635         dec->udev = udev;
1636
1637         if (ttusb_dec_init_usb(dec))
1638                 return 0;
1639         if (ttusb_dec_init_stb(dec)) {
1640                 ttusb_dec_exit_usb(dec);
1641                 return 0;
1642         }
1643         ttusb_dec_init_dvb(dec);
1644
1645         dec->adapter.priv = dec;
1646         switch (le16_to_cpu(id->idProduct)) {
1647         case 0x1006:
1648                 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1649                 break;
1650
1651         case 0x1008:
1652         case 0x1009:
1653                 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1654                 break;
1655         }
1656
1657         if (dec->fe == NULL) {
1658                 printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n",
1659                        le16_to_cpu(dec->udev->descriptor.idVendor),
1660                        le16_to_cpu(dec->udev->descriptor.idProduct));
1661         } else {
1662                 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1663                         printk("budget-ci: Frontend registration failed!\n");
1664                         if (dec->fe->ops.release)
1665                                 dec->fe->ops.release(dec->fe);
1666                         dec->fe = NULL;
1667                 }
1668         }
1669
1670         ttusb_dec_init_v_pes(dec);
1671         ttusb_dec_init_filters(dec);
1672         ttusb_dec_init_tasklet(dec);
1673
1674         dec->active = 1;
1675
1676         ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1677
1678         if (enable_rc)
1679                 ttusb_init_rc(dec);
1680
1681         return 0;
1682 }
1683
1684 static void ttusb_dec_disconnect(struct usb_interface *intf)
1685 {
1686         struct ttusb_dec *dec = usb_get_intfdata(intf);
1687
1688         usb_set_intfdata(intf, NULL);
1689
1690         dprintk("%s\n", __FUNCTION__);
1691
1692         if (dec->active) {
1693                 ttusb_dec_exit_tasklet(dec);
1694                 ttusb_dec_exit_filters(dec);
1695                 if(enable_rc)
1696                         ttusb_dec_exit_rc(dec);
1697                 ttusb_dec_exit_usb(dec);
1698                 ttusb_dec_exit_dvb(dec);
1699         }
1700
1701         kfree(dec);
1702 }
1703
1704 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1705                                 enum ttusb_dec_model model)
1706 {
1707         dec->model = model;
1708
1709         switch (model) {
1710         case TTUSB_DEC2000T:
1711                 dec->model_name = "DEC2000-t";
1712                 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1713                 break;
1714
1715         case TTUSB_DEC2540T:
1716                 dec->model_name = "DEC2540-t";
1717                 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1718                 break;
1719
1720         case TTUSB_DEC3000S:
1721                 dec->model_name = "DEC3000-s";
1722                 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1723                 break;
1724         }
1725 }
1726
1727 static struct usb_device_id ttusb_dec_table[] = {
1728         {USB_DEVICE(0x0b48, 0x1006)},   /* DEC3000-s */
1729         /*{USB_DEVICE(0x0b48, 0x1007)},    Unconfirmed */
1730         {USB_DEVICE(0x0b48, 0x1008)},   /* DEC2000-t */
1731         {USB_DEVICE(0x0b48, 0x1009)},   /* DEC2540-t */
1732         {}
1733 };
1734
1735 static struct usb_driver ttusb_dec_driver = {
1736         .name           = "ttusb-dec",
1737         .probe          = ttusb_dec_probe,
1738         .disconnect     = ttusb_dec_disconnect,
1739         .id_table       = ttusb_dec_table,
1740 };
1741
1742 static int __init ttusb_dec_init(void)
1743 {
1744         int result;
1745
1746         if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1747                 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1748                        result);
1749                 return result;
1750         }
1751
1752         return 0;
1753 }
1754
1755 static void __exit ttusb_dec_exit(void)
1756 {
1757         usb_deregister(&ttusb_dec_driver);
1758 }
1759
1760 module_init(ttusb_dec_init);
1761 module_exit(ttusb_dec_exit);
1762
1763 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1764 MODULE_DESCRIPTION(DRIVER_NAME);
1765 MODULE_LICENSE("GPL");
1766 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);