Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=0ba21762d3966d242cb2486a76f83e5a34933f95
Commit:     0ba21762d3966d242cb2486a76f83e5a34933f95
Parent:     756e2b014349e90aca1d0432498d1b35e5445566
Author:     Takashi Iwai <[EMAIL PROTECTED]>
AuthorDate: Mon Apr 16 11:29:14 2007 +0200
Committer:  Jaroslav Kysela <[EMAIL PROTECTED]>
CommitDate: Fri May 11 16:55:59 2007 +0200

    [ALSA] hda-codec - Code clean up
    
    Trivial code clean-ups to follow the standard coding styles.
    
    Signed-off-by: Takashi Iwai <[EMAIL PROTECTED]>
    Signed-off-by: Jaroslav Kysela <[EMAIL PROTECTED]>
---
 sound/pci/hda/hda_codec.c |  466 +++++++++++++++++++++++++++------------------
 1 files changed, 276 insertions(+), 190 deletions(-)

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index fe4acfa..2fdd165 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -71,12 +71,13 @@ static struct hda_vendor_id hda_vendor_ids[] = {
  *
  * Returns the obtained response value, or -1 for an error.
  */
-unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, int 
direct,
+unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
+                               int direct,
                                unsigned int verb, unsigned int parm)
 {
        unsigned int res;
        mutex_lock(&codec->bus->cmd_mutex);
-       if (! codec->bus->ops.command(codec, nid, direct, verb, parm))
+       if (!codec->bus->ops.command(codec, nid, direct, verb, parm))
                res = codec->bus->ops.get_response(codec);
        else
                res = (unsigned int)-1;
@@ -129,7 +130,8 @@ void snd_hda_sequence_write(struct hda_codec *codec, const 
struct hda_verb *seq)
  * Parse the NID and store the start NID of its sub-nodes.
  * Returns the number of sub-nodes.
  */
-int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, hda_nid_t 
*start_id)
+int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
+                         hda_nid_t *start_id)
 {
        unsigned int parm;
 
@@ -173,12 +175,13 @@ int snd_hda_get_connections(struct hda_codec *codec, 
hda_nid_t nid,
        conn_len = parm & AC_CLIST_LENGTH;
        mask = (1 << (shift-1)) - 1;
 
-       if (! conn_len)
+       if (!conn_len)
                return 0; /* no connection */
 
        if (conn_len == 1) {
                /* single connection */
-               parm = snd_hda_codec_read(codec, nid, 0, 
AC_VERB_GET_CONNECT_LIST, 0);
+               parm = snd_hda_codec_read(codec, nid, 0,
+                                         AC_VERB_GET_CONNECT_LIST, 0);
                conn_list[0] = parm & mask;
                return 1;
        }
@@ -193,18 +196,21 @@ int snd_hda_get_connections(struct hda_codec *codec, 
hda_nid_t nid,
                if (i % num_elems == 0)
                        parm = snd_hda_codec_read(codec, nid, 0,
                                                  AC_VERB_GET_CONNECT_LIST, i);
-               range_val = !! (parm & (1 << (shift-1))); /* ranges */
+               range_val = !!(parm & (1 << (shift-1))); /* ranges */
                val = parm & mask;
                parm >>= shift;
                if (range_val) {
                        /* ranges between the previous and this one */
-                       if (! prev_nid || prev_nid >= val) {
-                               snd_printk(KERN_WARNING "hda_codec: invalid 
dep_range_val %x:%x\n", prev_nid, val);
+                       if (!prev_nid || prev_nid >= val) {
+                               snd_printk(KERN_WARNING "hda_codec: "
+                                          "invalid dep_range_val %x:%x\n",
+                                          prev_nid, val);
                                continue;
                        }
                        for (n = prev_nid + 1; n <= val; n++) {
                                if (conns >= max_conns) {
-                                       snd_printk(KERN_ERR "Too many 
connections\n");
+                                       snd_printk(KERN_ERR
+                                                  "Too many connections\n");
                                        return -EINVAL;
                                }
                                conn_list[conns++] = n;
@@ -239,7 +245,8 @@ int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, 
u32 res_ex)
        struct hda_bus_unsolicited *unsol;
        unsigned int wp;
 
-       if ((unsol = bus->unsol) == NULL)
+       unsol = bus->unsol;
+       if (!unsol)
                return 0;
 
        wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
@@ -271,7 +278,7 @@ static void process_unsol_events(struct work_struct *work)
                rp <<= 1;
                res = unsol->queue[rp];
                caddr = unsol->queue[rp + 1];
-               if (! (caddr & (1 << 4))) /* no unsolicited event? */
+               if (!(caddr & (1 << 4))) /* no unsolicited event? */
                        continue;
                codec = bus->caddr_tbl[caddr & 0x0f];
                if (codec && codec->patch_ops.unsol_event)
@@ -290,8 +297,9 @@ static int __devinit init_unsol_queue(struct hda_bus *bus)
                return 0;
 
        unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
-       if (! unsol) {
-               snd_printk(KERN_ERR "hda_codec: can't allocate unsolicited 
queue\n");
+       if (!unsol) {
+               snd_printk(KERN_ERR "hda_codec: "
+                          "can't allocate unsolicited queue\n");
                return -ENOMEM;
        }
        INIT_WORK(&unsol->work, process_unsol_events);
@@ -307,16 +315,15 @@ static void snd_hda_codec_free(struct hda_codec *codec);
 
 static int snd_hda_bus_free(struct hda_bus *bus)
 {
-       struct list_head *p, *n;
+       struct hda_codec *codec, *n;
 
-       if (! bus)
+       if (!bus)
                return 0;
        if (bus->unsol) {
                flush_scheduled_work();
                kfree(bus->unsol);
        }
-       list_for_each_safe(p, n, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
                snd_hda_codec_free(codec);
        }
        if (bus->ops.private_free)
@@ -370,7 +377,8 @@ int __devinit snd_hda_bus_new(struct snd_card *card,
        mutex_init(&bus->cmd_mutex);
        INIT_LIST_HEAD(&bus->codec_list);
 
-       if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) {
+       err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
+       if (err < 0) {
                snd_hda_bus_free(bus);
                return err;
        }
@@ -393,10 +401,10 @@ find_codec_preset(struct hda_codec *codec)
        for (tbl = hda_preset_tables; *tbl; tbl++) {
                for (preset = *tbl; preset->id; preset++) {
                        u32 mask = preset->mask;
-                       if (! mask)
+                       if (!mask)
                                mask = ~0;
                        if (preset->id == (codec->vendor_id & mask) &&
-                           (! preset->rev ||
+                           (!preset->rev ||
                             preset->rev == codec->revision_id))
                                return preset;
                }
@@ -421,14 +429,15 @@ void snd_hda_get_codec_name(struct hda_codec *codec,
                        break;
                }
        }
-       if (! vendor) {
+       if (!vendor) {
                sprintf(tmp, "Generic %04x", vendor_id);
                vendor = tmp;
        }
        if (codec->preset && codec->preset->name)
                snprintf(name, namelen, "%s %s", vendor, codec->preset->name);
        else
-               snprintf(name, namelen, "%s ID %x", vendor, codec->vendor_id & 
0xffff);
+               snprintf(name, namelen, "%s ID %x", vendor,
+                        codec->vendor_id & 0xffff);
 }
 
 /*
@@ -441,7 +450,9 @@ static void __devinit setup_fg_nodes(struct hda_codec 
*codec)
 
        total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
        for (i = 0; i < total_nodes; i++, nid++) {
-               switch((snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE) & 
0xff)) {
+               unsigned int func;
+               func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
+               switch (func & 0xff) {
                case AC_GRP_AUDIO_FUNCTION:
                        codec->afg = nid;
                        break;
@@ -465,7 +476,7 @@ static int read_widget_caps(struct hda_codec *codec, 
hda_nid_t fg_node)
        codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
                                                 &codec->start_nid);
        codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
-       if (! codec->wcaps)
+       if (!codec->wcaps)
                return -ENOMEM;
        nid = codec->start_nid;
        for (i = 0; i < codec->num_nodes; i++, nid++)
@@ -480,7 +491,7 @@ static int read_widget_caps(struct hda_codec *codec, 
hda_nid_t fg_node)
  */
 static void snd_hda_codec_free(struct hda_codec *codec)
 {
-       if (! codec)
+       if (!codec)
                return;
        list_del(&codec->list);
        codec->bus->caddr_tbl[codec->addr] = NULL;
@@ -512,7 +523,8 @@ int __devinit snd_hda_codec_new(struct hda_bus *bus, 
unsigned int codec_addr,
        snd_assert(codec_addr <= HDA_MAX_CODEC_ADDRESS, return -EINVAL);
 
        if (bus->caddr_tbl[codec_addr]) {
-               snd_printk(KERN_ERR "hda_codec: address 0x%x is already 
occupied\n", codec_addr);
+               snd_printk(KERN_ERR "hda_codec: "
+                          "address 0x%x is already occupied\n", codec_addr);
                return -EBUSY;
        }
 
@@ -530,18 +542,21 @@ int __devinit snd_hda_codec_new(struct hda_bus *bus, 
unsigned int codec_addr,
        list_add_tail(&codec->list, &bus->codec_list);
        bus->caddr_tbl[codec_addr] = codec;
 
-       codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT, 
AC_PAR_VENDOR_ID);
+       codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
+                                             AC_PAR_VENDOR_ID);
        if (codec->vendor_id == -1)
                /* read again, hopefully the access method was corrected
                 * in the last read...
                 */
                codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
                                                      AC_PAR_VENDOR_ID);
-       codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT, 
AC_PAR_SUBSYSTEM_ID);
-       codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT, 
AC_PAR_REV_ID);
+       codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
+                                                AC_PAR_SUBSYSTEM_ID);
+       codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
+                                               AC_PAR_REV_ID);
 
        setup_fg_nodes(codec);
-       if (! codec->afg && ! codec->mfg) {
+       if (!codec->afg && !codec->mfg) {
                snd_printdd("hda_codec: no AFG or MFG node found\n");
                snd_hda_codec_free(codec);
                return -ENODEV;
@@ -553,15 +568,15 @@ int __devinit snd_hda_codec_new(struct hda_bus *bus, 
unsigned int codec_addr,
                return -ENOMEM;
        }
 
-       if (! codec->subsystem_id) {
+       if (!codec->subsystem_id) {
                hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
-               codec->subsystem_id = snd_hda_codec_read(codec, nid, 0,
-                                                        
AC_VERB_GET_SUBSYSTEM_ID,
-                                                        0);
+               codec->subsystem_id =
+                       snd_hda_codec_read(codec, nid, 0,
+                                          AC_VERB_GET_SUBSYSTEM_ID, 0);
        }
 
        codec->preset = find_codec_preset(codec);
-       if (! *bus->card->mixername)
+       if (!*bus->card->mixername)
                snd_hda_get_codec_name(codec, bus->card->mixername,
                                       sizeof(bus->card->mixername));
 
@@ -595,13 +610,15 @@ int __devinit snd_hda_codec_new(struct hda_bus *bus, 
unsigned int codec_addr,
  * @channel_id: channel id to pass, zero based.
  * @format: stream format.
  */
-void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, u32 
stream_tag,
+void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
+                               u32 stream_tag,
                                int channel_id, int format)
 {
-       if (! nid)
+       if (!nid)
                return;
 
-       snd_printdd("hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, 
format=0x%x\n",
+       snd_printdd("hda_codec_setup_stream: "
+                   "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
                    nid, stream_tag, channel_id, format);
        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
                            (stream_tag << 4) | channel_id);
@@ -645,15 +662,18 @@ static struct hda_amp_info *get_alloc_amp_hash(struct 
hda_codec *codec, u32 key)
        if (codec->num_amp_entries >= codec->amp_info_size) {
                /* reallocate the array */
                int new_size = codec->amp_info_size + 64;
-               struct hda_amp_info *new_info = kcalloc(new_size, sizeof(struct 
hda_amp_info),
-                                                       GFP_KERNEL);
-               if (! new_info) {
-                       snd_printk(KERN_ERR "hda_codec: can't malloc 
amp_info\n");
+               struct hda_amp_info *new_info;
+               new_info = kcalloc(new_size, sizeof(struct hda_amp_info),
+                                  GFP_KERNEL);
+               if (!new_info) {
+                       snd_printk(KERN_ERR "hda_codec: "
+                                  "can't malloc amp_info\n");
                        return NULL;
                }
                if (codec->amp_info) {
                        memcpy(new_info, codec->amp_info,
-                              codec->amp_info_size * sizeof(struct 
hda_amp_info));
+                              codec->amp_info_size *
+                              sizeof(struct hda_amp_info));
                        kfree(codec->amp_info);
                }
                codec->amp_info_size = new_size;
@@ -674,15 +694,18 @@ static struct hda_amp_info *get_alloc_amp_hash(struct 
hda_codec *codec, u32 key)
  */
 static u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int 
direction)
 {
-       struct hda_amp_info *info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, 
direction, 0));
+       struct hda_amp_info *info;
 
-       if (! info)
+       info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
+       if (!info)
                return 0;
-       if (! (info->status & INFO_AMP_CAPS)) {
-               if (! (get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
+       if (!(info->status & INFO_AMP_CAPS)) {
+               if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
                        nid = codec->afg;
-               info->amp_caps = snd_hda_param_read(codec, nid, direction == 
HDA_OUTPUT ?
-                                                   AC_PAR_AMP_OUT_CAP : 
AC_PAR_AMP_IN_CAP);
+               info->amp_caps = snd_hda_param_read(codec, nid,
+                                                   direction == HDA_OUTPUT ?
+                                                   AC_PAR_AMP_OUT_CAP :
+                                                   AC_PAR_AMP_IN_CAP);
                info->status |= INFO_AMP_CAPS;
        }
        return info->amp_caps;
@@ -692,8 +715,9 @@ static u32 query_amp_caps(struct hda_codec *codec, 
hda_nid_t nid, int direction)
  * read the current volume to info
  * if the cache exists, read the cache value.
  */
-static unsigned int get_vol_mute(struct hda_codec *codec, struct hda_amp_info 
*info,
-                        hda_nid_t nid, int ch, int direction, int index)
+static unsigned int get_vol_mute(struct hda_codec *codec,
+                                struct hda_amp_info *info, hda_nid_t nid,
+                                int ch, int direction, int index)
 {
        u32 val, parm;
 
@@ -703,7 +727,8 @@ static unsigned int get_vol_mute(struct hda_codec *codec, 
struct hda_amp_info *i
        parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
        parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
        parm |= index;
-       val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_AMP_GAIN_MUTE, 
parm);
+       val = snd_hda_codec_read(codec, nid, 0,
+                                AC_VERB_GET_AMP_GAIN_MUTE, parm);
        info->vol[ch] = val & 0xff;
        info->status |= INFO_AMP_VOL(ch);
        return info->vol[ch];
@@ -713,7 +738,8 @@ static unsigned int get_vol_mute(struct hda_codec *codec, 
struct hda_amp_info *i
  * write the current volume in info to the h/w and update the cache
  */
 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
-                        hda_nid_t nid, int ch, int direction, int index, int 
val)
+                        hda_nid_t nid, int ch, int direction, int index,
+                        int val)
 {
        u32 parm;
 
@@ -731,8 +757,9 @@ static void put_vol_mute(struct hda_codec *codec, struct 
hda_amp_info *info,
 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
                           int direction, int index)
 {
-       struct hda_amp_info *info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, 
direction, index));
-       if (! info)
+       struct hda_amp_info *info;
+       info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
+       if (!info)
                return 0;
        return get_vol_mute(codec, info, nid, ch, direction, index);
 }
@@ -743,13 +770,14 @@ int snd_hda_codec_amp_read(struct hda_codec *codec, 
hda_nid_t nid, int ch,
 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
                             int direction, int idx, int mask, int val)
 {
-       struct hda_amp_info *info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, 
direction, idx));
+       struct hda_amp_info *info;
 
-       if (! info)
+       info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
+       if (!info)
                return 0;
        val &= mask;
        val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
-       if (info->vol[ch] == val && ! codec->in_resume)
+       if (info->vol[ch] == val && !codec->in_resume)
                return 0;
        put_vol_mute(codec, info, nid, ch, direction, idx, val);
        return 1;
@@ -766,7 +794,8 @@ int snd_hda_codec_amp_update(struct hda_codec *codec, 
hda_nid_t nid, int ch,
 #define get_amp_index(kc)      (((kc)->private_value >> 19) & 0xf)
 
 /* volume */
-int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_info *uinfo)
+int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_info *uinfo)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        u16 nid = get_amp_nid(kcontrol);
@@ -775,9 +804,11 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
        u32 caps;
 
        caps = query_amp_caps(codec, nid, dir);
-       caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; /* 
num steps */
-       if (! caps) {
-               printk(KERN_WARNING "hda_codec: num_steps = 0 for NID=0x%x\n", 
nid);
+       /* num steps */
+       caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+       if (!caps) {
+               printk(KERN_WARNING "hda_codec: "
+                      "num_steps = 0 for NID=0x%x\n", nid);
                return -EINVAL;
        }
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
@@ -787,7 +818,8 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
        return 0;
 }
 
-int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = get_amp_nid(kcontrol);
@@ -803,7 +835,8 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol 
*kcontrol, struct snd_ctl_e
        return 0;
 }
 
-int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = get_amp_nid(kcontrol);
@@ -835,7 +868,8 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, 
int op_flag,
        if (size < 4 * sizeof(unsigned int))
                return -ENOMEM;
        caps = query_amp_caps(codec, nid, dir);
-       val2 = (((caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT) + 
1) * 25;
+       val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
+       val2 = (val2 + 1) * 25;
        val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
        val1 = ((int)val1) * ((int)val2);
        if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
@@ -850,7 +884,8 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, 
int op_flag,
 }
 
 /* switch */
-int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_info *uinfo)
+int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_info *uinfo)
 {
        int chs = get_amp_channels(kcontrol);
 
@@ -861,7 +896,8 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
        return 0;
 }
 
-int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = get_amp_nid(kcontrol);
@@ -871,13 +907,16 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol 
*kcontrol, struct snd_ctl_e
        long *valp = ucontrol->value.integer.value;
 
        if (chs & 1)
-               *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) & 
0x80) ? 0 : 1;
+               *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
+                          0x80) ? 0 : 1;
        if (chs & 2)
-               *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) & 
0x80) ? 0 : 1;
+               *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
+                        0x80) ? 0 : 1;
        return 0;
 }
 
-int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = get_amp_nid(kcontrol);
@@ -908,7 +947,8 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol 
*kcontrol, struct snd_ctl_e
 #define AMP_VAL_IDX_SHIFT      19
 #define AMP_VAL_IDX_MASK       (0x0f<<19)
 
-int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        unsigned long pval;
@@ -923,7 +963,8 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
        return err;
 }
 
-int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        unsigned long pval;
@@ -933,7 +974,8 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
        pval = kcontrol->private_value;
        indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
        for (i = 0; i < indices; i++) {
-               kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | (i << 
AMP_VAL_IDX_SHIFT);
+               kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
+                       (i << AMP_VAL_IDX_SHIFT);
                err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
                if (err < 0)
                        break;
@@ -948,14 +990,16 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol 
*kcontrol, struct snd_ctl_
  * SPDIF out controls
  */
 
-static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_info *uinfo)
+static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
        uinfo->count = 1;
        return 0;
 }
 
-static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
 {
        ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
                                           IEC958_AES0_NONAUDIO |
@@ -966,7 +1010,8 @@ static int snd_hda_spdif_cmask_get(struct snd_kcontrol 
*kcontrol, struct snd_ctl
        return 0;
 }
 
-static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
 {
        ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
                                           IEC958_AES0_NONAUDIO |
@@ -974,7 +1019,8 @@ static int snd_hda_spdif_pmask_get(struct snd_kcontrol 
*kcontrol, struct snd_ctl
        return 0;
 }
 
-static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 
@@ -994,19 +1040,21 @@ static unsigned short convert_from_spdif_status(unsigned 
int sbits)
        unsigned short val = 0;
 
        if (sbits & IEC958_AES0_PROFESSIONAL)
-               val |= 1 << 6;
+               val |= AC_DIG1_PROFESSIONAL;
        if (sbits & IEC958_AES0_NONAUDIO)
-               val |= 1 << 5;
+               val |= AC_DIG1_NONAUDIO;
        if (sbits & IEC958_AES0_PROFESSIONAL) {
-               if ((sbits & IEC958_AES0_PRO_EMPHASIS) == 
IEC958_AES0_PRO_EMPHASIS_5015)
-                       val |= 1 << 3;
+               if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
+                   IEC958_AES0_PRO_EMPHASIS_5015)
+                       val |= AC_DIG1_EMPHASIS;
        } else {
-               if ((sbits & IEC958_AES0_CON_EMPHASIS) == 
IEC958_AES0_CON_EMPHASIS_5015)
-                       val |= 1 << 3;
-               if (! (sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
-                       val |= 1 << 4;
+               if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
+                   IEC958_AES0_CON_EMPHASIS_5015)
+                       val |= AC_DIG1_EMPHASIS;
+               if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
+                       val |= AC_DIG1_COPYRIGHT;
                if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
-                       val |= 1 << 7;
+                       val |= AC_DIG1_LEVEL;
                val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
        }
        return val;
@@ -1018,26 +1066,27 @@ static unsigned int convert_to_spdif_status(unsigned 
short val)
 {
        unsigned int sbits = 0;
 
-       if (val & (1 << 5))
+       if (val & AC_DIG1_NONAUDIO)
                sbits |= IEC958_AES0_NONAUDIO;
-       if (val & (1 << 6))
+       if (val & AC_DIG1_PROFESSIONAL)
                sbits |= IEC958_AES0_PROFESSIONAL;
        if (sbits & IEC958_AES0_PROFESSIONAL) {
-               if (sbits & (1 << 3))
+               if (sbits & AC_DIG1_EMPHASIS)
                        sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
        } else {
-               if (val & (1 << 3))
+               if (val & AC_DIG1_EMPHASIS)
                        sbits |= IEC958_AES0_CON_EMPHASIS_5015;
-               if (! (val & (1 << 4)))
+               if (!(val & AC_DIG1_COPYRIGHT))
                        sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
-               if (val & (1 << 7))
+               if (val & AC_DIG1_LEVEL)
                        sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
                sbits |= val & (0x7f << 8);
        }
        return sbits;
 }
 
-static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value;
@@ -1055,15 +1104,18 @@ static int snd_hda_spdif_default_put(struct 
snd_kcontrol *kcontrol, struct snd_c
        codec->spdif_ctls = val;
 
        if (change || codec->in_resume) {
-               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 
val & 0xff);
-               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_2, 
val >> 8);
+               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
+                                   val & 0xff);
+               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_2,
+                                   val >> 8);
        }
 
        mutex_unlock(&codec->spdif_mutex);
        return change;
 }
 
-static int snd_hda_spdif_out_switch_info(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_info *uinfo)
+static int snd_hda_spdif_out_switch_info(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        uinfo->count = 1;
@@ -1072,15 +1124,17 @@ static int snd_hda_spdif_out_switch_info(struct 
snd_kcontrol *kcontrol, struct s
        return 0;
 }
 
-static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 
-       ucontrol->value.integer.value[0] = codec->spdif_ctls & 1;
+       ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
        return 0;
 }
 
-static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value;
@@ -1088,20 +1142,21 @@ static int snd_hda_spdif_out_switch_put(struct 
snd_kcontrol *kcontrol, struct sn
        int change;
 
        mutex_lock(&codec->spdif_mutex);
-       val = codec->spdif_ctls & ~1;
+       val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
        if (ucontrol->value.integer.value[0])
-               val |= 1;
+               val |= AC_DIG1_ENABLE;
        change = codec->spdif_ctls != val;
        if (change || codec->in_resume) {
                codec->spdif_ctls = val;
                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
                                    val & 0xff);
-               if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
+               /* unmute amp switch (if any) */
+               if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
+                   (val & AC_DIG1_ENABLE))
                        snd_hda_codec_write(codec, nid, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
                                            AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT |
-                                           AC_AMP_SET_OUTPUT |
-                                           ((val & 1) ? 0 : 0x80));
+                                           AC_AMP_SET_OUTPUT);
        }
        mutex_unlock(&codec->spdif_mutex);
        return change;
@@ -1159,10 +1214,12 @@ int __devinit snd_hda_create_spdif_out_ctls(struct 
hda_codec *codec,
        for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
                kctl = snd_ctl_new1(dig_mix, codec);
                kctl->private_value = nid;
-               if ((err = snd_ctl_add(codec->bus->card, kctl)) < 0)
+               err = snd_ctl_add(codec->bus->card, kctl);
+               if (err < 0)
                        return err;
        }
-       codec->spdif_ctls = snd_hda_codec_read(codec, nid, 0, 
AC_VERB_GET_DIGI_CONVERT, 0);
+       codec->spdif_ctls =
+               snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT, 0);
        codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
        return 0;
 }
@@ -1173,7 +1230,8 @@ int __devinit snd_hda_create_spdif_out_ctls(struct 
hda_codec *codec,
 
 #define snd_hda_spdif_in_switch_info   snd_hda_spdif_out_switch_info
 
-static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 
@@ -1181,7 +1239,8 @@ static int snd_hda_spdif_in_switch_get(struct 
snd_kcontrol *kcontrol, struct snd
        return 0;
 }
 
-static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value;
@@ -1192,13 +1251,15 @@ static int snd_hda_spdif_in_switch_put(struct 
snd_kcontrol *kcontrol, struct snd
        change = codec->spdif_in_enable != val;
        if (change || codec->in_resume) {
                codec->spdif_in_enable = val;
-               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 
val);
+               snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
+                                   val);
        }
        mutex_unlock(&codec->spdif_mutex);
        return change;
 }
 
-static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, struct 
snd_ctl_elem_value *ucontrol)
+static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
 {
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value;
@@ -1252,10 +1313,13 @@ int __devinit snd_hda_create_spdif_in_ctls(struct 
hda_codec *codec,
        for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
                kctl = snd_ctl_new1(dig_mix, codec);
                kctl->private_value = nid;
-               if ((err = snd_ctl_add(codec->bus->card, kctl)) < 0)
+               err = snd_ctl_add(codec->bus->card, kctl);
+               if (err < 0)
                        return err;
        }
-       codec->spdif_in_enable = snd_hda_codec_read(codec, nid, 0, 
AC_VERB_GET_DIGI_CONVERT, 0) & 1;
+       codec->spdif_in_enable =
+               snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT, 0) &
+               AC_DIG1_ENABLE;
        return 0;
 }
 
@@ -1295,13 +1359,12 @@ static void hda_set_power_state(struct hda_codec 
*codec, hda_nid_t fg,
  */
 int __devinit snd_hda_build_controls(struct hda_bus *bus)
 {
-       struct list_head *p;
+       struct hda_codec *codec;
 
        /* build controls */
-       list_for_each(p, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry(codec, &bus->codec_list, list) {
                int err;
-               if (! codec->patch_ops.build_controls)
+               if (!codec->patch_ops.build_controls)
                        continue;
                err = codec->patch_ops.build_controls(codec);
                if (err < 0)
@@ -1309,13 +1372,12 @@ int __devinit snd_hda_build_controls(struct hda_bus 
*bus)
        }
 
        /* initialize */
-       list_for_each(p, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry(codec, &bus->codec_list, list) {
                int err;
                hda_set_power_state(codec,
                                    codec->afg ? codec->afg : codec->mfg,
                                    AC_PWRST_D0);
-               if (! codec->patch_ops.init)
+               if (!codec->patch_ops.init)
                        continue;
                err = codec->patch_ops.init(codec);
                if (err < 0)
@@ -1381,7 +1443,7 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
                        val = rate_bits[i].hda_fmt;
                        break;
                }
-       if (! rate_bits[i].hz) {
+       if (!rate_bits[i].hz) {
                snd_printdd("invalid rate %d\n", rate);
                return 0;
        }
@@ -1406,7 +1468,8 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
                        val |= 0x20;
                break;
        default:
-               snd_printdd("invalid format width %d\n", 
snd_pcm_format_width(format));
+               snd_printdd("invalid format width %d\n",
+                           snd_pcm_format_width(format));
                return 0;
        }
 
@@ -1439,7 +1502,7 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, 
hda_nid_t nid,
                if (val == -1)
                        return -EIO;
        }
-       if (! val)
+       if (!val)
                val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
 
        if (ratesp) {
@@ -1460,8 +1523,9 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, 
hda_nid_t nid,
                streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
                if (streams == -1)
                        return -EIO;
-               if (! streams) {
-                       streams = snd_hda_param_read(codec, codec->afg, 
AC_PAR_STREAM);
+               if (!streams) {
+                       streams = snd_hda_param_read(codec, codec->afg,
+                                                    AC_PAR_STREAM);
                        if (streams == -1)
                                return -EIO;
                }
@@ -1485,7 +1549,8 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, 
hda_nid_t nid,
                                        bps = 24;
                                else if (val & AC_SUPPCM_BITS_20)
                                        bps = 20;
-                       } else if (val & 
(AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|AC_SUPPCM_BITS_32)) {
+                       } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
+                                         AC_SUPPCM_BITS_32)) {
                                formats |= SNDRV_PCM_FMTBIT_S32_LE;
                                if (val & AC_SUPPCM_BITS_32)
                                        bps = 32;
@@ -1495,10 +1560,12 @@ int snd_hda_query_supported_pcm(struct hda_codec 
*codec, hda_nid_t nid,
                                        bps = 20;
                        }
                }
-               else if (streams == AC_SUPFMT_FLOAT32) { /* should be exclusive 
*/
+               else if (streams == AC_SUPFMT_FLOAT32) {
+                       /* should be exclusive */
                        formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
                        bps = 32;
-               } else if (streams == AC_SUPFMT_AC3) { /* should be exclusive */
+               } else if (streams == AC_SUPFMT_AC3) {
+                       /* should be exclusive */
                        /* temporary hack: we have still no proper support
                         * for the direct AC3 stream...
                         */
@@ -1515,7 +1582,8 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, 
hda_nid_t nid,
 }
 
 /**
- * snd_hda_is_supported_format - check whether the given node supports the 
format val
+ * snd_hda_is_supported_format - check whether the given node supports
+ * the format val
  *
  * Returns 1 if supported, 0 if not.
  */
@@ -1531,7 +1599,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, 
hda_nid_t nid,
                if (val == -1)
                        return 0;
        }
-       if (! val) {
+       if (!val) {
                val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
                if (val == -1)
                        return 0;
@@ -1550,31 +1618,31 @@ int snd_hda_is_supported_format(struct hda_codec 
*codec, hda_nid_t nid,
        stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
        if (stream == -1)
                return 0;
-       if (! stream && nid != codec->afg)
+       if (!stream && nid != codec->afg)
                stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
-       if (! stream || stream == -1)
+       if (!stream || stream == -1)
                return 0;
 
        if (stream & AC_SUPFMT_PCM) {
                switch (format & 0xf0) {
                case 0x00:
-                       if (! (val & AC_SUPPCM_BITS_8))
+                       if (!(val & AC_SUPPCM_BITS_8))
                                return 0;
                        break;
                case 0x10:
-                       if (! (val & AC_SUPPCM_BITS_16))
+                       if (!(val & AC_SUPPCM_BITS_16))
                                return 0;
                        break;
                case 0x20:
-                       if (! (val & AC_SUPPCM_BITS_20))
+                       if (!(val & AC_SUPPCM_BITS_20))
                                return 0;
                        break;
                case 0x30:
-                       if (! (val & AC_SUPPCM_BITS_24))
+                       if (!(val & AC_SUPPCM_BITS_24))
                                return 0;
                        break;
                case 0x40:
-                       if (! (val & AC_SUPPCM_BITS_32))
+                       if (!(val & AC_SUPPCM_BITS_32))
                                return 0;
                        break;
                default:
@@ -1615,15 +1683,15 @@ static int hda_pcm_default_cleanup(struct 
hda_pcm_stream *hinfo,
        return 0;
 }
 
-static int set_pcm_default_values(struct hda_codec *codec, struct 
hda_pcm_stream *info)
+static int __devinit set_pcm_default_values(struct hda_codec *codec,
+                                           struct hda_pcm_stream *info)
 {
-       if (info->nid) {
-               /* query support PCM information from the given NID */
-               if (! info->rates || ! info->formats)
-                       snd_hda_query_supported_pcm(codec, info->nid,
-                                                   info->rates ? NULL : 
&info->rates,
-                                                   info->formats ? NULL : 
&info->formats,
-                                                   info->maxbps ? NULL : 
&info->maxbps);
+       /* query support PCM information from the given NID */
+       if (info->nid && (!info->rates || !info->formats)) {
+               snd_hda_query_supported_pcm(codec, info->nid,
+                               info->rates ? NULL : &info->rates,
+                               info->formats ? NULL : &info->formats,
+                               info->maxbps ? NULL : &info->maxbps);
        }
        if (info->ops.open == NULL)
                info->ops.open = hda_pcm_default_open_close;
@@ -1668,13 +1736,12 @@ static int set_pcm_default_values(struct hda_codec 
*codec, struct hda_pcm_stream
  */
 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
 {
-       struct list_head *p;
+       struct hda_codec *codec;
 
-       list_for_each(p, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry(codec, &bus->codec_list, list) {
                unsigned int pcm, s;
                int err;
-               if (! codec->patch_ops.build_pcms)
+               if (!codec->patch_ops.build_pcms)
                        continue;
                err = codec->patch_ops.build_pcms(codec);
                if (err < 0)
@@ -1683,7 +1750,7 @@ int __devinit snd_hda_build_pcms(struct hda_bus *bus)
                        for (s = 0; s < 2; s++) {
                                struct hda_pcm_stream *info;
                                info = &codec->pcm_info[pcm].stream[s];
-                               if (! info->substreams)
+                               if (!info->substreams)
                                        continue;
                                err = set_pcm_default_values(codec, info);
                                if (err < 0)
@@ -1767,17 +1834,18 @@ int __devinit snd_hda_add_new_ctls(struct hda_codec 
*codec,
        for (; knew->name; knew++) {
                struct snd_kcontrol *kctl;
                kctl = snd_ctl_new1(knew, codec);
-               if (! kctl)
+               if (!kctl)
                        return -ENOMEM;
                err = snd_ctl_add(codec->bus->card, kctl);
                if (err < 0) {
-                       if (! codec->addr)
+                       if (!codec->addr)
                                return err;
                        kctl = snd_ctl_new1(knew, codec);
-                       if (! kctl)
+                       if (!kctl)
                                return -ENOMEM;
                        kctl->id.device = codec->addr;
-                       if ((err = snd_ctl_add(codec->bus->card, kctl)) < 0)
+                       err = snd_ctl_add(codec->bus->card, kctl);
+                       if (err < 0)
                                return err;
                }
        }
@@ -1788,8 +1856,10 @@ int __devinit snd_hda_add_new_ctls(struct hda_codec 
*codec,
 /*
  * Channel mode helper
  */
-int snd_hda_ch_mode_info(struct hda_codec *codec, struct snd_ctl_elem_info 
*uinfo,
-                        const struct hda_channel_mode *chmode, int num_chmodes)
+int snd_hda_ch_mode_info(struct hda_codec *codec,
+                        struct snd_ctl_elem_info *uinfo,
+                        const struct hda_channel_mode *chmode,
+                        int num_chmodes)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
        uinfo->count = 1;
@@ -1801,8 +1871,10 @@ int snd_hda_ch_mode_info(struct hda_codec *codec, struct 
snd_ctl_elem_info *uinf
        return 0;
 }
 
-int snd_hda_ch_mode_get(struct hda_codec *codec, struct snd_ctl_elem_value 
*ucontrol,
-                       const struct hda_channel_mode *chmode, int num_chmodes,
+int snd_hda_ch_mode_get(struct hda_codec *codec,
+                       struct snd_ctl_elem_value *ucontrol,
+                       const struct hda_channel_mode *chmode,
+                       int num_chmodes,
                        int max_channels)
 {
        int i;
@@ -1816,15 +1888,17 @@ int snd_hda_ch_mode_get(struct hda_codec *codec, struct 
snd_ctl_elem_value *ucon
        return 0;
 }
 
-int snd_hda_ch_mode_put(struct hda_codec *codec, struct snd_ctl_elem_value 
*ucontrol,
-                       const struct hda_channel_mode *chmode, int num_chmodes,
+int snd_hda_ch_mode_put(struct hda_codec *codec,
+                       struct snd_ctl_elem_value *ucontrol,
+                       const struct hda_channel_mode *chmode,
+                       int num_chmodes,
                        int *max_channelsp)
 {
        unsigned int mode;
 
        mode = ucontrol->value.enumerated.item[0];
        snd_assert(mode < num_chmodes, return -EINVAL);
-       if (*max_channelsp == chmode[mode].channels && ! codec->in_resume)
+       if (*max_channelsp == chmode[mode].channels && !codec->in_resume)
                return 0;
        /* change the current channel setting */
        *max_channelsp = chmode[mode].channels;
@@ -1836,7 +1910,8 @@ int snd_hda_ch_mode_put(struct hda_codec *codec, struct 
snd_ctl_elem_value *ucon
 /*
  * input MUX helper
  */
-int snd_hda_input_mux_info(const struct hda_input_mux *imux, struct 
snd_ctl_elem_info *uinfo)
+int snd_hda_input_mux_info(const struct hda_input_mux *imux,
+                          struct snd_ctl_elem_info *uinfo)
 {
        unsigned int index;
 
@@ -1850,8 +1925,10 @@ int snd_hda_input_mux_info(const struct hda_input_mux 
*imux, struct snd_ctl_elem
        return 0;
 }
 
-int snd_hda_input_mux_put(struct hda_codec *codec, const struct hda_input_mux 
*imux,
-                         struct snd_ctl_elem_value *ucontrol, hda_nid_t nid,
+int snd_hda_input_mux_put(struct hda_codec *codec,
+                         const struct hda_input_mux *imux,
+                         struct snd_ctl_elem_value *ucontrol,
+                         hda_nid_t nid,
                          unsigned int *cur_val)
 {
        unsigned int idx;
@@ -1859,7 +1936,7 @@ int snd_hda_input_mux_put(struct hda_codec *codec, const 
struct hda_input_mux *i
        idx = ucontrol->value.enumerated.item[0];
        if (idx >= imux->num_items)
                idx = imux->num_items - 1;
-       if (*cur_val == idx && ! codec->in_resume)
+       if (*cur_val == idx && !codec->in_resume)
                return 0;
        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
                            imux->items[idx].index);
@@ -1890,7 +1967,8 @@ static void setup_dig_out_stream(struct hda_codec *codec, 
hda_nid_t nid,
 /*
  * open the digital out in the exclusive mode
  */
-int snd_hda_multi_out_dig_open(struct hda_codec *codec, struct hda_multi_out 
*mout)
+int snd_hda_multi_out_dig_open(struct hda_codec *codec,
+                              struct hda_multi_out *mout)
 {
        mutex_lock(&codec->spdif_mutex);
        if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
@@ -1916,7 +1994,8 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
 /*
  * release the digital out
  */
-int snd_hda_multi_out_dig_close(struct hda_codec *codec, struct hda_multi_out 
*mout)
+int snd_hda_multi_out_dig_close(struct hda_codec *codec,
+                               struct hda_multi_out *mout)
 {
        mutex_lock(&codec->spdif_mutex);
        mout->dig_out_used = 0;
@@ -1927,7 +2006,8 @@ int snd_hda_multi_out_dig_close(struct hda_codec *codec, 
struct hda_multi_out *m
 /*
  * set up more restrictions for analog out
  */
-int snd_hda_multi_out_analog_open(struct hda_codec *codec, struct 
hda_multi_out *mout,
+int snd_hda_multi_out_analog_open(struct hda_codec *codec,
+                                 struct hda_multi_out *mout,
                                  struct snd_pcm_substream *substream)
 {
        substream->runtime->hw.channels_max = mout->max_channels;
@@ -1939,7 +2019,8 @@ int snd_hda_multi_out_analog_open(struct hda_codec 
*codec, struct hda_multi_out
  * set up the i/o for analog out
  * when the digital out is available, copy the front out to digital out, too.
  */
-int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, struct 
hda_multi_out *mout,
+int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
+                                    struct hda_multi_out *mout,
                                     unsigned int stream_tag,
                                     unsigned int format,
                                     struct snd_pcm_substream *substream)
@@ -1951,23 +2032,27 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec 
*codec, struct hda_multi_o
        mutex_lock(&codec->spdif_mutex);
        if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
                if (chs == 2 &&
-                   snd_hda_is_supported_format(codec, mout->dig_out_nid, 
format) &&
-                   ! (codec->spdif_status & IEC958_AES0_NONAUDIO)) {
+                   snd_hda_is_supported_format(codec, mout->dig_out_nid,
+                                               format) &&
+                   !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
                        mout->dig_out_used = HDA_DIG_ANALOG_DUP;
                        setup_dig_out_stream(codec, mout->dig_out_nid,
                                             stream_tag, format);
                } else {
                        mout->dig_out_used = 0;
-                       snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 0, 
0, 0);
+                       snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
+                                                  0, 0, 0);
                }
        }
        mutex_unlock(&codec->spdif_mutex);
 
        /* front */
-       snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 0, 
format);
+       snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
+                                  0, format);
        if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
                /* headphone out will just decode front left/right (stereo) */
-               snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 0, 
format);
+               snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
+                                          0, format);
        /* extra outputs copied from front */
        for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
                if (mout->extra_out_nid[i])
@@ -1978,11 +2063,11 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec 
*codec, struct hda_multi_o
        /* surrounds */
        for (i = 1; i < mout->num_dacs; i++) {
                if (chs >= (i + 1) * 2) /* independent out */
-                       snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 
i * 2,
-                                                  format);
+                       snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
+                                                  i * 2, format);
                else /* copy front */
-                       snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 
0,
-                                                  format);
+                       snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
+                                                  0, format);
        }
        return 0;
 }
@@ -1990,7 +2075,8 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec 
*codec, struct hda_multi_o
 /*
  * clean up the setting for analog out
  */
-int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, struct 
hda_multi_out *mout)
+int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
+                                    struct hda_multi_out *mout)
 {
        hda_nid_t *nids = mout->dac_nids;
        int i;
@@ -2058,7 +2144,8 @@ int __devinit snd_hda_parse_pin_def_config(struct 
hda_codec *codec,
        nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid_start);
        for (nid = nid_start; nid < nodes + nid_start; nid++) {
                unsigned int wid_caps = get_wcaps(codec, nid);
-               unsigned int wid_type = (wid_caps & AC_WCAP_TYPE) >> 
AC_WCAP_TYPE_SHIFT;
+               unsigned int wid_type =
+                       (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
                unsigned int def_conf;
                short assoc, loc;
 
@@ -2069,7 +2156,8 @@ int __devinit snd_hda_parse_pin_def_config(struct 
hda_codec *codec,
                if (ignore_nids && is_in_nid_list(nid, ignore_nids))
                        continue;
 
-               def_conf = snd_hda_codec_read(codec, nid, 0, 
AC_VERB_GET_CONFIG_DEFAULT, 0);
+               def_conf = snd_hda_codec_read(codec, nid, 0,
+                                             AC_VERB_GET_CONFIG_DEFAULT, 0);
                if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
                        continue;
                loc = get_defcfg_location(def_conf);
@@ -2077,9 +2165,9 @@ int __devinit snd_hda_parse_pin_def_config(struct 
hda_codec *codec,
                case AC_JACK_LINE_OUT:
                        seq = get_defcfg_sequence(def_conf);
                        assoc = get_defcfg_association(def_conf);
-                       if (! assoc)
+                       if (!assoc)
                                continue;
-                       if (! assoc_line_out)
+                       if (!assoc_line_out)
                                assoc_line_out = assoc;
                        else if (assoc_line_out != assoc)
                                continue;
@@ -2198,7 +2286,7 @@ int __devinit snd_hda_parse_pin_def_config(struct 
hda_codec *codec,
         * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
         * as a primary output
         */
-       if (! cfg->line_outs) {
+       if (!cfg->line_outs) {
                if (cfg->speaker_outs) {
                        cfg->line_outs = cfg->speaker_outs;
                        memcpy(cfg->line_out_pins, cfg->speaker_pins,
@@ -2237,11 +2325,10 @@ const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
  */
 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
 {
-       struct list_head *p;
+       struct hda_codec *codec;
 
        /* FIXME: should handle power widget capabilities */
-       list_for_each(p, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry(codec, &bus->codec_list, list) {
                if (codec->patch_ops.suspend)
                        codec->patch_ops.suspend(codec, state);
                hda_set_power_state(codec,
@@ -2260,10 +2347,9 @@ int snd_hda_suspend(struct hda_bus *bus, pm_message_t 
state)
  */
 int snd_hda_resume(struct hda_bus *bus)
 {
-       struct list_head *p;
+       struct hda_codec *codec;
 
-       list_for_each(p, &bus->codec_list) {
-               struct hda_codec *codec = list_entry(p, struct hda_codec, list);
+       list_for_each_entry(codec, &bus->codec_list, list) {
                hda_set_power_state(codec,
                                    codec->afg ? codec->afg : codec->mfg,
                                    AC_PWRST_D0);
@@ -2287,7 +2373,7 @@ int snd_hda_resume_ctls(struct hda_codec *codec, struct 
snd_kcontrol_new *knew)
        struct snd_ctl_elem_value *val;
 
        val = kmalloc(sizeof(*val), GFP_KERNEL);
-       if (! val)
+       if (!val)
                return -ENOMEM;
        codec->in_resume = 1;
        for (; knew->name; knew++) {
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to