3 * sep_driver.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>
38 #include <linux/sched.h>
40 #include <linux/poll.h>
41 #include <linux/wait.h>
42 #include <linux/sched.h>
43 #include <linux/pci.h>
44 #include <linux/firmware.h>
45 #include <asm/ioctl.h>
46 #include <linux/ioport.h>
48 #include <linux/interrupt.h>
49 #include <linux/pagemap.h>
50 #include <asm/cacheflush.h>
51 #include "sep_driver_hw_defs.h"
52 #include "sep_driver_config.h"
53 #include "sep_driver_api.h"
56 #if SEP_DRIVER_ARM_DEBUG_MODE
58 #define CRYS_SEP_ROM_length 0x4000
59 #define CRYS_SEP_ROM_start_address 0x8000C000UL
60 #define CRYS_SEP_ROM_start_address_offset 0xC000UL
61 #define SEP_ROM_BANK_register 0x80008420UL
62 #define SEP_ROM_BANK_register_offset 0x8420UL
63 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0x82000000
66 * THESE 2 definitions are specific to the board - must be
67 * defined during integration
69 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0xFF0D0000
73 static void sep_load_rom_code(struct sep_device *sep)
76 unsigned long i, k, j;
81 /* Loading ROM from SEP_ROM_image.h file */
82 k = sizeof(CRYS_SEP_ROM);
84 edbg("SEP Driver: DX_CC_TST_SepRomLoader start\n");
86 edbg("SEP Driver: k is %lu\n", k);
87 edbg("SEP Driver: sep->reg_addr is %p\n", sep->reg_addr);
88 edbg("SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", CRYS_SEP_ROM_start_address_offset);
90 for (i = 0; i < 4; i++) {
92 sep_write_reg(sep, SEP_ROM_BANK_register_offset, i);
94 for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) {
95 sep_write_reg(sep, CRYS_SEP_ROM_start_address_offset + 4 * j, CRYS_SEP_ROM[i * 0x1000 + j]);
100 j = CRYS_SEP_ROM_length;
107 sep_write_reg(sep, HW_HOST_SEP_SW_RST_REG_ADDR, 0x1);
109 /* poll for SEP ROM boot finish */
111 reg = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
114 edbg("SEP Driver: ROM polling ended\n");
118 /* fatal error - read erro status from GPRO */
119 error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
120 edbg("SEP Driver: ROM polling case 1\n");
123 /* Cold boot ended successfully */
125 /* Warmboot ended successfully */
127 /* ColdWarm boot ended successfully */
130 /* Boot First Phase ended */
131 warning = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
133 edbg("SEP Driver: ROM polling case %d\n", reg);
140 static void sep_load_rom_code(struct sep_device *sep) { }
141 #endif /* SEP_DRIVER_ARM_DEBUG_MODE */
145 /*----------------------------------------
147 -----------------------------------------*/
149 #define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000
150 #define SEP_RAR_IO_MEM_REGION_SIZE 0x40000
152 /*--------------------------------------------
154 --------------------------------------------*/
156 /* debug messages level */
158 module_param(debug, int , 0);
159 MODULE_PARM_DESC(debug, "Flag to enable SEP debug messages");
161 /* Keep this a single static object for now to keep the conversion easy */
163 static struct sep_device sep_instance;
164 static struct sep_device *sep_dev = &sep_instance;
167 mutex for the access to the internals of the sep driver
169 static DEFINE_MUTEX(sep_mutex);
172 /* wait queue head (event) of the driver */
173 static DECLARE_WAIT_QUEUE_HEAD(sep_event);
176 * sep_load_firmware - copy firmware cache/resident
177 * @sep: device we are loading
179 * This functions copies the cache and resident from their source
180 * location into destination shared memory.
183 static int sep_load_firmware(struct sep_device *sep)
185 const struct firmware *fw;
186 char *cache_name = "sep/cache.image.bin";
187 char *res_name = "sep/resident.image.bin";
190 edbg("SEP Driver:rar_virtual is %p\n", sep->rar_addr);
191 edbg("SEP Driver:rar_bus is %08llx\n", (unsigned long long)sep->rar_bus);
194 error = request_firmware(&fw, cache_name, &sep->pdev->dev);
196 edbg("SEP Driver:cant request cache fw\n");
199 edbg("SEP Driver:cache %08Zx@%p\n", fw->size, (void *) fw->data);
201 memcpy(sep->rar_addr, (void *)fw->data, fw->size);
202 sep->cache_size = fw->size;
203 release_firmware(fw);
205 sep->resident_bus = sep->rar_bus + sep->cache_size;
206 sep->resident_addr = sep->rar_addr + sep->cache_size;
209 error = request_firmware(&fw, res_name, &sep->pdev->dev);
211 edbg("SEP Driver:cant request res fw\n");
214 edbg("sep: res %08Zx@%p\n", fw->size, (void *)fw->data);
216 memcpy(sep->resident_addr, (void *) fw->data, fw->size);
217 sep->resident_size = fw->size;
218 release_firmware(fw);
220 edbg("sep: resident v %p b %08llx cache v %p b %08llx\n",
221 sep->resident_addr, (unsigned long long)sep->resident_bus,
222 sep->rar_addr, (unsigned long long)sep->rar_bus);
226 MODULE_FIRMWARE("sep/cache.image.bin");
227 MODULE_FIRMWARE("sep/resident.image.bin");
230 * sep_map_and_alloc_shared_area - allocate shared block
231 * @sep: security processor
232 * @size: size of shared area
234 * Allocate a shared buffer in host memory that can be used by both the
235 * kernel and also the hardware interface via DMA.
238 static int sep_map_and_alloc_shared_area(struct sep_device *sep,
241 /* shared_addr = ioremap_nocache(0xda00000,shared_area_size); */
242 sep->shared_addr = dma_alloc_coherent(&sep->pdev->dev, size,
243 &sep->shared_bus, GFP_KERNEL);
245 if (!sep->shared_addr) {
246 edbg("sep_driver :shared memory dma_alloc_coherent failed\n");
249 /* set the bus address of the shared area */
250 edbg("sep: shared_addr %ld bytes @%p (bus %08llx)\n",
251 size, sep->shared_addr, (unsigned long long)sep->shared_bus);
256 * sep_unmap_and_free_shared_area - free shared block
257 * @sep: security processor
259 * Free the shared area allocated to the security processor. The
260 * processor must have finished with this and any final posted
261 * writes cleared before we do so.
263 static void sep_unmap_and_free_shared_area(struct sep_device *sep, int size)
265 dma_free_coherent(&sep->pdev->dev, size,
266 sep->shared_addr, sep->shared_bus);
270 * sep_shared_virt_to_bus - convert bus/virt addresses
272 * Returns the bus address inside the shared area according
273 * to the virtual address.
276 static dma_addr_t sep_shared_virt_to_bus(struct sep_device *sep,
279 dma_addr_t pa = sep->shared_bus + (virt_address - sep->shared_addr);
280 edbg("sep: virt to bus b %08llx v %p\n", (unsigned long long) pa,
286 * sep_shared_bus_to_virt - convert bus/virt addresses
288 * Returns virtual address inside the shared area according
289 * to the bus address.
292 static void *sep_shared_bus_to_virt(struct sep_device *sep,
293 dma_addr_t bus_address)
295 return sep->shared_addr + (bus_address - sep->shared_bus);
300 * sep_try_open - attempt to open a SEP device
301 * @sep: device to attempt to open
303 * Atomically attempt to get ownership of a SEP device.
304 * Returns 1 if the device was opened, 0 on failure.
307 static int sep_try_open(struct sep_device *sep)
309 if (!test_and_set_bit(0, &sep->in_use))
315 * sep_open - device open method
316 * @inode: inode of sep device
317 * @filp: file handle to sep device
319 * Open method for the SEP device. Called when userspace opens
320 * the SEP device node. Must also release the memory data pool
323 * Returns zero on success otherwise an error code.
326 static int sep_open(struct inode *inode, struct file *filp)
331 /* check the blocking mode */
332 if (filp->f_flags & O_NDELAY) {
333 if (sep_try_open(sep_dev) == 0)
336 if (wait_event_interruptible(sep_event, sep_try_open(sep_dev)) < 0)
339 /* Bind to the device, we only have one which makes it easy */
340 filp->private_data = sep_dev;
341 /* release data pool allocations */
342 sep_dev->data_pool_bytes_allocated = 0;
348 * sep_release - close a SEP device
349 * @inode: inode of SEP device
350 * @filp: file handle being closed
352 * Called on the final close of a SEP device. As the open protects against
353 * multiple simultaenous opens that means this method is called when the
354 * final reference to the open handle is dropped.
357 static int sep_release(struct inode *inode, struct file *filp)
359 struct sep_device *sep = filp->private_data;
360 #if 0 /*!SEP_DRIVER_POLLING_MODE */
362 sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, 0x7FFF);
363 /* release IRQ line */
364 free_irq(SEP_DIRVER_IRQ_NUM, sep);
367 /* Ensure any blocked open progresses */
368 clear_bit(0, &sep->in_use);
373 /*---------------------------------------------------------------
374 map function - this functions maps the message shared area
375 -----------------------------------------------------------------*/
376 static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
379 struct sep_device *sep = filp->private_data;
381 dbg("-------->SEP Driver: mmap start\n");
383 /* check that the size of the mapped range is as the size of the message
385 if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) {
386 edbg("SEP Driver mmap requested size is more than allowed\n");
387 printk(KERN_WARNING "SEP Driver mmap requested size is more than allowed\n");
388 printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_end);
389 printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_start);
393 edbg("SEP Driver:sep->shared_addr is %p\n", sep->shared_addr);
395 /* get bus address */
396 bus_addr = sep->shared_bus;
398 edbg("SEP Driver: phys_addr is %08llx\n", (unsigned long long)bus_addr);
400 if (remap_pfn_range(vma, vma->vm_start, bus_addr >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
401 edbg("SEP Driver remap_page_range failed\n");
402 printk(KERN_WARNING "SEP Driver remap_page_range failed\n");
406 dbg("SEP Driver:<-------- mmap end\n");
412 /*-----------------------------------------------
414 *----------------------------------------------*/
415 static unsigned int sep_poll(struct file *filp, poll_table * wait)
418 unsigned int mask = 0;
419 unsigned long retval = 0; /* flow id */
420 struct sep_device *sep = filp->private_data;
422 dbg("---------->SEP Driver poll: start\n");
425 #if SEP_DRIVER_POLLING_MODE
427 while (sep->send_ct != (retval & 0x7FFFFFFF)) {
428 retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
430 for (count = 0; count < 10 * 4; count += 4)
431 edbg("Poll Debug Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count)));
436 /* add the event to the polling wait table */
437 poll_wait(filp, &sep_event, wait);
441 edbg("sep->send_ct is %lu\n", sep->send_ct);
442 edbg("sep->reply_ct is %lu\n", sep->reply_ct);
444 /* check if the data is ready */
445 if (sep->send_ct == sep->reply_ct) {
446 for (count = 0; count < 12 * 4; count += 4)
447 edbg("Sep Mesg Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + count)));
449 for (count = 0; count < 10 * 4; count += 4)
450 edbg("Debug Data Word %lu of the message is %lu\n", count, *((unsigned long *) (sep->shared_addr + 0x1800 + count)));
452 retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
453 edbg("retval is %lu\n", retval);
454 /* check if the this is sep reply or request */
456 edbg("SEP Driver: sep request in\n");
458 mask |= POLLOUT | POLLWRNORM;
460 edbg("SEP Driver: sep reply in\n");
461 mask |= POLLIN | POLLRDNORM;
464 dbg("SEP Driver:<-------- poll exit\n");
469 * sep_time_address - address in SEP memory of time
470 * @sep: SEP device we want the address from
472 * Return the address of the two dwords in memory used for time
476 static u32 *sep_time_address(struct sep_device *sep)
478 return sep->shared_addr + SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES;
482 * sep_set_time - set the SEP time
483 * @sep: the SEP we are setting the time for
485 * Calculates time and sets it at the predefined address.
486 * Called with the sep mutex held.
488 static unsigned long sep_set_time(struct sep_device *sep)
491 u32 *time_addr; /* address of time as seen by the kernel */
494 dbg("sep:sep_set_time start\n");
496 do_gettimeofday(&time);
498 /* set value in the SYSTEM MEMORY offset */
499 time_addr = sep_time_address(sep);
501 time_addr[0] = SEP_TIME_VAL_TOKEN;
502 time_addr[1] = time.tv_sec;
504 edbg("SEP Driver:time.tv_sec is %lu\n", time.tv_sec);
505 edbg("SEP Driver:time_addr is %p\n", time_addr);
506 edbg("SEP Driver:sep->shared_addr is %p\n", sep->shared_addr);
512 * sep_dump_message - dump the message that is pending
515 * Dump out the message pending in the shared message area
518 static void sep_dump_message(struct sep_device *sep)
521 for (count = 0; count < 12 * 4; count += 4)
522 edbg("Word %d of the message is %u\n", count, *((u32 *) (sep->shared_addr + count)));
526 * sep_send_command_handler - kick off a command
527 * @sep: sep being signalled
529 * This function raises interrupt to SEP that signals that is has a new
530 * command from the host
533 static void sep_send_command_handler(struct sep_device *sep)
535 dbg("sep:sep_send_command_handler start\n");
537 mutex_lock(&sep_mutex);
540 /* FIXME: flush cache */
543 sep_dump_message(sep);
546 /* send interrupt to SEP */
547 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
548 dbg("SEP Driver:<-------- sep_send_command_handler end\n");
549 mutex_unlock(&sep_mutex);
554 * sep_send_reply_command_handler - kick off a command reply
555 * @sep: sep being signalled
557 * This function raises interrupt to SEP that signals that is has a new
558 * command from the host
561 static void sep_send_reply_command_handler(struct sep_device *sep)
563 dbg("sep:sep_send_reply_command_handler start\n");
568 sep_dump_message(sep);
570 mutex_lock(&sep_mutex);
571 sep->send_ct++; /* update counter */
572 /* send the interrupt to SEP */
573 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR, sep->send_ct);
574 /* update both counters */
577 mutex_unlock(&sep_mutex);
578 dbg("sep: sep_send_reply_command_handler end\n");
582 This function handles the allocate data pool memory request
583 This function returns calculates the bus address of the
584 allocated memory, and the offset of this area from the mapped address.
585 Therefore, the FVOs in user space can calculate the exact virtual
586 address of this allocated memory
588 static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
592 struct sep_driver_alloc_t command_args;
594 dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n");
596 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_alloc_t));
600 /* allocate memory */
601 if ((sep->data_pool_bytes_allocated + command_args.num_bytes) > SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) {
606 /* set the virtual and bus address */
607 command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep->data_pool_bytes_allocated;
608 command_args.phys_address = sep->shared_bus + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep->data_pool_bytes_allocated;
610 /* write the memory back to the user space */
611 error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_alloc_t));
615 /* set the allocation */
616 sep->data_pool_bytes_allocated += command_args.num_bytes;
619 dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n");
624 This function handles write into allocated data pool command
626 static int sep_write_into_data_pool_handler(struct sep_device *sep, unsigned long arg)
631 unsigned long app_in_address;
632 unsigned long num_bytes;
633 void *data_pool_area_addr;
635 dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n");
637 /* get the application address */
638 error = get_user(app_in_address, &(((struct sep_driver_write_t *) arg)->app_address));
642 /* get the virtual kernel address address */
643 error = get_user(va, &(((struct sep_driver_write_t *) arg)->datapool_address));
646 virt_address = (void *)va;
648 /* get the number of bytes */
649 error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes));
653 /* calculate the start of the data pool */
654 data_pool_area_addr = sep->shared_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
657 /* check that the range of the virtual kernel address is correct */
658 if (virt_address < data_pool_area_addr || virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES)) {
662 /* copy the application data */
663 error = copy_from_user(virt_address, (void *) app_in_address, num_bytes);
665 dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n");
670 this function handles the read from data pool command
672 static int sep_read_from_data_pool_handler(struct sep_device *sep, unsigned long arg)
675 /* virtual address of dest application buffer */
676 unsigned long app_out_address;
677 /* virtual address of the data pool */
680 unsigned long num_bytes;
681 void *data_pool_area_addr;
683 dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n");
685 /* get the application address */
686 error = get_user(app_out_address, &(((struct sep_driver_write_t *) arg)->app_address));
690 /* get the virtual kernel address address */
691 error = get_user(va, &(((struct sep_driver_write_t *) arg)->datapool_address));
694 virt_address = (void *)va;
696 /* get the number of bytes */
697 error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes));
701 /* calculate the start of the data pool */
702 data_pool_area_addr = sep->shared_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
704 /* FIXME: These are incomplete all over the driver: what about + len
705 and when doing that also overflows */
706 /* check that the range of the virtual kernel address is correct */
707 if (virt_address < data_pool_area_addr || virt_address > data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) {
712 /* copy the application data */
713 error = copy_to_user((void *) app_out_address, virt_address, num_bytes);
715 dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n");
720 This function releases all the application virtual buffer physical pages,
721 that were previously locked
723 static int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag)
728 for (count = 0; count < num_pages; count++) {
729 /* the out array was written, therefore the data was changed */
730 if (!PageReserved(page_array_ptr[count]))
731 SetPageDirty(page_array_ptr[count]);
732 page_cache_release(page_array_ptr[count]);
735 /* free in pages - the data was only read, therefore no update was done
737 for (count = 0; count < num_pages; count++)
738 page_cache_release(page_array_ptr[count]);
743 kfree(page_array_ptr);
749 This function locks all the physical pages of the kernel virtual buffer
750 and construct a basic lli array, where each entry holds the physical
751 page address and the size that application data holds in this physical pages
753 static int sep_lock_kernel_pages(struct sep_device *sep,
754 unsigned long kernel_virt_addr,
755 unsigned long data_size,
756 unsigned long *num_pages_ptr,
757 struct sep_lli_entry_t **lli_array_ptr,
758 struct page ***page_array_ptr)
761 /* the the page of the end address of the user space buffer */
762 unsigned long end_page;
763 /* the page of the start address of the user space buffer */
764 unsigned long start_page;
765 /* the range in pages */
766 unsigned long num_pages;
767 struct sep_lli_entry_t *lli_array;
768 /* next kernel address to map */
769 unsigned long next_kernel_address;
772 dbg("SEP Driver:--------> sep_lock_kernel_pages start\n");
774 /* set start and end pages and num pages */
775 end_page = (kernel_virt_addr + data_size - 1) >> PAGE_SHIFT;
776 start_page = kernel_virt_addr >> PAGE_SHIFT;
777 num_pages = end_page - start_page + 1;
779 edbg("SEP Driver: kernel_virt_addr is %08lx\n", kernel_virt_addr);
780 edbg("SEP Driver: data_size is %lu\n", data_size);
781 edbg("SEP Driver: start_page is %lx\n", start_page);
782 edbg("SEP Driver: end_page is %lx\n", end_page);
783 edbg("SEP Driver: num_pages is %lu\n", num_pages);
785 lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC);
787 edbg("SEP Driver: kmalloc for lli_array failed\n");
792 /* set the start address of the first page - app data may start not at
793 the beginning of the page */
794 lli_array[0].physical_address = (unsigned long) virt_to_phys((unsigned long *) kernel_virt_addr);
796 /* check that not all the data is in the first page only */
797 if ((PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK))) >= data_size)
798 lli_array[0].block_size = data_size;
800 lli_array[0].block_size = PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK));
803 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);
805 /* advance the address to the start of the next page */
806 next_kernel_address = (kernel_virt_addr & PAGE_MASK) + PAGE_SIZE;
808 /* go from the second page to the prev before last */
809 for (count = 1; count < (num_pages - 1); count++) {
810 lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address);
811 lli_array[count].block_size = PAGE_SIZE;
813 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);
814 next_kernel_address += PAGE_SIZE;
817 /* if more then 1 pages locked - then update for the last page size needed */
819 /* update the address of the last page */
820 lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address);
822 /* set the size of the last page */
823 lli_array[count].block_size = (kernel_virt_addr + data_size) & (~PAGE_MASK);
825 if (lli_array[count].block_size == 0) {
826 dbg("app_virt_addr is %08lx\n", kernel_virt_addr);
827 dbg("data_size is %lu\n", data_size);
831 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);
833 /* set output params */
834 *lli_array_ptr = lli_array;
835 *num_pages_ptr = num_pages;
838 dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n");
843 This function locks all the physical pages of the application virtual buffer
844 and construct a basic lli array, where each entry holds the physical page
845 address and the size that application data holds in this physical pages
847 static int sep_lock_user_pages(struct sep_device *sep,
848 unsigned long app_virt_addr,
849 unsigned long data_size,
850 unsigned long *num_pages_ptr,
851 struct sep_lli_entry_t **lli_array_ptr,
852 struct page ***page_array_ptr)
855 /* the the page of the end address of the user space buffer */
856 unsigned long end_page;
857 /* the page of the start address of the user space buffer */
858 unsigned long start_page;
859 /* the range in pages */
860 unsigned long num_pages;
861 struct page **page_array;
862 struct sep_lli_entry_t *lli_array;
866 dbg("SEP Driver:--------> sep_lock_user_pages start\n");
868 /* set start and end pages and num pages */
869 end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
870 start_page = app_virt_addr >> PAGE_SHIFT;
871 num_pages = end_page - start_page + 1;
873 edbg("SEP Driver: app_virt_addr is %08lx\n", app_virt_addr);
874 edbg("SEP Driver: data_size is %lu\n", data_size);
875 edbg("SEP Driver: start_page is %lu\n", start_page);
876 edbg("SEP Driver: end_page is %lu\n", end_page);
877 edbg("SEP Driver: num_pages is %lu\n", num_pages);
879 /* allocate array of pages structure pointers */
880 page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
882 edbg("SEP Driver: kmalloc for page_array failed\n");
888 lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC);
890 edbg("SEP Driver: kmalloc for lli_array failed\n");
893 goto end_function_with_error1;
896 /* convert the application virtual address into a set of physical */
897 down_read(¤t->mm->mmap_sem);
898 result = get_user_pages(current, current->mm, app_virt_addr, num_pages, 1, 0, page_array, 0);
899 up_read(¤t->mm->mmap_sem);
901 /* check the number of pages locked - if not all then exit with error */
902 if (result != num_pages) {
903 dbg("SEP Driver: not all pages locked by get_user_pages\n");
906 goto end_function_with_error2;
909 /* flush the cache */
910 for (count = 0; count < num_pages; count++)
911 flush_dcache_page(page_array[count]);
913 /* set the start address of the first page - app data may start not at
914 the beginning of the page */
915 lli_array[0].physical_address = ((unsigned long) page_to_phys(page_array[0])) + (app_virt_addr & (~PAGE_MASK));
917 /* check that not all the data is in the first page only */
918 if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size)
919 lli_array[0].block_size = data_size;
921 lli_array[0].block_size = PAGE_SIZE - (app_virt_addr & (~PAGE_MASK));
924 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);
926 /* go from the second page to the prev before last */
927 for (count = 1; count < (num_pages - 1); count++) {
928 lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]);
929 lli_array[count].block_size = PAGE_SIZE;
931 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);
934 /* if more then 1 pages locked - then update for the last page size needed */
936 /* update the address of the last page */
937 lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]);
939 /* set the size of the last page */
940 lli_array[count].block_size = (app_virt_addr + data_size) & (~PAGE_MASK);
942 if (lli_array[count].block_size == 0) {
943 dbg("app_virt_addr is %08lx\n", app_virt_addr);
944 dbg("data_size is %lu\n", data_size);
947 edbg("lli_array[%lu].physical_address is %08lx, lli_array[%lu].block_size is %lu\n",
948 count, lli_array[count].physical_address,
949 count, lli_array[count].block_size);
952 /* set output params */
953 *lli_array_ptr = lli_array;
954 *num_pages_ptr = num_pages;
955 *page_array_ptr = page_array;
958 end_function_with_error2:
959 /* release the cache */
960 for (count = 0; count < num_pages; count++)
961 page_cache_release(page_array[count]);
963 end_function_with_error1:
966 dbg("SEP Driver:<-------- sep_lock_user_pages end\n");
972 this function calculates the size of data that can be inserted into the lli
973 table from this array the condition is that either the table is full
974 (all etnries are entered), or there are no more entries in the lli array
976 static unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t *lli_in_array_ptr, unsigned long num_array_entries)
978 unsigned long table_data_size = 0;
979 unsigned long counter;
981 /* calculate the data in the out lli table if till we fill the whole
982 table or till the data has ended */
983 for (counter = 0; (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) && (counter < num_array_entries); counter++)
984 table_data_size += lli_in_array_ptr[counter].block_size;
985 return table_data_size;
989 this functions builds ont lli table from the lli_array according to
990 the given size of data
992 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)
994 unsigned long curr_table_data_size;
995 /* counter of lli array entry */
996 unsigned long array_counter;
998 dbg("SEP Driver:--------> sep_build_lli_table start\n");
1000 /* init currrent table data size and lli array entry counter */
1001 curr_table_data_size = 0;
1003 *num_table_entries_ptr = 1;
1005 edbg("SEP Driver:table_data_size is %lu\n", table_data_size);
1007 /* fill the table till table size reaches the needed amount */
1008 while (curr_table_data_size < table_data_size) {
1009 /* update the number of entries in table */
1010 (*num_table_entries_ptr)++;
1012 lli_table_ptr->physical_address = lli_array_ptr[array_counter].physical_address;
1013 lli_table_ptr->block_size = lli_array_ptr[array_counter].block_size;
1014 curr_table_data_size += lli_table_ptr->block_size;
1016 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr);
1017 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1018 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1020 /* check for overflow of the table data */
1021 if (curr_table_data_size > table_data_size) {
1022 edbg("SEP Driver:curr_table_data_size > table_data_size\n");
1024 /* update the size of block in the table */
1025 lli_table_ptr->block_size -= (curr_table_data_size - table_data_size);
1027 /* update the physical address in the lli array */
1028 lli_array_ptr[array_counter].physical_address += lli_table_ptr->block_size;
1030 /* update the block size left in the lli array */
1031 lli_array_ptr[array_counter].block_size = (curr_table_data_size - table_data_size);
1033 /* advance to the next entry in the lli_array */
1036 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1037 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1039 /* move to the next entry in table */
1043 /* set the info entry to default */
1044 lli_table_ptr->physical_address = 0xffffffff;
1045 lli_table_ptr->block_size = 0;
1047 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr);
1048 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1049 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1051 /* set the output parameter */
1052 *num_processed_entries_ptr += array_counter;
1054 edbg("SEP Driver:*num_processed_entries_ptr is %lu\n", *num_processed_entries_ptr);
1055 dbg("SEP Driver:<-------- sep_build_lli_table end\n");
1060 this function goes over the list of the print created tables and
1063 static void sep_debug_print_lli_tables(struct sep_device *sep, struct sep_lli_entry_t *lli_table_ptr, unsigned long num_table_entries, unsigned long table_data_size)
1065 unsigned long table_count;
1066 unsigned long entries_count;
1068 dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n");
1071 while ((unsigned long) lli_table_ptr != 0xffffffff) {
1072 edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", table_count, table_data_size);
1073 edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries);
1075 /* print entries of the table (without info entry) */
1076 for (entries_count = 0; entries_count < num_table_entries; entries_count++, lli_table_ptr++) {
1077 edbg("SEP Driver:lli_table_ptr address is %08lx\n", (unsigned long) lli_table_ptr);
1078 edbg("SEP Driver:phys address is %08lx block size is %lu\n", lli_table_ptr->physical_address, lli_table_ptr->block_size);
1081 /* point to the info entry */
1084 edbg("SEP Driver:phys lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1085 edbg("SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1088 table_data_size = lli_table_ptr->block_size & 0xffffff;
1089 num_table_entries = (lli_table_ptr->block_size >> 24) & 0xff;
1090 lli_table_ptr = (struct sep_lli_entry_t *)
1091 (lli_table_ptr->physical_address);
1093 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);
1095 if ((unsigned long) lli_table_ptr != 0xffffffff)
1096 lli_table_ptr = (struct sep_lli_entry_t *) sep_shared_bus_to_virt(sep, (unsigned long) lli_table_ptr);
1100 dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n");
1105 This function prepares only input DMA table for synhronic symmetric
1108 static int sep_prepare_input_dma_table(struct sep_device *sep,
1109 unsigned long app_virt_addr,
1110 unsigned long data_size,
1111 unsigned long block_size,
1112 unsigned long *lli_table_ptr,
1113 unsigned long *num_entries_ptr,
1114 unsigned long *table_data_size_ptr,
1115 bool isKernelVirtualAddress)
1117 /* pointer to the info entry of the table - the last entry */
1118 struct sep_lli_entry_t *info_entry_ptr;
1119 /* array of pointers ot page */
1120 struct sep_lli_entry_t *lli_array_ptr;
1121 /* points to the first entry to be processed in the lli_in_array */
1122 unsigned long current_entry;
1123 /* num entries in the virtual buffer */
1124 unsigned long sep_lli_entries;
1125 /* lli table pointer */
1126 struct sep_lli_entry_t *in_lli_table_ptr;
1127 /* the total data in one table */
1128 unsigned long table_data_size;
1129 /* number of entries in lli table */
1130 unsigned long num_entries_in_table;
1131 /* next table address */
1132 void *lli_table_alloc_addr;
1133 unsigned long result;
1135 dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n");
1137 edbg("SEP Driver:data_size is %lu\n", data_size);
1138 edbg("SEP Driver:block_size is %lu\n", block_size);
1140 /* initialize the pages pointers */
1141 sep->in_page_array = 0;
1142 sep->in_num_pages = 0;
1144 if (data_size == 0) {
1145 /* special case - created 2 entries table with zero data */
1146 in_lli_table_ptr = (struct sep_lli_entry_t *) (sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES);
1147 /* FIXME: Should the entry below not be for _bus */
1148 in_lli_table_ptr->physical_address = (unsigned long)sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1149 in_lli_table_ptr->block_size = 0;
1152 in_lli_table_ptr->physical_address = 0xFFFFFFFF;
1153 in_lli_table_ptr->block_size = 0;
1155 *lli_table_ptr = sep->shared_bus + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1156 *num_entries_ptr = 2;
1157 *table_data_size_ptr = 0;
1162 /* check if the pages are in Kernel Virtual Address layout */
1163 if (isKernelVirtualAddress == true)
1164 /* lock the pages of the kernel buffer and translate them to pages */
1165 result = sep_lock_kernel_pages(sep, app_virt_addr, data_size, &sep->in_num_pages, &lli_array_ptr, &sep->in_page_array);
1167 /* lock the pages of the user buffer and translate them to pages */
1168 result = sep_lock_user_pages(sep, app_virt_addr, data_size, &sep->in_num_pages, &lli_array_ptr, &sep->in_page_array);
1173 edbg("SEP Driver:output sep->in_num_pages is %lu\n", sep->in_num_pages);
1177 sep_lli_entries = sep->in_num_pages;
1179 /* initiate to point after the message area */
1180 lli_table_alloc_addr = sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1182 /* loop till all the entries in in array are not processed */
1183 while (current_entry < sep_lli_entries) {
1184 /* set the new input and output tables */
1185 in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1187 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1189 /* calculate the maximum size of data for input table */
1190 table_data_size = sep_calculate_lli_table_max_size(&lli_array_ptr[current_entry], (sep_lli_entries - current_entry));
1192 /* now calculate the table size so that it will be module block size */
1193 table_data_size = (table_data_size / block_size) * block_size;
1195 edbg("SEP Driver:output table_data_size is %lu\n", table_data_size);
1197 /* construct input lli table */
1198 sep_build_lli_table(&lli_array_ptr[current_entry], in_lli_table_ptr, ¤t_entry, &num_entries_in_table, table_data_size);
1200 if (info_entry_ptr == 0) {
1201 /* set the output parameters to physical addresses */
1202 *lli_table_ptr = sep_shared_virt_to_bus(sep, in_lli_table_ptr);
1203 *num_entries_ptr = num_entries_in_table;
1204 *table_data_size_ptr = table_data_size;
1206 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_ptr);
1208 /* update the info entry of the previous in table */
1209 info_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, in_lli_table_ptr);
1210 info_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size);
1213 /* save the pointer to the info entry of the current tables */
1214 info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
1217 /* print input tables */
1218 sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *)
1219 sep_shared_bus_to_virt(sep, *lli_table_ptr), *num_entries_ptr, *table_data_size_ptr);
1221 /* the array of the pages */
1222 kfree(lli_array_ptr);
1224 dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n");
1230 This function creates the input and output dma tables for
1231 symmetric operations (AES/DES) according to the block size from LLI arays
1233 static int sep_construct_dma_tables_from_lli(struct sep_device *sep,
1234 struct sep_lli_entry_t *lli_in_array,
1235 unsigned long sep_in_lli_entries,
1236 struct sep_lli_entry_t *lli_out_array,
1237 unsigned long sep_out_lli_entries,
1238 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)
1240 /* points to the area where next lli table can be allocated: keep void *
1241 as there is pointer scaling to fix otherwise */
1242 void *lli_table_alloc_addr;
1243 /* input lli table */
1244 struct sep_lli_entry_t *in_lli_table_ptr;
1245 /* output lli table */
1246 struct sep_lli_entry_t *out_lli_table_ptr;
1247 /* pointer to the info entry of the table - the last entry */
1248 struct sep_lli_entry_t *info_in_entry_ptr;
1249 /* pointer to the info entry of the table - the last entry */
1250 struct sep_lli_entry_t *info_out_entry_ptr;
1251 /* points to the first entry to be processed in the lli_in_array */
1252 unsigned long current_in_entry;
1253 /* points to the first entry to be processed in the lli_out_array */
1254 unsigned long current_out_entry;
1255 /* max size of the input table */
1256 unsigned long in_table_data_size;
1257 /* max size of the output table */
1258 unsigned long out_table_data_size;
1259 /* flag te signifies if this is the first tables build from the arrays */
1260 unsigned long first_table_flag;
1261 /* the data size that should be in table */
1262 unsigned long table_data_size;
1263 /* number of etnries in the input table */
1264 unsigned long num_entries_in_table;
1265 /* number of etnries in the output table */
1266 unsigned long num_entries_out_table;
1268 dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n");
1270 /* initiate to pint after the message area */
1271 lli_table_alloc_addr = sep->shared_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1273 current_in_entry = 0;
1274 current_out_entry = 0;
1275 first_table_flag = 1;
1276 info_in_entry_ptr = 0;
1277 info_out_entry_ptr = 0;
1279 /* loop till all the entries in in array are not processed */
1280 while (current_in_entry < sep_in_lli_entries) {
1281 /* set the new input and output tables */
1282 in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1284 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1286 /* set the first output tables */
1287 out_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1289 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1291 /* calculate the maximum size of data for input table */
1292 in_table_data_size = sep_calculate_lli_table_max_size(&lli_in_array[current_in_entry], (sep_in_lli_entries - current_in_entry));
1294 /* calculate the maximum size of data for output table */
1295 out_table_data_size = sep_calculate_lli_table_max_size(&lli_out_array[current_out_entry], (sep_out_lli_entries - current_out_entry));
1297 edbg("SEP Driver:in_table_data_size is %lu\n", in_table_data_size);
1298 edbg("SEP Driver:out_table_data_size is %lu\n", out_table_data_size);
1300 /* check where the data is smallest */
1301 table_data_size = in_table_data_size;
1302 if (table_data_size > out_table_data_size)
1303 table_data_size = out_table_data_size;
1305 /* now calculate the table size so that it will be module block size */
1306 table_data_size = (table_data_size / block_size) * block_size;
1308 dbg("SEP Driver:table_data_size is %lu\n", table_data_size);
1310 /* construct input lli table */
1311 sep_build_lli_table(&lli_in_array[current_in_entry], in_lli_table_ptr, ¤t_in_entry, &num_entries_in_table, table_data_size);
1313 /* construct output lli table */
1314 sep_build_lli_table(&lli_out_array[current_out_entry], out_lli_table_ptr, ¤t_out_entry, &num_entries_out_table, table_data_size);
1316 /* if info entry is null - this is the first table built */
1317 if (info_in_entry_ptr == 0) {
1318 /* set the output parameters to physical addresses */
1319 *lli_table_in_ptr = sep_shared_virt_to_bus(sep, in_lli_table_ptr);
1320 *in_num_entries_ptr = num_entries_in_table;
1321 *lli_table_out_ptr = sep_shared_virt_to_bus(sep, out_lli_table_ptr);
1322 *out_num_entries_ptr = num_entries_out_table;
1323 *table_data_size_ptr = table_data_size;
1325 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr);
1326 edbg("SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr);
1328 /* update the info entry of the previous in table */
1329 info_in_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, in_lli_table_ptr);
1330 info_in_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size);
1332 /* update the info entry of the previous in table */
1333 info_out_entry_ptr->physical_address = sep_shared_virt_to_bus(sep, out_lli_table_ptr);
1334 info_out_entry_ptr->block_size = ((num_entries_out_table) << 24) | (table_data_size);
1337 /* save the pointer to the info entry of the current tables */
1338 info_in_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
1339 info_out_entry_ptr = out_lli_table_ptr + num_entries_out_table - 1;
1341 edbg("SEP Driver:output num_entries_out_table is %lu\n", (unsigned long) num_entries_out_table);
1342 edbg("SEP Driver:output info_in_entry_ptr is %lu\n", (unsigned long) info_in_entry_ptr);
1343 edbg("SEP Driver:output info_out_entry_ptr is %lu\n", (unsigned long) info_out_entry_ptr);
1346 /* print input tables */
1347 sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *)
1348 sep_shared_bus_to_virt(sep, *lli_table_in_ptr), *in_num_entries_ptr, *table_data_size_ptr);
1349 /* print output tables */
1350 sep_debug_print_lli_tables(sep, (struct sep_lli_entry_t *)
1351 sep_shared_bus_to_virt(sep, *lli_table_out_ptr), *out_num_entries_ptr, *table_data_size_ptr);
1352 dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n");
1358 This function builds input and output DMA tables for synhronic
1359 symmetric operations (AES, DES). It also checks that each table
1360 is of the modular block size
1362 static int sep_prepare_input_output_dma_table(struct sep_device *sep,
1363 unsigned long app_virt_in_addr,
1364 unsigned long app_virt_out_addr,
1365 unsigned long data_size,
1366 unsigned long block_size,
1367 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)
1369 /* array of pointers of page */
1370 struct sep_lli_entry_t *lli_in_array;
1371 /* array of pointers of page */
1372 struct sep_lli_entry_t *lli_out_array;
1375 dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n");
1377 /* initialize the pages pointers */
1378 sep->in_page_array = 0;
1379 sep->out_page_array = 0;
1381 /* check if the pages are in Kernel Virtual Address layout */
1382 if (isKernelVirtualAddress == true) {
1383 /* lock the pages of the kernel buffer and translate them to pages */
1384 result = sep_lock_kernel_pages(sep, app_virt_in_addr, data_size, &sep->in_num_pages, &lli_in_array, &sep->in_page_array);
1386 edbg("SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n");
1390 /* lock the pages of the user buffer and translate them to pages */
1391 result = sep_lock_user_pages(sep, app_virt_in_addr, data_size, &sep->in_num_pages, &lli_in_array, &sep->in_page_array);
1393 edbg("SEP Driver: sep_lock_user_pages for input virtual buffer failed\n");
1398 if (isKernelVirtualAddress == true) {
1399 result = sep_lock_kernel_pages(sep, app_virt_out_addr, data_size, &sep->out_num_pages, &lli_out_array, &sep->out_page_array);
1401 edbg("SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n");
1402 goto end_function_with_error1;
1405 result = sep_lock_user_pages(sep, app_virt_out_addr, data_size, &sep->out_num_pages, &lli_out_array, &sep->out_page_array);
1407 edbg("SEP Driver: sep_lock_user_pages for output virtual buffer failed\n");
1408 goto end_function_with_error1;
1411 edbg("sep->in_num_pages is %lu\n", sep->in_num_pages);
1412 edbg("sep->out_num_pages is %lu\n", sep->out_num_pages);
1413 edbg("SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
1416 /* call the fucntion that creates table from the lli arrays */
1417 result = sep_construct_dma_tables_from_lli(sep, lli_in_array, sep->in_num_pages, lli_out_array, sep->out_num_pages, block_size, lli_table_in_ptr, lli_table_out_ptr, in_num_entries_ptr, out_num_entries_ptr, table_data_size_ptr);
1419 edbg("SEP Driver: sep_construct_dma_tables_from_lli failed\n");
1420 goto end_function_with_error2;
1423 /* fall through - free the lli entry arrays */
1424 dbg("in_num_entries_ptr is %08lx\n", *in_num_entries_ptr);
1425 dbg("out_num_entries_ptr is %08lx\n", *out_num_entries_ptr);
1426 dbg("table_data_size_ptr is %08lx\n", *table_data_size_ptr);
1427 end_function_with_error2:
1428 kfree(lli_out_array);
1429 end_function_with_error1:
1430 kfree(lli_in_array);
1432 dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result);
1438 this function handles tha request for creation of the DMA table
1439 for the synchronic symmetric operations (AES,DES)
1441 static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
1445 /* command arguments */
1446 struct sep_driver_build_sync_table_t command_args;
1448 dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n");
1450 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_sync_table_t));
1454 edbg("app_in_address is %08lx\n", command_args.app_in_address);
1455 edbg("app_out_address is %08lx\n", command_args.app_out_address);
1456 edbg("data_size is %lu\n", command_args.data_in_size);
1457 edbg("block_size is %lu\n", command_args.block_size);
1459 /* check if we need to build only input table or input/output */
1460 if (command_args.app_out_address)
1461 /* prepare input and output tables */
1462 error = sep_prepare_input_output_dma_table(sep,
1463 command_args.app_in_address,
1464 command_args.app_out_address,
1465 command_args.data_in_size,
1466 command_args.block_size,
1467 &command_args.in_table_address,
1468 &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);
1470 /* prepare input tables */
1471 error = sep_prepare_input_dma_table(sep,
1472 command_args.app_in_address,
1473 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);
1478 if (copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_build_sync_table_t)))
1481 dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n");
1486 this function handles the request for freeing dma table for synhronic actions
1488 static int sep_free_dma_table_data_handler(struct sep_device *sep)
1490 dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n");
1492 /* free input pages array */
1493 sep_free_dma_pages(sep->in_page_array, sep->in_num_pages, 0);
1495 /* free output pages array if needed */
1496 if (sep->out_page_array)
1497 sep_free_dma_pages(sep->out_page_array, sep->out_num_pages, 1);
1499 /* reset all the values */
1500 sep->in_page_array = 0;
1501 sep->out_page_array = 0;
1502 sep->in_num_pages = 0;
1503 sep->out_num_pages = 0;
1504 dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n");
1509 this function find a space for the new flow dma table
1511 static int sep_find_free_flow_dma_table_space(struct sep_device *sep,
1512 unsigned long **table_address_ptr)
1515 /* pointer to the id field of the flow dma table */
1516 unsigned long *start_table_ptr;
1517 /* Do not make start_addr unsigned long * unless fixing the offset
1519 void *flow_dma_area_start_addr;
1520 unsigned long *flow_dma_area_end_addr;
1521 /* maximum table size in words */
1522 unsigned long table_size_in_words;
1524 /* find the start address of the flow DMA table area */
1525 flow_dma_area_start_addr = sep->shared_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1527 /* set end address of the flow table area */
1528 flow_dma_area_end_addr = flow_dma_area_start_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES;
1530 /* set table size in words */
1531 table_size_in_words = SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE * (sizeof(struct sep_lli_entry_t) / sizeof(long)) + 2;
1533 /* set the pointer to the start address of DMA area */
1534 start_table_ptr = flow_dma_area_start_addr;
1536 /* find the space for the next table */
1537 while (((*start_table_ptr & 0x7FFFFFFF) != 0) && start_table_ptr < flow_dma_area_end_addr)
1538 start_table_ptr += table_size_in_words;
1540 /* check if we reached the end of floa tables area */
1541 if (start_table_ptr >= flow_dma_area_end_addr)
1544 *table_address_ptr = start_table_ptr;
1550 This function creates one DMA table for flow and returns its data,
1551 and pointer to its info entry
1553 static int sep_prepare_one_flow_dma_table(struct sep_device *sep,
1554 unsigned long virt_buff_addr,
1555 unsigned long virt_buff_size,
1556 struct sep_lli_entry_t *table_data,
1557 struct sep_lli_entry_t **info_entry_ptr,
1558 struct sep_flow_context_t *flow_data_ptr,
1559 bool isKernelVirtualAddress)
1562 /* the range in pages */
1563 unsigned long lli_array_size;
1564 struct sep_lli_entry_t *lli_array;
1565 struct sep_lli_entry_t *flow_dma_table_entry_ptr;
1566 unsigned long *start_dma_table_ptr;
1567 /* total table data counter */
1568 unsigned long dma_table_data_count;
1569 /* pointer that will keep the pointer to the pages of the virtual buffer */
1570 struct page **page_array_ptr;
1571 unsigned long entry_count;
1573 /* find the space for the new table */
1574 error = sep_find_free_flow_dma_table_space(sep, &start_dma_table_ptr);
1578 /* check if the pages are in Kernel Virtual Address layout */
1579 if (isKernelVirtualAddress == true)
1580 /* lock kernel buffer in the memory */
1581 error = sep_lock_kernel_pages(sep, virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr);
1583 /* lock user buffer in the memory */
1584 error = sep_lock_user_pages(sep, virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr);
1589 /* set the pointer to page array at the beginning of table - this table is
1590 now considered taken */
1591 *start_dma_table_ptr = lli_array_size;
1593 /* point to the place of the pages pointers of the table */
1594 start_dma_table_ptr++;
1596 /* set the pages pointer */
1597 *start_dma_table_ptr = (unsigned long) page_array_ptr;
1599 /* set the pointer to the first entry */
1600 flow_dma_table_entry_ptr = (struct sep_lli_entry_t *) (++start_dma_table_ptr);
1602 /* now create the entries for table */
1603 for (dma_table_data_count = entry_count = 0; entry_count < lli_array_size; entry_count++) {
1604 flow_dma_table_entry_ptr->physical_address = lli_array[entry_count].physical_address;
1606 flow_dma_table_entry_ptr->block_size = lli_array[entry_count].block_size;
1608 /* set the total data of a table */
1609 dma_table_data_count += lli_array[entry_count].block_size;
1611 flow_dma_table_entry_ptr++;
1614 /* set the physical address */
1615 table_data->physical_address = virt_to_phys(start_dma_table_ptr);
1617 /* set the num_entries and total data size */
1618 table_data->block_size = ((lli_array_size + 1) << SEP_NUM_ENTRIES_OFFSET_IN_BITS) | (dma_table_data_count);
1620 /* set the info entry */
1621 flow_dma_table_entry_ptr->physical_address = 0xffffffff;
1622 flow_dma_table_entry_ptr->block_size = 0;
1624 /* set the pointer to info entry */
1625 *info_entry_ptr = flow_dma_table_entry_ptr;
1627 /* the array of the lli entries */
1636 This function creates a list of tables for flow and returns the data for
1637 the first and last tables of the list
1639 static int sep_prepare_flow_dma_tables(struct sep_device *sep,
1640 unsigned long num_virtual_buffers,
1641 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)
1644 unsigned long virt_buff_addr;
1645 unsigned long virt_buff_size;
1646 struct sep_lli_entry_t table_data;
1647 struct sep_lli_entry_t *info_entry_ptr;
1648 struct sep_lli_entry_t *prev_info_entry_ptr;
1653 prev_info_entry_ptr = 0;
1655 /* init the first table to default */
1656 table_data.physical_address = 0xffffffff;
1657 first_table_data_ptr->physical_address = 0xffffffff;
1658 table_data.block_size = 0;
1660 for (i = 0; i < num_virtual_buffers; i++) {
1661 /* get the virtual buffer address */
1662 error = get_user(virt_buff_addr, &first_buff_addr);
1666 /* get the virtual buffer size */
1668 error = get_user(virt_buff_size, &first_buff_addr);
1672 /* advance the address to point to the next pair of address|size */
1675 /* now prepare the one flow LLI table from the data */
1676 error = sep_prepare_one_flow_dma_table(sep, virt_buff_addr, virt_buff_size, &table_data, &info_entry_ptr, flow_data_ptr, isKernelVirtualAddress);
1681 /* if this is the first table - save it to return to the user
1683 *first_table_data_ptr = table_data;
1685 /* set the pointer to info entry */
1686 prev_info_entry_ptr = info_entry_ptr;
1688 /* not first table - the previous table info entry should
1690 prev_info_entry_ptr->block_size = (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS) | (table_data.block_size);
1692 /* set the pointer to info entry */
1693 prev_info_entry_ptr = info_entry_ptr;
1697 /* set the last table data */
1698 *last_table_data_ptr = table_data;
1704 this function goes over all the flow tables connected to the given
1705 table and deallocate them
1707 static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr)
1710 unsigned long *table_ptr;
1711 /* end address of the flow dma area */
1712 unsigned long num_entries;
1713 unsigned long num_pages;
1714 struct page **pages_ptr;
1715 /* maximum table size in words */
1716 struct sep_lli_entry_t *info_entry_ptr;
1718 /* set the pointer to the first table */
1719 table_ptr = (unsigned long *) first_table_ptr->physical_address;
1721 /* set the num of entries */
1722 num_entries = (first_table_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS)
1723 & SEP_NUM_ENTRIES_MASK;
1725 /* go over all the connected tables */
1726 while (*table_ptr != 0xffffffff) {
1727 /* get number of pages */
1728 num_pages = *(table_ptr - 2);
1730 /* get the pointer to the pages */
1731 pages_ptr = (struct page **) (*(table_ptr - 1));
1733 /* free the pages */
1734 sep_free_dma_pages(pages_ptr, num_pages, 1);
1736 /* goto to the info entry */
1737 info_entry_ptr = ((struct sep_lli_entry_t *) table_ptr) + (num_entries - 1);
1739 table_ptr = (unsigned long *) info_entry_ptr->physical_address;
1740 num_entries = (info_entry_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1747 * sep_find_flow_context - find a flow
1748 * @sep: the SEP we are working with
1749 * @flow_id: flow identifier
1751 * Returns a pointer the matching flow, or NULL if the flow does not
1755 static struct sep_flow_context_t *sep_find_flow_context(struct sep_device *sep,
1756 unsigned long flow_id)
1760 * always search for flow with id default first - in case we
1761 * already started working on the flow there can be no situation
1762 * when 2 flows are with default flag
1764 for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) {
1765 if (sep->flows[count].flow_id == flow_id)
1766 return &sep->flows[count];
1773 this function handles the request to create the DMA tables for flow
1775 static int sep_create_flow_dma_tables_handler(struct sep_device *sep,
1778 int error = -ENOENT;
1779 struct sep_driver_build_flow_table_t command_args;
1780 /* first table - output */
1781 struct sep_lli_entry_t first_table_data;
1782 /* dma table data */
1783 struct sep_lli_entry_t last_table_data;
1784 /* pointer to the info entry of the previuos DMA table */
1785 struct sep_lli_entry_t *prev_info_entry_ptr;
1786 /* pointer to the flow data strucutre */
1787 struct sep_flow_context_t *flow_context_ptr;
1789 dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n");
1791 /* init variables */
1792 prev_info_entry_ptr = 0;
1793 first_table_data.physical_address = 0xffffffff;
1795 /* find the free structure for flow data */
1797 flow_context_ptr = sep_find_flow_context(sep, SEP_FREE_FLOW_ID);
1798 if (flow_context_ptr == NULL)
1801 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_flow_table_t));
1805 /* create flow tables */
1806 error = sep_prepare_flow_dma_tables(sep, command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress);
1808 goto end_function_with_error;
1810 /* check if flow is static */
1811 if (!command_args.flow_type)
1812 /* point the info entry of the last to the info entry of the first */
1813 last_table_data = first_table_data;
1815 /* set output params */
1816 command_args.first_table_addr = first_table_data.physical_address;
1817 command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK);
1818 command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK);
1820 /* send the parameters to user application */
1821 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_build_flow_table_t));
1823 goto end_function_with_error;
1825 /* all the flow created - update the flow entry with temp id */
1826 flow_context_ptr->flow_id = SEP_TEMP_FLOW_ID;
1828 /* set the processing tables data in the context */
1829 if (command_args.input_output_flag == SEP_DRIVER_IN_FLAG)
1830 flow_context_ptr->input_tables_in_process = first_table_data;
1832 flow_context_ptr->output_tables_in_process = first_table_data;
1836 end_function_with_error:
1837 /* free the allocated tables */
1838 sep_deallocated_flow_tables(&first_table_data);
1840 dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n");
1845 this function handles add tables to flow
1847 static int sep_add_flow_tables_handler(struct sep_device *sep, unsigned long arg)
1850 unsigned long num_entries;
1851 struct sep_driver_add_flow_table_t command_args;
1852 struct sep_flow_context_t *flow_context_ptr;
1853 /* first dma table data */
1854 struct sep_lli_entry_t first_table_data;
1855 /* last dma table data */
1856 struct sep_lli_entry_t last_table_data;
1857 /* pointer to the info entry of the current DMA table */
1858 struct sep_lli_entry_t *info_entry_ptr;
1860 dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n");
1862 /* get input parameters */
1863 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_flow_table_t));
1867 /* find the flow structure for the flow id */
1868 flow_context_ptr = sep_find_flow_context(sep, command_args.flow_id);
1869 if (flow_context_ptr == NULL)
1872 /* prepare the flow dma tables */
1873 error = sep_prepare_flow_dma_tables(sep, command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress);
1875 goto end_function_with_error;
1877 /* now check if there is already an existing add table for this flow */
1878 if (command_args.inputOutputFlag == SEP_DRIVER_IN_FLAG) {
1879 /* this buffer was for input buffers */
1880 if (flow_context_ptr->input_tables_flag) {
1881 /* add table already exists - add the new tables to the end
1883 num_entries = (flow_context_ptr->last_input_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1885 info_entry_ptr = (struct sep_lli_entry_t *)
1886 (flow_context_ptr->last_input_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1)));
1888 /* connect to list of tables */
1889 *info_entry_ptr = first_table_data;
1891 /* set the first table data */
1892 first_table_data = flow_context_ptr->first_input_table;
1894 /* set the input flag */
1895 flow_context_ptr->input_tables_flag = 1;
1897 /* set the first table data */
1898 flow_context_ptr->first_input_table = first_table_data;
1900 /* set the last table data */
1901 flow_context_ptr->last_input_table = last_table_data;
1902 } else { /* this is output tables */
1904 /* this buffer was for input buffers */
1905 if (flow_context_ptr->output_tables_flag) {
1906 /* add table already exists - add the new tables to
1907 the end of the previous */
1908 num_entries = (flow_context_ptr->last_output_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1910 info_entry_ptr = (struct sep_lli_entry_t *)
1911 (flow_context_ptr->last_output_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1)));
1913 /* connect to list of tables */
1914 *info_entry_ptr = first_table_data;
1916 /* set the first table data */
1917 first_table_data = flow_context_ptr->first_output_table;
1919 /* set the input flag */
1920 flow_context_ptr->output_tables_flag = 1;
1922 /* set the first table data */
1923 flow_context_ptr->first_output_table = first_table_data;
1925 /* set the last table data */
1926 flow_context_ptr->last_output_table = last_table_data;
1929 /* set output params */
1930 command_args.first_table_addr = first_table_data.physical_address;
1931 command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK);
1932 command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK);
1934 /* send the parameters to user application */
1935 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_add_flow_table_t));
1936 end_function_with_error:
1937 /* free the allocated tables */
1938 sep_deallocated_flow_tables(&first_table_data);
1940 dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n");
1945 this function add the flow add message to the specific flow
1947 static int sep_add_flow_tables_message_handler(struct sep_device *sep, unsigned long arg)
1950 struct sep_driver_add_message_t command_args;
1951 struct sep_flow_context_t *flow_context_ptr;
1953 dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n");
1955 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_message_t));
1960 if (command_args.message_size_in_bytes > SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES) {
1965 /* find the flow context */
1966 flow_context_ptr = sep_find_flow_context(sep, command_args.flow_id);
1967 if (flow_context_ptr == NULL)
1970 /* copy the message into context */
1971 flow_context_ptr->message_size_in_bytes = command_args.message_size_in_bytes;
1972 error = copy_from_user(flow_context_ptr->message, (void *) command_args.message_address, command_args.message_size_in_bytes);
1974 dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n");
1980 this function returns the bus and virtual addresses of the static pool
1982 static int sep_get_static_pool_addr_handler(struct sep_device *sep, unsigned long arg)
1985 struct sep_driver_static_pool_addr_t command_args;
1987 dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n");
1989 /*prepare the output parameters in the struct */
1990 command_args.physical_static_address = sep->shared_bus + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
1991 command_args.virtual_static_address = (unsigned long)sep->shared_addr + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
1993 edbg("SEP Driver:bus_static_address is %08lx, virtual_static_address %08lx\n", command_args.physical_static_address, command_args.virtual_static_address);
1995 /* send the parameters to user application */
1996 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_static_pool_addr_t));
1997 dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n");
2002 this address gets the offset of the physical address from the start
2005 static int sep_get_physical_mapped_offset_handler(struct sep_device *sep, unsigned long arg)
2008 struct sep_driver_get_mapped_offset_t command_args;
2010 dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n");
2012 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_get_mapped_offset_t));
2016 if (command_args.physical_address < sep->shared_bus) {
2021 /*prepare the output parameters in the struct */
2022 command_args.offset = command_args.physical_address - sep->shared_bus;
2024 edbg("SEP Driver:bus_address is %08lx, offset is %lu\n", command_args.physical_address, command_args.offset);
2026 /* send the parameters to user application */
2027 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_get_mapped_offset_t));
2029 dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n");
2037 static int sep_start_handler(struct sep_device *sep)
2039 unsigned long reg_val;
2040 unsigned long error = 0;
2042 dbg("SEP Driver:--------> sep_start_handler start\n");
2044 /* wait in polling for message from SEP */
2046 reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
2049 /* check the value */
2051 /* fatal error - read error status from GPRO */
2052 error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
2053 dbg("SEP Driver:<-------- sep_start_handler end\n");
2058 this function handles the request for SEP initialization
2060 static int sep_init_handler(struct sep_device *sep, unsigned long arg)
2062 unsigned long message_word;
2063 unsigned long *message_ptr;
2064 struct sep_driver_init_t command_args;
2065 unsigned long counter;
2066 unsigned long error;
2067 unsigned long reg_val;
2069 dbg("SEP Driver:--------> sep_init_handler start\n");
2072 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_init_t));
2074 dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user \n");
2079 /* PATCH - configure the DMA to single -burst instead of multi-burst */
2080 /*sep_configure_dma_burst(); */
2082 dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n");
2084 message_ptr = (unsigned long *) command_args.message_addr;
2086 /* set the base address of the SRAM */
2087 sep_write_reg(sep, HW_SRAM_ADDR_REG_ADDR, HW_CC_SRAM_BASE_ADDRESS);
2089 for (counter = 0; counter < command_args.message_size_in_words; counter++, message_ptr++) {
2090 get_user(message_word, message_ptr);
2091 /* write data to SRAM */
2092 sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR, message_word);
2093 edbg("SEP Driver:message_word is %lu\n", message_word);
2094 /* wait for write complete */
2095 sep_wait_sram_write(sep);
2097 dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n");
2099 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1);
2102 reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
2103 while (!(reg_val & 0xFFFFFFFD));
2105 dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n");
2107 /* check the value */
2108 if (reg_val == 0x1) {
2109 edbg("SEP Driver:init failed\n");
2111 error = sep_read_reg(sep, 0x8060);
2112 edbg("SEP Driver:sw monitor is %lu\n", error);
2114 /* fatal error - read erro status from GPRO */
2115 error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
2116 edbg("SEP Driver:error is %lu\n", error);
2119 dbg("SEP Driver:<-------- sep_init_handler end\n");
2125 this function handles the request cache and resident reallocation
2127 static int sep_realloc_cache_resident_handler(struct sep_device *sep,
2130 struct sep_driver_realloc_cache_resident_t command_args;
2133 /* copy cache and resident to the their intended locations */
2134 error = sep_load_firmware(sep);
2138 command_args.new_base_addr = sep->shared_bus;
2140 /* find the new base address according to the lowest address between
2141 cache, resident and shared area */
2142 if (sep->resident_bus < command_args.new_base_addr)
2143 command_args.new_base_addr = sep->resident_bus;
2144 if (sep->rar_bus < command_args.new_base_addr)
2145 command_args.new_base_addr = sep->rar_bus;
2147 /* set the return parameters */
2148 command_args.new_cache_addr = sep->rar_bus;
2149 command_args.new_resident_addr = sep->resident_bus;
2151 /* set the new shared area */
2152 command_args.new_shared_area_addr = sep->shared_bus;
2154 edbg("SEP Driver:command_args.new_shared_addr is %08llx\n", command_args.new_shared_area_addr);
2155 edbg("SEP Driver:command_args.new_base_addr is %08llx\n", command_args.new_base_addr);
2156 edbg("SEP Driver:command_args.new_resident_addr is %08llx\n", command_args.new_resident_addr);
2157 edbg("SEP Driver:command_args.new_rar_addr is %08llx\n", command_args.new_cache_addr);
2159 /* return to user */
2160 if (copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_realloc_cache_resident_t)))
2166 * sep_get_time_handler - time request from user space
2167 * @sep: sep we are to set the time for
2168 * @arg: pointer to user space arg buffer
2170 * This function reports back the time and the address in the SEP
2171 * shared buffer at which it has been placed. (Do we really need this!!!)
2174 static int sep_get_time_handler(struct sep_device *sep, unsigned long arg)
2176 struct sep_driver_get_time_t command_args;
2178 mutex_lock(&sep_mutex);
2179 command_args.time_value = sep_set_time(sep);
2180 command_args.time_physical_address = (unsigned long)sep_time_address(sep);
2181 mutex_unlock(&sep_mutex);
2182 if (copy_to_user((void __user *)arg,
2183 &command_args, sizeof(struct sep_driver_get_time_t)))
2190 This API handles the end transaction request
2192 static int sep_end_transaction_handler(struct sep_device *sep, unsigned long arg)
2194 dbg("SEP Driver:--------> sep_end_transaction_handler start\n");
2196 #if 0 /*!SEP_DRIVER_POLLING_MODE */
2198 sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, 0x7FFF);
2200 /* release IRQ line */
2201 free_irq(SEP_DIRVER_IRQ_NUM, sep);
2203 /* lock the sep mutex */
2204 mutex_unlock(&sep_mutex);
2207 dbg("SEP Driver:<-------- sep_end_transaction_handler end\n");
2214 * sep_set_flow_id_handler - handle flow setting
2215 * @sep: the SEP we are configuring
2216 * @flow_id: the flow we are setting
2218 * This function handler the set flow id command
2220 static int sep_set_flow_id_handler(struct sep_device *sep,
2221 unsigned long flow_id)
2224 struct sep_flow_context_t *flow_data_ptr;
2226 /* find the flow data structure that was just used for creating new flow
2227 - its id should be default */
2229 mutex_lock(&sep_mutex);
2230 flow_data_ptr = sep_find_flow_context(sep, SEP_TEMP_FLOW_ID);
2232 flow_data_ptr->flow_id = flow_id; /* set flow id */
2235 mutex_unlock(&sep_mutex);
2239 static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
2242 struct sep_device *sep = filp->private_data;
2244 dbg("------------>SEP Driver: ioctl start\n");
2246 edbg("SEP Driver: cmd is %x\n", cmd);
2249 case SEP_IOCSENDSEPCOMMAND:
2250 /* send command to SEP */
2251 sep_send_command_handler(sep);
2252 edbg("SEP Driver: after sep_send_command_handler\n");
2254 case SEP_IOCSENDSEPRPLYCOMMAND:
2255 /* send reply command to SEP */
2256 sep_send_reply_command_handler(sep);
2258 case SEP_IOCALLOCDATAPOLL:
2259 /* allocate data pool */
2260 error = sep_allocate_data_pool_memory_handler(sep, arg);
2262 case SEP_IOCWRITEDATAPOLL:
2263 /* write data into memory pool */
2264 error = sep_write_into_data_pool_handler(sep, arg);
2266 case SEP_IOCREADDATAPOLL:
2267 /* read data from data pool into application memory */
2268 error = sep_read_from_data_pool_handler(sep, arg);
2270 case SEP_IOCCREATESYMDMATABLE:
2271 /* create dma table for synhronic operation */
2272 error = sep_create_sync_dma_tables_handler(sep, arg);
2274 case SEP_IOCCREATEFLOWDMATABLE:
2275 /* create flow dma tables */
2276 error = sep_create_flow_dma_tables_handler(sep, arg);
2278 case SEP_IOCFREEDMATABLEDATA:
2279 /* free the pages */
2280 error = sep_free_dma_table_data_handler(sep);
2282 case SEP_IOCSETFLOWID:
2284 error = sep_set_flow_id_handler(sep, (unsigned long)arg);
2286 case SEP_IOCADDFLOWTABLE:
2287 /* add tables to the dynamic flow */
2288 error = sep_add_flow_tables_handler(sep, arg);
2290 case SEP_IOCADDFLOWMESSAGE:
2291 /* add message of add tables to flow */
2292 error = sep_add_flow_tables_message_handler(sep, arg);
2294 case SEP_IOCSEPSTART:
2295 /* start command to sep */
2296 error = sep_start_handler(sep);
2298 case SEP_IOCSEPINIT:
2299 /* init command to sep */
2300 error = sep_init_handler(sep, arg);
2302 case SEP_IOCGETSTATICPOOLADDR:
2303 /* get the physical and virtual addresses of the static pool */
2304 error = sep_get_static_pool_addr_handler(sep, arg);
2306 case SEP_IOCENDTRANSACTION:
2307 error = sep_end_transaction_handler(sep, arg);
2309 case SEP_IOCREALLOCCACHERES:
2310 error = sep_realloc_cache_resident_handler(sep, arg);
2312 case SEP_IOCGETMAPPEDADDROFFSET:
2313 error = sep_get_physical_mapped_offset_handler(sep, arg);
2316 error = sep_get_time_handler(sep, arg);
2322 dbg("SEP Driver:<-------- ioctl end\n");
2328 #if !SEP_DRIVER_POLLING_MODE
2330 /* handler for flow done interrupt */
2332 static void sep_flow_done_handler(struct work_struct *work)
2334 struct sep_flow_context_t *flow_data_ptr;
2336 /* obtain the mutex */
2337 mutex_lock(&sep_mutex);
2339 /* get the pointer to context */
2340 flow_data_ptr = (struct sep_flow_context_t *) work;
2342 /* free all the current input tables in sep */
2343 sep_deallocated_flow_tables(&flow_data_ptr->input_tables_in_process);
2345 /* free all the current tables output tables in SEP (if needed) */
2346 if (flow_data_ptr->output_tables_in_process.physical_address != 0xffffffff)
2347 sep_deallocated_flow_tables(&flow_data_ptr->output_tables_in_process);
2349 /* check if we have additional tables to be sent to SEP only input
2350 flag may be checked */
2351 if (flow_data_ptr->input_tables_flag) {
2352 /* copy the message to the shared RAM and signal SEP */
2353 memcpy((void *) flow_data_ptr->message, (void *) sep->shared_addr, flow_data_ptr->message_size_in_bytes);
2355 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR, 0x2);
2357 mutex_unlock(&sep_mutex);
2360 interrupt handler function
2362 static irqreturn_t sep_inthandler(int irq, void *dev_id)
2364 irqreturn_t int_error;
2365 unsigned long reg_val;
2366 unsigned long flow_id;
2367 struct sep_flow_context_t *flow_context_ptr;
2368 struct sep_device *sep = dev_id;
2370 int_error = IRQ_HANDLED;
2372 /* read the IRR register to check if this is SEP interrupt */
2373 reg_val = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR);
2374 edbg("SEP Interrupt - reg is %08lx\n", reg_val);
2376 /* check if this is the flow interrupt */
2377 if (0 /*reg_val & (0x1 << 11) */ ) {
2378 /* read GPRO to find out the which flow is done */
2379 flow_id = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR);
2381 /* find the contex of the flow */
2382 flow_context_ptr = sep_find_flow_context(sep, flow_id >> 28);
2383 if (flow_context_ptr == NULL)
2384 goto end_function_with_error;
2386 /* queue the work */
2387 INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler);
2388 queue_work(sep->flow_wq, &flow_context_ptr->flow_wq);
2391 /* check if this is reply interrupt from SEP */
2392 if (reg_val & (0x1 << 13)) {
2393 /* update the counter of reply messages */
2395 /* wake up the waiting process */
2396 wake_up(&sep_event);
2398 int_error = IRQ_NONE;
2402 end_function_with_error:
2403 /* clear the interrupt */
2404 sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, reg_val);
2415 static void sep_wait_busy(struct sep_device *sep)
2420 reg = sep_read_reg(sep, HW_HOST_SEP_BUSY_REG_ADDR);
2425 PATCH for configuring the DMA to single burst instead of multi-burst
2427 static void sep_configure_dma_burst(struct sep_device *sep)
2429 #define HW_AHB_RD_WR_BURSTS_REG_ADDR 0x0E10UL
2431 dbg("SEP Driver:<-------- sep_configure_dma_burst start \n");
2433 /* request access to registers from SEP */
2434 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
2436 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n");
2440 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n");
2442 /* set the DMA burst register to single burst */
2443 sep_write_reg(sep, HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL);
2445 /* release the sep busy */
2446 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL);
2449 dbg("SEP Driver:<-------- sep_configure_dma_burst done \n");
2456 Function that is activated on the successful probe of the SEP device
2458 static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
2461 struct sep_device *sep;
2463 int size; /* size of memory for allocation */
2465 edbg("Sep pci probe starting\n");
2466 if (sep_dev != NULL) {
2467 dev_warn(&pdev->dev, "only one SEP supported.\n");
2471 /* enable the device */
2472 error = pci_enable_device(pdev);
2474 edbg("error enabling pci device\n");
2478 /* set the pci dev pointer */
2479 sep_dev = &sep_instance;
2480 sep = &sep_instance;
2482 edbg("sep->shared_addr = %p\n", sep->shared_addr);
2483 /* transaction counter that coordinates the transactions between SEP
2486 /* counter for the messages from sep */
2488 /* counter for the number of bytes allocated in the pool
2489 for the current transaction */
2490 sep->data_pool_bytes_allocated = 0;
2492 /* calculate the total size for allocation */
2493 size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES +
2494 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;
2496 /* allocate the shared area */
2497 if (sep_map_and_alloc_shared_area(sep, size)) {
2499 /* allocation failed */
2500 goto end_function_error;
2502 /* now set the memory regions */
2503 #if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1)
2504 /* Note: this test section will need moving before it could ever
2505 work as the registers are not yet mapped ! */
2506 /* send the new SHARED MESSAGE AREA to the SEP */
2507 sep_write_reg(sep, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep->shared_bus);
2509 /* poll for SEP response */
2510 retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
2511 while (retval != 0xffffffff && retval != sep->shared_bus)
2512 retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
2514 /* check the return value (register) */
2515 if (retval != sep->shared_bus) {
2517 goto end_function_deallocate_sep_shared_area;
2520 /* init the flow contextes */
2521 for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++)
2522 sep->flows[counter].flow_id = SEP_FREE_FLOW_ID;
2524 sep->flow_wq = create_singlethread_workqueue("sepflowwq");
2525 if (sep->flow_wq == NULL) {
2527 edbg("sep_driver:flow queue creation failed\n");
2528 goto end_function_deallocate_sep_shared_area;
2530 edbg("SEP Driver: create flow workqueue \n");
2531 sep->pdev = pci_dev_get(pdev);
2533 sep->reg_addr = pci_ioremap_bar(pdev, 0);
2534 if (!sep->reg_addr) {
2535 edbg("sep: ioremap of registers failed.\n");
2536 goto end_function_deallocate_sep_shared_area;
2538 edbg("SEP Driver:reg_addr is %p\n", sep->reg_addr);
2540 /* load the rom code */
2541 sep_load_rom_code(sep);
2543 /* set up system base address and shared memory location */
2544 sep->rar_addr = dma_alloc_coherent(&sep->pdev->dev,
2545 2 * SEP_RAR_IO_MEM_REGION_SIZE,
2546 &sep->rar_bus, GFP_KERNEL);
2548 if (!sep->rar_addr) {
2549 edbg("SEP Driver:can't allocate rar\n");
2550 goto end_function_uniomap;
2554 edbg("SEP Driver:rar_bus is %08llx\n", (unsigned long long)sep->rar_bus);
2555 edbg("SEP Driver:rar_virtual is %p\n", sep->rar_addr);
2557 #if !SEP_DRIVER_POLLING_MODE
2559 edbg("SEP Driver: about to write IMR and ICR REG_ADDR\n");
2561 /* clear ICR register */
2562 sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
2564 /* set the IMR register - open only GPR 2 */
2565 sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
2567 edbg("SEP Driver: about to call request_irq\n");
2568 /* get the interrupt line */
2569 error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED, "sep_driver", sep);
2571 goto end_function_free_res;
2573 edbg("SEP Driver: about to write IMR REG_ADDR");
2575 /* set the IMR register - open only GPR 2 */
2576 sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
2578 end_function_free_res:
2579 dma_free_coherent(&sep->pdev->dev, 2 * SEP_RAR_IO_MEM_REGION_SIZE,
2580 sep->rar_addr, sep->rar_bus);
2581 #endif /* SEP_DRIVER_POLLING_MODE */
2582 end_function_uniomap:
2583 iounmap(sep->reg_addr);
2584 end_function_deallocate_sep_shared_area:
2585 /* de-allocate shared area */
2586 sep_unmap_and_free_shared_area(sep, size);
2593 static const struct pci_device_id sep_pci_id_tbl[] = {
2594 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c)},
2598 MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
2600 /* field for registering driver to PCI device */
2601 static struct pci_driver sep_pci_driver = {
2602 .name = "sep_sec_driver",
2603 .id_table = sep_pci_id_tbl,
2605 /* FIXME: remove handler */
2608 /* major and minor device numbers */
2609 static dev_t sep_devno;
2611 /* the files operations structure of the driver */
2612 static struct file_operations sep_file_operations = {
2613 .owner = THIS_MODULE,
2614 .unlocked_ioctl = sep_ioctl,
2617 .release = sep_release,
2622 /* cdev struct of the driver */
2623 static struct cdev sep_cdev;
2626 this function registers the driver to the file system
2628 static int sep_register_driver_to_fs(void)
2630 int ret_val = alloc_chrdev_region(&sep_devno, 0, 1, "sep_sec_driver");
2632 edbg("sep: major number allocation failed, retval is %d\n",
2637 cdev_init(&sep_cdev, &sep_file_operations);
2638 sep_cdev.owner = THIS_MODULE;
2640 /* register the driver with the kernel */
2641 ret_val = cdev_add(&sep_cdev, sep_devno, 1);
2643 edbg("sep_driver:cdev_add failed, retval is %d\n", ret_val);
2644 /* unregister dev numbers */
2645 unregister_chrdev_region(sep_devno, 1);
2651 /*--------------------------------------------------------------
2653 ----------------------------------------------------------------*/
2654 static int __init sep_init(void)
2657 dbg("SEP Driver:-------->Init start\n");
2658 /* FIXME: Probe can occur before we are ready to survive a probe */
2659 ret_val = pci_register_driver(&sep_pci_driver);
2661 edbg("sep_driver:sep_driver_to_device failed, ret_val is %d\n", ret_val);
2662 goto end_function_unregister_from_fs;
2664 /* register driver to fs */
2665 ret_val = sep_register_driver_to_fs();
2667 goto end_function_unregister_pci;
2669 end_function_unregister_pci:
2670 pci_unregister_driver(&sep_pci_driver);
2671 end_function_unregister_from_fs:
2672 /* unregister from fs */
2673 cdev_del(&sep_cdev);
2674 /* unregister dev numbers */
2675 unregister_chrdev_region(sep_devno, 1);
2677 dbg("SEP Driver:<-------- Init end\n");
2682 /*-------------------------------------------------------------
2684 --------------------------------------------------------------*/
2685 static void __exit sep_exit(void)
2689 dbg("SEP Driver:--------> Exit start\n");
2691 /* unregister from fs */
2692 cdev_del(&sep_cdev);
2693 /* unregister dev numbers */
2694 unregister_chrdev_region(sep_devno, 1);
2695 /* calculate the total size for de-allocation */
2696 size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES +
2697 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;
2698 /* FIXME: We need to do this in the unload for the device */
2699 /* free shared area */
2701 sep_unmap_and_free_shared_area(sep_dev, size);
2702 edbg("SEP Driver: free pages SEP SHARED AREA \n");
2703 iounmap((void *) sep_dev->reg_addr);
2704 edbg("SEP Driver: iounmap \n");
2706 edbg("SEP Driver: release_mem_region \n");
2707 dbg("SEP Driver:<-------- Exit end\n");
2711 module_init(sep_init);
2712 module_exit(sep_exit);
2714 MODULE_LICENSE("GPL");