Changeset 410


Ignore:
Timestamp:
Jan 25, 2009, 11:51:57 PM (16 years ago)
Author:
Paul Smedley
Message:

Update ALSA core to 1.0.19 level

Location:
GPL/branches/uniaud32-2.0
Files:
94 edited

Legend:

Unmodified
Added
Removed

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

    r399 r410  
    682682
    683683/*
     684 * called on card->id change
     685 */
     686void snd_info_card_id_change(struct snd_card *card)
     687{
     688        mutex_lock(&info_mutex);
     689        if (card->proc_root_link) {
     690                snd_remove_proc_entry(snd_proc_root, card->proc_root_link);
     691                card->proc_root_link = NULL;
     692        }
     693#ifndef TARGET_OS2
     694        if (strcmp(card->id, card->proc_root->name))
     695                card->proc_root_link = proc_symlink(card->id,
     696                                                    snd_proc_root,
     697                                                    card->proc_root->name);
     698#endif
     699        mutex_unlock(&info_mutex);
     700}
     701
     702/*
    684703 * de-register the card proc file
    685704 * called from init.c

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

    r402 r410  
    138138
    139139/**
    140  *  snd_card_new - create and initialize a soundcard structure
     140 *  snd_card_create - create and initialize a soundcard structure
    141141 *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
    142142 *  @xid: card identification (ASCII string)
    143143 *  @module: top level module for locking
    144144 *  @extra_size: allocate this extra size after the main soundcard structure
     145 *  @card_ret: the pointer to store the created card instance
    145146 *
    146147 *  Creates and initializes a soundcard structure.
    147148 *
    148  *  Returns kmallocated snd_card structure. Creates the ALSA control interface
    149  *  (which is blocked until snd_card_register function is called).
     149 *  The function allocates snd_card instance via kzalloc with the given
     150 *  space for the driver to use freely.  The allocated struct is stored
     151 *  in the given card_ret pointer.
     152 *
     153 *  Returns zero if successful or a negative error code.
    150154 */
    151 struct snd_card *snd_card_new(int idx, const char *xid,
    152                          struct module *module, int extra_size)
     155int snd_card_create(int idx, const char *xid,
     156                    struct module *module, int extra_size,
     157                    struct snd_card **card_ret)
    153158{
    154159        struct snd_card *card;
    155160        int err, idx2;
     161
     162        if (snd_BUG_ON(!card_ret))
     163                return -EINVAL;
     164        *card_ret = NULL;
    156165
    157166        if (extra_size < 0)
    158167                extra_size = 0;
    159168        card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
    160 
    161         if (card == NULL)
    162                 return NULL;
     169        if (!card)
     170                return -ENOMEM;
    163171        if (xid) {
    164                 if (!snd_info_check_reserved_words(xid))
     172                if (!snd_info_check_reserved_words(xid)) {
     173                        snd_printk(KERN_ERR
     174                                   "given id string '%s' is reserved.\n", xid);
     175                        err = -EBUSY;
    165176                        goto __error;
     177                }
    166178                strlcpy(card->id, xid, sizeof(card->id));
    167179        }
    … …  
    220232        /* the control interface cannot be accessed from the user space until */
    221233        /* snd_cards_bitmask and snd_cards are set with snd_card_register */
    222         if ((err = snd_ctl_create(card)) < 0) {
    223                 snd_printd("unable to register control minors\n");
     234        err = snd_ctl_create(card);
     235        if (err < 0) {
     236                snd_printk(KERN_ERR "unable to register control minors\n");
    224237                goto __error;
    225238        }
    226         if ((err = snd_info_card_create(card)) < 0) {
    227                 snd_printd("unable to create card info\n");
     239        err = snd_info_card_create(card);
     240        if (err < 0) {
     241                snd_printk(KERN_ERR "unable to create card info\n");
    228242                goto __error_ctl;
    229243        }
    230244        if (extra_size > 0)
    231245                card->private_data = (char *)card + sizeof(struct snd_card);
    232         return card;
     246        *card_ret = card;
     247        return 0;
    233248
    234249      __error_ctl:
    … …  
    236251      __error:
    237252        kfree(card);
    238         return NULL;
    239 }
    240 
    241 EXPORT_SYMBOL(snd_card_new);
     253        return err;
     254}
     255EXPORT_SYMBOL(snd_card_create);
    242256
    243257/* return non-zero if a card is already locked */
    … …  
    573587}
    574588
     589#ifndef CONFIG_SYSFS_DEPRECATED
     590static ssize_t
     591card_id_show_attr(struct device *dev,
     592                  struct device_attribute *attr, char *buf)
     593{
     594        struct snd_card *card = dev_get_drvdata(dev);
     595        return snprintf(buf, PAGE_SIZE, "%s\n", card ? card->id : "(null)");
     596}
     597
     598static ssize_t
     599card_id_store_attr(struct device *dev, struct device_attribute *attr,
     600                   const char *buf, size_t count)
     601{
     602        struct snd_card *card = dev_get_drvdata(dev);
     603        char buf1[sizeof(card->id)];
     604        size_t copy = count > sizeof(card->id) - 1 ?
     605                                        sizeof(card->id) - 1 : count;
     606        size_t idx;
     607        int c;
     608
     609        for (idx = 0; idx < copy; idx++) {
     610                c = buf[idx];
     611                if (!isalnum(c) && c != '_' && c != '-')
     612                        return -EINVAL;
     613        }
     614        memcpy(buf1, buf, copy);
     615        buf1[copy] = '\0';
     616        mutex_lock(&snd_card_mutex);
     617        if (!snd_info_check_reserved_words(buf1)) {
     618             __exist:
     619                mutex_unlock(&snd_card_mutex);
     620                return -EEXIST;
     621        }
     622        for (idx = 0; idx < snd_ecards_limit; idx++) {
     623                if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1))
     624                        goto __exist;
     625        }
     626        strcpy(card->id, buf1);
     627        snd_info_card_id_change(card);
     628        mutex_unlock(&snd_card_mutex);
     629
     630        return count;
     631}
     632
     633static struct device_attribute card_id_attrs =
     634        __ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
     635
     636static ssize_t
     637card_number_show_attr(struct device *dev,
     638                     struct device_attribute *attr, char *buf)
     639{
     640        struct snd_card *card = dev_get_drvdata(dev);
     641        return snprintf(buf, PAGE_SIZE, "%i\n", card ? card->number : -1);
     642}
     643
     644static struct device_attribute card_number_attrs =
     645        __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
     646#endif /* CONFIG_SYSFS_DEPRECATED */
     647
    575648/**
    576649 *  snd_card_register - register the soundcard
    … …  
    593666        if (!card->card_dev) {
    594667                card->card_dev = device_create(sound_class, card->dev,
    595                                                MKDEV(0, 0), NULL,
     668                                               MKDEV(0, 0), card,
    596669                                               "card%i", card->number);
    597670                if (IS_ERR(card->card_dev))
    … …  
    615688        if (snd_mixer_oss_notify_callback)
    616689                snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
     690#endif
     691#ifndef CONFIG_SYSFS_DEPRECATED
     692        if (card->card_dev) {
     693                err = device_create_file(card->card_dev, &card_id_attrs);
     694                if (err < 0)
     695                        return err;
     696                err = device_create_file(card->card_dev, &card_number_attrs);
     697                if (err < 0)
     698                        return err;
     699        }
    617700#endif
    618701        return 0;

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

    r402 r410  
    156156                return;
    157157        if (up) {
    158                 tasklet_hi_schedule(&substream->runtime->tasklet);
     158                tasklet_schedule(&substream->runtime->tasklet);
    159159        } else {
    160160                tasklet_kill(&substream->runtime->tasklet);
    … …  
    929929        if (result > 0) {
    930930                if (runtime->event)
    931                         tasklet_hi_schedule(&runtime->tasklet);
     931                        tasklet_schedule(&runtime->tasklet);
    932932                else if (snd_rawmidi_ready(substream))
    933933                        wake_up(&runtime->sleep);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/core/rtctimer.c

    r399 r410  
    119119static void rtctimer_interrupt(void *private_data)
    120120{
    121         tasklet_hi_schedule(private_data);
     121        tasklet_schedule(private_data);
    122122}
    123123

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/core/sound.c

    r399 r410  
    161161        old_fops = file->f_op;
    162162        file->f_op = fops_get(mptr->f_ops);
     163        if (file->f_op == NULL) {
     164                file->f_op = old_fops;
     165                return -ENODEV;
     166        }
    163167        if (file->f_op->open)
    164168                err = file->f_op->open(inode, file);

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

    r402 r410  
    748748
    749749        if (use_tasklet)
    750                 tasklet_hi_schedule(&timer->task_queue);
     750                tasklet_schedule(&timer->task_queue);
    751751}
    752752

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/core/vmaster.c

    r399 r410  
    5151        struct link_ctl_info info;
    5252        int vals[2];            /* current values */
     53        unsigned int flags;
    5354        struct snd_kcontrol slave; /* the copy of original control entry */
    5455};
    5556
     57static int slave_update(struct link_slave *slave)
     58{
     59        struct snd_ctl_elem_value *uctl;
     60        int err, ch;
     61
     62        uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
     63        if (!uctl)
     64                return -ENOMEM;
     65        uctl->id = slave->slave.id;
     66        err = slave->slave.get(&slave->slave, uctl);
     67        for (ch = 0; ch < slave->info.count; ch++)
     68                slave->vals[ch] = uctl->value.integer.value[ch];
     69        kfree(uctl);
     70        return 0;
     71}
     72
    5673/* get the slave ctl info and save the initial values */
    5774static int slave_init(struct link_slave *slave)
    5875{
    5976        struct snd_ctl_elem_info *uinfo;
    60         struct snd_ctl_elem_value *uctl;
    61         int err, ch;
    62 
    63         if (slave->info.count)
    64                 return 0; /* already initialized */
     77        int err;
     78
     79        if (slave->info.count) {
     80                /* already initialized */
     81                if (slave->flags & SND_CTL_SLAVE_NEED_UPDATE)
     82                        return slave_update(slave);
     83                return 0;
     84        }
    6585
    6686        uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL);
    … …  
    86106        kfree(uinfo);
    87107
    88         uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
    89         if (!uctl)
    90                 return -ENOMEM;
    91         uctl->id = slave->slave.id;
    92         err = slave->slave.get(&slave->slave, uctl);
    93         for (ch = 0; ch < slave->info.count; ch++)
    94                 slave->vals[ch] = uctl->value.integer.value[ch];
    95         kfree(uctl);
    96         return 0;
     108        return slave_update(slave);
    97109}
    98110
    … …  
    230242 * - master can only attenuate the volume, no gain
    231243 */
    232 int snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
     244int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave,
     245                       unsigned int flags)
    233246{
    234247        struct link_master *master_link = snd_kcontrol_chip(master);
    … …  
    242255        memcpy(srec->slave.vd, slave->vd, slave->count * sizeof(*slave->vd));
    243256        srec->master = master_link;
     257        srec->flags = flags;
    244258
    245259        /* override callbacks */
    … …  
    255269        return 0;
    256270}
    257 
    258 EXPORT_SYMBOL(snd_ctl_add_slave);
     271EXPORT_SYMBOL(_snd_ctl_add_slave);
    259272
    260273/*
    … …  
    368381        return kctl;
    369382}
    370 
    371383EXPORT_SYMBOL(snd_ctl_make_virtual_master);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/drivers/dummy.c

    r399 r410  
    589589        int dev = devptr->id;
    590590
    591         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    592                             sizeof(struct snd_dummy));
    593         if (card == NULL)
    594                 return -ENOMEM;
     591        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     592                              sizeof(struct snd_dummy), &card);
     593        if (err < 0)
     594                return err;
    595595        dummy = card->private_data;
    596596        dummy->card = card;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/drivers/mpu401/mpu401.c

    r399 r410  
    8989
    9090        *rcard = NULL;
    91         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    92         if (card == NULL)
    93                 return -ENOMEM;
     91        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     92        if (err < 0)
     93                return err;
    9494        strcpy(card->driver, "MPU-401 UART");
    9595        strcpy(card->shortname, card->driver);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/drivers/mtpav.c

    r399 r410  
    697697        struct mtpav *mtp_card;
    698698
    699         card = snd_card_new(index, id, THIS_MODULE, sizeof(*mtp_card));
    700         if (! card)
    701                 return -ENOMEM;
     699        err = snd_card_create(index, id, THIS_MODULE, sizeof(*mtp_card), &card);
     700        if (err < 0)
     701                return err;
    702702
    703703        mtp_card = card->private_data;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/drivers/serial-u16550.c

    r305 r410  
    937937        }
    938938
    939         card  = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    940         if (card == NULL)
    941                 return -ENOMEM;
     939        err  = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     940        if (err < 0)
     941                return err;
    942942
    943943        strcpy(card->driver, "Serial");

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/drivers/virmidi.c

    r305 r410  
    9191        int dev = devptr->id;
    9292
    93         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    94                             sizeof(struct snd_card_virmidi));
    95         if (card == NULL)
    96                 return -ENOMEM;
     93        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     94                              sizeof(struct snd_card_virmidi), &card);
     95        if (err < 0)
     96                return err;
    9797        vmidi = (struct snd_card_virmidi *)card->private_data;
    9898        vmidi->card = card;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/compat_22.h

    r305 r410  
    5656#endif
    5757
    58 #define tasklet_hi_schedule(t)  queue_task((t), &tq_immediate); \
    59                                 mark_bh(IMMEDIATE_BH)
    60 
    61 #define tasklet_init(t,f,d)     (t)->next = NULL; \
    62                                 (t)->sync = 0; \
    63                                 (t)->routine = (void (*)(void *))(f); \
    64                                 (t)->data = (void *)(d)
    65 
    66 #define tasklet_struct          tq_struct
     58/* this is identical with tq_struct but the "routine" field is renamed to "func" */
     59struct tasklet_struct {
     60        struct tasklet_struct *next;    /* linked list of active bh's */
     61        unsigned long sync;             /* must be initialized to zero */
     62        void (*func)(void *);           /* function to call */
     63        void *data;                     /* argument to function */
     64};
     65
     66#define tasklet_schedule(t)     do { \
     67        queue_task((struct tq_struct *)(t), &tq_immediate);\
     68        mark_bh(IMMEDIATE_BH); \
     69} while (0)
     70
     71#define tasklet_hi_schedule(t)  tasklet_schedule(t)
     72
     73#define tasklet_init(t,f,d)     do { \
     74        (t)->next = NULL; \
     75        (t)->sync = 0; \
     76        (t)->func = (void (*)(void *))(f); \
     77        (t)->data = (void *)(d); \
     78} while (0)
    6779
    6880#define tasklet_unlock_wait(t)  while (test_bit(0, &(t)->sync)) { }
     81#define tasklet_kill(t)         tasklet_unlock_wait(t) /* FIXME: world is not perfect... */
    6982
    7083#define rwlock_init(x) do { *(x) = RW_LOCK_UNLOCKED; } while(0)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/config.h

    r399 r410  
    4040#endif
    4141
     42#ifndef __deprecated
     43# define __deprecated           /* unimplemented */
     44#endif
     45
    4246typedef unsigned int fmode_t;
    4347
    … …  
    223227int snd_compat_schedule_work(struct work_struct *work);
    224228#define schedule_work(w) snd_compat_schedule_work(w)
     229void snd_compat_flush_workqueue(struct workqueue_struct *wq);
     230#define flush_workqueue(wq) snd_compat_flush_workqueue((wq));
    225231
    226232/* Name change */
    … …  
    309315#define CONFIG_HAVE_PCI_DEV_PRESENT
    310316#define CONFIG_SND_DEBUG_DETECT
     317#define CONFIG_SND_DEBUG_VERBOSE
    311318#define CONFIG_SYSFS_DEPRECATED
    312319#undef interrupt

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

    r398 r410  
    179179struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
    180180                                                 const unsigned int *tlv);
    181 int snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave);
    182                      
     181int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave,
     182                       unsigned int flags);
     183/* optional flags for slave */
     184#define SND_CTL_SLAVE_NEED_UPDATE       (1 << 0)
     185
     186static inline int
     187snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
     188{
     189        return _snd_ctl_add_slave(master, slave, 0);
     190}
     191
     192static inline int
     193snd_ctl_add_slave_uncached(struct snd_kcontrol *master,
     194                           struct snd_kcontrol *slave)
     195{
     196        return _snd_ctl_add_slave(master, slave, SND_CTL_SLAVE_NEED_UPDATE);
     197}
     198
    183199#endif  /* __SOUND_CONTROL_H */

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

    r402 r410  
    320320#endif
    321321
     322int snd_card_create(int idx, const char *id,
     323                    struct module *module, int extra_size,
     324                    struct snd_card **card_ret);
     325
     326static inline __deprecated
    322327struct snd_card *snd_card_new(int idx, const char *id,
    323                          struct module *module, int extra_size);
     328                              struct module *module, int extra_size)
     329{
     330        struct snd_card *card;
     331        if (snd_card_create(idx, id, module, extra_size, &card) < 0)
     332                return NULL;
     333        return card;
     334}
     335
    324336int snd_card_disconnect(struct snd_card *card);
    325337int snd_card_free(struct snd_card *card);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/info.h

    r305 r410  
    4141
    4242struct snd_info_entry_text {
    43         void (*read) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
    44         void (*write) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
     43        void (*read)(struct snd_info_entry *entry,
     44                     struct snd_info_buffer *buffer);
     45        void (*write)(struct snd_info_entry *entry,
     46                      struct snd_info_buffer *buffer);
    4547};
    4648
    4749struct snd_info_entry_ops {
    48         int (*open) (struct snd_info_entry *entry,
    49                      unsigned short mode, void **file_private_data);
    50         int (*release) (struct snd_info_entry * entry,
    51                         unsigned short mode, void *file_private_data);
    52         long (*read) (struct snd_info_entry *entry, void *file_private_data,
    53                       struct file * file, char __user *buf,
     50        int (*open)(struct snd_info_entry *entry,
     51                    unsigned short mode, void **file_private_data);
     52        int (*release)(struct snd_info_entry *entry,
     53                       unsigned short mode, void *file_private_data);
     54        long (*read)(struct snd_info_entry *entry, void *file_private_data,
     55                     struct file *file, char __user *buf,
     56                     unsigned long count, unsigned long pos);
     57        long (*write)(struct snd_info_entry *entry, void *file_private_data,
     58                      struct file *file, const char __user *buf,
    5459                      unsigned long count, unsigned long pos);
    55         long (*write) (struct snd_info_entry *entry, void *file_private_data,
    56                        struct file * file, const char __user *buf,
    57                        unsigned long count, unsigned long pos);
    58         long long (*llseek) (struct snd_info_entry *entry, void *file_private_data,
    59                             struct file * file, long long offset, int orig);
    60         unsigned int (*poll) (struct snd_info_entry *entry, void *file_private_data,
    61                               struct file * file, poll_table * wait);
    62         int (*ioctl) (struct snd_info_entry *entry, void *file_private_data,
    63                       struct file * file, unsigned int cmd, unsigned long arg);
    64         int (*mmap) (struct snd_info_entry *entry, void *file_private_data,
    65                      struct inode * inode, struct file * file,
    66                      struct vm_area_struct * vma);
     60        long long (*llseek)(struct snd_info_entry *entry,
     61                            void *file_private_data, struct file *file,
     62                            long long offset, int orig);
     63        unsigned int(*poll)(struct snd_info_entry *entry,
     64                            void *file_private_data, struct file *file,
     65                            poll_table *wait);
     66        int (*ioctl)(struct snd_info_entry *entry, void *file_private_data,
     67                     struct file *file, unsigned int cmd, unsigned long arg);
     68        int (*mmap)(struct snd_info_entry *entry, void *file_private_data,
     69                    struct inode *inode, struct file *file,
     70                    struct vm_area_struct *vma);
    6771};
    6872
    … …  
    108112
    109113#ifndef TARGET_OS2
    110 int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...) __attribute__ ((format (printf, 2, 3)));
     114int snd_iprintf(struct snd_info_buffer *buffer, char *fmt, ...) \
     115                                __attribute__ ((format (printf, 2, 3)));
    111116#else
    112117int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...);
    … …  
    115120int snd_info_done(void);
    116121
    117 int snd_info_get_line(struct snd_info_buffer * buffer, char *line, int len);
     122int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len);
    118123char *snd_info_get_str(char *dest, char *src, int len);
    119 struct snd_info_entry *snd_info_create_module_entry(struct module * module,
     124struct snd_info_entry *snd_info_create_module_entry(struct module *module,
    120125                                               const char *name,
    121                                                struct snd_info_entry * parent);
    122 struct snd_info_entry *snd_info_create_card_entry(struct snd_card * card,
     126                                               struct snd_info_entry *parent);
     127struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card,
    123128                                             const char *name,
    124                                              struct snd_info_entry * parent);
    125 void snd_info_free_entry(struct snd_info_entry * entry);
    126 int snd_info_store_text(struct snd_info_entry * entry);
    127 int snd_info_restore_text(struct snd_info_entry * entry);
    128 
    129 int snd_info_card_create(struct snd_card * card);
    130 int snd_info_card_register(struct snd_card * card);
    131 int snd_info_card_free(struct snd_card * card);
    132 void snd_info_card_disconnect(struct snd_card * card);
    133 int snd_info_register(struct snd_info_entry * entry);
     129                                             struct snd_info_entry *parent);
     130void snd_info_free_entry(struct snd_info_entry *entry);
     131int snd_info_store_text(struct snd_info_entry *entry);
     132int snd_info_restore_text(struct snd_info_entry *entry);
     133
     134int snd_info_card_create(struct snd_card *card);
     135int snd_info_card_register(struct snd_card *card);
     136int snd_info_card_free(struct snd_card *card);
     137void snd_info_card_disconnect(struct snd_card *card);
     138void snd_info_card_id_change(struct snd_card *card);
     139int snd_info_register(struct snd_info_entry *entry);
    134140
    135141/* for card drivers */
    136 int snd_card_proc_new(struct snd_card *card, const char *name, struct snd_info_entry **entryp);
     142int snd_card_proc_new(struct snd_card *card, const char *name,
     143                      struct snd_info_entry **entryp);
    137144
    138145static inline void snd_info_set_text_ops(struct snd_info_entry *entry,
    139                                          void *private_data,
    140                                          void (*read)(struct snd_info_entry *, struct snd_info_buffer *))
     146        void *private_data,
     147        void (*read)(struct snd_info_entry *, struct snd_info_buffer *))
    141148{
    142149        entry->private_data = private_data;
    … …  
    151158#define snd_oss_root NULL
    152159
    153 static inline int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...) { return 0; }
     160static inline int snd_iprintf(struct snd_info_buffer *buffer, char *fmt, ...) { return 0; }
    154161static inline int snd_info_init(void) { return 0; }
    155162static inline int snd_info_done(void) { return 0; }
    156163
    157 static inline int snd_info_get_line(struct snd_info_buffer * buffer, char *line, int len) { return 0; }
     164static inline int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) { return 0; }
    158165static inline char *snd_info_get_str(char *dest, char *src, int len) { return NULL; }
    159 static inline struct snd_info_entry *snd_info_create_module_entry(struct module * module, const char *name, struct snd_info_entry * parent) { return NULL; }
    160 static inline struct snd_info_entry *snd_info_create_card_entry(struct snd_card * card, const char *name, struct snd_info_entry * parent) { return NULL; }
    161 static inline void snd_info_free_entry(struct snd_info_entry * entry) { ; }
    162 
    163 static inline int snd_info_card_create(struct snd_card * card) { return 0; }
    164 static inline int snd_info_card_register(struct snd_card * card) { return 0; }
    165 static inline int snd_info_card_free(struct snd_card * card) { return 0; }
    166 static inline void snd_info_card_disconnect(struct snd_card * card) { }
    167 static inline int snd_info_register(struct snd_info_entry * entry) { return 0; }
     166static inline struct snd_info_entry *snd_info_create_module_entry(struct module *module, const char *name, struct snd_info_entry *parent) { return NULL; }
     167static inline struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, const char *name, struct snd_info_entry *parent) { return NULL; }
     168static inline void snd_info_free_entry(struct snd_info_entry *entry) { ; }
     169
     170static inline int snd_info_card_create(struct snd_card *card) { return 0; }
     171static inline int snd_info_card_register(struct snd_card *card) { return 0; }
     172static inline int snd_info_card_free(struct snd_card *card) { return 0; }
     173static inline void snd_info_card_disconnect(struct snd_card *card) { }
     174static inline void snd_info_card_id_change(struct snd_card *card) { }
     175static inline int snd_info_register(struct snd_info_entry *entry) { return 0; }
    168176
    169177static inline int snd_card_proc_new(struct snd_card *card, const char *name,

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

    r401 r410  
    3131 * Jack types which can be reported.  These values are used as a
    3232 * bitmask.
     33 *
     34 * Note that this must be kept in sync with the lookup table in
     35 * sound/core/jack.c.
    3336 */
    3437enum snd_jack_types {
    … …  
    3740        SND_JACK_HEADSET        = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE,
    3841        SND_JACK_LINEOUT        = 0x0004,
     42        SND_JACK_MECHANICAL     = 0x0008, /* If detected separately */
     43        SND_JACK_VIDEOOUT       = 0x0010,
     44        SND_JACK_AVOUT          = SND_JACK_LINEOUT | SND_JACK_VIDEOOUT,
    3945};
    4046

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/soc-dapm.h

    r399 r410  
    7777{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
    7878        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols}
     79#define SND_SOC_DAPM_MIXER_NAMED_CTL(wname, wreg, wshift, winvert, \
     80         wcontrols, wncontrols)\
     81{       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, .reg = wreg, \
     82        .shift = wshift, .invert = winvert, .kcontrols = wcontrols, \
     83        .num_kcontrols = wncontrols}
    7984#define SND_SOC_DAPM_MICBIAS(wname, wreg, wshift, winvert) \
    8085{       .id = snd_soc_dapm_micbias, .name = wname, .reg = wreg, .shift = wshift, \
    … …  
    8691{       .id = snd_soc_dapm_mux, .name = wname, .reg = wreg, .shift = wshift, \
    8792        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1}
     93#define SND_SOC_DAPM_VALUE_MUX(wname, wreg, wshift, winvert, wcontrols) \
     94{       .id = snd_soc_dapm_value_mux, .name = wname, .reg = wreg, \
     95        .shift = wshift, .invert = winvert, .kcontrols = wcontrols, \
     96        .num_kcontrols = 1}
    8897
    8998/* path domain with event - event handler must return 0 for success */
    … …  
    98107        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols, \
    99108        .event = wevent, .event_flags = wflags}
     109#define SND_SOC_DAPM_MIXER_NAMED_CTL_E(wname, wreg, wshift, winvert, \
     110        wcontrols, wncontrols, wevent, wflags) \
     111{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
     112        .invert = winvert, .kcontrols = wcontrols, \
     113        .num_kcontrols = wncontrols, .event = wevent, .event_flags = wflags}
    100114#define SND_SOC_DAPM_MICBIAS_E(wname, wreg, wshift, winvert, wevent, wflags) \
    101115{       .id = snd_soc_dapm_micbias, .name = wname, .reg = wreg, .shift = wshift, \
    … …  
    173187        .put = snd_soc_dapm_put_enum_double, \
    174188        .private_value = (unsigned long)&xenum }
     189#define SOC_DAPM_VALUE_ENUM(xname, xenum) \
     190{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
     191        .info = snd_soc_info_enum_double, \
     192        .get = snd_soc_dapm_get_value_enum_double, \
     193        .put = snd_soc_dapm_put_value_enum_double, \
     194        .private_value = (unsigned long)&xenum }
    175195
    176196/* dapm stream operations */
    … …  
    215235int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
    216236        struct snd_ctl_elem_value *ucontrol);
     237int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
     238        struct snd_ctl_elem_value *ucontrol);
     239int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
     240        struct snd_ctl_elem_value *ucontrol);
    217241int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
    218242        const struct snd_soc_dapm_widget *widget);
    … …  
    237261
    238262/* dapm audio pin control and status */
    239 int snd_soc_dapm_enable_pin(struct snd_soc_codec *codec, char *pin);
    240 int snd_soc_dapm_disable_pin(struct snd_soc_codec *codec, char *pin);
    241 int snd_soc_dapm_nc_pin(struct snd_soc_codec *codec, char *pin);
    242 int snd_soc_dapm_get_pin_status(struct snd_soc_codec *codec, char *pin);
     263int snd_soc_dapm_enable_pin(struct snd_soc_codec *codec, const char *pin);
     264int snd_soc_dapm_disable_pin(struct snd_soc_codec *codec, const char *pin);
     265int snd_soc_dapm_nc_pin(struct snd_soc_codec *codec, const char *pin);
     266int snd_soc_dapm_get_pin_status(struct snd_soc_codec *codec, const char *pin);
    243267int snd_soc_dapm_sync(struct snd_soc_codec *codec);
    244268
    … …  
    248272        snd_soc_dapm_output,            /* output pin */
    249273        snd_soc_dapm_mux,                       /* selects 1 analog signal from many inputs */
     274        snd_soc_dapm_value_mux,                 /* selects 1 analog signal from many inputs */
    250275        snd_soc_dapm_mixer,                     /* mixes several analog signals together */
     276        snd_soc_dapm_mixer_named_ctl,           /* mixer with named controls */
    251277        snd_soc_dapm_pga,                       /* programmable gain/attenuation (volume) */
    252278        snd_soc_dapm_adc,                       /* analog to digital converter */

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/soc.h

    r402 r410  
    9595#define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
    9696{       .max = xmax, .texts = xtexts }
     97#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
     98{       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
     99        .mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
     100#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
     101        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
    97102#define SOC_ENUM(xname, xenum) \
    98103{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
    99104        .info = snd_soc_info_enum_double, \
    100105        .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
     106        .private_value = (unsigned long)&xenum }
     107#define SOC_VALUE_ENUM(xname, xenum) \
     108{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
     109        .info = snd_soc_info_enum_double, \
     110        .get = snd_soc_get_value_enum_double, \
     111        .put = snd_soc_put_value_enum_double, \
    101112        .private_value = (unsigned long)&xenum }
    102113#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
    … …  
    144155};
    145156
    146 /*
    147  * Digital Audio Interface (DAI) types
    148  */
    149 #define SND_SOC_DAI_AC97        0x1
    150 #define SND_SOC_DAI_I2S         0x2
    151 #define SND_SOC_DAI_PCM         0x4
    152 #define SND_SOC_DAI_AC97_BUS    0x8     /* for custom i.e. non ac97_codec.c */
    153 
    154 /*
    155  * DAI hardware audio formats
    156  */
    157 #define SND_SOC_DAIFMT_I2S              0       /* I2S mode */
    158 #define SND_SOC_DAIFMT_RIGHT_J  1       /* Right justified mode */
    159 #define SND_SOC_DAIFMT_LEFT_J   2       /* Left Justified mode */
    160 #define SND_SOC_DAIFMT_DSP_A    3       /* L data msb after FRM or LRC */
    161 #define SND_SOC_DAIFMT_DSP_B    4       /* L data msb during FRM or LRC */
    162 #define SND_SOC_DAIFMT_AC97             5       /* AC97 */
    163 
    164 #define SND_SOC_DAIFMT_MSB      SND_SOC_DAIFMT_LEFT_J
    165 #define SND_SOC_DAIFMT_LSB      SND_SOC_DAIFMT_RIGHT_J
    166 
    167 /*
    168  * DAI Gating
    169  */
    170 #define SND_SOC_DAIFMT_CONT                     (0 << 4)        /* continuous clock */
    171 #define SND_SOC_DAIFMT_GATED            (1 << 4)        /* clock is gated when not Tx/Rx */
    172 
    173 /*
    174  * DAI Sync
    175  * Synchronous LR (Left Right) clocks and Frame signals.
    176  */
    177 #define SND_SOC_DAIFMT_SYNC             (0 << 5)        /* Tx FRM = Rx FRM */
    178 #define SND_SOC_DAIFMT_ASYNC            (1 << 5)        /* Tx FRM ~ Rx FRM */
    179 
    180 /*
    181  * TDM
    182  */
    183 #define SND_SOC_DAIFMT_TDM              (1 << 6)
    184 
    185 /*
    186  * DAI hardware signal inversions
    187  */
    188 #define SND_SOC_DAIFMT_NB_NF            (0 << 8)        /* normal bclk + frm */
    189 #define SND_SOC_DAIFMT_NB_IF            (1 << 8)        /* normal bclk + inv frm */
    190 #define SND_SOC_DAIFMT_IB_NF            (2 << 8)        /* invert bclk + nor frm */
    191 #define SND_SOC_DAIFMT_IB_IF            (3 << 8)        /* invert bclk + frm */
    192 
    193 /*
    194  * DAI hardware clock masters
    195  * This is wrt the codec, the inverse is true for the interface
    196  * i.e. if the codec is clk and frm master then the interface is
    197  * clk and frame slave.
    198  */
    199 #define SND_SOC_DAIFMT_CBM_CFM  (0 << 12) /* codec clk & frm master */
    200 #define SND_SOC_DAIFMT_CBS_CFM  (1 << 12) /* codec clk slave & frm master */
    201 #define SND_SOC_DAIFMT_CBM_CFS  (2 << 12) /* codec clk master & frame slave */
    202 #define SND_SOC_DAIFMT_CBS_CFS  (3 << 12) /* codec clk & frm slave */
    203 
    204 #define SND_SOC_DAIFMT_FORMAT_MASK              0x000f
    205 #define SND_SOC_DAIFMT_CLOCK_MASK               0x00f0
    206 #define SND_SOC_DAIFMT_INV_MASK                 0x0f00
    207 #define SND_SOC_DAIFMT_MASTER_MASK              0xf000
    208 
    209 
    210 /*
    211  * Master Clock Directions
    212  */
    213 #define SND_SOC_CLOCK_IN        0
    214 #define SND_SOC_CLOCK_OUT       1
    215 
    216 /*
    217  * AC97 codec ID's bitmask
    218  */
    219 #define SND_SOC_DAI_AC97_ID0    (1 << 0)
    220 #define SND_SOC_DAI_AC97_ID1    (1 << 1)
    221 #define SND_SOC_DAI_AC97_ID2    (1 << 2)
    222 #define SND_SOC_DAI_AC97_ID3    (1 << 3)
    223 
     157struct snd_jack;
     158struct snd_soc_card;
    224159struct snd_soc_device;
    225160struct snd_soc_pcm_stream;
    … …  
    228163struct snd_soc_pcm_runtime;
    229164struct snd_soc_dai;
     165struct snd_soc_platform;
    230166struct snd_soc_codec;
    231 struct snd_soc_machine_config;
    232167struct soc_enum;
    233168struct snd_soc_ac97_ops;
    234 struct snd_soc_clock_info;
     169struct snd_soc_jack;
     170struct snd_soc_jack_pin;
    235171
    236172typedef int (*hw_write_t)(void *,const char* ,int);
    … …  
    238174
    239175extern struct snd_ac97_bus_ops soc_ac97_ops;
     176
     177int snd_soc_register_platform(struct snd_soc_platform *platform);
     178void snd_soc_unregister_platform(struct snd_soc_platform *platform);
     179int snd_soc_register_codec(struct snd_soc_codec *codec);
     180void snd_soc_unregister_codec(struct snd_soc_codec *codec);
    240181
    241182/* pcm <-> DAI connect */
    242183void snd_soc_free_pcms(struct snd_soc_device *socdev);
    243184int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid);
    244 int snd_soc_register_card(struct snd_soc_device *socdev);
     185int snd_soc_init_card(struct snd_soc_device *socdev);
    245186
    246187/* set runtime hw params */
    247188int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
    248189        const struct snd_pcm_hardware *hw);
     190
     191/* Jack reporting */
     192int snd_soc_jack_new(struct snd_soc_card *card, const char *id, int type,
     193                     struct snd_soc_jack *jack);
     194void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
     195int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
     196                          struct snd_soc_jack_pin *pins);
    249197
    250198/* codec IO */
    … …  
    262210void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
    263211
    264 /* Digital Audio Interface clocking API.*/
    265 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
    266         unsigned int freq, int dir);
    267 
    268 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
    269         int div_id, int div);
    270 
    271 int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
    272         int pll_id, unsigned int freq_in, unsigned int freq_out);
    273 
    274 /* Digital Audio interface formatting */
    275 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt);
    276 
    277 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
    278         unsigned int mask, int slots);
    279 
    280 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate);
    281 
    282 /* Digital Audio Interface mute */
    283 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute);
    284 
    285212/*
    286213 *Controls
    … …  
    288215struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
    289216        void *data, char *long_name);
     217int snd_soc_add_controls(struct snd_soc_codec *codec,
     218        const struct snd_kcontrol_new *controls, int num_controls);
    290219int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
    291220        struct snd_ctl_elem_info *uinfo);
    … …  
    295224        struct snd_ctl_elem_value *ucontrol);
    296225int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
     226        struct snd_ctl_elem_value *ucontrol);
     227int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
     228        struct snd_ctl_elem_value *ucontrol);
     229int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
    297230        struct snd_ctl_elem_value *ucontrol);
    298231int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
    … …  
    317250int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
    318251        struct snd_ctl_elem_value *ucontrol);
     252
     253/**
     254 * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
     255 *
     256 * @pin:    name of the pin to update
     257 * @mask:   bits to check for in reported jack status
     258 * @invert: if non-zero then pin is enabled when status is not reported
     259 */
     260struct snd_soc_jack_pin {
     261        struct list_head list;
     262        const char *pin;
     263        int mask;
     264        bool invert;
     265};
     266
     267struct snd_soc_jack {
     268        struct snd_jack *jack;
     269        struct snd_soc_card *card;
     270        struct list_head pins;
     271        int status;
     272};
    319273
    320274/* SoC PCM stream information */
    … …  
    340294};
    341295
    342 /* ASoC DAI ops */
    343 struct snd_soc_dai_ops {
    344         /* DAI clocking configuration */
    345         int (*set_sysclk)(struct snd_soc_dai *dai,
    346                 int clk_id, unsigned int freq, int dir);
    347         int (*set_pll)(struct snd_soc_dai *dai,
    348                 int pll_id, unsigned int freq_in, unsigned int freq_out);
    349         int (*set_clkdiv)(struct snd_soc_dai *dai, int div_id, int div);
    350 
    351         /* DAI format configuration */
    352         int (*set_fmt)(struct snd_soc_dai *dai, unsigned int fmt);
    353         int (*set_tdm_slot)(struct snd_soc_dai *dai,
    354                 unsigned int mask, int slots);
    355         int (*set_tristate)(struct snd_soc_dai *dai, int tristate);
    356 
    357         /* digital mute */
    358         int (*digital_mute)(struct snd_soc_dai *dai, int mute);
    359 };
    360 
    361 /* SoC  DAI (Digital Audio Interface) */
    362 struct snd_soc_dai {
    363         /* DAI description */
    364         char *name;
    365         unsigned int id;
    366         unsigned char type;
    367 
    368         /* DAI callbacks */
    369         int (*probe)(struct platform_device *pdev,
    370                      struct snd_soc_dai *dai);
    371         void (*remove)(struct platform_device *pdev,
    372                        struct snd_soc_dai *dai);
    373         int (*suspend)(struct platform_device *pdev,
    374                 struct snd_soc_dai *dai);
    375         int (*resume)(struct platform_device *pdev,
    376                 struct snd_soc_dai *dai);
    377 
    378         /* ops */
    379         struct snd_soc_ops ops;
    380         struct snd_soc_dai_ops dai_ops;
    381 
    382         /* DAI capabilities */
    383         struct snd_soc_pcm_stream capture;
    384         struct snd_soc_pcm_stream playback;
    385 
    386         /* DAI runtime info */
    387         struct snd_pcm_runtime *runtime;
    388         struct snd_soc_codec *codec;
    389         unsigned int active;
    390         unsigned char pop_wait:1;
    391         void *dma_data;
    392 
    393         /* DAI private data */
    394         void *private_data;
    395 };
    396 
    397296/* SoC Audio Codec */
    398297struct snd_soc_codec {
    … …  
    400299        struct module *owner;
    401300        struct mutex mutex;
     301        struct device *dev;
     302
     303        struct list_head list;
    402304
    403305        /* callbacks */
    … …  
    435337        struct snd_soc_dai *dai;
    436338        unsigned int num_dai;
     339
     340#ifdef CONFIG_DEBUG_FS
     341        struct dentry *debugfs_reg;
     342        struct dentry *debugfs_pop_time;
     343#endif
    437344};
    438345
    … …  
    448355struct snd_soc_platform {
    449356        char *name;
     357        struct list_head list;
    450358
    451359        int (*probe)(struct platform_device *pdev);
    452360        int (*remove)(struct platform_device *pdev);
    453         int (*suspend)(struct platform_device *pdev,
    454                 struct snd_soc_dai *dai);
    455         int (*resume)(struct platform_device *pdev,
    456                 struct snd_soc_dai *dai);
     361        int (*suspend)(struct snd_soc_dai *dai);
     362        int (*resume)(struct snd_soc_dai *dai);
    457363
    458364        /* pcm creation and destruction */
    … …  
    484390};
    485391
    486 /* SoC machine */
    487 struct snd_soc_machine {
     392/* SoC card */
     393struct snd_soc_card {
    488394        char *name;
     395        struct device *dev;
     396
     397        struct list_head list;
     398
     399        int instantiated;
    489400
    490401        int (*probe)(struct platform_device *pdev);
    … …  
    499410
    500411        /* callbacks */
    501         int (*set_bias_level)(struct snd_soc_machine *,
     412        int (*set_bias_level)(struct snd_soc_card *,
    502413                              enum snd_soc_bias_level level);
    503414
    … …  
    505416        struct snd_soc_dai_link *dai_link;
    506417        int num_links;
     418
     419        struct snd_soc_device *socdev;
     420
     421        struct snd_soc_platform *platform;
     422        struct delayed_work delayed_work;
     423        struct work_struct deferred_resume_work;
    507424};
    508425
    … …  
    510427struct snd_soc_device {
    511428        struct device *dev;
    512         struct snd_soc_machine *machine;
    513         struct snd_soc_platform *platform;
     429        struct snd_soc_card *card;
    514430        struct snd_soc_codec *codec;
    515431        struct snd_soc_codec_device *codec_dev;
    516         struct delayed_work delayed_work;
    517         struct work_struct deferred_resume_work;
    518432        void *codec_data;
    519 #ifdef CONFIG_DEBUG_FS
    520         struct dentry   *debugfs_root;
    521 #endif
    522433};
    523434
    … …  
    541452        unsigned char shift_r;
    542453        unsigned int max;
     454        unsigned int mask;
    543455        const char **texts;
     456        const unsigned int *values;
    544457        void *dapm;
    545458};
    546459
     460#include <sound/soc-dai.h>
     461
    547462#endif

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/tea575x-tuner.h

    r399 r410  
    3737        struct snd_card *card;
    3838        struct video_device vd;         /* video device */
    39         struct file_operations fops;
     39        struct v4l2_file_operations fops;
    4040        int dev_nr;                     /* requested device number + 1 */
    4141        int vd_registered;              /* video device is registered */

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

    r402 r410  
    11/* include/version.h */
    2 #define CONFIG_SND_VERSION "1.0.18a"
     2#define CONFIG_SND_VERSION "1.0.19"
    33#define CONFIG_SND_DATE ""

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/ad1816a/ad1816a.c

    r399 r410  
    158158        struct snd_opl3 *opl3;
    159159
    160         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    161                                  sizeof(struct snd_card_ad1816a))) == NULL)
    162                 return -ENOMEM;
     160        error = snd_card_create(index[dev], id[dev], THIS_MODULE,
     161                                sizeof(struct snd_card_ad1816a), &card);
     162        if (error < 0)
     163                return error;
    163164        acard = (struct snd_card_ad1816a *)card->private_data;
    164165

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/ad1848/ad1848.c

    r402 r410  
    9292        int error;
    9393
    94         card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
    95         if (!card)
    96                 return -EINVAL;
     94        error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card);
     95        if (error < 0)
     96                return error;
    9797
    9898        error = snd_wss_create(card, port[n], -1, irq[n], dma1[n], -1,

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/als100.c

    r305 r410  
    164164        struct snd_opl3 *opl3;
    165165
    166         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    167                                  sizeof(struct snd_card_als100))) == NULL)
    168                 return -ENOMEM;
     166        error = snd_card_create(index[dev], id[dev], THIS_MODULE,
     167                                sizeof(struct snd_card_als100), &card);
     168        if (error < 0)
     169                return error;
    169170        acard = card->private_data;
    170171

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/azt2320.c

    r399 r410  
    185185        struct snd_opl3 *opl3;
    186186
    187         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    188                                  sizeof(struct snd_card_azt2320))) == NULL)
    189                 return -ENOMEM;
     187        error = snd_card_create(index[dev], id[dev], THIS_MODULE,
     188                                sizeof(struct snd_card_azt2320), &card);
     189        if (error < 0)
     190                return error;
    190191        acard = (struct snd_card_azt2320 *)card->private_data;
    191192

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/cmi8330.c

    r399 r410  
    468468#define PFX     "cmi8330: "
    469469
    470 static struct snd_card *snd_cmi8330_card_new(int dev)
     470static int snd_cmi8330_card_new(int dev, struct snd_card **cardp)
    471471{
    472472        struct snd_card *card;
    473473        struct snd_cmi8330 *acard;
    474 
    475         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    476                             sizeof(struct snd_cmi8330));
    477         if (card == NULL) {
     474        int err;
     475
     476        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     477                              sizeof(struct snd_cmi8330), &card);
     478        if (err < 0) {
    478479                snd_printk(KERN_ERR PFX "could not get a new card\n");
    479                 return NULL;
     480                return err;
    480481        }
    481482        acard = card->private_data;
    482483        acard->card = card;
    483         return card;
     484        *cardp = card;
     485        return 0;
    484486}
    485487
    … …  
    565567        int err;
    566568
    567         card = snd_cmi8330_card_new(dev);
    568         if (! card)
    569                 return -ENOMEM;
     569        err = snd_cmi8330_card_new(dev, &card);
     570        if (err < 0)
     571                return err;
    570572        snd_card_set_dev(card, pdev);
    571573        if ((err = snd_cmi8330_probe(card, dev)) < 0) {
    … …  
    629631                return -ENODEV;
    630632                               
    631         card = snd_cmi8330_card_new(dev);
    632         if (! card)
    633                 return -ENOMEM;
     633        res = snd_cmi8330_card_new(dev, &card);
     634        if (res < 0)
     635                return res;
    634636        if ((res = snd_cmi8330_pnp(dev, card->private_data, pcard, pid)) < 0) {
    635637                snd_printk(KERN_ERR PFX "PnP detection failed\n");

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/cs423x/cs4231.c

    r402 r410  
    9696        int error;
    9797
    98         card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
    99         if (!card)
    100                 return -EINVAL;
     98        error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card);
     99        if (error < 0)
     100                return error;
    101101
    102102        error = snd_wss_create(card, port[n], -1, irq[n], dma1[n], dma2[n],

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/cs423x/cs4236.c

    r402 r410  
    383383}
    384384
    385 static struct snd_card *snd_cs423x_card_new(int dev)
     385static int snd_cs423x_card_new(int dev, struct snd_card **cardp)
    386386{
    387387        struct snd_card *card;
    388 
    389         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    390                             sizeof(struct snd_card_cs4236));
    391         if (card == NULL)
    392                 return NULL;
     388        int err;
     389
     390        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     391                              sizeof(struct snd_card_cs4236), &card);
     392        if (err < 0)
     393                return err;
    393394        card->private_free = snd_card_cs4236_free;
    394         return card;
     395        *cardp = card;
     396        return 0;
    395397}
    396398
    … …  
    513515        int err;
    514516
    515         card = snd_cs423x_card_new(dev);
    516         if (! card)
    517                 return -ENOMEM;
     517        err = snd_cs423x_card_new(dev, &card);
     518        if (err < 0)
     519                return err;
    518520        snd_card_set_dev(card, pdev);
    519521        if ((err = snd_cs423x_probe(card, dev)) < 0) {
    … …  
    595597                return -ENODEV;
    596598
    597         card = snd_cs423x_card_new(dev);
    598         if (! card)
    599                 return -ENOMEM;
     599        err = snd_cs423x_card_new(dev, &card);
     600        if (err < 0)
     601                return err;
    600602        if ((err = snd_card_cs4232_pnp(dev, card->private_data, pdev)) < 0) {
    601603                printk(KERN_ERR "PnP BIOS detection failed for " IDENT "\n");
    … …  
    657659                return -ENODEV;
    658660
    659         card = snd_cs423x_card_new(dev);
    660         if (! card)
    661                 return -ENOMEM;
     661        res = snd_cs423x_card_new(dev, &card);
     662        if (res < 0)
     663                return res;
    662664        if ((res = snd_card_cs423x_pnpc(dev, card->private_data, pcard, pid)) < 0) {
    663665                printk(KERN_ERR "isapnp detection failed and probing for " IDENT

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/es1688/es1688.c

    r402 r410  
    123123        int error;
    124124
    125         card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
    126         if (!card)
    127                 return -EINVAL;
     125        error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card);
     126        if (error < 0)
     127                return error;
    128128
    129129        error = snd_es1688_legacy_create(card, dev, n, &chip);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/es18xx.c

    r305 r410  
    21262126#endif
    21272127
    2128 static struct snd_card *snd_es18xx_card_new(int dev)
    2129 {
    2130         return snd_card_new(index[dev], id[dev], THIS_MODULE,
    2131                             sizeof(struct snd_audiodrive));
     2128static int snd_es18xx_card_new(int dev, struct snd_card **cardp)
     2129{
     2130        return snd_card_create(index[dev], id[dev], THIS_MODULE,
     2131                               sizeof(struct snd_audiodrive), cardp);
    21322132}
    21332133
    … …  
    21982198        int err;
    21992199
    2200         card = snd_es18xx_card_new(dev);
    2201         if (! card)
    2202                 return -ENOMEM;
     2200        err = snd_es18xx_card_new(dev, &card);
     2201        if (err < 0)
     2202                return err;
    22032203        snd_card_set_dev(card, devptr);
    22042204        if ((err = snd_audiodrive_probe(card, dev)) < 0) {
    … …  
    23042304                return -ENODEV;
    23052305
    2306         card = snd_es18xx_card_new(dev);
    2307         if (! card)
    2308                 return -ENOMEM;
     2306        err = snd_es18xx_card_new(dev, &card);
     2307        if (err < 0)
     2308                return err;
    23092309        if ((err = snd_audiodrive_pnp(dev, card->private_data, pdev)) < 0) {
    23102310                snd_card_free(card);
    … …  
    23632363                return -ENODEV;
    23642364
    2365         card = snd_es18xx_card_new(dev);
    2366         if (! card)
    2367                 return -ENOMEM;
     2365        res = snd_es18xx_card_new(dev, &card);
     2366        if (res < 0)
     2367                return res;
    23682368
    23692369        if ((res = snd_audiodrive_pnpc(dev, card->private_data, pcard, pid)) < 0) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/gusclassic.c

    r402 r410  
    149149        int error;
    150150
    151         card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
    152         if (!card)
    153                 return -EINVAL;
     151        error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card);
     152        if (error < 0)
     153                return error;
    154154
    155155        if (pcm_channels[n] < 2)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/gusextreme.c

    r402 r410  
    242242        int error;
    243243
    244         card = snd_card_new(index[n], id[n], THIS_MODULE, 0);
    245         if (!card)
    246                 return -EINVAL;
     244        error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card);
     245        if (error < 0)
     246                return error;
    247247
    248248        if (mpu_port[n] == SNDRV_AUTO_PORT)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/gusmax.c

    r399 r410  
    215215        struct snd_gusmax *maxcard;
    216216
    217         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    218                             sizeof(struct snd_gusmax));
    219         if (card == NULL)
    220                 return -ENOMEM;
     217        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     218                              sizeof(struct snd_gusmax), &card);
     219        if (err < 0)
     220                return err;
    221221        card->private_free = snd_gusmax_free;
    222222        maxcard = (struct snd_gusmax *)card->private_data;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/interwave.c

    r399 r410  
    627627}
    628628
    629 static struct snd_card *snd_interwave_card_new(int dev)
     629static int snd_interwave_card_new(int dev, struct snd_card **cardp)
    630630{
    631631        struct snd_card *card;
    632632        struct snd_interwave *iwcard;
    633 
    634         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    635                             sizeof(struct snd_interwave));
    636         if (card == NULL)
    637                 return NULL;
     633        int err;
     634
     635        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     636                              sizeof(struct snd_interwave), &card);
     637        if (err < 0)
     638                return err;
    638639        iwcard = card->private_data;
    639640        iwcard->card = card;
    640641        iwcard->irq = -1;
    641642        card->private_free = snd_interwave_free;
    642         return card;
     643        *cardp = card;
     644        return 0;
    643645}
    644646
    … …  
    779781        int err;
    780782
    781         card = snd_interwave_card_new(dev);
    782         if (! card)
    783                 return -ENOMEM;
     783        err = snd_interwave_card_new(dev, &card);
     784        if (err < 0)
     785                return err;
    784786
    785787        snd_card_set_dev(card, devptr);
    … …  
    877879                return -ENODEV;
    878880                               
    879         card = snd_interwave_card_new(dev);
    880         if (! card)
    881                 return -ENOMEM;
     881        res = snd_interwave_card_new(dev, &card);
     882        if (res < 0)
     883                return res;
    882884
    883885        if ((res = snd_interwave_pnp(dev, card->private_data, pcard, pid)) < 0) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/opl3sa2.c

    r399 r410  
    622622}
    623623
    624 static struct snd_card *snd_opl3sa2_card_new(int dev)
     624static int snd_opl3sa2_card_new(int dev, struct snd_card **cardp)
    625625{
    626626        struct snd_card *card;
    627627        struct snd_opl3sa2 *chip;
    628 
    629         card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_opl3sa2));
    630         if (card == NULL)
    631                 return NULL;
     628        int err;
     629
     630        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     631                              sizeof(struct snd_opl3sa2), &card);
     632        if (err < 0)
     633                return err;
    632634        strcpy(card->driver, "OPL3SA2");
    633635        strcpy(card->shortname, "Yamaha OPL3-SA2");
    … …  
    636638        chip->irq = -1;
    637639        card->private_free = snd_opl3sa2_free;
    638         return card;
     640        *cardp = card;
     641        return 0;
    639642}
    640643
    … …  
    728731                return -ENODEV;
    729732
    730         card = snd_opl3sa2_card_new(dev);
    731         if (! card)
    732                 return -ENOMEM;
     733        err = snd_opl3sa2_card_new(dev, &card);
     734        if (err < 0)
     735                return err;
    733736        if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) {
    734737                snd_card_free(card);
    … …  
    794797                return -ENODEV;
    795798
    796         card = snd_opl3sa2_card_new(dev);
    797         if (! card)
    798                 return -ENOMEM;
     799        err = snd_opl3sa2_card_new(dev, &card);
     800        if (err < 0)
     801                return err;
    799802        if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) {
    800803                snd_card_free(card);
    … …  
    875878        int err;
    876879
    877         card = snd_opl3sa2_card_new(dev);
    878         if (! card)
    879                 return -ENOMEM;
     880        err = snd_opl3sa2_card_new(dev, &card);
     881        if (err < 0)
     882                return err;
    880883        snd_card_set_dev(card, pdev);
    881884        if ((err = snd_opl3sa2_probe(card, dev)) < 0) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/opti9xx/opti92x-ad1848.c

    r399 r410  
    831831}
    832832
    833 static struct snd_card *snd_opti9xx_card_new(void)
     833static int snd_opti9xx_card_new(struct snd_card **cardp)
    834834{
    835835        struct snd_card *card;
    836 
    837         card = snd_card_new(index, id, THIS_MODULE, sizeof(struct snd_opti9xx));
    838         if (! card)
    839                 return NULL;
     836        int err;
     837
     838        err = snd_card_create(index, id, THIS_MODULE,
     839                              sizeof(struct snd_opti9xx), &card);
     840        if (err < 0)
     841                return err;
    840842        card->private_free = snd_card_opti9xx_free;
    841         return card;
     843        *cardp = card;
     844        return 0;
    842845}
    843846
    … …  
    904907#endif
    905908
    906         card = snd_opti9xx_card_new();
    907         if (! card)
    908                 return -ENOMEM;
     909        error = snd_opti9xx_card_new(&card);
     910        if (error < 0)
     911                return error;
    909912
    910913        if ((error = snd_card_opti9xx_detect(card, card->private_data)) < 0) {
    … …  
    951954        if (! isapnp)
    952955                return -ENODEV;
    953         card = snd_opti9xx_card_new();
    954         if (! card)
    955                 return -ENOMEM;
     956        error = snd_opti9xx_card_new(&card);
     957        if (error < 0)
     958                return error;
    956959        chip = card->private_data;
    957960

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/sb/es968.c

    r305 r410  
    109109        struct snd_card_es968 *acard;
    110110
    111         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    112                                  sizeof(struct snd_card_es968))) == NULL)
    113                 return -ENOMEM;
     111        error = snd_card_create(index[dev], id[dev], THIS_MODULE,
     112                                sizeof(struct snd_card_es968), &card);
     113        if (error < 0)
     114                return error;
    114115        acard = card->private_data;
    115116        if ((error = snd_card_es968_pnp(dev, acard, pcard, pid))) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/sb/sb16.c

    r305 r410  
    325325#endif
    326326
    327 static struct snd_card *snd_sb16_card_new(int dev)
    328 {
    329         struct snd_card *card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    330                                         sizeof(struct snd_card_sb16));
    331         if (card == NULL)
    332                 return NULL;
     327static int snd_sb16_card_new(int dev, struct snd_card **cardp)
     328{
     329        struct snd_card *card;
     330        int err;
     331
     332        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     333                              sizeof(struct snd_card_sb16), &card);
     334        if (err < 0)
     335                return err;
    333336        card->private_free = snd_sb16_free;
    334         return card;
     337        *cardp = card;
     338        return 0;
    335339}
    336340
    … …  
    490494        int err;
    491495
    492         card = snd_sb16_card_new(dev);
    493         if (! card)
    494                 return -ENOMEM;
     496        err = snd_sb16_card_new(dev, &card);
     497        if (err < 0)
     498                return err;
    495499
    496500        acard = card->private_data;
    … …  
    611615                if (!enable[dev] || !isapnp[dev])
    612616                        continue;
    613                 card = snd_sb16_card_new(dev);
    614                 if (! card)
    615                         return -ENOMEM;
     617                res = snd_sb16_card_new(dev, &card);
     618                if (res < 0)
     619                        return res;
    616620                snd_card_set_dev(card, &pcard->card->dev);
    617621                if ((res = snd_card_sb16_pnp(dev, card->private_data, pcard, pid)) < 0 ||

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/sb/sb8.c

    r402 r410  
    104104        int err;
    105105
    106         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    107                             sizeof(struct snd_sb8));
    108         if (card == NULL)
    109                 return -ENOMEM;
     106        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     107                              sizeof(struct snd_sb8), &card);
     108        if (err < 0)
     109                return err;
    110110        acard = card->private_data;
    111111        card->private_free = snd_sb8_free;
    … …  
    141141                        }
    142142                }
    143                 if (i >= ARRAY_SIZE(possible_ports))
     143                if (i >= ARRAY_SIZE(possible_ports)) {
     144                        err = -EINVAL;
    144145                        goto _err;
     146                }
    145147        }
    146148        acard->chip = chip;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/sgalaxy.c

    r399 r410  
    244244        struct snd_wss *chip;
    245245
    246         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    247         if (card == NULL)
    248                 return -ENOMEM;
     246        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     247        if (err < 0)
     248                return err;
    249249
    250250        xirq = irq[dev];

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/isa/wavefront/wavefront.c

    r399 r410  
    339339}
    340340
    341 static struct snd_card *snd_wavefront_card_new(int dev)
     341static int snd_wavefront_card_new(int dev, struct snd_card **cardp)
    342342{
    343343        struct snd_card *card;
    344344        snd_wavefront_card_t *acard;
    345 
    346         card = snd_card_new (index[dev], id[dev], THIS_MODULE,
    347                              sizeof(snd_wavefront_card_t));
    348         if (card == NULL)
    349                 return NULL;
     345        int err;
     346
     347        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     348                              sizeof(snd_wavefront_card_t), &card);
     349        if (err < 0)
     350                return err;
    350351
    351352        acard = card->private_data;
    … …  
    358359        card->private_free = snd_wavefront_free;
    359360
    360         return card;
     361        *cardp = card;
     362        return 0;
    361363}
    362364
    … …  
    568570        int err;
    569571
    570         card = snd_wavefront_card_new(dev);
    571         if (! card)
    572                 return -ENOMEM;
     572        err = snd_wavefront_card_new(dev, &card);
     573        if (err < 0)
     574                return err;
    573575        snd_card_set_dev(card, pdev);
    574576        if ((err = snd_wavefront_probe(card, dev)) < 0) {
    … …  
    617619                return -ENODEV;
    618620
    619         card = snd_wavefront_card_new(dev);
    620         if (! card)
    621                 return -ENOMEM;
     621        res = snd_wavefront_card_new(dev, &card);
     622        if (res < 0)
     623                return res;
    622624
    623625        if (snd_wavefront_pnp (dev, card->private_data, pcard, pid) < 0) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/ac97/ac97_codec.c

    r402 r410  
    176176{ 0x574d4C05, 0xffffffff, "WM9705,WM9710",      patch_wolfson05, NULL},
    177177{ 0x574d4C09, 0xffffffff, "WM9709",             NULL,           NULL},
    178 { 0x574d4C12, 0xffffffff, "WM9711,WM9712",      patch_wolfson11, NULL},
     178{ 0x574d4C12, 0xffffffff, "WM9711,WM9712,WM9715",       patch_wolfson11, NULL},
    179179{ 0x574d4c13, 0xffffffff, "WM9713,WM9714",      patch_wolfson13, NULL, AC97_DEFAULT_POWER_OFF},
    180180{ 0x594d4800, 0xffffffff, "YMF743",             patch_yamaha_ymf743,    NULL },

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

    r358 r410  
    23222322        snd_ali_printk("probe ...\n");
    23232323
    2324         card = snd_card_new(index, id, THIS_MODULE, 0);
    2325         if (!card)
    2326                 return -ENOMEM;
     2324        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
     2325        if (err < 0)
     2326                return err;
    23272327
    23282328        err = snd_ali_create(card, pci, pcm_channels, spdif, &codec);

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

    r399 r410  
    890890        pci_set_master(pci);
    891891       
    892         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    893                             sizeof(*acard) /* private_data: acard */);
    894         if (card == NULL) {
     892        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     893                              sizeof(*acard) /* private_data: acard */,
     894                              &card);
     895        if (err < 0) {
    895896                pci_release_regions(pci);
    896897                pci_disable_device(pci);
    897                 return -ENOMEM;
     898                return err;
    898899        }
    899900

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

    r399 r410  
    16481648        int err;
    16491649
    1650         card = snd_card_new(index, id, THIS_MODULE, 0);
    1651         if (card == NULL)
    1652                 return -ENOMEM;
     1650        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
     1651        if (err < 0)
     1652                return err;
    16531653
    16541654        strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA");

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

    r399 r410  
    251251        }
    252252        // (2)
    253         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    254         if (card == NULL)
    255                 return -ENOMEM;
     253        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     254        if (err < 0)
     255                return err;
    256256
    257257        // (3)

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

    r399 r410  
    924924        }
    925925
    926         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    927         if (!card)
    928                 return -ENOMEM;
     926        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     927        if (err < 0)
     928                return err;
    929929
    930930        err = snd_bt87x_create(card, pci, &chip);

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

    r305 r410  
    665665        u32 serial;
    666666        char * name;
    667         int ac97;
    668         int gpio_type;
    669         int i2c_adc;
    670         int spi_dac;
     667        int ac97;       /* ac97 = 0 -> Select MIC, Line in, TAD in, AUX in.
     668                           ac97 = 1 -> Default to AC97 in. */
     669        int gpio_type;  /* gpio_type = 1 -> shared mic-in/line-in
     670                           gpio_type = 2 -> shared side-out/line-in. */
     671        int i2c_adc;    /* with i2c_adc=1, the driver adds some capture volume
     672                           controls, phone, mic, line-in and aux. */
     673        int spi_dac;    /* spi_dac=1 adds the mute switch for each analog
     674                           output, front, rear, etc. */
    671675};
    672676
    … …  
    687691
    688692        struct snd_ac97 *ac97;
    689         struct snd_pcm *pcm;
     693        struct snd_pcm *pcm[4];
    690694
    691695        struct snd_ca0106_channel playback_channels[4];
    692696        struct snd_ca0106_channel capture_channels[4];
    693         u32 spdif_bits[4];             /* s/pdif out setup */
     697        u32 spdif_bits[4];             /* s/pdif out default setup */
     698        u32 spdif_str_bits[4];         /* s/pdif out per-stream setup */
    694699        int spdif_enable;
    695700        int capture_source;
    … …  
    704709
    705710        u16 spi_dac_reg[16];
     711
     712#ifdef CONFIG_PM
     713#define NUM_SAVED_VOLUMES       9
     714        unsigned int saved_vol[NUM_SAVED_VOLUMES];
     715#endif
    706716};
    707717
    … …  
    722732int snd_ca0106_spi_write(struct snd_ca0106 * emu,
    723733                                   unsigned int data);
     734
     735#ifdef CONFIG_PM
     736void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip);
     737void snd_ca0106_mixer_resume(struct snd_ca0106 *chip);
     738#else
     739#define snd_ca0106_mixer_suspend(chip)  do { } while (0)
     740#define snd_ca0106_mixer_resume(chip)   do { } while (0)
     741#endif

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

    r399 r410  
    255255           .gpio_type = 2,
    256256           .i2c_adc = 1,
    257            .spi_dac = 2 } ,
     257           .spi_dac = 1 } ,
    258258         /* Shuttle XPC SD31P which has an onboard Creative Labs
    259259          * Sound Blaster Live! 24-bit EAX
    … …  
    306306                                 SNDRV_PCM_INFO_MMAP_VALID),
    307307        .formats =              SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
     308#if 0 /* FIXME: looks like 44.1kHz capture causes noisy output on 48kHz */
    308309        .rates =                (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    309310                                 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
    310311        .rate_min =             44100,
     312#else
     313        .rates =                (SNDRV_PCM_RATE_48000 |
     314                                 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
     315        .rate_min =             48000,
     316#endif /* FIXME */
    311317        .rate_max =             192000,
    312318        .channels_min =         2,
    … …  
    480486};
    481487
     488static void restore_spdif_bits(struct snd_ca0106 *chip, int idx)
     489{
     490        if (chip->spdif_str_bits[idx] != chip->spdif_bits[idx]) {
     491                chip->spdif_str_bits[idx] = chip->spdif_bits[idx];
     492                snd_ca0106_ptr_write(chip, SPCS0 + idx, 0,
     493                                     chip->spdif_str_bits[idx]);
     494        }
     495}
     496
    482497/* open_playback callback */
    483498static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
    … …  
    525540                        return err;
    526541        }
     542
     543        restore_spdif_bits(chip, channel_id);
     544
    527545        return 0;
    528546}
    … …  
    535553        struct snd_ca0106_pcm *epcm = runtime->private_data;
    536554        chip->playback_channels[epcm->channel_id].use = 0;
     555
     556        restore_spdif_bits(chip, epcm->channel_id);
    537557
    538558        if (chip->details->spi_dac && epcm->channel_id != PCM_FRONT_CHANNEL) {
    … …  
    848868        u32 basic = 0;
    849869        u32 extended = 0;
    850         int running=0;
     870        u32 bits;
     871        int running = 0;
    851872
    852873        switch (cmd) {
    853874        case SNDRV_PCM_TRIGGER_START:
    854                 running=1;
     875        case SNDRV_PCM_TRIGGER_RESUME:
     876                running = 1;
    855877                break;
    856878        case SNDRV_PCM_TRIGGER_STOP:
     879        case SNDRV_PCM_TRIGGER_SUSPEND:
    857880        default:
    858                 running=0;
     881                running = 0;
    859882                break;
    860883        }
    … …  
    866889                epcm = runtime->private_data;
    867890                channel = epcm->channel_id;
    868                 //snd_printk("channel=%d\n",channel);
     891                /* snd_printk("channel=%d\n",channel); */
    869892                epcm->running = running;
    870                 basic |= (0x1<<channel);
    871                 extended |= (0x10<<channel);
     893                basic |= (0x1 << channel);
     894                extended |= (0x10 << channel);
    872895                snd_pcm_trigger_done(s, substream);
    873896        }
    874         //snd_printk("basic=0x%x, extended=0x%x\n",basic, extended);
     897        /* snd_printk("basic=0x%x, extended=0x%x\n",basic, extended); */
    875898
    876899        switch (cmd) {
    877900        case SNDRV_PCM_TRIGGER_START:
    878                 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (extended));
    879                 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(basic));
     901        case SNDRV_PCM_TRIGGER_RESUME:
     902                bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
     903                bits |= extended;
     904                snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
     905                bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
     906                bits |= basic;
     907                snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
    880908                break;
    881909        case SNDRV_PCM_TRIGGER_STOP:
    882                 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(basic));
    883                 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(extended));
     910        case SNDRV_PCM_TRIGGER_SUSPEND:
     911                bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
     912                bits &= ~basic;
     913                snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
     914                bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
     915                bits &= ~extended;
     916                snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
    884917                break;
    885918        default:
    … …  
    11041137}
    11051138
     1139static void ca0106_stop_chip(struct snd_ca0106 *chip);
     1140
    11061141static int snd_ca0106_free(struct snd_ca0106 *chip)
    11071142{
    1108         if (chip->res_port != NULL) {    /* avoid access to already used hardware */
    1109                 // disable interrupts
    1110                 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
    1111                 outl(0, chip->port + INTE);
    1112                 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
    1113                 udelay(1000);
    1114                 // disable audio
    1115                 //outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG);
    1116                 outl(0, chip->port + HCFG);
    1117                 /* FIXME: We need to stop and DMA transfers here.
    1118                  *        But as I am not sure how yet, we cannot from the dma pages.
    1119                  * So we can fix: snd-malloc: Memory leak?  pages not freed = 8
    1120                  */
     1143        if (chip->res_port != NULL) {
     1144                /* avoid access to already used hardware */
     1145                ca0106_stop_chip(chip);
    11211146        }
    11221147        if (chip->irq >= 0)
    … …  
    12041229}
    12051230
    1206 static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm)
     1231static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device)
    12071232{
    12081233        struct snd_pcm *pcm;
    … …  
    12101235        int err;
    12111236 
    1212         if (rpcm)
    1213                 *rpcm = NULL;
    1214         if ((err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm)) < 0)
     1237        err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm);
     1238        if (err < 0)
    12151239                return err;
    12161240 
    … …  
    12391263        pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
    12401264        strcpy(pcm->name, "CA0106");
    1241         emu->pcm = pcm;
    12421265
    12431266        for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
    … …  
    12611284        }
    12621285 
    1263         if (rpcm)
    1264                 *rpcm = pcm;
     1286        emu->pcm[device] = pcm;
    12651287 
    12661288        return 0;
    … …  
    13021324};
    13031325
    1304 static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
    1305                                          struct pci_dev *pci,
    1306                                          struct snd_ca0106 **rchip)
    1307 {
    1308         struct snd_ca0106 *chip;
    1309         struct snd_ca0106_details *c;
    1310         int err;
     1326static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
     1327{
    13111328        int ch;
    1312         static struct snd_device_ops ops = {
    1313                 .dev_free = snd_ca0106_dev_free,
    1314         };
    1315  
    1316         *rchip = NULL;
    1317  
    1318         if ((err = pci_enable_device(pci)) < 0)
    1319                 return err;
    1320         if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
    1321             pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
    1322                 printk(KERN_ERR "error to set 32bit mask DMA\n");
    1323                 pci_disable_device(pci);
    1324                 return -ENXIO;
    1325         }
    1326  
    1327         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    1328         if (chip == NULL) {
    1329                 pci_disable_device(pci);
    1330                 return -ENOMEM;
    1331         }
    1332  
    1333         chip->card = card;
    1334         chip->pci = pci;
    1335         chip->irq = -1;
    1336 
    1337         spin_lock_init(&chip->emu_lock);
    1338  
    1339         chip->port = pci_resource_start(pci, 0);
    1340         if ((chip->res_port = request_region(chip->port, 0x20,
    1341                                              "snd_ca0106")) == NULL) {
    1342                 snd_ca0106_free(chip);
    1343                 printk(KERN_ERR "cannot allocate the port\n");
    1344                 return -EBUSY;
    1345         }
    1346 
    1347         if (request_irq(pci->irq, snd_ca0106_interrupt,
    1348                         IRQF_SHARED, "snd_ca0106", chip)) {
    1349                 snd_ca0106_free(chip);
    1350                 printk(KERN_ERR "cannot grab irq\n");
    1351                 return -EBUSY;
    1352         }
    1353         chip->irq = pci->irq;
    1354  
    1355         /* This stores the periods table. */
    1356         if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 1024, &chip->buffer) < 0) {
    1357                 snd_ca0106_free(chip);
    1358                 return -ENOMEM;
    1359         }
    1360 
    1361         pci_set_master(pci);
    1362         /* read serial */
    1363         pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
    1364         pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
    1365 #if 1
    1366         printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n", chip->model,
    1367 #ifndef TARGET_OS2
    1368                pci->revision, chip->serial);
    1369 #else
    1370                snd_pci_revision(pci), chip->serial);
    1371 #endif
    1372 #endif
    1373         strcpy(card->driver, "CA0106");
    1374         strcpy(card->shortname, "CA0106");
    1375 
    1376         for (c = ca0106_chip_details; c->serial; c++) {
    1377                 if (subsystem[dev]) {
    1378                         if (c->serial == subsystem[dev])
    1379                                 break;
    1380                 } else if (c->serial == chip->serial)
    1381                         break;
    1382         }
    1383         chip->details = c;
    1384         if (subsystem[dev]) {
    1385                 printk(KERN_INFO "snd-ca0106: Sound card name=%s, subsystem=0x%x. Forced to subsystem=0x%x\n",
    1386                         c->name, chip->serial, subsystem[dev]);
    1387         }
    1388 
    1389         sprintf(card->longname, "%s at 0x%lx irq %i",
    1390                 c->name, chip->port, chip->irq);
     1329        unsigned int def_bits;
    13911330
    13921331        outl(0, chip->port + INTE);
    … …  
    14061345         *  P                 = 0     (Consumer)
    14071346         */
    1408         snd_ca0106_ptr_write(chip, SPCS0, 0,
    1409                                 chip->spdif_bits[0] =
    1410                                 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    1411                                 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    1412                                 SPCS_GENERATIONSTATUS | 0x00001200 |
    1413                                 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
     1347        def_bits =
     1348                SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
     1349                SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
     1350                SPCS_GENERATIONSTATUS | 0x00001200 |
     1351                0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
     1352        if (!resume) {
     1353                chip->spdif_str_bits[0] = chip->spdif_bits[0] = def_bits;
     1354                chip->spdif_str_bits[1] = chip->spdif_bits[1] = def_bits;
     1355                chip->spdif_str_bits[2] = chip->spdif_bits[2] = def_bits;
     1356                chip->spdif_str_bits[3] = chip->spdif_bits[3] = def_bits;
     1357        }
    14141358        /* Only SPCS1 has been tested */
    1415         snd_ca0106_ptr_write(chip, SPCS1, 0,
    1416                                 chip->spdif_bits[1] =
    1417                                 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    1418                                 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    1419                                 SPCS_GENERATIONSTATUS | 0x00001200 |
    1420                                 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
    1421         snd_ca0106_ptr_write(chip, SPCS2, 0,
    1422                                 chip->spdif_bits[2] =
    1423                                 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    1424                                 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    1425                                 SPCS_GENERATIONSTATUS | 0x00001200 |
    1426                                 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
    1427         snd_ca0106_ptr_write(chip, SPCS3, 0,
    1428                                 chip->spdif_bits[3] =
    1429                                 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
    1430                                 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
    1431                                 SPCS_GENERATIONSTATUS | 0x00001200 |
    1432                                 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
     1359        snd_ca0106_ptr_write(chip, SPCS1, 0, chip->spdif_str_bits[1]);
     1360        snd_ca0106_ptr_write(chip, SPCS0, 0, chip->spdif_str_bits[0]);
     1361        snd_ca0106_ptr_write(chip, SPCS2, 0, chip->spdif_str_bits[2]);
     1362        snd_ca0106_ptr_write(chip, SPCS3, 0, chip->spdif_str_bits[3]);
    14331363
    14341364        snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
    … …  
    14381368        outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
    14391369        outw(0x8000, chip->port + AC97DATA);
    1440 #if 0
     1370#if 0 /* FIXME: what are these? */
    14411371        snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
    14421372        snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
    … …  
    14451375#endif
    14461376
    1447         //snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); /* OSS drivers set this. */
     1377        /* OSS drivers set this. */
     1378        /* snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); */
     1379
    14481380        /* Analog or Digital output */
    14491381        snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
    1450         snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000); /* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers. Use 0x000f0000 for surround71 */
     1382        /* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers.
     1383         * Use 0x000f0000 for surround71
     1384         */
     1385        snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000);
     1386
    14511387        chip->spdif_enable = 0; /* Set digital SPDIF output off */
    1452         //snd_ca0106_ptr_write(chip, 0x45, 0, 0); /* Analogue out */
    1453         //snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00); /* Digital out */
    1454 
    1455         snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000); /* goes to 0x40c80000 when doing SPDIF IN/OUT */
    1456         snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff); /* (Mute) CAPTURE feedback into PLAYBACK volume. Only lower 16 bits matter. */
    1457         snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000); /* SPDIF IN Volume */
    1458         snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000); /* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */
     1388        /*snd_ca0106_ptr_write(chip, 0x45, 0, 0);*/ /* Analogue out */
     1389        /*snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00);*/ /* Digital out */
     1390
     1391        /* goes to 0x40c80000 when doing SPDIF IN/OUT */
     1392        snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000);
     1393        /* (Mute) CAPTURE feedback into PLAYBACK volume.
     1394         * Only lower 16 bits matter.
     1395         */
     1396        snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff);
     1397        /* SPDIF IN Volume */
     1398        snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000);
     1399        /* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */
     1400        snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000);
     1401
    14591402        snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
    14601403        snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
    14611404        snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
    14621405        snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
    1463         for(ch = 0; ch < 4; ch++) {
    1464                 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030); /* Only high 16 bits matter */
     1406
     1407        for (ch = 0; ch < 4; ch++) {
     1408                /* Only high 16 bits matter */
     1409                snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030);
    14651410                snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
    1466                 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040); /* Mute */
    1467                 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040); /* Mute */
    1468                 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff); /* Mute */
    1469                 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff); /* Mute */
     1411#if 0 /* Mute */
     1412                snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040);
     1413                snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040);
     1414                snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff);
     1415                snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff);
     1416#endif
    14701417        }
    14711418        if (chip->details->i2c_adc == 1) {
    … …  
    14731420                snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
    14741421                /* Default to CAPTURE_SOURCE to i2s in */
    1475                 chip->capture_source = 3;
     1422                if (!resume)
     1423                        chip->capture_source = 3;
    14761424        } else if (chip->details->ac97 == 1) {
    14771425                /* Default to AC97 in */
    14781426                snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
    14791427                /* Default to CAPTURE_SOURCE to AC97 in */
    1480                 chip->capture_source = 4;
     1428                if (!resume)
     1429                        chip->capture_source = 4;
    14811430        } else {
    14821431                /* Select MIC, Line in, TAD in, AUX in */
    14831432                snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
    14841433                /* Default to Set CAPTURE_SOURCE to i2s in */
    1485                 chip->capture_source = 3;
    1486         }
    1487 
    1488         if (chip->details->gpio_type == 2) { /* The SB0438 use GPIO differently. */
    1489                 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
     1434                if (!resume)
     1435                        chip->capture_source = 3;
     1436        }
     1437
     1438        if (chip->details->gpio_type == 2) {
     1439                /* The SB0438 use GPIO differently. */
     1440                /* FIXME: Still need to find out what the other GPIO bits do.
     1441                 * E.g. For digital spdif out.
     1442                 */
    14901443                outl(0x0, chip->port+GPIO);
    1491                 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
     1444                /* outl(0x00f0e000, chip->port+GPIO); */ /* Analog */
    14921445                outl(0x005f5301, chip->port+GPIO); /* Analog */
    1493         } else if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */
    1494                 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
     1446        } else if (chip->details->gpio_type == 1) {
     1447                /* The SB0410 and SB0413 use GPIO differently. */
     1448                /* FIXME: Still need to find out what the other GPIO bits do.
     1449                 * E.g. For digital spdif out.
     1450                 */
    14951451                outl(0x0, chip->port+GPIO);
    1496                 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
     1452                /* outl(0x00f0e000, chip->port+GPIO); */ /* Analog */
    14971453                outl(0x005f5301, chip->port+GPIO); /* Analog */
    14981454        } else {
    14991455                outl(0x0, chip->port+GPIO);
    15001456                outl(0x005f03a3, chip->port+GPIO); /* Analog */
    1501                 //outl(0x005f02a2, chip->port+GPIO);  /* SPDIF */
     1457                /* outl(0x005f02a2, chip->port+GPIO); */ /* SPDIF */
    15021458        }
    15031459        snd_ca0106_intr_enable(chip, 0x105); /* Win2000 uses 0x1e0 */
    15041460
    1505         //outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG);
    1506         //outl(0x00001409, chip->port+HCFG); /* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */
    1507         //outl(0x00000009, chip->port+HCFG);
    1508         outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG); /* AC97 2.0, Enable outputs. */
    1509 
    1510         if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
     1461        /* outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG); */
     1462        /* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */
     1463        /* outl(0x00001409, chip->port+HCFG); */
     1464        /* outl(0x00000009, chip->port+HCFG); */
     1465        /* AC97 2.0, Enable outputs. */
     1466        outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG);
     1467
     1468        if (chip->details->i2c_adc == 1) {
     1469                /* The SB0410 and SB0413 use I2C to control ADC. */
    15111470                int size, n;
    15121471
    15131472                size = ARRAY_SIZE(i2c_adc_init);
    1514                 //snd_printk("I2C:array size=0x%x\n", size);
    1515                 for (n=0; n < size; n++) {
    1516                         snd_ca0106_i2c_write(chip, i2c_adc_init[n][0], i2c_adc_init[n][1]);
     1473                /* snd_printk("I2C:array size=0x%x\n", size); */
     1474                for (n = 0; n < size; n++)
     1475                        snd_ca0106_i2c_write(chip, i2c_adc_init[n][0],
     1476                                             i2c_adc_init[n][1]);
     1477                for (n = 0; n < 4; n++) {
     1478                        chip->i2c_capture_volume[n][0] = 0xcf;
     1479                        chip->i2c_capture_volume[n][1] = 0xcf;
    15171480                }
    1518                 for (n=0; n < 4; n++) {
    1519                         chip->i2c_capture_volume[n][0]= 0xcf;
    1520                         chip->i2c_capture_volume[n][1]= 0xcf;
    1521                 }
    1522                 chip->i2c_capture_source=2; /* Line in */
    1523                 //snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */
    1524         }
    1525         if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */
     1481                chip->i2c_capture_source = 2; /* Line in */
     1482                /* Enable Line-in capture. MIC in currently untested. */
     1483                /* snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); */
     1484        }
     1485
     1486        if (chip->details->spi_dac == 1) {
     1487                /* The SB0570 use SPI to control DAC. */
    15261488                int size, n;
    15271489
    … …  
    15351497                }
    15361498        }
    1537 
    1538         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
    1539                                   chip, &ops)) < 0) {
     1499}
     1500
     1501static void ca0106_stop_chip(struct snd_ca0106 *chip)
     1502{
     1503        /* disable interrupts */
     1504        snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
     1505        outl(0, chip->port + INTE);
     1506        snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
     1507        udelay(1000);
     1508        /* disable audio */
     1509        /* outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG); */
     1510        outl(0, chip->port + HCFG);
     1511        /* FIXME: We need to stop and DMA transfers here.
     1512         *        But as I am not sure how yet, we cannot from the dma pages.
     1513         * So we can fix: snd-malloc: Memory leak?  pages not freed = 8
     1514         */
     1515}
     1516
     1517static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
     1518                                         struct pci_dev *pci,
     1519                                         struct snd_ca0106 **rchip)
     1520{
     1521        struct snd_ca0106 *chip;
     1522        struct snd_ca0106_details *c;
     1523        int err;
     1524        static struct snd_device_ops ops = {
     1525                .dev_free = snd_ca0106_dev_free,
     1526        };
     1527
     1528        *rchip = NULL;
     1529
     1530        err = pci_enable_device(pci);
     1531        if (err < 0)
     1532                return err;
     1533        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
     1534            pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
     1535                printk(KERN_ERR "error to set 32bit mask DMA\n");
     1536                pci_disable_device(pci);
     1537                return -ENXIO;
     1538        }
     1539
     1540        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
     1541        if (chip == NULL) {
     1542                pci_disable_device(pci);
     1543                return -ENOMEM;
     1544        }
     1545
     1546        chip->card = card;
     1547        chip->pci = pci;
     1548        chip->irq = -1;
     1549
     1550        spin_lock_init(&chip->emu_lock);
     1551
     1552        chip->port = pci_resource_start(pci, 0);
     1553        chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
     1554        if (!chip->res_port) {
     1555                snd_ca0106_free(chip);
     1556                printk(KERN_ERR "cannot allocate the port\n");
     1557                return -EBUSY;
     1558        }
     1559
     1560        if (request_irq(pci->irq, snd_ca0106_interrupt,
     1561                        IRQF_SHARED, "snd_ca0106", chip)) {
     1562                snd_ca0106_free(chip);
     1563                printk(KERN_ERR "cannot grab irq\n");
     1564                return -EBUSY;
     1565        }
     1566        chip->irq = pci->irq;
     1567
     1568        /* This stores the periods table. */
     1569        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
     1570                                1024, &chip->buffer) < 0) {
     1571                snd_ca0106_free(chip);
     1572                return -ENOMEM;
     1573        }
     1574
     1575        pci_set_master(pci);
     1576        /* read serial */
     1577        pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
     1578        pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
     1579        printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n",
     1580#ifndef TARGET_OS2
     1581               chip->model, pci->revision, chip->serial);
     1582#else
     1583               chip->model, snd_pci_revision(pci), chip->serial);
     1584#endif
     1585        strcpy(card->driver, "CA0106");
     1586        strcpy(card->shortname, "CA0106");
     1587
     1588        for (c = ca0106_chip_details; c->serial; c++) {
     1589                if (subsystem[dev]) {
     1590                        if (c->serial == subsystem[dev])
     1591                                break;
     1592                } else if (c->serial == chip->serial)
     1593                        break;
     1594        }
     1595        chip->details = c;
     1596        if (subsystem[dev]) {
     1597                printk(KERN_INFO "snd-ca0106: Sound card name=%s, "
     1598                       "subsystem=0x%x. Forced to subsystem=0x%x\n",
     1599                       c->name, chip->serial, subsystem[dev]);
     1600        }
     1601
     1602        sprintf(card->longname, "%s at 0x%lx irq %i",
     1603                c->name, chip->port, chip->irq);
     1604
     1605        ca0106_init_chip(chip, 0);
     1606
     1607        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
     1608        if (err < 0) {
    15401609                snd_ca0106_free(chip);
    15411610                return err;
    … …  
    16341703        struct snd_card *card;
    16351704        struct snd_ca0106 *chip;
    1636         int err;
     1705        int i, err;
    16371706
    16381707        if (dev >= SNDRV_CARDS)
    … …  
    16431712        }
    16441713
    1645         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1646         if (card == NULL)
    1647                 return -ENOMEM;
    1648 
    1649         if ((err = snd_ca0106_create(dev, card, pci, &chip)) < 0) {
    1650                 snd_card_free(card);
     1714        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1715        if (err < 0)
    16511716                return err;
    1652         }
    1653 
    1654         if ((err = snd_ca0106_pcm(chip, 0, NULL)) < 0) {
    1655                 snd_card_free(card);
    1656                 return err;
    1657         }
    1658         if ((err = snd_ca0106_pcm(chip, 1, NULL)) < 0) {
    1659                 snd_card_free(card);
    1660                 return err;
    1661         }
    1662         if ((err = snd_ca0106_pcm(chip, 2, NULL)) < 0) {
    1663                 snd_card_free(card);
    1664                 return err;
    1665         }
    1666         if ((err = snd_ca0106_pcm(chip, 3, NULL)) < 0) {
    1667                 snd_card_free(card);
    1668                 return err;
    1669         }
    1670         if (chip->details->ac97 == 1) { /* The SB0410 and SB0413 do not have an AC97 chip. */
    1671                 if ((err = snd_ca0106_ac97(chip)) < 0) {
    1672                         snd_card_free(card);
    1673                         return err;
    1674                 }
    1675         }
    1676         if ((err = snd_ca0106_mixer(chip)) < 0) {
    1677                 snd_card_free(card);
    1678                 return err;
    1679         }
     1717
     1718        err = snd_ca0106_create(dev, card, pci, &chip);
     1719        if (err < 0)
     1720                goto error;
     1721        card->private_data = chip;
     1722
     1723        for (i = 0; i < 4; i++) {
     1724                err = snd_ca0106_pcm(chip, i);
     1725                if (err < 0)
     1726                        goto error;
     1727        }
     1728
     1729        if (chip->details->ac97 == 1) {
     1730                /* The SB0410 and SB0413 do not have an AC97 chip. */
     1731                err = snd_ca0106_ac97(chip);
     1732                if (err < 0)
     1733                        goto error;
     1734        }
     1735        err = snd_ca0106_mixer(chip);
     1736        if (err < 0)
     1737                goto error;
    16801738
    16811739        snd_printdd("ca0106: probe for MIDI channel A ...");
    1682         if ((err = snd_ca0106_midi(chip,CA0106_MIDI_CHAN_A)) < 0) {
    1683                 snd_card_free(card);
    1684                 snd_printdd(" failed, err=0x%x\n",err);
    1685                 return err;
    1686         }
     1740        err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
     1741        if (err < 0)
     1742                goto error;
    16871743        snd_printdd(" done.\n");
    16881744
    … …  
    16931749        snd_card_set_dev(card, &pci->dev);
    16941750
    1695         if ((err = snd_card_register(card)) < 0) {
    1696                 snd_card_free(card);
    1697                 return err;
    1698         }
     1751        err = snd_card_register(card);
     1752        if (err < 0)
     1753                goto error;
    16991754
    17001755        pci_set_drvdata(pci, card);
    17011756        dev++;
    17021757        return 0;
     1758
     1759 error:
     1760        snd_card_free(card);
     1761        return err;
    17031762}
    17041763
    … …  
    17081767        pci_set_drvdata(pci, NULL);
    17091768}
     1769
     1770#ifdef CONFIG_PM
     1771static int snd_ca0106_suspend(struct pci_dev *pci, pm_message_t state)
     1772{
     1773        struct snd_card *card = pci_get_drvdata(pci);
     1774        struct snd_ca0106 *chip = card->private_data;
     1775        int i;
     1776
     1777        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
     1778        for (i = 0; i < 4; i++)
     1779                snd_pcm_suspend_all(chip->pcm[i]);
     1780        if (chip->details->ac97)
     1781                snd_ac97_suspend(chip->ac97);
     1782        snd_ca0106_mixer_suspend(chip);
     1783
     1784        ca0106_stop_chip(chip);
     1785
     1786        pci_disable_device(pci);
     1787        pci_save_state(pci);
     1788        pci_set_power_state(pci, pci_choose_state(pci, state));
     1789        return 0;
     1790}
     1791
     1792static int snd_ca0106_resume(struct pci_dev *pci)
     1793{
     1794        struct snd_card *card = pci_get_drvdata(pci);
     1795        struct snd_ca0106 *chip = card->private_data;
     1796        int i;
     1797
     1798        pci_set_power_state(pci, PCI_D0);
     1799        pci_restore_state(pci);
     1800
     1801        if (pci_enable_device(pci) < 0) {
     1802                snd_card_disconnect(card);
     1803                return -EIO;
     1804        }
     1805
     1806        pci_set_master(pci);
     1807
     1808        ca0106_init_chip(chip, 1);
     1809
     1810        if (chip->details->ac97)
     1811                snd_ac97_resume(chip->ac97);
     1812        snd_ca0106_mixer_resume(chip);
     1813        if (chip->details->spi_dac) {
     1814                for (i = 0; i < ARRAY_SIZE(chip->spi_dac_reg); i++)
     1815                        snd_ca0106_spi_write(chip, chip->spi_dac_reg[i]);
     1816        }
     1817
     1818        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
     1819        return 0;
     1820}
     1821#endif
    17101822
    17111823// PCI IDs
    … …  
    17221834        .probe = snd_ca0106_probe,
    17231835        .remove = __devexit_p(snd_ca0106_remove),
     1836#ifdef CONFIG_PM
     1837        .suspend = snd_ca0106_suspend,
     1838        .resume = snd_ca0106_resume,
     1839#endif
    17241840};
    17251841

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/ca0106/ca0106_mixer.c

    r399 r410  
    7676#include "ca0106.h"
    7777
     78static void ca0106_spdif_enable(struct snd_ca0106 *emu)
     79{
     80        unsigned int val;
     81
     82        if (emu->spdif_enable) {
     83                /* Digital */
     84                snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
     85                snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
     86                val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000;
     87                snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
     88                val = inl(emu->port + GPIO) & ~0x101;
     89                outl(val, emu->port + GPIO);
     90
     91        } else {
     92                /* Analog */
     93                snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
     94                snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
     95                val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000;
     96                snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
     97                val = inl(emu->port + GPIO) | 0x101;
     98                outl(val, emu->port + GPIO);
     99        }
     100}
     101
     102static void ca0106_set_capture_source(struct snd_ca0106 *emu)
     103{
     104        unsigned int val = emu->capture_source;
     105        unsigned int source, mask;
     106        source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
     107        mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
     108        snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
     109}
     110
     111static void ca0106_set_i2c_capture_source(struct snd_ca0106 *emu,
     112                                          unsigned int val, int force)
     113{
     114        unsigned int ngain, ogain;
     115        u32 source;
     116
     117        snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
     118        ngain = emu->i2c_capture_volume[val][0]; /* Left */
     119        ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
     120        if (force || ngain != ogain)
     121                snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ngain & 0xff);
     122        ngain = emu->i2c_capture_volume[val][1]; /* Right */
     123        ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
     124        if (force || ngain != ogain)
     125                snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ngain & 0xff);
     126        source = 1 << val;
     127        snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
     128        emu->i2c_capture_source = val;
     129}
     130
     131static void ca0106_set_capture_mic_line_in(struct snd_ca0106 *emu)
     132{
     133        u32 tmp;
     134
     135        if (emu->capture_mic_line_in) {
     136                /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
     137                tmp = inl(emu->port+GPIO) & ~0x400;
     138                tmp = tmp | 0x400;
     139                outl(tmp, emu->port+GPIO);
     140                /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC); */
     141        } else {
     142                /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
     143                tmp = inl(emu->port+GPIO) & ~0x400;
     144                outl(tmp, emu->port+GPIO);
     145                /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN); */
     146        }
     147}
     148
     149static void ca0106_set_spdif_bits(struct snd_ca0106 *emu, int idx)
     150{
     151        snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, emu->spdif_str_bits[idx]);
     152}
     153
     154/*
     155 */
    78156static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
    79157static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
    … …  
    96174        unsigned int val;
    97175        int change = 0;
    98         u32 mask;
    99176
    100177        val = !!ucontrol->value.integer.value[0];
    … …  
    102179        if (change) {
    103180                emu->spdif_enable = val;
    104                 if (val) {
    105                         /* Digital */
    106                         snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
    107                         snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
    108                         snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
    109                                 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000);
    110                         mask = inl(emu->port + GPIO) & ~0x101;
    111                         outl(mask, emu->port + GPIO);
    112 
    113                 } else {
    114                         /* Analog */
    115                         snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
    116                         snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
    117                         snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
    118                                 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000);
    119                         mask = inl(emu->port + GPIO) | 0x101;
    120                         outl(mask, emu->port + GPIO);
    121                 }
     181                ca0106_spdif_enable(emu);
    122182        }
    123183        return change;
    … …  
    155215        unsigned int val;
    156216        int change = 0;
    157         u32 mask;
    158         u32 source;
    159217
    160218        val = ucontrol->value.enumerated.item[0] ;
    … …  
    164222        if (change) {
    165223                emu->capture_source = val;
    166                 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
    167                 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
    168                 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
     224                ca0106_set_capture_source(emu);
    169225        }
    170226        return change;
    … …  
    201257        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
    202258        unsigned int source_id;
    203         unsigned int ngain, ogain;
    204259        int change = 0;
    205         u32 source;
    206260        /* If the capture source has changed,
    207261         * update the capture volume from the cached value
    … …  
    213267        change = (emu->i2c_capture_source != source_id);
    214268        if (change) {
    215                 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
    216                 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
    217                 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
    218                 if (ngain != ogain)
    219                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
    220                 ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
    221                 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
    222                 if (ngain != ogain)
    223                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
    224                 source = 1 << source_id;
    225                 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
    226                 emu->i2c_capture_source = source_id;
     269                ca0106_set_i2c_capture_source(emu, source_id, 0);
    227270        }
    228271        return change;
    … …  
    272315        unsigned int val;
    273316        int change = 0;
    274         u32 tmp;
    275317
    276318        val = ucontrol->value.enumerated.item[0] ;
    … …  
    280322        if (change) {
    281323                emu->capture_mic_line_in = val;
    282                 if (val) {
    283                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
    284                         tmp = inl(emu->port+GPIO) & ~0x400;
    285                         tmp = tmp | 0x400;
    286                         outl(tmp, emu->port+GPIO);
    287                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
    288                 } else {
    289                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
    290                         tmp = inl(emu->port+GPIO) & ~0x400;
    291                         outl(tmp, emu->port+GPIO);
    292                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
    293                 }
     324                ca0106_set_capture_mic_line_in(emu);
    294325        }
    295326        return change;
    … …  
    323354}
    324355
    325 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
     356static void decode_spdif_bits(unsigned char *status, unsigned int bits)
     357{
     358        status[0] = (bits >> 0) & 0xff;
     359        status[1] = (bits >> 8) & 0xff;
     360        status[2] = (bits >> 16) & 0xff;
     361        status[3] = (bits >> 24) & 0xff;
     362}
     363
     364static int snd_ca0106_spdif_get_default(struct snd_kcontrol *kcontrol,
    326365                                 struct snd_ctl_elem_value *ucontrol)
    327366{
    … …  
    329368        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
    330369
    331         ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
    332         ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
    333         ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
    334         ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
     370        decode_spdif_bits(ucontrol->value.iec958.status,
     371                          emu->spdif_bits[idx]);
     372        return 0;
     373}
     374
     375static int snd_ca0106_spdif_get_stream(struct snd_kcontrol *kcontrol,
     376                                 struct snd_ctl_elem_value *ucontrol)
     377{
     378        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
     379        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
     380
     381        decode_spdif_bits(ucontrol->value.iec958.status,
     382                          emu->spdif_str_bits[idx]);
    335383        return 0;
    336384}
    … …  
    346394}
    347395
    348 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
     396static unsigned int encode_spdif_bits(unsigned char *status)
     397{
     398        return ((unsigned int)status[0] << 0) |
     399                ((unsigned int)status[1] << 8) |
     400                ((unsigned int)status[2] << 16) |
     401                ((unsigned int)status[3] << 24);
     402}
     403
     404static int snd_ca0106_spdif_put_default(struct snd_kcontrol *kcontrol,
    349405                                 struct snd_ctl_elem_value *ucontrol)
    350406{
    351407        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
    352408        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
    353         int change;
    354409        unsigned int val;
    355410
    356         val = (ucontrol->value.iec958.status[0] << 0) |
    357               (ucontrol->value.iec958.status[1] << 8) |
    358               (ucontrol->value.iec958.status[2] << 16) |
    359               (ucontrol->value.iec958.status[3] << 24);
    360         change = val != emu->spdif_bits[idx];
    361         if (change) {
    362                 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
     411        val = encode_spdif_bits(ucontrol->value.iec958.status);
     412        if (val != emu->spdif_bits[idx]) {
    363413                emu->spdif_bits[idx] = val;
    364         }
    365         return change;
     414                /* FIXME: this isn't safe, but needed to keep the compatibility
     415                 * with older alsa-lib config
     416                 */
     417                emu->spdif_str_bits[idx] = val;
     418                ca0106_set_spdif_bits(emu, idx);
     419                return 1;
     420        }
     421        return 0;
     422}
     423
     424static int snd_ca0106_spdif_put_stream(struct snd_kcontrol *kcontrol,
     425                                 struct snd_ctl_elem_value *ucontrol)
     426{
     427        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
     428        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
     429        unsigned int val;
     430
     431        val = encode_spdif_bits(ucontrol->value.iec958.status);
     432        if (val != emu->spdif_str_bits[idx]) {
     433                emu->spdif_str_bits[idx] = val;
     434                ca0106_set_spdif_bits(emu, idx);
     435                return 1;
     436        }
     437        return 0;
    366438}
    367439
    … …  
    574646                .count =        4,
    575647                .info =         snd_ca0106_spdif_info,
    576                 .get =          snd_ca0106_spdif_get,
    577                 .put =          snd_ca0106_spdif_put
     648                .get =          snd_ca0106_spdif_get_default,
     649                .put =          snd_ca0106_spdif_put_default
     650        },
     651        {
     652                .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
     653                .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
     654                .count =        4,
     655                .info =         snd_ca0106_spdif_info,
     656                .get =          snd_ca0106_spdif_get_stream,
     657                .put =          snd_ca0106_spdif_put_stream
    578658        },
    579659};
    … …  
    774854}
    775855
     856#ifdef CONFIG_PM
     857struct ca0106_vol_tbl {
     858        unsigned int channel_id;
     859        unsigned int reg;
     860};
     861
     862static struct ca0106_vol_tbl saved_volumes[NUM_SAVED_VOLUMES] = {
     863        { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2 },
     864        { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2 },
     865        { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2 },
     866        { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2 },
     867        { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1 },
     868        { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1 },
     869        { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1 },
     870        { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1 },
     871        { 1, CAPTURE_CONTROL },
     872};
     873
     874void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip)
     875{
     876        int i;
     877
     878        /* save volumes */
     879        for (i = 0; i < NUM_SAVED_VOLUMES; i++)
     880                chip->saved_vol[i] =
     881                        snd_ca0106_ptr_read(chip, saved_volumes[i].reg,
     882                                            saved_volumes[i].channel_id);
     883}
     884
     885void snd_ca0106_mixer_resume(struct snd_ca0106  *chip)
     886{
     887        int i;
     888
     889        for (i = 0; i < NUM_SAVED_VOLUMES; i++)
     890                snd_ca0106_ptr_write(chip, saved_volumes[i].reg,
     891                                     saved_volumes[i].channel_id,
     892                                     chip->saved_vol[i]);
     893
     894        ca0106_spdif_enable(chip);
     895        ca0106_set_capture_source(chip);
     896        ca0106_set_i2c_capture_source(chip, chip->i2c_capture_source, 1);
     897        for (i = 0; i < 4; i++)
     898                ca0106_set_spdif_bits(chip, i);
     899        if (chip->details->i2c_adc)
     900                ca0106_set_capture_mic_line_in(chip);
     901}
     902#endif /* CONFIG_PM */

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

    r399 r410  
    32893289        }
    32903290
    3291         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    3292         if (card == NULL)
    3293                 return -ENOMEM;
     3291        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     3292        if (err < 0)
     3293                return err;
    32943294       
    32953295        switch (pci->device) {

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

    r399 r410  
    19261926        }
    19271927
    1928         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1929         if (card == NULL)
    1930                 return -ENOMEM;
     1928        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1929        if (err < 0)
     1930                return err;
    19311931
    19321932        if ((err = snd_cs4281_create(card, pci, &chip, dual_codec[dev])) < 0) {

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

    r305 r410  
    9292        }
    9393
    94         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    95         if (card == NULL)
    96                 return -ENOMEM;
     94        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     95        if (err < 0)
     96                return err;
    9797        if ((err = snd_cs46xx_create(card, pci,
    9898                                     external_amp[dev], thinkpad[dev],

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/cs46xx/cs46xx_lib.c

    r399 r410  
    36413641        struct snd_card *card = pci_get_drvdata(pci);
    36423642        struct snd_cs46xx *chip = card->private_data;
    3643         int i, amp_saved;
     3643        int amp_saved;
     3644#ifdef CONFIG_SND_CS46XX_NEW_DSP
     3645        int i;
     3646#endif
    36443647
    36453648        pci_set_power_state(pci, PCI_D0);

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

    r305 r410  
    121121        }
    122122
    123         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    124         if (card == NULL)
    125                 return -ENOMEM;
     123        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     124        if (err < 0)
     125                return err;
    126126        if (max_buffer_size[dev] < 32)
    127127                max_buffer_size[dev] = 32;

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

    r399 r410  
    15491549        }
    15501550
    1551         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1552         if (card == NULL)
    1553                 return -ENOMEM;
     1551        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1552        if (err < 0)
     1553                return err;
    15541554
    15551555        if ((err = snd_emu10k1x_create(card, pci, &chip)) < 0) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/emu10k1/emumixer.c

    r399 r410  
    16391639        .put =          snd_emu10k1_shared_spdif_put
    16401640};
     1641
     1642/* workaround for too low volume on Audigy due to 16bit/24bit conversion */
     1643
     1644#define snd_audigy_capture_boost_info   snd_ctl_boolean_mono_info
     1645
     1646static int snd_audigy_capture_boost_get(struct snd_kcontrol *kcontrol,
     1647                                        struct snd_ctl_elem_value *ucontrol)
     1648{
     1649        struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
     1650        unsigned int val;
     1651
     1652        /* FIXME: better to use a cached version */
     1653        val = snd_ac97_read(emu->ac97, AC97_REC_GAIN);
     1654        ucontrol->value.integer.value[0] = !!val;
     1655        return 0;
     1656}
     1657
     1658static int snd_audigy_capture_boost_put(struct snd_kcontrol *kcontrol,
     1659                                        struct snd_ctl_elem_value *ucontrol)
     1660{
     1661        struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
     1662        unsigned int val;
     1663
     1664        if (ucontrol->value.integer.value[0])
     1665                val = 0x0f0f;
     1666        else
     1667                val = 0;
     1668        return snd_ac97_update(emu->ac97, AC97_REC_GAIN, val);
     1669}
     1670
     1671static struct snd_kcontrol_new snd_audigy_capture_boost __devinitdata =
     1672{
     1673        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
     1674        .name =         "Analog Capture Boost",
     1675        .info =         snd_audigy_capture_boost_info,
     1676        .get =          snd_audigy_capture_boost_get,
     1677        .put =          snd_audigy_capture_boost_put
     1678};
     1679
    16411680
    16421681/*
    … …  
    20882127        }
    20892128               
    2090         return 0;
    2091 }
     2129        if (emu->card_capabilities->ac97_chip && emu->audigy) {
     2130                err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_capture_boost,
     2131                                                     emu));
     2132                if (err < 0)
     2133                        return err;
     2134        }
     2135
     2136        return 0;
     2137}

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

    r399 r410  
    24142414        }
    24152415
    2416         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    2417         if (card == NULL)
    2418                 return -ENOMEM;
     2416        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     2417        if (err < 0)
     2418                return err;
    24192419
    24202420        if ((err = snd_ensoniq_create(card, pci, &ensoniq)) < 0) {

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

    r399 r410  
    18001800        }
    18011801
    1802         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1803         if (card == NULL)
    1804                 return -ENOMEM;
     1802        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1803        if (err < 0)
     1804                return err;
    18051805        for (idx = 0; idx < 5; idx++) {
    18061806                if (pci_resource_start(pci, idx) == 0 ||

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

    r399 r410  
    19631963
    19641964        if (event & ESM_HWVOL_IRQ)
    1965                 tasklet_hi_schedule(&chip->hwvol_tq); /* we'll do this later */
     1965                tasklet_schedule(&chip->hwvol_tq); /* we'll do this later */
    19661966
    19671967        /* else ack 'em all, i imagine */
    … …  
    26552655        }
    26562656
    2657         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    2658         if (!card)
    2659                 return -ENOMEM;
     2657        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     2658        if (err < 0)
     2659                return err;
    26602660               
    26612661        if (total_bufsize[dev] < 128)

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

    r358 r410  
    14731473        }
    14741474
    1475         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1476         if (card == NULL)
    1477                 return -ENOMEM;
     1475        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1476        if (err < 0)
     1477                return err;
    14781478        if ((err = snd_fm801_create(card, pci, tea575x_tuner[dev], &chip)) < 0) {
    14791479                snd_card_free(card);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_beep.h

    r401 r410  
    3232        int tone;
    3333        int nid;
     34        int enabled;
    3435        struct work_struct beep_work; /* scheduled task for beep event */
    3536};

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

    r402 r410  
    3232#include "hda_local.h"
    3333#include <sound/hda_hwdep.h>
    34 #include "hda_patch.h"  /* codec presets */
    35 
    36 #ifdef CONFIG_SND_HDA_POWER_SAVE
    37 /* define this option here to hide as static */
    38 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
    39 module_param(power_save, int, 0644);
    40 MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
    41                  "(in second, 0 = disable).");
    42 #endif
    4334
    4435/*
    … …  
    5647        { 0x1057, "Motorola" },
    5748        { 0x1095, "Silicon Image" },
     49        { 0x10de, "Nvidia" },
    5850        { 0x10ec, "Realtek" },
    5951        { 0x1106, "VIA" },
    … …  
    6759        { 0x1aec, "Wolfson Microelectronics" },
    6860        { 0x434d, "C-Media" },
     61        { 0x8086, "Intel" },
    6962        { 0x8384, "SigmaTel" },
    7063        {0} /* terminator */
    7164};
    7265
    73 static const struct hda_codec_preset *hda_preset_tables[] = {
    74 #ifdef CONFIG_SND_HDA_CODEC_REALTEK
    75         snd_hda_preset_realtek,
    76 #endif
    77 #ifdef CONFIG_SND_HDA_CODEC_CMEDIA
    78         snd_hda_preset_cmedia,
    79 #endif
    80 #ifdef CONFIG_SND_HDA_CODEC_ANALOG
    81         snd_hda_preset_analog,
    82 #endif
    83 #ifdef CONFIG_SND_HDA_CODEC_SIGMATEL
    84         snd_hda_preset_sigmatel,
    85 #endif
    86 #ifdef CONFIG_SND_HDA_CODEC_SI3054
    87         snd_hda_preset_si3054,
    88 #endif
    89 #ifdef CONFIG_SND_HDA_CODEC_ATIHDMI
    90         snd_hda_preset_atihdmi,
    91 #endif
    92 #ifdef CONFIG_SND_HDA_CODEC_CONEXANT
    93         snd_hda_preset_conexant,
    94 #endif
    95 #ifdef CONFIG_SND_HDA_CODEC_VIA
    96         snd_hda_preset_via,
    97 #endif
    98 #ifdef CONFIG_SND_HDA_CODEC_NVHDMI
    99         snd_hda_preset_nvhdmi,
    100 #endif
    101 #ifdef CONFIG_SND_HDA_CODEC_INTELHDMI
    102         snd_hda_preset_intelhdmi,
    103 #endif
    104         NULL
    105 };
     66static DEFINE_MUTEX(preset_mutex);
     67static LIST_HEAD(hda_preset_tables);
     68
     69int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
     70{
     71        mutex_lock(&preset_mutex);
     72        list_add_tail(&preset->list, &hda_preset_tables);
     73        mutex_unlock(&preset_mutex);
     74        return 0;
     75}
     76EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
     77
     78int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
     79{
     80        mutex_lock(&preset_mutex);
     81        list_del(&preset->list);
     82        mutex_unlock(&preset_mutex);
     83        return 0;
     84}
     85EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
    10686
    10787#ifdef CONFIG_SND_HDA_POWER_SAVE
    … …  
    137117        return "UNKNOWN";
    138118}
     119EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
    139120
    140121const char *snd_hda_get_jack_connectivity(u32 cfg)
    … …  
    144125        return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
    145126}
     127EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
    146128
    147129const char *snd_hda_get_jack_type(u32 cfg)
    … …  
    157139                                >> AC_DEFCFG_DEVICE_SHIFT];
    158140}
     141EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
    159142
    160143/*
    … …  
    205188        return res;
    206189}
     190EXPORT_SYMBOL_HDA(snd_hda_codec_read);
    207191
    208192/**
    … …  
    233217        return err;
    234218}
     219EXPORT_SYMBOL_HDA(snd_hda_codec_write);
    235220
    236221/**
    … …  
    247232                snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
    248233}
     234EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
    249235
    250236/**
    … …  
    268254        return (int)(parm & 0x7fff);
    269255}
     256EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
    270257
    271258/**
    … …  
    356343        return conns;
    357344}
     345EXPORT_SYMBOL_HDA(snd_hda_get_connections);
    358346
    359347
    … …  
    386374        unsol->queue[wp + 1] = res_ex;
    387375
    388 /* 2.4 kernels seem to have a problem with workq wrapper... */
    389 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    390         schedule_work(&unsol->work);
    391 #endif
    392         return 0;
    393 }
     376        queue_work(bus->workq, &unsol->work);
     377
     378        return 0;
     379}
     380EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
    394381
    395382/*
    … …  
    453440        if (!bus)
    454441                return 0;
    455         if (bus->unsol) {
    456 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    457                 flush_scheduled_work();
    458 #endif
     442        if (bus->workq)
     443                flush_workqueue(bus->workq);
     444        if (bus->unsol)
    459445                kfree(bus->unsol);
    460         }
    461446        list_for_each_entry_safe(codec, n, &bus->codec_list, list, struct hda_codec) {
    462447                snd_hda_codec_free(codec);
    … …  
    464449        if (bus->ops.private_free)
    465450                bus->ops.private_free(bus);
     451        if (bus->workq)
     452                destroy_workqueue(bus->workq);
    466453        kfree(bus);
    467454        return 0;
    … …  
    471458{
    472459        struct hda_bus *bus = device->device_data;
     460        bus->shutdown = 1;
    473461        return snd_hda_bus_free(bus);
    474462}
    … …  
    496484 * Returns 0 if successful, or a negative error code.
    497485 */
    498 int __devinit snd_hda_bus_new(struct snd_card *card,
     486int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
    499487                              const struct hda_bus_template *temp,
    500488                              struct hda_bus **busp)
    … …  
    502490        struct hda_bus *bus;
    503491        int err;
     492        char qname[8];
    504493        static struct snd_device_ops dev_ops = {
    505494                .dev_register = snd_hda_bus_dev_register,
    … …  
    525514        bus->pci = temp->pci;
    526515        bus->modelname = temp->modelname;
     516        bus->power_save = temp->power_save;
    527517        bus->ops = temp->ops;
    528518
    529519        mutex_init(&bus->cmd_mutex);
    530520        INIT_LIST_HEAD(&bus->codec_list);
     521
     522        snprintf(qname, sizeof(qname), "hda%d", card->number);
     523        bus->workq = create_workqueue(qname);
     524        if (!bus->workq) {
     525                snd_printk(KERN_ERR "cannot create workqueue %s\n", qname);
     526                kfree(bus);
     527                return -ENOMEM;
     528        }
    531529
    532530        err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
    … …  
    539537        return 0;
    540538}
     539EXPORT_SYMBOL_HDA(snd_hda_bus_new);
    541540
    542541#ifdef CONFIG_SND_HDA_GENERIC
    … …  
    547546#endif
    548547
     548#ifdef MODULE
     549#define HDA_MODREQ_MAX_COUNT    2       /* two request_modules()'s */
     550#else
     551#define HDA_MODREQ_MAX_COUNT    0       /* all presets are statically linked */
     552#endif
     553
    549554/*
    550555 * find a matching codec preset
    … …  
    553558find_codec_preset(struct hda_codec *codec)
    554559{
    555         const struct hda_codec_preset **tbl, *preset;
     560        struct hda_codec_preset_list *tbl;
     561        const struct hda_codec_preset *preset;
     562        int mod_requested = 0;
    556563
    557564        if (is_generic_config(codec))
    558565                return NULL; /* use the generic parser */
    559566
    560         for (tbl = hda_preset_tables; *tbl; tbl++) {
    561                 for (preset = *tbl; preset->id; preset++) {
     567 again:
     568        mutex_lock(&preset_mutex);
     569        list_for_each_entry(tbl, &hda_preset_tables, list, struct hda_codec_preset_list) {
     570                if (!try_module_get(tbl->owner)) {
     571                        snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
     572                        continue;
     573                }
     574                for (preset = tbl->preset; preset->id; preset++) {
    562575                        u32 mask = preset->mask;
    563576                        if (preset->afg && preset->afg != codec->afg)
    … …  
    569582                        if (preset->id == (codec->vendor_id & mask) &&
    570583                            (!preset->rev ||
    571                              preset->rev == codec->revision_id))
     584                             preset->rev == codec->revision_id)) {
     585                                mutex_unlock(&preset_mutex);
     586                                codec->owner = tbl->owner;
    572587                                return preset;
    573                 }
    574         }
     588                        }
     589                }
     590                module_put(tbl->owner);
     591        }
     592        mutex_unlock(&preset_mutex);
     593
     594#ifndef TARGET_OS2
     595        if (mod_requested < HDA_MODREQ_MAX_COUNT) {
     596                char name[32];
     597                if (!mod_requested)
     598                        snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
     599                                 codec->vendor_id);
     600                else
     601                        snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
     602                                 (codec->vendor_id >> 16) & 0xffff);
     603                request_module(name);
     604                mod_requested++;
     605                goto again;
     606        }
     607#endif
    575608        return NULL;
    576609}
    … …  
    611644 * look for an AFG and MFG nodes
    612645 */
    613 static void __devinit setup_fg_nodes(struct hda_codec *codec)
     646static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
    614647{
    615648        int i, total_nodes;
    … …  
    667700#ifdef CONFIG_SND_HDA_POWER_SAVE
    668701        cancel_delayed_work(&codec->power_work);
    669         flush_scheduled_work();
     702        flush_workqueue(codec->bus->workq);
    670703#endif
    671704        list_del(&codec->list);
    … …  
    674707        if (codec->patch_ops.free)
    675708                codec->patch_ops.free(codec);
     709        module_put(codec->owner);
    676710        free_hda_cache(&codec->amp_cache);
    677711        free_hda_cache(&codec->cmd_cache);
    … …  
    690724 * Returns 0 if successful, or a negative error code.
    691725 */
    692 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
    693                                 struct hda_codec **codecp)
     726int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
     727                                    int do_init, struct hda_codec **codecp)
    694728{
    695729        struct hda_codec *codec;
    … …  
    717751        codec->addr = codec_addr;
    718752        mutex_init(&codec->spdif_mutex);
     753        mutex_init(&codec->control_mutex);
    719754        init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
    720755        init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
    … …  
    775810                codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
    776811
    777         err = snd_hda_codec_configure(codec);
    778         if (err < 0) {
    779                 snd_hda_codec_free(codec);
    780                 return err;
     812        if (do_init) {
     813                err = snd_hda_codec_configure(codec);
     814                if (err < 0) {
     815                        snd_hda_codec_free(codec);
     816                        return err;
     817                }
    781818        }
    782819        snd_hda_codec_proc_new(codec);
    … …  
    792829        return 0;
    793830}
     831EXPORT_SYMBOL_HDA(snd_hda_codec_new);
    794832
    795833int snd_hda_codec_configure(struct hda_codec *codec)
    … …  
    851889        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
    852890}
     891EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
    853892
    854893void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
    … …  
    864903#endif
    865904}
     905EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
    866906
    867907/*
    … …  
    875915
    876916/* initialize the hash table */
    877 static void __devinit init_hda_cache(struct hda_cache_rec *cache,
     917static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
    878918                                     unsigned int record_size)
    879919{
    … …  
    945985        return info->amp_caps;
    946986}
     987EXPORT_SYMBOL_HDA(query_amp_caps);
    947988
    948989int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
    … …  
    958999        return 0;
    9591000}
     1001EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
    9601002
    9611003/*
    … …  
    10111053        return get_vol_mute(codec, info, nid, ch, direction, index);
    10121054}
     1055EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
    10131056
    10141057/*
    … …  
    10301073        return 1;
    10311074}
     1075EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
    10321076
    10331077/*
    … …  
    10431087        return ret;
    10441088}
     1089EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
    10451090
    10461091#ifdef SND_HDA_NEEDS_RESUME
    … …  
    10681113        }
    10691114}
     1115EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
    10701116#endif /* SND_HDA_NEEDS_RESUME */
    10711117
    … …  
    10951141        return 0;
    10961142}
     1143EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
    10971144
    10981145int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
    … …  
    11141161        return 0;
    11151162}
     1163EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
    11161164
    11171165int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
    … …  
    11381186        return change;
    11391187}
     1188EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
    11401189
    11411190int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
    … …  
    11641213        return 0;
    11651214}
     1215EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
    11661216
    11671217/*
    … …  
    11831233        tlv[3] = step;
    11841234}
     1235EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
    11851236
    11861237/* find a mixer control element with the given name */
    … …  
    12021253        return _snd_hda_find_mixer_ctl(codec, name, 0);
    12031254}
     1255EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
    12041256
    12051257/* Add a control element and assign to the codec */
    … …  
    12181270        return 0;
    12191271}
    1220 
     1272EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
     1273
     1274#ifdef CONFIG_SND_HDA_RECONFIG
    12211275/* Clear all controls assigned to the given codec */
    12221276void snd_hda_ctls_clear(struct hda_codec *codec)
    … …  
    12351289#ifdef CONFIG_SND_HDA_POWER_SAVE
    12361290        cancel_delayed_work(&codec->power_work);
    1237         flush_scheduled_work();
     1291        flush_workqueue(codec->bus->workq);
    12381292#endif
    12391293        snd_hda_ctls_clear(codec);
    12401294        /* relase PCMs */
    12411295        for (i = 0; i < codec->num_pcms; i++) {
    1242                 if (codec->pcm_info[i].pcm)
     1296                if (codec->pcm_info[i].pcm) {
    12431297                        snd_device_free(codec->bus->card,
    12441298                                        codec->pcm_info[i].pcm);
     1299                        clear_bit(codec->pcm_info[i].device,
     1300                                  codec->bus->pcm_dev_bits);
     1301                }
    12451302        }
    12461303        if (codec->patch_ops.free)
    12471304                codec->patch_ops.free(codec);
     1305        codec->proc_widget_hook = NULL;
    12481306        codec->spec = NULL;
    12491307        free_hda_cache(&codec->amp_cache);
    12501308        free_hda_cache(&codec->cmd_cache);
     1309        init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
     1310        init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
    12511311        codec->num_pcms = 0;
    12521312        codec->pcm_info = NULL;
    12531313        codec->preset = NULL;
    1254 }
     1314        module_put(codec->owner);
     1315        codec->owner = NULL;
     1316}
     1317#endif /* CONFIG_SND_HDA_RECONFIG */
    12551318
    12561319/* create a virtual master control and add slaves */
    … …  
    12891352        return 0;
    12901353}
     1354EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
    12911355
    12921356/* switch */
    … …  
    13021366        return 0;
    13031367}
     1368EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
    13041369
    13051370int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
    … …  
    13211386        return 0;
    13221387}
     1388EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
    13231389
    13241390int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
    … …  
    13511417        return change;
    13521418}
     1419EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
    13531420
    13541421/*
    … …  
    13681435        int err;
    13691436
    1370         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1437        mutex_lock(&codec->control_mutex);
    13711438        pval = kcontrol->private_value;
    13721439        kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
    13731440        err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
    13741441        kcontrol->private_value = pval;
    1375         mutex_unlock(&codec->spdif_mutex);
     1442        mutex_unlock(&codec->control_mutex);
    13761443        return err;
    13771444}
     1445EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
    13781446
    13791447int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
    … …  
    13841452        int i, indices, err = 0, change = 0;
    13851453
    1386         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1454        mutex_lock(&codec->control_mutex);
    13871455        pval = kcontrol->private_value;
    13881456        indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
    … …  
    13961464        }
    13971465        kcontrol->private_value = pval;
    1398         mutex_unlock(&codec->spdif_mutex);
     1466        mutex_unlock(&codec->control_mutex);
    13991467        return err < 0 ? err : change;
    14001468}
     1469EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
    14011470
    14021471/*
    … …  
    14101479        int err;
    14111480
    1412         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1481        mutex_lock(&codec->control_mutex);
    14131482        c = (struct hda_bind_ctls *)kcontrol->private_value;
    14141483        kcontrol->private_value = *c->values;
    14151484        err = c->ops->info(kcontrol, uinfo);
    14161485        kcontrol->private_value = (long)c;
    1417         mutex_unlock(&codec->spdif_mutex);
     1486        mutex_unlock(&codec->control_mutex);
    14181487        return err;
    14191488}
     1489EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
    14201490
    14211491int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
    … …  
    14261496        int err;
    14271497
    1428         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1498        mutex_lock(&codec->control_mutex);
    14291499        c = (struct hda_bind_ctls *)kcontrol->private_value;
    14301500        kcontrol->private_value = *c->values;
    14311501        err = c->ops->get(kcontrol, ucontrol);
    14321502        kcontrol->private_value = (long)c;
    1433         mutex_unlock(&codec->spdif_mutex);
     1503        mutex_unlock(&codec->control_mutex);
    14341504        return err;
    14351505}
     1506EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
    14361507
    14371508int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
    … …  
    14431514        int err = 0, change = 0;
    14441515
    1445         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1516        mutex_lock(&codec->control_mutex);
    14461517        c = (struct hda_bind_ctls *)kcontrol->private_value;
    14471518        for (vals = c->values; *vals; vals++) {
    … …  
    14531524        }
    14541525        kcontrol->private_value = (long)c;
    1455         mutex_unlock(&codec->spdif_mutex);
     1526        mutex_unlock(&codec->control_mutex);
    14561527        return err < 0 ? err : change;
    14571528}
     1529EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
    14581530
    14591531int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
    … …  
    14641536        int err;
    14651537
    1466         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1538        mutex_lock(&codec->control_mutex);
    14671539        c = (struct hda_bind_ctls *)kcontrol->private_value;
    14681540        kcontrol->private_value = *c->values;
    14691541        err = c->ops->tlv(kcontrol, op_flag, size, tlv);
    14701542        kcontrol->private_value = (long)c;
    1471         mutex_unlock(&codec->spdif_mutex);
     1543        mutex_unlock(&codec->control_mutex);
    14721544        return err;
    14731545}
     1546EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
    14741547
    14751548struct hda_ctl_ops snd_hda_bind_vol = {
    … …  
    14791552        .tlv = snd_hda_mixer_amp_tlv
    14801553};
     1554EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
    14811555
    14821556struct hda_ctl_ops snd_hda_bind_sw = {
    … …  
    14861560        .tlv = snd_hda_mixer_amp_tlv
    14871561};
     1562EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
    14881563
    14891564/*
    … …  
    15921667        hda_nid_t *d;
    15931668
    1594         snd_hda_codec_write(codec, nid, 0, verb, val);
     1669        snd_hda_codec_write_cache(codec, nid, 0, verb, val);
    15951670        d = codec->slave_dig_outs;
    15961671        if (!d)
    15971672                return;
    15981673        for (; *d; d++)
    1599                 snd_hda_codec_write(codec, *d, 0, verb, val);
     1674                snd_hda_codec_write_cache(codec, *d, 0, verb, val);
    16001675}
    16011676
    … …  
    17471822        return 0;
    17481823}
     1824EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
    17491825
    17501826/*
    … …  
    17841860                           snd_ctl_new1(&spdif_share_sw, mout));
    17851861}
     1862EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
    17861863
    17871864/*
    … …  
    18931970        return 0;
    18941971}
     1972EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
    18951973
    18961974#ifdef SND_HDA_NEEDS_RESUME
    … …  
    19382016        return err;
    19392017}
     2018EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
    19402019
    19412020/* resume the all commands from the cache */
    … …  
    19532032        }
    19542033}
     2034EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
    19552035
    19562036/**
    … …  
    19702050                                          seq->param);
    19712051}
     2052EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
    19722053#endif /* SND_HDA_NEEDS_RESUME */
    19732054
    … …  
    20882169 * Returns 0 if successful, otherwise a negative error code.
    20892170 */
    2090 int __devinit snd_hda_build_controls(struct hda_bus *bus)
     2171int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
    20912172{
    20922173        struct hda_codec *codec;
    … …  
    21002181        return 0;
    21012182}
     2183EXPORT_SYMBOL_HDA(snd_hda_build_controls);
    21022184
    21032185int snd_hda_codec_build_controls(struct hda_codec *codec)
    … …  
    22112293        return val;
    22122294}
     2295EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
    22132296
    22142297/**
    … …  
    22252308 * Returns 0 if successful, otherwise a negative error code.
    22262309 */
    2227 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
     2310static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
    22282311                                u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
    22292312{
    … …  
    23902473        return 1;
    23912474}
     2475EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
    23922476
    23932477/*
    … …  
    24472531
    24482532/*
    2449  * attach a new PCM stream
    2450  */
    2451 static int __devinit
    2452 snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
    2453 {
    2454         struct hda_bus *bus = codec->bus;
    2455         struct hda_pcm_stream *info;
    2456         int stream, err;
    2457 
    2458         if (snd_BUG_ON(!pcm->name))
    2459                 return -EINVAL;
    2460         for (stream = 0; stream < 2; stream++) {
    2461                 info = &pcm->stream[stream];
    2462                 if (info->substreams) {
    2463                         err = set_pcm_default_values(codec, info);
    2464                         if (err < 0)
    2465                                 return err;
    2466                 }
    2467         }
    2468         return bus->ops.attach_pcm(bus, codec, pcm);
    2469 }
    2470 
    2471 /**
    2472  * snd_hda_build_pcms - build PCM information
    2473  * @bus: the BUS
    2474  *
    2475  * Create PCM information for each codec included in the bus.
    2476  *
    2477  * The build_pcms codec patch is requested to set up codec->num_pcms and
    2478  * codec->pcm_info properly.  The array is referred by the top-level driver
    2479  * to create its PCM instances.
    2480  * The allocated codec->pcm_info should be released in codec->patch_ops.free
    2481  * callback.
    2482  *
    2483  * At least, substreams, channels_min and channels_max must be filled for
    2484  * each stream.  substreams = 0 indicates that the stream doesn't exist.
    2485  * When rates and/or formats are zero, the supported values are queried
    2486  * from the given nid.  The nid is used also by the default ops.prepare
    2487  * and ops.cleanup callbacks.
    2488  *
    2489  * The driver needs to call ops.open in its open callback.  Similarly,
    2490  * ops.close is supposed to be called in the close callback.
    2491  * ops.prepare should be called in the prepare or hw_params callback
    2492  * with the proper parameters for set up.
    2493  * ops.cleanup should be called in hw_free for clean up of streams.
    2494  *
    2495  * This function returns 0 if successfull, or a negative error code.
    2496  */
    2497 int snd_hda_build_pcms(struct hda_bus *bus)
     2533 * get the empty PCM device number to assign
     2534 */
     2535static int get_empty_pcm_device(struct hda_bus *bus, int type)
    24982536{
    24992537        static const char *dev_name[HDA_PCM_NTYPES] = {
    … …  
    25092547        /* normal audio device indices; not linear to keep compatibility */
    25102548        static int audio_idx[4] = { 0, 2, 4, 5 };
    2511         struct hda_codec *codec;
    2512         int num_devs[HDA_PCM_NTYPES];
    2513 
    2514         memset(num_devs, 0, sizeof(num_devs));
    2515         list_for_each_entry(codec, &bus->codec_list, list, struct hda_codec) {
    2516                 unsigned int pcm;
    2517                 int err;
    2518                 if (!codec->num_pcms) {
    2519                         if (!codec->patch_ops.build_pcms)
    2520                                 continue;
    2521                         err = codec->patch_ops.build_pcms(codec);
     2549        int i, dev;
     2550
     2551        switch (type) {
     2552        case HDA_PCM_TYPE_AUDIO:
     2553                for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
     2554                        dev = audio_idx[i];
     2555                        if (!test_bit(dev, bus->pcm_dev_bits))
     2556                                break;
     2557                }
     2558                if (i >= ARRAY_SIZE(audio_idx)) {
     2559                        snd_printk(KERN_WARNING "Too many audio devices\n");
     2560                        return -EAGAIN;
     2561                }
     2562                break;
     2563        case HDA_PCM_TYPE_SPDIF:
     2564        case HDA_PCM_TYPE_HDMI:
     2565        case HDA_PCM_TYPE_MODEM:
     2566                dev = dev_idx[type];
     2567                if (test_bit(dev, bus->pcm_dev_bits)) {
     2568                        snd_printk(KERN_WARNING "%s already defined\n",
     2569                                   dev_name[type]);
     2570                        return -EAGAIN;
     2571                }
     2572                break;
     2573        default:
     2574                snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
     2575                return -EINVAL;
     2576        }
     2577        set_bit(dev, bus->pcm_dev_bits);
     2578        return dev;
     2579}
     2580
     2581/*
     2582 * attach a new PCM stream
     2583 */
     2584static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
     2585{
     2586        struct hda_bus *bus = codec->bus;
     2587        struct hda_pcm_stream *info;
     2588        int stream, err;
     2589
     2590        if (snd_BUG_ON(!pcm->name))
     2591                return -EINVAL;
     2592        for (stream = 0; stream < 2; stream++) {
     2593                info = &pcm->stream[stream];
     2594                if (info->substreams) {
     2595                        err = set_pcm_default_values(codec, info);
    25222596                        if (err < 0)
    25232597                                return err;
    25242598                }
    2525                 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
    2526                         struct hda_pcm *cpcm = &codec->pcm_info[pcm];
    2527                         int type = cpcm->pcm_type;
    2528                         int dev;
    2529 
    2530                         if (!cpcm->stream[0].substreams &&
    2531                             !cpcm->stream[1].substreams)
    2532                                 continue; /* no substreams assigned */
    2533 
    2534                         switch (type) {
    2535                         case HDA_PCM_TYPE_AUDIO:
    2536                                 if (num_devs[type] >= ARRAY_SIZE(audio_idx)) {
    2537                                         snd_printk(KERN_WARNING
    2538                                                    "Too many audio devices\n");
    2539                                         continue;
    2540                                 }
    2541                                 dev = audio_idx[num_devs[type]];
    2542                                 break;
    2543                         case HDA_PCM_TYPE_SPDIF:
    2544                         case HDA_PCM_TYPE_HDMI:
    2545                         case HDA_PCM_TYPE_MODEM:
    2546                                 if (num_devs[type]) {
    2547                                         snd_printk(KERN_WARNING
    2548                                                    "%s already defined\n",
    2549                                                    dev_name[type]);
    2550                                         continue;
    2551                                 }
    2552                                 dev = dev_idx[type];
    2553                                 break;
    2554                         default:
    2555                                 snd_printk(KERN_WARNING
    2556                                            "Invalid PCM type %d\n", type);
    2557                                 continue;
    2558                         }
    2559                         num_devs[type]++;
    2560                         if (!cpcm->pcm) {
    2561                                 cpcm->device = dev;
    2562                                 err = snd_hda_attach_pcm(codec, cpcm);
    2563                                 if (err < 0)
    2564                                         return err;
    2565                         }
    2566                 }
    2567         }
    2568         return 0;
    2569 }
     2599        }
     2600        return bus->ops.attach_pcm(bus, codec, pcm);
     2601}
     2602
     2603/* assign all PCMs of the given codec */
     2604int snd_hda_codec_build_pcms(struct hda_codec *codec)
     2605{
     2606        unsigned int pcm;
     2607        int err;
     2608
     2609        if (!codec->num_pcms) {
     2610                if (!codec->patch_ops.build_pcms)
     2611                        return 0;
     2612                err = codec->patch_ops.build_pcms(codec);
     2613                if (err < 0)
     2614                        return err;
     2615        }
     2616        for (pcm = 0; pcm < codec->num_pcms; pcm++) {
     2617                struct hda_pcm *cpcm = &codec->pcm_info[pcm];
     2618                int dev;
     2619
     2620                if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
     2621                        return 0; /* no substreams assigned */
     2622
     2623                if (!cpcm->pcm) {
     2624                        dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
     2625                        if (dev < 0)
     2626                                return 0;
     2627                        cpcm->device = dev;
     2628                        err = snd_hda_attach_pcm(codec, cpcm);
     2629                        if (err < 0)
     2630                                return err;
     2631                }
     2632        }
     2633        return 0;
     2634}
     2635
     2636/**
     2637 * snd_hda_build_pcms - build PCM information
     2638 * @bus: the BUS
     2639 *
     2640 * Create PCM information for each codec included in the bus.
     2641 *
     2642 * The build_pcms codec patch is requested to set up codec->num_pcms and
     2643 * codec->pcm_info properly.  The array is referred by the top-level driver
     2644 * to create its PCM instances.
     2645 * The allocated codec->pcm_info should be released in codec->patch_ops.free
     2646 * callback.
     2647 *
     2648 * At least, substreams, channels_min and channels_max must be filled for
     2649 * each stream.  substreams = 0 indicates that the stream doesn't exist.
     2650 * When rates and/or formats are zero, the supported values are queried
     2651 * from the given nid.  The nid is used also by the default ops.prepare
     2652 * and ops.cleanup callbacks.
     2653 *
     2654 * The driver needs to call ops.open in its open callback.  Similarly,
     2655 * ops.close is supposed to be called in the close callback.
     2656 * ops.prepare should be called in the prepare or hw_params callback
     2657 * with the proper parameters for set up.
     2658 * ops.cleanup should be called in hw_free for clean up of streams.
     2659 *
     2660 * This function returns 0 if successfull, or a negative error code.
     2661 */
     2662int __devinit snd_hda_build_pcms(struct hda_bus *bus)
     2663{
     2664        struct hda_codec *codec;
     2665
     2666        list_for_each_entry(codec, &bus->codec_list, list, struct hda_codec) {
     2667                int err = snd_hda_codec_build_pcms(codec);
     2668                if (err < 0)
     2669                        return err;
     2670        }
     2671        return 0;
     2672}
     2673EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
    25702674
    25712675/**
    … …  
    26232727        return -1;
    26242728}
     2729EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
     2730
     2731/**
     2732 * snd_hda_check_board_codec_sid_config - compare the current codec
     2733                                          subsystem ID with the
     2734                                          config table
     2735
     2736           This is important for Gateway notebooks with SB450 HDA Audio
     2737           where the vendor ID of the PCI device is:
     2738                ATI Technologies Inc SB450 HDA Audio [1002:437b]
     2739           and the vendor/subvendor are found only at the codec.
     2740
     2741 * @codec: the HDA codec
     2742 * @num_configs: number of config enums
     2743 * @models: array of model name strings
     2744 * @tbl: configuration table, terminated by null entries
     2745 *
     2746 * Compares the modelname or PCI subsystem id of the current codec with the
     2747 * given configuration table.  If a matching entry is found, returns its
     2748 * config value (supposed to be 0 or positive).
     2749 *
     2750 * If no entries are matching, the function returns a negative value.
     2751 */
     2752int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
     2753                               int num_configs, const char **models,
     2754                               const struct snd_pci_quirk *tbl)
     2755{
     2756        const struct snd_pci_quirk *q;
     2757
     2758        /* Search for codec ID */
     2759        for (q = tbl; q->subvendor; q++) {
     2760                unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
     2761
     2762                if (vendorid == codec->subsystem_id)
     2763                        break;
     2764        }
     2765
     2766        if (!q->subvendor)
     2767                return -1;
     2768
     2769        tbl = q;
     2770
     2771        if (tbl->value >= 0 && tbl->value < num_configs) {
     2772#ifdef CONFIG_SND_DEBUG_DETECT
     2773                char tmp[10];
     2774                const char *model = NULL;
     2775                if (models)
     2776                        model = models[tbl->value];
     2777                if (!model) {
     2778                        sprintf(tmp, "#%d", tbl->value);
     2779                        model = tmp;
     2780                }
     2781                snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
     2782                            "for config %x:%x (%s)\n",
     2783                            model, tbl->subvendor, tbl->subdevice,
     2784                            (tbl->name ? tbl->name : "Unknown device"));
     2785#endif
     2786                return tbl->value;
     2787        }
     2788        return -1;
     2789}
     2790EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
    26252791
    26262792/**
    … …  
    26582824        return 0;
    26592825}
     2826EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
    26602827
    26612828#ifdef CONFIG_SND_HDA_POWER_SAVE
    … …  
    27002867        codec->power_transition = 0;
    27012868}
     2869EXPORT_SYMBOL_HDA(snd_hda_power_up);
     2870
     2871#define power_save(codec)       \
     2872        ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
     2873
     2874#define power_save(codec)       \
     2875        ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
    27022876
    27032877void snd_hda_power_down(struct hda_codec *codec)
    … …  
    27062880        if (!codec->power_on || codec->power_count || codec->power_transition)
    27072881                return;
    2708         if (power_save) {
     2882        if (power_save(codec)) {
    27092883                codec->power_transition = 1; /* avoid reentrance */
    2710                 schedule_delayed_work(&codec->power_work,
    2711                                       msecs_to_jiffies(power_save * 1000));
    2712         }
    2713 }
     2884                queue_delayed_work(codec->bus->workq, &codec->power_work,
     2885                                msecs_to_jiffies(power_save(codec) * 1000));
     2886        }
     2887}
     2888EXPORT_SYMBOL_HDA(snd_hda_power_down);
    27142889
    27152890int snd_hda_check_amp_list_power(struct hda_codec *codec,
    … …  
    27482923        return 0;
    27492924}
     2925EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
    27502926#endif
    27512927
    … …  
    27672943        return 0;
    27682944}
     2945EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
    27692946
    27702947int snd_hda_ch_mode_get(struct hda_codec *codec,
    … …  
    27842961        return 0;
    27852962}
     2963EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
    27862964
    27872965int snd_hda_ch_mode_put(struct hda_codec *codec,
    … …  
    28042982        return 1;
    28052983}
     2984EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
    28062985
    28072986/*
    … …  
    28243003        return 0;
    28253004}
     3005EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
    28263006
    28273007int snd_hda_input_mux_put(struct hda_codec *codec,
    … …  
    28453025        return 1;
    28463026}
     3027EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
    28473028
    28483029
    … …  
    28973078        return 0;
    28983079}
     3080EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
    28993081
    29003082int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
    … …  
    29093091        return 0;
    29103092}
     3093EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
    29113094
    29123095/*
    … …  
    29213104        return 0;
    29223105}
     3106EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
    29233107
    29243108/*
    … …  
    29603144                                          SNDRV_PCM_HW_PARAM_CHANNELS, 2);
    29613145}
     3146EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
    29623147
    29633148/*
    … …  
    30183203        return 0;
    30193204}
     3205EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
    30203206
    30213207/*
    … …  
    30443230        return 0;
    30453231}
     3232EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
    30463233
    30473234/*
    … …  
    33293516        return 0;
    33303517}
     3518EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
    33313519
    33323520/* labels for input pins */
    … …  
    33343522        "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
    33353523};
     3524EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
    33363525
    33373526
    … …  
    33613550        return 0;
    33623551}
     3552EXPORT_SYMBOL_HDA(snd_hda_suspend);
    33633553
    33643554/**
    33653555 * snd_hda_resume - resume the codecs
    33663556 * @bus: the HDA bus
    3367  * @state: resume state
    33683557 *
    33693558 * Returns 0 if successful.
    … …  
    33823571        return 0;
    33833572}
    3384 #ifdef CONFIG_SND_HDA_POWER_SAVE
    3385 int snd_hda_codecs_inuse(struct hda_bus *bus)
    3386 {
    3387         struct hda_codec *codec;
    3388 
    3389         list_for_each_entry(codec, &bus->codec_list, list, struct hda_codec) {
    3390                 if (snd_hda_codec_needs_resume(codec))
    3391                         return 1;
    3392         }
    3393         return 0;
    3394 }
    3395 #endif
    3396 #endif
     3573EXPORT_SYMBOL_HDA(snd_hda_resume);
     3574#endif /* CONFIG_PM */
    33973575
    33983576/*
    … …  
    34233601        return snd_array_elem(array, array->used++);
    34243602}
     3603EXPORT_SYMBOL_HDA(snd_array_new);
    34253604
    34263605/* free the given array elements */
    … …  
    34323611        array->list = NULL;
    34333612}
     3613EXPORT_SYMBOL_HDA(snd_array_free);
     3614
     3615/*
     3616 * used by hda_proc.c and hda_eld.c
     3617 */
     3618void snd_print_pcm_rates(int pcm, char *buf, int buflen)
     3619{
     3620        static unsigned int rates[] = {
     3621                8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
     3622                96000, 176400, 192000, 384000
     3623        };
     3624        int i, j;
     3625
     3626        for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
     3627                if (pcm & (1 << i))
     3628                        j += snprintf(buf + j, buflen - j,  " %d", rates[i]);
     3629
     3630        buf[j] = '\0'; /* necessary when j == 0 */
     3631}
     3632EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
     3633
     3634void snd_print_pcm_bits(int pcm, char *buf, int buflen)
     3635{
     3636        static unsigned int bits[] = { 8, 16, 20, 24, 32 };
     3637        int i, j;
     3638
     3639        for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
     3640                if (pcm & (AC_SUPPCM_BITS_8 << i))
     3641                        j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
     3642
     3643        buf[j] = '\0'; /* necessary when j == 0 */
     3644}
     3645EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
     3646
     3647MODULE_DESCRIPTION("HDA codec core");
     3648MODULE_LICENSE("GPL");

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_codec.h

    r402 r410  
    586586        struct pci_dev *pci;
    587587        const char *modelname;
     588        int *power_save;
    588589        struct hda_bus_ops ops;
    589590};
    … …  
    602603        struct pci_dev *pci;
    603604        const char *modelname;
     605        int *power_save;
    604606        struct hda_bus_ops ops;
    605607
    … …  
    617619        /* unsolicited event queue */
    618620        struct hda_bus_unsolicited *unsol;
    619 
    620         struct snd_info_entry *proc;
     621        struct workqueue_struct *workq; /* common workqueue for codecs */
     622
     623        /* assigned PCMs */
     624        DECLARE_BITMAP(pcm_dev_bits, SNDRV_PCM_DEVICES);
    621625
    622626        /* misc op flags */
    623627        unsigned int needs_damn_long_delay :1;
     628        unsigned int shutdown :1;       /* being unloaded */
    624629};
    625630
    … …  
    641646};
    642647       
     648struct hda_codec_preset_list {
     649        const struct hda_codec_preset *preset;
     650        struct module *owner;
     651        struct list_head list;
     652};
     653
     654/* initial hook */
     655int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset);
     656int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset);
     657
    643658/* ops set by the preset patch */
    644659struct hda_codec_ops {
    … …  
    734749        /* detected preset */
    735750        const struct hda_codec_preset *preset;
     751        struct module *owner;
    736752        const char *name;       /* codec name */
    737753        const char *modelname;  /* model name for preset */
    … …  
    765781        struct semaphore spdif_mutex;
    766782#endif
     783        struct mutex control_mutex;
    767784        unsigned int spdif_status;      /* IEC958 status bits */
    768785        unsigned short spdif_ctls;      /* SPDIF control bits */
    … …  
    787804        struct delayed_work power_work; /* delayed task for powerdown */
    788805#endif
     806
     807        /* codec-specific additional proc output */
     808        void (*proc_widget_hook)(struct snd_info_buffer *buffer,
     809                                 struct hda_codec *codec, hda_nid_t nid);
    789810};
    790811
    … …  
    801822                    struct hda_bus **busp);
    802823int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
    803                       struct hda_codec **codecp);
     824                      int do_init, struct hda_codec **codecp);
    804825
    805826/*
    … …  
    852873 */
    853874int snd_hda_build_pcms(struct hda_bus *bus);
     875int snd_hda_codec_build_pcms(struct hda_codec *codec);
    854876void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
    855877                                u32 stream_tag,
    … …  
    860882                                        unsigned int format,
    861883                                        unsigned int maxbps);
    862 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
    863                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp);
    864884int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
    865885                                unsigned int format);
    … …  
    892912void snd_hda_power_down(struct hda_codec *codec);
    893913#define snd_hda_codec_needs_resume(codec) codec->power_count
    894 int snd_hda_codecs_inuse(struct hda_bus *bus);
    895914#else
    896915static inline void snd_hda_power_up(struct hda_codec *codec) {}
    897916static inline void snd_hda_power_down(struct hda_codec *codec) {}
    898917#define snd_hda_codec_needs_resume(codec) 1
    899 #define snd_hda_codecs_inuse(bus) 1
     918#endif
     919
     920/*
     921 * Codec modularization
     922 */
     923
     924/* Export symbols only for communication with codec drivers;
     925 * When built in kernel, all HD-audio drivers are supposed to be statically
     926 * linked to the kernel.  Thus, the symbols don't have to (or shouldn't) be
     927 * exported unless it's built as a module.
     928 */
     929#if defined(MODULE) && !defined(TARGET_OS2)
     930#define EXPORT_SYMBOL_HDA(sym) EXPORT_SYMBOL_GPL(sym)
     931#else
     932#define EXPORT_SYMBOL_HDA(sym)
    900933#endif
    901934

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_generic.c

    r399 r410  
    739739                /*knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT);*/
    740740                knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
    741                 knew.index = index;
     741                knew.index = 0;
    742742                knew.name = name;
    743743                knew.info = snd_hda_mixer_amp_switch_info;
    … …  
    747747                if (is_loopback)
    748748                        add_input_loopback(codec, node->nid, HDA_OUTPUT, 0);
    749                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
     749                snd_printdd("[%s] NID=0x%x, DIR=OUT1\n", name, node->nid);
    750750                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
    751751                if (err < 0)
    … …  
    11381138        return err;
    11391139}
     1140EXPORT_SYMBOL(snd_hda_parse_generic_codec);

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_hwdep.c

    r399 r410  
    117117}
    118118
    119 int __devinit snd_hda_create_hwdep(struct hda_codec *codec)
     119int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec)
    120120{
    121121        char hwname[16];
    … …  
    146146}
    147147
     148#ifdef CONFIG_SND_HDA_RECONFIG
     149
    148150/*
    149151 * sysfs interface
    … …  
    167169                return err;
    168170        /* rebuild PCMs */
    169         err = snd_hda_build_pcms(codec->bus);
     171        err = snd_hda_codec_build_pcms(codec);
    170172        if (err < 0)
    171173                return err;
    … …  
    314316}
    315317
    316 #ifndef TARGET_OS2
    317318#define CODEC_ATTR_RW(type) \
    318319        __ATTR(type, 0644, type##_show, type##_store)
    … …  
    349350        return 0;
    350351}
    351 #endif /* TARGET_OS2 */
     352
     353#endif /* CONFIG_SND_HDA_RECONFIG */

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

    r402 r410  
    5151#include "hda_codec.h"
    5252
     53
    5354static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
    5455static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
    … …  
    6364static int probe_mask[SNDRV_CARDS] = {-1};
    6465#endif
     66static int probe_only[SNDRV_CARDS];
    6567static int single_cmd;
    6668static int enable_msi;
    … …  
    8183module_param_array(probe_mask, int, NULL, 0444);
    8284MODULE_PARM_DESC(probe_mask, "Bitmask to probe codecs (default = -1).");
     85module_param_array(probe_only, bool, NULL, 0444);
     86MODULE_PARM_DESC(probe_only, "Only probing and no codec initialization.");
    8387module_param(single_cmd, bool, 0444);
    8488MODULE_PARM_DESC(single_cmd, "Use single command to communicate with codecs "
    … …  
    8892
    8993#ifdef CONFIG_SND_HDA_POWER_SAVE
    90 /* power_save option is defined in hda_codec.c */
     94static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
     95module_param(power_save, int, 0644);
     96MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
     97                 "(in second, 0 = disable).");
    9198
    9299/* reset the HD-audio controller in power save mode.
    … …  
    297304#define VIA_HDAC_DEVICE_ID              0x3288
    298305
     306/* HD Audio class code */
     307#define PCI_CLASS_MULTIMEDIA_HD_AUDIO   0x0403
    299308
    300309/*
    … …  
    435444        AZX_DRIVER_NVIDIA,
    436445        AZX_DRIVER_TERA,
     446        AZX_DRIVER_GENERIC,
    437447        AZX_NUM_DRIVERS, /* keep this as last entry */
    438448};
    … …  
    448458        [AZX_DRIVER_NVIDIA] = "HDA NVidia",
    449459        [AZX_DRIVER_TERA] = "HDA Teradici",
     460        [AZX_DRIVER_GENERIC] = "HD-Audio Generic",
    450461};
    451462
    … …  
    10121023                                snd_pcm_period_elapsed(azx_dev->substream);
    10131024                                spin_lock(&chip->reg_lock);
    1014                         } else {
     1025                        } else if (chip->bus && chip->bus->workq) {
    10151026                                /* bogus IRQ, process it later */
    10161027                                azx_dev->irq_pending = 1;
    1017 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    1018                                 schedule_work(&chip->irq_pending_work);
    1019 #endif
     1028                                queue_work(chip->bus->workq,
     1029                                           &chip->irq_pending_work);
    10201030                        }
    10211031                }
    … …  
    12551265
    12561266static int __devinit azx_codec_create(struct azx *chip, const char *model,
    1257                                       unsigned int codec_probe_mask)
     1267                                      unsigned int codec_probe_mask,
     1268                                      int no_init)
    12581269{
    12591270        struct hda_bus_template bus_temp;
    … …  
    12691280        bus_temp.ops.attach_pcm = azx_attach_pcm_stream;
    12701281#ifdef CONFIG_SND_HDA_POWER_SAVE
     1282        bus_temp.power_save = &power_save;
    12711283        bus_temp.ops.pm_notify = azx_power_notify;
    12721284#endif
    … …  
    13121324                if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
    13131325                        struct hda_codec *codec;
    1314                         err = snd_hda_codec_new(chip->bus, c, &codec);
     1326                        err = snd_hda_codec_new(chip->bus, c, !no_init, &codec);
    13151327                        if (err < 0)
    13161328                                continue;
    … …  
    17671779                chip->azx_dev[i].irq_pending = 0;
    17681780        spin_unlock_irq(&chip->reg_lock);
    1769         flush_scheduled_work();
    17701781}
    17711782
    … …  
    19381949 * power management
    19391950 */
     1951
     1952static int snd_hda_codecs_inuse(struct hda_bus *bus)
     1953{
     1954        struct hda_codec *codec;
     1955
     1956        list_for_each_entry(codec, &bus->codec_list, list, struct hda_codec) {
     1957                if (snd_hda_codec_needs_resume(codec))
     1958                        return 1;
     1959        }
     1960        return 0;
     1961}
     1962
    19401963static int azx_suspend(struct pci_dev *pci, pm_message_t state)
    19411964{
    … …  
    19631986}
    19641987
     1988#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
     1989static int azx_resume_early(struct pci_dev *pci)
     1990{
     1991        return pci_restore_state(pci);
     1992}
     1993#endif
     1994
    19651995static int azx_resume(struct pci_dev *pci)
    19661996{
    … …  
    19681998        struct azx *chip = card->private_data;
    19691999
    1970         pci_set_power_state(pci, PCI_D0);
     2000#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
    19712001        pci_restore_state(pci);
     2002#endif
     2003
    19722004        if (pci_enable_device(pci) < 0) {
    19732005                printk(KERN_ERR "hda-intel: pci_enable_device failed, "
    … …  
    21102142        SND_PCI_QUIRK(0x17aa, 0x2010, "Thinkpad X/T/R60", 0x01),
    21112143        SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X/T/R61", 0x01),
    2112         /* broken BIOS */
    2113         SND_PCI_QUIRK(0x1028, 0x20ac, "Dell Studio Desktop", 0x01),
     2144        /* broken BIOS */
     2145        SND_PCI_QUIRK(0x1028, 0x20ac, "Dell Studio Desktop", 0x01),
     2146        /* including bogus ALC268 in slot#2 that conflicts with ALC888 */
     2147        SND_PCI_QUIRK(0x17c0, 0x4085, "Medion MD96630", 0x01),
    21142148        {0}
    21152149};
    … …  
    22462280                        chip->capture_streams = ATIHDMI_NUM_CAPTURE;
    22472281                        break;
     2282                case AZX_DRIVER_GENERIC:
    22482283                default:
    22492284                        chip->playback_streams = ICH6_NUM_PLAYBACK;
    … …  
    23482383        }
    23492384
    2350         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    2351         if (!card) {
     2385        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     2386        if (err < 0) {
    23522387                snd_printk(KERN_ERR SFX "Error creating card!\n");
    2353                 return -ENOMEM;
     2388                return err;
    23542389        }
    23552390
    23562391        err = azx_create(card, pci, dev, pci_id->driver_data, &chip);
    2357         if (err < 0) {
    2358                 snd_card_free(card);
    2359                 return err;
    2360         }
     2392        if (err < 0)
     2393                goto out_free;
    23612394        card->private_data = chip;
    23622395
    23632396        /* create codec instances */
    2364         err = azx_codec_create(chip, model[dev], probe_mask[dev]);
    2365         if (err < 0) {
    2366                 snd_card_free(card);
    2367                 return err;
    2368         }
     2397        err = azx_codec_create(chip, model[dev], probe_mask[dev],
     2398                               probe_only[dev]);
     2399        if (err < 0)
     2400                goto out_free;
    23692401
    23702402        /* create PCM streams */
    23712403        err = snd_hda_build_pcms(chip->bus);
    2372         if (err < 0) {
    2373                 snd_card_free(card);
    2374                 return err;
    2375         }
     2404        if (err < 0)
     2405                goto out_free;
    23762406
    23772407        /* create mixer controls */
    23782408        err = azx_mixer_create(chip);
    2379         if (err < 0) {
    2380                 snd_card_free(card);
    2381                 return err;
    2382         }
     2409        if (err < 0)
     2410                goto out_free;
    23832411
    23842412        snd_card_set_dev(card, &pci->dev);
    23852413
    23862414        err = snd_card_register(card);
    2387         if (err < 0) {
    2388                 snd_card_free(card);
    2389                 return err;
    2390         }
     2415        if (err < 0)
     2416                goto out_free;
    23912417
    23922418        pci_set_drvdata(pci, card);
    … …  
    23962422
    23972423        dev++;
     2424        return err;
     2425out_free:
     2426        snd_card_free(card);
    23982427        return err;
    23992428}
    … …  
    24702499        /* Teradici */
    24712500        { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },
     2501        /* AMD Generic, PCI class code and Vendor ID for HD Audio */
     2502        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_ANY_ID),
     2503          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
     2504          .class_mask = 0xffffff,
     2505          .driver_data = AZX_DRIVER_GENERIC },
    24722506        { 0, }
    24732507};
    … …  
    24822516#ifdef CONFIG_PM
    24832517        .suspend = azx_suspend,
     2518#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
     2519        .resume_early = azx_resume_early,
     2520#endif
    24842521        .resume = azx_resume,
    24852522#endif

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

    r402 r410  
    289289#endif
    290290
     291#define SND_PRINT_RATES_ADVISED_BUFSIZE 80
     292void snd_print_pcm_rates(int pcm, char *buf, int buflen);
     293
     294#define SND_PRINT_BITS_ADVISED_BUFSIZE  16
     295void snd_print_pcm_bits(int pcm, char *buf, int buflen);
     296
    291297/*
    292298 * Misc
    … …  
    295301                               const char **modelnames,
    296302                               const struct snd_pci_quirk *pci_list);
     303int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
     304                               int num_configs, const char **models,
     305                               const struct snd_pci_quirk *tbl);
    297306int snd_hda_add_new_ctls(struct hda_codec *codec,
    298307                         struct snd_kcontrol_new *knew);
    … …  
    408417#ifdef CONFIG_SND_HDA_HWDEP
    409418int snd_hda_create_hwdep(struct hda_codec *codec);
     419#else
     420static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; }
     421#endif
     422
     423#ifdef CONFIG_SND_HDA_RECONFIG
    410424int snd_hda_hwdep_add_sysfs(struct hda_codec *codec);
    411425#else
    412 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; }
     426static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec)
     427{
     428        return 0;
     429}
    413430#endif
    414431
    … …  
    445462#define get_amp_index(kc)       (((kc)->private_value >> 19) & 0xf)
    446463
     464/*
     465 * CEA Short Audio Descriptor data
     466 */
     467struct cea_sad {
     468        int     channels;
     469        int     format;         /* (format == 0) indicates invalid SAD */
     470        int     rates;
     471        int     sample_bits;    /* for LPCM */
     472        int     max_bitrate;    /* for AC3...ATRAC */
     473        int     profile;        /* for WMAPRO */
     474};
     475
     476#define ELD_FIXED_BYTES 20
     477#define ELD_MAX_MNL     16
     478#define ELD_MAX_SAD     16
     479
     480/*
     481 * ELD: EDID Like Data
     482 */
     483struct hdmi_eld {
     484        int     eld_size;
     485        int     baseline_len;
     486        int     eld_ver;        /* (eld_ver == 0) indicates invalid ELD */
     487        int     cea_edid_ver;
     488        char    monitor_name[ELD_MAX_MNL + 1];
     489        int     manufacture_id;
     490        int     product_id;
     491        u64     port_id;
     492        int     support_hdcp;
     493        int     support_ai;
     494        int     conn_type;
     495        int     aud_synch_delay;
     496        int     spk_alloc;
     497        int     sad_count;
     498        struct cea_sad sad[ELD_MAX_SAD];
     499#ifdef CONFIG_PROC_FS
     500        struct snd_info_entry *proc_entry;
     501#endif
     502};
     503
     504int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
     505int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
     506void snd_hdmi_show_eld(struct hdmi_eld *eld);
     507
     508#ifdef CONFIG_PROC_FS
     509int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld);
     510void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld);
     511#else
     512static inline int snd_hda_eld_proc_new(struct hda_codec *codec,
     513                                       struct hdmi_eld *eld)
     514{
     515        return 0;
     516}
     517static inline void snd_hda_eld_proc_free(struct hda_codec *codec,
     518                                         struct hdmi_eld *eld)
     519{
     520}
     521#endif
     522
     523#define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80
     524void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
     525
    447526#endif /* __SOUND_HDA_LOCAL_H */

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_proc.c

    r402 r410  
    9292static void print_pcm_rates(struct snd_info_buffer *buffer, unsigned int pcm)
    9393{
    94         static unsigned int rates[] = {
    95                 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
    96                 96000, 176400, 192000, 384000
    97         };
    98         int i;
     94        char buf[SND_PRINT_RATES_ADVISED_BUFSIZE];
    9995
    10096        pcm &= AC_SUPPCM_RATES;
    10197        snd_iprintf(buffer, "    rates [0x%x]:", pcm);
    102         for (i = 0; i < ARRAY_SIZE(rates); i++)
    103                 if (pcm & (1 << i))
    104                         snd_iprintf(buffer, " %d", rates[i]);
    105         snd_iprintf(buffer, "\n");
     98        snd_print_pcm_rates(pcm, buf, sizeof(buf));
     99        snd_iprintf(buffer, "%s\n", buf);
    106100}
    107101
    108102static void print_pcm_bits(struct snd_info_buffer *buffer, unsigned int pcm)
    109103{
    110         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
    111         int i;
    112 
    113         pcm = (pcm >> 16) & 0xff;
    114         snd_iprintf(buffer, "    bits [0x%x]:", pcm);
    115         for (i = 0; i < ARRAY_SIZE(bits); i++)
    116                 if (pcm & (1 << i))
    117                         snd_iprintf(buffer, " %d", bits[i]);
    118         snd_iprintf(buffer, "\n");
     104        char buf[SND_PRINT_BITS_ADVISED_BUFSIZE];
     105
     106        snd_iprintf(buffer, "    bits [0x%x]:", (pcm >> 16) & 0xff);
     107        snd_print_pcm_bits(pcm, buf, sizeof(buf));
     108        snd_iprintf(buffer, "%s\n", buf);
    119109}
    120110
    … …  
    425415}
    426416
    427 static void print_realtek_coef(struct snd_info_buffer *buffer,
    428                                struct hda_codec *codec, hda_nid_t nid)
    429 {
    430         int coeff = snd_hda_codec_read(codec, nid, 0,
    431                                        AC_VERB_GET_PROC_COEF, 0);
    432         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
    433         coeff = snd_hda_codec_read(codec, nid, 0,
    434                                    AC_VERB_GET_COEF_INDEX, 0);
    435         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
    436 }
    437 
    438417static void print_gpio(struct snd_info_buffer *buffer,
    439418                       struct hda_codec *codec, hda_nid_t nid)
    … …  
    468447                snd_iprintf(buffer,
    469448                            "  IO[%d]: enable=%d, dir=%d, wake=%d, "
    470                             "sticky=%d, data=%d\n", i,
     449                            "sticky=%d, data=%d, unsol=%d\n", i,
    471450                            (enable & (1<<i)) ? 1 : 0,
    472451                            (direction & (1<<i)) ? 1 : 0,
    473452                            (wake & (1<<i)) ? 1 : 0,
    474453                            (sticky & (1<<i)) ? 1 : 0,
    475                             (data & (1<<i)) ? 1 : 0);
     454                            (data & (1<<i)) ? 1 : 0,
     455                            (unsol & (1<<i)) ? 1 : 0);
    476456        /* FIXME: add GPO and GPI pin information */
    477457}
    … …  
    514494
    515495        print_gpio(buffer, codec, codec->afg);
     496        if (codec->proc_widget_hook)
     497                codec->proc_widget_hook(buffer, codec, codec->afg);
    516498
    517499        for (i = 0; i < nodes; i++, nid++) {
    … …  
    616598                        print_proc_caps(buffer, codec, nid);
    617599
    618                 /* NID 0x20 == Realtek Define Registers */
    619                 if (codec->vendor_id == 0x10ec && nid == 0x20)
    620                         print_realtek_coef(buffer, codec, nid);
     600                if (codec->proc_widget_hook)
     601                        codec->proc_widget_hook(buffer, codec, nid);
    621602        }
    622603        snd_hda_power_down(codec);

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

    r402 r410  
    2828#include "hda_codec.h"
    2929#include "hda_local.h"
    30 #include "hda_patch.h"
    3130
    3231struct ad198x_spec {
    … …  
    639638
    640639static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
     640        HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
     641        HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
     642        HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
     643        HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
     644        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
     645        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
     646        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
     647        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
     648        HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
     649        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
     650        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
     651        {
     652                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     653                .name = "Capture Source",
     654                .info = ad198x_mux_enum_info,
     655                .get = ad198x_mux_enum_get,
     656                .put = ad198x_mux_enum_put,
     657        },
     658        {
     659                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     660                .name = "External Amplifier",
     661                .info = ad198x_eapd_info,
     662                .get = ad198x_eapd_get,
     663                .put = ad198x_eapd_put,
     664                .private_value = 0x1b | (1 << 8), /* port-D, inversed */
     665        },
     666        {0} /* end */
     667};
     668
     669static struct snd_kcontrol_new ad1986a_samsung_mixers[] = {
    641670        HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
    642671        HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
    … …  
    931960        AD1986A_LAPTOP_AUTOMUTE,
    932961        AD1986A_ULTRA,
     962        AD1986A_SAMSUNG,
    933963        AD1986A_MODELS
    934964};
    … …  
    941971        [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
    942972        [AD1986A_ULTRA]         = "ultra",
     973        [AD1986A_SAMSUNG]       = "samsung",
    943974};
    944975
    … …  
    963994        SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
    964995        SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
    965         SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
    966         SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
    967         SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
     996        SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_SAMSUNG),
     997        SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_SAMSUNG),
     998        SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_SAMSUNG),
    968999        SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
    9691000        SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
    … …  
    10471078        case AD1986A_LAPTOP_EAPD:
    10481079                spec->mixers[0] = ad1986a_laptop_eapd_mixers;
     1080                spec->num_init_verbs = 2;
     1081                spec->init_verbs[1] = ad1986a_eapd_init_verbs;
     1082                spec->multiout.max_channels = 2;
     1083                spec->multiout.num_dacs = 1;
     1084                spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
     1085                if (!is_jack_available(codec, 0x25))
     1086                        spec->multiout.dig_out_nid = 0;
     1087                spec->input_mux = &ad1986a_laptop_eapd_capture_source;
     1088                break;
     1089        case AD1986A_SAMSUNG:
     1090                spec->mixers[0] = ad1986a_samsung_mixers;
    10491091                spec->num_init_verbs = 3;
    10501092                spec->init_verbs[1] = ad1986a_eapd_init_verbs;
    … …  
    38593901static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
    38603902        SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
     3903        SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
    38613904        SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
     3905        SND_PCI_QUIRK(0x103c, 0x30e6, "HP 6730b", AD1884A_LAPTOP),
    38623906        SND_PCI_QUIRK(0x103c, 0x30e7, "HP EliteBook 8530p", AD1884A_LAPTOP),
    38633907        SND_PCI_QUIRK(0x103c, 0x3614, "HP 6730s", AD1884A_LAPTOP),
    … …  
    42204264        spec->adc_nids = ad1882_adc_nids;
    42214265        spec->capsrc_nids = ad1882_capsrc_nids;
    4222         if (codec->vendor_id == 0x11d1882)
     4266        if (codec->vendor_id == 0x11d41882)
    42234267                spec->input_mux = &ad1882_capture_source;
    42244268        else
    … …  
    42264270        spec->num_mixers = 2;
    42274271        spec->mixers[0] = ad1882_base_mixers;
    4228         if (codec->vendor_id == 0x11d1882)
     4272        if (codec->vendor_id == 0x11d41882)
    42294273                spec->mixers[1] = ad1882_loopback_mixers;
    42304274        else
    … …  
    42664310 * patch entries
    42674311 */
    4268 struct hda_codec_preset snd_hda_preset_analog[] = {
     4312static struct hda_codec_preset snd_hda_preset_analog[] = {
    42694313        { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
    42704314        { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
    … …  
    42844328        {0} /* terminator */
    42854329};
     4330
     4331MODULE_ALIAS("snd-hda-codec-id:11d4*");
     4332
     4333MODULE_LICENSE("GPL");
     4334MODULE_DESCRIPTION("Analog Devices HD-audio codec");
     4335
     4336static struct hda_codec_preset_list analog_list = {
     4337        .preset = snd_hda_preset_analog,
     4338        .owner = THIS_MODULE,
     4339};
     4340
     4341static int __init patch_analog_init(void)
     4342{
     4343        return snd_hda_add_codec_preset(&analog_list);
     4344}
     4345
     4346static void __exit patch_analog_exit(void)
     4347{
     4348        snd_hda_delete_codec_preset(&analog_list);
     4349}
     4350
     4351module_init(patch_analog_init)
     4352module_exit(patch_analog_exit)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_atihdmi.c

    r399 r410  
    2828#include "hda_codec.h"
    2929#include "hda_local.h"
    30 #include "hda_patch.h"
    3130
    3231struct atihdmi_spec {
    … …  
    188187 * patch entries
    189188 */
    190 struct hda_codec_preset snd_hda_preset_atihdmi[] = {
    191         { .id = 0x1002793c, .name = "ATI RS600 HDMI", .patch = patch_atihdmi },
    192         { .id = 0x10027919, .name = "ATI RS600 HDMI", .patch = patch_atihdmi },
    193         { .id = 0x1002791a, .name = "ATI RS690/780 HDMI", .patch = patch_atihdmi },
    194         { .id = 0x1002aa01, .name = "ATI R6xx HDMI", .patch = patch_atihdmi },
     189static struct hda_codec_preset snd_hda_preset_atihdmi[] = {
     190        { .id = 0x1002793c, .name = "RS600 HDMI", .patch = patch_atihdmi },
     191        { .id = 0x10027919, .name = "RS600 HDMI", .patch = patch_atihdmi },
     192        { .id = 0x1002791a, .name = "RS690/780 HDMI", .patch = patch_atihdmi },
     193        { .id = 0x1002aa01, .name = "R6xx HDMI", .patch = patch_atihdmi },
    195194        { .id = 0x10951390, .name = "SiI1390 HDMI", .patch = patch_atihdmi },
    196         { .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_atihdmi },
    197195        { .id = 0x17e80047, .name = "Chrontel HDMI",  .patch = patch_atihdmi },
    198196        {0} /* terminator */
    199197};
     198
     199MODULE_ALIAS("snd-hda-codec-id:1002793c");
     200MODULE_ALIAS("snd-hda-codec-id:10027919");
     201MODULE_ALIAS("snd-hda-codec-id:1002791a");
     202MODULE_ALIAS("snd-hda-codec-id:1002aa01");
     203MODULE_ALIAS("snd-hda-codec-id:10951390");
     204MODULE_ALIAS("snd-hda-codec-id:17e80047");
     205
     206MODULE_LICENSE("GPL");
     207MODULE_DESCRIPTION("ATI HDMI HD-audio codec");
     208
     209static struct hda_codec_preset_list atihdmi_list = {
     210        .preset = snd_hda_preset_atihdmi,
     211        .owner = THIS_MODULE,
     212};
     213
     214static int __init patch_atihdmi_init(void)
     215{
     216        return snd_hda_add_codec_preset(&atihdmi_list);
     217}
     218
     219static void __exit patch_atihdmi_exit(void)
     220{
     221        snd_hda_delete_codec_preset(&atihdmi_list);
     222}
     223
     224module_init(patch_atihdmi_init)
     225module_exit(patch_atihdmi_exit)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_cmedia.c

    r399 r410  
    2929#include "hda_codec.h"
    3030#include "hda_local.h"
    31 #include "hda_patch.h"
    3231#define NUM_PINS        11
    3332
    … …  
    737736 * patch entries
    738737 */
    739 struct hda_codec_preset snd_hda_preset_cmedia[] = {
     738static struct hda_codec_preset snd_hda_preset_cmedia[] = {
    740739        { .id = 0x13f69880, .name = "CMI9880", .patch = patch_cmi9880 },
    741740        { .id = 0x434d4980, .name = "CMI9880", .patch = patch_cmi9880 },
    742741        {0} /* terminator */
    743742};
     743
     744MODULE_ALIAS("snd-hda-codec-id:13f69880");
     745MODULE_ALIAS("snd-hda-codec-id:434d4980");
     746
     747MODULE_LICENSE("GPL");
     748MODULE_DESCRIPTION("C-Media HD-audio codec");
     749
     750static struct hda_codec_preset_list cmedia_list = {
     751        .preset = snd_hda_preset_cmedia,
     752        .owner = THIS_MODULE,
     753};
     754
     755static int __init patch_cmedia_init(void)
     756{
     757        return snd_hda_add_codec_preset(&cmedia_list);
     758}
     759
     760static void __exit patch_cmedia_exit(void)
     761{
     762        snd_hda_delete_codec_preset(&cmedia_list);
     763}
     764
     765module_init(patch_cmedia_init)
     766module_exit(patch_cmedia_exit)

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

    r399 r410  
    2626#include <linux/pci.h>
    2727#include <sound/core.h>
     28#include <sound/jack.h>
     29
    2830#include "hda_codec.h"
    2931#include "hda_local.h"
    30 #include "hda_patch.h"
    3132
    3233#define CXT_PIN_DIR_IN              0x00
    … …  
    3940#define CONEXANT_MIC_EVENT      0x38
    4041
    41 
     42/* Conexant 5051 specific */
     43
     44#define CXT5051_SPDIF_OUT       0x1C
     45#define CXT5051_PORTB_EVENT     0x38
     46#define CXT5051_PORTC_EVENT     0x39
     47
     48
     49struct conexant_jack {
     50
     51        hda_nid_t nid;
     52        int type;
     53        struct snd_jack *jack;
     54
     55};
    4256
    4357struct conexant_spec {
    … …  
    8498
    8599        unsigned int spdif_route;
     100
     101        /* jack detection */
     102        struct snd_array jacks;
    86103
    87104        /* dynamic controls, init_verbs and input_mux */
    … …  
    331348}
    332349
     350static int conexant_add_jack(struct hda_codec *codec,
     351                hda_nid_t nid, int type)
     352{
     353        struct conexant_spec *spec;
     354        struct conexant_jack *jack;
     355        const char *name;
     356
     357        spec = codec->spec;
     358        snd_array_init(&spec->jacks, sizeof(*jack), 32);
     359        jack = snd_array_new(&spec->jacks);
     360        name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
     361
     362        if (!jack)
     363                return -ENOMEM;
     364
     365        jack->nid = nid;
     366        jack->type = type;
     367
     368        return snd_jack_new(codec->bus->card, name, type, &jack->jack);
     369}
     370
     371static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
     372{
     373        struct conexant_spec *spec = codec->spec;
     374        struct conexant_jack *jacks = spec->jacks.list;
     375
     376        if (jacks) {
     377                int i;
     378                for (i = 0; i < spec->jacks.used; i++) {
     379                        if (jacks->nid == nid) {
     380                                unsigned int present;
     381                                present = snd_hda_codec_read(codec, nid, 0,
     382                                                AC_VERB_GET_PIN_SENSE, 0) &
     383                                        AC_PINSENSE_PRESENCE;
     384
     385                                present = (present) ? jacks->type : 0 ;
     386
     387                                snd_jack_report(jacks->jack,
     388                                                present);
     389                        }
     390                        jacks++;
     391                }
     392        }
     393}
     394
     395static int conexant_init_jacks(struct hda_codec *codec)
     396{
     397#ifdef CONFIG_SND_JACK
     398        struct conexant_spec *spec = codec->spec;
     399        int i;
     400
     401        for (i = 0; i < spec->num_init_verbs; i++) {
     402                const struct hda_verb *hv;
     403
     404                hv = spec->init_verbs[i];
     405                while (hv->nid) {
     406                        int err = 0;
     407                        switch (hv->param ^ AC_USRSP_EN) {
     408                        case CONEXANT_HP_EVENT:
     409                                err = conexant_add_jack(codec, hv->nid,
     410                                                SND_JACK_HEADPHONE);
     411                                conexant_report_jack(codec, hv->nid);
     412                                break;
     413                        case CXT5051_PORTC_EVENT:
     414                        case CONEXANT_MIC_EVENT:
     415                                err = conexant_add_jack(codec, hv->nid,
     416                                                SND_JACK_MICROPHONE);
     417                                conexant_report_jack(codec, hv->nid);
     418                                break;
     419                        }
     420                        if (err < 0)
     421                                return err;
     422                        ++hv;
     423                }
     424        }
     425#endif
     426        return 0;
     427
     428}
     429
    333430static int conexant_init(struct hda_codec *codec)
    334431{
    … …  
    343440static void conexant_free(struct hda_codec *codec)
    344441{
     442#ifdef CONFIG_SND_JACK
     443        struct conexant_spec *spec = codec->spec;
     444        if (spec->jacks.list) {
     445                struct conexant_jack *jacks = spec->jacks.list;
     446                int i;
     447                for (i = 0; i < spec->jacks.used; i++)
     448                        snd_device_free(codec->bus->card, &jacks[i].jack);
     449                snd_array_free(&spec->jacks);
     450        }
     451#endif
    345452        kfree(codec->spec);
    346453}
    … …  
    15281635static hda_nid_t cxt5051_dac_nids[1] = { 0x10 };
    15291636static hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 };
    1530 #define CXT5051_SPDIF_OUT       0x1C
    1531 #define CXT5051_PORTB_EVENT     0x38
    1532 #define CXT5051_PORTC_EVENT     0x39
    15331637
    15341638static struct hda_channel_mode cxt5051_modes[1] = {
    … …  
    16101714                                   unsigned int res)
    16111715{
     1716        int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20;
    16121717        switch (res >> 26) {
    16131718        case CONEXANT_HP_EVENT:
    … …  
    16211726                break;
    16221727        }
     1728        conexant_report_jack(codec, nid);
    16231729}
    16241730
    … …  
    16951801{
    16961802        conexant_init(codec);
     1803        conexant_init_jacks(codec);
    16971804        if (codec->patch_ops.unsol_event) {
    16981805                cxt5051_hp_automute(codec);
    … …  
    17721879 */
    17731880
    1774 struct hda_codec_preset snd_hda_preset_conexant[] = {
     1881static struct hda_codec_preset snd_hda_preset_conexant[] = {
    17751882        { .id = 0x14f15045, .name = "CX20549 (Venice)",
    17761883          .patch = patch_cxt5045 },
    … …  
    17811888        {0} /* terminator */
    17821889};
     1890
     1891MODULE_ALIAS("snd-hda-codec-id:14f15045");
     1892MODULE_ALIAS("snd-hda-codec-id:14f15047");
     1893MODULE_ALIAS("snd-hda-codec-id:14f15051");
     1894
     1895MODULE_LICENSE("GPL");
     1896MODULE_DESCRIPTION("Conexant HD-audio codec");
     1897
     1898static struct hda_codec_preset_list conexant_list = {
     1899        .preset = snd_hda_preset_conexant,
     1900        .owner = THIS_MODULE,
     1901};
     1902
     1903static int __init patch_conexant_init(void)
     1904{
     1905        return snd_hda_add_codec_preset(&conexant_list);
     1906}
     1907
     1908static void __exit patch_conexant_exit(void)
     1909{
     1910        snd_hda_delete_codec_preset(&conexant_list);
     1911}
     1912
     1913module_init(patch_conexant_init)
     1914module_exit(patch_conexant_exit)

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

    r402 r410  
    3131#include "hda_codec.h"
    3232#include "hda_local.h"
    33 #include "hda_patch.h"
    3433
    3534#define ALC880_FRONT_EVENT              0x01
    … …  
    217216        ALC883_ACER,
    218217        ALC883_ACER_ASPIRE,
     218        ALC888_ACER_ASPIRE_4930G,
    219219        ALC883_MEDION,
    220220        ALC883_MEDION_MD2,
    … …  
    230230        ALC883_CLEVO_M720,
    231231        ALC883_FUJITSU_PI2515,
     232        ALC888_FUJITSU_XA3530,
    232233        ALC883_3ST_6ch_INTEL,
    233234        ALC888_ASUS_M90V,
    234235        ALC888_ASUS_EEE1601,
     236        ALC1200_ASUS_P5Q,
    235237        ALC883_AUTO,
    236238        ALC883_MODEL_LAST,
    … …  
    382384        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    383385        struct alc_spec *spec = codec->spec;
    384         const struct hda_input_mux *imux = spec->input_mux;
     386        const struct hda_input_mux *imux;
    385387        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
     388        unsigned int mux_idx;
    386389        hda_nid_t nid = spec->capsrc_nids ?
    387390                spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
     391
     392        mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
     393        imux = &spec->input_mux[mux_idx];
    388394
    389395        if (spec->is_mix_capture) {
    … …  
    407413        } else {
    408414                /* MUX style (e.g. ALC880) */
    409                 unsigned int mux_idx;
    410                 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
    411                 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx],
    412                                              ucontrol, nid,
     415                return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
    413416                                             &spec->cur_mux[adc_idx]);
    414417        }
    … …  
    762765        spec->init_verbs[spec->num_init_verbs++] = verb;
    763766}
     767
     768#ifdef CONFIG_PROC_FS
     769/*
     770 * hook for proc
     771 */
     772static void print_realtek_coef(struct snd_info_buffer *buffer,
     773                               struct hda_codec *codec, hda_nid_t nid)
     774{
     775        int coeff;
     776
     777        if (nid != 0x20)
     778                return;
     779        coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
     780        snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
     781        coeff = snd_hda_codec_read(codec, nid, 0,
     782                                   AC_VERB_GET_COEF_INDEX, 0);
     783        snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
     784}
     785#else
     786#define print_realtek_coef      NULL
     787#endif
    764788
    765789/*
    … …  
    11541178
    11551179/*
     1180 * ALC888
     1181 */
     1182
     1183/*
     1184 * 2ch mode
     1185 */
     1186static struct hda_verb alc888_4ST_ch2_intel_init[] = {
     1187/* Mic-in jack as mic in */
     1188        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
     1189        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
     1190/* Line-in jack as Line in */
     1191        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
     1192        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
     1193/* Line-Out as Front */
     1194        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
     1195        {0} /* end */
     1196};
     1197
     1198/*
     1199 * 4ch mode
     1200 */
     1201static struct hda_verb alc888_4ST_ch4_intel_init[] = {
     1202/* Mic-in jack as mic in */
     1203        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
     1204        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
     1205/* Line-in jack as Surround */
     1206        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
     1207        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
     1208/* Line-Out as Front */
     1209        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
     1210        {0} /* end */
     1211};
     1212
     1213/*
     1214 * 6ch mode
     1215 */
     1216static struct hda_verb alc888_4ST_ch6_intel_init[] = {
     1217/* Mic-in jack as CLFE */
     1218        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
     1219        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
     1220/* Line-in jack as Surround */
     1221        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
     1222        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
     1223/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
     1224        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
     1225        {0} /* end */
     1226};
     1227
     1228/*
     1229 * 8ch mode
     1230 */
     1231static struct hda_verb alc888_4ST_ch8_intel_init[] = {
     1232/* Mic-in jack as CLFE */
     1233        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
     1234        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
     1235/* Line-in jack as Surround */
     1236        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
     1237        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
     1238/* Line-Out as Side */
     1239        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
     1240        {0} /* end */
     1241};
     1242
     1243static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
     1244        { 2, alc888_4ST_ch2_intel_init },
     1245        { 4, alc888_4ST_ch4_intel_init },
     1246        { 6, alc888_4ST_ch6_intel_init },
     1247        { 8, alc888_4ST_ch8_intel_init },
     1248};
     1249
     1250/*
     1251 * ALC888 Fujitsu Siemens Amillo xa3530
     1252 */
     1253
     1254static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
     1255/* Front Mic: set to PIN_IN (empty by default) */
     1256        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
     1257/* Connect Internal HP to Front */
     1258        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1259        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1260        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
     1261/* Connect Bass HP to Front */
     1262        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1263        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1264        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
     1265/* Connect Line-Out side jack (SPDIF) to Side */
     1266        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1267        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1268        {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
     1269/* Connect Mic jack to CLFE */
     1270        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1271        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1272        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
     1273/* Connect Line-in jack to Surround */
     1274        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1275        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1276        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
     1277/* Connect HP out jack to Front */
     1278        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1279        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1280        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
     1281/* Enable unsolicited event for HP jack and Line-out jack */
     1282        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
     1283        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
     1284        {0}
     1285};
     1286
     1287static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
     1288{
     1289        unsigned int present;
     1290        unsigned int bits;
     1291        /* Line out presence */
     1292        present = snd_hda_codec_read(codec, 0x17, 0,
     1293                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     1294        /* HP out presence */
     1295        present = present || snd_hda_codec_read(codec, 0x1b, 0,
     1296                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     1297        bits = present ? HDA_AMP_MUTE : 0;
     1298        /* Toggle internal speakers muting */
     1299        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
     1300                                 HDA_AMP_MUTE, bits);
     1301        /* Toggle internal bass muting */
     1302        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
     1303                                 HDA_AMP_MUTE, bits);
     1304}
     1305
     1306static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
     1307                unsigned int res)
     1308{
     1309        if (res >> 26 == ALC880_HP_EVENT)
     1310                alc888_fujitsu_xa3530_automute(codec);
     1311}
     1312
     1313
     1314/*
     1315 * ALC888 Acer Aspire 4930G model
     1316 */
     1317
     1318static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
     1319/* Front Mic: set to PIN_IN (empty by default) */
     1320        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
     1321/* Unselect Front Mic by default in input mixer 3 */
     1322        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
     1323/* Enable unsolicited event for HP jack */
     1324        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
     1325/* Connect Internal HP to front */
     1326        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1327        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1328        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
     1329/* Connect HP out to front */
     1330        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
     1331        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     1332        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
     1333        {0}
     1334};
     1335
     1336static struct hda_input_mux alc888_2_capture_sources[2] = {
     1337        /* Front mic only available on one ADC */
     1338        {
     1339                .num_items = 4,
     1340                .items = {
     1341                        { "Mic", 0x0 },
     1342                        { "Line", 0x2 },
     1343                        { "CD", 0x4 },
     1344                        { "Front Mic", 0xb },
     1345                },
     1346        },
     1347        {
     1348                .num_items = 3,
     1349                .items = {
     1350                        { "Mic", 0x0 },
     1351                        { "Line", 0x2 },
     1352                        { "CD", 0x4 },
     1353                },
     1354        }
     1355};
     1356
     1357static struct snd_kcontrol_new alc888_base_mixer[] = {
     1358        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
     1359        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
     1360        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
     1361        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
     1362        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
     1363                HDA_OUTPUT),
     1364        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
     1365        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
     1366        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
     1367        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
     1368        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
     1369        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
     1370        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
     1371        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
     1372        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
     1373        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
     1374        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
     1375        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
     1376        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
     1377        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
     1378        {0} /* end */
     1379};
     1380
     1381static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
     1382{
     1383        unsigned int present;
     1384        unsigned int bits;
     1385        present = snd_hda_codec_read(codec, 0x15, 0,
     1386                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     1387        bits = present ? HDA_AMP_MUTE : 0;
     1388        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
     1389                                 HDA_AMP_MUTE, bits);
     1390}
     1391
     1392static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
     1393                unsigned int res)
     1394{
     1395        if (res >> 26 == ALC880_HP_EVENT)
     1396                alc888_acer_aspire_4930g_automute(codec);
     1397}
     1398
     1399/*
    11561400 * ALC880 3-stack model
    11571401 *
    … …  
    12581502        int err;
    12591503
    1260         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1504        mutex_lock(&codec->control_mutex);
    12611505        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
    12621506                                                      HDA_INPUT);
    12631507        err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
    1264         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1508        mutex_unlock(&codec->control_mutex);
    12651509        return err;
    12661510}
    … …  
    12731517        int err;
    12741518
    1275         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1519        mutex_lock(&codec->control_mutex);
    12761520        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
    12771521                                                      HDA_INPUT);
    12781522        err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
    1279         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1523        mutex_unlock(&codec->control_mutex);
    12801524        return err;
    12811525}
    … …  
    12931537        int err;
    12941538
    1295         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1539        mutex_lock(&codec->control_mutex);
    12961540        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
    12971541                                                      3, 0, HDA_INPUT);
    12981542        err = func(kcontrol, ucontrol);
    1299         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1543        mutex_unlock(&codec->control_mutex);
    13001544        return err;
    13011545}
    … …  
    40464290                alc_capture_mixer3,
    40474291        };
    4048         if (spec->num_adc_nids > 0 && spec->num_adc_nids < 3)
     4292        if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
    40494293                spec->cap_mixer = caps[spec->num_adc_nids - 1];
    40504294}
    … …  
    41214365                spec->loopback.amplist = alc880_loopbacks;
    41224366#endif
     4367        codec->proc_widget_hook = print_realtek_coef;
    41234368
    41244369        return 0;
    … …  
    56465891                spec->loopback.amplist = alc260_loopbacks;
    56475892#endif
     5893        codec->proc_widget_hook = print_realtek_coef;
    56485894
    56495895        return 0;
    … …  
    68517097                spec->loopback.amplist = alc882_loopbacks;
    68527098#endif
     7099        codec->proc_widget_hook = print_realtek_coef;
    68537100
    68547101        return 0;
    … …  
    68697116#define ALC883_DIGIN_NID        0x0a
    68707117
     7118#define ALC1200_DIGOUT_NID      0x10
     7119
    68717120static hda_nid_t alc883_dac_nids[4] = {
    68727121        /* front, rear, clfe, rear_surr */
    … …  
    68847133};
    68857134
     7135static hda_nid_t alc883_adc_nids_rev[2] = {
     7136        /* ADC2-1 */
     7137        0x09, 0x08
     7138};
     7139
    68867140static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
     7141
     7142static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
    68877143
    68887144/* input MUX */
    … …  
    81778433        [ALC883_ACER]           = "acer",
    81788434        [ALC883_ACER_ASPIRE]    = "acer-aspire",
     8435        [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
    81798436        [ALC883_MEDION]         = "medion",
    81808437        [ALC883_MEDION_MD2]     = "medion-md2",
    … …  
    81908447        [ALC883_CLEVO_M720]     = "clevo-m720",
    81918448        [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
     8449        [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
    81928450        [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
     8451        [ALC1200_ASUS_P5Q]      = "asus-p5q",
    81938452        [ALC883_AUTO]           = "auto",
    81948453};
    … …  
    82018460        SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
    82028461        SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
     8462        SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
     8463                ALC888_ACER_ASPIRE_4930G),
     8464        SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
     8465                ALC888_ACER_ASPIRE_4930G),
     8466        SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
     8467                ALC888_ACER_ASPIRE_4930G),
    82038468        SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
    82048469        SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
    … …  
    82078472        SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
    82088473        SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
     8474        SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
    82098475        SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
    82108476        SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
     8477        SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
    82118478        SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
    82128479        SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
    82138480        SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
     8481        SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
    82148482        SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
    82158483        SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
    … …  
    82358503        SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
    82368504        SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
     8505        SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
    82378506        SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
    82388507        SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
    … …  
    82468515        SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
    82478516        SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
     8517        SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
     8518                ALC888_FUJITSU_XA3530),
    82488519        SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
    82498520        SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
    … …  
    82578528        SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
    82588529        SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
     8530        SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
     8531        SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
    82598532        SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
    82608533        {0}
    … …  
    83718644                .init_hook = alc883_acer_aspire_automute,
    83728645        },
     8646        [ALC888_ACER_ASPIRE_4930G] = {
     8647                .mixers = { alc888_base_mixer,
     8648                                alc883_chmode_mixer },
     8649                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
     8650                                alc888_acer_aspire_4930g_verbs },
     8651                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
     8652                .dac_nids = alc883_dac_nids,
     8653                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
     8654                .adc_nids = alc883_adc_nids_rev,
     8655                .capsrc_nids = alc883_capsrc_nids_rev,
     8656                .dig_out_nid = ALC883_DIGOUT_NID,
     8657                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
     8658                .channel_mode = alc883_3ST_6ch_modes,
     8659                .need_dac_fix = 1,
     8660                .num_mux_defs =
     8661                        ARRAY_SIZE(alc888_2_capture_sources),
     8662                .input_mux = alc888_2_capture_sources,
     8663                .unsol_event = alc888_acer_aspire_4930g_unsol_event,
     8664                .init_hook = alc888_acer_aspire_4930g_automute,
     8665        },
    83738666        [ALC883_MEDION] = {
    83748667                .mixers = { alc883_fivestack_mixer,
    … …  
    85138806                .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
    85148807                .init_hook = alc883_2ch_fujitsu_pi2515_automute,
     8808        },
     8809        [ALC888_FUJITSU_XA3530] = {
     8810                .mixers = { alc888_base_mixer, alc883_chmode_mixer },
     8811                .init_verbs = { alc883_init_verbs,
     8812                        alc888_fujitsu_xa3530_verbs },
     8813                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
     8814                .dac_nids = alc883_dac_nids,
     8815                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
     8816                .adc_nids = alc883_adc_nids_rev,
     8817                .capsrc_nids = alc883_capsrc_nids_rev,
     8818                .dig_out_nid = ALC883_DIGOUT_NID,
     8819                .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
     8820                .channel_mode = alc888_4ST_8ch_intel_modes,
     8821                .num_mux_defs =
     8822                        ARRAY_SIZE(alc888_2_capture_sources),
     8823                .input_mux = alc888_2_capture_sources,
     8824                .unsol_event = alc888_fujitsu_xa3530_unsol_event,
     8825                .init_hook = alc888_fujitsu_xa3530_automute,
    85158826        },
    85168827        [ALC888_LENOVO_SKY] = {
    … …  
    85558866                .unsol_event = alc883_eee1601_unsol_event,
    85568867                .init_hook = alc883_eee1601_inithook,
     8868        },
     8869        [ALC1200_ASUS_P5Q] = {
     8870                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
     8871                .init_verbs = { alc883_init_verbs },
     8872                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
     8873                .dac_nids = alc883_dac_nids,
     8874                .dig_out_nid = ALC1200_DIGOUT_NID,
     8875                .dig_in_nid = ALC883_DIGIN_NID,
     8876                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
     8877                .channel_mode = alc883_sixstack_modes,
     8878                .input_mux = &alc883_capture_source,
    85578879        },
    85588880};
    … …  
    87529074                spec->loopback.amplist = alc883_loopbacks;
    87539075#endif
     9076        codec->proc_widget_hook = print_realtek_coef;
    87549077
    87559078        return 0;
    … …  
    1024410567        SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
    1024510568        SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
     10569        SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN",
     10570                      ALC262_SONY_ASSAMD),
    1024610571        SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
    1024710572                      ALC262_TOSHIBA_RX1),
    … …  
    1025110576        SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
    1025210577        SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
     10578        SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
    1025310579        SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
    1025410580        SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
    … …  
    1055810884                spec->loopback.amplist = alc262_loopbacks;
    1055910885#endif
     10886        codec->proc_widget_hook = print_realtek_coef;
    1056010887
    1056110888        return 0;
    … …  
    1137111698                                                ALC268_ACER_ASPIRE_ONE),
    1137211699        SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
     11700        SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
    1137311701        SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
    1137411702        SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
    … …  
    1162211950        if (board_config == ALC268_AUTO)
    1162311951                spec->init_hook = alc268_auto_init;
     11952
     11953        codec->proc_widget_hook = print_realtek_coef;
    1162411954
    1162511955        return 0;
    … …  
    1242412754                spec->loopback.amplist = alc269_loopbacks;
    1242512755#endif
     12756        codec->proc_widget_hook = print_realtek_coef;
    1242612757
    1242712758        return 0;
    … …  
    1351113842                spec->loopback.amplist = alc861_loopbacks;
    1351213843#endif
     13844        codec->proc_widget_hook = print_realtek_coef;
    1351313845
    1351413846        return 0;
    … …  
    1447214804                spec->loopback.amplist = alc861vd_loopbacks;
    1447314805#endif
     14806        codec->proc_widget_hook = print_realtek_coef;
    1447414807
    1447514808        return 0;
    … …  
    1628116614                spec->loopback.amplist = alc662_loopbacks;
    1628216615#endif
     16616        codec->proc_widget_hook = print_realtek_coef;
    1628316617
    1628416618        return 0;
    … …  
    1628816622 * patch entries
    1628916623 */
    16290 struct hda_codec_preset snd_hda_preset_realtek[] = {
     16624static struct hda_codec_preset snd_hda_preset_realtek[] = {
    1629116625        { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
    1629216626        { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
    … …  
    1631416648        { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
    1631516649        { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
    16316         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
    1631716650        { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
    1631816651          .patch = patch_alc883 },
     16652        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
    1631916653        { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
    1632016654        {0} /* terminator */
    1632116655};
     16656
     16657MODULE_ALIAS("snd-hda-codec-id:10ec*");
     16658
     16659MODULE_LICENSE("GPL");
     16660MODULE_DESCRIPTION("Realtek HD-audio codec");
     16661
     16662static struct hda_codec_preset_list realtek_list = {
     16663        .preset = snd_hda_preset_realtek,
     16664        .owner = THIS_MODULE,
     16665};
     16666
     16667static int __init patch_realtek_init(void)
     16668{
     16669        return snd_hda_add_codec_preset(&realtek_list);
     16670}
     16671
     16672static void __exit patch_realtek_exit(void)
     16673{
     16674        snd_hda_delete_codec_preset(&realtek_list);
     16675}
     16676
     16677module_init(patch_realtek_init)
     16678module_exit(patch_realtek_exit)

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_si3054.c

    r399 r410  
    2929#include "hda_codec.h"
    3030#include "hda_local.h"
    31 #include "hda_patch.h"
    3231
    3332/* si3054 verbs */
    … …  
    284283 * patch entries
    285284 */
    286 struct hda_codec_preset snd_hda_preset_si3054[] = {
     285static struct hda_codec_preset snd_hda_preset_si3054[] = {
    287286        { .id = 0x163c3055, .name = "Si3054", .patch = patch_si3054 },
    288287        { .id = 0x163c3155, .name = "Si3054", .patch = patch_si3054 },
    … …  
    302301};
    303302
     303MODULE_ALIAS("snd-hda-codec-id:163c3055");
     304MODULE_ALIAS("snd-hda-codec-id:163c3155");
     305MODULE_ALIAS("snd-hda-codec-id:11c13026");
     306MODULE_ALIAS("snd-hda-codec-id:11c13055");
     307MODULE_ALIAS("snd-hda-codec-id:11c13155");
     308MODULE_ALIAS("snd-hda-codec-id:10573055");
     309MODULE_ALIAS("snd-hda-codec-id:10573057");
     310MODULE_ALIAS("snd-hda-codec-id:10573155");
     311MODULE_ALIAS("snd-hda-codec-id:11063288");
     312MODULE_ALIAS("snd-hda-codec-id:15433155");
     313MODULE_ALIAS("snd-hda-codec-id:18540018");
     314
     315MODULE_LICENSE("GPL");
     316MODULE_DESCRIPTION("Si3054 HD-audio modem codec");
     317
     318static struct hda_codec_preset_list si3054_list = {
     319        .preset = snd_hda_preset_si3054,
     320        .owner = THIS_MODULE,
     321};
     322
     323static int __init patch_si3054_init(void)
     324{
     325        return snd_hda_add_codec_preset(&si3054_list);
     326}
     327
     328static void __exit patch_si3054_exit(void)
     329{
     330        snd_hda_delete_codec_preset(&si3054_list);
     331}
     332
     333module_init(patch_si3054_init)
     334module_exit(patch_si3054_exit)

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

    r402 r410  
    3434#include "hda_codec.h"
    3535#include "hda_local.h"
    36 #include "hda_patch.h"
    3736#include "hda_beep.h"
    3837
    39 #define STAC_INSERT_EVENT       0x10
    40 #define STAC_PWR_EVENT          0x20
    41 #define STAC_HP_EVENT           0x30
    42 #define STAC_VREF_EVENT         0x40
     38enum {
     39        STAC_VREF_EVENT = 1,
     40        STAC_INSERT_EVENT,
     41        STAC_PWR_EVENT,
     42        STAC_HP_EVENT,
     43};
    4344
    4445enum {
    … …  
    5556        STAC_9200_DELL_M26,
    5657        STAC_9200_DELL_M27,
    57         STAC_9200_GATEWAY,
     58        STAC_9200_M4,
     59        STAC_9200_M4_2,
    5860        STAC_9200_PANASONIC,
    5961        STAC_9200_MODELS
    … …  
    6971
    7072enum {
     73        STAC_92HD73XX_NO_JD, /* no jack-detection */
    7174        STAC_92HD73XX_REF,
    72         STAC_DELL_M6,
     75        STAC_DELL_M6_AMIC,
     76        STAC_DELL_M6_DMIC,
     77        STAC_DELL_M6_BOTH,
    7378        STAC_DELL_EQ,
    7479        STAC_92HD73XX_MODELS
    … …  
    8489        STAC_DELL_M4_1,
    8590        STAC_DELL_M4_2,
     91        STAC_DELL_M4_3,
    8692        STAC_HP_M4,
     93        STAC_HP_DV5,
    8794        STAC_92HD71BXX_MODELS
    8895};
    … …  
    9097enum {
    9198        STAC_925x_REF,
     99        STAC_M1,
     100        STAC_M1_2,
     101        STAC_M2,
    92102        STAC_M2_2,
    93         STAC_MA6,
    94         STAC_PA6,
     103        STAC_M3,
     104        STAC_M5,
     105        STAC_M6,
    95106        STAC_925x_MODELS
    96107};
    … …  
    124135
    125136enum {
     137        STAC_D965_REF_NO_JD, /* no jack-detection */
    126138        STAC_D965_REF,
    127139        STAC_D965_3ST,
    … …  
    134146struct sigmatel_event {
    135147        hda_nid_t nid;
     148        unsigned char type;
     149        unsigned char tag;
    136150        int data;
    137151};
    … …  
    148162
    149163        int board_config;
     164        unsigned int eapd_switch: 1;
    150165        unsigned int surr_switch: 1;
    151         unsigned int line_switch: 1;
    152         unsigned int mic_switch: 1;
    153166        unsigned int alt_switch: 1;
    154167        unsigned int hp_detect: 1;
    … …  
    187200        struct hda_multi_out multiout;
    188201        hda_nid_t dac_nids[5];
     202        hda_nid_t hp_dacs[5];
     203        hda_nid_t speaker_dacs[5];
    189204
    190205        /* capture */
    … …  
    210225        unsigned int num_pins;
    211226        unsigned int *pin_configs;
    212         unsigned int *bios_pin_configs;
    213227
    214228        /* codec specific stuff */
    … …  
    231245        unsigned int io_switch[2];
    232246        unsigned int clfe_swap;
    233         unsigned int hp_switch;
     247        hda_nid_t line_switch;  /* shared line-in for input and output */
     248        hda_nid_t mic_switch;   /* shared mic-in for input and output */
     249        hda_nid_t hp_switch; /* NID of HP as line-out */
    234250        unsigned int aloopback;
    235251
    … …  
    282298
    283299#define STAC92HD73_DAC_COUNT 5
    284 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
    285         0x15, 0x16, 0x17, 0x18, 0x19,
    286 };
    287300
    288301static hda_nid_t stac92hd73xx_mux_nids[4] = {
    … …  
    303316};
    304317
    305 #define STAC92HD81_DAC_COUNT 2
    306318#define STAC92HD83_DAC_COUNT 3
    307 static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
    308         0x13, 0x14, 0x22,
    309 };
    310319
    311320static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
    … …  
    326335
    327336static unsigned int stac92hd83xxx_pwr_mapping[4] = {
    328         0x03, 0x0c, 0x10, 0x40,
     337        0x03, 0x0c, 0x20, 0x80,
     338};
     339
     340static hda_nid_t stac92hd83xxx_amp_nids[1] = {
     341        0xc,
    329342};
    330343
    … …  
    347360static hda_nid_t stac92hd71bxx_smux_nids[2] = {
    348361        0x24, 0x25,
    349 };
    350 
    351 static hda_nid_t stac92hd71bxx_dac_nids[1] = {
    352         0x10, /*0x11, */
    353362};
    354363
    … …  
    584593                        nid = codec->slave_dig_outs[smux_idx - 1];
    585594                if (spec->cur_smux[smux_idx] == smux->num_items - 1)
    586                         val = AMP_OUT_MUTE;
     595                        val = HDA_AMP_MUTE;
    587596                else
    588                         val = AMP_OUT_UNMUTE;
     597                        val = 0;
    589598                /* un/mute SPDIF out */
    590                 snd_hda_codec_write_cache(codec, nid, 0,
    591                         AC_VERB_SET_AMP_GAIN_MUTE, val);
     599                snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
     600                                         HDA_AMP_MUTE, val);
    592601        }
    593602        return 0;
    … …  
    754763        /* set master volume and direct control */
    755764        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    756         /* setup audio connections */
    757         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
    758         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
    759         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
    760765        /* setup adcs to point to mixer */
    761766        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
    … …  
    776781         * and direct control */
    777782        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
    778         /* setup audio connections */
    779         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
    780         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
    781         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
    782783        /* setup adcs to point to mixer */
    783784        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
    … …  
    793794static struct hda_verb dell_m6_core_init[] = {
    794795        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    795         /* setup audio connections */
    796         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
    797         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
    798         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
    799796        /* setup adcs to point to mixer */
    800797        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
    … …  
    811808        /* set master volume and direct control */
    812809        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    813         /* setup audio connections */
    814         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
    815         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
    816         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
    817         /* connect hp ports to dac3 */
    818         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
    819         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
    820810        /* setup adcs to point to mixer */
    821811        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
    … …  
    835825        /* set master volume and direct control */
    836826        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    837         /* setup audio connections */
    838         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
    839         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
    840         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
    841827        /* dac3 is connected to import3 mux */
    842828        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
    843         /* connect hp ports to dac4 */
    844         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
    845         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
    846829        /* setup adcs to point to mixer */
    847830        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
    … …  
    869852        /* power state controls amps */
    870853        { 0x01, AC_VERB_SET_EAPD, 1 << 2},
     854        {0}
    871855};
    872856
    … …  
    874858        /* set master volume and direct control */
    875859        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    876         /* connect headphone jack to dac1 */
    877         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
    878860        /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
    879861        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
    880862        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
    881863        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
     864        {0}
    882865};
    883866
    … …  
    894877        /* set master volume and direct control */
    895878        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    896         /* connect headphone jack to dac1 */
    897         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
    898879        /* unmute right and left channels for nodes 0x0a, 0xd */
    899880        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
    … …  
    905886        /* set dac0mux for dac converter */
    906887        { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
     888        /* mute the master volume */
     889        { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
    907890        {0}
    908891};
    … …  
    10951078        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
    10961079
    1097         HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
    1098         HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
    1099 
    1100         HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
    1101         HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
    1102 
    1103         HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
    1104         HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
    1105 
    1106         HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
    1107         HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
     1080        HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
     1081        HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
     1082
     1083        HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
     1084        HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
     1085
     1086        HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
     1087        HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
     1088
     1089        HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
     1090        HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
    11081091
    11091092        /*
    1110         HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
    1111         HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
     1093        HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
     1094        HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
    11121095        */
    11131096        {0} /* end */
    … …  
    11561139
    11571140static struct snd_kcontrol_new stac925x_mixer[] = {
     1141        HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
     1142        HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
    11581143        STAC_INPUT_SOURCE(1),
    11591144        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
    … …  
    12491234
    12501235static void stac92xx_free_kctls(struct hda_codec *codec);
     1236static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
    12511237
    12521238static int stac92xx_build_controls(struct hda_codec *codec)
    12531239{
    12541240        struct sigmatel_spec *spec = codec->spec;
     1241        struct auto_pin_cfg *cfg = &spec->autocfg;
     1242        hda_nid_t nid;
    12551243        int err;
    12561244        int i;
    … …  
    12831271                }
    12841272                stac_smux_mixer.count = spec->num_smuxes;
    1285                 err = snd_ctl_add(codec->bus->card,
     1273                err = snd_hda_ctl_add(codec,
    12861274                                  snd_ctl_new1(&stac_smux_mixer, codec));
    12871275                if (err < 0)
    … …  
    13231311
    13241312        stac92xx_free_kctls(codec); /* no longer needed */
     1313
     1314        /* create jack input elements */
     1315        if (spec->hp_detect) {
     1316                for (i = 0; i < cfg->hp_outs; i++) {
     1317                        int type = SND_JACK_HEADPHONE;
     1318                        nid = cfg->hp_pins[i];
     1319                        /* jack detection */
     1320                        if (cfg->hp_outs == i)
     1321                                type |= SND_JACK_LINEOUT;
     1322                        err = stac92xx_add_jack(codec, nid, type);
     1323                        if (err < 0)
     1324                                return err;
     1325                }
     1326        }
     1327        for (i = 0; i < cfg->line_outs; i++) {
     1328                err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
     1329                                        SND_JACK_LINEOUT);
     1330                if (err < 0)
     1331                        return err;
     1332        }
     1333        for (i = 0; i < AUTO_PIN_LAST; i++) {
     1334                nid = cfg->input_pins[i];
     1335                if (nid) {
     1336                        err = stac92xx_add_jack(codec, nid,
     1337                                                SND_JACK_MICROPHONE);
     1338                        if (err < 0)
     1339                                return err;
     1340                }
     1341        }
     1342
    13251343        return 0;       
    13261344}
    … …  
    13311349};
    13321350
    1333 /*
     1351static unsigned int gateway9200_m4_pin_configs[8] = {
     1352        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
     1353        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
     1354};
     1355static unsigned int gateway9200_m4_2_pin_configs[8] = {
     1356        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
     1357        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
     1358};
     1359
     1360/*
    13341361    STAC 9200 pin configs for
    13351362    102801A8
    … …  
    14611488        [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
    14621489        [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
     1490        [STAC_9200_M4] = gateway9200_m4_pin_configs,
     1491        [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
    14631492        [STAC_9200_PANASONIC] = ref9200_pin_configs,
    14641493};
    … …  
    14771506        [STAC_9200_DELL_M26] = "dell-m26",
    14781507        [STAC_9200_DELL_M27] = "dell-m27",
    1479         [STAC_9200_GATEWAY] = "gateway",
     1508        [STAC_9200_M4] = "gateway-m4",
     1509        [STAC_9200_M4_2] = "gateway-m4-2",
    14801510        [STAC_9200_PANASONIC] = "panasonic",
    14811511};
    … …  
    15471577        SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
    15481578        /* Gateway machines needs EAPD to be set on resume */
    1549         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
    1550         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
    1551                       STAC_9200_GATEWAY),
    1552         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
    1553                       STAC_9200_GATEWAY),
     1579        SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
     1580        SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
     1581        SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
    15541582        /* OQO Mobile */
    15551583        SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
    … …  
    15621590};
    15631591
    1564 static unsigned int stac925x_MA6_pin_configs[8] = {
    1565         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
    1566         0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
    1567 };
    1568 
    1569 static unsigned int stac925x_PA6_pin_configs[8] = {
    1570         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
    1571         0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
     1592static unsigned int stac925xM1_pin_configs[8] = {
     1593        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1594        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
     1595};
     1596
     1597static unsigned int stac925xM1_2_pin_configs[8] = {
     1598        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1599        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
     1600};
     1601
     1602static unsigned int stac925xM2_pin_configs[8] = {
     1603        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1604        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
    15721605};
    15731606
    15741607static unsigned int stac925xM2_2_pin_configs[8] = {
    1575         0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
    1576         0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
     1608        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1609        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
     1610};
     1611
     1612static unsigned int stac925xM3_pin_configs[8] = {
     1613        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1614        0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
     1615};
     1616
     1617static unsigned int stac925xM5_pin_configs[8] = {
     1618        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1619        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
     1620};
     1621
     1622static unsigned int stac925xM6_pin_configs[8] = {
     1623        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
     1624        0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
    15771625};
    15781626
    15791627static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
    15801628        [STAC_REF] = ref925x_pin_configs,
     1629        [STAC_M1] = stac925xM1_pin_configs,
     1630        [STAC_M1_2] = stac925xM1_2_pin_configs,
     1631        [STAC_M2] = stac925xM2_pin_configs,
    15811632        [STAC_M2_2] = stac925xM2_2_pin_configs,
    1582         [STAC_MA6] = stac925x_MA6_pin_configs,
    1583         [STAC_PA6] = stac925x_PA6_pin_configs,
     1633        [STAC_M3] = stac925xM3_pin_configs,
     1634        [STAC_M5] = stac925xM5_pin_configs,
     1635        [STAC_M6] = stac925xM6_pin_configs,
    15841636};
    15851637
    15861638static const char *stac925x_models[STAC_925x_MODELS] = {
    15871639        [STAC_REF] = "ref",
     1640        [STAC_M1] = "m1",
     1641        [STAC_M1_2] = "m1-2",
     1642        [STAC_M2] = "m2",
    15881643        [STAC_M2_2] = "m2-2",
    1589         [STAC_MA6] = "m6",
    1590         [STAC_PA6] = "pa6",
     1644        [STAC_M3] = "m3",
     1645        [STAC_M5] = "m5",
     1646        [STAC_M6] = "m6",
     1647};
     1648
     1649static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
     1650        SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
     1651        SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
     1652        SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
     1653        SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
     1654        SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
     1655        /* Not sure about the brand name for those */
     1656        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
     1657        SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
     1658        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
     1659        SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
     1660        {0} /* terminator */
    15911661};
    15921662
    … …  
    15951665        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
    15961666        SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
    1597         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
    1598         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
    1599         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
    1600         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
    1601         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
     1667
     1668        /* Default table for unknown ID */
     1669        SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
     1670
    16021671        {0} /* terminator */
    16031672};
    … …  
    16191688static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
    16201689        [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
    1621         [STAC_DELL_M6]  = dell_m6_pin_configs,
     1690        [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
     1691        [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
     1692        [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
    16221693        [STAC_DELL_EQ]  = dell_m6_pin_configs,
    16231694};
    16241695
    16251696static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
     1697        [STAC_92HD73XX_NO_JD] = "no-jd",
    16261698        [STAC_92HD73XX_REF] = "ref",
    1627         [STAC_DELL_M6] = "dell-m6",
     1699        [STAC_DELL_M6_AMIC] = "dell-m6-amic",
     1700        [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
     1701        [STAC_DELL_M6_BOTH] = "dell-m6",
    16281702        [STAC_DELL_EQ] = "dell-eq",
    16291703};
    … …  
    16341708                                "DFI LanParty", STAC_92HD73XX_REF),
    16351709        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
    1636                                 "unknown Dell", STAC_DELL_M6),
     1710                                "Dell Studio 1535", STAC_DELL_M6_DMIC),
    16371711        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
    1638                                 "unknown Dell", STAC_DELL_M6),
     1712                                "unknown Dell", STAC_DELL_M6_DMIC),
    16391713        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
    1640                                 "unknown Dell", STAC_DELL_M6),
     1714                                "unknown Dell", STAC_DELL_M6_BOTH),
    16411715        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
    1642                                 "unknown Dell", STAC_DELL_M6),
     1716                                "unknown Dell", STAC_DELL_M6_BOTH),
    16431717        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
    1644                                 "unknown Dell", STAC_DELL_M6),
     1718                                "unknown Dell", STAC_DELL_M6_AMIC),
    16451719        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
    1646                                 "unknown Dell", STAC_DELL_M6),
     1720                                "unknown Dell", STAC_DELL_M6_AMIC),
    16471721        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
    1648                                 "unknown Dell", STAC_DELL_M6),
     1722                                "unknown Dell", STAC_DELL_M6_DMIC),
     1723        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
     1724                                "unknown Dell", STAC_DELL_M6_DMIC),
     1725        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
     1726                                "Dell Studio 1537", STAC_DELL_M6_DMIC),
     1727        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
     1728                                "Dell Studio 17", STAC_DELL_M6_DMIC),
    16491729        {0} /* terminator */
    16501730};
    … …  
    16681748        /* SigmaTel reference board */
    16691749        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
    1670                       "DFI LanParty", STAC_92HD71BXX_REF),
     1750                      "DFI LanParty", STAC_92HD83XXX_REF),
     1751        {0} /* terminator */
    16711752};
    16721753
    … …  
    16891770};
    16901771
     1772static unsigned int dell_m4_3_pin_configs[11] = {
     1773        0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
     1774        0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
     1775        0x40f000f0, 0x044413b0, 0x044413b0,
     1776};
     1777
    16911778static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
    16921779        [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
    16931780        [STAC_DELL_M4_1]        = dell_m4_1_pin_configs,
    16941781        [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
     1782        [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
    16951783        [STAC_HP_M4]            = NULL,
     1784        [STAC_HP_DV5]           = NULL,
    16961785};
    16971786
    … …  
    17001789        [STAC_DELL_M4_1] = "dell-m4-1",
    17011790        [STAC_DELL_M4_2] = "dell-m4-2",
     1791        [STAC_DELL_M4_3] = "dell-m4-3",
    17021792        [STAC_HP_M4] = "hp-m4",
     1793        [STAC_HP_DV5] = "hp-dv5",
    17031794};
    17041795
    … …  
    17071798        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
    17081799                      "DFI LanParty", STAC_92HD71BXX_REF),
     1800        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
     1801                      "HP dv5", STAC_HP_M4),
     1802        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
     1803                      "HP dv7", STAC_HP_M4),
     1804        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
     1805                      "HP dv7", STAC_HP_M4),
     1806        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
     1807                      "HP dv5", STAC_HP_DV5),
    17091808        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
    17101809                                "unknown HP", STAC_HP_M4),
    … …  
    17311830        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
    17321831                                "unknown Dell", STAC_DELL_M4_2),
     1832        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
     1833                                "unknown Dell", STAC_DELL_M4_3),
    17331834        {0} /* terminator */
    17341835};
    … …  
    20202121
    20212122static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
     2123        [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
    20222124        [STAC_D965_REF]  = ref927x_pin_configs,
    20232125        [STAC_D965_3ST]  = d965_3st_pin_configs,
    … …  
    20282130
    20292131static const char *stac927x_models[STAC_927X_MODELS] = {
     2132        [STAC_D965_REF_NO_JD]   = "ref-no-jd",
    20302133        [STAC_D965_REF]         = "ref",
    20312134        [STAC_D965_3ST]         = "3stack",
    … …  
    21862289        struct sigmatel_spec *spec = codec->spec;
    21872290       
    2188         if (! spec->bios_pin_configs) {
    2189                 spec->bios_pin_configs = kcalloc(spec->num_pins,
    2190                                                  sizeof(*spec->bios_pin_configs), GFP_KERNEL);
    2191                 if (! spec->bios_pin_configs)
    2192                         return -ENOMEM;
    2193         }
     2291        kfree(spec->pin_configs);
     2292        spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
     2293                                    GFP_KERNEL);
     2294        if (!spec->pin_configs)
     2295                return -ENOMEM;
    21942296       
    21952297        for (i = 0; i < spec->num_pins; i++) {
    … …  
    22012303                snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
    22022304                                        nid, pin_cfg);
    2203                 spec->bios_pin_configs[i] = pin_cfg;
     2305                spec->pin_configs[i] = pin_cfg;
    22042306        }
    22052307       
    … …  
    22432345}
    22442346
     2347static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
     2348{
     2349        struct sigmatel_spec *spec = codec->spec;
     2350
     2351        if (!pins)
     2352                return stac92xx_save_bios_config_regs(codec);
     2353
     2354        kfree(spec->pin_configs);
     2355        spec->pin_configs = kmemdup(pins,
     2356                                    spec->num_pins * sizeof(*pins),
     2357                                    GFP_KERNEL);
     2358        if (!spec->pin_configs)
     2359                return -ENOMEM;
     2360
     2361        stac92xx_set_config_regs(codec);
     2362        return 0;
     2363}
     2364
     2365static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
     2366                                   unsigned int cfg)
     2367{
     2368        struct sigmatel_spec *spec = codec->spec;
     2369        int i;
     2370
     2371        for (i = 0; i < spec->num_pins; i++) {
     2372                if (spec->pin_nids[i] == nid) {
     2373                        spec->pin_configs[i] = cfg;
     2374                        stac92xx_set_config_reg(codec, nid, cfg);
     2375                        break;
     2376                }
     2377        }
     2378}
     2379
    22452380/*
    22462381 * Analog playback callbacks
    … …  
    23202455        if (spec->powerdown_adcs) {
    23212456                msleep(40);
    2322                 snd_hda_codec_write_cache(codec, nid, 0,
     2457                snd_hda_codec_write(codec, nid, 0,
    23232458                        AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
    23242459        }
    … …  
    23362471        snd_hda_codec_cleanup_stream(codec, nid);
    23372472        if (spec->powerdown_adcs)
    2338                 snd_hda_codec_write_cache(codec, nid, 0,
     2473                snd_hda_codec_write(codec, nid, 0,
    23392474                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
    23402475        return 0;
    … …  
    24642599        struct sigmatel_spec *spec = codec->spec;
    24652600
    2466         ucontrol->value.integer.value[0] = spec->hp_switch;
     2601        ucontrol->value.integer.value[0] = !!spec->hp_switch;
    24672602        return 0;
    24682603}
     2604
     2605static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
     2606                                   unsigned char type);
    24692607
    24702608static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
    … …  
    24732611        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    24742612        struct sigmatel_spec *spec = codec->spec;
    2475         struct auto_pin_cfg *cfg = &spec->autocfg;
    2476         int nid = cfg->hp_pins[cfg->hp_outs - 1];
    2477 
    2478         spec->hp_switch = ucontrol->value.integer.value[0];
     2613        int nid = kcontrol->private_value;
     2614 
     2615        spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
    24792616
    24802617        /* check to be sure that the ports are upto date with
    24812618         * switch changes
    24822619         */
    2483         codec->patch_ops.unsol_event(codec, (STAC_HP_EVENT | nid) << 26);
     2620        stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
    24842621
    24852622        return 1;
    … …  
    25212658         */
    25222659        if (spec->hp_detect)
    2523                 codec->patch_ops.unsol_event(codec,
    2524                         (STAC_HP_EVENT | nid) << 26);
     2660                stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
    25252661
    25262662        return 1;
    … …  
    26102746
    26112747/* add dynamic controls */
    2612 static int stac92xx_add_control_idx(struct sigmatel_spec *spec, int type,
    2613                 int idx, const char *name, unsigned long val)
     2748static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
     2749                                     struct snd_kcontrol_new *ktemp,
     2750                                     int idx, const char *name,
     2751                                     unsigned long val)
    26142752{
    26152753        struct snd_kcontrol_new *knew;
    … …  
    26192757        if (!knew)
    26202758                return -ENOMEM;
    2621         *knew = stac92xx_control_templates[type];
     2759        *knew = *ktemp;
    26222760        knew->index = idx;
    26232761        knew->name = kstrdup(name, GFP_KERNEL);
    2624         if (! knew->name)
     2762        if (!knew->name)
    26252763                return -ENOMEM;
    26262764        knew->private_value = val;
    … …  
    26282766}
    26292767
     2768static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
     2769                                           int type, int idx, const char *name,
     2770                                           unsigned long val)
     2771{
     2772        return stac92xx_add_control_temp(spec,
     2773                                         &stac92xx_control_templates[type],
     2774                                         idx, name, val);
     2775}
     2776
    26302777
    26312778/* add dynamic controls */
    2632 static int stac92xx_add_control(struct sigmatel_spec *spec, int type,
    2633                 const char *name, unsigned long val)
     2779static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
     2780                                       const char *name, unsigned long val)
    26342781{
    26352782        return stac92xx_add_control_idx(spec, type, 0, name, val);
    26362783}
    26372784
    2638 /* flag inputs as additional dynamic lineouts */
    2639 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
    2640 {
    2641         struct sigmatel_spec *spec = codec->spec;
    2642         unsigned int wcaps, wtype;
    2643         int i, num_dacs = 0;
    2644        
    2645         /* use the wcaps cache to count all DACs available for line-outs */
    2646         for (i = 0; i < codec->num_nodes; i++) {
    2647                 wcaps = codec->wcaps[i];
    2648                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
    2649 
    2650                 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
    2651                         num_dacs++;
    2652         }
    2653 
    2654         snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
    2655        
    2656         switch (cfg->line_outs) {
    2657         case 3:
    2658                 /* add line-in as side */
    2659                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
    2660                         cfg->line_out_pins[cfg->line_outs] =
    2661                                 cfg->input_pins[AUTO_PIN_LINE];
    2662                         spec->line_switch = 1;
    2663                         cfg->line_outs++;
     2785/* check whether the line-input can be used as line-out */
     2786static hda_nid_t check_line_out_switch(struct hda_codec *codec)
     2787{
     2788        struct sigmatel_spec *spec = codec->spec;
     2789        struct auto_pin_cfg *cfg = &spec->autocfg;
     2790        hda_nid_t nid;
     2791        unsigned int pincap;
     2792
     2793        if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
     2794                return 0;
     2795        nid = cfg->input_pins[AUTO_PIN_LINE];
     2796        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
     2797        if (pincap & AC_PINCAP_OUT)
     2798                return nid;
     2799        return 0;
     2800}
     2801
     2802/* check whether the mic-input can be used as line-out */
     2803static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
     2804{
     2805        struct sigmatel_spec *spec = codec->spec;
     2806        struct auto_pin_cfg *cfg = &spec->autocfg;
     2807        unsigned int def_conf, pincap;
     2808        unsigned int mic_pin;
     2809
     2810        if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
     2811                return 0;
     2812        mic_pin = AUTO_PIN_MIC;
     2813        for (;;) {
     2814                hda_nid_t nid = cfg->input_pins[mic_pin];
     2815                def_conf = snd_hda_codec_read(codec, nid, 0,
     2816                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
     2817                /* some laptops have an internal analog microphone
     2818                 * which can't be used as a output */
     2819                if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
     2820                        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
     2821                        if (pincap & AC_PINCAP_OUT)
     2822                                return nid;
    26642823                }
    2665                 break;
    2666         case 2:
    2667                 /* add line-in as clfe and mic as side */
    2668                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
    2669                         cfg->line_out_pins[cfg->line_outs] =
    2670                                 cfg->input_pins[AUTO_PIN_LINE];
    2671                         spec->line_switch = 1;
    2672                         cfg->line_outs++;
    2673                 }
    2674                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
    2675                         cfg->line_out_pins[cfg->line_outs] =
    2676                                 cfg->input_pins[AUTO_PIN_MIC];
    2677                         spec->mic_switch = 1;
    2678                         cfg->line_outs++;
    2679                 }
    2680                 break;
    2681         case 1:
    2682                 /* add line-in as surr and mic as clfe */
    2683                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
    2684                         cfg->line_out_pins[cfg->line_outs] =
    2685                                 cfg->input_pins[AUTO_PIN_LINE];
    2686                         spec->line_switch = 1;
    2687                         cfg->line_outs++;
    2688                 }
    2689                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
    2690                         cfg->line_out_pins[cfg->line_outs] =
    2691                                 cfg->input_pins[AUTO_PIN_MIC];
    2692                         spec->mic_switch = 1;
    2693                         cfg->line_outs++;
    2694                 }
    2695                 break;
    2696         }
    2697 
     2824                if (mic_pin == AUTO_PIN_MIC)
     2825                        mic_pin = AUTO_PIN_FRONT_MIC;
     2826                else
     2827                        break;
     2828        }
    26982829        return 0;
    26992830}
    2700 
    27012831
    27022832static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
    … …  
    27112841        return 0;
    27122842}
     2843
     2844static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
     2845{
     2846        int i;
     2847        if (is_in_dac_nids(spec, nid))
     2848                return 1;
     2849        for (i = 0; i < spec->autocfg.hp_outs; i++)
     2850                if (spec->hp_dacs[i] == nid)
     2851                        return 1;
     2852        for (i = 0; i < spec->autocfg.speaker_outs; i++)
     2853                if (spec->speaker_dacs[i] == nid)
     2854                        return 1;
     2855        return 0;
     2856}
     2857
     2858static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
     2859{
     2860        struct sigmatel_spec *spec = codec->spec;
     2861        int j, conn_len;
     2862        hda_nid_t conn[HDA_MAX_CONNECTIONS];
     2863        unsigned int wcaps, wtype;
     2864
     2865        conn_len = snd_hda_get_connections(codec, nid, conn,
     2866                                           HDA_MAX_CONNECTIONS);
     2867        for (j = 0; j < conn_len; j++) {
     2868                wcaps = snd_hda_param_read(codec, conn[j],
     2869                                           AC_PAR_AUDIO_WIDGET_CAP);
     2870                wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
     2871                /* we check only analog outputs */
     2872                if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
     2873                        continue;
     2874                /* if this route has a free DAC, assign it */
     2875                if (!check_all_dac_nids(spec, conn[j])) {
     2876                        if (conn_len > 1) {
     2877                                /* select this DAC in the pin's input mux */
     2878                                snd_hda_codec_write_cache(codec, nid, 0,
     2879                                                  AC_VERB_SET_CONNECT_SEL, j);
     2880                        }
     2881                        return conn[j];
     2882                }
     2883        }
     2884        return 0;
     2885}
     2886
     2887static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
     2888static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
    27132889
    27142890/*
    … …  
    27192895 * and 9202/925x. For those, dac_nids[] must be hard-coded.
    27202896 */
    2721 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
    2722                                        struct auto_pin_cfg *cfg)
    2723 {
    2724         struct sigmatel_spec *spec = codec->spec;
    2725         int i, j, conn_len = 0;
    2726         hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
    2727         unsigned int wcaps, wtype;
     2897static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
     2898{
     2899        struct sigmatel_spec *spec = codec->spec;
     2900        struct auto_pin_cfg *cfg = &spec->autocfg;
     2901        int i;
     2902        hda_nid_t nid, dac;
    27282903       
    27292904        for (i = 0; i < cfg->line_outs; i++) {
    27302905                nid = cfg->line_out_pins[i];
    2731                 conn_len = snd_hda_get_connections(codec, nid, conn,
    2732                                                    HDA_MAX_CONNECTIONS);
    2733                 for (j = 0; j < conn_len; j++) {
    2734                         wcaps = snd_hda_param_read(codec, conn[j],
    2735                                                    AC_PAR_AUDIO_WIDGET_CAP);
    2736                         wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
    2737                         if (wtype != AC_WID_AUD_OUT ||
    2738                             (wcaps & AC_WCAP_DIGITAL))
    2739                                 continue;
    2740                         /* conn[j] is a DAC routed to this line-out */
    2741                         if (!is_in_dac_nids(spec, conn[j]))
    2742                                 break;
    2743                 }
    2744 
    2745                 if (j == conn_len) {
     2906                dac = get_unassigned_dac(codec, nid);
     2907                if (!dac) {
    27462908                        if (spec->multiout.num_dacs > 0) {
    27472909                                /* we have already working output pins,
    … …  
    27572919                        return -ENODEV;
    27582920                }
    2759 
    2760                 spec->multiout.dac_nids[i] = conn[j];
    2761                 spec->multiout.num_dacs++;
    2762                 if (conn_len > 1) {
    2763                         /* select this DAC in the pin's input mux */
    2764                         snd_hda_codec_write_cache(codec, nid, 0,
    2765                                                   AC_VERB_SET_CONNECT_SEL, j);
    2766 
     2921                add_spec_dacs(spec, dac);
     2922        }
     2923
     2924        /* add line-in as output */
     2925        nid = check_line_out_switch(codec);
     2926        if (nid) {
     2927                dac = get_unassigned_dac(codec, nid);
     2928                if (dac) {
     2929                        snd_printdd("STAC: Add line-in 0x%x as output %d\n",
     2930                                    nid, cfg->line_outs);
     2931                        cfg->line_out_pins[cfg->line_outs] = nid;
     2932                        cfg->line_outs++;
     2933                        spec->line_switch = nid;
     2934                        add_spec_dacs(spec, dac);
    27672935                }
    27682936        }
    2769 
    2770         snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
     2937        /* add mic as output */
     2938        nid = check_mic_out_switch(codec);
     2939        if (nid) {
     2940                dac = get_unassigned_dac(codec, nid);
     2941                if (dac) {
     2942                        snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
     2943                                    nid, cfg->line_outs);
     2944                        cfg->line_out_pins[cfg->line_outs] = nid;
     2945                        cfg->line_outs++;
     2946                        spec->mic_switch = nid;
     2947                        add_spec_dacs(spec, dac);
     2948                }
     2949        }
     2950
     2951        for (i = 0; i < cfg->hp_outs; i++) {
     2952                nid = cfg->hp_pins[i];
     2953                dac = get_unassigned_dac(codec, nid);
     2954                if (dac) {
     2955                        if (!spec->multiout.hp_nid)
     2956                                spec->multiout.hp_nid = dac;
     2957                        else
     2958                                add_spec_extra_dacs(spec, dac);
     2959                }
     2960                spec->hp_dacs[i] = dac;
     2961        }
     2962
     2963        for (i = 0; i < cfg->speaker_outs; i++) {
     2964                nid = cfg->speaker_pins[i];
     2965                dac = get_unassigned_dac(codec, nid);
     2966                if (dac)
     2967                        add_spec_extra_dacs(spec, dac);
     2968                spec->speaker_dacs[i] = dac;
     2969        }
     2970
     2971        snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
    27712972                   spec->multiout.num_dacs,
    27722973                   spec->multiout.dac_nids[0],
    … …  
    27752976                   spec->multiout.dac_nids[3],
    27762977                   spec->multiout.dac_nids[4]);
     2978
    27772979        return 0;
    27782980}
    … …  
    27993001static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
    28003002{
    2801         if (!spec->multiout.hp_nid)
    2802                 spec->multiout.hp_nid = nid;
    2803         else if (spec->multiout.num_dacs > 4) {
     3003        if (spec->multiout.num_dacs > 4) {
    28043004                printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
    28053005                return 1;
    … …  
    28113011}
    28123012
    2813 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
    2814 {
    2815         if (is_in_dac_nids(spec, nid))
    2816                 return 1;
     3013static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
     3014{
     3015        int i;
     3016        for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
     3017                if (!spec->multiout.extra_out_nid[i]) {
     3018                        spec->multiout.extra_out_nid[i] = nid;
     3019                        return 0;
     3020                }
     3021        }
     3022        printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
     3023        return 1;
     3024}
     3025
     3026static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
     3027{
     3028        int i;
     3029
     3030        if (spec->autocfg.line_outs != 1)
     3031                return 0;
    28173032        if (spec->multiout.hp_nid == nid)
    2818                 return 1;
    2819         return 0;
     3033                return 0;
     3034        for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
     3035                if (spec->multiout.extra_out_nid[i] == nid)
     3036                        return 0;
     3037        return 1;
    28203038}
    28213039
    … …  
    28243042                                               const struct auto_pin_cfg *cfg)
    28253043{
     3044        struct sigmatel_spec *spec = codec->spec;
    28263045        static const char *chname[4] = {
    28273046                "Front", "Surround", NULL /*CLFE*/, "Side"
    … …  
    28293048        hda_nid_t nid = 0;
    28303049        int i, err;
    2831 
    2832         struct sigmatel_spec *spec = codec->spec;
    2833         unsigned int wid_caps, pincap;
    2834 
    2835 
    2836         for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) {
    2837                 if (!spec->multiout.dac_nids[i])
    2838                         continue;
    2839 
     3050        unsigned int wid_caps;
     3051
     3052        for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
    28403053                nid = spec->multiout.dac_nids[i];
    2841 
    28423054                if (i == 2) {
    28433055                        /* Center/LFE */
    … …  
    28613073
    28623074                } else {
    2863                         err = create_controls(spec, chname[i], nid, 3);
     3075                        const char *name = chname[i];
     3076                        /* if it's a single DAC, assign a better name */
     3077                        if (!i && is_unique_dac(spec, nid)) {
     3078                                switch (cfg->line_out_type) {
     3079                                case AUTO_PIN_HP_OUT:
     3080                                        name = "Headphone";
     3081                                        break;
     3082                                case AUTO_PIN_SPEAKER_OUT:
     3083                                        name = "Speaker";
     3084                                        break;
     3085                                }
     3086                        }
     3087                        err = create_controls(spec, name, nid, 3);
    28643088                        if (err < 0)
    28653089                                return err;
    … …  
    28673091        }
    28683092
    2869         if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
    2870                         cfg->hp_outs && !spec->multiout.hp_nid)
    2871                 spec->multiout.hp_nid = nid;
    2872 
    2873         if (cfg->hp_outs > 1) {
     3093        if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
    28743094                err = stac92xx_add_control(spec,
    28753095                        STAC_CTL_WIDGET_HP_SWITCH,
    2876                         "Headphone as Line Out Switch", 0);
     3096                        "Headphone as Line Out Switch",
     3097                        cfg->hp_pins[cfg->hp_outs - 1]);
    28773098                if (err < 0)
    28783099                        return err;
    … …  
    28803101
    28813102        if (spec->line_switch) {
    2882                 nid = cfg->input_pins[AUTO_PIN_LINE];
    2883                 pincap = snd_hda_param_read(codec, nid,
    2884                                                 AC_PAR_PIN_CAP);
    2885                 if (pincap & AC_PINCAP_OUT) {
    2886                         err = stac92xx_add_control(spec,
    2887                                 STAC_CTL_WIDGET_IO_SWITCH,
    2888                                 "Line In as Output Switch", nid << 8);
    2889                         if (err < 0)
    2890                                 return err;
    2891                 }
     3103                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
     3104                                           "Line In as Output Switch",
     3105                                           spec->line_switch << 8);
     3106                if (err < 0)
     3107                        return err;
    28923108        }
    28933109
    28943110        if (spec->mic_switch) {
    2895                 unsigned int def_conf;
    2896                 unsigned int mic_pin = AUTO_PIN_MIC;
    2897 again:
    2898                 nid = cfg->input_pins[mic_pin];
    2899                 def_conf = snd_hda_codec_read(codec, nid, 0,
    2900                                                 AC_VERB_GET_CONFIG_DEFAULT, 0);
    2901                 /* some laptops have an internal analog microphone
    2902                  * which can't be used as a output */
    2903                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
    2904                         pincap = snd_hda_param_read(codec, nid,
    2905                                                         AC_PAR_PIN_CAP);
    2906                         if (pincap & AC_PINCAP_OUT) {
    2907                                 err = stac92xx_add_control(spec,
    2908                                         STAC_CTL_WIDGET_IO_SWITCH,
    2909                                         "Mic as Output Switch", (nid << 8) | 1);
    2910                                 nid = snd_hda_codec_read(codec, nid, 0,
    2911                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
    2912                                 if (!check_in_dac_nids(spec, nid))
    2913                                         add_spec_dacs(spec, nid);
    2914                                 if (err < 0)
    2915                                         return err;
    2916                         }
    2917                 } else if (mic_pin == AUTO_PIN_MIC) {
    2918                         mic_pin = AUTO_PIN_FRONT_MIC;
    2919                         goto again;
    2920                 }
     3111                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
     3112                                           "Mic as Output Switch",
     3113                                           (spec->mic_switch << 8) | 1);
     3114                if (err < 0)
     3115                        return err;
    29213116        }
    29223117
    … …  
    29303125        struct sigmatel_spec *spec = codec->spec;
    29313126        hda_nid_t nid;
    2932         int i, old_num_dacs, err;
    2933 
    2934         old_num_dacs = spec->multiout.num_dacs;
     3127        int i, err, nums;
     3128
     3129        nums = 0;
    29353130        for (i = 0; i < cfg->hp_outs; i++) {
     3131                static const char *pfxs[] = {
     3132                        "Headphone", "Headphone2", "Headphone3",
     3133                };
    29363134                unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
    29373135                if (wid_caps & AC_WCAP_UNSOL_CAP)
    29383136                        spec->hp_detect = 1;
    2939                 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
    2940                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
    2941                 if (check_in_dac_nids(spec, nid))
    2942                         nid = 0;
    2943                 if (! nid)
     3137                if (nums >= ARRAY_SIZE(pfxs))
    29443138                        continue;
    2945                 add_spec_dacs(spec, nid);
    2946         }
     3139                nid = spec->hp_dacs[i];
     3140                if (!nid)
     3141                        continue;
     3142                err = create_controls(spec, pfxs[nums++], nid, 3);
     3143                if (err < 0)
     3144                        return err;
     3145        }
     3146        nums = 0;
    29473147        for (i = 0; i < cfg->speaker_outs; i++) {
    2948                 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
    2949                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
    2950                 if (check_in_dac_nids(spec, nid))
    2951                         nid = 0;
    2952                 if (! nid)
    2953                         continue;
    2954                 add_spec_dacs(spec, nid);
    2955         }
    2956         for (i = 0; i < cfg->line_outs; i++) {
    2957                 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
    2958                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
    2959                 if (check_in_dac_nids(spec, nid))
    2960                         nid = 0;
    2961                 if (! nid)
    2962                         continue;
    2963                 add_spec_dacs(spec, nid);
    2964         }
    2965         for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
    29663148                static const char *pfxs[] = {
    29673149                        "Speaker", "External Speaker", "Speaker2",
    29683150                };
    2969                 err = create_controls(spec, pfxs[i - old_num_dacs],
    2970                                       spec->multiout.dac_nids[i], 3);
     3151                if (nums >= ARRAY_SIZE(pfxs))
     3152                        continue;
     3153                nid = spec->speaker_dacs[i];
     3154                if (!nid)
     3155                        continue;
     3156                err = create_controls(spec, pfxs[nums++], nid, 3);
    29713157                if (err < 0)
    29723158                        return err;
    29733159        }
    2974         if (spec->multiout.hp_nid) {
    2975                 err = create_controls(spec, "Headphone",
    2976                                       spec->multiout.hp_nid, 3);
    2977                 if (err < 0)
    2978                         return err;
    2979         }
    2980 
    29813160        return 0;
    29823161}
    … …  
    30713250        return 0;
    30723251}
     3252
     3253#ifdef CONFIG_SND_HDA_INPUT_BEEP
     3254#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
     3255
     3256static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
     3257                                        struct snd_ctl_elem_value *ucontrol)
     3258{
     3259        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
     3260        ucontrol->value.integer.value[0] = codec->beep->enabled;
     3261        return 0;
     3262}
     3263
     3264static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
     3265                                        struct snd_ctl_elem_value *ucontrol)
     3266{
     3267        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
     3268        int enabled = !!ucontrol->value.integer.value[0];
     3269        if (codec->beep->enabled != enabled) {
     3270                codec->beep->enabled = enabled;
     3271                return 1;
     3272        }
     3273        return 0;
     3274}
     3275
     3276static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
     3277        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     3278        .info = stac92xx_dig_beep_switch_info,
     3279        .get = stac92xx_dig_beep_switch_get,
     3280        .put = stac92xx_dig_beep_switch_put,
     3281};
     3282
     3283static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
     3284{
     3285        return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
     3286                                         0, "PC Beep Playback Switch", 0);
     3287}
     3288#endif
    30733289
    30743290static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
    … …  
    32793495        struct sigmatel_spec *spec = codec->spec;
    32803496        int err;
    3281         int hp_speaker_swap = 0;
    32823497
    32833498        if ((err = snd_hda_parse_pin_def_config(codec,
    … …  
    32973512                 * HP pins as primary outputs.
    32983513                 */
     3514                snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
    32993515                memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
    33003516                       sizeof(spec->autocfg.line_out_pins));
    … …  
    33033519                       sizeof(spec->autocfg.hp_pins));
    33043520                spec->autocfg.line_outs = spec->autocfg.hp_outs;
    3305                 hp_speaker_swap = 1;
     3521                spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
     3522                spec->autocfg.hp_outs = 0;
    33063523        }
    33073524        if (spec->autocfg.mono_out_pin) {
    … …  
    33553572        }
    33563573
    3357         if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
    3358                 return err;
    3359         if (spec->multiout.num_dacs == 0)
    3360                 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
     3574        if (!spec->multiout.num_dacs) {
     3575                err = stac92xx_auto_fill_dac_nids(codec);
     3576                if (err < 0)
    33613577                        return err;
    3362 
    3363         err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
    3364 
    3365         if (err < 0)
    3366                 return err;
     3578                err = stac92xx_auto_create_multi_out_ctls(codec,
     3579                                                          &spec->autocfg);
     3580                if (err < 0)
     3581                        return err;
     3582        }
    33673583
    33683584        /* setup analog beep controls */
    … …  
    33783594        if (spec->digbeep_nid > 0) {
    33793595                hda_nid_t nid = spec->digbeep_nid;
     3596                unsigned int caps;
    33803597
    33813598                err = stac92xx_auto_create_beep_ctls(codec, nid);
    … …  
    33853602                if (err < 0)
    33863603                        return err;
     3604                /* if no beep switch is available, make its own one */
     3605                caps = query_amp_caps(codec, nid, HDA_OUTPUT);
     3606                if (codec->beep &&
     3607                    !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
     3608                        err = stac92xx_beep_switch_ctl(codec);
     3609                        if (err < 0)
     3610                                return err;
     3611                }
    33873612        }
    33883613#endif
    3389 
    3390         if (hp_speaker_swap == 1) {
    3391                 /* Restore the hp_outs and line_outs */
    3392                 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
    3393                        sizeof(spec->autocfg.line_out_pins));
    3394                 spec->autocfg.hp_outs = spec->autocfg.line_outs;
    3395                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
    3396                        sizeof(spec->autocfg.speaker_pins));
    3397                 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
    3398                 memset(spec->autocfg.speaker_pins, 0,
    3399                        sizeof(spec->autocfg.speaker_pins));
    3400                 spec->autocfg.speaker_outs = 0;
    3401         }
    34023614
    34033615        err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
    … …  
    34493661
    34503662        spec->input_mux = &spec->private_imux;
    3451         spec->dinput_mux = &spec->private_dimux;
     3663        if (!spec->dinput_mux)
     3664                spec->dinput_mux = &spec->private_dimux;
    34523665        spec->sinput_mux = &spec->private_smux;
    34533666        spec->mono_mux = &spec->private_mono_mux;
    … …  
    35423755                return err;
    35433756
     3757        if (spec->num_muxes > 0) {
     3758                err = stac92xx_auto_create_mux_input_ctls(codec);
     3759                if (err < 0)
     3760                        return err;
     3761        }
     3762
    35443763        if (spec->autocfg.dig_out_pin)
    35453764                spec->multiout.dig_out_nid = 0x05;
    … …  
    35953814                hda_nid_t nid, int type)
    35963815{
     3816#ifdef CONFIG_SND_JACK
    35973817        struct sigmatel_spec *spec = codec->spec;
    35983818        struct sigmatel_jack *jack;
    … …  
    36183838
    36193839        return snd_jack_new(codec->bus->card, name, type, &jack->jack);
    3620 }
    3621 
    3622 static int stac92xx_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
    3623                              int data)
     3840#else
     3841        return 0;
     3842#endif
     3843}
     3844
     3845static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
     3846                          unsigned char type, int data)
    36243847{
    36253848        struct sigmatel_event *event;
    … …  
    36303853                return -ENOMEM;
    36313854        event->nid = nid;
     3855        event->type = type;
     3856        event->tag = spec->events.used;
    36323857        event->data = data;
    36333858
    3634         return 0;
    3635 }
    3636 
    3637 static int stac92xx_event_data(struct hda_codec *codec, hda_nid_t nid)
    3638 {
    3639         struct sigmatel_spec *spec = codec->spec;
    3640         struct sigmatel_event *events = spec->events.list;
    3641         if (events) {
    3642                 int i;
    3643                 for (i = 0; i < spec->events.used; i++)
    3644                         if (events[i].nid == nid)
    3645                                 return events[i].data;
    3646         }
    3647         return 0;
     3859        return event->tag;
     3860}
     3861
     3862static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
     3863                                             hda_nid_t nid, unsigned char type)
     3864{
     3865        struct sigmatel_spec *spec = codec->spec;
     3866        struct sigmatel_event *event = spec->events.list;
     3867        int i;
     3868
     3869        for (i = 0; i < spec->events.used; i++, event++) {
     3870                if (event->nid == nid && event->type == type)
     3871                        return event;
     3872        }
     3873        return NULL;
     3874}
     3875
     3876static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
     3877                                                      unsigned char tag)
     3878{
     3879        struct sigmatel_spec *spec = codec->spec;
     3880        struct sigmatel_event *event = spec->events.list;
     3881        int i;
     3882
     3883        for (i = 0; i < spec->events.used; i++, event++) {
     3884                if (event->tag == tag)
     3885                        return event;
     3886        }
     3887        return NULL;
    36483888}
    36493889
    36503890static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
    3651                               unsigned int event)
    3652 {
    3653         if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
    3654                 snd_hda_codec_write_cache(codec, nid, 0,
    3655                                           AC_VERB_SET_UNSOLICITED_ENABLE,
    3656                                           (AC_USRSP_EN | event | nid));
    3657         }
     3891                              unsigned int type)
     3892{
     3893        struct sigmatel_event *event;
     3894        int tag;
     3895
     3896        if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
     3897                return;
     3898        event = stac_get_event(codec, nid, type);
     3899        if (event)
     3900                tag = event->tag;
     3901        else
     3902                tag = stac_add_event(codec->spec, nid, type, 0);
     3903        if (tag < 0)
     3904                return;
     3905        snd_hda_codec_write_cache(codec, nid, 0,
     3906                                  AC_VERB_SET_UNSOLICITED_ENABLE,
     3907                                  AC_USRSP_EN | tag);
    36583908}
    36593909
    … …  
    36753925        hda_nid_t *dac;
    36763926        for (dac = spec->dac_list; *dac; dac++)
    3677                 if (!is_in_dac_nids(spec, *dac) &&
    3678                         spec->multiout.hp_nid != *dac)
    3679                         snd_hda_codec_write_cache(codec, *dac, 0,
     3927                if (!check_all_dac_nids(spec, *dac))
     3928                        snd_hda_codec_write(codec, *dac, 0,
    36803929                                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
    36813930}
    36823931
     3932static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
     3933                                  int enable);
     3934
    36833935static int stac92xx_init(struct hda_codec *codec)
    36843936{
    36853937        struct sigmatel_spec *spec = codec->spec;
    36863938        struct auto_pin_cfg *cfg = &spec->autocfg;
    3687         int i, err;
     3939        unsigned int gpio;
     3940        int i;
    36883941
    36893942        snd_hda_sequence_write(codec, spec->init);
    … …  
    36923945        if (spec->powerdown_adcs)
    36933946                for (i = 0; i < spec->num_adcs; i++)
    3694                         snd_hda_codec_write_cache(codec,
     3947                        snd_hda_codec_write(codec,
    36953948                                spec->adc_nids[i], 0,
    36963949                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
     3950
     3951        /* set up GPIO */
     3952        gpio = spec->gpio_data;
     3953        /* turn on EAPD statically when spec->eapd_switch isn't set.
     3954         * otherwise, unsol event will turn it on/off dynamically
     3955         */
     3956        if (!spec->eapd_switch)
     3957                gpio |= spec->eapd_mask;
     3958        stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
     3959
    36973960        /* set up pins */
    36983961        if (spec->hp_detect) {
    36993962                /* Enable unsolicited responses on the HP widget */
    37003963                for (i = 0; i < cfg->hp_outs; i++) {
    3701                         int type = SND_JACK_HEADPHONE;
    37023964                        hda_nid_t nid = cfg->hp_pins[i];
    3703                         enable_pin_detect(codec, nid, STAC_HP_EVENT | nid);
    3704                         /* jack detection */
    3705                         if (cfg->hp_outs == i)
    3706                                 type |= SND_JACK_LINEOUT;
    3707                         err = stac92xx_add_jack(codec, nid, type);
    3708                         if (err < 0)
    3709                                 return err;
    3710 
     3965                        enable_pin_detect(codec, nid, STAC_HP_EVENT);
    37113966                }
    37123967                /* force to enable the first line-out; the others are set up
    … …  
    37163971                                AC_PINCTL_OUT_EN);
    37173972                /* fake event to set up pins */
    3718                 codec->patch_ops.unsol_event(codec,
    3719                         (STAC_HP_EVENT | spec->autocfg.hp_pins[0]) << 26);
     3973                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
     3974                                       STAC_HP_EVENT);
    37203975        } else {
    37213976                stac92xx_auto_init_multi_out(codec);
    37223977                stac92xx_auto_init_hp_out(codec);
    3723         }
    3724         for (i = 0; i < cfg->line_outs; i++) {
    3725                 err = stac92xx_add_jack(codec,
    3726                                 cfg->line_out_pins[i], SND_JACK_LINEOUT);
    3727                 if (err < 0)
    3728                         return err;
     3978                for (i = 0; i < cfg->hp_outs; i++)
     3979                        stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
    37293980        }
    37303981        for (i = 0; i < AUTO_PIN_LAST; i++) {
    37313982                hda_nid_t nid = cfg->input_pins[i];
    37323983                if (nid) {
    3733                         unsigned int pinctl = snd_hda_codec_read(codec, nid,
    3734                                 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
    3735                         /* if PINCTL already set then skip */
    3736                         if (pinctl & AC_PINCAP_IN)
    3737                                 continue;
    3738                         pinctl = AC_PINCTL_IN_EN;
    3739                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
    3740                                 pinctl |= stac92xx_get_vref(codec, nid);
    3741                         stac92xx_auto_set_pinctl(codec, nid, pinctl);
    3742                         err = stac92xx_add_jack(codec, nid,
    3743                                 SND_JACK_MICROPHONE);
    3744                         if (err < 0)
    3745                                 return err;
    3746                         enable_pin_detect(codec, nid, STAC_INSERT_EVENT | nid);
     3984                        unsigned int pinctl, conf;
     3985                        if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
     3986                                /* for mic pins, force to initialize */
     3987                                pinctl = stac92xx_get_vref(codec, nid);
     3988                                pinctl |= AC_PINCTL_IN_EN;
     3989                                stac92xx_auto_set_pinctl(codec, nid, pinctl);
     3990                        } else {
     3991                                pinctl = snd_hda_codec_read(codec, nid, 0,
     3992                                        AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
     3993                                /* if PINCTL already set then skip */
     3994                                if (!(pinctl & AC_PINCTL_IN_EN)) {
     3995                                        pinctl |= AC_PINCTL_IN_EN;
     3996                                        stac92xx_auto_set_pinctl(codec, nid,
     3997                                                                 pinctl);
     3998                                }
     3999                        }
     4000                        conf = snd_hda_codec_read(codec, nid, 0,
     4001                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
     4002                        if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
     4003                                enable_pin_detect(codec, nid,
     4004                                                  STAC_INSERT_EVENT);
     4005                                stac_issue_unsol_event(codec, nid,
     4006                                                       STAC_INSERT_EVENT);
     4007                        }
    37474008                }
    37484009        }
    … …  
    37504011                stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
    37514012                                        AC_PINCTL_IN_EN);
    3752         for (i = 0; i < spec->num_pwrs; i++)  {
    3753                 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
    3754                                         ? STAC_HP_EVENT : STAC_PWR_EVENT;
    3755                 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
    3756                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
    3757                 int def_conf = snd_hda_codec_read(codec, spec->pwr_nids[i],
    3758                                         0, AC_VERB_GET_CONFIG_DEFAULT, 0);
    3759                 def_conf = get_defcfg_connect(def_conf);
    3760                 /* outputs are only ports capable of power management
    3761                  * any attempts on powering down a input port cause the
    3762                  * referenced VREF to act quirky.
    3763                  */
    3764                 if (pinctl & AC_PINCTL_IN_EN)
    3765                         continue;
    3766                 /* skip any ports that don't have jacks since presence
    3767                  * detection is useless */
    3768                 if (def_conf && def_conf != AC_JACK_PORT_FIXED)
    3769                         continue;
    3770                 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
    3771                 codec->patch_ops.unsol_event(codec, (event | i) << 26);
    3772         }
    3773         if (spec->dac_list)
    3774                 stac92xx_power_down(codec);
    37754013        if (cfg->dig_out_pin)
    37764014                stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
    … …  
    37794017                stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
    37804018                                         AC_PINCTL_IN_EN);
    3781 
    3782         stac_gpio_set(codec, spec->gpio_mask,
    3783                                         spec->gpio_dir, spec->gpio_data);
    3784 
     4019        for (i = 0; i < spec->num_pwrs; i++)  {
     4020                hda_nid_t nid = spec->pwr_nids[i];
     4021                int pinctl, def_conf;
     4022
     4023                /* power on when no jack detection is available */
     4024                if (!spec->hp_detect) {
     4025                        stac_toggle_power_map(codec, nid, 1);
     4026                        continue;
     4027                }
     4028
     4029                if (is_nid_hp_pin(cfg, nid))
     4030                        continue; /* already has an unsol event */
     4031
     4032                pinctl = snd_hda_codec_read(codec, nid, 0,
     4033                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
     4034                /* outputs are only ports capable of power management
     4035                 * any attempts on powering down a input port cause the
     4036                 * referenced VREF to act quirky.
     4037                 */
     4038                if (pinctl & AC_PINCTL_IN_EN) {
     4039                        stac_toggle_power_map(codec, nid, 1);
     4040                        continue;
     4041                }
     4042                def_conf = snd_hda_codec_read(codec, nid, 0,
     4043                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
     4044                def_conf = get_defcfg_connect(def_conf);
     4045                /* skip any ports that don't have jacks since presence
     4046                 * detection is useless */
     4047                if (def_conf != AC_JACK_PORT_COMPLEX) {
     4048                        if (def_conf != AC_JACK_PORT_NONE)
     4049                                stac_toggle_power_map(codec, nid, 1);
     4050                        continue;
     4051                }
     4052                if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
     4053                        enable_pin_detect(codec, nid, STAC_PWR_EVENT);
     4054                        stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
     4055                }
     4056        }
     4057        if (spec->dac_list)
     4058                stac92xx_power_down(codec);
    37854059        return 0;
    37864060}
    … …  
    37884062static void stac92xx_free_jacks(struct hda_codec *codec)
    37894063{
    3790         struct sigmatel_spec *spec = codec->spec;
    3791         if (spec->jacks.list) {
     4064#ifdef CONFIG_SND_JACK
     4065        /* free jack instances manually when clearing/reconfiguring */
     4066        struct sigmatel_spec *spec = codec->spec;
     4067        if (!codec->bus->shutdown && spec->jacks.list) {
    37924068                struct sigmatel_jack *jacks = spec->jacks.list;
    37934069                int i;
    … …  
    37964072        }
    37974073        snd_array_free(&spec->jacks);
     4074#endif
    37984075}
    37994076
    … …  
    38184095                return;
    38194096
    3820         if (spec->bios_pin_configs)
    3821                 kfree(spec->bios_pin_configs);
     4097        kfree(spec->pin_configs);
    38224098        stac92xx_free_jacks(codec);
    38234099        snd_array_free(&spec->events);
    … …  
    38404116                 */
    38414117                struct sigmatel_spec *spec = codec->spec;
    3842                 struct auto_pin_cfg *cfg = &spec->autocfg;
    3843                 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
    3844                      spec->line_switch) ||
    3845                     (nid == cfg->input_pins[AUTO_PIN_MIC] &&
    3846                      spec->mic_switch))
     4118                if (nid == spec->line_switch || nid == spec->mic_switch)
    38474119                        return;
    38484120        }
    … …  
    38684140}
    38694141
    3870 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
     4142static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
    38714143{
    38724144        if (!nid)
    38734145                return 0;
    38744146        if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
    3875             & (1 << 31)) {
    3876                 unsigned int pinctl;
    3877                 pinctl = snd_hda_codec_read(codec, nid, 0,
    3878                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
    3879                 if (pinctl & AC_PINCTL_IN_EN)
    3880                         return 0; /* mic- or line-input */
    3881                 else
    3882                         return 1; /* HP-output */
    3883         }
     4147            & (1 << 31))
     4148                return 1;
    38844149        return 0;
    38854150}
    38864151
    3887 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
    3888 {
    3889         struct sigmatel_spec *spec = codec->spec;
     4152/* return non-zero if the hp-pin of the given array index isn't
     4153 * a jack-detection target
     4154 */
     4155static int no_hp_sensing(struct sigmatel_spec *spec, int i)
     4156{
    38904157        struct auto_pin_cfg *cfg = &spec->autocfg;
    3891         int nid = cfg->hp_pins[cfg->hp_outs - 1];
     4158
     4159        /* ignore sensing of shared line and mic jacks */
     4160        if (cfg->hp_pins[i] == spec->line_switch)
     4161                return 1;
     4162        if (cfg->hp_pins[i] == spec->mic_switch)
     4163                return 1;
     4164        /* ignore if the pin is set as line-out */
     4165        if (cfg->hp_pins[i] == spec->hp_switch)
     4166                return 1;
     4167        return 0;
     4168}
     4169
     4170static void stac92xx_hp_detect(struct hda_codec *codec)
     4171{
     4172        struct sigmatel_spec *spec = codec->spec;
     4173        struct auto_pin_cfg *cfg = &spec->autocfg;
    38924174        int i, presence;
    38934175
    … …  
    39004182                if (presence)
    39014183                        break;
    3902                 if (spec->hp_switch && cfg->hp_pins[i] == nid)
    3903                         break;
    3904                 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
     4184                if (no_hp_sensing(spec, i))
     4185                        continue;
     4186                presence = get_pin_presence(codec, cfg->hp_pins[i]);
     4187                if (presence) {
     4188                        unsigned int pinctl;
     4189                        pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
     4190                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
     4191                        if (pinctl & AC_PINCTL_IN_EN)
     4192                                presence = 0; /* mic- or line-input */
     4193                }
    39054194        }
    39064195
    39074196        if (presence) {
    3908                 /* disable lineouts, enable hp */
     4197                /* disable lineouts */
    39094198                if (spec->hp_switch)
    3910                         stac92xx_reset_pinctl(codec, nid, AC_PINCTL_OUT_EN);
     4199                        stac92xx_reset_pinctl(codec, spec->hp_switch,
     4200                                              AC_PINCTL_OUT_EN);
    39114201                for (i = 0; i < cfg->line_outs; i++)
    39124202                        stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
    … …  
    39154205                        stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
    39164206                                                AC_PINCTL_OUT_EN);
    3917                 if (spec->eapd_mask)
     4207                if (spec->eapd_mask && spec->eapd_switch)
    39184208                        stac_gpio_set(codec, spec->gpio_mask,
    39194209                                spec->gpio_dir, spec->gpio_data &
    39204210                                ~spec->eapd_mask);
    39214211        } else {
    3922                 /* enable lineouts, disable hp */
     4212                /* enable lineouts */
    39234213                if (spec->hp_switch)
    3924                         stac92xx_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
     4214                        stac92xx_set_pinctl(codec, spec->hp_switch,
     4215                                            AC_PINCTL_OUT_EN);
    39254216                for (i = 0; i < cfg->line_outs; i++)
    39264217                        stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
    … …  
    39294220                        stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
    39304221                                                AC_PINCTL_OUT_EN);
    3931                 if (spec->eapd_mask)
     4222                if (spec->eapd_mask && spec->eapd_switch)
    39324223                        stac_gpio_set(codec, spec->gpio_mask,
    39334224                                spec->gpio_dir, spec->gpio_data |
    39344225                                spec->eapd_mask);
    39354226        }
    3936         if (!spec->hp_switch && cfg->hp_outs > 1 && presence)
    3937                 stac92xx_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
     4227        /* toggle hp outs */
     4228        for (i = 0; i < cfg->hp_outs; i++) {
     4229                unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
     4230                if (no_hp_sensing(spec, i))
     4231                        continue;
     4232                if (presence)
     4233                        stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
     4234#if 0 /* FIXME */
     4235/* Resetting the pinctl like below may lead to (a sort of) regressions
     4236 * on some devices since they use the HP pin actually for line/speaker
     4237 * outs although the default pin config shows a different pin (that is
     4238 * wrong and useless).
     4239 *
     4240 * So, it's basically a problem of default pin configs, likely a BIOS issue.
     4241 * But, disabling the code below just works around it, and I'm too tired of
     4242 * bug reports with such devices...
     4243 */
     4244                else
     4245                        stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
     4246#endif /* FIXME */
     4247        }
    39384248}
    39394249
    3940 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
    3941 {
    3942         struct sigmatel_spec *spec = codec->spec;
    3943         hda_nid_t nid = spec->pwr_nids[idx];
    3944         int presence, val;
    3945         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
    3946                                                         & 0x000000ff;
    3947         presence = get_hp_pin_presence(codec, nid);
     4250static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
     4251                                  int enable)
     4252{
     4253        struct sigmatel_spec *spec = codec->spec;
     4254        unsigned int idx, val;
     4255
     4256        for (idx = 0; idx < spec->num_pwrs; idx++) {
     4257                if (spec->pwr_nids[idx] == nid)
     4258                        break;
     4259        }
     4260        if (idx >= spec->num_pwrs)
     4261                return;
    39484262
    39494263        /* several codecs have two power down bits */
    … …  
    39534267                idx = 1 << idx;
    39544268
    3955         if (presence)
     4269        val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
     4270        if (enable)
    39564271                val &= ~idx;
    39574272        else
    … …  
    39604275        /* power down unused output ports */
    39614276        snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
     4277}
     4278
     4279static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
     4280{
     4281        stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
    39624282}
    39634283
    … …  
    39814301                                        ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
    39824302                                snd_jack_report(jacks->jack,
    3983                                         get_hp_pin_presence(codec, nid)
     4303                                        get_pin_presence(codec, nid)
    39844304                                        ? type : 0);
    39854305                        }
    … …  
    39894309}
    39904310
     4311static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
     4312                                   unsigned char type)
     4313{
     4314        struct sigmatel_event *event = stac_get_event(codec, nid, type);
     4315        if (!event)
     4316                return;
     4317        codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
     4318}
     4319
    39914320static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
    39924321{
    39934322        struct sigmatel_spec *spec = codec->spec;
    3994         int event = (res >> 26) & 0x70;
    3995         int nid = res >> 26 & 0x0f;
    3996 
    3997         switch (event) {
     4323        struct sigmatel_event *event;
     4324        int tag, data;
     4325
     4326        tag = (res >> 26) & 0x7f;
     4327        event = stac_get_event_from_tag(codec, tag);
     4328        if (!event)
     4329                return;
     4330
     4331        switch (event->type) {
    39984332        case STAC_HP_EVENT:
    3999                 stac92xx_hp_detect(codec, res);
     4333                stac92xx_hp_detect(codec);
    40004334                /* fallthru */
    40014335        case STAC_INSERT_EVENT:
    40024336        case STAC_PWR_EVENT:
    4003                 if (nid) {
    4004                         if (spec->num_pwrs > 0)
    4005                                 stac92xx_pin_sense(codec, nid);
    4006                         stac92xx_report_jack(codec, nid);
    4007                 }
     4337                if (spec->num_pwrs > 0)
     4338                        stac92xx_pin_sense(codec, event->nid);
     4339                stac92xx_report_jack(codec, event->nid);
    40084340                break;
    4009         case STAC_VREF_EVENT: {
    4010                 int data = snd_hda_codec_read(codec, codec->afg, 0,
    4011                         AC_VERB_GET_GPIO_DATA, 0);
    4012                 int idx = stac92xx_event_data(codec, nid);
     4341        case STAC_VREF_EVENT:
     4342                data = snd_hda_codec_read(codec, codec->afg, 0,
     4343                                          AC_VERB_GET_GPIO_DATA, 0);
    40134344                /* toggle VREF state based on GPIOx status */
    40144345                snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
    4015                         !!(data & (1 << idx)));
     4346                                    !!(data & (1 << event->data)));
    40164347                break;
    4017                 }
    4018         }
    4019 }
     4348        }
     4349}
     4350
     4351#ifdef CONFIG_PROC_FS
     4352static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
     4353                               struct hda_codec *codec, hda_nid_t nid)
     4354{
     4355        if (nid == codec->afg)
     4356                snd_iprintf(buffer, "Power-Map: 0x%02x\n",
     4357                            snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
     4358}
     4359
     4360static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
     4361                                  struct hda_codec *codec,
     4362                                  unsigned int verb)
     4363{
     4364        snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
     4365                    snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
     4366}
     4367
     4368/* stac92hd71bxx, stac92hd73xx */
     4369static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
     4370                                 struct hda_codec *codec, hda_nid_t nid)
     4371{
     4372        stac92hd_proc_hook(buffer, codec, nid);
     4373        if (nid == codec->afg)
     4374                analog_loop_proc_hook(buffer, codec, 0xfa0);
     4375}
     4376
     4377static void stac9205_proc_hook(struct snd_info_buffer *buffer,
     4378                               struct hda_codec *codec, hda_nid_t nid)
     4379{
     4380        if (nid == codec->afg)
     4381                analog_loop_proc_hook(buffer, codec, 0xfe0);
     4382}
     4383
     4384static void stac927x_proc_hook(struct snd_info_buffer *buffer,
     4385                               struct hda_codec *codec, hda_nid_t nid)
     4386{
     4387        if (nid == codec->afg)
     4388                analog_loop_proc_hook(buffer, codec, 0xfeb);
     4389}
     4390#else
     4391#define stac92hd_proc_hook      NULL
     4392#define stac92hd7x_proc_hook    NULL
     4393#define stac9205_proc_hook      NULL
     4394#define stac927x_proc_hook      NULL
     4395#endif
    40204396
    40214397#ifdef SND_HDA_NEEDS_RESUME
    … …  
    40254401
    40264402        stac92xx_set_config_regs(codec);
    4027         snd_hda_sequence_write(codec, spec->init);
    4028         stac_gpio_set(codec, spec->gpio_mask,
    4029                 spec->gpio_dir, spec->gpio_data);
     4403        stac92xx_init(codec);
    40304404        snd_hda_codec_resume_amp(codec);
    40314405        snd_hda_codec_resume_cache(codec);
    4032         /* power down inactive DACs */
    4033         if (spec->dac_list)
    4034                 stac92xx_power_down(codec);
    4035         /* invoke unsolicited event to reset the HP state */
     4406        /* fake event to set up pins again to override cached values */
    40364407        if (spec->hp_detect)
    4037                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
     4408                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
     4409                                       STAC_HP_EVENT);
     4410        return 0;
     4411}
     4412
     4413static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
     4414{
     4415        struct sigmatel_spec *spec = codec->spec;
     4416        if (spec->eapd_mask)
     4417                stac_gpio_set(codec, spec->gpio_mask,
     4418                                spec->gpio_dir, spec->gpio_data &
     4419                                ~spec->eapd_mask);
    40384420        return 0;
    40394421}
    … …  
    40474429        .unsol_event = stac92xx_unsol_event,
    40484430#ifdef SND_HDA_NEEDS_RESUME
     4431        .suspend = stac92xx_suspend,
    40494432        .resume = stac92xx_resume,
    40504433#endif
    … …  
    40694452                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
    40704453                err = stac92xx_save_bios_config_regs(codec);
    4071                 if (err < 0) {
    4072                         stac92xx_free(codec);
    4073                         return err;
    4074                 }
    4075                 spec->pin_configs = spec->bios_pin_configs;
    4076         } else {
    4077                 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
    4078                 stac92xx_set_config_regs(codec);
     4454        } else
     4455                err = stac_save_pin_cfgs(codec,
     4456                                         stac9200_brd_tbl[spec->board_config]);
     4457        if (err < 0) {
     4458                stac92xx_free(codec);
     4459                return err;
    40794460        }
    40804461
    … …  
    40894470        spec->num_pwrs = 0;
    40904471
    4091         if (spec->board_config == STAC_9200_GATEWAY ||
     4472        if (spec->board_config == STAC_9200_M4 ||
     4473            spec->board_config == STAC_9200_M4_2 ||
    40924474            spec->board_config == STAC_9200_OQO)
    40934475                spec->init = stac9200_eapd_init;
    … …  
    41074489        }
    41084490
     4491        /* CF-74 has no headphone detection, and the driver should *NOT*
     4492         * do detection and HP/speaker toggle because the hardware does it.
     4493         */
     4494        if (spec->board_config == STAC_9200_PANASONIC)
     4495                spec->hp_detect = 0;
     4496
    41094497        codec->patch_ops = stac92xx_patch_ops;
    41104498
    … …  
    41244512        spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
    41254513        spec->pin_nids = stac925x_pin_nids;
    4126         spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
     4514
     4515        /* Check first for codec ID */
     4516        spec->board_config = snd_hda_check_board_codec_sid_config(codec,
     4517                                                        STAC_925x_MODELS,
     4518                                                        stac925x_models,
     4519                                                        stac925x_codec_id_cfg_tbl);
     4520
     4521        /* Now checks for PCI ID, if codec ID is not found */
     4522        if (spec->board_config < 0)
     4523                spec->board_config = snd_hda_check_board_config(codec,
     4524                                                        STAC_925x_MODELS,
    41274525                                                        stac925x_models,
    41284526                                                        stac925x_cfg_tbl);
    41294527 again:
    41304528        if (spec->board_config < 0) {
    4131                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x," 
     4529                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
    41324530                                      "using BIOS defaults\n");
    41334531                err = stac92xx_save_bios_config_regs(codec);
    4134                 if (err < 0) {
    4135                         stac92xx_free(codec);
    4136                         return err;
    4137                 }
    4138                 spec->pin_configs = spec->bios_pin_configs;
    4139         } else if (stac925x_brd_tbl[spec->board_config] != NULL){
    4140                 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
    4141                 stac92xx_set_config_regs(codec);
     4532        } else
     4533                err = stac_save_pin_cfgs(codec,
     4534                                         stac925x_brd_tbl[spec->board_config]);
     4535        if (err < 0) {
     4536                stac92xx_free(codec);
     4537                return err;
    41424538        }
    41434539
    … …  
    42034599        hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
    42044600        int err = 0;
     4601        int num_dacs;
    42054602
    42064603        spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
    … …  
    42214618                        " STAC92HD73XX, using BIOS defaults\n");
    42224619                err = stac92xx_save_bios_config_regs(codec);
    4223                 if (err < 0) {
    4224                         stac92xx_free(codec);
    4225                         return err;
    4226                 }
    4227                 spec->pin_configs = spec->bios_pin_configs;
    4228         } else {
    4229                 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
    4230                 stac92xx_set_config_regs(codec);
    4231         }
    4232 
    4233         spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
     4620        } else
     4621                err = stac_save_pin_cfgs(codec,
     4622                                stac92hd73xx_brd_tbl[spec->board_config]);
     4623        if (err < 0) {
     4624                stac92xx_free(codec);
     4625                return err;
     4626        }
     4627
     4628        num_dacs = snd_hda_get_connections(codec, 0x0a,
    42344629                        conn, STAC92HD73_DAC_COUNT + 2) - 1;
    42354630
    4236         if (spec->multiout.num_dacs < 0) {
     4631        if (num_dacs < 3 || num_dacs > 5) {
    42374632                printk(KERN_WARNING "hda_codec: Could not determine "
    42384633                       "number of channels defaulting to DAC count\n");
    4239                 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
    4240         }
    4241 
    4242         switch (spec->multiout.num_dacs) {
     4634                num_dacs = STAC92HD73_DAC_COUNT;
     4635        }
     4636        switch (num_dacs) {
    42434637        case 0x3: /* 6 Channel */
    42444638                spec->mixer = stac92hd73xx_6ch_mixer;
    … …  
    42524646                spec->mixer = stac92hd73xx_10ch_mixer;
    42534647                spec->init = stac92hd73xx_10ch_core_init;
    4254         };
    4255 
    4256         spec->multiout.dac_nids = stac92hd73xx_dac_nids;
     4648        }
     4649        spec->multiout.dac_nids = spec->dac_nids;
     4650
    42574651        spec->aloopback_mask = 0x01;
    42584652        spec->aloopback_shift = 8;
    … …  
    42774671                spec->init = dell_eq_core_init;
    42784672                /* fallthru */
    4279         case STAC_DELL_M6:
     4673        case STAC_DELL_M6_AMIC:
     4674        case STAC_DELL_M6_DMIC:
     4675        case STAC_DELL_M6_BOTH:
    42804676                spec->num_smuxes = 0;
    42814677                spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
    42824678                spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
     4679                spec->eapd_switch = 0;
    42834680                spec->num_amps = 1;
    42844681
    4285                 if (!spec->init)
     4682                if (spec->board_config != STAC_DELL_EQ)
    42864683                        spec->init = dell_m6_core_init;
    4287                 switch (codec->subsystem_id) {
    4288                 case 0x1028025e: /* Analog Mics */
    4289                 case 0x1028025f:
     4684                switch (spec->board_config) {
     4685                case STAC_DELL_M6_AMIC: /* Analog Mics */
    42904686                        stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
    42914687                        spec->num_dmics = 0;
    42924688                        spec->private_dimux.num_items = 1;
    42934689                        break;
    4294                 case 0x10280271: /* Digital Mics */
    4295                 case 0x10280272:
    4296                 case 0x10280254:
    4297                 case 0x10280255:
     4690                case STAC_DELL_M6_DMIC: /* Digital Mics */
    42984691                        stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
    42994692                        spec->num_dmics = 1;
    43004693                        spec->private_dimux.num_items = 2;
    43014694                        break;
    4302                 case 0x10280256: /* Both */
    4303                 case 0x10280057:
     4695                case STAC_DELL_M6_BOTH: /* Both */
    43044696                        stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
    43054697                        stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
    … …  
    43124704                spec->num_dmics = STAC92HD73XX_NUM_DMICS;
    43134705                spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
     4706                spec->eapd_switch = 1;
    43144707        }
    43154708        if (spec->board_config > STAC_92HD73XX_REF) {
    … …  
    43404733        }
    43414734
     4735        if (spec->board_config == STAC_92HD73XX_NO_JD)
     4736                spec->hp_detect = 0;
     4737
    43424738        codec->patch_ops = stac92xx_patch_ops;
     4739
     4740        codec->proc_widget_hook = stac92hd7x_proc_hook;
    43434741
    43444742        return 0;
    … …  
    43714769        spec->adc_nids = stac92hd83xxx_adc_nids;
    43724770        spec->pwr_nids = stac92hd83xxx_pwr_nids;
     4771        spec->amp_nids = stac92hd83xxx_amp_nids;
    43734772        spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
    43744773        spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
    4375         spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
     4774        spec->multiout.dac_nids = spec->dac_nids;
    43764775
    43774776        spec->init = stac92hd83xxx_core_init;
    43784777        switch (codec->vendor_id) {
    43794778        case 0x111d7605:
    4380                 spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
    43814779                break;
    43824780        default:
    43834781                spec->num_pwrs--;
    43844782                spec->init++; /* switch to config #2 */
    4385                 spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
    43864783        }
    43874784
    … …  
    43904787        spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
    43914788        spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
     4789        spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
    43924790        spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
    43934791        spec->dinput_mux = &stac92hd83xxx_dmux;
    … …  
    44024800                        " STAC92HD83XXX, using BIOS defaults\n");
    44034801                err = stac92xx_save_bios_config_regs(codec);
    4404                 if (err < 0) {
    4405                         stac92xx_free(codec);
    4406                         return err;
    4407                 }
    4408                 spec->pin_configs = spec->bios_pin_configs;
    4409         } else {
    4410                 spec->pin_configs = stac92hd83xxx_brd_tbl[spec->board_config];
    4411                 stac92xx_set_config_regs(codec);
     4802        } else
     4803                err = stac_save_pin_cfgs(codec,
     4804                                stac92hd83xxx_brd_tbl[spec->board_config]);
     4805        if (err < 0) {
     4806                stac92xx_free(codec);
     4807                return err;
    44124808        }
    44134809
    … …  
    44304826        codec->patch_ops = stac92xx_patch_ops;
    44314827
     4828        codec->proc_widget_hook = stac92hd_proc_hook;
     4829
    44324830        return 0;
    44334831}
    4434 
    4435 #ifdef SND_HDA_NEEDS_RESUME
    4436 static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
    4437 {
    4438         struct sigmatel_spec *spec = codec->spec;
    4439         int i;
    4440         snd_hda_codec_write_cache(codec, codec->afg, 0,
    4441                 AC_VERB_SET_POWER_STATE, pwr);
    4442 
    4443         msleep(1);
    4444         for (i = 0; i < spec->num_adcs; i++) {
    4445                 snd_hda_codec_write_cache(codec,
    4446                         spec->adc_nids[i], 0,
    4447                         AC_VERB_SET_POWER_STATE, pwr);
    4448         }
    4449 };
    4450 
    4451 static int stac92hd71xx_resume(struct hda_codec *codec)
    4452 {
    4453         stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
    4454         return stac92xx_resume(codec);
    4455 }
    4456 
    4457 static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
    4458 {
    4459         stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
    4460         return 0;
    4461 };
    4462 
    4463 #endif
    4464 
    4465 static struct hda_codec_ops stac92hd71bxx_patch_ops = {
    4466         .build_controls = stac92xx_build_controls,
    4467         .build_pcms = stac92xx_build_pcms,
    4468         .init = stac92xx_init,
    4469         .free = stac92xx_free,
    4470         .unsol_event = stac92xx_unsol_event,
    4471 #ifdef SND_HDA_NEEDS_RESUME
    4472         .resume = stac92hd71xx_resume,
    4473         .suspend = stac92hd71xx_suspend,
    4474 #endif
    4475 };
    44764832
    44774833static struct hda_input_mux stac92hd71bxx_dmux = {
    … …  
    45104866                        " STAC92HD71BXX, using BIOS defaults\n");
    45114867                err = stac92xx_save_bios_config_regs(codec);
    4512                 if (err < 0) {
    4513                         stac92xx_free(codec);
    4514                         return err;
    4515                 }
    4516                 spec->pin_configs = spec->bios_pin_configs;
    4517         } else {
    4518                 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
    4519                 stac92xx_set_config_regs(codec);
     4868        } else
     4869                err = stac_save_pin_cfgs(codec,
     4870                                stac92hd71bxx_brd_tbl[spec->board_config]);
     4871        if (err < 0) {
     4872                stac92xx_free(codec);
     4873                return err;
     4874        }
     4875
     4876        if (spec->board_config > STAC_92HD71BXX_REF) {
     4877                /* GPIO0 = EAPD */
     4878                spec->gpio_mask = 0x01;
     4879                spec->gpio_dir = 0x01;
     4880                spec->gpio_data = 0x01;
    45204881        }
    45214882
    … …  
    45304891                break;
    45314892        case 0x111d7608: /* 5 Port with Analog Mixer */
    4532                 switch (codec->subsystem_id) {
    4533                 case 0x103c361a:
     4893                switch (spec->board_config) {
     4894                case STAC_HP_M4:
    45344895                        /* Enable VREF power saving on GPIO1 detect */
    4535                         snd_hda_codec_write(codec, codec->afg, 0,
     4896                        err = stac_add_event(spec, codec->afg,
     4897                                             STAC_VREF_EVENT, 0x02);
     4898                        if (err < 0)
     4899                                return err;
     4900                        snd_hda_codec_write_cache(codec, codec->afg, 0,
    45364901                                AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
    45374902                        snd_hda_codec_write_cache(codec, codec->afg, 0,
    45384903                                AC_VERB_SET_UNSOLICITED_ENABLE,
    4539                                 (AC_USRSP_EN | STAC_VREF_EVENT | codec->afg));
    4540                         err = stac92xx_add_event(spec, codec->afg, 0x02);
    4541                         if (err < 0)
    4542                                 return err;
     4904                                AC_USRSP_EN | err);
    45434905                        spec->gpio_mask |= 0x02;
    45444906                        break;
    45454907                }
    45464908                if ((codec->revision_id & 0xf) == 0 ||
    4547                                 (codec->revision_id & 0xf) == 1) {
    4548 #ifdef SND_HDA_NEEDS_RESUME
    4549                         codec->patch_ops = stac92hd71bxx_patch_ops;
    4550 #endif
     4909                    (codec->revision_id & 0xf) == 1)
    45514910                        spec->stream_delay = 40; /* 40 milliseconds */
    4552                 }
    45534911
    45544912                /* no output amps */
    … …  
    45594917                /* disable VSW */
    45604918                spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
    4561                 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0);
     4919                stac_change_pin_config(codec, 0xf, 0x40f000f0);
    45624920                break;
    45634921        case 0x111d7603: /* 6 Port with Analog Mixer */
    4564                 if ((codec->revision_id & 0xf) == 1) {
    4565 #ifdef SND_HDA_NEEDS_RESUME
    4566                         codec->patch_ops = stac92hd71bxx_patch_ops;
    4567 #endif
     4922                if ((codec->revision_id & 0xf) == 1)
    45684923                        spec->stream_delay = 40; /* 40 milliseconds */
    4569                 }
    45704924
    45714925                /* no output amps */
    … …  
    45824936        spec->aloopback_shift = 0;
    45834937
    4584         if (spec->board_config > STAC_92HD71BXX_REF) {
    4585                 /* GPIO0 = EAPD */
    4586                 spec->gpio_mask = 0x01;
    4587                 spec->gpio_dir = 0x01;
    4588                 spec->gpio_data = 0x01;
    4589         }
    4590 
    45914938        spec->powerdown_adcs = 1;
    45924939        spec->digbeep_nid = 0x26;
    … …  
    46034950        switch (spec->board_config) {
    46044951        case STAC_HP_M4:
     4952                /* enable internal microphone */
     4953                stac_change_pin_config(codec, 0x0e, 0x01813040);
     4954                stac92xx_auto_set_pinctl(codec, 0x0e,
     4955                        AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
     4956                /* fallthru */
     4957        case STAC_DELL_M4_2:
    46054958                spec->num_dmics = 0;
    46064959                spec->num_smuxes = 0;
    46074960                spec->num_dmuxes = 0;
    4608 
    4609                 /* enable internal microphone */
    4610                 stac92xx_set_config_reg(codec, 0x0e, 0x01813040);
    4611                 stac92xx_auto_set_pinctl(codec, 0x0e,
    4612                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
     4961                break;
     4962        case STAC_DELL_M4_1:
     4963        case STAC_DELL_M4_3:
     4964                spec->num_dmics = 1;
     4965                spec->num_smuxes = 0;
     4966                spec->num_dmuxes = 0;
    46134967                break;
    46144968        default:
    … …  
    46184972        };
    46194973
    4620         spec->multiout.num_dacs = 1;
    4621         spec->multiout.hp_nid = 0x11;
    4622         spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
     4974        spec->multiout.dac_nids = spec->dac_nids;
    46234975        if (spec->dinput_mux)
    46244976                spec->private_dimux.num_items +=
    … …  
    46414993                return err;
    46424994        }
     4995
     4996        codec->proc_widget_hook = stac92hd7x_proc_hook;
    46434997
    46444998        return 0;
    … …  
    47035057                        "using BIOS defaults\n");
    47045058                err = stac92xx_save_bios_config_regs(codec);
    4705                 if (err < 0) {
    4706                         stac92xx_free(codec);
    4707                         return err;
    4708                 }
    4709                 spec->pin_configs = spec->bios_pin_configs;
    4710         } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
    4711                 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
    4712                 stac92xx_set_config_regs(codec);
     5059        } else
     5060                err = stac_save_pin_cfgs(codec,
     5061                                stac922x_brd_tbl[spec->board_config]);
     5062        if (err < 0) {
     5063                stac92xx_free(codec);
     5064                return err;
    47135065        }
    47145066
    … …  
    47735125                                    "STAC927x, using BIOS defaults\n");
    47745126                err = stac92xx_save_bios_config_regs(codec);
    4775                 if (err < 0) {
    4776                         stac92xx_free(codec);
    4777                         return err;
    4778                 }
    4779                 spec->pin_configs = spec->bios_pin_configs;
    4780         } else {
    4781                 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
    4782                 stac92xx_set_config_regs(codec);
     5127        } else
     5128                err = stac_save_pin_cfgs(codec,
     5129                                stac927x_brd_tbl[spec->board_config]);
     5130        if (err < 0) {
     5131                stac92xx_free(codec);
     5132                return err;
    47835133        }
    47845134
    … …  
    48105160                case 0x1028022e:
    48115161                        /* correct the device field to SPDIF out */
    4812                         stac92xx_set_config_reg(codec, 0x21, 0x01442070);
     5162                        stac_change_pin_config(codec, 0x21, 0x01442070);
    48135163                        break;
    48145164                };
    48155165                /* configure the analog microphone on some laptops */
    4816                 stac92xx_set_config_reg(codec, 0x0c, 0x90a79130);
     5166                stac_change_pin_config(codec, 0x0c, 0x90a79130);
    48175167                /* correct the front output jack as a hp out */
    4818                 stac92xx_set_config_reg(codec, 0x0f, 0x0227011f);
     5168                stac_change_pin_config(codec, 0x0f, 0x0227011f);
    48195169                /* correct the front input jack as a mic */
    4820                 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
     5170                stac_change_pin_config(codec, 0x0e, 0x02a79130);
    48215171                /* fallthru */
    48225172        case STAC_DELL_3ST:
    … …  
    48475197        spec->aloopback_mask = 0x40;
    48485198        spec->aloopback_shift = 0;
     5199        spec->eapd_switch = 1;
    48495200
    48505201        err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
    … …  
    48645215
    48655216        codec->patch_ops = stac92xx_patch_ops;
     5217
     5218        codec->proc_widget_hook = stac927x_proc_hook;
    48665219
    48675220        /*
    … …  
    48775230        codec->bus->needs_damn_long_delay = 1;
    48785231
     5232        /* no jack detecion for ref-no-jd model */
     5233        if (spec->board_config == STAC_D965_REF_NO_JD)
     5234                spec->hp_detect = 0;
     5235
    48795236        return 0;
    48805237}
    … …  
    48995256                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
    49005257                err = stac92xx_save_bios_config_regs(codec);
    4901                 if (err < 0) {
    4902                         stac92xx_free(codec);
    4903                         return err;
    4904                 }
    4905                 spec->pin_configs = spec->bios_pin_configs;
    4906         } else {
    4907                 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
    4908                 stac92xx_set_config_regs(codec);
     5258        } else
     5259                err = stac_save_pin_cfgs(codec,
     5260                                         stac9205_brd_tbl[spec->board_config]);
     5261        if (err < 0) {
     5262                stac92xx_free(codec);
     5263                return err;
    49095264        }
    49105265
    … …  
    49275282        spec->aloopback_mask = 0x40;
    49285283        spec->aloopback_shift = 0;
     5284        spec->eapd_switch = 1;
    49295285        spec->multiout.dac_nids = spec->dac_nids;
    49305286       
    … …  
    49325288        case STAC_9205_DELL_M43:
    49335289                /* Enable SPDIF in/out */
    4934                 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
    4935                 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
     5290                stac_change_pin_config(codec, 0x1f, 0x01441030);
     5291                stac_change_pin_config(codec, 0x20, 0x1c410030);
    49365292
    49375293                /* Enable unsol response for GPIO4/Dock HP connection */
    4938                 snd_hda_codec_write(codec, codec->afg, 0,
     5294                err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
     5295                if (err < 0)
     5296                        return err;
     5297                snd_hda_codec_write_cache(codec, codec->afg, 0,
    49395298                        AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
    49405299                snd_hda_codec_write_cache(codec, codec->afg, 0,
    4941                         AC_VERB_SET_UNSOLICITED_ENABLE,
    4942                         (AC_USRSP_EN | STAC_VREF_EVENT | codec->afg));
    4943                 err = stac92xx_add_event(spec, codec->afg, 0x01);
    4944                 if (err < 0)
    4945                         return err;
     5300                                          AC_VERB_SET_UNSOLICITED_ENABLE,
     5301                                          AC_USRSP_EN | err);
    49465302
    49475303                spec->gpio_dir = 0x0b;
    … …  
    49815337        codec->patch_ops = stac92xx_patch_ops;
    49825338
     5339        codec->proc_widget_hook = stac9205_proc_hook;
     5340
    49835341        return 0;
    49845342}
    … …  
    50375395};
    50385396
    5039 /* bind volumes of both NID 0x02 and 0x05 */
    5040 static struct hda_bind_ctls vaio_bind_master_vol = {
    5041         .ops = &snd_hda_bind_vol,
    5042         .values = {
    5043                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
    5044                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
    5045                 0
    5046         },
    5047 };
    5048 
    5049 /* bind volumes of both NID 0x02 and 0x05 */
    5050 static struct hda_bind_ctls vaio_bind_master_sw = {
    5051         .ops = &snd_hda_bind_sw,
    5052         .values = {
    5053                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
    5054                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
    5055                 0,
    5056         },
    5057 };
    5058 
    50595397static struct snd_kcontrol_new vaio_mixer[] = {
    5060         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
    5061         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
     5398        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
     5399        HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
     5400        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
     5401        HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
    50625402        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
    50635403        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
    … …  
    50755415
    50765416static struct snd_kcontrol_new vaio_ar_mixer[] = {
    5077         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
    5078         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
     5417        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
     5418        HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
     5419        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
     5420        HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
    50795421        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
    50805422        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
    … …  
    51175459static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
    51185460{
    5119         if (get_hp_pin_presence(codec, 0x0a)) {
     5461        if (get_pin_presence(codec, 0x0a)) {
    51205462                stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
    51215463                stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
    … …  
    52285570 * patch entries
    52295571 */
    5230 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
     5572static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
    52315573        { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
    52325574        { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
    … …  
    52925634        {0} /* terminator */
    52935635};
     5636
     5637MODULE_ALIAS("snd-hda-codec-id:8384*");
     5638MODULE_ALIAS("snd-hda-codec-id:111d*");
     5639
     5640MODULE_LICENSE("GPL");
     5641MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
     5642
     5643static struct hda_codec_preset_list sigmatel_list = {
     5644        .preset = snd_hda_preset_sigmatel,
     5645        .owner = THIS_MODULE,
     5646};
     5647
     5648static int __init patch_sigmatel_init(void)
     5649{
     5650        return snd_hda_add_codec_preset(&sigmatel_list);
     5651}
     5652
     5653static void __exit patch_sigmatel_exit(void)
     5654{
     5655        snd_hda_delete_codec_preset(&sigmatel_list);
     5656}
     5657
     5658module_init(patch_sigmatel_init)
     5659module_exit(patch_sigmatel_exit)

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

    r399 r410  
    4848#include "hda_codec.h"
    4949#include "hda_local.h"
    50 #include "hda_patch.h"
    5150
    5251/* amp values */
    … …  
    142141        AUTO_SEQ_SIDE
    143142};
    144 
    145 #define get_amp_nid(kc) ((kc)->private_value & 0xffff)
    146143
    147144/* Some VT1708S based boards gets the micboost setting wrong, so we have
    … …  
    32533250 * patch entries
    32543251 */
    3255 struct hda_codec_preset snd_hda_preset_via[] = {
    3256         { .id = 0x11061708, .name = "VIA VT1708", .patch = patch_vt1708},
    3257         { .id = 0x11061709, .name = "VIA VT1708", .patch = patch_vt1708},
    3258         { .id = 0x1106170A, .name = "VIA VT1708", .patch = patch_vt1708},
    3259         { .id = 0x1106170B, .name = "VIA VT1708", .patch = patch_vt1708},
    3260         { .id = 0x1106E710, .name = "VIA VT1709 10-Ch",
     3252static struct hda_codec_preset snd_hda_preset_via[] = {
     3253        { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
     3254        { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
     3255        { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
     3256        { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
     3257        { .id = 0x1106e710, .name = "VT1709 10-Ch",
    32613258          .patch = patch_vt1709_10ch},
    3262         { .id = 0x1106E711, .name = "VIA VT1709 10-Ch",
     3259        { .id = 0x1106e711, .name = "VT1709 10-Ch",
    32633260          .patch = patch_vt1709_10ch},
    3264         { .id = 0x1106E712, .name = "VIA VT1709 10-Ch",
     3261        { .id = 0x1106e712, .name = "VT1709 10-Ch",
    32653262          .patch = patch_vt1709_10ch},
    3266         { .id = 0x1106E713, .name = "VIA VT1709 10-Ch",
     3263        { .id = 0x1106e713, .name = "VT1709 10-Ch",
    32673264          .patch = patch_vt1709_10ch},
    3268         { .id = 0x1106E714, .name = "VIA VT1709 6-Ch",
     3265        { .id = 0x1106e714, .name = "VT1709 6-Ch",
    32693266          .patch = patch_vt1709_6ch},
    3270         { .id = 0x1106E715, .name = "VIA VT1709 6-Ch",
     3267        { .id = 0x1106e715, .name = "VT1709 6-Ch",
    32713268          .patch = patch_vt1709_6ch},
    3272         { .id = 0x1106E716, .name = "VIA VT1709 6-Ch",
     3269        { .id = 0x1106e716, .name = "VT1709 6-Ch",
    32733270          .patch = patch_vt1709_6ch},
    3274         { .id = 0x1106E717, .name = "VIA VT1709 6-Ch",
     3271        { .id = 0x1106e717, .name = "VT1709 6-Ch",
    32753272          .patch = patch_vt1709_6ch},
    3276         { .id = 0x1106E720, .name = "VIA VT1708B 8-Ch",
     3273        { .id = 0x1106e720, .name = "VT1708B 8-Ch",
    32773274          .patch = patch_vt1708B_8ch},
    3278         { .id = 0x1106E721, .name = "VIA VT1708B 8-Ch",
     3275        { .id = 0x1106e721, .name = "VT1708B 8-Ch",
    32793276          .patch = patch_vt1708B_8ch},
    3280         { .id = 0x1106E722, .name = "VIA VT1708B 8-Ch",
     3277        { .id = 0x1106e722, .name = "VT1708B 8-Ch",
    32813278          .patch = patch_vt1708B_8ch},
    3282         { .id = 0x1106E723, .name = "VIA VT1708B 8-Ch",
     3279        { .id = 0x1106e723, .name = "VT1708B 8-Ch",
    32833280          .patch = patch_vt1708B_8ch},
    3284         { .id = 0x1106E724, .name = "VIA VT1708B 4-Ch",
     3281        { .id = 0x1106e724, .name = "VT1708B 4-Ch",
    32853282          .patch = patch_vt1708B_4ch},
    3286         { .id = 0x1106E725, .name = "VIA VT1708B 4-Ch",
     3283        { .id = 0x1106e725, .name = "VT1708B 4-Ch",
    32873284          .patch = patch_vt1708B_4ch},
    3288         { .id = 0x1106E726, .name = "VIA VT1708B 4-Ch",
     3285        { .id = 0x1106e726, .name = "VT1708B 4-Ch",
    32893286          .patch = patch_vt1708B_4ch},
    3290         { .id = 0x1106E727, .name = "VIA VT1708B 4-Ch",
     3287        { .id = 0x1106e727, .name = "VT1708B 4-Ch",
    32913288          .patch = patch_vt1708B_4ch},
    3292         { .id = 0x11060397, .name = "VIA VT1708S",
     3289        { .id = 0x11060397, .name = "VT1708S",
    32933290          .patch = patch_vt1708S},
    3294         { .id = 0x11061397, .name = "VIA VT1708S",
     3291        { .id = 0x11061397, .name = "VT1708S",
    32953292          .patch = patch_vt1708S},
    3296         { .id = 0x11062397, .name = "VIA VT1708S",
     3293        { .id = 0x11062397, .name = "VT1708S",
    32973294          .patch = patch_vt1708S},
    3298         { .id = 0x11063397, .name = "VIA VT1708S",
     3295        { .id = 0x11063397, .name = "VT1708S",
    32993296          .patch = patch_vt1708S},
    3300         { .id = 0x11064397, .name = "VIA VT1708S",
     3297        { .id = 0x11064397, .name = "VT1708S",
    33013298          .patch = patch_vt1708S},
    3302         { .id = 0x11065397, .name = "VIA VT1708S",
     3299        { .id = 0x11065397, .name = "VT1708S",
    33033300          .patch = patch_vt1708S},
    3304         { .id = 0x11066397, .name = "VIA VT1708S",
     3301        { .id = 0x11066397, .name = "VT1708S",
    33053302          .patch = patch_vt1708S},
    3306         { .id = 0x11067397, .name = "VIA VT1708S",
     3303        { .id = 0x11067397, .name = "VT1708S",
    33073304          .patch = patch_vt1708S},
    3308         { .id = 0x11060398, .name = "VIA VT1702",
     3305        { .id = 0x11060398, .name = "VT1702",
    33093306          .patch = patch_vt1702},
    3310         { .id = 0x11061398, .name = "VIA VT1702",
     3307        { .id = 0x11061398, .name = "VT1702",
    33113308          .patch = patch_vt1702},
    3312         { .id = 0x11062398, .name = "VIA VT1702",
     3309        { .id = 0x11062398, .name = "VT1702",
    33133310          .patch = patch_vt1702},
    3314         { .id = 0x11063398, .name = "VIA VT1702",
     3311        { .id = 0x11063398, .name = "VT1702",
    33153312          .patch = patch_vt1702},
    3316         { .id = 0x11064398, .name = "VIA VT1702",
     3313        { .id = 0x11064398, .name = "VT1702",
    33173314          .patch = patch_vt1702},
    3318         { .id = 0x11065398, .name = "VIA VT1702",
     3315        { .id = 0x11065398, .name = "VT1702",
    33193316          .patch = patch_vt1702},
    3320         { .id = 0x11066398, .name = "VIA VT1702",
     3317        { .id = 0x11066398, .name = "VT1702",
    33213318          .patch = patch_vt1702},
    3322         { .id = 0x11067398, .name = "VIA VT1702",
     3319        { .id = 0x11067398, .name = "VT1702",
    33233320          .patch = patch_vt1702},
    33243321        {0} /* terminator */
    33253322};
     3323
     3324MODULE_ALIAS("snd-hda-codec-id:1106*");
     3325
     3326static struct hda_codec_preset_list via_list = {
     3327        .preset = snd_hda_preset_via,
     3328        .owner = THIS_MODULE,
     3329};
     3330
     3331MODULE_LICENSE("GPL");
     3332MODULE_DESCRIPTION("VIA HD-audio codec");
     3333
     3334static int __init patch_via_init(void)
     3335{
     3336        return snd_hda_add_codec_preset(&via_list);
     3337}
     3338
     3339static void __exit patch_via_exit(void)
     3340{
     3341        snd_hda_delete_codec_preset(&via_list);
     3342}
     3343
     3344module_init(patch_via_init)
     3345module_exit(patch_via_exit)

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

    r402 r410  
    30653065        struct shortname_table *name;
    30663066
    3067         card = snd_card_new(index, id, THIS_MODULE, 0);
    3068         if (card == NULL)
    3069                 return -ENOMEM;
     3067        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
     3068        if (err < 0)
     3069                return err;
    30703070
    30713071        if (spdif_aclink < 0)

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

    r399 r410  
    24442444                return -ENOENT;
    24452445        }
    2446         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    2447         if (card == NULL)
    2448                 return -ENOMEM;
     2446        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     2447        if (err < 0)
     2448                return err;
    24492449
    24502450        if ((err = snd_korg1212_create(card, pci, &korg1212)) < 0) {

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

    r399 r410  
    16751675
    16761676        if (status & HV_INT_PENDING)
    1677                 tasklet_hi_schedule(&chip->hwvol_tq);
     1677                tasklet_schedule(&chip->hwvol_tq);
    16781678
    16791679        /*
    … …  
    27012701        }
    27022702
    2703         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    2704         if (card == NULL)
    2705                 return -ENOMEM;
     2703        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     2704        if (err < 0)
     2705                return err;
    27062706
    27072707        switch (pci->device) {

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

    r399 r410  
    16711671        }
    16721672
    1673         card = snd_card_new(index, id, THIS_MODULE, 0);
    1674         if (card == NULL)
    1675                 return -ENOMEM;
     1673        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
     1674        if (err < 0)
     1675                return err;
    16761676
    16771677        switch (pci->device) {

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/rme96.c

    r399 r410  
    23492349                return -ENOENT;
    23502350        }
    2351         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    2352                                  sizeof(struct rme96))) == NULL)
    2353                 return -ENOMEM;
     2351        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     2352                              sizeof(struct rme96), &card);
     2353        if (err < 0)
     2354                return err;
    23542355        card->private_free = snd_rme96_card_free;
    23552356        rme96 = (struct rme96 *)card->private_data;     

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

    r402 r410  
    14531453                return -1;
    14541454
    1455         sprintf (hdsp->midi[id].rmidi->name, "%s MIDI %d", card->id, id+1);
     1455        sprintf(hdsp->midi[id].rmidi->name, "HDSP MIDI %d", id+1);
    14561456        hdsp->midi[id].rmidi->private_data = &hdsp->midi[id];
    14571457
    … …  
    37513751        }
    37523752        if (hdsp->use_midi_tasklet && schedule)
    3753                 tasklet_hi_schedule(&hdsp->midi_tasklet);
     3753                tasklet_schedule(&hdsp->midi_tasklet);
    37543754        return IRQ_HANDLED;
    37553755}
    … …  
    51595159        }
    51605160
    5161         if (!(card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct hdsp))))
    5162                 return -ENOMEM;
     5161        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     5162                              sizeof(struct hdsp), &card);
     5163        if (err < 0)
     5164                return err;
    51635165
    51645166        hdsp = (struct hdsp *) card->private_data;

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

    r399 r410  
    12941294                return err;
    12951295
    1296         sprintf (hdspm->midi[id].rmidi->name, "%s MIDI %d", card->id, id+1);
     1296        sprintf(hdspm->midi[id].rmidi->name, "HDSPM MIDI %d", id+1);
    12971297        hdspm->midi[id].rmidi->private_data = &hdspm->midi[id];
    12981298
    … …  
    34773477        }
    34783478        if (schedule)
    3479                 tasklet_hi_schedule(&hdspm->midi_tasklet);
     3479                tasklet_schedule(&hdspm->midi_tasklet);
    34803480        return IRQ_HANDLED;
    34813481}
    … …  
    45044504        }
    45054505
    4506         card = snd_card_new(index[dev], id[dev],
    4507                             THIS_MODULE, sizeof(struct hdspm));
    4508         if (!card)
    4509                 return -ENOMEM;
     4506        err = snd_card_create(index[dev], id[dev],
     4507                              THIS_MODULE, sizeof(struct hdspm), &card);
     4508        if (err < 0)
     4509                return err;
    45104510
    45114511        hdspm = card->private_data;

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

    r399 r410  
    25952595        }
    25962596
    2597         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    2598                             sizeof(struct snd_rme9652));
    2599 
    2600         if (!card)
    2601                 return -ENOMEM;
     2597        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
     2598                              sizeof(struct snd_rme9652), &card);
     2599
     2600        if (err < 0)
     2601                return err;
    26022602
    26032603        rme9652 = (struct snd_rme9652 *) card->private_data;

  • TabularUnified GPL/branches/uniaud32-2.0/alsa-kernel/pci/sonicvibes.c

    r399 r410  
    14241424        }
    14251425 
    1426         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    1427         if (card == NULL)
    1428                 return -ENOMEM;
     1426        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     1427        if (err < 0)
     1428                return err;
    14291429        for (idx = 0; idx < 5; idx++) {
    14301430                if (pci_resource_start(pci, idx) == 0 ||

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

    r305 r410  
    9595        }
    9696
    97         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    98         if (card == NULL)
    99                 return -ENOMEM;
     97        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     98        if (err < 0)
     99                return err;
    100100
    101101        if ((err = snd_trident_create(card, pci,

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

    r399 r410  
    24392439#endif
    24402440
    2441         card = snd_card_new(index, id, THIS_MODULE, 0);
    2442         if (card == NULL)
    2443                 return -ENOMEM;
     2441        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
     2442        if (err < 0)
     2443                return err;
    24442444
    24452445        card_type = pci_id->driver_data;

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

    r305 r410  
    188188        }
    189189
    190         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
    191         if (card == NULL)
    192                 return -ENOMEM;
     190        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
     191        if (err < 0)
     192                return err;
    193193
    194194        switch (pci_id->device) {

  • TabularUnified GPL/branches/uniaud32-2.0/include/linux/interrupt.h

    r305 r410  
    7979extern void tasklet_hi_schedule(struct tasklet_struct *t);
    8080
     81#define tasklet_schedule tasklet_hi_schedule
     82
    8183extern void tasklet_init(struct tasklet_struct *t,
    8284                         void (*func)(unsigned long), unsigned long data);

  • TabularUnified GPL/branches/uniaud32-2.0/include/linux/pci.h

    r309 r410  
    657657
    658658void pci_save_state(struct pci_dev *dev);
    659 void pci_restore_state(struct pci_dev *dev);
     659int pci_restore_state(struct pci_dev *dev);
    660660
    661661unsigned long pci_get_dma_mask(struct pci_dev *);

  • TabularUnified GPL/branches/uniaud32-2.0/lib32/pci.c

    r333 r410  
    755755}
    756756
    757 void pci_restore_state(struct pci_dev *pci)
     757int pci_restore_state(struct pci_dev *pci)
    758758{
    759759    int i;
    … …  
    763763            saved_tbl[i].pci = NULL;
    764764            pci_orig_restore_state(pci, saved_tbl[i].config);
    765             return;
     765            return 0;
    766766        }
    767767    }
    768768    printk(KERN_DEBUG "snd: no saved pci config!\n");
     769    return 1;
    769770}
    770771

  • TabularUnified GPL/branches/uniaud32-2.0/uniaud.inc

    r402 r410  
    1313# ex RC3  GA  FIXPACK2 beta_47
    1414# Comment out to avoid a fixpack line in bldlevel
    15 FIXPACK = SVN r402
     15FIXPACK = SVN r402+
    1616
    1717# ALSA BUILD VERSION
    … …  
    2020# Leave empty or use MIXED
    2121# STRING must be max X chars
    22 ALSAVERSION = 1.0.18a
     22ALSAVERSION = 1.0.19
    2323
Note: See TracChangeset for help on using the changeset viewer.