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