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