m920x.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264
  1. /* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
  2. *
  3. * Copyright (C) 2006 Aapo Tahkola (aet@rasterburn.org)
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms of the GNU General Public License as published by the
  7. * Free Software Foundation, version 2.
  8. *
  9. * see Documentation/media/dvb-drivers/dvb-usb.rst for more information
  10. */
  11. #include "m920x.h"
  12. #include "mt352.h"
  13. #include "mt352_priv.h"
  14. #include "qt1010.h"
  15. #include "tda1004x.h"
  16. #include "tda827x.h"
  17. #include "mt2060.h"
  18. #include <media/tuner.h>
  19. #include "tuner-simple.h"
  20. #include <asm/unaligned.h>
  21. /* debug */
  22. static int dvb_usb_m920x_debug;
  23. module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
  24. MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
  25. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  26. static int m920x_set_filter(struct dvb_usb_device *d, int type, int idx, int pid);
  27. static inline int m920x_read(struct usb_device *udev, u8 request, u16 value,
  28. u16 index, void *data, int size)
  29. {
  30. int ret;
  31. ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
  32. request, USB_TYPE_VENDOR | USB_DIR_IN,
  33. value, index, data, size, 2000);
  34. if (ret < 0) {
  35. printk(KERN_INFO "m920x_read = error: %d\n", ret);
  36. return ret;
  37. }
  38. if (ret != size) {
  39. deb("m920x_read = no data\n");
  40. return -EIO;
  41. }
  42. return 0;
  43. }
  44. static inline int m920x_write(struct usb_device *udev, u8 request,
  45. u16 value, u16 index)
  46. {
  47. return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), request,
  48. USB_TYPE_VENDOR | USB_DIR_OUT, value, index,
  49. NULL, 0, 2000);
  50. }
  51. static inline int m920x_write_seq(struct usb_device *udev, u8 request,
  52. struct m920x_inits *seq)
  53. {
  54. int ret;
  55. do {
  56. ret = m920x_write(udev, request, seq->data, seq->address);
  57. if (ret != 0)
  58. return ret;
  59. seq++;
  60. } while (seq->address);
  61. return 0;
  62. }
  63. static int m920x_init(struct dvb_usb_device *d, struct m920x_inits *rc_seq)
  64. {
  65. int ret, i, epi, flags = 0;
  66. int adap_enabled[M9206_MAX_ADAPTERS] = { 0 };
  67. /* Remote controller init. */
  68. if (d->props.rc.legacy.rc_query || d->props.rc.core.rc_query) {
  69. deb("Initialising remote control\n");
  70. ret = m920x_write_seq(d->udev, M9206_CORE, rc_seq);
  71. if (ret != 0) {
  72. deb("Initialising remote control failed\n");
  73. return ret;
  74. }
  75. deb("Initialising remote control success\n");
  76. }
  77. for (i = 0; i < d->props.num_adapters; i++)
  78. flags |= d->adapter[i].props.fe[0].caps;
  79. /* Some devices(Dposh) might crash if we attempt touch at all. */
  80. if (flags & DVB_USB_ADAP_HAS_PID_FILTER) {
  81. for (i = 0; i < d->props.num_adapters; i++) {
  82. epi = d->adapter[i].props.fe[0].stream.endpoint - 0x81;
  83. if (epi < 0 || epi >= M9206_MAX_ADAPTERS) {
  84. printk(KERN_INFO "m920x: Unexpected adapter endpoint!\n");
  85. return -EINVAL;
  86. }
  87. adap_enabled[epi] = 1;
  88. }
  89. for (i = 0; i < M9206_MAX_ADAPTERS; i++) {
  90. if (adap_enabled[i])
  91. continue;
  92. if ((ret = m920x_set_filter(d, 0x81 + i, 0, 0x0)) != 0)
  93. return ret;
  94. if ((ret = m920x_set_filter(d, 0x81 + i, 0, 0x02f5)) != 0)
  95. return ret;
  96. }
  97. }
  98. return 0;
  99. }
  100. static int m920x_init_ep(struct usb_interface *intf)
  101. {
  102. struct usb_device *udev = interface_to_usbdev(intf);
  103. struct usb_host_interface *alt;
  104. if ((alt = usb_altnum_to_altsetting(intf, 1)) == NULL) {
  105. deb("No alt found!\n");
  106. return -ENODEV;
  107. }
  108. return usb_set_interface(udev, alt->desc.bInterfaceNumber,
  109. alt->desc.bAlternateSetting);
  110. }
  111. static inline void m920x_parse_rc_state(struct dvb_usb_device *d, u8 rc_state,
  112. int *state)
  113. {
  114. struct m920x_state *m = d->priv;
  115. switch (rc_state) {
  116. case 0x80:
  117. *state = REMOTE_NO_KEY_PRESSED;
  118. break;
  119. case 0x88: /* framing error or "invalid code" */
  120. case 0x99:
  121. case 0xc0:
  122. case 0xd8:
  123. *state = REMOTE_NO_KEY_PRESSED;
  124. m->rep_count = 0;
  125. break;
  126. case 0x93:
  127. case 0x92:
  128. case 0x83: /* pinnacle PCTV310e */
  129. case 0x82:
  130. m->rep_count = 0;
  131. *state = REMOTE_KEY_PRESSED;
  132. break;
  133. case 0x91:
  134. case 0x81: /* pinnacle PCTV310e */
  135. /* prevent immediate auto-repeat */
  136. if (++m->rep_count > 2)
  137. *state = REMOTE_KEY_REPEAT;
  138. else
  139. *state = REMOTE_NO_KEY_PRESSED;
  140. break;
  141. default:
  142. deb("Unexpected rc state %02x\n", rc_state);
  143. *state = REMOTE_NO_KEY_PRESSED;
  144. break;
  145. }
  146. }
  147. static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
  148. {
  149. int i, ret = 0;
  150. u8 *rc_state;
  151. rc_state = kmalloc(2, GFP_KERNEL);
  152. if (!rc_state)
  153. return -ENOMEM;
  154. ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE,
  155. rc_state, 1);
  156. if (ret != 0)
  157. goto out;
  158. ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY,
  159. rc_state + 1, 1);
  160. if (ret != 0)
  161. goto out;
  162. m920x_parse_rc_state(d, rc_state[0], state);
  163. for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
  164. if (rc5_data(&d->props.rc.legacy.rc_map_table[i]) == rc_state[1]) {
  165. *event = d->props.rc.legacy.rc_map_table[i].keycode;
  166. goto out;
  167. }
  168. if (rc_state[1] != 0)
  169. deb("Unknown rc key %02x\n", rc_state[1]);
  170. *state = REMOTE_NO_KEY_PRESSED;
  171. out:
  172. kfree(rc_state);
  173. return ret;
  174. }
  175. static int m920x_rc_core_query(struct dvb_usb_device *d)
  176. {
  177. int ret = 0;
  178. u8 *rc_state;
  179. int state;
  180. rc_state = kmalloc(2, GFP_KERNEL);
  181. if (!rc_state)
  182. return -ENOMEM;
  183. if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, &rc_state[0], 1)) != 0)
  184. goto out;
  185. if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, &rc_state[1], 1)) != 0)
  186. goto out;
  187. deb("state=0x%02x keycode=0x%02x\n", rc_state[0], rc_state[1]);
  188. m920x_parse_rc_state(d, rc_state[0], &state);
  189. if (state == REMOTE_NO_KEY_PRESSED)
  190. rc_keyup(d->rc_dev);
  191. else if (state == REMOTE_KEY_REPEAT)
  192. rc_repeat(d->rc_dev);
  193. else
  194. rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, rc_state[1], 0);
  195. out:
  196. kfree(rc_state);
  197. return ret;
  198. }
  199. /* I2C */
  200. static int m920x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
  201. {
  202. struct dvb_usb_device *d = i2c_get_adapdata(adap);
  203. int i, j;
  204. int ret = 0;
  205. if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
  206. return -EAGAIN;
  207. for (i = 0; i < num; i++) {
  208. if (msg[i].flags & (I2C_M_NO_RD_ACK | I2C_M_IGNORE_NAK | I2C_M_TEN) || msg[i].len == 0) {
  209. /* For a 0 byte message, I think sending the address
  210. * to index 0x80|0x40 would be the correct thing to
  211. * do. However, zero byte messages are only used for
  212. * probing, and since we don't know how to get the
  213. * slave's ack, we can't probe. */
  214. ret = -ENOTSUPP;
  215. goto unlock;
  216. }
  217. /* Send START & address/RW bit */
  218. if (!(msg[i].flags & I2C_M_NOSTART)) {
  219. if ((ret = m920x_write(d->udev, M9206_I2C,
  220. (msg[i].addr << 1) |
  221. (msg[i].flags & I2C_M_RD ? 0x01 : 0), 0x80)) != 0)
  222. goto unlock;
  223. /* Should check for ack here, if we knew how. */
  224. }
  225. if (msg[i].flags & I2C_M_RD) {
  226. for (j = 0; j < msg[i].len; j++) {
  227. /* Last byte of transaction?
  228. * Send STOP, otherwise send ACK. */
  229. int stop = (i+1 == num && j+1 == msg[i].len) ? 0x40 : 0x01;
  230. if ((ret = m920x_read(d->udev, M9206_I2C, 0x0,
  231. 0x20 | stop,
  232. &msg[i].buf[j], 1)) != 0)
  233. goto unlock;
  234. }
  235. } else {
  236. for (j = 0; j < msg[i].len; j++) {
  237. /* Last byte of transaction? Then send STOP. */
  238. int stop = (i+1 == num && j+1 == msg[i].len) ? 0x40 : 0x00;
  239. if ((ret = m920x_write(d->udev, M9206_I2C, msg[i].buf[j], stop)) != 0)
  240. goto unlock;
  241. /* Should check for ack here too. */
  242. }
  243. }
  244. }
  245. ret = num;
  246. unlock:
  247. mutex_unlock(&d->i2c_mutex);
  248. return ret;
  249. }
  250. static u32 m920x_i2c_func(struct i2c_adapter *adapter)
  251. {
  252. return I2C_FUNC_I2C;
  253. }
  254. static struct i2c_algorithm m920x_i2c_algo = {
  255. .master_xfer = m920x_i2c_xfer,
  256. .functionality = m920x_i2c_func,
  257. };
  258. /* pid filter */
  259. static int m920x_set_filter(struct dvb_usb_device *d, int type, int idx, int pid)
  260. {
  261. int ret = 0;
  262. if (pid >= 0x8000)
  263. return -EINVAL;
  264. pid |= 0x8000;
  265. if ((ret = m920x_write(d->udev, M9206_FILTER, pid, (type << 8) | (idx * 4) )) != 0)
  266. return ret;
  267. if ((ret = m920x_write(d->udev, M9206_FILTER, 0, (type << 8) | (idx * 4) )) != 0)
  268. return ret;
  269. return ret;
  270. }
  271. static int m920x_update_filters(struct dvb_usb_adapter *adap)
  272. {
  273. struct m920x_state *m = adap->dev->priv;
  274. int enabled = m->filtering_enabled[adap->id];
  275. int i, ret = 0, filter = 0;
  276. int ep = adap->props.fe[0].stream.endpoint;
  277. for (i = 0; i < M9206_MAX_FILTERS; i++)
  278. if (m->filters[adap->id][i] == 8192)
  279. enabled = 0;
  280. /* Disable all filters */
  281. if ((ret = m920x_set_filter(adap->dev, ep, 1, enabled)) != 0)
  282. return ret;
  283. for (i = 0; i < M9206_MAX_FILTERS; i++)
  284. if ((ret = m920x_set_filter(adap->dev, ep, i + 2, 0)) != 0)
  285. return ret;
  286. /* Set */
  287. if (enabled) {
  288. for (i = 0; i < M9206_MAX_FILTERS; i++) {
  289. if (m->filters[adap->id][i] == 0)
  290. continue;
  291. if ((ret = m920x_set_filter(adap->dev, ep, filter + 2, m->filters[adap->id][i])) != 0)
  292. return ret;
  293. filter++;
  294. }
  295. }
  296. return ret;
  297. }
  298. static int m920x_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
  299. {
  300. struct m920x_state *m = adap->dev->priv;
  301. m->filtering_enabled[adap->id] = onoff ? 1 : 0;
  302. return m920x_update_filters(adap);
  303. }
  304. static int m920x_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
  305. {
  306. struct m920x_state *m = adap->dev->priv;
  307. m->filters[adap->id][index] = onoff ? pid : 0;
  308. return m920x_update_filters(adap);
  309. }
  310. static int m920x_firmware_download(struct usb_device *udev, const struct firmware *fw)
  311. {
  312. u16 value, index, size;
  313. u8 *read, *buff;
  314. int i, pass, ret = 0;
  315. buff = kmalloc(65536, GFP_KERNEL);
  316. if (buff == NULL)
  317. return -ENOMEM;
  318. read = kmalloc(4, GFP_KERNEL);
  319. if (!read) {
  320. kfree(buff);
  321. return -ENOMEM;
  322. }
  323. if ((ret = m920x_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
  324. goto done;
  325. deb("%*ph\n", 4, read);
  326. if ((ret = m920x_read(udev, M9206_FW, 0x0, 0x0, read, 1)) != 0)
  327. goto done;
  328. deb("%x\n", read[0]);
  329. for (pass = 0; pass < 2; pass++) {
  330. for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
  331. value = get_unaligned_le16(fw->data + i);
  332. i += sizeof(u16);
  333. index = get_unaligned_le16(fw->data + i);
  334. i += sizeof(u16);
  335. size = get_unaligned_le16(fw->data + i);
  336. i += sizeof(u16);
  337. if (pass == 1) {
  338. /* Will stall if using fw->data ... */
  339. memcpy(buff, fw->data + i, size);
  340. ret = usb_control_msg(udev, usb_sndctrlpipe(udev,0),
  341. M9206_FW,
  342. USB_TYPE_VENDOR | USB_DIR_OUT,
  343. value, index, buff, size, 20);
  344. if (ret != size) {
  345. deb("error while uploading fw!\n");
  346. ret = -EIO;
  347. goto done;
  348. }
  349. msleep(3);
  350. }
  351. i += size;
  352. }
  353. if (i != fw->size) {
  354. deb("bad firmware file!\n");
  355. ret = -EINVAL;
  356. goto done;
  357. }
  358. }
  359. msleep(36);
  360. /* m920x will disconnect itself from the bus after this. */
  361. (void) m920x_write(udev, M9206_CORE, 0x01, M9206_FW_GO);
  362. deb("firmware uploaded!\n");
  363. done:
  364. kfree(read);
  365. kfree(buff);
  366. return ret;
  367. }
  368. /* Callbacks for DVB USB */
  369. static int m920x_identify_state(struct usb_device *udev,
  370. struct dvb_usb_device_properties *props,
  371. struct dvb_usb_device_description **desc,
  372. int *cold)
  373. {
  374. struct usb_host_interface *alt;
  375. alt = usb_altnum_to_altsetting(usb_ifnum_to_if(udev, 0), 1);
  376. *cold = (alt == NULL) ? 1 : 0;
  377. return 0;
  378. }
  379. /* demod configurations */
  380. static int m920x_mt352_demod_init(struct dvb_frontend *fe)
  381. {
  382. int ret;
  383. u8 config[] = { CONFIG, 0x3d };
  384. u8 clock[] = { CLOCK_CTL, 0x30 };
  385. u8 reset[] = { RESET, 0x80 };
  386. u8 adc_ctl[] = { ADC_CTL_1, 0x40 };
  387. u8 agc[] = { AGC_TARGET, 0x1c, 0x20 };
  388. u8 sec_agc[] = { 0x69, 0x00, 0xff, 0xff, 0x40, 0xff, 0x00, 0x40, 0x40 };
  389. u8 unk1[] = { 0x93, 0x1a };
  390. u8 unk2[] = { 0xb5, 0x7a };
  391. deb("Demod init!\n");
  392. if ((ret = mt352_write(fe, config, ARRAY_SIZE(config))) != 0)
  393. return ret;
  394. if ((ret = mt352_write(fe, clock, ARRAY_SIZE(clock))) != 0)
  395. return ret;
  396. if ((ret = mt352_write(fe, reset, ARRAY_SIZE(reset))) != 0)
  397. return ret;
  398. if ((ret = mt352_write(fe, adc_ctl, ARRAY_SIZE(adc_ctl))) != 0)
  399. return ret;
  400. if ((ret = mt352_write(fe, agc, ARRAY_SIZE(agc))) != 0)
  401. return ret;
  402. if ((ret = mt352_write(fe, sec_agc, ARRAY_SIZE(sec_agc))) != 0)
  403. return ret;
  404. if ((ret = mt352_write(fe, unk1, ARRAY_SIZE(unk1))) != 0)
  405. return ret;
  406. if ((ret = mt352_write(fe, unk2, ARRAY_SIZE(unk2))) != 0)
  407. return ret;
  408. return 0;
  409. }
  410. static struct mt352_config m920x_mt352_config = {
  411. .demod_address = 0x0f,
  412. .no_tuner = 1,
  413. .demod_init = m920x_mt352_demod_init,
  414. };
  415. static struct tda1004x_config m920x_tda10046_08_config = {
  416. .demod_address = 0x08,
  417. .invert = 0,
  418. .invert_oclk = 0,
  419. .ts_mode = TDA10046_TS_SERIAL,
  420. .xtal_freq = TDA10046_XTAL_16M,
  421. .if_freq = TDA10046_FREQ_045,
  422. .agc_config = TDA10046_AGC_TDA827X,
  423. .gpio_config = TDA10046_GPTRI,
  424. .request_firmware = NULL,
  425. };
  426. static struct tda1004x_config m920x_tda10046_0b_config = {
  427. .demod_address = 0x0b,
  428. .invert = 0,
  429. .invert_oclk = 0,
  430. .ts_mode = TDA10046_TS_SERIAL,
  431. .xtal_freq = TDA10046_XTAL_16M,
  432. .if_freq = TDA10046_FREQ_045,
  433. .agc_config = TDA10046_AGC_TDA827X,
  434. .gpio_config = TDA10046_GPTRI,
  435. .request_firmware = NULL, /* uses firmware EEPROM */
  436. };
  437. /* tuner configurations */
  438. static struct qt1010_config m920x_qt1010_config = {
  439. .i2c_address = 0x62
  440. };
  441. static struct mt2060_config m920x_mt2060_config = {
  442. .i2c_address = 0x60, /* 0xc0 */
  443. .clock_out = 0,
  444. };
  445. /* Callbacks for DVB USB */
  446. static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
  447. {
  448. deb("%s\n",__func__);
  449. adap->fe_adap[0].fe = dvb_attach(mt352_attach,
  450. &m920x_mt352_config,
  451. &adap->dev->i2c_adap);
  452. if ((adap->fe_adap[0].fe) == NULL)
  453. return -EIO;
  454. return 0;
  455. }
  456. static int m920x_mt352_frontend_attach_vp7049(struct dvb_usb_adapter *adap)
  457. {
  458. struct m920x_inits vp7049_fe_init_seq[] = {
  459. /* XXX without these commands the frontend cannot be detected,
  460. * they must be sent BEFORE the frontend is attached */
  461. { 0xff28, 0x00 },
  462. { 0xff23, 0x00 },
  463. { 0xff28, 0x00 },
  464. { 0xff23, 0x00 },
  465. { 0xff21, 0x20 },
  466. { 0xff21, 0x60 },
  467. { 0xff28, 0x00 },
  468. { 0xff22, 0x00 },
  469. { 0xff20, 0x30 },
  470. { 0xff20, 0x20 },
  471. { 0xff20, 0x30 },
  472. { } /* terminating entry */
  473. };
  474. int ret;
  475. deb("%s\n", __func__);
  476. ret = m920x_write_seq(adap->dev->udev, M9206_CORE, vp7049_fe_init_seq);
  477. if (ret != 0) {
  478. deb("Initialization of vp7049 frontend failed.");
  479. return ret;
  480. }
  481. return m920x_mt352_frontend_attach(adap);
  482. }
  483. static int m920x_tda10046_08_frontend_attach(struct dvb_usb_adapter *adap)
  484. {
  485. deb("%s\n",__func__);
  486. adap->fe_adap[0].fe = dvb_attach(tda10046_attach,
  487. &m920x_tda10046_08_config,
  488. &adap->dev->i2c_adap);
  489. if ((adap->fe_adap[0].fe) == NULL)
  490. return -EIO;
  491. return 0;
  492. }
  493. static int m920x_tda10046_0b_frontend_attach(struct dvb_usb_adapter *adap)
  494. {
  495. deb("%s\n",__func__);
  496. adap->fe_adap[0].fe = dvb_attach(tda10046_attach,
  497. &m920x_tda10046_0b_config,
  498. &adap->dev->i2c_adap);
  499. if ((adap->fe_adap[0].fe) == NULL)
  500. return -EIO;
  501. return 0;
  502. }
  503. static int m920x_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
  504. {
  505. deb("%s\n",__func__);
  506. if (dvb_attach(qt1010_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap, &m920x_qt1010_config) == NULL)
  507. return -ENODEV;
  508. return 0;
  509. }
  510. static int m920x_tda8275_60_tuner_attach(struct dvb_usb_adapter *adap)
  511. {
  512. deb("%s\n",__func__);
  513. if (dvb_attach(tda827x_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap, NULL) == NULL)
  514. return -ENODEV;
  515. return 0;
  516. }
  517. static int m920x_tda8275_61_tuner_attach(struct dvb_usb_adapter *adap)
  518. {
  519. deb("%s\n",__func__);
  520. if (dvb_attach(tda827x_attach, adap->fe_adap[0].fe, 0x61, &adap->dev->i2c_adap, NULL) == NULL)
  521. return -ENODEV;
  522. return 0;
  523. }
  524. static int m920x_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
  525. {
  526. dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
  527. &adap->dev->i2c_adap, 0x61,
  528. TUNER_PHILIPS_FMD1216ME_MK3);
  529. return 0;
  530. }
  531. static int m920x_mt2060_tuner_attach(struct dvb_usb_adapter *adap)
  532. {
  533. deb("%s\n", __func__);
  534. if (dvb_attach(mt2060_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
  535. &m920x_mt2060_config, 1220) == NULL)
  536. return -ENODEV;
  537. return 0;
  538. }
  539. /* device-specific initialization */
  540. static struct m920x_inits megasky_rc_init [] = {
  541. { M9206_RC_INIT2, 0xa8 },
  542. { M9206_RC_INIT1, 0x51 },
  543. { } /* terminating entry */
  544. };
  545. static struct m920x_inits tvwalkertwin_rc_init [] = {
  546. { M9206_RC_INIT2, 0x00 },
  547. { M9206_RC_INIT1, 0xef },
  548. { 0xff28, 0x00 },
  549. { 0xff23, 0x00 },
  550. { 0xff21, 0x30 },
  551. { } /* terminating entry */
  552. };
  553. static struct m920x_inits pinnacle310e_init[] = {
  554. /* without these the tuner doesn't work */
  555. { 0xff20, 0x9b },
  556. { 0xff22, 0x70 },
  557. /* rc settings */
  558. { 0xff50, 0x80 },
  559. { M9206_RC_INIT1, 0x00 },
  560. { M9206_RC_INIT2, 0xff },
  561. { } /* terminating entry */
  562. };
  563. static struct m920x_inits vp7049_rc_init[] = {
  564. { 0xff28, 0x00 },
  565. { 0xff23, 0x00 },
  566. { 0xff21, 0x70 },
  567. { M9206_RC_INIT2, 0x00 },
  568. { M9206_RC_INIT1, 0xff },
  569. { } /* terminating entry */
  570. };
  571. /* ir keymaps */
  572. static struct rc_map_table rc_map_megasky_table[] = {
  573. { 0x0012, KEY_POWER },
  574. { 0x001e, KEY_CYCLEWINDOWS }, /* min/max */
  575. { 0x0002, KEY_CHANNELUP },
  576. { 0x0005, KEY_CHANNELDOWN },
  577. { 0x0003, KEY_VOLUMEUP },
  578. { 0x0006, KEY_VOLUMEDOWN },
  579. { 0x0004, KEY_MUTE },
  580. { 0x0007, KEY_OK }, /* TS */
  581. { 0x0008, KEY_STOP },
  582. { 0x0009, KEY_MENU }, /* swap */
  583. { 0x000a, KEY_REWIND },
  584. { 0x001b, KEY_PAUSE },
  585. { 0x001f, KEY_FASTFORWARD },
  586. { 0x000c, KEY_RECORD },
  587. { 0x000d, KEY_CAMERA }, /* screenshot */
  588. { 0x000e, KEY_COFFEE }, /* "MTS" */
  589. };
  590. static struct rc_map_table rc_map_tvwalkertwin_table[] = {
  591. { 0x0001, KEY_ZOOM }, /* Full Screen */
  592. { 0x0002, KEY_CAMERA }, /* snapshot */
  593. { 0x0003, KEY_MUTE },
  594. { 0x0004, KEY_REWIND },
  595. { 0x0005, KEY_PLAYPAUSE }, /* Play/Pause */
  596. { 0x0006, KEY_FASTFORWARD },
  597. { 0x0007, KEY_RECORD },
  598. { 0x0008, KEY_STOP },
  599. { 0x0009, KEY_TIME }, /* Timeshift */
  600. { 0x000c, KEY_COFFEE }, /* Recall */
  601. { 0x000e, KEY_CHANNELUP },
  602. { 0x0012, KEY_POWER },
  603. { 0x0015, KEY_MENU }, /* source */
  604. { 0x0018, KEY_CYCLEWINDOWS }, /* TWIN PIP */
  605. { 0x001a, KEY_CHANNELDOWN },
  606. { 0x001b, KEY_VOLUMEDOWN },
  607. { 0x001e, KEY_VOLUMEUP },
  608. };
  609. static struct rc_map_table rc_map_pinnacle310e_table[] = {
  610. { 0x16, KEY_POWER },
  611. { 0x17, KEY_FAVORITES },
  612. { 0x0f, KEY_TEXT },
  613. { 0x48, KEY_PROGRAM }, /* preview */
  614. { 0x1c, KEY_EPG },
  615. { 0x04, KEY_LIST }, /* record list */
  616. { 0x03, KEY_1 },
  617. { 0x01, KEY_2 },
  618. { 0x06, KEY_3 },
  619. { 0x09, KEY_4 },
  620. { 0x1d, KEY_5 },
  621. { 0x1f, KEY_6 },
  622. { 0x0d, KEY_7 },
  623. { 0x19, KEY_8 },
  624. { 0x1b, KEY_9 },
  625. { 0x15, KEY_0 },
  626. { 0x0c, KEY_CANCEL },
  627. { 0x4a, KEY_CLEAR },
  628. { 0x13, KEY_BACK },
  629. { 0x00, KEY_TAB },
  630. { 0x4b, KEY_UP },
  631. { 0x4e, KEY_LEFT },
  632. { 0x52, KEY_RIGHT },
  633. { 0x51, KEY_DOWN },
  634. { 0x4f, KEY_ENTER }, /* could also be KEY_OK */
  635. { 0x1e, KEY_VOLUMEUP },
  636. { 0x0a, KEY_VOLUMEDOWN },
  637. { 0x05, KEY_CHANNELUP },
  638. { 0x02, KEY_CHANNELDOWN },
  639. { 0x11, KEY_RECORD },
  640. { 0x14, KEY_PLAY },
  641. { 0x4c, KEY_PAUSE },
  642. { 0x1a, KEY_STOP },
  643. { 0x40, KEY_REWIND },
  644. { 0x12, KEY_FASTFORWARD },
  645. { 0x41, KEY_PREVIOUSSONG }, /* Replay */
  646. { 0x42, KEY_NEXTSONG }, /* Skip */
  647. { 0x54, KEY_CAMERA }, /* Capture */
  648. /* { 0x50, KEY_SAP }, */ /* Sap */
  649. { 0x47, KEY_CYCLEWINDOWS }, /* Pip */
  650. { 0x4d, KEY_SCREEN }, /* FullScreen */
  651. { 0x08, KEY_SUBTITLE },
  652. { 0x0e, KEY_MUTE },
  653. /* { 0x49, KEY_LR }, */ /* L/R */
  654. { 0x07, KEY_SLEEP }, /* Hibernate */
  655. { 0x08, KEY_VIDEO }, /* A/V */
  656. { 0x0e, KEY_MENU }, /* Recall */
  657. { 0x45, KEY_ZOOMIN },
  658. { 0x46, KEY_ZOOMOUT },
  659. { 0x18, KEY_RED }, /* Red */
  660. { 0x53, KEY_GREEN }, /* Green */
  661. { 0x5e, KEY_YELLOW }, /* Yellow */
  662. { 0x5f, KEY_BLUE }, /* Blue */
  663. };
  664. /* DVB USB Driver stuff */
  665. static struct dvb_usb_device_properties megasky_properties;
  666. static struct dvb_usb_device_properties digivox_mini_ii_properties;
  667. static struct dvb_usb_device_properties tvwalkertwin_properties;
  668. static struct dvb_usb_device_properties dposh_properties;
  669. static struct dvb_usb_device_properties pinnacle_pctv310e_properties;
  670. static struct dvb_usb_device_properties vp7049_properties;
  671. static int m920x_probe(struct usb_interface *intf,
  672. const struct usb_device_id *id)
  673. {
  674. struct dvb_usb_device *d = NULL;
  675. int ret;
  676. struct m920x_inits *rc_init_seq = NULL;
  677. int bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
  678. deb("Probing for m920x device at interface %d\n", bInterfaceNumber);
  679. if (bInterfaceNumber == 0) {
  680. /* Single-tuner device, or first interface on
  681. * multi-tuner device
  682. */
  683. ret = dvb_usb_device_init(intf, &megasky_properties,
  684. THIS_MODULE, &d, adapter_nr);
  685. if (ret == 0) {
  686. rc_init_seq = megasky_rc_init;
  687. goto found;
  688. }
  689. ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties,
  690. THIS_MODULE, &d, adapter_nr);
  691. if (ret == 0) {
  692. /* No remote control, so no rc_init_seq */
  693. goto found;
  694. }
  695. /* This configures both tuners on the TV Walker Twin */
  696. ret = dvb_usb_device_init(intf, &tvwalkertwin_properties,
  697. THIS_MODULE, &d, adapter_nr);
  698. if (ret == 0) {
  699. rc_init_seq = tvwalkertwin_rc_init;
  700. goto found;
  701. }
  702. ret = dvb_usb_device_init(intf, &dposh_properties,
  703. THIS_MODULE, &d, adapter_nr);
  704. if (ret == 0) {
  705. /* Remote controller not supported yet. */
  706. goto found;
  707. }
  708. ret = dvb_usb_device_init(intf, &pinnacle_pctv310e_properties,
  709. THIS_MODULE, &d, adapter_nr);
  710. if (ret == 0) {
  711. rc_init_seq = pinnacle310e_init;
  712. goto found;
  713. }
  714. ret = dvb_usb_device_init(intf, &vp7049_properties,
  715. THIS_MODULE, &d, adapter_nr);
  716. if (ret == 0) {
  717. rc_init_seq = vp7049_rc_init;
  718. goto found;
  719. }
  720. return ret;
  721. } else {
  722. /* Another interface on a multi-tuner device */
  723. /* The LifeView TV Walker Twin gets here, but struct
  724. * tvwalkertwin_properties already configured both
  725. * tuners, so there is nothing for us to do here
  726. */
  727. }
  728. found:
  729. if ((ret = m920x_init_ep(intf)) < 0)
  730. return ret;
  731. if (d && (ret = m920x_init(d, rc_init_seq)) != 0)
  732. return ret;
  733. return ret;
  734. }
  735. static struct usb_device_id m920x_table [] = {
  736. { USB_DEVICE(USB_VID_MSI, USB_PID_MSI_MEGASKY580) },
  737. { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
  738. USB_PID_MSI_DIGI_VOX_MINI_II) },
  739. { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
  740. USB_PID_LIFEVIEW_TV_WALKER_TWIN_COLD) },
  741. { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
  742. USB_PID_LIFEVIEW_TV_WALKER_TWIN_WARM) },
  743. { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_COLD) },
  744. { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_WARM) },
  745. { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_PINNACLE_PCTV310E) },
  746. { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_TWINHAN_VP7049) },
  747. { } /* Terminating entry */
  748. };
  749. MODULE_DEVICE_TABLE (usb, m920x_table);
  750. static struct dvb_usb_device_properties megasky_properties = {
  751. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  752. .usb_ctrl = DEVICE_SPECIFIC,
  753. .firmware = "dvb-usb-megasky-02.fw",
  754. .download_firmware = m920x_firmware_download,
  755. .rc.legacy = {
  756. .rc_interval = 100,
  757. .rc_map_table = rc_map_megasky_table,
  758. .rc_map_size = ARRAY_SIZE(rc_map_megasky_table),
  759. .rc_query = m920x_rc_query,
  760. },
  761. .size_of_priv = sizeof(struct m920x_state),
  762. .identify_state = m920x_identify_state,
  763. .num_adapters = 1,
  764. .adapter = {{
  765. .num_frontends = 1,
  766. .fe = {{
  767. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  768. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  769. .pid_filter_count = 8,
  770. .pid_filter = m920x_pid_filter,
  771. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  772. .frontend_attach = m920x_mt352_frontend_attach,
  773. .tuner_attach = m920x_qt1010_tuner_attach,
  774. .stream = {
  775. .type = USB_BULK,
  776. .count = 8,
  777. .endpoint = 0x81,
  778. .u = {
  779. .bulk = {
  780. .buffersize = 512,
  781. }
  782. }
  783. },
  784. }},
  785. }},
  786. .i2c_algo = &m920x_i2c_algo,
  787. .num_device_descs = 1,
  788. .devices = {
  789. { "MSI Mega Sky 580 DVB-T USB2.0",
  790. { &m920x_table[0], NULL },
  791. { NULL },
  792. }
  793. }
  794. };
  795. static struct dvb_usb_device_properties digivox_mini_ii_properties = {
  796. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  797. .usb_ctrl = DEVICE_SPECIFIC,
  798. .firmware = "dvb-usb-digivox-02.fw",
  799. .download_firmware = m920x_firmware_download,
  800. .size_of_priv = sizeof(struct m920x_state),
  801. .identify_state = m920x_identify_state,
  802. .num_adapters = 1,
  803. .adapter = {{
  804. .num_frontends = 1,
  805. .fe = {{
  806. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  807. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  808. .pid_filter_count = 8,
  809. .pid_filter = m920x_pid_filter,
  810. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  811. .frontend_attach = m920x_tda10046_08_frontend_attach,
  812. .tuner_attach = m920x_tda8275_60_tuner_attach,
  813. .stream = {
  814. .type = USB_BULK,
  815. .count = 8,
  816. .endpoint = 0x81,
  817. .u = {
  818. .bulk = {
  819. .buffersize = 0x4000,
  820. }
  821. }
  822. },
  823. }},
  824. }},
  825. .i2c_algo = &m920x_i2c_algo,
  826. .num_device_descs = 1,
  827. .devices = {
  828. { "MSI DIGI VOX mini II DVB-T USB2.0",
  829. { &m920x_table[1], NULL },
  830. { NULL },
  831. },
  832. }
  833. };
  834. /* LifeView TV Walker Twin support by Nick Andrew <nick@nick-andrew.net>
  835. *
  836. * LifeView TV Walker Twin has 1 x M9206, 2 x TDA10046, 2 x TDA8275A
  837. * TDA10046 #0 is located at i2c address 0x08
  838. * TDA10046 #1 is located at i2c address 0x0b
  839. * TDA8275A #0 is located at i2c address 0x60
  840. * TDA8275A #1 is located at i2c address 0x61
  841. */
  842. static struct dvb_usb_device_properties tvwalkertwin_properties = {
  843. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  844. .usb_ctrl = DEVICE_SPECIFIC,
  845. .firmware = "dvb-usb-tvwalkert.fw",
  846. .download_firmware = m920x_firmware_download,
  847. .rc.legacy = {
  848. .rc_interval = 100,
  849. .rc_map_table = rc_map_tvwalkertwin_table,
  850. .rc_map_size = ARRAY_SIZE(rc_map_tvwalkertwin_table),
  851. .rc_query = m920x_rc_query,
  852. },
  853. .size_of_priv = sizeof(struct m920x_state),
  854. .identify_state = m920x_identify_state,
  855. .num_adapters = 2,
  856. .adapter = {{
  857. .num_frontends = 1,
  858. .fe = {{
  859. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  860. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  861. .pid_filter_count = 8,
  862. .pid_filter = m920x_pid_filter,
  863. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  864. .frontend_attach = m920x_tda10046_08_frontend_attach,
  865. .tuner_attach = m920x_tda8275_60_tuner_attach,
  866. .stream = {
  867. .type = USB_BULK,
  868. .count = 8,
  869. .endpoint = 0x81,
  870. .u = {
  871. .bulk = {
  872. .buffersize = 512,
  873. }
  874. }
  875. }},
  876. }},{
  877. .num_frontends = 1,
  878. .fe = {{
  879. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  880. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  881. .pid_filter_count = 8,
  882. .pid_filter = m920x_pid_filter,
  883. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  884. .frontend_attach = m920x_tda10046_0b_frontend_attach,
  885. .tuner_attach = m920x_tda8275_61_tuner_attach,
  886. .stream = {
  887. .type = USB_BULK,
  888. .count = 8,
  889. .endpoint = 0x82,
  890. .u = {
  891. .bulk = {
  892. .buffersize = 512,
  893. }
  894. }
  895. }},
  896. },
  897. }},
  898. .i2c_algo = &m920x_i2c_algo,
  899. .num_device_descs = 1,
  900. .devices = {
  901. { .name = "LifeView TV Walker Twin DVB-T USB2.0",
  902. .cold_ids = { &m920x_table[2], NULL },
  903. .warm_ids = { &m920x_table[3], NULL },
  904. },
  905. }
  906. };
  907. static struct dvb_usb_device_properties dposh_properties = {
  908. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  909. .usb_ctrl = DEVICE_SPECIFIC,
  910. .firmware = "dvb-usb-dposh-01.fw",
  911. .download_firmware = m920x_firmware_download,
  912. .size_of_priv = sizeof(struct m920x_state),
  913. .identify_state = m920x_identify_state,
  914. .num_adapters = 1,
  915. .adapter = {{
  916. .num_frontends = 1,
  917. .fe = {{
  918. /* Hardware pid filters don't work with this device/firmware */
  919. .frontend_attach = m920x_mt352_frontend_attach,
  920. .tuner_attach = m920x_qt1010_tuner_attach,
  921. .stream = {
  922. .type = USB_BULK,
  923. .count = 8,
  924. .endpoint = 0x81,
  925. .u = {
  926. .bulk = {
  927. .buffersize = 512,
  928. }
  929. }
  930. },
  931. }},
  932. }},
  933. .i2c_algo = &m920x_i2c_algo,
  934. .num_device_descs = 1,
  935. .devices = {
  936. { .name = "Dposh DVB-T USB2.0",
  937. .cold_ids = { &m920x_table[4], NULL },
  938. .warm_ids = { &m920x_table[5], NULL },
  939. },
  940. }
  941. };
  942. static struct dvb_usb_device_properties pinnacle_pctv310e_properties = {
  943. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  944. .usb_ctrl = DEVICE_SPECIFIC,
  945. .download_firmware = NULL,
  946. .rc.legacy = {
  947. .rc_interval = 100,
  948. .rc_map_table = rc_map_pinnacle310e_table,
  949. .rc_map_size = ARRAY_SIZE(rc_map_pinnacle310e_table),
  950. .rc_query = m920x_rc_query,
  951. },
  952. .size_of_priv = sizeof(struct m920x_state),
  953. .identify_state = m920x_identify_state,
  954. .num_adapters = 1,
  955. .adapter = {{
  956. .num_frontends = 1,
  957. .fe = {{
  958. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  959. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  960. .pid_filter_count = 8,
  961. .pid_filter = m920x_pid_filter,
  962. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  963. .frontend_attach = m920x_mt352_frontend_attach,
  964. .tuner_attach = m920x_fmd1216me_tuner_attach,
  965. .stream = {
  966. .type = USB_ISOC,
  967. .count = 5,
  968. .endpoint = 0x84,
  969. .u = {
  970. .isoc = {
  971. .framesperurb = 128,
  972. .framesize = 564,
  973. .interval = 1,
  974. }
  975. }
  976. },
  977. }},
  978. } },
  979. .i2c_algo = &m920x_i2c_algo,
  980. .num_device_descs = 1,
  981. .devices = {
  982. { "Pinnacle PCTV 310e",
  983. { &m920x_table[6], NULL },
  984. { NULL },
  985. }
  986. }
  987. };
  988. static struct dvb_usb_device_properties vp7049_properties = {
  989. .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  990. .usb_ctrl = DEVICE_SPECIFIC,
  991. .firmware = "dvb-usb-vp7049-0.95.fw",
  992. .download_firmware = m920x_firmware_download,
  993. .rc.core = {
  994. .rc_interval = 150,
  995. .rc_codes = RC_MAP_TWINHAN_VP1027_DVBS,
  996. .rc_query = m920x_rc_core_query,
  997. .allowed_protos = RC_PROTO_BIT_UNKNOWN,
  998. },
  999. .size_of_priv = sizeof(struct m920x_state),
  1000. .identify_state = m920x_identify_state,
  1001. .num_adapters = 1,
  1002. .adapter = {{
  1003. .num_frontends = 1,
  1004. .fe = {{
  1005. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  1006. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  1007. .pid_filter_count = 8,
  1008. .pid_filter = m920x_pid_filter,
  1009. .pid_filter_ctrl = m920x_pid_filter_ctrl,
  1010. .frontend_attach = m920x_mt352_frontend_attach_vp7049,
  1011. .tuner_attach = m920x_mt2060_tuner_attach,
  1012. .stream = {
  1013. .type = USB_BULK,
  1014. .count = 8,
  1015. .endpoint = 0x81,
  1016. .u = {
  1017. .bulk = {
  1018. .buffersize = 512,
  1019. }
  1020. }
  1021. },
  1022. } },
  1023. } },
  1024. .i2c_algo = &m920x_i2c_algo,
  1025. .num_device_descs = 1,
  1026. .devices = {
  1027. { "DTV-DVB UDTT7049",
  1028. { &m920x_table[7], NULL },
  1029. { NULL },
  1030. }
  1031. }
  1032. };
  1033. static struct usb_driver m920x_driver = {
  1034. .name = "dvb_usb_m920x",
  1035. .probe = m920x_probe,
  1036. .disconnect = dvb_usb_device_exit,
  1037. .id_table = m920x_table,
  1038. };
  1039. module_usb_driver(m920x_driver);
  1040. MODULE_AUTHOR("Aapo Tahkola <aet@rasterburn.org>");
  1041. MODULE_DESCRIPTION("DVB Driver for ULI M920x");
  1042. MODULE_VERSION("0.1");
  1043. MODULE_LICENSE("GPL");