git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/ttpci/budget-ci.c

   1 /*
   2  * budget-ci.c: driver for the SAA7146 based Budget DVB cards
   3  *
   4  * Compiled from various sources by Michael Hunold <michael@mihu.de>
   5  *
   6  *     msp430 IR support contributed by Jack Thomasson <jkt@Helius.COM>
   7  *     partially based on the Siemens DVB driver by Ralph+Marcus Metzler
   8  *
   9  * CI interface support (c) 2004 Andrew de Quincey <adq_dvb@lidskialf.net>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  27  *
  28  *
  29  * the project's page is at http://www.linuxtv.org/dvb/
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/errno.h>
  34 #include <linux/slab.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/input.h>
  37 #include <linux/spinlock.h>
  38 #include <media/ir-common.h>
  39
  40 #include "budget.h"
  41
  42 #include "dvb_ca_en50221.h"
  43 #include "stv0299.h"
  44 #include "stv0297.h"
  45 #include "tda1004x.h"
  46 #include "stb0899_drv.h"
  47 #include "stb0899_reg.h"
  48 #include "stb0899_cfg.h"
  49 #include "stb6100.h"
  50 #include "stb6100_cfg.h"
  51 #include "lnbp21.h"
  52 #include "bsbe1.h"
  53 #include "bsru6.h"
  54 #include "tda1002x.h"
  55 #include "tda827x.h"
  56
  57 /*
  58  * Regarding DEBIADDR_IR:
  59  * Some CI modules hang if random addresses are read.
  60  * Using address 0x4000 for the IR read means that we
  61  * use the same address as for CI version, which should
  62  * be a safe default.
  63  */
  64 #define DEBIADDR_IR             0x4000
  65 #define DEBIADDR_CICONTROL      0x0000
  66 #define DEBIADDR_CIVERSION      0x4000
  67 #define DEBIADDR_IO             0x1000
  68 #define DEBIADDR_ATTR           0x3000
  69
  70 #define CICONTROL_RESET         0x01
  71 #define CICONTROL_ENABLETS      0x02
  72 #define CICONTROL_CAMDETECT     0x08
  73
  74 #define DEBICICTL               0x00420000
  75 #define DEBICICAM               0x02420000
  76
  77 #define SLOTSTATUS_NONE         1
  78 #define SLOTSTATUS_PRESENT      2
  79 #define SLOTSTATUS_RESET        4
  80 #define SLOTSTATUS_READY        8
  81 #define SLOTSTATUS_OCCUPIED     (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
  82
  83 /*
  84  * Milliseconds during which a key is regarded as pressed.
  85  * If an identical command arrives within this time, the timer will start over.
  86  */
  87 #define IR_KEYPRESS_TIMEOUT     250
  88
  89 /* RC5 device wildcard */
  90 #define IR_DEVICE_ANY           255
  91
  92 static int rc5_device = -1;
  93 module_param(rc5_device, int, 0644);
  94 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
  95
  96 static int ir_debug;
  97 module_param(ir_debug, int, 0644);
  98 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
  99
 100 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 101
 102 struct budget_ci_ir {
 103         struct input_dev *dev;
 104         struct tasklet_struct msp430_irq_tasklet;
 105         struct timer_list timer_keyup;
 106         char name[72]; /* 40 + 32 for (struct saa7146_dev).name */
 107         char phys[32];
 108         struct ir_input_state state;
 109         int rc5_device;
 110         u32 last_raw;
 111         u32 ir_key;
 112         bool have_command;
 113 };
 114
 115 struct budget_ci {
 116         struct budget budget;
 117         struct tasklet_struct ciintf_irq_tasklet;
 118         int slot_status;
 119         int ci_irq;
 120         struct dvb_ca_en50221 ca;
 121         struct budget_ci_ir ir;
 122         u8 tuner_pll_address; /* used for philips_tdm1316l configs */
 123 };
 124
 125 static void msp430_ir_keyup(unsigned long data)
 126 {
 127         struct budget_ci_ir *ir = (struct budget_ci_ir *) data;
 128         ir_input_nokey(ir->dev, &ir->state);
 129 }
 130
 131 static void msp430_ir_interrupt(unsigned long data)
 132 {
 133         struct budget_ci *budget_ci = (struct budget_ci *) data;
 134         struct input_dev *dev = budget_ci->ir.dev;
 135         u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
 136         u32 raw;
 137
 138         /*
 139          * The msp430 chip can generate two different bytes, command and device
 140          *
 141          * type1: X1CCCCCC, C = command bits (0 - 63)
 142          * type2: X0TDDDDD, D = device bits (0 - 31), T = RC5 toggle bit
 143          *
 144          * Each signal from the remote control can generate one or more command
 145          * bytes and one or more device bytes. For the repeated bytes, the
 146          * highest bit (X) is set. The first command byte is always generated
 147          * before the first device byte. Other than that, no specific order
 148          * seems to apply. To make life interesting, bytes can also be lost.
 149          *
 150          * Only when we have a command and device byte, a keypress is
 151          * generated.
 152          */
 153
 154         if (ir_debug)
 155                 printk("budget_ci: received byte 0x%02x\n", command);
 156
 157         /* Remove repeat bit, we use every command */
 158         command = command & 0x7f;
 159
 160         /* Is this a RC5 command byte? */
 161         if (command & 0x40) {
 162                 budget_ci->ir.have_command = true;
 163                 budget_ci->ir.ir_key = command & 0x3f;
 164                 return;
 165         }
 166
 167         /* It's a RC5 device byte */
 168         if (!budget_ci->ir.have_command)
 169                 return;
 170         budget_ci->ir.have_command = false;
 171
 172         if (budget_ci->ir.rc5_device != IR_DEVICE_ANY &&
 173             budget_ci->ir.rc5_device != (command & 0x1f))
 174                 return;
 175
 176         /* Is this a repeated key sequence? (same device, command, toggle) */
 177         raw = budget_ci->ir.ir_key | (command << 8);
 178         if (budget_ci->ir.last_raw != raw || !timer_pending(&budget_ci->ir.timer_keyup)) {
 179                 ir_input_nokey(dev, &budget_ci->ir.state);
 180                 ir_input_keydown(dev, &budget_ci->ir.state,
 181                                  budget_ci->ir.ir_key, raw);
 182                 budget_ci->ir.last_raw = raw;
 183         }
 184
 185         mod_timer(&budget_ci->ir.timer_keyup, jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT));
 186 }
 187
 188 static int msp430_ir_init(struct budget_ci *budget_ci)
 189 {
 190         struct saa7146_dev *saa = budget_ci->budget.dev;
 191         struct input_dev *input_dev = budget_ci->ir.dev;
 192         int error;
 193
 194         budget_ci->ir.dev = input_dev = input_allocate_device();
 195         if (!input_dev) {
 196                 printk(KERN_ERR "budget_ci: IR interface initialisation failed\n");
 197                 error = -ENOMEM;
 198                 goto out1;
 199         }
 200
 201         snprintf(budget_ci->ir.name, sizeof(budget_ci->ir.name),
 202                  "Budget-CI dvb ir receiver %s", saa->name);
 203         snprintf(budget_ci->ir.phys, sizeof(budget_ci->ir.phys),
 204                  "pci-%s/ir0", pci_name(saa->pci));
 205
 206         input_dev->name = budget_ci->ir.name;
 207
 208         input_dev->phys = budget_ci->ir.phys;
 209         input_dev->id.bustype = BUS_PCI;
 210         input_dev->id.version = 1;
 211         if (saa->pci->subsystem_vendor) {
 212                 input_dev->id.vendor = saa->pci->subsystem_vendor;
 213                 input_dev->id.product = saa->pci->subsystem_device;
 214         } else {
 215                 input_dev->id.vendor = saa->pci->vendor;
 216                 input_dev->id.product = saa->pci->device;
 217         }
 218         input_dev->dev.parent = &saa->pci->dev;
 219
 220         /* Select keymap and address */
 221         switch (budget_ci->budget.dev->pci->subsystem_device) {
 222         case 0x100c:
 223         case 0x100f:
 224         case 0x1011:
 225         case 0x1012:
 226                 /* The hauppauge keymap is a superset of these remotes */
 227                 ir_input_init(input_dev, &budget_ci->ir.state,
 228                               IR_TYPE_RC5, ir_codes_hauppauge_new);
 229
 230                 if (rc5_device < 0)
 231                         budget_ci->ir.rc5_device = 0x1f;
 232                 else
 233                         budget_ci->ir.rc5_device = rc5_device;
 234                 break;
 235         case 0x1010:
 236         case 0x1017:
 237         case 0x101a:
 238                 /* for the Technotrend 1500 bundled remote */
 239                 ir_input_init(input_dev, &budget_ci->ir.state,
 240                               IR_TYPE_RC5, ir_codes_tt_1500);
 241
 242                 if (rc5_device < 0)
 243                         budget_ci->ir.rc5_device = IR_DEVICE_ANY;
 244                 else
 245                         budget_ci->ir.rc5_device = rc5_device;
 246                 break;
 247         default:
 248                 /* unknown remote */
 249                 ir_input_init(input_dev, &budget_ci->ir.state,
 250                               IR_TYPE_RC5, ir_codes_budget_ci_old);
 251
 252                 if (rc5_device < 0)
 253                         budget_ci->ir.rc5_device = IR_DEVICE_ANY;
 254                 else
 255                         budget_ci->ir.rc5_device = rc5_device;
 256                 break;
 257         }
 258
 259         /* initialise the key-up timeout handler */
 260         init_timer(&budget_ci->ir.timer_keyup);
 261         budget_ci->ir.timer_keyup.function = msp430_ir_keyup;
 262         budget_ci->ir.timer_keyup.data = (unsigned long) &budget_ci->ir;
 263         budget_ci->ir.last_raw = 0xffff; /* An impossible value */
 264         error = input_register_device(input_dev);
 265         if (error) {
 266                 printk(KERN_ERR "budget_ci: could not init driver for IR device (code %d)\n", error);
 267                 goto out2;
 268         }
 269
 270         /* note: these must be after input_register_device */
 271         input_dev->rep[REP_DELAY] = 400;
 272         input_dev->rep[REP_PERIOD] = 250;
 273
 274         tasklet_init(&budget_ci->ir.msp430_irq_tasklet, msp430_ir_interrupt,
 275                      (unsigned long) budget_ci);
 276
 277         SAA7146_IER_ENABLE(saa, MASK_06);
 278         saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI);
 279
 280         return 0;
 281
 282 out2:
 283         input_free_device(input_dev);
 284 out1:
 285         return error;
 286 }
 287
 288 static void msp430_ir_deinit(struct budget_ci *budget_ci)
 289 {
 290         struct saa7146_dev *saa = budget_ci->budget.dev;
 291         struct input_dev *dev = budget_ci->ir.dev;
 292
 293         SAA7146_IER_DISABLE(saa, MASK_06);
 294         saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
 295         tasklet_kill(&budget_ci->ir.msp430_irq_tasklet);
 296
 297         del_timer_sync(&dev->timer);
 298         ir_input_nokey(dev, &budget_ci->ir.state);
 299
 300         input_unregister_device(dev);
 301 }
 302
 303 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
 304 {
 305         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 306
 307         if (slot != 0)
 308                 return -EINVAL;
 309
 310         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
 311                                      DEBIADDR_ATTR | (address & 0xfff), 1, 1, 0);
 312 }
 313
 314 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
 315 {
 316         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 317
 318         if (slot != 0)
 319                 return -EINVAL;
 320
 321         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
 322                                       DEBIADDR_ATTR | (address & 0xfff), 1, value, 1, 0);
 323 }
 324
 325 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
 326 {
 327         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 328
 329         if (slot != 0)
 330                 return -EINVAL;
 331
 332         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
 333                                      DEBIADDR_IO | (address & 3), 1, 1, 0);
 334 }
 335
 336 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
 337 {
 338         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 339
 340         if (slot != 0)
 341                 return -EINVAL;
 342
 343         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
 344                                       DEBIADDR_IO | (address & 3), 1, value, 1, 0);
 345 }
 346
 347 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
 348 {
 349         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 350         struct saa7146_dev *saa = budget_ci->budget.dev;
 351
 352         if (slot != 0)
 353                 return -EINVAL;
 354
 355         if (budget_ci->ci_irq) {
 356                 // trigger on RISING edge during reset so we know when READY is re-asserted
 357                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 358         }
 359         budget_ci->slot_status = SLOTSTATUS_RESET;
 360         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
 361         msleep(1);
 362         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 363                                CICONTROL_RESET, 1, 0);
 364
 365         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
 366         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 367         return 0;
 368 }
 369
 370 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
 371 {
 372         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 373         struct saa7146_dev *saa = budget_ci->budget.dev;
 374
 375         if (slot != 0)
 376                 return -EINVAL;
 377
 378         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
 379         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 380         return 0;
 381 }
 382
 383 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
 384 {
 385         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 386         struct saa7146_dev *saa = budget_ci->budget.dev;
 387         int tmp;
 388
 389         if (slot != 0)
 390                 return -EINVAL;
 391
 392         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
 393
 394         tmp = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 395         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 396                                tmp | CICONTROL_ENABLETS, 1, 0);
 397
 398         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
 399         return 0;
 400 }
 401
 402 static void ciintf_interrupt(unsigned long data)
 403 {
 404         struct budget_ci *budget_ci = (struct budget_ci *) data;
 405         struct saa7146_dev *saa = budget_ci->budget.dev;
 406         unsigned int flags;
 407
 408         // ensure we don't get spurious IRQs during initialisation
 409         if (!budget_ci->budget.ci_present)
 410                 return;
 411
 412         // read the CAM status
 413         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 414         if (flags & CICONTROL_CAMDETECT) {
 415
 416                 // GPIO should be set to trigger on falling edge if a CAM is present
 417                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
 418
 419                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
 420                         // CAM insertion IRQ
 421                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
 422                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
 423                                                      DVB_CA_EN50221_CAMCHANGE_INSERTED);
 424
 425                 } else if (budget_ci->slot_status & SLOTSTATUS_RESET) {
 426                         // CAM ready (reset completed)
 427                         budget_ci->slot_status = SLOTSTATUS_READY;
 428                         dvb_ca_en50221_camready_irq(&budget_ci->ca, 0);
 429
 430                 } else if (budget_ci->slot_status & SLOTSTATUS_READY) {
 431                         // FR/DA IRQ
 432                         dvb_ca_en50221_frda_irq(&budget_ci->ca, 0);
 433                 }
 434         } else {
 435
 436                 // trigger on rising edge if a CAM is not present - when a CAM is inserted, we
 437                 // only want to get the IRQ when it sets READY. If we trigger on the falling edge,
 438                 // the CAM might not actually be ready yet.
 439                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 440
 441                 // generate a CAM removal IRQ if we haven't already
 442                 if (budget_ci->slot_status & SLOTSTATUS_OCCUPIED) {
 443                         // CAM removal IRQ
 444                         budget_ci->slot_status = SLOTSTATUS_NONE;
 445                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
 446                                                      DVB_CA_EN50221_CAMCHANGE_REMOVED);
 447                 }
 448         }
 449 }
 450
 451 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
 452 {
 453         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 454         unsigned int flags;
 455
 456         // ensure we don't get spurious IRQs during initialisation
 457         if (!budget_ci->budget.ci_present)
 458                 return -EINVAL;
 459
 460         // read the CAM status
 461         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 462         if (flags & CICONTROL_CAMDETECT) {
 463                 // mark it as present if it wasn't before
 464                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
 465                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
 466                 }
 467
 468                 // during a RESET, we check if we can read from IO memory to see when CAM is ready
 469                 if (budget_ci->slot_status & SLOTSTATUS_RESET) {
 470                         if (ciintf_read_attribute_mem(ca, slot, 0) == 0x1d) {
 471                                 budget_ci->slot_status = SLOTSTATUS_READY;
 472                         }
 473                 }
 474         } else {
 475                 budget_ci->slot_status = SLOTSTATUS_NONE;
 476         }
 477
 478         if (budget_ci->slot_status != SLOTSTATUS_NONE) {
 479                 if (budget_ci->slot_status & SLOTSTATUS_READY) {
 480                         return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
 481                 }
 482                 return DVB_CA_EN50221_POLL_CAM_PRESENT;
 483         }
 484
 485         return 0;
 486 }
 487
 488 static int ciintf_init(struct budget_ci *budget_ci)
 489 {
 490         struct saa7146_dev *saa = budget_ci->budget.dev;
 491         int flags;
 492         int result;
 493         int ci_version;
 494         int ca_flags;
 495
 496         memset(&budget_ci->ca, 0, sizeof(struct dvb_ca_en50221));
 497
 498         // enable DEBI pins
 499         saa7146_write(saa, MC1, MASK_27 | MASK_11);
 500
 501         // test if it is there
 502         ci_version = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CIVERSION, 1, 1, 0);
 503         if ((ci_version & 0xa0) != 0xa0) {
 504                 result = -ENODEV;
 505                 goto error;
 506         }
 507
 508         // determine whether a CAM is present or not
 509         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 510         budget_ci->slot_status = SLOTSTATUS_NONE;
 511         if (flags & CICONTROL_CAMDETECT)
 512                 budget_ci->slot_status = SLOTSTATUS_PRESENT;
 513
 514         // version 0xa2 of the CI firmware doesn't generate interrupts
 515         if (ci_version == 0xa2) {
 516                 ca_flags = 0;
 517                 budget_ci->ci_irq = 0;
 518         } else {
 519                 ca_flags = DVB_CA_EN50221_FLAG_IRQ_CAMCHANGE |
 520                                 DVB_CA_EN50221_FLAG_IRQ_FR |
 521                                 DVB_CA_EN50221_FLAG_IRQ_DA;
 522                 budget_ci->ci_irq = 1;
 523         }
 524
 525         // register CI interface
 526         budget_ci->ca.owner = THIS_MODULE;
 527         budget_ci->ca.read_attribute_mem = ciintf_read_attribute_mem;
 528         budget_ci->ca.write_attribute_mem = ciintf_write_attribute_mem;
 529         budget_ci->ca.read_cam_control = ciintf_read_cam_control;
 530         budget_ci->ca.write_cam_control = ciintf_write_cam_control;
 531         budget_ci->ca.slot_reset = ciintf_slot_reset;
 532         budget_ci->ca.slot_shutdown = ciintf_slot_shutdown;
 533         budget_ci->ca.slot_ts_enable = ciintf_slot_ts_enable;
 534         budget_ci->ca.poll_slot_status = ciintf_poll_slot_status;
 535         budget_ci->ca.data = budget_ci;
 536         if ((result = dvb_ca_en50221_init(&budget_ci->budget.dvb_adapter,
 537                                           &budget_ci->ca,
 538                                           ca_flags, 1)) != 0) {
 539                 printk("budget_ci: CI interface detected, but initialisation failed.\n");
 540                 goto error;
 541         }
 542
 543         // Setup CI slot IRQ
 544         if (budget_ci->ci_irq) {
 545                 tasklet_init(&budget_ci->ciintf_irq_tasklet, ciintf_interrupt, (unsigned long) budget_ci);
 546                 if (budget_ci->slot_status != SLOTSTATUS_NONE) {
 547                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
 548                 } else {
 549                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 550                 }
 551                 SAA7146_IER_ENABLE(saa, MASK_03);
 552         }
 553
 554         // enable interface
 555         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 556                                CICONTROL_RESET, 1, 0);
 557
 558         // success!
 559         printk("budget_ci: CI interface initialised\n");
 560         budget_ci->budget.ci_present = 1;
 561
 562         // forge a fake CI IRQ so the CAM state is setup correctly
 563         if (budget_ci->ci_irq) {
 564                 flags = DVB_CA_EN50221_CAMCHANGE_REMOVED;
 565                 if (budget_ci->slot_status != SLOTSTATUS_NONE)
 566                         flags = DVB_CA_EN50221_CAMCHANGE_INSERTED;
 567                 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, flags);
 568         }
 569
 570         return 0;
 571
 572 error:
 573         saa7146_write(saa, MC1, MASK_27);
 574         return result;
 575 }
 576
 577 static void ciintf_deinit(struct budget_ci *budget_ci)
 578 {
 579         struct saa7146_dev *saa = budget_ci->budget.dev;
 580
 581         // disable CI interrupts
 582         if (budget_ci->ci_irq) {
 583                 SAA7146_IER_DISABLE(saa, MASK_03);
 584                 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
 585                 tasklet_kill(&budget_ci->ciintf_irq_tasklet);
 586         }
 587
 588         // reset interface
 589         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
 590         msleep(1);
 591         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 592                                CICONTROL_RESET, 1, 0);
 593
 594         // disable TS data stream to CI interface
 595         saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
 596
 597         // release the CA device
 598         dvb_ca_en50221_release(&budget_ci->ca);
 599
 600         // disable DEBI pins
 601         saa7146_write(saa, MC1, MASK_27);
 602 }
 603
 604 static void budget_ci_irq(struct saa7146_dev *dev, u32 * isr)
 605 {
 606         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
 607
 608         dprintk(8, "dev: %p, budget_ci: %p\n", dev, budget_ci);
 609
 610         if (*isr & MASK_06)
 611                 tasklet_schedule(&budget_ci->ir.msp430_irq_tasklet);
 612
 613         if (*isr & MASK_10)
 614                 ttpci_budget_irq10_handler(dev, isr);
 615
 616         if ((*isr & MASK_03) && (budget_ci->budget.ci_present) && (budget_ci->ci_irq))
 617                 tasklet_schedule(&budget_ci->ciintf_irq_tasklet);
 618 }
 619
 620 static u8 philips_su1278_tt_inittab[] = {
 621         0x01, 0x0f,
 622         0x02, 0x30,
 623         0x03, 0x00,
 624         0x04, 0x5b,
 625         0x05, 0x85,
 626         0x06, 0x02,
 627         0x07, 0x00,
 628         0x08, 0x02,
 629         0x09, 0x00,
 630         0x0C, 0x01,
 631         0x0D, 0x81,
 632         0x0E, 0x44,
 633         0x0f, 0x14,
 634         0x10, 0x3c,
 635         0x11, 0x84,
 636         0x12, 0xda,
 637         0x13, 0x97,
 638         0x14, 0x95,
 639         0x15, 0xc9,
 640         0x16, 0x19,
 641         0x17, 0x8c,
 642         0x18, 0x59,
 643         0x19, 0xf8,
 644         0x1a, 0xfe,
 645         0x1c, 0x7f,
 646         0x1d, 0x00,
 647         0x1e, 0x00,
 648         0x1f, 0x50,
 649         0x20, 0x00,
 650         0x21, 0x00,
 651         0x22, 0x00,
 652         0x23, 0x00,
 653         0x28, 0x00,
 654         0x29, 0x28,
 655         0x2a, 0x14,
 656         0x2b, 0x0f,
 657         0x2c, 0x09,
 658         0x2d, 0x09,
 659         0x31, 0x1f,
 660         0x32, 0x19,
 661         0x33, 0xfc,
 662         0x34, 0x93,
 663         0xff, 0xff
 664 };
 665
 666 static int philips_su1278_tt_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
 667 {
 668         stv0299_writereg(fe, 0x0e, 0x44);
 669         if (srate >= 10000000) {
 670                 stv0299_writereg(fe, 0x13, 0x97);
 671                 stv0299_writereg(fe, 0x14, 0x95);
 672                 stv0299_writereg(fe, 0x15, 0xc9);
 673                 stv0299_writereg(fe, 0x17, 0x8c);
 674                 stv0299_writereg(fe, 0x1a, 0xfe);
 675                 stv0299_writereg(fe, 0x1c, 0x7f);
 676                 stv0299_writereg(fe, 0x2d, 0x09);
 677         } else {
 678                 stv0299_writereg(fe, 0x13, 0x99);
 679                 stv0299_writereg(fe, 0x14, 0x8d);
 680                 stv0299_writereg(fe, 0x15, 0xce);
 681                 stv0299_writereg(fe, 0x17, 0x43);
 682                 stv0299_writereg(fe, 0x1a, 0x1d);
 683                 stv0299_writereg(fe, 0x1c, 0x12);
 684                 stv0299_writereg(fe, 0x2d, 0x05);
 685         }
 686         stv0299_writereg(fe, 0x0e, 0x23);
 687         stv0299_writereg(fe, 0x0f, 0x94);
 688         stv0299_writereg(fe, 0x10, 0x39);
 689         stv0299_writereg(fe, 0x15, 0xc9);
 690
 691         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
 692         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
 693         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
 694
 695         return 0;
 696 }
 697
 698 static int philips_su1278_tt_tuner_set_params(struct dvb_frontend *fe,
 699                                            struct dvb_frontend_parameters *params)
 700 {
 701         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 702         u32 div;
 703         u8 buf[4];
 704         struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
 705
 706         if ((params->frequency < 950000) || (params->frequency > 2150000))
 707                 return -EINVAL;
 708
 709         div = (params->frequency + (500 - 1)) / 500;    // round correctly
 710         buf[0] = (div >> 8) & 0x7f;
 711         buf[1] = div & 0xff;
 712         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 2;
 713         buf[3] = 0x20;
 714
 715         if (params->u.qpsk.symbol_rate < 4000000)
 716                 buf[3] |= 1;
 717
 718         if (params->frequency < 1250000)
 719                 buf[3] |= 0;
 720         else if (params->frequency < 1550000)
 721                 buf[3] |= 0x40;
 722         else if (params->frequency < 2050000)
 723                 buf[3] |= 0x80;
 724         else if (params->frequency < 2150000)
 725                 buf[3] |= 0xC0;
 726
 727         if (fe->ops.i2c_gate_ctrl)
 728                 fe->ops.i2c_gate_ctrl(fe, 1);
 729         if (i2c_transfer(&budget_ci->budget.i2c_adap, &msg, 1) != 1)
 730                 return -EIO;
 731         return 0;
 732 }
 733
 734 static struct stv0299_config philips_su1278_tt_config = {
 735
 736         .demod_address = 0x68,
 737         .inittab = philips_su1278_tt_inittab,
 738         .mclk = 64000000UL,
 739         .invert = 0,
 740         .skip_reinit = 1,
 741         .lock_output = STV0299_LOCKOUTPUT_1,
 742         .volt13_op0_op1 = STV0299_VOLT13_OP1,
 743         .min_delay_ms = 50,
 744         .set_symbol_rate = philips_su1278_tt_set_symbol_rate,
 745 };
 746
 747
 748
 749 static int philips_tdm1316l_tuner_init(struct dvb_frontend *fe)
 750 {
 751         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 752         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
 753         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
 754         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = td1316_init,.len =
 755                         sizeof(td1316_init) };
 756
 757         // setup PLL configuration
 758         if (fe->ops.i2c_gate_ctrl)
 759                 fe->ops.i2c_gate_ctrl(fe, 1);
 760         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 761                 return -EIO;
 762         msleep(1);
 763
 764         // disable the mc44BC374c (do not check for errors)
 765         tuner_msg.addr = 0x65;
 766         tuner_msg.buf = disable_mc44BC374c;
 767         tuner_msg.len = sizeof(disable_mc44BC374c);
 768         if (fe->ops.i2c_gate_ctrl)
 769                 fe->ops.i2c_gate_ctrl(fe, 1);
 770         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) {
 771                 if (fe->ops.i2c_gate_ctrl)
 772                         fe->ops.i2c_gate_ctrl(fe, 1);
 773                 i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1);
 774         }
 775
 776         return 0;
 777 }
 778
 779 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 780 {
 781         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 782         u8 tuner_buf[4];
 783         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = tuner_buf,.len = sizeof(tuner_buf) };
 784         int tuner_frequency = 0;
 785         u8 band, cp, filter;
 786
 787         // determine charge pump
 788         tuner_frequency = params->frequency + 36130000;
 789         if (tuner_frequency < 87000000)
 790                 return -EINVAL;
 791         else if (tuner_frequency < 130000000)
 792                 cp = 3;
 793         else if (tuner_frequency < 160000000)
 794                 cp = 5;
 795         else if (tuner_frequency < 200000000)
 796                 cp = 6;
 797         else if (tuner_frequency < 290000000)
 798                 cp = 3;
 799         else if (tuner_frequency < 420000000)
 800                 cp = 5;
 801         else if (tuner_frequency < 480000000)
 802                 cp = 6;
 803         else if (tuner_frequency < 620000000)
 804                 cp = 3;
 805         else if (tuner_frequency < 830000000)
 806                 cp = 5;
 807         else if (tuner_frequency < 895000000)
 808                 cp = 7;
 809         else
 810                 return -EINVAL;
 811
 812         // determine band
 813         if (params->frequency < 49000000)
 814                 return -EINVAL;
 815         else if (params->frequency < 159000000)
 816                 band = 1;
 817         else if (params->frequency < 444000000)
 818                 band = 2;
 819         else if (params->frequency < 861000000)
 820                 band = 4;
 821         else
 822                 return -EINVAL;
 823
 824         // setup PLL filter and TDA9889
 825         switch (params->u.ofdm.bandwidth) {
 826         case BANDWIDTH_6_MHZ:
 827                 tda1004x_writereg(fe, 0x0C, 0x14);
 828                 filter = 0;
 829                 break;
 830
 831         case BANDWIDTH_7_MHZ:
 832                 tda1004x_writereg(fe, 0x0C, 0x80);
 833                 filter = 0;
 834                 break;
 835
 836         case BANDWIDTH_8_MHZ:
 837                 tda1004x_writereg(fe, 0x0C, 0x14);
 838                 filter = 1;
 839                 break;
 840
 841         default:
 842                 return -EINVAL;
 843         }
 844
 845         // calculate divisor
 846         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
 847         tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
 848
 849         // setup tuner buffer
 850         tuner_buf[0] = tuner_frequency >> 8;
 851         tuner_buf[1] = tuner_frequency & 0xff;
 852         tuner_buf[2] = 0xca;
 853         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 854
 855         if (fe->ops.i2c_gate_ctrl)
 856                 fe->ops.i2c_gate_ctrl(fe, 1);
 857         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 858                 return -EIO;
 859
 860         msleep(1);
 861         return 0;
 862 }
 863
 864 static int philips_tdm1316l_request_firmware(struct dvb_frontend *fe,
 865                                              const struct firmware **fw, char *name)
 866 {
 867         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 868
 869         return request_firmware(fw, name, &budget_ci->budget.dev->pci->dev);
 870 }
 871
 872 static struct tda1004x_config philips_tdm1316l_config = {
 873
 874         .demod_address = 0x8,
 875         .invert = 0,
 876         .invert_oclk = 0,
 877         .xtal_freq = TDA10046_XTAL_4M,
 878         .agc_config = TDA10046_AGC_DEFAULT,
 879         .if_freq = TDA10046_FREQ_3617,
 880         .request_firmware = philips_tdm1316l_request_firmware,
 881 };
 882
 883 static struct tda1004x_config philips_tdm1316l_config_invert = {
 884
 885         .demod_address = 0x8,
 886         .invert = 1,
 887         .invert_oclk = 0,
 888         .xtal_freq = TDA10046_XTAL_4M,
 889         .agc_config = TDA10046_AGC_DEFAULT,
 890         .if_freq = TDA10046_FREQ_3617,
 891         .request_firmware = philips_tdm1316l_request_firmware,
 892 };
 893
 894 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 895 {
 896         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 897         u8 tuner_buf[5];
 898         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,
 899                                     .flags = 0,
 900                                     .buf = tuner_buf,
 901                                     .len = sizeof(tuner_buf) };
 902         int tuner_frequency = 0;
 903         u8 band, cp, filter;
 904
 905         // determine charge pump
 906         tuner_frequency = params->frequency + 36125000;
 907         if (tuner_frequency < 87000000)
 908                 return -EINVAL;
 909         else if (tuner_frequency < 130000000) {
 910                 cp = 3;
 911                 band = 1;
 912         } else if (tuner_frequency < 160000000) {
 913                 cp = 5;
 914                 band = 1;
 915         } else if (tuner_frequency < 200000000) {
 916                 cp = 6;
 917                 band = 1;
 918         } else if (tuner_frequency < 290000000) {
 919                 cp = 3;
 920                 band = 2;
 921         } else if (tuner_frequency < 420000000) {
 922                 cp = 5;
 923                 band = 2;
 924         } else if (tuner_frequency < 480000000) {
 925                 cp = 6;
 926                 band = 2;
 927         } else if (tuner_frequency < 620000000) {
 928                 cp = 3;
 929                 band = 4;
 930         } else if (tuner_frequency < 830000000) {
 931                 cp = 5;
 932                 band = 4;
 933         } else if (tuner_frequency < 895000000) {
 934                 cp = 7;
 935                 band = 4;
 936         } else
 937                 return -EINVAL;
 938
 939         // assume PLL filter should always be 8MHz for the moment.
 940         filter = 1;
 941
 942         // calculate divisor
 943         tuner_frequency = (params->frequency + 36125000 + (62500/2)) / 62500;
 944
 945         // setup tuner buffer
 946         tuner_buf[0] = tuner_frequency >> 8;
 947         tuner_buf[1] = tuner_frequency & 0xff;
 948         tuner_buf[2] = 0xc8;
 949         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 950         tuner_buf[4] = 0x80;
 951
 952         if (fe->ops.i2c_gate_ctrl)
 953                 fe->ops.i2c_gate_ctrl(fe, 1);
 954         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 955                 return -EIO;
 956
 957         msleep(50);
 958
 959         if (fe->ops.i2c_gate_ctrl)
 960                 fe->ops.i2c_gate_ctrl(fe, 1);
 961         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 962                 return -EIO;
 963
 964         msleep(1);
 965
 966         return 0;
 967 }
 968
 969 static u8 dvbc_philips_tdm1316l_inittab[] = {
 970         0x80, 0x01,
 971         0x80, 0x00,
 972         0x81, 0x01,
 973         0x81, 0x00,
 974         0x00, 0x09,
 975         0x01, 0x69,
 976         0x03, 0x00,
 977         0x04, 0x00,
 978         0x07, 0x00,
 979         0x08, 0x00,
 980         0x20, 0x00,
 981         0x21, 0x40,
 982         0x22, 0x00,
 983         0x23, 0x00,
 984         0x24, 0x40,
 985         0x25, 0x88,
 986         0x30, 0xff,
 987         0x31, 0x00,
 988         0x32, 0xff,
 989         0x33, 0x00,
 990         0x34, 0x50,
 991         0x35, 0x7f,
 992         0x36, 0x00,
 993         0x37, 0x20,
 994         0x38, 0x00,
 995         0x40, 0x1c,
 996         0x41, 0xff,
 997         0x42, 0x29,
 998         0x43, 0x20,
 999         0x44, 0xff,
1000         0x45, 0x00,
1001         0x46, 0x00,
1002         0x49, 0x04,
1003         0x4a, 0x00,
1004         0x4b, 0x7b,
1005         0x52, 0x30,
1006         0x55, 0xae,
1007         0x56, 0x47,
1008         0x57, 0xe1,
1009         0x58, 0x3a,
1010         0x5a, 0x1e,
1011         0x5b, 0x34,
1012         0x60, 0x00,
1013         0x63, 0x00,
1014         0x64, 0x00,
1015         0x65, 0x00,
1016         0x66, 0x00,
1017         0x67, 0x00,
1018         0x68, 0x00,
1019         0x69, 0x00,
1020         0x6a, 0x02,
1021         0x6b, 0x00,
1022         0x70, 0xff,
1023         0x71, 0x00,
1024         0x72, 0x00,
1025         0x73, 0x00,
1026         0x74, 0x0c,
1027         0x80, 0x00,
1028         0x81, 0x00,
1029         0x82, 0x00,
1030         0x83, 0x00,
1031         0x84, 0x04,
1032         0x85, 0x80,
1033         0x86, 0x24,
1034         0x87, 0x78,
1035         0x88, 0x10,
1036         0x89, 0x00,
1037         0x90, 0x01,
1038         0x91, 0x01,
1039         0xa0, 0x04,
1040         0xa1, 0x00,
1041         0xa2, 0x00,
1042         0xb0, 0x91,
1043         0xb1, 0x0b,
1044         0xc0, 0x53,
1045         0xc1, 0x70,
1046         0xc2, 0x12,
1047         0xd0, 0x00,
1048         0xd1, 0x00,
1049         0xd2, 0x00,
1050         0xd3, 0x00,
1051         0xd4, 0x00,
1052         0xd5, 0x00,
1053         0xde, 0x00,
1054         0xdf, 0x00,
1055         0x61, 0x38,
1056         0x62, 0x0a,
1057         0x53, 0x13,
1058         0x59, 0x08,
1059         0xff, 0xff,
1060 };
1061
1062 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1063         .demod_address = 0x1c,
1064         .inittab = dvbc_philips_tdm1316l_inittab,
1065         .invert = 0,
1066         .stop_during_read = 1,
1067 };
1068
1069 static struct tda10023_config tda10023_config = {
1070         .demod_address = 0xc,
1071         .invert = 0,
1072         .xtal = 16000000,
1073         .pll_m = 11,
1074         .pll_p = 3,
1075         .pll_n = 1,
1076         .deltaf = 0xa511,
1077 };
1078
1079 static struct tda827x_config tda827x_config = {
1080         .config = 0,
1081 };
1082
1083 /* TT S2-3200 DVB-S (STB0899) Inittab */
1084 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_1[] = {
1085
1086         { STB0899_DEV_ID                , 0x81 },
1087         { STB0899_DISCNTRL1             , 0x32 },
1088         { STB0899_DISCNTRL2             , 0x80 },
1089         { STB0899_DISRX_ST0             , 0x04 },
1090         { STB0899_DISRX_ST1             , 0x00 },
1091         { STB0899_DISPARITY             , 0x00 },
1092         { STB0899_DISFIFO               , 0x00 },
1093         { STB0899_DISSTATUS             , 0x20 },
1094         { STB0899_DISF22                , 0x8c },
1095         { STB0899_DISF22RX              , 0x9a },
1096         { STB0899_SYSREG                , 0x0b },
1097         { STB0899_ACRPRESC              , 0x11 },
1098         { STB0899_ACRDIV1               , 0x0a },
1099         { STB0899_ACRDIV2               , 0x05 },
1100         { STB0899_DACR1                 , 0x00 },
1101         { STB0899_DACR2                 , 0x00 },
1102         { STB0899_OUTCFG                , 0x00 },
1103         { STB0899_MODECFG               , 0x00 },
1104         { STB0899_IRQSTATUS_3           , 0x30 },
1105         { STB0899_IRQSTATUS_2           , 0x00 },
1106         { STB0899_IRQSTATUS_1           , 0x00 },
1107         { STB0899_IRQSTATUS_0           , 0x00 },
1108         { STB0899_IRQMSK_3              , 0xf3 },
1109         { STB0899_IRQMSK_2              , 0xfc },
1110         { STB0899_IRQMSK_1              , 0xff },
1111         { STB0899_IRQMSK_0              , 0xff },
1112         { STB0899_IRQCFG                , 0x00 },
1113         { STB0899_I2CCFG                , 0x88 },
1114         { STB0899_I2CRPT                , 0x48 }, /* 12k Pullup, Repeater=16, Stop=disabled */
1115         { STB0899_IOPVALUE5             , 0x00 },
1116         { STB0899_IOPVALUE4             , 0x20 },
1117         { STB0899_IOPVALUE3             , 0xc9 },
1118         { STB0899_IOPVALUE2             , 0x90 },
1119         { STB0899_IOPVALUE1             , 0x40 },
1120         { STB0899_IOPVALUE0             , 0x00 },
1121         { STB0899_GPIO00CFG             , 0x82 },
1122         { STB0899_GPIO01CFG             , 0x82 },
1123         { STB0899_GPIO02CFG             , 0x82 },
1124         { STB0899_GPIO03CFG             , 0x82 },
1125         { STB0899_GPIO04CFG             , 0x82 },
1126         { STB0899_GPIO05CFG             , 0x82 },
1127         { STB0899_GPIO06CFG             , 0x82 },
1128         { STB0899_GPIO07CFG             , 0x82 },
1129         { STB0899_GPIO08CFG             , 0x82 },
1130         { STB0899_GPIO09CFG             , 0x82 },
1131         { STB0899_GPIO10CFG             , 0x82 },
1132         { STB0899_GPIO11CFG             , 0x82 },
1133         { STB0899_GPIO12CFG             , 0x82 },
1134         { STB0899_GPIO13CFG             , 0x82 },
1135         { STB0899_GPIO14CFG             , 0x82 },
1136         { STB0899_GPIO15CFG             , 0x82 },
1137         { STB0899_GPIO16CFG             , 0x82 },
1138         { STB0899_GPIO17CFG             , 0x82 },
1139         { STB0899_GPIO18CFG             , 0x82 },
1140         { STB0899_GPIO19CFG             , 0x82 },
1141         { STB0899_GPIO20CFG             , 0x82 },
1142         { STB0899_SDATCFG               , 0xb8 },
1143         { STB0899_SCLTCFG               , 0xba },
1144         { STB0899_AGCRFCFG              , 0x1c }, /* 0x11 */
1145         { STB0899_GPIO22                , 0x82 }, /* AGCBB2CFG */
1146         { STB0899_GPIO21                , 0x91 }, /* AGCBB1CFG */
1147         { STB0899_DIRCLKCFG             , 0x82 },
1148         { STB0899_CLKOUT27CFG           , 0x7e },
1149         { STB0899_STDBYCFG              , 0x82 },
1150         { STB0899_CS0CFG                , 0x82 },
1151         { STB0899_CS1CFG                , 0x82 },
1152         { STB0899_DISEQCOCFG            , 0x20 },
1153         { STB0899_GPIO32CFG             , 0x82 },
1154         { STB0899_GPIO33CFG             , 0x82 },
1155         { STB0899_GPIO34CFG             , 0x82 },
1156         { STB0899_GPIO35CFG             , 0x82 },
1157         { STB0899_GPIO36CFG             , 0x82 },
1158         { STB0899_GPIO37CFG             , 0x82 },
1159         { STB0899_GPIO38CFG             , 0x82 },
1160         { STB0899_GPIO39CFG             , 0x82 },
1161         { STB0899_NCOARSE               , 0x15 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */
1162         { STB0899_SYNTCTRL              , 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */
1163         { STB0899_FILTCTRL              , 0x00 },
1164         { STB0899_SYSCTRL               , 0x00 },
1165         { STB0899_STOPCLK1              , 0x20 },
1166         { STB0899_STOPCLK2              , 0x00 },
1167         { STB0899_INTBUFSTATUS          , 0x00 },
1168         { STB0899_INTBUFCTRL            , 0x0a },
1169         { 0xffff                        , 0xff },
1170 };
1171
1172 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_3[] = {
1173         { STB0899_DEMOD                 , 0x00 },
1174         { STB0899_RCOMPC                , 0xc9 },
1175         { STB0899_AGC1CN                , 0x41 },
1176         { STB0899_AGC1REF               , 0x10 },
1177         { STB0899_RTC                   , 0x7a },
1178         { STB0899_TMGCFG                , 0x4e },
1179         { STB0899_AGC2REF               , 0x34 },
1180         { STB0899_TLSR                  , 0x84 },
1181         { STB0899_CFD                   , 0xc7 },
1182         { STB0899_ACLC                  , 0x87 },
1183         { STB0899_BCLC                  , 0x94 },
1184         { STB0899_EQON                  , 0x41 },
1185         { STB0899_LDT                   , 0xdd },
1186         { STB0899_LDT2                  , 0xc9 },
1187         { STB0899_EQUALREF              , 0xb4 },
1188         { STB0899_TMGRAMP               , 0x10 },
1189         { STB0899_TMGTHD                , 0x30 },
1190         { STB0899_IDCCOMP               , 0xfb },
1191         { STB0899_QDCCOMP               , 0x03 },
1192         { STB0899_POWERI                , 0x3b },
1193         { STB0899_POWERQ                , 0x3d },
1194         { STB0899_RCOMP                 , 0x81 },
1195         { STB0899_AGCIQIN               , 0x80 },
1196         { STB0899_AGC2I1                , 0x04 },
1197         { STB0899_AGC2I2                , 0xf5 },
1198         { STB0899_TLIR                  , 0x25 },
1199         { STB0899_RTF                   , 0x80 },
1200         { STB0899_DSTATUS               , 0x00 },
1201         { STB0899_LDI                   , 0xca },
1202         { STB0899_CFRM                  , 0xf1 },
1203         { STB0899_CFRL                  , 0xf3 },
1204         { STB0899_NIRM                  , 0x2a },
1205         { STB0899_NIRL                  , 0x05 },
1206         { STB0899_ISYMB                 , 0x17 },
1207         { STB0899_QSYMB                 , 0xfa },
1208         { STB0899_SFRH                  , 0x2f },
1209         { STB0899_SFRM                  , 0x68 },
1210         { STB0899_SFRL                  , 0x40 },
1211         { STB0899_SFRUPH                , 0x2f },
1212         { STB0899_SFRUPM                , 0x68 },
1213         { STB0899_SFRUPL                , 0x40 },
1214         { STB0899_EQUAI1                , 0xfd },
1215         { STB0899_EQUAQ1                , 0x04 },
1216         { STB0899_EQUAI2                , 0x0f },
1217         { STB0899_EQUAQ2                , 0xff },
1218         { STB0899_EQUAI3                , 0xdf },
1219         { STB0899_EQUAQ3                , 0xfa },
1220         { STB0899_EQUAI4                , 0x37 },
1221         { STB0899_EQUAQ4                , 0x0d },
1222         { STB0899_EQUAI5                , 0xbd },
1223         { STB0899_EQUAQ5                , 0xf7 },
1224         { STB0899_DSTATUS2              , 0x00 },
1225         { STB0899_VSTATUS               , 0x00 },
1226         { STB0899_VERROR                , 0xff },
1227         { STB0899_IQSWAP                , 0x2a },
1228         { STB0899_ECNT1M                , 0x00 },
1229         { STB0899_ECNT1L                , 0x00 },
1230         { STB0899_ECNT2M                , 0x00 },
1231         { STB0899_ECNT2L                , 0x00 },
1232         { STB0899_ECNT3M                , 0x00 },
1233         { STB0899_ECNT3L                , 0x00 },
1234         { STB0899_FECAUTO1              , 0x06 },
1235         { STB0899_FECM                  , 0x01 },
1236         { STB0899_VTH12                 , 0xf0 },
1237         { STB0899_VTH23                 , 0xa0 },
1238         { STB0899_VTH34                 , 0x78 },
1239         { STB0899_VTH56                 , 0x4e },
1240         { STB0899_VTH67                 , 0x48 },
1241         { STB0899_VTH78                 , 0x38 },
1242         { STB0899_PRVIT                 , 0xff },
1243         { STB0899_VITSYNC               , 0x19 },
1244         { STB0899_RSULC                 , 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
1245         { STB0899_TSULC                 , 0x42 },
1246         { STB0899_RSLLC                 , 0x40 },
1247         { STB0899_TSLPL                 , 0x12 },
1248         { STB0899_TSCFGH                , 0x0c },
1249         { STB0899_TSCFGM                , 0x00 },
1250         { STB0899_TSCFGL                , 0x0c },
1251         { STB0899_TSOUT                 , 0x0d }, /* 0x0d for CAM */
1252         { STB0899_RSSYNCDEL             , 0x00 },
1253         { STB0899_TSINHDELH             , 0x02 },
1254         { STB0899_TSINHDELM             , 0x00 },
1255         { STB0899_TSINHDELL             , 0x00 },
1256         { STB0899_TSLLSTKM              , 0x00 },
1257         { STB0899_TSLLSTKL              , 0x00 },
1258         { STB0899_TSULSTKM              , 0x00 },
1259         { STB0899_TSULSTKL              , 0xab },
1260         { STB0899_PCKLENUL              , 0x00 },
1261         { STB0899_PCKLENLL              , 0xcc },
1262         { STB0899_RSPCKLEN              , 0xcc },
1263         { STB0899_TSSTATUS              , 0x80 },
1264         { STB0899_ERRCTRL1              , 0xb6 },
1265         { STB0899_ERRCTRL2              , 0x96 },
1266         { STB0899_ERRCTRL3              , 0x89 },
1267         { STB0899_DMONMSK1              , 0x27 },
1268         { STB0899_DMONMSK0              , 0x03 },
1269         { STB0899_DEMAPVIT              , 0x5c },
1270         { STB0899_PLPARM                , 0x1f },
1271         { STB0899_PDELCTRL              , 0x48 },
1272         { STB0899_PDELCTRL2             , 0x00 },
1273         { STB0899_BBHCTRL1              , 0x00 },
1274         { STB0899_BBHCTRL2              , 0x00 },
1275         { STB0899_HYSTTHRESH            , 0x77 },
1276         { STB0899_MATCSTM               , 0x00 },
1277         { STB0899_MATCSTL               , 0x00 },
1278         { STB0899_UPLCSTM               , 0x00 },
1279         { STB0899_UPLCSTL               , 0x00 },
1280         { STB0899_DFLCSTM               , 0x00 },
1281         { STB0899_DFLCSTL               , 0x00 },
1282         { STB0899_SYNCCST               , 0x00 },
1283         { STB0899_SYNCDCSTM             , 0x00 },
1284         { STB0899_SYNCDCSTL             , 0x00 },
1285         { STB0899_ISI_ENTRY             , 0x00 },
1286         { STB0899_ISI_BIT_EN            , 0x00 },
1287         { STB0899_MATSTRM               , 0x00 },
1288         { STB0899_MATSTRL               , 0x00 },
1289         { STB0899_UPLSTRM               , 0x00 },
1290         { STB0899_UPLSTRL               , 0x00 },
1291         { STB0899_DFLSTRM               , 0x00 },
1292         { STB0899_DFLSTRL               , 0x00 },
1293         { STB0899_SYNCSTR               , 0x00 },
1294         { STB0899_SYNCDSTRM             , 0x00 },
1295         { STB0899_SYNCDSTRL             , 0x00 },
1296         { STB0899_CFGPDELSTATUS1        , 0x10 },
1297         { STB0899_CFGPDELSTATUS2        , 0x00 },
1298         { STB0899_BBFERRORM             , 0x00 },
1299         { STB0899_BBFERRORL             , 0x00 },
1300         { STB0899_UPKTERRORM            , 0x00 },
1301         { STB0899_UPKTERRORL            , 0x00 },
1302         { 0xffff                        , 0xff },
1303 };
1304
1305 static struct stb0899_config tt3200_config = {
1306         .init_dev               = tt3200_stb0899_s1_init_1,
1307         .init_s2_demod          = stb0899_s2_init_2,
1308         .init_s1_demod          = tt3200_stb0899_s1_init_3,
1309         .init_s2_fec            = stb0899_s2_init_4,
1310         .init_tst               = stb0899_s1_init_5,
1311
1312         .postproc               = NULL,
1313
1314         .demod_address          = 0x68,
1315
1316         .xtal_freq              = 27000000,
1317         .inversion              = IQ_SWAP_ON, /* 1 */
1318
1319         .lo_clk                 = 76500000,
1320         .hi_clk                 = 99000000,
1321
1322         .esno_ave               = STB0899_DVBS2_ESNO_AVE,
1323         .esno_quant             = STB0899_DVBS2_ESNO_QUANT,
1324         .avframes_coarse        = STB0899_DVBS2_AVFRAMES_COARSE,
1325         .avframes_fine          = STB0899_DVBS2_AVFRAMES_FINE,
1326         .miss_threshold         = STB0899_DVBS2_MISS_THRESHOLD,
1327         .uwp_threshold_acq      = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
1328         .uwp_threshold_track    = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
1329         .uwp_threshold_sof      = STB0899_DVBS2_UWP_THRESHOLD_SOF,
1330         .sof_search_timeout     = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
1331
1332         .btr_nco_bits           = STB0899_DVBS2_BTR_NCO_BITS,
1333         .btr_gain_shift_offset  = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
1334         .crl_nco_bits           = STB0899_DVBS2_CRL_NCO_BITS,
1335         .ldpc_max_iter          = STB0899_DVBS2_LDPC_MAX_ITER,
1336
1337         .tuner_get_frequency    = stb6100_get_frequency,
1338         .tuner_set_frequency    = stb6100_set_frequency,
1339         .tuner_set_bandwidth    = stb6100_set_bandwidth,
1340         .tuner_get_bandwidth    = stb6100_get_bandwidth,
1341         .tuner_set_rfsiggain    = NULL
1342 };
1343
1344 static struct stb6100_config tt3200_stb6100_config = {
1345         .tuner_address  = 0x60,
1346         .refclock       = 27000000,
1347 };
1348
1349 static void frontend_init(struct budget_ci *budget_ci)
1350 {
1351         switch (budget_ci->budget.dev->pci->subsystem_device) {
1352         case 0x100c:            // Hauppauge/TT Nova-CI budget (stv0299/ALPS BSRU6(tsa5059))
1353                 budget_ci->budget.dvb_frontend =
1354                         dvb_attach(stv0299_attach, &alps_bsru6_config, &budget_ci->budget.i2c_adap);
1355                 if (budget_ci->budget.dvb_frontend) {
1356                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
1357                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1358                         break;
1359                 }
1360                 break;
1361
1362         case 0x100f:            // Hauppauge/TT Nova-CI budget (stv0299b/Philips su1278(tsa5059))
1363                 budget_ci->budget.dvb_frontend =
1364                         dvb_attach(stv0299_attach, &philips_su1278_tt_config, &budget_ci->budget.i2c_adap);
1365                 if (budget_ci->budget.dvb_frontend) {
1366                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_su1278_tt_tuner_set_params;
1367                         break;
1368                 }
1369                 break;
1370
1371         case 0x1010:            // TT DVB-C CI budget (stv0297/Philips tdm1316l(tda6651tt))
1372                 budget_ci->tuner_pll_address = 0x61;
1373                 budget_ci->budget.dvb_frontend =
1374                         dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1375                 if (budget_ci->budget.dvb_frontend) {
1376                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1377                         break;
1378                 }
1379                 break;
1380
1381         case 0x1011:            // Hauppauge/TT Nova-T budget (tda10045/Philips tdm1316l(tda6651tt) + TDA9889)
1382                 budget_ci->tuner_pll_address = 0x63;
1383                 budget_ci->budget.dvb_frontend =
1384                         dvb_attach(tda10045_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1385                 if (budget_ci->budget.dvb_frontend) {
1386                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1387                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1388                         break;
1389                 }
1390                 break;
1391
1392         case 0x1012:            // TT DVB-T CI budget (tda10046/Philips tdm1316l(tda6651tt))
1393                 budget_ci->tuner_pll_address = 0x60;
1394                 budget_ci->budget.dvb_frontend =
1395                         dvb_attach(tda10046_attach, &philips_tdm1316l_config_invert, &budget_ci->budget.i2c_adap);
1396                 if (budget_ci->budget.dvb_frontend) {
1397                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1398                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1399                         break;
1400                 }
1401                 break;
1402
1403         case 0x1017:            // TT S-1500 PCI
1404                 budget_ci->budget.dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config, &budget_ci->budget.i2c_adap);
1405                 if (budget_ci->budget.dvb_frontend) {
1406                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
1407                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1408
1409                         budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
1410                         if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) {
1411                                 printk("%s: No LNBP21 found!\n", __func__);
1412                                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1413                                 budget_ci->budget.dvb_frontend = NULL;
1414                         }
1415                 }
1416                 break;
1417
1418         case 0x101a: /* TT Budget-C-1501 (philips tda10023/philips tda8274A) */
1419                 budget_ci->budget.dvb_frontend = dvb_attach(tda10023_attach, &tda10023_config, &budget_ci->budget.i2c_adap, 0x48);
1420                 if (budget_ci->budget.dvb_frontend) {
1421                         if (dvb_attach(tda827x_attach, budget_ci->budget.dvb_frontend, 0x61, &budget_ci->budget.i2c_adap, &tda827x_config) == NULL) {
1422                                 printk(KERN_ERR "%s: No tda827x found!\n", __func__);
1423                                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1424                                 budget_ci->budget.dvb_frontend = NULL;
1425                         }
1426                 }
1427                 break;
1428
1429         case 0x1019:            // TT S2-3200 PCI
1430                 /*
1431                  * NOTE! on some STB0899 versions, the internal PLL takes a longer time
1432                  * to settle, aka LOCK. On the older revisions of the chip, we don't see
1433                  * this, as a result on the newer chips the entire clock tree, will not
1434                  * be stable after a freshly POWER 'ed up situation.
1435                  * In this case, we should RESET the STB0899 (Active LOW) and wait for
1436                  * PLL stabilization.
1437                  *
1438                  * On the TT S2 3200 and clones, the STB0899 demodulator's RESETB is
1439                  * connected to the SAA7146 GPIO, GPIO2, Pin 142
1440                  */
1441                 /* Reset Demodulator */
1442                 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTLO);
1443                 /* Wait for everything to die */
1444                 msleep(50);
1445                 /* Pull it up out of Reset state */
1446                 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTHI);
1447                 /* Wait for PLL to stabilize */
1448                 msleep(250);
1449                 /*
1450                  * PLL state should be stable now. Ideally, we should check
1451                  * for PLL LOCK status. But well, never mind!
1452                  */
1453                 budget_ci->budget.dvb_frontend = dvb_attach(stb0899_attach, &tt3200_config, &budget_ci->budget.i2c_adap);
1454                 if (budget_ci->budget.dvb_frontend) {
1455                         if (dvb_attach(stb6100_attach, budget_ci->budget.dvb_frontend, &tt3200_stb6100_config, &budget_ci->budget.i2c_adap)) {
1456                                 if (!dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, 0, 0)) {
1457                                         printk("%s: No LNBP21 found!\n", __func__);
1458                                         dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1459                                         budget_ci->budget.dvb_frontend = NULL;
1460                                 }
1461                         } else {
1462                                         dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1463                                         budget_ci->budget.dvb_frontend = NULL;
1464                         }
1465                 }
1466                 break;
1467
1468         }
1469
1470         if (budget_ci->budget.dvb_frontend == NULL) {
1471                 printk("budget-ci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
1472                        budget_ci->budget.dev->pci->vendor,
1473                        budget_ci->budget.dev->pci->device,
1474                        budget_ci->budget.dev->pci->subsystem_vendor,
1475                        budget_ci->budget.dev->pci->subsystem_device);
1476         } else {
1477                 if (dvb_register_frontend
1478                     (&budget_ci->budget.dvb_adapter, budget_ci->budget.dvb_frontend)) {
1479                         printk("budget-ci: Frontend registration failed!\n");
1480                         dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1481                         budget_ci->budget.dvb_frontend = NULL;
1482                 }
1483         }
1484 }
1485
1486 static int budget_ci_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1487 {
1488         struct budget_ci *budget_ci;
1489         int err;
1490
1491         budget_ci = kzalloc(sizeof(struct budget_ci), GFP_KERNEL);
1492         if (!budget_ci) {
1493                 err = -ENOMEM;
1494                 goto out1;
1495         }
1496
1497         dprintk(2, "budget_ci: %p\n", budget_ci);
1498
1499         dev->ext_priv = budget_ci;
1500
1501         err = ttpci_budget_init(&budget_ci->budget, dev, info, THIS_MODULE,
1502                                 adapter_nr);
1503         if (err)
1504                 goto out2;
1505
1506         err = msp430_ir_init(budget_ci);
1507         if (err)
1508                 goto out3;
1509
1510         ciintf_init(budget_ci);
1511
1512         budget_ci->budget.dvb_adapter.priv = budget_ci;
1513         frontend_init(budget_ci);
1514
1515         ttpci_budget_init_hooks(&budget_ci->budget);
1516
1517         return 0;
1518
1519 out3:
1520         ttpci_budget_deinit(&budget_ci->budget);
1521 out2:
1522         kfree(budget_ci);
1523 out1:
1524         return err;
1525 }
1526
1527 static int budget_ci_detach(struct saa7146_dev *dev)
1528 {
1529         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
1530         struct saa7146_dev *saa = budget_ci->budget.dev;
1531         int err;
1532
1533         if (budget_ci->budget.ci_present)
1534                 ciintf_deinit(budget_ci);
1535         msp430_ir_deinit(budget_ci);
1536         if (budget_ci->budget.dvb_frontend) {
1537                 dvb_unregister_frontend(budget_ci->budget.dvb_frontend);
1538                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1539         }
1540         err = ttpci_budget_deinit(&budget_ci->budget);
1541
1542         // disable frontend and CI interface
1543         saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
1544
1545         kfree(budget_ci);
1546
1547         return err;
1548 }
1549
1550 static struct saa7146_extension budget_extension;
1551
1552 MAKE_BUDGET_INFO(ttbs2, "TT-Budget/S-1500 PCI", BUDGET_TT);
1553 MAKE_BUDGET_INFO(ttbci, "TT-Budget/WinTV-NOVA-CI PCI", BUDGET_TT_HW_DISEQC);
1554 MAKE_BUDGET_INFO(ttbt2, "TT-Budget/WinTV-NOVA-T  PCI", BUDGET_TT);
1555 MAKE_BUDGET_INFO(ttbtci, "TT-Budget-T-CI PCI", BUDGET_TT);
1556 MAKE_BUDGET_INFO(ttbcci, "TT-Budget-C-CI PCI", BUDGET_TT);
1557 MAKE_BUDGET_INFO(ttc1501, "TT-Budget C-1501 PCI", BUDGET_TT);
1558 MAKE_BUDGET_INFO(tt3200, "TT-Budget S2-3200 PCI", BUDGET_TT);
1559
1560 static struct pci_device_id pci_tbl[] = {
1561         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100c),
1562         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100f),
1563         MAKE_EXTENSION_PCI(ttbcci, 0x13c2, 0x1010),
1564         MAKE_EXTENSION_PCI(ttbt2, 0x13c2, 0x1011),
1565         MAKE_EXTENSION_PCI(ttbtci, 0x13c2, 0x1012),
1566         MAKE_EXTENSION_PCI(ttbs2, 0x13c2, 0x1017),
1567         MAKE_EXTENSION_PCI(ttc1501, 0x13c2, 0x101a),
1568         MAKE_EXTENSION_PCI(tt3200, 0x13c2, 0x1019),
1569         {
1570          .vendor = 0,
1571          }
1572 };
1573
1574 MODULE_DEVICE_TABLE(pci, pci_tbl);
1575
1576 static struct saa7146_extension budget_extension = {
1577         .name = "budget_ci dvb",
1578         .flags = SAA7146_USE_I2C_IRQ,
1579
1580         .module = THIS_MODULE,
1581         .pci_tbl = &pci_tbl[0],
1582         .attach = budget_ci_attach,
1583         .detach = budget_ci_detach,
1584
1585         .irq_mask = MASK_03 | MASK_06 | MASK_10,
1586         .irq_func = budget_ci_irq,
1587 };
1588
1589 static int __init budget_ci_init(void)
1590 {
1591         return saa7146_register_extension(&budget_extension);
1592 }
1593
1594 static void __exit budget_ci_exit(void)
1595 {
1596         saa7146_unregister_extension(&budget_extension);
1597 }
1598
1599 module_init(budget_ci_init);
1600 module_exit(budget_ci_exit);
1601
1602 MODULE_LICENSE("GPL");
1603 MODULE_AUTHOR("Michael Hunold, Jack Thomasson, Andrew de Quincey, others");
1604 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1605                    "budget PCI DVB cards w/ CI-module produced by "
1606                    "Siemens, Technotrend, Hauppauge");