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