Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

Linux/drivers/media/usb/dvb-usb-v2/mxl111sf.c

  1 /*
  2  * Copyright (C) 2010-2014 Michael Krufky (mkrufky@linuxtv.org)
  3  *
  4  *   This program is free software; you can redistribute it and/or modify it
  5  *   under the terms of the GNU General Public License as published by the Free
  6  *   Software Foundation, version 2.
  7  *
  8  * see Documentation/dvb/README.dvb-usb for more information
  9  */
 10 
 11 #include <linux/vmalloc.h>
 12 #include <linux/i2c.h>
 13 #include <media/tuner.h>
 14 
 15 #include "mxl111sf.h"
 16 #include "mxl111sf-reg.h"
 17 #include "mxl111sf-phy.h"
 18 #include "mxl111sf-i2c.h"
 19 #include "mxl111sf-gpio.h"
 20 
 21 #include "mxl111sf-demod.h"
 22 #include "mxl111sf-tuner.h"
 23 
 24 #include "lgdt3305.h"
 25 #include "lg2160.h"
 26 
 27 /* Max transfer size done by I2C transfer functions */
 28 #define MAX_XFER_SIZE  64
 29 
 30 int dvb_usb_mxl111sf_debug;
 31 module_param_named(debug, dvb_usb_mxl111sf_debug, int, 0644);
 32 MODULE_PARM_DESC(debug, "set debugging level "
 33                  "(1=info, 2=xfer, 4=i2c, 8=reg, 16=adv (or-able)).");
 34 
 35 static int dvb_usb_mxl111sf_isoc;
 36 module_param_named(isoc, dvb_usb_mxl111sf_isoc, int, 0644);
 37 MODULE_PARM_DESC(isoc, "enable usb isoc xfer (0=bulk, 1=isoc).");
 38 
 39 static int dvb_usb_mxl111sf_spi;
 40 module_param_named(spi, dvb_usb_mxl111sf_spi, int, 0644);
 41 MODULE_PARM_DESC(spi, "use spi rather than tp for data xfer (0=tp, 1=spi).");
 42 
 43 #define ANT_PATH_AUTO 0
 44 #define ANT_PATH_EXTERNAL 1
 45 #define ANT_PATH_INTERNAL 2
 46 
 47 static int dvb_usb_mxl111sf_rfswitch =
 48 #if 0
 49                 ANT_PATH_AUTO;
 50 #else
 51                 ANT_PATH_EXTERNAL;
 52 #endif
 53 
 54 module_param_named(rfswitch, dvb_usb_mxl111sf_rfswitch, int, 0644);
 55 MODULE_PARM_DESC(rfswitch, "force rf switch position (0=auto, 1=ext, 2=int).");
 56 
 57 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 58 
 59 int mxl111sf_ctrl_msg(struct dvb_usb_device *d,
 60                       u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
 61 {
 62         int wo = (rbuf == NULL || rlen == 0); /* write-only */
 63         int ret;
 64         u8 sndbuf[MAX_XFER_SIZE];
 65 
 66         if (1 + wlen > sizeof(sndbuf)) {
 67                 pr_warn("%s: len=%d is too big!\n", __func__, wlen);
 68                 return -EOPNOTSUPP;
 69         }
 70 
 71         pr_debug("%s(wlen = %d, rlen = %d)\n", __func__, wlen, rlen);
 72 
 73         memset(sndbuf, 0, 1+wlen);
 74 
 75         sndbuf[0] = cmd;
 76         memcpy(&sndbuf[1], wbuf, wlen);
 77 
 78         ret = (wo) ? dvb_usbv2_generic_write(d, sndbuf, 1+wlen) :
 79                 dvb_usbv2_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen);
 80         mxl_fail(ret);
 81 
 82         return ret;
 83 }
 84 
 85 /* ------------------------------------------------------------------------ */
 86 
 87 #define MXL_CMD_REG_READ        0xaa
 88 #define MXL_CMD_REG_WRITE       0x55
 89 
 90 int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data)
 91 {
 92         u8 buf[2];
 93         int ret;
 94 
 95         ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_READ, &addr, 1, buf, 2);
 96         if (mxl_fail(ret)) {
 97                 mxl_debug("error reading reg: 0x%02x", addr);
 98                 goto fail;
 99         }
100 
101         if (buf[0] == addr)
102                 *data = buf[1];
103         else {
104                 pr_err("invalid response reading reg: 0x%02x != 0x%02x, 0x%02x",
105                     addr, buf[0], buf[1]);
106                 ret = -EINVAL;
107         }
108 
109         pr_debug("R: (0x%02x, 0x%02x)\n", addr, buf[1]);
110 fail:
111         return ret;
112 }
113 
114 int mxl111sf_write_reg(struct mxl111sf_state *state, u8 addr, u8 data)
115 {
116         u8 buf[] = { addr, data };
117         int ret;
118 
119         pr_debug("W: (0x%02x, 0x%02x)\n", addr, data);
120 
121         ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_WRITE, buf, 2, NULL, 0);
122         if (mxl_fail(ret))
123                 pr_err("error writing reg: 0x%02x, val: 0x%02x", addr, data);
124         return ret;
125 }
126 
127 /* ------------------------------------------------------------------------ */
128 
129 int mxl111sf_write_reg_mask(struct mxl111sf_state *state,
130                                    u8 addr, u8 mask, u8 data)
131 {
132         int ret;
133         u8 val = 0;
134 
135         if (mask != 0xff) {
136                 ret = mxl111sf_read_reg(state, addr, &val);
137 #if 1
138                 /* dont know why this usually errors out on the first try */
139                 if (mxl_fail(ret))
140                         pr_err("error writing addr: 0x%02x, mask: 0x%02x, "
141                             "data: 0x%02x, retrying...", addr, mask, data);
142 
143                 ret = mxl111sf_read_reg(state, addr, &val);
144 #endif
145                 if (mxl_fail(ret))
146                         goto fail;
147         }
148         val &= ~mask;
149         val |= data;
150 
151         ret = mxl111sf_write_reg(state, addr, val);
152         mxl_fail(ret);
153 fail:
154         return ret;
155 }
156 
157 /* ------------------------------------------------------------------------ */
158 
159 int mxl111sf_ctrl_program_regs(struct mxl111sf_state *state,
160                                struct mxl111sf_reg_ctrl_info *ctrl_reg_info)
161 {
162         int i, ret = 0;
163 
164         for (i = 0;  ctrl_reg_info[i].addr |
165                      ctrl_reg_info[i].mask |
166                      ctrl_reg_info[i].data;  i++) {
167 
168                 ret = mxl111sf_write_reg_mask(state,
169                                               ctrl_reg_info[i].addr,
170                                               ctrl_reg_info[i].mask,
171                                               ctrl_reg_info[i].data);
172                 if (mxl_fail(ret)) {
173                         pr_err("failed on reg #%d (0x%02x)", i,
174                             ctrl_reg_info[i].addr);
175                         break;
176                 }
177         }
178         return ret;
179 }
180 
181 /* ------------------------------------------------------------------------ */
182 
183 static int mxl1x1sf_get_chip_info(struct mxl111sf_state *state)
184 {
185         int ret;
186         u8 id, ver;
187         char *mxl_chip, *mxl_rev;
188 
189         if ((state->chip_id) && (state->chip_ver))
190                 return 0;
191 
192         ret = mxl111sf_read_reg(state, CHIP_ID_REG, &id);
193         if (mxl_fail(ret))
194                 goto fail;
195         state->chip_id = id;
196 
197         ret = mxl111sf_read_reg(state, TOP_CHIP_REV_ID_REG, &ver);
198         if (mxl_fail(ret))
199                 goto fail;
200         state->chip_ver = ver;
201 
202         switch (id) {
203         case 0x61:
204                 mxl_chip = "MxL101SF";
205                 break;
206         case 0x63:
207                 mxl_chip = "MxL111SF";
208                 break;
209         default:
210                 mxl_chip = "UNKNOWN MxL1X1";
211                 break;
212         }
213         switch (ver) {
214         case 0x36:
215                 state->chip_rev = MXL111SF_V6;
216                 mxl_rev = "v6";
217                 break;
218         case 0x08:
219                 state->chip_rev = MXL111SF_V8_100;
220                 mxl_rev = "v8_100";
221                 break;
222         case 0x18:
223                 state->chip_rev = MXL111SF_V8_200;
224                 mxl_rev = "v8_200";
225                 break;
226         default:
227                 state->chip_rev = 0;
228                 mxl_rev = "UNKNOWN REVISION";
229                 break;
230         }
231         pr_info("%s detected, %s (0x%x)", mxl_chip, mxl_rev, ver);
232 fail:
233         return ret;
234 }
235 
236 #define get_chip_info(state)                                            \
237 ({                                                                      \
238         int ___ret;                                                     \
239         ___ret = mxl1x1sf_get_chip_info(state);                         \
240         if (mxl_fail(___ret)) {                                         \
241                 mxl_debug("failed to get chip info"                     \
242                           " on first probe attempt");                   \
243                 ___ret = mxl1x1sf_get_chip_info(state);                 \
244                 if (mxl_fail(___ret))                                   \
245                         pr_err("failed to get chip info during probe"); \
246                 else                                                    \
247                         mxl_debug("probe needed a retry "               \
248                                   "in order to succeed.");              \
249         }                                                               \
250         ___ret;                                                         \
251 })
252 
253 /* ------------------------------------------------------------------------ */
254 #if 0
255 static int mxl111sf_power_ctrl(struct dvb_usb_device *d, int onoff)
256 {
257         /* power control depends on which adapter is being woken:
258          * save this for init, instead, via mxl111sf_adap_fe_init */
259         return 0;
260 }
261 #endif
262 
263 static int mxl111sf_adap_fe_init(struct dvb_frontend *fe)
264 {
265         struct dvb_usb_device *d = fe_to_d(fe);
266         struct mxl111sf_state *state = fe_to_priv(fe);
267         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
268         int err;
269 
270         /* exit if we didn't initialize the driver yet */
271         if (!state->chip_id) {
272                 mxl_debug("driver not yet initialized, exit.");
273                 goto fail;
274         }
275 
276         pr_debug("%s()\n", __func__);
277 
278         mutex_lock(&state->fe_lock);
279 
280         state->alt_mode = adap_state->alt_mode;
281 
282         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
283                 pr_err("set interface failed");
284 
285         err = mxl1x1sf_soft_reset(state);
286         mxl_fail(err);
287         err = mxl111sf_init_tuner_demod(state);
288         mxl_fail(err);
289         err = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
290 
291         mxl_fail(err);
292         err = mxl111sf_enable_usb_output(state);
293         mxl_fail(err);
294         err = mxl1x1sf_top_master_ctrl(state, 1);
295         mxl_fail(err);
296 
297         if ((MXL111SF_GPIO_MOD_DVBT != adap_state->gpio_mode) &&
298             (state->chip_rev > MXL111SF_V6)) {
299                 mxl111sf_config_pin_mux_modes(state,
300                                               PIN_MUX_TS_SPI_IN_MODE_1);
301                 mxl_fail(err);
302         }
303         err = mxl111sf_init_port_expander(state);
304         if (!mxl_fail(err)) {
305                 state->gpio_mode = adap_state->gpio_mode;
306                 err = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
307                 mxl_fail(err);
308 #if 0
309                 err = fe->ops.init(fe);
310 #endif
311                 msleep(100); /* add short delay after enabling
312                               * the demod before touching it */
313         }
314 
315         return (adap_state->fe_init) ? adap_state->fe_init(fe) : 0;
316 fail:
317         return -ENODEV;
318 }
319 
320 static int mxl111sf_adap_fe_sleep(struct dvb_frontend *fe)
321 {
322         struct mxl111sf_state *state = fe_to_priv(fe);
323         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
324         int err;
325 
326         /* exit if we didn't initialize the driver yet */
327         if (!state->chip_id) {
328                 mxl_debug("driver not yet initialized, exit.");
329                 goto fail;
330         }
331 
332         pr_debug("%s()\n", __func__);
333 
334         err = (adap_state->fe_sleep) ? adap_state->fe_sleep(fe) : 0;
335 
336         mutex_unlock(&state->fe_lock);
337 
338         return err;
339 fail:
340         return -ENODEV;
341 }
342 
343 
344 static int mxl111sf_ep6_streaming_ctrl(struct dvb_frontend *fe, int onoff)
345 {
346         struct mxl111sf_state *state = fe_to_priv(fe);
347         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
348         int ret = 0;
349 
350         pr_debug("%s(%d)\n", __func__, onoff);
351 
352         if (onoff) {
353                 ret = mxl111sf_enable_usb_output(state);
354                 mxl_fail(ret);
355                 ret = mxl111sf_config_mpeg_in(state, 1, 1,
356                                               adap_state->ep6_clockphase,
357                                               0, 0);
358                 mxl_fail(ret);
359 #if 0
360         } else {
361                 ret = mxl111sf_disable_656_port(state);
362                 mxl_fail(ret);
363 #endif
364         }
365 
366         return ret;
367 }
368 
369 static int mxl111sf_ep5_streaming_ctrl(struct dvb_frontend *fe, int onoff)
370 {
371         struct mxl111sf_state *state = fe_to_priv(fe);
372         int ret = 0;
373 
374         pr_debug("%s(%d)\n", __func__, onoff);
375 
376         if (onoff) {
377                 ret = mxl111sf_enable_usb_output(state);
378                 mxl_fail(ret);
379 
380                 ret = mxl111sf_init_i2s_port(state, 200);
381                 mxl_fail(ret);
382                 ret = mxl111sf_config_i2s(state, 0, 15);
383                 mxl_fail(ret);
384         } else {
385                 ret = mxl111sf_disable_i2s_port(state);
386                 mxl_fail(ret);
387         }
388         if (state->chip_rev > MXL111SF_V6)
389                 ret = mxl111sf_config_spi(state, onoff);
390         mxl_fail(ret);
391 
392         return ret;
393 }
394 
395 static int mxl111sf_ep4_streaming_ctrl(struct dvb_frontend *fe, int onoff)
396 {
397         struct mxl111sf_state *state = fe_to_priv(fe);
398         int ret = 0;
399 
400         pr_debug("%s(%d)\n", __func__, onoff);
401 
402         if (onoff) {
403                 ret = mxl111sf_enable_usb_output(state);
404                 mxl_fail(ret);
405         }
406 
407         return ret;
408 }
409 
410 /* ------------------------------------------------------------------------ */
411 
412 static struct lgdt3305_config hauppauge_lgdt3305_config = {
413         .i2c_addr           = 0xb2 >> 1,
414         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
415         .tpclk_edge         = LGDT3305_TPCLK_RISING_EDGE,
416         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
417         .deny_i2c_rptr      = 1,
418         .spectral_inversion = 0,
419         .qam_if_khz         = 6000,
420         .vsb_if_khz         = 6000,
421 };
422 
423 static int mxl111sf_lgdt3305_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
424 {
425         struct dvb_usb_device *d = adap_to_d(adap);
426         struct mxl111sf_state *state = d_to_priv(d);
427         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
428         int ret;
429 
430         pr_debug("%s()\n", __func__);
431 
432         /* save a pointer to the dvb_usb_device in device state */
433         state->d = d;
434         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
435         state->alt_mode = adap_state->alt_mode;
436 
437         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
438                 pr_err("set interface failed");
439 
440         state->gpio_mode = MXL111SF_GPIO_MOD_ATSC;
441         adap_state->gpio_mode = state->gpio_mode;
442         adap_state->device_mode = MXL_TUNER_MODE;
443         adap_state->ep6_clockphase = 1;
444 
445         ret = mxl1x1sf_soft_reset(state);
446         if (mxl_fail(ret))
447                 goto fail;
448         ret = mxl111sf_init_tuner_demod(state);
449         if (mxl_fail(ret))
450                 goto fail;
451 
452         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
453         if (mxl_fail(ret))
454                 goto fail;
455 
456         ret = mxl111sf_enable_usb_output(state);
457         if (mxl_fail(ret))
458                 goto fail;
459         ret = mxl1x1sf_top_master_ctrl(state, 1);
460         if (mxl_fail(ret))
461                 goto fail;
462 
463         ret = mxl111sf_init_port_expander(state);
464         if (mxl_fail(ret))
465                 goto fail;
466         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
467         if (mxl_fail(ret))
468                 goto fail;
469 
470         adap->fe[fe_id] = dvb_attach(lgdt3305_attach,
471                                  &hauppauge_lgdt3305_config,
472                                  &d->i2c_adap);
473         if (adap->fe[fe_id]) {
474                 state->num_frontends++;
475                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
476                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
477                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
478                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
479                 return 0;
480         }
481         ret = -EIO;
482 fail:
483         return ret;
484 }
485 
486 static struct lg2160_config hauppauge_lg2160_config = {
487         .lg_chip            = LG2160,
488         .i2c_addr           = 0x1c >> 1,
489         .deny_i2c_rptr      = 1,
490         .spectral_inversion = 0,
491         .if_khz             = 6000,
492 };
493 
494 static int mxl111sf_lg2160_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
495 {
496         struct dvb_usb_device *d = adap_to_d(adap);
497         struct mxl111sf_state *state = d_to_priv(d);
498         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
499         int ret;
500 
501         pr_debug("%s()\n", __func__);
502 
503         /* save a pointer to the dvb_usb_device in device state */
504         state->d = d;
505         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
506         state->alt_mode = adap_state->alt_mode;
507 
508         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
509                 pr_err("set interface failed");
510 
511         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
512         adap_state->gpio_mode = state->gpio_mode;
513         adap_state->device_mode = MXL_TUNER_MODE;
514         adap_state->ep6_clockphase = 1;
515 
516         ret = mxl1x1sf_soft_reset(state);
517         if (mxl_fail(ret))
518                 goto fail;
519         ret = mxl111sf_init_tuner_demod(state);
520         if (mxl_fail(ret))
521                 goto fail;
522 
523         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
524         if (mxl_fail(ret))
525                 goto fail;
526 
527         ret = mxl111sf_enable_usb_output(state);
528         if (mxl_fail(ret))
529                 goto fail;
530         ret = mxl1x1sf_top_master_ctrl(state, 1);
531         if (mxl_fail(ret))
532                 goto fail;
533 
534         ret = mxl111sf_init_port_expander(state);
535         if (mxl_fail(ret))
536                 goto fail;
537         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
538         if (mxl_fail(ret))
539                 goto fail;
540 
541         ret = get_chip_info(state);
542         if (mxl_fail(ret))
543                 goto fail;
544 
545         adap->fe[fe_id] = dvb_attach(lg2160_attach,
546                               &hauppauge_lg2160_config,
547                               &d->i2c_adap);
548         if (adap->fe[fe_id]) {
549                 state->num_frontends++;
550                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
551                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
552                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
553                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
554                 return 0;
555         }
556         ret = -EIO;
557 fail:
558         return ret;
559 }
560 
561 static struct lg2160_config hauppauge_lg2161_1019_config = {
562         .lg_chip            = LG2161_1019,
563         .i2c_addr           = 0x1c >> 1,
564         .deny_i2c_rptr      = 1,
565         .spectral_inversion = 0,
566         .if_khz             = 6000,
567         .output_if          = 2, /* LG2161_OIF_SPI_MAS */
568 };
569 
570 static struct lg2160_config hauppauge_lg2161_1040_config = {
571         .lg_chip            = LG2161_1040,
572         .i2c_addr           = 0x1c >> 1,
573         .deny_i2c_rptr      = 1,
574         .spectral_inversion = 0,
575         .if_khz             = 6000,
576         .output_if          = 4, /* LG2161_OIF_SPI_MAS */
577 };
578 
579 static int mxl111sf_lg2161_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
580 {
581         struct dvb_usb_device *d = adap_to_d(adap);
582         struct mxl111sf_state *state = d_to_priv(d);
583         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
584         int ret;
585 
586         pr_debug("%s()\n", __func__);
587 
588         /* save a pointer to the dvb_usb_device in device state */
589         state->d = d;
590         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
591         state->alt_mode = adap_state->alt_mode;
592 
593         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
594                 pr_err("set interface failed");
595 
596         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
597         adap_state->gpio_mode = state->gpio_mode;
598         adap_state->device_mode = MXL_TUNER_MODE;
599         adap_state->ep6_clockphase = 1;
600 
601         ret = mxl1x1sf_soft_reset(state);
602         if (mxl_fail(ret))
603                 goto fail;
604         ret = mxl111sf_init_tuner_demod(state);
605         if (mxl_fail(ret))
606                 goto fail;
607 
608         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
609         if (mxl_fail(ret))
610                 goto fail;
611 
612         ret = mxl111sf_enable_usb_output(state);
613         if (mxl_fail(ret))
614                 goto fail;
615         ret = mxl1x1sf_top_master_ctrl(state, 1);
616         if (mxl_fail(ret))
617                 goto fail;
618 
619         ret = mxl111sf_init_port_expander(state);
620         if (mxl_fail(ret))
621                 goto fail;
622         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
623         if (mxl_fail(ret))
624                 goto fail;
625 
626         ret = get_chip_info(state);
627         if (mxl_fail(ret))
628                 goto fail;
629 
630         adap->fe[fe_id] = dvb_attach(lg2160_attach,
631                               (MXL111SF_V8_200 == state->chip_rev) ?
632                               &hauppauge_lg2161_1040_config :
633                               &hauppauge_lg2161_1019_config,
634                               &d->i2c_adap);
635         if (adap->fe[fe_id]) {
636                 state->num_frontends++;
637                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
638                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
639                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
640                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
641                 return 0;
642         }
643         ret = -EIO;
644 fail:
645         return ret;
646 }
647 
648 static struct lg2160_config hauppauge_lg2161_1019_ep6_config = {
649         .lg_chip            = LG2161_1019,
650         .i2c_addr           = 0x1c >> 1,
651         .deny_i2c_rptr      = 1,
652         .spectral_inversion = 0,
653         .if_khz             = 6000,
654         .output_if          = 1, /* LG2161_OIF_SERIAL_TS */
655 };
656 
657 static struct lg2160_config hauppauge_lg2161_1040_ep6_config = {
658         .lg_chip            = LG2161_1040,
659         .i2c_addr           = 0x1c >> 1,
660         .deny_i2c_rptr      = 1,
661         .spectral_inversion = 0,
662         .if_khz             = 6000,
663         .output_if          = 7, /* LG2161_OIF_SERIAL_TS */
664 };
665 
666 static int mxl111sf_lg2161_ep6_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
667 {
668         struct dvb_usb_device *d = adap_to_d(adap);
669         struct mxl111sf_state *state = d_to_priv(d);
670         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
671         int ret;
672 
673         pr_debug("%s()\n", __func__);
674 
675         /* save a pointer to the dvb_usb_device in device state */
676         state->d = d;
677         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
678         state->alt_mode = adap_state->alt_mode;
679 
680         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
681                 pr_err("set interface failed");
682 
683         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
684         adap_state->gpio_mode = state->gpio_mode;
685         adap_state->device_mode = MXL_TUNER_MODE;
686         adap_state->ep6_clockphase = 0;
687 
688         ret = mxl1x1sf_soft_reset(state);
689         if (mxl_fail(ret))
690                 goto fail;
691         ret = mxl111sf_init_tuner_demod(state);
692         if (mxl_fail(ret))
693                 goto fail;
694 
695         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
696         if (mxl_fail(ret))
697                 goto fail;
698 
699         ret = mxl111sf_enable_usb_output(state);
700         if (mxl_fail(ret))
701                 goto fail;
702         ret = mxl1x1sf_top_master_ctrl(state, 1);
703         if (mxl_fail(ret))
704                 goto fail;
705 
706         ret = mxl111sf_init_port_expander(state);
707         if (mxl_fail(ret))
708                 goto fail;
709         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
710         if (mxl_fail(ret))
711                 goto fail;
712 
713         ret = get_chip_info(state);
714         if (mxl_fail(ret))
715                 goto fail;
716 
717         adap->fe[fe_id] = dvb_attach(lg2160_attach,
718                               (MXL111SF_V8_200 == state->chip_rev) ?
719                               &hauppauge_lg2161_1040_ep6_config :
720                               &hauppauge_lg2161_1019_ep6_config,
721                               &d->i2c_adap);
722         if (adap->fe[fe_id]) {
723                 state->num_frontends++;
724                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
725                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
726                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
727                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
728                 return 0;
729         }
730         ret = -EIO;
731 fail:
732         return ret;
733 }
734 
735 static const struct mxl111sf_demod_config mxl_demod_config = {
736         .read_reg        = mxl111sf_read_reg,
737         .write_reg       = mxl111sf_write_reg,
738         .program_regs    = mxl111sf_ctrl_program_regs,
739 };
740 
741 static int mxl111sf_attach_demod(struct dvb_usb_adapter *adap, u8 fe_id)
742 {
743         struct dvb_usb_device *d = adap_to_d(adap);
744         struct mxl111sf_state *state = d_to_priv(d);
745         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
746         int ret;
747 
748         pr_debug("%s()\n", __func__);
749 
750         /* save a pointer to the dvb_usb_device in device state */
751         state->d = d;
752         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 1 : 2;
753         state->alt_mode = adap_state->alt_mode;
754 
755         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
756                 pr_err("set interface failed");
757 
758         state->gpio_mode = MXL111SF_GPIO_MOD_DVBT;
759         adap_state->gpio_mode = state->gpio_mode;
760         adap_state->device_mode = MXL_SOC_MODE;
761         adap_state->ep6_clockphase = 1;
762 
763         ret = mxl1x1sf_soft_reset(state);
764         if (mxl_fail(ret))
765                 goto fail;
766         ret = mxl111sf_init_tuner_demod(state);
767         if (mxl_fail(ret))
768                 goto fail;
769 
770         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
771         if (mxl_fail(ret))
772                 goto fail;
773 
774         ret = mxl111sf_enable_usb_output(state);
775         if (mxl_fail(ret))
776                 goto fail;
777         ret = mxl1x1sf_top_master_ctrl(state, 1);
778         if (mxl_fail(ret))
779                 goto fail;
780 
781         /* dont care if this fails */
782         mxl111sf_init_port_expander(state);
783 
784         adap->fe[fe_id] = dvb_attach(mxl111sf_demod_attach, state,
785                               &mxl_demod_config);
786         if (adap->fe[fe_id]) {
787                 state->num_frontends++;
788                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
789                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
790                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
791                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
792                 return 0;
793         }
794         ret = -EIO;
795 fail:
796         return ret;
797 }
798 
799 static inline int mxl111sf_set_ant_path(struct mxl111sf_state *state,
800                                         int antpath)
801 {
802         return mxl111sf_idac_config(state, 1, 1,
803                                     (antpath == ANT_PATH_INTERNAL) ?
804                                     0x3f : 0x00, 0);
805 }
806 
807 #define DbgAntHunt(x, pwr0, pwr1, pwr2, pwr3) \
808         pr_err("%s(%d) FINAL input set to %s rxPwr:%d|%d|%d|%d\n", \
809             __func__, __LINE__, \
810             (ANT_PATH_EXTERNAL == x) ? "EXTERNAL" : "INTERNAL", \
811             pwr0, pwr1, pwr2, pwr3)
812 
813 #define ANT_HUNT_SLEEP 90
814 #define ANT_EXT_TWEAK 0
815 
816 static int mxl111sf_ant_hunt(struct dvb_frontend *fe)
817 {
818         struct mxl111sf_state *state = fe_to_priv(fe);
819         int antctrl = dvb_usb_mxl111sf_rfswitch;
820 
821         u16 rxPwrA, rxPwr0, rxPwr1, rxPwr2;
822 
823         /* FIXME: must force EXTERNAL for QAM - done elsewhere */
824         mxl111sf_set_ant_path(state, antctrl == ANT_PATH_AUTO ?
825                               ANT_PATH_EXTERNAL : antctrl);
826 
827         if (antctrl == ANT_PATH_AUTO) {
828 #if 0
829                 msleep(ANT_HUNT_SLEEP);
830 #endif
831                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwrA);
832 
833                 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
834                 msleep(ANT_HUNT_SLEEP);
835                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr0);
836 
837                 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
838                 msleep(ANT_HUNT_SLEEP);
839                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr1);
840 
841                 mxl111sf_set_ant_path(state, ANT_PATH_INTERNAL);
842                 msleep(ANT_HUNT_SLEEP);
843                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr2);
844 
845                 if (rxPwr1+ANT_EXT_TWEAK >= rxPwr2) {
846                         /* return with EXTERNAL enabled */
847                         mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
848                         DbgAntHunt(ANT_PATH_EXTERNAL, rxPwrA,
849                                    rxPwr0, rxPwr1, rxPwr2);
850                 } else {
851                         /* return with INTERNAL enabled */
852                         DbgAntHunt(ANT_PATH_INTERNAL, rxPwrA,
853                                    rxPwr0, rxPwr1, rxPwr2);
854                 }
855         }
856         return 0;
857 }
858 
859 static struct mxl111sf_tuner_config mxl_tuner_config = {
860         .if_freq         = MXL_IF_6_0, /* applies to external IF output, only */
861         .invert_spectrum = 0,
862         .read_reg        = mxl111sf_read_reg,
863         .write_reg       = mxl111sf_write_reg,
864         .program_regs    = mxl111sf_ctrl_program_regs,
865         .top_master_ctrl = mxl1x1sf_top_master_ctrl,
866         .ant_hunt        = mxl111sf_ant_hunt,
867 };
868 
869 static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap)
870 {
871         struct mxl111sf_state *state = adap_to_priv(adap);
872 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
873         struct media_device *mdev = dvb_get_media_controller(&adap->dvb_adap);
874         int ret;
875 #endif
876         int i;
877 
878         pr_debug("%s()\n", __func__);
879 
880         for (i = 0; i < state->num_frontends; i++) {
881                 if (dvb_attach(mxl111sf_tuner_attach, adap->fe[i], state,
882                                 &mxl_tuner_config) == NULL)
883                         return -EIO;
884                 adap->fe[i]->ops.read_signal_strength = adap->fe[i]->ops.tuner_ops.get_rf_strength;
885         }
886 
887 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
888         state->tuner.function = MEDIA_ENT_F_TUNER;
889         state->tuner.name = "mxl111sf tuner";
890         state->tuner_pads[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
891         state->tuner_pads[TUNER_PAD_IF_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
892 
893         ret = media_entity_pads_init(&state->tuner,
894                                      TUNER_NUM_PADS, state->tuner_pads);
895         if (ret)
896                 return ret;
897 
898         ret = media_device_register_entity(mdev, &state->tuner);
899         if (ret)
900                 return ret;
901 #endif
902         return 0;
903 }
904 
905 static u32 mxl111sf_i2c_func(struct i2c_adapter *adapter)
906 {
907         return I2C_FUNC_I2C;
908 }
909 
910 static struct i2c_algorithm mxl111sf_i2c_algo = {
911         .master_xfer   = mxl111sf_i2c_xfer,
912         .functionality = mxl111sf_i2c_func,
913 #ifdef NEED_ALGO_CONTROL
914         .algo_control = dummy_algo_control,
915 #endif
916 };
917 
918 static int mxl111sf_init(struct dvb_usb_device *d)
919 {
920         struct mxl111sf_state *state = d_to_priv(d);
921         int ret;
922         static u8 eeprom[256];
923         struct i2c_client c;
924 
925         ret = get_chip_info(state);
926         if (mxl_fail(ret))
927                 pr_err("failed to get chip info during probe");
928 
929         mutex_init(&state->fe_lock);
930 
931         if (state->chip_rev > MXL111SF_V6)
932                 mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1);
933 
934         c.adapter = &d->i2c_adap;
935         c.addr = 0xa0 >> 1;
936 
937         ret = tveeprom_read(&c, eeprom, sizeof(eeprom));
938         if (mxl_fail(ret))
939                 return 0;
940         tveeprom_hauppauge_analog(&c, &state->tv, (0x84 == eeprom[0xa0]) ?
941                         eeprom + 0xa0 : eeprom + 0x80);
942 #if 0
943         switch (state->tv.model) {
944         case 117001:
945         case 126001:
946         case 138001:
947                 break;
948         default:
949                 printk(KERN_WARNING "%s: warning: "
950                        "unknown hauppauge model #%d\n",
951                        __func__, state->tv.model);
952         }
953 #endif
954         return 0;
955 }
956 
957 static int mxl111sf_frontend_attach_dvbt(struct dvb_usb_adapter *adap)
958 {
959         return mxl111sf_attach_demod(adap, 0);
960 }
961 
962 static int mxl111sf_frontend_attach_atsc(struct dvb_usb_adapter *adap)
963 {
964         return mxl111sf_lgdt3305_frontend_attach(adap, 0);
965 }
966 
967 static int mxl111sf_frontend_attach_mh(struct dvb_usb_adapter *adap)
968 {
969         return mxl111sf_lg2160_frontend_attach(adap, 0);
970 }
971 
972 static int mxl111sf_frontend_attach_atsc_mh(struct dvb_usb_adapter *adap)
973 {
974         int ret;
975         pr_debug("%s\n", __func__);
976 
977         ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
978         if (ret < 0)
979                 return ret;
980 
981         ret = mxl111sf_attach_demod(adap, 1);
982         if (ret < 0)
983                 return ret;
984 
985         ret = mxl111sf_lg2160_frontend_attach(adap, 2);
986         if (ret < 0)
987                 return ret;
988 
989         return ret;
990 }
991 
992 static int mxl111sf_frontend_attach_mercury(struct dvb_usb_adapter *adap)
993 {
994         int ret;
995         pr_debug("%s\n", __func__);
996 
997         ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
998         if (ret < 0)
999                 return ret;
1000 
1001         ret = mxl111sf_attach_demod(adap, 1);
1002         if (ret < 0)
1003                 return ret;
1004 
1005         ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 2);
1006         if (ret < 0)
1007                 return ret;
1008 
1009         return ret;
1010 }
1011 
1012 static int mxl111sf_frontend_attach_mercury_mh(struct dvb_usb_adapter *adap)
1013 {
1014         int ret;
1015         pr_debug("%s\n", __func__);
1016 
1017         ret = mxl111sf_attach_demod(adap, 0);
1018         if (ret < 0)
1019                 return ret;
1020 
1021         if (dvb_usb_mxl111sf_spi)
1022                 ret = mxl111sf_lg2161_frontend_attach(adap, 1);
1023         else
1024                 ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 1);
1025 
1026         return ret;
1027 }
1028 
1029 static void mxl111sf_stream_config_bulk(struct usb_data_stream_properties *stream, u8 endpoint)
1030 {
1031         pr_debug("%s: endpoint=%d size=8192\n", __func__, endpoint);
1032         stream->type = USB_BULK;
1033         stream->count = 5;
1034         stream->endpoint = endpoint;
1035         stream->u.bulk.buffersize = 8192;
1036 }
1037 
1038 static void mxl111sf_stream_config_isoc(struct usb_data_stream_properties *stream,
1039                 u8 endpoint, int framesperurb, int framesize)
1040 {
1041         pr_debug("%s: endpoint=%d size=%d\n", __func__, endpoint,
1042                         framesperurb * framesize);
1043         stream->type = USB_ISOC;
1044         stream->count = 5;
1045         stream->endpoint = endpoint;
1046         stream->u.isoc.framesperurb = framesperurb;
1047         stream->u.isoc.framesize = framesize;
1048         stream->u.isoc.interval = 1;
1049 }
1050 
1051 /* DVB USB Driver stuff */
1052 
1053 /* dvbt       mxl111sf
1054  * bulk       EP4/BULK/5/8192
1055  * isoc       EP4/ISOC/5/96/564
1056  */
1057 static int mxl111sf_get_stream_config_dvbt(struct dvb_frontend *fe,
1058                 u8 *ts_type, struct usb_data_stream_properties *stream)
1059 {
1060         pr_debug("%s: fe=%d\n", __func__, fe->id);
1061 
1062         *ts_type = DVB_USB_FE_TS_TYPE_188;
1063         if (dvb_usb_mxl111sf_isoc)
1064                 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1065         else
1066                 mxl111sf_stream_config_bulk(stream, 4);
1067         return 0;
1068 }
1069 
1070 static struct dvb_usb_device_properties mxl111sf_props_dvbt = {
1071         .driver_name = KBUILD_MODNAME,
1072         .owner = THIS_MODULE,
1073         .adapter_nr = adapter_nr,
1074         .size_of_priv = sizeof(struct mxl111sf_state),
1075 
1076         .generic_bulk_ctrl_endpoint = 0x02,
1077         .generic_bulk_ctrl_endpoint_response = 0x81,
1078 
1079         .i2c_algo          = &mxl111sf_i2c_algo,
1080         .frontend_attach   = mxl111sf_frontend_attach_dvbt,
1081         .tuner_attach      = mxl111sf_attach_tuner,
1082         .init              = mxl111sf_init,
1083         .streaming_ctrl    = mxl111sf_ep4_streaming_ctrl,
1084         .get_stream_config = mxl111sf_get_stream_config_dvbt,
1085 
1086         .num_adapters = 1,
1087         .adapter = {
1088                 {
1089                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1090                 }
1091         }
1092 };
1093 
1094 /* atsc       lgdt3305
1095  * bulk       EP6/BULK/5/8192
1096  * isoc       EP6/ISOC/5/24/3072
1097  */
1098 static int mxl111sf_get_stream_config_atsc(struct dvb_frontend *fe,
1099                 u8 *ts_type, struct usb_data_stream_properties *stream)
1100 {
1101         pr_debug("%s: fe=%d\n", __func__, fe->id);
1102 
1103         *ts_type = DVB_USB_FE_TS_TYPE_188;
1104         if (dvb_usb_mxl111sf_isoc)
1105                 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1106         else
1107                 mxl111sf_stream_config_bulk(stream, 6);
1108         return 0;
1109 }
1110 
1111 static struct dvb_usb_device_properties mxl111sf_props_atsc = {
1112         .driver_name = KBUILD_MODNAME,
1113         .owner = THIS_MODULE,
1114         .adapter_nr = adapter_nr,
1115         .size_of_priv = sizeof(struct mxl111sf_state),
1116 
1117         .generic_bulk_ctrl_endpoint = 0x02,
1118         .generic_bulk_ctrl_endpoint_response = 0x81,
1119 
1120         .i2c_algo          = &mxl111sf_i2c_algo,
1121         .frontend_attach   = mxl111sf_frontend_attach_atsc,
1122         .tuner_attach      = mxl111sf_attach_tuner,
1123         .init              = mxl111sf_init,
1124         .streaming_ctrl    = mxl111sf_ep6_streaming_ctrl,
1125         .get_stream_config = mxl111sf_get_stream_config_atsc,
1126 
1127         .num_adapters = 1,
1128         .adapter = {
1129                 {
1130                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1131                 }
1132         }
1133 };
1134 
1135 /* mh         lg2160
1136  * bulk       EP5/BULK/5/8192/RAW
1137  * isoc       EP5/ISOC/5/96/200/RAW
1138  */
1139 static int mxl111sf_get_stream_config_mh(struct dvb_frontend *fe,
1140                 u8 *ts_type, struct usb_data_stream_properties *stream)
1141 {
1142         pr_debug("%s: fe=%d\n", __func__, fe->id);
1143 
1144         *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1145         if (dvb_usb_mxl111sf_isoc)
1146                 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1147         else
1148                 mxl111sf_stream_config_bulk(stream, 5);
1149         return 0;
1150 }
1151 
1152 static struct dvb_usb_device_properties mxl111sf_props_mh = {
1153         .driver_name = KBUILD_MODNAME,
1154         .owner = THIS_MODULE,
1155         .adapter_nr = adapter_nr,
1156         .size_of_priv = sizeof(struct mxl111sf_state),
1157 
1158         .generic_bulk_ctrl_endpoint = 0x02,
1159         .generic_bulk_ctrl_endpoint_response = 0x81,
1160 
1161         .i2c_algo          = &mxl111sf_i2c_algo,
1162         .frontend_attach   = mxl111sf_frontend_attach_mh,
1163         .tuner_attach      = mxl111sf_attach_tuner,
1164         .init              = mxl111sf_init,
1165         .streaming_ctrl    = mxl111sf_ep5_streaming_ctrl,
1166         .get_stream_config = mxl111sf_get_stream_config_mh,
1167 
1168         .num_adapters = 1,
1169         .adapter = {
1170                 {
1171                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1172                 }
1173         }
1174 };
1175 
1176 /* atsc mh    lgdt3305           mxl111sf          lg2160
1177  * bulk       EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1178  * isoc       EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1179  */
1180 static int mxl111sf_get_stream_config_atsc_mh(struct dvb_frontend *fe,
1181                 u8 *ts_type, struct usb_data_stream_properties *stream)
1182 {
1183         pr_debug("%s: fe=%d\n", __func__, fe->id);
1184 
1185         if (fe->id == 0) {
1186                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1187                 if (dvb_usb_mxl111sf_isoc)
1188                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1189                 else
1190                         mxl111sf_stream_config_bulk(stream, 6);
1191         } else if (fe->id == 1) {
1192                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1193                 if (dvb_usb_mxl111sf_isoc)
1194                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1195                 else
1196                         mxl111sf_stream_config_bulk(stream, 4);
1197         } else if (fe->id == 2) {
1198                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1199                 if (dvb_usb_mxl111sf_isoc)
1200                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1201                 else
1202                         mxl111sf_stream_config_bulk(stream, 5);
1203         }
1204         return 0;
1205 }
1206 
1207 static int mxl111sf_streaming_ctrl_atsc_mh(struct dvb_frontend *fe, int onoff)
1208 {
1209         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1210 
1211         if (fe->id == 0)
1212                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1213         else if (fe->id == 1)
1214                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1215         else if (fe->id == 2)
1216                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1217         return 0;
1218 }
1219 
1220 static struct dvb_usb_device_properties mxl111sf_props_atsc_mh = {
1221         .driver_name = KBUILD_MODNAME,
1222         .owner = THIS_MODULE,
1223         .adapter_nr = adapter_nr,
1224         .size_of_priv = sizeof(struct mxl111sf_state),
1225 
1226         .generic_bulk_ctrl_endpoint = 0x02,
1227         .generic_bulk_ctrl_endpoint_response = 0x81,
1228 
1229         .i2c_algo          = &mxl111sf_i2c_algo,
1230         .frontend_attach   = mxl111sf_frontend_attach_atsc_mh,
1231         .tuner_attach      = mxl111sf_attach_tuner,
1232         .init              = mxl111sf_init,
1233         .streaming_ctrl    = mxl111sf_streaming_ctrl_atsc_mh,
1234         .get_stream_config = mxl111sf_get_stream_config_atsc_mh,
1235 
1236         .num_adapters = 1,
1237         .adapter = {
1238                 {
1239                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1240                 }
1241         }
1242 };
1243 
1244 /* mercury    lgdt3305           mxl111sf          lg2161
1245  * tp bulk    EP6/BULK/5/8192    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1246  * tp isoc    EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1247  * spi bulk   EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1248  * spi isoc   EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1249  */
1250 static int mxl111sf_get_stream_config_mercury(struct dvb_frontend *fe,
1251                 u8 *ts_type, struct usb_data_stream_properties *stream)
1252 {
1253         pr_debug("%s: fe=%d\n", __func__, fe->id);
1254 
1255         if (fe->id == 0) {
1256                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1257                 if (dvb_usb_mxl111sf_isoc)
1258                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1259                 else
1260                         mxl111sf_stream_config_bulk(stream, 6);
1261         } else if (fe->id == 1) {
1262                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1263                 if (dvb_usb_mxl111sf_isoc)
1264                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1265                 else
1266                         mxl111sf_stream_config_bulk(stream, 4);
1267         } else if (fe->id == 2 && dvb_usb_mxl111sf_spi) {
1268                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1269                 if (dvb_usb_mxl111sf_isoc)
1270                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1271                 else
1272                         mxl111sf_stream_config_bulk(stream, 5);
1273         } else if (fe->id == 2 && !dvb_usb_mxl111sf_spi) {
1274                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1275                 if (dvb_usb_mxl111sf_isoc)
1276                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1277                 else
1278                         mxl111sf_stream_config_bulk(stream, 6);
1279         }
1280         return 0;
1281 }
1282 
1283 static int mxl111sf_streaming_ctrl_mercury(struct dvb_frontend *fe, int onoff)
1284 {
1285         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1286 
1287         if (fe->id == 0)
1288                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1289         else if (fe->id == 1)
1290                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1291         else if (fe->id == 2 && dvb_usb_mxl111sf_spi)
1292                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1293         else if (fe->id == 2 && !dvb_usb_mxl111sf_spi)
1294                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1295         return 0;
1296 }
1297 
1298 static struct dvb_usb_device_properties mxl111sf_props_mercury = {
1299         .driver_name = KBUILD_MODNAME,
1300         .owner = THIS_MODULE,
1301         .adapter_nr = adapter_nr,
1302         .size_of_priv = sizeof(struct mxl111sf_state),
1303 
1304         .generic_bulk_ctrl_endpoint = 0x02,
1305         .generic_bulk_ctrl_endpoint_response = 0x81,
1306 
1307         .i2c_algo          = &mxl111sf_i2c_algo,
1308         .frontend_attach   = mxl111sf_frontend_attach_mercury,
1309         .tuner_attach      = mxl111sf_attach_tuner,
1310         .init              = mxl111sf_init,
1311         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury,
1312         .get_stream_config = mxl111sf_get_stream_config_mercury,
1313 
1314         .num_adapters = 1,
1315         .adapter = {
1316                 {
1317                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1318                 }
1319         }
1320 };
1321 
1322 /* mercury mh mxl111sf          lg2161
1323  * tp bulk    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1324  * tp isoc    EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1325  * spi bulk   EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1326  * spi isoc   EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1327  */
1328 static int mxl111sf_get_stream_config_mercury_mh(struct dvb_frontend *fe,
1329                 u8 *ts_type, struct usb_data_stream_properties *stream)
1330 {
1331         pr_debug("%s: fe=%d\n", __func__, fe->id);
1332 
1333         if (fe->id == 0) {
1334                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1335                 if (dvb_usb_mxl111sf_isoc)
1336                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1337                 else
1338                         mxl111sf_stream_config_bulk(stream, 4);
1339         } else if (fe->id == 1 && dvb_usb_mxl111sf_spi) {
1340                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1341                 if (dvb_usb_mxl111sf_isoc)
1342                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1343                 else
1344                         mxl111sf_stream_config_bulk(stream, 5);
1345         } else if (fe->id == 1 && !dvb_usb_mxl111sf_spi) {
1346                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1347                 if (dvb_usb_mxl111sf_isoc)
1348                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1349                 else
1350                         mxl111sf_stream_config_bulk(stream, 6);
1351         }
1352         return 0;
1353 }
1354 
1355 static int mxl111sf_streaming_ctrl_mercury_mh(struct dvb_frontend *fe, int onoff)
1356 {
1357         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1358 
1359         if (fe->id == 0)
1360                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1361         else if (fe->id == 1  && dvb_usb_mxl111sf_spi)
1362                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1363         else if (fe->id == 1 && !dvb_usb_mxl111sf_spi)
1364                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1365         return 0;
1366 }
1367 
1368 static struct dvb_usb_device_properties mxl111sf_props_mercury_mh = {
1369         .driver_name = KBUILD_MODNAME,
1370         .owner = THIS_MODULE,
1371         .adapter_nr = adapter_nr,
1372         .size_of_priv = sizeof(struct mxl111sf_state),
1373 
1374         .generic_bulk_ctrl_endpoint = 0x02,
1375         .generic_bulk_ctrl_endpoint_response = 0x81,
1376 
1377         .i2c_algo          = &mxl111sf_i2c_algo,
1378         .frontend_attach   = mxl111sf_frontend_attach_mercury_mh,
1379         .tuner_attach      = mxl111sf_attach_tuner,
1380         .init              = mxl111sf_init,
1381         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury_mh,
1382         .get_stream_config = mxl111sf_get_stream_config_mercury_mh,
1383 
1384         .num_adapters = 1,
1385         .adapter = {
1386                 {
1387                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1388                 }
1389         }
1390 };
1391 
1392 static const struct usb_device_id mxl111sf_id_table[] = {
1393         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc600, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1394         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc601, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1395         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc602, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1396         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc603, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1397         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc604, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1398         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc609, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1399         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60a, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1400         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1401         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60c, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1402         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc653, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1403         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc65b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1404         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb700, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1405         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb701, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1406         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb702, &mxl111sf_props_mh, "HCW 117xxx", NULL) },
1407         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb703, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1408         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb704, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1409         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb753, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1410         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb763, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1411         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb764, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1412         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd853, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1413         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd854, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1414         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd863, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1415         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd864, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1416         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1417         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1418         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1419         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1420         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8ff, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1421         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc612, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1422         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc613, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1423         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61a, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1424         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61b, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1425         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb757, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1426         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb767, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1427         { }
1428 };
1429 MODULE_DEVICE_TABLE(usb, mxl111sf_id_table);
1430 
1431 static struct usb_driver mxl111sf_usb_driver = {
1432         .name = KBUILD_MODNAME,
1433         .id_table = mxl111sf_id_table,
1434         .probe = dvb_usbv2_probe,
1435         .disconnect = dvb_usbv2_disconnect,
1436         .suspend = dvb_usbv2_suspend,
1437         .resume = dvb_usbv2_resume,
1438         .no_dynamic_id = 1,
1439         .soft_unbind = 1,
1440 };
1441 
1442 module_usb_driver(mxl111sf_usb_driver);
1443 
1444 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1445 MODULE_DESCRIPTION("Driver for MaxLinear MxL111SF");
1446 MODULE_VERSION("1.0");
1447 MODULE_LICENSE("GPL");
1448 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us