Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6
[linux-2.6] / drivers / media / dvb / dvb-usb / m920x.c
1 /* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
2  *
3  * Copyright (C) 2006 Aapo Tahkola (aet@rasterburn.org)
4  *
5  *      This program is free software; you can redistribute it and/or modify it
6  *      under the terms of the GNU General Public License as published by the Free
7  *      Software Foundation, version 2.
8  *
9  * see Documentation/dvb/README.dvb-usb for more information
10  */
11
12 #include "m920x.h"
13
14 #include "mt352.h"
15 #include "mt352_priv.h"
16 #include "qt1010.h"
17 #include "tda1004x.h"
18 #include "tda827x.h"
19
20 /* debug */
21 static int dvb_usb_m920x_debug;
22 module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
23 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
24
25 static struct dvb_usb_rc_key megasky_rc_keys [] = {
26         { 0x0, 0x12, KEY_POWER },
27         { 0x0, 0x1e, KEY_CYCLEWINDOWS }, /* min/max */
28         { 0x0, 0x02, KEY_CHANNELUP },
29         { 0x0, 0x05, KEY_CHANNELDOWN },
30         { 0x0, 0x03, KEY_VOLUMEUP },
31         { 0x0, 0x06, KEY_VOLUMEDOWN },
32         { 0x0, 0x04, KEY_MUTE },
33         { 0x0, 0x07, KEY_OK }, /* TS */
34         { 0x0, 0x08, KEY_STOP },
35         { 0x0, 0x09, KEY_MENU }, /* swap */
36         { 0x0, 0x0a, KEY_REWIND },
37         { 0x0, 0x1b, KEY_PAUSE },
38         { 0x0, 0x1f, KEY_FASTFORWARD },
39         { 0x0, 0x0c, KEY_RECORD },
40         { 0x0, 0x0d, KEY_CAMERA }, /* screenshot */
41         { 0x0, 0x0e, KEY_COFFEE }, /* "MTS" */
42 };
43
44 static inline int m9206_read(struct usb_device *udev, u8 request, u16 value,\
45                              u16 index, void *data, int size)
46 {
47         int ret;
48
49         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
50                               request, USB_TYPE_VENDOR | USB_DIR_IN,
51                               value, index, data, size, 2000);
52         if (ret < 0) {
53                 printk(KERN_INFO "m920x_read = error: %d\n", ret);
54                 return ret;
55         }
56
57         if (ret != size) {
58                 deb_rc("m920x_read = no data\n");
59                 return -EIO;
60         }
61
62         return 0;
63 }
64
65 static inline int m9206_write(struct usb_device *udev, u8 request,
66                               u16 value, u16 index)
67 {
68         int ret;
69
70         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
71                               request, USB_TYPE_VENDOR | USB_DIR_OUT,
72                               value, index, NULL, 0, 2000);
73
74         return ret;
75 }
76
77 static int m9206_init(struct dvb_usb_device *d)
78 {
79         int ret = 0;
80
81         /* Remote controller init. */
82         if (d->props.rc_query) {
83                 if ((ret = m9206_write(d->udev, M9206_CORE, 0xa8, M9206_RC_INIT2)) != 0)
84                         return ret;
85
86                 if ((ret = m9206_write(d->udev, M9206_CORE, 0x51, M9206_RC_INIT1)) != 0)
87                         return ret;
88         }
89
90         return ret;
91 }
92
93 static int m9206_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
94 {
95         struct m9206_state *m = d->priv;
96         int i, ret = 0;
97         u8 rc_state[2];
98
99         if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, rc_state, 1)) != 0)
100                 goto unlock;
101
102         if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, rc_state + 1, 1)) != 0)
103                 goto unlock;
104
105         for (i = 0; i < d->props.rc_key_map_size; i++)
106                 if (d->props.rc_key_map[i].data == rc_state[1]) {
107                         *event = d->props.rc_key_map[i].event;
108
109                         switch(rc_state[0]) {
110                         case 0x80:
111                                 *state = REMOTE_NO_KEY_PRESSED;
112                                 goto unlock;
113
114                         case 0x93:
115                         case 0x92:
116                                 m->rep_count = 0;
117                                 *state = REMOTE_KEY_PRESSED;
118                                 goto unlock;
119
120                         case 0x91:
121                                 /* For comfort. */
122                                 if (++m->rep_count > 2)
123                                         *state = REMOTE_KEY_REPEAT;
124                                 goto unlock;
125
126                         default:
127                                 deb_rc("Unexpected rc response %x\n", rc_state[0]);
128                                 *state = REMOTE_NO_KEY_PRESSED;
129                                 goto unlock;
130                         }
131                 }
132
133         if (rc_state[1] != 0)
134                 deb_rc("Unknown rc key %x\n", rc_state[1]);
135
136         *state = REMOTE_NO_KEY_PRESSED;
137
138         unlock:
139
140         return ret;
141 }
142
143 /* I2C */
144 static int m9206_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
145                           int num)
146 {
147         struct dvb_usb_device *d = i2c_get_adapdata(adap);
148         int i, j;
149         int ret = 0;
150
151         if (!num)
152                 return -EINVAL;
153
154         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
155                 return -EAGAIN;
156
157         for (i = 0; i < num; i++) {
158                 if (msg[i].flags & (I2C_M_NO_RD_ACK|I2C_M_IGNORE_NAK|I2C_M_TEN) ||
159                     msg[i].len == 0) {
160                         /* For a 0 byte message, I think sending the address to index 0x80|0x40
161                          * would be the correct thing to do.  However, zero byte messages are
162                          * only used for probing, and since we don't know how to get the slave's
163                          * ack, we can't probe. */
164                         ret = -ENOTSUPP;
165                         goto unlock;
166                 }
167                 /* Send START & address/RW bit */
168                 if (!(msg[i].flags & I2C_M_NOSTART)) {
169                         if ((ret = m9206_write(d->udev, M9206_I2C, (msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0), 0x80)) != 0)
170                                 goto unlock;
171                         /* Should check for ack here, if we knew how. */
172                 }
173                 if (msg[i].flags & I2C_M_RD) {
174                         for (j = 0; j < msg[i].len; j++) {
175                                 /* Last byte of transaction? Send STOP, otherwise send ACK. */
176                                 int stop = (i+1 == num && j+1 == msg[i].len)?0x40:0x01;
177                                 if ((ret = m9206_read(d->udev, M9206_I2C, 0x0, 0x20|stop, &msg[i].buf[j], 1)) != 0)
178                                         goto unlock;
179                         }
180                 } else {
181                         for (j = 0; j < msg[i].len; j++) {
182                                 /* Last byte of transaction? Then send STOP. */
183                                 int stop = (i+1 == num && j+1 == msg[i].len)?0x40:0x00;
184                                 if ((ret = m9206_write(d->udev, M9206_I2C, msg[i].buf[j], stop)) != 0)
185                                         goto unlock;
186                                 /* Should check for ack here too. */
187                         }
188                 }
189         }
190         ret = num;
191
192 unlock:
193         mutex_unlock(&d->i2c_mutex);
194
195         return ret;
196 }
197
198 static u32 m9206_i2c_func(struct i2c_adapter *adapter)
199 {
200         return I2C_FUNC_I2C;
201 }
202
203 static struct i2c_algorithm m9206_i2c_algo = {
204         .master_xfer   = m9206_i2c_xfer,
205         .functionality = m9206_i2c_func,
206 };
207
208
209 static int m9206_set_filter(struct dvb_usb_adapter *adap, int type, int idx,
210                             int pid)
211 {
212         int ret = 0;
213
214         if (pid >= 0x8000)
215                 return -EINVAL;
216
217         pid |= 0x8000;
218
219         if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, pid, (type << 8) | (idx * 4) )) != 0)
220                 return ret;
221
222         if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, 0, (type << 8) | (idx * 4) )) != 0)
223                 return ret;
224
225         return ret;
226 }
227
228 static int m9206_update_filters(struct dvb_usb_adapter *adap)
229 {
230         struct m9206_state *m = adap->dev->priv;
231         int enabled = m->filtering_enabled;
232         int i, ret = 0, filter = 0;
233
234         for (i = 0; i < M9206_MAX_FILTERS; i++)
235                 if (m->filters[i] == 8192)
236                         enabled = 0;
237
238         /* Disable all filters */
239         if ((ret = m9206_set_filter(adap, 0x81, 1, enabled)) != 0)
240                 return ret;
241
242         for (i = 0; i < M9206_MAX_FILTERS; i++)
243                 if ((ret = m9206_set_filter(adap, 0x81, i + 2, 0)) != 0)
244                         return ret;
245
246         if ((ret = m9206_set_filter(adap, 0x82, 0, 0x0)) != 0)
247                 return ret;
248
249         /* Set */
250         if (enabled) {
251                 for (i = 0; i < M9206_MAX_FILTERS; i++) {
252                         if (m->filters[i] == 0)
253                                 continue;
254
255                         if ((ret = m9206_set_filter(adap, 0x81, filter + 2, m->filters[i])) != 0)
256                                 return ret;
257
258                         filter++;
259                 }
260         }
261
262         if ((ret = m9206_set_filter(adap, 0x82, 0, 0x02f5)) != 0)
263                 return ret;
264
265         return ret;
266 }
267
268 static int m9206_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
269 {
270         struct m9206_state *m = adap->dev->priv;
271
272         m->filtering_enabled = onoff ? 1 : 0;
273
274         return m9206_update_filters(adap);
275 }
276
277 static int m9206_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
278                             int onoff)
279 {
280         struct m9206_state *m = adap->dev->priv;
281
282         m->filters[index] = onoff ? pid : 0;
283
284         return m9206_update_filters(adap);
285 }
286
287 static int m9206_firmware_download(struct usb_device *udev,
288                                    const struct firmware *fw)
289 {
290         u16 value, index, size;
291         u8 read[4], *buff;
292         int i, pass, ret = 0;
293
294         buff = kmalloc(65536, GFP_KERNEL);
295
296         if ((ret = m9206_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
297                 goto done;
298         deb_rc("%x %x %x %x\n", read[0], read[1], read[2], read[3]);
299
300         if ((ret = m9206_read(udev, M9206_FW, 0x0, 0x0, read, 1)) != 0)
301                 goto done;
302         deb_rc("%x\n", read[0]);
303
304         for (pass = 0; pass < 2; pass++) {
305                 for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
306                         value = le16_to_cpu(*(u16 *)(fw->data + i));
307                         i += sizeof(u16);
308
309                         index = le16_to_cpu(*(u16 *)(fw->data + i));
310                         i += sizeof(u16);
311
312                         size = le16_to_cpu(*(u16 *)(fw->data + i));
313                         i += sizeof(u16);
314
315                         if (pass == 1) {
316                                 /* Will stall if using fw->data ... */
317                                 memcpy(buff, fw->data + i, size);
318
319                                 ret = usb_control_msg(udev, usb_sndctrlpipe(udev,0),
320                                             M9206_FW,
321                                             USB_TYPE_VENDOR | USB_DIR_OUT,
322                                             value, index, buff, size, 20);
323                                 if (ret != size) {
324                                         deb_rc("error while uploading fw!\n");
325                                         ret = -EIO;
326                                         goto done;
327                                 }
328                                 msleep(3);
329                         }
330                         i += size;
331                 }
332                 if (i != fw->size) {
333                         deb_rc("bad firmware file!\n");
334                         ret = -EINVAL;
335                         goto done;
336                 }
337         }
338
339         msleep(36);
340
341         /* m9206 will disconnect itself from the bus after this. */
342         (void) m9206_write(udev, M9206_CORE, 0x01, M9206_FW_GO);
343         deb_rc("firmware uploaded!\n");
344
345         done:
346         kfree(buff);
347
348         return ret;
349 }
350
351 /* Callbacks for DVB USB */
352 static int m920x_identify_state(struct usb_device *udev,
353                                 struct dvb_usb_device_properties *props,
354                                 struct dvb_usb_device_description **desc,
355                                 int *cold)
356 {
357         struct usb_host_interface *alt;
358
359         alt = usb_altnum_to_altsetting(usb_ifnum_to_if(udev, 0), 1);
360         *cold = (alt == NULL) ? 1 : 0;
361
362         return 0;
363 }
364
365 static int megasky_mt352_demod_init(struct dvb_frontend *fe)
366 {
367         u8 config[] = { CONFIG, 0x3d };
368         u8 clock[] = { CLOCK_CTL, 0x30 };
369         u8 reset[] = { RESET, 0x80 };
370         u8 adc_ctl[] = { ADC_CTL_1, 0x40 };
371         u8 agc[] = { AGC_TARGET, 0x1c, 0x20 };
372         u8 sec_agc[] = { 0x69, 0x00, 0xff, 0xff, 0x40, 0xff, 0x00, 0x40, 0x40 };
373         u8 unk1[] = { 0x93, 0x1a };
374         u8 unk2[] = { 0xb5, 0x7a };
375
376         mt352_write(fe, config, ARRAY_SIZE(config));
377         mt352_write(fe, clock, ARRAY_SIZE(clock));
378         mt352_write(fe, reset, ARRAY_SIZE(reset));
379         mt352_write(fe, adc_ctl, ARRAY_SIZE(adc_ctl));
380         mt352_write(fe, agc, ARRAY_SIZE(agc));
381         mt352_write(fe, sec_agc, ARRAY_SIZE(sec_agc));
382         mt352_write(fe, unk1, ARRAY_SIZE(unk1));
383         mt352_write(fe, unk2, ARRAY_SIZE(unk2));
384
385         deb_rc("Demod init!\n");
386
387         return 0;
388 }
389
390 static struct mt352_config megasky_mt352_config = {
391         .demod_address = 0x0f,
392         .no_tuner = 1,
393         .demod_init = megasky_mt352_demod_init,
394 };
395
396 static int megasky_mt352_frontend_attach(struct dvb_usb_adapter *adap)
397 {
398         deb_rc("megasky_frontend_attach!\n");
399
400         if ((adap->fe = dvb_attach(mt352_attach, &megasky_mt352_config, &adap->dev->i2c_adap)) == NULL)
401                 return -EIO;
402
403         return 0;
404 }
405
406 static struct qt1010_config megasky_qt1010_config = {
407         .i2c_address = 0x62
408 };
409
410 static int megasky_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
411 {
412         if (dvb_attach(qt1010_attach, adap->fe, &adap->dev->i2c_adap,
413                        &megasky_qt1010_config) == NULL)
414                 return -ENODEV;
415
416         return 0;
417 }
418
419 static struct tda1004x_config digivox_tda10046_config = {
420         .demod_address = 0x08,
421         .invert = 0,
422         .invert_oclk = 0,
423         .ts_mode = TDA10046_TS_SERIAL,
424         .xtal_freq = TDA10046_XTAL_16M,
425         .if_freq = TDA10046_FREQ_045,
426         .agc_config = TDA10046_AGC_TDA827X,
427         .gpio_config = TDA10046_GPTRI,
428         .request_firmware = NULL,
429 };
430
431 static int digivox_tda10046_frontend_attach(struct dvb_usb_adapter *adap)
432 {
433         deb_rc("digivox_tda10046_frontend_attach!\n");
434
435         if ((adap->fe = dvb_attach(tda10046_attach, &digivox_tda10046_config,
436                                    &adap->dev->i2c_adap)) == NULL)
437                 return -EIO;
438
439         return 0;
440 }
441
442 static int digivox_tda8275_tuner_attach(struct dvb_usb_adapter *adap)
443 {
444         if (dvb_attach(tda827x_attach, adap->fe, 0x60, &adap->dev->i2c_adap,
445                        NULL) == NULL)
446                 return -ENODEV;
447         return 0;
448 }
449
450 /* DVB USB Driver stuff */
451 static struct dvb_usb_device_properties megasky_properties;
452 static struct dvb_usb_device_properties digivox_mini_ii_properties;
453
454 static int m920x_probe(struct usb_interface *intf,
455                        const struct usb_device_id *id)
456 {
457         struct dvb_usb_device *d;
458         struct usb_host_interface *alt;
459         int ret;
460
461         deb_rc("Probed!\n");
462
463         if (((ret = dvb_usb_device_init(intf, &megasky_properties, THIS_MODULE, &d)) == 0) ||
464             ((ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties, THIS_MODULE, &d)) == 0))
465                 goto found;
466
467         return ret;
468
469 found:
470         alt = usb_altnum_to_altsetting(intf, 1);
471         if (alt == NULL) {
472                 deb_rc("No alt found!\n");
473                 return -ENODEV;
474         }
475
476         ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
477                                 alt->desc.bAlternateSetting);
478         if (ret < 0)
479                 return ret;
480
481         if ((ret = m9206_init(d)) != 0)
482                 return ret;
483
484         return ret;
485 }
486
487 static struct usb_device_id m920x_table [] = {
488                 { USB_DEVICE(USB_VID_MSI, USB_PID_MSI_MEGASKY580) },
489                 { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
490                              USB_PID_MSI_DIGI_VOX_MINI_II) },
491                 { }             /* Terminating entry */
492 };
493 MODULE_DEVICE_TABLE (usb, m920x_table);
494
495 static struct dvb_usb_device_properties megasky_properties = {
496         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
497
498         .usb_ctrl = DEVICE_SPECIFIC,
499         .firmware = "dvb-usb-megasky-02.fw",
500         .download_firmware = m9206_firmware_download,
501
502         .rc_interval      = 100,
503         .rc_key_map       = megasky_rc_keys,
504         .rc_key_map_size  = ARRAY_SIZE(megasky_rc_keys),
505         .rc_query         = m9206_rc_query,
506
507         .size_of_priv     = sizeof(struct m9206_state),
508
509         .identify_state   = m920x_identify_state,
510         .num_adapters = 1,
511         .adapter = {{
512                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
513                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
514
515                 .pid_filter_count = 8,
516                 .pid_filter       = m9206_pid_filter,
517                 .pid_filter_ctrl  = m9206_pid_filter_ctrl,
518
519                 .frontend_attach  = megasky_mt352_frontend_attach,
520                 .tuner_attach     = megasky_qt1010_tuner_attach,
521
522                 .stream = {
523                         .type = USB_BULK,
524                         .count = 8,
525                         .endpoint = 0x81,
526                         .u = {
527                                 .bulk = {
528                                         .buffersize = 512,
529                                 }
530                         }
531                 },
532         }},
533         .i2c_algo         = &m9206_i2c_algo,
534
535         .num_device_descs = 1,
536         .devices = {
537                 {   "MSI Mega Sky 580 DVB-T USB2.0",
538                         { &m920x_table[0], NULL },
539                         { NULL },
540                 }
541         }
542 };
543
544 static struct dvb_usb_device_properties digivox_mini_ii_properties = {
545         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
546
547         .usb_ctrl = DEVICE_SPECIFIC,
548         .firmware = "dvb-usb-digivox-02.fw",
549         .download_firmware = m9206_firmware_download,
550
551         .size_of_priv     = sizeof(struct m9206_state),
552
553         .identify_state   = m920x_identify_state,
554         .num_adapters = 1,
555         .adapter = {{
556                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
557                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
558
559                 .pid_filter_count = 8,
560                 .pid_filter       = m9206_pid_filter,
561                 .pid_filter_ctrl  = m9206_pid_filter_ctrl,
562
563                 .frontend_attach  = digivox_tda10046_frontend_attach,
564                 .tuner_attach     = digivox_tda8275_tuner_attach,
565
566                 .stream = {
567                         .type = USB_BULK,
568                         .count = 8,
569                         .endpoint = 0x81,
570                         .u = {
571                                 .bulk = {
572                                         .buffersize = 0x4000,
573                                 }
574                         }
575                 },
576         }},
577         .i2c_algo         = &m9206_i2c_algo,
578
579         .num_device_descs = 1,
580         .devices = {
581                 {   "MSI DIGI VOX mini II DVB-T USB2.0",
582                         { &m920x_table[1], NULL },
583                         { NULL },
584                 },
585         }
586 };
587
588 static struct usb_driver m920x_driver = {
589         .name           = "dvb_usb_m920x",
590         .probe          = m920x_probe,
591         .disconnect     = dvb_usb_device_exit,
592         .id_table       = m920x_table,
593 };
594
595 /* module stuff */
596 static int __init m920x_module_init(void)
597 {
598         int ret;
599
600         if ((ret = usb_register(&m920x_driver))) {
601                 err("usb_register failed. Error number %d", ret);
602                 return ret;
603         }
604
605         return 0;
606 }
607
608 static void __exit m920x_module_exit(void)
609 {
610         /* deregister this driver from the USB subsystem */
611         usb_deregister(&m920x_driver);
612 }
613
614 module_init (m920x_module_init);
615 module_exit (m920x_module_exit);
616
617 MODULE_AUTHOR("Aapo Tahkola <aet@rasterburn.org>");
618 MODULE_DESCRIPTION("Driver MSI Mega Sky 580 DVB-T USB2.0 / Uli m920x");
619 MODULE_VERSION("0.1");
620 MODULE_LICENSE("GPL");