Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us