SYSLINK:ProcMgr-Add ProcMgr to Syslink

Add ProcMgr to Syslink

Signed-off-by: Hari Kanigeri <h-kanigeri2@ti.com>
Signed-off-by: Ramesh Gupta G <grgupta@ti.com>
Signed-off-by: Suman Anna <s-anna@ti.com>
Signed-off-by: Arun M G <arunmg@ti.com>
Signed-off-by: Angela Stegmaier <angelabaker@ti.com>

12 files changed, 4118 insertions, 0 deletions

diff --git a/drivers/dsp/syslink/procmgr/Kbuild b/drivers/dsp/syslink/procmgr/Kbuild
new file mode 100644
index 00000000000..33622e8425b
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/Kbuild
@@ -0,0 +1,9 @@
+libomap_syslink_proc = processor.o procmgr.o procmgr_drv.o
+
+obj-$(CONFIG_SYSLINK_PROC)        += syslink_proc.o
+syslink_proc-objs = $(libomap_syslink_proc)
+
+ccflags-y += -Wno-strict-prototypes
+
+#Header files
+ccflags-y += -Iarch/arm/plat-omap/include/syslink
diff --git a/drivers/dsp/syslink/procmgr/proc4430/Kbuild b/drivers/dsp/syslink/procmgr/proc4430/Kbuild
new file mode 100644
index 00000000000..3dee46d956d
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/proc4430/Kbuild
@@ -0,0 +1,9 @@
+libomap_proc4430 = proc4430.o proc4430_drv.o
+
+obj-$(CONFIG_SYSLINK_PROC)        += syslink_proc4430.o
+syslink_proc4430-objs = $(libomap_proc4430)
+
+ccflags-y += -Wno-strict-prototypes -DUSE_LEVEL_1_MACROS
+
+#Header files
+ccflags-y += -Iarch/arm/plat-omap/include/syslink
diff --git a/drivers/dsp/syslink/procmgr/proc4430/proc4430.c b/drivers/dsp/syslink/procmgr/proc4430/proc4430.c
new file mode 100644
index 00000000000..44c66c6a444
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/proc4430/proc4430.c
@@ -0,0 +1,834 @@
+/*
+ * proc4430.c
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/vmalloc.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+
+/* Module level headers */
+#include "../procdefs.h"
+#include "../processor.h"
+#include <procmgr.h>
+#include "../procmgr_drvdefs.h"
+#include "proc4430.h"
+#include "../../ipu_pm/ipu_pm.h"
+#include <syslink/multiproc.h>
+#include <syslink/platform_mem.h>
+#include <syslink/atomic_linux.h>
+
+
+#define OMAP4430PROC_MODULEID          (u16) 0xbbec
+
+/* Macro to make a correct module magic number with refCount */
+#define OMAP4430PROC_MAKE_MAGICSTAMP(x) ((OMAP4430PROC_MODULEID << 12u) | (x))
+
+#define PG_MASK(pg_size) (~((pg_size)-1))
+#define PG_ALIGN_LOW(addr, pg_size) ((addr) & PG_MASK(pg_size))
+
+/*OMAP4430 Module state object */
+struct proc4430_module_object {
+        u32 config_size;
+        /* Size of configuration structure */
+        struct proc4430_config cfg;
+        /* OMAP4430 configuration structure */
+        struct proc4430_config def_cfg;
+        /* Default module configuration */
+        struct proc4430_params def_inst_params;
+        /* Default parameters for the OMAP4430 instances */
+        void *proc_handles[MULTIPROC_MAXPROCESSORS];
+        /* Processor handle array. */
+        struct mutex *gate_handle;
+        /* void * of gate to be used for local thread safety */
+        atomic_t ref_count;
+};
+
+/*
+  OMAP4430 instance object.
+ */
+struct proc4430_object {
+        struct proc4430_params params;
+        /* Instance parameters (configuration values) */
+        atomic_t attach_count;
+        /* attach reference count */
+};
+
+
+/* =================================
+ *  Globals
+ * =================================
+ */
+/*
+  OMAP4430 state object variable
+ */
+
+static struct proc4430_module_object proc4430_state = {
+        .config_size = sizeof(struct proc4430_config),
+        .gate_handle = NULL,
+        .def_inst_params.num_mem_entries = 0u,
+        .def_inst_params.mem_entries = NULL,
+        .def_inst_params.reset_vector_mem_entry = 0
+};
+
+
+/* =================================
+ * APIs directly called by applications
+ * =================================
+ */
+/*
+ * Function to get the default configuration for the OMAP4430
+ * module.
+ *
+ * This function can be called by the application to get their
+ * configuration parameter to proc4430_setup filled in by the
+ * OMAP4430 module with the default parameters. If the user
+ * does not wish to make any change in the default parameters, this
+ * API is not required to be called.
+ */
+void proc4430_get_config(struct proc4430_config *cfg)
+{
+        BUG_ON(cfg == NULL);
+        memcpy(cfg, &(proc4430_state.def_cfg),
+                        sizeof(struct proc4430_config));
+}
+EXPORT_SYMBOL(proc4430_get_config);
+
+/*
+ * Function to setup the OMAP4430 module.
+ *
+ * This function sets up the OMAP4430 module. This function
+ * must be called before any other instance-level APIs can be
+ * invoked.
+ * Module-level configuration needs to be provided to this
+ * function. If the user wishes to change some specific config
+ * parameters, then proc4430_get_config can be called to get the
+ * configuration filled with the default values. After this, only
+ * the required configuration values can be changed. If the user
+ * does not wish to make any change in the default parameters, the
+ * application can simply call proc4430_setup with NULL
+ * parameters. The default parameters would get automatically used.
+ */
+int proc4430_setup(struct proc4430_config *cfg)
+{
+        int retval = 0;
+        struct proc4430_config tmp_cfg;
+        atomic_cmpmask_and_set(&proc4430_state.ref_count,
+                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                 OMAP4430PROC_MAKE_MAGICSTAMP(0));
+
+        if (atomic_inc_return(&proc4430_state.ref_count) !=
+                                OMAP4430PROC_MAKE_MAGICSTAMP(1)) {
+                return 1;
+        }
+
+        if (cfg == NULL) {
+                proc4430_get_config(&tmp_cfg);
+                cfg = &tmp_cfg;
+        }
+
+        /* Create a default gate handle for local module protection. */
+        proc4430_state.gate_handle =
+                kmalloc(sizeof(struct mutex), GFP_KERNEL);
+        if (proc4430_state.gate_handle == NULL) {
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        mutex_init(proc4430_state.gate_handle);
+
+        /* Initialize the name to handles mapping array. */
+        memset(&proc4430_state.proc_handles, 0,
+                (sizeof(void *) * MULTIPROC_MAXPROCESSORS));
+
+        /* Copy the user provided values into the state object. */
+        memcpy(&proc4430_state.cfg, cfg,
+                                sizeof(struct proc4430_config));
+
+        return 0;
+
+error:
+        atomic_dec_return(&proc4430_state.ref_count);
+
+        return retval;
+}
+EXPORT_SYMBOL(proc4430_setup);
+
+/*
+ * Function to destroy the OMAP4430 module.
+ *
+ * Once this function is called, other OMAP4430 module APIs,
+ * except for the proc4430_get_config API cannot be called
+ * anymore.
+ */
+int proc4430_destroy(void)
+{
+        int retval = 0;
+        u16 i;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                retval = -ENODEV;
+                goto exit;
+        }
+        if (!(atomic_dec_return(&proc4430_state.ref_count)
+                        == OMAP4430PROC_MAKE_MAGICSTAMP(0))) {
+
+                retval = 1;
+                goto exit;
+        }
+
+        /* Check if any OMAP4430 instances have not been
+         * deleted so far. If not,delete them.
+         */
+
+        for (i = 0; i < MULTIPROC_MAXPROCESSORS; i++) {
+                if (proc4430_state.proc_handles[i] == NULL)
+                        continue;
+                proc4430_delete(&(proc4430_state.proc_handles[i]));
+        }
+
+        /* Check if the gate_handle was created internally. */
+        if (proc4430_state.gate_handle != NULL) {
+                mutex_destroy(proc4430_state.gate_handle);
+                kfree(proc4430_state.gate_handle);
+        }
+
+exit:
+        return retval;
+}
+EXPORT_SYMBOL(proc4430_destroy);
+
+/*=================================================
+ * Function to initialize the parameters for this Processor
+ * instance.
+ */
+void proc4430_params_init(void *handle, struct proc4430_params *params)
+{
+        struct proc4430_object *proc_object = (struct proc4430_object *)handle;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_params_init failed "
+                        "Module not initialized");
+                return;
+        }
+
+        if (WARN_ON(params == NULL)) {
+                printk(KERN_ERR "proc4430_params_init failed "
+                        "Argument of type proc4430_params * "
+                        "is NULL");
+                return;
+        }
+
+        if (handle == NULL)
+                memcpy(params, &(proc4430_state.def_inst_params),
+                                sizeof(struct proc4430_params));
+        else
+                memcpy(params, &(proc_object->params),
+                                sizeof(struct proc4430_params));
+}
+EXPORT_SYMBOL(proc4430_params_init);
+
+/*===================================================
+ *Function to create an instance of this Processor.
+ *
+ */
+void *proc4430_create(u16 proc_id, const struct proc4430_params *params)
+{
+        struct processor_object *handle = NULL;
+        struct proc4430_object *object = NULL;
+
+        BUG_ON(!IS_VALID_PROCID(proc_id));
+        BUG_ON(params == NULL);
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_create failed "
+                        "Module not initialized");
+                goto error;
+        }
+
+        /* Enter critical section protection. */
+        WARN_ON(mutex_lock_interruptible(proc4430_state.gate_handle));
+        if (proc4430_state.proc_handles[proc_id] != NULL) {
+                handle = proc4430_state.proc_handles[proc_id];
+                goto func_end;
+        } else {
+                handle = (struct processor_object *)
+                        vmalloc(sizeof(struct processor_object));
+                if (WARN_ON(handle == NULL))
+                        goto func_end;
+
+                handle->proc_fxn_table.attach = &proc4430_attach;
+                handle->proc_fxn_table.detach = &proc4430_detach;
+                handle->proc_fxn_table.read = &proc4430_read;
+                handle->proc_fxn_table.write = &proc4430_write;
+                handle->proc_fxn_table.control = &proc4430_control;
+                handle->proc_fxn_table.translateAddr =
+                                         &proc4430_translate_addr;
+                handle->proc_fxn_table.procinfo = &proc4430_proc_info;
+                handle->proc_fxn_table.virt_to_phys = &proc4430_virt_to_phys;
+                handle->state = PROC_MGR_STATE_UNKNOWN;
+                handle->object = vmalloc(sizeof(struct proc4430_object));
+                handle->proc_id = proc_id;
+                object = (struct proc4430_object *)handle->object;
+                if (params != NULL) {
+                        /* Copy params into instance object. */
+                        memcpy(&(object->params), (void *)params,
+                                        sizeof(struct proc4430_params));
+                }
+                if ((params != NULL) && (params->mem_entries != NULL)
+                                        && (params->num_mem_entries > 0)) {
+                        /* Allocate memory for, and copy mem_entries table*/
+                        object->params.mem_entries = vmalloc(sizeof(struct
+                                                proc4430_mem_entry) *
+                                                params->num_mem_entries);
+                        memcpy(object->params.mem_entries,
+                                params->mem_entries,
+                                (sizeof(struct proc4430_mem_entry) *
+                                 params->num_mem_entries));
+                }
+                handle->boot_mode = PROC_MGR_BOOTMODE_NOLOAD;
+                /* Set the handle in the state object. */
+                proc4430_state.proc_handles[proc_id] = handle;
+        }
+
+func_end:
+        mutex_unlock(proc4430_state.gate_handle);
+error:
+        return (void *)handle;
+}
+EXPORT_SYMBOL(proc4430_create);
+
+/*=================================================
+ * Function to delete an instance of this Processor.
+ *
+ * The user provided pointer to the handle is reset after
+ * successful completion of this function.
+ *
+ */
+int proc4430_delete(void **handle_ptr)
+{
+        int retval = 0;
+        struct proc4430_object *object = NULL;
+        struct processor_object *handle;
+
+        BUG_ON(handle_ptr == NULL);
+        BUG_ON(*handle_ptr == NULL);
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_delete failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        handle = (struct processor_object *)(*handle_ptr);
+        BUG_ON(!IS_VALID_PROCID(handle->proc_id));
+        /* Enter critical section protection. */
+        WARN_ON(mutex_lock_interruptible(proc4430_state.gate_handle));
+        /* Reset handle in PwrMgr handle array. */
+        proc4430_state.proc_handles[handle->proc_id] = NULL;
+        /* Free memory used for the OMAP4430 object. */
+        if (handle->object != NULL) {
+                object = (struct proc4430_object *)handle->object;
+                if (object->params.mem_entries != NULL) {
+                        vfree(object->params.mem_entries);
+                        object->params.mem_entries = NULL;
+                }
+                vfree(handle->object);
+                handle->object = NULL;
+        }
+        /* Free memory used for the Processor object. */
+        vfree(handle);
+        *handle_ptr = NULL;
+        /* Leave critical section protection. */
+        mutex_unlock(proc4430_state.gate_handle);
+        return retval;
+}
+EXPORT_SYMBOL(proc4430_delete);
+
+/*===================================================
+ * Function to open a handle to an instance of this Processor. This
+ * function is called when access to the Processor is required from
+ * a different process.
+ */
+int proc4430_open(void **handle_ptr, u16 proc_id)
+{
+        int retval = 0;
+
+        BUG_ON(handle_ptr == NULL);
+        BUG_ON(!IS_VALID_PROCID(proc_id));
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_open failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        /* Initialize return parameter handle. */
+        *handle_ptr = NULL;
+
+        /* Check if the PwrMgr exists and return the handle if found. */
+        if (proc4430_state.proc_handles[proc_id] == NULL) {
+                retval = -ENODEV;
+                goto func_exit;
+        } else
+                *handle_ptr = proc4430_state.proc_handles[proc_id];
+func_exit:
+        return retval;
+}
+EXPORT_SYMBOL(proc4430_open);
+
+/*===============================================
+ * Function to close a handle to an instance of this Processor.
+ *
+ */
+int proc4430_close(void *handle)
+{
+        int retval = 0;
+
+        BUG_ON(handle == NULL);
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_close failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        /* nothing to be done for now */
+        return retval;
+}
+EXPORT_SYMBOL(proc4430_close);
+
+/* =================================
+ * APIs called by Processor module (part of function table interface)
+ * =================================
+ */
+/*================================
+ * Function to initialize the slave processor
+ *
+ */
+int proc4430_attach(void *handle, struct processor_attach_params *params)
+{
+        int retval = 0;
+
+        struct processor_object *proc_handle = NULL;
+        struct proc4430_object *object = NULL;
+        u32 map_count = 0;
+        u32 i;
+        memory_map_info map_info;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_attach failed"
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        if (WARN_ON(handle == NULL)) {
+                printk(KERN_ERR "proc4430_attach failed"
+                        "Driver handle is NULL");
+                return -EINVAL;
+        }
+
+        if (WARN_ON(params == NULL)) {
+                printk(KERN_ERR "proc4430_attach failed"
+                        "Argument processor_attach_params * is NULL");
+                return -EINVAL;
+        }
+
+        proc_handle = (struct processor_object *)handle;
+
+        object = (struct proc4430_object *)proc_handle->object;
+
+        atomic_cmpmask_and_set(&object->attach_count,
+                                OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                OMAP4430PROC_MAKE_MAGICSTAMP(0));
+        atomic_inc_return(&object->attach_count);
+
+        printk(KERN_ERR "proc4430_attach num_mem_entries = %d",
+                                object->params.num_mem_entries);
+        /* Return memory information in params. */
+        for (i = 0; (i < object->params.num_mem_entries); i++) {
+                /* If the configured master virtual address is invalid, get the
+                * actual address by mapping the physical address into master
+                * kernel memory space.
+                */
+                if ((object->params.mem_entries[i].master_virt_addr == (u32)-1)
+                && (object->params.mem_entries[i].shared == true)) {
+                        map_info.src = object->params.mem_entries[i].phys_addr;
+                        map_info.size = object->params.mem_entries[i].size;
+                        map_info.is_cached = false;
+                        retval = platform_mem_map(&map_info);
+                        if (retval != 0) {
+                                printk(KERN_ERR "proc4430_attach failed\n");
+                                return -EFAULT;
+                        }
+                        map_count++;
+                        object->params.mem_entries[i].master_virt_addr =
+                                                                map_info.dst;
+                        params->mem_entries[i].addr
+                                [PROC_MGR_ADDRTYPE_MASTERKNLVIRT] =
+                                                                map_info.dst;
+                        params->mem_entries[i].addr
+                                [PROC_MGR_ADDRTYPE_SLAVEVIRT] =
+                        (object->params.mem_entries[i].slave_virt_addr);
+                        /* User virtual will be filled by user side. For now,
+                        fill in the physical address so that it can be used
+                        by mmap to remap this region into user-space */
+                        params->mem_entries[i].addr
+                                [PROC_MGR_ADDRTYPE_MASTERUSRVIRT] = \
+                                object->params.mem_entries[i].phys_addr;
+                        params->mem_entries[i].size =
+                                object->params.mem_entries[i].size;
+                }
+        }
+        params->num_mem_entries = map_count;
+        return retval;
+}
+
+
+/*==========================================
+ * Function to detach from the Processor.
+ *
+ */
+int proc4430_detach(void *handle)
+{
+        struct processor_object *proc_handle = NULL;
+        struct proc4430_object *object = NULL;
+        u32 i;
+        memory_unmap_info unmap_info;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+
+                printk(KERN_ERR "proc4430_detach failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+        if (WARN_ON(handle == NULL)) {
+                printk(KERN_ERR "proc4430_detach failed "
+                        "Argument Driverhandle is NULL");
+                return -EINVAL;
+        }
+
+        proc_handle = (struct processor_object *)handle;
+        object = (struct proc4430_object *)proc_handle->object;
+
+        if (!(atomic_dec_return(&object->attach_count) == \
+                OMAP4430PROC_MAKE_MAGICSTAMP(0)))
+                return 1;
+
+        for (i = 0; (i < object->params.num_mem_entries); i++) {
+                if ((object->params.mem_entries[i].master_virt_addr > 0)
+                    && (object->params.mem_entries[i].shared == true)) {
+                        unmap_info.addr =
+                                object->params.mem_entries[i].master_virt_addr;
+                        unmap_info.size = object->params.mem_entries[i].size;
+                        platform_mem_unmap(&unmap_info);
+                        object->params.mem_entries[i].master_virt_addr =
+                                (u32)-1;
+                }
+        }
+        return 0;
+}
+
+
+/*==============================================
+ *       Function to read from the slave processor's memory.
+ *
+ * Read from the slave processor's memory and copy into the
+ * provided buffer.
+ */
+int proc4430_read(void *handle, u32 proc_addr, u32 *num_bytes,
+                                                void *buffer)
+{
+        int retval = 0;
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_read failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        buffer = memcpy(buffer, (void *)proc_addr, *num_bytes);
+
+        return retval;
+}
+
+
+/*==============================================
+ * Function to write into the slave processor's memory.
+ *
+ * Read from the provided buffer and copy into the slave
+ * processor's memory.
+ *
+ */
+int proc4430_write(void *handle, u32 proc_addr, u32 *num_bytes,
+                                                void *buffer)
+{
+        int retval = 0;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_write failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        proc_addr = (u32)memcpy((void *)proc_addr, buffer, *num_bytes);
+
+        return retval;
+}
+
+
+/*=========================================================
+ * Function to perform device-dependent operations.
+ *
+ * Performs device-dependent control operations as exposed by this
+ * implementation of the Processor module.
+ */
+int proc4430_control(void *handle, int cmd, void *arg)
+{
+        int retval = 0;
+
+        /*FIXME: Remove handle,etc if not used */
+
+#ifdef CONFIG_SYSLINK_DUCATI_PM
+        /* For purpose testing */
+        switch (cmd) {
+        case PM_SUSPEND:
+        case PM_RESUME:
+                retval = ipu_pm_notifications(cmd, NULL);
+                break;
+        default:
+                printk(KERN_ERR "Invalid notification\n");
+        }
+        if (retval != PM_SUCCESS)
+                printk(KERN_ERR "Error in notifications\n");
+#endif
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_control failed "
+                        "Module not initialized");
+                return -ENODEV;
+        }
+
+        return retval;
+}
+
+
+/*=====================================================
+ * Function to translate between two types of address spaces.
+ *
+ * Translate between the specified address spaces.
+ */
+int proc4430_translate_addr(void *handle,
+                void **dst_addr, enum proc_mgr_addr_type dst_addr_type,
+                void *src_addr, enum proc_mgr_addr_type src_addr_type)
+{
+        int retval = 0;
+        struct processor_object *proc_handle = NULL;
+        struct proc4430_object *object = NULL;
+        struct proc4430_mem_entry *entry = NULL;
+        bool found = false;
+        u32 fm_addr_base = (u32)NULL;
+        u32 to_addr_base = (u32)NULL;
+        u32 i;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_translate_addr failed "
+                        "Module not initialized");
+                retval = -ENODEV;
+                goto error_exit;
+        }
+
+        if (WARN_ON(handle == NULL)) {
+                retval = -EINVAL;
+                goto error_exit;
+        }
+        if (WARN_ON(dst_addr == NULL)) {
+                retval = -EINVAL;
+                goto error_exit;
+        }
+        if (WARN_ON(dst_addr_type > PROC_MGR_ADDRTYPE_ENDVALUE)) {
+                retval = -EINVAL;
+                goto error_exit;
+        }
+        if (WARN_ON(src_addr == NULL)) {
+                retval = -EINVAL;
+                goto error_exit;
+        }
+        if (WARN_ON(src_addr_type > PROC_MGR_ADDRTYPE_ENDVALUE)) {
+                retval = -EINVAL;
+                goto error_exit;
+        }
+
+        proc_handle = (struct processor_object *)handle;
+        object = (struct proc4430_object *)proc_handle->object;
+        *dst_addr = NULL;
+        for (i = 0 ; i < object->params.num_mem_entries ; i++) {
+                entry = &(object->params.mem_entries[i]);
+                fm_addr_base =
+                        (src_addr_type == PROC_MGR_ADDRTYPE_MASTERKNLVIRT) ?
+                        entry->master_virt_addr : entry->slave_virt_addr;
+                to_addr_base =
+                        (dst_addr_type == PROC_MGR_ADDRTYPE_MASTERKNLVIRT) ?
+                        entry->master_virt_addr : entry->slave_virt_addr;
+                /* Determine whether which way to convert */
+                if (((u32)src_addr < (fm_addr_base + entry->size)) &&
+                        ((u32)src_addr >= fm_addr_base)) {
+                        found = true;
+                        *dst_addr = (void *)(((u32)src_addr - fm_addr_base)
+                                + to_addr_base);
+                        break;
+                }
+        }
+
+        /* This check must not be removed even with build optimize. */
+        if (WARN_ON(found == false)) {
+                /*Failed to translate address. */
+                retval = -ENXIO;
+                goto error_exit;
+        }
+        return 0;
+
+error_exit:
+        return retval;
+}
+
+
+/*=================================================
+ * Function to return list of translated mem entries
+ *
+ * This function takes the remote processor address as
+ * an input and returns the mapped Page entries in the
+ * buffer passed
+ */
+int proc4430_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
+                                                u32 num_of_entries)
+{
+        int da_align;
+        int i;
+        int ret_val = 0;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_virt_to_phys failed "
+                        "Module not initialized");
+                ret_val = -EFAULT;
+                goto error_exit;
+        }
+
+        if (handle == NULL || mapped_entries == NULL || num_of_entries == 0) {
+                ret_val = -EFAULT;
+                goto error_exit;
+        }
+        da_align = PG_ALIGN_LOW((u32)da, PAGE_SIZE);
+        for (i = 0; i < num_of_entries; i++) {
+                mapped_entries[i] = da_align;
+                da_align += PAGE_SIZE;
+        }
+        return 0;
+
+error_exit:
+        printk(KERN_WARNING "proc4430_virtToPhys failed !!!!\n");
+        return ret_val;
+}
+
+
+/*=================================================
+ * Function to return PROC4430 mem_entries info
+ *
+ */
+int proc4430_proc_info(void *handle, struct proc_mgr_proc_info *procinfo)
+{
+        struct processor_object *proc_handle = NULL;
+        struct proc4430_object *object = NULL;
+        struct proc4430_mem_entry *entry = NULL;
+        int i;
+
+        if (atomic_cmpmask_and_lt(&proc4430_state.ref_count,
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(0),
+                                        OMAP4430PROC_MAKE_MAGICSTAMP(1))
+                                        == true) {
+                printk(KERN_ERR "proc4430_proc_info failed "
+                        "Module not initialized");
+                goto error_exit;
+        }
+
+        if (WARN_ON(handle == NULL))
+                goto error_exit;
+        if (WARN_ON(procinfo == NULL))
+                goto error_exit;
+
+        proc_handle = (struct processor_object *)handle;
+
+        object = (struct proc4430_object *)proc_handle->object;
+
+        for (i = 0 ; i < object->params.num_mem_entries ; i++) {
+                entry = &(object->params.mem_entries[i]);
+                procinfo->mem_entries[i].addr[PROC_MGR_ADDRTYPE_MASTERKNLVIRT]
+                                                = entry->master_virt_addr;
+                procinfo->mem_entries[i].addr[PROC_MGR_ADDRTYPE_SLAVEVIRT]
+                                                = entry->slave_virt_addr;
+                procinfo->mem_entries[i].size = entry->size;
+        }
+        procinfo->num_mem_entries = object->params.num_mem_entries;
+        procinfo->boot_mode = proc_handle->boot_mode;
+        return 0;
+
+error_exit:
+        printk(KERN_WARNING "proc4430_proc_info failed !!!!\n");
+        return -EFAULT;
+}
diff --git a/drivers/dsp/syslink/procmgr/proc4430/proc4430.h b/drivers/dsp/syslink/procmgr/proc4430/proc4430.h
new file mode 100644
index 00000000000..e264f473aa0
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/proc4430/proc4430.h
@@ -0,0 +1,133 @@
+/*
+ * proc4430.h
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+
+
+#ifndef _SYSLINK_PROC_4430_H_
+#define _SYSLINK_PROC_4430_H_
+
+
+/* Module headers */
+#include <procmgr.h>
+#include "../procdefs.h"
+#include <linux/types.h>
+
+/*
+  Module configuration structure.
+ */
+struct proc4430_config {
+        struct mutex *gate_handle;
+        /* void * of gate to be used for local thread safety */
+};
+
+/*
+  Memory entry for slave memory map configuration
+ */
+struct proc4430_mem_entry {
+        char name[PROCMGR_MAX_STRLEN];
+        /* Name identifying the memory region. */
+        u32 phys_addr;
+        /* Physical address of the memory region. */
+        u32 slave_virt_addr;
+        /* Slave virtual address of the memory region. */
+        u32 master_virt_addr;
+        /* Master virtual address of the memory region. If specified as -1,
+        * the master virtual address is assumed to be invalid, and shall be
+        * set internally within the Processor module. */
+        u32 size;
+        /* Size (in bytes) of the memory region. */
+        bool shared;
+        /* Flag indicating whether the memory region is shared between master
+        * and slave. */
+};
+
+/*
+  Configuration parameters specific to this processor.
+ */
+struct proc4430_params {
+        int num_mem_entries;
+        /* Number of memory regions to be configured. */
+        struct proc4430_mem_entry *mem_entries;
+        /* Array of information structures for memory regions
+        * to be configured. */
+        u32 reset_vector_mem_entry;
+        /* Index of the memory entry within the mem_entries array,
+        * which is the resetVector memory region. */
+};
+
+
+/* Function to initialize the slave processor */
+int proc4430_attach(void *handle, struct processor_attach_params *params);
+
+/* Function to finalize the slave processor */
+int proc4430_detach(void *handle);
+
+
+/* Function to read from the slave processor's memory. */
+int proc4430_read(void *handle, u32 proc_addr, u32 *num_bytes,
+                                                void *buffer);
+
+/* Function to write into the slave processor's memory. */
+int proc4430_write(void *handle, u32 proc_addr, u32 *num_bytes,
+                                        void *buffer);
+
+/* Function to perform device-dependent operations. */
+int proc4430_control(void *handle, int cmd, void *arg);
+
+/* Function to translate between two types of address spaces. */
+int proc4430_translate_addr(void *handle, void **dst_addr,
+                        enum proc_mgr_addr_type dst_addr_type,
+                        void *src_addr, enum proc_mgr_addr_type src_addr_type);
+
+/* Function to retrive physical address translations */
+int proc4430_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
+                                        u32 num_of_entries);
+
+/* =================================================
+ *  APIs
+ * =================================================
+ */
+
+/* Function to get the default configuration for the OMAP4430PROC module */
+void proc4430_get_config(struct proc4430_config *cfg);
+
+/* Function to setup the OMAP4430PROC module. */
+int proc4430_setup(struct proc4430_config *cfg);
+
+/* Function to destroy the OMAP4430PROC module. */
+int proc4430_destroy(void);
+
+/* Function to initialize the parameters for this processor instance. */
+void proc4430_params_init(void *handle,
+                         struct proc4430_params *params);
+
+/* Function to create an instance of this processor. */
+void *proc4430_create(u16 proc_id, const struct proc4430_params *params);
+
+/* Function to delete an instance of this processor. */
+int proc4430_delete(void **handle_ptr);
+
+/* Function to open an instance of this processor. */
+int proc4430_open(void **handle_ptr, u16 proc_id);
+
+/* Function to close an instance of this processor. */
+int proc4430_close(void *handle);
+
+/* Function to get the proc info */
+int proc4430_proc_info(void *handle, struct proc_mgr_proc_info *procinfo);
+
+#endif
diff --git a/drivers/dsp/syslink/procmgr/proc4430/proc4430_drv.c b/drivers/dsp/syslink/procmgr/proc4430/proc4430_drv.c
new file mode 100644
index 00000000000..f7d75db0e6d
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/proc4430/proc4430_drv.c
@@ -0,0 +1,434 @@
+/*
+ * proc4430_drv.c
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <generated/autoconf.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/uaccess.h>
+#include <linux/platform_device.h>
+
+
+/* Module headers */
+#include "proc4430.h"
+#include "proc4430_drvdefs.h"
+
+
+
+/** ============================================================================
+ *  Macros and types
+ *  ============================================================================
+ */
+#define PROC4430_NAME "syslink-proc4430"
+
+static char *driver_name = PROC4430_NAME;
+
+static s32 driver_major;
+
+static s32 driver_minor;
+
+struct proc_4430_dev {
+        struct cdev cdev;
+};
+
+static struct proc_4430_dev *proc_4430_device;
+
+static struct class *proc_4430_class;
+
+
+
+/** ============================================================================
+ *  Forward declarations of internal functions
+ *  ============================================================================
+ */
+/* Linux driver function to open the driver object. */
+static int proc4430_drv_open(struct inode *inode, struct file *filp);
+
+/* Linux driver function to close the driver object. */
+static int proc4430_drv_release(struct inode *inode, struct file *filp);
+
+/* Linux driver function to invoke the APIs through ioctl. */
+static int proc4430_drv_ioctl(struct inode *inode,
+                        struct file *filp, unsigned int cmd,
+                        unsigned long args);
+
+/* Linux driver function to map memory regions to user space. */
+static int proc4430_drv_mmap(struct file *filp,
+                        struct vm_area_struct *vma);
+
+/* Module initialization function for Linux driver. */
+static int __init proc4430_drv_initializeModule(void);
+
+/* Module finalization  function for Linux driver. */
+static void  __exit proc4430_drv_finalizeModule(void);
+
+
+/* Process Context */
+struct proc4430_process_context {
+        u32 setup_count;
+};
+
+/** ============================================================================
+ *  Globals
+ *  ============================================================================
+ */
+
+/*
+  File operations table for PROC4430.
+ */
+static const struct file_operations proc_4430_fops = {
+        .open = proc4430_drv_open,
+        .release = proc4430_drv_release,
+        .ioctl = proc4430_drv_ioctl,
+        .mmap = proc4430_drv_mmap,
+};
+
+static int proc4430_drv_open(struct inode *inode, struct file *filp)
+{
+        s32 retval = 0;
+        struct proc4430_process_context *pr_ctxt = NULL;
+
+        pr_ctxt = kzalloc(sizeof(struct proc4430_process_context), GFP_KERNEL);
+        if (!pr_ctxt)
+                retval = -ENOMEM;
+
+        filp->private_data = pr_ctxt;
+        return retval;
+}
+
+static int proc4430_drv_release(struct inode *inode, struct file *filp)
+{
+        s32 retval = 0;
+        struct proc4430_process_context *pr_ctxt;
+
+        if (!filp->private_data) {
+                retval = -EIO;
+                goto err;
+        }
+
+        pr_ctxt = filp->private_data;
+        while (pr_ctxt->setup_count-- > 0) {
+                /* Destroy has not been called.  Call destroy now. */
+                proc4430_destroy();
+        }
+        kfree(pr_ctxt);
+
+        filp->private_data = NULL;
+err:
+        return retval;
+}
+
+
+/*
+  Linux driver function to invoke the APIs through ioctl.
+ *
+ */
+static int proc4430_drv_ioctl(struct inode *inode, struct file *filp,
+                unsigned int cmd, unsigned long args)
+{
+        int retval = 0;
+        struct proc_mgr_cmd_args *cmd_args = (struct proc_mgr_cmd_args *)args;
+        struct proc_mgr_cmd_args command_args;
+        struct proc4430_process_context *pr_ctxt =
+                (struct proc4430_process_context *)filp->private_data;
+
+        switch (cmd) {
+        case CMD_PROC4430_GETCONFIG:
+        {
+                struct proc4430_cmd_args_get_config *src_args =
+                        (struct proc4430_cmd_args_get_config *)args;
+                struct proc4430_config cfg;
+
+                /* copy_from_useris not needed for
+                * proc4430_get_config, since the
+                * user's config is not used.
+                */
+                proc4430_get_config(&cfg);
+
+                retval = copy_to_user((void __user *)(src_args->cfg),
+                                (const void *)&cfg,
+                                sizeof(struct proc4430_config));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+        }
+        break;
+
+        case CMD_PROC4430_SETUP:
+        {
+                struct proc4430_cmd_args_setup *src_args =
+                        (struct proc4430_cmd_args_setup *)args;
+                struct proc4430_config cfg;
+
+                retval = copy_from_user((void *)&cfg,
+                        (const void __user *)(src_args->cfg),
+                        sizeof(struct proc4430_config));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                proc4430_setup(&cfg);
+                pr_ctxt->setup_count++;
+        }
+        break;
+
+        case CMD_PROC4430_DESTROY:
+        {
+                proc4430_destroy();
+                pr_ctxt->setup_count--;
+        }
+        break;
+
+        case CMD_PROC4430_PARAMS_INIT:
+        {
+                struct proc4430_cmd_args_params_init src_args;
+                struct proc4430_params params;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc4430_cmd_args_params_init));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                proc4430_params_init(src_args.handle, &params);
+                retval = copy_to_user((void __user *)(src_args.params),
+                        (const void *) &params,
+                        sizeof(struct proc4430_params));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+        }
+        break;
+
+        case CMD_PROC4430_CREATE:
+        {
+                struct proc4430_cmd_args_create   src_args;
+                struct proc4430_params params;
+                struct proc4430_mem_entry *entries = NULL;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                                (const void __user *)(args),
+                                sizeof(struct proc4430_cmd_args_create));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_from_user((void *) &params,
+                        (const void __user *)(src_args.params),
+                        sizeof(struct proc4430_params));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                /* Copy the contents of mem_entries from user-side */
+                if (params.num_mem_entries) {
+                        entries = vmalloc(params.num_mem_entries * \
+                                sizeof(struct proc4430_mem_entry));
+                        if (WARN_ON(!entries))
+                                goto func_exit;
+                        retval = copy_from_user((void *) (entries),
+                                (const void __user *)(params.mem_entries),
+                                params.num_mem_entries * \
+                                sizeof(struct proc4430_mem_entry));
+                        if (WARN_ON(retval < 0)) {
+                                vfree(entries);
+                                goto func_exit;
+                        }
+                        params.mem_entries = entries;
+                }
+                src_args.handle = proc4430_create(src_args.proc_id,
+                                                        &params);
+                if (WARN_ON(src_args.handle == NULL))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                                (const void *)&src_args,
+                                sizeof(struct proc4430_cmd_args_create));
+                /* Free the memory created */
+                if (params.num_mem_entries)
+                        vfree(entries);
+        }
+        break;
+
+        case CMD_PROC4430_DELETE:
+        {
+                struct proc4430_cmd_args_delete src_args;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc4430_cmd_args_delete));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = proc4430_delete(&(src_args.handle));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROC4430_OPEN:
+        {
+                struct proc4430_cmd_args_open src_args;
+
+                /*Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                                (const void __user *)(args),
+                                sizeof(struct proc4430_cmd_args_open));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = proc4430_open(&(src_args.handle),
+                                        src_args.proc_id);
+                retval = copy_to_user((void __user *)(args),
+                                (const void *)&src_args,
+                        sizeof(struct proc4430_cmd_args_open));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROC4430_CLOSE:
+        {
+                struct proc4430_cmd_args_close src_args;
+
+                /*Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc4430_cmd_args_close));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = proc4430_close(src_args.handle);
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        default:
+        {
+                printk(KERN_ERR "unsupported ioctl\n");
+        }
+        break;
+        }
+func_exit:
+        /* Set the status and copy the common args to user-side. */
+        command_args.api_status = retval;
+        retval = copy_to_user((void __user *) cmd_args,
+                (const void *) &command_args,
+                 sizeof(struct proc_mgr_cmd_args));
+        WARN_ON(retval < 0);
+        return retval;
+}
+
+
+/*
+  Linux driver function to map memory regions to user space.
+ *
+ */
+static int proc4430_drv_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        vma->vm_page_prot = pgprot_dmacoherent(vma->vm_page_prot);
+
+        if (remap_pfn_range(vma,
+                         vma->vm_start,
+                         vma->vm_pgoff,
+                         vma->vm_end - vma->vm_start,
+                         vma->vm_page_prot)) {
+                return -EAGAIN;
+        }
+        return 0;
+}
+
+
+/** ==================================================================
+ *  Functions required for multiple .ko modules configuration
+ *  ==================================================================
+ */
+/*
+  Module initialization  function for Linux driver.
+ */
+static int __init proc4430_drv_initializeModule(void)
+{
+        dev_t dev = 0 ;
+        int retval;
+
+        /* Display the version info and created date/time */
+        printk(KERN_INFO "proc4430_drv_initializeModule\n");
+
+        if (driver_major) {
+                dev = MKDEV(driver_major, driver_minor);
+                retval = register_chrdev_region(dev, 1, driver_name);
+        } else {
+                retval = alloc_chrdev_region(&dev, driver_minor, 1,
+                                 driver_name);
+                driver_major = MAJOR(dev);
+        }
+
+        proc_4430_device = kmalloc(sizeof(struct proc_4430_dev), GFP_KERNEL);
+        if (!proc_4430_device) {
+                retval = -ENOMEM;
+                unregister_chrdev_region(dev, 1);
+                goto exit;
+        }
+        memset(proc_4430_device, 0, sizeof(struct proc_4430_dev));
+        cdev_init(&proc_4430_device->cdev, &proc_4430_fops);
+        proc_4430_device->cdev.owner = THIS_MODULE;
+        proc_4430_device->cdev.ops = &proc_4430_fops;
+
+        retval = cdev_add(&proc_4430_device->cdev, dev, 1);
+
+        if (retval) {
+                printk(KERN_ERR "Failed to add the syslink proc_4430 device\n");
+                goto exit;
+        }
+
+        /* udev support */
+        proc_4430_class = class_create(THIS_MODULE, "syslink-proc4430");
+
+        if (IS_ERR(proc_4430_class)) {
+                printk(KERN_ERR "Error creating bridge class\n");
+                goto exit;
+        }
+        device_create(proc_4430_class, NULL, MKDEV(driver_major, driver_minor),
+                        NULL, PROC4430_NAME);
+exit:
+        return 0;
+}
+
+/*
+ function to finalize the driver module.
+ */
+static void __exit proc4430_drv_finalizeModule(void)
+{
+        dev_t devno = 0;
+
+        /* FIX ME: THIS MIGHT NOT BE THE RIGHT PLACE TO CALL THE SETUP */
+        proc4430_destroy();
+
+        devno = MKDEV(driver_major, driver_minor);
+        if (proc_4430_device) {
+                cdev_del(&proc_4430_device->cdev);
+                kfree(proc_4430_device);
+        }
+        unregister_chrdev_region(devno, 1);
+        if (proc_4430_class) {
+                /* remove the device from sysfs */
+                device_destroy(proc_4430_class, MKDEV(driver_major,
+                                                driver_minor));
+                class_destroy(proc_4430_class);
+        }
+        return;
+}
+
+/*
+  Macro calls that indicate initialization and finalization functions
+ *                to the kernel.
+ */
+MODULE_LICENSE("GPL v2");
+module_init(proc4430_drv_initializeModule);
+module_exit(proc4430_drv_finalizeModule);
diff --git a/drivers/dsp/syslink/procmgr/proc4430/proc4430_drvdefs.h b/drivers/dsp/syslink/procmgr/proc4430/proc4430_drvdefs.h
new file mode 100644
index 00000000000..4176d731f1d
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/proc4430/proc4430_drvdefs.h
@@ -0,0 +1,169 @@
+/*
+ * proc4430_drvdefs.h
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+#ifndef _SYSLINK_PROC4430_H
+#define _SYSLINK_PROC4430_H
+
+
+/* Module headers */
+#include "../procmgr_drvdefs.h"
+#include "proc4430.h"
+
+
+/*  ----------------------------------------------------------------------------
+ *  IOCTL command IDs for OMAP4430PROC
+ *  ----------------------------------------------------------------------------
+ */
+/*
+ * Base command ID for OMAP4430PROC
+ */
+#define PROC4430_BASE_CMD                0x200
+
+/*
+ * Command for PROC4430_getConfig
+ */
+#define CMD_PROC4430_GETCONFIG          (PROC4430_BASE_CMD + 1)
+
+/*
+ * Command for PROC4430_setup
+ */
+#define CMD_PROC4430_SETUP              (PROC4430_BASE_CMD + 2)
+
+/*
+ * Command for PROC4430_setup
+ */
+#define CMD_PROC4430_DESTROY            (PROC4430_BASE_CMD + 3)
+
+/*
+ * Command for PROC4430_destroy
+ */
+#define CMD_PROC4430_PARAMS_INIT        (PROC4430_BASE_CMD + 4)
+
+/*
+ * Command for PROC4430_create
+ */
+#define CMD_PROC4430_CREATE             (PROC4430_BASE_CMD + 5)
+
+/*
+ * Command for PROC4430_delete
+ */
+#define CMD_PROC4430_DELETE             (PROC4430_BASE_CMD + 6)
+
+/*
+ * Command for PROC4430_open
+ */
+#define CMD_PROC4430_OPEN               (PROC4430_BASE_CMD + 7)
+
+/*
+ * Command for PROC4430_close
+ */
+#define CMD_PROC4430_CLOSE              (PROC4430_BASE_CMD + 8)
+
+
+/*  ---------------------------------------------------
+ *  Command arguments for OMAP4430PROC
+ *  ---------------------------------------------------
+ */
+/*
+ * Command arguments for PROC4430_getConfig
+ */
+struct proc4430_cmd_args_get_config {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        struct proc4430_config *cfg;
+        /* Pointer to the OMAP4430PROC module configuration structure
+        * in which the default config is to be returned. */
+};
+
+/*
+ * Command arguments for PROC4430_setup
+ */
+struct proc4430_cmd_args_setup {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        struct proc4430_config *cfg;
+        /* Optional OMAP4430PROC module configuration. If provided as NULL,
+        * default configuration is used. */
+};
+
+/*
+ * Command arguments for PROC4430_destroy
+ */
+struct proc4430_cmd_args_destroy {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+};
+
+/*
+ * Command arguments for struct struct proc4430_params_init
+ */
+struct proc4430_cmd_args_params_init {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        void *handle;
+        /* void * to the processor instance. */
+        struct proc4430_params *params;
+        /* Configuration parameters. */
+};
+
+/*
+ * Command arguments for PROC4430_create
+ */
+struct proc4430_cmd_args_create {
+        struct proc_mgr_cmd_args         command_args;
+        /* Common command args */
+        u16 proc_id;
+        /* Processor ID for which this processor instance is required. */
+        struct proc4430_params *params;
+        /*Configuration parameters. */
+        void *handle;
+        /* void * to the created processor instance. */
+};
+
+/*
+ * Command arguments for PROC4430_delete
+ */
+struct proc4430_cmd_args_delete {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        void *handle;
+        /* Pointer to handle to the processor instance */
+};
+
+/*
+ * Command arguments for PROC4430_open
+ */
+struct proc4430_cmd_args_open {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        u16 proc_id;
+        /* Processor ID addressed by this OMAP4430PROC instance. */
+        void *handle;
+        /* Return parameter: void * to the processor instance */
+};
+
+/*
+ * Command arguments for PROC4430_close
+ */
+struct proc4430_cmd_args_close {
+        struct proc_mgr_cmd_args command_args;
+        /* Common command args */
+        void *handle;
+        /* void * to the processor instance */
+};
+
+#endif
diff --git a/drivers/dsp/syslink/procmgr/procdefs.h b/drivers/dsp/syslink/procmgr/procdefs.h
new file mode 100644
index 00000000000..d28025835aa
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/procdefs.h
@@ -0,0 +1,155 @@
+/*
+ * procdefs.h
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef SYSLINK_PROCDEFS_H
+#define SYSLINK_PROCDEFS_H
+
+#include <linux/types.h>
+
+/* Module level headers */
+#include <procmgr.h>
+
+
+/* =============================
+ *  Macros and types
+ * =============================
+ */
+/*
+ * Enumerates the types of Endianism of slave processor.
+ */
+enum processor_endian{
+        PROCESSOR_ENDIAN_DEFAULT = 0,
+        /* Default endianism (no conversion required) */
+        PROCESSOR_ENDIAN_BIG = 1,
+        /* Big endian */
+        PROCESSOR_ENDIAN_LITTLE = 2,
+        /* Little endian */
+        PROCESSOR_ENDIAN_ENDVALUE = 3
+        /* End delimiter indicating start of invalid values for this enum */
+};
+
+
+/*
+ * Configuration parameters for attaching to the slave Processor
+ */
+struct processor_attach_params {
+        struct proc_mgr_attach_params *params;
+        /* Common attach parameters for ProcMgr */
+        u16 num_mem_entries;
+        /* Number of valid memory entries */
+        struct proc_mgr_addr_info mem_entries[PROCMGR_MAX_MEMORY_REGIONS];
+        /* Configuration of memory regions */
+};
+
+/*
+ * Function pointer type for the function to attach to the processor.
+ */
+typedef int (*processor_attach_fxn) (void *handle,
+                                struct processor_attach_params *params);
+
+/*
+ * Function pointer type for the function to detach from the
+ * procssor
+ */
+typedef int (*processor_detach_fxn) (void *handle);
+
+/*
+ * Function pointer type for the function to read from the slave
+ *              processor's memory.
+ */
+typedef int (*processor_read_fxn) (void *handle, u32 proc_addr,
+                                u32 *num_bytes, void *buffer);
+
+/*
+ *Function pointer type for the function to write into the slave
+ *processor's memory.
+ */
+typedef int (*processor_write_fxn) (void *handle, u32 proc_addr,
+                                u32 *num_bytes, void *buffer);
+
+/*
+ *Function pointer type for the function to perform device-dependent
+ *              operations.
+ */
+typedef int (*processor_control_fxn) (void *handle, int cmd, void *arg);
+
+/*
+ *Function pointer type for the function to translate between
+ *              two types of address spaces.
+ */
+typedef int (*processor_translate_addr_fxn) (void *handle, void **dst_addr,
+                enum proc_mgr_addr_type dstAddrType, void *srcAddr,
+                enum proc_mgr_addr_type srcAddrType);
+
+/*
+ *Function pointer type for the function that returns proc info
+ */
+typedef int (*processor_proc_info) (void *handle,
+                                struct  proc_mgr_proc_info *proc_info);
+
+/*
+ *Function pointer type for the function that returns proc info
+ */
+typedef int (*processor_virt_to_phys_fxn) (void *handle, u32 da,
+                        u32 *mapped_entries, u32 num_of_entries);
+
+
+/* =============================
+ *  Function table interface
+ * =============================
+ */
+/*
+ *Function table interface for Processor.
+ */
+struct processor_fxn_table {
+        processor_attach_fxn attach;
+        /* Function to attach to the slave processor */
+        processor_detach_fxn detach;
+        /* Function to detach from the slave processor */
+        processor_read_fxn read;
+        /* Function to read from the slave processor's memory */
+        processor_write_fxn write;
+        /* Function to write into the slave processor's memory */
+        processor_control_fxn  control;
+        /* Function to perform device-dependent control function */
+        processor_translate_addr_fxn translateAddr;
+        /* Function to translate between address ranges */
+        processor_proc_info procinfo;
+        /* Function to convert Virtual to Physical pages */
+        processor_virt_to_phys_fxn virt_to_phys;
+};
+
+/* =============================
+ * Processor structure
+ * =============================
+ */
+/*
+ *  Generic Processor object. This object defines the handle type for all
+ *  Processor operations.
+ */
+struct processor_object {
+        struct processor_fxn_table proc_fxn_table;
+        /* interface function table to plug into the generic Processor. */
+        enum proc_mgr_state state;
+        /* State of the slave processor */
+        enum proc_mgr_boot_mode boot_mode;
+        /* Boot mode for the slave processor. */
+        void *object;
+        /* Pointer to Processor-specific object. */
+        u16 proc_id;
+        /* Processor ID addressed by this Processor instance. */
+};
+#endif
diff --git a/drivers/dsp/syslink/procmgr/processor.c b/drivers/dsp/syslink/procmgr/processor.c
new file mode 100644
index 00000000000..34a2d252b3f
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/processor.c
@@ -0,0 +1,293 @@
+/*
+ * processor.c
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <linux/types.h>
+#include <linux/module.h>
+
+/* Module level headers */
+#include "procdefs.h"
+#include "processor.h"
+
+
+
+/* =========================================
+ * Functions called by ProcMgr
+ * =========================================
+ */
+/*
+ * Function to attach to the Processor.
+ *
+ * This function calls into the specific Processor implementation
+ * to attach to it.
+ * This function is called from the ProcMgr attach function, and
+ * hence is used to perform any activities that may be required
+ * once the slave is powered up.
+ * Depending on the type of Processor, this function may or may not
+ * perform any activities.
+ */
+inline int processor_attach(void *handle,
+                                struct processor_attach_params *params)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(params == NULL);
+        BUG_ON(proc_handle->proc_fxn_table.attach == NULL);
+
+        proc_handle->boot_mode = params->params->boot_mode;
+        retval = proc_handle->proc_fxn_table.attach(handle, params);
+
+        if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_BOOT)
+                proc_handle->state = PROC_MGR_STATE_POWERED;
+        else if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOLOAD)
+                proc_handle->state = PROC_MGR_STATE_LOADED;
+        else if (proc_handle->boot_mode == PROC_MGR_BOOTMODE_NOBOOT)
+                proc_handle->state = PROC_MGR_STATE_RUNNNING;
+        return retval;
+}
+
+
+/*
+ * Function to detach from the Processor.
+ *
+ * This function calls into the specific Processor implementation
+ * to detach from it.
+ * This function is called from the ProcMgr detach function, and
+ * hence is useful to perform any activities that may be required
+ * before the slave is powered down.
+ * Depending on the type of Processor, this function may or may not
+ * perform any activities.
+ */
+inline int processor_detach(void *handle)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                        (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(proc_handle->proc_fxn_table.detach == NULL);
+
+        retval = proc_handle->proc_fxn_table.detach(handle);
+        /* For all boot modes, at the end of detach, the Processor is in
+        * unknown state.
+        */
+        proc_handle->state = PROC_MGR_STATE_UNKNOWN;
+        return retval;
+}
+
+
+/*
+ * Function to read from the slave processor's memory.
+ *
+ * This function calls into the specific Processor implementation
+ * to read from the slave processor's memory. It reads from the
+ * specified address in the processor's address space and copies
+ * the required number of bytes into the specified buffer.
+ * It returns the number of bytes actually read in the num_bytes
+ * parameter.
+ * Depending on the processor implementation, it may result in
+ * reading from shared memory or across a peripheral physical
+ * connectivity.
+ * The handle specifies the specific Processor instance to be used.
+ */
+inline int processor_read(void *handle, u32 proc_addr,
+                        u32 *num_bytes, void *buffer)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(proc_addr == 0);
+        BUG_ON(num_bytes == 0);
+        BUG_ON(buffer == NULL);
+        BUG_ON(proc_handle->proc_fxn_table.read == NULL);
+
+        retval = proc_handle->proc_fxn_table.read(handle, proc_addr,
+                                                num_bytes, buffer);
+        return retval;
+}
+
+
+/*
+ * Function to write into the slave processor's memory.
+ *
+ * This function calls into the specific Processor implementation
+ * to write into the slave processor's memory. It writes into the
+ * specified address in the processor's address space and copies
+ * the required number of bytes from the specified buffer.
+ * It returns the number of bytes actually written in the num_bytes
+ * parameter.
+ * Depending on the processor implementation, it may result in
+ * writing into shared memory or across a peripheral physical
+ * connectivity.
+ * The handle specifies the specific Processor instance to be used.
+ */
+inline int processor_write(void *handle, u32 proc_addr, u32 *num_bytes,
+                                                        void *buffer)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+        BUG_ON(handle == NULL);
+        BUG_ON(proc_addr == 0);
+        BUG_ON(num_bytes == 0);
+        BUG_ON(buffer == NULL);
+        BUG_ON(proc_handle->proc_fxn_table.write == NULL);
+
+        retval = proc_handle->proc_fxn_table.write(handle, proc_addr,
+                                                num_bytes, buffer);
+        return retval;
+}
+
+
+/*
+ * Function to get the current state of the slave Processor.
+ *
+ * This function gets the state of the slave processor as
+ * maintained on the master Processor state machine. It does not
+ * go to the slave processor to get its actual state at the time
+ * when this API is called.
+ */
+enum proc_mgr_state processor_get_state(void *handle)
+{
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+
+        return proc_handle->state;
+}
+
+
+/*
+ * Function to set the current state of the slave Processor
+ * to specified value.
+ *
+ * This function is used to set the state of the processor to the
+ * value as specified. This function may be used by external
+ * entities that affect the state of the slave processor, such as
+ * PwrMgr, error handler, or ProcMgr.
+ */
+void processor_set_state(void *handle, enum proc_mgr_state state)
+{
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        proc_handle->state = state;
+}
+
+
+/*
+ * Function to perform device-dependent operations.
+ *
+ * This function calls into the specific Processor implementation
+ * to perform device dependent control operations. The control
+ * operations supported by the device are exposed directly by the
+ * specific implementation of the Processor interface. These
+ * commands and their specific argument types are used with this
+ * function.
+ */
+inline int processor_control(void *handle, int cmd, void *arg)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(proc_handle->proc_fxn_table.control == NULL);
+
+        retval = proc_handle->proc_fxn_table.control(handle, cmd, arg);
+        return retval;
+}
+
+
+/*
+ * Function to translate between two types of address spaces.
+ *
+ * This function translates addresses between two types of address
+ * spaces. The destination and source address types are indicated
+ * through parameters specified in this function.
+ */
+inline int processor_translate_addr(void *handle, void **dst_addr,
+                enum proc_mgr_addr_type dst_addr_type, void *src_addr,
+                enum proc_mgr_addr_type src_addr_type)
+{
+        int retval = 0;
+        struct processor_object *proc_handle =
+                                        (struct processor_object *)handle;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(dst_addr == NULL);
+        BUG_ON(src_addr == NULL);
+        BUG_ON(dst_addr_type >= PROC_MGR_ADDRTYPE_ENDVALUE);
+        BUG_ON(src_addr_type >= PROC_MGR_ADDRTYPE_ENDVALUE);
+        BUG_ON(proc_handle->proc_fxn_table.translateAddr == NULL);
+
+        retval = proc_handle->proc_fxn_table.translateAddr(handle,
+                        dst_addr, dst_addr_type, src_addr, src_addr_type);
+        return retval;
+}
+
+
+/*
+ * Function that registers for notification when the slave
+ * processor transitions to any of the states specified.
+ *
+ * This function allows the user application to register for
+ * changes in processor state and take actions accordingly.
+
+ */
+inline int processor_register_notify(void *handle, proc_mgr_callback_fxn fxn,
+                                void *args, enum proc_mgr_state state[])
+{
+        int retval = 0;
+
+        BUG_ON(handle == NULL);
+        BUG_ON(fxn == NULL);
+
+        /* TODO: TBD: To be implemented. */
+        return retval;
+}
+
+/*
+ * Function that returns the proc instance mem info
+ */
+int processor_get_proc_info(void *handle, struct proc_mgr_proc_info *procinfo)
+{
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+        int retval;
+        retval = proc_handle->proc_fxn_table.procinfo(proc_handle, procinfo);
+        return retval;
+}
+
+/*
+ * Function that returns the address translations
+ */
+int processor_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
+                                                u32 num_of_entries)
+{
+        struct processor_object *proc_handle =
+                                (struct processor_object *)handle;
+        int retval;
+        retval = proc_handle->proc_fxn_table.virt_to_phys(handle, da,
+                                mapped_entries, num_of_entries);
+        return retval;
+}
diff --git a/drivers/dsp/syslink/procmgr/processor.h b/drivers/dsp/syslink/procmgr/processor.h
new file mode 100644
index 00000000000..13942e91e84
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/processor.h
@@ -0,0 +1,70 @@
+/*
+ * processor.h
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef SYSLINK_PROCESSOR_H_
+#define SYSLINK_PROCESSOR_H_
+
+#include <linux/types.h>
+
+/* Module level headers */
+#include "procdefs.h"
+
+/* ===================================
+ *  APIs
+ * ===================================
+ */
+/* Function to attach to the Processor. */
+int processor_attach(void *handle, struct processor_attach_params *params);
+
+/* Function to detach from the Processor. */
+int processor_detach(void *handle);
+
+/* Function to read from the slave processor's memory. */
+int processor_read(void *handle, u32 proc_addr, u32 *num_bytes, void *buffer);
+
+/* Function to read write into the slave processor's memory. */
+int processor_write(void *handle, u32 proc_addr, u32 *num_bytes, void *buffer);
+
+/* Function to get the current state of the slave Processor as maintained on
+ * the master Processor state machine.
+ */
+enum proc_mgr_state processor_get_state(void *handle);
+
+/* Function to set the current state of the slave Processor to specified value.
+ */
+void processor_set_state(void *handle, enum proc_mgr_state state);
+
+/* Function to perform device-dependent operations. */
+int processor_control(void *handle, int cmd, void *arg);
+
+/* Function to translate between two types of address spaces. */
+int processor_translate_addr(void *handle, void **dst_addr,
+        enum proc_mgr_addr_type dst_addr_type, void *src_addr,
+        enum proc_mgr_addr_type src_addr_type);
+
+/* Function that registers for notification when the slave processor
+ * transitions to any of the states specified.
+ */
+int processor_register_notify(void *handle, proc_mgr_callback_fxn fxn,
+                void *args, enum proc_mgr_state state[]);
+
+/* Function that returns the return value of specific processor info
+ */
+int processor_get_proc_info(void *handle, struct proc_mgr_proc_info *procinfo);
+
+int processor_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
+                                                u32 num_of_entries);
+#endif
diff --git a/drivers/dsp/syslink/procmgr/procmgr.c b/drivers/dsp/syslink/procmgr/procmgr.c
new file mode 100644
index 00000000000..b0ce1d1dc3d
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/procmgr.c
@@ -0,0 +1,790 @@
+/*
+ * procmgr.c
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <asm/atomic.h>
+
+/* Module level headers */
+#include <procmgr.h>
+#include "procdefs.h"
+#include "processor.h"
+#include <syslink/atomic_linux.h>
+
+/* ================================
+ *  Macros and types
+ * ================================
+ */
+/*! @brief Macro to make a correct module magic number with refCount */
+#define PROCMGR_MAKE_MAGICSTAMP(x) ((PROCMGR_MODULEID << 12u) | (x))
+
+/*
+ *  ProcMgr Module state object
+ */
+struct proc_mgr_module_object {
+        atomic_t ref_count;
+        u32 config_size;
+        /* Size of configuration structure */
+        struct proc_mgr_config cfg;
+        /* ProcMgr configuration structure */
+        struct proc_mgr_config def_cfg;
+        /* Default module configuration */
+        struct proc_mgr_params def_inst_params;
+        /* Default parameters for the ProcMgr instances */
+        struct proc_mgr_attach_params def_attach_params;
+        /* Default parameters for the ProcMgr attach function */
+        struct mutex *gate_handle;
+        /* handle of gate to be used for local thread safety */
+        void *proc_handles[MULTIPROC_MAXPROCESSORS];
+        /* Array of handles of ProcMgr instances */
+};
+
+/*
+ * ProcMgr instance object
+ */
+struct proc_mgr_object {
+        u16 proc_id;
+        /* Processor ID associated with this ProcMgr. */
+        struct processor_object *proc_handle;
+        /* Processor ID of the processor being represented by this instance. */
+        void *loader_handle;
+        /*!< Handle to the Loader object associated with this ProcMgr. */
+        void *pwr_handle;
+        /*!< Handle to the PwrMgr object associated with this ProcMgr. */
+        /*!< Processor ID of the processor being represented by this instance */
+        struct proc_mgr_params params;
+        /* ProcMgr instance params structure */
+        struct proc_mgr_attach_params attach_params;
+        /* ProcMgr attach params structure */
+        u32 file_id;
+        /*!< File ID of the loaded static executable */
+        u16 num_mem_entries;
+        /* Number of valid memory entries */
+        struct proc_mgr_addr_info mem_entries[PROCMGR_MAX_MEMORY_REGIONS];
+        /* Configuration of memory regions */
+};
+
+static struct proc_mgr_module_object proc_mgr_obj_state = {
+        .config_size = sizeof(struct proc_mgr_config),
+        .def_cfg.gate_handle = NULL,
+        .gate_handle = NULL,
+        .def_inst_params.proc_handle   = NULL,
+        .def_attach_params.boot_mode = PROC_MGR_BOOTMODE_BOOT,
+};
+
+
+/*======================================
+ * Function to get the default configuration for the ProcMgr
+ * module.
+ *
+* This function can be called by the application to get their
+* configuration parameter to ProcMgr_setup filled in by the
+* ProcMgr module with the default parameters. If the user does
+* not wish to make any change in the default parameters, this API
+* is not required to be called.
+ */
+void proc_mgr_get_config(struct proc_mgr_config *cfg)
+{
+        BUG_ON(cfg == NULL);
+        memcpy(cfg, &proc_mgr_obj_state.def_cfg,
+                        sizeof(struct proc_mgr_config));
+        return;
+}
+EXPORT_SYMBOL(proc_mgr_get_config);
+
+/*
+ * Function to setup the ProcMgr module.
+ *
+ *This function sets up the ProcMgr module. This function must
+ *be called before any other instance-level APIs can be invoked.
+ *Module-level configuration needs to be provided to this
+ *function. If the user wishes to change some specific config
+ *parameters, then ProcMgr_getConfig can be called to get the
+ *configuration filled with the default values. After this, only
+ *the required configuration values can be changed. If the user
+ *does not wish to make any change in the default parameters, the
+ *application can simply call ProcMgr_setup with NULL parameters.
+ *The default parameters would get automatically used.
+ */
+int proc_mgr_setup(struct proc_mgr_config *cfg)
+{
+        int retval = 0;
+        struct proc_mgr_config tmp_cfg;
+
+        /* This sets the refCount variable is not initialized, upper 16 bits is
+        * written with module Id to ensure correctness of refCount variable.
+        */
+        atomic_cmpmask_and_set(&proc_mgr_obj_state.ref_count,
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(0));
+
+        if (atomic_inc_return(&proc_mgr_obj_state.ref_count)
+                != PROCMGR_MAKE_MAGICSTAMP(1u))
+                return 0;
+        if (cfg == NULL) {
+                proc_mgr_get_config(&tmp_cfg);
+                cfg = &tmp_cfg;
+        }
+        if (cfg->gate_handle != NULL) {
+                proc_mgr_obj_state.gate_handle = cfg->gate_handle;
+        } else {
+                /* User has not provided any gate handle, so create a
+                *default handle.
+                */
+                proc_mgr_obj_state.gate_handle = kmalloc(sizeof(struct mutex),
+                                                GFP_KERNEL);
+                mutex_init(proc_mgr_obj_state.gate_handle);
+        }
+        memcpy(&proc_mgr_obj_state.cfg, cfg, sizeof(struct proc_mgr_config));
+        /* Initialize the procHandles array. */
+        memset(&proc_mgr_obj_state.proc_handles, 0,
+                (sizeof(void *) * MULTIPROC_MAXPROCESSORS));
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_setup);
+
+/*==================================
+ *  Function to destroy the ProcMgr module.
+ *
+ * Once this function is called, other ProcMgr module APIs, except
+ * for the proc_mgr_get_config API cannot be called anymore.
+ */
+int proc_mgr_destroy(void)
+{
+        int retval = 0;
+        int i;
+
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_destroy: Error - module not initialized\n");
+                return -EFAULT;
+        }
+        if (atomic_dec_return(&proc_mgr_obj_state.ref_count)
+                 == PROCMGR_MAKE_MAGICSTAMP(0)) {
+
+                /* Check if any ProcMgr instances have not been deleted so far
+                *. If not,delete them
+                */
+                for (i = 0 ; i < MULTIPROC_MAXPROCESSORS; i++) {
+                        if (proc_mgr_obj_state.proc_handles[i] != NULL)
+                                proc_mgr_delete
+                                (&(proc_mgr_obj_state.proc_handles[i]));
+                }
+
+                mutex_destroy(proc_mgr_obj_state.gate_handle);
+                kfree(proc_mgr_obj_state.gate_handle);
+                /* Decrease the refCount */
+                atomic_set(&proc_mgr_obj_state.ref_count,
+                        PROCMGR_MAKE_MAGICSTAMP(0));
+        }
+        return retval;;
+}
+EXPORT_SYMBOL(proc_mgr_destroy);
+
+/*=====================================
+ *  Function to initialize the parameters for the ProcMgr instance.
+ *
+ * This function can be called by the application to get their
+ * configuration parameter to ProcMgr_create filled in by the
+ * ProcMgr module with the default parameters.
+ */
+void proc_mgr_params_init(void *handle, struct proc_mgr_params *params)
+{
+        struct proc_mgr_object *proc_handle = (struct proc_mgr_object *)handle;
+
+        if (WARN_ON(params == NULL))
+                goto exit;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_params_init: Error - module not initialized\n");
+        }
+        if (handle == NULL) {
+                memcpy(params, &(proc_mgr_obj_state.def_inst_params),
+                                sizeof(struct proc_mgr_params));
+        } else {
+                /* Return updated ProcMgr instance specific parameters. */
+                memcpy(params, &(proc_handle->params),
+                                sizeof(struct proc_mgr_params));
+        }
+exit:
+        return;
+}
+EXPORT_SYMBOL(proc_mgr_params_init);
+
+/*=====================================
+ *  Function to create a ProcMgr object for a specific slave
+ * processor.
+ *
+ * This function creates an instance of the ProcMgr module and
+ * returns an instance handle, which is used to access the
+ * specified slave processor. The processor ID specified here is
+ * the ID of the slave processor as configured with the MultiProc
+ * module.
+ * Instance-level configuration needs to be provided to this
+ * function. If the user wishes to change some specific config
+ * parameters, then struct proc_mgr_params_init can be called to get the
+ * configuration filled with the default values. After this, only
+ * the required configuration values can be changed. For this
+ * API, the params argument is not optional, since the user needs
+ * to provide some essential values such as loader, PwrMgr and
+ * Processor instances to be used with this ProcMgr instance.
+ */
+void *proc_mgr_create(u16 proc_id, const struct proc_mgr_params *params)
+{
+        struct proc_mgr_object *handle = NULL;
+
+        BUG_ON(!IS_VALID_PROCID(proc_id));
+        BUG_ON(params == NULL);
+        BUG_ON(params->proc_handle == NULL);
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_create: Error - module not initialized\n");
+                return NULL;
+        }
+        if (proc_mgr_obj_state.proc_handles[proc_id] != NULL) {
+                handle = proc_mgr_obj_state.proc_handles[proc_id];
+                printk(KERN_WARNING "proc_mgr_create:"
+                        "Processor already exists for specified"
+                        "%d  proc_id, handle = 0x%x\n", proc_id, (u32)handle);
+                return handle;
+        }
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        handle = (struct proc_mgr_object *)
+                                vmalloc(sizeof(struct proc_mgr_object));
+        BUG_ON(handle == NULL);
+        memset(handle, 0, sizeof(struct proc_mgr_object));
+        memcpy(&(handle->params), params, sizeof(struct proc_mgr_params));
+        handle->proc_id = proc_id;
+        handle->proc_handle = params->proc_handle;
+        handle->loader_handle = params->loader_handle;
+        handle->pwr_handle = params->pwr_handle;
+        proc_mgr_obj_state.proc_handles[proc_id] = handle;
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return handle;
+}
+EXPORT_SYMBOL(proc_mgr_create);
+
+/*===================================
+ *  Function to delete a ProcMgr object for a specific slave
+ * processor.
+ *
+ * Once this function is called, other ProcMgr instance level APIs
+ * that require the instance handle cannot be called.
+ *
+ */
+int
+proc_mgr_delete(void **handle_ptr)
+{
+        int retval = 0;
+        struct proc_mgr_object *handle;
+
+        BUG_ON(handle_ptr == NULL);
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_delete: Error - module not initialized\n");
+                return -EFAULT;
+        }
+
+        handle = (struct proc_mgr_object *)(*handle_ptr);
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        proc_mgr_obj_state.proc_handles[handle->proc_id] = NULL;
+        vfree(handle);
+        *handle_ptr = NULL;
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_delete);
+
+/*======================================
+ *  Function to open a handle to an existing ProcMgr object handling
+ * the proc_id.
+ *
+ * This function returns a handle to an existing ProcMgr instance
+ * created for this proc_id. It enables other entities to access
+ * and use this ProcMgr instance.
+ */
+int proc_mgr_open(void **handle_ptr, u16 proc_id)
+{
+        int retval = 0;
+
+        BUG_ON(handle_ptr == NULL);
+        BUG_ON(!IS_VALID_PROCID(proc_id));
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_open: Error - module not initialized\n");
+                return -EFAULT;
+        }
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        *handle_ptr = proc_mgr_obj_state.proc_handles[proc_id];
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_open);
+
+/*=====================================
+ *  Function to close this handle to the ProcMgr instance.
+ *
+ * This function closes the handle to the ProcMgr instance
+ * obtained through proc_mgr_open call made earlier.
+ */
+int proc_mgr_close(void *handle)
+{
+        int retval = 0;
+
+        BUG_ON(handle == NULL);
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_close: Error - module not initialized\n");
+                return -EFAULT;
+        }
+        /* Nothing to be done for closing the handle. */
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_close);
+
+/*========================================
+ *  Function to initialize the parameters for the ProcMgr attach
+ * function.
+ *
+ * This function can be called by the application to get their
+ * configuration parameter to proc_mgr_attach filled in by the
+ * ProcMgr module with the default parameters. If the user does
+ * not wish to make any change in the default parameters, this API
+ * is not required to be called.
+ */
+void proc_mgr_get_attach_params(void *handle,
+                                struct proc_mgr_attach_params *params)
+{
+        struct proc_mgr_object *proc_mgr_handle =
+                                (struct proc_mgr_object *)handle;
+        BUG_ON(params == NULL);
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_get_attach_params:"
+                        "Error - module not initialized\n");
+        }
+        if (handle == NULL) {
+                memcpy(params, &(proc_mgr_obj_state.def_attach_params),
+                                sizeof(struct proc_mgr_attach_params));
+        } else {
+                /* Return updated ProcMgr instance specific parameters. */
+                memcpy(params, &(proc_mgr_handle->attach_params),
+                                sizeof(struct proc_mgr_attach_params));
+        }
+        return;
+}
+EXPORT_SYMBOL(proc_mgr_get_attach_params);
+
+/*
+ *  Function to attach the client to the specified slave and also
+ * initialize the slave (if required).
+ *
+ * This function attaches to an instance of the ProcMgr module and
+ * performs any hardware initialization required to power up the
+ * slave device. This function also performs the required state
+ * transitions for this ProcMgr instance to ensure that the local
+ * object representing the slave device correctly indicates the
+ * state of the slave device. Depending on the slave boot mode
+ * being used, the slave may be powered up, in reset, or even
+ * running state.
+ * Configuration parameters need to be provided to this
+ * function. If the user wishes to change some specific config
+ * parameters, then proc_mgr_get_attach_params can be called to get
+ * the configuration filled with the default values. After this,
+ * only the required configuration values can be changed. If the
+ * user does not wish to make any change in the default parameters,
+ * the application can simply call proc_mgr_attach with NULL
+ * parameters.
+ * The default parameters would get automatically used.
+ */
+int proc_mgr_attach(void *handle, struct proc_mgr_attach_params *params)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                (struct proc_mgr_object *)handle;
+        struct proc_mgr_attach_params tmp_params;
+        struct processor_attach_params proc_attach_params;
+
+        if (params == NULL) {
+                proc_mgr_get_attach_params(handle, &tmp_params);
+                params = &tmp_params;
+        }
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_attach:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        if (WARN_ON(handle == NULL)) {
+                retval = -EFAULT;
+                goto exit;
+        }
+        if (WARN_ON(params->boot_mode == PROC_MGR_BOOTMODE_ENDVALUE)) {
+                retval = -EINVAL;
+                goto exit;
+        }
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        /* Copy the user provided values into the instance object. */
+        memcpy(&(proc_mgr_handle->attach_params), params,
+                                sizeof(struct proc_mgr_attach_params));
+        proc_attach_params.params = params;
+        proc_attach_params.num_mem_entries = 0;
+        /* Attach to the specified Processor instance. */
+        retval = processor_attach(proc_mgr_handle->proc_handle,
+                                        &proc_attach_params);
+        proc_mgr_handle->num_mem_entries = proc_attach_params.num_mem_entries;
+        printk(KERN_INFO "proc_mgr_attach:proc_mgr_handle->num_mem_entries = %d\n",
+                        proc_mgr_handle->num_mem_entries);
+        /* Store memory information in local object.*/
+        memcpy(&(proc_mgr_handle->mem_entries),
+                &(proc_attach_params.mem_entries),
+                sizeof(proc_mgr_handle->mem_entries));
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+exit:
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_attach);
+
+/*===================================
+ *  Function to detach the client from the specified slave and also
+ * finalze the slave (if required).
+ *
+ * This function detaches from an instance of the ProcMgr module
+ * and performs any hardware finalization required to power down
+ * the slave device. This function also performs the required state
+ * transitions for this ProcMgr instance to ensure that the local
+ * object representing the slave device correctly indicates the
+ * state of the slave device. Depending on the slave boot mode
+ * being used, the slave may be powered down, in reset, or left in
+ * its original state.
+*/
+int proc_mgr_detach(void *handle)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                (struct proc_mgr_object *)handle;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_detach:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(handle == NULL);
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        /* Detach from the Processor. */
+        retval = processor_detach(proc_mgr_handle->proc_handle);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_detach);
+
+/*===================================
+ *  Function to get the current state of the slave Processor.
+ *
+ * This function gets the state of the slave processor as
+ * maintained on the master Processor state machine. It does not
+ * go to the slave processor to get its actual state at the time
+ * when this API is called.
+ *
+ */
+enum proc_mgr_state proc_mgr_get_state(void *handle)
+{
+        struct proc_mgr_object *proc_mgr_handle =
+                                (struct proc_mgr_object *)handle;
+        enum proc_mgr_state state = PROC_MGR_STATE_UNKNOWN;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_get_state:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(handle == NULL);
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        state = processor_get_state(proc_mgr_handle->proc_handle);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return state;
+}
+EXPORT_SYMBOL(proc_mgr_get_state);
+
+/*==================================================
+ *  Function to read from the slave processor's memory.
+ *
+ * This function reads from the specified address in the
+ * processor's address space and copies the required number of
+ * bytes into the specified buffer.
+ * It returns the number of bytes actually read in thenum_bytes
+ * parameter.
+ */
+int proc_mgr_read(void *handle, u32 proc_addr, u32 *num_bytes, void *buffer)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                        (struct proc_mgr_object *)handle;
+        void *addr;
+
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_read:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(handle == NULL);
+        BUG_ON(proc_addr == 0);
+        BUG_ON(num_bytes == NULL);
+        BUG_ON(buffer == NULL);
+
+        /* Check if the address is already mapped */
+        retval = proc_mgr_translate_addr(handle,
+                                        (void **) &addr,
+                                        PROC_MGR_ADDRTYPE_MASTERKNLVIRT,
+                                        (void *) proc_addr,
+                                        PROC_MGR_ADDRTYPE_SLAVEVIRT);
+
+
+        if (retval >= 0) {
+                /* Enter critical section protection. */
+                WARN_ON(mutex_lock_interruptible(
+                                        proc_mgr_obj_state.gate_handle));
+
+                retval = processor_read(proc_mgr_handle->proc_handle, (u32)addr,
+                                                        num_bytes, buffer);
+
+                /* Leave critical section protection. */
+                mutex_unlock(proc_mgr_obj_state.gate_handle);
+        }
+
+        WARN_ON(retval < 0);
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_read);
+
+/*
+ *  Function to write into the slave processor's memory.
+ *
+ * This function writes into the specified address in the
+ * processor's address space and copies the required number of
+ * bytes from the specified buffer.
+ * It returns the number of bytes actually written in thenum_bytes
+ * parameter.
+ */
+int proc_mgr_write(void *handle, u32 proc_addr, u32 *num_bytes, void *buffer)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                        (struct proc_mgr_object *)handle;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_write:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(proc_addr == 0);
+        BUG_ON(num_bytes == NULL);
+        BUG_ON(buffer == NULL);
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        retval = processor_write(proc_mgr_handle->proc_handle, proc_addr,
+                                                        num_bytes, buffer);
+        WARN_ON(retval < 0);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;;
+}
+EXPORT_SYMBOL(proc_mgr_write);
+
+
+/*===================================
+ *  Function to perform device-dependent operations.
+ *
+ * This function performs control operations supported by the
+ * as exposed directly by the specific implementation of the
+ * Processor interface. These commands and their specific argument
+ * types are used with this function.
+ */
+int proc_mgr_control(void *handle, int cmd, void *arg)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle
+                                        = (struct proc_mgr_object *)handle;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_control:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(handle == NULL);
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        /* Perform device-dependent control operation. */
+        retval = processor_control(proc_mgr_handle->proc_handle, cmd, arg);
+        WARN_ON(retval < 0);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;;
+}
+EXPORT_SYMBOL(proc_mgr_control);
+
+/*========================================
+ *  Function to translate between two types of address spaces.
+ *
+ * This function translates addresses between two types of address
+ * spaces. The destination and source address types are indicated
+ * through parameters specified in this function.
+ */
+int proc_mgr_translate_addr(void *handle, void **dst_addr,
+                enum proc_mgr_addr_type dst_addr_type, void *src_addr,
+                enum proc_mgr_addr_type src_addr_type)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                        (struct proc_mgr_object *)handle;
+
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_translate_addr:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(dst_addr == NULL);
+        BUG_ON(handle == NULL);
+        BUG_ON(dst_addr_type > PROC_MGR_ADDRTYPE_ENDVALUE);
+        BUG_ON(src_addr == NULL);
+        BUG_ON(src_addr_type > PROC_MGR_ADDRTYPE_ENDVALUE);
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        /* Translate the address. */
+        retval = processor_translate_addr(proc_mgr_handle->proc_handle,
+                dst_addr, dst_addr_type, src_addr, src_addr_type);
+        WARN_ON(retval < 0);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;;
+}
+EXPORT_SYMBOL(proc_mgr_translate_addr);
+
+/*=================================
+ *  Function that registers for notification when the slave
+ * processor transitions to any of the states specified.
+ *
+ * This function allows the user application to register for
+ * changes in processor state and take actions accordingly.
+ *
+ */
+int proc_mgr_register_notify(void *handle, proc_mgr_callback_fxn fxn,
+                                void *args, enum proc_mgr_state state[])
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle
+                                = (struct proc_mgr_object *)handle;
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_register_notify:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        BUG_ON(handle == NULL);
+        BUG_ON(fxn == NULL);
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+        retval = processor_register_notify(proc_mgr_handle->proc_handle, fxn,
+                                        args, state);
+        WARN_ON(retval < 0);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;
+}
+EXPORT_SYMBOL(proc_mgr_register_notify);
+
+/*
+ *  Function that returns information about the characteristics of
+ * the slave processor.
+ */
+int proc_mgr_get_proc_info(void *handle, struct proc_mgr_proc_info *proc_info)
+{
+        struct proc_mgr_object *proc_mgr_handle =
+                                        (struct proc_mgr_object *)handle;
+        struct processor_object *proc_handle;
+
+        struct proc_mgr_proc_info proc_info_test;
+
+        if (atomic_cmpmask_and_lt(&(proc_mgr_obj_state.ref_count),
+                PROCMGR_MAKE_MAGICSTAMP(0), PROCMGR_MAKE_MAGICSTAMP(1))
+                 == true) {
+                printk(KERN_ERR "proc_mgr_get_proc_info:"
+                        "Error - module not initialized\n");
+                return -EFAULT;
+        }
+        if (WARN_ON(handle == NULL))
+                goto error_exit;
+        if (WARN_ON(proc_info == NULL))
+                goto error_exit;
+        proc_handle = proc_mgr_handle->proc_handle;
+        if (WARN_ON(proc_handle == NULL))
+                goto error_exit;
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+
+        processor_get_proc_info(proc_handle, &proc_info_test);
+        /* Return bootMode information. */
+        proc_info->boot_mode = proc_mgr_handle->attach_params.boot_mode;
+        /* Return memory information. */
+        proc_info->num_mem_entries = proc_mgr_handle->num_mem_entries;
+        memcpy(&(proc_info->mem_entries),
+                        &(proc_mgr_handle->mem_entries),
+                        sizeof(proc_mgr_handle->mem_entries));
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return 0;
+error_exit:
+        return -EFAULT;
+}
+EXPORT_SYMBOL(proc_mgr_get_proc_info);
+
+/*============================================
+ *  Function to get virtual to physical address translations
+ *
+ * This function retrieves physical entries
+ *
+ */
+int proc_mgr_virt_to_phys(void *handle, u32 da, u32 *mapped_entries,
+                                                u32 num_of_entries)
+{
+        int retval = 0;
+        struct proc_mgr_object *proc_mgr_handle =
+                                (struct proc_mgr_object *)handle;
+
+        WARN_ON(mutex_lock_interruptible(proc_mgr_obj_state.gate_handle));
+
+        /* Map to host address space. */
+        retval = processor_virt_to_phys(proc_mgr_handle->proc_handle, da,
+                                mapped_entries, num_of_entries);
+        WARN_ON(retval < 0);
+        mutex_unlock(proc_mgr_obj_state.gate_handle);
+        return retval;;
+}
+EXPORT_SYMBOL(proc_mgr_virt_to_phys);
diff --git a/drivers/dsp/syslink/procmgr/procmgr_drv.c b/drivers/dsp/syslink/procmgr/procmgr_drv.c
new file mode 100644
index 00000000000..6bb6e7ab594
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/procmgr_drv.c
@@ -0,0 +1,731 @@
+/*
+ * procmgr_drv.c
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+#include <generated/autoconf.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/platform_device.h>
+
+#include <plat/cpu.h>
+
+/* Module headers */
+#include <procmgr.h>
+#include "procmgr_drvdefs.h"
+
+#define PROCMGR_NAME "syslink-procmgr"
+
+static char *driver_name = PROCMGR_NAME;
+
+static s32 driver_major;
+
+static s32 driver_minor;
+
+struct procmgr_dev {
+        struct cdev cdev;
+};
+
+static struct platform_device   *omap_proc_dev;
+static struct platform_device   *procmgr_pdev;
+static struct procmgr_dev *procmgr_device;
+
+static struct class *proc_mgr_class;
+
+
+/** ====================================
+ *  Forward declarations of internal functions
+ *  ====================================
+ */
+/* Linux driver function to open the driver object. */
+static int proc_mgr_drv_open(struct inode *inode, struct file *filp);
+
+/* Linux driver function to close the driver object. */
+static int proc_mgr_drv_release(struct inode *inode, struct file *filp);
+
+/* Linux driver function to invoke the APIs through ioctl. */
+static int proc_mgr_drv_ioctl(struct inode *inode,
+                                 struct file *filp,
+                                 unsigned int cmd,
+                                 unsigned long args);
+
+/* Linux driver function to map memory regions to user space. */
+static int proc_mgr_drv_mmap(struct file *filp, struct vm_area_struct *vma);
+
+/* Module initialization function for Linux driver. */
+static int __init proc_mgr_drv_initialize_module(void);
+
+/* Module finalization  function for Linux driver. */
+static void  __exit proc_mgr_drv_finalize_module(void);
+
+/* Platform driver probe function */
+static int __devinit proc_mgr_probe(struct platform_device *pdev);
+
+/* Platform driver remove function */
+static int __devexit proc_mgr_remove(struct platform_device *pdev);
+
+/*
+ * name   DriverOps
+ *
+ * desc   Function to invoke the APIs through ioctl
+ *
+ */
+static const struct file_operations procmgr_fops = {
+        .open  =  proc_mgr_drv_open,
+        .ioctl =  proc_mgr_drv_ioctl,
+        .release = proc_mgr_drv_release,
+        .mmap = proc_mgr_drv_mmap,
+} ;
+
+/* Imtiaz changed places */
+static struct platform_driver procmgr_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = PROCMGR_NAME,
+        },
+        .probe          = proc_mgr_probe,
+        .remove         = __devexit_p(proc_mgr_remove),
+        .shutdown       = NULL,
+        .suspend        = NULL,
+        .resume         = NULL,
+};
+
+/* Process Context */
+struct procmgr_process_context {
+        u32 setup_count;
+};
+
+/*
+* brief  Linux specific function to open the driver.
+ */
+static int proc_mgr_drv_open(struct inode *inode, struct file *filp)
+{
+        s32 retval = 0;
+        struct procmgr_process_context *pr_ctxt = NULL;
+
+        pr_ctxt = kzalloc(sizeof(struct procmgr_process_context), GFP_KERNEL);
+        if (!pr_ctxt)
+                retval = -ENOMEM;
+
+        filp->private_data = pr_ctxt;
+        return retval;
+}
+
+/*
+* brief  Linux driver function to close the driver object.
+ */
+static int proc_mgr_drv_release(struct inode *inode, struct file *filp)
+{
+        s32 retval = 0;
+        struct procmgr_process_context *pr_ctxt;
+
+        if (!filp->private_data) {
+                retval = -EIO;
+                goto err;
+        }
+
+        pr_ctxt = filp->private_data;
+        while (pr_ctxt->setup_count-- > 0) {
+                /* Destroy has not been called.  Call destroy now. */
+                printk(KERN_ERR "proc_mgr_drv_release: "
+                        "proc_mgr_destroy %d\n", pr_ctxt->setup_count);
+                proc_mgr_destroy();
+        }
+        kfree(pr_ctxt);
+
+        filp->private_data = NULL;
+err:
+        return retval;
+}
+
+/*
+* Linux driver function to invoke the APIs through ioctl.
+ */
+static int proc_mgr_drv_ioctl(struct inode *inode, struct file *filp,
+                        unsigned int cmd, unsigned long args)
+{
+        int retval = 0;
+        struct proc_mgr_cmd_args *cmd_args = (struct proc_mgr_cmd_args *)args;
+        struct proc_mgr_cmd_args command_args;
+        struct procmgr_process_context *pr_ctxt =
+                (struct procmgr_process_context *)filp->private_data;
+
+        switch (cmd) {
+        case CMD_PROCMGR_GETCONFIG:
+        {
+                struct proc_mgr_cmd_args_get_config *src_args =
+                        (struct proc_mgr_cmd_args_get_config *)args;
+                struct proc_mgr_config cfg;
+
+                /* copy_from_user is not needed for proc_mgr_get_config,
+                * since the user's config is not used.
+                */
+                proc_mgr_get_config(&cfg);
+
+                retval = copy_to_user((void __user *)(src_args->cfg),
+                                (const void *)&cfg,
+                                sizeof(struct proc_mgr_config));
+
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_SETUP:
+        {
+                struct proc_mgr_cmd_args_setup *src_args =
+                        (struct proc_mgr_cmd_args_setup *)args;
+                struct proc_mgr_config cfg;
+
+                retval = copy_from_user((void *)&cfg,
+                                (const void __user *)(src_args->cfg),
+                                sizeof(struct proc_mgr_config));
+
+                /* This check is needed at run-time also since it
+                * depends on run environment.
+                * It must not be optimized out.
+                */
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+
+                retval = proc_mgr_setup(&cfg);
+                if (retval >= 0)
+                        pr_ctxt->setup_count++;
+        }
+        break;
+
+        case CMD_PROCMGR_DESTROY:
+        {
+                retval = proc_mgr_destroy();
+                pr_ctxt->setup_count--;
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_PARAMS_INIT:
+        {
+                struct proc_mgr_cmd_args_params_init src_args;
+                struct proc_mgr_params params;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc_mgr_cmd_args_params_init));
+
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+
+                        proc_mgr_params_init(src_args.handle, &params);
+
+                /* Copy only the params to user-side */
+                retval = copy_to_user((void __user *)(src_args.params),
+                                (const void *)&params,
+                                sizeof(struct proc_mgr_params));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_CREATE:
+        {
+                struct proc_mgr_cmd_args_create src_args;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_create));
+
+                src_args.handle = proc_mgr_create(src_args.proc_id,
+                                         &(src_args.params));
+                if (src_args.handle == NULL) {
+                        retval = -EFAULT;
+                        goto func_exit;
+                }
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args,
+                        sizeof(struct proc_mgr_cmd_args_create));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_DELETE:
+        {
+                struct proc_mgr_cmd_args_delete src_args;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_delete));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+
+                retval = proc_mgr_delete(&(src_args.handle));
+        }
+        break;
+
+        case CMD_PROCMGR_OPEN:
+        {
+                struct proc_mgr_cmd_args_open src_args;
+
+                /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_open));
+
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_open(&(src_args.handle),
+                                                src_args.proc_id);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = proc_mgr_get_proc_info(src_args.handle,
+                                &(src_args.proc_info));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                                (const void *)&src_args,
+                                sizeof(struct proc_mgr_cmd_args_open));
+                WARN_ON(retval);
+        }
+        break;
+
+        case CMD_PROCMGR_CLOSE:
+        {
+                struct proc_mgr_cmd_args_close src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_close));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_close(&(src_args.handle));
+        }
+        break;
+
+        case CMD_PROCMGR_GETATTACHPARAMS:
+        {
+                struct proc_mgr_cmd_args_get_attach_params src_args;
+                struct proc_mgr_attach_params params;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_get_attach_params));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                proc_mgr_get_attach_params(src_args.handle, &params);
+                retval = copy_to_user((void __user *)(src_args.params),
+                                (const void *)&params,
+                                sizeof(struct proc_mgr_attach_params));
+                WARN_ON(retval);
+        }
+        break;
+
+        case CMD_PROCMGR_ATTACH:
+        {
+                struct proc_mgr_cmd_args_attach src_args;
+                struct proc_mgr_attach_params  params;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_attach));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                /* Copy params from user-side. */
+                retval = copy_from_user((void *)&params,
+                        (const void __user *)(src_args.params),
+                        sizeof(struct proc_mgr_attach_params));
+                retval = proc_mgr_attach(src_args.handle, &params);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                /* Get memory information. */
+                retval = proc_mgr_get_proc_info(src_args.handle,
+                                        &(src_args.proc_info));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args,
+                        sizeof(struct proc_mgr_cmd_args_attach));
+        }
+        break;
+
+        case CMD_PROCMGR_DETACH:
+        {
+                struct proc_mgr_cmd_args_detach src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_detach));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_detach(src_args.handle);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+        }
+        break;
+
+        case CMD_PROCMGR_GETSTATE:
+        {
+                struct proc_mgr_cmd_args_get_state src_args;
+                enum proc_mgr_state procmgrstate;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const __user void *)(args),
+                        sizeof(struct proc_mgr_cmd_args_get_state));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                procmgrstate = proc_mgr_get_state(src_args.handle);
+                src_args.proc_mgr_state = procmgrstate;
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args,
+                        sizeof(struct proc_mgr_cmd_args_get_state));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_READ:
+        {
+                struct proc_mgr_cmd_args_read src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc_mgr_cmd_args_read));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_read(src_args.handle,
+                        src_args.proc_addr, &(src_args.num_bytes),
+                        src_args.buffer);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                                (const void *)&src_args,
+                                sizeof(struct proc_mgr_cmd_args_read));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_WRITE:
+        {
+                struct proc_mgr_cmd_args_write src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc_mgr_cmd_args_write));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_write(src_args.handle,
+                        src_args.proc_addr, &(src_args.num_bytes),
+                        src_args.buffer);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args,
+                        sizeof(struct proc_mgr_cmd_args_write));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_CONTROL:
+        {
+                struct proc_mgr_cmd_args_control src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc_mgr_cmd_args_control));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_control(src_args.handle,
+                        src_args.cmd, src_args.arg);
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_TRANSLATEADDR:
+        {
+                struct proc_mgr_cmd_args_translate_addr src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_translate_addr));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_translate_addr(src_args.handle,
+                        &(src_args.dst_addr), src_args.dst_addr_type,
+                        src_args.src_addr, src_args.src_addr_type);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args, sizeof
+                        (struct proc_mgr_cmd_args_translate_addr));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_REGISTERNOTIFY:
+        {
+                struct proc_mgr_cmd_args_register_notify src_args;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_register_notify));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+                retval = proc_mgr_register_notify(src_args.handle,
+                                src_args.callback_fxn,
+                                src_args.args, src_args.state);
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        case CMD_PROCMGR_GETPROCINFO:
+        {
+                struct proc_mgr_cmd_args_get_proc_info src_args;
+                struct proc_mgr_proc_info *proc_info;
+
+                 /* Copy the full args from user-side. */
+                retval = copy_from_user((void *)&src_args,
+                (const void __user *)(args),
+                sizeof(struct proc_mgr_cmd_args_get_proc_info));
+                if (WARN_ON(retval != 0))
+                        goto func_exit;
+
+                proc_info = kzalloc(sizeof(struct proc_mgr_proc_info),
+                                                        GFP_KERNEL);
+                retval = proc_mgr_get_proc_info
+                        (src_args.handle, proc_info);
+                if (WARN_ON(retval < 0)) {
+                        kfree(proc_info);
+                        goto func_exit;
+                }
+                retval = copy_to_user((void __user *)(src_args.proc_info),
+                                (const void *) proc_info,
+                                sizeof(struct proc_mgr_proc_info));
+                WARN_ON(retval < 0);
+                kfree(proc_info);
+        }
+        break;
+
+        case CMD_PROCMGR_GETVIRTTOPHYS:
+        {
+                struct proc_mgr_cmd_args_get_virt_to_phys src_args;
+
+                retval = copy_from_user((void *)&src_args,
+                        (const void __user *)(args),
+                        sizeof(struct proc_mgr_cmd_args_get_virt_to_phys));
+                retval = proc_mgr_virt_to_phys(src_args.handle,
+                                        src_args.da, (src_args.mem_entries),
+                                        src_args.num_of_entries);
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+                retval = copy_to_user((void __user *)(args),
+                        (const void *)&src_args,
+                        sizeof(struct proc_mgr_cmd_args_get_virt_to_phys));
+                WARN_ON(retval < 0);
+        }
+        break;
+
+        /*
+         * This is added to provide the information whether to enable
+         * lock all entries in TLB or not. ES1.0 requires all the entries
+         * to be locked, so the loader in userspace makes the decision on
+         * how the entries should be programmed based on ES revision. This
+         * case is meant for temporary purpose and can be removed once ES1.0
+         * boards are phased out
+         */
+        case CMD_PROCMGR_GETBOARDREV:
+        {
+                int rev;
+                struct proc_mgr_cmd_args_cpurev src_args;
+                retval = copy_from_user((void *)&src_args,
+                                (const void __user *)(args),
+                                sizeof(struct proc_mgr_cmd_args_cpurev));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+
+                rev = GET_OMAP_REVISION();
+                *(src_args.cpu_rev) = rev;
+                retval = copy_to_user((void __user *)(args),
+                                (const void *)&src_args,
+                                sizeof(struct proc_mgr_cmd_args_cpurev));
+                if (WARN_ON(retval < 0))
+                        goto func_exit;
+        }
+        break;
+        default:
+                printk(KERN_ERR"PROC_MGR_DRV: WRONG IOCTL !!!!\n");
+                BUG_ON(1);
+        break;
+        }
+func_exit:
+        /* Set the retval and copy the common args to user-side. */
+        command_args.api_status = retval;
+        retval = copy_to_user((void __user *)cmd_args,
+                (const void *)&command_args, sizeof(struct proc_mgr_cmd_args));
+
+        WARN_ON(retval < 0);
+        return retval;
+}
+
+
+/*
+  Driver function to map memory regions to user space.
+ */
+static int proc_mgr_drv_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        vma->vm_page_prot = pgprot_dmacoherent(vma->vm_page_prot);
+        vma->vm_flags |= VM_RESERVED;
+
+        if (remap_pfn_range(vma,
+                         vma->vm_start,
+                         vma->vm_pgoff,
+                         vma->vm_end - vma->vm_start,
+                         vma->vm_page_prot)) {
+                return -EAGAIN;
+        }
+        return 0;
+}
+
+static int __devinit proc_mgr_probe(struct platform_device *pdev)
+{
+        dev_t dev = 0 ;
+        int retval = -ENOMEM;
+
+        /* Display the version info and created date/time */
+        dev_dbg(&omap_proc_dev->dev, "Entering %s function\n\n", __func__);
+
+        if (driver_major) {
+                dev = MKDEV(driver_major, driver_minor);
+                retval = register_chrdev_region(dev, 1, driver_name);
+        } else {
+                retval = alloc_chrdev_region(&dev, driver_minor, 1,
+                                 driver_name);
+                driver_major = MAJOR(dev);
+        }
+
+        procmgr_device = kmalloc(sizeof(struct procmgr_dev), GFP_KERNEL);
+        if (!procmgr_device) {
+                retval = -ENOMEM;
+                unregister_chrdev_region(dev, 1);
+                goto exit;
+        }
+        memset(procmgr_device, 0, sizeof(struct procmgr_dev));
+        cdev_init(&procmgr_device->cdev, &procmgr_fops);
+        procmgr_device->cdev.owner = THIS_MODULE;
+        procmgr_device->cdev.ops = &procmgr_fops;
+
+        retval = cdev_add(&procmgr_device->cdev, dev, 1);
+
+        if (retval) {
+                printk(KERN_ERR "Failed to add the syslink procmgr device\n");
+                goto exit;
+        }
+
+        /* udev support */
+        proc_mgr_class = class_create(THIS_MODULE, "syslink-procmgr");
+
+        if (IS_ERR(proc_mgr_class)) {
+                printk(KERN_ERR "Error creating bridge class\n");
+                goto exit;
+        }
+        device_create(proc_mgr_class, NULL, MKDEV(driver_major, driver_minor),
+                        NULL, PROCMGR_NAME);
+
+exit:
+        dev_dbg(&omap_proc_dev->dev, "Leaving %s function\n\n", __func__);
+        return retval;
+}
+
+
+static int __devexit proc_mgr_remove(struct platform_device *pdev)
+{
+        dev_t devno = 0;
+
+        dev_dbg(&omap_proc_dev->dev, "Entering %s function\n", __func__);
+        devno = MKDEV(driver_major, driver_minor);
+        if (procmgr_device) {
+                cdev_del(&procmgr_device->cdev);
+                kfree(procmgr_device);
+        }
+        unregister_chrdev_region(devno, 1);
+        if (proc_mgr_class) {
+                /* remove the device from sysfs */
+                device_destroy(proc_mgr_class, MKDEV(driver_major,
+                                                driver_minor));
+                class_destroy(proc_mgr_class);
+        }
+        dev_dbg(&omap_proc_dev->dev, "Entering %s function\n", __func__);
+        return 0;
+}
+
+/*
+* Module initialization  function for Linux driver.
+ */
+static int __init proc_mgr_drv_initialize_module(void)
+{
+        int retval = -ENOMEM;
+
+        procmgr_pdev = platform_device_alloc(PROCMGR_NAME, -1);
+        if (!procmgr_pdev) {
+                printk(KERN_ERR "%s:device allocation failed\n", __func__);
+                return -ENOMEM;
+        }
+        retval = platform_device_add(procmgr_pdev);
+        if (retval)
+                goto err_out;
+
+        /*Saving the context for future use*/
+        omap_proc_dev = procmgr_pdev;
+
+        retval = platform_driver_register(&procmgr_driver);
+        if (!retval)
+                return retval;
+err_out:
+        platform_device_put(procmgr_pdev);
+        return retval;
+}
+
+/*
+* driver function to finalize the driver module.
+ */
+static void __exit proc_mgr_drv_finalize_module(void)
+{
+
+        dev_dbg(&omap_proc_dev->dev, "Entering %s function\n", __func__);
+        platform_device_unregister(procmgr_pdev);
+        platform_driver_unregister(&procmgr_driver);
+        dev_dbg(&omap_proc_dev->dev, "Leaving %s function\n", __func__);
+}
+
+/*
+* brief  Macro calls that indicate initialization and finalization functions
+ *      to the kernel.
+ */
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Mugdha Kamoolkar");
+module_init(proc_mgr_drv_initialize_module);
+module_exit(proc_mgr_drv_finalize_module);
diff --git a/drivers/dsp/syslink/procmgr/procmgr_drvdefs.h b/drivers/dsp/syslink/procmgr/procmgr_drvdefs.h
new file mode 100644
index 00000000000..fc0015d5882
--- /dev/null
+++ b/drivers/dsp/syslink/procmgr/procmgr_drvdefs.h
@@ -0,0 +1,491 @@
+/*
+ * procmgr_drvdefs.h
+ *
+ * Syslink driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2010 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+#ifndef SYSLINK_PROCMGR_DRVDEFS_H
+#define SYSLINK_PROCMGR_DRVDEFS_H
+
+#include <linux/types.h>
+
+/* Module headers */
+#include <procmgr.h>
+
+
+/* =================================
+ *  Macros and types
+ * =================================
+ */
+/*
+ * Base structure for ProcMgr command args. This needs to be the first
+ *  field in all command args structures.
+ */
+struct proc_mgr_cmd_args {
+        int api_status;
+        /*Status of the API being called. */
+};
+
+/*  --------------------------------------
+ *  IOCTL command IDs for ProcMgr
+ *  ---------------------------------------
+ */
+/*
+ * Base command ID for ProcMgr
+ */
+#define PROCMGR_BASE_CMD                        0x100
+
+/*
+ * Command for ProcMgr_getConfig
+ */
+#define CMD_PROCMGR_GETCONFIG           (PROCMGR_BASE_CMD + 1)
+
+/*
+ * Command for ProcMgr_setup
+ */
+#define CMD_PROCMGR_SETUP                       (PROCMGR_BASE_CMD + 2)
+
+/*
+ * Command for ProcMgr_setup
+ */
+#define CMD_PROCMGR_DESTROY                     (PROCMGR_BASE_CMD + 3)
+
+/*
+ * Command for ProcMgr_destroy
+ */
+#define CMD_PROCMGR_PARAMS_INIT         (PROCMGR_BASE_CMD + 4)
+
+/*
+ * Command for ProcMgr_create
+ */
+#define CMD_PROCMGR_CREATE                      (PROCMGR_BASE_CMD + 5)
+
+/*
+ * Command for ProcMgr_delete
+ */
+#define CMD_PROCMGR_DELETE                      (PROCMGR_BASE_CMD + 6)
+
+/*
+ * Command for ProcMgr_open
+ */
+#define CMD_PROCMGR_OPEN                        (PROCMGR_BASE_CMD + 7)
+
+/*
+ * Command for ProcMgr_close
+ */
+#define CMD_PROCMGR_CLOSE                       (PROCMGR_BASE_CMD + 8)
+
+/*
+ * Command for ProcMgr_getAttachParams
+ */
+#define CMD_PROCMGR_GETATTACHPARAMS             (PROCMGR_BASE_CMD + 9)
+
+/*
+ * Command for ProcMgr_attach
+ */
+#define CMD_PROCMGR_ATTACH                      (PROCMGR_BASE_CMD + 10)
+
+/*
+ * Command for ProcMgr_detach
+ */
+#define CMD_PROCMGR_DETACH                      (PROCMGR_BASE_CMD + 11)
+
+/*
+ * Command for ProcMgr_load
+ */
+#define CMD_PROCMGR_LOAD                        (PROCMGR_BASE_CMD + 12)
+
+/*
+ * Command for ProcMgr_unload
+ */
+#define CMD_PROCMGR_UNLOAD                      (PROCMGR_BASE_CMD + 13)
+
+/*
+ * Command for ProcMgr_getStartParams
+ */
+#define CMD_PROCMGR_GETSTARTPARAMS              (PROCMGR_BASE_CMD + 14)
+
+/*
+ * Command for ProcMgr_start
+ */
+#define CMD_PROCMGR_START                       (PROCMGR_BASE_CMD + 15)
+
+/*
+ * Command for ProcMgr_stop
+ */
+#define CMD_PROCMGR_STOP                        (PROCMGR_BASE_CMD + 16)
+
+/*
+ * Command for ProcMgr_getState
+ */
+#define CMD_PROCMGR_GETSTATE                    (PROCMGR_BASE_CMD + 17)
+
+/*
+ * Command for ProcMgr_read
+ */
+#define CMD_PROCMGR_READ                        (PROCMGR_BASE_CMD + 18)
+
+/*
+ * Command for ProcMgr_write
+ */
+#define CMD_PROCMGR_WRITE                       (PROCMGR_BASE_CMD + 19)
+
+/*
+ * Command for ProcMgr_control
+ */
+#define CMD_PROCMGR_CONTROL                     (PROCMGR_BASE_CMD + 20)
+
+/*
+ * Command for ProcMgr_translateAddr
+ */
+#define CMD_PROCMGR_TRANSLATEADDR               (PROCMGR_BASE_CMD + 22)
+
+/*
+ * Command for ProcMgr_getSymbolAddress
+ */
+#define CMD_PROCMGR_GETSYMBOLADDRESS            (PROCMGR_BASE_CMD + 23)
+
+/*
+ * Command for ProcMgr_map
+ */
+#define CMD_PROCMGR_MAP                         (PROCMGR_BASE_CMD + 24)
+
+/*
+ * Command for ProcMgr_registerNotify
+ */
+#define CMD_PROCMGR_REGISTERNOTIFY              (PROCMGR_BASE_CMD + 25)
+
+/*
+ * Command for ProcMgr_getProcInfo
+ */
+#define CMD_PROCMGR_GETPROCINFO                 (PROCMGR_BASE_CMD + 26)
+
+/*
+ * Command for ProcMgr_unmap
+ */
+#define CMD_PROCMGR_UNMAP                       (PROCMGR_BASE_CMD + 27)
+
+/*
+ * Command for ProcMgr_getVirtToPhysPages
+ */
+#define CMD_PROCMGR_GETVIRTTOPHYS               (PROCMGR_BASE_CMD + 28)
+
+
+/*
+ * Command to get Board revision
+ */
+#define CMD_PROCMGR_GETBOARDREV                 (PROCMGR_BASE_CMD + 31)
+
+
+
+/*  ----------------------------------------------------------------------------
+ *  Command arguments for ProcMgr
+ *  ----------------------------------------------------------------------------
+ */
+/*
+ * Command arguments for ProcMgr_getConfig
+ */
+struct proc_mgr_cmd_args_get_config {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        struct proc_mgr_config *cfg;
+        /*Pointer to the ProcMgr module configuration structure in which the
+         default config is to be returned. */
+};
+
+/*
+ * Command arguments for ProcMgr_setup
+ */
+struct proc_mgr_cmd_args_setup {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        struct proc_mgr_config *cfg;
+        /*Optional ProcMgr module configuration. If provided as NULL, default
+         configuration is used. */
+};
+
+/*
+ * Command arguments for ProcMgr_destroy
+ */
+struct proc_mgr_cmd_args_destroy {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+};
+
+/*
+ * Command arguments for ProcMgr_Params_init
+ */
+struct proc_mgr_cmd_args_params_init {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object. */
+        struct proc_mgr_params *params;
+        /*Pointer to the ProcMgr instance params structure in which the default
+         params is to be returned. */
+};
+
+/*
+ * Command arguments for ProcMgr_create
+ */
+struct proc_mgr_cmd_args_create {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        u16 proc_id;
+        /*Processor ID represented by this ProcMgr instance */
+        struct proc_mgr_params  params;
+        /*ProcMgr instance configuration parameters. */
+        void *handle;
+        /*Handle to the created ProcMgr object */
+};
+
+/*
+ * Command arguments for ProcMgr_delete
+ */
+struct proc_mgr_cmd_args_delete{
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Pointer to Handle to the ProcMgr object */
+};
+
+/*
+ * Command arguments for ProcMgr_open
+ */
+struct proc_mgr_cmd_args_open {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        u16 proc_id;
+        /*Processor ID represented by this ProcMgr instance */
+        void *handle;
+        /*Handle to the opened ProcMgr object. */
+        struct proc_mgr_proc_info proc_info;
+        /*Processor information.  */
+};
+
+/*
+ * Command arguments for ProcMgr_close
+ */
+struct proc_mgr_cmd_args_close{
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        struct proc_mgr_proc_info proc_info;
+        /*Processor information.  */
+};
+
+/*
+ * Command arguments for ProcMgr_getAttachParams
+ */
+struct proc_mgr_cmd_args_get_attach_params{
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object. */
+        struct proc_mgr_attach_params *params;
+        /*Pointer to the ProcMgr attach params structure in which the default
+         params is to be returned. */
+};
+
+/*
+ * Command arguments for ProcMgr_attach
+ */
+struct proc_mgr_cmd_args_attach {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object. */
+        struct proc_mgr_attach_params *params;
+        /*Optional ProcMgr attach parameters.  */
+        struct proc_mgr_proc_info proc_info;
+        /*Processor information.  */
+};
+
+/*
+ * Command arguments for ProcMgr_detach
+ */
+struct proc_mgr_cmd_args_detach {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        struct proc_mgr_proc_info proc_info;
+        /*Processor information.  */
+};
+
+
+/*
+ * Command arguments for ProcMgr_getStartParams
+ */
+struct proc_mgr_cmd_args_get_start_params {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Entry point for the image*/
+        u32 entry_point;
+        /*Handle to the ProcMgr object */
+        struct proc_mgr_start_params *params;
+        /*Pointer to the ProcMgr start params structure in which the default
+         params is to be returned. */
+};
+
+/*
+ * Command arguments for ProcMgr_getState
+ */
+struct proc_mgr_cmd_args_get_state {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /* Handle to the ProcMgr object */
+        enum proc_mgr_state proc_mgr_state;
+        /*Current state of the ProcMgr object. */
+};
+
+/*
+ * Command arguments for ProcMgr_read
+ */
+struct proc_mgr_cmd_args_read {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        u32 proc_addr;
+        /*Address in space processor's address space of the memory region to
+         read from. */
+        u32 num_bytes;
+        /*IN/OUT parameter. As an IN-parameter, it takes in the number of bytes
+         to be read. When the function returns, this parameter contains the
+         number of bytes actually read. */
+        void *buffer;
+        /*User-provided buffer in which the slave processor's memory contents
+         are to be copied. */
+};
+
+/*
+ * Command arguments for ProcMgr_write
+ */
+struct proc_mgr_cmd_args_write {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        u32 proc_addr;
+        /*Address in space processor's address space of the memory region to
+         write into. */
+        u32 num_bytes;
+        /*IN/OUT parameter. As an IN-parameter, it takes in the number of bytes
+         to be written. When the function returns, this parameter contains the
+         number of bytes actually written. */
+        void *buffer;
+        /*User-provided buffer from which the data is to be written into the
+         slave processor's memory. */
+};
+
+/*
+ * Command arguments for ProcMgr_control
+ */
+struct proc_mgr_cmd_args_control {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        int cmd;
+        /*Device specific processor command */
+        void *arg;
+        /*Arguments specific to the type of command. */
+};
+
+/*
+ * Command arguments for ProcMgr_translateAddr
+ */
+struct proc_mgr_cmd_args_translate_addr {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        void *dst_addr;
+        /*Return parameter: Pointer to receive the translated address. */
+        enum proc_mgr_addr_type dst_addr_type;
+        /*Destination address type requested */
+        void *src_addr;
+        /*Source address in the source address space */
+        enum proc_mgr_addr_type src_addr_type;
+        /*Source address type */
+};
+
+/*
+ * Command arguments for ProcMgr_getSymbolAddress
+ */
+struct proc_mgr_cmd_args_get_symbol_address {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        u32 file_id;
+        /*ID of the file received from the load function */
+        char *symbol_name;
+        /*Name of the symbol */
+        u32 sym_value;
+        /*Return parameter: Symbol address */
+};
+
+/*
+ * Command arguments for ProcMgr_registerNotify
+ */
+struct proc_mgr_cmd_args_register_notify {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        int (*callback_fxn)(u16 proc_id, void *handle,
+                enum proc_mgr_state from_state, enum proc_mgr_state to_state);
+        /*Handling function to be registered. */
+        void *args;
+        /*Optional arguments associated with the handler fxn. */
+        enum proc_mgr_state state[];
+        /*Array of target states for which registration is required. */
+};
+
+/*
+ * Command arguments for ProcMgr_getProcInfo
+ */
+struct proc_mgr_cmd_args_get_proc_info {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        /*Handle to the ProcMgr object */
+        struct proc_mgr_proc_info *proc_info;
+        /*Pointer to the ProcInfo object to be populated. */
+};
+
+/*
+ * Command arguments for ProcMgr_virtToPhys
+ */
+struct proc_mgr_cmd_args_get_virt_to_phys {
+        struct proc_mgr_cmd_args commond_args;
+        /*Common command args */
+        void *handle;
+        u32 da;
+        /* mem entries buffer */
+        u32 *mem_entries;
+        /* number of entries */
+        u32 num_of_entries;
+};
+
+struct proc_mgr_cmd_args_cpurev {
+        struct proc_mgr_cmd_args commond_args;
+        u32 *cpu_rev;
+};
+#endif