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