[media] az6007: CodingStyle 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  * 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         rc_keydown(d->rc_dev, code, st->data[5]);
217
218         return 0;
219 }
220
221 static int az6007_read_mac_addr(struct dvb_usb_device *d, u8 mac[6])
222 {
223         struct az6007_device_state *st = d->priv;
224         int ret;
225
226         ret = az6007_read(d, AZ6007_READ_DATA, 6, 0, st->data, 6);
227         memcpy(mac, st->data, sizeof(mac));
228
229         if (ret > 0)
230                 deb_info("%s: mac is %02x:%02x:%02x:%02x:%02x:%02x\n",
231                          __func__, mac[0], mac[1], mac[2],
232                          mac[3], mac[4], mac[5]);
233
234         return ret;
235 }
236
237 static int az6007_frontend_attach(struct dvb_usb_adapter *adap)
238 {
239         struct az6007_device_state *st = adap->dev->priv;
240
241         deb_info("attaching demod drxk");
242
243         adap->fe_adap[0].fe = dvb_attach(drxk_attach, &terratec_h7_drxk,
244                                          &adap->dev->i2c_adap);
245         if (!adap->fe_adap[0].fe)
246                 return -EINVAL;
247
248         adap->fe_adap[0].fe->sec_priv = adap;
249         st->gate_ctrl = adap->fe_adap[0].fe->ops.i2c_gate_ctrl;
250         adap->fe_adap[0].fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
251
252         return 0;
253 }
254
255 static int az6007_tuner_attach(struct dvb_usb_adapter *adap)
256 {
257         deb_info("attaching tuner mt2063");
258
259         /* Attach mt2063 to DVB-C frontend */
260         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
261                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1);
262         if (!dvb_attach(mt2063_attach, adap->fe_adap[0].fe,
263                         &az6007_mt2063_config,
264                         &adap->dev->i2c_adap))
265                 return -EINVAL;
266
267         if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
268                 adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0);
269
270         return 0;
271 }
272
273 int az6007_power_ctrl(struct dvb_usb_device *d, int onoff)
274 {
275         struct az6007_device_state *st = d->priv;
276         int ret;
277
278         deb_info("%s()\n", __func__);
279
280         if (!st->warm) {
281                 mutex_init(&st->mutex);
282
283                 ret = az6007_write(d, AZ6007_POWER, 0, 2, NULL, 0);
284                 if (ret < 0)
285                         return ret;
286                 msleep(60);
287                 ret = az6007_write(d, AZ6007_POWER, 1, 4, NULL, 0);
288                 if (ret < 0)
289                         return ret;
290                 msleep(100);
291                 ret = az6007_write(d, AZ6007_POWER, 1, 3, NULL, 0);
292                 if (ret < 0)
293                         return ret;
294                 msleep(20);
295                 ret = az6007_write(d, AZ6007_POWER, 1, 4, NULL, 0);
296                 if (ret < 0)
297                         return ret;
298
299                 msleep(400);
300                 ret = az6007_write(d, FX2_SCON1, 0, 3, NULL, 0);
301                 if (ret < 0)
302                         return ret;
303                 msleep(150);
304                 ret = az6007_write(d, FX2_SCON1, 1, 3, NULL, 0);
305                 if (ret < 0)
306                         return ret;
307                 msleep(430);
308                 ret = az6007_write(d, AZ6007_POWER, 0, 0, NULL, 0);
309                 if (ret < 0)
310                         return ret;
311
312                 st->warm = true;
313
314                 return 0;
315         }
316
317         if (!onoff)
318                 return 0;
319
320         az6007_write(d, AZ6007_POWER, 0, 0, NULL, 0);
321         az6007_write(d, AZ6007_TS_THROUGH, 0, 0, NULL, 0);
322
323         return 0;
324 }
325
326 /* I2C */
327 static int az6007_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
328                            int num)
329 {
330         struct dvb_usb_device *d = i2c_get_adapdata(adap);
331         struct az6007_device_state *st = d->priv;
332         int i, j, len;
333         int ret = 0;
334         u16 index;
335         u16 value;
336         int length;
337         u8 req, addr;
338
339         if (mutex_lock_interruptible(&st->mutex) < 0)
340                 return -EAGAIN;
341
342         for (i = 0; i < num; i++) {
343                 addr = msgs[i].addr << 1;
344                 if (((i + 1) < num)
345                     && (msgs[i].len == 1)
346                     && (!msgs[i].flags & I2C_M_RD)
347                     && (msgs[i + 1].flags & I2C_M_RD)
348                     && (msgs[i].addr == msgs[i + 1].addr)) {
349                         /*
350                          * A write + read xfer for the same address, where
351                          * the first xfer has just 1 byte length.
352                          * Need to join both into one operation
353                          */
354                         if (dvb_usb_az6007_debug & 2)
355                                 printk(KERN_DEBUG
356                                        "az6007 I2C xfer write+read addr=0x%x len=%d/%d: ",
357                                        addr, msgs[i].len, msgs[i + 1].len);
358                         req = AZ6007_I2C_RD;
359                         index = msgs[i].buf[0];
360                         value = addr | (1 << 8);
361                         length = 6 + msgs[i + 1].len;
362                         len = msgs[i + 1].len;
363                         ret = __az6007_read(d->udev, req, value, index,
364                                             st->data, length);
365                         if (ret >= len) {
366                                 for (j = 0; j < len; j++) {
367                                         msgs[i + 1].buf[j] = st->data[j + 5];
368                                         if (dvb_usb_az6007_debug & 2)
369                                                 printk(KERN_CONT
370                                                        "0x%02x ",
371                                                        msgs[i + 1].buf[j]);
372                                 }
373                         } else
374                                 ret = -EIO;
375                         i++;
376                 } else if (!(msgs[i].flags & I2C_M_RD)) {
377                         /* write bytes */
378                         if (dvb_usb_az6007_debug & 2)
379                                 printk(KERN_DEBUG
380                                        "az6007 I2C xfer write addr=0x%x len=%d: ",
381                                        addr, msgs[i].len);
382                         req = AZ6007_I2C_WR;
383                         index = msgs[i].buf[0];
384                         value = addr | (1 << 8);
385                         length = msgs[i].len - 1;
386                         len = msgs[i].len - 1;
387                         if (dvb_usb_az6007_debug & 2)
388                                 printk(KERN_CONT "(0x%02x) ", msgs[i].buf[0]);
389                         for (j = 0; j < len; j++) {
390                                 st->data[j] = msgs[i].buf[j + 1];
391                                 if (dvb_usb_az6007_debug & 2)
392                                         printk(KERN_CONT "0x%02x ",
393                                                st->data[j]);
394                         }
395                         ret =  __az6007_write(d->udev, req, value, index,
396                                               st->data, length);
397                 } else {
398                         /* read bytes */
399                         if (dvb_usb_az6007_debug & 2)
400                                 printk(KERN_DEBUG
401                                        "az6007 I2C xfer read addr=0x%x len=%d: ",
402                                        addr, msgs[i].len);
403                         req = AZ6007_I2C_RD;
404                         index = msgs[i].buf[0];
405                         value = addr;
406                         length = msgs[i].len + 6;
407                         len = msgs[i].len;
408                         ret = __az6007_read(d->udev, req, value, index,
409                                             st->data, length);
410                         for (j = 0; j < len; j++) {
411                                 msgs[i].buf[j] = st->data[j + 5];
412                                 if (dvb_usb_az6007_debug & 2)
413                                         printk(KERN_CONT
414                                                "0x%02x ", st->data[j + 5]);
415                         }
416                 }
417                 if (dvb_usb_az6007_debug & 2)
418                         printk(KERN_CONT "\n");
419                 if (ret < 0)
420                         goto err;
421         }
422 err:
423         mutex_unlock(&st->mutex);
424
425         if (ret < 0) {
426                 info("%s ERROR: %i", __func__, ret);
427                 return ret;
428         }
429         return num;
430 }
431
432 static u32 az6007_i2c_func(struct i2c_adapter *adapter)
433 {
434         return I2C_FUNC_I2C;
435 }
436
437 static struct i2c_algorithm az6007_i2c_algo = {
438         .master_xfer = az6007_i2c_xfer,
439         .functionality = az6007_i2c_func,
440 };
441
442 int az6007_identify_state(struct usb_device *udev,
443                           struct dvb_usb_device_properties *props,
444                           struct dvb_usb_device_description **desc, int *cold)
445 {
446         int ret;
447         u8 *mac;
448
449         mac = kmalloc(6, GFP_ATOMIC);
450         if (!mac)
451                 return -ENOMEM;
452
453         /* Try to read the mac address */
454         ret = __az6007_read(udev, AZ6007_READ_DATA, 6, 0, mac, 6);
455         if (ret == 6)
456                 *cold = 0;
457         else
458                 *cold = 1;
459
460         kfree(mac);
461
462         if (*cold) {
463                 __az6007_write(udev, 0x09, 1, 0, NULL, 0);
464                 __az6007_write(udev, 0x00, 0, 0, NULL, 0);
465                 __az6007_write(udev, 0x00, 0, 0, NULL, 0);
466         }
467
468         deb_info("Device is on %s state\n", *cold ? "warm" : "cold");
469         return 0;
470 }
471
472 static struct dvb_usb_device_properties az6007_properties;
473
474 static int az6007_usb_probe(struct usb_interface *intf,
475                             const struct usb_device_id *id)
476 {
477         return dvb_usb_device_init(intf, &az6007_properties,
478                                    THIS_MODULE, NULL, adapter_nr);
479 }
480
481 static struct usb_device_id az6007_usb_table[] = {
482         {USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_6007)},
483         {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_H7)},
484         {0},
485 };
486
487 MODULE_DEVICE_TABLE(usb, az6007_usb_table);
488
489 static struct dvb_usb_device_properties az6007_properties = {
490         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
491         .usb_ctrl = CYPRESS_FX2,
492         .firmware            = "dvb-usb-terratec-h7-az6007.fw",
493         .no_reconnect        = 1,
494         .size_of_priv        = sizeof(struct az6007_device_state),
495         .identify_state      = az6007_identify_state,
496         .num_adapters = 1,
497         .adapter = {
498                 {
499                 .num_frontends = 1,
500                 .fe = {{
501                         .streaming_ctrl   = az6007_streaming_ctrl,
502                         .tuner_attach     = az6007_tuner_attach,
503                         .frontend_attach  = az6007_frontend_attach,
504
505                         /* parameter for the MPEG2-data transfer */
506                         .stream = {
507                                 .type = USB_BULK,
508                                 .count = 10,
509                                 .endpoint = 0x02,
510                                 .u = {
511                                         .bulk = {
512                                                 .buffersize = 4096,
513                                         }
514                                 }
515                         },
516                 } }
517         } },
518         .power_ctrl       = az6007_power_ctrl,
519         .read_mac_address = az6007_read_mac_addr,
520
521         .rc.core = {
522                 .rc_interval      = 400,
523                 .rc_codes         = RC_MAP_NEC_TERRATEC_CINERGY_XS,
524                 .module_name      = "az6007",
525                 .rc_query         = az6007_rc_query,
526                 .allowed_protos   = RC_TYPE_NEC,
527         },
528         .i2c_algo         = &az6007_i2c_algo,
529
530         .num_device_descs = 2,
531         .devices = {
532                 { .name = "AzureWave DTV StarBox DVB-T/C USB2.0 (az6007)",
533                   .cold_ids = { &az6007_usb_table[0], NULL },
534                   .warm_ids = { NULL },
535                 },
536                 { .name = "TerraTec DTV StarBox DVB-T/C USB2.0 (az6007)",
537                   .cold_ids = { &az6007_usb_table[1], NULL },
538                   .warm_ids = { NULL },
539                 },
540                 { NULL },
541         }
542 };
543
544 /* usb specific object needed to register this driver with the usb subsystem */
545 static struct usb_driver az6007_usb_driver = {
546         .name           = "dvb_usb_az6007",
547         .probe          = az6007_usb_probe,
548         .disconnect = dvb_usb_device_exit,
549         .id_table       = az6007_usb_table,
550 };
551
552 /* module stuff */
553 static int __init az6007_usb_module_init(void)
554 {
555         int result;
556         deb_info("az6007 usb module init\n");
557
558         result = usb_register(&az6007_usb_driver);
559         if (result) {
560                 err("usb_register failed. (%d)", result);
561                 return result;
562         }
563
564         return 0;
565 }
566
567 static void __exit az6007_usb_module_exit(void)
568 {
569         /* deregister this driver from the USB subsystem */
570         deb_info("az6007 usb module exit\n");
571         usb_deregister(&az6007_usb_driver);
572 }
573
574 module_init(az6007_usb_module_init);
575 module_exit(az6007_usb_module_exit);
576
577 MODULE_AUTHOR("Henry Wang <Henry.wang@AzureWave.com>");
578 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
579 MODULE_DESCRIPTION("Driver for AzureWave 6007 DVB-C/T USB2.0 and clones");
580 MODULE_VERSION("1.1");
581 MODULE_LICENSE("GPL");