projects / deliverable / linux.git / blob
? search:


f9d3e063626b346b1dbdc346c098570135df4001
[deliverable/linux.git] / drivers / media / dvb / dvb-usb / anysee.c
1 /*
2 * DVB USB Linux driver for Anysee E30 DVB-C & DVB-T USB2.0 receiver
3 *
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 * TODO:
21 * - add smart card reader support for Conditional Access (CA)
22 *
23 * Card reader in Anysee is nothing more than ISO 7816 card reader.
24 * There is no hardware CAM in any Anysee device sold.
25 * In my understanding it should be implemented by making own module
26 * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
27 * module registers serial interface that can be used to communicate
28 * with any ISO 7816 smart card.
29 *
30 * Any help according to implement serial smart card reader support
31 * is highly welcome!
32 */
33
34 #include "anysee.h"
35 #include "tda1002x.h"
36 #include "mt352.h"
37 #include "mt352_priv.h"
38 #include "zl10353.h"
39
40 /* debug */
41 static int dvb_usb_anysee_debug;
42 module_param_named(debug, dvb_usb_anysee_debug, int, 0644);
43 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
44 static int dvb_usb_anysee_delsys;
45 module_param_named(delsys, dvb_usb_anysee_delsys, int, 0644);
46 MODULE_PARM_DESC(delsys, "select delivery mode (0=DVB-C, 1=DVB-T)");
47 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
48
49 static DEFINE_MUTEX(anysee_usb_mutex);
50
51 static int anysee_ctrl_msg(struct dvb_usb_device *d, u8 *sbuf, u8 slen,
52 u8 *rbuf, u8 rlen)
53 {
54 struct anysee_state *state = d->priv;
55 int act_len, ret;
56 u8 buf[64];
57
58 if (slen > sizeof(buf))
59 slen = sizeof(buf);
60 memcpy(&buf[0], sbuf, slen);
61 buf[60] = state->seq++;
62
63 if (mutex_lock_interruptible(&anysee_usb_mutex) < 0)
64 return -EAGAIN;
65
66 /* We need receive one message more after dvb_usb_generic_rw due
67 to weird transaction flow, which is 1 x send + 2 x receive. */
68 ret = dvb_usb_generic_rw(d, buf, sizeof(buf), buf, sizeof(buf), 0);
69
70 if (!ret) {
71 /* receive 2nd answer */
72 ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev,
73 d->props.generic_bulk_ctrl_endpoint), buf, sizeof(buf),
74 &act_len, 2000);
75 if (ret)
76 err("%s: recv bulk message failed: %d", __func__, ret);
77 else {
78 deb_xfer("<<< ");
79 debug_dump(buf, act_len, deb_xfer);
80 }
81 }
82
83 /* read request, copy returned data to return buf */
84 if (!ret && rbuf && rlen)
85 memcpy(rbuf, buf, rlen);
86
87 mutex_unlock(&anysee_usb_mutex);
88
89 return ret;
90 }
91
92 static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
93 {
94 u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
95 int ret;
96 ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
97 deb_info("%s: reg:%04x val:%02x\n", __func__, reg, *val);
98 return ret;
99 }
100
101 static int anysee_write_reg(struct dvb_usb_device *d, u16 reg, u8 val)
102 {
103 u8 buf[] = {CMD_REG_WRITE, reg >> 8, reg & 0xff, 0x01, val};
104 deb_info("%s: reg:%04x val:%02x\n", __func__, reg, val);
105 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
106 }
107
108 static int anysee_get_hw_info(struct dvb_usb_device *d, u8 *id)
109 {
110 u8 buf[] = {CMD_GET_HW_INFO};
111 return anysee_ctrl_msg(d, buf, sizeof(buf), id, 3);
112 }
113
114 static int anysee_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
115 {
116 u8 buf[] = {CMD_STREAMING_CTRL, (u8)onoff, 0x00};
117 deb_info("%s: onoff:%02x\n", __func__, onoff);
118 return anysee_ctrl_msg(adap->dev, buf, sizeof(buf), NULL, 0);
119 }
120
121 static int anysee_led_ctrl(struct dvb_usb_device *d, u8 mode, u8 interval)
122 {
123 u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x01, mode, interval};
124 deb_info("%s: state:%02x interval:%02x\n", __func__, mode, interval);
125 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
126 }
127
128 static int anysee_ir_ctrl(struct dvb_usb_device *d, u8 onoff)
129 {
130 u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x02, onoff};
131 deb_info("%s: onoff:%02x\n", __func__, onoff);
132 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
133 }
134
135 static int anysee_init(struct dvb_usb_device *d)
136 {
137 int ret;
138 /* LED light */
139 ret = anysee_led_ctrl(d, 0x01, 0x03);
140 if (ret)
141 return ret;
142
143 /* enable IR */
144 ret = anysee_ir_ctrl(d, 1);
145 if (ret)
146 return ret;
147
148 return 0;
149 }
150
151 /* I2C */
152 static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
153 int num)
154 {
155 struct dvb_usb_device *d = i2c_get_adapdata(adap);
156 int ret = 0, inc, i = 0;
157
158 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
159 return -EAGAIN;
160
161 while (i < num) {
162 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
163 u8 buf[6];
164 buf[0] = CMD_I2C_READ;
165 buf[1] = msg[i].addr + 1;
166 buf[2] = msg[i].buf[0];
167 buf[3] = 0x00;
168 buf[4] = 0x00;
169 buf[5] = 0x01;
170 ret = anysee_ctrl_msg(d, buf, sizeof(buf), msg[i+1].buf,
171 msg[i+1].len);
172 inc = 2;
173 } else {
174 u8 buf[4+msg[i].len];
175 buf[0] = CMD_I2C_WRITE;
176 buf[1] = msg[i].addr;
177 buf[2] = msg[i].len;
178 buf[3] = 0x01;
179 memcpy(&buf[4], msg[i].buf, msg[i].len);
180 ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
181 inc = 1;
182 }
183 if (ret)
184 break;
185
186 i += inc;
187 }
188
189 mutex_unlock(&d->i2c_mutex);
190
191 return ret ? ret : i;
192 }
193
194 static u32 anysee_i2c_func(struct i2c_adapter *adapter)
195 {
196 return I2C_FUNC_I2C;
197 }
198
199 static struct i2c_algorithm anysee_i2c_algo = {
200 .master_xfer = anysee_master_xfer,
201 .functionality = anysee_i2c_func,
202 };
203
204 static int anysee_mt352_demod_init(struct dvb_frontend *fe)
205 {
206 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
207 static u8 reset [] = { RESET, 0x80 };
208 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
209 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
210 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
211 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
212
213 mt352_write(fe, clock_config, sizeof(clock_config));
214 udelay(200);
215 mt352_write(fe, reset, sizeof(reset));
216 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
217
218 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
219 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
220 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
221
222 return 0;
223 }
224
225 /* Callbacks for DVB USB */
226 static struct tda10023_config anysee_tda10023_config = {
227 .demod_address = 0x1a,
228 .invert = 0,
229 .xtal = 16000000,
230 .pll_m = 11,
231 .pll_p = 3,
232 .pll_n = 1,
233 .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
234 .deltaf = 0xfeeb,
235 };
236
237 static struct mt352_config anysee_mt352_config = {
238 .demod_address = 0x1e,
239 .demod_init = anysee_mt352_demod_init,
240 };
241
242 static struct zl10353_config anysee_zl10353_config = {
243 .demod_address = 0x1e,
244 .parallel_ts = 1,
245 };
246
247 static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
248 {
249 int ret;
250 struct anysee_state *state = adap->dev->priv;
251 u8 hw_info[3];
252 u8 io_d; /* IO port D */
253
254 /* check which hardware we have
255 We must do this call two times to get reliable values (hw bug). */
256 ret = anysee_get_hw_info(adap->dev, hw_info);
257 if (ret)
258 return ret;
259 ret = anysee_get_hw_info(adap->dev, hw_info);
260 if (ret)
261 return ret;
262
263 /* Meaning of these info bytes are guessed. */
264 info("firmware version:%d.%d.%d hardware id:%d",
265 0, hw_info[1], hw_info[2], hw_info[0]);
266
267 ret = anysee_read_reg(adap->dev, 0xb0, &io_d); /* IO port D */
268 if (ret)
269 return ret;
270 deb_info("%s: IO port D:%02x\n", __func__, io_d);
271
272 /* Select demod using trial and error method. */
273
274 /* Try to attach demodulator in following order:
275 model demod hw firmware
276 1. E30 MT352 02 0.2.1
277 2. E30 ZL10353 02 0.2.1
278 3. E30 Combo ZL10353 0f 0.1.2 DVB-T/C combo
279 4. E30 Plus ZL10353 06 0.1.0
280 5. E30C Plus TDA10023 0a 0.1.0 rev 0.2
281 E30C Plus TDA10023 0f 0.1.2 rev 0.4
282 E30 Combo TDA10023 0f 0.1.2 DVB-T/C combo
283 */
284
285 /* Zarlink MT352 DVB-T demod inside of Samsung DNOS404ZH102A NIM */
286 adap->fe = dvb_attach(mt352_attach, &anysee_mt352_config,
287 &adap->dev->i2c_adap);
288 if (adap->fe != NULL) {
289 state->tuner = DVB_PLL_THOMSON_DTT7579;
290 return 0;
291 }
292
293 /* Zarlink ZL10353 DVB-T demod inside of Samsung DNOS404ZH103A NIM */
294 adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
295 &adap->dev->i2c_adap);
296 if (adap->fe != NULL) {
297 state->tuner = DVB_PLL_THOMSON_DTT7579;
298 return 0;
299 }
300
301 /* for E30 Combo Plus DVB-T demodulator */
302 if (dvb_usb_anysee_delsys) {
303 ret = anysee_write_reg(adap->dev, 0xb0, 0x01);
304 if (ret)
305 return ret;
306
307 /* Zarlink ZL10353 DVB-T demod */
308 adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
309 &adap->dev->i2c_adap);
310 if (adap->fe != NULL) {
311 state->tuner = DVB_PLL_SAMSUNG_DTOS403IH102A;
312 return 0;
313 }
314 }
315
316 /* connect demod on IO port D for TDA10023 & ZL10353 */
317 ret = anysee_write_reg(adap->dev, 0xb0, 0x25);
318 if (ret)
319 return ret;
320
321 /* Zarlink ZL10353 DVB-T demod inside of Samsung DNOS404ZH103A NIM */
322 adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
323 &adap->dev->i2c_adap);
324 if (adap->fe != NULL) {
325 state->tuner = DVB_PLL_THOMSON_DTT7579;
326 return 0;
327 }
328
329 /* IO port E - E30C rev 0.4 board requires this */
330 ret = anysee_write_reg(adap->dev, 0xb1, 0xa7);
331 if (ret)
332 return ret;
333
334 /* Philips TDA10023 DVB-C demod */
335 adap->fe = dvb_attach(tda10023_attach, &anysee_tda10023_config,
336 &adap->dev->i2c_adap, 0x48);
337 if (adap->fe != NULL) {
338 state->tuner = DVB_PLL_SAMSUNG_DTOS403IH102A;
339 return 0;
340 }
341
342 /* return IO port D to init value for safe */
343 ret = anysee_write_reg(adap->dev, 0xb0, io_d);
344 if (ret)
345 return ret;
346
347 err("Unkown Anysee version: %02x %02x %02x. "\
348 "Please report the <linux-dvb@linuxtv.org>.",
349 hw_info[0], hw_info[1], hw_info[2]);
350
351 return -ENODEV;
352 }
353
354 static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
355 {
356 struct anysee_state *state = adap->dev->priv;
357 deb_info("%s: \n", __func__);
358
359 switch (state->tuner) {
360 case DVB_PLL_THOMSON_DTT7579:
361 /* Thomson dtt7579 (not sure) PLL inside of:
362 Samsung DNOS404ZH102A NIM
363 Samsung DNOS404ZH103A NIM */
364 dvb_attach(dvb_pll_attach, adap->fe, 0x61,
365 NULL, DVB_PLL_THOMSON_DTT7579);
366 break;
367 case DVB_PLL_SAMSUNG_DTOS403IH102A:
368 /* Unknown PLL inside of Samsung DTOS403IH102A tuner module */
369 dvb_attach(dvb_pll_attach, adap->fe, 0xc0,
370 &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
371 break;
372 }
373
374 return 0;
375 }
376
377 static int anysee_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
378 {
379 u8 buf[] = {CMD_GET_IR_CODE};
380 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
381 u8 ircode[2];
382 int i, ret;
383
384 ret = anysee_ctrl_msg(d, buf, sizeof(buf), &ircode[0], 2);
385 if (ret)
386 return ret;
387
388 *event = 0;
389 *state = REMOTE_NO_KEY_PRESSED;
390
391 for (i = 0; i < d->props.rc_key_map_size; i++) {
392 if (rc5_custom(&keymap[i]) == ircode[0] &&
393 rc5_data(&keymap[i]) == ircode[1]) {
394 *event = keymap[i].event;
395 *state = REMOTE_KEY_PRESSED;
396 return 0;
397 }
398 }
399 return 0;
400 }
401
402 static struct dvb_usb_rc_key anysee_rc_keys[] = {
403 { 0x0100, KEY_0 },
404 { 0x0101, KEY_1 },
405 { 0x0102, KEY_2 },
406 { 0x0103, KEY_3 },
407 { 0x0104, KEY_4 },
408 { 0x0105, KEY_5 },
409 { 0x0106, KEY_6 },
410 { 0x0107, KEY_7 },
411 { 0x0108, KEY_8 },
412 { 0x0109, KEY_9 },
413 { 0x010a, KEY_POWER },
414 { 0x010b, KEY_DOCUMENTS }, /* * */
415 { 0x0119, KEY_FAVORITES },
416 { 0x0120, KEY_SLEEP },
417 { 0x0121, KEY_MODE }, /* 4:3 / 16:9 select */
418 { 0x0122, KEY_ZOOM },
419 { 0x0147, KEY_TEXT },
420 { 0x0116, KEY_TV }, /* TV / radio select */
421 { 0x011e, KEY_LANGUAGE }, /* Second Audio Program */
422 { 0x011a, KEY_SUBTITLE },
423 { 0x011b, KEY_CAMERA }, /* screenshot */
424 { 0x0142, KEY_MUTE },
425 { 0x010e, KEY_MENU },
426 { 0x010f, KEY_EPG },
427 { 0x0117, KEY_INFO },
428 { 0x0110, KEY_EXIT },
429 { 0x0113, KEY_VOLUMEUP },
430 { 0x0112, KEY_VOLUMEDOWN },
431 { 0x0111, KEY_CHANNELUP },
432 { 0x0114, KEY_CHANNELDOWN },
433 { 0x0115, KEY_OK },
434 { 0x011d, KEY_RED },
435 { 0x011f, KEY_GREEN },
436 { 0x011c, KEY_YELLOW },
437 { 0x0144, KEY_BLUE },
438 { 0x010c, KEY_SHUFFLE }, /* snapshot */
439 { 0x0148, KEY_STOP },
440 { 0x0150, KEY_PLAY },
441 { 0x0151, KEY_PAUSE },
442 { 0x0149, KEY_RECORD },
443 { 0x0118, KEY_PREVIOUS }, /* |<< */
444 { 0x010d, KEY_NEXT }, /* >>| */
445 { 0x0124, KEY_PROG1 }, /* F1 */
446 { 0x0125, KEY_PROG2 }, /* F2 */
447 };
448
449 /* DVB USB Driver stuff */
450 static struct dvb_usb_device_properties anysee_properties;
451
452 static int anysee_probe(struct usb_interface *intf,
453 const struct usb_device_id *id)
454 {
455 struct dvb_usb_device *d;
456 struct usb_host_interface *alt;
457 int ret;
458
459 /* There is one interface with two alternate settings.
460 Alternate setting 0 is for bulk transfer.
461 Alternate setting 1 is for isochronous transfer.
462 We use bulk transfer (alternate setting 0). */
463 if (intf->num_altsetting < 1)
464 return -ENODEV;
465
466 ret = dvb_usb_device_init(intf, &anysee_properties, THIS_MODULE, &d,
467 adapter_nr);
468 if (ret)
469 return ret;
470
471 alt = usb_altnum_to_altsetting(intf, 0);
472 if (alt == NULL) {
473 deb_info("%s: no alt found!\n", __func__);
474 return -ENODEV;
475 }
476
477 ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
478 alt->desc.bAlternateSetting);
479 if (ret)
480 return ret;
481
482 if (d)
483 ret = anysee_init(d);
484
485 return ret;
486 }
487
488 static struct usb_device_id anysee_table [] = {
489 { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
490 { USB_DEVICE(USB_VID_AMT, USB_PID_ANYSEE) },
491 { } /* Terminating entry */
492 };
493 MODULE_DEVICE_TABLE(usb, anysee_table);
494
495 static struct dvb_usb_device_properties anysee_properties = {
496 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
497
498 .usb_ctrl = DEVICE_SPECIFIC,
499
500 .size_of_priv = sizeof(struct anysee_state),
501
502 .num_adapters = 1,
503 .adapter = {
504 {
505 .streaming_ctrl = anysee_streaming_ctrl,
506 .frontend_attach = anysee_frontend_attach,
507 .tuner_attach = anysee_tuner_attach,
508 .stream = {
509 .type = USB_BULK,
510 .count = 8,
511 .endpoint = 0x82,
512 .u = {
513 .bulk = {
514 .buffersize = (16*512),
515 }
516 }
517 },
518 }
519 },
520
521 .rc_key_map = anysee_rc_keys,
522 .rc_key_map_size = ARRAY_SIZE(anysee_rc_keys),
523 .rc_query = anysee_rc_query,
524 .rc_interval = 200, /* windows driver uses 500ms */
525
526 .i2c_algo = &anysee_i2c_algo,
527
528 .generic_bulk_ctrl_endpoint = 1,
529
530 .num_device_descs = 1,
531 .devices = {
532 {
533 .name = "Anysee DVB USB2.0",
534 .cold_ids = {NULL},
535 .warm_ids = {&anysee_table[0],
536 &anysee_table[1], NULL},
537 },
538 }
539 };
540
541 static struct usb_driver anysee_driver = {
542 .name = "dvb_usb_anysee",
543 .probe = anysee_probe,
544 .disconnect = dvb_usb_device_exit,
545 .id_table = anysee_table,
546 };
547
548 /* module stuff */
549 static int __init anysee_module_init(void)
550 {
551 int ret;
552
553 ret = usb_register(&anysee_driver);
554 if (ret)
555 err("%s: usb_register failed. Error number %d", __func__, ret);
556
557 return ret;
558 }
559
560 static void __exit anysee_module_exit(void)
561 {
562 /* deregister this driver from the USB subsystem */
563 usb_deregister(&anysee_driver);
564 }
565
566 module_init(anysee_module_init);
567 module_exit(anysee_module_exit);
568
569 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
570 MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
571 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.042064 seconds and 4 git commands to generate.