static int __devinit snd_cs4231_probe(struct device *dev, unsigned int n)
{
struct snd_card *card;
struct snd_cs4231 *chip;
struct snd_pcm *pcm;
int error;
card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
if (!card)
return -EINVAL;
error = snd_cs4231_create(card, port[n], -1, irq[n], dma1[n], dma2[n],
CS4231_HW_DETECT, 0, &chip);
if (error < 0)
goto out;
card->private_data = chip;
error = snd_cs4231_pcm(chip, 0, &pcm);
if (error < 0)
goto out;
strcpy(card->driver, "CS4231");
strcpy(card->shortname, pcm->name);
sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
pcm->name, chip->port, irq[n], dma1[n]);
if (dma2[n] >= 0)
sprintf(card->longname + strlen(card->longname), "&%d", dma2[n]);
error = snd_cs4231_mixer(chip);
if (error < 0)
goto out;
error = snd_cs4231_timer(chip, 0, NULL);
if (error < 0)
goto out;
if (mpu_port[n] > 0 && mpu_port[n] != SNDRV_AUTO_PORT) {
if (mpu_irq[n] == SNDRV_AUTO_IRQ)
mpu_irq[n] = -1;
if (snd_mpu401_uart_new(card, 0, MPU401_HW_CS4232,
mpu_port[n], 0, mpu_irq[n],
mpu_irq[n] >= 0 ? IRQF_DISABLED : 0,
NULL) < 0)
printk(KERN_WARNING "%s: MPU401 not detected\n", dev->bus_id);
}
snd_card_set_dev(card, dev);
error = snd_card_register(card);
if (error < 0)
goto out;
dev_set_drvdata(dev, card);
return 0;
out: snd_card_free(card);
return error;
}
int snd_cs4236_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm)
{
struct snd_pcm *pcm;
int err;
if ((err = snd_cs4231_pcm(chip, device, &pcm)) < 0)
return err;
pcm->info_flags &= ~SNDRV_PCM_INFO_JOINT_DUPLEX;
if (rpcm)
*rpcm = pcm;
return 0;
}
/*
* Create an AD1845 PCM subdevice on the SoundScape. The AD1845
* is very much like a CS4231, with a few extra bits. We will
* try to support at least some of the extra bits by overriding
* some of the CS4231 callback.
*/
static int __devinit create_ad1845(struct snd_card *card, unsigned port, int irq, int dma1)
{
register struct soundscape *sscape = get_card_soundscape(card);
struct snd_cs4231 *chip;
int err;
#define CS4231_SHARE_HARDWARE (CS4231_HWSHARE_DMA1 | CS4231_HWSHARE_DMA2)
/*
* The AD1845 PCM device is only half-duplex, and so
* we only give it one DMA channel ...
*/
if ((err = snd_cs4231_create(card,
port, -1, irq, dma1, dma1,
CS4231_HW_DETECT,
CS4231_HWSHARE_DMA1, &chip)) == 0) {
unsigned long flags;
struct snd_pcm *pcm;
#define AD1845_FREQ_SEL_ENABLE 0x08
#define AD1845_PWR_DOWN_CTRL 0x1b
#define AD1845_CRYS_CLOCK_SEL 0x1d
/*
* It turns out that the PLAYBACK_ENABLE bit is set
* by the lowlevel driver ...
*
#define AD1845_IFACE_CONFIG \
(CS4231_AUTOCALIB | CS4231_RECORD_ENABLE | CS4231_PLAYBACK_ENABLE)
snd_cs4231_mce_up(chip);
spin_lock_irqsave(&chip->reg_lock, flags);
snd_cs4231_out(chip, CS4231_IFACE_CTRL, AD1845_IFACE_CONFIG);
spin_unlock_irqrestore(&chip->reg_lock, flags);
snd_cs4231_mce_down(chip);
*/
/*
* The input clock frequency on the SoundScape must
* be 14.31818 MHz, because we must set this register
* to get the playback to sound correct ...
*/
snd_cs4231_mce_up(chip);
spin_lock_irqsave(&chip->reg_lock, flags);
snd_cs4231_out(chip, AD1845_CRYS_CLOCK_SEL, 0x20);
spin_unlock_irqrestore(&chip->reg_lock, flags);
snd_cs4231_mce_down(chip);
/*
* More custom configuration:
* a) select "mode 2", and provide a current drive of 8 mA
* b) enable frequency selection (for capture/playback)
*/
spin_lock_irqsave(&chip->reg_lock, flags);
snd_cs4231_out(chip, CS4231_MISC_INFO, (CS4231_MODE2 | 0x10));
snd_cs4231_out(chip, AD1845_PWR_DOWN_CTRL, snd_cs4231_in(chip, AD1845_PWR_DOWN_CTRL) | AD1845_FREQ_SEL_ENABLE);
spin_unlock_irqrestore(&chip->reg_lock, flags);
if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) {
snd_printk(KERN_ERR "sscape: No PCM device for AD1845 chip\n");
goto _error;
}
if ((err = snd_cs4231_mixer(chip)) < 0) {
snd_printk(KERN_ERR "sscape: No mixer device for AD1845 chip\n");
goto _error;
}
if ((err = snd_ctl_add(card, snd_ctl_new1(&midi_mixer_ctl, chip))) < 0) {
snd_printk(KERN_ERR "sscape: Could not create MIDI mixer control\n");
goto _error;
}
strcpy(card->driver, "SoundScape");
strcpy(card->shortname, pcm->name);
snprintf(card->longname, sizeof(card->longname),
"%s at 0x%lx, IRQ %d, DMA %d\n",
pcm->name, chip->port, chip->irq, chip->dma1);
chip->set_playback_format = ad1845_playback_format;
chip->set_capture_format = ad1845_capture_format;
sscape->chip = chip;
}
_error:
return err;
}
static int __init snd_gusmax_probe(int dev)
{
static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};
static int possible_dmas[] = {5, 6, 7, 1, 3, -1};
int xirq, xdma1, xdma2, err;
snd_card_t *card;
snd_gus_card_t *gus = NULL;
cs4231_t *cs4231;
struct snd_gusmax *maxcard;
card = snd_card_new(index[dev], id[dev], THIS_MODULE,
sizeof(struct snd_gusmax));
if (card == NULL)
return -ENOMEM;
card->private_free = snd_gusmax_free;
maxcard = (struct snd_gusmax *)card->private_data;
maxcard->card = card;
maxcard->irq = -1;
xirq = irq[dev];
if (xirq == SNDRV_AUTO_IRQ) {
if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) {
snd_card_free(card);
snd_printk("unable to find a free IRQ\n");
return -EBUSY;
}
}
xdma1 = dma1[dev];
if (xdma1 == SNDRV_AUTO_DMA) {
if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) {
snd_card_free(card);
snd_printk("unable to find a free DMA1\n");
return -EBUSY;
}
}
xdma2 = dma2[dev];
if (xdma2 == SNDRV_AUTO_DMA) {
if ((xdma2 = snd_legacy_find_free_dma(possible_dmas)) < 0) {
snd_card_free(card);
snd_printk("unable to find a free DMA2\n");
return -EBUSY;
}
}
if ((err = snd_gus_create(card,
port[dev],
-xirq, xdma1, xdma2,
0, channels[dev],
pcm_channels[dev],
0, &gus)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_gusmax_detect(gus)) < 0) {
snd_card_free(card);
return err;
}
maxcard->gus_status_reg = gus->gf1.reg_irqstat;
maxcard->pcm_status_reg = gus->gf1.port + 0x10c + 2;
snd_gusmax_init(dev, card, gus);
if ((err = snd_gus_initialize(gus)) < 0) {
snd_card_free(card);
return err;
}
if (!gus->max_flag) {
printk(KERN_ERR "GUS MAX soundcard was not detected at 0x%lx\n", gus->gf1.port);
snd_card_free(card);
return -ENODEV;
}
if (request_irq(xirq, snd_gusmax_interrupt, SA_INTERRUPT, "GUS MAX", (void *)maxcard)) {
snd_card_free(card);
printk(KERN_ERR "gusmax: unable to grab IRQ %d\n", xirq);
return -EBUSY;
}
maxcard->irq = xirq;
if ((err = snd_cs4231_create(card,
gus->gf1.port + 0x10c, -1, xirq,
xdma2 < 0 ? xdma1 : xdma2, xdma1,
CS4231_HW_DETECT,
CS4231_HWSHARE_IRQ |
CS4231_HWSHARE_DMA1 |
CS4231_HWSHARE_DMA2,
&cs4231)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_pcm(cs4231, 0, NULL)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_mixer(cs4231)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_timer(cs4231, 2, NULL)) < 0) {
snd_card_free(card);
return err;
}
if (pcm_channels[dev] > 0) {
if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0) {
snd_card_free(card);
return err;
}
}
if ((err = snd_gusmax_mixer(cs4231)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_gf1_rawmidi_new(gus, 0, NULL)) < 0) {
snd_card_free(card);
return err;
}
sprintf(card->longname + strlen(card->longname), " at 0x%lx, irq %i, dma %i", gus->gf1.port, xirq, xdma1);
if (xdma2 >= 0)
sprintf(card->longname + strlen(card->longname), "&%i", xdma2);
if ((err = snd_card_register(card)) < 0) {
snd_card_free(card);
return err;
}
maxcard->gus = gus;
maxcard->cs4231 = cs4231;
snd_gusmax_cards[dev] = card;
return 0;
}
static int __init snd_gusmax_probe(struct platform_device *pdev)
{
int dev = pdev->id;
static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};
static int possible_dmas[] = {5, 6, 7, 1, 3, -1};
int xirq, xdma1, xdma2, err;
struct snd_card *card;
struct snd_gus_card *gus = NULL;
struct snd_cs4231 *cs4231;
struct snd_gusmax *maxcard;
card = snd_card_new(index[dev], id[dev], THIS_MODULE,
sizeof(struct snd_gusmax));
if (card == NULL)
return -ENOMEM;
card->private_free = snd_gusmax_free;
maxcard = (struct snd_gusmax *)card->private_data;
maxcard->card = card;
maxcard->irq = -1;
xirq = irq[dev];
if (xirq == SNDRV_AUTO_IRQ) {
if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) {
snd_printk(KERN_ERR PFX "unable to find a free IRQ\n");
err = -EBUSY;
goto _err;
}
}
xdma1 = dma1[dev];
if (xdma1 == SNDRV_AUTO_DMA) {
if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) {
snd_printk(KERN_ERR PFX "unable to find a free DMA1\n");
err = -EBUSY;
goto _err;
}
}
xdma2 = dma2[dev];
if (xdma2 == SNDRV_AUTO_DMA) {
if ((xdma2 = snd_legacy_find_free_dma(possible_dmas)) < 0) {
snd_printk(KERN_ERR PFX "unable to find a free DMA2\n");
err = -EBUSY;
goto _err;
}
}
if (port[dev] != SNDRV_AUTO_PORT) {
err = snd_gus_create(card,
port[dev],
-xirq, xdma1, xdma2,
0, channels[dev],
pcm_channels[dev],
0, &gus);
} else {
static unsigned long possible_ports[] = {
0x220, 0x230, 0x240, 0x250, 0x260
};
int i;
for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {
err = snd_gus_create(card,
possible_ports[i],
-xirq, xdma1, xdma2,
0, channels[dev],
pcm_channels[dev],
0, &gus);
if (err >= 0) {
port[dev] = possible_ports[i];
break;
}
}
}
if (err < 0)
goto _err;
if ((err = snd_gusmax_detect(gus)) < 0)
goto _err;
maxcard->gus_status_reg = gus->gf1.reg_irqstat;
maxcard->pcm_status_reg = gus->gf1.port + 0x10c + 2;
snd_gusmax_init(dev, card, gus);
if ((err = snd_gus_initialize(gus)) < 0)
goto _err;
if (!gus->max_flag) {
snd_printk(KERN_ERR PFX "GUS MAX soundcard was not detected at 0x%lx\n", gus->gf1.port);
err = -ENODEV;
goto _err;
}
if (request_irq(xirq, snd_gusmax_interrupt, IRQF_DISABLED, "GUS MAX", (void *)maxcard)) {
snd_printk(KERN_ERR PFX "unable to grab IRQ %d\n", xirq);
err = -EBUSY;
goto _err;
}
maxcard->irq = xirq;
if ((err = snd_cs4231_create(card,
gus->gf1.port + 0x10c, -1, xirq,
xdma2 < 0 ? xdma1 : xdma2, xdma1,
CS4231_HW_DETECT,
CS4231_HWSHARE_IRQ |
CS4231_HWSHARE_DMA1 |
CS4231_HWSHARE_DMA2,
&cs4231)) < 0)
goto _err;
if ((err = snd_cs4231_pcm(cs4231, 0, NULL)) < 0)
goto _err;
if ((err = snd_cs4231_mixer(cs4231)) < 0)
goto _err;
if ((err = snd_cs4231_timer(cs4231, 2, NULL)) < 0)
goto _err;
if (pcm_channels[dev] > 0) {
if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0)
goto _err;
}
if ((err = snd_gusmax_mixer(cs4231)) < 0)
goto _err;
if ((err = snd_gf1_rawmidi_new(gus, 0, NULL)) < 0)
goto _err;
sprintf(card->longname + strlen(card->longname), " at 0x%lx, irq %i, dma %i", gus->gf1.port, xirq, xdma1);
if (xdma2 >= 0)
sprintf(card->longname + strlen(card->longname), "&%i", xdma2);
snd_card_set_dev(card, &pdev->dev);
if ((err = snd_card_register(card)) < 0)
goto _err;
maxcard->gus = gus;
maxcard->cs4231 = cs4231;
platform_set_drvdata(pdev, card);
return 0;
_err:
snd_card_free(card);
return err;
}
static int __devinit
snd_wavefront_probe (struct snd_card *card, int dev)
{
snd_wavefront_card_t *acard = card->private_data;
struct snd_cs4231 *chip;
struct snd_hwdep *wavefront_synth;
struct snd_rawmidi *ics2115_internal_rmidi = NULL;
struct snd_rawmidi *ics2115_external_rmidi = NULL;
struct snd_hwdep *fx_processor;
int hw_dev = 0, midi_dev = 0, err;
/* --------- PCM --------------- */
if ((err = snd_cs4231_create (card,
cs4232_pcm_port[dev],
-1,
cs4232_pcm_irq[dev],
dma1[dev],
dma2[dev],
CS4231_HW_DETECT, 0, &chip)) < 0) {
snd_printk (KERN_ERR "can't allocate CS4231 device\n");
return err;
}
if ((err = snd_cs4231_pcm (chip, 0, NULL)) < 0)
return err;
if ((err = snd_cs4231_timer (chip, 0, NULL)) < 0)
return err;
/* ---------- OPL3 synth --------- */
if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
struct snd_opl3 *opl3;
if ((err = snd_opl3_create(card,
fm_port[dev],
fm_port[dev] + 2,
OPL3_HW_OPL3_CS,
0, &opl3)) < 0) {
snd_printk (KERN_ERR "can't allocate or detect OPL3 synth\n");
return err;
}
if ((err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL)) < 0)
return err;
hw_dev++;
}
/* ------- ICS2115 Wavetable synth ------- */
if ((acard->wavefront.res_base = request_region(ics2115_port[dev], 16,
"ICS2115")) == NULL) {
snd_printk(KERN_ERR "unable to grab ICS2115 i/o region 0x%lx-0x%lx\n",
ics2115_port[dev], ics2115_port[dev] + 16 - 1);
return -EBUSY;
}
if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt,
IRQF_DISABLED, "ICS2115", acard)) {
snd_printk(KERN_ERR "unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]);
return -EBUSY;
}
acard->wavefront.irq = ics2115_irq[dev];
acard->wavefront.base = ics2115_port[dev];
if ((wavefront_synth = snd_wavefront_new_synth (card, hw_dev, acard)) == NULL) {
snd_printk (KERN_ERR "can't create WaveFront synth device\n");
return -ENOMEM;
}
strcpy (wavefront_synth->name, "ICS2115 Wavetable MIDI Synthesizer");
wavefront_synth->iface = SNDRV_HWDEP_IFACE_ICS2115;
hw_dev++;
/* --------- Mixer ------------ */
if ((err = snd_cs4231_mixer(chip)) < 0) {
snd_printk (KERN_ERR "can't allocate mixer device\n");
return err;
}
/* -------- CS4232 MPU-401 interface -------- */
if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) {
if ((err = snd_mpu401_uart_new(card, midi_dev, MPU401_HW_CS4232,
cs4232_mpu_port[dev], 0,
cs4232_mpu_irq[dev],
IRQF_DISABLED,
NULL)) < 0) {
snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n");
return err;
}
midi_dev++;
}
/* ------ ICS2115 internal MIDI ------------ */
if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) {
ics2115_internal_rmidi =
snd_wavefront_new_midi (card,
midi_dev,
acard,
ics2115_port[dev],
internal_mpu);
if (ics2115_internal_rmidi == NULL) {
snd_printk (KERN_ERR "can't setup ICS2115 internal MIDI device\n");
return -ENOMEM;
}
midi_dev++;
}
/* ------ ICS2115 external MIDI ------------ */
if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) {
ics2115_external_rmidi =
snd_wavefront_new_midi (card,
midi_dev,
acard,
ics2115_port[dev],
external_mpu);
if (ics2115_external_rmidi == NULL) {
snd_printk (KERN_ERR "can't setup ICS2115 external MIDI device\n");
return -ENOMEM;
}
midi_dev++;
}
/* FX processor for Tropez+ */
if (acard->wavefront.has_fx) {
fx_processor = snd_wavefront_new_fx (card,
hw_dev,
acard,
ics2115_port[dev]);
if (fx_processor == NULL) {
snd_printk (KERN_ERR "can't setup FX device\n");
return -ENOMEM;
}
hw_dev++;
strcpy(card->driver, "Tropez+");
strcpy(card->shortname, "Turtle Beach Tropez+");
} else {
/* Need a way to distinguish between Maui and Tropez */
strcpy(card->driver, "WaveFront");
strcpy(card->shortname, "Turtle Beach WaveFront");
}
/* ----- Register the card --------- */
/* Not safe to include "Turtle Beach" in longname, due to
length restrictions
*/
sprintf(card->longname, "%s PCM 0x%lx irq %d dma %d",
card->driver,
chip->port,
cs4232_pcm_irq[dev],
dma1[dev]);
if (dma2[dev] >= 0 && dma2[dev] < 8)
sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) {
sprintf (card->longname + strlen (card->longname),
" MPU-401 0x%lx irq %d",
cs4232_mpu_port[dev],
cs4232_mpu_irq[dev]);
}
sprintf (card->longname + strlen (card->longname),
" SYNTH 0x%lx irq %d",
ics2115_port[dev],
ics2115_irq[dev]);
return snd_card_register(card);
}
static int __init snd_cs4231_probe(struct platform_device *pdev)
{
int dev = pdev->id;
struct snd_card *card;
struct snd_pcm *pcm;
struct snd_cs4231 *chip;
int err;
if (port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR "specify port\n");
return -EINVAL;
}
if (irq[dev] == SNDRV_AUTO_IRQ) {
snd_printk(KERN_ERR "specify irq\n");
return -EINVAL;
}
if (dma1[dev] == SNDRV_AUTO_DMA) {
snd_printk(KERN_ERR "specify dma1\n");
return -EINVAL;
}
card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
if (card == NULL)
return -ENOMEM;
if ((err = snd_cs4231_create(card, port[dev], -1,
irq[dev],
dma1[dev],
dma2[dev],
CS4231_HW_DETECT,
0, &chip)) < 0)
goto _err;
card->private_data = chip;
if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0)
goto _err;
strcpy(card->driver, "CS4231");
strcpy(card->shortname, pcm->name);
sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
pcm->name, chip->port, irq[dev], dma1[dev]);
if (dma2[dev] >= 0)
sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
if ((err = snd_cs4231_mixer(chip)) < 0)
goto _err;
if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0)
goto _err;
if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
mpu_irq[dev] = -1;
if (snd_mpu401_uart_new(card, 0, MPU401_HW_CS4232,
mpu_port[dev], 0,
mpu_irq[dev],
mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0,
NULL) < 0)
printk(KERN_WARNING "cs4231: MPU401 not detected\n");
}
snd_card_set_dev(card, &pdev->dev);
if ((err = snd_card_register(card)) < 0)
goto _err;
platform_set_drvdata(pdev, card);
return 0;
_err:
snd_card_free(card);
return err;
}
static int __init snd_card_pc98_probe(int dev)
{
struct snd_card *card;
struct snd_pcm *pcm = NULL;
cs4231_t *chip;
struct snd_opl3 *opl3;
int err;
if (port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR IDENT ": specify port\n");
return -EINVAL;
}
err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
if (err < 0)
return err;
if ((err = pc98_cs4231_chip_init(dev)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_create(card,
port[dev],
-1,
irq[dev],
dma1[dev],
dma2[dev],
CS4231_HW_DETECT,
0,
&chip)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_mixer(chip)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0) {
snd_card_free(card);
return err;
}
if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
/* ??? */
outb(0x00, fm_port[dev] + 6);
inb(fm_port[dev] + 7);
/* Enable OPL-3 Function */
outb(inb(PC9800_SOUND_IO_ID) | 0x03, PC9800_SOUND_IO_ID);
if (snd_opl3_create(card,
fm_port[dev], fm_port[dev] + 2,
OPL3_HW_OPL3_PC98, 0, &opl3) < 0) {
printk(KERN_ERR IDENT ": OPL3 not detected\n");
} else {
if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
snd_card_free(card);
return err;
}
}
}
if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
err = pc98_mpu401_init(mpu_irq[dev]);
if (! err) {
err = snd_mpu401_uart_new(card, 0,
pc98ii[dev] ? MPU401_HW_PC98II : MPU401_HW_MPU401,
mpu_port[dev], 0,
mpu_irq[dev], SA_INTERRUPT, NULL);
if (err < 0)
snd_printk(KERN_INFO IDENT ": MPU401 not detected\n");
}
}
strcpy(card->driver, pcm->name);
strcpy(card->shortname, pcm->name);
sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i",
pcm->name,
chip->port,
irq[dev],
dma1[dev]);
if (dma2[dev] >= 0)
sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
if ((err = snd_card_register(card)) < 0) {
snd_card_free(card);
return err;
}
snd_pc98_cards[dev] = card;
return 0;
}
static int __init snd_card_cs4231_probe(int dev)
{
snd_card_t *card;
struct snd_card_cs4231 *acard;
snd_pcm_t *pcm = NULL;
cs4231_t *chip;
int err;
if (port[dev] == SNDRV_AUTO_PORT) {
snd_printk("specify port\n");
return -EINVAL;
}
if (irq[dev] == SNDRV_AUTO_IRQ) {
snd_printk("specify irq\n");
return -EINVAL;
}
if (dma1[dev] == SNDRV_AUTO_DMA) {
snd_printk("specify dma1\n");
return -EINVAL;
}
card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
if (card == NULL)
return -ENOMEM;
acard = (struct snd_card_cs4231 *)card->private_data;
if ((err = snd_cs4231_create(card, port[dev], -1,
irq[dev],
dma1[dev],
dma2[dev],
CS4231_HW_DETECT,
0, &chip)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) {
snd_card_free(card);
return err;
}
strcpy(card->driver, "CS4231");
strcpy(card->shortname, pcm->name);
sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
pcm->name, chip->port, irq[dev], dma1[dev]);
if (dma2[dev] >= 0)
sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
if ((err = snd_cs4231_mixer(chip)) < 0) {
snd_card_free(card);
return err;
}
if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0) {
snd_card_free(card);
return err;
}
if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
mpu_irq[dev] = -1;
if (snd_mpu401_uart_new(card, 0, MPU401_HW_CS4232,
mpu_port[dev], 0,
mpu_irq[dev],
mpu_irq[dev] >= 0 ? SA_INTERRUPT : 0,
NULL) < 0)
printk(KERN_ERR "cs4231: MPU401 not detected\n");
}
if ((err = snd_card_register(card)) < 0) {
snd_card_free(card);
return err;
}
snd_cs4231_cards[dev] = card;
return 0;
}