Skip to content

Commit

Permalink
ALSA: nm256: Allocate resources with device-managed APIs
Browse files Browse the repository at this point in the history 
This patch converts the resource management in PCI nm256 driver with
devres as a clean up.  Each manual resource management is converted
with the corresponding devres helper, and the card object release is
managed now via card->private_free instead of a lowlevel snd_device.

This should give no user-visible functional changes.

Link: https://lore.kernel.org/r/20210715075941.23332-43-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
  • Loading branch information
@tiwai
tiwai committed Jul 19, 2021
1 parent 6f16c19 commit c19935f
Showing 1 changed file with 30 additions and 100 deletions.
130 changes: 30 additions & 100 deletions sound/pci/nm256/nm256.c
View file
Expand Up @@ -193,11 +193,9 @@ struct nm256 {
struct snd_card *card;

void __iomem *cport; /* control port */
struct resource *res_cport; /* its resource */
unsigned long cport_addr; /* physical address */

void __iomem *buffer; /* buffer */
struct resource *res_buffer; /* its resource */
unsigned long buffer_addr; /* buffer phyiscal address */

u32 buffer_start; /* start offset from pci resource 0 */
Expand Down Expand Up @@ -1313,8 +1311,9 @@ snd_nm256_mixer(struct nm256 *chip)
.read = snd_nm256_ac97_read,
};

chip->ac97_regs = kcalloc(ARRAY_SIZE(nm256_ac97_init_val),
sizeof(short), GFP_KERNEL);
chip->ac97_regs = devm_kcalloc(chip->card->dev,
ARRAY_SIZE(nm256_ac97_init_val),
sizeof(short), GFP_KERNEL);
if (! chip->ac97_regs)
return -ENOMEM;

Expand Down Expand Up @@ -1437,56 +1436,27 @@ static SIMPLE_DEV_PM_OPS(nm256_pm, nm256_suspend, nm256_resume);
#define NM256_PM_OPS NULL
#endif /* CONFIG_PM_SLEEP */

static int snd_nm256_free(struct nm256 *chip)
static void snd_nm256_free(struct snd_card *card)
{
struct nm256 *chip = card->private_data;

if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
snd_nm256_playback_stop(chip);
if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
snd_nm256_capture_stop(chip);

if (chip->irq >= 0)
free_irq(chip->irq, chip);

iounmap(chip->cport);
iounmap(chip->buffer);
release_and_free_resource(chip->res_cport);
release_and_free_resource(chip->res_buffer);

pci_disable_device(chip->pci);
kfree(chip->ac97_regs);
kfree(chip);
return 0;
}

static int snd_nm256_dev_free(struct snd_device *device)
{
struct nm256 *chip = device->device_data;
return snd_nm256_free(chip);
}

static int
snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
struct nm256 **chip_ret)
snd_nm256_create(struct snd_card *card, struct pci_dev *pci)
{
struct nm256 *chip;
struct nm256 *chip = card->private_data;
int err, pval;
static const struct snd_device_ops ops = {
.dev_free = snd_nm256_dev_free,
};
u32 addr;

*chip_ret = NULL;

err = pci_enable_device(pci);
err = pcim_enable_device(pci);
if (err < 0)
return err;

chip = kzalloc(sizeof(*chip), GFP_KERNEL);
if (chip == NULL) {
pci_disable_device(pci);
return -ENOMEM;
}

chip->card = card;
chip->pci = pci;
chip->use_cache = use_cache;
Expand All @@ -1508,22 +1478,16 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
chip->buffer_addr = pci_resource_start(pci, 0);
chip->cport_addr = pci_resource_start(pci, 1);

if (pci_request_regions(pci, card->driver))
return err;

/* Init the memory port info. */
/* remap control port (#2) */
chip->res_cport = request_mem_region(chip->cport_addr, NM_PORT2_SIZE,
card->driver);
if (chip->res_cport == NULL) {
dev_err(card->dev, "memory region 0x%lx (size 0x%x) busy\n",
chip->cport_addr, NM_PORT2_SIZE);
err = -EBUSY;
goto __error;
}
chip->cport = ioremap(chip->cport_addr, NM_PORT2_SIZE);
if (chip->cport == NULL) {
chip->cport = devm_ioremap(&pci->dev, chip->cport_addr, NM_PORT2_SIZE);
if (!chip->cport) {
dev_err(card->dev, "unable to map control port %lx\n",
chip->cport_addr);
err = -ENOMEM;
goto __error;
return -ENOMEM;
}

if (!strcmp(card->driver, "NM256AV")) {
Expand All @@ -1539,8 +1503,7 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
" force_ac97=1\n");
dev_err(card->dev,
"or try sb16, opl3sa2, or cs423x drivers instead.\n");
err = -ENXIO;
goto __error;
return -ENXIO;
}
}
chip->buffer_end = 2560 * 1024;
Expand Down Expand Up @@ -1572,7 +1535,7 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
/* get buffer end pointer from signature */
err = snd_nm256_peek_for_sig(chip);
if (err < 0)
goto __error;
return err;
}

chip->buffer_start = chip->buffer_end - chip->buffer_size;
Expand All @@ -1581,21 +1544,12 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
dev_info(card->dev, "Mapping port 1 from 0x%x - 0x%x\n",
chip->buffer_start, chip->buffer_end);

chip->res_buffer = request_mem_region(chip->buffer_addr,
chip->buffer_size,
card->driver);
if (chip->res_buffer == NULL) {
dev_err(card->dev, "buffer 0x%lx (size 0x%x) busy\n",
chip->buffer_addr, chip->buffer_size);
err = -EBUSY;
goto __error;
}
chip->buffer = ioremap(chip->buffer_addr, chip->buffer_size);
if (chip->buffer == NULL) {
err = -ENOMEM;
chip->buffer = devm_ioremap(&pci->dev, chip->buffer_addr,
chip->buffer_size);
if (!chip->buffer) {
dev_err(card->dev, "unable to map ring buffer at %lx\n",
chip->buffer_addr);
goto __error;
return -ENOMEM;
}

/* set offsets */
Expand All @@ -1618,19 +1572,10 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
chip->coeffs_current = 0;

snd_nm256_init_chip(chip);
card->private_free = snd_nm256_free;

// pci_set_master(pci); /* needed? */

err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
if (err < 0)
goto __error;

*chip_ret = chip;
return 0;

__error:
snd_nm256_free(chip);
return err;
}


Expand Down Expand Up @@ -1673,9 +1618,11 @@ static int snd_nm256_probe(struct pci_dev *pci,
}
}

err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
sizeof(*chip), &card);
if (err < 0)
return err;
chip = card->private_data;

switch (pci->device) {
case PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO:
Expand All @@ -1689,7 +1636,6 @@ static int snd_nm256_probe(struct pci_dev *pci,
break;
default:
dev_err(&pci->dev, "invalid device id 0x%x\n", pci->device);
snd_card_free(card);
return -EINVAL;
}

Expand All @@ -1704,12 +1650,9 @@ static int snd_nm256_probe(struct pci_dev *pci,
capture_bufsize = 4;
if (capture_bufsize > 128)
capture_bufsize = 128;
err = snd_nm256_create(card, pci, &chip);
if (err < 0) {
snd_card_free(card);
err = snd_nm256_create(card, pci);
if (err < 0)
return err;
}
card->private_data = chip;

if (reset_workaround) {
dev_dbg(&pci->dev, "reset_workaround activated\n");
Expand All @@ -1722,42 +1665,29 @@ static int snd_nm256_probe(struct pci_dev *pci,
}

err = snd_nm256_pcm(chip, 0);
if (err < 0) {
snd_card_free(card);
if (err < 0)
return err;
}
err = snd_nm256_mixer(chip);
if (err < 0) {
snd_card_free(card);
if (err < 0)
return err;
}

sprintf(card->shortname, "NeoMagic %s", card->driver);
sprintf(card->longname, "%s at 0x%lx & 0x%lx, irq %d",
card->shortname,
chip->buffer_addr, chip->cport_addr, chip->irq);

err = snd_card_register(card);
if (err < 0) {
snd_card_free(card);
if (err < 0)
return err;
}

pci_set_drvdata(pci, card);
return 0;
}

static void snd_nm256_remove(struct pci_dev *pci)
{
snd_card_free(pci_get_drvdata(pci));
}


static struct pci_driver nm256_driver = {
.name = KBUILD_MODNAME,
.id_table = snd_nm256_ids,
.probe = snd_nm256_probe,
.remove = snd_nm256_remove,
.driver = {
.pm = NM256_PM_OPS,
},
Expand Down

0 comments on commit c19935f

Please sign in to comment.