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