]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/media/dvb/dvb-usb/anysee.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB: rename all *_rc_keys to ir_codes_*_nec_table
[net-next-2.6.git] / drivers / media / dvb / dvb-usb / anysee.c
CommitLineData
a51e34dd
AP		 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
9fdd9caf
AP		 26 * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
27 * module registers serial interface that can be used to communicate
a51e34dd
AP		 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 */
41static int dvb_usb_anysee_debug;
42module_param_named(debug, dvb_usb_anysee_debug, int, 0644);
43MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
ffbc5f88 44static int dvb_usb_anysee_delsys;
0f77c3a4
AP		 45module_param_named(delsys, dvb_usb_anysee_delsys, int, 0644);
46MODULE_PARM_DESC(delsys, "select delivery mode (0=DVB-C, 1=DVB-T)");
a51e34dd
AP		 47DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
48
dec0c46a 49static DEFINE_MUTEX(anysee_usb_mutex);
a51e34dd
AP		 50
51static 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
92static 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
101static 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
108static 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
114static 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
121static 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
128static 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
135static 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 */
152static 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);
902571aa 156 int ret = 0, inc, i = 0;
a51e34dd
AP		 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)
e613f8fa 184 break;
a51e34dd
AP		 185
186 i += inc;
187 }
188
189 mutex_unlock(&d->i2c_mutex);
190
e613f8fa 191 return ret ? ret : i;
a51e34dd
AP		 192}
193
194static u32 anysee_i2c_func(struct i2c_adapter *adapter)
195{
196 return I2C_FUNC_I2C;
197}
198
199static struct i2c_algorithm anysee_i2c_algo = {
200 .master_xfer = anysee_master_xfer,
201 .functionality = anysee_i2c_func,
202};
203
204static int anysee_mt352_demod_init(struct dvb_frontend *fe)
205{
ae3745f6
AP		 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 };
a51e34dd
AP		 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 */
226static 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,
5ae2fcae
AP		 233 .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
234 .deltaf = 0xfeeb,
a51e34dd
AP		 235};
236
237static struct mt352_config anysee_mt352_config = {
238 .demod_address = 0x1e,
239 .demod_init = anysee_mt352_demod_init,
240};
241
242static struct zl10353_config anysee_zl10353_config = {
243 .demod_address = 0x1e,
244 .parallel_ts = 1,
245};
246
247static 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
0f77c3a4
AP		 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
a51e34dd
AP		 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
0f77c3a4
AP		 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
a51e34dd
AP		 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
5ae2fcae
AP		 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;
a51e34dd
AP		 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
af901ca1 347 err("Unknown Anysee version: %02x %02x %02x. "\
a51e34dd
AP		 348 "Please report the <linux-dvb@linuxtv.org>.",
349 hw_info[0], hw_info[1], hw_info[2]);
350
351 return -ENODEV;
352}
353
354static 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
377static 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++) {
2e365883
MCC		 392 if (rc5_custom(&keymap[i]) == ircode[0] &&
393 rc5_data(&keymap[i]) == ircode[1]) {
a51e34dd
AP		 394 *event = keymap[i].event;
395 *state = REMOTE_KEY_PRESSED;
396 return 0;
397 }
398 }
399 return 0;
400}
401
e27e971c 402static struct dvb_usb_rc_key ir_codes_anysee_table[] = {
2e365883
MCC		 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 */
a51e34dd
AP		 447};
448
449/* DVB USB Driver stuff */
450static struct dvb_usb_device_properties anysee_properties;
451
452static 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
a51e34dd
AP		 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
ae3745f6 488static struct usb_device_id anysee_table[] = {
a51e34dd
AP		 489 { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
490 { USB_DEVICE(USB_VID_AMT, USB_PID_ANYSEE) },
491 { } /* Terminating entry */
492};
493MODULE_DEVICE_TABLE(usb, anysee_table);
494
495static 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 = {
ab693336 514 .buffersize = (16*512),
a51e34dd
AP		 515 }
516 }
517 },
518 }
519 },
520
e27e971c
MCC		 521 .rc_key_map = ir_codes_anysee_table,
522 .rc_key_map_size = ARRAY_SIZE(ir_codes_anysee_table),
a51e34dd
AP		 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
541static 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 */
549static 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
560static void __exit anysee_module_exit(void)
561{
562 /* deregister this driver from the USB subsystem */
563 usb_deregister(&anysee_driver);
564}
565
566module_init(anysee_module_init);
567module_exit(anysee_module_exit);
568
569MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
570MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
571MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree