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 | ||
3706a4da PB |
33 | /* check for mutex FIXME */ |
34 | int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen) | |
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 | ||
5e7361a1 | 58 | static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, |
703cb2cb | 59 | u16 index, u8 *b, int blen) |
3706a4da | 60 | { |
0540c496 PB |
61 | int ret; |
62 | deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index); | |
3706a4da PB |
63 | debug_dump(b,blen,deb_xfer); |
64 | ||
0540c496 | 65 | if ((ret = usb_control_msg(d->udev, |
3706a4da PB |
66 | usb_sndctrlpipe(d->udev,0), |
67 | req, | |
68 | USB_TYPE_VENDOR | USB_DIR_OUT, | |
69 | value,index,b,blen, | |
0540c496 PB |
70 | 2000)) != blen) { |
71 | warn("usb out operation failed. (%d)",ret); | |
3706a4da PB |
72 | return -EIO; |
73 | } else | |
74 | return 0; | |
75 | } | |
76 | ||
77 | int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec) | |
78 | { | |
79 | int ret; | |
80 | ||
3593cab5 | 81 | if ((ret = mutex_lock_interruptible(&d->usb_mutex))) |
3706a4da PB |
82 | return ret; |
83 | ||
0540c496 | 84 | ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen); |
3706a4da PB |
85 | msleep(msec); |
86 | ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen); | |
87 | ||
3593cab5 | 88 | mutex_unlock(&d->usb_mutex); |
3706a4da PB |
89 | |
90 | return ret; | |
91 | } | |
92 | ||
703cb2cb AB |
93 | static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, |
94 | int olen, u8 *i, int ilen, int msec) | |
3706a4da | 95 | { |
3706a4da | 96 | int ret = 0; |
57873c72 FM |
97 | u8 *buf; |
98 | int buflen = max(olen + 2, ilen + 1); | |
3706a4da | 99 | |
57873c72 FM |
100 | buf = kmalloc(buflen, GFP_KERNEL); |
101 | if (!buf) | |
102 | return -ENOMEM; | |
3706a4da | 103 | |
57873c72 FM |
104 | buf[0] = 0x00; |
105 | buf[1] = cmd; | |
106 | memcpy(&buf[2], o, olen); | |
107 | ||
108 | ret = vp702x_usb_inout_op(d, buf, olen+2, buf, ilen+1, msec); | |
3706a4da PB |
109 | |
110 | if (ret == 0) | |
57873c72 | 111 | memcpy(i, &buf[1], ilen); |
3706a4da | 112 | |
57873c72 | 113 | kfree(buf); |
3706a4da PB |
114 | return ret; |
115 | } | |
116 | ||
0540c496 PB |
117 | static int vp702x_set_pld_mode(struct dvb_usb_adapter *adap, u8 bypass) |
118 | { | |
57873c72 FM |
119 | int ret; |
120 | u8 *buf = kzalloc(16, GFP_KERNEL); | |
121 | if (!buf) | |
122 | return -ENOMEM; | |
123 | ||
124 | ret = vp702x_usb_in_op(adap->dev, 0xe0, (bypass << 8) | 0x0e, | |
125 | 0, buf, 16); | |
126 | kfree(buf); | |
127 | return ret; | |
0540c496 PB |
128 | } |
129 | ||
130 | static int vp702x_set_pld_state(struct dvb_usb_adapter *adap, u8 state) | |
131 | { | |
57873c72 FM |
132 | int ret; |
133 | u8 *buf = kzalloc(16, GFP_KERNEL); | |
134 | if (!buf) | |
135 | return -ENOMEM; | |
136 | ||
137 | ret = vp702x_usb_in_op(adap->dev, 0xe0, (state << 8) | 0x0f, | |
138 | 0, buf, 16); | |
139 | kfree(buf); | |
140 | return ret; | |
0540c496 PB |
141 | } |
142 | ||
143 | static int vp702x_set_pid(struct dvb_usb_adapter *adap, u16 pid, u8 id, int onoff) | |
3706a4da | 144 | { |
36f773e8 | 145 | struct vp702x_adapter_state *st = adap->priv; |
57873c72 FM |
146 | u8 *buf; |
147 | ||
148 | buf = kzalloc(16, GFP_KERNEL); | |
149 | if (!buf) | |
150 | return -ENOMEM; | |
0540c496 PB |
151 | |
152 | if (onoff) | |
153 | st->pid_filter_state |= (1 << id); | |
154 | else { | |
155 | st->pid_filter_state &= ~(1 << id); | |
156 | pid = 0xffff; | |
3706a4da PB |
157 | } |
158 | ||
0540c496 PB |
159 | id = 0x10 + id*2; |
160 | ||
161 | vp702x_set_pld_state(adap, st->pid_filter_state); | |
162 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid >> 8) & 0xff) << 8) | (id), 0, buf, 16); | |
163 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid ) & 0xff) << 8) | (id+1), 0, buf, 16); | |
57873c72 FM |
164 | |
165 | kfree(buf); | |
0540c496 | 166 | return 0; |
3706a4da PB |
167 | } |
168 | ||
0540c496 PB |
169 | |
170 | static int vp702x_init_pid_filter(struct dvb_usb_adapter *adap) | |
3706a4da | 171 | { |
36f773e8 | 172 | struct vp702x_adapter_state *st = adap->priv; |
0540c496 | 173 | int i; |
57873c72 FM |
174 | u8 *b; |
175 | ||
176 | b = kzalloc(10, GFP_KERNEL); | |
177 | if (!b) | |
178 | return -ENOMEM; | |
3706a4da | 179 | |
0540c496 PB |
180 | st->pid_filter_count = 8; |
181 | st->pid_filter_can_bypass = 1; | |
182 | st->pid_filter_state = 0x00; | |
183 | ||
57873c72 | 184 | vp702x_set_pld_mode(adap, 1); /* bypass */ |
0540c496 PB |
185 | |
186 | for (i = 0; i < st->pid_filter_count; i++) | |
187 | vp702x_set_pid(adap, 0xffff, i, 1); | |
188 | ||
189 | vp702x_usb_in_op(adap->dev, 0xb5, 3, 0, b, 10); | |
190 | vp702x_usb_in_op(adap->dev, 0xb5, 0, 0, b, 10); | |
191 | vp702x_usb_in_op(adap->dev, 0xb5, 1, 0, b, 10); | |
192 | ||
193 | //vp702x_set_pld_mode(d, 0); // filter | |
57873c72 | 194 | kfree(b); |
0540c496 PB |
195 | return 0; |
196 | } | |
197 | ||
198 | static int vp702x_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) | |
199 | { | |
200 | return 0; | |
3706a4da PB |
201 | } |
202 | ||
203 | /* keys for the enclosed remote control */ | |
2f4f58d6 | 204 | static struct rc_map_table rc_map_vp702x_table[] = { |
2e365883 MCC |
205 | { 0x0001, KEY_1 }, |
206 | { 0x0002, KEY_2 }, | |
3706a4da PB |
207 | }; |
208 | ||
209 | /* remote control stuff (does not work with my box) */ | |
210 | static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |
211 | { | |
57873c72 | 212 | u8 *key; |
3706a4da PB |
213 | int i; |
214 | ||
215 | /* remove the following return to enabled remote querying */ | |
216 | return 0; | |
217 | ||
57873c72 FM |
218 | key = kmalloc(10, GFP_KERNEL); |
219 | if (!key) | |
220 | return -ENOMEM; | |
221 | ||
3706a4da PB |
222 | vp702x_usb_in_op(d,READ_REMOTE_REQ,0,0,key,10); |
223 | ||
224 | deb_rc("remote query key: %x %d\n",key[1],key[1]); | |
225 | ||
226 | if (key[1] == 0x44) { | |
227 | *state = REMOTE_NO_KEY_PRESSED; | |
57873c72 | 228 | kfree(key); |
3706a4da PB |
229 | return 0; |
230 | } | |
231 | ||
2f4f58d6 MCC |
232 | for (i = 0; i < ARRAY_SIZE(rc_map_vp702x_table); i++) |
233 | if (rc5_custom(&rc_map_vp702x_table[i]) == key[1]) { | |
3706a4da | 234 | *state = REMOTE_KEY_PRESSED; |
2f4f58d6 | 235 | *event = rc_map_vp702x_table[i].keycode; |
3706a4da PB |
236 | break; |
237 | } | |
57873c72 | 238 | kfree(key); |
3706a4da PB |
239 | return 0; |
240 | } | |
241 | ||
0540c496 | 242 | |
3706a4da PB |
243 | static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6]) |
244 | { | |
57873c72 FM |
245 | u8 i, *buf; |
246 | ||
247 | buf = kmalloc(6, GFP_KERNEL); | |
248 | if (!buf) | |
249 | return -ENOMEM; | |
250 | ||
0540c496 | 251 | for (i = 6; i < 12; i++) |
57873c72 FM |
252 | vp702x_usb_in_op(d, READ_EEPROM_REQ, i, 1, &buf[i - 6], 1); |
253 | ||
254 | memcpy(mac, buf, 6); | |
255 | kfree(buf); | |
3706a4da PB |
256 | return 0; |
257 | } | |
258 | ||
4d43e13f | 259 | static int vp702x_frontend_attach(struct dvb_usb_adapter *adap) |
3706a4da | 260 | { |
0540c496 PB |
261 | u8 buf[10] = { 0 }; |
262 | ||
263 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 0, 7, NULL, 0); | |
3706a4da | 264 | |
d30615d8 FM |
265 | if (vp702x_usb_inout_cmd(adap->dev, GET_SYSTEM_STRING, NULL, 0, |
266 | buf, 10, 10)) | |
3706a4da PB |
267 | return -EIO; |
268 | ||
0540c496 | 269 | buf[9] = '\0'; |
3706a4da PB |
270 | info("system string: %s",&buf[1]); |
271 | ||
0540c496 PB |
272 | vp702x_init_pid_filter(adap); |
273 | ||
4d43e13f | 274 | adap->fe = vp702x_fe_attach(adap->dev); |
0540c496 PB |
275 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 1, 7, NULL, 0); |
276 | ||
3706a4da PB |
277 | return 0; |
278 | } | |
279 | ||
4d43e13f | 280 | static struct dvb_usb_device_properties vp702x_properties; |
3706a4da PB |
281 | |
282 | static int vp702x_usb_probe(struct usb_interface *intf, | |
283 | const struct usb_device_id *id) | |
284 | { | |
1c6410f3 FM |
285 | struct dvb_usb_device *d; |
286 | struct vp702x_device_state *st; | |
287 | int ret; | |
288 | ||
289 | ret = dvb_usb_device_init(intf, &vp702x_properties, | |
290 | THIS_MODULE, &d, adapter_nr); | |
291 | if (ret) | |
292 | goto out; | |
293 | ||
294 | st = d->priv; | |
295 | st->buf_len = 16; | |
296 | st->buf = kmalloc(st->buf_len, GFP_KERNEL); | |
297 | if (!st->buf) { | |
298 | ret = -ENOMEM; | |
299 | dvb_usb_device_exit(intf); | |
300 | goto out; | |
301 | } | |
302 | mutex_init(&st->buf_mutex); | |
303 | ||
304 | out: | |
305 | return ret; | |
306 | ||
307 | } | |
308 | ||
309 | static void vp702x_usb_disconnect(struct usb_interface *intf) | |
310 | { | |
311 | struct dvb_usb_device *d = usb_get_intfdata(intf); | |
312 | struct vp702x_device_state *st = d->priv; | |
313 | mutex_lock(&st->buf_mutex); | |
314 | kfree(st->buf); | |
315 | mutex_unlock(&st->buf_mutex); | |
316 | dvb_usb_device_exit(intf); | |
3706a4da PB |
317 | } |
318 | ||
319 | static struct usb_device_id vp702x_usb_table [] = { | |
320 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) }, | |
0540c496 PB |
321 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) }, |
322 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) }, | |
3706a4da PB |
323 | { 0 }, |
324 | }; | |
325 | MODULE_DEVICE_TABLE(usb, vp702x_usb_table); | |
326 | ||
4d43e13f | 327 | static struct dvb_usb_device_properties vp702x_properties = { |
3706a4da | 328 | .usb_ctrl = CYPRESS_FX2, |
0540c496 PB |
329 | .firmware = "dvb-usb-vp702x-02.fw", |
330 | .no_reconnect = 1, | |
331 | ||
332 | .size_of_priv = sizeof(struct vp702x_device_state), | |
3706a4da | 333 | |
4d43e13f PB |
334 | .num_adapters = 1, |
335 | .adapter = { | |
336 | { | |
0540c496 | 337 | .caps = DVB_USB_ADAP_RECEIVES_204_BYTE_TS, |
4d43e13f | 338 | |
0540c496 | 339 | .streaming_ctrl = vp702x_streaming_ctrl, |
01451e72 | 340 | .frontend_attach = vp702x_frontend_attach, |
0540c496 | 341 | |
01451e72 | 342 | /* parameter for the MPEG2-data transfer */ |
4d43e13f PB |
343 | .stream = { |
344 | .type = USB_BULK, | |
0540c496 | 345 | .count = 10, |
01451e72 PB |
346 | .endpoint = 0x02, |
347 | .u = { | |
348 | .bulk = { | |
349 | .buffersize = 4096, | |
350 | } | |
351 | } | |
352 | }, | |
36f773e8 | 353 | .size_of_priv = sizeof(struct vp702x_adapter_state), |
0540c496 | 354 | } |
01451e72 | 355 | }, |
4d43e13f PB |
356 | .read_mac_address = vp702x_read_mac_addr, |
357 | ||
f72a27b8 | 358 | .rc.legacy = { |
2f4f58d6 MCC |
359 | .rc_map_table = rc_map_vp702x_table, |
360 | .rc_map_size = ARRAY_SIZE(rc_map_vp702x_table), | |
f72a27b8 MCC |
361 | .rc_interval = 400, |
362 | .rc_query = vp702x_rc_query, | |
363 | }, | |
3706a4da | 364 | |
0540c496 | 365 | .num_device_descs = 1, |
3706a4da PB |
366 | .devices = { |
367 | { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)", | |
368 | .cold_ids = { &vp702x_usb_table[0], NULL }, | |
0540c496 | 369 | .warm_ids = { NULL }, |
3706a4da | 370 | }, |
0540c496 | 371 | /* { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)", |
3706a4da PB |
372 | .cold_ids = { &vp702x_usb_table[2], NULL }, |
373 | .warm_ids = { &vp702x_usb_table[3], NULL }, | |
374 | }, | |
0540c496 | 375 | */ { NULL }, |
3706a4da PB |
376 | } |
377 | }; | |
378 | ||
379 | /* usb specific object needed to register this driver with the usb subsystem */ | |
380 | static struct usb_driver vp702x_usb_driver = { | |
0540c496 | 381 | .name = "dvb_usb_vp702x", |
d30615d8 | 382 | .probe = vp702x_usb_probe, |
1c6410f3 | 383 | .disconnect = vp702x_usb_disconnect, |
d30615d8 | 384 | .id_table = vp702x_usb_table, |
3706a4da PB |
385 | }; |
386 | ||
387 | /* module stuff */ | |
388 | static int __init vp702x_usb_module_init(void) | |
389 | { | |
390 | int result; | |
391 | if ((result = usb_register(&vp702x_usb_driver))) { | |
392 | err("usb_register failed. (%d)",result); | |
393 | return result; | |
394 | } | |
395 | ||
396 | return 0; | |
397 | } | |
398 | ||
399 | static void __exit vp702x_usb_module_exit(void) | |
400 | { | |
401 | /* deregister this driver from the USB subsystem */ | |
402 | usb_deregister(&vp702x_usb_driver); | |
403 | } | |
404 | ||
405 | module_init(vp702x_usb_module_init); | |
406 | module_exit(vp702x_usb_module_exit); | |
407 | ||
408 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | |
409 | MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones"); | |
0540c496 | 410 | MODULE_VERSION("1.0"); |
3706a4da | 411 | MODULE_LICENSE("GPL"); |