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