redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

Staging: sep: Create a structure to hold all the current crap spewed about as globals

Browse source 
For now keep the field names matching the variable names

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Alan Cox 2009-08-06 20:45:07 +01:00 committed by Greg Kroah-Hartman
parent 6a10753989
commit f5e3980f9b
5 changed files with 338 additions and 284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

119
drivers/staging/sep/sep_dev.h Normal file
View file

@ -0,0 +1,119 @@
#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 *sep_pci_dev_ptr;
unsigned long io_memory_start_physical_address;
unsigned long io_memory_end_physical_address;
unsigned long io_memory_size;
void *io_memory_start_virtual_address;
/* restricted access region */
unsigned long rar_physical_address;
void *rar_virtual_address;
/* shared memory region */
unsigned long shared_physical_address;
void *shared_virtual_address;
/* firmware regions */
unsigned long cache_physical_address;
unsigned long cache_size;
void *cache_virtual_address;
unsigned long resident_physical_address;
unsigned long resident_size;
void *resident_virtual_address;
/* device interrupt (as retrieved from PCI) */
int sep_irq;
unsigned long rar_region_addr;
/* start address of the access to the SEP registers from driver */
unsigned long reg_base_address;
/* transaction counter that coordinates the transactions between SEP and HOST */
unsigned long host_to_sep_send_counter;
/* counter for the messages from sep */
unsigned long sep_to_host_reply_counter;
/* 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_data_array[SEP_DRIVER_NUM_FLOWS];
/* flag for API mode - 1 -is blocking, 0 is non-blocking */
unsigned long block_mode_flag;
/* pointer to the workqueue that handles the flow done interrupts */
struct workqueue_struct *flow_wq_ptr;
/* address of the shared memory allocated during init for SEP driver */
unsigned long shared_area_addr;
/* the physical address of the shared area */
unsigned long phys_shared_area_addr;
/* Message Shared Area start address - will be allocated during init */
unsigned long message_shared_area_addr;
};
extern struct sep_device *sep_dev;
extern inline void sep_write_reg(struct sep_device *dev, int reg, u32 value)
{
void __iomem *addr = dev->reg_base_address + reg;
writel(value, reg);
}
extern inline u32 sep_read_reg(struct sep_device *dev, int reg)
{
void __iomem *addr = dev->reg_base_address + reg;
return readl(reg);
}
#endif

2
drivers/staging/sep/sep_driver_config.h
View file

@ -297,7 +297,7 @@ do { \
do { \ do { \
unsigned long reg_val; \ unsigned long reg_val; \
do { \ do { \
SEP_READ_REGISTER(g_sep_reg_base_address + \ SEP_READ_REGISTER(sep_dev->reg_base_address + \
HW_SRAM_DATA_READY_REG_ADDR, (reg_val)); \ HW_SRAM_DATA_READY_REG_ADDR, (reg_val)); \
} while (!(reg_val & 0x1)); \ } while (!(reg_val & 0x1)); \
} while (0) } while (0)

2
drivers/staging/sep/sep_driver_ext_api.h
View file

@ -36,8 +36,6 @@
/* shared variables */ /* shared variables */
extern int sepDebug; extern int sepDebug;
extern unsigned long g_sep_reg_base_address;
/* /*
this function loads the ROM code in SEP (needed only in the debug mode on FPGA) this function loads the ROM code in SEP (needed only in the debug mode on FPGA)
*/ */

180
drivers/staging/sep/sep_ext_with_pci_driver.c
View file

@ -51,6 +51,7 @@
#include "sep_driver_config.h" #include "sep_driver_config.h"
#include "sep_driver_api.h" #include "sep_driver_api.h"
#include "sep_driver_ext_api.h" #include "sep_driver_ext_api.h"
#include "sep_dev.h"
#if SEP_DRIVER_ARM_DEBUG_MODE #if SEP_DRIVER_ARM_DEBUG_MODE
@ -91,32 +92,10 @@ static unsigned long CRYS_SEP_ROM[] = {
irqreturn_t sep_inthandler(int irq , void* dev_id); irqreturn_t sep_inthandler(int irq , void* dev_id);
/* Keep this a single static object for now to keep the conversion easy */
/* io memory (register area) */ static struct sep_device sep_instance;
static unsigned long io_memory_start_physical_address; struct sep_device *sep_dev = &sep_instance;
static unsigned long io_memory_end_physical_address;
static unsigned long io_memory_size;
void *io_memory_start_virtual_address;
/* restricted access region */
static unsigned long rar_physical_address;
static void *rar_virtual_address;
/* shared memory region */
static unsigned long shared_physical_address;
static void *shared_virtual_address;
/* firmware regions */
static unsigned long cache_physical_address;
static unsigned long cache_size;
static void *cache_virtual_address;
static unsigned long resident_physical_address;
static unsigned long resident_size;
static void *resident_virtual_address;
/* device interrupt (as retrieved from PCI) */
int sep_irq;
/* temporary */ /* temporary */
unsigned long jiffies_future; unsigned long jiffies_future;
@ -138,7 +117,6 @@ static struct pci_device_id sep_pci_id_tbl[] = {
MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl); MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
static unsigned long rar_region_addr;
/* field for registering driver to PCI device */ /* field for registering driver to PCI device */
@ -148,8 +126,6 @@ static struct pci_driver sep_pci_driver = {
.probe = sep_probe .probe = sep_probe
}; };
/* pointer to pci dev received during probe */
struct pci_dev *sep_pci_dev_ptr;
/* /*
This functions locks the area of the resisnd and cache sep code This functions locks the area of the resisnd and cache sep code
@ -193,18 +169,18 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr,
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:rar_virtual is %p\n", "SEP Driver:rar_virtual is %p\n",
rar_virtual_address); sep_dev->rar_virtual_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:rar_physical is %08lx\n", "SEP Driver:rar_physical is %08lx\n",
rar_physical_address); sep_dev->rar_physical_address);
rar_region_addr = (unsigned long)rar_virtual_address; sep_dev->rar_region_addr = (unsigned long)sep_dev->rar_virtual_address;
cache_physical_address = rar_physical_address; sep_dev->cache_physical_address = sep_dev->rar_physical_address;
cache_virtual_address = rar_virtual_address; sep_dev->cache_virtual_address = sep_dev->rar_virtual_address;
/* load cache */ /* load cache */
error = request_firmware(&fw, cache_name, &sep_pci_dev_ptr->dev); error = request_firmware(&fw, cache_name, &sep_dev->sep_pci_dev_ptr->dev);
if (error) { if (error) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:cant request cache fw\n"); "SEP Driver:cant request cache fw\n");
@ -218,19 +194,21 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr,
"SEP Driver:cache data size is %08Zx\n", "SEP Driver:cache data size is %08Zx\n",
fw->size); fw->size);
memcpy((void *)cache_virtual_address, (void *)fw->data, fw->size); memcpy((void *)sep_dev->cache_virtual_address, (void *)fw->data, fw->size);
cache_size = fw->size; sep_dev->cache_size = fw->size;
cache_addr = (unsigned long)cache_virtual_address; cache_addr = (unsigned long)sep_dev->cache_virtual_address;
release_firmware(fw); release_firmware(fw);
resident_physical_address = cache_physical_address+cache_size; sep_dev->resident_physical_address = sep_dev->cache_physical_address
resident_virtual_address = cache_virtual_address+cache_size; + sep_dev->cache_size;
sep_dev->resident_virtual_address = sep_dev->cache_virtual_address
+ sep_dev->cache_size;
/* load resident */ /* load resident */
error = request_firmware(&fw, res_name, &sep_pci_dev_ptr->dev); error = request_firmware(&fw, res_name, &sep_dev->sep_pci_dev_ptr->dev);
if (error) { if (error) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:cant request res fw\n"); "SEP Driver:cant request res fw\n");
@ -244,20 +222,20 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr,
"SEP Driver:res data size is %08Zx\n", "SEP Driver:res data size is %08Zx\n",
fw->size); fw->size);
memcpy((void *)resident_virtual_address, (void *)fw->data, fw->size); memcpy((void *)sep_dev->resident_virtual_address, (void *)fw->data, fw->size);
resident_size = fw->size; sep_dev->resident_size = fw->size;
release_firmware(fw); release_firmware(fw);
resident_addr = (unsigned long)resident_virtual_address; resident_addr = (unsigned long)sep_dev->resident_virtual_address;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:resident_addr (physical )is %08lx\n", "SEP Driver:resident_addr (physical )is %08lx\n",
resident_physical_address); sep_dev->resident_physical_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:cache_addr (physical) is %08lx\n", "SEP Driver:cache_addr (physical) is %08lx\n",
cache_physical_address); sep_dev->cache_physical_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:resident_addr (logical )is %08lx\n", "SEP Driver:resident_addr (logical )is %08lx\n",
@ -267,15 +245,15 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr,
cache_addr); cache_addr);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:resident_size is %08lx\n", resident_size); "SEP Driver:resident_size is %08lx\n", sep_dev->resident_size);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:cache_size is %08lx\n", cache_size); "SEP Driver:cache_size is %08lx\n", sep_dev->cache_size);
/* physical addresses */ /* physical addresses */
*dst_new_cache_addr_ptr = cache_physical_address; *dst_new_cache_addr_ptr = sep_dev->cache_physical_address;
*dst_new_resident_addr_ptr = resident_physical_address; *dst_new_resident_addr_ptr = sep_dev->resident_physical_address;
end_function: end_function:
@ -297,23 +275,24 @@ int sep_map_and_alloc_shared_area(unsigned long shared_area_size,
unsigned long *phys_shared_area_addr_ptr) unsigned long *phys_shared_area_addr_ptr)
{ {
// shared_virtual_address = ioremap_nocache(0xda00000,shared_area_size); // shared_virtual_address = ioremap_nocache(0xda00000,shared_area_size);
shared_virtual_address = kmalloc(shared_area_size, GFP_KERNEL); sep_dev->shared_virtual_address = kmalloc(shared_area_size, GFP_KERNEL);
if (!shared_virtual_address) { if (!sep_dev->shared_virtual_address) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"sep_driver:shared memory kmalloc failed\n"); "sep_driver:shared memory kmalloc failed\n");
return -1; return -1;
} }
shared_physical_address = __pa(shared_virtual_address); /* FIXME */
sep_dev->shared_physical_address = __pa(sep_dev->shared_virtual_address);
// shared_physical_address = 0xda00000; // shared_physical_address = 0xda00000;
*kernel_shared_area_addr_ptr = (unsigned long)shared_virtual_address; *kernel_shared_area_addr_ptr = (unsigned long)sep_dev->shared_virtual_address;
/* set the physical address of the shared area */ /* set the physical address of the shared area */
*phys_shared_area_addr_ptr = shared_physical_address; *phys_shared_area_addr_ptr = sep_dev->shared_physical_address;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:shared_virtual_address is %p\n", "SEP Driver:shared_virtual_address is %p\n",
shared_virtual_address); sep_dev->shared_virtual_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:shared_region_size is %08lx\n", "SEP Driver:shared_region_size is %08lx\n",
shared_area_size); shared_area_size);
@ -353,11 +332,11 @@ unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address)
virt_address); virt_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:sh virt to phys p %08lx\n", "SEP Driver:sh virt to phys p %08lx\n",
shared_physical_address sep_dev->shared_physical_address
+ (virt_address - (unsigned long)shared_virtual_address)); + (virt_address - (unsigned long)sep_dev->shared_virtual_address));
return (unsigned long)shared_physical_address + return (unsigned long)sep_dev->shared_physical_address +
(virt_address - (unsigned long)shared_virtual_address); (virt_address - (unsigned long)sep_dev->shared_virtual_address);
} }
/* /*
@ -368,8 +347,8 @@ unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address)
*/ */
unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address) unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address)
{ {
return (unsigned long)shared_virtual_address return (unsigned long)sep_dev->shared_virtual_address
+ (phys_address - shared_physical_address); + (phys_address - sep_dev->shared_physical_address);
} }
@ -399,43 +378,43 @@ static int __devinit sep_probe(struct pci_dev *pdev,
} }
/* set the pci dev pointer */ /* set the pci dev pointer */
sep_pci_dev_ptr = pdev; sep_dev->sep_pci_dev_ptr = pdev;
/* get the io memory start address */ /* get the io memory start address */
io_memory_start_physical_address = pci_resource_start(pdev, 0); sep_dev->io_memory_start_physical_address = pci_resource_start(pdev, 0);
if (!io_memory_start_physical_address) { if (!sep_dev->io_memory_start_physical_address) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver error pci resource start\n"); "SEP Driver error pci resource start\n");
goto end_function; goto end_function;
} }
/* get the io memory end address */ /* get the io memory end address */
io_memory_end_physical_address = pci_resource_end(pdev, 0); sep_dev->io_memory_end_physical_address = pci_resource_end(pdev, 0);
if (!io_memory_end_physical_address) { if (!sep_dev->io_memory_end_physical_address) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver error pci resource end\n"); "SEP Driver error pci resource end\n");
goto end_function; goto end_function;
} }
io_memory_size = io_memory_end_physical_address - sep_dev->io_memory_size = sep_dev->io_memory_end_physical_address -
io_memory_start_physical_address + 1; sep_dev->io_memory_start_physical_address + 1;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:io_memory_start_physical_address is %08lx\n", "SEP Driver:io_memory_start_physical_address is %08lx\n",
io_memory_start_physical_address); sep_dev->io_memory_start_physical_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:io_memory_end_phyaical_address is %08lx\n", "SEP Driver:io_memory_end_phyaical_address is %08lx\n",
io_memory_end_physical_address); sep_dev->io_memory_end_physical_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:io_memory_size is %08lx\n", "SEP Driver:io_memory_size is %08lx\n",
io_memory_size); sep_dev->io_memory_size);
io_memory_start_virtual_address = sep_dev->io_memory_start_virtual_address =
ioremap_nocache(io_memory_start_physical_address, ioremap_nocache(sep_dev->io_memory_start_physical_address,
io_memory_size); sep_dev->io_memory_size);
if (!io_memory_start_virtual_address) { if (!sep_dev->io_memory_start_virtual_address) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver error ioremap of io memory\n"); "SEP Driver error ioremap of io memory\n");
goto end_function; goto end_function;
@ -443,31 +422,31 @@ static int __devinit sep_probe(struct pci_dev *pdev,
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:io_memory_start_virtual_address is %p\n", "SEP Driver:io_memory_start_virtual_address is %p\n",
io_memory_start_virtual_address); sep_dev->io_memory_start_virtual_address);
g_sep_reg_base_address = (unsigned long)io_memory_start_virtual_address; sep_dev->reg_base_address = (unsigned long)sep_dev->io_memory_start_virtual_address;
/* set up system base address and shared memory location */ /* set up system base address and shared memory location */
rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE, sep_dev->rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE,
GFP_KERNEL); GFP_KERNEL);
if (!rar_virtual_address) { if (!sep_dev->rar_virtual_address) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:cant kmalloc rar\n"); "SEP Driver:cant kmalloc rar\n");
goto end_function; goto end_function;
} }
/* FIXME */
rar_physical_address = __pa(rar_virtual_address); sep_dev->rar_physical_address = __pa(sep_dev->rar_virtual_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:rar_physical is %08lx\n", "SEP Driver:rar_physical is %08lx\n",
rar_physical_address); sep_dev->rar_physical_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:rar_virtual is %p\n", "SEP Driver:rar_virtual is %p\n",
rar_virtual_address); sep_dev->rar_virtual_address);
#if !SEP_DRIVER_POLLING_MODE #if !SEP_DRIVER_POLLING_MODE
@ -476,15 +455,16 @@ static int __devinit sep_probe(struct pci_dev *pdev,
"SEP Driver: about to write IMR and ICR REG_ADDR\n"); "SEP Driver: about to write IMR and ICR REG_ADDR\n");
/* clear ICR register */ /* clear ICR register */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_ICR_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_ICR_REG_ADDR,
0xFFFFFFFF); 0xFFFFFFFF);
/* set the IMR register - open only GPR 2 */ /* set the IMR register - open only GPR 2 */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_IMR_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR,
(~(0x1 << 13))); (~(0x1 << 13)));
/* figure out our irq */ /* figure out our irq */
error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *)&sep_irq); /* FIXME: */
error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *)&sep_dev->sep_irq);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: my irq is %d\n", sep_irq); "SEP Driver: my irq is %d\n", sep_irq);
@ -493,7 +473,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
"SEP Driver: about to call request_irq\n"); "SEP Driver: about to call request_irq\n");
/* get the interrupt line */ /* get the interrupt line */
error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED, error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED,
"sep_driver", &g_sep_reg_base_address); "sep_driver", &sep_dev->reg_base_address);
if (error) if (error)
goto end_function; goto end_function;
@ -502,7 +482,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
"SEP Driver: about to write IMR REG_ADDR"); "SEP Driver: about to write IMR REG_ADDR");
/* set the IMR register - open only GPR 2 */ /* set the IMR register - open only GPR 2 */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_IMR_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR,
(~(0x1 << 13))); (~(0x1 << 13)));
#endif /* SEP_DRIVER_POLLING_MODE */ #endif /* SEP_DRIVER_POLLING_MODE */
@ -523,7 +503,7 @@ int sep_register_driver_to_device(void)
void sep_load_rom_code() void sep_load_rom_code(void)
{ {
#if SEP_DRIVER_ARM_DEBUG_MODE #if SEP_DRIVER_ARM_DEBUG_MODE
/* Index variables */ /* Index variables */
@ -541,19 +521,19 @@ void sep_load_rom_code()
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: k is %lu\n", k); "SEP Driver: k is %lu\n", k);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: g_sep_reg_base_address is %p\n", "SEP Driver: sep_dev->reg_base_address is %p\n",
g_sep_reg_base_address); sep_dev->reg_base_address);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", "SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n",
CRYS_SEP_ROM_start_address_offset); CRYS_SEP_ROM_start_address_offset);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
/* write bank */ /* write bank */
SEP_WRITE_REGISTER(g_sep_reg_base_address SEP_WRITE_REGISTER(sep_dev->reg_base_address
+ SEP_ROM_BANK_register_offset, i); + SEP_ROM_BANK_register_offset, i);
for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) { for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) {
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
CRYS_SEP_ROM_start_address_offset + 4*j, CRYS_SEP_ROM_start_address_offset + 4*j,
CRYS_SEP_ROM[i * 0x1000 + j]); CRYS_SEP_ROM[i * 0x1000 + j]);
@ -567,12 +547,12 @@ void sep_load_rom_code()
} }
/* reset the SEP*/ /* reset the SEP*/
SEP_WRITE_REGISTER(g_sep_reg_base_address SEP_WRITE_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_SW_RST_REG_ADDR, 0x1); + HW_HOST_SEP_SW_RST_REG_ADDR, 0x1);
/* poll for SEP ROM boot finish */ /* poll for SEP ROM boot finish */
do { do {
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR3_REG_ADDR, regVal); + HW_HOST_SEP_HOST_GPR3_REG_ADDR, regVal);
} while (!regVal); } while (!regVal);
@ -582,21 +562,21 @@ void sep_load_rom_code()
switch (regVal) { switch (regVal) {
case 0x1: case 0x1:
/* fatal error - read erro status from GPRO */ /* fatal error - read erro status from GPRO */
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR0_REG_ADDR, Error); + HW_HOST_SEP_HOST_GPR0_REG_ADDR, Error);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: ROM polling case 1\n"); "SEP Driver: ROM polling case 1\n");
break; break;
case 0x2: case 0x2:
/* Boot First Phase ended */ /* Boot First Phase ended */
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning); + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: ROM polling case 2\n"); "SEP Driver: ROM polling case 2\n");
break; break;
case 0x4: case 0x4:
/* Cold boot ended successfully */ /* Cold boot ended successfully */
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning); + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: ROM polling case 4\n"); "SEP Driver: ROM polling case 4\n");
@ -604,7 +584,7 @@ void sep_load_rom_code()
break; break;
case 0x8: case 0x8:
/* Warmboot ended successfully */ /* Warmboot ended successfully */
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning); + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: ROM polling case 8\n"); "SEP Driver: ROM polling case 8\n");
@ -612,7 +592,7 @@ void sep_load_rom_code()
break; break;
case 0x10: case 0x10:
/* ColdWarm boot ended successfully */ /* ColdWarm boot ended successfully */
SEP_READ_REGISTER(g_sep_reg_base_address SEP_READ_REGISTER(sep_dev->reg_base_address
+ HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning); + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: ROM polling case 16\n"); "SEP Driver: ROM polling case 16\n");

319
drivers/staging/sep/sep_main_mod.c
View file

@ -48,6 +48,7 @@
#include "sep_driver_config.h" #include "sep_driver_config.h"
#include "sep_driver_api.h" #include "sep_driver_api.h"
#include "sep_driver_ext_api.h" #include "sep_driver_ext_api.h"
#include "sep_dev.h"
/*---------------------------------------- /*----------------------------------------
DEFINES DEFINES
@ -70,15 +71,6 @@
INT_MODULE_PARM(sepDebug, 0x0); INT_MODULE_PARM(sepDebug, 0x0);
MODULE_PARM_DESC(sepDebug, "Flag to enable SEP debug messages"); MODULE_PARM_DESC(sepDebug, "Flag to enable SEP debug messages");
/* address of the shared memory allocated during init for SEP driver */
static unsigned long g_sep_shared_area_addr;
/* the physical address of the shared area */
static unsigned long g_sep_phys_shared_area_addr;
/* Message Shared Area start address - will be allocated during init */
static unsigned long g_message_shared_area_addr;
/* major and minor device numbers */ /* major and minor device numbers */
static dev_t g_sep_device_number; static dev_t g_sep_device_number;
@ -95,44 +87,9 @@ static DEFINE_MUTEX(sep_mutex);
/* wait queue head (event) of the driver */ /* wait queue head (event) of the driver */
DECLARE_WAIT_QUEUE_HEAD(g_sep_event); static DECLARE_WAIT_QUEUE_HEAD(g_sep_event);
/* start address of the access to the SEP registers from driver */
unsigned long g_sep_reg_base_address;
/* transaction counter that coordinates the transactions between SEP and HOST */
static unsigned long sep_host_to_sep_send_counter;
/* counter for the messages from sep */
static unsigned long sep_sep_to_host_reply_counter;
/* counter for the number of bytes allocated in the pool for the current
transaction */
static unsigned long sep_data_pool_bytes_allocated;
/* array of pointers to the pages that represent input data for the synchronic
DMA action */
struct page **sep_in_page_array;
/* array of pointers to the pages that represent out data for the synchronic
DMA action */
struct page **sep_out_page_array;
/* number of pages in the sep_in_page_array */
unsigned long sep_in_num_pages;
/* number of pages in the sep_out_page_array */
unsigned long sep_out_num_pages;
/* global data for every flow */
static struct sep_flow_context_t g_sep_flows_data_array[SEP_DRIVER_NUM_FLOWS];
/* flag for API mode - 1 -is blocking, 0 is non-blocking */
static unsigned long g_sep_block_mode_flag;
/* pointer to the workqueue that handles the flow done interrupts */
static struct workqueue_struct *g_sep_flow_wq_ptr;
/*------------------------------------------------ /*------------------------------------------------
PROTOTYPES PROTOTYPES
@ -391,7 +348,7 @@ void sep_unlock()
*/ */
void sep_map_shared_area(unsigned long *mappedAddr_ptr) void sep_map_shared_area(unsigned long *mappedAddr_ptr)
{ {
*mappedAddr_ptr = g_sep_shared_area_addr; *mappedAddr_ptr = sep_dev->shared_area_addr;
} }
/* /*
@ -416,16 +373,16 @@ void sep_driver_poll()
#ifdef SEP_DRIVER_POLLING_MODE #ifdef SEP_DRIVER_POLLING_MODE
while (sep_host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF))
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR2_REG_ADDR, HW_HOST_SEP_HOST_GPR2_REG_ADDR,
retVal); retVal);
sep_sep_to_host_reply_counter++; sep_dev->sep_to_host_reply_counter++;
#else #else
/* poll, until reply from sep */ /* poll, until reply from sep */
wait_event(g_sep_event, wait_event(g_sep_event,
(sep_host_to_sep_send_counter == sep_sep_to_host_reply_counter)); (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter));
#endif #endif
} }
@ -448,7 +405,7 @@ static int sep_open(struct inode *inode_ptr, struct file *file_ptr)
error = 0; error = 0;
/* check the blocking mode */ /* check the blocking mode */
if (g_sep_block_mode_flag) if (sep_dev->block_mode_flag)
/* lock mutex */ /* lock mutex */
mutex_lock(&sep_mutex); mutex_lock(&sep_mutex);
else else
@ -463,7 +420,7 @@ static int sep_open(struct inode *inode_ptr, struct file *file_ptr)
} }
/* release data pool allocations */ /* release data pool allocations */
sep_data_pool_bytes_allocated = 0; sep_dev->data_pool_bytes_allocated = 0;
end_function: end_function:
@ -489,10 +446,10 @@ static int sep_release(struct inode *inode_ptr, struct file *file_ptr)
#if 0/*!SEP_DRIVER_POLLING_MODE*/ #if 0/*!SEP_DRIVER_POLLING_MODE*/
/* close IMR */ /* close IMR */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_IMR_REG_ADDR, 0x7FFF); SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR, 0x7FFF);
/* release IRQ line */ /* release IRQ line */
free_irq(SEP_DIRVER_IRQ_NUM, &g_sep_reg_base_address); free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address);
#endif #endif
@ -538,10 +495,10 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:g_message_shared_area_addr is %08lx\n", "SEP Driver:g_message_shared_area_addr is %08lx\n",
g_message_shared_area_addr); sep_dev->message_shared_area_addr);
/* get physical address */ /* get physical address */
phys_addr = g_sep_phys_shared_area_addr; phys_addr = sep_dev->phys_shared_area_addr;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "SEP Driver: phys_addr is %08lx\n", DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "SEP Driver: phys_addr is %08lx\n",
phys_addr); phys_addr);
@ -584,8 +541,8 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
#if SEP_DRIVER_POLLING_MODE #if SEP_DRIVER_POLLING_MODE
while (sep_host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) { while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) {
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR2_REG_ADDR, HW_HOST_SEP_HOST_GPR2_REG_ADDR,
retVal); retVal);
@ -593,11 +550,11 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"Poll Debug Word %lu of the message is %lu\n", "Poll Debug Word %lu of the message is %lu\n",
count, count,
*((unsigned long *)(g_sep_shared_area_addr + *((unsigned long *)(sep_dev->shared_area_addr +
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count))); SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count)));
} }
sep_sep_to_host_reply_counter++; sep_dev->sep_to_host_reply_counter++;
#else #else
/* add the event to the polling wait table */ /* add the event to the polling wait table */
poll_wait(filp, &g_sep_event, wait); poll_wait(filp, &g_sep_event, wait);
@ -605,26 +562,26 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
#endif #endif
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"sep_host_to_sep_send_counter is %lu\n", "sep_dev->host_to_sep_send_counter is %lu\n",
sep_host_to_sep_send_counter); sep_dev->host_to_sep_send_counter);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"sep_sep_to_host_reply_counter is %lu\n", "sep_dev->sep_to_host_reply_counter is %lu\n",
sep_sep_to_host_reply_counter); sep_dev->sep_to_host_reply_counter);
/* check if the data is ready */ /* check if the data is ready */
if (sep_host_to_sep_send_counter == sep_sep_to_host_reply_counter) { if (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter) {
for (count = 0; count < 12 * 4; count += 4) for (count = 0; count < 12 * 4; count += 4)
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"Sep Mesg Word %lu of the message is %lu\n", "Sep Mesg Word %lu of the message is %lu\n",
count, *((unsigned long *)(g_sep_shared_area_addr + count))); count, *((unsigned long *)(sep_dev->shared_area_addr + count)));
for (count = 0; count < 10 * 4; count += 4) for (count = 0; count < 10 * 4; count += 4)
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"Debug Data Word %lu of the message is %lu\n", "Debug Data Word %lu of the message is %lu\n",
count, count,
*((unsigned long *)(g_sep_shared_area_addr + 0x1800 + count))); *((unsigned long *)(sep_dev->shared_area_addr + 0x1800 + count)));
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR2_REG_ADDR, HW_HOST_SEP_HOST_GPR2_REG_ADDR,
retVal); retVal);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "retVal is %lu\n", retVal); DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "retVal is %lu\n", retVal);
@ -900,23 +857,23 @@ static int __init sep_init(void)
"SEP Driver:-------->Init start\n"); "SEP Driver:-------->Init start\n");
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_BASIC,
"g_sep_shared_area_addr = %lx\n", "g_sep_shared_area_addr = %lx\n",
(unsigned long)&g_sep_shared_area_addr); (unsigned long)&sep_dev->shared_area_addr);
ret_val = 0; ret_val = 0;
/* transaction counter that coordinates the transactions between SEP /* transaction counter that coordinates the transactions between SEP
and HOST */ and HOST */
sep_host_to_sep_send_counter = 0; sep_dev->host_to_sep_send_counter = 0;
/* counter for the messages from sep */ /* counter for the messages from sep */
sep_sep_to_host_reply_counter = 0; sep_dev->sep_to_host_reply_counter = 0;
/* counter for the number of bytes allocated in the pool /* counter for the number of bytes allocated in the pool
for the current transaction */ for the current transaction */
sep_data_pool_bytes_allocated = 0; sep_dev->data_pool_bytes_allocated = 0;
/* set the starting mode to blocking */ /* set the starting mode to blocking */
g_sep_block_mode_flag = 1; sep_dev->block_mode_flag = 1;
ret_val = sep_register_driver_to_device(); ret_val = sep_register_driver_to_device();
@ -939,36 +896,36 @@ for the current transaction */
/* allocate the shared area */ /* allocate the shared area */
if (sep_map_and_alloc_shared_area(size, if (sep_map_and_alloc_shared_area(size,
&g_sep_shared_area_addr, &sep_dev->shared_area_addr,
&g_sep_phys_shared_area_addr)) { &sep_dev->phys_shared_area_addr)) {
ret_val = -ENOMEM; ret_val = -ENOMEM;
/* allocation failed */ /* allocation failed */
goto end_function_unmap_io_memory; goto end_function_unmap_io_memory;
} }
/* now set the memory regions */ /* now set the memory regions */
g_message_shared_area_addr = g_sep_shared_area_addr; sep_dev->message_shared_area_addr = sep_dev->shared_area_addr;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: g_message_shared_area_addr is %08lx\n", "SEP Driver: g_message_shared_area_addr is %08lx\n",
g_message_shared_area_addr); sep_dev->message_shared_area_addr);
#if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1) #if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1)
/* send the new SHARED MESSAGE AREA to the SEP */ /* send the new SHARED MESSAGE AREA to the SEP */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_HOST_SEP_GPR1_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_HOST_SEP_GPR1_REG_ADDR,
g_sep_phys_shared_area_addr); sep_dev->phys_shared_area_addr);
/* poll for SEP response */ /* poll for SEP response */
SEP_READ_REGISTER(g_sep_reg_base_address + HW_HOST_SEP_HOST_GPR1_REG_ADDR, SEP_READ_REGISTER(sep_dev->reg_base_address + HW_HOST_SEP_HOST_GPR1_REG_ADDR,
retVal); retVal);
while (retVal != 0xffffffff && retVal != g_sep_phys_shared_area_addr) while (retVal != 0xffffffff && retVal != sep_dev->phys_shared_area_addr)
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR1_REG_ADDR, HW_HOST_SEP_HOST_GPR1_REG_ADDR,
retVal); retVal);
/* check the return value (register) */ /* check the return value (register) */
if (retVal != g_sep_phys_shared_area_addr) { if (retVal != sep_dev->phys_shared_area_addr) {
ret_val = -ENOMEM; ret_val = -ENOMEM;
goto end_function_deallocate_message_area; goto end_function_deallocate_message_area;
} }
@ -977,10 +934,10 @@ for the current transaction */
/* init the flow contextes */ /* init the flow contextes */
for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++) for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++)
g_sep_flows_data_array[counter].flow_id = SEP_FREE_FLOW_ID; sep_dev->flows_data_array[counter].flow_id = SEP_FREE_FLOW_ID;
g_sep_flow_wq_ptr = create_singlethread_workqueue("sepflowwq"); sep_dev->flow_wq_ptr = create_singlethread_workqueue("sepflowwq");
if (g_sep_flow_wq_ptr == 0) { if (sep_dev->flow_wq_ptr == 0) {
ret_val = -ENOMEM; ret_val = -ENOMEM;
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"sep_driver:flow queue creation failed\n"); "sep_driver:flow queue creation failed\n");
@ -1009,12 +966,12 @@ end_function_deallocate_sep_shared_area:
/* de-allocate shared area */ /* de-allocate shared area */
sep_unmap_and_free_shared_area(size, sep_unmap_and_free_shared_area(size,
g_sep_shared_area_addr, sep_dev->shared_area_addr,
g_sep_phys_shared_area_addr); sep_dev->phys_shared_area_addr);
end_function_unmap_io_memory: end_function_unmap_io_memory:
iounmap((void *)g_sep_reg_base_address); iounmap((void *)sep_dev->reg_base_address);
/* release io memory region */ /* release io memory region */
release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE); release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE);
@ -1057,13 +1014,13 @@ static void __exit sep_exit(void)
/* free shared area */ /* free shared area */
sep_unmap_and_free_shared_area(size, sep_unmap_and_free_shared_area(size,
g_sep_shared_area_addr, sep_dev->shared_area_addr,
g_sep_phys_shared_area_addr); sep_dev->phys_shared_area_addr);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: free pages SEP SHARED AREA \n"); "SEP Driver: free pages SEP SHARED AREA \n");
iounmap((void *)g_sep_reg_base_address); iounmap((void *)sep_dev->reg_base_address);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, "SEP Driver: iounmap \n"); DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, "SEP Driver: iounmap \n");
@ -1103,14 +1060,14 @@ irqreturn_t sep_inthandler(int irq, void *dev_id)
int_error = IRQ_HANDLED; int_error = IRQ_HANDLED;
/* read the IRR register to check if this is SEP interrupt */ /* read the IRR register to check if this is SEP interrupt */
SEP_READ_REGISTER(g_sep_reg_base_address + HW_HOST_IRR_REG_ADDR, reg_val); SEP_READ_REGISTER(sep_dev->reg_base_address + HW_HOST_IRR_REG_ADDR, reg_val);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "SEP Interrupt - reg is %08lx\n", DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, "SEP Interrupt - reg is %08lx\n",
reg_val); reg_val);
/* check if this is the flow interrupt */ /* check if this is the flow interrupt */
if (0/*reg_val & (0x1 << 11)*/) { if (0/*reg_val & (0x1 << 11)*/) {
/* read GPRO to find out the which flow is done */ /* read GPRO to find out the which flow is done */
SEP_READ_REGISTER(g_sep_reg_base_address + HW_HOST_IRR_REG_ADDR, SEP_READ_REGISTER(sep_dev->reg_base_address + HW_HOST_IRR_REG_ADDR,
flow_id); flow_id);
/* find the contex of the flow */ /* find the contex of the flow */
@ -1121,13 +1078,13 @@ irqreturn_t sep_inthandler(int irq, void *dev_id)
INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler); INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler);
/* queue the work */ /* queue the work */
queue_work(g_sep_flow_wq_ptr, &flow_context_ptr->flow_wq); queue_work(sep_dev->flow_wq_ptr, &flow_context_ptr->flow_wq);
} else { } else {
/* check if this is reply interrupt from SEP */ /* check if this is reply interrupt from SEP */
if (reg_val & (0x1 << 13)) { if (reg_val & (0x1 << 13)) {
/* update the counter of reply messages */ /* update the counter of reply messages */
sep_sep_to_host_reply_counter++; sep_dev->sep_to_host_reply_counter++;
/* wake up the waiting process */ /* wake up the waiting process */
wake_up(&g_sep_event); wake_up(&g_sep_event);
@ -1140,7 +1097,7 @@ irqreturn_t sep_inthandler(int irq, void *dev_id)
end_function_with_error: end_function_with_error:
/* clear the interrupt */ /* clear the interrupt */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_ICR_REG_ADDR, reg_val); SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_ICR_REG_ADDR, reg_val);
end_function: end_function:
@ -1201,14 +1158,14 @@ int sep_prepare_input_dma_table(unsigned long app_virt_addr,
block_size); block_size);
/* initialize the pages pointers */ /* initialize the pages pointers */
sep_in_page_array = 0; sep_dev->in_page_array = 0;
sep_in_num_pages = 0; sep_dev->in_num_pages = 0;
if (data_size == 0) { if (data_size == 0) {
/* special case - created 2 entries table with zero data */ /* special case - created 2 entries table with zero data */
in_lli_table_ptr = (struct sep_lli_entry_t *)(g_sep_shared_area_addr + in_lli_table_ptr = (struct sep_lli_entry_t *)(sep_dev->shared_area_addr +
SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES); SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES);
in_lli_table_ptr->physical_address = g_sep_shared_area_addr + in_lli_table_ptr->physical_address = sep_dev->shared_area_addr +
SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
in_lli_table_ptr->block_size = 0; in_lli_table_ptr->block_size = 0;
@ -1216,7 +1173,7 @@ int sep_prepare_input_dma_table(unsigned long app_virt_addr,
in_lli_table_ptr->physical_address = 0xFFFFFFFF; in_lli_table_ptr->physical_address = 0xFFFFFFFF;
in_lli_table_ptr->block_size = 0; in_lli_table_ptr->block_size = 0;
*lli_table_ptr = g_sep_phys_shared_area_addr + *lli_table_ptr = sep_dev->phys_shared_area_addr +
SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
*num_entries_ptr = 2; *num_entries_ptr = 2;
*table_data_size_ptr = 0; *table_data_size_ptr = 0;
@ -1229,30 +1186,30 @@ int sep_prepare_input_dma_table(unsigned long app_virt_addr,
/* lock the pages of the kernel buffer and translate them to pages */ /* lock the pages of the kernel buffer and translate them to pages */
result = sep_lock_kernel_pages(app_virt_addr, result = sep_lock_kernel_pages(app_virt_addr,
data_size, data_size,
&sep_in_num_pages, &sep_dev->in_num_pages,
&lli_array_ptr, &lli_array_ptr,
&sep_in_page_array); &sep_dev->in_page_array);
else else
/* lock the pages of the user buffer and translate them to pages */ /* lock the pages of the user buffer and translate them to pages */
result = sep_lock_user_pages(app_virt_addr, result = sep_lock_user_pages(app_virt_addr,
data_size, data_size,
&sep_in_num_pages, &sep_dev->in_num_pages,
&lli_array_ptr, &lli_array_ptr,
&sep_in_page_array); &sep_dev->in_page_array);
if (result) if (result)
return result; return result;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:output sep_in_num_pages is %lu\n", "SEP Driver:output sep_dev->in_num_pages is %lu\n",
sep_in_num_pages); sep_dev->in_num_pages);
current_entry = 0; current_entry = 0;
info_entry_ptr = 0; info_entry_ptr = 0;
sep_lli_entries = sep_in_num_pages; sep_lli_entries = sep_dev->in_num_pages;
/* initiate to point after the message area */ /* initiate to point after the message area */
lli_table_alloc_addr = g_sep_shared_area_addr + lli_table_alloc_addr = sep_dev->shared_area_addr +
SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
/* loop till all the entries in in array are not processed */ /* loop till all the entries in in array are not processed */
@ -1359,17 +1316,17 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
result = 0; result = 0;
/* initialize the pages pointers */ /* initialize the pages pointers */
sep_in_page_array = 0; sep_dev->in_page_array = 0;
sep_out_page_array = 0; sep_dev->out_page_array = 0;
/* check if the pages are in Kernel Virtual Address layout */ /* check if the pages are in Kernel Virtual Address layout */
if (isKernelVirtualAddress == true) { if (isKernelVirtualAddress == true) {
/* lock the pages of the kernel buffer and translate them to pages */ /* lock the pages of the kernel buffer and translate them to pages */
result = sep_lock_kernel_pages(app_virt_in_addr, result = sep_lock_kernel_pages(app_virt_in_addr,
data_size, data_size,
&sep_in_num_pages, &sep_dev->in_num_pages,
&lli_in_array, &lli_in_array,
&sep_in_page_array); &sep_dev->in_page_array);
if (result) { if (result) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n"); "SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n");
@ -1379,9 +1336,9 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
/* lock the pages of the user buffer and translate them to pages */ /* lock the pages of the user buffer and translate them to pages */
result = sep_lock_user_pages(app_virt_in_addr, result = sep_lock_user_pages(app_virt_in_addr,
data_size, data_size,
&sep_in_num_pages, &sep_dev->in_num_pages,
&lli_in_array, &lli_in_array,
&sep_in_page_array); &sep_dev->in_page_array);
if (result) { if (result) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: sep_lock_user_pages for input virtual buffer failed\n"); "SEP Driver: sep_lock_user_pages for input virtual buffer failed\n");
@ -1392,9 +1349,9 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
if (isKernelVirtualAddress == true) { if (isKernelVirtualAddress == true) {
result = sep_lock_kernel_pages(app_virt_out_addr, result = sep_lock_kernel_pages(app_virt_out_addr,
data_size, data_size,
&sep_out_num_pages, &sep_dev->out_num_pages,
&lli_out_array, &lli_out_array,
&sep_out_page_array); &sep_dev->out_page_array);
if (result) { if (result) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n"); "SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n");
@ -1403,9 +1360,9 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
} else { } else {
result = sep_lock_user_pages(app_virt_out_addr, result = sep_lock_user_pages(app_virt_out_addr,
data_size, data_size,
&sep_out_num_pages, &sep_dev->out_num_pages,
&lli_out_array, &lli_out_array,
&sep_out_page_array); &sep_dev->out_page_array);
if (result) { if (result) {
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver: sep_lock_user_pages for output virtual buffer failed\n"); "SEP Driver: sep_lock_user_pages for output virtual buffer failed\n");
@ -1415,9 +1372,9 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"sep_in_num_pages is %lu\n", sep_in_num_pages); "sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"sep_out_num_pages is %lu\n", sep_out_num_pages); "sep_dev->out_num_pages is %lu\n", sep_dev->out_num_pages);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", "SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n",
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP); SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
@ -1425,9 +1382,9 @@ int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
/* call the fucntion that creates table from the lli arrays */ /* call the fucntion that creates table from the lli arrays */
result = sep_construct_dma_tables_from_lli(lli_in_array, result = sep_construct_dma_tables_from_lli(lli_in_array,
sep_in_num_pages, sep_dev->in_num_pages,
lli_out_array, lli_out_array,
sep_out_num_pages, sep_dev->out_num_pages,
block_size, block_size,
lli_table_in_ptr, lli_table_in_ptr,
lli_table_out_ptr, lli_table_out_ptr,
@ -1531,7 +1488,7 @@ int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array,
"SEP Driver:--------> sep_construct_dma_tables_from_lli start\n"); "SEP Driver:--------> sep_construct_dma_tables_from_lli start\n");
/* initiate to pint after the message area */ /* initiate to pint after the message area */
lli_table_alloc_addr = g_sep_shared_area_addr + lli_table_alloc_addr = sep_dev->shared_area_addr +
SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
current_in_entry = 0; current_in_entry = 0;
@ -2272,13 +2229,13 @@ static void sep_send_command_handler()
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"Word %lu of the message is %lu\n", "Word %lu of the message is %lu\n",
count, count,
*((unsigned long *)(g_sep_shared_area_addr + count))); *((unsigned long *)(sep_dev->shared_area_addr + count)));
/* update counter */ /* update counter */
sep_host_to_sep_send_counter++; sep_dev->host_to_sep_send_counter++;
/* send interrupt to SEP */ /* send interrupt to SEP */
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,
@ -2305,20 +2262,20 @@ static void sep_send_reply_command_handler()
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"Word %lu of the message is %lu\n", "Word %lu of the message is %lu\n",
count, count,
*((unsigned long *)(g_sep_shared_area_addr + count))); *((unsigned long *)(sep_dev->shared_area_addr + count)));
/* update counter */ /* update counter */
sep_host_to_sep_send_counter++; sep_dev->host_to_sep_send_counter++;
/* send the interrupt to SEP */ /* send the interrupt to SEP */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_HOST_SEP_GPR2_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_HOST_SEP_GPR2_REG_ADDR,
sep_host_to_sep_send_counter); sep_dev->host_to_sep_send_counter);
/* update both counters */ /* update both counters */
sep_host_to_sep_send_counter++; sep_dev->host_to_sep_send_counter++;
sep_sep_to_host_reply_counter++; sep_dev->sep_to_host_reply_counter++;
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,
"SEP Driver:<-------- sep_send_reply_command_handler end\n"); "SEP Driver:<-------- sep_send_reply_command_handler end\n");
@ -2359,7 +2316,7 @@ static int sep_allocate_data_pool_memory_handler(unsigned long arg)
/* allocate memory */ /* allocate memory */
if ( if (
(sep_data_pool_bytes_allocated + command_args.num_bytes) > (sep_dev->data_pool_bytes_allocated + command_args.num_bytes) >
SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) { SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) {
error = -ENOTTY; error = -ENOTTY;
goto end_function; goto end_function;
@ -2367,10 +2324,10 @@ static int sep_allocate_data_pool_memory_handler(unsigned long arg)
/* set the virtual and physical address */ /* set the virtual and physical address */
command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES +
sep_data_pool_bytes_allocated; sep_dev->data_pool_bytes_allocated;
command_args.phys_address = g_sep_phys_shared_area_addr + command_args.phys_address = sep_dev->phys_shared_area_addr +
SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES +
sep_data_pool_bytes_allocated; sep_dev->data_pool_bytes_allocated;
/* write the memory back to the user space */ /* write the memory back to the user space */
error = copy_to_user((void *)arg, error = copy_to_user((void *)arg,
@ -2380,7 +2337,7 @@ static int sep_allocate_data_pool_memory_handler(unsigned long arg)
goto end_function; goto end_function;
/* set the allocation */ /* set the allocation */
sep_data_pool_bytes_allocated += command_args.num_bytes; sep_dev->data_pool_bytes_allocated += command_args.num_bytes;
end_function: end_function:
@ -2435,7 +2392,7 @@ static int sep_write_into_data_pool_handler(unsigned long arg)
goto end_function; goto end_function;
/* calculate the start of the data pool */ /* calculate the start of the data pool */
data_pool_area_addr = g_sep_shared_area_addr + data_pool_area_addr = sep_dev->shared_area_addr +
SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
@ -2505,7 +2462,7 @@ static int sep_read_from_data_pool_handler(unsigned long arg)
goto end_function; goto end_function;
/* calculate the start of the data pool */ /* calculate the start of the data pool */
data_pool_area_addr = g_sep_shared_area_addr + data_pool_area_addr = sep_dev->shared_area_addr +
SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
/* check that the range of the virtual kernel address is correct */ /* check that the range of the virtual kernel address is correct */
@ -2620,21 +2577,21 @@ int sep_free_dma_table_data_handler()
"SEP Driver:--------> sep_free_dma_table_data_handler start\n"); "SEP Driver:--------> sep_free_dma_table_data_handler start\n");
/* free input pages array */ /* free input pages array */
sep_free_dma_pages(sep_in_page_array, sep_free_dma_pages(sep_dev->in_page_array,
sep_in_num_pages, sep_dev->in_num_pages,
0); 0);
/* free output pages array if needed */ /* free output pages array if needed */
if (sep_out_page_array) if (sep_dev->out_page_array)
sep_free_dma_pages(sep_out_page_array, sep_free_dma_pages(sep_dev->out_page_array,
sep_out_num_pages, sep_dev->out_num_pages,
1); 1);
/* reset all the values */ /* reset all the values */
sep_in_page_array = 0; sep_dev->in_page_array = 0;
sep_out_page_array = 0; sep_dev->out_page_array = 0;
sep_in_num_pages = 0; sep_dev->in_num_pages = 0;
sep_out_num_pages = 0; sep_dev->out_num_pages = 0;
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,
@ -2957,9 +2914,9 @@ static int sep_get_static_pool_addr_handler(unsigned long arg)
"SEP Driver:--------> sep_get_static_pool_addr_handler start\n"); "SEP Driver:--------> sep_get_static_pool_addr_handler start\n");
/*prepare the output parameters in the struct */ /*prepare the output parameters in the struct */
command_args.physical_static_address = g_sep_phys_shared_area_addr + command_args.physical_static_address = sep_dev->phys_shared_area_addr +
SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
command_args.virtual_static_address = g_sep_shared_area_addr + command_args.virtual_static_address = sep_dev->shared_area_addr +
SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
@ -3007,14 +2964,14 @@ static int sep_get_physical_mapped_offset_handler(unsigned long arg)
if (error) if (error)
goto end_function; goto end_function;
if (command_args.physical_address < g_sep_phys_shared_area_addr) { if (command_args.physical_address < sep_dev->phys_shared_area_addr) {
error = -ENOTTY; error = -ENOTTY;
goto end_function; goto end_function;
} }
/*prepare the output parameters in the struct */ /*prepare the output parameters in the struct */
command_args.offset = command_args.physical_address - command_args.offset = command_args.physical_address -
g_sep_phys_shared_area_addr; sep_dev->phys_shared_area_addr;
DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_2(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:physical_address is %08lx, offset is %lu\n", "SEP Driver:physical_address is %08lx, offset is %lu\n",
@ -3059,14 +3016,14 @@ static int sep_start_handler(void)
/* wait in polling for message from SEP */ /* wait in polling for message from SEP */
do { do {
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR3_REG_ADDR, reg_val); HW_HOST_SEP_HOST_GPR3_REG_ADDR, reg_val);
} while (!reg_val); } while (!reg_val);
/* check the value */ /* check the value */
if (reg_val == 0x1) { if (reg_val == 0x1) {
/* fatal error - read erro status from GPRO */ /* fatal error - read erro status from GPRO */
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR0_REG_ADDR, error); HW_HOST_SEP_HOST_GPR0_REG_ADDR, error);
goto end_function; goto end_function;
} }
@ -3129,7 +3086,7 @@ static int sep_init_handler(unsigned long arg)
message_ptr = (unsigned long *)command_args.message_addr; message_ptr = (unsigned long *)command_args.message_addr;
/* set the base address of the SRAM */ /* set the base address of the SRAM */
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_SRAM_ADDR_REG_ADDR, HW_SRAM_ADDR_REG_ADDR,
HW_CC_SRAM_BASE_ADDRESS); HW_CC_SRAM_BASE_ADDRESS);
@ -3139,7 +3096,7 @@ static int sep_init_handler(unsigned long arg)
get_user(message_word, message_ptr); get_user(message_word, message_ptr);
/* write data to SRAM */ /* write data to SRAM */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_SRAM_DATA_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_SRAM_DATA_REG_ADDR,
message_word); message_word);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
@ -3154,11 +3111,11 @@ static int sep_init_handler(unsigned long arg)
"SEP Driver:--------> sep_init_handler - finished getting messages from user space\n"); "SEP Driver:--------> sep_init_handler - finished getting messages from user space\n");
/* signal SEP */ /* signal SEP */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_HOST_SEP_GPR0_REG_ADDR, SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_HOST_SEP_GPR0_REG_ADDR,
0x1); 0x1);
do { do {
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR3_REG_ADDR, reg_val); HW_HOST_SEP_HOST_GPR3_REG_ADDR, reg_val);
} while (!(reg_val & 0xFFFFFFFD)); } while (!(reg_val & 0xFFFFFFFD));
@ -3170,13 +3127,13 @@ static int sep_init_handler(unsigned long arg)
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:init failed\n"); "SEP Driver:init failed\n");
SEP_READ_REGISTER(g_sep_reg_base_address + 0x8060, error); SEP_READ_REGISTER(sep_dev->reg_base_address + 0x8060, error);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:sw monitor is %lu\n", "SEP Driver:sw monitor is %lu\n",
error); error);
/* fatal error - read erro status from GPRO */ /* fatal error - read erro status from GPRO */
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_HOST_GPR0_REG_ADDR, HW_HOST_SEP_HOST_GPR0_REG_ADDR,
error); error);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
@ -3234,7 +3191,7 @@ static int sep_realloc_cache_resident_handler(unsigned long arg)
/* lock the area (if needed) */ /* lock the area (if needed) */
sep_lock_cache_resident_area(); sep_lock_cache_resident_area();
command_args.new_base_addr = g_sep_phys_shared_area_addr; command_args.new_base_addr = sep_dev->phys_shared_area_addr;
/* find the new base address according to the lowest address between /* find the new base address according to the lowest address between
cache, resident and shared area */ cache, resident and shared area */
@ -3249,7 +3206,7 @@ static int sep_realloc_cache_resident_handler(unsigned long arg)
/* set the new shared area */ /* set the new shared area */
command_args.new_shared_area_addr = g_sep_phys_shared_area_addr; command_args.new_shared_area_addr = sep_dev->phys_shared_area_addr;
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:command_args.new_shared_area_addr is %08lx\n", "SEP Driver:command_args.new_shared_area_addr is %08lx\n",
@ -3325,7 +3282,7 @@ static int sep_set_api_mode_handler(unsigned long arg)
goto end_function; goto end_function;
/* set the global flag */ /* set the global flag */
g_sep_block_mode_flag = mode_flag; sep_dev->block_mode_flag = mode_flag;
end_function: end_function:
@ -3350,10 +3307,10 @@ static int sep_end_transaction_handler(unsigned long arg)
#if 0/*!SEP_DRIVER_POLLING_MODE*/ #if 0/*!SEP_DRIVER_POLLING_MODE*/
/* close IMR */ /* close IMR */
SEP_WRITE_REGISTER(g_sep_reg_base_address + HW_HOST_IMR_REG_ADDR, 0x7FFF); SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR, 0x7FFF);
/* release IRQ line */ /* release IRQ line */
free_irq(SEP_DIRVER_IRQ_NUM, &g_sep_reg_base_address); free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address);
/* lock the sep mutex */ /* lock the sep mutex */
mutex_unlock(&sep_mutex); mutex_unlock(&sep_mutex);
@ -3392,10 +3349,10 @@ static void sep_flow_done_handler(struct work_struct *work)
if (flow_data_ptr->input_tables_flag) { if (flow_data_ptr->input_tables_flag) {
/* copy the message to the shared RAM and signal SEP */ /* copy the message to the shared RAM and signal SEP */
memcpy((void *)flow_data_ptr->message, memcpy((void *)flow_data_ptr->message,
(void *)g_sep_shared_area_addr, (void *)sep_dev->shared_area_addr,
flow_data_ptr->message_size_in_bytes); flow_data_ptr->message_size_in_bytes);
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_HOST_HOST_SEP_GPR2_REG_ADDR, HW_HOST_HOST_SEP_GPR2_REG_ADDR,
0x2); 0x2);
} }
@ -3644,8 +3601,8 @@ static int sep_find_flow_context(
when 2 flows are with default flag when 2 flows are with default flag
*/ */
for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) { for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) {
if (g_sep_flows_data_array[count].flow_id == flow_id) { if (sep_dev->flows_data_array[count].flow_id == flow_id) {
*flow_data_ptr = &g_sep_flows_data_array[count]; *flow_data_ptr = &sep_dev->flows_data_array[count];
break; break;
} }
} }
@ -3685,7 +3642,7 @@ static int sep_find_free_flow_dma_table_space(
error = 0; error = 0;
/* find the start address of the flow DMA table area */ /* find the start address of the flow DMA table area */
flow_dma_area_start_addr = g_sep_shared_area_addr + flow_dma_area_start_addr = sep_dev->shared_area_addr +
SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES; SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES;
/* set end address of the flow table area */ /* set end address of the flow table area */
@ -3837,7 +3794,7 @@ static int sep_set_time(unsigned long *address_ptr,
do_gettimeofday(&time); do_gettimeofday(&time);
/* set value in the SYSTEM MEMORY offset */ /* set value in the SYSTEM MEMORY offset */
time_addr = g_message_shared_area_addr + time_addr = sep_dev->message_shared_area_addr +
SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES; SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES;
*(unsigned long *)time_addr = SEP_TIME_VAL_TOKEN; *(unsigned long *)time_addr = SEP_TIME_VAL_TOKEN;
@ -3851,7 +3808,7 @@ static int sep_set_time(unsigned long *address_ptr,
time_addr); time_addr);
DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED, DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
"SEP Driver:g_message_shared_area_addr is %lu\n", "SEP Driver:g_message_shared_area_addr is %lu\n",
g_message_shared_area_addr); sep_dev->message_shared_area_addr);
/* set the output parameters if needed */ /* set the output parameters if needed */
if (address_ptr) if (address_ptr)
@ -3880,32 +3837,32 @@ static void sep_configure_dma_burst(void)
"SEP Driver:<-------- sep_configure_dma_burst start \n"); "SEP Driver:<-------- sep_configure_dma_burst start \n");
/* request access to registers from SEP */ /* request access to registers from SEP */
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2UL); HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2UL);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,
"SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n"); "SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n");
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_BUSY_REG_ADDR, regVal); HW_HOST_SEP_BUSY_REG_ADDR, regVal);
while (regVal) while (regVal)
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_BUSY_REG_ADDR, regVal); HW_HOST_SEP_BUSY_REG_ADDR, regVal);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,
"SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n"); "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*/ /* set the DMA burst register to single burst*/
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL); HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL);
/* release the sep busy */ /* release the sep busy */
SEP_WRITE_REGISTER(g_sep_reg_base_address + SEP_WRITE_REGISTER(sep_dev->reg_base_address +
HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL); HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL);
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_BUSY_REG_ADDR, regVal); HW_HOST_SEP_BUSY_REG_ADDR, regVal);
while (regVal != 0x0) while (regVal != 0x0)
SEP_READ_REGISTER(g_sep_reg_base_address + SEP_READ_REGISTER(sep_dev->reg_base_address +
HW_HOST_SEP_BUSY_REG_ADDR, regVal); HW_HOST_SEP_BUSY_REG_ADDR, regVal);
DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC, DEBUG_PRINT_0(SEP_DEBUG_LEVEL_BASIC,