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

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

Linux/Unix编程

开发平台：

Unix_Linux

nm256_audio.c：源码内容
  1. /* 
  2.  * Audio driver for the NeoMagic 256AV and 256ZX chipsets in native
  3.  * mode, with AC97 mixer support.
  4.  *
  5.  * Overall design and parts of this code stolen from vidc_*.c and
  6.  * skeleton.c.
  7.  *
  8.  * Yeah, there are a lot of magic constants in here.  You tell ME what
  9.  * they are.  I just get this stuff psychically, remember? 
  10.  *
  11.  * This driver was written by someone who wishes to remain anonymous. 
  12.  * It is in the public domain, so share and enjoy.  Try to make a profit
  13.  * off of it; go on, I dare you.  
  14.  *
  15.  * Changes:
  16.  * 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
  17.  * Added some __init
  18.  * 19-04-2001 Marcus Meissner <mm@caldera.de>
  19.  * Ported to 2.4 PCI API.
  20.  */
  22. #define __NO_VERSION__
  23. #include <linux/pci.h>
  24. #include <linux/init.h>
  25. #include <linux/module.h>
  26. #include <linux/pm.h>
  27. #include <linux/delay.h>
  28. #include "sound_config.h"
  29. #include "nm256.h"
  30. #include "nm256_coeff.h"
  32. int nm256_debug;
  33. static int force_load;
  35. /* 
  36.  * The size of the playback reserve.  When the playback buffer has less
  37.  * than NM256_PLAY_WMARK_SIZE bytes to output, we request a new
  38.  * buffer.
  39.  */
  40. #define NM256_PLAY_WMARK_SIZE 512
  42. static struct audio_driver nm256_audio_driver;
  44. static int nm256_grabInterrupt (struct nm256_info *card);
  45. static int nm256_releaseInterrupt (struct nm256_info *card);
  46. static void nm256_interrupt (int irq, void *dev_id, struct pt_regs *dummy);
  47. static void nm256_interrupt_zx (int irq, void *dev_id, struct pt_regs *dummy);
  48. static int handle_pm_event (struct pm_dev *dev, pm_request_t rqst, void *data);
  50. /* These belong in linux/pci.h. */
  51. #define PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO 0x8005
  52. #define PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO 0x8006
  54. /* List of cards.  */
  55. static struct nm256_info *nmcard_list;
  57. /* Release the mapped-in memory for CARD.  */
  58. static void
  59. nm256_release_ports (struct nm256_info *card)
  60. {
  61.     int x;
  63.     for (x = 0; x < 2; x++) {
  64. if (card->port[x].ptr != NULL) {
  65.     iounmap (card->port[x].ptr);
  66.     card->port[x].ptr = NULL;
  67. }
  68.     }
  69. }
  71. /* 
  72.  * Map in the memory ports for CARD, if they aren't already mapped in
  73.  * and have been configured.  If successful, a zero value is returned;
  74.  * otherwise any previously mapped-in areas are released and a non-zero
  75.  * value is returned.
  76.  *
  77.  * This is invoked twice, once for each port.  Ideally it would only be
  78.  * called once, but we now need to map in the second port in order to
  79.  * check how much memory the card has on the 256ZX.
  80.  */
  81. static int
  82. nm256_remap_ports (struct nm256_info *card)
  83. {
  84.     int x;
  86.     for (x = 0; x < 2; x++) {
  87. if (card->port[x].ptr == NULL && card->port[x].end_offset > 0) {
  88.     u32 physaddr 
  89. = card->port[x].physaddr + card->port[x].start_offset;
  90.     u32 size 
  91. = card->port[x].end_offset - card->port[x].start_offset;
  93.     card->port[x].ptr = ioremap_nocache (physaddr, size);
  94.   
  95.     if (card->port[x].ptr == NULL) {
  96. printk (KERN_ERR "NM256: Unable to remap port %dn", x + 1);
  97. nm256_release_ports (card);
  98. return -1;
  99.     }
  100. }
  101.     }
  102.     return 0;
  103. }
  105. /* Locate the card in our list. */
  106. static struct nm256_info *
  107. nm256_find_card (int dev)
  108. {
  109.     struct nm256_info *card;
  111.     for (card = nmcard_list; card != NULL; card = card->next_card)
  112. if (card->dev[0] == dev || card->dev[1] == dev)
  113.     return card;
  115.     return NULL;
  116. }
  118. /*
  119.  * Ditto, but find the card struct corresponding to the mixer device DEV 
  120.  * instead. 
  121.  */
  122. static struct nm256_info *
  123. nm256_find_card_for_mixer (int dev)
  124. {
  125.     struct nm256_info *card;
  127.     for (card = nmcard_list; card != NULL; card = card->next_card)
  128. if (card->mixer_oss_dev == dev)
  129.     return card;
  131.     return NULL;
  132. }
  134. static int usecache;
  135. static int buffertop;
  137. /* Check to see if we're using the bank of cached coefficients. */
  138. int
  139. nm256_cachedCoefficients (struct nm256_info *card)
  140. {
  141.     return usecache;
  142. }
  144. /* The actual rates supported by the card. */
  145. static int samplerates[9] = {
  146.     8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 99999999
  147. };
  149. /*
  150.  * Set the card samplerate, word size and stereo mode to correspond to
  151.  * the settings in the CARD struct for the specified device in DEV.
  152.  * We keep two separate sets of information, one for each device; the
  153.  * hardware is not actually configured until a read or write is
  154.  * attempted.
  155.  */
  157. int
  158. nm256_setInfo (int dev, struct nm256_info *card)
  159. {
  160.     int x;
  161.     int w;
  162.     int targetrate;
  164.     if (card->dev[0] == dev)
  165. w = 0;
  166.     else if (card->dev[1] == dev)
  167. w = 1;
  168.     else
  169. return -ENODEV;
  171.     targetrate = card->sinfo[w].samplerate;
  173.     if ((card->sinfo[w].bits != 8 && card->sinfo[w].bits != 16)
  174. || targetrate < samplerates[0]
  175. || targetrate > samplerates[7])
  176. return -EINVAL;
  178.     for (x = 0; x < 8; x++)
  179. if (targetrate < ((samplerates[x] + samplerates[x + 1]) / 2))
  180.     break;
  182.     if (x < 8) {
  183. u8 ratebits = ((x << 4) & NM_RATE_MASK);
  184. if (card->sinfo[w].bits == 16)
  185.     ratebits |= NM_RATE_BITS_16;
  186. if (card->sinfo[w].stereo)
  187.     ratebits |= NM_RATE_STEREO;
  189. card->sinfo[w].samplerate = samplerates[x];
  192. if (card->dev_for_play == dev && card->playing) {
  193.     if (nm256_debug)
  194. printk (KERN_DEBUG "Setting play ratebits to 0x%xn",
  195. ratebits);
  196.     nm256_loadCoefficient (card, 0, x);
  197.     nm256_writePort8 (card, 2,
  198.       NM_PLAYBACK_REG_OFFSET + NM_RATE_REG_OFFSET,
  199.       ratebits);
  200. }
  202. if (card->dev_for_record == dev && card->recording) {
  203.     if (nm256_debug)
  204. printk (KERN_DEBUG "Setting record ratebits to 0x%xn",
  205. ratebits);
  206.     nm256_loadCoefficient (card, 1, x);
  207.     nm256_writePort8 (card, 2,
  208.       NM_RECORD_REG_OFFSET + NM_RATE_REG_OFFSET,
  209.       ratebits);
  210. }
  211. return 0;
  212.     }
  213.     else
  214. return -EINVAL;
  215. }
  217. /* Start the play process going. */
  218. static void
  219. startPlay (struct nm256_info *card)
  220. {
  221.     if (! card->playing) {
  222. card->playing = 1;
  223. if (nm256_grabInterrupt (card) == 0) {
  224.     nm256_setInfo (card->dev_for_play, card);
  226.     /* Enable playback engine and interrupts. */
  227.     nm256_writePort8 (card, 2, NM_PLAYBACK_ENABLE_REG,
  228.       NM_PLAYBACK_ENABLE_FLAG | NM_PLAYBACK_FREERUN);
  230.     /* Enable both channels. */
  231.     nm256_writePort16 (card, 2, NM_AUDIO_MUTE_REG, 0x0);
  232. }
  233.     }
  234. }
  236. /* 
  237.  * Request one chunk of AMT bytes from the recording device.  When the
  238.  * operation is complete, the data will be copied into BUFFER and the
  239.  * function DMAbuf_inputintr will be invoked.
  240.  */
  242. static void
  243. nm256_startRecording (struct nm256_info *card, char *buffer, u32 amt)
  244. {
  245.     u32 endpos;
  246.     int enableEngine = 0;
  247.     u32 ringsize = card->recordBufferSize;
  248.     unsigned long flags;
  250.     if (amt > (ringsize / 2)) {
  251. /*
  252.  * Of course this won't actually work right, because the
  253.  * caller is going to assume we will give what we got asked
  254.  * for.
  255.  */
  256. printk (KERN_ERR "NM256: Read request too large: %dn", amt);
  257. amt = ringsize / 2;
  258.     }
  260.     if (amt < 8) {
  261. printk (KERN_ERR "NM256: Read request too small; %dn", amt);
  262. return;
  263.     }
  265.     save_flags (flags);
  266.     cli ();
  267.     /*
  268.      * If we're not currently recording, set up the start and end registers
  269.      * for the recording engine.
  270.      */
  271.     if (! card->recording) {
  272. card->recording = 1;
  273. if (nm256_grabInterrupt (card) == 0) {
  274.     card->curRecPos = 0;
  275.     nm256_setInfo (card->dev_for_record, card);
  276.     nm256_writePort32 (card, 2, NM_RBUFFER_START, card->abuf2);
  277.     nm256_writePort32 (card, 2, NM_RBUFFER_END,
  278.  card->abuf2 + ringsize);
  280.     nm256_writePort32 (card, 2, NM_RBUFFER_CURRP,
  281.  card->abuf2 + card->curRecPos);
  282.     enableEngine = 1;
  283. }
  284. else {
  285.     /* Not sure what else to do here.  */
  286.     restore_flags (flags);
  287.     return;
  288. }
  289.     }
  291.     /* 
  292.      * If we happen to go past the end of the buffer a bit (due to a
  293.      * delayed interrupt) it's OK.  So might as well set the watermark
  294.      * right at the end of the data we want.
  295.      */
  296.     endpos = card->abuf2 + ((card->curRecPos + amt) % ringsize);
  298.     card->recBuf = buffer;
  299.     card->requestedRecAmt = amt;
  300.     nm256_writePort32 (card, 2, NM_RBUFFER_WMARK, endpos);
  301.     /* Enable recording engine and interrupts. */
  302.     if (enableEngine)
  303. nm256_writePort8 (card, 2, NM_RECORD_ENABLE_REG,
  304.     NM_RECORD_ENABLE_FLAG | NM_RECORD_FREERUN);
  306.     restore_flags (flags);
  307. }
  309. /* Stop the play engine. */
  310. static void
  311. stopPlay (struct nm256_info *card)
  312. {
  313.     /* Shut off sound from both channels. */
  314.     nm256_writePort16 (card, 2, NM_AUDIO_MUTE_REG,
  315.        NM_AUDIO_MUTE_LEFT | NM_AUDIO_MUTE_RIGHT);
  316.     /* Disable play engine. */
  317.     nm256_writePort8 (card, 2, NM_PLAYBACK_ENABLE_REG, 0);
  318.     if (card->playing) {
  319. nm256_releaseInterrupt (card);
  321. /* Reset the relevant state bits. */
  322. card->playing = 0;
  323. card->curPlayPos = 0;
  324.     }
  325. }
  327. /* Stop recording. */
  328. static void
  329. stopRecord (struct nm256_info *card)
  330. {
  331.     /* Disable recording engine. */
  332.     nm256_writePort8 (card, 2, NM_RECORD_ENABLE_REG, 0);
  334.     if (card->recording) {
  335. nm256_releaseInterrupt (card);
  337. card->recording = 0;
  338. card->curRecPos = 0;
  339.     }
  340. }
  342. /*
  343.  * Ring buffers, man.  That's where the hip-hop, wild-n-wooly action's at.
  344.  * 1972?  (Well, I suppose it was cheep-n-easy to implement.)
  345.  *
  346.  * Write AMT bytes of BUFFER to the playback ring buffer, and start the
  347.  * playback engine running.  It will only accept up to 1/2 of the total
  348.  * size of the ring buffer.  No check is made that we're about to overwrite
  349.  * the currently-playing sample.
  350.  */
  352. static void
  353. nm256_write_block (struct nm256_info *card, char *buffer, u32 amt)
  354. {
  355.     u32 ringsize = card->playbackBufferSize;
  356.     u32 endstop;
  357.     unsigned long flags;
  359.     if (amt > (ringsize / 2)) {
  360. printk (KERN_ERR "NM256: Write request too large: %dn", amt);
  361. amt = (ringsize / 2);
  362.     }
  364.     if (amt < NM256_PLAY_WMARK_SIZE) {
  365. printk (KERN_ERR "NM256: Write request too small: %dn", amt);
  366. return;
  367.     }
  369.     card->curPlayPos %= ringsize;
  371.     card->requested_amt = amt;
  373.     save_flags (flags);
  374.     cli ();
  376.     if ((card->curPlayPos + amt) >= ringsize) {
  377. u32 rem = ringsize - card->curPlayPos;
  379. nm256_writeBuffer8 (card, buffer, 1,
  380.       card->abuf1 + card->curPlayPos,
  381.       rem);
  382. if (amt > rem)
  383.     nm256_writeBuffer8 (card, buffer + rem, 1, card->abuf1,
  384.   amt - rem);
  385.     } 
  386.     else
  387. nm256_writeBuffer8 (card, buffer, 1,
  388.       card->abuf1 + card->curPlayPos,
  389.       amt);
  391.     /*
  392.      * Setup the start-n-stop-n-limit registers, and start that engine
  393.      * goin'. 
  394.      *
  395.      * Normally we just let it wrap around to avoid the click-click
  396.      * action scene.
  397.      */
  398.     if (! card->playing) {
  399. /* The PBUFFER_END register in this case points to one sample
  400.    before the end of the buffer. */
  401. int w = (card->dev_for_play == card->dev[0] ? 0 : 1);
  402. int sampsize = (card->sinfo[w].bits == 16 ? 2 : 1);
  404. if (card->sinfo[w].stereo)
  405.     sampsize *= 2;
  407. /* Need to set the not-normally-changing-registers up. */
  408. nm256_writePort32 (card, 2, NM_PBUFFER_START,
  409.      card->abuf1 + card->curPlayPos);
  410. nm256_writePort32 (card, 2, NM_PBUFFER_END,
  411.      card->abuf1 + ringsize - sampsize);
  412. nm256_writePort32 (card, 2, NM_PBUFFER_CURRP,
  413.      card->abuf1 + card->curPlayPos);
  414.     }
  415.     endstop = (card->curPlayPos + amt - NM256_PLAY_WMARK_SIZE) % ringsize;
  416.     nm256_writePort32 (card, 2, NM_PBUFFER_WMARK, card->abuf1 + endstop);
  418.     if (! card->playing)
  419. startPlay (card);
  421.     restore_flags (flags);
  422. }
  424. /*  We just got a card playback interrupt; process it.  */
  425. static void
  426. nm256_get_new_block (struct nm256_info *card)
  427. {
  428.     /* Check to see how much got played so far. */
  429.     u32 amt = nm256_readPort32 (card, 2, NM_PBUFFER_CURRP) - card->abuf1;
  431.     if (amt >= card->playbackBufferSize) {
  432. printk (KERN_ERR "NM256: Sound playback pointer invalid!n");
  433. amt = 0;
  434.     }
  436.     if (amt < card->curPlayPos)
  437. amt = (card->playbackBufferSize - card->curPlayPos) + amt;
  438.     else
  439. amt -= card->curPlayPos;
  441.     if (card->requested_amt > (amt + NM256_PLAY_WMARK_SIZE)) {
  442. u32 endstop =
  443.     card->curPlayPos + card->requested_amt - NM256_PLAY_WMARK_SIZE;
  444. nm256_writePort32 (card, 2, NM_PBUFFER_WMARK, card->abuf1 + endstop);
  445.     } 
  446.     else {
  447. card->curPlayPos += card->requested_amt;
  448. /* Get a new block to write.  This will eventually invoke
  449.    nm256_write_block () or stopPlay ().  */
  450. DMAbuf_outputintr (card->dev_for_play, 1);
  451.     }
  452. }
  454. /* Ultra cheez-whiz.  But I'm too lazy to grep headers. */
  455. #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
  457. /* 
  458.  * Read the last-recorded block from the ring buffer, copy it into the
  459.  * saved buffer pointer, and invoke DMAuf_inputintr() with the recording
  460.  * device. 
  461.  */
  463. static void
  464. nm256_read_block (struct nm256_info *card)
  465. {
  466.     /* Grab the current position of the recording pointer. */
  467.     u32 currptr = nm256_readPort32 (card, 2, NM_RBUFFER_CURRP) - card->abuf2;
  468.     u32 amtToRead = card->requestedRecAmt;
  469.     u32 ringsize = card->recordBufferSize;
  471.     if (currptr >= card->recordBufferSize) {
  472. printk (KERN_ERR "NM256: Sound buffer record pointer invalid!n");
  473.         currptr = 0;
  474.     }
  476.     /*
  477.      * This test is probably redundant; we shouldn't be here unless
  478.      * it's true.
  479.      */
  480.     if (card->recording) {
  481. /* If we wrapped around, copy everything from the start of our
  482.    recording buffer to the end of the buffer. */
  483. if (currptr < card->curRecPos) {
  484.     u32 amt = MIN (ringsize - card->curRecPos, amtToRead);
  486.     nm256_readBuffer8 (card, card->recBuf, 1,
  487.  card->abuf2 + card->curRecPos,
  488.  amt);
  489.     amtToRead -= amt;
  490.     card->curRecPos += amt;
  491.     card->recBuf += amt;
  492.     if (card->curRecPos == ringsize)
  493. card->curRecPos = 0;
  494. }
  496. if ((card->curRecPos < currptr) && (amtToRead > 0)) {
  497.     u32 amt = MIN (currptr - card->curRecPos, amtToRead);
  498.     nm256_readBuffer8 (card, card->recBuf, 1,
  499.  card->abuf2 + card->curRecPos, amt);
  500.     card->curRecPos = ((card->curRecPos + amt) % ringsize);
  501. }
  502. card->recBuf = NULL;
  503. card->requestedRecAmt = 0;
  504. DMAbuf_inputintr (card->dev_for_record);
  505.     }
  506. }
  507. #undef MIN
  509. /* 
  510.  * Initialize the hardware. 
  511.  */
  512. static void
  513. nm256_initHw (struct nm256_info *card)
  514. {
  515.     /* Reset everything. */
  516.     nm256_writePort8 (card, 2, 0x0, 0x11);
  517.     nm256_writePort16 (card, 2, 0x214, 0);
  519.     stopRecord (card);
  520.     stopPlay (card);
  521. }
  523. /* 
  524.  * Handle a potential interrupt for the device referred to by DEV_ID. 
  525.  *
  526.  * I don't like the cut-n-paste job here either between the two routines,
  527.  * but there are sufficient differences between the two interrupt handlers
  528.  * that parameterizing it isn't all that great either.  (Could use a macro,
  529.  * I suppose...yucky bleah.)
  530.  */
  532. static void
  533. nm256_interrupt (int irq, void *dev_id, struct pt_regs *dummy)
  534. {
  535.     struct nm256_info *card = (struct nm256_info *)dev_id;
  536.     u16 status;
  537.     static int badintrcount = 0;
  539.     if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
  540. printk (KERN_ERR "NM256: Bad card pointern");
  541. return;
  542.     }
  544.     status = nm256_readPort16 (card, 2, NM_INT_REG);
  546.     /* Not ours. */
  547.     if (status == 0) {
  548. if (badintrcount++ > 1000) {
  549.     /*
  550.      * I'm not sure if the best thing is to stop the card from
  551.      * playing or just release the interrupt (after all, we're in
  552.      * a bad situation, so doing fancy stuff may not be such a good
  553.      * idea).
  554.      *
  555.      * I worry about the card engine continuing to play noise
  556.      * over and over, however--that could become a very
  557.      * obnoxious problem.  And we know that when this usually
  558.      * happens things are fairly safe, it just means the user's
  559.      * inserted a PCMCIA card and someone's spamming us with IRQ 9s.
  560.      */
  562.     if (card->playing)
  563. stopPlay (card);
  564.     if (card->recording)
  565. stopRecord (card);
  566.     badintrcount = 0;
  567. }
  568. return;
  569.     }
  571.     badintrcount = 0;
  573.     /* Rather boring; check for individual interrupts and process them. */
  575.     if (status & NM_PLAYBACK_INT) {
  576. status &= ~NM_PLAYBACK_INT;
  577. NM_ACK_INT (card, NM_PLAYBACK_INT);
  579. if (card->playing)
  580.     nm256_get_new_block (card);
  581.     }
  583.     if (status & NM_RECORD_INT) {
  584. status &= ~NM_RECORD_INT;
  585. NM_ACK_INT (card, NM_RECORD_INT);
  587. if (card->recording)
  588.     nm256_read_block (card);
  589.     }
  591.     if (status & NM_MISC_INT_1) {
  592. u8 cbyte;
  594. status &= ~NM_MISC_INT_1;
  595. printk (KERN_ERR "NM256: Got misc interrupt #1n");
  596. NM_ACK_INT (card, NM_MISC_INT_1);
  597. nm256_writePort16 (card, 2, NM_INT_REG, 0x8000);
  598. cbyte = nm256_readPort8 (card, 2, 0x400);
  599. nm256_writePort8 (card, 2, 0x400, cbyte | 2);
  600.     }
  602.     if (status & NM_MISC_INT_2) {
  603. u8 cbyte;
  605. status &= ~NM_MISC_INT_2;
  606. printk (KERN_ERR "NM256: Got misc interrupt #2n");
  607. NM_ACK_INT (card, NM_MISC_INT_2);
  608. cbyte = nm256_readPort8 (card, 2, 0x400);
  609. nm256_writePort8 (card, 2, 0x400, cbyte & ~2);
  610.     }
  612.     /* Unknown interrupt. */
  613.     if (status) {
  614. printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%xn",
  615. status);
  616. /* Pray. */
  617. NM_ACK_INT (card, status);
  618.     }
  619. }
  621. /*
  622.  * Handle a potential interrupt for the device referred to by DEV_ID.
  623.  * This handler is for the 256ZX, and is very similar to the non-ZX
  624.  * routine.
  625.  */
  627. static void
  628. nm256_interrupt_zx (int irq, void *dev_id, struct pt_regs *dummy)
  629. {
  630.     struct nm256_info *card = (struct nm256_info *)dev_id;
  631.     u32 status;
  632.     static int badintrcount = 0;
  634.     if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
  635. printk (KERN_ERR "NM256: Bad card pointern");
  636. return;
  637.     }
  639.     status = nm256_readPort32 (card, 2, NM_INT_REG);
  641.     /* Not ours. */
  642.     if (status == 0) {
  643. if (badintrcount++ > 1000) {
  644.     printk (KERN_ERR "NM256: Releasing interrupt, over 1000 invalid interruptsn");
  645.     /*
  646.      * I'm not sure if the best thing is to stop the card from
  647.      * playing or just release the interrupt (after all, we're in
  648.      * a bad situation, so doing fancy stuff may not be such a good
  649.      * idea).
  650.      *
  651.      * I worry about the card engine continuing to play noise
  652.      * over and over, however--that could become a very
  653.      * obnoxious problem.  And we know that when this usually
  654.      * happens things are fairly safe, it just means the user's
  655.      * inserted a PCMCIA card and someone's spamming us with 
  656.      * IRQ 9s.
  657.      */
  659.     if (card->playing)
  660. stopPlay (card);
  661.     if (card->recording)
  662. stopRecord (card);
  663.     badintrcount = 0;
  664. }
  665. return;
  666.     }
  668.     badintrcount = 0;
  670.     /* Rather boring; check for individual interrupts and process them. */
  672.     if (status & NM2_PLAYBACK_INT) {
  673. status &= ~NM2_PLAYBACK_INT;
  674. NM2_ACK_INT (card, NM2_PLAYBACK_INT);
  676. if (card->playing)
  677.     nm256_get_new_block (card);
  678.     }
  680.     if (status & NM2_RECORD_INT) {
  681. status &= ~NM2_RECORD_INT;
  682. NM2_ACK_INT (card, NM2_RECORD_INT);
  684. if (card->recording)
  685.     nm256_read_block (card);
  686.     }
  688.     if (status & NM2_MISC_INT_1) {
  689. u8 cbyte;
  691. status &= ~NM2_MISC_INT_1;
  692. printk (KERN_ERR "NM256: Got misc interrupt #1n");
  693. NM2_ACK_INT (card, NM2_MISC_INT_1);
  694. cbyte = nm256_readPort8 (card, 2, 0x400);
  695. nm256_writePort8 (card, 2, 0x400, cbyte | 2);
  696.     }
  698.     if (status & NM2_MISC_INT_2) {
  699. u8 cbyte;
  701. status &= ~NM2_MISC_INT_2;
  702. printk (KERN_ERR "NM256: Got misc interrupt #2n");
  703. NM2_ACK_INT (card, NM2_MISC_INT_2);
  704. cbyte = nm256_readPort8 (card, 2, 0x400);
  705. nm256_writePort8 (card, 2, 0x400, cbyte & ~2);
  706.     }
  708.     /* Unknown interrupt. */
  709.     if (status) {
  710. printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%xn",
  711. status);
  712. /* Pray. */
  713. NM2_ACK_INT (card, status);
  714.     }
  715. }
  717. /* 
  718.  * Request our interrupt.
  719.  */
  720. static int
  721. nm256_grabInterrupt (struct nm256_info *card)
  722. {
  723.     if (card->has_irq++ == 0) {
  724. if (request_irq (card->irq, card->introutine, SA_SHIRQ,
  725.  "NM256_audio", card) < 0) {
  726.     printk (KERN_ERR "NM256: can't obtain IRQ %dn", card->irq);
  727.     return -1;
  728. }
  729.     }
  730.     return 0;
  731. }
  733. /* 
  734.  * Release our interrupt. 
  735.  */
  736. static int
  737. nm256_releaseInterrupt (struct nm256_info *card)
  738. {
  739.     if (card->has_irq <= 0) {
  740. printk (KERN_ERR "nm256: too many calls to releaseInterruptn");
  741. return -1;
  742.     }
  743.     card->has_irq--;
  744.     if (card->has_irq == 0) {
  745. free_irq (card->irq, card);
  746.     }
  747.     return 0;
  748. }
  750. /*
  751.  * Waits for the mixer to become ready to be written; returns a zero value
  752.  * if it timed out.
  753.  */
  755. static int
  756. nm256_isReady (struct ac97_hwint *dev)
  757. {
  758.     struct nm256_info *card = (struct nm256_info *)dev->driver_private;
  759.     int t2 = 10;
  760.     u32 testaddr;
  761.     u16 testb;
  762.     int done = 0;
  764.     if (card->magsig != NM_MAGIC_SIG) {
  765. printk (KERN_ERR "NM256: Bad magic signature in isReady!n");
  766. return 0;
  767.     }
  769.     testaddr = card->mixer_status_offset;
  770.     testb = card->mixer_status_mask;
  772.     /* 
  773.      * Loop around waiting for the mixer to become ready. 
  774.      */
  775.     while (! done && t2-- > 0) {
  776. if ((nm256_readPort16 (card, 2, testaddr) & testb) == 0)
  777.     done = 1;
  778. else
  779.     udelay (100);
  780.     }
  781.     return done;
  782. }
  784. /*
  785.  * Return the contents of the AC97 mixer register REG.  Returns a positive
  786.  * value if successful, or a negative error code.
  787.  */
  788. static int
  789. nm256_readAC97Reg (struct ac97_hwint *dev, u8 reg)
  790. {
  791.     struct nm256_info *card = (struct nm256_info *)dev->driver_private;
  793.     if (card->magsig != NM_MAGIC_SIG) {
  794. printk (KERN_ERR "NM256: Bad magic signature in readAC97Reg!n");
  795. return -EINVAL;
  796.     }
  798.     if (reg < 128) {
  799. int res;
  801. nm256_isReady (dev);
  802. res = nm256_readPort16 (card, 2, card->mixer + reg);
  803. /* Magic delay.  Bleah yucky.  */
  804.         udelay (1000);
  805. return res;
  806.     }
  807.     else
  808. return -EINVAL;
  809. }
  811. /* 
  812.  * Writes VALUE to AC97 mixer register REG.  Returns 0 if successful, or
  813.  * a negative error code. 
  814.  */
  815. static int
  816. nm256_writeAC97Reg (struct ac97_hwint *dev, u8 reg, u16 value)
  817. {
  818.     unsigned long flags;
  819.     int tries = 2;
  820.     int done = 0;
  821.     u32 base;
  823.     struct nm256_info *card = (struct nm256_info *)dev->driver_private;
  825.     if (card->magsig != NM_MAGIC_SIG) {
  826. printk (KERN_ERR "NM256: Bad magic signature in writeAC97Reg!n");
  827. return -EINVAL;
  828.     }
  830.     base = card->mixer;
  832.     save_flags (flags);
  833.     cli ();
  835.     nm256_isReady (dev);
  837.     /* Wait for the write to take, too. */
  838.     while ((tries-- > 0) && !done) {
  839. nm256_writePort16 (card, 2, base + reg, value);
  840. if (nm256_isReady (dev)) {
  841.     done = 1;
  842.     break;
  843. }
  845.     }
  847.     restore_flags (flags);
  848.     udelay (1000);
  850.     return ! done;
  851. }
  853. /* 
  854.  * Initial register values to be written to the AC97 mixer.
  855.  * While most of these are identical to the reset values, we do this
  856.  * so that we have most of the register contents cached--this avoids
  857.  * reading from the mixer directly (which seems to be problematic,
  858.  * probably due to ignorance).
  859.  */
  860. struct initialValues 
  861. {
  862.     unsigned short port;
  863.     unsigned short value;
  864. };
  866. static struct initialValues nm256_ac97_initial_values[] = 
  867. {
  868.     { AC97_MASTER_VOL_STEREO, 0x8000 },
  869.     { AC97_HEADPHONE_VOL,     0x8000 },
  870.     { AC97_MASTER_VOL_MONO,   0x0000 },
  871.     { AC97_PCBEEP_VOL,        0x0000 },
  872.     { AC97_PHONE_VOL,         0x0008 },
  873.     { AC97_MIC_VOL,           0x8000 },
  874.     { AC97_LINEIN_VOL,        0x8808 },
  875.     { AC97_CD_VOL,            0x8808 },
  876.     { AC97_VIDEO_VOL,         0x8808 },
  877.     { AC97_AUX_VOL,           0x8808 },
  878.     { AC97_PCMOUT_VOL,        0x0808 },
  879.     { AC97_RECORD_SELECT,     0x0000 },
  880.     { AC97_RECORD_GAIN,       0x0B0B },
  881.     { AC97_GENERAL_PURPOSE,   0x0000 },
  882.     { 0xffff, 0xffff }
  883. };
  885. /* Initialize the AC97 into a known state.  */
  886. static int
  887. nm256_resetAC97 (struct ac97_hwint *dev)
  888. {
  889.     struct nm256_info *card = (struct nm256_info *)dev->driver_private;
  890.     int x;
  892.     if (card->magsig != NM_MAGIC_SIG) {
  893. printk (KERN_ERR "NM256: Bad magic signature in resetAC97!n");
  894. return -EINVAL;
  895.     }
  897.     /* Reset the mixer.  'Tis magic!  */
  898.     nm256_writePort8 (card, 2, 0x6c0, 1);
  899. //  nm256_writePort8 (card, 2, 0x6cc, 0x87); /* This crashes Dell latitudes */
  900.     nm256_writePort8 (card, 2, 0x6cc, 0x80);
  901.     nm256_writePort8 (card, 2, 0x6cc, 0x0);
  903.     if (! card->mixer_values_init) {
  904. for (x = 0; nm256_ac97_initial_values[x].port != 0xffff; x++) {
  905.     ac97_put_register (dev,
  906.        nm256_ac97_initial_values[x].port,
  907.        nm256_ac97_initial_values[x].value);
  908.     card->mixer_values_init = 1;
  909. }
  910.     }
  912.     return 0;
  913. }
  915. /*
  916.  * We don't do anything particularly special here; it just passes the
  917.  * mixer ioctl to the AC97 driver.
  918.  */
  919. static int
  920. nm256_default_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
  921. {
  922.     struct nm256_info *card = nm256_find_card_for_mixer (dev);
  923.     if (card != NULL)
  924. return ac97_mixer_ioctl (&(card->mdev), cmd, arg);
  925.     else
  926. return -ENODEV;
  927. }
  929. static struct mixer_operations nm256_mixer_operations = {
  930.     owner: THIS_MODULE,
  931.     id: "NeoMagic",
  932.     name: "NM256AC97Mixer",
  933.     ioctl: nm256_default_mixer_ioctl
  934. };
  936. /*
  937.  * Default settings for the OSS mixer.  These are set last, after the
  938.  * mixer is initialized.
  939.  *
  940.  * I "love" C sometimes.  Got braces?
  941.  */
  942. static struct ac97_mixer_value_list mixer_defaults[] = {
  943.     { SOUND_MIXER_VOLUME,  { { 85, 85 } } },
  944.     { SOUND_MIXER_SPEAKER, { { 100 } } },
  945.     { SOUND_MIXER_PCM,     { { 65, 65 } } },
  946.     { SOUND_MIXER_CD,      { { 65, 65 } } },
  947.     { -1,                  {  { 0,  0 } } }
  948. };
  951. /* Installs the AC97 mixer into CARD.  */
  952. static int __init
  953. nm256_install_mixer (struct nm256_info *card)
  954. {
  955.     int mixer;
  957.     card->mdev.reset_device = nm256_resetAC97;
  958.     card->mdev.read_reg = nm256_readAC97Reg;
  959.     card->mdev.write_reg = nm256_writeAC97Reg;
  960.     card->mdev.driver_private = (void *)card;
  962.     if (ac97_init (&(card->mdev)))
  963. return -1;
  965.     mixer = sound_alloc_mixerdev();
  966.     if (num_mixers >= MAX_MIXER_DEV) {
  967. printk ("NM256 mixer: Unable to alloc mixerdevn");
  968. return -1;
  969.     }
  971.     mixer_devs[mixer] = &nm256_mixer_operations;
  972.     card->mixer_oss_dev = mixer;
  974.     /* Some reasonable default values.  */
  975.     ac97_set_values (&(card->mdev), mixer_defaults);
  977.     printk(KERN_INFO "Initialized AC97 mixern");
  978.     return 0;
  979. }
  981. /* Perform a full reset on the hardware; this is invoked when an APM
  982.    resume event occurs.  */
  983. static void
  984. nm256_full_reset (struct nm256_info *card)
  985. {
  986.     nm256_initHw (card);
  987.     ac97_reset (&(card->mdev));
  988. }
  990. /* 
  991.  * See if the signature left by the NM256 BIOS is intact; if so, we use
  992.  * the associated address as the end of our audio buffer in the video
  993.  * RAM.
  994.  */
  996. static void __init
  997. nm256_peek_for_sig (struct nm256_info *card)
  998. {
  999.     u32 port1offset 
  1000. = card->port[0].physaddr + card->port[0].end_offset - 0x0400;
  1001.     /* The signature is located 1K below the end of video RAM.  */
  1002.     char *temp = ioremap_nocache (port1offset, 16);
  1003.     /* Default buffer end is 5120 bytes below the top of RAM.  */
  1004.     u32 default_value = card->port[0].end_offset - 0x1400;
  1005.     u32 sig;
  1007.     /* Install the default value first, so we don't have to repeatedly
  1008.        do it if there is a problem.  */
  1009.     card->port[0].end_offset = default_value;
  1011.     if (temp == NULL) {
  1012. printk (KERN_ERR "NM256: Unable to scan for card signature in video RAMn");
  1013. return;
  1014.     }
  1015.     sig = readl (temp);
  1016.     if ((sig & NM_SIG_MASK) == NM_SIGNATURE) {
  1017. u32 pointer = readl (temp + 4);
  1019. /*
  1020.  * If it's obviously invalid, don't use it (the port already has a
  1021.  * suitable default value set).
  1022.  */
  1023. if (pointer != 0xffffffff)
  1024.     card->port[0].end_offset = pointer;
  1026. printk (KERN_INFO "NM256: Found card signature in video RAM: 0x%xn",
  1027. pointer);
  1028.     }
  1030.     iounmap (temp);
  1031. }
  1033. /* 
  1034.  * Install a driver for the PCI device referenced by PCIDEV.
  1035.  * VERSTR is a human-readable version string.
  1036.  */
  1038. static int __init
  1039. nm256_install(struct pci_dev *pcidev, enum nm256rev rev, char *verstr)
  1040. {
  1041.     struct nm256_info *card;
  1042.     struct pm_dev *pmdev;
  1043.     int x;
  1045.     if (pci_enable_device(pcidev))
  1046.     return 0;
  1048.     card = kmalloc (sizeof (struct nm256_info), GFP_KERNEL);
  1049.     if (card == NULL) {
  1050. printk (KERN_ERR "NM256: out of memory!n");
  1051. return 0;
  1052.     }
  1054.     card->magsig = NM_MAGIC_SIG;
  1055.     card->playing  = 0;
  1056.     card->recording = 0;
  1057.     card->rev = rev;
  1059.     /* Init the memory port info.  */
  1060.     for (x = 0; x < 2; x++) {
  1061. card->port[x].physaddr = pci_resource_start (pcidev, x);
  1062. card->port[x].ptr = NULL;
  1063. card->port[x].start_offset = 0;
  1064. card->port[x].end_offset = 0;
  1065.     }
  1067.     /* Port 2 is easy.  */
  1068.     card->port[1].start_offset = 0;
  1069.     card->port[1].end_offset = NM_PORT2_SIZE;
  1071.     /* Yuck.  But we have to map in port 2 so we can check how much RAM the
  1072.        card has.  */
  1073.     if (nm256_remap_ports (card)) {
  1074. kfree (card);
  1075. return 0;
  1076.     }
  1078.     /* 
  1079.      * The NM256 has two memory ports.  The first port is nothing
  1080.      * more than a chunk of video RAM, which is used as the I/O ring
  1081.      * buffer.  The second port has the actual juicy stuff (like the
  1082.      * mixer and the playback engine control registers).
  1083.      */
  1085.     if (card->rev == REV_NM256AV) {
  1086. /* Ok, try to see if this is a non-AC97 version of the hardware. */
  1087. int pval = nm256_readPort16 (card, 2, NM_MIXER_PRESENCE);
  1088. if ((pval & NM_PRESENCE_MASK) != NM_PRESENCE_VALUE) {
  1089.     if (! force_load) {
  1090. printk (KERN_ERR "NM256: This doesn't look to me like the AC97-compatible version.n");
  1091. printk (KERN_ERR "       You can force the driver to load by passing in the modulen");
  1092. printk (KERN_ERR "       parameter:n");
  1093. printk (KERN_ERR "              force_ac97 = 1n");
  1094. printk (KERN_ERR "n");
  1095. printk (KERN_ERR "       More likely, you should be using the appropriate SB-16 orn");
  1096. printk (KERN_ERR "       CS4232 driver instead.  (If your BIOS has settings forn");
  1097. printk (KERN_ERR "       IRQ and/or DMA for the sound card, this is *not* the correctn");
  1098. printk (KERN_ERR "       driver to use.)n");
  1099. nm256_release_ports (card);
  1100. kfree (card);
  1101. return 0;
  1102.     }
  1103.     else {
  1104. printk (KERN_INFO "NM256: Forcing driver load as per user request.n");
  1105.     }
  1106. }
  1107. else {
  1108.  /*   printk (KERN_INFO "NM256: Congratulations. You're not running Eunice.n")*/;
  1109. }
  1110. card->port[0].end_offset = 2560 * 1024;
  1111. card->introutine = nm256_interrupt;
  1112. card->mixer_status_offset = NM_MIXER_STATUS_OFFSET;
  1113. card->mixer_status_mask = NM_MIXER_READY_MASK;
  1114.     } 
  1115.     else {
  1116. /* Not sure if there is any relevant detect for the ZX or not.  */
  1117. if (nm256_readPort8 (card, 2, 0xa0b) != 0)
  1118.     card->port[0].end_offset = 6144 * 1024;
  1119. else
  1120.     card->port[0].end_offset = 4096 * 1024;
  1122. card->introutine = nm256_interrupt_zx;
  1123. card->mixer_status_offset = NM2_MIXER_STATUS_OFFSET;
  1124. card->mixer_status_mask = NM2_MIXER_READY_MASK;
  1125.     }
  1127.     if (buffertop >= 98304 && buffertop < card->port[0].end_offset)
  1128. card->port[0].end_offset = buffertop;
  1129.     else
  1130. nm256_peek_for_sig (card);
  1132.     card->port[0].start_offset = card->port[0].end_offset - 98304;
  1134.     printk (KERN_INFO "NM256: Mapping port 1 from 0x%x - 0x%xn",
  1135.     card->port[0].start_offset, card->port[0].end_offset);
  1137.     if (nm256_remap_ports (card)) {
  1138. kfree (card);
  1139. return 0;
  1140.     }
  1142.     /* See if we can get the interrupt. */
  1144.     card->irq = pcidev->irq;
  1145.     card->has_irq = 0;
  1147.     if (nm256_grabInterrupt (card) != 0) {
  1148. nm256_release_ports (card);
  1149. kfree (card);
  1150. return 0;
  1151.     }
  1153.     nm256_releaseInterrupt (card);
  1155.     /*
  1156.      * Init the board.
  1157.      */
  1159.     card->playbackBufferSize = 16384;
  1160.     card->recordBufferSize = 16384;
  1162.     card->coeffBuf = card->port[0].end_offset - NM_MAX_COEFFICIENT;
  1163.     card->abuf2 = card->coeffBuf - card->recordBufferSize;
  1164.     card->abuf1 = card->abuf2 - card->playbackBufferSize;
  1165.     card->allCoeffBuf = card->abuf2 - (NM_TOTAL_COEFF_COUNT * 4);
  1167.     /* Fixed setting. */
  1168.     card->mixer = NM_MIXER_OFFSET;
  1169.     card->mixer_values_init = 0;
  1171.     card->is_open_play = 0;
  1172.     card->is_open_record = 0;
  1174.     card->coeffsCurrent = 0;
  1176.     card->opencnt[0] = 0; card->opencnt[1] = 0;
  1178.     /* Reasonable default settings, but largely unnecessary. */
  1179.     for (x = 0; x < 2; x++) {
  1180. card->sinfo[x].bits = 8;
  1181. card->sinfo[x].stereo = 0;
  1182. card->sinfo[x].samplerate = 8000;
  1183.     }
  1185.     nm256_initHw (card);
  1187.     for (x = 0; x < 2; x++) {
  1188. if ((card->dev[x] =
  1189.      sound_install_audiodrv(AUDIO_DRIVER_VERSION,
  1190.     "NM256", &nm256_audio_driver,
  1191.     sizeof(struct audio_driver),
  1192.     DMA_NODMA, AFMT_U8 | AFMT_S16_LE,
  1193.     NULL, -1, -1)) >= 0) {
  1194.     /* 1K minimum buffer size. */
  1195.     audio_devs[card->dev[x]]->min_fragment = 10;
  1196.     /* Maximum of 8K buffer size. */
  1197.     audio_devs[card->dev[x]]->max_fragment = 13;
  1198. }
  1199. else {
  1200.     printk(KERN_ERR "NM256: Too many PCM devices availablen");
  1201.     nm256_release_ports (card);
  1202.     kfree (card);
  1203.     return 0;
  1204. }
  1205.     }
  1207.     pci_set_drvdata(pcidev,card);
  1209.     /* Insert the card in the list.  */
  1210.     card->next_card = nmcard_list;
  1211.     nmcard_list = card;
  1213.     printk(KERN_INFO "Initialized NeoMagic %s audio in PCI native moden",
  1214.    verstr);
  1216.     /* 
  1217.      * And our mixer.  (We should allow support for other mixers, maybe.)
  1218.      */
  1220.     nm256_install_mixer (card);
  1222.     pmdev = pm_register(PM_PCI_DEV, PM_PCI_ID(pcidev), handle_pm_event);
  1223.     if (pmdev)
  1224.         pmdev->data = card;
  1226.     return 1;
  1227. }
  1230. /*
  1231.  * PM event handler, so the card is properly reinitialized after a power
  1232.  * event.
  1233.  */
  1234. static int
  1235. handle_pm_event (struct pm_dev *dev, pm_request_t rqst, void *data)
  1236. {
  1237.     struct nm256_info *crd = (struct nm256_info*) dev->data;
  1238.     if (crd) {
  1239.         switch (rqst) {
  1240. case PM_SUSPEND:
  1241.     break;
  1242. case PM_RESUME:
  1243.             {
  1244.                 int playing = crd->playing;
  1245.                 nm256_full_reset (crd);
  1246.                 /*
  1247.                  * A little ugly, but that's ok; pretend the
  1248.                  * block we were playing is done. 
  1249.                  */
  1250.                 if (playing)
  1251.                     DMAbuf_outputintr (crd->dev_for_play, 1);
  1252.             }
  1253.     break;
  1254. }
  1255.     }
  1256.     return 0;
  1257. }
  1259. static int __devinit
  1260. nm256_probe(struct pci_dev *pcidev,const struct pci_device_id *pciid)
  1261. {
  1262.     if (pcidev->device == PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO)
  1263. return nm256_install(pcidev, REV_NM256AV, "256AV");
  1264.     if (pcidev->device == PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO)
  1265. return nm256_install(pcidev, REV_NM256ZX, "256ZX");
  1266.     return -1; /* should not come here ... */
  1267. }
  1269. static void __devinit
  1270. nm256_remove(struct pci_dev *pcidev) {
  1271.     struct nm256_info *xcard = pci_get_drvdata(pcidev);
  1272.     struct nm256_info *card,*next_card = NULL;
  1274.     for (card = nmcard_list; card != NULL; card = next_card) {
  1275. next_card = card->next_card;
  1276. if (card == xcard) {
  1277.     stopPlay (card);
  1278.     stopRecord (card);
  1279.     if (card->has_irq)
  1280. free_irq (card->irq, card);
  1281.     nm256_release_ports (card);
  1282.     sound_unload_mixerdev (card->mixer_oss_dev);
  1283.     sound_unload_audiodev (card->dev[0]);
  1284.     sound_unload_audiodev (card->dev[1]);
  1285.     kfree (card);
  1286.     break;
  1287. }
  1288.     }
  1289.     if (nmcard_list == card)
  1290.      nmcard_list = next_card;
  1291. }
  1293. /*
  1294.  * Open the device
  1295.  *
  1296.  * DEV  - device
  1297.  * MODE - mode to open device (logical OR of OPEN_READ and OPEN_WRITE)
  1298.  *
  1299.  * Called when opening the DMAbuf               (dmabuf.c:259)
  1300.  */
  1301. static int
  1302. nm256_audio_open(int dev, int mode)
  1303. {
  1304.     struct nm256_info *card = nm256_find_card (dev);
  1305.     int w;
  1307.     if (card == NULL)
  1308. return -ENODEV;
  1310.     if (card->dev[0] == dev)
  1311. w = 0;
  1312.     else if (card->dev[1] == dev)
  1313. w = 1;
  1314.     else
  1315. return -ENODEV;
  1317.     if (card->opencnt[w] > 0)
  1318. return -EBUSY;
  1320.     /* No bits set? Huh? */
  1321.     if (! ((mode & OPEN_READ) || (mode & OPEN_WRITE)))
  1322. return -EIO;
  1324.     /*
  1325.      * If it's open for both read and write, and the card's currently
  1326.      * being read or written to, then do the opposite of what has
  1327.      * already been done.  Otherwise, don't specify any mode until the
  1328.      * user actually tries to do I/O.  (Some programs open the device
  1329.      * for both read and write, but only actually do reading or writing.)
  1330.      */
  1332.     if ((mode & OPEN_WRITE) && (mode & OPEN_READ)) {
  1333. if (card->is_open_play)
  1334.     mode = OPEN_WRITE;
  1335. else if (card->is_open_record)
  1336.     mode = OPEN_READ;
  1337. else mode = 0;
  1338.     }
  1340.     if (mode & OPEN_WRITE) {
  1341. if (card->is_open_play == 0) {
  1342.     card->dev_for_play = dev;
  1343.     card->is_open_play = 1;
  1344. }
  1345. else
  1346.     return -EBUSY;
  1347.     }
  1349.     if (mode & OPEN_READ) {
  1350. if (card->is_open_record == 0) {
  1351.     card->dev_for_record = dev;
  1352.     card->is_open_record = 1;
  1353. }
  1354. else
  1355.     return -EBUSY;
  1356.     }
  1358.     card->opencnt[w]++;
  1359.     return 0;
  1360. }
  1362. /*
  1363.  * Close the device
  1364.  *
  1365.  * DEV  - device
  1366.  *
  1367.  * Called when closing the DMAbuf               (dmabuf.c:477)
  1368.  *      after halt_xfer
  1369.  */
  1370. static void
  1371. nm256_audio_close(int dev)
  1372. {
  1373.     struct nm256_info *card = nm256_find_card (dev);
  1375.     if (card != NULL) {
  1376. int w;
  1378. if (card->dev[0] == dev)
  1379.     w = 0;
  1380. else if (card->dev[1] == dev)
  1381.     w = 1;
  1382. else
  1383.     return;
  1385. card->opencnt[w]--;
  1386. if (card->opencnt[w] <= 0) {
  1387.     card->opencnt[w] = 0;
  1389.     if (card->dev_for_play == dev) {
  1390. stopPlay (card);
  1391. card->is_open_play = 0;
  1392. card->dev_for_play = -1;
  1393.     }
  1395.     if (card->dev_for_record == dev) {
  1396. stopRecord (card);
  1397. card->is_open_record = 0;
  1398. card->dev_for_record = -1;
  1399.     }
  1400. }
  1401.     }
  1402. }
  1404. /* Standard ioctl handler. */
  1405. static int
  1406. nm256_audio_ioctl(int dev, unsigned int cmd, caddr_t arg)
  1407. {
  1408.     int ret;
  1409.     u32 oldinfo;
  1410.     int w;
  1412.     struct nm256_info *card = nm256_find_card (dev);
  1414.     if (card == NULL)
  1415. return -ENODEV;
  1417.     if (dev == card->dev[0])
  1418. w = 0;
  1419.     else
  1420. w = 1;
  1422.     /* 
  1423.      * The code here is messy.  There are probably better ways to do
  1424.      * it.  (It should be possible to handle it the same way the AC97 mixer 
  1425.      * is done.)
  1426.      */
  1427.     switch (cmd)
  1428. {
  1429. case SOUND_PCM_WRITE_RATE:
  1430.     if (get_user(ret, (int *) arg))
  1431. return -EFAULT;
  1433.     if (ret != 0) {
  1434. oldinfo = card->sinfo[w].samplerate;
  1435. card->sinfo[w].samplerate = ret;
  1436. ret = nm256_setInfo(dev, card);
  1437. if (ret != 0)
  1438.     card->sinfo[w].samplerate = oldinfo;
  1439.     }
  1440.     if (ret == 0)
  1441. ret = card->sinfo[w].samplerate;
  1442.     break;
  1444. case SOUND_PCM_READ_RATE:
  1445.     ret = card->sinfo[w].samplerate;
  1446.     break;
  1448. case SNDCTL_DSP_STEREO:
  1449.     if (get_user(ret, (int *) arg))
  1450. return -EFAULT;
  1452.     card->sinfo[w].stereo = ret ? 1 : 0;
  1453.     ret = nm256_setInfo (dev, card);
  1454.     if (ret == 0)
  1455. ret = card->sinfo[w].stereo;
  1457.     break;
  1459. case SOUND_PCM_WRITE_CHANNELS:
  1460.     if (get_user(ret, (int *) arg))
  1461. return -EFAULT;
  1463.     if (ret < 1 || ret > 3)
  1464. ret = card->sinfo[w].stereo + 1;
  1465.     else {
  1466. card->sinfo[w].stereo = ret - 1;
  1467. ret = nm256_setInfo (dev, card);
  1468. if (ret == 0)
  1469.     ret = card->sinfo[w].stereo + 1;
  1470.     }
  1471.     break;
  1473. case SOUND_PCM_READ_CHANNELS:
  1474.     ret = card->sinfo[w].stereo + 1;
  1475.     break;
  1477. case SNDCTL_DSP_SETFMT:
  1478.     if (get_user(ret, (int *) arg))
  1479. return -EFAULT;
  1481.     if (ret != 0) {
  1482. oldinfo = card->sinfo[w].bits;
  1483. card->sinfo[w].bits = ret;
  1484. ret = nm256_setInfo (dev, card);
  1485. if (ret != 0)
  1486.     card->sinfo[w].bits = oldinfo;
  1487.     }
  1488.     if (ret == 0)
  1489. ret = card->sinfo[w].bits;
  1490.     break;
  1492. case SOUND_PCM_READ_BITS:
  1493.     ret = card->sinfo[w].bits;
  1494.     break;
  1496. default:
  1497.     return -EINVAL;
  1498. }
  1499.     return put_user(ret, (int *) arg);
  1500. }
  1502. /*
  1503.  * Given the sound device DEV and an associated physical buffer PHYSBUF, 
  1504.  * return a pointer to the actual buffer in kernel space. 
  1505.  *
  1506.  * This routine should exist as part of the soundcore routines.
  1507.  */
  1509. static char *
  1510. nm256_getDMAbuffer (int dev, unsigned long physbuf)
  1511. {
  1512.     struct audio_operations *adev = audio_devs[dev];
  1513.     struct dma_buffparms *dmap = adev->dmap_out;
  1514.     char *dma_start =
  1515. (char *)(physbuf - (unsigned long)dmap->raw_buf_phys 
  1516.  + (unsigned long)dmap->raw_buf);
  1518.     return dma_start;
  1519. }
  1522. /*
  1523.  * Output a block to sound device
  1524.  *
  1525.  * dev          - device number
  1526.  * buf          - physical address of buffer
  1527.  * total_count  - total byte count in buffer
  1528.  * intrflag     - set if this has been called from an interrupt 
  1529.  *   (via DMAbuf_outputintr)
  1530.  * restart_dma  - set if engine needs to be re-initialised
  1531.  *
  1532.  * Called when:
  1533.  *  1. Starting output                                  (dmabuf.c:1327)
  1534.  *  2.                                                  (dmabuf.c:1504)
  1535.  *  3. A new buffer needs to be sent to the device      (dmabuf.c:1579)
  1536.  */
  1537. static void
  1538. nm256_audio_output_block(int dev, unsigned long physbuf,
  1539.        int total_count, int intrflag)
  1540. {
  1541.     struct nm256_info *card = nm256_find_card (dev);
  1543.     if (card != NULL) {
  1544. char *dma_buf = nm256_getDMAbuffer (dev, physbuf);
  1545. card->is_open_play = 1;
  1546. card->dev_for_play = dev;
  1547. nm256_write_block (card, dma_buf, total_count);
  1548.     }
  1549. }
  1551. /* Ditto, but do recording instead.  */
  1552. static void
  1553. nm256_audio_start_input(int dev, unsigned long physbuf, int count,
  1554. int intrflag)
  1555. {
  1556.     struct nm256_info *card = nm256_find_card (dev);
  1558.     if (card != NULL) {
  1559. char *dma_buf = nm256_getDMAbuffer (dev, physbuf);
  1560. card->is_open_record = 1;
  1561. card->dev_for_record = dev;
  1562. nm256_startRecording (card, dma_buf, count);
  1563.     }
  1564. }
  1566. /* 
  1567.  * Prepare for inputting samples to DEV. 
  1568.  * Each requested buffer will be BSIZE byes long, with a total of
  1569.  * BCOUNT buffers. 
  1570.  */
  1572. static int
  1573. nm256_audio_prepare_for_input(int dev, int bsize, int bcount)
  1574. {
  1575.     struct nm256_info *card = nm256_find_card (dev);
  1577.     if (card == NULL) 
  1578. return -ENODEV;
  1580.     if (card->is_open_record && card->dev_for_record != dev)
  1581. return -EBUSY;
  1583.     audio_devs[dev]->dmap_in->flags |= DMA_NODMA;
  1584.     return 0;
  1585. }
  1587. /*
  1588.  * Prepare for outputting samples to `dev'
  1589.  *
  1590.  * Each buffer that will be passed will be `bsize' bytes long,
  1591.  * with a total of `bcount' buffers.
  1592.  *
  1593.  * Called when:
  1594.  *  1. A trigger enables audio output                   (dmabuf.c:978)
  1595.  *  2. We get a write buffer without dma_mode setup     (dmabuf.c:1152)
  1596.  *  3. We restart a transfer                            (dmabuf.c:1324)
  1597.  */
  1599. static int
  1600. nm256_audio_prepare_for_output(int dev, int bsize, int bcount)
  1601. {
  1602.     struct nm256_info *card = nm256_find_card (dev);
  1604.     if (card == NULL)
  1605. return -ENODEV;
  1607.     if (card->is_open_play && card->dev_for_play != dev)
  1608. return -EBUSY;
  1610.     audio_devs[dev]->dmap_out->flags |= DMA_NODMA;
  1611.     return 0;
  1612. }
  1614. /* Stop the current operations associated with DEV.  */
  1615. static void
  1616. nm256_audio_reset(int dev)
  1617. {
  1618.     struct nm256_info *card = nm256_find_card (dev);
  1620.     if (card != NULL) {
  1621. if (card->dev_for_play == dev)
  1622.     stopPlay (card);
  1623. if (card->dev_for_record == dev)
  1624.     stopRecord (card);
  1625.     }
  1626. }
  1628. static int
  1629. nm256_audio_local_qlen(int dev)
  1630. {
  1631.     return 0;
  1632. }
  1634. static struct audio_driver nm256_audio_driver =
  1635. {
  1636.     owner: THIS_MODULE,
  1637.     open: nm256_audio_open,
  1638.     close: nm256_audio_close,
  1639.     output_block: nm256_audio_output_block,
  1640.     start_input: nm256_audio_start_input,
  1641.     ioctl: nm256_audio_ioctl,
  1642.     prepare_for_input: nm256_audio_prepare_for_input,
  1643.     prepare_for_output:nm256_audio_prepare_for_output,
  1644.     halt_io: nm256_audio_reset,
  1645.     local_qlen: nm256_audio_local_qlen,
  1646. };
  1648. static struct pci_device_id nm256_pci_tbl[] __devinitdata = {
  1649. {PCI_VENDOR_ID_NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO,
  1650. PCI_ANY_ID, PCI_ANY_ID, 0, 0},
  1651. {PCI_VENDOR_ID_NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO,
  1652. PCI_ANY_ID, PCI_ANY_ID, 0, 0},
  1653. {0,}
  1654. };
  1655. MODULE_DEVICE_TABLE(pci, nm256_pci_tbl);
  1656. MODULE_LICENSE("GPL");
  1659. struct pci_driver nm256_pci_driver = {
  1660. name:"nm256_audio",
  1661. id_table:nm256_pci_tbl,
  1662. probe:nm256_probe,
  1663. remove:nm256_remove,
  1664. };
  1666. MODULE_PARM (usecache, "i");
  1667. MODULE_PARM (buffertop, "i");
  1668. MODULE_PARM (nm256_debug, "i");
  1669. MODULE_PARM (force_load, "i");
  1671. static int __init do_init_nm256(void)
  1672. {
  1673.     printk (KERN_INFO "NeoMagic 256AV/256ZX audio driver, version 1.1pn");
  1674.     return pci_module_init(&nm256_pci_driver);
  1675. }
  1677. static void __exit cleanup_nm256 (void)
  1678. {
  1679.     pci_unregister_driver(&nm256_pci_driver);
  1680.     pm_unregister_all (&handle_pm_event);
  1681. }
  1683. module_init(do_init_nm256);
  1684. module_exit(cleanup_nm256);
  1686. /*
  1687.  * Local variables:
  1688.  *  c-basic-offset: 4
  1689.  * End:
  1690.  */