#include <asm/io.h>
-#define chip_t trident_t
-
static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs);
unsigned int data = 0, treg;
unsigned short count = 0xffff;
unsigned long flags;
- trident_t *trident = snd_magic_cast(trident_t, ac97->private_data, return -ENXIO);
+ trident_t *trident = ac97->private_data;
spin_lock_irqsave(&trident->reg_lock, flags);
if (trident->device == TRIDENT_DEVICE_ID_DX) {
unsigned int address, data;
unsigned short count = 0xffff;
unsigned long flags;
- trident_t *trident = snd_magic_cast(trident_t, ac97->private_data, return);
+ trident_t *trident = ac97->private_data;
data = ((unsigned long) wdata) << 16;
snd_trident_voice_t *evoice = voice->extra;
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number];
- spin_lock(&trident->reg_lock);
+ spin_lock_irq(&trident->reg_lock);
/* set delta (rate) value */
voice->Delta = snd_trident_convert_rate(runtime->rate);
evoice->ESO = (runtime->period_size * 2) - 1;
}
- spin_unlock(&trident->reg_lock);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
unsigned int val, ESO_bytes;
- spin_lock(&trident->reg_lock);
+ spin_lock_irq(&trident->reg_lock);
// Initilize the channel and set channel Mode
outb(0, TRID_REG(trident, LEGACY_DMAR15));
snd_trident_write_voice_regs(trident, voice);
- spin_unlock(&trident->reg_lock);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
snd_trident_voice_t *evoice = voice->extra;
- spin_lock(&trident->reg_lock);
+ spin_lock_irq(&trident->reg_lock);
voice->LBA = runtime->dma_addr;
voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
evoice->ESO = (runtime->period_size * 2) - 1;
}
- spin_unlock(&trident->reg_lock);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
snd_trident_voice_t *evoice = voice->extra;
- spin_lock(&trident->reg_lock);
+ spin_lock_irq(&trident->reg_lock);
/* Set channel buffer Address */
if (voice->memblk)
evoice->ESO = (runtime->period_size * 2) - 1;
}
- spin_unlock(&trident->reg_lock);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
unsigned int RESO, LBAO;
unsigned int temp;
- spin_lock(&trident->reg_lock);
+ spin_lock_irq(&trident->reg_lock);
if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
}
- spin_unlock(&trident->reg_lock);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
snd_pcm_group_for_each(pos, substream) {
s = snd_pcm_group_substream_entry(pos);
- if ((trident_t *) _snd_pcm_chip(s->pcm) == trident) {
+ if ((trident_t *) snd_pcm_substream_chip(s) == trident) {
voice = (snd_trident_voice_t *) s->runtime->private_data;
evoice = voice->extra;
what |= 1 << (voice->number & 0x1f);
---------------------------------------------------------------------------*/
static void snd_trident_pcm_free(snd_pcm_t *pcm)
{
- trident_t *trident = snd_magic_cast(trident_t, pcm->private_data, return);
+ trident_t *trident = pcm->private_data;
trident->pcm = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
static void snd_trident_foldback_pcm_free(snd_pcm_t *pcm)
{
- trident_t *trident = snd_magic_cast(trident_t, pcm->private_data, return);
+ trident_t *trident = pcm->private_data;
trident->foldback = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
static void snd_trident_spdif_pcm_free(snd_pcm_t *pcm)
{
- trident_t *trident = snd_magic_cast(trident_t, pcm->private_data, return);
+ trident_t *trident = pcm->private_data;
trident->spdif = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned char val;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
val = trident->spdif_ctrl;
ucontrol->value.integer.value[0] = val == kcontrol->private_value;
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned char val;
int change;
val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
/* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
change = trident->spdif_ctrl != val;
trident->spdif_ctrl = val;
outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
}
}
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int val;
int change;
(ucontrol->value.iec958.status[1] << 8) |
(ucontrol->value.iec958.status[2] << 16) |
(ucontrol->value.iec958.status[3] << 24);
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = trident->spdif_bits != val;
trident->spdif_bits = val;
if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
if (trident->spdif == NULL)
outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
}
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned int val;
int change;
(ucontrol->value.iec958.status[1] << 8) |
(ucontrol->value.iec958.status[2] << 16) |
(ucontrol->value.iec958.status[3] << 24);
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = trident->spdif_pcm_bits != val;
trident->spdif_pcm_bits = val;
if (trident->spdif != NULL) {
outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
}
}
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned char val;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
trident_t *trident = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
unsigned char val;
int change = 0;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
val &= ~(1 << kcontrol->private_value);
if (ucontrol->value.integer.value[0])
change = val != trident->ac97_ctrl;
trident->ac97_ctrl = val;
outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol,
snd_ctl_elem_value_t * ucontrol)
{
- unsigned long flags;
trident_t *trident = snd_kcontrol_chip(kcontrol);
unsigned int val;
int change = 0;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
val = trident->musicvol_wavevol;
val &= ~(0xffff << kcontrol->private_value);
val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
change = val != trident->musicvol_wavevol;
outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol,
snd_ctl_elem_value_t * ucontrol)
{
- unsigned long flags;
trident_t *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned int val;
} else {
val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
}
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = val != mix->vol;
mix->vol = val;
if (mix->voice != NULL)
snd_trident_write_vol_reg(trident, mix->voice, val);
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol,
snd_ctl_elem_value_t * ucontrol)
{
- unsigned long flags;
trident_t *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned char val;
val = ucontrol->value.integer.value[0] & 0x3f;
else
val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = val != mix->pan;
mix->pan = val;
if (mix->voice != NULL)
snd_trident_write_pan_reg(trident, mix->voice, val);
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol,
snd_ctl_elem_value_t * ucontrol)
{
- unsigned long flags;
trident_t *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned short val;
int change = 0;
val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = val != mix->rvol;
mix->rvol = val;
if (mix->voice != NULL)
snd_trident_write_rvol_reg(trident, mix->voice, val);
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol,
snd_ctl_elem_value_t * ucontrol)
{
- unsigned long flags;
trident_t *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned short val;
int change = 0;
val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
- spin_lock_irqsave(&trident->reg_lock, flags);
+ spin_lock_irq(&trident->reg_lock);
change = val != mix->cvol;
mix->cvol = val;
if (mix->voice != NULL)
snd_trident_write_cvol_reg(trident, mix->voice, val);
- spin_unlock_irqrestore(&trident->reg_lock, flags);
+ spin_unlock_irq(&trident->reg_lock);
return change;
}
static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device)
{
- ac97_bus_t _bus;
- ac97_t _ac97;
+ ac97_template_t _ac97;
snd_card_t * card = trident->card;
snd_kcontrol_t *kctl;
snd_ctl_elem_value_t *uctl;
int idx, err, retries = 2;
+ static ac97_bus_ops_t ops = {
+ .write = snd_trident_codec_write,
+ .read = snd_trident_codec_read,
+ };
- uctl = (snd_ctl_elem_value_t *)snd_kcalloc(sizeof(*uctl), GFP_KERNEL);
+ uctl = kcalloc(1, sizeof(*uctl), GFP_KERNEL);
if (!uctl)
return -ENOMEM;
- memset(&_bus, 0, sizeof(_bus));
- _bus.write = snd_trident_codec_write;
- _bus.read = snd_trident_codec_read;
- if ((err = snd_ac97_bus(trident->card, &_bus, &trident->ac97_bus)) < 0)
+ if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
goto __out;
memset(&_ac97, 0, sizeof(_ac97));
trident_gameport_t *gp = (trident_gameport_t *)gameport;
trident_t *chip;
snd_assert(gp, return 0);
- chip = snd_magic_cast(trident_t, gp->chip, return 0);
+ chip = gp->chip;
return inb(TRID_REG(chip, GAMEPORT_LEGACY));
}
trident_gameport_t *gp = (trident_gameport_t *)gameport;
trident_t *chip;
snd_assert(gp, return);
- chip = snd_magic_cast(trident_t, gp->chip, return);
+ chip = gp->chip;
outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
}
int i;
snd_assert(gp, return 0);
- chip = snd_magic_cast(trident_t, gp->chip, return 0);
+ chip = gp->chip;
*buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
trident_gameport_t *gp = (trident_gameport_t *)gameport;
trident_t *chip;
snd_assert(gp, return -1);
- chip = snd_magic_cast(trident_t, gp->chip, return -1);
+ chip = gp->chip;
switch (mode) {
case GAMEPORT_MODE_COOKED:
static void snd_trident_proc_read(snd_info_entry_t *entry,
snd_info_buffer_t * buffer)
{
- trident_t *trident = snd_magic_cast(trident_t, entry->private_data, return);
+ trident_t *trident = entry->private_data;
char *s;
switch (trident->device) {
static int snd_trident_dev_free(snd_device_t *device)
{
- trident_t *trident = snd_magic_cast(trident_t, device->device_data, return -ENXIO);
+ trident_t *trident = device->device_data;
return snd_trident_free(trident);
}
/* TLB array must be aligned to 16kB !!! so we allocate
32kB region and correct offset when necessary */
- if (snd_dma_alloc_pages(&trident->dma_dev, 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
+ if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+ 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
return -ENOMEM;
}
return -ENOMEM;
}
/* allocate and setup silent page and initialise TLB entries */
- if (snd_dma_alloc_pages(&trident->dma_dev, SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
+ if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+ SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
snd_printk(KERN_ERR "trident: unable to allocate silent page\n");
return -ENOMEM;
}
return -ENXIO;
}
- trident = snd_magic_kcalloc(trident_t, 0, GFP_KERNEL);
+ trident = kcalloc(1, sizeof(*trident), GFP_KERNEL);
if (trident == NULL)
return -ENOMEM;
trident->device = (pci->vendor << 16) | pci->device;
if (max_wavetable_size < 0 )
max_wavetable_size = 0;
trident->synth.max_size = max_wavetable_size * 1024;
- trident->port = pci_resource_start(pci, 0);
trident->irq = -1;
trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
pci_set_master(pci);
- trident->port = pci_resource_start(pci, 0);
- if ((trident->res_port = request_region(trident->port, 0x100, "Trident Audio")) == NULL) {
- snd_printk("unable to grab I/O region 0x%lx-0x%lx\n", trident->port, trident->port + 0x100 - 1);
- snd_trident_free(trident);
- return -EBUSY;
+ if ((err = pci_request_regions(pci, "Trident Audio")) < 0) {
+ kfree(trident);
+ return err;
}
+ trident->port = pci_resource_start(pci, 0);
+
if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, "Trident Audio", (void *) trident)) {
snd_printk("unable to grab IRQ %d\n", pci->irq);
snd_trident_free(trident);
}
trident->irq = pci->irq;
- memset(&trident->dma_dev, 0, sizeof(trident->dma_dev));
- trident->dma_dev.type = SNDRV_DMA_TYPE_DEV;
- trident->dma_dev.dev = snd_dma_pci_data(pci);
-
/* allocate 16k-aligned TLB for NX cards */
trident->tlb.entries = NULL;
trident->tlb.buffer.area = NULL;
if (trident->tlb.memhdr)
snd_util_memhdr_free(trident->tlb.memhdr);
if (trident->tlb.silent_page.area)
- snd_dma_free_pages(&trident->dma_dev, &trident->tlb.silent_page);
+ snd_dma_free_pages(&trident->tlb.silent_page);
if (trident->tlb.shadow_entries)
vfree(trident->tlb.shadow_entries);
- snd_dma_free_pages(&trident->dma_dev, &trident->tlb.buffer);
+ snd_dma_free_pages(&trident->tlb.buffer);
}
if (trident->irq >= 0)
free_irq(trident->irq, (void *)trident);
- if (trident->res_port) {
- release_resource(trident->res_port);
- kfree_nocheck(trident->res_port);
- }
- snd_magic_kfree(trident);
+ pci_release_regions(trident->pci);
+ kfree(trident);
return 0;
}
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
- trident_t *trident = snd_magic_cast(trident_t, dev_id, return IRQ_NONE);
+ trident_t *trident = dev_id;
unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
int delta;
snd_trident_voice_t *voice;
#ifdef CONFIG_PM
static int snd_trident_suspend(snd_card_t *card, unsigned int state)
{
- trident_t *trident = snd_magic_cast(trident_t, card->pm_private_data, return -EINVAL);
+ trident_t *trident = card->pm_private_data;
trident->in_suspend = 1;
snd_pcm_suspend_all(trident->pcm);
static int snd_trident_resume(snd_card_t *card, unsigned int state)
{
- trident_t *trident = snd_magic_cast(trident_t, card->pm_private_data, return -EINVAL);
+ trident_t *trident = card->pm_private_data;
pci_enable_device(trident->pci);
if (pci_set_dma_mask(trident->pci, 0x3fffffff) < 0 ||
git://git.onelab.eu / linux-2.6.git / blobdiff