rt2x00: Rename queue->lock to queue->index_lock

The queue->lock is only used to protect the index
numbers. Rename the lock accordingly.

Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Acked-by: Gertjan van Wingerde <gwingerde@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

diff --git a/drivers/net/wireless/rt2x00/rt2x00debug.c b/drivers/net/wireless/rt2x00/rt2x00debug.c
index 8296a9d47bbdc369c191c7117f230a2bedebbf40..64dfb1f6823ed9b6cfc0272e6700687df82b6ce6 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00debug.c
+++ b/drivers/net/wireless/rt2x00/rt2x00debug.c
@@ -342,7 +342,7 @@ static ssize_t rt2x00debug_read_queue_stats(struct file *file,
            sprintf(data, "qid\tcount\tlimit\tlength\tindex\tdma done\tdone\n");
 
        queue_for_each(intf->rt2x00dev, queue) {
-               spin_lock_irqsave(&queue->lock, irqflags);
+               spin_lock_irqsave(&queue->index_lock, irqflags);
 
                temp += sprintf(temp, "%d\t%d\t%d\t%d\t%d\t%d\t%d\n", queue->qid,
                                queue->count, queue->limit, queue->length,
@@ -350,7 +350,7 @@ static ssize_t rt2x00debug_read_queue_stats(struct file *file,
                                queue->index[Q_INDEX_DMA_DONE],
                                queue->index[Q_INDEX_DONE]);
 
-               spin_unlock_irqrestore(&queue->lock, irqflags);
+               spin_unlock_irqrestore(&queue->index_lock, irqflags);
        }
 
        size = strlen(data);

diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.c b/drivers/net/wireless/rt2x00/rt2x00queue.c
index 32d6a17d5aa0c3541b95a76b757d39b56e8cf2b4..aa4c8f2dc7df3235060bad1d6f3d6ca72e3ccb1c 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00queue.c
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
@@ -641,10 +641,10 @@ void rt2x00queue_for_each_entry(struct data_queue *queue,
         * it should not be kicked during this run, since it
         * is part of another TX operation.
         */
-       spin_lock_irqsave(&queue->lock, irqflags);
+       spin_lock_irqsave(&queue->index_lock, irqflags);
        index_start = queue->index[start];
        index_end = queue->index[end];
-       spin_unlock_irqrestore(&queue->lock, irqflags);
+       spin_unlock_irqrestore(&queue->index_lock, irqflags);
 
        /*
         * Start from the TX done pointer, this guarentees that we will
@@ -698,11 +698,11 @@ struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
                return NULL;
        }
 
-       spin_lock_irqsave(&queue->lock, irqflags);
+       spin_lock_irqsave(&queue->index_lock, irqflags);
 
        entry = &queue->entries[queue->index[index]];
 
-       spin_unlock_irqrestore(&queue->lock, irqflags);
+       spin_unlock_irqrestore(&queue->index_lock, irqflags);
 
        return entry;
 }
@@ -718,7 +718,7 @@ void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index)
                return;
        }
 
-       spin_lock_irqsave(&queue->lock, irqflags);
+       spin_lock_irqsave(&queue->index_lock, irqflags);
 
        queue->index[index]++;
        if (queue->index[index] >= queue->limit)
@@ -733,7 +733,7 @@ void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index)
                queue->count++;
        }
 
-       spin_unlock_irqrestore(&queue->lock, irqflags);
+       spin_unlock_irqrestore(&queue->index_lock, irqflags);
 }
 
 static void rt2x00queue_reset(struct data_queue *queue)
@@ -741,7 +741,7 @@ static void rt2x00queue_reset(struct data_queue *queue)
        unsigned long irqflags;
        unsigned int i;
 
-       spin_lock_irqsave(&queue->lock, irqflags);
+       spin_lock_irqsave(&queue->index_lock, irqflags);
 
        queue->count = 0;
        queue->length = 0;
@@ -751,7 +751,7 @@ static void rt2x00queue_reset(struct data_queue *queue)
                queue->last_action[i] = jiffies;
        }
 
-       spin_unlock_irqrestore(&queue->lock, irqflags);
+       spin_unlock_irqrestore(&queue->index_lock, irqflags);
 }
 
 void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev)
@@ -903,7 +903,7 @@ void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev)
 static void rt2x00queue_init(struct rt2x00_dev *rt2x00dev,
                             struct data_queue *queue, enum data_queue_qid qid)
 {
-       spin_lock_init(&queue->lock);
+       spin_lock_init(&queue->index_lock);
 
        queue->rt2x00dev = rt2x00dev;
        queue->qid = qid;

diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.h b/drivers/net/wireless/rt2x00/rt2x00queue.h
index 64c00e2ab716d6a82fd68bc7346b4163475c352f..29b051ac64012461b48d33a9f557bdf0c2897cd9 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00queue.h
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h
@@ -398,7 +398,7 @@ enum queue_index {
  * @entries: Base address of the &struct queue_entry which are
  *     part of this queue.
  * @qid: The queue identification, see &enum data_queue_qid.
- * @lock: Spinlock to protect index handling. Whenever @index, @index_done or
+ * @index_lock: Spinlock to protect index handling. Whenever @index, @index_done or
  *     @index_crypt needs to be changed this lock should be grabbed to prevent
  *     index corruption due to concurrency.
  * @count: Number of frames handled in the queue.
@@ -422,7 +422,7 @@ struct data_queue {
 
        enum data_queue_qid qid;
 
-       spinlock_t lock;
+       spinlock_t index_lock;
        unsigned int count;
        unsigned short limit;
        unsigned short threshold;