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