kernel/drivers/media/usb/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         enum fe_sec_tone_mode tone;
 115         enum fe_sec_voltage 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,
 515                              enum fe_sec_voltage voltage)
 516 {
 517         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
 518
 519         ttusb->voltage = voltage;
 520         return ttusb_update_lnb(ttusb);
 521 }
 522
 523 #ifdef TTUSB_TONE
 524 static int ttusb_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
 525 {
 526         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
 527
 528         ttusb->tone = tone;
 529         return ttusb_update_lnb(ttusb);
 530 }
 531 #endif
 532
 533
 534 #if 0
 535 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
 536 {
 537         u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
 538         int err, actual_len;
 539
 540         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
 541         if (err) {
 542                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
 543                         __func__, err);
 544         }
 545 }
 546 #endif
 547
 548 /*****************************************************************************/
 549
 550 #ifdef TTUSB_HWSECTIONS
 551 static void ttusb_handle_ts_data(struct ttusb_channel *channel,
 552                                  const u8 * data, int len);
 553 static void ttusb_handle_sec_data(struct ttusb_channel *channel,
 554                                   const u8 * data, int len);
 555 #endif
 556
 557 static int numpkt, numts, numstuff, numsec, numinvalid;
 558 static unsigned long lastj;
 559
 560 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
 561                            int len)
 562 {
 563         u16 csum = 0, cc;
 564         int i;
 565
 566         if (len < 4 || len & 0x1) {
 567                 pr_warn("%s: muxpack has invalid len %d\n", __func__, len);
 568                 numinvalid++;
 569                 return;
 570         }
 571
 572         for (i = 0; i < len; i += 2)
 573                 csum ^= le16_to_cpup((__le16 *) (muxpack + i));
 574         if (csum) {
 575                 printk("%s: muxpack with incorrect checksum, ignoring\n",
 576                        __func__);
 577                 numinvalid++;
 578                 return;
 579         }
 580
 581         cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
 582         cc &= 0x7FFF;
 583         if ((cc != ttusb->cc) && (ttusb->cc != -1))
 584                 printk("%s: cc discontinuity (%d frames missing)\n",
 585                        __func__, (cc - ttusb->cc) & 0x7FFF);
 586         ttusb->cc = (cc + 1) & 0x7FFF;
 587         if (muxpack[0] & 0x80) {
 588 #ifdef TTUSB_HWSECTIONS
 589                 /* section data */
 590                 int pusi = muxpack[0] & 0x40;
 591                 int channel = muxpack[0] & 0x1F;
 592                 int payload = muxpack[1];
 593                 const u8 *data = muxpack + 2;
 594                 /* check offset flag */
 595                 if (muxpack[0] & 0x20)
 596                         data++;
 597
 598                 ttusb_handle_sec_data(ttusb->channel + channel, data,
 599                                       payload);
 600                 data += payload;
 601
 602                 if ((!!(ttusb->muxpack[0] & 0x20)) ^
 603                     !!(ttusb->muxpack[1] & 1))
 604                         data++;
 605 #warning TODO: pusi
 606                 printk("cc: %04x\n", (data[0] << 8) | data[1]);
 607 #endif
 608                 numsec++;
 609         } else if (muxpack[0] == 0x47) {
 610 #ifdef TTUSB_HWSECTIONS
 611                 /* we have TS data here! */
 612                 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
 613                 int channel;
 614                 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
 615                         if (ttusb->channel[channel].active
 616                             && (pid == ttusb->channel[channel].pid))
 617                                 ttusb_handle_ts_data(ttusb->channel +
 618                                                      channel, muxpack,
 619                                                      188);
 620 #endif
 621                 numts++;
 622                 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
 623         } else if (muxpack[0] != 0) {
 624                 numinvalid++;
 625                 printk("illegal muxpack type %02x\n", muxpack[0]);
 626         } else
 627                 numstuff++;
 628 }
 629
 630 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
 631 {
 632         int maxwork = 1024;
 633         while (len) {
 634                 if (!(maxwork--)) {
 635                         printk("%s: too much work\n", __func__);
 636                         break;
 637                 }
 638
 639                 switch (ttusb->mux_state) {
 640                 case 0:
 641                 case 1:
 642                 case 2:
 643                         len--;
 644                         if (*data++ == 0xAA)
 645                                 ++ttusb->mux_state;
 646                         else {
 647                                 ttusb->mux_state = 0;
 648                                 if (ttusb->insync) {
 649                                         dprintk("%s: %02x\n",
 650                                                 __func__, data[-1]);
 651                                         printk(KERN_INFO "%s: lost sync.\n",
 652                                                __func__);
 653                                         ttusb->insync = 0;
 654                                 }
 655                         }
 656                         break;
 657                 case 3:
 658                         ttusb->insync = 1;
 659                         len--;
 660                         ttusb->mux_npacks = *data++;
 661                         ++ttusb->mux_state;
 662                         ttusb->muxpack_ptr = 0;
 663                         /* maximum bytes, until we know the length */
 664                         ttusb->muxpack_len = 2;
 665                         break;
 666                 case 4:
 667                         {
 668                                 int avail;
 669                                 avail = len;
 670                                 if (avail >
 671                                     (ttusb->muxpack_len -
 672                                      ttusb->muxpack_ptr))
 673                                         avail =
 674                                             ttusb->muxpack_len -
 675                                             ttusb->muxpack_ptr;
 676                                 memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
 677                                        data, avail);
 678                                 ttusb->muxpack_ptr += avail;
 679                                 BUG_ON(ttusb->muxpack_ptr > 264);
 680                                 data += avail;
 681                                 len -= avail;
 682                                 /* determine length */
 683                                 if (ttusb->muxpack_ptr == 2) {
 684                                         if (ttusb->muxpack[0] & 0x80) {
 685                                                 ttusb->muxpack_len =
 686                                                     ttusb->muxpack[1] + 2;
 687                                                 if (ttusb->
 688                                                     muxpack[0] & 0x20)
 689                                                         ttusb->
 690                                                             muxpack_len++;
 691                                                 if ((!!
 692                                                      (ttusb->
 693                                                       muxpack[0] & 0x20)) ^
 694                                                     !!(ttusb->
 695                                                        muxpack[1] & 1))
 696                                                         ttusb->
 697                                                             muxpack_len++;
 698                                                 ttusb->muxpack_len += 4;
 699                                         } else if (ttusb->muxpack[0] ==
 700                                                    0x47)
 701                                                 ttusb->muxpack_len =
 702                                                     188 + 4;
 703                                         else if (ttusb->muxpack[0] == 0x00)
 704                                                 ttusb->muxpack_len =
 705                                                     ttusb->muxpack[1] + 2 +
 706                                                     4;
 707                                         else {
 708                                                 dprintk
 709                                                     ("%s: invalid state: first byte is %x\n",
 710                                                      __func__,
 711                                                      ttusb->muxpack[0]);
 712                                                 ttusb->mux_state = 0;
 713                                         }
 714                                 }
 715
 716                         /**
 717                          * if length is valid and we reached the end:
 718                          * goto next muxpack
 719                          */
 720                                 if ((ttusb->muxpack_ptr >= 2) &&
 721                                     (ttusb->muxpack_ptr ==
 722                                      ttusb->muxpack_len)) {
 723                                         ttusb_process_muxpack(ttusb,
 724                                                               ttusb->
 725                                                               muxpack,
 726                                                               ttusb->
 727                                                               muxpack_ptr);
 728                                         ttusb->muxpack_ptr = 0;
 729                                         /* maximum bytes, until we know the length */
 730                                         ttusb->muxpack_len = 2;
 731
 732                                 /**
 733                                  * no muxpacks left?
 734                                  * return to search-sync state
 735                                  */
 736                                         if (!ttusb->mux_npacks--) {
 737                                                 ttusb->mux_state = 0;
 738                                                 break;
 739                                         }
 740                                 }
 741                                 break;
 742                         }
 743                 default:
 744                         BUG();
 745                         break;
 746                 }
 747         }
 748 }
 749
 750 static void ttusb_iso_irq(struct urb *urb)
 751 {
 752         struct ttusb *ttusb = urb->context;
 753         struct usb_iso_packet_descriptor *d;
 754         u8 *data;
 755         int len, i;
 756
 757         if (!ttusb->iso_streaming)
 758                 return;
 759
 760 #if 0
 761         printk("%s: status %d, errcount == %d, length == %i\n",
 762                __func__,
 763                urb->status, urb->error_count, urb->actual_length);
 764 #endif
 765
 766         if (!urb->status) {
 767                 for (i = 0; i < urb->number_of_packets; ++i) {
 768                         numpkt++;
 769                         if (time_after_eq(jiffies, lastj + HZ)) {
 770                                 dprintk("frames/s: %lu (ts: %d, stuff %d, "
 771                                         "sec: %d, invalid: %d, all: %d)\n",
 772                                         numpkt * HZ / (jiffies - lastj),
 773                                         numts, numstuff, numsec, numinvalid,
 774                                         numts + numstuff + numsec + numinvalid);
 775                                 numts = numstuff = numsec = numinvalid = 0;
 776                                 lastj = jiffies;
 777                                 numpkt = 0;
 778                         }
 779                         d = &urb->iso_frame_desc[i];
 780                         data = urb->transfer_buffer + d->offset;
 781                         len = d->actual_length;
 782                         d->actual_length = 0;
 783                         d->status = 0;
 784                         ttusb_process_frame(ttusb, data, len);
 785                 }
 786         }
 787         usb_submit_urb(urb, GFP_ATOMIC);
 788 }
 789
 790 static void ttusb_free_iso_urbs(struct ttusb *ttusb)
 791 {
 792         int i;
 793
 794         for (i = 0; i < ISO_BUF_COUNT; i++)
 795                 usb_free_urb(ttusb->iso_urb[i]);
 796
 797         pci_free_consistent(NULL,
 798                             ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
 799                             ISO_BUF_COUNT, ttusb->iso_buffer,
 800                             ttusb->iso_dma_handle);
 801 }
 802
 803 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
 804 {
 805         int i;
 806
 807         ttusb->iso_buffer = pci_zalloc_consistent(NULL,
 808                                                   ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
 809                                                   &ttusb->iso_dma_handle);
 810
 811         if (!ttusb->iso_buffer) {
 812                 dprintk("%s: pci_alloc_consistent - not enough memory\n",
 813                         __func__);
 814                 return -ENOMEM;
 815         }
 816
 817         for (i = 0; i < ISO_BUF_COUNT; i++) {
 818                 struct urb *urb;
 819
 820                 if (!
 821                     (urb =
 822                      usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
 823                         ttusb_free_iso_urbs(ttusb);
 824                         return -ENOMEM;
 825                 }
 826
 827                 ttusb->iso_urb[i] = urb;
 828         }
 829
 830         return 0;
 831 }
 832
 833 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
 834 {
 835         int i;
 836
 837         for (i = 0; i < ISO_BUF_COUNT; i++)
 838                 usb_kill_urb(ttusb->iso_urb[i]);
 839
 840         ttusb->iso_streaming = 0;
 841 }
 842
 843 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
 844 {
 845         int i, j, err, buffer_offset = 0;
 846
 847         if (ttusb->iso_streaming) {
 848                 printk("%s: iso xfer already running!\n", __func__);
 849                 return 0;
 850         }
 851
 852         ttusb->cc = -1;
 853         ttusb->insync = 0;
 854         ttusb->mux_state = 0;
 855
 856         for (i = 0; i < ISO_BUF_COUNT; i++) {
 857                 int frame_offset = 0;
 858                 struct urb *urb = ttusb->iso_urb[i];
 859
 860                 urb->dev = ttusb->dev;
 861                 urb->context = ttusb;
 862                 urb->complete = ttusb_iso_irq;
 863                 urb->pipe = ttusb->isoc_in_pipe;
 864                 urb->transfer_flags = URB_ISO_ASAP;
 865                 urb->interval = 1;
 866                 urb->number_of_packets = FRAMES_PER_ISO_BUF;
 867                 urb->transfer_buffer_length =
 868                     ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
 869                 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
 870                 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
 871
 872                 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
 873                         urb->iso_frame_desc[j].offset = frame_offset;
 874                         urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
 875                         frame_offset += ISO_FRAME_SIZE;
 876                 }
 877         }
 878
 879         for (i = 0; i < ISO_BUF_COUNT; i++) {
 880                 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
 881                         ttusb_stop_iso_xfer(ttusb);
 882                         printk
 883                             ("%s: failed urb submission (%i: err = %i)!\n",
 884                              __func__, i, err);
 885                         return err;
 886                 }
 887         }
 888
 889         ttusb->iso_streaming = 1;
 890
 891         return 0;
 892 }
 893
 894 #ifdef TTUSB_HWSECTIONS
 895 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
 896                           int len)
 897 {
 898         dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
 899 }
 900
 901 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
 902                            int len)
 903 {
 904 //      struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
 905 #error TODO: handle ugly stuff
 906 //      dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
 907 }
 908 #endif
 909
 910 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 911 {
 912         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
 913         int feed_type = 1;
 914
 915         dprintk("ttusb_start_feed\n");
 916
 917         switch (dvbdmxfeed->type) {
 918         case DMX_TYPE_TS:
 919                 break;
 920         case DMX_TYPE_SEC:
 921                 break;
 922         default:
 923                 return -EINVAL;
 924         }
 925
 926         if (dvbdmxfeed->type == DMX_TYPE_TS) {
 927                 switch (dvbdmxfeed->pes_type) {
 928                 case DMX_PES_VIDEO:
 929                 case DMX_PES_AUDIO:
 930                 case DMX_PES_TELETEXT:
 931                 case DMX_PES_PCR:
 932                 case DMX_PES_OTHER:
 933                         break;
 934                 default:
 935                         return -EINVAL;
 936                 }
 937         }
 938
 939 #ifdef TTUSB_HWSECTIONS
 940 #error TODO: allocate filters
 941         if (dvbdmxfeed->type == DMX_TYPE_TS) {
 942                 feed_type = 1;
 943         } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
 944                 feed_type = 2;
 945         }
 946 #endif
 947
 948         ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
 949
 950         if (0 == ttusb->running_feed_count++)
 951                 ttusb_start_iso_xfer(ttusb);
 952
 953         return 0;
 954 }
 955
 956 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 957 {
 958         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
 959
 960         ttusb_del_channel(ttusb, dvbdmxfeed->index);
 961
 962         if (--ttusb->running_feed_count == 0)
 963                 ttusb_stop_iso_xfer(ttusb);
 964
 965         return 0;
 966 }
 967
 968 static int ttusb_setup_interfaces(struct ttusb *ttusb)
 969 {
 970         usb_set_interface(ttusb->dev, 1, 1);
 971
 972         ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
 973         ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
 974         ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
 975
 976         return 0;
 977 }
 978
 979 #if 0
 980 static u8 stc_firmware[8192];
 981
 982 static int stc_open(struct inode *inode, struct file *file)
 983 {
 984         struct ttusb *ttusb = file->private_data;
 985         int addr;
 986
 987         for (addr = 0; addr < 8192; addr += 16) {
 988                 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
 989                 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
 990                               16);
 991         }
 992
 993         return 0;
 994 }
 995
 996 static ssize_t stc_read(struct file *file, char *buf, size_t count,
 997                  loff_t *offset)
 998 {
 999         return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
1000 }
1001
1002 static int stc_release(struct inode *inode, struct file *file)
1003 {
1004         return 0;
1005 }
1006
1007 static const struct file_operations stc_fops = {
1008         .owner = THIS_MODULE,
1009         .read = stc_read,
1010         .open = stc_open,
1011         .release = stc_release,
1012 };
1013 #endif
1014
1015 static u32 functionality(struct i2c_adapter *adapter)
1016 {
1017         return I2C_FUNC_I2C;
1018 }
1019
1020
1021
1022 static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe)
1023 {
1024         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1025         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1026         u8 data[4];
1027         struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
1028         u32 div;
1029
1030         div = (p->frequency + 36166667) / 166667;
1031
1032         data[0] = (div >> 8) & 0x7f;
1033         data[1] = div & 0xff;
1034         data[2] = ((div >> 10) & 0x60) | 0x85;
1035         data[3] = p->frequency < 592000000 ? 0x40 : 0x80;
1036
1037         if (fe->ops.i2c_gate_ctrl)
1038                 fe->ops.i2c_gate_ctrl(fe, 1);
1039         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
1040         return 0;
1041 }
1042
1043 static struct cx22700_config alps_tdmb7_config = {
1044         .demod_address = 0x43,
1045 };
1046
1047
1048
1049
1050
1051 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
1052 {
1053         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1054         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
1055         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
1056         struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
1057
1058         // setup PLL configuration
1059         if (fe->ops.i2c_gate_ctrl)
1060                 fe->ops.i2c_gate_ctrl(fe, 1);
1061         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
1062         msleep(1);
1063
1064         // disable the mc44BC374c (do not check for errors)
1065         tuner_msg.addr = 0x65;
1066         tuner_msg.buf = disable_mc44BC374c;
1067         tuner_msg.len = sizeof(disable_mc44BC374c);
1068         if (fe->ops.i2c_gate_ctrl)
1069                 fe->ops.i2c_gate_ctrl(fe, 1);
1070         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1071                 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
1072         }
1073
1074         return 0;
1075 }
1076
1077 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1078 {
1079         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
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 = p->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 (p->frequency < 49000000)
1102                 return -EINVAL;
1103         else if (p->frequency < 159000000)
1104                 band = 1;
1105         else if (p->frequency < 444000000)
1106                 band = 2;
1107         else if (p->frequency < 861000000)
1108                 band = 4;
1109         else return -EINVAL;
1110
1111         // setup PLL filter
1112         switch (p->bandwidth_hz) {
1113         case 6000000:
1114                 tda1004x_writereg(fe, 0x0C, 0);
1115                 filter = 0;
1116                 break;
1117
1118         case 7000000:
1119                 tda1004x_writereg(fe, 0x0C, 0);
1120                 filter = 0;
1121                 break;
1122
1123         case 8000000:
1124                 tda1004x_writereg(fe, 0x0C, 0xFF);
1125                 filter = 1;
1126                 break;
1127
1128         default:
1129                 return -EINVAL;
1130         }
1131
1132         // calculate divisor
1133         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
1134         tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000;
1135
1136         // setup tuner buffer
1137         tuner_buf[0] = tuner_frequency >> 8;
1138         tuner_buf[1] = tuner_frequency & 0xff;
1139         tuner_buf[2] = 0xca;
1140         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1141
1142         if (fe->ops.i2c_gate_ctrl)
1143                 fe->ops.i2c_gate_ctrl(fe, 1);
1144         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
1145                 return -EIO;
1146
1147         msleep(1);
1148         return 0;
1149 }
1150
1151 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1152 {
1153         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1154
1155         return request_firmware(fw, name, &ttusb->dev->dev);
1156 }
1157
1158 static struct tda1004x_config philips_tdm1316l_config = {
1159
1160         .demod_address = 0x8,
1161         .invert = 1,
1162         .invert_oclk = 0,
1163         .request_firmware = philips_tdm1316l_request_firmware,
1164 };
1165
1166 static u8 alps_bsbe1_inittab[] = {
1167         0x01, 0x15,
1168         0x02, 0x30,
1169         0x03, 0x00,
1170         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1171         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1172         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1173         0x07, 0x00,             /* DAC LSB */
1174         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1175         0x09, 0x00,             /* FIFO */
1176         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1177         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1178         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1179         0x10, 0x3f,             // AGC2  0x3d
1180         0x11, 0x84,
1181         0x12, 0xb9,
1182         0x15, 0xc9,             // lock detector threshold
1183         0x16, 0x00,
1184         0x17, 0x00,
1185         0x18, 0x00,
1186         0x19, 0x00,
1187         0x1a, 0x00,
1188         0x1f, 0x50,
1189         0x20, 0x00,
1190         0x21, 0x00,
1191         0x22, 0x00,
1192         0x23, 0x00,
1193         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1194         0x29, 0x1e,             // 1/2 threshold
1195         0x2a, 0x14,             // 2/3 threshold
1196         0x2b, 0x0f,             // 3/4 threshold
1197         0x2c, 0x09,             // 5/6 threshold
1198         0x2d, 0x05,             // 7/8 threshold
1199         0x2e, 0x01,
1200         0x31, 0x1f,             // test all FECs
1201         0x32, 0x19,             // viterbi and synchro search
1202         0x33, 0xfc,             // rs control
1203         0x34, 0x93,             // error control
1204         0x0f, 0x92,
1205         0xff, 0xff
1206 };
1207
1208 static u8 alps_bsru6_inittab[] = {
1209         0x01, 0x15,
1210         0x02, 0x30,
1211         0x03, 0x00,
1212         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1213         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1214         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1215         0x07, 0x00,             /* DAC LSB */
1216         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1217         0x09, 0x00,             /* FIFO */
1218         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1219         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1220         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1221         0x10, 0x3f,             // AGC2  0x3d
1222         0x11, 0x84,
1223         0x12, 0xb9,
1224         0x15, 0xc9,             // lock detector threshold
1225         0x16, 0x00,
1226         0x17, 0x00,
1227         0x18, 0x00,
1228         0x19, 0x00,
1229         0x1a, 0x00,
1230         0x1f, 0x50,
1231         0x20, 0x00,
1232         0x21, 0x00,
1233         0x22, 0x00,
1234         0x23, 0x00,
1235         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1236         0x29, 0x1e,             // 1/2 threshold
1237         0x2a, 0x14,             // 2/3 threshold
1238         0x2b, 0x0f,             // 3/4 threshold
1239         0x2c, 0x09,             // 5/6 threshold
1240         0x2d, 0x05,             // 7/8 threshold
1241         0x2e, 0x01,
1242         0x31, 0x1f,             // test all FECs
1243         0x32, 0x19,             // viterbi and synchro search
1244         0x33, 0xfc,             // rs control
1245         0x34, 0x93,             // error control
1246         0x0f, 0x52,
1247         0xff, 0xff
1248 };
1249
1250 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
1251 {
1252         u8 aclk = 0;
1253         u8 bclk = 0;
1254
1255         if (srate < 1500000) {
1256                 aclk = 0xb7;
1257                 bclk = 0x47;
1258         } else if (srate < 3000000) {
1259                 aclk = 0xb7;
1260                 bclk = 0x4b;
1261         } else if (srate < 7000000) {
1262                 aclk = 0xb7;
1263                 bclk = 0x4f;
1264         } else if (srate < 14000000) {
1265                 aclk = 0xb7;
1266                 bclk = 0x53;
1267         } else if (srate < 30000000) {
1268                 aclk = 0xb6;
1269                 bclk = 0x53;
1270         } else if (srate < 45000000) {
1271                 aclk = 0xb4;
1272                 bclk = 0x51;
1273         }
1274
1275         stv0299_writereg(fe, 0x13, aclk);
1276         stv0299_writereg(fe, 0x14, bclk);
1277         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1278         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1279         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
1280
1281         return 0;
1282 }
1283
1284 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe)
1285 {
1286         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1287         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1288         u8 buf[4];
1289         u32 div;
1290         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1291
1292         if ((p->frequency < 950000) || (p->frequency > 2150000))
1293                 return -EINVAL;
1294
1295         div = (p->frequency + (125 - 1)) / 125; /* round correctly */
1296         buf[0] = (div >> 8) & 0x7f;
1297         buf[1] = div & 0xff;
1298         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1299         buf[3] = 0xC4;
1300
1301         if (p->frequency > 1530000)
1302                 buf[3] = 0xC0;
1303
1304         /* BSBE1 wants XCE bit set */
1305         if (ttusb->revision == TTUSB_REV_2_2)
1306                 buf[3] |= 0x20;
1307
1308         if (fe->ops.i2c_gate_ctrl)
1309                 fe->ops.i2c_gate_ctrl(fe, 1);
1310         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1311                 return -EIO;
1312
1313         return 0;
1314 }
1315
1316 static struct stv0299_config alps_stv0299_config = {
1317         .demod_address = 0x68,
1318         .inittab = alps_bsru6_inittab,
1319         .mclk = 88000000UL,
1320         .invert = 1,
1321         .skip_reinit = 0,
1322         .lock_output = STV0299_LOCKOUTPUT_1,
1323         .volt13_op0_op1 = STV0299_VOLT13_OP1,
1324         .min_delay_ms = 100,
1325         .set_symbol_rate = alps_stv0299_set_symbol_rate,
1326 };
1327
1328 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe)
1329 {
1330         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1331         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1332         u8 buf[4];
1333         u32 div;
1334         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1335
1336         div = p->frequency / 125;
1337
1338         buf[0] = (div >> 8) & 0x7f;
1339         buf[1] = div & 0xff;
1340         buf[2] = 0x8e;
1341         buf[3] = 0x00;
1342
1343         if (fe->ops.i2c_gate_ctrl)
1344                 fe->ops.i2c_gate_ctrl(fe, 1);
1345         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1346                 return -EIO;
1347
1348         return 0;
1349 }
1350
1351 static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
1352
1353         .demod_address = 0x68,
1354 };
1355
1356 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1357 {
1358         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1359         struct ttusb* ttusb = fe->dvb->priv;
1360         u32 div;
1361         u8 data[4];
1362         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1363
1364         div = (p->frequency + 35937500 + 31250) / 62500;
1365
1366         data[0] = (div >> 8) & 0x7f;
1367         data[1] = div & 0xff;
1368         data[2] = 0x85 | ((div >> 10) & 0x60);
1369         data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1370
1371         if (fe->ops.i2c_gate_ctrl)
1372                 fe->ops.i2c_gate_ctrl(fe, 1);
1373         if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
1374                 return -EIO;
1375
1376         return 0;
1377 }
1378
1379
1380 static struct ves1820_config alps_tdbe2_config = {
1381         .demod_address = 0x09,
1382         .xin = 57840000UL,
1383         .invert = 1,
1384         .selagc = VES1820_SELAGC_SIGNAMPERR,
1385 };
1386
1387 static u8 read_pwm(struct ttusb* ttusb)
1388 {
1389         u8 b = 0xff;
1390         u8 pwm;
1391         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1392                                 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1393
1394         if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1395                 pwm = 0x48;
1396
1397         return pwm;
1398 }
1399
1400
1401 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1402 {
1403         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1404         struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
1405         u8 tuner_buf[5];
1406         struct i2c_msg tuner_msg = {.addr = 0x60,
1407                                     .flags = 0,
1408                                     .buf = tuner_buf,
1409                                     .len = sizeof(tuner_buf) };
1410         int tuner_frequency = 0;
1411         u8 band, cp, filter;
1412
1413         // determine charge pump
1414         tuner_frequency = p->frequency;
1415         if      (tuner_frequency <  87000000) {return -EINVAL;}
1416         else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
1417         else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
1418         else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
1419         else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
1420         else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
1421         else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
1422         else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
1423         else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
1424         else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
1425         else {return -EINVAL;}
1426
1427         // assume PLL filter should always be 8MHz for the moment.
1428         filter = 1;
1429
1430         // calculate divisor
1431         // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
1432         tuner_frequency = ((p->frequency + 36125000) / 62500);
1433
1434         // setup tuner buffer
1435         tuner_buf[0] = tuner_frequency >> 8;
1436         tuner_buf[1] = tuner_frequency & 0xff;
1437         tuner_buf[2] = 0xc8;
1438         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1439         tuner_buf[4] = 0x80;
1440
1441         if (fe->ops.i2c_gate_ctrl)
1442                 fe->ops.i2c_gate_ctrl(fe, 1);
1443         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1444                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
1445                 return -EIO;
1446         }
1447
1448         msleep(50);
1449
1450         if (fe->ops.i2c_gate_ctrl)
1451                 fe->ops.i2c_gate_ctrl(fe, 1);
1452         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1453                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
1454                 return -EIO;
1455         }
1456
1457         msleep(1);
1458
1459         return 0;
1460 }
1461
1462 static u8 dvbc_philips_tdm1316l_inittab[] = {
1463         0x80, 0x21,
1464         0x80, 0x20,
1465         0x81, 0x01,
1466         0x81, 0x00,
1467         0x00, 0x09,
1468         0x01, 0x69,
1469         0x03, 0x00,
1470         0x04, 0x00,
1471         0x07, 0x00,
1472         0x08, 0x00,
1473         0x20, 0x00,
1474         0x21, 0x40,
1475         0x22, 0x00,
1476         0x23, 0x00,
1477         0x24, 0x40,
1478         0x25, 0x88,
1479         0x30, 0xff,
1480         0x31, 0x00,
1481         0x32, 0xff,
1482         0x33, 0x00,
1483         0x34, 0x50,
1484         0x35, 0x7f,
1485         0x36, 0x00,
1486         0x37, 0x20,
1487         0x38, 0x00,
1488         0x40, 0x1c,
1489         0x41, 0xff,
1490         0x42, 0x29,
1491         0x43, 0x20,
1492         0x44, 0xff,
1493         0x45, 0x00,
1494         0x46, 0x00,
1495         0x49, 0x04,
1496         0x4a, 0xff,
1497         0x4b, 0x7f,
1498         0x52, 0x30,
1499         0x55, 0xae,
1500         0x56, 0x47,
1501         0x57, 0xe1,
1502         0x58, 0x3a,
1503         0x5a, 0x1e,
1504         0x5b, 0x34,
1505         0x60, 0x00,
1506         0x63, 0x00,
1507         0x64, 0x00,
1508         0x65, 0x00,
1509         0x66, 0x00,
1510         0x67, 0x00,
1511         0x68, 0x00,
1512         0x69, 0x00,
1513         0x6a, 0x02,
1514         0x6b, 0x00,
1515         0x70, 0xff,
1516         0x71, 0x00,
1517         0x72, 0x00,
1518         0x73, 0x00,
1519         0x74, 0x0c,
1520         0x80, 0x00,
1521         0x81, 0x00,
1522         0x82, 0x00,
1523         0x83, 0x00,
1524         0x84, 0x04,
1525         0x85, 0x80,
1526         0x86, 0x24,
1527         0x87, 0x78,
1528         0x88, 0x00,
1529         0x89, 0x00,
1530         0x90, 0x01,
1531         0x91, 0x01,
1532         0xa0, 0x00,
1533         0xa1, 0x00,
1534         0xa2, 0x00,
1535         0xb0, 0x91,
1536         0xb1, 0x0b,
1537         0xc0, 0x4b,
1538         0xc1, 0x00,
1539         0xc2, 0x00,
1540         0xd0, 0x00,
1541         0xd1, 0x00,
1542         0xd2, 0x00,
1543         0xd3, 0x00,
1544         0xd4, 0x00,
1545         0xd5, 0x00,
1546         0xde, 0x00,
1547         0xdf, 0x00,
1548         0x61, 0x38,
1549         0x62, 0x0a,
1550         0x53, 0x13,
1551         0x59, 0x08,
1552         0x55, 0x00,
1553         0x56, 0x40,
1554         0x57, 0x08,
1555         0x58, 0x3d,
1556         0x88, 0x10,
1557         0xa0, 0x00,
1558         0xa0, 0x00,
1559         0xa0, 0x00,
1560         0xa0, 0x04,
1561         0xff, 0xff,
1562 };
1563
1564 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1565         .demod_address = 0x1c,
1566         .inittab = dvbc_philips_tdm1316l_inittab,
1567         .invert = 0,
1568 };
1569
1570 static void frontend_init(struct ttusb* ttusb)
1571 {
1572         switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
1573         case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
1574                 // try the stv0299 based first
1575                 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
1576                 if (ttusb->fe != NULL) {
1577                         ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
1578
1579                         if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
1580                                 alps_stv0299_config.inittab = alps_bsbe1_inittab;
1581                                 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
1582                         } else { // ALPS BSRU6
1583                                 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1584                         }
1585                         break;
1586                 }
1587
1588                 // Grundig 29504-491
1589                 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
1590                 if (ttusb->fe != NULL) {
1591                         ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
1592                         ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1593                         break;
1594                 }
1595                 break;
1596
1597         case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
1598                 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
1599                 if (ttusb->fe != NULL) {
1600                         ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
1601                         break;
1602                 }
1603
1604                 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
1605                 if (ttusb->fe != NULL) {
1606                         ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1607                         break;
1608                 }
1609                 break;
1610
1611         case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
1612                 // try the ALPS TDMB7 first
1613                 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
1614                 if (ttusb->fe != NULL) {
1615                         ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
1616                         break;
1617                 }
1618
1619                 // Philips td1316
1620                 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
1621                 if (ttusb->fe != NULL) {
1622                         ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1623                         ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1624                         break;
1625                 }
1626                 break;
1627         }
1628
1629         if (ttusb->fe == NULL) {
1630                 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
1631                        le16_to_cpu(ttusb->dev->descriptor.idVendor),
1632                        le16_to_cpu(ttusb->dev->descriptor.idProduct));
1633         } else {
1634                 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
1635                         printk("dvb-ttusb-budget: Frontend registration failed!\n");
1636                         dvb_frontend_detach(ttusb->fe);
1637                         ttusb->fe = NULL;
1638                 }
1639         }
1640 }
1641
1642
1643
1644 static struct i2c_algorithm ttusb_dec_algo = {
1645         .master_xfer    = master_xfer,
1646         .functionality  = functionality,
1647 };
1648
1649 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1650 {
1651         struct usb_device *udev;
1652         struct ttusb *ttusb;
1653         int result;
1654
1655         dprintk("%s: TTUSB DVB connected\n", __func__);
1656
1657         udev = interface_to_usbdev(intf);
1658
1659         if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1660
1661         if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
1662                 return -ENOMEM;
1663
1664         ttusb->dev = udev;
1665         ttusb->c = 0;
1666         ttusb->mux_state = 0;
1667         mutex_init(&ttusb->semi2c);
1668
1669         mutex_lock(&ttusb->semi2c);
1670
1671         mutex_init(&ttusb->semusb);
1672
1673         ttusb_setup_interfaces(ttusb);
1674
1675         result = ttusb_alloc_iso_urbs(ttusb);
1676         if (result < 0) {
1677                 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__);
1678                 mutex_unlock(&ttusb->semi2c);
1679                 kfree(ttusb);
1680                 return result;
1681         }
1682
1683         if (ttusb_init_controller(ttusb))
1684                 printk("ttusb_init_controller: error\n");
1685
1686         mutex_unlock(&ttusb->semi2c);
1687
1688         result = dvb_register_adapter(&ttusb->adapter,
1689                                       "Technotrend/Hauppauge Nova-USB",
1690                                       THIS_MODULE, &udev->dev, adapter_nr);
1691         if (result < 0) {
1692                 ttusb_free_iso_urbs(ttusb);
1693                 kfree(ttusb);
1694                 return result;
1695         }
1696         ttusb->adapter.priv = ttusb;
1697
1698         /* i2c */
1699         memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
1700         strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
1701
1702         i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
1703
1704         ttusb->i2c_adap.algo              = &ttusb_dec_algo;
1705         ttusb->i2c_adap.algo_data         = NULL;
1706         ttusb->i2c_adap.dev.parent        = &udev->dev;
1707
1708         result = i2c_add_adapter(&ttusb->i2c_adap);
1709         if (result)
1710                 goto err_unregister_adapter;
1711
1712         memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1713
1714         ttusb->dvb_demux.dmx.capabilities =
1715             DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1716         ttusb->dvb_demux.priv = NULL;
1717 #ifdef TTUSB_HWSECTIONS
1718         ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1719 #else
1720         ttusb->dvb_demux.filternum = 32;
1721 #endif
1722         ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1723         ttusb->dvb_demux.start_feed = ttusb_start_feed;
1724         ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1725         ttusb->dvb_demux.write_to_decoder = NULL;
1726
1727         result = dvb_dmx_init(&ttusb->dvb_demux);
1728         if (result < 0) {
1729                 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
1730                 result = -ENODEV;
1731                 goto err_i2c_del_adapter;
1732         }
1733 //FIXME dmxdev (nur WAS?)
1734         ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1735         ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1736         ttusb->dmxdev.capabilities = 0;
1737
1738         result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter);
1739         if (result < 0) {
1740                 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1741                        result);
1742                 result = -ENODEV;
1743                 goto err_release_dmx;
1744         }
1745
1746         if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1747                 printk("ttusb_dvb: dvb_net_init failed!\n");
1748                 result = -ENODEV;
1749                 goto err_release_dmxdev;
1750         }
1751
1752         usb_set_intfdata(intf, (void *) ttusb);
1753
1754         frontend_init(ttusb);
1755
1756         return 0;
1757
1758 err_release_dmxdev:
1759         dvb_dmxdev_release(&ttusb->dmxdev);
1760 err_release_dmx:
1761         dvb_dmx_release(&ttusb->dvb_demux);
1762 err_i2c_del_adapter:
1763         i2c_del_adapter(&ttusb->i2c_adap);
1764 err_unregister_adapter:
1765         dvb_unregister_adapter (&ttusb->adapter);
1766         ttusb_free_iso_urbs(ttusb);
1767         kfree(ttusb);
1768         return result;
1769 }
1770
1771 static void ttusb_disconnect(struct usb_interface *intf)
1772 {
1773         struct ttusb *ttusb = usb_get_intfdata(intf);
1774
1775         usb_set_intfdata(intf, NULL);
1776
1777         ttusb->disconnecting = 1;
1778
1779         ttusb_stop_iso_xfer(ttusb);
1780
1781         ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1782         dvb_net_release(&ttusb->dvbnet);
1783         dvb_dmxdev_release(&ttusb->dmxdev);
1784         dvb_dmx_release(&ttusb->dvb_demux);
1785         if (ttusb->fe != NULL) {
1786                 dvb_unregister_frontend(ttusb->fe);
1787                 dvb_frontend_detach(ttusb->fe);
1788         }
1789         i2c_del_adapter(&ttusb->i2c_adap);
1790         dvb_unregister_adapter(&ttusb->adapter);
1791
1792         ttusb_free_iso_urbs(ttusb);
1793
1794         kfree(ttusb);
1795
1796         dprintk("%s: TTUSB DVB disconnected\n", __func__);
1797 }
1798
1799 static struct usb_device_id ttusb_table[] = {
1800         {USB_DEVICE(0xb48, 0x1003)},
1801         {USB_DEVICE(0xb48, 0x1004)},
1802         {USB_DEVICE(0xb48, 0x1005)},
1803         {}
1804 };
1805
1806 MODULE_DEVICE_TABLE(usb, ttusb_table);
1807
1808 static struct usb_driver ttusb_driver = {
1809       .name             = "ttusb",
1810       .probe            = ttusb_probe,
1811       .disconnect       = ttusb_disconnect,
1812       .id_table         = ttusb_table,
1813 };
1814
1815 module_usb_driver(ttusb_driver);
1816
1817 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1818 MODULE_DESCRIPTION("TTUSB DVB Driver");
1819 MODULE_LICENSE("GPL");
1820 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");