aboutsummaryrefslogtreecommitdiffstats
path: root/sound/oss/nm256_audio.c
diff options
context:
space:
mode:
authorAdrian Bunk <bunk@stusta.de>2007-07-16 02:39:01 -0400
committerLinus Torvalds <torvalds@woody.linux-foundation.org>2007-07-16 12:05:40 -0400
commitb5d425c97f7d4e92151167b01ca038e7853c6b37 (patch)
treee2a888ad0e79325b3eecd60738ddd92aba770ebf /sound/oss/nm256_audio.c
parent786d7e1612f0b0adb6046f19b906609e4fe8b1ba (diff)
more scheduled OSS driver removal
This patch contains the scheduled removal of OSS drivers that: - have ALSA drivers for the same hardware without known regressions and - whose Kconfig options have been removed in 2.6.20. Signed-off-by: Adrian Bunk <bunk@stusta.de> Acked-by: Jeff Garzik <jeff@garzik.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat (limited to 'sound/oss/nm256_audio.c')
-rw-r--r--sound/oss/nm256_audio.c1662
1 files changed, 0 insertions, 1662 deletions
diff --git a/sound/oss/nm256_audio.c b/sound/oss/nm256_audio.c
deleted file mode 100644
index 44cd15505001..000000000000
--- a/sound/oss/nm256_audio.c
+++ /dev/null
@@ -1,1662 +0,0 @@
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
31static int nm256_debug;
32static 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
44static struct audio_driver nm256_audio_driver;
45
46static int nm256_grabInterrupt (struct nm256_info *card);
47static int nm256_releaseInterrupt (struct nm256_info *card);
48static irqreturn_t nm256_interrupt (int irq, void *dev_id);
49static 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. */
57static struct nm256_info *nmcard_list;
58
59/* Release the mapped-in memory for CARD. */
60static void
61nm256_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 */
83static int
84nm256_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. */
108static struct nm256_info *
109nm256_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 */
124static struct nm256_info *
125nm256_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
136static int usecache;
137static int buffertop;
138
139/* Check to see if we're using the bank of cached coefficients. */
140static int
141nm256_cachedCoefficients (struct nm256_info *card)
142{
143 return usecache;
144}
145
146/* The actual rates supported by the card. */
147static 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
159static int
160nm256_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. */
220static void
221startPlay (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
244static void
245nm256_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. */
311static void
312stopPlay (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. */
329static void
330stopRecord (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
353static void
354nm256_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. */
425static void
426nm256_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
460static void
461nm256_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 */
508static void
509nm256_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
528static irqreturn_t
529nm256_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
631static irqreturn_t
632nm256_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 */
732static int
733nm256_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 */
748static int
749nm256_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
767static int
768nm256_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 */
800static int
801nm256_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 */
827static int
828nm256_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 */
871struct initialValues
872{
873 unsigned short port;
874 unsigned short value;
875};
876
877static 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. */
897static int
898nm256_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 */
930static int
931nm256_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
940static 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 */
953static 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. */
963static int __devinit
964nm256_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
998static void __devinit
999nm256_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
1040static int __devinit
1041nm256_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
1228static int __devinit
1229nm256_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
1240static void __devinit
1241nm256_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 */
1272static int
1273nm256_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 */
1341static void
1342nm256_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. */
1376static int
1377nm256_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
1480static char *
1481nm256_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 */
1508static void
1509nm256_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. */
1523static void
1524nm256_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
1543static int
1544nm256_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
1570static int
1571nm256_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. */
1586static void
1587nm256_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
1599static int
1600nm256_audio_local_qlen(int dev)
1601{
1602 return 0;
1603}
1604
1605static 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
1619static 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};
1628MODULE_DEVICE_TABLE(pci, nm256_pci_tbl);
1629MODULE_LICENSE("GPL");
1630
1631
1632static 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
1639module_param(usecache, bool, 0);
1640module_param(buffertop, int, 0);
1641module_param(nm256_debug, bool, 0644);
1642module_param(force_load, bool, 0);
1643
1644static 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
1650static void __exit cleanup_nm256 (void)
1651{
1652 pci_unregister_driver(&nm256_pci_driver);
1653}
1654
1655module_init(do_init_nm256);
1656module_exit(cleanup_nm256);
1657
1658/*
1659 * Local variables:
1660 * c-basic-offset: 4
1661 * End:
1662 */
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-11 11:24:43 -0500