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