?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / media / usb / em28xx / em28xx-dvb.c
bloba0a669e81362956878755eea3cbf1a134905a303
1 /*
2 DVB device driver for em28xx
3
4 (c) 2008-2011 Mauro Carvalho Chehab <mchehab@infradead.org>
5
6 (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
7 - Fixes for the driver to properly work with HVR-950
8 - Fixes for the driver to properly work with Pinnacle PCTV HD Pro Stick
9 - Fixes for the driver to properly work with AMD ATI TV Wonder HD 600
10
11 (c) 2008 Aidan Thornton <makosoft@googlemail.com>
12
13 (c) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
14
15 Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
16 (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
17 (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
18
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License.
22 */
23
24 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/usb.h>
27
28 #include "em28xx.h"
29 #include <media/v4l2-common.h>
30 #include <dvb_demux.h>
31 #include <dvb_net.h>
32 #include <dmxdev.h>
33 #include <media/tuner.h>
34 #include "tuner-simple.h"
35 #include <linux/gpio.h>
36
37 #include "lgdt330x.h"
38 #include "lgdt3305.h"
39 #include "zl10353.h"
40 #include "s5h1409.h"
41 #include "mt352.h"
42 #include "mt352_priv.h" /* FIXME */
43 #include "tda1002x.h"
44 #include "tda18271.h"
45 #include "s921.h"
46 #include "drxd.h"
47 #include "cxd2820r.h"
48 #include "tda18271c2dd.h"
49 #include "drxk.h"
50 #include "tda10071.h"
51 #include "a8293.h"
52 #include "qt1010.h"
53 #include "mb86a20s.h"
54 #include "m88ds3103.h"
55 #include "m88ts2022.h"
56
57 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
58 MODULE_LICENSE("GPL");
59 MODULE_DESCRIPTION(DRIVER_DESC " - digital TV interface");
60 MODULE_VERSION(EM28XX_VERSION);
61
62
63 static unsigned int debug;
64 module_param(debug, int, 0644);
65 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
66
67 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
68
69 #define dprintk(level, fmt, arg...) do { \
70 if (debug >= level) \
71 printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
72 } while (0)
73
74 struct em28xx_dvb {
75 struct dvb_frontend *fe[2];
76
77 /* feed count management */
78 struct mutex lock;
79 int nfeeds;
80
81 /* general boilerplate stuff */
82 struct dvb_adapter adapter;
83 struct dvb_demux demux;
84 struct dmxdev dmxdev;
85 struct dmx_frontend fe_hw;
86 struct dmx_frontend fe_mem;
87 struct dvb_net net;
88
89 /* Due to DRX-K - probably need changes */
90 int (*gate_ctrl)(struct dvb_frontend *, int);
91 struct semaphore pll_mutex;
92 bool dont_attach_fe1;
93 int lna_gpio;
94 struct i2c_client *i2c_client_tuner;
95 };
96
97
98 static inline void print_err_status(struct em28xx *dev,
99 int packet, int status)
100 {
101 char *errmsg = "Unknown";
102
103 switch (status) {
104 case -ENOENT:
105 errmsg = "unlinked synchronuously";
106 break;
107 case -ECONNRESET:
108 errmsg = "unlinked asynchronuously";
109 break;
110 case -ENOSR:
111 errmsg = "Buffer error (overrun)";
112 break;
113 case -EPIPE:
114 errmsg = "Stalled (device not responding)";
115 break;
116 case -EOVERFLOW:
117 errmsg = "Babble (bad cable?)";
118 break;
119 case -EPROTO:
120 errmsg = "Bit-stuff error (bad cable?)";
121 break;
122 case -EILSEQ:
123 errmsg = "CRC/Timeout (could be anything)";
124 break;
125 case -ETIME:
126 errmsg = "Device does not respond";
127 break;
128 }
129 if (packet < 0) {
130 dprintk(1, "URB status %d [%s].\n", status, errmsg);
131 } else {
132 dprintk(1, "URB packet %d, status %d [%s].\n",
133 packet, status, errmsg);
134 }
135 }
136
137 static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
138 {
139 int xfer_bulk, num_packets, i;
140
141 if (!dev)
142 return 0;
143
144 if (dev->disconnected)
145 return 0;
146
147 if (urb->status < 0)
148 print_err_status(dev, -1, urb->status);
149
150 xfer_bulk = usb_pipebulk(urb->pipe);
151
152 if (xfer_bulk) /* bulk */
153 num_packets = 1;
154 else /* isoc */
155 num_packets = urb->number_of_packets;
156
157 for (i = 0; i < num_packets; i++) {
158 if (xfer_bulk) {
159 if (urb->status < 0) {
160 print_err_status(dev, i, urb->status);
161 if (urb->status != -EPROTO)
162 continue;
163 }
164 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
165 urb->actual_length);
166 } else {
167 if (urb->iso_frame_desc[i].status < 0) {
168 print_err_status(dev, i,
169 urb->iso_frame_desc[i].status);
170 if (urb->iso_frame_desc[i].status != -EPROTO)
171 continue;
172 }
173 dvb_dmx_swfilter(&dev->dvb->demux,
174 urb->transfer_buffer +
175 urb->iso_frame_desc[i].offset,
176 urb->iso_frame_desc[i].actual_length);
177 }
178 }
179
180 return 0;
181 }
182
183 static int em28xx_start_streaming(struct em28xx_dvb *dvb)
184 {
185 int rc;
186 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
187 struct em28xx *dev = i2c_bus->dev;
188 int dvb_max_packet_size, packet_multiplier, dvb_alt;
189
190 if (dev->dvb_xfer_bulk) {
191 if (!dev->dvb_ep_bulk)
192 return -ENODEV;
193 dvb_max_packet_size = 512; /* USB 2.0 spec */
194 packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER;
195 dvb_alt = 0;
196 } else { /* isoc */
197 if (!dev->dvb_ep_isoc)
198 return -ENODEV;
199 dvb_max_packet_size = dev->dvb_max_pkt_size_isoc;
200 if (dvb_max_packet_size < 0)
201 return dvb_max_packet_size;
202 packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS;
203 dvb_alt = dev->dvb_alt_isoc;
204 }
205
206 usb_set_interface(dev->udev, dev->ifnum, dvb_alt);
207 rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
208 if (rc < 0)
209 return rc;
210
211 dprintk(1, "Using %d buffers each with %d x %d bytes\n",
212 EM28XX_DVB_NUM_BUFS,
213 packet_multiplier,
214 dvb_max_packet_size);
215
216 return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE,
217 dev->dvb_xfer_bulk,
218 EM28XX_DVB_NUM_BUFS,
219 dvb_max_packet_size,
220 packet_multiplier,
221 em28xx_dvb_urb_data_copy);
222 }
223
224 static int em28xx_stop_streaming(struct em28xx_dvb *dvb)
225 {
226 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
227 struct em28xx *dev = i2c_bus->dev;
228
229 em28xx_stop_urbs(dev);
230
231 return 0;
232 }
233
234 static int em28xx_start_feed(struct dvb_demux_feed *feed)
235 {
236 struct dvb_demux *demux = feed->demux;
237 struct em28xx_dvb *dvb = demux->priv;
238 int rc, ret;
239
240 if (!demux->dmx.frontend)
241 return -EINVAL;
242
243 mutex_lock(&dvb->lock);
244 dvb->nfeeds++;
245 rc = dvb->nfeeds;
246
247 if (dvb->nfeeds == 1) {
248 ret = em28xx_start_streaming(dvb);
249 if (ret < 0)
250 rc = ret;
251 }
252
253 mutex_unlock(&dvb->lock);
254 return rc;
255 }
256
257 static int em28xx_stop_feed(struct dvb_demux_feed *feed)
258 {
259 struct dvb_demux *demux = feed->demux;
260 struct em28xx_dvb *dvb = demux->priv;
261 int err = 0;
262
263 mutex_lock(&dvb->lock);
264 dvb->nfeeds--;
265
266 if (0 == dvb->nfeeds)
267 err = em28xx_stop_streaming(dvb);
268
269 mutex_unlock(&dvb->lock);
270 return err;
271 }
272
273
274
275 /* ------------------------------------------------------------------ */
276 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
277 {
278 struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
279 struct em28xx *dev = i2c_bus->dev;
280
281 if (acquire)
282 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
283 else
284 return em28xx_set_mode(dev, EM28XX_SUSPEND);
285 }
286
287 /* ------------------------------------------------------------------ */
288
289 static struct lgdt330x_config em2880_lgdt3303_dev = {
290 .demod_address = 0x0e,
291 .demod_chip = LGDT3303,
292 };
293
294 static struct lgdt3305_config em2870_lgdt3304_dev = {
295 .i2c_addr = 0x0e,
296 .demod_chip = LGDT3304,
297 .spectral_inversion = 1,
298 .deny_i2c_rptr = 1,
299 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
300 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
301 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
302 .vsb_if_khz = 3250,
303 .qam_if_khz = 4000,
304 };
305
306 static struct lgdt3305_config em2874_lgdt3305_dev = {
307 .i2c_addr = 0x0e,
308 .demod_chip = LGDT3305,
309 .spectral_inversion = 1,
310 .deny_i2c_rptr = 0,
311 .mpeg_mode = LGDT3305_MPEG_SERIAL,
312 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
313 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
314 .vsb_if_khz = 3250,
315 .qam_if_khz = 4000,
316 };
317
318 static struct s921_config sharp_isdbt = {
319 .demod_address = 0x30 >> 1
320 };
321
322 static struct zl10353_config em28xx_zl10353_with_xc3028 = {
323 .demod_address = (0x1e >> 1),
324 .no_tuner = 1,
325 .parallel_ts = 1,
326 .if2 = 45600,
327 };
328
329 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
330 .demod_address = 0x32 >> 1,
331 .output_mode = S5H1409_PARALLEL_OUTPUT,
332 .gpio = S5H1409_GPIO_OFF,
333 .inversion = S5H1409_INVERSION_OFF,
334 .status_mode = S5H1409_DEMODLOCKING,
335 .mpeg_timing = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
336 };
337
338 static struct tda18271_std_map kworld_a340_std_map = {
339 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 0,
340 .if_lvl = 1, .rfagc_top = 0x37, },
341 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 1,
342 .if_lvl = 1, .rfagc_top = 0x37, },
343 };
344
345 static struct tda18271_config kworld_a340_config = {
346 .std_map = &kworld_a340_std_map,
347 };
348
349 static struct tda18271_config kworld_ub435q_v2_config = {
350 .std_map = &kworld_a340_std_map,
351 .gate = TDA18271_GATE_DIGITAL,
352 };
353
354 static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
355 .demod_address = (0x1e >> 1),
356 .no_tuner = 1,
357 .disable_i2c_gate_ctrl = 1,
358 .parallel_ts = 1,
359 .if2 = 45600,
360 };
361
362 static struct drxd_config em28xx_drxd = {
363 .demod_address = 0x70,
364 .demod_revision = 0xa2,
365 .pll_type = DRXD_PLL_NONE,
366 .clock = 12000,
367 .insert_rs_byte = 1,
368 .IF = 42800000,
369 .disable_i2c_gate_ctrl = 1,
370 };
371
372 static struct drxk_config terratec_h5_drxk = {
373 .adr = 0x29,
374 .single_master = 1,
375 .no_i2c_bridge = 1,
376 .microcode_name = "dvb-usb-terratec-h5-drxk.fw",
377 .qam_demod_parameter_count = 2,
378 };
379
380 static struct drxk_config hauppauge_930c_drxk = {
381 .adr = 0x29,
382 .single_master = 1,
383 .no_i2c_bridge = 1,
384 .microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw",
385 .chunk_size = 56,
386 .qam_demod_parameter_count = 2,
387 };
388
389 static struct drxk_config terratec_htc_stick_drxk = {
390 .adr = 0x29,
391 .single_master = 1,
392 .no_i2c_bridge = 1,
393 .microcode_name = "dvb-usb-terratec-htc-stick-drxk.fw",
394 .chunk_size = 54,
395 .qam_demod_parameter_count = 2,
396 /* Required for the antenna_gpio to disable LNA. */
397 .antenna_dvbt = true,
398 /* The windows driver uses the same. This will disable LNA. */
399 .antenna_gpio = 0x6,
400 };
401
402 static struct drxk_config maxmedia_ub425_tc_drxk = {
403 .adr = 0x29,
404 .single_master = 1,
405 .no_i2c_bridge = 1,
406 .microcode_name = "dvb-demod-drxk-01.fw",
407 .chunk_size = 62,
408 .qam_demod_parameter_count = 2,
409 };
410
411 static struct drxk_config pctv_520e_drxk = {
412 .adr = 0x29,
413 .single_master = 1,
414 .microcode_name = "dvb-demod-drxk-pctv.fw",
415 .qam_demod_parameter_count = 2,
416 .chunk_size = 58,
417 .antenna_dvbt = true, /* disable LNA */
418 .antenna_gpio = (1 << 2), /* disable LNA */
419 };
420
421 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
422 {
423 struct em28xx_dvb *dvb = fe->sec_priv;
424 int status;
425
426 if (!dvb)
427 return -EINVAL;
428
429 if (enable) {
430 down(&dvb->pll_mutex);
431 status = dvb->gate_ctrl(fe, 1);
432 } else {
433 status = dvb->gate_ctrl(fe, 0);
434 up(&dvb->pll_mutex);
435 }
436 return status;
437 }
438
439 static void hauppauge_hvr930c_init(struct em28xx *dev)
440 {
441 int i;
442
443 struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
444 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0x65},
445 {EM2874_R80_GPIO_P0_CTRL, 0xfb, 0xff, 0x32},
446 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0xb8},
447 { -1, -1, -1, -1},
448 };
449 struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
450 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01},
451 {EM2874_R80_GPIO_P0_CTRL, 0xaf, 0xff, 0x65},
452 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x76},
453 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01},
454 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b},
455 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x40},
456
457 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x65},
458 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65},
459 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b},
460 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65},
461
462 { -1, -1, -1, -1},
463 };
464
465 struct {
466 unsigned char r[4];
467 int len;
468 } regs[] = {
469 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
470 {{ 0x01, 0x02 }, 2},
471 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
472 {{ 0x01, 0x00 }, 2},
473 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
474 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
475 {{ 0x01, 0x00 }, 2},
476 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
477 {{ 0x04, 0x00 }, 2},
478 {{ 0x00, 0x04 }, 2},
479 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
480 {{ 0x04, 0x14 }, 2},
481 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
482 };
483
484 em28xx_gpio_set(dev, hauppauge_hvr930c_init);
485 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
486 msleep(10);
487 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
488 msleep(10);
489
490 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
491
492 for (i = 0; i < ARRAY_SIZE(regs); i++)
493 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
494 em28xx_gpio_set(dev, hauppauge_hvr930c_end);
495
496 msleep(100);
497
498 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
499 msleep(30);
500
501 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
502 msleep(10);
503
504 }
505
506 static void terratec_h5_init(struct em28xx *dev)
507 {
508 int i;
509 struct em28xx_reg_seq terratec_h5_init[] = {
510 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
511 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
512 {EM2874_R80_GPIO_P0_CTRL, 0xf2, 0xff, 50},
513 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
514 { -1, -1, -1, -1},
515 };
516 struct em28xx_reg_seq terratec_h5_end[] = {
517 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
518 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50},
519 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
520 { -1, -1, -1, -1},
521 };
522 struct {
523 unsigned char r[4];
524 int len;
525 } regs[] = {
526 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
527 {{ 0x01, 0x02 }, 2},
528 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
529 {{ 0x01, 0x00 }, 2},
530 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
531 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
532 {{ 0x01, 0x00 }, 2},
533 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
534 {{ 0x04, 0x00 }, 2},
535 {{ 0x00, 0x04 }, 2},
536 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
537 {{ 0x04, 0x14 }, 2},
538 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
539 };
540
541 em28xx_gpio_set(dev, terratec_h5_init);
542 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
543 msleep(10);
544 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
545 msleep(10);
546
547 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
548
549 for (i = 0; i < ARRAY_SIZE(regs); i++)
550 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
551 em28xx_gpio_set(dev, terratec_h5_end);
552 };
553
554 static void terratec_htc_stick_init(struct em28xx *dev)
555 {
556 int i;
557
558 /*
559 * GPIO configuration:
560 * 0xff: unknown (does not affect DVB-T).
561 * 0xf6: DRX-K (demodulator).
562 * 0xe6: unknown (does not affect DVB-T).
563 * 0xb6: unknown (does not affect DVB-T).
564 */
565 struct em28xx_reg_seq terratec_htc_stick_init[] = {
566 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
567 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
568 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 50},
569 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
570 { -1, -1, -1, -1},
571 };
572 struct em28xx_reg_seq terratec_htc_stick_end[] = {
573 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100},
574 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 50},
575 { -1, -1, -1, -1},
576 };
577
578 /*
579 * Init the analog decoder (not yet supported), but
580 * it's probably still a good idea.
581 */
582 struct {
583 unsigned char r[4];
584 int len;
585 } regs[] = {
586 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
587 {{ 0x01, 0x02 }, 2},
588 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
589 {{ 0x01, 0x00 }, 2},
590 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
591 };
592
593 em28xx_gpio_set(dev, terratec_htc_stick_init);
594
595 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
596 msleep(10);
597 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
598 msleep(10);
599
600 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
601
602 for (i = 0; i < ARRAY_SIZE(regs); i++)
603 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
604
605 em28xx_gpio_set(dev, terratec_htc_stick_end);
606 };
607
608 static void terratec_htc_usb_xs_init(struct em28xx *dev)
609 {
610 int i;
611
612 struct em28xx_reg_seq terratec_htc_usb_xs_init[] = {
613 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
614 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 100},
615 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 50},
616 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100},
617 { -1, -1, -1, -1},
618 };
619 struct em28xx_reg_seq terratec_htc_usb_xs_end[] = {
620 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 100},
621 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50},
622 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
623 { -1, -1, -1, -1},
624 };
625
626 /*
627 * Init the analog decoder (not yet supported), but
628 * it's probably still a good idea.
629 */
630 struct {
631 unsigned char r[4];
632 int len;
633 } regs[] = {
634 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
635 {{ 0x01, 0x02 }, 2},
636 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
637 {{ 0x01, 0x00 }, 2},
638 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
639 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
640 {{ 0x01, 0x00 }, 2},
641 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
642 {{ 0x04, 0x00 }, 2},
643 {{ 0x00, 0x04 }, 2},
644 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
645 {{ 0x04, 0x14 }, 2},
646 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
647 };
648
649 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
650
651 em28xx_gpio_set(dev, terratec_htc_usb_xs_init);
652
653 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
654 msleep(10);
655 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
656 msleep(10);
657
658 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
659
660 for (i = 0; i < ARRAY_SIZE(regs); i++)
661 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
662
663 em28xx_gpio_set(dev, terratec_htc_usb_xs_end);
664 };
665
666 static void pctv_520e_init(struct em28xx *dev)
667 {
668 /*
669 * Init AVF4910B analog decoder. Looks like I2C traffic to
670 * digital demodulator and tuner are routed via AVF4910B.
671 */
672 int i;
673 struct {
674 unsigned char r[4];
675 int len;
676 } regs[] = {
677 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
678 {{ 0x01, 0x02 }, 2},
679 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
680 {{ 0x01, 0x00 }, 2},
681 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
682 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
683 {{ 0x01, 0x00 }, 2},
684 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
685 };
686
687 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; /* 0x41 */
688
689 for (i = 0; i < ARRAY_SIZE(regs); i++)
690 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
691 };
692
693 static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe)
694 {
695 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
696 struct em28xx *dev = fe->dvb->priv;
697 #ifdef CONFIG_GPIOLIB
698 struct em28xx_dvb *dvb = dev->dvb;
699 int ret;
700 unsigned long flags;
701
702 if (c->lna == 1)
703 flags = GPIOF_OUT_INIT_HIGH; /* enable LNA */
704 else
705 flags = GPIOF_OUT_INIT_LOW; /* disable LNA */
706
707 ret = gpio_request_one(dvb->lna_gpio, flags, NULL);
708 if (ret)
709 em28xx_errdev("gpio request failed %d\n", ret);
710 else
711 gpio_free(dvb->lna_gpio);
712
713 return ret;
714 #else
715 dev_warn(&dev->udev->dev, "%s: LNA control is disabled (lna=%u)\n",
716 KBUILD_MODNAME, c->lna);
717 return 0;
718 #endif
719 }
720
721 static int em28xx_mt352_terratec_xs_init(struct dvb_frontend *fe)
722 {
723 /* Values extracted from a USB trace of the Terratec Windows driver */
724 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x2c };
725 static u8 reset[] = { RESET, 0x80 };
726 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
727 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0xa0 };
728 static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
729 static u8 rs_err_cfg[] = { RS_ERR_PER_1, 0x00, 0x4d };
730 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
731 static u8 trl_nom_cfg[] = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
732 static u8 tps_given_cfg[] = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
733 static u8 tuner_go[] = { TUNER_GO, 0x01};
734
735 mt352_write(fe, clock_config, sizeof(clock_config));
736 udelay(200);
737 mt352_write(fe, reset, sizeof(reset));
738 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
739 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
740 mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
741 mt352_write(fe, rs_err_cfg, sizeof(rs_err_cfg));
742 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
743 mt352_write(fe, trl_nom_cfg, sizeof(trl_nom_cfg));
744 mt352_write(fe, tps_given_cfg, sizeof(tps_given_cfg));
745 mt352_write(fe, tuner_go, sizeof(tuner_go));
746 return 0;
747 }
748
749 static struct mt352_config terratec_xs_mt352_cfg = {
750 .demod_address = (0x1e >> 1),
751 .no_tuner = 1,
752 .if2 = 45600,
753 .demod_init = em28xx_mt352_terratec_xs_init,
754 };
755
756 static struct tda10023_config em28xx_tda10023_config = {
757 .demod_address = 0x0c,
758 .invert = 1,
759 };
760
761 static struct cxd2820r_config em28xx_cxd2820r_config = {
762 .i2c_address = (0xd8 >> 1),
763 .ts_mode = CXD2820R_TS_SERIAL,
764 };
765
766 static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
767 .output_opt = TDA18271_OUTPUT_LT_OFF,
768 .gate = TDA18271_GATE_DIGITAL,
769 };
770
771 static const struct tda10071_config em28xx_tda10071_config = {
772 .demod_i2c_addr = 0x55, /* (0xaa >> 1) */
773 .tuner_i2c_addr = 0x14,
774 .i2c_wr_max = 64,
775 .ts_mode = TDA10071_TS_SERIAL,
776 .spec_inv = 0,
777 .xtal = 40444000, /* 40.444 MHz */
778 .pll_multiplier = 20,
779 };
780
781 static const struct a8293_config em28xx_a8293_config = {
782 .i2c_addr = 0x08, /* (0x10 >> 1) */
783 };
784
785 static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
786 .demod_address = (0x1e >> 1),
787 .disable_i2c_gate_ctrl = 1,
788 .no_tuner = 1,
789 .parallel_ts = 1,
790 };
791 static struct qt1010_config em28xx_qt1010_config = {
792 .i2c_address = 0x62
793 };
794
795 static const struct mb86a20s_config c3tech_duo_mb86a20s_config = {
796 .demod_address = 0x10,
797 .is_serial = true,
798 };
799
800 static struct tda18271_std_map mb86a20s_tda18271_config = {
801 .dvbt_6 = { .if_freq = 4000, .agc_mode = 3, .std = 4,
802 .if_lvl = 1, .rfagc_top = 0x37, },
803 };
804
805 static struct tda18271_config c3tech_duo_tda18271_config = {
806 .std_map = &mb86a20s_tda18271_config,
807 .gate = TDA18271_GATE_DIGITAL,
808 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
809 };
810
811 static const struct m88ds3103_config pctv_461e_m88ds3103_config = {
812 .i2c_addr = 0x68,
813 .clock = 27000000,
814 .i2c_wr_max = 33,
815 .clock_out = 0,
816 .ts_mode = M88DS3103_TS_PARALLEL_16,
817 .agc = 0x99,
818 };
819
820 /* ------------------------------------------------------------------ */
821
822 static int em28xx_attach_xc3028(u8 addr, struct em28xx *dev)
823 {
824 struct dvb_frontend *fe;
825 struct xc2028_config cfg;
826 struct xc2028_ctrl ctl;
827
828 memset(&cfg, 0, sizeof(cfg));
829 cfg.i2c_adap = &dev->i2c_adap[dev->def_i2c_bus];
830 cfg.i2c_addr = addr;
831
832 memset(&ctl, 0, sizeof(ctl));
833 em28xx_setup_xc3028(dev, &ctl);
834 cfg.ctrl = &ctl;
835
836 if (!dev->dvb->fe[0]) {
837 em28xx_errdev("/2: dvb frontend not attached. "
838 "Can't attach xc3028\n");
839 return -EINVAL;
840 }
841
842 fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
843 if (!fe) {
844 em28xx_errdev("/2: xc3028 attach failed\n");
845 dvb_frontend_detach(dev->dvb->fe[0]);
846 dev->dvb->fe[0] = NULL;
847 return -EINVAL;
848 }
849
850 em28xx_info("%s/2: xc3028 attached\n", dev->name);
851
852 return 0;
853 }
854
855 /* ------------------------------------------------------------------ */
856
857 static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module,
858 struct em28xx *dev, struct device *device)
859 {
860 int result;
861
862 mutex_init(&dvb->lock);
863
864 /* register adapter */
865 result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
866 adapter_nr);
867 if (result < 0) {
868 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
869 dev->name, result);
870 goto fail_adapter;
871 }
872
873 /* Ensure all frontends negotiate bus access */
874 dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
875 if (dvb->fe[1])
876 dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
877
878 dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus];
879
880 /* register frontend */
881 result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
882 if (result < 0) {
883 printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
884 dev->name, result);
885 goto fail_frontend0;
886 }
887
888 /* register 2nd frontend */
889 if (dvb->fe[1]) {
890 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
891 if (result < 0) {
892 printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n",
893 dev->name, result);
894 goto fail_frontend1;
895 }
896 }
897
898 /* register demux stuff */
899 dvb->demux.dmx.capabilities =
900 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
901 DMX_MEMORY_BASED_FILTERING;
902 dvb->demux.priv = dvb;
903 dvb->demux.filternum = 256;
904 dvb->demux.feednum = 256;
905 dvb->demux.start_feed = em28xx_start_feed;
906 dvb->demux.stop_feed = em28xx_stop_feed;
907
908 result = dvb_dmx_init(&dvb->demux);
909 if (result < 0) {
910 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
911 dev->name, result);
912 goto fail_dmx;
913 }
914
915 dvb->dmxdev.filternum = 256;
916 dvb->dmxdev.demux = &dvb->demux.dmx;
917 dvb->dmxdev.capabilities = 0;
918 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
919 if (result < 0) {
920 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
921 dev->name, result);
922 goto fail_dmxdev;
923 }
924
925 dvb->fe_hw.source = DMX_FRONTEND_0;
926 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
927 if (result < 0) {
928 printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
929 dev->name, result);
930 goto fail_fe_hw;
931 }
932
933 dvb->fe_mem.source = DMX_MEMORY_FE;
934 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
935 if (result < 0) {
936 printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
937 dev->name, result);
938 goto fail_fe_mem;
939 }
940
941 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
942 if (result < 0) {
943 printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
944 dev->name, result);
945 goto fail_fe_conn;
946 }
947
948 /* register network adapter */
949 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
950 return 0;
951
952 fail_fe_conn:
953 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
954 fail_fe_mem:
955 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
956 fail_fe_hw:
957 dvb_dmxdev_release(&dvb->dmxdev);
958 fail_dmxdev:
959 dvb_dmx_release(&dvb->demux);
960 fail_dmx:
961 if (dvb->fe[1])
962 dvb_unregister_frontend(dvb->fe[1]);
963 dvb_unregister_frontend(dvb->fe[0]);
964 fail_frontend1:
965 if (dvb->fe[1])
966 dvb_frontend_detach(dvb->fe[1]);
967 fail_frontend0:
968 dvb_frontend_detach(dvb->fe[0]);
969 dvb_unregister_adapter(&dvb->adapter);
970 fail_adapter:
971 return result;
972 }
973
974 static void em28xx_unregister_dvb(struct em28xx_dvb *dvb)
975 {
976 dvb_net_release(&dvb->net);
977 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
978 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
979 dvb_dmxdev_release(&dvb->dmxdev);
980 dvb_dmx_release(&dvb->demux);
981 if (dvb->fe[1])
982 dvb_unregister_frontend(dvb->fe[1]);
983 dvb_unregister_frontend(dvb->fe[0]);
984 if (dvb->fe[1] && !dvb->dont_attach_fe1)
985 dvb_frontend_detach(dvb->fe[1]);
986 dvb_frontend_detach(dvb->fe[0]);
987 dvb_unregister_adapter(&dvb->adapter);
988 }
989
990 static int em28xx_dvb_init(struct em28xx *dev)
991 {
992 int result = 0, mfe_shared = 0;
993 struct em28xx_dvb *dvb;
994
995 if (dev->is_audio_only) {
996 /* Shouldn't initialize IR for this interface */
997 return 0;
998 }
999
1000 if (!dev->board.has_dvb) {
1001 /* This device does not support the extension */
1002 return 0;
1003 }
1004
1005 em28xx_info("Binding DVB extension\n");
1006
1007 dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
1008
1009 if (dvb == NULL) {
1010 em28xx_info("em28xx_dvb: memory allocation failed\n");
1011 return -ENOMEM;
1012 }
1013 dev->dvb = dvb;
1014 dvb->fe[0] = dvb->fe[1] = NULL;
1015
1016 /* pre-allocate DVB usb transfer buffers */
1017 if (dev->dvb_xfer_bulk) {
1018 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1019 dev->dvb_xfer_bulk,
1020 EM28XX_DVB_NUM_BUFS,
1021 512,
1022 EM28XX_DVB_BULK_PACKET_MULTIPLIER);
1023 } else {
1024 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1025 dev->dvb_xfer_bulk,
1026 EM28XX_DVB_NUM_BUFS,
1027 dev->dvb_max_pkt_size_isoc,
1028 EM28XX_DVB_NUM_ISOC_PACKETS);
1029 }
1030 if (result) {
1031 em28xx_errdev("em28xx_dvb: failed to pre-allocate USB transfer buffers for DVB.\n");
1032 kfree(dvb);
1033 dev->dvb = NULL;
1034 return result;
1035 }
1036
1037 mutex_lock(&dev->lock);
1038 em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
1039 /* init frontend */
1040 switch (dev->model) {
1041 case EM2874_BOARD_LEADERSHIP_ISDBT:
1042 dvb->fe[0] = dvb_attach(s921_attach,
1043 &sharp_isdbt, &dev->i2c_adap[dev->def_i2c_bus]);
1044
1045 if (!dvb->fe[0]) {
1046 result = -EINVAL;
1047 goto out_free;
1048 }
1049
1050 break;
1051 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
1052 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
1053 case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
1054 case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
1055 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1056 &em2880_lgdt3303_dev,
1057 &dev->i2c_adap[dev->def_i2c_bus]);
1058 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1059 result = -EINVAL;
1060 goto out_free;
1061 }
1062 break;
1063 case EM2880_BOARD_KWORLD_DVB_310U:
1064 dvb->fe[0] = dvb_attach(zl10353_attach,
1065 &em28xx_zl10353_with_xc3028,
1066 &dev->i2c_adap[dev->def_i2c_bus]);
1067 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1068 result = -EINVAL;
1069 goto out_free;
1070 }
1071 break;
1072 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
1073 case EM2882_BOARD_TERRATEC_HYBRID_XS:
1074 case EM2880_BOARD_EMPIRE_DUAL_TV:
1075 dvb->fe[0] = dvb_attach(zl10353_attach,
1076 &em28xx_zl10353_xc3028_no_i2c_gate,
1077 &dev->i2c_adap[dev->def_i2c_bus]);
1078 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1079 result = -EINVAL;
1080 goto out_free;
1081 }
1082 break;
1083 case EM2880_BOARD_TERRATEC_HYBRID_XS:
1084 case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
1085 case EM2881_BOARD_PINNACLE_HYBRID_PRO:
1086 case EM2882_BOARD_DIKOM_DK300:
1087 case EM2882_BOARD_KWORLD_VS_DVBT:
1088 dvb->fe[0] = dvb_attach(zl10353_attach,
1089 &em28xx_zl10353_xc3028_no_i2c_gate,
1090 &dev->i2c_adap[dev->def_i2c_bus]);
1091 if (dvb->fe[0] == NULL) {
1092 /* This board could have either a zl10353 or a mt352.
1093 If the chip id isn't for zl10353, try mt352 */
1094 dvb->fe[0] = dvb_attach(mt352_attach,
1095 &terratec_xs_mt352_cfg,
1096 &dev->i2c_adap[dev->def_i2c_bus]);
1097 }
1098
1099 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1100 result = -EINVAL;
1101 goto out_free;
1102 }
1103 break;
1104 case EM2870_BOARD_KWORLD_355U:
1105 dvb->fe[0] = dvb_attach(zl10353_attach,
1106 &em28xx_zl10353_no_i2c_gate_dev,
1107 &dev->i2c_adap[dev->def_i2c_bus]);
1108 if (dvb->fe[0] != NULL)
1109 dvb_attach(qt1010_attach, dvb->fe[0],
1110 &dev->i2c_adap[dev->def_i2c_bus], &em28xx_qt1010_config);
1111 break;
1112 case EM2883_BOARD_KWORLD_HYBRID_330U:
1113 case EM2882_BOARD_EVGA_INDTUBE:
1114 dvb->fe[0] = dvb_attach(s5h1409_attach,
1115 &em28xx_s5h1409_with_xc3028,
1116 &dev->i2c_adap[dev->def_i2c_bus]);
1117 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1118 result = -EINVAL;
1119 goto out_free;
1120 }
1121 break;
1122 case EM2882_BOARD_KWORLD_ATSC_315U:
1123 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1124 &em2880_lgdt3303_dev,
1125 &dev->i2c_adap[dev->def_i2c_bus]);
1126 if (dvb->fe[0] != NULL) {
1127 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1128 &dev->i2c_adap[dev->def_i2c_bus], 0x61, TUNER_THOMSON_DTT761X)) {
1129 result = -EINVAL;
1130 goto out_free;
1131 }
1132 }
1133 break;
1134 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
1135 case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
1136 dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
1137 &dev->i2c_adap[dev->def_i2c_bus], &dev->udev->dev);
1138 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1139 result = -EINVAL;
1140 goto out_free;
1141 }
1142 break;
1143 case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
1144 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
1145 dvb->fe[0] = dvb_attach(tda10023_attach,
1146 &em28xx_tda10023_config,
1147 &dev->i2c_adap[dev->def_i2c_bus], 0x48);
1148 if (dvb->fe[0]) {
1149 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1150 &dev->i2c_adap[dev->def_i2c_bus], 0x60, TUNER_PHILIPS_CU1216L)) {
1151 result = -EINVAL;
1152 goto out_free;
1153 }
1154 }
1155 break;
1156 case EM2870_BOARD_KWORLD_A340:
1157 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1158 &em2870_lgdt3304_dev,
1159 &dev->i2c_adap[dev->def_i2c_bus]);
1160 if (dvb->fe[0] != NULL)
1161 dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1162 &dev->i2c_adap[dev->def_i2c_bus], &kworld_a340_config);
1163 break;
1164 case EM28174_BOARD_PCTV_290E:
1165 /* set default GPIO0 for LNA, used if GPIOLIB is undefined */
1166 dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O |
1167 CXD2820R_GPIO_L;
1168 dvb->fe[0] = dvb_attach(cxd2820r_attach,
1169 &em28xx_cxd2820r_config,
1170 &dev->i2c_adap[dev->def_i2c_bus],
1171 &dvb->lna_gpio);
1172 if (dvb->fe[0]) {
1173 /* FE 0 attach tuner */
1174 if (!dvb_attach(tda18271_attach,
1175 dvb->fe[0],
1176 0x60,
1177 &dev->i2c_adap[dev->def_i2c_bus],
1178 &em28xx_cxd2820r_tda18271_config)) {
1179
1180 dvb_frontend_detach(dvb->fe[0]);
1181 result = -EINVAL;
1182 goto out_free;
1183 }
1184
1185 #ifdef CONFIG_GPIOLIB
1186 /* enable LNA for DVB-T, DVB-T2 and DVB-C */
1187 result = gpio_request_one(dvb->lna_gpio,
1188 GPIOF_OUT_INIT_LOW, NULL);
1189 if (result)
1190 em28xx_errdev("gpio request failed %d\n",
1191 result);
1192 else
1193 gpio_free(dvb->lna_gpio);
1194
1195 result = 0; /* continue even set LNA fails */
1196 #endif
1197 dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna;
1198 }
1199
1200 break;
1201 case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
1202 {
1203 struct xc5000_config cfg;
1204 hauppauge_hvr930c_init(dev);
1205
1206 dvb->fe[0] = dvb_attach(drxk_attach,
1207 &hauppauge_930c_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1208 if (!dvb->fe[0]) {
1209 result = -EINVAL;
1210 goto out_free;
1211 }
1212 /* FIXME: do we need a pll semaphore? */
1213 dvb->fe[0]->sec_priv = dvb;
1214 sema_init(&dvb->pll_mutex, 1);
1215 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1216 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1217
1218 /* Attach xc5000 */
1219 memset(&cfg, 0, sizeof(cfg));
1220 cfg.i2c_address = 0x61;
1221 cfg.if_khz = 4000;
1222
1223 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1224 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1225 if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus],
1226 &cfg)) {
1227 result = -EINVAL;
1228 goto out_free;
1229 }
1230 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1231 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1232
1233 break;
1234 }
1235 case EM2884_BOARD_TERRATEC_H5:
1236 terratec_h5_init(dev);
1237
1238 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1239 if (!dvb->fe[0]) {
1240 result = -EINVAL;
1241 goto out_free;
1242 }
1243 /* FIXME: do we need a pll semaphore? */
1244 dvb->fe[0]->sec_priv = dvb;
1245 sema_init(&dvb->pll_mutex, 1);
1246 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1247 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1248
1249 /* Attach tda18271 to DVB-C frontend */
1250 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1251 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1252 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60)) {
1253 result = -EINVAL;
1254 goto out_free;
1255 }
1256 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1257 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1258
1259 break;
1260 case EM2884_BOARD_C3TECH_DIGITAL_DUO:
1261 dvb->fe[0] = dvb_attach(mb86a20s_attach,
1262 &c3tech_duo_mb86a20s_config,
1263 &dev->i2c_adap[dev->def_i2c_bus]);
1264 if (dvb->fe[0] != NULL)
1265 dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1266 &dev->i2c_adap[dev->def_i2c_bus],
1267 &c3tech_duo_tda18271_config);
1268 break;
1269 case EM28174_BOARD_PCTV_460E:
1270 /* attach demod */
1271 dvb->fe[0] = dvb_attach(tda10071_attach,
1272 &em28xx_tda10071_config, &dev->i2c_adap[dev->def_i2c_bus]);
1273
1274 /* attach SEC */
1275 if (dvb->fe[0])
1276 dvb_attach(a8293_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus],
1277 &em28xx_a8293_config);
1278 break;
1279 case EM2874_BOARD_DELOCK_61959:
1280 case EM2874_BOARD_MAXMEDIA_UB425_TC:
1281 /* attach demodulator */
1282 dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk,
1283 &dev->i2c_adap[dev->def_i2c_bus]);
1284
1285 if (dvb->fe[0]) {
1286 /* disable I2C-gate */
1287 dvb->fe[0]->ops.i2c_gate_ctrl = NULL;
1288
1289 /* attach tuner */
1290 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1291 &dev->i2c_adap[dev->def_i2c_bus],
1292 &em28xx_cxd2820r_tda18271_config)) {
1293 dvb_frontend_detach(dvb->fe[0]);
1294 result = -EINVAL;
1295 goto out_free;
1296 }
1297 }
1298 break;
1299 case EM2884_BOARD_PCTV_510E:
1300 case EM2884_BOARD_PCTV_520E:
1301 pctv_520e_init(dev);
1302
1303 /* attach demodulator */
1304 dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk,
1305 &dev->i2c_adap[dev->def_i2c_bus]);
1306
1307 if (dvb->fe[0]) {
1308 /* attach tuner */
1309 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1310 &dev->i2c_adap[dev->def_i2c_bus],
1311 &em28xx_cxd2820r_tda18271_config)) {
1312 dvb_frontend_detach(dvb->fe[0]);
1313 result = -EINVAL;
1314 goto out_free;
1315 }
1316 }
1317 break;
1318 case EM2884_BOARD_CINERGY_HTC_STICK:
1319 terratec_htc_stick_init(dev);
1320
1321 /* attach demodulator */
1322 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1323 &dev->i2c_adap[dev->def_i2c_bus]);
1324 if (!dvb->fe[0]) {
1325 result = -EINVAL;
1326 goto out_free;
1327 }
1328
1329 /* Attach the demodulator. */
1330 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1331 &dev->i2c_adap[dev->def_i2c_bus],
1332 &em28xx_cxd2820r_tda18271_config)) {
1333 result = -EINVAL;
1334 goto out_free;
1335 }
1336 break;
1337 case EM2884_BOARD_TERRATEC_HTC_USB_XS:
1338 terratec_htc_usb_xs_init(dev);
1339
1340 /* attach demodulator */
1341 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1342 &dev->i2c_adap[dev->def_i2c_bus]);
1343 if (!dvb->fe[0]) {
1344 result = -EINVAL;
1345 goto out_free;
1346 }
1347
1348 /* Attach the demodulator. */
1349 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1350 &dev->i2c_adap[dev->def_i2c_bus],
1351 &em28xx_cxd2820r_tda18271_config)) {
1352 result = -EINVAL;
1353 goto out_free;
1354 }
1355 break;
1356 case EM2874_BOARD_KWORLD_UB435Q_V2:
1357 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1358 &em2874_lgdt3305_dev,
1359 &dev->i2c_adap[dev->def_i2c_bus]);
1360 if (!dvb->fe[0]) {
1361 result = -EINVAL;
1362 goto out_free;
1363 }
1364
1365 /* Attach the demodulator. */
1366 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1367 &dev->i2c_adap[dev->def_i2c_bus],
1368 &kworld_ub435q_v2_config)) {
1369 result = -EINVAL;
1370 goto out_free;
1371 }
1372 break;
1373 case EM28178_BOARD_PCTV_461E:
1374 {
1375 /* demod I2C adapter */
1376 struct i2c_adapter *i2c_adapter;
1377 struct i2c_board_info info;
1378 struct m88ts2022_config m88ts2022_config = {
1379 .clock = 27000000,
1380 };
1381 memset(&info, 0, sizeof(struct i2c_board_info));
1382
1383 /* attach demod */
1384 dvb->fe[0] = dvb_attach(m88ds3103_attach,
1385 &pctv_461e_m88ds3103_config,
1386 &dev->i2c_adap[dev->def_i2c_bus],
1387 &i2c_adapter);
1388 if (dvb->fe[0] == NULL) {
1389 result = -ENODEV;
1390 goto out_free;
1391 }
1392
1393 /* attach tuner */
1394 m88ts2022_config.fe = dvb->fe[0];
1395 strlcpy(info.type, "m88ts2022", I2C_NAME_SIZE);
1396 info.addr = 0x60;
1397 info.platform_data = &m88ts2022_config;
1398 request_module("m88ts2022");
1399 dvb->i2c_client_tuner = i2c_new_device(i2c_adapter, &info);
1400
1401 /* delegate signal strength measurement to tuner */
1402 dvb->fe[0]->ops.read_signal_strength =
1403 dvb->fe[0]->ops.tuner_ops.get_rf_strength;
1404
1405 /* attach SEC */
1406 if (!dvb_attach(a8293_attach, dvb->fe[0],
1407 &dev->i2c_adap[dev->def_i2c_bus],
1408 &em28xx_a8293_config)) {
1409 dvb_frontend_detach(dvb->fe[0]);
1410 result = -ENODEV;
1411 goto out_free;
1412 }
1413 }
1414 break;
1415 default:
1416 em28xx_errdev("/2: The frontend of your DVB/ATSC card"
1417 " isn't supported yet\n");
1418 break;
1419 }
1420 if (NULL == dvb->fe[0]) {
1421 em28xx_errdev("/2: frontend initialization failed\n");
1422 result = -EINVAL;
1423 goto out_free;
1424 }
1425 /* define general-purpose callback pointer */
1426 dvb->fe[0]->callback = em28xx_tuner_callback;
1427 if (dvb->fe[1])
1428 dvb->fe[1]->callback = em28xx_tuner_callback;
1429
1430 /* register everything */
1431 result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
1432
1433 if (result < 0)
1434 goto out_free;
1435
1436 /* MFE lock */
1437 dvb->adapter.mfe_shared = mfe_shared;
1438
1439 em28xx_info("DVB extension successfully initialized\n");
1440 ret:
1441 em28xx_set_mode(dev, EM28XX_SUSPEND);
1442 mutex_unlock(&dev->lock);
1443 return result;
1444
1445 out_free:
1446 kfree(dvb);
1447 dev->dvb = NULL;
1448 goto ret;
1449 }
1450
1451 static inline void prevent_sleep(struct dvb_frontend_ops *ops)
1452 {
1453 ops->set_voltage = NULL;
1454 ops->sleep = NULL;
1455 ops->tuner_ops.sleep = NULL;
1456 }
1457
1458 static int em28xx_dvb_fini(struct em28xx *dev)
1459 {
1460 if (dev->is_audio_only) {
1461 /* Shouldn't initialize IR for this interface */
1462 return 0;
1463 }
1464
1465 if (!dev->board.has_dvb) {
1466 /* This device does not support the extension */
1467 return 0;
1468 }
1469
1470 em28xx_info("Closing DVB extension");
1471
1472 if (dev->dvb) {
1473 struct em28xx_dvb *dvb = dev->dvb;
1474
1475 em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
1476
1477 if (dev->disconnected) {
1478 /* We cannot tell the device to sleep
1479 * once it has been unplugged. */
1480 if (dvb->fe[0])
1481 prevent_sleep(&dvb->fe[0]->ops);
1482 if (dvb->fe[1])
1483 prevent_sleep(&dvb->fe[1]->ops);
1484 }
1485
1486 i2c_release_client(dvb->i2c_client_tuner);
1487 em28xx_unregister_dvb(dvb);
1488 kfree(dvb);
1489 dev->dvb = NULL;
1490 }
1491
1492 return 0;
1493 }
1494
1495 static struct em28xx_ops dvb_ops = {
1496 .id = EM28XX_DVB,
1497 .name = "Em28xx dvb Extension",
1498 .init = em28xx_dvb_init,
1499 .fini = em28xx_dvb_fini,
1500 };
1501
1502 static int __init em28xx_dvb_register(void)
1503 {
1504 return em28xx_register_extension(&dvb_ops);
1505 }
1506
1507 static void __exit em28xx_dvb_unregister(void)
1508 {
1509 em28xx_unregister_extension(&dvb_ops);
1510 }
1511
1512 module_init(em28xx_dvb_register);
1513 module_exit(em28xx_dvb_unregister);
Linux with added FPC-III support