2 * Driver for NeoMagic 256AV and 256ZX chipsets.
3 * Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>
5 * Based on nm256_audio.c OSS driver in linux kernel.
6 * The original author of OSS nm256 driver wishes to remain anonymous,
7 * so I just put my acknoledgment to him/her here.
8 * The original author's web page is found at
9 * http://www.uglx.org/sony.html
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <sound/driver.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/init.h>
32 #include <linux/pci.h>
33 #include <linux/slab.h>
34 #include <linux/moduleparam.h>
35 #include <sound/core.h>
36 #include <sound/info.h>
37 #include <sound/control.h>
38 #include <sound/pcm.h>
39 #include <sound/ac97_codec.h>
40 #include <sound/initval.h>
42 #define CARD_NAME "NeoMagic 256AV/ZX"
43 #define DRIVER_NAME "NM256"
45 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
46 MODULE_DESCRIPTION("NeoMagic NM256AV/ZX");
47 MODULE_LICENSE("GPL");
48 MODULE_SUPPORTED_DEVICE("{{NeoMagic,NM256AV},"
49 "{NeoMagic,NM256ZX}}");
52 * some compile conditions.
55 static int index
= SNDRV_DEFAULT_IDX1
; /* Index */
56 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
57 static int playback_bufsize
= 16;
58 static int capture_bufsize
= 16;
59 static int force_ac97
; /* disabled as default */
60 static int buffer_top
; /* not specified */
61 static int use_cache
; /* disabled */
62 static int vaio_hack
; /* disabled */
63 static int reset_workaround
;
64 static int reset_workaround_2
;
66 module_param(index
, int, 0444);
67 MODULE_PARM_DESC(index
, "Index value for " CARD_NAME
" soundcard.");
68 module_param(id
, charp
, 0444);
69 MODULE_PARM_DESC(id
, "ID string for " CARD_NAME
" soundcard.");
70 module_param(playback_bufsize
, int, 0444);
71 MODULE_PARM_DESC(playback_bufsize
, "DAC frame size in kB for " CARD_NAME
" soundcard.");
72 module_param(capture_bufsize
, int, 0444);
73 MODULE_PARM_DESC(capture_bufsize
, "ADC frame size in kB for " CARD_NAME
" soundcard.");
74 module_param(force_ac97
, bool, 0444);
75 MODULE_PARM_DESC(force_ac97
, "Force to use AC97 codec for " CARD_NAME
" soundcard.");
76 module_param(buffer_top
, int, 0444);
77 MODULE_PARM_DESC(buffer_top
, "Set the top address of audio buffer for " CARD_NAME
" soundcard.");
78 module_param(use_cache
, bool, 0444);
79 MODULE_PARM_DESC(use_cache
, "Enable the cache for coefficient table access.");
80 module_param(vaio_hack
, bool, 0444);
81 MODULE_PARM_DESC(vaio_hack
, "Enable workaround for Sony VAIO notebooks.");
82 module_param(reset_workaround
, bool, 0444);
83 MODULE_PARM_DESC(reset_workaround
, "Enable AC97 RESET workaround for some laptops.");
84 module_param(reset_workaround_2
, bool, 0444);
85 MODULE_PARM_DESC(reset_workaround_2
, "Enable extended AC97 RESET workaround for some other laptops.");
87 /* just for backward compatibility */
89 module_param(enable
, bool, 0444);
97 /* The BIOS signature. */
98 #define NM_SIGNATURE 0x4e4d0000
100 #define NM_SIG_MASK 0xffff0000
102 /* Size of the second memory area. */
103 #define NM_PORT2_SIZE 4096
105 /* The base offset of the mixer in the second memory area. */
106 #define NM_MIXER_OFFSET 0x600
108 /* The maximum size of a coefficient entry. */
109 #define NM_MAX_PLAYBACK_COEF_SIZE 0x5000
110 #define NM_MAX_RECORD_COEF_SIZE 0x1260
112 /* The interrupt register. */
113 #define NM_INT_REG 0xa04
115 #define NM_PLAYBACK_INT 0x40
116 #define NM_RECORD_INT 0x100
117 #define NM_MISC_INT_1 0x4000
118 #define NM_MISC_INT_2 0x1
119 #define NM_ACK_INT(chip, X) snd_nm256_writew(chip, NM_INT_REG, (X) << 1)
121 /* The AV's "mixer ready" status bit and location. */
122 #define NM_MIXER_STATUS_OFFSET 0xa04
123 #define NM_MIXER_READY_MASK 0x0800
124 #define NM_MIXER_PRESENCE 0xa06
125 #define NM_PRESENCE_MASK 0x0050
126 #define NM_PRESENCE_VALUE 0x0040
129 * For the ZX. It uses the same interrupt register, but it holds 32
130 * bits instead of 16.
132 #define NM2_PLAYBACK_INT 0x10000
133 #define NM2_RECORD_INT 0x80000
134 #define NM2_MISC_INT_1 0x8
135 #define NM2_MISC_INT_2 0x2
136 #define NM2_ACK_INT(chip, X) snd_nm256_writel(chip, NM_INT_REG, (X))
138 /* The ZX's "mixer ready" status bit and location. */
139 #define NM2_MIXER_STATUS_OFFSET 0xa06
140 #define NM2_MIXER_READY_MASK 0x0800
142 /* The playback registers start from here. */
143 #define NM_PLAYBACK_REG_OFFSET 0x0
144 /* The record registers start from here. */
145 #define NM_RECORD_REG_OFFSET 0x200
147 /* The rate register is located 2 bytes from the start of the register area. */
148 #define NM_RATE_REG_OFFSET 2
150 /* Mono/stereo flag, number of bits on playback, and rate mask. */
151 #define NM_RATE_STEREO 1
152 #define NM_RATE_BITS_16 2
153 #define NM_RATE_MASK 0xf0
155 /* Playback enable register. */
156 #define NM_PLAYBACK_ENABLE_REG (NM_PLAYBACK_REG_OFFSET + 0x1)
157 #define NM_PLAYBACK_ENABLE_FLAG 1
158 #define NM_PLAYBACK_ONESHOT 2
159 #define NM_PLAYBACK_FREERUN 4
161 /* Mutes the audio output. */
162 #define NM_AUDIO_MUTE_REG (NM_PLAYBACK_REG_OFFSET + 0x18)
163 #define NM_AUDIO_MUTE_LEFT 0x8000
164 #define NM_AUDIO_MUTE_RIGHT 0x0080
166 /* Recording enable register. */
167 #define NM_RECORD_ENABLE_REG (NM_RECORD_REG_OFFSET + 0)
168 #define NM_RECORD_ENABLE_FLAG 1
169 #define NM_RECORD_FREERUN 2
171 /* coefficient buffer pointer */
172 #define NM_COEFF_START_OFFSET 0x1c
173 #define NM_COEFF_END_OFFSET 0x20
175 /* DMA buffer offsets */
176 #define NM_RBUFFER_START (NM_RECORD_REG_OFFSET + 0x4)
177 #define NM_RBUFFER_END (NM_RECORD_REG_OFFSET + 0x10)
178 #define NM_RBUFFER_WMARK (NM_RECORD_REG_OFFSET + 0xc)
179 #define NM_RBUFFER_CURRP (NM_RECORD_REG_OFFSET + 0x8)
181 #define NM_PBUFFER_START (NM_PLAYBACK_REG_OFFSET + 0x4)
182 #define NM_PBUFFER_END (NM_PLAYBACK_REG_OFFSET + 0x14)
183 #define NM_PBUFFER_WMARK (NM_PLAYBACK_REG_OFFSET + 0xc)
184 #define NM_PBUFFER_CURRP (NM_PLAYBACK_REG_OFFSET + 0x8)
186 struct nm256_stream
{
189 struct snd_pcm_substream
*substream
;
193 u32 buf
; /* offset from chip->buffer */
194 int bufsize
; /* buffer size in bytes */
195 void __iomem
*bufptr
; /* mapped pointer */
196 unsigned long bufptr_addr
; /* physical address of the mapped pointer */
198 int dma_size
; /* buffer size of the substream in bytes */
199 int period_size
; /* period size in bytes */
200 int periods
; /* # of periods */
201 int shift
; /* bit shifts */
202 int cur_period
; /* current period # */
208 struct snd_card
*card
;
210 void __iomem
*cport
; /* control port */
211 struct resource
*res_cport
; /* its resource */
212 unsigned long cport_addr
; /* physical address */
214 void __iomem
*buffer
; /* buffer */
215 struct resource
*res_buffer
; /* its resource */
216 unsigned long buffer_addr
; /* buffer phyiscal address */
218 u32 buffer_start
; /* start offset from pci resource 0 */
219 u32 buffer_end
; /* end offset */
220 u32 buffer_size
; /* total buffer size */
222 u32 all_coeff_buf
; /* coefficient buffer */
223 u32 coeff_buf
[2]; /* coefficient buffer for each stream */
225 unsigned int coeffs_current
: 1; /* coeff. table is loaded? */
226 unsigned int use_cache
: 1; /* use one big coef. table */
227 unsigned int reset_workaround
: 1; /* Workaround for some laptops to avoid freeze */
228 unsigned int reset_workaround_2
: 1; /* Extended workaround for some other laptops to avoid freeze */
230 int mixer_base
; /* register offset of ac97 mixer */
231 int mixer_status_offset
; /* offset of mixer status reg. */
232 int mixer_status_mask
; /* bit mask to test the mixer status */
236 irqreturn_t (*interrupt
)(int, void *, struct pt_regs
*);
237 int badintrcount
; /* counter to check bogus interrupts */
238 struct semaphore irq_mutex
;
240 struct nm256_stream streams
[2];
242 struct snd_ac97
*ac97
;
254 * include coefficient table
256 #include "nm256_coef.c"
262 static struct pci_device_id snd_nm256_ids
[] = {
263 {PCI_VENDOR_ID_NEOMAGIC
, PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
264 {PCI_VENDOR_ID_NEOMAGIC
, PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
265 {PCI_VENDOR_ID_NEOMAGIC
, PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
269 MODULE_DEVICE_TABLE(pci
, snd_nm256_ids
);
277 snd_nm256_readb(struct nm256
*chip
, int offset
)
279 return readb(chip
->cport
+ offset
);
283 snd_nm256_readw(struct nm256
*chip
, int offset
)
285 return readw(chip
->cport
+ offset
);
289 snd_nm256_readl(struct nm256
*chip
, int offset
)
291 return readl(chip
->cport
+ offset
);
295 snd_nm256_writeb(struct nm256
*chip
, int offset
, u8 val
)
297 writeb(val
, chip
->cport
+ offset
);
301 snd_nm256_writew(struct nm256
*chip
, int offset
, u16 val
)
303 writew(val
, chip
->cport
+ offset
);
307 snd_nm256_writel(struct nm256
*chip
, int offset
, u32 val
)
309 writel(val
, chip
->cport
+ offset
);
313 snd_nm256_write_buffer(struct nm256
*chip
, void *src
, int offset
, int size
)
315 offset
-= chip
->buffer_start
;
316 #ifdef CONFIG_SND_DEBUG
317 if (offset
< 0 || offset
>= chip
->buffer_size
) {
318 snd_printk(KERN_ERR
"write_buffer invalid offset = %d size = %d\n",
323 memcpy_toio(chip
->buffer
+ offset
, src
, size
);
327 * coefficient handlers -- what a magic!
331 snd_nm256_get_start_offset(int which
)
335 offset
+= coefficient_sizes
[which
];
340 snd_nm256_load_one_coefficient(struct nm256
*chip
, int stream
, u32 port
, int which
)
342 u32 coeff_buf
= chip
->coeff_buf
[stream
];
343 u16 offset
= snd_nm256_get_start_offset(which
);
344 u16 size
= coefficient_sizes
[which
];
346 snd_nm256_write_buffer(chip
, coefficients
+ offset
, coeff_buf
, size
);
347 snd_nm256_writel(chip
, port
, coeff_buf
);
348 /* ??? Record seems to behave differently than playback. */
349 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
351 snd_nm256_writel(chip
, port
+ 4, coeff_buf
+ size
);
355 snd_nm256_load_coefficient(struct nm256
*chip
, int stream
, int number
)
357 /* The enable register for the specified engine. */
358 u32 poffset
= (stream
== SNDRV_PCM_STREAM_CAPTURE
?
359 NM_RECORD_ENABLE_REG
: NM_PLAYBACK_ENABLE_REG
);
360 u32 addr
= NM_COEFF_START_OFFSET
;
362 addr
+= (stream
== SNDRV_PCM_STREAM_CAPTURE
?
363 NM_RECORD_REG_OFFSET
: NM_PLAYBACK_REG_OFFSET
);
365 if (snd_nm256_readb(chip
, poffset
) & 1) {
366 snd_printd("NM256: Engine was enabled while loading coefficients!\n");
370 /* The recording engine uses coefficient values 8-15. */
372 if (stream
== SNDRV_PCM_STREAM_CAPTURE
)
375 if (! chip
->use_cache
) {
376 snd_nm256_load_one_coefficient(chip
, stream
, addr
, number
);
379 if (! chip
->coeffs_current
) {
380 snd_nm256_write_buffer(chip
, coefficients
, chip
->all_coeff_buf
,
381 NM_TOTAL_COEFF_COUNT
* 4);
382 chip
->coeffs_current
= 1;
384 u32 base
= chip
->all_coeff_buf
;
385 u32 offset
= snd_nm256_get_start_offset(number
);
386 u32 end_offset
= offset
+ coefficient_sizes
[number
];
387 snd_nm256_writel(chip
, addr
, base
+ offset
);
388 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
390 snd_nm256_writel(chip
, addr
+ 4, base
+ end_offset
);
395 /* The actual rates supported by the card. */
396 static unsigned int samplerates
[8] = {
397 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000,
399 static struct snd_pcm_hw_constraint_list constraints_rates
= {
400 .count
= ARRAY_SIZE(samplerates
),
406 * return the index of the target rate
409 snd_nm256_fixed_rate(unsigned int rate
)
412 for (i
= 0; i
< ARRAY_SIZE(samplerates
); i
++) {
413 if (rate
== samplerates
[i
])
421 * set sample rate and format
424 snd_nm256_set_format(struct nm256
*chip
, struct nm256_stream
*s
,
425 struct snd_pcm_substream
*substream
)
427 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
428 int rate_index
= snd_nm256_fixed_rate(runtime
->rate
);
429 unsigned char ratebits
= (rate_index
<< 4) & NM_RATE_MASK
;
432 if (snd_pcm_format_width(runtime
->format
) == 16) {
433 ratebits
|= NM_RATE_BITS_16
;
436 if (runtime
->channels
> 1) {
437 ratebits
|= NM_RATE_STEREO
;
441 runtime
->rate
= samplerates
[rate_index
];
443 switch (substream
->stream
) {
444 case SNDRV_PCM_STREAM_PLAYBACK
:
445 snd_nm256_load_coefficient(chip
, 0, rate_index
); /* 0 = playback */
446 snd_nm256_writeb(chip
,
447 NM_PLAYBACK_REG_OFFSET
+ NM_RATE_REG_OFFSET
,
450 case SNDRV_PCM_STREAM_CAPTURE
:
451 snd_nm256_load_coefficient(chip
, 1, rate_index
); /* 1 = record */
452 snd_nm256_writeb(chip
,
453 NM_RECORD_REG_OFFSET
+ NM_RATE_REG_OFFSET
,
459 /* acquire interrupt */
460 static int snd_nm256_acquire_irq(struct nm256
*chip
)
462 down(&chip
->irq_mutex
);
464 if (request_irq(chip
->pci
->irq
, chip
->interrupt
, SA_INTERRUPT
|SA_SHIRQ
,
465 chip
->card
->driver
, chip
)) {
466 snd_printk(KERN_ERR
"unable to grab IRQ %d\n", chip
->pci
->irq
);
467 up(&chip
->irq_mutex
);
470 chip
->irq
= chip
->pci
->irq
;
473 up(&chip
->irq_mutex
);
477 /* release interrupt */
478 static void snd_nm256_release_irq(struct nm256
*chip
)
480 down(&chip
->irq_mutex
);
481 if (chip
->irq_acks
> 0)
483 if (chip
->irq_acks
== 0 && chip
->irq
>= 0) {
484 free_irq(chip
->irq
, chip
);
487 up(&chip
->irq_mutex
);
494 /* update the watermark (current period) */
495 static void snd_nm256_pcm_mark(struct nm256
*chip
, struct nm256_stream
*s
, int reg
)
498 s
->cur_period
%= s
->periods
;
499 snd_nm256_writel(chip
, reg
, s
->buf
+ s
->cur_period
* s
->period_size
);
502 #define snd_nm256_playback_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_PBUFFER_WMARK)
503 #define snd_nm256_capture_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_RBUFFER_WMARK)
506 snd_nm256_playback_start(struct nm256
*chip
, struct nm256_stream
*s
,
507 struct snd_pcm_substream
*substream
)
509 /* program buffer pointers */
510 snd_nm256_writel(chip
, NM_PBUFFER_START
, s
->buf
);
511 snd_nm256_writel(chip
, NM_PBUFFER_END
, s
->buf
+ s
->dma_size
- (1 << s
->shift
));
512 snd_nm256_writel(chip
, NM_PBUFFER_CURRP
, s
->buf
);
513 snd_nm256_playback_mark(chip
, s
);
515 /* Enable playback engine and interrupts. */
516 snd_nm256_writeb(chip
, NM_PLAYBACK_ENABLE_REG
,
517 NM_PLAYBACK_ENABLE_FLAG
| NM_PLAYBACK_FREERUN
);
518 /* Enable both channels. */
519 snd_nm256_writew(chip
, NM_AUDIO_MUTE_REG
, 0x0);
523 snd_nm256_capture_start(struct nm256
*chip
, struct nm256_stream
*s
,
524 struct snd_pcm_substream
*substream
)
526 /* program buffer pointers */
527 snd_nm256_writel(chip
, NM_RBUFFER_START
, s
->buf
);
528 snd_nm256_writel(chip
, NM_RBUFFER_END
, s
->buf
+ s
->dma_size
);
529 snd_nm256_writel(chip
, NM_RBUFFER_CURRP
, s
->buf
);
530 snd_nm256_capture_mark(chip
, s
);
532 /* Enable playback engine and interrupts. */
533 snd_nm256_writeb(chip
, NM_RECORD_ENABLE_REG
,
534 NM_RECORD_ENABLE_FLAG
| NM_RECORD_FREERUN
);
537 /* Stop the play engine. */
539 snd_nm256_playback_stop(struct nm256
*chip
)
541 /* Shut off sound from both channels. */
542 snd_nm256_writew(chip
, NM_AUDIO_MUTE_REG
,
543 NM_AUDIO_MUTE_LEFT
| NM_AUDIO_MUTE_RIGHT
);
544 /* Disable play engine. */
545 snd_nm256_writeb(chip
, NM_PLAYBACK_ENABLE_REG
, 0);
549 snd_nm256_capture_stop(struct nm256
*chip
)
551 /* Disable recording engine. */
552 snd_nm256_writeb(chip
, NM_RECORD_ENABLE_REG
, 0);
556 snd_nm256_playback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
558 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
559 struct nm256_stream
*s
= substream
->runtime
->private_data
;
562 snd_assert(s
!= NULL
, return -ENXIO
);
564 spin_lock(&chip
->reg_lock
);
566 case SNDRV_PCM_TRIGGER_RESUME
:
569 case SNDRV_PCM_TRIGGER_START
:
571 snd_nm256_playback_start(chip
, s
, substream
);
575 case SNDRV_PCM_TRIGGER_SUSPEND
:
578 case SNDRV_PCM_TRIGGER_STOP
:
580 snd_nm256_playback_stop(chip
);
588 spin_unlock(&chip
->reg_lock
);
593 snd_nm256_capture_trigger(struct snd_pcm_substream
*substream
, int cmd
)
595 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
596 struct nm256_stream
*s
= substream
->runtime
->private_data
;
599 snd_assert(s
!= NULL
, return -ENXIO
);
601 spin_lock(&chip
->reg_lock
);
603 case SNDRV_PCM_TRIGGER_START
:
604 case SNDRV_PCM_TRIGGER_RESUME
:
606 snd_nm256_capture_start(chip
, s
, substream
);
610 case SNDRV_PCM_TRIGGER_STOP
:
611 case SNDRV_PCM_TRIGGER_SUSPEND
:
613 snd_nm256_capture_stop(chip
);
621 spin_unlock(&chip
->reg_lock
);
627 * prepare playback/capture channel
629 static int snd_nm256_pcm_prepare(struct snd_pcm_substream
*substream
)
631 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
632 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
633 struct nm256_stream
*s
= runtime
->private_data
;
635 snd_assert(s
, return -ENXIO
);
636 s
->dma_size
= frames_to_bytes(runtime
, substream
->runtime
->buffer_size
);
637 s
->period_size
= frames_to_bytes(runtime
, substream
->runtime
->period_size
);
638 s
->periods
= substream
->runtime
->periods
;
641 spin_lock_irq(&chip
->reg_lock
);
643 snd_nm256_set_format(chip
, s
, substream
);
644 spin_unlock_irq(&chip
->reg_lock
);
651 * get the current pointer
653 static snd_pcm_uframes_t
654 snd_nm256_playback_pointer(struct snd_pcm_substream
*substream
)
656 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
657 struct nm256_stream
*s
= substream
->runtime
->private_data
;
660 snd_assert(s
, return 0);
661 curp
= snd_nm256_readl(chip
, NM_PBUFFER_CURRP
) - (unsigned long)s
->buf
;
663 return bytes_to_frames(substream
->runtime
, curp
);
666 static snd_pcm_uframes_t
667 snd_nm256_capture_pointer(struct snd_pcm_substream
*substream
)
669 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
670 struct nm256_stream
*s
= substream
->runtime
->private_data
;
673 snd_assert(s
!= NULL
, return 0);
674 curp
= snd_nm256_readl(chip
, NM_RBUFFER_CURRP
) - (unsigned long)s
->buf
;
676 return bytes_to_frames(substream
->runtime
, curp
);
679 /* Remapped I/O space can be accessible as pointer on i386 */
680 /* This might be changed in the future */
683 * silence / copy for playback
686 snd_nm256_playback_silence(struct snd_pcm_substream
*substream
,
687 int channel
, /* not used (interleaved data) */
688 snd_pcm_uframes_t pos
,
689 snd_pcm_uframes_t count
)
691 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
692 struct nm256_stream
*s
= runtime
->private_data
;
693 count
= frames_to_bytes(runtime
, count
);
694 pos
= frames_to_bytes(runtime
, pos
);
695 memset_io(s
->bufptr
+ pos
, 0, count
);
700 snd_nm256_playback_copy(struct snd_pcm_substream
*substream
,
701 int channel
, /* not used (interleaved data) */
702 snd_pcm_uframes_t pos
,
704 snd_pcm_uframes_t count
)
706 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
707 struct nm256_stream
*s
= runtime
->private_data
;
708 count
= frames_to_bytes(runtime
, count
);
709 pos
= frames_to_bytes(runtime
, pos
);
710 if (copy_from_user_toio(s
->bufptr
+ pos
, src
, count
))
719 snd_nm256_capture_copy(struct snd_pcm_substream
*substream
,
720 int channel
, /* not used (interleaved data) */
721 snd_pcm_uframes_t pos
,
723 snd_pcm_uframes_t count
)
725 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
726 struct nm256_stream
*s
= runtime
->private_data
;
727 count
= frames_to_bytes(runtime
, count
);
728 pos
= frames_to_bytes(runtime
, pos
);
729 if (copy_to_user_fromio(dst
, s
->bufptr
+ pos
, count
))
734 #endif /* !__i386__ */
738 * update playback/capture watermarks
743 snd_nm256_playback_update(struct nm256
*chip
)
745 struct nm256_stream
*s
;
747 s
= &chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
];
748 if (s
->running
&& s
->substream
) {
749 spin_unlock(&chip
->reg_lock
);
750 snd_pcm_period_elapsed(s
->substream
);
751 spin_lock(&chip
->reg_lock
);
752 snd_nm256_playback_mark(chip
, s
);
758 snd_nm256_capture_update(struct nm256
*chip
)
760 struct nm256_stream
*s
;
762 s
= &chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
];
763 if (s
->running
&& s
->substream
) {
764 spin_unlock(&chip
->reg_lock
);
765 snd_pcm_period_elapsed(s
->substream
);
766 spin_lock(&chip
->reg_lock
);
767 snd_nm256_capture_mark(chip
, s
);
774 static struct snd_pcm_hardware snd_nm256_playback
=
776 .info
= SNDRV_PCM_INFO_MMAP_IOMEM
|SNDRV_PCM_INFO_MMAP_VALID
|
777 SNDRV_PCM_INFO_INTERLEAVED
|
778 /*SNDRV_PCM_INFO_PAUSE |*/
779 SNDRV_PCM_INFO_RESUME
,
780 .formats
= SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
,
781 .rates
= SNDRV_PCM_RATE_KNOT
/*24k*/ | SNDRV_PCM_RATE_8000_48000
,
788 .buffer_bytes_max
= 128 * 1024,
789 .period_bytes_min
= 256,
790 .period_bytes_max
= 128 * 1024,
793 static struct snd_pcm_hardware snd_nm256_capture
=
795 .info
= SNDRV_PCM_INFO_MMAP_IOMEM
| SNDRV_PCM_INFO_MMAP_VALID
|
796 SNDRV_PCM_INFO_INTERLEAVED
|
797 /*SNDRV_PCM_INFO_PAUSE |*/
798 SNDRV_PCM_INFO_RESUME
,
799 .formats
= SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
,
800 .rates
= SNDRV_PCM_RATE_KNOT
/*24k*/ | SNDRV_PCM_RATE_8000_48000
,
807 .buffer_bytes_max
= 128 * 1024,
808 .period_bytes_min
= 256,
809 .period_bytes_max
= 128 * 1024,
813 /* set dma transfer size */
814 static int snd_nm256_pcm_hw_params(struct snd_pcm_substream
*substream
,
815 struct snd_pcm_hw_params
*hw_params
)
817 /* area and addr are already set and unchanged */
818 substream
->runtime
->dma_bytes
= params_buffer_bytes(hw_params
);
825 static void snd_nm256_setup_stream(struct nm256
*chip
, struct nm256_stream
*s
,
826 struct snd_pcm_substream
*substream
,
827 struct snd_pcm_hardware
*hw_ptr
)
829 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
832 runtime
->hw
= *hw_ptr
;
833 runtime
->hw
.buffer_bytes_max
= s
->bufsize
;
834 runtime
->hw
.period_bytes_max
= s
->bufsize
/ 2;
835 runtime
->dma_area
= (void __force
*) s
->bufptr
;
836 runtime
->dma_addr
= s
->bufptr_addr
;
837 runtime
->dma_bytes
= s
->bufsize
;
838 runtime
->private_data
= s
;
839 s
->substream
= substream
;
841 snd_pcm_set_sync(substream
);
842 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
847 snd_nm256_playback_open(struct snd_pcm_substream
*substream
)
849 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
851 if (snd_nm256_acquire_irq(chip
) < 0)
853 snd_nm256_setup_stream(chip
, &chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
],
854 substream
, &snd_nm256_playback
);
859 snd_nm256_capture_open(struct snd_pcm_substream
*substream
)
861 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
863 if (snd_nm256_acquire_irq(chip
) < 0)
865 snd_nm256_setup_stream(chip
, &chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
],
866 substream
, &snd_nm256_capture
);
871 * close - we don't have to do special..
874 snd_nm256_playback_close(struct snd_pcm_substream
*substream
)
876 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
878 snd_nm256_release_irq(chip
);
884 snd_nm256_capture_close(struct snd_pcm_substream
*substream
)
886 struct nm256
*chip
= snd_pcm_substream_chip(substream
);
888 snd_nm256_release_irq(chip
);
893 * create a pcm instance
895 static struct snd_pcm_ops snd_nm256_playback_ops
= {
896 .open
= snd_nm256_playback_open
,
897 .close
= snd_nm256_playback_close
,
898 .ioctl
= snd_pcm_lib_ioctl
,
899 .hw_params
= snd_nm256_pcm_hw_params
,
900 .prepare
= snd_nm256_pcm_prepare
,
901 .trigger
= snd_nm256_playback_trigger
,
902 .pointer
= snd_nm256_playback_pointer
,
904 .copy
= snd_nm256_playback_copy
,
905 .silence
= snd_nm256_playback_silence
,
907 .mmap
= snd_pcm_lib_mmap_iomem
,
910 static struct snd_pcm_ops snd_nm256_capture_ops
= {
911 .open
= snd_nm256_capture_open
,
912 .close
= snd_nm256_capture_close
,
913 .ioctl
= snd_pcm_lib_ioctl
,
914 .hw_params
= snd_nm256_pcm_hw_params
,
915 .prepare
= snd_nm256_pcm_prepare
,
916 .trigger
= snd_nm256_capture_trigger
,
917 .pointer
= snd_nm256_capture_pointer
,
919 .copy
= snd_nm256_capture_copy
,
921 .mmap
= snd_pcm_lib_mmap_iomem
,
925 snd_nm256_pcm(struct nm256
*chip
, int device
)
930 for (i
= 0; i
< 2; i
++) {
931 struct nm256_stream
*s
= &chip
->streams
[i
];
932 s
->bufptr
= chip
->buffer
+ (s
->buf
- chip
->buffer_start
);
933 s
->bufptr_addr
= chip
->buffer_addr
+ (s
->buf
- chip
->buffer_start
);
936 err
= snd_pcm_new(chip
->card
, chip
->card
->driver
, device
,
941 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_nm256_playback_ops
);
942 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_nm256_capture_ops
);
944 pcm
->private_data
= chip
;
953 * Initialize the hardware.
956 snd_nm256_init_chip(struct nm256
*chip
)
958 /* Reset everything. */
959 snd_nm256_writeb(chip
, 0x0, 0x11);
960 snd_nm256_writew(chip
, 0x214, 0);
962 //snd_nm256_playback_stop(chip);
963 //snd_nm256_capture_stop(chip);
968 snd_nm256_intr_check(struct nm256
*chip
)
970 if (chip
->badintrcount
++ > 1000) {
972 * I'm not sure if the best thing is to stop the card from
973 * playing or just release the interrupt (after all, we're in
974 * a bad situation, so doing fancy stuff may not be such a good
977 * I worry about the card engine continuing to play noise
978 * over and over, however--that could become a very
979 * obnoxious problem. And we know that when this usually
980 * happens things are fairly safe, it just means the user's
981 * inserted a PCMCIA card and someone's spamming us with IRQ 9s.
983 if (chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].running
)
984 snd_nm256_playback_stop(chip
);
985 if (chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].running
)
986 snd_nm256_capture_stop(chip
);
987 chip
->badintrcount
= 0;
994 * Handle a potential interrupt for the device referred to by DEV_ID.
996 * I don't like the cut-n-paste job here either between the two routines,
997 * but there are sufficient differences between the two interrupt handlers
998 * that parameterizing it isn't all that great either. (Could use a macro,
999 * I suppose...yucky bleah.)
1003 snd_nm256_interrupt(int irq
, void *dev_id
, struct pt_regs
*dummy
)
1005 struct nm256
*chip
= dev_id
;
1009 status
= snd_nm256_readw(chip
, NM_INT_REG
);
1013 return snd_nm256_intr_check(chip
);
1015 chip
->badintrcount
= 0;
1017 /* Rather boring; check for individual interrupts and process them. */
1019 spin_lock(&chip
->reg_lock
);
1020 if (status
& NM_PLAYBACK_INT
) {
1021 status
&= ~NM_PLAYBACK_INT
;
1022 NM_ACK_INT(chip
, NM_PLAYBACK_INT
);
1023 snd_nm256_playback_update(chip
);
1026 if (status
& NM_RECORD_INT
) {
1027 status
&= ~NM_RECORD_INT
;
1028 NM_ACK_INT(chip
, NM_RECORD_INT
);
1029 snd_nm256_capture_update(chip
);
1032 if (status
& NM_MISC_INT_1
) {
1033 status
&= ~NM_MISC_INT_1
;
1034 NM_ACK_INT(chip
, NM_MISC_INT_1
);
1035 snd_printd("NM256: Got misc interrupt #1\n");
1036 snd_nm256_writew(chip
, NM_INT_REG
, 0x8000);
1037 cbyte
= snd_nm256_readb(chip
, 0x400);
1038 snd_nm256_writeb(chip
, 0x400, cbyte
| 2);
1041 if (status
& NM_MISC_INT_2
) {
1042 status
&= ~NM_MISC_INT_2
;
1043 NM_ACK_INT(chip
, NM_MISC_INT_2
);
1044 snd_printd("NM256: Got misc interrupt #2\n");
1045 cbyte
= snd_nm256_readb(chip
, 0x400);
1046 snd_nm256_writeb(chip
, 0x400, cbyte
& ~2);
1049 /* Unknown interrupt. */
1051 snd_printd("NM256: Fire in the hole! Unknown status 0x%x\n",
1054 NM_ACK_INT(chip
, status
);
1057 spin_unlock(&chip
->reg_lock
);
1062 * Handle a potential interrupt for the device referred to by DEV_ID.
1063 * This handler is for the 256ZX, and is very similar to the non-ZX
1068 snd_nm256_interrupt_zx(int irq
, void *dev_id
, struct pt_regs
*dummy
)
1070 struct nm256
*chip
= dev_id
;
1074 status
= snd_nm256_readl(chip
, NM_INT_REG
);
1078 return snd_nm256_intr_check(chip
);
1080 chip
->badintrcount
= 0;
1082 /* Rather boring; check for individual interrupts and process them. */
1084 spin_lock(&chip
->reg_lock
);
1085 if (status
& NM2_PLAYBACK_INT
) {
1086 status
&= ~NM2_PLAYBACK_INT
;
1087 NM2_ACK_INT(chip
, NM2_PLAYBACK_INT
);
1088 snd_nm256_playback_update(chip
);
1091 if (status
& NM2_RECORD_INT
) {
1092 status
&= ~NM2_RECORD_INT
;
1093 NM2_ACK_INT(chip
, NM2_RECORD_INT
);
1094 snd_nm256_capture_update(chip
);
1097 if (status
& NM2_MISC_INT_1
) {
1098 status
&= ~NM2_MISC_INT_1
;
1099 NM2_ACK_INT(chip
, NM2_MISC_INT_1
);
1100 snd_printd("NM256: Got misc interrupt #1\n");
1101 cbyte
= snd_nm256_readb(chip
, 0x400);
1102 snd_nm256_writeb(chip
, 0x400, cbyte
| 2);
1105 if (status
& NM2_MISC_INT_2
) {
1106 status
&= ~NM2_MISC_INT_2
;
1107 NM2_ACK_INT(chip
, NM2_MISC_INT_2
);
1108 snd_printd("NM256: Got misc interrupt #2\n");
1109 cbyte
= snd_nm256_readb(chip
, 0x400);
1110 snd_nm256_writeb(chip
, 0x400, cbyte
& ~2);
1113 /* Unknown interrupt. */
1115 snd_printd("NM256: Fire in the hole! Unknown status 0x%x\n",
1118 NM2_ACK_INT(chip
, status
);
1121 spin_unlock(&chip
->reg_lock
);
1130 * Waits for the mixer to become ready to be written; returns a zero value
1134 snd_nm256_ac97_ready(struct nm256
*chip
)
1140 testaddr
= chip
->mixer_status_offset
;
1141 testb
= chip
->mixer_status_mask
;
1144 * Loop around waiting for the mixer to become ready.
1146 while (timeout
-- > 0) {
1147 if ((snd_nm256_readw(chip
, testaddr
) & testb
) == 0)
1156 static unsigned short
1157 snd_nm256_ac97_read(struct snd_ac97
*ac97
, unsigned short reg
)
1159 struct nm256
*chip
= ac97
->private_data
;
1165 if (! snd_nm256_ac97_ready(chip
))
1167 res
= snd_nm256_readw(chip
, chip
->mixer_base
+ reg
);
1168 /* Magic delay. Bleah yucky. */
1176 snd_nm256_ac97_write(struct snd_ac97
*ac97
,
1177 unsigned short reg
, unsigned short val
)
1179 struct nm256
*chip
= ac97
->private_data
;
1183 base
= chip
->mixer_base
;
1185 snd_nm256_ac97_ready(chip
);
1187 /* Wait for the write to take, too. */
1188 while (tries
-- > 0) {
1189 snd_nm256_writew(chip
, base
+ reg
, val
);
1190 msleep(1); /* a little delay here seems better.. */
1191 if (snd_nm256_ac97_ready(chip
))
1194 snd_printd("nm256: ac97 codec not ready..\n");
1197 /* initialize the ac97 into a known state */
1199 snd_nm256_ac97_reset(struct snd_ac97
*ac97
)
1201 struct nm256
*chip
= ac97
->private_data
;
1203 /* Reset the mixer. 'Tis magic! */
1204 snd_nm256_writeb(chip
, 0x6c0, 1);
1205 if (! chip
->reset_workaround
) {
1206 /* Dell latitude LS will lock up by this */
1207 snd_nm256_writeb(chip
, 0x6cc, 0x87);
1209 if (! chip
->reset_workaround_2
) {
1210 /* Dell latitude CSx will lock up by this */
1211 snd_nm256_writeb(chip
, 0x6cc, 0x80);
1212 snd_nm256_writeb(chip
, 0x6cc, 0x0);
1216 /* create an ac97 mixer interface */
1217 static int __devinit
1218 snd_nm256_mixer(struct nm256
*chip
)
1220 struct snd_ac97_bus
*pbus
;
1221 struct snd_ac97_template ac97
;
1223 static struct snd_ac97_bus_ops ops
= {
1224 .reset
= snd_nm256_ac97_reset
,
1225 .write
= snd_nm256_ac97_write
,
1226 .read
= snd_nm256_ac97_read
,
1228 /* looks like nm256 hangs up when unexpected registers are touched... */
1229 static int mixer_regs
[] = {
1230 AC97_MASTER
, AC97_HEADPHONE
, AC97_MASTER_MONO
,
1231 AC97_PC_BEEP
, AC97_PHONE
, AC97_MIC
, AC97_LINE
, AC97_CD
,
1232 AC97_VIDEO
, AC97_AUX
, AC97_PCM
, AC97_REC_SEL
,
1233 AC97_REC_GAIN
, AC97_GENERAL_PURPOSE
, AC97_3D_CONTROL
,
1234 /*AC97_EXTENDED_ID,*/
1235 AC97_VENDOR_ID1
, AC97_VENDOR_ID2
,
1239 if ((err
= snd_ac97_bus(chip
->card
, 0, &ops
, NULL
, &pbus
)) < 0)
1242 memset(&ac97
, 0, sizeof(ac97
));
1243 ac97
.scaps
= AC97_SCAP_AUDIO
; /* we support audio! */
1244 ac97
.limited_regs
= 1;
1245 for (i
= 0; mixer_regs
[i
] >= 0; i
++)
1246 set_bit(mixer_regs
[i
], ac97
.reg_accessed
);
1247 ac97
.private_data
= chip
;
1249 err
= snd_ac97_mixer(pbus
, &ac97
, &chip
->ac97
);
1252 if (! (chip
->ac97
->id
& (0xf0000000))) {
1253 /* looks like an invalid id */
1254 sprintf(chip
->card
->mixername
, "%s AC97", chip
->card
->driver
);
1260 * See if the signature left by the NM256 BIOS is intact; if so, we use
1261 * the associated address as the end of our audio buffer in the video
1265 static int __devinit
1266 snd_nm256_peek_for_sig(struct nm256
*chip
)
1268 /* The signature is located 1K below the end of video RAM. */
1270 /* Default buffer end is 5120 bytes below the top of RAM. */
1271 unsigned long pointer_found
= chip
->buffer_end
- 0x1400;
1274 temp
= ioremap_nocache(chip
->buffer_addr
+ chip
->buffer_end
- 0x400, 16);
1276 snd_printk(KERN_ERR
"Unable to scan for card signature in video RAM\n");
1281 if ((sig
& NM_SIG_MASK
) == NM_SIGNATURE
) {
1282 u32 pointer
= readl(temp
+ 4);
1285 * If it's obviously invalid, don't use it
1287 if (pointer
== 0xffffffff ||
1288 pointer
< chip
->buffer_size
||
1289 pointer
> chip
->buffer_end
) {
1290 snd_printk(KERN_ERR
"invalid signature found: 0x%x\n", pointer
);
1294 pointer_found
= pointer
;
1295 printk(KERN_INFO
"nm256: found card signature in video RAM: 0x%x\n",
1301 chip
->buffer_end
= pointer_found
;
1308 * APM event handler, so the card is properly reinitialized after a power
1311 static int nm256_suspend(struct pci_dev
*pci
, pm_message_t state
)
1313 struct snd_card
*card
= pci_get_drvdata(pci
);
1314 struct nm256
*chip
= card
->private_data
;
1316 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
1317 snd_pcm_suspend_all(chip
->pcm
);
1318 snd_ac97_suspend(chip
->ac97
);
1319 chip
->coeffs_current
= 0;
1320 pci_disable_device(pci
);
1321 pci_save_state(pci
);
1325 static int nm256_resume(struct pci_dev
*pci
)
1327 struct snd_card
*card
= pci_get_drvdata(pci
);
1328 struct nm256
*chip
= card
->private_data
;
1331 /* Perform a full reset on the hardware */
1332 pci_restore_state(pci
);
1333 pci_enable_device(pci
);
1334 snd_nm256_init_chip(chip
);
1337 snd_ac97_resume(chip
->ac97
);
1339 for (i
= 0; i
< 2; i
++) {
1340 struct nm256_stream
*s
= &chip
->streams
[i
];
1341 if (s
->substream
&& s
->suspended
) {
1342 spin_lock_irq(&chip
->reg_lock
);
1343 snd_nm256_set_format(chip
, s
, s
->substream
);
1344 spin_unlock_irq(&chip
->reg_lock
);
1348 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
1351 #endif /* CONFIG_PM */
1353 static int snd_nm256_free(struct nm256
*chip
)
1355 if (chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].running
)
1356 snd_nm256_playback_stop(chip
);
1357 if (chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].running
)
1358 snd_nm256_capture_stop(chip
);
1361 synchronize_irq(chip
->irq
);
1364 iounmap(chip
->cport
);
1366 iounmap(chip
->buffer
);
1367 release_and_free_resource(chip
->res_cport
);
1368 release_and_free_resource(chip
->res_buffer
);
1370 free_irq(chip
->irq
, chip
);
1372 pci_disable_device(chip
->pci
);
1377 static int snd_nm256_dev_free(struct snd_device
*device
)
1379 struct nm256
*chip
= device
->device_data
;
1380 return snd_nm256_free(chip
);
1383 static int __devinit
1384 snd_nm256_create(struct snd_card
*card
, struct pci_dev
*pci
,
1385 struct nm256
**chip_ret
)
1389 static struct snd_device_ops ops
= {
1390 .dev_free
= snd_nm256_dev_free
,
1396 if ((err
= pci_enable_device(pci
)) < 0)
1399 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1401 pci_disable_device(pci
);
1407 chip
->use_cache
= use_cache
;
1408 spin_lock_init(&chip
->reg_lock
);
1410 init_MUTEX(&chip
->irq_mutex
);
1412 /* store buffer sizes in bytes */
1413 chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].bufsize
= playback_bufsize
* 1024;
1414 chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].bufsize
= capture_bufsize
* 1024;
1417 * The NM256 has two memory ports. The first port is nothing
1418 * more than a chunk of video RAM, which is used as the I/O ring
1419 * buffer. The second port has the actual juicy stuff (like the
1420 * mixer and the playback engine control registers).
1423 chip
->buffer_addr
= pci_resource_start(pci
, 0);
1424 chip
->cport_addr
= pci_resource_start(pci
, 1);
1426 /* Init the memory port info. */
1427 /* remap control port (#2) */
1428 chip
->res_cport
= request_mem_region(chip
->cport_addr
, NM_PORT2_SIZE
,
1430 if (chip
->res_cport
== NULL
) {
1431 snd_printk(KERN_ERR
"memory region 0x%lx (size 0x%x) busy\n",
1432 chip
->cport_addr
, NM_PORT2_SIZE
);
1436 chip
->cport
= ioremap_nocache(chip
->cport_addr
, NM_PORT2_SIZE
);
1437 if (chip
->cport
== NULL
) {
1438 snd_printk(KERN_ERR
"unable to map control port %lx\n", chip
->cport_addr
);
1443 if (!strcmp(card
->driver
, "NM256AV")) {
1444 /* Ok, try to see if this is a non-AC97 version of the hardware. */
1445 pval
= snd_nm256_readw(chip
, NM_MIXER_PRESENCE
);
1446 if ((pval
& NM_PRESENCE_MASK
) != NM_PRESENCE_VALUE
) {
1448 printk(KERN_ERR
"nm256: no ac97 is found!\n");
1449 printk(KERN_ERR
" force the driver to load by "
1450 "passing in the module parameter\n");
1451 printk(KERN_ERR
" force_ac97=1\n");
1452 printk(KERN_ERR
" or try sb16 or cs423x drivers instead.\n");
1457 chip
->buffer_end
= 2560 * 1024;
1458 chip
->interrupt
= snd_nm256_interrupt
;
1459 chip
->mixer_status_offset
= NM_MIXER_STATUS_OFFSET
;
1460 chip
->mixer_status_mask
= NM_MIXER_READY_MASK
;
1462 /* Not sure if there is any relevant detect for the ZX or not. */
1463 if (snd_nm256_readb(chip
, 0xa0b) != 0)
1464 chip
->buffer_end
= 6144 * 1024;
1466 chip
->buffer_end
= 4096 * 1024;
1468 chip
->interrupt
= snd_nm256_interrupt_zx
;
1469 chip
->mixer_status_offset
= NM2_MIXER_STATUS_OFFSET
;
1470 chip
->mixer_status_mask
= NM2_MIXER_READY_MASK
;
1473 chip
->buffer_size
= chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].bufsize
+
1474 chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].bufsize
;
1475 if (chip
->use_cache
)
1476 chip
->buffer_size
+= NM_TOTAL_COEFF_COUNT
* 4;
1478 chip
->buffer_size
+= NM_MAX_PLAYBACK_COEF_SIZE
+ NM_MAX_RECORD_COEF_SIZE
;
1480 if (buffer_top
>= chip
->buffer_size
&& buffer_top
< chip
->buffer_end
)
1481 chip
->buffer_end
= buffer_top
;
1483 /* get buffer end pointer from signature */
1484 if ((err
= snd_nm256_peek_for_sig(chip
)) < 0)
1488 chip
->buffer_start
= chip
->buffer_end
- chip
->buffer_size
;
1489 chip
->buffer_addr
+= chip
->buffer_start
;
1491 printk(KERN_INFO
"nm256: Mapping port 1 from 0x%x - 0x%x\n",
1492 chip
->buffer_start
, chip
->buffer_end
);
1494 chip
->res_buffer
= request_mem_region(chip
->buffer_addr
,
1497 if (chip
->res_buffer
== NULL
) {
1498 snd_printk(KERN_ERR
"nm256: buffer 0x%lx (size 0x%x) busy\n",
1499 chip
->buffer_addr
, chip
->buffer_size
);
1503 chip
->buffer
= ioremap_nocache(chip
->buffer_addr
, chip
->buffer_size
);
1504 if (chip
->buffer
== NULL
) {
1506 snd_printk(KERN_ERR
"unable to map ring buffer at %lx\n", chip
->buffer_addr
);
1511 addr
= chip
->buffer_start
;
1512 chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].buf
= addr
;
1513 addr
+= chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].bufsize
;
1514 chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].buf
= addr
;
1515 addr
+= chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].bufsize
;
1516 if (chip
->use_cache
) {
1517 chip
->all_coeff_buf
= addr
;
1519 chip
->coeff_buf
[SNDRV_PCM_STREAM_PLAYBACK
] = addr
;
1520 addr
+= NM_MAX_PLAYBACK_COEF_SIZE
;
1521 chip
->coeff_buf
[SNDRV_PCM_STREAM_CAPTURE
] = addr
;
1524 /* Fixed setting. */
1525 chip
->mixer_base
= NM_MIXER_OFFSET
;
1527 chip
->coeffs_current
= 0;
1529 snd_nm256_init_chip(chip
);
1531 // pci_set_master(pci); /* needed? */
1533 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0)
1536 snd_card_set_dev(card
, &pci
->dev
);
1542 snd_nm256_free(chip
);
1547 struct nm256_quirk
{
1548 unsigned short vendor
;
1549 unsigned short device
;
1553 enum { NM_BLACKLISTED
, NM_RESET_WORKAROUND
, NM_RESET_WORKAROUND_2
};
1555 static struct nm256_quirk nm256_quirks
[] __devinitdata
= {
1556 /* HP omnibook 4150 has cs4232 codec internally */
1557 { .vendor
= 0x103c, .device
= 0x0007, .type
= NM_BLACKLISTED
},
1559 { .vendor
= 0x104d, .device
= 0x8041, .type
= NM_RESET_WORKAROUND
},
1560 /* Dell Latitude LS */
1561 { .vendor
= 0x1028, .device
= 0x0080, .type
= NM_RESET_WORKAROUND
},
1562 /* Dell Latitude CSx */
1563 { .vendor
= 0x1028, .device
= 0x0091, .type
= NM_RESET_WORKAROUND_2
},
1564 { } /* terminator */
1568 static int __devinit
snd_nm256_probe(struct pci_dev
*pci
,
1569 const struct pci_device_id
*pci_id
)
1571 struct snd_card
*card
;
1574 struct nm256_quirk
*q
;
1575 u16 subsystem_vendor
, subsystem_device
;
1577 pci_read_config_word(pci
, PCI_SUBSYSTEM_VENDOR_ID
, &subsystem_vendor
);
1578 pci_read_config_word(pci
, PCI_SUBSYSTEM_ID
, &subsystem_device
);
1580 for (q
= nm256_quirks
; q
->vendor
; q
++) {
1581 if (q
->vendor
== subsystem_vendor
&& q
->device
== subsystem_device
) {
1583 case NM_BLACKLISTED
:
1584 printk(KERN_INFO
"nm256: The device is blacklisted. "
1585 "Loading stopped\n");
1587 case NM_RESET_WORKAROUND_2
:
1588 reset_workaround_2
= 1;
1590 case NM_RESET_WORKAROUND
:
1591 reset_workaround
= 1;
1597 card
= snd_card_new(index
, id
, THIS_MODULE
, 0);
1601 switch (pci
->device
) {
1602 case PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO
:
1603 strcpy(card
->driver
, "NM256AV");
1605 case PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO
:
1606 strcpy(card
->driver
, "NM256ZX");
1608 case PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO
:
1609 strcpy(card
->driver
, "NM256XL+");
1612 snd_printk(KERN_ERR
"invalid device id 0x%x\n", pci
->device
);
1613 snd_card_free(card
);
1618 buffer_top
= 0x25a800; /* this avoids conflicts with XFree86 server */
1620 if (playback_bufsize
< 4)
1621 playback_bufsize
= 4;
1622 if (playback_bufsize
> 128)
1623 playback_bufsize
= 128;
1624 if (capture_bufsize
< 4)
1625 capture_bufsize
= 4;
1626 if (capture_bufsize
> 128)
1627 capture_bufsize
= 128;
1628 if ((err
= snd_nm256_create(card
, pci
, &chip
)) < 0) {
1629 snd_card_free(card
);
1632 card
->private_data
= chip
;
1634 if (reset_workaround
) {
1635 snd_printdd(KERN_INFO
"nm256: reset_workaround activated\n");
1636 chip
->reset_workaround
= 1;
1639 if (reset_workaround_2
) {
1640 snd_printdd(KERN_INFO
"nm256: reset_workaround_2 activated\n");
1641 chip
->reset_workaround_2
= 1;
1644 if ((err
= snd_nm256_pcm(chip
, 0)) < 0 ||
1645 (err
= snd_nm256_mixer(chip
)) < 0) {
1646 snd_card_free(card
);
1650 sprintf(card
->shortname
, "NeoMagic %s", card
->driver
);
1651 sprintf(card
->longname
, "%s at 0x%lx & 0x%lx, irq %d",
1653 chip
->buffer_addr
, chip
->cport_addr
, chip
->irq
);
1655 if ((err
= snd_card_register(card
)) < 0) {
1656 snd_card_free(card
);
1660 pci_set_drvdata(pci
, card
);
1664 static void __devexit
snd_nm256_remove(struct pci_dev
*pci
)
1666 snd_card_free(pci_get_drvdata(pci
));
1667 pci_set_drvdata(pci
, NULL
);
1671 static struct pci_driver driver
= {
1672 .name
= "NeoMagic 256",
1673 .id_table
= snd_nm256_ids
,
1674 .probe
= snd_nm256_probe
,
1675 .remove
= __devexit_p(snd_nm256_remove
),
1677 .suspend
= nm256_suspend
,
1678 .resume
= nm256_resume
,
1683 static int __init
alsa_card_nm256_init(void)
1685 return pci_register_driver(&driver
);
1688 static void __exit
alsa_card_nm256_exit(void)
1690 pci_unregister_driver(&driver
);
1693 module_init(alsa_card_nm256_init
)
1694 module_exit(alsa_card_nm256_exit
)