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