lmedm04.c 31 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369
  1. /* DVB USB compliant linux driver for
  2. *
  3. * DM04/QQBOX DVB-S USB BOX LME2510C + SHARP:BS2F7HZ7395
  4. * LME2510C + LG TDQY-P001F
  5. * LME2510C + BS2F7HZ0194
  6. * LME2510 + LG TDQY-P001F
  7. * LME2510 + BS2F7HZ0194
  8. *
  9. * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
  10. * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
  11. *
  12. * MV001F (LME2510+LGTDQY-P001F)
  13. * LG TDQY - P001F =(TDA8263 + TDA10086H)
  14. *
  15. * MVB0001F (LME2510C+LGTDQT-P001F)
  16. *
  17. * MV0194 (LME2510+SHARP:BS2F7HZ0194)
  18. * SHARP:BS2F7HZ0194 = (STV0299+IX2410)
  19. *
  20. * MVB0194 (LME2510C+SHARP0194)
  21. *
  22. * LME2510C + M88RS2000
  23. *
  24. * For firmware see Documentation/dvb/lmedm04.txt
  25. *
  26. * I2C addresses:
  27. * 0xd0 - STV0288 - Demodulator
  28. * 0xc0 - Sharp IX2505V - Tuner
  29. * --
  30. * 0x1c - TDA10086 - Demodulator
  31. * 0xc0 - TDA8263 - Tuner
  32. * --
  33. * 0xd0 - STV0299 - Demodulator
  34. * 0xc0 - IX2410 - Tuner
  35. *
  36. *
  37. * VID = 3344 PID LME2510=1122 LME2510C=1120
  38. *
  39. * Copyright (C) 2010 Malcolm Priestley (tvboxspy@gmail.com)
  40. * LME2510(C)(C) Leaguerme (Shenzhen) MicroElectronics Co., Ltd.
  41. *
  42. * This program is free software; you can redistribute it and/or modify
  43. * it under the terms of the GNU General Public License Version 2, as
  44. * published by the Free Software Foundation.
  45. *
  46. * This program is distributed in the hope that it will be useful,
  47. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  48. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  49. * GNU General Public License for more details.
  50. *
  51. * You should have received a copy of the GNU General Public License
  52. * along with this program; if not, write to the Free Software
  53. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  54. *
  55. *
  56. * see Documentation/dvb/README.dvb-usb for more information
  57. *
  58. * Known Issues :
  59. * LME2510: Non Intel USB chipsets fail to maintain High Speed on
  60. * Boot or Hot Plug.
  61. *
  62. * QQbox suffers from noise on LNB voltage.
  63. *
  64. * LME2510: SHARP:BS2F7HZ0194(MV0194) cannot cold reset and share system
  65. * with other tuners. After a cold reset streaming will not start.
  66. *
  67. * M88RS2000 suffers from loss of lock.
  68. */
  69. #define DVB_USB_LOG_PREFIX "LME2510(C)"
  70. #include <linux/usb.h>
  71. #include <linux/usb/input.h>
  72. #include <media/rc-core.h>
  73. #include "dvb_usb.h"
  74. #include "lmedm04.h"
  75. #include "tda826x.h"
  76. #include "tda10086.h"
  77. #include "stv0288.h"
  78. #include "ix2505v.h"
  79. #include "stv0299.h"
  80. #include "dvb-pll.h"
  81. #include "z0194a.h"
  82. #include "m88rs2000.h"
  83. #define LME2510_C_S7395 "dvb-usb-lme2510c-s7395.fw";
  84. #define LME2510_C_LG "dvb-usb-lme2510c-lg.fw";
  85. #define LME2510_C_S0194 "dvb-usb-lme2510c-s0194.fw";
  86. #define LME2510_C_RS2000 "dvb-usb-lme2510c-rs2000.fw";
  87. #define LME2510_LG "dvb-usb-lme2510-lg.fw";
  88. #define LME2510_S0194 "dvb-usb-lme2510-s0194.fw";
  89. /* debug */
  90. static int dvb_usb_lme2510_debug;
  91. #define lme_debug(var, level, args...) do { \
  92. if ((var >= level)) \
  93. pr_debug(DVB_USB_LOG_PREFIX": " args); \
  94. } while (0)
  95. #define deb_info(level, args...) lme_debug(dvb_usb_lme2510_debug, level, args)
  96. #define debug_data_snipet(level, name, p) \
  97. deb_info(level, name" (%02x%02x%02x%02x%02x%02x%02x%02x)", \
  98. *p, *(p+1), *(p+2), *(p+3), *(p+4), \
  99. *(p+5), *(p+6), *(p+7));
  100. #define info(args...) pr_info(DVB_USB_LOG_PREFIX": "args)
  101. module_param_named(debug, dvb_usb_lme2510_debug, int, 0644);
  102. MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
  103. static int dvb_usb_lme2510_firmware;
  104. module_param_named(firmware, dvb_usb_lme2510_firmware, int, 0644);
  105. MODULE_PARM_DESC(firmware, "set default firmware 0=Sharp7395 1=LG");
  106. static int pid_filter;
  107. module_param_named(pid, pid_filter, int, 0644);
  108. MODULE_PARM_DESC(pid, "set default 0=default 1=off 2=on");
  109. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  110. #define TUNER_DEFAULT 0x0
  111. #define TUNER_LG 0x1
  112. #define TUNER_S7395 0x2
  113. #define TUNER_S0194 0x3
  114. #define TUNER_RS2000 0x4
  115. struct lme2510_state {
  116. u8 id;
  117. u8 tuner_config;
  118. u8 signal_lock;
  119. u8 signal_level;
  120. u8 signal_sn;
  121. u8 time_key;
  122. u8 last_key;
  123. u8 key_timeout;
  124. u8 i2c_talk_onoff;
  125. u8 i2c_gate;
  126. u8 i2c_tuner_gate_w;
  127. u8 i2c_tuner_gate_r;
  128. u8 i2c_tuner_addr;
  129. u8 stream_on;
  130. u8 pid_size;
  131. u8 pid_off;
  132. void *buffer;
  133. struct urb *lme_urb;
  134. void *usb_buffer;
  135. int (*fe_set_voltage)(struct dvb_frontend *, fe_sec_voltage_t);
  136. u8 dvb_usb_lme2510_firmware;
  137. };
  138. static int lme2510_bulk_write(struct usb_device *dev,
  139. u8 *snd, int len, u8 pipe)
  140. {
  141. int ret, actual_l;
  142. ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, pipe),
  143. snd, len , &actual_l, 100);
  144. return ret;
  145. }
  146. static int lme2510_bulk_read(struct usb_device *dev,
  147. u8 *rev, int len, u8 pipe)
  148. {
  149. int ret, actual_l;
  150. ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, pipe),
  151. rev, len , &actual_l, 200);
  152. return ret;
  153. }
  154. static int lme2510_usb_talk(struct dvb_usb_device *d,
  155. u8 *wbuf, int wlen, u8 *rbuf, int rlen)
  156. {
  157. struct lme2510_state *st = d->priv;
  158. u8 *buff;
  159. int ret = 0;
  160. if (st->usb_buffer == NULL) {
  161. st->usb_buffer = kmalloc(64, GFP_KERNEL);
  162. if (st->usb_buffer == NULL) {
  163. info("MEM Error no memory");
  164. return -ENOMEM;
  165. }
  166. }
  167. buff = st->usb_buffer;
  168. ret = mutex_lock_interruptible(&d->usb_mutex);
  169. if (ret < 0)
  170. return -EAGAIN;
  171. /* the read/write capped at 64 */
  172. memcpy(buff, wbuf, (wlen < 64) ? wlen : 64);
  173. ret |= lme2510_bulk_write(d->udev, buff, wlen , 0x01);
  174. ret |= lme2510_bulk_read(d->udev, buff, (rlen < 64) ?
  175. rlen : 64 , 0x01);
  176. if (rlen > 0)
  177. memcpy(rbuf, buff, rlen);
  178. mutex_unlock(&d->usb_mutex);
  179. return (ret < 0) ? -ENODEV : 0;
  180. }
  181. static int lme2510_stream_restart(struct dvb_usb_device *d)
  182. {
  183. struct lme2510_state *st = d->priv;
  184. u8 all_pids[] = LME_ALL_PIDS;
  185. u8 stream_on[] = LME_ST_ON_W;
  186. int ret;
  187. u8 rbuff[1];
  188. if (st->pid_off)
  189. ret = lme2510_usb_talk(d, all_pids, sizeof(all_pids),
  190. rbuff, sizeof(rbuff));
  191. /*Restart Stream Command*/
  192. ret = lme2510_usb_talk(d, stream_on, sizeof(stream_on),
  193. rbuff, sizeof(rbuff));
  194. return ret;
  195. }
  196. static int lme2510_enable_pid(struct dvb_usb_device *d, u8 index, u16 pid_out)
  197. {
  198. struct lme2510_state *st = d->priv;
  199. static u8 pid_buff[] = LME_ZERO_PID;
  200. static u8 rbuf[1];
  201. u8 pid_no = index * 2;
  202. u8 pid_len = pid_no + 2;
  203. int ret = 0;
  204. deb_info(1, "PID Setting Pid %04x", pid_out);
  205. if (st->pid_size == 0)
  206. ret |= lme2510_stream_restart(d);
  207. pid_buff[2] = pid_no;
  208. pid_buff[3] = (u8)pid_out & 0xff;
  209. pid_buff[4] = pid_no + 1;
  210. pid_buff[5] = (u8)(pid_out >> 8);
  211. if (pid_len > st->pid_size)
  212. st->pid_size = pid_len;
  213. pid_buff[7] = 0x80 + st->pid_size;
  214. ret |= lme2510_usb_talk(d, pid_buff ,
  215. sizeof(pid_buff) , rbuf, sizeof(rbuf));
  216. if (st->stream_on)
  217. ret |= lme2510_stream_restart(d);
  218. return ret;
  219. }
  220. static void lme2510_int_response(struct urb *lme_urb)
  221. {
  222. struct dvb_usb_adapter *adap = lme_urb->context;
  223. struct lme2510_state *st = adap_to_priv(adap);
  224. static u8 *ibuf, *rbuf;
  225. int i = 0, offset;
  226. u32 key;
  227. switch (lme_urb->status) {
  228. case 0:
  229. case -ETIMEDOUT:
  230. break;
  231. case -ECONNRESET:
  232. case -ENOENT:
  233. case -ESHUTDOWN:
  234. return;
  235. default:
  236. info("Error %x", lme_urb->status);
  237. break;
  238. }
  239. rbuf = (u8 *) lme_urb->transfer_buffer;
  240. offset = ((lme_urb->actual_length/8) > 4)
  241. ? 4 : (lme_urb->actual_length/8) ;
  242. for (i = 0; i < offset; ++i) {
  243. ibuf = (u8 *)&rbuf[i*8];
  244. deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",
  245. offset, i, ibuf[0], ibuf[1]);
  246. switch (ibuf[0]) {
  247. case 0xaa:
  248. debug_data_snipet(1, "INT Remote data snipet", ibuf);
  249. if ((ibuf[4] + ibuf[5]) == 0xff) {
  250. key = ibuf[5];
  251. key += (ibuf[3] > 0)
  252. ? (ibuf[3] ^ 0xff) << 8 : 0;
  253. key += (ibuf[2] ^ 0xff) << 16;
  254. deb_info(1, "INT Key =%08x", key);
  255. if (adap_to_d(adap)->rc_dev != NULL)
  256. rc_keydown(adap_to_d(adap)->rc_dev,
  257. key, 0);
  258. }
  259. break;
  260. case 0xbb:
  261. switch (st->tuner_config) {
  262. case TUNER_LG:
  263. if (ibuf[2] > 0)
  264. st->signal_lock = ibuf[2];
  265. st->signal_level = ibuf[4];
  266. st->signal_sn = ibuf[3];
  267. st->time_key = ibuf[7];
  268. break;
  269. case TUNER_S7395:
  270. case TUNER_S0194:
  271. /* Tweak for earlier firmware*/
  272. if (ibuf[1] == 0x03) {
  273. if (ibuf[2] > 1)
  274. st->signal_lock = ibuf[2];
  275. st->signal_level = ibuf[3];
  276. st->signal_sn = ibuf[4];
  277. } else {
  278. st->signal_level = ibuf[4];
  279. st->signal_sn = ibuf[5];
  280. st->signal_lock =
  281. (st->signal_lock & 0xf7) +
  282. ((ibuf[2] & 0x01) << 0x03);
  283. }
  284. break;
  285. case TUNER_RS2000:
  286. if (ibuf[1] == 0x3 && ibuf[6] == 0xff)
  287. st->signal_lock = 0xff;
  288. else
  289. st->signal_lock = 0x00;
  290. st->signal_level = ibuf[5];
  291. st->signal_sn = ibuf[4];
  292. st->time_key = ibuf[7];
  293. default:
  294. break;
  295. }
  296. debug_data_snipet(5, "INT Remote data snipet in", ibuf);
  297. break;
  298. case 0xcc:
  299. debug_data_snipet(1, "INT Control data snipet", ibuf);
  300. break;
  301. default:
  302. debug_data_snipet(1, "INT Unknown data snipet", ibuf);
  303. break;
  304. }
  305. }
  306. usb_submit_urb(lme_urb, GFP_ATOMIC);
  307. }
  308. static int lme2510_int_read(struct dvb_usb_adapter *adap)
  309. {
  310. struct dvb_usb_device *d = adap_to_d(adap);
  311. struct lme2510_state *lme_int = adap_to_priv(adap);
  312. lme_int->lme_urb = usb_alloc_urb(0, GFP_ATOMIC);
  313. if (lme_int->lme_urb == NULL)
  314. return -ENOMEM;
  315. lme_int->buffer = usb_alloc_coherent(d->udev, 128, GFP_ATOMIC,
  316. &lme_int->lme_urb->transfer_dma);
  317. if (lme_int->buffer == NULL)
  318. return -ENOMEM;
  319. usb_fill_int_urb(lme_int->lme_urb,
  320. d->udev,
  321. usb_rcvintpipe(d->udev, 0xa),
  322. lme_int->buffer,
  323. 128,
  324. lme2510_int_response,
  325. adap,
  326. 8);
  327. lme_int->lme_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  328. usb_submit_urb(lme_int->lme_urb, GFP_ATOMIC);
  329. info("INT Interrupt Service Started");
  330. return 0;
  331. }
  332. static int lme2510_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
  333. {
  334. struct dvb_usb_device *d = adap_to_d(adap);
  335. struct lme2510_state *st = adap_to_priv(adap);
  336. static u8 clear_pid_reg[] = LME_ALL_PIDS;
  337. static u8 rbuf[1];
  338. int ret = 0;
  339. deb_info(1, "PID Clearing Filter");
  340. mutex_lock(&d->i2c_mutex);
  341. if (!onoff) {
  342. ret |= lme2510_usb_talk(d, clear_pid_reg,
  343. sizeof(clear_pid_reg), rbuf, sizeof(rbuf));
  344. st->pid_off = true;
  345. } else
  346. st->pid_off = false;
  347. st->pid_size = 0;
  348. mutex_unlock(&d->i2c_mutex);
  349. return 0;
  350. }
  351. static int lme2510_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
  352. int onoff)
  353. {
  354. struct dvb_usb_device *d = adap_to_d(adap);
  355. int ret = 0;
  356. deb_info(3, "%s PID=%04x Index=%04x onoff=%02x", __func__,
  357. pid, index, onoff);
  358. if (onoff) {
  359. mutex_lock(&d->i2c_mutex);
  360. ret |= lme2510_enable_pid(d, index, pid);
  361. mutex_unlock(&d->i2c_mutex);
  362. }
  363. return ret;
  364. }
  365. static int lme2510_return_status(struct dvb_usb_device *d)
  366. {
  367. int ret = 0;
  368. u8 *data;
  369. data = kzalloc(10, GFP_KERNEL);
  370. if (!data)
  371. return -ENOMEM;
  372. ret |= usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
  373. 0x06, 0x80, 0x0302, 0x00, data, 0x0006, 200);
  374. info("Firmware Status: %x (%x)", ret , data[2]);
  375. ret = (ret < 0) ? -ENODEV : data[2];
  376. kfree(data);
  377. return ret;
  378. }
  379. static int lme2510_msg(struct dvb_usb_device *d,
  380. u8 *wbuf, int wlen, u8 *rbuf, int rlen)
  381. {
  382. int ret = 0;
  383. struct lme2510_state *st = d->priv;
  384. if (st->i2c_talk_onoff == 1) {
  385. ret = lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
  386. switch (st->tuner_config) {
  387. case TUNER_LG:
  388. if (wbuf[2] == 0x1c) {
  389. if (wbuf[3] == 0x0e) {
  390. st->signal_lock = rbuf[1];
  391. if ((st->stream_on & 1) &&
  392. (st->signal_lock & 0x10)) {
  393. lme2510_stream_restart(d);
  394. st->i2c_talk_onoff = 0;
  395. }
  396. msleep(80);
  397. }
  398. }
  399. break;
  400. case TUNER_S7395:
  401. if (wbuf[2] == 0xd0) {
  402. if (wbuf[3] == 0x24) {
  403. st->signal_lock = rbuf[1];
  404. if ((st->stream_on & 1) &&
  405. (st->signal_lock & 0x8)) {
  406. lme2510_stream_restart(d);
  407. st->i2c_talk_onoff = 0;
  408. }
  409. }
  410. }
  411. break;
  412. case TUNER_S0194:
  413. if (wbuf[2] == 0xd0) {
  414. if (wbuf[3] == 0x1b) {
  415. st->signal_lock = rbuf[1];
  416. if ((st->stream_on & 1) &&
  417. (st->signal_lock & 0x8)) {
  418. lme2510_stream_restart(d);
  419. st->i2c_talk_onoff = 0;
  420. }
  421. }
  422. }
  423. break;
  424. case TUNER_RS2000:
  425. default:
  426. break;
  427. }
  428. } else {
  429. /* TODO rewrite this section */
  430. switch (st->tuner_config) {
  431. case TUNER_LG:
  432. switch (wbuf[3]) {
  433. case 0x0e:
  434. rbuf[0] = 0x55;
  435. rbuf[1] = st->signal_lock;
  436. break;
  437. case 0x43:
  438. rbuf[0] = 0x55;
  439. rbuf[1] = st->signal_level;
  440. break;
  441. case 0x1c:
  442. rbuf[0] = 0x55;
  443. rbuf[1] = st->signal_sn;
  444. break;
  445. case 0x15:
  446. case 0x16:
  447. case 0x17:
  448. case 0x18:
  449. rbuf[0] = 0x55;
  450. rbuf[1] = 0x00;
  451. break;
  452. default:
  453. lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
  454. st->i2c_talk_onoff = 1;
  455. break;
  456. }
  457. break;
  458. case TUNER_S7395:
  459. switch (wbuf[3]) {
  460. case 0x10:
  461. rbuf[0] = 0x55;
  462. rbuf[1] = (st->signal_level & 0x80)
  463. ? 0 : (st->signal_level * 2);
  464. break;
  465. case 0x2d:
  466. rbuf[0] = 0x55;
  467. rbuf[1] = st->signal_sn;
  468. break;
  469. case 0x24:
  470. rbuf[0] = 0x55;
  471. rbuf[1] = st->signal_lock;
  472. break;
  473. case 0x2e:
  474. case 0x26:
  475. case 0x27:
  476. rbuf[0] = 0x55;
  477. rbuf[1] = 0x00;
  478. break;
  479. default:
  480. lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
  481. st->i2c_talk_onoff = 1;
  482. break;
  483. }
  484. break;
  485. case TUNER_S0194:
  486. switch (wbuf[3]) {
  487. case 0x18:
  488. rbuf[0] = 0x55;
  489. rbuf[1] = (st->signal_level & 0x80)
  490. ? 0 : (st->signal_level * 2);
  491. break;
  492. case 0x24:
  493. rbuf[0] = 0x55;
  494. rbuf[1] = st->signal_sn;
  495. break;
  496. case 0x1b:
  497. rbuf[0] = 0x55;
  498. rbuf[1] = st->signal_lock;
  499. break;
  500. case 0x19:
  501. case 0x25:
  502. case 0x1e:
  503. case 0x1d:
  504. rbuf[0] = 0x55;
  505. rbuf[1] = 0x00;
  506. break;
  507. default:
  508. lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
  509. st->i2c_talk_onoff = 1;
  510. break;
  511. }
  512. break;
  513. case TUNER_RS2000:
  514. switch (wbuf[3]) {
  515. case 0x8c:
  516. rbuf[0] = 0x55;
  517. rbuf[1] = 0xff;
  518. if (st->last_key == st->time_key) {
  519. st->key_timeout++;
  520. if (st->key_timeout > 5)
  521. rbuf[1] = 0;
  522. } else
  523. st->key_timeout = 0;
  524. st->last_key = st->time_key;
  525. break;
  526. default:
  527. lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
  528. st->i2c_talk_onoff = 1;
  529. break;
  530. }
  531. default:
  532. break;
  533. }
  534. deb_info(4, "I2C From Interrupt Message out(%02x) in(%02x)",
  535. wbuf[3], rbuf[1]);
  536. }
  537. return ret;
  538. }
  539. static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
  540. int num)
  541. {
  542. struct dvb_usb_device *d = i2c_get_adapdata(adap);
  543. struct lme2510_state *st = d->priv;
  544. static u8 obuf[64], ibuf[64];
  545. int i, read, read_o;
  546. u16 len;
  547. u8 gate = st->i2c_gate;
  548. mutex_lock(&d->i2c_mutex);
  549. if (gate == 0)
  550. gate = 5;
  551. for (i = 0; i < num; i++) {
  552. read_o = 1 & (msg[i].flags & I2C_M_RD);
  553. read = i+1 < num && (msg[i+1].flags & I2C_M_RD);
  554. read |= read_o;
  555. gate = (msg[i].addr == st->i2c_tuner_addr)
  556. ? (read) ? st->i2c_tuner_gate_r
  557. : st->i2c_tuner_gate_w
  558. : st->i2c_gate;
  559. obuf[0] = gate | (read << 7);
  560. if (gate == 5)
  561. obuf[1] = (read) ? 2 : msg[i].len + 1;
  562. else
  563. obuf[1] = msg[i].len + read + 1;
  564. obuf[2] = msg[i].addr;
  565. if (read) {
  566. if (read_o)
  567. len = 3;
  568. else {
  569. memcpy(&obuf[3], msg[i].buf, msg[i].len);
  570. obuf[msg[i].len+3] = msg[i+1].len;
  571. len = msg[i].len+4;
  572. }
  573. } else {
  574. memcpy(&obuf[3], msg[i].buf, msg[i].len);
  575. len = msg[i].len+3;
  576. }
  577. if (lme2510_msg(d, obuf, len, ibuf, 64) < 0) {
  578. deb_info(1, "i2c transfer failed.");
  579. mutex_unlock(&d->i2c_mutex);
  580. return -EAGAIN;
  581. }
  582. if (read) {
  583. if (read_o)
  584. memcpy(msg[i].buf, &ibuf[1], msg[i].len);
  585. else {
  586. memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
  587. i++;
  588. }
  589. }
  590. }
  591. mutex_unlock(&d->i2c_mutex);
  592. return i;
  593. }
  594. static u32 lme2510_i2c_func(struct i2c_adapter *adapter)
  595. {
  596. return I2C_FUNC_I2C;
  597. }
  598. static struct i2c_algorithm lme2510_i2c_algo = {
  599. .master_xfer = lme2510_i2c_xfer,
  600. .functionality = lme2510_i2c_func,
  601. };
  602. static int lme2510_streaming_ctrl(struct dvb_frontend *fe, int onoff)
  603. {
  604. struct dvb_usb_adapter *adap = fe_to_adap(fe);
  605. struct dvb_usb_device *d = adap_to_d(adap);
  606. struct lme2510_state *st = adap_to_priv(adap);
  607. static u8 clear_reg_3[] = LME_ALL_PIDS;
  608. static u8 rbuf[1];
  609. int ret = 0, rlen = sizeof(rbuf);
  610. deb_info(1, "STM (%02x)", onoff);
  611. /* Streaming is started by FE_HAS_LOCK */
  612. if (onoff == 1)
  613. st->stream_on = 1;
  614. else {
  615. deb_info(1, "STM Steam Off");
  616. /* mutex is here only to avoid collision with I2C */
  617. mutex_lock(&d->i2c_mutex);
  618. ret = lme2510_usb_talk(d, clear_reg_3,
  619. sizeof(clear_reg_3), rbuf, rlen);
  620. st->stream_on = 0;
  621. st->i2c_talk_onoff = 1;
  622. mutex_unlock(&d->i2c_mutex);
  623. }
  624. return (ret < 0) ? -ENODEV : 0;
  625. }
  626. static u8 check_sum(u8 *p, u8 len)
  627. {
  628. u8 sum = 0;
  629. while (len--)
  630. sum += *p++;
  631. return sum;
  632. }
  633. static int lme2510_download_firmware(struct dvb_usb_device *d,
  634. const struct firmware *fw)
  635. {
  636. int ret = 0;
  637. u8 *data;
  638. u16 j, wlen, len_in, start, end;
  639. u8 packet_size, dlen, i;
  640. u8 *fw_data;
  641. packet_size = 0x31;
  642. len_in = 1;
  643. data = kzalloc(128, GFP_KERNEL);
  644. if (!data) {
  645. info("FRM Could not start Firmware Download"\
  646. "(Buffer allocation failed)");
  647. return -ENOMEM;
  648. }
  649. info("FRM Starting Firmware Download");
  650. for (i = 1; i < 3; i++) {
  651. start = (i == 1) ? 0 : 512;
  652. end = (i == 1) ? 512 : fw->size;
  653. for (j = start; j < end; j += (packet_size+1)) {
  654. fw_data = (u8 *)(fw->data + j);
  655. if ((end - j) > packet_size) {
  656. data[0] = i;
  657. dlen = packet_size;
  658. } else {
  659. data[0] = i | 0x80;
  660. dlen = (u8)(end - j)-1;
  661. }
  662. data[1] = dlen;
  663. memcpy(&data[2], fw_data, dlen+1);
  664. wlen = (u8) dlen + 4;
  665. data[wlen-1] = check_sum(fw_data, dlen+1);
  666. deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
  667. data[dlen+2], data[dlen+3]);
  668. lme2510_usb_talk(d, data, wlen, data, len_in);
  669. ret |= (data[0] == 0x88) ? 0 : -1;
  670. }
  671. }
  672. data[0] = 0x8a;
  673. len_in = 1;
  674. msleep(2000);
  675. lme2510_usb_talk(d, data, len_in, data, len_in);
  676. msleep(400);
  677. if (ret < 0)
  678. info("FRM Firmware Download Failed (%04x)" , ret);
  679. else
  680. info("FRM Firmware Download Completed - Resetting Device");
  681. kfree(data);
  682. return RECONNECTS_USB;
  683. }
  684. static void lme_coldreset(struct dvb_usb_device *d)
  685. {
  686. u8 data[1] = {0};
  687. data[0] = 0x0a;
  688. info("FRM Firmware Cold Reset");
  689. lme2510_usb_talk(d, data, sizeof(data), data, sizeof(data));
  690. return;
  691. }
  692. static const char fw_c_s7395[] = LME2510_C_S7395;
  693. static const char fw_c_lg[] = LME2510_C_LG;
  694. static const char fw_c_s0194[] = LME2510_C_S0194;
  695. static const char fw_c_rs2000[] = LME2510_C_RS2000;
  696. static const char fw_lg[] = LME2510_LG;
  697. static const char fw_s0194[] = LME2510_S0194;
  698. static const char *lme_firmware_switch(struct dvb_usb_device *d, int cold)
  699. {
  700. struct lme2510_state *st = d->priv;
  701. struct usb_device *udev = d->udev;
  702. const struct firmware *fw = NULL;
  703. const char *fw_lme;
  704. int ret = 0;
  705. cold = (cold > 0) ? (cold & 1) : 0;
  706. switch (le16_to_cpu(udev->descriptor.idProduct)) {
  707. case 0x1122:
  708. switch (st->dvb_usb_lme2510_firmware) {
  709. default:
  710. st->dvb_usb_lme2510_firmware = TUNER_S0194;
  711. case TUNER_S0194:
  712. fw_lme = fw_s0194;
  713. ret = request_firmware(&fw, fw_lme, &udev->dev);
  714. if (ret == 0) {
  715. cold = 0;
  716. break;
  717. }
  718. st->dvb_usb_lme2510_firmware = TUNER_LG;
  719. case TUNER_LG:
  720. fw_lme = fw_lg;
  721. ret = request_firmware(&fw, fw_lme, &udev->dev);
  722. if (ret == 0)
  723. break;
  724. st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
  725. break;
  726. }
  727. break;
  728. case 0x1120:
  729. switch (st->dvb_usb_lme2510_firmware) {
  730. default:
  731. st->dvb_usb_lme2510_firmware = TUNER_S7395;
  732. case TUNER_S7395:
  733. fw_lme = fw_c_s7395;
  734. ret = request_firmware(&fw, fw_lme, &udev->dev);
  735. if (ret == 0) {
  736. cold = 0;
  737. break;
  738. }
  739. st->dvb_usb_lme2510_firmware = TUNER_LG;
  740. case TUNER_LG:
  741. fw_lme = fw_c_lg;
  742. ret = request_firmware(&fw, fw_lme, &udev->dev);
  743. if (ret == 0)
  744. break;
  745. st->dvb_usb_lme2510_firmware = TUNER_S0194;
  746. case TUNER_S0194:
  747. fw_lme = fw_c_s0194;
  748. ret = request_firmware(&fw, fw_lme, &udev->dev);
  749. if (ret == 0)
  750. break;
  751. st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
  752. cold = 0;
  753. break;
  754. }
  755. break;
  756. case 0x22f0:
  757. fw_lme = fw_c_rs2000;
  758. st->dvb_usb_lme2510_firmware = TUNER_RS2000;
  759. break;
  760. default:
  761. fw_lme = fw_c_s7395;
  762. }
  763. release_firmware(fw);
  764. if (cold) {
  765. dvb_usb_lme2510_firmware = st->dvb_usb_lme2510_firmware;
  766. info("FRM Changing to %s firmware", fw_lme);
  767. lme_coldreset(d);
  768. return NULL;
  769. }
  770. return fw_lme;
  771. }
  772. static int lme2510_kill_urb(struct usb_data_stream *stream)
  773. {
  774. int i;
  775. for (i = 0; i < stream->urbs_submitted; i++) {
  776. deb_info(3, "killing URB no. %d.", i);
  777. /* stop the URB */
  778. usb_kill_urb(stream->urb_list[i]);
  779. }
  780. stream->urbs_submitted = 0;
  781. return 0;
  782. }
  783. static struct tda10086_config tda10086_config = {
  784. .demod_address = 0x1c,
  785. .invert = 0,
  786. .diseqc_tone = 1,
  787. .xtal_freq = TDA10086_XTAL_16M,
  788. };
  789. static struct stv0288_config lme_config = {
  790. .demod_address = 0xd0,
  791. .min_delay_ms = 15,
  792. .inittab = s7395_inittab,
  793. };
  794. static struct ix2505v_config lme_tuner = {
  795. .tuner_address = 0xc0,
  796. .min_delay_ms = 100,
  797. .tuner_gain = 0x0,
  798. .tuner_chargepump = 0x3,
  799. };
  800. static struct stv0299_config sharp_z0194_config = {
  801. .demod_address = 0xd0,
  802. .inittab = sharp_z0194a_inittab,
  803. .mclk = 88000000UL,
  804. .invert = 0,
  805. .skip_reinit = 0,
  806. .lock_output = STV0299_LOCKOUTPUT_1,
  807. .volt13_op0_op1 = STV0299_VOLT13_OP1,
  808. .min_delay_ms = 100,
  809. .set_symbol_rate = sharp_z0194a_set_symbol_rate,
  810. };
  811. static int dm04_rs2000_set_ts_param(struct dvb_frontend *fe,
  812. int caller)
  813. {
  814. struct dvb_usb_adapter *adap = fe_to_adap(fe);
  815. struct dvb_usb_device *d = adap_to_d(adap);
  816. struct lme2510_state *st = d->priv;
  817. mutex_lock(&d->i2c_mutex);
  818. if ((st->i2c_talk_onoff == 1) && (st->stream_on & 1)) {
  819. st->i2c_talk_onoff = 0;
  820. lme2510_stream_restart(d);
  821. }
  822. mutex_unlock(&d->i2c_mutex);
  823. return 0;
  824. }
  825. static struct m88rs2000_config m88rs2000_config = {
  826. .demod_addr = 0xd0,
  827. .tuner_addr = 0xc0,
  828. .set_ts_params = dm04_rs2000_set_ts_param,
  829. };
  830. static int dm04_lme2510_set_voltage(struct dvb_frontend *fe,
  831. fe_sec_voltage_t voltage)
  832. {
  833. struct dvb_usb_device *d = fe_to_d(fe);
  834. struct lme2510_state *st = fe_to_priv(fe);
  835. static u8 voltage_low[] = LME_VOLTAGE_L;
  836. static u8 voltage_high[] = LME_VOLTAGE_H;
  837. static u8 rbuf[1];
  838. int ret = 0, len = 3, rlen = 1;
  839. mutex_lock(&d->i2c_mutex);
  840. switch (voltage) {
  841. case SEC_VOLTAGE_18:
  842. ret |= lme2510_usb_talk(d,
  843. voltage_high, len, rbuf, rlen);
  844. break;
  845. case SEC_VOLTAGE_OFF:
  846. case SEC_VOLTAGE_13:
  847. default:
  848. ret |= lme2510_usb_talk(d,
  849. voltage_low, len, rbuf, rlen);
  850. break;
  851. }
  852. mutex_unlock(&d->i2c_mutex);
  853. if (st->tuner_config == TUNER_RS2000)
  854. if (st->fe_set_voltage)
  855. st->fe_set_voltage(fe, voltage);
  856. return (ret < 0) ? -ENODEV : 0;
  857. }
  858. static int dm04_rs2000_read_signal_strength(struct dvb_frontend *fe,
  859. u16 *strength)
  860. {
  861. struct lme2510_state *st = fe_to_priv(fe);
  862. *strength = (u16)((u32)st->signal_level * 0xffff / 0xff);
  863. return 0;
  864. }
  865. static int dm04_rs2000_read_snr(struct dvb_frontend *fe, u16 *snr)
  866. {
  867. struct lme2510_state *st = fe_to_priv(fe);
  868. *snr = (u16)((u32)st->signal_sn * 0xffff / 0x7f);
  869. return 0;
  870. }
  871. static int dm04_read_ber(struct dvb_frontend *fe, u32 *ber)
  872. {
  873. *ber = 0;
  874. return 0;
  875. }
  876. static int dm04_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
  877. {
  878. *ucblocks = 0;
  879. return 0;
  880. }
  881. static int lme_name(struct dvb_usb_adapter *adap)
  882. {
  883. struct dvb_usb_device *d = adap_to_d(adap);
  884. struct lme2510_state *st = adap_to_priv(adap);
  885. const char *desc = d->name;
  886. char *fe_name[] = {"", " LG TDQY-P001F", " SHARP:BS2F7HZ7395",
  887. " SHARP:BS2F7HZ0194", " RS2000"};
  888. char *name = adap->fe[0]->ops.info.name;
  889. strlcpy(name, desc, 128);
  890. strlcat(name, fe_name[st->tuner_config], 128);
  891. return 0;
  892. }
  893. static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
  894. {
  895. struct dvb_usb_device *d = adap_to_d(adap);
  896. struct lme2510_state *st = d->priv;
  897. int ret = 0;
  898. st->i2c_talk_onoff = 1;
  899. switch (le16_to_cpu(d->udev->descriptor.idProduct)) {
  900. case 0x1122:
  901. case 0x1120:
  902. st->i2c_gate = 4;
  903. adap->fe[0] = dvb_attach(tda10086_attach,
  904. &tda10086_config, &d->i2c_adap);
  905. if (adap->fe[0]) {
  906. info("TUN Found Frontend TDA10086");
  907. st->i2c_tuner_gate_w = 4;
  908. st->i2c_tuner_gate_r = 4;
  909. st->i2c_tuner_addr = 0xc0;
  910. st->tuner_config = TUNER_LG;
  911. if (st->dvb_usb_lme2510_firmware != TUNER_LG) {
  912. st->dvb_usb_lme2510_firmware = TUNER_LG;
  913. ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
  914. }
  915. break;
  916. }
  917. st->i2c_gate = 4;
  918. adap->fe[0] = dvb_attach(stv0299_attach,
  919. &sharp_z0194_config, &d->i2c_adap);
  920. if (adap->fe[0]) {
  921. info("FE Found Stv0299");
  922. st->i2c_tuner_gate_w = 4;
  923. st->i2c_tuner_gate_r = 5;
  924. st->i2c_tuner_addr = 0xc0;
  925. st->tuner_config = TUNER_S0194;
  926. if (st->dvb_usb_lme2510_firmware != TUNER_S0194) {
  927. st->dvb_usb_lme2510_firmware = TUNER_S0194;
  928. ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
  929. }
  930. break;
  931. }
  932. st->i2c_gate = 5;
  933. adap->fe[0] = dvb_attach(stv0288_attach, &lme_config,
  934. &d->i2c_adap);
  935. if (adap->fe[0]) {
  936. info("FE Found Stv0288");
  937. st->i2c_tuner_gate_w = 4;
  938. st->i2c_tuner_gate_r = 5;
  939. st->i2c_tuner_addr = 0xc0;
  940. st->tuner_config = TUNER_S7395;
  941. if (st->dvb_usb_lme2510_firmware != TUNER_S7395) {
  942. st->dvb_usb_lme2510_firmware = TUNER_S7395;
  943. ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
  944. }
  945. break;
  946. }
  947. case 0x22f0:
  948. st->i2c_gate = 5;
  949. adap->fe[0] = dvb_attach(m88rs2000_attach,
  950. &m88rs2000_config, &d->i2c_adap);
  951. if (adap->fe[0]) {
  952. info("FE Found M88RS2000");
  953. st->i2c_tuner_gate_w = 5;
  954. st->i2c_tuner_gate_r = 5;
  955. st->i2c_tuner_addr = 0xc0;
  956. st->tuner_config = TUNER_RS2000;
  957. st->fe_set_voltage =
  958. adap->fe[0]->ops.set_voltage;
  959. adap->fe[0]->ops.read_signal_strength =
  960. dm04_rs2000_read_signal_strength;
  961. adap->fe[0]->ops.read_snr =
  962. dm04_rs2000_read_snr;
  963. adap->fe[0]->ops.read_ber =
  964. dm04_read_ber;
  965. adap->fe[0]->ops.read_ucblocks =
  966. dm04_read_ucblocks;
  967. }
  968. break;
  969. }
  970. if (adap->fe[0] == NULL) {
  971. info("DM04/QQBOX Not Powered up or not Supported");
  972. return -ENODEV;
  973. }
  974. if (ret) {
  975. if (adap->fe[0]) {
  976. dvb_frontend_detach(adap->fe[0]);
  977. adap->fe[0] = NULL;
  978. }
  979. d->rc_map = NULL;
  980. return -ENODEV;
  981. }
  982. adap->fe[0]->ops.set_voltage = dm04_lme2510_set_voltage;
  983. ret = lme_name(adap);
  984. return ret;
  985. }
  986. static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
  987. {
  988. struct dvb_usb_device *d = adap_to_d(adap);
  989. struct lme2510_state *st = adap_to_priv(adap);
  990. char *tun_msg[] = {"", "TDA8263", "IX2505V", "DVB_PLL_OPERA", "RS2000"};
  991. int ret = 0;
  992. switch (st->tuner_config) {
  993. case TUNER_LG:
  994. if (dvb_attach(tda826x_attach, adap->fe[0], 0xc0,
  995. &d->i2c_adap, 1))
  996. ret = st->tuner_config;
  997. break;
  998. case TUNER_S7395:
  999. if (dvb_attach(ix2505v_attach , adap->fe[0], &lme_tuner,
  1000. &d->i2c_adap))
  1001. ret = st->tuner_config;
  1002. break;
  1003. case TUNER_S0194:
  1004. if (dvb_attach(dvb_pll_attach , adap->fe[0], 0xc0,
  1005. &d->i2c_adap, DVB_PLL_OPERA1))
  1006. ret = st->tuner_config;
  1007. break;
  1008. case TUNER_RS2000:
  1009. ret = st->tuner_config;
  1010. break;
  1011. default:
  1012. break;
  1013. }
  1014. if (ret)
  1015. info("TUN Found %s tuner", tun_msg[ret]);
  1016. else {
  1017. info("TUN No tuner found --- resetting device");
  1018. lme_coldreset(d);
  1019. return -ENODEV;
  1020. }
  1021. /* Start the Interrupt*/
  1022. ret = lme2510_int_read(adap);
  1023. if (ret < 0) {
  1024. info("INT Unable to start Interrupt Service");
  1025. return -ENODEV;
  1026. }
  1027. return ret;
  1028. }
  1029. static int lme2510_powerup(struct dvb_usb_device *d, int onoff)
  1030. {
  1031. struct lme2510_state *st = d->priv;
  1032. static u8 lnb_on[] = LNB_ON;
  1033. static u8 lnb_off[] = LNB_OFF;
  1034. static u8 rbuf[1];
  1035. int ret = 0, len = 3, rlen = 1;
  1036. mutex_lock(&d->i2c_mutex);
  1037. if (onoff)
  1038. ret = lme2510_usb_talk(d, lnb_on, len, rbuf, rlen);
  1039. else
  1040. ret = lme2510_usb_talk(d, lnb_off, len, rbuf, rlen);
  1041. st->i2c_talk_onoff = 1;
  1042. mutex_unlock(&d->i2c_mutex);
  1043. return ret;
  1044. }
  1045. static int lme2510_get_adapter_count(struct dvb_usb_device *d)
  1046. {
  1047. return 1;
  1048. }
  1049. static int lme2510_identify_state(struct dvb_usb_device *d, const char **name)
  1050. {
  1051. struct lme2510_state *st = d->priv;
  1052. usb_reset_configuration(d->udev);
  1053. usb_set_interface(d->udev,
  1054. d->intf->cur_altsetting->desc.bInterfaceNumber, 1);
  1055. st->dvb_usb_lme2510_firmware = dvb_usb_lme2510_firmware;
  1056. if (lme2510_return_status(d) == 0x44) {
  1057. *name = lme_firmware_switch(d, 0);
  1058. return COLD;
  1059. }
  1060. return 0;
  1061. }
  1062. static int lme2510_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
  1063. struct usb_data_stream_properties *stream)
  1064. {
  1065. struct dvb_usb_adapter *adap = fe_to_adap(fe);
  1066. struct dvb_usb_device *d = adap_to_d(adap);
  1067. if (adap == NULL)
  1068. return 0;
  1069. /* Turn PID filter on the fly by module option */
  1070. if (pid_filter == 2) {
  1071. adap->pid_filtering = 1;
  1072. adap->max_feed_count = 15;
  1073. }
  1074. if (!(le16_to_cpu(d->udev->descriptor.idProduct)
  1075. == 0x1122))
  1076. stream->endpoint = 0x8;
  1077. return 0;
  1078. }
  1079. static int lme2510_get_rc_config(struct dvb_usb_device *d,
  1080. struct dvb_usb_rc *rc)
  1081. {
  1082. rc->allowed_protos = RC_BIT_NEC;
  1083. return 0;
  1084. }
  1085. static void *lme2510_exit_int(struct dvb_usb_device *d)
  1086. {
  1087. struct lme2510_state *st = d->priv;
  1088. struct dvb_usb_adapter *adap = &d->adapter[0];
  1089. void *buffer = NULL;
  1090. if (adap != NULL) {
  1091. lme2510_kill_urb(&adap->stream);
  1092. }
  1093. if (st->usb_buffer != NULL) {
  1094. st->i2c_talk_onoff = 1;
  1095. st->signal_lock = 0;
  1096. st->signal_level = 0;
  1097. st->signal_sn = 0;
  1098. buffer = st->usb_buffer;
  1099. }
  1100. if (st->lme_urb != NULL) {
  1101. usb_kill_urb(st->lme_urb);
  1102. usb_free_coherent(d->udev, 128, st->buffer,
  1103. st->lme_urb->transfer_dma);
  1104. info("Interrupt Service Stopped");
  1105. }
  1106. return buffer;
  1107. }
  1108. static void lme2510_exit(struct dvb_usb_device *d)
  1109. {
  1110. void *usb_buffer;
  1111. if (d != NULL) {
  1112. usb_buffer = lme2510_exit_int(d);
  1113. if (usb_buffer != NULL)
  1114. kfree(usb_buffer);
  1115. }
  1116. }
  1117. static struct dvb_usb_device_properties lme2510_props = {
  1118. .driver_name = KBUILD_MODNAME,
  1119. .owner = THIS_MODULE,
  1120. .bInterfaceNumber = 0,
  1121. .adapter_nr = adapter_nr,
  1122. .size_of_priv = sizeof(struct lme2510_state),
  1123. .download_firmware = lme2510_download_firmware,
  1124. .power_ctrl = lme2510_powerup,
  1125. .identify_state = lme2510_identify_state,
  1126. .i2c_algo = &lme2510_i2c_algo,
  1127. .frontend_attach = dm04_lme2510_frontend_attach,
  1128. .tuner_attach = dm04_lme2510_tuner,
  1129. .get_stream_config = lme2510_get_stream_config,
  1130. .get_adapter_count = lme2510_get_adapter_count,
  1131. .streaming_ctrl = lme2510_streaming_ctrl,
  1132. .get_rc_config = lme2510_get_rc_config,
  1133. .exit = lme2510_exit,
  1134. .adapter = {
  1135. {
  1136. .caps = DVB_USB_ADAP_HAS_PID_FILTER|
  1137. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  1138. .pid_filter_count = 15,
  1139. .pid_filter = lme2510_pid_filter,
  1140. .pid_filter_ctrl = lme2510_pid_filter_ctrl,
  1141. .stream =
  1142. DVB_USB_STREAM_BULK(0x86, 10, 4096),
  1143. },
  1144. {
  1145. }
  1146. },
  1147. };
  1148. static const struct usb_device_id lme2510_id_table[] = {
  1149. { DVB_USB_DEVICE(0x3344, 0x1122, &lme2510_props,
  1150. "DM04_LME2510_DVB-S", RC_MAP_LME2510) },
  1151. { DVB_USB_DEVICE(0x3344, 0x1120, &lme2510_props,
  1152. "DM04_LME2510C_DVB-S", RC_MAP_LME2510) },
  1153. { DVB_USB_DEVICE(0x3344, 0x22f0, &lme2510_props,
  1154. "DM04_LME2510C_DVB-S RS2000", RC_MAP_LME2510) },
  1155. {} /* Terminating entry */
  1156. };
  1157. MODULE_DEVICE_TABLE(usb, lme2510_id_table);
  1158. static struct usb_driver lme2510_driver = {
  1159. .name = KBUILD_MODNAME,
  1160. .probe = dvb_usbv2_probe,
  1161. .disconnect = dvb_usbv2_disconnect,
  1162. .id_table = lme2510_id_table,
  1163. .no_dynamic_id = 1,
  1164. .soft_unbind = 1,
  1165. };
  1166. module_usb_driver(lme2510_driver);
  1167. MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
  1168. MODULE_DESCRIPTION("LME2510(C) DVB-S USB2.0");
  1169. MODULE_VERSION("2.06");
  1170. MODULE_LICENSE("GPL");
  1171. MODULE_FIRMWARE(LME2510_C_S7395);
  1172. MODULE_FIRMWARE(LME2510_C_LG);
  1173. MODULE_FIRMWARE(LME2510_C_S0194);
  1174. MODULE_FIRMWARE(LME2510_C_RS2000);
  1175. MODULE_FIRMWARE(LME2510_LG);
  1176. MODULE_FIRMWARE(LME2510_S0194);