diff options
Diffstat (limited to 'drivers/media/dvb/dvb-usb/digitv.c')
-rw-r--r-- | drivers/media/dvb/dvb-usb/digitv.c | 365 |
1 files changed, 365 insertions, 0 deletions
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c new file mode 100644 index 00000000000..f6344cdd360 --- /dev/null +++ b/drivers/media/dvb/dvb-usb/digitv.c | |||
@@ -0,0 +1,365 @@ | |||
1 | /* DVB USB compliant linux driver for Nebula Electronics uDigiTV DVB-T USB2.0 | ||
2 | * receiver | ||
3 | * | ||
4 | * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de) | ||
5 | * | ||
6 | * partly based on the SDK published by Nebula Electronics | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify it | ||
9 | * under the terms of the GNU General Public License as published by the Free | ||
10 | * Software Foundation, version 2. | ||
11 | * | ||
12 | * see Documentation/dvb/README.dvb-usb for more information | ||
13 | */ | ||
14 | #include "digitv.h" | ||
15 | |||
16 | #include "mt352.h" | ||
17 | #include "nxt6000.h" | ||
18 | |||
19 | /* debug */ | ||
20 | static int dvb_usb_digitv_debug; | ||
21 | module_param_named(debug,dvb_usb_digitv_debug, int, 0644); | ||
22 | MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS); | ||
23 | |||
24 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); | ||
25 | |||
26 | #define deb_rc(args...) dprintk(dvb_usb_digitv_debug,0x01,args) | ||
27 | |||
28 | static int digitv_ctrl_msg(struct dvb_usb_device *d, | ||
29 | u8 cmd, u8 vv, u8 *wbuf, int wlen, u8 *rbuf, int rlen) | ||
30 | { | ||
31 | int wo = (rbuf == NULL || rlen == 0); /* write-only */ | ||
32 | u8 sndbuf[7],rcvbuf[7]; | ||
33 | memset(sndbuf,0,7); memset(rcvbuf,0,7); | ||
34 | |||
35 | sndbuf[0] = cmd; | ||
36 | sndbuf[1] = vv; | ||
37 | sndbuf[2] = wo ? wlen : rlen; | ||
38 | |||
39 | if (wo) { | ||
40 | memcpy(&sndbuf[3],wbuf,wlen); | ||
41 | dvb_usb_generic_write(d,sndbuf,7); | ||
42 | } else { | ||
43 | dvb_usb_generic_rw(d,sndbuf,7,rcvbuf,7,10); | ||
44 | memcpy(rbuf,&rcvbuf[3],rlen); | ||
45 | } | ||
46 | return 0; | ||
47 | } | ||
48 | |||
49 | /* I2C */ | ||
50 | static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num) | ||
51 | { | ||
52 | struct dvb_usb_device *d = i2c_get_adapdata(adap); | ||
53 | int i; | ||
54 | |||
55 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) | ||
56 | return -EAGAIN; | ||
57 | |||
58 | if (num > 2) | ||
59 | warn("more than 2 i2c messages at a time is not handled yet. TODO."); | ||
60 | |||
61 | for (i = 0; i < num; i++) { | ||
62 | /* write/read request */ | ||
63 | if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) { | ||
64 | if (digitv_ctrl_msg(d, USB_READ_COFDM, msg[i].buf[0], NULL, 0, | ||
65 | msg[i+1].buf,msg[i+1].len) < 0) | ||
66 | break; | ||
67 | i++; | ||
68 | } else | ||
69 | if (digitv_ctrl_msg(d,USB_WRITE_COFDM, msg[i].buf[0], | ||
70 | &msg[i].buf[1],msg[i].len-1,NULL,0) < 0) | ||
71 | break; | ||
72 | } | ||
73 | |||
74 | mutex_unlock(&d->i2c_mutex); | ||
75 | return i; | ||
76 | } | ||
77 | |||
78 | static u32 digitv_i2c_func(struct i2c_adapter *adapter) | ||
79 | { | ||
80 | return I2C_FUNC_I2C; | ||
81 | } | ||
82 | |||
83 | static struct i2c_algorithm digitv_i2c_algo = { | ||
84 | .master_xfer = digitv_i2c_xfer, | ||
85 | .functionality = digitv_i2c_func, | ||
86 | }; | ||
87 | |||
88 | /* Callbacks for DVB USB */ | ||
89 | static int digitv_identify_state (struct usb_device *udev, struct | ||
90 | dvb_usb_device_properties *props, struct dvb_usb_device_description **desc, | ||
91 | int *cold) | ||
92 | { | ||
93 | *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0; | ||
94 | return 0; | ||
95 | } | ||
96 | |||
97 | static int digitv_mt352_demod_init(struct dvb_frontend *fe) | ||
98 | { | ||
99 | static u8 reset_buf[] = { 0x89, 0x38, 0x8a, 0x2d, 0x50, 0x80 }; | ||
100 | static u8 init_buf[] = { 0x68, 0xa0, 0x8e, 0x40, 0x53, 0x50, | ||
101 | 0x67, 0x20, 0x7d, 0x01, 0x7c, 0x00, 0x7a, 0x00, | ||
102 | 0x79, 0x20, 0x57, 0x05, 0x56, 0x31, 0x88, 0x0f, | ||
103 | 0x75, 0x32 }; | ||
104 | int i; | ||
105 | |||
106 | for (i = 0; i < ARRAY_SIZE(reset_buf); i += 2) | ||
107 | mt352_write(fe, &reset_buf[i], 2); | ||
108 | |||
109 | msleep(1); | ||
110 | |||
111 | for (i = 0; i < ARRAY_SIZE(init_buf); i += 2) | ||
112 | mt352_write(fe, &init_buf[i], 2); | ||
113 | |||
114 | return 0; | ||
115 | } | ||
116 | |||
117 | static struct mt352_config digitv_mt352_config = { | ||
118 | .demod_init = digitv_mt352_demod_init, | ||
119 | }; | ||
120 | |||
121 | static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) | ||
122 | { | ||
123 | struct dvb_usb_adapter *adap = fe->dvb->priv; | ||
124 | u8 b[5]; | ||
125 | |||
126 | fe->ops.tuner_ops.calc_regs(fe, fep, b, sizeof(b)); | ||
127 | if (fe->ops.i2c_gate_ctrl) | ||
128 | fe->ops.i2c_gate_ctrl(fe, 1); | ||
129 | return digitv_ctrl_msg(adap->dev, USB_WRITE_TUNER, 0, &b[1], 4, NULL, 0); | ||
130 | } | ||
131 | |||
132 | static struct nxt6000_config digitv_nxt6000_config = { | ||
133 | .clock_inversion = 1, | ||
134 | }; | ||
135 | |||
136 | static int digitv_frontend_attach(struct dvb_usb_adapter *adap) | ||
137 | { | ||
138 | struct digitv_state *st = adap->dev->priv; | ||
139 | |||
140 | if ((adap->fe = dvb_attach(mt352_attach, &digitv_mt352_config, &adap->dev->i2c_adap)) != NULL) { | ||
141 | st->is_nxt6000 = 0; | ||
142 | return 0; | ||
143 | } | ||
144 | if ((adap->fe = dvb_attach(nxt6000_attach, &digitv_nxt6000_config, &adap->dev->i2c_adap)) != NULL) { | ||
145 | st->is_nxt6000 = 1; | ||
146 | return 0; | ||
147 | } | ||
148 | return -EIO; | ||
149 | } | ||
150 | |||
151 | static int digitv_tuner_attach(struct dvb_usb_adapter *adap) | ||
152 | { | ||
153 | struct digitv_state *st = adap->dev->priv; | ||
154 | |||
155 | if (!dvb_attach(dvb_pll_attach, adap->fe, 0x60, NULL, DVB_PLL_TDED4)) | ||
156 | return -ENODEV; | ||
157 | |||
158 | if (st->is_nxt6000) | ||
159 | adap->fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params; | ||
160 | |||
161 | return 0; | ||
162 | } | ||
163 | |||
164 | static struct rc_map_table rc_map_digitv_table[] = { | ||
165 | { 0x5f55, KEY_0 }, | ||
166 | { 0x6f55, KEY_1 }, | ||
167 | { 0x9f55, KEY_2 }, | ||
168 | { 0xaf55, KEY_3 }, | ||
169 | { 0x5f56, KEY_4 }, | ||
170 | { 0x6f56, KEY_5 }, | ||
171 | { 0x9f56, KEY_6 }, | ||
172 | { 0xaf56, KEY_7 }, | ||
173 | { 0x5f59, KEY_8 }, | ||
174 | { 0x6f59, KEY_9 }, | ||
175 | { 0x9f59, KEY_TV }, | ||
176 | { 0xaf59, KEY_AUX }, | ||
177 | { 0x5f5a, KEY_DVD }, | ||
178 | { 0x6f5a, KEY_POWER }, | ||
179 | { 0x9f5a, KEY_CAMERA }, /* labelled 'Picture' */ | ||
180 | { 0xaf5a, KEY_AUDIO }, | ||
181 | { 0x5f65, KEY_INFO }, | ||
182 | { 0x6f65, KEY_F13 }, /* 16:9 */ | ||
183 | { 0x9f65, KEY_F14 }, /* 14:9 */ | ||
184 | { 0xaf65, KEY_EPG }, | ||
185 | { 0x5f66, KEY_EXIT }, | ||
186 | { 0x6f66, KEY_MENU }, | ||
187 | { 0x9f66, KEY_UP }, | ||
188 | { 0xaf66, KEY_DOWN }, | ||
189 | { 0x5f69, KEY_LEFT }, | ||
190 | { 0x6f69, KEY_RIGHT }, | ||
191 | { 0x9f69, KEY_ENTER }, | ||
192 | { 0xaf69, KEY_CHANNELUP }, | ||
193 | { 0x5f6a, KEY_CHANNELDOWN }, | ||
194 | { 0x6f6a, KEY_VOLUMEUP }, | ||
195 | { 0x9f6a, KEY_VOLUMEDOWN }, | ||
196 | { 0xaf6a, KEY_RED }, | ||
197 | { 0x5f95, KEY_GREEN }, | ||
198 | { 0x6f95, KEY_YELLOW }, | ||
199 | { 0x9f95, KEY_BLUE }, | ||
200 | { 0xaf95, KEY_SUBTITLE }, | ||
201 | { 0x5f96, KEY_F15 }, /* AD */ | ||
202 | { 0x6f96, KEY_TEXT }, | ||
203 | { 0x9f96, KEY_MUTE }, | ||
204 | { 0xaf96, KEY_REWIND }, | ||
205 | { 0x5f99, KEY_STOP }, | ||
206 | { 0x6f99, KEY_PLAY }, | ||
207 | { 0x9f99, KEY_FASTFORWARD }, | ||
208 | { 0xaf99, KEY_F16 }, /* chapter */ | ||
209 | { 0x5f9a, KEY_PAUSE }, | ||
210 | { 0x6f9a, KEY_PLAY }, | ||
211 | { 0x9f9a, KEY_RECORD }, | ||
212 | { 0xaf9a, KEY_F17 }, /* picture in picture */ | ||
213 | { 0x5fa5, KEY_KPPLUS }, /* zoom in */ | ||
214 | { 0x6fa5, KEY_KPMINUS }, /* zoom out */ | ||
215 | { 0x9fa5, KEY_F18 }, /* capture */ | ||
216 | { 0xafa5, KEY_F19 }, /* web */ | ||
217 | { 0x5fa6, KEY_EMAIL }, | ||
218 | { 0x6fa6, KEY_PHONE }, | ||
219 | { 0x9fa6, KEY_PC }, | ||
220 | }; | ||
221 | |||
222 | static int digitv_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | ||
223 | { | ||
224 | int i; | ||
225 | u8 key[5]; | ||
226 | u8 b[4] = { 0 }; | ||
227 | |||
228 | *event = 0; | ||
229 | *state = REMOTE_NO_KEY_PRESSED; | ||
230 | |||
231 | digitv_ctrl_msg(d,USB_READ_REMOTE,0,NULL,0,&key[1],4); | ||
232 | |||
233 | /* Tell the device we've read the remote. Not sure how necessary | ||
234 | this is, but the Nebula SDK does it. */ | ||
235 | digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0); | ||
236 | |||
237 | /* if something is inside the buffer, simulate key press */ | ||
238 | if (key[1] != 0) | ||
239 | { | ||
240 | for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) { | ||
241 | if (rc5_custom(&d->props.rc.legacy.rc_map_table[i]) == key[1] && | ||
242 | rc5_data(&d->props.rc.legacy.rc_map_table[i]) == key[2]) { | ||
243 | *event = d->props.rc.legacy.rc_map_table[i].keycode; | ||
244 | *state = REMOTE_KEY_PRESSED; | ||
245 | return 0; | ||
246 | } | ||
247 | } | ||
248 | } | ||
249 | |||
250 | if (key[0] != 0) | ||
251 | deb_rc("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]); | ||
252 | return 0; | ||
253 | } | ||
254 | |||
255 | /* DVB USB Driver stuff */ | ||
256 | static struct dvb_usb_device_properties digitv_properties; | ||
257 | |||
258 | static int digitv_probe(struct usb_interface *intf, | ||
259 | const struct usb_device_id *id) | ||
260 | { | ||
261 | struct dvb_usb_device *d; | ||
262 | int ret = dvb_usb_device_init(intf, &digitv_properties, THIS_MODULE, &d, | ||
263 | adapter_nr); | ||
264 | if (ret == 0) { | ||
265 | u8 b[4] = { 0 }; | ||
266 | |||
267 | if (d != NULL) { /* do that only when the firmware is loaded */ | ||
268 | b[0] = 1; | ||
269 | digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0); | ||
270 | |||
271 | b[0] = 0; | ||
272 | digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0); | ||
273 | } | ||
274 | } | ||
275 | return ret; | ||
276 | } | ||
277 | |||
278 | static struct usb_device_id digitv_table [] = { | ||
279 | { USB_DEVICE(USB_VID_ANCHOR, USB_PID_NEBULA_DIGITV) }, | ||
280 | { } /* Terminating entry */ | ||
281 | }; | ||
282 | MODULE_DEVICE_TABLE (usb, digitv_table); | ||
283 | |||
284 | static struct dvb_usb_device_properties digitv_properties = { | ||
285 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | ||
286 | |||
287 | .usb_ctrl = CYPRESS_FX2, | ||
288 | .firmware = "dvb-usb-digitv-02.fw", | ||
289 | |||
290 | .size_of_priv = sizeof(struct digitv_state), | ||
291 | |||
292 | .num_adapters = 1, | ||
293 | .adapter = { | ||
294 | { | ||
295 | .frontend_attach = digitv_frontend_attach, | ||
296 | .tuner_attach = digitv_tuner_attach, | ||
297 | |||
298 | /* parameter for the MPEG2-data transfer */ | ||
299 | .stream = { | ||
300 | .type = USB_BULK, | ||
301 | .count = 7, | ||
302 | .endpoint = 0x02, | ||
303 | .u = { | ||
304 | .bulk = { | ||
305 | .buffersize = 4096, | ||
306 | } | ||
307 | } | ||
308 | }, | ||
309 | } | ||
310 | }, | ||
311 | .identify_state = digitv_identify_state, | ||
312 | |||
313 | .rc.legacy = { | ||
314 | .rc_interval = 1000, | ||
315 | .rc_map_table = rc_map_digitv_table, | ||
316 | .rc_map_size = ARRAY_SIZE(rc_map_digitv_table), | ||
317 | .rc_query = digitv_rc_query, | ||
318 | }, | ||
319 | |||
320 | .i2c_algo = &digitv_i2c_algo, | ||
321 | |||
322 | .generic_bulk_ctrl_endpoint = 0x01, | ||
323 | |||
324 | .num_device_descs = 1, | ||
325 | .devices = { | ||
326 | { "Nebula Electronics uDigiTV DVB-T USB2.0)", | ||
327 | { &digitv_table[0], NULL }, | ||
328 | { NULL }, | ||
329 | }, | ||
330 | { NULL }, | ||
331 | } | ||
332 | }; | ||
333 | |||
334 | static struct usb_driver digitv_driver = { | ||
335 | .name = "dvb_usb_digitv", | ||
336 | .probe = digitv_probe, | ||
337 | .disconnect = dvb_usb_device_exit, | ||
338 | .id_table = digitv_table, | ||
339 | }; | ||
340 | |||
341 | /* module stuff */ | ||
342 | static int __init digitv_module_init(void) | ||
343 | { | ||
344 | int result; | ||
345 | if ((result = usb_register(&digitv_driver))) { | ||
346 | err("usb_register failed. Error number %d",result); | ||
347 | return result; | ||
348 | } | ||
349 | |||
350 | return 0; | ||
351 | } | ||
352 | |||
353 | static void __exit digitv_module_exit(void) | ||
354 | { | ||
355 | /* deregister this driver from the USB subsystem */ | ||
356 | usb_deregister(&digitv_driver); | ||
357 | } | ||
358 | |||
359 | module_init (digitv_module_init); | ||
360 | module_exit (digitv_module_exit); | ||
361 | |||
362 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | ||
363 | MODULE_DESCRIPTION("Driver for Nebula Electronics uDigiTV DVB-T USB2.0"); | ||
364 | MODULE_VERSION("1.0-alpha"); | ||
365 | MODULE_LICENSE("GPL"); | ||