Changeset 710 for GPL/branches


Ignore:
Timestamp:
Aug 5, 2022, 2:58:37 AM (3 years ago)
Author:
Paul Smedley
Message:

Update source to 5.15

Location:
GPL/branches/uniaud32-next
Files:
85 edited

Legend:

Unmodified
Added
Removed

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

    r637 r710  
    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/branches/uniaud32-next/alsa-kernel/core/init.c

    r697 r710  
    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 */
     217int snd_devm_card_new(struct device *parent, int idx, const char *xid,
     218                      struct module *module, size_t extra_size,
     219                      struct snd_card **card_ret)
     220{
     221        struct snd_card *card;
     222        int err;
     223
     224        *card_ret = NULL;
     225        card = devres_alloc(__snd_card_release, sizeof(*card) + extra_size,
     226                            GFP_KERNEL);
     227        if (!card)
     228                return -ENOMEM;
     229        card->managed = true;
     230        err = snd_card_init(card, parent, idx, xid, module, extra_size);
     231        if (err < 0) {
     232                devres_free(card);
     233                return err;
     234        }
     235
     236        devres_add(parent, card);
     237        *card_ret = card;
     238        return 0;
     239}
     240EXPORT_SYMBOL_GPL(snd_devm_card_new);
     241
     242static int snd_card_init(struct snd_card *card, struct device *parent,
     243                         int idx, const char *xid, struct module *module,
     244                         size_t extra_size)
     245{
     246        int err;
     247#ifdef CONFIG_SND_DEBUG
     248        char name[8];
     249#endif
     250
    183251        if (extra_size > 0)
    184252                card->private_data = (char *)card + sizeof(struct snd_card);
    … …  
    202270                dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
    203271                         idx, snd_ecards_limit - 1, err);
    204                 kfree(card);
    205272                return err;
    206273        }
    … …  
    261328        card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
    262329#endif
    263 
    264         *card_ret = card;
    265330        return 0;
    266331
    … …  
    271336        return err;
    272337}
    273 EXPORT_SYMBOL(snd_card_new);
    274338
    275339/**
    … …  
    489553static int snd_card_do_free(struct snd_card *card)
    490554{
     555        card->releasing = true;
    491556#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
    492557        if (snd_mixer_oss_notify_callback)
    … …  
    506571        if (card->release_completion)
    507572                complete(card->release_completion);
    508         kfree(card);
     573        if (!card->managed)
     574                kfree(card);
    509575        return 0;
    510576}
    … …  
    546612        DECLARE_COMPLETION_ONSTACK(released);
    547613        int ret;
     614
     615        /* The call of snd_card_free() is allowed from various code paths;
     616         * a manual call from the driver and the call via devres_free, and
     617         * we need to avoid double-free. Moreover, the release via devres
     618         * may call snd_card_free() twice due to its nature, we need to have
     619         * the check here at the beginning.
     620         */
     621        if (card->releasing)
     622                return 0;
    548623
    549624        card->release_completion = &released;
    … …  
    755830EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
    756831
     832static void trigger_card_free(void *data)
     833{
     834        snd_card_free(data);
     835}
     836
    757837/**
    758838 *  snd_card_register - register the soundcard
    … …  
    778858                        return err;
    779859                card->registered = true;
    780         }
    781 
     860#ifndef TARGET_OS2
     861        } else {
     862                if (card->managed)
     863                        devm_remove_action(card->dev, trigger_card_free, card);
     864#endif
     865        }
     866
     867#ifndef TARGET_OS2
     868        if (card->managed) {
     869                err = devm_add_action(card->dev, trigger_card_free, card);
     870                if (err < 0)
     871                        return err;
     872        }
     873#endif
    782874        err = snd_device_register_all(card);
    783875        if (err < 0)

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

    r697 r710  
    4141                                        gfp_flags);
    4242#ifdef CONFIG_X86
    43         if (dmab->area && dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
     43        if (dmab->area && dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
    4444                set_memory_wc((unsigned long)dmab->area,
    4545                              PAGE_ALIGN(size) >> PAGE_SHIFT);
    … …  
    6868{
    6969#ifdef CONFIG_X86
    70         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
     70        if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
    7171                set_memory_wb((unsigned long)dmab->area,
    7272                              PAGE_ALIGN(dmab->bytes) >> PAGE_SHIFT);
    … …  
    201201#endif /* CONFIG_GENERIC_ALLOCATOR */
    202202        case SNDRV_DMA_TYPE_DEV:
    203         case SNDRV_DMA_TYPE_DEV_UC:
     203        case SNDRV_DMA_TYPE_DEV_WC:
    204204#ifndef TARGET_OS2
    205205                snd_malloc_dev_pages(dmab, size);
    … …  
    211211#ifdef CONFIG_SND_DMA_SGBUF
    212212        case SNDRV_DMA_TYPE_DEV_SG:
    213         case SNDRV_DMA_TYPE_DEV_UC_SG:
     213        case SNDRV_DMA_TYPE_DEV_WC_SG:
    214214                snd_malloc_sgbuf_pages(device, size, dmab, NULL);
    215215                break;
    … …  
    283283#endif /* CONFIG_GENERIC_ALLOCATOR */
    284284        case SNDRV_DMA_TYPE_DEV:
    285         case SNDRV_DMA_TYPE_DEV_UC:
     285        case SNDRV_DMA_TYPE_DEV_WC:
    286286#ifndef TARGET_OS2
    287287                snd_free_dev_pages(dmab);
    … …  
    293293#ifdef CONFIG_SND_DMA_SGBUF
    294294        case SNDRV_DMA_TYPE_DEV_SG:
    295         case SNDRV_DMA_TYPE_DEV_UC_SG:
     295        case SNDRV_DMA_TYPE_DEV_WC_SG:
    296296                snd_free_sgbuf_pages(dmab);
    297297                break;

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

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/core/pcm_memory.c

    r697 r710  
    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
    … …  
    223226 * pre-allocate the buffer and create a proc file for the substream
    224227 */
    225 static void preallocate_pages(struct snd_pcm_substream *substream,
     228static int preallocate_pages(struct snd_pcm_substream *substream,
    226229                              int type, struct device *data,
    227230                              size_t size, size_t max, bool managed)
    228231{
     232        int err;
     233
    229234        if (snd_BUG_ON(substream->dma_buffer.dev.type))
    230                 return;
     235                return -EINVAL;
    231236
    232237        substream->dma_buffer.dev.type = type;
    233238        substream->dma_buffer.dev.dev = data;
    234239
    235         if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
    236                 preallocate_pcm_pages(substream, size);
     240        if (size > 0) {
     241                if (!max) {
     242                        /* no fallback, only also inform -ENOMEM */
     243                        err = preallocate_pcm_pages(substream, size, true);
     244                        if (err < 0)
     245                                return err;
     246                } else if (preallocate_dma &&
     247                           substream->number < maximum_substreams) {
     248                        err = preallocate_pcm_pages(substream, size, false);
     249                        if (err < 0 && err != -ENOMEM)
     250                                return err;
     251                }
     252        }
    237253
    238254        if (substream->dma_buffer.bytes > 0)
    … …  
    243259        if (managed)
    244260                substream->managed_buffer_alloc = 1;
    245 }
    246 
    247 static void preallocate_pages_for_all(struct snd_pcm *pcm, int type,
     261        return 0;
     262}
     263
     264static int preallocate_pages_for_all(struct snd_pcm *pcm, int type,
    248265                                      void *data, size_t size, size_t max,
    249266                                      bool managed)
    250267{
    251268        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);
     269        int stream, err;
     270
     271        for_each_pcm_substream(pcm, stream, substream) {
     272                err = preallocate_pages(substream, type, data, size, max, managed);
     273                if (err < 0)
     274                        return err;
     275        }
     276        return 0;
    256277}
    257278
    … …  
    310331 * turns on the runtime buffer_changed flag for drivers changing their h/w
    311332 * parameters accordingly.
    312  */
    313 void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
     333 *
     334 * When @size is non-zero and @max is zero, this tries to allocate for only
     335 * the exact buffer size without fallback, and may return -ENOMEM.
     336 * Otherwise, the function tries to allocate smaller chunks if the allocation
     337 * fails.  This is the behavior of snd_pcm_set_fixed_buffer().
     338 *
     339 * When both @size and @max are zero, the function only sets up the buffer
     340 * for later dynamic allocations. It's used typically for buffers with
     341 * SNDRV_DMA_TYPE_VMALLOC type.
     342 *
     343 * Upon successful buffer allocation and setup, the function returns 0.
     344 */
     345int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
    314346                                struct device *data, size_t size, size_t max)
    315347{
    316         preallocate_pages(substream, type, data, size, max, true);
     348        return preallocate_pages(substream, type, data, size, max, true);
    317349}
    318350EXPORT_SYMBOL(snd_pcm_set_managed_buffer);
    … …  
    330362 * type and size, and set the managed_buffer_alloc flag to each substream.
    331363 */
    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);
     364int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
     365                                   struct device *data,
     366                                   size_t size, size_t max)
     367{
     368        return preallocate_pages_for_all(pcm, type, data, size, max, true);
    337369}
    338370EXPORT_SYMBOL(snd_pcm_set_managed_buffer_all);
    … …  
    377409                dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
    378410        } else {
     411                /* dma_max=0 means the fixed size preallocation */
     412                if (substream->dma_buffer.area && !substream->dma_max)
     413                        return -ENOMEM;
    379414                dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
    380415                if (! dmab)

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

    r697 r710  
    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}
    … …  
    36663671static bool pcm_status_mmap_allowed(struct snd_pcm_file *pcm_file)
    36673672{
     3673        /* If drivers require the explicit sync (typically for non-coherent
     3674         * pages), we have to disable the mmap of status and control data
     3675         * to enforce the control via SYNC_PTR ioctl.
     3676         */
     3677        if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC)
     3678                return false;
    36683679        /* See pcm_control_mmap_allowed() below.
    36693680         * Since older alsa-lib requires both status and control mmaps to be
    … …  
    36793690{
    36803691        if (pcm_file->no_compat_mmap)
     3692                return false;
     3693        /* see above */
     3694        if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC)
    36813695                return false;
    36823696        /* Disallow the control mmap when SYNC_APPLPTR flag is set;

  • GPL/branches/uniaud32-next/alsa-kernel/core/rawmidi.c

    r697 r710  
    894894                }
    895895        }
     896        case SNDRV_RAWMIDI_IOCTL_USER_PVERSION:
     897                if (get_user(rfile->user_pversion, (unsigned int __user *)arg))
     898                        return -EFAULT;
     899                return 0;
     900
    896901        case SNDRV_RAWMIDI_IOCTL_PARAMS:
    897902        {
    … …  
    900905                if (copy_from_user(&params, argp, sizeof(struct snd_rawmidi_params)))
    901906                        return -EFAULT;
     907                if (rfile->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 2)) {
     908                        params.mode = 0;
     909                        memset(params.reserved, 0, sizeof(params.reserved));
     910                }
    902911                switch (params.stream) {
    903912                case SNDRV_RAWMIDI_STREAM_OUTPUT:

  • GPL/branches/uniaud32-next/alsa-kernel/core/seq/seq_dummy.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/core/seq_device.c

    r694 r710  
    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/branches/uniaud32-next/alsa-kernel/core/sgbuf.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/drivers/mpu401/mpu401.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/hda/hdac_controller.c

    r693 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/compress_driver.h

    r692 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/core.h

    r697 r710  
    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);
    … …  
    328333void snd_dma_disable(unsigned long dma);
    329334unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
     335int snd_devm_request_dma(struct device *dev, int dma, const char *name);
    330336#endif
    331337

  • GPL/branches/uniaud32-next/alsa-kernel/include/sound/emu10k1.h

    r615 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/emu8000.h

    r615 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/hda_codec.h

    r692 r710  
    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};
    … …  
    226225
    227226        /* misc flags */
     227        unsigned int configured:1; /* codec was configured */
    228228        unsigned int in_freeing:1; /* being released */
    229229        unsigned int registered:1; /* codec was registered */

  • GPL/branches/uniaud32-next/alsa-kernel/include/sound/hdaudio_ext.h

    r693 r710  
    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 {

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

    r697 r710  
    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);
    8285#endif /* __SOUND_MEMALLOC_H */
    8386

  • GPL/branches/uniaud32-next/alsa-kernel/include/sound/pcm.h

    r697 r710  
    12251225int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
    12261226
    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);
     1227int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
     1228                               struct device *data, size_t size, size_t max);
     1229int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
     1230                                   struct device *data,
     1231                                   size_t size, size_t max);
     1232
     1233/**
     1234 * snd_pcm_set_fixed_buffer - Preallocate and set up the fixed size PCM buffer
     1235 * @substream: the pcm substream instance
     1236 * @type: DMA type (SNDRV_DMA_TYPE_*)
     1237 * @data: DMA type dependent data
     1238 * @size: the requested pre-allocation size in bytes
     1239 *
     1240 * This is a variant of snd_pcm_set_managed_buffer(), but this pre-allocates
     1241 * only the given sized buffer and doesn't allow re-allocation nor dynamic
     1242 * allocation of a larger buffer unlike the standard one.
     1243 * The function may return -ENOMEM error, hence the caller must check it.
     1244 */
     1245static inline int __must_check
     1246snd_pcm_set_fixed_buffer(struct snd_pcm_substream *substream, int type,
     1247                                 struct device *data, size_t size)
     1248{
     1249        return snd_pcm_set_managed_buffer(substream, type, data, size, 0);
     1250}
     1251
     1252/**
     1253 * snd_pcm_set_fixed_buffer_all - Preallocate and set up the fixed size PCM buffer
     1254 * @pcm: the pcm instance
     1255 * @type: DMA type (SNDRV_DMA_TYPE_*)
     1256 * @data: DMA type dependent data
     1257 * @size: the requested pre-allocation size in bytes
     1258 *
     1259 * Apply the set up of the fixed buffer via snd_pcm_set_fixed_buffer() for
     1260 * all substream.  If any of allocation fails, it returns -ENOMEM, hence the
     1261 * caller must check the return value.
     1262 */
     1263static inline int __must_check
     1264snd_pcm_set_fixed_buffer_all(struct snd_pcm *pcm, int type,
     1265                             struct device *data, size_t size)
     1266{
     1267        return snd_pcm_set_managed_buffer_all(pcm, type, data, size, 0);
     1268}
    12321269
    12331270int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,

  • GPL/branches/uniaud32-next/alsa-kernel/include/sound/pxa2xx-lib.h

    r629 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/rawmidi.h

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

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

    r694 r710  
    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/branches/uniaud32-next/alsa-kernel/include/sound/version.h

    r697 r710  
    11/* include/version.h */
    2 #define CONFIG_SND_VERSION "5.14.7"
     2#define CONFIG_SND_VERSION "5.15"
    33#define CONFIG_SND_DATE ""

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

    r697 r710  
    324324#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME    0x04000000  /* report estimated link audio time */
    325325#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000  /* report synchronized audio/system time */
     326#define SNDRV_PCM_INFO_EXPLICIT_SYNC    0x10000000      /* needs explicit sync of pointers and data */
    326327
    327328#define SNDRV_PCM_INFO_DRAIN_TRIGGER    0x40000000              /* internal kernel flag - trigger in drain */
    … …  
    825826#define SNDRV_RAWMIDI_IOCTL_PVERSION    _IOR('W', 0x00, int)
    826827#define SNDRV_RAWMIDI_IOCTL_INFO        _IOR('W', 0x01, struct snd_rawmidi_info)
     828#define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int)
    827829#define SNDRV_RAWMIDI_IOCTL_PARAMS      _IOWR('W', 0x10, struct snd_rawmidi_params)
    828830#define SNDRV_RAWMIDI_IOCTL_STATUS      _IOWR('W', 0x20, struct snd_rawmidi_status)

  • GPL/branches/uniaud32-next/alsa-kernel/isa/sb/sb_common.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/ali5451/ali5451.c

    r693 r710  
    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}
    … …  
    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));
    22252178}
    22262179
    … …  
    22292182        .id_table = snd_ali_ids,
    22302183        .probe = snd_ali_probe,
    2231         .remove = snd_ali_remove,
    22322184        .driver = {
    22332185                .pm = ALI_PM_OPS,

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

    r697 r710  
    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);
    816810}
    817811
    … …  
    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;
    958934}
    959935
    … …  
    1000976        .id_table = snd_als4000_ids,
    1001977        .probe = snd_card_als4000_probe,
    1002         .remove = snd_card_als4000_remove,
    1003978        .driver = {
    1004979                .pm = SND_ALS4000_PM_OPS,

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

    r697 r710  
    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        if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt,
     1581                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
     1582                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     1583                return -EBUSY;
     1584        }
     1585#else
    16001586        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 
    16071587        if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
    16081588                        KBUILD_MODNAME, chip)) {
    … …  
    16111591                return -EBUSY;
    16121592        }
     1593#endif
    16131594        chip->irq = pci->irq;
    16141595        card->sync_irq = chip->irq;
     1596        card->private_free = snd_atiixp_free;
    16151597        pci_set_master(pci);
    16161598
    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;
    16241599        return 0;
    16251600}
    … …  
    16331608        int err;
    16341609
    1635         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     1610        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     1611                                sizeof(*chip), &card);
    16361612        if (err < 0)
    16371613                return err;
     1614        chip = card->private_data;
    16381615
    16391616        strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA");
    16401617        strcpy(card->shortname, "ATI IXP");
    1641         err = snd_atiixp_create(card, pci, &chip);
     1618        err = snd_atiixp_init(card, pci);
    16421619        if (err < 0)
    1643                 goto __error;
    1644         card->private_data = chip;
     1620                return err;
    16451621
    16461622        err = snd_atiixp_aclink_reset(chip);
    16471623        if (err < 0)
    1648                 goto __error;
     1624                return err;
    16491625
    16501626        chip->spdif_over_aclink = spdif_aclink;
    … …  
    16521628        err = snd_atiixp_mixer_new(chip, ac97_clock, ac97_quirk);
    16531629        if (err < 0)
    1654                 goto __error;
     1630                return err;
    16551631
    16561632        err = snd_atiixp_pcm_new(chip);
    16571633        if (err < 0)
    1658                 goto __error;
     1634                return err;
    16591635       
    16601636        snd_atiixp_proc_init(chip);
    … …  
    16741650        err = snd_card_register(card);
    16751651        if (err < 0)
    1676                 goto __error;
     1652                return err;
    16771653
    16781654        pci_set_drvdata(pci, card);
    16791655        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));
    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/branches/uniaud32-next/alsa-kernel/pci/au88x0/au88x0.c

    r697 r710  
    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
    … …  
    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));
    386 }
    387 
    388313// pci_driver definition
    389314static struct pci_driver vortex_driver = {
    … …  
    391316        .id_table = snd_vortex_ids,
    392317        .probe = snd_vortex_probe,
    393         .remove = snd_vortex_remove,
    394318};
    395319

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

    r697 r710  
    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
    … …  
    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));
    946908}
    947909
    … …  
    958920        .id_table = snd_bt87x_ids,
    959921        .probe = snd_bt87x_probe,
    960         .remove = snd_bt87x_remove,
    961922};
    962923

  • GPL/branches/uniaud32-next/alsa-kernel/pci/ca0106/ca0106.h

    r629 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/ca0106/ca0106_main.c

    r697 r710  
    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. */
     1614#ifndef TARGET_OS2
     1615        chip->buffer = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024);
     1616        if (!chip->buffer)
     1617                return -ENOMEM;
     1618#else
    16521619        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    16531620                                1024, &chip->buffer) < 0) {
    … …  
    16551622                return -ENOMEM;
    16561623        }
    1657 
     1624#endif
    16581625        pci_set_master(pci);
    16591626        /* read serial */
    … …  
    16831650
    16841651        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;
    16921652        return 0;
    16931653}
    … …  
    17921752        }
    17931753
    1794         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1795                            0, &card);
     1754        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1755                                sizeof(*chip), &card);
    17961756        if (err < 0)
    17971757                return err;
    1798 
    1799         err = snd_ca0106_create(dev, card, pci, &chip);
     1758        chip = card->private_data;
     1759
     1760        err = snd_ca0106_create(dev, card, pci);
    18001761        if (err < 0)
    1801                 goto error;
    1802         card->private_data = chip;
     1762                return err;
     1763        card->private_free = snd_ca0106_free;
    18031764
    18041765        for (i = 0; i < 4; i++) {
    18051766                err = snd_ca0106_pcm(chip, i);
    18061767                if (err < 0)
    1807                         goto error;
     1768                        return err;
    18081769        }
    18091770
    … …  
    18121773                err = snd_ca0106_ac97(chip);
    18131774                if (err < 0)
    1814                         goto error;
     1775                        return err;
    18151776        }
    18161777        err = snd_ca0106_mixer(chip);
    18171778        if (err < 0)
    1818                 goto error;
     1779                return err;
    18191780
    18201781        dev_dbg(card->dev, "probe for MIDI channel A ...");
    18211782        err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
    18221783        if (err < 0)
    1823                 goto error;
     1784                return err;
    18241785        dev_dbg(card->dev, " done.\n");
    18251786
    … …  
    18301791        err = snd_card_register(card);
    18311792        if (err < 0)
    1832                 goto error;
     1793                return err;
    18331794
    18341795        pci_set_drvdata(pci, card);
    18351796        dev++;
    18361797        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));
    18461798}
    18471799
    … …  
    18991851        .id_table = snd_ca0106_ids,
    19001852        .probe = snd_ca0106_probe,
    1901         .remove = snd_ca0106_remove,
    19021853        .driver = {
    19031854                .pm = SND_CA0106_PM_OPS,

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

    r697 r710  
    28732873                for (i = 0; ports[i]; i++) {
    28742874                        io_port = ports[i];
    2875                         r = request_region(io_port, 1, "CMIPCI gameport");
     2875                        r = devm_request_region(&cm->pci->dev, io_port, 1,
     2876                                                "CMIPCI gameport");
    28762877                        if (r)
    28772878                                break;
    … …  
    28792880        } else {
    28802881                io_port = joystick_port[dev];
    2881                 r = request_region(io_port, 1, "CMIPCI gameport");
     2882                r = devm_request_region(&cm->pci->dev, io_port, 1,
     2883                                        "CMIPCI gameport");
    28822884        }
    28832885
    … …  
    28902892        if (!gp) {
    28912893                dev_err(cm->card->dev, "cannot allocate memory for gameport\n");
    2892                 release_and_free_resource(r);
    28932894                return -ENOMEM;
    28942895        }
    … …  
    28972898        gameport_set_dev_parent(gp, &cm->pci->dev);
    28982899        gp->io = io_port;
    2899         gameport_set_port_data(gp, r);
    29002900
    29012901        snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    … …  
    29092909{
    29102910        if (cm->gameport) {
    2911                 struct resource *r = gameport_get_port_data(cm->gameport);
    2912 
    29132911                gameport_unregister_port(cm->gameport);
    29142912                cm->gameport = NULL;
    29152913
    29162914                snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    2917                 release_and_free_resource(r);
    29182915        }
    29192916}
    … …  
    29232920#endif
    29242921
    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         }
     2922static void snd_cmipci_free(struct snd_card *card)
     2923{
     2924        struct cmipci *cm = card->private_data;
     2925
     2926        snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN);
     2927        snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_ENSPDOUT);
     2928        snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);  /* disable ints */
     2929        snd_cmipci_ch_reset(cm, CM_CH_PLAY);
     2930        snd_cmipci_ch_reset(cm, CM_CH_CAPT);
     2931        snd_cmipci_write(cm, CM_REG_FUNCTRL0, 0); /* disable channels */
     2932        snd_cmipci_write(cm, CM_REG_FUNCTRL1, 0);
     2933
     2934        /* reset mixer */
     2935        snd_cmipci_mixer_write(cm, 0, 0);
    29412936
    29422937        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);
    29532938}
    29542939
    … …  
    30092994
    30102995static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci,
    3011                              int dev, struct cmipci **rcmipci)
    3012 {
    3013         struct cmipci *cm;
     2996                             int dev)
     2997{
     2998        struct cmipci *cm = card->private_data;
    30142999        int err;
    3015         static const struct snd_device_ops ops = {
    3016                 .dev_free =     snd_cmipci_dev_free,
    3017         };
    30183000        unsigned int val;
    30193001        long iomidi = 0;
    … …  
    30263008        };
    30273009
    3028         *rcmipci = NULL;
    3029 
    3030         err = pci_enable_device(pci);
     3010        err = pcim_enable_device(pci);
    30313011        if (err < 0)
    30323012                return err;
    3033 
    3034         cm = kzalloc(sizeof(*cm), GFP_KERNEL);
    3035         if (cm == NULL) {
    3036                 pci_disable_device(pci);
    3037                 return -ENOMEM;
    3038         }
    30393013
    30403014        spin_lock_init(&cm->reg_lock);
    … …  
    30493023
    30503024        err = pci_request_regions(pci, card->driver);
    3051         if (err < 0) {
    3052                 kfree(cm);
    3053                 pci_disable_device(pci);
     3025        if (err < 0)
    30543026                return err;
    3055         }
    30563027        cm->iobase = pci_resource_start(pci, 0);
    30573028
     3029#ifndef TARGET_OS2
     3030        if (devm_request_irq(&pci->dev, pci->irq, snd_cmipci_interrupt,
     3031                             IRQF_SHARED, KBUILD_MODNAME, cm)) {
     3032                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     3033                return -EBUSY;
     3034        }
     3035#else
    30583036        if (request_irq(pci->irq, snd_cmipci_interrupt,
    30593037                        IRQF_SHARED, KBUILD_MODNAME, cm)) {
    … …  
    30623040                return -EBUSY;
    30633041        }
     3042#endif
    30643043        cm->irq = pci->irq;
    30653044        card->sync_irq = cm->irq;
     3045        card->private_free = snd_cmipci_free;
    30663046
    30673047        pci_set_master(cm->pci);
    … …  
    31633143                card->shortname, modelstr, cm->iobase, cm->irq);
    31643144
    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 
    31713145        if (cm->chip_version >= 39) {
    31723146                val = snd_cmipci_read_b(cm, CM_REG_MPU_PCI + 1);
    … …  
    32613235                snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
    32623236
    3263         *rcmipci = cm;
    32643237        return 0;
    32653238}
    … …  
    32853258        }
    32863259
    3287         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    3288                            0, &card);
     3260        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     3261                                sizeof(*cm), &card);
    32893262        if (err < 0)
    32903263                return err;
     3264        cm = card->private_data;
    32913265       
    32923266        switch (pci->device) {
    … …  
    33043278        }
    33053279
    3306         err = snd_cmipci_create(card, pci, dev, &cm);
     3280        err = snd_cmipci_create(card, pci, dev);
    33073281        if (err < 0)
    3308                 goto free_card;
    3309 
    3310         card->private_data = cm;
     3282                return err;
    33113283
    33123284        err = snd_card_register(card);
    33133285        if (err < 0)
    3314                 goto free_card;
     3286                return err;
    33153287
    33163288        pci_set_drvdata(pci, card);
    33173289        dev++;
    33183290        return 0;
    3319 
    3320 free_card:
    3321         snd_card_free(card);
    3322         return err;
    3323 }
    3324 
    3325 static void snd_cmipci_remove(struct pci_dev *pci)
    3326 {
    3327         snd_card_free(pci_get_drvdata(pci));
    3328 }
    3329 
     3291}
    33303292
    33313293#ifdef CONFIG_PM_SLEEP
    … …  
    34033365        .id_table = snd_cmipci_ids,
    34043366        .probe = snd_cmipci_probe,
    3405         .remove = snd_cmipci_remove,
    34063367        .driver = {
    34073368                .pm = SND_CMIPCI_PM_OPS,

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

    r697 r710  
    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        if (devm_request_irq(&pci->dev, pci->irq, snd_cs4281_interrupt,
     1330                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
     1331                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     1332                return -ENOMEM;
     1333        }
     1334#else
    13471335        chip->ba0 = pci_ioremap_bar(pci, 0);
    13481336        chip->ba1 = pci_ioremap_bar(pci, 1);
    1349         if (!chip->ba0 || !chip->ba1) {
    1350                 snd_cs4281_free(chip);
    1351                 return -ENOMEM;
    1352         }
    1353        
    13541337        if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
    13551338                        KBUILD_MODNAME, chip)) {
    … …  
    13581341                return -ENOMEM;
    13591342        }
     1343#endif 
    13601344        chip->irq = pci->irq;
    13611345        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);
     1346        card->private_free = snd_cs4281_free;
     1347
     1348        err = snd_cs4281_chip_init(chip);
     1349        if (err)
    13721350                return err;
    1373         }
    13741351
    13751352        snd_cs4281_proc_init(chip);
    1376 
    1377         *rchip = chip;
    13781353        return 0;
    13791354}
    … …  
    18911866        }
    18921867
    1893         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1894                            0, &card);
     1868        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1869                                sizeof(*chip), &card);
    18951870        if (err < 0)
    18961871                return err;
    1897 
    1898         err = snd_cs4281_create(card, pci, &chip, dual_codec[dev]);
    1899         if (err < 0) {
    1900                 snd_card_free(card);
     1872        chip = card->private_data;
     1873
     1874        err = snd_cs4281_create(card, pci, dual_codec[dev]);
     1875        if (err < 0)
    19011876                return err;
    1902         }
    1903         card->private_data = chip;
    19041877
    19051878        err = snd_cs4281_mixer(chip);
    1906         if (err < 0) {
    1907                 snd_card_free(card);
     1879        if (err < 0)
    19081880                return err;
    1909         }
    19101881        err = snd_cs4281_pcm(chip, 0);
    1911         if (err < 0) {
    1912                 snd_card_free(card);
     1882        if (err < 0)
    19131883                return err;
    1914         }
    19151884        err = snd_cs4281_midi(chip, 0);
    1916         if (err < 0) {
    1917                 snd_card_free(card);
     1885        if (err < 0)
    19181886                return err;
    1919         }
    19201887        err = snd_opl3_new(card, OPL3_HW_OPL3_CS4281, &opl3);
    1921         if (err < 0) {
    1922                 snd_card_free(card);
     1888        if (err < 0)
    19231889                return err;
    1924         }
    19251890        opl3->private_data = chip;
    19261891        opl3->command = snd_cs4281_opl3_command;
    19271892        snd_opl3_init(opl3);
    19281893        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    1929         if (err < 0) {
    1930                 snd_card_free(card);
     1894        if (err < 0)
    19311895                return err;
    1932         }
    19331896        snd_cs4281_create_gameport(chip);
    19341897        strcpy(card->driver, "CS4281");
    … …  
    19401903
    19411904        err = snd_card_register(card);
    1942         if (err < 0) {
    1943                 snd_card_free(card);
     1905        if (err < 0)
    19441906                return err;
    1945         }
    19461907
    19471908        pci_set_drvdata(pci, card);
    19481909        dev++;
    19491910        return 0;
    1950 }
    1951 
    1952 static void snd_cs4281_remove(struct pci_dev *pci)
    1953 {
    1954         snd_card_free(pci_get_drvdata(pci));
    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/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx.c

    r697 r710  
    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);
     82                                external_amp[dev], thinkpad[dev]);
     83        if (err < 0)
    8584                return err;
    86         }
    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);
     88        if (err < 0)
    9289                return err;
    93         }
    9490#ifdef CONFIG_SND_CS46XX_NEW_DSP
    9591        err = snd_cs46xx_pcm_rear(chip, 1);
    96         if (err < 0) {
    97                 snd_card_free(card);
     92        if (err < 0)
    9893                return err;
    99         }
    10094        err = snd_cs46xx_pcm_iec958(chip, 2);
    101         if (err < 0) {
    102                 snd_card_free(card);
     95        if (err < 0)
    10396                return err;
    104         }
    10597#endif
    10698        err = snd_cs46xx_mixer(chip, 2);
    107         if (err < 0) {
    108                 snd_card_free(card);
     99        if (err < 0)
    109100                return err;
    110         }
    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);
     104                if (err < 0)
    116105                        return err;
    117                 }
    118106        }
    119107#endif
    120108        err = snd_cs46xx_midi(chip, 0);
    121         if (err < 0) {
    122                 snd_card_free(card);
     109        if (err < 0)
    123110                return err;
    124         }
    125111        err = snd_cs46xx_start_dsp(chip);
    126         if (err < 0) {
    127                 snd_card_free(card);
     112        if (err < 0)
    128113                return err;
    129         }
    130 
    131114
    132115        snd_cs46xx_gameport(chip);
    … …  
    141124
    142125        err = snd_card_register(card);
    143         if (err < 0) {
    144                 snd_card_free(card);
     126        if (err < 0)
    145127                return err;
    146         }
    147128
    148129        pci_set_drvdata(pci, card);
    … …  
    151132}
    152133
    153 static void snd_card_cs46xx_remove(struct pci_dev *pci)
    154 {
    155         snd_card_free(pci_get_drvdata(pci));
    156 }
    157 
    158134static struct pci_driver cs46xx_driver = {
    159135        .name = KBUILD_MODNAME,
    160136        .id_table = snd_cs46xx_ids,
    161137        .probe = snd_card_cs46xx_probe,
    162         .remove = snd_card_cs46xx_remove,
    163138#ifdef CONFIG_PM_SLEEP
    164139        .driver = {

  • GPL/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx.h

    r615 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx_lib.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/cs5530.c

    r629 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/cs5535audio/cs5535audio.c

    r697 r710  
    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;
    329286}
    330287
    … …  
    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));
    389336}
    390337
    … …  
    393340        .id_table = snd_cs5535audio_ids,
    394341        .probe = snd_cs5535audio_probe,
    395         .remove = snd_cs5535audio_remove,
    396342#ifdef CONFIG_PM_SLEEP
    397343        .driver = {

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

    r697 r710  
    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. */
     142#ifndef TARGET_OS2
     143        if (emu->card_capabilities->ca0151_chip) { /* P16V */   
     144                emu->p16v_buffer =
     145                        snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024);
     146                if (!emu->p16v_buffer)
     147                        return -ENOMEM;
     148        }
     149#else
    142150        if (emu->card_capabilities->ca0151_chip) { /* P16V */   
    143151                err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    144152                                          1024, &emu->p16v_buffer);
    145153                if (err < 0)
    146                         goto error;
    147         }
    148 
     154                        return -ENOMEM;
     155        }
     156#endif
    149157        err = snd_emu10k1_mixer(emu, 0, 3);
    150158        if (err < 0)
    151                 goto error;
     159                return err;
    152160       
    153161        err = snd_emu10k1_timer(emu, 0);
    154162        if (err < 0)
    155                 goto error;
     163                return err;
    156164
    157165        err = snd_emu10k1_pcm_multi(emu, 3);
    158166        if (err < 0)
    159                 goto error;
     167                return err;
    160168        if (emu->card_capabilities->ca0151_chip) { /* P16V */
    161169                err = snd_p16v_pcm(emu, 4);
    162170                if (err < 0)
    163                         goto error;
     171                        return err;
    164172        }
    165173        if (emu->audigy) {
    166174                err = snd_emu10k1_audigy_midi(emu);
    167175                if (err < 0)
    168                         goto error;
     176                        return err;
    169177        } else {
    170178                err = snd_emu10k1_midi(emu);
    171179                if (err < 0)
    172                         goto error;
     180                        return err;
    173181        }
    174182        err = snd_emu10k1_fx8010_new(emu, 0);
    175183        if (err < 0)
    176                 goto error;
     184                return err;
    177185#ifdef ENABLE_SYNTH
    178186        if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
    … …  
    202210        err = snd_card_register(card);
    203211        if (err < 0)
    204                 goto error;
     212                return err;
    205213
    206214        if (emu->card_capabilities->emu_model)
    … …  
    210218        dev++;
    211219        return 0;
    212 
    213  error:
    214         snd_card_free(card);
    215         return err;
    216220}
    217 
    218 static void snd_card_emu10k1_remove(struct pci_dev *pci)
    219 {
    220         snd_card_free(pci_get_drvdata(pci));
    221 }
    222 
    223221
    224222#ifdef CONFIG_PM_SLEEP
    … …  
    278276        .id_table = snd_emu10k1_ids,
    279277        .probe = snd_card_emu10k1_probe,
    280         .remove = snd_card_emu10k1_remove,
    281278        .driver = {
    282279                .pm = SND_EMU10K1_PM_OPS,

  • GPL/branches/uniaud32-next/alsa-kernel/pci/emu10k1/emu10k1_main.c

    r693 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/emu10k1/emu10k1x.c

    r697 r710  
    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}
    … …  
    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);
    16221560        dev++;
    16231561        return 0;
    1624 }
    1625 
    1626 static void snd_emu10k1x_remove(struct pci_dev *pci)
    1627 {
    1628         snd_card_free(pci_get_drvdata(pci));
    16291562}
    16301563
    … …  
    16411574        .id_table = snd_emu10k1x_ids,
    16421575        .probe = snd_emu10k1x_probe,
    1643         .remove = snd_emu10k1x_remove,
    16441576};
    16451577

  • GPL/branches/uniaud32-next/alsa-kernel/pci/emu10k1/p16v.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/ens1370.c

    r697 r710  
    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)) {
    … …  
    20722048                return -EBUSY;
    20732049        }
     2050#endif
    20742051        ensoniq->irq = pci->irq;
    20752052        card->sync_irq = ensoniq->irq;
    20762053#ifdef CHIP1370
     2054#ifndef TARGET_OS2
     2055        ensoniq->dma_bug =
     2056                snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 16);
     2057        if (!ensoniq->dma_bug)
     2058                return -ENOMEM;
     2059#else
    20772060        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    20782061                                16, &ensoniq->dma_bug) < 0) {
    … …  
    20812064                return -EBUSY;
    20822065        }
     2066#endif
    20832067#endif
    20842068        pci_set_master(pci);
    … …  
    21072091#endif
    21082092
     2093        card->private_free = snd_ensoniq_free;
    21092094        snd_ensoniq_chip_init(ensoniq);
    21102095
    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 
    21172096        snd_ensoniq_proc_init(ensoniq);
    2118 
    2119         *rensoniq = ensoniq;
    21202097        return 0;
    21212098}
    … …  
    23682345        }
    23692346
    2370         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2371                            0, &card);
     2347        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2348                                sizeof(*ensoniq), &card);
    23722349        if (err < 0)
    23732350                return err;
    2374 
    2375         err = snd_ensoniq_create(card, pci, &ensoniq);
    2376         if (err < 0) {
    2377                 snd_card_free(card);
     2351        ensoniq = card->private_data;
     2352
     2353        err = snd_ensoniq_create(card, pci);
     2354        if (err < 0)
    23782355                return err;
    2379         }
    2380         card->private_data = ensoniq;
    23812356
    23822357#ifdef CHIP1370
    23832358        err = snd_ensoniq_1370_mixer(ensoniq);
    2384         if (err < 0) {
    2385                 snd_card_free(card);
     2359        if (err < 0)
    23862360                return err;
    2387         }
    23882361#endif
    23892362#ifdef CHIP1371
    23902363        err = snd_ensoniq_1371_mixer(ensoniq, spdif[dev], lineio[dev]);
    2391         if (err < 0) {
    2392                 snd_card_free(card);
     2364        if (err < 0)
    23932365                return err;
    2394         }
    23952366#endif
    23962367        err = snd_ensoniq_pcm(ensoniq, 0);
    2397         if (err < 0) {
    2398                 snd_card_free(card);
     2368        if (err < 0)
    23992369                return err;
    2400         }
    24012370        err = snd_ensoniq_pcm2(ensoniq, 1);
    2402         if (err < 0) {
    2403                 snd_card_free(card);
     2371        if (err < 0)
    24042372                return err;
    2405         }
    24062373        err = snd_ensoniq_midi(ensoniq, 0);
    2407         if (err < 0) {
    2408                 snd_card_free(card);
     2374        if (err < 0)
    24092375                return err;
    2410         }
    24112376
    24122377        snd_ensoniq_create_gameport(ensoniq, dev);
    … …  
    24222387
    24232388        err = snd_card_register(card);
    2424         if (err < 0) {
    2425                 snd_card_free(card);
     2389        if (err < 0)
    24262390                return err;
    2427         }
    24282391
    24292392        pci_set_drvdata(pci, card);
    24302393        dev++;
    24312394        return 0;
    2432 }
    2433 
    2434 static void snd_audiopci_remove(struct pci_dev *pci)
    2435 {
    2436         snd_card_free(pci_get_drvdata(pci));
    24372395}
    24382396
    … …  
    24412399        .id_table = snd_audiopci_ids,
    24422400        .probe = snd_audiopci_probe,
    2443         .remove = snd_audiopci_remove,
    24442401        .driver = {
    24452402                .pm = SND_ENSONIQ_PM_OPS,

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

    r697 r710  
    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}
    … …  
    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);
    18731830        dev++;
    18741831        return 0;
    1875 }
    1876 
    1877 static void snd_es1938_remove(struct pci_dev *pci)
    1878 {
    1879         snd_card_free(pci_get_drvdata(pci));
    18801832}
    18811833
    … …  
    18841836        .id_table = snd_es1938_ids,
    18851837        .probe = snd_es1938_probe,
    1886         .remove = snd_es1938_remove,
    18871838        .driver = {
    18881839                .pm = ES1938_PM_OPS,

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

    r697 r710  
    24792479                return -ENODEV;
    24802480
     2481#ifndef TARGET_OS2
     2482        r = devm_request_region(&chip->pci->dev, JOYSTICK_ADDR, 8,
     2483                                "ES1968 gameport");
     2484#else
    24812485        r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
     2486#endif
    24822487        if (!r)
    24832488                return -EBUSY;
    … …  
    24872492                dev_err(chip->card->dev,
    24882493                        "cannot allocate memory for gameport\n");
    2489                 release_and_free_resource(r);
    24902494                return -ENOMEM;
    24912495        }
    … …  
    24982502        gameport_set_dev_parent(gp, &chip->pci->dev);
    24992503        gp->io = JOYSTICK_ADDR;
    2500         gameport_set_port_data(gp, r);
    25012504
    25022505        gameport_register_port(gp);
    … …  
    25082511{
    25092512        if (chip->gameport) {
    2510                 struct resource *r = gameport_get_port_data(chip->gameport);
    2511 
    25122513                gameport_unregister_port(chip->gameport);
    25132514                chip->gameport = NULL;
    2514 
    2515                 release_and_free_resource(r);
    25162515        }
    25172516}
    … …  
    25272526        int err;
    25282527
    2529         input_dev = input_allocate_device();
     2528        input_dev = devm_input_allocate_device(&chip->pci->dev);
    25302529        if (!input_dev)
    25312530                return -ENOMEM;
    … …  
    25472546
    25482547        err = input_register_device(input_dev);
    2549         if (err) {
    2550                 input_free_device(input_dev);
     2548        if (err)
    25512549                return err;
    2552         }
    25532550
    25542551        chip->input_dev = input_dev;
    … …  
    26342631#endif
    26352632
    2636 static int snd_es1968_free(struct es1968 *chip)
    2637 {
     2633static void snd_es1968_free(struct snd_card *card)
     2634{
     2635        struct es1968 *chip = card->private_data;
     2636
    26382637        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
    26432638
    26442639        if (chip->io_port) {
    … …  
    26522647#endif
    26532648
    2654         if (chip->irq >= 0)
    2655                 free_irq(chip->irq, chip);
    26562649        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);
    26672650}
    26682651
    … …  
    26942677                             int chip_type,
    26952678                             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;
     2679                             int radio_nr)
     2680{
     2681        struct es1968 *chip = card->private_data;
    27032682        int i, err;
    27042683
    2705         *chip_ret = NULL;
    2706 
    27072684        /* enable PCI device */
    2708         err = pci_enable_device(pci);
     2685        err = pcim_enable_device(pci);
    27092686        if (err < 0)
    27102687                return err;
    … …  
    27132690                dev_err(card->dev,
    27142691                        "architecture does not support 28bit PCI busmaster DMA\n");
    2715                 pci_disable_device(pci);
    27162692                return -ENXIO;
    2717         }
    2718 
    2719         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2720         if (! chip) {
    2721                 pci_disable_device(pci);
    2722                 return -ENOMEM;
    27232693        }
    27242694
    … …  
    27392709
    27402710        err = pci_request_regions(pci, "ESS Maestro");
    2741         if (err < 0) {
    2742                 kfree(chip);
    2743                 pci_disable_device(pci);
     2711        if (err < 0)
    27442712                return err;
    2745         }
    27462713        chip->io_port = pci_resource_start(pci, 0);
     2714#ifndef TARGET_OS2
     2715        if (devm_request_irq(&pci->dev, pci->irq, snd_es1968_interrupt,
     2716                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
     2717                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     2718                return -EBUSY;
     2719        }
     2720#else
    27472721        if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
    27482722                        KBUILD_MODNAME, chip)) {
    … …  
    27512725                return -EBUSY;
    27522726        }
     2727#endif
    27532728        chip->irq = pci->irq;
    27542729        card->sync_irq = chip->irq;
     2730        card->private_free = snd_es1968_free;
    27552731               
    27562732        /* Clear Maestro_map */
    … …  
    27862762        snd_es1968_chip_init(chip);
    27872763
    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 
    27942764#ifdef CONFIG_SND_ES1968_RADIO
    27952765        /* don't play with GPIOs on laptops */
    27962766        if (chip->pci->subsystem_vendor != 0x125d)
    2797                 goto no_radio;
     2767                return 0;
    27982768        err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
    2799         if (err < 0) {
    2800                 snd_es1968_free(chip);
     2769        if (err < 0)
    28012770                return err;
    2802         }
    28032771        chip->tea.v4l2_dev = &chip->v4l2_dev;
    28042772        chip->tea.private_data = chip;
    … …  
    28162784                }
    28172785        }
    2818 no_radio:
    2819 #endif
    2820 
    2821         *chip_ret = chip;
    2822 
     2786#endif
    28232787        return 0;
    28242788}
    … …  
    28432807        }
    28442808
    2845         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2846                            0, &card);
     2809        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2810                                sizeof(*chip), &card);
    28472811        if (err < 0)
    28482812                return err;
     2813        chip = card->private_data;
    28492814               
    28502815        if (total_bufsize[dev] < 128)
    … …  
    28582823                                pci_id->driver_data,
    28592824                                use_pm[dev],
    2860                                 radio_nr[dev],
    2861                                 &chip);
    2862         if (err < 0) {
    2863                 snd_card_free(card);
     2825                                radio_nr[dev]);
     2826        if (err < 0)
    28642827                return err;
    2865         }
    2866         card->private_data = chip;
    28672828
    28682829        switch (chip->type) {
    … …  
    28822843
    28832844        err = snd_es1968_pcm(chip, 0);
    2884         if (err < 0) {
    2885                 snd_card_free(card);
     2845        if (err < 0)
    28862846                return err;
    2887         }
    28882847
    28892848        err = snd_es1968_mixer(chip);
    2890         if (err < 0) {
    2891                 snd_card_free(card);
     2849        if (err < 0)
    28922850                return err;
    2893         }
    28942851
    28952852        if (enable_mpu[dev] == 2) {
    … …  
    29342891
    29352892        err = snd_card_register(card);
    2936         if (err < 0) {
    2937                 snd_card_free(card);
     2893        if (err < 0)
    29382894                return err;
    2939         }
    29402895        pci_set_drvdata(pci, card);
    29412896        dev++;
    29422897        return 0;
    2943 }
    2944 
    2945 static void snd_es1968_remove(struct pci_dev *pci)
    2946 {
    2947         snd_card_free(pci_get_drvdata(pci));
    29482898}
    29492899
    … …  
    29522902        .id_table = snd_es1968_ids,
    29532903        .probe = snd_es1968_probe,
    2954         .remove = snd_es1968_remove,
    29552904        .driver = {
    29562905                .pm = ES1968_PM_OPS,

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

    r697 r710  
    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;
    13401291        return 0;
    13411292}
    … …  
    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++;
    14191356        return 0;
    1420 }
    1421 
    1422 static void snd_card_fm801_remove(struct pci_dev *pci)
    1423 {
    1424         snd_card_free(pci_get_drvdata(pci));
    14251357}
    14261358
    … …  
    14921424        .id_table = snd_fm801_ids,
    14931425        .probe = snd_card_fm801_probe,
    1494         .remove = snd_card_fm801_remove,
    14951426        .driver = {
    14961427                .pm = SND_FM801_PM_OPS,

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

    r693 r710  
    976976 *
    977977 * The function tries to find the matching model name at first, if given.
     978 * If the model string contains the SSID alias, try to look up with the given
     979 * alias ID.
    978980 * If nothing matched, try to look up the PCI SSID.
    979981 * If still nothing matched, try to look up the codec SSID.
    … …  
    987989        int id = HDA_FIXUP_ID_NOT_SET;
    988990        const char *name = NULL;
     991        const char *type = NULL;
     992        int vendor, device;
    989993
    990994        if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
    … …  
    993997        /* when model=nofixup is given, don't pick up any fixups */
    994998        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;
     999                id = HDA_FIXUP_ID_NO_FIXUP;
     1000                fixlist = NULL;
    9981001                codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
    9991002                          codec->core.chip_name);
    1000                 return;
    1001         }
    1002 
     1003                goto found;
     1004        }
     1005
     1006        /* match with the model name string */
    10031007        if (codec->modelname && models) {
    10041008                while (models->name) {
    10051009                        if (!strcmp(codec->modelname, models->name)) {
    1006                                 codec->fixup_id = models->id;
    1007                                 codec->fixup_name = models->name;
    1008                                 codec->fixup_list = fixlist;
     1010                                id = models->id;
     1011                                name = models->name;
    10091012                                codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
    10101013                                          codec->core.chip_name, codec->fixup_name);
    1011                                 return;
     1014                                goto found;
    10121015                        }
    10131016                        models++;
    10141017                }
    10151018        }
    1016         if (quirk) {
    1017                 q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
     1019
     1020        if (!quirk)
     1021                return;
     1022
     1023        /* match with the SSID alias given by the model string "XXXX:YYYY" */
     1024        if (codec->modelname &&
     1025            sscanf(codec->modelname, "%04x:%04x", &vendor, &device) == 2) {
     1026                q = snd_pci_quirk_lookup_id(vendor, device, quirk);
    10181027                if (q) {
    1019                         id = q->value;
     1028                        type = "alias SSID";
     1029                        goto found_device;
     1030                }
     1031        }
     1032
     1033        /* match with the PCI SSID */
     1034        q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
     1035        if (q) {
     1036                type = "PCI SSID";
     1037                goto found_device;
     1038        }
     1039
     1040        /* match with the codec SSID */
     1041        q = snd_pci_quirk_lookup_id(codec->core.subsystem_id >> 16,
     1042                                    codec->core.subsystem_id & 0xffff,
     1043                                    quirk);
     1044        if (q) {
     1045                type = "codec SSID";
     1046                goto found_device;
     1047        }
     1048
     1049        return; /* no matching */
     1050
     1051 found_device:
     1052        id = q->value;
    10201053#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");
     1054        name = q->name;
    10241055#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 
     1056        codec_dbg(codec, "%s: picked fixup %s for %s %04x:%04x\n",
     1057                  codec->core.chip_name, name ? name : "",
     1058                  type, q->subvendor, q->subdevice);
     1059 found:
    10441060        codec->fixup_id = id;
    1045         if (id >= 0) {
    1046                 codec->fixup_list = fixlist;
    1047                 codec->fixup_name = name;
    1048         }
     1061        codec->fixup_list = fixlist;
     1062        codec->fixup_name = name;
    10491063}
    10501064EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_bind.c

    r697 r710  
    168168static void hda_codec_driver_shutdown(struct device *dev)
    169169{
    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         }
     170        snd_hda_codec_shutdown(dev_to_hda_codec(dev));
    177171}
    178172
    … …  
    309303        int err;
    310304
     305        if (codec->configured)
     306                return 0;
     307
    311308        if (is_generic_config(codec))
    312309                codec->probe_id = HDA_CODEC_ID_GENERIC;
    … …  
    314311                codec->probe_id = 0;
    315312
    316         err = snd_hdac_device_register(&codec->core);
    317         if (err < 0)
    318                 return err;
     313        if (!device_is_registered(&codec->core.dev)) {
     314                err = snd_hdac_device_register(&codec->core);
     315                if (err < 0)
     316                        return err;
     317        }
    319318
    320319        if (!codec->preset)
    … …  
    323322                err = codec_bind_generic(codec);
    324323                if (err < 0) {
    325                         codec_err(codec, "Unable to bind the codec\n");
    326                         goto error;
     324                        codec_dbg(codec, "Unable to bind the codec\n");
     325                        return err;
    327326                }
    328327        }
    329328
    330         return 0;
    331 
    332  error:
    333         snd_hdac_device_unregister(&codec->core);
    334         return err;
     329        codec->configured = 1;
     330        return 0;
    335331}
    336332EXPORT_SYMBOL_GPL(snd_hda_codec_configure);

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_codec.c

    r697 r710  
    802802        remove_conn_list(codec);
    803803        snd_hdac_regmap_exit(&codec->core);
     804        codec->configured = 0;
    804805}
    805806EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_for_unbind);
    … …  
    29982999                           NULL)
    29993000};
     3001
     3002/* suspend the codec at shutdown; called from driver's shutdown callback */
     3003void snd_hda_codec_shutdown(struct hda_codec *codec)
     3004{
     3005        struct hda_pcm *cpcm;
     3006
     3007        list_for_each_entry(cpcm, &codec->pcm_list_head, list, struct hda_pcm)
     3008                snd_pcm_suspend_all(cpcm->pcm);
     3009
     3010        pm_runtime_force_suspend(hda_codec_dev(codec));
     3011        pm_runtime_disable(hda_codec_dev(codec));
     3012}
    30003013
    30013014/*

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_controller.c

    r693 r710  
    2626#include <sound/initval.h>
    2727#include "hda_controller.h"
     28#include "hda_local.h"
    2829
    2930#ifndef TARGET_OS2
    … …  
    690691}
    691692
    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 
    706693static const struct snd_pcm_ops azx_pcm_ops = {
    707694        .open = azx_pcm_open,
    … …  
    713700        .pointer = azx_pcm_pointer,
    714701        .get_time_info =  azx_get_time_info,
    715         .mmap = azx_pcm_mmap,
    716702};
    717703
    … …  
    778764                size = MAX_PREALLOC_SIZE;
    779765        if (chip->uc_buffer)
    780                 type = SNDRV_DMA_TYPE_DEV_UC_SG;
     766                type = SNDRV_DMA_TYPE_DEV_WC_SG;
    781767        snd_pcm_set_managed_buffer_all(pcm, type, chip->card->dev,
    782768                                       size, MAX_PREALLOC_SIZE);
    … …  
    12931279{
    12941280        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;
     1281        int success = 0;
     1282
     1283        list_for_each_codec(codec, &chip->bus) {
     1284                if (!snd_hda_codec_configure(codec))
     1285                        success++;
     1286        }
     1287
     1288        if (success) {
     1289                /* unregister failed codecs if any codec has been probed */
     1290                list_for_each_codec_safe(codec, next, &chip->bus) {
     1291                        if (!codec->configured) {
     1292                                codec_err(codec, "Unable to configure, disabling\n");
     1293                                snd_hdac_device_unregister(&codec->core);
     1294                        }
     1295                }
     1296        }
     1297
     1298        return success ? 0 : -ENODEV;
    13061299}
    13071300EXPORT_SYMBOL_GPL(azx_codec_configure);

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_controller.h

    r629 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/hda/hda_generic.c

    r697 r710  
    60166016EXPORT_SYMBOL_GPL(snd_hda_gen_free);
    60176017
    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 
    60366018#ifdef CONFIG_PM
    60376019/**
    … …  
    60616043        .free = snd_hda_gen_free,
    60626044        .unsol_event = snd_hda_jack_unsol_event,
    6063         .reboot_notify = snd_hda_gen_reboot_notify,
    60646045#ifdef CONFIG_PM
    60656046        .check_power_status = snd_hda_gen_check_power_status,

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_generic.h

    r694 r710  
    325325int snd_hda_gen_build_controls(struct hda_codec *codec);
    326326int snd_hda_gen_build_pcms(struct hda_codec *codec);
    327 void snd_hda_gen_reboot_notify(struct hda_codec *codec);
    328327
    329328/* standard jack event callbacks */

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

    r697 r710  
    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 */
    … …  
    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);
    … …  
    17681758static void azx_probe_work(struct work_struct *work)
    17691759{
    1770         struct hda_intel *hda = container_of(work, struct hda_intel, probe_work);
     1760        struct hda_intel *hda = container_of(work, struct hda_intel, probe_work.work);
    17711761        azx_probe_continue(&hda->chip);
    17721762}
    … …  
    18201810        hda = kzalloc(sizeof(*hda), GFP_KERNEL);
    18211811#endif
    1822         if (!hda) {
    1823                 pci_disable_device(pci);
    1824                 return -ENOMEM;
    1825         }
     1812        if (!hda)
     1813                return -ENOMEM;
    18261814
    18271815        chip = &hda->chip;
    … …  
    18591847
    18601848        err = azx_bus_init(chip, model[dev]);
    1861         if (err < 0) {
    1862                 pci_disable_device(pci);
     1849        if (err < 0)
    18631850                return err;
    1864         }
    18651851
    18661852        /* use the non-cached pages in non-snoop mode */
    18671853        if (!azx_snoop(chip))
    1868                 azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_UC;
     1854                azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_WC;
    18691855
    18701856        if (chip->driver_type == AZX_DRIVER_NVIDIA) {
    … …  
    18811867
    18821868        /* continue probing in work context as may trigger request module */
    1883         INIT_WORK(&hda->probe_work, azx_probe_work);
     1869        INIT_DELAYED_WORK(&hda->probe_work, azx_probe_work);
    18841870
    18851871        *rchip = chip;
    … …  
    19081894#endif
    19091895
     1896#ifndef TARGET_OS2
     1897        err = pcim_iomap_regions(pci, 1 << 0, "ICH HD audio");
     1898#else
    19101899        err = pci_request_regions(pci, "ICH HD audio");
     1900#endif
    19111901        if (err < 0)
    19121902                return err;
    1913         chip->region_requested = 1;
    19141903
    19151904        bus->addr = pci_resource_start(pci, 0);
     1905#ifndef TARGET_OS2
     1906        bus->remap_addr = pcim_iomap_table(pci)[0];
     1907#else
    19161908        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 
     1909#endif
    19221910        if (chip->driver_type == AZX_DRIVER_SKL)
    19231911                snd_hdac_bus_parse_capabilities(bus);
    … …  
    21012089}
    21022090
    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 
    21142091/* Denylist for skipping the whole probe:
    21152092 * some HD-audio PCI entries are exposed without any codecs, and such devices
    … …  
    21252102static const struct hda_controller_ops pci_hda_ops = {
    21262103        .disable_msi_reset_irq = disable_msi_reset_irq,
    2127         .pcm_mmap_prepare = pcm_mmap_prepare,
    21282104        .position_check = azx_position_check,
    21292105};
    … …  
    22192195#else
    22202196        if (schedule_probe)
    2221                 schedule_work(&hda->probe_work);
     2197                schedule_delayed_work(&hda->probe_work, 0);
    22222198#endif
    22232199
    … …  
    23062282        int err;
    23072283
     2284        if (chip->disabled || hda->init_failed)
     2285                return -EIO;
     2286        if (hda->probe_retry)
     2287                goto probe_retry;
     2288
    23082289        to_hda_bus(bus)->bus_probing = 1;
    23092290        hda->probe_continued = 1;
    … …  
    23672348        }
    23682349#endif
     2350
     2351 probe_retry:
    23692352        if (bus->codec_mask && !(probe_only[dev] & 1)) {
    23702353                err = azx_codec_configure(chip);
    2371                 if (err < 0)
     2354                if (err) {
     2355                        if ((chip->driver_caps & AZX_DCAPS_RETRY_PROBE) &&
     2356                            ++hda->probe_retry < 60) {
     2357                                schedule_delayed_work(&hda->probe_work,
     2358                                                      msecs_to_jiffies(1000));
     2359                                return 0; /* keep things up */
     2360                        }
     2361                        dev_err(chip->card->dev, "Cannot probe codecs, giving up\n");
    23722362                        goto out_free;
     2363                }
    23732364        }
    23742365
    … …  
    24002391        complete_all(&hda->probe_wait);
    24012392        to_hda_bus(bus)->bus_probing = 0;
     2393        hda->probe_retry = 0;
    24022394        return 0;
    24032395}
    … …  
    24252417                 */
    24262418                device_unlock(&pci->dev);
    2427                 cancel_work_sync(&hda->probe_work);
     2419                cancel_delayed_work_sync(&hda->probe_work);
    24282420                device_lock(&pci->dev);
    24292421

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_intel.h

    r615 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/hda/hda_local.h

    r697 r710  
    630630                                             unsigned int power_state);
    631631
     632void snd_hda_codec_shutdown(struct hda_codec *codec);
     633
    632634/*
    633635 * AMP control callbacks

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_analog.c

    r648 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/hda/patch_ca0132.c

    r697 r710  
    22752275{
    22762276        struct ca0132_spec *spec = codec->spec;
    2277         int status = -1;
     2277        int status;
    22782278        unsigned int scp_send_size = 0;
    22792279        unsigned int total_size;
    … …  
    97789778}
    97799779
    9780 static void ca0132_reboot_notify(struct hda_codec *codec)
    9781 {
    9782         codec->patch_ops.free(codec);
    9783 }
    9784 
    97859780#ifdef CONFIG_PM
    97869781static int ca0132_suspend(struct hda_codec *codec)
    … …  
    98029797        .suspend = ca0132_suspend,
    98039798#endif
    9804         .reboot_notify = ca0132_reboot_notify,
    98059799};
    98069800

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

    r694 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/hda/patch_conexant.c

    r693 r710  
    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

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

    r708 r710  
    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 {
    … …  
    19711975                return -EINVAL;
    19721976        }
     1977
     1978        if (enable_all_pins)
     1979                spec->force_connect = true;
    19731980
    19741981        q = snd_pci_quirk_lookup(codec->bus->pci, force_connect_list);

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

    r697 r710  
    115115#endif
    116116        void (*shutup)(struct hda_codec *codec);
    117         void (*reboot_notify)(struct hda_codec *codec);
    118117
    119118        int init_amp;
    … …  
    535534
    536535        switch (codec->core.vendor_id) {
     536        case 0x10ec0236:
     537        case 0x10ec0256:
    537538        case 0x10ec0283:
    538539        case 0x10ec0286:
    … …  
    906907}
    907908
    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 
    918909#define alc_free        snd_hda_gen_free
    919910
    … …  
    961952        .check_power_status = snd_hda_gen_check_power_status,
    962953#endif
    963         .reboot_notify = alc_reboot_notify,
    964954};
    965955
    … …  
    30943084        SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30953085        SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3086        SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30963087        SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30973088        SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30983089        SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
    30993090        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),
     3091        SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
     3092        SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
    31013093        SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
    31023094        SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
    … …  
    41844176         * when booting with headset plugged. So skip setting it for the codec alc257
    41854177         */
    4186         if (codec->core.vendor_id != 0x10ec0257)
     4178        if (spec->codec_variant != ALC269_TYPE_ALC257 &&
     4179            spec->codec_variant != ALC269_TYPE_ALC256)
    41874180                alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
    41884181
    … …  
    64666459
    64676460        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
    6468                 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
    64696461                spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
    64706462                codec->power_save_node = 0; /* avoid click noises */
    … …  
    71107102#endif /* NOT_USED */
    71117103
     7104/* GPIO1 = amplifier on/off
     7105 * GPIO3 = mic mute LED
     7106 */
     7107static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
     7108                                          const struct hda_fixup *fix, int action)
     7109{
     7110        static const hda_nid_t conn[] = { 0x02 };
     7111
     7112        struct alc_spec *spec = codec->spec;
     7113        static const struct hda_pintbl pincfgs[] = {
     7114                { 0x14, 0x90170110 },  /* front/high speakers */
     7115                { 0x17, 0x90170130 },  /* back/bass speakers */
     7116                {0}
     7117        };
     7118
     7119        //enable micmute led
     7120        alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
     7121
     7122        switch (action) {
     7123        case HDA_FIXUP_ACT_PRE_PROBE:
     7124                spec->micmute_led_polarity = 1;
     7125                /* needed for amp of back speakers */
     7126                spec->gpio_mask |= 0x01;
     7127                spec->gpio_dir |= 0x01;
     7128                snd_hda_apply_pincfgs(codec, pincfgs);
     7129                /* share DAC to have unified volume control */
     7130                snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
     7131                snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
     7132                break;
     7133        case HDA_FIXUP_ACT_INIT:
     7134                /* need to toggle GPIO to enable the amp of back speakers */
     7135                alc_update_gpio_data(codec, 0x01, true);
     7136                msleep(100);
     7137                alc_update_gpio_data(codec, 0x01, false);
     7138                break;
     7139        }
     7140}
     7141
    71127142static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
    71137143                                          const struct hda_fixup *fix, int action)
    … …  
    71387168}
    71397169
     7170/* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
     7171static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
     7172                                                  const struct hda_fixup *fix,
     7173                                                  int action)
     7174{
     7175        struct alc_spec *spec = codec->spec;
     7176
     7177        switch (action) {
     7178        case HDA_FIXUP_ACT_PRE_PROBE:
     7179                spec->gen.suppress_auto_mute = 1;
     7180                break;
     7181        }
     7182}
     7183
    71407184/* for alc295_fixup_hp_top_speakers */
    71417185#include "hp_x360_helper.c"
    … …  
    71437187/* for alc285_fixup_ideapad_s740_coef() */
    71447188#include "ideapad_s740_helper.c"
     7189
     7190static void alc256_fixup_tongfang_reset_persistent_settings(struct hda_codec *codec,
     7191                                                            const struct hda_fixup *fix,
     7192                                                            int action)
     7193{
     7194        /*
     7195        * A certain other OS sets these coeffs to different values. On at least one TongFang
     7196        * barebone these settings might survive even a cold reboot. So to restore a clean slate the
     7197        * values are explicitly reset to default here. Without this, the external microphone is
     7198        * always in a plugged-in state, while the internal microphone is always in an unplugged
     7199        * state, breaking the ability to use the internal microphone.
     7200        */
     7201        alc_write_coef_idx(codec, 0x24, 0x0000);
     7202        alc_write_coef_idx(codec, 0x26, 0x0000);
     7203        alc_write_coef_idx(codec, 0x29, 0x3000);
     7204        alc_write_coef_idx(codec, 0x37, 0xfe05);
     7205        alc_write_coef_idx(codec, 0x45, 0x5089);
     7206}
    71457207
    71467208enum {
    … …  
    72307292        ALC280_FIXUP_HP_9480M,
    72317293        ALC245_FIXUP_HP_X360_AMP,
     7294        ALC285_FIXUP_HP_SPECTRE_X360_EB1,
    72327295        ALC288_FIXUP_DELL_HEADSET_MODE,
    72337296        ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
    … …  
    73557418        ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
    73567419        ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
     7420        ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
     7421        ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
     7422        ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
     7423        ALC287_FIXUP_13S_GEN2_SPEAKERS,
     7424        ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS,
    73577425};
    73587426
    … …  
    92279295                .v.func = alc285_fixup_hp_spectre_x360,
    92289296        },
     9297        [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
     9298                .type = HDA_FIXUP_FUNC,
     9299                .v.func = alc285_fixup_hp_spectre_x360_eb1
     9300        },
    92299301        [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
    92309302                .type = HDA_FIXUP_FUNC,
    … …  
    92559327                .chained = true,
    92569328                .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
     9329        },
     9330#ifdef TARGET_OS2xxx
     9331        [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
     9332                .type = HDA_FIXUP_VERBS,
     9333                //.v.verbs = legion_15imhg05_coefs,
     9334                .v.verbs = (const struct hda_verb[]) {
     9335                         // set left speaker Legion 7i.
     9336                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9337                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9338
     9339                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9340                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9341                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9342                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
     9343                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9344
     9345                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9346                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9347                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9348                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9349                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9350
     9351                         // set right speaker Legion 7i.
     9352                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9353                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
     9354
     9355                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9356                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9357                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9358                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
     9359                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9360
     9361                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9362                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9363                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9364                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9365                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9366                         {}
     9367                },
     9368                .chained = true,
     9369                .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
     9370        },
     9371#endif
     9372        [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
     9373                .type = HDA_FIXUP_FUNC,
     9374                .v.func = alc287_fixup_legion_15imhg05_speakers,
     9375                .chained = true,
     9376                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9377        },
     9378#ifdef TARGET_OS2xxx
     9379        [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
     9380                .type = HDA_FIXUP_VERBS,
     9381                .v.verbs = (const struct hda_verb[]) {
     9382                         // set left speaker Yoga 7i.
     9383                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9384                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9385
     9386                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9387                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9388                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9389                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
     9390                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9391
     9392                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9393                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9394                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9395                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9396                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9397
     9398                         // set right speaker Yoga 7i.
     9399                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9400                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
     9401
     9402                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9403                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
     9404                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9405                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
     9406                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9407
     9408                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9409                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9410                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9411                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9412                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9413                         {}
     9414                },
     9415                .chained = true,
     9416                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9417        },
     9418        [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
     9419                .type = HDA_FIXUP_VERBS,
     9420                .v.verbs = (const struct hda_verb[]) {
     9421                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9422                        { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
     9423                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9424                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9425                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9426                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9427                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9428                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
     9429                        { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
     9430                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
     9431                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
     9432                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9433                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
     9434                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
     9435                        {}
     9436                },
     9437                .chained = true,
     9438                .chain_id = ALC269_FIXUP_HEADSET_MODE,
     9439        },
     9440#endif
     9441        [ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS] = {
     9442                .type = HDA_FIXUP_FUNC,
     9443                .v.func = alc256_fixup_tongfang_reset_persistent_settings,
    92579444        },
    92589445};
    … …  
    93479534        SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
    93489535        SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
     9536        SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
     9537        SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
     9538        SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
    93499539        SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    93509540        SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
    … …  
    94499639        SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
    94509640        SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
     9641        SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
     9642        SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
    94519643        SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
    94529644        SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
    … …  
    96509842        SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
    96519843        SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
     9844        SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
     9845        SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     9846        SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
     9847        SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
    96529848        SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
    96539849        SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
    … …  
    96809876        SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
    96819877        SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
     9878        SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS),
    96829879        SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
    96839880        SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
    … …  
    986510062        {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
    986610063        {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
     10064        {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
    986710065        {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
    986810066        {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
    … …  
    1110011298        ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
    1110111299        ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
     11300        ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
     11301        ALC668_FIXUP_HEADSET_MIC,
     11302        ALC668_FIXUP_MIC_DET_COEF,
    1110211303};
    1110311304
    … …  
    1166611867                .chained = true,
    1166711868                .chain_id = ALC662_FIXUP_USI_FUNC
     11869        },
     11870        [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
     11871                .type = HDA_FIXUP_PINS,
     11872                .v.pins = (const struct hda_pintbl[]) {
     11873                        { 0x1b, 0x04a1112c },
     11874                        { }
     11875                },
     11876                .chained = true,
     11877                .chain_id = ALC668_FIXUP_HEADSET_MIC
     11878        },
     11879#endif
     11880        [ALC668_FIXUP_HEADSET_MIC] = {
     11881                .type = HDA_FIXUP_FUNC,
     11882                .v.func = alc269_fixup_headset_mic,
     11883                .chained = true,
     11884                .chain_id = ALC668_FIXUP_MIC_DET_COEF
     11885        },
     11886#ifdef TARGET_OS2xxx
     11887        [ALC668_FIXUP_MIC_DET_COEF] = {
     11888                .type = HDA_FIXUP_VERBS,
     11889                .v.verbs = (const struct hda_verb[]) {
     11890                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
     11891                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
     11892                        {}
     11893                },
    1166811894        },
    1166911895#endif
    … …  
    1170311929        SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
    1170411930        SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
     11931        SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
    1170511932        SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
    1170611933        SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),

  • GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_sigmatel.c

    r694 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/intel8x0.c

    r697 r710  
    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 */
     3014#ifndef TARGET_OS2
     3015        chip->bdbars = snd_devm_alloc_pages(&pci->dev, intel8x0_dma_type(chip),
     3016                                            chip->bdbars_count * sizeof(u32) *
     3017                                            ICH_MAX_FRAGS * 2);
     3018        if (!chip->bdbars)
     3019                return -ENOMEM;
     3020#else
    30533021        if (snd_dma_alloc_pages(intel8x0_dma_type(chip), &pci->dev,
    30543022                                chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2,
    … …  
    30583026                return -ENOMEM;
    30593027        }
     3028#endif
    30603029        /* tables must be aligned to 8 bytes here, but the kernel pages
    30613030           are much bigger, so we don't care (on i386) */
    … …  
    30633032        for (i = 0; i < chip->bdbars_count; i++) {
    30643033                ichdev = &chip->ichd[i];
    3065                 ichdev->bdbar = ((__le32 *)chip->bdbars.area) +
     3034                ichdev->bdbar = ((__le32 *)chip->bdbars->area) +
    30663035                        (i * ICH_MAX_FRAGS * 2);
    3067                 ichdev->bdbar_addr = chip->bdbars.addr +
     3036                ichdev->bdbar_addr = chip->bdbars->addr +
    30683037                        (i * sizeof(u32) * ICH_MAX_FRAGS * 2);
    30693038                int_sta_masks |= ichdev->int_sta_mask;
    … …  
    30993068
    31003069        err = snd_intel8x0_chip_init(chip, 1);
    3101         if (err < 0) {
    3102                 snd_intel8x0_free(chip);
     3070        if (err < 0)
    31033071                return err;
    3104         }
    31053072
    31063073        /* request irq after initializaing int_sta_mask, etc */
     3074        /* NOTE: we don't use devm version here since it's released /
     3075         * re-acquired in PM callbacks.
     3076         * It's released explicitly in snd_intel8x0_free(), too.
     3077         */
    31073078        if (request_irq(pci->irq, snd_intel8x0_interrupt,
    31083079                        IRQF_SHARED, KBUILD_MODNAME, chip)) {
    31093080                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    3110                 snd_intel8x0_free(chip);
    31113081                return -EBUSY;
    31123082        }
    … …  
    31143084        card->sync_irq = chip->irq;
    31153085
    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;
     3086        card->private_free = snd_intel8x0_free;
     3087
    31233088        return 0;
    31243089}
    … …  
    31863151        struct shortname_table *name;
    31873152
    3188         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     3153        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     3154                                sizeof(*chip), &card);
    31893155        if (err < 0)
    31903156                return err;
     3157        chip = card->private_data;
    31913158
    31923159        if (spdif_aclink < 0)
    … …  
    32223189        }
    32233190
    3224         err = snd_intel8x0_create(card, pci, pci_id->driver_data, &chip);
    3225         if (err < 0) {
    3226                 snd_card_free(card);
     3191        err = snd_intel8x0_init(card, pci, pci_id->driver_data);
     3192        if (err < 0)
    32273193                return err;
    3228         }
    3229         card->private_data = chip;
    32303194
    32313195        err = snd_intel8x0_mixer(chip, ac97_clock, ac97_quirk);
    3232         if (err < 0) {
    3233                 snd_card_free(card);
     3196        if (err < 0)
    32343197                return err;
    3235         }
    32363198        err = snd_intel8x0_pcm(chip);
    3237         if (err < 0) {
    3238                 snd_card_free(card);
     3199        if (err < 0)
    32393200                return err;
    3240         }
    32413201       
    32423202        snd_intel8x0_proc_init(chip);
    … …  
    32563216
    32573217        err = snd_card_register(card);
    3258         if (err < 0) {
    3259                 snd_card_free(card);
     3218        if (err < 0)
    32603219                return err;
    3261         }
     3220
    32623221        pci_set_drvdata(pci, card);
    32633222        return 0;
    3264 }
    3265 
    3266 static void snd_intel8x0_remove(struct pci_dev *pci)
    3267 {
    3268         snd_card_free(pci_get_drvdata(pci));
    32693223}
    32703224
    … …  
    32733227        .id_table = snd_intel8x0_ids,
    32743228        .probe = snd_intel8x0_probe,
    3275         .remove = snd_intel8x0_remove,
    32763229        .driver = {
    32773230                .pm = INTEL8X0_PM_OPS,

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

    r697 r710  
    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);
     2354        korg1212 = card->private_data;
     2355
     2356        err = snd_korg1212_create(card, pci);
     2357        if (err < 0)
    24482358                return err;
    2449         }
    24502359
    24512360        strcpy(card->driver, "korg1212");
    … …  
    24572366
    24582367        err = snd_card_register(card);
    2459         if (err < 0) {
    2460                 snd_card_free(card);
     2368        if (err < 0)
    24612369                return err;
    2462         }
    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));
    24712373}
    24722374
    … …  
    24752377        .id_table = snd_korg1212_ids,
    24762378        .probe = snd_korg1212_probe,
    2477         .remove = snd_korg1212_remove,
    24782379};
    24792380

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

    r697 r710  
    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
    … …  
    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));
    27732727}
    27742728
    … …  
    27772731        .id_table = snd_m3_ids,
    27782732        .probe = snd_m3_probe,
    2779         .remove = snd_m3_remove,
    27802733        .driver = {
    27812734                .pm = M3_PM_OPS,

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

    r697 r710  
    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
    … …  
    16231578
    16241579        snd_nm256_init_chip(chip);
     1580        card->private_free = snd_nm256_free;
    16251581
    16261582        // 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;
     1583        return 0;
    16381584}
    16391585
    … …  
    16781624        }
    16791625
    1680         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     1626        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     1627                                sizeof(*chip), &card);
    16811628        if (err < 0)
    16821629                return err;
     1630        chip = card->private_data;
    16831631
    16841632        switch (pci->device) {
    … …  
    16941642        default:
    16951643                dev_err(&pci->dev, "invalid device id 0x%x\n", pci->device);
    1696                 snd_card_free(card);
    16971644                return -EINVAL;
    16981645        }
    … …  
    17091656        if (capture_bufsize > 128)
    17101657                capture_bufsize = 128;
    1711         err = snd_nm256_create(card, pci, &chip);
    1712         if (err < 0) {
    1713                 snd_card_free(card);
     1658        err = snd_nm256_create(card, pci);
     1659        if (err < 0)
    17141660                return err;
    1715         }
    1716         card->private_data = chip;
    17171661
    17181662        if (reset_workaround) {
    … …  
    17271671
    17281672        err = snd_nm256_pcm(chip, 0);
    1729         if (err < 0) {
    1730                 snd_card_free(card);
     1673        if (err < 0)
    17311674                return err;
    1732         }
    17331675        err = snd_nm256_mixer(chip);
    1734         if (err < 0) {
    1735                 snd_card_free(card);
     1676        if (err < 0)
    17361677                return err;
    1737         }
    17381678
    17391679        sprintf(card->shortname, "NeoMagic %s", card->driver);
    … …  
    17431683
    17441684        err = snd_card_register(card);
    1745         if (err < 0) {
    1746                 snd_card_free(card);
     1685        if (err < 0)
    17471686                return err;
    1748         }
    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/branches/uniaud32-next/alsa-kernel/pci/rme9652/hdsp.c

    r697 r710  
    469469        u32                   io_loopback;          /* output loopback channel states*/
    470470
    471         struct snd_dma_buffer capture_dma_buf;
    472         struct snd_dma_buffer playback_dma_buf;
     471        struct snd_dma_buffer *capture_dma_buf;
     472        struct snd_dma_buffer *playback_dma_buf;
    473473        unsigned char        *capture_buffer;       /* suitably aligned address */
    474474        unsigned char        *playback_buffer;      /* suitably aligned address */
    … …  
    566566};
    567567
    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 
     568static struct snd_dma_buffer *
     569snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size)
     570{
     571        return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size);
     572}
    579573
    580574static const struct pci_device_id snd_hdsp_ids[] = {
    … …  
    37693763}
    37703764
    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 
    37773765static int snd_hdsp_initialize_memory(struct hdsp *hdsp)
    37783766{
    37793767        unsigned long pb_bus, cb_bus;
    37803768
    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);
     3769        hdsp->capture_dma_buf =
     3770                snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
     3771        hdsp->playback_dma_buf =
     3772                snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
     3773        if (!hdsp->capture_dma_buf || !hdsp->playback_dma_buf) {
    37853774                dev_err(hdsp->card->dev,
    37863775                        "%s: no buffers available\n", hdsp->card_name);
    … …  
    37903779        /* Align to bus-space 64K boundary */
    37913780
    3792         cb_bus = ALIGN(hdsp->capture_dma_buf.addr, 0x10000ul);
    3793         pb_bus = ALIGN(hdsp->playback_dma_buf.addr, 0x10000ul);
     3781        cb_bus = ALIGN(hdsp->capture_dma_buf->addr, 0x10000ul);
     3782        pb_bus = ALIGN(hdsp->playback_dma_buf->addr, 0x10000ul);
    37943783
    37953784        /* Tell the card where it is */
    … …  
    37983787        hdsp_write(hdsp, HDSP_outputBufferAddress, pb_bus);
    37993788
    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->capture_buffer = hdsp->capture_dma_buf->area + (cb_bus - hdsp->capture_dma_buf->addr);
     3790        hdsp->playback_buffer = hdsp->playback_dma_buf->area + (pb_bus - hdsp->playback_dma_buf->addr);
    38023791
    38033792        return 0;
    … …  
    45194508
    45204509        runtime->hw = snd_hdsp_playback_subinfo;
    4521         runtime->dma_area = hdsp->playback_buffer;
    4522         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
     4510        snd_pcm_set_runtime_buffer(substream, hdsp->playback_dma_buf);
    45234511
    45244512        hdsp->playback_pid = current->pid;
    … …  
    45964584
    45974585        runtime->hw = snd_hdsp_capture_subinfo;
    4598         runtime->dma_area = hdsp->capture_buffer;
    4599         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
     4586        snd_pcm_set_runtime_buffer(substream, hdsp->capture_dma_buf);
    46004587
    46014588        hdsp->capture_pid = current->pid;
    … …  
    53145301        }
    53155302
    5316         err = pci_enable_device(pci);
     5303        err = pcim_enable_device(pci);
    53175304        if (err < 0)
    53185305                return err;
    … …  
    53245311                return err;
    53255312        hdsp->port = pci_resource_start(pci, 0);
    5326         hdsp->iobase = ioremap(hdsp->port, HDSP_IO_EXTENT);
     5313        hdsp->iobase = devm_ioremap(&pci->dev, hdsp->port, HDSP_IO_EXTENT);
    53275314        if (!hdsp->iobase) {
    53285315                dev_err(hdsp->card->dev, "unable to remap region 0x%lx-0x%lx\n",
    … …  
    53315318        }
    53325319
    5333         if (request_irq(pci->irq, snd_hdsp_interrupt, IRQF_SHARED,
    5334                         KBUILD_MODNAME, hdsp)) {
     5320        if (devm_request_irq(&pci->dev, pci->irq, snd_hdsp_interrupt,
     5321                             IRQF_SHARED, KBUILD_MODNAME, hdsp)) {
    53355322                dev_err(hdsp->card->dev, "unable to use IRQ %d\n", pci->irq);
    53365323                return -EBUSY;
    … …  
    54125399}
    54135400
    5414 static int snd_hdsp_free(struct hdsp *hdsp)
    5415 {
     5401static void snd_hdsp_card_free(struct snd_card *card)
     5402{
     5403        struct hdsp *hdsp = card->private_data;
     5404
    54165405        if (hdsp->port) {
    54175406                /* stop the audio, and cancel all interrupts */
    … …  
    54215410        }
    54225411
    5423         if (hdsp->irq >= 0)
    5424                 free_irq(hdsp->irq, (void *)hdsp);
    5425 
    5426         snd_hdsp_free_buffers(hdsp);
    5427 
    54285412        release_firmware(hdsp->firmware);
    54295413        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);
    54465414}
    54475415
    … …  
    54615429        }
    54625430
    5463         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    5464                            sizeof(struct hdsp), &card);
     5431        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     5432                                sizeof(struct hdsp), &card);
    54655433        if (err < 0)
    54665434                return err;
    … …  
    54725440        err = snd_hdsp_create(card, hdsp);
    54735441        if (err)
    5474                 goto free_card;
     5442                return err;
    54755443
    54765444        strcpy(card->shortname, "Hammerfall DSP");
    … …  
    54785446                hdsp->port, hdsp->irq);
    54795447        err = snd_card_register(card);
    5480         if (err) {
    5481 free_card:
    5482                 snd_card_free(card);
     5448        if (err)
    54835449                return err;
    5484         }
    54855450        pci_set_drvdata(pci, card);
    54865451        dev++;
    54875452        return 0;
    5488 }
    5489 
    5490 static void snd_hdsp_remove(struct pci_dev *pci)
    5491 {
    5492         snd_card_free(pci_get_drvdata(pci));
    54935453}
    54945454
    … …  
    54975457        .id_table = snd_hdsp_ids,
    54985458        .probe =    snd_hdsp_probe,
    5499         .remove = snd_hdsp_remove,
    55005459};
    55015460

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

    r693 r710  
    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                return err;
    69296899
    69306900        if (hdspm->io_type != MADIface) {
    … …  
    69456915        err = snd_card_register(card);
    69466916        if (err < 0)
    6947                 goto free_card;
     6917                return err;
    69486918
    69496919        pci_set_drvdata(pci, card);
    … …  
    69516921        dev++;
    69526922        return 0;
    6953 
    6954 free_card:
    6955         snd_card_free(card);
    6956         return err;
    6957 }
    6958 
    6959 static void snd_hdspm_remove(struct pci_dev *pci)
    6960 {
    6961         snd_card_free(pci_get_drvdata(pci));
    69626923}
    69636924
    … …  
    69666927        .id_table = snd_hdspm_ids,
    69676928        .probe = snd_hdspm_probe,
    6968         .remove = snd_hdspm_remove,
    69696929};
    69706930

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

    r697 r710  
    209209        unsigned char ss_channels;      /* different for hammerfall/hammerfall-light */
    210210
    211         struct snd_dma_buffer playback_dma_buf;
    212         struct snd_dma_buffer capture_dma_buf;
     211        struct snd_dma_buffer *playback_dma_buf;
     212        struct snd_dma_buffer *capture_dma_buf;
    213213
    214214        unsigned char *capture_buffer;  /* suitably aligned address */
    … …  
    276276};
    277277
    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 
     278static struct snd_dma_buffer *
     279snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size)
     280{
     281        return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size);
     282}
    289283
    290284static const struct pci_device_id snd_rme9652_ids[] = {
    … …  
    17161710}
    17171711
    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 {
     1712static void snd_rme9652_card_free(struct snd_card *card)
     1713{
     1714        struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
     1715
    17261716        if (rme9652->irq >= 0)
    17271717                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;
    17391718}
    17401719
    … …  
    17431722        unsigned long pb_bus, cb_bus;
    17441723
    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);
     1724        rme9652->capture_dma_buf =
     1725                snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
     1726        rme9652->playback_dma_buf =
     1727                snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
     1728        if (!rme9652->capture_dma_buf || !rme9652->playback_dma_buf) {
    17491729                dev_err(rme9652->card->dev,
    17501730                        "%s: no buffers available\n", rme9652->card_name);
    … …  
    17541734        /* Align to bus-space 64K boundary */
    17551735
    1756         cb_bus = ALIGN(rme9652->capture_dma_buf.addr, 0x10000ul);
    1757         pb_bus = ALIGN(rme9652->playback_dma_buf.addr, 0x10000ul);
     1736        cb_bus = ALIGN(rme9652->capture_dma_buf->addr, 0x10000ul);
     1737        pb_bus = ALIGN(rme9652->playback_dma_buf->addr, 0x10000ul);
    17581738
    17591739        /* Tell the card where it is */
    … …  
    17621742        rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
    17631743
    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->capture_buffer = rme9652->capture_dma_buf->area + (cb_bus - rme9652->capture_dma_buf->addr);
     1745        rme9652->playback_buffer = rme9652->playback_dma_buf->area + (pb_bus - rme9652->playback_dma_buf->addr);
    17661746
    17671747        return 0;
    … …  
    22802260
    22812261        runtime->hw = snd_rme9652_playback_subinfo;
    2282         runtime->dma_area = rme9652->playback_buffer;
    2283         runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
     2262        snd_pcm_set_runtime_buffer(substream, rme9652->playback_dma_buf);
    22842263
    22852264        if (rme9652->capture_substream == NULL) {
    … …  
    23402319
    23412320        runtime->hw = snd_rme9652_capture_subinfo;
    2342         runtime->dma_area = rme9652->capture_buffer;
    2343         runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
     2321        snd_pcm_set_runtime_buffer(substream, rme9652->capture_dma_buf);
    23442322
    23452323        if (rme9652->playback_substream == NULL) {
    … …  
    24532431        }
    24542432
    2455         err = pci_enable_device(pci);
     2433        err = pcim_enable_device(pci);
    24562434        if (err < 0)
    24572435                return err;
    … …  
    24632441                return err;
    24642442        rme9652->port = pci_resource_start(pci, 0);
    2465         rme9652->iobase = ioremap(rme9652->port, RME9652_IO_EXTENT);
     2443        rme9652->iobase = devm_ioremap(&pci->dev, rme9652->port, RME9652_IO_EXTENT);
    24662444        if (rme9652->iobase == NULL) {
    24672445                dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
    … …  
    24702448        }
    24712449       
    2472         if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED,
    2473                         KBUILD_MODNAME, rme9652)) {
     2450        if (devm_request_irq(&pci->dev, pci->irq, snd_rme9652_interrupt,
     2451                             IRQF_SHARED, KBUILD_MODNAME, rme9652)) {
    24742452                dev_err(card->dev, "unable to request IRQ %d\n", pci->irq);
    24752453                return -EBUSY;
    … …  
    25632541}
    25642542
    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 
    25732543static int snd_rme9652_probe(struct pci_dev *pci,
    25742544                             const struct pci_device_id *pci_id)
    … …  
    25862556        }
    25872557
    2588         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    2589                            sizeof(struct snd_rme9652), &card);
     2558        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     2559                                sizeof(struct snd_rme9652), &card);
    25902560
    25912561        if (err < 0)
    … …  
    25982568        err = snd_rme9652_create(card, rme9652, precise_ptr[dev]);
    25992569        if (err)
    2600                 goto free_card;
     2570                return err;
    26012571
    26022572        strcpy(card->shortname, rme9652->card_name);
    … …  
    26052575                card->shortname, rme9652->port, rme9652->irq);
    26062576        err = snd_card_register(card);
    2607         if (err) {
    2608 free_card:
    2609                 snd_card_free(card);
     2577        if (err)
    26102578                return err;
    2611         }
    26122579        pci_set_drvdata(pci, card);
    26132580        dev++;
    26142581        return 0;
    2615 }
    2616 
    2617 static void snd_rme9652_remove(struct pci_dev *pci)
    2618 {
    2619         snd_card_free(pci_get_drvdata(pci));
    26202582}
    26212583
    … …  
    26242586        .id_table = snd_rme9652_ids,
    26252587        .probe    = snd_rme9652_probe,
    2626         .remove   = snd_rme9652_remove,
    26272588};
    26282589

  • GPL/branches/uniaud32-next/alsa-kernel/pci/trident/trident.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/trident/trident.h

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/trident/trident_main.c

    r697 r710  
    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
     3333#ifndef TARGET_OS2
     3334        trident->tlb.buffer =
     3335                snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
     3336                                     2 * SNDRV_TRIDENT_MAX_PAGES * 4);
     3337        if (!trident->tlb.buffer) {
     3338                dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
     3339                return -ENOMEM;
     3340        }
     3341#else
    33393342        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
    33403343                                2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
    … …  
    33423345                return -ENOMEM;
    33433346        }
    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);
     3347#endif
     3348        trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer->area, SNDRV_TRIDENT_MAX_PAGES * 4);
     3349        trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer->addr, SNDRV_TRIDENT_MAX_PAGES * 4);
    33463350
    33473351        /* allocate and setup silent page and initialise TLB entries */
     3352#ifndef TARGET_OS2
     3353        trident->tlb.silent_page =
     3354                snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
     3355                                     SNDRV_TRIDENT_PAGE_SIZE);
     3356        if (!trident->tlb.silent_page) {
     3357                dev_err(trident->card->dev, "unable to allocate silent page\n");
     3358                return -ENOMEM;
     3359        }
     3360#else
    33483361        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
    33493362                                SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
    … …  
    33513364                return -ENOMEM;
    33523365        }
    3353         memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
     3366#endif
     3367        memset(trident->tlb.silent_page->area, 0, SNDRV_TRIDENT_PAGE_SIZE);
    33543368        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));
     3369                trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page->addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
    33563370
    33573371        /* use emu memory block manager code to manage tlb page allocation */
    … …  
    35103524                       int pcm_streams,
    35113525                       int pcm_spdif_device,
    3512                        int max_wavetable_size,
    3513                        struct snd_trident ** rtrident)
    3514 {
    3515         struct snd_trident *trident;
     3526                       int max_wavetable_size)
     3527{
     3528        struct snd_trident *trident = card->private_data;
    35163529        int i, err;
    35173530        struct snd_trident_voice *voice;
    35183531        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;
    35243532
    35253533        /* enable PCI device */
    3526         err = pci_enable_device(pci);
     3534        err = pcim_enable_device(pci);
    35273535        if (err < 0)
    35283536                return err;
    … …  
    35313539                dev_err(card->dev,
    35323540                        "architecture does not support 30bit PCI busmaster DMA\n");
    3533                 pci_disable_device(pci);
    35343541                return -ENXIO;
    35353542        }
    35363543       
    3537         trident = kzalloc(sizeof(*trident), GFP_KERNEL);
    3538         if (trident == NULL) {
    3539                 pci_disable_device(pci);
    3540                 return -ENOMEM;
    3541         }
    35423544        trident->device = (pci->vendor << 16) | pci->device;
    35433545        trident->card = card;
    … …  
    35553557        trident->synth.max_size = max_wavetable_size * 1024;
    35563558        trident->irq = -1;
     3559        card->private_free = snd_trident_free;
    35573560
    35583561        trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
    … …  
    35603563
    35613564        err = pci_request_regions(pci, "Trident Audio");
    3562         if (err < 0) {
    3563                 kfree(trident);
    3564                 pci_disable_device(pci);
     3565        if (err < 0)
    35653566                return err;
    3566         }
    35673567        trident->port = pci_resource_start(pci, 0);
    35683568
    3569         if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
    3570                         KBUILD_MODNAME, trident)) {
     3569        if (devm_request_irq(&pci->dev, pci->irq, snd_trident_interrupt,
     3570                             IRQF_SHARED, KBUILD_MODNAME, trident)) {
    35713571                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    3572                 snd_trident_free(trident);
    35733572                return -EBUSY;
    35743573        }
    … …  
    35783577        /* allocate 16k-aligned TLB for NX cards */
    35793578        trident->tlb.entries = NULL;
    3580         trident->tlb.buffer.area = NULL;
    35813579        if (trident->device == TRIDENT_DEVICE_ID_NX) {
    35823580                err = snd_trident_tlb_alloc(trident);
    3583                 if (err < 0) {
    3584                         snd_trident_free(trident);
     3581                if (err < 0)
    35853582                        return err;
    3586                 }
    35873583        }
    35883584
    … …  
    36043600                break;
    36053601        }
    3606         if (err < 0) {
    3607                 snd_trident_free(trident);
     3602        if (err < 0)
    36083603                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         }
    36163604
    36173605        err = snd_trident_mixer(trident, pcm_spdif_device);
    … …  
    36373625
    36383626        snd_trident_proc_init(trident);
    3639         *rtrident = trident;
    36403627        return 0;
    36413628}
    … …  
    36473634                the 4DWave card.
    36483635               
    3649    Parameters:  trident  - device specific private data for 4DWave card
     3636   Parameters:  card - card to release
    36503637
    36513638   Returns:     None.
    … …  
    36533640  ---------------------------------------------------------------------------*/
    36543641
    3655 static int snd_trident_free(struct snd_trident *trident)
    3656 {
     3642static void snd_trident_free(struct snd_card *card)
     3643{
     3644        struct snd_trident *trident = card->private_data;
     3645
    36573646        snd_trident_free_gameport(trident);
    36583647        snd_trident_disable_eso(trident);
    … …  
    36633652                outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
    36643653        }
    3665         if (trident->irq >= 0)
    3666                 free_irq(trident->irq, trident);
    3667         if (trident->tlb.buffer.area) {
     3654        if (trident->tlb.buffer) {
    36683655                outl(0, TRID_REG(trident, NX_TLBC));
    36693656                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;
     3657        }
    36783658}
    36793659

  • GPL/branches/uniaud32-next/alsa-kernel/pci/trident/trident_memory.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/via82xx.c

    r697 r710  
    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)
     2064#ifndef TARGET_OS2
     2065                chip->mpu_res = devm_request_region(&chip->pci->dev, mpu_port,
     2066                                                    2, "VIA82xx MPU401");
     2067#else
    20702068                chip->mpu_res = request_region(mpu_port, 2, "VIA82xx MPU401");
     2069#endif
    20712070        if (chip->mpu_res) {
    20722071                if (rev_h)
    … …  
    23072306#endif /* CONFIG_PM_SLEEP */
    23082307
    2309 static int snd_via82xx_free(struct via82xx *chip)
    2310 {
     2308static void snd_via82xx_free(struct snd_card *card)
     2309{
     2310        struct via82xx *chip = card->private_data;
    23112311        unsigned int i;
    23122312
    2313         if (chip->irq < 0)
    2314                 goto __end_hw;
    23152313        /* disable interrupts */
    23162314        for (i = 0; i < chip->num_devs; i++)
    23172315                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);
    23242316
    23252317        if (chip->chip_type == TYPE_VIA686) {
    … …  
    23282320                pci_write_config_byte(chip->pci, VIA_PNP_CONTROL, chip->old_legacy_cfg);
    23292321        }
    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);
    23392322}
    23402323
    … …  
    23432326                              int chip_type,
    23442327                              int revision,
    2345                               unsigned int ac97_clock,
    2346                               struct via82xx **r_via)
    2347 {
    2348         struct via82xx *chip;
     2328                              unsigned int ac97_clock)
     2329{
     2330        struct via82xx *chip = card->private_data;
    23492331        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);
     2332
     2333        err = pcim_enable_device(pci);
    23552334        if (err < 0)
    23562335                return err;
    2357 
    2358         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2359         if (!chip) {
    2360                 pci_disable_device(pci);
    2361                 return -ENOMEM;
    2362         }
    23632336
    23642337        chip->chip_type = chip_type;
    … …  
    23782351
    23792352        err = pci_request_regions(pci, card->driver);
    2380         if (err < 0) {
    2381                 kfree(chip);
    2382                 pci_disable_device(pci);
     2353        if (err < 0)
    23832354                return err;
    2384         }
    23852355        chip->port = pci_resource_start(pci, 0);
     2356#ifndef TARGET_OS2
     2357        if (devm_request_irq(&pci->dev, pci->irq,
     2358                             chip_type == TYPE_VIA8233 ?
     2359                             snd_via8233_interrupt : snd_via686_interrupt,
     2360                             IRQF_SHARED,
     2361                             KBUILD_MODNAME, chip)) {
     2362                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
     2363                return -EBUSY;
     2364        }
     2365#else
    23862366        if (request_irq(pci->irq,
    23872367                        chip_type == TYPE_VIA8233 ?
    … …  
    23932373                return -EBUSY;
    23942374        }
     2375#endif
    23952376        chip->irq = pci->irq;
    23962377        card->sync_irq = chip->irq;
     2378        card->private_free = snd_via82xx_free;
    23972379        if (ac97_clock >= 8000 && ac97_clock <= 48000)
    23982380                chip->ac97_clock = ac97_clock;
    23992381
    24002382        err = snd_via82xx_chip_init(chip);
    2401         if (err < 0) {
    2402                 snd_via82xx_free(chip);
     2383        if (err < 0)
    24032384                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         }
    24112385
    24122386        /* The 8233 ac97 controller does not implement the master bit
    … …  
    24142388         * We call pci_set_master here because it does not hurt. */
    24152389        pci_set_master(pci);
    2416 
    2417         *r_via = chip;
    24182390        return 0;
    24192391}
    … …  
    25162488        int err;
    25172489
    2518         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
     2490        err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
     2491                                sizeof(*chip), &card);
    25192492        if (err < 0)
    25202493                return err;
     2494        chip = card->private_data;
    25212495
    25222496        card_type = pci_id->driver_data;
    … …  
    25572531        default:
    25582532                dev_err(card->dev, "invalid card type %d\n", card_type);
    2559                 err = -EINVAL;
    2560                 goto __error;
     2533                return -EINVAL;
    25612534        }
    25622535               
    25632536        err = snd_via82xx_create(card, pci, chip_type, pci->revision,
    2564                                  ac97_clock, &chip);
     2537                                 ac97_clock);
    25652538        if (err < 0)
    2566                 goto __error;
    2567         card->private_data = chip;
     2539                return err;
    25682540        err = snd_via82xx_mixer_new(chip, ac97_quirk);
    25692541        if (err < 0)
    2570                 goto __error;
     2542                return err;
    25712543
    25722544        if (chip_type == TYPE_VIA686) {
    25732545                err = snd_via686_pcm_new(chip);
    25742546                if (err < 0)
    2575                         goto __error;
     2547                        return err;
    25762548                err = snd_via686_init_misc(chip);
    25772549                if (err < 0)
    2578                         goto __error;
     2550                        return err;
    25792551        } else {
    25802552                if (chip_type == TYPE_VIA8233A) {
    25812553                        err = snd_via8233a_pcm_new(chip);
    25822554                        if (err < 0)
    2583                                 goto __error;
     2555                                return err;
    25842556                        // chip->dxs_fixed = 1; /* FIXME: use 48k for DXS #3? */
    25852557                } else {
    25862558                        err = snd_via8233_pcm_new(chip);
    25872559                        if (err < 0)
    2588                                 goto __error;
     2560                                return err;
    25892561                        if (dxs_support == VIA_DXS_48K)
    25902562                                chip->dxs_fixed = 1;
    … …  
    25982570                err = snd_via8233_init_misc(chip);
    25992571                if (err < 0)
    2600                         goto __error;
     2572                        return err;
    26012573        }
    26022574
    … …  
    26122584
    26132585        err = snd_card_register(card);
    2614         if (err < 0) {
    2615                 snd_card_free(card);
     2586        if (err < 0)
    26162587                return err;
    2617         }
    26182588        pci_set_drvdata(pci, card);
    26192589        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));
    26292590}
    26302591
    … …  
    26332594        .id_table = snd_via82xx_ids,
    26342595        .probe = snd_via82xx_probe,
    2635         .remove = snd_via82xx_remove,
    26362596        .driver = {
    26372597                .pm = SND_VIA82XX_PM_OPS,

  • GPL/branches/uniaud32-next/alsa-kernel/pci/ymfpci/ymfpci.c

    r697 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/ymfpci/ymfpci.h

    r615 r710  
    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/branches/uniaud32-next/alsa-kernel/pci/ymfpci/ymfpci_main.c

    r697 r710  
    21212121        /* work_ptr must be aligned to 256 bytes, but it's already
    21222122           covered with the kernel page allocation mechanism */
     2123#ifndef TARGET_OS2
     2124        chip->work_ptr = snd_devm_alloc_pages(&chip->pci->dev,
     2125                                              SNDRV_DMA_TYPE_DEV, size);
     2126        if (!chip->work_ptr)
     2127                return -ENOMEM;
     2128#else
    21232129        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
    21242130                                size, &chip->work_ptr) < 0)
    21252131                return -ENOMEM;
    2126         ptr = chip->work_ptr.area;
    2127         ptr_addr = chip->work_ptr.addr;
     2132#endif
     2133        ptr = chip->work_ptr->area;
     2134        ptr_addr = chip->work_ptr->addr;
    21282135        memset(ptr, 0, size);   /* for sure */
    21292136
    … …  
    21702177       
    21712178        snd_BUG_ON(ptr + chip->work_size !=
    2172                    chip->work_ptr.area + chip->work_ptr.bytes);
     2179                   chip->work_ptr->area + chip->work_ptr->bytes);
    21732180
    21742181        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, chip->bank_base_playback_addr);
    … …  
    22012208}
    22022209
    2203 static int snd_ymfpci_free(struct snd_ymfpci *chip)
    2204 {
     2210static void snd_ymfpci_free(struct snd_card *card)
     2211{
     2212        struct snd_ymfpci *chip = card->private_data;
    22052213        u16 ctrl;
    22062214
    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         }
     2215        snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
     2216        snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
     2217        snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0);
     2218        snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0);
     2219        snd_ymfpci_disable_dsp(chip);
     2220        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0);
     2221        snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0);
     2222        snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0);
     2223        snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0);
     2224        snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0);
     2225        ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
     2226        snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
    22242227
    22252228        snd_ymfpci_ac3_done(chip);
    22262229
    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);
    22422230        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 
     2231       
    22492232        pci_write_config_word(chip->pci, 0x40, chip->old_legacy_ctrl);
    22502233       
    2251         pci_disable_device(chip->pci);
    22522234        release_firmware(chip->dsp_microcode);
    22532235        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);
    22622236}
    22632237
    … …  
    23512325int snd_ymfpci_create(struct snd_card *card,
    23522326                      struct pci_dev *pci,
    2353                       unsigned short old_legacy_ctrl,
    2354                       struct snd_ymfpci **rchip)
    2355 {
    2356         struct snd_ymfpci *chip;
     2327                      unsigned short old_legacy_ctrl)
     2328{
     2329        struct snd_ymfpci *chip = card->private_data;
    23572330        int err;
    2358         static const struct snd_device_ops ops = {
    2359                 .dev_free =     snd_ymfpci_dev_free,
    2360         };
    2361        
    2362         *rchip = NULL;
    2363 
     2331       
    23642332        /* enable PCI device */
    2365         err = pci_enable_device(pci);
     2333        err = pcim_enable_device(pci);
    23662334        if (err < 0)
    23672335                return err;
    23682336
    2369         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2370         if (chip == NULL) {
    2371                 pci_disable_device(pci);
    2372                 return -ENOMEM;
    2373         }
    23742337        chip->old_legacy_ctrl = old_legacy_ctrl;
    23752338        spin_lock_init(&chip->reg_lock);
    … …  
    23822345        chip->device_id = pci->device;
    23832346        chip->rev = pci->revision;
     2347
     2348        err = pci_request_regions(pci, "YMFPCI");
     2349        if (err < 0)
     2350                return err;
     2351
    23842352        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) {
     2353        chip->reg_area_virt = devm_ioremap(&pci->dev, chip->reg_area_phys, 0x8000);
     2354        if (!chip->reg_area_virt) {
    23912355                dev_err(chip->card->dev,
    23922356                        "unable to grab memory region 0x%lx-0x%lx\n",
    23932357                        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,
     2358                return -EBUSY;
     2359        }
     2360        pci_set_master(pci);
     2361        chip->src441_used = -1;
     2362
     2363        if (devm_request_irq(&pci->dev, pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
    23982364                        KBUILD_MODNAME, chip)) {
    23992365                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
    2400                 err = -EBUSY;
    2401                 goto free_chip;
     2366                return -EBUSY;
    24022367        }
    24032368        chip->irq = pci->irq;
    24042369        card->sync_irq = chip->irq;
     2370        card->private_free = snd_ymfpci_free;
    24052371
    24062372        snd_ymfpci_aclink_reset(pci);
    2407         if (snd_ymfpci_codec_ready(chip, 0) < 0) {
    2408                 err = -EIO;
    2409                 goto free_chip;
    2410         }
     2373        if (snd_ymfpci_codec_ready(chip, 0) < 0)
     2374                return -EIO;
    24112375
    24122376        err = snd_ymfpci_request_firmware(chip);
    24132377        if (err < 0) {
    24142378                dev_err(chip->card->dev, "firmware request failed: %d\n", err);
    2415                 goto free_chip;
     2379                return err;
    24162380        }
    24172381        snd_ymfpci_download_image(chip);
    … …  
    24192383        udelay(100); /* seems we need a delay after downloading image.. */
    24202384
    2421         if (snd_ymfpci_memalloc(chip) < 0) {
    2422                 err = -EIO;
    2423                 goto free_chip;
    2424         }
     2385        if (snd_ymfpci_memalloc(chip) < 0)
     2386                return -EIO;
    24252387
    24262388        err = snd_ymfpci_ac3_init(chip);
    24272389        if (err < 0)
    2428                 goto free_chip;
     2390                return err;
    24292391
    24302392#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         }
     2393        chip->saved_regs = devm_kmalloc_array(&pci->dev, YDSXGR_NUM_SAVED_REGS,
     2394                                              sizeof(u32), GFP_KERNEL);
     2395        if (!chip->saved_regs)
     2396                return -ENOMEM;
    24372397#endif
    24382398
    2439         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2440         if (err < 0)
    2441                 goto free_chip;
    2442 
    24432399        snd_ymfpci_proc_init(card, chip);
    24442400
    2445         *rchip = chip;
    2446         return 0;
    2447 
    2448 free_chip:
    2449         snd_ymfpci_free(chip);
    2450         return err;
    2451 }
     2401        return 0;
     2402}

  • GPL/branches/uniaud32-next/include/linux/device.h

    r647 r710  
    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, D)
     295#define devm_kmalloc_array(A, B, C, D) kmalloc_array(B, C, D)
    293296#endif /* _LINUX_DEVICE_H */
    294297

  • GPL/branches/uniaud32-next/include/linux/interrupt.h

    r647 r710  
    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/branches/uniaud32-next/include/linux/io.h

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

  • GPL/branches/uniaud32-next/include/linux/ioport.h

    r647 r710  
    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/branches/uniaud32-next/include/linux/pci.h

    r708 r710  
    770770
    771771#define dev_is_pci(d) (true)
    772 
     772#define pcim_enable_device pci_enable_device
     773#define pcim_iomap pci_iomap
    773774#endif /* LINUX_PCI_H */
Note: See TracChangeset for help on using the changeset viewer.