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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pxa-audio.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：20k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pxa-audio.c：源码内容
  1. /*
  2.  *  linux/drivers/sound/pxa-audio.c -- audio interface for the Cotula chip
  3.  *
  4.  *  Author: Nicolas Pitre
  5.  *  Created: Aug 15, 2001
  6.  *  Copyright: MontaVista Software Inc.
  7.  *
  8.  *  This program is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License version 2 as
  10.  *  published by the Free Software Foundation.
  11.  */
  13. #include <linux/init.h>
  14. #include <linux/module.h>
  15. #include <linux/kernel.h>
  16. #include <linux/slab.h>
  17. #include <linux/pci.h>
  18. #include <linux/poll.h>
  19. #include <linux/sound.h>
  20. #include <linux/soundcard.h>
  22. #include <asm/hardware.h>
  23. #include <asm/irq.h>
  24. #include <asm/uaccess.h>
  25. #include <asm/semaphore.h>
  26. #include <asm/dma.h>
  28. #include "pxa-audio.h"
  31. #define AUDIO_NBFRAGS_DEFAULT 8
  32. #define AUDIO_FRAGSIZE_DEFAULT 8192
  34. #define MAX_DMA_SIZE 4096
  35. #define DMA_DESC_SIZE sizeof(pxa_dma_desc)
  38. /*
  39.  * This function frees all buffers
  40.  */
  41. #define audio_clear_buf pxa_audio_clear_buf
  43. void pxa_audio_clear_buf(audio_stream_t * s)
  44. {
  45. DECLARE_WAITQUEUE(wait, current);
  46. int frag;
  48. if (!s->buffers)
  49. return;
  51. /* Ensure DMA isn't running */
  52. set_current_state(TASK_UNINTERRUPTIBLE);
  53. add_wait_queue(&s->stop_wq, &wait);
  54. DCSR(s->dma_ch) = DCSR_STOPIRQEN;
  55. schedule();
  56. remove_wait_queue(&s->stop_wq, &wait);
  58. /* free DMA buffers */
  59. for (frag = 0; frag < s->nbfrags; frag++) {
  60. audio_buf_t *b = &s->buffers[frag];
  61. if (!b->master)
  62. continue;
  63. consistent_free(b->data, b->master, b->dma_desc->dsadr);
  64. }
  66. /* free descriptor ring */
  67. if (s->buffers->dma_desc)
  68. consistent_free(s->buffers->dma_desc, 
  69. s->nbfrags * s->descs_per_frag * DMA_DESC_SIZE,
  70. s->dma_desc_phys);
  72. /* free buffer structure array */
  73. kfree(s->buffers);
  74. s->buffers = NULL;
  75. }
  77. /*
  78.  * This function allocates the DMA descriptor array and buffer data space
  79.  * according to the current number of fragments and fragment size.
  80.  */
  81. static int audio_setup_buf(audio_stream_t * s)
  82. {
  83. pxa_dma_desc *dma_desc;
  84. dma_addr_t dma_desc_phys;
  85. int nb_desc, frag, i, buf_size = 0;
  86. char *dma_buf = NULL;
  87. dma_addr_t dma_buf_phys = 0;
  89. if (s->buffers)
  90. return -EBUSY;
  92. /* Our buffer structure array */
  93. s->buffers = kmalloc(sizeof(audio_buf_t) * s->nbfrags, GFP_KERNEL);
  94. if (!s->buffers)
  95. goto err;
  96. memzero(s->buffers, sizeof(audio_buf_t) * s->nbfrags);
  98. /* 
  99.  * Our DMA descriptor array:
  100.  * for Each fragment we have one checkpoint descriptor plus one 
  101.  * descriptor per MAX_DMA_SIZE byte data blocks.
  102.  */
  103. nb_desc = (1 + (s->fragsize + MAX_DMA_SIZE - 1)/MAX_DMA_SIZE) * s->nbfrags;
  104. dma_desc = consistent_alloc(GFP_KERNEL,
  105.     nb_desc * DMA_DESC_SIZE,
  106.     &dma_desc_phys);
  107. if (!dma_desc)
  108. goto err;
  109. s->descs_per_frag = nb_desc / s->nbfrags;
  110. s->buffers->dma_desc = dma_desc;
  111. s->dma_desc_phys = dma_desc_phys;
  112. for (i = 0; i < nb_desc - 1; i++)
  113. dma_desc[i].ddadr = dma_desc_phys + (i + 1) * DMA_DESC_SIZE;
  114. dma_desc[i].ddadr = dma_desc_phys;
  116. /* Our actual DMA buffers */
  117. for (frag = 0; frag < s->nbfrags; frag++) {
  118. audio_buf_t *b = &s->buffers[frag];
  120. /*
  121.  * Let's allocate non-cached memory for DMA buffers.
  122.  * We try to allocate all memory at once.
  123.  * If this fails (a common reason is memory fragmentation),
  124.  * then we'll try allocating smaller buffers.
  125.  */
  126. if (!buf_size) {
  127. buf_size = (s->nbfrags - frag) * s->fragsize;
  128. do {
  129. dma_buf = consistent_alloc(GFP_KERNEL,
  130.    buf_size, 
  131.    &dma_buf_phys);
  132. if (!dma_buf)
  133. buf_size -= s->fragsize;
  134. } while (!dma_buf && buf_size);
  135. if (!dma_buf)
  136. goto err;
  137. b->master = buf_size;
  138. memzero(dma_buf, buf_size);
  139. }
  141. /* 
  142.  * Set up our checkpoint descriptor.  Since the count 
  143.  * is always zero, we'll abuse the dsadr and dtadr fields
  144.  * just in case this one is picked up by the hardware
  145.  * while processing SOUND_DSP_GETPTR.
  146.  */
  147. dma_desc->dsadr = dma_buf_phys;
  148. dma_desc->dtadr = dma_buf_phys;
  149. dma_desc->dcmd = DCMD_ENDIRQEN;
  150. if (s->output && !s->mapped)
  151. dma_desc->ddadr |= DDADR_STOP;
  152. b->dma_desc = dma_desc++;
  154. /* set up the actual data descriptors */
  155. for (i = 0; (i * MAX_DMA_SIZE) < s->fragsize; i++) {
  156. dma_desc[i].dsadr = (s->output) ?
  157. (dma_buf_phys + i*MAX_DMA_SIZE) : s->dev_addr;
  158. dma_desc[i].dtadr = (s->output) ?
  159. s->dev_addr : (dma_buf_phys + i*MAX_DMA_SIZE);
  160. dma_desc[i].dcmd = s->dcmd |
  161. ((s->fragsize < MAX_DMA_SIZE) ?
  162. s->fragsize : MAX_DMA_SIZE);
  163. }
  164. dma_desc += i;
  166. /* handle buffer pointers */
  167. b->data = dma_buf;
  168. dma_buf += s->fragsize;
  169. dma_buf_phys += s->fragsize;
  170. buf_size -= s->fragsize;
  171. }
  173. s->usr_frag = s->dma_frag = 0;
  174. s->bytecount = 0;
  175. s->fragcount = 0;
  176. sema_init(&s->sem, (s->output) ? s->nbfrags : 0);
  177. return 0;
  179. err:
  180. printk("pxa-audio: unable to allocate audio memoryn ");
  181. audio_clear_buf(s);
  182. return -ENOMEM;
  183. }
  185. /*
  186.  * Our DMA interrupt handler
  187.  */
  188. static void audio_dma_irq(int ch, void *dev_id, struct pt_regs *regs)
  189. {
  190. audio_stream_t *s = dev_id;
  191. u_int dcsr;
  193. dcsr = DCSR(ch);
  194. DCSR(ch) = dcsr & ~DCSR_STOPIRQEN;
  196. if (!s->buffers) {
  197. printk("AC97 DMA: wow... received IRQ for channel %d but no buffer existsn", ch);
  198. return;
  199. }
  201. if (dcsr & DCSR_BUSERR)
  202. printk("AC97 DMA: bus error interrupt on channel %dn", ch);
  204. if (dcsr & DCSR_ENDINTR) {
  205. u_long cur_dma_desc;
  206. u_int cur_dma_frag;
  208. /* 
  209.  * Find out which DMA desc is current.  Note that DDADR
  210.  * points to the next desc, not the current one.
  211.  */
  212. cur_dma_desc = DDADR(ch) - s->dma_desc_phys - DMA_DESC_SIZE;
  214. /*
  215.  * Let the compiler nicely optimize constant divisors into
  216.  * multiplications for the common cases which is much faster.
  217.  * Common cases: x = 1 + (1 << y) for y = [0..3]
  218.  */
  219. switch (s->descs_per_frag) {
  220. case 2:  cur_dma_frag = cur_dma_desc / (2*DMA_DESC_SIZE); break;
  221. case 3:  cur_dma_frag = cur_dma_desc / (3*DMA_DESC_SIZE); break;
  222. case 5:  cur_dma_frag = cur_dma_desc / (5*DMA_DESC_SIZE); break;
  223. case 9:  cur_dma_frag = cur_dma_desc / (9*DMA_DESC_SIZE); break;
  224. default: cur_dma_frag =
  225.     cur_dma_desc / (s->descs_per_frag * DMA_DESC_SIZE);
  226. }
  228. /* Account for possible wrap back of cur_dma_desc above */
  229. if (cur_dma_frag >= s->nbfrags)
  230. cur_dma_frag = s->nbfrags - 1;
  232. while (s->dma_frag != cur_dma_frag) {
  233. if (!s->mapped) {
  234. /* 
  235.  * This fragment is done - set the checkpoint
  236.  * descriptor to STOP until it is gets
  237.  * processed by the read or write function.
  238.  */
  239. s->buffers[s->dma_frag].dma_desc->ddadr |= DDADR_STOP;
  240. up(&s->sem);
  241. }
  242. if (++s->dma_frag >= s->nbfrags)
  243. s->dma_frag = 0;
  245. /* Accounting */
  246. s->bytecount += s->fragsize;
  247. s->fragcount++;
  248. }
  250. /* ... and for polling processes */
  251. wake_up(&s->frag_wq);
  252. }
  254. if ((dcsr & DCSR_STOPIRQEN) && (dcsr & DCSR_STOPSTATE))
  255. wake_up(&s->stop_wq);
  256. }
  258. /*
  259.  * Validate and sets up buffer fragments, etc.
  260.  */
  261. static int audio_set_fragments(audio_stream_t *s, int val)
  262. {
  263. if (s->mapped || DCSR(s->dma_ch) & DCSR_RUN)
  264. return -EBUSY;
  265. if (s->buffers)
  266. audio_clear_buf(s);
  267. s->nbfrags = (val >> 16) & 0x7FFF;
  268. val &= 0xffff;
  269. if (val < 5)
  270. val = 5;
  271. if (val > 15)
  272. val = 15;
  273. s->fragsize = 1 << val;
  274. if (s->nbfrags < 2)
  275. s->nbfrags = 2;
  276. if (s->nbfrags * s->fragsize > 256 * 1024)
  277. s->nbfrags = 256 * 1024 / s->fragsize;
  278. if (audio_setup_buf(s))
  279. return -ENOMEM;
  280. return val|(s->nbfrags << 16);
  281. }
  284. /*
  285.  * The fops functions
  286.  */
  288. static int audio_write(struct file *file, const char *buffer,
  289.        size_t count, loff_t * ppos)
  290. {
  291. const char *buffer0 = buffer;
  292. audio_state_t *state = (audio_state_t *)file->private_data;
  293. audio_stream_t *s = state->output_stream;
  294. int chunksize, ret = 0;
  296. if (ppos != &file->f_pos)
  297. return -ESPIPE;
  298. if (s->mapped)
  299. return -ENXIO;
  300. if (!s->buffers && audio_setup_buf(s))
  301. return -ENOMEM;
  303. while (count > 0) {
  304. audio_buf_t *b = &s->buffers[s->usr_frag];
  306. /* Grab a fragment */
  307. if (file->f_flags & O_NONBLOCK) {
  308. ret = -EAGAIN;
  309. if (down_trylock(&s->sem))
  310. break;
  311. } else {
  312. ret = -ERESTARTSYS;
  313. if (down_interruptible(&s->sem))
  314. break;
  315. }
  317. /* Feed the current buffer */
  318. chunksize = s->fragsize - b->offset;
  319. if (chunksize > count)
  320. chunksize = count;
  321. if (copy_from_user(b->data + b->offset, buffer, chunksize)) {
  322. up(&s->sem);
  323. return -EFAULT;
  324. }
  325. b->offset += chunksize;
  326. buffer += chunksize;
  327. count -= chunksize;
  328. if (b->offset < s->fragsize) {
  329. up(&s->sem);
  330. break;
  331. }
  333. /* 
  334.  * Activate DMA on current buffer.
  335.  * We unlock this fragment's checkpoint descriptor and
  336.  * kick DMA if it is idle.  Using checkpoint descriptors
  337.  * allows for control operations without the need for 
  338.  * stopping the DMA channel if it is already running.
  339.  */
  340. b->offset = 0;
  341. b->dma_desc->ddadr &= ~DDADR_STOP;
  342. if (DCSR(s->dma_ch) & DCSR_STOPSTATE) {
  343. DDADR(s->dma_ch) = b->dma_desc->ddadr;
  344. DCSR(s->dma_ch) = DCSR_RUN;
  345. }
  347. /* move the index to the next fragment */
  348. if (++s->usr_frag >= s->nbfrags)
  349. s->usr_frag = 0;
  350. }
  352. if ((buffer - buffer0))
  353. ret = buffer - buffer0;
  354. return ret;
  355. }
  358. static int audio_read(struct file *file, char *buffer,
  359.       size_t count, loff_t * ppos)
  360. {
  361. char *buffer0 = buffer;
  362. audio_state_t *state = file->private_data;
  363. audio_stream_t *s = state->input_stream;
  364. int chunksize, ret = 0;
  366. if (ppos != &file->f_pos)
  367. return -ESPIPE;
  368. if (s->mapped)
  369. return -ENXIO;
  370. if (!s->buffers && audio_setup_buf(s))
  371. return -ENOMEM;
  373. while (count > 0) {
  374. audio_buf_t *b = &s->buffers[s->usr_frag];
  376. /* prime DMA */
  377. if (DCSR(s->dma_ch) & DCSR_STOPSTATE) {
  378. DDADR(s->dma_ch) = 
  379. s->buffers[s->dma_frag].dma_desc->ddadr;
  380. DCSR(s->dma_ch) = DCSR_RUN;
  381. }
  383. /* Wait for a buffer to become full */
  384. if (file->f_flags & O_NONBLOCK) {
  385. ret = -EAGAIN;
  386. if (down_trylock(&s->sem))
  387. break;
  388. } else {
  389. ret = -ERESTARTSYS;
  390. if (down_interruptible(&s->sem))
  391. break;
  392. }
  394. /* Grab data from current buffer */
  395. chunksize = s->fragsize - b->offset;
  396. if (chunksize > count)
  397. chunksize = count;
  398. if (copy_to_user(buffer, b->data + b->offset, chunksize)) {
  399. up(&s->sem);
  400. return -EFAULT;
  401. }
  402. b->offset += chunksize;
  403. buffer += chunksize;
  404. count -= chunksize;
  405. if (b->offset < s->fragsize) {
  406. up(&s->sem);
  407. break;
  408. }
  410. /* 
  411.  * Make this buffer available for DMA again.
  412.  * We unlock this fragment's checkpoint descriptor and
  413.  * kick DMA if it is idle.  Using checkpoint descriptors
  414.  * allows for control operations without the need for 
  415.  * stopping the DMA channel if it is already running.
  416.  */
  417. b->offset = 0;
  418. b->dma_desc->ddadr &= ~DDADR_STOP;
  420. /* move the index to the next fragment */
  421. if (++s->usr_frag >= s->nbfrags)
  422. s->usr_frag = 0;
  423. }
  425. if ((buffer - buffer0))
  426. ret = buffer - buffer0;
  427. return ret;
  428. }
  431. static int audio_sync(struct file *file)
  432. {
  433. audio_state_t *state = file->private_data;
  434. audio_stream_t *s = state->output_stream;
  435. audio_buf_t *b;
  436. pxa_dma_desc *final_desc;
  437. u_long dcmd_save = 0;
  438. DECLARE_WAITQUEUE(wait, current);
  440. if (!(file->f_mode & FMODE_WRITE) || !s->buffers || s->mapped)
  441. return 0;
  443. /*
  444.  * Send current buffer if it contains data.  Be sure to send
  445.  * a full sample count.
  446.  */
  447. final_desc = NULL;
  448. b = &s->buffers[s->usr_frag];
  449. if (b->offset &= ~3) {
  450. final_desc = &b->dma_desc[1 + b->offset/MAX_DMA_SIZE];
  451. b->offset &= (MAX_DMA_SIZE-1);
  452. dcmd_save = final_desc->dcmd;
  453. final_desc->dcmd = b->offset | s->dcmd | DCMD_ENDIRQEN; 
  454. final_desc->ddadr |= DDADR_STOP;
  455. b->offset = 0;
  456. b->dma_desc->ddadr &= ~DDADR_STOP;
  457. if (DCSR(s->dma_ch) & DCSR_STOPSTATE) {
  458. DDADR(s->dma_ch) = b->dma_desc->ddadr;
  459. DCSR(s->dma_ch) = DCSR_RUN;
  460. }
  461. }
  463. /* Wait for DMA to complete. */
  464. set_current_state(TASK_INTERRUPTIBLE);
  465. #if 0
  466. /* 
  467.  * The STOPSTATE IRQ never seem to occur if DCSR_STOPIRQEN is set
  468.  * along wotj DCSR_RUN.  Silicon bug?
  469.  */
  470. add_wait_queue(&s->stop_wq, &wait);
  471. DCSR(s->dma_ch) |= DCSR_STOPIRQEN;
  472. schedule();
  473. #else 
  474. add_wait_queue(&s->frag_wq, &wait);
  475. while ((DCSR(s->dma_ch) & DCSR_RUN) && !signal_pending(current)) {
  476. schedule();
  477. set_current_state(TASK_INTERRUPTIBLE);
  478. }
  479. #endif
  480. set_current_state(TASK_RUNNING);
  481. remove_wait_queue(&s->frag_wq, &wait);
  483. /* Restore the descriptor chain. */
  484. if (final_desc) {
  485. final_desc->dcmd = dcmd_save;
  486. final_desc->ddadr &= ~DDADR_STOP;
  487. b->dma_desc->ddadr |= DDADR_STOP;
  488. }
  489. return 0;
  490. }
  493. static unsigned int audio_poll(struct file *file,
  494.        struct poll_table_struct *wait)
  495. {
  496. audio_state_t *state = file->private_data;
  497. audio_stream_t *is = state->input_stream;
  498. audio_stream_t *os = state->output_stream;
  499. unsigned int mask = 0;
  501. if (file->f_mode & FMODE_READ) {
  502. /* Start audio input if not already active */
  503. if (!is->buffers && audio_setup_buf(is))
  504. return -ENOMEM;
  505. if (DCSR(is->dma_ch) & DCSR_STOPSTATE) {
  506. DDADR(is->dma_ch) = 
  507. is->buffers[is->dma_frag].dma_desc->ddadr;
  508. DCSR(is->dma_ch) = DCSR_RUN;
  509. }
  510. poll_wait(file, &is->frag_wq, wait);
  511. }
  513. if (file->f_mode & FMODE_WRITE) {
  514. if (!os->buffers && audio_setup_buf(os))
  515. return -ENOMEM;
  516. poll_wait(file, &os->frag_wq, wait);
  517. }
  519. if (file->f_mode & FMODE_READ)
  520. if (( is->mapped && is->bytecount > 0) ||
  521.     (!is->mapped && atomic_read(&is->sem.count) > 0))
  522. mask |= POLLIN | POLLRDNORM;
  524. if (file->f_mode & FMODE_WRITE)
  525. if (( os->mapped && os->bytecount > 0) ||
  526.     (!os->mapped && atomic_read(&os->sem.count) > 0))
  527. mask |= POLLOUT | POLLWRNORM;
  529. return mask;
  530. }
  533. static int audio_ioctl( struct inode *inode, struct file *file,
  534. uint cmd, ulong arg)
  535. {
  536. audio_state_t *state = file->private_data;
  537. audio_stream_t *os = state->output_stream;
  538. audio_stream_t *is = state->input_stream;
  539. long val;
  541. switch (cmd) {
  542. case OSS_GETVERSION:
  543. return put_user(SOUND_VERSION, (int *)arg);
  545. case SNDCTL_DSP_GETBLKSIZE:
  546. if (file->f_mode & FMODE_WRITE)
  547. return put_user(os->fragsize, (int *)arg);
  548. else
  549. return put_user(is->fragsize, (int *)arg);
  551. case SNDCTL_DSP_GETCAPS:
  552. val = DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP;
  553. if (is && os)
  554. val |= DSP_CAP_DUPLEX;
  555. return put_user(val, (int *)arg);
  557. case SNDCTL_DSP_SETFRAGMENT:
  558. if (get_user(val, (long *) arg))
  559. return -EFAULT;
  560. if (file->f_mode & FMODE_READ) {
  561. int ret = audio_set_fragments(is, val);
  562. if (ret < 0)
  563. return ret;
  564. ret = put_user(ret, (int *)arg);
  565. if (ret)
  566. return ret;
  567. }
  568. if (file->f_mode & FMODE_WRITE) {
  569. int ret = audio_set_fragments(os, val);
  570. if (ret < 0)
  571. return ret;
  572. ret = put_user(ret, (int *)arg);
  573. if (ret)
  574. return ret;
  575. }
  576. return 0;
  578. case SNDCTL_DSP_SYNC:
  579. return audio_sync(file);
  581. case SNDCTL_DSP_SETDUPLEX:
  582. return 0;
  584. case SNDCTL_DSP_POST:
  585. return 0;
  587. case SNDCTL_DSP_GETTRIGGER:
  588. val = 0;
  589. if (file->f_mode & FMODE_READ && DCSR(is->dma_ch) & DCSR_RUN)
  590. val |= PCM_ENABLE_INPUT;
  591. if (file->f_mode & FMODE_WRITE && DCSR(os->dma_ch) & DCSR_RUN)
  592. val |= PCM_ENABLE_OUTPUT;
  593. return put_user(val, (int *)arg);
  595. case SNDCTL_DSP_SETTRIGGER:
  596. if (get_user(val, (int *)arg))
  597. return -EFAULT;
  598. if (file->f_mode & FMODE_READ) {
  599. if (val & PCM_ENABLE_INPUT) {
  600. if (!is->buffers && audio_setup_buf(is))
  601. return -ENOMEM;
  602. if (!(DCSR(is->dma_ch) & DCSR_RUN)) {
  603. audio_buf_t *b = &is->buffers[is->dma_frag];
  604. DDADR(is->dma_ch) = b->dma_desc->ddadr;
  605. DCSR(is->dma_ch) = DCSR_RUN;
  606. }
  607. } else {
  608. DCSR(is->dma_ch) = 0;
  609. }
  610. }
  611. if (file->f_mode & FMODE_WRITE) {
  612. if (val & PCM_ENABLE_OUTPUT) {
  613. if (!os->buffers && audio_setup_buf(os))
  614. return -ENOMEM;
  615. if (!(DCSR(os->dma_ch) & DCSR_RUN)) {
  616. audio_buf_t *b = &os->buffers[os->dma_frag];
  617. DDADR(os->dma_ch) = b->dma_desc->ddadr;
  618. DCSR(os->dma_ch) = DCSR_RUN;
  619. }
  620. } else {
  621. DCSR(os->dma_ch) = 0;
  622. }
  623. }
  624. return 0;
  626. case SNDCTL_DSP_GETOSPACE:
  627. case SNDCTL_DSP_GETISPACE:
  628.     {
  629. audio_buf_info inf = { 0, };
  630. audio_stream_t *s = (cmd == SNDCTL_DSP_GETOSPACE) ? os : is;
  632. if ((s == is && !(file->f_mode & FMODE_READ)) ||
  633.     (s == os && !(file->f_mode & FMODE_WRITE)))
  634. return -EINVAL;
  635. if (!s->buffers && audio_setup_buf(s))
  636. return -ENOMEM;
  637. inf.bytes = atomic_read(&s->sem.count) * s->fragsize;
  638. inf.bytes -= s->buffers[s->usr_frag].offset;
  639. inf.fragments = inf.bytes / s->fragsize;
  640. inf.fragsize = s->fragsize;
  641. inf.fragstotal = s->nbfrags;
  642. return copy_to_user((void *)arg, &inf, sizeof(inf));
  643.     }
  645. case SNDCTL_DSP_GETOPTR:
  646. case SNDCTL_DSP_GETIPTR:
  647.     {
  648. count_info inf = { 0, };
  649. audio_stream_t *s = (cmd == SNDCTL_DSP_GETOPTR) ? os : is;
  650. dma_addr_t ptr;
  651. int bytecount, offset, flags;
  653. if ((s == is && !(file->f_mode & FMODE_READ)) ||
  654.     (s == os && !(file->f_mode & FMODE_WRITE)))
  655. return -EINVAL;
  656. if (DCSR(s->dma_ch) & DCSR_RUN) {
  657. audio_buf_t *b;
  658. save_flags_cli(flags);
  659. ptr = (s->output) ? DSADR(s->dma_ch) : DTADR(s->dma_ch);
  660. b = &s->buffers[s->dma_frag];
  661. offset = ptr - b->dma_desc->dsadr;
  662. if (offset >= s->fragsize)
  663. offset = s->fragsize - 4;
  664. } else {
  665. save_flags(flags);
  666. offset = 0;
  667. }
  668. inf.ptr = s->dma_frag * s->fragsize + offset;
  669. bytecount = s->bytecount + offset;
  670. s->bytecount = -offset;
  671. inf.blocks = s->fragcount;
  672. s->fragcount = 0;
  673. restore_flags(flags);
  674. if (bytecount < 0)
  675. bytecount = 0;
  676. inf.bytes = bytecount;
  677. return copy_to_user((void *)arg, &inf, sizeof(inf));
  678.     }
  680. case SNDCTL_DSP_NONBLOCK:
  681. file->f_flags |= O_NONBLOCK;
  682. return 0;
  684. case SNDCTL_DSP_RESET:
  685. if (file->f_mode & FMODE_WRITE) 
  686. audio_clear_buf(os);
  687. if (file->f_mode & FMODE_READ)
  688. audio_clear_buf(is);
  689. return 0;
  691. default:
  692. return state->client_ioctl(inode, file, cmd, arg);
  693. }
  695. return 0;
  696. }
  699. static int audio_mmap(struct file *file, struct vm_area_struct *vma)
  700. {
  701. audio_state_t *state = file->private_data;
  702. audio_stream_t *s;
  703. unsigned long size, vma_addr;
  704. int i, ret;
  706. if (vma->vm_pgoff != 0)
  707. return -EINVAL;
  709. if (vma->vm_flags & VM_WRITE) {
  710. if (!state->wr_ref)
  711. return -EINVAL;;
  712. s = state->output_stream;
  713. } else if (vma->vm_flags & VM_READ) {
  714. if (!state->rd_ref)
  715. return -EINVAL;
  716. s = state->input_stream;
  717. } else return -EINVAL;
  719. if (s->mapped)
  720. return -EINVAL;
  721. size = vma->vm_end - vma->vm_start;
  722. if (size != s->fragsize * s->nbfrags)
  723. return -EINVAL;
  724. if (!s->buffers && audio_setup_buf(s))
  725. return -ENOMEM;
  726. vma_addr = vma->vm_start;
  727. for (i = 0; i < s->nbfrags; i++) {
  728. audio_buf_t *buf = &s->buffers[i];
  729. if (!buf->master)
  730. continue;
  731. ret = remap_page_range(vma_addr, buf->dma_desc->dsadr,
  732.        buf->master, vma->vm_page_prot);
  733. if (ret)
  734. return ret;
  735. vma_addr += buf->master;
  736. }
  737. for (i = 0; i < s->nbfrags; i++)
  738. s->buffers[i].dma_desc->ddadr &= ~DDADR_STOP;
  739. s->mapped = 1;
  740. return 0;
  741. }
  744. static int audio_release(struct inode *inode, struct file *file)
  745. {
  746. audio_state_t *state = file->private_data;
  748. down(&state->sem);
  750. if (file->f_mode & FMODE_READ) {
  751. audio_clear_buf(state->input_stream);
  752. *state->input_stream->drcmr = 0;
  753. pxa_free_dma(state->input_stream->dma_ch);
  754. state->rd_ref = 0;
  755. }
  757. if (file->f_mode & FMODE_WRITE) {
  758. audio_sync(file);
  759. audio_clear_buf(state->output_stream);
  760. *state->output_stream->drcmr = 0;
  761. pxa_free_dma(state->output_stream->dma_ch);
  762. state->wr_ref = 0;
  763. }
  765. up(&state->sem);
  766. return 0;
  767. }
  770. int pxa_audio_attach(struct inode *inode, struct file *file,
  771.  audio_state_t *state)
  772. {
  773. audio_stream_t *is = state->input_stream;
  774. audio_stream_t *os = state->output_stream;
  775. int err;
  777. down(&state->sem);
  779. /* access control */
  780. err = -ENODEV;
  781. if ((file->f_mode & FMODE_WRITE) && !os)
  782. goto out;
  783. if ((file->f_mode & FMODE_READ) && !is)
  784. goto out;
  785. err = -EBUSY;
  786. if ((file->f_mode & FMODE_WRITE) && state->wr_ref)
  787. goto out;
  788. if ((file->f_mode & FMODE_READ) && state->rd_ref)
  789. goto out;
  791. /* request DMA channels */
  792. if (file->f_mode & FMODE_WRITE) {
  793. err = pxa_request_dma(os->name, DMA_PRIO_LOW, 
  794.   audio_dma_irq, os);
  795. if (err < 0)
  796. goto out;
  797. os->dma_ch = err;
  798. }
  799. if (file->f_mode & FMODE_READ) {
  800. err = pxa_request_dma(is->name, DMA_PRIO_LOW,
  801.   audio_dma_irq, is);
  802. if (err < 0) {
  803. if (file->f_mode & FMODE_WRITE) {
  804. *os->drcmr = 0;
  805. pxa_free_dma(os->dma_ch);
  806. }
  807. goto out;
  808. }
  809. is->dma_ch = err;
  810. }
  812. file->private_data = state;
  813. file->f_op->release = audio_release;
  814. file->f_op->write = audio_write;
  815. file->f_op->read = audio_read;
  816. file->f_op->mmap = audio_mmap;
  817. file->f_op->poll = audio_poll;
  818. file->f_op->ioctl = audio_ioctl;
  819. file->f_op->llseek = no_llseek;
  821. if ((file->f_mode & FMODE_WRITE)) {
  822. state->wr_ref = 1;
  823. os->fragsize = AUDIO_FRAGSIZE_DEFAULT;
  824. os->nbfrags = AUDIO_NBFRAGS_DEFAULT;
  825. os->output = 1;
  826. os->mapped = 0;
  827. init_waitqueue_head(&os->frag_wq);
  828. init_waitqueue_head(&os->stop_wq);
  829. *os->drcmr = os->dma_ch | DRCMR_MAPVLD;
  830. }
  831. if (file->f_mode & FMODE_READ) {
  832. state->rd_ref = 1;
  833. is->fragsize = AUDIO_FRAGSIZE_DEFAULT;
  834. is->nbfrags = AUDIO_NBFRAGS_DEFAULT;
  835. is->output = 0;
  836. is->mapped = 0;
  837. init_waitqueue_head(&is->frag_wq);
  838. init_waitqueue_head(&is->stop_wq);
  839. *is->drcmr = is->dma_ch | DRCMR_MAPVLD;
  840. }
  842. err = 0;
  844. out:
  845. up(&state->sem);
  846. return err;
  847. }
  849. EXPORT_SYMBOL(pxa_audio_attach);
  850. EXPORT_SYMBOL(pxa_audio_clear_buf);