dmabuf.c 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267
  1. /*
  2. * sound/oss/dmabuf.c
  3. *
  4. * The DMA buffer manager for digitized voice applications
  5. */
  6. /*
  7. * Copyright (C) by Hannu Savolainen 1993-1997
  8. *
  9. * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10. * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11. * for more info.
  12. *
  13. * Thomas Sailer : moved several static variables into struct audio_operations
  14. * (which is grossly misnamed btw.) because they have the same
  15. * lifetime as the rest in there and dynamic allocation saves
  16. * 12k or so
  17. * Thomas Sailer : remove {in,out}_sleep_flag. It was used for the sleeper to
  18. * determine if it was woken up by the expiring timeout or by
  19. * an explicit wake_up. The return value from schedule_timeout
  20. * can be used instead; if 0, the wakeup was due to the timeout.
  21. *
  22. * Rob Riggs Added persistent DMA buffers (1998/10/17)
  23. */
  24. #define BE_CONSERVATIVE
  25. #define SAMPLE_ROUNDUP 0
  26. #include <linux/mm.h>
  27. #include "sound_config.h"
  28. #define DMAP_FREE_ON_CLOSE 0
  29. #define DMAP_KEEP_ON_CLOSE 1
  30. extern int sound_dmap_flag;
  31. static void dma_reset_output(int dev);
  32. static void dma_reset_input(int dev);
  33. static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode);
  34. static int debugmem; /* switched off by default */
  35. static int dma_buffsize = DSP_BUFFSIZE;
  36. static long dmabuf_timeout(struct dma_buffparms *dmap)
  37. {
  38. long tmout;
  39. tmout = (dmap->fragment_size * HZ) / dmap->data_rate;
  40. tmout += HZ / 5; /* Some safety distance */
  41. if (tmout < (HZ / 2))
  42. tmout = HZ / 2;
  43. if (tmout > 20 * HZ)
  44. tmout = 20 * HZ;
  45. return tmout;
  46. }
  47. static int sound_alloc_dmap(struct dma_buffparms *dmap)
  48. {
  49. char *start_addr, *end_addr;
  50. int dma_pagesize;
  51. int sz, size;
  52. struct page *page;
  53. dmap->mapping_flags &= ~DMA_MAP_MAPPED;
  54. if (dmap->raw_buf != NULL)
  55. return 0; /* Already done */
  56. if (dma_buffsize < 4096)
  57. dma_buffsize = 4096;
  58. dma_pagesize = (dmap->dma < 4) ? (64 * 1024) : (128 * 1024);
  59. /*
  60. * Now check for the Cyrix problem.
  61. */
  62. if(isa_dma_bridge_buggy==2)
  63. dma_pagesize=32768;
  64. dmap->raw_buf = NULL;
  65. dmap->buffsize = dma_buffsize;
  66. if (dmap->buffsize > dma_pagesize)
  67. dmap->buffsize = dma_pagesize;
  68. start_addr = NULL;
  69. /*
  70. * Now loop until we get a free buffer. Try to get smaller buffer if
  71. * it fails. Don't accept smaller than 8k buffer for performance
  72. * reasons.
  73. */
  74. while (start_addr == NULL && dmap->buffsize > PAGE_SIZE) {
  75. for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
  76. dmap->buffsize = PAGE_SIZE * (1 << sz);
  77. start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA|__GFP_NOWARN, sz);
  78. if (start_addr == NULL)
  79. dmap->buffsize /= 2;
  80. }
  81. if (start_addr == NULL) {
  82. printk(KERN_WARNING "Sound error: Couldn't allocate DMA buffer\n");
  83. return -ENOMEM;
  84. } else {
  85. /* make some checks */
  86. end_addr = start_addr + dmap->buffsize - 1;
  87. if (debugmem)
  88. printk(KERN_DEBUG "sound: start 0x%lx, end 0x%lx\n", (long) start_addr, (long) end_addr);
  89. /* now check if it fits into the same dma-pagesize */
  90. if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
  91. || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
  92. printk(KERN_ERR "sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, dmap->buffsize);
  93. return -EFAULT;
  94. }
  95. }
  96. dmap->raw_buf = start_addr;
  97. dmap->raw_buf_phys = virt_to_bus(start_addr);
  98. for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
  99. SetPageReserved(page);
  100. return 0;
  101. }
  102. static void sound_free_dmap(struct dma_buffparms *dmap)
  103. {
  104. int sz, size;
  105. struct page *page;
  106. unsigned long start_addr, end_addr;
  107. if (dmap->raw_buf == NULL)
  108. return;
  109. if (dmap->mapping_flags & DMA_MAP_MAPPED)
  110. return; /* Don't free mmapped buffer. Will use it next time */
  111. for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
  112. start_addr = (unsigned long) dmap->raw_buf;
  113. end_addr = start_addr + dmap->buffsize;
  114. for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
  115. ClearPageReserved(page);
  116. free_pages((unsigned long) dmap->raw_buf, sz);
  117. dmap->raw_buf = NULL;
  118. }
  119. /* Intel version !!!!!!!!! */
  120. static int sound_start_dma(struct dma_buffparms *dmap, unsigned long physaddr, int count, int dma_mode)
  121. {
  122. unsigned long flags;
  123. int chan = dmap->dma;
  124. /* printk( "Start DMA%d %d, %d\n", chan, (int)(physaddr-dmap->raw_buf_phys), count); */
  125. flags = claim_dma_lock();
  126. disable_dma(chan);
  127. clear_dma_ff(chan);
  128. set_dma_mode(chan, dma_mode);
  129. set_dma_addr(chan, physaddr);
  130. set_dma_count(chan, count);
  131. enable_dma(chan);
  132. release_dma_lock(flags);
  133. return 0;
  134. }
  135. static void dma_init_buffers(struct dma_buffparms *dmap)
  136. {
  137. dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
  138. dmap->byte_counter = 0;
  139. dmap->max_byte_counter = 8000 * 60 * 60;
  140. dmap->bytes_in_use = dmap->buffsize;
  141. dmap->dma_mode = DMODE_NONE;
  142. dmap->mapping_flags = 0;
  143. dmap->neutral_byte = 0x80;
  144. dmap->data_rate = 8000;
  145. dmap->cfrag = -1;
  146. dmap->closing = 0;
  147. dmap->nbufs = 1;
  148. dmap->flags = DMA_BUSY; /* Other flags off */
  149. }
  150. static int open_dmap(struct audio_operations *adev, int mode, struct dma_buffparms *dmap)
  151. {
  152. int err;
  153. if (dmap->flags & DMA_BUSY)
  154. return -EBUSY;
  155. if ((err = sound_alloc_dmap(dmap)) < 0)
  156. return err;
  157. if (dmap->raw_buf == NULL) {
  158. printk(KERN_WARNING "Sound: DMA buffers not available\n");
  159. return -ENOSPC; /* Memory allocation failed during boot */
  160. }
  161. if (dmap->dma >= 0 && sound_open_dma(dmap->dma, adev->name)) {
  162. printk(KERN_WARNING "Unable to grab(2) DMA%d for the audio driver\n", dmap->dma);
  163. return -EBUSY;
  164. }
  165. dma_init_buffers(dmap);
  166. spin_lock_init(&dmap->lock);
  167. dmap->open_mode = mode;
  168. dmap->subdivision = dmap->underrun_count = 0;
  169. dmap->fragment_size = 0;
  170. dmap->max_fragments = 65536; /* Just a large value */
  171. dmap->byte_counter = 0;
  172. dmap->max_byte_counter = 8000 * 60 * 60;
  173. dmap->applic_profile = APF_NORMAL;
  174. dmap->needs_reorg = 1;
  175. dmap->audio_callback = NULL;
  176. dmap->callback_parm = 0;
  177. return 0;
  178. }
  179. static void close_dmap(struct audio_operations *adev, struct dma_buffparms *dmap)
  180. {
  181. unsigned long flags;
  182. if (dmap->dma >= 0) {
  183. sound_close_dma(dmap->dma);
  184. flags=claim_dma_lock();
  185. disable_dma(dmap->dma);
  186. release_dma_lock(flags);
  187. }
  188. if (dmap->flags & DMA_BUSY)
  189. dmap->dma_mode = DMODE_NONE;
  190. dmap->flags &= ~DMA_BUSY;
  191. if (sound_dmap_flag == DMAP_FREE_ON_CLOSE)
  192. sound_free_dmap(dmap);
  193. }
  194. static unsigned int default_set_bits(int dev, unsigned int bits)
  195. {
  196. mm_segment_t fs = get_fs();
  197. set_fs(get_ds());
  198. audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SETFMT, (void __user *)&bits);
  199. set_fs(fs);
  200. return bits;
  201. }
  202. static int default_set_speed(int dev, int speed)
  203. {
  204. mm_segment_t fs = get_fs();
  205. set_fs(get_ds());
  206. audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SPEED, (void __user *)&speed);
  207. set_fs(fs);
  208. return speed;
  209. }
  210. static short default_set_channels(int dev, short channels)
  211. {
  212. int c = channels;
  213. mm_segment_t fs = get_fs();
  214. set_fs(get_ds());
  215. audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_CHANNELS, (void __user *)&c);
  216. set_fs(fs);
  217. return c;
  218. }
  219. static void check_driver(struct audio_driver *d)
  220. {
  221. if (d->set_speed == NULL)
  222. d->set_speed = default_set_speed;
  223. if (d->set_bits == NULL)
  224. d->set_bits = default_set_bits;
  225. if (d->set_channels == NULL)
  226. d->set_channels = default_set_channels;
  227. }
  228. int DMAbuf_open(int dev, int mode)
  229. {
  230. struct audio_operations *adev = audio_devs[dev];
  231. int retval;
  232. struct dma_buffparms *dmap_in = NULL;
  233. struct dma_buffparms *dmap_out = NULL;
  234. if (!adev)
  235. return -ENXIO;
  236. if (!(adev->flags & DMA_DUPLEX))
  237. adev->dmap_in = adev->dmap_out;
  238. check_driver(adev->d);
  239. if ((retval = adev->d->open(dev, mode)) < 0)
  240. return retval;
  241. dmap_out = adev->dmap_out;
  242. dmap_in = adev->dmap_in;
  243. if (dmap_in == dmap_out)
  244. adev->flags &= ~DMA_DUPLEX;
  245. if (mode & OPEN_WRITE) {
  246. if ((retval = open_dmap(adev, mode, dmap_out)) < 0) {
  247. adev->d->close(dev);
  248. return retval;
  249. }
  250. }
  251. adev->enable_bits = mode;
  252. if (mode == OPEN_READ || (mode != OPEN_WRITE && (adev->flags & DMA_DUPLEX))) {
  253. if ((retval = open_dmap(adev, mode, dmap_in)) < 0) {
  254. adev->d->close(dev);
  255. if (mode & OPEN_WRITE)
  256. close_dmap(adev, dmap_out);
  257. return retval;
  258. }
  259. }
  260. adev->open_mode = mode;
  261. adev->go = 1;
  262. adev->d->set_bits(dev, 8);
  263. adev->d->set_channels(dev, 1);
  264. adev->d->set_speed(dev, DSP_DEFAULT_SPEED);
  265. if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
  266. memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
  267. adev->dmap_out->bytes_in_use);
  268. return 0;
  269. }
  270. /* MUST not hold the spinlock */
  271. void DMAbuf_reset(int dev)
  272. {
  273. if (audio_devs[dev]->open_mode & OPEN_WRITE)
  274. dma_reset_output(dev);
  275. if (audio_devs[dev]->open_mode & OPEN_READ)
  276. dma_reset_input(dev);
  277. }
  278. static void dma_reset_output(int dev)
  279. {
  280. struct audio_operations *adev = audio_devs[dev];
  281. unsigned long flags,f ;
  282. struct dma_buffparms *dmap = adev->dmap_out;
  283. if (!(dmap->flags & DMA_STARTED)) /* DMA is not active */
  284. return;
  285. /*
  286. * First wait until the current fragment has been played completely
  287. */
  288. spin_lock_irqsave(&dmap->lock,flags);
  289. adev->dmap_out->flags |= DMA_SYNCING;
  290. adev->dmap_out->underrun_count = 0;
  291. if (!signal_pending(current) && adev->dmap_out->qlen &&
  292. adev->dmap_out->underrun_count == 0){
  293. spin_unlock_irqrestore(&dmap->lock,flags);
  294. interruptible_sleep_on_timeout(&adev->out_sleeper,
  295. dmabuf_timeout(dmap));
  296. spin_lock_irqsave(&dmap->lock,flags);
  297. }
  298. adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
  299. /*
  300. * Finally shut the device off
  301. */
  302. if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_output)
  303. adev->d->halt_io(dev);
  304. else
  305. adev->d->halt_output(dev);
  306. adev->dmap_out->flags &= ~DMA_STARTED;
  307. f=claim_dma_lock();
  308. clear_dma_ff(dmap->dma);
  309. disable_dma(dmap->dma);
  310. release_dma_lock(f);
  311. dmap->byte_counter = 0;
  312. reorganize_buffers(dev, adev->dmap_out, 0);
  313. dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
  314. spin_unlock_irqrestore(&dmap->lock,flags);
  315. }
  316. static void dma_reset_input(int dev)
  317. {
  318. struct audio_operations *adev = audio_devs[dev];
  319. unsigned long flags;
  320. struct dma_buffparms *dmap = adev->dmap_in;
  321. spin_lock_irqsave(&dmap->lock,flags);
  322. if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_input)
  323. adev->d->halt_io(dev);
  324. else
  325. adev->d->halt_input(dev);
  326. adev->dmap_in->flags &= ~DMA_STARTED;
  327. dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
  328. dmap->byte_counter = 0;
  329. reorganize_buffers(dev, adev->dmap_in, 1);
  330. spin_unlock_irqrestore(&dmap->lock,flags);
  331. }
  332. /* MUST be called with holding the dmap->lock */
  333. void DMAbuf_launch_output(int dev, struct dma_buffparms *dmap)
  334. {
  335. struct audio_operations *adev = audio_devs[dev];
  336. if (!((adev->enable_bits * adev->go) & PCM_ENABLE_OUTPUT))
  337. return; /* Don't start DMA yet */
  338. dmap->dma_mode = DMODE_OUTPUT;
  339. if (!(dmap->flags & DMA_ACTIVE) || !(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
  340. if (!(dmap->flags & DMA_STARTED)) {
  341. reorganize_buffers(dev, dmap, 0);
  342. if (adev->d->prepare_for_output(dev, dmap->fragment_size, dmap->nbufs))
  343. return;
  344. if (!(dmap->flags & DMA_NODMA))
  345. local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_WRITE);
  346. dmap->flags |= DMA_STARTED;
  347. }
  348. if (dmap->counts[dmap->qhead] == 0)
  349. dmap->counts[dmap->qhead] = dmap->fragment_size;
  350. dmap->dma_mode = DMODE_OUTPUT;
  351. adev->d->output_block(dev, dmap->raw_buf_phys + dmap->qhead * dmap->fragment_size,
  352. dmap->counts[dmap->qhead], 1);
  353. if (adev->d->trigger)
  354. adev->d->trigger(dev,adev->enable_bits * adev->go);
  355. }
  356. dmap->flags |= DMA_ACTIVE;
  357. }
  358. int DMAbuf_sync(int dev)
  359. {
  360. struct audio_operations *adev = audio_devs[dev];
  361. unsigned long flags;
  362. int n = 0;
  363. struct dma_buffparms *dmap;
  364. if (!adev->go && !(adev->enable_bits & PCM_ENABLE_OUTPUT))
  365. return 0;
  366. if (adev->dmap_out->dma_mode == DMODE_OUTPUT) {
  367. dmap = adev->dmap_out;
  368. spin_lock_irqsave(&dmap->lock,flags);
  369. if (dmap->qlen > 0 && !(dmap->flags & DMA_ACTIVE))
  370. DMAbuf_launch_output(dev, dmap);
  371. adev->dmap_out->flags |= DMA_SYNCING;
  372. adev->dmap_out->underrun_count = 0;
  373. while (!signal_pending(current) && n++ <= adev->dmap_out->nbufs &&
  374. adev->dmap_out->qlen && adev->dmap_out->underrun_count == 0) {
  375. long t = dmabuf_timeout(dmap);
  376. spin_unlock_irqrestore(&dmap->lock,flags);
  377. /* FIXME: not safe may miss events */
  378. t = interruptible_sleep_on_timeout(&adev->out_sleeper, t);
  379. spin_lock_irqsave(&dmap->lock,flags);
  380. if (!t) {
  381. adev->dmap_out->flags &= ~DMA_SYNCING;
  382. spin_unlock_irqrestore(&dmap->lock,flags);
  383. return adev->dmap_out->qlen;
  384. }
  385. }
  386. adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
  387. /*
  388. * Some devices such as GUS have huge amount of on board RAM for the
  389. * audio data. We have to wait until the device has finished playing.
  390. */
  391. /* still holding the lock */
  392. if (adev->d->local_qlen) { /* Device has hidden buffers */
  393. while (!signal_pending(current) &&
  394. adev->d->local_qlen(dev)){
  395. spin_unlock_irqrestore(&dmap->lock,flags);
  396. interruptible_sleep_on_timeout(&adev->out_sleeper,
  397. dmabuf_timeout(dmap));
  398. spin_lock_irqsave(&dmap->lock,flags);
  399. }
  400. }
  401. spin_unlock_irqrestore(&dmap->lock,flags);
  402. }
  403. adev->dmap_out->dma_mode = DMODE_NONE;
  404. return adev->dmap_out->qlen;
  405. }
  406. int DMAbuf_release(int dev, int mode)
  407. {
  408. struct audio_operations *adev = audio_devs[dev];
  409. struct dma_buffparms *dmap;
  410. unsigned long flags;
  411. dmap = adev->dmap_out;
  412. if (adev->open_mode & OPEN_WRITE)
  413. adev->dmap_out->closing = 1;
  414. if (adev->open_mode & OPEN_READ){
  415. adev->dmap_in->closing = 1;
  416. dmap = adev->dmap_in;
  417. }
  418. if (adev->open_mode & OPEN_WRITE)
  419. if (!(adev->dmap_out->mapping_flags & DMA_MAP_MAPPED))
  420. if (!signal_pending(current) && (adev->dmap_out->dma_mode == DMODE_OUTPUT))
  421. DMAbuf_sync(dev);
  422. if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
  423. memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte, adev->dmap_out->bytes_in_use);
  424. DMAbuf_reset(dev);
  425. spin_lock_irqsave(&dmap->lock,flags);
  426. adev->d->close(dev);
  427. if (adev->open_mode & OPEN_WRITE)
  428. close_dmap(adev, adev->dmap_out);
  429. if (adev->open_mode == OPEN_READ ||
  430. (adev->open_mode != OPEN_WRITE &&
  431. (adev->flags & DMA_DUPLEX)))
  432. close_dmap(adev, adev->dmap_in);
  433. adev->open_mode = 0;
  434. spin_unlock_irqrestore(&dmap->lock,flags);
  435. return 0;
  436. }
  437. /* called with dmap->lock dold */
  438. int DMAbuf_activate_recording(int dev, struct dma_buffparms *dmap)
  439. {
  440. struct audio_operations *adev = audio_devs[dev];
  441. int err;
  442. if (!(adev->open_mode & OPEN_READ))
  443. return 0;
  444. if (!(adev->enable_bits & PCM_ENABLE_INPUT))
  445. return 0;
  446. if (dmap->dma_mode == DMODE_OUTPUT) { /* Direction change */
  447. /* release lock - it's not recursive */
  448. spin_unlock_irq(&dmap->lock);
  449. DMAbuf_sync(dev);
  450. DMAbuf_reset(dev);
  451. spin_lock_irq(&dmap->lock);
  452. dmap->dma_mode = DMODE_NONE;
  453. }
  454. if (!dmap->dma_mode) {
  455. reorganize_buffers(dev, dmap, 1);
  456. if ((err = adev->d->prepare_for_input(dev,
  457. dmap->fragment_size, dmap->nbufs)) < 0)
  458. return err;
  459. dmap->dma_mode = DMODE_INPUT;
  460. }
  461. if (!(dmap->flags & DMA_ACTIVE)) {
  462. if (dmap->needs_reorg)
  463. reorganize_buffers(dev, dmap, 0);
  464. local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
  465. adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
  466. dmap->fragment_size, 0);
  467. dmap->flags |= DMA_ACTIVE;
  468. if (adev->d->trigger)
  469. adev->d->trigger(dev, adev->enable_bits * adev->go);
  470. }
  471. return 0;
  472. }
  473. /* acquires lock */
  474. int DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
  475. {
  476. struct audio_operations *adev = audio_devs[dev];
  477. unsigned long flags;
  478. int err = 0, n = 0;
  479. struct dma_buffparms *dmap = adev->dmap_in;
  480. int go;
  481. if (!(adev->open_mode & OPEN_READ))
  482. return -EIO;
  483. spin_lock_irqsave(&dmap->lock,flags);
  484. if (dmap->needs_reorg)
  485. reorganize_buffers(dev, dmap, 0);
  486. if (adev->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
  487. /* printk(KERN_WARNING "Sound: Can't read from mmapped device (1)\n");*/
  488. spin_unlock_irqrestore(&dmap->lock,flags);
  489. return -EINVAL;
  490. } else while (dmap->qlen <= 0 && n++ < 10) {
  491. long timeout = MAX_SCHEDULE_TIMEOUT;
  492. if (!(adev->enable_bits & PCM_ENABLE_INPUT) || !adev->go) {
  493. spin_unlock_irqrestore(&dmap->lock,flags);
  494. return -EAGAIN;
  495. }
  496. if ((err = DMAbuf_activate_recording(dev, dmap)) < 0) {
  497. spin_unlock_irqrestore(&dmap->lock,flags);
  498. return err;
  499. }
  500. /* Wait for the next block */
  501. if (dontblock) {
  502. spin_unlock_irqrestore(&dmap->lock,flags);
  503. return -EAGAIN;
  504. }
  505. if ((go = adev->go))
  506. timeout = dmabuf_timeout(dmap);
  507. spin_unlock_irqrestore(&dmap->lock,flags);
  508. timeout = interruptible_sleep_on_timeout(&adev->in_sleeper,
  509. timeout);
  510. if (!timeout) {
  511. /* FIXME: include device name */
  512. err = -EIO;
  513. printk(KERN_WARNING "Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
  514. dma_reset_input(dev);
  515. } else
  516. err = -EINTR;
  517. spin_lock_irqsave(&dmap->lock,flags);
  518. }
  519. spin_unlock_irqrestore(&dmap->lock,flags);
  520. if (dmap->qlen <= 0)
  521. return err ? err : -EINTR;
  522. *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
  523. *len = dmap->fragment_size - dmap->counts[dmap->qhead];
  524. return dmap->qhead;
  525. }
  526. int DMAbuf_rmchars(int dev, int buff_no, int c)
  527. {
  528. struct audio_operations *adev = audio_devs[dev];
  529. struct dma_buffparms *dmap = adev->dmap_in;
  530. int p = dmap->counts[dmap->qhead] + c;
  531. if (dmap->mapping_flags & DMA_MAP_MAPPED)
  532. {
  533. /* printk("Sound: Can't read from mmapped device (2)\n");*/
  534. return -EINVAL;
  535. }
  536. else if (dmap->qlen <= 0)
  537. return -EIO;
  538. else if (p >= dmap->fragment_size) { /* This buffer is completely empty */
  539. dmap->counts[dmap->qhead] = 0;
  540. dmap->qlen--;
  541. dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
  542. }
  543. else dmap->counts[dmap->qhead] = p;
  544. return 0;
  545. }
  546. /* MUST be called with dmap->lock hold */
  547. int DMAbuf_get_buffer_pointer(int dev, struct dma_buffparms *dmap, int direction)
  548. {
  549. /*
  550. * Try to approximate the active byte position of the DMA pointer within the
  551. * buffer area as well as possible.
  552. */
  553. int pos;
  554. unsigned long f;
  555. if (!(dmap->flags & DMA_ACTIVE))
  556. pos = 0;
  557. else {
  558. int chan = dmap->dma;
  559. f=claim_dma_lock();
  560. clear_dma_ff(chan);
  561. if(!isa_dma_bridge_buggy)
  562. disable_dma(dmap->dma);
  563. pos = get_dma_residue(chan);
  564. pos = dmap->bytes_in_use - pos;
  565. if (!(dmap->mapping_flags & DMA_MAP_MAPPED)) {
  566. if (direction == DMODE_OUTPUT) {
  567. if (dmap->qhead == 0)
  568. if (pos > dmap->fragment_size)
  569. pos = 0;
  570. } else {
  571. if (dmap->qtail == 0)
  572. if (pos > dmap->fragment_size)
  573. pos = 0;
  574. }
  575. }
  576. if (pos < 0)
  577. pos = 0;
  578. if (pos >= dmap->bytes_in_use)
  579. pos = 0;
  580. if(!isa_dma_bridge_buggy)
  581. enable_dma(dmap->dma);
  582. release_dma_lock(f);
  583. }
  584. /* printk( "%04x ", pos); */
  585. return pos;
  586. }
  587. /*
  588. * DMAbuf_start_devices() is called by the /dev/music driver to start
  589. * one or more audio devices at desired moment.
  590. */
  591. void DMAbuf_start_devices(unsigned int devmask)
  592. {
  593. struct audio_operations *adev;
  594. int dev;
  595. for (dev = 0; dev < num_audiodevs; dev++) {
  596. if (!(devmask & (1 << dev)))
  597. continue;
  598. if (!(adev = audio_devs[dev]))
  599. continue;
  600. if (adev->open_mode == 0)
  601. continue;
  602. if (adev->go)
  603. continue;
  604. /* OK to start the device */
  605. adev->go = 1;
  606. if (adev->d->trigger)
  607. adev->d->trigger(dev,adev->enable_bits * adev->go);
  608. }
  609. }
  610. /* via poll called without a lock ?*/
  611. int DMAbuf_space_in_queue(int dev)
  612. {
  613. struct audio_operations *adev = audio_devs[dev];
  614. int len, max, tmp;
  615. struct dma_buffparms *dmap = adev->dmap_out;
  616. int lim = dmap->nbufs;
  617. if (lim < 2)
  618. lim = 2;
  619. if (dmap->qlen >= lim) /* No space at all */
  620. return 0;
  621. /*
  622. * Verify that there are no more pending buffers than the limit
  623. * defined by the process.
  624. */
  625. max = dmap->max_fragments;
  626. if (max > lim)
  627. max = lim;
  628. len = dmap->qlen;
  629. if (adev->d->local_qlen) {
  630. tmp = adev->d->local_qlen(dev);
  631. if (tmp && len)
  632. tmp--; /* This buffer has been counted twice */
  633. len += tmp;
  634. }
  635. if (dmap->byte_counter % dmap->fragment_size) /* There is a partial fragment */
  636. len = len + 1;
  637. if (len >= max)
  638. return 0;
  639. return max - len;
  640. }
  641. /* MUST not hold the spinlock - this function may sleep */
  642. static int output_sleep(int dev, int dontblock)
  643. {
  644. struct audio_operations *adev = audio_devs[dev];
  645. int err = 0;
  646. struct dma_buffparms *dmap = adev->dmap_out;
  647. long timeout;
  648. long timeout_value;
  649. if (dontblock)
  650. return -EAGAIN;
  651. if (!(adev->enable_bits & PCM_ENABLE_OUTPUT))
  652. return -EAGAIN;
  653. /*
  654. * Wait for free space
  655. */
  656. if (signal_pending(current))
  657. return -EINTR;
  658. timeout = (adev->go && !(dmap->flags & DMA_NOTIMEOUT));
  659. if (timeout)
  660. timeout_value = dmabuf_timeout(dmap);
  661. else
  662. timeout_value = MAX_SCHEDULE_TIMEOUT;
  663. timeout_value = interruptible_sleep_on_timeout(&adev->out_sleeper,
  664. timeout_value);
  665. if (timeout != MAX_SCHEDULE_TIMEOUT && !timeout_value) {
  666. printk(KERN_WARNING "Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
  667. dma_reset_output(dev);
  668. } else {
  669. if (signal_pending(current))
  670. err = -EINTR;
  671. }
  672. return err;
  673. }
  674. /* called with the lock held */
  675. static int find_output_space(int dev, char **buf, int *size)
  676. {
  677. struct audio_operations *adev = audio_devs[dev];
  678. struct dma_buffparms *dmap = adev->dmap_out;
  679. unsigned long active_offs;
  680. long len, offs;
  681. int maxfrags;
  682. int occupied_bytes = (dmap->user_counter % dmap->fragment_size);
  683. *buf = dmap->raw_buf;
  684. if (!(maxfrags = DMAbuf_space_in_queue(dev)) && !occupied_bytes)
  685. return 0;
  686. #ifdef BE_CONSERVATIVE
  687. active_offs = dmap->byte_counter + dmap->qhead * dmap->fragment_size;
  688. #else
  689. active_offs = DMAbuf_get_buffer_pointer(dev, dmap, DMODE_OUTPUT);
  690. /* Check for pointer wrapping situation */
  691. if (active_offs < 0 || active_offs >= dmap->bytes_in_use)
  692. active_offs = 0;
  693. active_offs += dmap->byte_counter;
  694. #endif
  695. offs = (dmap->user_counter % dmap->bytes_in_use) & ~SAMPLE_ROUNDUP;
  696. if (offs < 0 || offs >= dmap->bytes_in_use) {
  697. printk(KERN_ERR "Sound: Got unexpected offs %ld. Giving up.\n", offs);
  698. printk("Counter = %ld, bytes=%d\n", dmap->user_counter, dmap->bytes_in_use);
  699. return 0;
  700. }
  701. *buf = dmap->raw_buf + offs;
  702. len = active_offs + dmap->bytes_in_use - dmap->user_counter; /* Number of unused bytes in buffer */
  703. if ((offs + len) > dmap->bytes_in_use)
  704. len = dmap->bytes_in_use - offs;
  705. if (len < 0) {
  706. return 0;
  707. }
  708. if (len > ((maxfrags * dmap->fragment_size) - occupied_bytes))
  709. len = (maxfrags * dmap->fragment_size) - occupied_bytes;
  710. *size = len & ~SAMPLE_ROUNDUP;
  711. return (*size > 0);
  712. }
  713. /* acquires lock */
  714. int DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
  715. {
  716. struct audio_operations *adev = audio_devs[dev];
  717. unsigned long flags;
  718. int err = -EIO;
  719. struct dma_buffparms *dmap = adev->dmap_out;
  720. if (dmap->mapping_flags & DMA_MAP_MAPPED) {
  721. /* printk(KERN_DEBUG "Sound: Can't write to mmapped device (3)\n");*/
  722. return -EINVAL;
  723. }
  724. spin_lock_irqsave(&dmap->lock,flags);
  725. if (dmap->needs_reorg)
  726. reorganize_buffers(dev, dmap, 0);
  727. if (dmap->dma_mode == DMODE_INPUT) { /* Direction change */
  728. spin_unlock_irqrestore(&dmap->lock,flags);
  729. DMAbuf_reset(dev);
  730. spin_lock_irqsave(&dmap->lock,flags);
  731. }
  732. dmap->dma_mode = DMODE_OUTPUT;
  733. while (find_output_space(dev, buf, size) <= 0) {
  734. spin_unlock_irqrestore(&dmap->lock,flags);
  735. if ((err = output_sleep(dev, dontblock)) < 0) {
  736. return err;
  737. }
  738. spin_lock_irqsave(&dmap->lock,flags);
  739. }
  740. spin_unlock_irqrestore(&dmap->lock,flags);
  741. return 0;
  742. }
  743. /* has to acquire dmap->lock */
  744. int DMAbuf_move_wrpointer(int dev, int l)
  745. {
  746. struct audio_operations *adev = audio_devs[dev];
  747. struct dma_buffparms *dmap = adev->dmap_out;
  748. unsigned long ptr;
  749. unsigned long end_ptr, p;
  750. int post;
  751. unsigned long flags;
  752. spin_lock_irqsave(&dmap->lock,flags);
  753. post= (dmap->flags & DMA_POST);
  754. ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
  755. dmap->flags &= ~DMA_POST;
  756. dmap->cfrag = -1;
  757. dmap->user_counter += l;
  758. dmap->flags |= DMA_DIRTY;
  759. if (dmap->byte_counter >= dmap->max_byte_counter) {
  760. /* Wrap the byte counters */
  761. long decr = dmap->byte_counter;
  762. dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
  763. decr -= dmap->byte_counter;
  764. dmap->user_counter -= decr;
  765. }
  766. end_ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
  767. p = (dmap->user_counter - 1) % dmap->bytes_in_use;
  768. dmap->neutral_byte = dmap->raw_buf[p];
  769. /* Update the fragment based bookkeeping too */
  770. while (ptr < end_ptr) {
  771. dmap->counts[dmap->qtail] = dmap->fragment_size;
  772. dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
  773. dmap->qlen++;
  774. ptr += dmap->fragment_size;
  775. }
  776. dmap->counts[dmap->qtail] = dmap->user_counter - ptr;
  777. /*
  778. * Let the low level driver perform some postprocessing to
  779. * the written data.
  780. */
  781. if (adev->d->postprocess_write)
  782. adev->d->postprocess_write(dev);
  783. if (!(dmap->flags & DMA_ACTIVE))
  784. if (dmap->qlen > 1 || (dmap->qlen > 0 && (post || dmap->qlen >= dmap->nbufs - 1)))
  785. DMAbuf_launch_output(dev, dmap);
  786. spin_unlock_irqrestore(&dmap->lock,flags);
  787. return 0;
  788. }
  789. int DMAbuf_start_dma(int dev, unsigned long physaddr, int count, int dma_mode)
  790. {
  791. struct audio_operations *adev = audio_devs[dev];
  792. struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
  793. if (dmap->raw_buf == NULL) {
  794. printk(KERN_ERR "sound: DMA buffer(1) == NULL\n");
  795. printk("Device %d, chn=%s\n", dev, (dmap == adev->dmap_out) ? "out" : "in");
  796. return 0;
  797. }
  798. if (dmap->dma < 0)
  799. return 0;
  800. sound_start_dma(dmap, physaddr, count, dma_mode);
  801. return count;
  802. }
  803. EXPORT_SYMBOL(DMAbuf_start_dma);
  804. static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode)
  805. {
  806. struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
  807. if (dmap->raw_buf == NULL) {
  808. printk(KERN_ERR "sound: DMA buffer(2) == NULL\n");
  809. printk(KERN_ERR "Device %s, chn=%s\n", adev->name, (dmap == adev->dmap_out) ? "out" : "in");
  810. return 0;
  811. }
  812. if (dmap->flags & DMA_NODMA)
  813. return 1;
  814. if (dmap->dma < 0)
  815. return 0;
  816. sound_start_dma(dmap, dmap->raw_buf_phys, dmap->bytes_in_use, dma_mode | DMA_AUTOINIT);
  817. dmap->flags |= DMA_STARTED;
  818. return count;
  819. }
  820. static void finish_output_interrupt(int dev, struct dma_buffparms *dmap)
  821. {
  822. struct audio_operations *adev = audio_devs[dev];
  823. if (dmap->audio_callback != NULL)
  824. dmap->audio_callback(dev, dmap->callback_parm);
  825. wake_up(&adev->out_sleeper);
  826. wake_up(&adev->poll_sleeper);
  827. }
  828. /* called with dmap->lock held in irq context*/
  829. static void do_outputintr(int dev, int dummy)
  830. {
  831. struct audio_operations *adev = audio_devs[dev];
  832. struct dma_buffparms *dmap = adev->dmap_out;
  833. int this_fragment;
  834. if (dmap->raw_buf == NULL) {
  835. printk(KERN_ERR "Sound: Error. Audio interrupt (%d) after freeing buffers.\n", dev);
  836. return;
  837. }
  838. if (dmap->mapping_flags & DMA_MAP_MAPPED) { /* Virtual memory mapped access */
  839. /* mmapped access */
  840. dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
  841. if (dmap->qhead == 0) { /* Wrapped */
  842. dmap->byte_counter += dmap->bytes_in_use;
  843. if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
  844. long decr = dmap->byte_counter;
  845. dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
  846. decr -= dmap->byte_counter;
  847. dmap->user_counter -= decr;
  848. }
  849. }
  850. dmap->qlen++; /* Yes increment it (don't decrement) */
  851. if (!(adev->flags & DMA_AUTOMODE))
  852. dmap->flags &= ~DMA_ACTIVE;
  853. dmap->counts[dmap->qhead] = dmap->fragment_size;
  854. DMAbuf_launch_output(dev, dmap);
  855. finish_output_interrupt(dev, dmap);
  856. return;
  857. }
  858. dmap->qlen--;
  859. this_fragment = dmap->qhead;
  860. dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
  861. if (dmap->qhead == 0) { /* Wrapped */
  862. dmap->byte_counter += dmap->bytes_in_use;
  863. if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
  864. long decr = dmap->byte_counter;
  865. dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
  866. decr -= dmap->byte_counter;
  867. dmap->user_counter -= decr;
  868. }
  869. }
  870. if (!(adev->flags & DMA_AUTOMODE))
  871. dmap->flags &= ~DMA_ACTIVE;
  872. /*
  873. * This is dmap->qlen <= 0 except when closing when
  874. * dmap->qlen < 0
  875. */
  876. while (dmap->qlen <= -dmap->closing) {
  877. dmap->underrun_count++;
  878. dmap->qlen++;
  879. if ((dmap->flags & DMA_DIRTY) && dmap->applic_profile != APF_CPUINTENS) {
  880. dmap->flags &= ~DMA_DIRTY;
  881. memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
  882. adev->dmap_out->buffsize);
  883. }
  884. dmap->user_counter += dmap->fragment_size;
  885. dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
  886. }
  887. if (dmap->qlen > 0)
  888. DMAbuf_launch_output(dev, dmap);
  889. finish_output_interrupt(dev, dmap);
  890. }
  891. /* called in irq context */
  892. void DMAbuf_outputintr(int dev, int notify_only)
  893. {
  894. struct audio_operations *adev = audio_devs[dev];
  895. unsigned long flags;
  896. struct dma_buffparms *dmap = adev->dmap_out;
  897. spin_lock_irqsave(&dmap->lock,flags);
  898. if (!(dmap->flags & DMA_NODMA)) {
  899. int chan = dmap->dma, pos, n;
  900. unsigned long f;
  901. f=claim_dma_lock();
  902. if(!isa_dma_bridge_buggy)
  903. disable_dma(dmap->dma);
  904. clear_dma_ff(chan);
  905. pos = dmap->bytes_in_use - get_dma_residue(chan);
  906. if(!isa_dma_bridge_buggy)
  907. enable_dma(dmap->dma);
  908. release_dma_lock(f);
  909. pos = pos / dmap->fragment_size; /* Actual qhead */
  910. if (pos < 0 || pos >= dmap->nbufs)
  911. pos = 0;
  912. n = 0;
  913. while (dmap->qhead != pos && n++ < dmap->nbufs)
  914. do_outputintr(dev, notify_only);
  915. }
  916. else
  917. do_outputintr(dev, notify_only);
  918. spin_unlock_irqrestore(&dmap->lock,flags);
  919. }
  920. EXPORT_SYMBOL(DMAbuf_outputintr);
  921. /* called with dmap->lock held in irq context */
  922. static void do_inputintr(int dev)
  923. {
  924. struct audio_operations *adev = audio_devs[dev];
  925. struct dma_buffparms *dmap = adev->dmap_in;
  926. if (dmap->raw_buf == NULL) {
  927. printk(KERN_ERR "Sound: Fatal error. Audio interrupt after freeing buffers.\n");
  928. return;
  929. }
  930. if (dmap->mapping_flags & DMA_MAP_MAPPED) {
  931. dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
  932. if (dmap->qtail == 0) { /* Wrapped */
  933. dmap->byte_counter += dmap->bytes_in_use;
  934. if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
  935. long decr = dmap->byte_counter;
  936. dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
  937. decr -= dmap->byte_counter;
  938. dmap->user_counter -= decr;
  939. }
  940. }
  941. dmap->qlen++;
  942. if (!(adev->flags & DMA_AUTOMODE)) {
  943. if (dmap->needs_reorg)
  944. reorganize_buffers(dev, dmap, 0);
  945. local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_READ);
  946. adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
  947. dmap->fragment_size, 1);
  948. if (adev->d->trigger)
  949. adev->d->trigger(dev, adev->enable_bits * adev->go);
  950. }
  951. dmap->flags |= DMA_ACTIVE;
  952. } else if (dmap->qlen >= (dmap->nbufs - 1)) {
  953. printk(KERN_WARNING "Sound: Recording overrun\n");
  954. dmap->underrun_count++;
  955. /* Just throw away the oldest fragment but keep the engine running */
  956. dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
  957. dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
  958. } else if (dmap->qlen >= 0 && dmap->qlen < dmap->nbufs) {
  959. dmap->qlen++;
  960. dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
  961. if (dmap->qtail == 0) { /* Wrapped */
  962. dmap->byte_counter += dmap->bytes_in_use;
  963. if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
  964. long decr = dmap->byte_counter;
  965. dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
  966. decr -= dmap->byte_counter;
  967. dmap->user_counter -= decr;
  968. }
  969. }
  970. }
  971. if (!(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
  972. local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
  973. adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size, dmap->fragment_size, 1);
  974. if (adev->d->trigger)
  975. adev->d->trigger(dev,adev->enable_bits * adev->go);
  976. }
  977. dmap->flags |= DMA_ACTIVE;
  978. if (dmap->qlen > 0)
  979. {
  980. wake_up(&adev->in_sleeper);
  981. wake_up(&adev->poll_sleeper);
  982. }
  983. }
  984. /* called in irq context */
  985. void DMAbuf_inputintr(int dev)
  986. {
  987. struct audio_operations *adev = audio_devs[dev];
  988. struct dma_buffparms *dmap = adev->dmap_in;
  989. unsigned long flags;
  990. spin_lock_irqsave(&dmap->lock,flags);
  991. if (!(dmap->flags & DMA_NODMA)) {
  992. int chan = dmap->dma, pos, n;
  993. unsigned long f;
  994. f=claim_dma_lock();
  995. if(!isa_dma_bridge_buggy)
  996. disable_dma(dmap->dma);
  997. clear_dma_ff(chan);
  998. pos = dmap->bytes_in_use - get_dma_residue(chan);
  999. if(!isa_dma_bridge_buggy)
  1000. enable_dma(dmap->dma);
  1001. release_dma_lock(f);
  1002. pos = pos / dmap->fragment_size; /* Actual qhead */
  1003. if (pos < 0 || pos >= dmap->nbufs)
  1004. pos = 0;
  1005. n = 0;
  1006. while (dmap->qtail != pos && ++n < dmap->nbufs)
  1007. do_inputintr(dev);
  1008. } else
  1009. do_inputintr(dev);
  1010. spin_unlock_irqrestore(&dmap->lock,flags);
  1011. }
  1012. EXPORT_SYMBOL(DMAbuf_inputintr);
  1013. void DMAbuf_init(int dev, int dma1, int dma2)
  1014. {
  1015. struct audio_operations *adev = audio_devs[dev];
  1016. /*
  1017. * NOTE! This routine could be called several times.
  1018. */
  1019. if (adev && adev->dmap_out == NULL) {
  1020. if (adev->d == NULL)
  1021. panic("OSS: audio_devs[%d]->d == NULL\n", dev);
  1022. if (adev->parent_dev) { /* Use DMA map of the parent dev */
  1023. int parent = adev->parent_dev - 1;
  1024. adev->dmap_out = audio_devs[parent]->dmap_out;
  1025. adev->dmap_in = audio_devs[parent]->dmap_in;
  1026. } else {
  1027. adev->dmap_out = adev->dmap_in = &adev->dmaps[0];
  1028. adev->dmap_out->dma = dma1;
  1029. if (adev->flags & DMA_DUPLEX) {
  1030. adev->dmap_in = &adev->dmaps[1];
  1031. adev->dmap_in->dma = dma2;
  1032. }
  1033. }
  1034. /* Persistent DMA buffers allocated here */
  1035. if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
  1036. if (adev->dmap_in->raw_buf == NULL)
  1037. sound_alloc_dmap(adev->dmap_in);
  1038. if (adev->dmap_out->raw_buf == NULL)
  1039. sound_alloc_dmap(adev->dmap_out);
  1040. }
  1041. }
  1042. }
  1043. /* No kernel lock - DMAbuf_activate_recording protected by global cli/sti */
  1044. static unsigned int poll_input(struct file * file, int dev, poll_table *wait)
  1045. {
  1046. struct audio_operations *adev = audio_devs[dev];
  1047. struct dma_buffparms *dmap = adev->dmap_in;
  1048. if (!(adev->open_mode & OPEN_READ))
  1049. return 0;
  1050. if (dmap->mapping_flags & DMA_MAP_MAPPED) {
  1051. if (dmap->qlen)
  1052. return POLLIN | POLLRDNORM;
  1053. return 0;
  1054. }
  1055. if (dmap->dma_mode != DMODE_INPUT) {
  1056. if (dmap->dma_mode == DMODE_NONE &&
  1057. adev->enable_bits & PCM_ENABLE_INPUT &&
  1058. !dmap->qlen && adev->go) {
  1059. unsigned long flags;
  1060. spin_lock_irqsave(&dmap->lock,flags);
  1061. DMAbuf_activate_recording(dev, dmap);
  1062. spin_unlock_irqrestore(&dmap->lock,flags);
  1063. }
  1064. return 0;
  1065. }
  1066. if (!dmap->qlen)
  1067. return 0;
  1068. return POLLIN | POLLRDNORM;
  1069. }
  1070. static unsigned int poll_output(struct file * file, int dev, poll_table *wait)
  1071. {
  1072. struct audio_operations *adev = audio_devs[dev];
  1073. struct dma_buffparms *dmap = adev->dmap_out;
  1074. if (!(adev->open_mode & OPEN_WRITE))
  1075. return 0;
  1076. if (dmap->mapping_flags & DMA_MAP_MAPPED) {
  1077. if (dmap->qlen)
  1078. return POLLOUT | POLLWRNORM;
  1079. return 0;
  1080. }
  1081. if (dmap->dma_mode == DMODE_INPUT)
  1082. return 0;
  1083. if (dmap->dma_mode == DMODE_NONE)
  1084. return POLLOUT | POLLWRNORM;
  1085. if (!DMAbuf_space_in_queue(dev))
  1086. return 0;
  1087. return POLLOUT | POLLWRNORM;
  1088. }
  1089. unsigned int DMAbuf_poll(struct file * file, int dev, poll_table *wait)
  1090. {
  1091. struct audio_operations *adev = audio_devs[dev];
  1092. poll_wait(file, &adev->poll_sleeper, wait);
  1093. return poll_input(file, dev, wait) | poll_output(file, dev, wait);
  1094. }
  1095. void DMAbuf_deinit(int dev)
  1096. {
  1097. struct audio_operations *adev = audio_devs[dev];
  1098. /* This routine is called when driver is being unloaded */
  1099. if (!adev)
  1100. return;
  1101. /* Persistent DMA buffers deallocated here */
  1102. if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
  1103. sound_free_dmap(adev->dmap_out);
  1104. if (adev->flags & DMA_DUPLEX)
  1105. sound_free_dmap(adev->dmap_in);
  1106. }
  1107. }