[ALSA] alsa core: convert to list_for_each_entry*

This patch converts most uses of list_for_each to list_for_each_entry all
across alsa. In some place apparently an item can be on a list with
different pointers so of course that isn't compatible with list_for_each, I
therefore didn't touch those places.

Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>

4 files changed, 33 insertions, 59 deletions

diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 532a660df51d..bb9dd9fa8e51 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -659,7 +659,6 @@ static int deliver_to_subscribers(struct snd_seq_client *client,
         int err = 0, num_ev = 0;
         struct snd_seq_event event_saved;
         struct snd_seq_client_port *src_port;
-        struct list_head *p;
         struct snd_seq_port_subs_info *grp;
 
         src_port = snd_seq_port_use_ptr(client, event->source.port);
@@ -674,8 +673,7 @@ static int deliver_to_subscribers(struct snd_seq_client *client,
                 read_lock(&grp->list_lock);
         else
                 down_read(&grp->list_mutex);
-        list_for_each(p, &grp->list_head) {
-                subs = list_entry(p, struct snd_seq_subscribers, src_list);
+        list_for_each_entry(subs, &grp->list_head, src_list) {
                 event->dest = subs->info.dest;
                 if (subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP)
                         /* convert time according to flag with subscription */
@@ -709,15 +707,14 @@ static int port_broadcast_event(struct snd_seq_client *client,
 {
         int num_ev = 0, err = 0;
         struct snd_seq_client *dest_client;
-        struct list_head *p;
+        struct snd_seq_client_port *port;
 
         dest_client = get_event_dest_client(event, SNDRV_SEQ_FILTER_BROADCAST);
         if (dest_client == NULL)
                 return 0; /* no matching destination */
 
         read_lock(&dest_client->ports_lock);
-        list_for_each(p, &dest_client->ports_list_head) {
-                struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list);
+        list_for_each_entry(port, &dest_client->ports_list_head, list) {
                 event->dest.port = port->addr.port;
                 /* pass NULL as source client to avoid error bounce */
                 err = snd_seq_deliver_single_event(NULL, event,
@@ -2473,11 +2470,10 @@ static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer,
 static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer,
                                     struct snd_seq_client *client)
 {
-        struct list_head *l;
+        struct snd_seq_client_port *p;
 
         mutex_lock(&client->ports_mutex);
-        list_for_each(l, &client->ports_list_head) {
-                struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list);
+        list_for_each_entry(p, &client->ports_list_head, list) {
                 snd_iprintf(buffer, "  Port %3d : \"%s\" (%c%c%c%c)\n",
                             p->addr.port, p->name,
                             FLAG_PERM_RD(p->capability),
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index b79d011813c0..37852cdace76 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -106,11 +106,10 @@ static void remove_drivers(void);
 static void snd_seq_device_info(struct snd_info_entry *entry,
                                 struct snd_info_buffer *buffer)
 {
-        struct list_head *head;
+        struct ops_list *ops;
 
         mutex_lock(&ops_mutex);
-        list_for_each(head, &opslist) {
-                struct ops_list *ops = list_entry(head, struct ops_list, list);
+        list_for_each_entry(ops, &opslist, list) {
                 snd_iprintf(buffer, "snd-%s%s%s%s,%d\n",
                                 ops->id,
                                 ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""),
@@ -143,7 +142,7 @@ void snd_seq_autoload_unlock(void)
 void snd_seq_device_load_drivers(void)
 {
 #ifdef CONFIG_KMOD
-        struct list_head *head;
+        struct ops_list *ops;
 
         /* Calling request_module during module_init()
          * may cause blocking.
@@ -155,8 +154,7 @@ void snd_seq_device_load_drivers(void)
                 return;
 
         mutex_lock(&ops_mutex);
-        list_for_each(head, &opslist) {
-                struct ops_list *ops = list_entry(head, struct ops_list, list);
+        list_for_each_entry(ops, &opslist, list) {
                 if (! (ops->driver & DRIVER_LOADED) &&
                     ! (ops->driver & DRIVER_REQUESTED)) {
                         ops->used++;
@@ -314,8 +312,8 @@ static int snd_seq_device_dev_disconnect(struct snd_device *device)
 int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
                                    int argsize)
 {
-        struct list_head *head;
         struct ops_list *ops;
+        struct snd_seq_device *dev;
 
         if (id == NULL || entry == NULL ||
             entry->init_device == NULL || entry->free_device == NULL)
@@ -341,8 +339,7 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
         ops->argsize = argsize;
 
         /* initialize existing devices if necessary */
-        list_for_each(head, &ops->dev_list) {
-                struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
+        list_for_each_entry(dev, &ops->dev_list, list) {
                 init_device(dev, ops);
         }
         mutex_unlock(&ops->reg_mutex);
@@ -394,8 +391,8 @@ static struct ops_list * create_driver(char *id)
  */
 int snd_seq_device_unregister_driver(char *id)
 {
-        struct list_head *head;
         struct ops_list *ops;
+        struct snd_seq_device *dev;
 
         ops = find_driver(id, 0);
         if (ops == NULL)
@@ -411,8 +408,7 @@ int snd_seq_device_unregister_driver(char *id)
         /* close and release all devices associated with this driver */
         mutex_lock(&ops->reg_mutex);
         ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */
-        list_for_each(head, &ops->dev_list) {
-                struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
+        list_for_each_entry(dev, &ops->dev_list, list) {
                 free_device(dev, ops);
         }
 
@@ -512,11 +508,10 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
  */
 static struct ops_list * find_driver(char *id, int create_if_empty)
 {
-        struct list_head *head;
+        struct ops_list *ops;
 
         mutex_lock(&ops_mutex);
-        list_for_each(head, &opslist) {
-                struct ops_list *ops = list_entry(head, struct ops_list, list);
+        list_for_each_entry(ops, &opslist, list) {
                 if (strcmp(ops->id, id) == 0) {
                         ops->used++;
                         mutex_unlock(&ops_mutex);
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 8c64b58ff77b..d88153438d69 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -59,14 +59,12 @@ much elements are in array.
 struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
                                                  int num)
 {
-        struct list_head *p;
         struct snd_seq_client_port *port;
 
         if (client == NULL)
                 return NULL;
         read_lock(&client->ports_lock);
-        list_for_each(p, &client->ports_list_head) {
-                port = list_entry(p, struct snd_seq_client_port, list);
+        list_for_each_entry(port, &client->ports_list_head, list) {
                 if (port->addr.port == num) {
                         if (port->closing)
                                 break; /* deleting now */
@@ -85,14 +83,12 @@ struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *cl
                                                        struct snd_seq_port_info *pinfo)
 {
         int num;
-        struct list_head *p;
         struct snd_seq_client_port *port, *found;
 
         num = pinfo->addr.port;
         found = NULL;
         read_lock(&client->ports_lock);
-        list_for_each(p, &client->ports_list_head) {
-                port = list_entry(p, struct snd_seq_client_port, list);
+        list_for_each_entry(port, &client->ports_list_head, list) {
                 if (port->addr.port < num)
                         continue;
                 if (port->addr.port == num) {
@@ -131,8 +127,7 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
                                                 int port)
 {
         unsigned long flags;
-        struct snd_seq_client_port *new_port;
-        struct list_head *l;
+        struct snd_seq_client_port *new_port, *p;
         int num = -1;
         
         /* sanity check */
@@ -161,15 +156,14 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
         num = port >= 0 ? port : 0;
         mutex_lock(&client->ports_mutex);
         write_lock_irqsave(&client->ports_lock, flags);
-        list_for_each(l, &client->ports_list_head) {
-                struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list);
+        list_for_each_entry(p, &client->ports_list_head, list) {
                 if (p->addr.port > num)
                         break;
                 if (port < 0) /* auto-probe mode */
                         num = p->addr.port + 1;
         }
         /* insert the new port */
-        list_add_tail(&new_port->list, l);
+        list_add_tail(&new_port->list, &p->list);
         client->num_ports++;
         new_port->addr.port = num;      /* store the port number in the port */
         write_unlock_irqrestore(&client->ports_lock, flags);
@@ -287,16 +281,14 @@ static int port_delete(struct snd_seq_client *client,
 int snd_seq_delete_port(struct snd_seq_client *client, int port)
 {
         unsigned long flags;
-        struct list_head *l;
-        struct snd_seq_client_port *found = NULL;
+        struct snd_seq_client_port *found = NULL, *p;
 
         mutex_lock(&client->ports_mutex);
         write_lock_irqsave(&client->ports_lock, flags);
-        list_for_each(l, &client->ports_list_head) {
-                struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list);
+        list_for_each_entry(p, &client->ports_list_head, list) {
                 if (p->addr.port == port) {
                         /* ok found.  delete from the list at first */
-                        list_del(l);
+                        list_del(&p->list);
                         client->num_ports--;
                         found = p;
                         break;
@@ -314,7 +306,8 @@ int snd_seq_delete_port(struct snd_seq_client *client, int port)
 int snd_seq_delete_all_ports(struct snd_seq_client *client)
 {
         unsigned long flags;
-        struct list_head deleted_list, *p, *n;
+        struct list_head deleted_list;
+        struct snd_seq_client_port *port, *tmp;
         
         /* move the port list to deleted_list, and
          * clear the port list in the client data.
@@ -331,9 +324,8 @@ int snd_seq_delete_all_ports(struct snd_seq_client *client)
         write_unlock_irqrestore(&client->ports_lock, flags);
 
         /* remove each port in deleted_list */
-        list_for_each_safe(p, n, &deleted_list) {
-                struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list);
-                list_del(p);
+        list_for_each_entry_safe(port, tmp, &deleted_list, list) {
+                list_del(&port->list);
                 snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
                 port_delete(client, port);
         }
@@ -500,8 +492,7 @@ int snd_seq_port_connect(struct snd_seq_client *connector,
 {
         struct snd_seq_port_subs_info *src = &src_port->c_src;
         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
-        struct snd_seq_subscribers *subs;
-        struct list_head *p;
+        struct snd_seq_subscribers *subs, *s;
         int err, src_called = 0;
         unsigned long flags;
         int exclusive;
@@ -525,13 +516,11 @@ int snd_seq_port_connect(struct snd_seq_client *connector,
                 if (src->exclusive || dest->exclusive)
                         goto __error;
                 /* check whether already exists */
-                list_for_each(p, &src->list_head) {
-                        struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, src_list);
+                list_for_each_entry(s, &src->list_head, src_list) {
                         if (match_subs_info(info, &s->info))
                                 goto __error;
                 }
-                list_for_each(p, &dest->list_head) {
-                        struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, dest_list);
+                list_for_each_entry(s, &dest->list_head, dest_list) {
                         if (match_subs_info(info, &s->info))
                                 goto __error;
                 }
@@ -582,7 +571,6 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector,
         struct snd_seq_port_subs_info *src = &src_port->c_src;
         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
         struct snd_seq_subscribers *subs;
-        struct list_head *p;
         int err = -ENOENT;
         unsigned long flags;
 
@@ -590,8 +578,7 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector,
         down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
 
         /* look for the connection */
-        list_for_each(p, &src->list_head) {
-                subs = list_entry(p, struct snd_seq_subscribers, src_list);
+        list_for_each_entry(subs, &src->list_head, src_list) {
                 if (match_subs_info(info, &subs->info)) {
                         write_lock_irqsave(&src->list_lock, flags);
                         // write_lock(&dest->list_lock);  // no lock yet
@@ -620,12 +607,10 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector,
 struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
                                                           struct snd_seq_addr *dest_addr)
 {
-        struct list_head *p;
         struct snd_seq_subscribers *s, *found = NULL;
 
         down_read(&src_grp->list_mutex);
-        list_for_each(p, &src_grp->list_head) {
-                s = list_entry(p, struct snd_seq_subscribers, src_list);
+        list_for_each_entry(s, &src_grp->list_head, src_list) {
                 if (addr_match(dest_addr, &s->info.dest)) {
                         found = s;
                         break;
diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c
index 0cfa06c6b81f..972f93405364 100644
--- a/sound/core/seq/seq_virmidi.c
+++ b/sound/core/seq/seq_virmidi.c
@@ -81,13 +81,11 @@ static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev,
                                          struct snd_seq_event *ev)
 {
         struct snd_virmidi *vmidi;
-        struct list_head *list;
         unsigned char msg[4];
         int len;
 
         read_lock(&rdev->filelist_lock);
-        list_for_each(list, &rdev->filelist) {
-                vmidi = list_entry(list, struct snd_virmidi, list);
+        list_for_each_entry(vmidi, &rdev->filelist, list) {
                 if (!vmidi->trigger)
                         continue;
                 if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {