2ae7f648effebbe71cb60ad4867d9fd2ccd734a0
[linux-2.6.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");