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

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

Linux/Unix编程

开发平台：

Unix_Linux

audio.c：源码内容
  1. /*
  2.  **********************************************************************
  3.  *     audio.c -- /dev/dsp interface for emu10k1 driver
  4.  *     Copyright 1999, 2000 Creative Labs, Inc.
  5.  *
  6.  **********************************************************************
  7.  *
  8.  *     Date                 Author          Summary of changes
  9.  *     ----                 ------          ------------------
  10.  *     October 20, 1999     Bertrand Lee    base code release
  11.  *     November 2, 1999     Alan Cox        cleaned up types/leaks
  12.  *
  13.  **********************************************************************
  14.  *
  15.  *     This program is free software; you can redistribute it and/or
  16.  *     modify it under the terms of the GNU General Public License as
  17.  *     published by the Free Software Foundation; either version 2 of
  18.  *     the License, or (at your option) any later version.
  19.  *
  20.  *     This program is distributed in the hope that it will be useful,
  21.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  *     GNU General Public License for more details.
  24.  *
  25.  *     You should have received a copy of the GNU General Public
  26.  *     License along with this program; if not, write to the Free
  27.  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  28.  *     USA.
  29.  *
  30.  **********************************************************************
  31.  */
  33. #define __NO_VERSION__
  34. #include <linux/module.h>
  35. #include <linux/poll.h>
  36. #include <linux/slab.h>
  37. #include <linux/version.h>
  38. #include <linux/bitops.h>
  39. #include <asm/io.h>
  40. #include <linux/sched.h>
  41. #include <linux/smp_lock.h>
  42. #include <linux/wrapper.h>
  45. #include "hwaccess.h"
  46. #include "cardwo.h"
  47. #include "cardwi.h"
  48. #include "recmgr.h"
  49. #include "irqmgr.h"
  50. #include "audio.h"
  51. #include "8010.h"
  53. static void calculate_ofrag(struct woinst *);
  54. static void calculate_ifrag(struct wiinst *);
  56. /* Audio file operations */
  57. static ssize_t emu10k1_audio_read(struct file *file, char *buffer, size_t count, loff_t * ppos)
  58. {
  59. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  60. struct wiinst *wiinst = wave_dev->wiinst;
  61. ssize_t ret = 0;
  62. unsigned long flags;
  64. DPD(3, "emu10k1_audio_read(), buffer=%p, count=%dn", buffer, (u32) count);
  66. if (ppos != &file->f_pos)
  67. return -ESPIPE;
  69. if (!access_ok(VERIFY_WRITE, buffer, count))
  70. return -EFAULT;
  72. spin_lock_irqsave(&wiinst->lock, flags);
  74. if (wiinst->mmapped) {
  75. spin_unlock_irqrestore(&wiinst->lock, flags);
  76. return -ENXIO;
  77. }
  79. if (wiinst->state == WAVE_STATE_CLOSED) {
  80. calculate_ifrag(wiinst);
  82. while (emu10k1_wavein_open(wave_dev) < 0) {
  83. spin_unlock_irqrestore(&wiinst->lock, flags);
  85. if (file->f_flags & O_NONBLOCK)
  86. return -EAGAIN;
  88. interruptible_sleep_on(&wave_dev->card->open_wait);
  90. if (signal_pending(current))
  91. return -ERESTARTSYS;
  93. spin_lock_irqsave(&wiinst->lock, flags);
  94. }
  95. }
  97. spin_unlock_irqrestore(&wiinst->lock, flags);
  99. while (count > 0) {
  100. u32 bytestocopy;
  102. spin_lock_irqsave(&wiinst->lock, flags);
  104. if (!(wiinst->state & WAVE_STATE_STARTED)
  105.     && (wave_dev->enablebits & PCM_ENABLE_INPUT))
  106. emu10k1_wavein_start(wave_dev);
  108. emu10k1_wavein_update(wave_dev->card, wiinst);
  109. emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
  111. spin_unlock_irqrestore(&wiinst->lock, flags);
  113. DPD(3, "bytestocopy --> %dn", bytestocopy);
  115. if ((bytestocopy >= wiinst->buffer.fragment_size)
  116.     || (bytestocopy >= count)) {
  117. bytestocopy = min_t(u32, bytestocopy, count);
  119. emu10k1_wavein_xferdata(wiinst, (u8 *) buffer, &bytestocopy);
  121. count -= bytestocopy;
  122. buffer += bytestocopy;
  123. ret += bytestocopy;
  124. }
  126. if (count > 0) {
  127. if ((file->f_flags & O_NONBLOCK)
  128.     || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
  129. return (ret ? ret : -EAGAIN);
  131. interruptible_sleep_on(&wiinst->wait_queue);
  133. if (signal_pending(current))
  134. return (ret ? ret : -ERESTARTSYS);
  136. }
  137. }
  139. DPD(3, "bytes copied -> %dn", (u32) ret);
  141. return ret;
  142. }
  144. static ssize_t emu10k1_audio_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
  145. {
  146. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  147. struct woinst *woinst = wave_dev->woinst;
  148. ssize_t ret;
  149. unsigned long flags;
  151. DPD(3, "emu10k1_audio_write(), buffer=%p, count=%dn", buffer, (u32) count);
  153. if (ppos != &file->f_pos)
  154. return -ESPIPE;
  156. if (!access_ok(VERIFY_READ, buffer, count))
  157. return -EFAULT;
  159. spin_lock_irqsave(&woinst->lock, flags);
  161. if (woinst->mmapped) {
  162. spin_unlock_irqrestore(&woinst->lock, flags);
  163. return -ENXIO;
  164. }
  166. if (woinst->format.passthrough) {
  167. int r;
  169. woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
  170. woinst->buffer.numfrags = PT_BLOCKCOUNT;
  171. calculate_ofrag(woinst);
  173. r = emu10k1_pt_write(file, buffer, count);
  174. spin_unlock_irqrestore(&woinst->lock, flags);
  175. return r;
  176. }
  178. if (woinst->state == WAVE_STATE_CLOSED) {
  179. calculate_ofrag(woinst);
  181. while (emu10k1_waveout_open(wave_dev) < 0) {
  182. spin_unlock_irqrestore(&woinst->lock, flags);
  184. if (file->f_flags & O_NONBLOCK)
  185. return -EAGAIN;
  187. interruptible_sleep_on(&wave_dev->card->open_wait);
  189. if (signal_pending(current))
  190. return -ERESTARTSYS;
  192. spin_lock_irqsave(&woinst->lock, flags);
  193. }
  194. }
  196. spin_unlock_irqrestore(&woinst->lock, flags);
  198. ret = 0;
  199. if (count % woinst->format.bytespersample)
  200.                 return -EINVAL;
  202. count /= woinst->num_voices;
  204. while (count > 0) {
  205. u32 bytestocopy;
  207. spin_lock_irqsave(&woinst->lock, flags);
  208. emu10k1_waveout_update(woinst);
  209. emu10k1_waveout_getxfersize(woinst, &bytestocopy);
  210. spin_unlock_irqrestore(&woinst->lock, flags);
  212. DPD(3, "bytestocopy --> %dn", bytestocopy);
  214. if ((bytestocopy >= woinst->buffer.fragment_size)
  215.     || (bytestocopy >= count)) {
  217. bytestocopy = min_t(u32, bytestocopy, count);
  219. emu10k1_waveout_xferdata(woinst, (u8 *) buffer, &bytestocopy);
  221. count -= bytestocopy;
  222. buffer += bytestocopy * woinst->num_voices;
  223. ret += bytestocopy * woinst->num_voices;
  225. spin_lock_irqsave(&woinst->lock, flags);
  226. woinst->total_copied += bytestocopy;
  228. if (!(woinst->state & WAVE_STATE_STARTED)
  229.     && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
  230.     && (woinst->total_copied >= woinst->buffer.fragment_size))
  231. emu10k1_waveout_start(wave_dev);
  233. spin_unlock_irqrestore(&woinst->lock, flags);
  234. }
  236. if (count > 0) {
  237. if ((file->f_flags & O_NONBLOCK)
  238.     || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
  239. return (ret ? ret : -EAGAIN);
  241. interruptible_sleep_on(&woinst->wait_queue);
  243. if (signal_pending(current))
  244. return (ret ? ret : -ERESTARTSYS);
  245. }
  246. }
  248. DPD(3, "bytes copied -> %dn", (u32) ret);
  250. return ret;
  251. }
  253. static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  254. {
  255. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  256. struct woinst *woinst = NULL;
  257. struct wiinst *wiinst = NULL;
  258. int val = 0;
  259. u32 bytestocopy;
  260. unsigned long flags;
  262. DPF(4, "emu10k1_audio_ioctl()n");
  264. if (file->f_mode & FMODE_WRITE)
  265. woinst = wave_dev->woinst;
  267. if (file->f_mode & FMODE_READ)
  268. wiinst = wave_dev->wiinst;
  270. switch (cmd) {
  271. case OSS_GETVERSION:
  272. DPF(2, "OSS_GETVERSION:n");
  273. return put_user(SOUND_VERSION, (int *) arg);
  275. case SNDCTL_DSP_RESET:
  276. DPF(2, "SNDCTL_DSP_RESET:n");
  277. wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
  279. if (file->f_mode & FMODE_WRITE) {
  280. spin_lock_irqsave(&woinst->lock, flags);
  282. if (woinst->state & WAVE_STATE_OPEN) {
  283. emu10k1_waveout_close(wave_dev);
  284. }
  286. woinst->mmapped = 0;
  287. woinst->total_copied = 0;
  288. woinst->total_played = 0;
  289. woinst->blocks = 0;
  291. spin_unlock_irqrestore(&woinst->lock, flags);
  292. }
  294. if (file->f_mode & FMODE_READ) {
  295. spin_lock_irqsave(&wiinst->lock, flags);
  297. if (wiinst->state & WAVE_STATE_OPEN) {
  298. emu10k1_wavein_close(wave_dev);
  299. }
  301. wiinst->mmapped = 0;
  302. wiinst->total_recorded = 0;
  303. wiinst->blocks = 0;
  304. spin_unlock_irqrestore(&wiinst->lock, flags);
  305. }
  307. break;
  309. case SNDCTL_DSP_SYNC:
  310. DPF(2, "SNDCTL_DSP_SYNC:n");
  312. if (file->f_mode & FMODE_WRITE) {
  314. spin_lock_irqsave(&woinst->lock, flags);
  316. if (woinst->state & WAVE_STATE_OPEN) {
  318. if (woinst->state & WAVE_STATE_STARTED)
  319. while ((woinst->total_played < woinst->total_copied)
  320.        && !signal_pending(current)) {
  321. spin_unlock_irqrestore(&woinst->lock, flags);
  322. interruptible_sleep_on(&woinst->wait_queue);
  323. spin_lock_irqsave(&woinst->lock, flags);
  324. }
  325. emu10k1_waveout_close(wave_dev);
  326. }
  328. woinst->mmapped = 0;
  329. woinst->total_copied = 0;
  330. woinst->total_played = 0;
  331. woinst->blocks = 0;
  333. spin_unlock_irqrestore(&woinst->lock, flags);
  334. }
  336. if (file->f_mode & FMODE_READ) {
  337. spin_lock_irqsave(&wiinst->lock, flags);
  339. if (wiinst->state & WAVE_STATE_OPEN) {
  340. emu10k1_wavein_close(wave_dev);
  341. }
  343. wiinst->mmapped = 0;
  344. wiinst->total_recorded = 0;
  345. wiinst->blocks = 0;
  346. spin_unlock_irqrestore(&wiinst->lock, flags);
  347. }
  349. break;
  351. case SNDCTL_DSP_SETDUPLEX:
  352. DPF(2, "SNDCTL_DSP_SETDUPLEX:n");
  353. break;
  355. case SNDCTL_DSP_GETCAPS:
  356. DPF(2, "SNDCTL_DSP_GETCAPS:n");
  357. return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_COPROC, (int *) arg);
  359. case SNDCTL_DSP_SPEED:
  360. DPF(2, "SNDCTL_DSP_SPEED:n");
  362. if (get_user(val, (int *) arg))
  363. return -EFAULT;
  365. DPD(2, "val is %dn", val);
  367. if (val > 0) {
  368. if (file->f_mode & FMODE_READ) {
  369. struct wave_format format;
  371. spin_lock_irqsave(&wiinst->lock, flags);
  373. format = wiinst->format;
  374. format.samplingrate = val;
  376. if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
  377. spin_unlock_irqrestore(&wiinst->lock, flags);
  378. return -EINVAL;
  379. }
  381. val = wiinst->format.samplingrate;
  383. spin_unlock_irqrestore(&wiinst->lock, flags);
  385. DPD(2, "set recording sampling rate -> %dn", val);
  386. }
  388. if (file->f_mode & FMODE_WRITE) {
  389. struct wave_format format;
  391. spin_lock_irqsave(&woinst->lock, flags);
  393. format = woinst->format;
  394. format.samplingrate = val;
  396. if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
  397. spin_unlock_irqrestore(&woinst->lock, flags);
  398. return -EINVAL;
  399. }
  401. val = woinst->format.samplingrate;
  403. spin_unlock_irqrestore(&woinst->lock, flags);
  405. DPD(2, "set playback sampling rate -> %dn", val);
  406. }
  408. return put_user(val, (int *) arg);
  409. } else {
  410. if (file->f_mode & FMODE_READ)
  411. val = wiinst->format.samplingrate;
  412. else if (file->f_mode & FMODE_WRITE)
  413. val = woinst->format.samplingrate;
  415. return put_user(val, (int *) arg);
  416. }
  417. break;
  419. case SNDCTL_DSP_STEREO:
  420. DPF(2, "SNDCTL_DSP_STEREO:n");
  422. if (get_user(val, (int *) arg))
  423. return -EFAULT;
  425. DPD(2, " val is %dn", val);
  427. if (file->f_mode & FMODE_READ) {
  428. struct wave_format format;
  430. spin_lock_irqsave(&wiinst->lock, flags);
  432. format = wiinst->format;
  433. format.channels = val ? 2 : 1;
  435. if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
  436. spin_unlock_irqrestore(&wiinst->lock, flags);
  437. return -EINVAL;
  438. }
  440. val = wiinst->format.channels - 1;
  442. spin_unlock_irqrestore(&wiinst->lock, flags);
  443. DPD(2, "set recording stereo -> %dn", val);
  444. }
  446. if (file->f_mode & FMODE_WRITE) {
  447. struct wave_format format;
  449. spin_lock_irqsave(&woinst->lock, flags);
  451. format = woinst->format;
  452. format.channels = val ? 2 : 1;
  454. if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
  455. spin_unlock_irqrestore(&woinst->lock, flags);
  456. return -EINVAL;
  457. }
  459. val = woinst->format.channels - 1;
  461. spin_unlock_irqrestore(&woinst->lock, flags);
  463. DPD(2, "set playback stereo -> %dn", val);
  464. }
  466. return put_user(val, (int *) arg);
  468. break;
  470. case SNDCTL_DSP_CHANNELS:
  471. DPF(2, "SNDCTL_DSP_CHANNELS:n");
  473. if (get_user(val, (int *) arg))
  474. return -EFAULT;
  476. DPD(2, " val is %dn", val);
  478. if (val > 0) {
  479. if (file->f_mode & FMODE_READ) {
  480. struct wave_format format;
  482. spin_lock_irqsave(&wiinst->lock, flags);
  484. format = wiinst->format;
  485. format.channels = val;
  487. if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
  488. spin_unlock_irqrestore(&wiinst->lock, flags);
  489. return -EINVAL;
  490. }
  491. val = wiinst->format.channels;
  493. spin_unlock_irqrestore(&wiinst->lock, flags);
  494. DPD(2, "set recording number of channels -> %dn", val);
  495. }
  497. if (file->f_mode & FMODE_WRITE) {
  498. struct wave_format format;
  500. spin_lock_irqsave(&woinst->lock, flags);
  502. format = woinst->format;
  503. format.channels = val;
  505. if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
  506. spin_unlock_irqrestore(&woinst->lock, flags);
  507. return -EINVAL;
  508. }
  510. val = woinst->format.channels;
  512. spin_unlock_irqrestore(&woinst->lock, flags);
  513. DPD(2, "set playback number of channels -> %dn", val);
  514. }
  516. return put_user(val, (int *) arg);
  517. } else {
  518. if (file->f_mode & FMODE_READ)
  519. val = wiinst->format.channels;
  520. else if (file->f_mode & FMODE_WRITE)
  521. val = woinst->format.channels;
  523. return put_user(val, (int *) arg);
  524. }
  525. break;
  527. case SNDCTL_DSP_GETFMTS:
  528. DPF(2, "SNDCTL_DSP_GETFMTS:n");
  530. if (file->f_mode & FMODE_READ)
  531. val = AFMT_S16_LE;
  532. else if (file->f_mode & FMODE_WRITE) {
  533. val = AFMT_S16_LE | AFMT_U8;
  534. if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
  535.           wave_dev->card->pt.patch_name, 
  536.           wave_dev->card->pt.enable_gpr_name) >= 0)
  537. val |= AFMT_AC3;
  538. }
  539. return put_user(val, (int *) arg);
  541. case SNDCTL_DSP_SETFMT: /* Same as SNDCTL_DSP_SAMPLESIZE */
  542. DPF(2, "SNDCTL_DSP_SETFMT:n");
  544. if (get_user(val, (int *) arg))
  545. return -EFAULT;
  547. DPD(2, " val is %dn", val);
  549. if (val != AFMT_QUERY) {
  550. if (file->f_mode & FMODE_READ) {
  551. struct wave_format format;
  553. spin_lock_irqsave(&wiinst->lock, flags);
  555. format = wiinst->format;
  556. format.id = val;
  558. if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
  559. spin_unlock_irqrestore(&wiinst->lock, flags);
  560. return -EINVAL;
  561. }
  563. val = wiinst->format.id;
  565. spin_unlock_irqrestore(&wiinst->lock, flags);
  566. DPD(2, "set recording format -> %dn", val);
  567. }
  569. if (file->f_mode & FMODE_WRITE) {
  570. struct wave_format format;
  572. spin_lock_irqsave(&woinst->lock, flags);
  574. format = woinst->format;
  575. format.id = val;
  577. if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
  578. spin_unlock_irqrestore(&woinst->lock, flags);
  579. return -EINVAL;
  580. }
  582. val = woinst->format.id;
  584. spin_unlock_irqrestore(&woinst->lock, flags);
  585. DPD(2, "set playback format -> %dn", val);
  586. }
  588. return put_user(val, (int *) arg);
  589. } else {
  590. if (file->f_mode & FMODE_READ)
  591. val = wiinst->format.id;
  592. else if (file->f_mode & FMODE_WRITE)
  593. val = woinst->format.id;
  595. return put_user(val, (int *) arg);
  596. }
  597. break;
  599. case SOUND_PCM_READ_BITS:
  601. if (file->f_mode & FMODE_READ)
  602. val = wiinst->format.bitsperchannel;
  603. else if (file->f_mode & FMODE_WRITE)
  604. val = woinst->format.bitsperchannel;
  606. return put_user(val, (int *) arg);
  608. case SOUND_PCM_READ_RATE:
  610. if (file->f_mode & FMODE_READ)
  611. val = wiinst->format.samplingrate;
  612. else if (file->f_mode & FMODE_WRITE)
  613. val = woinst->format.samplingrate;
  615. return put_user(val, (int *) arg);
  617. case SOUND_PCM_READ_CHANNELS:
  619. if (file->f_mode & FMODE_READ)
  620. val = wiinst->format.channels;
  621. else if (file->f_mode & FMODE_WRITE)
  622. val = woinst->format.channels;
  624. return put_user(val, (int *) arg);
  626. case SOUND_PCM_WRITE_FILTER:
  627. DPF(2, "SOUND_PCM_WRITE_FILTER: not implementedn");
  628. break;
  630. case SOUND_PCM_READ_FILTER:
  631. DPF(2, "SOUND_PCM_READ_FILTER: not implementedn");
  632. break;
  634. case SNDCTL_DSP_SETSYNCRO:
  635. DPF(2, "SNDCTL_DSP_SETSYNCRO: not implementedn");
  636. break;
  638. case SNDCTL_DSP_GETTRIGGER:
  639. DPF(2, "SNDCTL_DSP_GETTRIGGER:n");
  641. if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
  642. val |= PCM_ENABLE_OUTPUT;
  644. if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
  645. val |= PCM_ENABLE_INPUT;
  647. return put_user(val, (int *) arg);
  649. case SNDCTL_DSP_SETTRIGGER:
  650. DPF(2, "SNDCTL_DSP_SETTRIGGER:n");
  652. if (get_user(val, (int *) arg))
  653. return -EFAULT;
  655. if (file->f_mode & FMODE_WRITE) {
  656. spin_lock_irqsave(&woinst->lock, flags);
  658. if (val & PCM_ENABLE_OUTPUT) {
  659. wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
  660. if (woinst->state & WAVE_STATE_OPEN)
  661. emu10k1_waveout_start(wave_dev);
  662. } else {
  663. wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
  664. if (woinst->state & WAVE_STATE_STARTED)
  665. emu10k1_waveout_stop(wave_dev);
  666. }
  668. spin_unlock_irqrestore(&woinst->lock, flags);
  669. }
  671. if (file->f_mode & FMODE_READ) {
  672. spin_lock_irqsave(&wiinst->lock, flags);
  674. if (val & PCM_ENABLE_INPUT) {
  675. wave_dev->enablebits |= PCM_ENABLE_INPUT;
  676. if (wiinst->state & WAVE_STATE_OPEN)
  677. emu10k1_wavein_start(wave_dev);
  678. } else {
  679. wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
  680. if (wiinst->state & WAVE_STATE_STARTED)
  681. emu10k1_wavein_stop(wave_dev);
  682. }
  684. spin_unlock_irqrestore(&wiinst->lock, flags);
  685. }
  686. break;
  688. case SNDCTL_DSP_GETOSPACE:
  689. {
  690. audio_buf_info info;
  692. DPF(4, "SNDCTL_DSP_GETOSPACE:n");
  694. if (!(file->f_mode & FMODE_WRITE))
  695. return -EINVAL;
  697. spin_lock_irqsave(&woinst->lock, flags);
  699. if (woinst->state & WAVE_STATE_OPEN) {
  700. emu10k1_waveout_update(woinst);
  701. emu10k1_waveout_getxfersize(woinst, &bytestocopy);
  702. info.bytes = bytestocopy;
  703. } else {
  704. calculate_ofrag(woinst);
  705. info.bytes = woinst->buffer.size;
  706. }
  707. spin_unlock_irqrestore(&woinst->lock, flags);
  709. info.bytes *= woinst->num_voices;
  710. info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
  711. info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
  712. info.fragments = info.bytes / info.fragsize;
  714. if (copy_to_user((int *) arg, &info, sizeof(info)))
  715. return -EFAULT;
  716. }
  717. break;
  719. case SNDCTL_DSP_GETISPACE:
  720. {
  721. audio_buf_info info;
  723. DPF(4, "SNDCTL_DSP_GETISPACE:n");
  725. if (!(file->f_mode & FMODE_READ))
  726. return -EINVAL;
  728. spin_lock_irqsave(&wiinst->lock, flags);
  729. if (wiinst->state & WAVE_STATE_OPEN) {
  730. emu10k1_wavein_update(wave_dev->card, wiinst);
  731. emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
  732. info.bytes = bytestocopy;
  733. } else {
  734. calculate_ifrag(wiinst);
  735. info.bytes = 0;
  736. }
  737. spin_unlock_irqrestore(&wiinst->lock, flags);
  739. info.fragstotal = wiinst->buffer.numfrags;
  740. info.fragments = info.bytes / wiinst->buffer.fragment_size;
  741. info.fragsize = wiinst->buffer.fragment_size;
  743. if (copy_to_user((int *) arg, &info, sizeof(info)))
  744. return -EFAULT;
  745. }
  746. break;
  748. case SNDCTL_DSP_NONBLOCK:
  749. DPF(2, "SNDCTL_DSP_NONBLOCK:n");
  751. file->f_flags |= O_NONBLOCK;
  752. break;
  754. case SNDCTL_DSP_GETODELAY:
  755. DPF(4, "SNDCTL_DSP_GETODELAY:n");
  757. if (!(file->f_mode & FMODE_WRITE))
  758. return -EINVAL;
  760. spin_lock_irqsave(&woinst->lock, flags);
  761. if (woinst->state & WAVE_STATE_OPEN) {
  762. emu10k1_waveout_update(woinst);
  763. emu10k1_waveout_getxfersize(woinst, &bytestocopy);
  764. val = woinst->buffer.size - bytestocopy;
  765. } else
  766. val = 0;
  768. val *= woinst->num_voices;
  769. spin_unlock_irqrestore(&woinst->lock, flags);
  771. return put_user(val, (int *) arg);
  773. case SNDCTL_DSP_GETIPTR:
  774. {
  775. count_info cinfo;
  777. DPF(4, "SNDCTL_DSP_GETIPTR: n");
  779. if (!(file->f_mode & FMODE_READ))
  780. return -EINVAL;
  782. spin_lock_irqsave(&wiinst->lock, flags);
  784. if (wiinst->state & WAVE_STATE_OPEN) {
  785. emu10k1_wavein_update(wave_dev->card, wiinst);
  786. cinfo.ptr = wiinst->buffer.hw_pos;
  787. cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
  788. cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
  789. wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
  790. } else {
  791. cinfo.ptr = 0;
  792. cinfo.bytes = 0;
  793. cinfo.blocks = 0;
  794. }
  796. if(wiinst->mmapped)
  797. wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
  799. spin_unlock_irqrestore(&wiinst->lock, flags);
  801. if (copy_to_user((void *) arg, &cinfo, sizeof(cinfo)))
  802. return -EFAULT;
  803. }
  804. break;
  806. case SNDCTL_DSP_GETOPTR:
  807. {
  808. count_info cinfo;
  810. DPF(4, "SNDCTL_DSP_GETOPTR:n");
  812. if (!(file->f_mode & FMODE_WRITE))
  813. return -EINVAL;
  815. spin_lock_irqsave(&woinst->lock, flags);
  817. if (woinst->state & WAVE_STATE_OPEN || 
  818.     (woinst->format.passthrough && wave_dev->card->pt.state)) {
  819. int num_fragments;
  820. if (woinst->format.passthrough) {
  821. emu10k1_pt_waveout_update(wave_dev);
  822. cinfo.bytes = woinst->total_played;
  823. } else {
  824. emu10k1_waveout_update(woinst);
  825. cinfo.bytes = woinst->total_played;
  826. }
  827. cinfo.ptr = woinst->buffer.hw_pos;
  828. num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
  829. cinfo.blocks = num_fragments - woinst->blocks;
  830. woinst->blocks = num_fragments;
  832. cinfo.bytes *= woinst->num_voices;
  833. cinfo.ptr *= woinst->num_voices;
  834. } else {
  835. cinfo.ptr = 0;
  836. cinfo.bytes = 0;
  837. cinfo.blocks = 0;
  838. }
  840. if (woinst->mmapped)
  841. woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
  843. spin_unlock_irqrestore(&woinst->lock, flags);
  845. if (copy_to_user((void *) arg, &cinfo, sizeof(cinfo)))
  846. return -EFAULT;
  847. }
  848. break;
  850. case SNDCTL_DSP_GETBLKSIZE:
  851. DPF(2, "SNDCTL_DSP_GETBLKSIZE:n");
  853. if (file->f_mode & FMODE_WRITE) {
  854. spin_lock_irqsave(&woinst->lock, flags);
  856. calculate_ofrag(woinst);
  857. val = woinst->buffer.fragment_size * woinst->num_voices;
  859. spin_unlock_irqrestore(&woinst->lock, flags);
  860. }
  862. if (file->f_mode & FMODE_READ) {
  863. spin_lock_irqsave(&wiinst->lock, flags);
  865. calculate_ifrag(wiinst);
  866. val = wiinst->buffer.fragment_size;
  868. spin_unlock_irqrestore(&wiinst->lock, flags);
  869. }
  871. return put_user(val, (int *) arg);
  873. break;
  875. case SNDCTL_DSP_POST:
  876. if (file->f_mode & FMODE_WRITE) {
  877. spin_lock_irqsave(&woinst->lock, flags);
  879. if (!(woinst->state & WAVE_STATE_STARTED)
  880.     && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
  881.     && (woinst->total_copied > 0))
  882. emu10k1_waveout_start(wave_dev);
  884. spin_unlock_irqrestore(&woinst->lock, flags);
  885. }
  887. break;
  889. case SNDCTL_DSP_SUBDIVIDE:
  890. DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implementedn");
  891. break;
  893. case SNDCTL_DSP_SETFRAGMENT:
  894. DPF(2, "SNDCTL_DSP_SETFRAGMENT:n");
  896. if (get_user(val, (int *) arg))
  897. return -EFAULT;
  899. DPD(2, "val is %#xn", val);
  901. if (val == 0)
  902. return -EIO;
  904. if (file->f_mode & FMODE_WRITE) {
  905. /* digital pass-through fragment count and size are fixed values */
  906. if (woinst->state & WAVE_STATE_OPEN || woinst->format.passthrough)
  907. return -EINVAL; /* too late to change */
  909. woinst->buffer.ossfragshift = val & 0xffff;
  910. woinst->buffer.numfrags = (val >> 16) & 0xffff;
  911. }
  913. if (file->f_mode & FMODE_READ) {
  914. if (wiinst->state & WAVE_STATE_OPEN)
  915. return -EINVAL; /* too late to change */
  917. wiinst->buffer.ossfragshift = val & 0xffff;
  918. wiinst->buffer.numfrags = (val >> 16) & 0xffff;
  919. }
  921. break;
  923. case SNDCTL_COPR_LOAD:
  924. {
  925. copr_buffer *buf;
  926. u32 i;
  928. DPF(4, "SNDCTL_COPR_LOAD:n");
  930. buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
  931. if (!buf)
  932. return -ENOMEM;
  934. if (copy_from_user(buf, (copr_buffer *) arg, sizeof(copr_buffer))) {
  935. kfree (buf);
  936. return -EFAULT;
  937. }
  939. if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
  940. kfree (buf);
  941. return -EINVAL;
  942. }
  943. #ifdef DBGEMU
  944. if ( (buf->offs < 0) || (buf->offs + buf->len > 0x800) || (buf->len > 1000)) {
  945. #else
  946. if ( ((buf->offs < 0x100 ) || (buf->offs + buf->len > 0x800) || (buf->len > 1000))
  947.      && !( ( buf->offs == DBG) && (buf->len ==1) )){
  948. #endif
  949. kfree(buf);
  950. return -EINVAL;
  951. }
  953. if (buf->command == CMD_READ) {
  954. for (i = 0; i < buf->len; i++)
  955. ((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, 0);
  957. if (copy_to_user((copr_buffer *) arg, buf, sizeof(copr_buffer))) {
  958. kfree(buf);
  959. return -EFAULT;
  960. }
  961. } else {
  962. for (i = 0; i < buf->len; i++)
  963. sblive_writeptr(wave_dev->card, buf->offs + i, 0, ((u32 *) buf->data)[i]);
  964. }
  966. kfree (buf);
  967. break;
  968. }
  970. default: /* Default is unrecognized command */
  971. DPD(2, "default: %#xn", cmd);
  972. return -EINVAL;
  973. }
  974. return 0;
  975. }
  977. static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int write_access)
  978. {
  979. struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
  980. struct woinst *woinst = wave_dev->woinst;
  981. struct wiinst *wiinst = wave_dev->wiinst;
  982. struct page *dmapage;
  983. unsigned long pgoff;
  984. int rd, wr;
  986. DPF(3, "emu10k1_mm_nopage()n");
  987. DPD(3, "addr: %#lxn", address);
  989. if (address > vma->vm_end) {
  990. DPF(1, "EXIT, returning NOPAGE_SIGBUSn");
  991. return NOPAGE_SIGBUS; /* Disallow mremap */
  992. }
  994. pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
  995. if (woinst != NULL)
  996. wr = woinst->mmapped;
  997. else
  998. wr = 0;
  1000. if (wiinst != NULL)
  1001. rd = wiinst->mmapped;
  1002. else
  1003. rd = 0;
  1005. /* if full-duplex (read+write) and we have two sets of bufs,
  1006. * then the playback buffers come first, sez soundcard.c */
  1007. if (wr) {
  1008. if (pgoff >= woinst->buffer.pages) {
  1009. pgoff -= woinst->buffer.pages;
  1010. dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
  1011. } else
  1012. dmapage = virt_to_page (woinst->voice[0].mem.addr[pgoff]);
  1013. } else {
  1014. dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
  1015. }
  1017. get_page (dmapage);
  1019. DPD(3, "page: %#lxn", (unsigned long) dmapage);
  1020. return dmapage;
  1021. }
  1023. struct vm_operations_struct emu10k1_mm_ops = {
  1024. nopage:         emu10k1_mm_nopage,
  1025. };
  1027. static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
  1028. {
  1029. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  1030. unsigned long max_pages, n_pages, pgoffset;
  1031. struct woinst *woinst = NULL;
  1032. struct wiinst *wiinst = NULL;
  1033. unsigned long flags;
  1035. DPF(2, "emu10k1_audio_mmap()n");
  1037. max_pages = 0;
  1038. if (vma->vm_flags & VM_WRITE) {
  1039. woinst = wave_dev->woinst;
  1041. spin_lock_irqsave(&woinst->lock, flags);
  1043. /* No m'mapping possible for multichannel */
  1044. if (woinst->num_voices > 1) {
  1045. spin_unlock_irqrestore(&woinst->lock, flags);
  1046.                  return -EINVAL;
  1047. }
  1049. if (woinst->state == WAVE_STATE_CLOSED) {
  1050. calculate_ofrag(woinst);
  1052. if (emu10k1_waveout_open(wave_dev) < 0) {
  1053. spin_unlock_irqrestore(&woinst->lock, flags);
  1054. ERROR();
  1055. return -EINVAL;
  1056. }
  1057. }
  1059. woinst->mmapped = 1;
  1060. max_pages += woinst->buffer.pages;
  1061. spin_unlock_irqrestore(&woinst->lock, flags);
  1062. }
  1064. if (vma->vm_flags & VM_READ) {
  1065. wiinst = wave_dev->wiinst;
  1067. spin_lock_irqsave(&wiinst->lock, flags);
  1068. if (wiinst->state == WAVE_STATE_CLOSED) {
  1069. calculate_ifrag(wiinst);
  1071. if (emu10k1_wavein_open(wave_dev) < 0) {
  1072. spin_unlock_irqrestore(&wiinst->lock, flags);
  1073. ERROR();
  1074. return -EINVAL;
  1075. }
  1076. }
  1078. wiinst->mmapped = 1;
  1079. max_pages += wiinst->buffer.pages;
  1080. spin_unlock_irqrestore(&wiinst->lock, flags);
  1081. }
  1083. n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;
  1084. pgoffset = vma->vm_pgoff;
  1086. DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ldn", vma->vm_start, vma->vm_end, pgoffset);
  1087. DPD(2, "n_pages: %ld, max_pages: %ldn", n_pages, max_pages);
  1089. if (pgoffset + n_pages > max_pages)
  1090. return -EINVAL;
  1092. vma->vm_flags |= VM_RESERVED;
  1093. vma->vm_ops = &emu10k1_mm_ops;
  1094. vma->vm_private_data = wave_dev;
  1095. return 0;
  1096. }
  1098. static int emu10k1_audio_open(struct inode *inode, struct file *file)
  1099. {
  1100. int minor = MINOR(inode->i_rdev);
  1101. struct emu10k1_card *card = NULL;
  1102. struct list_head *entry;
  1103. struct emu10k1_wavedevice *wave_dev;
  1105. DPF(2, "emu10k1_audio_open()n");
  1107. /* Check for correct device to open */
  1109. list_for_each(entry, &emu10k1_devs) {
  1110. card = list_entry(entry, struct emu10k1_card, list);
  1112. if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
  1113. goto match;
  1114. }
  1116. return -ENODEV;
  1118. match:
  1120. wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
  1122. if (wave_dev == NULL) { 
  1123. ERROR();
  1124. return -ENOMEM;
  1125. }
  1127. wave_dev->card = card;
  1128. wave_dev->wiinst = NULL;
  1129. wave_dev->woinst = NULL;
  1130. wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT; /* Default */
  1132. if (file->f_mode & FMODE_READ) {
  1133. /* Recording */
  1134. struct wiinst *wiinst;
  1136. if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
  1137. ERROR();
  1138. return -ENODEV;
  1139. }
  1141. wiinst->recsrc = card->wavein.recsrc;
  1142.                 wiinst->fxwc = card->wavein.fxwc;
  1144. switch (wiinst->recsrc) {
  1145. case WAVERECORD_AC97:
  1146. wiinst->format.id = AFMT_S16_LE;
  1147. wiinst->format.samplingrate = 8000;
  1148. wiinst->format.bitsperchannel = 16;
  1149. wiinst->format.channels = 1;
  1150. break;
  1151. case WAVERECORD_MIC:
  1152. wiinst->format.id = AFMT_S16_LE;
  1153. wiinst->format.samplingrate = 8000;
  1154. wiinst->format.bitsperchannel = 16;
  1155. wiinst->format.channels = 1;
  1156. break;
  1157. case WAVERECORD_FX:
  1158. wiinst->format.id = AFMT_S16_LE;
  1159. wiinst->format.samplingrate = 48000;
  1160. wiinst->format.bitsperchannel = 16;
  1161. wiinst->format.channels = hweight32(wiinst->fxwc);
  1162. break;
  1163. default:
  1164. BUG();
  1165. break;
  1166. }
  1168. wiinst->state = WAVE_STATE_CLOSED;
  1170. wiinst->buffer.ossfragshift = 0;
  1171. wiinst->buffer.fragment_size = 0;
  1172. wiinst->buffer.numfrags = 0;
  1174. init_waitqueue_head(&wiinst->wait_queue);
  1176. wiinst->mmapped = 0;
  1177. wiinst->total_recorded = 0;
  1178. wiinst->blocks = 0;
  1179. wiinst->lock = SPIN_LOCK_UNLOCKED;
  1180. tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
  1181. wave_dev->wiinst = wiinst;
  1182. emu10k1_wavein_setformat(wave_dev, &wiinst->format);
  1183. }
  1185. if (file->f_mode & FMODE_WRITE) {
  1186. struct woinst *woinst;
  1187. int i;
  1189. if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
  1190. ERROR();
  1191. return -ENODEV;
  1192. }
  1194. if (wave_dev->wiinst != NULL) {
  1195. woinst->format = wave_dev->wiinst->format;
  1196. } else {
  1197. woinst->format.id = AFMT_U8;
  1198. woinst->format.samplingrate = 8000;
  1199. woinst->format.bitsperchannel = 8;
  1200. woinst->format.channels = 1;
  1201. }
  1203. woinst->state = WAVE_STATE_CLOSED;
  1205. woinst->buffer.fragment_size = 0;
  1206. woinst->buffer.ossfragshift = 0;
  1207. woinst->buffer.numfrags = 0;
  1208. woinst->device = (card->audio_dev1 == minor);
  1209. woinst->timer.state = TIMER_STATE_UNINSTALLED;
  1210. woinst->num_voices = 1;
  1211. for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
  1212. woinst->voice[i].usage = VOICE_USAGE_FREE;
  1213. woinst->voice[i].mem.emupageindex = -1;
  1214. }
  1216. init_waitqueue_head(&woinst->wait_queue);
  1218. woinst->mmapped = 0;
  1219. woinst->total_copied = 0;
  1220. woinst->total_played = 0;
  1221. woinst->blocks = 0;
  1222. woinst->lock = SPIN_LOCK_UNLOCKED;
  1223. tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
  1224. wave_dev->woinst = woinst;
  1225. emu10k1_waveout_setformat(wave_dev, &woinst->format);
  1226. }
  1228. file->private_data = (void *) wave_dev;
  1230. return 0;
  1231. }
  1233. static int emu10k1_audio_release(struct inode *inode, struct file *file)
  1234. {
  1235. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  1236. struct emu10k1_card *card;
  1237. unsigned long flags;
  1239. card = wave_dev->card;
  1241. DPF(2, "emu10k1_audio_release()n");
  1243. if (file->f_mode & FMODE_WRITE) {
  1244. struct woinst *woinst = wave_dev->woinst;
  1246. spin_lock_irqsave(&woinst->lock, flags);
  1248. if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE) {
  1249. spin_lock(&card->pt.lock);
  1250.                         emu10k1_pt_stop(card);
  1251. spin_unlock(&card->pt.lock);
  1252. }
  1253. if (woinst->state & WAVE_STATE_OPEN) {
  1254. if (woinst->state & WAVE_STATE_STARTED) {
  1255. if (!(file->f_flags & O_NONBLOCK)) {
  1256. while (!signal_pending(current)
  1257.        && (woinst->total_played < woinst->total_copied)) {
  1258. DPF(4, "Buffer hasn't been totally played, sleep....n");
  1259. spin_unlock_irqrestore(&woinst->lock, flags);
  1260. interruptible_sleep_on(&woinst->wait_queue);
  1261. spin_lock_irqsave(&woinst->lock, flags);
  1262. }
  1263. }
  1264. }
  1265. emu10k1_waveout_close(wave_dev);
  1266. }
  1268. spin_unlock_irqrestore(&woinst->lock, flags);
  1269. /* remove the tasklet */
  1270. tasklet_kill(&woinst->timer.tasklet);
  1271. kfree(wave_dev->woinst);
  1272. }
  1274. if (file->f_mode & FMODE_READ) {
  1275. struct wiinst *wiinst = wave_dev->wiinst;
  1277. spin_lock_irqsave(&wiinst->lock, flags);
  1279. if (wiinst->state & WAVE_STATE_OPEN) {
  1280. emu10k1_wavein_close(wave_dev);
  1281. }
  1283. spin_unlock_irqrestore(&wiinst->lock, flags);
  1284. tasklet_kill(&wiinst->timer.tasklet);
  1285. kfree(wave_dev->wiinst);
  1286. }
  1288. kfree(wave_dev);
  1290. if (waitqueue_active(&card->open_wait))
  1291. wake_up_interruptible(&card->open_wait);
  1293. return 0;
  1294. }
  1296. /* FIXME sort out poll() + mmap() */
  1297. static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
  1298. {
  1299. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
  1300. struct woinst *woinst = wave_dev->woinst;
  1301. struct wiinst *wiinst = wave_dev->wiinst;
  1302. unsigned int mask = 0;
  1303. u32 bytestocopy;
  1304. unsigned long flags;
  1306. DPF(4, "emu10k1_audio_poll()n");
  1308. if (file->f_mode & FMODE_WRITE)
  1309. poll_wait(file, &woinst->wait_queue, wait);
  1311. if (file->f_mode & FMODE_READ)
  1312. poll_wait(file, &wiinst->wait_queue, wait);
  1314. if (file->f_mode & FMODE_WRITE) {
  1315. spin_lock_irqsave(&woinst->lock, flags);
  1317. if (woinst->state & WAVE_STATE_OPEN) {
  1318. emu10k1_waveout_update(woinst);
  1319. emu10k1_waveout_getxfersize(woinst, &bytestocopy);
  1321. if (bytestocopy >= woinst->buffer.fragment_size)
  1322. mask |= POLLOUT | POLLWRNORM;
  1323. } else
  1324. mask |= POLLOUT | POLLWRNORM;
  1326. spin_unlock_irqrestore(&woinst->lock, flags);
  1327. }
  1329. if (file->f_mode & FMODE_READ) {
  1330. spin_lock_irqsave(&wiinst->lock, flags);
  1332. if (wiinst->state & WAVE_STATE_OPEN) {
  1333. emu10k1_wavein_update(wave_dev->card, wiinst);
  1334. emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
  1336. if (bytestocopy >= wiinst->buffer.fragment_size)
  1337. mask |= POLLIN | POLLRDNORM;
  1338. }
  1340. spin_unlock_irqrestore(&wiinst->lock, flags);
  1341. }
  1343. return mask;
  1344. }
  1346. static void calculate_ofrag(struct woinst *woinst)
  1347. {
  1348. struct waveout_buffer *buffer = &woinst->buffer;
  1349. u32 fragsize;
  1351. if (buffer->fragment_size)
  1352. return;
  1354. if (!buffer->ossfragshift) {
  1355. fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
  1357. while (fragsize) {
  1358. fragsize >>= 1;
  1359. buffer->ossfragshift++;
  1360. }
  1361. }
  1363. if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
  1364. buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
  1366. buffer->fragment_size = 1 << buffer->ossfragshift;
  1368. while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)
  1369. buffer->fragment_size >>= 1;
  1371. /* now we are sure that:
  1372.  (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)
  1373. */
  1375. if (!buffer->numfrags) {
  1376. u32 numfrags;
  1378. numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
  1379.    (buffer->fragment_size * 1000) - 1;
  1381. buffer->numfrags = 1;
  1383. while (numfrags) {
  1384. numfrags >>= 1;
  1385. buffer->numfrags <<= 1;
  1386. }
  1387. }
  1389. if (buffer->numfrags < WAVEOUT_MINFRAGS)
  1390. buffer->numfrags = WAVEOUT_MINFRAGS;
  1392. if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)
  1393. buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
  1395. if (buffer->numfrags < WAVEOUT_MINFRAGS)
  1396. BUG();
  1398. buffer->size = buffer->fragment_size * buffer->numfrags;
  1399. buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
  1401. DPD(2, " calculated playback fragment_size -> %dn", buffer->fragment_size);
  1402. DPD(2, " calculated playback numfrags -> %dn", buffer->numfrags);
  1404. return;
  1405. }
  1407. static void calculate_ifrag(struct wiinst *wiinst)
  1408. {
  1409. struct wavein_buffer *buffer = &wiinst->buffer;
  1410. u32 fragsize, bufsize, size[4];
  1411. int i, j;
  1413. if (buffer->fragment_size)
  1414. return;
  1416. if (!buffer->ossfragshift) {
  1417. fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
  1419. while (fragsize) {
  1420. fragsize >>= 1;
  1421. buffer->ossfragshift++;
  1422. }
  1423. }
  1425. if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
  1426. buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
  1428. buffer->fragment_size = 1 << buffer->ossfragshift;
  1430. while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)
  1431. buffer->fragment_size >>= 1;
  1433. /* now we are sure that:
  1434.    (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)
  1435.         */
  1438. if (!buffer->numfrags)
  1439. buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
  1441. if (buffer->numfrags < WAVEIN_MINFRAGS)
  1442. buffer->numfrags = WAVEIN_MINFRAGS;
  1444. if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)
  1445. buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
  1447. if (buffer->numfrags < WAVEIN_MINFRAGS)
  1448. BUG();
  1450. bufsize = buffer->fragment_size * buffer->numfrags;
  1452. /* the buffer size for recording is restricted to certain values, adjust it now */
  1453. if (bufsize >= 0x10000) {
  1454. buffer->size = 0x10000;
  1455. buffer->sizeregval = 0x1f;
  1456. } else {
  1457. buffer->size = 0;
  1458. size[0] = 384;
  1459. size[1] = 448;
  1460. size[2] = 512;
  1461. size[3] = 640;
  1463. for (i = 0; i < 8; i++)
  1464. for (j = 0; j < 4; j++)
  1465. if (bufsize >= size[j]) {
  1466. buffer->size = size[j];
  1467. size[j] *= 2;
  1468. buffer->sizeregval = i * 4 + j + 1;
  1469. } else
  1470. goto exitloop;
  1471.       exitloop:
  1472. if (buffer->size == 0) {
  1473. buffer->size = 384;
  1474. buffer->sizeregval = 0x01;
  1475. }
  1476. }
  1478. /* adjust the fragment size so that buffer size is an integer multiple */
  1479. while (buffer->size % buffer->fragment_size)
  1480. buffer->fragment_size >>= 1;
  1482. buffer->numfrags = buffer->size / buffer->fragment_size;
  1483. buffer->pages =  buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
  1485. DPD(2, " calculated recording fragment_size -> %dn", buffer->fragment_size);
  1486. DPD(2, " calculated recording numfrags -> %dn", buffer->numfrags);
  1487. DPD(2, " buffer size register -> %#04xn", buffer->sizeregval);
  1489. return;
  1490. }
  1492. void emu10k1_wavein_bh(unsigned long refdata)
  1493. {
  1494. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
  1495. struct wiinst *wiinst = wave_dev->wiinst;
  1496. u32 bytestocopy;
  1497. unsigned long flags;
  1499. if (!wiinst)
  1500. return;
  1502. spin_lock_irqsave(&wiinst->lock, flags);
  1504. if (!(wiinst->state & WAVE_STATE_STARTED)) {
  1505. spin_unlock_irqrestore(&wiinst->lock, flags);
  1506. return;
  1507. }
  1509. emu10k1_wavein_update(wave_dev->card, wiinst);
  1510. emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
  1512. spin_unlock_irqrestore(&wiinst->lock, flags);
  1514. if (bytestocopy >= wiinst->buffer.fragment_size) {
  1515.   if (waitqueue_active(&wiinst->wait_queue))
  1516. wake_up_interruptible(&wiinst->wait_queue);
  1517. } else
  1518. DPD(3, "Not enough transfer size, %dn", bytestocopy);
  1520. return;
  1521. }
  1523. void emu10k1_waveout_bh(unsigned long refdata)
  1524. {
  1525. struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
  1526. struct woinst *woinst = wave_dev->woinst;
  1527. u32 bytestocopy;
  1528. unsigned long flags;
  1530. if (!woinst)
  1531. return;
  1533. spin_lock_irqsave(&woinst->lock, flags);
  1535. if (!(woinst->state & WAVE_STATE_STARTED)) {
  1536. spin_unlock_irqrestore(&woinst->lock, flags);
  1537. return;
  1538. }
  1540. emu10k1_waveout_update(woinst);
  1541. emu10k1_waveout_getxfersize(woinst, &bytestocopy);
  1543. if (woinst->buffer.fill_silence) {
  1544. spin_unlock_irqrestore(&woinst->lock, flags);
  1545. emu10k1_waveout_fillsilence(woinst);
  1546. } else
  1547. spin_unlock_irqrestore(&woinst->lock, flags);
  1549. if (bytestocopy >= woinst->buffer.fragment_size) {
  1550. if (waitqueue_active(&woinst->wait_queue))
  1551. wake_up_interruptible(&woinst->wait_queue);
  1552. } else
  1553. DPD(3, "Not enough transfer size -> %dn", bytestocopy);
  1555. return;
  1556. }
  1558. struct file_operations emu10k1_audio_fops = {
  1559. owner: THIS_MODULE,
  1560. llseek: no_llseek,
  1561. read: emu10k1_audio_read,
  1562. write: emu10k1_audio_write,
  1563. poll: emu10k1_audio_poll,
  1564. ioctl: emu10k1_audio_ioctl,
  1565. mmap: emu10k1_audio_mmap,
  1566. open: emu10k1_audio_open,
  1567. release: emu10k1_audio_release,
  1568. };