soundcard.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742
  1. /*
  2. * linux/sound/oss/soundcard.c
  3. *
  4. * Sound card driver for Linux
  5. *
  6. *
  7. * Copyright (C) by Hannu Savolainen 1993-1997
  8. *
  9. * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10. * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11. * for more info.
  12. *
  13. *
  14. * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
  15. * integrated sound_switch.c
  16. * Stefan Reinauer : integrated /proc/sound (equals to /dev/sndstat,
  17. * which should disappear in the near future)
  18. * Eric Dumas : devfs support (22-Jan-98) <dumas@linux.eu.org> with
  19. * fixups by C. Scott Ananian <cananian@alumni.princeton.edu>
  20. * Richard Gooch : moved common (non OSS-specific) devices to sound_core.c
  21. * Rob Riggs : Added persistent DMA buffers support (1998/10/17)
  22. * Christoph Hellwig : Some cleanup work (2000/03/01)
  23. */
  24. #include "sound_config.h"
  25. #include <linux/init.h>
  26. #include <linux/types.h>
  27. #include <linux/errno.h>
  28. #include <linux/signal.h>
  29. #include <linux/fcntl.h>
  30. #include <linux/ctype.h>
  31. #include <linux/stddef.h>
  32. #include <linux/kmod.h>
  33. #include <linux/kernel.h>
  34. #include <asm/dma.h>
  35. #include <asm/io.h>
  36. #include <linux/wait.h>
  37. #include <linux/slab.h>
  38. #include <linux/ioport.h>
  39. #include <linux/major.h>
  40. #include <linux/delay.h>
  41. #include <linux/proc_fs.h>
  42. #include <linux/smp_lock.h>
  43. #include <linux/module.h>
  44. #include <linux/mm.h>
  45. /*
  46. * This ought to be moved into include/asm/dma.h
  47. */
  48. #ifndef valid_dma
  49. #define valid_dma(n) ((n) >= 0 && (n) < MAX_DMA_CHANNELS && (n) != 4)
  50. #endif
  51. /*
  52. * Table for permanently allocated memory (used when unloading the module)
  53. */
  54. void * sound_mem_blocks[1024];
  55. int sound_nblocks = 0;
  56. /* Persistent DMA buffers */
  57. #ifdef CONFIG_SOUND_DMAP
  58. int sound_dmap_flag = 1;
  59. #else
  60. int sound_dmap_flag = 0;
  61. #endif
  62. static char dma_alloc_map[MAX_DMA_CHANNELS];
  63. #define DMA_MAP_UNAVAIL 0
  64. #define DMA_MAP_FREE 1
  65. #define DMA_MAP_BUSY 2
  66. unsigned long seq_time = 0; /* Time for /dev/sequencer */
  67. extern struct class *sound_class;
  68. /*
  69. * Table for configurable mixer volume handling
  70. */
  71. static mixer_vol_table mixer_vols[MAX_MIXER_DEV];
  72. static int num_mixer_volumes;
  73. int *load_mixer_volumes(char *name, int *levels, int present)
  74. {
  75. int i, n;
  76. for (i = 0; i < num_mixer_volumes; i++) {
  77. if (strcmp(name, mixer_vols[i].name) == 0) {
  78. if (present)
  79. mixer_vols[i].num = i;
  80. return mixer_vols[i].levels;
  81. }
  82. }
  83. if (num_mixer_volumes >= MAX_MIXER_DEV) {
  84. printk(KERN_ERR "Sound: Too many mixers (%s)\n", name);
  85. return levels;
  86. }
  87. n = num_mixer_volumes++;
  88. strcpy(mixer_vols[n].name, name);
  89. if (present)
  90. mixer_vols[n].num = n;
  91. else
  92. mixer_vols[n].num = -1;
  93. for (i = 0; i < 32; i++)
  94. mixer_vols[n].levels[i] = levels[i];
  95. return mixer_vols[n].levels;
  96. }
  97. EXPORT_SYMBOL(load_mixer_volumes);
  98. static int set_mixer_levels(void __user * arg)
  99. {
  100. /* mixer_vol_table is 174 bytes, so IMHO no reason to not allocate it on the stack */
  101. mixer_vol_table buf;
  102. if (__copy_from_user(&buf, arg, sizeof(buf)))
  103. return -EFAULT;
  104. load_mixer_volumes(buf.name, buf.levels, 0);
  105. if (__copy_to_user(arg, &buf, sizeof(buf)))
  106. return -EFAULT;
  107. return 0;
  108. }
  109. static int get_mixer_levels(void __user * arg)
  110. {
  111. int n;
  112. if (__get_user(n, (int __user *)(&(((mixer_vol_table __user *)arg)->num))))
  113. return -EFAULT;
  114. if (n < 0 || n >= num_mixer_volumes)
  115. return -EINVAL;
  116. if (__copy_to_user(arg, &mixer_vols[n], sizeof(mixer_vol_table)))
  117. return -EFAULT;
  118. return 0;
  119. }
  120. /* 4K page size but our output routines use some slack for overruns */
  121. #define PROC_BLOCK_SIZE (3*1024)
  122. static ssize_t sound_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
  123. {
  124. int dev = iminor(file->f_path.dentry->d_inode);
  125. int ret = -EINVAL;
  126. /*
  127. * The OSS drivers aren't remotely happy without this locking,
  128. * and unless someone fixes them when they are about to bite the
  129. * big one anyway, we might as well bandage here..
  130. */
  131. lock_kernel();
  132. DEB(printk("sound_read(dev=%d, count=%d)\n", dev, count));
  133. switch (dev & 0x0f) {
  134. case SND_DEV_DSP:
  135. case SND_DEV_DSP16:
  136. case SND_DEV_AUDIO:
  137. ret = audio_read(dev, file, buf, count);
  138. break;
  139. case SND_DEV_SEQ:
  140. case SND_DEV_SEQ2:
  141. ret = sequencer_read(dev, file, buf, count);
  142. break;
  143. case SND_DEV_MIDIN:
  144. ret = MIDIbuf_read(dev, file, buf, count);
  145. }
  146. unlock_kernel();
  147. return ret;
  148. }
  149. static ssize_t sound_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
  150. {
  151. int dev = iminor(file->f_path.dentry->d_inode);
  152. int ret = -EINVAL;
  153. lock_kernel();
  154. DEB(printk("sound_write(dev=%d, count=%d)\n", dev, count));
  155. switch (dev & 0x0f) {
  156. case SND_DEV_SEQ:
  157. case SND_DEV_SEQ2:
  158. ret = sequencer_write(dev, file, buf, count);
  159. break;
  160. case SND_DEV_DSP:
  161. case SND_DEV_DSP16:
  162. case SND_DEV_AUDIO:
  163. ret = audio_write(dev, file, buf, count);
  164. break;
  165. case SND_DEV_MIDIN:
  166. ret = MIDIbuf_write(dev, file, buf, count);
  167. break;
  168. }
  169. unlock_kernel();
  170. return ret;
  171. }
  172. static int sound_open(struct inode *inode, struct file *file)
  173. {
  174. int dev = iminor(inode);
  175. int retval;
  176. DEB(printk("sound_open(dev=%d)\n", dev));
  177. if ((dev >= SND_NDEVS) || (dev < 0)) {
  178. printk(KERN_ERR "Invalid minor device %d\n", dev);
  179. return -ENXIO;
  180. }
  181. switch (dev & 0x0f) {
  182. case SND_DEV_CTL:
  183. dev >>= 4;
  184. if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
  185. request_module("mixer%d", dev);
  186. }
  187. if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
  188. return -ENXIO;
  189. if (!try_module_get(mixer_devs[dev]->owner))
  190. return -ENXIO;
  191. break;
  192. case SND_DEV_SEQ:
  193. case SND_DEV_SEQ2:
  194. if ((retval = sequencer_open(dev, file)) < 0)
  195. return retval;
  196. break;
  197. case SND_DEV_MIDIN:
  198. if ((retval = MIDIbuf_open(dev, file)) < 0)
  199. return retval;
  200. break;
  201. case SND_DEV_DSP:
  202. case SND_DEV_DSP16:
  203. case SND_DEV_AUDIO:
  204. if ((retval = audio_open(dev, file)) < 0)
  205. return retval;
  206. break;
  207. default:
  208. printk(KERN_ERR "Invalid minor device %d\n", dev);
  209. return -ENXIO;
  210. }
  211. return 0;
  212. }
  213. static int sound_release(struct inode *inode, struct file *file)
  214. {
  215. int dev = iminor(inode);
  216. lock_kernel();
  217. DEB(printk("sound_release(dev=%d)\n", dev));
  218. switch (dev & 0x0f) {
  219. case SND_DEV_CTL:
  220. module_put(mixer_devs[dev >> 4]->owner);
  221. break;
  222. case SND_DEV_SEQ:
  223. case SND_DEV_SEQ2:
  224. sequencer_release(dev, file);
  225. break;
  226. case SND_DEV_MIDIN:
  227. MIDIbuf_release(dev, file);
  228. break;
  229. case SND_DEV_DSP:
  230. case SND_DEV_DSP16:
  231. case SND_DEV_AUDIO:
  232. audio_release(dev, file);
  233. break;
  234. default:
  235. printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev);
  236. }
  237. unlock_kernel();
  238. return 0;
  239. }
  240. static int get_mixer_info(int dev, void __user *arg)
  241. {
  242. mixer_info info;
  243. memset(&info, 0, sizeof(info));
  244. strlcpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
  245. strlcpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
  246. info.modify_counter = mixer_devs[dev]->modify_counter;
  247. if (__copy_to_user(arg, &info, sizeof(info)))
  248. return -EFAULT;
  249. return 0;
  250. }
  251. static int get_old_mixer_info(int dev, void __user *arg)
  252. {
  253. _old_mixer_info info;
  254. memset(&info, 0, sizeof(info));
  255. strlcpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
  256. strlcpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
  257. if (copy_to_user(arg, &info, sizeof(info)))
  258. return -EFAULT;
  259. return 0;
  260. }
  261. static int sound_mixer_ioctl(int mixdev, unsigned int cmd, void __user *arg)
  262. {
  263. if (mixdev < 0 || mixdev >= MAX_MIXER_DEV)
  264. return -ENXIO;
  265. /* Try to load the mixer... */
  266. if (mixer_devs[mixdev] == NULL) {
  267. request_module("mixer%d", mixdev);
  268. }
  269. if (mixdev >= num_mixers || !mixer_devs[mixdev])
  270. return -ENXIO;
  271. if (cmd == SOUND_MIXER_INFO)
  272. return get_mixer_info(mixdev, arg);
  273. if (cmd == SOUND_OLD_MIXER_INFO)
  274. return get_old_mixer_info(mixdev, arg);
  275. if (_SIOC_DIR(cmd) & _SIOC_WRITE)
  276. mixer_devs[mixdev]->modify_counter++;
  277. if (!mixer_devs[mixdev]->ioctl)
  278. return -EINVAL;
  279. return mixer_devs[mixdev]->ioctl(mixdev, cmd, arg);
  280. }
  281. static int sound_ioctl(struct inode *inode, struct file *file,
  282. unsigned int cmd, unsigned long arg)
  283. {
  284. int len = 0, dtype;
  285. int dev = iminor(inode);
  286. void __user *p = (void __user *)arg;
  287. if (_SIOC_DIR(cmd) != _SIOC_NONE && _SIOC_DIR(cmd) != 0) {
  288. /*
  289. * Have to validate the address given by the process.
  290. */
  291. len = _SIOC_SIZE(cmd);
  292. if (len < 1 || len > 65536 || !p)
  293. return -EFAULT;
  294. if (_SIOC_DIR(cmd) & _SIOC_WRITE)
  295. if (!access_ok(VERIFY_READ, p, len))
  296. return -EFAULT;
  297. if (_SIOC_DIR(cmd) & _SIOC_READ)
  298. if (!access_ok(VERIFY_WRITE, p, len))
  299. return -EFAULT;
  300. }
  301. DEB(printk("sound_ioctl(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
  302. if (cmd == OSS_GETVERSION)
  303. return __put_user(SOUND_VERSION, (int __user *)p);
  304. if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 && /* Mixer ioctl */
  305. (dev & 0x0f) != SND_DEV_CTL) {
  306. dtype = dev & 0x0f;
  307. switch (dtype) {
  308. case SND_DEV_DSP:
  309. case SND_DEV_DSP16:
  310. case SND_DEV_AUDIO:
  311. return sound_mixer_ioctl(audio_devs[dev >> 4]->mixer_dev,
  312. cmd, p);
  313. default:
  314. return sound_mixer_ioctl(dev >> 4, cmd, p);
  315. }
  316. }
  317. switch (dev & 0x0f) {
  318. case SND_DEV_CTL:
  319. if (cmd == SOUND_MIXER_GETLEVELS)
  320. return get_mixer_levels(p);
  321. if (cmd == SOUND_MIXER_SETLEVELS)
  322. return set_mixer_levels(p);
  323. return sound_mixer_ioctl(dev >> 4, cmd, p);
  324. case SND_DEV_SEQ:
  325. case SND_DEV_SEQ2:
  326. return sequencer_ioctl(dev, file, cmd, p);
  327. case SND_DEV_DSP:
  328. case SND_DEV_DSP16:
  329. case SND_DEV_AUDIO:
  330. return audio_ioctl(dev, file, cmd, p);
  331. break;
  332. case SND_DEV_MIDIN:
  333. return MIDIbuf_ioctl(dev, file, cmd, p);
  334. break;
  335. }
  336. return -EINVAL;
  337. }
  338. static unsigned int sound_poll(struct file *file, poll_table * wait)
  339. {
  340. struct inode *inode = file->f_path.dentry->d_inode;
  341. int dev = iminor(inode);
  342. DEB(printk("sound_poll(dev=%d)\n", dev));
  343. switch (dev & 0x0f) {
  344. case SND_DEV_SEQ:
  345. case SND_DEV_SEQ2:
  346. return sequencer_poll(dev, file, wait);
  347. case SND_DEV_MIDIN:
  348. return MIDIbuf_poll(dev, file, wait);
  349. case SND_DEV_DSP:
  350. case SND_DEV_DSP16:
  351. case SND_DEV_AUDIO:
  352. return DMAbuf_poll(file, dev >> 4, wait);
  353. }
  354. return 0;
  355. }
  356. static int sound_mmap(struct file *file, struct vm_area_struct *vma)
  357. {
  358. int dev_class;
  359. unsigned long size;
  360. struct dma_buffparms *dmap = NULL;
  361. int dev = iminor(file->f_path.dentry->d_inode);
  362. dev_class = dev & 0x0f;
  363. dev >>= 4;
  364. if (dev_class != SND_DEV_DSP && dev_class != SND_DEV_DSP16 && dev_class != SND_DEV_AUDIO) {
  365. printk(KERN_ERR "Sound: mmap() not supported for other than audio devices\n");
  366. return -EINVAL;
  367. }
  368. lock_kernel();
  369. if (vma->vm_flags & VM_WRITE) /* Map write and read/write to the output buf */
  370. dmap = audio_devs[dev]->dmap_out;
  371. else if (vma->vm_flags & VM_READ)
  372. dmap = audio_devs[dev]->dmap_in;
  373. else {
  374. printk(KERN_ERR "Sound: Undefined mmap() access\n");
  375. unlock_kernel();
  376. return -EINVAL;
  377. }
  378. if (dmap == NULL) {
  379. printk(KERN_ERR "Sound: mmap() error. dmap == NULL\n");
  380. unlock_kernel();
  381. return -EIO;
  382. }
  383. if (dmap->raw_buf == NULL) {
  384. printk(KERN_ERR "Sound: mmap() called when raw_buf == NULL\n");
  385. unlock_kernel();
  386. return -EIO;
  387. }
  388. if (dmap->mapping_flags) {
  389. printk(KERN_ERR "Sound: mmap() called twice for the same DMA buffer\n");
  390. unlock_kernel();
  391. return -EIO;
  392. }
  393. if (vma->vm_pgoff != 0) {
  394. printk(KERN_ERR "Sound: mmap() offset must be 0.\n");
  395. unlock_kernel();
  396. return -EINVAL;
  397. }
  398. size = vma->vm_end - vma->vm_start;
  399. if (size != dmap->bytes_in_use) {
  400. printk(KERN_WARNING "Sound: mmap() size = %ld. Should be %d\n", size, dmap->bytes_in_use);
  401. }
  402. if (remap_pfn_range(vma, vma->vm_start,
  403. virt_to_phys(dmap->raw_buf) >> PAGE_SHIFT,
  404. vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
  405. unlock_kernel();
  406. return -EAGAIN;
  407. }
  408. dmap->mapping_flags |= DMA_MAP_MAPPED;
  409. if( audio_devs[dev]->d->mmap)
  410. audio_devs[dev]->d->mmap(dev);
  411. memset(dmap->raw_buf,
  412. dmap->neutral_byte,
  413. dmap->bytes_in_use);
  414. unlock_kernel();
  415. return 0;
  416. }
  417. const struct file_operations oss_sound_fops = {
  418. .owner = THIS_MODULE,
  419. .llseek = no_llseek,
  420. .read = sound_read,
  421. .write = sound_write,
  422. .poll = sound_poll,
  423. .ioctl = sound_ioctl,
  424. .mmap = sound_mmap,
  425. .open = sound_open,
  426. .release = sound_release,
  427. };
  428. /*
  429. * Create the required special subdevices
  430. */
  431. static int create_special_devices(void)
  432. {
  433. int seq1,seq2;
  434. seq1=register_sound_special(&oss_sound_fops, 1);
  435. if(seq1==-1)
  436. goto bad;
  437. seq2=register_sound_special(&oss_sound_fops, 8);
  438. if(seq2!=-1)
  439. return 0;
  440. unregister_sound_special(1);
  441. bad:
  442. return -1;
  443. }
  444. /* These device names follow the official Linux device list,
  445. * Documentation/devices.txt. Let us know if there are other
  446. * common names we should support for compatibility.
  447. * Only those devices not created by the generic code in sound_core.c are
  448. * registered here.
  449. */
  450. static const struct {
  451. unsigned short minor;
  452. char *name;
  453. umode_t mode;
  454. int *num;
  455. } dev_list[] = { /* list of minor devices */
  456. /* seems to be some confusion here -- this device is not in the device list */
  457. {SND_DEV_DSP16, "dspW", S_IWUGO | S_IRUSR | S_IRGRP,
  458. &num_audiodevs},
  459. {SND_DEV_AUDIO, "audio", S_IWUGO | S_IRUSR | S_IRGRP,
  460. &num_audiodevs},
  461. };
  462. static int dmabuf;
  463. static int dmabug;
  464. module_param(dmabuf, int, 0444);
  465. module_param(dmabug, int, 0444);
  466. static int __init oss_init(void)
  467. {
  468. int err;
  469. int i, j;
  470. #ifdef CONFIG_PCI
  471. if(dmabug)
  472. isa_dma_bridge_buggy = dmabug;
  473. #endif
  474. err = create_special_devices();
  475. if (err) {
  476. printk(KERN_ERR "sound: driver already loaded/included in kernel\n");
  477. return err;
  478. }
  479. /* Protecting the innocent */
  480. sound_dmap_flag = (dmabuf > 0 ? 1 : 0);
  481. for (i = 0; i < ARRAY_SIZE(dev_list); i++) {
  482. device_create(sound_class, NULL,
  483. MKDEV(SOUND_MAJOR, dev_list[i].minor),
  484. "%s", dev_list[i].name);
  485. if (!dev_list[i].num)
  486. continue;
  487. for (j = 1; j < *dev_list[i].num; j++)
  488. device_create(sound_class, NULL,
  489. MKDEV(SOUND_MAJOR, dev_list[i].minor + (j*0x10)),
  490. "%s%d", dev_list[i].name, j);
  491. }
  492. if (sound_nblocks >= 1024)
  493. printk(KERN_ERR "Sound warning: Deallocation table was too small.\n");
  494. return 0;
  495. }
  496. static void __exit oss_cleanup(void)
  497. {
  498. int i, j;
  499. for (i = 0; i < ARRAY_SIZE(dev_list); i++) {
  500. device_destroy(sound_class, MKDEV(SOUND_MAJOR, dev_list[i].minor));
  501. if (!dev_list[i].num)
  502. continue;
  503. for (j = 1; j < *dev_list[i].num; j++)
  504. device_destroy(sound_class, MKDEV(SOUND_MAJOR, dev_list[i].minor + (j*0x10)));
  505. }
  506. unregister_sound_special(1);
  507. unregister_sound_special(8);
  508. sound_stop_timer();
  509. sequencer_unload();
  510. for (i = 0; i < MAX_DMA_CHANNELS; i++)
  511. if (dma_alloc_map[i] != DMA_MAP_UNAVAIL) {
  512. printk(KERN_ERR "Sound: Hmm, DMA%d was left allocated - fixed\n", i);
  513. sound_free_dma(i);
  514. }
  515. for (i = 0; i < sound_nblocks; i++)
  516. vfree(sound_mem_blocks[i]);
  517. }
  518. module_init(oss_init);
  519. module_exit(oss_cleanup);
  520. MODULE_LICENSE("GPL");
  521. MODULE_DESCRIPTION("OSS Sound subsystem");
  522. MODULE_AUTHOR("Hannu Savolainen, et al.");
  523. int sound_alloc_dma(int chn, char *deviceID)
  524. {
  525. int err;
  526. if ((err = request_dma(chn, deviceID)) != 0)
  527. return err;
  528. dma_alloc_map[chn] = DMA_MAP_FREE;
  529. return 0;
  530. }
  531. EXPORT_SYMBOL(sound_alloc_dma);
  532. int sound_open_dma(int chn, char *deviceID)
  533. {
  534. if (!valid_dma(chn)) {
  535. printk(KERN_ERR "sound_open_dma: Invalid DMA channel %d\n", chn);
  536. return 1;
  537. }
  538. if (dma_alloc_map[chn] != DMA_MAP_FREE) {
  539. printk("sound_open_dma: DMA channel %d busy or not allocated (%d)\n", chn, dma_alloc_map[chn]);
  540. return 1;
  541. }
  542. dma_alloc_map[chn] = DMA_MAP_BUSY;
  543. return 0;
  544. }
  545. EXPORT_SYMBOL(sound_open_dma);
  546. void sound_free_dma(int chn)
  547. {
  548. if (dma_alloc_map[chn] == DMA_MAP_UNAVAIL) {
  549. /* printk( "sound_free_dma: Bad access to DMA channel %d\n", chn); */
  550. return;
  551. }
  552. free_dma(chn);
  553. dma_alloc_map[chn] = DMA_MAP_UNAVAIL;
  554. }
  555. EXPORT_SYMBOL(sound_free_dma);
  556. void sound_close_dma(int chn)
  557. {
  558. if (dma_alloc_map[chn] != DMA_MAP_BUSY) {
  559. printk(KERN_ERR "sound_close_dma: Bad access to DMA channel %d\n", chn);
  560. return;
  561. }
  562. dma_alloc_map[chn] = DMA_MAP_FREE;
  563. }
  564. EXPORT_SYMBOL(sound_close_dma);
  565. static void do_sequencer_timer(unsigned long dummy)
  566. {
  567. sequencer_timer(0);
  568. }
  569. static DEFINE_TIMER(seq_timer, do_sequencer_timer, 0, 0);
  570. void request_sound_timer(int count)
  571. {
  572. extern unsigned long seq_time;
  573. if (count < 0) {
  574. seq_timer.expires = (-count) + jiffies;
  575. add_timer(&seq_timer);
  576. return;
  577. }
  578. count += seq_time;
  579. count -= jiffies;
  580. if (count < 1)
  581. count = 1;
  582. seq_timer.expires = (count) + jiffies;
  583. add_timer(&seq_timer);
  584. }
  585. void sound_stop_timer(void)
  586. {
  587. del_timer(&seq_timer);
  588. }
  589. void conf_printf(char *name, struct address_info *hw_config)
  590. {
  591. #ifndef CONFIG_SOUND_TRACEINIT
  592. return;
  593. #else
  594. printk("<%s> at 0x%03x", name, hw_config->io_base);
  595. if (hw_config->irq)
  596. printk(" irq %d", (hw_config->irq > 0) ? hw_config->irq : -hw_config->irq);
  597. if (hw_config->dma != -1 || hw_config->dma2 != -1)
  598. {
  599. printk(" dma %d", hw_config->dma);
  600. if (hw_config->dma2 != -1)
  601. printk(",%d", hw_config->dma2);
  602. }
  603. printk("\n");
  604. #endif
  605. }
  606. EXPORT_SYMBOL(conf_printf);
  607. void conf_printf2(char *name, int base, int irq, int dma, int dma2)
  608. {
  609. #ifndef CONFIG_SOUND_TRACEINIT
  610. return;
  611. #else
  612. printk("<%s> at 0x%03x", name, base);
  613. if (irq)
  614. printk(" irq %d", (irq > 0) ? irq : -irq);
  615. if (dma != -1 || dma2 != -1)
  616. {
  617. printk(" dma %d", dma);
  618. if (dma2 != -1)
  619. printk(",%d", dma2);
  620. }
  621. printk("\n");
  622. #endif
  623. }
  624. EXPORT_SYMBOL(conf_printf2);