drivers/media/pci/ngene/ngene-cards.c

   1 /*
   2  * ngene-cards.c: nGene PCIe bridge driver - card specific info
   3  *
   4  * Copyright (C) 2005-2007 Micronas
   5  *
   6  * Copyright (C) 2008-2009 Ralph Metzler <rjkm@metzlerbros.de>
   7  *                         Modifications for new nGene firmware,
   8  *                         support for EEPROM-copying,
   9  *                         support for new dual DVB-S2 card prototype
  10  *
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * version 2 only, as published by the Free Software Foundation.
  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  * To obtain the license, point your browser to
  23  * http://www.gnu.org/copyleft/gpl.html
  24  */
  25
  26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  27
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/pci.h>
  31 #include <linux/pci_ids.h>
  32
  33 #include "ngene.h"
  34
  35 /* demods/tuners */
  36 #include "stv6110x.h"
  37 #include "stv090x.h"
  38 #include "lnbh24.h"
  39 #include "lgdt330x.h"
  40 #include "mt2131.h"
  41 #include "tda18271c2dd.h"
  42 #include "drxk.h"
  43 #include "drxd.h"
  44 #include "dvb-pll.h"
  45 #include "stv0367.h"
  46 #include "stv0367_priv.h"
  47 #include "tda18212.h"
  48 #include "cxd2841er.h"
  49 #include "stv0910.h"
  50 #include "stv6111.h"
  51 #include "lnbh25.h"
  52
  53 /****************************************************************************/
  54 /* I2C transfer functions used for demod/tuner probing***********************/
  55 /****************************************************************************/
  56
  57 static int i2c_io(struct i2c_adapter *adapter, u8 adr,
  58                   u8 *wbuf, u32 wlen, u8 *rbuf, u32 rlen)
  59 {
  60         struct i2c_msg msgs[2] = {{.addr = adr,  .flags = 0,
  61                                    .buf  = wbuf, .len   = wlen },
  62                                   {.addr = adr,  .flags = I2C_M_RD,
  63                                    .buf  = rbuf,  .len   = rlen } };
  64         return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
  65 }
  66
  67 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
  68 {
  69         struct i2c_msg msg = {.addr = adr, .flags = 0,
  70                               .buf = data, .len = len};
  71
  72         return (i2c_transfer(adap, &msg, 1) == 1) ? 0 : -1;
  73 }
  74
  75 static int i2c_write_reg(struct i2c_adapter *adap, u8 adr,
  76                          u8 reg, u8 val)
  77 {
  78         u8 msg[2] = {reg, val};
  79
  80         return i2c_write(adap, adr, msg, 2);
  81 }
  82
  83 static int i2c_read(struct i2c_adapter *adapter, u8 adr, u8 *val)
  84 {
  85         struct i2c_msg msgs[1] = {{.addr = adr,  .flags = I2C_M_RD,
  86                                    .buf  = val,  .len   = 1 } };
  87         return (i2c_transfer(adapter, msgs, 1) == 1) ? 0 : -1;
  88 }
  89
  90 static int i2c_read_reg16(struct i2c_adapter *adapter, u8 adr,
  91                           u16 reg, u8 *val)
  92 {
  93         u8 msg[2] = {reg >> 8, reg & 0xff};
  94         struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
  95                                    .buf  = msg, .len   = 2},
  96                                   {.addr = adr, .flags = I2C_M_RD,
  97                                    .buf  = val, .len   = 1} };
  98         return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
  99 }
 100
 101 static int i2c_read_regs(struct i2c_adapter *adapter,
 102                          u8 adr, u8 reg, u8 *val, u8 len)
 103 {
 104         struct i2c_msg msgs[2] = {{.addr = adr,  .flags = 0,
 105                                    .buf  = &reg, .len   = 1},
 106                                   {.addr = adr,  .flags = I2C_M_RD,
 107                                    .buf  = val,  .len   = len} };
 108
 109         return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
 110 }
 111
 112 static int i2c_read_reg(struct i2c_adapter *adapter, u8 adr, u8 reg, u8 *val)
 113 {
 114         return i2c_read_regs(adapter, adr, reg, val, 1);
 115 }
 116
 117 /****************************************************************************/
 118 /* Demod/tuner attachment ***************************************************/
 119 /****************************************************************************/
 120
 121 static struct i2c_adapter *i2c_adapter_from_chan(struct ngene_channel *chan)
 122 {
 123         /* tuner 1+2: i2c adapter #0, tuner 3+4: i2c adapter #1 */
 124         if (chan->number < 2)
 125                 return &chan->dev->channel[0].i2c_adapter;
 126
 127         return &chan->dev->channel[1].i2c_adapter;
 128 }
 129
 130 static int tuner_attach_stv6110(struct ngene_channel *chan)
 131 {
 132         struct device *pdev = &chan->dev->pci_dev->dev;
 133         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 134         struct stv090x_config *feconf = (struct stv090x_config *)
 135                 chan->dev->card_info->fe_config[chan->number];
 136         struct stv6110x_config *tunerconf = (struct stv6110x_config *)
 137                 chan->dev->card_info->tuner_config[chan->number];
 138         const struct stv6110x_devctl *ctl;
 139
 140         ctl = dvb_attach(stv6110x_attach, chan->fe, tunerconf, i2c);
 141         if (ctl == NULL) {
 142                 dev_err(pdev, "No STV6110X found!\n");
 143                 return -ENODEV;
 144         }
 145
 146         feconf->tuner_init          = ctl->tuner_init;
 147         feconf->tuner_sleep         = ctl->tuner_sleep;
 148         feconf->tuner_set_mode      = ctl->tuner_set_mode;
 149         feconf->tuner_set_frequency = ctl->tuner_set_frequency;
 150         feconf->tuner_get_frequency = ctl->tuner_get_frequency;
 151         feconf->tuner_set_bandwidth = ctl->tuner_set_bandwidth;
 152         feconf->tuner_get_bandwidth = ctl->tuner_get_bandwidth;
 153         feconf->tuner_set_bbgain    = ctl->tuner_set_bbgain;
 154         feconf->tuner_get_bbgain    = ctl->tuner_get_bbgain;
 155         feconf->tuner_set_refclk    = ctl->tuner_set_refclk;
 156         feconf->tuner_get_status    = ctl->tuner_get_status;
 157
 158         return 0;
 159 }
 160
 161 static int tuner_attach_stv6111(struct ngene_channel *chan)
 162 {
 163         struct device *pdev = &chan->dev->pci_dev->dev;
 164         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 165         struct dvb_frontend *fe;
 166         u8 adr = 4 + ((chan->number & 1) ? 0x63 : 0x60);
 167
 168         fe = dvb_attach(stv6111_attach, chan->fe, i2c, adr);
 169         if (!fe) {
 170                 fe = dvb_attach(stv6111_attach, chan->fe, i2c, adr & ~4);
 171                 if (!fe) {
 172                         dev_err(pdev, "stv6111_attach() failed!\n");
 173                         return -ENODEV;
 174                 }
 175         }
 176         return 0;
 177 }
 178
 179 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
 180 {
 181         struct ngene_channel *chan = fe->sec_priv;
 182         int status;
 183
 184         if (enable) {
 185                 down(&chan->dev->pll_mutex);
 186                 status = chan->gate_ctrl(fe, 1);
 187         } else {
 188                 status = chan->gate_ctrl(fe, 0);
 189                 up(&chan->dev->pll_mutex);
 190         }
 191         return status;
 192 }
 193
 194 static int tuner_attach_tda18271(struct ngene_channel *chan)
 195 {
 196         struct device *pdev = &chan->dev->pci_dev->dev;
 197         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 198         struct dvb_frontend *fe;
 199
 200         if (chan->fe->ops.i2c_gate_ctrl)
 201                 chan->fe->ops.i2c_gate_ctrl(chan->fe, 1);
 202         fe = dvb_attach(tda18271c2dd_attach, chan->fe, i2c, 0x60);
 203         if (chan->fe->ops.i2c_gate_ctrl)
 204                 chan->fe->ops.i2c_gate_ctrl(chan->fe, 0);
 205         if (!fe) {
 206                 dev_err(pdev, "No TDA18271 found!\n");
 207                 return -ENODEV;
 208         }
 209
 210         return 0;
 211 }
 212
 213 static int tuner_tda18212_ping(struct ngene_channel *chan,
 214                                struct i2c_adapter *i2c,
 215                                unsigned short adr)
 216 {
 217         struct device *pdev = &chan->dev->pci_dev->dev;
 218         u8 tda_id[2];
 219         u8 subaddr = 0x00;
 220
 221         dev_dbg(pdev, "stv0367-tda18212 tuner ping\n");
 222         if (chan->fe->ops.i2c_gate_ctrl)
 223                 chan->fe->ops.i2c_gate_ctrl(chan->fe, 1);
 224
 225         if (i2c_read_regs(i2c, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
 226                 dev_dbg(pdev, "tda18212 ping 1 fail\n");
 227         if (i2c_read_regs(i2c, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
 228                 dev_warn(pdev, "tda18212 ping failed, expect problems\n");
 229
 230         if (chan->fe->ops.i2c_gate_ctrl)
 231                 chan->fe->ops.i2c_gate_ctrl(chan->fe, 0);
 232
 233         return 0;
 234 }
 235
 236 static int tuner_attach_tda18212(struct ngene_channel *chan, u32 dmdtype)
 237 {
 238         struct device *pdev = &chan->dev->pci_dev->dev;
 239         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 240         struct i2c_client *client;
 241         struct tda18212_config config = {
 242                 .fe = chan->fe,
 243                 .if_dvbt_6 = 3550,
 244                 .if_dvbt_7 = 3700,
 245                 .if_dvbt_8 = 4150,
 246                 .if_dvbt2_6 = 3250,
 247                 .if_dvbt2_7 = 4000,
 248                 .if_dvbt2_8 = 4000,
 249                 .if_dvbc = 5000,
 250         };
 251         u8 addr = (chan->number & 1) ? 0x63 : 0x60;
 252
 253         /*
 254          * due to a hardware quirk with the I2C gate on the stv0367+tda18212
 255          * combo, the tda18212 must be probed by reading it's id _twice_ when
 256          * cold started, or it very likely will fail.
 257          */
 258         if (dmdtype == DEMOD_TYPE_STV0367)
 259                 tuner_tda18212_ping(chan, i2c, addr);
 260
 261         /* perform tuner probe/init/attach */
 262         client = dvb_module_probe("tda18212", NULL, i2c, addr, &config);
 263         if (!client)
 264                 goto err;
 265
 266         chan->i2c_client[0] = client;
 267         chan->i2c_client_fe = 1;
 268
 269         return 0;
 270 err:
 271         dev_err(pdev, "TDA18212 tuner not found. Device is not fully operational.\n");
 272         return -ENODEV;
 273 }
 274
 275 static int tuner_attach_probe(struct ngene_channel *chan)
 276 {
 277         switch (chan->demod_type) {
 278         case DEMOD_TYPE_STV090X:
 279                 return tuner_attach_stv6110(chan);
 280         case DEMOD_TYPE_DRXK:
 281                 return tuner_attach_tda18271(chan);
 282         case DEMOD_TYPE_STV0367:
 283         case DEMOD_TYPE_SONY_CT2:
 284         case DEMOD_TYPE_SONY_ISDBT:
 285         case DEMOD_TYPE_SONY_C2T2:
 286         case DEMOD_TYPE_SONY_C2T2I:
 287                 return tuner_attach_tda18212(chan, chan->demod_type);
 288         case DEMOD_TYPE_STV0910:
 289                 return tuner_attach_stv6111(chan);
 290         }
 291
 292         return -EINVAL;
 293 }
 294
 295 static int demod_attach_stv0900(struct ngene_channel *chan)
 296 {
 297         struct device *pdev = &chan->dev->pci_dev->dev;
 298         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 299         struct stv090x_config *feconf = (struct stv090x_config *)
 300                 chan->dev->card_info->fe_config[chan->number];
 301
 302         chan->fe = dvb_attach(stv090x_attach, feconf, i2c,
 303                         (chan->number & 1) == 0 ? STV090x_DEMODULATOR_0
 304                                                 : STV090x_DEMODULATOR_1);
 305         if (chan->fe == NULL) {
 306                 dev_err(pdev, "No STV0900 found!\n");
 307                 return -ENODEV;
 308         }
 309
 310         /* store channel info */
 311         if (feconf->tuner_i2c_lock)
 312                 chan->fe->analog_demod_priv = chan;
 313
 314         if (!dvb_attach(lnbh24_attach, chan->fe, i2c, 0,
 315                         0, chan->dev->card_info->lnb[chan->number])) {
 316                 dev_err(pdev, "No LNBH24 found!\n");
 317                 dvb_frontend_detach(chan->fe);
 318                 chan->fe = NULL;
 319                 return -ENODEV;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static struct stv0910_cfg stv0910_p = {
 326         .adr      = 0x68,
 327         .parallel = 1,
 328         .rptlvl   = 4,
 329         .clk      = 30000000,
 330         .tsspeed  = 0x28,
 331 };
 332
 333 static struct lnbh25_config lnbh25_cfg = {
 334         .i2c_address = 0x0c << 1,
 335         .data2_config = LNBH25_TEN
 336 };
 337
 338 static int demod_attach_stv0910(struct ngene_channel *chan,
 339                                 struct i2c_adapter *i2c)
 340 {
 341         struct device *pdev = &chan->dev->pci_dev->dev;
 342         struct stv0910_cfg cfg = stv0910_p;
 343         struct lnbh25_config lnbcfg = lnbh25_cfg;
 344
 345         chan->fe = dvb_attach(stv0910_attach, i2c, &cfg, (chan->number & 1));
 346         if (!chan->fe) {
 347                 cfg.adr = 0x6c;
 348                 chan->fe = dvb_attach(stv0910_attach, i2c,
 349                                       &cfg, (chan->number & 1));
 350         }
 351         if (!chan->fe) {
 352                 dev_err(pdev, "stv0910_attach() failed!\n");
 353                 return -ENODEV;
 354         }
 355
 356         /*
 357          * attach lnbh25 - leftshift by one as the lnbh25 driver expects 8bit
 358          * i2c addresses
 359          */
 360         lnbcfg.i2c_address = (((chan->number & 1) ? 0x0d : 0x0c) << 1);
 361         if (!dvb_attach(lnbh25_attach, chan->fe, &lnbcfg, i2c)) {
 362                 lnbcfg.i2c_address = (((chan->number & 1) ? 0x09 : 0x08) << 1);
 363                 if (!dvb_attach(lnbh25_attach, chan->fe, &lnbcfg, i2c)) {
 364                         dev_err(pdev, "lnbh25_attach() failed!\n");
 365                         dvb_frontend_detach(chan->fe);
 366                         chan->fe = NULL;
 367                         return -ENODEV;
 368                 }
 369         }
 370
 371         return 0;
 372 }
 373
 374 static struct stv0367_config ddb_stv0367_config[] = {
 375         {
 376                 .demod_address = 0x1f,
 377                 .xtal = 27000000,
 378                 .if_khz = 0,
 379                 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
 380                 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
 381                 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
 382         }, {
 383                 .demod_address = 0x1e,
 384                 .xtal = 27000000,
 385                 .if_khz = 0,
 386                 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
 387                 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
 388                 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
 389         },
 390 };
 391
 392 static int demod_attach_stv0367(struct ngene_channel *chan,
 393                                 struct i2c_adapter *i2c)
 394 {
 395         struct device *pdev = &chan->dev->pci_dev->dev;
 396
 397         chan->fe = dvb_attach(stv0367ddb_attach,
 398                               &ddb_stv0367_config[(chan->number & 1)], i2c);
 399
 400         if (!chan->fe) {
 401                 dev_err(pdev, "stv0367ddb_attach() failed!\n");
 402                 return -ENODEV;
 403         }
 404
 405         chan->fe->sec_priv = chan;
 406         chan->gate_ctrl = chan->fe->ops.i2c_gate_ctrl;
 407         chan->fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
 408         return 0;
 409 }
 410
 411 static int demod_attach_cxd28xx(struct ngene_channel *chan,
 412                                 struct i2c_adapter *i2c, int osc24)
 413 {
 414         struct device *pdev = &chan->dev->pci_dev->dev;
 415         struct cxd2841er_config cfg;
 416
 417         /* the cxd2841er driver expects 8bit/shifted I2C addresses */
 418         cfg.i2c_addr = ((chan->number & 1) ? 0x6d : 0x6c) << 1;
 419
 420         cfg.xtal = osc24 ? SONY_XTAL_24000 : SONY_XTAL_20500;
 421         cfg.flags = CXD2841ER_AUTO_IFHZ | CXD2841ER_EARLY_TUNE |
 422                 CXD2841ER_NO_WAIT_LOCK | CXD2841ER_NO_AGCNEG |
 423                 CXD2841ER_TSBITS | CXD2841ER_TS_SERIAL;
 424
 425         /* attach frontend */
 426         chan->fe = dvb_attach(cxd2841er_attach_t_c, &cfg, i2c);
 427
 428         if (!chan->fe) {
 429                 dev_err(pdev, "CXD28XX attach failed!\n");
 430                 return -ENODEV;
 431         }
 432
 433         chan->fe->sec_priv = chan;
 434         chan->gate_ctrl = chan->fe->ops.i2c_gate_ctrl;
 435         chan->fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
 436         return 0;
 437 }
 438
 439 static void cineS2_tuner_i2c_lock(struct dvb_frontend *fe, int lock)
 440 {
 441         struct ngene_channel *chan = fe->analog_demod_priv;
 442
 443         if (lock)
 444                 down(&chan->dev->pll_mutex);
 445         else
 446                 up(&chan->dev->pll_mutex);
 447 }
 448
 449 static int port_has_stv0900(struct i2c_adapter *i2c, int port)
 450 {
 451         u8 val;
 452         if (i2c_read_reg16(i2c, 0x68+port/2, 0xf100, &val) < 0)
 453                 return 0;
 454         return 1;
 455 }
 456
 457 static int port_has_drxk(struct i2c_adapter *i2c, int port)
 458 {
 459         u8 val;
 460
 461         if (i2c_read(i2c, 0x29+port, &val) < 0)
 462                 return 0;
 463         return 1;
 464 }
 465
 466 static int port_has_stv0367(struct i2c_adapter *i2c)
 467 {
 468         u8 val;
 469
 470         if (i2c_read_reg16(i2c, 0x1e, 0xf000, &val) < 0)
 471                 return 0;
 472         if (val != 0x60)
 473                 return 0;
 474         if (i2c_read_reg16(i2c, 0x1f, 0xf000, &val) < 0)
 475                 return 0;
 476         if (val != 0x60)
 477                 return 0;
 478         return 1;
 479 }
 480
 481 int ngene_port_has_cxd2099(struct i2c_adapter *i2c, u8 *type)
 482 {
 483         u8 val;
 484         u8 probe[4] = { 0xe0, 0x00, 0x00, 0x00 }, data[4];
 485         struct i2c_msg msgs[2] = {{ .addr = 0x40,  .flags = 0,
 486                                     .buf  = probe, .len   = 4 },
 487                                   { .addr = 0x40,  .flags = I2C_M_RD,
 488                                     .buf  = data,  .len   = 4 } };
 489         val = i2c_transfer(i2c, msgs, 2);
 490         if (val != 2)
 491                 return 0;
 492
 493         if (data[0] == 0x02 && data[1] == 0x2b && data[3] == 0x43)
 494                 *type = 2;
 495         else
 496                 *type = 1;
 497         return 1;
 498 }
 499
 500 static int demod_attach_drxk(struct ngene_channel *chan,
 501                              struct i2c_adapter *i2c)
 502 {
 503         struct device *pdev = &chan->dev->pci_dev->dev;
 504         struct drxk_config config;
 505
 506         memset(&config, 0, sizeof(config));
 507         config.microcode_name = "drxk_a3.mc";
 508         config.qam_demod_parameter_count = 4;
 509         config.adr = 0x29 + (chan->number ^ 2);
 510
 511         chan->fe = dvb_attach(drxk_attach, &config, i2c);
 512         if (!chan->fe) {
 513                 dev_err(pdev, "No DRXK found!\n");
 514                 return -ENODEV;
 515         }
 516         chan->fe->sec_priv = chan;
 517         chan->gate_ctrl = chan->fe->ops.i2c_gate_ctrl;
 518         chan->fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
 519         return 0;
 520 }
 521
 522 /****************************************************************************/
 523 /* XO2 related lists and functions ******************************************/
 524 /****************************************************************************/
 525
 526 static char *xo2names[] = {
 527         "DUAL DVB-S2",
 528         "DUAL DVB-C/T/T2",
 529         "DUAL DVB-ISDBT",
 530         "DUAL DVB-C/C2/T/T2",
 531         "DUAL ATSC",
 532         "DUAL DVB-C/C2/T/T2/I",
 533 };
 534
 535 static int init_xo2(struct ngene_channel *chan, struct i2c_adapter *i2c)
 536 {
 537         struct device *pdev = &chan->dev->pci_dev->dev;
 538         u8 addr = 0x10;
 539         u8 val, data[2];
 540         int res;
 541
 542         res = i2c_read_regs(i2c, addr, 0x04, data, 2);
 543         if (res < 0)
 544                 return res;
 545
 546         if (data[0] != 0x01)  {
 547                 dev_info(pdev, "Invalid XO2 on channel %d\n", chan->number);
 548                 return -1;
 549         }
 550
 551         i2c_read_reg(i2c, addr, 0x08, &val);
 552         if (val != 0) {
 553                 i2c_write_reg(i2c, addr, 0x08, 0x00);
 554                 msleep(100);
 555         }
 556         /* Enable tuner power, disable pll, reset demods */
 557         i2c_write_reg(i2c, addr, 0x08, 0x04);
 558         usleep_range(2000, 3000);
 559         /* Release demod resets */
 560         i2c_write_reg(i2c, addr, 0x08, 0x07);
 561
 562         /*
 563          * speed: 0=55,1=75,2=90,3=104 MBit/s
 564          * Note: The ngene hardware must be run at 75 MBit/s compared
 565          * to more modern ddbridge hardware which runs at 90 MBit/s,
 566          * else there will be issues with the data transport and non-
 567          * working secondary/slave demods/tuners.
 568          */
 569         i2c_write_reg(i2c, addr, 0x09, 1);
 570
 571         i2c_write_reg(i2c, addr, 0x0a, 0x01);
 572         i2c_write_reg(i2c, addr, 0x0b, 0x01);
 573
 574         usleep_range(2000, 3000);
 575         /* Start XO2 PLL */
 576         i2c_write_reg(i2c, addr, 0x08, 0x87);
 577
 578         return 0;
 579 }
 580
 581 static int port_has_xo2(struct i2c_adapter *i2c, u8 *type, u8 *id)
 582 {
 583         u8 probe[1] = { 0x00 }, data[4];
 584         u8 addr = 0x10;
 585
 586         *type = NGENE_XO2_TYPE_NONE;
 587
 588         if (i2c_io(i2c, addr, probe, 1, data, 4))
 589                 return 0;
 590         if (data[0] == 'D' && data[1] == 'F') {
 591                 *id = data[2];
 592                 *type = NGENE_XO2_TYPE_DUOFLEX;
 593                 return 1;
 594         }
 595         if (data[0] == 'C' && data[1] == 'I') {
 596                 *id = data[2];
 597                 *type = NGENE_XO2_TYPE_CI;
 598                 return 1;
 599         }
 600         return 0;
 601 }
 602
 603 /****************************************************************************/
 604 /* Probing and port/channel handling ****************************************/
 605 /****************************************************************************/
 606
 607 static int cineS2_probe(struct ngene_channel *chan)
 608 {
 609         struct device *pdev = &chan->dev->pci_dev->dev;
 610         struct i2c_adapter *i2c = i2c_adapter_from_chan(chan);
 611         struct stv090x_config *fe_conf;
 612         u8 buf[3];
 613         u8 xo2_type, xo2_id, xo2_demodtype;
 614         u8 sony_osc24 = 0;
 615         struct i2c_msg i2c_msg = { .flags = 0, .buf = buf };
 616         int rc;
 617
 618         if (port_has_xo2(i2c, &xo2_type, &xo2_id)) {
 619                 xo2_id >>= 2;
 620                 dev_dbg(pdev, "XO2 on channel %d (type %d, id %d)\n",
 621                         chan->number, xo2_type, xo2_id);
 622
 623                 switch (xo2_type) {
 624                 case NGENE_XO2_TYPE_DUOFLEX:
 625                         if (chan->number & 1)
 626                                 dev_dbg(pdev,
 627                                         "skipping XO2 init on odd channel %d",
 628                                         chan->number);
 629                         else
 630                                 init_xo2(chan, i2c);
 631
 632                         xo2_demodtype = DEMOD_TYPE_XO2 + xo2_id;
 633
 634                         switch (xo2_demodtype) {
 635                         case DEMOD_TYPE_SONY_CT2:
 636                         case DEMOD_TYPE_SONY_ISDBT:
 637                         case DEMOD_TYPE_SONY_C2T2:
 638                         case DEMOD_TYPE_SONY_C2T2I:
 639                                 dev_info(pdev, "%s (XO2) on channel %d\n",
 640                                          xo2names[xo2_id], chan->number);
 641                                 chan->demod_type = xo2_demodtype;
 642                                 if (xo2_demodtype == DEMOD_TYPE_SONY_C2T2I)
 643                                         sony_osc24 = 1;
 644
 645                                 demod_attach_cxd28xx(chan, i2c, sony_osc24);
 646                                 break;
 647                         case DEMOD_TYPE_STV0910:
 648                                 dev_info(pdev, "%s (XO2) on channel %d\n",
 649                                          xo2names[xo2_id], chan->number);
 650                                 chan->demod_type = xo2_demodtype;
 651                                 demod_attach_stv0910(chan, i2c);
 652                                 break;
 653                         default:
 654                                 dev_warn(pdev,
 655                                          "Unsupported XO2 module on channel %d\n",
 656                                          chan->number);
 657                                 return -ENODEV;
 658                         }
 659                         break;
 660                 case NGENE_XO2_TYPE_CI:
 661                         dev_info(pdev, "DuoFlex CI modules not supported\n");
 662                         return -ENODEV;
 663                 default:
 664                         dev_info(pdev, "Unsupported XO2 module type\n");
 665                         return -ENODEV;
 666                 }
 667         } else if (port_has_stv0900(i2c, chan->number)) {
 668                 chan->demod_type = DEMOD_TYPE_STV090X;
 669                 fe_conf = chan->dev->card_info->fe_config[chan->number];
 670                 /* demod found, attach it */
 671                 rc = demod_attach_stv0900(chan);
 672                 if (rc < 0 || chan->number < 2)
 673                         return rc;
 674
 675                 /* demod #2: reprogram outputs DPN1 & DPN2 */
 676                 i2c_msg.addr = fe_conf->address;
 677                 i2c_msg.len = 3;
 678                 buf[0] = 0xf1;
 679                 switch (chan->number) {
 680                 case 2:
 681                         buf[1] = 0x5c;
 682                         buf[2] = 0xc2;
 683                         break;
 684                 case 3:
 685                         buf[1] = 0x61;
 686                         buf[2] = 0xcc;
 687                         break;
 688                 default:
 689                         return -ENODEV;
 690                 }
 691                 rc = i2c_transfer(i2c, &i2c_msg, 1);
 692                 if (rc != 1) {
 693                         dev_err(pdev, "Could not setup DPNx\n");
 694                         return -EIO;
 695                 }
 696         } else if (port_has_drxk(i2c, chan->number^2)) {
 697                 chan->demod_type = DEMOD_TYPE_DRXK;
 698                 demod_attach_drxk(chan, i2c);
 699         } else if (port_has_stv0367(i2c)) {
 700                 chan->demod_type = DEMOD_TYPE_STV0367;
 701                 dev_info(pdev, "STV0367 on channel %d\n", chan->number);
 702                 demod_attach_stv0367(chan, i2c);
 703         } else {
 704                 dev_info(pdev, "No demod found on chan %d\n", chan->number);
 705                 return -ENODEV;
 706         }
 707         return 0;
 708 }
 709
 710
 711 static struct lgdt330x_config aver_m780 = {
 712         .demod_chip    = LGDT3303,
 713         .serial_mpeg   = 0x00, /* PARALLEL */
 714         .clock_polarity_flip = 1,
 715 };
 716
 717 static struct mt2131_config m780_tunerconfig = {
 718         0xc0 >> 1
 719 };
 720
 721 /* A single func to attach the demo and tuner, rather than
 722  * use two sep funcs like the current design mandates.
 723  */
 724 static int demod_attach_lg330x(struct ngene_channel *chan)
 725 {
 726         struct device *pdev = &chan->dev->pci_dev->dev;
 727
 728         chan->fe = dvb_attach(lgdt330x_attach, &aver_m780,
 729                               0xb2 >> 1, &chan->i2c_adapter);
 730         if (chan->fe == NULL) {
 731                 dev_err(pdev, "No LGDT330x found!\n");
 732                 return -ENODEV;
 733         }
 734
 735         dvb_attach(mt2131_attach, chan->fe, &chan->i2c_adapter,
 736                    &m780_tunerconfig, 0);
 737
 738         return (chan->fe) ? 0 : -ENODEV;
 739 }
 740
 741 static int demod_attach_drxd(struct ngene_channel *chan)
 742 {
 743         struct device *pdev = &chan->dev->pci_dev->dev;
 744         struct drxd_config *feconf;
 745
 746         feconf = chan->dev->card_info->fe_config[chan->number];
 747
 748         chan->fe = dvb_attach(drxd_attach, feconf, chan,
 749                         &chan->i2c_adapter, &chan->dev->pci_dev->dev);
 750         if (!chan->fe) {
 751                 dev_err(pdev, "No DRXD found!\n");
 752                 return -ENODEV;
 753         }
 754         return 0;
 755 }
 756
 757 static int tuner_attach_dtt7520x(struct ngene_channel *chan)
 758 {
 759         struct device *pdev = &chan->dev->pci_dev->dev;
 760         struct drxd_config *feconf;
 761
 762         feconf = chan->dev->card_info->fe_config[chan->number];
 763
 764         if (!dvb_attach(dvb_pll_attach, chan->fe, feconf->pll_address,
 765                         &chan->i2c_adapter,
 766                         feconf->pll_type)) {
 767                 dev_err(pdev, "No pll(%d) found!\n", feconf->pll_type);
 768                 return -ENODEV;
 769         }
 770         return 0;
 771 }
 772
 773 /****************************************************************************/
 774 /* EEPROM TAGS **************************************************************/
 775 /****************************************************************************/
 776
 777 #define MICNG_EE_START      0x0100
 778 #define MICNG_EE_END        0x0FF0
 779
 780 #define MICNG_EETAG_END0    0x0000
 781 #define MICNG_EETAG_END1    0xFFFF
 782
 783 /* 0x0001 - 0x000F reserved for housekeeping */
 784 /* 0xFFFF - 0xFFFE reserved for housekeeping */
 785
 786 /* Micronas assigned tags
 787    EEProm tags for hardware support */
 788
 789 #define MICNG_EETAG_DRXD1_OSCDEVIATION  0x1000  /* 2 Bytes data */
 790 #define MICNG_EETAG_DRXD2_OSCDEVIATION  0x1001  /* 2 Bytes data */
 791
 792 #define MICNG_EETAG_MT2060_1_1STIF      0x1100  /* 2 Bytes data */
 793 #define MICNG_EETAG_MT2060_2_1STIF      0x1101  /* 2 Bytes data */
 794
 795 /* Tag range for OEMs */
 796
 797 #define MICNG_EETAG_OEM_FIRST  0xC000
 798 #define MICNG_EETAG_OEM_LAST   0xFFEF
 799
 800 static int i2c_write_eeprom(struct i2c_adapter *adapter,
 801                             u8 adr, u16 reg, u8 data)
 802 {
 803         struct device *pdev = adapter->dev.parent;
 804         u8 m[3] = {(reg >> 8), (reg & 0xff), data};
 805         struct i2c_msg msg = {.addr = adr, .flags = 0, .buf = m,
 806                               .len = sizeof(m)};
 807
 808         if (i2c_transfer(adapter, &msg, 1) != 1) {
 809                 dev_err(pdev, "Error writing EEPROM!\n");
 810                 return -EIO;
 811         }
 812         return 0;
 813 }
 814
 815 static int i2c_read_eeprom(struct i2c_adapter *adapter,
 816                            u8 adr, u16 reg, u8 *data, int len)
 817 {
 818         struct device *pdev = adapter->dev.parent;
 819         u8 msg[2] = {(reg >> 8), (reg & 0xff)};
 820         struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
 821                                    .buf = msg, .len = 2 },
 822                                   {.addr = adr, .flags = I2C_M_RD,
 823                                    .buf = data, .len = len} };
 824
 825         if (i2c_transfer(adapter, msgs, 2) != 2) {
 826                 dev_err(pdev, "Error reading EEPROM\n");
 827                 return -EIO;
 828         }
 829         return 0;
 830 }
 831
 832 static int ReadEEProm(struct i2c_adapter *adapter,
 833                       u16 Tag, u32 MaxLen, u8 *data, u32 *pLength)
 834 {
 835         struct device *pdev = adapter->dev.parent;
 836         int status = 0;
 837         u16 Addr = MICNG_EE_START, Length, tag = 0;
 838         u8  EETag[3];
 839
 840         while (Addr + sizeof(u16) + 1 < MICNG_EE_END) {
 841                 if (i2c_read_eeprom(adapter, 0x50, Addr, EETag, sizeof(EETag)))
 842                         return -1;
 843                 tag = (EETag[0] << 8) | EETag[1];
 844                 if (tag == MICNG_EETAG_END0 || tag == MICNG_EETAG_END1)
 845                         return -1;
 846                 if (tag == Tag)
 847                         break;
 848                 Addr += sizeof(u16) + 1 + EETag[2];
 849         }
 850         if (Addr + sizeof(u16) + 1 + EETag[2] > MICNG_EE_END) {
 851                 dev_err(pdev, "Reached EOEE @ Tag = %04x Length = %3d\n",
 852                         tag, EETag[2]);
 853                 return -1;
 854         }
 855         Length = EETag[2];
 856         if (Length > MaxLen)
 857                 Length = (u16) MaxLen;
 858         if (Length > 0) {
 859                 Addr += sizeof(u16) + 1;
 860                 status = i2c_read_eeprom(adapter, 0x50, Addr, data, Length);
 861                 if (!status) {
 862                         *pLength = EETag[2];
 863 #if 0
 864                         if (Length < EETag[2])
 865                                 status = STATUS_BUFFER_OVERFLOW;
 866 #endif
 867                 }
 868         }
 869         return status;
 870 }
 871
 872 static int WriteEEProm(struct i2c_adapter *adapter,
 873                        u16 Tag, u32 Length, u8 *data)
 874 {
 875         struct device *pdev = adapter->dev.parent;
 876         int status = 0;
 877         u16 Addr = MICNG_EE_START;
 878         u8 EETag[3];
 879         u16 tag = 0;
 880         int retry, i;
 881
 882         while (Addr + sizeof(u16) + 1 < MICNG_EE_END) {
 883                 if (i2c_read_eeprom(adapter, 0x50, Addr, EETag, sizeof(EETag)))
 884                         return -1;
 885                 tag = (EETag[0] << 8) | EETag[1];
 886                 if (tag == MICNG_EETAG_END0 || tag == MICNG_EETAG_END1)
 887                         return -1;
 888                 if (tag == Tag)
 889                         break;
 890                 Addr += sizeof(u16) + 1 + EETag[2];
 891         }
 892         if (Addr + sizeof(u16) + 1 + EETag[2] > MICNG_EE_END) {
 893                 dev_err(pdev, "Reached EOEE @ Tag = %04x Length = %3d\n",
 894                         tag, EETag[2]);
 895                 return -1;
 896         }
 897
 898         if (Length > EETag[2])
 899                 return -EINVAL;
 900         /* Note: We write the data one byte at a time to avoid
 901            issues with page sizes. (which are different for
 902            each manufacture and eeprom size)
 903          */
 904         Addr += sizeof(u16) + 1;
 905         for (i = 0; i < Length; i++, Addr++) {
 906                 status = i2c_write_eeprom(adapter, 0x50, Addr, data[i]);
 907
 908                 if (status)
 909                         break;
 910
 911                 /* Poll for finishing write cycle */
 912                 retry = 10;
 913                 while (retry) {
 914                         u8 Tmp;
 915
 916                         msleep(50);
 917                         status = i2c_read_eeprom(adapter, 0x50, Addr, &Tmp, 1);
 918                         if (status)
 919                                 break;
 920                         if (Tmp != data[i])
 921                                 dev_err(pdev, "eeprom write error\n");
 922                         retry -= 1;
 923                 }
 924                 if (status) {
 925                         dev_err(pdev, "Timeout polling eeprom\n");
 926                         break;
 927                 }
 928         }
 929         return status;
 930 }
 931
 932 static int eeprom_read_ushort(struct i2c_adapter *adapter, u16 tag, u16 *data)
 933 {
 934         int stat;
 935         u8 buf[2];
 936         u32 len = 0;
 937
 938         stat = ReadEEProm(adapter, tag, 2, buf, &len);
 939         if (stat)
 940                 return stat;
 941         if (len != 2)
 942                 return -EINVAL;
 943
 944         *data = (buf[0] << 8) | buf[1];
 945         return 0;
 946 }
 947
 948 static int eeprom_write_ushort(struct i2c_adapter *adapter, u16 tag, u16 data)
 949 {
 950         int stat;
 951         u8 buf[2];
 952
 953         buf[0] = data >> 8;
 954         buf[1] = data & 0xff;
 955         stat = WriteEEProm(adapter, tag, 2, buf);
 956         if (stat)
 957                 return stat;
 958         return 0;
 959 }
 960
 961 static s16 osc_deviation(void *priv, s16 deviation, int flag)
 962 {
 963         struct ngene_channel *chan = priv;
 964         struct device *pdev = &chan->dev->pci_dev->dev;
 965         struct i2c_adapter *adap = &chan->i2c_adapter;
 966         u16 data = 0;
 967
 968         if (flag) {
 969                 data = (u16) deviation;
 970                 dev_info(pdev, "write deviation %d\n",
 971                          deviation);
 972                 eeprom_write_ushort(adap, 0x1000 + chan->number, data);
 973         } else {
 974                 if (eeprom_read_ushort(adap, 0x1000 + chan->number, &data))
 975                         data = 0;
 976                 dev_info(pdev, "read deviation %d\n",
 977                          (s16)data);
 978         }
 979
 980         return (s16) data;
 981 }
 982
 983 /****************************************************************************/
 984 /* Switch control (I2C gates, etc.) *****************************************/
 985 /****************************************************************************/
 986
 987
 988 static struct stv090x_config fe_cineS2 = {
 989         .device         = STV0900,
 990         .demod_mode     = STV090x_DUAL,
 991         .clk_mode       = STV090x_CLK_EXT,
 992
 993         .xtal           = 27000000,
 994         .address        = 0x68,
 995
 996         .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
 997         .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
 998
 999         .repeater_level = STV090x_RPTLEVEL_16,
1000
1001         .adc1_range     = STV090x_ADC_1Vpp,
1002         .adc2_range     = STV090x_ADC_1Vpp,
1003
1004         .diseqc_envelope_mode = true,
1005
1006         .tuner_i2c_lock = cineS2_tuner_i2c_lock,
1007 };
1008
1009 static struct stv090x_config fe_cineS2_2 = {
1010         .device         = STV0900,
1011         .demod_mode     = STV090x_DUAL,
1012         .clk_mode       = STV090x_CLK_EXT,
1013
1014         .xtal           = 27000000,
1015         .address        = 0x69,
1016
1017         .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1018         .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1019
1020         .repeater_level = STV090x_RPTLEVEL_16,
1021
1022         .adc1_range     = STV090x_ADC_1Vpp,
1023         .adc2_range     = STV090x_ADC_1Vpp,
1024
1025         .diseqc_envelope_mode = true,
1026
1027         .tuner_i2c_lock = cineS2_tuner_i2c_lock,
1028 };
1029
1030 static struct stv6110x_config tuner_cineS2_0 = {
1031         .addr   = 0x60,
1032         .refclk = 27000000,
1033         .clk_div = 1,
1034 };
1035
1036 static struct stv6110x_config tuner_cineS2_1 = {
1037         .addr   = 0x63,
1038         .refclk = 27000000,
1039         .clk_div = 1,
1040 };
1041
1042 static const struct ngene_info ngene_info_cineS2 = {
1043         .type           = NGENE_SIDEWINDER,
1044         .name           = "Linux4Media cineS2 DVB-S2 Twin Tuner",
1045         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN},
1046         .demod_attach   = {demod_attach_stv0900, demod_attach_stv0900},
1047         .tuner_attach   = {tuner_attach_stv6110, tuner_attach_stv6110},
1048         .fe_config      = {&fe_cineS2, &fe_cineS2},
1049         .tuner_config   = {&tuner_cineS2_0, &tuner_cineS2_1},
1050         .lnb            = {0x0b, 0x08},
1051         .tsf            = {3, 3},
1052         .fw_version     = 18,
1053         .msi_supported  = true,
1054 };
1055
1056 static const struct ngene_info ngene_info_satixS2 = {
1057         .type           = NGENE_SIDEWINDER,
1058         .name           = "Mystique SaTiX-S2 Dual",
1059         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN},
1060         .demod_attach   = {demod_attach_stv0900, demod_attach_stv0900},
1061         .tuner_attach   = {tuner_attach_stv6110, tuner_attach_stv6110},
1062         .fe_config      = {&fe_cineS2, &fe_cineS2},
1063         .tuner_config   = {&tuner_cineS2_0, &tuner_cineS2_1},
1064         .lnb            = {0x0b, 0x08},
1065         .tsf            = {3, 3},
1066         .fw_version     = 18,
1067         .msi_supported  = true,
1068 };
1069
1070 static const struct ngene_info ngene_info_satixS2v2 = {
1071         .type           = NGENE_SIDEWINDER,
1072         .name           = "Mystique SaTiX-S2 Dual (v2)",
1073         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN,
1074                            NGENE_IO_TSOUT},
1075         .demod_attach   = {demod_attach_stv0900, demod_attach_stv0900, cineS2_probe, cineS2_probe},
1076         .tuner_attach   = {tuner_attach_stv6110, tuner_attach_stv6110, tuner_attach_probe, tuner_attach_probe},
1077         .fe_config      = {&fe_cineS2, &fe_cineS2, &fe_cineS2_2, &fe_cineS2_2},
1078         .tuner_config   = {&tuner_cineS2_0, &tuner_cineS2_1, &tuner_cineS2_0, &tuner_cineS2_1},
1079         .lnb            = {0x0a, 0x08, 0x0b, 0x09},
1080         .tsf            = {3, 3},
1081         .fw_version     = 18,
1082         .msi_supported  = true,
1083 };
1084
1085 static const struct ngene_info ngene_info_cineS2v5 = {
1086         .type           = NGENE_SIDEWINDER,
1087         .name           = "Linux4Media cineS2 DVB-S2 Twin Tuner (v5)",
1088         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN,
1089                            NGENE_IO_TSOUT},
1090         .demod_attach   = {demod_attach_stv0900, demod_attach_stv0900, cineS2_probe, cineS2_probe},
1091         .tuner_attach   = {tuner_attach_stv6110, tuner_attach_stv6110, tuner_attach_probe, tuner_attach_probe},
1092         .fe_config      = {&fe_cineS2, &fe_cineS2, &fe_cineS2_2, &fe_cineS2_2},
1093         .tuner_config   = {&tuner_cineS2_0, &tuner_cineS2_1, &tuner_cineS2_0, &tuner_cineS2_1},
1094         .lnb            = {0x0a, 0x08, 0x0b, 0x09},
1095         .tsf            = {3, 3},
1096         .fw_version     = 18,
1097         .msi_supported  = true,
1098 };
1099
1100
1101 static const struct ngene_info ngene_info_duoFlex = {
1102         .type           = NGENE_SIDEWINDER,
1103         .name           = "Digital Devices DuoFlex PCIe or miniPCIe",
1104         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN, NGENE_IO_TSIN,
1105                            NGENE_IO_TSOUT},
1106         .demod_attach   = {cineS2_probe, cineS2_probe, cineS2_probe, cineS2_probe},
1107         .tuner_attach   = {tuner_attach_probe, tuner_attach_probe, tuner_attach_probe, tuner_attach_probe},
1108         .fe_config      = {&fe_cineS2, &fe_cineS2, &fe_cineS2_2, &fe_cineS2_2},
1109         .tuner_config   = {&tuner_cineS2_0, &tuner_cineS2_1, &tuner_cineS2_0, &tuner_cineS2_1},
1110         .lnb            = {0x0a, 0x08, 0x0b, 0x09},
1111         .tsf            = {3, 3},
1112         .fw_version     = 18,
1113         .msi_supported  = true,
1114 };
1115
1116 static const struct ngene_info ngene_info_m780 = {
1117         .type           = NGENE_APP,
1118         .name           = "Aver M780 ATSC/QAM-B",
1119
1120         /* Channel 0 is analog, which is currently unsupported */
1121         .io_type        = { NGENE_IO_NONE, NGENE_IO_TSIN },
1122         .demod_attach   = { NULL, demod_attach_lg330x },
1123
1124         /* Ensure these are NULL else the frame will call them (as funcs) */
1125         .tuner_attach   = { NULL, NULL, NULL, NULL },
1126         .fe_config      = { NULL, &aver_m780 },
1127         .avf            = { 0 },
1128
1129         /* A custom electrical interface config for the demod to bridge */
1130         .tsf            = { 4, 4 },
1131         .fw_version     = 15,
1132 };
1133
1134 static struct drxd_config fe_terratec_dvbt_0 = {
1135         .index          = 0,
1136         .demod_address  = 0x70,
1137         .demod_revision = 0xa2,
1138         .demoda_address = 0x00,
1139         .pll_address    = 0x60,
1140         .pll_type       = DVB_PLL_THOMSON_DTT7520X,
1141         .clock          = 20000,
1142         .osc_deviation  = osc_deviation,
1143 };
1144
1145 static struct drxd_config fe_terratec_dvbt_1 = {
1146         .index          = 1,
1147         .demod_address  = 0x71,
1148         .demod_revision = 0xa2,
1149         .demoda_address = 0x00,
1150         .pll_address    = 0x60,
1151         .pll_type       = DVB_PLL_THOMSON_DTT7520X,
1152         .clock          = 20000,
1153         .osc_deviation  = osc_deviation,
1154 };
1155
1156 static const struct ngene_info ngene_info_terratec = {
1157         .type           = NGENE_TERRATEC,
1158         .name           = "Terratec Integra/Cinergy2400i Dual DVB-T",
1159         .io_type        = {NGENE_IO_TSIN, NGENE_IO_TSIN},
1160         .demod_attach   = {demod_attach_drxd, demod_attach_drxd},
1161         .tuner_attach   = {tuner_attach_dtt7520x, tuner_attach_dtt7520x},
1162         .fe_config      = {&fe_terratec_dvbt_0, &fe_terratec_dvbt_1},
1163         .i2c_access     = 1,
1164 };
1165
1166 /****************************************************************************/
1167
1168
1169
1170 /****************************************************************************/
1171 /* PCI Subsystem ID *********************************************************/
1172 /****************************************************************************/
1173
1174 #define NGENE_ID(_subvend, _subdev, _driverdata) { \
1175         .vendor = NGENE_VID, .device = NGENE_PID, \
1176         .subvendor = _subvend, .subdevice = _subdev, \
1177         .driver_data = (unsigned long) &_driverdata }
1178
1179 /****************************************************************************/
1180
1181 static const struct pci_device_id ngene_id_tbl[] = {
1182         NGENE_ID(0x18c3, 0xab04, ngene_info_cineS2),
1183         NGENE_ID(0x18c3, 0xab05, ngene_info_cineS2v5),
1184         NGENE_ID(0x18c3, 0xabc3, ngene_info_cineS2),
1185         NGENE_ID(0x18c3, 0xabc4, ngene_info_cineS2),
1186         NGENE_ID(0x18c3, 0xdb01, ngene_info_satixS2),
1187         NGENE_ID(0x18c3, 0xdb02, ngene_info_satixS2v2),
1188         NGENE_ID(0x18c3, 0xdd00, ngene_info_cineS2v5),
1189         NGENE_ID(0x18c3, 0xdd10, ngene_info_duoFlex),
1190         NGENE_ID(0x18c3, 0xdd20, ngene_info_duoFlex),
1191         NGENE_ID(0x1461, 0x062e, ngene_info_m780),
1192         NGENE_ID(0x153b, 0x1167, ngene_info_terratec),
1193         {0}
1194 };
1195 MODULE_DEVICE_TABLE(pci, ngene_id_tbl);
1196
1197 /****************************************************************************/
1198 /* Init/Exit ****************************************************************/
1199 /****************************************************************************/
1200
1201 static pci_ers_result_t ngene_error_detected(struct pci_dev *dev,
1202                                              enum pci_channel_state state)
1203 {
1204         dev_err(&dev->dev, "PCI error\n");
1205         if (state == pci_channel_io_perm_failure)
1206                 return PCI_ERS_RESULT_DISCONNECT;
1207         if (state == pci_channel_io_frozen)
1208                 return PCI_ERS_RESULT_NEED_RESET;
1209         return PCI_ERS_RESULT_CAN_RECOVER;
1210 }
1211
1212 static pci_ers_result_t ngene_slot_reset(struct pci_dev *dev)
1213 {
1214         dev_info(&dev->dev, "slot reset\n");
1215         return 0;
1216 }
1217
1218 static void ngene_resume(struct pci_dev *dev)
1219 {
1220         dev_info(&dev->dev, "resume\n");
1221 }
1222
1223 static const struct pci_error_handlers ngene_errors = {
1224         .error_detected = ngene_error_detected,
1225         .slot_reset = ngene_slot_reset,
1226         .resume = ngene_resume,
1227 };
1228
1229 static struct pci_driver ngene_pci_driver = {
1230         .name        = "ngene",
1231         .id_table    = ngene_id_tbl,
1232         .probe       = ngene_probe,
1233         .remove      = ngene_remove,
1234         .err_handler = &ngene_errors,
1235         .shutdown    = ngene_shutdown,
1236 };
1237
1238 static __init int module_init_ngene(void)
1239 {
1240         /* pr_*() since we don't have a device to use with dev_*() yet */
1241         pr_info("nGene PCIE bridge driver, Copyright (C) 2005-2007 Micronas\n");
1242
1243         return pci_register_driver(&ngene_pci_driver);
1244 }
1245
1246 static __exit void module_exit_ngene(void)
1247 {
1248         pci_unregister_driver(&ngene_pci_driver);
1249 }
1250
1251 module_init(module_init_ngene);
1252 module_exit(module_exit_ngene);
1253
1254 MODULE_DESCRIPTION("nGene");
1255 MODULE_AUTHOR("Micronas, Ralph Metzler, Manfred Voelkel");
1256 MODULE_LICENSE("GPL");