diff options
| -rw-r--r-- | series | 1 | ||||
| -rw-r--r-- | staging.current/staging-sep-remove-driver.patch | 3824 |
2 files changed, 3825 insertions, 0 deletions
@@ -74,6 +74,7 @@ staging.current/staging-batman-adv-fix-own-mac-address-detection.patch staging.current/staging-batman-adv-create-batman_if-only-on-register-event.patch staging.current/staging-batman-adv-don-t-use-net_dev-after-dev_put.patch staging.current/staging-batman-adv-don-t-write-in-not-allocated-packet_buff.patch +staging.current/staging-sep-remove-driver.patch ##################################################################### diff --git a/staging.current/staging-sep-remove-driver.patch b/staging.current/staging-sep-remove-driver.patch new file mode 100644 index 00000000000000..12dc46c94020a2 --- /dev/null +++ b/staging.current/staging-sep-remove-driver.patch @@ -0,0 +1,3824 @@ +From foo@baz Mon Aug 23 10:28:31 PDT 2010 +Date: Mon, 23 Aug 2010 10:28:31 -0700 +To: Greg KH <greg@kroah.com> +From: Greg Kroah-Hartman <gregkh@suse.de> +Subject: Staging: sep: remove driver + +It's currently stalled and the original submitter recommended that it +just be dropped at this point in time due. + +Cc: Alan Cox <alan@linux.intel.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + drivers/staging/Kconfig | 2 + drivers/staging/Makefile | 1 + drivers/staging/sep/Kconfig | 10 + drivers/staging/sep/Makefile | 2 + drivers/staging/sep/TODO | 8 + drivers/staging/sep/sep_dev.h | 110 - + drivers/staging/sep/sep_driver.c | 2742 ------------------------------- + drivers/staging/sep/sep_driver_api.h | 425 ---- + drivers/staging/sep/sep_driver_config.h | 225 -- + drivers/staging/sep/sep_driver_hw_defs.h | 232 -- + 10 files changed, 3757 deletions(-) + +--- a/drivers/staging/Kconfig ++++ b/drivers/staging/Kconfig +@@ -113,8 +113,6 @@ source "drivers/staging/vme/Kconfig" + + source "drivers/staging/memrar/Kconfig" + +-source "drivers/staging/sep/Kconfig" +- + source "drivers/staging/iio/Kconfig" + + source "drivers/staging/zram/Kconfig" +--- a/drivers/staging/Makefile ++++ b/drivers/staging/Makefile +@@ -38,7 +38,6 @@ obj-$(CONFIG_FB_UDL) += udlfb/ + obj-$(CONFIG_HYPERV) += hv/ + obj-$(CONFIG_VME_BUS) += vme/ + obj-$(CONFIG_MRST_RAR_HANDLER) += memrar/ +-obj-$(CONFIG_DX_SEP) += sep/ + obj-$(CONFIG_IIO) += iio/ + obj-$(CONFIG_ZRAM) += zram/ + obj-$(CONFIG_WLAGS49_H2) += wlags49_h2/ +--- a/drivers/staging/sep/Kconfig ++++ /dev/null +@@ -1,10 +0,0 @@ +-config DX_SEP +- tristate "Discretix SEP driver" +-# depends on MRST +- depends on RAR_REGISTER && PCI +- default y +- help +- Discretix SEP driver +- +- If unsure say M. The compiled module will be +- called sep_driver.ko +--- a/drivers/staging/sep/Makefile ++++ /dev/null +@@ -1,2 +0,0 @@ +-obj-$(CONFIG_DX_SEP) := sep_driver.o +- +--- a/drivers/staging/sep/TODO ++++ /dev/null +@@ -1,8 +0,0 @@ +-Todo's so far (from Alan Cox) +-- Fix firmware loading +-- Get firmware into firmware git tree +-- Review and tidy each algorithm function +-- Check whether it can be plugged into any of the kernel crypto API +- interfaces +-- Do something about the magic shared memory interface and replace it +- with something saner (in Linux terms) +--- a/drivers/staging/sep/sep_dev.h ++++ /dev/null +@@ -1,110 +0,0 @@ +-#ifndef __SEP_DEV_H__ +-#define __SEP_DEV_H__ +- +-/* +- * +- * sep_dev.h - Security Processor Device Structures +- * +- * Copyright(c) 2009 Intel Corporation. All rights reserved. +- * Copyright(c) 2009 Discretix. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License as published by the Free +- * Software Foundation; either version 2 of the License, or (at your option) +- * any later version. +- * +- * This program is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +- * more details. +- * +- * You should have received a copy of the GNU General Public License along with +- * this program; if not, write to the Free Software Foundation, Inc., 59 +- * Temple Place - Suite 330, Boston, MA 02111-1307, USA. +- * +- * CONTACTS: +- * +- * Alan Cox alan@linux.intel.com +- * +- */ +- +-struct sep_device { +- /* pointer to pci dev */ +- struct pci_dev *pdev; +- +- unsigned long in_use; +- +- /* address of the shared memory allocated during init for SEP driver +- (coherent alloc) */ +- void *shared_addr; +- /* the physical address of the shared area */ +- dma_addr_t shared_bus; +- +- /* restricted access region (coherent alloc) */ +- dma_addr_t rar_bus; +- void *rar_addr; +- /* firmware regions: cache is at rar_addr */ +- unsigned long cache_size; +- +- /* follows the cache */ +- dma_addr_t resident_bus; +- unsigned long resident_size; +- void *resident_addr; +- +- /* start address of the access to the SEP registers from driver */ +- void __iomem *reg_addr; +- /* transaction counter that coordinates the transactions between SEP and HOST */ +- unsigned long send_ct; +- /* counter for the messages from sep */ +- unsigned long reply_ct; +- /* counter for the number of bytes allocated in the pool for the current +- transaction */ +- unsigned long data_pool_bytes_allocated; +- +- /* array of pointers to the pages that represent input data for the synchronic +- DMA action */ +- struct page **in_page_array; +- +- /* array of pointers to the pages that represent out data for the synchronic +- DMA action */ +- struct page **out_page_array; +- +- /* number of pages in the sep_in_page_array */ +- unsigned long in_num_pages; +- +- /* number of pages in the sep_out_page_array */ +- unsigned long out_num_pages; +- +- /* global data for every flow */ +- struct sep_flow_context_t flows[SEP_DRIVER_NUM_FLOWS]; +- +- /* pointer to the workqueue that handles the flow done interrupts */ +- struct workqueue_struct *flow_wq; +- +-}; +- +-static struct sep_device *sep_dev; +- +-static inline void sep_write_reg(struct sep_device *dev, int reg, u32 value) +-{ +- void __iomem *addr = dev->reg_addr + reg; +- writel(value, addr); +-} +- +-static inline u32 sep_read_reg(struct sep_device *dev, int reg) +-{ +- void __iomem *addr = dev->reg_addr + reg; +- return readl(addr); +-} +- +-/* wait for SRAM write complete(indirect write */ +-static inline void sep_wait_sram_write(struct sep_device *dev) +-{ +- u32 reg_val; +- do +- reg_val = sep_read_reg(dev, HW_SRAM_DATA_READY_REG_ADDR); +- while (!(reg_val & 1)); +-} +- +- +-#endif +--- a/drivers/staging/sep/sep_driver.c ++++ /dev/null +@@ -1,2742 +0,0 @@ +-/* +- * +- * sep_driver.c - Security Processor Driver main group of functions +- * +- * Copyright(c) 2009 Intel Corporation. All rights reserved. +- * Copyright(c) 2009 Discretix. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License as published by the Free +- * Software Foundation; either version 2 of the License, or (at your option) +- * any later version. +- * +- * This program is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +- * more details. +- * +- * You should have received a copy of the GNU General Public License along with +- * this program; if not, write to the Free Software Foundation, Inc., 59 +- * Temple Place - Suite 330, Boston, MA 02111-1307, USA. +- * +- * CONTACTS: +- * +- * Mark Allyn mark.a.allyn@intel.com +- * +- * CHANGES: +- * +- * 2009.06.26 Initial publish +- * +- */ +- +-#include <linux/init.h> +-#include <linux/module.h> +-#include <linux/fs.h> +-#include <linux/cdev.h> +-#include <linux/kdev_t.h> +-#include <linux/mutex.h> +-#include <linux/sched.h> +-#include <linux/mm.h> +-#include <linux/poll.h> +-#include <linux/wait.h> +-#include <linux/pci.h> +-#include <linux/firmware.h> +-#include <linux/slab.h> +-#include <asm/ioctl.h> +-#include <linux/ioport.h> +-#include <asm/io.h> +-#include <linux/interrupt.h> +-#include <linux/pagemap.h> +-#include <asm/cacheflush.h> +-#include "sep_driver_hw_defs.h" +-#include "sep_driver_config.h" +-#include "sep_driver_api.h" +-#include "sep_dev.h" +- +-#if SEP_DRIVER_ARM_DEBUG_MODE +- +-#define CRYS_SEP_ROM_length 0x4000 +-#define CRYS_SEP_ROM_start_address 0x8000C000UL +-#define CRYS_SEP_ROM_start_address_offset 0xC000UL +-#define SEP_ROM_BANK_register 0x80008420UL +-#define SEP_ROM_BANK_register_offset 0x8420UL +-#define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0x82000000 +- +-/* +- * THESE 2 definitions are specific to the board - must be +- * defined during integration +- */ +-#define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0xFF0D0000 +- +-/* 2M size */ +- +-static void sep_load_rom_code(struct sep_device *sep) +-{ +- /* Index variables */ +- unsigned long i, k, j; +- u32 reg; +- u32 error; +- u32 warning; +- +- /* Loading ROM from SEP_ROM_image.h file */ +- k = sizeof(CRYS_SEP_ROM); +- +- edbg("SEP Driver: DX_CC_TST_SepRomLoader start\n"); +- +- edbg("SEP Driver: k is %lu\n", k); +- edbg("SEP Driver: sep->reg_addr is %p\n", sep->reg_addr); +- edbg("SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", CRYS_SEP_ROM_start_address_offset); +- +- for (i = 0; i < 4; i++) { +- /* write bank */ +- sep_write_reg(sep, SEP_ROM_BANK_register_offset, i); +- +- for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) { +- sep_write_reg(sep, CRYS_SEP_ROM_start_address_offset + 4 * j, CRYS_SEP_ROM[i * 0x1000 + j]); +- +- k = k - 4; +- +- if (k == 0) { +- j = CRYS_SEP_ROM_length; +- i = 4; +- } +- } +- } +- +- /* reset the SEP */ +- sep_write_reg(sep, HW_HOST_SEP_SW_RST_REG_ADDR, 0x1); +- +- /* poll for SEP ROM boot finish */ +- do +- reg = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); +- while (!reg); +- +- edbg("SEP Driver: ROM polling ended\n"); +- +- switch (reg) { +- case 0x1: +- /* fatal error - read erro status from GPRO */ +- error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR); +- edbg("SEP Driver: ROM polling case 1\n"); +- break; +- case 0x4: +- /* Cold boot ended successfully */ +- case 0x8: +- /* Warmboot ended successfully */ +- case 0x10: +- /* ColdWarm boot ended successfully */ +- error = 0; +- case 0x2: +- /* Boot First Phase ended */ +- warning = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR); +- case 0x20: +- edbg("SEP Driver: ROM polling case %d\n", reg); +- break; +- } +- +-} +- +-#else +-static void sep_load_rom_code(struct sep_device *sep) { } +-#endif /* SEP_DRIVER_ARM_DEBUG_MODE */ +- +- +- +-/*---------------------------------------- +- DEFINES +------------------------------------------*/ +- +-#define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000 +-#define SEP_RAR_IO_MEM_REGION_SIZE 0x40000 +- +-/*-------------------------------------------- +- GLOBAL variables +---------------------------------------------*/ +- +-/* debug messages level */ +-static int debug; +-module_param(debug, int , 0); +-MODULE_PARM_DESC(debug, "Flag to enable SEP debug messages"); +- +-/* Keep this a single static object for now to keep the conversion easy */ +- +-static struct sep_device sep_instance; +-static struct sep_device *sep_dev = &sep_instance; +- +-/* +- mutex for the access to the internals of the sep driver +-*/ +-static DEFINE_MUTEX(sep_mutex); +- +- +-/* wait queue head (event) of the driver */ +-static DECLARE_WAIT_QUEUE_HEAD(sep_event); +- +-/** +- * sep_load_firmware - copy firmware cache/resident +- * @sep: device we are loading +- * +- * This functions copies the cache and resident from their source +- * location into destination shared memory. +- */ +- +-static int sep_load_firmware(struct sep_device *sep) +-{ +- const struct firmware *fw; +- char *cache_name = "sep/cache.image.bin"; +- char *res_name = "sep/resident.image.bin"; +- int error; +- +- edbg("SEP Driver:rar_virtual is %p\n", sep->rar_addr); +- edbg("SEP Driver:rar_bus is %08llx\n", (unsigned long long)sep->rar_bus); +- +- /* load cache */ +- error = request_firmware(&fw, cache_name, &sep->pdev->dev); +- if (error) { +- edbg("SEP Driver:cant request cache fw\n"); +- return error; +- } +- edbg("SEP Driver:cache %08Zx@%p\n", fw->size, (void *) fw->data); +- +- memcpy(sep->rar_addr, (void *)fw->data, fw->size); +- sep->cache_size = fw->size; +- release_firmware(fw); +- +- sep->resident_bus = sep->rar_bus + sep->cache_size; +- sep->resident_addr = sep->rar_addr + sep->cache_size; +- +- /* load resident */ +- error = request_firmware(&fw, res_name, &sep->pdev->dev); +- if (error) { +- edbg("SEP Driver:cant request res fw\n"); +- return error; +- } +- edbg("sep: res %08Zx@%p\n", fw->size, (void *)fw->data); +- +- memcpy(sep->resident_addr, (void *) fw->data, fw->size); +- sep->resident_size = fw->size; +- release_firmware(fw); +- +- edbg("sep: resident v %p b %08llx cache v %p b %08llx\n", +- sep->resident_addr, (unsigned long long)sep->resident_bus, +- sep->rar_addr, (unsigned long long)sep->rar_bus); +- return 0; +-} +- +-MODULE_FIRMWARE("sep/cache.image.bin"); +-MODULE_FIRMWARE("sep/resident.image.bin"); +- +-/** +- * sep_map_and_alloc_shared_area - allocate shared block +- * @sep: security processor +- * @size: size of shared area +- * +- * Allocate a shared buffer in host memory that can be used by both the +- * kernel and also the hardware interface via DMA. +- */ +- +-static int sep_map_and_alloc_shared_area(struct sep_device *sep, +- unsigned long size) +-{ +- /* shared_addr = ioremap_nocache(0xda00000,shared_area_size); */ +- sep->shared_addr = dma_alloc_coherent(&sep->pdev->dev, size, +- &sep->shared_bus, GFP_KERNEL); +- +- if (!sep->shared_addr) { +- edbg("sep_driver :shared memory dma_alloc_coherent failed\n"); +- return -ENOMEM; +- } +- /* set the bus address of the shared area */ +- edbg("sep: shared_addr %ld bytes @%p (bus %08llx)\n", +- size, sep->shared_addr, (unsigned long long)sep->shared_bus); +- return 0; +-} +- +-/** +- * sep_unmap_and_free_shared_area - free shared block +- * @sep: security processor +- * +- * Free the shared area allocated to the security processor. The +- * processor must have finished with this and any final posted +- * writes cleared before we do so. +- */ +-static void sep_unmap_and_free_shared_area(struct sep_device *sep, int size) +-{ +- dma_free_coherent(&sep->pdev->dev, size, +- sep->shared_addr, sep->shared_bus); +-} +- +-/** +- * sep_shared_virt_to_bus - convert bus/virt addresses +- * +- * Returns the bus address inside the shared area according +- * to the virtual address. +- */ +- +-static dma_addr_t sep_shared_virt_to_bus(struct sep_device *sep, +- void *virt_address) +-{ +- dma_addr_t pa = sep->shared_bus + (virt_address - sep->shared_addr); +- edbg("sep: virt to bus b %08llx v %p\n", (unsigned long long) pa, +- virt_address); +- return pa; +-} +- +-/** +- * sep_shared_bus_to_virt - convert bus/virt addresses +- * +- * Returns virtual address inside the shared area according +- * to the bus address. +- */ +- +-static void *sep_shared_bus_to_virt(struct sep_device *sep, +- dma_addr_t bus_address) +-{ +- return sep->shared_addr + (bus_address - sep->shared_bus); +-} +- +- +-/** +- * sep_try_open - attempt to open a SEP device +- * @sep: device to attempt to open +- * +- * Atomically attempt to get ownership of a SEP device. +- * Returns 1 if the device was opened, 0 on failure. +- */ +- +-static int sep_try_open(struct sep_device *sep) +-{ +- if (!test_and_set_bit(0, &sep->in_use)) +- return 1; +- return 0; +-} +- +-/** +- * sep_open - device open method +- * @inode: inode of sep device +- * @filp: file handle to sep device +- * +- * Open method for the SEP device. Called when userspace opens +- * the SEP device node. Must also release the memory data pool +- * allocations. +- * +- * Returns zero on success otherwise an error code. +- */ +- +-static int sep_open(struct inode *inode, struct file *filp) +-{ +- if (sep_dev == NULL) +- return -ENODEV; +- +- /* check the blocking mode */ +- if (filp->f_flags & O_NDELAY) { +- if (sep_try_open(sep_dev) == 0) +- return -EAGAIN; +- } else +- if (wait_event_interruptible(sep_event, sep_try_open(sep_dev)) < 0) +- return -EINTR; +- +- /* Bind to the device, we only have one which makes it easy */ +- filp->private_data = sep_dev; +- /* release data pool allocations */ +- sep_dev->data_pool_bytes_allocated = 0; +- return 0; +-} +- +- +-/** +- * sep_release - close a SEP device +- * @inode: inode of SEP device +- * @filp: file handle being closed +- * +- * Called on the final close of a SEP device. As the open protects against +- * multiple simultaenous opens that means this method is called when the +- * final reference to the open handle is dropped. +- */ +- +-static int sep_release(struct inode *inode, struct file *filp) +-{ +- struct sep_device *sep = filp->private_data; +-#if 0 /*!SEP_DRIVER_POLLING_MODE */ +- /* close IMR */ +- sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, 0x7FFF); +- /* release IRQ line */ +- free_irq(SEP_DIRVER_IRQ_NUM, sep); +- +-#endif +- /* Ensure any blocked open progresses */ +- clear_bit(0, &sep->in_use); +- wake_up(&sep_event); +- return 0; +-} +- +-/*--------------------------------------------------------------- +- map function - this functions maps the message shared area +------------------------------------------------------------------*/ +-static int sep_mmap(struct file *filp, struct vm_area_struct *vma) +-{ +- dma_addr_t bus_addr; +- struct sep_device *sep = filp->private_data; +- +- dbg("-------->SEP Driver: mmap start\n"); +- +- /* check that the size of the mapped range is as the size of the message +- shared area */ +- if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) { +- edbg("SEP Driver mmap requested size is more than allowed\n"); +- printk(KERN_WARNING "SEP Driver mmap requested size is more than allowed\n"); +- printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_end); +- printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_start); +- return -EAGAIN; +- } +- +- edbg("SEP Driver:sep->shared_addr is %p\n", sep->shared_addr); +- +- /* get bus address */ +- bus_addr = sep->shared_bus; +- +- edbg("SEP Driver: phys_addr is %08llx\n", (unsigned long long)bus_addr); +- +- if (remap_pfn_range(vma, vma->vm_start, bus_addr >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) { +- edbg("SEP Driver remap_page_range failed\n"); +- printk(KERN_WARNING "SEP Driver remap_page_range failed\n"); +- return -EAGAIN; +- } +- +- dbg("SEP Driver:<-------- mmap end\n"); +- +- return 0; +-} +- +- +-/*----------------------------------------------- +- poll function +-*----------------------------------------------*/ +-static unsigned int sep_poll(struct file *filp, poll_table * wait) +-{ +- unsigned long count; +- unsigned int mask = 0; +- unsigned long retval = 0; /* flow id */ +- struct sep_device *sep = filp->private_data; +- +- dbg("---------->SEP Driver poll: start\n"); +- +- +-#if SEP_DRIVER_POLLING_MODE +- +- while (sep->send_ct != (retval & 0x7FFFFFFF)) { +- retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR); +- +- for (count = 0; count < 10 * 4; count += 4) +- edbg("Poll Debug Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count))); +- } +- +- sep->reply_ct++; +-#else +- /* add the event to the polling wait table */ +- poll_wait(filp, &sep_event, wait); +- +-#endif +- +- edbg("sep->send_ct is %lu\n", sep->send_ct); +- edbg("sep->reply_ct is %lu\n", sep->reply_ct); +- +- /* check if the data is ready */ +- if (sep->send_ct == sep->reply_ct) { +- for (count = 0; count < 12 * 4; count += 4) +- edbg("Sep Mesg Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + count))); +- +- for (count = 0; count < 10 * 4; count += 4) +- edbg("Debug Data Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + 0x1800 + count))); +- +- retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR); +- edbg("retval is %lu\n", retval); +- /* check if the this is sep reply or request */ +- if (retval >> 31) { +- edbg("SEP Driver: sep request in\n"); +- /* request */ +- mask |= POLLOUT | POLLWRNORM; +- } else { +- edbg("SEP Driver: sep reply in\n"); +- mask |= POLLIN | POLLRDNORM; +- } +- } +- dbg("SEP Driver:<-------- poll exit\n"); +- return mask; +-} +- +-/** +- * sep_time_address - address in SEP memory of time +- * @sep: SEP device we want the address from +- * +- * Return the address of the two dwords in memory used for time +- * setting. +- */ +- +-static u32 *sep_time_address(struct sep_device *sep) +-{ +- return sep->shared_addr + SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES; +-} +- +-/** +- * sep_set_time - set the SEP time +- * @sep: the SEP we are setting the time for +- * +- * Calculates time and sets it at the predefined address. +- * Called with the sep mutex held. +- */ +-static unsigned long sep_set_time(struct sep_device *sep) +-{ +- struct timeval time; +- u32 *time_addr; /* address of time as seen by the kernel */ +- +- +- dbg("sep:sep_set_time start\n"); +- +- do_gettimeofday(&time); +- +- /* set value in the SYSTEM MEMORY offset */ +- time_addr = sep_time_address(sep); +- +- time_addr[0] = SEP_TIME_VAL_TOKEN; +- time_addr[1] = time.tv_sec; +- +- edbg("SEP Driver:time.tv_sec is %lu\n", time.tv_sec); +- edbg("SEP Driver:time_addr is %p\n", time_addr); +- edbg("SEP Driver:sep->shared_addr is %p\n", sep->shared_addr); +- +- return time.tv_sec; +-} +- +-/** +- * sep_dump_message - dump the message that is pending +- * @sep: sep device +- * +- * Dump out the message pending in the shared message area +- */ +- +-static void sep_dump_message(struct sep_device *sep) +-{ +- int count; +- for (count = 0; count < 12 * 4; count += 4) +- edbg("Word %d of the message is %u\n", count, *((u32 *) (sep->shared_addr + count))); +-} +- +-/** +- * sep_send_command_handler - kick off a command +- * @sep: sep being signalled +- * +- * This function raises interrupt to SEP that signals that is has a new +- * command from the host +- */ +- +-static void sep_send_command_handler(struct sep_device *sep) +-{ +- dbg("sep:sep_send_command_handler start\n"); +- +- mutex_lock(&sep_mutex); +- sep_set_time(sep); +- +- /* FIXME: flush cache */ +- flush_cache_all(); +- +- sep_dump_message(sep); +- /* update counter */ +- sep->send_ct++; +- /* send interrupt to SEP */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); +- dbg("SEP Driver:<-------- sep_send_command_handler end\n"); +- mutex_unlock(&sep_mutex); +- return; +-} +- +-/** +- * sep_send_reply_command_handler - kick off a command reply +- * @sep: sep being signalled +- * +- * This function raises interrupt to SEP that signals that is has a new +- * command from the host +- */ +- +-static void sep_send_reply_command_handler(struct sep_device *sep) +-{ +- dbg("sep:sep_send_reply_command_handler start\n"); +- +- /* flash cache */ +- flush_cache_all(); +- +- sep_dump_message(sep); +- +- mutex_lock(&sep_mutex); +- sep->send_ct++; /* update counter */ +- /* send the interrupt to SEP */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR, sep->send_ct); +- /* update both counters */ +- sep->send_ct++; +- sep->reply_ct++; +- mutex_unlock(&sep_mutex); +- dbg("sep: sep_send_reply_command_handler end\n"); +-} +- +-/* +- This function handles the allocate data pool memory request +- This function returns calculates the bus address of the +- allocated memory, and the offset of this area from the mapped address. +- Therefore, the FVOs in user space can calculate the exact virtual +- address of this allocated memory +-*/ +-static int sep_allocate_data_pool_memory_handler(struct sep_device *sep, +- unsigned long arg) +-{ +- int error; +- struct sep_driver_alloc_t command_args; +- +- dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n"); +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_alloc_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- /* allocate memory */ +- if ((sep->data_pool_bytes_allocated + command_args.num_bytes) > SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) { +- error = -ENOMEM; +- goto end_function; +- } +- +- /* set the virtual and bus address */ +- command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep->data_pool_bytes_allocated; +- command_args.phys_address = sep->shared_bus + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep->data_pool_bytes_allocated; +- +- /* write the memory back to the user space */ +- error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_alloc_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- /* set the allocation */ +- sep->data_pool_bytes_allocated += command_args.num_bytes; +- +-end_function: +- dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n"); +- return error; +-} +- +-/* +- This function handles write into allocated data pool command +-*/ +-static int sep_write_into_data_pool_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- void *virt_address; +- unsigned long va; +- unsigned long app_in_address; +- unsigned long num_bytes; +- void *data_pool_area_addr; +- +- dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n"); +- +- /* get the application address */ +- error = get_user(app_in_address, &(((struct sep_driver_write_t *) arg)->app_address)); +- if (error) +- goto end_function; +- +- /* get the virtual kernel address address */ +- error = get_user(va, &(((struct sep_driver_write_t *) arg)->datapool_address)); +- if (error) +- goto end_function; +- virt_address = (void *)va; +- +- /* get the number of bytes */ +- error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes)); +- if (error) +- goto end_function; +- +- /* calculate the start of the data pool */ +- data_pool_area_addr = sep->shared_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; +- +- +- /* check that the range of the virtual kernel address is correct */ +- if (virt_address < data_pool_area_addr || virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES)) { +- error = -EINVAL; +- goto end_function; +- } +- /* copy the application data */ +- error = copy_from_user(virt_address, (void *) app_in_address, num_bytes); +- if (error) +- error = -EFAULT; +-end_function: +- dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n"); +- return error; +-} +- +-/* +- this function handles the read from data pool command +-*/ +-static int sep_read_from_data_pool_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- /* virtual address of dest application buffer */ +- unsigned long app_out_address; +- /* virtual address of the data pool */ +- unsigned long va; +- void *virt_address; +- unsigned long num_bytes; +- void *data_pool_area_addr; +- +- dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n"); +- +- /* get the application address */ +- error = get_user(app_out_address, &(((struct sep_driver_write_t *) arg)->app_address)); +- if (error) +- goto end_function; +- +- /* get the virtual kernel address address */ +- error = get_user(va, &(((struct sep_driver_write_t *) arg)->datapool_address)); +- if (error) +- goto end_function; +- virt_address = (void *)va; +- +- /* get the number of bytes */ +- error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes)); +- if (error) +- goto end_function; +- +- /* calculate the start of the data pool */ +- data_pool_area_addr = sep->shared_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; +- +- /* FIXME: These are incomplete all over the driver: what about + len +- and when doing that also overflows */ +- /* check that the range of the virtual kernel address is correct */ +- if (virt_address < data_pool_area_addr || virt_address > data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) { +- error = -EINVAL; +- goto end_function; +- } +- +- /* copy the application data */ +- error = copy_to_user((void *) app_out_address, virt_address, num_bytes); +- if (error) +- error = -EFAULT; +-end_function: +- dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n"); +- return error; +-} +- +-/* +- This function releases all the application virtual buffer physical pages, +- that were previously locked +-*/ +-static int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag) +-{ +- unsigned long count; +- +- if (dirtyFlag) { +- for (count = 0; count < num_pages; count++) { +- /* the out array was written, therefore the data was changed */ +- if (!PageReserved(page_array_ptr[count])) +- SetPageDirty(page_array_ptr[count]); +- page_cache_release(page_array_ptr[count]); +- } +- } else { +- /* free in pages - the data was only read, therefore no update was done +- on those pages */ +- for (count = 0; count < num_pages; count++) +- page_cache_release(page_array_ptr[count]); +- } +- +- if (page_array_ptr) +- /* free the array */ +- kfree(page_array_ptr); +- +- return 0; +-} +- +-/* +- This function locks all the physical pages of the kernel virtual buffer +- and construct a basic lli array, where each entry holds the physical +- page address and the size that application data holds in this physical pages +-*/ +-static int sep_lock_kernel_pages(struct sep_device *sep, +- unsigned long kernel_virt_addr, +- unsigned long data_size, +- unsigned long *num_pages_ptr, +- struct sep_lli_entry_t **lli_array_ptr, +- struct page ***page_array_ptr) +-{ +- int error = 0; +- /* the the page of the end address of the user space buffer */ +- unsigned long end_page; +- /* the page of the start address of the user space buffer */ +- unsigned long start_page; +- /* the range in pages */ +- unsigned long num_pages; +- struct sep_lli_entry_t *lli_array; +- /* next kernel address to map */ +- unsigned long next_kernel_address; +- unsigned long count; +- +- dbg("SEP Driver:--------> sep_lock_kernel_pages start\n"); +- +- /* set start and end pages and num pages */ +- end_page = (kernel_virt_addr + data_size - 1) >> PAGE_SHIFT; +- start_page = kernel_virt_addr >> PAGE_SHIFT; +- num_pages = end_page - start_page + 1; +- +- edbg("SEP Driver: kernel_virt_addr is %08lx\n", kernel_virt_addr); +- edbg("SEP Driver: data_size is %lu\n", data_size); +- edbg("SEP Driver: start_page is %lx\n", start_page); +- edbg("SEP Driver: end_page is %lx\n", end_page); +- edbg("SEP Driver: num_pages is %lu\n", num_pages); +- +- lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); +- if (!lli_array) { +- edbg("SEP Driver: kmalloc for lli_array failed\n"); +- error = -ENOMEM; +- goto end_function; +- } +- +- /* set the start address of the first page - app data may start not at +- the beginning of the page */ +- lli_array[0].physical_address = (unsigned long) virt_to_phys((unsigned long *) kernel_virt_addr); +- +- /* check that not all the data is in the first page only */ +- if ((PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK))) >= data_size) +- lli_array[0].block_size = data_size; +- else +- lli_array[0].block_size = PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK)); +- +- /* debug print */ +- dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", lli_array[0].physical_address, lli_array[0].block_size); +- +- /* advance the address to the start of the next page */ +- next_kernel_address = (kernel_virt_addr & PAGE_MASK) + PAGE_SIZE; +- +- /* go from the second page to the prev before last */ +- for (count = 1; count < (num_pages - 1); count++) { +- lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address); +- lli_array[count].block_size = PAGE_SIZE; +- +- edbg("lli_array[%lu].physical_address is %08lx, lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); +- next_kernel_address += PAGE_SIZE; +- } +- +- /* if more then 1 pages locked - then update for the last page size needed */ +- if (num_pages > 1) { +- /* update the address of the last page */ +- lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address); +- +- /* set the size of the last page */ +- lli_array[count].block_size = (kernel_virt_addr + data_size) & (~PAGE_MASK); +- +- if (lli_array[count].block_size == 0) { +- dbg("app_virt_addr is %08lx\n", kernel_virt_addr); +- dbg("data_size is %lu\n", data_size); +- while (1); +- } +- +- edbg("lli_array[%lu].physical_address is %08lx, lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); +- } +- /* set output params */ +- *lli_array_ptr = lli_array; +- *num_pages_ptr = num_pages; +- *page_array_ptr = 0; +-end_function: +- dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n"); +- return 0; +-} +- +-/* +- This function locks all the physical pages of the application virtual buffer +- and construct a basic lli array, where each entry holds the physical page +- address and the size that application data holds in this physical pages +-*/ +-static int sep_lock_user_pages(struct sep_device *sep, +- unsigned long app_virt_addr, +- unsigned long data_size, +- unsigned long *num_pages_ptr, +- struct sep_lli_entry_t **lli_array_ptr, +- struct page ***page_array_ptr) +-{ +- int error = 0; +- /* the the page of the end address of the user space buffer */ +- unsigned long end_page; +- /* the page of the start address of the user space buffer */ +- unsigned long start_page; +- /* the range in pages */ +- unsigned long num_pages; +- struct page **page_array; +- struct sep_lli_entry_t *lli_array; +- unsigned long count; +- int result; +- +- dbg("SEP Driver:--------> sep_lock_user_pages start\n"); +- +- /* set start and end pages and num pages */ +- end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT; +- start_page = app_virt_addr >> PAGE_SHIFT; +- num_pages = end_page - start_page + 1; +- +- edbg("SEP Driver: app_virt_addr is %08lx\n", app_virt_addr); +- edbg("SEP Driver: data_size is %lu\n", data_size); +- edbg("SEP Driver: start_page is %lu\n", start_page); +- edbg("SEP Driver: end_page is %lu\n", end_page); +- edbg("SEP Driver: num_pages is %lu\n", num_pages); +- +- /* allocate array of pages structure pointers */ +- page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC); +- if (!page_array) { +- edbg("SEP Driver: kmalloc for page_array failed\n"); +- +- error = -ENOMEM; +- goto end_function; +- } +- +- lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); +- if (!lli_array) { +- edbg("SEP Driver: kmalloc for lli_array failed\n"); +- +- error = -ENOMEM; +- goto end_function_with_error1; +- } +- +- /* convert the application virtual address into a set of physical */ +- down_read(¤t->mm->mmap_sem); +- result = get_user_pages(current, current->mm, app_virt_addr, num_pages, 1, 0, page_array, 0); +- up_read(¤t->mm->mmap_sem); +- +- /* check the number of pages locked - if not all then exit with error */ +- if (result != num_pages) { +- dbg("SEP Driver: not all pages locked by get_user_pages\n"); +- +- error = -ENOMEM; +- goto end_function_with_error2; +- } +- +- /* flush the cache */ +- for (count = 0; count < num_pages; count++) +- flush_dcache_page(page_array[count]); +- +- /* set the start address of the first page - app data may start not at +- the beginning of the page */ +- lli_array[0].physical_address = ((unsigned long) page_to_phys(page_array[0])) + (app_virt_addr & (~PAGE_MASK)); +- +- /* check that not all the data is in the first page only */ +- if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size) +- lli_array[0].block_size = data_size; +- else +- lli_array[0].block_size = PAGE_SIZE - (app_virt_addr & (~PAGE_MASK)); +- +- /* debug print */ +- dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", lli_array[0].physical_address, lli_array[0].block_size); +- +- /* go from the second page to the prev before last */ +- for (count = 1; count < (num_pages - 1); count++) { +- lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]); +- lli_array[count].block_size = PAGE_SIZE; +- +- edbg("lli_array[%lu].physical_address is %08lx, lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); +- } +- +- /* if more then 1 pages locked - then update for the last page size needed */ +- if (num_pages > 1) { +- /* update the address of the last page */ +- lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]); +- +- /* set the size of the last page */ +- lli_array[count].block_size = (app_virt_addr + data_size) & (~PAGE_MASK); +- +- if (lli_array[count].block_size == 0) { +- dbg("app_virt_addr is %08lx\n", app_virt_addr); +- dbg("data_size is %lu\n", data_size); +- while (1); +- } +- edbg("lli_array[%lu].physical_address is %08lx, lli_array[%lu].block_size is %lu\n", +- count, lli_array[count].physical_address, +- count, lli_array[count].block_size); +- } +- +- /* set output params */ +- *lli_array_ptr = lli_array; +- *num_pages_ptr = num_pages; +- *page_array_ptr = page_array; +- goto end_function; +- +-end_function_with_error2: +- /* release the cache */ +- for (count = 0; count < num_pages; count++) +- page_cache_release(page_array[count]); +- kfree(lli_array); +-end_function_with_error1: +- kfree(page_array); +-end_function: +- dbg("SEP Driver:<-------- sep_lock_user_pages end\n"); +- return 0; +-} +- +- +-/* +- this function calculates the size of data that can be inserted into the lli +- table from this array the condition is that either the table is full +- (all etnries are entered), or there are no more entries in the lli array +-*/ +-static unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t *lli_in_array_ptr, unsigned long num_array_entries) +-{ +- unsigned long table_data_size = 0; +- unsigned long counter; +- +- /* calculate the data in the out lli table if till we fill the whole +- table or till the data has ended */ +- for (counter = 0; (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) && (counter < num_array_entries); counter++) +- table_data_size += lli_in_array_ptr[counter].block_size; +- return table_data_size; +-} +- +-/* +- this functions builds ont lli table from the lli_array according to +- the given size of data +-*/ +-static void sep_build_lli_table(struct sep_lli_entry_t *lli_array_ptr, struct sep_lli_entry_t *lli_table_ptr, unsigned long *num_processed_entries_ptr, unsigned long *num_table_entries_ptr, unsigned long table_data_size) +-{ +- unsigned long curr_table_data_size; +- /* counter of lli array entry */ +- unsigned long array_counter; +- +- dbg("SEP Driver:--------> sep_build_lli_table start\n"); +- +- /* init currrent table data size and lli array entry counter */ +- curr_table_data_size = 0; +- array_counter = 0; +- *num_table_entries_ptr = 1; +- +- edbg("SEP Driver:table_data_size is %lu\n", table_data_size); +- +- /* fill the table till table size reaches the needed amount */ +- while (curr_table_data_size < table_data_size) { +- /* update the number of entries in table */ +- (*num_table_entries_ptr)++; +- +- lli_table_ptr->physical_address = lli_array_ptr[array_counter].physical_address; +- lli_table_ptr->block_size = lli_array_ptr[array_counter].block_size; +- curr_table_data_size += lli_table_ptr->block_size; +- +- edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr); +- edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); +- edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); +- +- /* check for overflow of the table data */ +- if (curr_table_data_size > table_data_size) { +- edbg("SEP Driver:curr_table_data_size > table_data_size\n"); +- +- /* update the size of block in the table */ +- lli_table_ptr->block_size -= (curr_table_data_size - table_data_size); +- +- /* update the physical address in the lli array */ +- lli_array_ptr[array_counter].physical_address += lli_table_ptr->block_size; +- +- /* update the block size left in the lli array */ +- lli_array_ptr[array_counter].block_size = (curr_table_data_size - table_data_size); +- } else +- /* advance to the next entry in the lli_array */ +- array_counter++; +- +- edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); +- edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); +- +- /* move to the next entry in table */ +- lli_table_ptr++; +- } +- +- /* set the info entry to default */ +- lli_table_ptr->physical_address = 0xffffffff; +- lli_table_ptr->block_size = 0; +- +- edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr); +- edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); +- edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); +- +- /* set the output parameter */ +- *num_processed_entries_ptr += array_counter; +- +- edbg("SEP Driver:*num_processed_entries_ptr is %lu\n", *num_processed_entries_ptr); +- dbg("SEP Driver:<-------- sep_build_lli_table end\n"); +- return; +-} +- +-/* +- this function goes over the list of the print created tables and +- prints all the data +-*/ +-static void sep_debug_print_lli_tables(struct sep_device *sep, struct sep_lli_entry_t *lli_table_ptr, unsigned long num_table_entries, unsigned long table_data_size) +-{ +- unsigned long table_count; +- unsigned long entries_count; +- +- dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n"); +- +- table_count = 1; +- while ((unsigned long) lli_table_ptr != 0xffffffff) { +- edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", table_count, table_data_size); +- edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries); +- +- /* print entries of the table (without info entry) */ +- for (entries_count = 0; entries_count < num_table_entries; entries_count++, lli_table_ptr++) { +- edbg("SEP Driver:lli_table_ptr address is %08lx\n", (unsigned long) lli_table_ptr); +- edbg("SEP Driver:phys address is %08lx block size is %lu\n", lli_table_ptr->physical_address, lli_table_ptr->block_size); +- } +- +- /* point to the info entry */ +- lli_table_ptr--; +- +- edbg("SEP Driver:phys lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); +- edbg("SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); +- +- +- table_data_size = lli_table_ptr->block_size & 0xffffff; +- num_table_entries = (lli_table_ptr->block_size >> 24) & 0xff; +- lli_table_ptr = (struct sep_lli_entry_t *) +- (lli_table_ptr->physical_address); +- +- edbg("SEP Driver:phys table_data_size is %lu num_table_entries is %lu lli_table_ptr is%lu\n", table_data_size, num_table_entries, (unsigned long) lli_table_ptr); +- +- if ((unsigned long) lli_table_ptr != 0xffffffff) +- lli_table_ptr = (struct sep_lli_entry_t *) sep_shared_bus_to_virt(sep, (unsigned long) lli_table_ptr); +- +- table_count++; +- } +- dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n"); +-} +- +- +-/* +- This function prepares only input DMA table for synhronic symmetric +- operations (HASH) +-*/ +-static int sep_prepare_input_dma_table(struct sep_device *sep, +- unsigned long app_virt_addr, +- unsigned long data_size, +- unsigned long block_size, +- unsigned long *lli_table_ptr, +- unsigned long *num_entries_ptr, +- unsigned long *table_data_size_ptr, +- bool isKernelVirtualAddress) +-{ +- /* pointer to the info entry of the table - the last entry */ +- struct sep_lli_entry_t *info_entry_ptr; +- /* array of pointers ot page */ +- struct sep_lli_entry_t *lli_array_ptr; +- /* points to the first entry to be processed in the lli_in_array */ +- unsigned long current_entry; +- /* num entries in the virtual buffer */ +- unsigned long sep_lli_entries; +- /* lli table pointer */ +- struct sep_lli_entry_t *in_lli_table_ptr; +- /* the total data in one table */ +- unsigned long table_data_size; +- /* number of entries in lli table */ +- unsigned long num_entries_in_table; +- /* next table address */ +- void *lli_table_alloc_addr; +- unsigned long result; +- +- dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n"); +- +- edbg("SEP Driver:data_size is %lu\n", data_size); +- edbg("SEP Driver:block_size is %lu\n", block_size); +- +- /* initialize the pages pointers */ +- sep->in_page_array = 0; +- sep->in_num_pages = 0; +- +- if (data_size == 0) { +- /* special case - created 2 entries table with zero data */ +- in_lli_table_ptr = (struct sep_lli_entry_t *) (sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES); +- /* FIXME: Should the entry below not be for _bus */ +- in_lli_table_ptr->physical_address = (unsigned long)sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; +- in_lli_table_ptr->block_size = 0; +- +- in_lli_table_ptr++; +- in_lli_table_ptr->physical_address = 0xFFFFFFFF; +- in_lli_table_ptr->block_size = 0; +- +- *lli_table_ptr = sep->shared_bus + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; +- *num_entries_ptr = 2; +- *table_data_size_ptr = 0; +- +- goto end_function; +- } +- +- /* check if the pages are in Kernel Virtual Address layout */ +- if (isKernelVirtualAddress == true) +- /* lock the pages of the kernel buffer and translate them to pages */ +- result = sep_lock_kernel_pages(sep, app_virt_addr, data_size, &sep->in_num_pages, &lli_array_ptr, &sep->in_page_array); +- else +- /* lock the pages of the user buffer and translate them to pages */ +- result = sep_lock_user_pages(sep, app_virt_addr, data_size, &sep->in_num_pages, &lli_array_ptr, &sep->in_page_array); +- +- if (result) +- return result; +- +- edbg("SEP Driver:output sep->in_num_pages is %lu\n", sep->in_num_pages); +- +- current_entry = 0; +- info_entry_ptr = 0; +- sep_lli_entries = sep->in_num_pages; +- +- /* initiate to point after the message area */ +- lli_table_alloc_addr = sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; +- +- /* loop till all the entries in in array are not processed */ +- while (current_entry < sep_lli_entries) { +- /* set the new input and output tables */ +- in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; +- +- lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; +- +- /* calculate the maximum size of data for input table */ +- table_data_size = sep_calculate_lli_table_max_size(&lli_array_ptr[current_entry], (sep_lli_entries - current_entry)); +- +- /* now calculate the table size so that it will be module block size */ +- table_data_size = (table_data_size / block_size) * block_size; +- +- edbg("SEP Driver:output table_data_size is %lu\n", table_data_size); +- +- /* construct input lli table */ +- sep_build_lli_table(&lli_array_ptr[current_entry], in_lli_table_ptr, ¤t_entry, &num_entries_in_table, table_data_size); +- +- if (info_entry_ptr == 0) { +- /* set the output parameters to physical addresses */ +- *lli_table_ptr = sep_shared_virt_to_bus(sep, in_lli_table_ptr); +- *num_entries_ptr = num_entries_in_table; +- *table_data_size_ptr = table_data_size; +- +- edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_ptr); +- } else { +- /* update the info entry of the previous in table */ +- info_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, in_lli_table_ptr); +- info_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size); +- } +- +- /* save the pointer to the info entry of the current tables */ +- info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; +- } +- +- /* print input tables */ +- sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *) +- sep_shared_bus_to_virt(sep, *lli_table_ptr), *num_entries_ptr, *table_data_size_ptr); +- +- /* the array of the pages */ +- kfree(lli_array_ptr); +-end_function: +- dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n"); +- return 0; +- +-} +- +-/* +- This function creates the input and output dma tables for +- symmetric operations (AES/DES) according to the block size from LLI arays +-*/ +-static int sep_construct_dma_tables_from_lli(struct sep_device *sep, +- struct sep_lli_entry_t *lli_in_array, +- unsigned long sep_in_lli_entries, +- struct sep_lli_entry_t *lli_out_array, +- unsigned long sep_out_lli_entries, +- unsigned long block_size, unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr) +-{ +- /* points to the area where next lli table can be allocated: keep void * +- as there is pointer scaling to fix otherwise */ +- void *lli_table_alloc_addr; +- /* input lli table */ +- struct sep_lli_entry_t *in_lli_table_ptr; +- /* output lli table */ +- struct sep_lli_entry_t *out_lli_table_ptr; +- /* pointer to the info entry of the table - the last entry */ +- struct sep_lli_entry_t *info_in_entry_ptr; +- /* pointer to the info entry of the table - the last entry */ +- struct sep_lli_entry_t *info_out_entry_ptr; +- /* points to the first entry to be processed in the lli_in_array */ +- unsigned long current_in_entry; +- /* points to the first entry to be processed in the lli_out_array */ +- unsigned long current_out_entry; +- /* max size of the input table */ +- unsigned long in_table_data_size; +- /* max size of the output table */ +- unsigned long out_table_data_size; +- /* flag te signifies if this is the first tables build from the arrays */ +- unsigned long first_table_flag; +- /* the data size that should be in table */ +- unsigned long table_data_size; +- /* number of etnries in the input table */ +- unsigned long num_entries_in_table; +- /* number of etnries in the output table */ +- unsigned long num_entries_out_table; +- +- dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n"); +- +- /* initiate to pint after the message area */ +- lli_table_alloc_addr = sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; +- +- current_in_entry = 0; +- current_out_entry = 0; +- first_table_flag = 1; +- info_in_entry_ptr = 0; +- info_out_entry_ptr = 0; +- +- /* loop till all the entries in in array are not processed */ +- while (current_in_entry < sep_in_lli_entries) { +- /* set the new input and output tables */ +- in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; +- +- lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; +- +- /* set the first output tables */ +- out_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; +- +- lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; +- +- /* calculate the maximum size of data for input table */ +- in_table_data_size = sep_calculate_lli_table_max_size(&lli_in_array[current_in_entry], (sep_in_lli_entries - current_in_entry)); +- +- /* calculate the maximum size of data for output table */ +- out_table_data_size = sep_calculate_lli_table_max_size(&lli_out_array[current_out_entry], (sep_out_lli_entries - current_out_entry)); +- +- edbg("SEP Driver:in_table_data_size is %lu\n", in_table_data_size); +- edbg("SEP Driver:out_table_data_size is %lu\n", out_table_data_size); +- +- /* check where the data is smallest */ +- table_data_size = in_table_data_size; +- if (table_data_size > out_table_data_size) +- table_data_size = out_table_data_size; +- +- /* now calculate the table size so that it will be module block size */ +- table_data_size = (table_data_size / block_size) * block_size; +- +- dbg("SEP Driver:table_data_size is %lu\n", table_data_size); +- +- /* construct input lli table */ +- sep_build_lli_table(&lli_in_array[current_in_entry], in_lli_table_ptr, ¤t_in_entry, &num_entries_in_table, table_data_size); +- +- /* construct output lli table */ +- sep_build_lli_table(&lli_out_array[current_out_entry], out_lli_table_ptr, ¤t_out_entry, &num_entries_out_table, table_data_size); +- +- /* if info entry is null - this is the first table built */ +- if (info_in_entry_ptr == 0) { +- /* set the output parameters to physical addresses */ +- *lli_table_in_ptr = sep_shared_virt_to_bus(sep, in_lli_table_ptr); +- *in_num_entries_ptr = num_entries_in_table; +- *lli_table_out_ptr = sep_shared_virt_to_bus(sep, out_lli_table_ptr); +- *out_num_entries_ptr = num_entries_out_table; +- *table_data_size_ptr = table_data_size; +- +- edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr); +- edbg("SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr); +- } else { +- /* update the info entry of the previous in table */ +- info_in_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, in_lli_table_ptr); +- info_in_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size); +- +- /* update the info entry of the previous in table */ +- info_out_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, out_lli_table_ptr); +- info_out_entry_ptr->block_size = ((num_entries_out_table) << 24) | (table_data_size); +- } +- +- /* save the pointer to the info entry of the current tables */ +- info_in_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; +- info_out_entry_ptr = out_lli_table_ptr + num_entries_out_table - 1; +- +- edbg("SEP Driver:output num_entries_out_table is %lu\n", (unsigned long) num_entries_out_table); +- edbg("SEP Driver:output info_in_entry_ptr is %lu\n", (unsigned long) info_in_entry_ptr); +- edbg("SEP Driver:output info_out_entry_ptr is %lu\n", (unsigned long) info_out_entry_ptr); +- } +- +- /* print input tables */ +- sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *) +- sep_shared_bus_to_virt(sep, *lli_table_in_ptr), *in_num_entries_ptr, *table_data_size_ptr); +- /* print output tables */ +- sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *) +- sep_shared_bus_to_virt(sep, *lli_table_out_ptr), *out_num_entries_ptr, *table_data_size_ptr); +- dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n"); +- return 0; +-} +- +- +-/* +- This function builds input and output DMA tables for synhronic +- symmetric operations (AES, DES). It also checks that each table +- is of the modular block size +-*/ +-static int sep_prepare_input_output_dma_table(struct sep_device *sep, +- unsigned long app_virt_in_addr, +- unsigned long app_virt_out_addr, +- unsigned long data_size, +- unsigned long block_size, +- unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr, bool isKernelVirtualAddress) +-{ +- /* array of pointers of page */ +- struct sep_lli_entry_t *lli_in_array; +- /* array of pointers of page */ +- struct sep_lli_entry_t *lli_out_array; +- int result = 0; +- +- dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n"); +- +- /* initialize the pages pointers */ +- sep->in_page_array = 0; +- sep->out_page_array = 0; +- +- /* check if the pages are in Kernel Virtual Address layout */ +- if (isKernelVirtualAddress == true) { +- /* lock the pages of the kernel buffer and translate them to pages */ +- result = sep_lock_kernel_pages(sep, app_virt_in_addr, data_size, &sep->in_num_pages, &lli_in_array, &sep->in_page_array); +- if (result) { +- edbg("SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n"); +- goto end_function; +- } +- } else { +- /* lock the pages of the user buffer and translate them to pages */ +- result = sep_lock_user_pages(sep, app_virt_in_addr, data_size, &sep->in_num_pages, &lli_in_array, &sep->in_page_array); +- if (result) { +- edbg("SEP Driver: sep_lock_user_pages for input virtual buffer failed\n"); +- goto end_function; +- } +- } +- +- if (isKernelVirtualAddress == true) { +- result = sep_lock_kernel_pages(sep, app_virt_out_addr, data_size, &sep->out_num_pages, &lli_out_array, &sep->out_page_array); +- if (result) { +- edbg("SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n"); +- goto end_function_with_error1; +- } +- } else { +- result = sep_lock_user_pages(sep, app_virt_out_addr, data_size, &sep->out_num_pages, &lli_out_array, &sep->out_page_array); +- if (result) { +- edbg("SEP Driver: sep_lock_user_pages for output virtual buffer failed\n"); +- goto end_function_with_error1; +- } +- } +- edbg("sep->in_num_pages is %lu\n", sep->in_num_pages); +- edbg("sep->out_num_pages is %lu\n", sep->out_num_pages); +- edbg("SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP); +- +- +- /* call the fucntion that creates table from the lli arrays */ +- result = sep_construct_dma_tables_from_lli(sep, lli_in_array, sep->in_num_pages, lli_out_array, sep->out_num_pages, block_size, lli_table_in_ptr, lli_table_out_ptr, in_num_entries_ptr, out_num_entries_ptr, table_data_size_ptr); +- if (result) { +- edbg("SEP Driver: sep_construct_dma_tables_from_lli failed\n"); +- goto end_function_with_error2; +- } +- +- /* fall through - free the lli entry arrays */ +- dbg("in_num_entries_ptr is %08lx\n", *in_num_entries_ptr); +- dbg("out_num_entries_ptr is %08lx\n", *out_num_entries_ptr); +- dbg("table_data_size_ptr is %08lx\n", *table_data_size_ptr); +-end_function_with_error2: +- kfree(lli_out_array); +-end_function_with_error1: +- kfree(lli_in_array); +-end_function: +- dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result); +- return result; +- +-} +- +-/* +- this function handles tha request for creation of the DMA table +- for the synchronic symmetric operations (AES,DES) +-*/ +-static int sep_create_sync_dma_tables_handler(struct sep_device *sep, +- unsigned long arg) +-{ +- int error; +- /* command arguments */ +- struct sep_driver_build_sync_table_t command_args; +- +- dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n"); +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_sync_table_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- edbg("app_in_address is %08lx\n", command_args.app_in_address); +- edbg("app_out_address is %08lx\n", command_args.app_out_address); +- edbg("data_size is %lu\n", command_args.data_in_size); +- edbg("block_size is %lu\n", command_args.block_size); +- +- /* check if we need to build only input table or input/output */ +- if (command_args.app_out_address) +- /* prepare input and output tables */ +- error = sep_prepare_input_output_dma_table(sep, +- command_args.app_in_address, +- command_args.app_out_address, +- command_args.data_in_size, +- command_args.block_size, +- &command_args.in_table_address, +- &command_args.out_table_address, &command_args.in_table_num_entries, &command_args.out_table_num_entries, &command_args.table_data_size, command_args.isKernelVirtualAddress); +- else +- /* prepare input tables */ +- error = sep_prepare_input_dma_table(sep, +- command_args.app_in_address, +- command_args.data_in_size, command_args.block_size, &command_args.in_table_address, &command_args.in_table_num_entries, &command_args.table_data_size, command_args.isKernelVirtualAddress); +- +- if (error) +- goto end_function; +- /* copy to user */ +- if (copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_build_sync_table_t))) +- error = -EFAULT; +-end_function: +- dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n"); +- return error; +-} +- +-/* +- this function handles the request for freeing dma table for synhronic actions +-*/ +-static int sep_free_dma_table_data_handler(struct sep_device *sep) +-{ +- dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n"); +- +- /* free input pages array */ +- sep_free_dma_pages(sep->in_page_array, sep->in_num_pages, 0); +- +- /* free output pages array if needed */ +- if (sep->out_page_array) +- sep_free_dma_pages(sep->out_page_array, sep->out_num_pages, 1); +- +- /* reset all the values */ +- sep->in_page_array = 0; +- sep->out_page_array = 0; +- sep->in_num_pages = 0; +- sep->out_num_pages = 0; +- dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n"); +- return 0; +-} +- +-/* +- this function find a space for the new flow dma table +-*/ +-static int sep_find_free_flow_dma_table_space(struct sep_device *sep, +- unsigned long **table_address_ptr) +-{ +- int error = 0; +- /* pointer to the id field of the flow dma table */ +- unsigned long *start_table_ptr; +- /* Do not make start_addr unsigned long * unless fixing the offset +- computations ! */ +- void *flow_dma_area_start_addr; +- unsigned long *flow_dma_area_end_addr; +- /* maximum table size in words */ +- unsigned long table_size_in_words; +- +- /* find the start address of the flow DMA table area */ +- flow_dma_area_start_addr = sep->shared_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES; +- +- /* set end address of the flow table area */ +- flow_dma_area_end_addr = flow_dma_area_start_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES; +- +- /* set table size in words */ +- table_size_in_words = SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE * (sizeof(struct sep_lli_entry_t) / sizeof(long)) + 2; +- +- /* set the pointer to the start address of DMA area */ +- start_table_ptr = flow_dma_area_start_addr; +- +- /* find the space for the next table */ +- while (((*start_table_ptr & 0x7FFFFFFF) != 0) && start_table_ptr < flow_dma_area_end_addr) +- start_table_ptr += table_size_in_words; +- +- /* check if we reached the end of floa tables area */ +- if (start_table_ptr >= flow_dma_area_end_addr) +- error = -1; +- else +- *table_address_ptr = start_table_ptr; +- +- return error; +-} +- +-/* +- This function creates one DMA table for flow and returns its data, +- and pointer to its info entry +-*/ +-static int sep_prepare_one_flow_dma_table(struct sep_device *sep, +- unsigned long virt_buff_addr, +- unsigned long virt_buff_size, +- struct sep_lli_entry_t *table_data, +- struct sep_lli_entry_t **info_entry_ptr, +- struct sep_flow_context_t *flow_data_ptr, +- bool isKernelVirtualAddress) +-{ +- int error; +- /* the range in pages */ +- unsigned long lli_array_size; +- struct sep_lli_entry_t *lli_array; +- struct sep_lli_entry_t *flow_dma_table_entry_ptr; +- unsigned long *start_dma_table_ptr; +- /* total table data counter */ +- unsigned long dma_table_data_count; +- /* pointer that will keep the pointer to the pages of the virtual buffer */ +- struct page **page_array_ptr; +- unsigned long entry_count; +- +- /* find the space for the new table */ +- error = sep_find_free_flow_dma_table_space(sep, &start_dma_table_ptr); +- if (error) +- goto end_function; +- +- /* check if the pages are in Kernel Virtual Address layout */ +- if (isKernelVirtualAddress == true) +- /* lock kernel buffer in the memory */ +- error = sep_lock_kernel_pages(sep, virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr); +- else +- /* lock user buffer in the memory */ +- error = sep_lock_user_pages(sep, virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr); +- +- if (error) +- goto end_function; +- +- /* set the pointer to page array at the beginning of table - this table is +- now considered taken */ +- *start_dma_table_ptr = lli_array_size; +- +- /* point to the place of the pages pointers of the table */ +- start_dma_table_ptr++; +- +- /* set the pages pointer */ +- *start_dma_table_ptr = (unsigned long) page_array_ptr; +- +- /* set the pointer to the first entry */ +- flow_dma_table_entry_ptr = (struct sep_lli_entry_t *) (++start_dma_table_ptr); +- +- /* now create the entries for table */ +- for (dma_table_data_count = entry_count = 0; entry_count < lli_array_size; entry_count++) { +- flow_dma_table_entry_ptr->physical_address = lli_array[entry_count].physical_address; +- +- flow_dma_table_entry_ptr->block_size = lli_array[entry_count].block_size; +- +- /* set the total data of a table */ +- dma_table_data_count += lli_array[entry_count].block_size; +- +- flow_dma_table_entry_ptr++; +- } +- +- /* set the physical address */ +- table_data->physical_address = virt_to_phys(start_dma_table_ptr); +- +- /* set the num_entries and total data size */ +- table_data->block_size = ((lli_array_size + 1) << SEP_NUM_ENTRIES_OFFSET_IN_BITS) | (dma_table_data_count); +- +- /* set the info entry */ +- flow_dma_table_entry_ptr->physical_address = 0xffffffff; +- flow_dma_table_entry_ptr->block_size = 0; +- +- /* set the pointer to info entry */ +- *info_entry_ptr = flow_dma_table_entry_ptr; +- +- /* the array of the lli entries */ +- kfree(lli_array); +-end_function: +- return error; +-} +- +- +- +-/* +- This function creates a list of tables for flow and returns the data for +- the first and last tables of the list +-*/ +-static int sep_prepare_flow_dma_tables(struct sep_device *sep, +- unsigned long num_virtual_buffers, +- unsigned long first_buff_addr, struct sep_flow_context_t *flow_data_ptr, struct sep_lli_entry_t *first_table_data_ptr, struct sep_lli_entry_t *last_table_data_ptr, bool isKernelVirtualAddress) +-{ +- int error; +- unsigned long virt_buff_addr; +- unsigned long virt_buff_size; +- struct sep_lli_entry_t table_data; +- struct sep_lli_entry_t *info_entry_ptr; +- struct sep_lli_entry_t *prev_info_entry_ptr; +- unsigned long i; +- +- /* init vars */ +- error = 0; +- prev_info_entry_ptr = 0; +- +- /* init the first table to default */ +- table_data.physical_address = 0xffffffff; +- first_table_data_ptr->physical_address = 0xffffffff; +- table_data.block_size = 0; +- +- for (i = 0; i < num_virtual_buffers; i++) { +- /* get the virtual buffer address */ +- error = get_user(virt_buff_addr, &first_buff_addr); +- if (error) +- goto end_function; +- +- /* get the virtual buffer size */ +- first_buff_addr++; +- error = get_user(virt_buff_size, &first_buff_addr); +- if (error) +- goto end_function; +- +- /* advance the address to point to the next pair of address|size */ +- first_buff_addr++; +- +- /* now prepare the one flow LLI table from the data */ +- error = sep_prepare_one_flow_dma_table(sep, virt_buff_addr, virt_buff_size, &table_data, &info_entry_ptr, flow_data_ptr, isKernelVirtualAddress); +- if (error) +- goto end_function; +- +- if (i == 0) { +- /* if this is the first table - save it to return to the user +- application */ +- *first_table_data_ptr = table_data; +- +- /* set the pointer to info entry */ +- prev_info_entry_ptr = info_entry_ptr; +- } else { +- /* not first table - the previous table info entry should +- be updated */ +- prev_info_entry_ptr->block_size = (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS) | (table_data.block_size); +- +- /* set the pointer to info entry */ +- prev_info_entry_ptr = info_entry_ptr; +- } +- } +- +- /* set the last table data */ +- *last_table_data_ptr = table_data; +-end_function: +- return error; +-} +- +-/* +- this function goes over all the flow tables connected to the given +- table and deallocate them +-*/ +-static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr) +-{ +- /* id pointer */ +- unsigned long *table_ptr; +- /* end address of the flow dma area */ +- unsigned long num_entries; +- unsigned long num_pages; +- struct page **pages_ptr; +- /* maximum table size in words */ +- struct sep_lli_entry_t *info_entry_ptr; +- +- /* set the pointer to the first table */ +- table_ptr = (unsigned long *) first_table_ptr->physical_address; +- +- /* set the num of entries */ +- num_entries = (first_table_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) +- & SEP_NUM_ENTRIES_MASK; +- +- /* go over all the connected tables */ +- while (*table_ptr != 0xffffffff) { +- /* get number of pages */ +- num_pages = *(table_ptr - 2); +- +- /* get the pointer to the pages */ +- pages_ptr = (struct page **) (*(table_ptr - 1)); +- +- /* free the pages */ +- sep_free_dma_pages(pages_ptr, num_pages, 1); +- +- /* goto to the info entry */ +- info_entry_ptr = ((struct sep_lli_entry_t *) table_ptr) + (num_entries - 1); +- +- table_ptr = (unsigned long *) info_entry_ptr->physical_address; +- num_entries = (info_entry_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; +- } +- +- return; +-} +- +-/** +- * sep_find_flow_context - find a flow +- * @sep: the SEP we are working with +- * @flow_id: flow identifier +- * +- * Returns a pointer the matching flow, or NULL if the flow does not +- * exist. +- */ +- +-static struct sep_flow_context_t *sep_find_flow_context(struct sep_device *sep, +- unsigned long flow_id) +-{ +- int count; +- /* +- * always search for flow with id default first - in case we +- * already started working on the flow there can be no situation +- * when 2 flows are with default flag +- */ +- for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) { +- if (sep->flows[count].flow_id == flow_id) +- return &sep->flows[count]; +- } +- return NULL; +-} +- +- +-/* +- this function handles the request to create the DMA tables for flow +-*/ +-static int sep_create_flow_dma_tables_handler(struct sep_device *sep, +- unsigned long arg) +-{ +- int error = -ENOENT; +- struct sep_driver_build_flow_table_t command_args; +- /* first table - output */ +- struct sep_lli_entry_t first_table_data; +- /* dma table data */ +- struct sep_lli_entry_t last_table_data; +- /* pointer to the info entry of the previuos DMA table */ +- struct sep_lli_entry_t *prev_info_entry_ptr; +- /* pointer to the flow data strucutre */ +- struct sep_flow_context_t *flow_context_ptr; +- +- dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n"); +- +- /* init variables */ +- prev_info_entry_ptr = 0; +- first_table_data.physical_address = 0xffffffff; +- +- /* find the free structure for flow data */ +- error = -EINVAL; +- flow_context_ptr = sep_find_flow_context(sep, SEP_FREE_FLOW_ID); +- if (flow_context_ptr == NULL) +- goto end_function; +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_flow_table_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- /* create flow tables */ +- error = sep_prepare_flow_dma_tables(sep, command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress); +- if (error) +- goto end_function_with_error; +- +- /* check if flow is static */ +- if (!command_args.flow_type) +- /* point the info entry of the last to the info entry of the first */ +- last_table_data = first_table_data; +- +- /* set output params */ +- command_args.first_table_addr = first_table_data.physical_address; +- command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK); +- command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); +- +- /* send the parameters to user application */ +- error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_build_flow_table_t)); +- if (error) { +- error = -EFAULT; +- goto end_function_with_error; +- } +- +- /* all the flow created - update the flow entry with temp id */ +- flow_context_ptr->flow_id = SEP_TEMP_FLOW_ID; +- +- /* set the processing tables data in the context */ +- if (command_args.input_output_flag == SEP_DRIVER_IN_FLAG) +- flow_context_ptr->input_tables_in_process = first_table_data; +- else +- flow_context_ptr->output_tables_in_process = first_table_data; +- +- goto end_function; +- +-end_function_with_error: +- /* free the allocated tables */ +- sep_deallocated_flow_tables(&first_table_data); +-end_function: +- dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n"); +- return error; +-} +- +-/* +- this function handles add tables to flow +-*/ +-static int sep_add_flow_tables_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- unsigned long num_entries; +- struct sep_driver_add_flow_table_t command_args; +- struct sep_flow_context_t *flow_context_ptr; +- /* first dma table data */ +- struct sep_lli_entry_t first_table_data; +- /* last dma table data */ +- struct sep_lli_entry_t last_table_data; +- /* pointer to the info entry of the current DMA table */ +- struct sep_lli_entry_t *info_entry_ptr; +- +- dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n"); +- +- /* get input parameters */ +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_flow_table_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- /* find the flow structure for the flow id */ +- flow_context_ptr = sep_find_flow_context(sep, command_args.flow_id); +- if (flow_context_ptr == NULL) +- goto end_function; +- +- /* prepare the flow dma tables */ +- error = sep_prepare_flow_dma_tables(sep, command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress); +- if (error) +- goto end_function_with_error; +- +- /* now check if there is already an existing add table for this flow */ +- if (command_args.inputOutputFlag == SEP_DRIVER_IN_FLAG) { +- /* this buffer was for input buffers */ +- if (flow_context_ptr->input_tables_flag) { +- /* add table already exists - add the new tables to the end +- of the previous */ +- num_entries = (flow_context_ptr->last_input_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; +- +- info_entry_ptr = (struct sep_lli_entry_t *) +- (flow_context_ptr->last_input_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); +- +- /* connect to list of tables */ +- *info_entry_ptr = first_table_data; +- +- /* set the first table data */ +- first_table_data = flow_context_ptr->first_input_table; +- } else { +- /* set the input flag */ +- flow_context_ptr->input_tables_flag = 1; +- +- /* set the first table data */ +- flow_context_ptr->first_input_table = first_table_data; +- } +- /* set the last table data */ +- flow_context_ptr->last_input_table = last_table_data; +- } else { /* this is output tables */ +- +- /* this buffer was for input buffers */ +- if (flow_context_ptr->output_tables_flag) { +- /* add table already exists - add the new tables to +- the end of the previous */ +- num_entries = (flow_context_ptr->last_output_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; +- +- info_entry_ptr = (struct sep_lli_entry_t *) +- (flow_context_ptr->last_output_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); +- +- /* connect to list of tables */ +- *info_entry_ptr = first_table_data; +- +- /* set the first table data */ +- first_table_data = flow_context_ptr->first_output_table; +- } else { +- /* set the input flag */ +- flow_context_ptr->output_tables_flag = 1; +- +- /* set the first table data */ +- flow_context_ptr->first_output_table = first_table_data; +- } +- /* set the last table data */ +- flow_context_ptr->last_output_table = last_table_data; +- } +- +- /* set output params */ +- command_args.first_table_addr = first_table_data.physical_address; +- command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK); +- command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); +- +- /* send the parameters to user application */ +- error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_add_flow_table_t)); +- if (error) +- error = -EFAULT; +-end_function_with_error: +- /* free the allocated tables */ +- sep_deallocated_flow_tables(&first_table_data); +-end_function: +- dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n"); +- return error; +-} +- +-/* +- this function add the flow add message to the specific flow +-*/ +-static int sep_add_flow_tables_message_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- struct sep_driver_add_message_t command_args; +- struct sep_flow_context_t *flow_context_ptr; +- +- dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n"); +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_message_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- /* check input */ +- if (command_args.message_size_in_bytes > SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES) { +- error = -ENOMEM; +- goto end_function; +- } +- +- /* find the flow context */ +- flow_context_ptr = sep_find_flow_context(sep, command_args.flow_id); +- if (flow_context_ptr == NULL) +- goto end_function; +- +- /* copy the message into context */ +- flow_context_ptr->message_size_in_bytes = command_args.message_size_in_bytes; +- error = copy_from_user(flow_context_ptr->message, (void *) command_args.message_address, command_args.message_size_in_bytes); +- if (error) +- error = -EFAULT; +-end_function: +- dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n"); +- return error; +-} +- +- +-/* +- this function returns the bus and virtual addresses of the static pool +-*/ +-static int sep_get_static_pool_addr_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- struct sep_driver_static_pool_addr_t command_args; +- +- dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n"); +- +- /*prepare the output parameters in the struct */ +- command_args.physical_static_address = sep->shared_bus + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; +- command_args.virtual_static_address = (unsigned long)sep->shared_addr + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; +- +- edbg("SEP Driver:bus_static_address is %08lx, virtual_static_address %08lx\n", command_args.physical_static_address, command_args.virtual_static_address); +- +- /* send the parameters to user application */ +- error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_static_pool_addr_t)); +- if (error) +- error = -EFAULT; +- dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n"); +- return error; +-} +- +-/* +- this address gets the offset of the physical address from the start +- of the mapped area +-*/ +-static int sep_get_physical_mapped_offset_handler(struct sep_device *sep, unsigned long arg) +-{ +- int error; +- struct sep_driver_get_mapped_offset_t command_args; +- +- dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n"); +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_get_mapped_offset_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- +- if (command_args.physical_address < sep->shared_bus) { +- error = -EINVAL; +- goto end_function; +- } +- +- /*prepare the output parameters in the struct */ +- command_args.offset = command_args.physical_address - sep->shared_bus; +- +- edbg("SEP Driver:bus_address is %08lx, offset is %lu\n", command_args.physical_address, command_args.offset); +- +- /* send the parameters to user application */ +- error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_get_mapped_offset_t)); +- if (error) +- error = -EFAULT; +-end_function: +- dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n"); +- return error; +-} +- +- +-/* +- ? +-*/ +-static int sep_start_handler(struct sep_device *sep) +-{ +- unsigned long reg_val; +- unsigned long error = 0; +- +- dbg("SEP Driver:--------> sep_start_handler start\n"); +- +- /* wait in polling for message from SEP */ +- do +- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); +- while (!reg_val); +- +- /* check the value */ +- if (reg_val == 0x1) +- /* fatal error - read error status from GPRO */ +- error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR); +- dbg("SEP Driver:<-------- sep_start_handler end\n"); +- return error; +-} +- +-/* +- this function handles the request for SEP initialization +-*/ +-static int sep_init_handler(struct sep_device *sep, unsigned long arg) +-{ +- unsigned long message_word; +- unsigned long *message_ptr; +- struct sep_driver_init_t command_args; +- unsigned long counter; +- unsigned long error; +- unsigned long reg_val; +- +- dbg("SEP Driver:--------> sep_init_handler start\n"); +- error = 0; +- +- error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_init_t)); +- if (error) { +- error = -EFAULT; +- goto end_function; +- } +- dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user\n"); +- +- /* PATCH - configure the DMA to single -burst instead of multi-burst */ +- /*sep_configure_dma_burst(); */ +- +- dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n"); +- +- message_ptr = (unsigned long *) command_args.message_addr; +- +- /* set the base address of the SRAM */ +- sep_write_reg(sep, HW_SRAM_ADDR_REG_ADDR, HW_CC_SRAM_BASE_ADDRESS); +- +- for (counter = 0; counter < command_args.message_size_in_words; counter++, message_ptr++) { +- get_user(message_word, message_ptr); +- /* write data to SRAM */ +- sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR, message_word); +- edbg("SEP Driver:message_word is %lu\n", message_word); +- /* wait for write complete */ +- sep_wait_sram_write(sep); +- } +- dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n"); +- /* signal SEP */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1); +- +- do +- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); +- while (!(reg_val & 0xFFFFFFFD)); +- +- dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n"); +- +- /* check the value */ +- if (reg_val == 0x1) { +- edbg("SEP Driver:init failed\n"); +- +- error = sep_read_reg(sep, 0x8060); +- edbg("SEP Driver:sw monitor is %lu\n", error); +- +- /* fatal error - read erro status from GPRO */ +- error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR); +- edbg("SEP Driver:error is %lu\n", error); +- } +-end_function: +- dbg("SEP Driver:<-------- sep_init_handler end\n"); +- return error; +- +-} +- +-/* +- this function handles the request cache and resident reallocation +-*/ +-static int sep_realloc_cache_resident_handler(struct sep_device *sep, +- unsigned long arg) +-{ +- struct sep_driver_realloc_cache_resident_t command_args; +- int error; +- +- /* copy cache and resident to the their intended locations */ +- error = sep_load_firmware(sep); +- if (error) +- return error; +- +- command_args.new_base_addr = sep->shared_bus; +- +- /* find the new base address according to the lowest address between +- cache, resident and shared area */ +- if (sep->resident_bus < command_args.new_base_addr) +- command_args.new_base_addr = sep->resident_bus; +- if (sep->rar_bus < command_args.new_base_addr) +- command_args.new_base_addr = sep->rar_bus; +- +- /* set the return parameters */ +- command_args.new_cache_addr = sep->rar_bus; +- command_args.new_resident_addr = sep->resident_bus; +- +- /* set the new shared area */ +- command_args.new_shared_area_addr = sep->shared_bus; +- +- edbg("SEP Driver:command_args.new_shared_addr is %08llx\n", command_args.new_shared_area_addr); +- edbg("SEP Driver:command_args.new_base_addr is %08llx\n", command_args.new_base_addr); +- edbg("SEP Driver:command_args.new_resident_addr is %08llx\n", command_args.new_resident_addr); +- edbg("SEP Driver:command_args.new_rar_addr is %08llx\n", command_args.new_cache_addr); +- +- /* return to user */ +- if (copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_realloc_cache_resident_t))) +- return -EFAULT; +- return 0; +-} +- +-/** +- * sep_get_time_handler - time request from user space +- * @sep: sep we are to set the time for +- * @arg: pointer to user space arg buffer +- * +- * This function reports back the time and the address in the SEP +- * shared buffer at which it has been placed. (Do we really need this!!!) +- */ +- +-static int sep_get_time_handler(struct sep_device *sep, unsigned long arg) +-{ +- struct sep_driver_get_time_t command_args; +- +- mutex_lock(&sep_mutex); +- command_args.time_value = sep_set_time(sep); +- command_args.time_physical_address = (unsigned long)sep_time_address(sep); +- mutex_unlock(&sep_mutex); +- if (copy_to_user((void __user *)arg, +- &command_args, sizeof(struct sep_driver_get_time_t))) +- return -EFAULT; +- return 0; +- +-} +- +-/* +- This API handles the end transaction request +-*/ +-static int sep_end_transaction_handler(struct sep_device *sep, unsigned long arg) +-{ +- dbg("SEP Driver:--------> sep_end_transaction_handler start\n"); +- +-#if 0 /*!SEP_DRIVER_POLLING_MODE */ +- /* close IMR */ +- sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, 0x7FFF); +- +- /* release IRQ line */ +- free_irq(SEP_DIRVER_IRQ_NUM, sep); +- +- /* lock the sep mutex */ +- mutex_unlock(&sep_mutex); +-#endif +- +- dbg("SEP Driver:<-------- sep_end_transaction_handler end\n"); +- +- return 0; +-} +- +- +-/** +- * sep_set_flow_id_handler - handle flow setting +- * @sep: the SEP we are configuring +- * @flow_id: the flow we are setting +- * +- * This function handler the set flow id command +- */ +-static int sep_set_flow_id_handler(struct sep_device *sep, +- unsigned long flow_id) +-{ +- int error = 0; +- struct sep_flow_context_t *flow_data_ptr; +- +- /* find the flow data structure that was just used for creating new flow +- - its id should be default */ +- +- mutex_lock(&sep_mutex); +- flow_data_ptr = sep_find_flow_context(sep, SEP_TEMP_FLOW_ID); +- if (flow_data_ptr) +- flow_data_ptr->flow_id = flow_id; /* set flow id */ +- else +- error = -EINVAL; +- mutex_unlock(&sep_mutex); +- return error; +-} +- +-static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +-{ +- int error = 0; +- struct sep_device *sep = filp->private_data; +- +- dbg("------------>SEP Driver: ioctl start\n"); +- +- edbg("SEP Driver: cmd is %x\n", cmd); +- +- switch (cmd) { +- case SEP_IOCSENDSEPCOMMAND: +- /* send command to SEP */ +- sep_send_command_handler(sep); +- edbg("SEP Driver: after sep_send_command_handler\n"); +- break; +- case SEP_IOCSENDSEPRPLYCOMMAND: +- /* send reply command to SEP */ +- sep_send_reply_command_handler(sep); +- break; +- case SEP_IOCALLOCDATAPOLL: +- /* allocate data pool */ +- error = sep_allocate_data_pool_memory_handler(sep, arg); +- break; +- case SEP_IOCWRITEDATAPOLL: +- /* write data into memory pool */ +- error = sep_write_into_data_pool_handler(sep, arg); +- break; +- case SEP_IOCREADDATAPOLL: +- /* read data from data pool into application memory */ +- error = sep_read_from_data_pool_handler(sep, arg); +- break; +- case SEP_IOCCREATESYMDMATABLE: +- /* create dma table for synhronic operation */ +- error = sep_create_sync_dma_tables_handler(sep, arg); +- break; +- case SEP_IOCCREATEFLOWDMATABLE: +- /* create flow dma tables */ +- error = sep_create_flow_dma_tables_handler(sep, arg); +- break; +- case SEP_IOCFREEDMATABLEDATA: +- /* free the pages */ +- error = sep_free_dma_table_data_handler(sep); +- break; +- case SEP_IOCSETFLOWID: +- /* set flow id */ +- error = sep_set_flow_id_handler(sep, (unsigned long)arg); +- break; +- case SEP_IOCADDFLOWTABLE: +- /* add tables to the dynamic flow */ +- error = sep_add_flow_tables_handler(sep, arg); +- break; +- case SEP_IOCADDFLOWMESSAGE: +- /* add message of add tables to flow */ +- error = sep_add_flow_tables_message_handler(sep, arg); +- break; +- case SEP_IOCSEPSTART: +- /* start command to sep */ +- error = sep_start_handler(sep); +- break; +- case SEP_IOCSEPINIT: +- /* init command to sep */ +- error = sep_init_handler(sep, arg); +- break; +- case SEP_IOCGETSTATICPOOLADDR: +- /* get the physical and virtual addresses of the static pool */ +- error = sep_get_static_pool_addr_handler(sep, arg); +- break; +- case SEP_IOCENDTRANSACTION: +- error = sep_end_transaction_handler(sep, arg); +- break; +- case SEP_IOCREALLOCCACHERES: +- error = sep_realloc_cache_resident_handler(sep, arg); +- break; +- case SEP_IOCGETMAPPEDADDROFFSET: +- error = sep_get_physical_mapped_offset_handler(sep, arg); +- break; +- case SEP_IOCGETIME: +- error = sep_get_time_handler(sep, arg); +- break; +- default: +- error = -ENOTTY; +- break; +- } +- dbg("SEP Driver:<-------- ioctl end\n"); +- return error; +-} +- +- +- +-#if !SEP_DRIVER_POLLING_MODE +- +-/* handler for flow done interrupt */ +- +-static void sep_flow_done_handler(struct work_struct *work) +-{ +- struct sep_flow_context_t *flow_data_ptr; +- +- /* obtain the mutex */ +- mutex_lock(&sep_mutex); +- +- /* get the pointer to context */ +- flow_data_ptr = (struct sep_flow_context_t *) work; +- +- /* free all the current input tables in sep */ +- sep_deallocated_flow_tables(&flow_data_ptr->input_tables_in_process); +- +- /* free all the current tables output tables in SEP (if needed) */ +- if (flow_data_ptr->output_tables_in_process.physical_address != 0xffffffff) +- sep_deallocated_flow_tables(&flow_data_ptr->output_tables_in_process); +- +- /* check if we have additional tables to be sent to SEP only input +- flag may be checked */ +- if (flow_data_ptr->input_tables_flag) { +- /* copy the message to the shared RAM and signal SEP */ +- memcpy((void *) flow_data_ptr->message, (void *) sep->shared_addr, flow_data_ptr->message_size_in_bytes); +- +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR, 0x2); +- } +- mutex_unlock(&sep_mutex); +-} +-/* +- interrupt handler function +-*/ +-static irqreturn_t sep_inthandler(int irq, void *dev_id) +-{ +- irqreturn_t int_error; +- unsigned long reg_val; +- unsigned long flow_id; +- struct sep_flow_context_t *flow_context_ptr; +- struct sep_device *sep = dev_id; +- +- int_error = IRQ_HANDLED; +- +- /* read the IRR register to check if this is SEP interrupt */ +- reg_val = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR); +- edbg("SEP Interrupt - reg is %08lx\n", reg_val); +- +- /* check if this is the flow interrupt */ +- if (0 /*reg_val & (0x1 << 11) */ ) { +- /* read GPRO to find out the which flow is done */ +- flow_id = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR); +- +- /* find the contex of the flow */ +- flow_context_ptr = sep_find_flow_context(sep, flow_id >> 28); +- if (flow_context_ptr == NULL) +- goto end_function_with_error; +- +- /* queue the work */ +- INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler); +- queue_work(sep->flow_wq, &flow_context_ptr->flow_wq); +- +- } else { +- /* check if this is reply interrupt from SEP */ +- if (reg_val & (0x1 << 13)) { +- /* update the counter of reply messages */ +- sep->reply_ct++; +- /* wake up the waiting process */ +- wake_up(&sep_event); +- } else { +- int_error = IRQ_NONE; +- goto end_function; +- } +- } +-end_function_with_error: +- /* clear the interrupt */ +- sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, reg_val); +-end_function: +- return int_error; +-} +- +-#endif +- +- +- +-#if 0 +- +-static void sep_wait_busy(struct sep_device *sep) +-{ +- u32 reg; +- +- do { +- reg = sep_read_reg(sep, HW_HOST_SEP_BUSY_REG_ADDR); +- } while (reg); +-} +- +-/* +- PATCH for configuring the DMA to single burst instead of multi-burst +-*/ +-static void sep_configure_dma_burst(struct sep_device *sep) +-{ +-#define HW_AHB_RD_WR_BURSTS_REG_ADDR 0x0E10UL +- +- dbg("SEP Driver:<-------- sep_configure_dma_burst start \n"); +- +- /* request access to registers from SEP */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); +- +- dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n"); +- +- sep_wait_busy(sep); +- +- dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n"); +- +- /* set the DMA burst register to single burst */ +- sep_write_reg(sep, HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL); +- +- /* release the sep busy */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL); +- sep_wait_busy(sep); +- +- dbg("SEP Driver:<-------- sep_configure_dma_burst done \n"); +- +-} +- +-#endif +- +-/* +- Function that is activated on the successful probe of the SEP device +-*/ +-static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent) +-{ +- int error = 0; +- struct sep_device *sep; +- int counter; +- int size; /* size of memory for allocation */ +- +- edbg("Sep pci probe starting\n"); +- if (sep_dev != NULL) { +- dev_warn(&pdev->dev, "only one SEP supported.\n"); +- return -EBUSY; +- } +- +- /* enable the device */ +- error = pci_enable_device(pdev); +- if (error) { +- edbg("error enabling pci device\n"); +- goto end_function; +- } +- +- /* set the pci dev pointer */ +- sep_dev = &sep_instance; +- sep = &sep_instance; +- +- edbg("sep->shared_addr = %p\n", sep->shared_addr); +- /* transaction counter that coordinates the transactions between SEP +- and HOST */ +- sep->send_ct = 0; +- /* counter for the messages from sep */ +- sep->reply_ct = 0; +- /* counter for the number of bytes allocated in the pool +- for the current transaction */ +- sep->data_pool_bytes_allocated = 0; +- +- /* calculate the total size for allocation */ +- size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + +- SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; +- +- /* allocate the shared area */ +- if (sep_map_and_alloc_shared_area(sep, size)) { +- error = -ENOMEM; +- /* allocation failed */ +- goto end_function_error; +- } +- /* now set the memory regions */ +-#if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1) +- /* Note: this test section will need moving before it could ever +- work as the registers are not yet mapped ! */ +- /* send the new SHARED MESSAGE AREA to the SEP */ +- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep->shared_bus); +- +- /* poll for SEP response */ +- retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR); +- while (retval != 0xffffffff && retval != sep->shared_bus) +- retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR); +- +- /* check the return value (register) */ +- if (retval != sep->shared_bus) { +- error = -ENOMEM; +- goto end_function_deallocate_sep_shared_area; +- } +-#endif +- /* init the flow contextes */ +- for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++) +- sep->flows[counter].flow_id = SEP_FREE_FLOW_ID; +- +- sep->flow_wq = create_singlethread_workqueue("sepflowwq"); +- if (sep->flow_wq == NULL) { +- error = -ENOMEM; +- edbg("sep_driver:flow queue creation failed\n"); +- goto end_function_deallocate_sep_shared_area; +- } +- edbg("SEP Driver: create flow workqueue \n"); +- sep->pdev = pci_dev_get(pdev); +- +- sep->reg_addr = pci_ioremap_bar(pdev, 0); +- if (!sep->reg_addr) { +- edbg("sep: ioremap of registers failed.\n"); +- goto end_function_deallocate_sep_shared_area; +- } +- edbg("SEP Driver:reg_addr is %p\n", sep->reg_addr); +- +- /* load the rom code */ +- sep_load_rom_code(sep); +- +- /* set up system base address and shared memory location */ +- sep->rar_addr = dma_alloc_coherent(&sep->pdev->dev, +- 2 * SEP_RAR_IO_MEM_REGION_SIZE, +- &sep->rar_bus, GFP_KERNEL); +- +- if (!sep->rar_addr) { +- edbg("SEP Driver:can't allocate rar\n"); +- goto end_function_uniomap; +- } +- +- +- edbg("SEP Driver:rar_bus is %08llx\n", (unsigned long long)sep->rar_bus); +- edbg("SEP Driver:rar_virtual is %p\n", sep->rar_addr); +- +-#if !SEP_DRIVER_POLLING_MODE +- +- edbg("SEP Driver: about to write IMR and ICR REG_ADDR\n"); +- +- /* clear ICR register */ +- sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF); +- +- /* set the IMR register - open only GPR 2 */ +- sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); +- +- edbg("SEP Driver: about to call request_irq\n"); +- /* get the interrupt line */ +- error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED, "sep_driver", sep); +- if (error) +- goto end_function_free_res; +- return 0; +- edbg("SEP Driver: about to write IMR REG_ADDR"); +- +- /* set the IMR register - open only GPR 2 */ +- sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); +- +-end_function_free_res: +- dma_free_coherent(&sep->pdev->dev, 2 * SEP_RAR_IO_MEM_REGION_SIZE, +- sep->rar_addr, sep->rar_bus); +-#endif /* SEP_DRIVER_POLLING_MODE */ +-end_function_uniomap: +- iounmap(sep->reg_addr); +-end_function_deallocate_sep_shared_area: +- /* de-allocate shared area */ +- sep_unmap_and_free_shared_area(sep, size); +-end_function_error: +- sep_dev = NULL; +-end_function: +- return error; +-} +- +-static const struct pci_device_id sep_pci_id_tbl[] = { +- {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c)}, +- {0} +-}; +- +-MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl); +- +-/* field for registering driver to PCI device */ +-static struct pci_driver sep_pci_driver = { +- .name = "sep_sec_driver", +- .id_table = sep_pci_id_tbl, +- .probe = sep_probe +- /* FIXME: remove handler */ +-}; +- +-/* major and minor device numbers */ +-static dev_t sep_devno; +- +-/* the files operations structure of the driver */ +-static struct file_operations sep_file_operations = { +- .owner = THIS_MODULE, +- .unlocked_ioctl = sep_ioctl, +- .poll = sep_poll, +- .open = sep_open, +- .release = sep_release, +- .mmap = sep_mmap, +-}; +- +- +-/* cdev struct of the driver */ +-static struct cdev sep_cdev; +- +-/* +- this function registers the driver to the file system +-*/ +-static int sep_register_driver_to_fs(void) +-{ +- int ret_val = alloc_chrdev_region(&sep_devno, 0, 1, "sep_sec_driver"); +- if (ret_val) { +- edbg("sep: major number allocation failed, retval is %d\n", +- ret_val); +- return ret_val; +- } +- /* init cdev */ +- cdev_init(&sep_cdev, &sep_file_operations); +- sep_cdev.owner = THIS_MODULE; +- +- /* register the driver with the kernel */ +- ret_val = cdev_add(&sep_cdev, sep_devno, 1); +- if (ret_val) { +- edbg("sep_driver:cdev_add failed, retval is %d\n", ret_val); +- /* unregister dev numbers */ +- unregister_chrdev_region(sep_devno, 1); +- } +- return ret_val; +-} +- +- +-/*-------------------------------------------------------------- +- init function +-----------------------------------------------------------------*/ +-static int __init sep_init(void) +-{ +- int ret_val = 0; +- dbg("SEP Driver:-------->Init start\n"); +- /* FIXME: Probe can occur before we are ready to survive a probe */ +- ret_val = pci_register_driver(&sep_pci_driver); +- if (ret_val) { +- edbg("sep_driver:sep_driver_to_device failed, ret_val is %d\n", ret_val); +- goto end_function_unregister_from_fs; +- } +- /* register driver to fs */ +- ret_val = sep_register_driver_to_fs(); +- if (ret_val) +- goto end_function_unregister_pci; +- goto end_function; +-end_function_unregister_pci: +- pci_unregister_driver(&sep_pci_driver); +-end_function_unregister_from_fs: +- /* unregister from fs */ +- cdev_del(&sep_cdev); +- /* unregister dev numbers */ +- unregister_chrdev_region(sep_devno, 1); +-end_function: +- dbg("SEP Driver:<-------- Init end\n"); +- return ret_val; +-} +- +- +-/*------------------------------------------------------------- +- exit function +---------------------------------------------------------------*/ +-static void __exit sep_exit(void) +-{ +- int size; +- +- dbg("SEP Driver:--------> Exit start\n"); +- +- /* unregister from fs */ +- cdev_del(&sep_cdev); +- /* unregister dev numbers */ +- unregister_chrdev_region(sep_devno, 1); +- /* calculate the total size for de-allocation */ +- size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + +- SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; +- /* FIXME: We need to do this in the unload for the device */ +- /* free shared area */ +- if (sep_dev) { +- sep_unmap_and_free_shared_area(sep_dev, size); +- edbg("SEP Driver: free pages SEP SHARED AREA \n"); +- iounmap((void *) sep_dev->reg_addr); +- edbg("SEP Driver: iounmap \n"); +- } +- edbg("SEP Driver: release_mem_region \n"); +- dbg("SEP Driver:<-------- Exit end\n"); +-} +- +- +-module_init(sep_init); +-module_exit(sep_exit); +- +-MODULE_LICENSE("GPL"); +--- a/drivers/staging/sep/sep_driver_api.h ++++ /dev/null +@@ -1,425 +0,0 @@ +-/* +- * +- * sep_driver_api.h - Security Processor Driver api definitions +- * +- * Copyright(c) 2009 Intel Corporation. All rights reserved. +- * Copyright(c) 2009 Discretix. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License as published by the Free +- * Software Foundation; either version 2 of the License, or (at your option) +- * any later version. +- * +- * This program is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +- * more details. +- * +- * You should have received a copy of the GNU General Public License along with +- * this program; if not, write to the Free Software Foundation, Inc., 59 +- * Temple Place - Suite 330, Boston, MA 02111-1307, USA. +- * +- * CONTACTS: +- * +- * Mark Allyn mark.a.allyn@intel.com +- * +- * CHANGES: +- * +- * 2009.06.26 Initial publish +- * +- */ +- +-#ifndef __SEP_DRIVER_API_H__ +-#define __SEP_DRIVER_API_H__ +- +- +- +-/*---------------------------------------------------------------- +- IOCTL command defines +- -----------------------------------------------------------------*/ +- +-/* magic number 1 of the sep IOCTL command */ +-#define SEP_IOC_MAGIC_NUMBER 's' +- +-/* sends interrupt to sep that message is ready */ +-#define SEP_IOCSENDSEPCOMMAND _IO(SEP_IOC_MAGIC_NUMBER , 0) +- +-/* sends interrupt to sep that message is ready */ +-#define SEP_IOCSENDSEPRPLYCOMMAND _IO(SEP_IOC_MAGIC_NUMBER , 1) +- +-/* allocate memory in data pool */ +-#define SEP_IOCALLOCDATAPOLL _IO(SEP_IOC_MAGIC_NUMBER , 2) +- +-/* write to pre-allocated memory in data pool */ +-#define SEP_IOCWRITEDATAPOLL _IO(SEP_IOC_MAGIC_NUMBER , 3) +- +-/* read from pre-allocated memory in data pool */ +-#define SEP_IOCREADDATAPOLL _IO(SEP_IOC_MAGIC_NUMBER , 4) +- +-/* create sym dma lli tables */ +-#define SEP_IOCCREATESYMDMATABLE _IO(SEP_IOC_MAGIC_NUMBER , 5) +- +-/* create flow dma lli tables */ +-#define SEP_IOCCREATEFLOWDMATABLE _IO(SEP_IOC_MAGIC_NUMBER , 6) +- +-/* free dynamic data aalocated during table creation */ +-#define SEP_IOCFREEDMATABLEDATA _IO(SEP_IOC_MAGIC_NUMBER , 7) +- +-/* get the static pool area addresses (physical and virtual) */ +-#define SEP_IOCGETSTATICPOOLADDR _IO(SEP_IOC_MAGIC_NUMBER , 8) +- +-/* set flow id command */ +-#define SEP_IOCSETFLOWID _IO(SEP_IOC_MAGIC_NUMBER , 9) +- +-/* add tables to the dynamic flow */ +-#define SEP_IOCADDFLOWTABLE _IO(SEP_IOC_MAGIC_NUMBER , 10) +- +-/* add flow add tables message */ +-#define SEP_IOCADDFLOWMESSAGE _IO(SEP_IOC_MAGIC_NUMBER , 11) +- +-/* start sep command */ +-#define SEP_IOCSEPSTART _IO(SEP_IOC_MAGIC_NUMBER , 12) +- +-/* init sep command */ +-#define SEP_IOCSEPINIT _IO(SEP_IOC_MAGIC_NUMBER , 13) +- +-/* end transaction command */ +-#define SEP_IOCENDTRANSACTION _IO(SEP_IOC_MAGIC_NUMBER , 15) +- +-/* reallocate cache and resident */ +-#define SEP_IOCREALLOCCACHERES _IO(SEP_IOC_MAGIC_NUMBER , 16) +- +-/* get the offset of the address starting from the beginnnig of the map area */ +-#define SEP_IOCGETMAPPEDADDROFFSET _IO(SEP_IOC_MAGIC_NUMBER , 17) +- +-/* get time address and value */ +-#define SEP_IOCGETIME _IO(SEP_IOC_MAGIC_NUMBER , 19) +- +-/*------------------------------------------- +- TYPEDEFS +-----------------------------------------------*/ +- +-/* +- init command struct +-*/ +-struct sep_driver_init_t { +- /* start of the 1G of the host memory address that SEP can access */ +- unsigned long message_addr; +- +- /* start address of resident */ +- unsigned long message_size_in_words; +- +-}; +- +- +-/* +- realloc cache resident command +-*/ +-struct sep_driver_realloc_cache_resident_t { +- /* new cache address */ +- u64 new_cache_addr; +- /* new resident address */ +- u64 new_resident_addr; +- /* new resident address */ +- u64 new_shared_area_addr; +- /* new base address */ +- u64 new_base_addr; +-}; +- +-struct sep_driver_alloc_t { +- /* virtual address of allocated space */ +- unsigned long offset; +- +- /* physical address of allocated space */ +- unsigned long phys_address; +- +- /* number of bytes to allocate */ +- unsigned long num_bytes; +-}; +- +-/* +- */ +-struct sep_driver_write_t { +- /* application space address */ +- unsigned long app_address; +- +- /* address of the data pool */ +- unsigned long datapool_address; +- +- /* number of bytes to write */ +- unsigned long num_bytes; +-}; +- +-/* +- */ +-struct sep_driver_read_t { +- /* application space address */ +- unsigned long app_address; +- +- /* address of the data pool */ +- unsigned long datapool_address; +- +- /* number of bytes to read */ +- unsigned long num_bytes; +-}; +- +-/* +-*/ +-struct sep_driver_build_sync_table_t { +- /* address value of the data in */ +- unsigned long app_in_address; +- +- /* size of data in */ +- unsigned long data_in_size; +- +- /* address of the data out */ +- unsigned long app_out_address; +- +- /* the size of the block of the operation - if needed, +- every table will be modulo this parameter */ +- unsigned long block_size; +- +- /* the physical address of the first input DMA table */ +- unsigned long in_table_address; +- +- /* number of entries in the first input DMA table */ +- unsigned long in_table_num_entries; +- +- /* the physical address of the first output DMA table */ +- unsigned long out_table_address; +- +- /* number of entries in the first output DMA table */ +- unsigned long out_table_num_entries; +- +- /* data in the first input table */ +- unsigned long table_data_size; +- +- /* distinct user/kernel layout */ +- bool isKernelVirtualAddress; +- +-}; +- +-/* +-*/ +-struct sep_driver_build_flow_table_t { +- /* flow type */ +- unsigned long flow_type; +- +- /* flag for input output */ +- unsigned long input_output_flag; +- +- /* address value of the data in */ +- unsigned long virt_buff_data_addr; +- +- /* size of data in */ +- unsigned long num_virtual_buffers; +- +- /* the physical address of the first input DMA table */ +- unsigned long first_table_addr; +- +- /* number of entries in the first input DMA table */ +- unsigned long first_table_num_entries; +- +- /* data in the first input table */ +- unsigned long first_table_data_size; +- +- /* distinct user/kernel layout */ +- bool isKernelVirtualAddress; +-}; +- +- +-struct sep_driver_add_flow_table_t { +- /* flow id */ +- unsigned long flow_id; +- +- /* flag for input output */ +- unsigned long inputOutputFlag; +- +- /* address value of the data in */ +- unsigned long virt_buff_data_addr; +- +- /* size of data in */ +- unsigned long num_virtual_buffers; +- +- /* address of the first table */ +- unsigned long first_table_addr; +- +- /* number of entries in the first table */ +- unsigned long first_table_num_entries; +- +- /* data size of the first table */ +- unsigned long first_table_data_size; +- +- /* distinct user/kernel layout */ +- bool isKernelVirtualAddress; +- +-}; +- +-/* +- command struct for set flow id +-*/ +-struct sep_driver_set_flow_id_t { +- /* flow id to set */ +- unsigned long flow_id; +-}; +- +- +-/* command struct for add tables message */ +-struct sep_driver_add_message_t { +- /* flow id to set */ +- unsigned long flow_id; +- +- /* message size in bytes */ +- unsigned long message_size_in_bytes; +- +- /* address of the message */ +- unsigned long message_address; +-}; +- +-/* command struct for static pool addresses */ +-struct sep_driver_static_pool_addr_t { +- /* physical address of the static pool */ +- unsigned long physical_static_address; +- +- /* virtual address of the static pool */ +- unsigned long virtual_static_address; +-}; +- +-/* command struct for getiing offset of the physical address from +- the start of the mapped area */ +-struct sep_driver_get_mapped_offset_t { +- /* physical address of the static pool */ +- unsigned long physical_address; +- +- /* virtual address of the static pool */ +- unsigned long offset; +-}; +- +-/* command struct for getting time value and address */ +-struct sep_driver_get_time_t { +- /* physical address of stored time */ +- unsigned long time_physical_address; +- +- /* value of the stored time */ +- unsigned long time_value; +-}; +- +- +-/* +- structure that represent one entry in the DMA LLI table +-*/ +-struct sep_lli_entry_t { +- /* physical address */ +- unsigned long physical_address; +- +- /* block size */ +- unsigned long block_size; +-}; +- +-/* +- structure that reperesents data needed for lli table construction +-*/ +-struct sep_lli_prepare_table_data_t { +- /* pointer to the memory where the first lli entry to be built */ +- struct sep_lli_entry_t *lli_entry_ptr; +- +- /* pointer to the array of lli entries from which the table is to be built */ +- struct sep_lli_entry_t *lli_array_ptr; +- +- /* number of elements in lli array */ +- int lli_array_size; +- +- /* number of entries in the created table */ +- int num_table_entries; +- +- /* number of array entries processed during table creation */ +- int num_array_entries_processed; +- +- /* the totatl data size in the created table */ +- int lli_table_total_data_size; +-}; +- +-/* +- structure that represent tone table - it is not used in code, jkust +- to show what table looks like +-*/ +-struct sep_lli_table_t { +- /* number of pages mapped in this tables. If 0 - means that the table +- is not defined (used as a valid flag) */ +- unsigned long num_pages; +- /* +- pointer to array of page pointers that represent the mapping of the +- virtual buffer defined by the table to the physical memory. If this +- pointer is NULL, it means that the table is not defined +- (used as a valid flag) +- */ +- struct page **table_page_array_ptr; +- +- /* maximum flow entries in table */ +- struct sep_lli_entry_t lli_entries[SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE]; +-}; +- +- +-/* +- structure for keeping the mapping of the virtual buffer into physical pages +-*/ +-struct sep_flow_buffer_data { +- /* pointer to the array of page structs pointers to the pages of the +- virtual buffer */ +- struct page **page_array_ptr; +- +- /* number of pages taken by the virtual buffer */ +- unsigned long num_pages; +- +- /* this flag signals if this page_array is the last one among many that were +- sent in one setting to SEP */ +- unsigned long last_page_array_flag; +-}; +- +-/* +- struct that keeps all the data for one flow +-*/ +-struct sep_flow_context_t { +- /* +- work struct for handling the flow done interrupt in the workqueue +- this structure must be in the first place, since it will be used +- forcasting to the containing flow context +- */ +- struct work_struct flow_wq; +- +- /* flow id */ +- unsigned long flow_id; +- +- /* additional input tables exists */ +- unsigned long input_tables_flag; +- +- /* additional output tables exists */ +- unsigned long output_tables_flag; +- +- /* data of the first input file */ +- struct sep_lli_entry_t first_input_table; +- +- /* data of the first output table */ +- struct sep_lli_entry_t first_output_table; +- +- /* last input table data */ +- struct sep_lli_entry_t last_input_table; +- +- /* last output table data */ +- struct sep_lli_entry_t last_output_table; +- +- /* first list of table */ +- struct sep_lli_entry_t input_tables_in_process; +- +- /* output table in process (in sep) */ +- struct sep_lli_entry_t output_tables_in_process; +- +- /* size of messages in bytes */ +- unsigned long message_size_in_bytes; +- +- /* message */ +- unsigned char message[SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES]; +-}; +- +- +-#endif +--- a/drivers/staging/sep/sep_driver_config.h ++++ /dev/null +@@ -1,225 +0,0 @@ +-/* +- * +- * sep_driver_config.h - Security Processor Driver configuration +- * +- * Copyright(c) 2009 Intel Corporation. All rights reserved. +- * Copyright(c) 2009 Discretix. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License as published by the Free +- * Software Foundation; either version 2 of the License, or (at your option) +- * any later version. +- * +- * This program is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +- * more details. +- * +- * You should have received a copy of the GNU General Public License along with +- * this program; if not, write to the Free Software Foundation, Inc., 59 +- * Temple Place - Suite 330, Boston, MA 02111-1307, USA. +- * +- * CONTACTS: +- * +- * Mark Allyn mark.a.allyn@intel.com +- * +- * CHANGES: +- * +- * 2009.06.26 Initial publish +- * +- */ +- +-#ifndef __SEP_DRIVER_CONFIG_H__ +-#define __SEP_DRIVER_CONFIG_H__ +- +- +-/*-------------------------------------- +- DRIVER CONFIGURATION FLAGS +- -------------------------------------*/ +- +-/* if flag is on , then the driver is running in polling and +- not interrupt mode */ +-#define SEP_DRIVER_POLLING_MODE 1 +- +-/* flag which defines if the shared area address should be +- reconfiged (send to SEP anew) during init of the driver */ +-#define SEP_DRIVER_RECONFIG_MESSAGE_AREA 0 +- +-/* the mode for running on the ARM1172 Evaluation platform (flag is 1) */ +-#define SEP_DRIVER_ARM_DEBUG_MODE 0 +- +-/*------------------------------------------- +- INTERNAL DATA CONFIGURATION +- -------------------------------------------*/ +- +-/* flag for the input array */ +-#define SEP_DRIVER_IN_FLAG 0 +- +-/* flag for output array */ +-#define SEP_DRIVER_OUT_FLAG 1 +- +-/* maximum number of entries in one LLI tables */ +-#define SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP 8 +- +- +-/*-------------------------------------------------------- +- SHARED AREA memory total size is 36K +- it is divided is following: +- +- SHARED_MESSAGE_AREA 8K } +- } +- STATIC_POOL_AREA 4K } MAPPED AREA ( 24 K) +- } +- DATA_POOL_AREA 12K } +- +- SYNCHRONIC_DMA_TABLES_AREA 5K +- +- FLOW_DMA_TABLES_AREA 4K +- +- SYSTEM_MEMORY_AREA 3k +- +- SYSTEM_MEMORY total size is 3k +- it is divided as following: +- +- TIME_MEMORY_AREA 8B +------------------------------------------------------------*/ +- +- +- +-/* +- the maximum length of the message - the rest of the message shared +- area will be dedicated to the dma lli tables +-*/ +-#define SEP_DRIVER_MAX_MESSAGE_SIZE_IN_BYTES (8 * 1024) +- +-/* the size of the message shared area in pages */ +-#define SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES (8 * 1024) +- +-/* the size of the data pool static area in pages */ +-#define SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES (4 * 1024) +- +-/* the size of the data pool shared area size in pages */ +-#define SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES (12 * 1024) +- +-/* the size of the message shared area in pages */ +-#define SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES (1024 * 5) +- +- +-/* the size of the data pool shared area size in pages */ +-#define SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES (1024 * 4) +- +-/* system data (time, caller id etc') pool */ +-#define SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES 100 +- +- +-/* area size that is mapped - we map the MESSAGE AREA, STATIC POOL and +- DATA POOL areas. area must be module 4k */ +-#define SEP_DRIVER_MMMAP_AREA_SIZE (1024 * 24) +- +- +-/*----------------------------------------------- +- offsets of the areas starting from the shared area start address +-*/ +- +-/* message area offset */ +-#define SEP_DRIVER_MESSAGE_AREA_OFFSET_IN_BYTES 0 +- +-/* static pool area offset */ +-#define SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES \ +- (SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES) +- +-/* data pool area offset */ +-#define SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES \ +- (SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES + \ +- SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES) +- +-/* synhronic dma tables area offset */ +-#define SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES \ +- (SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + \ +- SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) +- +-/* sep driver flow dma tables area offset */ +-#define SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES \ +- (SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES + \ +- SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES) +- +-/* system memory offset in bytes */ +-#define SEP_DRIVER_SYSTEM_DATA_MEMORY_OFFSET_IN_BYTES \ +- (SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES + \ +- SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES) +- +-/* offset of the time area */ +-#define SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES \ +- (SEP_DRIVER_SYSTEM_DATA_MEMORY_OFFSET_IN_BYTES) +- +- +- +-/* start physical address of the SEP registers memory in HOST */ +-#define SEP_IO_MEM_REGION_START_ADDRESS 0x80000000 +- +-/* size of the SEP registers memory region in HOST (for now 100 registers) */ +-#define SEP_IO_MEM_REGION_SIZE (2 * 0x100000) +- +-/* define the number of IRQ for SEP interrupts */ +-#define SEP_DIRVER_IRQ_NUM 1 +- +-/* maximum number of add buffers */ +-#define SEP_MAX_NUM_ADD_BUFFERS 100 +- +-/* number of flows */ +-#define SEP_DRIVER_NUM_FLOWS 4 +- +-/* maximum number of entries in flow table */ +-#define SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE 25 +- +-/* offset of the num entries in the block length entry of the LLI */ +-#define SEP_NUM_ENTRIES_OFFSET_IN_BITS 24 +- +-/* offset of the interrupt flag in the block length entry of the LLI */ +-#define SEP_INT_FLAG_OFFSET_IN_BITS 31 +- +-/* mask for extracting data size from LLI */ +-#define SEP_TABLE_DATA_SIZE_MASK 0xFFFFFF +- +-/* mask for entries after being shifted left */ +-#define SEP_NUM_ENTRIES_MASK 0x7F +- +-/* default flow id */ +-#define SEP_FREE_FLOW_ID 0xFFFFFFFF +- +-/* temp flow id used during cretiong of new flow until receiving +- real flow id from sep */ +-#define SEP_TEMP_FLOW_ID (SEP_DRIVER_NUM_FLOWS + 1) +- +-/* maximum add buffers message length in bytes */ +-#define SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES (7 * 4) +- +-/* maximum number of concurrent virtual buffers */ +-#define SEP_MAX_VIRT_BUFFERS_CONCURRENT 100 +- +-/* the token that defines the start of time address */ +-#define SEP_TIME_VAL_TOKEN 0x12345678 +- +-/* DEBUG LEVEL MASKS */ +-#define SEP_DEBUG_LEVEL_BASIC 0x1 +- +-#define SEP_DEBUG_LEVEL_EXTENDED 0x4 +- +- +-/* Debug helpers */ +- +-#define dbg(fmt, args...) \ +-do {\ +- if (debug & SEP_DEBUG_LEVEL_BASIC) \ +- printk(KERN_DEBUG fmt, ##args); \ +-} while(0); +- +-#define edbg(fmt, args...) \ +-do { \ +- if (debug & SEP_DEBUG_LEVEL_EXTENDED) \ +- printk(KERN_DEBUG fmt, ##args); \ +-} while(0); +- +- +- +-#endif +--- a/drivers/staging/sep/sep_driver_hw_defs.h ++++ /dev/null +@@ -1,232 +0,0 @@ +-/* +- * +- * sep_driver_hw_defs.h - Security Processor Driver hardware definitions +- * +- * Copyright(c) 2009 Intel Corporation. All rights reserved. +- * Copyright(c) 2009 Discretix. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License as published by the Free +- * Software Foundation; either version 2 of the License, or (at your option) +- * any later version. +- * +- * This program is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +- * more details. +- * +- * You should have received a copy of the GNU General Public License along with +- * this program; if not, write to the Free Software Foundation, Inc., 59 +- * Temple Place - Suite 330, Boston, MA 02111-1307, USA. +- * +- * CONTACTS: +- * +- * Mark Allyn mark.a.allyn@intel.com +- * +- * CHANGES: +- * +- * 2009.06.26 Initial publish +- * +- */ +- +-#ifndef SEP_DRIVER_HW_DEFS__H +-#define SEP_DRIVER_HW_DEFS__H +- +-/*--------------------------------------------------------------------------*/ +-/* Abstract: HW Registers Defines. */ +-/* */ +-/* Note: This file was automatically created !!! */ +-/* DO NOT EDIT THIS FILE !!! */ +-/*--------------------------------------------------------------------------*/ +- +- +-/* cf registers */ +-#define HW_R0B_ADDR_0_REG_ADDR 0x0000UL +-#define HW_R0B_ADDR_1_REG_ADDR 0x0004UL +-#define HW_R0B_ADDR_2_REG_ADDR 0x0008UL +-#define HW_R0B_ADDR_3_REG_ADDR 0x000cUL +-#define HW_R0B_ADDR_4_REG_ADDR 0x0010UL +-#define HW_R0B_ADDR_5_REG_ADDR 0x0014UL +-#define HW_R0B_ADDR_6_REG_ADDR 0x0018UL +-#define HW_R0B_ADDR_7_REG_ADDR 0x001cUL +-#define HW_R0B_ADDR_8_REG_ADDR 0x0020UL +-#define HW_R2B_ADDR_0_REG_ADDR 0x0080UL +-#define HW_R2B_ADDR_1_REG_ADDR 0x0084UL +-#define HW_R2B_ADDR_2_REG_ADDR 0x0088UL +-#define HW_R2B_ADDR_3_REG_ADDR 0x008cUL +-#define HW_R2B_ADDR_4_REG_ADDR 0x0090UL +-#define HW_R2B_ADDR_5_REG_ADDR 0x0094UL +-#define HW_R2B_ADDR_6_REG_ADDR 0x0098UL +-#define HW_R2B_ADDR_7_REG_ADDR 0x009cUL +-#define HW_R2B_ADDR_8_REG_ADDR 0x00a0UL +-#define HW_R3B_REG_ADDR 0x00C0UL +-#define HW_R4B_REG_ADDR 0x0100UL +-#define HW_CSA_ADDR_0_REG_ADDR 0x0140UL +-#define HW_CSA_ADDR_1_REG_ADDR 0x0144UL +-#define HW_CSA_ADDR_2_REG_ADDR 0x0148UL +-#define HW_CSA_ADDR_3_REG_ADDR 0x014cUL +-#define HW_CSA_ADDR_4_REG_ADDR 0x0150UL +-#define HW_CSA_ADDR_5_REG_ADDR 0x0154UL +-#define HW_CSA_ADDR_6_REG_ADDR 0x0158UL +-#define HW_CSA_ADDR_7_REG_ADDR 0x015cUL +-#define HW_CSA_ADDR_8_REG_ADDR 0x0160UL +-#define HW_CSA_REG_ADDR 0x0140UL +-#define HW_SINB_REG_ADDR 0x0180UL +-#define HW_SOUTB_REG_ADDR 0x0184UL +-#define HW_PKI_CONTROL_REG_ADDR 0x01C0UL +-#define HW_PKI_STATUS_REG_ADDR 0x01C4UL +-#define HW_PKI_BUSY_REG_ADDR 0x01C8UL +-#define HW_PKI_A_1025_REG_ADDR 0x01CCUL +-#define HW_PKI_SDMA_CTL_REG_ADDR 0x01D0UL +-#define HW_PKI_SDMA_OFFSET_REG_ADDR 0x01D4UL +-#define HW_PKI_SDMA_POINTERS_REG_ADDR 0x01D8UL +-#define HW_PKI_SDMA_DLENG_REG_ADDR 0x01DCUL +-#define HW_PKI_SDMA_EXP_POINTERS_REG_ADDR 0x01E0UL +-#define HW_PKI_SDMA_RES_POINTERS_REG_ADDR 0x01E4UL +-#define HW_PKI_CLR_REG_ADDR 0x01E8UL +-#define HW_PKI_SDMA_BUSY_REG_ADDR 0x01E8UL +-#define HW_PKI_SDMA_FIRST_EXP_N_REG_ADDR 0x01ECUL +-#define HW_PKI_SDMA_MUL_BY1_REG_ADDR 0x01F0UL +-#define HW_PKI_SDMA_RMUL_SEL_REG_ADDR 0x01F4UL +-#define HW_DES_KEY_0_REG_ADDR 0x0208UL +-#define HW_DES_KEY_1_REG_ADDR 0x020CUL +-#define HW_DES_KEY_2_REG_ADDR 0x0210UL +-#define HW_DES_KEY_3_REG_ADDR 0x0214UL +-#define HW_DES_KEY_4_REG_ADDR 0x0218UL +-#define HW_DES_KEY_5_REG_ADDR 0x021CUL +-#define HW_DES_CONTROL_0_REG_ADDR 0x0220UL +-#define HW_DES_CONTROL_1_REG_ADDR 0x0224UL +-#define HW_DES_IV_0_REG_ADDR 0x0228UL +-#define HW_DES_IV_1_REG_ADDR 0x022CUL +-#define HW_AES_KEY_0_ADDR_0_REG_ADDR 0x0400UL +-#define HW_AES_KEY_0_ADDR_1_REG_ADDR 0x0404UL +-#define HW_AES_KEY_0_ADDR_2_REG_ADDR 0x0408UL +-#define HW_AES_KEY_0_ADDR_3_REG_ADDR 0x040cUL +-#define HW_AES_KEY_0_ADDR_4_REG_ADDR 0x0410UL +-#define HW_AES_KEY_0_ADDR_5_REG_ADDR 0x0414UL +-#define HW_AES_KEY_0_ADDR_6_REG_ADDR 0x0418UL +-#define HW_AES_KEY_0_ADDR_7_REG_ADDR 0x041cUL +-#define HW_AES_KEY_0_REG_ADDR 0x0400UL +-#define HW_AES_IV_0_ADDR_0_REG_ADDR 0x0440UL +-#define HW_AES_IV_0_ADDR_1_REG_ADDR 0x0444UL +-#define HW_AES_IV_0_ADDR_2_REG_ADDR 0x0448UL +-#define HW_AES_IV_0_ADDR_3_REG_ADDR 0x044cUL +-#define HW_AES_IV_0_REG_ADDR 0x0440UL +-#define HW_AES_CTR1_ADDR_0_REG_ADDR 0x0460UL +-#define HW_AES_CTR1_ADDR_1_REG_ADDR 0x0464UL +-#define HW_AES_CTR1_ADDR_2_REG_ADDR 0x0468UL +-#define HW_AES_CTR1_ADDR_3_REG_ADDR 0x046cUL +-#define HW_AES_CTR1_REG_ADDR 0x0460UL +-#define HW_AES_SK_REG_ADDR 0x0478UL +-#define HW_AES_MAC_OK_REG_ADDR 0x0480UL +-#define HW_AES_PREV_IV_0_ADDR_0_REG_ADDR 0x0490UL +-#define HW_AES_PREV_IV_0_ADDR_1_REG_ADDR 0x0494UL +-#define HW_AES_PREV_IV_0_ADDR_2_REG_ADDR 0x0498UL +-#define HW_AES_PREV_IV_0_ADDR_3_REG_ADDR 0x049cUL +-#define HW_AES_PREV_IV_0_REG_ADDR 0x0490UL +-#define HW_AES_CONTROL_REG_ADDR 0x04C0UL +-#define HW_HASH_H0_REG_ADDR 0x0640UL +-#define HW_HASH_H1_REG_ADDR 0x0644UL +-#define HW_HASH_H2_REG_ADDR 0x0648UL +-#define HW_HASH_H3_REG_ADDR 0x064CUL +-#define HW_HASH_H4_REG_ADDR 0x0650UL +-#define HW_HASH_H5_REG_ADDR 0x0654UL +-#define HW_HASH_H6_REG_ADDR 0x0658UL +-#define HW_HASH_H7_REG_ADDR 0x065CUL +-#define HW_HASH_H8_REG_ADDR 0x0660UL +-#define HW_HASH_H9_REG_ADDR 0x0664UL +-#define HW_HASH_H10_REG_ADDR 0x0668UL +-#define HW_HASH_H11_REG_ADDR 0x066CUL +-#define HW_HASH_H12_REG_ADDR 0x0670UL +-#define HW_HASH_H13_REG_ADDR 0x0674UL +-#define HW_HASH_H14_REG_ADDR 0x0678UL +-#define HW_HASH_H15_REG_ADDR 0x067CUL +-#define HW_HASH_CONTROL_REG_ADDR 0x07C0UL +-#define HW_HASH_PAD_EN_REG_ADDR 0x07C4UL +-#define HW_HASH_PAD_CFG_REG_ADDR 0x07C8UL +-#define HW_HASH_CUR_LEN_0_REG_ADDR 0x07CCUL +-#define HW_HASH_CUR_LEN_1_REG_ADDR 0x07D0UL +-#define HW_HASH_CUR_LEN_2_REG_ADDR 0x07D4UL +-#define HW_HASH_CUR_LEN_3_REG_ADDR 0x07D8UL +-#define HW_HASH_PARAM_REG_ADDR 0x07DCUL +-#define HW_HASH_INT_BUSY_REG_ADDR 0x07E0UL +-#define HW_HASH_SW_RESET_REG_ADDR 0x07E4UL +-#define HW_HASH_ENDIANESS_REG_ADDR 0x07E8UL +-#define HW_HASH_DATA_REG_ADDR 0x07ECUL +-#define HW_DRNG_CONTROL_REG_ADDR 0x0800UL +-#define HW_DRNG_VALID_REG_ADDR 0x0804UL +-#define HW_DRNG_DATA_REG_ADDR 0x0808UL +-#define HW_RND_SRC_EN_REG_ADDR 0x080CUL +-#define HW_AES_CLK_ENABLE_REG_ADDR 0x0810UL +-#define HW_DES_CLK_ENABLE_REG_ADDR 0x0814UL +-#define HW_HASH_CLK_ENABLE_REG_ADDR 0x0818UL +-#define HW_PKI_CLK_ENABLE_REG_ADDR 0x081CUL +-#define HW_CLK_STATUS_REG_ADDR 0x0824UL +-#define HW_CLK_ENABLE_REG_ADDR 0x0828UL +-#define HW_DRNG_SAMPLE_REG_ADDR 0x0850UL +-#define HW_RND_SRC_CTL_REG_ADDR 0x0858UL +-#define HW_CRYPTO_CTL_REG_ADDR 0x0900UL +-#define HW_CRYPTO_STATUS_REG_ADDR 0x090CUL +-#define HW_CRYPTO_BUSY_REG_ADDR 0x0910UL +-#define HW_AES_BUSY_REG_ADDR 0x0914UL +-#define HW_DES_BUSY_REG_ADDR 0x0918UL +-#define HW_HASH_BUSY_REG_ADDR 0x091CUL +-#define HW_CONTENT_REG_ADDR 0x0924UL +-#define HW_VERSION_REG_ADDR 0x0928UL +-#define HW_CONTEXT_ID_REG_ADDR 0x0930UL +-#define HW_DIN_BUFFER_REG_ADDR 0x0C00UL +-#define HW_DIN_MEM_DMA_BUSY_REG_ADDR 0x0c20UL +-#define HW_SRC_LLI_MEM_ADDR_REG_ADDR 0x0c24UL +-#define HW_SRC_LLI_WORD0_REG_ADDR 0x0C28UL +-#define HW_SRC_LLI_WORD1_REG_ADDR 0x0C2CUL +-#define HW_SRAM_SRC_ADDR_REG_ADDR 0x0c30UL +-#define HW_DIN_SRAM_BYTES_LEN_REG_ADDR 0x0c34UL +-#define HW_DIN_SRAM_DMA_BUSY_REG_ADDR 0x0C38UL +-#define HW_WRITE_ALIGN_REG_ADDR 0x0C3CUL +-#define HW_OLD_DATA_REG_ADDR 0x0C48UL +-#define HW_WRITE_ALIGN_LAST_REG_ADDR 0x0C4CUL +-#define HW_DOUT_BUFFER_REG_ADDR 0x0C00UL +-#define HW_DST_LLI_WORD0_REG_ADDR 0x0D28UL +-#define HW_DST_LLI_WORD1_REG_ADDR 0x0D2CUL +-#define HW_DST_LLI_MEM_ADDR_REG_ADDR 0x0D24UL +-#define HW_DOUT_MEM_DMA_BUSY_REG_ADDR 0x0D20UL +-#define HW_SRAM_DEST_ADDR_REG_ADDR 0x0D30UL +-#define HW_DOUT_SRAM_BYTES_LEN_REG_ADDR 0x0D34UL +-#define HW_DOUT_SRAM_DMA_BUSY_REG_ADDR 0x0D38UL +-#define HW_READ_ALIGN_REG_ADDR 0x0D3CUL +-#define HW_READ_LAST_DATA_REG_ADDR 0x0D44UL +-#define HW_RC4_THRU_CPU_REG_ADDR 0x0D4CUL +-#define HW_AHB_SINGLE_REG_ADDR 0x0E00UL +-#define HW_SRAM_DATA_REG_ADDR 0x0F00UL +-#define HW_SRAM_ADDR_REG_ADDR 0x0F04UL +-#define HW_SRAM_DATA_READY_REG_ADDR 0x0F08UL +-#define HW_HOST_IRR_REG_ADDR 0x0A00UL +-#define HW_HOST_IMR_REG_ADDR 0x0A04UL +-#define HW_HOST_ICR_REG_ADDR 0x0A08UL +-#define HW_HOST_SEP_SRAM_THRESHOLD_REG_ADDR 0x0A10UL +-#define HW_HOST_SEP_BUSY_REG_ADDR 0x0A14UL +-#define HW_HOST_SEP_LCS_REG_ADDR 0x0A18UL +-#define HW_HOST_CC_SW_RST_REG_ADDR 0x0A40UL +-#define HW_HOST_SEP_SW_RST_REG_ADDR 0x0A44UL +-#define HW_HOST_FLOW_DMA_SW_INT0_REG_ADDR 0x0A80UL +-#define HW_HOST_FLOW_DMA_SW_INT1_REG_ADDR 0x0A84UL +-#define HW_HOST_FLOW_DMA_SW_INT2_REG_ADDR 0x0A88UL +-#define HW_HOST_FLOW_DMA_SW_INT3_REG_ADDR 0x0A8cUL +-#define HW_HOST_FLOW_DMA_SW_INT4_REG_ADDR 0x0A90UL +-#define HW_HOST_FLOW_DMA_SW_INT5_REG_ADDR 0x0A94UL +-#define HW_HOST_FLOW_DMA_SW_INT6_REG_ADDR 0x0A98UL +-#define HW_HOST_FLOW_DMA_SW_INT7_REG_ADDR 0x0A9cUL +-#define HW_HOST_SEP_HOST_GPR0_REG_ADDR 0x0B00UL +-#define HW_HOST_SEP_HOST_GPR1_REG_ADDR 0x0B04UL +-#define HW_HOST_SEP_HOST_GPR2_REG_ADDR 0x0B08UL +-#define HW_HOST_SEP_HOST_GPR3_REG_ADDR 0x0B0CUL +-#define HW_HOST_HOST_SEP_GPR0_REG_ADDR 0x0B80UL +-#define HW_HOST_HOST_SEP_GPR1_REG_ADDR 0x0B84UL +-#define HW_HOST_HOST_SEP_GPR2_REG_ADDR 0x0B88UL +-#define HW_HOST_HOST_SEP_GPR3_REG_ADDR 0x0B8CUL +-#define HW_HOST_HOST_ENDIAN_REG_ADDR 0x0B90UL +-#define HW_HOST_HOST_COMM_CLK_EN_REG_ADDR 0x0B94UL +-#define HW_CLR_SRAM_BUSY_REG_REG_ADDR 0x0F0CUL +-#define HW_CC_SRAM_BASE_ADDRESS 0x5800UL +- +-#endif /* ifndef HW_DEFS */ |