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

   1 /*
   2  * budget-av.c: driver for the SAA7146 based Budget DVB cards
   3  *              with analog video in
   4  *
   5  * Compiled from various sources by Michael Hunold <michael@mihu.de>
   6  *
   7  * CI interface support (c) 2004 Olivier Gournet <ogournet@anevia.com> &
   8  *                               Andrew de Quincey <adq_dvb@lidskialf.net>
   9  *
  10  * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
  11  *
  12  * Copyright (C) 1999-2002 Ralph  Metzler
  13  *                       & Marcus Metzler for convergence integrated media GmbH
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, write to the Free Software
  29  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  30  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  31  *
  32  *
  33  * the project's page is at http://www.linuxtv.org/dvb/
  34  */
  35
  36 #include "budget.h"
  37 #include "stv0299.h"
  38 #include "tda10021.h"
  39 #include "tda1004x.h"
  40 #include "tua6100.h"
  41 #include "dvb-pll.h"
  42 #include <media/saa7146_vv.h>
  43 #include <linux/module.h>
  44 #include <linux/errno.h>
  45 #include <linux/slab.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/input.h>
  48 #include <linux/spinlock.h>
  49
  50 #include "dvb_ca_en50221.h"
  51
  52 #define DEBICICAM               0x02420000
  53
  54 #define SLOTSTATUS_NONE         1
  55 #define SLOTSTATUS_PRESENT      2
  56 #define SLOTSTATUS_RESET        4
  57 #define SLOTSTATUS_READY        8
  58 #define SLOTSTATUS_OCCUPIED     (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
  59
  60 struct budget_av {
  61         struct budget budget;
  62         struct video_device *vd;
  63         int cur_input;
  64         int has_saa7113;
  65         struct tasklet_struct ciintf_irq_tasklet;
  66         int slot_status;
  67         struct dvb_ca_en50221 ca;
  68         u8 reinitialise_demod:1;
  69         u8 tda10021_poclkp:1;
  70         u8 tda10021_ts_enabled;
  71         int (*tda10021_set_frontend)(struct dvb_frontend *fe, struct dvb_frontend_parameters *p);
  72 };
  73
  74 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot);
  75
  76
  77 /* GPIO Connections:
  78  * 0 - Vcc/Reset (Reset is controlled by capacitor). Resets the frontend *AS WELL*!
  79  * 1 - CI memory select 0=>IO memory, 1=>Attribute Memory
  80  * 2 - CI Card Enable (Active Low)
  81  * 3 - CI Card Detect
  82  */
  83
  84 /****************************************************************************
  85  * INITIALIZATION
  86  ****************************************************************************/
  87
  88 static u8 i2c_readreg(struct i2c_adapter *i2c, u8 id, u8 reg)
  89 {
  90         u8 mm1[] = { 0x00 };
  91         u8 mm2[] = { 0x00 };
  92         struct i2c_msg msgs[2];
  93
  94         msgs[0].flags = 0;
  95         msgs[1].flags = I2C_M_RD;
  96         msgs[0].addr = msgs[1].addr = id / 2;
  97         mm1[0] = reg;
  98         msgs[0].len = 1;
  99         msgs[1].len = 1;
 100         msgs[0].buf = mm1;
 101         msgs[1].buf = mm2;
 102
 103         i2c_transfer(i2c, msgs, 2);
 104
 105         return mm2[0];
 106 }
 107
 108 static int i2c_readregs(struct i2c_adapter *i2c, u8 id, u8 reg, u8 * buf, u8 len)
 109 {
 110         u8 mm1[] = { reg };
 111         struct i2c_msg msgs[2] = {
 112                 {.addr = id / 2,.flags = 0,.buf = mm1,.len = 1},
 113                 {.addr = id / 2,.flags = I2C_M_RD,.buf = buf,.len = len}
 114         };
 115
 116         if (i2c_transfer(i2c, msgs, 2) != 2)
 117                 return -EIO;
 118
 119         return 0;
 120 }
 121
 122 static int i2c_writereg(struct i2c_adapter *i2c, u8 id, u8 reg, u8 val)
 123 {
 124         u8 msg[2] = { reg, val };
 125         struct i2c_msg msgs;
 126
 127         msgs.flags = 0;
 128         msgs.addr = id / 2;
 129         msgs.len = 2;
 130         msgs.buf = msg;
 131         return i2c_transfer(i2c, &msgs, 1);
 132 }
 133
 134 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
 135 {
 136         struct budget_av *budget_av = (struct budget_av *) ca->data;
 137         int result;
 138
 139         if (slot != 0)
 140                 return -EINVAL;
 141
 142         saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
 143         udelay(1);
 144
 145         result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 0xfff, 1, 0, 1);
 146         if (result == -ETIMEDOUT) {
 147                 ciintf_slot_shutdown(ca, slot);
 148                 printk(KERN_INFO "budget-av: cam ejected 1\n");
 149         }
 150         return result;
 151 }
 152
 153 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
 154 {
 155         struct budget_av *budget_av = (struct budget_av *) ca->data;
 156         int result;
 157
 158         if (slot != 0)
 159                 return -EINVAL;
 160
 161         saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
 162         udelay(1);
 163
 164         result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 0xfff, 1, value, 0, 1);
 165         if (result == -ETIMEDOUT) {
 166                 ciintf_slot_shutdown(ca, slot);
 167                 printk(KERN_INFO "budget-av: cam ejected 2\n");
 168         }
 169         return result;
 170 }
 171
 172 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
 173 {
 174         struct budget_av *budget_av = (struct budget_av *) ca->data;
 175         int result;
 176
 177         if (slot != 0)
 178                 return -EINVAL;
 179
 180         saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
 181         udelay(1);
 182
 183         result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0);
 184         if ((result == -ETIMEDOUT) || ((result == 0xff) && ((address & 3) < 2))) {
 185                 ciintf_slot_shutdown(ca, slot);
 186                 printk(KERN_INFO "budget-av: cam ejected 3\n");
 187                 return -ETIMEDOUT;
 188         }
 189         return result;
 190 }
 191
 192 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
 193 {
 194         struct budget_av *budget_av = (struct budget_av *) ca->data;
 195         int result;
 196
 197         if (slot != 0)
 198                 return -EINVAL;
 199
 200         saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
 201         udelay(1);
 202
 203         result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 3, 1, value, 0, 0);
 204         if (result == -ETIMEDOUT) {
 205                 ciintf_slot_shutdown(ca, slot);
 206                 printk(KERN_INFO "budget-av: cam ejected 5\n");
 207         }
 208         return result;
 209 }
 210
 211 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
 212 {
 213         struct budget_av *budget_av = (struct budget_av *) ca->data;
 214         struct saa7146_dev *saa = budget_av->budget.dev;
 215
 216         if (slot != 0)
 217                 return -EINVAL;
 218
 219         dprintk(1, "ciintf_slot_reset\n");
 220         budget_av->slot_status = SLOTSTATUS_RESET;
 221
 222         saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
 223
 224         saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); /* Vcc off */
 225         msleep(2);
 226         saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); /* Vcc on */
 227         msleep(20); /* 20 ms Vcc settling time */
 228
 229         saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); /* enable card */
 230         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 231         msleep(20);
 232
 233         /* reinitialise the frontend if necessary */
 234         if (budget_av->reinitialise_demod)
 235                 dvb_frontend_reinitialise(budget_av->budget.dvb_frontend);
 236
 237         /* set tda10021 back to original clock configuration on reset */
 238         if (budget_av->tda10021_poclkp) {
 239                 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
 240                 budget_av->tda10021_ts_enabled = 0;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
 247 {
 248         struct budget_av *budget_av = (struct budget_av *) ca->data;
 249         struct saa7146_dev *saa = budget_av->budget.dev;
 250
 251         if (slot != 0)
 252                 return -EINVAL;
 253
 254         dprintk(1, "ciintf_slot_shutdown\n");
 255
 256         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
 257         budget_av->slot_status = SLOTSTATUS_NONE;
 258
 259         /* set tda10021 back to original clock configuration when cam removed */
 260         if (budget_av->tda10021_poclkp) {
 261                 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
 262                 budget_av->tda10021_ts_enabled = 0;
 263         }
 264         return 0;
 265 }
 266
 267 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
 268 {
 269         struct budget_av *budget_av = (struct budget_av *) ca->data;
 270         struct saa7146_dev *saa = budget_av->budget.dev;
 271
 272         if (slot != 0)
 273                 return -EINVAL;
 274
 275         dprintk(1, "ciintf_slot_ts_enable: %d\n", budget_av->slot_status);
 276
 277         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
 278
 279         /* tda10021 seems to need a different TS clock config when data is routed to the CAM */
 280         if (budget_av->tda10021_poclkp) {
 281                 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
 282                 budget_av->tda10021_ts_enabled = 1;
 283         }
 284
 285         return 0;
 286 }
 287
 288 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
 289 {
 290         struct budget_av *budget_av = (struct budget_av *) ca->data;
 291         struct saa7146_dev *saa = budget_av->budget.dev;
 292         int result;
 293
 294         if (slot != 0)
 295                 return -EINVAL;
 296
 297         /* test the card detect line - needs to be done carefully
 298          * since it never goes high for some CAMs on this interface (e.g. topuptv) */
 299         if (budget_av->slot_status == SLOTSTATUS_NONE) {
 300                 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
 301                 udelay(1);
 302                 if (saa7146_read(saa, PSR) & MASK_06) {
 303                         if (budget_av->slot_status == SLOTSTATUS_NONE) {
 304                                 budget_av->slot_status = SLOTSTATUS_PRESENT;
 305                                 printk(KERN_INFO "budget-av: cam inserted A\n");
 306                         }
 307                 }
 308                 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
 309         }
 310
 311         /* We also try and read from IO memory to work round the above detection bug. If
 312          * there is no CAM, we will get a timeout. Only done if there is no cam
 313          * present, since this test actually breaks some cams :(
 314          *
 315          * if the CI interface is not open, we also do the above test since we
 316          * don't care if the cam has problems - we'll be resetting it on open() anyway */
 317         if ((budget_av->slot_status == SLOTSTATUS_NONE) || (!open)) {
 318                 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
 319                 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, 0, 1, 0, 1);
 320                 if ((result >= 0) && (budget_av->slot_status == SLOTSTATUS_NONE)) {
 321                         budget_av->slot_status = SLOTSTATUS_PRESENT;
 322                         printk(KERN_INFO "budget-av: cam inserted B\n");
 323                 } else if (result < 0) {
 324                         if (budget_av->slot_status != SLOTSTATUS_NONE) {
 325                                 ciintf_slot_shutdown(ca, slot);
 326                                 printk(KERN_INFO "budget-av: cam ejected 5\n");
 327                                 return 0;
 328                         }
 329                 }
 330         }
 331
 332         /* read from attribute memory in reset/ready state to know when the CAM is ready */
 333         if (budget_av->slot_status == SLOTSTATUS_RESET) {
 334                 result = ciintf_read_attribute_mem(ca, slot, 0);
 335                 if (result == 0x1d) {
 336                         budget_av->slot_status = SLOTSTATUS_READY;
 337                 }
 338         }
 339
 340         /* work out correct return code */
 341         if (budget_av->slot_status != SLOTSTATUS_NONE) {
 342                 if (budget_av->slot_status & SLOTSTATUS_READY) {
 343                         return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
 344                 }
 345                 return DVB_CA_EN50221_POLL_CAM_PRESENT;
 346         }
 347         return 0;
 348 }
 349
 350 static int ciintf_init(struct budget_av *budget_av)
 351 {
 352         struct saa7146_dev *saa = budget_av->budget.dev;
 353         int result;
 354
 355         memset(&budget_av->ca, 0, sizeof(struct dvb_ca_en50221));
 356
 357         saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
 358         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
 359         saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO);
 360         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
 361
 362         /* Enable DEBI pins */
 363         saa7146_write(saa, MC1, MASK_27 | MASK_11);
 364
 365         /* register CI interface */
 366         budget_av->ca.owner = THIS_MODULE;
 367         budget_av->ca.read_attribute_mem = ciintf_read_attribute_mem;
 368         budget_av->ca.write_attribute_mem = ciintf_write_attribute_mem;
 369         budget_av->ca.read_cam_control = ciintf_read_cam_control;
 370         budget_av->ca.write_cam_control = ciintf_write_cam_control;
 371         budget_av->ca.slot_reset = ciintf_slot_reset;
 372         budget_av->ca.slot_shutdown = ciintf_slot_shutdown;
 373         budget_av->ca.slot_ts_enable = ciintf_slot_ts_enable;
 374         budget_av->ca.poll_slot_status = ciintf_poll_slot_status;
 375         budget_av->ca.data = budget_av;
 376         budget_av->budget.ci_present = 1;
 377         budget_av->slot_status = SLOTSTATUS_NONE;
 378
 379         if ((result = dvb_ca_en50221_init(&budget_av->budget.dvb_adapter,
 380                                           &budget_av->ca, 0, 1)) != 0) {
 381                 printk(KERN_ERR "budget-av: ci initialisation failed.\n");
 382                 goto error;
 383         }
 384
 385         printk(KERN_INFO "budget-av: ci interface initialised.\n");
 386         return 0;
 387
 388 error:
 389         saa7146_write(saa, MC1, MASK_27);
 390         return result;
 391 }
 392
 393 static void ciintf_deinit(struct budget_av *budget_av)
 394 {
 395         struct saa7146_dev *saa = budget_av->budget.dev;
 396
 397         saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
 398         saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
 399         saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
 400         saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
 401
 402         /* release the CA device */
 403         dvb_ca_en50221_release(&budget_av->ca);
 404
 405         /* disable DEBI pins */
 406         saa7146_write(saa, MC1, MASK_27);
 407 }
 408
 409
 410 static const u8 saa7113_tab[] = {
 411         0x01, 0x08,
 412         0x02, 0xc0,
 413         0x03, 0x33,
 414         0x04, 0x00,
 415         0x05, 0x00,
 416         0x06, 0xeb,
 417         0x07, 0xe0,
 418         0x08, 0x28,
 419         0x09, 0x00,
 420         0x0a, 0x80,
 421         0x0b, 0x47,
 422         0x0c, 0x40,
 423         0x0d, 0x00,
 424         0x0e, 0x01,
 425         0x0f, 0x44,
 426
 427         0x10, 0x08,
 428         0x11, 0x0c,
 429         0x12, 0x7b,
 430         0x13, 0x00,
 431         0x15, 0x00, 0x16, 0x00, 0x17, 0x00,
 432
 433         0x57, 0xff,
 434         0x40, 0x82, 0x58, 0x00, 0x59, 0x54, 0x5a, 0x07,
 435         0x5b, 0x83, 0x5e, 0x00,
 436         0xff
 437 };
 438
 439 static int saa7113_init(struct budget_av *budget_av)
 440 {
 441         struct budget *budget = &budget_av->budget;
 442         struct saa7146_dev *saa = budget->dev;
 443         const u8 *data = saa7113_tab;
 444
 445         saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI);
 446         msleep(200);
 447
 448         if (i2c_writereg(&budget->i2c_adap, 0x4a, 0x01, 0x08) != 1) {
 449                 dprintk(1, "saa7113 not found on KNC card\n");
 450                 return -ENODEV;
 451         }
 452
 453         dprintk(1, "saa7113 detected and initializing\n");
 454
 455         while (*data != 0xff) {
 456                 i2c_writereg(&budget->i2c_adap, 0x4a, *data, *(data + 1));
 457                 data += 2;
 458         }
 459
 460         dprintk(1, "saa7113  status=%02x\n", i2c_readreg(&budget->i2c_adap, 0x4a, 0x1f));
 461
 462         return 0;
 463 }
 464
 465 static int saa7113_setinput(struct budget_av *budget_av, int input)
 466 {
 467         struct budget *budget = &budget_av->budget;
 468
 469         if (1 != budget_av->has_saa7113)
 470                 return -ENODEV;
 471
 472         if (input == 1) {
 473                 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc7);
 474                 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x80);
 475         } else if (input == 0) {
 476                 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc0);
 477                 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x00);
 478         } else
 479                 return -EINVAL;
 480
 481         budget_av->cur_input = input;
 482         return 0;
 483 }
 484
 485
 486 static int philips_su1278_ty_ci_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
 487 {
 488         u8 aclk = 0;
 489         u8 bclk = 0;
 490         u8 m1;
 491
 492         aclk = 0xb5;
 493         if (srate < 2000000)
 494                 bclk = 0x86;
 495         else if (srate < 5000000)
 496                 bclk = 0x89;
 497         else if (srate < 15000000)
 498                 bclk = 0x8f;
 499         else if (srate < 45000000)
 500                 bclk = 0x95;
 501
 502         m1 = 0x14;
 503         if (srate < 4000000)
 504                 m1 = 0x10;
 505
 506         stv0299_writereg(fe, 0x13, aclk);
 507         stv0299_writereg(fe, 0x14, bclk);
 508         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
 509         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
 510         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
 511         stv0299_writereg(fe, 0x0f, 0x80 | m1);
 512
 513         return 0;
 514 }
 515
 516 static int philips_su1278_ty_ci_tuner_set_params(struct dvb_frontend *fe,
 517                                                  struct dvb_frontend_parameters *params)
 518 {
 519         u32 div;
 520         u8 buf[4];
 521         struct budget *budget = (struct budget *) fe->dvb->priv;
 522         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
 523
 524         if ((params->frequency < 950000) || (params->frequency > 2150000))
 525                 return -EINVAL;
 526
 527         div = (params->frequency + (125 - 1)) / 125;    // round correctly
 528         buf[0] = (div >> 8) & 0x7f;
 529         buf[1] = div & 0xff;
 530         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
 531         buf[3] = 0x20;
 532
 533         if (params->u.qpsk.symbol_rate < 4000000)
 534                 buf[3] |= 1;
 535
 536         if (params->frequency < 1250000)
 537                 buf[3] |= 0;
 538         else if (params->frequency < 1550000)
 539                 buf[3] |= 0x40;
 540         else if (params->frequency < 2050000)
 541                 buf[3] |= 0x80;
 542         else if (params->frequency < 2150000)
 543                 buf[3] |= 0xC0;
 544
 545         if (fe->ops.i2c_gate_ctrl)
 546                 fe->ops.i2c_gate_ctrl(fe, 1);
 547         if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
 548                 return -EIO;
 549         return 0;
 550 }
 551
 552 static u8 typhoon_cinergy1200s_inittab[] = {
 553         0x01, 0x15,
 554         0x02, 0x30,
 555         0x03, 0x00,
 556         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
 557         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
 558         0x06, 0x40,             /* DAC not used, set to high impendance mode */
 559         0x07, 0x00,             /* DAC LSB */
 560         0x08, 0x40,             /* DiSEqC off */
 561         0x09, 0x00,             /* FIFO */
 562         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
 563         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
 564         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
 565         0x10, 0x3f,             // AGC2  0x3d
 566         0x11, 0x84,
 567         0x12, 0xb9,
 568         0x15, 0xc9,             // lock detector threshold
 569         0x16, 0x00,
 570         0x17, 0x00,
 571         0x18, 0x00,
 572         0x19, 0x00,
 573         0x1a, 0x00,
 574         0x1f, 0x50,
 575         0x20, 0x00,
 576         0x21, 0x00,
 577         0x22, 0x00,
 578         0x23, 0x00,
 579         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
 580         0x29, 0x1e,             // 1/2 threshold
 581         0x2a, 0x14,             // 2/3 threshold
 582         0x2b, 0x0f,             // 3/4 threshold
 583         0x2c, 0x09,             // 5/6 threshold
 584         0x2d, 0x05,             // 7/8 threshold
 585         0x2e, 0x01,
 586         0x31, 0x1f,             // test all FECs
 587         0x32, 0x19,             // viterbi and synchro search
 588         0x33, 0xfc,             // rs control
 589         0x34, 0x93,             // error control
 590         0x0f, 0x92,
 591         0xff, 0xff
 592 };
 593
 594 static struct stv0299_config typhoon_config = {
 595         .demod_address = 0x68,
 596         .inittab = typhoon_cinergy1200s_inittab,
 597         .mclk = 88000000UL,
 598         .invert = 0,
 599         .skip_reinit = 0,
 600         .lock_output = STV0229_LOCKOUTPUT_1,
 601         .volt13_op0_op1 = STV0299_VOLT13_OP0,
 602         .min_delay_ms = 100,
 603         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
 604 };
 605
 606
 607 static struct stv0299_config cinergy_1200s_config = {
 608         .demod_address = 0x68,
 609         .inittab = typhoon_cinergy1200s_inittab,
 610         .mclk = 88000000UL,
 611         .invert = 0,
 612         .skip_reinit = 0,
 613         .lock_output = STV0229_LOCKOUTPUT_0,
 614         .volt13_op0_op1 = STV0299_VOLT13_OP0,
 615         .min_delay_ms = 100,
 616         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
 617 };
 618
 619 static struct stv0299_config cinergy_1200s_1894_0010_config = {
 620         .demod_address = 0x68,
 621         .inittab = typhoon_cinergy1200s_inittab,
 622         .mclk = 88000000UL,
 623         .invert = 1,
 624         .skip_reinit = 0,
 625         .lock_output = STV0229_LOCKOUTPUT_1,
 626         .volt13_op0_op1 = STV0299_VOLT13_OP0,
 627         .min_delay_ms = 100,
 628         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
 629 };
 630
 631 static int philips_cu1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 632 {
 633         struct budget *budget = (struct budget *) fe->dvb->priv;
 634         u8 buf[4];
 635         struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
 636
 637 #define TUNER_MUL 62500
 638
 639         u32 div = (params->frequency + 36125000 + TUNER_MUL / 2) / TUNER_MUL;
 640
 641         buf[0] = (div >> 8) & 0x7f;
 642         buf[1] = div & 0xff;
 643         buf[2] = 0x86;
 644         buf[3] = (params->frequency < 150000000 ? 0x01 :
 645                   params->frequency < 445000000 ? 0x02 : 0x04);
 646
 647         if (fe->ops.i2c_gate_ctrl)
 648                 fe->ops.i2c_gate_ctrl(fe, 1);
 649         if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
 650                 return -EIO;
 651         return 0;
 652 }
 653
 654 static struct tda10021_config philips_cu1216_config = {
 655         .demod_address = 0x0c,
 656 };
 657
 658 static struct tda10021_config philips_cu1216_config_altaddress = {
 659         .demod_address = 0x0d,
 660 };
 661
 662
 663
 664
 665 static int philips_tu1216_tuner_init(struct dvb_frontend *fe)
 666 {
 667         struct budget *budget = (struct budget *) fe->dvb->priv;
 668         static u8 tu1216_init[] = { 0x0b, 0xf5, 0x85, 0xab };
 669         struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) };
 670
 671         // setup PLL configuration
 672         if (fe->ops.i2c_gate_ctrl)
 673                 fe->ops.i2c_gate_ctrl(fe, 1);
 674         if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
 675                 return -EIO;
 676         msleep(1);
 677
 678         return 0;
 679 }
 680
 681 static int philips_tu1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 682 {
 683         struct budget *budget = (struct budget *) fe->dvb->priv;
 684         u8 tuner_buf[4];
 685         struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tuner_buf,.len =
 686                         sizeof(tuner_buf) };
 687         int tuner_frequency = 0;
 688         u8 band, cp, filter;
 689
 690         // determine charge pump
 691         tuner_frequency = params->frequency + 36166000;
 692         if (tuner_frequency < 87000000)
 693                 return -EINVAL;
 694         else if (tuner_frequency < 130000000)
 695                 cp = 3;
 696         else if (tuner_frequency < 160000000)
 697                 cp = 5;
 698         else if (tuner_frequency < 200000000)
 699                 cp = 6;
 700         else if (tuner_frequency < 290000000)
 701                 cp = 3;
 702         else if (tuner_frequency < 420000000)
 703                 cp = 5;
 704         else if (tuner_frequency < 480000000)
 705                 cp = 6;
 706         else if (tuner_frequency < 620000000)
 707                 cp = 3;
 708         else if (tuner_frequency < 830000000)
 709                 cp = 5;
 710         else if (tuner_frequency < 895000000)
 711                 cp = 7;
 712         else
 713                 return -EINVAL;
 714
 715         // determine band
 716         if (params->frequency < 49000000)
 717                 return -EINVAL;
 718         else if (params->frequency < 161000000)
 719                 band = 1;
 720         else if (params->frequency < 444000000)
 721                 band = 2;
 722         else if (params->frequency < 861000000)
 723                 band = 4;
 724         else
 725                 return -EINVAL;
 726
 727         // setup PLL filter
 728         switch (params->u.ofdm.bandwidth) {
 729         case BANDWIDTH_6_MHZ:
 730                 filter = 0;
 731                 break;
 732
 733         case BANDWIDTH_7_MHZ:
 734                 filter = 0;
 735                 break;
 736
 737         case BANDWIDTH_8_MHZ:
 738                 filter = 1;
 739                 break;
 740
 741         default:
 742                 return -EINVAL;
 743         }
 744
 745         // calculate divisor
 746         // ((36166000+((1000000/6)/2)) + Finput)/(1000000/6)
 747         tuner_frequency = (((params->frequency / 1000) * 6) + 217496) / 1000;
 748
 749         // setup tuner buffer
 750         tuner_buf[0] = (tuner_frequency >> 8) & 0x7f;
 751         tuner_buf[1] = tuner_frequency & 0xff;
 752         tuner_buf[2] = 0xca;
 753         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 754
 755         if (fe->ops.i2c_gate_ctrl)
 756                 fe->ops.i2c_gate_ctrl(fe, 1);
 757         if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
 758                 return -EIO;
 759
 760         msleep(1);
 761         return 0;
 762 }
 763
 764 static int philips_tu1216_request_firmware(struct dvb_frontend *fe,
 765                                            const struct firmware **fw, char *name)
 766 {
 767         struct budget *budget = (struct budget *) fe->dvb->priv;
 768
 769         return request_firmware(fw, name, &budget->dev->pci->dev);
 770 }
 771
 772 static struct tda1004x_config philips_tu1216_config = {
 773
 774         .demod_address = 0x8,
 775         .invert = 1,
 776         .invert_oclk = 1,
 777         .xtal_freq = TDA10046_XTAL_4M,
 778         .agc_config = TDA10046_AGC_DEFAULT,
 779         .if_freq = TDA10046_FREQ_3617,
 780         .request_firmware = philips_tu1216_request_firmware,
 781 };
 782
 783 static u8 philips_sd1878_inittab[] = {
 784         0x01, 0x15,
 785         0x02, 0x30,
 786         0x03, 0x00,
 787         0x04, 0x7d,
 788         0x05, 0x35,
 789         0x06, 0x40,
 790         0x07, 0x00,
 791         0x08, 0x43,
 792         0x09, 0x02,
 793         0x0C, 0x51,
 794         0x0D, 0x82,
 795         0x0E, 0x23,
 796         0x10, 0x3f,
 797         0x11, 0x84,
 798         0x12, 0xb9,
 799         0x15, 0xc9,
 800         0x16, 0x19,
 801         0x17, 0x8c,
 802         0x18, 0x59,
 803         0x19, 0xf8,
 804         0x1a, 0xfe,
 805         0x1c, 0x7f,
 806         0x1d, 0x00,
 807         0x1e, 0x00,
 808         0x1f, 0x50,
 809         0x20, 0x00,
 810         0x21, 0x00,
 811         0x22, 0x00,
 812         0x23, 0x00,
 813         0x28, 0x00,
 814         0x29, 0x28,
 815         0x2a, 0x14,
 816         0x2b, 0x0f,
 817         0x2c, 0x09,
 818         0x2d, 0x09,
 819         0x31, 0x1f,
 820         0x32, 0x19,
 821         0x33, 0xfc,
 822         0x34, 0x93,
 823         0xff, 0xff
 824 };
 825
 826 static int philips_sd1878_tda8261_tuner_set_params(struct dvb_frontend *fe,
 827                                                    struct dvb_frontend_parameters *params)
 828 {
 829         u8              buf[4];
 830         int             rc;
 831         struct i2c_msg  tuner_msg = {.addr=0x60,.flags=0,.buf=buf,.len=sizeof(buf)};
 832         struct budget *budget = (struct budget *) fe->dvb->priv;
 833
 834         if((params->frequency < 950000) || (params->frequency > 2150000))
 835                 return -EINVAL;
 836
 837         rc=dvb_pll_configure(&dvb_pll_philips_sd1878_tda8261, buf,
 838                              params->frequency, 0);
 839         if(rc < 0) return rc;
 840
 841         if (fe->ops.i2c_gate_ctrl)
 842                 fe->ops.i2c_gate_ctrl(fe, 1);
 843         if(i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
 844                 return -EIO;
 845
 846     return 0;
 847 }
 848
 849 static int philips_sd1878_ci_set_symbol_rate(struct dvb_frontend *fe,
 850                 u32 srate, u32 ratio)
 851 {
 852         u8 aclk = 0;
 853         u8 bclk = 0;
 854         u8 m1;
 855
 856         aclk = 0xb5;
 857         if (srate < 2000000)
 858                 bclk = 0x86;
 859         else if (srate < 5000000)
 860                 bclk = 0x89;
 861         else if (srate < 15000000)
 862                 bclk = 0x8f;
 863         else if (srate < 45000000)
 864                 bclk = 0x95;
 865
 866         m1 = 0x14;
 867         if (srate < 4000000)
 868                 m1 = 0x10;
 869
 870         stv0299_writereg(fe, 0x0e, 0x23);
 871         stv0299_writereg(fe, 0x0f, 0x94);
 872         stv0299_writereg(fe, 0x10, 0x39);
 873         stv0299_writereg(fe, 0x13, aclk);
 874         stv0299_writereg(fe, 0x14, bclk);
 875         stv0299_writereg(fe, 0x15, 0xc9);
 876         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
 877         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
 878         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
 879         stv0299_writereg(fe, 0x0f, 0x80 | m1);
 880
 881         return 0;
 882 }
 883
 884 static struct stv0299_config philips_sd1878_config = {
 885         .demod_address = 0x68,
 886      .inittab = philips_sd1878_inittab,
 887         .mclk = 88000000UL,
 888         .invert = 0,
 889         .skip_reinit = 0,
 890         .lock_output = STV0229_LOCKOUTPUT_1,
 891         .volt13_op0_op1 = STV0299_VOLT13_OP0,
 892         .min_delay_ms = 100,
 893         .set_symbol_rate = philips_sd1878_ci_set_symbol_rate,
 894 };
 895
 896 static u8 read_pwm(struct budget_av *budget_av)
 897 {
 898         u8 b = 0xff;
 899         u8 pwm;
 900         struct i2c_msg msg[] = { {.addr = 0x50,.flags = 0,.buf = &b,.len = 1},
 901         {.addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1}
 902         };
 903
 904         if ((i2c_transfer(&budget_av->budget.i2c_adap, msg, 2) != 2)
 905             || (pwm == 0xff))
 906                 pwm = 0x48;
 907
 908         return pwm;
 909 }
 910
 911 #define SUBID_DVBS_KNC1         0x0010
 912 #define SUBID_DVBS_KNC1_PLUS    0x0011
 913 #define SUBID_DVBS_TYPHOON      0x4f56
 914 #define SUBID_DVBS_CINERGY1200  0x1154
 915 #define SUBID_DVBS_CYNERGY1200N 0x1155
 916
 917 #define SUBID_DVBS_TV_STAR      0x0014
 918 #define SUBID_DVBS_TV_STAR_CI   0x0016
 919 #define SUBID_DVBS_EASYWATCH_1  0x001a
 920 #define SUBID_DVBS_EASYWATCH    0x001e
 921 #define SUBID_DVBC_EASYWATCH    0x002a
 922 #define SUBID_DVBC_KNC1         0x0020
 923 #define SUBID_DVBC_KNC1_PLUS    0x0021
 924 #define SUBID_DVBC_CINERGY1200  0x1156
 925
 926 #define SUBID_DVBT_KNC1_PLUS    0x0031
 927 #define SUBID_DVBT_KNC1         0x0030
 928 #define SUBID_DVBT_CINERGY1200  0x1157
 929
 930
 931 static int tda10021_set_frontend(struct dvb_frontend *fe,
 932                                  struct dvb_frontend_parameters *p)
 933 {
 934         struct budget_av* budget_av = fe->dvb->priv;
 935         int result;
 936
 937         result = budget_av->tda10021_set_frontend(fe, p);
 938         if (budget_av->tda10021_ts_enabled) {
 939                 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
 940         } else {
 941                 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
 942         }
 943
 944         return result;
 945 }
 946
 947 static void frontend_init(struct budget_av *budget_av)
 948 {
 949         struct saa7146_dev * saa = budget_av->budget.dev;
 950         struct dvb_frontend * fe = NULL;
 951
 952         /* Enable / PowerON Frontend */
 953         saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
 954
 955         /* Wait for PowerON */
 956         msleep(100);
 957
 958         /* additional setup necessary for the PLUS cards */
 959         switch (saa->pci->subsystem_device) {
 960                 case SUBID_DVBS_KNC1_PLUS:
 961                 case SUBID_DVBC_KNC1_PLUS:
 962                 case SUBID_DVBT_KNC1_PLUS:
 963                 case SUBID_DVBC_EASYWATCH:
 964                         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
 965                         break;
 966         }
 967
 968         switch (saa->pci->subsystem_device) {
 969
 970         case SUBID_DVBS_KNC1:
 971         case SUBID_DVBS_KNC1_PLUS:
 972         case SUBID_DVBS_EASYWATCH_1:
 973                 if (saa->pci->subsystem_vendor == 0x1894) {
 974                         fe = dvb_attach(stv0299_attach, &cinergy_1200s_1894_0010_config,
 975                                              &budget_av->budget.i2c_adap);
 976                         if (fe) {
 977                                 dvb_attach(tua6100_attach, fe, 0x60, &budget_av->budget.i2c_adap);
 978                         }
 979                 } else {
 980                         fe = dvb_attach(stv0299_attach, &typhoon_config,
 981                                              &budget_av->budget.i2c_adap);
 982                         if (fe) {
 983                                 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
 984                         }
 985                 }
 986                 break;
 987
 988         case SUBID_DVBS_TV_STAR:
 989         case SUBID_DVBS_TV_STAR_CI:
 990         case SUBID_DVBS_CYNERGY1200N:
 991         case SUBID_DVBS_EASYWATCH:
 992                 fe = dvb_attach(stv0299_attach, &philips_sd1878_config,
 993                                 &budget_av->budget.i2c_adap);
 994                 if (fe) {
 995                         fe->ops.tuner_ops.set_params = philips_sd1878_tda8261_tuner_set_params;
 996                 }
 997                 break;
 998
 999         case SUBID_DVBS_TYPHOON:
1000                 fe = dvb_attach(stv0299_attach, &typhoon_config,
1001                                     &budget_av->budget.i2c_adap);
1002                 if (fe) {
1003                         fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1004                 }
1005                 break;
1006
1007         case SUBID_DVBS_CINERGY1200:
1008                 fe = dvb_attach(stv0299_attach, &cinergy_1200s_config,
1009                                     &budget_av->budget.i2c_adap);
1010                 if (fe) {
1011                         fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1012                 }
1013                 break;
1014
1015         case SUBID_DVBC_KNC1:
1016         case SUBID_DVBC_KNC1_PLUS:
1017         case SUBID_DVBC_CINERGY1200:
1018         case SUBID_DVBC_EASYWATCH:
1019                 budget_av->reinitialise_demod = 1;
1020                 fe = dvb_attach(tda10021_attach, &philips_cu1216_config,
1021                                      &budget_av->budget.i2c_adap,
1022                                      read_pwm(budget_av));
1023                 if (fe == NULL)
1024                         fe = dvb_attach(tda10021_attach, &philips_cu1216_config_altaddress,
1025                                              &budget_av->budget.i2c_adap,
1026                                              read_pwm(budget_av));
1027                 if (fe) {
1028                         budget_av->tda10021_poclkp = 1;
1029                         budget_av->tda10021_set_frontend = fe->ops.set_frontend;
1030                         fe->ops.set_frontend = tda10021_set_frontend;
1031                         fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
1032                 }
1033                 break;
1034
1035         case SUBID_DVBT_KNC1:
1036         case SUBID_DVBT_KNC1_PLUS:
1037         case SUBID_DVBT_CINERGY1200:
1038                 budget_av->reinitialise_demod = 1;
1039                 fe = dvb_attach(tda10046_attach, &philips_tu1216_config,
1040                                      &budget_av->budget.i2c_adap);
1041                 if (fe) {
1042                         fe->ops.tuner_ops.init = philips_tu1216_tuner_init;
1043                         fe->ops.tuner_ops.set_params = philips_tu1216_tuner_set_params;
1044                 }
1045                 break;
1046         }
1047
1048         if (fe == NULL) {
1049                 printk(KERN_ERR "budget-av: A frontend driver was not found "
1050                                 "for device %04x/%04x subsystem %04x/%04x\n",
1051                        saa->pci->vendor,
1052                        saa->pci->device,
1053                        saa->pci->subsystem_vendor,
1054                        saa->pci->subsystem_device);
1055                 return;
1056         }
1057
1058         budget_av->budget.dvb_frontend = fe;
1059
1060         if (dvb_register_frontend(&budget_av->budget.dvb_adapter,
1061                                   budget_av->budget.dvb_frontend)) {
1062                 printk(KERN_ERR "budget-av: Frontend registration failed!\n");
1063                 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1064                 budget_av->budget.dvb_frontend = NULL;
1065         }
1066 }
1067
1068
1069 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr)
1070 {
1071         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1072
1073         dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av);
1074
1075         if (*isr & MASK_10)
1076                 ttpci_budget_irq10_handler(dev, isr);
1077 }
1078
1079 static int budget_av_detach(struct saa7146_dev *dev)
1080 {
1081         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1082         int err;
1083
1084         dprintk(2, "dev: %p\n", dev);
1085
1086         if (1 == budget_av->has_saa7113) {
1087                 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO);
1088
1089                 msleep(200);
1090
1091                 saa7146_unregister_device(&budget_av->vd, dev);
1092
1093                 saa7146_vv_release(dev);
1094         }
1095
1096         if (budget_av->budget.ci_present)
1097                 ciintf_deinit(budget_av);
1098
1099         if (budget_av->budget.dvb_frontend != NULL) {
1100                 dvb_unregister_frontend(budget_av->budget.dvb_frontend);
1101                 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1102         }
1103         err = ttpci_budget_deinit(&budget_av->budget);
1104
1105         kfree(budget_av);
1106
1107         return err;
1108 }
1109
1110 static struct saa7146_ext_vv vv_data;
1111
1112 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1113 {
1114         struct budget_av *budget_av;
1115         u8 *mac;
1116         int err;
1117
1118         dprintk(2, "dev: %p\n", dev);
1119
1120         if (!(budget_av = kzalloc(sizeof(struct budget_av), GFP_KERNEL)))
1121                 return -ENOMEM;
1122
1123         budget_av->has_saa7113 = 0;
1124         budget_av->budget.ci_present = 0;
1125
1126         dev->ext_priv = budget_av;
1127
1128         if ((err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE))) {
1129                 kfree(budget_av);
1130                 return err;
1131         }
1132
1133         /* knc1 initialization */
1134         saa7146_write(dev, DD1_STREAM_B, 0x04000000);
1135         saa7146_write(dev, DD1_INIT, 0x07000600);
1136         saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26);
1137
1138         if (saa7113_init(budget_av) == 0) {
1139                 budget_av->has_saa7113 = 1;
1140
1141                 if (0 != saa7146_vv_init(dev, &vv_data)) {
1142                         /* fixme: proper cleanup here */
1143                         ERR(("cannot init vv subsystem.\n"));
1144                         return err;
1145                 }
1146
1147                 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_GRABBER))) {
1148                         /* fixme: proper cleanup here */
1149                         ERR(("cannot register capture v4l2 device.\n"));
1150                         saa7146_vv_release(dev);
1151                         return err;
1152                 }
1153
1154                 /* beware: this modifies dev->vv ... */
1155                 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A,
1156                                                 SAA7146_HPS_SYNC_PORT_A);
1157
1158                 saa7113_setinput(budget_av, 0);
1159         }
1160
1161         /* fixme: find some sane values here... */
1162         saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1163
1164         mac = budget_av->budget.dvb_adapter.proposed_mac;
1165         if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) {
1166                 printk(KERN_ERR "KNC1-%d: Could not read MAC from KNC1 card\n",
1167                        budget_av->budget.dvb_adapter.num);
1168                 memset(mac, 0, 6);
1169         } else {
1170                 printk(KERN_INFO "KNC1-%d: MAC addr = %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
1171                        budget_av->budget.dvb_adapter.num,
1172                        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
1173         }
1174
1175         budget_av->budget.dvb_adapter.priv = budget_av;
1176         frontend_init(budget_av);
1177         ciintf_init(budget_av);
1178
1179         ttpci_budget_init_hooks(&budget_av->budget);
1180
1181         return 0;
1182 }
1183
1184 #define KNC1_INPUTS 2
1185 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = {
1186         {0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
1187         {1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
1188 };
1189
1190 static struct saa7146_extension_ioctls ioctls[] = {
1191         {VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE},
1192         {VIDIOC_G_INPUT, SAA7146_EXCLUSIVE},
1193         {VIDIOC_S_INPUT, SAA7146_EXCLUSIVE},
1194         {0, 0}
1195 };
1196
1197 static int av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
1198 {
1199         struct saa7146_dev *dev = fh->dev;
1200         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1201
1202         switch (cmd) {
1203         case VIDIOC_ENUMINPUT:{
1204                 struct v4l2_input *i = arg;
1205
1206                 dprintk(1, "VIDIOC_ENUMINPUT %d.\n", i->index);
1207                 if (i->index < 0 || i->index >= KNC1_INPUTS) {
1208                         return -EINVAL;
1209                 }
1210                 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input));
1211                 return 0;
1212         }
1213         case VIDIOC_G_INPUT:{
1214                 int *input = (int *) arg;
1215
1216                 *input = budget_av->cur_input;
1217
1218                 dprintk(1, "VIDIOC_G_INPUT %d.\n", *input);
1219                 return 0;
1220         }
1221         case VIDIOC_S_INPUT:{
1222                 int input = *(int *) arg;
1223                 dprintk(1, "VIDIOC_S_INPUT %d.\n", input);
1224                 return saa7113_setinput(budget_av, input);
1225         }
1226         default:
1227                 return -ENOIOCTLCMD;
1228         }
1229         return 0;
1230 }
1231
1232 static struct saa7146_standard standard[] = {
1233         {.name = "PAL",.id = V4L2_STD_PAL,
1234          .v_offset = 0x17,.v_field = 288,
1235          .h_offset = 0x14,.h_pixels = 680,
1236          .v_max_out = 576,.h_max_out = 768 },
1237
1238         {.name = "NTSC",.id = V4L2_STD_NTSC,
1239          .v_offset = 0x16,.v_field = 240,
1240          .h_offset = 0x06,.h_pixels = 708,
1241          .v_max_out = 480,.h_max_out = 640, },
1242 };
1243
1244 static struct saa7146_ext_vv vv_data = {
1245         .inputs = 2,
1246         .capabilities = 0,      // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113
1247         .flags = 0,
1248         .stds = &standard[0],
1249         .num_stds = sizeof(standard) / sizeof(struct saa7146_standard),
1250         .ioctls = &ioctls[0],
1251         .ioctl = av_ioctl,
1252 };
1253
1254 static struct saa7146_extension budget_extension;
1255
1256 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S);
1257 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C);
1258 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T);
1259 MAKE_BUDGET_INFO(kncxs, "KNC TV STAR DVB-S", BUDGET_TVSTAR);
1260 MAKE_BUDGET_INFO(satewpls, "Satelco EasyWatch DVB-S light", BUDGET_TVSTAR);
1261 MAKE_BUDGET_INFO(satewpls1, "Satelco EasyWatch DVB-S light", BUDGET_KNC1S);
1262 MAKE_BUDGET_INFO(satewplc, "Satelco EasyWatch DVB-C", BUDGET_KNC1CP);
1263 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
1264 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
1265 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
1266 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1267 MAKE_BUDGET_INFO(cin1200sn, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1268 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
1269 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
1270
1271 static struct pci_device_id pci_tbl[] = {
1272         MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56),
1273         MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010),
1274         MAKE_EXTENSION_PCI(knc1s, 0x1894, 0x0010),
1275         MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011),
1276         MAKE_EXTENSION_PCI(knc1sp, 0x1894, 0x0011),
1277         MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0014),
1278         MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0016),
1279         MAKE_EXTENSION_PCI(satewpls, 0x1894, 0x001e),
1280         MAKE_EXTENSION_PCI(satewpls1, 0x1894, 0x001a),
1281         MAKE_EXTENSION_PCI(satewplc, 0x1894, 0x002a),
1282         MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
1283         MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
1284         MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
1285         MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
1286         MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
1287         MAKE_EXTENSION_PCI(cin1200sn, 0x153b, 0x1155),
1288         MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
1289         MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
1290         {
1291          .vendor = 0,
1292         }
1293 };
1294
1295 MODULE_DEVICE_TABLE(pci, pci_tbl);
1296
1297 static struct saa7146_extension budget_extension = {
1298         .name = "budget_av",
1299         .flags = SAA7146_USE_I2C_IRQ,
1300
1301         .pci_tbl = pci_tbl,
1302
1303         .module = THIS_MODULE,
1304         .attach = budget_av_attach,
1305         .detach = budget_av_detach,
1306
1307         .irq_mask = MASK_10,
1308         .irq_func = budget_av_irq,
1309 };
1310
1311 static int __init budget_av_init(void)
1312 {
1313         return saa7146_register_extension(&budget_extension);
1314 }
1315
1316 static void __exit budget_av_exit(void)
1317 {
1318         saa7146_unregister_extension(&budget_extension);
1319 }
1320
1321 module_init(budget_av_init);
1322 module_exit(budget_av_exit);
1323
1324 MODULE_LICENSE("GPL");
1325 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others");
1326 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1327                    "budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)");