1 // SPDX-License-Identifier: GPL-2.0-only 2 /* DVB USB compliant linux driver for mobile DVB-T USB devices based on 3 * reference designs made by DiBcom (http://www.dibcom.fr/) (DiB3000M-B) 4 * 5 * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@posteo.de) 6 * 7 * based on GPL code from DiBcom, which has 8 * Copyright (C) 2004 Amaury Demol for DiBcom 9 * 10 * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information 11 */ 12 #include "dibusb.h" 13 14 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 15 16 static int dib3000mb_i2c_gate_ctrl(struct dvb_frontend* fe, int enable) 17 { 18 struct dvb_usb_adapter *adap = fe->dvb->priv; 19 struct dibusb_state *st = adap->priv; 20 21 return st->ops.tuner_pass_ctrl(fe, enable, st->tuner_addr); 22 } 23 24 static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_adapter *adap) 25 { 26 struct dib3000_config demod_cfg; 27 struct dibusb_state *st = adap->priv; 28 29 demod_cfg.demod_address = 0x8; 30 31 adap->fe_adap[0].fe = dvb_attach(dib3000mb_attach, &demod_cfg, 32 &adap->dev->i2c_adap, &st->ops); 33 if ((adap->fe_adap[0].fe) == NULL) 34 return -ENODEV; 35 36 adap->fe_adap[0].fe->ops.i2c_gate_ctrl = dib3000mb_i2c_gate_ctrl; 37 38 return 0; 39 } 40 41 static int dibusb_thomson_tuner_attach(struct dvb_usb_adapter *adap) 42 { 43 struct dibusb_state *st = adap->priv; 44 45 st->tuner_addr = 0x61; 46 47 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, &adap->dev->i2c_adap, 48 DVB_PLL_TUA6010XS); 49 return 0; 50 } 51 52 static int dibusb_panasonic_tuner_attach(struct dvb_usb_adapter *adap) 53 { 54 struct dibusb_state *st = adap->priv; 55 56 st->tuner_addr = 0x60; 57 58 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap, 59 DVB_PLL_TDA665X); 60 return 0; 61 } 62 63 /* Some of the Artec 1.1 device aren't equipped with the default tuner 64 * (Thomson Cable), but with a Panasonic ENV77H11D5. This function figures 65 * this out. */ 66 static int dibusb_tuner_probe_and_attach(struct dvb_usb_adapter *adap) 67 { 68 u8 b[2] = { 0,0 }, b2[1]; 69 int ret = 0; 70 struct i2c_msg msg[2] = { 71 { .flags = 0, .buf = b, .len = 2 }, 72 { .flags = I2C_M_RD, .buf = b2, .len = 1 }, 73 }; 74 struct dibusb_state *st = adap->priv; 75 76 /* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */ 77 msg[0].addr = msg[1].addr = st->tuner_addr = 0x60; 78 79 if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl) 80 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1); 81 82 if (i2c_transfer(&adap->dev->i2c_adap, msg, 2) != 2) { 83 err("tuner i2c write failed."); 84 return -EREMOTEIO; 85 } 86 87 if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl) 88 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0); 89 90 if (b2[0] == 0xfe) { 91 info("This device has the Thomson Cable onboard. Which is default."); 92 ret = dibusb_thomson_tuner_attach(adap); 93 } else { 94 info("This device has the Panasonic ENV77H11D5 onboard."); 95 ret = dibusb_panasonic_tuner_attach(adap); 96 } 97 98 return ret; 99 } 100 101 /* USB Driver stuff */ 102 static struct dvb_usb_device_properties dibusb1_1_properties; 103 static struct dvb_usb_device_properties dibusb1_1_an2235_properties; 104 static struct dvb_usb_device_properties dibusb2_0b_properties; 105 static struct dvb_usb_device_properties artec_t1_usb2_properties; 106 107 static int dibusb_probe(struct usb_interface *intf, 108 const struct usb_device_id *id) 109 { 110 if (0 == dvb_usb_device_init(intf, &dibusb1_1_properties, 111 THIS_MODULE, NULL, adapter_nr) || 112 0 == dvb_usb_device_init(intf, &dibusb1_1_an2235_properties, 113 THIS_MODULE, NULL, adapter_nr) || 114 0 == dvb_usb_device_init(intf, &dibusb2_0b_properties, 115 THIS_MODULE, NULL, adapter_nr) || 116 0 == dvb_usb_device_init(intf, &artec_t1_usb2_properties, 117 THIS_MODULE, NULL, adapter_nr)) 118 return 0; 119 120 return -EINVAL; 121 } 122 123 /* do not change the order of the ID table */ 124 enum { 125 WIDEVIEW_DVBT_USB_COLD, 126 WIDEVIEW_DVBT_USB_WARM, 127 COMPRO_DVBU2000_COLD, 128 COMPRO_DVBU2000_WARM, 129 COMPRO_DVBU2000_UNK_COLD, 130 DIBCOM_MOD3000_COLD, 131 DIBCOM_MOD3000_WARM, 132 EMPIA_VSTREAM_COLD, 133 EMPIA_VSTREAM_WARM, 134 GRANDTEC_DVBT_USB_COLD, 135 GRANDTEC_DVBT_USB_WARM, 136 GRANDTEC_MOD3000_COLD, 137 GRANDTEC_MOD3000_WARM, 138 UNK_HYPER_PALTEK_COLD, 139 UNK_HYPER_PALTEK_WARM, 140 VISIONPLUS_VP7041_COLD, 141 VISIONPLUS_VP7041_WARM, 142 TWINHAN_VP7041_COLD, 143 TWINHAN_VP7041_WARM, 144 ULTIMA_TVBOX_COLD, 145 ULTIMA_TVBOX_WARM, 146 ULTIMA_TVBOX_AN2235_COLD, 147 ULTIMA_TVBOX_AN2235_WARM, 148 ADSTECH_USB2_COLD, 149 ADSTECH_USB2_WARM, 150 KYE_DVB_T_COLD, 151 KYE_DVB_T_WARM, 152 KWORLD_VSTREAM_COLD, 153 ULTIMA_TVBOX_USB2_COLD, 154 ULTIMA_TVBOX_USB2_WARM, 155 ULTIMA_TVBOX_ANCHOR_COLD, 156 }; 157 158 static struct usb_device_id dibusb_dib3000mb_table[] = { 159 DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_COLD), 160 DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_WARM), 161 DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_COLD), 162 DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_WARM), 163 DVB_USB_DEV(COMPRO_UNK, COMPRO_DVBU2000_UNK_COLD), 164 DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_COLD), 165 DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_WARM), 166 DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_COLD), 167 DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_WARM), 168 DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_COLD), 169 DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_WARM), 170 DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_COLD), 171 DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_WARM), 172 DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_COLD), 173 DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_WARM), 174 DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_COLD), 175 DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_WARM), 176 DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_COLD), 177 DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_WARM), 178 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_COLD), 179 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_WARM), 180 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_COLD), 181 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_WARM), 182 DVB_USB_DEV(ADSTECH, ADSTECH_USB2_COLD), 183 DVB_USB_DEV(ADSTECH, ADSTECH_USB2_WARM), 184 DVB_USB_DEV(KYE, KYE_DVB_T_COLD), 185 DVB_USB_DEV(KYE, KYE_DVB_T_WARM), 186 DVB_USB_DEV(KWORLD, KWORLD_VSTREAM_COLD), 187 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_COLD), 188 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_WARM), 189 #ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY 190 DVB_USB_DEV(ANCHOR, ULTIMA_TVBOX_ANCHOR_COLD), 191 #endif 192 { } 193 }; 194 195 MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table); 196 197 static struct dvb_usb_device_properties dibusb1_1_properties = { 198 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 199 200 .usb_ctrl = CYPRESS_AN2135, 201 202 .firmware = "dvb-usb-dibusb-5.0.0.11.fw", 203 204 .num_adapters = 1, 205 .adapter = { 206 { 207 .num_frontends = 1, 208 .fe = {{ 209 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 210 .pid_filter_count = 16, 211 212 .streaming_ctrl = dibusb_streaming_ctrl, 213 .pid_filter = dibusb_pid_filter, 214 .pid_filter_ctrl = dibusb_pid_filter_ctrl, 215 .frontend_attach = dibusb_dib3000mb_frontend_attach, 216 .tuner_attach = dibusb_tuner_probe_and_attach, 217 218 /* parameter for the MPEG2-data transfer */ 219 .stream = { 220 .type = USB_BULK, 221 .count = 7, 222 .endpoint = 0x02, 223 .u = { 224 .bulk = { 225 .buffersize = 4096, 226 } 227 } 228 }, 229 }}, 230 .size_of_priv = sizeof(struct dibusb_state), 231 } 232 }, 233 234 .power_ctrl = dibusb_power_ctrl, 235 236 .rc.legacy = { 237 .rc_interval = DEFAULT_RC_INTERVAL, 238 .rc_map_table = rc_map_dibusb_table, 239 .rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ 240 .rc_query = dibusb_rc_query, 241 }, 242 243 .i2c_algo = &dibusb_i2c_algo, 244 245 .generic_bulk_ctrl_endpoint = 0x01, 246 247 .num_device_descs = 9, 248 .devices = { 249 { "AVerMedia AverTV DVBT USB1.1", 250 { &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_COLD], NULL }, 251 { &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_WARM], NULL }, 252 }, 253 { "Compro Videomate DVB-U2000 - DVB-T USB1.1 (please confirm to linux-dvb)", 254 { &dibusb_dib3000mb_table[COMPRO_DVBU2000_COLD], &dibusb_dib3000mb_table[COMPRO_DVBU2000_UNK_COLD], NULL}, 255 { &dibusb_dib3000mb_table[COMPRO_DVBU2000_WARM], NULL }, 256 }, 257 { "DiBcom USB1.1 DVB-T reference design (MOD3000)", 258 { &dibusb_dib3000mb_table[DIBCOM_MOD3000_COLD], NULL }, 259 { &dibusb_dib3000mb_table[DIBCOM_MOD3000_WARM], NULL }, 260 }, 261 { "KWorld V-Stream XPERT DTV - DVB-T USB1.1", 262 { &dibusb_dib3000mb_table[EMPIA_VSTREAM_COLD], NULL }, 263 { &dibusb_dib3000mb_table[EMPIA_VSTREAM_WARM], NULL }, 264 }, 265 { "Grandtec USB1.1 DVB-T", 266 { &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_COLD], &dibusb_dib3000mb_table[GRANDTEC_MOD3000_COLD], NULL }, 267 { &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_WARM], &dibusb_dib3000mb_table[GRANDTEC_MOD3000_WARM], NULL }, 268 }, 269 { "Unknown USB1.1 DVB-T device ???? please report the name to the author", 270 { &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_COLD], NULL }, 271 { &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_WARM], NULL }, 272 }, 273 { "TwinhanDTV USB-Ter USB1.1 / Magic Box I / HAMA USB1.1 DVB-T device", 274 { &dibusb_dib3000mb_table[VISIONPLUS_VP7041_COLD], &dibusb_dib3000mb_table[TWINHAN_VP7041_COLD], NULL}, 275 { &dibusb_dib3000mb_table[VISIONPLUS_VP7041_WARM], &dibusb_dib3000mb_table[TWINHAN_VP7041_WARM], NULL}, 276 }, 277 { "Artec T1 USB1.1 TVBOX with AN2135", 278 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_COLD], NULL }, 279 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_WARM], NULL }, 280 }, 281 { "VideoWalker DVB-T USB", 282 { &dibusb_dib3000mb_table[KYE_DVB_T_COLD], NULL }, 283 { &dibusb_dib3000mb_table[KYE_DVB_T_WARM], NULL }, 284 }, 285 } 286 }; 287 288 static struct dvb_usb_device_properties dibusb1_1_an2235_properties = { 289 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 290 .usb_ctrl = CYPRESS_AN2235, 291 292 .firmware = "dvb-usb-dibusb-an2235-01.fw", 293 294 .num_adapters = 1, 295 .adapter = { 296 { 297 .num_frontends = 1, 298 .fe = {{ 299 .caps = DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_ADAP_HAS_PID_FILTER, 300 .pid_filter_count = 16, 301 302 .streaming_ctrl = dibusb_streaming_ctrl, 303 .pid_filter = dibusb_pid_filter, 304 .pid_filter_ctrl = dibusb_pid_filter_ctrl, 305 .frontend_attach = dibusb_dib3000mb_frontend_attach, 306 .tuner_attach = dibusb_tuner_probe_and_attach, 307 308 /* parameter for the MPEG2-data transfer */ 309 .stream = { 310 .type = USB_BULK, 311 .count = 7, 312 .endpoint = 0x02, 313 .u = { 314 .bulk = { 315 .buffersize = 4096, 316 } 317 } 318 }, 319 }}, 320 .size_of_priv = sizeof(struct dibusb_state), 321 }, 322 }, 323 .power_ctrl = dibusb_power_ctrl, 324 325 .rc.legacy = { 326 .rc_interval = DEFAULT_RC_INTERVAL, 327 .rc_map_table = rc_map_dibusb_table, 328 .rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ 329 .rc_query = dibusb_rc_query, 330 }, 331 332 .i2c_algo = &dibusb_i2c_algo, 333 334 .generic_bulk_ctrl_endpoint = 0x01, 335 336 #ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY 337 .num_device_descs = 2, 338 #else 339 .num_device_descs = 1, 340 #endif 341 .devices = { 342 { "Artec T1 USB1.1 TVBOX with AN2235", 343 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_COLD], NULL }, 344 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_WARM], NULL }, 345 }, 346 #ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY 347 { "Artec T1 USB1.1 TVBOX with AN2235 (faulty USB IDs)", 348 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_ANCHOR_COLD], NULL }, 349 { NULL }, 350 }, 351 { NULL }, 352 #endif 353 } 354 }; 355 356 static struct dvb_usb_device_properties dibusb2_0b_properties = { 357 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 358 359 .usb_ctrl = CYPRESS_FX2, 360 361 .firmware = "dvb-usb-adstech-usb2-02.fw", 362 363 .num_adapters = 1, 364 .adapter = { 365 { 366 .num_frontends = 1, 367 .fe = {{ 368 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 369 .pid_filter_count = 16, 370 371 .streaming_ctrl = dibusb2_0_streaming_ctrl, 372 .pid_filter = dibusb_pid_filter, 373 .pid_filter_ctrl = dibusb_pid_filter_ctrl, 374 .frontend_attach = dibusb_dib3000mb_frontend_attach, 375 .tuner_attach = dibusb_thomson_tuner_attach, 376 377 /* parameter for the MPEG2-data transfer */ 378 .stream = { 379 .type = USB_BULK, 380 .count = 7, 381 .endpoint = 0x06, 382 .u = { 383 .bulk = { 384 .buffersize = 4096, 385 } 386 } 387 }, 388 }}, 389 .size_of_priv = sizeof(struct dibusb_state), 390 } 391 }, 392 .power_ctrl = dibusb2_0_power_ctrl, 393 394 .rc.legacy = { 395 .rc_interval = DEFAULT_RC_INTERVAL, 396 .rc_map_table = rc_map_dibusb_table, 397 .rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ 398 .rc_query = dibusb_rc_query, 399 }, 400 401 .i2c_algo = &dibusb_i2c_algo, 402 403 .generic_bulk_ctrl_endpoint = 0x01, 404 405 .num_device_descs = 2, 406 .devices = { 407 { "KWorld/ADSTech Instant DVB-T USB2.0", 408 { &dibusb_dib3000mb_table[ADSTECH_USB2_COLD], NULL }, 409 { &dibusb_dib3000mb_table[ADSTECH_USB2_WARM], NULL }, 410 }, 411 { "KWorld Xpert DVB-T USB2.0", 412 { &dibusb_dib3000mb_table[KWORLD_VSTREAM_COLD], NULL }, 413 { NULL } 414 }, 415 { NULL }, 416 } 417 }; 418 419 static struct dvb_usb_device_properties artec_t1_usb2_properties = { 420 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 421 422 .usb_ctrl = CYPRESS_FX2, 423 424 .firmware = "dvb-usb-dibusb-6.0.0.8.fw", 425 426 .num_adapters = 1, 427 .adapter = { 428 { 429 .num_frontends = 1, 430 .fe = {{ 431 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 432 .pid_filter_count = 16, 433 434 .streaming_ctrl = dibusb2_0_streaming_ctrl, 435 .pid_filter = dibusb_pid_filter, 436 .pid_filter_ctrl = dibusb_pid_filter_ctrl, 437 .frontend_attach = dibusb_dib3000mb_frontend_attach, 438 .tuner_attach = dibusb_tuner_probe_and_attach, 439 /* parameter for the MPEG2-data transfer */ 440 .stream = { 441 .type = USB_BULK, 442 .count = 7, 443 .endpoint = 0x06, 444 .u = { 445 .bulk = { 446 .buffersize = 4096, 447 } 448 } 449 }, 450 }}, 451 .size_of_priv = sizeof(struct dibusb_state), 452 } 453 }, 454 .power_ctrl = dibusb2_0_power_ctrl, 455 456 .rc.legacy = { 457 .rc_interval = DEFAULT_RC_INTERVAL, 458 .rc_map_table = rc_map_dibusb_table, 459 .rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ 460 .rc_query = dibusb_rc_query, 461 }, 462 463 .i2c_algo = &dibusb_i2c_algo, 464 465 .generic_bulk_ctrl_endpoint = 0x01, 466 467 .num_device_descs = 1, 468 .devices = { 469 { "Artec T1 USB2.0", 470 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_COLD], NULL }, 471 { &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_WARM], NULL }, 472 }, 473 { NULL }, 474 } 475 }; 476 477 static struct usb_driver dibusb_driver = { 478 .name = "dvb_usb_dibusb_mb", 479 .probe = dibusb_probe, 480 .disconnect = dvb_usb_device_exit, 481 .id_table = dibusb_dib3000mb_table, 482 }; 483 484 module_usb_driver(dibusb_driver); 485 486 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 487 MODULE_DESCRIPTION("Driver for DiBcom USB DVB-T devices (DiB3000M-B based)"); 488 MODULE_VERSION("1.0"); 489 MODULE_LICENSE("GPL"); 490