Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-pull
[linux-2.6] / 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 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
45
46 static struct mutex anysee_usb_mutex;
47
48 static int anysee_ctrl_msg(struct dvb_usb_device *d, u8 *sbuf, u8 slen,
49         u8 *rbuf, u8 rlen)
50 {
51         struct anysee_state *state = d->priv;
52         int act_len, ret;
53         u8 buf[64];
54
55         if (slen > sizeof(buf))
56                 slen = sizeof(buf);
57         memcpy(&buf[0], sbuf, slen);
58         buf[60] = state->seq++;
59
60         if (mutex_lock_interruptible(&anysee_usb_mutex) < 0)
61                 return -EAGAIN;
62
63         /* We need receive one message more after dvb_usb_generic_rw due
64            to weird transaction flow, which is 1 x send + 2 x receive. */
65         ret = dvb_usb_generic_rw(d, buf, sizeof(buf), buf, sizeof(buf), 0);
66
67         if (!ret) {
68                 /* receive 2nd answer */
69                 ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev,
70                         d->props.generic_bulk_ctrl_endpoint), buf, sizeof(buf),
71                         &act_len, 2000);
72                 if (ret)
73                         err("%s: recv bulk message failed: %d", __func__, ret);
74                 else {
75                         deb_xfer("<<< ");
76                         debug_dump(buf, act_len, deb_xfer);
77                 }
78         }
79
80         /* read request, copy returned data to return buf */
81         if (!ret && rbuf && rlen)
82                 memcpy(rbuf, buf, rlen);
83
84         mutex_unlock(&anysee_usb_mutex);
85
86         return ret;
87 }
88
89 static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
90 {
91         u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
92         int ret;
93         ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
94         deb_info("%s: reg:%04x val:%02x\n", __func__, reg, *val);
95         return ret;
96 }
97
98 static int anysee_write_reg(struct dvb_usb_device *d, u16 reg, u8 val)
99 {
100         u8 buf[] = {CMD_REG_WRITE, reg >> 8, reg & 0xff, 0x01, val};
101         deb_info("%s: reg:%04x val:%02x\n", __func__, reg, val);
102         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
103 }
104
105 static int anysee_get_hw_info(struct dvb_usb_device *d, u8 *id)
106 {
107         u8 buf[] = {CMD_GET_HW_INFO};
108         return anysee_ctrl_msg(d, buf, sizeof(buf), id, 3);
109 }
110
111 static int anysee_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
112 {
113         u8 buf[] = {CMD_STREAMING_CTRL, (u8)onoff, 0x00};
114         deb_info("%s: onoff:%02x\n", __func__, onoff);
115         return anysee_ctrl_msg(adap->dev, buf, sizeof(buf), NULL, 0);
116 }
117
118 static int anysee_led_ctrl(struct dvb_usb_device *d, u8 mode, u8 interval)
119 {
120         u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x01, mode, interval};
121         deb_info("%s: state:%02x interval:%02x\n", __func__, mode, interval);
122         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
123 }
124
125 static int anysee_ir_ctrl(struct dvb_usb_device *d, u8 onoff)
126 {
127         u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x02, onoff};
128         deb_info("%s: onoff:%02x\n", __func__, onoff);
129         return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
130 }
131
132 static int anysee_init(struct dvb_usb_device *d)
133 {
134         int ret;
135         /* LED light */
136         ret = anysee_led_ctrl(d, 0x01, 0x03);
137         if (ret)
138                 return ret;
139
140         /* enable IR */
141         ret = anysee_ir_ctrl(d, 1);
142         if (ret)
143                 return ret;
144
145         return 0;
146 }
147
148 /* I2C */
149 static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
150         int num)
151 {
152         struct dvb_usb_device *d = i2c_get_adapdata(adap);
153         int ret, inc, i = 0;
154
155         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
156                 return -EAGAIN;
157
158         while (i < num) {
159                 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
160                         u8 buf[6];
161                         buf[0] = CMD_I2C_READ;
162                         buf[1] = msg[i].addr + 1;
163                         buf[2] = msg[i].buf[0];
164                         buf[3] = 0x00;
165                         buf[4] = 0x00;
166                         buf[5] = 0x01;
167                         ret = anysee_ctrl_msg(d, buf, sizeof(buf), msg[i+1].buf,
168                                 msg[i+1].len);
169                         inc = 2;
170                 } else {
171                         u8 buf[4+msg[i].len];
172                         buf[0] = CMD_I2C_WRITE;
173                         buf[1] = msg[i].addr;
174                         buf[2] = msg[i].len;
175                         buf[3] = 0x01;
176                         memcpy(&buf[4], msg[i].buf, msg[i].len);
177                         ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
178                         inc = 1;
179                 }
180                 if (ret)
181                         return ret;
182
183                 i += inc;
184         }
185
186         mutex_unlock(&d->i2c_mutex);
187
188         return i;
189 }
190
191 static u32 anysee_i2c_func(struct i2c_adapter *adapter)
192 {
193         return I2C_FUNC_I2C;
194 }
195
196 static struct i2c_algorithm anysee_i2c_algo = {
197         .master_xfer   = anysee_master_xfer,
198         .functionality = anysee_i2c_func,
199 };
200
201 static int anysee_mt352_demod_init(struct dvb_frontend *fe)
202 {
203         static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
204         static u8 reset []         = { RESET,      0x80 };
205         static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
206         static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
207         static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
208         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
209
210         mt352_write(fe, clock_config,   sizeof(clock_config));
211         udelay(200);
212         mt352_write(fe, reset,          sizeof(reset));
213         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
214
215         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
216         mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
217         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
218
219         return 0;
220 }
221
222 /* Callbacks for DVB USB */
223 static struct tda10023_config anysee_tda10023_config = {
224         .demod_address = 0x1a,
225         .invert = 0,
226         .xtal   = 16000000,
227         .pll_m  = 11,
228         .pll_p  = 3,
229         .pll_n  = 1,
230         .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
231         .deltaf = 0xfeeb,
232 };
233
234 static struct mt352_config anysee_mt352_config = {
235         .demod_address = 0x1e,
236         .demod_init    = anysee_mt352_demod_init,
237 };
238
239 static struct zl10353_config anysee_zl10353_config = {
240         .demod_address = 0x1e,
241         .parallel_ts = 1,
242 };
243
244 static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
245 {
246         int ret;
247         struct anysee_state *state = adap->dev->priv;
248         u8 hw_info[3];
249         u8 io_d; /* IO port D */
250
251         /* check which hardware we have
252            We must do this call two times to get reliable values (hw bug). */
253         ret = anysee_get_hw_info(adap->dev, hw_info);
254         if (ret)
255                 return ret;
256         ret = anysee_get_hw_info(adap->dev, hw_info);
257         if (ret)
258                 return ret;
259
260         /* Meaning of these info bytes are guessed. */
261         info("firmware version:%d.%d.%d hardware id:%d",
262                 0, hw_info[1], hw_info[2], hw_info[0]);
263
264         ret = anysee_read_reg(adap->dev, 0xb0, &io_d); /* IO port D */
265         if (ret)
266                 return ret;
267         deb_info("%s: IO port D:%02x\n", __func__, io_d);
268
269         /* Select demod using trial and error method. */
270
271         /* Try to attach demodulator in following order:
272               model      demod     hw  firmware
273            1. E30        MT352     02  0.2.1
274            2. E30        ZL10353   02  0.2.1
275            3. E30 Plus   ZL10353   06  0.1.0
276            4. E30C Plus  TDA10023  0a  0.1.0    rev 0.2
277            4. E30C Plus  TDA10023  0f  0.1.2    rev 0.4
278         */
279
280         /* Zarlink MT352 DVB-T demod inside of Samsung DNOS404ZH102A NIM */
281         adap->fe = dvb_attach(mt352_attach, &anysee_mt352_config,
282                               &adap->dev->i2c_adap);
283         if (adap->fe != NULL) {
284                 state->tuner = DVB_PLL_THOMSON_DTT7579;
285                 return 0;
286         }
287
288         /* Zarlink ZL10353 DVB-T demod inside of Samsung DNOS404ZH103A NIM */
289         adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
290                               &adap->dev->i2c_adap);
291         if (adap->fe != NULL) {
292                 state->tuner = DVB_PLL_THOMSON_DTT7579;
293                 return 0;
294         }
295
296         /* connect demod on IO port D for TDA10023 & ZL10353 */
297         ret = anysee_write_reg(adap->dev, 0xb0, 0x25);
298         if (ret)
299                 return ret;
300
301         /* Zarlink ZL10353 DVB-T demod inside of Samsung DNOS404ZH103A NIM */
302         adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
303                               &adap->dev->i2c_adap);
304         if (adap->fe != NULL) {
305                 state->tuner = DVB_PLL_THOMSON_DTT7579;
306                 return 0;
307         }
308
309         /* IO port E - E30C rev 0.4 board requires this */
310         ret = anysee_write_reg(adap->dev, 0xb1, 0xa7);
311         if (ret)
312                 return ret;
313
314         /* Philips TDA10023 DVB-C demod */
315         adap->fe = dvb_attach(tda10023_attach, &anysee_tda10023_config,
316                               &adap->dev->i2c_adap, 0x48);
317         if (adap->fe != NULL) {
318                 state->tuner = DVB_PLL_SAMSUNG_DTOS403IH102A;
319                 return 0;
320         }
321
322         /* return IO port D to init value for safe */
323         ret = anysee_write_reg(adap->dev, 0xb0, io_d);
324         if (ret)
325                 return ret;
326
327         err("Unkown Anysee version: %02x %02x %02x. "\
328             "Please report the <linux-dvb@linuxtv.org>.",
329             hw_info[0], hw_info[1], hw_info[2]);
330
331         return -ENODEV;
332 }
333
334 static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
335 {
336         struct anysee_state *state = adap->dev->priv;
337         deb_info("%s: \n", __func__);
338
339         switch (state->tuner) {
340         case DVB_PLL_THOMSON_DTT7579:
341                 /* Thomson dtt7579 (not sure) PLL inside of:
342                    Samsung DNOS404ZH102A NIM
343                    Samsung DNOS404ZH103A NIM */
344                 dvb_attach(dvb_pll_attach, adap->fe, 0x61,
345                            NULL, DVB_PLL_THOMSON_DTT7579);
346                 break;
347         case DVB_PLL_SAMSUNG_DTOS403IH102A:
348                 /* Unknown PLL inside of Samsung DTOS403IH102A tuner module */
349                 dvb_attach(dvb_pll_attach, adap->fe, 0xc0,
350                            &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
351                 break;
352         }
353
354         return 0;
355 }
356
357 static int anysee_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
358 {
359         u8 buf[] = {CMD_GET_IR_CODE};
360         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
361         u8 ircode[2];
362         int i, ret;
363
364         ret = anysee_ctrl_msg(d, buf, sizeof(buf), &ircode[0], 2);
365         if (ret)
366                 return ret;
367
368         *event = 0;
369         *state = REMOTE_NO_KEY_PRESSED;
370
371         for (i = 0; i < d->props.rc_key_map_size; i++) {
372                 if (keymap[i].custom == ircode[0] &&
373                     keymap[i].data == ircode[1]) {
374                         *event = keymap[i].event;
375                         *state = REMOTE_KEY_PRESSED;
376                         return 0;
377                 }
378         }
379         return 0;
380 }
381
382 static struct dvb_usb_rc_key anysee_rc_keys[] = {
383         { 0x01, 0x00, KEY_0 },
384         { 0x01, 0x01, KEY_1 },
385         { 0x01, 0x02, KEY_2 },
386         { 0x01, 0x03, KEY_3 },
387         { 0x01, 0x04, KEY_4 },
388         { 0x01, 0x05, KEY_5 },
389         { 0x01, 0x06, KEY_6 },
390         { 0x01, 0x07, KEY_7 },
391         { 0x01, 0x08, KEY_8 },
392         { 0x01, 0x09, KEY_9 },
393         { 0x01, 0x0a, KEY_POWER },
394         { 0x01, 0x0b, KEY_DOCUMENTS },    /* * */
395         { 0x01, 0x19, KEY_FAVORITES },
396         { 0x01, 0x20, KEY_SLEEP },
397         { 0x01, 0x21, KEY_MODE },         /* 4:3 / 16:9 select */
398         { 0x01, 0x22, KEY_ZOOM },
399         { 0x01, 0x47, KEY_TEXT },
400         { 0x01, 0x16, KEY_TV },           /* TV / radio select */
401         { 0x01, 0x1e, KEY_LANGUAGE },     /* Second Audio Program */
402         { 0x01, 0x1a, KEY_SUBTITLE },
403         { 0x01, 0x1b, KEY_CAMERA },       /* screenshot */
404         { 0x01, 0x42, KEY_MUTE },
405         { 0x01, 0x0e, KEY_MENU },
406         { 0x01, 0x0f, KEY_EPG },
407         { 0x01, 0x17, KEY_INFO },
408         { 0x01, 0x10, KEY_EXIT },
409         { 0x01, 0x13, KEY_VOLUMEUP },
410         { 0x01, 0x12, KEY_VOLUMEDOWN },
411         { 0x01, 0x11, KEY_CHANNELUP },
412         { 0x01, 0x14, KEY_CHANNELDOWN },
413         { 0x01, 0x15, KEY_OK },
414         { 0x01, 0x1d, KEY_RED },
415         { 0x01, 0x1f, KEY_GREEN },
416         { 0x01, 0x1c, KEY_YELLOW },
417         { 0x01, 0x44, KEY_BLUE },
418         { 0x01, 0x0c, KEY_SHUFFLE },      /* snapshot */
419         { 0x01, 0x48, KEY_STOP },
420         { 0x01, 0x50, KEY_PLAY },
421         { 0x01, 0x51, KEY_PAUSE },
422         { 0x01, 0x49, KEY_RECORD },
423         { 0x01, 0x18, KEY_PREVIOUS },     /* |<< */
424         { 0x01, 0x0d, KEY_NEXT },         /* >>| */
425         { 0x01, 0x24, KEY_PROG1 },        /* F1 */
426         { 0x01, 0x25, KEY_PROG2 },        /* F2 */
427 };
428
429 /* DVB USB Driver stuff */
430 static struct dvb_usb_device_properties anysee_properties;
431
432 static int anysee_probe(struct usb_interface *intf,
433                         const struct usb_device_id *id)
434 {
435         struct dvb_usb_device *d;
436         struct usb_host_interface *alt;
437         int ret;
438
439         mutex_init(&anysee_usb_mutex);
440
441         /* There is one interface with two alternate settings.
442            Alternate setting 0 is for bulk transfer.
443            Alternate setting 1 is for isochronous transfer.
444            We use bulk transfer (alternate setting 0). */
445         if (intf->num_altsetting < 1)
446                 return -ENODEV;
447
448         ret = dvb_usb_device_init(intf, &anysee_properties, THIS_MODULE, &d,
449                 adapter_nr);
450         if (ret)
451                 return ret;
452
453         alt = usb_altnum_to_altsetting(intf, 0);
454         if (alt == NULL) {
455                 deb_info("%s: no alt found!\n", __func__);
456                 return -ENODEV;
457         }
458
459         ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
460                 alt->desc.bAlternateSetting);
461         if (ret)
462                 return ret;
463
464         if (d)
465                 ret = anysee_init(d);
466
467         return ret;
468 }
469
470 static struct usb_device_id anysee_table [] = {
471         { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
472         { USB_DEVICE(USB_VID_AMT,     USB_PID_ANYSEE) },
473         { }             /* Terminating entry */
474 };
475 MODULE_DEVICE_TABLE(usb, anysee_table);
476
477 static struct dvb_usb_device_properties anysee_properties = {
478         .caps             = DVB_USB_IS_AN_I2C_ADAPTER,
479
480         .usb_ctrl         = DEVICE_SPECIFIC,
481
482         .size_of_priv     = sizeof(struct anysee_state),
483
484         .num_adapters = 1,
485         .adapter = {
486                 {
487                         .streaming_ctrl   = anysee_streaming_ctrl,
488                         .frontend_attach  = anysee_frontend_attach,
489                         .tuner_attach     = anysee_tuner_attach,
490                         .stream = {
491                                 .type = USB_BULK,
492                                 .count = 8,
493                                 .endpoint = 0x82,
494                                 .u = {
495                                         .bulk = {
496                                                 .buffersize = 512,
497                                         }
498                                 }
499                         },
500                 }
501         },
502
503         .rc_key_map       = anysee_rc_keys,
504         .rc_key_map_size  = ARRAY_SIZE(anysee_rc_keys),
505         .rc_query         = anysee_rc_query,
506         .rc_interval      = 200,  /* windows driver uses 500ms */
507
508         .i2c_algo         = &anysee_i2c_algo,
509
510         .generic_bulk_ctrl_endpoint = 1,
511
512         .num_device_descs = 1,
513         .devices = {
514                 {
515                         .name = "Anysee DVB USB2.0",
516                         .cold_ids = {NULL},
517                         .warm_ids = {&anysee_table[0],
518                                      &anysee_table[1], NULL},
519                 },
520         }
521 };
522
523 static struct usb_driver anysee_driver = {
524         .name       = "dvb_usb_anysee",
525         .probe      = anysee_probe,
526         .disconnect = dvb_usb_device_exit,
527         .id_table   = anysee_table,
528 };
529
530 /* module stuff */
531 static int __init anysee_module_init(void)
532 {
533         int ret;
534
535         ret = usb_register(&anysee_driver);
536         if (ret)
537                 err("%s: usb_register failed. Error number %d", __func__, ret);
538
539         return ret;
540 }
541
542 static void __exit anysee_module_exit(void)
543 {
544         /* deregister this driver from the USB subsystem */
545         usb_deregister(&anysee_driver);
546 }
547
548 module_init(anysee_module_init);
549 module_exit(anysee_module_exit);
550
551 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
552 MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
553 MODULE_LICENSE("GPL");