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 static int rtl28xxu_disable_rc; 26 module_param_named(disable_rc, rtl28xxu_disable_rc, int, 0644); 27 MODULE_PARM_DESC(disable_rc, "disable RTL2832U remote controller"); 28 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 29 30 static int rtl28xxu_ctrl_msg(struct dvb_usb_device *d, struct rtl28xxu_req *req) 31 { 32 struct rtl28xxu_dev *dev = d->priv; 33 int ret; 34 unsigned int pipe; 35 u8 requesttype; 36 37 if (req->index & CMD_WR_FLAG) { 38 /* write */ 39 memcpy(dev->buf, req->data, req->size); 40 requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT); 41 pipe = usb_sndctrlpipe(d->udev, 0); 42 } else { 43 /* read */ 44 requesttype = (USB_TYPE_VENDOR | USB_DIR_IN); 45 pipe = usb_rcvctrlpipe(d->udev, 0); 46 } 47 48 ret = usb_control_msg(d->udev, pipe, 0, requesttype, req->value, 49 req->index, dev->buf, req->size, 1000); 50 dvb_usb_dbg_usb_control_msg(d->udev, 0, requesttype, req->value, 51 req->index, dev->buf, req->size); 52 if (ret < 0) 53 goto err; 54 55 /* read request, copy returned data to return buf */ 56 if (requesttype == (USB_TYPE_VENDOR | USB_DIR_IN)) 57 memcpy(req->data, dev->buf, req->size); 58 59 return 0; 60 err: 61 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 62 return ret; 63 } 64 65 static int rtl28xxu_wr_regs(struct dvb_usb_device *d, u16 reg, u8 *val, int len) 66 { 67 struct rtl28xxu_req req; 68 69 if (reg < 0x3000) 70 req.index = CMD_USB_WR; 71 else if (reg < 0x4000) 72 req.index = CMD_SYS_WR; 73 else 74 req.index = CMD_IR_WR; 75 76 req.value = reg; 77 req.size = len; 78 req.data = val; 79 80 return rtl28xxu_ctrl_msg(d, &req); 81 } 82 83 static int rtl28xxu_rd_regs(struct dvb_usb_device *d, u16 reg, u8 *val, int len) 84 { 85 struct rtl28xxu_req req; 86 87 if (reg < 0x3000) 88 req.index = CMD_USB_RD; 89 else if (reg < 0x4000) 90 req.index = CMD_SYS_RD; 91 else 92 req.index = CMD_IR_RD; 93 94 req.value = reg; 95 req.size = len; 96 req.data = val; 97 98 return rtl28xxu_ctrl_msg(d, &req); 99 } 100 101 static int rtl28xxu_wr_reg(struct dvb_usb_device *d, u16 reg, u8 val) 102 { 103 return rtl28xxu_wr_regs(d, reg, &val, 1); 104 } 105 106 static int rtl28xxu_rd_reg(struct dvb_usb_device *d, u16 reg, u8 *val) 107 { 108 return rtl28xxu_rd_regs(d, reg, val, 1); 109 } 110 111 static int rtl28xxu_wr_reg_mask(struct dvb_usb_device *d, u16 reg, u8 val, 112 u8 mask) 113 { 114 int ret; 115 u8 tmp; 116 117 /* no need for read if whole reg is written */ 118 if (mask != 0xff) { 119 ret = rtl28xxu_rd_reg(d, reg, &tmp); 120 if (ret) 121 return ret; 122 123 val &= mask; 124 tmp &= ~mask; 125 val |= tmp; 126 } 127 128 return rtl28xxu_wr_reg(d, reg, val); 129 } 130 131 /* I2C */ 132 static int rtl28xxu_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], 133 int num) 134 { 135 int ret; 136 struct dvb_usb_device *d = i2c_get_adapdata(adap); 137 struct rtl28xxu_dev *dev = d->priv; 138 struct rtl28xxu_req req; 139 140 /* 141 * It is not known which are real I2C bus xfer limits, but testing 142 * with RTL2831U + MT2060 gives max RD 24 and max WR 22 bytes. 143 * TODO: find out RTL2832U lens 144 */ 145 146 /* 147 * I2C adapter logic looks rather complicated due to fact it handles 148 * three different access methods. Those methods are; 149 * 1) integrated demod access 150 * 2) old I2C access 151 * 3) new I2C access 152 * 153 * Used method is selected in order 1, 2, 3. Method 3 can handle all 154 * requests but there is two reasons why not use it always; 155 * 1) It is most expensive, usually two USB messages are needed 156 * 2) At least RTL2831U does not support it 157 * 158 * Method 3 is needed in case of I2C write+read (typical register read) 159 * where write is more than one byte. 160 */ 161 162 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 163 return -EAGAIN; 164 165 if (num == 2 && !(msg[0].flags & I2C_M_RD) && 166 (msg[1].flags & I2C_M_RD)) { 167 if (msg[0].len > 24 || msg[1].len > 24) { 168 /* TODO: check msg[0].len max */ 169 ret = -EOPNOTSUPP; 170 goto err_mutex_unlock; 171 } else if (msg[0].addr == 0x10) { 172 /* method 1 - integrated demod */ 173 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 174 req.index = CMD_DEMOD_RD | dev->page; 175 req.size = msg[1].len; 176 req.data = &msg[1].buf[0]; 177 ret = rtl28xxu_ctrl_msg(d, &req); 178 } else if (msg[0].len < 2) { 179 /* method 2 - old I2C */ 180 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 181 req.index = CMD_I2C_RD; 182 req.size = msg[1].len; 183 req.data = &msg[1].buf[0]; 184 ret = rtl28xxu_ctrl_msg(d, &req); 185 } else { 186 /* method 3 - new I2C */ 187 req.value = (msg[0].addr << 1); 188 req.index = CMD_I2C_DA_WR; 189 req.size = msg[0].len; 190 req.data = msg[0].buf; 191 ret = rtl28xxu_ctrl_msg(d, &req); 192 if (ret) 193 goto err_mutex_unlock; 194 195 req.value = (msg[0].addr << 1); 196 req.index = CMD_I2C_DA_RD; 197 req.size = msg[1].len; 198 req.data = msg[1].buf; 199 ret = rtl28xxu_ctrl_msg(d, &req); 200 } 201 } else if (num == 1 && !(msg[0].flags & I2C_M_RD)) { 202 if (msg[0].len > 22) { 203 /* TODO: check msg[0].len max */ 204 ret = -EOPNOTSUPP; 205 goto err_mutex_unlock; 206 } else if (msg[0].addr == 0x10) { 207 /* method 1 - integrated demod */ 208 if (msg[0].buf[0] == 0x00) { 209 /* save demod page for later demod access */ 210 dev->page = msg[0].buf[1]; 211 ret = 0; 212 } else { 213 req.value = (msg[0].buf[0] << 8) | 214 (msg[0].addr << 1); 215 req.index = CMD_DEMOD_WR | dev->page; 216 req.size = msg[0].len-1; 217 req.data = &msg[0].buf[1]; 218 ret = rtl28xxu_ctrl_msg(d, &req); 219 } 220 } else if ((msg[0].len < 23) && (!dev->new_i2c_write)) { 221 /* method 2 - old I2C */ 222 req.value = (msg[0].buf[0] << 8) | (msg[0].addr << 1); 223 req.index = CMD_I2C_WR; 224 req.size = msg[0].len-1; 225 req.data = &msg[0].buf[1]; 226 ret = rtl28xxu_ctrl_msg(d, &req); 227 } else { 228 /* method 3 - new I2C */ 229 req.value = (msg[0].addr << 1); 230 req.index = CMD_I2C_DA_WR; 231 req.size = msg[0].len; 232 req.data = msg[0].buf; 233 ret = rtl28xxu_ctrl_msg(d, &req); 234 } 235 } else if (num == 1 && (msg[0].flags & I2C_M_RD)) { 236 req.value = (msg[0].addr << 1); 237 req.index = CMD_I2C_DA_RD; 238 req.size = msg[0].len; 239 req.data = msg[0].buf; 240 ret = rtl28xxu_ctrl_msg(d, &req); 241 } else { 242 ret = -EOPNOTSUPP; 243 } 244 245 err_mutex_unlock: 246 mutex_unlock(&d->i2c_mutex); 247 248 return ret ? ret : num; 249 } 250 251 static u32 rtl28xxu_i2c_func(struct i2c_adapter *adapter) 252 { 253 return I2C_FUNC_I2C; 254 } 255 256 static struct i2c_algorithm rtl28xxu_i2c_algo = { 257 .master_xfer = rtl28xxu_i2c_xfer, 258 .functionality = rtl28xxu_i2c_func, 259 }; 260 261 static int rtl2831u_read_config(struct dvb_usb_device *d) 262 { 263 struct rtl28xxu_dev *dev = d_to_priv(d); 264 int ret; 265 u8 buf[1]; 266 /* open RTL2831U/RTL2830 I2C gate */ 267 struct rtl28xxu_req req_gate_open = {0x0120, 0x0011, 0x0001, "\x08"}; 268 /* tuner probes */ 269 struct rtl28xxu_req req_mt2060 = {0x00c0, CMD_I2C_RD, 1, buf}; 270 struct rtl28xxu_req req_qt1010 = {0x0fc4, CMD_I2C_RD, 1, buf}; 271 272 dev_dbg(&d->intf->dev, "\n"); 273 274 /* 275 * RTL2831U GPIOs 276 * ========================================================= 277 * GPIO0 | tuner#0 | 0 off | 1 on | MXL5005S (?) 278 * GPIO2 | LED | 0 off | 1 on | 279 * GPIO4 | tuner#1 | 0 on | 1 off | MT2060 280 */ 281 282 /* GPIO direction */ 283 ret = rtl28xxu_wr_reg(d, SYS_GPIO_DIR, 0x0a); 284 if (ret) 285 goto err; 286 287 /* enable as output GPIO0, GPIO2, GPIO4 */ 288 ret = rtl28xxu_wr_reg(d, SYS_GPIO_OUT_EN, 0x15); 289 if (ret) 290 goto err; 291 292 /* 293 * Probe used tuner. We need to know used tuner before demod attach 294 * since there is some demod params needed to set according to tuner. 295 */ 296 297 /* demod needs some time to wake up */ 298 msleep(20); 299 300 dev->tuner_name = "NONE"; 301 302 /* open demod I2C gate */ 303 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 304 if (ret) 305 goto err; 306 307 /* check QT1010 ID(?) register; reg=0f val=2c */ 308 ret = rtl28xxu_ctrl_msg(d, &req_qt1010); 309 if (ret == 0 && buf[0] == 0x2c) { 310 dev->tuner = TUNER_RTL2830_QT1010; 311 dev->tuner_name = "QT1010"; 312 goto found; 313 } 314 315 /* open demod I2C gate */ 316 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 317 if (ret) 318 goto err; 319 320 /* check MT2060 ID register; reg=00 val=63 */ 321 ret = rtl28xxu_ctrl_msg(d, &req_mt2060); 322 if (ret == 0 && buf[0] == 0x63) { 323 dev->tuner = TUNER_RTL2830_MT2060; 324 dev->tuner_name = "MT2060"; 325 goto found; 326 } 327 328 /* assume MXL5005S */ 329 dev->tuner = TUNER_RTL2830_MXL5005S; 330 dev->tuner_name = "MXL5005S"; 331 goto found; 332 333 found: 334 dev_dbg(&d->intf->dev, "tuner=%s\n", dev->tuner_name); 335 336 return 0; 337 err: 338 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 339 return ret; 340 } 341 342 static int rtl2832u_read_config(struct dvb_usb_device *d) 343 { 344 struct rtl28xxu_dev *dev = d_to_priv(d); 345 int ret; 346 u8 buf[2]; 347 /* open RTL2832U/RTL2832 I2C gate */ 348 struct rtl28xxu_req req_gate_open = {0x0120, 0x0011, 0x0001, "\x18"}; 349 /* close RTL2832U/RTL2832 I2C gate */ 350 struct rtl28xxu_req req_gate_close = {0x0120, 0x0011, 0x0001, "\x10"}; 351 /* tuner probes */ 352 struct rtl28xxu_req req_fc0012 = {0x00c6, CMD_I2C_RD, 1, buf}; 353 struct rtl28xxu_req req_fc0013 = {0x00c6, CMD_I2C_RD, 1, buf}; 354 struct rtl28xxu_req req_mt2266 = {0x00c0, CMD_I2C_RD, 1, buf}; 355 struct rtl28xxu_req req_fc2580 = {0x01ac, CMD_I2C_RD, 1, buf}; 356 struct rtl28xxu_req req_mt2063 = {0x00c0, CMD_I2C_RD, 1, buf}; 357 struct rtl28xxu_req req_max3543 = {0x00c0, CMD_I2C_RD, 1, buf}; 358 struct rtl28xxu_req req_tua9001 = {0x7ec0, CMD_I2C_RD, 2, buf}; 359 struct rtl28xxu_req req_mxl5007t = {0xd9c0, CMD_I2C_RD, 1, buf}; 360 struct rtl28xxu_req req_e4000 = {0x02c8, CMD_I2C_RD, 1, buf}; 361 struct rtl28xxu_req req_tda18272 = {0x00c0, CMD_I2C_RD, 2, buf}; 362 struct rtl28xxu_req req_r820t = {0x0034, CMD_I2C_RD, 1, buf}; 363 struct rtl28xxu_req req_r828d = {0x0074, CMD_I2C_RD, 1, buf}; 364 struct rtl28xxu_req req_mn88472 = {0xff38, CMD_I2C_RD, 1, buf}; 365 struct rtl28xxu_req req_mn88473 = {0xff38, CMD_I2C_RD, 1, buf}; 366 struct rtl28xxu_req req_si2157 = {0x00c0, CMD_I2C_RD, 1, buf}; 367 struct rtl28xxu_req req_si2168 = {0x00c8, CMD_I2C_RD, 1, buf}; 368 369 dev_dbg(&d->intf->dev, "\n"); 370 371 /* enable GPIO3 and GPIO6 as output */ 372 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x40); 373 if (ret) 374 goto err; 375 376 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x48, 0x48); 377 if (ret) 378 goto err; 379 380 /* 381 * Probe used tuner. We need to know used tuner before demod attach 382 * since there is some demod params needed to set according to tuner. 383 */ 384 385 /* open demod I2C gate */ 386 ret = rtl28xxu_ctrl_msg(d, &req_gate_open); 387 if (ret) 388 goto err; 389 390 dev->tuner_name = "NONE"; 391 392 /* check FC0012 ID register; reg=00 val=a1 */ 393 ret = rtl28xxu_ctrl_msg(d, &req_fc0012); 394 if (ret == 0 && buf[0] == 0xa1) { 395 dev->tuner = TUNER_RTL2832_FC0012; 396 dev->tuner_name = "FC0012"; 397 goto tuner_found; 398 } 399 400 /* check FC0013 ID register; reg=00 val=a3 */ 401 ret = rtl28xxu_ctrl_msg(d, &req_fc0013); 402 if (ret == 0 && buf[0] == 0xa3) { 403 dev->tuner = TUNER_RTL2832_FC0013; 404 dev->tuner_name = "FC0013"; 405 goto tuner_found; 406 } 407 408 /* check MT2266 ID register; reg=00 val=85 */ 409 ret = rtl28xxu_ctrl_msg(d, &req_mt2266); 410 if (ret == 0 && buf[0] == 0x85) { 411 dev->tuner = TUNER_RTL2832_MT2266; 412 dev->tuner_name = "MT2266"; 413 goto tuner_found; 414 } 415 416 /* check FC2580 ID register; reg=01 val=56 */ 417 ret = rtl28xxu_ctrl_msg(d, &req_fc2580); 418 if (ret == 0 && buf[0] == 0x56) { 419 dev->tuner = TUNER_RTL2832_FC2580; 420 dev->tuner_name = "FC2580"; 421 goto tuner_found; 422 } 423 424 /* check MT2063 ID register; reg=00 val=9e || 9c */ 425 ret = rtl28xxu_ctrl_msg(d, &req_mt2063); 426 if (ret == 0 && (buf[0] == 0x9e || buf[0] == 0x9c)) { 427 dev->tuner = TUNER_RTL2832_MT2063; 428 dev->tuner_name = "MT2063"; 429 goto tuner_found; 430 } 431 432 /* check MAX3543 ID register; reg=00 val=38 */ 433 ret = rtl28xxu_ctrl_msg(d, &req_max3543); 434 if (ret == 0 && buf[0] == 0x38) { 435 dev->tuner = TUNER_RTL2832_MAX3543; 436 dev->tuner_name = "MAX3543"; 437 goto tuner_found; 438 } 439 440 /* check TUA9001 ID register; reg=7e val=2328 */ 441 ret = rtl28xxu_ctrl_msg(d, &req_tua9001); 442 if (ret == 0 && buf[0] == 0x23 && buf[1] == 0x28) { 443 dev->tuner = TUNER_RTL2832_TUA9001; 444 dev->tuner_name = "TUA9001"; 445 goto tuner_found; 446 } 447 448 /* check MXL5007R ID register; reg=d9 val=14 */ 449 ret = rtl28xxu_ctrl_msg(d, &req_mxl5007t); 450 if (ret == 0 && buf[0] == 0x14) { 451 dev->tuner = TUNER_RTL2832_MXL5007T; 452 dev->tuner_name = "MXL5007T"; 453 goto tuner_found; 454 } 455 456 /* check E4000 ID register; reg=02 val=40 */ 457 ret = rtl28xxu_ctrl_msg(d, &req_e4000); 458 if (ret == 0 && buf[0] == 0x40) { 459 dev->tuner = TUNER_RTL2832_E4000; 460 dev->tuner_name = "E4000"; 461 goto tuner_found; 462 } 463 464 /* check TDA18272 ID register; reg=00 val=c760 */ 465 ret = rtl28xxu_ctrl_msg(d, &req_tda18272); 466 if (ret == 0 && (buf[0] == 0xc7 || buf[1] == 0x60)) { 467 dev->tuner = TUNER_RTL2832_TDA18272; 468 dev->tuner_name = "TDA18272"; 469 goto tuner_found; 470 } 471 472 /* check R820T ID register; reg=00 val=69 */ 473 ret = rtl28xxu_ctrl_msg(d, &req_r820t); 474 if (ret == 0 && buf[0] == 0x69) { 475 dev->tuner = TUNER_RTL2832_R820T; 476 dev->tuner_name = "R820T"; 477 goto tuner_found; 478 } 479 480 /* check R828D ID register; reg=00 val=69 */ 481 ret = rtl28xxu_ctrl_msg(d, &req_r828d); 482 if (ret == 0 && buf[0] == 0x69) { 483 dev->tuner = TUNER_RTL2832_R828D; 484 dev->tuner_name = "R828D"; 485 goto tuner_found; 486 } 487 488 /* GPIO0 and GPIO5 to reset Si2157/Si2168 tuner and demod */ 489 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x00, 0x21); 490 if (ret) 491 goto err; 492 493 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x00, 0x21); 494 if (ret) 495 goto err; 496 497 msleep(50); 498 499 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x21, 0x21); 500 if (ret) 501 goto err; 502 503 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x21, 0x21); 504 if (ret) 505 goto err; 506 507 msleep(50); 508 509 /* check Si2157 ID register; reg=c0 val=80 */ 510 ret = rtl28xxu_ctrl_msg(d, &req_si2157); 511 if (ret == 0 && ((buf[0] & 0x80) == 0x80)) { 512 dev->tuner = TUNER_RTL2832_SI2157; 513 dev->tuner_name = "SI2157"; 514 goto tuner_found; 515 } 516 517 tuner_found: 518 dev_dbg(&d->intf->dev, "tuner=%s\n", dev->tuner_name); 519 520 /* probe slave demod */ 521 if (dev->tuner == TUNER_RTL2832_R828D) { 522 /* power on MN88472 demod on GPIO0 */ 523 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x01, 0x01); 524 if (ret) 525 goto err; 526 527 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x01); 528 if (ret) 529 goto err; 530 531 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x01, 0x01); 532 if (ret) 533 goto err; 534 535 /* check MN88472 answers */ 536 ret = rtl28xxu_ctrl_msg(d, &req_mn88472); 537 if (ret == 0 && buf[0] == 0x02) { 538 dev_dbg(&d->intf->dev, "MN88472 found\n"); 539 dev->slave_demod = SLAVE_DEMOD_MN88472; 540 goto demod_found; 541 } 542 543 ret = rtl28xxu_ctrl_msg(d, &req_mn88473); 544 if (ret == 0 && buf[0] == 0x03) { 545 dev_dbg(&d->intf->dev, "MN88473 found\n"); 546 dev->slave_demod = SLAVE_DEMOD_MN88473; 547 goto demod_found; 548 } 549 } 550 if (dev->tuner == TUNER_RTL2832_SI2157) { 551 /* check Si2168 ID register; reg=c8 val=80 */ 552 ret = rtl28xxu_ctrl_msg(d, &req_si2168); 553 if (ret == 0 && ((buf[0] & 0x80) == 0x80)) { 554 dev_dbg(&d->intf->dev, "Si2168 found\n"); 555 dev->slave_demod = SLAVE_DEMOD_SI2168; 556 goto demod_found; 557 } 558 } 559 560 demod_found: 561 /* close demod I2C gate */ 562 ret = rtl28xxu_ctrl_msg(d, &req_gate_close); 563 if (ret < 0) 564 goto err; 565 566 return 0; 567 err: 568 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 569 return ret; 570 } 571 572 static int rtl28xxu_read_config(struct dvb_usb_device *d) 573 { 574 struct rtl28xxu_dev *dev = d_to_priv(d); 575 576 if (dev->chip_id == CHIP_ID_RTL2831U) 577 return rtl2831u_read_config(d); 578 else 579 return rtl2832u_read_config(d); 580 } 581 582 static int rtl28xxu_identify_state(struct dvb_usb_device *d, const char **name) 583 { 584 struct rtl28xxu_dev *dev = d_to_priv(d); 585 int ret; 586 struct rtl28xxu_req req_demod_i2c = {0x0020, CMD_I2C_DA_RD, 0, NULL}; 587 588 dev_dbg(&d->intf->dev, "\n"); 589 590 /* 591 * Detect chip type using I2C command that is not supported 592 * by old RTL2831U. 593 */ 594 ret = rtl28xxu_ctrl_msg(d, &req_demod_i2c); 595 if (ret == -EPIPE) { 596 dev->chip_id = CHIP_ID_RTL2831U; 597 } else if (ret == 0) { 598 dev->chip_id = CHIP_ID_RTL2832U; 599 } else { 600 dev_err(&d->intf->dev, "chip type detection failed %d\n", ret); 601 goto err; 602 } 603 dev_dbg(&d->intf->dev, "chip_id=%u\n", dev->chip_id); 604 605 return WARM; 606 err: 607 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 608 return ret; 609 } 610 611 static const struct rtl2830_platform_data rtl2830_mt2060_platform_data = { 612 .clk = 28800000, 613 .spec_inv = 1, 614 .vtop = 0x20, 615 .krf = 0x04, 616 .agc_targ_val = 0x2d, 617 618 }; 619 620 static const struct rtl2830_platform_data rtl2830_qt1010_platform_data = { 621 .clk = 28800000, 622 .spec_inv = 1, 623 .vtop = 0x20, 624 .krf = 0x04, 625 .agc_targ_val = 0x2d, 626 }; 627 628 static const struct rtl2830_platform_data rtl2830_mxl5005s_platform_data = { 629 .clk = 28800000, 630 .spec_inv = 0, 631 .vtop = 0x3f, 632 .krf = 0x04, 633 .agc_targ_val = 0x3e, 634 }; 635 636 static int rtl2831u_frontend_attach(struct dvb_usb_adapter *adap) 637 { 638 struct dvb_usb_device *d = adap_to_d(adap); 639 struct rtl28xxu_dev *dev = d_to_priv(d); 640 struct rtl2830_platform_data *pdata = &dev->rtl2830_platform_data; 641 struct i2c_board_info board_info; 642 struct i2c_client *client; 643 int ret; 644 645 dev_dbg(&d->intf->dev, "\n"); 646 647 switch (dev->tuner) { 648 case TUNER_RTL2830_QT1010: 649 *pdata = rtl2830_qt1010_platform_data; 650 break; 651 case TUNER_RTL2830_MT2060: 652 *pdata = rtl2830_mt2060_platform_data; 653 break; 654 case TUNER_RTL2830_MXL5005S: 655 *pdata = rtl2830_mxl5005s_platform_data; 656 break; 657 default: 658 dev_err(&d->intf->dev, "unknown tuner %s\n", dev->tuner_name); 659 ret = -ENODEV; 660 goto err; 661 } 662 663 /* attach demodulator */ 664 memset(&board_info, 0, sizeof(board_info)); 665 strlcpy(board_info.type, "rtl2830", I2C_NAME_SIZE); 666 board_info.addr = 0x10; 667 board_info.platform_data = pdata; 668 request_module("%s", board_info.type); 669 client = i2c_new_device(&d->i2c_adap, &board_info); 670 if (client == NULL || client->dev.driver == NULL) { 671 ret = -ENODEV; 672 goto err; 673 } 674 675 if (!try_module_get(client->dev.driver->owner)) { 676 i2c_unregister_device(client); 677 ret = -ENODEV; 678 goto err; 679 } 680 681 adap->fe[0] = pdata->get_dvb_frontend(client); 682 dev->demod_i2c_adapter = pdata->get_i2c_adapter(client); 683 684 dev->i2c_client_demod = client; 685 686 return 0; 687 err: 688 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 689 return ret; 690 } 691 692 static const struct rtl2832_platform_data rtl2832_fc2580_platform_data = { 693 .clk = 28800000, 694 .tuner = TUNER_RTL2832_FC2580, 695 }; 696 697 static const struct rtl2832_platform_data rtl2832_fc0012_platform_data = { 698 .clk = 28800000, 699 .tuner = TUNER_RTL2832_FC0012 700 }; 701 702 static const struct rtl2832_platform_data rtl2832_fc0013_platform_data = { 703 .clk = 28800000, 704 .tuner = TUNER_RTL2832_FC0013 705 }; 706 707 static const struct rtl2832_platform_data rtl2832_tua9001_platform_data = { 708 .clk = 28800000, 709 .tuner = TUNER_RTL2832_TUA9001, 710 }; 711 712 static const struct rtl2832_platform_data rtl2832_e4000_platform_data = { 713 .clk = 28800000, 714 .tuner = TUNER_RTL2832_E4000, 715 }; 716 717 static const struct rtl2832_platform_data rtl2832_r820t_platform_data = { 718 .clk = 28800000, 719 .tuner = TUNER_RTL2832_R820T, 720 }; 721 722 static const struct rtl2832_platform_data rtl2832_si2157_platform_data = { 723 .clk = 28800000, 724 .tuner = TUNER_RTL2832_SI2157, 725 }; 726 727 static int rtl2832u_fc0012_tuner_callback(struct dvb_usb_device *d, 728 int cmd, int arg) 729 { 730 int ret; 731 u8 val; 732 733 dev_dbg(&d->intf->dev, "cmd=%d arg=%d\n", cmd, arg); 734 735 switch (cmd) { 736 case FC_FE_CALLBACK_VHF_ENABLE: 737 /* set output values */ 738 ret = rtl28xxu_rd_reg(d, SYS_GPIO_OUT_VAL, &val); 739 if (ret) 740 goto err; 741 742 if (arg) 743 val &= 0xbf; /* set GPIO6 low */ 744 else 745 val |= 0x40; /* set GPIO6 high */ 746 747 748 ret = rtl28xxu_wr_reg(d, SYS_GPIO_OUT_VAL, val); 749 if (ret) 750 goto err; 751 break; 752 default: 753 ret = -EINVAL; 754 goto err; 755 } 756 return 0; 757 err: 758 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 759 return ret; 760 } 761 762 static int rtl2832u_tua9001_tuner_callback(struct dvb_usb_device *d, 763 int cmd, int arg) 764 { 765 int ret; 766 u8 val; 767 768 dev_dbg(&d->intf->dev, "cmd=%d arg=%d\n", cmd, arg); 769 770 /* 771 * CEN always enabled by hardware wiring 772 * RESETN GPIO4 773 * RXEN GPIO1 774 */ 775 776 switch (cmd) { 777 case TUA9001_CMD_RESETN: 778 if (arg) 779 val = (1 << 4); 780 else 781 val = (0 << 4); 782 783 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, val, 0x10); 784 if (ret) 785 goto err; 786 break; 787 case TUA9001_CMD_RXEN: 788 if (arg) 789 val = (1 << 1); 790 else 791 val = (0 << 1); 792 793 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, val, 0x02); 794 if (ret) 795 goto err; 796 break; 797 } 798 799 return 0; 800 err: 801 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 802 return ret; 803 } 804 805 static int rtl2832u_frontend_callback(void *adapter_priv, int component, 806 int cmd, int arg) 807 { 808 struct i2c_adapter *adapter = adapter_priv; 809 struct device *parent = adapter->dev.parent; 810 struct i2c_adapter *parent_adapter; 811 struct dvb_usb_device *d; 812 struct rtl28xxu_dev *dev; 813 814 /* 815 * All tuners are connected to demod muxed I2C adapter. We have to 816 * resolve its parent adapter in order to get handle for this driver 817 * private data. That is a bit hackish solution, GPIO or direct driver 818 * callback would be better... 819 */ 820 if (parent != NULL && parent->type == &i2c_adapter_type) 821 parent_adapter = to_i2c_adapter(parent); 822 else 823 return -EINVAL; 824 825 d = i2c_get_adapdata(parent_adapter); 826 dev = d->priv; 827 828 dev_dbg(&d->intf->dev, "component=%d cmd=%d arg=%d\n", 829 component, cmd, arg); 830 831 switch (component) { 832 case DVB_FRONTEND_COMPONENT_TUNER: 833 switch (dev->tuner) { 834 case TUNER_RTL2832_FC0012: 835 return rtl2832u_fc0012_tuner_callback(d, cmd, arg); 836 case TUNER_RTL2832_TUA9001: 837 return rtl2832u_tua9001_tuner_callback(d, cmd, arg); 838 } 839 } 840 841 return 0; 842 } 843 844 static int rtl2832u_frontend_attach(struct dvb_usb_adapter *adap) 845 { 846 struct dvb_usb_device *d = adap_to_d(adap); 847 struct rtl28xxu_dev *dev = d_to_priv(d); 848 struct rtl2832_platform_data *pdata = &dev->rtl2832_platform_data; 849 struct i2c_board_info board_info; 850 struct i2c_client *client; 851 int ret; 852 853 dev_dbg(&d->intf->dev, "\n"); 854 855 switch (dev->tuner) { 856 case TUNER_RTL2832_FC0012: 857 *pdata = rtl2832_fc0012_platform_data; 858 break; 859 case TUNER_RTL2832_FC0013: 860 *pdata = rtl2832_fc0013_platform_data; 861 break; 862 case TUNER_RTL2832_FC2580: 863 *pdata = rtl2832_fc2580_platform_data; 864 break; 865 case TUNER_RTL2832_TUA9001: 866 *pdata = rtl2832_tua9001_platform_data; 867 break; 868 case TUNER_RTL2832_E4000: 869 *pdata = rtl2832_e4000_platform_data; 870 break; 871 case TUNER_RTL2832_R820T: 872 case TUNER_RTL2832_R828D: 873 *pdata = rtl2832_r820t_platform_data; 874 break; 875 case TUNER_RTL2832_SI2157: 876 *pdata = rtl2832_si2157_platform_data; 877 break; 878 default: 879 dev_err(&d->intf->dev, "unknown tuner %s\n", dev->tuner_name); 880 ret = -ENODEV; 881 goto err; 882 } 883 884 /* attach demodulator */ 885 memset(&board_info, 0, sizeof(board_info)); 886 strlcpy(board_info.type, "rtl2832", I2C_NAME_SIZE); 887 board_info.addr = 0x10; 888 board_info.platform_data = pdata; 889 request_module("%s", board_info.type); 890 client = i2c_new_device(&d->i2c_adap, &board_info); 891 if (client == NULL || client->dev.driver == NULL) { 892 ret = -ENODEV; 893 goto err; 894 } 895 896 if (!try_module_get(client->dev.driver->owner)) { 897 i2c_unregister_device(client); 898 ret = -ENODEV; 899 goto err; 900 } 901 902 adap->fe[0] = pdata->get_dvb_frontend(client); 903 dev->demod_i2c_adapter = pdata->get_i2c_adapter(client); 904 905 dev->i2c_client_demod = client; 906 907 /* set fe callback */ 908 adap->fe[0]->callback = rtl2832u_frontend_callback; 909 910 if (dev->slave_demod) { 911 struct i2c_board_info info = {}; 912 913 /* 914 * We continue on reduced mode, without DVB-T2/C, using master 915 * demod, when slave demod fails. 916 */ 917 ret = 0; 918 919 /* attach slave demodulator */ 920 if (dev->slave_demod == SLAVE_DEMOD_MN88472) { 921 struct mn88472_config mn88472_config = {}; 922 923 mn88472_config.fe = &adap->fe[1]; 924 mn88472_config.i2c_wr_max = 22, 925 strlcpy(info.type, "mn88472", I2C_NAME_SIZE); 926 mn88472_config.xtal = 20500000; 927 mn88472_config.ts_mode = SERIAL_TS_MODE; 928 mn88472_config.ts_clock = VARIABLE_TS_CLOCK; 929 info.addr = 0x18; 930 info.platform_data = &mn88472_config; 931 request_module(info.type); 932 client = i2c_new_device(&d->i2c_adap, &info); 933 if (client == NULL || client->dev.driver == NULL) { 934 dev->slave_demod = SLAVE_DEMOD_NONE; 935 goto err_slave_demod_failed; 936 } 937 938 if (!try_module_get(client->dev.driver->owner)) { 939 i2c_unregister_device(client); 940 dev->slave_demod = SLAVE_DEMOD_NONE; 941 goto err_slave_demod_failed; 942 } 943 944 dev->i2c_client_slave_demod = client; 945 } else if (dev->slave_demod == SLAVE_DEMOD_MN88473) { 946 struct mn88473_config mn88473_config = {}; 947 948 mn88473_config.fe = &adap->fe[1]; 949 mn88473_config.i2c_wr_max = 22, 950 strlcpy(info.type, "mn88473", I2C_NAME_SIZE); 951 info.addr = 0x18; 952 info.platform_data = &mn88473_config; 953 request_module(info.type); 954 client = i2c_new_device(&d->i2c_adap, &info); 955 if (client == NULL || client->dev.driver == NULL) { 956 dev->slave_demod = SLAVE_DEMOD_NONE; 957 goto err_slave_demod_failed; 958 } 959 960 if (!try_module_get(client->dev.driver->owner)) { 961 i2c_unregister_device(client); 962 dev->slave_demod = SLAVE_DEMOD_NONE; 963 goto err_slave_demod_failed; 964 } 965 966 dev->i2c_client_slave_demod = client; 967 } else { 968 struct si2168_config si2168_config = {}; 969 struct i2c_adapter *adapter; 970 971 si2168_config.i2c_adapter = &adapter; 972 si2168_config.fe = &adap->fe[1]; 973 si2168_config.ts_mode = SI2168_TS_SERIAL; 974 si2168_config.ts_clock_inv = false; 975 si2168_config.ts_clock_gapped = true; 976 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 977 info.addr = 0x64; 978 info.platform_data = &si2168_config; 979 request_module(info.type); 980 client = i2c_new_device(&d->i2c_adap, &info); 981 if (client == NULL || client->dev.driver == NULL) { 982 dev->slave_demod = SLAVE_DEMOD_NONE; 983 goto err_slave_demod_failed; 984 } 985 986 if (!try_module_get(client->dev.driver->owner)) { 987 i2c_unregister_device(client); 988 dev->slave_demod = SLAVE_DEMOD_NONE; 989 goto err_slave_demod_failed; 990 } 991 992 dev->i2c_client_slave_demod = client; 993 994 /* for Si2168 devices use only new I2C write method */ 995 dev->new_i2c_write = true; 996 } 997 } 998 return 0; 999 err_slave_demod_failed: 1000 err: 1001 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1002 return ret; 1003 } 1004 1005 static int rtl28xxu_frontend_attach(struct dvb_usb_adapter *adap) 1006 { 1007 struct rtl28xxu_dev *dev = adap_to_priv(adap); 1008 1009 if (dev->chip_id == CHIP_ID_RTL2831U) 1010 return rtl2831u_frontend_attach(adap); 1011 else 1012 return rtl2832u_frontend_attach(adap); 1013 } 1014 1015 static int rtl28xxu_frontend_detach(struct dvb_usb_adapter *adap) 1016 { 1017 struct dvb_usb_device *d = adap_to_d(adap); 1018 struct rtl28xxu_dev *dev = d_to_priv(d); 1019 struct i2c_client *client; 1020 1021 dev_dbg(&d->intf->dev, "\n"); 1022 1023 /* remove I2C slave demod */ 1024 client = dev->i2c_client_slave_demod; 1025 if (client) { 1026 module_put(client->dev.driver->owner); 1027 i2c_unregister_device(client); 1028 } 1029 1030 /* remove I2C demod */ 1031 client = dev->i2c_client_demod; 1032 if (client) { 1033 module_put(client->dev.driver->owner); 1034 i2c_unregister_device(client); 1035 } 1036 1037 return 0; 1038 } 1039 1040 static struct qt1010_config rtl28xxu_qt1010_config = { 1041 .i2c_address = 0x62, /* 0xc4 */ 1042 }; 1043 1044 static struct mt2060_config rtl28xxu_mt2060_config = { 1045 .i2c_address = 0x60, /* 0xc0 */ 1046 .clock_out = 0, 1047 }; 1048 1049 static struct mxl5005s_config rtl28xxu_mxl5005s_config = { 1050 .i2c_address = 0x63, /* 0xc6 */ 1051 .if_freq = IF_FREQ_4570000HZ, 1052 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 1053 .agc_mode = MXL_SINGLE_AGC, 1054 .tracking_filter = MXL_TF_C_H, 1055 .rssi_enable = MXL_RSSI_ENABLE, 1056 .cap_select = MXL_CAP_SEL_ENABLE, 1057 .div_out = MXL_DIV_OUT_4, 1058 .clock_out = MXL_CLOCK_OUT_DISABLE, 1059 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 1060 .top = MXL5005S_TOP_25P2, 1061 .mod_mode = MXL_DIGITAL_MODE, 1062 .if_mode = MXL_ZERO_IF, 1063 .AgcMasterByte = 0x00, 1064 }; 1065 1066 static int rtl2831u_tuner_attach(struct dvb_usb_adapter *adap) 1067 { 1068 int ret; 1069 struct dvb_usb_device *d = adap_to_d(adap); 1070 struct rtl28xxu_dev *dev = d_to_priv(d); 1071 struct dvb_frontend *fe; 1072 1073 dev_dbg(&d->intf->dev, "\n"); 1074 1075 switch (dev->tuner) { 1076 case TUNER_RTL2830_QT1010: 1077 fe = dvb_attach(qt1010_attach, adap->fe[0], 1078 dev->demod_i2c_adapter, 1079 &rtl28xxu_qt1010_config); 1080 break; 1081 case TUNER_RTL2830_MT2060: 1082 fe = dvb_attach(mt2060_attach, adap->fe[0], 1083 dev->demod_i2c_adapter, 1084 &rtl28xxu_mt2060_config, 1220); 1085 break; 1086 case TUNER_RTL2830_MXL5005S: 1087 fe = dvb_attach(mxl5005s_attach, adap->fe[0], 1088 dev->demod_i2c_adapter, 1089 &rtl28xxu_mxl5005s_config); 1090 break; 1091 default: 1092 fe = NULL; 1093 dev_err(&d->intf->dev, "unknown tuner %d\n", dev->tuner); 1094 } 1095 1096 if (fe == NULL) { 1097 ret = -ENODEV; 1098 goto err; 1099 } 1100 1101 return 0; 1102 err: 1103 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1104 return ret; 1105 } 1106 1107 static const struct fc0012_config rtl2832u_fc0012_config = { 1108 .i2c_address = 0x63, /* 0xc6 >> 1 */ 1109 .xtal_freq = FC_XTAL_28_8_MHZ, 1110 }; 1111 1112 static const struct r820t_config rtl2832u_r820t_config = { 1113 .i2c_addr = 0x1a, 1114 .xtal = 28800000, 1115 .max_i2c_msg_len = 2, 1116 .rafael_chip = CHIP_R820T, 1117 }; 1118 1119 static const struct r820t_config rtl2832u_r828d_config = { 1120 .i2c_addr = 0x3a, 1121 .xtal = 16000000, 1122 .max_i2c_msg_len = 2, 1123 .rafael_chip = CHIP_R828D, 1124 }; 1125 1126 static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap) 1127 { 1128 int ret; 1129 struct dvb_usb_device *d = adap_to_d(adap); 1130 struct rtl28xxu_dev *dev = d_to_priv(d); 1131 struct dvb_frontend *fe = NULL; 1132 struct i2c_board_info info; 1133 struct i2c_client *client; 1134 struct v4l2_subdev *subdev = NULL; 1135 struct platform_device *pdev; 1136 struct rtl2832_sdr_platform_data pdata; 1137 1138 dev_dbg(&d->intf->dev, "\n"); 1139 1140 memset(&info, 0, sizeof(struct i2c_board_info)); 1141 memset(&pdata, 0, sizeof(pdata)); 1142 1143 switch (dev->tuner) { 1144 case TUNER_RTL2832_FC0012: 1145 fe = dvb_attach(fc0012_attach, adap->fe[0], 1146 dev->demod_i2c_adapter, &rtl2832u_fc0012_config); 1147 1148 /* since fc0012 includs reading the signal strength delegate 1149 * that to the tuner driver */ 1150 adap->fe[0]->ops.read_signal_strength = 1151 adap->fe[0]->ops.tuner_ops.get_rf_strength; 1152 break; 1153 case TUNER_RTL2832_FC0013: 1154 fe = dvb_attach(fc0013_attach, adap->fe[0], 1155 dev->demod_i2c_adapter, 0xc6>>1, 0, FC_XTAL_28_8_MHZ); 1156 1157 /* fc0013 also supports signal strength reading */ 1158 adap->fe[0]->ops.read_signal_strength = 1159 adap->fe[0]->ops.tuner_ops.get_rf_strength; 1160 break; 1161 case TUNER_RTL2832_E4000: { 1162 struct e4000_config e4000_config = { 1163 .fe = adap->fe[0], 1164 .clock = 28800000, 1165 }; 1166 1167 strlcpy(info.type, "e4000", I2C_NAME_SIZE); 1168 info.addr = 0x64; 1169 info.platform_data = &e4000_config; 1170 1171 request_module(info.type); 1172 client = i2c_new_device(dev->demod_i2c_adapter, &info); 1173 if (client == NULL || client->dev.driver == NULL) 1174 break; 1175 1176 if (!try_module_get(client->dev.driver->owner)) { 1177 i2c_unregister_device(client); 1178 break; 1179 } 1180 1181 dev->i2c_client_tuner = client; 1182 subdev = i2c_get_clientdata(client); 1183 } 1184 break; 1185 case TUNER_RTL2832_FC2580: { 1186 struct fc2580_platform_data fc2580_pdata = { 1187 .dvb_frontend = adap->fe[0], 1188 }; 1189 struct i2c_board_info board_info = {}; 1190 1191 strlcpy(board_info.type, "fc2580", I2C_NAME_SIZE); 1192 board_info.addr = 0x56; 1193 board_info.platform_data = &fc2580_pdata; 1194 request_module("fc2580"); 1195 client = i2c_new_device(dev->demod_i2c_adapter, 1196 &board_info); 1197 if (client == NULL || client->dev.driver == NULL) 1198 break; 1199 if (!try_module_get(client->dev.driver->owner)) { 1200 i2c_unregister_device(client); 1201 break; 1202 } 1203 dev->i2c_client_tuner = client; 1204 subdev = fc2580_pdata.get_v4l2_subdev(client); 1205 } 1206 break; 1207 case TUNER_RTL2832_TUA9001: { 1208 struct tua9001_platform_data tua9001_pdata = { 1209 .dvb_frontend = adap->fe[0], 1210 }; 1211 struct i2c_board_info board_info = {}; 1212 1213 /* enable GPIO1 and GPIO4 as output */ 1214 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x12); 1215 if (ret) 1216 goto err; 1217 1218 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x12, 0x12); 1219 if (ret) 1220 goto err; 1221 1222 strlcpy(board_info.type, "tua9001", I2C_NAME_SIZE); 1223 board_info.addr = 0x60; 1224 board_info.platform_data = &tua9001_pdata; 1225 request_module("tua9001"); 1226 client = i2c_new_device(dev->demod_i2c_adapter, &board_info); 1227 if (client == NULL || client->dev.driver == NULL) 1228 break; 1229 if (!try_module_get(client->dev.driver->owner)) { 1230 i2c_unregister_device(client); 1231 break; 1232 } 1233 dev->i2c_client_tuner = client; 1234 break; 1235 } 1236 case TUNER_RTL2832_R820T: 1237 fe = dvb_attach(r820t_attach, adap->fe[0], 1238 dev->demod_i2c_adapter, 1239 &rtl2832u_r820t_config); 1240 1241 /* Use tuner to get the signal strength */ 1242 adap->fe[0]->ops.read_signal_strength = 1243 adap->fe[0]->ops.tuner_ops.get_rf_strength; 1244 break; 1245 case TUNER_RTL2832_R828D: 1246 fe = dvb_attach(r820t_attach, adap->fe[0], 1247 dev->demod_i2c_adapter, 1248 &rtl2832u_r828d_config); 1249 adap->fe[0]->ops.read_signal_strength = 1250 adap->fe[0]->ops.tuner_ops.get_rf_strength; 1251 1252 if (adap->fe[1]) { 1253 fe = dvb_attach(r820t_attach, adap->fe[1], 1254 dev->demod_i2c_adapter, 1255 &rtl2832u_r828d_config); 1256 adap->fe[1]->ops.read_signal_strength = 1257 adap->fe[1]->ops.tuner_ops.get_rf_strength; 1258 } 1259 break; 1260 case TUNER_RTL2832_SI2157: { 1261 struct si2157_config si2157_config = { 1262 .fe = adap->fe[0], 1263 .if_port = 0, 1264 .inversion = false, 1265 }; 1266 1267 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1268 info.addr = 0x60; 1269 info.platform_data = &si2157_config; 1270 request_module(info.type); 1271 client = i2c_new_device(&d->i2c_adap, &info); 1272 if (client == NULL || client->dev.driver == NULL) 1273 break; 1274 1275 if (!try_module_get(client->dev.driver->owner)) { 1276 i2c_unregister_device(client); 1277 break; 1278 } 1279 1280 dev->i2c_client_tuner = client; 1281 subdev = i2c_get_clientdata(client); 1282 1283 /* copy tuner ops for 2nd FE as tuner is shared */ 1284 if (adap->fe[1]) { 1285 adap->fe[1]->tuner_priv = 1286 adap->fe[0]->tuner_priv; 1287 memcpy(&adap->fe[1]->ops.tuner_ops, 1288 &adap->fe[0]->ops.tuner_ops, 1289 sizeof(struct dvb_tuner_ops)); 1290 } 1291 } 1292 break; 1293 default: 1294 dev_err(&d->intf->dev, "unknown tuner %d\n", dev->tuner); 1295 } 1296 if (fe == NULL && dev->i2c_client_tuner == NULL) { 1297 ret = -ENODEV; 1298 goto err; 1299 } 1300 1301 /* register SDR */ 1302 switch (dev->tuner) { 1303 case TUNER_RTL2832_FC2580: 1304 case TUNER_RTL2832_FC0012: 1305 case TUNER_RTL2832_FC0013: 1306 case TUNER_RTL2832_E4000: 1307 case TUNER_RTL2832_R820T: 1308 case TUNER_RTL2832_R828D: 1309 pdata.clk = dev->rtl2832_platform_data.clk; 1310 pdata.tuner = dev->tuner; 1311 pdata.i2c_client = dev->i2c_client_demod; 1312 pdata.bulk_read = dev->rtl2832_platform_data.bulk_read; 1313 pdata.bulk_write = dev->rtl2832_platform_data.bulk_write; 1314 pdata.update_bits = dev->rtl2832_platform_data.update_bits; 1315 pdata.dvb_frontend = adap->fe[0]; 1316 pdata.dvb_usb_device = d; 1317 pdata.v4l2_subdev = subdev; 1318 1319 request_module("%s", "rtl2832_sdr"); 1320 pdev = platform_device_register_data(&d->intf->dev, 1321 "rtl2832_sdr", 1322 PLATFORM_DEVID_AUTO, 1323 &pdata, sizeof(pdata)); 1324 if (IS_ERR(pdev) || pdev->dev.driver == NULL) 1325 break; 1326 dev->platform_device_sdr = pdev; 1327 break; 1328 default: 1329 dev_dbg(&d->intf->dev, "no SDR for tuner=%d\n", dev->tuner); 1330 } 1331 1332 return 0; 1333 err: 1334 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1335 return ret; 1336 } 1337 1338 static int rtl28xxu_tuner_attach(struct dvb_usb_adapter *adap) 1339 { 1340 struct rtl28xxu_dev *dev = adap_to_priv(adap); 1341 1342 if (dev->chip_id == CHIP_ID_RTL2831U) 1343 return rtl2831u_tuner_attach(adap); 1344 else 1345 return rtl2832u_tuner_attach(adap); 1346 } 1347 1348 static int rtl28xxu_tuner_detach(struct dvb_usb_adapter *adap) 1349 { 1350 struct dvb_usb_device *d = adap_to_d(adap); 1351 struct rtl28xxu_dev *dev = d_to_priv(d); 1352 struct i2c_client *client; 1353 struct platform_device *pdev; 1354 1355 dev_dbg(&d->intf->dev, "\n"); 1356 1357 /* remove platform SDR */ 1358 pdev = dev->platform_device_sdr; 1359 if (pdev) 1360 platform_device_unregister(pdev); 1361 1362 /* remove I2C tuner */ 1363 client = dev->i2c_client_tuner; 1364 if (client) { 1365 module_put(client->dev.driver->owner); 1366 i2c_unregister_device(client); 1367 } 1368 1369 return 0; 1370 } 1371 1372 static int rtl28xxu_init(struct dvb_usb_device *d) 1373 { 1374 int ret; 1375 u8 val; 1376 1377 dev_dbg(&d->intf->dev, "\n"); 1378 1379 /* init USB endpoints */ 1380 ret = rtl28xxu_rd_reg(d, USB_SYSCTL_0, &val); 1381 if (ret) 1382 goto err; 1383 1384 /* enable DMA and Full Packet Mode*/ 1385 val |= 0x09; 1386 ret = rtl28xxu_wr_reg(d, USB_SYSCTL_0, val); 1387 if (ret) 1388 goto err; 1389 1390 /* set EPA maximum packet size to 0x0200 */ 1391 ret = rtl28xxu_wr_regs(d, USB_EPA_MAXPKT, "\x00\x02\x00\x00", 4); 1392 if (ret) 1393 goto err; 1394 1395 /* change EPA FIFO length */ 1396 ret = rtl28xxu_wr_regs(d, USB_EPA_FIFO_CFG, "\x14\x00\x00\x00", 4); 1397 if (ret) 1398 goto err; 1399 1400 return ret; 1401 err: 1402 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1403 return ret; 1404 } 1405 1406 static int rtl2831u_power_ctrl(struct dvb_usb_device *d, int onoff) 1407 { 1408 int ret; 1409 u8 gpio, sys0, epa_ctl[2]; 1410 1411 dev_dbg(&d->intf->dev, "onoff=%d\n", onoff); 1412 1413 /* demod adc */ 1414 ret = rtl28xxu_rd_reg(d, SYS_SYS0, &sys0); 1415 if (ret) 1416 goto err; 1417 1418 /* tuner power, read GPIOs */ 1419 ret = rtl28xxu_rd_reg(d, SYS_GPIO_OUT_VAL, &gpio); 1420 if (ret) 1421 goto err; 1422 1423 dev_dbg(&d->intf->dev, "RD SYS0=%02x GPIO_OUT_VAL=%02x\n", sys0, gpio); 1424 1425 if (onoff) { 1426 gpio |= 0x01; /* GPIO0 = 1 */ 1427 gpio &= (~0x10); /* GPIO4 = 0 */ 1428 gpio |= 0x04; /* GPIO2 = 1, LED on */ 1429 sys0 = sys0 & 0x0f; 1430 sys0 |= 0xe0; 1431 epa_ctl[0] = 0x00; /* clear stall */ 1432 epa_ctl[1] = 0x00; /* clear reset */ 1433 } else { 1434 gpio &= (~0x01); /* GPIO0 = 0 */ 1435 gpio |= 0x10; /* GPIO4 = 1 */ 1436 gpio &= (~0x04); /* GPIO2 = 1, LED off */ 1437 sys0 = sys0 & (~0xc0); 1438 epa_ctl[0] = 0x10; /* set stall */ 1439 epa_ctl[1] = 0x02; /* set reset */ 1440 } 1441 1442 dev_dbg(&d->intf->dev, "WR SYS0=%02x GPIO_OUT_VAL=%02x\n", sys0, gpio); 1443 1444 /* demod adc */ 1445 ret = rtl28xxu_wr_reg(d, SYS_SYS0, sys0); 1446 if (ret) 1447 goto err; 1448 1449 /* tuner power, write GPIOs */ 1450 ret = rtl28xxu_wr_reg(d, SYS_GPIO_OUT_VAL, gpio); 1451 if (ret) 1452 goto err; 1453 1454 /* streaming EP: stall & reset */ 1455 ret = rtl28xxu_wr_regs(d, USB_EPA_CTL, epa_ctl, 2); 1456 if (ret) 1457 goto err; 1458 1459 if (onoff) 1460 usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81)); 1461 1462 return ret; 1463 err: 1464 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1465 return ret; 1466 } 1467 1468 static int rtl2832u_power_ctrl(struct dvb_usb_device *d, int onoff) 1469 { 1470 int ret; 1471 1472 dev_dbg(&d->intf->dev, "onoff=%d\n", onoff); 1473 1474 if (onoff) { 1475 /* GPIO3=1, GPIO4=0 */ 1476 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x08, 0x18); 1477 if (ret) 1478 goto err; 1479 1480 /* suspend? */ 1481 ret = rtl28xxu_wr_reg_mask(d, SYS_DEMOD_CTL1, 0x00, 0x10); 1482 if (ret) 1483 goto err; 1484 1485 /* enable PLL */ 1486 ret = rtl28xxu_wr_reg_mask(d, SYS_DEMOD_CTL, 0x80, 0x80); 1487 if (ret) 1488 goto err; 1489 1490 /* disable reset */ 1491 ret = rtl28xxu_wr_reg_mask(d, SYS_DEMOD_CTL, 0x20, 0x20); 1492 if (ret) 1493 goto err; 1494 1495 /* streaming EP: clear stall & reset */ 1496 ret = rtl28xxu_wr_regs(d, USB_EPA_CTL, "\x00\x00", 2); 1497 if (ret) 1498 goto err; 1499 1500 ret = usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81)); 1501 if (ret) 1502 goto err; 1503 } else { 1504 /* GPIO4=1 */ 1505 ret = rtl28xxu_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x10, 0x10); 1506 if (ret) 1507 goto err; 1508 1509 /* disable PLL */ 1510 ret = rtl28xxu_wr_reg_mask(d, SYS_DEMOD_CTL, 0x00, 0x80); 1511 if (ret) 1512 goto err; 1513 1514 /* streaming EP: set stall & reset */ 1515 ret = rtl28xxu_wr_regs(d, USB_EPA_CTL, "\x10\x02", 2); 1516 if (ret) 1517 goto err; 1518 } 1519 1520 return ret; 1521 err: 1522 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1523 return ret; 1524 } 1525 1526 static int rtl28xxu_power_ctrl(struct dvb_usb_device *d, int onoff) 1527 { 1528 struct rtl28xxu_dev *dev = d_to_priv(d); 1529 1530 if (dev->chip_id == CHIP_ID_RTL2831U) 1531 return rtl2831u_power_ctrl(d, onoff); 1532 else 1533 return rtl2832u_power_ctrl(d, onoff); 1534 } 1535 1536 static int rtl28xxu_frontend_ctrl(struct dvb_frontend *fe, int onoff) 1537 { 1538 struct dvb_usb_device *d = fe_to_d(fe); 1539 struct rtl28xxu_dev *dev = fe_to_priv(fe); 1540 struct rtl2832_platform_data *pdata = &dev->rtl2832_platform_data; 1541 int ret; 1542 u8 val; 1543 1544 dev_dbg(&d->intf->dev, "fe=%d onoff=%d\n", fe->id, onoff); 1545 1546 if (dev->chip_id == CHIP_ID_RTL2831U) 1547 return 0; 1548 1549 /* control internal demod ADC */ 1550 if (fe->id == 0 && onoff) 1551 val = 0x48; /* enable ADC */ 1552 else 1553 val = 0x00; /* disable ADC */ 1554 1555 ret = rtl28xxu_wr_reg_mask(d, SYS_DEMOD_CTL, val, 0x48); 1556 if (ret) 1557 goto err; 1558 1559 /* bypass slave demod TS through master demod */ 1560 if (fe->id == 1 && onoff) { 1561 ret = pdata->enable_slave_ts(dev->i2c_client_demod); 1562 if (ret) 1563 goto err; 1564 } 1565 1566 return 0; 1567 err: 1568 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1569 return ret; 1570 } 1571 1572 #if IS_ENABLED(CONFIG_RC_CORE) 1573 static int rtl2831u_rc_query(struct dvb_usb_device *d) 1574 { 1575 int ret, i; 1576 struct rtl28xxu_dev *dev = d->priv; 1577 u8 buf[5]; 1578 u32 rc_code; 1579 struct rtl28xxu_reg_val rc_nec_tab[] = { 1580 { 0x3033, 0x80 }, 1581 { 0x3020, 0x43 }, 1582 { 0x3021, 0x16 }, 1583 { 0x3022, 0x16 }, 1584 { 0x3023, 0x5a }, 1585 { 0x3024, 0x2d }, 1586 { 0x3025, 0x16 }, 1587 { 0x3026, 0x01 }, 1588 { 0x3028, 0xb0 }, 1589 { 0x3029, 0x04 }, 1590 { 0x302c, 0x88 }, 1591 { 0x302e, 0x13 }, 1592 { 0x3030, 0xdf }, 1593 { 0x3031, 0x05 }, 1594 }; 1595 1596 /* init remote controller */ 1597 if (!dev->rc_active) { 1598 for (i = 0; i < ARRAY_SIZE(rc_nec_tab); i++) { 1599 ret = rtl28xxu_wr_reg(d, rc_nec_tab[i].reg, 1600 rc_nec_tab[i].val); 1601 if (ret) 1602 goto err; 1603 } 1604 dev->rc_active = true; 1605 } 1606 1607 ret = rtl28xxu_rd_regs(d, SYS_IRRC_RP, buf, 5); 1608 if (ret) 1609 goto err; 1610 1611 if (buf[4] & 0x01) { 1612 if (buf[2] == (u8) ~buf[3]) { 1613 if (buf[0] == (u8) ~buf[1]) { 1614 /* NEC standard (16 bit) */ 1615 rc_code = RC_SCANCODE_NEC(buf[0], buf[2]); 1616 } else { 1617 /* NEC extended (24 bit) */ 1618 rc_code = RC_SCANCODE_NECX(buf[0] << 8 | buf[1], 1619 buf[2]); 1620 } 1621 } else { 1622 /* NEC full (32 bit) */ 1623 rc_code = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 | 1624 buf[2] << 8 | buf[3]); 1625 } 1626 1627 rc_keydown(d->rc_dev, RC_TYPE_NEC, rc_code, 0); 1628 1629 ret = rtl28xxu_wr_reg(d, SYS_IRRC_SR, 1); 1630 if (ret) 1631 goto err; 1632 1633 /* repeated intentionally to avoid extra keypress */ 1634 ret = rtl28xxu_wr_reg(d, SYS_IRRC_SR, 1); 1635 if (ret) 1636 goto err; 1637 } 1638 1639 return ret; 1640 err: 1641 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1642 return ret; 1643 } 1644 1645 static int rtl2831u_get_rc_config(struct dvb_usb_device *d, 1646 struct dvb_usb_rc *rc) 1647 { 1648 rc->map_name = RC_MAP_EMPTY; 1649 rc->allowed_protos = RC_BIT_NEC; 1650 rc->query = rtl2831u_rc_query; 1651 rc->interval = 400; 1652 1653 return 0; 1654 } 1655 1656 static int rtl2832u_rc_query(struct dvb_usb_device *d) 1657 { 1658 int ret, i, len; 1659 struct rtl28xxu_dev *dev = d->priv; 1660 struct ir_raw_event ev; 1661 u8 buf[128]; 1662 static const struct rtl28xxu_reg_val_mask refresh_tab[] = { 1663 {IR_RX_IF, 0x03, 0xff}, 1664 {IR_RX_BUF_CTRL, 0x80, 0xff}, 1665 {IR_RX_CTRL, 0x80, 0xff}, 1666 }; 1667 1668 /* init remote controller */ 1669 if (!dev->rc_active) { 1670 static const struct rtl28xxu_reg_val_mask init_tab[] = { 1671 {SYS_DEMOD_CTL1, 0x00, 0x04}, 1672 {SYS_DEMOD_CTL1, 0x00, 0x08}, 1673 {USB_CTRL, 0x20, 0x20}, 1674 {SYS_GPIO_DIR, 0x00, 0x08}, 1675 {SYS_GPIO_OUT_EN, 0x08, 0x08}, 1676 {SYS_GPIO_OUT_VAL, 0x08, 0x08}, 1677 {IR_MAX_DURATION0, 0xd0, 0xff}, 1678 {IR_MAX_DURATION1, 0x07, 0xff}, 1679 {IR_IDLE_LEN0, 0xc0, 0xff}, 1680 {IR_IDLE_LEN1, 0x00, 0xff}, 1681 {IR_GLITCH_LEN, 0x03, 0xff}, 1682 {IR_RX_CLK, 0x09, 0xff}, 1683 {IR_RX_CFG, 0x1c, 0xff}, 1684 {IR_MAX_H_TOL_LEN, 0x1e, 0xff}, 1685 {IR_MAX_L_TOL_LEN, 0x1e, 0xff}, 1686 {IR_RX_CTRL, 0x80, 0xff}, 1687 }; 1688 1689 for (i = 0; i < ARRAY_SIZE(init_tab); i++) { 1690 ret = rtl28xxu_wr_reg_mask(d, init_tab[i].reg, 1691 init_tab[i].val, init_tab[i].mask); 1692 if (ret) 1693 goto err; 1694 } 1695 1696 dev->rc_active = true; 1697 } 1698 1699 ret = rtl28xxu_rd_reg(d, IR_RX_IF, &buf[0]); 1700 if (ret) 1701 goto err; 1702 1703 if (buf[0] != 0x83) 1704 goto exit; 1705 1706 ret = rtl28xxu_rd_reg(d, IR_RX_BC, &buf[0]); 1707 if (ret) 1708 goto err; 1709 1710 len = buf[0]; 1711 1712 /* read raw code from hw */ 1713 ret = rtl28xxu_rd_regs(d, IR_RX_BUF, buf, len); 1714 if (ret) 1715 goto err; 1716 1717 /* let hw receive new code */ 1718 for (i = 0; i < ARRAY_SIZE(refresh_tab); i++) { 1719 ret = rtl28xxu_wr_reg_mask(d, refresh_tab[i].reg, 1720 refresh_tab[i].val, refresh_tab[i].mask); 1721 if (ret) 1722 goto err; 1723 } 1724 1725 /* pass data to Kernel IR decoder */ 1726 init_ir_raw_event(&ev); 1727 1728 for (i = 0; i < len; i++) { 1729 ev.pulse = buf[i] >> 7; 1730 ev.duration = 50800 * (buf[i] & 0x7f); 1731 ir_raw_event_store_with_filter(d->rc_dev, &ev); 1732 } 1733 1734 /* 'flush' ir_raw_event_store_with_filter() */ 1735 ir_raw_event_set_idle(d->rc_dev, true); 1736 ir_raw_event_handle(d->rc_dev); 1737 exit: 1738 return ret; 1739 err: 1740 dev_dbg(&d->intf->dev, "failed=%d\n", ret); 1741 return ret; 1742 } 1743 1744 static int rtl2832u_get_rc_config(struct dvb_usb_device *d, 1745 struct dvb_usb_rc *rc) 1746 { 1747 /* disable IR interrupts in order to avoid SDR sample loss */ 1748 if (rtl28xxu_disable_rc) 1749 return rtl28xxu_wr_reg(d, IR_RX_IE, 0x00); 1750 1751 /* load empty to enable rc */ 1752 if (!rc->map_name) 1753 rc->map_name = RC_MAP_EMPTY; 1754 rc->allowed_protos = RC_BIT_ALL; 1755 rc->driver_type = RC_DRIVER_IR_RAW; 1756 rc->query = rtl2832u_rc_query; 1757 rc->interval = 200; 1758 1759 return 0; 1760 } 1761 1762 static int rtl28xxu_get_rc_config(struct dvb_usb_device *d, 1763 struct dvb_usb_rc *rc) 1764 { 1765 struct rtl28xxu_dev *dev = d_to_priv(d); 1766 1767 if (dev->chip_id == CHIP_ID_RTL2831U) 1768 return rtl2831u_get_rc_config(d, rc); 1769 else 1770 return rtl2832u_get_rc_config(d, rc); 1771 } 1772 #else 1773 #define rtl28xxu_get_rc_config NULL 1774 #endif 1775 1776 static int rtl28xxu_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff) 1777 { 1778 struct rtl28xxu_dev *dev = adap_to_priv(adap); 1779 1780 if (dev->chip_id == CHIP_ID_RTL2831U) { 1781 struct rtl2830_platform_data *pdata = &dev->rtl2830_platform_data; 1782 1783 return pdata->pid_filter_ctrl(adap->fe[0], onoff); 1784 } else { 1785 struct rtl2832_platform_data *pdata = &dev->rtl2832_platform_data; 1786 1787 return pdata->pid_filter_ctrl(adap->fe[0], onoff); 1788 } 1789 } 1790 1791 static int rtl28xxu_pid_filter(struct dvb_usb_adapter *adap, int index, 1792 u16 pid, int onoff) 1793 { 1794 struct rtl28xxu_dev *dev = adap_to_priv(adap); 1795 1796 if (dev->chip_id == CHIP_ID_RTL2831U) { 1797 struct rtl2830_platform_data *pdata = &dev->rtl2830_platform_data; 1798 1799 return pdata->pid_filter(adap->fe[0], index, pid, onoff); 1800 } else { 1801 struct rtl2832_platform_data *pdata = &dev->rtl2832_platform_data; 1802 1803 return pdata->pid_filter(adap->fe[0], index, pid, onoff); 1804 } 1805 } 1806 1807 static const struct dvb_usb_device_properties rtl28xxu_props = { 1808 .driver_name = KBUILD_MODNAME, 1809 .owner = THIS_MODULE, 1810 .adapter_nr = adapter_nr, 1811 .size_of_priv = sizeof(struct rtl28xxu_dev), 1812 1813 .identify_state = rtl28xxu_identify_state, 1814 .power_ctrl = rtl28xxu_power_ctrl, 1815 .frontend_ctrl = rtl28xxu_frontend_ctrl, 1816 .i2c_algo = &rtl28xxu_i2c_algo, 1817 .read_config = rtl28xxu_read_config, 1818 .frontend_attach = rtl28xxu_frontend_attach, 1819 .frontend_detach = rtl28xxu_frontend_detach, 1820 .tuner_attach = rtl28xxu_tuner_attach, 1821 .tuner_detach = rtl28xxu_tuner_detach, 1822 .init = rtl28xxu_init, 1823 .get_rc_config = rtl28xxu_get_rc_config, 1824 1825 .num_adapters = 1, 1826 .adapter = { 1827 { 1828 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 1829 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 1830 1831 .pid_filter_count = 32, 1832 .pid_filter_ctrl = rtl28xxu_pid_filter_ctrl, 1833 .pid_filter = rtl28xxu_pid_filter, 1834 1835 .stream = DVB_USB_STREAM_BULK(0x81, 6, 8 * 512), 1836 }, 1837 }, 1838 }; 1839 1840 static const struct usb_device_id rtl28xxu_id_table[] = { 1841 /* RTL2831U devices: */ 1842 { DVB_USB_DEVICE(USB_VID_REALTEK, USB_PID_REALTEK_RTL2831U, 1843 &rtl28xxu_props, "Realtek RTL2831U reference design", NULL) }, 1844 { DVB_USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_FREECOM_DVBT, 1845 &rtl28xxu_props, "Freecom USB2.0 DVB-T", NULL) }, 1846 { DVB_USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_FREECOM_DVBT_2, 1847 &rtl28xxu_props, "Freecom USB2.0 DVB-T", NULL) }, 1848 1849 /* RTL2832U devices: */ 1850 { DVB_USB_DEVICE(USB_VID_REALTEK, 0x2832, 1851 &rtl28xxu_props, "Realtek RTL2832U reference design", NULL) }, 1852 { DVB_USB_DEVICE(USB_VID_REALTEK, 0x2838, 1853 &rtl28xxu_props, "Realtek RTL2832U reference design", NULL) }, 1854 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_BLACK_REV1, 1855 &rtl28xxu_props, "TerraTec Cinergy T Stick Black", RC_MAP_TERRATEC_SLIM) }, 1856 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_DELOCK_USB2_DVBT, 1857 &rtl28xxu_props, "G-Tek Electronics Group Lifeview LV5TDLX DVB-T", NULL) }, 1858 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK, 1859 &rtl28xxu_props, "TerraTec NOXON DAB Stick", NULL) }, 1860 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK_REV2, 1861 &rtl28xxu_props, "TerraTec NOXON DAB Stick (rev 2)", NULL) }, 1862 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK_REV3, 1863 &rtl28xxu_props, "TerraTec NOXON DAB Stick (rev 3)", NULL) }, 1864 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TREKSTOR_TERRES_2_0, 1865 &rtl28xxu_props, "Trekstor DVB-T Stick Terres 2.0", NULL) }, 1866 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1101, 1867 &rtl28xxu_props, "Dexatek DK DVB-T Dongle", NULL) }, 1868 { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6680, 1869 &rtl28xxu_props, "DigitalNow Quad DVB-T Receiver", NULL) }, 1870 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_MINID, 1871 &rtl28xxu_props, "Leadtek Winfast DTV Dongle Mini D", NULL) }, 1872 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS_PLUS, 1873 &rtl28xxu_props, "Leadtek WinFast DTV2000DS Plus", RC_MAP_LEADTEK_Y04G0051) }, 1874 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d3, 1875 &rtl28xxu_props, "TerraTec Cinergy T Stick RC (Rev. 3)", NULL) }, 1876 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1102, 1877 &rtl28xxu_props, "Dexatek DK mini DVB-T Dongle", NULL) }, 1878 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d7, 1879 &rtl28xxu_props, "TerraTec Cinergy T Stick+", NULL) }, 1880 { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd3a8, 1881 &rtl28xxu_props, "ASUS My Cinema-U3100Mini Plus V2", NULL) }, 1882 { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd393, 1883 &rtl28xxu_props, "GIGABYTE U7300", NULL) }, 1884 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1104, 1885 &rtl28xxu_props, "MSI DIGIVOX Micro HD", NULL) }, 1886 { DVB_USB_DEVICE(USB_VID_COMPRO, 0x0620, 1887 &rtl28xxu_props, "Compro VideoMate U620F", NULL) }, 1888 { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd394, 1889 &rtl28xxu_props, "MaxMedia HU394-T", NULL) }, 1890 { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a03, 1891 &rtl28xxu_props, "Leadtek WinFast DTV Dongle mini", NULL) }, 1892 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_CPYTO_REDI_PC50A, 1893 &rtl28xxu_props, "Crypto ReDi PC 50 A", NULL) }, 1894 { DVB_USB_DEVICE(USB_VID_KYE, 0x707f, 1895 &rtl28xxu_props, "Genius TVGo DVB-T03", NULL) }, 1896 { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd395, 1897 &rtl28xxu_props, "Peak DVB-T USB", NULL) }, 1898 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20_RTL2832U, 1899 &rtl28xxu_props, "Sveon STV20", NULL) }, 1900 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV21, 1901 &rtl28xxu_props, "Sveon STV21", NULL) }, 1902 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV27, 1903 &rtl28xxu_props, "Sveon STV27", NULL) }, 1904 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TURBOX_DTT_2000, 1905 &rtl28xxu_props, "TURBO-X Pure TV Tuner DTT-2000", NULL) }, 1906 1907 /* RTL2832P devices: */ 1908 { DVB_USB_DEVICE(USB_VID_HANFTEK, 0x0131, 1909 &rtl28xxu_props, "Astrometa DVB-T2", NULL) }, 1910 { DVB_USB_DEVICE(0x5654, 0xca42, 1911 &rtl28xxu_props, "GoTView MasterHD 3", NULL) }, 1912 { } 1913 }; 1914 MODULE_DEVICE_TABLE(usb, rtl28xxu_id_table); 1915 1916 static struct usb_driver rtl28xxu_usb_driver = { 1917 .name = KBUILD_MODNAME, 1918 .id_table = rtl28xxu_id_table, 1919 .probe = dvb_usbv2_probe, 1920 .disconnect = dvb_usbv2_disconnect, 1921 .suspend = dvb_usbv2_suspend, 1922 .resume = dvb_usbv2_resume, 1923 .reset_resume = dvb_usbv2_reset_resume, 1924 .no_dynamic_id = 1, 1925 .soft_unbind = 1, 1926 }; 1927 1928 module_usb_driver(rtl28xxu_usb_driver); 1929 1930 MODULE_DESCRIPTION("Realtek RTL28xxU DVB USB driver"); 1931 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1932 MODULE_AUTHOR("Thomas Mair <thomas.mair86@googlemail.com>"); 1933 MODULE_LICENSE("GPL"); 1934