1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * card-als4000.c - driver for Avance Logic ALS4000 based soundcards.
4 * Copyright (C) 2000 by Bart Hartgers <bart@etpmod.phys.tue.nl>,
5 * Jaroslav Kysela <perex@perex.cz>
6 * Copyright (C) 2002, 2008 by Andreas Mohr <hw7oshyuv3001@sneakemail.com>
8 * Framework borrowed from Massimo Piccioni's card-als100.c.
12 * Since Avance does not provide any meaningful documentation, and I
13 * bought an ALS4000 based soundcard, I was forced to base this driver
14 * on reverse engineering.
16 * Note: this is no longer true (thank you!):
17 * pretty verbose chip docu (ALS4000a.PDF) can be found on the ALSA web site.
18 * Page numbers stated anywhere below with the "SPECS_PAGE:" tag
19 * refer to: ALS4000a.PDF specs Ver 1.0, May 28th, 1998.
21 * The ALS4000 seems to be the PCI-cousin of the ALS100. It contains an
22 * ALS100-like SB DSP/mixer, an OPL3 synth, a MPU401 and a gameport
23 * interface. These subsystems can be mapped into ISA io-port space,
24 * using the PCI-interface. In addition, the PCI-bit provides DMA and IRQ
25 * services to the subsystems.
27 * While ALS4000 is very similar to a SoundBlaster, the differences in
28 * DMA and capturing require more changes to the SoundBlaster than
29 * desirable, so I made this separate driver.
31 * The ALS4000 can do real full duplex playback/capture.
37 * Enable/disable 3D sound:
39 * - change bit 6 (0x40) of port 0x15
44 * 0x3e (mode 3), 0x3c (mode 2), 0x3a (mode 1), 0x38 (mode 0)
47 * - value -> some port 0x0c0d
50 * - by default, don't enable legacy game and use PCI game I/O
51 * - power management? (card can do voice wakeup according to datasheet!!)
55 #include <linux/init.h>
56 #include <linux/pci.h>
57 #include <linux/gameport.h>
58 #include <linux/module.h>
59 #include <linux/dma-mapping.h>
60 #include <sound/core.h>
61 #include <sound/pcm.h>
62 #include <sound/rawmidi.h>
63 #include <sound/mpu401.h>
64 #include <sound/opl3.h>
66 #include <sound/initval.h>
68 MODULE_AUTHOR("Bart Hartgers <bart@etpmod.phys.tue.nl>, Andreas Mohr");
69 MODULE_DESCRIPTION("Avance Logic ALS4000");
70 MODULE_LICENSE("GPL");
71 MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS4000}}");
73 #if IS_REACHABLE(CONFIG_GAMEPORT)
74 #define SUPPORT_JOYSTICK 1
77 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
78 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
79 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
; /* Enable this card */
80 #ifdef SUPPORT_JOYSTICK
81 static int joystick_port
[SNDRV_CARDS
];
84 module_param_array(index
, int, NULL
, 0444);
85 MODULE_PARM_DESC(index
, "Index value for ALS4000 soundcard.");
86 module_param_array(id
, charp
, NULL
, 0444);
87 MODULE_PARM_DESC(id
, "ID string for ALS4000 soundcard.");
88 module_param_array(enable
, bool, NULL
, 0444);
89 MODULE_PARM_DESC(enable
, "Enable ALS4000 soundcard.");
90 #ifdef SUPPORT_JOYSTICK
91 module_param_hw_array(joystick_port
, int, ioport
, NULL
, 0444);
92 MODULE_PARM_DESC(joystick_port
, "Joystick port address for ALS4000 soundcard. (0 = disabled)");
95 struct snd_card_als4000
{
96 /* most frequent access first */
100 #ifdef SUPPORT_JOYSTICK
101 struct gameport
*gameport
;
105 static const struct pci_device_id snd_als4000_ids
[] = {
106 { 0x4005, 0x4000, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0, }, /* ALS4000 */
110 MODULE_DEVICE_TABLE(pci
, snd_als4000_ids
);
112 enum als4k_iobase_t
{
113 /* IOx: B == Byte, W = Word, D = DWord; SPECS_PAGE: 37 */
114 ALS4K_IOD_00_AC97_ACCESS
= 0x00,
115 ALS4K_IOW_04_AC97_READ
= 0x04,
116 ALS4K_IOB_06_AC97_STATUS
= 0x06,
117 ALS4K_IOB_07_IRQSTATUS
= 0x07,
118 ALS4K_IOD_08_GCR_DATA
= 0x08,
119 ALS4K_IOB_0C_GCR_INDEX
= 0x0c,
120 ALS4K_IOB_0E_IRQTYPE_SB_CR1E_MPU
= 0x0e,
121 ALS4K_IOB_10_ADLIB_ADDR0
= 0x10,
122 ALS4K_IOB_11_ADLIB_ADDR1
= 0x11,
123 ALS4K_IOB_12_ADLIB_ADDR2
= 0x12,
124 ALS4K_IOB_13_ADLIB_ADDR3
= 0x13,
125 ALS4K_IOB_14_MIXER_INDEX
= 0x14,
126 ALS4K_IOB_15_MIXER_DATA
= 0x15,
127 ALS4K_IOB_16_ESP_RESET
= 0x16,
128 ALS4K_IOB_16_ACK_FOR_CR1E
= 0x16, /* 2nd function */
129 ALS4K_IOB_18_OPL_ADDR0
= 0x18,
130 ALS4K_IOB_19_OPL_ADDR1
= 0x19,
131 ALS4K_IOB_1A_ESP_RD_DATA
= 0x1a,
132 ALS4K_IOB_1C_ESP_CMD_DATA
= 0x1c,
133 ALS4K_IOB_1C_ESP_WR_STATUS
= 0x1c, /* 2nd function */
134 ALS4K_IOB_1E_ESP_RD_STATUS8
= 0x1e,
135 ALS4K_IOB_1F_ESP_RD_STATUS16
= 0x1f,
136 ALS4K_IOB_20_ESP_GAMEPORT_200
= 0x20,
137 ALS4K_IOB_21_ESP_GAMEPORT_201
= 0x21,
138 ALS4K_IOB_30_MIDI_DATA
= 0x30,
139 ALS4K_IOB_31_MIDI_STATUS
= 0x31,
140 ALS4K_IOB_31_MIDI_COMMAND
= 0x31, /* 2nd function */
143 enum als4k_iobase_0e_t
{
144 ALS4K_IOB_0E_MPU_IRQ
= 0x10,
145 ALS4K_IOB_0E_CR1E_IRQ
= 0x40,
146 ALS4K_IOB_0E_SB_DMA_IRQ
= 0x80,
149 enum als4k_gcr_t
{ /* all registers 32bit wide; SPECS_PAGE: 38 to 42 */
150 ALS4K_GCR8C_MISC_CTRL
= 0x8c,
151 ALS4K_GCR90_TEST_MODE_REG
= 0x90,
152 ALS4K_GCR91_DMA0_ADDR
= 0x91,
153 ALS4K_GCR92_DMA0_MODE_COUNT
= 0x92,
154 ALS4K_GCR93_DMA1_ADDR
= 0x93,
155 ALS4K_GCR94_DMA1_MODE_COUNT
= 0x94,
156 ALS4K_GCR95_DMA3_ADDR
= 0x95,
157 ALS4K_GCR96_DMA3_MODE_COUNT
= 0x96,
158 ALS4K_GCR99_DMA_EMULATION_CTRL
= 0x99,
159 ALS4K_GCRA0_FIFO1_CURRENT_ADDR
= 0xa0,
160 ALS4K_GCRA1_FIFO1_STATUS_BYTECOUNT
= 0xa1,
161 ALS4K_GCRA2_FIFO2_PCIADDR
= 0xa2,
162 ALS4K_GCRA3_FIFO2_COUNT
= 0xa3,
163 ALS4K_GCRA4_FIFO2_CURRENT_ADDR
= 0xa4,
164 ALS4K_GCRA5_FIFO1_STATUS_BYTECOUNT
= 0xa5,
165 ALS4K_GCRA6_PM_CTRL
= 0xa6,
166 ALS4K_GCRA7_PCI_ACCESS_STORAGE
= 0xa7,
167 ALS4K_GCRA8_LEGACY_CFG1
= 0xa8,
168 ALS4K_GCRA9_LEGACY_CFG2
= 0xa9,
169 ALS4K_GCRFF_DUMMY_SCRATCH
= 0xff,
173 ALS4K_GCR8C_IRQ_MASK_CTRL_ENABLE
= 0x8000,
174 ALS4K_GCR8C_CHIP_REV_MASK
= 0xf0000
177 static inline void snd_als4k_iobase_writeb(unsigned long iobase
,
178 enum als4k_iobase_t reg
,
181 outb(val
, iobase
+ reg
);
184 static inline void snd_als4k_iobase_writel(unsigned long iobase
,
185 enum als4k_iobase_t reg
,
188 outl(val
, iobase
+ reg
);
191 static inline u8
snd_als4k_iobase_readb(unsigned long iobase
,
192 enum als4k_iobase_t reg
)
194 return inb(iobase
+ reg
);
197 static inline u32
snd_als4k_iobase_readl(unsigned long iobase
,
198 enum als4k_iobase_t reg
)
200 return inl(iobase
+ reg
);
203 static inline void snd_als4k_gcr_write_addr(unsigned long iobase
,
204 enum als4k_gcr_t reg
,
207 snd_als4k_iobase_writeb(iobase
, ALS4K_IOB_0C_GCR_INDEX
, reg
);
208 snd_als4k_iobase_writel(iobase
, ALS4K_IOD_08_GCR_DATA
, val
);
211 static inline void snd_als4k_gcr_write(struct snd_sb
*sb
,
212 enum als4k_gcr_t reg
,
215 snd_als4k_gcr_write_addr(sb
->alt_port
, reg
, val
);
218 static inline u32
snd_als4k_gcr_read_addr(unsigned long iobase
,
219 enum als4k_gcr_t reg
)
221 /* SPECS_PAGE: 37/38 */
222 snd_als4k_iobase_writeb(iobase
, ALS4K_IOB_0C_GCR_INDEX
, reg
);
223 return snd_als4k_iobase_readl(iobase
, ALS4K_IOD_08_GCR_DATA
);
226 static inline u32
snd_als4k_gcr_read(struct snd_sb
*sb
, enum als4k_gcr_t reg
)
228 return snd_als4k_gcr_read_addr(sb
->alt_port
, reg
);
231 enum als4k_cr_t
{ /* all registers 8bit wide; SPECS_PAGE: 20 to 23 */
232 ALS4K_CR0_SB_CONFIG
= 0x00,
233 ALS4K_CR2_MISC_CONTROL
= 0x02,
234 ALS4K_CR3_CONFIGURATION
= 0x03,
235 ALS4K_CR17_FIFO_STATUS
= 0x17,
236 ALS4K_CR18_ESP_MAJOR_VERSION
= 0x18,
237 ALS4K_CR19_ESP_MINOR_VERSION
= 0x19,
238 ALS4K_CR1A_MPU401_UART_MODE_CONTROL
= 0x1a,
239 ALS4K_CR1C_FIFO2_BLOCK_LENGTH_LO
= 0x1c,
240 ALS4K_CR1D_FIFO2_BLOCK_LENGTH_HI
= 0x1d,
241 ALS4K_CR1E_FIFO2_CONTROL
= 0x1e, /* secondary PCM FIFO (recording) */
242 ALS4K_CR3A_MISC_CONTROL
= 0x3a,
243 ALS4K_CR3B_CRC32_BYTE0
= 0x3b, /* for testing, activate via CR3A */
244 ALS4K_CR3C_CRC32_BYTE1
= 0x3c,
245 ALS4K_CR3D_CRC32_BYTE2
= 0x3d,
246 ALS4K_CR3E_CRC32_BYTE3
= 0x3e,
250 ALS4K_CR0_DMA_CONTIN_MODE_CTRL
= 0x02, /* IRQ/FIFO controlled for 0/1 */
251 ALS4K_CR0_DMA_90H_MODE_CTRL
= 0x04, /* IRQ/FIFO controlled for 0/1 */
252 ALS4K_CR0_MX80_81_REG_WRITE_ENABLE
= 0x80,
255 static inline void snd_als4_cr_write(struct snd_sb
*chip
,
259 /* Control Register is reg | 0xc0 (bit 7, 6 set) on sbmixer_index
260 * NOTE: assumes chip->mixer_lock to be locked externally already!
262 snd_sbmixer_write(chip
, reg
| 0xc0, data
);
265 static inline u8
snd_als4_cr_read(struct snd_sb
*chip
,
268 /* NOTE: assumes chip->mixer_lock to be locked externally already! */
269 return snd_sbmixer_read(chip
, reg
| 0xc0);
274 static void snd_als4000_set_rate(struct snd_sb
*chip
, unsigned int rate
)
276 if (!(chip
->mode
& SB_RATE_LOCK
)) {
277 snd_sbdsp_command(chip
, SB_DSP_SAMPLE_RATE_OUT
);
278 snd_sbdsp_command(chip
, rate
>>8);
279 snd_sbdsp_command(chip
, rate
);
283 static inline void snd_als4000_set_capture_dma(struct snd_sb
*chip
,
284 dma_addr_t addr
, unsigned size
)
287 snd_als4k_gcr_write(chip
, ALS4K_GCRA2_FIFO2_PCIADDR
, addr
);
288 snd_als4k_gcr_write(chip
, ALS4K_GCRA3_FIFO2_COUNT
, (size
-1));
291 static inline void snd_als4000_set_playback_dma(struct snd_sb
*chip
,
296 snd_als4k_gcr_write(chip
, ALS4K_GCR91_DMA0_ADDR
, addr
);
297 snd_als4k_gcr_write(chip
, ALS4K_GCR92_DMA0_MODE_COUNT
,
301 #define ALS4000_FORMAT_SIGNED (1<<0)
302 #define ALS4000_FORMAT_16BIT (1<<1)
303 #define ALS4000_FORMAT_STEREO (1<<2)
305 static int snd_als4000_get_format(struct snd_pcm_runtime
*runtime
)
310 if (snd_pcm_format_signed(runtime
->format
))
311 result
|= ALS4000_FORMAT_SIGNED
;
312 if (snd_pcm_format_physical_width(runtime
->format
) == 16)
313 result
|= ALS4000_FORMAT_16BIT
;
314 if (runtime
->channels
> 1)
315 result
|= ALS4000_FORMAT_STEREO
;
319 /* structure for setting up playback */
320 static const struct {
321 unsigned char dsp_cmd
, dma_on
, dma_off
, format
;
322 } playback_cmd_vals
[]={
323 /* ALS4000_FORMAT_U8_MONO */
324 { SB_DSP4_OUT8_AI
, SB_DSP_DMA8_ON
, SB_DSP_DMA8_OFF
, SB_DSP4_MODE_UNS_MONO
},
325 /* ALS4000_FORMAT_S8_MONO */
326 { SB_DSP4_OUT8_AI
, SB_DSP_DMA8_ON
, SB_DSP_DMA8_OFF
, SB_DSP4_MODE_SIGN_MONO
},
327 /* ALS4000_FORMAT_U16L_MONO */
328 { SB_DSP4_OUT16_AI
, SB_DSP_DMA16_ON
, SB_DSP_DMA16_OFF
, SB_DSP4_MODE_UNS_MONO
},
329 /* ALS4000_FORMAT_S16L_MONO */
330 { SB_DSP4_OUT16_AI
, SB_DSP_DMA16_ON
, SB_DSP_DMA16_OFF
, SB_DSP4_MODE_SIGN_MONO
},
331 /* ALS4000_FORMAT_U8_STEREO */
332 { SB_DSP4_OUT8_AI
, SB_DSP_DMA8_ON
, SB_DSP_DMA8_OFF
, SB_DSP4_MODE_UNS_STEREO
},
333 /* ALS4000_FORMAT_S8_STEREO */
334 { SB_DSP4_OUT8_AI
, SB_DSP_DMA8_ON
, SB_DSP_DMA8_OFF
, SB_DSP4_MODE_SIGN_STEREO
},
335 /* ALS4000_FORMAT_U16L_STEREO */
336 { SB_DSP4_OUT16_AI
, SB_DSP_DMA16_ON
, SB_DSP_DMA16_OFF
, SB_DSP4_MODE_UNS_STEREO
},
337 /* ALS4000_FORMAT_S16L_STEREO */
338 { SB_DSP4_OUT16_AI
, SB_DSP_DMA16_ON
, SB_DSP_DMA16_OFF
, SB_DSP4_MODE_SIGN_STEREO
},
340 #define playback_cmd(chip) (playback_cmd_vals[(chip)->playback_format])
342 /* structure for setting up capture */
343 enum { CMD_WIDTH8
=0x04, CMD_SIGNED
=0x10, CMD_MONO
=0x80, CMD_STEREO
=0xA0 };
344 static const unsigned char capture_cmd_vals
[]=
346 CMD_WIDTH8
|CMD_MONO
, /* ALS4000_FORMAT_U8_MONO */
347 CMD_WIDTH8
|CMD_SIGNED
|CMD_MONO
, /* ALS4000_FORMAT_S8_MONO */
348 CMD_MONO
, /* ALS4000_FORMAT_U16L_MONO */
349 CMD_SIGNED
|CMD_MONO
, /* ALS4000_FORMAT_S16L_MONO */
350 CMD_WIDTH8
|CMD_STEREO
, /* ALS4000_FORMAT_U8_STEREO */
351 CMD_WIDTH8
|CMD_SIGNED
|CMD_STEREO
, /* ALS4000_FORMAT_S8_STEREO */
352 CMD_STEREO
, /* ALS4000_FORMAT_U16L_STEREO */
353 CMD_SIGNED
|CMD_STEREO
, /* ALS4000_FORMAT_S16L_STEREO */
355 #define capture_cmd(chip) (capture_cmd_vals[(chip)->capture_format])
357 static int snd_als4000_hw_params(struct snd_pcm_substream
*substream
,
358 struct snd_pcm_hw_params
*hw_params
)
360 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
363 static int snd_als4000_hw_free(struct snd_pcm_substream
*substream
)
365 snd_pcm_lib_free_pages(substream
);
369 static int snd_als4000_capture_prepare(struct snd_pcm_substream
*substream
)
371 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
372 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
376 chip
->capture_format
= snd_als4000_get_format(runtime
);
378 size
= snd_pcm_lib_buffer_bytes(substream
);
379 count
= snd_pcm_lib_period_bytes(substream
);
381 if (chip
->capture_format
& ALS4000_FORMAT_16BIT
)
385 spin_lock_irq(&chip
->reg_lock
);
386 snd_als4000_set_rate(chip
, runtime
->rate
);
387 snd_als4000_set_capture_dma(chip
, runtime
->dma_addr
, size
);
388 spin_unlock_irq(&chip
->reg_lock
);
389 spin_lock_irq(&chip
->mixer_lock
);
390 snd_als4_cr_write(chip
, ALS4K_CR1C_FIFO2_BLOCK_LENGTH_LO
, count
& 0xff);
391 snd_als4_cr_write(chip
, ALS4K_CR1D_FIFO2_BLOCK_LENGTH_HI
, count
>> 8);
392 spin_unlock_irq(&chip
->mixer_lock
);
396 static int snd_als4000_playback_prepare(struct snd_pcm_substream
*substream
)
398 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
399 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
403 chip
->playback_format
= snd_als4000_get_format(runtime
);
405 size
= snd_pcm_lib_buffer_bytes(substream
);
406 count
= snd_pcm_lib_period_bytes(substream
);
408 if (chip
->playback_format
& ALS4000_FORMAT_16BIT
)
412 /* FIXME: from second playback on, there's a lot more clicks and pops
413 * involved here than on first playback. Fiddling with
414 * tons of different settings didn't help (DMA, speaker on/off,
415 * reordering, ...). Something seems to get enabled on playback
416 * that I haven't found out how to disable again, which then causes
417 * the switching pops to reach the speakers the next time here. */
418 spin_lock_irq(&chip
->reg_lock
);
419 snd_als4000_set_rate(chip
, runtime
->rate
);
420 snd_als4000_set_playback_dma(chip
, runtime
->dma_addr
, size
);
422 /* SPEAKER_ON not needed, since dma_on seems to also enable speaker */
423 /* snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON); */
424 snd_sbdsp_command(chip
, playback_cmd(chip
).dsp_cmd
);
425 snd_sbdsp_command(chip
, playback_cmd(chip
).format
);
426 snd_sbdsp_command(chip
, count
& 0xff);
427 snd_sbdsp_command(chip
, count
>> 8);
428 snd_sbdsp_command(chip
, playback_cmd(chip
).dma_off
);
429 spin_unlock_irq(&chip
->reg_lock
);
434 static int snd_als4000_capture_trigger(struct snd_pcm_substream
*substream
, int cmd
)
436 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
439 /* FIXME race condition in here!!!
440 chip->mode non-atomic update gets consistently protected
441 by reg_lock always, _except_ for this place!!
442 Probably need to take reg_lock as outer (or inner??) lock, too.
443 (or serialize both lock operations? probably not, though... - racy?)
445 spin_lock(&chip
->mixer_lock
);
447 case SNDRV_PCM_TRIGGER_START
:
448 case SNDRV_PCM_TRIGGER_RESUME
:
449 chip
->mode
|= SB_RATE_LOCK_CAPTURE
;
450 snd_als4_cr_write(chip
, ALS4K_CR1E_FIFO2_CONTROL
,
453 case SNDRV_PCM_TRIGGER_STOP
:
454 case SNDRV_PCM_TRIGGER_SUSPEND
:
455 chip
->mode
&= ~SB_RATE_LOCK_CAPTURE
;
456 snd_als4_cr_write(chip
, ALS4K_CR1E_FIFO2_CONTROL
,
463 spin_unlock(&chip
->mixer_lock
);
467 static int snd_als4000_playback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
469 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
472 spin_lock(&chip
->reg_lock
);
474 case SNDRV_PCM_TRIGGER_START
:
475 case SNDRV_PCM_TRIGGER_RESUME
:
476 chip
->mode
|= SB_RATE_LOCK_PLAYBACK
;
477 snd_sbdsp_command(chip
, playback_cmd(chip
).dma_on
);
479 case SNDRV_PCM_TRIGGER_STOP
:
480 case SNDRV_PCM_TRIGGER_SUSPEND
:
481 snd_sbdsp_command(chip
, playback_cmd(chip
).dma_off
);
482 chip
->mode
&= ~SB_RATE_LOCK_PLAYBACK
;
488 spin_unlock(&chip
->reg_lock
);
492 static snd_pcm_uframes_t
snd_als4000_capture_pointer(struct snd_pcm_substream
*substream
)
494 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
497 spin_lock(&chip
->reg_lock
);
498 result
= snd_als4k_gcr_read(chip
, ALS4K_GCRA4_FIFO2_CURRENT_ADDR
);
499 spin_unlock(&chip
->reg_lock
);
501 return bytes_to_frames( substream
->runtime
, result
);
504 static snd_pcm_uframes_t
snd_als4000_playback_pointer(struct snd_pcm_substream
*substream
)
506 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
509 spin_lock(&chip
->reg_lock
);
510 result
= snd_als4k_gcr_read(chip
, ALS4K_GCRA0_FIFO1_CURRENT_ADDR
);
511 spin_unlock(&chip
->reg_lock
);
513 return bytes_to_frames( substream
->runtime
, result
);
516 /* FIXME: this IRQ routine doesn't really support IRQ sharing (we always
517 * return IRQ_HANDLED no matter whether we actually had an IRQ flag or not).
518 * ALS4000a.PDF writes that while ACKing IRQ in PCI block will *not* ACK
519 * the IRQ in the SB core, ACKing IRQ in SB block *will* ACK the PCI IRQ
520 * register (alt_port + ALS4K_IOB_0E_IRQTYPE_SB_CR1E_MPU). Probably something
521 * could be optimized here to query/write one register only...
522 * And even if both registers need to be queried, then there's still the
523 * question of whether it's actually correct to ACK PCI IRQ before reading
524 * SB IRQ like we do now, since ALS4000a.PDF mentions that PCI IRQ will *clear*
526 * (hmm, SPECS_PAGE: 38 mentions it the other way around!)
527 * And do we *really* need the lock here for *reading* SB_DSP4_IRQSTATUS??
529 static irqreturn_t
snd_als4000_interrupt(int irq
, void *dev_id
)
531 struct snd_sb
*chip
= dev_id
;
532 unsigned pci_irqstatus
;
533 unsigned sb_irqstatus
;
535 /* find out which bit of the ALS4000 PCI block produced the interrupt,
537 pci_irqstatus
= snd_als4k_iobase_readb(chip
->alt_port
,
538 ALS4K_IOB_0E_IRQTYPE_SB_CR1E_MPU
);
539 if ((pci_irqstatus
& ALS4K_IOB_0E_SB_DMA_IRQ
)
540 && (chip
->playback_substream
)) /* playback */
541 snd_pcm_period_elapsed(chip
->playback_substream
);
542 if ((pci_irqstatus
& ALS4K_IOB_0E_CR1E_IRQ
)
543 && (chip
->capture_substream
)) /* capturing */
544 snd_pcm_period_elapsed(chip
->capture_substream
);
545 if ((pci_irqstatus
& ALS4K_IOB_0E_MPU_IRQ
)
546 && (chip
->rmidi
)) /* MPU401 interrupt */
547 snd_mpu401_uart_interrupt(irq
, chip
->rmidi
->private_data
);
548 /* ACK the PCI block IRQ */
549 snd_als4k_iobase_writeb(chip
->alt_port
,
550 ALS4K_IOB_0E_IRQTYPE_SB_CR1E_MPU
, pci_irqstatus
);
552 spin_lock(&chip
->mixer_lock
);
554 sb_irqstatus
= snd_sbmixer_read(chip
, SB_DSP4_IRQSTATUS
);
555 spin_unlock(&chip
->mixer_lock
);
557 if (sb_irqstatus
& SB_IRQTYPE_8BIT
)
558 snd_sb_ack_8bit(chip
);
559 if (sb_irqstatus
& SB_IRQTYPE_16BIT
)
560 snd_sb_ack_16bit(chip
);
561 if (sb_irqstatus
& SB_IRQTYPE_MPUIN
)
563 if (sb_irqstatus
& ALS4K_IRQTYPE_CR1E_DMA
)
564 snd_als4k_iobase_readb(chip
->alt_port
,
565 ALS4K_IOB_16_ACK_FOR_CR1E
);
567 /* dev_dbg(chip->card->dev, "als4000: irq 0x%04x 0x%04x\n",
568 pci_irqstatus, sb_irqstatus); */
570 /* only ack the things we actually handled above */
572 (pci_irqstatus
& (ALS4K_IOB_0E_SB_DMA_IRQ
|ALS4K_IOB_0E_CR1E_IRQ
|
573 ALS4K_IOB_0E_MPU_IRQ
))
574 || (sb_irqstatus
& (SB_IRQTYPE_8BIT
|SB_IRQTYPE_16BIT
|
575 SB_IRQTYPE_MPUIN
|ALS4K_IRQTYPE_CR1E_DMA
))
579 /*****************************************************************/
581 static const struct snd_pcm_hardware snd_als4000_playback
=
583 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
584 SNDRV_PCM_INFO_MMAP_VALID
),
585 .formats
= SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U8
|
586 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
, /* formats */
587 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
592 .buffer_bytes_max
= 65536,
593 .period_bytes_min
= 64,
594 .period_bytes_max
= 65536,
600 static const struct snd_pcm_hardware snd_als4000_capture
=
602 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
603 SNDRV_PCM_INFO_MMAP_VALID
),
604 .formats
= SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U8
|
605 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
, /* formats */
606 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
611 .buffer_bytes_max
= 65536,
612 .period_bytes_min
= 64,
613 .period_bytes_max
= 65536,
619 /*****************************************************************/
621 static int snd_als4000_playback_open(struct snd_pcm_substream
*substream
)
623 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
624 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
626 chip
->playback_substream
= substream
;
627 runtime
->hw
= snd_als4000_playback
;
631 static int snd_als4000_playback_close(struct snd_pcm_substream
*substream
)
633 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
635 chip
->playback_substream
= NULL
;
636 snd_pcm_lib_free_pages(substream
);
640 static int snd_als4000_capture_open(struct snd_pcm_substream
*substream
)
642 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
643 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
645 chip
->capture_substream
= substream
;
646 runtime
->hw
= snd_als4000_capture
;
650 static int snd_als4000_capture_close(struct snd_pcm_substream
*substream
)
652 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
654 chip
->capture_substream
= NULL
;
655 snd_pcm_lib_free_pages(substream
);
659 /******************************************************************/
661 static const struct snd_pcm_ops snd_als4000_playback_ops
= {
662 .open
= snd_als4000_playback_open
,
663 .close
= snd_als4000_playback_close
,
664 .ioctl
= snd_pcm_lib_ioctl
,
665 .hw_params
= snd_als4000_hw_params
,
666 .hw_free
= snd_als4000_hw_free
,
667 .prepare
= snd_als4000_playback_prepare
,
668 .trigger
= snd_als4000_playback_trigger
,
669 .pointer
= snd_als4000_playback_pointer
672 static const struct snd_pcm_ops snd_als4000_capture_ops
= {
673 .open
= snd_als4000_capture_open
,
674 .close
= snd_als4000_capture_close
,
675 .ioctl
= snd_pcm_lib_ioctl
,
676 .hw_params
= snd_als4000_hw_params
,
677 .hw_free
= snd_als4000_hw_free
,
678 .prepare
= snd_als4000_capture_prepare
,
679 .trigger
= snd_als4000_capture_trigger
,
680 .pointer
= snd_als4000_capture_pointer
683 static int snd_als4000_pcm(struct snd_sb
*chip
, int device
)
688 err
= snd_pcm_new(chip
->card
, "ALS4000 DSP", device
, 1, 1, &pcm
);
691 pcm
->private_data
= chip
;
692 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
693 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_als4000_playback_ops
);
694 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_als4000_capture_ops
);
696 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(chip
->pci
),
704 /******************************************************************/
706 static void snd_als4000_set_addr(unsigned long iobase
,
710 unsigned int game_io
)
716 cfg2
|= (mpu_io
| 1) << 16;
720 cfg1
|= (game_io
| 1) << 16;
722 cfg1
|= (opl_io
| 1);
723 snd_als4k_gcr_write_addr(iobase
, ALS4K_GCRA8_LEGACY_CFG1
, cfg1
);
724 snd_als4k_gcr_write_addr(iobase
, ALS4K_GCRA9_LEGACY_CFG2
, cfg2
);
727 static void snd_als4000_configure(struct snd_sb
*chip
)
732 /* do some more configuration */
733 spin_lock_irq(&chip
->mixer_lock
);
734 tmp
= snd_als4_cr_read(chip
, ALS4K_CR0_SB_CONFIG
);
735 snd_als4_cr_write(chip
, ALS4K_CR0_SB_CONFIG
,
736 tmp
|ALS4K_CR0_MX80_81_REG_WRITE_ENABLE
);
737 /* always select DMA channel 0, since we do not actually use DMA
738 * SPECS_PAGE: 19/20 */
739 snd_sbmixer_write(chip
, SB_DSP4_DMASETUP
, SB_DMASETUP_DMA0
);
740 snd_als4_cr_write(chip
, ALS4K_CR0_SB_CONFIG
,
741 tmp
& ~ALS4K_CR0_MX80_81_REG_WRITE_ENABLE
);
742 spin_unlock_irq(&chip
->mixer_lock
);
744 spin_lock_irq(&chip
->reg_lock
);
745 /* enable interrupts */
746 snd_als4k_gcr_write(chip
, ALS4K_GCR8C_MISC_CTRL
,
747 ALS4K_GCR8C_IRQ_MASK_CTRL_ENABLE
);
750 for (i
= ALS4K_GCR91_DMA0_ADDR
; i
<= ALS4K_GCR96_DMA3_MODE_COUNT
; ++i
)
751 snd_als4k_gcr_write(chip
, i
, 0);
752 /* enable burst mode to prevent dropouts during high PCI bus usage */
753 snd_als4k_gcr_write(chip
, ALS4K_GCR99_DMA_EMULATION_CTRL
,
754 (snd_als4k_gcr_read(chip
, ALS4K_GCR99_DMA_EMULATION_CTRL
) & ~0x07) | 0x04);
755 spin_unlock_irq(&chip
->reg_lock
);
758 #ifdef SUPPORT_JOYSTICK
759 static int snd_als4000_create_gameport(struct snd_card_als4000
*acard
, int dev
)
765 if (joystick_port
[dev
] == 0)
768 if (joystick_port
[dev
] == 1) { /* auto-detect */
769 for (io_port
= 0x200; io_port
<= 0x218; io_port
+= 8) {
770 r
= request_region(io_port
, 8, "ALS4000 gameport");
775 io_port
= joystick_port
[dev
];
776 r
= request_region(io_port
, 8, "ALS4000 gameport");
780 dev_warn(&acard
->pci
->dev
, "cannot reserve joystick ports\n");
784 acard
->gameport
= gp
= gameport_allocate_port();
786 dev_err(&acard
->pci
->dev
, "cannot allocate memory for gameport\n");
787 release_and_free_resource(r
);
791 gameport_set_name(gp
, "ALS4000 Gameport");
792 gameport_set_phys(gp
, "pci%s/gameport0", pci_name(acard
->pci
));
793 gameport_set_dev_parent(gp
, &acard
->pci
->dev
);
795 gameport_set_port_data(gp
, r
);
797 /* Enable legacy joystick port */
798 snd_als4000_set_addr(acard
->iobase
, 0, 0, 0, 1);
800 gameport_register_port(acard
->gameport
);
805 static void snd_als4000_free_gameport(struct snd_card_als4000
*acard
)
807 if (acard
->gameport
) {
808 struct resource
*r
= gameport_get_port_data(acard
->gameport
);
810 gameport_unregister_port(acard
->gameport
);
811 acard
->gameport
= NULL
;
813 /* disable joystick */
814 snd_als4000_set_addr(acard
->iobase
, 0, 0, 0, 0);
816 release_and_free_resource(r
);
820 static inline int snd_als4000_create_gameport(struct snd_card_als4000
*acard
, int dev
) { return -ENOSYS
; }
821 static inline void snd_als4000_free_gameport(struct snd_card_als4000
*acard
) { }
824 static void snd_card_als4000_free( struct snd_card
*card
)
826 struct snd_card_als4000
*acard
= card
->private_data
;
828 /* make sure that interrupts are disabled */
829 snd_als4k_gcr_write_addr(acard
->iobase
, ALS4K_GCR8C_MISC_CTRL
, 0);
831 snd_als4000_free_gameport(acard
);
832 pci_release_regions(acard
->pci
);
833 pci_disable_device(acard
->pci
);
836 static int snd_card_als4000_probe(struct pci_dev
*pci
,
837 const struct pci_device_id
*pci_id
)
840 struct snd_card
*card
;
841 struct snd_card_als4000
*acard
;
842 unsigned long iobase
;
844 struct snd_opl3
*opl3
;
848 if (dev
>= SNDRV_CARDS
)
855 /* enable PCI device */
856 if ((err
= pci_enable_device(pci
)) < 0) {
859 /* check, if we can restrict PCI DMA transfers to 24 bits */
860 if (dma_set_mask(&pci
->dev
, DMA_BIT_MASK(24)) < 0 ||
861 dma_set_coherent_mask(&pci
->dev
, DMA_BIT_MASK(24)) < 0) {
862 dev_err(&pci
->dev
, "architecture does not support 24bit PCI busmaster DMA\n");
863 pci_disable_device(pci
);
867 if ((err
= pci_request_regions(pci
, "ALS4000")) < 0) {
868 pci_disable_device(pci
);
871 iobase
= pci_resource_start(pci
, 0);
873 pci_read_config_word(pci
, PCI_COMMAND
, &word
);
874 pci_write_config_word(pci
, PCI_COMMAND
, word
| PCI_COMMAND_IO
);
877 err
= snd_card_new(&pci
->dev
, index
[dev
], id
[dev
], THIS_MODULE
,
878 sizeof(*acard
) /* private_data: acard */,
881 pci_release_regions(pci
);
882 pci_disable_device(pci
);
886 acard
= card
->private_data
;
888 acard
->iobase
= iobase
;
889 card
->private_free
= snd_card_als4000_free
;
891 /* disable all legacy ISA stuff */
892 snd_als4000_set_addr(acard
->iobase
, 0, 0, 0, 0);
894 if ((err
= snd_sbdsp_create(card
,
895 iobase
+ ALS4K_IOB_10_ADLIB_ADDR0
,
897 /* internally registered as IRQF_SHARED in case of ALS4000 SB */
898 snd_als4000_interrupt
,
908 chip
->alt_port
= iobase
;
910 snd_als4000_configure(chip
);
912 strcpy(card
->driver
, "ALS4000");
913 strcpy(card
->shortname
, "Avance Logic ALS4000");
914 sprintf(card
->longname
, "%s at 0x%lx, irq %i",
915 card
->shortname
, chip
->alt_port
, chip
->irq
);
917 if ((err
= snd_mpu401_uart_new( card
, 0, MPU401_HW_ALS4000
,
918 iobase
+ ALS4K_IOB_30_MIDI_DATA
,
919 MPU401_INFO_INTEGRATED
|
920 MPU401_INFO_IRQ_HOOK
,
921 -1, &chip
->rmidi
)) < 0) {
922 dev_err(&pci
->dev
, "no MPU-401 device at 0x%lx?\n",
923 iobase
+ ALS4K_IOB_30_MIDI_DATA
);
926 /* FIXME: ALS4000 has interesting MPU401 configuration features
927 * at ALS4K_CR1A_MPU401_UART_MODE_CONTROL
928 * (pass-thru / UART switching, fast MIDI clock, etc.),
929 * however there doesn't seem to be an ALSA API for this...
932 if ((err
= snd_als4000_pcm(chip
, 0)) < 0) {
935 if ((err
= snd_sbmixer_new(chip
)) < 0) {
939 if (snd_opl3_create(card
,
940 iobase
+ ALS4K_IOB_10_ADLIB_ADDR0
,
941 iobase
+ ALS4K_IOB_12_ADLIB_ADDR2
,
942 OPL3_HW_AUTO
, 1, &opl3
) < 0) {
943 dev_err(&pci
->dev
, "no OPL device at 0x%lx-0x%lx?\n",
944 iobase
+ ALS4K_IOB_10_ADLIB_ADDR0
,
945 iobase
+ ALS4K_IOB_12_ADLIB_ADDR2
);
947 if ((err
= snd_opl3_hwdep_new(opl3
, 0, 1, NULL
)) < 0) {
952 snd_als4000_create_gameport(acard
, dev
);
954 if ((err
= snd_card_register(card
)) < 0) {
957 pci_set_drvdata(pci
, card
);
969 static void snd_card_als4000_remove(struct pci_dev
*pci
)
971 snd_card_free(pci_get_drvdata(pci
));
974 #ifdef CONFIG_PM_SLEEP
975 static int snd_als4000_suspend(struct device
*dev
)
977 struct snd_card
*card
= dev_get_drvdata(dev
);
978 struct snd_card_als4000
*acard
= card
->private_data
;
979 struct snd_sb
*chip
= acard
->chip
;
981 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
983 snd_sbmixer_suspend(chip
);
987 static int snd_als4000_resume(struct device
*dev
)
989 struct snd_card
*card
= dev_get_drvdata(dev
);
990 struct snd_card_als4000
*acard
= card
->private_data
;
991 struct snd_sb
*chip
= acard
->chip
;
993 snd_als4000_configure(chip
);
994 snd_sbdsp_reset(chip
);
995 snd_sbmixer_resume(chip
);
997 #ifdef SUPPORT_JOYSTICK
999 snd_als4000_set_addr(acard
->iobase
, 0, 0, 0, 1);
1002 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
1006 static SIMPLE_DEV_PM_OPS(snd_als4000_pm
, snd_als4000_suspend
, snd_als4000_resume
);
1007 #define SND_ALS4000_PM_OPS &snd_als4000_pm
1009 #define SND_ALS4000_PM_OPS NULL
1010 #endif /* CONFIG_PM_SLEEP */
1012 static struct pci_driver als4000_driver
= {
1013 .name
= KBUILD_MODNAME
,
1014 .id_table
= snd_als4000_ids
,
1015 .probe
= snd_card_als4000_probe
,
1016 .remove
= snd_card_als4000_remove
,
1018 .pm
= SND_ALS4000_PM_OPS
,
1022 module_pci_driver(als4000_driver
);