File: /usr/src/linux/drivers/sound/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 #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"
31
32 int nm256_debug;
33 static int force_load;
34
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
41
42 static struct audio_driver nm256_audio_driver;
43
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);
49
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
53
54 /* List of cards. */
55 static struct nm256_info *nmcard_list;
56
57 /* Release the mapped-in memory for CARD. */
58 static void
59 nm256_release_ports (struct nm256_info *card)
60 {
61 int x;
62
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 }
70
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;
85
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;
92
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 %d\n", x + 1);
97 nm256_release_ports (card);
98 return -1;
99 }
100 }
101 }
102 return 0;
103 }
104
105 /* Locate the card in our list. */
106 static struct nm256_info *
107 nm256_find_card (int dev)
108 {
109 struct nm256_info *card;
110
111 for (card = nmcard_list; card != NULL; card = card->next_card)
112 if (card->dev[0] == dev || card->dev[1] == dev)
113 return card;
114
115 return NULL;
116 }
117
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;
126
127 for (card = nmcard_list; card != NULL; card = card->next_card)
128 if (card->mixer_oss_dev == dev)
129 return card;
130
131 return NULL;
132 }
133
134 static int usecache;
135 static int buffertop;
136
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 }
143
144 /* The actual rates supported by the card. */
145 static int samplerates[9] = {
146 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 99999999
147 };
148
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 */
156
157 int
158 nm256_setInfo (int dev, struct nm256_info *card)
159 {
160 int x;
161 int w;
162 int targetrate;
163
164 if (card->dev[0] == dev)
165 w = 0;
166 else if (card->dev[1] == dev)
167 w = 1;
168 else
169 return -ENODEV;
170
171 targetrate = card->sinfo[w].samplerate;
172
173 if ((card->sinfo[w].bits != 8 && card->sinfo[w].bits != 16)
174 || targetrate < samplerates[0]
175 || targetrate > samplerates[7])
176 return -EINVAL;
177
178 for (x = 0; x < 8; x++)
179 if (targetrate < ((samplerates[x] + samplerates[x + 1]) / 2))
180 break;
181
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;
188
189 card->sinfo[w].samplerate = samplerates[x];
190
191
192 if (card->dev_for_play == dev && card->playing) {
193 if (nm256_debug)
194 printk (KERN_DEBUG "Setting play ratebits to 0x%x\n",
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 }
201
202 if (card->dev_for_record == dev && card->recording) {
203 if (nm256_debug)
204 printk (KERN_DEBUG "Setting record ratebits to 0x%x\n",
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 }
216
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);
225
226 /* Enable playback engine and interrupts. */
227 nm256_writePort8 (card, 2, NM_PLAYBACK_ENABLE_REG,
228 NM_PLAYBACK_ENABLE_FLAG | NM_PLAYBACK_FREERUN);
229
230 /* Enable both channels. */
231 nm256_writePort16 (card, 2, NM_AUDIO_MUTE_REG, 0x0);
232 }
233 }
234 }
235
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 */
241
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;
249
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: %d\n", amt);
257 amt = ringsize / 2;
258 }
259
260 if (amt < 8) {
261 printk (KERN_ERR "NM256: Read request too small; %d\n", amt);
262 return;
263 }
264
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);
279
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 }
290
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);
297
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);
305
306 restore_flags (flags);
307 }
308
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);
320
321 /* Reset the relevant state bits. */
322 card->playing = 0;
323 card->curPlayPos = 0;
324 }
325 }
326
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);
333
334 if (card->recording) {
335 nm256_releaseInterrupt (card);
336
337 card->recording = 0;
338 card->curRecPos = 0;
339 }
340 }
341
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 */
351
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;
358
359 if (amt > (ringsize / 2)) {
360 printk (KERN_ERR "NM256: Write request too large: %d\n", amt);
361 amt = (ringsize / 2);
362 }
363
364 if (amt < NM256_PLAY_WMARK_SIZE) {
365 printk (KERN_ERR "NM256: Write request too small: %d\n", amt);
366 return;
367 }
368
369 card->curPlayPos %= ringsize;
370
371 card->requested_amt = amt;
372
373 save_flags (flags);
374 cli ();
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 restore_flags (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 /* Ultra cheez-whiz. But I'm too lazy to grep headers. */
455 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
456
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 */
462
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;
470
471 if (currptr >= card->recordBufferSize) {
472 printk (KERN_ERR "NM256: Sound buffer record pointer invalid!\n");
473 currptr = 0;
474 }
475
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);
485
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 }
495
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
508
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);
518
519 stopRecord (card);
520 stopPlay (card);
521 }
522
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 */
531
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;
538
539 if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
540 printk (KERN_ERR "NM256: Bad card pointer\n");
541 return;
542 }
543
544 status = nm256_readPort16 (card, 2, NM_INT_REG);
545
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 */
561
562 if (card->playing)
563 stopPlay (card);
564 if (card->recording)
565 stopRecord (card);
566 badintrcount = 0;
567 }
568 return;
569 }
570
571 badintrcount = 0;
572
573 /* Rather boring; check for individual interrupts and process them. */
574
575 if (status & NM_PLAYBACK_INT) {
576 status &= ~NM_PLAYBACK_INT;
577 NM_ACK_INT (card, NM_PLAYBACK_INT);
578
579 if (card->playing)
580 nm256_get_new_block (card);
581 }
582
583 if (status & NM_RECORD_INT) {
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 status &= ~NM_MISC_INT_1;
595 printk (KERN_ERR "NM256: Got misc interrupt #1\n");
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 }
601
602 if (status & NM_MISC_INT_2) {
603 u8 cbyte;
604
605 status &= ~NM_MISC_INT_2;
606 printk (KERN_ERR "NM256: Got misc interrupt #2\n");
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 }
611
612 /* Unknown interrupt. */
613 if (status) {
614 printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%x\n",
615 status);
616 /* Pray. */
617 NM_ACK_INT (card, status);
618 }
619 }
620
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 */
626
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;
633
634 if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
635 printk (KERN_ERR "NM256: Bad card pointer\n");
636 return;
637 }
638
639 status = nm256_readPort32 (card, 2, NM_INT_REG);
640
641 /* Not ours. */
642 if (status == 0) {
643 if (badintrcount++ > 1000) {
644 printk (KERN_ERR "NM256: Releasing interrupt, over 1000 invalid interrupts\n");
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 */
658
659 if (card->playing)
660 stopPlay (card);
661 if (card->recording)
662 stopRecord (card);
663 badintrcount = 0;
664 }
665 return;
666 }
667
668 badintrcount = 0;
669
670 /* Rather boring; check for individual interrupts and process them. */
671
672 if (status & NM2_PLAYBACK_INT) {
673 status &= ~NM2_PLAYBACK_INT;
674 NM2_ACK_INT (card, NM2_PLAYBACK_INT);
675
676 if (card->playing)
677 nm256_get_new_block (card);
678 }
679
680 if (status & NM2_RECORD_INT) {
681 status &= ~NM2_RECORD_INT;
682 NM2_ACK_INT (card, NM2_RECORD_INT);
683
684 if (card->recording)
685 nm256_read_block (card);
686 }
687
688 if (status & NM2_MISC_INT_1) {
689 u8 cbyte;
690
691 status &= ~NM2_MISC_INT_1;
692 printk (KERN_ERR "NM256: Got misc interrupt #1\n");
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 }
697
698 if (status & NM2_MISC_INT_2) {
699 u8 cbyte;
700
701 status &= ~NM2_MISC_INT_2;
702 printk (KERN_ERR "NM256: Got misc interrupt #2\n");
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 }
707
708 /* Unknown interrupt. */
709 if (status) {
710 printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%x\n",
711 status);
712 /* Pray. */
713 NM2_ACK_INT (card, status);
714 }
715 }
716
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 %d\n", card->irq);
727 return -1;
728 }
729 }
730 return 0;
731 }
732
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 releaseInterrupt\n");
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 }
749
750 /*
751 * Waits for the mixer to become ready to be written; returns a zero value
752 * if it timed out.
753 */
754
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;
763
764 if (card->magsig != NM_MAGIC_SIG) {
765 printk (KERN_ERR "NM256: Bad magic signature in isReady!\n");
766 return 0;
767 }
768
769 testaddr = card->mixer_status_offset;
770 testb = card->mixer_status_mask;
771
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 }
783
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;
792
793 if (card->magsig != NM_MAGIC_SIG) {
794 printk (KERN_ERR "NM256: Bad magic signature in readAC97Reg!\n");
795 return -EINVAL;
796 }
797
798 if (reg < 128) {
799 int res;
800
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 }
810
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;
822
823 struct nm256_info *card = (struct nm256_info *)dev->driver_private;
824
825 if (card->magsig != NM_MAGIC_SIG) {
826 printk (KERN_ERR "NM256: Bad magic signature in writeAC97Reg!\n");
827 return -EINVAL;
828 }
829
830 base = card->mixer;
831
832 save_flags (flags);
833 cli ();
834
835 nm256_isReady (dev);
836
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 }
844
845 }
846
847 restore_flags (flags);
848 udelay (1000);
849
850 return ! done;
851 }
852
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 };
865
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 };
884
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;
891
892 if (card->magsig != NM_MAGIC_SIG) {
893 printk (KERN_ERR "NM256: Bad magic signature in resetAC97!\n");
894 return -EINVAL;
895 }
896
897 /* Reset the mixer. 'Tis magic! */
898 nm256_writePort8 (card, 2, 0x6c0, 1);
899 nm256_writePort8 (card, 2, 0x6cc, 0x87);
900 nm256_writePort8 (card, 2, 0x6cc, 0x80);
901 nm256_writePort8 (card, 2, 0x6cc, 0x0);
902
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 }
911
912 return 0;
913 }
914
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 }
928
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 };
935
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 };
949
950
951 /* Installs the AC97 mixer into CARD. */
952 static int __init
953 nm256_install_mixer (struct nm256_info *card)
954 {
955 int mixer;
956
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;
961
962 if (ac97_init (&(card->mdev)))
963 return -1;
964
965 mixer = sound_alloc_mixerdev();
966 if (num_mixers >= MAX_MIXER_DEV) {
967 printk ("NM256 mixer: Unable to alloc mixerdev\n");
968 return -1;
969 }
970
971 mixer_devs[mixer] = &nm256_mixer_operations;
972 card->mixer_oss_dev = mixer;
973
974 /* Some reasonable default values. */
975 ac97_set_values (&(card->mdev), mixer_defaults);
976
977 printk(KERN_INFO "Initialized AC97 mixer\n");
978 return 0;
979 }
980
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 }
989
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 */
995
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;
1006
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;
1010
1011 if (temp == NULL) {
1012 printk (KERN_ERR "NM256: Unable to scan for card signature in video RAM\n");
1013 return;
1014 }
1015 sig = readl (temp);
1016 if ((sig & NM_SIG_MASK) == NM_SIGNATURE) {
1017 u32 pointer = readl (temp + 4);
1018
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;
1025
1026 printk (KERN_INFO "NM256: Found card signature in video RAM: 0x%x\n",
1027 pointer);
1028 }
1029
1030 iounmap (temp);
1031 }
1032
1033 /*
1034 * Install a driver for the PCI device referenced by PCIDEV.
1035 * VERSTR is a human-readable version string.
1036 */
1037
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;
1044
1045 if (pci_enable_device(pcidev))
1046 return 0;
1047
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 }
1053
1054 card->magsig = NM_MAGIC_SIG;
1055 card->playing = 0;
1056 card->recording = 0;
1057 card->rev = rev;
1058
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 }
1066
1067 /* Port 2 is easy. */
1068 card->port[1].start_offset = 0;
1069 card->port[1].end_offset = NM_PORT2_SIZE;
1070
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 }
1077
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 */
1084
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 module\n");
1092 printk (KERN_ERR " parameter:\n");
1093 printk (KERN_ERR " force_ac97 = 1\n");
1094 printk (KERN_ERR "\n");
1095 printk (KERN_ERR " More likely, you should be using the appropriate SB-16 or\n");
1096 printk (KERN_ERR " CS4232 driver instead. (If your BIOS has settings for\n");
1097 printk (KERN_ERR " IRQ and/or DMA for the sound card, this is *not* the correct\n");
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;
1121
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 }
1126
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);
1131
1132 card->port[0].start_offset = card->port[0].end_offset - 98304;
1133
1134 printk (KERN_INFO "NM256: Mapping port 1 from 0x%x - 0x%x\n",
1135 card->port[0].start_offset, card->port[0].end_offset);
1136
1137 if (nm256_remap_ports (card)) {
1138 kfree (card);
1139 return 0;
1140 }
1141
1142 /* See if we can get the interrupt. */
1143
1144 card->irq = pcidev->irq;
1145 card->has_irq = 0;
1146
1147 if (nm256_grabInterrupt (card) != 0) {
1148 nm256_release_ports (card);
1149 kfree (card);
1150 return 0;
1151 }
1152
1153 nm256_releaseInterrupt (card);
1154
1155 /*
1156 * Init the board.
1157 */
1158
1159 card->playbackBufferSize = 16384;
1160 card->recordBufferSize = 16384;
1161
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);
1166
1167 /* Fixed setting. */
1168 card->mixer = NM_MIXER_OFFSET;
1169 card->mixer_values_init = 0;
1170
1171 card->is_open_play = 0;
1172 card->is_open_record = 0;
1173
1174 card->coeffsCurrent = 0;
1175
1176 card->opencnt[0] = 0; card->opencnt[1] = 0;
1177
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 }
1184
1185 nm256_initHw (card);
1186
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 available\n");
1201 nm256_release_ports (card);
1202 kfree (card);
1203 return 0;
1204 }
1205 }
1206
1207 pci_set_drvdata(pcidev,card);
1208
1209 /* Insert the card in the list. */
1210 card->next_card = nmcard_list;
1211 nmcard_list = card;
1212
1213 printk(KERN_INFO "Initialized NeoMagic %s audio in PCI native mode\n",
1214 verstr);
1215
1216 /*
1217 * And our mixer. (We should allow support for other mixers, maybe.)
1218 */
1219
1220 nm256_install_mixer (card);
1221
1222 pmdev = pm_register(PM_PCI_DEV, PM_PCI_ID(pcidev), handle_pm_event);
1223 if (pmdev)
1224 pmdev->data = card;
1225
1226 return 1;
1227 }
1228
1229
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 }
1258
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 }
1268
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;
1273
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 }
1292
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;
1306
1307 if (card == NULL)
1308 return -ENODEV;
1309
1310 if (card->dev[0] == dev)
1311 w = 0;
1312 else if (card->dev[1] == dev)
1313 w = 1;
1314 else
1315 return -ENODEV;
1316
1317 if (card->opencnt[w] > 0)
1318 return -EBUSY;
1319
1320 /* No bits set? Huh? */
1321 if (! ((mode & OPEN_READ) || (mode & OPEN_WRITE)))
1322 return -EIO;
1323
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 */
1331
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 }
1339
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 }
1348
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 }
1357
1358 card->opencnt[w]++;
1359 return 0;
1360 }
1361
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);
1374
1375 if (card != NULL) {
1376 int w;
1377
1378 if (card->dev[0] == dev)
1379 w = 0;
1380 else if (card->dev[1] == dev)
1381 w = 1;
1382 else
1383 return;
1384
1385 card->opencnt[w]--;
1386 if (card->opencnt[w] <= 0) {
1387 card->opencnt[w] = 0;
1388
1389 if (card->dev_for_play == dev) {
1390 stopPlay (card);
1391 card->is_open_play = 0;
1392 card->dev_for_play = -1;
1393 }
1394
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 }
1403
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;
1411
1412 struct nm256_info *card = nm256_find_card (dev);
1413
1414 if (card == NULL)
1415 return -ENODEV;
1416
1417 if (dev == card->dev[0])
1418 w = 0;
1419 else
1420 w = 1;
1421
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;
1432
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;
1443
1444 case SOUND_PCM_READ_RATE:
1445 ret = card->sinfo[w].samplerate;
1446 break;
1447
1448 case SNDCTL_DSP_STEREO:
1449 if (get_user(ret, (int *) arg))
1450 return -EFAULT;
1451
1452 card->sinfo[w].stereo = ret ? 1 : 0;
1453 ret = nm256_setInfo (dev, card);
1454 if (ret == 0)
1455 ret = card->sinfo[w].stereo;
1456
1457 break;
1458
1459 case SOUND_PCM_WRITE_CHANNELS:
1460 if (get_user(ret, (int *) arg))
1461 return -EFAULT;
1462
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;
1472
1473 case SOUND_PCM_READ_CHANNELS:
1474 ret = card->sinfo[w].stereo + 1;
1475 break;
1476
1477 case SNDCTL_DSP_SETFMT:
1478 if (get_user(ret, (int *) arg))
1479 return -EFAULT;
1480
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;
1491
1492 case SOUND_PCM_READ_BITS:
1493 ret = card->sinfo[w].bits;
1494 break;
1495
1496 default:
1497 return -EINVAL;
1498 }
1499 return put_user(ret, (int *) arg);
1500 }
1501
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 */
1508
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);
1517
1518 return dma_start;
1519 }
1520
1521
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);
1542
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 }
1550
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);
1557
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 }
1565
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 */
1571
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);
1576
1577 if (card == NULL)
1578 return -ENODEV;
1579
1580 if (card->is_open_record && card->dev_for_record != dev)
1581 return -EBUSY;
1582
1583 audio_devs[dev]->dmap_in->flags |= DMA_NODMA;
1584 return 0;
1585 }
1586
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 */
1598
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);
1603
1604 if (card == NULL)
1605 return -ENODEV;
1606
1607 if (card->is_open_play && card->dev_for_play != dev)
1608 return -EBUSY;
1609
1610 audio_devs[dev]->dmap_out->flags |= DMA_NODMA;
1611 return 0;
1612 }
1613
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);
1619
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 }
1627
1628 static int
1629 nm256_audio_local_qlen(int dev)
1630 {
1631 return 0;
1632 }
1633
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 };
1647
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
1657 struct pci_driver nm256_pci_driver = {
1658 name:"nm256_audio",
1659 id_table:nm256_pci_tbl,
1660 probe:nm256_probe,
1661 remove:nm256_remove,
1662 };
1663
1664 MODULE_PARM (usecache, "i");
1665 MODULE_PARM (buffertop, "i");
1666 MODULE_PARM (nm256_debug, "i");
1667 MODULE_PARM (force_load, "i");
1668
1669 static int __init do_init_nm256(void)
1670 {
1671 printk (KERN_INFO "NeoMagic 256AV/256ZX audio driver, version 1.1p\n");
1672 return pci_module_init(&nm256_pci_driver);
1673 }
1674
1675 static void __exit cleanup_nm256 (void)
1676 {
1677 pci_unregister_driver(&nm256_pci_driver);
1678 pm_unregister_all (&handle_pm_event);
1679 }
1680
1681 module_init(do_init_nm256);
1682 module_exit(cleanup_nm256);
1683
1684 /*
1685 * Local variables:
1686 * c-basic-offset: 4
1687 * End:
1688 */
1689