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