开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
audio.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：25k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

audio.c：源码内容
  1. /*
  2.  * sound/audio.c
  3.  *
  4.  * Device file manager for /dev/audio
  5.  */
  7. /*
  8.  * Copyright (C) by Hannu Savolainen 1993-1997
  9.  *
  10.  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  11.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  12.  * for more info.
  13.  */
  14. /*
  15.  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  16.  * Thomas Sailer   : moved several static variables into struct audio_operations
  17.  *                   (which is grossly misnamed btw.) because they have the same
  18.  *                   lifetime as the rest in there and dynamic allocation saves
  19.  *                   12k or so
  20.  * Thomas Sailer   : use more logical O_NONBLOCK semantics
  21.  * Daniel Rodriksson: reworked the use of the device specific copy_user
  22.  *                    still generic
  23.  * Horst von Brand:  Add missing #include <linux/string.h>
  24.  * Chris Rankin    : Update the module-usage counter for the coprocessor,
  25.  *                   and decrement the counters again if we cannot open
  26.  *                   the audio device.
  27.  */
  29. #include <linux/stddef.h>
  30. #include <linux/string.h>
  31. #include <linux/kmod.h>
  33. #include "sound_config.h"
  34. #include "ulaw.h"
  35. #include "coproc.h"
  37. #define NEUTRAL8 0x80
  38. #define NEUTRAL16 0x00
  41. int             dma_ioctl(int dev, unsigned int cmd, caddr_t arg);
  43. static int set_format(int dev, int fmt)
  44. {
  45. if (fmt != AFMT_QUERY)
  46. {
  47. audio_devs[dev]->local_conversion = 0;
  49. if (!(audio_devs[dev]->format_mask & fmt)) /* Not supported */
  50. {
  51. if (fmt == AFMT_MU_LAW)
  52. {
  53. fmt = AFMT_U8;
  54. audio_devs[dev]->local_conversion = CNV_MU_LAW;
  55. }
  56. else
  57. fmt = AFMT_U8; /* This is always supported */
  58. }
  59. audio_devs[dev]->audio_format = audio_devs[dev]->d->set_bits(dev, fmt);
  60. audio_devs[dev]->local_format = fmt;
  61. }
  62. else
  63. return audio_devs[dev]->local_format;
  65. if (audio_devs[dev]->local_conversion)
  66. return audio_devs[dev]->local_conversion;
  67. else 
  68. return audio_devs[dev]->local_format;
  69. }
  71. int audio_open(int dev, struct file *file)
  72. {
  73. int ret;
  74. int bits;
  75. int dev_type = dev & 0x0f;
  76. int mode = translate_mode(file);
  77. const struct audio_driver *driver;
  78. const struct coproc_operations *coprocessor;
  80. dev = dev >> 4;
  82. if (dev_type == SND_DEV_DSP16)
  83. bits = 16;
  84. else
  85. bits = 8;
  87. if (dev < 0 || dev >= num_audiodevs)
  88. return -ENXIO;
  90. driver = audio_devs[dev]->d;
  91. if (driver->owner)
  92. __MOD_INC_USE_COUNT(driver->owner);
  94. if ((ret = DMAbuf_open(dev, mode)) < 0)
  95. goto error_1;
  97. if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
  98. if (coprocessor->owner)
  99. __MOD_INC_USE_COUNT(coprocessor->owner);
  101. if ((ret = coprocessor->open(coprocessor->devc, COPR_PCM)) < 0) {
  102. printk(KERN_WARNING "Sound: Can't access coprocessor devicen");
  103. goto error_2;
  104. }
  105. }
  107. audio_devs[dev]->local_conversion = 0;
  109. if (dev_type == SND_DEV_AUDIO)
  110. set_format(dev, AFMT_MU_LAW);
  111. else 
  112. set_format(dev, bits);
  114. audio_devs[dev]->audio_mode = AM_NONE;
  116. return 0;
  118. /*
  119.  * Clean-up stack: this is what needs (un)doing if
  120.  * we can't open the audio device ...
  121.  */
  122. error_2:
  123. if (coprocessor->owner)
  124. __MOD_DEC_USE_COUNT(coprocessor->owner);
  125. DMAbuf_release(dev, mode);
  127. error_1:
  128. if (driver->owner)
  129. __MOD_DEC_USE_COUNT(driver->owner);
  131. return ret;
  132. }
  134. static void sync_output(int dev)
  135. {
  136. int             p, i;
  137. int             l;
  138. struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
  140. if (dmap->fragment_size <= 0)
  141. return;
  142. dmap->flags |= DMA_POST;
  144. /* Align the write pointer with fragment boundaries */
  146. if ((l = dmap->user_counter % dmap->fragment_size) > 0)
  147. {
  148. int len;
  149. unsigned long offs = dmap->user_counter % dmap->bytes_in_use;
  151. len = dmap->fragment_size - l;
  152. memset(dmap->raw_buf + offs, dmap->neutral_byte, len);
  153. DMAbuf_move_wrpointer(dev, len);
  154. }
  156. /*
  157.  * Clean all unused buffer fragments.
  158.  */
  160. p = dmap->qtail;
  161. dmap->flags |= DMA_POST;
  163. for (i = dmap->qlen + 1; i < dmap->nbufs; i++)
  164. {
  165. p = (p + 1) % dmap->nbufs;
  166. if (((dmap->raw_buf + p * dmap->fragment_size) + dmap->fragment_size) >
  167. (dmap->raw_buf + dmap->buffsize))
  168. printk(KERN_ERR "audio: Buffer error 2n");
  170. memset(dmap->raw_buf + p * dmap->fragment_size,
  171. dmap->neutral_byte,
  172. dmap->fragment_size);
  173. }
  175. dmap->flags |= DMA_DIRTY;
  176. }
  178. void audio_release(int dev, struct file *file)
  179. {
  180. const struct coproc_operations *coprocessor;
  181. int mode = translate_mode(file);
  183. dev = dev >> 4;
  185. /*
  186.  * We do this in DMAbuf_release(). Why are we doing it
  187.  * here? Why don't we test the file mode before setting
  188.  * both flags? DMAbuf_release() does.
  189.  * ...pester...pester...pester...
  190.  */
  191. audio_devs[dev]->dmap_out->closing = 1;
  192. audio_devs[dev]->dmap_in->closing = 1;
  194. /*
  195.  * We need to make sure we allocated the dmap_out buffer
  196.  * before we go mucking around with it in sync_output().
  197.  */
  198. if (mode & OPEN_WRITE)
  199. sync_output(dev);
  201. if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
  202. coprocessor->close(coprocessor->devc, COPR_PCM);
  204. if (coprocessor->owner)
  205. __MOD_DEC_USE_COUNT(coprocessor->owner);
  206. }
  207. DMAbuf_release(dev, mode);
  209. if (audio_devs[dev]->d->owner)
  210. __MOD_DEC_USE_COUNT (audio_devs[dev]->d->owner);
  211. }
  213. static void translate_bytes(const unsigned char *table, unsigned char *buff, int n)
  214. {
  215. unsigned long   i;
  217. if (n <= 0)
  218. return;
  220. for (i = 0; i < n; ++i)
  221. buff[i] = table[buff[i]];
  222. }
  224. int audio_write(int dev, struct file *file, const char *buf, int count)
  225. {
  226. int c, p, l, buf_size, used, returned;
  227. int err;
  228. char *dma_buf;
  230. dev = dev >> 4;
  232. p = 0;
  233. c = count;
  235. if(count < 0)
  236. return -EINVAL;
  238. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  239. return -EPERM;
  241. if (audio_devs[dev]->flags & DMA_DUPLEX)
  242. audio_devs[dev]->audio_mode |= AM_WRITE;
  243. else
  244. audio_devs[dev]->audio_mode = AM_WRITE;
  246. if (!count) /* Flush output */
  247. {
  248.   sync_output(dev);
  249.   return 0;
  250. }
  252. while (c)
  253. {
  254. if ((err = DMAbuf_getwrbuffer(dev, &dma_buf, &buf_size, !!(file->f_flags & O_NONBLOCK))) < 0)
  255. {
  256.     /* Handle nonblocking mode */
  257. if ((file->f_flags & O_NONBLOCK) && err == -EAGAIN)
  258. return p? p : -EAGAIN; /* No more space. Return # of accepted bytes */
  259. return err;
  260. }
  261. l = c;
  263. if (l > buf_size)
  264. l = buf_size;
  266. returned = l;
  267. used = l;
  268. if (!audio_devs[dev]->d->copy_user)
  269. {
  270. if ((dma_buf + l) >
  271. (audio_devs[dev]->dmap_out->raw_buf + audio_devs[dev]->dmap_out->buffsize))
  272. {
  273. printk(KERN_ERR "audio: Buffer error 3 (%lx,%d), (%lx, %d)n", (long) dma_buf, l, (long) audio_devs[dev]->dmap_out->raw_buf, (int) audio_devs[dev]->dmap_out->buffsize);
  274. return -EDOM;
  275. }
  276. if (dma_buf < audio_devs[dev]->dmap_out->raw_buf)
  277. {
  278. printk(KERN_ERR "audio: Buffer error 13 (%lx<%lx)n", (long) dma_buf, (long) audio_devs[dev]->dmap_out->raw_buf);
  279. return -EDOM;
  280. }
  281. if(copy_from_user(dma_buf, &(buf)[p], l))
  282. return -EFAULT;
  283. } 
  284. else audio_devs[dev]->d->copy_user (dev,
  285. dma_buf, 0,
  286. buf, p,
  287. c, buf_size,
  288. &used, &returned,
  289. l);
  290. l = returned;
  292. if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
  293. {
  294. /*
  295.  * This just allows interrupts while the conversion is running
  296.  */
  297. sti();
  298. translate_bytes(ulaw_dsp, (unsigned char *) dma_buf, l);
  299. }
  300. c -= used;
  301. p += used;
  302. DMAbuf_move_wrpointer(dev, l);
  304. }
  306. return count;
  307. }
  309. int audio_read(int dev, struct file *file, char *buf, int count)
  310. {
  311. int             c, p, l;
  312. char           *dmabuf;
  313. int             buf_no;
  315. dev = dev >> 4;
  316. p = 0;
  317. c = count;
  319. if (!(audio_devs[dev]->open_mode & OPEN_READ))
  320. return -EPERM;
  322. if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
  323. sync_output(dev);
  325. if (audio_devs[dev]->flags & DMA_DUPLEX)
  326. audio_devs[dev]->audio_mode |= AM_READ;
  327. else
  328. audio_devs[dev]->audio_mode = AM_READ;
  330. while(c)
  331. {
  332. if ((buf_no = DMAbuf_getrdbuffer(dev, &dmabuf, &l, !!(file->f_flags & O_NONBLOCK))) < 0)
  333. {
  334. /*
  335.  * Nonblocking mode handling. Return current # of bytes
  336.  */
  338. if (p > 0)  /* Avoid throwing away data */
  339. return p; /* Return it instead */
  341. if ((file->f_flags & O_NONBLOCK) && buf_no == -EAGAIN)
  342. return -EAGAIN;
  344. return buf_no;
  345. }
  346. if (l > c)
  347. l = c;
  349. /*
  350.  * Insert any local processing here.
  351.  */
  353. if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
  354. {
  355. /*
  356.  * This just allows interrupts while the conversion is running
  357.  */
  358. sti();
  360. translate_bytes(dsp_ulaw, (unsigned char *) dmabuf, l);
  361. }
  363. {
  364. char           *fixit = dmabuf;
  366. if(copy_to_user(&(buf)[p], fixit, l))
  367. return -EFAULT;
  368. };
  370. DMAbuf_rmchars(dev, buf_no, l);
  372. p += l;
  373. c -= l;
  374. }
  376. return count - c;
  377. }
  379. int audio_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
  380. {
  381. int val, count;
  382. unsigned long flags;
  383. struct dma_buffparms *dmap;
  385. dev = dev >> 4;
  387. if (_IOC_TYPE(cmd) == 'C') {
  388. if (audio_devs[dev]->coproc) /* Coprocessor ioctl */
  389. return audio_devs[dev]->coproc->ioctl(audio_devs[dev]->coproc->devc, cmd, arg, 0);
  390. /* else
  391.         printk(KERN_DEBUG"/dev/dsp%d: No coprocessor for this devicen", dev); */
  392. return -ENXIO;
  393. }
  394. else switch (cmd) 
  395. {
  396. case SNDCTL_DSP_SYNC:
  397. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  398. return 0;
  399. if (audio_devs[dev]->dmap_out->fragment_size == 0)
  400. return 0;
  401. sync_output(dev);
  402. DMAbuf_sync(dev);
  403. DMAbuf_reset(dev);
  404. return 0;
  406. case SNDCTL_DSP_POST:
  407. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  408. return 0;
  409. if (audio_devs[dev]->dmap_out->fragment_size == 0)
  410. return 0;
  411. audio_devs[dev]->dmap_out->flags |= DMA_POST | DMA_DIRTY;
  412. sync_output(dev);
  413. dma_ioctl(dev, SNDCTL_DSP_POST, (caddr_t) 0);
  414. return 0;
  416. case SNDCTL_DSP_RESET:
  417. audio_devs[dev]->audio_mode = AM_NONE;
  418. DMAbuf_reset(dev);
  419. return 0;
  421. case SNDCTL_DSP_GETFMTS:
  422. val = audio_devs[dev]->format_mask | AFMT_MU_LAW;
  423. break;
  425. case SNDCTL_DSP_SETFMT:
  426. if (get_user(val, (int *)arg))
  427. return -EFAULT;
  428. val = set_format(dev, val);
  429. break;
  431. case SNDCTL_DSP_GETISPACE:
  432. if (!(audio_devs[dev]->open_mode & OPEN_READ))
  433. return 0;
  434.    if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
  435.    return -EBUSY;
  436. return dma_ioctl(dev, cmd, arg);
  438. case SNDCTL_DSP_GETOSPACE:
  439. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  440. return -EPERM;
  441.    if ((audio_devs[dev]->audio_mode & AM_READ) && !(audio_devs[dev]->flags & DMA_DUPLEX))
  442.    return -EBUSY;
  443. return dma_ioctl(dev, cmd, arg);
  445. case SNDCTL_DSP_NONBLOCK:
  446. file->f_flags |= O_NONBLOCK;
  447. return 0;
  449. case SNDCTL_DSP_GETCAPS:
  450. val = 1 | DSP_CAP_MMAP; /* Revision level of this ioctl() */
  451. if (audio_devs[dev]->flags & DMA_DUPLEX &&
  452. audio_devs[dev]->open_mode == OPEN_READWRITE)
  453. val |= DSP_CAP_DUPLEX;
  454. if (audio_devs[dev]->coproc)
  455. val |= DSP_CAP_COPROC;
  456. if (audio_devs[dev]->d->local_qlen) /* Device has hidden buffers */
  457. val |= DSP_CAP_BATCH;
  458. if (audio_devs[dev]->d->trigger) /* Supports SETTRIGGER */
  459. val |= DSP_CAP_TRIGGER;
  460. break;
  462. case SOUND_PCM_WRITE_RATE:
  463. if (get_user(val, (int *)arg))
  464. return -EFAULT;
  465. val = audio_devs[dev]->d->set_speed(dev, val);
  466. break;
  468. case SOUND_PCM_READ_RATE:
  469. val = audio_devs[dev]->d->set_speed(dev, 0);
  470. break;
  472. case SNDCTL_DSP_STEREO:
  473. if (get_user(val, (int *)arg))
  474. return -EFAULT;
  475. if (val > 1 || val < 0)
  476. return -EINVAL;
  477. val = audio_devs[dev]->d->set_channels(dev, val + 1) - 1;
  478. break;
  480. case SOUND_PCM_WRITE_CHANNELS:
  481. if (get_user(val, (int *)arg))
  482. return -EFAULT;
  483. val = audio_devs[dev]->d->set_channels(dev, val);
  484. break;
  486. case SOUND_PCM_READ_CHANNELS:
  487. val = audio_devs[dev]->d->set_channels(dev, 0);
  488. break;
  490. case SOUND_PCM_READ_BITS:
  491. val = audio_devs[dev]->d->set_bits(dev, 0);
  492. break;
  494. case SNDCTL_DSP_SETDUPLEX:
  495. if (audio_devs[dev]->open_mode != OPEN_READWRITE)
  496. return -EPERM;
  497. return (audio_devs[dev]->flags & DMA_DUPLEX) ? 0 : -EIO;
  499. case SNDCTL_DSP_PROFILE:
  500. if (get_user(val, (int *)arg))
  501. return -EFAULT;
  502. if (audio_devs[dev]->open_mode & OPEN_WRITE)
  503. audio_devs[dev]->dmap_out->applic_profile = val;
  504. if (audio_devs[dev]->open_mode & OPEN_READ)
  505. audio_devs[dev]->dmap_in->applic_profile = val;
  506. return 0;
  508. case SNDCTL_DSP_GETODELAY:
  509. dmap = audio_devs[dev]->dmap_out;
  510. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  511. return -EINVAL;
  512. if (!(dmap->flags & DMA_ALLOC_DONE))
  513. {
  514. val=0;
  515. break;
  516. }
  518. save_flags (flags);
  519. cli();
  520. /* Compute number of bytes that have been played */
  521. count = DMAbuf_get_buffer_pointer (dev, dmap, DMODE_OUTPUT);
  522. if (count < dmap->fragment_size && dmap->qhead != 0)
  523. count += dmap->bytes_in_use; /* Pointer wrap not handled yet */
  524. count += dmap->byte_counter;
  526. /* Substract current count from the number of bytes written by app */
  527. count = dmap->user_counter - count;
  528. if (count < 0)
  529. count = 0;
  530. restore_flags (flags);
  531. val = count;
  532. break;
  534. default:
  535. return dma_ioctl(dev, cmd, arg);
  536. }
  537. return put_user(val, (int *)arg);
  538. }
  540. void audio_init_devices(void)
  541. {
  542. /*
  543.  * NOTE! This routine could be called several times during boot.
  544.  */
  545. }
  547. void reorganize_buffers(int dev, struct dma_buffparms *dmap, int recording)
  548. {
  549. /*
  550.  * This routine breaks the physical device buffers to logical ones.
  551.  */
  553. struct audio_operations *dsp_dev = audio_devs[dev];
  555. unsigned i, n;
  556. unsigned sr, nc, sz, bsz;
  558. sr = dsp_dev->d->set_speed(dev, 0);
  559. nc = dsp_dev->d->set_channels(dev, 0);
  560. sz = dsp_dev->d->set_bits(dev, 0);
  562. if (sz == 8)
  563. dmap->neutral_byte = NEUTRAL8;
  564. else
  565. dmap->neutral_byte = NEUTRAL16;
  567. if (sr < 1 || nc < 1 || sz < 1)
  568. {
  569. /* printk(KERN_DEBUG "Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%dn", dev, sr, nc, sz);*/
  570. sr = DSP_DEFAULT_SPEED;
  571. nc = 1;
  572. sz = 8;
  573. }
  575. sz = sr * nc * sz;
  577. sz /= 8; /* #bits -> #bytes */
  578. dmap->data_rate = sz;
  580. if (!dmap->needs_reorg)
  581. return;
  582. dmap->needs_reorg = 0;
  584. if (dmap->fragment_size == 0)
  585. {
  586. /* Compute the fragment size using the default algorithm */
  588. /*
  589.  * Compute a buffer size for time not exceeding 1 second.
  590.  * Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
  591.  * of sound (using the current speed, sample size and #channels).
  592.  */
  594. bsz = dmap->buffsize;
  595. while (bsz > sz)
  596. bsz /= 2;
  598. if (bsz == dmap->buffsize)
  599. bsz /= 2; /* Needs at least 2 buffers */
  601. /*
  602.  *    Split the computed fragment to smaller parts. After 3.5a9
  603.  *      the default subdivision is 4 which should give better
  604.  *      results when recording.
  605.  */
  607. if (dmap->subdivision == 0) /* Not already set */
  608. {
  609. dmap->subdivision = 4; /* Init to the default value */
  611. if ((bsz / dmap->subdivision) > 4096)
  612. dmap->subdivision *= 2;
  613. if ((bsz / dmap->subdivision) < 4096)
  614. dmap->subdivision = 1;
  615. }
  616. bsz /= dmap->subdivision;
  618. if (bsz < 16)
  619. bsz = 16; /* Just a sanity check */
  621. dmap->fragment_size = bsz;
  622. }
  623. else
  624. {
  625. /*
  626.  * The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
  627.  * the buffer size computation has already been done.
  628.  */
  629. if (dmap->fragment_size > (dmap->buffsize / 2))
  630. dmap->fragment_size = (dmap->buffsize / 2);
  631. bsz = dmap->fragment_size;
  632. }
  634. if (audio_devs[dev]->min_fragment)
  635. if (bsz < (1 << audio_devs[dev]->min_fragment))
  636. bsz = 1 << audio_devs[dev]->min_fragment;
  637. if (audio_devs[dev]->max_fragment)
  638. if (bsz > (1 << audio_devs[dev]->max_fragment))
  639. bsz = 1 << audio_devs[dev]->max_fragment;
  640. bsz &= ~0x07; /* Force size which is multiple of 8 bytes */
  641. #ifdef OS_DMA_ALIGN_CHECK
  642. OS_DMA_ALIGN_CHECK(bsz);
  643. #endif
  645. n = dmap->buffsize / bsz;
  646. if (n > MAX_SUB_BUFFERS)
  647. n = MAX_SUB_BUFFERS;
  648. if (n > dmap->max_fragments)
  649. n = dmap->max_fragments;
  651. if (n < 2)
  652. {
  653. n = 2;
  654. bsz /= 2;
  655. }
  656. dmap->nbufs = n;
  657. dmap->bytes_in_use = n * bsz;
  658. dmap->fragment_size = bsz;
  659. dmap->max_byte_counter = (dmap->data_rate * 60 * 60) +
  660. dmap->bytes_in_use; /* Approximately one hour */
  662. if (dmap->raw_buf)
  663. {
  664. memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use);
  665. }
  667. for (i = 0; i < dmap->nbufs; i++)
  668. {
  669. dmap->counts[i] = 0;
  670. }
  672. dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
  673. }
  675. static int dma_subdivide(int dev, struct dma_buffparms *dmap, int fact)
  676. {
  677. if (fact == 0) 
  678. {
  679. fact = dmap->subdivision;
  680. if (fact == 0)
  681. fact = 1;
  682. return fact;
  683. }
  684. if (dmap->subdivision != 0 || dmap->fragment_size) /* Too late to change */
  685. return -EINVAL;
  687. if (fact > MAX_REALTIME_FACTOR)
  688. return -EINVAL;
  690. if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
  691. return -EINVAL;
  693. dmap->subdivision = fact;
  694. return fact;
  695. }
  697. static int dma_set_fragment(int dev, struct dma_buffparms *dmap, int fact)
  698. {
  699. int bytes, count;
  701. if (fact == 0)
  702. return -EIO;
  704. if (dmap->subdivision != 0 ||
  705.     dmap->fragment_size) /* Too late to change */
  706. return -EINVAL;
  708. bytes = fact & 0xffff;
  709. count = (fact >> 16) & 0x7fff;
  711. if (count == 0)
  712. count = MAX_SUB_BUFFERS;
  713. else if (count < MAX_SUB_BUFFERS)
  714. count++;
  716. if (bytes < 4 || bytes > 17) /* <16 || > 512k */
  717. return -EINVAL;
  719. if (count < 2)
  720. return -EINVAL;
  722. if (audio_devs[dev]->min_fragment > 0)
  723. if (bytes < audio_devs[dev]->min_fragment)
  724. bytes = audio_devs[dev]->min_fragment;
  726. if (audio_devs[dev]->max_fragment > 0)
  727. if (bytes > audio_devs[dev]->max_fragment)
  728. bytes = audio_devs[dev]->max_fragment;
  730. #ifdef OS_DMA_MINBITS
  731. if (bytes < OS_DMA_MINBITS)
  732. bytes = OS_DMA_MINBITS;
  733. #endif
  735. dmap->fragment_size = (1 << bytes);
  736. dmap->max_fragments = count;
  738. if (dmap->fragment_size > dmap->buffsize)
  739. dmap->fragment_size = dmap->buffsize;
  741. if (dmap->fragment_size == dmap->buffsize &&
  742.     audio_devs[dev]->flags & DMA_AUTOMODE)
  743. dmap->fragment_size /= 2; /* Needs at least 2 buffers */
  745. dmap->subdivision = 1; /* Disable SNDCTL_DSP_SUBDIVIDE */
  746. return bytes | ((count - 1) << 16);
  747. }
  749. int dma_ioctl(int dev, unsigned int cmd, caddr_t arg)
  750. {
  751. struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
  752. struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
  753. struct dma_buffparms *dmap;
  754. audio_buf_info info;
  755. count_info cinfo;
  756. int fact, ret, changed, bits, count, err;
  757. unsigned long flags;
  759. switch (cmd) 
  760. {
  761. case SNDCTL_DSP_SUBDIVIDE:
  762. ret = 0;
  763. if (get_user(fact, (int *)arg))
  764. return -EFAULT;
  765. if (audio_devs[dev]->open_mode & OPEN_WRITE)
  766. ret = dma_subdivide(dev, dmap_out, fact);
  767. if (ret < 0)
  768. return ret;
  769. if (audio_devs[dev]->open_mode != OPEN_WRITE ||
  770. (audio_devs[dev]->flags & DMA_DUPLEX &&
  771. audio_devs[dev]->open_mode & OPEN_READ))
  772. ret = dma_subdivide(dev, dmap_in, fact);
  773. if (ret < 0)
  774. return ret;
  775. break;
  777. case SNDCTL_DSP_GETISPACE:
  778. case SNDCTL_DSP_GETOSPACE:
  779. dmap = dmap_out;
  780. if (cmd == SNDCTL_DSP_GETISPACE && !(audio_devs[dev]->open_mode & OPEN_READ))
  781. return -EINVAL;
  782. if (cmd == SNDCTL_DSP_GETOSPACE && !(audio_devs[dev]->open_mode & OPEN_WRITE))
  783. return -EINVAL;
  784. if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
  785. dmap = dmap_in;
  786. if (dmap->mapping_flags & DMA_MAP_MAPPED)
  787. return -EINVAL;
  788. if (!(dmap->flags & DMA_ALLOC_DONE))
  789. reorganize_buffers(dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
  790. info.fragstotal = dmap->nbufs;
  791. if (cmd == SNDCTL_DSP_GETISPACE)
  792. info.fragments = dmap->qlen;
  793. else 
  794. {
  795. if (!DMAbuf_space_in_queue(dev))
  796. info.fragments = 0;
  797. else
  798. {
  799. info.fragments = DMAbuf_space_in_queue(dev);
  800. if (audio_devs[dev]->d->local_qlen) 
  801. {
  802. int tmp = audio_devs[dev]->d->local_qlen(dev);
  803. if (tmp && info.fragments)
  804. tmp--; /*
  805.  * This buffer has been counted twice
  806.  */
  807. info.fragments -= tmp;
  808. }
  809. }
  810. }
  811. if (info.fragments < 0)
  812. info.fragments = 0;
  813. else if (info.fragments > dmap->nbufs)
  814. info.fragments = dmap->nbufs;
  816. info.fragsize = dmap->fragment_size;
  817. info.bytes = info.fragments * dmap->fragment_size;
  819. if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
  820. info.bytes -= dmap->counts[dmap->qhead];
  821. else 
  822. {
  823. info.fragments = info.bytes / dmap->fragment_size;
  824. info.bytes -= dmap->user_counter % dmap->fragment_size;
  825. }
  826. if (copy_to_user(arg, &info, sizeof(info)))
  827. return -EFAULT;
  828. return 0;
  830. case SNDCTL_DSP_SETTRIGGER:
  831. if (get_user(bits, (int *)arg))
  832. return -EFAULT;
  833. bits &= audio_devs[dev]->open_mode;
  834. if (audio_devs[dev]->d->trigger == NULL)
  835. return -EINVAL;
  836. if (!(audio_devs[dev]->flags & DMA_DUPLEX) && (bits & PCM_ENABLE_INPUT) &&
  837. (bits & PCM_ENABLE_OUTPUT))
  838. return -EINVAL;
  839. save_flags(flags);
  840. cli();
  841. changed = audio_devs[dev]->enable_bits ^ bits;
  842. if ((changed & bits) & PCM_ENABLE_INPUT && audio_devs[dev]->go) 
  843. {
  844. reorganize_buffers(dev, dmap_in, 1);
  845. if ((err = audio_devs[dev]->d->prepare_for_input(dev,
  846.      dmap_in->fragment_size, dmap_in->nbufs)) < 0) {
  847. restore_flags(flags);
  848. return -err;
  849. }
  850. dmap_in->dma_mode = DMODE_INPUT;
  851. audio_devs[dev]->enable_bits = bits;
  852. DMAbuf_activate_recording(dev, dmap_in);
  853. }
  854. if ((changed & bits) & PCM_ENABLE_OUTPUT &&
  855.     (dmap_out->mapping_flags & DMA_MAP_MAPPED || dmap_out->qlen > 0) &&
  856.     audio_devs[dev]->go) 
  857. {
  858. if (!(dmap_out->flags & DMA_ALLOC_DONE))
  859. reorganize_buffers(dev, dmap_out, 0);
  860. dmap_out->dma_mode = DMODE_OUTPUT;
  861. audio_devs[dev]->enable_bits = bits;
  862. dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
  863. DMAbuf_launch_output(dev, dmap_out);
  864. }
  865. audio_devs[dev]->enable_bits = bits;
  866. #if 0
  867. if (changed && audio_devs[dev]->d->trigger)
  868. audio_devs[dev]->d->trigger(dev, bits * audio_devs[dev]->go);
  869. #endif
  870. restore_flags(flags);
  871. /* Falls through... */
  873. case SNDCTL_DSP_GETTRIGGER:
  874. ret = audio_devs[dev]->enable_bits;
  875. break;
  877. case SNDCTL_DSP_SETSYNCRO:
  878. if (!audio_devs[dev]->d->trigger)
  879. return -EINVAL;
  880. audio_devs[dev]->d->trigger(dev, 0);
  881. audio_devs[dev]->go = 0;
  882. return 0;
  884. case SNDCTL_DSP_GETIPTR:
  885. if (!(audio_devs[dev]->open_mode & OPEN_READ))
  886. return -EINVAL;
  887. save_flags(flags);
  888. cli();
  889. cinfo.bytes = dmap_in->byte_counter;
  890. cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_in, DMODE_INPUT) & ~3;
  891. if (cinfo.ptr < dmap_in->fragment_size && dmap_in->qtail != 0)
  892. cinfo.bytes += dmap_in->bytes_in_use; /* Pointer wrap not handled yet */
  893. cinfo.blocks = dmap_in->qlen;
  894. cinfo.bytes += cinfo.ptr;
  895. if (dmap_in->mapping_flags & DMA_MAP_MAPPED)
  896. dmap_in->qlen = 0; /* Reset interrupt counter */
  897. restore_flags(flags);
  898. if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
  899. return -EFAULT;
  900. return 0;
  902. case SNDCTL_DSP_GETOPTR:
  903. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  904. return -EINVAL;
  906. save_flags(flags);
  907. cli();
  908. cinfo.bytes = dmap_out->byte_counter;
  909. cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_out, DMODE_OUTPUT) & ~3;
  910. if (cinfo.ptr < dmap_out->fragment_size && dmap_out->qhead != 0)
  911. cinfo.bytes += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
  912. cinfo.blocks = dmap_out->qlen;
  913. cinfo.bytes += cinfo.ptr;
  914. if (dmap_out->mapping_flags & DMA_MAP_MAPPED)
  915. dmap_out->qlen = 0; /* Reset interrupt counter */
  916. restore_flags(flags);
  917. if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
  918. return -EFAULT;
  919. return 0;
  921. case SNDCTL_DSP_GETODELAY:
  922. if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
  923. return -EINVAL;
  924. if (!(dmap_out->flags & DMA_ALLOC_DONE))
  925. {
  926. ret=0;
  927. break;
  928. }
  929. save_flags(flags);
  930. cli();
  931. /* Compute number of bytes that have been played */
  932. count = DMAbuf_get_buffer_pointer (dev, dmap_out, DMODE_OUTPUT);
  933. if (count < dmap_out->fragment_size && dmap_out->qhead != 0)
  934. count += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
  935. count += dmap_out->byte_counter;
  936. /* Substract current count from the number of bytes written by app */
  937. count = dmap_out->user_counter - count;
  938. if (count < 0)
  939. count = 0;
  940. restore_flags (flags);
  941. ret = count;
  942. break;
  944. case SNDCTL_DSP_POST:
  945. if (audio_devs[dev]->dmap_out->qlen > 0)
  946. if (!(audio_devs[dev]->dmap_out->flags & DMA_ACTIVE))
  947. DMAbuf_launch_output(dev, audio_devs[dev]->dmap_out);
  948. return 0;
  950. case SNDCTL_DSP_GETBLKSIZE:
  951. dmap = dmap_out;
  952. if (audio_devs[dev]->open_mode & OPEN_WRITE)
  953. reorganize_buffers(dev, dmap_out, (audio_devs[dev]->open_mode == OPEN_READ));
  954. if (audio_devs[dev]->open_mode == OPEN_READ ||
  955.     (audio_devs[dev]->flags & DMA_DUPLEX &&
  956.      audio_devs[dev]->open_mode & OPEN_READ))
  957. reorganize_buffers(dev, dmap_in, (audio_devs[dev]->open_mode == OPEN_READ));
  958. if (audio_devs[dev]->open_mode == OPEN_READ)
  959. dmap = dmap_in;
  960. ret = dmap->fragment_size;
  961. break;
  963. case SNDCTL_DSP_SETFRAGMENT:
  964. ret = 0;
  965. if (get_user(fact, (int *)arg))
  966. return -EFAULT;
  967. if (audio_devs[dev]->open_mode & OPEN_WRITE)
  968. ret = dma_set_fragment(dev, dmap_out, fact);
  969. if (ret < 0)
  970. return ret;
  971. if (audio_devs[dev]->open_mode == OPEN_READ ||
  972.     (audio_devs[dev]->flags & DMA_DUPLEX &&
  973.      audio_devs[dev]->open_mode & OPEN_READ))
  974. ret = dma_set_fragment(dev, dmap_in, fact);
  975. if (ret < 0)
  976. return ret;
  977. if (!arg) /* don't know what this is good for, but preserve old semantics */
  978. return 0;
  979. break;
  981. default:
  982. if (!audio_devs[dev]->d->ioctl)
  983. return -EINVAL;
  984. return audio_devs[dev]->d->ioctl(dev, cmd, arg);
  985. }
  986. return put_user(ret, (int *)arg);
  987. }