14733b84e8b8b57097ec9f9fed1f6f9656b5d826
[~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 mutex            mutex;
57         struct dvb_ca_en50221   ca;
58         unsigned                warm:1;
59         int                     (*gate_ctrl) (struct dvb_frontend *, int);
60         unsigned char           data[4096];
61 };
62
63 static struct drxk_config terratec_h7_drxk = {
64         .adr = 0x29,
65         .parallel_ts = true,
66         .dynamic_clk = true,
67         .single_master = true,
68         .enable_merr_cfg = true,
69         .no_i2c_bridge = false,
70         .chunk_size = 64,
71         .mpeg_out_clk_strength = 0x02,
72         .microcode_name = "dvb-usb-terratec-h7-drxk.fw",
73 };
74
75 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
76 {
77         struct dvb_usb_adapter *adap = fe->sec_priv;
78         struct az6007_device_state *st;
79         int status = 0;
80
81         deb_info("%s: %s\n", __func__, enable ? "enable" : "disable");
82
83         if (!adap)
84                 return -EINVAL;
85
86         st = adap->dev->priv;
87
88         if (!st)
89                 return -EINVAL;
90
91         if (enable)
92                 status = st->gate_ctrl(fe, 1);
93         else
94                 status = st->gate_ctrl(fe, 0);
95
96         return status;
97 }
98
99 static struct mt2063_config az6007_mt2063_config = {
100         .tuner_address = 0x60,
101         .refclock = 36125000,
102 };
103
104 static int __az6007_read(struct usb_device *udev, u8 req, u16 value,
105                             u16 index, u8 *b, int blen)
106 {
107         int ret;
108
109         ret = usb_control_msg(udev,
110                               usb_rcvctrlpipe(udev, 0),
111                               req,
112                               USB_TYPE_VENDOR | USB_DIR_IN,
113                               value, index, b, blen, 5000);
114         if (ret < 0) {
115                 warn("usb read operation failed. (%d)", ret);
116                 return -EIO;
117         }
118
119         deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ", req, value,
120                  index);
121         debug_dump(b, blen, deb_xfer);
122
123         return ret;
124 }
125
126 static int az6007_read(struct dvb_usb_device *d, u8 req, u16 value,
127                             u16 index, u8 *b, int blen)
128 {
129         struct az6007_device_state *st = d->priv;
130         int ret;
131
132         if (mutex_lock_interruptible(&st->mutex) < 0)
133                 return -EAGAIN;
134
135         ret = __az6007_read(d->udev, req, value, index, b, blen);
136
137         mutex_unlock(&st->mutex);
138
139         return ret;
140 }
141
142 static int __az6007_write(struct usb_device *udev, u8 req, u16 value,
143                              u16 index, u8 *b, int blen)
144 {
145         int ret;
146
147         deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ", req, value,
148                  index);
149         debug_dump(b, blen, deb_xfer);
150
151         if (blen > 64) {
152                 err("az6007: tried to write %d bytes, but I2C max size is 64 bytes\n",
153                     blen);
154                 return -EOPNOTSUPP;
155         }
156
157         ret = usb_control_msg(udev,
158                               usb_sndctrlpipe(udev, 0),
159                               req,
160                               USB_TYPE_VENDOR | USB_DIR_OUT,
161                               value, index, b, blen, 5000);
162         if (ret != blen) {
163                 err("usb write operation failed. (%d)", ret);
164                 return -EIO;
165         }
166
167         return 0;
168 }
169
170 static int az6007_write(struct dvb_usb_device *d, u8 req, u16 value,
171                             u16 index, u8 *b, int blen)
172 {
173         struct az6007_device_state *st = d->priv;
174         int ret;
175
176         if (mutex_lock_interruptible(&st->mutex) < 0)
177                 return -EAGAIN;
178
179         ret = __az6007_write(d->udev, req, value, index, b, blen);
180
181         mutex_unlock(&st->mutex);
182
183         return ret;
184 }
185
186 static int az6007_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
187 {
188         struct dvb_usb_device *d = adap->dev;
189
190         deb_info("%s: %s", __func__, onoff ? "enable" : "disable");
191
192         return az6007_write(d, 0xbc, onoff, 0, NULL, 0);
193 }
194
195 /* remote control stuff (does not work with my box) */
196 static int az6007_rc_query(struct dvb_usb_device *d)
197 {
198         struct az6007_device_state *st = d->priv;
199         unsigned code = 0;
200
201         az6007_read(d, AZ6007_READ_IR, 0, 0, st->data, 10);
202
203         if (st->data[1] == 0x44)
204                 return 0;
205
206         if ((st->data[1] ^ st->data[2]) == 0xff)
207                 code = st->data[1];
208         else
209                 code = st->data[1] << 8 | st->data[2];
210
211         if ((st->data[3] ^ st->data[4]) == 0xff)
212                 code = code << 8 | st->data[3];
213         else
214                 code = code << 16 | st->data[3] << 8| st->data[4];
215
216         printk("remote query key: %04x\n", code);
217
218         rc_keydown(d->rc_dev, code, st->data[5]);
219
220         return 0;
221 }
222
223 static int az6007_read_mac_addr(struct dvb_usb_device *d, u8 mac[6])
224 {
225         struct az6007_device_state *st = d->priv;
226         int ret;
227
228         ret = az6007_read(d, AZ6007_READ_DATA, 6, 0, st->data, 6);
229         memcpy(mac, st->data, sizeof(mac));
230
231         if (ret > 0)
232                 deb_info("%s: mac is %02x:%02x:%02x:%02x:%02x:%02x\n",
233                          __func__, mac[0], mac[1], mac[2],
234                          mac[3], mac[4], mac[5]);
235
236         return ret;
237 }
238
239 static int az6007_frontend_attach(struct dvb_usb_adapter *adap)
240 {
241         struct az6007_device_state *st = adap->dev->priv;
242
243         deb_info("attaching demod drxk");
244
245         adap->fe_adap[0].fe = dvb_attach(drxk_attach, &terratec_h7_drxk,
246                                          &adap->dev->i2c_adap);
247         if (!adap->fe_adap[0].fe)
248                 return -EINVAL;
249
250         adap->fe_adap[0].fe->sec_priv = adap;
251         st->gate_ctrl = adap->fe_adap[0].fe->ops.i2c_gate_ctrl;
252         adap->fe_adap[0].fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
253
254         return 0;
255 }
256
257 static int az6007_tuner_attach(struct dvb_usb_adapter *adap)
258 {
259         deb_info("attaching tuner mt2063");
260
261         /* Attach mt2063 to DVB-C frontend */
262         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
263                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1);
264         if (!dvb_attach(mt2063_attach, adap->fe_adap[0].fe,
265                         &az6007_mt2063_config,
266                         &adap->dev->i2c_adap))
267                 return -EINVAL;
268
269         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
270                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0);
271
272         return 0;
273 }
274
275 int az6007_power_ctrl(struct dvb_usb_device *d, int onoff)
276 {
277         struct az6007_device_state *st = d->priv;
278         int ret;
279
280         deb_info("%s()\n", __func__);
281
282         if (!st->warm) {
283                 mutex_init(&st->mutex);
284
285                 ret = az6007_write(d, AZ6007_POWER, 0, 2, NULL, 0);
286                 if (ret < 0)
287                         return ret;
288                 msleep(60);
289                 ret = az6007_write(d, AZ6007_POWER, 1, 4, NULL, 0);
290                 if (ret < 0)
291                         return ret;
292                 msleep(100);
293                 ret = az6007_write(d, AZ6007_POWER, 1, 3, NULL, 0);
294                 if (ret < 0)
295                         return ret;
296                 msleep(20);
297                 ret = az6007_write(d, AZ6007_POWER, 1, 4, NULL, 0);
298                 if (ret < 0)
299                         return ret;
300
301                 msleep(400);
302                 ret = az6007_write(d, FX2_SCON1, 0, 3, NULL, 0);
303                 if (ret < 0)
304                         return ret;
305                 msleep (150);
306                 ret = az6007_write(d, FX2_SCON1, 1, 3, NULL, 0);
307                 if (ret < 0)
308                         return ret;
309                 msleep (430);
310                 ret = az6007_write(d, AZ6007_POWER, 0, 0, NULL, 0);
311                 if (ret < 0)
312                         return ret;
313
314                 st->warm = true;
315
316                 return 0;
317         }
318
319         if (!onoff)
320                 return 0;
321
322         az6007_write(d, AZ6007_POWER, 0, 0, NULL, 0);
323         az6007_write(d, AZ6007_TS_THROUGH, 0, 0, NULL, 0);
324
325         return 0;
326 }
327
328 /* I2C */
329 static int az6007_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
330                            int num)
331 {
332         struct dvb_usb_device *d = i2c_get_adapdata(adap);
333         struct az6007_device_state *st = d->priv;
334         int i, j, len;
335         int ret = 0;
336         u16 index;
337         u16 value;
338         int length;
339         u8 req, addr;
340
341         if (mutex_lock_interruptible(&st->mutex) < 0)
342                 return -EAGAIN;
343
344         for (i = 0; i < num; i++) {
345                 addr = msgs[i].addr << 1;
346                 if (((i + 1) < num)
347                     && (msgs[i].len == 1)
348                     && (!msgs[i].flags & I2C_M_RD)
349                     && (msgs[i + 1].flags & I2C_M_RD)
350                     && (msgs[i].addr == msgs[i + 1].addr)) {
351                         /*
352                          * A write + read xfer for the same address, where
353                          * the first xfer has just 1 byte length.
354                          * Need to join both into one operation
355                          */
356                         if (dvb_usb_az6007_debug & 2)
357                                 printk(KERN_DEBUG
358                                        "az6007 I2C xfer write+read addr=0x%x len=%d/%d: ",
359                                        addr, msgs[i].len, msgs[i + 1].len);
360                         req = AZ6007_I2C_RD;
361                         index = msgs[i].buf[0];
362                         value = addr | (1 << 8);
363                         length = 6 + msgs[i + 1].len;
364                         len = msgs[i + 1].len;
365                         ret = __az6007_read(d->udev, req, value, index, st->data,
366                                                length);
367                         if (ret >= len) {
368                                 for (j = 0; j < len; j++) {
369                                         msgs[i + 1].buf[j] = st->data[j + 5];
370                                         if (dvb_usb_az6007_debug & 2)
371                                                 printk(KERN_CONT
372                                                        "0x%02x ",
373                                                        msgs[i + 1].buf[j]);
374                                 }
375                         } else
376                                 ret = -EIO;
377                         i++;
378                 } else if (!(msgs[i].flags & I2C_M_RD)) {
379                         /* write bytes */
380                         if (dvb_usb_az6007_debug & 2)
381                                 printk(KERN_DEBUG
382                                        "az6007 I2C xfer write addr=0x%x len=%d: ",
383                                        addr, msgs[i].len);
384                         req = AZ6007_I2C_WR;
385                         index = msgs[i].buf[0];
386                         value = addr | (1 << 8);
387                         length = msgs[i].len - 1;
388                         len = msgs[i].len - 1;
389                         if (dvb_usb_az6007_debug & 2)
390                                 printk(KERN_CONT "(0x%02x) ", msgs[i].buf[0]);
391                         for (j = 0; j < len; j++) {
392                                 st->data[j] = msgs[i].buf[j + 1];
393                                 if (dvb_usb_az6007_debug & 2)
394                                         printk(KERN_CONT "0x%02x ", st->data[j]);
395                         }
396                         ret =  __az6007_write(d->udev, req, value, index, st->data,
397                                                  length);
398                 } else {
399                         /* read bytes */
400                         if (dvb_usb_az6007_debug & 2)
401                                 printk(KERN_DEBUG
402                                        "az6007 I2C xfer read addr=0x%x len=%d: ",
403                                        addr, msgs[i].len);
404                         req = AZ6007_I2C_RD;
405                         index = msgs[i].buf[0];
406                         value = addr;
407                         length = msgs[i].len + 6;
408                         len = msgs[i].len;
409                         ret = __az6007_read(d->udev, req, value, index, st->data,
410                                                length);
411                         for (j = 0; j < len; j++) {
412                                 msgs[i].buf[j] = st->data[j + 5];
413                                 if (dvb_usb_az6007_debug & 2)
414                                         printk(KERN_CONT
415                                                "0x%02x ", st->data[j + 5]);
416                         }
417                 }
418                 if (dvb_usb_az6007_debug & 2)
419                         printk(KERN_CONT "\n");
420                 if (ret < 0)
421                         goto err;
422         }
423 err:
424         mutex_unlock(&st->mutex);
425
426         if (ret < 0) {
427                 info("%s ERROR: %i", __func__, ret);
428                 return ret;
429         }
430         return num;
431 }
432
433 static u32 az6007_i2c_func(struct i2c_adapter *adapter)
434 {
435         return I2C_FUNC_I2C;
436 }
437
438 static struct i2c_algorithm az6007_i2c_algo = {
439         .master_xfer = az6007_i2c_xfer,
440         .functionality = az6007_i2c_func,
441 };
442
443 int az6007_identify_state(struct usb_device *udev,
444                           struct dvb_usb_device_properties *props,
445                           struct dvb_usb_device_description **desc, int *cold)
446 {
447         int ret;
448         u8 *mac;
449
450         mac = kmalloc(6, GFP_ATOMIC);
451         if (!mac)
452                 return -ENOMEM;
453
454         /* Try to read the mac address */
455         ret = __az6007_read(udev, AZ6007_READ_DATA, 6, 0, mac, 6);
456         if (ret == 6)
457                 *cold = 0;
458         else
459                 *cold = 1;
460
461         kfree(mac);
462
463         if (*cold) {
464                 __az6007_write(udev, 0x09, 1, 0, NULL, 0);
465                 __az6007_write(udev, 0x00, 0, 0, NULL, 0);
466                 __az6007_write(udev, 0x00, 0, 0, NULL, 0);
467         }
468
469         deb_info("Device is on %s state\n", *cold? "warm" : "cold");
470         return 0;
471 }
472
473 static struct dvb_usb_device_properties az6007_properties;
474
475 static int az6007_usb_probe(struct usb_interface *intf,
476                             const struct usb_device_id *id)
477 {
478         return dvb_usb_device_init(intf, &az6007_properties,
479                                    THIS_MODULE, NULL, adapter_nr);
480 }
481
482 static struct usb_device_id az6007_usb_table[] = {
483         {USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_6007)},
484         {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_H7)},
485         {0},
486 };
487
488 MODULE_DEVICE_TABLE(usb, az6007_usb_table);
489
490 static struct dvb_usb_device_properties az6007_properties = {
491         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
492         .usb_ctrl = CYPRESS_FX2,
493         .firmware            = "dvb-usb-terratec-h7-az6007.fw",
494         .no_reconnect        = 1,
495         .size_of_priv        = sizeof(struct az6007_device_state),
496         .identify_state      = az6007_identify_state,
497         .num_adapters = 1,
498         .adapter = {
499                 {
500                 .num_frontends = 1,
501                 .fe = {{
502                         .streaming_ctrl   = az6007_streaming_ctrl,
503                         .tuner_attach     = az6007_tuner_attach,
504                         .frontend_attach  = az6007_frontend_attach,
505
506                         /* parameter for the MPEG2-data transfer */
507                         .stream = {
508                                 .type = USB_BULK,
509                                 .count = 10,
510                                 .endpoint = 0x02,
511                                 .u = {
512                                         .bulk = {
513                                                 .buffersize = 4096,
514                                         }
515                                 }
516                         },
517                 }}
518         } },
519         .power_ctrl       = az6007_power_ctrl,
520         .read_mac_address = az6007_read_mac_addr,
521
522         .rc.core = {
523                 .rc_interval      = 400,
524                 .rc_codes         = RC_MAP_NEC_TERRATEC_CINERGY_XS,
525                 .module_name      = "az6007",
526                 .rc_query         = az6007_rc_query,
527                 .allowed_protos   = RC_TYPE_NEC,
528         },
529         .i2c_algo         = &az6007_i2c_algo,
530
531         .num_device_descs = 2,
532         .devices = {
533                 { .name = "AzureWave DTV StarBox DVB-T/C USB2.0 (az6007)",
534                   .cold_ids = { &az6007_usb_table[0], NULL },
535                   .warm_ids = { NULL },
536                 },
537                 { .name = "TerraTec DTV StarBox DVB-T/C USB2.0 (az6007)",
538                   .cold_ids = { &az6007_usb_table[1], NULL },
539                   .warm_ids = { NULL },
540                 },
541                 { NULL },
542         }
543 };
544
545 /* usb specific object needed to register this driver with the usb subsystem */
546 static struct usb_driver az6007_usb_driver = {
547         .name           = "dvb_usb_az6007",
548         .probe          = az6007_usb_probe,
549         .disconnect = dvb_usb_device_exit,
550         .id_table       = az6007_usb_table,
551 };
552
553 /* module stuff */
554 static int __init az6007_usb_module_init(void)
555 {
556         int result;
557         deb_info("az6007 usb module init\n");
558
559         result = usb_register(&az6007_usb_driver);
560         if (result) {
561                 err("usb_register failed. (%d)", result);
562                 return result;
563         }
564
565         return 0;
566 }
567
568 static void __exit az6007_usb_module_exit(void)
569 {
570         /* deregister this driver from the USB subsystem */
571         deb_info("az6007 usb module exit\n");
572         usb_deregister(&az6007_usb_driver);
573 }
574
575 module_init(az6007_usb_module_init);
576 module_exit(az6007_usb_module_exit);
577
578 MODULE_AUTHOR("Henry Wang <Henry.wang@AzureWave.com>");
579 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
580 MODULE_DESCRIPTION("Driver for AzureWave 6007 DVB-C/T USB2.0 and clones");
581 MODULE_VERSION("1.1");
582 MODULE_LICENSE("GPL");