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 "budget.h"
  33
  34 #include <linux/module.h>
  35 #include <linux/errno.h>
  36 #include <linux/slab.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/input.h>
  39 #include <linux/spinlock.h>
  40 #include <media/ir-common.h>
  41
  42 #include "dvb_ca_en50221.h"
  43 #include "stv0299.h"
  44 #include "stv0297.h"
  45 #include "tda1004x.h"
  46 #include "lnbp21.h"
  47 #include "bsbe1.h"
  48 #include "bsru6.h"
  49
  50 /*
  51  * Regarding DEBIADDR_IR:
  52  * Some CI modules hang if random addresses are read.
  53  * Using address 0x4000 for the IR read means that we
  54  * use the same address as for CI version, which should
  55  * be a safe default.
  56  */
  57 #define DEBIADDR_IR             0x4000
  58 #define DEBIADDR_CICONTROL      0x0000
  59 #define DEBIADDR_CIVERSION      0x4000
  60 #define DEBIADDR_IO             0x1000
  61 #define DEBIADDR_ATTR           0x3000
  62
  63 #define CICONTROL_RESET         0x01
  64 #define CICONTROL_ENABLETS      0x02
  65 #define CICONTROL_CAMDETECT     0x08
  66
  67 #define DEBICICTL               0x00420000
  68 #define DEBICICAM               0x02420000
  69
  70 #define SLOTSTATUS_NONE         1
  71 #define SLOTSTATUS_PRESENT      2
  72 #define SLOTSTATUS_RESET        4
  73 #define SLOTSTATUS_READY        8
  74 #define SLOTSTATUS_OCCUPIED     (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
  75
  76 /* Milliseconds during which key presses are regarded as key repeat and during
  77  * which the debounce logic is active
  78  */
  79 #define IR_REPEAT_TIMEOUT       350
  80
  81 /* RC5 device wildcard */
  82 #define IR_DEVICE_ANY           255
  83
  84 /* Some remotes sends multiple sequences per keypress (e.g. Zenith sends two),
  85  * this setting allows the superflous sequences to be ignored
  86  */
  87 static int debounce = 0;
  88 module_param(debounce, int, 0644);
  89 MODULE_PARM_DESC(debounce, "ignore repeated IR sequences (default: 0 = ignore no sequences)");
  90
  91 static int rc5_device = -1;
  92 module_param(rc5_device, int, 0644);
  93 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
  94
  95 static int ir_debug = 0;
  96 module_param(ir_debug, int, 0644);
  97 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
  98
  99 struct budget_ci_ir {
 100         struct input_dev *dev;
 101         struct tasklet_struct msp430_irq_tasklet;
 102         char name[72]; /* 40 + 32 for (struct saa7146_dev).name */
 103         char phys[32];
 104         struct ir_input_state state;
 105         int rc5_device;
 106 };
 107
 108 struct budget_ci {
 109         struct budget budget;
 110         struct tasklet_struct ciintf_irq_tasklet;
 111         int slot_status;
 112         int ci_irq;
 113         struct dvb_ca_en50221 ca;
 114         struct budget_ci_ir ir;
 115         u8 tuner_pll_address; /* used for philips_tdm1316l configs */
 116 };
 117
 118 static void msp430_ir_keyup(unsigned long data)
 119 {
 120         struct budget_ci_ir *ir = (struct budget_ci_ir *) data;
 121         ir_input_nokey(ir->dev, &ir->state);
 122 }
 123
 124 static void msp430_ir_interrupt(unsigned long data)
 125 {
 126         struct budget_ci *budget_ci = (struct budget_ci *) data;
 127         struct input_dev *dev = budget_ci->ir.dev;
 128         static int bounces = 0;
 129         int device;
 130         int toggle;
 131         static int prev_toggle = -1;
 132         static u32 ir_key;
 133         u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
 134
 135         /*
 136          * The msp430 chip can generate two different bytes, command and device
 137          *
 138          * type1: X1CCCCCC, C = command bits (0 - 63)
 139          * type2: X0TDDDDD, D = device bits (0 - 31), T = RC5 toggle bit
 140          *
 141          * More than one command byte may be generated before the device byte
 142          * Only when we have both, a correct keypress is generated
 143          */
 144
 145         /* Is this a RC5 command byte? */
 146         if (command & 0x40) {
 147                 if (ir_debug)
 148                         printk("budget_ci: received command byte 0x%02x\n", command);
 149                 ir_key = command & 0x3f;
 150                 return;
 151         }
 152
 153         /* It's a RC5 device byte */
 154         if (ir_debug)
 155                 printk("budget_ci: received device byte 0x%02x\n", command);
 156         device = command & 0x1f;
 157         toggle = command & 0x20;
 158
 159         if (budget_ci->ir.rc5_device != IR_DEVICE_ANY && budget_ci->ir.rc5_device != device)
 160                 return;
 161
 162         /* Ignore repeated key sequences if requested */
 163         if (toggle == prev_toggle && ir_key == dev->repeat_key &&
 164             bounces > 0 && timer_pending(&dev->timer)) {
 165                 if (ir_debug)
 166                         printk("budget_ci: debounce logic ignored IR command\n");
 167                 bounces--;
 168                 return;
 169         }
 170         prev_toggle = toggle;
 171
 172         /* Are we still waiting for a keyup event? */
 173         if (del_timer(&dev->timer))
 174                 ir_input_nokey(dev, &budget_ci->ir.state);
 175
 176         /* Generate keypress */
 177         if (ir_debug)
 178                 printk("budget_ci: generating keypress 0x%02x\n", ir_key);
 179         ir_input_keydown(dev, &budget_ci->ir.state, ir_key, (ir_key & (command << 8)));
 180
 181         /* Do we want to delay the keyup event? */
 182         if (debounce) {
 183                 bounces = debounce;
 184                 mod_timer(&dev->timer, jiffies + msecs_to_jiffies(IR_REPEAT_TIMEOUT));
 185         } else {
 186                 ir_input_nokey(dev, &budget_ci->ir.state);
 187         }
 188 }
 189
 190 static int msp430_ir_init(struct budget_ci *budget_ci)
 191 {
 192         struct saa7146_dev *saa = budget_ci->budget.dev;
 193         struct input_dev *input_dev = budget_ci->ir.dev;
 194         int error;
 195
 196         budget_ci->ir.dev = input_dev = input_allocate_device();
 197         if (!input_dev) {
 198                 printk(KERN_ERR "budget_ci: IR interface initialisation failed\n");
 199                 error = -ENOMEM;
 200                 goto out1;
 201         }
 202
 203         snprintf(budget_ci->ir.name, sizeof(budget_ci->ir.name),
 204                  "Budget-CI dvb ir receiver %s", saa->name);
 205         snprintf(budget_ci->ir.phys, sizeof(budget_ci->ir.phys),
 206                  "pci-%s/ir0", pci_name(saa->pci));
 207
 208         input_dev->name = budget_ci->ir.name;
 209
 210         input_dev->phys = budget_ci->ir.phys;
 211         input_dev->id.bustype = BUS_PCI;
 212         input_dev->id.version = 1;
 213         if (saa->pci->subsystem_vendor) {
 214                 input_dev->id.vendor = saa->pci->subsystem_vendor;
 215                 input_dev->id.product = saa->pci->subsystem_device;
 216         } else {
 217                 input_dev->id.vendor = saa->pci->vendor;
 218                 input_dev->id.product = saa->pci->device;
 219         }
 220 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
 221         input_dev->cdev.dev = &saa->pci->dev;
 222 # else
 223         input_dev->dev = &saa->pci->dev;
 224 # endif
 225
 226         /* Select keymap and address */
 227         switch (budget_ci->budget.dev->pci->subsystem_device) {
 228         case 0x100c:
 229         case 0x100f:
 230         case 0x1010:
 231         case 0x1011:
 232         case 0x1012:
 233         case 0x1017:
 234                 /* The hauppauge keymap is a superset of these remotes */
 235                 ir_input_init(input_dev, &budget_ci->ir.state,
 236                               IR_TYPE_RC5, ir_codes_hauppauge_new);
 237
 238                 if (rc5_device < 0)
 239                         budget_ci->ir.rc5_device = 0x1f;
 240                 else
 241                         budget_ci->ir.rc5_device = rc5_device;
 242                 break;
 243         default:
 244                 /* unknown remote */
 245                 ir_input_init(input_dev, &budget_ci->ir.state,
 246                               IR_TYPE_RC5, ir_codes_budget_ci_old);
 247
 248                 if (rc5_device < 0)
 249                         budget_ci->ir.rc5_device = IR_DEVICE_ANY;
 250                 else
 251                         budget_ci->ir.rc5_device = rc5_device;
 252                 break;
 253         }
 254
 255         /* initialise the key-up debounce timeout handler */
 256         input_dev->timer.function = msp430_ir_keyup;
 257         input_dev->timer.data = (unsigned long) &budget_ci->ir;
 258
 259         error = input_register_device(input_dev);
 260         if (error) {
 261                 printk(KERN_ERR "budget_ci: could not init driver for IR device (code %d)\n", error);
 262                 goto out2;
 263         }
 264
 265         tasklet_init(&budget_ci->ir.msp430_irq_tasklet, msp430_ir_interrupt,
 266                      (unsigned long) budget_ci);
 267
 268         saa7146_write(saa, IER, saa7146_read(saa, IER) | MASK_06);
 269         saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI);
 270
 271         return 0;
 272
 273 out2:
 274         input_free_device(input_dev);
 275 out1:
 276         return error;
 277 }
 278
 279 static void msp430_ir_deinit(struct budget_ci *budget_ci)
 280 {
 281         struct saa7146_dev *saa = budget_ci->budget.dev;
 282         struct input_dev *dev = budget_ci->ir.dev;
 283
 284         saa7146_write(saa, IER, saa7146_read(saa, IER) & ~MASK_06);
 285         saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
 286         tasklet_kill(&budget_ci->ir.msp430_irq_tasklet);
 287
 288         if (del_timer(&dev->timer)) {
 289                 ir_input_nokey(dev, &budget_ci->ir.state);
 290                 input_sync(dev);
 291         }
 292
 293         input_unregister_device(dev);
 294 }
 295
 296 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
 297 {
 298         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 299
 300         if (slot != 0)
 301                 return -EINVAL;
 302
 303         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
 304                                      DEBIADDR_ATTR | (address & 0xfff), 1, 1, 0);
 305 }
 306
 307 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
 308 {
 309         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 310
 311         if (slot != 0)
 312                 return -EINVAL;
 313
 314         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
 315                                       DEBIADDR_ATTR | (address & 0xfff), 1, value, 1, 0);
 316 }
 317
 318 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
 319 {
 320         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 321
 322         if (slot != 0)
 323                 return -EINVAL;
 324
 325         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
 326                                      DEBIADDR_IO | (address & 3), 1, 1, 0);
 327 }
 328
 329 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
 330 {
 331         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 332
 333         if (slot != 0)
 334                 return -EINVAL;
 335
 336         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
 337                                       DEBIADDR_IO | (address & 3), 1, value, 1, 0);
 338 }
 339
 340 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
 341 {
 342         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 343         struct saa7146_dev *saa = budget_ci->budget.dev;
 344
 345         if (slot != 0)
 346                 return -EINVAL;
 347
 348         if (budget_ci->ci_irq) {
 349                 // trigger on RISING edge during reset so we know when READY is re-asserted
 350                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 351         }
 352         budget_ci->slot_status = SLOTSTATUS_RESET;
 353         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
 354         msleep(1);
 355         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 356                                CICONTROL_RESET, 1, 0);
 357
 358         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
 359         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 360         return 0;
 361 }
 362
 363 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
 364 {
 365         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 366         struct saa7146_dev *saa = budget_ci->budget.dev;
 367
 368         if (slot != 0)
 369                 return -EINVAL;
 370
 371         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
 372         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 373         return 0;
 374 }
 375
 376 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
 377 {
 378         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 379         struct saa7146_dev *saa = budget_ci->budget.dev;
 380         int tmp;
 381
 382         if (slot != 0)
 383                 return -EINVAL;
 384
 385         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
 386
 387         tmp = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 388         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 389                                tmp | CICONTROL_ENABLETS, 1, 0);
 390
 391         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
 392         return 0;
 393 }
 394
 395 static void ciintf_interrupt(unsigned long data)
 396 {
 397         struct budget_ci *budget_ci = (struct budget_ci *) data;
 398         struct saa7146_dev *saa = budget_ci->budget.dev;
 399         unsigned int flags;
 400
 401         // ensure we don't get spurious IRQs during initialisation
 402         if (!budget_ci->budget.ci_present)
 403                 return;
 404
 405         // read the CAM status
 406         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 407         if (flags & CICONTROL_CAMDETECT) {
 408
 409                 // GPIO should be set to trigger on falling edge if a CAM is present
 410                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
 411
 412                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
 413                         // CAM insertion IRQ
 414                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
 415                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
 416                                                      DVB_CA_EN50221_CAMCHANGE_INSERTED);
 417
 418                 } else if (budget_ci->slot_status & SLOTSTATUS_RESET) {
 419                         // CAM ready (reset completed)
 420                         budget_ci->slot_status = SLOTSTATUS_READY;
 421                         dvb_ca_en50221_camready_irq(&budget_ci->ca, 0);
 422
 423                 } else if (budget_ci->slot_status & SLOTSTATUS_READY) {
 424                         // FR/DA IRQ
 425                         dvb_ca_en50221_frda_irq(&budget_ci->ca, 0);
 426                 }
 427         } else {
 428
 429                 // trigger on rising edge if a CAM is not present - when a CAM is inserted, we
 430                 // only want to get the IRQ when it sets READY. If we trigger on the falling edge,
 431                 // the CAM might not actually be ready yet.
 432                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 433
 434                 // generate a CAM removal IRQ if we haven't already
 435                 if (budget_ci->slot_status & SLOTSTATUS_OCCUPIED) {
 436                         // CAM removal IRQ
 437                         budget_ci->slot_status = SLOTSTATUS_NONE;
 438                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
 439                                                      DVB_CA_EN50221_CAMCHANGE_REMOVED);
 440                 }
 441         }
 442 }
 443
 444 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
 445 {
 446         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
 447         unsigned int flags;
 448
 449         // ensure we don't get spurious IRQs during initialisation
 450         if (!budget_ci->budget.ci_present)
 451                 return -EINVAL;
 452
 453         // read the CAM status
 454         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 455         if (flags & CICONTROL_CAMDETECT) {
 456                 // mark it as present if it wasn't before
 457                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
 458                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
 459                 }
 460
 461                 // during a RESET, we check if we can read from IO memory to see when CAM is ready
 462                 if (budget_ci->slot_status & SLOTSTATUS_RESET) {
 463                         if (ciintf_read_attribute_mem(ca, slot, 0) == 0x1d) {
 464                                 budget_ci->slot_status = SLOTSTATUS_READY;
 465                         }
 466                 }
 467         } else {
 468                 budget_ci->slot_status = SLOTSTATUS_NONE;
 469         }
 470
 471         if (budget_ci->slot_status != SLOTSTATUS_NONE) {
 472                 if (budget_ci->slot_status & SLOTSTATUS_READY) {
 473                         return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
 474                 }
 475                 return DVB_CA_EN50221_POLL_CAM_PRESENT;
 476         }
 477
 478         return 0;
 479 }
 480
 481 static int ciintf_init(struct budget_ci *budget_ci)
 482 {
 483         struct saa7146_dev *saa = budget_ci->budget.dev;
 484         int flags;
 485         int result;
 486         int ci_version;
 487         int ca_flags;
 488
 489         memset(&budget_ci->ca, 0, sizeof(struct dvb_ca_en50221));
 490
 491         // enable DEBI pins
 492         saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16) | 0x800);
 493
 494         // test if it is there
 495         ci_version = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CIVERSION, 1, 1, 0);
 496         if ((ci_version & 0xa0) != 0xa0) {
 497                 result = -ENODEV;
 498                 goto error;
 499         }
 500
 501         // determine whether a CAM is present or not
 502         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
 503         budget_ci->slot_status = SLOTSTATUS_NONE;
 504         if (flags & CICONTROL_CAMDETECT)
 505                 budget_ci->slot_status = SLOTSTATUS_PRESENT;
 506
 507         // version 0xa2 of the CI firmware doesn't generate interrupts
 508         if (ci_version == 0xa2) {
 509                 ca_flags = 0;
 510                 budget_ci->ci_irq = 0;
 511         } else {
 512                 ca_flags = DVB_CA_EN50221_FLAG_IRQ_CAMCHANGE |
 513                                 DVB_CA_EN50221_FLAG_IRQ_FR |
 514                                 DVB_CA_EN50221_FLAG_IRQ_DA;
 515                 budget_ci->ci_irq = 1;
 516         }
 517
 518         // register CI interface
 519         budget_ci->ca.owner = THIS_MODULE;
 520         budget_ci->ca.read_attribute_mem = ciintf_read_attribute_mem;
 521         budget_ci->ca.write_attribute_mem = ciintf_write_attribute_mem;
 522         budget_ci->ca.read_cam_control = ciintf_read_cam_control;
 523         budget_ci->ca.write_cam_control = ciintf_write_cam_control;
 524         budget_ci->ca.slot_reset = ciintf_slot_reset;
 525         budget_ci->ca.slot_shutdown = ciintf_slot_shutdown;
 526         budget_ci->ca.slot_ts_enable = ciintf_slot_ts_enable;
 527         budget_ci->ca.poll_slot_status = ciintf_poll_slot_status;
 528         budget_ci->ca.data = budget_ci;
 529         if ((result = dvb_ca_en50221_init(&budget_ci->budget.dvb_adapter,
 530                                           &budget_ci->ca,
 531                                           ca_flags, 1)) != 0) {
 532                 printk("budget_ci: CI interface detected, but initialisation failed.\n");
 533                 goto error;
 534         }
 535
 536         // Setup CI slot IRQ
 537         if (budget_ci->ci_irq) {
 538                 tasklet_init(&budget_ci->ciintf_irq_tasklet, ciintf_interrupt, (unsigned long) budget_ci);
 539                 if (budget_ci->slot_status != SLOTSTATUS_NONE) {
 540                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
 541                 } else {
 542                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
 543                 }
 544                 saa7146_write(saa, IER, saa7146_read(saa, IER) | MASK_03);
 545         }
 546
 547         // enable interface
 548         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 549                                CICONTROL_RESET, 1, 0);
 550
 551         // success!
 552         printk("budget_ci: CI interface initialised\n");
 553         budget_ci->budget.ci_present = 1;
 554
 555         // forge a fake CI IRQ so the CAM state is setup correctly
 556         if (budget_ci->ci_irq) {
 557                 flags = DVB_CA_EN50221_CAMCHANGE_REMOVED;
 558                 if (budget_ci->slot_status != SLOTSTATUS_NONE)
 559                         flags = DVB_CA_EN50221_CAMCHANGE_INSERTED;
 560                 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, flags);
 561         }
 562
 563         return 0;
 564
 565 error:
 566         saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16));
 567         return result;
 568 }
 569
 570 static void ciintf_deinit(struct budget_ci *budget_ci)
 571 {
 572         struct saa7146_dev *saa = budget_ci->budget.dev;
 573
 574         // disable CI interrupts
 575         if (budget_ci->ci_irq) {
 576                 saa7146_write(saa, IER, saa7146_read(saa, IER) & ~MASK_03);
 577                 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
 578                 tasklet_kill(&budget_ci->ciintf_irq_tasklet);
 579         }
 580
 581         // reset interface
 582         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
 583         msleep(1);
 584         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
 585                                CICONTROL_RESET, 1, 0);
 586
 587         // disable TS data stream to CI interface
 588         saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
 589
 590         // release the CA device
 591         dvb_ca_en50221_release(&budget_ci->ca);
 592
 593         // disable DEBI pins
 594         saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16));
 595 }
 596
 597 static void budget_ci_irq(struct saa7146_dev *dev, u32 * isr)
 598 {
 599         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
 600
 601         dprintk(8, "dev: %p, budget_ci: %p\n", dev, budget_ci);
 602
 603         if (*isr & MASK_06)
 604                 tasklet_schedule(&budget_ci->ir.msp430_irq_tasklet);
 605
 606         if (*isr & MASK_10)
 607                 ttpci_budget_irq10_handler(dev, isr);
 608
 609         if ((*isr & MASK_03) && (budget_ci->budget.ci_present) && (budget_ci->ci_irq))
 610                 tasklet_schedule(&budget_ci->ciintf_irq_tasklet);
 611 }
 612
 613 static u8 philips_su1278_tt_inittab[] = {
 614         0x01, 0x0f,
 615         0x02, 0x30,
 616         0x03, 0x00,
 617         0x04, 0x5b,
 618         0x05, 0x85,
 619         0x06, 0x02,
 620         0x07, 0x00,
 621         0x08, 0x02,
 622         0x09, 0x00,
 623         0x0C, 0x01,
 624         0x0D, 0x81,
 625         0x0E, 0x44,
 626         0x0f, 0x14,
 627         0x10, 0x3c,
 628         0x11, 0x84,
 629         0x12, 0xda,
 630         0x13, 0x97,
 631         0x14, 0x95,
 632         0x15, 0xc9,
 633         0x16, 0x19,
 634         0x17, 0x8c,
 635         0x18, 0x59,
 636         0x19, 0xf8,
 637         0x1a, 0xfe,
 638         0x1c, 0x7f,
 639         0x1d, 0x00,
 640         0x1e, 0x00,
 641         0x1f, 0x50,
 642         0x20, 0x00,
 643         0x21, 0x00,
 644         0x22, 0x00,
 645         0x23, 0x00,
 646         0x28, 0x00,
 647         0x29, 0x28,
 648         0x2a, 0x14,
 649         0x2b, 0x0f,
 650         0x2c, 0x09,
 651         0x2d, 0x09,
 652         0x31, 0x1f,
 653         0x32, 0x19,
 654         0x33, 0xfc,
 655         0x34, 0x93,
 656         0xff, 0xff
 657 };
 658
 659 static int philips_su1278_tt_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
 660 {
 661         stv0299_writereg(fe, 0x0e, 0x44);
 662         if (srate >= 10000000) {
 663                 stv0299_writereg(fe, 0x13, 0x97);
 664                 stv0299_writereg(fe, 0x14, 0x95);
 665                 stv0299_writereg(fe, 0x15, 0xc9);
 666                 stv0299_writereg(fe, 0x17, 0x8c);
 667                 stv0299_writereg(fe, 0x1a, 0xfe);
 668                 stv0299_writereg(fe, 0x1c, 0x7f);
 669                 stv0299_writereg(fe, 0x2d, 0x09);
 670         } else {
 671                 stv0299_writereg(fe, 0x13, 0x99);
 672                 stv0299_writereg(fe, 0x14, 0x8d);
 673                 stv0299_writereg(fe, 0x15, 0xce);
 674                 stv0299_writereg(fe, 0x17, 0x43);
 675                 stv0299_writereg(fe, 0x1a, 0x1d);
 676                 stv0299_writereg(fe, 0x1c, 0x12);
 677                 stv0299_writereg(fe, 0x2d, 0x05);
 678         }
 679         stv0299_writereg(fe, 0x0e, 0x23);
 680         stv0299_writereg(fe, 0x0f, 0x94);
 681         stv0299_writereg(fe, 0x10, 0x39);
 682         stv0299_writereg(fe, 0x15, 0xc9);
 683
 684         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
 685         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
 686         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
 687
 688         return 0;
 689 }
 690
 691 static int philips_su1278_tt_tuner_set_params(struct dvb_frontend *fe,
 692                                            struct dvb_frontend_parameters *params)
 693 {
 694         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 695         u32 div;
 696         u8 buf[4];
 697         struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
 698
 699         if ((params->frequency < 950000) || (params->frequency > 2150000))
 700                 return -EINVAL;
 701
 702         div = (params->frequency + (500 - 1)) / 500;    // round correctly
 703         buf[0] = (div >> 8) & 0x7f;
 704         buf[1] = div & 0xff;
 705         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 2;
 706         buf[3] = 0x20;
 707
 708         if (params->u.qpsk.symbol_rate < 4000000)
 709                 buf[3] |= 1;
 710
 711         if (params->frequency < 1250000)
 712                 buf[3] |= 0;
 713         else if (params->frequency < 1550000)
 714                 buf[3] |= 0x40;
 715         else if (params->frequency < 2050000)
 716                 buf[3] |= 0x80;
 717         else if (params->frequency < 2150000)
 718                 buf[3] |= 0xC0;
 719
 720         if (fe->ops.i2c_gate_ctrl)
 721                 fe->ops.i2c_gate_ctrl(fe, 1);
 722         if (i2c_transfer(&budget_ci->budget.i2c_adap, &msg, 1) != 1)
 723                 return -EIO;
 724         return 0;
 725 }
 726
 727 static struct stv0299_config philips_su1278_tt_config = {
 728
 729         .demod_address = 0x68,
 730         .inittab = philips_su1278_tt_inittab,
 731         .mclk = 64000000UL,
 732         .invert = 0,
 733         .skip_reinit = 1,
 734         .lock_output = STV0229_LOCKOUTPUT_1,
 735         .volt13_op0_op1 = STV0299_VOLT13_OP1,
 736         .min_delay_ms = 50,
 737         .set_symbol_rate = philips_su1278_tt_set_symbol_rate,
 738 };
 739
 740
 741
 742 static int philips_tdm1316l_tuner_init(struct dvb_frontend *fe)
 743 {
 744         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 745         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
 746         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
 747         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = td1316_init,.len =
 748                         sizeof(td1316_init) };
 749
 750         // setup PLL configuration
 751         if (fe->ops.i2c_gate_ctrl)
 752                 fe->ops.i2c_gate_ctrl(fe, 1);
 753         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 754                 return -EIO;
 755         msleep(1);
 756
 757         // disable the mc44BC374c (do not check for errors)
 758         tuner_msg.addr = 0x65;
 759         tuner_msg.buf = disable_mc44BC374c;
 760         tuner_msg.len = sizeof(disable_mc44BC374c);
 761         if (fe->ops.i2c_gate_ctrl)
 762                 fe->ops.i2c_gate_ctrl(fe, 1);
 763         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) {
 764                 if (fe->ops.i2c_gate_ctrl)
 765                         fe->ops.i2c_gate_ctrl(fe, 1);
 766                 i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1);
 767         }
 768
 769         return 0;
 770 }
 771
 772 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 773 {
 774         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 775         u8 tuner_buf[4];
 776         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = tuner_buf,.len = sizeof(tuner_buf) };
 777         int tuner_frequency = 0;
 778         u8 band, cp, filter;
 779
 780         // determine charge pump
 781         tuner_frequency = params->frequency + 36130000;
 782         if (tuner_frequency < 87000000)
 783                 return -EINVAL;
 784         else if (tuner_frequency < 130000000)
 785                 cp = 3;
 786         else if (tuner_frequency < 160000000)
 787                 cp = 5;
 788         else if (tuner_frequency < 200000000)
 789                 cp = 6;
 790         else if (tuner_frequency < 290000000)
 791                 cp = 3;
 792         else if (tuner_frequency < 420000000)
 793                 cp = 5;
 794         else if (tuner_frequency < 480000000)
 795                 cp = 6;
 796         else if (tuner_frequency < 620000000)
 797                 cp = 3;
 798         else if (tuner_frequency < 830000000)
 799                 cp = 5;
 800         else if (tuner_frequency < 895000000)
 801                 cp = 7;
 802         else
 803                 return -EINVAL;
 804
 805         // determine band
 806         if (params->frequency < 49000000)
 807                 return -EINVAL;
 808         else if (params->frequency < 159000000)
 809                 band = 1;
 810         else if (params->frequency < 444000000)
 811                 band = 2;
 812         else if (params->frequency < 861000000)
 813                 band = 4;
 814         else
 815                 return -EINVAL;
 816
 817         // setup PLL filter and TDA9889
 818         switch (params->u.ofdm.bandwidth) {
 819         case BANDWIDTH_6_MHZ:
 820                 tda1004x_writereg(fe, 0x0C, 0x14);
 821                 filter = 0;
 822                 break;
 823
 824         case BANDWIDTH_7_MHZ:
 825                 tda1004x_writereg(fe, 0x0C, 0x80);
 826                 filter = 0;
 827                 break;
 828
 829         case BANDWIDTH_8_MHZ:
 830                 tda1004x_writereg(fe, 0x0C, 0x14);
 831                 filter = 1;
 832                 break;
 833
 834         default:
 835                 return -EINVAL;
 836         }
 837
 838         // calculate divisor
 839         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
 840         tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
 841
 842         // setup tuner buffer
 843         tuner_buf[0] = tuner_frequency >> 8;
 844         tuner_buf[1] = tuner_frequency & 0xff;
 845         tuner_buf[2] = 0xca;
 846         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 847
 848         if (fe->ops.i2c_gate_ctrl)
 849                 fe->ops.i2c_gate_ctrl(fe, 1);
 850         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 851                 return -EIO;
 852
 853         msleep(1);
 854         return 0;
 855 }
 856
 857 static int philips_tdm1316l_request_firmware(struct dvb_frontend *fe,
 858                                              const struct firmware **fw, char *name)
 859 {
 860         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 861
 862         return request_firmware(fw, name, &budget_ci->budget.dev->pci->dev);
 863 }
 864
 865 static struct tda1004x_config philips_tdm1316l_config = {
 866
 867         .demod_address = 0x8,
 868         .invert = 0,
 869         .invert_oclk = 0,
 870         .xtal_freq = TDA10046_XTAL_4M,
 871         .agc_config = TDA10046_AGC_DEFAULT,
 872         .if_freq = TDA10046_FREQ_3617,
 873         .request_firmware = philips_tdm1316l_request_firmware,
 874 };
 875
 876 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 877 {
 878         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
 879         u8 tuner_buf[5];
 880         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,
 881                                     .flags = 0,
 882                                     .buf = tuner_buf,
 883                                     .len = sizeof(tuner_buf) };
 884         int tuner_frequency = 0;
 885         u8 band, cp, filter;
 886
 887         // determine charge pump
 888         tuner_frequency = params->frequency + 36125000;
 889         if (tuner_frequency < 87000000)
 890                 return -EINVAL;
 891         else if (tuner_frequency < 130000000) {
 892                 cp = 3;
 893                 band = 1;
 894         } else if (tuner_frequency < 160000000) {
 895                 cp = 5;
 896                 band = 1;
 897         } else if (tuner_frequency < 200000000) {
 898                 cp = 6;
 899                 band = 2;
 900         } else if (tuner_frequency < 290000000) {
 901                 cp = 3;
 902                 band = 2;
 903         } else if (tuner_frequency < 420000000) {
 904                 cp = 5;
 905                 band = 2;
 906         } else if (tuner_frequency < 480000000) {
 907                 cp = 6;
 908                 band = 2;
 909         } else if (tuner_frequency < 620000000) {
 910                 cp = 3;
 911                 band = 4;
 912         } else if (tuner_frequency < 830000000) {
 913                 cp = 5;
 914                 band = 4;
 915         } else if (tuner_frequency < 895000000) {
 916                 cp = 7;
 917                 band = 4;
 918         } else
 919                 return -EINVAL;
 920
 921         // assume PLL filter should always be 8MHz for the moment.
 922         filter = 1;
 923
 924         // calculate divisor
 925         tuner_frequency = (params->frequency + 36125000 + (62500/2)) / 62500;
 926
 927         // setup tuner buffer
 928         tuner_buf[0] = tuner_frequency >> 8;
 929         tuner_buf[1] = tuner_frequency & 0xff;
 930         tuner_buf[2] = 0xc8;
 931         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 932         tuner_buf[4] = 0x80;
 933
 934         if (fe->ops.i2c_gate_ctrl)
 935                 fe->ops.i2c_gate_ctrl(fe, 1);
 936         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 937                 return -EIO;
 938
 939         msleep(50);
 940
 941         if (fe->ops.i2c_gate_ctrl)
 942                 fe->ops.i2c_gate_ctrl(fe, 1);
 943         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
 944                 return -EIO;
 945
 946         msleep(1);
 947
 948         return 0;
 949 }
 950
 951 static u8 dvbc_philips_tdm1316l_inittab[] = {
 952         0x80, 0x01,
 953         0x80, 0x00,
 954         0x81, 0x01,
 955         0x81, 0x00,
 956         0x00, 0x09,
 957         0x01, 0x69,
 958         0x03, 0x00,
 959         0x04, 0x00,
 960         0x07, 0x00,
 961         0x08, 0x00,
 962         0x20, 0x00,
 963         0x21, 0x40,
 964         0x22, 0x00,
 965         0x23, 0x00,
 966         0x24, 0x40,
 967         0x25, 0x88,
 968         0x30, 0xff,
 969         0x31, 0x00,
 970         0x32, 0xff,
 971         0x33, 0x00,
 972         0x34, 0x50,
 973         0x35, 0x7f,
 974         0x36, 0x00,
 975         0x37, 0x20,
 976         0x38, 0x00,
 977         0x40, 0x1c,
 978         0x41, 0xff,
 979         0x42, 0x29,
 980         0x43, 0x20,
 981         0x44, 0xff,
 982         0x45, 0x00,
 983         0x46, 0x00,
 984         0x49, 0x04,
 985         0x4a, 0x00,
 986         0x4b, 0x7b,
 987         0x52, 0x30,
 988         0x55, 0xae,
 989         0x56, 0x47,
 990         0x57, 0xe1,
 991         0x58, 0x3a,
 992         0x5a, 0x1e,
 993         0x5b, 0x34,
 994         0x60, 0x00,
 995         0x63, 0x00,
 996         0x64, 0x00,
 997         0x65, 0x00,
 998         0x66, 0x00,
 999         0x67, 0x00,
1000         0x68, 0x00,
1001         0x69, 0x00,
1002         0x6a, 0x02,
1003         0x6b, 0x00,
1004         0x70, 0xff,
1005         0x71, 0x00,
1006         0x72, 0x00,
1007         0x73, 0x00,
1008         0x74, 0x0c,
1009         0x80, 0x00,
1010         0x81, 0x00,
1011         0x82, 0x00,
1012         0x83, 0x00,
1013         0x84, 0x04,
1014         0x85, 0x80,
1015         0x86, 0x24,
1016         0x87, 0x78,
1017         0x88, 0x10,
1018         0x89, 0x00,
1019         0x90, 0x01,
1020         0x91, 0x01,
1021         0xa0, 0x04,
1022         0xa1, 0x00,
1023         0xa2, 0x00,
1024         0xb0, 0x91,
1025         0xb1, 0x0b,
1026         0xc0, 0x53,
1027         0xc1, 0x70,
1028         0xc2, 0x12,
1029         0xd0, 0x00,
1030         0xd1, 0x00,
1031         0xd2, 0x00,
1032         0xd3, 0x00,
1033         0xd4, 0x00,
1034         0xd5, 0x00,
1035         0xde, 0x00,
1036         0xdf, 0x00,
1037         0x61, 0x38,
1038         0x62, 0x0a,
1039         0x53, 0x13,
1040         0x59, 0x08,
1041         0xff, 0xff,
1042 };
1043
1044 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1045         .demod_address = 0x1c,
1046         .inittab = dvbc_philips_tdm1316l_inittab,
1047         .invert = 0,
1048         .stop_during_read = 1,
1049 };
1050
1051
1052
1053
1054 static void frontend_init(struct budget_ci *budget_ci)
1055 {
1056         switch (budget_ci->budget.dev->pci->subsystem_device) {
1057         case 0x100c:            // Hauppauge/TT Nova-CI budget (stv0299/ALPS BSRU6(tsa5059))
1058                 budget_ci->budget.dvb_frontend =
1059                         dvb_attach(stv0299_attach, &alps_bsru6_config, &budget_ci->budget.i2c_adap);
1060                 if (budget_ci->budget.dvb_frontend) {
1061                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
1062                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1063                         break;
1064                 }
1065                 break;
1066
1067         case 0x100f:            // Hauppauge/TT Nova-CI budget (stv0299b/Philips su1278(tsa5059))
1068                 budget_ci->budget.dvb_frontend =
1069                         dvb_attach(stv0299_attach, &philips_su1278_tt_config, &budget_ci->budget.i2c_adap);
1070                 if (budget_ci->budget.dvb_frontend) {
1071                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_su1278_tt_tuner_set_params;
1072                         break;
1073                 }
1074                 break;
1075
1076         case 0x1010:            // TT DVB-C CI budget (stv0297/Philips tdm1316l(tda6651tt))
1077                 budget_ci->tuner_pll_address = 0x61;
1078                 budget_ci->budget.dvb_frontend =
1079                         dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1080                 if (budget_ci->budget.dvb_frontend) {
1081                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1082                         break;
1083                 }
1084                 break;
1085
1086         case 0x1011:            // Hauppauge/TT Nova-T budget (tda10045/Philips tdm1316l(tda6651tt) + TDA9889)
1087                 budget_ci->tuner_pll_address = 0x63;
1088                 budget_ci->budget.dvb_frontend =
1089                         dvb_attach(tda10045_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1090                 if (budget_ci->budget.dvb_frontend) {
1091                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1092                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1093                         break;
1094                 }
1095                 break;
1096
1097         case 0x1012:            // TT DVB-T CI budget (tda10046/Philips tdm1316l(tda6651tt))
1098                 budget_ci->tuner_pll_address = 0x60;
1099                 philips_tdm1316l_config.invert = 1;
1100                 budget_ci->budget.dvb_frontend =
1101                         dvb_attach(tda10046_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1102                 if (budget_ci->budget.dvb_frontend) {
1103                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1104                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1105                         break;
1106                 }
1107                 break;
1108
1109         case 0x1017:            // TT S-1500 PCI
1110                 budget_ci->budget.dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config, &budget_ci->budget.i2c_adap);
1111                 if (budget_ci->budget.dvb_frontend) {
1112                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
1113                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1114
1115                         budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
1116                         if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) {
1117                                 printk("%s: No LNBP21 found!\n", __FUNCTION__);
1118                                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1119                                 budget_ci->budget.dvb_frontend = NULL;
1120                         }
1121                 }
1122
1123                 break;
1124         }
1125
1126         if (budget_ci->budget.dvb_frontend == NULL) {
1127                 printk("budget-ci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
1128                        budget_ci->budget.dev->pci->vendor,
1129                        budget_ci->budget.dev->pci->device,
1130                        budget_ci->budget.dev->pci->subsystem_vendor,
1131                        budget_ci->budget.dev->pci->subsystem_device);
1132         } else {
1133                 if (dvb_register_frontend
1134                     (&budget_ci->budget.dvb_adapter, budget_ci->budget.dvb_frontend)) {
1135                         printk("budget-ci: Frontend registration failed!\n");
1136                         dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1137                         budget_ci->budget.dvb_frontend = NULL;
1138                 }
1139         }
1140 }
1141
1142 static int budget_ci_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1143 {
1144         struct budget_ci *budget_ci;
1145         int err;
1146
1147         budget_ci = kzalloc(sizeof(struct budget_ci), GFP_KERNEL);
1148         if (!budget_ci) {
1149                 err = -ENOMEM;
1150                 goto out1;
1151         }
1152
1153         dprintk(2, "budget_ci: %p\n", budget_ci);
1154
1155         dev->ext_priv = budget_ci;
1156
1157         err = ttpci_budget_init(&budget_ci->budget, dev, info, THIS_MODULE);
1158         if (err)
1159                 goto out2;
1160
1161         err = msp430_ir_init(budget_ci);
1162         if (err)
1163                 goto out3;
1164
1165         ciintf_init(budget_ci);
1166
1167         budget_ci->budget.dvb_adapter.priv = budget_ci;
1168         frontend_init(budget_ci);
1169
1170         ttpci_budget_init_hooks(&budget_ci->budget);
1171
1172         return 0;
1173
1174 out3:
1175         ttpci_budget_deinit(&budget_ci->budget);
1176 out2:
1177         kfree(budget_ci);
1178 out1:
1179         return err;
1180 }
1181
1182 static int budget_ci_detach(struct saa7146_dev *dev)
1183 {
1184         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
1185         struct saa7146_dev *saa = budget_ci->budget.dev;
1186         int err;
1187
1188         if (budget_ci->budget.ci_present)
1189                 ciintf_deinit(budget_ci);
1190         msp430_ir_deinit(budget_ci);
1191         if (budget_ci->budget.dvb_frontend) {
1192                 dvb_unregister_frontend(budget_ci->budget.dvb_frontend);
1193                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1194         }
1195         err = ttpci_budget_deinit(&budget_ci->budget);
1196
1197         // disable frontend and CI interface
1198         saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
1199
1200         kfree(budget_ci);
1201
1202         return err;
1203 }
1204
1205 static struct saa7146_extension budget_extension;
1206
1207 MAKE_BUDGET_INFO(ttbs2, "TT-Budget/S-1500 PCI", BUDGET_TT);
1208 MAKE_BUDGET_INFO(ttbci, "TT-Budget/WinTV-NOVA-CI PCI", BUDGET_TT_HW_DISEQC);
1209 MAKE_BUDGET_INFO(ttbt2, "TT-Budget/WinTV-NOVA-T  PCI", BUDGET_TT);
1210 MAKE_BUDGET_INFO(ttbtci, "TT-Budget-T-CI PCI", BUDGET_TT);
1211 MAKE_BUDGET_INFO(ttbcci, "TT-Budget-C-CI PCI", BUDGET_TT);
1212
1213 static struct pci_device_id pci_tbl[] = {
1214         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100c),
1215         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100f),
1216         MAKE_EXTENSION_PCI(ttbcci, 0x13c2, 0x1010),
1217         MAKE_EXTENSION_PCI(ttbt2, 0x13c2, 0x1011),
1218         MAKE_EXTENSION_PCI(ttbtci, 0x13c2, 0x1012),
1219         MAKE_EXTENSION_PCI(ttbs2, 0x13c2, 0x1017),
1220         {
1221          .vendor = 0,
1222          }
1223 };
1224
1225 MODULE_DEVICE_TABLE(pci, pci_tbl);
1226
1227 static struct saa7146_extension budget_extension = {
1228         .name = "budget_ci dvb",
1229         .flags = SAA7146_I2C_SHORT_DELAY,
1230
1231         .module = THIS_MODULE,
1232         .pci_tbl = &pci_tbl[0],
1233         .attach = budget_ci_attach,
1234         .detach = budget_ci_detach,
1235
1236         .irq_mask = MASK_03 | MASK_06 | MASK_10,
1237         .irq_func = budget_ci_irq,
1238 };
1239
1240 static int __init budget_ci_init(void)
1241 {
1242         return saa7146_register_extension(&budget_extension);
1243 }
1244
1245 static void __exit budget_ci_exit(void)
1246 {
1247         saa7146_unregister_extension(&budget_extension);
1248 }
1249
1250 module_init(budget_ci_init);
1251 module_exit(budget_ci_exit);
1252
1253 MODULE_LICENSE("GPL");
1254 MODULE_AUTHOR("Michael Hunold, Jack Thomasson, Andrew de Quincey, others");
1255 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1256                    "budget PCI DVB cards w/ CI-module produced by "
1257                    "Siemens, Technotrend, Hauppauge");