drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c

   1 /*
   2  * TTUSB DVB driver
   3  *
   4  * Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
   5  * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License as
   9  *      published by the Free Software Foundation; either version 2 of
  10  *      the License, or (at your option) any later version.
  11  */
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/wait.h>
  15 #include <linux/fs.h>
  16 #include <linux/module.h>
  17 #include <linux/usb.h>
  18 #include <linux/delay.h>
  19 #include <linux/time.h>
  20 #include <linux/errno.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/mutex.h>
  23 #include <linux/firmware.h>
  24
  25 #include "dvb_frontend.h"
  26 #include "dmxdev.h"
  27 #include "dvb_demux.h"
  28 #include "dvb_net.h"
  29 #include "ves1820.h"
  30 #include "cx22700.h"
  31 #include "tda1004x.h"
  32 #include "stv0299.h"
  33 #include "tda8083.h"
  34 #include "stv0297.h"
  35 #include "lnbp21.h"
  36
  37 #include <linux/dvb/frontend.h>
  38 #include <linux/dvb/dmx.h>
  39 #include <linux/pci.h>
  40
  41 /*
  42   TTUSB_HWSECTIONS:
  43     the DSP supports filtering in hardware, however, since the "muxstream"
  44     is a bit braindead (no matching channel masks or no matching filter mask),
  45     we won't support this - yet. it doesn't event support negative filters,
  46     so the best way is maybe to keep TTUSB_HWSECTIONS undef'd and just
  47     parse TS data. USB bandwidth will be a problem when having large
  48     datastreams, especially for dvb-net, but hey, that's not my problem.
  49
  50   TTUSB_DISEQC, TTUSB_TONE:
  51     let the STC do the diseqc/tone stuff. this isn't supported at least with
  52     my TTUSB, so let it undef'd unless you want to implement another
  53     frontend. never tested.
  54
  55   debug:
  56     define it to > 3 for really hardcore debugging. you probably don't want
  57     this unless the device doesn't load at all. > 2 for bandwidth statistics.
  58 */
  59
  60 static int debug;
  61 module_param(debug, int, 0644);
  62 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  63
  64 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  65
  66 #define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0)
  67
  68 #define ISO_BUF_COUNT      4
  69 #define FRAMES_PER_ISO_BUF 4
  70 #define ISO_FRAME_SIZE     912
  71 #define TTUSB_MAXCHANNEL   32
  72 #ifdef TTUSB_HWSECTIONS
  73 #define TTUSB_MAXFILTER    16   /* ??? */
  74 #endif
  75
  76 #define TTUSB_REV_2_2   0x22
  77 #define TTUSB_BUDGET_NAME "ttusb_stc_fw"
  78
  79 /**
  80  *  since we're casting (struct ttusb*) <-> (struct dvb_demux*) around
  81  *  the dvb_demux field must be the first in struct!!
  82  */
  83 struct ttusb {
  84         struct dvb_demux dvb_demux;
  85         struct dmxdev dmxdev;
  86         struct dvb_net dvbnet;
  87
  88         /* and one for USB access. */
  89         struct mutex semi2c;
  90         struct mutex semusb;
  91
  92         struct dvb_adapter adapter;
  93         struct usb_device *dev;
  94
  95         struct i2c_adapter i2c_adap;
  96
  97         int disconnecting;
  98         int iso_streaming;
  99
 100         unsigned int bulk_out_pipe;
 101         unsigned int bulk_in_pipe;
 102         unsigned int isoc_in_pipe;
 103
 104         void *iso_buffer;
 105         dma_addr_t iso_dma_handle;
 106
 107         struct urb *iso_urb[ISO_BUF_COUNT];
 108
 109         int running_feed_count;
 110         int last_channel;
 111         int last_filter;
 112
 113         u8 c;                   /* transaction counter, wraps around...  */
 114         fe_sec_tone_mode_t tone;
 115         fe_sec_voltage_t voltage;
 116
 117         int mux_state;          // 0..2 - MuxSyncWord, 3 - nMuxPacks,    4 - muxpack
 118         u8 mux_npacks;
 119         u8 muxpack[256 + 8];
 120         int muxpack_ptr, muxpack_len;
 121
 122         int insync;
 123
 124         int cc;                 /* MuxCounter - will increment on EVERY MUX PACKET */
 125         /* (including stuffing. yes. really.) */
 126
 127         u8 last_result[32];
 128
 129         int revision;
 130
 131         struct dvb_frontend* fe;
 132 };
 133
 134 /* ugly workaround ... don't know why it's necessary to read */
 135 /* all result codes. */
 136
 137 static int ttusb_cmd(struct ttusb *ttusb,
 138               const u8 * data, int len, int needresult)
 139 {
 140         int actual_len;
 141         int err;
 142         int i;
 143
 144         if (debug >= 3) {
 145                 printk(KERN_DEBUG ">");
 146                 for (i = 0; i < len; ++i)
 147                         printk(KERN_CONT " %02x", data[i]);
 148                 printk(KERN_CONT "\n");
 149         }
 150
 151         if (mutex_lock_interruptible(&ttusb->semusb) < 0)
 152                 return -EAGAIN;
 153
 154         err = usb_bulk_msg(ttusb->dev, ttusb->bulk_out_pipe,
 155                            (u8 *) data, len, &actual_len, 1000);
 156         if (err != 0) {
 157                 dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
 158                         __func__, err);
 159                 mutex_unlock(&ttusb->semusb);
 160                 return err;
 161         }
 162         if (actual_len != len) {
 163                 dprintk("%s: only wrote %d of %d bytes\n", __func__,
 164                         actual_len, len);
 165                 mutex_unlock(&ttusb->semusb);
 166                 return -1;
 167         }
 168
 169         err = usb_bulk_msg(ttusb->dev, ttusb->bulk_in_pipe,
 170                            ttusb->last_result, 32, &actual_len, 1000);
 171
 172         if (err != 0) {
 173                 printk("%s: failed, receive error %d\n", __func__,
 174                        err);
 175                 mutex_unlock(&ttusb->semusb);
 176                 return err;
 177         }
 178
 179         if (debug >= 3) {
 180                 actual_len = ttusb->last_result[3] + 4;
 181                 printk(KERN_DEBUG "<");
 182                 for (i = 0; i < actual_len; ++i)
 183                         printk(KERN_CONT " %02x", ttusb->last_result[i]);
 184                 printk(KERN_CONT "\n");
 185         }
 186
 187         if (!needresult)
 188                 mutex_unlock(&ttusb->semusb);
 189         return 0;
 190 }
 191
 192 static int ttusb_result(struct ttusb *ttusb, u8 * data, int len)
 193 {
 194         memcpy(data, ttusb->last_result, len);
 195         mutex_unlock(&ttusb->semusb);
 196         return 0;
 197 }
 198
 199 static int ttusb_i2c_msg(struct ttusb *ttusb,
 200                   u8 addr, u8 * snd_buf, u8 snd_len, u8 * rcv_buf,
 201                   u8 rcv_len)
 202 {
 203         u8 b[0x28];
 204         u8 id = ++ttusb->c;
 205         int i, err;
 206
 207         if (snd_len > 0x28 - 7 || rcv_len > 0x20 - 7)
 208                 return -EINVAL;
 209
 210         b[0] = 0xaa;
 211         b[1] = id;
 212         b[2] = 0x31;
 213         b[3] = snd_len + 3;
 214         b[4] = addr << 1;
 215         b[5] = snd_len;
 216         b[6] = rcv_len;
 217
 218         for (i = 0; i < snd_len; i++)
 219                 b[7 + i] = snd_buf[i];
 220
 221         err = ttusb_cmd(ttusb, b, snd_len + 7, 1);
 222
 223         if (err)
 224                 return -EREMOTEIO;
 225
 226         err = ttusb_result(ttusb, b, 0x20);
 227
 228         /* check if the i2c transaction was successful */
 229         if ((snd_len != b[5]) || (rcv_len != b[6])) return -EREMOTEIO;
 230
 231         if (rcv_len > 0) {
 232
 233                 if (err || b[0] != 0x55 || b[1] != id) {
 234                         dprintk
 235                             ("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ",
 236                              __func__, err, id);
 237                         return -EREMOTEIO;
 238                 }
 239
 240                 for (i = 0; i < rcv_len; i++)
 241                         rcv_buf[i] = b[7 + i];
 242         }
 243
 244         return rcv_len;
 245 }
 246
 247 static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
 248 {
 249         struct ttusb *ttusb = i2c_get_adapdata(adapter);
 250         int i = 0;
 251         int inc;
 252
 253         if (mutex_lock_interruptible(&ttusb->semi2c) < 0)
 254                 return -EAGAIN;
 255
 256         while (i < num) {
 257                 u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
 258                 int err;
 259
 260                 if (num > i + 1 && (msg[i + 1].flags & I2C_M_RD)) {
 261                         addr = msg[i].addr;
 262                         snd_buf = msg[i].buf;
 263                         snd_len = msg[i].len;
 264                         rcv_buf = msg[i + 1].buf;
 265                         rcv_len = msg[i + 1].len;
 266                         inc = 2;
 267                 } else {
 268                         addr = msg[i].addr;
 269                         snd_buf = msg[i].buf;
 270                         snd_len = msg[i].len;
 271                         rcv_buf = NULL;
 272                         rcv_len = 0;
 273                         inc = 1;
 274                 }
 275
 276                 err = ttusb_i2c_msg(ttusb, addr,
 277                                     snd_buf, snd_len, rcv_buf, rcv_len);
 278
 279                 if (err < rcv_len) {
 280                         dprintk("%s: i == %i\n", __func__, i);
 281                         break;
 282                 }
 283
 284                 i += inc;
 285         }
 286
 287         mutex_unlock(&ttusb->semi2c);
 288         return i;
 289 }
 290
 291 static int ttusb_boot_dsp(struct ttusb *ttusb)
 292 {
 293         const struct firmware *fw;
 294         int i, err;
 295         u8 b[40];
 296
 297         err = request_firmware(&fw, "ttusb-budget/dspbootcode.bin",
 298                                &ttusb->dev->dev);
 299         if (err) {
 300                 printk(KERN_ERR "ttusb-budget: failed to request firmware\n");
 301                 return err;
 302         }
 303
 304         /* BootBlock */
 305         b[0] = 0xaa;
 306         b[2] = 0x13;
 307         b[3] = 28;
 308
 309         /* upload dsp code in 32 byte steps (36 didn't work for me ...) */
 310         /* 32 is max packet size, no messages should be splitted. */
 311         for (i = 0; i < fw->size; i += 28) {
 312                 memcpy(&b[4], &fw->data[i], 28);
 313
 314                 b[1] = ++ttusb->c;
 315
 316                 err = ttusb_cmd(ttusb, b, 32, 0);
 317                 if (err)
 318                         goto done;
 319         }
 320
 321         /* last block ... */
 322         b[1] = ++ttusb->c;
 323         b[2] = 0x13;
 324         b[3] = 0;
 325
 326         err = ttusb_cmd(ttusb, b, 4, 0);
 327         if (err)
 328                 goto done;
 329
 330         /* BootEnd */
 331         b[1] = ++ttusb->c;
 332         b[2] = 0x14;
 333         b[3] = 0;
 334
 335         err = ttusb_cmd(ttusb, b, 4, 0);
 336
 337       done:
 338         release_firmware(fw);
 339         if (err) {
 340                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
 341                         __func__, err);
 342         }
 343
 344         return err;
 345 }
 346
 347 static int ttusb_set_channel(struct ttusb *ttusb, int chan_id, int filter_type,
 348                       int pid)
 349 {
 350         int err;
 351         /* SetChannel */
 352         u8 b[] = { 0xaa, ++ttusb->c, 0x22, 4, chan_id, filter_type,
 353                 (pid >> 8) & 0xff, pid & 0xff
 354         };
 355
 356         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 357         return err;
 358 }
 359
 360 static int ttusb_del_channel(struct ttusb *ttusb, int channel_id)
 361 {
 362         int err;
 363         /* DelChannel */
 364         u8 b[] = { 0xaa, ++ttusb->c, 0x23, 1, channel_id };
 365
 366         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 367         return err;
 368 }
 369
 370 #ifdef TTUSB_HWSECTIONS
 371 static int ttusb_set_filter(struct ttusb *ttusb, int filter_id,
 372                      int associated_chan, u8 filter[8], u8 mask[8])
 373 {
 374         int err;
 375         /* SetFilter */
 376         u8 b[] = { 0xaa, 0, 0x24, 0x1a, filter_id, associated_chan,
 377                 filter[0], filter[1], filter[2], filter[3],
 378                 filter[4], filter[5], filter[6], filter[7],
 379                 filter[8], filter[9], filter[10], filter[11],
 380                 mask[0], mask[1], mask[2], mask[3],
 381                 mask[4], mask[5], mask[6], mask[7],
 382                 mask[8], mask[9], mask[10], mask[11]
 383         };
 384
 385         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 386         return err;
 387 }
 388
 389 static int ttusb_del_filter(struct ttusb *ttusb, int filter_id)
 390 {
 391         int err;
 392         /* DelFilter */
 393         u8 b[] = { 0xaa, ++ttusb->c, 0x25, 1, filter_id };
 394
 395         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 396         return err;
 397 }
 398 #endif
 399
 400 static int ttusb_init_controller(struct ttusb *ttusb)
 401 {
 402         u8 b0[] = { 0xaa, ++ttusb->c, 0x15, 1, 0 };
 403         u8 b1[] = { 0xaa, ++ttusb->c, 0x15, 1, 1 };
 404         u8 b2[] = { 0xaa, ++ttusb->c, 0x32, 1, 0 };
 405         /* i2c write read: 5 bytes, addr 0x10, 0x02 bytes write, 1 bytes read. */
 406         u8 b3[] =
 407             { 0xaa, ++ttusb->c, 0x31, 5, 0x10, 0x02, 0x01, 0x00, 0x1e };
 408         u8 b4[] =
 409             { 0x55, ttusb->c, 0x31, 4, 0x10, 0x02, 0x01, 0x00, 0x1e };
 410
 411         u8 get_version[] = { 0xaa, ++ttusb->c, 0x17, 5, 0, 0, 0, 0, 0 };
 412         u8 get_dsp_version[0x20] =
 413             { 0xaa, ++ttusb->c, 0x26, 28, 0, 0, 0, 0, 0 };
 414         int err;
 415
 416         /* reset board */
 417         if ((err = ttusb_cmd(ttusb, b0, sizeof(b0), 0)))
 418                 return err;
 419
 420         /* reset board (again?) */
 421         if ((err = ttusb_cmd(ttusb, b1, sizeof(b1), 0)))
 422                 return err;
 423
 424         ttusb_boot_dsp(ttusb);
 425
 426         /* set i2c bit rate */
 427         if ((err = ttusb_cmd(ttusb, b2, sizeof(b2), 0)))
 428                 return err;
 429
 430         if ((err = ttusb_cmd(ttusb, b3, sizeof(b3), 1)))
 431                 return err;
 432
 433         err = ttusb_result(ttusb, b4, sizeof(b4));
 434
 435         if ((err = ttusb_cmd(ttusb, get_version, sizeof(get_version), 1)))
 436                 return err;
 437
 438         if ((err = ttusb_result(ttusb, get_version, sizeof(get_version))))
 439                 return err;
 440
 441         dprintk("%s: stc-version: %c%c%c%c%c\n", __func__,
 442                 get_version[4], get_version[5], get_version[6],
 443                 get_version[7], get_version[8]);
 444
 445         if (memcmp(get_version + 4, "V 0.0", 5) &&
 446             memcmp(get_version + 4, "V 1.1", 5) &&
 447             memcmp(get_version + 4, "V 2.1", 5) &&
 448             memcmp(get_version + 4, "V 2.2", 5)) {
 449                 printk
 450                     ("%s: unknown STC version %c%c%c%c%c, please report!\n",
 451                      __func__, get_version[4], get_version[5],
 452                      get_version[6], get_version[7], get_version[8]);
 453         }
 454
 455         ttusb->revision = ((get_version[6] - '0') << 4) |
 456                            (get_version[8] - '0');
 457
 458         err =
 459             ttusb_cmd(ttusb, get_dsp_version, sizeof(get_dsp_version), 1);
 460         if (err)
 461                 return err;
 462
 463         err =
 464             ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version));
 465         if (err)
 466                 return err;
 467         printk("%s: dsp-version: %c%c%c\n", __func__,
 468                get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]);
 469         return 0;
 470 }
 471
 472 #ifdef TTUSB_DISEQC
 473 static int ttusb_send_diseqc(struct dvb_frontend* fe,
 474                              const struct dvb_diseqc_master_cmd *cmd)
 475 {
 476         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
 477         u8 b[12] = { 0xaa, ++ttusb->c, 0x18 };
 478
 479         int err;
 480
 481         b[3] = 4 + 2 + cmd->msg_len;
 482         b[4] = 0xFF;            /* send diseqc master, not burst */
 483         b[5] = cmd->msg_len;
 484
 485         memcpy(b + 5, cmd->msg, cmd->msg_len);
 486
 487         /* Diseqc */
 488         if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) {
 489                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
 490                         __func__, err);
 491         }
 492
 493         return err;
 494 }
 495 #endif
 496
 497 static int ttusb_update_lnb(struct ttusb *ttusb)
 498 {
 499         u8 b[] = { 0xaa, ++ttusb->c, 0x16, 5, /*power: */ 1,
 500                 ttusb->voltage == SEC_VOLTAGE_18 ? 0 : 1,
 501                 ttusb->tone == SEC_TONE_ON ? 1 : 0, 1, 1
 502         };
 503         int err;
 504
 505         /* SetLNB */
 506         if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) {
 507                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
 508                         __func__, err);
 509         }
 510
 511         return err;
 512 }
 513
 514 static int ttusb_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 515 {
 516         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
 517
 518         ttusb->voltage = voltage;
 519         return ttusb_update_lnb(ttusb);
 520 }
 521
 522 #ifdef TTUSB_TONE
 523 static int ttusb_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 524 {
 525         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
 526
 527         ttusb->tone = tone;
 528         return ttusb_update_lnb(ttusb);
 529 }
 530 #endif
 531
 532
 533 #if 0
 534 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
 535 {
 536         u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
 537         int err, actual_len;
 538
 539         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 540         if (err) {
 541                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
 542                         __func__, err);
 543         }
 544 }
 545 #endif
 546
 547 /*****************************************************************************/
 548
 549 #ifdef TTUSB_HWSECTIONS
 550 static void ttusb_handle_ts_data(struct ttusb_channel *channel,
 551                                  const u8 * data, int len);
 552 static void ttusb_handle_sec_data(struct ttusb_channel *channel,
 553                                   const u8 * data, int len);
 554 #endif
 555
 556 static int numpkt, numts, numstuff, numsec, numinvalid;
 557 static unsigned long lastj;
 558
 559 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
 560                            int len)
 561 {
 562         u16 csum = 0, cc;
 563         int i;
 564         for (i = 0; i < len; i += 2)
 565                 csum ^= le16_to_cpup((__le16 *) (muxpack + i));
 566         if (csum) {
 567                 printk("%s: muxpack with incorrect checksum, ignoring\n",
 568                        __func__);
 569                 numinvalid++;
 570                 return;
 571         }
 572
 573         cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
 574         cc &= 0x7FFF;
 575         if ((cc != ttusb->cc) && (ttusb->cc != -1))
 576                 printk("%s: cc discontinuity (%d frames missing)\n",
 577                        __func__, (cc - ttusb->cc) & 0x7FFF);
 578         ttusb->cc = (cc + 1) & 0x7FFF;
 579         if (muxpack[0] & 0x80) {
 580 #ifdef TTUSB_HWSECTIONS
 581                 /* section data */
 582                 int pusi = muxpack[0] & 0x40;
 583                 int channel = muxpack[0] & 0x1F;
 584                 int payload = muxpack[1];
 585                 const u8 *data = muxpack + 2;
 586                 /* check offset flag */
 587                 if (muxpack[0] & 0x20)
 588                         data++;
 589
 590                 ttusb_handle_sec_data(ttusb->channel + channel, data,
 591                                       payload);
 592                 data += payload;
 593
 594                 if ((!!(ttusb->muxpack[0] & 0x20)) ^
 595                     !!(ttusb->muxpack[1] & 1))
 596                         data++;
 597 #warning TODO: pusi
 598                 printk("cc: %04x\n", (data[0] << 8) | data[1]);
 599 #endif
 600                 numsec++;
 601         } else if (muxpack[0] == 0x47) {
 602 #ifdef TTUSB_HWSECTIONS
 603                 /* we have TS data here! */
 604                 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
 605                 int channel;
 606                 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
 607                         if (ttusb->channel[channel].active
 608                             && (pid == ttusb->channel[channel].pid))
 609                                 ttusb_handle_ts_data(ttusb->channel +
 610                                                      channel, muxpack,
 611                                                      188);
 612 #endif
 613                 numts++;
 614                 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
 615         } else if (muxpack[0] != 0) {
 616                 numinvalid++;
 617                 printk("illegal muxpack type %02x\n", muxpack[0]);
 618         } else
 619                 numstuff++;
 620 }
 621
 622 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
 623 {
 624         int maxwork = 1024;
 625         while (len) {
 626                 if (!(maxwork--)) {
 627                         printk("%s: too much work\n", __func__);
 628                         break;
 629                 }
 630
 631                 switch (ttusb->mux_state) {
 632                 case 0:
 633                 case 1:
 634                 case 2:
 635                         len--;
 636                         if (*data++ == 0xAA)
 637                                 ++ttusb->mux_state;
 638                         else {
 639                                 ttusb->mux_state = 0;
 640                                 if (ttusb->insync) {
 641                                         dprintk("%s: %02x\n",
 642                                                 __func__, data[-1]);
 643                                         printk(KERN_INFO "%s: lost sync.\n",
 644                                                __func__);
 645                                         ttusb->insync = 0;
 646                                 }
 647                         }
 648                         break;
 649                 case 3:
 650                         ttusb->insync = 1;
 651                         len--;
 652                         ttusb->mux_npacks = *data++;
 653                         ++ttusb->mux_state;
 654                         ttusb->muxpack_ptr = 0;
 655                         /* maximum bytes, until we know the length */
 656                         ttusb->muxpack_len = 2;
 657                         break;
 658                 case 4:
 659                         {
 660                                 int avail;
 661                                 avail = len;
 662                                 if (avail >
 663                                     (ttusb->muxpack_len -
 664                                      ttusb->muxpack_ptr))
 665                                         avail =
 666                                             ttusb->muxpack_len -
 667                                             ttusb->muxpack_ptr;
 668                                 memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
 669                                        data, avail);
 670                                 ttusb->muxpack_ptr += avail;
 671                                 BUG_ON(ttusb->muxpack_ptr > 264);
 672                                 data += avail;
 673                                 len -= avail;
 674                                 /* determine length */
 675                                 if (ttusb->muxpack_ptr == 2) {
 676                                         if (ttusb->muxpack[0] & 0x80) {
 677                                                 ttusb->muxpack_len =
 678                                                     ttusb->muxpack[1] + 2;
 679                                                 if (ttusb->
 680                                                     muxpack[0] & 0x20)
 681                                                         ttusb->
 682                                                             muxpack_len++;
 683                                                 if ((!!
 684                                                      (ttusb->
 685                                                       muxpack[0] & 0x20)) ^
 686                                                     !!(ttusb->
 687                                                        muxpack[1] & 1))
 688                                                         ttusb->
 689                                                             muxpack_len++;
 690                                                 ttusb->muxpack_len += 4;
 691                                         } else if (ttusb->muxpack[0] ==
 692                                                    0x47)
 693                                                 ttusb->muxpack_len =
 694                                                     188 + 4;
 695                                         else if (ttusb->muxpack[0] == 0x00)
 696                                                 ttusb->muxpack_len =
 697                                                     ttusb->muxpack[1] + 2 +
 698                                                     4;
 699                                         else {
 700                                                 dprintk
 701                                                     ("%s: invalid state: first byte is %x\n",
 702                                                      __func__,
 703                                                      ttusb->muxpack[0]);
 704                                                 ttusb->mux_state = 0;
 705                                         }
 706                                 }
 707
 708                         /**
 709                          * if length is valid and we reached the end:
 710                          * goto next muxpack
 711                          */
 712                                 if ((ttusb->muxpack_ptr >= 2) &&
 713                                     (ttusb->muxpack_ptr ==
 714                                      ttusb->muxpack_len)) {
 715                                         ttusb_process_muxpack(ttusb,
 716                                                               ttusb->
 717                                                               muxpack,
 718                                                               ttusb->
 719                                                               muxpack_ptr);
 720                                         ttusb->muxpack_ptr = 0;
 721                                         /* maximum bytes, until we know the length */
 722                                         ttusb->muxpack_len = 2;
 723
 724                                 /**
 725                                  * no muxpacks left?
 726                                  * return to search-sync state
 727                                  */
 728                                         if (!ttusb->mux_npacks--) {
 729                                                 ttusb->mux_state = 0;
 730                                                 break;
 731                                         }
 732                                 }
 733                                 break;
 734                         }
 735                 default:
 736                         BUG();
 737                         break;
 738                 }
 739         }
 740 }
 741
 742 static void ttusb_iso_irq(struct urb *urb)
 743 {
 744         struct ttusb *ttusb = urb->context;
 745         struct usb_iso_packet_descriptor *d;
 746         u8 *data;
 747         int len, i;
 748
 749         if (!ttusb->iso_streaming)
 750                 return;
 751
 752 #if 0
 753         printk("%s: status %d, errcount == %d, length == %i\n",
 754                __func__,
 755                urb->status, urb->error_count, urb->actual_length);
 756 #endif
 757
 758         if (!urb->status) {
 759                 for (i = 0; i < urb->number_of_packets; ++i) {
 760                         numpkt++;
 761                         if (time_after_eq(jiffies, lastj + HZ)) {
 762                                 dprintk("frames/s: %lu (ts: %d, stuff %d, "
 763                                         "sec: %d, invalid: %d, all: %d)\n",
 764                                         numpkt * HZ / (jiffies - lastj),
 765                                         numts, numstuff, numsec, numinvalid,
 766                                         numts + numstuff + numsec + numinvalid);
 767                                 numts = numstuff = numsec = numinvalid = 0;
 768                                 lastj = jiffies;
 769                                 numpkt = 0;
 770                         }
 771                         d = &urb->iso_frame_desc[i];
 772                         data = urb->transfer_buffer + d->offset;
 773                         len = d->actual_length;
 774                         d->actual_length = 0;
 775                         d->status = 0;
 776                         ttusb_process_frame(ttusb, data, len);
 777                 }
 778         }
 779         usb_submit_urb(urb, GFP_ATOMIC);
 780 }
 781
 782 static void ttusb_free_iso_urbs(struct ttusb *ttusb)
 783 {
 784         int i;
 785
 786         for (i = 0; i < ISO_BUF_COUNT; i++)
 787                 if (ttusb->iso_urb[i])
 788                         usb_free_urb(ttusb->iso_urb[i]);
 789
 790         pci_free_consistent(NULL,
 791                             ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
 792                             ISO_BUF_COUNT, ttusb->iso_buffer,
 793                             ttusb->iso_dma_handle);
 794 }
 795
 796 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
 797 {
 798         int i;
 799
 800         ttusb->iso_buffer = pci_alloc_consistent(NULL,
 801                                                  ISO_FRAME_SIZE *
 802                                                  FRAMES_PER_ISO_BUF *
 803                                                  ISO_BUF_COUNT,
 804                                                  &ttusb->iso_dma_handle);
 805
 806         if (!ttusb->iso_buffer) {
 807                 dprintk("%s: pci_alloc_consistent - not enough memory\n",
 808                         __func__);
 809                 return -ENOMEM;
 810         }
 811
 812         memset(ttusb->iso_buffer, 0,
 813                ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT);
 814
 815         for (i = 0; i < ISO_BUF_COUNT; i++) {
 816                 struct urb *urb;
 817
 818                 if (!
 819                     (urb =
 820                      usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
 821                         ttusb_free_iso_urbs(ttusb);
 822                         return -ENOMEM;
 823                 }
 824
 825                 ttusb->iso_urb[i] = urb;
 826         }
 827
 828         return 0;
 829 }
 830
 831 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
 832 {
 833         int i;
 834
 835         for (i = 0; i < ISO_BUF_COUNT; i++)
 836                 usb_kill_urb(ttusb->iso_urb[i]);
 837
 838         ttusb->iso_streaming = 0;
 839 }
 840
 841 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
 842 {
 843         int i, j, err, buffer_offset = 0;
 844
 845         if (ttusb->iso_streaming) {
 846                 printk("%s: iso xfer already running!\n", __func__);
 847                 return 0;
 848         }
 849
 850         ttusb->cc = -1;
 851         ttusb->insync = 0;
 852         ttusb->mux_state = 0;
 853
 854         for (i = 0; i < ISO_BUF_COUNT; i++) {
 855                 int frame_offset = 0;
 856                 struct urb *urb = ttusb->iso_urb[i];
 857
 858                 urb->dev = ttusb->dev;
 859                 urb->context = ttusb;
 860                 urb->complete = ttusb_iso_irq;
 861                 urb->pipe = ttusb->isoc_in_pipe;
 862                 urb->transfer_flags = URB_ISO_ASAP;
 863                 urb->interval = 1;
 864                 urb->number_of_packets = FRAMES_PER_ISO_BUF;
 865                 urb->transfer_buffer_length =
 866                     ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
 867                 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
 868                 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
 869
 870                 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
 871                         urb->iso_frame_desc[j].offset = frame_offset;
 872                         urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
 873                         frame_offset += ISO_FRAME_SIZE;
 874                 }
 875         }
 876
 877         for (i = 0; i < ISO_BUF_COUNT; i++) {
 878                 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
 879                         ttusb_stop_iso_xfer(ttusb);
 880                         printk
 881                             ("%s: failed urb submission (%i: err = %i)!\n",
 882                              __func__, i, err);
 883                         return err;
 884                 }
 885         }
 886
 887         ttusb->iso_streaming = 1;
 888
 889         return 0;
 890 }
 891
 892 #ifdef TTUSB_HWSECTIONS
 893 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
 894                           int len)
 895 {
 896         dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
 897 }
 898
 899 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
 900                            int len)
 901 {
 902 //      struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
 903 #error TODO: handle ugly stuff
 904 //      dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
 905 }
 906 #endif
 907
 908 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 909 {
 910         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
 911         int feed_type = 1;
 912
 913         dprintk("ttusb_start_feed\n");
 914
 915         switch (dvbdmxfeed->type) {
 916         case DMX_TYPE_TS:
 917                 break;
 918         case DMX_TYPE_SEC:
 919                 break;
 920         default:
 921                 return -EINVAL;
 922         }
 923
 924         if (dvbdmxfeed->type == DMX_TYPE_TS) {
 925                 switch (dvbdmxfeed->pes_type) {
 926                 case DMX_TS_PES_VIDEO:
 927                 case DMX_TS_PES_AUDIO:
 928                 case DMX_TS_PES_TELETEXT:
 929                 case DMX_TS_PES_PCR:
 930                 case DMX_TS_PES_OTHER:
 931                         break;
 932                 default:
 933                         return -EINVAL;
 934                 }
 935         }
 936
 937 #ifdef TTUSB_HWSECTIONS
 938 #error TODO: allocate filters
 939         if (dvbdmxfeed->type == DMX_TYPE_TS) {
 940                 feed_type = 1;
 941         } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
 942                 feed_type = 2;
 943         }
 944 #endif
 945
 946         ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
 947
 948         if (0 == ttusb->running_feed_count++)
 949                 ttusb_start_iso_xfer(ttusb);
 950
 951         return 0;
 952 }
 953
 954 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 955 {
 956         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
 957
 958         ttusb_del_channel(ttusb, dvbdmxfeed->index);
 959
 960         if (--ttusb->running_feed_count == 0)
 961                 ttusb_stop_iso_xfer(ttusb);
 962
 963         return 0;
 964 }
 965
 966 static int ttusb_setup_interfaces(struct ttusb *ttusb)
 967 {
 968         usb_set_interface(ttusb->dev, 1, 1);
 969
 970         ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
 971         ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
 972         ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
 973
 974         return 0;
 975 }
 976
 977 #if 0
 978 static u8 stc_firmware[8192];
 979
 980 static int stc_open(struct inode *inode, struct file *file)
 981 {
 982         struct ttusb *ttusb = file->private_data;
 983         int addr;
 984
 985         for (addr = 0; addr < 8192; addr += 16) {
 986                 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
 987                 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
 988                               16);
 989         }
 990
 991         return 0;
 992 }
 993
 994 static ssize_t stc_read(struct file *file, char *buf, size_t count,
 995                  loff_t *offset)
 996 {
 997         return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
 998 }
 999
1000 static int stc_release(struct inode *inode, struct file *file)
1001 {
1002         return 0;
1003 }
1004
1005 static const struct file_operations stc_fops = {
1006         .owner = THIS_MODULE,
1007         .read = stc_read,
1008         .open = stc_open,
1009         .release = stc_release,
1010 };
1011 #endif
1012
1013 static u32 functionality(struct i2c_adapter *adapter)
1014 {
1015         return I2C_FUNC_I2C;
1016 }
1017
1018
1019
1020 static int alps_tdmb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1021 {
1022         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1023         u8 data[4];
1024         struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
1025         u32 div;
1026
1027         div = (params->frequency + 36166667) / 166667;
1028
1029         data[0] = (div >> 8) & 0x7f;
1030         data[1] = div & 0xff;
1031         data[2] = ((div >> 10) & 0x60) | 0x85;
1032         data[3] = params->frequency < 592000000 ? 0x40 : 0x80;
1033
1034         if (fe->ops.i2c_gate_ctrl)
1035                 fe->ops.i2c_gate_ctrl(fe, 1);
1036         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
1037         return 0;
1038 }
1039
1040 static struct cx22700_config alps_tdmb7_config = {
1041         .demod_address = 0x43,
1042 };
1043
1044
1045
1046
1047
1048 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
1049 {
1050         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1051         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
1052         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
1053         struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
1054
1055         // setup PLL configuration
1056         if (fe->ops.i2c_gate_ctrl)
1057                 fe->ops.i2c_gate_ctrl(fe, 1);
1058         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
1059         msleep(1);
1060
1061         // disable the mc44BC374c (do not check for errors)
1062         tuner_msg.addr = 0x65;
1063         tuner_msg.buf = disable_mc44BC374c;
1064         tuner_msg.len = sizeof(disable_mc44BC374c);
1065         if (fe->ops.i2c_gate_ctrl)
1066                 fe->ops.i2c_gate_ctrl(fe, 1);
1067         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1068                 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
1069         }
1070
1071         return 0;
1072 }
1073
1074 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1075 {
1076         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1077         u8 tuner_buf[4];
1078         struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) };
1079         int tuner_frequency = 0;
1080         u8 band, cp, filter;
1081
1082         // determine charge pump
1083         tuner_frequency = params->frequency + 36130000;
1084         if (tuner_frequency < 87000000) return -EINVAL;
1085         else if (tuner_frequency < 130000000) cp = 3;
1086         else if (tuner_frequency < 160000000) cp = 5;
1087         else if (tuner_frequency < 200000000) cp = 6;
1088         else if (tuner_frequency < 290000000) cp = 3;
1089         else if (tuner_frequency < 420000000) cp = 5;
1090         else if (tuner_frequency < 480000000) cp = 6;
1091         else if (tuner_frequency < 620000000) cp = 3;
1092         else if (tuner_frequency < 830000000) cp = 5;
1093         else if (tuner_frequency < 895000000) cp = 7;
1094         else return -EINVAL;
1095
1096         // determine band
1097         if (params->frequency < 49000000) return -EINVAL;
1098         else if (params->frequency < 159000000) band = 1;
1099         else if (params->frequency < 444000000) band = 2;
1100         else if (params->frequency < 861000000) band = 4;
1101         else return -EINVAL;
1102
1103         // setup PLL filter
1104         switch (params->u.ofdm.bandwidth) {
1105         case BANDWIDTH_6_MHZ:
1106                 tda1004x_writereg(fe, 0x0C, 0);
1107                 filter = 0;
1108                 break;
1109
1110         case BANDWIDTH_7_MHZ:
1111                 tda1004x_writereg(fe, 0x0C, 0);
1112                 filter = 0;
1113                 break;
1114
1115         case BANDWIDTH_8_MHZ:
1116                 tda1004x_writereg(fe, 0x0C, 0xFF);
1117                 filter = 1;
1118                 break;
1119
1120         default:
1121                 return -EINVAL;
1122         }
1123
1124         // calculate divisor
1125         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
1126         tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
1127
1128         // setup tuner buffer
1129         tuner_buf[0] = tuner_frequency >> 8;
1130         tuner_buf[1] = tuner_frequency & 0xff;
1131         tuner_buf[2] = 0xca;
1132         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1133
1134         if (fe->ops.i2c_gate_ctrl)
1135                 fe->ops.i2c_gate_ctrl(fe, 1);
1136         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
1137                 return -EIO;
1138
1139         msleep(1);
1140         return 0;
1141 }
1142
1143 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1144 {
1145         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1146
1147         return request_firmware(fw, name, &ttusb->dev->dev);
1148 }
1149
1150 static struct tda1004x_config philips_tdm1316l_config = {
1151
1152         .demod_address = 0x8,
1153         .invert = 1,
1154         .invert_oclk = 0,
1155         .request_firmware = philips_tdm1316l_request_firmware,
1156 };
1157
1158 static u8 alps_bsbe1_inittab[] = {
1159         0x01, 0x15,
1160         0x02, 0x30,
1161         0x03, 0x00,
1162         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1163         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1164         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1165         0x07, 0x00,             /* DAC LSB */
1166         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1167         0x09, 0x00,             /* FIFO */
1168         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1169         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1170         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1171         0x10, 0x3f,             // AGC2  0x3d
1172         0x11, 0x84,
1173         0x12, 0xb9,
1174         0x15, 0xc9,             // lock detector threshold
1175         0x16, 0x00,
1176         0x17, 0x00,
1177         0x18, 0x00,
1178         0x19, 0x00,
1179         0x1a, 0x00,
1180         0x1f, 0x50,
1181         0x20, 0x00,
1182         0x21, 0x00,
1183         0x22, 0x00,
1184         0x23, 0x00,
1185         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1186         0x29, 0x1e,             // 1/2 threshold
1187         0x2a, 0x14,             // 2/3 threshold
1188         0x2b, 0x0f,             // 3/4 threshold
1189         0x2c, 0x09,             // 5/6 threshold
1190         0x2d, 0x05,             // 7/8 threshold
1191         0x2e, 0x01,
1192         0x31, 0x1f,             // test all FECs
1193         0x32, 0x19,             // viterbi and synchro search
1194         0x33, 0xfc,             // rs control
1195         0x34, 0x93,             // error control
1196         0x0f, 0x92,
1197         0xff, 0xff
1198 };
1199
1200 static u8 alps_bsru6_inittab[] = {
1201         0x01, 0x15,
1202         0x02, 0x30,
1203         0x03, 0x00,
1204         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1205         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1206         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1207         0x07, 0x00,             /* DAC LSB */
1208         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1209         0x09, 0x00,             /* FIFO */
1210         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1211         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1212         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1213         0x10, 0x3f,             // AGC2  0x3d
1214         0x11, 0x84,
1215         0x12, 0xb9,
1216         0x15, 0xc9,             // lock detector threshold
1217         0x16, 0x00,
1218         0x17, 0x00,
1219         0x18, 0x00,
1220         0x19, 0x00,
1221         0x1a, 0x00,
1222         0x1f, 0x50,
1223         0x20, 0x00,
1224         0x21, 0x00,
1225         0x22, 0x00,
1226         0x23, 0x00,
1227         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1228         0x29, 0x1e,             // 1/2 threshold
1229         0x2a, 0x14,             // 2/3 threshold
1230         0x2b, 0x0f,             // 3/4 threshold
1231         0x2c, 0x09,             // 5/6 threshold
1232         0x2d, 0x05,             // 7/8 threshold
1233         0x2e, 0x01,
1234         0x31, 0x1f,             // test all FECs
1235         0x32, 0x19,             // viterbi and synchro search
1236         0x33, 0xfc,             // rs control
1237         0x34, 0x93,             // error control
1238         0x0f, 0x52,
1239         0xff, 0xff
1240 };
1241
1242 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
1243 {
1244         u8 aclk = 0;
1245         u8 bclk = 0;
1246
1247         if (srate < 1500000) {
1248                 aclk = 0xb7;
1249                 bclk = 0x47;
1250         } else if (srate < 3000000) {
1251                 aclk = 0xb7;
1252                 bclk = 0x4b;
1253         } else if (srate < 7000000) {
1254                 aclk = 0xb7;
1255                 bclk = 0x4f;
1256         } else if (srate < 14000000) {
1257                 aclk = 0xb7;
1258                 bclk = 0x53;
1259         } else if (srate < 30000000) {
1260                 aclk = 0xb6;
1261                 bclk = 0x53;
1262         } else if (srate < 45000000) {
1263                 aclk = 0xb4;
1264                 bclk = 0x51;
1265         }
1266
1267         stv0299_writereg(fe, 0x13, aclk);
1268         stv0299_writereg(fe, 0x14, bclk);
1269         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1270         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1271         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
1272
1273         return 0;
1274 }
1275
1276 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1277 {
1278         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1279         u8 buf[4];
1280         u32 div;
1281         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1282
1283         if ((params->frequency < 950000) || (params->frequency > 2150000))
1284                 return -EINVAL;
1285
1286         div = (params->frequency + (125 - 1)) / 125;    // round correctly
1287         buf[0] = (div >> 8) & 0x7f;
1288         buf[1] = div & 0xff;
1289         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1290         buf[3] = 0xC4;
1291
1292         if (params->frequency > 1530000)
1293                 buf[3] = 0xC0;
1294
1295         /* BSBE1 wants XCE bit set */
1296         if (ttusb->revision == TTUSB_REV_2_2)
1297                 buf[3] |= 0x20;
1298
1299         if (fe->ops.i2c_gate_ctrl)
1300                 fe->ops.i2c_gate_ctrl(fe, 1);
1301         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1302                 return -EIO;
1303
1304         return 0;
1305 }
1306
1307 static struct stv0299_config alps_stv0299_config = {
1308         .demod_address = 0x68,
1309         .inittab = alps_bsru6_inittab,
1310         .mclk = 88000000UL,
1311         .invert = 1,
1312         .skip_reinit = 0,
1313         .lock_output = STV0299_LOCKOUTPUT_1,
1314         .volt13_op0_op1 = STV0299_VOLT13_OP1,
1315         .min_delay_ms = 100,
1316         .set_symbol_rate = alps_stv0299_set_symbol_rate,
1317 };
1318
1319 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1320 {
1321         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1322         u8 buf[4];
1323         u32 div;
1324         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1325
1326         div = params->frequency / 125;
1327
1328         buf[0] = (div >> 8) & 0x7f;
1329         buf[1] = div & 0xff;
1330         buf[2] = 0x8e;
1331         buf[3] = 0x00;
1332
1333         if (fe->ops.i2c_gate_ctrl)
1334                 fe->ops.i2c_gate_ctrl(fe, 1);
1335         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1336                 return -EIO;
1337
1338         return 0;
1339 }
1340
1341 static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
1342
1343         .demod_address = 0x68,
1344 };
1345
1346 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1347 {
1348         struct ttusb* ttusb = fe->dvb->priv;
1349         u32 div;
1350         u8 data[4];
1351         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1352
1353         div = (params->frequency + 35937500 + 31250) / 62500;
1354
1355         data[0] = (div >> 8) & 0x7f;
1356         data[1] = div & 0xff;
1357         data[2] = 0x85 | ((div >> 10) & 0x60);
1358         data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1359
1360         if (fe->ops.i2c_gate_ctrl)
1361                 fe->ops.i2c_gate_ctrl(fe, 1);
1362         if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
1363                 return -EIO;
1364
1365         return 0;
1366 }
1367
1368
1369 static struct ves1820_config alps_tdbe2_config = {
1370         .demod_address = 0x09,
1371         .xin = 57840000UL,
1372         .invert = 1,
1373         .selagc = VES1820_SELAGC_SIGNAMPERR,
1374 };
1375
1376 static u8 read_pwm(struct ttusb* ttusb)
1377 {
1378         u8 b = 0xff;
1379         u8 pwm;
1380         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1381                                 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1382
1383         if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1384                 pwm = 0x48;
1385
1386         return pwm;
1387 }
1388
1389
1390 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1391 {
1392         struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
1393         u8 tuner_buf[5];
1394         struct i2c_msg tuner_msg = {.addr = 0x60,
1395                                     .flags = 0,
1396                                     .buf = tuner_buf,
1397                                     .len = sizeof(tuner_buf) };
1398         int tuner_frequency = 0;
1399         u8 band, cp, filter;
1400
1401         // determine charge pump
1402         tuner_frequency = params->frequency;
1403         if      (tuner_frequency <  87000000) {return -EINVAL;}
1404         else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
1405         else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
1406         else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
1407         else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
1408         else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
1409         else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
1410         else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
1411         else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
1412         else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
1413         else {return -EINVAL;}
1414
1415         // assume PLL filter should always be 8MHz for the moment.
1416         filter = 1;
1417
1418         // calculate divisor
1419         // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
1420         tuner_frequency = ((params->frequency + 36125000) / 62500);
1421
1422         // setup tuner buffer
1423         tuner_buf[0] = tuner_frequency >> 8;
1424         tuner_buf[1] = tuner_frequency & 0xff;
1425         tuner_buf[2] = 0xc8;
1426         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1427         tuner_buf[4] = 0x80;
1428
1429         if (fe->ops.i2c_gate_ctrl)
1430                 fe->ops.i2c_gate_ctrl(fe, 1);
1431         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1432                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
1433                 return -EIO;
1434         }
1435
1436         msleep(50);
1437
1438         if (fe->ops.i2c_gate_ctrl)
1439                 fe->ops.i2c_gate_ctrl(fe, 1);
1440         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1441                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
1442                 return -EIO;
1443         }
1444
1445         msleep(1);
1446
1447         return 0;
1448 }
1449
1450 static u8 dvbc_philips_tdm1316l_inittab[] = {
1451         0x80, 0x21,
1452         0x80, 0x20,
1453         0x81, 0x01,
1454         0x81, 0x00,
1455         0x00, 0x09,
1456         0x01, 0x69,
1457         0x03, 0x00,
1458         0x04, 0x00,
1459         0x07, 0x00,
1460         0x08, 0x00,
1461         0x20, 0x00,
1462         0x21, 0x40,
1463         0x22, 0x00,
1464         0x23, 0x00,
1465         0x24, 0x40,
1466         0x25, 0x88,
1467         0x30, 0xff,
1468         0x31, 0x00,
1469         0x32, 0xff,
1470         0x33, 0x00,
1471         0x34, 0x50,
1472         0x35, 0x7f,
1473         0x36, 0x00,
1474         0x37, 0x20,
1475         0x38, 0x00,
1476         0x40, 0x1c,
1477         0x41, 0xff,
1478         0x42, 0x29,
1479         0x43, 0x20,
1480         0x44, 0xff,
1481         0x45, 0x00,
1482         0x46, 0x00,
1483         0x49, 0x04,
1484         0x4a, 0xff,
1485         0x4b, 0x7f,
1486         0x52, 0x30,
1487         0x55, 0xae,
1488         0x56, 0x47,
1489         0x57, 0xe1,
1490         0x58, 0x3a,
1491         0x5a, 0x1e,
1492         0x5b, 0x34,
1493         0x60, 0x00,
1494         0x63, 0x00,
1495         0x64, 0x00,
1496         0x65, 0x00,
1497         0x66, 0x00,
1498         0x67, 0x00,
1499         0x68, 0x00,
1500         0x69, 0x00,
1501         0x6a, 0x02,
1502         0x6b, 0x00,
1503         0x70, 0xff,
1504         0x71, 0x00,
1505         0x72, 0x00,
1506         0x73, 0x00,
1507         0x74, 0x0c,
1508         0x80, 0x00,
1509         0x81, 0x00,
1510         0x82, 0x00,
1511         0x83, 0x00,
1512         0x84, 0x04,
1513         0x85, 0x80,
1514         0x86, 0x24,
1515         0x87, 0x78,
1516         0x88, 0x00,
1517         0x89, 0x00,
1518         0x90, 0x01,
1519         0x91, 0x01,
1520         0xa0, 0x00,
1521         0xa1, 0x00,
1522         0xa2, 0x00,
1523         0xb0, 0x91,
1524         0xb1, 0x0b,
1525         0xc0, 0x4b,
1526         0xc1, 0x00,
1527         0xc2, 0x00,
1528         0xd0, 0x00,
1529         0xd1, 0x00,
1530         0xd2, 0x00,
1531         0xd3, 0x00,
1532         0xd4, 0x00,
1533         0xd5, 0x00,
1534         0xde, 0x00,
1535         0xdf, 0x00,
1536         0x61, 0x38,
1537         0x62, 0x0a,
1538         0x53, 0x13,
1539         0x59, 0x08,
1540         0x55, 0x00,
1541         0x56, 0x40,
1542         0x57, 0x08,
1543         0x58, 0x3d,
1544         0x88, 0x10,
1545         0xa0, 0x00,
1546         0xa0, 0x00,
1547         0xa0, 0x00,
1548         0xa0, 0x04,
1549         0xff, 0xff,
1550 };
1551
1552 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1553         .demod_address = 0x1c,
1554         .inittab = dvbc_philips_tdm1316l_inittab,
1555         .invert = 0,
1556 };
1557
1558 static void frontend_init(struct ttusb* ttusb)
1559 {
1560         switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
1561         case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
1562                 // try the stv0299 based first
1563                 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
1564                 if (ttusb->fe != NULL) {
1565                         ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
1566
1567                         if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
1568                                 alps_stv0299_config.inittab = alps_bsbe1_inittab;
1569                                 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
1570                         } else { // ALPS BSRU6
1571                                 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1572                         }
1573                         break;
1574                 }
1575
1576                 // Grundig 29504-491
1577                 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
1578                 if (ttusb->fe != NULL) {
1579                         ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
1580                         ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1581                         break;
1582                 }
1583                 break;
1584
1585         case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
1586                 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
1587                 if (ttusb->fe != NULL) {
1588                         ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
1589                         break;
1590                 }
1591
1592                 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
1593                 if (ttusb->fe != NULL) {
1594                         ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1595                         break;
1596                 }
1597                 break;
1598
1599         case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
1600                 // try the ALPS TDMB7 first
1601                 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
1602                 if (ttusb->fe != NULL) {
1603                         ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
1604                         break;
1605                 }
1606
1607                 // Philips td1316
1608                 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
1609                 if (ttusb->fe != NULL) {
1610                         ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1611                         ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1612                         break;
1613                 }
1614                 break;
1615         }
1616
1617         if (ttusb->fe == NULL) {
1618                 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
1619                        le16_to_cpu(ttusb->dev->descriptor.idVendor),
1620                        le16_to_cpu(ttusb->dev->descriptor.idProduct));
1621         } else {
1622                 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
1623                         printk("dvb-ttusb-budget: Frontend registration failed!\n");
1624                         dvb_frontend_detach(ttusb->fe);
1625                         ttusb->fe = NULL;
1626                 }
1627         }
1628 }
1629
1630
1631
1632 static struct i2c_algorithm ttusb_dec_algo = {
1633         .master_xfer    = master_xfer,
1634         .functionality  = functionality,
1635 };
1636
1637 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1638 {
1639         struct usb_device *udev;
1640         struct ttusb *ttusb;
1641         int result;
1642
1643         dprintk("%s: TTUSB DVB connected\n", __func__);
1644
1645         udev = interface_to_usbdev(intf);
1646
1647         if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1648
1649         if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
1650                 return -ENOMEM;
1651
1652         ttusb->dev = udev;
1653         ttusb->c = 0;
1654         ttusb->mux_state = 0;
1655         mutex_init(&ttusb->semi2c);
1656
1657         mutex_lock(&ttusb->semi2c);
1658
1659         mutex_init(&ttusb->semusb);
1660
1661         ttusb_setup_interfaces(ttusb);
1662
1663         result = ttusb_alloc_iso_urbs(ttusb);
1664         if (result < 0) {
1665                 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__);
1666                 mutex_unlock(&ttusb->semi2c);
1667                 kfree(ttusb);
1668                 return result;
1669         }
1670
1671         if (ttusb_init_controller(ttusb))
1672                 printk("ttusb_init_controller: error\n");
1673
1674         mutex_unlock(&ttusb->semi2c);
1675
1676         result = dvb_register_adapter(&ttusb->adapter,
1677                                       "Technotrend/Hauppauge Nova-USB",
1678                                       THIS_MODULE, &udev->dev, adapter_nr);
1679         if (result < 0) {
1680                 ttusb_free_iso_urbs(ttusb);
1681                 kfree(ttusb);
1682                 return result;
1683         }
1684         ttusb->adapter.priv = ttusb;
1685
1686         /* i2c */
1687         memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
1688         strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
1689
1690         i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
1691
1692         ttusb->i2c_adap.algo              = &ttusb_dec_algo;
1693         ttusb->i2c_adap.algo_data         = NULL;
1694         ttusb->i2c_adap.dev.parent        = &udev->dev;
1695
1696         result = i2c_add_adapter(&ttusb->i2c_adap);
1697         if (result) {
1698                 dvb_unregister_adapter (&ttusb->adapter);
1699                 return result;
1700         }
1701
1702         memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1703
1704         ttusb->dvb_demux.dmx.capabilities =
1705             DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1706         ttusb->dvb_demux.priv = NULL;
1707 #ifdef TTUSB_HWSECTIONS
1708         ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1709 #else
1710         ttusb->dvb_demux.filternum = 32;
1711 #endif
1712         ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1713         ttusb->dvb_demux.start_feed = ttusb_start_feed;
1714         ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1715         ttusb->dvb_demux.write_to_decoder = NULL;
1716
1717         if ((result = dvb_dmx_init(&ttusb->dvb_demux)) < 0) {
1718                 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
1719                 i2c_del_adapter(&ttusb->i2c_adap);
1720                 dvb_unregister_adapter (&ttusb->adapter);
1721                 return -ENODEV;
1722         }
1723 //FIXME dmxdev (nur WAS?)
1724         ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1725         ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1726         ttusb->dmxdev.capabilities = 0;
1727
1728         if ((result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter)) < 0) {
1729                 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1730                        result);
1731                 dvb_dmx_release(&ttusb->dvb_demux);
1732                 i2c_del_adapter(&ttusb->i2c_adap);
1733                 dvb_unregister_adapter (&ttusb->adapter);
1734                 return -ENODEV;
1735         }
1736
1737         if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1738                 printk("ttusb_dvb: dvb_net_init failed!\n");
1739                 dvb_dmxdev_release(&ttusb->dmxdev);
1740                 dvb_dmx_release(&ttusb->dvb_demux);
1741                 i2c_del_adapter(&ttusb->i2c_adap);
1742                 dvb_unregister_adapter (&ttusb->adapter);
1743                 return -ENODEV;
1744         }
1745
1746         usb_set_intfdata(intf, (void *) ttusb);
1747
1748         frontend_init(ttusb);
1749
1750         return 0;
1751 }
1752
1753 static void ttusb_disconnect(struct usb_interface *intf)
1754 {
1755         struct ttusb *ttusb = usb_get_intfdata(intf);
1756
1757         usb_set_intfdata(intf, NULL);
1758
1759         ttusb->disconnecting = 1;
1760
1761         ttusb_stop_iso_xfer(ttusb);
1762
1763         ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1764         dvb_net_release(&ttusb->dvbnet);
1765         dvb_dmxdev_release(&ttusb->dmxdev);
1766         dvb_dmx_release(&ttusb->dvb_demux);
1767         if (ttusb->fe != NULL) {
1768                 dvb_unregister_frontend(ttusb->fe);
1769                 dvb_frontend_detach(ttusb->fe);
1770         }
1771         i2c_del_adapter(&ttusb->i2c_adap);
1772         dvb_unregister_adapter(&ttusb->adapter);
1773
1774         ttusb_free_iso_urbs(ttusb);
1775
1776         kfree(ttusb);
1777
1778         dprintk("%s: TTUSB DVB disconnected\n", __func__);
1779 }
1780
1781 static struct usb_device_id ttusb_table[] = {
1782         {USB_DEVICE(0xb48, 0x1003)},
1783         {USB_DEVICE(0xb48, 0x1004)},
1784         {USB_DEVICE(0xb48, 0x1005)},
1785         {}
1786 };
1787
1788 MODULE_DEVICE_TABLE(usb, ttusb_table);
1789
1790 static struct usb_driver ttusb_driver = {
1791       .name             = "ttusb",
1792       .probe            = ttusb_probe,
1793       .disconnect       = ttusb_disconnect,
1794       .id_table         = ttusb_table,
1795 };
1796
1797 static int __init ttusb_init(void)
1798 {
1799         int err;
1800
1801         if ((err = usb_register(&ttusb_driver)) < 0) {
1802                 printk("%s: usb_register failed! Error number %d",
1803                        __FILE__, err);
1804                 return err;
1805         }
1806
1807         return 0;
1808 }
1809
1810 static void __exit ttusb_exit(void)
1811 {
1812         usb_deregister(&ttusb_driver);
1813 }
1814
1815 module_init(ttusb_init);
1816 module_exit(ttusb_exit);
1817
1818 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1819 MODULE_DESCRIPTION("TTUSB DVB Driver");
1820 MODULE_LICENSE("GPL");
1821 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");