1 /* 2 * Realtek RTL28xxU DVB USB driver 3 * 4 * Copyright (C) 2009 Antti Palosaari <crope@iki.fi> 5 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi> 6 * Copyright (C) 2012 Thomas Mair <thomas.mair86@googlemail.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License along 19 * with this program; if not, write to the Free Software Foundation, Inc., 20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 21 */ 22 23 #include "rtl28xxu.h" 24 25 #include "rtl2830.h" 26 #include "rtl2832.h" 27 28 #include "qt1010.h" 29 #include "mt2060.h" 30 #include "mxl5005s.h" 31 #include "fc0012.h" 32 #include "fc0013.h" 33 #include "e4000.h" 34 #include "fc2580.h" 35 #include "tua9001.h" 36 37 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 38 39 static int rtl28xxu_ctrl_msg(struct dvb_usb_device *d, struct rtl28xxu_req *req) 40 { 41 int ret; 42 unsigned int pipe; 43 u8 requesttype; 44 u8 *buf; 45 46 buf = kmalloc(req->size, GFP_KERNEL); 47 if (!buf) { 48 ret = -ENOMEM; 49 goto err; 50 } 51 52 if (req->index & CMD_WR_FLAG) { 53 /* write */ 54 memcpy(buf, req->data, req->size); 55 requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT); 56 pipe = usb_sndctrlpipe(d->udev, 0); 57 } else { 58 /* read */ 59 requesttype = (USB_TYPE_VENDOR | USB_DIR_IN); 60 pipe = usb_rcvctrlpipe(d->udev, 0); 61 } 62 63 ret = usb_control_msg(d->udev, pipe, 0, requesttype, req->value, 64 req->index, buf, req->size, 1000); 65 66 dvb_usb_dbg_usb_control_msg(d->udev, 0, requesttype, req->value, 67 req->index, buf, req->size); 68 69 if (ret > 0) 70 ret = 0; 71 72 /* read request, copy returned data to return buf */ 73 if (!ret && requesttype == (USB_TYPE_VENDOR | USB_DIR_IN)) 74 memcpy(req->data, buf, req->size); 75 76 kfree(buf); 77 78 if (ret) 79 goto err; 80 81 return ret; 82 err: 83 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 84 return ret; 85 } 86 87 static int rtl28xx_wr_regs(struct dvb_usb_device *d, u16 reg, u8 *val, int len) 88 { 89 struct rtl28xxu_req req; 90 91 if (reg < 0x3000) 92 req.index = CMD_USB_WR; 93 else if (reg < 0x4000) 94 req.index = CMD_SYS_WR; 95 else 96 req.index = CMD_IR_WR; 97 98 req.value = reg; 99 req.size = len; 100 req.data = val; 101 102 return rtl28xxu_ctrl_msg(d, &req); 103 } 104 105 static int rtl2831_rd_regs(struct dvb_usb_device *d, u16 reg, u8 *val, int len) 106 { 107 struct rtl28xxu_req req; 108 109 if (reg < 0x3000) 110 req.index = CMD_USB_RD; 111 else if (reg < 0x4000) 112 req.index = CMD_SYS_RD; 113 else 114 req.index = CMD_IR_RD; 115 116 req.value = reg; 117 req.size = len; 118 req.data = val; 119 120 return rtl28xxu_ctrl_msg(d, &req); 121 } 122 123 static int rtl28xx_wr_reg(struct dvb_usb_device *d, u16 reg, u8 val) 124 { 125 return rtl28xx_wr_regs(d, reg, &val, 1); 126 } 127 128 static int rtl28xx_rd_reg(struct dvb_usb_device *d, u16 reg, u8 *val) 129 { 130 return rtl2831_rd_regs(d, reg, val, 1); 131 } 132 133 static int rtl28xx_wr_reg_mask(struct dvb_usb_device *d, u16 reg, u8 val, 134 u8 mask) 135 { 136 int ret; 137 u8 tmp; 138 139 /* no need for read if whole reg is written */ 140 if (mask != 0xff) { 141 ret = rtl28xx_rd_reg(d, reg, &tmp); 142 if (ret) 143 return ret; 144 145 val &= mask; 146 tmp &= ~mask; 147 val |= tmp; 148 } 149 150 return rtl28xx_wr_reg(d, reg, val); 151 } 152 153 /* I2C */ 154 static int rtl28xxu_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], 155 int num) 156 { 157 int ret; 158 struct dvb_usb_device *d = i2c_get_adapdata(adap); 159 struct rtl28xxu_priv *priv = d->priv; 160 struct rtl28xxu_req req; 161 162 /* 163 * It is not known which are real I2C bus xfer limits, but testing 164 * with RTL2831U + MT2060 gives max RD 24 and max WR 22 bytes. 165 * TODO: find out RTL2832U lens 166 */ 167 168 /* 169 * I2C adapter logic looks rather complicated due to fact it handles 170 * three different access methods. Those methods are; 171 * 1) integrated demod access 172 * 2) old I2C access 173 * 3) new I2C access 174 * 175 * Used method is selected in order 1, 2, 3. Method 3 can handle all 176 * requests but there is two reasons why not use it always; 177 * 1) It is most expensive, usually two USB messages are needed 178 * 2) At least RTL2831U does not support it 179 * 180 * Method 3 is needed in case of I2C write+read (typical register read) 181 * where write is more than one byte. 182 */ 183 184 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 185 return -EAGAIN; 186 187 if (num == 2 && !(msg[0].flags & I2C_M_RD) && 188 (msg[1].flags & I2C_M_RD)) { 189 if (msg[0].len > 24 || msg[1].len > 24) { 190 /* TODO: check msg[0].len max */ 191 ret = -EOPNOTSUPP; 192 goto err_mutex_unlock; 193 } else if (msg[0].addr == 0x10) { 194 /* method 1 - integrated demod */ 195 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 196 req.index = CMD_DEMOD_RD | priv->page; 197 req.size = msg[1].len; 198 req.data = &msg[1].buf[0]; 199 ret = rtl28xxu_ctrl_msg(d, &req); 200 } else if (msg[0].len < 2) { 201 /* method 2 - old I2C */ 202 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 203 req.index = CMD_I2C_RD; 204 req.size = msg[1].len; 205 req.data = &msg[1].buf[0]; 206 ret = rtl28xxu_ctrl_msg(d, &req); 207 } else { 208 /* method 3 - new I2C */ 209 req.value = (msg[0].addr << 1); 210 req.index = CMD_I2C_DA_WR; 211 req.size = msg[0].len; 212 req.data = msg[0].buf; 213 ret = rtl28xxu_ctrl_msg(d, &req); 214 if (ret) 215 goto err_mutex_unlock; 216 217 req.value = (msg[0].addr << 1); 218 req.index = CMD_I2C_DA_RD; 219 req.size = msg[1].len; 220 req.data = msg[1].buf; 221 ret = rtl28xxu_ctrl_msg(d, &req); 222 } 223 } else if (num == 1 && !(msg[0].flags & I2C_M_RD)) { 224 if (msg[0].len > 22) { 225 /* TODO: check msg[0].len max */ 226 ret = -EOPNOTSUPP; 227 goto err_mutex_unlock; 228 } else if (msg[0].addr == 0x10) { 229 /* method 1 - integrated demod */ 230 if (msg[0].buf[0] == 0x00) { 231 /* save demod page for later demod access */ 232 priv->page = msg[0].buf[1]; 233 ret = 0; 234 } else { 235 req.value = (msg[0].buf[0] << 8) | 236 (msg[0].addr << 1); 237 req.index = CMD_DEMOD_WR | priv->page; 238 req.size = msg[0].len-1; 239 req.data = &msg[0].buf[1]; 240 ret = rtl28xxu_ctrl_msg(d, &req); 241 } 242 } else if (msg[0].len < 23) { 243 /* method 2 - old I2C */ 244 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 245 req.index = CMD_I2C_WR; 246 req.size = msg[0].len-1; 247 req.data = &msg[0].buf[1]; 248 ret = rtl28xxu_ctrl_msg(d, &req); 249 } else { 250 /* method 3 - new I2C */ 251 req.value = (msg[0].addr << 1); 252 req.index = CMD_I2C_DA_WR; 253 req.size = msg[0].len; 254 req.data = msg[0].buf; 255 ret = rtl28xxu_ctrl_msg(d, &req); 256 } 257 } else { 258 ret = -EINVAL; 259 } 260 261 err_mutex_unlock: 262 mutex_unlock(&d->i2c_mutex); 263 264 return ret ? ret : num; 265 } 266 267 static u32 rtl28xxu_i2c_func(struct i2c_adapter *adapter) 268 { 269 return I2C_FUNC_I2C; 270 } 271 272 static struct i2c_algorithm rtl28xxu_i2c_algo = { 273 .master_xfer = rtl28xxu_i2c_xfer, 274 .functionality = rtl28xxu_i2c_func, 275 }; 276 277 static int rtl2831u_read_config(struct dvb_usb_device *d) 278 { 279 struct rtl28xxu_priv *priv = d_to_priv(d); 280 int ret; 281 u8 buf[1]; 282 /* open RTL2831U/RTL2830 I2C gate */ 283 struct rtl28xxu_req req_gate_open = {0x0120, 0x0011, 0x0001, "\x08"}; 284 /* tuner probes */ 285 struct rtl28xxu_req req_mt2060 = {0x00c0, CMD_I2C_RD, 1, buf}; 286 struct rtl28xxu_req req_qt1010 = {0x0fc4, CMD_I2C_RD, 1, buf}; 287 288 dev_dbg(&d->udev->dev, "%s:\n", __func__); 289 290 /* 291 * RTL2831U GPIOs 292 * ========================================================= 293 * GPIO0 | tuner#0 | 0 off | 1 on | MXL5005S (?) 294 * GPIO2 | LED | 0 off | 1 on | 295 * GPIO4 | tuner#1 | 0 on | 1 off | MT2060 296 */ 297 298 /* GPIO direction */ 299 ret = rtl28xx_wr_reg(d, SYS_GPIO_DIR, 0x0a); 300 if (ret) 301 goto err; 302 303 /* enable as output GPIO0, GPIO2, GPIO4 */ 304 ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_EN, 0x15); 305 if (ret) 306 goto err; 307 308 /* 309 * Probe used tuner. We need to know used tuner before demod attach 310 * since there is some demod params needed to set according to tuner. 311 */ 312 313 /* demod needs some time to wake up */ 314 msleep(20); 315 316 priv->tuner_name = "NONE"; 317 318 /* open demod I2C gate */ 319 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 320 if (ret) 321 goto err; 322 323 /* check QT1010 ID(?) register; reg=0f val=2c */ 324 ret = rtl28xxu_ctrl_msg(d, &req_qt1010); 325 if (ret == 0 && buf[0] == 0x2c) { 326 priv->tuner = TUNER_RTL2830_QT1010; 327 priv->tuner_name = "QT1010"; 328 goto found; 329 } 330 331 /* open demod I2C gate */ 332 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 333 if (ret) 334 goto err; 335 336 /* check MT2060 ID register; reg=00 val=63 */ 337 ret = rtl28xxu_ctrl_msg(d, &req_mt2060); 338 if (ret == 0 && buf[0] == 0x63) { 339 priv->tuner = TUNER_RTL2830_MT2060; 340 priv->tuner_name = "MT2060"; 341 goto found; 342 } 343 344 /* assume MXL5005S */ 345 priv->tuner = TUNER_RTL2830_MXL5005S; 346 priv->tuner_name = "MXL5005S"; 347 goto found; 348 349 found: 350 dev_dbg(&d->udev->dev, "%s: tuner=%s\n", __func__, priv->tuner_name); 351 352 return 0; 353 err: 354 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 355 return ret; 356 } 357 358 static int rtl2832u_read_config(struct dvb_usb_device *d) 359 { 360 struct rtl28xxu_priv *priv = d_to_priv(d); 361 int ret; 362 u8 buf[2]; 363 /* open RTL2832U/RTL2832 I2C gate */ 364 struct rtl28xxu_req req_gate_open = {0x0120, 0x0011, 0x0001, "\x18"}; 365 /* close RTL2832U/RTL2832 I2C gate */ 366 struct rtl28xxu_req req_gate_close = {0x0120, 0x0011, 0x0001, "\x10"}; 367 /* tuner probes */ 368 struct rtl28xxu_req req_fc0012 = {0x00c6, CMD_I2C_RD, 1, buf}; 369 struct rtl28xxu_req req_fc0013 = {0x00c6, CMD_I2C_RD, 1, buf}; 370 struct rtl28xxu_req req_mt2266 = {0x00c0, CMD_I2C_RD, 1, buf}; 371 struct rtl28xxu_req req_fc2580 = {0x01ac, CMD_I2C_RD, 1, buf}; 372 struct rtl28xxu_req req_mt2063 = {0x00c0, CMD_I2C_RD, 1, buf}; 373 struct rtl28xxu_req req_max3543 = {0x00c0, CMD_I2C_RD, 1, buf}; 374 struct rtl28xxu_req req_tua9001 = {0x7ec0, CMD_I2C_RD, 2, buf}; 375 struct rtl28xxu_req req_mxl5007t = {0xd9c0, CMD_I2C_RD, 1, buf}; 376 struct rtl28xxu_req req_e4000 = {0x02c8, CMD_I2C_RD, 1, buf}; 377 struct rtl28xxu_req req_tda18272 = {0x00c0, CMD_I2C_RD, 2, buf}; 378 379 dev_dbg(&d->udev->dev, "%s:\n", __func__); 380 381 /* enable GPIO3 and GPIO6 as output */ 382 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x40); 383 if (ret) 384 goto err; 385 386 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x48, 0x48); 387 if (ret) 388 goto err; 389 390 /* 391 * Probe used tuner. We need to know used tuner before demod attach 392 * since there is some demod params needed to set according to tuner. 393 */ 394 395 /* open demod I2C gate */ 396 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 397 if (ret) 398 goto err; 399 400 priv->tuner_name = "NONE"; 401 402 /* check FC0012 ID register; reg=00 val=a1 */ 403 ret = rtl28xxu_ctrl_msg(d, &req_fc0012); 404 if (ret == 0 && buf[0] == 0xa1) { 405 priv->tuner = TUNER_RTL2832_FC0012; 406 priv->tuner_name = "FC0012"; 407 goto found; 408 } 409 410 /* check FC0013 ID register; reg=00 val=a3 */ 411 ret = rtl28xxu_ctrl_msg(d, &req_fc0013); 412 if (ret == 0 && buf[0] == 0xa3) { 413 priv->tuner = TUNER_RTL2832_FC0013; 414 priv->tuner_name = "FC0013"; 415 goto found; 416 } 417 418 /* check MT2266 ID register; reg=00 val=85 */ 419 ret = rtl28xxu_ctrl_msg(d, &req_mt2266); 420 if (ret == 0 && buf[0] == 0x85) { 421 priv->tuner = TUNER_RTL2832_MT2266; 422 priv->tuner_name = "MT2266"; 423 goto found; 424 } 425 426 /* check FC2580 ID register; reg=01 val=56 */ 427 ret = rtl28xxu_ctrl_msg(d, &req_fc2580); 428 if (ret == 0 && buf[0] == 0x56) { 429 priv->tuner = TUNER_RTL2832_FC2580; 430 priv->tuner_name = "FC2580"; 431 goto found; 432 } 433 434 /* check MT2063 ID register; reg=00 val=9e || 9c */ 435 ret = rtl28xxu_ctrl_msg(d, &req_mt2063); 436 if (ret == 0 && (buf[0] == 0x9e || buf[0] == 0x9c)) { 437 priv->tuner = TUNER_RTL2832_MT2063; 438 priv->tuner_name = "MT2063"; 439 goto found; 440 } 441 442 /* check MAX3543 ID register; reg=00 val=38 */ 443 ret = rtl28xxu_ctrl_msg(d, &req_max3543); 444 if (ret == 0 && buf[0] == 0x38) { 445 priv->tuner = TUNER_RTL2832_MAX3543; 446 priv->tuner_name = "MAX3543"; 447 goto found; 448 } 449 450 /* check TUA9001 ID register; reg=7e val=2328 */ 451 ret = rtl28xxu_ctrl_msg(d, &req_tua9001); 452 if (ret == 0 && buf[0] == 0x23 && buf[1] == 0x28) { 453 priv->tuner = TUNER_RTL2832_TUA9001; 454 priv->tuner_name = "TUA9001"; 455 goto found; 456 } 457 458 /* check MXL5007R ID register; reg=d9 val=14 */ 459 ret = rtl28xxu_ctrl_msg(d, &req_mxl5007t); 460 if (ret == 0 && buf[0] == 0x14) { 461 priv->tuner = TUNER_RTL2832_MXL5007T; 462 priv->tuner_name = "MXL5007T"; 463 goto found; 464 } 465 466 /* check E4000 ID register; reg=02 val=40 */ 467 ret = rtl28xxu_ctrl_msg(d, &req_e4000); 468 if (ret == 0 && buf[0] == 0x40) { 469 priv->tuner = TUNER_RTL2832_E4000; 470 priv->tuner_name = "E4000"; 471 goto found; 472 } 473 474 /* check TDA18272 ID register; reg=00 val=c760 */ 475 ret = rtl28xxu_ctrl_msg(d, &req_tda18272); 476 if (ret == 0 && (buf[0] == 0xc7 || buf[1] == 0x60)) { 477 priv->tuner = TUNER_RTL2832_TDA18272; 478 priv->tuner_name = "TDA18272"; 479 goto found; 480 } 481 482 found: 483 dev_dbg(&d->udev->dev, "%s: tuner=%s\n", __func__, priv->tuner_name); 484 485 /* close demod I2C gate */ 486 ret = rtl28xxu_ctrl_msg(d, &req_gate_close); 487 if (ret < 0) 488 goto err; 489 490 return 0; 491 err: 492 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 493 return ret; 494 } 495 496 static struct rtl2830_config rtl28xxu_rtl2830_mt2060_config = { 497 .i2c_addr = 0x10, /* 0x20 */ 498 .xtal = 28800000, 499 .ts_mode = 0, 500 .spec_inv = 1, 501 .vtop = 0x20, 502 .krf = 0x04, 503 .agc_targ_val = 0x2d, 504 505 }; 506 507 static struct rtl2830_config rtl28xxu_rtl2830_qt1010_config = { 508 .i2c_addr = 0x10, /* 0x20 */ 509 .xtal = 28800000, 510 .ts_mode = 0, 511 .spec_inv = 1, 512 .vtop = 0x20, 513 .krf = 0x04, 514 .agc_targ_val = 0x2d, 515 }; 516 517 static struct rtl2830_config rtl28xxu_rtl2830_mxl5005s_config = { 518 .i2c_addr = 0x10, /* 0x20 */ 519 .xtal = 28800000, 520 .ts_mode = 0, 521 .spec_inv = 0, 522 .vtop = 0x3f, 523 .krf = 0x04, 524 .agc_targ_val = 0x3e, 525 }; 526 527 static int rtl2831u_frontend_attach(struct dvb_usb_adapter *adap) 528 { 529 struct dvb_usb_device *d = adap_to_d(adap); 530 struct rtl28xxu_priv *priv = d_to_priv(d); 531 struct rtl2830_config *rtl2830_config; 532 int ret; 533 534 dev_dbg(&d->udev->dev, "%s:\n", __func__); 535 536 switch (priv->tuner) { 537 case TUNER_RTL2830_QT1010: 538 rtl2830_config = &rtl28xxu_rtl2830_qt1010_config; 539 break; 540 case TUNER_RTL2830_MT2060: 541 rtl2830_config = &rtl28xxu_rtl2830_mt2060_config; 542 break; 543 case TUNER_RTL2830_MXL5005S: 544 rtl2830_config = &rtl28xxu_rtl2830_mxl5005s_config; 545 break; 546 default: 547 dev_err(&d->udev->dev, "%s: unknown tuner=%s\n", 548 KBUILD_MODNAME, priv->tuner_name); 549 ret = -ENODEV; 550 goto err; 551 } 552 553 /* attach demodulator */ 554 adap->fe[0] = dvb_attach(rtl2830_attach, rtl2830_config, &d->i2c_adap); 555 if (!adap->fe[0]) { 556 ret = -ENODEV; 557 goto err; 558 } 559 560 return 0; 561 err: 562 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 563 return ret; 564 } 565 566 static struct rtl2832_config rtl28xxu_rtl2832_fc0012_config = { 567 .i2c_addr = 0x10, /* 0x20 */ 568 .xtal = 28800000, 569 .if_dvbt = 0, 570 .tuner = TUNER_RTL2832_FC0012 571 }; 572 573 static struct rtl2832_config rtl28xxu_rtl2832_fc0013_config = { 574 .i2c_addr = 0x10, /* 0x20 */ 575 .xtal = 28800000, 576 .if_dvbt = 0, 577 .tuner = TUNER_RTL2832_FC0013 578 }; 579 580 static struct rtl2832_config rtl28xxu_rtl2832_tua9001_config = { 581 .i2c_addr = 0x10, /* 0x20 */ 582 .xtal = 28800000, 583 .tuner = TUNER_RTL2832_TUA9001, 584 }; 585 586 static struct rtl2832_config rtl28xxu_rtl2832_e4000_config = { 587 .i2c_addr = 0x10, /* 0x20 */ 588 .xtal = 28800000, 589 .tuner = TUNER_RTL2832_E4000, 590 }; 591 592 static int rtl2832u_fc0012_tuner_callback(struct dvb_usb_device *d, 593 int cmd, int arg) 594 { 595 int ret; 596 u8 val; 597 598 dev_dbg(&d->udev->dev, "%s: cmd=%d arg=%d\n", __func__, cmd, arg); 599 600 switch (cmd) { 601 case FC_FE_CALLBACK_VHF_ENABLE: 602 /* set output values */ 603 ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &val); 604 if (ret) 605 goto err; 606 607 if (arg) 608 val &= 0xbf; /* set GPIO6 low */ 609 else 610 val |= 0x40; /* set GPIO6 high */ 611 612 613 ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, val); 614 if (ret) 615 goto err; 616 break; 617 default: 618 ret = -EINVAL; 619 goto err; 620 } 621 return 0; 622 err: 623 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 624 return ret; 625 } 626 627 static int rtl2832u_tua9001_tuner_callback(struct dvb_usb_device *d, 628 int cmd, int arg) 629 { 630 int ret; 631 u8 val; 632 633 dev_dbg(&d->udev->dev, "%s: cmd=%d arg=%d\n", __func__, cmd, arg); 634 635 /* 636 * CEN always enabled by hardware wiring 637 * RESETN GPIO4 638 * RXEN GPIO1 639 */ 640 641 switch (cmd) { 642 case TUA9001_CMD_RESETN: 643 if (arg) 644 val = (1 << 4); 645 else 646 val = (0 << 4); 647 648 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_VAL, val, 0x10); 649 if (ret) 650 goto err; 651 break; 652 case TUA9001_CMD_RXEN: 653 if (arg) 654 val = (1 << 1); 655 else 656 val = (0 << 1); 657 658 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_VAL, val, 0x02); 659 if (ret) 660 goto err; 661 break; 662 } 663 664 return 0; 665 err: 666 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 667 return ret; 668 } 669 670 static int rtl2832u_tuner_callback(struct dvb_usb_device *d, int cmd, int arg) 671 { 672 struct rtl28xxu_priv *priv = d->priv; 673 674 switch (priv->tuner) { 675 case TUNER_RTL2832_FC0012: 676 return rtl2832u_fc0012_tuner_callback(d, cmd, arg); 677 case TUNER_RTL2832_TUA9001: 678 return rtl2832u_tua9001_tuner_callback(d, cmd, arg); 679 default: 680 break; 681 } 682 683 return 0; 684 } 685 686 static int rtl2832u_frontend_callback(void *adapter_priv, int component, 687 int cmd, int arg) 688 { 689 struct i2c_adapter *adap = adapter_priv; 690 struct dvb_usb_device *d = i2c_get_adapdata(adap); 691 692 dev_dbg(&d->udev->dev, "%s: component=%d cmd=%d arg=%d\n", 693 __func__, component, cmd, arg); 694 695 switch (component) { 696 case DVB_FRONTEND_COMPONENT_TUNER: 697 return rtl2832u_tuner_callback(d, cmd, arg); 698 default: 699 break; 700 } 701 702 return 0; 703 } 704 705 static int rtl2832u_frontend_attach(struct dvb_usb_adapter *adap) 706 { 707 int ret; 708 struct dvb_usb_device *d = adap_to_d(adap); 709 struct rtl28xxu_priv *priv = d_to_priv(d); 710 struct rtl2832_config *rtl2832_config; 711 712 dev_dbg(&d->udev->dev, "%s:\n", __func__); 713 714 switch (priv->tuner) { 715 case TUNER_RTL2832_FC0012: 716 rtl2832_config = &rtl28xxu_rtl2832_fc0012_config; 717 break; 718 case TUNER_RTL2832_FC0013: 719 rtl2832_config = &rtl28xxu_rtl2832_fc0013_config; 720 break; 721 case TUNER_RTL2832_FC2580: 722 /* FIXME: do not abuse fc0012 settings */ 723 rtl2832_config = &rtl28xxu_rtl2832_fc0012_config; 724 break; 725 case TUNER_RTL2832_TUA9001: 726 rtl2832_config = &rtl28xxu_rtl2832_tua9001_config; 727 break; 728 case TUNER_RTL2832_E4000: 729 rtl2832_config = &rtl28xxu_rtl2832_e4000_config; 730 break; 731 default: 732 dev_err(&d->udev->dev, "%s: unknown tuner=%s\n", 733 KBUILD_MODNAME, priv->tuner_name); 734 ret = -ENODEV; 735 goto err; 736 } 737 738 /* attach demodulator */ 739 adap->fe[0] = dvb_attach(rtl2832_attach, rtl2832_config, &d->i2c_adap); 740 if (!adap->fe[0]) { 741 ret = -ENODEV; 742 goto err; 743 } 744 745 /* set fe callback */ 746 adap->fe[0]->callback = rtl2832u_frontend_callback; 747 748 return 0; 749 err: 750 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 751 return ret; 752 } 753 754 static struct qt1010_config rtl28xxu_qt1010_config = { 755 .i2c_address = 0x62, /* 0xc4 */ 756 }; 757 758 static struct mt2060_config rtl28xxu_mt2060_config = { 759 .i2c_address = 0x60, /* 0xc0 */ 760 .clock_out = 0, 761 }; 762 763 static struct mxl5005s_config rtl28xxu_mxl5005s_config = { 764 .i2c_address = 0x63, /* 0xc6 */ 765 .if_freq = IF_FREQ_4570000HZ, 766 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 767 .agc_mode = MXL_SINGLE_AGC, 768 .tracking_filter = MXL_TF_C_H, 769 .rssi_enable = MXL_RSSI_ENABLE, 770 .cap_select = MXL_CAP_SEL_ENABLE, 771 .div_out = MXL_DIV_OUT_4, 772 .clock_out = MXL_CLOCK_OUT_DISABLE, 773 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 774 .top = MXL5005S_TOP_25P2, 775 .mod_mode = MXL_DIGITAL_MODE, 776 .if_mode = MXL_ZERO_IF, 777 .AgcMasterByte = 0x00, 778 }; 779 780 static int rtl2831u_tuner_attach(struct dvb_usb_adapter *adap) 781 { 782 int ret; 783 struct dvb_usb_device *d = adap_to_d(adap); 784 struct rtl28xxu_priv *priv = d_to_priv(d); 785 struct i2c_adapter *rtl2830_tuner_i2c; 786 struct dvb_frontend *fe; 787 788 dev_dbg(&d->udev->dev, "%s:\n", __func__); 789 790 /* use rtl2830 driver I2C adapter, for more info see rtl2830 driver */ 791 rtl2830_tuner_i2c = rtl2830_get_tuner_i2c_adapter(adap->fe[0]); 792 793 switch (priv->tuner) { 794 case TUNER_RTL2830_QT1010: 795 fe = dvb_attach(qt1010_attach, adap->fe[0], 796 rtl2830_tuner_i2c, &rtl28xxu_qt1010_config); 797 break; 798 case TUNER_RTL2830_MT2060: 799 fe = dvb_attach(mt2060_attach, adap->fe[0], 800 rtl2830_tuner_i2c, &rtl28xxu_mt2060_config, 801 1220); 802 break; 803 case TUNER_RTL2830_MXL5005S: 804 fe = dvb_attach(mxl5005s_attach, adap->fe[0], 805 rtl2830_tuner_i2c, &rtl28xxu_mxl5005s_config); 806 break; 807 default: 808 fe = NULL; 809 dev_err(&d->udev->dev, "%s: unknown tuner=%d\n", KBUILD_MODNAME, 810 priv->tuner); 811 } 812 813 if (fe == NULL) { 814 ret = -ENODEV; 815 goto err; 816 } 817 818 return 0; 819 err: 820 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 821 return ret; 822 } 823 824 static const struct e4000_config rtl2832u_e4000_config = { 825 .i2c_addr = 0x64, 826 .clock = 28800000, 827 }; 828 829 static const struct fc2580_config rtl2832u_fc2580_config = { 830 .i2c_addr = 0x56, 831 .clock = 16384000, 832 }; 833 834 static struct tua9001_config rtl2832u_tua9001_config = { 835 .i2c_addr = 0x60, 836 }; 837 838 static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap) 839 { 840 int ret; 841 struct dvb_usb_device *d = adap_to_d(adap); 842 struct rtl28xxu_priv *priv = d_to_priv(d); 843 struct dvb_frontend *fe; 844 845 dev_dbg(&d->udev->dev, "%s:\n", __func__); 846 847 switch (priv->tuner) { 848 case TUNER_RTL2832_FC0012: 849 fe = dvb_attach(fc0012_attach, adap->fe[0], 850 &d->i2c_adap, 0xc6>>1, 0, FC_XTAL_28_8_MHZ); 851 852 /* since fc0012 includs reading the signal strength delegate 853 * that to the tuner driver */ 854 adap->fe[0]->ops.read_signal_strength = 855 adap->fe[0]->ops.tuner_ops.get_rf_strength; 856 return 0; 857 break; 858 case TUNER_RTL2832_FC0013: 859 fe = dvb_attach(fc0013_attach, adap->fe[0], 860 &d->i2c_adap, 0xc6>>1, 0, FC_XTAL_28_8_MHZ); 861 862 /* fc0013 also supports signal strength reading */ 863 adap->fe[0]->ops.read_signal_strength = 864 adap->fe[0]->ops.tuner_ops.get_rf_strength; 865 return 0; 866 case TUNER_RTL2832_E4000: 867 fe = dvb_attach(e4000_attach, adap->fe[0], &d->i2c_adap, 868 &rtl2832u_e4000_config); 869 break; 870 case TUNER_RTL2832_FC2580: 871 fe = dvb_attach(fc2580_attach, adap->fe[0], &d->i2c_adap, 872 &rtl2832u_fc2580_config); 873 break; 874 case TUNER_RTL2832_TUA9001: 875 /* enable GPIO1 and GPIO4 as output */ 876 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x12); 877 if (ret) 878 goto err; 879 880 ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x12, 0x12); 881 if (ret) 882 goto err; 883 884 fe = dvb_attach(tua9001_attach, adap->fe[0], &d->i2c_adap, 885 &rtl2832u_tua9001_config); 886 break; 887 default: 888 fe = NULL; 889 dev_err(&d->udev->dev, "%s: unknown tuner=%d\n", KBUILD_MODNAME, 890 priv->tuner); 891 } 892 893 if (fe == NULL) { 894 ret = -ENODEV; 895 goto err; 896 } 897 898 return 0; 899 err: 900 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 901 return ret; 902 } 903 904 static int rtl28xxu_init(struct dvb_usb_device *d) 905 { 906 int ret; 907 u8 val; 908 909 dev_dbg(&d->udev->dev, "%s:\n", __func__); 910 911 /* init USB endpoints */ 912 ret = rtl28xx_rd_reg(d, USB_SYSCTL_0, &val); 913 if (ret) 914 goto err; 915 916 /* enable DMA and Full Packet Mode*/ 917 val |= 0x09; 918 ret = rtl28xx_wr_reg(d, USB_SYSCTL_0, val); 919 if (ret) 920 goto err; 921 922 /* set EPA maximum packet size to 0x0200 */ 923 ret = rtl28xx_wr_regs(d, USB_EPA_MAXPKT, "\x00\x02\x00\x00", 4); 924 if (ret) 925 goto err; 926 927 /* change EPA FIFO length */ 928 ret = rtl28xx_wr_regs(d, USB_EPA_FIFO_CFG, "\x14\x00\x00\x00", 4); 929 if (ret) 930 goto err; 931 932 return ret; 933 err: 934 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 935 return ret; 936 } 937 938 static int rtl2831u_power_ctrl(struct dvb_usb_device *d, int onoff) 939 { 940 int ret; 941 u8 gpio, sys0, epa_ctl[2]; 942 943 dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff); 944 945 /* demod adc */ 946 ret = rtl28xx_rd_reg(d, SYS_SYS0, &sys0); 947 if (ret) 948 goto err; 949 950 /* tuner power, read GPIOs */ 951 ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &gpio); 952 if (ret) 953 goto err; 954 955 dev_dbg(&d->udev->dev, "%s: RD SYS0=%02x GPIO_OUT_VAL=%02x\n", __func__, 956 sys0, gpio); 957 958 if (onoff) { 959 gpio |= 0x01; /* GPIO0 = 1 */ 960 gpio &= (~0x10); /* GPIO4 = 0 */ 961 gpio |= 0x04; /* GPIO2 = 1, LED on */ 962 sys0 = sys0 & 0x0f; 963 sys0 |= 0xe0; 964 epa_ctl[0] = 0x00; /* clear stall */ 965 epa_ctl[1] = 0x00; /* clear reset */ 966 } else { 967 gpio &= (~0x01); /* GPIO0 = 0 */ 968 gpio |= 0x10; /* GPIO4 = 1 */ 969 gpio &= (~0x04); /* GPIO2 = 1, LED off */ 970 sys0 = sys0 & (~0xc0); 971 epa_ctl[0] = 0x10; /* set stall */ 972 epa_ctl[1] = 0x02; /* set reset */ 973 } 974 975 dev_dbg(&d->udev->dev, "%s: WR SYS0=%02x GPIO_OUT_VAL=%02x\n", __func__, 976 sys0, gpio); 977 978 /* demod adc */ 979 ret = rtl28xx_wr_reg(d, SYS_SYS0, sys0); 980 if (ret) 981 goto err; 982 983 /* tuner power, write GPIOs */ 984 ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, gpio); 985 if (ret) 986 goto err; 987 988 /* streaming EP: stall & reset */ 989 ret = rtl28xx_wr_regs(d, USB_EPA_CTL, epa_ctl, 2); 990 if (ret) 991 goto err; 992 993 if (onoff) 994 usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81)); 995 996 return ret; 997 err: 998 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 999 return ret; 1000 } 1001 1002 static int rtl2832u_power_ctrl(struct dvb_usb_device *d, int onoff) 1003 { 1004 int ret; 1005 u8 val; 1006 1007 dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff); 1008 1009 if (onoff) { 1010 /* set output values */ 1011 ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &val); 1012 if (ret) 1013 goto err; 1014 1015 val |= 0x08; 1016 val &= 0xef; 1017 1018 ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, val); 1019 if (ret) 1020 goto err; 1021 1022 /* demod_ctl_1 */ 1023 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL1, &val); 1024 if (ret) 1025 goto err; 1026 1027 val &= 0xef; 1028 1029 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL1, val); 1030 if (ret) 1031 goto err; 1032 1033 /* demod control */ 1034 /* PLL enable */ 1035 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val); 1036 if (ret) 1037 goto err; 1038 1039 /* bit 7 to 1 */ 1040 val |= 0x80; 1041 1042 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val); 1043 if (ret) 1044 goto err; 1045 1046 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val); 1047 if (ret) 1048 goto err; 1049 1050 val |= 0x20; 1051 1052 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val); 1053 if (ret) 1054 goto err; 1055 1056 mdelay(5); 1057 1058 /*enable ADC_Q and ADC_I */ 1059 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val); 1060 if (ret) 1061 goto err; 1062 1063 val |= 0x48; 1064 1065 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val); 1066 if (ret) 1067 goto err; 1068 1069 /* streaming EP: clear stall & reset */ 1070 ret = rtl28xx_wr_regs(d, USB_EPA_CTL, "\x00\x00", 2); 1071 if (ret) 1072 goto err; 1073 1074 ret = usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81)); 1075 if (ret) 1076 goto err; 1077 } else { 1078 /* demod_ctl_1 */ 1079 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL1, &val); 1080 if (ret) 1081 goto err; 1082 1083 val |= 0x0c; 1084 1085 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL1, val); 1086 if (ret) 1087 goto err; 1088 1089 /* set output values */ 1090 ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &val); 1091 if (ret) 1092 goto err; 1093 1094 val |= 0x10; 1095 1096 ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, val); 1097 if (ret) 1098 goto err; 1099 1100 /* demod control */ 1101 ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val); 1102 if (ret) 1103 goto err; 1104 1105 val &= 0x37; 1106 1107 ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val); 1108 if (ret) 1109 goto err; 1110 1111 /* streaming EP: set stall & reset */ 1112 ret = rtl28xx_wr_regs(d, USB_EPA_CTL, "\x10\x02", 2); 1113 if (ret) 1114 goto err; 1115 } 1116 1117 return ret; 1118 err: 1119 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 1120 return ret; 1121 } 1122 1123 1124 static int rtl2831u_rc_query(struct dvb_usb_device *d) 1125 { 1126 int ret, i; 1127 struct rtl28xxu_priv *priv = d->priv; 1128 u8 buf[5]; 1129 u32 rc_code; 1130 struct rtl28xxu_reg_val rc_nec_tab[] = { 1131 { 0x3033, 0x80 }, 1132 { 0x3020, 0x43 }, 1133 { 0x3021, 0x16 }, 1134 { 0x3022, 0x16 }, 1135 { 0x3023, 0x5a }, 1136 { 0x3024, 0x2d }, 1137 { 0x3025, 0x16 }, 1138 { 0x3026, 0x01 }, 1139 { 0x3028, 0xb0 }, 1140 { 0x3029, 0x04 }, 1141 { 0x302c, 0x88 }, 1142 { 0x302e, 0x13 }, 1143 { 0x3030, 0xdf }, 1144 { 0x3031, 0x05 }, 1145 }; 1146 1147 /* init remote controller */ 1148 if (!priv->rc_active) { 1149 for (i = 0; i < ARRAY_SIZE(rc_nec_tab); i++) { 1150 ret = rtl28xx_wr_reg(d, rc_nec_tab[i].reg, 1151 rc_nec_tab[i].val); 1152 if (ret) 1153 goto err; 1154 } 1155 priv->rc_active = true; 1156 } 1157 1158 ret = rtl2831_rd_regs(d, SYS_IRRC_RP, buf, 5); 1159 if (ret) 1160 goto err; 1161 1162 if (buf[4] & 0x01) { 1163 if (buf[2] == (u8) ~buf[3]) { 1164 if (buf[0] == (u8) ~buf[1]) { 1165 /* NEC standard (16 bit) */ 1166 rc_code = buf[0] << 8 | buf[2]; 1167 } else { 1168 /* NEC extended (24 bit) */ 1169 rc_code = buf[0] << 16 | 1170 buf[1] << 8 | buf[2]; 1171 } 1172 } else { 1173 /* NEC full (32 bit) */ 1174 rc_code = buf[0] << 24 | buf[1] << 16 | 1175 buf[2] << 8 | buf[3]; 1176 } 1177 1178 rc_keydown(d->rc_dev, rc_code, 0); 1179 1180 ret = rtl28xx_wr_reg(d, SYS_IRRC_SR, 1); 1181 if (ret) 1182 goto err; 1183 1184 /* repeated intentionally to avoid extra keypress */ 1185 ret = rtl28xx_wr_reg(d, SYS_IRRC_SR, 1); 1186 if (ret) 1187 goto err; 1188 } 1189 1190 return ret; 1191 err: 1192 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 1193 return ret; 1194 } 1195 1196 static int rtl2831u_get_rc_config(struct dvb_usb_device *d, 1197 struct dvb_usb_rc *rc) 1198 { 1199 rc->map_name = RC_MAP_EMPTY; 1200 rc->allowed_protos = RC_BIT_NEC; 1201 rc->query = rtl2831u_rc_query; 1202 rc->interval = 400; 1203 1204 return 0; 1205 } 1206 1207 static int rtl2832u_rc_query(struct dvb_usb_device *d) 1208 { 1209 int ret, i; 1210 struct rtl28xxu_priv *priv = d->priv; 1211 u8 buf[128]; 1212 int len; 1213 struct rtl28xxu_reg_val rc_nec_tab[] = { 1214 { IR_RX_CTRL, 0x20 }, 1215 { IR_RX_BUF_CTRL, 0x80 }, 1216 { IR_RX_IF, 0xff }, 1217 { IR_RX_IE, 0xff }, 1218 { IR_MAX_DURATION0, 0xd0 }, 1219 { IR_MAX_DURATION1, 0x07 }, 1220 { IR_IDLE_LEN0, 0xc0 }, 1221 { IR_IDLE_LEN1, 0x00 }, 1222 { IR_GLITCH_LEN, 0x03 }, 1223 { IR_RX_CLK, 0x09 }, 1224 { IR_RX_CFG, 0x1c }, 1225 { IR_MAX_H_TOL_LEN, 0x1e }, 1226 { IR_MAX_L_TOL_LEN, 0x1e }, 1227 { IR_RX_CTRL, 0x80 }, 1228 }; 1229 1230 /* init remote controller */ 1231 if (!priv->rc_active) { 1232 for (i = 0; i < ARRAY_SIZE(rc_nec_tab); i++) { 1233 ret = rtl28xx_wr_reg(d, rc_nec_tab[i].reg, 1234 rc_nec_tab[i].val); 1235 if (ret) 1236 goto err; 1237 } 1238 priv->rc_active = true; 1239 } 1240 1241 ret = rtl28xx_rd_reg(d, IR_RX_IF, &buf[0]); 1242 if (ret) 1243 goto err; 1244 1245 if (buf[0] != 0x83) 1246 goto exit; 1247 1248 ret = rtl28xx_rd_reg(d, IR_RX_BC, &buf[0]); 1249 if (ret) 1250 goto err; 1251 1252 len = buf[0]; 1253 ret = rtl2831_rd_regs(d, IR_RX_BUF, buf, len); 1254 1255 /* TODO: pass raw IR to Kernel IR decoder */ 1256 1257 ret = rtl28xx_wr_reg(d, IR_RX_IF, 0x03); 1258 ret = rtl28xx_wr_reg(d, IR_RX_BUF_CTRL, 0x80); 1259 ret = rtl28xx_wr_reg(d, IR_RX_CTRL, 0x80); 1260 1261 exit: 1262 return ret; 1263 err: 1264 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); 1265 return ret; 1266 } 1267 1268 static int rtl2832u_get_rc_config(struct dvb_usb_device *d, 1269 struct dvb_usb_rc *rc) 1270 { 1271 rc->map_name = RC_MAP_EMPTY; 1272 rc->allowed_protos = RC_BIT_NEC; 1273 rc->query = rtl2832u_rc_query; 1274 rc->interval = 400; 1275 1276 return 0; 1277 } 1278 1279 static const struct dvb_usb_device_properties rtl2831u_props = { 1280 .driver_name = KBUILD_MODNAME, 1281 .owner = THIS_MODULE, 1282 .adapter_nr = adapter_nr, 1283 .size_of_priv = sizeof(struct rtl28xxu_priv), 1284 1285 .power_ctrl = rtl2831u_power_ctrl, 1286 .i2c_algo = &rtl28xxu_i2c_algo, 1287 .read_config = rtl2831u_read_config, 1288 .frontend_attach = rtl2831u_frontend_attach, 1289 .tuner_attach = rtl2831u_tuner_attach, 1290 .init = rtl28xxu_init, 1291 .get_rc_config = rtl2831u_get_rc_config, 1292 1293 .num_adapters = 1, 1294 .adapter = { 1295 { 1296 .stream = DVB_USB_STREAM_BULK(0x81, 6, 8 * 512), 1297 }, 1298 }, 1299 }; 1300 1301 static const struct dvb_usb_device_properties rtl2832u_props = { 1302 .driver_name = KBUILD_MODNAME, 1303 .owner = THIS_MODULE, 1304 .adapter_nr = adapter_nr, 1305 .size_of_priv = sizeof(struct rtl28xxu_priv), 1306 1307 .power_ctrl = rtl2832u_power_ctrl, 1308 .i2c_algo = &rtl28xxu_i2c_algo, 1309 .read_config = rtl2832u_read_config, 1310 .frontend_attach = rtl2832u_frontend_attach, 1311 .tuner_attach = rtl2832u_tuner_attach, 1312 .init = rtl28xxu_init, 1313 .get_rc_config = rtl2832u_get_rc_config, 1314 1315 .num_adapters = 1, 1316 .adapter = { 1317 { 1318 .stream = DVB_USB_STREAM_BULK(0x81, 6, 8 * 512), 1319 }, 1320 }, 1321 }; 1322 1323 static const struct usb_device_id rtl28xxu_id_table[] = { 1324 { DVB_USB_DEVICE(USB_VID_REALTEK, USB_PID_REALTEK_RTL2831U, 1325 &rtl2831u_props, "Realtek RTL2831U reference design", NULL) }, 1326 { DVB_USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_FREECOM_DVBT, 1327 &rtl2831u_props, "Freecom USB2.0 DVB-T", NULL) }, 1328 { DVB_USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_FREECOM_DVBT_2, 1329 &rtl2831u_props, "Freecom USB2.0 DVB-T", NULL) }, 1330 1331 { DVB_USB_DEVICE(USB_VID_REALTEK, 0x2832, 1332 &rtl2832u_props, "Realtek RTL2832U reference design", NULL) }, 1333 { DVB_USB_DEVICE(USB_VID_REALTEK, 0x2838, 1334 &rtl2832u_props, "Realtek RTL2832U reference design", NULL) }, 1335 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_BLACK_REV1, 1336 &rtl2832u_props, "Terratec Cinergy T Stick Black", NULL) }, 1337 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_DELOCK_USB2_DVBT, 1338 &rtl2832u_props, "G-Tek Electronics Group Lifeview LV5TDLX DVB-T", NULL) }, 1339 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK, 1340 &rtl2832u_props, "NOXON DAB/DAB+ USB dongle", NULL) }, 1341 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK_REV2, 1342 &rtl2832u_props, "NOXON DAB/DAB+ USB dongle (rev 2)", NULL) }, 1343 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TREKSTOR_TERRES_2_0, 1344 &rtl2832u_props, "Trekstor DVB-T Stick Terres 2.0", NULL) }, 1345 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1101, 1346 &rtl2832u_props, "Dexatek DK DVB-T Dongle", NULL) }, 1347 { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6680, 1348 &rtl2832u_props, "DigitalNow Quad DVB-T Receiver", NULL) }, 1349 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d3, 1350 &rtl2832u_props, "TerraTec Cinergy T Stick RC (Rev. 3)", NULL) }, 1351 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1102, 1352 &rtl2832u_props, "Dexatek DK mini DVB-T Dongle", NULL) }, 1353 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d7, 1354 &rtl2832u_props, "TerraTec Cinergy T Stick+", NULL) }, 1355 { } 1356 }; 1357 MODULE_DEVICE_TABLE(usb, rtl28xxu_id_table); 1358 1359 static struct usb_driver rtl28xxu_usb_driver = { 1360 .name = KBUILD_MODNAME, 1361 .id_table = rtl28xxu_id_table, 1362 .probe = dvb_usbv2_probe, 1363 .disconnect = dvb_usbv2_disconnect, 1364 .suspend = dvb_usbv2_suspend, 1365 .resume = dvb_usbv2_resume, 1366 .reset_resume = dvb_usbv2_reset_resume, 1367 .no_dynamic_id = 1, 1368 .soft_unbind = 1, 1369 }; 1370 1371 module_usb_driver(rtl28xxu_usb_driver); 1372 1373 MODULE_DESCRIPTION("Realtek RTL28xxU DVB USB driver"); 1374 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1375 MODULE_AUTHOR("Thomas Mair <thomas.mair86@googlemail.com>"); 1376 MODULE_LICENSE("GPL"); 1377