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