Changeset 736


Ignore:
Timestamp:
Sep 18, 2022, 2:46:55 AM (3 years ago)
Author:
Paul Smedley
Message:

Update ALSA code to 5.16.20

Location:
GPL/branches/uniaud32-exp
Files:
2 added
59 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud32-exp/alsa-kernel/core/control.c

    r732 r736  
    130130                                control->vd[idx].owner = NULL;
    131131        up_write(&card->controls_rwsem);
    132         snd_fasync_free(ctl->fasync);
    133132        snd_ctl_empty_read_queue(ctl);
    134133        put_pid(ctl->pid);
    … …  
    185184                wake_up(&ctl->change_sleep);
    186185                spin_unlock(&ctl->read_lock);
    187                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_IN);
     186                kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
    188187        }
    189188        read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
    … …  
    20162015
    20172016        ctl = file->private_data;
    2018         return snd_fasync_helper(fd, file, on, &ctl->fasync);
     2017        return fasync_helper(fd, file, on, &ctl->fasync);
    20192018}
    20202019
    … …  
    21842183        list_for_each_entry(ctl, &card->ctl_files, list, struct snd_ctl_file) {
    21852184                wake_up(&ctl->change_sleep);
    2186                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_ERR);
     2185                kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
    21872186        }
    21882187        read_unlock_irqrestore(&card->ctl_files_rwlock, flags);

  • GPL/branches/uniaud32-exp/alsa-kernel/core/info.c

    r725 r736  
    113113        mutex_lock(&entry->access);
    114114        if (entry->c.ops->llseek) {
    115                 ret = entry->c.ops->llseek(entry,
    116                                            data->file_private_data,
    117                                            file, offset, orig);
     115                offset = entry->c.ops->llseek(entry,
     116                                              data->file_private_data,
     117                                              file, offset, orig);
    118118                goto out;
    119119        }

  • GPL/branches/uniaud32-exp/alsa-kernel/core/init.c

    r732 r736  
    214214 * is added automatically.  In that way, the resource disconnection is assured
    215215 * 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.
    222216 */
    223217int snd_devm_card_new(struct device *parent, int idx, const char *xid,
    … …  
    245239}
    246240EXPORT_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  */
    257 int 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 }
    268 EXPORT_SYMBOL_GPL(snd_card_free_on_error);
    269241
    270242static int snd_card_init(struct snd_card *card, struct device *parent,

  • GPL/branches/uniaud32-exp/alsa-kernel/core/jack.c

    r711 r736  
    4343        struct snd_jack *jack = device->device_data;
    4444
    45         mutex_lock(&jack->input_dev_lock);
    46         if (!jack->input_dev) {
    47                 mutex_unlock(&jack->input_dev_lock);
     45        if (!jack->input_dev)
    4846                return 0;
    49         }
    5047
    5148        /* If the input device is registered with the input subsystem
    … …  
    5653                input_free_device(jack->input_dev);
    5754        jack->input_dev = NULL;
    58         mutex_unlock(&jack->input_dev_lock);
    5955#endif /* CONFIG_SND_JACK_INPUT_DEV */
    6056        return 0;
    … …  
    9591                 card->shortname, jack->id);
    9692
    97         mutex_lock(&jack->input_dev_lock);
    98         if (!jack->input_dev) {
    99                 mutex_unlock(&jack->input_dev_lock);
     93        if (!jack->input_dev)
    10094                return 0;
    101         }
    10295
    10396        jack->input_dev->name = jack->name;
    … …  
    124117                jack->registered = 1;
    125118
    126         mutex_unlock(&jack->input_dev_lock);
    127119        return err;
    128120}
    … …  
    526518        }
    527519
    528 #ifdef CONFIG_SND_JACK_INPUT_DEV
    529         mutex_init(&jack->input_dev_lock);
    530 
    531         /* don't create input device for phantom jack */
     520        /* don't creat input device for phantom jack */
    532521        if (!phantom_jack) {
     522#ifdef CONFIG_SND_JACK_INPUT_DEV
    533523                int i;
    534524
    … …  
    548538                                                     jack_switch_types[i]);
    549539
    550         }
    551 #endif /* CONFIG_SND_JACK_INPUT_DEV */
     540#endif /* CONFIG_SND_JACK_INPUT_DEV */
     541        }
    552542
    553543        err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
    … …  
    589579{
    590580        WARN_ON(jack->registered);
    591         mutex_lock(&jack->input_dev_lock);
    592         if (!jack->input_dev) {
    593                 mutex_unlock(&jack->input_dev_lock);
     581        if (!jack->input_dev)
    594582                return;
    595         }
    596583
    597584        jack->input_dev->dev.parent = parent;
    598         mutex_unlock(&jack->input_dev_lock);
    599585}
    600586EXPORT_SYMBOL(snd_jack_set_parent);
    … …  
    644630/**
    645631 * 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).
    648632 *
    649633 * @jack:   The jack to report status for
    … …  
    671655
    672656#ifdef CONFIG_SND_JACK_INPUT_DEV
    673         mutex_lock(&jack->input_dev_lock);
    674         if (!jack->input_dev) {
    675                 mutex_unlock(&jack->input_dev_lock);
     657        if (!jack->input_dev)
    676658                return;
    677         }
    678659
    679660        for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
    … …  
    695676
    696677        input_sync(jack->input_dev);
    697         mutex_unlock(&jack->input_dev_lock);
    698678#endif /* CONFIG_SND_JACK_INPUT_DEV */
    699679}

  • GPL/branches/uniaud32-exp/alsa-kernel/core/memalloc.c

    r722 r736  
    1414#include <linux/dma-mapping.h>
    1515#include <linux/genalloc.h>
     16#include <linux/highmem.h>
    1617#include <linux/vmalloc.h>
    1718#ifdef CONFIG_X86
    … …  
    2021#include <sound/memalloc.h>
    2122#include "memalloc_local.h"
     23
     24static const struct snd_malloc_ops *snd_dma_get_ops(struct snd_dma_buffer *dmab);
    2225
    2326/*
    … …  
    148151
    149152/**
    150  * snd_dma_alloc_pages - allocate the buffer area according to the given type
     153 * snd_dma_alloc_dir_pages - allocate the buffer area according to the given
     154 *      type and direction
    151155 * @type: the DMA buffer type
    152156 * @device: the device pointer
     157 * @dir: DMA direction
    153158 * @size: the buffer size to allocate
    154159 * @dmab: buffer allocation record to store the allocated data
    … …  
    160165 * otherwise a negative value on error.
    161166 */
    162 int snd_dma_alloc_pages(int type, struct device *device, size_t size,
    163                         struct snd_dma_buffer *dmab)
     167int snd_dma_alloc_dir_pages(int type, struct device *device,
     168                            enum dma_data_direction dir, size_t size,
     169                            struct snd_dma_buffer *dmab)
    164170{
    165171        gfp_t gfp;
    … …  
    173179        dmab->dev.type = type;
    174180        dmab->dev.dev = device;
     181        dmab->dev.dir = dir;
    175182        dmab->bytes = 0;
    176183        dmab->area = NULL;
    … …  
    224231        return 0;
    225232}
    226 EXPORT_SYMBOL(snd_dma_alloc_pages);
     233EXPORT_SYMBOL(snd_dma_alloc_dir_pages);
    227234
    228235/**
    … …  
    342349
    343350/**
    344  * snd_devm_alloc_pages - allocate the buffer and manage with devres
     351 * snd_devm_alloc_dir_pages - allocate the buffer and manage with devres
    345352 * @dev: the device pointer
    346353 * @type: the DMA buffer type
     354 * @dir: DMA direction
    347355 * @size: the buffer size to allocate
    348356 *
    … …  
    357365 */
    358366struct snd_dma_buffer *
    359 snd_devm_alloc_pages(struct device *dev, int type, size_t size)
     367snd_devm_alloc_dir_pages(struct device *dev, int type,
     368                         enum dma_data_direction dir, size_t size)
    360369{
    361370        struct snd_dma_buffer *dmab;
    … …  
    370379                return NULL;
    371380
    372         err = snd_dma_alloc_pages(type, dev, size, dmab);
     381        err = snd_dma_alloc_dir_pages(type, dev, dir, size, dmab);
    373382        if (err < 0) {
    374383                devres_free(dmab);
    … …  
    379388        return dmab;
    380389}
    381 EXPORT_SYMBOL_GPL(snd_devm_alloc_pages);
     390EXPORT_SYMBOL_GPL(snd_devm_alloc_dir_pages);
     391

  • GPL/branches/uniaud32-exp/alsa-kernel/core/memalloc_local.h

    r710 r736  
    1111                                       unsigned int ofs, unsigned int size);
    1212        int (*mmap)(struct snd_dma_buffer *dmab, struct vm_area_struct *area);
     13        void (*sync)(struct snd_dma_buffer *dmab, enum snd_dma_sync_mode mode);
    1314};
    1415

  • GPL/branches/uniaud32-exp/alsa-kernel/core/misc.c

    r725 r736  
    1111#include <linux/slab.h>
    1212#include <linux/ioport.h>
    13 #include <linux/fs.h>
    1413#include <sound/core.h>
    1514
    … …  
    147146EXPORT_SYMBOL(snd_pci_quirk_lookup);
    148147#endif
    149 
    150 /*
    151  * Deferred async signal helpers
    152  *
    153  * Below are a few helper functions to wrap the async signal handling
    154  * in the deferred work.  The main purpose is to avoid the messy deadlock
    155  * around tasklist_lock and co at the kill_fasync() invocation.
    156  * fasync_helper() and kill_fasync() are replaced with snd_fasync_helper()
    157  * and snd_kill_fasync(), respectively.  In addition, snd_fasync_free() has
    158  * to be called at releasing the relevant file object.
    159  */
    160 struct snd_fasync {
    161         struct fasync_struct *fasync;
    162         int signal;
    163         int poll;
    164         int on;
    165         struct list_head list;
    166 };
    167 
    168 static DEFINE_SPINLOCK(snd_fasync_lock);
    169 static LIST_HEAD(snd_fasync_list);
    170 
    171 static void snd_fasync_work_fn(struct work_struct *work)
    172 {
    173         struct snd_fasync *fasync;
    174 
    175         spin_lock_irq(&snd_fasync_lock);
    176         while (!list_empty(&snd_fasync_list)) {
    177                 fasync = list_first_entry(&snd_fasync_list, struct snd_fasync, list);
    178                 list_del_init(&fasync->list);
    179                 spin_unlock_irq(&snd_fasync_lock);
    180                 if (fasync->on)
    181                         kill_fasync(&fasync->fasync, fasync->signal, fasync->poll);
    182                 spin_lock_irq(&snd_fasync_lock);
    183         }
    184         spin_unlock_irq(&snd_fasync_lock);
    185 }
    186 
    187 static DECLARE_WORK(snd_fasync_work, snd_fasync_work_fn);
    188 
    189 int snd_fasync_helper(int fd, struct file *file, int on,
    190                       struct snd_fasync **fasyncp)
    191 {
    192         struct snd_fasync *fasync = NULL;
    193 
    194         if (on) {
    195                 fasync = kzalloc(sizeof(*fasync), GFP_KERNEL);
    196                 if (!fasync)
    197                         return -ENOMEM;
    198                 INIT_LIST_HEAD(&fasync->list);
    199         }
    200 
    201         spin_lock_irq(&snd_fasync_lock);
    202         if (*fasyncp) {
    203                 kfree(fasync);
    204                 fasync = *fasyncp;
    205         } else {
    206                 if (!fasync) {
    207                         spin_unlock_irq(&snd_fasync_lock);
    208                         return 0;
    209                 }
    210                 *fasyncp = fasync;
    211         }
    212         fasync->on = on;
    213         spin_unlock_irq(&snd_fasync_lock);
    214         return fasync_helper(fd, file, on, &fasync->fasync);
    215 }
    216 EXPORT_SYMBOL_GPL(snd_fasync_helper);
    217 
    218 void snd_kill_fasync(struct snd_fasync *fasync, int signal, int poll)
    219 {
    220         unsigned long flags;
    221 
    222         if (!fasync || !fasync->on)
    223                 return;
    224         spin_lock_irqsave(&snd_fasync_lock, flags);
    225         fasync->signal = signal;
    226         fasync->poll = poll;
    227         list_move(&fasync->list, &snd_fasync_list);
    228         schedule_work(&snd_fasync_work);
    229         spin_unlock_irqrestore(&snd_fasync_lock, flags);
    230 }
    231 EXPORT_SYMBOL_GPL(snd_kill_fasync);
    232 
    233 void snd_fasync_free(struct snd_fasync *fasync)
    234 {
    235         if (!fasync)
    236                 return;
    237         fasync->on = 0;
    238         flush_work(&snd_fasync_work);
    239         kfree(fasync);
    240 }
    241 EXPORT_SYMBOL_GPL(snd_fasync_free);

  • GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_lib.c

    r711 r736  
    120120                ofs = 0;
    121121        }
     122#ifndef TARGET_OS2
     123        snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     124#endif
    122125}
    123126
    … …  
    23102313#endif
    23112314                snd_pcm_stream_unlock_irq(substream);
     2315#ifndef TARGET_OS2
     2316                if (!is_playback)
     2317                        snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_CPU);
     2318#endif
    23122319                err = writer(substream, appl_ofs, data, offset, frames,
    23132320                             transfer);
     2321#ifndef TARGET_OS2
     2322                if (is_playback)
     2323                        snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     2324#endif
    23142325                snd_pcm_stream_lock_irq(substream);
    23152326#ifndef TARGET_OS2

  • GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_local.h

    r697 r736  
    7474                     (subs) = (subs)->next)
    7575
     76static inline void snd_pcm_dma_buffer_sync(struct snd_pcm_substream *substream,
     77                                           enum snd_dma_sync_mode mode)
     78{
     79        if (substream->runtime->info & SNDRV_PCM_INFO_EXPLICIT_SYNC)
     80                snd_dma_buffer_sync(snd_pcm_get_dma_buf(substream), mode);
     81}
     82
    7683#endif  /* __SOUND_CORE_PCM_LOCAL_H */

  • GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_memory.c

    r733 r736  
    3333
    3434static int do_alloc_pages(struct snd_card *card, int type, struct device *dev,
    35                           size_t size, struct snd_dma_buffer *dmab)
    36 {
     35                          int str, size_t size, struct snd_dma_buffer *dmab)
     36{
     37        enum dma_data_direction dir;
    3738        int err;
    3839
    … …  
    4142                return -ENOMEM;
    4243
    43         err = snd_dma_alloc_pages(type, dev, size, dmab);
     44        if (str == SNDRV_PCM_STREAM_PLAYBACK)
     45                dir = DMA_TO_DEVICE;
     46        else
     47                dir = DMA_FROM_DEVICE;
     48        err = snd_dma_alloc_dir_pages(type, dev, dir, size, dmab);
    4449        if (!err) {
    4550                mutex_lock(&card->memory_mutex);
    … …  
    7883        do {
    7984                err = do_alloc_pages(card, dmab->dev.type, dmab->dev.dev,
    80                                      size, dmab);
     85                                     substream->stream, size, dmab);
    8186                if (err != -ENOMEM)
    8287                        return err;
    … …  
    183188                                           substream->dma_buffer.dev.type,
    184189                                           substream->dma_buffer.dev.dev,
     190                                           substream->stream,
    185191                                           size, &new_dmab) < 0) {
    186192                                buffer->error = -ENOMEM;
    … …  
    430436                                   substream->dma_buffer.dev.type,
    431437                                   substream->dma_buffer.dev.dev,
     438                                   substream->stream,
    432439                                   size, dmab) < 0) {
    433440                        kfree(dmab);
    … …  
    459466int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
    460467{
     468        struct snd_card *card = substream->pcm->card;
    461469        struct snd_pcm_runtime *runtime;
    462470
    … …  
    467475                return 0;
    468476        if (runtime->dma_buffer_p != &substream->dma_buffer) {
    469                 struct snd_card *card = substream->pcm->card;
    470 
    471477                /* it's a newly allocated buffer.  release it now. */
    472478                do_free_pages(card, runtime->dma_buffer_p);

  • GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_misc.c

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

  • GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_native.c

    r713 r736  
    27732773        }
    27742774
     2775        /* automatically set EXPLICIT_SYNC flag in the managed mode whenever
     2776         * the DMA buffer requires it
     2777         */
     2778        if (substream->managed_buffer_alloc &&
     2779            substream->dma_buffer.dev.need_sync)
     2780                substream->runtime->hw.info |= SNDRV_PCM_INFO_EXPLICIT_SYNC;
     2781
    27752782        *rsubstream = substream;
    27762783        return 0;
    … …  
    30003007                                      snd_pcm_hw_avail(substream));
    30013008        snd_pcm_stream_unlock_irq(substream);
     3009#ifndef TARGET_OS2
     3010        if (ret >= 0)
     3011                snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     3012#endif
    30023013        return ret;
    30033014}
    … …  
    30173028                                       snd_pcm_avail(substream));
    30183029        snd_pcm_stream_unlock_irq(substream);
     3030#ifndef TARGET_OS2
     3031        if (ret >= 0)
     3032                snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     3033#endif
    30193034        return ret;
    30203035}
    30213036
    3022 static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
     3037static int snd_pcm_delay(struct snd_pcm_substream *substream,
     3038                         snd_pcm_sframes_t *delay)
    30233039{
    30243040        int err;
    … …  
    30263042        snd_pcm_stream_lock_irq(substream);
    30273043        err = do_pcm_hwsync(substream);
     3044        if (delay && !err)
     3045                *delay = snd_pcm_calc_delay(substream);
    30283046        snd_pcm_stream_unlock_irq(substream);
     3047#ifndef TARGET_OS2
     3048        snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_CPU);
     3049#endif
    30293050        return err;
    30303051}
    30313052               
    3032 static int snd_pcm_delay(struct snd_pcm_substream *substream,
    3033                          snd_pcm_sframes_t *delay)
    3034 {
    3035         int err;
    3036         snd_pcm_sframes_t n = 0;
    3037 
    3038         snd_pcm_stream_lock_irq(substream);
    3039         err = do_pcm_hwsync(substream);
    3040         if (!err)
    3041                 n = snd_pcm_calc_delay(substream);
    3042         snd_pcm_stream_unlock_irq(substream);
    3043         if (!err)
    3044                 *delay = n;
    3045         return err;
    3046 }
    3047                
     3053static inline int snd_pcm_hwsync(struct snd_pcm_substream *substream)
     3054{
     3055        return snd_pcm_delay(substream, NULL);
     3056}
     3057
    30483058static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
    30493059                            struct snd_pcm_sync_ptr __user *_sync_ptr)
    … …  
    30883098        sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
    30893099        snd_pcm_stream_unlock_irq(substream);
     3100#ifndef TARGET_OS2
     3101        if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
     3102                snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     3103#endif
    30903104        if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
    30913105                return -EFAULT;
    … …  
    31923206        sstatus.audio_tstamp = status->audio_tstamp;
    31933207        snd_pcm_stream_unlock_irq(substream);
     3208#ifndef TARGET_OS2
     3209        if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
     3210                snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE);
     3211#endif
    31943212        if (put_user(sstatus.state, &src->s.status.state) ||
    31953213            put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) ||
    … …  
    33133331        if (PCM_RUNTIME_CHECK(substream))
    33143332                return -ENXIO;
     3333
     3334        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
     3335                return -EBADFD;
    33153336
    33163337        res = snd_power_wait(substream->pcm->card);
    … …  
    33683389        case SNDRV_PCM_IOCTL_DELAY:
    33693390        {
    3370                 snd_pcm_sframes_t delay;
     3391                snd_pcm_sframes_t delay = 0;
    33713392                snd_pcm_sframes_t __user *res = arg;
    33723393                int err;
    … …  
    34403461        snd_pcm_sframes_t result;
    34413462       
     3463        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
     3464                return -EBADFD;
     3465
    34423466        switch (cmd) {
    34433467        case SNDRV_PCM_IOCTL_FORWARD:
    … …  
    34823506                return -ENXIO;
    34833507        runtime = substream->runtime;
    3484         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
     3508        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
     3509            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
    34853510                return -EBADFD;
    34863511        if (!frame_aligned(runtime, count))
    … …  
    35063531                return -ENXIO;
    35073532        runtime = substream->runtime;
    3508         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
     3533        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
     3534            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
    35093535                return -EBADFD;
    35103536        if (!frame_aligned(runtime, count))
    … …  
    35363562                return -ENXIO;
    35373563        runtime = substream->runtime;
    3538         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
     3564        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
     3565            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
    35393566                return -EBADFD;
    35403567        if (!iter_is_iovec(to))
    … …  
    35723599                return -ENXIO;
    35733600        runtime = substream->runtime;
    3574         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
     3601        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
     3602            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
    35753603                return -EBADFD;
    35763604        if (!iter_is_iovec(from))
    … …  
    36113639
    36123640        runtime = substream->runtime;
     3641        if (runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
     3642                return ok | EPOLLERR;
     3643
    36133644        poll_wait(file, &runtime->sleep, wait);
    36143645
    … …  
    39223953        if (PCM_RUNTIME_CHECK(substream))
    39233954                return -ENXIO;
     3955        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
     3956                return -EBADFD;
    39243957
    39253958        offset = area->vm_pgoff << PAGE_SHIFT;
    … …  
    39593992                return -ENXIO;
    39603993        runtime = substream->runtime;
     3994        if (runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
     3995                return -EBADFD;
    39613996        return fasync_helper(fd, file, on, &runtime->fasync);
    39623997}

  • GPL/branches/uniaud32-exp/alsa-kernel/core/timer.c

    r725 r736  
    8585        struct timespec64 tstamp;               /* trigger tstamp */
    8686        wait_queue_head_t qchange_sleep;
    87         struct snd_fasync *fasync;
     87        struct fasync_struct *fasync;
    8888        struct mutex ioctl_lock;
    8989};
    … …  
    13621362      __wake:
    13631363        spin_unlock(&tu->qlock);
    1364         snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
     1364        kill_fasync(&tu->fasync, SIGIO, POLL_IN);
    13651365        wake_up(&tu->qchange_sleep);
    13661366}
    … …  
    14001400        snd_timer_user_append_to_tqueue(tu, &r1);
    14011401        spin_unlock_irqrestore(&tu->qlock, flags);
    1402         snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
     1402        kill_fasync(&tu->fasync, SIGIO, POLL_IN);
    14031403        wake_up(&tu->qchange_sleep);
    14041404}
    … …  
    14701470        if (append == 0)
    14711471                return;
    1472         snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
     1472        kill_fasync(&tu->fasync, SIGIO, POLL_IN);
    14731473        wake_up(&tu->qchange_sleep);
    14741474}
    … …  
    15381538                }
    15391539                mutex_unlock(&tu->ioctl_lock);
    1540                 snd_fasync_free(tu->fasync);
    15411540                kfree(tu->queue);
    15421541                kfree(tu->tqueue);
    … …  
    21532152
    21542153        tu = file->private_data;
    2155         return snd_fasync_helper(fd, file, on, &tu->fasync);
     2154        return fasync_helper(fd, file, on, &tu->fasync);
    21562155}
    21572156

  • GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_device.c

    r711 r736  
    675675        { 0x17e8, "Chrontel" },
    676676        { 0x1854, "LG" },
    677         { 0x19e5, "Huawei" },
    678677        { 0x1aec, "Wolfson Microelectronics" },
    679678        { 0x1af4, "QEMU" },

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/control.h

    r725 r736  
    110110        wait_queue_head_t change_sleep;
    111111        spinlock_t read_lock;
    112         struct snd_fasync *fasync;
     112        struct fasync_struct *fasync;
    113113        int subscribed;                 /* read interface is activated */
    114114        struct list_head events;        /* waiting events for read */

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/core.h

    r725 r736  
    288288int snd_card_free(struct snd_card *card);
    289289int snd_card_free_when_closed(struct snd_card *card);
    290 int snd_card_free_on_error(struct device *dev, int ret);
    291290void snd_card_set_id(struct snd_card *card, const char *id);
    292291int snd_card_register(struct snd_card *card);
    … …  
    543542#endif
    544543
    545 /* async signal helpers */
    546 struct snd_fasync;
    547 
    548 int snd_fasync_helper(int fd, struct file *file, int on,
    549                       struct snd_fasync **fasyncp);
    550 void snd_kill_fasync(struct snd_fasync *fasync, int signal, int poll);
    551 void snd_fasync_free(struct snd_fasync *fasync);
    552 
    553544#endif /* __SOUND_CORE_H */

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/jack.h

    r711 r736  
    6363#ifdef CONFIG_SND_JACK_INPUT_DEV
    6464        struct input_dev *input_dev;
    65         struct mutex input_dev_lock;
    6665        int registered;
    6766        int type;

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/memalloc.h

    r716 r736  
    1010#define __SOUND_MEMALLOC_H
    1111
     12#include <linux/dma-direction.h>
    1213#include <asm/page.h>
    1314
    1415struct device;
    1516struct vm_area_struct;
     17struct sg_table;
    1618
    1719/*
    … …  
    2022struct snd_dma_device {
    2123        int type;                       /* SNDRV_DMA_TYPE_XXX */
     24        enum dma_data_direction dir;    /* DMA direction */
     25        bool need_sync;                 /* explicit sync needed? */
    2226        struct device *dev;             /* generic device */
    2327};
    … …  
    4650#endif
    4751#define SNDRV_DMA_TYPE_VMALLOC          7       /* vmalloc'ed buffer */
     52#define SNDRV_DMA_TYPE_NONCONTIG        8       /* non-coherent SG buffer */
     53#define SNDRV_DMA_TYPE_NONCOHERENT      9       /* non-coherent buffer */
    4854
    4955/*
    … …  
    6773
    6874/* allocate/release a buffer */
    69 int snd_dma_alloc_pages(int type, struct device *dev, size_t size,
    70                         struct snd_dma_buffer *dmab);
     75int snd_dma_alloc_dir_pages(int type, struct device *dev,
     76                            enum dma_data_direction dir, size_t size,
     77                            struct snd_dma_buffer *dmab);
     78
     79static inline int snd_dma_alloc_pages(int type, struct device *dev,
     80                                      size_t size, struct snd_dma_buffer *dmab)
     81{
     82        return snd_dma_alloc_dir_pages(type, dev, DMA_BIDIRECTIONAL, size, dmab);
     83}
     84
    7185int snd_dma_alloc_pages_fallback(int type, struct device *dev, size_t size,
    7286                                 struct snd_dma_buffer *dmab);
    … …  
    7488int snd_dma_buffer_mmap(struct snd_dma_buffer *dmab,
    7589                        struct vm_area_struct *area);
     90
     91enum snd_dma_sync_mode { SNDRV_DMA_SYNC_CPU, SNDRV_DMA_SYNC_DEVICE };
     92#ifdef CONFIG_HAS_DMA
     93void snd_dma_buffer_sync(struct snd_dma_buffer *dmab,
     94                         enum snd_dma_sync_mode mode);
     95#else
     96static inline void snd_dma_buffer_sync(struct snd_dma_buffer *dmab,
     97                                       enum snd_dma_sync_mode mode) {}
     98#endif
    7699
    77100dma_addr_t snd_sgbuf_get_addr(struct snd_dma_buffer *dmab, size_t offset);
    … …  
    81104
    82105/* device-managed memory allocator */
    83 struct snd_dma_buffer *snd_devm_alloc_pages(struct device *dev, int type,
    84                                             size_t size);
     106struct snd_dma_buffer *snd_devm_alloc_dir_pages(struct device *dev, int type,
     107                                                enum dma_data_direction dir,
     108                                                size_t size);
     109
     110static inline struct snd_dma_buffer *
     111snd_devm_alloc_pages(struct device *dev, int type, size_t size)
     112{
     113        return snd_devm_alloc_dir_pages(dev, type, DMA_BIDIRECTIONAL, size);
     114}
     115
     116static inline struct sg_table *
     117snd_dma_noncontig_sg_table(struct snd_dma_buffer *dmab)
     118{
     119        return dmab->private_data;
     120}
     121
    85122#ifdef TARGET_OS2
    86123int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab);

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/simple_card_utils.h

    r694 r736  
    4343        int codecs;
    4444        int platforms;
     45        int c2c;
    4546};
    4647
    … …  
    5556                struct asoc_simple_data adata;
    5657                struct snd_soc_codec_conf *codec_conf;
     58                struct snd_soc_pcm_stream *c2c_conf;
    5759                struct prop_nums num;
    5860                unsigned int mclk_fs;
    … …  
    6567        struct snd_soc_dai_link_component dummy;
    6668        struct snd_soc_codec_conf *codec_conf;
     69        struct snd_soc_pcm_stream *c2c_conf;
    6770        struct gpio_desc *pa_gpio;
    6871        const struct snd_soc_ops *ops;
    … …  
    116119             (i)++)
    117120
    118 #define SNDRV_MAX_LINKS 128
     121#define SNDRV_MAX_LINKS 512
    119122
    120123struct link_info {
    … …  
    181184
    182185int asoc_graph_card_probe(struct snd_soc_card *card);
     186int asoc_graph_is_ports0(struct device_node *port);
    183187
    184188#ifdef DEBUG

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-acpi.h

    r694 r736  
    130130 *
    131131 * @id: ACPI ID (usually the codec's) used to find a matching machine driver.
     132 * @comp_ids: list of compatible audio codecs using the same machine driver,
     133 * firmware and topology
    132134 * @link_mask: describes required board layout, e.g. for SoundWire.
    133135 * @links: array of link _ADR descriptors, null terminated.
    … …  
    146148/* Descriptor for SST ASoC machine driver */
    147149struct snd_soc_acpi_mach {
    148         const u8 id[ACPI_ID_LEN];
     150        u8 id[ACPI_ID_LEN];
     151        const struct snd_soc_acpi_codecs *comp_ids;
    149152        const u32 link_mask;
    150153        const struct snd_soc_acpi_link_adr *links;

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-component.h

    r694 r736  
    221221
    222222        /* function mark */
    223         struct snd_pcm_substream *mark_module;
     223        void *mark_module;
    224224        struct snd_pcm_substream *mark_open;
    225225        struct snd_pcm_substream *mark_hw_params;
    … …  
    228228        void *mark_pm;
    229229
    230 #ifdef CONFIG_DEBUG_FS
    231230        struct dentry *debugfs_root;
    232231        const char *debugfs_prefix;
    233 #endif
    234232};
    235233
    … …  
    334332{
    335333        return regcache_sync(component->regmap);
     334}
     335
     336static inline int snd_soc_component_is_codec(struct snd_soc_component *component)
     337{
     338        return component->driver->non_legacy_dai_naming;
    336339}
    337340
    … …  
    392395        snd_soc_component_module_get(component, substream, 1)
    393396int snd_soc_component_module_get(struct snd_soc_component *component,
    394                                  struct snd_pcm_substream *substream,
    395                                  int upon_open);
     397                                 void *mark, int upon_open);
    396398#define snd_soc_component_module_put_when_remove(component)     \
    397399        snd_soc_component_module_put(component, NULL, 0, 0)
    … …  
    399401        snd_soc_component_module_put(component, substream, 1, rollback)
    400402void snd_soc_component_module_put(struct snd_soc_component *component,
    401                                   struct snd_pcm_substream *substream,
    402                                   int upon_open, int rollback);
     403                                  void *mark, int upon_open, int rollback);
    403404
    404405static inline void snd_soc_component_set_drvdata(struct snd_soc_component *c,
    … …  
    456457                                        const struct of_phandle_args *args,
    457458                                        const char **dai_name);
    458 int snd_soc_component_compr_open(struct snd_compr_stream *cstream);
    459 void snd_soc_component_compr_free(struct snd_compr_stream *cstream,
     459int snd_soc_component_compr_open(struct snd_soc_component *component,
     460                                 struct snd_compr_stream *cstream);
     461void snd_soc_component_compr_free(struct snd_soc_component *component,
     462                                  struct snd_compr_stream *cstream,
    460463                                  int rollback);
    461464int snd_soc_component_compr_trigger(struct snd_compr_stream *cstream, int cmd);

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-dpcm.h

    r694 r736  
    160160int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
    161161        int event);
     162bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget, enum snd_soc_dapm_direction dir);
    162163
    163164#define dpcm_be_dai_startup_rollback(fe, stream, last)  \

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-topology.h

    r711 r736  
    152152
    153153        /* completion - called at completion of firmware loading */
    154         void (*complete)(struct snd_soc_component *);
     154        int (*complete)(struct snd_soc_component *comp);
    155155
    156156        /* manifest - optional to inform component of manifest */

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/sof.h

    r710 r736  
    7575        int resindex_imr_base;
    7676        int irqindex_host_ipc;
    77         int resindex_dma_base;
    78 
    79         /* DMA only valid when resindex_dma_base != -1*/
    80         int dma_engine;
    81         int dma_size;
    8277
    8378        /* IPC timeouts in ms */

  • GPL/branches/uniaud32-exp/alsa-kernel/include/sound/version.h

    r725 r736  
    11/* include/version.h */
    2 #define CONFIG_SND_VERSION "5.15.65"
     2#define CONFIG_SND_VERSION "5.16.20"
    33#define CONFIG_SND_DATE ""

  • GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asoc.h

    r692 r736  
    241241        __le32 size;    /* in bytes of private data */
    242242        union {
    243                 char data[0];
    244                 struct snd_soc_tplg_vendor_array array[0];
     243                __DECLARE_FLEX_ARRAY(char, data);
     244                __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_array, array);
    245245        };
    246246} __attribute__((packed));

  • GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asound.h

    r711 r736  
    10471047#define SNDRV_CTL_ELEM_ACCESS_READWRITE         (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE)
    10481048#define SNDRV_CTL_ELEM_ACCESS_VOLATILE          (1<<2)  /* control value may be changed without a notification */
    1049 // (1 << 3) is unused.
     1049/* (1 << 3) is unused. */
    10501050#define SNDRV_CTL_ELEM_ACCESS_TLV_READ          (1<<4)  /* TLV read is possible */
    10511051#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE         (1<<5)  /* TLV write is possible */

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/ali5451/ali5451.c

    r711 r736  
    21322132}
    21332133
    2134 static int __snd_ali_probe(struct pci_dev *pci,
    2135                            const struct pci_device_id *pci_id)
     2134static int snd_ali_probe(struct pci_dev *pci,
     2135                         const struct pci_device_id *pci_id)
    21362136{
    21372137        struct snd_card *card;
    … …  
    21762176        pci_set_drvdata(pci, card);
    21772177        return 0;
    2178 }
    2179 
    2180 static 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));
    21842178}
    21852179

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/als4000.c

    r711 r736  
    810810}
    811811
    812 static int __snd_card_als4000_probe(struct pci_dev *pci,
    813                                     const struct pci_device_id *pci_id)
     812static int snd_card_als4000_probe(struct pci_dev *pci,
     813                                  const struct pci_device_id *pci_id)
    814814{
    815815        static int dev;
    … …  
    934934}
    935935
    936 static 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));
    940 }
    941 
    942936#ifdef CONFIG_PM_SLEEP
    943937static int snd_als4000_suspend(struct device *dev)

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/atiixp.c

    r715 r736  
    15951595
    15961596
    1597 static int __snd_atiixp_probe(struct pci_dev *pci,
    1598                               const struct pci_device_id *pci_id)
     1597static int snd_atiixp_probe(struct pci_dev *pci,
     1598                            const struct pci_device_id *pci_id)
    15991599{
    16001600        struct snd_card *card;
    … …  
    16501650}
    16511651
    1652 static 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));
    1656 }
    1657 
    16581652static struct pci_driver atiixp_driver = {
    16591653        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/au88x0/au88x0.c

    r711 r736  
    194194// constructor -- see "Constructor" sub-section
    195195static int
    196 __snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     196snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
    197197{
    198198        static int dev;
    … …  
    311311}
    312312
    313 static int
    314 snd_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));
    317 }
    318 
    319313// pci_driver definition
    320314static struct pci_driver vortex_driver = {

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/bt87x.c

    r711 r736  
    824824}
    825825
    826 static int __snd_bt87x_probe(struct pci_dev *pci,
    827                              const struct pci_device_id *pci_id)
     826static int snd_bt87x_probe(struct pci_dev *pci,
     827                           const struct pci_device_id *pci_id)
    828828{
    829829        static int dev;
    … …  
    908908}
    909909
    910 static 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));
    914 }
    915 
    916910/* default entries for all Bt87x cards - it's not exported */
    917911/* driver_data is set to 0 to call detection */

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/ca0106/ca0106_main.c

    r713 r736  
    17291729
    17301730
    1731 static int __snd_ca0106_probe(struct pci_dev *pci,
    1732                               const struct pci_device_id *pci_id)
     1731static int snd_ca0106_probe(struct pci_dev *pci,
     1732                                        const struct pci_device_id *pci_id)
    17331733{
    17341734        static int dev;
    … …  
    17881788        dev++;
    17891789        return 0;
    1790 }
    1791 
    1792 static 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));
    17961790}
    17971791

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/cmipci.c

    r715 r736  
    32383238        static int dev;
    32393239        struct snd_card *card;
    3240         struct cmipci *cm;
    32413240        int err;
    32423241
    … …  
    32493248
    32503249        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    3251                                 sizeof(*cm), &card);
     3250                                sizeof(struct cmipci), &card);
    32523251        if (err < 0)
    32533252                return err;
    3254         cm = card->private_data;
    32553253       
    32563254        switch (pci->device) {
    … …  
    32703268        err = snd_cmipci_create(card, pci, dev);
    32713269        if (err < 0)
    3272                 goto error;
     3270                return err;
    32733271
    32743272        err = snd_card_register(card);
    32753273        if (err < 0)
    3276                 goto error;
     3274                return err;
    32773275
    32783276        pci_set_drvdata(pci, card);
    32793277        dev++;
    32803278        return 0;
    3281 
    3282  error:
    3283         snd_card_free(card);
    3284         return err;
    32853279}
    32863280

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/cs4281.c

    r715 r736  
    18441844}
    18451845
    1846 static int __snd_cs4281_probe(struct pci_dev *pci,
    1847                               const struct pci_device_id *pci_id)
     1846static int snd_cs4281_probe(struct pci_dev *pci,
     1847                            const struct pci_device_id *pci_id)
    18481848{
    18491849        static int dev;
    … …  
    19051905}
    19061906
    1907 static 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));
    1911 }
    1912 
    19131907/*
    19141908 * Power Management

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/cs46xx/cs46xx.c

    r711 r736  
    8282                                external_amp[dev], thinkpad[dev]);
    8383        if (err < 0)
    84                 goto error;
     84                return err;
    8585        card->private_data = chip;
    8686        chip->accept_valid = mmap_valid[dev];
    8787        err = snd_cs46xx_pcm(chip, 0);
    8888        if (err < 0)
    89                 goto error;
     89                return err;
    9090#ifdef CONFIG_SND_CS46XX_NEW_DSP
    9191        err = snd_cs46xx_pcm_rear(chip, 1);
    9292        if (err < 0)
    93                 goto error;
     93                return err;
    9494        err = snd_cs46xx_pcm_iec958(chip, 2);
    9595        if (err < 0)
    96                 goto error;
     96                return err;
    9797#endif
    9898        err = snd_cs46xx_mixer(chip, 2);
    9999        if (err < 0)
    100                 goto error;
     100                return err;
    101101#ifdef CONFIG_SND_CS46XX_NEW_DSP
    102102        if (chip->nr_ac97_codecs ==2) {
    103103                err = snd_cs46xx_pcm_center_lfe(chip, 3);
    104104                if (err < 0)
    105                         goto error;
     105                        return err;
    106106        }
    107107#endif
    108108        err = snd_cs46xx_midi(chip, 0);
    109109        if (err < 0)
    110                 goto error;
     110                return err;
    111111        err = snd_cs46xx_start_dsp(chip);
    112112        if (err < 0)
    113                 goto error;
     113                return err;
    114114
    115115        snd_cs46xx_gameport(chip);
    … …  
    125125        err = snd_card_register(card);
    126126        if (err < 0)
    127                 goto error;
     127                return err;
    128128
    129129        pci_set_drvdata(pci, card);
    130130        dev++;
    131131        return 0;
    132 
    133  error:
    134         snd_card_free(card);
    135         return err;
    136132}
    137133

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/cs5535audio/cs5535audio.c

    r711 r736  
    286286}
    287287
    288 static int __snd_cs5535audio_probe(struct pci_dev *pci,
    289                                    const struct pci_device_id *pci_id)
     288static int snd_cs5535audio_probe(struct pci_dev *pci,
     289                                 const struct pci_device_id *pci_id)
    290290{
    291291        static int dev;
    … …  
    334334        dev++;
    335335        return 0;
    336 }
    337 
    338 static 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));
    342336}
    343337

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/emu10k1/emu10k1x.c

    r711 r736  
    14991499}
    15001500
    1501 static int __snd_emu10k1x_probe(struct pci_dev *pci,
    1502                                 const struct pci_device_id *pci_id)
     1501static int snd_emu10k1x_probe(struct pci_dev *pci,
     1502                              const struct pci_device_id *pci_id)
    15031503{
    15041504        static int dev;
    … …  
    15621562}
    15631563
    1564 static 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));
    1568 }
    1569 
    15701564// PCI IDs
    15711565static const struct pci_device_id snd_emu10k1x_ids[] = {

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/ens1370.c

    r732 r736  
    23202320}
    23212321
    2322 static int __snd_audiopci_probe(struct pci_dev *pci,
    2323                                 const struct pci_device_id *pci_id)
     2322static int snd_audiopci_probe(struct pci_dev *pci,
     2323                              const struct pci_device_id *pci_id)
    23242324{
    23252325        static int dev;
    … …  
    23852385}
    23862386
    2387 static int snd_audiopci_probe(struct pci_dev *pci,
    2388                               const struct pci_device_id *pci_id)
    2389 {
    2390         return snd_card_free_on_error(&pci->dev, __snd_audiopci_probe(pci, pci_id));
    2391 }
    2392 
    23932387static struct pci_driver ens137x_driver = {
    23942388        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/es1938.c

    r711 r736  
    17521752       
    17531753
    1754 static int __snd_es1938_probe(struct pci_dev *pci,
    1755                               const struct pci_device_id *pci_id)
     1754static int snd_es1938_probe(struct pci_dev *pci,
     1755                            const struct pci_device_id *pci_id)
    17561756{
    17571757        static int dev;
    … …  
    18321832}
    18331833
    1834 static 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));
    1838 }
    1839 
    18401834static struct pci_driver es1938_driver = {
    18411835        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/es1968.c

    r715 r736  
    27782778/*
    27792779 */
    2780 static int __snd_es1968_probe(struct pci_dev *pci,
    2781                               const struct pci_device_id *pci_id)
     2780static int snd_es1968_probe(struct pci_dev *pci,
     2781                            const struct pci_device_id *pci_id)
    27822782{
    27832783        static int dev;
    … …  
    28852885}
    28862886
    2887 static 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));
    2891 }
    2892 
    28932887static struct pci_driver es1968_driver = {
    28942888        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/fm801.c

    r711 r736  
    12921292}
    12931293
    1294 static int __snd_card_fm801_probe(struct pci_dev *pci,
    1295                                   const struct pci_device_id *pci_id)
     1294static int snd_card_fm801_probe(struct pci_dev *pci,
     1295                                const struct pci_device_id *pci_id)
    12961296{
    12971297        static int dev;
    … …  
    13551355        dev++;
    13561356        return 0;
    1357 }
    1358 
    1359 static 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));
    13631357}
    13641358

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_auto_parser.c

    r711 r736  
    828828}
    829829
    830 void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth)
     830static void 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                         __snd_hda_apply_fixup(codec, fix->chain_id, action, depth + 1);
     840                        apply_fixup(codec, fix->chain_id, action, depth + 1);
    841841
    842842                switch (fix->type) {
    … …  
    879879        }
    880880}
    881 EXPORT_SYMBOL_GPL(__snd_hda_apply_fixup);
    882881
    883882/**
    … …  
    889888{
    890889        if (codec->fixup_list)
    891                 __snd_hda_apply_fixup(codec, codec->fixup_id, action, 0);
     890                apply_fixup(codec, codec->fixup_id, action, 0);
    892891}
    893892EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_intel.c

    r732 r736  
    21022102};
    21032103
     2104static DECLARE_BITMAP(probed_devs, SNDRV_CARDS);
     2105
    21042106static int azx_probe(struct pci_dev *pci,
    21052107                     const struct pci_device_id *pci_id)
    21062108{
    2107         static int dev;
    21082109        struct snd_card *card;
    21092110        struct hda_intel *hda;
    21102111        struct azx *chip;
    21112112        bool schedule_probe;
     2113        int dev;
    21122114        int err;
    21132115
    … …  
    21172119        }
    21182120
     2121        dev = find_first_zero_bit(probed_devs, SNDRV_CARDS);
    21192122        if (dev >= SNDRV_CARDS)
    21202123                return -ENODEV;
    21212124        if (!enable[dev]) {
    2122                 dev++;
     2125                set_bit(dev, probed_devs);
    21232126                return -ENOENT;
    21242127        }
    … …  
    21952198#endif
    21962199
    2197         dev++;
     2200        set_bit(dev, probed_devs);
    21982201        if (chip->disabled)
    21992202                complete_all(&hda->probe_wait);
    … …  
    24182421                device_lock(&pci->dev);
    24192422
     2423                clear_bit(chip->dev_index, probed_devs);
     2424                pci_set_drvdata(pci, NULL);
    24202425                snd_card_free(card);
    24212426        }

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_local.h

    r711 r736  
    365365                           const struct hda_pintbl *cfg);
    366366void snd_hda_apply_fixup(struct hda_codec *codec, int action);
    367 void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth);
    368367void snd_hda_pick_fixup(struct hda_codec *codec,
    369368                        const struct hda_model_fixup *models,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_cirrus.c

    r725 r736  
    400400        /* codec SSID */
    401401        SND_PCI_QUIRK(0x106b, 0x0600, "iMac 14,1", CS420X_IMAC27_122),
    402         SND_PCI_QUIRK(0x106b, 0x0900, "iMac 12,1", CS420X_IMAC27_122),
    403402        SND_PCI_QUIRK(0x106b, 0x1c00, "MacBookPro 8,1", CS420X_MBP81),
    404403        SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_conexant.c

    r725 r736  
    229229        CXT_PINCFG_COMPAQ_CQ60,
    230230        CXT_FIXUP_STEREO_DMIC,
    231         CXT_PINCFG_LENOVO_NOTEBOOK,
    232231        CXT_FIXUP_INC_MIC_BOOST,
    233232        CXT_FIXUP_HEADPHONE_MIC_PIN,
    … …  
    814813                .v.func = cxt_fixup_stereo_dmic,
    815814        },
    816 #ifdef TARGET_OS2xxx
    817         [CXT_PINCFG_LENOVO_NOTEBOOK] = {
    818                 .type = HDA_FIXUP_PINS,
    819                 .v.pins = (const struct hda_pintbl[]) {
    820                         { 0x1a, 0x05d71030 },
    821                         { }
    822                 },
    823                 .chain_id = CXT_FIXUP_STEREO_DMIC,
    824         },
    825 #endif
    826815        [CXT_FIXUP_INC_MIC_BOOST] = {
    827816                .type = HDA_FIXUP_FUNC,
    … …  
    10161005        SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
    10171006        SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE),
    1018         SND_PCI_QUIRK(0x103c, 0x82b4, "HP ProDesk 600 G3", CXT_FIXUP_HP_MIC_NO_PRESENCE),
    10191007        SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO),
    10201008        SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO),
    … …  
    10431031        SND_PCI_QUIRK(0x17aa, 0x390b, "Lenovo G50-80", CXT_FIXUP_STEREO_DMIC),
    10441032        SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
    1045         SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_PINCFG_LENOVO_NOTEBOOK),
     1033        SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),
    10461034        SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo G50-70", CXT_FIXUP_STEREO_DMIC),
    10471035        SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),
    … …  
    11251113                                   cxt5051_fixups, cxt_fixups);
    11261114                break;
    1127         case 0x14f15098:
    1128                 codec->pin_amp_workaround = 1;
    1129                 spec->gen.mixer_nid = 0x22;
    1130                 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
    1131                 snd_hda_pick_fixup(codec, cxt5066_fixup_models,
    1132                                    cxt5066_fixups, cxt_fixups);
    1133                 break;
    11341115        case 0x14f150f2:
    11351116                codec->power_save_node = 1;
    … …  
    11521133                goto error;
    11531134
    1154         err = cx_auto_parse_beep(codec);
     1135        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
    11551136        if (err < 0)
    11561137                goto error;
    11571138
    1158         err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
     1139        err = cx_auto_parse_beep(codec);
    11591140        if (err < 0)
    11601141                goto error;

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_hdmi.c

    r711 r736  
    14001400 last_try:
    14011401        /* the last try; check the empty slots in pins */
    1402         for (i = 0; i < spec->pcm_used; i++) {
     1402        for (i = 0; i < spec->num_nids; i++) {
    14031403                if (!test_bit(i, &spec->pcm_bitmap))
    14041404                        return i;
    … …  
    22762276         */
    22772277
    2278         if (spec->dyn_pcm_no_legacy && codec->mst_no_extra_pcms)
    2279                 pcm_num = spec->num_cvts;
    2280         else if (codec->mst_no_extra_pcms)
     2278        if (codec->mst_no_extra_pcms)
    22812279                pcm_num = spec->num_nids;
    22822280        else

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_realtek.c

    r733 r736  
    446446        case 0x10ec0255:
    447447        case 0x10ec0256:
    448         case 0x19e58326:
    449448        case 0x10ec0257:
    450449        case 0x10ec0282:
    … …  
    584583        case 0x10ec0236:
    585584        case 0x10ec0256:
    586         case 0x19e58326:
    587585        case 0x10ec0283:
    588586        case 0x10ec0286:
    … …  
    943941}
    944942
    945 #define alc_free        snd_hda_gen_free
    946 
    947 #ifdef CONFIG_PM
    948943static inline void alc_shutup(struct hda_codec *codec)
    949944{
    … …  
    959954}
    960955
     956#define alc_free        snd_hda_gen_free
     957
     958#ifdef CONFIG_PM
    961959static void alc_power_eapd(struct hda_codec *codec)
    962960{
    … …  
    972970        return 0;
    973971}
    974 
     972#endif
     973
     974#ifdef CONFIG_PM
    975975static int alc_resume(struct hda_codec *codec)
    976976{
    … …  
    23392339        ALC887_FIXUP_ASUS_AUDIO,
    23402340        ALC887_FIXUP_ASUS_HMIC,
    2341         ALCS1200A_FIXUP_MIC_VREF,
    23422341};
    23432342
    … …  
    30733072                .chain_id = ALC887_FIXUP_ASUS_AUDIO,
    30743073        },
    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
    30853074};
    30863075
    … …  
    31203109        SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
    31213110        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),
    31233111        SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
    31243112        SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
    … …  
    31753163        SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    31763164        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),
    31783165        SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    31793166        SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    31803167        SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    31813168        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),
    31833169        SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    31843170        SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    … …  
    37833769        ALC269_TYPE_ALC215,
    37843770        ALC269_TYPE_ALC225,
    3785         ALC269_TYPE_ALC245,
    37863771        ALC269_TYPE_ALC287,
    37873772        ALC269_TYPE_ALC294,
    … …  
    38213806        case ALC269_TYPE_ALC215:
    38223807        case ALC269_TYPE_ALC225:
    3823         case ALC269_TYPE_ALC245:
    38243808        case ALC269_TYPE_ALC287:
    38253809        case ALC269_TYPE_ALC294:
    … …  
    38913875        case 0x10ec0236:
    38923876        case 0x10ec0256:
    3893         case 0x19e58326:
    38943877                alc_write_coef_idx(codec, 0x48, 0x0);
    38953878                alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
    … …  
    39203903        case 0x10ec0236:
    39213904        case 0x10ec0256:
    3922         case 0x19e58326:
    39233905                alc_write_coef_idx(codec, 0x48, 0xd011);
    39243906                alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
    … …  
    43534335        bool hp1_pin_sense, hp2_pin_sense;
    43544336
    4355         if (spec->codec_variant != ALC269_TYPE_ALC287 &&
    4356                 spec->codec_variant != ALC269_TYPE_ALC245)
     4337        if (spec->codec_variant != ALC269_TYPE_ALC287)
    43574338                /* required only at boot or S3 and S4 resume time */
    43584339#ifndef TARGET_OS2
    … …  
    56035584        case 0x10ec0236:
    56045585        case 0x10ec0256:
    5605         case 0x19e58326:
    56065586                alc_process_coef_fw(codec, coef0256);
    56075587                break;
    … …  
    57195699        case 0x10ec0236:
    57205700        case 0x10ec0256:
    5721         case 0x19e58326:
    57225701                alc_write_coef_idx(codec, 0x45, 0xc489);
    57235702                snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
    … …  
    58705849        case 0x10ec0236:
    58715850        case 0x10ec0256:
    5872         case 0x19e58326:
    58735851                alc_write_coef_idx(codec, 0x1b, 0x0e4b);
    58745852                alc_write_coef_idx(codec, 0x45, 0xc089);
    … …  
    59705948        case 0x10ec0236:
    59715949        case 0x10ec0256:
    5972         case 0x19e58326:
    59735950                alc_process_coef_fw(codec, coef0256);
    59745951                break;
    … …  
    60856062        case 0x10ec0236:
    60866063        case 0x10ec0256:
    6087         case 0x19e58326:
    60886064                alc_process_coef_fw(codec, coef0256);
    60896065                break;
    … …  
    61876163        case 0x10ec0236:
    61886164        case 0x10ec0256:
    6189         case 0x19e58326:
    61906165                alc_write_coef_idx(codec, 0x1b, 0x0e4b);
    61916166                alc_write_coef_idx(codec, 0x06, 0x6104);
    … …  
    64846459        case 0x10ec0236:
    64856460        case 0x10ec0256:
    6486         case 0x19e58326:
    64876461                alc_process_coef_fw(codec, alc256fw);
    64886462                break;
    … …  
    70887062        case 0x10ec0255:
    70897063        case 0x10ec0256:
    7090         case 0x19e58326:
    70917064                alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
    70927065                alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
    … …  
    74197392        ALC269VB_FIXUP_ASUS_ZENBOOK,
    74207393        ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
    7421         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
    74227394        ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
    74237395        ALC269VB_FIXUP_ORDISSIMO_EVE2,
    … …  
    74797451        ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
    74807452        ALC269_FIXUP_ATIV_BOOK_8,
    7481         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
    74827453        ALC221_FIXUP_HP_MIC_NO_PRESENCE,
    74837454        ALC256_FIXUP_ASUS_HEADSET_MODE,
    … …  
    75847555        ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
    75857556        ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
    7586         ALC298_FIXUP_LENOVO_C940_DUET7,
    75877557        ALC287_FIXUP_13S_GEN2_SPEAKERS,
    75887558        ALC256_FIXUP_SET_COEF_DEFAULTS,
    … …  
    75937563        ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
    75947564};
    7595 
    7596 #ifdef NOT_USED
    7597 /* A special fixup for Lenovo C940 and Yoga Duet 7;
    7598  * both have the very same PCI SSID, and we need to apply different fixups
    7599  * depending on the codec ID
    7600  */
    7601 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
    7602                                            const struct hda_fixup *fix,
    7603                                            int action)
    7604 {
    7605         int id;
    7606 
    7607         if (codec->core.vendor_id == 0x10ec0298)
    7608                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
    7609         else
    7610                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
    7611         __snd_hda_apply_fixup(codec, id, action, 0);
    7612 }
    7613 #endif
    76147565
    76157566#ifdef TARGET_OS2
    … …  
    82518202                .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
    82528203        },
    8253 #ifdef TARGET_OS2xxx
    8254         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
    8255                 .type = HDA_FIXUP_PINS,
    8256                 .v.pins = (const struct hda_pintbl[]) {
    8257                         { 0x18, 0x01a110f0 },  /* use as headset mic */
    8258                         { }
    8259                 },
    8260                 .chained = true,
    8261                 .chain_id = ALC269_FIXUP_HEADSET_MIC
    8262         },
    8263 #endif
    82648204        [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
    82658205                .type = HDA_FIXUP_FUNC,
    … …  
    87188658        },
    87198659#ifdef TARGET_OS2xxx
    8720         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
    8721                 .type = HDA_FIXUP_PINS,
    8722                 .v.pins = (const struct hda_pintbl[]) {
    8723                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
    8724                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
    8725                         { }
    8726                 },
    8727                 .chained = true,
    8728                 .chain_id = ALC269_FIXUP_HEADSET_MODE
    8729         },
    87308660        [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
    87318661                .type = HDA_FIXUP_PINS,
    … …  
    96469576                .chained = true,
    96479577                .chain_id = ALC269_FIXUP_HEADSET_MODE,
    9648         },
    9649         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
    9650                 .type = HDA_FIXUP_FUNC,
    9651                 .v.func = alc298_fixup_lenovo_c940_duet7,
    96529578        },
    96539579        [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
    … …  
    97359661        SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
    97369662        SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
    9737         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
    97389663        SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
    97399664        SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
    … …  
    97459670        SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
    97469671        SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
    9747         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
    97489672        SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
    97499673        SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
    … …  
    98009724        SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
    98019725        SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
    9802         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
    98039726        SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    98049727        SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    … …  
    98609783        SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
    98619784        SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
    9862         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
    98639785        SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
    98649786        SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
    … …  
    98819803        SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
    98829804        SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
    9883         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
    9884         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
    98859805        SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    98869806        SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
    … …  
    98989818        SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
    98999819                      ALC285_FIXUP_HP_GPIO_AMP_INIT),
    9900         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
    9901         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
    99029820        SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
    99039821        SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
    … …  
    99279845        SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
    99289846        SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
    9929         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
    99309847        SND_PCI_QUIRK(0x103c, 0x89c3, "HP", ALC285_FIXUP_HP_GPIO_LED),
    99319848        SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
    9932         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
    9933         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
    9934         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
    9935         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
    9936         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
    99379849        SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
    99389850        SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
    … …  
    99499861        SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
    99509862        SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
    9951         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
    99529863        SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
    99539864        SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
    … …  
    100259936        SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100269937        SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    10027         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100289938        SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100299939        SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    100529962        SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100539963        SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    10054         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    10055         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    10056         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100579964        SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100589965        SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    100679974        SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100689975        SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    10069         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100709976        SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    100719977        SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
    … …  
    1013610042        SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
    1013710043        SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
    10138         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
    1013910044        SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
    10140         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
     10045        SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME),
    1014110046        SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
    10142         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
    1014310047        SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
    1014410048        SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
    … …  
    1016810072        SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    1016910073        SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    10170         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
    1017110074        SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
    1017210075        SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
    … …  
    1018210085        SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
    1018310086        SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
    10184         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
    10185         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
    10186         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
    10187         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
    10188         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
    10189         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
    10190         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
    10191         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
    1019210087        SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
    1019310088        SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
    1019410089        SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
    10195         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
    1019610090        SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
    1019710091        SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
    … …  
    1097710871        case 0x10ec0236:
    1097810872        case 0x10ec0256:
    10979         case 0x19e58326:
    1098010873                spec->codec_variant = ALC269_TYPE_ALC256;
    1098110874                spec->shutup = alc256_shutup;
    … …  
    1099310886        case 0x10ec0285:
    1099410887        case 0x10ec0289:
    10995                 if (alc_get_coef0(codec) & 0x0010)
    10996                         spec->codec_variant = ALC269_TYPE_ALC245;
    10997                 else
    10998                         spec->codec_variant = ALC269_TYPE_ALC215;
     10888                spec->codec_variant = ALC269_TYPE_ALC215;
    1099910889                spec->shutup = alc225_shutup;
    1100010890                spec->init_hook = alc225_init;
    … …  
    1164411534        ALC897_FIXUP_LENOVO_HEADSET_MIC,
    1164511535        ALC897_FIXUP_HEADSET_MIC_PIN,
    11646         ALC897_FIXUP_HP_HSMIC_VERB,
    1164711536};
    1164811537
    … …  
    1225112140                .chained = true,
    1225212141                .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
    12253         },
    12254         [ALC897_FIXUP_HP_HSMIC_VERB] = {
    12255                 .type = HDA_FIXUP_PINS,
    12256                 .v.pins = (const struct hda_pintbl[]) {
    12257                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
    12258                         { }
    12259                 },
    1226012142        },
    1226112143#endif
    … …  
    1228512167        SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
    1228612168        SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
    12287         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
    1228812169        SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
    12289         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
    1229012170        SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
    1229112171        SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
    … …  
    1230712187        SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
    1230812188        SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
    12309         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
    1231012189        SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
    1231112190        SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
    … …  
    1266912548        HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
    1267012549        HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
    12671         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
    1267212550        {0} /* terminator */
    1267312551};

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_via.c

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

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/intel8x0.c

    r713 r736  
    31333133}
    31343134
    3135 static int __snd_intel8x0_probe(struct pci_dev *pci,
    3136                                 const struct pci_device_id *pci_id)
     3135static int snd_intel8x0_probe(struct pci_dev *pci,
     3136                              const struct pci_device_id *pci_id)
    31373137{
    31383138        struct snd_card *card;
    … …  
    32133213}
    32143214
    3215 static 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));
    3219 }
    3220 
    32213215static struct pci_driver intel8x0_driver = {
    32223216        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/korg1212/korg1212.c

    r711 r736  
    23562356        err = snd_korg1212_create(card, pci);
    23572357        if (err < 0)
    2358                 goto error;
     2358                return err;
    23592359
    23602360        strcpy(card->driver, "korg1212");
    … …  
    23672367        err = snd_card_register(card);
    23682368        if (err < 0)
    2369                 goto error;
     2369                return err;
    23702370        pci_set_drvdata(pci, card);
    23712371        dev++;
    23722372        return 0;
    2373 
    2374  error:
    2375         snd_card_free(card);
    2376         return err;
    23772373}
    23782374

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/maestro3.c

    r732 r736  
    26492649 */
    26502650static int
    2651 __snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
     2651snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
    26522652{
    26532653        static int dev;
    … …  
    27142714}
    27152715
    2716 static int
    2717 snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
    2718 {
    2719         return snd_card_free_on_error(&pci->dev, __snd_m3_probe(pci, pci_id));
    2720 }
    2721 
    27222716static struct pci_driver m3_driver = {
    27232717        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/nm256/nm256.c

    r711 r736  
    15781578
    15791579        snd_nm256_init_chip(chip);
     1580        card->private_free = snd_nm256_free;
    15801581
    15811582        // pci_set_master(pci); /* needed? */
    … …  
    16841685        if (err < 0)
    16851686                return err;
    1686         card->private_free = snd_nm256_free;
    16871687
    16881688        pci_set_drvdata(pci, card);

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/rme9652/hdsp.c

    r711 r736  
    54455445        err = snd_hdsp_create(card, hdsp);
    54465446        if (err)
    5447                 goto error;
     5447                return err;
    54485448
    54495449        strcpy(card->shortname, "Hammerfall DSP");
    … …  
    54525452        err = snd_card_register(card);
    54535453        if (err)
    5454                 goto error;
     5454                return err;
    54555455        pci_set_drvdata(pci, card);
    54565456        dev++;
    54575457        return 0;
    5458 
    5459  error:
    5460         snd_card_free(card);
    5461         return err;
    54625458}
    54635459

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/rme9652/hdspm.c

    r711 r736  
    68966896        err = snd_hdspm_create(card, hdspm);
    68976897        if (err < 0)
    6898                 goto error;
     6898                return err;
    68996899
    69006900        if (hdspm->io_type != MADIface) {
    … …  
    69156915        err = snd_card_register(card);
    69166916        if (err < 0)
    6917                 goto error;
     6917                return err;
    69186918
    69196919        pci_set_drvdata(pci, card);
    … …  
    69216921        dev++;
    69226922        return 0;
    6923 
    6924  error:
    6925         snd_card_free(card);
    6926         return err;
    69276923}
    69286924

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/rme9652/rme9652.c

    r711 r736  
    25732573        err = snd_rme9652_create(card, rme9652, precise_ptr[dev]);
    25742574        if (err)
    2575                 goto error;
     2575                return err;
    25762576
    25772577        strcpy(card->shortname, rme9652->card_name);
    … …  
    25812581        err = snd_card_register(card);
    25822582        if (err)
    2583                 goto error;
     2583                return err;
    25842584        pci_set_drvdata(pci, card);
    25852585        dev++;
    25862586        return 0;
    2587 
    2588  error:
    2589         snd_card_free(card);
    2590         return err;
    25912587}
    25922588

  • GPL/branches/uniaud32-exp/alsa-kernel/pci/via82xx.c

    r715 r736  
    24632463};
    24642464
    2465 static int __snd_via82xx_probe(struct pci_dev *pci,
    2466                                const struct pci_device_id *pci_id)
     2465static int snd_via82xx_probe(struct pci_dev *pci,
     2466                             const struct pci_device_id *pci_id)
    24672467{
    24682468        struct snd_card *card;
    … …  
    25742574}
    25752575
    2576 static 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));
    2580 }
    2581 
    25822576static struct pci_driver via82xx_driver = {
    25832577        .name = KBUILD_MODNAME,

  • GPL/branches/uniaud32-exp/include/linux/dma-mapping.h

    r697 r736  
    55#include <linux/string.h>
    66#include <linux/err.h>
    7 
    8 /* These definitions mirror those in pci.h, so they can be used
    9  * interchangeably with their PCI_ counterparts */
    10 enum dma_data_direction {
    11         DMA_BIDIRECTIONAL = 0,
    12         DMA_TO_DEVICE = 1,
    13         DMA_FROM_DEVICE = 2,
    14         DMA_NONE = 3,
    15 };
    167
    178/*
Note: See TracChangeset for help on using the changeset viewer.