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