/drivers/media/video/em28xx/em28xx-dvb.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 757 lines · 605 code · 103 blank · 49 comment · 67 complexity · 33300a6a1a0f3a61d0f0d8b25b014189 MD5 · raw file 

    

  1. /*
    2. 

  2.  DVB device driver for em28xx
    3. 

    4. 

  4.  (c) 2008 Mauro Carvalho Chehab <mchehab@infradead.org>
    5. 

    6. 

  6.  (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
    7. 

  7. 	- Fixes for the driver to properly work with HVR-950
    8. 

  8. 	- Fixes for the driver to properly work with Pinnacle PCTV HD Pro Stick
    9. 

  9. 	- Fixes for the driver to properly work with AMD ATI TV Wonder HD 600
    10. 

    11. 

  11.  (c) 2008 Aidan Thornton <makosoft@googlemail.com>
    12. 

    13. 

  13.  Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
    14. 

  14. 	(c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
    15. 

  15. 	(c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
    16. 

    17. 

  17.  This program is free software; you can redistribute it and/or modify
    18. 

  18.  it under the terms of the GNU General Public License as published by
    19. 

  19.  the Free Software Foundation; either version 2 of the License.
    20. 

  20.  */
    21. 

  21. 

  22. #include <linux/kernel.h>
    23. 

  23. #include <linux/slab.h>
    24. 

  24. #include <linux/usb.h>
    25. 

  25. 

  26. #include "em28xx.h"
    27. 

  27. #include <media/v4l2-common.h>
    28. 

  28. #include <media/videobuf-vmalloc.h>
    29. 

  29. #include <media/tuner.h>
    30. 

  30. #include "tuner-simple.h"
    31. 

  31. 

  32. #include "lgdt330x.h"
    33. 

  33. #include "lgdt3305.h"
    34. 

  34. #include "zl10353.h"
    35. 

  35. #include "s5h1409.h"
    36. 

  36. #include "mt352.h"
    37. 

  37. #include "mt352_priv.h" /* FIXME */
    38. 

  38. #include "tda1002x.h"
    39. 

  39. #include "tda18271.h"
    40. 

  40. #include "s921.h"
    41. 

  41. #include "drxd.h"
    42. 

  42. #include "cxd2820r.h"
    43. 

  43. 

  44. MODULE_DESCRIPTION("driver for em28xx based DVB cards");
    45. 

  45. MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
    46. 

  46. MODULE_LICENSE("GPL");
    47. 

  47. 

  48. static unsigned int debug;
    49. 

  49. module_param(debug, int, 0644);
    50. 

  50. MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
    51. 

  51. 

  52. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
    53. 

  53. 

  54. #define dprintk(level, fmt, arg...) do {			\
    55. 

  55. if (debug >= level) 						\
    56. 

  56. 	printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg);	\
    57. 

  57. } while (0)
    58. 

  58. 

  59. #define EM28XX_DVB_NUM_BUFS 5
    60. 

  60. #define EM28XX_DVB_MAX_PACKETS 64
    61. 

  61. 

  62. struct em28xx_dvb {
    63. 

  63. 	struct dvb_frontend        *fe[2];
    64. 

  64. 

  65. 	/* feed count management */
    66. 

  66. 	struct mutex               lock;
    67. 

  67. 	int                        nfeeds;
    68. 

  68. 

  69. 	/* general boilerplate stuff */
    70. 

  70. 	struct dvb_adapter         adapter;
    71. 

  71. 	struct dvb_demux           demux;
    72. 

  72. 	struct dmxdev              dmxdev;
    73. 

  73. 	struct dmx_frontend        fe_hw;
    74. 

  74. 	struct dmx_frontend        fe_mem;
    75. 

  75. 	struct dvb_net             net;
    76. 

  76. };
    77. 

  77. 

  78. 

  79. static inline void print_err_status(struct em28xx *dev,
    80. 

  80. 				     int packet, int status)
    81. 

  81. {
    82. 

  82. 	char *errmsg = "Unknown";
    83. 

  83. 

  84. 	switch (status) {
    85. 

  85. 	case -ENOENT:
    86. 

  86. 		errmsg = "unlinked synchronuously";
    87. 

  87. 		break;
    88. 

  88. 	case -ECONNRESET:
    89. 

  89. 		errmsg = "unlinked asynchronuously";
    90. 

  90. 		break;
    91. 

  91. 	case -ENOSR:
    92. 

  92. 		errmsg = "Buffer error (overrun)";
    93. 

  93. 		break;
    94. 

  94. 	case -EPIPE:
    95. 

  95. 		errmsg = "Stalled (device not responding)";
    96. 

  96. 		break;
    97. 

  97. 	case -EOVERFLOW:
    98. 

  98. 		errmsg = "Babble (bad cable?)";
    99. 

  99. 		break;
    100. 

  100. 	case -EPROTO:
    101. 

  101. 		errmsg = "Bit-stuff error (bad cable?)";
    102. 

  102. 		break;
    103. 

  103. 	case -EILSEQ:
    104. 

  104. 		errmsg = "CRC/Timeout (could be anything)";
    105. 

  105. 		break;
    106. 

  106. 	case -ETIME:
    107. 

  107. 		errmsg = "Device does not respond";
    108. 

  108. 		break;
    109. 

  109. 	}
    110. 

  110. 	if (packet < 0) {
    111. 

  111. 		dprintk(1, "URB status %d [%s].\n", status, errmsg);
    112. 

  112. 	} else {
    113. 

  113. 		dprintk(1, "URB packet %d, status %d [%s].\n",
    114. 

  114. 			packet, status, errmsg);
    115. 

  115. 	}
    116. 

  116. }
    117. 

  117. 

  118. static inline int dvb_isoc_copy(struct em28xx *dev, struct urb *urb)
    119. 

  119. {
    120. 

  120. 	int i;
    121. 

  121. 

  122. 	if (!dev)
    123. 

  123. 		return 0;
    124. 

  124. 

  125. 	if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
    126. 

  126. 		return 0;
    127. 

  127. 

  128. 	if (urb->status < 0) {
    129. 

  129. 		print_err_status(dev, -1, urb->status);
    130. 

  130. 		if (urb->status == -ENOENT)
    131. 

  131. 			return 0;
    132. 

  132. 	}
    133. 

  133. 

  134. 	for (i = 0; i < urb->number_of_packets; i++) {
    135. 

  135. 		int status = urb->iso_frame_desc[i].status;
    136. 

  136. 

  137. 		if (status < 0) {
    138. 

  138. 			print_err_status(dev, i, status);
    139. 

  139. 			if (urb->iso_frame_desc[i].status != -EPROTO)
    140. 

  140. 				continue;
    141. 

  141. 		}
    142. 

  142. 

  143. 		dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer +
    144. 

  144. 				 urb->iso_frame_desc[i].offset,
    145. 

  145. 				 urb->iso_frame_desc[i].actual_length);
    146. 

  146. 	}
    147. 

  147. 

  148. 	return 0;
    149. 

  149. }
    150. 

  150. 

  151. static int start_streaming(struct em28xx_dvb *dvb)
    152. 

  152. {
    153. 

  153. 	int rc;
    154. 

  154. 	struct em28xx *dev = dvb->adapter.priv;
    155. 

  155. 	int max_dvb_packet_size;
    156. 

  156. 

  157. 	usb_set_interface(dev->udev, 0, 1);
    158. 

  158. 	rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
    159. 

  159. 	if (rc < 0)
    160. 

  160. 		return rc;
    161. 

  161. 

  162. 	max_dvb_packet_size = em28xx_isoc_dvb_max_packetsize(dev);
    163. 

  163. 

  164. 	return em28xx_init_isoc(dev, EM28XX_DVB_MAX_PACKETS,
    165. 

  165. 				EM28XX_DVB_NUM_BUFS, max_dvb_packet_size,
    166. 

  166. 				dvb_isoc_copy);
    167. 

  167. }
    168. 

  168. 

  169. static int stop_streaming(struct em28xx_dvb *dvb)
    170. 

  170. {
    171. 

  171. 	struct em28xx *dev = dvb->adapter.priv;
    172. 

  172. 

  173. 	em28xx_uninit_isoc(dev);
    174. 

  174. 

  175. 	em28xx_set_mode(dev, EM28XX_SUSPEND);
    176. 

  176. 

  177. 	return 0;
    178. 

  178. }
    179. 

  179. 

  180. static int start_feed(struct dvb_demux_feed *feed)
    181. 

  181. {
    182. 

  182. 	struct dvb_demux *demux  = feed->demux;
    183. 

  183. 	struct em28xx_dvb *dvb = demux->priv;
    184. 

  184. 	int rc, ret;
    185. 

  185. 

  186. 	if (!demux->dmx.frontend)
    187. 

  187. 		return -EINVAL;
    188. 

  188. 

  189. 	mutex_lock(&dvb->lock);
    190. 

  190. 	dvb->nfeeds++;
    191. 

  191. 	rc = dvb->nfeeds;
    192. 

  192. 

  193. 	if (dvb->nfeeds == 1) {
    194. 

  194. 		ret = start_streaming(dvb);
    195. 

  195. 		if (ret < 0)
    196. 

  196. 			rc = ret;
    197. 

  197. 	}
    198. 

  198. 

  199. 	mutex_unlock(&dvb->lock);
    200. 

  200. 	return rc;
    201. 

  201. }
    202. 

  202. 

  203. static int stop_feed(struct dvb_demux_feed *feed)
    204. 

  204. {
    205. 

  205. 	struct dvb_demux *demux  = feed->demux;
    206. 

  206. 	struct em28xx_dvb *dvb = demux->priv;
    207. 

  207. 	int err = 0;
    208. 

  208. 

  209. 	mutex_lock(&dvb->lock);
    210. 

  210. 	dvb->nfeeds--;
    211. 

  211. 

  212. 	if (0 == dvb->nfeeds)
    213. 

  213. 		err = stop_streaming(dvb);
    214. 

  214. 

  215. 	mutex_unlock(&dvb->lock);
    216. 

  216. 	return err;
    217. 

  217. }
    218. 

  218. 

  219. 

  220. 

  221. /* ------------------------------------------------------------------ */
    222. 

  222. static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
    223. 

  223. {
    224. 

  224. 	struct em28xx *dev = fe->dvb->priv;
    225. 

  225. 

  226. 	if (acquire)
    227. 

  227. 		return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
    228. 

  228. 	else
    229. 

  229. 		return em28xx_set_mode(dev, EM28XX_SUSPEND);
    230. 

  230. }
    231. 

  231. 

  232. /* ------------------------------------------------------------------ */
    233. 

  233. 

  234. static struct lgdt330x_config em2880_lgdt3303_dev = {
    235. 

  235. 	.demod_address = 0x0e,
    236. 

  236. 	.demod_chip = LGDT3303,
    237. 

  237. };
    238. 

  238. 

  239. static struct lgdt3305_config em2870_lgdt3304_dev = {
    240. 

  240. 	.i2c_addr           = 0x0e,
    241. 

  241. 	.demod_chip         = LGDT3304,
    242. 

  242. 	.spectral_inversion = 1,
    243. 

  243. 	.deny_i2c_rptr      = 1,
    244. 

  244. 	.mpeg_mode          = LGDT3305_MPEG_PARALLEL,
    245. 

  245. 	.tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
    246. 

  246. 	.tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
    247. 

  247. 	.vsb_if_khz         = 3250,
    248. 

  248. 	.qam_if_khz         = 4000,
    249. 

  249. };
    250. 

  250. 

  251. static struct s921_config sharp_isdbt = {
    252. 

  252. 	.demod_address = 0x30 >> 1
    253. 

  253. };
    254. 

  254. 

  255. static struct zl10353_config em28xx_zl10353_with_xc3028 = {
    256. 

  256. 	.demod_address = (0x1e >> 1),
    257. 

  257. 	.no_tuner = 1,
    258. 

  258. 	.parallel_ts = 1,
    259. 

  259. 	.if2 = 45600,
    260. 

  260. };
    261. 

  261. 

  262. static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
    263. 

  263. 	.demod_address = 0x32 >> 1,
    264. 

  264. 	.output_mode   = S5H1409_PARALLEL_OUTPUT,
    265. 

  265. 	.gpio          = S5H1409_GPIO_OFF,
    266. 

  266. 	.inversion     = S5H1409_INVERSION_OFF,
    267. 

  267. 	.status_mode   = S5H1409_DEMODLOCKING,
    268. 

  268. 	.mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
    269. 

  269. };
    270. 

  270. 

  271. static struct tda18271_std_map kworld_a340_std_map = {
    272. 

  272. 	.atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 0,
    273. 

  273. 		      .if_lvl = 1, .rfagc_top = 0x37, },
    274. 

  274. 	.qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 1,
    275. 

  275. 		      .if_lvl = 1, .rfagc_top = 0x37, },
    276. 

  276. };
    277. 

  277. 

  278. static struct tda18271_config kworld_a340_config = {
    279. 

  279. 	.std_map           = &kworld_a340_std_map,
    280. 

  280. };
    281. 

  281. 

  282. static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
    283. 

  283. 	.demod_address = (0x1e >> 1),
    284. 

  284. 	.no_tuner = 1,
    285. 

  285. 	.disable_i2c_gate_ctrl = 1,
    286. 

  286. 	.parallel_ts = 1,
    287. 

  287. 	.if2 = 45600,
    288. 

  288. };
    289. 

  289. 

  290. static struct drxd_config em28xx_drxd = {
    291. 

  291. 	.index = 0, .demod_address = 0x70, .demod_revision = 0xa2,
    292. 

  292. 	.demoda_address = 0x00, .pll_address = 0x00,
    293. 

  293. 	.pll_type = DRXD_PLL_NONE, .clock = 12000, .insert_rs_byte = 1,
    294. 

  294. 	.pll_set = NULL, .osc_deviation = NULL, .IF = 42800000,
    295. 

  295. 	.disable_i2c_gate_ctrl = 1,
    296. 

  296. };
    297. 

  297. 

  298. static int mt352_terratec_xs_init(struct dvb_frontend *fe)
    299. 

  299. {
    300. 

  300. 	/* Values extracted from a USB trace of the Terratec Windows driver */
    301. 

  301. 	static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x2c };
    302. 

  302. 	static u8 reset[]          = { RESET,      0x80 };
    303. 

  303. 	static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
    304. 

  304. 	static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0xa0 };
    305. 

  305. 	static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
    306. 

  306. 	static u8 rs_err_cfg[]     = { RS_ERR_PER_1, 0x00, 0x4d };
    307. 

  307. 	static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
    308. 

  308. 	static u8 trl_nom_cfg[]    = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
    309. 

  309. 	static u8 tps_given_cfg[]  = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
    310. 

  310. 	static u8 tuner_go[]       = { TUNER_GO, 0x01};
    311. 

  311. 

  312. 	mt352_write(fe, clock_config,   sizeof(clock_config));
    313. 

  313. 	udelay(200);
    314. 

  314. 	mt352_write(fe, reset,          sizeof(reset));
    315. 

  315. 	mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
    316. 

  316. 	mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
    317. 

  317. 	mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
    318. 

  318. 	mt352_write(fe, rs_err_cfg,     sizeof(rs_err_cfg));
    319. 

  319. 	mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
    320. 

  320. 	mt352_write(fe, trl_nom_cfg,    sizeof(trl_nom_cfg));
    321. 

  321. 	mt352_write(fe, tps_given_cfg,  sizeof(tps_given_cfg));
    322. 

  322. 	mt352_write(fe, tuner_go,       sizeof(tuner_go));
    323. 

  323. 	return 0;
    324. 

  324. }
    325. 

  325. 

  326. static struct mt352_config terratec_xs_mt352_cfg = {
    327. 

  327. 	.demod_address = (0x1e >> 1),
    328. 

  328. 	.no_tuner = 1,
    329. 

  329. 	.if2 = 45600,
    330. 

  330. 	.demod_init = mt352_terratec_xs_init,
    331. 

  331. };
    332. 

  332. 

  333. static struct tda10023_config em28xx_tda10023_config = {
    334. 

  334. 	.demod_address = 0x0c,
    335. 

  335. 	.invert = 1,
    336. 

  336. };
    337. 

  337. 

  338. static struct cxd2820r_config em28xx_cxd2820r_config = {
    339. 

  339. 	.i2c_address = (0xd8 >> 1),
    340. 

  340. 	.ts_mode = CXD2820R_TS_SERIAL,
    341. 

  341. 	.if_dvbt_6  = 3300,
    342. 

  342. 	.if_dvbt_7  = 3500,
    343. 

  343. 	.if_dvbt_8  = 4000,
    344. 

  344. 	.if_dvbt2_6 = 3300,
    345. 

  345. 	.if_dvbt2_7 = 3500,
    346. 

  346. 	.if_dvbt2_8 = 4000,
    347. 

  347. 	.if_dvbc    = 5000,
    348. 

  348. 

  349. 	/* enable LNA for DVB-T2 and DVB-C */
    350. 

  350. 	.gpio_dvbt2[0] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L,
    351. 

  351. 	.gpio_dvbc[0] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L,
    352. 

  352. };
    353. 

  353. 

  354. static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
    355. 

  355. 	.output_opt = TDA18271_OUTPUT_LT_OFF,
    356. 

  356. };
    357. 

  357. 

  358. /* ------------------------------------------------------------------ */
    359. 

  359. 

  360. static int attach_xc3028(u8 addr, struct em28xx *dev)
    361. 

  361. {
    362. 

  362. 	struct dvb_frontend *fe;
    363. 

  363. 	struct xc2028_config cfg;
    364. 

  364. 

  365. 	memset(&cfg, 0, sizeof(cfg));
    366. 

  366. 	cfg.i2c_adap  = &dev->i2c_adap;
    367. 

  367. 	cfg.i2c_addr  = addr;
    368. 

  368. 

  369. 	if (!dev->dvb->fe[0]) {
    370. 

  370. 		em28xx_errdev("/2: dvb frontend not attached. "
    371. 

  371. 				"Can't attach xc3028\n");
    372. 

  372. 		return -EINVAL;
    373. 

  373. 	}
    374. 

  374. 

  375. 	fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
    376. 

  376. 	if (!fe) {
    377. 

  377. 		em28xx_errdev("/2: xc3028 attach failed\n");
    378. 

  378. 		dvb_frontend_detach(dev->dvb->fe[0]);
    379. 

  379. 		dev->dvb->fe[0] = NULL;
    380. 

  380. 		return -EINVAL;
    381. 

  381. 	}
    382. 

  382. 

  383. 	em28xx_info("%s/2: xc3028 attached\n", dev->name);
    384. 

  384. 

  385. 	return 0;
    386. 

  386. }
    387. 

  387. 

  388. /* ------------------------------------------------------------------ */
    389. 

  389. 

  390. static int register_dvb(struct em28xx_dvb *dvb,
    391. 

  391. 		 struct module *module,
    392. 

  392. 		 struct em28xx *dev,
    393. 

  393. 		 struct device *device)
    394. 

  394. {
    395. 

  395. 	int result;
    396. 

  396. 

  397. 	mutex_init(&dvb->lock);
    398. 

  398. 

  399. 	/* register adapter */
    400. 

  400. 	result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
    401. 

  401. 				      adapter_nr);
    402. 

  402. 	if (result < 0) {
    403. 

  403. 		printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
    404. 

  404. 		       dev->name, result);
    405. 

  405. 		goto fail_adapter;
    406. 

  406. 	}
    407. 

  407. 

  408. 	/* Ensure all frontends negotiate bus access */
    409. 

  409. 	dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
    410. 

  410. 	if (dvb->fe[1])
    411. 

  411. 		dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
    412. 

  412. 

  413. 	dvb->adapter.priv = dev;
    414. 

  414. 

  415. 	/* register frontend */
    416. 

  416. 	result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
    417. 

  417. 	if (result < 0) {
    418. 

  418. 		printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
    419. 

  419. 		       dev->name, result);
    420. 

  420. 		goto fail_frontend0;
    421. 

  421. 	}
    422. 

  422. 

  423. 	/* register 2nd frontend */
    424. 

  424. 	if (dvb->fe[1]) {
    425. 

  425. 		result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
    426. 

  426. 		if (result < 0) {
    427. 

  427. 			printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n",
    428. 

  428. 				dev->name, result);
    429. 

  429. 			goto fail_frontend1;
    430. 

  430. 		}
    431. 

  431. 	}
    432. 

  432. 

  433. 	/* register demux stuff */
    434. 

  434. 	dvb->demux.dmx.capabilities =
    435. 

  435. 		DMX_TS_FILTERING | DMX_SECTION_FILTERING |
    436. 

  436. 		DMX_MEMORY_BASED_FILTERING;
    437. 

  437. 	dvb->demux.priv       = dvb;
    438. 

  438. 	dvb->demux.filternum  = 256;
    439. 

  439. 	dvb->demux.feednum    = 256;
    440. 

  440. 	dvb->demux.start_feed = start_feed;
    441. 

  441. 	dvb->demux.stop_feed  = stop_feed;
    442. 

  442. 

  443. 	result = dvb_dmx_init(&dvb->demux);
    444. 

  444. 	if (result < 0) {
    445. 

  445. 		printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
    446. 

  446. 		       dev->name, result);
    447. 

  447. 		goto fail_dmx;
    448. 

  448. 	}
    449. 

  449. 

  450. 	dvb->dmxdev.filternum    = 256;
    451. 

  451. 	dvb->dmxdev.demux        = &dvb->demux.dmx;
    452. 

  452. 	dvb->dmxdev.capabilities = 0;
    453. 

  453. 	result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
    454. 

  454. 	if (result < 0) {
    455. 

  455. 		printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
    456. 

  456. 		       dev->name, result);
    457. 

  457. 		goto fail_dmxdev;
    458. 

  458. 	}
    459. 

  459. 

  460. 	dvb->fe_hw.source = DMX_FRONTEND_0;
    461. 

  461. 	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
    462. 

  462. 	if (result < 0) {
    463. 

  463. 		printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
    464. 

  464. 		       dev->name, result);
    465. 

  465. 		goto fail_fe_hw;
    466. 

  466. 	}
    467. 

  467. 

  468. 	dvb->fe_mem.source = DMX_MEMORY_FE;
    469. 

  469. 	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
    470. 

  470. 	if (result < 0) {
    471. 

  471. 		printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
    472. 

  472. 		       dev->name, result);
    473. 

  473. 		goto fail_fe_mem;
    474. 

  474. 	}
    475. 

  475. 

  476. 	result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
    477. 

  477. 	if (result < 0) {
    478. 

  478. 		printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
    479. 

  479. 		       dev->name, result);
    480. 

  480. 		goto fail_fe_conn;
    481. 

  481. 	}
    482. 

  482. 

  483. 	/* register network adapter */
    484. 

  484. 	dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
    485. 

  485. 	return 0;
    486. 

  486. 

  487. fail_fe_conn:
    488. 

  488. 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
    489. 

  489. fail_fe_mem:
    490. 

  490. 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
    491. 

  491. fail_fe_hw:
    492. 

  492. 	dvb_dmxdev_release(&dvb->dmxdev);
    493. 

  493. fail_dmxdev:
    494. 

  494. 	dvb_dmx_release(&dvb->demux);
    495. 

  495. fail_dmx:
    496. 

  496. 	if (dvb->fe[1])
    497. 

  497. 		dvb_unregister_frontend(dvb->fe[1]);
    498. 

  498. 	dvb_unregister_frontend(dvb->fe[0]);
    499. 

  499. fail_frontend1:
    500. 

  500. 	if (dvb->fe[1])
    501. 

  501. 		dvb_frontend_detach(dvb->fe[1]);
    502. 

  502. fail_frontend0:
    503. 

  503. 	dvb_frontend_detach(dvb->fe[0]);
    504. 

  504. 	dvb_unregister_adapter(&dvb->adapter);
    505. 

  505. fail_adapter:
    506. 

  506. 	return result;
    507. 

  507. }
    508. 

  508. 

  509. static void unregister_dvb(struct em28xx_dvb *dvb)
    510. 

  510. {
    511. 

  511. 	dvb_net_release(&dvb->net);
    512. 

  512. 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
    513. 

  513. 	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
    514. 

  514. 	dvb_dmxdev_release(&dvb->dmxdev);
    515. 

  515. 	dvb_dmx_release(&dvb->demux);
    516. 

  516. 	if (dvb->fe[1])
    517. 

  517. 		dvb_unregister_frontend(dvb->fe[1]);
    518. 

  518. 	dvb_unregister_frontend(dvb->fe[0]);
    519. 

  519. 	if (dvb->fe[1])
    520. 

  520. 		dvb_frontend_detach(dvb->fe[1]);
    521. 

  521. 	dvb_frontend_detach(dvb->fe[0]);
    522. 

  522. 	dvb_unregister_adapter(&dvb->adapter);
    523. 

  523. }
    524. 

  524. 

  525. static int dvb_init(struct em28xx *dev)
    526. 

  526. {
    527. 

  527. 	int result = 0;
    528. 

  528. 	struct em28xx_dvb *dvb;
    529. 

  529. 

  530. 	if (!dev->board.has_dvb) {
    531. 

  531. 		/* This device does not support the extension */
    532. 

  532. 		printk(KERN_INFO "em28xx_dvb: This device does not support the extension\n");
    533. 

  533. 		return 0;
    534. 

  534. 	}
    535. 

  535. 

  536. 	dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
    537. 

  537. 

  538. 	if (dvb == NULL) {
    539. 

  539. 		em28xx_info("em28xx_dvb: memory allocation failed\n");
    540. 

  540. 		return -ENOMEM;
    541. 

  541. 	}
    542. 

  542. 	dev->dvb = dvb;
    543. 

  543. 	dvb->fe[0] = dvb->fe[1] = NULL;
    544. 

  544. 

  545. 	mutex_lock(&dev->lock);
    546. 

  546. 	em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
    547. 

  547. 	/* init frontend */
    548. 

  548. 	switch (dev->model) {
    549. 

  549. 	case EM2874_LEADERSHIP_ISDBT:
    550. 

  550. 		dvb->fe[0] = dvb_attach(s921_attach,
    551. 

  551. 				&sharp_isdbt, &dev->i2c_adap);
    552. 

  552. 

  553. 		if (!dvb->fe[0]) {
    554. 

  554. 			result = -EINVAL;
    555. 

  555. 			goto out_free;
    556. 

  556. 		}
    557. 

  557. 

  558. 		break;
    559. 

  559. 	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
    560. 

  560. 	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
    561. 

  561. 	case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
    562. 

  562. 	case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
    563. 

  563. 		dvb->fe[0] = dvb_attach(lgdt330x_attach,
    564. 

  564. 					   &em2880_lgdt3303_dev,
    565. 

  565. 					   &dev->i2c_adap);
    566. 

  566. 		if (attach_xc3028(0x61, dev) < 0) {
    567. 

  567. 			result = -EINVAL;
    568. 

  568. 			goto out_free;
    569. 

  569. 		}
    570. 

  570. 		break;
    571. 

  571. 	case EM2880_BOARD_KWORLD_DVB_310U:
    572. 

  572. 		dvb->fe[0] = dvb_attach(zl10353_attach,
    573. 

  573. 					   &em28xx_zl10353_with_xc3028,
    574. 

  574. 					   &dev->i2c_adap);
    575. 

  575. 		if (attach_xc3028(0x61, dev) < 0) {
    576. 

  576. 			result = -EINVAL;
    577. 

  577. 			goto out_free;
    578. 

  578. 		}
    579. 

  579. 		break;
    580. 

  580. 	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
    581. 

  581. 	case EM2882_BOARD_TERRATEC_HYBRID_XS:
    582. 

  582. 	case EM2880_BOARD_EMPIRE_DUAL_TV:
    583. 

  583. 		dvb->fe[0] = dvb_attach(zl10353_attach,
    584. 

  584. 					   &em28xx_zl10353_xc3028_no_i2c_gate,
    585. 

  585. 					   &dev->i2c_adap);
    586. 

  586. 		if (attach_xc3028(0x61, dev) < 0) {
    587. 

  587. 			result = -EINVAL;
    588. 

  588. 			goto out_free;
    589. 

  589. 		}
    590. 

  590. 		break;
    591. 

  591. 	case EM2880_BOARD_TERRATEC_HYBRID_XS:
    592. 

  592. 	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
    593. 

  593. 	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
    594. 

  594. 	case EM2882_BOARD_DIKOM_DK300:
    595. 

  595. 	case EM2882_BOARD_KWORLD_VS_DVBT:
    596. 

  596. 		dvb->fe[0] = dvb_attach(zl10353_attach,
    597. 

  597. 					   &em28xx_zl10353_xc3028_no_i2c_gate,
    598. 

  598. 					   &dev->i2c_adap);
    599. 

  599. 		if (dvb->fe[0] == NULL) {
    600. 

  600. 			/* This board could have either a zl10353 or a mt352.
    601. 

  601. 			   If the chip id isn't for zl10353, try mt352 */
    602. 

  602. 			dvb->fe[0] = dvb_attach(mt352_attach,
    603. 

  603. 						   &terratec_xs_mt352_cfg,
    604. 

  604. 						   &dev->i2c_adap);
    605. 

  605. 		}
    606. 

  606. 

  607. 		if (attach_xc3028(0x61, dev) < 0) {
    608. 

  608. 			result = -EINVAL;
    609. 

  609. 			goto out_free;
    610. 

  610. 		}
    611. 

  611. 		break;
    612. 

  612. 	case EM2883_BOARD_KWORLD_HYBRID_330U:
    613. 

  613. 	case EM2882_BOARD_EVGA_INDTUBE:
    614. 

  614. 		dvb->fe[0] = dvb_attach(s5h1409_attach,
    615. 

  615. 					   &em28xx_s5h1409_with_xc3028,
    616. 

  616. 					   &dev->i2c_adap);
    617. 

  617. 		if (attach_xc3028(0x61, dev) < 0) {
    618. 

  618. 			result = -EINVAL;
    619. 

  619. 			goto out_free;
    620. 

  620. 		}
    621. 

  621. 		break;
    622. 

  622. 	case EM2882_BOARD_KWORLD_ATSC_315U:
    623. 

  623. 		dvb->fe[0] = dvb_attach(lgdt330x_attach,
    624. 

  624. 					   &em2880_lgdt3303_dev,
    625. 

  625. 					   &dev->i2c_adap);
    626. 

  626. 		if (dvb->fe[0] != NULL) {
    627. 

  627. 			if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
    628. 

  628. 				&dev->i2c_adap, 0x61, TUNER_THOMSON_DTT761X)) {
    629. 

  629. 				result = -EINVAL;
    630. 

  630. 				goto out_free;
    631. 

  631. 			}
    632. 

  632. 		}
    633. 

  633. 		break;
    634. 

  634. 	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
    635. 

  635. 	case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
    636. 

  636. 		dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
    637. 

  637. 					   &dev->i2c_adap, &dev->udev->dev);
    638. 

  638. 		if (attach_xc3028(0x61, dev) < 0) {
    639. 

  639. 			result = -EINVAL;
    640. 

  640. 			goto out_free;
    641. 

  641. 		}
    642. 

  642. 		break;
    643. 

  643. 	case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
    644. 

  644. 		/* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
    645. 

  645. 		dvb->fe[0] = dvb_attach(tda10023_attach,
    646. 

  646. 			&em28xx_tda10023_config,
    647. 

  647. 			&dev->i2c_adap, 0x48);
    648. 

  648. 		if (dvb->fe[0]) {
    649. 

  649. 			if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
    650. 

  650. 				&dev->i2c_adap, 0x60, TUNER_PHILIPS_CU1216L)) {
    651. 

  651. 				result = -EINVAL;
    652. 

  652. 				goto out_free;
    653. 

  653. 			}
    654. 

  654. 		}
    655. 

  655. 		break;
    656. 

  656. 	case EM2870_BOARD_KWORLD_A340:
    657. 

  657. 		dvb->fe[0] = dvb_attach(lgdt3305_attach,
    658. 

  658. 					   &em2870_lgdt3304_dev,
    659. 

  659. 					   &dev->i2c_adap);
    660. 

  660. 		if (dvb->fe[0] != NULL)
    661. 

  661. 			dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
    662. 

  662. 				   &dev->i2c_adap, &kworld_a340_config);
    663. 

  663. 		break;
    664. 

  664. 	case EM28174_BOARD_PCTV_290E:
    665. 

  665. 		/* MFE
    666. 

  666. 		 * FE 0 = DVB-T/T2 + FE 1 = DVB-C, both sharing same tuner. */
    667. 

  667. 		/* FE 0 */
    668. 

  668. 		dvb->fe[0] = dvb_attach(cxd2820r_attach,
    669. 

  669. 			&em28xx_cxd2820r_config, &dev->i2c_adap, NULL);
    670. 

  670. 		if (dvb->fe[0]) {
    671. 

  671. 			struct i2c_adapter *i2c_tuner;
    672. 

  672. 			i2c_tuner = cxd2820r_get_tuner_i2c_adapter(dvb->fe[0]);
    673. 

  673. 			/* FE 0 attach tuner */
    674. 

  674. 			if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
    675. 

  675. 				i2c_tuner, &em28xx_cxd2820r_tda18271_config)) {
    676. 

  676. 				dvb_frontend_detach(dvb->fe[0]);
    677. 

  677. 				result = -EINVAL;
    678. 

  678. 				goto out_free;
    679. 

  679. 			}
    680. 

  680. 			/* FE 1. This dvb_attach() cannot fail. */
    681. 

  681. 			dvb->fe[1] = dvb_attach(cxd2820r_attach, NULL, NULL,
    682. 

  682. 				dvb->fe[0]);
    683. 

  683. 			dvb->fe[1]->id = 1;
    684. 

  684. 			/* FE 1 attach tuner */
    685. 

  685. 			if (!dvb_attach(tda18271_attach, dvb->fe[1], 0x60,
    686. 

  686. 				i2c_tuner, &em28xx_cxd2820r_tda18271_config)) {
    687. 

  687. 				dvb_frontend_detach(dvb->fe[1]);
    688. 

  688. 				/* leave FE 0 still active */
    689. 

  689. 			}
    690. 

  690. 		}
    691. 

  691. 		break;
    692. 

  692. 	default:
    693. 

  693. 		em28xx_errdev("/2: The frontend of your DVB/ATSC card"
    694. 

  694. 				" isn't supported yet\n");
    695. 

  695. 		break;
    696. 

  696. 	}
    697. 

  697. 	if (NULL == dvb->fe[0]) {
    698. 

  698. 		em28xx_errdev("/2: frontend initialization failed\n");
    699. 

  699. 		result = -EINVAL;
    700. 

  700. 		goto out_free;
    701. 

  701. 	}
    702. 

  702. 	/* define general-purpose callback pointer */
    703. 

  703. 	dvb->fe[0]->callback = em28xx_tuner_callback;
    704. 

  704. 

  705. 	/* register everything */
    706. 

  706. 	result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
    707. 

  707. 

  708. 	if (result < 0)
    709. 

  709. 		goto out_free;
    710. 

  710. 

  711. 	em28xx_info("Successfully loaded em28xx-dvb\n");
    712. 

  712. ret:
    713. 

  713. 	em28xx_set_mode(dev, EM28XX_SUSPEND);
    714. 

  714. 	mutex_unlock(&dev->lock);
    715. 

  715. 	return result;
    716. 

  716. 

  717. out_free:
    718. 

  718. 	kfree(dvb);
    719. 

  719. 	dev->dvb = NULL;
    720. 

  720. 	goto ret;
    721. 

  721. }
    722. 

  722. 

  723. static int dvb_fini(struct em28xx *dev)
    724. 

  724. {
    725. 

  725. 	if (!dev->board.has_dvb) {
    726. 

  726. 		/* This device does not support the extension */
    727. 

  727. 		return 0;
    728. 

  728. 	}
    729. 

  729. 

  730. 	if (dev->dvb) {
    731. 

  731. 		unregister_dvb(dev->dvb);
    732. 

  732. 		kfree(dev->dvb);
    733. 

  733. 		dev->dvb = NULL;
    734. 

  734. 	}
    735. 

  735. 

  736. 	return 0;
    737. 

  737. }
    738. 

  738. 

  739. static struct em28xx_ops dvb_ops = {
    740. 

  740. 	.id   = EM28XX_DVB,
    741. 

  741. 	.name = "Em28xx dvb Extension",
    742. 

  742. 	.init = dvb_init,
    743. 

  743. 	.fini = dvb_fini,
    744. 

  744. };
    745. 

  745. 

  746. static int __init em28xx_dvb_register(void)
    747. 

  747. {
    748. 

  748. 	return em28xx_register_extension(&dvb_ops);
    749. 

  749. }
    750. 

  750. 

  751. static void __exit em28xx_dvb_unregister(void)
    752. 

  752. {
    753. 

  753. 	em28xx_unregister_extension(&dvb_ops);
    754. 

  754. }
    755. 

  755. 

  756. module_init(em28xx_dvb_register);
    757. 

  757. module_exit(em28xx_dvb_unregister);
    758.