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

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