Version:  2.0.40 2.2.26 2.4.37 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 4.6 4.7 4.8 4.9 4.10

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

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