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

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