?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sched: Remove double_rq_lock() from __migrate_task()
[linux/fpc-iii.git] / drivers / media / usb / dvb-usb-v2 / mxl111sf.c
blobc7304fa8ab737e46257545d0e30316de2c8cd539
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 */
Linux with added FPC-III support