Changeset 717


Ignore:
Timestamp:
Aug 7, 2022, 6:11:12 PM (3 years ago)
Author:
David Azarewicz
Message:

Merge changes from next branch.

Location:
GPL/trunk
Files:
109 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk

  • GPL/trunk/alsa-kernel/core/info.c

    r679 r717  
    1717#include <linux/proc_fs.h>
    1818#include <linux/mutex.h>
    19 #include <stdarg.h>
    2019
    2120int snd_info_check_reserved_words(const char *str)

  • GPL/trunk/alsa-kernel/core/init.c

    r703 r717  
    139139EXPORT_SYMBOL_GPL(snd_device_initialize);
    140140
     141static int snd_card_init(struct snd_card *card, struct device *parent,
     142                         int idx, const char *xid, struct module *module,
     143                         size_t extra_size);
    141144static int snd_card_do_free(struct snd_card *card);
    142145static const struct attribute_group card_dev_attr_group;
    … …  
    168171        struct snd_card *card;
    169172        int err;
    170 #ifdef CONFIG_SND_DEBUG
    171         char name[8];
    172 #endif
    173173
    174174        if (snd_BUG_ON(!card_ret))
    … …  
    181181        if (!card)
    182182                return -ENOMEM;
     183
     184        err = snd_card_init(card, parent, idx, xid, module, extra_size);
     185        if (err < 0) {
     186                kfree(card);
     187                return err;
     188        }
     189
     190        *card_ret = card;
     191        return 0;
     192}
     193EXPORT_SYMBOL(snd_card_new);
     194
     195static void __snd_card_release(struct device *dev, void *data)
     196{
     197        snd_card_free(data);
     198}
     199
     200/**
     201 * snd_devm_card_new - managed snd_card object creation
     202 * @parent: the parent device object
     203 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
     204 * @xid: card identification (ASCII string)
     205 * @module: top level module for locking
     206 * @extra_size: allocate this extra size after the main soundcard structure
     207 * @card_ret: the pointer to store the created card instance
     208 *
     209 * This function works like snd_card_new() but manages the allocated resource
     210 * via devres, i.e. you don't need to free explicitly.
     211 *
     212 * When a snd_card object is created with this function and registered via
     213 * snd_card_register(), the very first devres action to call snd_card_free()
     214 * is added automatically.  In that way, the resource disconnection is assured
     215 * at first, then released in the expected order.
     216 *
     217 * If an error happens at the probe before snd_card_register() is called and
     218 * there have been other devres resources, you'd need to free the card manually
     219 * via snd_card_free() call in the error; otherwise it may lead to UAF due to
     220 * devres call orders.  You can use snd_card_free_on_error() helper for
     221 * handling it more easily.
     222 */
     223int snd_devm_card_new(struct device *parent, int idx, const char *xid,
     224                      struct module *module, size_t extra_size,
     225                      struct snd_card **card_ret)
     226{
     227        struct snd_card *card;
     228        int err;
     229
     230        *card_ret = NULL;
     231        card = devres_alloc(__snd_card_release, sizeof(*card) + extra_size,
     232                            GFP_KERNEL);
     233        if (!card)
     234                return -ENOMEM;
     235        card->managed = true;
     236        err = snd_card_init(card, parent, idx, xid, module, extra_size);
     237        if (err < 0) {
     238                devres_free(card);
     239                return err;
     240        }
     241        devres_add(parent, card);
     242
     243        *card_ret = card;
     244        return 0;
     245}
     246EXPORT_SYMBOL_GPL(snd_devm_card_new);
     247
     248/**
     249 * snd_card_free_on_error - a small helper for handling devm probe errors
     250 * @dev: the managed device object
     251 * @ret: the return code from the probe callback
     252 *
     253 * This function handles the explicit snd_card_free() call at the error from
     254 * the probe callback.  It's just a small helper for simplifying the error
     255 * handling with the managed devices.
     256 */
     257int snd_card_free_on_error(struct device *dev, int ret)
     258{
     259        struct snd_card *card;
     260
     261        if (!ret)
     262                return 0;
     263        card = devres_find(dev, __snd_card_release, NULL, NULL);
     264        if (card)
     265                snd_card_free(card);
     266        return ret;
     267}
     268EXPORT_SYMBOL_GPL(snd_card_free_on_error);
     269
     270static int snd_card_init(struct snd_card *card, struct device *parent,
     271                         int idx, const char *xid, struct module *module,
     272                         size_t extra_size)
     273{
     274        int err;
     275#ifdef CONFIG_SND_DEBUG
     276        char name[8];
     277#endif
     278
    183279        if (extra_size > 0)
    184280                card->private_data = (char *)card + sizeof(struct snd_card);
    … …  
    202298                dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
    203299                         idx, snd_ecards_limit - 1, err);
    204                 kfree(card);
    205300                return err;
    206301        }
    … …  
    261356        card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
    262357#endif
    263 
    264         *card_ret = card;
    265358        return 0;
    266359
    … …  
    271364        return err;
    272365}
    273 EXPORT_SYMBOL(snd_card_new);
    274366
    275367/**
    … …  
    489581static int snd_card_do_free(struct snd_card *card)
    490582{
     583        card->releasing = true;
    491584#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
    492585        if (snd_mixer_oss_notify_callback)
    … …  
    506599        if (card->release_completion)
    507600                complete(card->release_completion);
    508         kfree(card);
     601        if (!card->managed)
     602                kfree(card);
    509603        return 0;
    510604}
    … …  
    546640        DECLARE_COMPLETION_ONSTACK(released);
    547641        int ret;
     642
     643        /* The call of snd_card_free() is allowed from various code paths;
     644         * a manual call from the driver and the call via devres_free, and
     645         * we need to avoid double-free. Moreover, the release via devres
     646         * may call snd_card_free() twice due to its nature, we need to have
     647         * the check here at the beginning.
     648         */
     649        if (card->releasing)
     650                return 0;
    548651
    549652        card->release_completion = &released;
    … …  
    755858EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
    756859
     860static void trigger_card_free(void *data)
     861{
     862        snd_card_free(data);
     863}
     864
    757865/**
    758866 *  snd_card_register - register the soundcard
    … …  
    778886                        return err;
    779887                card->registered = true;
     888        } else {
     889                if (card->managed)
     890                        devm_remove_action(card->dev, trigger_card_free, card);
     891        }
     892
     893        if (card->managed) {
     894                err = devm_add_action(card->dev, trigger_card_free, card);
     895                if (err < 0)
     896                        return err;
    780897        }
    781898

  • GPL/trunk/alsa-kernel/core/jack.c

    r695 r717  
    4343        struct snd_jack *jack = device->device_data;
    4444
    45         if (!jack->input_dev)
     45        mutex_lock(&jack->input_dev_lock);
     46        if (!jack->input_dev) {
     47                mutex_unlock(&jack->input_dev_lock);
    4648                return 0;
     49        }
    4750
    4851        /* If the input device is registered with the input subsystem
    … …  
    5356                input_free_device(jack->input_dev);
    5457        jack->input_dev = NULL;
     58        mutex_unlock(&jack->input_dev_lock);
    5559#endif /* CONFIG_SND_JACK_INPUT_DEV */
    5660        return 0;
    … …  
    6367        struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
    6468
     69        down_write(&card->controls_rwsem);
    6570        list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list, struct snd_jack_kctl) {
    6671                list_del_init(&jack_kctl->list);
    6772                snd_ctl_remove(card, jack_kctl->kctl);
    6873        }
     74        up_write(&card->controls_rwsem);
     75
    6976        if (jack->private_free)
    7077                jack->private_free(jack);
    … …  
    8895                 card->shortname, jack->id);
    8996
    90         if (!jack->input_dev)
     97        mutex_lock(&jack->input_dev_lock);
     98        if (!jack->input_dev) {
     99                mutex_unlock(&jack->input_dev_lock);
    91100                return 0;
     101        }
    92102
    93103        jack->input_dev->name = jack->name;
    … …  
    114124                jack->registered = 1;
    115125
     126        mutex_unlock(&jack->input_dev_lock);
    116127        return err;
    117128}
    … …  
    510521
    511522        jack->id = kstrdup(id, GFP_KERNEL);
    512 
    513         /* don't creat input device for phantom jack */
     523        if (jack->id == NULL) {
     524                kfree(jack);
     525                return -ENOMEM;
     526        }
     527
     528#ifdef CONFIG_SND_JACK_INPUT_DEV
     529        mutex_init(&jack->input_dev_lock);
     530
     531        /* don't create input device for phantom jack */
    514532        if (!phantom_jack) {
    515 #ifdef CONFIG_SND_JACK_INPUT_DEV
    516533                int i;
    517534
    … …  
    531548                                                     jack_switch_types[i]);
    532549
     550        }
    533551#endif /* CONFIG_SND_JACK_INPUT_DEV */
    534         }
    535552
    536553        err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
    … …  
    572589{
    573590        WARN_ON(jack->registered);
    574         if (!jack->input_dev)
     591        mutex_lock(&jack->input_dev_lock);
     592        if (!jack->input_dev) {
     593                mutex_unlock(&jack->input_dev_lock);
    575594                return;
     595        }
    576596
    577597        jack->input_dev->dev.parent = parent;
     598        mutex_unlock(&jack->input_dev_lock);
    578599}
    579600EXPORT_SYMBOL(snd_jack_set_parent);
    … …  
    623644/**
    624645 * snd_jack_report - Report the current status of a jack
     646 * Note: This function uses mutexes and should be called from a
     647 * context which can sleep (such as a workqueue).
    625648 *
    626649 * @jack:   The jack to report status for
    … …  
    648671
    649672#ifdef CONFIG_SND_JACK_INPUT_DEV
    650         if (!jack->input_dev)
     673        mutex_lock(&jack->input_dev_lock);
     674        if (!jack->input_dev) {
     675                mutex_unlock(&jack->input_dev_lock);
    651676                return;
     677        }
    652678
    653679        for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
    … …  
    669695
    670696        input_sync(jack->input_dev);
     697        mutex_unlock(&jack->input_dev_lock);
    671698#endif /* CONFIG_SND_JACK_INPUT_DEV */
    672699}

  • GPL/trunk/alsa-kernel/core/memalloc.c

    r703 r717  
    4444                                        gfp_flags);
    4545#ifdef CONFIG_X86
    46         if (dmab->area && dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
     46        if (dmab->area && dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
    4747                set_memory_wc((unsigned long)dmab->area,
    4848                              PAGE_ALIGN(size) >> PAGE_SHIFT);
    … …  
    7171{
    7272#ifdef CONFIG_X86
    73         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
     73        if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
    7474                set_memory_wb((unsigned long)dmab->area,
    7575                              PAGE_ALIGN(dmab->bytes) >> PAGE_SHIFT);
    … …  
    204204#endif /* CONFIG_GENERIC_ALLOCATOR */
    205205        case SNDRV_DMA_TYPE_DEV:
    206         case SNDRV_DMA_TYPE_DEV_UC:
     206        case SNDRV_DMA_TYPE_DEV_WC:
    207207#ifndef TARGET_OS2
    208208                snd_malloc_dev_pages(dmab, size);
    … …  
    214214#ifdef CONFIG_SND_DMA_SGBUF
    215215        case SNDRV_DMA_TYPE_DEV_SG:
    216         case SNDRV_DMA_TYPE_DEV_UC_SG:
     216        case SNDRV_DMA_TYPE_DEV_WC_SG:
    217217                snd_malloc_sgbuf_pages(device, size, dmab, NULL);
    218218                break;
    … …  
    286286#endif /* CONFIG_GENERIC_ALLOCATOR */
    287287        case SNDRV_DMA_TYPE_DEV:
    288         case SNDRV_DMA_TYPE_DEV_UC:
     288        case SNDRV_DMA_TYPE_DEV_WC:
    289289#ifndef TARGET_OS2
    290290                snd_free_dev_pages(dmab);
    … …  
    296296#ifdef CONFIG_SND_DMA_SGBUF
    297297        case SNDRV_DMA_TYPE_DEV_SG:
    298         case SNDRV_DMA_TYPE_DEV_UC_SG:
     298        case SNDRV_DMA_TYPE_DEV_WC_SG:
    299299                snd_free_sgbuf_pages(dmab);
    300300                break;
    … …  
    337337}
    338338#endif
     339
     340/* called by devres */
     341static void __snd_release_pages(struct device *dev, void *res)
     342{
     343        snd_dma_free_pages(res);
     344}
     345
     346/**
     347 * snd_devm_alloc_pages - allocate the buffer and manage with devres
     348 * @dev: the device pointer
     349 * @type: the DMA buffer type
     350 * @size: the buffer size to allocate
     351 *
     352 * Allocate buffer pages depending on the given type and manage using devres.
     353 * The pages will be released automatically at the device removal.
     354 *
     355 * Unlike snd_dma_alloc_pages(), this function requires the real device pointer,
     356 * hence it can't work with SNDRV_DMA_TYPE_CONTINUOUS or
     357 * SNDRV_DMA_TYPE_VMALLOC type.
     358 *
     359 * The function returns the snd_dma_buffer object at success, or NULL if failed.
     360 */
     361struct snd_dma_buffer *
     362snd_devm_alloc_pages(struct device *dev, int type, size_t size)
     363{
     364        struct snd_dma_buffer *dmab;
     365        int err;
     366
     367        if (WARN_ON(type == SNDRV_DMA_TYPE_CONTINUOUS ||
     368                    type == SNDRV_DMA_TYPE_VMALLOC))
     369                return NULL;
     370
     371        dmab = devres_alloc(__snd_release_pages, sizeof(*dmab), GFP_KERNEL);
     372        if (!dmab)
     373                return NULL;
     374
     375        err = snd_dma_alloc_pages(type, dev, size, dmab);
     376        if (err < 0) {
     377                devres_free(dmab);
     378                return NULL;
     379        }
     380
     381        devres_add(dev, dmab);
     382        return dmab;
     383}
     384EXPORT_SYMBOL_GPL(snd_devm_alloc_pages);

  • GPL/trunk/alsa-kernel/core/memalloc_local.h

    r703 r717  
    44
    55struct snd_malloc_ops {
    6         int (*alloc)(struct snd_dma_buffer *dmab, size_t size);
     6        void *(*alloc)(struct snd_dma_buffer *dmab, size_t size);
    77        void (*free)(struct snd_dma_buffer *dmab);
    88        dma_addr_t (*get_addr)(struct snd_dma_buffer *dmab, size_t offset);

  • GPL/trunk/alsa-kernel/core/misc.c

    r679 r717  
    113113        const struct snd_pci_quirk *q;
    114114
    115         for (q = list; q->subvendor; q++) {
     115        for (q = list; q->subvendor || q->subdevice; q++) {
    116116                if (q->subvendor != vendor)
    117117                        continue;

  • GPL/trunk/alsa-kernel/core/oss/pcm_oss.c

    r703 r717  
    152152 * Return the maximum value for field PAR.
    153153 */
    154 static unsigned int
     154static int
    155155snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
    156156                           snd_pcm_hw_param_t var, int *dir)
    … …  
    691691                                   struct snd_pcm_hw_params *slave_params)
    692692{
    693         size_t s;
    694         size_t oss_buffer_size, oss_period_size, oss_periods;
    695         size_t min_period_size, max_period_size;
     693        ssize_t s;
     694        ssize_t oss_buffer_size;
     695        ssize_t oss_period_size, oss_periods;
     696        ssize_t min_period_size, max_period_size;
    696697        struct snd_pcm_runtime *runtime = substream->runtime;
    697698        size_t oss_frame_size;
    … …  
    700701                         params_channels(oss_params) / 8;
    701702
     703        oss_buffer_size = snd_pcm_hw_param_value_max(slave_params,
     704                                                     SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
     705                                                     NULL);
     706        if (oss_buffer_size <= 0)
     707                return -EINVAL;
    702708        oss_buffer_size = snd_pcm_plug_client_size(substream,
    703                                                    snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;
    704         if (!oss_buffer_size)
     709                                                   oss_buffer_size * oss_frame_size);
     710        if (oss_buffer_size <= 0)
    705711                return -EINVAL;
    706712        oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);
    … …  
    739745        min_period_size = snd_pcm_plug_client_size(substream,
    740746                                                   snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
    741         if (min_period_size) {
     747        if (min_period_size > 0) {
    742748                min_period_size *= oss_frame_size;
    743749                min_period_size = roundup_pow_of_two(min_period_size);
    … …  
    748754        max_period_size = snd_pcm_plug_client_size(substream,
    749755                                                   snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
    750         if (max_period_size) {
     756        if (max_period_size > 0) {
    751757                max_period_size *= oss_frame_size;
    752758                max_period_size = rounddown_pow_of_two(max_period_size);
    … …  
    762768
    763769        s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
    764         if (runtime->oss.maxfrags && s > runtime->oss.maxfrags)
     770        if (s > 0 && runtime->oss.maxfrags && s > runtime->oss.maxfrags)
    765771                s = runtime->oss.maxfrags;
    766772        if (oss_periods > s)
    … …  
    778784        if (oss_period_size < 16)
    779785                return -EINVAL;
     786
     787        /* don't allocate too large period; 1MB period must be enough */
     788        if (oss_period_size > 1024 * 1024)
     789                return -ENOMEM;
     790
    780791        runtime->oss.period_bytes = oss_period_size;
    781792        runtime->oss.period_frames = 1;
    … …  
    888899                goto failure;
    889900        }
    890         choose_rate(substream, sparams, runtime->oss.rate);
    891         snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_CHANNELS, runtime->oss.channels, NULL);
     901
     902        err = choose_rate(substream, sparams, runtime->oss.rate);
     903        if (err < 0)
     904                goto failure;
     905        err = snd_pcm_hw_param_near(substream, sparams,
     906                                    SNDRV_PCM_HW_PARAM_CHANNELS,
     907                                    runtime->oss.channels, NULL);
     908        if (err < 0)
     909                goto failure;
    892910
    893911        format = snd_pcm_oss_format_from(runtime->oss.format);
    … …  
    10401058        }
    10411059#endif
    1042         oss_period_size *= oss_frame_size;
    1043 
    1044         oss_buffer_size = oss_period_size * runtime->oss.periods;
    1045         if (oss_buffer_size < 0) {
     1060        oss_period_size = array_size(oss_period_size, oss_frame_size);
     1061        oss_buffer_size = array_size(oss_period_size, runtime->oss.periods);
     1062        if (oss_buffer_size <= 0) {
    10461063                err = -EINVAL;
    10471064                goto failure;
    … …  
    19701987                return -EINVAL;
    19711988        fragshift = val & 0xffff;
    1972         if (fragshift >= 31)
     1989        if (fragshift >= 25) /* should be large enough */
    19731990                return -EINVAL;
    19741991        runtime->oss.fragshift = fragshift;
    … …  
    20662083
    20672084#ifdef OSS_DEBUG
    2068         pcm_dbg(substream->pcm, "pcm_oss: trigger = 0x%x\n", trigger);
     2085        pr_debug("pcm_oss: trigger = 0x%x\n", trigger);
    20692086#endif
    20702087       

  • GPL/trunk/alsa-kernel/core/pcm.c

    r703 r717  
    818818{
    819819        if (pstr->chmap_kctl) {
    820                 snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl);
     820                struct snd_card *card = pstr->pcm->card;
     821
     822                down_write(&card->controls_rwsem);
     823                snd_ctl_remove(card, pstr->chmap_kctl);
     824                up_write(&card->controls_rwsem);
    821825                pstr->chmap_kctl = NULL;
    822826        }
    … …  
    973977
    974978        runtime->status->state = SNDRV_PCM_STATE_OPEN;
     979        mutex_init(&runtime->buffer_mutex);
     980        atomic_set(&runtime->buffer_accessing, 0);
    975981
    976982        substream->runtime = runtime;
    … …  
    10061012                substream->runtime = NULL;
    10071013        }
     1014        mutex_destroy(&runtime->buffer_mutex);
    10081015        kfree(runtime);
    10091016        put_pid(substream->pid);

  • GPL/trunk/alsa-kernel/core/pcm_lib.c

    r703 r717  
    23032303                        goto _end_unlock;
    23042304                }
     2305#ifndef TARGET_OS2
     2306                if (!atomic_inc_unless_negative(&runtime->buffer_accessing)) {
     2307                        err = -EBUSY;
     2308                        goto _end_unlock;
     2309                }
     2310#endif
    23052311                snd_pcm_stream_unlock_irq(substream);
    23062312                err = writer(substream, appl_ofs, data, offset, frames,
    23072313                             transfer);
    23082314                snd_pcm_stream_lock_irq(substream);
     2315#ifndef TARGET_OS2
     2316                atomic_dec(&runtime->buffer_accessing);
     2317#endif
    23092318                if (err < 0)
    23102319                        goto _end_unlock;

  • GPL/trunk/alsa-kernel/core/pcm_memory.c

    r703 r717  
    6868 * the minimum size is snd_minimum_buffer.  it should be power of 2.
    6969 */
    70 static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
     70static int preallocate_pcm_pages(struct snd_pcm_substream *substream,
     71                                 size_t size, bool no_fallback)
    7172{
    7273        struct snd_dma_buffer *dmab = &substream->dma_buffer;
    … …  
    8081                if (err != -ENOMEM)
    8182                        return err;
     83                if (no_fallback)
     84                        break;
    8285                size >>= 1;
    8386        } while (size >= snd_minimum_buffer);
    … …  
    8790                substream->stream ? 'c' : 'p', substream->number,
    8891                substream->pcm->name, orig_size);
    89         return 0;
     92        return -ENOMEM;
    9093}
    9194
    … …  
    156159        struct snd_dma_buffer new_dmab;
    157160
     161        mutex_lock(&substream->pcm->open_mutex);
    158162        if (substream->runtime) {
    159163                buffer->error = -EBUSY;
    160                 return;
     164                goto unlock;
    161165        }
    162166        if (!snd_info_get_line(buffer, line, sizeof(line))) {
    … …  
    165169                if ((size != 0 && size < 8192) || size > substream->dma_max) {
    166170                        buffer->error = -EINVAL;
    167                         return;
     171                        goto unlock;
    168172                }
    169173                if (substream->dma_buffer.bytes == size)
    170                         return;
     174                        goto unlock;
    171175                memset(&new_dmab, 0, sizeof(new_dmab));
    172176                new_dmab.dev = substream->dma_buffer.dev;
    … …  
    181185                                         substream->stream ? 'c' : 'p', substream->number,
    182186                                         substream->pcm->name, size);
    183                                 return;
     187                                goto unlock;
    184188                        }
    185189                        substream->buffer_bytes_max = size;
    … …  
    193197                buffer->error = -EINVAL;
    194198        }
     199 unlock:
     200        mutex_unlock(&substream->pcm->open_mutex);
    195201}
    196202
    … …  
    223229 * pre-allocate the buffer and create a proc file for the substream
    224230 */
    225 static void preallocate_pages(struct snd_pcm_substream *substream,
     231static int preallocate_pages(struct snd_pcm_substream *substream,
    226232                              int type, struct device *data,
    227233                              size_t size, size_t max, bool managed)
    228234{
     235        int err;
     236
    229237        if (snd_BUG_ON(substream->dma_buffer.dev.type))
    230                 return;
     238                return -EINVAL;
    231239
    232240        substream->dma_buffer.dev.type = type;
    233241        substream->dma_buffer.dev.dev = data;
    234242
    235         if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
    236                 preallocate_pcm_pages(substream, size);
     243        if (size > 0) {
     244                if (!max) {
     245                        /* no fallback, only also inform -ENOMEM */
     246                        err = preallocate_pcm_pages(substream, size, true);
     247                        if (err < 0)
     248                                return err;
     249                } else if (preallocate_dma &&
     250                           substream->number < maximum_substreams) {
     251                        err = preallocate_pcm_pages(substream, size, false);
     252                        if (err < 0 && err != -ENOMEM)
     253                                return err;
     254                }
     255        }
    237256
    238257        if (substream->dma_buffer.bytes > 0)
    … …  
    243262        if (managed)
    244263                substream->managed_buffer_alloc = 1;
    245 }
    246 
    247 static void preallocate_pages_for_all(struct snd_pcm *pcm, int type,
     264        return 0;
     265}
     266
     267static int preallocate_pages_for_all(struct snd_pcm *pcm, int type,
    248268                                      void *data, size_t size, size_t max,
    249269                                      bool managed)
    250270{
    251271        struct snd_pcm_substream *substream;
    252         int stream;
    253 
    254         for_each_pcm_substream(pcm, stream, substream)
    255                 preallocate_pages(substream, type, data, size, max, managed);
     272        int stream, err;
     273
     274        for_each_pcm_substream(pcm, stream, substream) {
     275                err = preallocate_pages(substream, type, data, size, max, managed);
     276                if (err < 0)
     277                        return err;
     278        }
     279        return 0;
    256280}
    257281
    … …  
    310334 * turns on the runtime buffer_changed flag for drivers changing their h/w
    311335 * parameters accordingly.
    312  */
    313 void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
     336 *
     337 * When @size is non-zero and @max is zero, this tries to allocate for only
     338 * the exact buffer size without fallback, and may return -ENOMEM.
     339 * Otherwise, the function tries to allocate smaller chunks if the allocation
     340 * fails.  This is the behavior of snd_pcm_set_fixed_buffer().
     341 *
     342 * When both @size and @max are zero, the function only sets up the buffer
     343 * for later dynamic allocations. It's used typically for buffers with
     344 * SNDRV_DMA_TYPE_VMALLOC type.
     345 *
     346 * Upon successful buffer allocation and setup, the function returns 0.
     347 */
     348int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
    314349                                struct device *data, size_t size, size_t max)
    315350{
    316         preallocate_pages(substream, type, data, size, max, true);
     351        return preallocate_pages(substream, type, data, size, max, true);
    317352}
    318353EXPORT_SYMBOL(snd_pcm_set_managed_buffer);
    … …  
    330365 * type and size, and set the managed_buffer_alloc flag to each substream.
    331366 */
    332 void snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
    333                                     struct device *data,
    334                                     size_t size, size_t max)
    335 {
    336         preallocate_pages_for_all(pcm, type, data, size, max, true);
     367int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
     368                                   struct device *data,
     369                                   size_t size, size_t max)
     370{
     371        return preallocate_pages_for_all(pcm, type, data, size, max, true);
    337372}
    338373EXPORT_SYMBOL(snd_pcm_set_managed_buffer_all);
    … …  
    377412                dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
    378413        } else {
     414                /* dma_max=0 means the fixed size preallocation */
     415                if (substream->dma_buffer.area && !substream->dma_max)
     416                        return -ENOMEM;
    379417                dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
    380418                if (! dmab)
    … …  
    409447int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
    410448{
    411         struct snd_card *card = substream->pcm->card;
    412449        struct snd_pcm_runtime *runtime;
    413450
    … …  
    418455                return 0;
    419456        if (runtime->dma_buffer_p != &substream->dma_buffer) {
     457                struct snd_card *card = substream->pcm->card;
     458
    420459                /* it's a newly allocated buffer.  release it now. */
    421460                do_free_pages(card, runtime->dma_buffer_p);

  • GPL/trunk/alsa-kernel/core/pcm_misc.c

    r703 r717  
    434434        width = pcm_formats[(INT)format].phys; /* physical width */
    435435        pat = pcm_formats[(INT)format].silence;
    436         if (! width)
     436        if (!width || !pat)
    437437                return -EINVAL;
    438438        /* signed or 1 byte data */

  • GPL/trunk/alsa-kernel/core/pcm_native.c

    r703 r717  
    248248static bool hw_support_mmap(struct snd_pcm_substream *substream)
    249249{
     250        struct snd_dma_buffer *dmabuf;
     251
    250252        if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_MMAP))
    251253                return false;
    … …  
    254256                return true;
    255257
    256         switch (substream->dma_buffer.dev.type) {
     258        dmabuf = snd_pcm_get_dma_buf(substream);
     259        if (!dmabuf)
     260                dmabuf = &substream->dma_buffer;
     261        switch (dmabuf->dev.type) {
    257262        case SNDRV_DMA_TYPE_UNKNOWN:
    258263                /* we can't know the device, so just assume that the driver does
    … …  
    264269                return true;
    265270        default:
    266                 return dma_can_mmap(substream->dma_buffer.dev.dev);
     271                return dma_can_mmap(dmabuf->dev.dev);
    267272        }
    268273}
    … …  
    672677}
    673678
     679/* acquire buffer_mutex; if it's in r/w operation, return -EBUSY, otherwise
     680 * block the further r/w operations
     681 */
     682static int snd_pcm_buffer_access_lock(struct snd_pcm_runtime *runtime)
     683{
     684#ifndef TARGET_OS2
     685        if (!atomic_dec_unless_positive(&runtime->buffer_accessing))
     686                return -EBUSY;
     687#endif
     688        mutex_lock(&runtime->buffer_mutex);
     689        return 0; /* keep buffer_mutex, unlocked by below */
     690}
     691
     692/* release buffer_mutex and clear r/w access flag */
     693static void snd_pcm_buffer_access_unlock(struct snd_pcm_runtime *runtime)
     694{
     695        mutex_unlock(&runtime->buffer_mutex);
     696        atomic_inc(&runtime->buffer_accessing);
     697}
     698
     699#if IS_ENABLED(CONFIG_SND_PCM_OSS)
     700#define is_oss_stream(substream)        ((substream)->oss.oss)
     701#else
     702#define is_oss_stream(substream)        false
     703#endif
     704
    674705static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
    675706                             struct snd_pcm_hw_params *params)
    … …  
    683714                return -ENXIO;
    684715        runtime = substream->runtime;
     716        err = snd_pcm_buffer_access_lock(runtime);
     717        if (err < 0)
     718                return err;
    685719        snd_pcm_stream_lock_irq(substream);
    686720        switch (runtime->status->state) {
    … …  
    688722        case SNDRV_PCM_STATE_SETUP:
    689723        case SNDRV_PCM_STATE_PREPARED:
     724                if (!is_oss_stream(substream) &&
     725                    atomic_read(&substream->mmap_count))
     726                        err = -EBADFD;
    690727                break;
    691728        default:
    692                 snd_pcm_stream_unlock_irq(substream);
    693                 return -EBADFD;
     729                err = -EBADFD;
     730                break;
    694731        }
    695732        snd_pcm_stream_unlock_irq(substream);
    696 #if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
    697         if (!substream->oss.oss)
    698 #endif
    699                 if (atomic_read(&substream->mmap_count))
    700                         return -EBADFD;
     733        if (err)
     734                goto unlock;
    701735
    702736        snd_pcm_sync_stop(substream, true);
    … …  
    786820                cpu_latency_qos_add_request(&substream->latency_pm_qos_req,
    787821                                            usecs);
    788         return 0;
     822        err = 0;
    789823 _error:
    790         /* hardware might be unusable from this time,
    791            so we force application to retry to set
    792            the correct hardware parameter settings */
    793         snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
    794         if (substream->ops->hw_free != NULL)
    795                 substream->ops->hw_free(substream);
    796         if (substream->managed_buffer_alloc)
    797                 snd_pcm_lib_free_pages(substream);
     824        if (err) {
     825                /* hardware might be unusable from this time,
     826                 * so we force application to retry to set
     827                 * the correct hardware parameter settings
     828                 */
     829                snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
     830                if (substream->ops->hw_free != NULL)
     831                        substream->ops->hw_free(substream);
     832                if (substream->managed_buffer_alloc)
     833                        snd_pcm_lib_free_pages(substream);
     834        }
     835 unlock:
     836        snd_pcm_buffer_access_unlock(runtime);
    798837        return err;
    799838}
    … …  
    835874{
    836875        struct snd_pcm_runtime *runtime;
    837         int result;
     876        int result = 0;
    838877
    839878        if (PCM_RUNTIME_CHECK(substream))
    840879                return -ENXIO;
    841880        runtime = substream->runtime;
     881        result = snd_pcm_buffer_access_lock(runtime);
     882        if (result < 0)
     883                return result;
    842884        snd_pcm_stream_lock_irq(substream);
    843885        switch (runtime->status->state) {
    844886        case SNDRV_PCM_STATE_SETUP:
    845887        case SNDRV_PCM_STATE_PREPARED:
     888                if (atomic_read(&substream->mmap_count))
     889                        result = -EBADFD;
    846890                break;
    847891        default:
    848                 snd_pcm_stream_unlock_irq(substream);
    849                 return -EBADFD;
     892                result = -EBADFD;
     893                break;
    850894        }
    851895        snd_pcm_stream_unlock_irq(substream);
    852         if (atomic_read(&substream->mmap_count))
    853                 return -EBADFD;
     896        if (result)
     897                goto unlock;
    854898        result = do_hw_free(substream);
    855899        snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
    856900        cpu_latency_qos_remove_request(&substream->latency_pm_qos_req);
     901 unlock:
     902        snd_pcm_buffer_access_unlock(runtime);
    857903        return result;
    858904}
    … …  
    11811227                                struct snd_pcm_substream *substream,
    11821228                                snd_pcm_state_t state,
    1183                                 bool do_lock)
     1229                                bool stream_lock)
    11841230{
    11851231        struct snd_pcm_substream *s = NULL;
    … …  
    11881234
    11891235        snd_pcm_group_for_each_entry(s, substream) {
    1190                 if (do_lock && s != substream) {
    1191                         if (s->pcm->nonatomic)
     1236                if (s != substream) {
     1237                        if (!stream_lock)
     1238                                mutex_lock_nested(&s->runtime->buffer_mutex, depth);
     1239                        else if (s->pcm->nonatomic)
    11921240                                mutex_lock_nested(&s->self_group.mutex, depth);
    11931241                        else
    … …  
    12171265        }
    12181266 _unlock:
    1219         if (do_lock) {
    1220                 /* unlock streams */
    1221                 snd_pcm_group_for_each_entry(s1, substream) {
    1222                         if (s1 != substream) {
    1223                                 if (s1->pcm->nonatomic)
    1224                                         mutex_unlock(&s1->self_group.mutex);
    1225                                 else
    1226                                         spin_unlock(&s1->self_group.lock);
    1227                         }
    1228                         if (s1 == s)    /* end */
    1229                                 break;
     1267        /* unlock streams */
     1268        snd_pcm_group_for_each_entry(s1, substream) {
     1269                if (s1 != substream) {
     1270                        if (!stream_lock)
     1271                                mutex_unlock(&s1->runtime->buffer_mutex);
     1272                        else if (s1->pcm->nonatomic)
     1273                                mutex_unlock(&s1->self_group.mutex);
     1274                        else
     1275                                spin_unlock(&s1->self_group.lock);
    12301276                }
     1277                if (s1 == s)    /* end */
     1278                        break;
    12311279        }
    12321280        return res;
    … …  
    13581406        /* Guarantee the group members won't change during non-atomic action */
    13591407        down_read(&snd_pcm_link_rwsem);
     1408        res = snd_pcm_buffer_access_lock(substream->runtime);
     1409        if (res < 0)
     1410                goto unlock;
    13601411        if (snd_pcm_stream_linked(substream))
    13611412                res = snd_pcm_action_group(ops, substream, state, false);
    13621413        else
    13631414                res = snd_pcm_action_single(ops, substream, state);
     1415        snd_pcm_buffer_access_unlock(substream->runtime);
     1416 unlock:
    13641417        up_read(&snd_pcm_link_rwsem);
    13651418        return res;
    … …  
    18511904        if (err < 0)
    18521905                return err;
     1906        snd_pcm_stream_lock_irq(substream);
    18531907        runtime->hw_ptr_base = 0;
    18541908        runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
    … …  
    18561910        runtime->silence_start = runtime->status->hw_ptr;
    18571911        runtime->silence_filled = 0;
     1912        snd_pcm_stream_unlock_irq(substream);
    18581913        return 0;
    18591914}
    … …  
    18631918{
    18641919        struct snd_pcm_runtime *runtime = substream->runtime;
     1920        snd_pcm_stream_lock_irq(substream);
    18651921        runtime->control->appl_ptr = runtime->status->hw_ptr;
    18661922        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
    18671923            runtime->silence_size > 0)
    18681924                snd_pcm_playback_silence(substream, ULONG_MAX);
     1925        snd_pcm_stream_unlock_irq(substream);
    18691926}
    18701927
    … …  
    36663723static bool pcm_status_mmap_allowed(struct snd_pcm_file *pcm_file)
    36673724{
     3725        /* If drivers require the explicit sync (typically for non-coherent
     3726         * pages), we have to disable the mmap of status and control data
     3727         * to enforce the control via SYNC_PTR ioctl.
     3728         */
     3729        if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC)
     3730                return false;
    36683731        /* See pcm_control_mmap_allowed() below.
    36693732         * Since older alsa-lib requires both status and control mmaps to be
    … …  
    36793742{
    36803743        if (pcm_file->no_compat_mmap)
     3744                return false;
     3745        /* see above */
     3746        if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC)
    36813747                return false;
    36823748        /* Disallow the control mmap when SYNC_APPLPTR flag is set;

  • GPL/trunk/alsa-kernel/core/rawmidi.c

    r703 r717  
    465465                goto __error;
    466466        }
     467        rawmidi_file->user_pversion = 0;
    467468        init_waitqueue_entry(&wait, current);
    468469        add_wait_queue(&rmidi->open_wait, &wait);
    … …  
    894895                }
    895896        }
     897        case SNDRV_RAWMIDI_IOCTL_USER_PVERSION:
     898                if (get_user(rfile->user_pversion, (unsigned int __user *)arg))
     899                        return -EFAULT;
     900                return 0;
     901
    896902        case SNDRV_RAWMIDI_IOCTL_PARAMS:
    897903        {
    … …  
    900906                if (copy_from_user(&params, argp, sizeof(struct snd_rawmidi_params)))
    901907                        return -EFAULT;
     908                if (rfile->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 2)) {
     909                        params.mode = 0;
     910                        memset(params.reserved, 0, sizeof(params.reserved));
     911                }
    902912                switch (params.stream) {
    903913                case SNDRV_RAWMIDI_STREAM_OUTPUT:

  • GPL/trunk/alsa-kernel/core/seq/seq_dummy.c

    r703 r717  
    2121  The routing can be done via aconnect program in alsa-utils.
    2222
    23   Each client has a static client number 62 (= SNDRV_SEQ_CLIENT_DUMMY).
     23  Each client has a static client number 14 (= SNDRV_SEQ_CLIENT_DUMMY).
    2424  If you want to auto-load this module, you may add the following alias
    2525  in your /etc/conf.modules file.
    2626
    27         alias snd-seq-client-62  snd-seq-dummy
    28 
    29   The module is loaded on demand for client 62, or /proc/asound/seq/
     27        alias snd-seq-client-14  snd-seq-dummy
     28
     29  The module is loaded on demand for client 14, or /proc/asound/seq/
    3030  is accessed.  If you don't need this module to be loaded, alias
    31   snd-seq-client-62 as "off".  This will help modprobe.
     31  snd-seq-client-14 as "off".  This will help modprobe.
    3232
    3333  The number of ports to be created can be specified via the module

  • GPL/trunk/alsa-kernel/core/seq/seq_queue.c

    r703 r717  
    236236/* -------------------------------------------------------- */
    237237
     238#define MAX_CELL_PROCESSES_IN_QUEUE     1000
     239
    238240void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop)
    239241{
    … …  
    242244        snd_seq_tick_time_t cur_tick;
    243245        snd_seq_real_time_t cur_time;
     246        int processed = 0;
    244247
    245248        if (q == NULL)
    … …  
    264267                        break;
    265268                snd_seq_dispatch_event(cell, atomic, hop);
     269                if (++processed >= MAX_CELL_PROCESSES_IN_QUEUE)
     270                        goto out; /* the rest processed at the next batch */
    266271        }
    267272
    … …  
    273278                        break;
    274279                snd_seq_dispatch_event(cell, atomic, hop);
    275         }
    276 
     280                if (++processed >= MAX_CELL_PROCESSES_IN_QUEUE)
     281                        goto out; /* the rest processed at the next batch */
     282        }
     283
     284 out:
    277285        /* free lock */
    278286        spin_lock_irqsave(&q->check_lock, flags);
    279287        if (q->check_again) {
    280288                q->check_again = 0;
    281                 spin_unlock_irqrestore(&q->check_lock, flags);
    282                 goto __again;
     289                if (processed < MAX_CELL_PROCESSES_IN_QUEUE) {
     290                        spin_unlock_irqrestore(&q->check_lock, flags);
     291                        goto __again;
     292                }
    283293        }
    284294        q->check_blocked = 0;

  • GPL/trunk/alsa-kernel/core/seq_device.c

    r695 r717  
    157157
    158158        cancel_autoload_drivers();
     159        if (dev->private_free)
     160                dev->private_free(dev);
    159161        put_device(&dev->dev);
    160162        return 0;
    … …  
    184186static void snd_seq_dev_release(struct device *dev)
    185187{
    186         struct snd_seq_device *sdev = to_seq_dev(dev);
    187 
    188         if (sdev->private_free)
    189                 sdev->private_free(sdev);
    190         kfree(sdev);
     188        kfree(to_seq_dev(dev));
    191189}
    192190

  • GPL/trunk/alsa-kernel/core/sgbuf.c

    r703 r717  
    5353
    5454        tmpb.dev.type = SNDRV_DMA_TYPE_DEV;
    55         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC_SG)
    56                 tmpb.dev.type = SNDRV_DMA_TYPE_DEV_UC;
     55        if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
     56                tmpb.dev.type = SNDRV_DMA_TYPE_DEV_WC;
    5757        tmpb.dev.dev = sgbuf->dev;
    5858        for (i = 0; i < sgbuf->pages; i++) {
    … …  
    134134        if (! sgbuf)
    135135                return NULL;
    136         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC_SG) {
    137                 type = SNDRV_DMA_TYPE_DEV_UC;
     136        if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG) {
     137                type = SNDRV_DMA_TYPE_DEV_WC;
    138138#ifdef pgprot_noncached
    139139                prot = pgprot_noncached(PAGE_KERNEL);

  • GPL/trunk/alsa-kernel/core/timer.c

    r695 r717  
    626626                return -EINVAL;
    627627        spin_lock_irqsave(&timer->lock, flags);
     628        list_del_init(&timeri->ack_list);
     629        list_del_init(&timeri->active_list);
    628630        if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
    629631                               SNDRV_TIMER_IFLG_START))) {
    … …  
    631633                goto unlock;
    632634        }
    633         list_del_init(&timeri->ack_list);
    634         list_del_init(&timeri->active_list);
    635635        if (timer->card && timer->card->shutdown)
    636636                goto unlock;
    … …  
    667667{
    668668        unsigned long flags;
     669        bool running;
    669670
    670671        spin_lock_irqsave(&slave_active_lock, flags);
    671         if (!(timeri->flags & SNDRV_TIMER_IFLG_RUNNING)) {
    672                 spin_unlock_irqrestore(&slave_active_lock, flags);
    673                 return -EBUSY;
    674         }
     672        running = timeri->flags & SNDRV_TIMER_IFLG_RUNNING;
    675673        timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
    676674        if (timeri->timer) {
    … …  
    678676                list_del_init(&timeri->ack_list);
    679677                list_del_init(&timeri->active_list);
    680                 snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
    681                                   SNDRV_TIMER_EVENT_PAUSE);
     678                if (running)
     679                        snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
     680                                          SNDRV_TIMER_EVENT_PAUSE);
    682681                spin_unlock(&timeri->timer->lock);
    683682        }
    684683        spin_unlock_irqrestore(&slave_active_lock, flags);
    685         return 0;
     684        return running ? 0 : -EBUSY;
    686685}
    687686

  • GPL/trunk/alsa-kernel/drivers/mpu401/mpu401.c

    r703 r717  
    7272
    7373        *rcard = NULL;
    74         err = snd_card_new(devptr, index[dev], id[dev], THIS_MODULE,
    75                            0, &card);
     74        err = snd_devm_card_new(devptr, index[dev], id[dev], THIS_MODULE,
     75                                0, &card);
    7676        if (err < 0)
    7777                return err;
    … …  
    8989        if (err < 0) {
    9090                printk(KERN_ERR "MPU401 not detected at 0x%lx\n", port[dev]);
    91                 goto _err;
     91                return err;
    9292        }
    9393
    9494        *rcard = card;
    9595        return 0;
    96 
    97  _err:
    98         snd_card_free(card);
    99         return err;
    10096}
    10197
    … …  
    118114                return err;
    119115        err = snd_card_register(card);
    120         if (err < 0) {
    121                 snd_card_free(card);
    122                 return err;
    123         }
     116        if (err < 0)
     117                return err;
    124118        platform_set_drvdata(devptr, card);
    125         return 0;
    126 }
    127 
    128 static int snd_mpu401_remove(struct platform_device *devptr)
    129 {
    130         snd_card_free(platform_get_drvdata(devptr));
    131119        return 0;
    132120}
    … …  
    136124static struct platform_driver snd_mpu401_driver = {
    137125        .probe          = snd_mpu401_probe,
    138         .remove         = snd_mpu401_remove,
    139126        .driver         = {
    140127                .name   = SND_MPU401_DRIVER,
    … …  
    197184                        return err;
    198185                err = snd_card_register(card);
    199                 if (err < 0) {
    200                         snd_card_free(card);
     186                if (err < 0)
    201187                        return err;
    202                 }
    203188                pnp_set_drvdata(pnp_dev, card);
    204189                snd_mpu401_devices++;
    … …  
    209194}
    210195
    211 static void snd_mpu401_pnp_remove(struct pnp_dev *dev)
    212 {
    213         struct snd_card *card = (struct snd_card *) pnp_get_drvdata(dev);
    214 
    215         snd_card_disconnect(card);
    216         snd_card_free_when_closed(card);
    217 }
    218 
    219196static struct pnp_driver snd_mpu401_pnp_driver = {
    220197        .name = "mpu401",
    221198        .id_table = snd_mpu401_pnpids,
    222199        .probe = snd_mpu401_pnp_probe,
    223         .remove = snd_mpu401_pnp_remove,
    224200};
    225201#else

  • GPL/trunk/alsa-kernel/drivers/opl3/opl3_midi.c

    r703 r717  
    401401        if (instr_4op) {
    402402                vp2 = &opl3->voices[voice + 3];
    403                 if (vp->state > 0) {
     403                if (vp2->state > 0) {
    404404                        opl3_reg = reg_side | (OPL3_REG_KEYON_BLOCK +
    405405                                               voice_offset + 3);

  • GPL/trunk/alsa-kernel/hda/ext/hdac_ext_stream.c

    r695 r717  
    107107EXPORT_SYMBOL_GPL(snd_hdac_stream_free_all);
    108108
    109 /**
    110  * snd_hdac_ext_stream_decouple - decouple the hdac stream
    111  * @bus: HD-audio core bus
    112  * @stream: HD-audio ext core stream object to initialize
    113  * @decouple: flag to decouple
    114  */
    115 void snd_hdac_ext_stream_decouple(struct hdac_bus *bus,
    116                                 struct hdac_ext_stream *stream, bool decouple)
     109void snd_hdac_ext_stream_decouple_locked(struct hdac_bus *bus,
     110                                         struct hdac_ext_stream *stream,
     111                                         bool decouple)
    117112{
    118113        struct hdac_stream *hstream = &stream->hstream;
    … …  
    120115        int mask = AZX_PPCTL_PROCEN(hstream->index);
    121116
    122         spin_lock_irq(&bus->reg_lock);
    123117        val = readw(bus->ppcap + AZX_REG_PP_PPCTL) & mask;
    124118
    … …  
    129123
    130124        stream->decoupled = decouple;
     125}
     126EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple_locked);
     127
     128/**
     129 * snd_hdac_ext_stream_decouple - decouple the hdac stream
     130 * @bus: HD-audio core bus
     131 * @stream: HD-audio ext core stream object to initialize
     132 * @decouple: flag to decouple
     133 */
     134void snd_hdac_ext_stream_decouple(struct hdac_bus *bus,
     135                                  struct hdac_ext_stream *stream, bool decouple)
     136{
     137        spin_lock_irq(&bus->reg_lock);
     138        snd_hdac_ext_stream_decouple_locked(bus, stream, decouple);
    131139        spin_unlock_irq(&bus->reg_lock);
    132140}
    … …  
    253261        }
    254262
     263        spin_lock_irq(&bus->reg_lock);
    255264        list_for_each_entry(stream, &bus->stream_list, list) {
    256265                struct hdac_ext_stream *hstream = container_of(stream,
    … …  
    267276
    268277                if (!hstream->link_locked) {
    269                         snd_hdac_ext_stream_decouple(bus, hstream, true);
     278                        snd_hdac_ext_stream_decouple_locked(bus, hstream, true);
    270279                        res = hstream;
    271280                        break;
    … …  
    273282        }
    274283        if (res) {
    275                 spin_lock_irq(&bus->reg_lock);
    276284                res->link_locked = 1;
    277285                res->link_substream = substream;
    278                 spin_unlock_irq(&bus->reg_lock);
    279         }
     286        }
     287        spin_unlock_irq(&bus->reg_lock);
    280288        return res;
    281289}
    … …  
    293301        }
    294302
     303        spin_lock_irq(&bus->reg_lock);
    295304        list_for_each_entry(stream, &bus->stream_list, list) {
    296305                struct hdac_ext_stream *hstream = container_of(stream,
    … …  
    302311                if (!stream->opened) {
    303312                        if (!hstream->decoupled)
    304                                 snd_hdac_ext_stream_decouple(bus, hstream, true);
     313                                snd_hdac_ext_stream_decouple_locked(bus, hstream, true);
    305314                        res = hstream;
    306315                        break;
    … …  
    308317        }
    309318        if (res) {
    310                 spin_lock_irq(&bus->reg_lock);
    311319                res->hstream.opened = 1;
    312320                res->hstream.running = 0;
    313321                res->hstream.substream = substream;
    314                 spin_unlock_irq(&bus->reg_lock);
    315         }
     322        }
     323        spin_unlock_irq(&bus->reg_lock);
    316324
    317325        return res;
    … …  
    379387
    380388        case HDAC_EXT_STREAM_TYPE_HOST:
     389                spin_lock_irq(&bus->reg_lock);
    381390                if (stream->decoupled && !stream->link_locked)
    382                         snd_hdac_ext_stream_decouple(bus, stream, false);
     391                        snd_hdac_ext_stream_decouple_locked(bus, stream, false);
     392                spin_unlock_irq(&bus->reg_lock);
    383393                snd_hdac_stream_release(&stream->hstream);
    384394                break;
    385395
    386396        case HDAC_EXT_STREAM_TYPE_LINK:
     397                spin_lock_irq(&bus->reg_lock);
    387398                if (stream->decoupled && !stream->hstream.opened)
    388                         snd_hdac_ext_stream_decouple(bus, stream, false);
    389                 spin_lock_irq(&bus->reg_lock);
     399                        snd_hdac_ext_stream_decouple_locked(bus, stream, false);
    390400                stream->link_locked = 0;
    391401                stream->link_substream = NULL;

  • GPL/trunk/alsa-kernel/hda/hdac_controller.c

    r695 r717  
    428428                goto skip_reset;
    429429
    430         /* clear STATESTS */
    431         snd_hdac_chip_writew(bus, STATESTS, STATESTS_INT_MASK);
     430        /* clear STATESTS if not in reset */
     431        if (snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET)
     432                snd_hdac_chip_writew(bus, STATESTS, STATESTS_INT_MASK);
    432433
    433434        /* reset controller */

  • GPL/trunk/alsa-kernel/hda/hdac_device.c

    r629 r717  
    675675        { 0x17e8, "Chrontel" },
    676676        { 0x1854, "LG" },
     677        { 0x19e5, "Huawei" },
    677678        { 0x1aec, "Wolfson Microelectronics" },
    678679        { 0x1af4, "QEMU" },

  • GPL/trunk/alsa-kernel/hda/hdac_stream.c

    r695 r717  
    302302                (substream->stream + 1);
    303303
     304        spin_lock_irq(&bus->reg_lock);
    304305        list_for_each_entry(azx_dev, &bus->stream_list, list, struct hdac_stream) {
    305306                if (azx_dev->direction != substream->stream)
    … …  
    315316        }
    316317        if (res) {
    317                 spin_lock_irq(&bus->reg_lock);
    318318                res->opened = 1;
    319319                res->running = 0;
    320320                res->assigned_key = key;
    321321                res->substream = substream;
    322                 spin_unlock_irq(&bus->reg_lock);
    323         }
     322        }
     323        spin_unlock_irq(&bus->reg_lock);
    324324        return res;
    325325}
    … …  
    539539        cc->mask = CLOCKSOURCE_MASK(32);
    540540
     541#ifndef TARGET_OS2
     542        /*
     543         * Calculate the optimal mult/shift values. The counter wraps
     544         * around after ~178.9 seconds.
     545         */
     546        clocks_calc_mult_shift(&cc->mult, &cc->shift, 24000000,
     547                               NSEC_PER_SEC, 178);
     548#else
    541549        /*
    542550         * Converting from 24 MHz to ns means applying a 125/3 factor.
    … …  
    551559        cc->mult = 125; /* saturation after 195 years */
    552560        cc->shift = 0;
    553 
     561#endif
    554562        nsec = 0; /* audio time is elapsed time since trigger */
    555563        timecounter_init(tc, cc, nsec);

  • GPL/trunk/alsa-kernel/include/sound/compress_driver.h

    r695 r717  
    166166
    167167/* compress device register APIs */
    168 int snd_compress_register(struct snd_compr *device);
    169 int snd_compress_deregister(struct snd_compr *device);
    170168int snd_compress_new(struct snd_card *card, int device,
    171169                        int type, const char *id, struct snd_compr *compr);

  • GPL/trunk/alsa-kernel/include/sound/core.h

    r703 r717  
    121121        const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
    122122        bool registered;                /* card_dev is registered? */
     123        bool managed;                   /* managed via devres */
     124        bool releasing;                 /* during card free process */
    123125        int sync_irq;                   /* assigned irq, used for PCM sync */
    124126        wait_queue_head_t remove_sleep;
    … …  
    278280                 struct module *module, int extra_size,
    279281                 struct snd_card **card_ret);
     282int snd_devm_card_new(struct device *parent, int idx, const char *xid,
     283                      struct module *module, size_t extra_size,
     284                      struct snd_card **card_ret);
    280285
    281286int snd_card_disconnect(struct snd_card *card);
    … …  
    283288int snd_card_free(struct snd_card *card);
    284289int snd_card_free_when_closed(struct snd_card *card);
     290int snd_card_free_on_error(struct device *dev, int ret);
    285291void snd_card_set_id(struct snd_card *card, const char *id);
    286292int snd_card_register(struct snd_card *card);
    … …  
    328334void snd_dma_disable(unsigned long dma);
    329335unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
     336int snd_devm_request_dma(struct device *dev, int dma, const char *name);
    330337#endif
    331338

  • GPL/trunk/alsa-kernel/include/sound/emu10k1.h

    r679 r717  
    17021702        struct snd_dma_buffer ptb_pages;        /* page table pages */
    17031703        struct snd_dma_device p16v_dma_dev;
    1704         struct snd_dma_buffer p16v_buffer;
     1704        struct snd_dma_buffer *p16v_buffer;
    17051705
    17061706        struct snd_util_memhdr *memhdr;         /* page allocation list */
    … …  
    17971797                       long max_cache_bytes,
    17981798                       int enable_ir,
    1799                        uint subsystem,
    1800                        struct snd_emu10k1 ** remu);
     1799                       uint subsystem);
    18011800
    18021801int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device);
    … …  
    18041803int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device);
    18051804int snd_p16v_pcm(struct snd_emu10k1 *emu, int device);
    1806 int snd_p16v_free(struct snd_emu10k1 * emu);
    18071805int snd_p16v_mixer(struct snd_emu10k1 * emu);
    18081806int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device);

  • GPL/trunk/alsa-kernel/include/sound/emu8000.h

    r679 r717  
    5757        unsigned long port2;    /* Port usually at base+0x400 */
    5858        unsigned long port3;    /* Port usually at base+0x800 */
    59         struct resource *res_port1;
    60         struct resource *res_port2;
    61         struct resource *res_port3;
    6259        unsigned short last_reg;/* Last register command */
    6360        spinlock_t reg_lock;

  • GPL/trunk/alsa-kernel/include/sound/hda_codec.h

    r695 r717  
    99#define __SOUND_HDA_CODEC_H
    1010
    11 #include <linux/kref.h>
     11#include <linux/refcount.h>
    1212#include <linux/mod_devicetable.h>
    1313#include <sound/info.h>
    … …  
    115115        int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid);
    116116#endif
    117         void (*reboot_notify)(struct hda_codec *codec);
    118117        void (*stream_pm)(struct hda_codec *codec, hda_nid_t nid, bool on);
    119118};
    … …  
    168167        /* private: */
    169168        struct hda_codec *codec;
    170         struct kref kref;
    171169        struct list_head list;
     170        unsigned int disconnected:1;
    172171};
    173172
    … …  
    189188        /* PCM to create, set by patch_ops.build_pcms callback */
    190189        struct list_head pcm_list_head;
     190        refcount_t pcm_ref;
     191        wait_queue_head_t remove_sleep;
    191192
    192193        /* codec specific info */
    … …  
    226227
    227228        /* misc flags */
     229        unsigned int configured:1; /* codec was configured */
    228230        unsigned int in_freeing:1; /* being released */
    229231        unsigned int registered:1; /* codec was registered */
    … …  
    423425static inline void snd_hda_codec_pcm_get(struct hda_pcm *pcm)
    424426{
    425         kref_get(&pcm->kref);
     427        refcount_inc(&pcm->codec->pcm_ref);
    426428}
    427429void snd_hda_codec_pcm_put(struct hda_pcm *pcm);

  • GPL/trunk/alsa-kernel/include/sound/hdaudio_ext.h

    r695 r717  
    5252 * @link_locked: link is locked
    5353 * @link_prepared: link is prepared
    54  * link_substream: link substream
     54 * @link_substream: link substream
    5555 */
    5656struct hdac_ext_stream {
    … …  
    8989                                           int type);
    9090void snd_hdac_ext_stream_release(struct hdac_ext_stream *azx_dev, int type);
     91void snd_hdac_ext_stream_decouple_locked(struct hdac_bus *bus,
     92                                  struct hdac_ext_stream *azx_dev, bool decouple);
    9193void snd_hdac_ext_stream_decouple(struct hdac_bus *bus,
    9294                                struct hdac_ext_stream *azx_dev, bool decouple);

  • GPL/trunk/alsa-kernel/include/sound/jack.h

    r695 r717  
    6363#ifdef CONFIG_SND_JACK_INPUT_DEV
    6464        struct input_dev *input_dev;
     65        struct mutex input_dev_lock;
    6566        int registered;
    6667        int type;

  • GPL/trunk/alsa-kernel/include/sound/memalloc.h

    r703 r717  
    3232#define SNDRV_DMA_TYPE_CONTINUOUS       1       /* continuous no-DMA memory */
    3333#define SNDRV_DMA_TYPE_DEV              2       /* generic device continuous */
    34 #define SNDRV_DMA_TYPE_DEV_UC           5       /* continuous non-cahced */
     34#define SNDRV_DMA_TYPE_DEV_WC           5       /* continuous write-combined */
    3535#ifdef CONFIG_SND_DMA_SGBUF
    3636#define SNDRV_DMA_TYPE_DEV_SG           3       /* generic device SG-buffer */
    37 #define SNDRV_DMA_TYPE_DEV_UC_SG        6       /* SG non-cached */
     37#define SNDRV_DMA_TYPE_DEV_WC_SG        6       /* SG write-combined */
    3838#else
    3939#define SNDRV_DMA_TYPE_DEV_SG   SNDRV_DMA_TYPE_DEV /* no SG-buf support */
    40 #define SNDRV_DMA_TYPE_DEV_UC_SG        SNDRV_DMA_TYPE_DEV_UC
     40#define SNDRV_DMA_TYPE_DEV_WC_SG        SNDRV_DMA_TYPE_DEV_WC
    4141#endif
    4242#ifdef CONFIG_GENERIC_ALLOCATOR
    … …  
    8080                                      unsigned int ofs, unsigned int size);
    8181
     82/* device-managed memory allocator */
     83struct snd_dma_buffer *snd_devm_alloc_pages(struct device *dev, int type,
     84                                            size_t size);
     85#ifdef TARGET_OS2
     86int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab);
     87void *snd_malloc_sgbuf_pages(struct device *device,
     88                             size_t size, struct snd_dma_buffer *dmab,
     89                             size_t *res_size);
     90
     91#endif
    8292#endif /* __SOUND_MEMALLOC_H */
    8393

  • GPL/trunk/alsa-kernel/include/sound/pcm.h

    r703 r717  
    399399        struct fasync_struct *fasync;
    400400        bool stop_operating;            /* sync_stop will be called */
     401        struct mutex buffer_mutex;      /* protect for buffer changes */
     402        atomic_t buffer_accessing;      /* >0: in r/w operation, <0: blocked */
    401403
    402404        /* -- private section -- */
    … …  
    12251227int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
    12261228
    1227 void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
    1228                                 struct device *data, size_t size, size_t max);
    1229 void snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
    1230                                     struct device *data,
    1231                                     size_t size, size_t max);
     1229int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
     1230                               struct device *data, size_t size, size_t max);
     1231int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
     1232                                   struct device *data,
     1233                                   size_t size, size_t max);
     1234
     1235/**
     1236 * snd_pcm_set_fixed_buffer - Preallocate and set up the fixed size PCM buffer
     1237 * @substream: the pcm substream instance
     1238 * @type: DMA type (SNDRV_DMA_TYPE_*)
     1239 * @data: DMA type dependent data
     1240 * @size: the requested pre-allocation size in bytes
     1241 *
     1242 * This is a variant of snd_pcm_set_managed_buffer(), but this pre-allocates
     1243 * only the given sized buffer and doesn't allow re-allocation nor dynamic
     1244 * allocation of a larger buffer unlike the standard one.
     1245 * The function may return -ENOMEM error, hence the caller must check it.
     1246 */
     1247static inline int __must_check
     1248snd_pcm_set_fixed_buffer(struct snd_pcm_substream *substream, int type,
     1249                                 struct device *data, size_t size)
     1250{
     1251        return snd_pcm_set_managed_buffer(substream, type, data, size, 0);
     1252}
     1253
     1254/**
     1255 * snd_pcm_set_fixed_buffer_all - Preallocate and set up the fixed size PCM buffer
     1256 * @pcm: the pcm instance
     1257 * @type: DMA type (SNDRV_DMA_TYPE_*)
     1258 * @data: DMA type dependent data
     1259 * @size: the requested pre-allocation size in bytes
     1260 *
     1261 * Apply the set up of the fixed buffer via snd_pcm_set_fixed_buffer() for
     1262 * all substream.  If any of allocation fails, it returns -ENOMEM, hence the
     1263 * caller must check the return value.
     1264 */
     1265static inline int __must_check
     1266snd_pcm_set_fixed_buffer_all(struct snd_pcm *pcm, int type,
     1267                             struct device *data, size_t size)
     1268{
     1269        return snd_pcm_set_managed_buffer_all(pcm, type, data, size, 0);
     1270}
    12321271
    12331272int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,

  • GPL/trunk/alsa-kernel/include/sound/pxa2xx-lib.h

    r679 r717  
    1515extern int pxa2xx_pcm_hw_params(struct snd_pcm_substream *substream,
    1616                                struct snd_pcm_hw_params *params);
    17 extern int pxa2xx_pcm_hw_free(struct snd_pcm_substream *substream);
    1817extern int pxa2xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd);
    1918extern snd_pcm_uframes_t pxa2xx_pcm_pointer(struct snd_pcm_substream *substream);
    … …  
    2120extern int pxa2xx_pcm_open(struct snd_pcm_substream *substream);
    2221extern int pxa2xx_pcm_close(struct snd_pcm_substream *substream);
    23 extern int pxa2xx_pcm_mmap(struct snd_pcm_substream *substream,
    24         struct vm_area_struct *vma);
    25 extern int pxa2xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream);
    26 extern void pxa2xx_pcm_free_dma_buffers(struct snd_pcm *pcm);
    27 extern void pxa2xx_soc_pcm_free(struct snd_soc_component *component,
    28                                 struct snd_pcm *pcm);
     22extern int pxa2xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm);
    2923extern int pxa2xx_soc_pcm_new(struct snd_soc_component *component,
    3024                              struct snd_soc_pcm_runtime *rtd);
    … …  
    3630                                    struct snd_pcm_substream *substream,
    3731                                    struct snd_pcm_hw_params *params);
    38 extern int pxa2xx_soc_pcm_hw_free(struct snd_soc_component *component,
    39                                   struct snd_pcm_substream *substream);
    4032extern int pxa2xx_soc_pcm_prepare(struct snd_soc_component *component,
    4133                                  struct snd_pcm_substream *substream);
    … …  
    4537pxa2xx_soc_pcm_pointer(struct snd_soc_component *component,
    4638                       struct snd_pcm_substream *substream);
    47 extern int pxa2xx_soc_pcm_mmap(struct snd_soc_component *component,
    48                                struct snd_pcm_substream *substream,
    49                                struct vm_area_struct *vma);
    5039
    5140/* AC97 */

  • GPL/trunk/alsa-kernel/include/sound/rawmidi.h

    r703 r717  
    9999        struct snd_rawmidi_substream *input;
    100100        struct snd_rawmidi_substream *output;
     101        unsigned int user_pversion;     /* supported protocol version */
    101102};
    102103

  • GPL/trunk/alsa-kernel/include/sound/soc-topology.h

    r703 r717  
    189189#else
    190190
    191 static inline int snd_soc_tplg_component_remove(struct snd_soc_component *comp,
    192                                                 u32 index)
     191static inline int snd_soc_tplg_component_remove(struct snd_soc_component *comp)
    193192{
    194193        return 0;

  • GPL/trunk/alsa-kernel/include/sound/sof.h

    r695 r717  
    102102
    103103int sof_dai_get_mclk(struct snd_soc_pcm_runtime *rtd);
     104int sof_dai_get_bclk(struct snd_soc_pcm_runtime *rtd);
    104105
    105106#endif

  • GPL/trunk/alsa-kernel/include/sound/version.h

    r703 r717  
    11/* include/version.h */
    2 #define CONFIG_SND_VERSION "5.14.7"
     2#define CONFIG_SND_VERSION "5.15.59"
    33#define CONFIG_SND_DATE ""

  • GPL/trunk/alsa-kernel/include/uapi/sound/asound.h

    r703 r717  
    8181 ****************************************************************************/
    8282
     83#define AES_IEC958_STATUS_SIZE          24
     84
    8385struct snd_aes_iec958 {
    84         unsigned char status[24];       /* AES/IEC958 channel status bits */
     86        unsigned char status[AES_IEC958_STATUS_SIZE]; /* AES/IEC958 channel status bits */
    8587        unsigned char subcode[147];     /* AES/IEC958 subcode bits */
    8688        unsigned char pad;              /* nothing */
    … …  
    324326#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME    0x04000000  /* report estimated link audio time */
    325327#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000  /* report synchronized audio/system time */
     328#define SNDRV_PCM_INFO_EXPLICIT_SYNC    0x10000000      /* needs explicit sync of pointers and data */
    326329
    327330#define SNDRV_PCM_INFO_DRAIN_TRIGGER    0x40000000              /* internal kernel flag - trigger in drain */
    … …  
    825828#define SNDRV_RAWMIDI_IOCTL_PVERSION    _IOR('W', 0x00, int)
    826829#define SNDRV_RAWMIDI_IOCTL_INFO        _IOR('W', 0x01, struct snd_rawmidi_info)
     830#define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int)
    827831#define SNDRV_RAWMIDI_IOCTL_PARAMS      _IOWR('W', 0x10, struct snd_rawmidi_params)
    828832#define SNDRV_RAWMIDI_IOCTL_STATUS      _IOWR('W', 0x20, struct snd_rawmidi_status)

  • GPL/trunk/alsa-kernel/isa/sb/sb_common.c

    r703 r717  
    169169}
    170170
    171 static int snd_sbdsp_free(struct snd_sb *chip)
    172 {
    173         release_and_free_resource(chip->res_port);
    174         if (chip->irq >= 0)
    175                 free_irq(chip->irq, (void *) chip);
    176 #ifdef CONFIG_ISA
    177         if (chip->dma8 >= 0) {
    178                 disable_dma(chip->dma8);
    179                 free_dma(chip->dma8);
    180         }
    181         if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
    182                 disable_dma(chip->dma16);
    183                 free_dma(chip->dma16);
    184         }
    185 #endif
    186         kfree(chip);
    187         return 0;
    188 }
    189 
    190 static int snd_sbdsp_dev_free(struct snd_device *device)
    191 {
    192         struct snd_sb *chip = device->device_data;
    193         return snd_sbdsp_free(chip);
    194 }
    195 
    196171int snd_sbdsp_create(struct snd_card *card,
    197172                     unsigned long port,
    … …  
    205180        struct snd_sb *chip;
    206181        int err;
    207         static const struct snd_device_ops ops = {
    208                 .dev_free =     snd_sbdsp_dev_free,
    209         };
    210182
    211183        if (snd_BUG_ON(!r_chip))
    212184                return -EINVAL;
    213185        *r_chip = NULL;
    214         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    215         if (chip == NULL)
     186        chip = devm_kzalloc(card->dev, sizeof(*chip), GFP_KERNEL);
     187        if (!chip)
    216188                return -ENOMEM;
    217189        spin_lock_init(&chip->reg_lock);
    … …  
    224196        chip->port = port;
    225197       
    226         if (request_irq(irq, irq_handler,
    227                         (hardware == SB_HW_ALS4000 ||
    228                          hardware == SB_HW_CS5530) ?
    229                         IRQF_SHARED : 0,
    230                         "SoundBlaster", (void *) chip)) {
     198        if (devm_request_irq(card->dev, irq, irq_handler,
     199                             (hardware == SB_HW_ALS4000 ||
     200                              hardware == SB_HW_CS5530) ?
     201                             IRQF_SHARED : 0,
     202                             "SoundBlaster", (void *) chip)) {
    231203                snd_printk(KERN_ERR "sb: can't grab irq %d\n", irq);
    232                 snd_sbdsp_free(chip);
    233204                return -EBUSY;
    234205        }
    … …  
    239210                goto __skip_allocation;
    240211       
    241         chip->res_port = request_region(port, 16, "SoundBlaster");
     212        chip->res_port = devm_request_region(card->dev, port, 16,
     213                                             "SoundBlaster");
    242214        if (!chip->res_port) {
    243215                snd_printk(KERN_ERR "sb: can't grab port 0x%lx\n", port);
    244                 snd_sbdsp_free(chip);
    245216                return -EBUSY;
    246217        }
    247218
    248219#ifdef CONFIG_ISA
    249         if (dma8 >= 0 && request_dma(dma8, "SoundBlaster - 8bit")) {
     220        if (dma8 >= 0 && snd_devm_request_dma(card->dev, dma8,
     221                                              "SoundBlaster - 8bit")) {
    250222                snd_printk(KERN_ERR "sb: can't grab DMA8 %d\n", dma8);
    251                 snd_sbdsp_free(chip);
    252223                return -EBUSY;
    253224        }
    … …  
    257228                        /* no duplex */
    258229                        dma16 = -1;
    259                 } else if (request_dma(dma16, "SoundBlaster - 16bit")) {
     230                } else if (snd_devm_request_dma(card->dev, dma16,
     231                                                "SoundBlaster - 16bit")) {
    260232                        snd_printk(KERN_ERR "sb: can't grab DMA16 %d\n", dma16);
    261                         snd_sbdsp_free(chip);
    262233                        return -EBUSY;
    263234                }
    … …  
    270241        chip->hardware = hardware;
    271242        err = snd_sbdsp_probe(chip);
    272         if (err < 0) {
    273                 snd_sbdsp_free(chip);
     243        if (err < 0)
    274244                return err;
    275         }
    276         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    277         if (err < 0) {
    278                 snd_sbdsp_free(chip);
    279                 return err;
    280         }
    281245        *r_chip = chip;
    282246        return 0;

  • GPL/trunk/alsa-kernel/pci/ac97/ac97_codec.c

    r703 r717  
    947947       
    948948        mutex_lock(&ac97->page_mutex);
    949         ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
    950         ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
     949        ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
     950        ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
    951951        mutex_unlock(&ac97->page_mutex);
    952952        return 0;

  • GPL/trunk/alsa-kernel/pci/ali5451/ali5451.c

    r695 r717  
    19181918#endif /* CONFIG_PM_SLEEP */
    19191919
    1920 static int snd_ali_free(struct snd_ali * codec)
    1921 {
     1920static void snd_ali_free(struct snd_card *card)
     1921{
     1922        struct snd_ali *codec = card->private_data;
     1923
    19221924        if (codec->hw_initialized)
    19231925                snd_ali_disable_address_interrupt(codec);
    1924         if (codec->irq >= 0)
    1925                 free_irq(codec->irq, codec);
    1926         if (codec->port)
    1927                 pci_release_regions(codec->pci);
    1928         pci_disable_device(codec->pci);
    1929 #ifdef CONFIG_PM_SLEEP
    1930         kfree(codec->image);
    1931 #endif
    19321926        pci_dev_put(codec->pci_m1533);
    19331927        pci_dev_put(codec->pci_m7101);
    1934         kfree(codec);
    1935         return 0;
    19361928}
    19371929
    … …  
    20212013        codec->port = pci_resource_start(codec->pci, 0);
    20222014
    2023         if (request_irq(codec->pci->irq, snd_ali_card_interrupt,
    2024                         IRQF_SHARED, KBUILD_MODNAME, codec)) {
     2015        if (devm_request_irq(&codec->pci->dev, codec->pci->irq,
     2016                             snd_ali_card_interrupt,
     2017                             IRQF_SHARED, KBUILD_MODNAME, codec)) {
    20252018                dev_err(codec->card->dev, "Unable to request irq.\n");
    20262019                return -EBUSY;
    … …  
    20312024        return 0;
    20322025}
    2033 static int snd_ali_dev_free(struct snd_device *device)
    2034 {
    2035         struct snd_ali *codec = device->device_data;
    2036         snd_ali_free(codec);
    2037         return 0;
    2038 }
    20392026
    20402027static int snd_ali_create(struct snd_card *card,
    20412028                          struct pci_dev *pci,
    20422029                          int pcm_streams,
    2043                           int spdif_support,
    2044                           struct snd_ali **r_ali)
    2045 {
    2046         struct snd_ali *codec;
     2030                          int spdif_support)
     2031{
     2032        struct snd_ali *codec = card->private_data;
    20472033        int i, err;
    20482034        unsigned short cmdw;
    2049         static const struct snd_device_ops ops = {
    2050                 .dev_free = snd_ali_dev_free,
    2051         };
    2052 
    2053         *r_ali = NULL;
    20542035
    20552036        dev_dbg(card->dev, "creating ...\n");
    20562037
    20572038        /* enable PCI device */
    2058         err = pci_enable_device(pci);
     2039        err = pcim_enable_device(pci);
    20592040        if (err < 0)
    20602041                return err;
    … …  
    20632044                dev_err(card->dev,
    20642045                        "architecture does not support 31bit PCI busmaster DMA\n");
    2065                 pci_disable_device(pci);
    20662046                return -ENXIO;
    2067         }
    2068 
    2069         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
    2070         if (!codec) {
    2071                 pci_disable_device(pci);
    2072                 return -ENOMEM;
    20732047        }
    20742048
    … …  
    20972071                pci_write_config_word(pci, PCI_COMMAND, cmdw);
    20982072        }
    2099         pci_set_master(pci);
    2100        
    2101         if (snd_ali_resources(codec)) {
    2102                 snd_ali_free(codec);
     2073       
     2074        if (snd_ali_resources(codec))
    21032075                return -EBUSY;
    2104         }
     2076        card->private_free = snd_ali_free;
    21052077
    21062078        codec->synth.chmap = 0;
    … …  
    21292101        if (!codec->pci_m1533) {
    21302102                dev_err(card->dev, "cannot find ALi 1533 chip.\n");
    2131                 snd_ali_free(codec);
    21322103                return -ENODEV;
    21332104        }
    … …  
    21362107        if (!codec->pci_m7101 && codec->revision == ALI_5451_V02) {
    21372108                dev_err(card->dev, "cannot find ALi 7101 chip.\n");
    2138                 snd_ali_free(codec);
    21392109                return -ENODEV;
    2140         }
    2141 
    2142         dev_dbg(card->dev, "snd_device_new is called.\n");
    2143         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, codec, &ops);
    2144         if (err < 0) {
    2145                 snd_ali_free(codec);
    2146                 return err;
    21472110        }
    21482111
    … …  
    21582121
    21592122#ifdef CONFIG_PM_SLEEP
    2160         codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL);
     2123        codec->image = devm_kmalloc(&pci->dev, sizeof(*codec->image),
     2124                                    GFP_KERNEL);
    21612125        if (!codec->image)
    21622126                dev_warn(card->dev, "can't allocate apm buffer\n");
    … …  
    21652129        snd_ali_enable_address_interrupt(codec);
    21662130        codec->hw_initialized = 1;
    2167 
    2168         *r_ali = codec;
    2169         dev_dbg(card->dev, "created.\n");
    21702131        return 0;
    21712132}
    21722133
    2173 static int snd_ali_probe(struct pci_dev *pci,
    2174                          const struct pci_device_id *pci_id)
     2134static int __snd_ali_probe(struct pci_dev *pci,
     2135                           const struct pci_device_id *pci_id)
    21752136{
    21762137        struct snd_card *card;
    … …  
    21802141        dev_dbg(&pci->dev, "probe ...\n");
    21812142
    2182         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     2143        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     2144                                sizeof(*codec), &card);
    21832145        if (err < 0)
    21842146                return err;
    2185 
    2186         err = snd_ali_create(card, pci, pcm_channels, spdif, &codec);
     2147        codec = card->private_data;
     2148
     2149        err = snd_ali_create(card, pci, pcm_channels, spdif);
    21872150        if (err < 0)
    2188                 goto error;
    2189         card->private_data = codec;
     2151                return err;
    21902152
    21912153        dev_dbg(&pci->dev, "mixer building ...\n");
    21922154        err = snd_ali_mixer(codec);
    21932155        if (err < 0)
    2194                 goto error;
     2156                return err;
    21952157       
    21962158        dev_dbg(&pci->dev, "pcm building ...\n");
    21972159        err = snd_ali_build_pcms(codec);
    21982160        if (err < 0)
    2199                 goto error;
     2161                return err;
    22002162
    22012163        snd_ali_proc_init(codec);
    … …  
    22102172        err = snd_card_register(card);
    22112173        if (err < 0)
    2212                 goto error;
     2174                return err;
    22132175
    22142176        pci_set_drvdata(pci, card);
    22152177        return 0;
    2216 
    2217  error:
    2218         snd_card_free(card);
    2219         return err;
    2220 }
    2221 
    2222 static void snd_ali_remove(struct pci_dev *pci)
    2223 {
    2224         snd_card_free(pci_get_drvdata(pci));
     2178}
     2179
     2180static int snd_ali_probe(struct pci_dev *pci,
     2181                         const struct pci_device_id *pci_id)
     2182{
     2183        return snd_card_free_on_error(&pci->dev, __snd_ali_probe(pci, pci_id));
    22252184}
    22262185
    … …  
    22292188        .id_table = snd_ali_ids,
    22302189        .probe = snd_ali_probe,
    2231         .remove = snd_ali_remove,
    22322190        .driver = {
    22332191                .pm = ALI_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/als4000.c

    r703 r717  
    750750        if (joystick_port[dev] == 1) { /* auto-detect */
    751751                for (io_port = 0x200; io_port <= 0x218; io_port += 8) {
    752                         r = request_region(io_port, 8, "ALS4000 gameport");
     752                        r = devm_request_region(&acard->pci->dev, io_port, 8,
     753                                                "ALS4000 gameport");
    753754                        if (r)
    754755                                break;
    … …  
    756757        } else {
    757758                io_port = joystick_port[dev];
    758                 r = request_region(io_port, 8, "ALS4000 gameport");
     759                r = devm_request_region(&acard->pci->dev, io_port, 8,
     760                                        "ALS4000 gameport");
    759761        }
    760762
    … …  
    767769        if (!gp) {
    768770                dev_err(&acard->pci->dev, "cannot allocate memory for gameport\n");
    769                 release_and_free_resource(r);
    770771                return -ENOMEM;
    771772        }
    … …  
    775776        gameport_set_dev_parent(gp, &acard->pci->dev);
    776777        gp->io = io_port;
    777         gameport_set_port_data(gp, r);
    778778
    779779        /* Enable legacy joystick port */
    … …  
    788788{
    789789        if (acard->gameport) {
    790                 struct resource *r = gameport_get_port_data(acard->gameport);
    791 
    792790                gameport_unregister_port(acard->gameport);
    793791                acard->gameport = NULL;
    … …  
    795793                /* disable joystick */
    796794                snd_als4000_set_addr(acard->iobase, 0, 0, 0, 0);
    797 
    798                 release_and_free_resource(r);
    799795        }
    800796}
    … …  
    812808        /* free resources */
    813809        snd_als4000_free_gameport(acard);
    814         pci_release_regions(acard->pci);
    815         pci_disable_device(acard->pci);
    816 }
    817 
    818 static int snd_card_als4000_probe(struct pci_dev *pci,
    819                                   const struct pci_device_id *pci_id)
     810}
     811
     812static int __snd_card_als4000_probe(struct pci_dev *pci,
     813                                    const struct pci_device_id *pci_id)
    820814{
    821815        static int dev;
    … …  
    836830
    837831        /* enable PCI device */
    838         err = pci_enable_device(pci);
     832        err = pcim_enable_device(pci);
    839833        if (err < 0)
    840834                return err;
    … …  
    843837        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(24))) {
    844838                dev_err(&pci->dev, "architecture does not support 24bit PCI busmaster DMA\n");
    845                 pci_disable_device(pci);
    846839                return -ENXIO;
    847840        }
    848841
    849842        err = pci_request_regions(pci, "ALS4000");
    850         if (err < 0) {
    851                 pci_disable_device(pci);
     843        if (err < 0)
    852844                return err;
    853         }
    854845        iobase = pci_resource_start(pci, 0);
    855846
    … …  
    858849        pci_set_master(pci);
    859850       
    860         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    861                            sizeof(*acard) /* private_data: acard */,
    862                            &card);
    863         if (err < 0) {
    864                 pci_release_regions(pci);
    865                 pci_disable_device(pci);
     851        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     852                                sizeof(*acard) /* private_data: acard */,
     853                                &card);
     854        if (err < 0)
    866855                return err;
    867         }
    868856
    869857        acard = card->private_data;
    … …  
    885873                               &chip);
    886874        if (err < 0)
    887                 goto out_err;
     875                return err;
    888876        acard->chip = chip;
    889877
    … …  
    906894                dev_err(&pci->dev, "no MPU-401 device at 0x%lx?\n",
    907895                                iobase + ALS4K_IOB_30_MIDI_DATA);
    908                 goto out_err;
     896                return err;
    909897        }
    910898        /* FIXME: ALS4000 has interesting MPU401 configuration features
    … …  
    916904        err = snd_als4000_pcm(chip, 0);
    917905        if (err < 0)
    918                 goto out_err;
     906                return err;
    919907
    920908        err = snd_sbmixer_new(chip);
    921909        if (err < 0)
    922                 goto out_err;
     910                return err;
    923911
    924912        if (snd_opl3_create(card,
    … …  
    932920                err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    933921                if (err < 0)
    934                         goto out_err;
     922                        return err;
    935923        }
    936924
    … …  
    939927        err = snd_card_register(card);
    940928        if (err < 0)
    941                 goto out_err;
     929                return err;
    942930
    943931        pci_set_drvdata(pci, card);
    944932        dev++;
    945         err = 0;
    946         goto out;
    947 
    948 out_err:
    949         snd_card_free(card);
    950        
    951 out:
    952         return err;
    953 }
    954 
    955 static void snd_card_als4000_remove(struct pci_dev *pci)
    956 {
    957         snd_card_free(pci_get_drvdata(pci));
     933        return 0;
     934}
     935
     936static int snd_card_als4000_probe(struct pci_dev *pci,
     937                                  const struct pci_device_id *pci_id)
     938{
     939        return snd_card_free_on_error(&pci->dev, __snd_card_als4000_probe(pci, pci_id));
    958940}
    959941
    … …  
    1000982        .id_table = snd_als4000_ids,
    1001983        .probe = snd_card_als4000_probe,
    1002         .remove = snd_card_als4000_remove,
    1003984        .driver = {
    1004985                .pm = SND_ALS4000_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/atiixp.c

    r703 r717  
    15411541 */
    15421542
    1543 static int snd_atiixp_free(struct atiixp *chip)
    1544 {
    1545         if (chip->irq < 0)
    1546                 goto __hw_end;
    1547         snd_atiixp_chip_stop(chip);
    1548 
    1549       __hw_end:
    1550         if (chip->irq >= 0)
    1551                 free_irq(chip->irq, chip);
    1552         iounmap(chip->remap_addr);
    1553         pci_release_regions(chip->pci);
    1554         pci_disable_device(chip->pci);
    1555         kfree(chip);
    1556         return 0;
    1557 }
    1558 
    1559 static int snd_atiixp_dev_free(struct snd_device *device)
    1560 {
    1561         struct atiixp *chip = device->device_data;
    1562         return snd_atiixp_free(chip);
     1543static void snd_atiixp_free(struct snd_card *card)
     1544{
     1545        snd_atiixp_chip_stop(card->private_data);
    15631546}
    15641547
    … …  
    15661549 * constructor for chip instance
    15671550 */
    1568 static int snd_atiixp_create(struct snd_card *card,
    1569                              struct pci_dev *pci,
    1570                              struct atiixp **r_chip)
    1571 {
    1572         static const struct snd_device_ops ops = {
    1573                 .dev_free =     snd_atiixp_dev_free,
    1574         };
    1575         struct atiixp *chip;
     1551static int snd_atiixp_init(struct snd_card *card, struct pci_dev *pci)
     1552{
     1553        struct atiixp *chip = card->private_data;
    15761554        int err;
    15771555
    1578         err = pci_enable_device(pci);
     1556        err = pcim_enable_device(pci);
    15791557        if (err < 0)
    15801558                return err;
    1581 
    1582         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1583         if (chip == NULL) {
    1584                 pci_disable_device(pci);
    1585                 return -ENOMEM;
    1586         }
    15871559
    15881560        spin_lock_init(&chip->reg_lock);
    … …  
    15911563        chip->pci = pci;
    15921564        chip->irq = -1;
     1565#ifndef TARGET_OS2
     1566        err = pcim_iomap_regions(pci, 1 << 0, "ATI IXP AC97");
     1567        if (err < 0)
     1568                return err;
     1569#else
    15931570        err = pci_request_regions(pci, "ATI IXP AC97");
    15941571        if (err < 0) {
    … …  
    15971574                return err;
    15981575        }
     1576#endif
    15991577        chip->addr = pci_resource_start(pci, 0);
     1578#ifndef TARGET_OS2
     1579        chip->remap_addr = pcim_iomap_table(pci)[0];
     1580#else
    16001581        chip->remap_addr = pci_ioremap_bar(pci, 0);
    1601         if (chip->remap_addr == NULL) {
    1602                 dev_err(card->dev, "AC'97 space ioremap problem\n");
    1603                 snd_atiixp_free(chip);
    1604                 return -EIO;
    1605         }
    1606 
    1607         if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
    1608                         KBUILD_MODNAME, chip)) {
     1582#endif
     1583        if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt,
     1584                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    16091585                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    1610                 snd_atiixp_free(chip);
    16111586                return -EBUSY;
    16121587        }
    16131588        chip->irq = pci->irq;
    16141589        card->sync_irq = chip->irq;
     1590        card->private_free = snd_atiixp_free;
    16151591        pci_set_master(pci);
    16161592
    1617         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1618         if (err < 0) {
    1619                 snd_atiixp_free(chip);
    1620                 return err;
    1621         }
    1622 
    1623         *r_chip = chip;
    1624         return 0;
    1625 }
    1626 
    1627 
    1628 static int snd_atiixp_probe(struct pci_dev *pci,
    1629                             const struct pci_device_id *pci_id)
     1593        return 0;
     1594}
     1595
     1596
     1597static int __snd_atiixp_probe(struct pci_dev *pci,
     1598                              const struct pci_device_id *pci_id)
    16301599{
    16311600        struct snd_card *card;
    … …  
    16331602        int err;
    16341603
    1635         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     1604        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     1605                                sizeof(*chip), &card);
    16361606        if (err < 0)
    16371607                return err;
     1608        chip = card->private_data;
    16381609
    16391610        strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA");
    16401611        strcpy(card->shortname, "ATI IXP");
    1641         err = snd_atiixp_create(card, pci, &chip);
     1612        err = snd_atiixp_init(card, pci);
    16421613        if (err < 0)
    1643                 goto __error;
    1644         card->private_data = chip;
     1614                return err;
    16451615
    16461616        err = snd_atiixp_aclink_reset(chip);
    16471617        if (err < 0)
    1648                 goto __error;
     1618                return err;
    16491619
    16501620        chip->spdif_over_aclink = spdif_aclink;
    … …  
    16521622        err = snd_atiixp_mixer_new(chip, ac97_clock, ac97_quirk);
    16531623        if (err < 0)
    1654                 goto __error;
     1624                return err;
    16551625
    16561626        err = snd_atiixp_pcm_new(chip);
    16571627        if (err < 0)
    1658                 goto __error;
     1628                return err;
    16591629       
    16601630        snd_atiixp_proc_init(chip);
    … …  
    16741644        err = snd_card_register(card);
    16751645        if (err < 0)
    1676                 goto __error;
     1646                return err;
    16771647
    16781648        pci_set_drvdata(pci, card);
    16791649        return 0;
    1680 
    1681  __error:
    1682         snd_card_free(card);
    1683         return err;
    1684 }
    1685 
    1686 static void snd_atiixp_remove(struct pci_dev *pci)
    1687 {
    1688         snd_card_free(pci_get_drvdata(pci));
     1650}
     1651
     1652static int snd_atiixp_probe(struct pci_dev *pci,
     1653                            const struct pci_device_id *pci_id)
     1654{
     1655        return snd_card_free_on_error(&pci->dev, __snd_atiixp_probe(pci, pci_id));
    16891656}
    16901657
    … …  
    16931660        .id_table = snd_atiixp_ids,
    16941661        .probe = snd_atiixp_probe,
    1695         .remove = snd_atiixp_remove,
    16961662        .driver = {
    16971663                .pm = SND_ATIIXP_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/au88x0/au88x0.c

    r703 r717  
    124124// component-destructor
    125125// (see "Management of Cards and Components")
    126 static int snd_vortex_dev_free(struct snd_device *device)
    127 {
    128         vortex_t *vortex = device->device_data;
     126static void snd_vortex_free(struct snd_card *card)
     127{
     128        vortex_t *vortex = card->private_data;
    129129
    130130        vortex_gameport_unregister(vortex);
    131131        vortex_core_shutdown(vortex);
    132         // Take down PCI interface.
    133         free_irq(vortex->irq, vortex);
    134         iounmap(vortex->mmio);
    135         pci_release_regions(vortex->pci_dev);
    136         pci_disable_device(vortex->pci_dev);
    137         kfree(vortex);
    138 
    139         return 0;
    140132}
    141133
    … …  
    143135// (see "Management of Cards and Components")
    144136static int
    145 snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip)
    146 {
    147         vortex_t *chip;
     137snd_vortex_create(struct snd_card *card, struct pci_dev *pci)
     138{
     139        vortex_t *chip = card->private_data;
    148140        int err;
    149         static const struct snd_device_ops ops = {
    150                 .dev_free = snd_vortex_dev_free,
    151         };
    152 
    153         *rchip = NULL;
    154141
    155142        // check PCI availability (DMA).
    156         err = pci_enable_device(pci);
     143        err = pcim_enable_device(pci);
    157144        if (err < 0)
    158145                return err;
    159146        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) {
    160147                dev_err(card->dev, "error to set DMA mask\n");
    161                 pci_disable_device(pci);
    162148                return -ENXIO;
    163         }
    164 
    165         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    166         if (chip == NULL) {
    167                 pci_disable_device(pci);
    168                 return -ENOMEM;
    169149        }
    170150
    … …  
    173153        // initialize the stuff
    174154        chip->pci_dev = pci;
    175         chip->io = pci_resource_start(pci, 0);
    176155        chip->vendor = pci->vendor;
    177156        chip->device = pci->device;
    … …  
    182161        // Get MMIO area
    183162        //
    184         err = pci_request_regions(pci, CARD_NAME_SHORT);
     163        err = pcim_iomap_regions(pci, 1 << 0, CARD_NAME_SHORT);
    185164        if (err)
    186                 goto regions_out;
    187 
    188         chip->mmio = pci_ioremap_bar(pci, 0);
    189         if (!chip->mmio) {
    190                 dev_err(card->dev, "MMIO area remap failed.\n");
    191                 err = -ENOMEM;
    192                 goto ioremap_out;
    193         }
     165                return err;
     166
     167        chip->io = pci_resource_start(pci, 0);
     168        chip->mmio = pcim_iomap_table(pci)[0];
    194169
    195170        /* Init audio core.
    … …  
    199174        if (err) {
    200175                dev_err(card->dev, "hw core init failed\n");
    201                 goto core_out;
    202         }
    203 
    204         err = request_irq(pci->irq, vortex_interrupt,
    205                           IRQF_SHARED, KBUILD_MODNAME, chip);
     176                return err;
     177        }
     178
     179        err = devm_request_irq(&pci->dev, pci->irq, vortex_interrupt,
     180                               IRQF_SHARED, KBUILD_MODNAME, chip);
    206181        if (err) {
    207182                dev_err(card->dev, "cannot grab irq\n");
    208                 goto irq_out;
     183                return err;
    209184        }
    210185        chip->irq = pci->irq;
    211186        card->sync_irq = chip->irq;
     187        card->private_free = snd_vortex_free;
    212188
    213189        pci_set_master(pci);
    214190        // End of PCI setup.
    215 
    216         // Register alsa root device.
    217         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    218         if (err < 0)
    219                 goto alloc_out;
    220 
    221         *rchip = chip;
    222 
    223191        return 0;
    224 
    225       alloc_out:
    226         free_irq(chip->irq, chip);
    227       irq_out:
    228         vortex_core_shutdown(chip);
    229       core_out:
    230         iounmap(chip->mmio);
    231       ioremap_out:
    232         pci_release_regions(chip->pci_dev);
    233       regions_out:
    234         pci_disable_device(chip->pci_dev);
    235         //FIXME: this not the right place to unregister the gameport
    236         vortex_gameport_unregister(chip);
    237         kfree(chip);
    238         return err;
    239192}
    240193
    241194// constructor -- see "Constructor" sub-section
    242195static int
    243 snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     196__snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
    244197{
    245198        static int dev;
    … …  
    256209        }
    257210        // (2)
    258         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    259                            0, &card);
    260         if (err < 0)
    261                 return err;
     211        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     212                                sizeof(*chip), &card);
     213        if (err < 0)
     214                return err;
     215        chip = card->private_data;
    262216
    263217        // (3)
    264         err = snd_vortex_create(card, pci, &chip);
    265         if (err < 0) {
    266                 snd_card_free(card);
    267                 return err;
    268         }
     218        err = snd_vortex_create(card, pci);
     219        if (err < 0)
     220                return err;
    269221        snd_vortex_workaround(pci, pcifix[dev]);
    270222
    … …  
    277229        // (4) Alloc components.
    278230        err = snd_vortex_mixer(chip);
    279         if (err < 0) {
    280                 snd_card_free(card);
    281                 return err;
    282         }
     231        if (err < 0)
     232                return err;
    283233        // ADB pcm.
    284234        err = snd_vortex_new_pcm(chip, VORTEX_PCM_ADB, NR_PCM);
    285         if (err < 0) {
    286                 snd_card_free(card);
    287                 return err;
    288         }
     235        if (err < 0)
     236                return err;
    289237#ifndef CHIP_AU8820
    290238        // ADB SPDIF
    291239        err = snd_vortex_new_pcm(chip, VORTEX_PCM_SPDIF, 1);
    292         if (err < 0) {
    293                 snd_card_free(card);
    294                 return err;
    295         }
     240        if (err < 0)
     241                return err;
    296242        // A3D
    297243        err = snd_vortex_new_pcm(chip, VORTEX_PCM_A3D, NR_A3D);
    298         if (err < 0) {
    299                 snd_card_free(card);
    300                 return err;
    301         }
     244        if (err < 0)
     245                return err;
    302246#endif
    303247        /*
    304248           // ADB I2S
    305249           if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_I2S, 1)) < 0) {
    306            snd_card_free(card);
    307250           return err;
    308251           }
    … …  
    311254        // WT pcm.
    312255        err = snd_vortex_new_pcm(chip, VORTEX_PCM_WT, NR_WT);
    313         if (err < 0) {
    314                 snd_card_free(card);
    315                 return err;
    316         }
     256        if (err < 0)
     257                return err;
    317258#endif
    318259        err = snd_vortex_midi(chip);
    319         if (err < 0) {
    320                 snd_card_free(card);
    321                 return err;
    322         }
     260        if (err < 0)
     261                return err;
    323262
    324263        vortex_gameport_register(chip);
    … …  
    343282        // (5)
    344283        err = pci_read_config_word(pci, PCI_DEVICE_ID, &chip->device);
    345         if (err < 0) {
    346                 snd_card_free(card);
    347                 return err;
    348         }       
     284        if (err < 0)
     285                return err;
    349286        err = pci_read_config_word(pci, PCI_VENDOR_ID, &chip->vendor);
    350         if (err < 0) {
    351                 snd_card_free(card);
    352                 return err;
    353         }
     287        if (err < 0)
     288                return err;
    354289        chip->rev = pci->revision;
    355290#ifdef CHIP_AU8830
    … …  
    360295                dev_alert(card->dev,
    361296                          "Please email the results of 'lspci -vv' to openvortex-dev@nongnu.org.\n");
    362                 snd_card_free(card);
    363                 err = -ENODEV;
    364                 return err;
     297                return -ENODEV;
    365298        }
    366299#endif
    … …  
    368301        // (6)
    369302        err = snd_card_register(card);
    370         if (err < 0) {
    371                 snd_card_free(card);
    372                 return err;
    373         }
     303        if (err < 0)
     304                return err;
    374305        // (7)
    375306        pci_set_drvdata(pci, card);
    … …  
    380311}
    381312
    382 // destructor -- see "Destructor" sub-section
    383 static void snd_vortex_remove(struct pci_dev *pci)
    384 {
    385         snd_card_free(pci_get_drvdata(pci));
     313static int
     314snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     315{
     316        return snd_card_free_on_error(&pci->dev, __snd_vortex_probe(pci, pci_id));
    386317}
    387318
    … …  
    391322        .id_table = snd_vortex_ids,
    392323        .probe = snd_vortex_probe,
    393         .remove = snd_vortex_remove,
    394324};
    395325

  • GPL/trunk/alsa-kernel/pci/bt87x.c

    r703 r717  
    666666};
    667667
    668 static int snd_bt87x_free(struct snd_bt87x *chip)
    669 {
    670         if (chip->mmio)
    671                 snd_bt87x_stop(chip);
    672         if (chip->irq >= 0)
    673                 free_irq(chip->irq, chip);
    674         iounmap(chip->mmio);
    675         pci_release_regions(chip->pci);
    676         pci_disable_device(chip->pci);
    677         kfree(chip);
    678         return 0;
    679 }
    680 
    681 static int snd_bt87x_dev_free(struct snd_device *device)
    682 {
    683         struct snd_bt87x *chip = device->device_data;
    684         return snd_bt87x_free(chip);
     668static void snd_bt87x_free(struct snd_card *card)
     669{
     670        struct snd_bt87x *chip = card->private_data;
     671
     672        snd_bt87x_stop(chip);
    685673}
    686674
    … …  
    704692
    705693static int snd_bt87x_create(struct snd_card *card,
    706                             struct pci_dev *pci,
    707                             struct snd_bt87x **rchip)
    708 {
    709         struct snd_bt87x *chip;
     694                            struct pci_dev *pci)
     695{
     696        struct snd_bt87x *chip = card->private_data;
    710697        int err;
    711         static const struct snd_device_ops ops = {
    712                 .dev_free = snd_bt87x_dev_free
    713         };
    714 
    715         *rchip = NULL;
    716 
    717         err = pci_enable_device(pci);
     698
     699        err = pcim_enable_device(pci);
    718700        if (err < 0)
    719701                return err;
    720702
    721         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    722         if (!chip) {
    723                 pci_disable_device(pci);
    724                 return -ENOMEM;
    725         }
    726703        chip->card = card;
    727704        chip->pci = pci;
    … …  
    729706        spin_lock_init(&chip->reg_lock);
    730707
     708#ifndef TARGET_OS2
     709        err = pcim_iomap_regions(pci, 1 << 0, "Bt87x audio");
     710        if (err < 0)
     711                return err;
     712        chip->mmio = pcim_iomap_table(pci)[0];
     713#else
    731714        err = pci_request_regions(pci, "Bt87x audio");
    732715        if (err < 0) {
    … …  
    736719        }
    737720        chip->mmio = pci_ioremap_bar(pci, 0);
    738         if (!chip->mmio) {
    739                 dev_err(card->dev, "cannot remap io memory\n");
    740                 err = -ENOMEM;
    741                 goto fail;
    742         }
    743 
     721#endif
    744722        chip->reg_control = CTL_A_PWRDN | CTL_DA_ES2 |
    745723                            CTL_PKTP_16 | (15 << CTL_DA_SDR_SHIFT);
    … …  
    749727        snd_bt87x_writel(chip, REG_INT_STAT, MY_INTERRUPTS);
    750728
    751         err = request_irq(pci->irq, snd_bt87x_interrupt, IRQF_SHARED,
    752                           KBUILD_MODNAME, chip);
     729        err = devm_request_irq(&pci->dev, pci->irq, snd_bt87x_interrupt,
     730                               IRQF_SHARED, KBUILD_MODNAME, chip);
    753731        if (err < 0) {
    754732                dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
    755                 goto fail;
     733                return err;
    756734        }
    757735        chip->irq = pci->irq;
    758736        card->sync_irq = chip->irq;
     737        card->private_free = snd_bt87x_free;
    759738        pci_set_master(pci);
    760739
    761         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    762         if (err < 0)
    763                 goto fail;
    764 
    765         *rchip = chip;
    766         return 0;
    767 
    768 fail:
    769         snd_bt87x_free(chip);
    770         return err;
     740        return 0;
    771741}
    772742
    … …  
    854824}
    855825
    856 static int snd_bt87x_probe(struct pci_dev *pci,
    857                            const struct pci_device_id *pci_id)
     826static int __snd_bt87x_probe(struct pci_dev *pci,
     827                             const struct pci_device_id *pci_id)
    858828{
    859829        static int dev;
    … …  
    878848        }
    879849
    880         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    881                            0, &card);
     850        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     851                                sizeof(*chip), &card);
    882852        if (err < 0)
    883853                return err;
    884 
    885         err = snd_bt87x_create(card, pci, &chip);
     854        chip = card->private_data;
     855
     856        err = snd_bt87x_create(card, pci);
    886857        if (err < 0)
    887                 goto _error;
     858                return err;
    888859
    889860        memcpy(&chip->board, &snd_bt87x_boards[boardid], sizeof(chip->board));
    … …  
    897868                err = snd_bt87x_pcm(chip, DEVICE_DIGITAL, "Bt87x Digital");
    898869                if (err < 0)
    899                         goto _error;
     870                        return err;
    900871        }
    901872        if (!chip->board.no_analog) {
    902873                err = snd_bt87x_pcm(chip, DEVICE_ANALOG, "Bt87x Analog");
    903874                if (err < 0)
    904                         goto _error;
     875                        return err;
    905876                err = snd_ctl_add(card, snd_ctl_new1(
    906877                                  &snd_bt87x_capture_volume, chip));
    907878                if (err < 0)
    908                         goto _error;
     879                        return err;
    909880                err = snd_ctl_add(card, snd_ctl_new1(
    910881                                  &snd_bt87x_capture_boost, chip));
    911882                if (err < 0)
    912                         goto _error;
     883                        return err;
    913884                err = snd_ctl_add(card, snd_ctl_new1(
    914885                                  &snd_bt87x_capture_source, chip));
    915886                if (err < 0)
    916                         goto _error;
     887                        return err;
    917888        }
    918889        dev_info(card->dev, "bt87x%d: Using board %d, %sanalog, %sdigital "
    … …  
    930901        err = snd_card_register(card);
    931902        if (err < 0)
    932                 goto _error;
     903                return err;
    933904
    934905        pci_set_drvdata(pci, card);
    935906        ++dev;
    936907        return 0;
    937 
    938 _error:
    939         snd_card_free(card);
    940         return err;
    941 }
    942 
    943 static void snd_bt87x_remove(struct pci_dev *pci)
    944 {
    945         snd_card_free(pci_get_drvdata(pci));
     908}
     909
     910static int snd_bt87x_probe(struct pci_dev *pci,
     911                           const struct pci_device_id *pci_id)
     912{
     913        return snd_card_free_on_error(&pci->dev, __snd_bt87x_probe(pci, pci_id));
    946914}
    947915
    … …  
    958926        .id_table = snd_bt87x_ids,
    959927        .probe = snd_bt87x_probe,
    960         .remove = snd_bt87x_remove,
    961928};
    962929

  • GPL/trunk/alsa-kernel/pci/ca0106/ca0106.h

    r679 r717  
    668668
    669669        unsigned long port;
    670         struct resource *res_port;
    671670        int irq;
    672671
    … …  
    689688        int capture_mic_line_in;
    690689
    691         struct snd_dma_buffer buffer;
     690        struct snd_dma_buffer *buffer;
    692691
    693692        struct snd_ca_midi midi;

  • GPL/trunk/alsa-kernel/pci/ca0106/ca0106_main.c

    r703 r717  
    723723        struct snd_ca0106_pcm *epcm = runtime->private_data;
    724724        int channel = epcm->channel_id;
    725         u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel));
     725        u32 *table_base = (u32 *)(emu->buffer->area+(8*16*channel));
    726726        u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    727727        u32 hcfg_mask = HCFG_PLAYBACK_S32_LE;
    … …  
    751751        dev_dbg(emu->card->dev,
    752752                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    753                    emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
     753                   emu->buffer->addr, emu->buffer->area, emu->buffer->bytes);
    754754#endif /* debug */
    755755        /* Rate can be set per channel. */
    … …  
    801801        snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
    802802
    803         /* FIXME: Check emu->buffer.size before actually writing to it. */
     803        /* FIXME: Check emu->buffer->size before actually writing to it. */
    804804        for(i=0; i < runtime->periods; i++) {
    805805                table_base[i*2] = runtime->dma_addr + (i * period_size_bytes);
    … …  
    807807        }
    808808 
    809         snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel));
     809        snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer->addr+(8*16*channel));
    810810        snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
    811811        snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0);
    … …  
    858858        dev_dbg(emu->card->dev,
    859859                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    860                    emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
     860                   emu->buffer->addr, emu->buffer->area, emu->buffer->bytes);
    861861#endif /* debug */
    862862        /* reg71 controls ADC rate. */
    … …  
    11881188static void ca0106_stop_chip(struct snd_ca0106 *chip);
    11891189
    1190 static int snd_ca0106_free(struct snd_ca0106 *chip)
    1191 {
    1192         if (chip->res_port != NULL) {
    1193                 /* avoid access to already used hardware */
    1194                 ca0106_stop_chip(chip);
    1195         }
    1196         if (chip->irq >= 0)
    1197                 free_irq(chip->irq, chip);
    1198         // release the data
    1199 #if 1
    1200         if (chip->buffer.area)
    1201                 snd_dma_free_pages(&chip->buffer);
    1202 #endif
    1203 
    1204         // release the i/o port
    1205         release_and_free_resource(chip->res_port);
    1206 
    1207         pci_disable_device(chip->pci);
    1208         kfree(chip);
    1209         return 0;
    1210 }
    1211 
    1212 static int snd_ca0106_dev_free(struct snd_device *device)
    1213 {
    1214         struct snd_ca0106 *chip = device->device_data;
    1215         return snd_ca0106_free(chip);
     1190static void snd_ca0106_free(struct snd_card *card)
     1191{
     1192        struct snd_ca0106 *chip = card->private_data;
     1193
     1194        ca0106_stop_chip(chip);
    12161195}
    12171196
    … …  
    15991578
    16001579static int snd_ca0106_create(int dev, struct snd_card *card,
    1601                                          struct pci_dev *pci,
    1602                                          struct snd_ca0106 **rchip)
    1603 {
    1604         struct snd_ca0106 *chip;
     1580                             struct pci_dev *pci)
     1581{
     1582        struct snd_ca0106 *chip = card->private_data;
    16051583        const struct snd_ca0106_details *c;
    16061584        int err;
    1607         static const struct snd_device_ops ops = {
    1608                 .dev_free = snd_ca0106_dev_free,
    1609         };
    1610 
    1611         *rchip = NULL;
    1612 
    1613         err = pci_enable_device(pci);
     1585
     1586        err = pcim_enable_device(pci);
    16141587        if (err < 0)
    16151588                return err;
    16161589        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) {
    16171590                dev_err(card->dev, "error to set 32bit mask DMA\n");
    1618                 pci_disable_device(pci);
    16191591                return -ENXIO;
    1620         }
    1621 
    1622         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1623         if (chip == NULL) {
    1624                 pci_disable_device(pci);
    1625                 return -ENOMEM;
    16261592        }
    16271593
    … …  
    16321598        spin_lock_init(&chip->emu_lock);
    16331599
     1600        err = pci_request_regions(pci, "snd_ca0106");
     1601        if (err < 0)
     1602                return err;
    16341603        chip->port = pci_resource_start(pci, 0);
    1635         chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
    1636         if (!chip->res_port) {
    1637                 snd_ca0106_free(chip);
    1638                 dev_err(card->dev, "cannot allocate the port\n");
    1639                 return -EBUSY;
    1640         }
    1641 
    1642         if (request_irq(pci->irq, snd_ca0106_interrupt,
    1643                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
    1644                 snd_ca0106_free(chip);
     1604
     1605        if (devm_request_irq(&pci->dev, pci->irq, snd_ca0106_interrupt,
     1606                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    16451607                dev_err(card->dev, "cannot grab irq\n");
    16461608                return -EBUSY;
    … …  
    16501612
    16511613        /* This stores the periods table. */
    1652         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    1653                                 1024, &chip->buffer) < 0) {
    1654                 snd_ca0106_free(chip);
     1614        chip->buffer = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024);
     1615        if (!chip->buffer)
    16551616                return -ENOMEM;
    1656         }
    1657 
    16581617        pci_set_master(pci);
    16591618        /* read serial */
    … …  
    16831642
    16841643        ca0106_init_chip(chip, 0);
    1685 
    1686         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1687         if (err < 0) {
    1688                 snd_ca0106_free(chip);
    1689                 return err;
    1690         }
    1691         *rchip = chip;
    16921644        return 0;
    16931645}
    … …  
    17771729
    17781730
    1779 static int snd_ca0106_probe(struct pci_dev *pci,
    1780                                         const struct pci_device_id *pci_id)
     1731static int __snd_ca0106_probe(struct pci_dev *pci,
     1732                              const struct pci_device_id *pci_id)
    17811733{
    17821734        static int dev;
    … …  
    17921744        }
    17931745
    1794         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1795                            0, &card);
     1746        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1747                                sizeof(*chip), &card);
    17961748        if (err < 0)
    17971749                return err;
    1798 
    1799         err = snd_ca0106_create(dev, card, pci, &chip);
     1750        chip = card->private_data;
     1751
     1752        err = snd_ca0106_create(dev, card, pci);
    18001753        if (err < 0)
    1801                 goto error;
    1802         card->private_data = chip;
     1754                return err;
     1755        card->private_free = snd_ca0106_free;
    18031756
    18041757        for (i = 0; i < 4; i++) {
    18051758                err = snd_ca0106_pcm(chip, i);
    18061759                if (err < 0)
    1807                         goto error;
     1760                        return err;
    18081761        }
    18091762
    … …  
    18121765                err = snd_ca0106_ac97(chip);
    18131766                if (err < 0)
    1814                         goto error;
     1767                        return err;
    18151768        }
    18161769        err = snd_ca0106_mixer(chip);
    18171770        if (err < 0)
    1818                 goto error;
     1771                return err;
    18191772
    18201773        dev_dbg(card->dev, "probe for MIDI channel A ...");
    18211774        err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
    18221775        if (err < 0)
    1823                 goto error;
     1776                return err;
    18241777        dev_dbg(card->dev, " done.\n");
    18251778
    … …  
    18301783        err = snd_card_register(card);
    18311784        if (err < 0)
    1832                 goto error;
     1785                return err;
    18331786
    18341787        pci_set_drvdata(pci, card);
    18351788        dev++;
    18361789        return 0;
    1837 
    1838  error:
    1839         snd_card_free(card);
    1840         return err;
    1841 }
    1842 
    1843 static void snd_ca0106_remove(struct pci_dev *pci)
    1844 {
    1845         snd_card_free(pci_get_drvdata(pci));
     1790}
     1791
     1792static int snd_ca0106_probe(struct pci_dev *pci,
     1793                            const struct pci_device_id *pci_id)
     1794{
     1795        return snd_card_free_on_error(&pci->dev, __snd_ca0106_probe(pci, pci_id));
    18461796}
    18471797
    … …  
    18991849        .id_table = snd_ca0106_ids,
    19001850        .probe = snd_ca0106_probe,
    1901         .remove = snd_ca0106_remove,
    19021851        .driver = {
    19031852                .pm = SND_CA0106_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/cmipci.c

    r703 r717  
    308308#define CM_MICGAINZ_SHIFT       0
    309309
    310 #define CM_REG_MIXER3           0x24
    311310#define CM_REG_AUX_VOL          0x26
    312311#define CM_VAUXL_MASK           0xf0
    … …  
    28732872                for (i = 0; ports[i]; i++) {
    28742873                        io_port = ports[i];
    2875                         r = request_region(io_port, 1, "CMIPCI gameport");
     2874                        r = devm_request_region(&cm->pci->dev, io_port, 1,
     2875                                                "CMIPCI gameport");
    28762876                        if (r)
    28772877                                break;
    … …  
    28792879        } else {
    28802880                io_port = joystick_port[dev];
    2881                 r = request_region(io_port, 1, "CMIPCI gameport");
     2881                r = devm_request_region(&cm->pci->dev, io_port, 1,
     2882                                        "CMIPCI gameport");
    28822883        }
    28832884
    … …  
    28902891        if (!gp) {
    28912892                dev_err(cm->card->dev, "cannot allocate memory for gameport\n");
    2892                 release_and_free_resource(r);
    28932893                return -ENOMEM;
    28942894        }
    … …  
    28972897        gameport_set_dev_parent(gp, &cm->pci->dev);
    28982898        gp->io = io_port;
    2899         gameport_set_port_data(gp, r);
    29002899
    29012900        snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    … …  
    29092908{
    29102909        if (cm->gameport) {
    2911                 struct resource *r = gameport_get_port_data(cm->gameport);
    2912 
    29132910                gameport_unregister_port(cm->gameport);
    29142911                cm->gameport = NULL;
    29152912
    29162913                snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    2917                 release_and_free_resource(r);
    29182914        }
    29192915}
    … …  
    29232919#endif
    29242920
    2925 static int snd_cmipci_free(struct cmipci *cm)
    2926 {
    2927         if (cm->irq >= 0) {
    2928                 snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN);
    2929                 snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_ENSPDOUT);
    2930                 snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);  /* disable ints */
    2931                 snd_cmipci_ch_reset(cm, CM_CH_PLAY);
    2932                 snd_cmipci_ch_reset(cm, CM_CH_CAPT);
    2933                 snd_cmipci_write(cm, CM_REG_FUNCTRL0, 0); /* disable channels */
    2934                 snd_cmipci_write(cm, CM_REG_FUNCTRL1, 0);
    2935 
    2936                 /* reset mixer */
    2937                 snd_cmipci_mixer_write(cm, 0, 0);
    2938 
    2939                 free_irq(cm->irq, cm);
    2940         }
     2921static void snd_cmipci_free(struct snd_card *card)
     2922{
     2923        struct cmipci *cm = card->private_data;
     2924
     2925        snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN);
     2926        snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_ENSPDOUT);
     2927        snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);  /* disable ints */
     2928        snd_cmipci_ch_reset(cm, CM_CH_PLAY);
     2929        snd_cmipci_ch_reset(cm, CM_CH_CAPT);
     2930        snd_cmipci_write(cm, CM_REG_FUNCTRL0, 0); /* disable channels */
     2931        snd_cmipci_write(cm, CM_REG_FUNCTRL1, 0);
     2932
     2933        /* reset mixer */
     2934        snd_cmipci_mixer_write(cm, 0, 0);
    29412935
    29422936        snd_cmipci_free_gameport(cm);
    2943         pci_release_regions(cm->pci);
    2944         pci_disable_device(cm->pci);
    2945         kfree(cm);
    2946         return 0;
    2947 }
    2948 
    2949 static int snd_cmipci_dev_free(struct snd_device *device)
    2950 {
    2951         struct cmipci *cm = device->device_data;
    2952         return snd_cmipci_free(cm);
    29532937}
    29542938
    … …  
    30092993
    30102994static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci,
    3011                              int dev, struct cmipci **rcmipci)
    3012 {
    3013         struct cmipci *cm;
     2995                             int dev)
     2996{
     2997        struct cmipci *cm = card->private_data;
    30142998        int err;
    3015         static const struct snd_device_ops ops = {
    3016                 .dev_free =     snd_cmipci_dev_free,
    3017         };
    30182999        unsigned int val;
    30193000        long iomidi = 0;
    … …  
    30263007        };
    30273008
    3028         *rcmipci = NULL;
    3029 
    3030         err = pci_enable_device(pci);
     3009        err = pcim_enable_device(pci);
    30313010        if (err < 0)
    30323011                return err;
    3033 
    3034         cm = kzalloc(sizeof(*cm), GFP_KERNEL);
    3035         if (cm == NULL) {
    3036                 pci_disable_device(pci);
    3037                 return -ENOMEM;
    3038         }
    30393012
    30403013        spin_lock_init(&cm->reg_lock);
    … …  
    30493022
    30503023        err = pci_request_regions(pci, card->driver);
    3051         if (err < 0) {
    3052                 kfree(cm);
    3053                 pci_disable_device(pci);
     3024        if (err < 0)
    30543025                return err;
    3055         }
    30563026        cm->iobase = pci_resource_start(pci, 0);
    30573027
    3058         if (request_irq(pci->irq, snd_cmipci_interrupt,
    3059                         IRQF_SHARED, KBUILD_MODNAME, cm)) {
     3028        if (devm_request_irq(&pci->dev, pci->irq, snd_cmipci_interrupt,
     3029                             IRQF_SHARED, KBUILD_MODNAME, cm)) {
    30603030                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    3061                 snd_cmipci_free(cm);
    30623031                return -EBUSY;
    30633032        }
    30643033        cm->irq = pci->irq;
    30653034        card->sync_irq = cm->irq;
     3035        card->private_free = snd_cmipci_free;
    30663036
    30673037        pci_set_master(cm->pci);
    … …  
    31633133                card->shortname, modelstr, cm->iobase, cm->irq);
    31643134
    3165         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, cm, &ops);
    3166         if (err < 0) {
    3167                 snd_cmipci_free(cm);
    3168                 return err;
    3169         }
    3170 
    31713135        if (cm->chip_version >= 39) {
    31723136                val = snd_cmipci_read_b(cm, CM_REG_MPU_PCI + 1);
    … …  
    32613225                snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    32623226
    3263         *rcmipci = cm;
    32643227        return 0;
    32653228}
    … …  
    32853248        }
    32863249
    3287         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    3288                            0, &card);
     3250        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     3251                                sizeof(*cm), &card);
    32893252        if (err < 0)
    32903253                return err;
     3254        cm = card->private_data;
    32913255       
    32923256        switch (pci->device) {
    … …  
    33043268        }
    33053269
    3306         err = snd_cmipci_create(card, pci, dev, &cm);
     3270        err = snd_cmipci_create(card, pci, dev);
    33073271        if (err < 0)
    3308                 goto free_card;
    3309 
    3310         card->private_data = cm;
     3272                goto error;
    33113273
    33123274        err = snd_card_register(card);
    33133275        if (err < 0)
    3314                 goto free_card;
     3276                goto error;
    33153277
    33163278        pci_set_drvdata(pci, card);
    … …  
    33183280        return 0;
    33193281
    3320 free_card:
     3282 error:
    33213283        snd_card_free(card);
    33223284        return err;
    33233285}
    33243286
    3325 static void snd_cmipci_remove(struct pci_dev *pci)
    3326 {
    3327         snd_card_free(pci_get_drvdata(pci));
    3328 }
    3329 
    3330 
    33313287#ifdef CONFIG_PM_SLEEP
    33323288/*
    … …  
    33353291static const unsigned char saved_regs[] = {
    33363292        CM_REG_FUNCTRL1, CM_REG_CHFORMAT, CM_REG_LEGACY_CTRL, CM_REG_MISC_CTRL,
    3337         CM_REG_MIXER0, CM_REG_MIXER1, CM_REG_MIXER2, CM_REG_MIXER3, CM_REG_PLL,
     3293        CM_REG_MIXER0, CM_REG_MIXER1, CM_REG_MIXER2, CM_REG_AUX_VOL, CM_REG_PLL,
    33383294        CM_REG_CH0_FRAME1, CM_REG_CH0_FRAME2,
    33393295        CM_REG_CH1_FRAME1, CM_REG_CH1_FRAME2, CM_REG_EXT_MISC,
    … …  
    34033359        .id_table = snd_cmipci_ids,
    34043360        .probe = snd_cmipci_probe,
    3405         .remove = snd_cmipci_remove,
    34063361        .driver = {
    34073362                .pm = SND_CMIPCI_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/cs4281.c

    r703 r717  
    12721272#endif /* IS_REACHABLE(CONFIG_GAMEPORT) */
    12731273
    1274 static int snd_cs4281_free(struct cs4281 *chip)
    1275 {
     1274static void snd_cs4281_free(struct snd_card *card)
     1275{
     1276        struct cs4281 *chip = card->private_data;
     1277
    12761278        snd_cs4281_free_gameport(chip);
    12771279
    … …  
    12821284        /* Sound System Power Management - Turn Everything OFF */
    12831285        snd_cs4281_pokeBA0(chip, BA0_SSPM, 0);
    1284         /* PCI interface - D3 state */
    1285         pci_set_power_state(chip->pci, PCI_D3hot);
    1286 
    1287         if (chip->irq >= 0)
    1288                 free_irq(chip->irq, chip);
    1289         iounmap(chip->ba0);
    1290         iounmap(chip->ba1);
    1291         pci_release_regions(chip->pci);
    1292         pci_disable_device(chip->pci);
    1293 
    1294         kfree(chip);
    1295         return 0;
    1296 }
    1297 
    1298 static int snd_cs4281_dev_free(struct snd_device *device)
    1299 {
    1300         struct cs4281 *chip = device->device_data;
    1301         return snd_cs4281_free(chip);
    13021286}
    13031287
    … …  
    13061290static int snd_cs4281_create(struct snd_card *card,
    13071291                             struct pci_dev *pci,
    1308                              struct cs4281 **rchip,
    13091292                             int dual_codec)
    13101293{
    1311         struct cs4281 *chip;
    1312         unsigned int tmp;
     1294        struct cs4281 *chip = card->private_data;
    13131295        int err;
    1314         static const struct snd_device_ops ops = {
    1315                 .dev_free =     snd_cs4281_dev_free,
    1316         };
    1317 
    1318         *rchip = NULL;
    1319         err = pci_enable_device(pci);
     1296
     1297        err = pcim_enable_device(pci);
    13201298        if (err < 0)
    13211299                return err;
    1322         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1323         if (chip == NULL) {
    1324                 pci_disable_device(pci);
    1325                 return -ENOMEM;
    1326         }
    13271300        spin_lock_init(&chip->reg_lock);
    13281301        chip->card = card;
    … …  
    13361309        chip->dual_codec = dual_codec;
    13371310
     1311#ifndef TARGET_OS2
     1312        err = pcim_iomap_regions(pci, 0x03, "CS4281"); /* 2 BARs */
     1313        if (err < 0)
     1314                return err;
     1315#else
    13381316        err = pci_request_regions(pci, "CS4281");
    13391317        if (err < 0) {
    … …  
    13421320                return err;
    13431321        }
     1322#endif
    13441323        chip->ba0_addr = pci_resource_start(pci, 0);
    13451324        chip->ba1_addr = pci_resource_start(pci, 1);
    13461325
     1326#ifndef TARGET_OS2
     1327        chip->ba0 = pcim_iomap_table(pci)[0];
     1328        chip->ba1 = pcim_iomap_table(pci)[1];
     1329#else
    13471330        chip->ba0 = pci_ioremap_bar(pci, 0);
    13481331        chip->ba1 = pci_ioremap_bar(pci, 1);
    1349         if (!chip->ba0 || !chip->ba1) {
    1350                 snd_cs4281_free(chip);
    1351                 return -ENOMEM;
    1352         }
    1353        
    1354         if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
    1355                         KBUILD_MODNAME, chip)) {
     1332#endif
     1333        if (devm_request_irq(&pci->dev, pci->irq, snd_cs4281_interrupt,
     1334                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    13561335                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    1357                 snd_cs4281_free(chip);
    13581336                return -ENOMEM;
    13591337        }
    13601338        chip->irq = pci->irq;
    13611339        card->sync_irq = chip->irq;
    1362 
    1363         tmp = snd_cs4281_chip_init(chip);
    1364         if (tmp) {
    1365                 snd_cs4281_free(chip);
    1366                 return tmp;
    1367         }
    1368 
    1369         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1370         if (err < 0) {
    1371                 snd_cs4281_free(chip);
     1340        card->private_free = snd_cs4281_free;
     1341
     1342        err = snd_cs4281_chip_init(chip);
     1343        if (err)
    13721344                return err;
    1373         }
    13741345
    13751346        snd_cs4281_proc_init(chip);
    1376 
    1377         *rchip = chip;
    13781347        return 0;
    13791348}
    … …  
    18751844}
    18761845
    1877 static int snd_cs4281_probe(struct pci_dev *pci,
    1878                             const struct pci_device_id *pci_id)
     1846static int __snd_cs4281_probe(struct pci_dev *pci,
     1847                              const struct pci_device_id *pci_id)
    18791848{
    18801849        static int dev;
    … …  
    18911860        }
    18921861
    1893         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1894                            0, &card);
     1862        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1863                                sizeof(*chip), &card);
    18951864        if (err < 0)
    18961865                return err;
    1897 
    1898         err = snd_cs4281_create(card, pci, &chip, dual_codec[dev]);
    1899         if (err < 0) {
    1900                 snd_card_free(card);
     1866        chip = card->private_data;
     1867
     1868        err = snd_cs4281_create(card, pci, dual_codec[dev]);
     1869        if (err < 0)
    19011870                return err;
    1902         }
    1903         card->private_data = chip;
    19041871
    19051872        err = snd_cs4281_mixer(chip);
    1906         if (err < 0) {
    1907                 snd_card_free(card);
     1873        if (err < 0)
    19081874                return err;
    1909         }
    19101875        err = snd_cs4281_pcm(chip, 0);
    1911         if (err < 0) {
    1912                 snd_card_free(card);
     1876        if (err < 0)
    19131877                return err;
    1914         }
    19151878        err = snd_cs4281_midi(chip, 0);
    1916         if (err < 0) {
    1917                 snd_card_free(card);
     1879        if (err < 0)
    19181880                return err;
    1919         }
    19201881        err = snd_opl3_new(card, OPL3_HW_OPL3_CS4281, &opl3);
    1921         if (err < 0) {
    1922                 snd_card_free(card);
     1882        if (err < 0)
    19231883                return err;
    1924         }
    19251884        opl3->private_data = chip;
    19261885        opl3->command = snd_cs4281_opl3_command;
    19271886        snd_opl3_init(opl3);
    19281887        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    1929         if (err < 0) {
    1930                 snd_card_free(card);
     1888        if (err < 0)
    19311889                return err;
    1932         }
    19331890        snd_cs4281_create_gameport(chip);
    19341891        strcpy(card->driver, "CS4281");
    … …  
    19401897
    19411898        err = snd_card_register(card);
    1942         if (err < 0) {
    1943                 snd_card_free(card);
     1899        if (err < 0)
    19441900                return err;
    1945         }
    19461901
    19471902        pci_set_drvdata(pci, card);
    … …  
    19501905}
    19511906
    1952 static void snd_cs4281_remove(struct pci_dev *pci)
    1953 {
    1954         snd_card_free(pci_get_drvdata(pci));
     1907static int snd_cs4281_probe(struct pci_dev *pci,
     1908                            const struct pci_device_id *pci_id)
     1909{
     1910        return snd_card_free_on_error(&pci->dev, __snd_cs4281_probe(pci, pci_id));
    19551911}
    19561912
    … …  
    20582014        .id_table = snd_cs4281_ids,
    20592015        .probe = snd_cs4281_probe,
    2060         .remove = snd_cs4281_remove,
    20612016        .driver = {
    20622017                .pm = CS4281_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/cs46xx/cs46xx.c

    r703 r717  
    7474        }
    7575
    76         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    77                            0, &card);
     76        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     77                                sizeof(*chip), &card);
    7878        if (err < 0)
    7979                return err;
     80        chip = card->private_data;
    8081        err = snd_cs46xx_create(card, pci,
    81                                 external_amp[dev], thinkpad[dev],
    82                                 &chip);
    83         if (err < 0) {
    84                 snd_card_free(card);
    85                 return err;
    86         }
     82                                external_amp[dev], thinkpad[dev]);
     83        if (err < 0)
     84                goto error;
    8785        card->private_data = chip;
    8886        chip->accept_valid = mmap_valid[dev];
    8987        err = snd_cs46xx_pcm(chip, 0);
    90         if (err < 0) {
    91                 snd_card_free(card);
    92                 return err;
    93         }
     88        if (err < 0)
     89                goto error;
    9490#ifdef CONFIG_SND_CS46XX_NEW_DSP
    9591        err = snd_cs46xx_pcm_rear(chip, 1);
    96         if (err < 0) {
    97                 snd_card_free(card);
    98                 return err;
    99         }
     92        if (err < 0)
     93                goto error;
    10094        err = snd_cs46xx_pcm_iec958(chip, 2);
    101         if (err < 0) {
    102                 snd_card_free(card);
    103                 return err;
    104         }
     95        if (err < 0)
     96                goto error;
    10597#endif
    10698        err = snd_cs46xx_mixer(chip, 2);
    107         if (err < 0) {
    108                 snd_card_free(card);
    109                 return err;
    110         }
     99        if (err < 0)
     100                goto error;
    111101#ifdef CONFIG_SND_CS46XX_NEW_DSP
    112102        if (chip->nr_ac97_codecs ==2) {
    113103                err = snd_cs46xx_pcm_center_lfe(chip, 3);
    114                 if (err < 0) {
    115                         snd_card_free(card);
    116                         return err;
    117                 }
     104                if (err < 0)
     105                        goto error;
    118106        }
    119107#endif
    120108        err = snd_cs46xx_midi(chip, 0);
    121         if (err < 0) {
    122                 snd_card_free(card);
    123                 return err;
    124         }
     109        if (err < 0)
     110                goto error;
    125111        err = snd_cs46xx_start_dsp(chip);
    126         if (err < 0) {
    127                 snd_card_free(card);
    128                 return err;
    129         }
    130 
     112        if (err < 0)
     113                goto error;
    131114
    132115        snd_cs46xx_gameport(chip);
    … …  
    141124
    142125        err = snd_card_register(card);
    143         if (err < 0) {
    144                 snd_card_free(card);
    145                 return err;
    146         }
     126        if (err < 0)
     127                goto error;
    147128
    148129        pci_set_drvdata(pci, card);
    149130        dev++;
    150131        return 0;
    151 }
    152132
    153 static void snd_card_cs46xx_remove(struct pci_dev *pci)
    154 {
    155         snd_card_free(pci_get_drvdata(pci));
     133 error:
     134        snd_card_free(card);
     135        return err;
    156136}
    157137
    … …  
    160140        .id_table = snd_cs46xx_ids,
    161141        .probe = snd_card_cs46xx_probe,
    162         .remove = snd_card_cs46xx_remove,
    163142#ifdef CONFIG_PM_SLEEP
    164143        .driver = {

  • GPL/trunk/alsa-kernel/pci/cs46xx/cs46xx.h

    r679 r717  
    16361636        void __iomem *remap_addr;
    16371637        unsigned long size;
    1638         struct resource *resource;
    16391638};
    16401639
    … …  
    17191718int snd_cs46xx_create(struct snd_card *card,
    17201719                      struct pci_dev *pci,
    1721                       int external_amp, int thinkpad,
    1722                       struct snd_cs46xx **rcodec);
     1720                      int external_amp, int thinkpad);
    17231721extern const struct dev_pm_ops snd_cs46xx_pm;
    17241722

  • GPL/trunk/alsa-kernel/pci/cs46xx/cs46xx_lib.c

    r703 r717  
    11261126                if (runtime->dma_area != cpcm->hw_buf.area)
    11271127                        snd_pcm_lib_free_pages(substream);
    1128                 runtime->dma_area = cpcm->hw_buf.area;
    1129                 runtime->dma_addr = cpcm->hw_buf.addr;
    1130                 runtime->dma_bytes = cpcm->hw_buf.bytes;
     1128                snd_pcm_set_runtime_buffer(substream, &cpcm->hw_buf);
    11311129
    11321130
    … …  
    11481146
    11491147        } else {
    1150                 if (runtime->dma_area == cpcm->hw_buf.area) {
    1151                         runtime->dma_area = NULL;
    1152                         runtime->dma_addr = 0;
    1153                         runtime->dma_bytes = 0;
    1154                 }
     1148                if (runtime->dma_area == cpcm->hw_buf.area)
     1149                        snd_pcm_set_runtime_buffer(substream, NULL);
    11551150                err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
    11561151                if (err < 0) {
    … …  
    12011196                snd_pcm_lib_free_pages(substream);
    12021197   
    1203         runtime->dma_area = NULL;
    1204         runtime->dma_addr = 0;
    1205         runtime->dma_bytes = 0;
     1198        snd_pcm_set_runtime_buffer(substream, NULL);
    12061199
    12071200        return 0;
    … …  
    12921285                if (runtime->dma_area != chip->capt.hw_buf.area)
    12931286                        snd_pcm_lib_free_pages(substream);
    1294                 runtime->dma_area = chip->capt.hw_buf.area;
    1295                 runtime->dma_addr = chip->capt.hw_buf.addr;
    1296                 runtime->dma_bytes = chip->capt.hw_buf.bytes;
     1287                snd_pcm_set_runtime_buffer(substream, &chip->capt.hw_buf);
    12971288                substream->ops = &snd_cs46xx_capture_ops;
    12981289        } else {
    1299                 if (runtime->dma_area == chip->capt.hw_buf.area) {
    1300                         runtime->dma_area = NULL;
    1301                         runtime->dma_addr = 0;
    1302                         runtime->dma_bytes = 0;
    1303                 }
     1290                if (runtime->dma_area == chip->capt.hw_buf.area)
     1291                        snd_pcm_set_runtime_buffer(substream, NULL);
    13041292                err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
    13051293                if (err < 0)
    … …  
    13181306        if (runtime->dma_area != chip->capt.hw_buf.area)
    13191307                snd_pcm_lib_free_pages(substream);
    1320         runtime->dma_area = NULL;
    1321         runtime->dma_addr = 0;
    1322         runtime->dma_bytes = 0;
     1308        snd_pcm_set_runtime_buffer(substream, NULL);
    13231309
    13241310        return 0;
    … …  
    18701856 *  Mixer routines
    18711857 */
    1872 static void snd_cs46xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus)
    1873 {
    1874         struct snd_cs46xx *chip = bus->private_data;
    1875 
    1876         chip->ac97_bus = NULL;
    1877 }
    1878 
    18791858static void snd_cs46xx_mixer_free_ac97(struct snd_ac97 *ac97)
    18801859{
    … …  
    24922471        if (err < 0)
    24932472                return err;
    2494         chip->ac97_bus->private_free = snd_cs46xx_mixer_free_ac97_bus;
    24952473
    24962474        if (cs46xx_detect_codec(chip, CS46XX_PRIMARY_CODEC_INDEX) < 0)
    … …  
    29182896
    29192897
    2920 static int snd_cs46xx_free(struct snd_cs46xx *chip)
    2921 {
     2898static void snd_cs46xx_free(struct snd_card *card)
     2899{
     2900        struct snd_cs46xx *chip = card->private_data;
     2901#ifdef CONFIG_SND_CS46XX_NEW_DSP
    29222902        int idx;
    2923 
    2924         if (snd_BUG_ON(!chip))
    2925                 return -EINVAL;
     2903#endif
    29262904
    29272905        if (chip->active_ctrl)
    … …  
    29352913        snd_cs46xx_proc_done(chip);
    29362914
    2937         if (chip->region.idx[0].resource)
    2938                 snd_cs46xx_hw_stop(chip);
    2939 
    2940         if (chip->irq >= 0)
    2941                 free_irq(chip->irq, chip);
     2915        snd_cs46xx_hw_stop(chip);
    29422916
    29432917        if (chip->active_ctrl)
    29442918                chip->active_ctrl(chip, -chip->amplifier);
    2945 
    2946         for (idx = 0; idx < 5; idx++) {
    2947                 struct snd_cs46xx_region *region = &chip->region.idx[idx];
    2948 
    2949                 iounmap(region->remap_addr);
    2950                 release_and_free_resource(region->resource);
    2951         }
    29522919
    29532920#ifdef CONFIG_SND_CS46XX_NEW_DSP
    … …  
    29612928        vfree(chip->ba1);
    29622929#endif
    2963        
    2964 #ifdef CONFIG_PM_SLEEP
    2965         kfree(chip->saved_regs);
    2966 #endif
    2967 
    2968         pci_disable_device(chip->pci);
    2969         kfree(chip);
    2970         return 0;
    2971 }
    2972 
    2973 static int snd_cs46xx_dev_free(struct snd_device *device)
    2974 {
    2975         struct snd_cs46xx *chip = device->device_data;
    2976         return snd_cs46xx_free(chip);
    29772930}
    29782931
    … …  
    38733826int snd_cs46xx_create(struct snd_card *card,
    38743827                      struct pci_dev *pci,
    3875                       int external_amp, int thinkpad,
    3876                       struct snd_cs46xx **rchip)
    3877 {
    3878         struct snd_cs46xx *chip;
     3828                      int external_amp, int thinkpad)
     3829{
     3830        struct snd_cs46xx *chip = card->private_data;
    38793831        int err, idx;
    38803832        struct snd_cs46xx_region *region;
    38813833        struct cs_card_type *cp;
    38823834        u16 ss_card, ss_vendor;
    3883         static const struct snd_device_ops ops = {
    3884                 .dev_free =     snd_cs46xx_dev_free,
    3885         };
    38863835       
    3887         *rchip = NULL;
    3888 
    38893836        /* enable PCI device */
    3890         err = pci_enable_device(pci);
     3837        err = pcim_enable_device(pci);
    38913838        if (err < 0)
    38923839                return err;
    38933840
    3894         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    3895         if (chip == NULL) {
    3896                 pci_disable_device(pci);
    3897                 return -ENOMEM;
    3898         }
    38993841        spin_lock_init(&chip->reg_lock);
    39003842#ifdef CONFIG_SND_CS46XX_NEW_DSP
    … …  
    39043846        chip->pci = pci;
    39053847        chip->irq = -1;
     3848
     3849        err = pci_request_regions(pci, "CS46xx");
     3850        if (err < 0)
     3851                return err;
    39063852        chip->ba0_addr = pci_resource_start(pci, 0);
    39073853        chip->ba1_addr = pci_resource_start(pci, 1);
    … …  
    39113857                        "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n",
    39123858                           chip->ba0_addr, chip->ba1_addr);
    3913                 snd_cs46xx_free(chip);
    39143859                return -ENOMEM;
    39153860        }
    … …  
    39833928        for (idx = 0; idx < 5; idx++) {
    39843929                region = &chip->region.idx[idx];
    3985                 region->resource = request_mem_region(region->base, region->size,
    3986                                                       region->name);
    3987                 if (!region->resource) {
    3988                         dev_err(chip->card->dev,
    3989                                 "unable to request memory region 0x%lx-0x%lx\n",
    3990                                    region->base, region->base + region->size - 1);
    3991                         snd_cs46xx_free(chip);
    3992                         return -EBUSY;
    3993                 }
    3994                 region->remap_addr = ioremap(region->base, region->size);
     3930                region->remap_addr = devm_ioremap(&pci->dev, region->base,
     3931                                                  region->size);
    39953932                if (region->remap_addr == NULL) {
    39963933                        dev_err(chip->card->dev,
    39973934                                "%s ioremap problem\n", region->name);
    3998                         snd_cs46xx_free(chip);
    39993935                        return -ENOMEM;
    40003936                }
    40013937        }
    40023938
    4003         if (request_irq(pci->irq, snd_cs46xx_interrupt, IRQF_SHARED,
    4004                         KBUILD_MODNAME, chip)) {
     3939        if (devm_request_irq(&pci->dev, pci->irq, snd_cs46xx_interrupt,
     3940                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    40053941                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
    4006                 snd_cs46xx_free(chip);
    40073942                return -EBUSY;
    40083943        }
    40093944        chip->irq = pci->irq;
    40103945        card->sync_irq = chip->irq;
     3946        card->private_free = snd_cs46xx_free;
    40113947
    40123948#ifdef CONFIG_SND_CS46XX_NEW_DSP
    40133949        chip->dsp_spos_instance = cs46xx_dsp_spos_create(chip);
    4014         if (chip->dsp_spos_instance == NULL) {
    4015                 snd_cs46xx_free(chip);
     3950        if (!chip->dsp_spos_instance)
    40163951                return -ENOMEM;
    4017         }
    40183952#endif
    40193953
    40203954        err = snd_cs46xx_chip_init(chip);
    4021         if (err < 0) {
    4022                 snd_cs46xx_free(chip);
     3955        if (err < 0)
    40233956                return err;
    4024         }
    4025 
    4026         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    4027         if (err < 0) {
    4028                 snd_cs46xx_free(chip);
    4029                 return err;
    4030         }
    40313957       
    40323958        snd_cs46xx_proc_init(card, chip);
    40333959
    40343960#ifdef CONFIG_PM_SLEEP
    4035         chip->saved_regs = kmalloc_array(ARRAY_SIZE(saved_regs),
    4036                                          sizeof(*chip->saved_regs),
    4037                                          GFP_KERNEL);
    4038         if (!chip->saved_regs) {
    4039                 snd_cs46xx_free(chip);
     3961        chip->saved_regs = devm_kmalloc_array(&pci->dev,
     3962                                              ARRAY_SIZE(saved_regs),
     3963                                              sizeof(*chip->saved_regs),
     3964                                              GFP_KERNEL);
     3965        if (!chip->saved_regs)
    40403966                return -ENOMEM;
    4041         }
    40423967#endif
    40433968
    40443969        chip->active_ctrl(chip, -1); /* disable CLKRUN */
    4045 
    4046         *rchip = chip;
    4047         return 0;
    4048 }
     3970        return 0;
     3971}

  • GPL/trunk/alsa-kernel/pci/cs5530.c

    r679 r717  
    7070MODULE_DEVICE_TABLE(pci, snd_cs5530_ids);
    7171
    72 static int snd_cs5530_free(struct snd_cs5530 *chip)
    73 {
    74         pci_release_regions(chip->pci);
    75         pci_disable_device(chip->pci);
    76         kfree(chip);
    77         return 0;
    78 }
    79 
    80 static int snd_cs5530_dev_free(struct snd_device *device)
    81 {
    82         struct snd_cs5530 *chip = device->device_data;
    83         return snd_cs5530_free(chip);
    84 }
    85 
    86 static void snd_cs5530_remove(struct pci_dev *pci)
    87 {
    88         snd_card_free(pci_get_drvdata(pci));
    89 }
    90 
    9172static u8 snd_cs5530_mixer_read(unsigned long io, u8 reg)
    9273{
    … …  
    9980
    10081static int snd_cs5530_create(struct snd_card *card,
    101                              struct pci_dev *pci,
    102                              struct snd_cs5530 **rchip)
     82                             struct pci_dev *pci)
    10383{
    104         struct snd_cs5530 *chip;
     84        struct snd_cs5530 *chip = card->private_data;
    10585        unsigned long sb_base;
    10686        u8 irq, dma8, dma16 = 0;
    … …  
    10989        int err;
    11090
    111         static const struct snd_device_ops ops = {
    112                 .dev_free = snd_cs5530_dev_free,
    113         };
    114         *rchip = NULL;
    115 
    116         err = pci_enable_device(pci);
     91        err = pcim_enable_device(pci);
    11792        if (err < 0)
    11893                return err;
    119 
    120         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    121         if (chip == NULL) {
    122                 pci_disable_device(pci);
    123                 return -ENOMEM;
    124         }
    12594
    12695        chip->card = card;
    12796        chip->pci = pci;
    12897
    129         err = pci_request_regions(pci, "CS5530");
    130         if (err < 0) {
    131                 kfree(chip);
    132                 pci_disable_device(pci);
    133                 return err;
    134         }
     98        err = pcim_iomap_regions(pci, 1 << 0, "CS5530");
     99        if (err < 0)
     100                return err;
    135101        chip->pci_base = pci_resource_start(pci, 0);
    136 
     102#ifndef TARGET_OS2
     103        mem = pcim_iomap_table(pci)[0];
     104#else
    137105        mem = pci_ioremap_bar(pci, 0);
    138         if (mem == NULL) {
    139                 snd_cs5530_free(chip);
    140                 return -EBUSY;
    141         }
    142 
     106#endif
    143107        map = readw(mem + 0x18);
    144         iounmap(mem);
    145108
    146109        /* Map bits
    … …  
    159122        else {
    160123                dev_err(card->dev, "Could not find XpressAudio!\n");
    161                 snd_cs5530_free(chip);
    162124                return -ENODEV;
    163125        }
    … …  
    179141        else {
    180142                dev_err(card->dev, "No 16bit DMA enabled\n");
    181                 snd_cs5530_free(chip);
    182143                return -ENODEV;
    183144        }
    … …  
    191152        else {
    192153                dev_err(card->dev, "No 8bit DMA enabled\n");
    193                 snd_cs5530_free(chip);
    194154                return -ENODEV;
    195155        }
    … …  
    205165        else {
    206166                dev_err(card->dev, "SoundBlaster IRQ not set\n");
    207                 snd_cs5530_free(chip);
    208167                return -ENODEV;
    209168        }
    … …  
    215174        if (err < 0) {
    216175                dev_err(card->dev, "Could not create SoundBlaster\n");
    217                 snd_cs5530_free(chip);
    218176                return err;
    219177        }
    … …  
    222180        if (err < 0) {
    223181                dev_err(card->dev, "Could not create PCM\n");
    224                 snd_cs5530_free(chip);
    225182                return err;
    226183        }
    … …  
    229186        if (err < 0) {
    230187                dev_err(card->dev, "Could not create Mixer\n");
    231                 snd_cs5530_free(chip);
    232                 return err;
    233         }
    234 
    235         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    236         if (err < 0) {
    237                 snd_cs5530_free(chip);
    238                 return err;
    239         }
    240 
    241         *rchip = chip;
     188                return err;
     189        }
     190
    242191        return 0;
    243192}
    … …  
    248197        static int dev;
    249198        struct snd_card *card;
    250         struct snd_cs5530 *chip = NULL;
     199        struct snd_cs5530 *chip;
    251200        int err;
    252201
    … …  
    258207        }
    259208
    260         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    261                            0, &card);
    262 
    263         if (err < 0)
    264                 return err;
    265 
    266         err = snd_cs5530_create(card, pci, &chip);
    267         if (err < 0) {
    268                 snd_card_free(card);
    269                 return err;
    270         }
     209        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     210                                sizeof(*chip), &card);
     211        if (err < 0)
     212                return err;
     213        chip = card->private_data;
     214
     215        err = snd_cs5530_create(card, pci);
     216        if (err < 0)
     217                return err;
    271218
    272219        strcpy(card->driver, "CS5530");
    … …  
    275222
    276223        err = snd_card_register(card);
    277         if (err < 0) {
    278                 snd_card_free(card);
    279                 return err;
    280         }
     224        if (err < 0)
     225                return err;
    281226        pci_set_drvdata(pci, card);
    282227        dev++;
    … …  
    288233        .id_table = snd_cs5530_ids,
    289234        .probe = snd_cs5530_probe,
    290         .remove = snd_cs5530_remove,
    291235};
    292236

  • GPL/trunk/alsa-kernel/pci/cs5535audio/cs5535audio.c

    r703 r717  
    242242}
    243243
    244 static int snd_cs5535audio_free(struct cs5535audio *cs5535au)
    245 {
    246         pci_set_power_state(cs5535au->pci, PCI_D3hot);
    247 
    248         if (cs5535au->irq >= 0)
    249                 free_irq(cs5535au->irq, cs5535au);
    250 
    251         pci_release_regions(cs5535au->pci);
    252         pci_disable_device(cs5535au->pci);
    253         kfree(cs5535au);
    254         return 0;
    255 }
    256 
    257 static int snd_cs5535audio_dev_free(struct snd_device *device)
    258 {
    259         struct cs5535audio *cs5535au = device->device_data;
    260         return snd_cs5535audio_free(cs5535au);
     244static void snd_cs5535audio_free(struct snd_card *card)
     245{
     246        olpc_quirks_cleanup();
    261247}
    262248
    263249static int snd_cs5535audio_create(struct snd_card *card,
    264                                   struct pci_dev *pci,
    265                                   struct cs5535audio **rcs5535au)
    266 {
    267         struct cs5535audio *cs5535au;
    268 
     250                                  struct pci_dev *pci)
     251{
     252        struct cs5535audio *cs5535au = card->private_data;
    269253        int err;
    270         static const struct snd_device_ops ops = {
    271                 .dev_free =     snd_cs5535audio_dev_free,
    272         };
    273 
    274         *rcs5535au = NULL;
    275         err = pci_enable_device(pci);
     254
     255        err = pcim_enable_device(pci);
    276256        if (err < 0)
    277257                return err;
    … …  
    279259        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) {
    280260                dev_warn(card->dev, "unable to get 32bit dma\n");
    281                 err = -ENXIO;
    282                 goto pcifail;
    283         }
    284 
    285         cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
    286         if (cs5535au == NULL) {
    287                 err = -ENOMEM;
    288                 goto pcifail;
     261                return -ENXIO;
    289262        }
    290263
    … …  
    295268
    296269        err = pci_request_regions(pci, "CS5535 Audio");
    297         if (err < 0) {
    298                 kfree(cs5535au);
    299                 goto pcifail;
    300         }
     270        if (err < 0)
     271                return err;
    301272
    302273        cs5535au->port = pci_resource_start(pci, 0);
    303274
    304         if (request_irq(pci->irq, snd_cs5535audio_interrupt,
    305                         IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
     275        if (devm_request_irq(&pci->dev, pci->irq, snd_cs5535audio_interrupt,
     276                             IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
    306277                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    307                 err = -EBUSY;
    308                 goto sndfail;
     278                return -EBUSY;
    309279        }
    310280
    … …  
    313283        pci_set_master(pci);
    314284
    315         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, cs5535au, &ops);
    316         if (err < 0)
    317                 goto sndfail;
    318 
    319         *rcs5535au = cs5535au;
    320285        return 0;
    321 
    322 sndfail: /* leave the device alive, just kill the snd */
    323         snd_cs5535audio_free(cs5535au);
    324         return err;
    325 
    326 pcifail:
    327         pci_disable_device(pci);
    328         return err;
    329 }
    330 
    331 static int snd_cs5535audio_probe(struct pci_dev *pci,
    332                                  const struct pci_device_id *pci_id)
     286}
     287
     288static int __snd_cs5535audio_probe(struct pci_dev *pci,
     289                                   const struct pci_device_id *pci_id)
    333290{
    334291        static int dev;
    … …  
    344301        }
    345302
    346         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    347                            0, &card);
    348         if (err < 0)
    349                 return err;
    350 
    351         err = snd_cs5535audio_create(card, pci, &cs5535au);
    352         if (err < 0)
    353                 goto probefail_out;
    354 
    355         card->private_data = cs5535au;
     303        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     304                                sizeof(*cs5535au), &card);
     305        if (err < 0)
     306                return err;
     307        cs5535au = card->private_data;
     308        card->private_free = snd_cs5535audio_free;
     309
     310        err = snd_cs5535audio_create(card, pci);
     311        if (err < 0)
     312                return err;
    356313
    357314        err = snd_cs5535audio_mixer(cs5535au);
    358315        if (err < 0)
    359                 goto probefail_out;
     316                return err;
    360317
    361318        err = snd_cs5535audio_pcm(cs5535au);
    362319        if (err < 0)
    363                 goto probefail_out;
     320                return err;
    364321
    365322        strcpy(card->driver, DRIVER_NAME);
    … …  
    372329        err = snd_card_register(card);
    373330        if (err < 0)
    374                 goto probefail_out;
     331                return err;
    375332
    376333        pci_set_drvdata(pci, card);
    377334        dev++;
    378335        return 0;
    379 
    380 probefail_out:
    381         snd_card_free(card);
    382         return err;
    383 }
    384 
    385 static void snd_cs5535audio_remove(struct pci_dev *pci)
    386 {
    387         olpc_quirks_cleanup();
    388         snd_card_free(pci_get_drvdata(pci));
     336}
     337
     338static int snd_cs5535audio_probe(struct pci_dev *pci,
     339                                 const struct pci_device_id *pci_id)
     340{
     341        return snd_card_free_on_error(&pci->dev, __snd_cs5535audio_probe(pci, pci_id));
    389342}
    390343
    … …  
    393346        .id_table = snd_cs5535audio_ids,
    394347        .probe = snd_cs5535audio_probe,
    395         .remove = snd_cs5535audio_remove,
    396348#ifdef CONFIG_PM_SLEEP
    397349        .driver = {

  • GPL/trunk/alsa-kernel/pci/emu10k1/emu10k1.c

    r703 r717  
    114114        }
    115115
    116         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    117                            0, &card);
    118         if (err < 0)
    119                 return err;
     116        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     117                                sizeof(*emu), &card);
     118        if (err < 0)
     119                return err;
     120        emu = card->private_data;
     121
    120122        if (max_buffer_size[dev] < 32)
    121123                max_buffer_size[dev] = 32;
    … …  
    124126        err = snd_emu10k1_create(card, pci, extin[dev], extout[dev],
    125127                                 (long)max_buffer_size[dev] * 1024 * 1024,
    126                                  enable_ir[dev], subsystem[dev],
    127                                  &emu);
    128         if (err < 0)
    129                 goto error;
    130         card->private_data = emu;
     128                                 enable_ir[dev], subsystem[dev]);
     129        if (err < 0)
     130                return err;
    131131        emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f;
    132132        err = snd_emu10k1_pcm(emu, 0);
    133133        if (err < 0)
    134                 goto error;
     134                return err;
    135135        err = snd_emu10k1_pcm_mic(emu, 1);
    136136        if (err < 0)
    137                 goto error;
     137                return err;
    138138        err = snd_emu10k1_pcm_efx(emu, 2);
    139139        if (err < 0)
    140                 goto error;
     140                return err;
    141141        /* This stores the periods table. */
    142142        if (emu->card_capabilities->ca0151_chip) { /* P16V */   
    143                 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    144                                           1024, &emu->p16v_buffer);
    145                 if (err < 0)
    146                         goto error;
    147         }
    148 
     143                emu->p16v_buffer =
     144                        snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024);
     145                if (!emu->p16v_buffer)
     146                        return -ENOMEM;
     147        }
    149148        err = snd_emu10k1_mixer(emu, 0, 3);
    150149        if (err < 0)
    151                 goto error;
     150                return err;
    152151       
    153152        err = snd_emu10k1_timer(emu, 0);
    154153        if (err < 0)
    155                 goto error;
     154                return err;
    156155
    157156        err = snd_emu10k1_pcm_multi(emu, 3);
    158157        if (err < 0)
    159                 goto error;
     158                return err;
    160159        if (emu->card_capabilities->ca0151_chip) { /* P16V */
    161160                err = snd_p16v_pcm(emu, 4);
    162161                if (err < 0)
    163                         goto error;
     162                        return err;
    164163        }
    165164        if (emu->audigy) {
    166165                err = snd_emu10k1_audigy_midi(emu);
    167166                if (err < 0)
    168                         goto error;
     167                        return err;
    169168        } else {
    170169                err = snd_emu10k1_midi(emu);
    171170                if (err < 0)
    172                         goto error;
     171                        return err;
    173172        }
    174173        err = snd_emu10k1_fx8010_new(emu, 0);
    175174        if (err < 0)
    176                 goto error;
     175                return err;
    177176#ifdef ENABLE_SYNTH
    178177        if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
    … …  
    202201        err = snd_card_register(card);
    203202        if (err < 0)
    204                 goto error;
     203                return err;
    205204
    206205        if (emu->card_capabilities->emu_model)
    … …  
    210209        dev++;
    211210        return 0;
    212 
    213  error:
    214         snd_card_free(card);
    215         return err;
    216211}
    217 
    218 static void snd_card_emu10k1_remove(struct pci_dev *pci)
    219 {
    220         snd_card_free(pci_get_drvdata(pci));
    221 }
    222 
    223212
    224213#ifdef CONFIG_PM_SLEEP
    … …  
    278267        .id_table = snd_emu10k1_ids,
    279268        .probe = snd_card_emu10k1_probe,
    280         .remove = snd_card_emu10k1_remove,
    281269        .driver = {
    282270                .pm = SND_EMU10K1_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/emu10k1/emu10k1_main.c

    r695 r717  
    12521252#endif
    12531253
    1254 static int snd_emu10k1_free(struct snd_emu10k1 *emu)
     1254static void snd_emu10k1_free(struct snd_card *card)
    12551255{
     1256        struct snd_emu10k1 *emu = card->private_data;
     1257
    12561258        if (emu->port) {        /* avoid access to already used hardware */
    12571259                snd_emu10k1_fx8010_tram_setup(emu, 0);
    … …  
    12661268        release_firmware(emu->firmware);
    12671269        release_firmware(emu->dock_fw);
    1268         if (emu->irq >= 0)
    1269                 free_irq(emu->irq, emu);
    12701270        snd_util_memhdr_free(emu->memhdr);
    12711271        if (emu->silent_page.area)
    … …  
    12781278        free_pm_buffer(emu);
    12791279#endif
    1280         if (emu->port)
    1281                 pci_release_regions(emu->pci);
    1282         if (emu->card_capabilities->ca0151_chip) /* P16V */
    1283                 snd_p16v_free(emu);
    1284         pci_disable_device(emu->pci);
    1285         kfree(emu);
    1286         return 0;
    1287 }
    1288 
    1289 static int snd_emu10k1_dev_free(struct snd_device *device)
    1290 {
    1291         struct snd_emu10k1 *emu = device->device_data;
    1292         return snd_emu10k1_free(emu);
    12931280}
    12941281
    … …  
    17921779                       long max_cache_bytes,
    17931780                       int enable_ir,
    1794                        uint subsystem,
    1795                        struct snd_emu10k1 **remu)
     1781                       uint subsystem)
    17961782{
    1797         struct snd_emu10k1 *emu;
     1783        struct snd_emu10k1 *emu = card->private_data;
    17981784        int idx, err;
    17991785        int is_audigy;
    … …  
    18021788        unsigned int silent_page;
    18031789        const struct snd_emu_chip_details *c;
    1804         static const struct snd_device_ops ops = {
    1805                 .dev_free =     snd_emu10k1_dev_free,
    1806         };
    1807 
    1808         *remu = NULL;
    18091790
    18101791        /* enable PCI device */
    1811         err = pci_enable_device(pci);
     1792        err = pcim_enable_device(pci);
    18121793        if (err < 0)
    18131794                return err;
    18141795
    1815         emu = kzalloc(sizeof(*emu), GFP_KERNEL);
    1816         if (emu == NULL) {
    1817                 pci_disable_device(pci);
    1818                 return -ENOMEM;
    1819         }
     1796        card->private_free = snd_emu10k1_free;
    18201797        emu->card = card;
    18211798        spin_lock_init(&emu->reg_lock);
    … …  
    18641841        if (c->vendor == 0) {
    18651842                dev_err(card->dev, "emu10k1: Card not recognised\n");
    1866                 kfree(emu);
    1867                 pci_disable_device(pci);
    18681843                return -ENOENT;
    18691844        }
    … …  
    18971872                        "architecture does not support PCI busmaster DMA with mask 0x%lx\n",
    18981873                        emu->dma_mask);
    1899                 kfree(emu);
    1900                 pci_disable_device(pci);
    19011874                return -ENXIO;
    19021875        }
    … …  
    19071880
    19081881        err = pci_request_regions(pci, "EMU10K1");
    1909         if (err < 0) {
    1910                 kfree(emu);
    1911                 pci_disable_device(pci);
     1882        if (err < 0)
    19121883                return err;
    1913         }
    19141884        emu->port = pci_resource_start(pci, 0);
    19151885
    … …  
    19191889                                         MAXPAGES0);
    19201890        if (snd_emu10k1_alloc_pages_maybe_wider(emu, page_table_size,
    1921                                                 &emu->ptb_pages) < 0) {
    1922                 err = -ENOMEM;
    1923                 goto error;
    1924         }
     1891                                                &emu->ptb_pages) < 0)
     1892                return -ENOMEM;
    19251893        dev_dbg(card->dev, "page table address range is %.8lx:%.8lx\n",
    19261894                (unsigned long)emu->ptb_pages.addr,
    … …  
    19371905                                       sizeof(unsigned long));
    19381906#endif
    1939         if (emu->page_ptr_table == NULL || emu->page_addr_table == NULL) {
    1940                 err = -ENOMEM;
    1941                 goto error;
    1942         }
     1907
     1908        if (!emu->page_ptr_table || !emu->page_addr_table)
     1909                return -ENOMEM;
    19431910
    19441911        if (snd_emu10k1_alloc_pages_maybe_wider(emu, EMUPAGESIZE,
    1945                                                 &emu->silent_page) < 0) {
    1946                 err = -ENOMEM;
    1947                 goto error;
    1948         }
     1912                                                &emu->silent_page) < 0)
     1913                return -ENOMEM;
    19491914        dev_dbg(card->dev, "silent page range is %.8lx:%.8lx\n",
    19501915                (unsigned long)emu->silent_page.addr,
    … …  
    19531918
    19541919        emu->memhdr = snd_util_memhdr_new(emu->max_cache_pages * PAGE_SIZE);
    1955         if (emu->memhdr == NULL) {
    1956                 err = -ENOMEM;
    1957                 goto error;
    1958         }
     1920        if (!emu->memhdr)
     1921                return -ENOMEM;
    19591922        emu->memhdr->block_extra_size = sizeof(struct snd_emu10k1_memblk) -
    19601923                sizeof(struct snd_util_memblk);
    … …  
    19741937                err = snd_emu10k1_cardbus_init(emu);
    19751938                if (err < 0)
    1976                         goto error;
     1939                        return err;
    19771940        }
    19781941        if (emu->card_capabilities->ecard) {
    19791942                err = snd_emu10k1_ecard_init(emu);
    19801943                if (err < 0)
    1981                         goto error;
     1944                        return err;
    19821945        } else if (emu->card_capabilities->emu_model) {
    19831946                err = snd_emu10k1_emu1010_init(emu);
    1984                 if (err < 0) {
    1985                         snd_emu10k1_free(emu);
     1947                if (err < 0)
    19861948                        return err;
    1987                 }
    19881949        } else {
    19891950                /* 5.1: Enable the additional AC97 Slots. If the emu10k1 version
    … …  
    19991960
    20001961        /* irq handler must be registered after I/O ports are activated */
    2001         if (request_irq(pci->irq, snd_emu10k1_interrupt, IRQF_SHARED,
    2002                         KBUILD_MODNAME, emu)) {
    2003                 err = -EBUSY;
    2004                 goto error;
    2005         }
     1962        if (devm_request_irq(&pci->dev, pci->irq, snd_emu10k1_interrupt,
     1963                             IRQF_SHARED, KBUILD_MODNAME, emu))
     1964                return -EBUSY;
    20061965        emu->irq = pci->irq;
    20071966        card->sync_irq = emu->irq;
    … …  
    20422001        err = snd_emu10k1_init(emu, enable_ir, 0);
    20432002        if (err < 0)
    2044                 goto error;
     2003                return err;
    20452004#ifdef CONFIG_PM_SLEEP
    20462005        err = alloc_pm_buffer(emu);
    20472006        if (err < 0)
    2048                 goto error;
     2007                return err;
    20492008#endif
    20502009
    … …  
    20522011        err = snd_emu10k1_init_efx(emu);
    20532012        if (err < 0)
    2054                 goto error;
     2013                return err;
    20552014        snd_emu10k1_audio_enable(emu);
    2056 
    2057         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, emu, &ops);
    2058         if (err < 0)
    2059                 goto error;
    20602015
    20612016#ifdef CONFIG_SND_PROC_FS
    20622017        snd_emu10k1_proc_init(emu);
    20632018#endif
    2064 
    2065         *remu = emu;
    20662019        return 0;
    2067 
    2068  error:
    2069         snd_emu10k1_free(emu);
    2070         return err;
    20712020}
    20722021

  • GPL/trunk/alsa-kernel/pci/emu10k1/emu10k1x.c

    r703 r717  
    220220
    221221        unsigned long port;
    222         struct resource *res_port;
    223222        int irq;
    224223
    … …  
    237236        u32 spdif_bits[3]; // SPDIF out setup
    238237
    239         struct snd_dma_buffer dma_buffer;
     238        struct snd_dma_buffer *dma_buffer;
    240239
    241240        struct emu10k1x_midi midi;
    … …  
    446445        struct emu10k1x_pcm *epcm = runtime->private_data;
    447446        int voice = epcm->voice->number;
    448         u32 *table_base = (u32 *)(emu->dma_buffer.area+1024*voice);
     447        u32 *table_base = (u32 *)(emu->dma_buffer->area+1024*voice);
    449448        u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    450449        int i;
    … …  
    455454        }
    456455
    457         snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_ADDR, voice, emu->dma_buffer.addr+1024*voice);
     456        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_ADDR, voice, emu->dma_buffer->addr+1024*voice);
    458457        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_SIZE, voice, (runtime->periods - 1) << 19);
    459458        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_PTR, voice, 0);
    … …  
    741740}
    742741
    743 static int snd_emu10k1x_free(struct emu10k1x *chip)
    744 {
     742static void snd_emu10k1x_free(struct snd_card *card)
     743{
     744        struct emu10k1x *chip = card->private_data;
     745
    745746        snd_emu10k1x_ptr_write(chip, TRIGGER_CHANNEL, 0, 0);
    746747        // disable interrupts
    … …  
    748749        // disable audio
    749750        outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG);
    750 
    751         /* release the irq */
    752         if (chip->irq >= 0)
    753                 free_irq(chip->irq, chip);
    754 
    755         // release the i/o port
    756         release_and_free_resource(chip->res_port);
    757 
    758         // release the DMA
    759         if (chip->dma_buffer.area) {
    760                 snd_dma_free_pages(&chip->dma_buffer);
    761         }
    762 
    763         pci_disable_device(chip->pci);
    764 
    765         // release the data
    766         kfree(chip);
    767         return 0;
    768 }
    769 
    770 static int snd_emu10k1x_dev_free(struct snd_device *device)
    771 {
    772         struct emu10k1x *chip = device->device_data;
    773         return snd_emu10k1x_free(chip);
    774751}
    775752
    … …  
    889866
    890867static int snd_emu10k1x_create(struct snd_card *card,
    891                                struct pci_dev *pci,
    892                                struct emu10k1x **rchip)
    893 {
    894         struct emu10k1x *chip;
     868                               struct pci_dev *pci)
     869{
     870        struct emu10k1x *chip = card->private_data;
    895871        int err;
    896872        int ch;
    897         static const struct snd_device_ops ops = {
    898                 .dev_free = snd_emu10k1x_dev_free,
    899         };
    900 
    901         *rchip = NULL;
    902 
    903         err = pci_enable_device(pci);
     873
     874        err = pcim_enable_device(pci);
    904875        if (err < 0)
    905876                return err;
    … …  
    907878        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28)) < 0) {
    908879                dev_err(card->dev, "error to set 28bit mask DMA\n");
    909                 pci_disable_device(pci);
    910880                return -ENXIO;
    911         }
    912 
    913         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    914         if (chip == NULL) {
    915                 pci_disable_device(pci);
    916                 return -ENOMEM;
    917881        }
    918882
    … …  
    924888        spin_lock_init(&chip->voice_lock);
    925889 
     890        err = pci_request_regions(pci, "EMU10K1X");
     891        if (err < 0)
     892                return err;
    926893        chip->port = pci_resource_start(pci, 0);
    927         chip->res_port = request_region(chip->port, 8, "EMU10K1X");
    928         if (!chip->res_port) {
    929                 dev_err(card->dev, "cannot allocate the port 0x%lx\n",
    930                         chip->port);
    931                 snd_emu10k1x_free(chip);
    932                 return -EBUSY;
    933         }
    934 
    935         if (request_irq(pci->irq, snd_emu10k1x_interrupt,
    936                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
     894
     895        if (devm_request_irq(&pci->dev, pci->irq, snd_emu10k1x_interrupt,
     896                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    937897                dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
    938                 snd_emu10k1x_free(chip);
    939898                return -EBUSY;
    940899        }
    941900        chip->irq = pci->irq;
    942901        card->sync_irq = chip->irq;
     902        card->private_free = snd_emu10k1x_free;
    943903 
    944         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    945                                 4 * 1024, &chip->dma_buffer) < 0) {
    946                 snd_emu10k1x_free(chip);
     904        chip->dma_buffer = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
     905                                                4 * 1024);
     906        if (!chip->dma_buffer)
    947907                return -ENOMEM;
    948         }
    949908
    950909        pci_set_master(pci);
    … …  
    1006965        outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG);
    1007966
    1008         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1009         if (err < 0) {
    1010                 snd_emu10k1x_free(chip);
    1011                 return err;
    1012         }
    1013         *rchip = chip;
    1014967        return 0;
    1015968}
    … …  
    15461499}
    15471500
    1548 static int snd_emu10k1x_probe(struct pci_dev *pci,
    1549                               const struct pci_device_id *pci_id)
     1501static int __snd_emu10k1x_probe(struct pci_dev *pci,
     1502                                const struct pci_device_id *pci_id)
    15501503{
    15511504        static int dev;
    … …  
    15611514        }
    15621515
    1563         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1564                            0, &card);
    1565         if (err < 0)
    1566                 return err;
    1567 
    1568         err = snd_emu10k1x_create(card, pci, &chip);
    1569         if (err < 0) {
    1570                 snd_card_free(card);
    1571                 return err;
    1572         }
     1516        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1517                                sizeof(*chip), &card);
     1518        if (err < 0)
     1519                return err;
     1520        chip = card->private_data;
     1521
     1522        err = snd_emu10k1x_create(card, pci);
     1523        if (err < 0)
     1524                return err;
    15731525
    15741526        err = snd_emu10k1x_pcm(chip, 0);
    1575         if (err < 0) {
    1576                 snd_card_free(card);
    1577                 return err;
    1578         }
     1527        if (err < 0)
     1528                return err;
    15791529        err = snd_emu10k1x_pcm(chip, 1);
    1580         if (err < 0) {
    1581                 snd_card_free(card);
    1582                 return err;
    1583         }
     1530        if (err < 0)
     1531                return err;
    15841532        err = snd_emu10k1x_pcm(chip, 2);
    1585         if (err < 0) {
    1586                 snd_card_free(card);
    1587                 return err;
    1588         }
     1533        if (err < 0)
     1534                return err;
    15891535
    15901536        err = snd_emu10k1x_ac97(chip);
    1591         if (err < 0) {
    1592                 snd_card_free(card);
    1593                 return err;
    1594         }
     1537        if (err < 0)
     1538                return err;
    15951539
    15961540        err = snd_emu10k1x_mixer(chip);
    1597         if (err < 0) {
    1598                 snd_card_free(card);
    1599                 return err;
    1600         }
     1541        if (err < 0)
     1542                return err;
    16011543       
    16021544        err = snd_emu10k1x_midi(chip);
    1603         if (err < 0) {
    1604                 snd_card_free(card);
    1605                 return err;
    1606         }
     1545        if (err < 0)
     1546                return err;
    16071547
    16081548        snd_emu10k1x_proc_init(chip);
    … …  
    16141554
    16151555        err = snd_card_register(card);
    1616         if (err < 0) {
    1617                 snd_card_free(card);
    1618                 return err;
    1619         }
     1556        if (err < 0)
     1557                return err;
    16201558
    16211559        pci_set_drvdata(pci, card);
    … …  
    16241562}
    16251563
    1626 static void snd_emu10k1x_remove(struct pci_dev *pci)
    1627 {
    1628         snd_card_free(pci_get_drvdata(pci));
     1564static int snd_emu10k1x_probe(struct pci_dev *pci,
     1565                              const struct pci_device_id *pci_id)
     1566{
     1567        return snd_card_free_on_error(&pci->dev, __snd_emu10k1x_probe(pci, pci_id));
    16291568}
    16301569
    … …  
    16411580        .id_table = snd_emu10k1x_ids,
    16421581        .probe = snd_emu10k1x_probe,
    1643         .remove = snd_emu10k1x_remove,
    16441582};
    16451583

  • GPL/trunk/alsa-kernel/pci/emu10k1/p16v.c

    r703 r717  
    291291        struct snd_pcm_runtime *runtime = substream->runtime;
    292292        int channel = substream->pcm->device - emu->p16v_device_offset;
    293         u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel));
     293        u32 *table_base = (u32 *)(emu->p16v_buffer->area+(8*16*channel));
    294294        u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    295295        int i;
    … …  
    309309        dev_dbg(emu->card->dev,
    310310                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    311                    emu->p16v_buffer.addr, emu->p16v_buffer.area,
    312                    emu->p16v_buffer.bytes);
     311                   emu->p16v_buffer->addr, emu->p16v_buffer->area,
     312                   emu->p16v_buffer->bytes);
    313313#endif /* debug */
    314314        tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
    … …  
    334334        }
    335335 
    336         snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer.addr+(8*16*channel));
     336        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer->addr+(8*16*channel));
    337337        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
    338338        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_PTR, channel, 0);
    … …  
    567567        .pointer =     snd_p16v_pcm_pointer_capture,
    568568};
    569 
    570 
    571 int snd_p16v_free(struct snd_emu10k1 *chip)
    572 {
    573         // release the data
    574         if (chip->p16v_buffer.area) {
    575                 snd_dma_free_pages(&chip->p16v_buffer);
    576                 /*
    577                 dev_dbg(chip->card->dev, "period lables free: %p\n",
    578                            &chip->p16v_buffer);
    579                 */
    580         }
    581         return 0;
    582 }
    583569
    584570int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)

  • GPL/trunk/alsa-kernel/pci/ens1370.c

    r703 r717  
    418418
    419419#ifdef CHIP1370
    420         struct snd_dma_buffer dma_bug;
     420        struct snd_dma_buffer *dma_bug;
    421421#endif
    422422
    … …  
    18761876 */
    18771877
    1878 static int snd_ensoniq_free(struct ensoniq *ensoniq)
    1879 {
     1878static void snd_ensoniq_free(struct snd_card *card)
     1879{
     1880        struct ensoniq *ensoniq = card->private_data;
     1881
    18801882        snd_ensoniq_free_gameport(ensoniq);
    1881         if (ensoniq->irq < 0)
    1882                 goto __hw_end;
    18831883#ifdef CHIP1370
    18841884        outl(ES_1370_SERR_DISABLE, ES_REG(ensoniq, CONTROL));   /* switch everything off */
    … …  
    18881888        outl(0, ES_REG(ensoniq, SERIAL));       /* clear serial interface */
    18891889#endif
    1890         pci_set_power_state(ensoniq->pci, PCI_D3hot);
    1891       __hw_end:
    1892 #ifdef CHIP1370
    1893         if (ensoniq->dma_bug.area)
    1894                 snd_dma_free_pages(&ensoniq->dma_bug);
    1895 #endif
    1896         if (ensoniq->irq >= 0)
    1897                 free_irq(ensoniq->irq, ensoniq);
    1898         pci_release_regions(ensoniq->pci);
    1899         pci_disable_device(ensoniq->pci);
    1900         kfree(ensoniq);
    1901         return 0;
    1902 }
    1903 
    1904 static int snd_ensoniq_dev_free(struct snd_device *device)
    1905 {
    1906         struct ensoniq *ensoniq = device->device_data;
    1907         return snd_ensoniq_free(ensoniq);
    19081890}
    19091891
    … …  
    19391921        outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL));
    19401922        outl(ES_MEM_PAGEO(ES_PAGE_ADC), ES_REG(ensoniq, MEM_PAGE));
    1941         outl(ensoniq->dma_bug.addr, ES_REG(ensoniq, PHANTOM_FRAME));
     1923        outl(ensoniq->dma_bug->addr, ES_REG(ensoniq, PHANTOM_FRAME));
    19421924        outl(0, ES_REG(ensoniq, PHANTOM_COUNT));
    19431925#else
    … …  
    20362018
    20372019static int snd_ensoniq_create(struct snd_card *card,
    2038                               struct pci_dev *pci,
    2039                               struct ensoniq **rensoniq)
    2040 {
    2041         struct ensoniq *ensoniq;
     2020                              struct pci_dev *pci)
     2021{
     2022        struct ensoniq *ensoniq = card->private_data;
    20422023        int err;
    2043         static const struct snd_device_ops ops = {
    2044                 .dev_free =     snd_ensoniq_dev_free,
    2045         };
    2046 
    2047         *rensoniq = NULL;
    2048         err = pci_enable_device(pci);
     2024
     2025        err = pcim_enable_device(pci);
    20492026        if (err < 0)
    20502027                return err;
    2051         ensoniq = kzalloc(sizeof(*ensoniq), GFP_KERNEL);
    2052         if (ensoniq == NULL) {
    2053                 pci_disable_device(pci);
    2054                 return -ENOMEM;
    2055         }
    20562028        spin_lock_init(&ensoniq->reg_lock);
    20572029        mutex_init(&ensoniq->src_mutex);
    … …  
    20602032        ensoniq->irq = -1;
    20612033        err = pci_request_regions(pci, "Ensoniq AudioPCI");
    2062         if (err < 0) {
    2063                 kfree(ensoniq);
    2064                 pci_disable_device(pci);
     2034        if (err < 0)
    20652035                return err;
    2066         }
    20672036        ensoniq->port = pci_resource_start(pci, 0);
     2037#ifndef TARGET_OS2
     2038        if (devm_request_irq(&pci->dev, pci->irq, snd_audiopci_interrupt,
     2039                             IRQF_SHARED, KBUILD_MODNAME, ensoniq)) {
     2040                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     2041                return -EBUSY;
     2042        }
     2043#else
    20682044        if (request_irq(pci->irq, snd_audiopci_interrupt, IRQF_SHARED,
    20692045                        KBUILD_MODNAME, ensoniq)) {
    20702046                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    2071                 snd_ensoniq_free(ensoniq);
     2047                snd_ensoniq_free(card);
    20722048                return -EBUSY;
    20732049        }
     2050#endif
    20742051        ensoniq->irq = pci->irq;
    20752052        card->sync_irq = ensoniq->irq;
    20762053#ifdef CHIP1370
    2077         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    2078                                 16, &ensoniq->dma_bug) < 0) {
    2079                 dev_err(card->dev, "unable to allocate space for phantom area - dma_bug\n");
    2080                 snd_ensoniq_free(ensoniq);
    2081                 return -EBUSY;
    2082         }
     2054        ensoniq->dma_bug =
     2055                snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 16);
     2056        if (!ensoniq->dma_bug)
     2057                return -ENOMEM;
    20832058#endif
    20842059        pci_set_master(pci);
    … …  
    21072082#endif
    21082083
     2084        card->private_free = snd_ensoniq_free;
    21092085        snd_ensoniq_chip_init(ensoniq);
    21102086
    2111         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ensoniq, &ops);
    2112         if (err < 0) {
    2113                 snd_ensoniq_free(ensoniq);
    2114                 return err;
    2115         }
    2116 
    21172087        snd_ensoniq_proc_init(ensoniq);
    2118 
    2119         *rensoniq = ensoniq;
    21202088        return 0;
    21212089}
    … …  
    23532321}
    23542322
    2355 static int snd_audiopci_probe(struct pci_dev *pci,
    2356                               const struct pci_device_id *pci_id)
     2323static int __snd_audiopci_probe(struct pci_dev *pci,
     2324                                const struct pci_device_id *pci_id)
    23572325{
    23582326        static int dev;
    … …  
    23682336        }
    23692337
    2370         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2371                            0, &card);
     2338        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2339                                sizeof(*ensoniq), &card);
    23722340        if (err < 0)
    23732341                return err;
    2374 
    2375         err = snd_ensoniq_create(card, pci, &ensoniq);
    2376         if (err < 0) {
    2377                 snd_card_free(card);
     2342        ensoniq = card->private_data;
     2343
     2344        err = snd_ensoniq_create(card, pci);
     2345        if (err < 0)
    23782346                return err;
    2379         }
    2380         card->private_data = ensoniq;
    23812347
    23822348#ifdef CHIP1370
    23832349        err = snd_ensoniq_1370_mixer(ensoniq);
    2384         if (err < 0) {
    2385                 snd_card_free(card);
     2350        if (err < 0)
    23862351                return err;
    2387         }
    23882352#endif
    23892353#ifdef CHIP1371
    23902354        err = snd_ensoniq_1371_mixer(ensoniq, spdif[dev], lineio[dev]);
    2391         if (err < 0) {
    2392                 snd_card_free(card);
     2355        if (err < 0)
    23932356                return err;
    2394         }
    23952357#endif
    23962358        err = snd_ensoniq_pcm(ensoniq, 0);
    2397         if (err < 0) {
    2398                 snd_card_free(card);
     2359        if (err < 0)
    23992360                return err;
    2400         }
    24012361        err = snd_ensoniq_pcm2(ensoniq, 1);
    2402         if (err < 0) {
    2403                 snd_card_free(card);
     2362        if (err < 0)
    24042363                return err;
    2405         }
    24062364        err = snd_ensoniq_midi(ensoniq, 0);
    2407         if (err < 0) {
    2408                 snd_card_free(card);
     2365        if (err < 0)
    24092366                return err;
    2410         }
    24112367
    24122368        snd_ensoniq_create_gameport(ensoniq, dev);
    … …  
    24222378
    24232379        err = snd_card_register(card);
    2424         if (err < 0) {
    2425                 snd_card_free(card);
     2380        if (err < 0)
    24262381                return err;
    2427         }
    24282382
    24292383        pci_set_drvdata(pci, card);
    … …  
    24322386}
    24332387
    2434 static void snd_audiopci_remove(struct pci_dev *pci)
    2435 {
    2436         snd_card_free(pci_get_drvdata(pci));
     2388static int snd_audiopci_probe(struct pci_dev *pci,
     2389                              const struct pci_device_id *pci_id)
     2390{
     2391        return snd_card_free_on_error(&pci->dev, __snd_audiopci_probe(pci, pci_id));
    24372392}
    24382393
    … …  
    24412396        .id_table = snd_audiopci_ids,
    24422397        .probe = snd_audiopci_probe,
    2443         .remove = snd_audiopci_remove,
    24442398        .driver = {
    24452399                .pm = SND_ENSONIQ_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/es1938.c

    r703 r717  
    15571557#endif /* SUPPORT_JOYSTICK */
    15581558
    1559 static int snd_es1938_free(struct es1938 *chip)
    1560 {
     1559static void snd_es1938_free(struct snd_card *card)
     1560{
     1561        struct es1938 *chip = card->private_data;
     1562
    15611563        /* disable irqs */
    15621564        outb(0x00, SLIO_REG(chip, IRQCONTROL));
    … …  
    15681570        if (chip->irq >= 0)
    15691571                free_irq(chip->irq, chip);
    1570         pci_release_regions(chip->pci);
    1571         pci_disable_device(chip->pci);
    1572         kfree(chip);
    1573         return 0;
    1574 }
    1575 
    1576 static int snd_es1938_dev_free(struct snd_device *device)
    1577 {
    1578         struct es1938 *chip = device->device_data;
    1579         return snd_es1938_free(chip);
    15801572}
    15811573
    15821574static int snd_es1938_create(struct snd_card *card,
    1583                              struct pci_dev *pci,
    1584                              struct es1938 **rchip)
    1585 {
    1586         struct es1938 *chip;
     1575                             struct pci_dev *pci)
     1576{
     1577        struct es1938 *chip = card->private_data;
    15871578        int err;
    1588         static const struct snd_device_ops ops = {
    1589                 .dev_free =     snd_es1938_dev_free,
    1590         };
    1591 
    1592         *rchip = NULL;
    15931579
    15941580        /* enable PCI device */
    1595         err = pci_enable_device(pci);
     1581        err = pcim_enable_device(pci);
    15961582        if (err < 0)
    15971583                return err;
    … …  
    16001586                dev_err(card->dev,
    16011587                        "architecture does not support 24bit PCI busmaster DMA\n");
    1602                 pci_disable_device(pci);
    16031588                return -ENXIO;
    16041589        }
    16051590
    1606         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1607         if (chip == NULL) {
    1608                 pci_disable_device(pci);
    1609                 return -ENOMEM;
    1610         }
    16111591        spin_lock_init(&chip->reg_lock);
    16121592        spin_lock_init(&chip->mixer_lock);
    … …  
    16151595        chip->irq = -1;
    16161596        err = pci_request_regions(pci, "ESS Solo-1");
    1617         if (err < 0) {
    1618                 kfree(chip);
    1619                 pci_disable_device(pci);
     1597        if (err < 0)
    16201598                return err;
    1621         }
    16221599        chip->io_port = pci_resource_start(pci, 0);
    16231600        chip->sb_port = pci_resource_start(pci, 1);
    … …  
    16251602        chip->mpu_port = pci_resource_start(pci, 3);
    16261603        chip->game_port = pci_resource_start(pci, 4);
     1604        /* still use non-managed irq handler as it's re-acquired at PM resume */
    16271605        if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
    16281606                        KBUILD_MODNAME, chip)) {
    16291607                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    1630                 snd_es1938_free(chip);
    16311608                return -EBUSY;
    16321609        }
    16331610        chip->irq = pci->irq;
    16341611        card->sync_irq = chip->irq;
     1612        card->private_free = snd_es1938_free;
    16351613        dev_dbg(card->dev,
    16361614                "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
    … …  
    16401618
    16411619        snd_es1938_chip_init(chip);
    1642 
    1643         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1644         if (err < 0) {
    1645                 snd_es1938_free(chip);
    1646                 return err;
    1647         }
    1648 
    1649         *rchip = chip;
    16501620        return 0;
    16511621}
    … …  
    17821752       
    17831753
    1784 static int snd_es1938_probe(struct pci_dev *pci,
    1785                             const struct pci_device_id *pci_id)
     1754static int __snd_es1938_probe(struct pci_dev *pci,
     1755                              const struct pci_device_id *pci_id)
    17861756{
    17871757        static int dev;
    … …  
    17981768        }
    17991769
    1800         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1801                            0, &card);
     1770        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1771                                sizeof(*chip), &card);
    18021772        if (err < 0)
    18031773                return err;
    1804         for (idx = 0; idx < 5; idx++) {
     1774        chip = card->private_data;
     1775
     1776        for (idx = 0; idx < 5; idx++)
    18051777                if (pci_resource_start(pci, idx) == 0 ||
    1806                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
    1807                         snd_card_free(card);
    1808                         return -ENODEV;
    1809                 }
    1810         }
    1811         err = snd_es1938_create(card, pci, &chip);
    1812         if (err < 0) {
    1813                 snd_card_free(card);
     1778                    !(pci_resource_flags(pci, idx) & IORESOURCE_IO))
     1779                        return -ENODEV;
     1780
     1781        err = snd_es1938_create(card, pci);
     1782        if (err < 0)
    18141783                return err;
    1815         }
    1816         card->private_data = chip;
    18171784
    18181785        strcpy(card->driver, "ES1938");
    … …  
    18241791
    18251792        err = snd_es1938_new_pcm(chip, 0);
    1826         if (err < 0) {
    1827                 snd_card_free(card);
     1793        if (err < 0)
    18281794                return err;
    1829         }
    18301795        err = snd_es1938_mixer(chip);
    1831         if (err < 0) {
    1832                 snd_card_free(card);
     1796        if (err < 0)
    18331797                return err;
    1834         }
    18351798        if (snd_opl3_create(card,
    18361799                            SLSB_REG(chip, FMLOWADDR),
    … …  
    18411804        } else {
    18421805                err = snd_opl3_timer_new(opl3, 0, 1);
    1843                 if (err < 0) {
    1844                         snd_card_free(card);
     1806                if (err < 0)
    18451807                        return err;
    1846                 }
    18471808                err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    1848                 if (err < 0) {
    1849                         snd_card_free(card);
     1809                if (err < 0)
    18501810                        return err;
    1851                 }
    18521811        }
    18531812        if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
    … …  
    18651824
    18661825        err = snd_card_register(card);
    1867         if (err < 0) {
    1868                 snd_card_free(card);
     1826        if (err < 0)
    18691827                return err;
    1870         }
    18711828
    18721829        pci_set_drvdata(pci, card);
    … …  
    18751832}
    18761833
    1877 static void snd_es1938_remove(struct pci_dev *pci)
    1878 {
    1879         snd_card_free(pci_get_drvdata(pci));
     1834static int snd_es1938_probe(struct pci_dev *pci,
     1835                            const struct pci_device_id *pci_id)
     1836{
     1837        return snd_card_free_on_error(&pci->dev, __snd_es1938_probe(pci, pci_id));
    18801838}
    18811839
    … …  
    18841842        .id_table = snd_es1938_ids,
    18851843        .probe = snd_es1938_probe,
    1886         .remove = snd_es1938_remove,
    18871844        .driver = {
    18881845                .pm = ES1938_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/es1968.c

    r703 r717  
    24792479                return -ENODEV;
    24802480
    2481         r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
     2481        r = devm_request_region(&chip->pci->dev, JOYSTICK_ADDR, 8,
     2482                                "ES1968 gameport");
    24822483        if (!r)
    24832484                return -EBUSY;
    … …  
    24872488                dev_err(chip->card->dev,
    24882489                        "cannot allocate memory for gameport\n");
    2489                 release_and_free_resource(r);
    24902490                return -ENOMEM;
    24912491        }
    … …  
    24982498        gameport_set_dev_parent(gp, &chip->pci->dev);
    24992499        gp->io = JOYSTICK_ADDR;
    2500         gameport_set_port_data(gp, r);
    25012500
    25022501        gameport_register_port(gp);
    … …  
    25082507{
    25092508        if (chip->gameport) {
    2510                 struct resource *r = gameport_get_port_data(chip->gameport);
    2511 
    25122509                gameport_unregister_port(chip->gameport);
    25132510                chip->gameport = NULL;
    2514 
    2515                 release_and_free_resource(r);
    25162511        }
    25172512}
    … …  
    25272522        int err;
    25282523
    2529         input_dev = input_allocate_device();
     2524        input_dev = devm_input_allocate_device(&chip->pci->dev);
    25302525        if (!input_dev)
    25312526                return -ENOMEM;
    … …  
    25472542
    25482543        err = input_register_device(input_dev);
    2549         if (err) {
    2550                 input_free_device(input_dev);
     2544        if (err)
    25512545                return err;
    2552         }
    25532546
    25542547        chip->input_dev = input_dev;
    … …  
    26342627#endif
    26352628
    2636 static int snd_es1968_free(struct es1968 *chip)
    2637 {
     2629static void snd_es1968_free(struct snd_card *card)
     2630{
     2631        struct es1968 *chip = card->private_data;
     2632
    26382633        cancel_work_sync(&chip->hwvol_work);
    2639 #ifdef CONFIG_SND_ES1968_INPUT
    2640         if (chip->input_dev)
    2641                 input_unregister_device(chip->input_dev);
    2642 #endif
    26432634
    26442635        if (chip->io_port) {
    … …  
    26522643#endif
    26532644
    2654         if (chip->irq >= 0)
    2655                 free_irq(chip->irq, chip);
    26562645        snd_es1968_free_gameport(chip);
    2657         pci_release_regions(chip->pci);
    2658         pci_disable_device(chip->pci);
    2659         kfree(chip);
    2660         return 0;
    2661 }
    2662 
    2663 static int snd_es1968_dev_free(struct snd_device *device)
    2664 {
    2665         struct es1968 *chip = device->device_data;
    2666         return snd_es1968_free(chip);
    26672646}
    26682647
    … …  
    26942673                             int chip_type,
    26952674                             int do_pm,
    2696                              int radio_nr,
    2697                              struct es1968 **chip_ret)
    2698 {
    2699         static const struct snd_device_ops ops = {
    2700                 .dev_free =     snd_es1968_dev_free,
    2701         };
    2702         struct es1968 *chip;
     2675                             int radio_nr)
     2676{
     2677        struct es1968 *chip = card->private_data;
    27032678        int i, err;
    27042679
    2705         *chip_ret = NULL;
    2706 
    27072680        /* enable PCI device */
    2708         err = pci_enable_device(pci);
     2681        err = pcim_enable_device(pci);
    27092682        if (err < 0)
    27102683                return err;
    … …  
    27132686                dev_err(card->dev,
    27142687                        "architecture does not support 28bit PCI busmaster DMA\n");
    2715                 pci_disable_device(pci);
    27162688                return -ENXIO;
    2717         }
    2718 
    2719         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2720         if (! chip) {
    2721                 pci_disable_device(pci);
    2722                 return -ENOMEM;
    27232689        }
    27242690
    … …  
    27392705
    27402706        err = pci_request_regions(pci, "ESS Maestro");
    2741         if (err < 0) {
    2742                 kfree(chip);
    2743                 pci_disable_device(pci);
     2707        if (err < 0)
    27442708                return err;
    2745         }
    27462709        chip->io_port = pci_resource_start(pci, 0);
    2747         if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
    2748                         KBUILD_MODNAME, chip)) {
     2710        if (devm_request_irq(&pci->dev, pci->irq, snd_es1968_interrupt,
     2711                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    27492712                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    2750                 snd_es1968_free(chip);
    27512713                return -EBUSY;
    27522714        }
    27532715        chip->irq = pci->irq;
    27542716        card->sync_irq = chip->irq;
     2717        card->private_free = snd_es1968_free;
    27552718               
    27562719        /* Clear Maestro_map */
    … …  
    27862749        snd_es1968_chip_init(chip);
    27872750
    2788         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2789         if (err < 0) {
    2790                 snd_es1968_free(chip);
    2791                 return err;
    2792         }
    2793 
    27942751#ifdef CONFIG_SND_ES1968_RADIO
    27952752        /* don't play with GPIOs on laptops */
    27962753        if (chip->pci->subsystem_vendor != 0x125d)
    2797                 goto no_radio;
     2754                return 0;
    27982755        err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
    2799         if (err < 0) {
    2800                 snd_es1968_free(chip);
     2756        if (err < 0)
    28012757                return err;
    2802         }
    28032758        chip->tea.v4l2_dev = &chip->v4l2_dev;
    28042759        chip->tea.private_data = chip;
    … …  
    28162771                }
    28172772        }
    2818 no_radio:
    28192773#endif
    2820 
    2821         *chip_ret = chip;
    2822 
    28232774        return 0;
    28242775}
    … …  
    28272778/*
    28282779 */
    2829 static int snd_es1968_probe(struct pci_dev *pci,
    2830                             const struct pci_device_id *pci_id)
     2780static int __snd_es1968_probe(struct pci_dev *pci,
     2781                              const struct pci_device_id *pci_id)
    28312782{
    28322783        static int dev;
    … …  
    28432794        }
    28442795
    2845         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2846                            0, &card);
     2796        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2797                                sizeof(*chip), &card);
    28472798        if (err < 0)
    28482799                return err;
     2800        chip = card->private_data;
    28492801               
    28502802        if (total_bufsize[dev] < 128)
    … …  
    28582810                                pci_id->driver_data,
    28592811                                use_pm[dev],
    2860                                 radio_nr[dev],
    2861                                 &chip);
    2862         if (err < 0) {
    2863                 snd_card_free(card);
     2812                                radio_nr[dev]);
     2813        if (err < 0)
    28642814                return err;
    2865         }
    2866         card->private_data = chip;
    28672815
    28682816        switch (chip->type) {
    … …  
    28822830
    28832831        err = snd_es1968_pcm(chip, 0);
    2884         if (err < 0) {
    2885                 snd_card_free(card);
     2832        if (err < 0)
    28862833                return err;
    2887         }
    28882834
    28892835        err = snd_es1968_mixer(chip);
    2890         if (err < 0) {
    2891                 snd_card_free(card);
     2836        if (err < 0)
    28922837                return err;
    2893         }
    28942838
    28952839        if (enable_mpu[dev] == 2) {
    … …  
    29342878
    29352879        err = snd_card_register(card);
    2936         if (err < 0) {
    2937                 snd_card_free(card);
     2880        if (err < 0)
    29382881                return err;
    2939         }
    29402882        pci_set_drvdata(pci, card);
    29412883        dev++;
    … …  
    29432885}
    29442886
    2945 static void snd_es1968_remove(struct pci_dev *pci)
    2946 {
    2947         snd_card_free(pci_get_drvdata(pci));
     2887static int snd_es1968_probe(struct pci_dev *pci,
     2888                            const struct pci_device_id *pci_id)
     2889{
     2890        return snd_card_free_on_error(&pci->dev, __snd_es1968_probe(pci, pci_id));
    29482891}
    29492892
    … …  
    29522895        .id_table = snd_es1968_ids,
    29532896        .probe = snd_es1968_probe,
    2954         .remove = snd_es1968_remove,
    29552897        .driver = {
    29562898                .pm = ES1968_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/fm801.c

    r703 r717  
    10371037};
    10381038
    1039 static void snd_fm801_mixer_free_ac97_bus(struct snd_ac97_bus *bus)
    1040 {
    1041         struct fm801 *chip = bus->private_data;
    1042         chip->ac97_bus = NULL;
    1043 }
    1044 
    1045 static void snd_fm801_mixer_free_ac97(struct snd_ac97 *ac97)
    1046 {
    1047         struct fm801 *chip = ac97->private_data;
    1048         if (ac97->num == 0) {
    1049                 chip->ac97 = NULL;
    1050         } else {
    1051                 chip->ac97_sec = NULL;
    1052         }
    1053 }
    1054 
    10551039static int snd_fm801_mixer(struct fm801 *chip)
    10561040{
    … …  
    10661050        if (err < 0)
    10671051                return err;
    1068         chip->ac97_bus->private_free = snd_fm801_mixer_free_ac97_bus;
    10691052
    10701053        memset(&ac97, 0, sizeof(ac97));
    10711054        ac97.private_data = chip;
    1072         ac97.private_free = snd_fm801_mixer_free_ac97;
    10731055        err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97);
    10741056        if (err < 0)
    … …  
    11861168}
    11871169
    1188 static int snd_fm801_free(struct fm801 *chip)
    1189 {
     1170static void snd_fm801_free(struct snd_card *card)
     1171{
     1172        struct fm801 *chip = card->private_data;
    11901173        unsigned short cmdw;
    1191 
    1192         if (chip->irq < 0)
    1193                 goto __end_hw;
    11941174
    11951175        /* interrupt setup - mask everything */
    … …  
    11981178        fm801_writew(chip, IRQ_MASK, cmdw);
    11991179
    1200         devm_free_irq(chip->dev, chip->irq, chip);
    1201 
    1202       __end_hw:
    12031180#ifdef CONFIG_SND_FM801_TEA575X_BOOL
    12041181        if (!(chip->tea575x_tuner & TUNER_DISABLED)) {
    … …  
    12071184        }
    12081185#endif
    1209         return 0;
    1210 }
    1211 
    1212 static int snd_fm801_dev_free(struct snd_device *device)
    1213 {
    1214         struct fm801 *chip = device->device_data;
    1215         return snd_fm801_free(chip);
    1216 }
     1186}
     1187
    12171188
    12181189static int snd_fm801_create(struct snd_card *card,
    12191190                            struct pci_dev *pci,
    12201191                            int tea575x_tuner,
    1221                             int radio_nr,
    1222                             struct fm801 **rchip)
    1223 {
    1224         struct fm801 *chip;
     1192                            int radio_nr)
     1193{
     1194        struct fm801 *chip = card->private_data;
    12251195        int err;
    1226         static const struct snd_device_ops ops = {
    1227                 .dev_free =     snd_fm801_dev_free,
    1228         };
    1229 
    1230         *rchip = NULL;
     1196
    12311197#ifndef TARGET_OS2
    12321198        err = pcim_enable_device(pci);
    12331199        if (err < 0)
    12341200                return err;
    1235         chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL);
    12361201#else
    12371202        if ((err = pci_enable_device(pci)) < 0)
    12381203                return err;
    1239         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    12401204#endif
    1241         if (chip == NULL)
    1242                 return -ENOMEM;
    12431205        spin_lock_init(&chip->reg_lock);
    12441206        chip->card = card;
    … …  
    12771239#endif
    12781240                        dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    1279                         snd_fm801_free(chip);
    12801241                        return -EBUSY;
    12811242                }
    … …  
    12851246        }
    12861247
     1248        card->private_free = snd_fm801_free;
    12871249        snd_fm801_chip_init(chip);
    1288 
    1289         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1290         if (err < 0) {
    1291                 snd_fm801_free(chip);
    1292                 return err;
    1293         }
    12941250
    12951251#ifdef CONFIG_SND_FM801_TEA575X_BOOL
    12961252        err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
    1297         if (err < 0) {
    1298                 snd_fm801_free(chip);
    1299                 return err;
    1300         }
     1253        if (err < 0)
     1254                return err;
    13011255        chip->tea.v4l2_dev = &chip->v4l2_dev;
    13021256        chip->tea.radio_nr = radio_nr;
    … …  
    13081262                if (snd_tea575x_init(&chip->tea, THIS_MODULE)) {
    13091263                        dev_err(card->dev, "TEA575x radio not found\n");
    1310                         snd_fm801_free(chip);
    13111264                        return -ENODEV;
    13121265                }
    … …  
    13361289        }
    13371290#endif
    1338 
    1339         *rchip = chip;
    1340         return 0;
    1341 }
    1342 
    1343 static int snd_card_fm801_probe(struct pci_dev *pci,
    1344                                 const struct pci_device_id *pci_id)
     1291        return 0;
     1292}
     1293
     1294static int __snd_card_fm801_probe(struct pci_dev *pci,
     1295                                  const struct pci_device_id *pci_id)
    13451296{
    13461297        static int dev;
    … …  
    13571308        }
    13581309
    1359         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1360                            0, &card);
    1361         if (err < 0)
    1362                 return err;
    1363         err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev], &chip);
    1364         if (err < 0) {
    1365                 snd_card_free(card);
    1366                 return err;
    1367         }
    1368         card->private_data = chip;
     1310        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1311                                sizeof(*chip), &card);
     1312        if (err < 0)
     1313                return err;
     1314        chip = card->private_data;
     1315        err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev]);
     1316        if (err < 0)
     1317                return err;
    13691318
    13701319        strcpy(card->driver, "FM801");
    … …  
    13781327
    13791328        err = snd_fm801_pcm(chip, 0);
    1380         if (err < 0) {
    1381                 snd_card_free(card);
    1382                 return err;
    1383         }
     1329        if (err < 0)
     1330                return err;
    13841331        err = snd_fm801_mixer(chip);
    1385         if (err < 0) {
    1386                 snd_card_free(card);
    1387                 return err;
    1388         }
     1332        if (err < 0)
     1333                return err;
    13891334        err = snd_mpu401_uart_new(card, 0, MPU401_HW_FM801,
    13901335                                  chip->port + FM801_MPU401_DATA,
    … …  
    13921337                                  MPU401_INFO_IRQ_HOOK,
    13931338                                  -1, &chip->rmidi);
    1394         if (err < 0) {
    1395                 snd_card_free(card);
    1396                 return err;
    1397         }
     1339        if (err < 0)
     1340                return err;
    13981341        err = snd_opl3_create(card, chip->port + FM801_OPL3_BANK0,
    13991342                              chip->port + FM801_OPL3_BANK1,
    14001343                              OPL3_HW_OPL3_FM801, 1, &opl3);
    1401         if (err < 0) {
    1402                 snd_card_free(card);
    1403                 return err;
    1404         }
     1344        if (err < 0)
     1345                return err;
    14051346        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    1406         if (err < 0) {
    1407                 snd_card_free(card);
    1408                 return err;
    1409         }
     1347        if (err < 0)
     1348                return err;
    14101349
    14111350      __fm801_tuner_only:
    14121351        err = snd_card_register(card);
    1413         if (err < 0) {
    1414                 snd_card_free(card);
    1415                 return err;
    1416         }
     1352        if (err < 0)
     1353                return err;
    14171354        pci_set_drvdata(pci, card);
    14181355        dev++;
    … …  
    14201357}
    14211358
    1422 static void snd_card_fm801_remove(struct pci_dev *pci)
    1423 {
    1424         snd_card_free(pci_get_drvdata(pci));
     1359static int snd_card_fm801_probe(struct pci_dev *pci,
     1360                                const struct pci_device_id *pci_id)
     1361{
     1362        return snd_card_free_on_error(&pci->dev, __snd_card_fm801_probe(pci, pci_id));
    14251363}
    14261364
    … …  
    14921430        .id_table = snd_fm801_ids,
    14931431        .probe = snd_card_fm801_probe,
    1494         .remove = snd_card_fm801_remove,
    14951432        .driver = {
    14961433                .pm = SND_FM801_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/hda/hda_auto_parser.c

    r695 r717  
    828828}
    829829
    830 static void apply_fixup(struct hda_codec *codec, int id, int action, int depth)
     830void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth)
    831831{
    832832        const char *modelname = codec->fixup_name;
    … …  
    838838                        break;
    839839                if (fix->chained_before)
    840                         apply_fixup(codec, fix->chain_id, action, depth + 1);
     840                        __snd_hda_apply_fixup(codec, fix->chain_id, action, depth + 1);
    841841
    842842                switch (fix->type) {
    … …  
    879879        }
    880880}
     881EXPORT_SYMBOL_GPL(__snd_hda_apply_fixup);
    881882
    882883/**
    … …  
    888889{
    889890        if (codec->fixup_list)
    890                 apply_fixup(codec, codec->fixup_id, action, 0);
     891                __snd_hda_apply_fixup(codec, codec->fixup_id, action, 0);
    891892}
    892893EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);
    … …  
    976977 *
    977978 * The function tries to find the matching model name at first, if given.
     979 * If the model string contains the SSID alias, try to look up with the given
     980 * alias ID.
    978981 * If nothing matched, try to look up the PCI SSID.
    979982 * If still nothing matched, try to look up the codec SSID.
    … …  
    987990        int id = HDA_FIXUP_ID_NOT_SET;
    988991        const char *name = NULL;
     992        const char *type = NULL;
     993        unsigned int vendor, device;
    989994
    990995        if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
    … …  
    993998        /* when model=nofixup is given, don't pick up any fixups */
    994999        if (codec->modelname && !strcmp(codec->modelname, "nofixup")) {
    995                 codec->fixup_list = NULL;
    996                 codec->fixup_name = NULL;
    997                 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
     1000                id = HDA_FIXUP_ID_NO_FIXUP;
     1001                fixlist = NULL;
    9981002                codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
    9991003                          codec->core.chip_name);
    1000                 return;
    1001         }
    1002 
     1004                goto found;
     1005        }
     1006
     1007        /* match with the model name string */
    10031008        if (codec->modelname && models) {
    10041009                while (models->name) {
    10051010                        if (!strcmp(codec->modelname, models->name)) {
    1006                                 codec->fixup_id = models->id;
    1007                                 codec->fixup_name = models->name;
    1008                                 codec->fixup_list = fixlist;
     1011                                id = models->id;
     1012                                name = models->name;
    10091013                                codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
    10101014                                          codec->core.chip_name, codec->fixup_name);
    1011                                 return;
     1015                                goto found;
    10121016                        }
    10131017                        models++;
    10141018                }
    10151019        }
    1016         if (quirk) {
    1017                 q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
     1020
     1021        if (!quirk)
     1022                return;
     1023
     1024        /* match with the SSID alias given by the model string "XXXX:YYYY" */
     1025        if (codec->modelname &&
     1026            sscanf(codec->modelname, "%04x:%04x", &vendor, &device) == 2) {
     1027                q = snd_pci_quirk_lookup_id(vendor, device, quirk);
    10181028                if (q) {
    1019                         id = q->value;
     1029                        type = "alias SSID";
     1030                        goto found_device;
     1031                }
     1032        }
     1033
     1034        /* match with the PCI SSID */
     1035        q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
     1036        if (q) {
     1037                type = "PCI SSID";
     1038                goto found_device;
     1039        }
     1040
     1041        /* match with the codec SSID */
     1042        q = snd_pci_quirk_lookup_id(codec->core.subsystem_id >> 16,
     1043                                    codec->core.subsystem_id & 0xffff,
     1044                                    quirk);
     1045        if (q) {
     1046                type = "codec SSID";
     1047                goto found_device;
     1048        }
     1049
     1050        return; /* no matching */
     1051
     1052 found_device:
     1053        id = q->value;
    10201054#ifdef CONFIG_SND_DEBUG_VERBOSE
    1021                         name = q->name;
    1022                         codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
    1023                                   codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
     1055        name = q->name;
    10241056#endif
    1025                 }
    1026         }
    1027         if (id < 0 && quirk) {
    1028                 for (q = quirk; q->subvendor || q->subdevice; q++) {
    1029                         unsigned int vendorid =
    1030                                 q->subdevice | (q->subvendor << 16);
    1031                         unsigned int mask = 0xffff0000 | q->subdevice_mask;
    1032                         if ((codec->core.subsystem_id & mask) == (vendorid & mask)) {
    1033                                 id = q->value;
    1034 #ifdef CONFIG_SND_DEBUG_VERBOSE
    1035                                 name = q->name;
    1036                                 codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
    1037                                           codec->core.chip_name, name);
    1038 #endif
    1039                                 break;
    1040                         }
    1041                 }
    1042         }
    1043 
     1057        codec_dbg(codec, "%s: picked fixup %s for %s %04x:%04x\n",
     1058                  codec->core.chip_name, name ? name : "",
     1059                  type, q->subvendor, q->subdevice);
     1060 found:
    10441061        codec->fixup_id = id;
    1045         if (id >= 0) {
    1046                 codec->fixup_list = fixlist;
    1047                 codec->fixup_name = name;
    1048         }
     1062        codec->fixup_list = fixlist;
     1063        codec->fixup_name = name;
    10491064}
    10501065EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);

  • GPL/trunk/alsa-kernel/pci/hda/hda_bind.c

    r703 r717  
    159159        }
    160160
     161        refcount_dec(&codec->pcm_ref);
     162        snd_hda_codec_disconnect_pcms(codec);
     163        wait_event(codec->remove_sleep, !refcount_read(&codec->pcm_ref));
     164        snd_power_sync_ref(codec->bus->card);
     165
    161166        if (codec->patch_ops.free)
    162167                codec->patch_ops.free(codec);
    … …  
    168173static void hda_codec_driver_shutdown(struct device *dev)
    169174{
    170         struct hda_codec *codec = dev_to_hda_codec(dev);
    171 
    172         if (!pm_runtime_suspended(dev)) {
    173                 if (codec->patch_ops.reboot_notify)
    174                         codec->patch_ops.reboot_notify(codec);
    175                 snd_hda_codec_display_power(codec, false);
    176         }
     175        snd_hda_codec_shutdown(dev_to_hda_codec(dev));
    177176}
    178177
    … …  
    309308        int err;
    310309
     310        if (codec->configured)
     311                return 0;
     312
    311313        if (is_generic_config(codec))
    312314                codec->probe_id = HDA_CODEC_ID_GENERIC;
    … …  
    314316                codec->probe_id = 0;
    315317
    316         err = snd_hdac_device_register(&codec->core);
    317         if (err < 0)
    318                 return err;
     318        if (!device_is_registered(&codec->core.dev)) {
     319                err = snd_hdac_device_register(&codec->core);
     320                if (err < 0)
     321                        return err;
     322        }
    319323
    320324        if (!codec->preset)
    … …  
    323327                err = codec_bind_generic(codec);
    324328                if (err < 0) {
    325                         codec_err(codec, "Unable to bind the codec\n");
    326                         goto error;
     329                        codec_dbg(codec, "Unable to bind the codec\n");
     330                        return err;
    327331                }
    328332        }
    329333
    330         return 0;
    331 
    332  error:
    333         snd_hdac_device_unregister(&codec->core);
    334         return err;
     334        codec->configured = 1;
     335        return 0;
    335336}
    336337EXPORT_SYMBOL_GPL(snd_hda_codec_configure);

  • GPL/trunk/alsa-kernel/pci/hda/hda_codec.c

    r703 r717  
    712712 * PCM device
    713713 */
    714 static void release_pcm(struct kref *kref)
    715 {
    716         struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
    717 #ifndef TARGET_OS2
    718 /* don't do this on OS/2 - results in the device being free'd and can't be re-opened */
    719         if (pcm->pcm)
    720                 snd_device_free(pcm->codec->card, pcm->pcm);
    721 #endif
    722         clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
    723         kfree(pcm->name);
    724         kfree(pcm);
    725 }
    726714
    727715void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
    728716{
    729         kref_put(&pcm->kref, release_pcm);
     717        if (refcount_dec_and_test(&pcm->codec->pcm_ref))
     718                wake_up(&pcm->codec->remove_sleep);
    730719}
    731720EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
    … …  
    742731
    743732        pcm->codec = codec;
    744         kref_init(&pcm->kref);
    745733        va_start(args, fmt);
    746734        pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
    … …  
    752740
    753741        list_add_tail(&pcm->list, &codec->pcm_list_head);
     742        refcount_inc(&codec->pcm_ref);
    754743        return pcm;
    755744}
    … …  
    759748 * codec destructor
    760749 */
    761 static void codec_release_pcms(struct hda_codec *codec)
    762 {
    763         struct hda_pcm *pcm, *n;
    764 
    765         list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list, struct hda_pcm) {
    766                 list_del_init(&pcm->list);
     750void snd_hda_codec_disconnect_pcms(struct hda_codec *codec)
     751{
     752        struct hda_pcm *pcm;
     753
     754        list_for_each_entry(pcm, &codec->pcm_list_head, list, struct hda_pcm) {
     755                if (pcm->disconnected)
     756                        continue;
    767757                if (pcm->pcm)
    768758                        snd_device_disconnect(codec->card, pcm->pcm);
    769759                snd_hda_codec_pcm_put(pcm);
     760                pcm->disconnected = 1;
     761        }
     762}
     763
     764static void codec_release_pcms(struct hda_codec *codec)
     765{
     766        struct hda_pcm *pcm, *n;
     767
     768        list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list, struct hda_pcm) {
     769                list_del(&pcm->list);
     770#ifndef TARGET_OS2
     771                /* don't do this on OS/2 - results in the device being free'd and can't be re-opened */
     772                if (pcm->pcm)
     773                        snd_device_free(pcm->codec->card, pcm->pcm);
     774#endif
     775                clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
     776                kfree(pcm->name);
     777                kfree(pcm);
    770778        }
    771779}
    … …  
    780788        }
    781789
     790        snd_hda_codec_disconnect_pcms(codec);
    782791        cancel_delayed_work_sync(&codec->jackpoll_work);
    783792        if (!codec->in_freeing)
    … …  
    802811        remove_conn_list(codec);
    803812        snd_hdac_regmap_exit(&codec->core);
     813        codec->configured = 0;
     814        refcount_set(&codec->pcm_ref, 1); /* reset refcount */
    804815}
    805816EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_for_unbind);
    … …  
    968979        INIT_LIST_HEAD(&codec->conn_list);
    969980        INIT_LIST_HEAD(&codec->pcm_list_head);
     981        refcount_set(&codec->pcm_ref, 1);
     982        init_waitqueue_head(&codec->remove_sleep);
    970983
    971984        INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
    … …  
    17371750        int i;
    17381751        struct hda_nid_item *items = codec->mixers.list;
     1752
     1753        down_write(&codec->card->controls_rwsem);
    17391754        for (i = 0; i < codec->mixers.used; i++)
    17401755                snd_ctl_remove(codec->card, items[i].kctl);
     1756        up_write(&codec->card->controls_rwsem);
    17411757        snd_array_free(&codec->mixers);
    17421758        snd_array_free(&codec->nids);
    … …  
    29983014                           NULL)
    29993015};
     3016
     3017/* suspend the codec at shutdown; called from driver's shutdown callback */
     3018void snd_hda_codec_shutdown(struct hda_codec *codec)
     3019{
     3020        struct hda_pcm *cpcm;
     3021
     3022        /* Skip the shutdown if codec is not registered */
     3023        if (!codec->registered)
     3024                return;
     3025
     3026        list_for_each_entry(cpcm, &codec->pcm_list_head, list, struct hda_pcm)
     3027                snd_pcm_suspend_all(cpcm->pcm);
     3028
     3029        pm_runtime_force_suspend(hda_codec_dev(codec));
     3030        pm_runtime_disable(hda_codec_dev(codec));
     3031}
    30003032
    30013033/*

  • GPL/trunk/alsa-kernel/pci/hda/hda_controller.c

    r695 r717  
    2626#include <sound/initval.h>
    2727#include "hda_controller.h"
     28#include "hda_local.h"
    2829
    2930#ifndef TARGET_OS2
    … …  
    523524
    524525                nsec = timecounter_read(&azx_dev->core.tc);
    525                 nsec = div_u64(nsec, 3); /* can be optimized */
    526526                if (audio_tstamp_config->report_delay)
    527527                        nsec = azx_adjust_codec_delay(substream, nsec);
    … …  
    690690}
    691691
    692 #ifndef TARGET_OS2
    693 static int azx_pcm_mmap(struct snd_pcm_substream *substream,
    694                         struct vm_area_struct *area)
    695 {
    696         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
    697         struct azx *chip = apcm->chip;
    698         if (chip->ops->pcm_mmap_prepare)
    699                 chip->ops->pcm_mmap_prepare(substream, area);
    700         return snd_pcm_lib_default_mmap(substream, area);
    701 }
    702 #else
    703 #define azx_pcm_mmap    NULL
    704 #endif
    705 
    706692static const struct snd_pcm_ops azx_pcm_ops = {
    707693        .open = azx_pcm_open,
    … …  
    713699        .pointer = azx_pcm_pointer,
    714700        .get_time_info =  azx_get_time_info,
    715         .mmap = azx_pcm_mmap,
    716701};
    717702
    … …  
    778763                size = MAX_PREALLOC_SIZE;
    779764        if (chip->uc_buffer)
    780                 type = SNDRV_DMA_TYPE_DEV_UC_SG;
     765                type = SNDRV_DMA_TYPE_DEV_WC_SG;
    781766        snd_pcm_set_managed_buffer_all(pcm, type, chip->card->dev,
    782767                                       size, MAX_PREALLOC_SIZE);
    … …  
    12931278{
    12941279        struct hda_codec *codec, *next;
    1295 
    1296         /* use _safe version here since snd_hda_codec_configure() deregisters
    1297          * the device upon error and deletes itself from the bus list.
    1298          */
    1299         list_for_each_codec_safe(codec, next, &chip->bus) {
    1300                 snd_hda_codec_configure(codec);
    1301         }
    1302 
    1303         if (!azx_bus(chip)->num_codecs)
    1304                 return -ENODEV;
    1305         return 0;
     1280        int success = 0;
     1281
     1282        list_for_each_codec(codec, &chip->bus) {
     1283                if (!snd_hda_codec_configure(codec))
     1284                        success++;
     1285        }
     1286
     1287        if (success) {
     1288                /* unregister failed codecs if any codec has been probed */
     1289                list_for_each_codec_safe(codec, next, &chip->bus) {
     1290                        if (!codec->configured) {
     1291                                codec_err(codec, "Unable to configure, disabling\n");
     1292                                snd_hdac_device_unregister(&codec->core);
     1293                        }
     1294                }
     1295        }
     1296
     1297        return success ? 0 : -ENODEV;
    13061298}
    13071299EXPORT_SYMBOL_GPL(azx_codec_configure);

  • GPL/trunk/alsa-kernel/pci/hda/hda_controller.h

    r679 r717  
    4242#define AZX_DCAPS_COUNT_LPIB_DELAY  (1 << 25)   /* Take LPIB as delay */
    4343#define AZX_DCAPS_PM_RUNTIME    (1 << 26)       /* runtime PM support */
    44 /* 27 unused */
     44#define AZX_DCAPS_RETRY_PROBE   (1 << 27)       /* retry probe if no codec is configured */
    4545#define AZX_DCAPS_CORBRP_SELF_CLEAR (1 << 28)   /* CORBRP clears itself after reset */
    4646#define AZX_DCAPS_NO_MSI64      (1 << 29)       /* Stick to 32-bit MSIs */
    … …  
    7575        /* Disable msi if supported, PCI only */
    7676        int (*disable_msi_reset_irq)(struct azx *);
    77         void (*pcm_mmap_prepare)(struct snd_pcm_substream *substream,
    78                                  struct vm_area_struct *area);
    7977        /* Check if current position is acceptable */
    8078        int (*position_check)(struct azx *chip, struct azx_dev *azx_dev);
    … …  
    142140        unsigned int uc_buffer:1; /* non-cached pages for stream buffers */
    143141        unsigned int align_buffer_size:1;
    144         unsigned int region_requested:1;
    145142        unsigned int disabled:1; /* disabled by vga_switcheroo */
    146143        unsigned int pm_prepared:1;

  • GPL/trunk/alsa-kernel/pci/hda/hda_generic.c

    r703 r717  
    9595        snd_array_free(&spec->paths);
    9696        snd_array_free(&spec->loopback_list);
     97#ifdef CONFIG_SND_HDA_GENERIC_LEDS
     98        if (spec->led_cdevs[LED_AUDIO_MUTE])
     99                led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);
     100        if (spec->led_cdevs[LED_AUDIO_MICMUTE])
     101                led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);
     102#endif
    97103}
    98104
    … …  
    39343940                                bool micmute)
    39353941{
     3942        struct hda_gen_spec *spec = codec->spec;
    39363943        struct led_classdev *cdev;
     3944        int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;
     3945        int err;
    39373946
    39383947        cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
    … …  
    39443953        cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
    39453954        cdev->brightness_set_blocking = callback;
    3946         cdev->brightness = ledtrig_audio_get(micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE);
     3955        cdev->brightness = ledtrig_audio_get(idx);
    39473956        cdev->flags = LED_CORE_SUSPENDRESUME;
    39483957
    3949         return devm_led_classdev_register(&codec->core.dev, cdev);
     3958        err = led_classdev_register(&codec->core.dev, cdev);
     3959        if (err < 0)
     3960                return err;
     3961        spec->led_cdevs[idx] = cdev;
     3962        return 0;
    39503963}
    39513964
    … …  
    60166029EXPORT_SYMBOL_GPL(snd_hda_gen_free);
    60176030
    6018 /**
    6019  * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
    6020  * @codec: the HDA codec
    6021  *
    6022  * This can be put as patch_ops reboot_notify function.
    6023  */
    6024 void snd_hda_gen_reboot_notify(struct hda_codec *codec)
    6025 {
    6026         /* Make the codec enter D3 to avoid spurious noises from the internal
    6027          * speaker during (and after) reboot
    6028          */
    6029         snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
    6030         snd_hda_codec_write(codec, codec->core.afg, 0,
    6031                             AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
    6032         msleep(10);
    6033 }
    6034 EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
    6035 
    60366031#ifdef CONFIG_PM
    60376032/**
    … …  
    60616056        .free = snd_hda_gen_free,
    60626057        .unsol_event = snd_hda_jack_unsol_event,
    6063         .reboot_notify = snd_hda_gen_reboot_notify,
    60646058#ifdef CONFIG_PM
    60656059        .check_power_status = snd_hda_gen_check_power_status,

  • GPL/trunk/alsa-kernel/pci/hda/hda_generic.h

    r695 r717  
    295295        void (*mic_autoswitch_hook)(struct hda_codec *codec,
    296296                                    struct hda_jack_callback *cb);
     297
     298        /* leds */
     299        struct led_classdev *led_cdevs[NUM_AUDIO_LEDS];
    297300};
    298301
    … …  
    325328int snd_hda_gen_build_controls(struct hda_codec *codec);
    326329int snd_hda_gen_build_pcms(struct hda_codec *codec);
    327 void snd_hda_gen_reboot_notify(struct hda_codec *codec);
    328330
    329331/* standard jack event callbacks */

  • GPL/trunk/alsa-kernel/pci/hda/hda_intel.c

    r703 r717  
    326326#define AZX_DCAPS_PRESET_AMD_SB \
    327327        (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_AMD_WORKAROUND |\
    328          AZX_DCAPS_SNOOP_TYPE(ATI) | AZX_DCAPS_PM_RUNTIME)
     328         AZX_DCAPS_SNOOP_TYPE(ATI) | AZX_DCAPS_PM_RUNTIME |\
     329         AZX_DCAPS_RETRY_PROBE)
    329330
    330331/* quirks for Nvidia */
    … …  
    353354                                        ((pci)->device == 0x0d0c) || \
    354355                                        ((pci)->device == 0x160c) || \
    355                                         ((pci)->device == 0x490d))
     356                                        ((pci)->device == 0x490d) || \
     357                                        ((pci)->device == 0x4f90) || \
     358                                        ((pci)->device == 0x4f91) || \
     359                                        ((pci)->device == 0x4f92))
    356360
    357361#define IS_BXT(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x5a98)
    … …  
    656660 * data is processed.  So, we need to process it afterwords in a
    657661 * workqueue.
     662 *
     663 * Returns 1 if OK to proceed, 0 for delay handling, -1 for skipping update
    658664 */
    659665static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
    660666{
    661667        struct snd_pcm_substream *substream = azx_dev->core.substream;
     668        struct snd_pcm_runtime *runtime = substream->runtime;
    662669        int stream = substream->stream;
    663670        u32 wallclk;
    664671        unsigned int pos;
     672        snd_pcm_uframes_t hwptr, target;
    665673
    666674        wallclk = azx_readl(chip, WALLCLK) - azx_dev->core.start_wallclk;
    … …  
    706714                return chip->bdl_pos_adj ? 0 : -1;
    707715        azx_dev->core.start_wallclk += wallclk;
     716
     717        if (azx_dev->core.no_period_wakeup)
     718                return 1; /* OK, no need to check period boundary */
     719
     720        if (runtime->hw_ptr_base != runtime->hw_ptr_interrupt)
     721                return 1; /* OK, already in hwptr updating process */
     722
     723        /* check whether the period gets really elapsed */
     724        pos = bytes_to_frames(runtime, pos);
     725        hwptr = runtime->hw_ptr_base + pos;
     726        if (hwptr < runtime->status->hw_ptr)
     727                hwptr += runtime->buffer_size;
     728        target = runtime->hw_ptr_interrupt + runtime->period_size;
     729        if (hwptr < target) {
     730                /* too early wakeup, process it later */
     731                return chip->bdl_pos_adj ? 0 : -1;
     732        }
     733
    708734        return 1; /* OK, it's fine */
    709735}
    … …  
    882908        /* just read back the calculated value in the above */
    883909        return substream->runtime->delay;
    884 }
    885 
    886 static unsigned int azx_skl_get_dpib_pos(struct azx *chip,
    887                                          struct azx_dev *azx_dev)
    888 {
    889         return _snd_hdac_chip_readl(azx_bus(chip),
    890                                     AZX_REG_VS_SDXDPIB_XBASE +
    891                                     (AZX_REG_VS_SDXDPIB_XINTERVAL *
    892                                      azx_dev->core.index));
    893 }
    894 
    895 /* get the current DMA position with correction on SKL+ chips */
    896 static unsigned int azx_get_pos_skl(struct azx *chip, struct azx_dev *azx_dev)
    897 {
    898         /* DPIB register gives a more accurate position for playback */
    899         if (azx_dev->core.substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
    900                 return azx_skl_get_dpib_pos(chip, azx_dev);
    901 
    902         /* For capture, we need to read posbuf, but it requires a delay
    903          * for the possible boundary overlap; the read of DPIB fetches the
    904          * actual posbuf
    905          */
    906         udelay(20);
    907         azx_skl_get_dpib_pos(chip, azx_dev);
    908         return azx_get_pos_posbuf(chip, azx_dev);
    909910}
    910911
    … …  
    14071408        if (bus->irq >= 0)
    14081409                free_irq(bus->irq, (void*)chip);
    1409         if (chip->msi)
    1410                 pci_disable_msi(chip->pci);
    1411 #ifdef TARGET_OS2
    1412         iounmap((void *)bus->remap_addr);
    1413 #else
    1414         iounmap(bus->remap_addr);
    1415 #endif
    14161410
    14171411        azx_free_stream_pages(chip);
    … …  
    14191413        snd_hdac_bus_exit(bus);
    14201414
    1421         if (chip->region_requested)
    1422                 pci_release_regions(chip->pci);
    1423 
    1424         pci_disable_device(chip->pci);
    14251415#ifdef CONFIG_SND_HDA_PATCH_LOADER
    14261416        release_firmware(chip->fw);
    … …  
    16171607                [POS_FIX_VIACOMBO] = azx_via_get_position,
    16181608                [POS_FIX_COMBO] = azx_get_pos_lpib,
    1619                 [POS_FIX_SKL] = azx_get_pos_skl,
     1609                [POS_FIX_SKL] = azx_get_pos_posbuf,
    16201610                [POS_FIX_FIFO] = azx_get_pos_fifo,
    16211611        };
    … …  
    16551645        SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
    16561646        SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
     1647        SND_PCI_QUIRK(0x1558, 0x0351, "Schenker Dock 15", 0x105),
    16571648        /* WinFast VP200 H (Teradici) user reported broken communication */
    16581649        SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
    … …  
    17681759static void azx_probe_work(struct work_struct *work)
    17691760{
    1770         struct hda_intel *hda = container_of(work, struct hda_intel, probe_work);
     1761        struct hda_intel *hda = container_of(work, struct hda_intel, probe_work.work);
    17711762        azx_probe_continue(&hda->chip);
    17721763}
    … …  
    18201811        hda = kzalloc(sizeof(*hda), GFP_KERNEL);
    18211812#endif
    1822         if (!hda) {
    1823                 pci_disable_device(pci);
    1824                 return -ENOMEM;
    1825         }
     1813        if (!hda)
     1814                return -ENOMEM;
    18261815
    18271816        chip = &hda->chip;
    … …  
    18441833        assign_position_fix(chip, check_position_fix(chip, position_fix[dev]));
    18451834
    1846         check_probe_mask(chip, dev);
    1847 
    18481835        if (single_cmd < 0) /* allow fallback to single_cmd at errors */
    18491836                chip->fallback_to_single_cmd = 1;
    … …  
    18591846
    18601847        err = azx_bus_init(chip, model[dev]);
    1861         if (err < 0) {
    1862                 pci_disable_device(pci);
     1848        if (err < 0)
    18631849                return err;
    1864         }
    18651850
    18661851        /* use the non-cached pages in non-snoop mode */
    18671852        if (!azx_snoop(chip))
    1868                 azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_UC;
     1853                azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_WC;
    18691854
    18701855        if (chip->driver_type == AZX_DRIVER_NVIDIA) {
    … …  
    18721857                chip->bus.core.needs_damn_long_delay = 1;
    18731858        }
     1859
     1860        check_probe_mask(chip, dev);
    18741861
    18751862        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    … …  
    18811868
    18821869        /* continue probing in work context as may trigger request module */
    1883         INIT_WORK(&hda->probe_work, azx_probe_work);
     1870        INIT_DELAYED_WORK(&hda->probe_work, azx_probe_work);
    18841871
    18851872        *rchip = chip;
    … …  
    19081895#endif
    19091896
     1897#ifndef TARGET_OS2
     1898        err = pcim_iomap_regions(pci, 1 << 0, "ICH HD audio");
     1899#else
    19101900        err = pci_request_regions(pci, "ICH HD audio");
     1901#endif
    19111902        if (err < 0)
    19121903                return err;
    1913         chip->region_requested = 1;
    19141904
    19151905        bus->addr = pci_resource_start(pci, 0);
     1906#ifndef TARGET_OS2
     1907        bus->remap_addr = pcim_iomap_table(pci)[0];
     1908#else
    19161909        bus->remap_addr = pci_ioremap_bar(pci, 0);
    1917         if (bus->remap_addr == NULL) {
    1918                 dev_err(card->dev, "ioremap error\n");
    1919                 return -ENXIO;
    1920         }
    1921 
     1910#endif
    19221911        if (chip->driver_type == AZX_DRIVER_SKL)
    19231912                snd_hdac_bus_parse_capabilities(bus);
    … …  
    21012090}
    21022091
    2103 static void pcm_mmap_prepare(struct snd_pcm_substream *substream,
    2104                              struct vm_area_struct *area)
    2105 {
    2106 #ifdef CONFIG_X86
    2107         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
    2108         struct azx *chip = apcm->chip;
    2109         if (chip->uc_buffer)
    2110                 area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
    2111 #endif
    2112 }
    2113 
    21142092/* Denylist for skipping the whole probe:
    21152093 * some HD-audio PCI entries are exposed without any codecs, and such devices
    … …  
    21252103static const struct hda_controller_ops pci_hda_ops = {
    21262104        .disable_msi_reset_irq = disable_msi_reset_irq,
    2127         .pcm_mmap_prepare = pcm_mmap_prepare,
    21282105        .position_check = azx_position_check,
    21292106};
    … …  
    22192196#else
    22202197        if (schedule_probe)
    2221                 schedule_work(&hda->probe_work);
     2198                schedule_delayed_work(&hda->probe_work, 0);
    22222199#endif
    22232200
    … …  
    23062283        int err;
    23072284
     2285        if (chip->disabled || hda->init_failed)
     2286                return -EIO;
     2287        if (hda->probe_retry)
     2288                goto probe_retry;
     2289
    23082290        to_hda_bus(bus)->bus_probing = 1;
    23092291        hda->probe_continued = 1;
    … …  
    23672349        }
    23682350#endif
     2351
     2352 probe_retry:
    23692353        if (bus->codec_mask && !(probe_only[dev] & 1)) {
    23702354                err = azx_codec_configure(chip);
    2371                 if (err < 0)
     2355                if (err) {
     2356                        if ((chip->driver_caps & AZX_DCAPS_RETRY_PROBE) &&
     2357                            ++hda->probe_retry < 60) {
     2358                                schedule_delayed_work(&hda->probe_work,
     2359                                                      msecs_to_jiffies(1000));
     2360                                return 0; /* keep things up */
     2361                        }
     2362                        dev_err(chip->card->dev, "Cannot probe codecs, giving up\n");
    23722363                        goto out_free;
     2364                }
    23732365        }
    23742366
    … …  
    23922384out_free:
    23932385        if (err < 0) {
    2394                 azx_free(chip);
     2386                pci_set_drvdata(pci, NULL);
     2387                snd_card_free(chip->card);
    23952388                return err;
    23962389        }
    … …  
    24002393        complete_all(&hda->probe_wait);
    24012394        to_hda_bus(bus)->bus_probing = 0;
     2395        hda->probe_retry = 0;
    24022396        return 0;
    24032397}
    … …  
    24252419                 */
    24262420                device_unlock(&pci->dev);
    2427                 cancel_work_sync(&hda->probe_work);
     2421                cancel_delayed_work_sync(&hda->probe_work);
    24282422                device_lock(&pci->dev);
    24292423
    … …  
    25342528        /* DG1 */
    25352529        { PCI_DEVICE(0x8086, 0x490d),
     2530          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
     2531        /* DG2 */
     2532        { PCI_DEVICE(0x8086, 0x4f90),
     2533          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
     2534        { PCI_DEVICE(0x8086, 0x4f91),
     2535          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
     2536        { PCI_DEVICE(0x8086, 0x4f92),
    25362537          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
    25372538        /* Alderlake-S */

  • GPL/trunk/alsa-kernel/pci/hda/hda_intel.h

    r679 r717  
    1515        /* sync probing */
    1616        struct completion probe_wait;
    17         struct work_struct probe_work;
     17        struct delayed_work probe_work;
    1818
    1919        /* card list (for power_save trigger) */
    … …  
    3131
    3232        bool need_i915_power:1; /* the hda controller needs i915 power */
     33
     34        int probe_retry;        /* being probe-retry */
    3335};
    3436

  • GPL/trunk/alsa-kernel/pci/hda/hda_local.h

    r703 r717  
    138138void snd_hda_codec_register(struct hda_codec *codec);
    139139void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec);
     140void snd_hda_codec_disconnect_pcms(struct hda_codec *codec);
    140141
    141142#define snd_hda_regmap_sync(codec)      snd_hdac_regmap_sync(&(codec)->core)
    … …  
    364365                           const struct hda_pintbl *cfg);
    365366void snd_hda_apply_fixup(struct hda_codec *codec, int action);
     367void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth);
    366368void snd_hda_pick_fixup(struct hda_codec *codec,
    367369                        const struct hda_model_fixup *models,
    … …  
    453455        for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)
    454456
     457/* Set the codec power_state flag to indicate to allow unsol event handling;
     458 * see hda_codec_unsol_event() in hda_bind.c.  Calling this might confuse the
     459 * state tracking, so use with care.
     460 */
     461static inline void snd_hda_codec_allow_unsol_events(struct hda_codec *codec)
     462{
     463        codec->core.dev.power.power_state = PMSG_ON;
     464}
     465
    455466/*
    456467 * get widget capabilities
    … …  
    629640                                             hda_nid_t nid,
    630641                                             unsigned int power_state);
     642
     643void snd_hda_codec_shutdown(struct hda_codec *codec);
    631644
    632645/*

  • GPL/trunk/alsa-kernel/pci/hda/patch_analog.c

    r679 r717  
    7676#endif
    7777
    78 
     78#ifdef CONFIG_PM
    7979static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
    8080                                hda_nid_t hp)
    … …  
    116116}
    117117
    118 static void ad198x_shutup(struct hda_codec *codec)
     118static int ad198x_suspend(struct hda_codec *codec)
    119119{
    120120        snd_hda_shutup_pins(codec);
    121121        ad198x_power_eapd(codec);
    122 }
    123 
    124 #ifdef CONFIG_PM
    125 static int ad198x_suspend(struct hda_codec *codec)
    126 {
    127         ad198x_shutup(codec);
    128122        return 0;
    129123}
    … …  
    172166        .suspend = ad198x_suspend,
    173167#endif
    174         .reboot_notify = ad198x_shutup,
    175168};
    176169

  • GPL/trunk/alsa-kernel/pci/hda/patch_ca0132.c

    r703 r717  
    22762276{
    22772277        struct ca0132_spec *spec = codec->spec;
    2278         int status = -1;
     2278        int status;
    22792279        unsigned int scp_send_size = 0;
    22802280        unsigned int total_size;
    … …  
    97829782}
    97839783
    9784 static void ca0132_reboot_notify(struct hda_codec *codec)
    9785 {
    9786         codec->patch_ops.free(codec);
    9787 }
    9788 
    97899784#ifdef CONFIG_PM
    97909785static int ca0132_suspend(struct hda_codec *codec)
    … …  
    98069801        .suspend = ca0132_suspend,
    98079802#endif
    9808         .reboot_notify = ca0132_reboot_notify,
    98099803};
    98109804

  • GPL/trunk/alsa-kernel/pci/hda/patch_cirrus.c

    r695 r717  
    1010#include <linux/module.h>
    1111#include <sound/core.h>
    12 #include <linux/mutex.h>
    1312#include <linux/pci.h>
    1413#include <sound/tlv.h>
    … …  
    2625 */
    2726
    28 #define CS42L42_HP_CH     (2U)
    29 #define CS42L42_HS_MIC_CH (1U)
    30 
    3127struct cs_spec {
    3228        struct hda_gen_spec gen;
    … …  
    4743        int (*spdif_sw_put)(struct snd_kcontrol *kcontrol,
    4844                            struct snd_ctl_elem_value *ucontrol);
    49 
    50         unsigned int cs42l42_hp_jack_in:1;
    51         unsigned int cs42l42_mic_jack_in:1;
    52         unsigned int cs42l42_volume_init:1;
    53         char cs42l42_hp_volume[CS42L42_HP_CH];
    54         char cs42l42_hs_mic_volume[CS42L42_HS_MIC_CH];
    55 
    56         struct mutex cs8409_i2c_mux;
    57 
    58         /* verb exec op override */
    59         int (*exec_verb)(struct hdac_device *dev, unsigned int cmd,
    60                                  unsigned int flags, unsigned int *res);
    6145};
    6246
    … …  
    570554                .chain_id = CS420X_GPIO_13,
    571555        },
    572 #ifdef TARGET_OS2xxx
     556#ifndef TARGET_OS2
    573557        [CS420X_MBP81] = {
    574558                .type = HDA_FIXUP_VERBS,
    … …  
    12461230}
    12471231
    1248 /* Cirrus Logic CS8409 HDA bridge with
    1249  * companion codec CS42L42
    1250  */
    1251 #define CS8409_VENDOR_NID 0x47
    1252 
    1253 #define CS8409_CS42L42_HP_PIN_NID       0x24
    1254 #define CS8409_CS42L42_SPK_PIN_NID      0x2c
    1255 #define CS8409_CS42L42_AMIC_PIN_NID     0x34
    1256 #define CS8409_CS42L42_DMIC_PIN_NID     0x44
    1257 #define CS8409_CS42L42_DMIC_ADC_PIN_NID 0x22
    1258 
    1259 #define CS42L42_HSDET_AUTO_DONE 0x02
    1260 #define CS42L42_HSTYPE_MASK             0x03
    1261 
    1262 #define CS42L42_JACK_INSERTED   0x0C
    1263 #define CS42L42_JACK_REMOVED    0x00
    1264 
    1265 #define GPIO3_INT (1 << 3)
    1266 #define GPIO4_INT (1 << 4)
    1267 #define GPIO5_INT (1 << 5)
    1268 
    1269 #define CS42L42_I2C_ADDR        (0x48 << 1)
    1270 
    1271 #define CIR_I2C_ADDR    0x0059
    1272 #define CIR_I2C_DATA    0x005A
    1273 #define CIR_I2C_CTRL    0x005B
    1274 #define CIR_I2C_STATUS  0x005C
    1275 #define CIR_I2C_QWRITE  0x005D
    1276 #define CIR_I2C_QREAD   0x005E
    1277 
    1278 #define CS8409_CS42L42_HP_VOL_REAL_MIN   (-63)
    1279 #define CS8409_CS42L42_HP_VOL_REAL_MAX   (0)
    1280 #define CS8409_CS42L42_AMIC_VOL_REAL_MIN (-97)
    1281 #define CS8409_CS42L42_AMIC_VOL_REAL_MAX (12)
    1282 #define CS8409_CS42L42_REG_HS_VOLUME_CHA (0x2301)
    1283 #define CS8409_CS42L42_REG_HS_VOLUME_CHB (0x2303)
    1284 #define CS8409_CS42L42_REG_AMIC_VOLUME   (0x1D03)
    1285 
    1286 struct cs8409_i2c_param {
    1287         unsigned int addr;
    1288         unsigned int reg;
    1289 };
    1290 
    1291 struct cs8409_cir_param {
    1292         unsigned int nid;
    1293         unsigned int cir;
    1294         unsigned int coeff;
    1295 };
    1296 
    1297 enum {
    1298         CS8409_BULLSEYE,
    1299         CS8409_WARLOCK,
    1300         CS8409_CYBORG,
    1301         CS8409_FIXUPS,
    1302 };
    1303 
    1304 static void cs8409_cs42l42_fixups(struct hda_codec *codec,
    1305                                     const struct hda_fixup *fix, int action);
    1306 static int cs8409_cs42l42_exec_verb(struct hdac_device *dev,
    1307                 unsigned int cmd, unsigned int flags, unsigned int *res);
    1308 
    1309 /* Dell Inspiron models with cs8409/cs42l42 */
    1310 static const struct hda_model_fixup cs8409_models[] = {
    1311         { .id = CS8409_BULLSEYE, .name = "bullseye" },
    1312         { .id = CS8409_WARLOCK, .name = "warlock" },
    1313         { .id = CS8409_CYBORG, .name = "cyborg" },
    1314         {0}
    1315 };
    1316 
    1317 /* Dell Inspiron platforms
    1318  * with cs8409 bridge and cs42l42 codec
    1319  */
    1320 static const struct snd_pci_quirk cs8409_fixup_tbl[] = {
    1321         SND_PCI_QUIRK(0x1028, 0x0A11, "Bullseye", CS8409_BULLSEYE),
    1322         SND_PCI_QUIRK(0x1028, 0x0A12, "Bullseye", CS8409_BULLSEYE),
    1323         SND_PCI_QUIRK(0x1028, 0x0A23, "Bullseye", CS8409_BULLSEYE),
    1324         SND_PCI_QUIRK(0x1028, 0x0A24, "Bullseye", CS8409_BULLSEYE),
    1325         SND_PCI_QUIRK(0x1028, 0x0A25, "Bullseye", CS8409_BULLSEYE),
    1326         SND_PCI_QUIRK(0x1028, 0x0A29, "Bullseye", CS8409_BULLSEYE),
    1327         SND_PCI_QUIRK(0x1028, 0x0A2A, "Bullseye", CS8409_BULLSEYE),
    1328         SND_PCI_QUIRK(0x1028, 0x0A2B, "Bullseye", CS8409_BULLSEYE),
    1329         SND_PCI_QUIRK(0x1028, 0x0AB0, "Warlock", CS8409_WARLOCK),
    1330         SND_PCI_QUIRK(0x1028, 0x0AB2, "Warlock", CS8409_WARLOCK),
    1331         SND_PCI_QUIRK(0x1028, 0x0AB1, "Warlock", CS8409_WARLOCK),
    1332         SND_PCI_QUIRK(0x1028, 0x0AB3, "Warlock", CS8409_WARLOCK),
    1333         SND_PCI_QUIRK(0x1028, 0x0AB4, "Warlock", CS8409_WARLOCK),
    1334         SND_PCI_QUIRK(0x1028, 0x0AB5, "Warlock", CS8409_WARLOCK),
    1335         SND_PCI_QUIRK(0x1028, 0x0AD9, "Warlock", CS8409_WARLOCK),
    1336         SND_PCI_QUIRK(0x1028, 0x0ADA, "Warlock", CS8409_WARLOCK),
    1337         SND_PCI_QUIRK(0x1028, 0x0ADB, "Warlock", CS8409_WARLOCK),
    1338         SND_PCI_QUIRK(0x1028, 0x0ADC, "Warlock", CS8409_WARLOCK),
    1339         SND_PCI_QUIRK(0x1028, 0x0AF4, "Warlock", CS8409_WARLOCK),
    1340         SND_PCI_QUIRK(0x1028, 0x0AF5, "Warlock", CS8409_WARLOCK),
    1341         SND_PCI_QUIRK(0x1028, 0x0A77, "Cyborg", CS8409_CYBORG),
    1342         SND_PCI_QUIRK(0x1028, 0x0A78, "Cyborg", CS8409_CYBORG),
    1343         SND_PCI_QUIRK(0x1028, 0x0A79, "Cyborg", CS8409_CYBORG),
    1344         SND_PCI_QUIRK(0x1028, 0x0A7A, "Cyborg", CS8409_CYBORG),
    1345         SND_PCI_QUIRK(0x1028, 0x0A7D, "Cyborg", CS8409_CYBORG),
    1346         SND_PCI_QUIRK(0x1028, 0x0A7E, "Cyborg", CS8409_CYBORG),
    1347         SND_PCI_QUIRK(0x1028, 0x0A7F, "Cyborg", CS8409_CYBORG),
    1348         SND_PCI_QUIRK(0x1028, 0x0A80, "Cyborg", CS8409_CYBORG),
    1349         SND_PCI_QUIRK(0x1028, 0x0ADF, "Cyborg", CS8409_CYBORG),
    1350         SND_PCI_QUIRK(0x1028, 0x0AE0, "Cyborg", CS8409_CYBORG),
    1351         SND_PCI_QUIRK(0x1028, 0x0AE1, "Cyborg", CS8409_CYBORG),
    1352         SND_PCI_QUIRK(0x1028, 0x0AE2, "Cyborg", CS8409_CYBORG),
    1353         SND_PCI_QUIRK(0x1028, 0x0AE9, "Cyborg", CS8409_CYBORG),
    1354         SND_PCI_QUIRK(0x1028, 0x0AEA, "Cyborg", CS8409_CYBORG),
    1355         SND_PCI_QUIRK(0x1028, 0x0AEB, "Cyborg", CS8409_CYBORG),
    1356         SND_PCI_QUIRK(0x1028, 0x0AEC, "Cyborg", CS8409_CYBORG),
    1357         SND_PCI_QUIRK(0x1028, 0x0AED, "Cyborg", CS8409_CYBORG),
    1358         SND_PCI_QUIRK(0x1028, 0x0AEE, "Cyborg", CS8409_CYBORG),
    1359         SND_PCI_QUIRK(0x1028, 0x0AEF, "Cyborg", CS8409_CYBORG),
    1360         SND_PCI_QUIRK(0x1028, 0x0AF0, "Cyborg", CS8409_CYBORG),
    1361         {0} /* terminator */
    1362 };
    1363 
    1364 static const struct hda_verb cs8409_cs42l42_init_verbs[] = {
    1365         { 0x01, AC_VERB_SET_GPIO_WAKE_MASK, 0x0018 }, /* WAKE from GPIO 3,4 */
    1366         { 0x47, AC_VERB_SET_PROC_STATE, 0x0001 },     /* Enable VPW processing  */
    1367         { 0x47, AC_VERB_SET_COEF_INDEX, 0x0002 },     /* Configure GPIO 6,7 */
    1368         { 0x47, AC_VERB_SET_PROC_COEF,  0x0080 },     /* I2C mode */
    1369         { 0x47, AC_VERB_SET_COEF_INDEX, 0x005b },     /* Set I2C bus speed */
    1370         { 0x47, AC_VERB_SET_PROC_COEF,  0x0200 },     /* 100kHz I2C_STO = 2 */
    1371         {0} /* terminator */
    1372 };
    1373 
    1374 static const struct hda_pintbl cs8409_cs42l42_pincfgs[] = {
    1375         { 0x24, 0x042120f0 }, /* ASP-1-TX */
    1376         { 0x34, 0x04a12050 }, /* ASP-1-RX */
    1377         { 0x2c, 0x901000f0 }, /* ASP-2-TX */
    1378         { 0x44, 0x90a00090 }, /* DMIC-1 */
    1379         {0} /* terminator */
    1380 };
    1381 
    1382 static const struct hda_fixup cs8409_fixups[] = {
    1383         [CS8409_BULLSEYE] = {
    1384                 .type = HDA_FIXUP_PINS,
    1385                 .v.pins = cs8409_cs42l42_pincfgs,
    1386                 .chained = true,
    1387                 .chain_id = CS8409_FIXUPS,
    1388         },
    1389         [CS8409_WARLOCK] = {
    1390                 .type = HDA_FIXUP_PINS,
    1391                 .v.pins = cs8409_cs42l42_pincfgs,
    1392                 .chained = true,
    1393                 .chain_id = CS8409_FIXUPS,
    1394         },
    1395         [CS8409_CYBORG] = {
    1396                 .type = HDA_FIXUP_PINS,
    1397                 .v.pins = cs8409_cs42l42_pincfgs,
    1398                 .chained = true,
    1399                 .chain_id = CS8409_FIXUPS,
    1400         },
    1401         [CS8409_FIXUPS] = {
    1402                 .type = HDA_FIXUP_FUNC,
    1403                 .v.func = cs8409_cs42l42_fixups,
    1404         },
    1405 };
    1406 
    1407 /* Vendor specific HW configuration for CS42L42 */
    1408 static const struct cs8409_i2c_param cs42l42_init_reg_seq[] = {
    1409         { 0x1010, 0xB0 },
    1410         { 0x1D01, 0x00 },
    1411         { 0x1D02, 0x06 },
    1412         { 0x1D03, 0x00 },
    1413         { 0x1107, 0x01 },
    1414         { 0x1009, 0x02 },
    1415         { 0x1007, 0x03 },
    1416         { 0x1201, 0x00 },
    1417         { 0x1208, 0x13 },
    1418         { 0x1205, 0xFF },
    1419         { 0x1206, 0x00 },
    1420         { 0x1207, 0x20 },
    1421         { 0x1202, 0x0D },
    1422         { 0x2A02, 0x02 },
    1423         { 0x2A03, 0x00 },
    1424         { 0x2A04, 0x00 },
    1425         { 0x2A05, 0x02 },
    1426         { 0x2A06, 0x00 },
    1427         { 0x2A07, 0x20 },
    1428         { 0x2A08, 0x02 },
    1429         { 0x2A09, 0x00 },
    1430         { 0x2A0A, 0x80 },
    1431         { 0x2A0B, 0x02 },
    1432         { 0x2A0C, 0x00 },
    1433         { 0x2A0D, 0xA0 },
    1434         { 0x2A01, 0x0C },
    1435         { 0x2902, 0x01 },
    1436         { 0x2903, 0x02 },
    1437         { 0x2904, 0x00 },
    1438         { 0x2905, 0x00 },
    1439         { 0x2901, 0x01 },
    1440         { 0x1101, 0x0A },
    1441         { 0x1102, 0x84 },
    1442         { 0x2301, 0x00 },
    1443         { 0x2303, 0x00 },
    1444         { 0x2302, 0x3f },
    1445         { 0x2001, 0x03 },
    1446         { 0x1B75, 0xB6 },
    1447         { 0x1B73, 0xC2 },
    1448         { 0x1129, 0x01 },
    1449         { 0x1121, 0xF3 },
    1450         { 0x1103, 0x20 },
    1451         { 0x1105, 0x00 },
    1452         { 0x1112, 0xC0 },
    1453         { 0x1113, 0x80 },
    1454         { 0x1C03, 0xC0 },
    1455         { 0x1105, 0x00 },
    1456         { 0x1112, 0xC0 },
    1457         { 0x1101, 0x02 },
    1458         {0} /* Terminator */
    1459 };
    1460 
    1461 /* Vendor specific hw configuration for CS8409 */
    1462 static const struct cs8409_cir_param cs8409_cs42l42_hw_cfg[] = {
    1463         { 0x47, 0x00, 0xb008 }, /* +PLL1/2_EN, +I2C_EN */
    1464         { 0x47, 0x01, 0x0002 }, /* ASP1/2_EN=0, ASP1_STP=1 */
    1465         { 0x47, 0x02, 0x0a80 }, /* ASP1/2_BUS_IDLE=10, +GPIO_I2C */
    1466         { 0x47, 0x19, 0x0800 }, /* ASP1.A: TX.LAP=0, TX.LSZ=24 bits, TX.LCS=0 */
    1467         { 0x47, 0x1a, 0x0820 }, /* ASP1.A: TX.RAP=0, TX.RSZ=24 bits, TX.RCS=32 */
    1468         { 0x47, 0x29, 0x0800 }, /* ASP2.A: TX.LAP=0, TX.LSZ=24 bits, TX.LCS=0 */
    1469         { 0x47, 0x2a, 0x2800 }, /* ASP2.A: TX.RAP=1, TX.RSZ=24 bits, TX.RCS=0 */
    1470         { 0x47, 0x39, 0x0800 }, /* ASP1.A: RX.LAP=0, RX.LSZ=24 bits, RX.LCS=0 */
    1471         { 0x47, 0x3a, 0x0800 }, /* ASP1.A: RX.RAP=0, RX.RSZ=24 bits, RX.RCS=0 */
    1472         { 0x47, 0x03, 0x8000 }, /* ASP1: LCHI = 00h */
    1473         { 0x47, 0x04, 0x28ff }, /* ASP1: MC/SC_SRCSEL=PLL1, LCPR=FFh */
    1474         { 0x47, 0x05, 0x0062 }, /* ASP1: MCEN=0, FSD=011, SCPOL_IN/OUT=0, SCDIV=1:4 */
    1475         { 0x47, 0x06, 0x801f }, /* ASP2: LCHI=1Fh */
    1476         { 0x47, 0x07, 0x283f }, /* ASP2: MC/SC_SRCSEL=PLL1, LCPR=3Fh */
    1477         { 0x47, 0x08, 0x805c }, /* ASP2: 5050=1, MCEN=0, FSD=010, SCPOL_IN/OUT=1, SCDIV=1:16 */
    1478         { 0x47, 0x09, 0x0023 }, /* DMIC1_MO=10b, DMIC1/2_SR=1 */
    1479         { 0x47, 0x0a, 0x0000 }, /* ASP1/2_BEEP=0 */
    1480         { 0x47, 0x01, 0x0062 }, /* ASP1/2_EN=1, ASP1_STP=1 */
    1481         { 0x47, 0x00, 0x9008 }, /* -PLL2_EN */
    1482         { 0x47, 0x68, 0x0000 }, /* TX2.A: pre-scale att.=0 dB */
    1483         { 0x47, 0x82, 0xfc03 }, /* ASP1/2_xxx_EN=1, ASP1/2_MCLK_EN=0, DMIC1_SCL_EN=1 */
    1484         { 0x47, 0xc0, 0x9999 }, /* test mode on */
    1485         { 0x47, 0xc5, 0x0000 }, /* GPIO hysteresis = 30 us */
    1486         { 0x47, 0xc0, 0x0000 }, /* test mode off */
    1487         {0} /* Terminator */
    1488 };
    1489 
    1490 static const struct cs8409_cir_param cs8409_cs42l42_bullseye_atn[] = {
    1491         { 0x47, 0x65, 0x4000 }, /* EQ_SEL=1, EQ1/2_EN=0 */
    1492         { 0x47, 0x64, 0x4000 }, /* +EQ_ACC */
    1493         { 0x47, 0x65, 0x4010 }, /* +EQ2_EN */
    1494         { 0x47, 0x63, 0x0647 }, /* EQ_DATA_HI=0x0647 */
    1495         { 0x47, 0x64, 0xc0c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=0, EQ_DATA_LO=0x67 */
    1496         { 0x47, 0x63, 0x0647 }, /* EQ_DATA_HI=0x0647 */
    1497         { 0x47, 0x64, 0xc1c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=1, EQ_DATA_LO=0x67 */
    1498         { 0x47, 0x63, 0xf370 }, /* EQ_DATA_HI=0xf370 */
    1499         { 0x47, 0x64, 0xc271 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=2, EQ_DATA_LO=0x71 */
    1500         { 0x47, 0x63, 0x1ef8 }, /* EQ_DATA_HI=0x1ef8 */
    1501         { 0x47, 0x64, 0xc348 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=3, EQ_DATA_LO=0x48 */
    1502         { 0x47, 0x63, 0xc110 }, /* EQ_DATA_HI=0xc110 */
    1503         { 0x47, 0x64, 0xc45a }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=4, EQ_DATA_LO=0x5a */
    1504         { 0x47, 0x63, 0x1f29 }, /* EQ_DATA_HI=0x1f29 */
    1505         { 0x47, 0x64, 0xc574 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=5, EQ_DATA_LO=0x74 */
    1506         { 0x47, 0x63, 0x1d7a }, /* EQ_DATA_HI=0x1d7a */
    1507         { 0x47, 0x64, 0xc653 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=6, EQ_DATA_LO=0x53 */
    1508         { 0x47, 0x63, 0xc38c }, /* EQ_DATA_HI=0xc38c */
    1509         { 0x47, 0x64, 0xc714 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=7, EQ_DATA_LO=0x14 */
    1510         { 0x47, 0x63, 0x1ca3 }, /* EQ_DATA_HI=0x1ca3 */
    1511         { 0x47, 0x64, 0xc8c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=8, EQ_DATA_LO=0xc7 */
    1512         { 0x47, 0x63, 0xc38c }, /* EQ_DATA_HI=0xc38c */
    1513         { 0x47, 0x64, 0xc914 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=9, EQ_DATA_LO=0x14 */
    1514         { 0x47, 0x64, 0x0000 }, /* -EQ_ACC, -EQ_WRT */
    1515         {0} /* Terminator */
    1516 };
    1517 
    1518 /**
    1519  * cs8409_enable_i2c_clock - Enable I2C clocks
    1520  * @codec: the codec instance
    1521  * @enable: Enable or disable I2C clocks
    1522  *
    1523  * Enable or Disable I2C clocks.
    1524  */
    1525 static void cs8409_enable_i2c_clock(struct hda_codec *codec, unsigned int enable)
    1526 {
    1527         unsigned int retval;
    1528         unsigned int newval;
    1529 
    1530         retval = cs_vendor_coef_get(codec, 0x0);
    1531         newval = (enable) ? (retval | 0x8) : (retval & 0xfffffff7);
    1532         cs_vendor_coef_set(codec, 0x0, newval);
    1533 }
    1534 
    1535 /**
    1536  * cs8409_i2c_wait_complete - Wait for I2C transaction
    1537  * @codec: the codec instance
    1538  *
    1539  * Wait for I2C transaction to complete.
    1540  * Return -1 if transaction wait times out.
    1541  */
    1542 static int cs8409_i2c_wait_complete(struct hda_codec *codec)
    1543 {
    1544         int repeat = 5;
    1545         unsigned int retval;
    1546 
    1547         do {
    1548                 retval = cs_vendor_coef_get(codec, CIR_I2C_STATUS);
    1549                 if ((retval & 0x18) != 0x18) {
    1550                         usleep_range(2000, 4000);
    1551                         --repeat;
    1552                 } else
    1553                         return 0;
    1554 
    1555         } while (repeat);
    1556 
    1557         return -1;
    1558 }
    1559 
    1560 /**
    1561  * cs8409_i2c_read - CS8409 I2C Read.
    1562  * @codec: the codec instance
    1563  * @i2c_address: I2C Address
    1564  * @i2c_reg: Register to read
    1565  * @paged: Is a paged transaction
    1566  *
    1567  * CS8409 I2C Read.
    1568  * Returns negative on error, otherwise returns read value in bits 0-7.
    1569  */
    1570 static int cs8409_i2c_read(struct hda_codec *codec,
    1571                 unsigned int i2c_address,
    1572                 unsigned int i2c_reg,
    1573                 unsigned int paged)
    1574 {
    1575         unsigned int i2c_reg_data;
    1576         unsigned int read_data;
    1577 
    1578         cs8409_enable_i2c_clock(codec, 1);
    1579         cs_vendor_coef_set(codec, CIR_I2C_ADDR, i2c_address);
    1580 
    1581         if (paged) {
    1582                 cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg >> 8);
    1583                 if (cs8409_i2c_wait_complete(codec) < 0) {
    1584                         codec_err(codec,
    1585                                 "%s() Paged Transaction Failed 0x%02x : 0x%04x\n",
    1586                                 __func__, i2c_address, i2c_reg);
    1587                         return -EIO;
    1588                 }
    1589         }
    1590 
    1591         i2c_reg_data = (i2c_reg << 8) & 0x0ffff;
    1592         cs_vendor_coef_set(codec, CIR_I2C_QREAD, i2c_reg_data);
    1593         if (cs8409_i2c_wait_complete(codec) < 0) {
    1594                 codec_err(codec, "%s() Transaction Failed 0x%02x : 0x%04x\n",
    1595                         __func__, i2c_address, i2c_reg);
    1596                 return -EIO;
    1597         }
    1598 
    1599         /* Register in bits 15-8 and the data in 7-0 */
    1600         read_data = cs_vendor_coef_get(codec, CIR_I2C_QREAD);
    1601 
    1602         cs8409_enable_i2c_clock(codec, 0);
    1603 
    1604         return read_data & 0x0ff;
    1605 }
    1606 
    1607 /**
    1608  * cs8409_i2c_write - CS8409 I2C Write.
    1609  * @codec: the codec instance
    1610  * @i2c_address: I2C Address
    1611  * @i2c_reg: Register to write to
    1612  * @i2c_data: Data to write
    1613  * @paged: Is a paged transaction
    1614  *
    1615  * CS8409 I2C Write.
    1616  * Returns negative on error, otherwise returns 0.
    1617  */
    1618 static int cs8409_i2c_write(struct hda_codec *codec,
    1619                 unsigned int i2c_address, unsigned int i2c_reg,
    1620                 unsigned int i2c_data,
    1621                 unsigned int paged)
    1622 {
    1623         unsigned int i2c_reg_data;
    1624 
    1625         cs8409_enable_i2c_clock(codec, 1);
    1626         cs_vendor_coef_set(codec, CIR_I2C_ADDR, i2c_address);
    1627 
    1628         if (paged) {
    1629                 cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg >> 8);
    1630                 if (cs8409_i2c_wait_complete(codec) < 0) {
    1631                         codec_err(codec,
    1632                                 "%s() Paged Transaction Failed 0x%02x : 0x%04x\n",
    1633                                 __func__, i2c_address, i2c_reg);
    1634                         return -EIO;
    1635                 }
    1636         }
    1637 
    1638         i2c_reg_data = ((i2c_reg << 8) & 0x0ff00) | (i2c_data & 0x0ff);
    1639         cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg_data);
    1640 
    1641         if (cs8409_i2c_wait_complete(codec) < 0) {
    1642                 codec_err(codec, "%s() Transaction Failed 0x%02x : 0x%04x\n",
    1643                         __func__, i2c_address, i2c_reg);
    1644                 return -EIO;
    1645         }
    1646 
    1647         cs8409_enable_i2c_clock(codec, 0);
    1648 
    1649         return 0;
    1650 }
    1651 
    1652 static int cs8409_cs42l42_volume_info(struct snd_kcontrol *kcontrol,
    1653                                   struct snd_ctl_elem_info *uinfo)
    1654 {
    1655         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    1656         u16 nid = get_amp_nid(kcontrol);
    1657         u8 chs = get_amp_channels(kcontrol);
    1658 
    1659         codec_dbg(codec, "%s() nid: %d\n", __func__, nid);
    1660         switch (nid) {
    1661         case CS8409_CS42L42_HP_PIN_NID:
    1662                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
    1663                 uinfo->count = chs == 3 ? 2 : 1;
    1664                 uinfo->value.integer.min = CS8409_CS42L42_HP_VOL_REAL_MIN;
    1665                 uinfo->value.integer.max = CS8409_CS42L42_HP_VOL_REAL_MAX;
    1666                 break;
    1667         case CS8409_CS42L42_AMIC_PIN_NID:
    1668                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
    1669                 uinfo->count = chs == 3 ? 2 : 1;
    1670                 uinfo->value.integer.min = CS8409_CS42L42_AMIC_VOL_REAL_MIN;
    1671                 uinfo->value.integer.max = CS8409_CS42L42_AMIC_VOL_REAL_MAX;
    1672                 break;
    1673         default:
    1674                 break;
    1675         }
    1676         return 0;
    1677 }
    1678 
    1679 static void cs8409_cs42l42_update_volume(struct hda_codec *codec)
    1680 {
    1681         struct cs_spec *spec = codec->spec;
    1682         int data;
    1683 
    1684         mutex_lock(&spec->cs8409_i2c_mux);
    1685         data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
    1686                                 CS8409_CS42L42_REG_HS_VOLUME_CHA, 1);
    1687         if (data >= 0)
    1688                 spec->cs42l42_hp_volume[0] = -data;
    1689         else
    1690                 spec->cs42l42_hp_volume[0] = CS8409_CS42L42_HP_VOL_REAL_MIN;
    1691         data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
    1692                                 CS8409_CS42L42_REG_HS_VOLUME_CHB, 1);
    1693         if (data >= 0)
    1694                 spec->cs42l42_hp_volume[1] = -data;
    1695         else
    1696                 spec->cs42l42_hp_volume[1] = CS8409_CS42L42_HP_VOL_REAL_MIN;
    1697         data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
    1698                                 CS8409_CS42L42_REG_AMIC_VOLUME, 1);
    1699         if (data >= 0)
    1700                 spec->cs42l42_hs_mic_volume[0] = -data;
    1701         else
    1702                 spec->cs42l42_hs_mic_volume[0] = CS8409_CS42L42_AMIC_VOL_REAL_MIN;
    1703         mutex_unlock(&spec->cs8409_i2c_mux);
    1704         spec->cs42l42_volume_init = 1;
    1705 }
    1706 
    1707 static int cs8409_cs42l42_volume_get(struct snd_kcontrol *kcontrol,
    1708                                  struct snd_ctl_elem_value *ucontrol)
    1709 {
    1710         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    1711         struct cs_spec *spec = codec->spec;
    1712         hda_nid_t nid = get_amp_nid(kcontrol);
    1713         int chs = get_amp_channels(kcontrol);
    1714         long *valp = ucontrol->value.integer.value;
    1715 
    1716         if (!spec->cs42l42_volume_init) {
    1717                 snd_hda_power_up(codec);
    1718                 cs8409_cs42l42_update_volume(codec);
    1719                 snd_hda_power_down(codec);
    1720         }
    1721         switch (nid) {
    1722         case CS8409_CS42L42_HP_PIN_NID:
    1723                 if (chs & BIT(0))
    1724                         *valp++ = spec->cs42l42_hp_volume[0];
    1725                 if (chs & BIT(1))
    1726                         *valp++ = spec->cs42l42_hp_volume[1];
    1727                 break;
    1728         case CS8409_CS42L42_AMIC_PIN_NID:
    1729                 if (chs & BIT(0))
    1730                         *valp++ = spec->cs42l42_hs_mic_volume[0];
    1731                 break;
    1732         default:
    1733                 break;
    1734         }
    1735         return 0;
    1736 }
    1737 
    1738 static int cs8409_cs42l42_volume_put(struct snd_kcontrol *kcontrol,
    1739                                  struct snd_ctl_elem_value *ucontrol)
    1740 {
    1741         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    1742         struct cs_spec *spec = codec->spec;
    1743         hda_nid_t nid = get_amp_nid(kcontrol);
    1744         int chs = get_amp_channels(kcontrol);
    1745         long *valp = ucontrol->value.integer.value;
    1746         int change = 0;
    1747         char vol;
    1748 
    1749         snd_hda_power_up(codec);
    1750         switch (nid) {
    1751         case CS8409_CS42L42_HP_PIN_NID:
    1752                 mutex_lock(&spec->cs8409_i2c_mux);
    1753                 if (chs & BIT(0)) {
    1754                         vol = -(*valp);
    1755                         change = cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
    1756                                 CS8409_CS42L42_REG_HS_VOLUME_CHA, vol, 1);
    1757                         valp++;
    1758                 }
    1759                 if (chs & BIT(1)) {
    1760                         vol = -(*valp);
    1761                         change |= cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
    1762                                 CS8409_CS42L42_REG_HS_VOLUME_CHB, vol, 1);
    1763                 }
    1764                 mutex_unlock(&spec->cs8409_i2c_mux);
    1765                 break;
    1766         case CS8409_CS42L42_AMIC_PIN_NID:
    1767                 mutex_lock(&spec->cs8409_i2c_mux);
    1768                 if (chs & BIT(0)) {
    1769                         change = cs8409_i2c_write(
    1770                                 codec, CS42L42_I2C_ADDR,
    1771                                 CS8409_CS42L42_REG_AMIC_VOLUME, (char)*valp, 1);
    1772                         valp++;
    1773                 }
    1774                 mutex_unlock(&spec->cs8409_i2c_mux);
    1775                 break;
    1776         default:
    1777                 break;
    1778         }
    1779         cs8409_cs42l42_update_volume(codec);
    1780         snd_hda_power_down(codec);
    1781         return change;
    1782 }
    1783 
    1784 static const DECLARE_TLV_DB_SCALE(
    1785         cs8409_cs42l42_hp_db_scale,
    1786         CS8409_CS42L42_HP_VOL_REAL_MIN * 100, 100, 1);
    1787 
    1788 static const DECLARE_TLV_DB_SCALE(
    1789         cs8409_cs42l42_amic_db_scale,
    1790         CS8409_CS42L42_AMIC_VOL_REAL_MIN * 100, 100, 1);
    1791 
    1792 static const struct snd_kcontrol_new cs8409_cs42l42_hp_volume_mixer = {
    1793         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1794         .index = 0,
    1795         .name = "Headphone Playback Volume",
    1796         .subdevice = (HDA_SUBDEV_AMP_FLAG | HDA_SUBDEV_NID_FLAG),
    1797         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE
    1798                          | SNDRV_CTL_ELEM_ACCESS_TLV_READ),
    1799         .info = cs8409_cs42l42_volume_info,
    1800         .get = cs8409_cs42l42_volume_get,
    1801         .put = cs8409_cs42l42_volume_put,
    1802         .tlv = { .p = cs8409_cs42l42_hp_db_scale },
    1803         .private_value = HDA_COMPOSE_AMP_VAL(
    1804                 CS8409_CS42L42_HP_PIN_NID, 3, 0, HDA_OUTPUT)
    1805                 | HDA_AMP_VAL_MIN_MUTE
    1806 };
    1807 
    1808 static const struct snd_kcontrol_new cs8409_cs42l42_amic_volume_mixer = {
    1809         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1810         .index = 0,
    1811         .name = "Mic Capture Volume",
    1812         .subdevice = (HDA_SUBDEV_AMP_FLAG | HDA_SUBDEV_NID_FLAG),
    1813         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE
    1814                          | SNDRV_CTL_ELEM_ACCESS_TLV_READ),
    1815         .info = cs8409_cs42l42_volume_info,
    1816         .get = cs8409_cs42l42_volume_get,
    1817         .put = cs8409_cs42l42_volume_put,
    1818         .tlv = { .p = cs8409_cs42l42_amic_db_scale },
    1819         .private_value = HDA_COMPOSE_AMP_VAL(
    1820                 CS8409_CS42L42_AMIC_PIN_NID, 1, 0, HDA_INPUT)
    1821                 | HDA_AMP_VAL_MIN_MUTE
    1822 };
    1823 
    1824 /* Assert/release RTS# line to CS42L42 */
    1825 static void cs8409_cs42l42_reset(struct hda_codec *codec)
    1826 {
    1827         struct cs_spec *spec = codec->spec;
    1828 
    1829         /* Assert RTS# line */
    1830         snd_hda_codec_write(codec,
    1831                         codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, 0);
    1832         /* wait ~10ms */
    1833         usleep_range(10000, 15000);
    1834         /* Release RTS# line */
    1835         snd_hda_codec_write(codec,
    1836                         codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, GPIO5_INT);
    1837         /* wait ~10ms */
    1838         usleep_range(10000, 15000);
    1839 
    1840         mutex_lock(&spec->cs8409_i2c_mux);
    1841 
    1842         /* Clear interrupts, by reading interrupt status registers */
    1843         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
    1844         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1309, 1);
    1845         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130A, 1);
    1846         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130F, 1);
    1847 
    1848         mutex_unlock(&spec->cs8409_i2c_mux);
    1849 
    1850 }
    1851 
    1852 /* Configure CS42L42 slave codec for jack autodetect */
    1853 static void cs8409_cs42l42_enable_jack_detect(struct hda_codec *codec)
    1854 {
    1855         struct cs_spec *spec = codec->spec;
    1856 
    1857         mutex_lock(&spec->cs8409_i2c_mux);
    1858 
    1859         /* Set TIP_SENSE_EN for analog front-end of tip sense. */
    1860         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b70, 0x0020, 1);
    1861         /* Clear WAKE# */
    1862         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b71, 0x0001, 1);
    1863         /* Wait ~2.5ms */
    1864         usleep_range(2500, 3000);
    1865         /* Set mode WAKE# output follows the combination logic directly */
    1866         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b71, 0x0020, 1);
    1867         /* Clear interrupts status */
    1868         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130f, 1);
    1869         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b7b, 1);
    1870         /* Enable interrupt */
    1871         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1320, 0x03, 1);
    1872         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b79, 0x00, 1);
    1873 
    1874         mutex_unlock(&spec->cs8409_i2c_mux);
    1875 }
    1876 
    1877 /* Enable and run CS42L42 slave codec jack auto detect */
    1878 static void cs8409_cs42l42_run_jack_detect(struct hda_codec *codec)
    1879 {
    1880         struct cs_spec *spec = codec->spec;
    1881 
    1882         mutex_lock(&spec->cs8409_i2c_mux);
    1883 
    1884         /* Clear interrupts */
    1885         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
    1886         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b77, 1);
    1887 
    1888         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1102, 0x87, 1);
    1889         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1f06, 0x86, 1);
    1890         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b74, 0x07, 1);
    1891         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x131b, 0x01, 1);
    1892         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1120, 0x80, 1);
    1893         /* Wait ~110ms*/
    1894         usleep_range(110000, 200000);
    1895         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x111f, 0x77, 1);
    1896         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1120, 0xc0, 1);
    1897         /* Wait ~10ms */
    1898         usleep_range(10000, 25000);
    1899 
    1900         mutex_unlock(&spec->cs8409_i2c_mux);
    1901 
    1902 }
    1903 
    1904 static void cs8409_cs42l42_reg_setup(struct hda_codec *codec)
    1905 {
    1906         const struct cs8409_i2c_param *seq = cs42l42_init_reg_seq;
    1907         struct cs_spec *spec = codec->spec;
    1908 
    1909         mutex_lock(&spec->cs8409_i2c_mux);
    1910 
    1911         for (; seq->addr; seq++)
    1912                 cs8409_i2c_write(codec, CS42L42_I2C_ADDR, seq->addr, seq->reg, 1);
    1913 
    1914         mutex_unlock(&spec->cs8409_i2c_mux);
    1915 
    1916 }
    1917 
    1918 /*
    1919  * In the case of CS8409 we do not have unsolicited events from NID's 0x24
    1920  * and 0x34 where hs mic and hp are connected. Companion codec CS42L42 will
    1921  * generate interrupt via gpio 4 to notify jack events. We have to overwrite
    1922  * generic snd_hda_jack_unsol_event(), read CS42L42 jack detect status registers
    1923  * and then notify status via generic snd_hda_jack_unsol_event() call.
    1924  */
    1925 static void cs8409_jack_unsol_event(struct hda_codec *codec, unsigned int res)
    1926 {
    1927         struct cs_spec *spec = codec->spec;
    1928         int status_changed = 0;
    1929         int reg_cdc_status;
    1930         int reg_hs_status;
    1931         int reg_ts_status;
    1932         int type;
    1933         struct hda_jack_tbl *jk;
    1934 
    1935         /* jack_unsol_event() will be called every time gpio line changing state.
    1936          * In this case gpio4 line goes up as a result of reading interrupt status
    1937          * registers in previous cs8409_jack_unsol_event() call.
    1938          * We don't need to handle this event, ignoring...
    1939          */
    1940         if ((res & (1 << 4)))
    1941                 return;
    1942 
    1943         mutex_lock(&spec->cs8409_i2c_mux);
    1944 
    1945         /* Read jack detect status registers */
    1946         reg_cdc_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
    1947         reg_hs_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1124, 1);
    1948         reg_ts_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130f, 1);
    1949 
    1950         /* Clear interrupts, by reading interrupt status registers */
    1951         cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b7b, 1);
    1952 
    1953         mutex_unlock(&spec->cs8409_i2c_mux);
    1954 
    1955         /* If status values are < 0, read error has occurred. */
    1956         if (reg_cdc_status < 0 || reg_hs_status < 0 || reg_ts_status < 0)
    1957                 return;
    1958 
    1959         /* HSDET_AUTO_DONE */
    1960         if (reg_cdc_status & CS42L42_HSDET_AUTO_DONE) {
    1961 
    1962                 type = ((reg_hs_status & CS42L42_HSTYPE_MASK) + 1);
    1963                 /* CS42L42 reports optical jack as type 4
    1964                  * We don't handle optical jack
    1965                  */
    1966                 if (type != 4) {
    1967                         if (!spec->cs42l42_hp_jack_in) {
    1968                                 status_changed = 1;
    1969                                 spec->cs42l42_hp_jack_in = 1;
    1970                         }
    1971                         /* type = 3 has no mic */
    1972                         if ((!spec->cs42l42_mic_jack_in) && (type != 3)) {
    1973                                 status_changed = 1;
    1974                                 spec->cs42l42_mic_jack_in = 1;
    1975                         }
    1976                 } else {
    1977                         if (spec->cs42l42_hp_jack_in || spec->cs42l42_mic_jack_in) {
    1978                                 status_changed = 1;
    1979                                 spec->cs42l42_hp_jack_in = 0;
    1980                                 spec->cs42l42_mic_jack_in = 0;
    1981                         }
    1982                 }
    1983 
    1984         } else {
    1985                 /* TIP_SENSE INSERT/REMOVE */
    1986                 switch (reg_ts_status) {
    1987                 case CS42L42_JACK_INSERTED:
    1988                         cs8409_cs42l42_run_jack_detect(codec);
    1989                         break;
    1990 
    1991                 case CS42L42_JACK_REMOVED:
    1992                         if (spec->cs42l42_hp_jack_in || spec->cs42l42_mic_jack_in) {
    1993                                 status_changed = 1;
    1994                                 spec->cs42l42_hp_jack_in = 0;
    1995                                 spec->cs42l42_mic_jack_in = 0;
    1996                         }
    1997                         break;
    1998 
    1999                 default:
    2000                         /* jack in transition */
    2001                         status_changed = 0;
    2002                         break;
    2003                 }
    2004         }
    2005 
    2006         if (status_changed) {
    2007 
    2008                 snd_hda_set_pin_ctl(codec, CS8409_CS42L42_SPK_PIN_NID,
    2009                                 spec->cs42l42_hp_jack_in ? 0 : PIN_OUT);
    2010 
    2011                 /* Report jack*/
    2012                 jk = snd_hda_jack_tbl_get_mst(codec, CS8409_CS42L42_HP_PIN_NID, 0);
    2013                 if (jk) {
    2014                         snd_hda_jack_unsol_event(codec,
    2015                                 (jk->tag << AC_UNSOL_RES_TAG_SHIFT) & AC_UNSOL_RES_TAG);
    2016                 }
    2017                 /* Report jack*/
    2018                 jk = snd_hda_jack_tbl_get_mst(codec, CS8409_CS42L42_AMIC_PIN_NID, 0);
    2019                 if (jk) {
    2020                         snd_hda_jack_unsol_event(codec,
    2021                                 (jk->tag << AC_UNSOL_RES_TAG_SHIFT) & AC_UNSOL_RES_TAG);
    2022                 }
    2023         }
    2024 }
    2025 
    2026 #ifdef CONFIG_PM
    2027 /* Manage PDREF, when transition to D3hot */
    2028 static int cs8409_suspend(struct hda_codec *codec)
    2029 {
    2030         struct cs_spec *spec = codec->spec;
    2031 
    2032         mutex_lock(&spec->cs8409_i2c_mux);
    2033         /* Power down CS42L42 ASP/EQ/MIX/HP */
    2034         cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1101, 0xfe, 1);
    2035         mutex_unlock(&spec->cs8409_i2c_mux);
    2036         /* Assert CS42L42 RTS# line */
    2037         snd_hda_codec_write(codec,
    2038                         codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, 0);
    2039 
    2040         snd_hda_shutup_pins(codec);
    2041 
    2042         return 0;
    2043 }
    2044 #endif
    2045 
    2046 /* Enable/Disable Unsolicited Response for gpio(s) 3,4 */
    2047 static void cs8409_enable_ur(struct hda_codec *codec, int flag)
    2048 {
    2049         /* GPIO4 INT# and GPIO3 WAKE# */
    2050         snd_hda_codec_write(codec, codec->core.afg,
    2051                         0, AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK,
    2052                         flag ? (GPIO3_INT | GPIO4_INT) : 0);
    2053 
    2054         snd_hda_codec_write(codec, codec->core.afg,
    2055                         0, AC_VERB_SET_UNSOLICITED_ENABLE,
    2056                         flag ? AC_UNSOL_ENABLED : 0);
    2057 
    2058 }
    2059 
    2060 /* Vendor specific HW configuration
    2061  * PLL, ASP, I2C, SPI, GPIOs, DMIC etc...
    2062  */
    2063 static void cs8409_cs42l42_hw_init(struct hda_codec *codec)
    2064 {
    2065         const struct cs8409_cir_param *seq = cs8409_cs42l42_hw_cfg;
    2066         const struct cs8409_cir_param *seq_bullseye = cs8409_cs42l42_bullseye_atn;
    2067         struct cs_spec *spec = codec->spec;
    2068 
    2069         if (spec->gpio_mask) {
    2070                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
    2071                                     spec->gpio_mask);
    2072                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
    2073                                     spec->gpio_dir);
    2074                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
    2075                                     spec->gpio_data);
    2076         }
    2077 
    2078         for (; seq->nid; seq++)
    2079                 cs_vendor_coef_set(codec, seq->cir, seq->coeff);
    2080 
    2081         if (codec->fixup_id == CS8409_BULLSEYE)
    2082                 for (; seq_bullseye->nid; seq_bullseye++)
    2083                         cs_vendor_coef_set(codec, seq_bullseye->cir, seq_bullseye->coeff);
    2084 
    2085         /* Disable Unsolicited Response during boot */
    2086         cs8409_enable_ur(codec, 0);
    2087 
    2088         /* Reset CS42L42 */
    2089         cs8409_cs42l42_reset(codec);
    2090 
    2091         /* Initialise CS42L42 companion codec */
    2092         cs8409_cs42l42_reg_setup(codec);
    2093 
    2094         if (codec->fixup_id == CS8409_WARLOCK ||
    2095                         codec->fixup_id == CS8409_CYBORG) {
    2096                 /* FULL_SCALE_VOL = 0 for Warlock / Cyborg */
    2097                 mutex_lock(&spec->cs8409_i2c_mux);
    2098                 cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x2001, 0x01, 1);
    2099                 mutex_unlock(&spec->cs8409_i2c_mux);
    2100                 /* DMIC1_MO=00b, DMIC1/2_SR=1 */
    2101                 cs_vendor_coef_set(codec, 0x09, 0x0003);
    2102         }
    2103 
    2104         /* Restore Volumes after Resume */
    2105         if (spec->cs42l42_volume_init) {
    2106                 mutex_lock(&spec->cs8409_i2c_mux);
    2107                 cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
    2108                                         CS8409_CS42L42_REG_HS_VOLUME_CHA,
    2109                                         -spec->cs42l42_hp_volume[0],
    2110                                         1);
    2111                 cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
    2112                                         CS8409_CS42L42_REG_HS_VOLUME_CHB,
    2113                                         -spec->cs42l42_hp_volume[1],
    2114                                         1);
    2115                 cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
    2116                                         CS8409_CS42L42_REG_AMIC_VOLUME,
    2117                                         spec->cs42l42_hs_mic_volume[0],
    2118                                         1);
    2119                 mutex_unlock(&spec->cs8409_i2c_mux);
    2120         }
    2121 
    2122         cs8409_cs42l42_update_volume(codec);
    2123 
    2124         cs8409_cs42l42_enable_jack_detect(codec);
    2125 
    2126         /* Enable Unsolicited Response */
    2127         cs8409_enable_ur(codec, 1);
    2128 }
    2129 
    2130 static int cs8409_cs42l42_init(struct hda_codec *codec)
    2131 {
    2132         int ret = snd_hda_gen_init(codec);
    2133 
    2134         if (!ret)
    2135                 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
    2136 
    2137         return ret;
    2138 }
    2139 
    2140 static const struct hda_codec_ops cs8409_cs42l42_patch_ops = {
    2141         .build_controls = cs_build_controls,
    2142         .build_pcms = snd_hda_gen_build_pcms,
    2143         .init = cs8409_cs42l42_init,
    2144         .free = cs_free,
    2145         .unsol_event = cs8409_jack_unsol_event,
    2146 #ifdef CONFIG_PM
    2147         .suspend = cs8409_suspend,
    2148 #endif
    2149 };
    2150 
    2151 static void cs8409_cs42l42_fixups(struct hda_codec *codec,
    2152                                     const struct hda_fixup *fix, int action)
    2153 {
    2154         struct cs_spec *spec = codec->spec;
    2155         int caps;
    2156 
    2157         switch (action) {
    2158         case HDA_FIXUP_ACT_PRE_PROBE:
    2159                 snd_hda_add_verbs(codec, cs8409_cs42l42_init_verbs);
    2160                 /* verb exec op override */
    2161                 spec->exec_verb = codec->core.exec_verb;
    2162                 codec->core.exec_verb = cs8409_cs42l42_exec_verb;
    2163 
    2164                 mutex_init(&spec->cs8409_i2c_mux);
    2165 
    2166                 codec->patch_ops = cs8409_cs42l42_patch_ops;
    2167 
    2168                 spec->gen.suppress_auto_mute = 1;
    2169                 spec->gen.no_primary_hp = 1;
    2170                 spec->gen.suppress_vmaster = 1;
    2171 
    2172                 /* GPIO 5 out, 3,4 in */
    2173                 spec->gpio_dir = GPIO5_INT;
    2174                 spec->gpio_data = 0;
    2175                 spec->gpio_mask = 0x03f;
    2176 
    2177                 spec->cs42l42_hp_jack_in = 0;
    2178                 spec->cs42l42_mic_jack_in = 0;
    2179 
    2180                 /* Basic initial sequence for specific hw configuration */
    2181                 snd_hda_sequence_write(codec, cs8409_cs42l42_init_verbs);
    2182 
    2183                 /* CS8409 is simple HDA bridge and intended to be used with a remote
    2184                  * companion codec. Most of input/output PIN(s) have only basic
    2185                  * capabilities. NID(s) 0x24 and 0x34 have only OUTC and INC
    2186                  * capabilities and no presence detect capable (PDC) and call to
    2187                  * snd_hda_gen_build_controls() will mark them as non detectable
    2188                  * phantom jacks. However, in this configuration companion codec
    2189                  * CS42L42 is connected to these pins and it has jack detect
    2190                  * capabilities. We have to override pin capabilities,
    2191                  * otherwise they will not be created as input devices.
    2192                  */
    2193                 caps = snd_hdac_read_parm(&codec->core, CS8409_CS42L42_HP_PIN_NID,
    2194                                 AC_PAR_PIN_CAP);
    2195                 if (caps >= 0)
    2196                         snd_hdac_override_parm(&codec->core,
    2197                                 CS8409_CS42L42_HP_PIN_NID, AC_PAR_PIN_CAP,
    2198                                 (caps | (AC_PINCAP_IMP_SENSE | AC_PINCAP_PRES_DETECT)));
    2199 
    2200                 caps = snd_hdac_read_parm(&codec->core, CS8409_CS42L42_AMIC_PIN_NID,
    2201                                 AC_PAR_PIN_CAP);
    2202                 if (caps >= 0)
    2203                         snd_hdac_override_parm(&codec->core,
    2204                                 CS8409_CS42L42_AMIC_PIN_NID, AC_PAR_PIN_CAP,
    2205                                 (caps | (AC_PINCAP_IMP_SENSE | AC_PINCAP_PRES_DETECT)));
    2206 
    2207                 snd_hda_override_wcaps(codec, CS8409_CS42L42_HP_PIN_NID,
    2208                         (get_wcaps(codec, CS8409_CS42L42_HP_PIN_NID) | AC_WCAP_UNSOL_CAP));
    2209 
    2210                 snd_hda_override_wcaps(codec, CS8409_CS42L42_AMIC_PIN_NID,
    2211                         (get_wcaps(codec, CS8409_CS42L42_AMIC_PIN_NID) | AC_WCAP_UNSOL_CAP));
    2212                 break;
    2213         case HDA_FIXUP_ACT_PROBE:
    2214 
    2215                 /* Set initial DMIC volume to -26 dB */
    2216                 snd_hda_codec_amp_init_stereo(codec, CS8409_CS42L42_DMIC_ADC_PIN_NID,
    2217                                 HDA_INPUT, 0, 0xff, 0x19);
    2218                 snd_hda_gen_add_kctl(&spec->gen,
    2219                         NULL, &cs8409_cs42l42_hp_volume_mixer);
    2220                 snd_hda_gen_add_kctl(&spec->gen,
    2221                         NULL, &cs8409_cs42l42_amic_volume_mixer);
    2222                 cs8409_cs42l42_hw_init(codec);
    2223                 snd_hda_codec_set_name(codec, "CS8409/CS42L42");
    2224                 break;
    2225         case HDA_FIXUP_ACT_INIT:
    2226                 cs8409_cs42l42_hw_init(codec);
    2227                 fallthrough;
    2228         case HDA_FIXUP_ACT_BUILD:
    2229                 /* Run jack auto detect first time on boot
    2230                  * after controls have been added, to check if jack has
    2231                  * been already plugged in.
    2232                  * Run immediately after init.
    2233                  */
    2234                 cs8409_cs42l42_run_jack_detect(codec);
    2235                 usleep_range(100000, 150000);
    2236                 break;
    2237         default:
    2238                 break;
    2239         }
    2240 }
    2241 
    2242 static int cs8409_cs42l42_exec_verb(struct hdac_device *dev,
    2243                 unsigned int cmd, unsigned int flags, unsigned int *res)
    2244 {
    2245         struct hda_codec *codec = container_of(dev, struct hda_codec, core);
    2246         struct cs_spec *spec = codec->spec;
    2247 
    2248         unsigned int nid = ((cmd >> 20) & 0x07f);
    2249         unsigned int verb = ((cmd >> 8) & 0x0fff);
    2250 
    2251         /* CS8409 pins have no AC_PINSENSE_PRESENCE
    2252          * capabilities. We have to intercept 2 calls for pins 0x24 and 0x34
    2253          * and return correct pin sense values for read_pin_sense() call from
    2254          * hda_jack based on CS42L42 jack detect status.
    2255          */
    2256         switch (nid) {
    2257         case CS8409_CS42L42_HP_PIN_NID:
    2258                 if (verb == AC_VERB_GET_PIN_SENSE) {
    2259                         *res = (spec->cs42l42_hp_jack_in) ? AC_PINSENSE_PRESENCE : 0;
    2260                         return 0;
    2261                 }
    2262                 break;
    2263 
    2264         case CS8409_CS42L42_AMIC_PIN_NID:
    2265                 if (verb == AC_VERB_GET_PIN_SENSE) {
    2266                         *res = (spec->cs42l42_mic_jack_in) ? AC_PINSENSE_PRESENCE : 0;
    2267                         return 0;
    2268                 }
    2269                 break;
    2270 
    2271         default:
    2272                 break;
    2273         }
    2274 
    2275         return spec->exec_verb(dev, cmd, flags, res);
    2276 }
    2277 
    2278 static int patch_cs8409(struct hda_codec *codec)
    2279 {
    2280         int err;
    2281 
    2282         if (!cs_alloc_spec(codec, CS8409_VENDOR_NID))
    2283                 return -ENOMEM;
    2284 
    2285         snd_hda_pick_fixup(codec,
    2286                         cs8409_models, cs8409_fixup_tbl, cs8409_fixups);
    2287 
    2288         codec_dbg(codec, "Picked ID=%d, VID=%08x, DEV=%08x\n",
    2289                         codec->fixup_id,
    2290                         codec->bus->pci->subsystem_vendor,
    2291                         codec->bus->pci->subsystem_device);
    2292 
    2293         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
    2294 
    2295         err = cs_parse_auto_config(codec);
    2296         if (err < 0) {
    2297                 cs_free(codec);
    2298                 return err;
    2299         }
    2300 
    2301         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
    2302         return 0;
    2303 }
    2304 
    23051232/*
    23061233 * patch entries
    … …  
    23121239        HDA_CODEC_ENTRY(0x10134210, "CS4210", patch_cs4210),
    23131240        HDA_CODEC_ENTRY(0x10134213, "CS4213", patch_cs4213),
    2314         HDA_CODEC_ENTRY(0x10138409, "CS8409", patch_cs8409),
    23151241        {0} /* terminator */
    23161242};

  • GPL/trunk/alsa-kernel/pci/hda/patch_conexant.c

    r695 r717  
    184184}
    185185
    186 static void cx_auto_reboot_notify(struct hda_codec *codec)
     186static void cx_auto_shutdown(struct hda_codec *codec)
    187187{
    188188        struct conexant_spec *spec = codec->spec;
    … …  
    191191           from the internal speaker during (and after) reboot */
    192192        cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);
    193         snd_hda_gen_reboot_notify(codec);
    194193}
    195194
    196195static void cx_auto_free(struct hda_codec *codec)
    197196{
    198         cx_auto_reboot_notify(codec);
     197        cx_auto_shutdown(codec);
    199198        snd_hda_gen_free(codec);
    200199}
     200
     201#ifdef CONFIG_PM
     202static int cx_auto_suspend(struct hda_codec *codec)
     203{
     204        cx_auto_shutdown(codec);
     205        return 0;
     206}
     207#endif
    201208
    202209static const struct hda_codec_ops cx_auto_patch_ops = {
    … …  
    204211        .build_pcms = snd_hda_gen_build_pcms,
    205212        .init = cx_auto_init,
    206         .reboot_notify = cx_auto_reboot_notify,
    207213        .free = cx_auto_free,
    208214        .unsol_event = snd_hda_jack_unsol_event,
    209215#ifdef CONFIG_PM
     216        .suspend = cx_auto_suspend,
    210217        .check_power_status = snd_hda_gen_check_power_status,
    211218#endif
    … …  
    9981005        SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
    9991006        SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE),
     1007        SND_PCI_QUIRK(0x103c, 0x82b4, "HP ProDesk 600 G3", CXT_FIXUP_HP_MIC_NO_PRESENCE),
    10001008        SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO),
    10011009        SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO),
    … …  
    11061114                                   cxt5051_fixups, cxt_fixups);
    11071115                break;
     1116        case 0x14f15098:
     1117                codec->pin_amp_workaround = 1;
     1118                spec->gen.mixer_nid = 0x22;
     1119                spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
     1120                snd_hda_pick_fixup(codec, cxt5066_fixup_models,
     1121                                   cxt5066_fixups, cxt_fixups);
     1122                break;
    11081123        case 0x14f150f2:
    11091124                codec->power_save_node = 1;
    … …  
    11261141                goto error;
    11271142
    1128         err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
     1143        err = cx_auto_parse_beep(codec);
    11291144        if (err < 0)
    11301145                goto error;
    11311146
    1132         err = cx_auto_parse_beep(codec);
     1147        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
    11331148        if (err < 0)
    11341149                goto error;

  • GPL/trunk/alsa-kernel/pci/hda/patch_hdmi.c

    r709 r717  
    5959module_param(enable_silent_stream, bool, 0644);
    6060MODULE_PARM_DESC(enable_silent_stream, "Enable Silent Stream for HDMI devices");
     61
     62static bool enable_all_pins;
     63module_param(enable_all_pins, bool, 0444);
     64MODULE_PARM_DESC(enable_all_pins, "Forcibly enable all pins");
    6165
    6266struct hdmi_spec_per_cvt {
    … …  
    13961400 last_try:
    13971401        /* the last try; check the empty slots in pins */
    1398         for (i = 0; i < spec->num_nids; i++) {
     1402        for (i = 0; i < spec->pcm_used; i++) {
    13991403                if (!test_bit(i, &spec->pcm_bitmap))
    14001404                        return i;
    … …  
    16261630        struct hdmi_spec *spec = codec->spec;
    16271631        struct hdmi_eld *eld = &spec->temp_eld;
     1632        struct device *dev = hda_codec_dev(codec);
    16281633        hda_nid_t pin_nid = per_pin->pin_nid;
    16291634        int dev_id = per_pin->dev_id;
    … …  
    16391644        int ret;
    16401645
     1646#ifdef  CONFIG_PM
     1647        if (dev->power.runtime_status == RPM_SUSPENDING)
     1648                return;
     1649#endif
     1650
    16411651        ret = snd_hda_power_up_pm(codec);
    1642         if (ret < 0 && pm_runtime_suspended(hda_codec_dev(codec)))
     1652        if (ret < 0 && pm_runtime_suspended(dev))
    16431653                goto out;
    16441654
    … …  
    19721982        }
    19731983
     1984        if (enable_all_pins)
     1985                spec->force_connect = true;
     1986
    19741987        q = snd_pci_quirk_lookup(codec->bus->pci, force_connect_list);
    19751988
    … …  
    22692282         */
    22702283
    2271         if (codec->mst_no_extra_pcms)
     2284        if (spec->dyn_pcm_no_legacy && codec->mst_no_extra_pcms)
     2285                pcm_num = spec->num_cvts;
     2286        else if (codec->mst_no_extra_pcms)
    22722287                pcm_num = spec->num_nids;
    22732288        else
    … …  
    29652980/* Intel Haswell and onwards; audio component with eld notifier */
    29662981static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid,
    2967                                  const int *port_map, int port_num, int dev_num)
     2982                                 const int *port_map, int port_num, int dev_num,
     2983                                 bool send_silent_stream)
    29682984{
    29692985        struct hdmi_spec *spec;
    … …  
    29983014         * module param or Kconfig option
    29993015         */
    3000         if (enable_silent_stream)
     3016        if (send_silent_stream)
    30013017                spec->send_silent_stream = true;
    30023018
    … …  
    30063022static int patch_i915_hsw_hdmi(struct hda_codec *codec)
    30073023{
    3008         return intel_hsw_common_init(codec, 0x08, NULL, 0, 3);
     3024        return intel_hsw_common_init(codec, 0x08, NULL, 0, 3,
     3025                                     enable_silent_stream);
    30093026}
    30103027
    30113028static int patch_i915_glk_hdmi(struct hda_codec *codec)
    30123029{
    3013         return intel_hsw_common_init(codec, 0x0b, NULL, 0, 3);
     3030        /*
     3031         * Silent stream calls audio component .get_power() from
     3032         * .pin_eld_notify(). On GLK this will deadlock in i915 due
     3033         * to the audio vs. CDCLK workaround.
     3034         */
     3035        return intel_hsw_common_init(codec, 0x0b, NULL, 0, 3, false);
    30143036}
    30153037
    … …  
    30223044        static const int map[] = {0x0, 0x4, 0x6, 0x8, 0xa, 0xb};
    30233045
    3024         return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 3);
     3046        return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 3,
     3047                                     enable_silent_stream);
    30253048}
    30263049
    … …  
    30343057        int ret;
    30353058
    3036         ret = intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4);
     3059        ret = intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4,
     3060                                    enable_silent_stream);
    30373061        if (!ret) {
    30383062                struct hdmi_spec *spec = codec->spec;
    … …  
    43984422HDA_CODEC_ENTRY(0x80862814, "DG1 HDMI", patch_i915_tgl_hdmi),
    43994423HDA_CODEC_ENTRY(0x80862815, "Alderlake HDMI",   patch_i915_tgl_hdmi),
    4400 HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
    44014424HDA_CODEC_ENTRY(0x80862816, "Rocketlake HDMI",  patch_i915_tgl_hdmi),
     4425HDA_CODEC_ENTRY(0x80862819, "DG2 HDMI", patch_i915_tgl_hdmi),
    44024426HDA_CODEC_ENTRY(0x8086281a, "Jasperlake HDMI",  patch_i915_icl_hdmi),
    44034427HDA_CODEC_ENTRY(0x8086281b, "Elkhartlake HDMI", patch_i915_icl_hdmi),
     4428HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
    44044429HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI",  patch_generic_hdmi),
    44054430HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI", patch_i915_byt_hdmi),

  • GPL/trunk/alsa-kernel/pci/hda/patch_realtek.c

    r703 r717  
    103103        struct alc_coef_led mute_led_coef;
    104104        struct alc_coef_led mic_led_coef;
     105        struct mutex coef_mutex;
    105106
    106107        hda_nid_t headset_mic_pin;
    … …  
    115116#endif
    116117        void (*shutup)(struct hda_codec *codec);
    117         void (*reboot_notify)(struct hda_codec *codec);
    118118
    119119        int init_amp;
    … …  
    139139 */
    140140
    141 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
    142                                unsigned int coef_idx)
     141static void coef_mutex_lock(struct hda_codec *codec)
     142{
     143        struct alc_spec *spec = codec->spec;
     144
     145        snd_hda_power_up_pm(codec);
     146        mutex_lock(&spec->coef_mutex);
     147}
     148
     149static void coef_mutex_unlock(struct hda_codec *codec)
     150{
     151        struct alc_spec *spec = codec->spec;
     152
     153        mutex_unlock(&spec->coef_mutex);
     154        snd_hda_power_down_pm(codec);
     155}
     156
     157static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
     158                                 unsigned int coef_idx)
    143159{
    144160        unsigned int val;
    … …  
    149165}
    150166
     167static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
     168                               unsigned int coef_idx)
     169{
     170        unsigned int val;
     171
     172        coef_mutex_lock(codec);
     173        val = __alc_read_coefex_idx(codec, nid, coef_idx);
     174        coef_mutex_unlock(codec);
     175        return val;
     176}
     177
    151178#define alc_read_coef_idx(codec, coef_idx) \
    152179        alc_read_coefex_idx(codec, 0x20, coef_idx)
    153180
     181static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
     182                                   unsigned int coef_idx, unsigned int coef_val)
     183{
     184        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
     185        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
     186}
     187
    154188static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
    155189                                 unsigned int coef_idx, unsigned int coef_val)
    156190{
    157         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
    158         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
     191        coef_mutex_lock(codec);
     192        __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
     193        coef_mutex_unlock(codec);
    159194}
    160195
    161196#define alc_write_coef_idx(codec, coef_idx, coef_val) \
    162197        alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
     198
     199static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
     200                                    unsigned int coef_idx, unsigned int mask,
     201                                    unsigned int bits_set)
     202{
     203        unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
     204
     205        if (val != -1)
     206                __alc_write_coefex_idx(codec, nid, coef_idx,
     207                                       (val & ~mask) | bits_set);
     208}
    163209
    164210static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
    … …  
    166212                                  unsigned int bits_set)
    167213{
    168         unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
    169 
    170         if (val != -1)
    171                 alc_write_coefex_idx(codec, nid, coef_idx,
    172                                      (val & ~mask) | bits_set);
     214        coef_mutex_lock(codec);
     215        __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
     216        coef_mutex_unlock(codec);
    173217}
    174218
    … …  
    203247                                const struct coef_fw *fw)
    204248{
     249        coef_mutex_lock(codec);
    205250        for (; fw->nid; fw++) {
    206251                if (fw->mask == (unsigned short)-1)
    207                         alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
     252                        __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
    208253                else
    209                         alc_update_coefex_idx(codec, fw->nid, fw->idx,
    210                                               fw->mask, fw->val);
    211         }
     254                        __alc_update_coefex_idx(codec, fw->nid, fw->idx,
     255                                                fw->mask, fw->val);
     256        }
     257        coef_mutex_unlock(codec);
    212258}
    213259
    … …  
    400446        case 0x10ec0255:
    401447        case 0x10ec0256:
     448        case 0x19e58326:
    402449        case 0x10ec0257:
    403450        case 0x10ec0282:
    … …  
    535582
    536583        switch (codec->core.vendor_id) {
     584        case 0x10ec0236:
     585        case 0x10ec0256:
     586        case 0x19e58326:
    537587        case 0x10ec0283:
    538588        case 0x10ec0286:
    … …  
    893943}
    894944
     945#define alc_free        snd_hda_gen_free
     946
     947#ifdef CONFIG_PM
    895948static inline void alc_shutup(struct hda_codec *codec)
    896949{
    … …  
    906959}
    907960
    908 static void alc_reboot_notify(struct hda_codec *codec)
    909 {
    910         struct alc_spec *spec = codec->spec;
    911 
    912         if (spec && spec->reboot_notify)
    913                 spec->reboot_notify(codec);
    914         else
    915                 alc_shutup(codec);
    916 }
    917 
    918 #define alc_free        snd_hda_gen_free
    919 
    920 #ifdef CONFIG_PM
    921961static void alc_power_eapd(struct hda_codec *codec)
    922962{
    … …  
    932972        return 0;
    933973}
    934 #endif
    935 
    936 #ifdef CONFIG_PM
     974
    937975static int alc_resume(struct hda_codec *codec)
    938976{
    … …  
    961999        .check_power_status = snd_hda_gen_check_power_status,
    9621000#endif
    963         .reboot_notify = alc_reboot_notify,
    9641001};
    9651002
    … …  
    11671204        codec->forced_resume = 1;
    11681205        codec->patch_ops = alc_patch_ops;
     1206        mutex_init(&spec->coef_mutex);
    11691207
    11701208        err = alc_codec_rename_from_preset(codec);
    … …  
    22952333        ALC887_FIXUP_BASS_CHMAP,
    22962334        ALC1220_FIXUP_GB_DUAL_CODECS,
     2335        ALC1220_FIXUP_GB_X570,
    22972336        ALC1220_FIXUP_CLEVO_P950,
    22982337        ALC1220_FIXUP_CLEVO_PB51ED,
    … …  
    23002339        ALC887_FIXUP_ASUS_AUDIO,
    23012340        ALC887_FIXUP_ASUS_HMIC,
     2341        ALCS1200A_FIXUP_MIC_VREF,
    23022342};
    23032343
    … …  
    24802520                           "Rear-Panel Capture Switch" :
    24812521                           "Front-Panel Capture Switch");
     2522                break;
     2523        }
     2524}
     2525
     2526static void alc1220_fixup_gb_x570(struct hda_codec *codec,
     2527                                     const struct hda_fixup *fix,
     2528                                     int action)
     2529{
     2530        static const hda_nid_t conn1[] = { 0x0c };
     2531        static const struct coef_fw gb_x570_coefs[] = {
     2532                WRITE_COEF(0x07, 0x03c0),
     2533                WRITE_COEF(0x1a, 0x01c1),
     2534                WRITE_COEF(0x1b, 0x0202),
     2535                WRITE_COEF(0x43, 0x3005),
     2536                {0}
     2537        };
     2538
     2539        switch (action) {
     2540        case HDA_FIXUP_ACT_PRE_PROBE:
     2541                snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
     2542                snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
     2543                break;
     2544        case HDA_FIXUP_ACT_INIT:
     2545                alc_process_coef_fw(codec, gb_x570_coefs);
    24822546                break;
    24832547        }
    … …  
    29723036                .v.func = alc1220_fixup_gb_dual_codecs,
    29733037        },
     3038        [ALC1220_FIXUP_GB_X570] = {
     3039                .type = HDA_FIXUP_FUNC,
     3040                .v.func = alc1220_fixup_gb_x570,
     3041        },
    29743042        [ALC1220_FIXUP_CLEVO_P950] = {
    29753043                .type = HDA_FIXUP_FUNC,
    … …  
    30053073                .chain_id = ALC887_FIXUP_ASUS_AUDIO,
    30063074        },
     3075#ifdef TARGET_OS2xxx
     3076        [ALCS1200A_FIXUP_MIC_VREF] = {
     3077                .type = HDA_FIXUP_PINCTLS,
     3078                .v.pins = (const struct hda_pintbl[]) {
     3079                        { 0x18, PIN_VREF50 }, /* rear mic */
     3080                        { 0x19, PIN_VREF50 }, /* front mic */
     3081                        {}
     3082                }
     3083        },
     3084#endif
    30073085};
    30083086
    … …  
    30423120        SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
    30433121        SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
     3122        SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
    30443123        SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
    30453124        SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
    … …  
    30763155        SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
    30773156        SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
    3078         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950),
    3079         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950),
     3157        SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
     3158        SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
     3159        SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
    30803160        SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
    30813161        SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
    … …  
    30943174        SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30953175        SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3176        SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3177        SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30963178        SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30973179        SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30983180        SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3181        SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3182        SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30993183        SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    3100         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3184        SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3185        SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
    31013186        SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
    31023187        SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
    … …  
    31493234        {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
    31503235        {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
     3236        {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
    31513237        {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
    31523238        {0}
    … …  
    36973783        ALC269_TYPE_ALC215,
    36983784        ALC269_TYPE_ALC225,
     3785        ALC269_TYPE_ALC245,
    36993786        ALC269_TYPE_ALC287,
    37003787        ALC269_TYPE_ALC294,
    … …  
    37343821        case ALC269_TYPE_ALC215:
    37353822        case ALC269_TYPE_ALC225:
     3823        case ALC269_TYPE_ALC245:
    37363824        case ALC269_TYPE_ALC287:
    37373825        case ALC269_TYPE_ALC294:
    … …  
    38033891        case 0x10ec0236:
    38043892        case 0x10ec0256:
     3893        case 0x19e58326:
    38053894                alc_write_coef_idx(codec, 0x48, 0x0);
    38063895                alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
    … …  
    38313920        case 0x10ec0236:
    38323921        case 0x10ec0256:
     3922        case 0x19e58326:
    38333923                alc_write_coef_idx(codec, 0x48, 0xd011);
    38343924                alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
    … …  
    41844274         * when booting with headset plugged. So skip setting it for the codec alc257
    41854275         */
    4186         if (codec->core.vendor_id != 0x10ec0257)
     4276        if (codec->core.vendor_id != 0x10ec0236 &&
     4277            codec->core.vendor_id != 0x10ec0257)
    41874278                alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
    41884279
    … …  
    42624353        bool hp1_pin_sense, hp2_pin_sense;
    42634354
    4264         if (spec->codec_variant != ALC269_TYPE_ALC287)
     4355        if (spec->codec_variant != ALC269_TYPE_ALC287 &&
     4356                spec->codec_variant != ALC269_TYPE_ALC245)
    42654357                /* required only at boot or S3 and S4 resume time */
    42664358#ifndef TARGET_OS2
    … …  
    50255117{
    50265118        alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
     5119}
     5120
     5121static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
     5122                                const struct hda_fixup *fix, int action)
     5123{
     5124        struct alc_spec *spec = codec->spec;
     5125
     5126        if (action == HDA_FIXUP_ACT_PRE_PROBE)
     5127                spec->micmute_led_polarity = 1;
     5128        alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
    50275129}
    50285130
    … …  
    55015603        case 0x10ec0236:
    55025604        case 0x10ec0256:
     5605        case 0x19e58326:
    55035606                alc_process_coef_fw(codec, coef0256);
    55045607                break;
    … …  
    56165719        case 0x10ec0236:
    56175720        case 0x10ec0256:
     5721        case 0x19e58326:
    56185722                alc_write_coef_idx(codec, 0x45, 0xc489);
    56195723                snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
    … …  
    57665870        case 0x10ec0236:
    57675871        case 0x10ec0256:
     5872        case 0x19e58326:
    57685873                alc_write_coef_idx(codec, 0x1b, 0x0e4b);
    57695874                alc_write_coef_idx(codec, 0x45, 0xc089);
    … …  
    58655970        case 0x10ec0236:
    58665971        case 0x10ec0256:
     5972        case 0x19e58326:
    58675973                alc_process_coef_fw(codec, coef0256);
    58685974                break;
    … …  
    59796085        case 0x10ec0236:
    59806086        case 0x10ec0256:
     6087        case 0x19e58326:
    59816088                alc_process_coef_fw(codec, coef0256);
    59826089                break;
    … …  
    60806187        case 0x10ec0236:
    60816188        case 0x10ec0256:
     6189        case 0x19e58326:
    60826190                alc_write_coef_idx(codec, 0x1b, 0x0e4b);
    60836191                alc_write_coef_idx(codec, 0x06, 0x6104);
    … …  
    63766484        case 0x10ec0236:
    63776485        case 0x10ec0256:
     6486        case 0x19e58326:
    63786487                alc_process_coef_fw(codec, alc256fw);
    63796488                break;
    … …  
    64666575
    64676576        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
    6468                 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
    64696577                spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
    64706578                codec->power_save_node = 0; /* avoid click noises */
    … …  
    69807088        case 0x10ec0255:
    69817089        case 0x10ec0256:
     7090        case 0x19e58326:
    69827091                alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
    69837092                alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
    … …  
    71107219#endif /* NOT_USED */
    71117220
     7221/* GPIO1 = amplifier on/off
     7222 * GPIO3 = mic mute LED
     7223 */
     7224static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
     7225                                          const struct hda_fixup *fix, int action)
     7226{
     7227        static const hda_nid_t conn[] = { 0x02 };
     7228
     7229        struct alc_spec *spec = codec->spec;
     7230        static const struct hda_pintbl pincfgs[] = {
     7231                { 0x14, 0x90170110 },  /* front/high speakers */
     7232                { 0x17, 0x90170130 },  /* back/bass speakers */
     7233                {0}
     7234        };
     7235
     7236        //enable micmute led
     7237        alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
     7238
     7239        switch (action) {
     7240        case HDA_FIXUP_ACT_PRE_PROBE:
     7241                spec->micmute_led_polarity = 1;
     7242                /* needed for amp of back speakers */
     7243                spec->gpio_mask |= 0x01;
     7244                spec->gpio_dir |= 0x01;
     7245                snd_hda_apply_pincfgs(codec, pincfgs);
     7246                /* share DAC to have unified volume control */
     7247                snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
     7248                snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
     7249                break;
     7250        case HDA_FIXUP_ACT_INIT:
     7251                /* need to toggle GPIO to enable the amp of back speakers */
     7252                alc_update_gpio_data(codec, 0x01, true);
     7253                msleep(100);
     7254                alc_update_gpio_data(codec, 0x01, false);
     7255                break;
     7256        }
     7257}
     7258
    71127259static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
    71137260                                          const struct hda_fixup *fix, int action)
    … …  
    71387285}
    71397286
     7287/* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
     7288static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
     7289                                                  const struct hda_fixup *fix,
     7290                                                  int action)
     7291{
     7292        struct alc_spec *spec = codec->spec;
     7293
     7294        switch (action) {
     7295        case HDA_FIXUP_ACT_PRE_PROBE:
     7296                spec->gen.suppress_auto_mute = 1;
     7297                break;
     7298        }
     7299}
     7300
    71407301/* for alc295_fixup_hp_top_speakers */
    71417302#include "hp_x360_helper.c"
    … …  
    71437304/* for alc285_fixup_ideapad_s740_coef() */
    71447305#include "ideapad_s740_helper.c"
     7306
     7307static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
     7308        WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
     7309        WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
     7310        WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
     7311        {0}
     7312};
     7313
     7314static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
     7315                                           const struct hda_fixup *fix,
     7316                                           int action)
     7317{
     7318        /*
     7319         * A certain other OS sets these coeffs to different values. On at least
     7320         * one TongFang barebone these settings might survive even a cold
     7321         * reboot. So to restore a clean slate the values are explicitly reset
     7322         * to default here. Without this, the external microphone is always in a
     7323         * plugged-in state, while the internal microphone is always in an
     7324         * unplugged state, breaking the ability to use the internal microphone.
     7325         */
     7326        alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
     7327}
     7328
     7329static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
     7330        WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
     7331        WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
     7332        WRITE_COEF(0x49, 0x0149),
     7333        {0}
     7334};
     7335
     7336static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
     7337                                       const struct hda_fixup *fix,
     7338                                       int action)
     7339{
     7340        /*
     7341         * The audio jack input and output is not detected on the ASRock NUC Box
     7342         * 1100 series when cold booting without this fix. Warm rebooting from a
     7343         * certain other OS makes the audio functional, as COEF settings are
     7344         * preserved in this case. This fix sets these altered COEF values as
     7345         * the default.
     7346         */
     7347        alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
     7348}
     7349
     7350static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
     7351                                                    const struct hda_fixup *fix,
     7352                                                    int action)
     7353{
     7354        /*
     7355         * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
     7356         * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
     7357         * needs an additional quirk for sound working after suspend and resume.
     7358         */
     7359        if (codec->core.vendor_id == 0x10ec0256) {
     7360                alc_update_coef_idx(codec, 0x10, 1<<9, 0);
     7361                snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
     7362        } else {
     7363                snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
     7364        }
     7365}
    71457366
    71467367enum {
    … …  
    72307451        ALC280_FIXUP_HP_9480M,
    72317452        ALC245_FIXUP_HP_X360_AMP,
     7453        ALC285_FIXUP_HP_SPECTRE_X360_EB1,
    72327454        ALC288_FIXUP_DELL_HEADSET_MODE,
    72337455        ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
    … …  
    72567478        ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
    72577479        ALC269_FIXUP_ATIV_BOOK_8,
     7480        ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
    72587481        ALC221_FIXUP_HP_MIC_NO_PRESENCE,
    72597482        ALC256_FIXUP_ASUS_HEADSET_MODE,
    … …  
    73177540        ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
    73187541        ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
     7542        ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
    73197543        ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
    73207544        ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
    … …  
    73427566        ALC287_FIXUP_HP_GPIO_LED,
    73437567        ALC256_FIXUP_HP_HEADSET_MIC,
     7568        ALC245_FIXUP_HP_GPIO_LED,
    73447569        ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
    73457570        ALC282_FIXUP_ACER_DISABLE_LINEOUT,
    … …  
    73557580        ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
    73567581        ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
    7357 };
     7582        ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
     7583        ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
     7584        ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
     7585        ALC298_FIXUP_LENOVO_C940_DUET7,
     7586        ALC287_FIXUP_13S_GEN2_SPEAKERS,
     7587        ALC256_FIXUP_SET_COEF_DEFAULTS,
     7588        ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
     7589        ALC233_FIXUP_NO_AUDIO_JACK,
     7590        ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
     7591        ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
     7592        ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
     7593};
     7594
     7595#ifdef NOT_USED
     7596/* A special fixup for Lenovo C940 and Yoga Duet 7;
     7597 * both have the very same PCI SSID, and we need to apply different fixups
     7598 * depending on the codec ID
     7599 */
     7600static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
     7601                                           const struct hda_fixup *fix,
     7602                                           int action)
     7603{
     7604        int id;
     7605
     7606        if (codec->core.vendor_id == 0x10ec0298)
     7607                id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
     7608        else
     7609                id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
     7610        __snd_hda_apply_fixup(codec, id, action, 0);
     7611}
     7612#endif
    73587613
    73597614#ifdef TARGET_OS2
    … …  
    82488503                .type = HDA_FIXUP_FUNC,
    82498504                .v.func = alc245_fixup_hp_x360_amp,
     8505                .chained = true,
     8506                .chain_id = ALC245_FIXUP_HP_GPIO_LED
    82508507        },
    82518508        [ALC288_FIXUP_DELL_HEADSET_MODE] = {
    … …  
    84498706        },
    84508707#ifdef TARGET_OS2xxx
     8708        [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
     8709                .type = HDA_FIXUP_PINS,
     8710                .v.pins = (const struct hda_pintbl[]) {
     8711                        { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
     8712                        { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
     8713                        { }
     8714                },
     8715                .chained = true,
     8716                .chain_id = ALC269_FIXUP_HEADSET_MODE
     8717        },
    84518718        [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
    84528719                .type = HDA_FIXUP_PINS,
    … …  
    89489215                },
    89499216        },
     9217        [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
     9218                .type = HDA_FIXUP_VERBS,
     9219                .v.verbs = (const struct hda_verb[]) {
     9220                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
     9221                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
     9222                        { }
     9223                },
     9224        },
    89509225        [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
    89519226                .type = HDA_FIXUP_PINS,
    … …  
    92279502                .v.func = alc285_fixup_hp_spectre_x360,
    92289503        },
     9504        [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
     9505                .type = HDA_FIXUP_FUNC,
     9506                .v.func = alc285_fixup_hp_spectre_x360_eb1
     9507        },
    92299508        [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
    92309509                .type = HDA_FIXUP_FUNC,
    … …  
    92559534                .chained = true,
    92569535                .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
     9536        },
     9537        [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
     9538                .type = HDA_FIXUP_FUNC,
     9539                .v.func = alc285_fixup_ideapad_s740_coef,
     9540                .chained = true,
     9541                .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
     9542        },
     9543        [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
     9544                .type = HDA_FIXUP_FUNC,
     9545                .v.func = alc287_fixup_legion_15imhg05_speakers,
     9546                .chained = true,
     9547                .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
     9548        },
     9549#ifdef TARGET_OS2xxx
     9550        [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
     9551                .type = HDA_FIXUP_VERBS,
     9552                //.v.verbs = legion_15imhg05_coefs,
     9553                .v.verbs = (const struct hda_verb[]) {
     9554                         // set left speaker Legion 7i.
     9555                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9556                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9557
     9558                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9559                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9560                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9561                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
     9562                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9563
     9564                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9565                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9566                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9567                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9568                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9569
     9570                         // set right speaker Legion 7i.
     9571                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9572                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
     9573
     9574                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9575                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9576                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9577                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
     9578                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9579
     9580                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9581                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9582                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9583                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9584                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9585                         {}
     9586                },
     9587                .chained = true,
     9588                .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
     9589        },
     9590#endif
     9591        [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
     9592                .type = HDA_FIXUP_FUNC,
     9593                .v.func = alc287_fixup_legion_15imhg05_speakers,
     9594                .chained = true,
     9595                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9596        },
     9597#ifdef TARGET_OS2xxx
     9598        [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
     9599                .type = HDA_FIXUP_VERBS,
     9600                .v.verbs = (const struct hda_verb[]) {
     9601                         // set left speaker Yoga 7i.
     9602                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9603                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9604
     9605                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9606                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9607                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9608                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
     9609                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9610
     9611                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9612                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9613                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9614                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9615                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9616
     9617                         // set right speaker Yoga 7i.
     9618                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9619                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
     9620
     9621                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9622                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9623                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9624                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
     9625                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9626
     9627                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9628                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9629                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9630                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9631                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9632                         {}
     9633                },
     9634                .chained = true,
     9635                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9636        },
     9637        [ALC298_FIXUP_LENOVO_C940_DUET7] = {
     9638                .type = HDA_FIXUP_FUNC,
     9639                .v.func = alc298_fixup_lenovo_c940_duet7,
     9640        },
     9641        [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
     9642                .type = HDA_FIXUP_VERBS,
     9643                .v.verbs = (const struct hda_verb[]) {
     9644                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9645                        { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9646                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9647                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9648                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9649                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9650                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9651                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9652                        { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
     9653                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9654                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9655                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9656                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9657                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9658                        {}
     9659                },
     9660                .chained = true,
     9661                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9662        },
     9663#endif
     9664        [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
     9665                .type = HDA_FIXUP_FUNC,
     9666                .v.func = alc256_fixup_set_coef_defaults,
     9667        },
     9668#ifdef TARGET_OS2xxx
     9669        [ALC245_FIXUP_HP_GPIO_LED] = {
     9670                .type = HDA_FIXUP_FUNC,
     9671                .v.func = alc245_fixup_hp_gpio_led,
     9672        },
     9673        [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
     9674                .type = HDA_FIXUP_PINS,
     9675                .v.pins = (const struct hda_pintbl[]) {
     9676                        { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
     9677                        { }
     9678                },
     9679                .chained = true,
     9680                .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
     9681        },
     9682#endif
     9683        [ALC233_FIXUP_NO_AUDIO_JACK] = {
     9684                .type = HDA_FIXUP_FUNC,
     9685                .v.func = alc233_fixup_no_audio_jack,
     9686        },
     9687        [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
     9688                .type = HDA_FIXUP_FUNC,
     9689                .v.func = alc256_fixup_mic_no_presence_and_resume,
     9690                .chained = true,
     9691                .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
    92579692        },
    92589693};
    … …  
    92889723        SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
    92899724        SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
     9725        SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
    92909726        SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
    92919727        SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
    92929728        SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
    92939729        SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
     9730        SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
    92949731        SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
    92959732        SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
    92969733        SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
    92979734        SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
     9735        SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
    92989736        SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
    92999737        SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
    … …  
    93479785        SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
    93489786        SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
     9787        SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
     9788        SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
     9789        SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
     9790        SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
    93499791        SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    93509792        SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    … …  
    94069848        SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
    94079849        SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
     9850        SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
    94089851        SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
    94099852        SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
    … …  
    94229865        SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
    94239866        SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
     9867        SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    94249868        SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    94259869        SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
    … …  
    94289872        SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    94299873        SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
     9874        SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
    94309875        SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
    94319876        SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
     9877        SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
    94329878        SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    94339879        SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
    … …  
    94389884        SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
    94399885                      ALC285_FIXUP_HP_GPIO_AMP_INIT),
     9886        SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
     9887        SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
    94409888        SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
    94419889        SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
    … …  
    94499897        SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
    94509898        SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
     9899        SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
     9900        SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
    94519901        SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
    94529902        SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
    … …  
    94629912        SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
    94639913        SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
     9914        SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
     9915        SND_PCI_QUIRK(0x103c, 0x89c3, "HP", ALC285_FIXUP_HP_GPIO_LED),
     9916        SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
     9917        SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
     9918        SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
     9919        SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
     9920        SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
     9921        SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
    94649922        SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
    94659923        SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
    … …  
    94879945        SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
    94889946        SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
     9947        SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
    94899948        SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
    94909949        SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
    … …  
    95029961        SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
    95039962        SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
     9963        SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
     9964        SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
    95049965        SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
    95059966        SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
    … …  
    95349995        SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
    95359996        SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
     9997        SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
    95369998        SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
    95379999        SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
    … …  
    955010012        SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955110013        SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10014        SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10015        SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955210016        SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955310017        SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    955510019        SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955610020        SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10021        SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10022        SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955710023        SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    955810024        SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    956910035        SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    957010036        SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10037        SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10038        SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    957110039        SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    957210040        SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    958010048        SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
    958110049        SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10050        SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10051        SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10052        SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    958210053        SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    9583         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
     10054        SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
    958410055        SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    958510056        SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    964710118        SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
    964810119        SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
    9649         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME),
     10120        SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     10121        SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
     10122        SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
     10123        SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
     10124        SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     10125        SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
    965010126        SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
     10127        SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     10128        SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
    965110129        SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
     10130        SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     10131        SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     10132        SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
    965210133        SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
    965310134        SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
    … …  
    966910150        SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    967010151        SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
     10152        SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
    967110153        SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
    967210154        SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    967310155        SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    967410156        SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
     10157        SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
    967510158        SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
    967610159        SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
    … …  
    968010163        SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
    968110164        SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
     10165        SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
     10166        SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
     10167        SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
     10168        SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
     10169        SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
     10170        SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
     10171        SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
     10172        SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
     10173        SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
    968210174        SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
    968310175        SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
    968410176        SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
     10177        SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
    968510178        SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
    968610179        SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
    … …  
    986010353        {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
    986110354        {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"},
     10355        {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
    986210356        {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
    986310357        {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
    … …  
    986510359        {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
    986610360        {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
     10361        {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
    986710362        {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
    986810363        {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
    986910364        {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
     10365        {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
    987010366        {0}
    987110367};
    … …  
    1046310959        case 0x10ec0236:
    1046410960        case 0x10ec0256:
     10961        case 0x19e58326:
    1046510962                spec->codec_variant = ALC269_TYPE_ALC256;
    1046610963                spec->shutup = alc256_shutup;
    … …  
    1047810975        case 0x10ec0285:
    1047910976        case 0x10ec0289:
    10480                 spec->codec_variant = ALC269_TYPE_ALC215;
     10977                if (alc_get_coef0(codec) & 0x0010)
     10978                        spec->codec_variant = ALC269_TYPE_ALC245;
     10979                else
     10980                        spec->codec_variant = ALC269_TYPE_ALC215;
    1048110981                spec->shutup = alc225_shutup;
    1048210982                spec->init_hook = alc225_init;
    … …  
    1102011520                alc_write_coef_idx(codec, 0x19, 0xa054);
    1102111521                break;
     11522        }
     11523}
     11524
     11525static void alc897_hp_automute_hook(struct hda_codec *codec,
     11526                                         struct hda_jack_callback *jack)
     11527{
     11528        struct alc_spec *spec = codec->spec;
     11529        int vref;
     11530
     11531        snd_hda_gen_hp_automute(codec, jack);
     11532        vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
     11533        snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
     11534                            vref);
     11535}
     11536
     11537static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
     11538                                     const struct hda_fixup *fix, int action)
     11539{
     11540        struct alc_spec *spec = codec->spec;
     11541        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
     11542                spec->gen.hp_automute_hook = alc897_hp_automute_hook;
    1102211543        }
    1102311544}
    … …  
    1110011621        ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
    1110111622        ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
     11623        ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
     11624        ALC668_FIXUP_HEADSET_MIC,
     11625        ALC668_FIXUP_MIC_DET_COEF,
     11626        ALC897_FIXUP_LENOVO_HEADSET_MIC,
     11627        ALC897_FIXUP_HEADSET_MIC_PIN,
     11628        ALC897_FIXUP_HP_HSMIC_VERB,
    1110211629};
    1110311630
    … …  
    1166612193                .chained = true,
    1166712194                .chain_id = ALC662_FIXUP_USI_FUNC
     12195        },
     12196        [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
     12197                .type = HDA_FIXUP_PINS,
     12198                .v.pins = (const struct hda_pintbl[]) {
     12199                        { 0x1b, 0x04a1112c },
     12200                        { }
     12201                },
     12202                .chained = true,
     12203                .chain_id = ALC668_FIXUP_HEADSET_MIC
     12204        },
     12205#endif
     12206        [ALC668_FIXUP_HEADSET_MIC] = {
     12207                .type = HDA_FIXUP_FUNC,
     12208                .v.func = alc269_fixup_headset_mic,
     12209                .chained = true,
     12210                .chain_id = ALC668_FIXUP_MIC_DET_COEF
     12211        },
     12212#ifdef TARGET_OS2xxx
     12213        [ALC668_FIXUP_MIC_DET_COEF] = {
     12214                .type = HDA_FIXUP_VERBS,
     12215                .v.verbs = (const struct hda_verb[]) {
     12216                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
     12217                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
     12218                        {}
     12219                },
     12220        },
     12221#endif
     12222        [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
     12223                .type = HDA_FIXUP_FUNC,
     12224                .v.func = alc897_fixup_lenovo_headset_mic,
     12225        },
     12226#ifdef TARGET_OS2xxx
     12227        [ALC897_FIXUP_HEADSET_MIC_PIN] = {
     12228                .type = HDA_FIXUP_PINS,
     12229                .v.pins = (const struct hda_pintbl[]) {
     12230                        { 0x1a, 0x03a11050 },
     12231                        { }
     12232                },
     12233                .chained = true,
     12234                .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
     12235        },
     12236        [ALC897_FIXUP_HP_HSMIC_VERB] = {
     12237                .type = HDA_FIXUP_PINS,
     12238                .v.pins = (const struct hda_pintbl[]) {
     12239                        { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
     12240                        { }
     12241                },
    1166812242        },
    1166912243#endif
    … …  
    1169312267        SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
    1169412268        SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
     12269        SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
    1169512270        SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
     12271        SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
     12272        SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
    1169612273        SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
    1169712274        SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
    … …  
    1170312280        SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
    1170412281        SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
     12282        SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
    1170512283        SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
    1170612284        SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
    … …  
    1171112289        SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
    1171212290        SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
     12291        SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
     12292        SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
     12293        SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
     12294        SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
     12295        SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
    1171312296        SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
    1171412297        SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
    … …  
    1206912652        HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
    1207012653        HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
     12654        HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
    1207112655        {0} /* terminator */
    1207212656};

  • GPL/trunk/alsa-kernel/pci/hda/patch_sigmatel.c

    r695 r717  
    44824482}
    44834483
    4484 static void stac_shutup(struct hda_codec *codec)
    4485 {
    4486         struct sigmatel_spec *spec = codec->spec;
    4487 
    4488         snd_hda_shutup_pins(codec);
    4489 
    4490         if (spec->eapd_mask)
    4491                 stac_gpio_set(codec, spec->gpio_mask,
    4492                                 spec->gpio_dir, spec->gpio_data &
    4493                                 ~spec->eapd_mask);
    4494 }
    4495 
    44964484#define stac_free       snd_hda_gen_free
    44974485
    … …  
    45464534static int stac_suspend(struct hda_codec *codec)
    45474535{
    4548         stac_shutup(codec);
     4536        struct sigmatel_spec *spec = codec->spec;
     4537
     4538        snd_hda_shutup_pins(codec);
     4539
     4540        if (spec->eapd_mask)
     4541                stac_gpio_set(codec, spec->gpio_mask,
     4542                                spec->gpio_dir, spec->gpio_data &
     4543                                ~spec->eapd_mask);
     4544
    45494545        return 0;
    45504546}
    … …  
    45624558        .suspend = stac_suspend,
    45634559#endif
    4564         .reboot_notify = stac_shutup,
    45654560};
    45664561

  • GPL/trunk/alsa-kernel/pci/hda/patch_via.c

    r703 r717  
    529529                return err;
    530530
     531        err = auto_parse_beep(codec);
     532        if (err < 0)
     533                return err;
     534
    531535        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
    532         if (err < 0)
    533                 return err;
    534 
    535         err = auto_parse_beep(codec);
    536536        if (err < 0)
    537537                return err;

  • GPL/trunk/alsa-kernel/pci/intel8x0.c

    r703 r717  
    382382       
    383383        u32 bdbars_count;
    384         struct snd_dma_buffer bdbars;
     384        struct snd_dma_buffer *bdbars;
    385385        u32 int_sta_reg;                /* interrupt status register */
    386386        u32 int_sta_mask;               /* interrupt status mask */
    … …  
    14311431
    14321432#define intel8x0_dma_type(chip) \
    1433         ((chip)->fix_nocache ? SNDRV_DMA_TYPE_DEV_UC : SNDRV_DMA_TYPE_DEV)
     1433        ((chip)->fix_nocache ? SNDRV_DMA_TYPE_DEV_WC : SNDRV_DMA_TYPE_DEV)
    14341434
    14351435static int snd_intel8x0_pcm1(struct intel8x0 *chip, int device,
    … …  
    25342534}
    25352535
    2536 static int snd_intel8x0_free(struct intel8x0 *chip)
    2537 {
     2536static void snd_intel8x0_free(struct snd_card *card)
     2537{
     2538        struct intel8x0 *chip = card->private_data;
    25382539        unsigned int i;
    25392540
    … …  
    25582559        if (chip->irq >= 0)
    25592560                free_irq(chip->irq, chip);
    2560         if (chip->bdbars.area)
    2561                 snd_dma_free_pages(&chip->bdbars);
    2562         if (chip->addr)
    2563                 pci_iounmap(chip->pci, chip->addr);
    2564         if (chip->bmaddr)
    2565                 pci_iounmap(chip->pci, chip->bmaddr);
    2566         pci_release_regions(chip->pci);
    2567         pci_disable_device(chip->pci);
    2568         kfree(chip);
    2569         return 0;
    25702561}
    25712562
    … …  
    26662657        if (chip->ac97_bus->clock != 48000)
    26672658                return; /* specified in module option */
     2659        if (chip->inside_vm && !ac97_clock)
     2660                return; /* no measurement on VM */
    26682661
    26692662      __again:
    … …  
    28542847}
    28552848
    2856 static int snd_intel8x0_dev_free(struct snd_device *device)
    2857 {
    2858         struct intel8x0 *chip = device->device_data;
    2859         return snd_intel8x0_free(chip);
    2860 }
    2861 
    28622849struct ich_reg_info {
    28632850        unsigned int int_sta_mask;
    … …  
    29032890}
    29042891
    2905 static int snd_intel8x0_create(struct snd_card *card,
    2906                                struct pci_dev *pci,
    2907                                unsigned long device_type,
    2908                                struct intel8x0 **r_intel8x0)
    2909 {
    2910         struct intel8x0 *chip;
     2892static int snd_intel8x0_init(struct snd_card *card,
     2893                             struct pci_dev *pci,
     2894                             unsigned long device_type)
     2895{
     2896        struct intel8x0 *chip = card->private_data;
    29112897        int err;
    29122898        unsigned int i;
    29132899        unsigned int int_sta_masks;
    29142900        struct ichdev *ichdev;
    2915         static const struct snd_device_ops ops = {
    2916                 .dev_free =     snd_intel8x0_dev_free,
    2917         };
    29182901
    29192902        static const unsigned int bdbars[] = {
    … …  
    29482931        const struct ich_reg_info *tbl;
    29492932
    2950         *r_intel8x0 = NULL;
    2951 
    2952         err = pci_enable_device(pci);
     2933        err = pcim_enable_device(pci);
    29532934        if (err < 0)
    29542935                return err;
    29552936
    2956         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2957         if (chip == NULL) {
    2958                 pci_disable_device(pci);
    2959                 return -ENOMEM;
    2960         }
    29612937        spin_lock_init(&chip->reg_lock);
    29622938        chip->device_type = device_type;
    … …  
    29842960
    29852961        err = pci_request_regions(pci, card->shortname);
    2986         if (err < 0) {
    2987                 kfree(chip);
    2988                 pci_disable_device(pci);
     2962        if (err < 0)
    29892963                return err;
    2990         }
    29912964
    29922965        if (device_type == DEVICE_ALI) {
    29932966                /* ALI5455 has no ac97 region */
    2994                 chip->bmaddr = pci_iomap(pci, 0, 0);
    2995                 goto port_inited;
    2996         }
    2997 
    2998         if (pci_resource_flags(pci, 2) & IORESOURCE_MEM) /* ICH4 and Nforce */
    2999                 chip->addr = pci_iomap(pci, 2, 0);
    3000         else
    3001                 chip->addr = pci_iomap(pci, 0, 0);
    3002         if (!chip->addr) {
    3003                 dev_err(card->dev, "AC'97 space ioremap problem\n");
    3004                 snd_intel8x0_free(chip);
    3005                 return -EIO;
    3006         }
    3007         if (pci_resource_flags(pci, 3) & IORESOURCE_MEM) /* ICH4 */
    3008                 chip->bmaddr = pci_iomap(pci, 3, 0);
    3009         else
    3010                 chip->bmaddr = pci_iomap(pci, 1, 0);
    3011 
    3012  port_inited:
    3013         if (!chip->bmaddr) {
    3014                 dev_err(card->dev, "Controller space ioremap problem\n");
    3015                 snd_intel8x0_free(chip);
    3016                 return -EIO;
    3017         }
     2967                chip->bmaddr = pcim_iomap(pci, 0, 0);
     2968        } else {
     2969                if (pci_resource_flags(pci, 2) & IORESOURCE_MEM) /* ICH4 and Nforce */
     2970                        chip->addr = pcim_iomap(pci, 2, 0);
     2971                else
     2972                        chip->addr = pcim_iomap(pci, 0, 0);
     2973                if (pci_resource_flags(pci, 3) & IORESOURCE_MEM) /* ICH4 */
     2974                        chip->bmaddr = pcim_iomap(pci, 3, 0);
     2975                else
     2976                        chip->bmaddr = pcim_iomap(pci, 1, 0);
     2977        }
     2978
    30182979        chip->bdbars_count = bdbars[device_type];
    30192980
    … …  
    30513012        /* allocate buffer descriptor lists */
    30523013        /* the start of each lists must be aligned to 8 bytes */
    3053         if (snd_dma_alloc_pages(intel8x0_dma_type(chip), &pci->dev,
    3054                                 chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2,
    3055                                 &chip->bdbars) < 0) {
    3056                 snd_intel8x0_free(chip);
    3057                 dev_err(card->dev, "cannot allocate buffer descriptors\n");
     3014        chip->bdbars = snd_devm_alloc_pages(&pci->dev, intel8x0_dma_type(chip),
     3015                                            chip->bdbars_count * sizeof(u32) *
     3016                                            ICH_MAX_FRAGS * 2);
     3017        if (!chip->bdbars)
    30583018                return -ENOMEM;
    3059         }
    30603019        /* tables must be aligned to 8 bytes here, but the kernel pages
    30613020           are much bigger, so we don't care (on i386) */
    … …  
    30633022        for (i = 0; i < chip->bdbars_count; i++) {
    30643023                ichdev = &chip->ichd[i];
    3065                 ichdev->bdbar = ((__le32 *)chip->bdbars.area) +
     3024                ichdev->bdbar = ((__le32 *)chip->bdbars->area) +
    30663025                        (i * ICH_MAX_FRAGS * 2);
    3067                 ichdev->bdbar_addr = chip->bdbars.addr +
     3026                ichdev->bdbar_addr = chip->bdbars->addr +
    30683027                        (i * sizeof(u32) * ICH_MAX_FRAGS * 2);
    30693028                int_sta_masks |= ichdev->int_sta_mask;
    … …  
    30993058
    31003059        err = snd_intel8x0_chip_init(chip, 1);
    3101         if (err < 0) {
    3102                 snd_intel8x0_free(chip);
     3060        if (err < 0)
    31033061                return err;
    3104         }
    31053062
    31063063        /* request irq after initializaing int_sta_mask, etc */
     3064        /* NOTE: we don't use devm version here since it's released /
     3065         * re-acquired in PM callbacks.
     3066         * It's released explicitly in snd_intel8x0_free(), too.
     3067         */
    31073068        if (request_irq(pci->irq, snd_intel8x0_interrupt,
    31083069                        IRQF_SHARED, KBUILD_MODNAME, chip)) {
    31093070                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    3110                 snd_intel8x0_free(chip);
    31113071                return -EBUSY;
    31123072        }
    … …  
    31143074        card->sync_irq = chip->irq;
    31153075
    3116         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    3117         if (err < 0) {
    3118                 snd_intel8x0_free(chip);
    3119                 return err;
    3120         }
    3121 
    3122         *r_intel8x0 = chip;
     3076        card->private_free = snd_intel8x0_free;
     3077
    31233078        return 0;
    31243079}
    … …  
    31783133}
    31793134
    3180 static int snd_intel8x0_probe(struct pci_dev *pci,
    3181                               const struct pci_device_id *pci_id)
     3135static int __snd_intel8x0_probe(struct pci_dev *pci,
     3136                                const struct pci_device_id *pci_id)
    31823137{
    31833138        struct snd_card *card;
    … …  
    31863141        struct shortname_table *name;
    31873142
    3188         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     3143        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     3144                                sizeof(*chip), &card);
    31893145        if (err < 0)
    31903146                return err;
     3147        chip = card->private_data;
    31913148
    31923149        if (spdif_aclink < 0)
    … …  
    32223179        }
    32233180
    3224         err = snd_intel8x0_create(card, pci, pci_id->driver_data, &chip);
    3225         if (err < 0) {
    3226                 snd_card_free(card);
     3181        err = snd_intel8x0_init(card, pci, pci_id->driver_data);
     3182        if (err < 0)
    32273183                return err;
    3228         }
    3229         card->private_data = chip;
    32303184
    32313185        err = snd_intel8x0_mixer(chip, ac97_clock, ac97_quirk);
    3232         if (err < 0) {
    3233                 snd_card_free(card);
     3186        if (err < 0)
    32343187                return err;
    3235         }
    32363188        err = snd_intel8x0_pcm(chip);
    3237         if (err < 0) {
    3238                 snd_card_free(card);
     3189        if (err < 0)
    32393190                return err;
    3240         }
    32413191       
    32423192        snd_intel8x0_proc_init(chip);
    … …  
    32563206
    32573207        err = snd_card_register(card);
    3258         if (err < 0) {
    3259                 snd_card_free(card);
     3208        if (err < 0)
    32603209                return err;
    3261         }
     3210
    32623211        pci_set_drvdata(pci, card);
    32633212        return 0;
    32643213}
    32653214
    3266 static void snd_intel8x0_remove(struct pci_dev *pci)
    3267 {
    3268         snd_card_free(pci_get_drvdata(pci));
     3215static int snd_intel8x0_probe(struct pci_dev *pci,
     3216                              const struct pci_device_id *pci_id)
     3217{
     3218        return snd_card_free_on_error(&pci->dev, __snd_intel8x0_probe(pci, pci_id));
    32693219}
    32703220
    … …  
    32733223        .id_table = snd_intel8x0_ids,
    32743224        .probe = snd_intel8x0_probe,
    3275         .remove = snd_intel8x0_remove,
    32763225        .driver = {
    32773226                .pm = INTEL8X0_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/korg1212/korg1212.c

    r703 r717  
    321321        void __iomem *iobase;
    322322
    323         struct snd_dma_buffer dma_dsp;
    324         struct snd_dma_buffer dma_play;
    325         struct snd_dma_buffer dma_rec;
    326         struct snd_dma_buffer dma_shared;
     323        struct snd_dma_buffer *dma_dsp;
     324        struct snd_dma_buffer *dma_play;
     325        struct snd_dma_buffer *dma_rec;
     326        struct snd_dma_buffer *dma_shared;
    327327
    328328        u32 DataBufsSize;
    … …  
    12011201
    12021202        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload,
    1203                                      UpperWordSwap(korg1212->dma_dsp.addr),
    1204                                      0, 0, 0);
     1203                                          UpperWordSwap(korg1212->dma_dsp->addr),
     1204                                          0, 0, 0);
    12051205        if (rc)
    12061206                K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n",
    … …  
    13831383
    13841384        runtime->hw = snd_korg1212_playback_info;
    1385         snd_pcm_set_runtime_buffer(substream, &korg1212->dma_play);
     1385        snd_pcm_set_runtime_buffer(substream, korg1212->dma_play);
    13861386
    13871387        spin_lock_irqsave(&korg1212->lock, flags);
    … …  
    14141414
    14151415        runtime->hw = snd_korg1212_capture_info;
    1416         snd_pcm_set_runtime_buffer(substream, &korg1212->dma_rec);
     1416        snd_pcm_set_runtime_buffer(substream, korg1212->dma_rec);
    14171417
    14181418        spin_lock_irqsave(&korg1212->lock, flags);
    … …  
    20812081}
    20822082
    2083 static int
    2084 snd_korg1212_free(struct snd_korg1212 *korg1212)
    2085 {
    2086         snd_korg1212_TurnOffIdleMonitor(korg1212);
    2087 
    2088         if (korg1212->irq >= 0) {
    2089                 snd_korg1212_DisableCardInterrupts(korg1212);
    2090                 free_irq(korg1212->irq, korg1212);
    2091                 korg1212->irq = -1;
    2092         }
    2093        
    2094         if (korg1212->iobase != NULL) {
    2095                 iounmap(korg1212->iobase);
    2096                 korg1212->iobase = NULL;
    2097         }
    2098        
    2099         pci_release_regions(korg1212->pci);
    2100 
    2101         // ----------------------------------------------------
    2102         // free up memory resources used for the DSP download.
    2103         // ----------------------------------------------------
    2104         if (korg1212->dma_dsp.area) {
    2105                 snd_dma_free_pages(&korg1212->dma_dsp);
    2106                 korg1212->dma_dsp.area = NULL;
    2107         }
    2108 
    2109 #ifndef K1212_LARGEALLOC
    2110 
    2111         // ------------------------------------------------------
    2112         // free up memory resources used for the Play/Rec Buffers
    2113         // ------------------------------------------------------
    2114         if (korg1212->dma_play.area) {
    2115                 snd_dma_free_pages(&korg1212->dma_play);
    2116                 korg1212->dma_play.area = NULL;
    2117         }
    2118 
    2119         if (korg1212->dma_rec.area) {
    2120                 snd_dma_free_pages(&korg1212->dma_rec);
    2121                 korg1212->dma_rec.area = NULL;
    2122         }
    2123 
    2124 #endif
    2125 
    2126         // ----------------------------------------------------
    2127         // free up memory resources used for the Shared Buffers
    2128         // ----------------------------------------------------
    2129         if (korg1212->dma_shared.area) {
    2130                 snd_dma_free_pages(&korg1212->dma_shared);
    2131                 korg1212->dma_shared.area = NULL;
    2132         }
    2133        
    2134         pci_disable_device(korg1212->pci);
    2135         kfree(korg1212);
    2136         return 0;
    2137 }
    2138 
    2139 static int snd_korg1212_dev_free(struct snd_device *device)
    2140 {
    2141         struct snd_korg1212 *korg1212 = device->device_data;
    2142         K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
    2143         return snd_korg1212_free(korg1212);
    2144 }
    2145 
    2146 static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci,
    2147                                struct snd_korg1212 **rchip)
     2083static void
     2084snd_korg1212_free(struct snd_card *card)
     2085{
     2086        struct snd_korg1212 *korg1212 = card->private_data;
     2087
     2088        snd_korg1212_TurnOffIdleMonitor(korg1212);
     2089        snd_korg1212_DisableCardInterrupts(korg1212);
     2090}
     2091
     2092static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci)
    21482093
    21492094{
    21502095        int err, rc;
    21512096        unsigned int i;
    2152         unsigned iomem_size;
     2097        __maybe_unused unsigned iomem_size;
    21532098        __maybe_unused unsigned ioport_size;
    21542099        __maybe_unused unsigned iomem2_size;
    2155         struct snd_korg1212 * korg1212;
     2100        struct snd_korg1212 *korg1212 = card->private_data;
    21562101        const struct firmware *dsp_code;
    21572102
    2158         static const struct snd_device_ops ops = {
    2159                 .dev_free = snd_korg1212_dev_free,
    2160         };
    2161 
    2162         * rchip = NULL;
    2163         err = pci_enable_device(pci);
     2103        err = pcim_enable_device(pci);
    21642104        if (err < 0)
    21652105                return err;
    2166 
    2167         korg1212 = kzalloc(sizeof(*korg1212), GFP_KERNEL);
    2168         if (korg1212 == NULL) {
    2169                 pci_disable_device(pci);
    2170                 return -ENOMEM;
    2171         }
    21722106
    21732107        korg1212->card = card;
    … …  
    21992133                korg1212->volumePhase[i] = 0;
    22002134
    2201         err = pci_request_regions(pci, "korg1212");
    2202         if (err < 0) {
    2203                 kfree(korg1212);
    2204                 pci_disable_device(pci);
     2135        err = pcim_iomap_regions_request_all(pci, 1 << 0, "korg1212");
     2136        if (err < 0)
    22052137                return err;
    2206         }
    22072138
    22082139        korg1212->iomem = pci_resource_start(korg1212->pci, 0);
    … …  
    22242155                   stateName[korg1212->cardState]);
    22252156
    2226         korg1212->iobase = ioremap(korg1212->iomem, iomem_size);
    2227         if (!korg1212->iobase) {
    2228                 snd_printk(KERN_ERR "korg1212: unable to remap memory region 0x%lx-0x%lx\n", korg1212->iomem,
    2229                            korg1212->iomem + iomem_size - 1);
    2230                 snd_korg1212_free(korg1212);
     2157        korg1212->iobase = pcim_iomap_table(pci)[0];
     2158
     2159        err = devm_request_irq(&pci->dev, pci->irq, snd_korg1212_interrupt,
     2160                          IRQF_SHARED,
     2161                          KBUILD_MODNAME, korg1212);
     2162
     2163        if (err) {
     2164                snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq);
    22312165                return -EBUSY;
    22322166        }
    22332167
    2234         err = request_irq(pci->irq, snd_korg1212_interrupt,
    2235                           IRQF_SHARED,
    2236                           KBUILD_MODNAME, korg1212);
    2237 
    2238         if (err) {
    2239                 snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq);
    2240                 snd_korg1212_free(korg1212);
    2241                 return -EBUSY;
    2242         }
    2243 
    22442168        korg1212->irq = pci->irq;
    22452169        card->sync_irq = korg1212->irq;
     2170        card->private_free = snd_korg1212_free;
    22462171
    22472172        pci_set_master(korg1212->pci);
    … …  
    22822207                   stateName[korg1212->cardState]);
    22832208
    2284         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    2285                                 sizeof(struct KorgSharedBuffer), &korg1212->dma_shared) < 0) {
    2286                 snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%zd bytes)\n", sizeof(struct KorgSharedBuffer));
    2287                 snd_korg1212_free(korg1212);
    2288                 return -ENOMEM;
    2289         }
    2290         korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared.area;
    2291         korg1212->sharedBufferPhy = korg1212->dma_shared.addr;
     2209        korg1212->dma_shared = snd_devm_alloc_pages(&pci->dev,
     2210                                                    SNDRV_DMA_TYPE_DEV,
     2211                                                    sizeof(struct KorgSharedBuffer));
     2212        if (!korg1212->dma_shared)
     2213                return -ENOMEM;
     2214        korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared->area;
     2215        korg1212->sharedBufferPhy = korg1212->dma_shared->addr;
    22922216
    22932217        K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(struct KorgSharedBuffer));
    22942218
    22952219#ifndef K1212_LARGEALLOC
    2296 
    22972220        korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers;
    2298 
    2299         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    2300                                 korg1212->DataBufsSize, &korg1212->dma_play) < 0) {
    2301                 snd_printk(KERN_ERR "korg1212: can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
    2302                 snd_korg1212_free(korg1212);
    2303                 return -ENOMEM;
    2304         }
    2305         korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play.area;
    2306         korg1212->PlayDataPhy = korg1212->dma_play.addr;
     2221        korg1212->dma_play = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
     2222                                                  korg1212->DataBufsSize);
     2223        if (!korg1212->dma_play)
     2224                return -ENOMEM;
     2225
     2226        korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play->area;
     2227        korg1212->PlayDataPhy = korg1212->dma_play->addr;
    23072228
    23082229        K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",
    23092230                korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize);
    23102231
    2311         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    2312                                 korg1212->DataBufsSize, &korg1212->dma_rec) < 0) {
    2313                 snd_printk(KERN_ERR "korg1212: can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
    2314                 snd_korg1212_free(korg1212);
    2315                 return -ENOMEM;
    2316         }
    2317         korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec.area;
    2318         korg1212->RecDataPhy = korg1212->dma_rec.addr;
     2232        korg1212->dma_rec = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
     2233                                                 korg1212->DataBufsSize);
     2234        if (!korg1212->dma_rec)
     2235                return -ENOMEM;
     2236
     2237        korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec->area;
     2238        korg1212->RecDataPhy = korg1212->dma_rec->addr;
    23192239
    23202240        K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",
    … …  
    23402260        if (err < 0) {
    23412261                snd_printk(KERN_ERR "firmware not available\n");
    2342                 snd_korg1212_free(korg1212);
    23432262                return err;
    23442263        }
    23452264
    2346         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    2347                                 dsp_code->size, &korg1212->dma_dsp) < 0) {
    2348                 snd_printk(KERN_ERR "korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code->size);
    2349                 snd_korg1212_free(korg1212);
     2265        korg1212->dma_dsp = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
     2266                                                 dsp_code->size);
     2267        if (!korg1212->dma_dsp) {
    23502268                release_firmware(dsp_code);
    2351                 return -ENOMEM;
    2352         }
     2269                return -ENOMEM;
     2270        }
    23532271
    23542272        K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",
    2355                    korg1212->dma_dsp.area, korg1212->dma_dsp.addr, dsp_code->size,
     2273                   korg1212->dma_dsp->area, korg1212->dma_dsp->addr, dsp_code->size,
    23562274                   stateName[korg1212->cardState]);
    23572275
    2358         memcpy(korg1212->dma_dsp.area, dsp_code->data, dsp_code->size);
     2276        memcpy(korg1212->dma_dsp->area, dsp_code->data, dsp_code->size);
    23592277
    23602278        release_firmware(dsp_code);
    … …  
    23652283                K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
    23662284
    2367         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops);
    2368         if (err < 0) {
    2369                 snd_korg1212_free(korg1212);
    2370                 return err;
    2371         }
    2372        
    23732285        snd_korg1212_EnableCardInterrupts(korg1212);
    23742286
    … …  
    24122324
    24132325        snd_korg1212_proc_init(korg1212);
    2414        
    2415         * rchip = korg1212;
     2326
    24162327        return 0;
    2417 
    24182328}
    24192329
    … …  
    24382348                return -ENOENT;
    24392349        }
    2440         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2441                            0, &card);
     2350        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2351                                sizeof(*korg1212), &card);
    24422352        if (err < 0)
    24432353                return err;
    2444 
    2445         err = snd_korg1212_create(card, pci, &korg1212);
    2446         if (err < 0) {
    2447                 snd_card_free(card);
    2448                 return err;
    2449         }
     2354        korg1212 = card->private_data;
     2355
     2356        err = snd_korg1212_create(card, pci);
     2357        if (err < 0)
     2358                goto error;
    24502359
    24512360        strcpy(card->driver, "korg1212");
    … …  
    24572366
    24582367        err = snd_card_register(card);
    2459         if (err < 0) {
    2460                 snd_card_free(card);
    2461                 return err;
    2462         }
     2368        if (err < 0)
     2369                goto error;
    24632370        pci_set_drvdata(pci, card);
    24642371        dev++;
    24652372        return 0;
    2466 }
    2467 
    2468 static void snd_korg1212_remove(struct pci_dev *pci)
    2469 {
    2470         snd_card_free(pci_get_drvdata(pci));
     2373
     2374 error:
     2375        snd_card_free(card);
     2376        return err;
    24712377}
    24722378
    … …  
    24752381        .id_table = snd_korg1212_ids,
    24762382        .probe = snd_korg1212_probe,
    2477         .remove = snd_korg1212_remove,
    24782383};
    24792384

  • GPL/trunk/alsa-kernel/pci/maestro3.c

    r703 r717  
    23512351 */
    23522352
    2353 static int snd_m3_free(struct snd_m3 *chip)
    2354 {
     2353static void snd_m3_free(struct snd_card *card)
     2354{
     2355        struct snd_m3 *chip = card->private_data;
    23552356        struct m3_dma *s;
    23562357        int i;
    23572358
    23582359        cancel_work_sync(&chip->hwvol_work);
    2359 #ifdef CONFIG_SND_MAESTRO3_INPUT
    2360         if (chip->input_dev)
    2361                 input_unregister_device(chip->input_dev);
    2362 #endif
    23632360
    23642361        if (chip->substreams) {
    … …  
    23712368                }
    23722369                spin_unlock_irq(&chip->reg_lock);
    2373                 kfree(chip->substreams);
    23742370        }
    23752371        if (chip->iobase) {
    … …  
    23802376        vfree(chip->suspend_mem);
    23812377#endif
    2382 
    2383         if (chip->irq >= 0)
    2384                 free_irq(chip->irq, chip);
    2385 
    2386         if (chip->iobase)
    2387                 pci_release_regions(chip->pci);
    2388 
    23892378        release_firmware(chip->assp_kernel_image);
    23902379        release_firmware(chip->assp_minisrc_image);
    2391 
    2392         pci_disable_device(chip->pci);
    2393         kfree(chip);
    2394         return 0;
    23952380}
    23962381
    … …  
    24852470        int err;
    24862471
    2487         input_dev = input_allocate_device();
     2472        input_dev = devm_input_allocate_device(&chip->pci->dev);
    24882473        if (!input_dev)
    24892474                return -ENOMEM;
    … …  
    25052490
    25062491        err = input_register_device(input_dev);
    2507         if (err) {
    2508                 input_free_device(input_dev);
     2492        if (err)
    25092493                return err;
    2510         }
    25112494
    25122495        chip->input_dev = input_dev;
    … …  
    25172500/*
    25182501 */
    2519 
    2520 static int snd_m3_dev_free(struct snd_device *device)
    2521 {
    2522         struct snd_m3 *chip = device->device_data;
    2523         return snd_m3_free(chip);
    2524 }
    25252502
    25262503static int
    25272504snd_m3_create(struct snd_card *card, struct pci_dev *pci,
    25282505              int enable_amp,
    2529               int amp_gpio,
    2530               struct snd_m3 **chip_ret)
    2531 {
    2532         struct snd_m3 *chip;
     2506              int amp_gpio)
     2507{
     2508        struct snd_m3 *chip = card->private_data;
    25332509        int i, err;
    25342510        const struct snd_pci_quirk *quirk;
    2535         static const struct snd_device_ops ops = {
    2536                 .dev_free =     snd_m3_dev_free,
    2537         };
    2538 
    2539         *chip_ret = NULL;
    2540 
    2541         if (pci_enable_device(pci))
     2511
     2512        if (pcim_enable_device(pci))
    25422513                return -EIO;
    25432514
    … …  
    25462517                dev_err(card->dev,
    25472518                        "architecture does not support 28bit PCI busmaster DMA\n");
    2548                 pci_disable_device(pci);
    25492519                return -ENXIO;
    2550         }
    2551 
    2552         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2553         if (chip == NULL) {
    2554                 pci_disable_device(pci);
    2555                 return -ENOMEM;
    25562520        }
    25572521
    … …  
    25712535        chip->irq = -1;
    25722536        INIT_WORK(&chip->hwvol_work, snd_m3_update_hw_volume);
     2537        card->private_free = snd_m3_free;
    25732538
    25742539        chip->external_amp = enable_amp;
    … …  
    26002565
    26012566        chip->num_substreams = NR_DSPS;
     2567#ifndef TARGET_OS2
     2568        chip->substreams = devm_kcalloc(&pci->dev, chip->num_substreams,
     2569                                        sizeof(struct m3_dma), GFP_KERNEL);
     2570#else
    26022571        chip->substreams = kcalloc(chip->num_substreams, sizeof(struct m3_dma),
    26032572                                   GFP_KERNEL);
    2604         if (chip->substreams == NULL) {
    2605                 kfree(chip);
    2606                 pci_disable_device(pci);
     2573#endif
     2574        if (!chip->substreams)
    26072575                return -ENOMEM;
    2608         }
    26092576
    26102577        err = request_firmware(&chip->assp_kernel_image,
    26112578                               "ess/maestro3_assp_kernel.fw", &pci->dev);
    26122579        if (err < 0)
    2613                 goto free_chip;
     2580                return err;
    26142581
    26152582        err = request_firmware(&chip->assp_minisrc_image,
    26162583                               "ess/maestro3_assp_minisrc.fw", &pci->dev);
    26172584        if (err < 0)
    2618                 goto free_chip;
     2585                return err;
    26192586
    26202587        err = pci_request_regions(pci, card->driver);
    26212588        if (err < 0)
    2622                 goto free_chip;
     2589                return err;
    26232590
    26242591        chip->iobase = pci_resource_start(pci, 0);
    … …  
    26362603        snd_m3_hv_init(chip);
    26372604
     2605#ifndef TARGET_OS2
     2606        if (devm_request_irq(&pci->dev, pci->irq, snd_m3_interrupt, IRQF_SHARED,
     2607                             KBUILD_MODNAME, chip)) {
     2608                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     2609                return -ENOMEM;
     2610        }
     2611#else
    26382612        if (request_irq(pci->irq, snd_m3_interrupt, IRQF_SHARED,
    26392613                        KBUILD_MODNAME, chip)) {
    26402614                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    2641                 err = -ENOMEM;
    2642                 goto free_chip;
    2643         }
     2615                return -ENOMEM;
     2616        }
     2617#endif
    26442618        chip->irq = pci->irq;
    26452619        card->sync_irq = chip->irq;
    … …  
    26542628#endif
    26552629
    2656         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2657         if (err < 0)
    2658                 goto free_chip;
    2659 
    26602630        err = snd_m3_mixer(chip);
    26612631        if (err < 0)
    … …  
    26862656        snd_m3_assp_continue(chip);
    26872657
    2688         *chip_ret = chip;
    2689 
    26902658        return 0;
    2691 
    2692 free_chip:
    2693         snd_m3_free(chip);
    2694         return err;
    26952659}
    26962660
    … …  
    26982662 */
    26992663static int
    2700 snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     2664__snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
    27012665{
    27022666        static int dev;
    … …  
    27162680        }
    27172681
    2718         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2719                            0, &card);
     2682        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2683                                sizeof(*chip), &card);
    27202684        if (err < 0)
    27212685                return err;
     2686        chip = card->private_data;
    27222687
    27232688        switch (pci->device) {
    … …  
    27352700        }
    27362701
    2737         err = snd_m3_create(card, pci, external_amp[dev], amp_gpio[dev], &chip);
     2702        err = snd_m3_create(card, pci, external_amp[dev], amp_gpio[dev]);
    27382703        if (err < 0)
    2739                 goto free_card;
    2740 
    2741         card->private_data = chip;
     2704                return err;
    27422705
    27432706        sprintf(card->shortname, "ESS %s PCI", card->driver);
    … …  
    27472710        err = snd_card_register(card);
    27482711        if (err < 0)
    2749                 goto free_card;
     2712                return err;
    27502713
    27512714#if 0 /* TODO: not supported yet */
    … …  
    27622725        dev++;
    27632726        return 0;
    2764 
    2765 free_card:
    2766         snd_card_free(card);
    2767         return err;
    2768 }
    2769 
    2770 static void snd_m3_remove(struct pci_dev *pci)
    2771 {
    2772         snd_card_free(pci_get_drvdata(pci));
     2727}
     2728
     2729static int
     2730snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     2731{
     2732        return snd_card_free_on_error(&pci->dev, __snd_m3_probe(pci, pci_id));
    27732733}
    27742734
    … …  
    27772737        .id_table = snd_m3_ids,
    27782738        .probe = snd_m3_probe,
    2779         .remove = snd_m3_remove,
    27802739        .driver = {
    27812740                .pm = M3_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/nm256/nm256.c

    r703 r717  
    198198
    199199        void __iomem *cport;            /* control port */
    200         struct resource *res_cport;     /* its resource */
    201200        unsigned long cport_addr;       /* physical address */
    202201
    203202        void __iomem *buffer;           /* buffer */
    204         struct resource *res_buffer;    /* its resource */
    205203        unsigned long buffer_addr;      /* buffer phyiscal address */
    206204
    … …  
    13181316        };
    13191317
    1320         chip->ac97_regs = kcalloc(ARRAY_SIZE(nm256_ac97_init_val),
    1321                                   sizeof(short), GFP_KERNEL);
     1318        chip->ac97_regs = devm_kcalloc(chip->card->dev,
     1319                                       ARRAY_SIZE(nm256_ac97_init_val),
     1320                                       sizeof(short), GFP_KERNEL);
    13221321        if (! chip->ac97_regs)
    13231322                return -ENOMEM;
    … …  
    14421441#endif /* CONFIG_PM_SLEEP */
    14431442
    1444 static int snd_nm256_free(struct nm256 *chip)
    1445 {
     1443static void snd_nm256_free(struct snd_card *card)
     1444{
     1445        struct nm256 *chip = card->private_data;
     1446
    14461447        if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
    14471448                snd_nm256_playback_stop(chip);
    14481449        if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
    14491450                snd_nm256_capture_stop(chip);
    1450 
    1451         if (chip->irq >= 0)
    1452                 free_irq(chip->irq, chip);
    1453 
    1454         iounmap(chip->cport);
    1455         iounmap(chip->buffer);
    1456         release_and_free_resource(chip->res_cport);
    1457         release_and_free_resource(chip->res_buffer);
    1458 
    1459         pci_disable_device(chip->pci);
    1460         kfree(chip->ac97_regs);
    1461         kfree(chip);
    1462         return 0;
    1463 }
    1464 
    1465 static int snd_nm256_dev_free(struct snd_device *device)
    1466 {
    1467         struct nm256 *chip = device->device_data;
    1468         return snd_nm256_free(chip);
    14691451}
    14701452
    14711453static int
    1472 snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
    1473                  struct nm256 **chip_ret)
    1474 {
    1475         struct nm256 *chip;
     1454snd_nm256_create(struct snd_card *card, struct pci_dev *pci)
     1455{
     1456        struct nm256 *chip = card->private_data;
    14761457        int err, pval;
    1477         static const struct snd_device_ops ops = {
    1478                 .dev_free =     snd_nm256_dev_free,
    1479         };
    14801458        u32 addr;
    14811459
    1482         *chip_ret = NULL;
    1483 
    1484         err = pci_enable_device(pci);
     1460        err = pcim_enable_device(pci);
    14851461        if (err < 0)
    14861462                return err;
    1487 
    1488         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1489         if (chip == NULL) {
    1490                 pci_disable_device(pci);
    1491                 return -ENOMEM;
    1492         }
    14931463
    14941464        chip->card = card;
    … …  
    15131483        chip->cport_addr = pci_resource_start(pci, 1);
    15141484
     1485        err = pci_request_regions(pci, card->driver);
     1486        if (err < 0)
     1487                return err;
     1488
    15151489        /* Init the memory port info.  */
    15161490        /* remap control port (#2) */
    1517         chip->res_cport = request_mem_region(chip->cport_addr, NM_PORT2_SIZE,
    1518                                              card->driver);
    1519         if (chip->res_cport == NULL) {
    1520                 dev_err(card->dev, "memory region 0x%lx (size 0x%x) busy\n",
    1521                            chip->cport_addr, NM_PORT2_SIZE);
    1522                 err = -EBUSY;
    1523                 goto __error;
    1524         }
    1525         chip->cport = ioremap(chip->cport_addr, NM_PORT2_SIZE);
    1526         if (chip->cport == NULL) {
     1491        chip->cport = devm_ioremap(&pci->dev, chip->cport_addr, NM_PORT2_SIZE);
     1492        if (!chip->cport) {
    15271493                dev_err(card->dev, "unable to map control port %lx\n",
    15281494                        chip->cport_addr);
    1529                 err = -ENOMEM;
    1530                 goto __error;
     1495                return -ENOMEM;
    15311496        }
    15321497
    … …  
    15441509                                dev_err(card->dev,
    15451510                                        "or try sb16, opl3sa2, or cs423x drivers instead.\n");
    1546                                 err = -ENXIO;
    1547                                 goto __error;
     1511                                return -ENXIO;
    15481512                        }
    15491513                }
    … …  
    15771541                err = snd_nm256_peek_for_sig(chip);
    15781542                if (err < 0)
    1579                         goto __error;
     1543                        return err;
    15801544        }
    15811545
    … …  
    15861550               chip->buffer_start, chip->buffer_end);
    15871551
    1588         chip->res_buffer = request_mem_region(chip->buffer_addr,
    1589                                               chip->buffer_size,
    1590                                               card->driver);
    1591         if (chip->res_buffer == NULL) {
    1592                 dev_err(card->dev, "buffer 0x%lx (size 0x%x) busy\n",
    1593                            chip->buffer_addr, chip->buffer_size);
    1594                 err = -EBUSY;
    1595                 goto __error;
    1596         }
    1597         chip->buffer = ioremap(chip->buffer_addr, chip->buffer_size);
    1598         if (chip->buffer == NULL) {
    1599                 err = -ENOMEM;
     1552        chip->buffer = devm_ioremap(&pci->dev, chip->buffer_addr,
     1553                                    chip->buffer_size);
     1554        if (!chip->buffer) {
    16001555                dev_err(card->dev, "unable to map ring buffer at %lx\n",
    16011556                        chip->buffer_addr);
    1602                 goto __error;
     1557                return -ENOMEM;
    16031558        }
    16041559
    … …  
    16251580
    16261581        // pci_set_master(pci); /* needed? */
    1627        
    1628         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1629         if (err < 0)
    1630                 goto __error;
    1631 
    1632         *chip_ret = chip;
    1633         return 0;
    1634 
    1635 __error:
    1636         snd_nm256_free(chip);
    1637         return err;
     1582        return 0;
    16381583}
    16391584
    … …  
    16781623        }
    16791624
    1680         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     1625        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     1626                                sizeof(*chip), &card);
    16811627        if (err < 0)
    16821628                return err;
     1629        chip = card->private_data;
    16831630
    16841631        switch (pci->device) {
    … …  
    16941641        default:
    16951642                dev_err(&pci->dev, "invalid device id 0x%x\n", pci->device);
    1696                 snd_card_free(card);
    16971643                return -EINVAL;
    16981644        }
    … …  
    17091655        if (capture_bufsize > 128)
    17101656                capture_bufsize = 128;
    1711         err = snd_nm256_create(card, pci, &chip);
    1712         if (err < 0) {
    1713                 snd_card_free(card);
     1657        err = snd_nm256_create(card, pci);
     1658        if (err < 0)
    17141659                return err;
    1715         }
    1716         card->private_data = chip;
    17171660
    17181661        if (reset_workaround) {
    … …  
    17271670
    17281671        err = snd_nm256_pcm(chip, 0);
    1729         if (err < 0) {
    1730                 snd_card_free(card);
     1672        if (err < 0)
    17311673                return err;
    1732         }
    17331674        err = snd_nm256_mixer(chip);
    1734         if (err < 0) {
    1735                 snd_card_free(card);
     1675        if (err < 0)
    17361676                return err;
    1737         }
    17381677
    17391678        sprintf(card->shortname, "NeoMagic %s", card->driver);
    … …  
    17431682
    17441683        err = snd_card_register(card);
    1745         if (err < 0) {
    1746                 snd_card_free(card);
     1684        if (err < 0)
    17471685                return err;
    1748         }
     1686        card->private_free = snd_nm256_free;
    17491687
    17501688        pci_set_drvdata(pci, card);
    17511689        return 0;
    17521690}
    1753 
    1754 static void snd_nm256_remove(struct pci_dev *pci)
    1755 {
    1756         snd_card_free(pci_get_drvdata(pci));
    1757 }
    1758 
    17591691
    17601692static struct pci_driver nm256_driver = {
    … …  
    17621694        .id_table = snd_nm256_ids,
    17631695        .probe = snd_nm256_probe,
    1764         .remove = snd_nm256_remove,
    17651696        .driver = {
    17661697                .pm = NM256_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/rme9652/hdsp.c

    r703 r717  
    469469        u32                   io_loopback;          /* output loopback channel states*/
    470470
     471        /* DMA buffers; those are copied instances from the original snd_dma_buf
     472         * objects (which are managed via devres) for the address alignments
     473         */
    471474        struct snd_dma_buffer capture_dma_buf;
    472475        struct snd_dma_buffer playback_dma_buf;
    … …  
    566569};
    567570
    568 static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size)
    569 {
    570         return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, size, dmab);
    571 }
    572 
    573 static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci)
    574 {
    575         if (dmab->area)
    576                 snd_dma_free_pages(dmab);
    577 }
    578 
     571static struct snd_dma_buffer *
     572snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size)
     573{
     574        return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size);
     575}
    579576
    580577static const struct pci_device_id snd_hdsp_ids[] = {
    … …  
    37693766}
    37703767
    3771 static void snd_hdsp_free_buffers(struct hdsp *hdsp)
    3772 {
    3773         snd_hammerfall_free_buffer(&hdsp->capture_dma_buf, hdsp->pci);
    3774         snd_hammerfall_free_buffer(&hdsp->playback_dma_buf, hdsp->pci);
    3775 }
    3776 
    37773768static int snd_hdsp_initialize_memory(struct hdsp *hdsp)
    37783769{
    3779         unsigned long pb_bus, cb_bus;
    3780 
    3781         if (snd_hammerfall_get_buffer(hdsp->pci, &hdsp->capture_dma_buf, HDSP_DMA_AREA_BYTES) < 0 ||
    3782             snd_hammerfall_get_buffer(hdsp->pci, &hdsp->playback_dma_buf, HDSP_DMA_AREA_BYTES) < 0) {
    3783                 if (hdsp->capture_dma_buf.area)
    3784                         snd_dma_free_pages(&hdsp->capture_dma_buf);
     3770        struct snd_dma_buffer *capture_dma, *playback_dma;
     3771
     3772        capture_dma = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
     3773        playback_dma = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
     3774        if (!capture_dma || !playback_dma) {
    37853775                dev_err(hdsp->card->dev,
    37863776                        "%s: no buffers available\n", hdsp->card_name);
    … …  
    37883778        }
    37893779
     3780        /* copy to the own data for alignment */
     3781        hdsp->capture_dma_buf = *capture_dma;
     3782        hdsp->playback_dma_buf = *playback_dma;
     3783
    37903784        /* Align to bus-space 64K boundary */
    3791 
    3792         cb_bus = ALIGN(hdsp->capture_dma_buf.addr, 0x10000ul);
    3793         pb_bus = ALIGN(hdsp->playback_dma_buf.addr, 0x10000ul);
     3785        hdsp->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul);
     3786        hdsp->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul);
    37943787
    37953788        /* Tell the card where it is */
    3796 
    3797         hdsp_write(hdsp, HDSP_inputBufferAddress, cb_bus);
    3798         hdsp_write(hdsp, HDSP_outputBufferAddress, pb_bus);
    3799 
    3800         hdsp->capture_buffer = hdsp->capture_dma_buf.area + (cb_bus - hdsp->capture_dma_buf.addr);
    3801         hdsp->playback_buffer = hdsp->playback_dma_buf.area + (pb_bus - hdsp->playback_dma_buf.addr);
     3789        hdsp_write(hdsp, HDSP_inputBufferAddress, hdsp->capture_dma_buf.addr);
     3790        hdsp_write(hdsp, HDSP_outputBufferAddress, hdsp->playback_dma_buf.addr);
     3791
     3792        hdsp->capture_dma_buf.area += hdsp->capture_dma_buf.addr - capture_dma->addr;
     3793        hdsp->playback_dma_buf.area += hdsp->playback_dma_buf.addr - playback_dma->addr;
     3794        hdsp->capture_buffer = hdsp->capture_dma_buf.area;
     3795        hdsp->playback_buffer = hdsp->playback_dma_buf.area;
    38023796
    38033797        return 0;
    … …  
    45194513
    45204514        runtime->hw = snd_hdsp_playback_subinfo;
    4521         runtime->dma_area = hdsp->playback_buffer;
    4522         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
     4515        snd_pcm_set_runtime_buffer(substream, &hdsp->playback_dma_buf);
    45234516
    45244517        hdsp->playback_pid = current->pid;
    … …  
    45964589
    45974590        runtime->hw = snd_hdsp_capture_subinfo;
    4598         runtime->dma_area = hdsp->capture_buffer;
    4599         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
     4591        snd_pcm_set_runtime_buffer(substream, &hdsp->capture_dma_buf);
    46004592
    46014593        hdsp->capture_pid = current->pid;
    … …  
    53145306        }
    53155307
    5316         err = pci_enable_device(pci);
     5308        err = pcim_enable_device(pci);
    53175309        if (err < 0)
    53185310                return err;
    … …  
    53245316                return err;
    53255317        hdsp->port = pci_resource_start(pci, 0);
    5326         hdsp->iobase = ioremap(hdsp->port, HDSP_IO_EXTENT);
     5318        hdsp->iobase = devm_ioremap(&pci->dev, hdsp->port, HDSP_IO_EXTENT);
    53275319        if (!hdsp->iobase) {
    53285320                dev_err(hdsp->card->dev, "unable to remap region 0x%lx-0x%lx\n",
    … …  
    53315323        }
    53325324
    5333         if (request_irq(pci->irq, snd_hdsp_interrupt, IRQF_SHARED,
    5334                         KBUILD_MODNAME, hdsp)) {
     5325        if (devm_request_irq(&pci->dev, pci->irq, snd_hdsp_interrupt,
     5326                             IRQF_SHARED, KBUILD_MODNAME, hdsp)) {
    53355327                dev_err(hdsp->card->dev, "unable to use IRQ %d\n", pci->irq);
    53365328                return -EBUSY;
    … …  
    54125404}
    54135405
    5414 static int snd_hdsp_free(struct hdsp *hdsp)
    5415 {
     5406static void snd_hdsp_card_free(struct snd_card *card)
     5407{
     5408        struct hdsp *hdsp = card->private_data;
     5409
    54165410        if (hdsp->port) {
    54175411                /* stop the audio, and cancel all interrupts */
    … …  
    54215415        }
    54225416
    5423         if (hdsp->irq >= 0)
    5424                 free_irq(hdsp->irq, (void *)hdsp);
    5425 
    5426         snd_hdsp_free_buffers(hdsp);
    5427 
    54285417        release_firmware(hdsp->firmware);
    54295418        vfree(hdsp->fw_uploaded);
    5430         iounmap(hdsp->iobase);
    5431 
    5432         if (hdsp->port)
    5433                 pci_release_regions(hdsp->pci);
    5434 
    5435         if (pci_is_enabled(hdsp->pci))
    5436                 pci_disable_device(hdsp->pci);
    5437         return 0;
    5438 }
    5439 
    5440 static void snd_hdsp_card_free(struct snd_card *card)
    5441 {
    5442         struct hdsp *hdsp = card->private_data;
    5443 
    5444         if (hdsp)
    5445                 snd_hdsp_free(hdsp);
    54465419}
    54475420
    … …  
    54615434        }
    54625435
    5463         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    5464                            sizeof(struct hdsp), &card);
     5436        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     5437                                sizeof(struct hdsp), &card);
    54655438        if (err < 0)
    54665439                return err;
    … …  
    54725445        err = snd_hdsp_create(card, hdsp);
    54735446        if (err)
    5474                 goto free_card;
     5447                goto error;
    54755448
    54765449        strcpy(card->shortname, "Hammerfall DSP");
    … …  
    54785451                hdsp->port, hdsp->irq);
    54795452        err = snd_card_register(card);
    5480         if (err) {
    5481 free_card:
    5482                 snd_card_free(card);
    5483                 return err;
    5484         }
     5453        if (err)
     5454                goto error;
    54855455        pci_set_drvdata(pci, card);
    54865456        dev++;
    54875457        return 0;
    5488 }
    5489 
    5490 static void snd_hdsp_remove(struct pci_dev *pci)
    5491 {
    5492         snd_card_free(pci_get_drvdata(pci));
     5458
     5459 error:
     5460        snd_card_free(card);
     5461        return err;
    54935462}
    54945463
    … …  
    54975466        .id_table = snd_hdsp_ids,
    54985467        .probe =    snd_hdsp_probe,
    5499         .remove = snd_hdsp_remove,
    55005468};
    55015469

  • GPL/trunk/alsa-kernel/pci/rme9652/hdspm.c

    r695 r717  
    65766576        }
    65776577
    6578         err = pci_enable_device(pci);
     6578        err = pcim_enable_device(pci);
    65796579        if (err < 0)
    65806580                return err;
    … …  
    65826582        pci_set_master(hdspm->pci);
    65836583
    6584         err = pci_request_regions(pci, "hdspm");
     6584        err = pcim_iomap_regions(pci, 1 << 0, "hdspm");
    65856585        if (err < 0)
    65866586                return err;
    … …  
    65886588        hdspm->port = pci_resource_start(pci, 0);
    65896589        io_extent = pci_resource_len(pci, 0);
    6590 
    6591         dev_dbg(card->dev, "grabbed memory region 0x%lx-0x%lx\n",
    6592                         hdspm->port, hdspm->port + io_extent - 1);
    6593 
    6594         hdspm->iobase = ioremap(hdspm->port, io_extent);
    6595         if (!hdspm->iobase) {
    6596                 dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
    6597                                 hdspm->port, hdspm->port + io_extent - 1);
    6598                 return -EBUSY;
    6599         }
     6590        hdspm->iobase = pcim_iomap_table(pci)[0];
    66006591        dev_dbg(card->dev, "remapped region (0x%lx) 0x%lx-0x%lx\n",
    66016592                        (unsigned long)hdspm->iobase, hdspm->port,
    66026593                        hdspm->port + io_extent - 1);
    66036594
    6604         if (request_irq(pci->irq, snd_hdspm_interrupt,
    6605                         IRQF_SHARED, KBUILD_MODNAME, hdspm)) {
     6595        if (devm_request_irq(&pci->dev, pci->irq, snd_hdspm_interrupt,
     6596                             IRQF_SHARED, KBUILD_MODNAME, hdspm)) {
    66066597                dev_err(card->dev, "unable to use IRQ %d\n", pci->irq);
    66076598                return -EBUSY;
    … …  
    66156606        dev_dbg(card->dev, "kmalloc Mixer memory of %zd Bytes\n",
    66166607                sizeof(*hdspm->mixer));
    6617         hdspm->mixer = kzalloc(sizeof(*hdspm->mixer), GFP_KERNEL);
     6608        hdspm->mixer = devm_kzalloc(&pci->dev, sizeof(*hdspm->mixer), GFP_KERNEL);
    66186609        if (!hdspm->mixer)
    66196610                return -ENOMEM;
    … …  
    68606851
    68616852
    6862 static int snd_hdspm_free(struct hdspm * hdspm)
    6863 {
     6853static void snd_hdspm_card_free(struct snd_card *card)
     6854{
     6855        struct hdspm *hdspm = card->private_data;
    68646856
    68656857        if (hdspm->port) {
    … …  
    68746866                            hdspm->control_register);
    68756867        }
    6876 
    6877         if (hdspm->irq >= 0)
    6878                 free_irq(hdspm->irq, (void *) hdspm);
    6879 
    6880         kfree(hdspm->mixer);
    6881         iounmap(hdspm->iobase);
    6882 
    6883         if (hdspm->port)
    6884                 pci_release_regions(hdspm->pci);
    6885 
    6886         if (pci_is_enabled(hdspm->pci))
    6887                 pci_disable_device(hdspm->pci);
    6888         return 0;
    6889 }
    6890 
    6891 
    6892 static void snd_hdspm_card_free(struct snd_card *card)
    6893 {
    6894         struct hdspm *hdspm = card->private_data;
    6895 
    6896         if (hdspm)
    6897                 snd_hdspm_free(hdspm);
    68986868}
    68996869
    … …  
    69146884        }
    69156885
    6916         err = snd_card_new(&pci->dev, index[dev], id[dev],
    6917                            THIS_MODULE, sizeof(*hdspm), &card);
     6886        err = snd_devm_card_new(&pci->dev, index[dev], id[dev],
     6887                                THIS_MODULE, sizeof(*hdspm), &card);
    69186888        if (err < 0)
    69196889                return err;
    … …  
    69266896        err = snd_hdspm_create(card, hdspm);
    69276897        if (err < 0)
    6928                 goto free_card;
     6898                goto error;
    69296899
    69306900        if (hdspm->io_type != MADIface) {
    … …  
    69456915        err = snd_card_register(card);
    69466916        if (err < 0)
    6947                 goto free_card;
     6917                goto error;
    69486918
    69496919        pci_set_drvdata(pci, card);
    … …  
    69526922        return 0;
    69536923
    6954 free_card:
     6924 error:
    69556925        snd_card_free(card);
    69566926        return err;
    6957 }
    6958 
    6959 static void snd_hdspm_remove(struct pci_dev *pci)
    6960 {
    6961         snd_card_free(pci_get_drvdata(pci));
    69626927}
    69636928
    … …  
    69666931        .id_table = snd_hdspm_ids,
    69676932        .probe = snd_hdspm_probe,
    6968         .remove = snd_hdspm_remove,
    69696933};
    69706934

  • GPL/trunk/alsa-kernel/pci/rme9652/rme9652.c

    r703 r717  
    209209        unsigned char ss_channels;      /* different for hammerfall/hammerfall-light */
    210210
     211        /* DMA buffers; those are copied instances from the original snd_dma_buf
     212         * objects (which are managed via devres) for the address alignments
     213         */
    211214        struct snd_dma_buffer playback_dma_buf;
    212215        struct snd_dma_buffer capture_dma_buf;
    … …  
    276279};
    277280
    278 static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size)
    279 {
    280         return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, size, dmab);
    281 }
    282 
    283 static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci)
    284 {
    285         if (dmab->area)
    286                 snd_dma_free_pages(dmab);
    287 }
    288 
     281static struct snd_dma_buffer *
     282snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size)
     283{
     284        return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size);
     285}
    289286
    290287static const struct pci_device_id snd_rme9652_ids[] = {
    … …  
    17161713}
    17171714
    1718 static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652)
    1719 {
    1720         snd_hammerfall_free_buffer(&rme9652->capture_dma_buf, rme9652->pci);
    1721         snd_hammerfall_free_buffer(&rme9652->playback_dma_buf, rme9652->pci);
    1722 }
    1723 
    1724 static int snd_rme9652_free(struct snd_rme9652 *rme9652)
    1725 {
     1715static void snd_rme9652_card_free(struct snd_card *card)
     1716{
     1717        struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
     1718
    17261719        if (rme9652->irq >= 0)
    17271720                rme9652_stop(rme9652);
    1728         snd_rme9652_free_buffers(rme9652);
    1729 
    1730         if (rme9652->irq >= 0)
    1731                 free_irq(rme9652->irq, (void *)rme9652);
    1732         iounmap(rme9652->iobase);
    1733         if (rme9652->port)
    1734                 pci_release_regions(rme9652->pci);
    1735 
    1736         if (pci_is_enabled(rme9652->pci))
    1737                 pci_disable_device(rme9652->pci);
    1738         return 0;
    17391721}
    17401722
    17411723static int snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)
    17421724{
    1743         unsigned long pb_bus, cb_bus;
    1744 
    1745         if (snd_hammerfall_get_buffer(rme9652->pci, &rme9652->capture_dma_buf, RME9652_DMA_AREA_BYTES) < 0 ||
    1746             snd_hammerfall_get_buffer(rme9652->pci, &rme9652->playback_dma_buf, RME9652_DMA_AREA_BYTES) < 0) {
    1747                 if (rme9652->capture_dma_buf.area)
    1748                         snd_dma_free_pages(&rme9652->capture_dma_buf);
     1725        struct snd_dma_buffer *capture_dma, *playback_dma;
     1726
     1727        capture_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
     1728        playback_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
     1729        if (!capture_dma || !playback_dma) {
    17491730                dev_err(rme9652->card->dev,
    17501731                        "%s: no buffers available\n", rme9652->card_name);
    … …  
    17521733        }
    17531734
     1735        /* copy to the own data for alignment */
     1736        rme9652->capture_dma_buf = *capture_dma;
     1737        rme9652->playback_dma_buf = *playback_dma;
     1738
    17541739        /* Align to bus-space 64K boundary */
    1755 
    1756         cb_bus = ALIGN(rme9652->capture_dma_buf.addr, 0x10000ul);
    1757         pb_bus = ALIGN(rme9652->playback_dma_buf.addr, 0x10000ul);
     1740        rme9652->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul);
     1741        rme9652->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul);
    17581742
    17591743        /* Tell the card where it is */
    1760 
    1761         rme9652_write(rme9652, RME9652_rec_buffer, cb_bus);
    1762         rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
    1763 
    1764         rme9652->capture_buffer = rme9652->capture_dma_buf.area + (cb_bus - rme9652->capture_dma_buf.addr);
    1765         rme9652->playback_buffer = rme9652->playback_dma_buf.area + (pb_bus - rme9652->playback_dma_buf.addr);
     1744        rme9652_write(rme9652, RME9652_rec_buffer, rme9652->capture_dma_buf.addr);
     1745        rme9652_write(rme9652, RME9652_play_buffer, rme9652->playback_dma_buf.addr);
     1746
     1747        rme9652->capture_dma_buf.area += rme9652->capture_dma_buf.addr - capture_dma->addr;
     1748        rme9652->playback_dma_buf.area += rme9652->playback_dma_buf.addr - playback_dma->addr;
     1749        rme9652->capture_buffer = rme9652->capture_dma_buf.area;
     1750        rme9652->playback_buffer = rme9652->playback_dma_buf.area;
    17661751
    17671752        return 0;
    … …  
    22802265
    22812266        runtime->hw = snd_rme9652_playback_subinfo;
    2282         runtime->dma_area = rme9652->playback_buffer;
    2283         runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
     2267        snd_pcm_set_runtime_buffer(substream, &rme9652->playback_dma_buf);
    22842268
    22852269        if (rme9652->capture_substream == NULL) {
    … …  
    23402324
    23412325        runtime->hw = snd_rme9652_capture_subinfo;
    2342         runtime->dma_area = rme9652->capture_buffer;
    2343         runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
     2326        snd_pcm_set_runtime_buffer(substream, &rme9652->capture_dma_buf);
    23442327
    23452328        if (rme9652->playback_substream == NULL) {
    … …  
    24532436        }
    24542437
    2455         err = pci_enable_device(pci);
     2438        err = pcim_enable_device(pci);
    24562439        if (err < 0)
    24572440                return err;
    … …  
    24632446                return err;
    24642447        rme9652->port = pci_resource_start(pci, 0);
    2465         rme9652->iobase = ioremap(rme9652->port, RME9652_IO_EXTENT);
     2448        rme9652->iobase = devm_ioremap(&pci->dev, rme9652->port, RME9652_IO_EXTENT);
    24662449        if (rme9652->iobase == NULL) {
    24672450                dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
    … …  
    24702453        }
    24712454       
    2472         if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED,
    2473                         KBUILD_MODNAME, rme9652)) {
     2455        if (devm_request_irq(&pci->dev, pci->irq, snd_rme9652_interrupt,
     2456                             IRQF_SHARED, KBUILD_MODNAME, rme9652)) {
    24742457                dev_err(card->dev, "unable to request IRQ %d\n", pci->irq);
    24752458                return -EBUSY;
    … …  
    25632546}
    25642547
    2565 static void snd_rme9652_card_free(struct snd_card *card)
    2566 {
    2567         struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
    2568 
    2569         if (rme9652)
    2570                 snd_rme9652_free(rme9652);
    2571 }
    2572 
    25732548static int snd_rme9652_probe(struct pci_dev *pci,
    25742549                             const struct pci_device_id *pci_id)
    … …  
    25862561        }
    25872562
    2588         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2589                            sizeof(struct snd_rme9652), &card);
     2563        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2564                                sizeof(struct snd_rme9652), &card);
    25902565
    25912566        if (err < 0)
    … …  
    25982573        err = snd_rme9652_create(card, rme9652, precise_ptr[dev]);
    25992574        if (err)
    2600                 goto free_card;
     2575                goto error;
    26012576
    26022577        strcpy(card->shortname, rme9652->card_name);
    … …  
    26052580                card->shortname, rme9652->port, rme9652->irq);
    26062581        err = snd_card_register(card);
    2607         if (err) {
    2608 free_card:
    2609                 snd_card_free(card);
    2610                 return err;
    2611         }
     2582        if (err)
     2583                goto error;
    26122584        pci_set_drvdata(pci, card);
    26132585        dev++;
    26142586        return 0;
    2615 }
    2616 
    2617 static void snd_rme9652_remove(struct pci_dev *pci)
    2618 {
    2619         snd_card_free(pci_get_drvdata(pci));
     2587
     2588 error:
     2589        snd_card_free(card);
     2590        return err;
    26202591}
    26212592
    … …  
    26242595        .id_table = snd_rme9652_ids,
    26252596        .probe    = snd_rme9652_probe,
    2626         .remove   = snd_rme9652_remove,
    26272597};
    26282598

  • GPL/trunk/alsa-kernel/pci/trident/trident.c

    r703 r717  
    7272        }
    7373
    74         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    75                            0, &card);
     74        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     75                                sizeof(*trident), &card);
    7676        if (err < 0)
    7777                return err;
     78        trident = card->private_data;
    7879
    7980        err = snd_trident_create(card, pci,
    8081                                 pcm_channels[dev],
    8182                                 ((pci->vendor << 16) | pci->device) == TRIDENT_DEVICE_ID_SI7018 ? 1 : 2,
    82                                  wavetable_size[dev],
    83                                  &trident);
    84         if (err < 0) {
    85                 snd_card_free(card);
     83                                 wavetable_size[dev]);
     84        if (err < 0)
    8685                return err;
    87         }
    88         card->private_data = trident;
    8986
    9087        switch (trident->device) {
    … …  
    112109
    113110        err = snd_trident_pcm(trident, pcm_dev++);
    114         if (err < 0) {
    115                 snd_card_free(card);
     111        if (err < 0)
    116112                return err;
    117         }
    118113        switch (trident->device) {
    119114        case TRIDENT_DEVICE_ID_DX:
    120115        case TRIDENT_DEVICE_ID_NX:
    121116                err = snd_trident_foldback_pcm(trident, pcm_dev++);
    122                 if (err < 0) {
    123                         snd_card_free(card);
     117                if (err < 0)
    124118                        return err;
    125                 }
    126119                break;
    127120        }
    128121        if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
    129122                err = snd_trident_spdif_pcm(trident, pcm_dev++);
    130                 if (err < 0) {
    131                         snd_card_free(card);
     123                if (err < 0)
    132124                        return err;
    133                 }
    134125        }
    135126        if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
    … …  
    139130                                          MPU401_INFO_IRQ_HOOK,
    140131                                          -1, &trident->rmidi);
    141                 if (err < 0) {
    142                         snd_card_free(card);
     132                if (err < 0)
    143133                        return err;
    144                 }
    145134        }
    146135
    … …  
    148137
    149138        err = snd_card_register(card);
    150         if (err < 0) {
    151                 snd_card_free(card);
     139        if (err < 0)
    152140                return err;
    153         }
    154141        pci_set_drvdata(pci, card);
    155142        dev++;
    156143        return 0;
    157 }
    158 
    159 static void snd_trident_remove(struct pci_dev *pci)
    160 {
    161         snd_card_free(pci_get_drvdata(pci));
    162144}
    163145
    … …  
    166148        .id_table = snd_trident_ids,
    167149        .probe = snd_trident_probe,
    168         .remove = snd_trident_remove,
    169150#ifdef CONFIG_PM_SLEEP
    170151        .driver = {

  • GPL/trunk/alsa-kernel/pci/trident/trident.h

    r703 r717  
    252252        __le32 *entries;                /* 16k-aligned TLB table */
    253253        dma_addr_t entries_dmaaddr;     /* 16k-aligned PCI address to TLB table */
    254         struct snd_dma_buffer buffer;
     254        struct snd_dma_buffer *buffer;
    255255        struct snd_util_memhdr * memhdr;        /* page allocation list */
    256         struct snd_dma_buffer silent_page;
     256        struct snd_dma_buffer *silent_page;
    257257};
    258258
    … …  
    401401                       int pcm_streams,
    402402                       int pcm_spdif_device,
    403                        int max_wavetable_size,
    404                        struct snd_trident ** rtrident);
     403                       int max_wavetable_size);
    405404int snd_trident_create_gameport(struct snd_trident *trident);
    406405

  • GPL/trunk/alsa-kernel/pci/trident/trident_main.c

    r703 r717  
    4747static void snd_trident_clear_voices(struct snd_trident * trident,
    4848                                     unsigned short v_min, unsigned short v_max);
    49 static int snd_trident_free(struct snd_trident *trident);
     49static void snd_trident_free(struct snd_card *card);
    5050
    5151/*
    … …  
    33123312}
    33133313
    3314 static int snd_trident_dev_free(struct snd_device *device)
    3315 {
    3316         struct snd_trident *trident = device->device_data;
    3317         return snd_trident_free(trident);
    3318 }
    3319 
    33203314/*---------------------------------------------------------------------------
    33213315   snd_trident_tlb_alloc
    … …  
    33373331           32kB region and correct offset when necessary */
    33383332
    3339         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
    3340                                 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
     3333        trident->tlb.buffer =
     3334                snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
     3335                                     2 * SNDRV_TRIDENT_MAX_PAGES * 4);
     3336        if (!trident->tlb.buffer) {
    33413337                dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
    33423338                return -ENOMEM;
    33433339        }
    3344         trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
    3345         trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
     3340        trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer->area, SNDRV_TRIDENT_MAX_PAGES * 4);
     3341        trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer->addr, SNDRV_TRIDENT_MAX_PAGES * 4);
    33463342
    33473343        /* allocate and setup silent page and initialise TLB entries */
    3348         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
    3349                                 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
     3344        trident->tlb.silent_page =
     3345                snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
     3346                                     SNDRV_TRIDENT_PAGE_SIZE);
     3347        if (!trident->tlb.silent_page) {
    33503348                dev_err(trident->card->dev, "unable to allocate silent page\n");
    33513349                return -ENOMEM;
    33523350        }
    3353         memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
     3351        memset(trident->tlb.silent_page->area, 0, SNDRV_TRIDENT_PAGE_SIZE);
    33543352        for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++)
    3355                 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
     3353                trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page->addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
    33563354
    33573355        /* use emu memory block manager code to manage tlb page allocation */
    … …  
    35103508                       int pcm_streams,
    35113509                       int pcm_spdif_device,
    3512                        int max_wavetable_size,
    3513                        struct snd_trident ** rtrident)
    3514 {
    3515         struct snd_trident *trident;
     3510                       int max_wavetable_size)
     3511{
     3512        struct snd_trident *trident = card->private_data;
    35163513        int i, err;
    35173514        struct snd_trident_voice *voice;
    35183515        struct snd_trident_pcm_mixer *tmix;
    3519         static const struct snd_device_ops ops = {
    3520                 .dev_free =     snd_trident_dev_free,
    3521         };
    3522 
    3523         *rtrident = NULL;
    35243516
    35253517        /* enable PCI device */
    3526         err = pci_enable_device(pci);
     3518        err = pcim_enable_device(pci);
    35273519        if (err < 0)
    35283520                return err;
    … …  
    35313523                dev_err(card->dev,
    35323524                        "architecture does not support 30bit PCI busmaster DMA\n");
    3533                 pci_disable_device(pci);
    35343525                return -ENXIO;
    35353526        }
    35363527       
    3537         trident = kzalloc(sizeof(*trident), GFP_KERNEL);
    3538         if (trident == NULL) {
    3539                 pci_disable_device(pci);
    3540                 return -ENOMEM;
    3541         }
    35423528        trident->device = (pci->vendor << 16) | pci->device;
    35433529        trident->card = card;
    … …  
    35553541        trident->synth.max_size = max_wavetable_size * 1024;
    35563542        trident->irq = -1;
     3543        card->private_free = snd_trident_free;
    35573544
    35583545        trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
    … …  
    35603547
    35613548        err = pci_request_regions(pci, "Trident Audio");
    3562         if (err < 0) {
    3563                 kfree(trident);
    3564                 pci_disable_device(pci);
     3549        if (err < 0)
    35653550                return err;
    3566         }
    35673551        trident->port = pci_resource_start(pci, 0);
    35683552
    3569         if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
    3570                         KBUILD_MODNAME, trident)) {
     3553        if (devm_request_irq(&pci->dev, pci->irq, snd_trident_interrupt,
     3554                             IRQF_SHARED, KBUILD_MODNAME, trident)) {
    35713555                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    3572                 snd_trident_free(trident);
    35733556                return -EBUSY;
    35743557        }
    … …  
    35783561        /* allocate 16k-aligned TLB for NX cards */
    35793562        trident->tlb.entries = NULL;
    3580         trident->tlb.buffer.area = NULL;
    35813563        if (trident->device == TRIDENT_DEVICE_ID_NX) {
    35823564                err = snd_trident_tlb_alloc(trident);
    3583                 if (err < 0) {
    3584                         snd_trident_free(trident);
     3565                if (err < 0)
    35853566                        return err;
    3586                 }
    35873567        }
    35883568
    … …  
    36043584                break;
    36053585        }
    3606         if (err < 0) {
    3607                 snd_trident_free(trident);
     3586        if (err < 0)
    36083587                return err;
    3609         }
    3610 
    3611         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops);
    3612         if (err < 0) {
    3613                 snd_trident_free(trident);
    3614                 return err;
    3615         }
    36163588
    36173589        err = snd_trident_mixer(trident, pcm_spdif_device);
    … …  
    36373609
    36383610        snd_trident_proc_init(trident);
    3639         *rtrident = trident;
    36403611        return 0;
    36413612}
    … …  
    36473618                the 4DWave card.
    36483619               
    3649    Parameters:  trident  - device specific private data for 4DWave card
     3620   Parameters:  card - card to release
    36503621
    36513622   Returns:     None.
    … …  
    36533624  ---------------------------------------------------------------------------*/
    36543625
    3655 static int snd_trident_free(struct snd_trident *trident)
    3656 {
     3626static void snd_trident_free(struct snd_card *card)
     3627{
     3628        struct snd_trident *trident = card->private_data;
     3629
    36573630        snd_trident_free_gameport(trident);
    36583631        snd_trident_disable_eso(trident);
    … …  
    36633636                outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
    36643637        }
    3665         if (trident->irq >= 0)
    3666                 free_irq(trident->irq, trident);
    3667         if (trident->tlb.buffer.area) {
     3638        if (trident->tlb.buffer) {
    36683639                outl(0, TRID_REG(trident, NX_TLBC));
    36693640                snd_util_memhdr_free(trident->tlb.memhdr);
    3670                 if (trident->tlb.silent_page.area)
    3671                         snd_dma_free_pages(&trident->tlb.silent_page);
    3672                 snd_dma_free_pages(&trident->tlb.buffer);
    3673         }
    3674         pci_release_regions(trident->pci);
    3675         pci_disable_device(trident->pci);
    3676         kfree(trident);
    3677         return 0;
     3641        }
    36783642}
    36793643

  • GPL/trunk/alsa-kernel/pci/trident/trident_memory.c

    r703 r717  
    3232#define set_tlb_bus(trident,page,addr) __set_tlb_bus(trident,page,addr)
    3333/* fill TLB entrie(s) corresponding to page with silence pointer */
    34 #define set_silent_tlb(trident,page)    __set_tlb_bus(trident, page, trident->tlb.silent_page.addr)
     34#define set_silent_tlb(trident,page)    __set_tlb_bus(trident, page, trident->tlb.silent_page->addr)
    3535/* get aligned page from offset address */
    3636#define get_aligned_page(offset)        ((offset) >> 12)
    … …  
    5959{
    6060        page <<= 1;
    61         __set_tlb_bus(trident, page, trident->tlb.silent_page.addr);
    62         __set_tlb_bus(trident, page+1, trident->tlb.silent_page.addr);
     61        __set_tlb_bus(trident, page, trident->tlb.silent_page->addr);
     62        __set_tlb_bus(trident, page+1, trident->tlb.silent_page->addr);
    6363}
    6464
    … …  
    9393        page *= UNIT_PAGES;
    9494        for (i = 0; i < UNIT_PAGES; i++, page++)
    95                 __set_tlb_bus(trident, page, trident->tlb.silent_page.addr);
     95                __set_tlb_bus(trident, page, trident->tlb.silent_page->addr);
    9696}
    9797

  • GPL/trunk/alsa-kernel/pci/via82xx.c

    r703 r717  
    19161916{
    19171917        struct gameport *gp;
    1918         struct resource *r;
    19191918
    19201919        if (!joystick)
    19211920                return -ENODEV;
    19221921
    1923         r = request_region(JOYSTICK_ADDR, 8, "VIA686 gameport");
    1924         if (!r) {
     1922        if (!devm_request_region(chip->card->dev, JOYSTICK_ADDR, 8,
     1923                                 "VIA686 gameport")) {
    19251924                dev_warn(chip->card->dev, "cannot reserve joystick port %#x\n",
    19261925                       JOYSTICK_ADDR);
    … …  
    19321931                dev_err(chip->card->dev,
    19331932                        "cannot allocate memory for gameport\n");
    1934                 release_and_free_resource(r);
    19351933                return -ENOMEM;
    19361934        }
    … …  
    19401938        gameport_set_dev_parent(gp, &chip->pci->dev);
    19411939        gp->io = JOYSTICK_ADDR;
    1942         gameport_set_port_data(gp, r);
    19431940
    19441941        /* Enable legacy joystick port */
    … …  
    19541951{
    19551952        if (chip->gameport) {
    1956                 struct resource *r = gameport_get_port_data(chip->gameport);
    1957 
    19581953                gameport_unregister_port(chip->gameport);
    19591954                chip->gameport = NULL;
    1960                 release_and_free_resource(r);
    19611955        }
    19621956}
    … …  
    20682062        }
    20692063        if (mpu_port >= 0x200)
    2070                 chip->mpu_res = request_region(mpu_port, 2, "VIA82xx MPU401");
     2064                chip->mpu_res = devm_request_region(&chip->pci->dev, mpu_port,
     2065                                                    2, "VIA82xx MPU401");
    20712066        if (chip->mpu_res) {
    20722067                if (rev_h)
    … …  
    23072302#endif /* CONFIG_PM_SLEEP */
    23082303
    2309 static int snd_via82xx_free(struct via82xx *chip)
    2310 {
     2304static void snd_via82xx_free(struct snd_card *card)
     2305{
     2306        struct via82xx *chip = card->private_data;
    23112307        unsigned int i;
    23122308
    2313         if (chip->irq < 0)
    2314                 goto __end_hw;
    23152309        /* disable interrupts */
    23162310        for (i = 0; i < chip->num_devs; i++)
    23172311                snd_via82xx_channel_reset(chip, &chip->devs[i]);
    2318 
    2319         if (chip->irq >= 0)
    2320                 free_irq(chip->irq, chip);
    2321  __end_hw:
    2322         release_and_free_resource(chip->mpu_res);
    2323         pci_release_regions(chip->pci);
    23242312
    23252313        if (chip->chip_type == TYPE_VIA686) {
    … …  
    23282316                pci_write_config_byte(chip->pci, VIA_PNP_CONTROL, chip->old_legacy_cfg);
    23292317        }
    2330         pci_disable_device(chip->pci);
    2331         kfree(chip);
    2332         return 0;
    2333 }
    2334 
    2335 static int snd_via82xx_dev_free(struct snd_device *device)
    2336 {
    2337         struct via82xx *chip = device->device_data;
    2338         return snd_via82xx_free(chip);
    23392318}
    23402319
    … …  
    23432322                              int chip_type,
    23442323                              int revision,
    2345                               unsigned int ac97_clock,
    2346                               struct via82xx **r_via)
    2347 {
    2348         struct via82xx *chip;
     2324                              unsigned int ac97_clock)
     2325{
     2326        struct via82xx *chip = card->private_data;
    23492327        int err;
    2350         static const struct snd_device_ops ops = {
    2351                 .dev_free =     snd_via82xx_dev_free,
    2352         };
    2353 
    2354         err = pci_enable_device(pci);
     2328
     2329        err = pcim_enable_device(pci);
    23552330        if (err < 0)
    23562331                return err;
    2357 
    2358         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2359         if (!chip) {
    2360                 pci_disable_device(pci);
    2361                 return -ENOMEM;
    2362         }
    23632332
    23642333        chip->chip_type = chip_type;
    … …  
    23782347
    23792348        err = pci_request_regions(pci, card->driver);
    2380         if (err < 0) {
    2381                 kfree(chip);
    2382                 pci_disable_device(pci);
     2349        if (err < 0)
    23832350                return err;
    2384         }
    23852351        chip->port = pci_resource_start(pci, 0);
    2386         if (request_irq(pci->irq,
    2387                         chip_type == TYPE_VIA8233 ?
    2388                         snd_via8233_interrupt : snd_via686_interrupt,
    2389                         IRQF_SHARED,
    2390                         KBUILD_MODNAME, chip)) {
     2352        if (devm_request_irq(&pci->dev, pci->irq,
     2353                             chip_type == TYPE_VIA8233 ?
     2354                             snd_via8233_interrupt : snd_via686_interrupt,
     2355                             IRQF_SHARED,
     2356                             KBUILD_MODNAME, chip)) {
    23912357                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    2392                 snd_via82xx_free(chip);
    23932358                return -EBUSY;
    23942359        }
    23952360        chip->irq = pci->irq;
    23962361        card->sync_irq = chip->irq;
     2362        card->private_free = snd_via82xx_free;
    23972363        if (ac97_clock >= 8000 && ac97_clock <= 48000)
    23982364                chip->ac97_clock = ac97_clock;
    23992365
    24002366        err = snd_via82xx_chip_init(chip);
    2401         if (err < 0) {
    2402                 snd_via82xx_free(chip);
     2367        if (err < 0)
    24032368                return err;
    2404         }
    2405 
    2406         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2407         if (err < 0) {
    2408                 snd_via82xx_free(chip);
    2409                 return err;
    2410         }
    24112369
    24122370        /* The 8233 ac97 controller does not implement the master bit
    … …  
    24142372         * We call pci_set_master here because it does not hurt. */
    24152373        pci_set_master(pci);
    2416 
    2417         *r_via = chip;
    24182374        return 0;
    24192375}
    … …  
    25072463};
    25082464
    2509 static int snd_via82xx_probe(struct pci_dev *pci,
    2510                              const struct pci_device_id *pci_id)
     2465static int __snd_via82xx_probe(struct pci_dev *pci,
     2466                               const struct pci_device_id *pci_id)
    25112467{
    25122468        struct snd_card *card;
    … …  
    25162472        int err;
    25172473
    2518         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     2474        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     2475                                sizeof(*chip), &card);
    25192476        if (err < 0)
    25202477                return err;
     2478        chip = card->private_data;
    25212479
    25222480        card_type = pci_id->driver_data;
    … …  
    25572515        default:
    25582516                dev_err(card->dev, "invalid card type %d\n", card_type);
    2559                 err = -EINVAL;
    2560                 goto __error;
     2517                return -EINVAL;
    25612518        }
    25622519               
    25632520        err = snd_via82xx_create(card, pci, chip_type, pci->revision,
    2564                                  ac97_clock, &chip);
     2521                                 ac97_clock);
    25652522        if (err < 0)
    2566                 goto __error;
    2567         card->private_data = chip;
     2523                return err;
    25682524        err = snd_via82xx_mixer_new(chip, ac97_quirk);
    25692525        if (err < 0)
    2570                 goto __error;
     2526                return err;
    25712527
    25722528        if (chip_type == TYPE_VIA686) {
    25732529                err = snd_via686_pcm_new(chip);
    25742530                if (err < 0)
    2575                         goto __error;
     2531                        return err;
    25762532                err = snd_via686_init_misc(chip);
    25772533                if (err < 0)
    2578                         goto __error;
     2534                        return err;
    25792535        } else {
    25802536                if (chip_type == TYPE_VIA8233A) {
    25812537                        err = snd_via8233a_pcm_new(chip);
    25822538                        if (err < 0)
    2583                                 goto __error;
     2539                                return err;
    25842540                        // chip->dxs_fixed = 1; /* FIXME: use 48k for DXS #3? */
    25852541                } else {
    25862542                        err = snd_via8233_pcm_new(chip);
    25872543                        if (err < 0)
    2588                                 goto __error;
     2544                                return err;
    25892545                        if (dxs_support == VIA_DXS_48K)
    25902546                                chip->dxs_fixed = 1;
    … …  
    25982554                err = snd_via8233_init_misc(chip);
    25992555                if (err < 0)
    2600                         goto __error;
     2556                        return err;
    26012557        }
    26022558
    … …  
    26122568
    26132569        err = snd_card_register(card);
    2614         if (err < 0) {
    2615                 snd_card_free(card);
     2570        if (err < 0)
    26162571                return err;
    2617         }
    26182572        pci_set_drvdata(pci, card);
    26192573        return 0;
    2620 
    2621  __error:
    2622         snd_card_free(card);
    2623         return err;
    2624 }
    2625 
    2626 static void snd_via82xx_remove(struct pci_dev *pci)
    2627 {
    2628         snd_card_free(pci_get_drvdata(pci));
     2574}
     2575
     2576static int snd_via82xx_probe(struct pci_dev *pci,
     2577                             const struct pci_device_id *pci_id)
     2578{
     2579        return snd_card_free_on_error(&pci->dev, __snd_via82xx_probe(pci, pci_id));
    26292580}
    26302581
    … …  
    26332584        .id_table = snd_via82xx_ids,
    26342585        .probe = snd_via82xx_probe,
    2635         .remove = snd_via82xx_remove,
    26362586        .driver = {
    26372587                .pm = SND_VIA82XX_PM_OPS,

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci.c

    r703 r717  
    110110
    111111        if (!r) {
    112                 r = request_region(io_port, 1, "YMFPCI gameport");
     112                r = devm_request_region(&chip->pci->dev, io_port, 1,
     113                                        "YMFPCI gameport");
    113114                if (!r) {
    114115                        dev_err(chip->card->dev,
    … …  
    122123                dev_err(chip->card->dev,
    123124                        "cannot allocate memory for gameport\n");
    124                 release_and_free_resource(r);
    125125                return -ENOMEM;
    126126        }
    … …  
    131131        gameport_set_dev_parent(gp, &chip->pci->dev);
    132132        gp->io = io_port;
    133         gameport_set_port_data(gp, r);
    134133
    135134        if (chip->pci->device >= 0x0010) /* YMF 744/754 */
    … …  
    147146{
    148147        if (chip->gameport) {
    149                 struct resource *r = gameport_get_port_data(chip->gameport);
    150 
    151148                gameport_unregister_port(chip->gameport);
    152149                chip->gameport = NULL;
    153 
    154                 release_and_free_resource(r);
    155150        }
    156151}
    … …  
    181176
    182177        err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    183                            0, &card);
    184         if (err < 0)
    185                 return err;
     178                           sizeof(*chip), &card);
     179        if (err < 0)
     180                return err;
     181        chip = card->private_data;
    186182
    187183        switch (pci_id->device) {
    … …  
    204200                }
    205201                if (fm_port[dev] > 0)
    206                         fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3");
     202                        fm_res = devm_request_region(&pci->dev, fm_port[dev],
     203                                                     4, "YMFPCI OPL3");
    207204                if (fm_res) {
    208205                        legacy_ctrl |= YMFPCI_LEGACY_FMEN;
    … …  
    214211                }
    215212                if (mpu_port[dev] > 0)
    216                         mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401");
     213                        mpu_res = devm_request_region(&pci->dev, mpu_port[dev],
     214                                                      2, "YMFPCI MPU401");
    217215                if (mpu_res) {
    218216                        legacy_ctrl |= YMFPCI_LEGACY_MEN;
    … …  
    228226                }
    229227                if (fm_port[dev] > 0)
    230                         fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3");
     228                        fm_res = devm_request_region(&pci->dev, fm_port[dev],
     229                                                     4, "YMFPCI OPL3");
    231230                if (fm_res) {
    232231                        legacy_ctrl |= YMFPCI_LEGACY_FMEN;
    … …  
    243242                }
    244243                if (mpu_port[dev] > 0)
    245                         mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401");
     244                        mpu_res = devm_request_region(&pci->dev, mpu_port[dev],
     245                                                      2, "YMFPCI MPU401");
    246246                if (mpu_res) {
    247247                        legacy_ctrl |= YMFPCI_LEGACY_MEN;
    … …  
    258258        pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
    259259        pci_write_config_word(pci, PCIR_DSXG_ELEGACY, legacy_ctrl2);
    260         err = snd_ymfpci_create(card, pci, old_legacy_ctrl, &chip);
    261         if (err  < 0) {
    262                 release_and_free_resource(mpu_res);
    263                 release_and_free_resource(fm_res);
    264                 goto free_card;
    265         }
    266         chip->fm_res = fm_res;
    267         chip->mpu_res = mpu_res;
    268         card->private_data = chip;
     260        err = snd_ymfpci_create(card, pci, old_legacy_ctrl);
     261        if (err  < 0)
     262                return err;
    269263
    270264        strcpy(card->driver, str);
    … …  
    276270        err = snd_ymfpci_pcm(chip, 0);
    277271        if (err < 0)
    278                 goto free_card;
     272                return err;
    279273
    280274        err = snd_ymfpci_pcm_spdif(chip, 1);
    281275        if (err < 0)
    282                 goto free_card;
     276                return err;
    283277
    284278        err = snd_ymfpci_mixer(chip, rear_switch[dev]);
    285279        if (err < 0)
    286                 goto free_card;
     280                return err;
    287281
    288282        if (chip->ac97->ext_id & AC97_EI_SDAC) {
    289283                err = snd_ymfpci_pcm_4ch(chip, 2);
    290284                if (err < 0)
    291                         goto free_card;
     285                        return err;
    292286
    293287                err = snd_ymfpci_pcm2(chip, 3);
    294288                if (err < 0)
    295                         goto free_card;
     289                        return err;
    296290        }
    297291        err = snd_ymfpci_timer(chip, 0);
    298292        if (err < 0)
    299                 goto free_card;
    300 
    301         if (chip->mpu_res) {
     293                return err;
     294
     295        if (mpu_res) {
    302296                err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI,
    303297                                          mpu_port[dev],
    … …  
    313307                }
    314308        }
    315         if (chip->fm_res) {
     309        if (fm_res) {
    316310                err = snd_opl3_create(card,
    317311                                      fm_port[dev],
    … …  
    328322                        if (err < 0) {
    329323                                dev_err(card->dev, "cannot create opl3 hwdep\n");
    330                                 goto free_card;
     324                                return err;
    331325                        }
    332326                }
    … …  
    337331        err = snd_card_register(card);
    338332        if (err < 0)
    339                 goto free_card;
     333                return err;
    340334
    341335        pci_set_drvdata(pci, card);
    342336        dev++;
    343337        return 0;
    344 
    345 free_card:
    346         snd_card_free(card);
    347         return err;
    348 }
    349 
    350 static void snd_card_ymfpci_remove(struct pci_dev *pci)
    351 {
    352         snd_card_free(pci_get_drvdata(pci));
    353338}
    354339
    … …  
    357342        .id_table = snd_ymfpci_ids,
    358343        .probe = snd_card_ymfpci_probe,
    359         .remove = snd_card_ymfpci_remove,
    360344#ifdef CONFIG_PM_SLEEP
    361345        .driver = {

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci.h

    r679 r717  
    276276        unsigned long reg_area_phys;
    277277        void __iomem *reg_area_virt;
    278         struct resource *res_reg_area;
    279         struct resource *fm_res;
    280         struct resource *mpu_res;
    281278
    282279        unsigned short old_legacy_ctrl;
    … …  
    285282#endif
    286283
    287         struct snd_dma_buffer work_ptr;
     284        struct snd_dma_buffer *work_ptr;
    288285
    289286        unsigned int bank_size_playback;
    … …  
    359356int snd_ymfpci_create(struct snd_card *card,
    360357                      struct pci_dev *pci,
    361                       unsigned short old_legacy_ctrl,
    362                       struct snd_ymfpci ** rcodec);
     358                      unsigned short old_legacy_ctrl);
    363359void snd_ymfpci_free_gameport(struct snd_ymfpci *chip);
    364360

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci_main.c

    r703 r717  
    21212121        /* work_ptr must be aligned to 256 bytes, but it's already
    21222122           covered with the kernel page allocation mechanism */
    2123         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
    2124                                 size, &chip->work_ptr) < 0)
     2123        chip->work_ptr = snd_devm_alloc_pages(&chip->pci->dev,
     2124                                              SNDRV_DMA_TYPE_DEV, size);
     2125        if (!chip->work_ptr)
    21252126                return -ENOMEM;
    2126         ptr = chip->work_ptr.area;
    2127         ptr_addr = chip->work_ptr.addr;
     2127        ptr = chip->work_ptr->area;
     2128        ptr_addr = chip->work_ptr->addr;
    21282129        memset(ptr, 0, size);   /* for sure */
    21292130
    … …  
    21702171       
    21712172        snd_BUG_ON(ptr + chip->work_size !=
    2172                    chip->work_ptr.area + chip->work_ptr.bytes);
     2173                   chip->work_ptr->area + chip->work_ptr->bytes);
    21732174
    21742175        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, chip->bank_base_playback_addr);
    … …  
    22012202}
    22022203
    2203 static int snd_ymfpci_free(struct snd_ymfpci *chip)
    2204 {
     2204static void snd_ymfpci_free(struct snd_card *card)
     2205{
     2206        struct snd_ymfpci *chip = card->private_data;
    22052207        u16 ctrl;
    22062208
    2207         if (snd_BUG_ON(!chip))
    2208                 return -EINVAL;
    2209 
    2210         if (chip->res_reg_area) {       /* don't touch busy hardware */
    2211                 snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
    2212                 snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
    2213                 snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0);
    2214                 snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0);
    2215                 snd_ymfpci_disable_dsp(chip);
    2216                 snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0);
    2217                 snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0);
    2218                 snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0);
    2219                 snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0);
    2220                 snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0);
    2221                 ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
    2222                 snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
    2223         }
     2209        snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
     2210        snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
     2211        snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0);
     2212        snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0);
     2213        snd_ymfpci_disable_dsp(chip);
     2214        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0);
     2215        snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0);
     2216        snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0);
     2217        snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0);
     2218        snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0);
     2219        ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
     2220        snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
    22242221
    22252222        snd_ymfpci_ac3_done(chip);
    22262223
    2227         /* Set PCI device to D3 state */
    2228 #if 0
    2229         /* FIXME: temporarily disabled, otherwise we cannot fire up
    2230          * the chip again unless reboot.  ACPI bug?
    2231          */
    2232         pci_set_power_state(chip->pci, PCI_D3hot);
    2233 #endif
    2234 
    2235 #ifdef CONFIG_PM_SLEEP
    2236         kfree(chip->saved_regs);
    2237 #endif
    2238         if (chip->irq >= 0)
    2239                 free_irq(chip->irq, chip);
    2240         release_and_free_resource(chip->mpu_res);
    2241         release_and_free_resource(chip->fm_res);
    22422224        snd_ymfpci_free_gameport(chip);
    2243         iounmap(chip->reg_area_virt);
    2244         if (chip->work_ptr.area)
    2245                 snd_dma_free_pages(&chip->work_ptr);
    2246        
    2247         release_and_free_resource(chip->res_reg_area);
    2248 
     2225       
    22492226        pci_write_config_word(chip->pci, 0x40, chip->old_legacy_ctrl);
    22502227       
    2251         pci_disable_device(chip->pci);
    22522228        release_firmware(chip->dsp_microcode);
    22532229        release_firmware(chip->controller_microcode);
    2254         kfree(chip);
    2255         return 0;
    2256 }
    2257 
    2258 static int snd_ymfpci_dev_free(struct snd_device *device)
    2259 {
    2260         struct snd_ymfpci *chip = device->device_data;
    2261         return snd_ymfpci_free(chip);
    22622230}
    22632231
    … …  
    23512319int snd_ymfpci_create(struct snd_card *card,
    23522320                      struct pci_dev *pci,
    2353                       unsigned short old_legacy_ctrl,
    2354                       struct snd_ymfpci **rchip)
    2355 {
    2356         struct snd_ymfpci *chip;
     2321                      unsigned short old_legacy_ctrl)
     2322{
     2323        struct snd_ymfpci *chip = card->private_data;
    23572324        int err;
    2358         static const struct snd_device_ops ops = {
    2359                 .dev_free =     snd_ymfpci_dev_free,
    2360         };
    2361        
    2362         *rchip = NULL;
    2363 
     2325       
    23642326        /* enable PCI device */
    2365         err = pci_enable_device(pci);
     2327        err = pcim_enable_device(pci);
    23662328        if (err < 0)
    23672329                return err;
    23682330
    2369         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2370         if (chip == NULL) {
    2371                 pci_disable_device(pci);
    2372                 return -ENOMEM;
    2373         }
    23742331        chip->old_legacy_ctrl = old_legacy_ctrl;
    23752332        spin_lock_init(&chip->reg_lock);
    … …  
    23822339        chip->device_id = pci->device;
    23832340        chip->rev = pci->revision;
     2341
     2342        err = pci_request_regions(pci, "YMFPCI");
     2343        if (err < 0)
     2344                return err;
     2345
    23842346        chip->reg_area_phys = pci_resource_start(pci, 0);
    2385         chip->reg_area_virt = ioremap(chip->reg_area_phys, 0x8000);
    2386         pci_set_master(pci);
    2387         chip->src441_used = -1;
    2388 
    2389         chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI");
    2390         if (!chip->res_reg_area) {
     2347        chip->reg_area_virt = devm_ioremap(&pci->dev, chip->reg_area_phys, 0x8000);
     2348        if (!chip->reg_area_virt) {
    23912349                dev_err(chip->card->dev,
    23922350                        "unable to grab memory region 0x%lx-0x%lx\n",
    23932351                        chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
    2394                 err = -EBUSY;
    2395                 goto free_chip;
    2396         }
    2397         if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
     2352                return -EBUSY;
     2353        }
     2354        pci_set_master(pci);
     2355        chip->src441_used = -1;
     2356
     2357        if (devm_request_irq(&pci->dev, pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
    23982358                        KBUILD_MODNAME, chip)) {
    23992359                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
    2400                 err = -EBUSY;
    2401                 goto free_chip;
     2360                return -EBUSY;
    24022361        }
    24032362        chip->irq = pci->irq;
    24042363        card->sync_irq = chip->irq;
     2364        card->private_free = snd_ymfpci_free;
    24052365
    24062366        snd_ymfpci_aclink_reset(pci);
    2407         if (snd_ymfpci_codec_ready(chip, 0) < 0) {
    2408                 err = -EIO;
    2409                 goto free_chip;
    2410         }
     2367        if (snd_ymfpci_codec_ready(chip, 0) < 0)
     2368                return -EIO;
    24112369
    24122370        err = snd_ymfpci_request_firmware(chip);
    24132371        if (err < 0) {
    24142372                dev_err(chip->card->dev, "firmware request failed: %d\n", err);
    2415                 goto free_chip;
     2373                return err;
    24162374        }
    24172375        snd_ymfpci_download_image(chip);
    … …  
    24192377        udelay(100); /* seems we need a delay after downloading image.. */
    24202378
    2421         if (snd_ymfpci_memalloc(chip) < 0) {
    2422                 err = -EIO;
    2423                 goto free_chip;
    2424         }
     2379        if (snd_ymfpci_memalloc(chip) < 0)
     2380                return -EIO;
    24252381
    24262382        err = snd_ymfpci_ac3_init(chip);
    24272383        if (err < 0)
    2428                 goto free_chip;
     2384                return err;
    24292385
    24302386#ifdef CONFIG_PM_SLEEP
    2431         chip->saved_regs = kmalloc_array(YDSXGR_NUM_SAVED_REGS, sizeof(u32),
    2432                                          GFP_KERNEL);
    2433         if (chip->saved_regs == NULL) {
    2434                 err = -ENOMEM;
    2435                 goto free_chip;
    2436         }
     2387        chip->saved_regs = devm_kmalloc_array(&pci->dev, YDSXGR_NUM_SAVED_REGS,
     2388                                              sizeof(u32), GFP_KERNEL);
     2389        if (!chip->saved_regs)
     2390                return -ENOMEM;
    24372391#endif
    24382392
    2439         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2440         if (err < 0)
    2441                 goto free_chip;
    2442 
    24432393        snd_ymfpci_proc_init(card, chip);
    24442394
    2445         *rchip = chip;
    2446         return 0;
    2447 
    2448 free_chip:
    2449         snd_ymfpci_free(chip);
    2450         return err;
    2451 }
     2395        return 0;
     2396}

  • GPL/trunk/alsa-kernel/synth/emux/emux.c

    r703 r717  
    9595        emu->voices = kcalloc(emu->max_voices, sizeof(struct snd_emux_voice),
    9696                              GFP_KERNEL);
    97         if (emu->voices == NULL)
     97        if (emu->name == NULL || emu->voices == NULL)
    9898                return -ENOMEM;
    9999

  • GPL/trunk/include/linux/device.h

    r679 r717  
    290290/* debugging and troubleshooting/diagnostic helpers. */
    291291extern const char *dev_driver_string(const struct device *dev);
    292 
     292#define devm_kzalloc(A, B, C) kzalloc(B, C)
     293#define devm_kmalloc(A, B, C) kmalloc(B, C)
     294#define devm_kcalloc(A, B, C, D) kmalloc(B, C)
     295#define devm_kmalloc_array(A, B, C, D) kmalloc_array(B, C, D)
     296
     297
     298/* allows to add/remove a custom action to devres stack */
     299int devm_add_action(struct device *dev, void (*action)(void *), void *data);
     300void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
    293301#endif /* _LINUX_DEVICE_H */
    294302

  • GPL/trunk/include/linux/interrupt.h

    r679 r717  
    154154
    155155static inline void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id) {}
     156#define devm_request_irq(A, B, C, D, E, F) request_irq(B, C, D, E, F)
     157
    156158#endif

  • GPL/trunk/include/linux/io.h

    r679 r717  
    77#include <linux/err.h>
    88
     9#define devm_ioremap(A, B, C) ioremap(B, C)
    910#endif /* _LINUX_IO_H */

  • GPL/trunk/include/linux/ioport.h

    r679 r717  
    111111extern int autoirq_report(int waittime);
    112112
     113#define devm_request_region(A, B, C, D) request_region(B, C, D)
    113114#endif  /* _LINUX_IOPORT_H */

  • GPL/trunk/include/linux/leds.h

    r679 r717  
    2020};
    2121
     22enum led_audio {
     23        LED_AUDIO_MUTE,         /* master mute LED */
     24        LED_AUDIO_MICMUTE,      /* mic mute LED */
     25        NUM_AUDIO_LEDS
     26};
    2227#endif /* _LINUX_LEDS_H */

  • GPL/trunk/include/linux/pci.h

    r709 r717  
    770770
    771771#define dev_is_pci(d) (true)
    772 
     772int pcim_enable_device(struct pci_dev *pdev);
     773#define pcim_iomap pci_iomap
     774int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
    773775#endif /* LINUX_PCI_H */

  • GPL/trunk/include/linux/pm.h

    r689 r717  
    246246        struct device           * pm_parent;
    247247        struct list_head        entry;
     248        enum rpm_status         runtime_status;
    248249};
    249250

  • GPL/trunk/include/linux/string.h

    r679 r717  
    3030#define vmemdup_user memdup_user
    3131#define scnprintf snprintf
     32ssize_t strscpy(char *dest, const char *src, size_t count);
     33
    3234#endif
    3335

  • GPL/trunk/lib32/devres.c

    r679 r717  
    3636};
    3737
     38#define devres_log(dev, node, op)       do {} while (0)
     39
    3840/*
    3941 * Release functions for devres group.  These callbacks are used only
    … …  
    7577
    7678#define devres_log(dev, node, op)       do {} while (0)
     79
     80static void add_dr(struct device *dev, struct devres_node *node)
     81{
     82        devres_log(dev, node, "ADD");
     83        BUG_ON(!list_empty(&node->entry));
     84//#ifndef TARGET_OS2
     85        /* Traps here on OS/2 */
     86        list_add_tail(&node->entry, &dev->devres_head);
     87//#endif
     88}
     89
     90/**
     91 * devres_add - Register device resource
     92 * @dev: Device to add resource to
     93 * @res: Resource to register
     94 *
     95 * Register devres @res to @dev.  @res should have been allocated
     96 * using devres_alloc().  On driver detach, the associated release
     97 * function will be invoked and devres will be freed automatically.
     98 */
     99void devres_add(struct device *dev, void *res)
     100{
     101        /* Traps here on OS/2 */
     102        struct devres *dr = container_of(res, struct devres, data);
     103        unsigned long flags;
     104        spin_lock_irqsave(&dev->devres_lock, flags);
     105        add_dr(dev, &dr->node);
     106        spin_unlock_irqrestore(&dev->devres_lock, flags);
     107}
    77108
    78109/**
    … …  
    273304        return NULL;
    274305}
     306
     307/**
     308 * devm_add_action() - add a custom action to list of managed resources
     309 * @dev: Device that owns the action
     310 * @action: Function that should be called
     311 * @data: Pointer to data passed to @action implementation
     312 *
     313 * This adds a custom action to the list of managed resources so that
     314 * it gets executed as part of standard resource unwinding.
     315 */
     316int devm_add_action(struct device *dev, void (*action)(void *), void *data)
     317{
     318        return 0;
     319}
     320
     321/**
     322 * devm_remove_action() - removes previously added custom action
     323 * @dev: Device that owns the action
     324 * @action: Function implementing the action
     325 * @data: Pointer to data passed to @action implementation
     326 *
     327 * Removes instance of @action previously added by devm_add_action().
     328 * Both action and data should match one of the existing entries.
     329 */
     330void devm_remove_action(struct device *dev, void (*action)(void *), void *data)
     331{
     332}

  • GPL/trunk/lib32/driver.c

    r679 r717  
    2626#include "base.h"
    2727
    28 #define devres_log(dev, node, op)       do {} while (0)
    29 
    30 struct devres_node {
    31         struct list_head                entry;
    32         dr_release_t                    release;
    33 #ifdef CONFIG_DEBUG_DEVRES
    34         const char                      *name;
    35         size_t                          size;
    36 #endif
    37 };
    38 
    39 struct devres {
    40         struct devres_node              node;
    41         /* -- 3 pointers */
    42         unsigned long long              data[1];        /* guarantee ull alignment */
    43 };
    44 
    45 
    4628/**
    4729 * dev_set_name - set a device name
    … …  
    6042}
    6143
    62 static void add_dr(struct device *dev, struct devres_node *node)
    63 {
    64         devres_log(dev, node, "ADD");
    65         BUG_ON(!list_empty(&node->entry));
    66         list_add_tail(&node->entry, &dev->devres_head);
    67 }
    68 
    69 /**
    70  * devres_add - Register device resource
    71  * @dev: Device to add resource to
    72  * @res: Resource to register
    73  *
    74  * Register devres @res to @dev.  @res should have been allocated
    75  * using devres_alloc().  On driver detach, the associated release
    76  * function will be invoked and devres will be freed automatically.
    77  */
    78 void devres_add(struct device *dev, void *res)
    79 {
    80         struct devres *dr = container_of(res, struct devres, data);
    81         unsigned long flags;
    82 
    83         spin_lock_irqsave(&dev->devres_lock, flags);
    84         add_dr(dev, &dr->node);
    85         spin_unlock_irqrestore(&dev->devres_lock, flags);
    86 }
     44
    8745
    8846static struct device *next_device(struct klist_iter *i)

  • GPL/trunk/lib32/pci.c

    r679 r717  
    455455
    456456/**
     457 * pcim_enable_device - Managed pci_enable_device()
     458 * @pdev: PCI device to be initialized
     459 *
     460 * Managed pci_enable_device().
     461 */
     462int pcim_enable_device(struct pci_dev *pdev)
     463{
     464        int rc;
     465
     466        rc = pci_enable_device(pdev);
     467        return rc;
     468}
     469
     470/**
    457471 *  Initialize device before it's used by a driver. Ask low-level code
    458472 *  to enable I/O and memory. Wake up the device if it was suspended.
Note: See TracChangeset for help on using the changeset viewer.