tm6000-dvb.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464
  1. /*
  2. * tm6000-dvb.c - dvb-t support for TM5600/TM6000/TM6010 USB video capture devices
  3. *
  4. * Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation version 2
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. */
  15. #include <linux/kernel.h>
  16. #include <linux/slab.h>
  17. #include <linux/usb.h>
  18. #include "tm6000.h"
  19. #include "tm6000-regs.h"
  20. #include "zl10353.h"
  21. #include <media/tuner.h>
  22. #include "tuner-xc2028.h"
  23. #include "xc5000.h"
  24. MODULE_DESCRIPTION("DVB driver extension module for tm5600/6000/6010 based TV cards");
  25. MODULE_AUTHOR("Mauro Carvalho Chehab");
  26. MODULE_LICENSE("GPL");
  27. MODULE_SUPPORTED_DEVICE("{{Trident, tm5600},{{Trident, tm6000},{{Trident, tm6010}");
  28. static int debug;
  29. module_param(debug, int, 0644);
  30. MODULE_PARM_DESC(debug, "enable debug message");
  31. static inline void print_err_status(struct tm6000_core *dev,
  32. int packet, int status)
  33. {
  34. char *errmsg = "Unknown";
  35. switch (status) {
  36. case -ENOENT:
  37. errmsg = "unlinked synchronously";
  38. break;
  39. case -ECONNRESET:
  40. errmsg = "unlinked asynchronously";
  41. break;
  42. case -ENOSR:
  43. errmsg = "Buffer error (overrun)";
  44. break;
  45. case -EPIPE:
  46. errmsg = "Stalled (device not responding)";
  47. break;
  48. case -EOVERFLOW:
  49. errmsg = "Babble (bad cable?)";
  50. break;
  51. case -EPROTO:
  52. errmsg = "Bit-stuff error (bad cable?)";
  53. break;
  54. case -EILSEQ:
  55. errmsg = "CRC/Timeout (could be anything)";
  56. break;
  57. case -ETIME:
  58. errmsg = "Device does not respond";
  59. break;
  60. }
  61. if (packet < 0) {
  62. dprintk(dev, 1, "URB status %d [%s].\n",
  63. status, errmsg);
  64. } else {
  65. dprintk(dev, 1, "URB packet %d, status %d [%s].\n",
  66. packet, status, errmsg);
  67. }
  68. }
  69. static void tm6000_urb_received(struct urb *urb)
  70. {
  71. int ret;
  72. struct tm6000_core *dev = urb->context;
  73. switch (urb->status) {
  74. case 0:
  75. case -ETIMEDOUT:
  76. break;
  77. case -ENOENT:
  78. case -ECONNRESET:
  79. case -ESHUTDOWN:
  80. return;
  81. default:
  82. print_err_status(dev, 0, urb->status);
  83. }
  84. if (urb->actual_length > 0)
  85. dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
  86. urb->actual_length);
  87. if (dev->dvb->streams > 0) {
  88. ret = usb_submit_urb(urb, GFP_ATOMIC);
  89. if (ret < 0) {
  90. printk(KERN_ERR "tm6000: error %s\n", __func__);
  91. kfree(urb->transfer_buffer);
  92. usb_free_urb(urb);
  93. dev->dvb->bulk_urb = NULL;
  94. }
  95. }
  96. }
  97. static int tm6000_start_stream(struct tm6000_core *dev)
  98. {
  99. int ret;
  100. unsigned int pipe, size;
  101. struct tm6000_dvb *dvb = dev->dvb;
  102. printk(KERN_INFO "tm6000: got start stream request %s\n", __func__);
  103. if (dev->mode != TM6000_MODE_DIGITAL) {
  104. tm6000_init_digital_mode(dev);
  105. dev->mode = TM6000_MODE_DIGITAL;
  106. }
  107. dvb->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
  108. if (!dvb->bulk_urb)
  109. return -ENOMEM;
  110. pipe = usb_rcvbulkpipe(dev->udev, dev->bulk_in.endp->desc.bEndpointAddress
  111. & USB_ENDPOINT_NUMBER_MASK);
  112. size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
  113. size = size * 15; /* 512 x 8 or 12 or 15 */
  114. dvb->bulk_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);
  115. if (!dvb->bulk_urb->transfer_buffer) {
  116. usb_free_urb(dvb->bulk_urb);
  117. dvb->bulk_urb = NULL;
  118. return -ENOMEM;
  119. }
  120. usb_fill_bulk_urb(dvb->bulk_urb, dev->udev, pipe,
  121. dvb->bulk_urb->transfer_buffer,
  122. size,
  123. tm6000_urb_received, dev);
  124. ret = usb_clear_halt(dev->udev, pipe);
  125. if (ret < 0) {
  126. printk(KERN_ERR "tm6000: error %i in %s during pipe reset\n",
  127. ret, __func__);
  128. kfree(dvb->bulk_urb->transfer_buffer);
  129. usb_free_urb(dvb->bulk_urb);
  130. dvb->bulk_urb = NULL;
  131. return ret;
  132. } else
  133. printk(KERN_ERR "tm6000: pipe resetted\n");
  134. /* mutex_lock(&tm6000_driver.open_close_mutex); */
  135. ret = usb_submit_urb(dvb->bulk_urb, GFP_ATOMIC);
  136. /* mutex_unlock(&tm6000_driver.open_close_mutex); */
  137. if (ret) {
  138. printk(KERN_ERR "tm6000: submit of urb failed (error=%i)\n",
  139. ret);
  140. kfree(dvb->bulk_urb->transfer_buffer);
  141. usb_free_urb(dvb->bulk_urb);
  142. dvb->bulk_urb = NULL;
  143. return ret;
  144. }
  145. return 0;
  146. }
  147. static void tm6000_stop_stream(struct tm6000_core *dev)
  148. {
  149. struct tm6000_dvb *dvb = dev->dvb;
  150. if (dvb->bulk_urb) {
  151. printk(KERN_INFO "urb killing\n");
  152. usb_kill_urb(dvb->bulk_urb);
  153. printk(KERN_INFO "urb buffer free\n");
  154. kfree(dvb->bulk_urb->transfer_buffer);
  155. usb_free_urb(dvb->bulk_urb);
  156. dvb->bulk_urb = NULL;
  157. }
  158. }
  159. static int tm6000_start_feed(struct dvb_demux_feed *feed)
  160. {
  161. struct dvb_demux *demux = feed->demux;
  162. struct tm6000_core *dev = demux->priv;
  163. struct tm6000_dvb *dvb = dev->dvb;
  164. printk(KERN_INFO "tm6000: got start feed request %s\n", __func__);
  165. mutex_lock(&dvb->mutex);
  166. if (dvb->streams == 0) {
  167. dvb->streams = 1;
  168. /* mutex_init(&tm6000_dev->streming_mutex); */
  169. tm6000_start_stream(dev);
  170. } else
  171. ++(dvb->streams);
  172. mutex_unlock(&dvb->mutex);
  173. return 0;
  174. }
  175. static int tm6000_stop_feed(struct dvb_demux_feed *feed)
  176. {
  177. struct dvb_demux *demux = feed->demux;
  178. struct tm6000_core *dev = demux->priv;
  179. struct tm6000_dvb *dvb = dev->dvb;
  180. printk(KERN_INFO "tm6000: got stop feed request %s\n", __func__);
  181. mutex_lock(&dvb->mutex);
  182. printk(KERN_INFO "stream %#x\n", dvb->streams);
  183. --(dvb->streams);
  184. if (dvb->streams == 0) {
  185. printk(KERN_INFO "stop stream\n");
  186. tm6000_stop_stream(dev);
  187. /* mutex_destroy(&tm6000_dev->streaming_mutex); */
  188. }
  189. mutex_unlock(&dvb->mutex);
  190. /* mutex_destroy(&tm6000_dev->streaming_mutex); */
  191. return 0;
  192. }
  193. static int tm6000_dvb_attach_frontend(struct tm6000_core *dev)
  194. {
  195. struct tm6000_dvb *dvb = dev->dvb;
  196. if (dev->caps.has_zl10353) {
  197. struct zl10353_config config = {
  198. .demod_address = dev->demod_addr,
  199. .no_tuner = 1,
  200. .parallel_ts = 1,
  201. .if2 = 45700,
  202. .disable_i2c_gate_ctrl = 1,
  203. };
  204. dvb->frontend = dvb_attach(zl10353_attach, &config,
  205. &dev->i2c_adap);
  206. } else {
  207. printk(KERN_ERR "tm6000: no frontend defined for the device!\n");
  208. return -1;
  209. }
  210. return (!dvb->frontend) ? -1 : 0;
  211. }
  212. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  213. static int register_dvb(struct tm6000_core *dev)
  214. {
  215. int ret = -1;
  216. struct tm6000_dvb *dvb = dev->dvb;
  217. mutex_init(&dvb->mutex);
  218. dvb->streams = 0;
  219. /* attach the frontend */
  220. ret = tm6000_dvb_attach_frontend(dev);
  221. if (ret < 0) {
  222. printk(KERN_ERR "tm6000: couldn't attach the frontend!\n");
  223. goto err;
  224. }
  225. ret = dvb_register_adapter(&dvb->adapter, "Trident TVMaster 6000 DVB-T",
  226. THIS_MODULE, &dev->udev->dev, adapter_nr);
  227. if (ret < 0) {
  228. pr_err("tm6000: couldn't register the adapter!\n");
  229. goto err;
  230. }
  231. dvb->adapter.priv = dev;
  232. if (dvb->frontend) {
  233. switch (dev->tuner_type) {
  234. case TUNER_XC2028: {
  235. struct xc2028_config cfg = {
  236. .i2c_adap = &dev->i2c_adap,
  237. .i2c_addr = dev->tuner_addr,
  238. };
  239. dvb->frontend->callback = tm6000_tuner_callback;
  240. ret = dvb_register_frontend(&dvb->adapter, dvb->frontend);
  241. if (ret < 0) {
  242. printk(KERN_ERR
  243. "tm6000: couldn't register frontend\n");
  244. goto adapter_err;
  245. }
  246. if (!dvb_attach(xc2028_attach, dvb->frontend, &cfg)) {
  247. printk(KERN_ERR "tm6000: couldn't register frontend (xc3028)\n");
  248. ret = -EINVAL;
  249. goto frontend_err;
  250. }
  251. printk(KERN_INFO "tm6000: XC2028/3028 asked to be attached to frontend!\n");
  252. break;
  253. }
  254. case TUNER_XC5000: {
  255. struct xc5000_config cfg = {
  256. .i2c_address = dev->tuner_addr,
  257. };
  258. dvb->frontend->callback = tm6000_xc5000_callback;
  259. ret = dvb_register_frontend(&dvb->adapter, dvb->frontend);
  260. if (ret < 0) {
  261. printk(KERN_ERR
  262. "tm6000: couldn't register frontend\n");
  263. goto adapter_err;
  264. }
  265. if (!dvb_attach(xc5000_attach, dvb->frontend, &dev->i2c_adap, &cfg)) {
  266. printk(KERN_ERR "tm6000: couldn't register frontend (xc5000)\n");
  267. ret = -EINVAL;
  268. goto frontend_err;
  269. }
  270. printk(KERN_INFO "tm6000: XC5000 asked to be attached to frontend!\n");
  271. break;
  272. }
  273. }
  274. } else
  275. printk(KERN_ERR "tm6000: no frontend found\n");
  276. dvb->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING
  277. | DMX_MEMORY_BASED_FILTERING;
  278. dvb->demux.priv = dev;
  279. dvb->demux.filternum = 8;
  280. dvb->demux.feednum = 8;
  281. dvb->demux.start_feed = tm6000_start_feed;
  282. dvb->demux.stop_feed = tm6000_stop_feed;
  283. dvb->demux.write_to_decoder = NULL;
  284. ret = dvb_dmx_init(&dvb->demux);
  285. if (ret < 0) {
  286. printk(KERN_ERR "tm6000: dvb_dmx_init failed (errno = %d)\n", ret);
  287. goto frontend_err;
  288. }
  289. dvb->dmxdev.filternum = dev->dvb->demux.filternum;
  290. dvb->dmxdev.demux = &dev->dvb->demux.dmx;
  291. dvb->dmxdev.capabilities = 0;
  292. ret = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
  293. if (ret < 0) {
  294. printk(KERN_ERR "tm6000: dvb_dmxdev_init failed (errno = %d)\n", ret);
  295. goto dvb_dmx_err;
  296. }
  297. return 0;
  298. dvb_dmx_err:
  299. dvb_dmx_release(&dvb->demux);
  300. frontend_err:
  301. if (dvb->frontend) {
  302. dvb_unregister_frontend(dvb->frontend);
  303. dvb_frontend_detach(dvb->frontend);
  304. }
  305. adapter_err:
  306. dvb_unregister_adapter(&dvb->adapter);
  307. err:
  308. return ret;
  309. }
  310. static void unregister_dvb(struct tm6000_core *dev)
  311. {
  312. struct tm6000_dvb *dvb = dev->dvb;
  313. if (dvb->bulk_urb) {
  314. struct urb *bulk_urb = dvb->bulk_urb;
  315. kfree(bulk_urb->transfer_buffer);
  316. bulk_urb->transfer_buffer = NULL;
  317. usb_unlink_urb(bulk_urb);
  318. usb_free_urb(bulk_urb);
  319. }
  320. /* mutex_lock(&tm6000_driver.open_close_mutex); */
  321. if (dvb->frontend) {
  322. dvb_unregister_frontend(dvb->frontend);
  323. dvb_frontend_detach(dvb->frontend);
  324. }
  325. dvb_dmxdev_release(&dvb->dmxdev);
  326. dvb_dmx_release(&dvb->demux);
  327. dvb_unregister_adapter(&dvb->adapter);
  328. mutex_destroy(&dvb->mutex);
  329. /* mutex_unlock(&tm6000_driver.open_close_mutex); */
  330. }
  331. static int dvb_init(struct tm6000_core *dev)
  332. {
  333. struct tm6000_dvb *dvb;
  334. int rc;
  335. if (!dev)
  336. return 0;
  337. if (!dev->caps.has_dvb)
  338. return 0;
  339. if (dev->udev->speed == USB_SPEED_FULL) {
  340. printk(KERN_INFO "This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)\n");
  341. return 0;
  342. }
  343. dvb = kzalloc(sizeof(struct tm6000_dvb), GFP_KERNEL);
  344. if (!dvb)
  345. return -ENOMEM;
  346. dev->dvb = dvb;
  347. rc = register_dvb(dev);
  348. if (rc < 0) {
  349. kfree(dvb);
  350. dev->dvb = NULL;
  351. return 0;
  352. }
  353. return 0;
  354. }
  355. static int dvb_fini(struct tm6000_core *dev)
  356. {
  357. if (!dev)
  358. return 0;
  359. if (!dev->caps.has_dvb)
  360. return 0;
  361. if (dev->dvb) {
  362. unregister_dvb(dev);
  363. kfree(dev->dvb);
  364. dev->dvb = NULL;
  365. }
  366. return 0;
  367. }
  368. static struct tm6000_ops dvb_ops = {
  369. .type = TM6000_DVB,
  370. .name = "TM6000 dvb Extension",
  371. .init = dvb_init,
  372. .fini = dvb_fini,
  373. };
  374. static int __init tm6000_dvb_register(void)
  375. {
  376. return tm6000_register_extension(&dvb_ops);
  377. }
  378. static void __exit tm6000_dvb_unregister(void)
  379. {
  380. tm6000_unregister_extension(&dvb_ops);
  381. }
  382. module_init(tm6000_dvb_register);
  383. module_exit(tm6000_dvb_unregister);