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