@@ -245,7 +245,7 @@ int pt_core_init(struct pt_device *pt)
iowrite32(CMD_CONFIG_REQID, pt->io_regs + CMD_REQID_CONFIG_OFFSET);
/* Allocate a dma pool for the queue */
- snprintf(dma_pool_name, sizeof(dma_pool_name), "pt_q");
+ snprintf(dma_pool_name, sizeof(dma_pool_name), "%s_q", pt->name);
dma_pool = dma_pool_create(dma_pool_name, dev,
PT_DMAPOOL_MAX_SIZE,
PT_DMAPOOL_ALIGN, 0);
@@ -311,7 +311,7 @@ int pt_core_init(struct pt_device *pt)
dev_dbg(dev, "Requesting an IRQ...\n");
/* Request an irq */
- ret = request_irq(pt->pt_irq, pt_core_irq_handler, 0, "pt", pt);
+ ret = request_irq(pt->pt_irq, pt_core_irq_handler, 0, pt->name, pt);
if (ret) {
dev_err(dev, "unable to allocate an IRQ\n");
goto e_pool;
@@ -338,7 +338,8 @@ int pt_core_init(struct pt_device *pt)
dev_dbg(dev, "Starting threads...\n");
/* Create a kthread for command queue */
- kthread = kthread_create(pt_cmd_queue_thread, cmd_q, "pt-q");
+ kthread = kthread_create(pt_cmd_queue_thread, cmd_q,
+ "%s-q", pt->name);
if (IS_ERR(kthread)) {
dev_err(dev, "error creating queue thread (%ld)\n",
PTR_ERR(kthread));
@@ -20,13 +20,16 @@
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
+#include <linux/spinlock_types.h>
+#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/cpu.h>
#include "ptdma.h"
-static struct pt_device *pt_dev;
+/* Ever-increasing value to produce unique unit numbers */
+static atomic_t pt_ordinal;
struct pt_tasklet_data {
struct completion completion;
@@ -63,24 +66,105 @@ static char *pt_error_codes[] = {
"ERR 43: LSB_PARITY_ERR",
};
-static inline struct pt_device *pt_get_device(void)
+void pt_log_error(struct pt_device *d, int e)
{
- return pt_dev;
+ dev_err(d->dev, "PTDMA error: %s (0x%x)\n", pt_error_codes[e], e);
}
+/* List of PTDMAs, PTDMA count, read-write access lock, and access functions
+ *
+ * Lock structure: get pt_unit_lock for reading whenever we need to
+ * examine the PTDMA list. While holding it for reading we can acquire
+ * the RR lock to update the round-robin next-PTDMA pointer. The unit lock
+ * must be acquired before the RR lock.
+ *
+ * If the unit-lock is acquired for writing, we have total control over
+ * the list, so there's no value in getting the RR lock.
+ */
+static DEFINE_RWLOCK(pt_unit_lock);
+static LIST_HEAD(pt_units);
+
+/* Round-robin counter */
+static DEFINE_SPINLOCK(pt_rr_lock);
+static struct pt_device *pt_rr;
+
+/*
+ * pt_add_device - add a PTDMA device to the list
+ *
+ * @pt: pt_device struct pointer
+ *
+ * Put this PTDMA on the unit list, which makes it available
+ * for use.
+ *
+ * Returns zero if a PTDMA device is present, -ENODEV otherwise.
+ */
void pt_add_device(struct pt_device *pt)
{
- pt_dev = pt;
+ unsigned long flags;
+
+ write_lock_irqsave(&pt_unit_lock, flags);
+ list_add_tail(&pt->entry, &pt_units);
+ if (!pt_rr)
+ /* We already have the list lock (we're first) so this
+ * pointer can't change on us. Set its initial value.
+ */
+ pt_rr = pt;
+ write_unlock_irqrestore(&pt_unit_lock, flags);
}
+/*
+ * pt_del_device - remove a PTDMA device from the list
+ *
+ * @pt: pt_device struct pointer
+ *
+ * Remove this unit from the list of devices. If the next device
+ * up for use is this one, adjust the pointer. If this is the last
+ * device, NULL the pointer.
+ */
void pt_del_device(struct pt_device *pt)
{
- pt_dev = NULL;
+ unsigned long flags;
+
+ write_lock_irqsave(&pt_unit_lock, flags);
+ if (pt_rr == pt) {
+ /* pt_unit_lock is read/write; any read access
+ * will be suspended while we make changes to the
+ * list and RR pointer.
+ */
+ if (list_is_last(&pt_rr->entry, &pt_units))
+ pt_rr = list_first_entry(&pt_units, struct pt_device,
+ entry);
+ else
+ pt_rr = list_next_entry(pt_rr, entry);
+ }
+ list_del(&pt->entry);
+ if (list_empty(&pt_units))
+ pt_rr = NULL;
+ write_unlock_irqrestore(&pt_unit_lock, flags);
}
-void pt_log_error(struct pt_device *d, int e)
+static struct pt_device *pt_get_device(void)
{
- dev_err(d->dev, "PTDMA error: %s (0x%x)\n", pt_error_codes[e], e);
+ unsigned long flags;
+ struct pt_device *dp = NULL;
+
+ /* We round-robin through the unit list.
+ * The (pt_rr) pointer refers to the next unit to use.
+ */
+ read_lock_irqsave(&pt_unit_lock, flags);
+ if (!list_empty(&pt_units)) {
+ spin_lock(&pt_rr_lock);
+ dp = pt_rr;
+ if (list_is_last(&pt_rr->entry, &pt_units))
+ pt_rr = list_first_entry(&pt_units, struct pt_device,
+ entry);
+ else
+ pt_rr = list_next_entry(pt_rr, entry);
+ spin_unlock(&pt_rr_lock);
+ }
+ read_unlock_irqrestore(&pt_unit_lock, flags);
+
+ return dp;
}
/*
@@ -90,10 +174,14 @@ void pt_log_error(struct pt_device *d, int e)
*/
int pt_present(void)
{
- if (pt_get_device())
- return 0;
+ unsigned long flags;
+ int ret;
+
+ read_lock_irqsave(&pt_unit_lock, flags);
+ ret = list_empty(&pt_units);
+ read_unlock_irqrestore(&pt_unit_lock, flags);
- return -ENODEV;
+ return ret ? -ENODEV : 0;
}
/*
@@ -286,6 +374,7 @@ struct pt_device *pt_alloc_struct(struct device *dev)
if (!pt)
return NULL;
pt->dev = dev;
+ pt->ord = atomic_inc_return(&pt_ordinal);
INIT_LIST_HEAD(&pt->cmd);
INIT_LIST_HEAD(&pt->backlog);
@@ -298,6 +387,8 @@ struct pt_device *pt_alloc_struct(struct device *dev)
init_waitqueue_head(&pt->lsb_queue);
init_waitqueue_head(&pt->suspend_queue);
+ snprintf(pt->name, MAX_PT_NAME_LEN, "pt-%u", pt->ord);
+
return pt;
}
@@ -26,6 +26,7 @@
#include <linux/wait.h>
#include <linux/dmapool.h>
+#define MAX_PT_NAME_LEN 16
#define MAX_DMAPOOL_NAME_LEN 32
#define MAX_HW_QUEUES 1
@@ -280,7 +281,11 @@ struct pt_cmd_queue {
} ____cacheline_aligned;
struct pt_device {
+ struct list_head entry;
+
unsigned int version;
+ unsigned int ord;
+ char name[MAX_PT_NAME_LEN];
struct device *dev;