Commit 6f16c19b authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: lx6464es: Allocate resources with device-managed APIs 

This patch converts the resource management in PCI lx6464es 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-42-tiwai@suse.de


Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 098fe3d6

sound/pci/lx6464es/lx6464es.c

+24 −88
Original line number Diff line number Diff line
@@ -524,29 +524,11 @@ static int lx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 
	return lx_pcm_trigger_dispatch(chip, stream, cmd);

}



static int snd_lx6464es_free(struct lx6464es *chip)

static void snd_lx6464es_free(struct snd_card *card)

{

	dev_dbg(chip->card->dev, "->snd_lx6464es_free\n");

	struct lx6464es *chip = card->private_data;



	lx_irq_disable(chip);



	if (chip->irq >= 0)

		free_irq(chip->irq, chip);



	iounmap(chip->port_dsp_bar);

	ioport_unmap(chip->port_plx_remapped);



	pci_release_regions(chip->pci);

	pci_disable_device(chip->pci);



	kfree(chip);



	return 0;

}



static int snd_lx6464es_dev_free(struct snd_device *device)

{

	return snd_lx6464es_free(device->device_data);

}



/* reset the dsp during initialization */
@@ -930,22 +912,15 @@ static int lx_proc_create(struct snd_card *card, struct lx6464es *chip) 




static int snd_lx6464es_create(struct snd_card *card,

			       struct pci_dev *pci,

			       struct lx6464es **rchip)

			       struct pci_dev *pci)

{

	struct lx6464es *chip;

	struct lx6464es *chip = card->private_data;

	int err;



	static const struct snd_device_ops ops = {

		.dev_free = snd_lx6464es_dev_free,

	};



	dev_dbg(card->dev, "->snd_lx6464es_create\n");



	*rchip = NULL;



	/* enable PCI device */

	err = pci_enable_device(pci);

	err = pcim_enable_device(pci);

	if (err < 0)

		return err;
@@ -956,16 +931,9 @@ static int snd_lx6464es_create(struct snd_card *card, 
	if (err < 0) {

		dev_err(card->dev,

			"architecture does not support 32bit PCI busmaster DMA\n");

		pci_disable_device(pci);

		return -ENXIO;

	}



	chip = kzalloc(sizeof(*chip), GFP_KERNEL);

	if (chip == NULL) {

		err = -ENOMEM;

		goto alloc_failed;

	}



	chip->card = card;

	chip->pci = pci;

	chip->irq = -1;
@@ -978,33 +946,30 @@ static int snd_lx6464es_create(struct snd_card *card, 
	/* request resources */

	err = pci_request_regions(pci, card_name);

	if (err < 0)

		goto request_regions_failed;

		return err;



	/* plx port */

	chip->port_plx = pci_resource_start(pci, 1);

	chip->port_plx_remapped = ioport_map(chip->port_plx,

	chip->port_plx_remapped = devm_ioport_map(&pci->dev, chip->port_plx,

						  pci_resource_len(pci, 1));

	if (!chip->port_plx_remapped)

		return -ENOMEM;



	/* dsp port */

	chip->port_dsp_bar = pci_ioremap_bar(pci, 2);

	if (!chip->port_dsp_bar) {

		dev_err(card->dev, "cannot remap PCI memory region\n");

		err = -ENOMEM;

		goto remap_pci_failed;

	}

	chip->port_dsp_bar = pcim_iomap(pci, 2, 0);

	if (!chip->port_dsp_bar)

		return -ENOMEM;



	err = request_threaded_irq(pci->irq, lx_interrupt, lx_threaded_irq,

				   IRQF_SHARED, KBUILD_MODNAME, chip);

	err = devm_request_threaded_irq(&pci->dev, pci->irq, lx_interrupt,

					lx_threaded_irq, IRQF_SHARED,

					KBUILD_MODNAME, chip);

	if (err) {

		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);

		goto request_irq_failed;

		return err;

	}

	chip->irq = pci->irq;

	card->sync_irq = chip->irq;



	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);

	if (err < 0)

		goto device_new_failed;

	card->private_free = snd_lx6464es_free;



	err = lx_init_dsp(chip);

	if (err < 0) {
@@ -1025,25 +990,7 @@ static int snd_lx6464es_create(struct snd_card *card, 
	if (err < 0)

		return err;



	*rchip = chip;

	return 0;



device_new_failed:

	free_irq(pci->irq, chip);



request_irq_failed:

	iounmap(chip->port_dsp_bar);



remap_pci_failed:

	pci_release_regions(pci);



request_regions_failed:

	kfree(chip);



alloc_failed:

	pci_disable_device(pci);



	return err;

}



static int snd_lx6464es_probe(struct pci_dev *pci,
@@ -1063,15 +1010,16 @@ static int snd_lx6464es_probe(struct pci_dev *pci, 
		return -ENOENT;

	}



	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,

			   0, &card);

	err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,

				sizeof(*chip), &card);

	if (err < 0)

		return err;

	chip = card->private_data;



	err = snd_lx6464es_create(card, pci, &chip);

	err = snd_lx6464es_create(card, pci);

	if (err < 0) {

		dev_err(card->dev, "error during snd_lx6464es_create\n");

		goto out_free;

		return err;

	}



	strcpy(card->driver, "LX6464ES");
@@ -1088,30 +1036,18 @@ static int snd_lx6464es_probe(struct pci_dev *pci, 


	err = snd_card_register(card);

	if (err < 0)

		goto out_free;

		return err;



	dev_dbg(chip->card->dev, "initialization successful\n");

	pci_set_drvdata(pci, card);

	dev++;

	return 0;



out_free:

	snd_card_free(card);

	return err;



}



static void snd_lx6464es_remove(struct pci_dev *pci)

{

	snd_card_free(pci_get_drvdata(pci));

}





static struct pci_driver lx6464es_driver = {

	.name =     KBUILD_MODNAME,

	.id_table = snd_lx6464es_ids,

	.probe =    snd_lx6464es_probe,

	.remove = snd_lx6464es_remove,

};



module_pci_driver(lx6464es_driver);