This is a preparation for allowing devres usages more widely in various sound drivers. As a first step, this patch adds a new allocator function, snd_devm_alloc_pages(), to manage the allocated pages via devres, so that the pages will be automagically released as device unbinding.

Unlike the old snd_dma_alloc_pages(), the new function returns directly the snd_dma_buffer pointer. The caller needs NULL-check for the allocation error appropriately.

Also, since a real device pointer is mandatory for devres, SNDRV_DMA_TYPE_CONTINUOUS or SNDRV_DMA_TYPE_VMALLOC type can't be used for this function.

Signed-off-by: Takashi Iwai tiwai@suse.de --- include/sound/memalloc.h | 4 ++++ sound/core/memalloc.c | 46 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+)

diff --git a/include/sound/memalloc.h b/include/sound/memalloc.h index 44d87775b352..d22c9387b2ba 100644 --- a/include/sound/memalloc.h +++ b/include/sound/memalloc.h @@ -79,5 +79,9 @@ struct page *snd_sgbuf_get_page(struct snd_dma_buffer *dmab, size_t offset); unsigned int snd_sgbuf_get_chunk_size(struct snd_dma_buffer *dmab, unsigned int ofs, unsigned int size);

+/* device-managed memory allocator */ +struct snd_dma_buffer *snd_devm_alloc_pages(struct device *dev, int type, + size_t size); + #endif /* __SOUND_MEMALLOC_H */

diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c index 83b79edfa52d..3a78fdad1ab4 100644 --- a/sound/core/memalloc.c +++ b/sound/core/memalloc.c @@ -127,6 +127,52 @@ void snd_dma_free_pages(struct snd_dma_buffer *dmab) } EXPORT_SYMBOL(snd_dma_free_pages);

+/* called by devres */ +static void __snd_release_pages(struct device *dev, void *res) +{ + snd_dma_free_pages(res); +} + +/** + * snd_devm_alloc_pages - allocate the buffer and manage with devres + * @dev: the device pointer + * @type: the DMA buffer type + * @size: the buffer size to allocate + * + * Allocate buffer pages depending on the given type and manage using devres. + * The pages will be released automatically at the device removal. + * + * Unlike snd_dma_alloc_pages(), this function requires the real device pointer, + * hence it can't work with SNDRV_DMA_TYPE_CONTINUOUS or + * SNDRV_DMA_TYPE_VMALLOC type. + * + * The function returns the snd_dma_buffer object at success, or NULL if failed. + */ +struct snd_dma_buffer * +snd_devm_alloc_pages(struct device *dev, int type, size_t size) +{ + struct snd_dma_buffer *dmab; + int err; + + if (WARN_ON(type == SNDRV_DMA_TYPE_CONTINUOUS || + type == SNDRV_DMA_TYPE_VMALLOC)) + return NULL; + + dmab = devres_alloc(__snd_release_pages, sizeof(*dmab), GFP_KERNEL); + if (!dmab) + return NULL; + + err = snd_dma_alloc_pages(type, dev, size, dmab); + if (err < 0) { + devres_free(dmab); + return NULL; + } + + devres_add(dev, dmab); + return dmab; +} +EXPORT_SYMBOL_GPL(snd_devm_alloc_pages); + /** * snd_dma_buffer_mmap - perform mmap of the given DMA buffer * @dmab: buffer allocation information

Like the previous patch, this patch converts the resource allocations with device-managed API calls, so that we can reduce resource-free calls.

The atiixp drivers are simpler than intel8x0, and even the irq can be allocated with devres.

The end result is a good amount of code reduction.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/atiixp.c | 92 +++++++++------------------------------- sound/pci/atiixp_modem.c | 92 +++++++++------------------------------- 2 files changed, 40 insertions(+), 144 deletions(-)

diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c index 5f8aa35c4bea..b8e035d5930d 100644 --- a/sound/pci/atiixp.c +++ b/sound/pci/atiixp.c @@ -1530,87 +1530,44 @@ static void snd_atiixp_proc_init(struct atiixp *chip) * destructor */

-static int snd_atiixp_free(struct atiixp *chip) +static void snd_atiixp_free(struct snd_card *card) { - if (chip->irq < 0) - goto __hw_end; - snd_atiixp_chip_stop(chip); - - __hw_end: - if (chip->irq >= 0) - free_irq(chip->irq, chip); - iounmap(chip->remap_addr); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_atiixp_dev_free(struct snd_device *device) -{ - struct atiixp *chip = device->device_data; - return snd_atiixp_free(chip); + snd_atiixp_chip_stop(card->private_data); }

/* * constructor for chip instance */ -static int snd_atiixp_create(struct snd_card *card, - struct pci_dev *pci, - struct atiixp **r_chip) +static int snd_atiixp_init(struct snd_card *card, struct pci_dev *pci) { - static const struct snd_device_ops ops = { - .dev_free = snd_atiixp_dev_free, - }; - struct atiixp *chip; + struct atiixp *chip = card->private_data; int err;

- 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; - } - spin_lock_init(&chip->reg_lock); mutex_init(&chip->open_mutex); chip->card = card; chip->pci = pci; chip->irq = -1; - err = pci_request_regions(pci, "ATI IXP AC97"); - if (err < 0) { - pci_disable_device(pci); - kfree(chip); + err = pcim_iomap_regions(pci, 1 << 0, "ATI IXP AC97"); + if (err < 0) return err; - } chip->addr = pci_resource_start(pci, 0); - chip->remap_addr = pci_ioremap_bar(pci, 0); - if (chip->remap_addr == NULL) { - dev_err(card->dev, "AC'97 space ioremap problem\n"); - snd_atiixp_free(chip); - return -EIO; - } + chip->remap_addr = pcim_iomap_table(pci)[0];

- if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED, - KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_atiixp_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_atiixp_free; pci_set_master(pci);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_atiixp_free(chip); - return err; - } - - *r_chip = chip; return 0; }

@@ -1622,30 +1579,31 @@ static int snd_atiixp_probe(struct pci_dev *pci, struct atiixp *chip; int err;

- 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;

strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA"); strcpy(card->shortname, "ATI IXP"); - err = snd_atiixp_create(card, pci, &chip); + err = snd_atiixp_init(card, pci); if (err < 0) - goto __error; - card->private_data = chip; + return err;

err = snd_atiixp_aclink_reset(chip); if (err < 0) - goto __error; + return err;

chip->spdif_over_aclink = spdif_aclink;

err = snd_atiixp_mixer_new(chip, ac97_clock, ac97_quirk); if (err < 0) - goto __error; + return err;

err = snd_atiixp_pcm_new(chip); if (err < 0) - goto __error; + return err; snd_atiixp_proc_init(chip);

@@ -1659,26 +1617,16 @@ static int snd_atiixp_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto __error; + return err;

pci_set_drvdata(pci, card); return 0; - - __error: - snd_card_free(card); - return err; -} - -static void snd_atiixp_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver atiixp_driver = { .name = KBUILD_MODNAME, .id_table = snd_atiixp_ids, .probe = snd_atiixp_probe, - .remove = snd_atiixp_remove, .driver = { .pm = SND_ATIIXP_PM_OPS, }, diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c index 9739c3a82777..178dce8ef1e9 100644 --- a/sound/pci/atiixp_modem.c +++ b/sound/pci/atiixp_modem.c @@ -1159,87 +1159,44 @@ static void snd_atiixp_proc_init(struct atiixp_modem *chip) * destructor */

-static int snd_atiixp_free(struct atiixp_modem *chip) +static void snd_atiixp_free(struct snd_card *card) { - if (chip->irq < 0) - goto __hw_end; - snd_atiixp_chip_stop(chip); - - __hw_end: - if (chip->irq >= 0) - free_irq(chip->irq, chip); - iounmap(chip->remap_addr); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_atiixp_dev_free(struct snd_device *device) -{ - struct atiixp_modem *chip = device->device_data; - return snd_atiixp_free(chip); + snd_atiixp_chip_stop(card->private_data); }

/* * constructor for chip instance */ -static int snd_atiixp_create(struct snd_card *card, - struct pci_dev *pci, - struct atiixp_modem **r_chip) +static int snd_atiixp_init(struct snd_card *card, struct pci_dev *pci) { - static const struct snd_device_ops ops = { - .dev_free = snd_atiixp_dev_free, - }; - struct atiixp_modem *chip; + struct atiixp_modem *chip = card->private_data; int err;

- 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; - } - spin_lock_init(&chip->reg_lock); mutex_init(&chip->open_mutex); chip->card = card; chip->pci = pci; chip->irq = -1; - err = pci_request_regions(pci, "ATI IXP MC97"); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + err = pcim_iomap_regions(pci, 1 << 0, "ATI IXP MC97"); + if (err < 0) return err; - } chip->addr = pci_resource_start(pci, 0); - chip->remap_addr = pci_ioremap_bar(pci, 0); - if (chip->remap_addr == NULL) { - dev_err(card->dev, "AC'97 space ioremap problem\n"); - snd_atiixp_free(chip); - return -EIO; - } + chip->remap_addr = pcim_iomap_table(pci)[0];

- if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED, - KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_atiixp_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_atiixp_free; pci_set_master(pci);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_atiixp_free(chip); - return err; - } - - *r_chip = chip; return 0; }

@@ -1251,28 +1208,29 @@ static int snd_atiixp_probe(struct pci_dev *pci, struct atiixp_modem *chip; int err;

- 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;

strcpy(card->driver, "ATIIXP-MODEM"); strcpy(card->shortname, "ATI IXP Modem"); - err = snd_atiixp_create(card, pci, &chip); + err = snd_atiixp_init(card, pci); if (err < 0) - goto __error; - card->private_data = chip; + return err;

err = snd_atiixp_aclink_reset(chip); if (err < 0) - goto __error; + return err;

err = snd_atiixp_mixer_new(chip, ac97_clock); if (err < 0) - goto __error; + return err;

err = snd_atiixp_pcm_new(chip); if (err < 0) - goto __error; + return err; snd_atiixp_proc_init(chip);

@@ -1283,26 +1241,16 @@ static int snd_atiixp_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto __error; + return err;

pci_set_drvdata(pci, card); return 0; - - __error: - snd_card_free(card); - return err; -} - -static void snd_atiixp_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver atiixp_modem_driver = { .name = KBUILD_MODNAME, .id_table = snd_atiixp_ids, .probe = snd_atiixp_probe, - .remove = snd_atiixp_remove, .driver = { .pm = SND_ATIIXP_PM_OPS, },

Give brief explanations about the device-managed resources and the newly introduced snd_devm_card_new() helper.

Signed-off-by: Takashi Iwai tiwai@suse.de --- .../kernel-api/writing-an-alsa-driver.rst | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+)

diff --git a/Documentation/sound/kernel-api/writing-an-alsa-driver.rst b/Documentation/sound/kernel-api/writing-an-alsa-driver.rst index 01d59b8aea92..255b7d3bebd6 100644 --- a/Documentation/sound/kernel-api/writing-an-alsa-driver.rst +++ b/Documentation/sound/kernel-api/writing-an-alsa-driver.rst @@ -4172,6 +4172,39 @@ module license as GPL, etc., otherwise the system is shown as “tainted”. MODULE_LICENSE("GPL");

+Device-Managed Resources +======================== + +In the examples above, all resources are allocated and released +manually. But human beings are lazy in nature, especially developers +are lazier. So there are some ways to automate the release part; it's +the (device-)managed resources aka devres or devm family. For +example, an object allocated via :c:func:`devm_kmalloc()` will be +freed automatically at unbinding the device. + +ALSA core provides also the device-managed helper, namely, +:c:func:`snd_devm_card_new()` for creating a card object. +Call this functions instead of the normal :c:func:`snd_card_new()`, +and you can forget the explicit :c:func:`snd_card_free()` call, as +it's called automagically at error and removal paths. + +One caveat is that the call of :c:func:`snd_card_free()` would be put +at the beginning of the call chain only after you call +:c:func:`snd_card_register()`. + +Also, the ``private_free`` callback is always called at the card free, +so be careful to put the hardware clean-up procedure in +``private_free`` callback. It might be called even before you +actually set up at an earlier error path. For avoiding such an +invalid initialization, you can set ``private_free`` callback after +:c:func:`snd_card_register()` call succeeds. + +Another thing to be remarked is that you should use device-managed +helpers for each component as much as possible once when you manage +the card in that way. Mixing up with the normal and the managed +resources may screw up the release order. + + How To Put Your Driver Into ALSA Tree =====================================

This patch converts the resource management in PCI als300 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/als300.c | 79 ++++++++++------------------------------------ 1 file changed, 17 insertions(+), 62 deletions(-)

diff --git a/sound/pci/als300.c b/sound/pci/als300.c index 668008fc21f7..9c94072572a5 100644 --- a/sound/pci/als300.c +++ b/sound/pci/als300.c @@ -163,21 +163,11 @@ static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd) snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp); }

-static int snd_als300_free(struct snd_als300 *chip) +static void snd_als300_free(struct snd_card *card) { - snd_als300_set_irq_flag(chip, IRQ_DISABLE); - if (chip->irq >= 0) - free_irq(chip->irq, chip); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} + struct snd_als300 *chip = card->private_data;

-static int snd_als300_dev_free(struct snd_device *device) -{ - struct snd_als300 *chip = device->device_data; - return snd_als300_free(chip); + snd_als300_set_irq_flag(chip, IRQ_DISABLE); }

static irqreturn_t snd_als300_interrupt(int irq, void *dev_id) @@ -248,11 +238,6 @@ static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id) return IRQ_HANDLED; }

-static void snd_als300_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static unsigned short snd_als300_ac97_read(struct snd_ac97 *ac97, unsigned short reg) { @@ -610,35 +595,22 @@ static void snd_als300_init(struct snd_als300 *chip) }

static int snd_als300_create(struct snd_card *card, - struct pci_dev *pci, int chip_type, - struct snd_als300 **rchip) + struct pci_dev *pci, int chip_type) { - struct snd_als300 *chip; + struct snd_als300 *chip = card->private_data; void *irq_handler; int err;

- static const struct snd_device_ops ops = { - .dev_free = snd_als300_dev_free, - }; - *rchip = NULL; - - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err;

if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28))) { dev_err(card->dev, "error setting 28bit DMA mask\n"); - pci_disable_device(pci); return -ENXIO; } pci_set_master(pci);

- chip = kzalloc(sizeof(*chip), GFP_KERNEL); - if (chip == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } - chip->card = card; chip->pci = pci; chip->irq = -1; @@ -646,11 +618,9 @@ static int snd_als300_create(struct snd_card *card, spin_lock_init(&chip->reg_lock);

err = pci_request_regions(pci, "ALS300"); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + if (err < 0) return err; - } + chip->port = pci_resource_start(pci, 0);

if (chip->chip_type == DEVICE_ALS300_PLUS) @@ -658,38 +628,29 @@ static int snd_als300_create(struct snd_card *card, else irq_handler = snd_als300_interrupt;

- if (request_irq(pci->irq, irq_handler, IRQF_SHARED, - KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, irq_handler, IRQF_SHARED, + KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_als300_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_als300_free;

snd_als300_init(chip);

err = snd_als300_ac97(chip); if (err < 0) { dev_err(card->dev, "Could not create ac97\n"); - snd_als300_free(chip); return err; }

err = snd_als300_new_pcm(chip); if (err < 0) { dev_err(card->dev, "Could not create PCM\n"); - snd_als300_free(chip); - return err; - } - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_als300_free(chip); return err; }

- *rchip = chip; return 0; }

@@ -737,20 +698,16 @@ static int snd_als300_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_type = pci_id->driver_data;

- err = snd_als300_create(card, pci, chip_type, &chip); - if (err < 0) { - snd_card_free(card); + err = snd_als300_create(card, pci, chip_type); + if (err < 0) return err; - } - card->private_data = chip;

strcpy(card->driver, "ALS300"); if (chip->chip_type == DEVICE_ALS300_PLUS) @@ -764,10 +721,9 @@ static int snd_als300_probe(struct pci_dev *pci, card->shortname, chip->port, chip->irq);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } + pci_set_drvdata(pci, card); dev++; return 0; @@ -777,7 +733,6 @@ static struct pci_driver als300_driver = { .name = KBUILD_MODNAME, .id_table = snd_als300_ids, .probe = snd_als300_probe, - .remove = snd_als300_remove, .driver = { .pm = SND_ALS300_PM_OPS, },

This patch converts the resource management in PCI azt3328 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/azt3328.c | 124 +++++++++++--------------------------------- 1 file changed, 30 insertions(+), 94 deletions(-)

diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c index 4ee7ab409807..089050470ff2 100644 --- a/sound/pci/azt3328.c +++ b/sound/pci/azt3328.c @@ -2244,32 +2244,15 @@ snd_azf3328_timer(struct snd_azf3328 *chip, int device)

/******************************************************************/

-static int -snd_azf3328_free(struct snd_azf3328 *chip) +static void +snd_azf3328_free(struct snd_card *card) { - if (chip->irq < 0) - goto __end_hw; + struct snd_azf3328 *chip = card->private_data;

snd_azf3328_mixer_reset(chip);

snd_azf3328_timer_stop(chip->timer); snd_azf3328_gameport_free(chip); - -__end_hw: - if (chip->irq >= 0) - free_irq(chip->irq, chip); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - - kfree(chip); - return 0; -} - -static int -snd_azf3328_dev_free(struct snd_device *device) -{ - struct snd_azf3328 *chip = device->device_data; - return snd_azf3328_free(chip); }

#if 0 @@ -2350,29 +2333,18 @@ snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip) static int snd_azf3328_create(struct snd_card *card, struct pci_dev *pci, - unsigned long device_type, - struct snd_azf3328 **rchip) + unsigned long device_type) { - struct snd_azf3328 *chip; + struct snd_azf3328 *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_azf3328_dev_free, - }; u8 dma_init; enum snd_azf3328_codec_type codec_type; struct snd_azf3328_codec_data *codec_setup;

- *rchip = 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) { - err = -ENOMEM; - goto out_err; - } spin_lock_init(&chip->reg_lock); chip->card = card; chip->pci = pci; @@ -2383,13 +2355,12 @@ snd_azf3328_create(struct snd_card *card, dev_err(card->dev, "architecture does not support 24bit PCI busmaster DMA\n" ); - err = -ENXIO; - goto out_err; + return -ENXIO; }

err = pci_request_regions(pci, "Aztech AZF3328"); if (err < 0) - goto out_err; + return err;

chip->ctrl_io = pci_resource_start(pci, 0); chip->game_io = pci_resource_start(pci, 1); @@ -2415,26 +2386,22 @@ snd_azf3328_create(struct snd_card *card, codec_setup->type = AZF_CODEC_I2S_OUT; codec_setup->name = "I2S_OUT";

- if (request_irq(pci->irq, snd_azf3328_interrupt, - IRQF_SHARED, KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_azf3328_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - err = -EBUSY; - goto out_err; + return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_azf3328_free; pci_set_master(pci);

snd_azf3328_debug_show_ports(chip);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) - goto out_err; - /* create mixer interface & switches */ err = snd_azf3328_mixer_new(chip); if (err < 0) - goto out_err; + return err;

/* standard codec init stuff */ /* default DMA init value */ @@ -2456,18 +2423,7 @@ snd_azf3328_create(struct snd_card *card, spin_unlock_irq(codec->lock); }

- *rchip = chip; - - err = 0; - goto out; - -out_err: - if (chip) - snd_azf3328_free(chip); - pci_disable_device(pci); - -out: - return err; + return 0; }

static int @@ -2479,29 +2435,25 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) struct snd_opl3 *opl3; int err;

- if (dev >= SNDRV_CARDS) { - err = -ENODEV; - goto out; - } + if (dev >= SNDRV_CARDS) + return -ENODEV; if (!enable[dev]) { dev++; - err = -ENOENT; - goto out; + 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) - goto out; + return err; + chip = card->private_data;

strcpy(card->driver, "AZF3328"); strcpy(card->shortname, "Aztech AZF3328 (PCI168)");

- err = snd_azf3328_create(card, pci, pci_id->driver_data, &chip); + err = snd_azf3328_create(card, pci, pci_id->driver_data); if (err < 0) - goto out_err; - - card->private_data = chip; + return err;

/* chose to use MPU401_HW_AZT2320 ID instead of MPU401_HW_MPU401, since our hardware ought to be similar, thus use same ID. */ @@ -2515,16 +2467,16 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) dev_err(card->dev, "no MPU-401 device at 0x%lx?\n", chip->mpu_io ); - goto out_err; + return err; }

err = snd_azf3328_timer(chip, 0); if (err < 0) - goto out_err; + return err;

err = snd_azf3328_pcm(chip); if (err < 0) - goto out_err; + return err;

if (snd_opl3_create(card, chip->opl3_io, chip->opl3_io+2, OPL3_HW_AUTO, 1, &opl3) < 0) { @@ -2535,10 +2487,10 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) /* need to use IDs 1, 2 since ID 0 is snd_azf3328_timer above */ err = snd_opl3_timer_new(opl3, 1, 2); if (err < 0) - goto out_err; + return err; err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); if (err < 0) - goto out_err; + return err; opl3->private_data = chip; }

@@ -2547,7 +2499,7 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)

err = snd_card_register(card); if (err < 0) - goto out_err; + return err;

#ifdef MODULE dev_info(card->dev, @@ -2565,22 +2517,7 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)

pci_set_drvdata(pci, card); dev++; - - err = 0; - goto out; - -out_err: - dev_err(card->dev, "something failed, exiting\n"); - snd_card_free(card); - -out: - return err; -} - -static void -snd_azf3328_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); + return 0; }

#ifdef CONFIG_PM_SLEEP @@ -2709,7 +2646,6 @@ static struct pci_driver azf3328_driver = { .name = KBUILD_MODNAME, .id_table = snd_azf3328_ids, .probe = snd_azf3328_probe, - .remove = snd_azf3328_remove, .driver = { .pm = SND_AZF3328_PM_OPS, },

This patch converts the resource management in PCI cmipci 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/cmipci.c | 104 ++++++++++++--------------------------------- 1 file changed, 28 insertions(+), 76 deletions(-)

diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c index f44f118aacad..ea20236f35db 100644 --- a/sound/pci/cmipci.c +++ b/sound/pci/cmipci.c @@ -2852,13 +2852,15 @@ static int snd_cmipci_create_gameport(struct cmipci *cm, int dev) if (joystick_port[dev] == 1) { /* auto-detect */ for (i = 0; ports[i]; i++) { io_port = ports[i]; - r = request_region(io_port, 1, "CMIPCI gameport"); + r = devm_request_region(&cm->pci->dev, io_port, 1, + "CMIPCI gameport"); if (r) break; } } else { io_port = joystick_port[dev]; - r = request_region(io_port, 1, "CMIPCI gameport"); + r = devm_request_region(&cm->pci->dev, io_port, 1, + "CMIPCI gameport"); }

if (!r) { @@ -2869,14 +2871,12 @@ static int snd_cmipci_create_gameport(struct cmipci *cm, int dev) cm->gameport = gp = gameport_allocate_port(); if (!gp) { dev_err(cm->card->dev, "cannot allocate memory for gameport\n"); - release_and_free_resource(r); return -ENOMEM; } gameport_set_name(gp, "C-Media Gameport"); gameport_set_phys(gp, "pci%s/gameport0", pci_name(cm->pci)); gameport_set_dev_parent(gp, &cm->pci->dev); gp->io = io_port; - gameport_set_port_data(gp, r);

snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);

@@ -2888,13 +2888,10 @@ static int snd_cmipci_create_gameport(struct cmipci *cm, int dev) static void snd_cmipci_free_gameport(struct cmipci *cm) { if (cm->gameport) { - struct resource *r = gameport_get_port_data(cm->gameport); - gameport_unregister_port(cm->gameport); cm->gameport = NULL;

snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN); - release_and_free_resource(r); } } #else @@ -2902,34 +2899,22 @@ static inline int snd_cmipci_create_gameport(struct cmipci *cm, int dev) { retur static inline void snd_cmipci_free_gameport(struct cmipci *cm) { } #endif

-static int snd_cmipci_free(struct cmipci *cm) +static void snd_cmipci_free(struct snd_card *card) { - if (cm->irq >= 0) { - snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN); - snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_ENSPDOUT); - snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0); /* disable ints */ - snd_cmipci_ch_reset(cm, CM_CH_PLAY); - snd_cmipci_ch_reset(cm, CM_CH_CAPT); - snd_cmipci_write(cm, CM_REG_FUNCTRL0, 0); /* disable channels */ - snd_cmipci_write(cm, CM_REG_FUNCTRL1, 0); + struct cmipci *cm = card->private_data;

- /* reset mixer */ - snd_cmipci_mixer_write(cm, 0, 0); + snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN); + snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_ENSPDOUT); + snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0); /* disable ints */ + snd_cmipci_ch_reset(cm, CM_CH_PLAY); + snd_cmipci_ch_reset(cm, CM_CH_CAPT); + snd_cmipci_write(cm, CM_REG_FUNCTRL0, 0); /* disable channels */ + snd_cmipci_write(cm, CM_REG_FUNCTRL1, 0);

- free_irq(cm->irq, cm); - } + /* reset mixer */ + snd_cmipci_mixer_write(cm, 0, 0);

snd_cmipci_free_gameport(cm); - pci_release_regions(cm->pci); - pci_disable_device(cm->pci); - kfree(cm); - return 0; -} - -static int snd_cmipci_dev_free(struct snd_device *device) -{ - struct cmipci *cm = device->device_data; - return snd_cmipci_free(cm); }

static int snd_cmipci_create_fm(struct cmipci *cm, long fm_port) @@ -2988,13 +2973,10 @@ static int snd_cmipci_create_fm(struct cmipci *cm, long fm_port) }

static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, - int dev, struct cmipci **rcmipci) + int dev) { - struct cmipci *cm; + struct cmipci *cm = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_cmipci_dev_free, - }; unsigned int val; long iomidi = 0; int integrated_midi = 0; @@ -3005,18 +2987,10 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, { }, };

- *rcmipci = NULL; - - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err;

- cm = kzalloc(sizeof(*cm), GFP_KERNEL); - if (cm == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } - spin_lock_init(&cm->reg_lock); mutex_init(&cm->open_mutex); cm->device = pci->device; @@ -3028,21 +3002,18 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, cm->channel[0].is_dac = cm->channel[1].is_dac = 1; /* dual DAC mode */

err = pci_request_regions(pci, card->driver); - if (err < 0) { - kfree(cm); - pci_disable_device(pci); + if (err < 0) return err; - } cm->iobase = pci_resource_start(pci, 0);

- if (request_irq(pci->irq, snd_cmipci_interrupt, - IRQF_SHARED, KBUILD_MODNAME, cm)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_cmipci_interrupt, + IRQF_SHARED, KBUILD_MODNAME, cm)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_cmipci_free(cm); return -EBUSY; } cm->irq = pci->irq; card->sync_irq = cm->irq; + card->private_free = snd_cmipci_free;

pci_set_master(cm->pci);

@@ -3142,12 +3113,6 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, sprintf(card->longname, "%s%s at %#lx, irq %i", card->shortname, modelstr, cm->iobase, cm->irq);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, cm, &ops); - if (err < 0) { - snd_cmipci_free(cm); - return err; - } - if (cm->chip_version >= 39) { val = snd_cmipci_read_b(cm, CM_REG_MPU_PCI + 1); if (val != 0x00 && val != 0xff) { @@ -3240,7 +3205,6 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, if (snd_cmipci_create_gameport(cm, dev) < 0) snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);

- *rcmipci = cm; return 0; }

@@ -3264,10 +3228,11 @@ static int snd_cmipci_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(*cm), &card); if (err < 0) return err; + cm = card->private_data; switch (pci->device) { case PCI_DEVICE_ID_CMEDIA_CM8738: @@ -3283,31 +3248,19 @@ static int snd_cmipci_probe(struct pci_dev *pci, break; }

- err = snd_cmipci_create(card, pci, dev, &cm); + err = snd_cmipci_create(card, pci, dev); if (err < 0) - goto free_card; - - card->private_data = cm; + return err;

err = snd_card_register(card); if (err < 0) - goto free_card; + return err;

pci_set_drvdata(pci, card); dev++; return 0; - -free_card: - snd_card_free(card); - return err; }

-static void snd_cmipci_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - - #ifdef CONFIG_PM_SLEEP /* * power management @@ -3382,7 +3335,6 @@ static struct pci_driver cmipci_driver = { .name = KBUILD_MODNAME, .id_table = snd_cmipci_ids, .probe = snd_cmipci_probe, - .remove = snd_cmipci_remove, .driver = { .pm = SND_CMIPCI_PM_OPS, },

This patch converts the resource management in PCI cs5530 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/cs5530.c | 86 +++++++--------------------------------------- 1 file changed, 13 insertions(+), 73 deletions(-)

diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c index 20b4faea50a6..93ff029e6583 100644 --- a/sound/pci/cs5530.c +++ b/sound/pci/cs5530.c @@ -65,25 +65,6 @@ static const struct pci_device_id snd_cs5530_ids[] = {

MODULE_DEVICE_TABLE(pci, snd_cs5530_ids);

-static int snd_cs5530_free(struct snd_cs5530 *chip) -{ - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_cs5530_dev_free(struct snd_device *device) -{ - struct snd_cs5530 *chip = device->device_data; - return snd_cs5530_free(chip); -} - -static void snd_cs5530_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static u8 snd_cs5530_mixer_read(unsigned long io, u8 reg) { outb(reg, io + 4); @@ -94,50 +75,28 @@ static u8 snd_cs5530_mixer_read(unsigned long io, u8 reg) }

static int snd_cs5530_create(struct snd_card *card, - struct pci_dev *pci, - struct snd_cs5530 **rchip) + struct pci_dev *pci) { - struct snd_cs5530 *chip; + struct snd_cs5530 *chip = card->private_data; unsigned long sb_base; u8 irq, dma8, dma16 = 0; u16 map; void __iomem *mem; int err;

- static const struct snd_device_ops ops = { - .dev_free = snd_cs5530_dev_free, - }; - *rchip = 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;

- err = pci_request_regions(pci, "CS5530"); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + err = pcim_iomap_regions(pci, 1 << 0, "CS5530"); + if (err < 0) return err; - } chip->pci_base = pci_resource_start(pci, 0); - - mem = pci_ioremap_bar(pci, 0); - if (mem == NULL) { - snd_cs5530_free(chip); - return -EBUSY; - } - + mem = pcim_iomap_table(pci)[0]; map = readw(mem + 0x18); - iounmap(mem);

/* Map bits 0:1 * 0x20 + 0x200 = sb base @@ -154,7 +113,6 @@ static int snd_cs5530_create(struct snd_card *card, dev_info(card->dev, "XpressAudio at 0x%lx\n", sb_base); else { dev_err(card->dev, "Could not find XpressAudio!\n"); - snd_cs5530_free(chip); return -ENODEV; }

@@ -174,7 +132,6 @@ static int snd_cs5530_create(struct snd_card *card, dma16 = 7; else { dev_err(card->dev, "No 16bit DMA enabled\n"); - snd_cs5530_free(chip); return -ENODEV; }

@@ -186,7 +143,6 @@ static int snd_cs5530_create(struct snd_card *card, dma8 = 3; else { dev_err(card->dev, "No 8bit DMA enabled\n"); - snd_cs5530_free(chip); return -ENODEV; }

@@ -200,7 +156,6 @@ static int snd_cs5530_create(struct snd_card *card, irq = 10; else { dev_err(card->dev, "SoundBlaster IRQ not set\n"); - snd_cs5530_free(chip); return -ENODEV; }

@@ -210,31 +165,21 @@ static int snd_cs5530_create(struct snd_card *card, dma16, SB_HW_CS5530, &chip->sb); if (err < 0) { dev_err(card->dev, "Could not create SoundBlaster\n"); - snd_cs5530_free(chip); return err; }

err = snd_sb16dsp_pcm(chip->sb, 0); if (err < 0) { dev_err(card->dev, "Could not create PCM\n"); - snd_cs5530_free(chip); return err; }

err = snd_sbmixer_new(chip->sb); if (err < 0) { dev_err(card->dev, "Could not create Mixer\n"); - snd_cs5530_free(chip); - return err; - } - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_cs5530_free(chip); return err; }

- *rchip = chip; return 0; }

@@ -243,7 +188,7 @@ static int snd_cs5530_probe(struct pci_dev *pci, { static int dev; struct snd_card *card; - struct snd_cs5530 *chip = NULL; + struct snd_cs5530 *chip; int err;

if (dev >= SNDRV_CARDS) @@ -253,27 +198,23 @@ static int snd_cs5530_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_cs5530_create(card, pci, &chip); - if (err < 0) { - snd_card_free(card); + err = snd_cs5530_create(card, pci); + if (err < 0) return err; - }

strcpy(card->driver, "CS5530"); strcpy(card->shortname, "CS5530 Audio"); sprintf(card->longname, "%s at 0x%lx", card->shortname, chip->pci_base);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); dev++; return 0; @@ -283,7 +224,6 @@ static struct pci_driver cs5530_driver = { .name = KBUILD_MODNAME, .id_table = snd_cs5530_ids, .probe = snd_cs5530_probe, - .remove = snd_cs5530_remove, };

module_pci_driver(cs5530_driver);

This patch converts the resource management in PCI es1938 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/es1938.c | 97 ++++++++++++---------------------------------- 1 file changed, 24 insertions(+), 73 deletions(-)

diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c index 33b1eb347a27..00b976f42a3d 100644 --- a/sound/pci/es1938.c +++ b/sound/pci/es1938.c @@ -1521,8 +1521,10 @@ static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOS static inline void snd_es1938_free_gameport(struct es1938 *chip) { } #endif /* SUPPORT_JOYSTICK */

-static int snd_es1938_free(struct es1938 *chip) +static void snd_es1938_free(struct snd_card *card) { + struct es1938 *chip = card->private_data; + /* disable irqs */ outb(0x00, SLIO_REG(chip, IRQCONTROL)); if (chip->rmidi) @@ -1532,71 +1534,47 @@ static int snd_es1938_free(struct es1938 *chip)

if (chip->irq >= 0) free_irq(chip->irq, chip); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_es1938_dev_free(struct snd_device *device) -{ - struct es1938 *chip = device->device_data; - return snd_es1938_free(chip); }

static int snd_es1938_create(struct snd_card *card, - struct pci_dev *pci, - struct es1938 **rchip) + struct pci_dev *pci) { - struct es1938 *chip; + struct es1938 *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_es1938_dev_free, - }; - - *rchip = NULL;

/* enable PCI device */ - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err; /* check, if we can restrict PCI DMA transfers to 24 bits */ if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(24))) { dev_err(card->dev, "architecture does not support 24bit PCI busmaster DMA\n"); - pci_disable_device(pci); return -ENXIO; }

- chip = kzalloc(sizeof(*chip), GFP_KERNEL); - if (chip == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } spin_lock_init(&chip->reg_lock); spin_lock_init(&chip->mixer_lock); chip->card = card; chip->pci = pci; chip->irq = -1; err = pci_request_regions(pci, "ESS Solo-1"); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + if (err < 0) return err; - } chip->io_port = pci_resource_start(pci, 0); chip->sb_port = pci_resource_start(pci, 1); chip->vc_port = pci_resource_start(pci, 2); chip->mpu_port = pci_resource_start(pci, 3); chip->game_port = pci_resource_start(pci, 4); + /* still use non-managed irq handler as it's re-acquired at PM resume */ if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_es1938_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_es1938_free; dev_dbg(card->dev, "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n", chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port); @@ -1604,14 +1582,6 @@ static int snd_es1938_create(struct snd_card *card, chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */

snd_es1938_chip_init(chip); - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_es1938_free(chip); - return err; - } - - *rchip = chip; return 0; }

@@ -1762,23 +1732,20 @@ static int snd_es1938_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; - for (idx = 0; idx < 5; idx++) { + chip = card->private_data; + + for (idx = 0; idx < 5; idx++) if (pci_resource_start(pci, idx) == 0 || - !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) { - snd_card_free(card); - return -ENODEV; - } - } - err = snd_es1938_create(card, pci, &chip); - if (err < 0) { - snd_card_free(card); + !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) + return -ENODEV; + + err = snd_es1938_create(card, pci); + if (err < 0) return err; - } - card->private_data = chip;

strcpy(card->driver, "ES1938"); strcpy(card->shortname, "ESS ES1938 (Solo-1)"); @@ -1788,15 +1755,11 @@ static int snd_es1938_probe(struct pci_dev *pci, chip->irq);

err = snd_es1938_new_pcm(chip, 0); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_es1938_mixer(chip); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } if (snd_opl3_create(card, SLSB_REG(chip, FMLOWADDR), SLSB_REG(chip, FMHIGHADDR), @@ -1805,15 +1768,11 @@ static int snd_es1938_probe(struct pci_dev *pci, SLSB_REG(chip, FMLOWADDR)); } else { err = snd_opl3_timer_new(opl3, 0, 1); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } } if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, chip->mpu_port, @@ -1829,26 +1788,18 @@ static int snd_es1938_probe(struct pci_dev *pci, snd_es1938_create_gameport(chip);

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

pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_es1938_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static struct pci_driver es1938_driver = { .name = KBUILD_MODNAME, .id_table = snd_es1938_ids, .probe = snd_es1938_probe, - .remove = snd_es1938_remove, .driver = { .pm = ES1938_PM_OPS, },

This patch converts the resource management in PCI fm801 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. Also the superfluous ac97 private_free callbacks were dropped, too.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/fm801.c | 103 ++++++++-------------------------------------- 1 file changed, 17 insertions(+), 86 deletions(-)

diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c index ed9dae87145b..9c22ff19e56d 100644 --- a/sound/pci/fm801.c +++ b/sound/pci/fm801.c @@ -1028,22 +1028,6 @@ FM801_SINGLE(SNDRV_CTL_NAME_IEC958("Raw Data ",CAPTURE,SWITCH), FM801_I2S_MODE, FM801_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), FM801_GEN_CTRL, 2, 1, 0), };

-static void snd_fm801_mixer_free_ac97_bus(struct snd_ac97_bus *bus) -{ - struct fm801 *chip = bus->private_data; - chip->ac97_bus = NULL; -} - -static void snd_fm801_mixer_free_ac97(struct snd_ac97 *ac97) -{ - struct fm801 *chip = ac97->private_data; - if (ac97->num == 0) { - chip->ac97 = NULL; - } else { - chip->ac97_sec = NULL; - } -} - static int snd_fm801_mixer(struct fm801 *chip) { struct snd_ac97_template ac97; @@ -1057,11 +1041,9 @@ static int snd_fm801_mixer(struct fm801 *chip) err = snd_ac97_bus(chip->card, 0, &ops, chip, &chip->ac97_bus); if (err < 0) return err; - chip->ac97_bus->private_free = snd_fm801_mixer_free_ac97_bus;

memset(&ac97, 0, sizeof(ac97)); ac97.private_data = chip; - ac97.private_free = snd_fm801_mixer_free_ac97; err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97); if (err < 0) return err; @@ -1177,55 +1159,35 @@ static void snd_fm801_chip_init(struct fm801 *chip) FM801_IRQ_PLAYBACK | FM801_IRQ_CAPTURE | FM801_IRQ_MPU); }

-static int snd_fm801_free(struct fm801 *chip) +static void snd_fm801_free(struct snd_card *card) { + struct fm801 *chip = card->private_data; unsigned short cmdw;

- if (chip->irq < 0) - goto __end_hw; - /* interrupt setup - mask everything */ cmdw = fm801_readw(chip, IRQ_MASK); cmdw |= 0x00c3; fm801_writew(chip, IRQ_MASK, cmdw);

- devm_free_irq(chip->dev, chip->irq, chip); - - __end_hw: #ifdef CONFIG_SND_FM801_TEA575X_BOOL if (!(chip->tea575x_tuner & TUNER_DISABLED)) { snd_tea575x_exit(&chip->tea); v4l2_device_unregister(&chip->v4l2_dev); } #endif - return 0; -} - -static int snd_fm801_dev_free(struct snd_device *device) -{ - struct fm801 *chip = device->device_data; - return snd_fm801_free(chip); }

static int snd_fm801_create(struct snd_card *card, struct pci_dev *pci, int tea575x_tuner, - int radio_nr, - struct fm801 **rchip) + int radio_nr) { - struct fm801 *chip; + struct fm801 *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_fm801_dev_free, - };

- *rchip = NULL; err = pcim_enable_device(pci); if (err < 0) return err; - chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL); - if (chip == NULL) - return -ENOMEM; spin_lock_init(&chip->reg_lock); chip->card = card; chip->dev = &pci->dev; @@ -1253,7 +1215,6 @@ static int snd_fm801_create(struct snd_card *card, if (devm_request_irq(&pci->dev, pci->irq, snd_fm801_interrupt, IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_fm801_free(chip); return -EBUSY; } chip->irq = pci->irq; @@ -1261,20 +1222,13 @@ static int snd_fm801_create(struct snd_card *card, pci_set_master(pci); }

+ card->private_free = snd_fm801_free; snd_fm801_chip_init(chip);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_fm801_free(chip); - return err; - } - #ifdef CONFIG_SND_FM801_TEA575X_BOOL err = v4l2_device_register(&pci->dev, &chip->v4l2_dev); - if (err < 0) { - snd_fm801_free(chip); + if (err < 0) return err; - } chip->tea.v4l2_dev = &chip->v4l2_dev; chip->tea.radio_nr = radio_nr; chip->tea.private_data = chip; @@ -1284,7 +1238,6 @@ static int snd_fm801_create(struct snd_card *card, (chip->tea575x_tuner & TUNER_TYPE_MASK) < 4) { if (snd_tea575x_init(&chip->tea, THIS_MODULE)) { dev_err(card->dev, "TEA575x radio not found\n"); - snd_fm801_free(chip); return -ENODEV; } } else if ((chip->tea575x_tuner & TUNER_TYPE_MASK) == 0) { @@ -1312,8 +1265,6 @@ static int snd_fm801_create(struct snd_card *card, sizeof(chip->tea.card)); } #endif - - *rchip = chip; return 0; }

@@ -1333,16 +1284,14 @@ static int snd_card_fm801_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; - err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev], &chip); - if (err < 0) { - snd_card_free(card); + chip = card->private_data; + err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev]); + if (err < 0) return err; - } - card->private_data = chip;

strcpy(card->driver, "FM801"); strcpy(card->shortname, "ForteMedia FM801-"); @@ -1354,53 +1303,36 @@ static int snd_card_fm801_probe(struct pci_dev *pci, goto __fm801_tuner_only;

err = snd_fm801_pcm(chip, 0); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_fm801_mixer(chip); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_mpu401_uart_new(card, 0, MPU401_HW_FM801, chip->port + FM801_MPU401_DATA, MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK, -1, &chip->rmidi); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_opl3_create(card, chip->port + FM801_OPL3_BANK0, chip->port + FM801_OPL3_BANK1, OPL3_HW_OPL3_FM801, 1, &opl3); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

__fm801_tuner_only: err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_card_fm801_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - #ifdef CONFIG_PM_SLEEP static const unsigned char saved_regs[] = { FM801_PCM_VOL, FM801_I2S_VOL, FM801_FM_VOL, FM801_REC_SRC, @@ -1468,7 +1400,6 @@ static struct pci_driver fm801_driver = { .name = KBUILD_MODNAME, .id_table = snd_fm801_ids, .probe = snd_card_fm801_probe, - .remove = snd_card_fm801_remove, .driver = { .pm = SND_FM801_PM_OPS, },

This patch converts the resource management in PCI rme32 driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/rme32.c | 49 +++++++++++------------------------------------ 1 file changed, 11 insertions(+), 38 deletions(-)

diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c index b5b357853c94..5b6bd9f0b2f7 100644 --- a/sound/pci/rme32.c +++ b/sound/pci/rme32.c @@ -1278,27 +1278,10 @@ static const struct snd_pcm_ops snd_rme32_capture_adat_fd_ops = { .ack = snd_rme32_capture_fd_ack, };

-static void snd_rme32_free(void *private_data) +static void snd_rme32_free(struct rme32 *rme32) { - struct rme32 *rme32 = (struct rme32 *) private_data; - - if (rme32 == NULL) { - return; - } - if (rme32->irq >= 0) { + if (rme32->irq >= 0) snd_rme32_pcm_stop(rme32, 0); - free_irq(rme32->irq, (void *) rme32); - rme32->irq = -1; - } - if (rme32->iobase) { - iounmap(rme32->iobase); - rme32->iobase = NULL; - } - if (rme32->port) { - pci_release_regions(rme32->pci); - rme32->port = 0; - } - pci_disable_device(rme32->pci); }

static void snd_rme32_free_spdif_pcm(struct snd_pcm *pcm) @@ -1322,7 +1305,7 @@ static int snd_rme32_create(struct rme32 *rme32) rme32->irq = -1; spin_lock_init(&rme32->lock);

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

@@ -1331,16 +1314,16 @@ static int snd_rme32_create(struct rme32 *rme32) return err; rme32->port = pci_resource_start(rme32->pci, 0);

- rme32->iobase = ioremap(rme32->port, RME32_IO_SIZE); + rme32->iobase = devm_ioremap(&pci->dev, rme32->port, RME32_IO_SIZE); if (!rme32->iobase) { dev_err(rme32->card->dev, "unable to remap memory region 0x%lx-0x%lx\n", - rme32->port, rme32->port + RME32_IO_SIZE - 1); + rme32->port, rme32->port + RME32_IO_SIZE - 1); return -ENOMEM; }

- if (request_irq(pci->irq, snd_rme32_interrupt, IRQF_SHARED, - KBUILD_MODNAME, rme32)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_rme32_interrupt, + IRQF_SHARED, KBUILD_MODNAME, rme32)) { dev_err(rme32->card->dev, "unable to grab IRQ %d\n", pci->irq); return -EBUSY; } @@ -1907,8 +1890,8 @@ snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) return -ENOENT; }

- err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, - sizeof(struct rme32), &card); + err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, + sizeof(*rme32), &card); if (err < 0) return err; card->private_free = snd_rme32_card_free; @@ -1918,10 +1901,8 @@ snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) if (fullduplex[dev]) rme32->fullduplex_mode = 1; err = snd_rme32_create(rme32); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

strcpy(card->driver, "Digi32"); switch (rme32->pci->device) { @@ -1939,25 +1920,17 @@ snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) card->shortname, rme32->rev, rme32->port, rme32->irq);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_rme32_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static struct pci_driver rme32_driver = { .name = KBUILD_MODNAME, .id_table = snd_rme32_ids, .probe = snd_rme32_probe, - .remove = snd_rme32_remove, };

module_pci_driver(rme32_driver);

This patch converts the resource management in PCI sis7019 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/sis7019.c | 87 +++++++++++---------------------------------- 1 file changed, 20 insertions(+), 67 deletions(-)

diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c index 00ab51c889da..0b722b0e0604 100644 --- a/sound/pci/sis7019.c +++ b/sound/pci/sis7019.c @@ -1007,16 +1007,10 @@ static int sis_mixer_create(struct sis7019 *sis) return rc; }

-static void sis_free_suspend(struct sis7019 *sis) +static void sis_chip_free(struct snd_card *card) { - int i; - - for (i = 0; i < SIS_SUSPEND_PAGES; i++) - kfree(sis->suspend_state[i]); -} + struct sis7019 *sis = card->private_data;

-static int sis_chip_free(struct sis7019 *sis) -{ /* Reset the chip, and disable all interrputs. */ outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR); @@ -1028,18 +1022,6 @@ static int sis_chip_free(struct sis7019 *sis) */ if (sis->irq >= 0) free_irq(sis->irq, sis); - - iounmap(sis->ioaddr); - pci_release_regions(sis->pci); - pci_disable_device(sis->pci); - sis_free_suspend(sis); - return 0; -} - -static int sis_dev_free(struct snd_device *dev) -{ - struct sis7019 *sis = dev->device_data; - return sis_chip_free(sis); }

static int sis_chip_init(struct sis7019 *sis) @@ -1265,7 +1247,8 @@ static int sis_alloc_suspend(struct sis7019 *sis) * buffer. */ for (i = 0; i < SIS_SUSPEND_PAGES; i++) { - sis->suspend_state[i] = kmalloc(4096, GFP_KERNEL); + sis->suspend_state[i] = devm_kmalloc(&sis->pci->dev, 4096, + GFP_KERNEL); if (!sis->suspend_state[i]) return -ENOMEM; } @@ -1279,23 +1262,19 @@ static int sis_chip_create(struct snd_card *card, { struct sis7019 *sis = card->private_data; struct voice *voice; - static const struct snd_device_ops ops = { - .dev_free = sis_dev_free, - }; int rc; int i;

- rc = pci_enable_device(pci); + rc = pcim_enable_device(pci); if (rc) - goto error_out; + return rc;

rc = dma_set_mask(&pci->dev, DMA_BIT_MASK(30)); if (rc < 0) { dev_err(&pci->dev, "architecture does not support 30-bit PCI busmaster DMA"); - goto error_out_enabled; + return -ENXIO; }

- memset(sis, 0, sizeof(*sis)); mutex_init(&sis->ac97_mutex); spin_lock_init(&sis->voice_lock); sis->card = card; @@ -1306,31 +1285,31 @@ static int sis_chip_create(struct snd_card *card, rc = pci_request_regions(pci, "SiS7019"); if (rc) { dev_err(&pci->dev, "unable request regions\n"); - goto error_out_enabled; + return rc; }

- rc = -EIO; - sis->ioaddr = ioremap(pci_resource_start(pci, 1), 0x4000); + sis->ioaddr = devm_ioremap(&pci->dev, pci_resource_start(pci, 1), 0x4000); if (!sis->ioaddr) { dev_err(&pci->dev, "unable to remap MMIO, aborting\n"); - goto error_out_cleanup; + return -EIO; }

rc = sis_alloc_suspend(sis); if (rc < 0) { dev_err(&pci->dev, "unable to allocate state storage\n"); - goto error_out_cleanup; + return rc; }

rc = sis_chip_init(sis); if (rc) - goto error_out_cleanup; + return rc; + card->private_free = sis_chip_free;

rc = request_irq(pci->irq, sis_interrupt, IRQF_SHARED, KBUILD_MODNAME, sis); if (rc) { dev_err(&pci->dev, "unable to allocate irq %d\n", sis->irq); - goto error_out_cleanup; + return rc; }

sis->irq = pci->irq; @@ -1349,20 +1328,7 @@ static int sis_chip_create(struct snd_card *card, voice->num = SIS_CAPTURE_CHAN_AC97_PCM_IN; voice->ctrl_base = SIS_CAPTURE_DMA_ADDR(sis->ioaddr, voice->num);

- rc = snd_device_new(card, SNDRV_DEV_LOWLEVEL, sis, &ops); - if (rc) - goto error_out_cleanup; - return 0; - -error_out_cleanup: - sis_chip_free(sis); - -error_out_enabled: - pci_disable_device(pci); - -error_out: - return rc; }

static int snd_sis7019_probe(struct pci_dev *pci, @@ -1372,9 +1338,8 @@ static int snd_sis7019_probe(struct pci_dev *pci, struct sis7019 *sis; int rc;

- rc = -ENOENT; if (!enable) - goto error_out; + return -ENOENT;

/* The user can specify which codecs should be present so that we * can wait for them to show up if they are slow to recover from @@ -1390,23 +1355,23 @@ static int snd_sis7019_probe(struct pci_dev *pci, rc = snd_card_new(&pci->dev, index, id, THIS_MODULE, sizeof(*sis), &card); if (rc < 0) - goto error_out; + return rc;

strcpy(card->driver, "SiS7019"); strcpy(card->shortname, "SiS7019"); rc = sis_chip_create(card, pci); if (rc) - goto card_error_out; + return rc;

sis = card->private_data;

rc = sis_mixer_create(sis); if (rc) - goto card_error_out; + return rc;

rc = sis_pcm_create(sis); if (rc) - goto card_error_out; + return rc;

snprintf(card->longname, sizeof(card->longname), "%s Audio Accelerator with %s at 0x%lx, irq %d", @@ -1415,28 +1380,16 @@ static int snd_sis7019_probe(struct pci_dev *pci,

rc = snd_card_register(card); if (rc) - goto card_error_out; + return rc;

pci_set_drvdata(pci, card); return 0; - -card_error_out: - snd_card_free(card); - -error_out: - return rc; -} - -static void snd_sis7019_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver sis7019_driver = { .name = KBUILD_MODNAME, .id_table = snd_sis7019_ids, .probe = snd_sis7019_probe, - .remove = snd_sis7019_remove, .driver = { .pm = SIS_PM_OPS, },

This patch converts the resource management in PCI via82xx drivers 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/via82xx.c | 106 ++++++++++---------------------------- sound/pci/via82xx_modem.c | 86 +++++++------------------------ 2 files changed, 46 insertions(+), 146 deletions(-)

diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c index 943813a06abc..9d9136580961 100644 --- a/sound/pci/via82xx.c +++ b/sound/pci/via82xx.c @@ -2063,7 +2063,8 @@ static int snd_via686_init_misc(struct via82xx *chip) } } if (mpu_port >= 0x200) - chip->mpu_res = request_region(mpu_port, 2, "VIA82xx MPU401"); + chip->mpu_res = devm_request_region(&chip->pci->dev, mpu_port, + 2, "VIA82xx MPU401"); if (chip->mpu_res) { if (rev_h) legacy |= VIA_FUNC_MIDI_PNP; /* enable PCI I/O 2 */ @@ -2302,61 +2303,35 @@ static SIMPLE_DEV_PM_OPS(snd_via82xx_pm, snd_via82xx_suspend, snd_via82xx_resume #define SND_VIA82XX_PM_OPS NULL #endif /* CONFIG_PM_SLEEP */

-static int snd_via82xx_free(struct via82xx *chip) +static void snd_via82xx_free(struct snd_card *card) { + struct via82xx *chip = card->private_data; unsigned int i;

- if (chip->irq < 0) - goto __end_hw; /* disable interrupts */ for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]);

- if (chip->irq >= 0) - free_irq(chip->irq, chip); - __end_hw: - release_and_free_resource(chip->mpu_res); - pci_release_regions(chip->pci); - if (chip->chip_type == TYPE_VIA686) { snd_via686_free_gameport(chip); pci_write_config_byte(chip->pci, VIA_FUNC_ENABLE, chip->old_legacy); pci_write_config_byte(chip->pci, VIA_PNP_CONTROL, chip->old_legacy_cfg); } - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_via82xx_dev_free(struct snd_device *device) -{ - struct via82xx *chip = device->device_data; - return snd_via82xx_free(chip); }

static int snd_via82xx_create(struct snd_card *card, struct pci_dev *pci, int chip_type, int revision, - unsigned int ac97_clock, - struct via82xx **r_via) + unsigned int ac97_clock) { - struct via82xx *chip; + struct via82xx *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_via82xx_dev_free, - };

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

- chip = kzalloc(sizeof(*chip), GFP_KERNEL); - if (!chip) { - pci_disable_device(pci); - return -ENOMEM; - } - chip->chip_type = chip_type; chip->revision = revision;

@@ -2373,44 +2348,31 @@ static int snd_via82xx_create(struct snd_card *card, chip->old_legacy & ~(VIA_FUNC_ENABLE_SB|VIA_FUNC_ENABLE_FM));

err = pci_request_regions(pci, card->driver); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + if (err < 0) return err; - } chip->port = pci_resource_start(pci, 0); - if (request_irq(pci->irq, - chip_type == TYPE_VIA8233 ? - snd_via8233_interrupt : snd_via686_interrupt, - IRQF_SHARED, - KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, + chip_type == TYPE_VIA8233 ? + snd_via8233_interrupt : snd_via686_interrupt, + IRQF_SHARED, + KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_via82xx_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_via82xx_free; if (ac97_clock >= 8000 && ac97_clock <= 48000) chip->ac97_clock = ac97_clock;

err = snd_via82xx_chip_init(chip); - if (err < 0) { - snd_via82xx_free(chip); + if (err < 0) return err; - } - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_via82xx_free(chip); - return err; - }

/* The 8233 ac97 controller does not implement the master bit * in the pci command register. IMHO this is a violation of the PCI spec. * We call pci_set_master here because it does not hurt. */ pci_set_master(pci); - - *r_via = chip; return 0; }

@@ -2511,9 +2473,11 @@ static int snd_via82xx_probe(struct pci_dev *pci, unsigned int i; int err;

- 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;

card_type = pci_id->driver_data; switch (card_type) { @@ -2552,36 +2516,34 @@ static int snd_via82xx_probe(struct pci_dev *pci, break; default: dev_err(card->dev, "invalid card type %d\n", card_type); - err = -EINVAL; - goto __error; + return -EINVAL; } err = snd_via82xx_create(card, pci, chip_type, pci->revision, - ac97_clock, &chip); + ac97_clock); if (err < 0) - goto __error; - card->private_data = chip; + return err; err = snd_via82xx_mixer_new(chip, ac97_quirk); if (err < 0) - goto __error; + return err;

if (chip_type == TYPE_VIA686) { err = snd_via686_pcm_new(chip); if (err < 0) - goto __error; + return err; err = snd_via686_init_misc(chip); if (err < 0) - goto __error; + return err; } else { if (chip_type == TYPE_VIA8233A) { err = snd_via8233a_pcm_new(chip); if (err < 0) - goto __error; + return err; // chip->dxs_fixed = 1; /* FIXME: use 48k for DXS #3? */ } else { err = snd_via8233_pcm_new(chip); if (err < 0) - goto __error; + return err; if (dxs_support == VIA_DXS_48K) chip->dxs_fixed = 1; else if (dxs_support == VIA_DXS_NO_VRA) @@ -2593,7 +2555,7 @@ static int snd_via82xx_probe(struct pci_dev *pci, } err = snd_via8233_init_misc(chip); if (err < 0) - goto __error; + return err; }

/* disable interrupts */ @@ -2607,28 +2569,16 @@ static int snd_via82xx_probe(struct pci_dev *pci, snd_via82xx_proc_init(chip);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); return 0; - - __error: - snd_card_free(card); - return err; -} - -static void snd_via82xx_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver via82xx_driver = { .name = KBUILD_MODNAME, .id_table = snd_via82xx_ids, .probe = snd_via82xx_probe, - .remove = snd_via82xx_remove, .driver = { .pm = SND_VIA82XX_PM_OPS, }, diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c index 07278a3dc8c1..b7ee5c67ec4e 100644 --- a/sound/pci/via82xx_modem.c +++ b/sound/pci/via82xx_modem.c @@ -1048,95 +1048,57 @@ static SIMPLE_DEV_PM_OPS(snd_via82xx_pm, snd_via82xx_suspend, snd_via82xx_resume #define SND_VIA82XX_PM_OPS NULL #endif /* CONFIG_PM_SLEEP */

-static int snd_via82xx_free(struct via82xx_modem *chip) +static void snd_via82xx_free(struct snd_card *card) { + struct via82xx_modem *chip = card->private_data; unsigned int i;

- if (chip->irq < 0) - goto __end_hw; /* disable interrupts */ for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); - - __end_hw: - if (chip->irq >= 0) - free_irq(chip->irq, chip); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} - -static int snd_via82xx_dev_free(struct snd_device *device) -{ - struct via82xx_modem *chip = device->device_data; - return snd_via82xx_free(chip); }

static int snd_via82xx_create(struct snd_card *card, struct pci_dev *pci, int chip_type, int revision, - unsigned int ac97_clock, - struct via82xx_modem **r_via) + unsigned int ac97_clock) { struct via82xx_modem *chip; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_via82xx_dev_free, - };

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

- chip = kzalloc(sizeof(*chip), GFP_KERNEL); - if (!chip) { - pci_disable_device(pci); - return -ENOMEM; - } - spin_lock_init(&chip->reg_lock); chip->card = card; chip->pci = pci; chip->irq = -1;

err = pci_request_regions(pci, card->driver); - if (err < 0) { - kfree(chip); - pci_disable_device(pci); + if (err < 0) return err; - } chip->port = pci_resource_start(pci, 0); - if (request_irq(pci->irq, snd_via82xx_interrupt, IRQF_SHARED, - KBUILD_MODNAME, chip)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_via82xx_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_via82xx_free(chip); return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_via82xx_free; if (ac97_clock >= 8000 && ac97_clock <= 48000) chip->ac97_clock = ac97_clock;

err = snd_via82xx_chip_init(chip); - if (err < 0) { - snd_via82xx_free(chip); - return err; - } - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_via82xx_free(chip); + if (err < 0) return err; - }

/* The 8233 ac97 controller does not implement the master bit * in the pci command register. IMHO this is a violation of the PCI spec. * We call pci_set_master here because it does not hurt. */ pci_set_master(pci); - - *r_via = chip; return 0; }

@@ -1150,9 +1112,11 @@ static int snd_via82xx_probe(struct pci_dev *pci, unsigned int i; int err;

- 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;

card_type = pci_id->driver_data; switch (card_type) { @@ -1162,22 +1126,20 @@ static int snd_via82xx_probe(struct pci_dev *pci, break; default: dev_err(card->dev, "invalid card type %d\n", card_type); - err = -EINVAL; - goto __error; + return -EINVAL; } err = snd_via82xx_create(card, pci, chip_type, pci->revision, - ac97_clock, &chip); + ac97_clock); if (err < 0) - goto __error; - card->private_data = chip; + return err; err = snd_via82xx_mixer_new(chip); if (err < 0) - goto __error; + return err;

err = snd_via686_pcm_new(chip); if (err < 0) - goto __error; + return err;

/* disable interrupts */ for (i = 0; i < chip->num_devs; i++) @@ -1189,28 +1151,16 @@ static int snd_via82xx_probe(struct pci_dev *pci, snd_via82xx_proc_init(chip);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); return 0; - - __error: - snd_card_free(card); - return err; -} - -static void snd_via82xx_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver via82xx_modem_driver = { .name = KBUILD_MODNAME, .id_table = snd_via82xx_modem_ids, .probe = snd_via82xx_probe, - .remove = snd_via82xx_remove, .driver = { .pm = SND_VIA82XX_PM_OPS, },

This patch converts the resource management in PCI au88x0 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/au88x0/au88x0.c | 134 +++++++++----------------------------- 1 file changed, 29 insertions(+), 105 deletions(-)

diff --git a/sound/pci/au88x0/au88x0.c b/sound/pci/au88x0/au88x0.c index 1f7fee470266..342ef2a6655e 100644 --- a/sound/pci/au88x0/au88x0.c +++ b/sound/pci/au88x0/au88x0.c @@ -123,56 +123,35 @@ static void snd_vortex_workaround(struct pci_dev *vortex, int fix)

// component-destructor // (see "Management of Cards and Components") -static int snd_vortex_dev_free(struct snd_device *device) +static void snd_vortex_free(struct snd_card *card) { - vortex_t *vortex = device->device_data; + vortex_t *vortex = card->private_data;

vortex_gameport_unregister(vortex); vortex_core_shutdown(vortex); - // Take down PCI interface. - free_irq(vortex->irq, vortex); - iounmap(vortex->mmio); - pci_release_regions(vortex->pci_dev); - pci_disable_device(vortex->pci_dev); - kfree(vortex); - - return 0; }

// chip-specific constructor // (see "Management of Cards and Components") static int -snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) +snd_vortex_create(struct snd_card *card, struct pci_dev *pci) { - vortex_t *chip; + vortex_t *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_vortex_dev_free, - }; - - *rchip = NULL;

// check PCI availability (DMA). - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err; if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) { dev_err(card->dev, "error to set DMA mask\n"); - pci_disable_device(pci); return -ENXIO; }

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

// initialize the stuff chip->pci_dev = pci; - chip->io = pci_resource_start(pci, 0); chip->vendor = pci->vendor; chip->device = pci->device; chip->card = card; @@ -181,16 +160,12 @@ snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) // (1) PCI resource allocation // Get MMIO area // - err = pci_request_regions(pci, CARD_NAME_SHORT); + err = pcim_iomap_regions(pci, 1 << 0, CARD_NAME_SHORT); if (err) - goto regions_out; + return err;

- chip->mmio = pci_ioremap_bar(pci, 0); - if (!chip->mmio) { - dev_err(card->dev, "MMIO area remap failed.\n"); - err = -ENOMEM; - goto ioremap_out; - } + chip->io = pci_resource_start(pci, 0); + chip->mmio = pcim_iomap_table(pci)[0];

/* Init audio core. * This must be done before we do request_irq otherwise we can get spurious @@ -198,44 +173,22 @@ snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) err = vortex_core_init(chip); if (err) { dev_err(card->dev, "hw core init failed\n"); - goto core_out; + return err; }

- err = request_irq(pci->irq, vortex_interrupt, - IRQF_SHARED, KBUILD_MODNAME, chip); + err = devm_request_irq(&pci->dev, pci->irq, vortex_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip); if (err) { dev_err(card->dev, "cannot grab irq\n"); - goto irq_out; + return err; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_vortex_free;

pci_set_master(pci); // End of PCI setup. - - // Register alsa root device. - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) - goto alloc_out; - - *rchip = chip; - return 0; - - alloc_out: - free_irq(chip->irq, chip); - irq_out: - vortex_core_shutdown(chip); - core_out: - iounmap(chip->mmio); - ioremap_out: - pci_release_regions(chip->pci_dev); - regions_out: - pci_disable_device(chip->pci_dev); - //FIXME: this not the right place to unregister the gameport - vortex_gameport_unregister(chip); - kfree(chip); - return err; }

// constructor -- see "Constructor" sub-section @@ -255,17 +208,16 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) return -ENOENT; } // (2) - 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;

// (3) - err = snd_vortex_create(card, pci, &chip); - if (err < 0) { - snd_card_free(card); + err = snd_vortex_create(card, pci); + if (err < 0) return err; - } snd_vortex_workaround(pci, pcifix[dev]);

// Card details needed in snd_vortex_midi @@ -276,50 +228,37 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)

// (4) Alloc components. err = snd_vortex_mixer(chip); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } // ADB pcm. err = snd_vortex_new_pcm(chip, VORTEX_PCM_ADB, NR_PCM); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } #ifndef CHIP_AU8820 // ADB SPDIF err = snd_vortex_new_pcm(chip, VORTEX_PCM_SPDIF, 1); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } // A3D err = snd_vortex_new_pcm(chip, VORTEX_PCM_A3D, NR_A3D); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } #endif /* // ADB I2S if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_I2S, 1)) < 0) { - snd_card_free(card); return err; } */ #ifndef CHIP_AU8810 // WT pcm. err = snd_vortex_new_pcm(chip, VORTEX_PCM_WT, NR_WT); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } #endif err = snd_vortex_midi(chip); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

vortex_gameport_register(chip);

@@ -342,15 +281,11 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)

// (5) err = pci_read_config_word(pci, PCI_DEVICE_ID, &chip->device); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } err = pci_read_config_word(pci, PCI_VENDOR_ID, &chip->vendor); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } chip->rev = pci->revision; #ifdef CHIP_AU8830 if ((chip->rev) != 0xfe && (chip->rev) != 0xfa) { @@ -359,18 +294,14 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) chip->rev); dev_alert(card->dev, "Please email the results of 'lspci -vv' to openvortex-dev@nongnu.org.\n"); - snd_card_free(card); - err = -ENODEV; - return err; + return -ENODEV; } #endif

// (6) err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } // (7) pci_set_drvdata(pci, card); dev++; @@ -379,18 +310,11 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) return 0; }

-// destructor -- see "Destructor" sub-section -static void snd_vortex_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - // pci_driver definition static struct pci_driver vortex_driver = { .name = KBUILD_MODNAME, .id_table = snd_vortex_ids, .probe = snd_vortex_probe, - .remove = snd_vortex_remove, };

module_pci_driver(vortex_driver);

This patch converts the resource management in PCI ca0106 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/ca0106/ca0106.h | 3 +- sound/pci/ca0106/ca0106_main.c | 114 +++++++++------------------------ 2 files changed, 30 insertions(+), 87 deletions(-)

diff --git a/sound/pci/ca0106/ca0106.h b/sound/pci/ca0106/ca0106.h index 62a22ca3b9de..f246e6094289 100644 --- a/sound/pci/ca0106/ca0106.h +++ b/sound/pci/ca0106/ca0106.h @@ -667,7 +667,6 @@ struct snd_ca0106 { struct pci_dev *pci;

unsigned long port; - struct resource *res_port; int irq;

unsigned int serial; /* serial number */ @@ -688,7 +687,7 @@ struct snd_ca0106 { u8 i2c_capture_volume[4][2]; int capture_mic_line_in;

- struct snd_dma_buffer buffer; + struct snd_dma_buffer *buffer;

struct snd_ca_midi midi; struct snd_ca_midi midi2; diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 99778711006a..36fb150b72fb 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -718,7 +718,7 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) struct snd_pcm_runtime *runtime = substream->runtime; struct snd_ca0106_pcm *epcm = runtime->private_data; int channel = epcm->channel_id; - u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel)); + u32 *table_base = (u32 *)(emu->buffer->area+(8*16*channel)); u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); u32 hcfg_mask = HCFG_PLAYBACK_S32_LE; u32 hcfg_set = 0x00000000; @@ -746,7 +746,7 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) runtime->dma_addr, runtime->dma_area, table_base); dev_dbg(emu->card->dev, "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n", - emu->buffer.addr, emu->buffer.area, emu->buffer.bytes); + emu->buffer->addr, emu->buffer->area, emu->buffer->bytes); #endif /* debug */ /* Rate can be set per channel. */ /* reg40 control host to fifo */ @@ -796,13 +796,13 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) reg71 = (reg71 & ~reg71_mask) | reg71_set; snd_ca0106_ptr_write(emu, 0x71, 0, reg71);

- /* FIXME: Check emu->buffer.size before actually writing to it. */ + /* FIXME: Check emu->buffer->size before actually writing to it. */ for(i=0; i < runtime->periods; i++) { table_base[i*2] = runtime->dma_addr + (i * period_size_bytes); table_base[i*2+1] = period_size_bytes << 16; }

- snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel)); + snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer->addr+(8*16*channel)); snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19); snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0); snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr); @@ -853,7 +853,7 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream) runtime->dma_addr, runtime->dma_area, table_base); dev_dbg(emu->card->dev, "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n", - emu->buffer.addr, emu->buffer.area, emu->buffer.bytes); + emu->buffer->addr, emu->buffer->area, emu->buffer->bytes); #endif /* debug */ /* reg71 controls ADC rate. */ switch (runtime->rate) { @@ -1183,32 +1183,11 @@ static int snd_ca0106_ac97(struct snd_ca0106 *chip)

static void ca0106_stop_chip(struct snd_ca0106 *chip);

-static int snd_ca0106_free(struct snd_ca0106 *chip) +static void snd_ca0106_free(struct snd_card *card) { - if (chip->res_port != NULL) { - /* avoid access to already used hardware */ - ca0106_stop_chip(chip); - } - if (chip->irq >= 0) - free_irq(chip->irq, chip); - // release the data -#if 1 - if (chip->buffer.area) - snd_dma_free_pages(&chip->buffer); -#endif - - // release the i/o port - release_and_free_resource(chip->res_port); - - pci_disable_device(chip->pci); - kfree(chip); - return 0; -} + struct snd_ca0106 *chip = card->private_data;

-static int snd_ca0106_dev_free(struct snd_device *device) -{ - struct snd_ca0106 *chip = device->device_data; - return snd_ca0106_free(chip); + ca0106_stop_chip(chip); }

static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id) @@ -1594,50 +1573,33 @@ static void ca0106_stop_chip(struct snd_ca0106 *chip) }

static int snd_ca0106_create(int dev, struct snd_card *card, - struct pci_dev *pci, - struct snd_ca0106 **rchip) + struct pci_dev *pci) { - struct snd_ca0106 *chip; + struct snd_ca0106 *chip = card->private_data; const struct snd_ca0106_details *c; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_ca0106_dev_free, - }; - - *rchip = NULL;

- err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err; if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) { dev_err(card->dev, "error to set 32bit mask DMA\n"); - pci_disable_device(pci); return -ENXIO; }

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

spin_lock_init(&chip->emu_lock);

+ err = pci_request_regions(pci, "snd_ca0106"); + if (err < 0) + return err; chip->port = pci_resource_start(pci, 0); - chip->res_port = request_region(chip->port, 0x20, "snd_ca0106"); - if (!chip->res_port) { - snd_ca0106_free(chip); - dev_err(card->dev, "cannot allocate the port\n"); - return -EBUSY; - }

- if (request_irq(pci->irq, snd_ca0106_interrupt, - IRQF_SHARED, KBUILD_MODNAME, chip)) { - snd_ca0106_free(chip); + if (devm_request_irq(&pci->dev, pci->irq, snd_ca0106_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(card->dev, "cannot grab irq\n"); return -EBUSY; } @@ -1645,11 +1607,9 @@ static int snd_ca0106_create(int dev, struct snd_card *card, card->sync_irq = chip->irq;

/* This stores the periods table. */ - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - 1024, &chip->buffer) < 0) { - snd_ca0106_free(chip); + chip->buffer = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024); + if (!chip->buffer) return -ENOMEM; - }

pci_set_master(pci); /* read serial */ @@ -1678,13 +1638,6 @@ static int snd_ca0106_create(int dev, struct snd_card *card, c->name, chip->port, chip->irq);

ca0106_init_chip(chip, 0); - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - snd_ca0106_free(chip); - return err; - } - *rchip = chip; return 0; }

@@ -1787,36 +1740,37 @@ static int snd_ca0106_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_ca0106_create(dev, card, pci, &chip); + err = snd_ca0106_create(dev, card, pci); if (err < 0) - goto error; - card->private_data = chip; + return err; + card->private_free = snd_ca0106_free;

for (i = 0; i < 4; i++) { err = snd_ca0106_pcm(chip, i); if (err < 0) - goto error; + return err; }

if (chip->details->ac97 == 1) { /* The SB0410 and SB0413 do not have an AC97 chip. */ err = snd_ca0106_ac97(chip); if (err < 0) - goto error; + return err; } err = snd_ca0106_mixer(chip); if (err < 0) - goto error; + return err;

dev_dbg(card->dev, "probe for MIDI channel A ..."); err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A); if (err < 0) - goto error; + return err; dev_dbg(card->dev, " done.\n");

#ifdef CONFIG_SND_PROC_FS @@ -1825,20 +1779,11 @@ static int snd_ca0106_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto error; + return err;

pci_set_drvdata(pci, card); dev++; return 0; - - error: - snd_card_free(card); - return err; -} - -static void snd_ca0106_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

#ifdef CONFIG_PM_SLEEP @@ -1894,7 +1839,6 @@ static struct pci_driver ca0106_driver = { .name = KBUILD_MODNAME, .id_table = snd_ca0106_ids, .probe = snd_ca0106_probe, - .remove = snd_ca0106_remove, .driver = { .pm = SND_CA0106_PM_OPS, },

This patch converts the resource management in PCI cs5535audio 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. A slight uncertain change is the call of olpc_quirks_cleanup() at removal: formerly this was called unconditionally at remove, but this should be a conditionally call, hence the machine_is_olpc() check is added here as well.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/cs5535audio/cs5535audio.c | 94 +++++------------------- sound/pci/cs5535audio/cs5535audio_olpc.c | 7 +- 2 files changed, 23 insertions(+), 78 deletions(-)

diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c index e048b45d9e7e..499fa0148f9a 100644 --- a/sound/pci/cs5535audio/cs5535audio.c +++ b/sound/pci/cs5535audio/cs5535audio.c @@ -237,51 +237,24 @@ static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id) return IRQ_HANDLED; }

-static int snd_cs5535audio_free(struct cs5535audio *cs5535au) +static void snd_cs5535audio_free(struct snd_card *card) { - pci_set_power_state(cs5535au->pci, PCI_D3hot); - - if (cs5535au->irq >= 0) - free_irq(cs5535au->irq, cs5535au); - - pci_release_regions(cs5535au->pci); - pci_disable_device(cs5535au->pci); - kfree(cs5535au); - return 0; -} - -static int snd_cs5535audio_dev_free(struct snd_device *device) -{ - struct cs5535audio *cs5535au = device->device_data; - return snd_cs5535audio_free(cs5535au); + olpc_quirks_cleanup(); }

static int snd_cs5535audio_create(struct snd_card *card, - struct pci_dev *pci, - struct cs5535audio **rcs5535au) + struct pci_dev *pci) { - struct cs5535audio *cs5535au; - + struct cs5535audio *cs5535au = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_cs5535audio_dev_free, - };

- *rcs5535au = NULL; - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err;

if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) { dev_warn(card->dev, "unable to get 32bit dma\n"); - err = -ENXIO; - goto pcifail; - } - - cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL); - if (cs5535au == NULL) { - err = -ENOMEM; - goto pcifail; + return -ENXIO; }

spin_lock_init(&cs5535au->reg_lock); @@ -290,38 +263,22 @@ static int snd_cs5535audio_create(struct snd_card *card, cs5535au->irq = -1;

err = pci_request_regions(pci, "CS5535 Audio"); - if (err < 0) { - kfree(cs5535au); - goto pcifail; - } + if (err < 0) + return err;

cs5535au->port = pci_resource_start(pci, 0);

- if (request_irq(pci->irq, snd_cs5535audio_interrupt, - IRQF_SHARED, KBUILD_MODNAME, cs5535au)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_cs5535audio_interrupt, + IRQF_SHARED, KBUILD_MODNAME, cs5535au)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - err = -EBUSY; - goto sndfail; + return -EBUSY; }

cs5535au->irq = pci->irq; card->sync_irq = cs5535au->irq; pci_set_master(pci);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, cs5535au, &ops); - if (err < 0) - goto sndfail; - - *rcs5535au = cs5535au; return 0; - -sndfail: /* leave the device alive, just kill the snd */ - snd_cs5535audio_free(cs5535au); - return err; - -pcifail: - pci_disable_device(pci); - return err; }

static int snd_cs5535audio_probe(struct pci_dev *pci, @@ -339,24 +296,24 @@ static int snd_cs5535audio_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(*cs5535au), &card); if (err < 0) return err; + cs5535au = card->private_data; + card->private_free = snd_cs5535audio_free;

- err = snd_cs5535audio_create(card, pci, &cs5535au); + err = snd_cs5535audio_create(card, pci); if (err < 0) - goto probefail_out; - - card->private_data = cs5535au; + return err;

err = snd_cs5535audio_mixer(cs5535au); if (err < 0) - goto probefail_out; + return err;

err = snd_cs5535audio_pcm(cs5535au); if (err < 0) - goto probefail_out; + return err;

strcpy(card->driver, DRIVER_NAME);

@@ -367,28 +324,17 @@ static int snd_cs5535audio_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto probefail_out; + return err;

pci_set_drvdata(pci, card); dev++; return 0; - -probefail_out: - snd_card_free(card); - return err; -} - -static void snd_cs5535audio_remove(struct pci_dev *pci) -{ - olpc_quirks_cleanup(); - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver cs5535audio_driver = { .name = KBUILD_MODNAME, .id_table = snd_cs5535audio_ids, .probe = snd_cs5535audio_probe, - .remove = snd_cs5535audio_remove, #ifdef CONFIG_PM_SLEEP .driver = { .pm = &snd_cs5535audio_pm, diff --git a/sound/pci/cs5535audio/cs5535audio_olpc.c b/sound/pci/cs5535audio/cs5535audio_olpc.c index 110d3209441b..122170a410d9 100644 --- a/sound/pci/cs5535audio/cs5535audio_olpc.c +++ b/sound/pci/cs5535audio/cs5535audio_olpc.c @@ -171,10 +171,8 @@ int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97) for (i = 0; i < ARRAY_SIZE(olpc_cs5535audio_ctls); i++) { err = snd_ctl_add(card, snd_ctl_new1(&olpc_cs5535audio_ctls[i], ac97->private_data)); - if (err < 0) { - gpio_free(OLPC_GPIO_MIC_AC); + if (err < 0) return err; - } }

/* turn off the mic by default */ @@ -184,5 +182,6 @@ int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)

void olpc_quirks_cleanup(void) { - gpio_free(OLPC_GPIO_MIC_AC); + if (machine_is_olpc()) + gpio_free(OLPC_GPIO_MIC_AC); }

This patch converts the resource management in PCI emu10k1 driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, the page allocations are done with the 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- include/sound/emu10k1.h | 6 +- sound/pci/emu10k1/emu10k1.c | 53 +++++++--------- sound/pci/emu10k1/emu10k1_main.c | 102 ++++++++----------------------- sound/pci/emu10k1/p16v.c | 22 ++----- 4 files changed, 52 insertions(+), 131 deletions(-)

diff --git a/include/sound/emu10k1.h b/include/sound/emu10k1.h index 468e38c54dd3..39787fecc8d9 100644 --- a/include/sound/emu10k1.h +++ b/include/sound/emu10k1.h @@ -1701,7 +1701,7 @@ struct snd_emu10k1 { struct snd_dma_buffer silent_page; /* silent page */ struct snd_dma_buffer ptb_pages; /* page table pages */ struct snd_dma_device p16v_dma_dev; - struct snd_dma_buffer p16v_buffer; + struct snd_dma_buffer *p16v_buffer;

struct snd_util_memhdr *memhdr; /* page allocation list */

@@ -1796,14 +1796,12 @@ int snd_emu10k1_create(struct snd_card *card, unsigned short extout_mask, long max_cache_bytes, int enable_ir, - uint subsystem, - struct snd_emu10k1 ** remu); + uint subsystem);

int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device); int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device); int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device); int snd_p16v_pcm(struct snd_emu10k1 *emu, int device); -int snd_p16v_free(struct snd_emu10k1 * emu); int snd_p16v_mixer(struct snd_emu10k1 * emu); int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device); int snd_emu10k1_fx8010_pcm(struct snd_emu10k1 *emu, int device); diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c index 887bfb3c1e17..672af4b9597b 100644 --- a/sound/pci/emu10k1/emu10k1.c +++ b/sound/pci/emu10k1/emu10k1.c @@ -99,67 +99,67 @@ static int snd_card_emu10k1_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(*emu), &card); if (err < 0) return err; + emu = card->private_data; + if (max_buffer_size[dev] < 32) max_buffer_size[dev] = 32; else if (max_buffer_size[dev] > 1024) max_buffer_size[dev] = 1024; err = snd_emu10k1_create(card, pci, extin[dev], extout[dev], (long)max_buffer_size[dev] * 1024 * 1024, - enable_ir[dev], subsystem[dev], - &emu); + enable_ir[dev], subsystem[dev]); if (err < 0) - goto error; - card->private_data = emu; + return err; emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f; err = snd_emu10k1_pcm(emu, 0); if (err < 0) - goto error; + return err; err = snd_emu10k1_pcm_mic(emu, 1); if (err < 0) - goto error; + return err; err = snd_emu10k1_pcm_efx(emu, 2); if (err < 0) - goto error; + return err; /* This stores the periods table. */ if (emu->card_capabilities->ca0151_chip) { /* P16V */ - err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - 1024, &emu->p16v_buffer); - if (err < 0) - goto error; + emu->p16v_buffer = + snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024); + if (!emu->p16v_buffer) + return -ENOMEM; }

err = snd_emu10k1_mixer(emu, 0, 3); if (err < 0) - goto error; + return err; err = snd_emu10k1_timer(emu, 0); if (err < 0) - goto error; + return err;

err = snd_emu10k1_pcm_multi(emu, 3); if (err < 0) - goto error; + return err; if (emu->card_capabilities->ca0151_chip) { /* P16V */ err = snd_p16v_pcm(emu, 4); if (err < 0) - goto error; + return err; } if (emu->audigy) { err = snd_emu10k1_audigy_midi(emu); if (err < 0) - goto error; + return err; } else { err = snd_emu10k1_midi(emu); if (err < 0) - goto error; + return err; } err = snd_emu10k1_fx8010_new(emu, 0); if (err < 0) - goto error; + return err; #ifdef ENABLE_SYNTH if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH, sizeof(struct snd_emu10k1_synth_arg), &wave) < 0 || @@ -187,7 +187,7 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto error; + return err;

if (emu->card_capabilities->emu_model) schedule_delayed_work(&emu->emu1010.firmware_work, 0); @@ -195,18 +195,8 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci, pci_set_drvdata(pci, card); dev++; return 0; - - error: - snd_card_free(card); - return err; }

-static void snd_card_emu10k1_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - - #ifdef CONFIG_PM_SLEEP static int snd_emu10k1_suspend(struct device *dev) { @@ -263,7 +253,6 @@ static struct pci_driver emu10k1_driver = { .name = KBUILD_MODNAME, .id_table = snd_emu10k1_ids, .probe = snd_card_emu10k1_probe, - .remove = snd_card_emu10k1_remove, .driver = { .pm = SND_EMU10K1_PM_OPS, }, diff --git a/sound/pci/emu10k1/emu10k1_main.c b/sound/pci/emu10k1/emu10k1_main.c index 24a2fd706d69..86cc1ca025e4 100644 --- a/sound/pci/emu10k1/emu10k1_main.c +++ b/sound/pci/emu10k1/emu10k1_main.c @@ -1242,8 +1242,10 @@ static int alloc_pm_buffer(struct snd_emu10k1 *emu); static void free_pm_buffer(struct snd_emu10k1 *emu); #endif

-static int snd_emu10k1_free(struct snd_emu10k1 *emu) +static void snd_emu10k1_free(struct snd_card *card) { + struct snd_emu10k1 *emu = card->private_data; + if (emu->port) { /* avoid access to already used hardware */ snd_emu10k1_fx8010_tram_setup(emu, 0); snd_emu10k1_done(emu); @@ -1256,8 +1258,6 @@ static int snd_emu10k1_free(struct snd_emu10k1 *emu) cancel_delayed_work_sync(&emu->emu1010.firmware_work); release_firmware(emu->firmware); release_firmware(emu->dock_fw); - if (emu->irq >= 0) - free_irq(emu->irq, emu); snd_util_memhdr_free(emu->memhdr); if (emu->silent_page.area) snd_dma_free_pages(&emu->silent_page); @@ -1268,19 +1268,6 @@ static int snd_emu10k1_free(struct snd_emu10k1 *emu) #ifdef CONFIG_PM_SLEEP free_pm_buffer(emu); #endif - if (emu->port) - pci_release_regions(emu->pci); - if (emu->card_capabilities->ca0151_chip) /* P16V */ - snd_p16v_free(emu); - pci_disable_device(emu->pci); - kfree(emu); - return 0; -} - -static int snd_emu10k1_dev_free(struct snd_device *device) -{ - struct snd_emu10k1 *emu = device->device_data; - return snd_emu10k1_free(emu); }

static const struct snd_emu_chip_details emu_chip_details[] = { @@ -1782,32 +1769,22 @@ int snd_emu10k1_create(struct snd_card *card, unsigned short extout_mask, long max_cache_bytes, int enable_ir, - uint subsystem, - struct snd_emu10k1 **remu) + uint subsystem) { - struct snd_emu10k1 *emu; + struct snd_emu10k1 *emu = card->private_data; int idx, err; int is_audigy; size_t page_table_size; __le32 *pgtbl; unsigned int silent_page; const struct snd_emu_chip_details *c; - static const struct snd_device_ops ops = { - .dev_free = snd_emu10k1_dev_free, - }; - - *remu = NULL;

/* enable PCI device */ - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err;

- emu = kzalloc(sizeof(*emu), GFP_KERNEL); - if (emu == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } + card->private_free = snd_emu10k1_free; emu->card = card; spin_lock_init(&emu->reg_lock); spin_lock_init(&emu->emu_lock); @@ -1850,8 +1827,6 @@ int snd_emu10k1_create(struct snd_card *card, } if (c->vendor == 0) { dev_err(card->dev, "emu10k1: Card not recognised\n"); - kfree(emu); - pci_disable_device(pci); return -ENOENT; } emu->card_capabilities = c; @@ -1883,8 +1858,6 @@ int snd_emu10k1_create(struct snd_card *card, dev_err(card->dev, "architecture does not support PCI busmaster DMA with mask 0x%lx\n", emu->dma_mask); - kfree(emu); - pci_disable_device(pci); return -ENXIO; } if (is_audigy) @@ -1893,11 +1866,8 @@ int snd_emu10k1_create(struct snd_card *card, emu->gpr_base = FXGPREGBASE;

err = pci_request_regions(pci, "EMU10K1"); - if (err < 0) { - kfree(emu); - pci_disable_device(pci); + if (err < 0) return err; - } emu->port = pci_resource_start(pci, 0);

emu->max_cache_pages = max_cache_bytes >> PAGE_SHIFT; @@ -1905,10 +1875,8 @@ int snd_emu10k1_create(struct snd_card *card, page_table_size = sizeof(u32) * (emu->address_mode ? MAXPAGES1 : MAXPAGES0); if (snd_emu10k1_alloc_pages_maybe_wider(emu, page_table_size, - &emu->ptb_pages) < 0) { - err = -ENOMEM; - goto error; - } + &emu->ptb_pages) < 0) + return -ENOMEM; dev_dbg(card->dev, "page table address range is %.8lx:%.8lx\n", (unsigned long)emu->ptb_pages.addr, (unsigned long)(emu->ptb_pages.addr + emu->ptb_pages.bytes)); @@ -1917,26 +1885,20 @@ int snd_emu10k1_create(struct snd_card *card, emu->max_cache_pages)); emu->page_addr_table = vmalloc(array_size(sizeof(unsigned long), emu->max_cache_pages)); - if (emu->page_ptr_table == NULL || emu->page_addr_table == NULL) { - err = -ENOMEM; - goto error; - } + if (!emu->page_ptr_table || !emu->page_addr_table) + return -ENOMEM;

if (snd_emu10k1_alloc_pages_maybe_wider(emu, EMUPAGESIZE, - &emu->silent_page) < 0) { - err = -ENOMEM; - goto error; - } + &emu->silent_page) < 0) + return -ENOMEM; dev_dbg(card->dev, "silent page range is %.8lx:%.8lx\n", (unsigned long)emu->silent_page.addr, (unsigned long)(emu->silent_page.addr + emu->silent_page.bytes));

emu->memhdr = snd_util_memhdr_new(emu->max_cache_pages * PAGE_SIZE); - if (emu->memhdr == NULL) { - err = -ENOMEM; - goto error; - } + if (!emu->memhdr) + return -ENOMEM; emu->memhdr->block_extra_size = sizeof(struct snd_emu10k1_memblk) - sizeof(struct snd_util_memblk);

@@ -1954,18 +1916,16 @@ int snd_emu10k1_create(struct snd_card *card, if (emu->card_capabilities->ca_cardbus_chip) { err = snd_emu10k1_cardbus_init(emu); if (err < 0) - goto error; + return err; } if (emu->card_capabilities->ecard) { err = snd_emu10k1_ecard_init(emu); if (err < 0) - goto error; + return err; } else if (emu->card_capabilities->emu_model) { err = snd_emu10k1_emu1010_init(emu); - if (err < 0) { - snd_emu10k1_free(emu); + if (err < 0) return err; - } } else { /* 5.1: Enable the additional AC97 Slots. If the emu10k1 version does not support this, it shouldn't do any harm */ @@ -1979,11 +1939,9 @@ int snd_emu10k1_create(struct snd_card *card, emu->fx8010.etram_pages.bytes = 0;

/* irq handler must be registered after I/O ports are activated */ - if (request_irq(pci->irq, snd_emu10k1_interrupt, IRQF_SHARED, - KBUILD_MODNAME, emu)) { - err = -EBUSY; - goto error; - } + if (devm_request_irq(&pci->dev, pci->irq, snd_emu10k1_interrupt, + IRQF_SHARED, KBUILD_MODNAME, emu)) + return -EBUSY; emu->irq = pci->irq; card->sync_irq = emu->irq;

@@ -2022,33 +1980,23 @@ int snd_emu10k1_create(struct snd_card *card,

err = snd_emu10k1_init(emu, enable_ir, 0); if (err < 0) - goto error; + return err; #ifdef CONFIG_PM_SLEEP err = alloc_pm_buffer(emu); if (err < 0) - goto error; + return err; #endif

/* Initialize the effect engine */ err = snd_emu10k1_init_efx(emu); if (err < 0) - goto error; + return err; snd_emu10k1_audio_enable(emu);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, emu, &ops); - if (err < 0) - goto error; - #ifdef CONFIG_SND_PROC_FS snd_emu10k1_proc_init(emu); #endif - - *remu = emu; return 0; - - error: - snd_emu10k1_free(emu); - return err; }

#ifdef CONFIG_PM_SLEEP diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c index ff2a3974c824..18a1b0740e6b 100644 --- a/sound/pci/emu10k1/p16v.c +++ b/sound/pci/emu10k1/p16v.c @@ -290,7 +290,7 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream) struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int channel = substream->pcm->device - emu->p16v_device_offset; - u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel)); + u32 *table_base = (u32 *)(emu->p16v_buffer->area+(8*16*channel)); u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); int i; u32 tmp; @@ -308,8 +308,8 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream) runtime->dma_addr, runtime->dma_area, table_base); dev_dbg(emu->card->dev, "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n", - emu->p16v_buffer.addr, emu->p16v_buffer.area, - emu->p16v_buffer.bytes); + emu->p16v_buffer->addr, emu->p16v_buffer->area, + emu->p16v_buffer->bytes); #endif /* debug */ tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel); switch (runtime->rate) { @@ -333,7 +333,7 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream) table_base[(i*2)+1]=period_size_bytes<<16; }

- snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer.addr+(8*16*channel)); + snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer->addr+(8*16*channel)); snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19); snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_PTR, channel, 0); snd_emu10k1_ptr20_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr); @@ -567,20 +567,6 @@ static const struct snd_pcm_ops snd_p16v_capture_ops = { .pointer = snd_p16v_pcm_pointer_capture, };

- -int snd_p16v_free(struct snd_emu10k1 *chip) -{ - // release the data - if (chip->p16v_buffer.area) { - snd_dma_free_pages(&chip->p16v_buffer); - /* - dev_dbg(chip->card->dev, "period lables free: %p\n", - &chip->p16v_buffer); - */ - } - return 0; -} - int snd_p16v_pcm(struct snd_emu10k1 *emu, int device) { struct snd_pcm *pcm;

This patch converts the resource management in PCI ice1712 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. Along with it, the chip_exit callback chain is moved into the card's private_free instead of the PCI remove callback, too.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/ice1712/ice1712.c | 133 ++++++++---------------------------- 1 file changed, 30 insertions(+), 103 deletions(-)

diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c index d54cd5143e9f..a5241a287851 100644 --- a/sound/pci/ice1712/ice1712.c +++ b/sound/pci/ice1712/ice1712.c @@ -2432,31 +2432,18 @@ static int snd_ice1712_build_controls(struct snd_ice1712 *ice) snd_ctl_new1(&snd_ice1712_mixer_pro_peak, ice)); }

-static int snd_ice1712_free(struct snd_ice1712 *ice) +static void snd_ice1712_free(struct snd_card *card) { - if (!ice->port) - goto __hw_end; + struct snd_ice1712 *ice = card->private_data; + + if (ice->card_info && ice->card_info->chip_exit) + ice->card_info->chip_exit(ice); + /* mask all interrupts */ outb(ICE1712_MULTI_CAPTURE | ICE1712_MULTI_PLAYBACK, ICEMT(ice, IRQ)); outb(0xff, ICEREG(ice, IRQMASK)); - /* --- */ -__hw_end: - if (ice->irq >= 0) - free_irq(ice->irq, ice);

- if (ice->port) - pci_release_regions(ice->pci); snd_ice1712_akm4xxx_free(ice); - pci_disable_device(ice->pci); - kfree(ice->spec); - kfree(ice); - return 0; -} - -static int snd_ice1712_dev_free(struct snd_device *device) -{ - struct snd_ice1712 *ice = device->device_data; - return snd_ice1712_free(ice); }

static int snd_ice1712_create(struct snd_card *card, @@ -2464,34 +2451,22 @@ static int snd_ice1712_create(struct snd_card *card, const char *modelname, int omni, int cs8427_timeout, - int dxr_enable, - struct snd_ice1712 **r_ice1712) + int dxr_enable) { - struct snd_ice1712 *ice; + struct snd_ice1712 *ice = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_ice1712_dev_free, - }; - - *r_ice1712 = NULL;

/* enable PCI device */ - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err; /* check, if we can restrict PCI DMA transfers to 28 bits */ if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28))) { dev_err(card->dev, "architecture does not support 28bit PCI busmaster DMA\n"); - pci_disable_device(pci); return -ENXIO; }

- ice = kzalloc(sizeof(*ice), GFP_KERNEL); - if (ice == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } ice->omni = omni ? 1 : 0; if (cs8427_timeout < 1) cs8427_timeout = 1; @@ -2523,45 +2498,29 @@ static int snd_ice1712_create(struct snd_card *card, pci_write_config_word(ice->pci, 0x42, 0x0006); snd_ice1712_proc_init(ice);

- card->private_data = ice; - err = pci_request_regions(pci, "ICE1712"); - if (err < 0) { - kfree(ice); - pci_disable_device(pci); + if (err < 0) return err; - } ice->port = pci_resource_start(pci, 0); ice->ddma_port = pci_resource_start(pci, 1); ice->dmapath_port = pci_resource_start(pci, 2); ice->profi_port = pci_resource_start(pci, 3);

- if (request_irq(pci->irq, snd_ice1712_interrupt, IRQF_SHARED, - KBUILD_MODNAME, ice)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_ice1712_interrupt, + IRQF_SHARED, KBUILD_MODNAME, ice)) { dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); - snd_ice1712_free(ice); return -EIO; }

ice->irq = pci->irq; card->sync_irq = ice->irq; + card->private_free = snd_ice1712_free;

- if (snd_ice1712_read_eeprom(ice, modelname) < 0) { - snd_ice1712_free(ice); + if (snd_ice1712_read_eeprom(ice, modelname) < 0) return -EIO; - } - if (snd_ice1712_chip_init(ice) < 0) { - snd_ice1712_free(ice); + if (snd_ice1712_chip_init(ice) < 0) return -EIO; - } - - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops); - if (err < 0) { - snd_ice1712_free(ice); - return err; - }

- *r_ice1712 = ice; return 0; }

@@ -2591,34 +2550,31 @@ static int snd_ice1712_probe(struct pci_dev *pci, }

err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, - 0, &card); + sizeof(*ice), &card); if (err < 0) return err; + ice = card->private_data;

strcpy(card->driver, "ICE1712"); strcpy(card->shortname, "ICEnsemble ICE1712");

err = snd_ice1712_create(card, pci, model[dev], omni[dev], - cs8427_timeout[dev], dxr_enable[dev], &ice); - if (err < 0) { - snd_card_free(card); + cs8427_timeout[dev], dxr_enable[dev]); + if (err < 0) return err; - }

for (tbl = card_tables; *tbl; tbl++) { for (c = *tbl; c->subvendor; c++) { if (c->subvendor == ice->eeprom.subvendor) { - ice->card_info = c; strcpy(card->shortname, c->name); if (c->driver) /* specific driver? */ strcpy(card->driver, c->driver); if (c->chip_init) { err = c->chip_init(ice); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } } + ice->card_info = c; goto __found; } } @@ -2627,45 +2583,33 @@ static int snd_ice1712_probe(struct pci_dev *pci, __found:

err = snd_ice1712_pcm_profi(ice, pcm_dev++); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

if (ice_has_con_ac97(ice)) { err = snd_ice1712_pcm(ice, pcm_dev++); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } }

err = snd_ice1712_ac97_mixer(ice); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

err = snd_ice1712_build_controls(ice); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - }

if (c->build_controls) { err = c->build_controls(ice); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } }

if (ice_has_con_ac97(ice)) { err = snd_ice1712_pcm_ds(ice, pcm_dev++); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } }

if (!c->no_mpu401) { @@ -2674,10 +2618,8 @@ static int snd_ice1712_probe(struct pci_dev *pci, c->mpu401_1_info_flags | MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK, -1, &ice->rmidi[0]); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } if (c->mpu401_1_name) /* Preferred name available in card_info */ snprintf(ice->rmidi[0]->name, @@ -2692,10 +2634,8 @@ static int snd_ice1712_probe(struct pci_dev *pci, MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK, -1, &ice->rmidi[1]);

- if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } if (c->mpu401_2_name) /* Preferred name available in card_info */ snprintf(ice->rmidi[1]->name, @@ -2711,25 +2651,13 @@ static int snd_ice1712_probe(struct pci_dev *pci, card->shortname, ice->port, ice->irq);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_ice1712_remove(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_ice1712 *ice = card->private_data; - - if (ice->card_info && ice->card_info->chip_exit) - ice->card_info->chip_exit(ice); - snd_card_free(card); -} - #ifdef CONFIG_PM_SLEEP static int snd_ice1712_suspend(struct device *dev) { @@ -2810,7 +2738,6 @@ static struct pci_driver ice1712_driver = { .name = KBUILD_MODNAME, .id_table = snd_ice1712_ids, .probe = snd_ice1712_probe, - .remove = snd_ice1712_remove, .driver = { .pm = SND_VT1712_PM_OPS, },

This patch converts the resource management in PCI korg1212 driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, the page allocations are done with the 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/korg1212/korg1212.c | 211 +++++++++------------------------- 1 file changed, 55 insertions(+), 156 deletions(-)

diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c index 030e01b062e4..7872abbd4587 100644 --- a/sound/pci/korg1212/korg1212.c +++ b/sound/pci/korg1212/korg1212.c @@ -320,10 +320,10 @@ struct snd_korg1212 { unsigned long inIRQ; void __iomem *iobase;

- struct snd_dma_buffer dma_dsp; - struct snd_dma_buffer dma_play; - struct snd_dma_buffer dma_rec; - struct snd_dma_buffer dma_shared; + struct snd_dma_buffer *dma_dsp; + struct snd_dma_buffer *dma_play; + struct snd_dma_buffer *dma_rec; + struct snd_dma_buffer *dma_shared;

u32 DataBufsSize;

@@ -1200,8 +1200,8 @@ static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212) snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS);

rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload, - UpperWordSwap(korg1212->dma_dsp.addr), - 0, 0, 0); + UpperWordSwap(korg1212->dma_dsp->addr), + 0, 0, 0); if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n", rc, stateName[korg1212->cardState]); @@ -1382,7 +1382,7 @@ static int snd_korg1212_playback_open(struct snd_pcm_substream *substream) snd_korg1212_OpenCard(korg1212);

runtime->hw = snd_korg1212_playback_info; - snd_pcm_set_runtime_buffer(substream, &korg1212->dma_play); + snd_pcm_set_runtime_buffer(substream, korg1212->dma_play);

spin_lock_irqsave(&korg1212->lock, flags);

@@ -1413,7 +1413,7 @@ static int snd_korg1212_capture_open(struct snd_pcm_substream *substream) snd_korg1212_OpenCard(korg1212);

runtime->hw = snd_korg1212_capture_info; - snd_pcm_set_runtime_buffer(substream, &korg1212->dma_rec); + snd_pcm_set_runtime_buffer(substream, korg1212->dma_rec);

spin_lock_irqsave(&korg1212->lock, flags);

@@ -2080,71 +2080,16 @@ static void snd_korg1212_proc_init(struct snd_korg1212 *korg1212) snd_korg1212_proc_read); }

-static int -snd_korg1212_free(struct snd_korg1212 *korg1212) +static void +snd_korg1212_free(struct snd_card *card) { - snd_korg1212_TurnOffIdleMonitor(korg1212); - - if (korg1212->irq >= 0) { - snd_korg1212_DisableCardInterrupts(korg1212); - free_irq(korg1212->irq, korg1212); - korg1212->irq = -1; - } - - if (korg1212->iobase != NULL) { - iounmap(korg1212->iobase); - korg1212->iobase = NULL; - } - - pci_release_regions(korg1212->pci); - - // ---------------------------------------------------- - // free up memory resources used for the DSP download. - // ---------------------------------------------------- - if (korg1212->dma_dsp.area) { - snd_dma_free_pages(&korg1212->dma_dsp); - korg1212->dma_dsp.area = NULL; - } - -#ifndef K1212_LARGEALLOC - - // ------------------------------------------------------ - // free up memory resources used for the Play/Rec Buffers - // ------------------------------------------------------ - if (korg1212->dma_play.area) { - snd_dma_free_pages(&korg1212->dma_play); - korg1212->dma_play.area = NULL; - } + struct snd_korg1212 *korg1212 = card->private_data;

- if (korg1212->dma_rec.area) { - snd_dma_free_pages(&korg1212->dma_rec); - korg1212->dma_rec.area = NULL; - } - -#endif - - // ---------------------------------------------------- - // free up memory resources used for the Shared Buffers - // ---------------------------------------------------- - if (korg1212->dma_shared.area) { - snd_dma_free_pages(&korg1212->dma_shared); - korg1212->dma_shared.area = NULL; - } - - pci_disable_device(korg1212->pci); - kfree(korg1212); - return 0; -} - -static int snd_korg1212_dev_free(struct snd_device *device) -{ - struct snd_korg1212 *korg1212 = device->device_data; - K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n"); - return snd_korg1212_free(korg1212); + snd_korg1212_TurnOffIdleMonitor(korg1212); + snd_korg1212_DisableCardInterrupts(korg1212); }

-static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, - struct snd_korg1212 **rchip) +static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci)

{ int err, rc; @@ -2152,24 +2097,13 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, unsigned iomem_size; __maybe_unused unsigned ioport_size; __maybe_unused unsigned iomem2_size; - struct snd_korg1212 * korg1212; + struct snd_korg1212 *korg1212 = card->private_data; const struct firmware *dsp_code;

- static const struct snd_device_ops ops = { - .dev_free = snd_korg1212_dev_free, - }; - - * rchip = NULL; - err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) return err;

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

@@ -2198,12 +2132,9 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, for (i=0; i<kAudioChannels; i++) korg1212->volumePhase[i] = 0;

- err = pci_request_regions(pci, "korg1212"); - if (err < 0) { - kfree(korg1212); - pci_disable_device(pci); + err = pcim_iomap_regions_request_all(pci, 1 << 0, "korg1212"); + if (err < 0) return err; - }

korg1212->iomem = pci_resource_start(korg1212->pci, 0); korg1212->ioport = pci_resource_start(korg1212->pci, 1); @@ -2223,26 +2154,20 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, korg1212->iomem2, iomem2_size, stateName[korg1212->cardState]);

- korg1212->iobase = ioremap(korg1212->iomem, iomem_size); - if (!korg1212->iobase) { - snd_printk(KERN_ERR "korg1212: unable to remap memory region 0x%lx-0x%lx\n", korg1212->iomem, - korg1212->iomem + iomem_size - 1); - snd_korg1212_free(korg1212); - return -EBUSY; - } + korg1212->iobase = pcim_iomap_table(pci)[0];

- err = request_irq(pci->irq, snd_korg1212_interrupt, + err = devm_request_irq(&pci->dev, pci->irq, snd_korg1212_interrupt, IRQF_SHARED, KBUILD_MODNAME, korg1212);

if (err) { snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq); - snd_korg1212_free(korg1212); return -EBUSY; }

korg1212->irq = pci->irq; card->sync_irq = korg1212->irq; + card->private_free = snd_korg1212_free;

pci_set_master(korg1212->pci);

@@ -2281,41 +2206,36 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, korg1212->idRegPtr, stateName[korg1212->cardState]);

- if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - sizeof(struct KorgSharedBuffer), &korg1212->dma_shared) < 0) { - snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%zd bytes)\n", sizeof(struct KorgSharedBuffer)); - snd_korg1212_free(korg1212); - return -ENOMEM; - } - korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared.area; - korg1212->sharedBufferPhy = korg1212->dma_shared.addr; + korg1212->dma_shared = snd_devm_alloc_pages(&pci->dev, + SNDRV_DMA_TYPE_DEV, + sizeof(struct KorgSharedBuffer)); + if (!korg1212->dma_shared) + return -ENOMEM; + korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared->area; + korg1212->sharedBufferPhy = korg1212->dma_shared->addr;

K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(struct KorgSharedBuffer));

#ifndef K1212_LARGEALLOC - korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers; + korg1212->dma_play = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, + korg1212->DataBufsSize); + if (!korg1212->dma_play) + return -ENOMEM;

- if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - korg1212->DataBufsSize, &korg1212->dma_play) < 0) { - snd_printk(KERN_ERR "korg1212: can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize); - snd_korg1212_free(korg1212); - return -ENOMEM; - } - korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play.area; - korg1212->PlayDataPhy = korg1212->dma_play.addr; + korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play->area; + korg1212->PlayDataPhy = korg1212->dma_play->addr;

K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n", korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize);

- if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - korg1212->DataBufsSize, &korg1212->dma_rec) < 0) { - snd_printk(KERN_ERR "korg1212: can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize); - snd_korg1212_free(korg1212); - return -ENOMEM; - } - korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec.area; - korg1212->RecDataPhy = korg1212->dma_rec.addr; + korg1212->dma_rec = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, + korg1212->DataBufsSize); + if (!korg1212->dma_rec) + return -ENOMEM; + + korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec->area; + korg1212->RecDataPhy = korg1212->dma_rec->addr;

K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n", korg1212->recordDataBufsPtr, korg1212->RecDataPhy, korg1212->DataBufsSize); @@ -2336,26 +2256,22 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, korg1212->AdatTimeCodePhy = korg1212->sharedBufferPhy + offsetof(struct KorgSharedBuffer, AdatTimeCode);

+ korg1212->dma_dsp = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, + dsp_code->size); + if (!korg1212->dma_dsp) + return -ENOMEM; + err = request_firmware(&dsp_code, "korg/k1212.dsp", &pci->dev); if (err < 0) { snd_printk(KERN_ERR "firmware not available\n"); - snd_korg1212_free(korg1212); return err; }

- if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, - dsp_code->size, &korg1212->dma_dsp) < 0) { - snd_printk(KERN_ERR "korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code->size); - snd_korg1212_free(korg1212); - release_firmware(dsp_code); - return -ENOMEM; - } - K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n", - korg1212->dma_dsp.area, korg1212->dma_dsp.addr, dsp_code->size, + korg1212->dma_dsp->area, korg1212->dma_dsp->addr, dsp_code->size, stateName[korg1212->cardState]);

- memcpy(korg1212->dma_dsp.area, dsp_code->data, dsp_code->size); + memcpy(korg1212->dma_dsp->area, dsp_code->data, dsp_code->size);

release_firmware(dsp_code);

@@ -2364,12 +2280,6 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops); - if (err < 0) { - snd_korg1212_free(korg1212); - return err; - } - snd_korg1212_EnableCardInterrupts(korg1212);

mdelay(CARD_BOOT_DELAY_IN_MS); @@ -2411,10 +2321,8 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, }

snd_korg1212_proc_init(korg1212); - - * rchip = korg1212; - return 0;

+ return 0; }

/* @@ -2437,16 +2345,15 @@ snd_korg1212_probe(struct pci_dev *pci, dev++; 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(*korg1212), &card); if (err < 0) return err; + korg1212 = card->private_data;

- err = snd_korg1212_create(card, pci, &korg1212); - if (err < 0) { - snd_card_free(card); + err = snd_korg1212_create(card, pci); + if (err < 0) return err; - }

strcpy(card->driver, "korg1212"); strcpy(card->shortname, "korg1212"); @@ -2456,25 +2363,17 @@ snd_korg1212_probe(struct pci_dev *pci, K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card->longname);

err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_korg1212_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static struct pci_driver korg1212_driver = { .name = KBUILD_MODNAME, .id_table = snd_korg1212_ids, .probe = snd_korg1212_probe, - .remove = snd_korg1212_remove, };

module_pci_driver(korg1212_driver);

This patch converts the resource management in PCI oxygen drivers with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, and the page allocations are done with the devres helper.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/oxygen/oxygen.c | 1 - sound/pci/oxygen/oxygen.h | 1 - sound/pci/oxygen/oxygen_lib.c | 66 ++++++++++++----------------------- sound/pci/oxygen/se6x.c | 1 - sound/pci/oxygen/virtuoso.c | 1 - 5 files changed, 22 insertions(+), 48 deletions(-)

diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c index e335c4b5b381..c346f42befc2 100644 --- a/sound/pci/oxygen/oxygen.c +++ b/sound/pci/oxygen/oxygen.c @@ -854,7 +854,6 @@ static struct pci_driver oxygen_driver = { .name = KBUILD_MODNAME, .id_table = oxygen_ids, .probe = generic_oxygen_probe, - .remove = oxygen_pci_remove, #ifdef CONFIG_PM_SLEEP .driver = { .pm = &oxygen_pci_pm, diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h index 06bf7e5744d0..0cae640708f3 100644 --- a/sound/pci/oxygen/oxygen.h +++ b/sound/pci/oxygen/oxygen.h @@ -161,7 +161,6 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, const struct pci_device_id *id ) ); -void oxygen_pci_remove(struct pci_dev *pci); #ifdef CONFIG_PM_SLEEP extern const struct dev_pm_ops oxygen_pci_pm; #endif diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c index afc6dd329c09..4fb3f2484fdb 100644 --- a/sound/pci/oxygen/oxygen_lib.c +++ b/sound/pci/oxygen/oxygen_lib.c @@ -570,15 +570,10 @@ static void oxygen_card_free(struct snd_card *card) struct oxygen *chip = card->private_data;

oxygen_shutdown(chip); - if (chip->irq >= 0) - free_irq(chip->irq, chip); flush_work(&chip->spdif_input_bits_work); flush_work(&chip->gpio_work); chip->model.cleanup(chip); - kfree(chip->model_data); mutex_destroy(&chip->mutex); - pci_release_regions(chip->pci); - pci_disable_device(chip->pci); }

int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, @@ -594,8 +589,8 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, const struct pci_device_id *pci_id; int err;

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

@@ -610,41 +605,38 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, INIT_WORK(&chip->gpio_work, oxygen_gpio_changed); init_waitqueue_head(&chip->ac97_waitqueue);

- err = pci_enable_device(pci); + err = pcim_enable_device(pci); if (err < 0) - goto err_card; + return err;

err = pci_request_regions(pci, DRIVER); if (err < 0) { dev_err(card->dev, "cannot reserve PCI resources\n"); - goto err_pci_enable; + return err; }

if (!(pci_resource_flags(pci, 0) & IORESOURCE_IO) || pci_resource_len(pci, 0) < OXYGEN_IO_SIZE) { dev_err(card->dev, "invalid PCI I/O range\n"); - err = -ENXIO; - goto err_pci_regions; + return -ENXIO; } chip->addr = pci_resource_start(pci, 0);

pci_id = oxygen_search_pci_id(chip, ids); - if (!pci_id) { - err = -ENODEV; - goto err_pci_regions; - } + if (!pci_id) + return -ENODEV; + oxygen_restore_eeprom(chip, pci_id); err = get_model(chip, pci_id); if (err < 0) - goto err_pci_regions; + return err;

if (chip->model.model_data_size) { - chip->model_data = kzalloc(chip->model.model_data_size, - GFP_KERNEL); - if (!chip->model_data) { - err = -ENOMEM; - goto err_pci_regions; - } + chip->model_data = devm_kzalloc(&pci->dev, + chip->model.model_data_size, + GFP_KERNEL); + if (!chip->model_data) + return -ENOMEM; }

pci_set_master(pci); @@ -654,11 +646,11 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, oxygen_init(chip); chip->model.init(chip);

- err = request_irq(pci->irq, oxygen_interrupt, IRQF_SHARED, - KBUILD_MODNAME, chip); + err = devm_request_irq(&pci->dev, pci->irq, oxygen_interrupt, + IRQF_SHARED, KBUILD_MODNAME, chip); if (err < 0) { dev_err(card->dev, "cannot grab interrupt %d\n", pci->irq); - goto err_card; + return err; } chip->irq = pci->irq; card->sync_irq = chip->irq; @@ -672,11 +664,11 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,

err = oxygen_pcm_init(chip); if (err < 0) - goto err_card; + return err;

err = oxygen_mixer_init(chip); if (err < 0) - goto err_card; + return err;

if (chip->model.device_config & (MIDI_OUTPUT | MIDI_INPUT)) { unsigned int info_flags = @@ -689,7 +681,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, chip->addr + OXYGEN_MPU401, info_flags, -1, &chip->midi); if (err < 0) - goto err_card; + return err; }

oxygen_proc_init(chip); @@ -704,27 +696,13 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,

err = snd_card_register(card); if (err < 0) - goto err_card; + return err;

pci_set_drvdata(pci, card); return 0; - -err_pci_regions: - pci_release_regions(pci); -err_pci_enable: - pci_disable_device(pci); -err_card: - snd_card_free(card); - return err; } EXPORT_SYMBOL(oxygen_pci_probe);

-void oxygen_pci_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} -EXPORT_SYMBOL(oxygen_pci_remove); - #ifdef CONFIG_PM_SLEEP static int oxygen_pci_suspend(struct device *dev) { diff --git a/sound/pci/oxygen/se6x.c b/sound/pci/oxygen/se6x.c index 434f885f6f91..17650a5b1bfa 100644 --- a/sound/pci/oxygen/se6x.c +++ b/sound/pci/oxygen/se6x.c @@ -137,7 +137,6 @@ static struct pci_driver se6x_driver = { .name = KBUILD_MODNAME, .id_table = se6x_ids, .probe = se6x_probe, - .remove = oxygen_pci_remove, #ifdef CONFIG_PM_SLEEP .driver = { .pm = &oxygen_pci_pm, diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c index baa3244d4dab..2e405133371f 100644 --- a/sound/pci/oxygen/virtuoso.c +++ b/sound/pci/oxygen/virtuoso.c @@ -82,7 +82,6 @@ static struct pci_driver xonar_driver = { .name = KBUILD_MODNAME, .id_table = xonar_ids, .probe = xonar_probe, - .remove = oxygen_pci_remove, #ifdef CONFIG_PM_SLEEP .driver = { .pm = &oxygen_pci_pm,

This patch converts the resource management in PCI hdsp driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, the page allocations are done with the 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/rme9652/hdsp.c | 89 +++++++++++----------------------------- 1 file changed, 25 insertions(+), 64 deletions(-)

diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c index 8457a4bbc3df..982278f8724d 100644 --- a/sound/pci/rme9652/hdsp.c +++ b/sound/pci/rme9652/hdsp.c @@ -468,8 +468,8 @@ struct hdsp { unsigned char ss_out_channels; u32 io_loopback; /* output loopback channel states*/

- struct snd_dma_buffer capture_dma_buf; - struct snd_dma_buffer playback_dma_buf; + struct snd_dma_buffer *capture_dma_buf; + struct snd_dma_buffer *playback_dma_buf; unsigned char *capture_buffer; /* suitably aligned address */ unsigned char *playback_buffer; /* suitably aligned address */

@@ -565,18 +565,12 @@ static const char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = { -1, -1 };

-static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size) +static struct snd_dma_buffer * +snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size) { - return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, size, dmab); + return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size); }

-static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci) -{ - if (dmab->area) - snd_dma_free_pages(dmab); -} - - static const struct pci_device_id snd_hdsp_ids[] = { { .vendor = PCI_VENDOR_ID_XILINX, @@ -3768,20 +3762,15 @@ static void snd_hdsp_proc_init(struct hdsp *hdsp) snd_card_ro_proc_new(hdsp->card, "hdsp", hdsp, snd_hdsp_proc_read); }

-static void snd_hdsp_free_buffers(struct hdsp *hdsp) -{ - snd_hammerfall_free_buffer(&hdsp->capture_dma_buf, hdsp->pci); - snd_hammerfall_free_buffer(&hdsp->playback_dma_buf, hdsp->pci); -} - static int snd_hdsp_initialize_memory(struct hdsp *hdsp) { unsigned long pb_bus, cb_bus;

- if (snd_hammerfall_get_buffer(hdsp->pci, &hdsp->capture_dma_buf, HDSP_DMA_AREA_BYTES) < 0 || - snd_hammerfall_get_buffer(hdsp->pci, &hdsp->playback_dma_buf, HDSP_DMA_AREA_BYTES) < 0) { - if (hdsp->capture_dma_buf.area) - snd_dma_free_pages(&hdsp->capture_dma_buf); + hdsp->capture_dma_buf = + snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES); + hdsp->playback_dma_buf = + snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES); + if (!hdsp->capture_dma_buf || !hdsp->playback_dma_buf) { dev_err(hdsp->card->dev, "%s: no buffers available\n", hdsp->card_name); return -ENOMEM; @@ -3789,16 +3778,16 @@ static int snd_hdsp_initialize_memory(struct hdsp *hdsp)

/* Align to bus-space 64K boundary */

- cb_bus = ALIGN(hdsp->capture_dma_buf.addr, 0x10000ul); - pb_bus = ALIGN(hdsp->playback_dma_buf.addr, 0x10000ul); + cb_bus = ALIGN(hdsp->capture_dma_buf->addr, 0x10000ul); + pb_bus = ALIGN(hdsp->playback_dma_buf->addr, 0x10000ul);

/* Tell the card where it is */

hdsp_write(hdsp, HDSP_inputBufferAddress, cb_bus); hdsp_write(hdsp, HDSP_outputBufferAddress, pb_bus);

- hdsp->capture_buffer = hdsp->capture_dma_buf.area + (cb_bus - hdsp->capture_dma_buf.addr); - hdsp->playback_buffer = hdsp->playback_dma_buf.area + (pb_bus - hdsp->playback_dma_buf.addr); + hdsp->capture_buffer = hdsp->capture_dma_buf->area + (cb_bus - hdsp->capture_dma_buf->addr); + hdsp->playback_buffer = hdsp->playback_dma_buf->area + (pb_bus - hdsp->playback_dma_buf->addr);

return 0; } @@ -5313,7 +5302,7 @@ static int snd_hdsp_create(struct snd_card *card, is_9632 = 1; }

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

@@ -5323,15 +5312,15 @@ static int snd_hdsp_create(struct snd_card *card, if (err < 0) return err; hdsp->port = pci_resource_start(pci, 0); - hdsp->iobase = ioremap(hdsp->port, HDSP_IO_EXTENT); + hdsp->iobase = devm_ioremap(&pci->dev, hdsp->port, HDSP_IO_EXTENT); if (!hdsp->iobase) { dev_err(hdsp->card->dev, "unable to remap region 0x%lx-0x%lx\n", hdsp->port, hdsp->port + HDSP_IO_EXTENT - 1); return -EBUSY; }

- if (request_irq(pci->irq, snd_hdsp_interrupt, IRQF_SHARED, - KBUILD_MODNAME, hdsp)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_hdsp_interrupt, + IRQF_SHARED, KBUILD_MODNAME, hdsp)) { dev_err(hdsp->card->dev, "unable to use IRQ %d\n", pci->irq); return -EBUSY; } @@ -5411,8 +5400,10 @@ static int snd_hdsp_create(struct snd_card *card, return 0; }

-static int snd_hdsp_free(struct hdsp *hdsp) +static void snd_hdsp_card_free(struct snd_card *card) { + struct hdsp *hdsp = card->private_data; + if (hdsp->port) { /* stop the audio, and cancel all interrupts */ cancel_work_sync(&hdsp->midi_work); @@ -5420,29 +5411,8 @@ static int snd_hdsp_free(struct hdsp *hdsp) hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register); }

- if (hdsp->irq >= 0) - free_irq(hdsp->irq, (void *)hdsp); - - snd_hdsp_free_buffers(hdsp); - release_firmware(hdsp->firmware); vfree(hdsp->fw_uploaded); - iounmap(hdsp->iobase); - - if (hdsp->port) - pci_release_regions(hdsp->pci); - - if (pci_is_enabled(hdsp->pci)) - pci_disable_device(hdsp->pci); - return 0; -} - -static void snd_hdsp_card_free(struct snd_card *card) -{ - struct hdsp *hdsp = card->private_data; - - if (hdsp) - snd_hdsp_free(hdsp); }

static int snd_hdsp_probe(struct pci_dev *pci, @@ -5460,8 +5430,8 @@ static int snd_hdsp_probe(struct pci_dev *pci, return -ENOENT; }

- err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, - sizeof(struct hdsp), &card); + err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, + sizeof(struct hdsp), &card); if (err < 0) return err;

@@ -5471,32 +5441,23 @@ static int snd_hdsp_probe(struct pci_dev *pci, hdsp->pci = pci; err = snd_hdsp_create(card, hdsp); if (err) - goto free_card; + return err;

strcpy(card->shortname, "Hammerfall DSP"); sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name, hdsp->port, hdsp->irq); err = snd_card_register(card); - if (err) { -free_card: - snd_card_free(card); + if (err) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_hdsp_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static struct pci_driver hdsp_driver = { .name = KBUILD_MODNAME, .id_table = snd_hdsp_ids, .probe = snd_hdsp_probe, - .remove = snd_hdsp_remove, };

module_pci_driver(hdsp_driver);

This patch converts the resource management in PCI rme9652 driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, the page allocations are done with the 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/rme9652/rme9652.c | 85 +++++++++++-------------------------- 1 file changed, 24 insertions(+), 61 deletions(-)

diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c index f1aad38760d6..45448a97070c 100644 --- a/sound/pci/rme9652/rme9652.c +++ b/sound/pci/rme9652/rme9652.c @@ -208,8 +208,8 @@ struct snd_rme9652 { unsigned char ds_channels; unsigned char ss_channels; /* different for hammerfall/hammerfall-light */

- struct snd_dma_buffer playback_dma_buf; - struct snd_dma_buffer capture_dma_buf; + struct snd_dma_buffer *playback_dma_buf; + struct snd_dma_buffer *capture_dma_buf;

unsigned char *capture_buffer; /* suitably aligned address */ unsigned char *playback_buffer; /* suitably aligned address */ @@ -275,18 +275,12 @@ static const char channel_map_9636_ds[26] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };

-static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size) +static struct snd_dma_buffer * +snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size) { - return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, size, dmab); + return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size); }

-static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci) -{ - if (dmab->area) - snd_dma_free_pages(dmab); -} - - static const struct pci_device_id snd_rme9652_ids[] = { { .vendor = 0x10ee, @@ -1715,37 +1709,23 @@ static void snd_rme9652_proc_init(struct snd_rme9652 *rme9652) snd_rme9652_proc_read); }

-static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652) +static void snd_rme9652_card_free(struct snd_card *card) { - snd_hammerfall_free_buffer(&rme9652->capture_dma_buf, rme9652->pci); - snd_hammerfall_free_buffer(&rme9652->playback_dma_buf, rme9652->pci); -} + struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;

-static int snd_rme9652_free(struct snd_rme9652 *rme9652) -{ if (rme9652->irq >= 0) rme9652_stop(rme9652); - snd_rme9652_free_buffers(rme9652); - - if (rme9652->irq >= 0) - free_irq(rme9652->irq, (void *)rme9652); - iounmap(rme9652->iobase); - if (rme9652->port) - pci_release_regions(rme9652->pci); - - if (pci_is_enabled(rme9652->pci)) - pci_disable_device(rme9652->pci); - return 0; }

static int snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652) { unsigned long pb_bus, cb_bus;

- if (snd_hammerfall_get_buffer(rme9652->pci, &rme9652->capture_dma_buf, RME9652_DMA_AREA_BYTES) < 0 || - snd_hammerfall_get_buffer(rme9652->pci, &rme9652->playback_dma_buf, RME9652_DMA_AREA_BYTES) < 0) { - if (rme9652->capture_dma_buf.area) - snd_dma_free_pages(&rme9652->capture_dma_buf); + rme9652->capture_dma_buf = + snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES); + rme9652->playback_dma_buf = + snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES); + if (!rme9652->capture_dma_buf || !rme9652->playback_dma_buf) { dev_err(rme9652->card->dev, "%s: no buffers available\n", rme9652->card_name); return -ENOMEM; @@ -1753,16 +1733,16 @@ static int snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)

/* Align to bus-space 64K boundary */

- cb_bus = ALIGN(rme9652->capture_dma_buf.addr, 0x10000ul); - pb_bus = ALIGN(rme9652->playback_dma_buf.addr, 0x10000ul); + cb_bus = ALIGN(rme9652->capture_dma_buf->addr, 0x10000ul); + pb_bus = ALIGN(rme9652->playback_dma_buf->addr, 0x10000ul);

/* Tell the card where it is */

rme9652_write(rme9652, RME9652_rec_buffer, cb_bus); rme9652_write(rme9652, RME9652_play_buffer, pb_bus);

- rme9652->capture_buffer = rme9652->capture_dma_buf.area + (cb_bus - rme9652->capture_dma_buf.addr); - rme9652->playback_buffer = rme9652->playback_dma_buf.area + (pb_bus - rme9652->playback_dma_buf.addr); + rme9652->capture_buffer = rme9652->capture_dma_buf->area + (cb_bus - rme9652->capture_dma_buf->addr); + rme9652->playback_buffer = rme9652->playback_dma_buf->area + (pb_bus - rme9652->playback_dma_buf->addr);

return 0; } @@ -2452,7 +2432,7 @@ static int snd_rme9652_create(struct snd_card *card, return -ENODEV; }

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

@@ -2462,15 +2442,15 @@ static int snd_rme9652_create(struct snd_card *card, if (err < 0) return err; rme9652->port = pci_resource_start(pci, 0); - rme9652->iobase = ioremap(rme9652->port, RME9652_IO_EXTENT); + rme9652->iobase = devm_ioremap(&pci->dev, rme9652->port, RME9652_IO_EXTENT); if (rme9652->iobase == NULL) { dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n", rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1); return -EBUSY; } - if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED, - KBUILD_MODNAME, rme9652)) { + if (devm_request_irq(&pci->dev, pci->irq, snd_rme9652_interrupt, + IRQF_SHARED, KBUILD_MODNAME, rme9652)) { dev_err(card->dev, "unable to request IRQ %d\n", pci->irq); return -EBUSY; } @@ -2562,14 +2542,6 @@ static int snd_rme9652_create(struct snd_card *card, return 0; }

-static void snd_rme9652_card_free(struct snd_card *card) -{ - struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data; - - if (rme9652) - snd_rme9652_free(rme9652); -} - static int snd_rme9652_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { @@ -2585,8 +2557,8 @@ static int snd_rme9652_probe(struct pci_dev *pci, return -ENOENT; }

- err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_rme9652), &card); + err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, + sizeof(struct snd_rme9652), &card);

if (err < 0) return err; @@ -2597,33 +2569,24 @@ static int snd_rme9652_probe(struct pci_dev *pci, rme9652->pci = pci; err = snd_rme9652_create(card, rme9652, precise_ptr[dev]); if (err) - goto free_card; + return err;

strcpy(card->shortname, rme9652->card_name);

sprintf(card->longname, "%s at 0x%lx, irq %d", card->shortname, rme9652->port, rme9652->irq); err = snd_card_register(card); - if (err) { -free_card: - snd_card_free(card); + if (err) return err; - } pci_set_drvdata(pci, card); dev++; return 0; }

-static void snd_rme9652_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); -} - static struct pci_driver rme9652_driver = { .name = KBUILD_MODNAME, .id_table = snd_rme9652_ids, .probe = snd_rme9652_probe, - .remove = snd_rme9652_remove, };

module_pci_driver(rme9652_driver);

The firmware data are also released automatically.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/drivers/vx/vx_core.c | 12 ++++++++++-- sound/pci/vx222/vx222.c | 1 - sound/pcmcia/vx/vxpocket.c | 21 --------------------- 3 files changed, 10 insertions(+), 24 deletions(-)

diff --git a/sound/drivers/vx/vx_core.c b/sound/drivers/vx/vx_core.c index a10449af5a76..18901e5bcfcf 100644 --- a/sound/drivers/vx/vx_core.c +++ b/sound/drivers/vx/vx_core.c @@ -774,6 +774,11 @@ int snd_vx_resume(struct vx_core *chip) EXPORT_SYMBOL(snd_vx_resume); #endif

+static void snd_vx_release(struct device *dev, void *data) +{ + snd_vx_free_firmware(data); +} + /** * snd_vx_create - constructor for struct vx_core * @card: card instance @@ -784,6 +789,8 @@ EXPORT_SYMBOL(snd_vx_resume); * this function allocates the instance and prepare for the hardware * initialization. * + * The object is managed via devres, and will be automatically released. + * * return the instance pointer if successful, NULL in error. */ struct vx_core *snd_vx_create(struct snd_card *card, @@ -796,8 +803,9 @@ struct vx_core *snd_vx_create(struct snd_card *card, if (snd_BUG_ON(!card || !hw || !ops)) return NULL;

- chip = kzalloc(sizeof(*chip) + extra_size, GFP_KERNEL); - if (! chip) + chip = devres_alloc(snd_vx_release, sizeof(*chip) + extra_size, + GFP_KERNEL); + if (!chip) return NULL; mutex_init(&chip->lock); chip->irq = -1; diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c index 04c7204cb7bc..46a80ef1d481 100644 --- a/sound/pci/vx222/vx222.c +++ b/sound/pci/vx222/vx222.c @@ -109,7 +109,6 @@ static int snd_vx222_free(struct vx_core *chip) if (vx->port[0]) pci_release_regions(vx->pci); pci_disable_device(vx->pci); - kfree(chip); return 0; }

diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c index 0dfb6a943b60..30ac1f96c6c7 100644 --- a/sound/pcmcia/vx/vxpocket.c +++ b/sound/pcmcia/vx/vxpocket.c @@ -50,19 +50,6 @@ static void vxpocket_release(struct pcmcia_device *link) pcmcia_disable_device(link); }

-/* - * destructor, called from snd_card_free_when_closed() - */ -static int snd_vxpocket_dev_free(struct snd_device *device) -{ - struct vx_core *chip = device->device_data; - - snd_vx_free_firmware(chip); - kfree(chip); - return 0; -} - - /* * Hardware information */ @@ -122,9 +109,6 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl, { struct vx_core *chip; struct snd_vxpocket *vxp; - static const struct snd_device_ops ops = { - .dev_free = snd_vxpocket_dev_free, - }; int err;

chip = snd_vx_create(card, &vxpocket_hw, &snd_vxpocket_ops, @@ -132,11 +116,6 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl, if (!chip) return -ENOMEM;

- err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); - if (err < 0) { - kfree(chip); - return err; - } chip->ibl.size = ibl;

vxp = to_vxpocket(chip);

This patch converts the resource management in PCI ymfpci driver with devres as a clean up. Each manual resource management is converted with the corresponding devres helper, the page allocations are done with the 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/pci/ymfpci/ymfpci.c | 66 ++++++--------- sound/pci/ymfpci/ymfpci.h | 8 +- sound/pci/ymfpci/ymfpci_main.c | 149 +++++++++++---------------------- 3 files changed, 74 insertions(+), 149 deletions(-)

diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c index 7e32d57147ff..1e198e4d57b8 100644 --- a/sound/pci/ymfpci/ymfpci.c +++ b/sound/pci/ymfpci/ymfpci.c @@ -105,7 +105,8 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, }

if (!r) { - r = request_region(io_port, 1, "YMFPCI gameport"); + r = devm_request_region(&chip->pci->dev, io_port, 1, + "YMFPCI gameport"); if (!r) { dev_err(chip->card->dev, "joystick port %#x is in use.\n", io_port); @@ -117,7 +118,6 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, if (!gp) { dev_err(chip->card->dev, "cannot allocate memory for gameport\n"); - release_and_free_resource(r); return -ENOMEM; }

@@ -126,7 +126,6 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); gameport_set_dev_parent(gp, &chip->pci->dev); gp->io = io_port; - gameport_set_port_data(gp, r);

if (chip->pci->device >= 0x0010) /* YMF 744/754 */ pci_write_config_word(chip->pci, PCIR_DSXG_JOYBASE, io_port); @@ -142,12 +141,8 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) { if (chip->gameport) { - struct resource *r = gameport_get_port_data(chip->gameport); - gameport_unregister_port(chip->gameport); chip->gameport = NULL; - - release_and_free_resource(r); } } #else @@ -176,9 +171,10 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, }

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

switch (pci_id->device) { case 0x0004: str = "YMF724"; model = "DS-1"; break; @@ -199,7 +195,8 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, fm_port[dev] = pci_resource_start(pci, 1); } if (fm_port[dev] > 0) - fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3"); + fm_res = devm_request_region(&pci->dev, fm_port[dev], + 4, "YMFPCI OPL3"); if (fm_res) { legacy_ctrl |= YMFPCI_LEGACY_FMEN; pci_write_config_word(pci, PCIR_DSXG_FMBASE, fm_port[dev]); @@ -209,7 +206,8 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, mpu_port[dev] = pci_resource_start(pci, 1) + 0x20; } if (mpu_port[dev] > 0) - mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401"); + mpu_res = devm_request_region(&pci->dev, mpu_port[dev], + 2, "YMFPCI MPU401"); if (mpu_res) { legacy_ctrl |= YMFPCI_LEGACY_MEN; pci_write_config_word(pci, PCIR_DSXG_MPU401BASE, mpu_port[dev]); @@ -223,7 +221,8 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, default: fm_port[dev] = 0; break; } if (fm_port[dev] > 0) - fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3"); + fm_res = devm_request_region(&pci->dev, fm_port[dev], + 4, "YMFPCI OPL3"); if (fm_res) { legacy_ctrl |= YMFPCI_LEGACY_FMEN; } else { @@ -238,7 +237,8 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, default: mpu_port[dev] = 0; break; } if (mpu_port[dev] > 0) - mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401"); + mpu_res = devm_request_region(&pci->dev, mpu_port[dev], + 2, "YMFPCI MPU401"); if (mpu_res) { legacy_ctrl |= YMFPCI_LEGACY_MEN; } else { @@ -253,15 +253,9 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, pci_read_config_word(pci, PCIR_DSXG_LEGACY, &old_legacy_ctrl); pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); pci_write_config_word(pci, PCIR_DSXG_ELEGACY, legacy_ctrl2); - err = snd_ymfpci_create(card, pci, old_legacy_ctrl, &chip); - if (err < 0) { - release_and_free_resource(mpu_res); - release_and_free_resource(fm_res); - goto free_card; - } - chip->fm_res = fm_res; - chip->mpu_res = mpu_res; - card->private_data = chip; + err = snd_ymfpci_create(card, pci, old_legacy_ctrl); + if (err < 0) + return err;

strcpy(card->driver, str); sprintf(card->shortname, "Yamaha %s (%s)", model, str); @@ -271,30 +265,30 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, chip->irq); err = snd_ymfpci_pcm(chip, 0); if (err < 0) - goto free_card; + return err;

err = snd_ymfpci_pcm_spdif(chip, 1); if (err < 0) - goto free_card; + return err;

err = snd_ymfpci_mixer(chip, rear_switch[dev]); if (err < 0) - goto free_card; + return err;

if (chip->ac97->ext_id & AC97_EI_SDAC) { err = snd_ymfpci_pcm_4ch(chip, 2); if (err < 0) - goto free_card; + return err;

err = snd_ymfpci_pcm2(chip, 3); if (err < 0) - goto free_card; + return err; } err = snd_ymfpci_timer(chip, 0); if (err < 0) - goto free_card; + return err;

- if (chip->mpu_res) { + if (mpu_res) { err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI, mpu_port[dev], MPU401_INFO_INTEGRATED | @@ -308,7 +302,7 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); } } - if (chip->fm_res) { + if (fm_res) { err = snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2, @@ -323,7 +317,7 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci, err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); if (err < 0) { dev_err(card->dev, "cannot create opl3 hwdep\n"); - goto free_card; + return err; } } } @@ -332,27 +326,17 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,

err = snd_card_register(card); if (err < 0) - goto free_card; + return err;

pci_set_drvdata(pci, card); dev++; return 0; - -free_card: - snd_card_free(card); - return err; -} - -static void snd_card_ymfpci_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); }

static struct pci_driver ymfpci_driver = { .name = KBUILD_MODNAME, .id_table = snd_ymfpci_ids, .probe = snd_card_ymfpci_probe, - .remove = snd_card_ymfpci_remove, #ifdef CONFIG_PM_SLEEP .driver = { .pm = &snd_ymfpci_pm, diff --git a/sound/pci/ymfpci/ymfpci.h b/sound/pci/ymfpci/ymfpci.h index c73d8a5f4d0b..66968776478a 100644 --- a/sound/pci/ymfpci/ymfpci.h +++ b/sound/pci/ymfpci/ymfpci.h @@ -275,16 +275,13 @@ struct snd_ymfpci { unsigned char rev; /* PCI revision */ unsigned long reg_area_phys; void __iomem *reg_area_virt; - struct resource *res_reg_area; - struct resource *fm_res; - struct resource *mpu_res;

unsigned short old_legacy_ctrl; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; #endif

- struct snd_dma_buffer work_ptr; + struct snd_dma_buffer *work_ptr;

unsigned int bank_size_playback; unsigned int bank_size_capture; @@ -358,8 +355,7 @@ struct snd_ymfpci {

int snd_ymfpci_create(struct snd_card *card, struct pci_dev *pci, - unsigned short old_legacy_ctrl, - struct snd_ymfpci ** rcodec); + unsigned short old_legacy_ctrl); void snd_ymfpci_free_gameport(struct snd_ymfpci *chip);

extern const struct dev_pm_ops snd_ymfpci_pm; diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c index 8fd060769882..c80114c0ad7b 100644 --- a/sound/pci/ymfpci/ymfpci_main.c +++ b/sound/pci/ymfpci/ymfpci_main.c @@ -2116,11 +2116,12 @@ static int snd_ymfpci_memalloc(struct snd_ymfpci *chip) 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(SNDRV_DMA_TYPE_DEV, &chip->pci->dev, - size, &chip->work_ptr) < 0) + chip->work_ptr = snd_devm_alloc_pages(&chip->pci->dev, + SNDRV_DMA_TYPE_DEV, size); + if (!chip->work_ptr) return -ENOMEM; - ptr = chip->work_ptr.area; - ptr_addr = chip->work_ptr.addr; + ptr = chip->work_ptr->area; + ptr_addr = chip->work_ptr->addr; memset(ptr, 0, size); /* for sure */

chip->bank_base_playback = ptr; @@ -2165,7 +2166,7 @@ static int snd_ymfpci_memalloc(struct snd_ymfpci *chip) chip->work_base_addr = ptr_addr; snd_BUG_ON(ptr + chip->work_size != - chip->work_ptr.area + chip->work_ptr.bytes); + chip->work_ptr->area + chip->work_ptr->bytes);

snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, chip->bank_base_playback_addr); snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, chip->bank_base_capture_addr); @@ -2196,65 +2197,32 @@ static int snd_ymfpci_memalloc(struct snd_ymfpci *chip) return 0; }

-static int snd_ymfpci_free(struct snd_ymfpci *chip) +static void snd_ymfpci_free(struct snd_card *card) { + struct snd_ymfpci *chip = card->private_data; u16 ctrl;

- if (snd_BUG_ON(!chip)) - return -EINVAL; - - if (chip->res_reg_area) { /* don't touch busy hardware */ - snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0); - snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0); - snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0); - snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0); - snd_ymfpci_disable_dsp(chip); - snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0); - snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0); - snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0); - snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0); - snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0); - ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL); - snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007); - } + snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0); + snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0); + snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0); + snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0); + snd_ymfpci_disable_dsp(chip); + snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0); + snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0); + snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0); + snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0); + snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0); + ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL); + snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);

snd_ymfpci_ac3_done(chip);

- /* Set PCI device to D3 state */ -#if 0 - /* FIXME: temporarily disabled, otherwise we cannot fire up - * the chip again unless reboot. ACPI bug? - */ - pci_set_power_state(chip->pci, PCI_D3hot); -#endif - -#ifdef CONFIG_PM_SLEEP - kfree(chip->saved_regs); -#endif - if (chip->irq >= 0) - free_irq(chip->irq, chip); - release_and_free_resource(chip->mpu_res); - release_and_free_resource(chip->fm_res); snd_ymfpci_free_gameport(chip); - iounmap(chip->reg_area_virt); - if (chip->work_ptr.area) - snd_dma_free_pages(&chip->work_ptr); - release_and_free_resource(chip->res_reg_area); - pci_write_config_word(chip->pci, 0x40, chip->old_legacy_ctrl); - pci_disable_device(chip->pci); release_firmware(chip->dsp_microcode); release_firmware(chip->controller_microcode); - kfree(chip); - return 0; -} - -static int snd_ymfpci_dev_free(struct snd_device *device) -{ - struct snd_ymfpci *chip = device->device_data; - return snd_ymfpci_free(chip); }

#ifdef CONFIG_PM_SLEEP @@ -2346,27 +2314,16 @@ SIMPLE_DEV_PM_OPS(snd_ymfpci_pm, snd_ymfpci_suspend, snd_ymfpci_resume);

int snd_ymfpci_create(struct snd_card *card, struct pci_dev *pci, - unsigned short old_legacy_ctrl, - struct snd_ymfpci **rchip) + unsigned short old_legacy_ctrl) { - struct snd_ymfpci *chip; + struct snd_ymfpci *chip = card->private_data; int err; - static const struct snd_device_ops ops = { - .dev_free = snd_ymfpci_dev_free, - }; - *rchip = NULL; - /* enable PCI device */ - 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->old_legacy_ctrl = old_legacy_ctrl; spin_lock_init(&chip->reg_lock); spin_lock_init(&chip->voice_lock); @@ -2377,71 +2334,59 @@ int snd_ymfpci_create(struct snd_card *card, chip->irq = -1; chip->device_id = pci->device; chip->rev = pci->revision; - chip->reg_area_phys = pci_resource_start(pci, 0); - chip->reg_area_virt = ioremap(chip->reg_area_phys, 0x8000); - pci_set_master(pci); - chip->src441_used = -1;

- chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI"); - if (!chip->res_reg_area) { + err = pci_request_regions(pci, "YMFPCI"); + if (err < 0) + return err; + + chip->reg_area_phys = pci_resource_start(pci, 0); + chip->reg_area_virt = devm_ioremap(&pci->dev, chip->reg_area_phys, 0x8000); + if (!chip->reg_area_virt) { dev_err(chip->card->dev, "unable to grab memory region 0x%lx-0x%lx\n", chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1); - err = -EBUSY; - goto free_chip; + return -EBUSY; } - if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED, + pci_set_master(pci); + chip->src441_used = -1; + + if (devm_request_irq(&pci->dev, pci->irq, snd_ymfpci_interrupt, IRQF_SHARED, KBUILD_MODNAME, chip)) { dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq); - err = -EBUSY; - goto free_chip; + return -EBUSY; } chip->irq = pci->irq; card->sync_irq = chip->irq; + card->private_free = snd_ymfpci_free;

snd_ymfpci_aclink_reset(pci); - if (snd_ymfpci_codec_ready(chip, 0) < 0) { - err = -EIO; - goto free_chip; - } + if (snd_ymfpci_codec_ready(chip, 0) < 0) + return -EIO;

err = snd_ymfpci_request_firmware(chip); if (err < 0) { dev_err(chip->card->dev, "firmware request failed: %d\n", err); - goto free_chip; + return err; } snd_ymfpci_download_image(chip);

udelay(100); /* seems we need a delay after downloading image.. */

- if (snd_ymfpci_memalloc(chip) < 0) { - err = -EIO; - goto free_chip; - } + if (snd_ymfpci_memalloc(chip) < 0) + return -EIO;

err = snd_ymfpci_ac3_init(chip); if (err < 0) - goto free_chip; + return err;

#ifdef CONFIG_PM_SLEEP - chip->saved_regs = kmalloc_array(YDSXGR_NUM_SAVED_REGS, sizeof(u32), - GFP_KERNEL); - if (chip->saved_regs == NULL) { - err = -ENOMEM; - goto free_chip; - } + chip->saved_regs = devm_kmalloc_array(&pci->dev, YDSXGR_NUM_SAVED_REGS, + sizeof(u32), GFP_KERNEL); + if (!chip->saved_regs) + return -ENOMEM; #endif

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

- *rchip = chip; return 0; - -free_chip: - snd_ymfpci_free(chip); - return err; }

This patch converts the card object management with devres as a clean up. The remove callback gets reduced by that.

This should give no user-visible functional changes.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/drivers/virmidi.c | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-)

diff --git a/sound/drivers/virmidi.c b/sound/drivers/virmidi.c index 4206d93ab47e..7f7eed6faaae 100644 --- a/sound/drivers/virmidi.c +++ b/sound/drivers/virmidi.c @@ -75,8 +75,8 @@ static int snd_virmidi_probe(struct platform_device *devptr) int idx, err; int dev = devptr->id;

- err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_card_virmidi), &card); + err = snd_devm_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE, + sizeof(struct snd_card_virmidi), &card); if (err < 0) return err; vmidi = card->private_data; @@ -94,7 +94,7 @@ static int snd_virmidi_probe(struct platform_device *devptr)

err = snd_virmidi_new(card, idx, &rmidi); if (err < 0) - goto __nodev; + return err; rdev = rmidi->private_data; vmidi->midi[idx] = rmidi; strcpy(rmidi->name, "Virtual Raw MIDI"); @@ -106,18 +106,10 @@ static int snd_virmidi_probe(struct platform_device *devptr) sprintf(card->longname, "Virtual MIDI Card %i", dev + 1);

err = snd_card_register(card); - if (!err) { - platform_set_drvdata(devptr, card); - return 0; - } -__nodev: - snd_card_free(card); - return err; -} + if (err) + return err;

-static int snd_virmidi_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); + platform_set_drvdata(devptr, card); return 0; }

@@ -125,7 +117,6 @@ static int snd_virmidi_remove(struct platform_device *devptr)

static struct platform_driver snd_virmidi_driver = { .probe = snd_virmidi_probe, - .remove = snd_virmidi_remove, .driver = { .name = SND_VIRMIDI_DRIVER, },

This patch converts the resource management in serial u16550 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.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/drivers/serial-u16550.c | 57 ++++++----------------------------- 1 file changed, 9 insertions(+), 48 deletions(-)

diff --git a/sound/drivers/serial-u16550.c b/sound/drivers/serial-u16550.c index da9983cba01c..d3bb5d177569 100644 --- a/sound/drivers/serial-u16550.c +++ b/sound/drivers/serial-u16550.c @@ -115,7 +115,6 @@ struct snd_uart16550 { int irq;

unsigned long base; - struct resource *res_base;

unsigned int speed; unsigned int speed_base; @@ -323,8 +322,7 @@ static int snd_uart16550_detect(struct snd_uart16550 *uart) return -ENODEV; /* Not configured */ }

- uart->res_base = request_region(io_base, 8, "Serial MIDI"); - if (uart->res_base == NULL) { + if (!devm_request_region(uart->card->dev, io_base, 8, "Serial MIDI")) { snd_printk(KERN_ERR "u16550: can't grab port 0x%lx\n", io_base); return -EBUSY; } @@ -752,21 +750,6 @@ static const struct snd_rawmidi_ops snd_uart16550_input = .trigger = snd_uart16550_input_trigger, };

-static int snd_uart16550_free(struct snd_uart16550 *uart) -{ - if (uart->irq >= 0) - free_irq(uart->irq, uart); - release_and_free_resource(uart->res_base); - kfree(uart); - return 0; -}; - -static int snd_uart16550_dev_free(struct snd_device *device) -{ - struct snd_uart16550 *uart = device->device_data; - return snd_uart16550_free(uart); -} - static int snd_uart16550_create(struct snd_card *card, unsigned long iobase, int irq, @@ -776,14 +759,11 @@ static int snd_uart16550_create(struct snd_card *card, int droponfull, struct snd_uart16550 **ruart) { - static const struct snd_device_ops ops = { - .dev_free = snd_uart16550_dev_free, - }; struct snd_uart16550 *uart; int err;

- uart = kzalloc(sizeof(*uart), GFP_KERNEL); + uart = devm_kzalloc(sizeof(*uart), GFP_KERNEL); if (!uart) return -ENOMEM; uart->adaptor = adaptor; @@ -796,13 +776,12 @@ static int snd_uart16550_create(struct snd_card *card, err = snd_uart16550_detect(uart); if (err <= 0) { printk(KERN_ERR "no UART detected at 0x%lx\n", iobase); - snd_uart16550_free(uart); return -ENODEV; }

if (irq >= 0 && irq != SNDRV_AUTO_IRQ) { - if (request_irq(irq, snd_uart16550_interrupt, - 0, "Serial MIDI", uart)) { + if (devm_request_irq(card->dev, irq, snd_uart16550_interrupt, + 0, "Serial MIDI", uart)) { snd_printk(KERN_WARNING "irq %d busy. Using Polling.\n", irq); } else { @@ -819,13 +798,6 @@ static int snd_uart16550_create(struct snd_card *card, timer_setup(&uart->buffer_timer, snd_uart16550_buffer_timer, 0); uart->timer_running = 0;

- /* Register device */ - err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, uart, &ops); - if (err < 0) { - snd_uart16550_free(uart); - return err; - } - switch (uart->adaptor) { case SNDRV_SERIAL_MS124W_SA: case SNDRV_SERIAL_MS124W_MB: @@ -927,8 +899,8 @@ static int snd_serial_probe(struct platform_device *devptr) return -ENODEV; }

- err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE, - 0, &card); + err = snd_devm_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE, + 0, &card); if (err < 0) return err;

@@ -939,11 +911,11 @@ static int snd_serial_probe(struct platform_device *devptr) base[dev], adaptor[dev], droponfull[dev], &uart); if (err < 0) - goto _err; + return err;

err = snd_uart16550_rmidi(uart, 0, outs[dev], ins[dev], &uart->rmidi); if (err < 0) - goto _err; + return err;

sprintf(card->longname, "%s [%s] at %#lx, irq %d", card->shortname, @@ -953,27 +925,16 @@ static int snd_serial_probe(struct platform_device *devptr)

err = snd_card_register(card); if (err < 0) - goto _err; + return err;

platform_set_drvdata(devptr, card); return 0; - - _err: - snd_card_free(card); - return err; -} - -static int snd_serial_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - return 0; }

#define SND_SERIAL_DRIVER "snd_serial_u16550"

static struct platform_driver snd_serial_driver = { .probe = snd_serial_probe, - .remove = snd_serial_remove, .driver = { .name = SND_SERIAL_DRIVER, },

This patch converts the card object management with devres as a clean up. The remove callback gets reduced by that.

This should give no user-visible functional changes.

Note that this converts only the mpu401 card driver. The mpu401_uart component is still managed with snd_device. It's for the case where the mpu401_uart component may be removed dynamically without the actual device unbind.

Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/drivers/mpu401/mpu401.c | 33 +++++---------------------------- 1 file changed, 5 insertions(+), 28 deletions(-)

diff --git a/sound/drivers/mpu401/mpu401.c b/sound/drivers/mpu401/mpu401.c index d0b55dbb411a..66b94f73956f 100644 --- a/sound/drivers/mpu401/mpu401.c +++ b/sound/drivers/mpu401/mpu401.c @@ -59,8 +59,8 @@ static int snd_mpu401_create(struct device *devptr, int dev, snd_printk(KERN_ERR "the uart_enter option is obsolete; remove it\n");

*rcard = NULL; - err = snd_card_new(devptr, index[dev], id[dev], THIS_MODULE, - 0, &card); + err = snd_devm_card_new(devptr, index[dev], id[dev], THIS_MODULE, + 0, &card); if (err < 0) return err; strcpy(card->driver, "MPU-401 UART"); @@ -76,15 +76,11 @@ static int snd_mpu401_create(struct device *devptr, int dev, irq[dev], NULL); if (err < 0) { printk(KERN_ERR "MPU401 not detected at 0x%lx\n", port[dev]); - goto _err; + return err; }

*rcard = card; return 0; - - _err: - snd_card_free(card); - return err; }

static int snd_mpu401_probe(struct platform_device *devptr) @@ -105,20 +101,12 @@ static int snd_mpu401_probe(struct platform_device *devptr) if (err < 0) return err; err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } platform_set_drvdata(devptr, card); return 0; }

-static int snd_mpu401_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - return 0; -} - #define SND_MPU401_DRIVER "snd_mpu401"

static struct platform_driver snd_mpu401_driver = { @@ -184,10 +172,8 @@ static int snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev, if (err < 0) return err; err = snd_card_register(card); - if (err < 0) { - snd_card_free(card); + if (err < 0) return err; - } pnp_set_drvdata(pnp_dev, card); snd_mpu401_devices++; ++dev; @@ -196,19 +182,10 @@ static int snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev, return -ENODEV; }

-static void snd_mpu401_pnp_remove(struct pnp_dev *dev) -{ - struct snd_card *card = (struct snd_card *) pnp_get_drvdata(dev); - - snd_card_disconnect(card); - snd_card_free_when_closed(card); -} - static struct pnp_driver snd_mpu401_pnp_driver = { .name = "mpu401", .id_table = snd_mpu401_pnpids, .probe = snd_mpu401_pnp_probe, - .remove = snd_mpu401_pnp_remove, }; #else static struct pnp_driver snd_mpu401_pnp_driver;