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

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

嵌入式Linux

开发平台：

Unix_Linux

dmasound_paula.c：源码内容
  1. /*
  2.  *  linux/drivers/sound/dmasound/dmasound_paula.c
  3.  *
  4.  *  Amiga `Paula' DMA Sound Driver
  5.  *
  6.  *  See linux/drivers/sound/dmasound/dmasound_core.c for copyright and credits
  7.  *  prior to 28/01/2001
  8.  *
  9.  *  28/01/2001 [0.1] Iain Sandoe
  10.  *      - added versioning
  11.  *      - put in and populated the hardware_afmts field.
  12.  *             [0.2] - put in SNDCTL_DSP_GETCAPS value.
  13.  *        [0.3] - put in constraint on state buffer usage.
  14.  *        [0.4] - put in default hard/soft settings
  15. */
  18. #include <linux/module.h>
  19. #include <linux/config.h>
  20. #include <linux/mm.h>
  21. #include <linux/init.h>
  22. #include <linux/ioport.h>
  23. #include <linux/soundcard.h>
  25. #include <asm/uaccess.h>
  26. #include <asm/setup.h>
  27. #include <asm/amigahw.h>
  28. #include <asm/amigaints.h>
  29. #include <asm/machdep.h>
  31. #include "dmasound.h"
  33. #define DMASOUND_PAULA_REVISION 0
  34. #define DMASOUND_PAULA_EDITION 4
  36.    /*
  37.     * The minimum period for audio depends on htotal (for OCS/ECS/AGA)
  38.     * (Imported from arch/m68k/amiga/amisound.c)
  39.     */
  41. extern volatile u_short amiga_audio_min_period;
  44.    /*
  45.     * amiga_mksound() should be able to restore the period after beeping
  46.     * (Imported from arch/m68k/amiga/amisound.c)
  47.     */
  49. extern u_short amiga_audio_period;
  52.    /*
  53.     * Audio DMA masks
  54.     */
  56. #define AMI_AUDIO_OFF (DMAF_AUD0 | DMAF_AUD1 | DMAF_AUD2 | DMAF_AUD3)
  57. #define AMI_AUDIO_8 (DMAF_SETCLR | DMAF_MASTER | DMAF_AUD0 | DMAF_AUD1)
  58. #define AMI_AUDIO_14 (AMI_AUDIO_8 | DMAF_AUD2 | DMAF_AUD3)
  61.     /*
  62.      *  Helper pointers for 16(14)-bit sound
  63.      */
  65. static int write_sq_block_size_half, write_sq_block_size_quarter;
  68. /*** Low level stuff *********************************************************/
  71. static void AmiOpen(void);
  72. static void AmiRelease(void);
  73. static void *AmiAlloc(unsigned int size, int flags);
  74. static void AmiFree(void *obj, unsigned int size);
  75. static int AmiIrqInit(void);
  76. #ifdef MODULE
  77. static void AmiIrqCleanUp(void);
  78. #endif
  79. static void AmiSilence(void);
  80. static void AmiInit(void);
  81. static int AmiSetFormat(int format);
  82. static int AmiSetVolume(int volume);
  83. static int AmiSetTreble(int treble);
  84. static void AmiPlayNextFrame(int index);
  85. static void AmiPlay(void);
  86. static void AmiInterrupt(int irq, void *dummy, struct pt_regs *fp);
  88. #ifdef CONFIG_HEARTBEAT
  90.     /*
  91.      *  Heartbeat interferes with sound since the 7 kHz low-pass filter and the
  92.      *  power LED are controlled by the same line.
  93.      */
  95. #ifdef CONFIG_APUS
  96. #define mach_heartbeat ppc_md.heartbeat
  97. #endif
  99. static void (*saved_heartbeat)(int) = NULL;
  101. static inline void disable_heartbeat(void)
  102. {
  103. if (mach_heartbeat) {
  104.     saved_heartbeat = mach_heartbeat;
  105.     mach_heartbeat = NULL;
  106. }
  107. AmiSetTreble(dmasound.treble);
  108. }
  110. static inline void enable_heartbeat(void)
  111. {
  112. if (saved_heartbeat)
  113.     mach_heartbeat = saved_heartbeat;
  114. }
  115. #else /* !CONFIG_HEARTBEAT */
  116. #define disable_heartbeat() do { } while (0)
  117. #define enable_heartbeat() do { } while (0)
  118. #endif /* !CONFIG_HEARTBEAT */
  121. /*** Mid level stuff *********************************************************/
  123. static void AmiMixerInit(void);
  124. static int AmiMixerIoctl(u_int cmd, u_long arg);
  125. static void AmiWriteSqSetup(void);
  126. static int AmiStateInfo(char *buffer, size_t space);
  129. /*** Translations ************************************************************/
  131. /* ++TeSche: radically changed for new expanding purposes...
  132.  *
  133.  * These two routines now deal with copying/expanding/translating the samples
  134.  * from user space into our buffer at the right frequency. They take care about
  135.  * how much data there's actually to read, how much buffer space there is and
  136.  * to convert samples into the right frequency/encoding. They will only work on
  137.  * complete samples so it may happen they leave some bytes in the input stream
  138.  * if the user didn't write a multiple of the current sample size. They both
  139.  * return the number of bytes they've used from both streams so you may detect
  140.  * such a situation. Luckily all programs should be able to cope with that.
  141.  *
  142.  * I think I've optimized anything as far as one can do in plain C, all
  143.  * variables should fit in registers and the loops are really short. There's
  144.  * one loop for every possible situation. Writing a more generalized and thus
  145.  * parameterized loop would only produce slower code. Feel free to optimize
  146.  * this in assembler if you like. :)
  147.  *
  148.  * I think these routines belong here because they're not yet really hardware
  149.  * independent, especially the fact that the Falcon can play 16bit samples
  150.  * only in stereo is hardcoded in both of them!
  151.  *
  152.  * ++geert: split in even more functions (one per format)
  153.  */
  156.     /*
  157.      *  Native format
  158.      */
  160. static ssize_t ami_ct_s8(const u_char *userPtr, size_t userCount,
  161.  u_char frame[], ssize_t *frameUsed, ssize_t frameLeft)
  162. {
  163. ssize_t count, used;
  165. if (!dmasound.soft.stereo) {
  166. void *p = &frame[*frameUsed];
  167. count = min_t(unsigned long, userCount, frameLeft) & ~1;
  168. used = count;
  169. if (copy_from_user(p, userPtr, count))
  170. return -EFAULT;
  171. } else {
  172. u_char *left = &frame[*frameUsed>>1];
  173. u_char *right = left+write_sq_block_size_half;
  174. count = min_t(unsigned long, userCount, frameLeft)>>1 & ~1;
  175. used = count*2;
  176. while (count > 0) {
  177. if (get_user(*left++, userPtr++)
  178.     || get_user(*right++, userPtr++))
  179. return -EFAULT;
  180. count--;
  181. }
  182. }
  183. *frameUsed += used;
  184. return used;
  185. }
  188.     /*
  189.      *  Copy and convert 8 bit data
  190.      */
  192. #define GENERATE_AMI_CT8(funcname, convsample)
  193. static ssize_t funcname(const u_char *userPtr, size_t userCount,
  194. u_char frame[], ssize_t *frameUsed,
  195. ssize_t frameLeft)
  196. {
  197. ssize_t count, used;
  199. if (!dmasound.soft.stereo) {
  200. u_char *p = &frame[*frameUsed];
  201. count = min_t(size_t, userCount, frameLeft) & ~1;
  202. used = count;
  203. while (count > 0) {
  204. u_char data;
  205. if (get_user(data, userPtr++))
  206. return -EFAULT;
  207. *p++ = convsample(data);
  208. count--;
  209. }
  210. } else {
  211. u_char *left = &frame[*frameUsed>>1];
  212. u_char *right = left+write_sq_block_size_half;
  213. count = min_t(size_t, userCount, frameLeft)>>1 & ~1;
  214. used = count*2;
  215. while (count > 0) {
  216. u_char data;
  217. if (get_user(data, userPtr++))
  218. return -EFAULT;
  219. *left++ = convsample(data);
  220. if (get_user(data, userPtr++))
  221. return -EFAULT;
  222. *right++ = convsample(data);
  223. count--;
  224. }
  225. }
  226. *frameUsed += used;
  227. return used;
  228. }
  230. #define AMI_CT_ULAW(x) (dmasound_ulaw2dma8[(x)])
  231. #define AMI_CT_ALAW(x) (dmasound_alaw2dma8[(x)])
  232. #define AMI_CT_U8(x) ((x) ^ 0x80)
  234. GENERATE_AMI_CT8(ami_ct_ulaw, AMI_CT_ULAW)
  235. GENERATE_AMI_CT8(ami_ct_alaw, AMI_CT_ALAW)
  236. GENERATE_AMI_CT8(ami_ct_u8, AMI_CT_U8)
  239.     /*
  240.      *  Copy and convert 16 bit data
  241.      */
  243. #define GENERATE_AMI_CT_16(funcname, convsample)
  244. static ssize_t funcname(const u_char *userPtr, size_t userCount,
  245. u_char frame[], ssize_t *frameUsed,
  246. ssize_t frameLeft)
  247. {
  248. ssize_t count, used;
  249. u_short data;
  251. if (!dmasound.soft.stereo) {
  252. u_char *high = &frame[*frameUsed>>1];
  253. u_char *low = high+write_sq_block_size_half;
  254. count = min_t(size_t, userCount, frameLeft)>>1 & ~1;
  255. used = count*2;
  256. while (count > 0) {
  257. if (get_user(data, ((u_short *)userPtr)++))
  258. return -EFAULT;
  259. data = convsample(data);
  260. *high++ = data>>8;
  261. *low++ = (data>>2) & 0x3f;
  262. count--;
  263. }
  264. } else {
  265. u_char *lefth = &frame[*frameUsed>>2];
  266. u_char *leftl = lefth+write_sq_block_size_quarter;
  267. u_char *righth = lefth+write_sq_block_size_half;
  268. u_char *rightl = righth+write_sq_block_size_quarter;
  269. count = min_t(size_t, userCount, frameLeft)>>2 & ~1;
  270. used = count*4;
  271. while (count > 0) {
  272. if (get_user(data, ((u_short *)userPtr)++))
  273. return -EFAULT;
  274. data = convsample(data);
  275. *lefth++ = data>>8;
  276. *leftl++ = (data>>2) & 0x3f;
  277. if (get_user(data, ((u_short *)userPtr)++))
  278. return -EFAULT;
  279. data = convsample(data);
  280. *righth++ = data>>8;
  281. *rightl++ = (data>>2) & 0x3f;
  282. count--;
  283. }
  284. }
  285. *frameUsed += used;
  286. return used;
  287. }
  289. #define AMI_CT_S16BE(x) (x)
  290. #define AMI_CT_U16BE(x) ((x) ^ 0x8000)
  291. #define AMI_CT_S16LE(x) (le2be16((x)))
  292. #define AMI_CT_U16LE(x) (le2be16((x)) ^ 0x8000)
  294. GENERATE_AMI_CT_16(ami_ct_s16be, AMI_CT_S16BE)
  295. GENERATE_AMI_CT_16(ami_ct_u16be, AMI_CT_U16BE)
  296. GENERATE_AMI_CT_16(ami_ct_s16le, AMI_CT_S16LE)
  297. GENERATE_AMI_CT_16(ami_ct_u16le, AMI_CT_U16LE)
  300. static TRANS transAmiga = {
  301. ct_ulaw: ami_ct_ulaw,
  302. ct_alaw: ami_ct_alaw,
  303. ct_s8: ami_ct_s8,
  304. ct_u8: ami_ct_u8,
  305. ct_s16be: ami_ct_s16be,
  306. ct_u16be: ami_ct_u16be,
  307. ct_s16le: ami_ct_s16le,
  308. ct_u16le: ami_ct_u16le,
  309. };
  311. /*** Low level stuff *********************************************************/
  314. static void AmiOpen(void)
  315. {
  316. MOD_INC_USE_COUNT;
  317. }
  319. static void AmiRelease(void)
  320. {
  321. MOD_DEC_USE_COUNT;
  322. }
  324. static inline void StopDMA(void)
  325. {
  326. custom.aud[0].audvol = custom.aud[1].audvol = 0;
  327. custom.aud[2].audvol = custom.aud[3].audvol = 0;
  328. custom.dmacon = AMI_AUDIO_OFF;
  329. enable_heartbeat();
  330. }
  332. static void *AmiAlloc(unsigned int size, int flags)
  333. {
  334. return amiga_chip_alloc((long)size, "dmasound [Paula]");
  335. }
  337. static void AmiFree(void *obj, unsigned int size)
  338. {
  339. amiga_chip_free (obj);
  340. }
  342. static int __init AmiIrqInit(void)
  343. {
  344. /* turn off DMA for audio channels */
  345. StopDMA();
  347. /* Register interrupt handler. */
  348. if (request_irq(IRQ_AMIGA_AUD0, AmiInterrupt, 0, "DMA sound",
  349. AmiInterrupt))
  350. return 0;
  351. return 1;
  352. }
  354. #ifdef MODULE
  355. static void AmiIrqCleanUp(void)
  356. {
  357. /* turn off DMA for audio channels */
  358. StopDMA();
  359. /* release the interrupt */
  360. free_irq(IRQ_AMIGA_AUD0, AmiInterrupt);
  361. }
  362. #endif /* MODULE */
  364. static void AmiSilence(void)
  365. {
  366. /* turn off DMA for audio channels */
  367. StopDMA();
  368. }
  371. static void AmiInit(void)
  372. {
  373. int period, i;
  375. AmiSilence();
  377. if (dmasound.soft.speed)
  378. period = amiga_colorclock/dmasound.soft.speed-1;
  379. else
  380. period = amiga_audio_min_period;
  381. dmasound.hard = dmasound.soft;
  382. dmasound.trans_write = &transAmiga;
  384. if (period < amiga_audio_min_period) {
  385. /* we would need to squeeze the sound, but we won't do that */
  386. period = amiga_audio_min_period;
  387. } else if (period > 65535) {
  388. period = 65535;
  389. }
  390. dmasound.hard.speed = amiga_colorclock/(period+1);
  392. for (i = 0; i < 4; i++)
  393. custom.aud[i].audper = period;
  394. amiga_audio_period = period;
  395. }
  398. static int AmiSetFormat(int format)
  399. {
  400. int size;
  402. /* Amiga sound DMA supports 8bit and 16bit (pseudo 14 bit) modes */
  404. switch (format) {
  405. case AFMT_QUERY:
  406. return dmasound.soft.format;
  407. case AFMT_MU_LAW:
  408. case AFMT_A_LAW:
  409. case AFMT_U8:
  410. case AFMT_S8:
  411. size = 8;
  412. break;
  413. case AFMT_S16_BE:
  414. case AFMT_U16_BE:
  415. case AFMT_S16_LE:
  416. case AFMT_U16_LE:
  417. size = 16;
  418. break;
  419. default: /* :-) */
  420. size = 8;
  421. format = AFMT_S8;
  422. }
  424. dmasound.soft.format = format;
  425. dmasound.soft.size = size;
  426. if (dmasound.minDev == SND_DEV_DSP) {
  427. dmasound.dsp.format = format;
  428. dmasound.dsp.size = dmasound.soft.size;
  429. }
  430. AmiInit();
  432. return format;
  433. }
  436. #define VOLUME_VOXWARE_TO_AMI(v) 
  437. (((v) < 0) ? 0 : ((v) > 100) ? 64 : ((v) * 64)/100)
  438. #define VOLUME_AMI_TO_VOXWARE(v) ((v)*100/64)
  440. static int AmiSetVolume(int volume)
  441. {
  442. dmasound.volume_left = VOLUME_VOXWARE_TO_AMI(volume & 0xff);
  443. custom.aud[0].audvol = dmasound.volume_left;
  444. dmasound.volume_right = VOLUME_VOXWARE_TO_AMI((volume & 0xff00) >> 8);
  445. custom.aud[1].audvol = dmasound.volume_right;
  446. if (dmasound.hard.size == 16) {
  447. if (dmasound.volume_left == 64 && dmasound.volume_right == 64) {
  448. custom.aud[2].audvol = 1;
  449. custom.aud[3].audvol = 1;
  450. } else {
  451. custom.aud[2].audvol = 0;
  452. custom.aud[3].audvol = 0;
  453. }
  454. }
  455. return VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) |
  456.        (VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8);
  457. }
  459. static int AmiSetTreble(int treble)
  460. {
  461. dmasound.treble = treble;
  462. if (treble < 50)
  463. ciaa.pra &= ~0x02;
  464. else
  465. ciaa.pra |= 0x02;
  466. return treble;
  467. }
  470. #define AMI_PLAY_LOADED 1
  471. #define AMI_PLAY_PLAYING 2
  472. #define AMI_PLAY_MASK 3
  475. static void AmiPlayNextFrame(int index)
  476. {
  477. u_char *start, *ch0, *ch1, *ch2, *ch3;
  478. u_long size;
  480. /* used by AmiPlay() if all doubts whether there really is something
  481.  * to be played are already wiped out.
  482.  */
  483. start = write_sq.buffers[write_sq.front];
  484. size = (write_sq.count == index ? write_sq.rear_size
  485. : write_sq.block_size)>>1;
  487. if (dmasound.hard.stereo) {
  488. ch0 = start;
  489. ch1 = start+write_sq_block_size_half;
  490. size >>= 1;
  491. } else {
  492. ch0 = start;
  493. ch1 = start;
  494. }
  496. disable_heartbeat();
  497. custom.aud[0].audvol = dmasound.volume_left;
  498. custom.aud[1].audvol = dmasound.volume_right;
  499. if (dmasound.hard.size == 8) {
  500. custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0);
  501. custom.aud[0].audlen = size;
  502. custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1);
  503. custom.aud[1].audlen = size;
  504. custom.dmacon = AMI_AUDIO_8;
  505. } else {
  506. size >>= 1;
  507. custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0);
  508. custom.aud[0].audlen = size;
  509. custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1);
  510. custom.aud[1].audlen = size;
  511. if (dmasound.volume_left == 64 && dmasound.volume_right == 64) {
  512. /* We can play pseudo 14-bit only with the maximum volume */
  513. ch3 = ch0+write_sq_block_size_quarter;
  514. ch2 = ch1+write_sq_block_size_quarter;
  515. custom.aud[2].audvol = 1;  /* we are being affected by the beeps */
  516. custom.aud[3].audvol = 1;  /* restoring volume here helps a bit */
  517. custom.aud[2].audlc = (u_short *)ZTWO_PADDR(ch2);
  518. custom.aud[2].audlen = size;
  519. custom.aud[3].audlc = (u_short *)ZTWO_PADDR(ch3);
  520. custom.aud[3].audlen = size;
  521. custom.dmacon = AMI_AUDIO_14;
  522. } else {
  523. custom.aud[2].audvol = 0;
  524. custom.aud[3].audvol = 0;
  525. custom.dmacon = AMI_AUDIO_8;
  526. }
  527. }
  528. write_sq.front = (write_sq.front+1) % write_sq.max_count;
  529. write_sq.active |= AMI_PLAY_LOADED;
  530. }
  533. static void AmiPlay(void)
  534. {
  535. int minframes = 1;
  537. custom.intena = IF_AUD0;
  539. if (write_sq.active & AMI_PLAY_LOADED) {
  540. /* There's already a frame loaded */
  541. custom.intena = IF_SETCLR | IF_AUD0;
  542. return;
  543. }
  545. if (write_sq.active & AMI_PLAY_PLAYING)
  546. /* Increase threshold: frame 1 is already being played */
  547. minframes = 2;
  549. if (write_sq.count < minframes) {
  550. /* Nothing to do */
  551. custom.intena = IF_SETCLR | IF_AUD0;
  552. return;
  553. }
  555. if (write_sq.count <= minframes &&
  556.     write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
  557. /* hmmm, the only existing frame is not
  558.  * yet filled and we're not syncing?
  559.  */
  560. custom.intena = IF_SETCLR | IF_AUD0;
  561. return;
  562. }
  564. AmiPlayNextFrame(minframes);
  566. custom.intena = IF_SETCLR | IF_AUD0;
  567. }
  570. static void AmiInterrupt(int irq, void *dummy, struct pt_regs *fp)
  571. {
  572. int minframes = 1;
  574. custom.intena = IF_AUD0;
  576. if (!write_sq.active) {
  577. /* Playing was interrupted and sq_reset() has already cleared
  578.  * the sq variables, so better don't do anything here.
  579.  */
  580. WAKE_UP(write_sq.sync_queue);
  581. return;
  582. }
  584. if (write_sq.active & AMI_PLAY_PLAYING) {
  585. /* We've just finished a frame */
  586. write_sq.count--;
  587. WAKE_UP(write_sq.action_queue);
  588. }
  590. if (write_sq.active & AMI_PLAY_LOADED)
  591. /* Increase threshold: frame 1 is already being played */
  592. minframes = 2;
  594. /* Shift the flags */
  595. write_sq.active = (write_sq.active<<1) & AMI_PLAY_MASK;
  597. if (!write_sq.active)
  598. /* No frame is playing, disable audio DMA */
  599. StopDMA();
  601. custom.intena = IF_SETCLR | IF_AUD0;
  603. if (write_sq.count >= minframes)
  604. /* Try to play the next frame */
  605. AmiPlay();
  607. if (!write_sq.active)
  608. /* Nothing to play anymore.
  609.    Wake up a process waiting for audio output to drain. */
  610. WAKE_UP(write_sq.sync_queue);
  611. }
  613. /*** Mid level stuff *********************************************************/
  616. /*
  617.  * /dev/mixer abstraction
  618.  */
  620. static void __init AmiMixerInit(void)
  621. {
  622. dmasound.volume_left = 64;
  623. dmasound.volume_right = 64;
  624. custom.aud[0].audvol = dmasound.volume_left;
  625. custom.aud[3].audvol = 1; /* For pseudo 14bit */
  626. custom.aud[1].audvol = dmasound.volume_right;
  627. custom.aud[2].audvol = 1; /* For pseudo 14bit */
  628. dmasound.treble = 50;
  629. }
  631. static int AmiMixerIoctl(u_int cmd, u_long arg)
  632. {
  633. int data;
  634. switch (cmd) {
  635.     case SOUND_MIXER_READ_DEVMASK:
  636.     return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_TREBLE);
  637.     case SOUND_MIXER_READ_RECMASK:
  638.     return IOCTL_OUT(arg, 0);
  639.     case SOUND_MIXER_READ_STEREODEVS:
  640.     return IOCTL_OUT(arg, SOUND_MASK_VOLUME);
  641.     case SOUND_MIXER_READ_VOLUME:
  642.     return IOCTL_OUT(arg,
  643.     VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) |
  644.     VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8);
  645.     case SOUND_MIXER_WRITE_VOLUME:
  646.     IOCTL_IN(arg, data);
  647.     return IOCTL_OUT(arg, dmasound_set_volume(data));
  648.     case SOUND_MIXER_READ_TREBLE:
  649.     return IOCTL_OUT(arg, dmasound.treble);
  650.     case SOUND_MIXER_WRITE_TREBLE:
  651.     IOCTL_IN(arg, data);
  652.     return IOCTL_OUT(arg, dmasound_set_treble(data));
  653. }
  654. return -EINVAL;
  655. }
  658. static void AmiWriteSqSetup(void)
  659. {
  660. write_sq_block_size_half = write_sq.block_size>>1;
  661. write_sq_block_size_quarter = write_sq_block_size_half>>1;
  662. }
  665. static int AmiStateInfo(char *buffer, size_t space)
  666. {
  667. int len = 0;
  668. len += sprintf(buffer+len, "tsound.volume_left = %d [0...64]n",
  669.        dmasound.volume_left);
  670. len += sprintf(buffer+len, "tsound.volume_right = %d [0...64]n",
  671.        dmasound.volume_right);
  672. if (len >= space) {
  673. printk(KERN_ERR "dmasound_paula: overlowed state buffer alloc.n") ;
  674. len = space ;
  675. }
  676. return len;
  677. }
  680. /*** Machine definitions *****************************************************/
  682. static SETTINGS def_hard = {
  683. format: AFMT_S8,
  684. stereo: 0,
  685. size: 8,
  686. speed: 8000
  687. } ;
  689. static SETTINGS def_soft = {
  690. format: AFMT_U8,
  691. stereo: 0,
  692. size: 8,
  693. speed: 8000
  694. } ;
  696. static MACHINE machAmiga = {
  697. name: "Amiga",
  698. name2: "AMIGA",
  699. open: AmiOpen,
  700. release: AmiRelease,
  701. dma_alloc: AmiAlloc,
  702. dma_free: AmiFree,
  703. irqinit: AmiIrqInit,
  704. #ifdef MODULE
  705. irqcleanup: AmiIrqCleanUp,
  706. #endif /* MODULE */
  707. init: AmiInit,
  708. silence: AmiSilence,
  709. setFormat: AmiSetFormat,
  710. setVolume: AmiSetVolume,
  711. setTreble: AmiSetTreble,
  712. play: AmiPlay,
  713. mixer_init: AmiMixerInit,
  714. mixer_ioctl: AmiMixerIoctl,
  715. write_sq_setup: AmiWriteSqSetup,
  716. state_info: AmiStateInfo,
  717. min_dsp_speed: 8000,
  718. version: ((DMASOUND_PAULA_REVISION<<8) | DMASOUND_PAULA_EDITION),
  719. hardware_afmts: (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */
  720.         capabilities:   DSP_CAP_BATCH          /* As per SNDCTL_DSP_GETCAPS */
  721. };
  724. /*** Config & Setup **********************************************************/
  727. int __init dmasound_paula_init(void)
  728. {
  729. int err;
  731. if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_AUDIO)) {
  732.     if (!request_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40,
  733.     "dmasound [Paula]"))
  734. return -EBUSY;
  735.     dmasound.mach = machAmiga;
  736.     dmasound.mach.default_hard = def_hard ;
  737.     dmasound.mach.default_soft = def_soft ;
  738.     err = dmasound_init();
  739.     if (err)
  740. release_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40);
  741.     return err;
  742. } else
  743.     return -ENODEV;
  744. }
  746. static void __exit dmasound_paula_cleanup(void)
  747. {
  748. dmasound_deinit();
  749. release_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40);
  750. }
  752. module_init(dmasound_paula_init);
  753. module_exit(dmasound_paula_cleanup);
  754. MODULE_LICENSE("GPL");