Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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 
 14 #include "mxl111sf.h"
 15 #include "mxl111sf-reg.h"
 16 #include "mxl111sf-phy.h"
 17 #include "mxl111sf-i2c.h"
 18 #include "mxl111sf-gpio.h"
 19 
 20 #include "mxl111sf-demod.h"
 21 #include "mxl111sf-tuner.h"
 22 
 23 #include "lgdt3305.h"
 24 #include "lg2160.h"
 25 
 26 /* Max transfer size done by I2C transfer functions */
 27 #define MAX_XFER_SIZE  64
 28 
 29 int dvb_usb_mxl111sf_debug;
 30 module_param_named(debug, dvb_usb_mxl111sf_debug, int, 0644);
 31 MODULE_PARM_DESC(debug, "set debugging level "
 32                  "(1=info, 2=xfer, 4=i2c, 8=reg, 16=adv (or-able)).");
 33 
 34 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 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 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;
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, "
140                             "data: 0x%02x, retrying...", 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         mxl111sf_enable_usb_output(state);
292         mxl_fail(err);
293         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 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 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         int i;
872 
873         pr_debug("%s()\n", __func__);
874 
875         for (i = 0; i < state->num_frontends; i++) {
876                 if (dvb_attach(mxl111sf_tuner_attach, adap->fe[i], state,
877                                 &mxl_tuner_config) == NULL)
878                         return -EIO;
879                 adap->fe[i]->ops.read_signal_strength = adap->fe[i]->ops.tuner_ops.get_rf_strength;
880         }
881 
882         return 0;
883 }
884 
885 static u32 mxl111sf_i2c_func(struct i2c_adapter *adapter)
886 {
887         return I2C_FUNC_I2C;
888 }
889 
890 struct i2c_algorithm mxl111sf_i2c_algo = {
891         .master_xfer   = mxl111sf_i2c_xfer,
892         .functionality = mxl111sf_i2c_func,
893 #ifdef NEED_ALGO_CONTROL
894         .algo_control = dummy_algo_control,
895 #endif
896 };
897 
898 static int mxl111sf_init(struct dvb_usb_device *d)
899 {
900         struct mxl111sf_state *state = d_to_priv(d);
901         int ret;
902         static u8 eeprom[256];
903         struct i2c_client c;
904 
905         ret = get_chip_info(state);
906         if (mxl_fail(ret))
907                 pr_err("failed to get chip info during probe");
908 
909         mutex_init(&state->fe_lock);
910 
911         if (state->chip_rev > MXL111SF_V6)
912                 mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1);
913 
914         c.adapter = &d->i2c_adap;
915         c.addr = 0xa0 >> 1;
916 
917         ret = tveeprom_read(&c, eeprom, sizeof(eeprom));
918         if (mxl_fail(ret))
919                 return 0;
920         tveeprom_hauppauge_analog(&c, &state->tv, (0x84 == eeprom[0xa0]) ?
921                         eeprom + 0xa0 : eeprom + 0x80);
922 #if 0
923         switch (state->tv.model) {
924         case 117001:
925         case 126001:
926         case 138001:
927                 break;
928         default:
929                 printk(KERN_WARNING "%s: warning: "
930                        "unknown hauppauge model #%d\n",
931                        __func__, state->tv.model);
932         }
933 #endif
934         return 0;
935 }
936 
937 static int mxl111sf_frontend_attach_dvbt(struct dvb_usb_adapter *adap)
938 {
939         return mxl111sf_attach_demod(adap, 0);
940 }
941 
942 static int mxl111sf_frontend_attach_atsc(struct dvb_usb_adapter *adap)
943 {
944         return mxl111sf_lgdt3305_frontend_attach(adap, 0);
945 }
946 
947 static int mxl111sf_frontend_attach_mh(struct dvb_usb_adapter *adap)
948 {
949         return mxl111sf_lg2160_frontend_attach(adap, 0);
950 }
951 
952 static int mxl111sf_frontend_attach_atsc_mh(struct dvb_usb_adapter *adap)
953 {
954         int ret;
955         pr_debug("%s\n", __func__);
956 
957         ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
958         if (ret < 0)
959                 return ret;
960 
961         ret = mxl111sf_attach_demod(adap, 1);
962         if (ret < 0)
963                 return ret;
964 
965         ret = mxl111sf_lg2160_frontend_attach(adap, 2);
966         if (ret < 0)
967                 return ret;
968 
969         return ret;
970 }
971 
972 static int mxl111sf_frontend_attach_mercury(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_lg2161_ep6_frontend_attach(adap, 2);
986         if (ret < 0)
987                 return ret;
988 
989         return ret;
990 }
991 
992 static int mxl111sf_frontend_attach_mercury_mh(struct dvb_usb_adapter *adap)
993 {
994         int ret;
995         pr_debug("%s\n", __func__);
996 
997         ret = mxl111sf_attach_demod(adap, 0);
998         if (ret < 0)
999                 return ret;
1000 
1001         if (dvb_usb_mxl111sf_spi)
1002                 ret = mxl111sf_lg2161_frontend_attach(adap, 1);
1003         else
1004                 ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 1);
1005 
1006         return ret;
1007 }
1008 
1009 static void mxl111sf_stream_config_bulk(struct usb_data_stream_properties *stream, u8 endpoint)
1010 {
1011         pr_debug("%s: endpoint=%d size=8192\n", __func__, endpoint);
1012         stream->type = USB_BULK;
1013         stream->count = 5;
1014         stream->endpoint = endpoint;
1015         stream->u.bulk.buffersize = 8192;
1016 }
1017 
1018 static void mxl111sf_stream_config_isoc(struct usb_data_stream_properties *stream,
1019                 u8 endpoint, int framesperurb, int framesize)
1020 {
1021         pr_debug("%s: endpoint=%d size=%d\n", __func__, endpoint,
1022                         framesperurb * framesize);
1023         stream->type = USB_ISOC;
1024         stream->count = 5;
1025         stream->endpoint = endpoint;
1026         stream->u.isoc.framesperurb = framesperurb;
1027         stream->u.isoc.framesize = framesize;
1028         stream->u.isoc.interval = 1;
1029 }
1030 
1031 /* DVB USB Driver stuff */
1032 
1033 /* dvbt       mxl111sf
1034  * bulk       EP4/BULK/5/8192
1035  * isoc       EP4/ISOC/5/96/564
1036  */
1037 static int mxl111sf_get_stream_config_dvbt(struct dvb_frontend *fe,
1038                 u8 *ts_type, struct usb_data_stream_properties *stream)
1039 {
1040         pr_debug("%s: fe=%d\n", __func__, fe->id);
1041 
1042         *ts_type = DVB_USB_FE_TS_TYPE_188;
1043         if (dvb_usb_mxl111sf_isoc)
1044                 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1045         else
1046                 mxl111sf_stream_config_bulk(stream, 4);
1047         return 0;
1048 }
1049 
1050 static struct dvb_usb_device_properties mxl111sf_props_dvbt = {
1051         .driver_name = KBUILD_MODNAME,
1052         .owner = THIS_MODULE,
1053         .adapter_nr = adapter_nr,
1054         .size_of_priv = sizeof(struct mxl111sf_state),
1055 
1056         .generic_bulk_ctrl_endpoint = 0x02,
1057         .generic_bulk_ctrl_endpoint_response = 0x81,
1058 
1059         .i2c_algo          = &mxl111sf_i2c_algo,
1060         .frontend_attach   = mxl111sf_frontend_attach_dvbt,
1061         .tuner_attach      = mxl111sf_attach_tuner,
1062         .init              = mxl111sf_init,
1063         .streaming_ctrl    = mxl111sf_ep4_streaming_ctrl,
1064         .get_stream_config = mxl111sf_get_stream_config_dvbt,
1065 
1066         .num_adapters = 1,
1067         .adapter = {
1068                 {
1069                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1070                 }
1071         }
1072 };
1073 
1074 /* atsc       lgdt3305
1075  * bulk       EP6/BULK/5/8192
1076  * isoc       EP6/ISOC/5/24/3072
1077  */
1078 static int mxl111sf_get_stream_config_atsc(struct dvb_frontend *fe,
1079                 u8 *ts_type, struct usb_data_stream_properties *stream)
1080 {
1081         pr_debug("%s: fe=%d\n", __func__, fe->id);
1082 
1083         *ts_type = DVB_USB_FE_TS_TYPE_188;
1084         if (dvb_usb_mxl111sf_isoc)
1085                 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1086         else
1087                 mxl111sf_stream_config_bulk(stream, 6);
1088         return 0;
1089 }
1090 
1091 static struct dvb_usb_device_properties mxl111sf_props_atsc = {
1092         .driver_name = KBUILD_MODNAME,
1093         .owner = THIS_MODULE,
1094         .adapter_nr = adapter_nr,
1095         .size_of_priv = sizeof(struct mxl111sf_state),
1096 
1097         .generic_bulk_ctrl_endpoint = 0x02,
1098         .generic_bulk_ctrl_endpoint_response = 0x81,
1099 
1100         .i2c_algo          = &mxl111sf_i2c_algo,
1101         .frontend_attach   = mxl111sf_frontend_attach_atsc,
1102         .tuner_attach      = mxl111sf_attach_tuner,
1103         .init              = mxl111sf_init,
1104         .streaming_ctrl    = mxl111sf_ep6_streaming_ctrl,
1105         .get_stream_config = mxl111sf_get_stream_config_atsc,
1106 
1107         .num_adapters = 1,
1108         .adapter = {
1109                 {
1110                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1111                 }
1112         }
1113 };
1114 
1115 /* mh         lg2160
1116  * bulk       EP5/BULK/5/8192/RAW
1117  * isoc       EP5/ISOC/5/96/200/RAW
1118  */
1119 static int mxl111sf_get_stream_config_mh(struct dvb_frontend *fe,
1120                 u8 *ts_type, struct usb_data_stream_properties *stream)
1121 {
1122         pr_debug("%s: fe=%d\n", __func__, fe->id);
1123 
1124         *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1125         if (dvb_usb_mxl111sf_isoc)
1126                 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1127         else
1128                 mxl111sf_stream_config_bulk(stream, 5);
1129         return 0;
1130 }
1131 
1132 static struct dvb_usb_device_properties mxl111sf_props_mh = {
1133         .driver_name = KBUILD_MODNAME,
1134         .owner = THIS_MODULE,
1135         .adapter_nr = adapter_nr,
1136         .size_of_priv = sizeof(struct mxl111sf_state),
1137 
1138         .generic_bulk_ctrl_endpoint = 0x02,
1139         .generic_bulk_ctrl_endpoint_response = 0x81,
1140 
1141         .i2c_algo          = &mxl111sf_i2c_algo,
1142         .frontend_attach   = mxl111sf_frontend_attach_mh,
1143         .tuner_attach      = mxl111sf_attach_tuner,
1144         .init              = mxl111sf_init,
1145         .streaming_ctrl    = mxl111sf_ep5_streaming_ctrl,
1146         .get_stream_config = mxl111sf_get_stream_config_mh,
1147 
1148         .num_adapters = 1,
1149         .adapter = {
1150                 {
1151                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1152                 }
1153         }
1154 };
1155 
1156 /* atsc mh    lgdt3305           mxl111sf          lg2160
1157  * bulk       EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1158  * isoc       EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1159  */
1160 static int mxl111sf_get_stream_config_atsc_mh(struct dvb_frontend *fe,
1161                 u8 *ts_type, struct usb_data_stream_properties *stream)
1162 {
1163         pr_debug("%s: fe=%d\n", __func__, fe->id);
1164 
1165         if (fe->id == 0) {
1166                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1167                 if (dvb_usb_mxl111sf_isoc)
1168                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1169                 else
1170                         mxl111sf_stream_config_bulk(stream, 6);
1171         } else if (fe->id == 1) {
1172                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1173                 if (dvb_usb_mxl111sf_isoc)
1174                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1175                 else
1176                         mxl111sf_stream_config_bulk(stream, 4);
1177         } else if (fe->id == 2) {
1178                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1179                 if (dvb_usb_mxl111sf_isoc)
1180                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1181                 else
1182                         mxl111sf_stream_config_bulk(stream, 5);
1183         }
1184         return 0;
1185 }
1186 
1187 static int mxl111sf_streaming_ctrl_atsc_mh(struct dvb_frontend *fe, int onoff)
1188 {
1189         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1190 
1191         if (fe->id == 0)
1192                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1193         else if (fe->id == 1)
1194                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1195         else if (fe->id == 2)
1196                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1197         return 0;
1198 }
1199 
1200 static struct dvb_usb_device_properties mxl111sf_props_atsc_mh = {
1201         .driver_name = KBUILD_MODNAME,
1202         .owner = THIS_MODULE,
1203         .adapter_nr = adapter_nr,
1204         .size_of_priv = sizeof(struct mxl111sf_state),
1205 
1206         .generic_bulk_ctrl_endpoint = 0x02,
1207         .generic_bulk_ctrl_endpoint_response = 0x81,
1208 
1209         .i2c_algo          = &mxl111sf_i2c_algo,
1210         .frontend_attach   = mxl111sf_frontend_attach_atsc_mh,
1211         .tuner_attach      = mxl111sf_attach_tuner,
1212         .init              = mxl111sf_init,
1213         .streaming_ctrl    = mxl111sf_streaming_ctrl_atsc_mh,
1214         .get_stream_config = mxl111sf_get_stream_config_atsc_mh,
1215 
1216         .num_adapters = 1,
1217         .adapter = {
1218                 {
1219                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1220                 }
1221         }
1222 };
1223 
1224 /* mercury    lgdt3305           mxl111sf          lg2161
1225  * tp bulk    EP6/BULK/5/8192    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1226  * tp isoc    EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1227  * spi bulk   EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1228  * spi isoc   EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1229  */
1230 static int mxl111sf_get_stream_config_mercury(struct dvb_frontend *fe,
1231                 u8 *ts_type, struct usb_data_stream_properties *stream)
1232 {
1233         pr_debug("%s: fe=%d\n", __func__, fe->id);
1234 
1235         if (fe->id == 0) {
1236                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1237                 if (dvb_usb_mxl111sf_isoc)
1238                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1239                 else
1240                         mxl111sf_stream_config_bulk(stream, 6);
1241         } else if (fe->id == 1) {
1242                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1243                 if (dvb_usb_mxl111sf_isoc)
1244                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1245                 else
1246                         mxl111sf_stream_config_bulk(stream, 4);
1247         } else if (fe->id == 2 && dvb_usb_mxl111sf_spi) {
1248                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1249                 if (dvb_usb_mxl111sf_isoc)
1250                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1251                 else
1252                         mxl111sf_stream_config_bulk(stream, 5);
1253         } else if (fe->id == 2 && !dvb_usb_mxl111sf_spi) {
1254                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
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         }
1260         return 0;
1261 }
1262 
1263 static int mxl111sf_streaming_ctrl_mercury(struct dvb_frontend *fe, int onoff)
1264 {
1265         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1266 
1267         if (fe->id == 0)
1268                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1269         else if (fe->id == 1)
1270                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1271         else if (fe->id == 2 && dvb_usb_mxl111sf_spi)
1272                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1273         else if (fe->id == 2 && !dvb_usb_mxl111sf_spi)
1274                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1275         return 0;
1276 }
1277 
1278 static struct dvb_usb_device_properties mxl111sf_props_mercury = {
1279         .driver_name = KBUILD_MODNAME,
1280         .owner = THIS_MODULE,
1281         .adapter_nr = adapter_nr,
1282         .size_of_priv = sizeof(struct mxl111sf_state),
1283 
1284         .generic_bulk_ctrl_endpoint = 0x02,
1285         .generic_bulk_ctrl_endpoint_response = 0x81,
1286 
1287         .i2c_algo          = &mxl111sf_i2c_algo,
1288         .frontend_attach   = mxl111sf_frontend_attach_mercury,
1289         .tuner_attach      = mxl111sf_attach_tuner,
1290         .init              = mxl111sf_init,
1291         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury,
1292         .get_stream_config = mxl111sf_get_stream_config_mercury,
1293 
1294         .num_adapters = 1,
1295         .adapter = {
1296                 {
1297                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1298                 }
1299         }
1300 };
1301 
1302 /* mercury mh mxl111sf          lg2161
1303  * tp bulk    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1304  * tp isoc    EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1305  * spi bulk   EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1306  * spi isoc   EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1307  */
1308 static int mxl111sf_get_stream_config_mercury_mh(struct dvb_frontend *fe,
1309                 u8 *ts_type, struct usb_data_stream_properties *stream)
1310 {
1311         pr_debug("%s: fe=%d\n", __func__, fe->id);
1312 
1313         if (fe->id == 0) {
1314                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1315                 if (dvb_usb_mxl111sf_isoc)
1316                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1317                 else
1318                         mxl111sf_stream_config_bulk(stream, 4);
1319         } else if (fe->id == 1 && dvb_usb_mxl111sf_spi) {
1320                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1321                 if (dvb_usb_mxl111sf_isoc)
1322                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1323                 else
1324                         mxl111sf_stream_config_bulk(stream, 5);
1325         } else if (fe->id == 1 && !dvb_usb_mxl111sf_spi) {
1326                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1327                 if (dvb_usb_mxl111sf_isoc)
1328                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1329                 else
1330                         mxl111sf_stream_config_bulk(stream, 6);
1331         }
1332         return 0;
1333 }
1334 
1335 static int mxl111sf_streaming_ctrl_mercury_mh(struct dvb_frontend *fe, int onoff)
1336 {
1337         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1338 
1339         if (fe->id == 0)
1340                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1341         else if (fe->id == 1  && dvb_usb_mxl111sf_spi)
1342                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1343         else if (fe->id == 1 && !dvb_usb_mxl111sf_spi)
1344                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1345         return 0;
1346 }
1347 
1348 static struct dvb_usb_device_properties mxl111sf_props_mercury_mh = {
1349         .driver_name = KBUILD_MODNAME,
1350         .owner = THIS_MODULE,
1351         .adapter_nr = adapter_nr,
1352         .size_of_priv = sizeof(struct mxl111sf_state),
1353 
1354         .generic_bulk_ctrl_endpoint = 0x02,
1355         .generic_bulk_ctrl_endpoint_response = 0x81,
1356 
1357         .i2c_algo          = &mxl111sf_i2c_algo,
1358         .frontend_attach   = mxl111sf_frontend_attach_mercury_mh,
1359         .tuner_attach      = mxl111sf_attach_tuner,
1360         .init              = mxl111sf_init,
1361         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury_mh,
1362         .get_stream_config = mxl111sf_get_stream_config_mercury_mh,
1363 
1364         .num_adapters = 1,
1365         .adapter = {
1366                 {
1367                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1368                 }
1369         }
1370 };
1371 
1372 static const struct usb_device_id mxl111sf_id_table[] = {
1373         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc600, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1374         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc601, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1375         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc602, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1376         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc603, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1377         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc604, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1378         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc609, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1379         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60a, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1380         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1381         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60c, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1382         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc653, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1383         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc65b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1384         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb700, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1385         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb701, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1386         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb702, &mxl111sf_props_mh, "HCW 117xxx", NULL) },
1387         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb703, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1388         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb704, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1389         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb753, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1390         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb763, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1391         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb764, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1392         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd853, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1393         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd854, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1394         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd863, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1395         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd864, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1396         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1397         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1398         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1399         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1400         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8ff, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1401         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc612, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1402         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc613, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1403         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61a, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1404         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61b, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1405         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb757, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1406         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb767, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1407         { }
1408 };
1409 MODULE_DEVICE_TABLE(usb, mxl111sf_id_table);
1410 
1411 static struct usb_driver mxl111sf_usb_driver = {
1412         .name = KBUILD_MODNAME,
1413         .id_table = mxl111sf_id_table,
1414         .probe = dvb_usbv2_probe,
1415         .disconnect = dvb_usbv2_disconnect,
1416         .suspend = dvb_usbv2_suspend,
1417         .resume = dvb_usbv2_resume,
1418         .no_dynamic_id = 1,
1419         .soft_unbind = 1,
1420 };
1421 
1422 module_usb_driver(mxl111sf_usb_driver);
1423 
1424 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1425 MODULE_DESCRIPTION("Driver for MaxLinear MxL111SF");
1426 MODULE_VERSION("1.0");
1427 MODULE_LICENSE("GPL");
1428 
1429 /*
1430  * Local variables:
1431  * c-basic-offset: 8
1432  * End:
1433  */
1434 

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