[media] az6007: Driver cleanup
[~shefty/rdma-dev.git] / drivers / media / dvb / dvb-usb / az6007.c
1 /*
2  * Driver for AzureWave 6007 DVB-C/T USB2.0 and clones
3  *
4  * Copyright (c) Henry Wang <Henry.wang@AzureWave.com>
5  *
6  * This driver was made publicly available by Terratec, at:
7  *      http://linux.terratec.de/files/TERRATEC_H7/20110323_TERRATEC_H7_Linux.tar.gz
8  * The original driver's license is GPL, as declared with MODULE_LICENSE()
9  *
10  * Copyright (c) 2010-2011 Mauro Carvalho Chehab <mchehab@redhat.com>
11  *      Driver modified by in order to work with upstream drxk driver, and
12  *      tons of bugs got fixed.
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation under version 2 of the License.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  */
23
24 #include "drxk.h"
25 #include "mt2063.h"
26 #include "dvb_ca_en50221.h"
27
28 #define DVB_USB_LOG_PREFIX "az6007"
29 #include "dvb-usb.h"
30
31 /* debug */
32 int dvb_usb_az6007_debug;
33 module_param_named(debug, dvb_usb_az6007_debug, int, 0644);
34 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))."
35                  DVB_USB_DEBUG_STATUS);
36
37 #define deb_info(args...) dprintk(dvb_usb_az6007_debug, 0x01, args)
38 #define deb_xfer(args...) dprintk(dvb_usb_az6007_debug, 0x02, args)
39 #define deb_rc(args...)   dprintk(dvb_usb_az6007_debug, 0x04, args)
40 #define deb_fe(args...)   dprintk(dvb_usb_az6007_debug, 0x08, args)
41
42 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
43
44 /* Known requests (Cypress FX2 firmware + az6007 "private" ones*/
45
46 #define FX2_OED                 0xb5
47 #define AZ6007_READ_DATA        0xb7
48 #define AZ6007_I2C_RD           0xb9
49 #define AZ6007_POWER            0xbc
50 #define AZ6007_I2C_WR           0xbd
51 #define FX2_SCON1               0xc0
52 #define AZ6007_TS_THROUGH       0xc7
53 #define AZ6007_READ_IR          0xb4
54
55 struct az6007_device_state {
56         struct                  dvb_ca_en50221 ca;
57         struct                  mutex ca_mutex;
58         unsigned                warm : 1;
59
60         /* Due to DRX-K - probably need changes */
61         int                     (*gate_ctrl) (struct dvb_frontend *, int);
62         bool                    tuner_attached;
63
64         unsigned char           data[4096];
65
66         struct usb_data_stream *stream;
67 };
68
69 static struct drxk_config terratec_h7_drxk = {
70         .adr = 0x29,
71         .parallel_ts = true,
72         .dynamic_clk = true,
73         .single_master = true,
74         .enable_merr_cfg = true,
75         .no_i2c_bridge = false,
76         .chunk_size = 64,
77         .mpeg_out_clk_strength = 0x02,
78         .microcode_name = "dvb-usb-terratec-h7-drxk.fw",
79 };
80
81 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
82 {
83         struct dvb_usb_adapter *adap = fe->sec_priv;
84         struct az6007_device_state *st;
85         int status = 0;
86
87         deb_info("%s: %s\n", __func__, enable ? "enable" : "disable");
88
89         if (!adap)
90                 return -EINVAL;
91
92         st = adap->dev->priv;
93
94         if (!st)
95                 return -EINVAL;
96
97         if (enable)
98                 status = st->gate_ctrl(fe, 1);
99         else
100                 status = st->gate_ctrl(fe, 0);
101
102         return status;
103 }
104
105 static struct mt2063_config az6007_mt2063_config = {
106         .tuner_address = 0x60,
107         .refclock = 36125000,
108 };
109
110 /* check for mutex FIXME */
111 static int az6007_read(struct usb_device *udev, u8 req, u16 value,
112                             u16 index, u8 *b, int blen)
113 {
114         int ret;
115
116         ret = usb_control_msg(udev,
117                               usb_rcvctrlpipe(udev, 0),
118                               req,
119                               USB_TYPE_VENDOR | USB_DIR_IN,
120                               value, index, b, blen, 5000);
121         if (ret < 0) {
122                 warn("usb read operation failed. (%d)", ret);
123                 return -EIO;
124         }
125
126         deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ", req, value,
127                  index);
128         debug_dump(b, blen, deb_xfer);
129
130         return ret;
131 }
132
133 static int az6007_write(struct usb_device *udev, u8 req, u16 value,
134                              u16 index, u8 *b, int blen)
135 {
136         int ret;
137
138         deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ", req, value,
139                  index);
140         debug_dump(b, blen, deb_xfer);
141
142         if (blen > 64) {
143                 err("az6007: tried to write %d bytes, but I2C max size is 64 bytes\n",
144                     blen);
145                 return -EOPNOTSUPP;
146         }
147
148         ret = usb_control_msg(udev,
149                               usb_sndctrlpipe(udev, 0),
150                               req,
151                               USB_TYPE_VENDOR | USB_DIR_OUT,
152                               value, index, b, blen, 5000);
153         if (ret != blen) {
154                 err("usb write operation failed. (%d)", ret);
155                 return -EIO;
156         }
157
158         return 0;
159 }
160
161 static int az6007_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
162 {
163         deb_info("%s: %s", __func__, onoff ? "enable" : "disable");
164
165         return az6007_write(adap->dev->udev, 0xbc, onoff, 0, NULL, 0);
166 }
167
168 /* keys for the enclosed remote control */
169 static struct rc_map_table rc_map_az6007_table[] = {
170         {0x0001, KEY_1},
171         {0x0002, KEY_2},
172 };
173
174 /* remote control stuff (does not work with my box) */
175 static int az6007_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
176 {
177         struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
178         u8 key[10];
179         int i;
180
181         /*
182          * FIXME: remove the following return to enabled remote querying
183          * The driver likely needs proper locking to avoid troubles between
184          * this call and other concurrent calls.
185          */
186         return 0;
187
188         az6007_read(d->udev, AZ6007_READ_IR, 0, 0, key, 10);
189
190         if (key[1] == 0x44) {
191                 *state = REMOTE_NO_KEY_PRESSED;
192                 return 0;
193         }
194
195         /*
196          * FIXME: need to make something useful with the keycodes and to
197          * convert it to the non-legacy mode. Yet, it is producing some
198          * debug info already, like:
199          * 88 04 eb 02 fd ff 00 82 63 82 (terratec IR)
200          * 88 04 eb 03 fc 00 00 82 63 82 (terratec IR)
201          * 88 80 7e 0d f2 ff 00 82 63 82 (another NEC-extended based IR)
202          * I suspect that the IR data is at bytes 1 to 4, and byte 5 is parity
203          */
204         deb_rc("remote query key: %x %d\n", key[1], key[1]);
205         print_hex_dump_bytes("Remote: ", DUMP_PREFIX_NONE, key, 10);
206
207         for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
208                 if (rc5_custom(&keymap[i]) == key[1]) {
209                         *event = keymap[i].keycode;
210                         *state = REMOTE_KEY_PRESSED;
211
212                         return 0;
213                 }
214         }
215         return 0;
216 }
217
218 static int az6007_read_mac_addr(struct dvb_usb_device *d, u8 mac[6])
219 {
220         int ret;
221         ret = az6007_read(d->udev, AZ6007_READ_DATA, 6, 0, mac, 6);
222
223         if (ret > 0)
224                 deb_info("%s: mac is %02x:%02x:%02x:%02x:%02x:%02x\n",
225                          __func__, mac[0], mac[1], mac[2],
226                          mac[3], mac[4], mac[5]);
227
228         return ret;
229 }
230
231 static int az6007_led_on_off(struct usb_interface *intf, int onoff)
232 {
233         struct usb_device *udev = interface_to_usbdev(intf);
234         int ret;
235
236         /* TS through */
237         ret = az6007_write(udev, AZ6007_POWER, onoff, 0, NULL, 0);
238         if (ret < 0)
239                 err("%s failed with error %d", __func__, ret);
240         return ret;
241 }
242
243 static int az6007_frontend_attach(struct dvb_usb_adapter *adap)
244 {
245         struct az6007_device_state *st = adap->dev->priv;
246
247         deb_info("attaching demod drxk");
248
249         adap->fe_adap[0].fe = dvb_attach(drxk_attach, &terratec_h7_drxk,
250                                          &adap->dev->i2c_adap);
251         if (!adap->fe_adap[0].fe)
252                 return -EINVAL;
253
254         adap->fe_adap[0].fe->sec_priv = adap;
255         st->gate_ctrl = adap->fe_adap[0].fe->ops.i2c_gate_ctrl;
256         adap->fe_adap[0].fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
257
258         return 0;
259 }
260
261 static int az6007_tuner_attach(struct dvb_usb_adapter *adap)
262 {
263         struct az6007_device_state *st = adap->dev->priv;
264
265         if (st->tuner_attached)
266                 return 0;
267
268         deb_info("attaching tuner mt2063");
269
270         /* Attach mt2063 to DVB-C frontend */
271         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
272                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1);
273         if (!dvb_attach(mt2063_attach, adap->fe_adap[0].fe,
274                         &az6007_mt2063_config,
275                         &adap->dev->i2c_adap))
276                 return -EINVAL;
277
278         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
279                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0);
280
281         st->tuner_attached = true;
282
283         return 0;
284 }
285
286 int az6007_power_ctrl(struct dvb_usb_device *d, int onoff)
287 {
288         struct az6007_device_state *st = d->priv;
289         struct usb_device *udev = d->udev;
290         int ret;
291
292         deb_info("%s()\n", __func__);
293
294         if (!st->warm) {
295                 u8 data[6];
296
297                 az6007_read(udev, FX2_OED, 1, 0, data, 1); /* {0x01} */
298                 az6007_read(udev, AZ6007_READ_DATA, 0, 8160, data, 1); /* {0x20} */
299                 az6007_read(udev, AZ6007_READ_DATA, 0, 0, data, 5); /* {0x00, 0x00, 0x00, 0x00, 0x0a} */
300                 az6007_read(udev, AZ6007_READ_DATA, 0, 4080, data, 6); /* {0x00, 0x08, 0x00, 0x0c, 0x22, 0x38} */
301
302                 ret = az6007_write(udev, AZ6007_POWER, 0, 2, NULL, 0);
303                 if (ret < 0)
304                         return ret;
305                 msleep(60);
306                 ret = az6007_write(udev, AZ6007_POWER, 1, 4, NULL, 0);
307                 if (ret < 0)
308                         return ret;
309                 msleep(100);
310                 ret = az6007_write(udev, AZ6007_POWER, 1, 3, NULL, 0);
311                 if (ret < 0)
312                         return ret;
313                 msleep(20);
314                 ret = az6007_write(udev, AZ6007_POWER, 1, 4, NULL, 0);
315                 if (ret < 0)
316                         return ret;
317
318                 msleep(400);
319                 ret = az6007_write(udev, FX2_SCON1, 0, 3, NULL, 0);
320                 if (ret < 0)
321                         return ret;
322                 msleep (150);
323                 ret = az6007_write(udev, FX2_SCON1, 1, 3, NULL, 0);
324                 if (ret < 0)
325                         return ret;
326                 msleep (430);
327                 ret = az6007_write(udev, AZ6007_POWER, 0, 0, NULL, 0);
328                 if (ret < 0)
329                         return ret;
330
331                 st->warm = true;
332
333                 return 0;
334         }
335
336         if (!onoff)
337                 return 0;
338
339         az6007_write(udev, AZ6007_POWER, 0, 0, NULL, 0);
340         az6007_write(udev, AZ6007_TS_THROUGH, 0, 0, NULL, 0);
341
342         return 0;
343 }
344
345 /* I2C */
346 static int az6007_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
347                            int num)
348 {
349         struct dvb_usb_device *d = i2c_get_adapdata(adap);
350         struct az6007_device_state *st = d->priv;
351         int i, j, len;
352         int ret = 0;
353         u16 index;
354         u16 value;
355         int length;
356         u8 req, addr;
357
358         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
359                 return -EAGAIN;
360
361         for (i = 0; i < num; i++) {
362                 addr = msgs[i].addr << 1;
363                 if (((i + 1) < num)
364                     && (msgs[i].len == 1)
365                     && (!msgs[i].flags & I2C_M_RD)
366                     && (msgs[i + 1].flags & I2C_M_RD)
367                     && (msgs[i].addr == msgs[i + 1].addr)) {
368                         /*
369                          * A write + read xfer for the same address, where
370                          * the first xfer has just 1 byte length.
371                          * Need to join both into one operation
372                          */
373                         if (dvb_usb_az6007_debug & 2)
374                                 printk(KERN_DEBUG
375                                        "az6007 I2C xfer write+read addr=0x%x len=%d/%d: ",
376                                        addr, msgs[i].len, msgs[i + 1].len);
377                         req = AZ6007_I2C_RD;
378                         index = msgs[i].buf[0];
379                         value = addr | (1 << 8);
380                         length = 6 + msgs[i + 1].len;
381                         len = msgs[i + 1].len;
382                         ret = az6007_read(d->udev, req, value, index, st->data,
383                                                length);
384                         if (ret >= len) {
385                                 for (j = 0; j < len; j++) {
386                                         msgs[i + 1].buf[j] = st->data[j + 5];
387                                         if (dvb_usb_az6007_debug & 2)
388                                                 printk(KERN_CONT
389                                                        "0x%02x ",
390                                                        msgs[i + 1].buf[j]);
391                                 }
392                         } else
393                                 ret = -EIO;
394                         i++;
395                 } else if (!(msgs[i].flags & I2C_M_RD)) {
396                         /* write bytes */
397                         if (dvb_usb_az6007_debug & 2)
398                                 printk(KERN_DEBUG
399                                        "az6007 I2C xfer write addr=0x%x len=%d: ",
400                                        addr, msgs[i].len);
401                         req = AZ6007_I2C_WR;
402                         index = msgs[i].buf[0];
403                         value = addr | (1 << 8);
404                         length = msgs[i].len - 1;
405                         len = msgs[i].len - 1;
406                         if (dvb_usb_az6007_debug & 2)
407                                 printk(KERN_CONT "(0x%02x) ", msgs[i].buf[0]);
408                         for (j = 0; j < len; j++) {
409                                 st->data[j] = msgs[i].buf[j + 1];
410                                 if (dvb_usb_az6007_debug & 2)
411                                         printk(KERN_CONT "0x%02x ", st->data[j]);
412                         }
413                         ret =  az6007_write(d->udev, req, value, index, st->data,
414                                                  length);
415                 } else {
416                         /* read bytes */
417                         if (dvb_usb_az6007_debug & 2)
418                                 printk(KERN_DEBUG
419                                        "az6007 I2C xfer read addr=0x%x len=%d: ",
420                                        addr, msgs[i].len);
421                         req = AZ6007_I2C_RD;
422                         index = msgs[i].buf[0];
423                         value = addr;
424                         length = msgs[i].len + 6;
425                         len = msgs[i].len;
426                         ret = az6007_read(d->udev, req, value, index, st->data,
427                                                length);
428                         for (j = 0; j < len; j++) {
429                                 msgs[i].buf[j] = st->data[j + 5];
430                                 if (dvb_usb_az6007_debug & 2)
431                                         printk(KERN_CONT
432                                                "0x%02x ", st->data[j + 5]);
433                         }
434                 }
435                 if (dvb_usb_az6007_debug & 2)
436                         printk(KERN_CONT "\n");
437                 if (ret < 0)
438                         goto err;
439         }
440 err:
441         mutex_unlock(&d->i2c_mutex);
442
443         if (ret < 0) {
444                 info("%s ERROR: %i", __func__, ret);
445                 return ret;
446         }
447         return num;
448 }
449
450 static u32 az6007_i2c_func(struct i2c_adapter *adapter)
451 {
452         return I2C_FUNC_I2C;
453 }
454
455 static struct i2c_algorithm az6007_i2c_algo = {
456         .master_xfer = az6007_i2c_xfer,
457         .functionality = az6007_i2c_func,
458 };
459
460 int az6007_identify_state(struct usb_device *udev,
461                           struct dvb_usb_device_properties *props,
462                           struct dvb_usb_device_description **desc, int *cold)
463 {
464         int ret;
465         u8 mac[6];
466
467         /* Try to read the mac address */
468         ret = az6007_read(udev, AZ6007_READ_DATA, 6, 0, mac, 6);
469         if (ret == 6)
470                 *cold = 0;
471         else
472                 *cold = 1;
473
474         if (*cold) {
475                 az6007_write(udev, 0x09, 1, 0, NULL, 0);
476                 az6007_write(udev, 0x00, 0, 0, NULL, 0);
477                 az6007_write(udev, 0x00, 0, 0, NULL, 0);
478         }
479
480         deb_info("Device is on %s state\n", *cold? "warm" : "cold");
481         return 0;
482 }
483
484 static struct dvb_usb_device_properties az6007_properties;
485
486 static int az6007_usb_probe(struct usb_interface *intf,
487                             const struct usb_device_id *id)
488 {
489         az6007_led_on_off(intf, 0);
490
491         return dvb_usb_device_init(intf, &az6007_properties,
492                                    THIS_MODULE, NULL, adapter_nr);
493 }
494
495 static struct usb_device_id az6007_usb_table[] = {
496         {USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_6007)},
497         {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_H7)},
498         {0},
499 };
500
501 MODULE_DEVICE_TABLE(usb, az6007_usb_table);
502
503 static struct dvb_usb_device_properties az6007_properties = {
504         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
505         .usb_ctrl = CYPRESS_FX2,
506         .firmware            = "dvb-usb-terratec-h7-az6007.fw",
507         .no_reconnect        = 1,
508         .size_of_priv        = sizeof(struct az6007_device_state),
509         .identify_state      = az6007_identify_state,
510         .num_adapters = 1,
511         .adapter = {
512                 {
513                 .num_frontends = 1,
514                 .fe = {{
515                         .streaming_ctrl   = az6007_streaming_ctrl,
516                         .tuner_attach     = az6007_tuner_attach,
517                         .frontend_attach  = az6007_frontend_attach,
518
519                         /* parameter for the MPEG2-data transfer */
520                         .stream = {
521                                 .type = USB_BULK,
522                                 .count = 10,
523                                 .endpoint = 0x02,
524                                 .u = {
525                                         .bulk = {
526                                                 .buffersize = 4096,
527                                         }
528                                 }
529                         },
530                 }}
531         } },
532         .power_ctrl       = az6007_power_ctrl,
533         .read_mac_address = az6007_read_mac_addr,
534
535         .rc.legacy = {
536                 .rc_map_table  = rc_map_az6007_table,
537                 .rc_map_size  = ARRAY_SIZE(rc_map_az6007_table),
538                 .rc_interval      = 400,
539                 .rc_query         = az6007_rc_query,
540         },
541         .i2c_algo         = &az6007_i2c_algo,
542
543         .num_device_descs = 2,
544         .devices = {
545                 { .name = "AzureWave DTV StarBox DVB-T/C USB2.0 (az6007)",
546                   .cold_ids = { &az6007_usb_table[0], NULL },
547                   .warm_ids = { NULL },
548                 },
549                 { .name = "TerraTec DTV StarBox DVB-T/C USB2.0 (az6007)",
550                   .cold_ids = { &az6007_usb_table[1], NULL },
551                   .warm_ids = { NULL },
552                 },
553                 { NULL },
554         }
555 };
556
557 /* usb specific object needed to register this driver with the usb subsystem */
558 static struct usb_driver az6007_usb_driver = {
559         .name           = "dvb_usb_az6007",
560         .probe          = az6007_usb_probe,
561         .disconnect = dvb_usb_device_exit,
562         .id_table       = az6007_usb_table,
563 };
564
565 /* module stuff */
566 static int __init az6007_usb_module_init(void)
567 {
568         int result;
569         deb_info("az6007 usb module init\n");
570
571         result = usb_register(&az6007_usb_driver);
572         if (result) {
573                 err("usb_register failed. (%d)", result);
574                 return result;
575         }
576
577         return 0;
578 }
579
580 static void __exit az6007_usb_module_exit(void)
581 {
582         /* deregister this driver from the USB subsystem */
583         deb_info("az6007 usb module exit\n");
584         usb_deregister(&az6007_usb_driver);
585 }
586
587 module_init(az6007_usb_module_init);
588 module_exit(az6007_usb_module_exit);
589
590 MODULE_AUTHOR("Henry Wang <Henry.wang@AzureWave.com>");
591 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
592 MODULE_DESCRIPTION("Driver for AzureWave 6007 DVB-C/T USB2.0 and clones");
593 MODULE_VERSION("1.1");
594 MODULE_LICENSE("GPL");