drivers/media/dvb/dvb-usb/anysee.c

   1 /*
   2  * DVB USB Linux driver for Anysee E30 DVB-C & DVB-T USB2.0 receiver
   3  *
   4  * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  * TODO:
  21  * - add smart card reader support for Conditional Access (CA)
  22  *
  23  * Card reader in Anysee is nothing more than ISO 7816 card reader.
  24  * There is no hardware CAM in any Anysee device sold.
  25  * In my understanding it should be implemented by making own module
  26  * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
  27  * module registers serial interface that can be used to communicate
  28  * with any ISO 7816 smart card.
  29  *
  30  * Any help according to implement serial smart card reader support
  31  * is highly welcome!
  32  */
  33
  34 #include "anysee.h"
  35 #include "tda1002x.h"
  36 #include "mt352.h"
  37 #include "mt352_priv.h"
  38 #include "zl10353.h"
  39 #include "tda18212.h"
  40 #include "cx24116.h"
  41 #include "stv0900.h"
  42 #include "stv6110.h"
  43 #include "isl6423.h"
  44
  45 /* debug */
  46 static int dvb_usb_anysee_debug;
  47 module_param_named(debug, dvb_usb_anysee_debug, int, 0644);
  48 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
  49 static int dvb_usb_anysee_delsys;
  50 module_param_named(delsys, dvb_usb_anysee_delsys, int, 0644);
  51 MODULE_PARM_DESC(delsys, "select delivery mode (0=DVB-C, 1=DVB-T)");
  52 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  53
  54 static DEFINE_MUTEX(anysee_usb_mutex);
  55
  56 static int anysee_ctrl_msg(struct dvb_usb_device *d, u8 *sbuf, u8 slen,
  57         u8 *rbuf, u8 rlen)
  58 {
  59         struct anysee_state *state = d->priv;
  60         int act_len, ret;
  61         u8 buf[64];
  62
  63         memcpy(&buf[0], sbuf, slen);
  64         buf[60] = state->seq++;
  65
  66         if (mutex_lock_interruptible(&anysee_usb_mutex) < 0)
  67                 return -EAGAIN;
  68
  69         /* We need receive one message more after dvb_usb_generic_rw due
  70            to weird transaction flow, which is 1 x send + 2 x receive. */
  71         ret = dvb_usb_generic_rw(d, buf, sizeof(buf), buf, sizeof(buf), 0);
  72
  73         if (!ret) {
  74                 /* receive 2nd answer */
  75                 ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev,
  76                         d->props.generic_bulk_ctrl_endpoint), buf, sizeof(buf),
  77                         &act_len, 2000);
  78                 if (ret)
  79                         err("%s: recv bulk message failed: %d", __func__, ret);
  80                 else {
  81                         deb_xfer("<<< ");
  82                         debug_dump(buf, act_len, deb_xfer);
  83                 }
  84         }
  85
  86         /* read request, copy returned data to return buf */
  87         if (!ret && rbuf && rlen)
  88                 memcpy(rbuf, buf, rlen);
  89
  90         mutex_unlock(&anysee_usb_mutex);
  91
  92         return ret;
  93 }
  94
  95 static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
  96 {
  97         u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
  98         int ret;
  99         ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
 100         deb_info("%s: reg:%04x val:%02x\n", __func__, reg, *val);
 101         return ret;
 102 }
 103
 104 static int anysee_write_reg(struct dvb_usb_device *d, u16 reg, u8 val)
 105 {
 106         u8 buf[] = {CMD_REG_WRITE, reg >> 8, reg & 0xff, 0x01, val};
 107         deb_info("%s: reg:%04x val:%02x\n", __func__, reg, val);
 108         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
 109 }
 110
 111 /* write single register with mask */
 112 static int anysee_wr_reg_mask(struct dvb_usb_device *d, u16 reg, u8 val,
 113         u8 mask)
 114 {
 115         int ret;
 116         u8 tmp;
 117
 118         /* no need for read if whole reg is written */
 119         if (mask != 0xff) {
 120                 ret = anysee_read_reg(d, reg, &tmp);
 121                 if (ret)
 122                         return ret;
 123
 124                 val &= mask;
 125                 tmp &= ~mask;
 126                 val |= tmp;
 127         }
 128
 129         return anysee_write_reg(d, reg, val);
 130 }
 131
 132 static int anysee_get_hw_info(struct dvb_usb_device *d, u8 *id)
 133 {
 134         u8 buf[] = {CMD_GET_HW_INFO};
 135         return anysee_ctrl_msg(d, buf, sizeof(buf), id, 3);
 136 }
 137
 138 static int anysee_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 139 {
 140         u8 buf[] = {CMD_STREAMING_CTRL, (u8)onoff, 0x00};
 141         deb_info("%s: onoff:%02x\n", __func__, onoff);
 142         return anysee_ctrl_msg(adap->dev, buf, sizeof(buf), NULL, 0);
 143 }
 144
 145 static int anysee_led_ctrl(struct dvb_usb_device *d, u8 mode, u8 interval)
 146 {
 147         u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x01, mode, interval};
 148         deb_info("%s: state:%02x interval:%02x\n", __func__, mode, interval);
 149         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
 150 }
 151
 152 static int anysee_ir_ctrl(struct dvb_usb_device *d, u8 onoff)
 153 {
 154         u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x02, onoff};
 155         deb_info("%s: onoff:%02x\n", __func__, onoff);
 156         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
 157 }
 158
 159 static int anysee_init(struct dvb_usb_device *d)
 160 {
 161         int ret;
 162         /* LED light */
 163         ret = anysee_led_ctrl(d, 0x01, 0x03);
 164         if (ret)
 165                 return ret;
 166
 167         /* enable IR */
 168         ret = anysee_ir_ctrl(d, 1);
 169         if (ret)
 170                 return ret;
 171
 172         return 0;
 173 }
 174
 175 /* I2C */
 176 static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
 177         int num)
 178 {
 179         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 180         int ret = 0, inc, i = 0;
 181         u8 buf[52]; /* 4 + 48 (I2C WR USB command header + I2C WR max) */
 182
 183         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 184                 return -EAGAIN;
 185
 186         while (i < num) {
 187                 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
 188                         if (msg[i].len > 2 || msg[i+1].len > 60) {
 189                                 ret = -EOPNOTSUPP;
 190                                 break;
 191                         }
 192                         buf[0] = CMD_I2C_READ;
 193                         buf[1] = (msg[i].addr << 1) | 0x01;
 194                         buf[2] = msg[i].buf[0];
 195                         buf[3] = msg[i].buf[1];
 196                         buf[4] = msg[i].len-1;
 197                         buf[5] = msg[i+1].len;
 198                         ret = anysee_ctrl_msg(d, buf, 6, msg[i+1].buf,
 199                                 msg[i+1].len);
 200                         inc = 2;
 201                 } else {
 202                         if (msg[i].len > 48) {
 203                                 ret = -EOPNOTSUPP;
 204                                 break;
 205                         }
 206                         buf[0] = CMD_I2C_WRITE;
 207                         buf[1] = (msg[i].addr << 1);
 208                         buf[2] = msg[i].len;
 209                         buf[3] = 0x01;
 210                         memcpy(&buf[4], msg[i].buf, msg[i].len);
 211                         ret = anysee_ctrl_msg(d, buf, 4 + msg[i].len, NULL, 0);
 212                         inc = 1;
 213                 }
 214                 if (ret)
 215                         break;
 216
 217                 i += inc;
 218         }
 219
 220         mutex_unlock(&d->i2c_mutex);
 221
 222         return ret ? ret : i;
 223 }
 224
 225 static u32 anysee_i2c_func(struct i2c_adapter *adapter)
 226 {
 227         return I2C_FUNC_I2C;
 228 }
 229
 230 static struct i2c_algorithm anysee_i2c_algo = {
 231         .master_xfer   = anysee_master_xfer,
 232         .functionality = anysee_i2c_func,
 233 };
 234
 235 static int anysee_mt352_demod_init(struct dvb_frontend *fe)
 236 {
 237         static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x28 };
 238         static u8 reset[]          = { RESET,      0x80 };
 239         static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
 240         static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0x20 };
 241         static u8 gpp_ctl_cfg[]    = { GPP_CTL,    0x33 };
 242         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 243
 244         mt352_write(fe, clock_config,   sizeof(clock_config));
 245         udelay(200);
 246         mt352_write(fe, reset,          sizeof(reset));
 247         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
 248
 249         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
 250         mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
 251         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
 252
 253         return 0;
 254 }
 255
 256 /* Callbacks for DVB USB */
 257 static struct tda10023_config anysee_tda10023_config = {
 258         .demod_address = (0x1a >> 1),
 259         .invert = 0,
 260         .xtal   = 16000000,
 261         .pll_m  = 11,
 262         .pll_p  = 3,
 263         .pll_n  = 1,
 264         .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
 265         .deltaf = 0xfeeb,
 266 };
 267
 268 static struct mt352_config anysee_mt352_config = {
 269         .demod_address = (0x1e >> 1),
 270         .demod_init    = anysee_mt352_demod_init,
 271 };
 272
 273 static struct zl10353_config anysee_zl10353_config = {
 274         .demod_address = (0x1e >> 1),
 275         .parallel_ts = 1,
 276 };
 277
 278 static struct zl10353_config anysee_zl10353_tda18212_config2 = {
 279         .demod_address = (0x1e >> 1),
 280         .parallel_ts = 1,
 281         .disable_i2c_gate_ctrl = 1,
 282         .no_tuner = 1,
 283         .if2 = 41500,
 284 };
 285
 286 static struct zl10353_config anysee_zl10353_tda18212_config = {
 287         .demod_address = (0x18 >> 1),
 288         .parallel_ts = 1,
 289         .disable_i2c_gate_ctrl = 1,
 290         .no_tuner = 1,
 291         .if2 = 41500,
 292 };
 293
 294 static struct tda10023_config anysee_tda10023_tda18212_config = {
 295         .demod_address = (0x1a >> 1),
 296         .xtal   = 16000000,
 297         .pll_m  = 12,
 298         .pll_p  = 3,
 299         .pll_n  = 1,
 300         .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
 301         .deltaf = 0xba02,
 302 };
 303
 304 static struct tda18212_config anysee_tda18212_config = {
 305         .i2c_address = (0xc0 >> 1),
 306         .if_dvbt_6 = 4150,
 307         .if_dvbt_7 = 4150,
 308         .if_dvbt_8 = 4150,
 309         .if_dvbc = 5000,
 310 };
 311
 312 static struct cx24116_config anysee_cx24116_config = {
 313         .demod_address = (0xaa >> 1),
 314         .mpg_clk_pos_pol = 0x00,
 315         .i2c_wr_max = 48,
 316 };
 317
 318 static struct stv0900_config anysee_stv0900_config = {
 319         .demod_address = (0xd0 >> 1),
 320         .demod_mode = 0,
 321         .xtal = 8000000,
 322         .clkmode = 3,
 323         .diseqc_mode = 2,
 324         .tun1_maddress = 0,
 325         .tun1_adc = 1, /* 1 Vpp */
 326         .path1_mode = 3,
 327 };
 328
 329 static struct stv6110_config anysee_stv6110_config = {
 330         .i2c_address = (0xc0 >> 1),
 331         .mclk = 16000000,
 332         .clk_div = 1,
 333 };
 334
 335 static struct isl6423_config anysee_isl6423_config = {
 336         .current_max = SEC_CURRENT_800m,
 337         .curlim  = SEC_CURRENT_LIM_OFF,
 338         .mod_extern = 1,
 339         .addr = (0x10 >> 1),
 340 };
 341
 342 /*
 343  * New USB device strings: Mfr=1, Product=2, SerialNumber=0
 344  * Manufacturer: AMT.CO.KR
 345  *
 346  * E30 VID=04b4 PID=861f HW=2 FW=2.1 Product=????????
 347  * PCB: ?
 348  * parts: DNOS404ZH102A(MT352, DTT7579(?))
 349  *
 350  * E30 VID=04b4 PID=861f HW=2 FW=2.1 Product=????????
 351  * PCB: ?
 352  * parts: DNOS404ZH103A(ZL10353, DTT7579(?))
 353  *
 354  * E30 Plus VID=04b4 PID=861f HW=6 FW=1.0 "anysee"
 355  * PCB: 507CD (rev1.1)
 356  * parts: DNOS404ZH103A(ZL10353, DTT7579(?)), CST56I01
 357  * OEA=80 OEB=00 OEC=00 OED=ff OEF=fe
 358  * IOA=4f IOB=ff IOC=00 IOD=06 IOF=01
 359  * IOD[0] ZL10353 1=enabled
 360  * IOA[7] TS 0=enabled
 361  * tuner is not behind ZL10353 I2C-gate (no care if gate disabled or not)
 362  *
 363  * E30 C Plus VID=04b4 PID=861f HW=10 FW=1.0 "anysee-DC(LP)"
 364  * PCB: 507DC (rev0.2)
 365  * parts: TDA10023, DTOS403IH102B TM, CST56I01
 366  * OEA=80 OEB=00 OEC=00 OED=ff OEF=fe
 367  * IOA=4f IOB=ff IOC=00 IOD=26 IOF=01
 368  * IOD[0] TDA10023 1=enabled
 369  *
 370  * E30 S2 Plus VID=04b4 PID=861f HW=11 FW=0.1 "anysee-S2(LP)"
 371  * PCB: 507SI (rev2.1)
 372  * parts: BS2N10WCC01(CX24116, CX24118), ISL6423, TDA8024
 373  * OEA=80 OEB=00 OEC=ff OED=ff OEF=fe
 374  * IOA=4d IOB=ff IOC=00 IOD=26 IOF=01
 375  * IOD[0] CX24116 1=enabled
 376  *
 377  * E30 C Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
 378  * PCB: 507FA (rev0.4)
 379  * parts: TDA10023, DTOS403IH102B TM, TDA8024
 380  * OEA=80 OEB=00 OEC=ff OED=ff OEF=ff
 381  * IOA=4d IOB=ff IOC=00 IOD=00 IOF=c0
 382  * IOD[5] TDA10023 1=enabled
 383  * IOE[0] tuner 1=enabled
 384  *
 385  * E30 Combo Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
 386  * PCB: 507FA (rev1.1)
 387  * parts: ZL10353, TDA10023, DTOS403IH102B TM, TDA8024
 388  * OEA=80 OEB=00 OEC=ff OED=ff OEF=ff
 389  * IOA=4d IOB=ff IOC=00 IOD=00 IOF=c0
 390  * DVB-C:
 391  * IOD[5] TDA10023 1=enabled
 392  * IOE[0] tuner 1=enabled
 393  * DVB-T:
 394  * IOD[0] ZL10353 1=enabled
 395  * IOE[0] tuner 0=enabled
 396  * tuner is behind ZL10353 I2C-gate
 397  *
 398  * E7 TC VID=1c73 PID=861f HW=18 FW=0.7 AMTCI=0.5 "anysee-E7TC(LP)"
 399  * PCB: 508TC (rev0.6)
 400  * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
 401  * OEA=80 OEB=00 OEC=03 OED=f7 OEF=ff
 402  * IOA=4d IOB=00 IOC=cc IOD=48 IOF=e4
 403  * IOA[7] TS 1=enabled
 404  * IOE[4] TDA18212 1=enabled
 405  * DVB-C:
 406  * IOD[6] ZL10353 0=disabled
 407  * IOD[5] TDA10023 1=enabled
 408  * IOE[0] IF 1=enabled
 409  * DVB-T:
 410  * IOD[5] TDA10023 0=disabled
 411  * IOD[6] ZL10353 1=enabled
 412  * IOE[0] IF 0=enabled
 413  *
 414  * E7 S2 VID=1c73 PID=861f HW=19 FW=0.4 AMTCI=0.5 "anysee-E7S2(LP)"
 415  * PCB: 508S2 (rev0.7)
 416  * parts: DNBU10512IST(STV0903, STV6110), ISL6423
 417  * OEA=80 OEB=00 OEC=03 OED=f7 OEF=ff
 418  * IOA=4d IOB=00 IOC=c4 IOD=08 IOF=e4
 419  * IOA[7] TS 1=enabled
 420  * IOE[5] STV0903 1=enabled
 421  *
 422  */
 423
 424 static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
 425 {
 426         int ret;
 427         struct anysee_state *state = adap->dev->priv;
 428         u8 hw_info[3];
 429         u8 tmp;
 430         struct i2c_msg msg[2] = {
 431                 {
 432                         .addr = anysee_tda18212_config.i2c_address,
 433                         .flags = 0,
 434                         .len = 1,
 435                         .buf = "\x00",
 436                 }, {
 437                         .addr = anysee_tda18212_config.i2c_address,
 438                         .flags = I2C_M_RD,
 439                         .len = 1,
 440                         .buf = &tmp,
 441                 }
 442         };
 443
 444         /* Check which hardware we have.
 445          * We must do this call two times to get reliable values (hw bug).
 446          */
 447         ret = anysee_get_hw_info(adap->dev, hw_info);
 448         if (ret)
 449                 goto error;
 450
 451         ret = anysee_get_hw_info(adap->dev, hw_info);
 452         if (ret)
 453                 goto error;
 454
 455         /* Meaning of these info bytes are guessed. */
 456         info("firmware version:%d.%d hardware id:%d",
 457                 hw_info[1], hw_info[2], hw_info[0]);
 458
 459         state->hw = hw_info[0];
 460
 461         switch (state->hw) {
 462         case ANYSEE_HW_02: /* 2 */
 463                 /* E30 */
 464
 465                 /* attach demod */
 466                 adap->fe = dvb_attach(mt352_attach, &anysee_mt352_config,
 467                         &adap->dev->i2c_adap);
 468                 if (adap->fe)
 469                         break;
 470
 471                 /* attach demod */
 472                 adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
 473                         &adap->dev->i2c_adap);
 474
 475                 break;
 476         case ANYSEE_HW_507CD: /* 6 */
 477                 /* E30 Plus */
 478
 479                 /* enable DVB-T demod on IOD[0] */
 480                 ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
 481                 if (ret)
 482                         goto error;
 483
 484                 /* enable transport stream on IOA[7] */
 485                 ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (0 << 7), 0x80);
 486                 if (ret)
 487                         goto error;
 488
 489                 /* attach demod */
 490                 adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
 491                         &adap->dev->i2c_adap);
 492
 493                 break;
 494         case ANYSEE_HW_507DC: /* 10 */
 495                 /* E30 C Plus */
 496
 497                 /* enable DVB-C demod on IOD[0] */
 498                 ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
 499                 if (ret)
 500                         goto error;
 501
 502                 /* attach demod */
 503                 adap->fe = dvb_attach(tda10023_attach, &anysee_tda10023_config,
 504                         &adap->dev->i2c_adap, 0x48);
 505
 506                 break;
 507         case ANYSEE_HW_507SI: /* 11 */
 508                 /* E30 S2 Plus */
 509
 510                 /* enable DVB-S/S2 demod on IOD[0] */
 511                 ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
 512                 if (ret)
 513                         goto error;
 514
 515                 /* attach demod */
 516                 adap->fe = dvb_attach(cx24116_attach, &anysee_cx24116_config,
 517                         &adap->dev->i2c_adap);
 518
 519                 break;
 520         case ANYSEE_HW_507FA: /* 15 */
 521                 /* E30 Combo Plus */
 522                 /* E30 C Plus */
 523
 524                 /* enable tuner on IOE[4] */
 525                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
 526                 if (ret)
 527                         goto error;
 528
 529                 /* probe TDA18212 */
 530                 tmp = 0;
 531                 ret = i2c_transfer(&adap->dev->i2c_adap, msg, 2);
 532                 if (ret == 2 && tmp == 0xc7)
 533                         deb_info("%s: TDA18212 found\n", __func__);
 534                 else
 535                         tmp = 0;
 536
 537                 /* disable tuner on IOE[4] */
 538                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 4), 0x10);
 539                 if (ret)
 540                         goto error;
 541
 542                 if (dvb_usb_anysee_delsys) {
 543                         /* disable DVB-C demod on IOD[5] */
 544                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 5),
 545                                 0x20);
 546                         if (ret)
 547                                 goto error;
 548
 549                         /* enable DVB-T demod on IOD[0] */
 550                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0),
 551                                 0x01);
 552                         if (ret)
 553                                 goto error;
 554
 555                         /* attach demod */
 556                         if (tmp == 0xc7) {
 557                                 /* TDA18212 config */
 558                                 adap->fe = dvb_attach(zl10353_attach,
 559                                         &anysee_zl10353_tda18212_config2,
 560                                         &adap->dev->i2c_adap);
 561                         } else {
 562                                 /* PLL config */
 563                                 adap->fe = dvb_attach(zl10353_attach,
 564                                         &anysee_zl10353_config,
 565                                         &adap->dev->i2c_adap);
 566                         }
 567                 } else {
 568                         /* disable DVB-T demod on IOD[0] */
 569                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 0),
 570                                 0x01);
 571                         if (ret)
 572                                 goto error;
 573
 574                         /* enable DVB-C demod on IOD[5] */
 575                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 5),
 576                                 0x20);
 577                         if (ret)
 578                                 goto error;
 579
 580                         /* attach demod */
 581                         if (tmp == 0xc7) {
 582                                 /* TDA18212 config */
 583                                 adap->fe = dvb_attach(tda10023_attach,
 584                                         &anysee_tda10023_tda18212_config,
 585                                         &adap->dev->i2c_adap, 0x48);
 586                         } else {
 587                                 /* PLL config */
 588                                 adap->fe = dvb_attach(tda10023_attach,
 589                                         &anysee_tda10023_config,
 590                                         &adap->dev->i2c_adap, 0x48);
 591                         }
 592                 }
 593
 594                 break;
 595         case ANYSEE_HW_508TC: /* 18 */
 596                 /* E7 TC */
 597
 598                 /* enable transport stream on IOA[7] */
 599                 ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (1 << 7), 0x80);
 600                 if (ret)
 601                         goto error;
 602
 603                 if (dvb_usb_anysee_delsys) {
 604                         /* disable DVB-C demod on IOD[5] */
 605                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 5),
 606                                 0x20);
 607                         if (ret)
 608                                 goto error;
 609
 610                         /* enable DVB-T demod on IOD[6] */
 611                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 6),
 612                                 0x40);
 613                         if (ret)
 614                                 goto error;
 615
 616                         /* enable IF route on IOE[0] */
 617                         ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 0),
 618                                 0x01);
 619                         if (ret)
 620                                 goto error;
 621
 622                         /* attach demod */
 623                         adap->fe = dvb_attach(zl10353_attach,
 624                                 &anysee_zl10353_tda18212_config,
 625                                 &adap->dev->i2c_adap);
 626                 } else {
 627                         /* disable DVB-T demod on IOD[6] */
 628                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 6),
 629                                 0x40);
 630                         if (ret)
 631                                 goto error;
 632
 633                         /* enable DVB-C demod on IOD[5] */
 634                         ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 5),
 635                                 0x20);
 636                         if (ret)
 637                                 goto error;
 638
 639                         /* enable IF route on IOE[0] */
 640                         ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 0),
 641                                 0x01);
 642                         if (ret)
 643                                 goto error;
 644
 645                         /* attach demod */
 646                         adap->fe = dvb_attach(tda10023_attach,
 647                                 &anysee_tda10023_tda18212_config,
 648                                 &adap->dev->i2c_adap, 0x48);
 649                 }
 650
 651                 break;
 652         case ANYSEE_HW_508S2: /* 19 */
 653                 /* E7 S2 */
 654
 655                 /* enable transport stream on IOA[7] */
 656                 ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (1 << 7), 0x80);
 657                 if (ret)
 658                         goto error;
 659
 660                 /* enable DVB-S/S2 demod on IOE[5] */
 661                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 5), 0x20);
 662                 if (ret)
 663                         goto error;
 664
 665                 /* attach demod */
 666                 adap->fe = dvb_attach(stv0900_attach, &anysee_stv0900_config,
 667                         &adap->dev->i2c_adap, 0);
 668
 669                 break;
 670         }
 671
 672         if (!adap->fe) {
 673                 /* we have no frontend :-( */
 674                 ret = -ENODEV;
 675                 err("Unsupported Anysee version. " \
 676                         "Please report the <linux-media@vger.kernel.org>.");
 677         }
 678 error:
 679         return ret;
 680 }
 681
 682 static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
 683 {
 684         struct anysee_state *state = adap->dev->priv;
 685         struct dvb_frontend *fe;
 686         int ret;
 687         deb_info("%s:\n", __func__);
 688
 689         switch (state->hw) {
 690         case ANYSEE_HW_02: /* 2 */
 691                 /* E30 */
 692
 693                 /* attach tuner */
 694                 fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc2 >> 1),
 695                         NULL, DVB_PLL_THOMSON_DTT7579);
 696
 697                 break;
 698         case ANYSEE_HW_507CD: /* 6 */
 699                 /* E30 Plus */
 700
 701                 /* attach tuner */
 702                 fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc2 >> 1),
 703                         &adap->dev->i2c_adap, DVB_PLL_THOMSON_DTT7579);
 704
 705                 break;
 706         case ANYSEE_HW_507DC: /* 10 */
 707                 /* E30 C Plus */
 708
 709                 /* attach tuner */
 710                 fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc0 >> 1),
 711                         &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
 712
 713                 break;
 714         case ANYSEE_HW_507SI: /* 11 */
 715                 /* E30 S2 Plus */
 716
 717                 /* attach LNB controller */
 718                 fe = dvb_attach(isl6423_attach, adap->fe, &adap->dev->i2c_adap,
 719                         &anysee_isl6423_config);
 720
 721                 break;
 722         case ANYSEE_HW_507FA: /* 15 */
 723                 /* E30 Combo Plus */
 724                 /* E30 C Plus */
 725
 726                 if (dvb_usb_anysee_delsys) {
 727                         /* enable DVB-T tuner on IOE[0] */
 728                         ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 0),
 729                                 0x01);
 730                         if (ret)
 731                                 goto error;
 732                 } else {
 733                         /* enable DVB-C tuner on IOE[0] */
 734                         ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 0),
 735                                 0x01);
 736                         if (ret)
 737                                 goto error;
 738                 }
 739
 740                 /* Try first attach TDA18212 silicon tuner on IOE[4], if that
 741                  * fails attach old simple PLL. */
 742
 743                 /* enable tuner on IOE[4] */
 744                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
 745                 if (ret)
 746                         goto error;
 747
 748                 /* attach tuner */
 749                 fe = dvb_attach(tda18212_attach, adap->fe, &adap->dev->i2c_adap,
 750                         &anysee_tda18212_config);
 751                 if (fe)
 752                         break;
 753
 754                 /* disable tuner on IOE[4] */
 755                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 4), 0x10);
 756                 if (ret)
 757                         goto error;
 758
 759                 /* attach tuner */
 760                 fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc0 >> 1),
 761                         &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
 762
 763                 break;
 764         case ANYSEE_HW_508TC: /* 18 */
 765                 /* E7 TC */
 766
 767                 /* enable tuner on IOE[4] */
 768                 ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
 769                 if (ret)
 770                         goto error;
 771
 772                 /* attach tuner */
 773                 fe = dvb_attach(tda18212_attach, adap->fe, &adap->dev->i2c_adap,
 774                         &anysee_tda18212_config);
 775
 776                 break;
 777         case ANYSEE_HW_508S2: /* 19 */
 778                 /* E7 S2 */
 779
 780                 /* attach tuner */
 781                 fe = dvb_attach(stv6110_attach, adap->fe,
 782                         &anysee_stv6110_config, &adap->dev->i2c_adap);
 783
 784                 if (fe) {
 785                         /* attach LNB controller */
 786                         fe = dvb_attach(isl6423_attach, adap->fe,
 787                                 &adap->dev->i2c_adap, &anysee_isl6423_config);
 788                 }
 789
 790                 break;
 791         default:
 792                 fe = NULL;
 793         }
 794
 795         if (fe)
 796                 ret = 0;
 797         else
 798                 ret = -ENODEV;
 799
 800 error:
 801         return ret;
 802 }
 803
 804 static int anysee_rc_query(struct dvb_usb_device *d)
 805 {
 806         u8 buf[] = {CMD_GET_IR_CODE};
 807         u8 ircode[2];
 808         int ret;
 809
 810         /* Remote controller is basic NEC using address byte 0x08.
 811            Anysee device RC query returns only two bytes, status and code,
 812            address byte is dropped. Also it does not return any value for
 813            NEC RCs having address byte other than 0x08. Due to that, we
 814            cannot use that device as standard NEC receiver.
 815            It could be possible make hack which reads whole code directly
 816            from device memory... */
 817
 818         ret = anysee_ctrl_msg(d, buf, sizeof(buf), ircode, sizeof(ircode));
 819         if (ret)
 820                 return ret;
 821
 822         if (ircode[0]) {
 823                 deb_rc("%s: key pressed %02x\n", __func__, ircode[1]);
 824                 rc_keydown(d->rc_dev, 0x08 << 8 | ircode[1], 0);
 825         }
 826
 827         return 0;
 828 }
 829
 830 /* DVB USB Driver stuff */
 831 static struct dvb_usb_device_properties anysee_properties;
 832
 833 static int anysee_probe(struct usb_interface *intf,
 834                         const struct usb_device_id *id)
 835 {
 836         struct dvb_usb_device *d;
 837         struct usb_host_interface *alt;
 838         int ret;
 839
 840         /* There is one interface with two alternate settings.
 841            Alternate setting 0 is for bulk transfer.
 842            Alternate setting 1 is for isochronous transfer.
 843            We use bulk transfer (alternate setting 0). */
 844         if (intf->num_altsetting < 1)
 845                 return -ENODEV;
 846
 847         /*
 848          * Anysee is always warm (its USB-bridge, Cypress FX2, uploads
 849          * firmware from eeprom).  If dvb_usb_device_init() succeeds that
 850          * means d is a valid pointer.
 851          */
 852         ret = dvb_usb_device_init(intf, &anysee_properties, THIS_MODULE, &d,
 853                 adapter_nr);
 854         if (ret)
 855                 return ret;
 856
 857         alt = usb_altnum_to_altsetting(intf, 0);
 858         if (alt == NULL) {
 859                 deb_info("%s: no alt found!\n", __func__);
 860                 return -ENODEV;
 861         }
 862
 863         ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
 864                 alt->desc.bAlternateSetting);
 865         if (ret)
 866                 return ret;
 867
 868         return anysee_init(d);
 869 }
 870
 871 static struct usb_device_id anysee_table[] = {
 872         { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
 873         { USB_DEVICE(USB_VID_AMT,     USB_PID_ANYSEE) },
 874         { }             /* Terminating entry */
 875 };
 876 MODULE_DEVICE_TABLE(usb, anysee_table);
 877
 878 static struct dvb_usb_device_properties anysee_properties = {
 879         .caps             = DVB_USB_IS_AN_I2C_ADAPTER,
 880
 881         .usb_ctrl         = DEVICE_SPECIFIC,
 882
 883         .size_of_priv     = sizeof(struct anysee_state),
 884
 885         .num_adapters = 1,
 886         .adapter = {
 887                 {
 888                         .streaming_ctrl   = anysee_streaming_ctrl,
 889                         .frontend_attach  = anysee_frontend_attach,
 890                         .tuner_attach     = anysee_tuner_attach,
 891                         .stream = {
 892                                 .type = USB_BULK,
 893                                 .count = 8,
 894                                 .endpoint = 0x82,
 895                                 .u = {
 896                                         .bulk = {
 897                                                 .buffersize = (16*512),
 898                                         }
 899                                 }
 900                         },
 901                 }
 902         },
 903
 904         .rc.core = {
 905                 .rc_codes         = RC_MAP_ANYSEE,
 906                 .protocol         = RC_TYPE_OTHER,
 907                 .module_name      = "anysee",
 908                 .rc_query         = anysee_rc_query,
 909                 .rc_interval      = 250,  /* windows driver uses 500ms */
 910         },
 911
 912         .i2c_algo         = &anysee_i2c_algo,
 913
 914         .generic_bulk_ctrl_endpoint = 1,
 915
 916         .num_device_descs = 1,
 917         .devices = {
 918                 {
 919                         .name = "Anysee DVB USB2.0",
 920                         .cold_ids = {NULL},
 921                         .warm_ids = {&anysee_table[0],
 922                                      &anysee_table[1], NULL},
 923                 },
 924         }
 925 };
 926
 927 static struct usb_driver anysee_driver = {
 928         .name       = "dvb_usb_anysee",
 929         .probe      = anysee_probe,
 930         .disconnect = dvb_usb_device_exit,
 931         .id_table   = anysee_table,
 932 };
 933
 934 /* module stuff */
 935 static int __init anysee_module_init(void)
 936 {
 937         int ret;
 938
 939         ret = usb_register(&anysee_driver);
 940         if (ret)
 941                 err("%s: usb_register failed. Error number %d", __func__, ret);
 942
 943         return ret;
 944 }
 945
 946 static void __exit anysee_module_exit(void)
 947 {
 948         /* deregister this driver from the USB subsystem */
 949         usb_deregister(&anysee_driver);
 950 }
 951
 952 module_init(anysee_module_init);
 953 module_exit(anysee_module_exit);
 954
 955 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 956 MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
 957 MODULE_LICENSE("GPL");