drivers/media/dvb/ttusb-dec/ttusb_dec.c

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