Commit | Line | Data |
---|---|---|
3706a4da PB |
1 | /* DVB USB compliant Linux driver for the TwinhanDTV StarBox USB2.0 DVB-S |
2 | * receiver. | |
3 | * | |
4 | * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de> | |
5 | * Metzler Brothers Systementwicklung GbR | |
6 | * | |
7 | * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de> | |
8 | * | |
9 | * Thanks to Twinhan who kindly provided hardware and information. | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify it | |
12 | * under the terms of the GNU General Public License as published by the Free | |
13 | * Software Foundation, version 2. | |
14 | * | |
15 | * see Documentation/dvb/README.dvb-usb for more information | |
16 | */ | |
17 | #include "vp702x.h" | |
1c6410f3 | 18 | #include <linux/mutex.h> |
3706a4da PB |
19 | |
20 | /* debug */ | |
21 | int dvb_usb_vp702x_debug; | |
22 | module_param_named(debug,dvb_usb_vp702x_debug, int, 0644); | |
23 | MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS); | |
24 | ||
78e92006 JG |
25 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
26 | ||
36f773e8 | 27 | struct vp702x_adapter_state { |
0540c496 PB |
28 | int pid_filter_count; |
29 | int pid_filter_can_bypass; | |
30 | u8 pid_filter_state; | |
31 | }; | |
32 | ||
9a187c41 FM |
33 | static int vp702x_usb_in_op_unlocked(struct dvb_usb_device *d, u8 req, |
34 | u16 value, u16 index, u8 *b, int blen) | |
3706a4da | 35 | { |
d30615d8 | 36 | int ret; |
3706a4da | 37 | |
d30615d8 FM |
38 | ret = usb_control_msg(d->udev, |
39 | usb_rcvctrlpipe(d->udev, 0), | |
40 | req, | |
41 | USB_TYPE_VENDOR | USB_DIR_IN, | |
42 | value, index, b, blen, | |
43 | 2000); | |
3706a4da | 44 | |
0540c496 PB |
45 | if (ret < 0) { |
46 | warn("usb in operation failed. (%d)", ret); | |
3706a4da PB |
47 | ret = -EIO; |
48 | } else | |
49 | ret = 0; | |
50 | ||
0540c496 PB |
51 | |
52 | deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index); | |
3706a4da PB |
53 | debug_dump(b,blen,deb_xfer); |
54 | ||
55 | return ret; | |
56 | } | |
57 | ||
9a187c41 | 58 | int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, |
d9e81a5c | 59 | u16 index, u8 *b, int blen) |
9a187c41 FM |
60 | { |
61 | int ret; | |
62 | ||
63 | mutex_lock(&d->usb_mutex); | |
64 | ret = vp702x_usb_in_op_unlocked(d, req, value, index, b, blen); | |
65 | mutex_unlock(&d->usb_mutex); | |
66 | ||
67 | return ret; | |
68 | } | |
69 | ||
d9e81a5c MCC |
70 | static int vp702x_usb_out_op_unlocked(struct dvb_usb_device *d, u8 req, |
71 | u16 value, u16 index, u8 *b, int blen) | |
3706a4da | 72 | { |
0540c496 PB |
73 | int ret; |
74 | deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index); | |
3706a4da PB |
75 | debug_dump(b,blen,deb_xfer); |
76 | ||
0540c496 | 77 | if ((ret = usb_control_msg(d->udev, |
3706a4da PB |
78 | usb_sndctrlpipe(d->udev,0), |
79 | req, | |
80 | USB_TYPE_VENDOR | USB_DIR_OUT, | |
81 | value,index,b,blen, | |
0540c496 PB |
82 | 2000)) != blen) { |
83 | warn("usb out operation failed. (%d)",ret); | |
3706a4da PB |
84 | return -EIO; |
85 | } else | |
86 | return 0; | |
87 | } | |
88 | ||
d9e81a5c | 89 | static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, |
9a187c41 FM |
90 | u16 index, u8 *b, int blen) |
91 | { | |
92 | int ret; | |
93 | ||
94 | mutex_lock(&d->usb_mutex); | |
95 | ret = vp702x_usb_out_op_unlocked(d, req, value, index, b, blen); | |
96 | mutex_unlock(&d->usb_mutex); | |
97 | ||
98 | return ret; | |
99 | } | |
100 | ||
3706a4da PB |
101 | int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec) |
102 | { | |
103 | int ret; | |
104 | ||
3593cab5 | 105 | if ((ret = mutex_lock_interruptible(&d->usb_mutex))) |
3706a4da PB |
106 | return ret; |
107 | ||
9a187c41 | 108 | ret = vp702x_usb_out_op_unlocked(d, REQUEST_OUT, 0, 0, o, olen); |
3706a4da | 109 | msleep(msec); |
9a187c41 | 110 | ret = vp702x_usb_in_op_unlocked(d, REQUEST_IN, 0, 0, i, ilen); |
3706a4da | 111 | |
3593cab5 | 112 | mutex_unlock(&d->usb_mutex); |
3706a4da PB |
113 | return ret; |
114 | } | |
115 | ||
703cb2cb AB |
116 | static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, |
117 | int olen, u8 *i, int ilen, int msec) | |
3706a4da | 118 | { |
ee52f120 | 119 | struct vp702x_device_state *st = d->priv; |
3706a4da | 120 | int ret = 0; |
57873c72 FM |
121 | u8 *buf; |
122 | int buflen = max(olen + 2, ilen + 1); | |
3706a4da | 123 | |
ee52f120 FM |
124 | ret = mutex_lock_interruptible(&st->buf_mutex); |
125 | if (ret < 0) | |
126 | return ret; | |
127 | ||
128 | if (buflen > st->buf_len) { | |
129 | buf = kmalloc(buflen, GFP_KERNEL); | |
130 | if (!buf) { | |
131 | mutex_unlock(&st->buf_mutex); | |
132 | return -ENOMEM; | |
133 | } | |
134 | info("successfully reallocated a bigger buffer"); | |
135 | kfree(st->buf); | |
136 | st->buf = buf; | |
137 | st->buf_len = buflen; | |
138 | } else { | |
139 | buf = st->buf; | |
140 | } | |
3706a4da | 141 | |
57873c72 FM |
142 | buf[0] = 0x00; |
143 | buf[1] = cmd; | |
144 | memcpy(&buf[2], o, olen); | |
145 | ||
146 | ret = vp702x_usb_inout_op(d, buf, olen+2, buf, ilen+1, msec); | |
3706a4da PB |
147 | |
148 | if (ret == 0) | |
57873c72 | 149 | memcpy(i, &buf[1], ilen); |
ee52f120 | 150 | mutex_unlock(&st->buf_mutex); |
3706a4da PB |
151 | |
152 | return ret; | |
153 | } | |
154 | ||
0540c496 PB |
155 | static int vp702x_set_pld_mode(struct dvb_usb_adapter *adap, u8 bypass) |
156 | { | |
57873c72 | 157 | int ret; |
8ea793aa FM |
158 | struct vp702x_device_state *st = adap->dev->priv; |
159 | u8 *buf; | |
160 | ||
161 | mutex_lock(&st->buf_mutex); | |
162 | ||
163 | buf = st->buf; | |
164 | memset(buf, 0, 16); | |
57873c72 FM |
165 | |
166 | ret = vp702x_usb_in_op(adap->dev, 0xe0, (bypass << 8) | 0x0e, | |
167 | 0, buf, 16); | |
8ea793aa | 168 | mutex_unlock(&st->buf_mutex); |
57873c72 | 169 | return ret; |
0540c496 PB |
170 | } |
171 | ||
172 | static int vp702x_set_pld_state(struct dvb_usb_adapter *adap, u8 state) | |
173 | { | |
57873c72 | 174 | int ret; |
8ea793aa FM |
175 | struct vp702x_device_state *st = adap->dev->priv; |
176 | u8 *buf; | |
177 | ||
178 | mutex_lock(&st->buf_mutex); | |
57873c72 | 179 | |
8ea793aa FM |
180 | buf = st->buf; |
181 | memset(buf, 0, 16); | |
57873c72 FM |
182 | ret = vp702x_usb_in_op(adap->dev, 0xe0, (state << 8) | 0x0f, |
183 | 0, buf, 16); | |
8ea793aa FM |
184 | |
185 | mutex_unlock(&st->buf_mutex); | |
186 | ||
57873c72 | 187 | return ret; |
0540c496 PB |
188 | } |
189 | ||
190 | static int vp702x_set_pid(struct dvb_usb_adapter *adap, u16 pid, u8 id, int onoff) | |
3706a4da | 191 | { |
36f773e8 | 192 | struct vp702x_adapter_state *st = adap->priv; |
8ea793aa | 193 | struct vp702x_device_state *dst = adap->dev->priv; |
57873c72 FM |
194 | u8 *buf; |
195 | ||
0540c496 PB |
196 | if (onoff) |
197 | st->pid_filter_state |= (1 << id); | |
198 | else { | |
199 | st->pid_filter_state &= ~(1 << id); | |
200 | pid = 0xffff; | |
3706a4da PB |
201 | } |
202 | ||
0540c496 PB |
203 | id = 0x10 + id*2; |
204 | ||
205 | vp702x_set_pld_state(adap, st->pid_filter_state); | |
8ea793aa FM |
206 | |
207 | mutex_lock(&dst->buf_mutex); | |
208 | ||
209 | buf = dst->buf; | |
210 | memset(buf, 0, 16); | |
0540c496 PB |
211 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid >> 8) & 0xff) << 8) | (id), 0, buf, 16); |
212 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid ) & 0xff) << 8) | (id+1), 0, buf, 16); | |
57873c72 | 213 | |
8ea793aa FM |
214 | mutex_unlock(&dst->buf_mutex); |
215 | ||
0540c496 | 216 | return 0; |
3706a4da PB |
217 | } |
218 | ||
0540c496 PB |
219 | |
220 | static int vp702x_init_pid_filter(struct dvb_usb_adapter *adap) | |
3706a4da | 221 | { |
36f773e8 | 222 | struct vp702x_adapter_state *st = adap->priv; |
8ea793aa | 223 | struct vp702x_device_state *dst = adap->dev->priv; |
0540c496 | 224 | int i; |
57873c72 FM |
225 | u8 *b; |
226 | ||
0540c496 PB |
227 | st->pid_filter_count = 8; |
228 | st->pid_filter_can_bypass = 1; | |
229 | st->pid_filter_state = 0x00; | |
230 | ||
57873c72 | 231 | vp702x_set_pld_mode(adap, 1); /* bypass */ |
0540c496 PB |
232 | |
233 | for (i = 0; i < st->pid_filter_count; i++) | |
234 | vp702x_set_pid(adap, 0xffff, i, 1); | |
235 | ||
8ea793aa FM |
236 | mutex_lock(&dst->buf_mutex); |
237 | b = dst->buf; | |
238 | memset(b, 0, 10); | |
0540c496 PB |
239 | vp702x_usb_in_op(adap->dev, 0xb5, 3, 0, b, 10); |
240 | vp702x_usb_in_op(adap->dev, 0xb5, 0, 0, b, 10); | |
241 | vp702x_usb_in_op(adap->dev, 0xb5, 1, 0, b, 10); | |
8ea793aa FM |
242 | mutex_unlock(&dst->buf_mutex); |
243 | /*vp702x_set_pld_mode(d, 0); // filter */ | |
0540c496 | 244 | |
0540c496 PB |
245 | return 0; |
246 | } | |
247 | ||
248 | static int vp702x_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) | |
249 | { | |
250 | return 0; | |
3706a4da PB |
251 | } |
252 | ||
253 | /* keys for the enclosed remote control */ | |
2f4f58d6 | 254 | static struct rc_map_table rc_map_vp702x_table[] = { |
2e365883 MCC |
255 | { 0x0001, KEY_1 }, |
256 | { 0x0002, KEY_2 }, | |
3706a4da PB |
257 | }; |
258 | ||
259 | /* remote control stuff (does not work with my box) */ | |
260 | static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |
261 | { | |
57873c72 | 262 | u8 *key; |
3706a4da PB |
263 | int i; |
264 | ||
265 | /* remove the following return to enabled remote querying */ | |
266 | return 0; | |
267 | ||
57873c72 FM |
268 | key = kmalloc(10, GFP_KERNEL); |
269 | if (!key) | |
270 | return -ENOMEM; | |
271 | ||
3706a4da PB |
272 | vp702x_usb_in_op(d,READ_REMOTE_REQ,0,0,key,10); |
273 | ||
274 | deb_rc("remote query key: %x %d\n",key[1],key[1]); | |
275 | ||
276 | if (key[1] == 0x44) { | |
277 | *state = REMOTE_NO_KEY_PRESSED; | |
57873c72 | 278 | kfree(key); |
3706a4da PB |
279 | return 0; |
280 | } | |
281 | ||
2f4f58d6 MCC |
282 | for (i = 0; i < ARRAY_SIZE(rc_map_vp702x_table); i++) |
283 | if (rc5_custom(&rc_map_vp702x_table[i]) == key[1]) { | |
3706a4da | 284 | *state = REMOTE_KEY_PRESSED; |
2f4f58d6 | 285 | *event = rc_map_vp702x_table[i].keycode; |
3706a4da PB |
286 | break; |
287 | } | |
57873c72 | 288 | kfree(key); |
3706a4da PB |
289 | return 0; |
290 | } | |
291 | ||
0540c496 | 292 | |
3706a4da PB |
293 | static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6]) |
294 | { | |
57873c72 | 295 | u8 i, *buf; |
8ea793aa | 296 | struct vp702x_device_state *st = d->priv; |
57873c72 | 297 | |
8ea793aa FM |
298 | mutex_lock(&st->buf_mutex); |
299 | buf = st->buf; | |
0540c496 | 300 | for (i = 6; i < 12; i++) |
57873c72 FM |
301 | vp702x_usb_in_op(d, READ_EEPROM_REQ, i, 1, &buf[i - 6], 1); |
302 | ||
303 | memcpy(mac, buf, 6); | |
8ea793aa | 304 | mutex_unlock(&st->buf_mutex); |
3706a4da PB |
305 | return 0; |
306 | } | |
307 | ||
4d43e13f | 308 | static int vp702x_frontend_attach(struct dvb_usb_adapter *adap) |
3706a4da | 309 | { |
0540c496 PB |
310 | u8 buf[10] = { 0 }; |
311 | ||
312 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 0, 7, NULL, 0); | |
3706a4da | 313 | |
d30615d8 FM |
314 | if (vp702x_usb_inout_cmd(adap->dev, GET_SYSTEM_STRING, NULL, 0, |
315 | buf, 10, 10)) | |
3706a4da PB |
316 | return -EIO; |
317 | ||
0540c496 | 318 | buf[9] = '\0'; |
3706a4da PB |
319 | info("system string: %s",&buf[1]); |
320 | ||
0540c496 PB |
321 | vp702x_init_pid_filter(adap); |
322 | ||
77eed219 | 323 | adap->fe_adap[0].fe = vp702x_fe_attach(adap->dev); |
0540c496 PB |
324 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 1, 7, NULL, 0); |
325 | ||
3706a4da PB |
326 | return 0; |
327 | } | |
328 | ||
4d43e13f | 329 | static struct dvb_usb_device_properties vp702x_properties; |
3706a4da PB |
330 | |
331 | static int vp702x_usb_probe(struct usb_interface *intf, | |
332 | const struct usb_device_id *id) | |
333 | { | |
1c6410f3 FM |
334 | struct dvb_usb_device *d; |
335 | struct vp702x_device_state *st; | |
336 | int ret; | |
337 | ||
338 | ret = dvb_usb_device_init(intf, &vp702x_properties, | |
339 | THIS_MODULE, &d, adapter_nr); | |
340 | if (ret) | |
341 | goto out; | |
342 | ||
343 | st = d->priv; | |
344 | st->buf_len = 16; | |
345 | st->buf = kmalloc(st->buf_len, GFP_KERNEL); | |
346 | if (!st->buf) { | |
347 | ret = -ENOMEM; | |
348 | dvb_usb_device_exit(intf); | |
349 | goto out; | |
350 | } | |
351 | mutex_init(&st->buf_mutex); | |
352 | ||
353 | out: | |
354 | return ret; | |
355 | ||
356 | } | |
357 | ||
358 | static void vp702x_usb_disconnect(struct usb_interface *intf) | |
359 | { | |
360 | struct dvb_usb_device *d = usb_get_intfdata(intf); | |
361 | struct vp702x_device_state *st = d->priv; | |
362 | mutex_lock(&st->buf_mutex); | |
363 | kfree(st->buf); | |
364 | mutex_unlock(&st->buf_mutex); | |
365 | dvb_usb_device_exit(intf); | |
3706a4da PB |
366 | } |
367 | ||
368 | static struct usb_device_id vp702x_usb_table [] = { | |
369 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) }, | |
0540c496 PB |
370 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) }, |
371 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) }, | |
3706a4da PB |
372 | { 0 }, |
373 | }; | |
374 | MODULE_DEVICE_TABLE(usb, vp702x_usb_table); | |
375 | ||
4d43e13f | 376 | static struct dvb_usb_device_properties vp702x_properties = { |
3706a4da | 377 | .usb_ctrl = CYPRESS_FX2, |
0540c496 PB |
378 | .firmware = "dvb-usb-vp702x-02.fw", |
379 | .no_reconnect = 1, | |
380 | ||
381 | .size_of_priv = sizeof(struct vp702x_device_state), | |
3706a4da | 382 | |
4d43e13f PB |
383 | .num_adapters = 1, |
384 | .adapter = { | |
385 | { | |
77eed219 MK |
386 | .num_frontends = 1, |
387 | .fe = {{ | |
0540c496 | 388 | .caps = DVB_USB_ADAP_RECEIVES_204_BYTE_TS, |
4d43e13f | 389 | |
0540c496 | 390 | .streaming_ctrl = vp702x_streaming_ctrl, |
01451e72 | 391 | .frontend_attach = vp702x_frontend_attach, |
0540c496 | 392 | |
01451e72 | 393 | /* parameter for the MPEG2-data transfer */ |
4d43e13f PB |
394 | .stream = { |
395 | .type = USB_BULK, | |
0540c496 | 396 | .count = 10, |
01451e72 PB |
397 | .endpoint = 0x02, |
398 | .u = { | |
399 | .bulk = { | |
400 | .buffersize = 4096, | |
401 | } | |
402 | } | |
403 | }, | |
77eed219 | 404 | }}, |
36f773e8 | 405 | .size_of_priv = sizeof(struct vp702x_adapter_state), |
0540c496 | 406 | } |
01451e72 | 407 | }, |
4d43e13f PB |
408 | .read_mac_address = vp702x_read_mac_addr, |
409 | ||
f72a27b8 | 410 | .rc.legacy = { |
2f4f58d6 MCC |
411 | .rc_map_table = rc_map_vp702x_table, |
412 | .rc_map_size = ARRAY_SIZE(rc_map_vp702x_table), | |
f72a27b8 MCC |
413 | .rc_interval = 400, |
414 | .rc_query = vp702x_rc_query, | |
415 | }, | |
3706a4da | 416 | |
0540c496 | 417 | .num_device_descs = 1, |
3706a4da PB |
418 | .devices = { |
419 | { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)", | |
420 | .cold_ids = { &vp702x_usb_table[0], NULL }, | |
0540c496 | 421 | .warm_ids = { NULL }, |
3706a4da | 422 | }, |
0540c496 | 423 | /* { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)", |
3706a4da PB |
424 | .cold_ids = { &vp702x_usb_table[2], NULL }, |
425 | .warm_ids = { &vp702x_usb_table[3], NULL }, | |
426 | }, | |
0540c496 | 427 | */ { NULL }, |
3706a4da PB |
428 | } |
429 | }; | |
430 | ||
431 | /* usb specific object needed to register this driver with the usb subsystem */ | |
432 | static struct usb_driver vp702x_usb_driver = { | |
0540c496 | 433 | .name = "dvb_usb_vp702x", |
d30615d8 | 434 | .probe = vp702x_usb_probe, |
1c6410f3 | 435 | .disconnect = vp702x_usb_disconnect, |
d30615d8 | 436 | .id_table = vp702x_usb_table, |
3706a4da PB |
437 | }; |
438 | ||
ecb3b2b3 | 439 | module_usb_driver(vp702x_usb_driver); |
3706a4da PB |
440 | |
441 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | |
442 | MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones"); | |
0540c496 | 443 | MODULE_VERSION("1.0"); |
3706a4da | 444 | MODULE_LICENSE("GPL"); |