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

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