#include <asm/io.h>
-#define chip_t ymfpci_t
-
/*
* constants
*/
static void snd_ymfpci_codec_write(ac97_t *ac97, u16 reg, u16 val)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, ac97->private_data, return);
+ ymfpci_t *chip = ac97->private_data;
u32 cmd;
snd_ymfpci_codec_ready(chip, 0);
static u16 snd_ymfpci_codec_read(ac97_t *ac97, u16 reg)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, ac97->private_data, return -ENXIO);
+ ymfpci_t *chip = ac97->private_data;
if (snd_ymfpci_codec_ready(chip, 0))
return ~0;
return -ENOMEM;
}
-int snd_ymfpci_voice_alloc(ymfpci_t *chip, ymfpci_voice_type_t type, int pair, ymfpci_voice_t **rvoice)
+static int snd_ymfpci_voice_alloc(ymfpci_t *chip, ymfpci_voice_type_t type, int pair, ymfpci_voice_t **rvoice)
{
unsigned long flags;
int result;
return result;
}
-int snd_ymfpci_voice_free(ymfpci_t *chip, ymfpci_voice_t *pvoice)
+static int snd_ymfpci_voice_free(ymfpci_t *chip, ymfpci_voice_t *pvoice)
{
unsigned long flags;
static void snd_ymfpci_pcm_capture_interrupt(snd_pcm_substream_t *substream)
{
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
ymfpci_t *chip = ypcm->chip;
u32 pos, delta;
int cmd)
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, substream->runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = substream->runtime->private_data;
int result = 0;
spin_lock(&chip->reg_lock);
int cmd)
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, substream->runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = substream->runtime->private_data;
int result = 0;
u32 tmp;
static int __devinit snd_ymfpci_ac3_init(ymfpci_t *chip)
{
- if (snd_dma_alloc_pages(&chip->dma_dev, 4096, &chip->ac3_tmp_base) < 0)
+ if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+ 4096, &chip->ac3_tmp_base) < 0)
return -ENOMEM;
chip->bank_effect[3][0]->base =
spin_unlock_irq(&chip->reg_lock);
// snd_ymfpci_irq_wait(chip);
if (chip->ac3_tmp_base.area) {
- snd_dma_free_pages(&chip->dma_dev, &chip->ac3_tmp_base);
+ snd_dma_free_pages(&chip->ac3_tmp_base);
chip->ac3_tmp_base.area = NULL;
}
return 0;
snd_pcm_hw_params_t * hw_params)
{
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
int err;
if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
if (runtime->private_data == NULL)
return 0;
- ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ypcm = runtime->private_data;
/* wait, until the PCI operations are not finished */
snd_ymfpci_irq_wait(chip);
{
// ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
unsigned int nvoice;
ypcm->period_size = runtime->period_size;
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
snd_ymfpci_capture_bank_t * bank;
int nbank;
u32 rate, format;
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
ymfpci_voice_t *voice = ypcm->voices[0];
if (!(ypcm->running && voice))
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
if (!ypcm->running)
return 0;
static irqreturn_t snd_ymfpci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, dev_id, return IRQ_NONE);
+ ymfpci_t *chip = dev_id;
u32 status, nvoice, mode;
ymfpci_voice_t *voice;
static void snd_ymfpci_pcm_free_substream(snd_pcm_runtime_t *runtime)
{
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
- if (ypcm)
- snd_magic_kfree(ypcm);
+ kfree(ypcm);
}
static int snd_ymfpci_playback_open_1(snd_pcm_substream_t * substream)
snd_pcm_runtime_t *runtime = substream->runtime;
ymfpci_pcm_t *ypcm;
- ypcm = snd_magic_kcalloc(ymfpci_pcm_t, 0, GFP_KERNEL);
+ ypcm = kcalloc(1, sizeof(*ypcm), GFP_KERNEL);
if (ypcm == NULL)
return -ENOMEM;
ypcm->chip = chip;
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
ymfpci_pcm_t *ypcm;
- unsigned long flags;
int err;
if ((err = snd_ymfpci_playback_open_1(substream)) < 0)
return err;
- ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return 0);
+ ypcm = runtime->private_data;
ypcm->output_front = 1;
ypcm->output_rear = chip->mode_dup4ch ? 1 : 0;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
if (ypcm->output_rear) {
ymfpci_open_extension(chip);
chip->rear_opened++;
}
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
ymfpci_pcm_t *ypcm;
- unsigned long flags;
int err;
if ((err = snd_ymfpci_playback_open_1(substream)) < 0)
return err;
- ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return 0);
+ ypcm = runtime->private_data;
ypcm->output_front = 0;
ypcm->output_rear = 1;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTCTRL,
snd_ymfpci_readw(chip, YDSXGR_SPDIFOUTCTRL) | 2);
ymfpci_open_extension(chip);
chip->spdif_pcm_bits = chip->spdif_bits;
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTSTATUS, chip->spdif_pcm_bits);
chip->spdif_opened++;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
chip->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
ymfpci_pcm_t *ypcm;
- unsigned long flags;
int err;
if ((err = snd_ymfpci_playback_open_1(substream)) < 0)
return err;
- ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return 0);
+ ypcm = runtime->private_data;
ypcm->output_front = 0;
ypcm->output_rear = 1;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
ymfpci_open_extension(chip);
chip->rear_opened++;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_pcm_runtime_t *runtime = substream->runtime;
ymfpci_pcm_t *ypcm;
- ypcm = snd_magic_kcalloc(ymfpci_pcm_t, 0, GFP_KERNEL);
+ ypcm = kcalloc(1, sizeof(*ypcm), GFP_KERNEL);
if (ypcm == NULL)
return -ENOMEM;
ypcm->chip = chip;
static int snd_ymfpci_playback_close(snd_pcm_substream_t * substream)
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, substream->runtime->private_data, return -ENXIO);
- unsigned long flags;
+ ymfpci_pcm_t *ypcm = substream->runtime->private_data;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
if (ypcm->output_rear && chip->rear_opened > 0) {
chip->rear_opened--;
ymfpci_close_extension(chip);
}
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return snd_ymfpci_playback_close_1(substream);
}
static int snd_ymfpci_playback_spdif_close(snd_pcm_substream_t * substream)
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
chip->spdif_opened = 0;
ymfpci_close_extension(chip);
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTCTRL,
snd_ymfpci_readw(chip, YDSXGR_SPDIFOUTCTRL) & ~2);
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTSTATUS, chip->spdif_bits);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
chip->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
SNDRV_CTL_EVENT_MASK_INFO, &chip->spdif_pcm_ctl->id);
static int snd_ymfpci_playback_4ch_close(snd_pcm_substream_t * substream)
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
if (chip->rear_opened > 0) {
chip->rear_opened--;
ymfpci_close_extension(chip);
}
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return snd_ymfpci_playback_close_1(substream);
}
{
ymfpci_t *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
- ymfpci_pcm_t *ypcm = snd_magic_cast(ymfpci_pcm_t, runtime->private_data, return -ENXIO);
+ ymfpci_pcm_t *ypcm = runtime->private_data;
if (ypcm != NULL) {
chip->capture_substream[ypcm->capture_bank_number] = NULL;
static void snd_ymfpci_pcm_free(snd_pcm_t *pcm)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
+ ymfpci_t *chip = pcm->private_data;
chip->pcm = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
static void snd_ymfpci_pcm2_free(snd_pcm_t *pcm)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
+ ymfpci_t *chip = pcm->private_data;
chip->pcm2 = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
static void snd_ymfpci_pcm_spdif_free(snd_pcm_t *pcm)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
+ ymfpci_t *chip = pcm->private_data;
chip->pcm_spdif = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
static void snd_ymfpci_pcm_4ch_free(snd_pcm_t *pcm)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
+ ymfpci_t *chip = pcm->private_data;
chip->pcm_4ch = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
ucontrol->value.iec958.status[0] = (chip->spdif_bits >> 0) & 0xff;
ucontrol->value.iec958.status[1] = (chip->spdif_bits >> 8) & 0xff;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int val;
int change;
val = ((ucontrol->value.iec958.status[0] & 0x3e) << 0) |
(ucontrol->value.iec958.status[1] << 8);
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
change = chip->spdif_bits != val;
chip->spdif_bits = val;
if ((snd_ymfpci_readw(chip, YDSXGR_SPDIFOUTCTRL) & 1) && chip->pcm_spdif == NULL)
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTSTATUS, chip->spdif_bits);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
ucontrol->value.iec958.status[0] = 0x3e;
ucontrol->value.iec958.status[1] = 0xff;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
ucontrol->value.iec958.status[0] = (chip->spdif_pcm_bits >> 0) & 0xff;
ucontrol->value.iec958.status[1] = (chip->spdif_pcm_bits >> 8) & 0xff;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int val;
int change;
val = ((ucontrol->value.iec958.status[0] & 0x3e) << 0) |
(ucontrol->value.iec958.status[1] << 8);
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
change = chip->spdif_pcm_bits != val;
chip->spdif_pcm_bits = val;
if ((snd_ymfpci_readw(chip, YDSXGR_SPDIFOUTCTRL) & 2))
snd_ymfpci_writew(chip, YDSXGR_SPDIFOUTSTATUS, chip->spdif_pcm_bits);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
static int snd_ymfpci_drec_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
u16 reg;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
reg = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
if (!(reg & 0x100))
value->value.enumerated.item[0] = 0;
else
static int snd_ymfpci_drec_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
u16 reg, old_reg;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
old_reg = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
if (value->value.enumerated.item[0] == 0)
reg = old_reg & ~0x100;
else
reg = (old_reg & ~0x300) | 0x100 | ((value->value.enumerated.item[0] == 2) << 9);
snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, reg);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return reg != old_reg;
}
static int snd_ymfpci_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
int reg = kcontrol->private_value;
unsigned int shift = 0, mask = 1, invert = 0;
int change;
if (invert)
val = mask - val;
val <<= shift;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
oval = snd_ymfpci_readl(chip, reg);
val = (oval & ~(mask << shift)) | val;
change = val != oval;
snd_ymfpci_writel(chip, reg, val);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
static int snd_ymfpci_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int reg = kcontrol->private_value;
unsigned int shift_left = 0, shift_right = 16, mask = 16383, invert = 0;
unsigned int val;
if (reg < 0x80 || reg >= 0xc0)
return -EINVAL;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
val = snd_ymfpci_readl(chip, reg);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
ucontrol->value.integer.value[0] = (val >> shift_left) & mask;
ucontrol->value.integer.value[1] = (val >> shift_right) & mask;
if (invert) {
static int snd_ymfpci_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
ymfpci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int reg = kcontrol->private_value;
unsigned int shift_left = 0, shift_right = 16, mask = 16383, invert = 0;
int change;
}
val1 <<= shift_left;
val2 <<= shift_right;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
oval = snd_ymfpci_readl(chip, reg);
val1 = (oval & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
change = val1 != oval;
snd_ymfpci_writel(chip, reg, val1);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
}
-#define YMFPCI_CONTROLS (sizeof(snd_ymfpci_controls)/sizeof(snd_kcontrol_new_t))
-
static snd_kcontrol_new_t snd_ymfpci_controls[] __devinitdata = {
YMFPCI_DOUBLE("Wave Playback Volume", 0, YDSXGR_NATIVEDACOUTVOL),
YMFPCI_DOUBLE("Wave Capture Volume", 0, YDSXGR_NATIVEDACLOOPVOL),
static void snd_ymfpci_mixer_free_ac97_bus(ac97_bus_t *bus)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, bus->private_data, return);
+ ymfpci_t *chip = bus->private_data;
chip->ac97_bus = NULL;
}
static void snd_ymfpci_mixer_free_ac97(ac97_t *ac97)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, ac97->private_data, return);
+ ymfpci_t *chip = ac97->private_data;
chip->ac97 = NULL;
}
int __devinit snd_ymfpci_mixer(ymfpci_t *chip, int rear_switch)
{
- ac97_bus_t bus;
- ac97_t ac97;
+ ac97_template_t ac97;
snd_kcontrol_t *kctl;
unsigned int idx;
int err;
+ static ac97_bus_ops_t ops = {
+ .write = snd_ymfpci_codec_write,
+ .read = snd_ymfpci_codec_read,
+ };
- memset(&bus, 0, sizeof(bus));
- bus.write = snd_ymfpci_codec_write;
- bus.read = snd_ymfpci_codec_read;
- bus.private_data = chip;
- bus.private_free = snd_ymfpci_mixer_free_ac97_bus;
- if ((err = snd_ac97_bus(chip->card, &bus, &chip->ac97_bus)) < 0)
+ if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &chip->ac97_bus)) < 0)
return err;
+ chip->ac97_bus->private_free = snd_ymfpci_mixer_free_ac97_bus;
+ chip->ac97_bus->no_vra = 1; /* YMFPCI doesn't need VRA */
memset(&ac97, 0, sizeof(ac97));
ac97.private_data = chip;
if ((err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97)) < 0)
return err;
- for (idx = 0; idx < YMFPCI_CONTROLS; idx++) {
+ /* to be sure */
+ snd_ac97_update_bits(chip->ac97, AC97_EXTENDED_STATUS,
+ AC97_EA_VRA|AC97_EA_VRM, 0);
+
+ for (idx = 0; idx < ARRAY_SIZE(snd_ymfpci_controls); idx++) {
if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_ymfpci_controls[idx], chip))) < 0)
return err;
}
static void snd_ymfpci_proc_read(snd_info_entry_t *entry,
snd_info_buffer_t * buffer)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, entry->private_data, return);
+ ymfpci_t *chip = entry->private_data;
int i;
snd_iprintf(buffer, "YMFPCI\n\n");
chip->work_size;
/* work_ptr must be aligned to 256 bytes, but it's already
covered with the kernel page allocation mechanism */
- if (snd_dma_alloc_pages(&chip->dma_dev, size, &chip->work_ptr) < 0)
+ if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+ size, &chip->work_ptr) < 0)
return -ENOMEM;
ptr = chip->work_ptr.area;
ptr_addr = chip->work_ptr.addr;
#endif
#ifdef CONFIG_PM
- if (chip->saved_regs)
- vfree(chip->saved_regs);
+ vfree(chip->saved_regs);
#endif
if (chip->mpu_res) {
release_resource(chip->mpu_res);
release_resource(chip->fm_res);
kfree_nocheck(chip->fm_res);
}
-#ifdef SUPPORT_JOYSTICK
- if (chip->joystick_res) {
- if (chip->gameport.io)
- gameport_unregister_port(&chip->gameport);
- release_resource(chip->joystick_res);
- kfree_nocheck(chip->joystick_res);
- }
-#endif
+ snd_ymfpci_free_gameport(chip);
if (chip->reg_area_virt)
- iounmap((void *)chip->reg_area_virt);
+ iounmap(chip->reg_area_virt);
if (chip->work_ptr.area)
- snd_dma_free_pages(&chip->dma_dev, &chip->work_ptr);
+ snd_dma_free_pages(&chip->work_ptr);
if (chip->irq >= 0)
free_irq(chip->irq, (void *)chip);
pci_write_config_word(chip->pci, 0x40, chip->old_legacy_ctrl);
- snd_magic_kfree(chip);
+ pci_disable_device(chip->pci);
+ kfree(chip);
return 0;
}
static int snd_ymfpci_dev_free(snd_device_t *device)
{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, device->device_data, return -ENXIO);
+ ymfpci_t *chip = device->device_data;
return snd_ymfpci_free(chip);
}
};
#define YDSXGR_NUM_SAVED_REGS ARRAY_SIZE(saved_regs_index)
-void snd_ymfpci_suspend(ymfpci_t *chip)
+static int snd_ymfpci_suspend(snd_card_t *card, pm_message_t state)
{
- snd_card_t *card = chip->card;
+ ymfpci_t *chip = card->pm_private_data;
unsigned int i;
- if (card->power_state == SNDRV_CTL_POWER_D3hot)
- return;
snd_pcm_suspend_all(chip->pcm);
snd_pcm_suspend_all(chip->pcm2);
snd_pcm_suspend_all(chip->pcm_spdif);
snd_pcm_suspend_all(chip->pcm_4ch);
+ snd_ac97_suspend(chip->ac97);
for (i = 0; i < YDSXGR_NUM_SAVED_REGS; i++)
chip->saved_regs[i] = snd_ymfpci_readl(chip, saved_regs_index[i]);
chip->saved_ydsxgr_mode = snd_ymfpci_readl(chip, YDSXGR_MODE);
snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
snd_ymfpci_disable_dsp(chip);
- snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+ pci_disable_device(chip->pci);
+ return 0;
}
-void snd_ymfpci_resume(ymfpci_t *chip)
+static int snd_ymfpci_resume(snd_card_t *card)
{
- snd_card_t *card = chip->card;
+ ymfpci_t *chip = card->pm_private_data;
unsigned int i;
- if (card->power_state == SNDRV_CTL_POWER_D0)
- return;
-
pci_enable_device(chip->pci);
pci_set_master(chip->pci);
snd_ymfpci_aclink_reset(chip->pci);
/* start hw again */
if (chip->start_count > 0) {
- unsigned long flags;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
snd_ymfpci_writel(chip, YDSXGR_MODE, chip->saved_ydsxgr_mode);
chip->active_bank = snd_ymfpci_readl(chip, YDSXGR_CTRLSELECT);
- spin_unlock_irqrestore(&chip->reg_lock, flags);
- }
- snd_power_change_state(card, SNDRV_CTL_POWER_D0);
-}
-
-static int snd_ymfpci_set_power_state(snd_card_t *card, unsigned int power_state)
-{
- ymfpci_t *chip = snd_magic_cast(ymfpci_t, card->power_state_private_data, return -ENXIO);
-
- switch (power_state) {
- case SNDRV_CTL_POWER_D0:
- case SNDRV_CTL_POWER_D1:
- case SNDRV_CTL_POWER_D2:
- snd_ymfpci_resume(chip);
- break;
- case SNDRV_CTL_POWER_D3hot:
- case SNDRV_CTL_POWER_D3cold:
- snd_ymfpci_suspend(chip);
- break;
- default:
- return -EINVAL;
+ spin_unlock_irq(&chip->reg_lock);
}
return 0;
}
if ((err = pci_enable_device(pci)) < 0)
return err;
- chip = snd_magic_kcalloc(ymfpci_t, 0, GFP_KERNEL);
- if (chip == NULL)
+ chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
+ if (chip == NULL) {
+ pci_disable_device(pci);
return -ENOMEM;
+ }
chip->old_legacy_ctrl = old_legacy_ctrl;
spin_lock_init(&chip->reg_lock);
spin_lock_init(&chip->voice_lock);
chip->device_id = pci->device;
pci_read_config_byte(pci, PCI_REVISION_ID, (u8 *)&chip->rev);
chip->reg_area_phys = pci_resource_start(pci, 0);
- chip->reg_area_virt = (unsigned long)ioremap_nocache(chip->reg_area_phys, 0x8000);
+ chip->reg_area_virt = ioremap_nocache(chip->reg_area_phys, 0x8000);
pci_set_master(pci);
if ((chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI")) == NULL) {
}
chip->irq = pci->irq;
- memset(&chip->dma_dev, 0, sizeof(chip->dma_dev));
- chip->dma_dev.type = SNDRV_DMA_TYPE_DEV;
- chip->dma_dev.dev = snd_dma_pci_data(pci);
-
snd_ymfpci_aclink_reset(pci);
if (snd_ymfpci_codec_ready(chip, 0) < 0) {
snd_ymfpci_free(chip);
snd_ymfpci_free(chip);
return -ENOMEM;
}
- card->set_power_state = snd_ymfpci_set_power_state;
- card->power_state_private_data = chip;
+ snd_card_set_pm_callback(card, snd_ymfpci_suspend, snd_ymfpci_resume, chip);
#endif
- snd_ymfpci_proc_init(card, chip);
-
if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
snd_ymfpci_free(chip);
return err;
}
+ snd_ymfpci_proc_init(card, chip);
+
snd_card_set_dev(card, &pci->dev);
*rchip = chip;
git://git.onelab.eu / linux-2.6.git / blobdiff