fsl_usdpaa: Add userspace DPAA resource management driver

Signed-off-by: Geoff Thorpe <Geoff.Thorpe@freescale.com>
Signed-off-by: Hai-Ying Wang <Haiying.Wang@freescale.com>
Signed-off-by: Emil Medve <Emilian.Medve@Freescale.com>

3 files changed, 728 insertions, 9 deletions

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index b151b7c..0e7d531 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -56,7 +56,7 @@ config ATMEL_PWM
 	depends on HAVE_CLK
 	help
 	  This option enables device driver support for the PWM channels
-	  on certain Atmel processors.  Pulse Width Modulation is used for
+	  on certain Atmel processors.	Pulse Width Modulation is used for
 	  purposes including software controlled power-efficient backlights
 	  on LCD displays, motor control, and waveform generation.
 
@@ -211,6 +211,23 @@ config ENCLOSURE_SERVICES
 	  driver (SCSI/ATA) which supports enclosures
 	  or a SCSI enclosure device (SES) to use these services.
 
+config FSL_USDPAA
+	bool "Freescale USDPAA process driver"
+	depends on FSL_DPA
+	default y
+	help
+	  This driver provides user-space access to kernel-managed
+	  resource interfaces for USDPAA applications, on the assumption
+	  that each process will open this device once. Specifically, this
+	  device exposes functionality that would be awkward if exposed
+	  via the portal devices - ie. this device exposes functionality
+	  that is inherently process-wide rather than portal-specific.
+	  This device is necessary for obtaining access to DMA memory and
+	  for allocation of Qman and Bman resources. In short, if you wish
+	  to use USDPAA applications, you need this.
+
+	  If unsure, say Y.
+
 config SGI_XP
 	tristate "Support communication between SGI SSIs"
 	depends on NET
@@ -346,14 +363,14 @@ config SENSORS_BH1780
 	  will be called bh1780gli.
 
 config SENSORS_BH1770
-         tristate "BH1770GLC / SFH7770 combined ALS - Proximity sensor"
-         depends on I2C
-         ---help---
-           Say Y here if you want to build a driver for BH1770GLC (ROHM) or
+	 tristate "BH1770GLC / SFH7770 combined ALS - Proximity sensor"
+	 depends on I2C
+	 ---help---
+	   Say Y here if you want to build a driver for BH1770GLC (ROHM) or
 	   SFH7770 (Osram) combined ambient light and proximity sensor chip.
 
-           To compile this driver as a module, choose M here: the
-           module will be called bh1770glc. If unsure, say N here.
+	   To compile this driver as a module, choose M here: the
+	   module will be called bh1770glc. If unsure, say N here.
 
 config SENSORS_APDS990X
 	 tristate "APDS990X combined als and proximity sensors"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 2129377..6a92bc9 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -15,14 +15,15 @@ obj-$(CONFIG_BMP085_I2C)	+= bmp085-i2c.o
 obj-$(CONFIG_BMP085_SPI)	+= bmp085-spi.o
 obj-$(CONFIG_ICS932S401)	+= ics932s401.o
 obj-$(CONFIG_LKDTM)		+= lkdtm.o
-obj-$(CONFIG_TIFM_CORE)       	+= tifm_core.o
-obj-$(CONFIG_TIFM_7XX1)       	+= tifm_7xx1.o
+obj-$(CONFIG_TIFM_CORE)		+= tifm_core.o
+obj-$(CONFIG_TIFM_7XX1)		+= tifm_7xx1.o
 obj-$(CONFIG_PHANTOM)		+= phantom.o
 obj-$(CONFIG_SENSORS_BH1780)	+= bh1780gli.o
 obj-$(CONFIG_SENSORS_BH1770)	+= bh1770glc.o
 obj-$(CONFIG_SENSORS_APDS990X)	+= apds990x.o
 obj-$(CONFIG_SGI_IOC4)		+= ioc4.o
 obj-$(CONFIG_ENCLOSURE_SERVICES) += enclosure.o
+obj-$(CONFIG_FSL_USDPAA)	+= fsl_usdpaa.o
 obj-$(CONFIG_KGDB_TESTS)	+= kgdbts.o
 obj-$(CONFIG_SGI_XP)		+= sgi-xp/
 obj-$(CONFIG_SGI_GRU)		+= sgi-gru/
diff --git a/drivers/misc/fsl_usdpaa.c b/drivers/misc/fsl_usdpaa.c
new file mode 100644
index 0000000..206d3ee
--- /dev/null
+++ b/drivers/misc/fsl_usdpaa.c
@@ -0,0 +1,701 @@
+/* Copyright (C) 2008-2012 Freescale Semiconductor, Inc.
+ * Authors: Andy Fleming <afleming@freescale.com>
+ *	    Timur Tabi <timur@freescale.com>
+ *	    Geoff Thorpe <Geoff.Thorpe@freescale.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2.  This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#include <linux/fsl_usdpaa.h>
+#include <linux/fsl_qman.h>
+#include <linux/fsl_bman.h>
+
+#include <linux/module.h>
+#include <linux/miscdevice.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/mm.h>
+#include <linux/of.h>
+#include <linux/memblock.h>
+#include <linux/slab.h>
+
+/* Physical address range of the memory reservation, exported for mm/mem.c */
+static u64 phys_start;
+static u64 phys_size;
+/* PFN versions of the above */
+static unsigned long pfn_start;
+static unsigned long pfn_size;
+
+/* Memory reservations are manipulated under this spinlock (which is why 'refs'
+ * isn't atomic_t). */
+static DEFINE_SPINLOCK(mem_lock);
+
+/* The range of TLB1 indices */
+static unsigned int first_tlb;
+static unsigned int num_tlb;
+static unsigned int current_tlb; /* loops around for fault handling */
+
+/* Memory reservation is represented as a list of 'mem_fragment's, some of which
+ * may be mapped. Unmapped fragments are always merged where possible. */
+static LIST_HEAD(mem_list);
+
+struct mem_mapping;
+
+/* Memory fragments are in 'mem_list'. */
+struct mem_fragment {
+	u64 base;
+	u64 len;
+	unsigned long pfn_base; /* PFN version of 'base' */
+	unsigned long pfn_len; /* PFN version of 'len' */
+	unsigned int refs; /* zero if unmapped */
+	struct list_head list;
+	/* if mapped, flags+name captured at creation time */
+	u32 flags;
+	char name[USDPAA_DMA_NAME_MAX];
+	/* support multi-process locks per-memory-fragment. */
+	int has_locking;
+	wait_queue_head_t wq;
+	struct mem_mapping *owner;
+};
+
+/* Mappings of memory fragments in 'struct ctx'. These are created from
+ * ioctl(USDPAA_IOCTL_DMA_MAP), though the actual mapping then happens via a
+ * mmap(). */
+struct mem_mapping {
+	struct mem_fragment *frag;
+	struct list_head list;
+};
+
+/* Per-FD state (which should also be per-process but we don't enforce that) */
+struct ctx {
+	/* Allocated resources get put here for accounting */
+	struct dpa_alloc ids[usdpaa_id_max];
+	struct list_head maps;
+};
+
+/* Different resource classes */
+static const struct alloc_backend {
+	enum usdpaa_id_type id_type;
+	int (*alloc)(u32 *, u32, u32, int);
+	void (*release)(u32 base, unsigned int count);
+	const char *acronym;
+} alloc_backends[] = {
+	{
+		.id_type = usdpaa_id_fqid,
+		.alloc = qman_alloc_fqid_range,
+		.release = qman_release_fqid_range,
+		.acronym = "FQID"
+	},
+	{
+		.id_type = usdpaa_id_bpid,
+		.alloc = bman_alloc_bpid_range,
+		.release = bman_release_bpid_range,
+		.acronym = "BPID"
+	},
+	{
+		.id_type = usdpaa_id_qpool,
+		.alloc = qman_alloc_pool_range,
+		.release = qman_release_pool_range,
+		.acronym = "QPOOL"
+	},
+	{
+		.id_type = usdpaa_id_cgrid,
+		.alloc = qman_alloc_cgrid_range,
+		.release = qman_release_cgrid_range,
+		.acronym = "CGRID"
+	},
+	{
+		.id_type = usdpaa_id_ceetm0_lfqid,
+		.alloc = qman_alloc_ceetm0_lfqid_range,
+		.release = qman_release_ceetm0_lfqid_range,
+		.acronym = "CEETM0_LFQID"
+	},
+	{
+		.id_type = usdpaa_id_ceetm0_channelid,
+		.alloc = qman_alloc_ceetm0_channel_range,
+		.release = qman_release_ceetm0_channel_range,
+		.acronym = "CEETM0_CHANNELID"
+	},
+	{
+		.id_type = usdpaa_id_ceetm1_lfqid,
+		.alloc = qman_alloc_ceetm1_lfqid_range,
+		.release = qman_release_ceetm1_lfqid_range,
+		.acronym = "CEETM1_LFQID"
+	},
+	{
+		.id_type = usdpaa_id_ceetm1_channelid,
+		.alloc = qman_alloc_ceetm1_channel_range,
+		.release = qman_release_ceetm1_channel_range,
+		.acronym = "CEETM1_CHANNELID"
+	},
+	{
+		/* This terminates the array */
+		.id_type = usdpaa_id_max
+	}
+};
+
+/* Helper for ioctl_dma_map() when we have a larger fragment than we need. This
+ * splits the fragment into 4 and returns the upper-most. (The caller can loop
+ * until it has a suitable fragment size.) */
+static struct mem_fragment *split_frag(struct mem_fragment *frag)
+{
+	struct mem_fragment *x[3];
+	x[0] = kmalloc(sizeof(struct mem_fragment), GFP_KERNEL);
+	x[1] = kmalloc(sizeof(struct mem_fragment), GFP_KERNEL);
+	x[2] = kmalloc(sizeof(struct mem_fragment), GFP_KERNEL);
+	if (!x[0] || !x[1] || !x[2]) {
+		kfree(x[0]);
+		kfree(x[1]);
+		kfree(x[2]);
+		return NULL;
+	}
+	BUG_ON(frag->refs);
+	frag->len >>= 2;
+	frag->pfn_len >>= 2;
+	x[0]->base = frag->base + frag->len;
+	x[1]->base = x[0]->base + frag->len;
+	x[2]->base = x[1]->base + frag->len;
+	x[0]->len = x[1]->len = x[2]->len = frag->len;
+	x[0]->pfn_base = frag->pfn_base + frag->pfn_len;
+	x[1]->pfn_base = x[0]->pfn_base + frag->pfn_len;
+	x[2]->pfn_base = x[1]->pfn_base + frag->pfn_len;
+	x[0]->pfn_len = x[1]->pfn_len = x[2]->pfn_len = frag->pfn_len;
+	x[0]->refs = x[1]->refs = x[2]->refs = 0;
+	list_add(&x[0]->list, &frag->list);
+	list_add(&x[1]->list, &x[0]->list);
+	list_add(&x[2]->list, &x[1]->list);
+	return x[2];
+}
+
+/* Conversely, when a fragment is released we look to see whether its
+ * similarly-split siblings are free to be reassembled. */
+static struct mem_fragment *merge_frag(struct mem_fragment *frag)
+{
+	/* If this fragment can be merged with its siblings, it will have
+	 * newbase and newlen as its geometry. */
+	uint64_t newlen = frag->len << 2;
+	uint64_t newbase = frag->base & ~(newlen - 1);
+	struct mem_fragment *tmp, *leftmost = frag, *rightmost = frag;
+	/* Scan left until we find the start */
+	tmp = list_entry(frag->list.prev, struct mem_fragment, list);
+	while ((&tmp->list != &mem_list) && (tmp->base >= newbase)) {
+		if (tmp->refs)
+			return NULL;
+		if (tmp->len != tmp->len)
+			return NULL;
+		leftmost = tmp;
+		tmp = list_entry(tmp->list.prev, struct mem_fragment, list);
+	}
+	/* Scan right until we find the end */
+	tmp = list_entry(frag->list.next, struct mem_fragment, list);
+	while ((&tmp->list != &mem_list) && (tmp->base < (newbase + newlen))) {
+		if (tmp->refs)
+			return NULL;
+		if (tmp->len != tmp->len)
+			return NULL;
+		rightmost = tmp;
+		tmp = list_entry(tmp->list.next, struct mem_fragment, list);
+	}
+	if (leftmost == rightmost)
+		return NULL;
+	/* OK, we can merge */
+	frag = leftmost;
+	frag->len = newlen;
+	frag->pfn_len = newlen >> PAGE_SHIFT;
+	while (1) {
+		int lastone;
+		tmp = list_entry(frag->list.next, struct mem_fragment, list);
+		lastone = (tmp == rightmost);
+		if (&tmp->list == &mem_list)
+			break;
+		list_del(&tmp->list);
+		kfree(tmp);
+		if (lastone)
+			break;
+	}
+	return frag;
+}
+
+/* Helper to verify that 'sz' is (4096 * 4^x) for some x. */
+static int is_good_size(u64 sz)
+{
+	int log = ilog2(phys_size);
+	if ((phys_size & (phys_size - 1)) || (log < 12) || (log & 1))
+		return 0;
+	return 1;
+}
+
+/* Hook from arch/powerpc/mm/mem.c */
+int usdpaa_test_fault(unsigned long pfn, u64 *phys_addr, u64 *size)
+{
+	struct mem_fragment *frag;
+	int idx = -1;
+	if ((pfn < pfn_start) || (pfn >= (pfn_start + pfn_size)))
+		return -1;
+	/* It's in-range, we need to find the fragment */
+	spin_lock(&mem_lock);
+	list_for_each_entry(frag, &mem_list, list) {
+		if ((pfn >= frag->pfn_base) && (pfn < (frag->pfn_base +
+						       frag->pfn_len))) {
+			*phys_addr = frag->base;
+			*size = frag->len;
+			idx = current_tlb++;
+			if (current_tlb >= (first_tlb + num_tlb))
+				current_tlb = first_tlb;
+			break;
+		}
+	}
+	spin_unlock(&mem_lock);
+	return idx;
+}
+
+static int usdpaa_open(struct inode *inode, struct file *filp)
+{
+	const struct alloc_backend *backend = &alloc_backends[0];
+	struct ctx *ctx = kmalloc(sizeof(struct ctx), GFP_KERNEL);
+	if (!ctx)
+		return -ENOMEM;
+	filp->private_data = ctx;
+
+	while (backend->id_type != usdpaa_id_max) {
+		dpa_alloc_init(&ctx->ids[backend->id_type]);
+		backend++;
+	}
+
+	INIT_LIST_HEAD(&ctx->maps);
+
+	filp->f_mapping->backing_dev_info = &directly_mappable_cdev_bdi;
+
+	return 0;
+}
+
+static int usdpaa_release(struct inode *inode, struct file *filp)
+{
+	struct ctx *ctx = filp->private_data;
+	struct mem_mapping *map, *tmp;
+	const struct alloc_backend *backend = &alloc_backends[0];
+	while (backend->id_type != usdpaa_id_max) {
+		int ret, leaks = 0;
+		do {
+			u32 id, num;
+			ret = dpa_alloc_pop(&ctx->ids[backend->id_type],
+					    &id, &num);
+			if (!ret) {
+				leaks += num;
+				backend->release(id, num);
+			}
+		} while (ret == 1);
+		if (leaks)
+			pr_crit("USDPAA process leaking %d %s%s\n", leaks,
+				backend->acronym, (leaks > 1) ? "s" : "");
+		backend++;
+	}
+	spin_lock(&mem_lock);
+	list_for_each_entry_safe(map, tmp, &ctx->maps, list) {
+		if (map->frag->has_locking && (map->frag->owner == map)) {
+			map->frag->owner = NULL;
+			wake_up(&map->frag->wq);
+		}
+		if (!--map->frag->refs) {
+			struct mem_fragment *frag = map->frag;
+			do {
+				frag = merge_frag(frag);
+			} while (frag);
+		}
+		list_del(&map->list);
+		kfree(map);
+	}
+	spin_unlock(&mem_lock);
+	kfree(ctx);
+	return 0;
+}
+
+static int usdpaa_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	struct ctx *ctx = filp->private_data;
+	struct mem_mapping *map;
+	int ret = 0;
+
+	spin_lock(&mem_lock);
+	list_for_each_entry(map, &ctx->maps, list) {
+		if (map->frag->pfn_base == vma->vm_pgoff)
+			goto map_match;
+	}
+	spin_unlock(&mem_lock);
+	return -ENOMEM;
+
+map_match:
+	if (map->frag->len != (vma->vm_end - vma->vm_start))
+		ret = -EINVAL;
+	spin_unlock(&mem_lock);
+	if (!ret)
+		ret = remap_pfn_range(vma, vma->vm_start, map->frag->pfn_base,
+				      vma->vm_end - vma->vm_start,
+				      vma->vm_page_prot);
+	return ret;
+}
+
+/* Return the nearest rounded-up address >= 'addr' that is 'sz'-aligned. 'sz'
+ * must be a power of 2, but both 'addr' and 'sz' can be expressions. */
+#define USDPAA_MEM_ROUNDUP(addr, sz) \
+	({ \
+		unsigned long foo_align = (sz) - 1; \
+		((addr) + foo_align) & ~foo_align; \
+	})
+/* Searching for a size-aligned virtual address range starting from 'addr' */
+static unsigned long usdpaa_get_unmapped_area(struct file *file,
+					      unsigned long addr,
+					      unsigned long len,
+					      unsigned long pgoff,
+					      unsigned long flags)
+{
+	struct vm_area_struct *vma;
+
+	if (!is_good_size(len))
+		return -EINVAL;
+
+	addr = USDPAA_MEM_ROUNDUP(addr, len);
+	vma = find_vma(current->mm, addr);
+	/* Keep searching until we reach the end of currently-used virtual
+	 * address-space or we find a big enough gap. */
+	while (vma) {
+		if ((addr + len) < vma->vm_start)
+			return addr;
+		addr = USDPAA_MEM_ROUNDUP(vma->vm_end, len);
+		vma = vma->vm_next;
+	}
+	if ((TASK_SIZE - len) < addr)
+		return -ENOMEM;
+	return addr;
+}
+
+static long ioctl_id_alloc(struct ctx *ctx, void __user *arg)
+{
+	struct usdpaa_ioctl_id_alloc i;
+	const struct alloc_backend *backend;
+	int ret = copy_from_user(&i, arg, sizeof(i));
+	if (ret)
+		return ret;
+	if ((i.id_type >= usdpaa_id_max) || !i.num)
+		return -EINVAL;
+	backend = &alloc_backends[i.id_type];
+	/* Allocate the required resource type */
+	ret = backend->alloc(&i.base, i.num, i.align, i.partial);
+	if (ret < 0)
+		return ret;
+	i.num = ret;
+	/* Copy the result to user-space */
+	ret = copy_to_user(arg, &i, sizeof(i));
+	if (ret) {
+		backend->release(i.base, i.num);
+		return ret;
+	}
+	/* Assign the allocated range to the FD accounting */
+	dpa_alloc_free(&ctx->ids[i.id_type], i.base, i.num);
+	return 0;
+}
+
+static long ioctl_id_release(struct ctx *ctx, void __user *arg)
+{
+	struct usdpaa_ioctl_id_release i;
+	const struct alloc_backend *backend;
+	int ret = copy_from_user(&i, arg, sizeof(i));
+	if (ret)
+		return ret;
+	if ((i.id_type >= usdpaa_id_max) || !i.num)
+		return -EINVAL;
+	backend = &alloc_backends[i.id_type];
+	/* Pull the range out of the FD accounting - the range is valid iff this
+	 * succeeds. */
+	ret = dpa_alloc_reserve(&ctx->ids[i.id_type], i.base, i.num);
+	if (ret)
+		return ret;
+	/* Release the resource to the backend */
+	backend->release(i.base, i.num);
+	return 0;
+}
+
+static long ioctl_dma_map(struct ctx *ctx, void __user *arg)
+{
+	struct usdpaa_ioctl_dma_map i;
+	struct mem_fragment *frag;
+	struct mem_mapping *map, *tmp;
+	u64 search_size;
+	int ret = copy_from_user(&i, arg, sizeof(i));
+	if (ret)
+		return ret;
+	if (i.len && !is_good_size(i.len))
+		return -EINVAL;
+	map = kmalloc(sizeof(*map), GFP_KERNEL);
+	if (!map)
+		return -ENOMEM;
+	spin_lock(&mem_lock);
+	if (i.flags & USDPAA_DMA_FLAG_SHARE) {
+		list_for_each_entry(frag, &mem_list, list) {
+			if (frag->refs && (frag->flags &
+					   USDPAA_DMA_FLAG_SHARE) &&
+					!strncmp(i.name, frag->name,
+						 USDPAA_DMA_NAME_MAX)) {
+				/* Matching entry */
+				if ((i.flags & USDPAA_DMA_FLAG_CREATE) &&
+				    !(i.flags & USDPAA_DMA_FLAG_LAZY)) {
+					ret = -EBUSY;
+					goto out;
+				}
+				list_for_each_entry(tmp, &ctx->maps, list)
+					if (tmp->frag == frag) {
+						ret = -EBUSY;
+						goto out;
+					}
+				i.has_locking = frag->has_locking;
+				i.did_create = 0;
+				i.len = frag->len;
+				goto do_map;
+			}
+		}
+		/* No matching entry */
+		if (!(i.flags & USDPAA_DMA_FLAG_CREATE)) {
+			ret = -ENOMEM;
+			goto out;
+		}
+	}
+	/* New fragment required, size must be provided. */
+	if (!i.len) {
+		ret = -EINVAL;
+		goto out;
+	}
+	/* We search for the required size and if that fails, for the next
+	 * biggest size, etc. */
+	for (search_size = i.len; search_size <= phys_size; search_size <<= 2) {
+		list_for_each_entry(frag, &mem_list, list) {
+			if (!frag->refs && (frag->len == search_size)) {
+				while (frag->len > i.len) {
+					frag = split_frag(frag);
+					if (!frag) {
+						ret = -ENOMEM;
+						goto out;
+					}
+				}
+				frag->flags = i.flags;
+				strncpy(frag->name, i.name,
+					USDPAA_DMA_NAME_MAX);
+				frag->has_locking = i.has_locking;
+				init_waitqueue_head(&frag->wq);
+				frag->owner = NULL;
+				i.did_create = 1;
+				goto do_map;
+			}
+		}
+	}
+	ret = -ENOMEM;
+	goto out;
+
+do_map:
+	map->frag = frag;
+	frag->refs++;
+	list_add(&map->list, &ctx->maps);
+	i.pa_offset = frag->base;
+
+out:
+	spin_unlock(&mem_lock);
+	if (!ret)
+		ret = copy_to_user(arg, &i, sizeof(i));
+	else
+		kfree(map);
+	return ret;
+}
+
+static int test_lock(struct mem_mapping *map)
+{
+	int ret = 0;
+	spin_lock(&mem_lock);
+	if (!map->frag->owner) {
+		map->frag->owner = map;
+		ret = 1;
+	}
+	spin_unlock(&mem_lock);
+	return ret;
+}
+
+static long ioctl_dma_lock(struct ctx *ctx, void __user *arg)
+{
+	struct mem_mapping *map;
+	struct vm_area_struct *vma;
+
+	down_read(&current->mm->mmap_sem);
+	vma = find_vma(current->mm, (unsigned long)arg);
+	if (!vma || (vma->vm_start > (unsigned long)arg)) {
+		up_read(&current->mm->mmap_sem);
+		return -EFAULT;
+	}
+	spin_lock(&mem_lock);
+	list_for_each_entry(map, &ctx->maps, list) {
+		if (map->frag->pfn_base == vma->vm_pgoff)
+			goto map_match;
+	}
+	map = NULL;
+map_match:
+	spin_unlock(&mem_lock);
+	up_read(&current->mm->mmap_sem);
+
+	if (!map->frag->has_locking)
+		return -ENODEV;
+	return wait_event_interruptible(map->frag->wq, test_lock(map));
+}
+
+static long ioctl_dma_unlock(struct ctx *ctx, void __user *arg)
+{
+	struct mem_mapping *map;
+	struct vm_area_struct *vma;
+	int ret;
+
+	down_read(&current->mm->mmap_sem);
+	vma = find_vma(current->mm, (unsigned long)arg);
+	if (!vma || (vma->vm_start > (unsigned long)arg))
+		ret = -EFAULT;
+	else {
+		spin_lock(&mem_lock);
+		list_for_each_entry(map, &ctx->maps, list) {
+			if (map->frag->pfn_base == vma->vm_pgoff) {
+				if (!map->frag->has_locking)
+					ret = -ENODEV;
+				else if (map->frag->owner == map) {
+					map->frag->owner = NULL;
+					wake_up(&map->frag->wq);
+					ret = 0;
+				} else
+					ret = -EBUSY;
+				goto map_match;
+			}
+		}
+		ret = -EINVAL;
+map_match:
+		spin_unlock(&mem_lock);
+	}
+	up_read(&current->mm->mmap_sem);
+	return ret;
+}
+
+static long usdpaa_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
+{
+	struct ctx *ctx = fp->private_data;
+	void __user *a = (void __user *)arg;
+	switch (cmd) {
+	case USDPAA_IOCTL_ID_ALLOC:
+		return ioctl_id_alloc(ctx, a);
+	case USDPAA_IOCTL_ID_RELEASE:
+		return ioctl_id_release(ctx, a);
+	case USDPAA_IOCTL_DMA_MAP:
+		return ioctl_dma_map(ctx, a);
+	case USDPAA_IOCTL_DMA_LOCK:
+		return ioctl_dma_lock(ctx, a);
+	case USDPAA_IOCTL_DMA_UNLOCK:
+		return ioctl_dma_unlock(ctx, a);
+	}
+	return -EINVAL;
+}
+
+static const struct file_operations usdpaa_fops = {
+	.open		   = usdpaa_open,
+	.release	   = usdpaa_release,
+	.mmap		   = usdpaa_mmap,
+	.get_unmapped_area = usdpaa_get_unmapped_area,
+	.unlocked_ioctl	   = usdpaa_ioctl,
+	.compat_ioctl	   = usdpaa_ioctl
+};
+
+static struct miscdevice usdpaa_miscdev = {
+	.name = "fsl-usdpaa",
+	.fops = &usdpaa_fops,
+	.minor = MISC_DYNAMIC_MINOR,
+};
+
+/* Early-boot memory allocation. The boot-arg "usdpaa_mem=<x>" is used to
+ * indicate how much memory (if any) to allocate during early boot. If the
+ * format "usdpaa_mem=<x>,<y>" is used, then <y> will be interpreted as the
+ * number of TLB1 entries to reserve (default is 1). If there are more mappings
+ * than there are TLB1 entries, fault-handling will occur. */
+static __init int usdpaa_mem(char *arg)
+{
+	phys_size = memparse(arg, &arg);
+	num_tlb = 1;
+	if (*arg == ',') {
+		unsigned long ul;
+		int err = kstrtoul(arg + 1, 0, &ul);
+		if (err < 0) {
+			num_tlb = 1;
+			pr_warning("ERROR, usdpaa_mem arg is invalid\n");
+		} else
+			num_tlb = (unsigned int)ul;
+	}
+	return 0;
+}
+early_param("usdpaa_mem", usdpaa_mem);
+
+__init void fsl_usdpaa_init_early(void)
+{
+	if (!phys_size) {
+		pr_info("No USDPAA memory, no 'usdpaa_mem' bootarg\n");
+		return;
+	}
+	if (!is_good_size(phys_size)) {
+		pr_err("'usdpaa_mem' bootarg must be 4096*4^x\n");
+		phys_size = 0;
+		return;
+	}
+	phys_start = memblock_alloc(phys_size, phys_size);
+	if (!phys_start) {
+		pr_err("Failed to reserve USDPAA region (sz:%llx)\n",
+		       phys_size);
+		return;
+	}
+	pfn_start = phys_start >> PAGE_SHIFT;
+	pfn_size = phys_size >> PAGE_SHIFT;
+	first_tlb = current_tlb = tlbcam_index;
+	tlbcam_index += num_tlb;
+	pr_info("USDPAA region at %llx:%llx(%lx:%lx), %d TLB1 entries)\n",
+		phys_start, phys_size, pfn_start, pfn_size, num_tlb);
+}
+
+static int __init usdpaa_init(void)
+{
+	struct mem_fragment *frag;
+	int ret;
+
+	pr_info("Freescale USDPAA process driver\n");
+	if (!phys_start) {
+		pr_warning("fsl-usdpaa: no region found\n");
+		return 0;
+	}
+	frag = kmalloc(sizeof(*frag), GFP_KERNEL);
+	if (!frag) {
+		pr_err("Failed to setup USDPAA memory accounting\n");
+		return -ENOMEM;
+	}
+	frag->base = phys_start;
+	frag->len = phys_size;
+	frag->pfn_base = pfn_start;
+	frag->pfn_len = pfn_size;
+	frag->refs = 0;
+	init_waitqueue_head(&frag->wq);
+	frag->owner = NULL;
+	list_add(&frag->list, &mem_list);
+	ret = misc_register(&usdpaa_miscdev);
+	if (ret)
+		pr_err("fsl-usdpaa: failed to register misc device\n");
+	return ret;
+}
+
+static void __exit usdpaa_exit(void)
+{
+	misc_deregister(&usdpaa_miscdev);
+}
+
+module_init(usdpaa_init);
+module_exit(usdpaa_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Freescale Semiconductor");
+MODULE_DESCRIPTION("Freescale USDPAA process driver");