ngene-dvb.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353
  1. /*
  2. * ngene-dvb.c: nGene PCIe bridge driver - DVB functions
  3. *
  4. * Copyright (C) 2005-2007 Micronas
  5. *
  6. * Copyright (C) 2008-2009 Ralph Metzler <rjkm@metzlerbros.de>
  7. * Modifications for new nGene firmware,
  8. * support for EEPROM-copying,
  9. * support for new dual DVB-S2 card prototype
  10. *
  11. *
  12. * This program is free software; you can redistribute it and/or
  13. * modify it under the terms of the GNU General Public License
  14. * version 2 only, as published by the Free Software Foundation.
  15. *
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. *
  22. * To obtain the license, point your browser to
  23. * http://www.gnu.org/copyleft/gpl.html
  24. */
  25. #include <linux/module.h>
  26. #include <linux/init.h>
  27. #include <linux/delay.h>
  28. #include <linux/slab.h>
  29. #include <linux/poll.h>
  30. #include <linux/io.h>
  31. #include <asm/div64.h>
  32. #include <linux/pci.h>
  33. #include <linux/timer.h>
  34. #include <linux/byteorder/generic.h>
  35. #include <linux/firmware.h>
  36. #include <linux/vmalloc.h>
  37. #include "ngene.h"
  38. static int ci_tsfix = 1;
  39. module_param(ci_tsfix, int, 0444);
  40. MODULE_PARM_DESC(ci_tsfix, "Detect and fix TS buffer offset shifts in conjunction with CI expansions (default: 1/enabled)");
  41. /****************************************************************************/
  42. /* COMMAND API interface ****************************************************/
  43. /****************************************************************************/
  44. static ssize_t ts_write(struct file *file, const char __user *buf,
  45. size_t count, loff_t *ppos)
  46. {
  47. struct dvb_device *dvbdev = file->private_data;
  48. struct ngene_channel *chan = dvbdev->priv;
  49. struct ngene *dev = chan->dev;
  50. if (wait_event_interruptible(dev->tsout_rbuf.queue,
  51. dvb_ringbuffer_free
  52. (&dev->tsout_rbuf) >= count) < 0)
  53. return 0;
  54. dvb_ringbuffer_write_user(&dev->tsout_rbuf, buf, count);
  55. return count;
  56. }
  57. static ssize_t ts_read(struct file *file, char __user *buf,
  58. size_t count, loff_t *ppos)
  59. {
  60. struct dvb_device *dvbdev = file->private_data;
  61. struct ngene_channel *chan = dvbdev->priv;
  62. struct ngene *dev = chan->dev;
  63. int left, avail;
  64. left = count;
  65. while (left) {
  66. if (wait_event_interruptible(
  67. dev->tsin_rbuf.queue,
  68. dvb_ringbuffer_avail(&dev->tsin_rbuf) > 0) < 0)
  69. return -EAGAIN;
  70. avail = dvb_ringbuffer_avail(&dev->tsin_rbuf);
  71. if (avail > left)
  72. avail = left;
  73. dvb_ringbuffer_read_user(&dev->tsin_rbuf, buf, avail);
  74. left -= avail;
  75. buf += avail;
  76. }
  77. return count;
  78. }
  79. static __poll_t ts_poll(struct file *file, poll_table *wait)
  80. {
  81. struct dvb_device *dvbdev = file->private_data;
  82. struct ngene_channel *chan = dvbdev->priv;
  83. struct ngene *dev = chan->dev;
  84. struct dvb_ringbuffer *rbuf = &dev->tsin_rbuf;
  85. struct dvb_ringbuffer *wbuf = &dev->tsout_rbuf;
  86. __poll_t mask = 0;
  87. poll_wait(file, &rbuf->queue, wait);
  88. poll_wait(file, &wbuf->queue, wait);
  89. if (!dvb_ringbuffer_empty(rbuf))
  90. mask |= EPOLLIN | EPOLLRDNORM;
  91. if (dvb_ringbuffer_free(wbuf) >= 188)
  92. mask |= EPOLLOUT | EPOLLWRNORM;
  93. return mask;
  94. }
  95. static const struct file_operations ci_fops = {
  96. .owner = THIS_MODULE,
  97. .read = ts_read,
  98. .write = ts_write,
  99. .open = dvb_generic_open,
  100. .release = dvb_generic_release,
  101. .poll = ts_poll,
  102. .mmap = NULL,
  103. };
  104. struct dvb_device ngene_dvbdev_ci = {
  105. .priv = NULL,
  106. .readers = 1,
  107. .writers = 1,
  108. .users = 2,
  109. .fops = &ci_fops,
  110. };
  111. /****************************************************************************/
  112. /* DVB functions and API interface ******************************************/
  113. /****************************************************************************/
  114. static void swap_buffer(u32 *p, u32 len)
  115. {
  116. while (len) {
  117. *p = swab32(*p);
  118. p++;
  119. len -= 4;
  120. }
  121. }
  122. /* start of filler packet */
  123. static u8 fill_ts[] = { 0x47, 0x1f, 0xff, 0x10, TS_FILLER };
  124. static int tsin_find_offset(void *buf, u32 len)
  125. {
  126. int i, l;
  127. l = len - sizeof(fill_ts);
  128. if (l <= 0)
  129. return -1;
  130. for (i = 0; i < l; i++) {
  131. if (((char *)buf)[i] == 0x47) {
  132. if (!memcmp(buf + i, fill_ts, sizeof(fill_ts)))
  133. return i % 188;
  134. }
  135. }
  136. return -1;
  137. }
  138. static inline void tsin_copy_stripped(struct ngene *dev, void *buf)
  139. {
  140. if (memcmp(buf, fill_ts, sizeof(fill_ts)) != 0) {
  141. if (dvb_ringbuffer_free(&dev->tsin_rbuf) >= 188) {
  142. dvb_ringbuffer_write(&dev->tsin_rbuf, buf, 188);
  143. wake_up(&dev->tsin_rbuf.queue);
  144. }
  145. }
  146. }
  147. void *tsin_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
  148. {
  149. struct ngene_channel *chan = priv;
  150. struct ngene *dev = chan->dev;
  151. int tsoff;
  152. if (flags & DF_SWAP32)
  153. swap_buffer(buf, len);
  154. if (dev->ci.en && chan->number == 2) {
  155. /* blindly copy buffers if ci_tsfix is disabled */
  156. if (!ci_tsfix) {
  157. while (len >= 188) {
  158. tsin_copy_stripped(dev, buf);
  159. buf += 188;
  160. len -= 188;
  161. }
  162. return NULL;
  163. }
  164. /* ci_tsfix = 1 */
  165. /*
  166. * since the remainder of the TS packet which got cut off
  167. * in the previous tsin_exchange() run is at the beginning
  168. * of the new TS buffer, append this to the temp buffer and
  169. * send it to the DVB ringbuffer afterwards.
  170. */
  171. if (chan->tsin_offset) {
  172. memcpy(&chan->tsin_buffer[(188 - chan->tsin_offset)],
  173. buf, chan->tsin_offset);
  174. tsin_copy_stripped(dev, &chan->tsin_buffer);
  175. buf += chan->tsin_offset;
  176. len -= chan->tsin_offset;
  177. }
  178. /*
  179. * copy TS packets to the DVB ringbuffer and detect new offset
  180. * shifts by checking for a valid TS SYNC byte
  181. */
  182. while (len >= 188) {
  183. if (*((char *)buf) != 0x47) {
  184. /*
  185. * no SYNC header, find new offset shift
  186. * (max. 188 bytes, tsoff will be mod 188)
  187. */
  188. tsoff = tsin_find_offset(buf, len);
  189. if (tsoff > 0) {
  190. chan->tsin_offset += tsoff;
  191. chan->tsin_offset %= 188;
  192. buf += tsoff;
  193. len -= tsoff;
  194. dev_info(&dev->pci_dev->dev,
  195. "%s(): tsin_offset shift by %d on channel %d\n",
  196. __func__, tsoff,
  197. chan->number);
  198. /*
  199. * offset corrected. re-check remaining
  200. * len for a full TS frame, break and
  201. * skip to fragment handling if < 188.
  202. */
  203. if (len < 188)
  204. break;
  205. }
  206. }
  207. tsin_copy_stripped(dev, buf);
  208. buf += 188;
  209. len -= 188;
  210. }
  211. /*
  212. * if a fragment is left, copy to temp buffer. The remainder
  213. * will be appended in the next tsin_exchange() iteration.
  214. */
  215. if (len > 0 && len < 188)
  216. memcpy(&chan->tsin_buffer, buf, len);
  217. return NULL;
  218. }
  219. if (chan->users > 0)
  220. dvb_dmx_swfilter(&chan->demux, buf, len);
  221. return NULL;
  222. }
  223. void *tsout_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
  224. {
  225. struct ngene_channel *chan = priv;
  226. struct ngene *dev = chan->dev;
  227. u32 alen;
  228. alen = dvb_ringbuffer_avail(&dev->tsout_rbuf);
  229. alen -= alen % 188;
  230. if (alen < len)
  231. FillTSBuffer(buf + alen, len - alen, flags);
  232. else
  233. alen = len;
  234. dvb_ringbuffer_read(&dev->tsout_rbuf, buf, alen);
  235. if (flags & DF_SWAP32)
  236. swap_buffer((u32 *)buf, alen);
  237. wake_up_interruptible(&dev->tsout_rbuf.queue);
  238. return buf;
  239. }
  240. int ngene_start_feed(struct dvb_demux_feed *dvbdmxfeed)
  241. {
  242. struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
  243. struct ngene_channel *chan = dvbdmx->priv;
  244. if (chan->users == 0) {
  245. if (!chan->dev->cmd_timeout_workaround || !chan->running)
  246. set_transfer(chan, 1);
  247. }
  248. return ++chan->users;
  249. }
  250. int ngene_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
  251. {
  252. struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
  253. struct ngene_channel *chan = dvbdmx->priv;
  254. if (--chan->users)
  255. return chan->users;
  256. if (!chan->dev->cmd_timeout_workaround)
  257. set_transfer(chan, 0);
  258. return 0;
  259. }
  260. int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
  261. int (*start_feed)(struct dvb_demux_feed *),
  262. int (*stop_feed)(struct dvb_demux_feed *),
  263. void *priv)
  264. {
  265. dvbdemux->priv = priv;
  266. dvbdemux->filternum = 256;
  267. dvbdemux->feednum = 256;
  268. dvbdemux->start_feed = start_feed;
  269. dvbdemux->stop_feed = stop_feed;
  270. dvbdemux->write_to_decoder = NULL;
  271. dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |
  272. DMX_SECTION_FILTERING |
  273. DMX_MEMORY_BASED_FILTERING);
  274. return dvb_dmx_init(dvbdemux);
  275. }
  276. int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
  277. struct dvb_demux *dvbdemux,
  278. struct dmx_frontend *hw_frontend,
  279. struct dmx_frontend *mem_frontend,
  280. struct dvb_adapter *dvb_adapter)
  281. {
  282. int ret;
  283. dmxdev->filternum = 256;
  284. dmxdev->demux = &dvbdemux->dmx;
  285. dmxdev->capabilities = 0;
  286. ret = dvb_dmxdev_init(dmxdev, dvb_adapter);
  287. if (ret < 0)
  288. return ret;
  289. hw_frontend->source = DMX_FRONTEND_0;
  290. dvbdemux->dmx.add_frontend(&dvbdemux->dmx, hw_frontend);
  291. mem_frontend->source = DMX_MEMORY_FE;
  292. dvbdemux->dmx.add_frontend(&dvbdemux->dmx, mem_frontend);
  293. return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
  294. }