3 * sep_main_mod.c - Security Processor Driver main group of functions
5 * Copyright(c) 2009 Intel Corporation. All rights reserved.
6 * Copyright(c) 2009 Discretix. All rights reserved.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * You should have received a copy of the GNU General Public License along with
19 * this program; if not, write to the Free Software Foundation, Inc., 59
20 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 * Mark Allyn mark.a.allyn@intel.com
28 * 2009.06.26 Initial publish
32 #include <linux/init.h>
33 #include <linux/module.h>
35 #include <linux/cdev.h>
36 #include <linux/kdev_t.h>
37 #include <linux/mutex.h>
39 #include <linux/poll.h>
40 #include <linux/wait.h>
41 #include <asm/ioctl.h>
42 #include <linux/ioport.h>
44 #include <linux/interrupt.h>
45 #include <linux/pagemap.h>
46 #include <asm/cacheflush.h>
47 #include "sep_driver_hw_defs.h"
48 #include "sep_driver_config.h"
49 #include "sep_driver_api.h"
50 #include "sep_driver_ext_api.h"
53 /*----------------------------------------
55 -----------------------------------------*/
58 #define INT_MODULE_PARM(n, v) int n = v; module_param(n, int, 0)
60 /*--------------------------------------
62 -----------------------------------------*/
66 /*--------------------------------------------
68 --------------------------------------------*/
70 /* debug messages level */
71 INT_MODULE_PARM(sepDebug
, 0x0);
72 MODULE_PARM_DESC(sepDebug
, "Flag to enable SEP debug messages");
74 /* major and minor device numbers */
75 static dev_t g_sep_device_number
;
77 /* the files operations structure of the driver */
78 static struct file_operations g_sep_fops
;
80 /* cdev struct of the driver */
81 static struct cdev g_sep_cdev
;
84 mutex for the access to the internals of the sep driver
86 static DEFINE_MUTEX(sep_mutex
);
89 /* wait queue head (event) of the driver */
90 static DECLARE_WAIT_QUEUE_HEAD(g_sep_event
);
94 /*------------------------------------------------
96 ---------------------------------------------------*/
99 interrupt handler function
101 irqreturn_t
sep_inthandler(int irq
, void *dev_id
);
104 this function registers the driver to the file system
106 static int sep_register_driver_to_fs(void);
109 this function unregisters driver from fs
111 static void sep_unregister_driver_from_fs(void);
114 this function calculates the size of data that can be inserted into the lli
115 table from this array the condition is that either the table is full
116 (all etnries are entered), or there are no more entries in the lli array
118 static unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t
*lli_in_array_ptr
, unsigned long num_array_entries
);
120 this functions builds ont lli table from the lli_array according to the
123 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
);
126 this function goes over the list of the print created tables and prints
129 static void sep_debug_print_lli_tables(struct sep_lli_entry_t
*lli_table_ptr
, unsigned long num_table_entries
, unsigned long table_data_size
);
134 This function raises interrupt to SEPm that signals that is has a new
137 static void sep_send_command_handler(void);
141 This function raises interrupt to SEP that signals that is has a
144 static void sep_send_reply_command_handler(void);
147 This function handles the allocate data pool memory request
148 This function returns calculates the physical address of the allocated memory
149 and the offset of this area from the mapped address. Therefore, the FVOs in
150 user space can calculate the exact virtual address of this allocated memory
152 static int sep_allocate_data_pool_memory_handler(unsigned long arg
);
156 This function handles write into allocated data pool command
158 static int sep_write_into_data_pool_handler(unsigned long arg
);
161 this function handles the read from data pool command
163 static int sep_read_from_data_pool_handler(unsigned long arg
);
166 this function handles tha request for creation of the DMA table
167 for the synchronic symmetric operations (AES,DES)
169 static int sep_create_sync_dma_tables_handler(unsigned long arg
);
172 this function handles the request to create the DMA tables for flow
174 static int sep_create_flow_dma_tables_handler(unsigned long arg
);
177 This API handles the end transaction request
179 static int sep_end_transaction_handler(unsigned long arg
);
183 this function handles add tables to flow
185 static int sep_add_flow_tables_handler(unsigned long arg
);
188 this function add the flow add message to the specific flow
190 static int sep_add_flow_tables_message_handler(unsigned long arg
);
193 this function handles the request for SEP start
195 static int sep_start_handler(void);
198 this function handles the request for SEP initialization
200 static int sep_init_handler(unsigned long arg
);
203 this function handles the request cache and resident reallocation
205 static int sep_realloc_cache_resident_handler(unsigned long arg
);
209 This api handles the setting of API mode to blocking or non-blocking
211 static int sep_set_api_mode_handler(unsigned long arg
);
213 /* handler for flow done interrupt */
214 static void sep_flow_done_handler(struct work_struct
*work
);
217 This function locks all the physical pages of the kernel virtual buffer
218 and construct a basic lli array, where each entry holds the physical
219 page address and the size that application data holds in this physical pages
221 static int sep_lock_kernel_pages(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
);
224 This function creates one DMA table for flow and returns its data,
225 and pointer to its info entry
227 static int sep_prepare_one_flow_dma_table(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
);
230 This function creates a list of tables for flow and returns the data for the
231 first and last tables of the list
233 static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers
,
234 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
);
237 this function find a space for the new flow dma table
239 static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr
);
242 this function goes over all the flow tables connected to the given table and
245 static void sep_deallocated_flow_tables(struct sep_lli_entry_t
*first_table_ptr
);
248 This function handler the set flow id command
250 static int sep_set_flow_id_handler(unsigned long arg
);
253 This function returns pointer to the flow data structure
254 that conatins the given id
256 static int sep_find_flow_context(unsigned long flow_id
, struct sep_flow_context_t
**flow_data_ptr
);
260 this function returns the physical and virtual addresses of the static pool
262 static int sep_get_static_pool_addr_handler(unsigned long arg
);
265 this address gets the offset of the physical address from the start of
268 static int sep_get_physical_mapped_offset_handler(unsigned long arg
);
272 this function handles the request for get time
274 static int sep_get_time_handler(unsigned long arg
);
277 calculates time and sets it at the predefined address
279 static int sep_set_time(unsigned long *address_ptr
, unsigned long *time_in_sec_ptr
);
282 PATCH for configuring the DMA to single burst instead of multi-burst
284 static void sep_configure_dma_burst(void);
287 This function locks all the physical pages of the
288 application virtual buffer and construct a basic lli
289 array, where each entry holds the physical page address
290 and the size that application data holds in this physical pages
292 static int sep_lock_user_pages(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
);
294 /*---------------------------------------------
296 -----------------------------------------------*/
299 this function locks SEP by locking the semaphore
303 mutex_lock(&sep_mutex
);
308 this function unlocks SEP
313 mutex_unlock(&sep_mutex
);
317 this function returns the address of the message shared area
319 void sep_map_shared_area(unsigned long *mappedAddr_ptr
)
321 *mappedAddr_ptr
= sep_dev
->shared_area_addr
;
325 this function returns the address of the message shared area
327 void sep_send_msg_rdy_cmd()
329 sep_send_command_handler();
332 /* this functions frees all the resources that were allocated for the building
333 of the LLI DMA tables */
334 void sep_free_dma_resources()
336 sep_free_dma_table_data_handler();
339 /* poll(suspend), until reply from sep */
340 void sep_driver_poll()
342 unsigned long retVal
= 0;
344 #ifdef SEP_DRIVER_POLLING_MODE
346 while (sep_dev
->host_to_sep_send_counter
!= (retVal
& 0x7FFFFFFF))
347 retVal
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR2_REG_ADDR
);
349 sep_dev
->sep_to_host_reply_counter
++;
351 /* poll, until reply from sep */
352 wait_event(g_sep_event
, (sep_dev
->host_to_sep_send_counter
== sep_dev
->sep_to_host_reply_counter
));
357 /*----------------------------------------------------------------------
358 open function of the character driver - must only lock the mutex
359 must also release the memory data pool allocations
360 ------------------------------------------------------------------------*/
361 static int sep_open(struct inode
*inode_ptr
, struct file
*file_ptr
)
365 dbg("SEP Driver:--------> open start\n");
369 /* check the blocking mode */
370 if (sep_dev
->block_mode_flag
)
372 mutex_lock(&sep_mutex
);
374 error
= mutex_trylock(&sep_mutex
);
376 /* check the error */
378 edbg("SEP Driver: down_interruptible failed\n");
383 /* release data pool allocations */
384 sep_dev
->data_pool_bytes_allocated
= 0;
387 dbg("SEP Driver:<-------- open end\n");
394 /*------------------------------------------------------------
396 -------------------------------------------------------------*/
397 static int sep_release(struct inode
*inode_ptr
, struct file
*file_ptr
)
399 dbg("----------->SEP Driver: sep_release start\n");
401 #if 0 /*!SEP_DRIVER_POLLING_MODE */
403 sep_write_reg(sep_dev
, HW_HOST_IMR_REG_ADDR
, 0x7FFF);
405 /* release IRQ line */
406 free_irq(SEP_DIRVER_IRQ_NUM
, &sep_dev
->reg_base_address
);
410 /* unlock the sep mutex */
411 mutex_unlock(&sep_mutex
);
413 dbg("SEP Driver:<-------- sep_release end\n");
421 /*---------------------------------------------------------------
422 map function - this functions maps the message shared area
423 -----------------------------------------------------------------*/
424 static int sep_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
426 unsigned long phys_addr
;
428 dbg("-------->SEP Driver: mmap start\n");
430 /* check that the size of the mapped range is as the size of the message
432 if ((vma
->vm_end
- vma
->vm_start
) > SEP_DRIVER_MMMAP_AREA_SIZE
) {
433 edbg("SEP Driver mmap requested size is more than allowed\n");
434 printk(KERN_WARNING
"SEP Driver mmap requested size is more \
436 printk(KERN_WARNING
"SEP Driver vma->vm_end is %08lx\n", vma
->vm_end
);
437 printk(KERN_WARNING
"SEP Driver vma->vm_end is %08lx\n", vma
->vm_start
);
441 edbg("SEP Driver:g_message_shared_area_addr is %08lx\n", sep_dev
->message_shared_area_addr
);
443 /* get physical address */
444 phys_addr
= sep_dev
->phys_shared_area_addr
;
446 edbg("SEP Driver: phys_addr is %08lx\n", phys_addr
);
448 if (remap_pfn_range(vma
, vma
->vm_start
, phys_addr
>> PAGE_SHIFT
, vma
->vm_end
- vma
->vm_start
, vma
->vm_page_prot
)) {
449 edbg("SEP Driver remap_page_range failed\n");
450 printk(KERN_WARNING
"SEP Driver remap_page_range failed\n");
454 dbg("SEP Driver:<-------- mmap end\n");
460 /*-----------------------------------------------
462 *----------------------------------------------*/
463 static unsigned int sep_poll(struct file
*filp
, poll_table
* wait
)
466 unsigned int mask
= 0;
467 unsigned long retVal
= 0; /* flow id */
469 dbg("---------->SEP Driver poll: start\n");
472 #if SEP_DRIVER_POLLING_MODE
474 while (sep_dev
->host_to_sep_send_counter
!= (retVal
& 0x7FFFFFFF)) {
475 retVal
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR2_REG_ADDR
);
477 for (count
= 0; count
< 10 * 4; count
+= 4)
478 edbg("Poll Debug Word %lu of the message is %lu\n", count
, *((unsigned long *) (sep_dev
->shared_area_addr
+ SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES
+ count
)));
481 sep_dev
->sep_to_host_reply_counter
++;
483 /* add the event to the polling wait table */
484 poll_wait(filp
, &g_sep_event
, wait
);
488 edbg("sep_dev->host_to_sep_send_counter is %lu\n", sep_dev
->host_to_sep_send_counter
);
489 edbg("sep_dev->sep_to_host_reply_counter is %lu\n", sep_dev
->sep_to_host_reply_counter
);
491 /* check if the data is ready */
492 if (sep_dev
->host_to_sep_send_counter
== sep_dev
->sep_to_host_reply_counter
) {
493 for (count
= 0; count
< 12 * 4; count
+= 4)
494 edbg("Sep Mesg Word %lu of the message is %lu\n", count
, *((unsigned long *) (sep_dev
->shared_area_addr
+ count
)));
496 for (count
= 0; count
< 10 * 4; count
+= 4)
497 edbg("Debug Data Word %lu of the message is %lu\n", count
, *((unsigned long *) (sep_dev
->shared_area_addr
+ 0x1800 + count
)));
499 retVal
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR2_REG_ADDR
);
500 edbg("retVal is %lu\n", retVal
);
501 /* check if the this is sep reply or request */
503 edbg("SEP Driver: sep request in\n");
505 mask
|= POLLOUT
| POLLWRNORM
;
507 edbg("SEP Driver: sep reply in\n");
508 mask
|= POLLIN
| POLLRDNORM
;
511 dbg("SEP Driver:<-------- poll exit\n");
516 static int sep_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int cmd
, unsigned long arg
)
520 dbg("------------>SEP Driver: ioctl start\n");
522 edbg("SEP Driver: cmd is %x\n", cmd
);
524 /* check that the command is for sep device */
525 if (_IOC_TYPE(cmd
) != SEP_IOC_MAGIC_NUMBER
)
529 case SEP_IOCSENDSEPCOMMAND
:
530 /* send command to SEP */
531 sep_send_command_handler();
532 edbg("SEP Driver: after sep_send_command_handler\n");
534 case SEP_IOCSENDSEPRPLYCOMMAND
:
535 /* send reply command to SEP */
536 sep_send_reply_command_handler();
538 case SEP_IOCALLOCDATAPOLL
:
539 /* allocate data pool */
540 error
= sep_allocate_data_pool_memory_handler(arg
);
542 case SEP_IOCWRITEDATAPOLL
:
543 /* write data into memory pool */
544 error
= sep_write_into_data_pool_handler(arg
);
546 case SEP_IOCREADDATAPOLL
:
547 /* read data from data pool into application memory */
548 error
= sep_read_from_data_pool_handler(arg
);
550 case SEP_IOCCREATESYMDMATABLE
:
551 /* create dma table for synhronic operation */
552 error
= sep_create_sync_dma_tables_handler(arg
);
554 case SEP_IOCCREATEFLOWDMATABLE
:
555 /* create flow dma tables */
556 error
= sep_create_flow_dma_tables_handler(arg
);
558 case SEP_IOCFREEDMATABLEDATA
:
560 error
= sep_free_dma_table_data_handler();
562 case SEP_IOCSETFLOWID
:
564 error
= sep_set_flow_id_handler(arg
);
566 case SEP_IOCADDFLOWTABLE
:
567 /* add tables to the dynamic flow */
568 error
= sep_add_flow_tables_handler(arg
);
570 case SEP_IOCADDFLOWMESSAGE
:
571 /* add message of add tables to flow */
572 error
= sep_add_flow_tables_message_handler(arg
);
574 case SEP_IOCSEPSTART
:
575 /* start command to sep */
576 error
= sep_start_handler();
579 /* init command to sep */
580 error
= sep_init_handler(arg
);
582 case SEP_IOCSETAPIMODE
:
583 /* set non- blocking mode */
584 error
= sep_set_api_mode_handler(arg
);
586 case SEP_IOCGETSTATICPOOLADDR
:
587 /* get the physical and virtual addresses of the static pool */
588 error
= sep_get_static_pool_addr_handler(arg
);
590 case SEP_IOCENDTRANSACTION
:
591 error
= sep_end_transaction_handler(arg
);
593 case SEP_IOCREALLOCCACHERES
:
594 error
= sep_realloc_cache_resident_handler(arg
);
596 case SEP_IOCGETMAPPEDADDROFFSET
:
597 error
= sep_get_physical_mapped_offset_handler(arg
);
600 error
= sep_get_time_handler(arg
);
606 dbg("SEP Driver:<-------- ioctl end\n");
612 this function registers the driver to the file system
614 static int sep_register_driver_to_fs(void)
616 int ret_val
= alloc_chrdev_region(&g_sep_device_number
, 0, 1, "sep_sec_driver");
618 edbg("sep_driver:major number allocation failed, retval is %d\n", ret_val
);
622 /* set the files operations structure */
623 g_sep_fops
.owner
= THIS_MODULE
;
624 g_sep_fops
.ioctl
= sep_ioctl
;
625 g_sep_fops
.poll
= sep_poll
;
626 g_sep_fops
.open
= sep_open
;
627 g_sep_fops
.release
= sep_release
;
628 g_sep_fops
.mmap
= sep_mmap
;
631 cdev_init(&g_sep_cdev
, &g_sep_fops
);
632 g_sep_cdev
.owner
= THIS_MODULE
;
634 /* register the driver with the kernel */
635 ret_val
= cdev_add(&g_sep_cdev
, g_sep_device_number
, 1);
638 edbg("sep_driver:cdev_add failed, retval is %d\n", ret_val
);
639 goto end_function_unregister_devnum
;
644 end_function_unregister_devnum
:
646 /* unregister dev numbers */
647 unregister_chrdev_region(g_sep_device_number
, 1);
654 this function unregisters driver from fs
656 static void sep_unregister_driver_from_fs(void)
658 cdev_del(&g_sep_cdev
);
659 /* unregister dev numbers */
660 unregister_chrdev_region(g_sep_device_number
, 1);
663 /*--------------------------------------------------------------
665 ----------------------------------------------------------------*/
666 static int __init
sep_init(void)
670 int size
; /* size of memory for allocation */
672 dbg("SEP Driver:-------->Init start\n");
673 edbg("sep->shared_area_addr = %lx\n", (unsigned long) &sep_dev
->shared_area_addr
);
675 /* transaction counter that coordinates the transactions between SEP
677 sep_dev
->host_to_sep_send_counter
= 0;
679 /* counter for the messages from sep */
680 sep_dev
->sep_to_host_reply_counter
= 0;
682 /* counter for the number of bytes allocated in the pool
683 for the current transaction */
684 sep_dev
->data_pool_bytes_allocated
= 0;
686 /* set the starting mode to blocking */
687 sep_dev
->block_mode_flag
= 1;
689 ret_val
= sep_register_driver_to_device();
691 edbg("sep_driver:sep_driver_to_device failed, ret_val is %d\n", ret_val
);
692 goto end_function_unregister_from_fs
;
694 /* calculate the total size for allocation */
695 size
= SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES
+
696 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
;
698 /* allocate the shared area */
699 if (sep_map_and_alloc_shared_area(size
, &sep_dev
->shared_area_addr
, &sep_dev
->phys_shared_area_addr
)) {
701 /* allocation failed */
702 goto end_function_unmap_io_memory
;
704 /* now set the memory regions */
705 sep_dev
->message_shared_area_addr
= sep_dev
->shared_area_addr
;
707 edbg("SEP Driver: g_message_shared_area_addr is %08lx\n", sep_dev
->message_shared_area_addr
);
709 #if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1)
710 /* send the new SHARED MESSAGE AREA to the SEP */
711 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR1_REG_ADDR
, sep_dev
->phys_shared_area_addr
);
713 /* poll for SEP response */
714 retVal
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR1_REG_ADDR
);
715 while (retVal
!= 0xffffffff && retVal
!= sep_dev
->phys_shared_area_addr
)
716 retVal
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR1_REG_ADDR
);
718 /* check the return value (register) */
719 if (retVal
!= sep_dev
->phys_shared_area_addr
) {
721 goto end_function_deallocate_message_area
;
724 /* init the flow contextes */
725 for (counter
= 0; counter
< SEP_DRIVER_NUM_FLOWS
; counter
++)
726 sep_dev
->flows_data_array
[counter
].flow_id
= SEP_FREE_FLOW_ID
;
728 sep_dev
->flow_wq_ptr
= create_singlethread_workqueue("sepflowwq");
729 if (sep_dev
->flow_wq_ptr
== 0) {
731 edbg("sep_driver:flow queue creation failed\n");
732 goto end_function_deallocate_sep_shared_area
;
734 edbg("SEP Driver: create flow workqueue \n");
736 /* register driver to fs */
737 ret_val
= sep_register_driver_to_fs();
739 goto end_function_deallocate_sep_shared_area
;
740 /* load the rom code */
743 end_function_unregister_from_fs
:
744 /* unregister from fs */
745 sep_unregister_driver_from_fs();
746 end_function_deallocate_sep_shared_area
:
747 /* de-allocate shared area */
748 sep_unmap_and_free_shared_area(size
, sep_dev
->shared_area_addr
, sep_dev
->phys_shared_area_addr
);
749 end_function_unmap_io_memory
:
750 iounmap((void *) sep_dev
->reg_base_address
);
751 /* release io memory region */
752 release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS
, SEP_IO_MEM_REGION_SIZE
);
754 dbg("SEP Driver:<-------- Init end\n");
759 /*-------------------------------------------------------------
761 --------------------------------------------------------------*/
762 static void __exit
sep_exit(void)
766 dbg("SEP Driver:--------> Exit start\n");
768 /* unregister from fs */
769 sep_unregister_driver_from_fs();
770 /* calculate the total size for de-allocation */
771 size
= SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES
+
772 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
;
773 /* free shared area */
774 sep_unmap_and_free_shared_area(size
, sep_dev
->shared_area_addr
, sep_dev
->phys_shared_area_addr
);
775 edbg("SEP Driver: free pages SEP SHARED AREA \n");
776 iounmap((void *) sep_dev
->reg_base_address
);
777 edbg("SEP Driver: iounmap \n");
778 /* release io memory region */
779 release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS
, SEP_IO_MEM_REGION_SIZE
);
780 edbg("SEP Driver: release_mem_region \n");
781 dbg("SEP Driver:<-------- Exit end\n");
786 interrupt handler function
788 irqreturn_t
sep_inthandler(int irq
, void *dev_id
)
790 irqreturn_t int_error
;
792 unsigned long reg_val
;
793 unsigned long flow_id
;
794 struct sep_flow_context_t
*flow_context_ptr
;
796 int_error
= IRQ_HANDLED
;
798 /* read the IRR register to check if this is SEP interrupt */
799 reg_val
= sep_read_reg(sep_dev
, HW_HOST_IRR_REG_ADDR
);
800 edbg("SEP Interrupt - reg is %08lx\n", reg_val
);
802 /* check if this is the flow interrupt */
803 if (0 /*reg_val & (0x1 << 11) */ ) {
804 /* read GPRO to find out the which flow is done */
805 flow_id
= sep_read_reg(sep_dev
, HW_HOST_IRR_REG_ADDR
);
807 /* find the contex of the flow */
808 error
= sep_find_flow_context(flow_id
>> 28, &flow_context_ptr
);
810 goto end_function_with_error
;
812 INIT_WORK(&flow_context_ptr
->flow_wq
, sep_flow_done_handler
);
815 queue_work(sep_dev
->flow_wq_ptr
, &flow_context_ptr
->flow_wq
);
818 /* check if this is reply interrupt from SEP */
819 if (reg_val
& (0x1 << 13)) {
820 /* update the counter of reply messages */
821 sep_dev
->sep_to_host_reply_counter
++;
823 /* wake up the waiting process */
824 wake_up(&g_sep_event
);
826 int_error
= IRQ_NONE
;
830 end_function_with_error
:
831 /* clear the interrupt */
832 sep_write_reg(sep_dev
, HW_HOST_ICR_REG_ADDR
, reg_val
);
839 This function prepares only input DMA table for synhronic symmetric
842 int sep_prepare_input_dma_table(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
)
844 /* pointer to the info entry of the table - the last entry */
845 struct sep_lli_entry_t
*info_entry_ptr
;
846 /* array of pointers ot page */
847 struct sep_lli_entry_t
*lli_array_ptr
;
848 /* points to the first entry to be processed in the lli_in_array */
849 unsigned long current_entry
;
850 /* num entries in the virtual buffer */
851 unsigned long sep_lli_entries
;
852 /* lli table pointer */
853 struct sep_lli_entry_t
*in_lli_table_ptr
;
854 /* the total data in one table */
855 unsigned long table_data_size
;
856 /* number of entries in lli table */
857 unsigned long num_entries_in_table
;
858 /* next table address */
859 unsigned long lli_table_alloc_addr
;
860 unsigned long result
;
862 dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n");
864 edbg("SEP Driver:data_size is %lu\n", data_size
);
865 edbg("SEP Driver:block_size is %lu\n", block_size
);
867 /* initialize the pages pointers */
868 sep_dev
->in_page_array
= 0;
869 sep_dev
->in_num_pages
= 0;
871 if (data_size
== 0) {
872 /* special case - created 2 entries table with zero data */
873 in_lli_table_ptr
= (struct sep_lli_entry_t
*) (sep_dev
->shared_area_addr
+ SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES
);
874 in_lli_table_ptr
->physical_address
= sep_dev
->shared_area_addr
+ SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES
;
875 in_lli_table_ptr
->block_size
= 0;
878 in_lli_table_ptr
->physical_address
= 0xFFFFFFFF;
879 in_lli_table_ptr
->block_size
= 0;
881 *lli_table_ptr
= sep_dev
->phys_shared_area_addr
+ SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES
;
882 *num_entries_ptr
= 2;
883 *table_data_size_ptr
= 0;
888 /* check if the pages are in Kernel Virtual Address layout */
889 if (isKernelVirtualAddress
== true)
890 /* lock the pages of the kernel buffer and translate them to pages */
891 result
= sep_lock_kernel_pages(app_virt_addr
, data_size
, &sep_dev
->in_num_pages
, &lli_array_ptr
, &sep_dev
->in_page_array
);
893 /* lock the pages of the user buffer and translate them to pages */
894 result
= sep_lock_user_pages(app_virt_addr
, data_size
, &sep_dev
->in_num_pages
, &lli_array_ptr
, &sep_dev
->in_page_array
);
899 edbg("SEP Driver:output sep_dev->in_num_pages is %lu\n", sep_dev
->in_num_pages
);
903 sep_lli_entries
= sep_dev
->in_num_pages
;
905 /* initiate to point after the message area */
906 lli_table_alloc_addr
= sep_dev
->shared_area_addr
+ SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES
;
908 /* loop till all the entries in in array are not processed */
909 while (current_entry
< sep_lli_entries
) {
910 /* set the new input and output tables */
911 in_lli_table_ptr
= (struct sep_lli_entry_t
*) lli_table_alloc_addr
;
913 lli_table_alloc_addr
+= sizeof(struct sep_lli_entry_t
) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP
;
915 /* calculate the maximum size of data for input table */
916 table_data_size
= sep_calculate_lli_table_max_size(&lli_array_ptr
[current_entry
], (sep_lli_entries
- current_entry
));
918 /* now calculate the table size so that it will be module block size */
919 table_data_size
= (table_data_size
/ block_size
) * block_size
;
921 edbg("SEP Driver:output table_data_size is %lu\n", table_data_size
);
923 /* construct input lli table */
924 sep_build_lli_table(&lli_array_ptr
[current_entry
], in_lli_table_ptr
, ¤t_entry
, &num_entries_in_table
, table_data_size
);
926 if (info_entry_ptr
== 0) {
927 /* set the output parameters to physical addresses */
928 *lli_table_ptr
= sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr
);
929 *num_entries_ptr
= num_entries_in_table
;
930 *table_data_size_ptr
= table_data_size
;
932 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_ptr
);
934 /* update the info entry of the previous in table */
935 info_entry_ptr
->physical_address
= sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr
);
936 info_entry_ptr
->block_size
= ((num_entries_in_table
) << 24) | (table_data_size
);
939 /* save the pointer to the info entry of the current tables */
940 info_entry_ptr
= in_lli_table_ptr
+ num_entries_in_table
- 1;
943 /* print input tables */
944 sep_debug_print_lli_tables((struct sep_lli_entry_t
*)
945 sep_shared_area_phys_to_virt(*lli_table_ptr
), *num_entries_ptr
, *table_data_size_ptr
);
947 /* the array of the pages */
948 kfree(lli_array_ptr
);
950 dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n");
956 This function builds input and output DMA tables for synhronic
957 symmetric operations (AES, DES). It also checks that each table
958 is of the modular block size
960 int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr
,
961 unsigned long app_virt_out_addr
,
962 unsigned long data_size
,
963 unsigned long block_size
,
964 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
)
966 /* array of pointers of page */
967 struct sep_lli_entry_t
*lli_in_array
;
968 /* array of pointers of page */
969 struct sep_lli_entry_t
*lli_out_array
;
972 dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n");
974 /* initialize the pages pointers */
975 sep_dev
->in_page_array
= 0;
976 sep_dev
->out_page_array
= 0;
978 /* check if the pages are in Kernel Virtual Address layout */
979 if (isKernelVirtualAddress
== true) {
980 /* lock the pages of the kernel buffer and translate them to pages */
981 result
= sep_lock_kernel_pages(app_virt_in_addr
, data_size
, &sep_dev
->in_num_pages
, &lli_in_array
, &sep_dev
->in_page_array
);
983 edbg("SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n");
987 /* lock the pages of the user buffer and translate them to pages */
988 result
= sep_lock_user_pages(app_virt_in_addr
, data_size
, &sep_dev
->in_num_pages
, &lli_in_array
, &sep_dev
->in_page_array
);
990 edbg("SEP Driver: sep_lock_user_pages for input virtual buffer failed\n");
995 if (isKernelVirtualAddress
== true) {
996 result
= sep_lock_kernel_pages(app_virt_out_addr
, data_size
, &sep_dev
->out_num_pages
, &lli_out_array
, &sep_dev
->out_page_array
);
998 edbg("SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n");
999 goto end_function_with_error1
;
1002 result
= sep_lock_user_pages(app_virt_out_addr
, data_size
, &sep_dev
->out_num_pages
, &lli_out_array
, &sep_dev
->out_page_array
);
1004 edbg("SEP Driver: sep_lock_user_pages for output virtual buffer failed\n");
1005 goto end_function_with_error1
;
1008 edbg("sep_dev->in_num_pages is %lu\n", sep_dev
->in_num_pages
);
1009 edbg("sep_dev->out_num_pages is %lu\n", sep_dev
->out_num_pages
);
1010 edbg("SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP
);
1013 /* call the fucntion that creates table from the lli arrays */
1014 result
= sep_construct_dma_tables_from_lli(lli_in_array
, sep_dev
->in_num_pages
, lli_out_array
, sep_dev
->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
);
1016 edbg("SEP Driver: sep_construct_dma_tables_from_lli failed\n");
1017 goto end_function_with_error2
;
1020 /* fall through - free the lli entry arrays */
1021 dbg("in_num_entries_ptr is %08lx\n", *in_num_entries_ptr
);
1022 dbg("out_num_entries_ptr is %08lx\n", *out_num_entries_ptr
);
1023 dbg("table_data_size_ptr is %08lx\n", *table_data_size_ptr
);
1024 end_function_with_error2
:
1025 kfree(lli_out_array
);
1026 end_function_with_error1
:
1027 kfree(lli_in_array
);
1029 dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result
);
1036 This function creates the input and output dma tables for
1037 symmetric operations (AES/DES) according to the block size from LLI arays
1039 int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t
*lli_in_array
,
1040 unsigned long sep_in_lli_entries
,
1041 struct sep_lli_entry_t
*lli_out_array
,
1042 unsigned long sep_out_lli_entries
,
1043 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
)
1045 /* points to the area where next lli table can be allocated */
1046 unsigned long lli_table_alloc_addr
;
1047 /* input lli table */
1048 struct sep_lli_entry_t
*in_lli_table_ptr
;
1049 /* output lli table */
1050 struct sep_lli_entry_t
*out_lli_table_ptr
;
1051 /* pointer to the info entry of the table - the last entry */
1052 struct sep_lli_entry_t
*info_in_entry_ptr
;
1053 /* pointer to the info entry of the table - the last entry */
1054 struct sep_lli_entry_t
*info_out_entry_ptr
;
1055 /* points to the first entry to be processed in the lli_in_array */
1056 unsigned long current_in_entry
;
1057 /* points to the first entry to be processed in the lli_out_array */
1058 unsigned long current_out_entry
;
1059 /* max size of the input table */
1060 unsigned long in_table_data_size
;
1061 /* max size of the output table */
1062 unsigned long out_table_data_size
;
1063 /* flag te signifies if this is the first tables build from the arrays */
1064 unsigned long first_table_flag
;
1065 /* the data size that should be in table */
1066 unsigned long table_data_size
;
1067 /* number of etnries in the input table */
1068 unsigned long num_entries_in_table
;
1069 /* number of etnries in the output table */
1070 unsigned long num_entries_out_table
;
1072 dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n");
1074 /* initiate to pint after the message area */
1075 lli_table_alloc_addr
= sep_dev
->shared_area_addr
+ SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES
;
1077 current_in_entry
= 0;
1078 current_out_entry
= 0;
1079 first_table_flag
= 1;
1080 info_in_entry_ptr
= 0;
1081 info_out_entry_ptr
= 0;
1083 /* loop till all the entries in in array are not processed */
1084 while (current_in_entry
< sep_in_lli_entries
) {
1085 /* set the new input and output tables */
1086 in_lli_table_ptr
= (struct sep_lli_entry_t
*) lli_table_alloc_addr
;
1088 lli_table_alloc_addr
+= sizeof(struct sep_lli_entry_t
) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP
;
1090 /* set the first output tables */
1091 out_lli_table_ptr
= (struct sep_lli_entry_t
*) lli_table_alloc_addr
;
1093 lli_table_alloc_addr
+= sizeof(struct sep_lli_entry_t
) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP
;
1095 /* calculate the maximum size of data for input table */
1096 in_table_data_size
= sep_calculate_lli_table_max_size(&lli_in_array
[current_in_entry
], (sep_in_lli_entries
- current_in_entry
));
1098 /* calculate the maximum size of data for output table */
1099 out_table_data_size
= sep_calculate_lli_table_max_size(&lli_out_array
[current_out_entry
], (sep_out_lli_entries
- current_out_entry
));
1101 edbg("SEP Driver:in_table_data_size is %lu\n", in_table_data_size
);
1102 edbg("SEP Driver:out_table_data_size is %lu\n", out_table_data_size
);
1104 /* check where the data is smallest */
1105 table_data_size
= in_table_data_size
;
1106 if (table_data_size
> out_table_data_size
)
1107 table_data_size
= out_table_data_size
;
1109 /* now calculate the table size so that it will be module block size */
1110 table_data_size
= (table_data_size
/ block_size
) * block_size
;
1112 dbg("SEP Driver:table_data_size is %lu\n", table_data_size
);
1114 /* construct input lli table */
1115 sep_build_lli_table(&lli_in_array
[current_in_entry
], in_lli_table_ptr
, ¤t_in_entry
, &num_entries_in_table
, table_data_size
);
1117 /* construct output lli table */
1118 sep_build_lli_table(&lli_out_array
[current_out_entry
], out_lli_table_ptr
, ¤t_out_entry
, &num_entries_out_table
, table_data_size
);
1120 /* if info entry is null - this is the first table built */
1121 if (info_in_entry_ptr
== 0) {
1122 /* set the output parameters to physical addresses */
1123 *lli_table_in_ptr
= sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr
);
1124 *in_num_entries_ptr
= num_entries_in_table
;
1125 *lli_table_out_ptr
= sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr
);
1126 *out_num_entries_ptr
= num_entries_out_table
;
1127 *table_data_size_ptr
= table_data_size
;
1129 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr
);
1130 edbg("SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr
);
1132 /* update the info entry of the previous in table */
1133 info_in_entry_ptr
->physical_address
= sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr
);
1134 info_in_entry_ptr
->block_size
= ((num_entries_in_table
) << 24) | (table_data_size
);
1136 /* update the info entry of the previous in table */
1137 info_out_entry_ptr
->physical_address
= sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr
);
1138 info_out_entry_ptr
->block_size
= ((num_entries_out_table
) << 24) | (table_data_size
);
1141 /* save the pointer to the info entry of the current tables */
1142 info_in_entry_ptr
= in_lli_table_ptr
+ num_entries_in_table
- 1;
1143 info_out_entry_ptr
= out_lli_table_ptr
+ num_entries_out_table
- 1;
1145 edbg("SEP Driver:output num_entries_out_table is %lu\n", (unsigned long) num_entries_out_table
);
1146 edbg("SEP Driver:output info_in_entry_ptr is %lu\n", (unsigned long) info_in_entry_ptr
);
1147 edbg("SEP Driver:output info_out_entry_ptr is %lu\n", (unsigned long) info_out_entry_ptr
);
1150 /* print input tables */
1151 sep_debug_print_lli_tables((struct sep_lli_entry_t
*)
1152 sep_shared_area_phys_to_virt(*lli_table_in_ptr
), *in_num_entries_ptr
, *table_data_size_ptr
);
1153 /* print output tables */
1154 sep_debug_print_lli_tables((struct sep_lli_entry_t
*)
1155 sep_shared_area_phys_to_virt(*lli_table_out_ptr
), *out_num_entries_ptr
, *table_data_size_ptr
);
1156 dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n");
1161 this function calculates the size of data that can be inserted into the lli
1162 table from this array the condition is that either the table is full
1163 (all etnries are entered), or there are no more entries in the lli array
1165 unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t
*lli_in_array_ptr
, unsigned long num_array_entries
)
1167 unsigned long table_data_size
= 0;
1168 unsigned long counter
;
1170 /* calculate the data in the out lli table if till we fill the whole
1171 table or till the data has ended */
1172 for (counter
= 0; (counter
< (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP
- 1)) && (counter
< num_array_entries
); counter
++)
1173 table_data_size
+= lli_in_array_ptr
[counter
].block_size
;
1174 return table_data_size
;
1178 this functions builds ont lli table from the lli_array according to
1179 the given size of data
1181 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
)
1183 unsigned long curr_table_data_size
;
1184 /* counter of lli array entry */
1185 unsigned long array_counter
;
1187 dbg("SEP Driver:--------> sep_build_lli_table start\n");
1189 /* init currrent table data size and lli array entry counter */
1190 curr_table_data_size
= 0;
1192 *num_table_entries_ptr
= 1;
1194 edbg("SEP Driver:table_data_size is %lu\n", table_data_size
);
1196 /* fill the table till table size reaches the needed amount */
1197 while (curr_table_data_size
< table_data_size
) {
1198 /* update the number of entries in table */
1199 (*num_table_entries_ptr
)++;
1201 lli_table_ptr
->physical_address
= lli_array_ptr
[array_counter
].physical_address
;
1202 lli_table_ptr
->block_size
= lli_array_ptr
[array_counter
].block_size
;
1203 curr_table_data_size
+= lli_table_ptr
->block_size
;
1205 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr
);
1206 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr
->physical_address
);
1207 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr
->block_size
);
1209 /* check for overflow of the table data */
1210 if (curr_table_data_size
> table_data_size
) {
1211 edbg("SEP Driver:curr_table_data_size > table_data_size\n");
1213 /* update the size of block in the table */
1214 lli_table_ptr
->block_size
-= (curr_table_data_size
- table_data_size
);
1216 /* update the physical address in the lli array */
1217 lli_array_ptr
[array_counter
].physical_address
+= lli_table_ptr
->block_size
;
1219 /* update the block size left in the lli array */
1220 lli_array_ptr
[array_counter
].block_size
= (curr_table_data_size
- table_data_size
);
1222 /* advance to the next entry in the lli_array */
1225 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr
->physical_address
);
1226 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr
->block_size
);
1228 /* move to the next entry in table */
1232 /* set the info entry to default */
1233 lli_table_ptr
->physical_address
= 0xffffffff;
1234 lli_table_ptr
->block_size
= 0;
1236 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr
);
1237 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr
->physical_address
);
1238 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr
->block_size
);
1240 /* set the output parameter */
1241 *num_processed_entries_ptr
+= array_counter
;
1243 edbg("SEP Driver:*num_processed_entries_ptr is %lu\n", *num_processed_entries_ptr
);
1244 dbg("SEP Driver:<-------- sep_build_lli_table end\n");
1249 this function goes over the list of the print created tables and
1252 static void sep_debug_print_lli_tables(struct sep_lli_entry_t
*lli_table_ptr
, unsigned long num_table_entries
, unsigned long table_data_size
)
1254 unsigned long table_count
;
1255 unsigned long entries_count
;
1257 dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n");
1260 while ((unsigned long) lli_table_ptr
!= 0xffffffff) {
1261 edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", table_count
, table_data_size
);
1262 edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries
);
1264 /* print entries of the table (without info entry) */
1265 for (entries_count
= 0; entries_count
< num_table_entries
; entries_count
++, lli_table_ptr
++) {
1266 edbg("SEP Driver:lli_table_ptr address is %08lx\n", (unsigned long) lli_table_ptr
);
1267 edbg("SEP Driver:phys address is %08lx block size is %lu\n", lli_table_ptr
->physical_address
, lli_table_ptr
->block_size
);
1270 /* point to the info entry */
1273 edbg("SEP Driver:phys lli_table_ptr->block_size is %lu\n", lli_table_ptr
->block_size
);
1274 edbg("SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", lli_table_ptr
->physical_address
);
1277 table_data_size
= lli_table_ptr
->block_size
& 0xffffff;
1278 num_table_entries
= (lli_table_ptr
->block_size
>> 24) & 0xff;
1279 lli_table_ptr
= (struct sep_lli_entry_t
*)
1280 (lli_table_ptr
->physical_address
);
1282 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
);
1284 if ((unsigned long) lli_table_ptr
!= 0xffffffff)
1285 lli_table_ptr
= (struct sep_lli_entry_t
*) sep_shared_area_phys_to_virt((unsigned long) lli_table_ptr
);
1289 dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n");
1294 This function locks all the physical pages of the application virtual buffer
1295 and construct a basic lli array, where each entry holds the physical page
1296 address and the size that application data holds in this physical pages
1298 int sep_lock_user_pages(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
)
1301 /* the the page of the end address of the user space buffer */
1302 unsigned long end_page
;
1303 /* the page of the start address of the user space buffer */
1304 unsigned long start_page
;
1305 /* the range in pages */
1306 unsigned long num_pages
;
1307 struct page
**page_array
;
1308 struct sep_lli_entry_t
*lli_array
;
1309 unsigned long count
;
1312 dbg("SEP Driver:--------> sep_lock_user_pages start\n");
1314 /* set start and end pages and num pages */
1315 end_page
= (app_virt_addr
+ data_size
- 1) >> PAGE_SHIFT
;
1316 start_page
= app_virt_addr
>> PAGE_SHIFT
;
1317 num_pages
= end_page
- start_page
+ 1;
1319 edbg("SEP Driver: app_virt_addr is %08lx\n", app_virt_addr
);
1320 edbg("SEP Driver: data_size is %lu\n", data_size
);
1321 edbg("SEP Driver: start_page is %lu\n", start_page
);
1322 edbg("SEP Driver: end_page is %lu\n", end_page
);
1323 edbg("SEP Driver: num_pages is %lu\n", num_pages
);
1325 /* allocate array of pages structure pointers */
1326 page_array
= kmalloc(sizeof(struct page
*) * num_pages
, GFP_ATOMIC
);
1328 edbg("SEP Driver: kmalloc for page_array failed\n");
1334 lli_array
= kmalloc(sizeof(struct sep_lli_entry_t
) * num_pages
, GFP_ATOMIC
);
1336 edbg("SEP Driver: kmalloc for lli_array failed\n");
1339 goto end_function_with_error1
;
1342 /* convert the application virtual address into a set of physical */
1343 down_read(¤t
->mm
->mmap_sem
);
1344 result
= get_user_pages(current
, current
->mm
, app_virt_addr
, num_pages
, 1, 0, page_array
, 0);
1345 up_read(¤t
->mm
->mmap_sem
);
1347 /* check the number of pages locked - if not all then exit with error */
1348 if (result
!= num_pages
) {
1349 dbg("SEP Driver: not all pages locked by get_user_pages\n");
1352 goto end_function_with_error2
;
1355 /* flush the cache */
1356 for (count
= 0; count
< num_pages
; count
++)
1357 flush_dcache_page(page_array
[count
]);
1359 /* set the start address of the first page - app data may start not at
1360 the beginning of the page */
1361 lli_array
[0].physical_address
= ((unsigned long) page_to_phys(page_array
[0])) + (app_virt_addr
& (~PAGE_MASK
));
1363 /* check that not all the data is in the first page only */
1364 if ((PAGE_SIZE
- (app_virt_addr
& (~PAGE_MASK
))) >= data_size
)
1365 lli_array
[0].block_size
= data_size
;
1367 lli_array
[0].block_size
= PAGE_SIZE
- (app_virt_addr
& (~PAGE_MASK
));
1370 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
);
1372 /* go from the second page to the prev before last */
1373 for (count
= 1; count
< (num_pages
- 1); count
++) {
1374 lli_array
[count
].physical_address
= (unsigned long) page_to_phys(page_array
[count
]);
1375 lli_array
[count
].block_size
= PAGE_SIZE
;
1377 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
);
1380 /* if more then 1 pages locked - then update for the last page size needed */
1381 if (num_pages
> 1) {
1382 /* update the address of the last page */
1383 lli_array
[count
].physical_address
= (unsigned long) page_to_phys(page_array
[count
]);
1385 /* set the size of the last page */
1386 lli_array
[count
].block_size
= (app_virt_addr
+ data_size
) & (~PAGE_MASK
);
1388 if (lli_array
[count
].block_size
== 0) {
1389 dbg("app_virt_addr is %08lx\n", app_virt_addr
);
1390 dbg("data_size is %lu\n", data_size
);
1393 edbg("lli_array[%lu].physical_address is %08lx, \
1394 lli_array[%lu].block_size is %lu\n", count
, lli_array
[count
].physical_address
, count
, lli_array
[count
].block_size
);
1397 /* set output params */
1398 *lli_array_ptr
= lli_array
;
1399 *num_pages_ptr
= num_pages
;
1400 *page_array_ptr
= page_array
;
1403 end_function_with_error2
:
1404 /* release the cache */
1405 for (count
= 0; count
< num_pages
; count
++)
1406 page_cache_release(page_array
[count
]);
1408 end_function_with_error1
:
1411 dbg("SEP Driver:<-------- sep_lock_user_pages end\n");
1416 This function locks all the physical pages of the kernel virtual buffer
1417 and construct a basic lli array, where each entry holds the physical
1418 page address and the size that application data holds in this physical pages
1420 int sep_lock_kernel_pages(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
)
1423 /* the the page of the end address of the user space buffer */
1424 unsigned long end_page
;
1425 /* the page of the start address of the user space buffer */
1426 unsigned long start_page
;
1427 /* the range in pages */
1428 unsigned long num_pages
;
1429 struct sep_lli_entry_t
*lli_array
;
1430 /* next kernel address to map */
1431 unsigned long next_kernel_address
;
1432 unsigned long count
;
1434 dbg("SEP Driver:--------> sep_lock_kernel_pages start\n");
1436 /* set start and end pages and num pages */
1437 end_page
= (kernel_virt_addr
+ data_size
- 1) >> PAGE_SHIFT
;
1438 start_page
= kernel_virt_addr
>> PAGE_SHIFT
;
1439 num_pages
= end_page
- start_page
+ 1;
1441 edbg("SEP Driver: kernel_virt_addr is %08lx\n", kernel_virt_addr
);
1442 edbg("SEP Driver: data_size is %lu\n", data_size
);
1443 edbg("SEP Driver: start_page is %lx\n", start_page
);
1444 edbg("SEP Driver: end_page is %lx\n", end_page
);
1445 edbg("SEP Driver: num_pages is %lu\n", num_pages
);
1447 lli_array
= kmalloc(sizeof(struct sep_lli_entry_t
) * num_pages
, GFP_ATOMIC
);
1449 edbg("SEP Driver: kmalloc for lli_array failed\n");
1454 /* set the start address of the first page - app data may start not at
1455 the beginning of the page */
1456 lli_array
[0].physical_address
= (unsigned long) virt_to_phys((unsigned long *) kernel_virt_addr
);
1458 /* check that not all the data is in the first page only */
1459 if ((PAGE_SIZE
- (kernel_virt_addr
& (~PAGE_MASK
))) >= data_size
)
1460 lli_array
[0].block_size
= data_size
;
1462 lli_array
[0].block_size
= PAGE_SIZE
- (kernel_virt_addr
& (~PAGE_MASK
));
1465 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
);
1467 /* advance the address to the start of the next page */
1468 next_kernel_address
= (kernel_virt_addr
& PAGE_MASK
) + PAGE_SIZE
;
1470 /* go from the second page to the prev before last */
1471 for (count
= 1; count
< (num_pages
- 1); count
++) {
1472 lli_array
[count
].physical_address
= (unsigned long) virt_to_phys((unsigned long *) next_kernel_address
);
1473 lli_array
[count
].block_size
= PAGE_SIZE
;
1475 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
);
1476 next_kernel_address
+= PAGE_SIZE
;
1479 /* if more then 1 pages locked - then update for the last page size needed */
1480 if (num_pages
> 1) {
1481 /* update the address of the last page */
1482 lli_array
[count
].physical_address
= (unsigned long) virt_to_phys((unsigned long *) next_kernel_address
);
1484 /* set the size of the last page */
1485 lli_array
[count
].block_size
= (kernel_virt_addr
+ data_size
) & (~PAGE_MASK
);
1487 if (lli_array
[count
].block_size
== 0) {
1488 dbg("app_virt_addr is %08lx\n", kernel_virt_addr
);
1489 dbg("data_size is %lu\n", data_size
);
1493 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
);
1495 /* set output params */
1496 *lli_array_ptr
= lli_array
;
1497 *num_pages_ptr
= num_pages
;
1498 *page_array_ptr
= 0;
1500 dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n");
1505 This function releases all the application virtual buffer physical pages,
1506 that were previously locked
1508 int sep_free_dma_pages(struct page
**page_array_ptr
, unsigned long num_pages
, unsigned long dirtyFlag
)
1510 unsigned long count
;
1513 for (count
= 0; count
< num_pages
; count
++) {
1514 /* the out array was written, therefore the data was changed */
1515 if (!PageReserved(page_array_ptr
[count
]))
1516 SetPageDirty(page_array_ptr
[count
]);
1517 page_cache_release(page_array_ptr
[count
]);
1520 /* free in pages - the data was only read, therefore no update was done
1522 for (count
= 0; count
< num_pages
; count
++)
1523 page_cache_release(page_array_ptr
[count
]);
1527 /* free the array */
1528 kfree(page_array_ptr
);
1534 This function raises interrupt to SEP that signals that is has a new
1537 static void sep_send_command_handler()
1539 unsigned long count
;
1541 dbg("SEP Driver:--------> sep_send_command_handler start\n");
1547 for (count
= 0; count
< 12 * 4; count
+= 4)
1548 edbg("Word %lu of the message is %lu\n", count
, *((unsigned long *) (sep_dev
->shared_area_addr
+ count
)));
1550 /* update counter */
1551 sep_dev
->host_to_sep_send_counter
++;
1552 /* send interrupt to SEP */
1553 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR0_REG_ADDR
, 0x2);
1554 dbg("SEP Driver:<-------- sep_send_command_handler end\n");
1559 This function raises interrupt to SEPm that signals that is has a
1560 new command from HOST
1562 static void sep_send_reply_command_handler()
1564 unsigned long count
;
1566 dbg("SEP Driver:--------> sep_send_reply_command_handler start\n");
1570 for (count
= 0; count
< 12 * 4; count
+= 4)
1571 edbg("Word %lu of the message is %lu\n", count
, *((unsigned long *) (sep_dev
->shared_area_addr
+ count
)));
1572 /* update counter */
1573 sep_dev
->host_to_sep_send_counter
++;
1574 /* send the interrupt to SEP */
1575 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR2_REG_ADDR
, sep_dev
->host_to_sep_send_counter
);
1576 /* update both counters */
1577 sep_dev
->host_to_sep_send_counter
++;
1578 sep_dev
->sep_to_host_reply_counter
++;
1579 dbg("SEP Driver:<-------- sep_send_reply_command_handler end\n");
1585 This function handles the allocate data pool memory request
1586 This function returns calculates the physical address of the
1587 allocated memory, and the offset of this area from the mapped address.
1588 Therefore, the FVOs in user space can calculate the exact virtual
1589 address of this allocated memory
1591 static int sep_allocate_data_pool_memory_handler(unsigned long arg
)
1594 struct sep_driver_alloc_t command_args
;
1596 dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n");
1598 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_alloc_t
));
1602 /* allocate memory */
1603 if ((sep_dev
->data_pool_bytes_allocated
+ command_args
.num_bytes
) > SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES
) {
1608 /* set the virtual and physical address */
1609 command_args
.offset
= SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES
+ sep_dev
->data_pool_bytes_allocated
;
1610 command_args
.phys_address
= sep_dev
->phys_shared_area_addr
+ SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES
+ sep_dev
->data_pool_bytes_allocated
;
1612 /* write the memory back to the user space */
1613 error
= copy_to_user((void *) arg
, (void *) &command_args
, sizeof(struct sep_driver_alloc_t
));
1617 /* set the allocation */
1618 sep_dev
->data_pool_bytes_allocated
+= command_args
.num_bytes
;
1621 dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n");
1626 This function handles write into allocated data pool command
1628 static int sep_write_into_data_pool_handler(unsigned long arg
)
1631 unsigned long virt_address
;
1632 unsigned long app_in_address
;
1633 unsigned long num_bytes
;
1634 unsigned long data_pool_area_addr
;
1636 dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n");
1638 /* get the application address */
1639 error
= get_user(app_in_address
, &(((struct sep_driver_write_t
*) arg
)->app_address
));
1643 /* get the virtual kernel address address */
1644 error
= get_user(virt_address
, &(((struct sep_driver_write_t
*) arg
)->datapool_address
));
1648 /* get the number of bytes */
1649 error
= get_user(num_bytes
, &(((struct sep_driver_write_t
*) arg
)->num_bytes
));
1653 /* calculate the start of the data pool */
1654 data_pool_area_addr
= sep_dev
->shared_area_addr
+ SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES
;
1657 /* check that the range of the virtual kernel address is correct */
1658 if ((virt_address
< data_pool_area_addr
) || (virt_address
> (data_pool_area_addr
+ SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES
))) {
1662 /* copy the application data */
1663 error
= copy_from_user((void *) virt_address
, (void *) app_in_address
, num_bytes
);
1665 dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n");
1670 this function handles the read from data pool command
1672 static int sep_read_from_data_pool_handler(unsigned long arg
)
1675 /* virtual address of dest application buffer */
1676 unsigned long app_out_address
;
1677 /* virtual address of the data pool */
1678 unsigned long virt_address
;
1679 unsigned long num_bytes
;
1680 unsigned long data_pool_area_addr
;
1682 dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n");
1684 /* get the application address */
1685 error
= get_user(app_out_address
, &(((struct sep_driver_write_t
*) arg
)->app_address
));
1689 /* get the virtual kernel address address */
1690 error
= get_user(virt_address
, &(((struct sep_driver_write_t
*) arg
)->datapool_address
));
1694 /* get the number of bytes */
1695 error
= get_user(num_bytes
, &(((struct sep_driver_write_t
*) arg
)->num_bytes
));
1699 /* calculate the start of the data pool */
1700 data_pool_area_addr
= sep_dev
->shared_area_addr
+ SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES
;
1702 /* check that the range of the virtual kernel address is correct */
1703 if ((virt_address
< data_pool_area_addr
) || (virt_address
> (data_pool_area_addr
+ SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES
))) {
1708 /* copy the application data */
1709 error
= copy_to_user((void *) app_out_address
, (void *) virt_address
, num_bytes
);
1711 dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n");
1717 this function handles tha request for creation of the DMA table
1718 for the synchronic symmetric operations (AES,DES)
1720 static int sep_create_sync_dma_tables_handler(unsigned long arg
)
1723 /* command arguments */
1724 struct sep_driver_build_sync_table_t command_args
;
1726 dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n");
1728 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_build_sync_table_t
));
1732 edbg("app_in_address is %08lx\n", command_args
.app_in_address
);
1733 edbg("app_out_address is %08lx\n", command_args
.app_out_address
);
1734 edbg("data_size is %lu\n", command_args
.data_in_size
);
1735 edbg("block_size is %lu\n", command_args
.block_size
);
1737 /* check if we need to build only input table or input/output */
1738 if (command_args
.app_out_address
)
1739 /* prepare input and output tables */
1740 error
= sep_prepare_input_output_dma_table(command_args
.app_in_address
,
1741 command_args
.app_out_address
,
1742 command_args
.data_in_size
,
1743 command_args
.block_size
,
1744 &command_args
.in_table_address
,
1745 &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
);
1747 /* prepare input tables */
1748 error
= sep_prepare_input_dma_table(command_args
.app_in_address
,
1749 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
);
1754 error
= copy_to_user((void *) arg
, (void *) &command_args
, sizeof(struct sep_driver_build_sync_table_t
));
1756 dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n");
1761 this function handles the request for freeing dma table for synhronic actions
1763 int sep_free_dma_table_data_handler()
1765 dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n");
1767 /* free input pages array */
1768 sep_free_dma_pages(sep_dev
->in_page_array
, sep_dev
->in_num_pages
, 0);
1770 /* free output pages array if needed */
1771 if (sep_dev
->out_page_array
)
1772 sep_free_dma_pages(sep_dev
->out_page_array
, sep_dev
->out_num_pages
, 1);
1774 /* reset all the values */
1775 sep_dev
->in_page_array
= 0;
1776 sep_dev
->out_page_array
= 0;
1777 sep_dev
->in_num_pages
= 0;
1778 sep_dev
->out_num_pages
= 0;
1779 dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n");
1784 this function handles the request to create the DMA tables for flow
1786 static int sep_create_flow_dma_tables_handler(unsigned long arg
)
1789 struct sep_driver_build_flow_table_t command_args
;
1790 /* first table - output */
1791 struct sep_lli_entry_t first_table_data
;
1792 /* dma table data */
1793 struct sep_lli_entry_t last_table_data
;
1794 /* pointer to the info entry of the previuos DMA table */
1795 struct sep_lli_entry_t
*prev_info_entry_ptr
;
1796 /* pointer to the flow data strucutre */
1797 struct sep_flow_context_t
*flow_context_ptr
;
1799 dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n");
1801 /* init variables */
1802 prev_info_entry_ptr
= 0;
1803 first_table_data
.physical_address
= 0xffffffff;
1805 /* find the free structure for flow data */
1806 error
= sep_find_flow_context(SEP_FREE_FLOW_ID
, &flow_context_ptr
);
1810 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_build_flow_table_t
));
1814 /* create flow tables */
1815 error
= sep_prepare_flow_dma_tables(command_args
.num_virtual_buffers
, command_args
.virt_buff_data_addr
, flow_context_ptr
, &first_table_data
, &last_table_data
, command_args
.isKernelVirtualAddress
);
1817 goto end_function_with_error
;
1819 /* check if flow is static */
1820 if (!command_args
.flow_type
)
1821 /* point the info entry of the last to the info entry of the first */
1822 last_table_data
= first_table_data
;
1824 /* set output params */
1825 command_args
.first_table_addr
= first_table_data
.physical_address
;
1826 command_args
.first_table_num_entries
= ((first_table_data
.block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
) & SEP_NUM_ENTRIES_MASK
);
1827 command_args
.first_table_data_size
= (first_table_data
.block_size
& SEP_TABLE_DATA_SIZE_MASK
);
1829 /* send the parameters to user application */
1830 error
= copy_to_user((void *) arg
, &command_args
, sizeof(struct sep_driver_build_flow_table_t
));
1832 goto end_function_with_error
;
1834 /* all the flow created - update the flow entry with temp id */
1835 flow_context_ptr
->flow_id
= SEP_TEMP_FLOW_ID
;
1837 /* set the processing tables data in the context */
1838 if (command_args
.input_output_flag
== SEP_DRIVER_IN_FLAG
)
1839 flow_context_ptr
->input_tables_in_process
= first_table_data
;
1841 flow_context_ptr
->output_tables_in_process
= first_table_data
;
1845 end_function_with_error
:
1846 /* free the allocated tables */
1847 sep_deallocated_flow_tables(&first_table_data
);
1849 dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n");
1854 this functio n handles add tables to flow
1856 static int sep_add_flow_tables_handler(unsigned long arg
)
1859 unsigned long num_entries
;
1860 struct sep_driver_add_flow_table_t command_args
;
1861 struct sep_flow_context_t
*flow_context_ptr
;
1862 /* first dma table data */
1863 struct sep_lli_entry_t first_table_data
;
1864 /* last dma table data */
1865 struct sep_lli_entry_t last_table_data
;
1866 /* pointer to the info entry of the current DMA table */
1867 struct sep_lli_entry_t
*info_entry_ptr
;
1869 dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n");
1871 /* get input parameters */
1872 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_add_flow_table_t
));
1876 /* find the flow structure for the flow id */
1877 error
= sep_find_flow_context(command_args
.flow_id
, &flow_context_ptr
);
1881 /* prepare the flow dma tables */
1882 error
= sep_prepare_flow_dma_tables(command_args
.num_virtual_buffers
, command_args
.virt_buff_data_addr
, flow_context_ptr
, &first_table_data
, &last_table_data
, command_args
.isKernelVirtualAddress
);
1884 goto end_function_with_error
;
1886 /* now check if there is already an existing add table for this flow */
1887 if (command_args
.inputOutputFlag
== SEP_DRIVER_IN_FLAG
) {
1888 /* this buffer was for input buffers */
1889 if (flow_context_ptr
->input_tables_flag
) {
1890 /* add table already exists - add the new tables to the end
1892 num_entries
= (flow_context_ptr
->last_input_table
.block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
) & SEP_NUM_ENTRIES_MASK
;
1894 info_entry_ptr
= (struct sep_lli_entry_t
*)
1895 (flow_context_ptr
->last_input_table
.physical_address
+ (sizeof(struct sep_lli_entry_t
) * (num_entries
- 1)));
1897 /* connect to list of tables */
1898 *info_entry_ptr
= first_table_data
;
1900 /* set the first table data */
1901 first_table_data
= flow_context_ptr
->first_input_table
;
1903 /* set the input flag */
1904 flow_context_ptr
->input_tables_flag
= 1;
1906 /* set the first table data */
1907 flow_context_ptr
->first_input_table
= first_table_data
;
1909 /* set the last table data */
1910 flow_context_ptr
->last_input_table
= last_table_data
;
1911 } else { /* this is output tables */
1913 /* this buffer was for input buffers */
1914 if (flow_context_ptr
->output_tables_flag
) {
1915 /* add table already exists - add the new tables to
1916 the end of the previous */
1917 num_entries
= (flow_context_ptr
->last_output_table
.block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
) & SEP_NUM_ENTRIES_MASK
;
1919 info_entry_ptr
= (struct sep_lli_entry_t
*)
1920 (flow_context_ptr
->last_output_table
.physical_address
+ (sizeof(struct sep_lli_entry_t
) * (num_entries
- 1)));
1922 /* connect to list of tables */
1923 *info_entry_ptr
= first_table_data
;
1925 /* set the first table data */
1926 first_table_data
= flow_context_ptr
->first_output_table
;
1928 /* set the input flag */
1929 flow_context_ptr
->output_tables_flag
= 1;
1931 /* set the first table data */
1932 flow_context_ptr
->first_output_table
= first_table_data
;
1934 /* set the last table data */
1935 flow_context_ptr
->last_output_table
= last_table_data
;
1938 /* set output params */
1939 command_args
.first_table_addr
= first_table_data
.physical_address
;
1940 command_args
.first_table_num_entries
= ((first_table_data
.block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
) & SEP_NUM_ENTRIES_MASK
);
1941 command_args
.first_table_data_size
= (first_table_data
.block_size
& SEP_TABLE_DATA_SIZE_MASK
);
1943 /* send the parameters to user application */
1944 error
= copy_to_user((void *) arg
, &command_args
, sizeof(struct sep_driver_add_flow_table_t
));
1946 goto end_function_with_error
;
1948 end_function_with_error
:
1949 /* free the allocated tables */
1950 sep_deallocated_flow_tables(&first_table_data
);
1952 dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n");
1957 this function add the flow add message to the specific flow
1959 static int sep_add_flow_tables_message_handler(unsigned long arg
)
1962 struct sep_driver_add_message_t command_args
;
1963 struct sep_flow_context_t
*flow_context_ptr
;
1965 dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n");
1967 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_add_message_t
));
1972 if (command_args
.message_size_in_bytes
> SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES
) {
1977 /* find the flow context */
1978 error
= sep_find_flow_context(command_args
.flow_id
, &flow_context_ptr
);
1982 /* copy the message into context */
1983 flow_context_ptr
->message_size_in_bytes
= command_args
.message_size_in_bytes
;
1984 error
= copy_from_user(flow_context_ptr
->message
, (void *) command_args
.message_address
, command_args
.message_size_in_bytes
);
1986 dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n");
1992 this function returns the physical and virtual addresses of the static pool
1994 static int sep_get_static_pool_addr_handler(unsigned long arg
)
1997 struct sep_driver_static_pool_addr_t command_args
;
1999 dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n");
2001 /*prepare the output parameters in the struct */
2002 command_args
.physical_static_address
= sep_dev
->phys_shared_area_addr
+ SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES
;
2003 command_args
.virtual_static_address
= sep_dev
->shared_area_addr
+ SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES
;
2005 edbg("SEP Driver:physical_static_address is %08lx, virtual_static_address %08lx\n", command_args
.physical_static_address
, command_args
.virtual_static_address
);
2007 /* send the parameters to user application */
2008 error
= copy_to_user((void *) arg
, &command_args
, sizeof(struct sep_driver_static_pool_addr_t
));
2012 dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n");
2017 this address gets the offset of the physical address from the start
2020 static int sep_get_physical_mapped_offset_handler(unsigned long arg
)
2023 struct sep_driver_get_mapped_offset_t command_args
;
2025 dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n");
2027 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_get_mapped_offset_t
));
2031 if (command_args
.physical_address
< sep_dev
->phys_shared_area_addr
) {
2036 /*prepare the output parameters in the struct */
2037 command_args
.offset
= command_args
.physical_address
- sep_dev
->phys_shared_area_addr
;
2039 edbg("SEP Driver:physical_address is %08lx, offset is %lu\n", command_args
.physical_address
, command_args
.offset
);
2041 /* send the parameters to user application */
2042 error
= copy_to_user((void *) arg
, &command_args
, sizeof(struct sep_driver_get_mapped_offset_t
));
2046 dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n");
2054 static int sep_start_handler(void)
2056 unsigned long reg_val
;
2057 unsigned long error
= 0;
2059 dbg("SEP Driver:--------> sep_start_handler start\n");
2061 /* wait in polling for message from SEP */
2063 reg_val
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR3_REG_ADDR
);
2066 /* check the value */
2067 if (reg_val
== 0x1) {
2068 /* fatal error - read erro status from GPRO */
2069 error
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR0_REG_ADDR
);
2073 dbg("SEP Driver:<-------- sep_start_handler end\n");
2078 this function handles the request for SEP initialization
2080 static int sep_init_handler(unsigned long arg
)
2082 unsigned long message_word
;
2083 unsigned long *message_ptr
;
2084 struct sep_driver_init_t command_args
;
2085 unsigned long counter
;
2086 unsigned long error
;
2087 unsigned long reg_val
;
2089 dbg("SEP Driver:--------> sep_init_handler start\n");
2092 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_init_t
));
2094 dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user \n");
2099 /* PATCH - configure the DMA to single -burst instead of multi-burst */
2100 /*sep_configure_dma_burst(); */
2102 dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n");
2104 message_ptr
= (unsigned long *) command_args
.message_addr
;
2106 /* set the base address of the SRAM */
2107 sep_write_reg(sep_dev
, HW_SRAM_ADDR_REG_ADDR
, HW_CC_SRAM_BASE_ADDRESS
);
2109 for (counter
= 0; counter
< command_args
.message_size_in_words
; counter
++, message_ptr
++) {
2110 get_user(message_word
, message_ptr
);
2111 /* write data to SRAM */
2112 sep_write_reg(sep_dev
, HW_SRAM_DATA_REG_ADDR
, message_word
);
2113 edbg("SEP Driver:message_word is %lu\n", message_word
);
2114 /* wait for write complete */
2115 sep_wait_sram_write(sep_dev
);
2117 dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n");
2119 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR0_REG_ADDR
, 0x1);
2122 reg_val
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR3_REG_ADDR
);
2123 while (!(reg_val
& 0xFFFFFFFD));
2125 dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n");
2127 /* check the value */
2128 if (reg_val
== 0x1) {
2129 edbg("SEP Driver:init failed\n");
2131 error
= sep_read_reg(sep_dev
, 0x8060);
2132 edbg("SEP Driver:sw monitor is %lu\n", error
);
2134 /* fatal error - read erro status from GPRO */
2135 error
= sep_read_reg(sep_dev
, HW_HOST_SEP_HOST_GPR0_REG_ADDR
);
2136 edbg("SEP Driver:error is %lu\n", error
);
2140 dbg("SEP Driver:<-------- sep_init_handler end\n");
2146 this function handles the request cache and resident reallocation
2148 static int sep_realloc_cache_resident_handler(unsigned long arg
)
2151 unsigned long phys_cache_address
;
2152 unsigned long phys_resident_address
;
2153 struct sep_driver_realloc_cache_resident_t command_args
;
2156 error
= copy_from_user(&command_args
, (void *) arg
, sizeof(struct sep_driver_realloc_cache_resident_t
));
2160 /* copy cache and resident to the their intended locations */
2161 error
= sep_copy_cache_resident_to_area(command_args
.cache_addr
, command_args
.cache_size_in_bytes
, command_args
.resident_addr
, command_args
.resident_size_in_bytes
, &phys_cache_address
, &phys_resident_address
);
2165 /* lock the area (if needed) */
2166 sep_lock_cache_resident_area();
2168 command_args
.new_base_addr
= sep_dev
->phys_shared_area_addr
;
2170 /* find the new base address according to the lowest address between
2171 cache, resident and shared area */
2172 if (phys_resident_address
< command_args
.new_base_addr
)
2173 command_args
.new_base_addr
= phys_resident_address
;
2174 if (phys_cache_address
< command_args
.new_base_addr
)
2175 command_args
.new_base_addr
= phys_cache_address
;
2177 /* set the return parameters */
2178 command_args
.new_cache_addr
= phys_cache_address
;
2179 command_args
.new_resident_addr
= phys_resident_address
;
2181 /* set the new shared area */
2182 command_args
.new_shared_area_addr
= sep_dev
->phys_shared_area_addr
;
2184 edbg("SEP Driver:command_args.new_shared_area_addr is %08lx\n", command_args
.new_shared_area_addr
);
2185 edbg("SEP Driver:command_args.new_base_addr is %08lx\n", command_args
.new_base_addr
);
2186 edbg("SEP Driver:command_args.new_resident_addr is %08lx\n", command_args
.new_resident_addr
);
2187 edbg("SEP Driver:command_args.new_cache_addr is %08lx\n", command_args
.new_cache_addr
);
2189 /* return to user */
2190 error
= copy_to_user((void *) arg
, (void *) &command_args
, sizeof(struct sep_driver_realloc_cache_resident_t
));
2196 this function handles the request for get time
2198 static int sep_get_time_handler(unsigned long arg
)
2201 struct sep_driver_get_time_t command_args
;
2203 error
= sep_set_time(&command_args
.time_physical_address
, &command_args
.time_value
);
2204 error
= copy_to_user((void *) arg
, (void *) &command_args
, sizeof(struct sep_driver_get_time_t
));
2210 This api handles the setting of API mode to blocking or non-blocking
2212 static int sep_set_api_mode_handler(unsigned long arg
)
2215 unsigned long mode_flag
;
2217 dbg("SEP Driver:--------> sep_set_api_mode_handler start\n");
2219 error
= get_user(mode_flag
, &(((struct sep_driver_set_api_mode_t
*) arg
)->mode
));
2223 /* set the global flag */
2224 sep_dev
->block_mode_flag
= mode_flag
;
2226 dbg("SEP Driver:<-------- sep_set_api_mode_handler end\n");
2231 This API handles the end transaction request
2233 static int sep_end_transaction_handler(unsigned long arg
)
2235 dbg("SEP Driver:--------> sep_end_transaction_handler start\n");
2237 #if 0 /*!SEP_DRIVER_POLLING_MODE */
2239 sep_write_reg(sep_dev
, HW_HOST_IMR_REG_ADDR
, 0x7FFF);
2241 /* release IRQ line */
2242 free_irq(SEP_DIRVER_IRQ_NUM
, &sep_dev
->reg_base_address
);
2244 /* lock the sep mutex */
2245 mutex_unlock(&sep_mutex
);
2248 dbg("SEP Driver:<-------- sep_end_transaction_handler end\n");
2253 /* handler for flow done interrupt */
2254 static void sep_flow_done_handler(struct work_struct
*work
)
2256 struct sep_flow_context_t
*flow_data_ptr
;
2258 /* obtain the mutex */
2259 mutex_lock(&sep_mutex
);
2261 /* get the pointer to context */
2262 flow_data_ptr
= (struct sep_flow_context_t
*) work
;
2264 /* free all the current input tables in sep */
2265 sep_deallocated_flow_tables(&flow_data_ptr
->input_tables_in_process
);
2267 /* free all the current tables output tables in SEP (if needed) */
2268 if (flow_data_ptr
->output_tables_in_process
.physical_address
!= 0xffffffff)
2269 sep_deallocated_flow_tables(&flow_data_ptr
->output_tables_in_process
);
2271 /* check if we have additional tables to be sent to SEP only input
2272 flag may be checked */
2273 if (flow_data_ptr
->input_tables_flag
) {
2274 /* copy the message to the shared RAM and signal SEP */
2275 memcpy((void *) flow_data_ptr
->message
, (void *) sep_dev
->shared_area_addr
, flow_data_ptr
->message_size_in_bytes
);
2277 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR2_REG_ADDR
, 0x2);
2279 mutex_unlock(&sep_mutex
);
2284 This function creates a list of tables for flow and returns the data for
2285 the first and last tables of the list
2287 static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers
,
2288 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
)
2291 unsigned long virt_buff_addr
;
2292 unsigned long virt_buff_size
;
2293 struct sep_lli_entry_t table_data
;
2294 struct sep_lli_entry_t
*info_entry_ptr
;
2295 struct sep_lli_entry_t
*prev_info_entry_ptr
;
2300 prev_info_entry_ptr
= 0;
2302 /* init the first table to default */
2303 table_data
.physical_address
= 0xffffffff;
2304 first_table_data_ptr
->physical_address
= 0xffffffff;
2305 table_data
.block_size
= 0;
2307 for (i
= 0; i
< num_virtual_buffers
; i
++) {
2308 /* get the virtual buffer address */
2309 error
= get_user(virt_buff_addr
, &first_buff_addr
);
2313 /* get the virtual buffer size */
2315 error
= get_user(virt_buff_size
, &first_buff_addr
);
2319 /* advance the address to point to the next pair of address|size */
2322 /* now prepare the one flow LLI table from the data */
2323 error
= sep_prepare_one_flow_dma_table(virt_buff_addr
, virt_buff_size
, &table_data
, &info_entry_ptr
, flow_data_ptr
, isKernelVirtualAddress
);
2328 /* if this is the first table - save it to return to the user
2330 *first_table_data_ptr
= table_data
;
2332 /* set the pointer to info entry */
2333 prev_info_entry_ptr
= info_entry_ptr
;
2335 /* not first table - the previous table info entry should
2337 prev_info_entry_ptr
->block_size
= (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS
) | (table_data
.block_size
);
2339 /* set the pointer to info entry */
2340 prev_info_entry_ptr
= info_entry_ptr
;
2344 /* set the last table data */
2345 *last_table_data_ptr
= table_data
;
2352 This function creates one DMA table for flow and returns its data,
2353 and pointer to its info entry
2355 static int sep_prepare_one_flow_dma_table(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
)
2358 /* the range in pages */
2359 unsigned long lli_array_size
;
2360 struct sep_lli_entry_t
*lli_array
;
2361 struct sep_lli_entry_t
*flow_dma_table_entry_ptr
;
2362 unsigned long *start_dma_table_ptr
;
2363 /* total table data counter */
2364 unsigned long dma_table_data_count
;
2365 /* pointer that will keep the pointer to the pages of the virtual buffer */
2366 struct page
**page_array_ptr
;
2367 unsigned long entry_count
;
2369 /* find the space for the new table */
2370 error
= sep_find_free_flow_dma_table_space(&start_dma_table_ptr
);
2374 /* check if the pages are in Kernel Virtual Address layout */
2375 if (isKernelVirtualAddress
== true)
2376 /* lock kernel buffer in the memory */
2377 error
= sep_lock_kernel_pages(virt_buff_addr
, virt_buff_size
, &lli_array_size
, &lli_array
, &page_array_ptr
);
2379 /* lock user buffer in the memory */
2380 error
= sep_lock_user_pages(virt_buff_addr
, virt_buff_size
, &lli_array_size
, &lli_array
, &page_array_ptr
);
2385 /* set the pointer to page array at the beginning of table - this table is
2386 now considered taken */
2387 *start_dma_table_ptr
= lli_array_size
;
2389 /* point to the place of the pages pointers of the table */
2390 start_dma_table_ptr
++;
2392 /* set the pages pointer */
2393 *start_dma_table_ptr
= (unsigned long) page_array_ptr
;
2395 /* set the pointer to the first entry */
2396 flow_dma_table_entry_ptr
= (struct sep_lli_entry_t
*) (++start_dma_table_ptr
);
2398 /* now create the entries for table */
2399 for (dma_table_data_count
= entry_count
= 0; entry_count
< lli_array_size
; entry_count
++) {
2400 flow_dma_table_entry_ptr
->physical_address
= lli_array
[entry_count
].physical_address
;
2402 flow_dma_table_entry_ptr
->block_size
= lli_array
[entry_count
].block_size
;
2404 /* set the total data of a table */
2405 dma_table_data_count
+= lli_array
[entry_count
].block_size
;
2407 flow_dma_table_entry_ptr
++;
2410 /* set the physical address */
2411 table_data
->physical_address
= virt_to_phys(start_dma_table_ptr
);
2413 /* set the num_entries and total data size */
2414 table_data
->block_size
= ((lli_array_size
+ 1) << SEP_NUM_ENTRIES_OFFSET_IN_BITS
) | (dma_table_data_count
);
2416 /* set the info entry */
2417 flow_dma_table_entry_ptr
->physical_address
= 0xffffffff;
2418 flow_dma_table_entry_ptr
->block_size
= 0;
2420 /* set the pointer to info entry */
2421 *info_entry_ptr
= flow_dma_table_entry_ptr
;
2423 /* the array of the lli entries */
2431 This function returns pointer to the flow data structure
2432 that contains the given id
2434 static int sep_find_flow_context(unsigned long flow_id
, struct sep_flow_context_t
**flow_data_ptr
)
2436 unsigned long count
;
2440 always search for flow with id default first - in case we
2441 already started working on the flow there can be no situation
2442 when 2 flows are with default flag
2444 for (count
= 0; count
< SEP_DRIVER_NUM_FLOWS
; count
++) {
2445 if (sep_dev
->flows_data_array
[count
].flow_id
== flow_id
) {
2446 *flow_data_ptr
= &sep_dev
->flows_data_array
[count
];
2451 if (count
== SEP_DRIVER_NUM_FLOWS
)
2459 this function find a space for the new flow dma table
2461 static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr
)
2464 /* pointer to the id field of the flow dma table */
2465 unsigned long *start_table_ptr
;
2466 unsigned long flow_dma_area_start_addr
;
2467 unsigned long flow_dma_area_end_addr
;
2468 /* maximum table size in words */
2469 unsigned long table_size_in_words
;
2471 /* find the start address of the flow DMA table area */
2472 flow_dma_area_start_addr
= sep_dev
->shared_area_addr
+ SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES
;
2474 /* set end address of the flow table area */
2475 flow_dma_area_end_addr
= flow_dma_area_start_addr
+ SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES
;
2477 /* set table size in words */
2478 table_size_in_words
= SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE
* (sizeof(struct sep_lli_entry_t
) / sizeof(long)) + 2;
2480 /* set the pointer to the start address of DMA area */
2481 start_table_ptr
= (unsigned long *) flow_dma_area_start_addr
;
2483 /* find the space for the next table */
2484 while (((*start_table_ptr
& 0x7FFFFFFF) != 0) && ((unsigned long) start_table_ptr
< flow_dma_area_end_addr
))
2485 start_table_ptr
+= table_size_in_words
;
2487 /* check if we reached the end of floa tables area */
2488 if ((unsigned long) start_table_ptr
>= flow_dma_area_end_addr
)
2491 *table_address_ptr
= start_table_ptr
;
2497 this function goes over all the flow tables connected to the given
2498 table and deallocate them
2500 static void sep_deallocated_flow_tables(struct sep_lli_entry_t
*first_table_ptr
)
2503 unsigned long *table_ptr
;
2504 /* end address of the flow dma area */
2505 unsigned long num_entries
;
2506 unsigned long num_pages
;
2507 struct page
**pages_ptr
;
2508 /* maximum table size in words */
2509 struct sep_lli_entry_t
*info_entry_ptr
;
2511 /* set the pointer to the first table */
2512 table_ptr
= (unsigned long *) first_table_ptr
->physical_address
;
2514 /* set the num of entries */
2515 num_entries
= (first_table_ptr
->block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
)
2516 & SEP_NUM_ENTRIES_MASK
;
2518 /* go over all the connected tables */
2519 while (*table_ptr
!= 0xffffffff) {
2520 /* get number of pages */
2521 num_pages
= *(table_ptr
- 2);
2523 /* get the pointer to the pages */
2524 pages_ptr
= (struct page
**) (*(table_ptr
- 1));
2526 /* free the pages */
2527 sep_free_dma_pages(pages_ptr
, num_pages
, 1);
2529 /* goto to the info entry */
2530 info_entry_ptr
= ((struct sep_lli_entry_t
*) table_ptr
) + (num_entries
- 1);
2532 table_ptr
= (unsigned long *) info_entry_ptr
->physical_address
;
2533 num_entries
= (info_entry_ptr
->block_size
>> SEP_NUM_ENTRIES_OFFSET_IN_BITS
) & SEP_NUM_ENTRIES_MASK
;
2540 This function handler the set flow id command
2542 static int sep_set_flow_id_handler(unsigned long arg
)
2545 unsigned long flow_id
;
2546 struct sep_flow_context_t
*flow_data_ptr
;
2548 dbg("------------>SEP Driver: sep_set_flow_id_handler start\n");
2550 error
= get_user(flow_id
, &(((struct sep_driver_set_flow_id_t
*) arg
)->flow_id
));
2554 /* find the flow data structure that was just used for creating new flow
2555 - its id should be default */
2556 error
= sep_find_flow_context(SEP_TEMP_FLOW_ID
, &flow_data_ptr
);
2561 flow_data_ptr
->flow_id
= flow_id
;
2564 dbg("SEP Driver:<-------- sep_set_flow_id_handler end\n");
2570 calculates time and sets it at the predefined address
2572 static int sep_set_time(unsigned long *address_ptr
, unsigned long *time_in_sec_ptr
)
2574 struct timeval time
;
2575 /* address of time in the kernel */
2576 unsigned long time_addr
;
2579 dbg("SEP Driver:--------> sep_set_time start\n");
2581 do_gettimeofday(&time
);
2583 /* set value in the SYSTEM MEMORY offset */
2584 time_addr
= sep_dev
->message_shared_area_addr
+ SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES
;
2586 *(unsigned long *) time_addr
= SEP_TIME_VAL_TOKEN
;
2587 *(unsigned long *) (time_addr
+ 4) = time
.tv_sec
;
2589 edbg("SEP Driver:time.tv_sec is %lu\n", time
.tv_sec
);
2590 edbg("SEP Driver:time_addr is %lu\n", time_addr
);
2591 edbg("SEP Driver:g_message_shared_area_addr is %lu\n", sep_dev
->message_shared_area_addr
);
2593 /* set the output parameters if needed */
2595 *address_ptr
= sep_shared_area_virt_to_phys(time_addr
);
2597 if (time_in_sec_ptr
)
2598 *time_in_sec_ptr
= time
.tv_sec
;
2600 dbg("SEP Driver:<-------- sep_set_time end\n");
2605 static void sep_wait_busy(struct sep_device
*dev
)
2610 reg
= sep_read_reg(sep_dev
, HW_HOST_SEP_BUSY_REG_ADDR
);
2615 PATCH for configuring the DMA to single burst instead of multi-burst
2617 static void sep_configure_dma_burst(void)
2619 #define HW_AHB_RD_WR_BURSTS_REG_ADDR 0x0E10UL
2621 dbg("SEP Driver:<-------- sep_configure_dma_burst start \n");
2623 /* request access to registers from SEP */
2624 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR0_REG_ADDR
, 0x2);
2626 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n");
2628 sep_wait_busy(sep_dev
);
2630 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n");
2632 /* set the DMA burst register to single burst */
2633 sep_write_reg(sep_dev
, HW_AHB_RD_WR_BURSTS_REG_ADDR
, 0x0UL
);
2635 /* release the sep busy */
2636 sep_write_reg(sep_dev
, HW_HOST_HOST_SEP_GPR0_REG_ADDR
, 0x0UL
);
2637 sep_wait_busy(sep_dev
);
2639 dbg("SEP Driver:<-------- sep_configure_dma_burst done \n");
2643 module_init(sep_init
);
2644 module_exit(sep_exit
);
2646 MODULE_LICENSE("GPL");