1 // SPDX-License-Identifier: GPL-2.0-only 2 /* DVB USB library compliant Linux driver for the WideView/ Yakumo/ Hama/ 3 * Typhoon/ Yuan/ Miglia DVB-T USB2.0 receiver. 4 * 5 * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@posteo.de) 6 * 7 * Thanks to Steve Chang from WideView for providing support for the WT-220U. 8 * 9 * see Documentation/media/dvb-drivers/dvb-usb.rst for more information 10 */ 11 #include "dtt200u.h" 12 13 /* debug */ 14 int dvb_usb_dtt200u_debug; 15 module_param_named(debug,dvb_usb_dtt200u_debug, int, 0644); 16 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2 (or-able))." DVB_USB_DEBUG_STATUS); 17 18 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 19 20 struct dtt200u_state { 21 unsigned char data[80]; 22 }; 23 24 static int dtt200u_power_ctrl(struct dvb_usb_device *d, int onoff) 25 { 26 struct dtt200u_state *st = d->priv; 27 int ret = 0; 28 29 mutex_lock(&d->data_mutex); 30 31 st->data[0] = SET_INIT; 32 33 if (onoff) 34 ret = dvb_usb_generic_write(d, st->data, 2); 35 36 mutex_unlock(&d->data_mutex); 37 return ret; 38 } 39 40 static int dtt200u_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 41 { 42 struct dvb_usb_device *d = adap->dev; 43 struct dtt200u_state *st = d->priv; 44 int ret; 45 46 mutex_lock(&d->data_mutex); 47 st->data[0] = SET_STREAMING; 48 st->data[1] = onoff; 49 50 ret = dvb_usb_generic_write(adap->dev, st->data, 2); 51 if (ret < 0) 52 goto ret; 53 54 if (onoff) 55 goto ret; 56 57 st->data[0] = RESET_PID_FILTER; 58 ret = dvb_usb_generic_write(adap->dev, st->data, 1); 59 60 ret: 61 mutex_unlock(&d->data_mutex); 62 63 return ret; 64 } 65 66 static int dtt200u_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff) 67 { 68 struct dvb_usb_device *d = adap->dev; 69 struct dtt200u_state *st = d->priv; 70 int ret; 71 72 pid = onoff ? pid : 0; 73 74 mutex_lock(&d->data_mutex); 75 st->data[0] = SET_PID_FILTER; 76 st->data[1] = index; 77 st->data[2] = pid & 0xff; 78 st->data[3] = (pid >> 8) & 0x1f; 79 80 ret = dvb_usb_generic_write(adap->dev, st->data, 4); 81 mutex_unlock(&d->data_mutex); 82 83 return ret; 84 } 85 86 static int dtt200u_rc_query(struct dvb_usb_device *d) 87 { 88 struct dtt200u_state *st = d->priv; 89 u32 scancode; 90 int ret; 91 92 mutex_lock(&d->data_mutex); 93 st->data[0] = GET_RC_CODE; 94 95 ret = dvb_usb_generic_rw(d, st->data, 1, st->data, 5, 0); 96 if (ret < 0) 97 goto ret; 98 99 if (st->data[0] == 1) { 100 enum rc_proto proto = RC_PROTO_NEC; 101 102 scancode = st->data[1]; 103 if ((u8) ~st->data[1] != st->data[2]) { 104 /* Extended NEC */ 105 scancode = scancode << 8; 106 scancode |= st->data[2]; 107 proto = RC_PROTO_NECX; 108 } 109 scancode = scancode << 8; 110 scancode |= st->data[3]; 111 112 /* Check command checksum is ok */ 113 if ((u8) ~st->data[3] == st->data[4]) 114 rc_keydown(d->rc_dev, proto, scancode, 0); 115 else 116 rc_keyup(d->rc_dev); 117 } else if (st->data[0] == 2) { 118 rc_repeat(d->rc_dev); 119 } else { 120 rc_keyup(d->rc_dev); 121 } 122 123 if (st->data[0] != 0) 124 deb_info("st->data: %*ph\n", 5, st->data); 125 126 ret: 127 mutex_unlock(&d->data_mutex); 128 return ret; 129 } 130 131 static int dtt200u_frontend_attach(struct dvb_usb_adapter *adap) 132 { 133 adap->fe_adap[0].fe = dtt200u_fe_attach(adap->dev); 134 return 0; 135 } 136 137 static struct dvb_usb_device_properties dtt200u_properties; 138 static struct dvb_usb_device_properties wt220u_fc_properties; 139 static struct dvb_usb_device_properties wt220u_properties; 140 static struct dvb_usb_device_properties wt220u_zl0353_properties; 141 static struct dvb_usb_device_properties wt220u_miglia_properties; 142 143 static int dtt200u_usb_probe(struct usb_interface *intf, 144 const struct usb_device_id *id) 145 { 146 if (0 == dvb_usb_device_init(intf, &dtt200u_properties, 147 THIS_MODULE, NULL, adapter_nr) || 148 0 == dvb_usb_device_init(intf, &wt220u_properties, 149 THIS_MODULE, NULL, adapter_nr) || 150 0 == dvb_usb_device_init(intf, &wt220u_fc_properties, 151 THIS_MODULE, NULL, adapter_nr) || 152 0 == dvb_usb_device_init(intf, &wt220u_zl0353_properties, 153 THIS_MODULE, NULL, adapter_nr) || 154 0 == dvb_usb_device_init(intf, &wt220u_miglia_properties, 155 THIS_MODULE, NULL, adapter_nr)) 156 return 0; 157 158 return -ENODEV; 159 } 160 161 static struct usb_device_id dtt200u_usb_table [] = { 162 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_DTT200U_COLD) }, 163 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_DTT200U_WARM) }, 164 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_COLD) }, 165 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_WARM) }, 166 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZL0353_COLD) }, 167 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZL0353_WARM) }, 168 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_FC_COLD) }, 169 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_FC_WARM) }, 170 { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZAP250_COLD) }, 171 { USB_DEVICE(USB_VID_MIGLIA, USB_PID_WT220U_ZAP250_COLD) }, 172 { 0 }, 173 }; 174 MODULE_DEVICE_TABLE(usb, dtt200u_usb_table); 175 176 static struct dvb_usb_device_properties dtt200u_properties = { 177 .usb_ctrl = CYPRESS_FX2, 178 .firmware = "dvb-usb-dtt200u-01.fw", 179 180 .size_of_priv = sizeof(struct dtt200u_state), 181 182 .num_adapters = 1, 183 .adapter = { 184 { 185 .num_frontends = 1, 186 .fe = {{ 187 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, 188 .pid_filter_count = 15, 189 190 .streaming_ctrl = dtt200u_streaming_ctrl, 191 .pid_filter = dtt200u_pid_filter, 192 .frontend_attach = dtt200u_frontend_attach, 193 /* parameter for the MPEG2-data transfer */ 194 .stream = { 195 .type = USB_BULK, 196 .count = 7, 197 .endpoint = 0x02, 198 .u = { 199 .bulk = { 200 .buffersize = 4096, 201 } 202 } 203 }, 204 }}, 205 } 206 }, 207 .power_ctrl = dtt200u_power_ctrl, 208 209 .rc.core = { 210 .rc_interval = 300, 211 .rc_codes = RC_MAP_DTT200U, 212 .rc_query = dtt200u_rc_query, 213 .allowed_protos = RC_PROTO_BIT_NEC, 214 }, 215 216 .generic_bulk_ctrl_endpoint = 0x01, 217 218 .num_device_descs = 1, 219 .devices = { 220 { .name = "WideView/Yuan/Yakumo/Hama/Typhoon DVB-T USB2.0 (WT-200U)", 221 .cold_ids = { &dtt200u_usb_table[0], NULL }, 222 .warm_ids = { &dtt200u_usb_table[1], NULL }, 223 }, 224 { NULL }, 225 } 226 }; 227 228 static struct dvb_usb_device_properties wt220u_properties = { 229 .usb_ctrl = CYPRESS_FX2, 230 .firmware = "dvb-usb-wt220u-02.fw", 231 232 .size_of_priv = sizeof(struct dtt200u_state), 233 234 .num_adapters = 1, 235 .adapter = { 236 { 237 .num_frontends = 1, 238 .fe = {{ 239 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, 240 .pid_filter_count = 15, 241 242 .streaming_ctrl = dtt200u_streaming_ctrl, 243 .pid_filter = dtt200u_pid_filter, 244 .frontend_attach = dtt200u_frontend_attach, 245 /* parameter for the MPEG2-data transfer */ 246 .stream = { 247 .type = USB_BULK, 248 .count = 7, 249 .endpoint = 0x02, 250 .u = { 251 .bulk = { 252 .buffersize = 4096, 253 } 254 } 255 }, 256 }}, 257 } 258 }, 259 .power_ctrl = dtt200u_power_ctrl, 260 261 .rc.core = { 262 .rc_interval = 300, 263 .rc_codes = RC_MAP_DTT200U, 264 .rc_query = dtt200u_rc_query, 265 .allowed_protos = RC_PROTO_BIT_NEC, 266 }, 267 268 .generic_bulk_ctrl_endpoint = 0x01, 269 270 .num_device_descs = 1, 271 .devices = { 272 { .name = "WideView WT-220U PenType Receiver (Typhoon/Freecom)", 273 .cold_ids = { &dtt200u_usb_table[2], &dtt200u_usb_table[8], NULL }, 274 .warm_ids = { &dtt200u_usb_table[3], NULL }, 275 }, 276 { NULL }, 277 } 278 }; 279 280 static struct dvb_usb_device_properties wt220u_fc_properties = { 281 .usb_ctrl = CYPRESS_FX2, 282 .firmware = "dvb-usb-wt220u-fc03.fw", 283 284 .size_of_priv = sizeof(struct dtt200u_state), 285 286 .num_adapters = 1, 287 .adapter = { 288 { 289 .num_frontends = 1, 290 .fe = {{ 291 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, 292 .pid_filter_count = 15, 293 294 .streaming_ctrl = dtt200u_streaming_ctrl, 295 .pid_filter = dtt200u_pid_filter, 296 .frontend_attach = dtt200u_frontend_attach, 297 /* parameter for the MPEG2-data transfer */ 298 .stream = { 299 .type = USB_BULK, 300 .count = 7, 301 .endpoint = 0x06, 302 .u = { 303 .bulk = { 304 .buffersize = 4096, 305 } 306 } 307 }, 308 }}, 309 } 310 }, 311 .power_ctrl = dtt200u_power_ctrl, 312 313 .rc.core = { 314 .rc_interval = 300, 315 .rc_codes = RC_MAP_DTT200U, 316 .rc_query = dtt200u_rc_query, 317 .allowed_protos = RC_PROTO_BIT_NEC, 318 }, 319 320 .generic_bulk_ctrl_endpoint = 0x01, 321 322 .num_device_descs = 1, 323 .devices = { 324 { .name = "WideView WT-220U PenType Receiver (Typhoon/Freecom)", 325 .cold_ids = { &dtt200u_usb_table[6], NULL }, 326 .warm_ids = { &dtt200u_usb_table[7], NULL }, 327 }, 328 { NULL }, 329 } 330 }; 331 332 static struct dvb_usb_device_properties wt220u_zl0353_properties = { 333 .usb_ctrl = CYPRESS_FX2, 334 .firmware = "dvb-usb-wt220u-zl0353-01.fw", 335 336 .size_of_priv = sizeof(struct dtt200u_state), 337 338 .num_adapters = 1, 339 .adapter = { 340 { 341 .num_frontends = 1, 342 .fe = {{ 343 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, 344 .pid_filter_count = 15, 345 346 .streaming_ctrl = dtt200u_streaming_ctrl, 347 .pid_filter = dtt200u_pid_filter, 348 .frontend_attach = dtt200u_frontend_attach, 349 /* parameter for the MPEG2-data transfer */ 350 .stream = { 351 .type = USB_BULK, 352 .count = 7, 353 .endpoint = 0x02, 354 .u = { 355 .bulk = { 356 .buffersize = 4096, 357 } 358 } 359 }, 360 }}, 361 } 362 }, 363 .power_ctrl = dtt200u_power_ctrl, 364 365 .rc.core = { 366 .rc_interval = 300, 367 .rc_codes = RC_MAP_DTT200U, 368 .rc_query = dtt200u_rc_query, 369 .allowed_protos = RC_PROTO_BIT_NEC, 370 }, 371 372 .generic_bulk_ctrl_endpoint = 0x01, 373 374 .num_device_descs = 1, 375 .devices = { 376 { .name = "WideView WT-220U PenType Receiver (based on ZL353)", 377 .cold_ids = { &dtt200u_usb_table[4], NULL }, 378 .warm_ids = { &dtt200u_usb_table[5], NULL }, 379 }, 380 { NULL }, 381 } 382 }; 383 384 static struct dvb_usb_device_properties wt220u_miglia_properties = { 385 .usb_ctrl = CYPRESS_FX2, 386 .firmware = "dvb-usb-wt220u-miglia-01.fw", 387 388 .size_of_priv = sizeof(struct dtt200u_state), 389 390 .num_adapters = 1, 391 .generic_bulk_ctrl_endpoint = 0x01, 392 393 .num_device_descs = 1, 394 .devices = { 395 { .name = "WideView WT-220U PenType Receiver (Miglia)", 396 .cold_ids = { &dtt200u_usb_table[9], NULL }, 397 /* This device turns into WT220U_ZL0353_WARM when fw 398 has been uploaded */ 399 .warm_ids = { NULL }, 400 }, 401 { NULL }, 402 } 403 }; 404 405 /* usb specific object needed to register this driver with the usb subsystem */ 406 static struct usb_driver dtt200u_usb_driver = { 407 .name = "dvb_usb_dtt200u", 408 .probe = dtt200u_usb_probe, 409 .disconnect = dvb_usb_device_exit, 410 .id_table = dtt200u_usb_table, 411 }; 412 413 module_usb_driver(dtt200u_usb_driver); 414 415 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 416 MODULE_DESCRIPTION("Driver for the WideView/Yakumo/Hama/Typhoon/Club3D/Miglia DVB-T USB2.0 devices"); 417 MODULE_VERSION("1.0"); 418 MODULE_LICENSE("GPL"); 419