[ALSA] hda-codec - Code clean up

Trivial code clean-ups to follow the standard coding styles.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>

1 files changed, 276 insertions, 190 deletions

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index fe4acfa9e4e6..2fdd1652bad3 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++) {