projects / deliverable / linux.git / blob
? search:


837b82884a82bced1b24d14ace32239165549832
[deliverable/linux.git] / drivers / staging / sep / sep_driver.c
1 /*
2 *
3 * sep_main_mod.c - Security Processor Driver main group of functions
4 *
5 * Copyright(c) 2009 Intel Corporation. All rights reserved.
6 * Copyright(c) 2009 Discretix. All rights reserved.
7 *
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)
11 * any later version.
12 *
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
16 * more details.
17 *
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.
21 *
22 * CONTACTS:
23 *
24 * Mark Allyn mark.a.allyn@intel.com
25 *
26 * CHANGES:
27 *
28 * 2009.06.26 Initial publish
29 *
30 */
31
32 #include <linux/init.h>
33 #include <linux/module.h>
34 #include <linux/fs.h>
35 #include <linux/cdev.h>
36 #include <linux/kdev_t.h>
37 #include <linux/mutex.h>
38 #include <linux/mm.h>
39 #include <linux/poll.h>
40 #include <linux/wait.h>
41 #include <linux/pci.h>
42 #include <linux/firmware.h>
43 #include <asm/ioctl.h>
44 #include <linux/ioport.h>
45 #include <asm/io.h>
46 #include <linux/interrupt.h>
47 #include <linux/pagemap.h>
48 #include <asm/cacheflush.h>
49 #include "sep_driver_hw_defs.h"
50 #include "sep_driver_config.h"
51 #include "sep_driver_api.h"
52 #include "sep_dev.h"
53
54 #if SEP_DRIVER_ARM_DEBUG_MODE
55
56 #define CRYS_SEP_ROM_length 0x4000
57 #define CRYS_SEP_ROM_start_address 0x8000C000UL
58 #define CRYS_SEP_ROM_start_address_offset 0xC000UL
59 #define SEP_ROM_BANK_register 0x80008420UL
60 #define SEP_ROM_BANK_register_offset 0x8420UL
61 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0x82000000
62
63 /*
64 * THESE 2 definitions are specific to the board - must be
65 * defined during integration
66 */
67 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0xFF0D0000
68
69 /* 2M size */
70
71 static void sep_load_rom_code(void)
72 {
73 /* Index variables */
74 unsigned long i, k, j;
75 u32 reg;
76 u32 error;
77 u32 warning;
78
79 /* Loading ROM from SEP_ROM_image.h file */
80 k = sizeof(CRYS_SEP_ROM);
81
82 edbg("SEP Driver: DX_CC_TST_SepRomLoader start\n");
83
84 edbg("SEP Driver: k is %lu\n", k);
85 edbg("SEP Driver: sep_dev->reg_addr is %p\n", sep_dev->reg_addr);
86 edbg("SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", CRYS_SEP_ROM_start_address_offset);
87
88 for (i = 0; i < 4; i++) {
89 /* write bank */
90 sep_write_reg(sep_dev, SEP_ROM_BANK_register_offset, i);
91
92 for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) {
93 sep_write_reg(sep_dev, CRYS_SEP_ROM_start_address_offset + 4 * j, CRYS_SEP_ROM[i * 0x1000 + j]);
94
95 k = k - 4;
96
97 if (k == 0) {
98 j = CRYS_SEP_ROM_length;
99 i = 4;
100 }
101 }
102 }
103
104 /* reset the SEP */
105 sep_write_reg(sep_dev, HW_HOST_SEP_SW_RST_REG_ADDR, 0x1);
106
107 /* poll for SEP ROM boot finish */
108 do {
109 reg = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
110 } while (!reg);
111
112 edbg("SEP Driver: ROM polling ended\n");
113
114 switch (reg) {
115 case 0x1:
116 /* fatal error - read erro status from GPRO */
117 error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
118 edbg("SEP Driver: ROM polling case 1\n");
119 break;
120 case 0x2:
121 /* Boot First Phase ended */
122 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
123 edbg("SEP Driver: ROM polling case 2\n");
124 break;
125 case 0x4:
126 /* Cold boot ended successfully */
127 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
128 edbg("SEP Driver: ROM polling case 4\n");
129 error = 0;
130 break;
131 case 0x8:
132 /* Warmboot ended successfully */
133 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
134 edbg("SEP Driver: ROM polling case 8\n");
135 error = 0;
136 break;
137 case 0x10:
138 /* ColdWarm boot ended successfully */
139 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
140 edbg("SEP Driver: ROM polling case 16\n");
141 error = 0;
142 break;
143 case 0x20:
144 edbg("SEP Driver: ROM polling case 32\n");
145 break;
146 }
147
148 }
149
150 #else
151 static void sep_load_rom_code(void) { }
152 #endif /* SEP_DRIVER_ARM_DEBUG_MODE */
153
154
155
156 /*----------------------------------------
157 DEFINES
158 -----------------------------------------*/
159
160 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
161 #define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000
162 #define SEP_RAR_IO_MEM_REGION_SIZE 0x40000
163
164 /*--------------------------------------------
165 GLOBAL variables
166 --------------------------------------------*/
167
168 /* debug messages level */
169 INT_MODULE_PARM(sepDebug, 0x0);
170 MODULE_PARM_DESC(sepDebug, "Flag to enable SEP debug messages");
171
172 /* Keep this a single static object for now to keep the conversion easy */
173
174 static struct sep_device sep_instance;
175 static struct sep_device *sep_dev = &sep_instance;
176
177 /*
178 mutex for the access to the internals of the sep driver
179 */
180 static DEFINE_MUTEX(sep_mutex);
181
182
183 /* wait queue head (event) of the driver */
184 static DECLARE_WAIT_QUEUE_HEAD(sep_event);
185
186 /*
187 This functions copies the cache and resident from their source location into
188 destination memory, which is external to Linux VM and is given as
189 physical address
190 */
191 static int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, unsigned long cache_size_in_bytes, unsigned long src_resident_addr, unsigned long resident_size_in_bytes, unsigned long *dst_new_cache_addr_ptr, unsigned long *dst_new_resident_addr_ptr)
192 {
193 unsigned long resident_addr;
194 unsigned long cache_addr;
195 const struct firmware *fw;
196
197 char *cache_name = "cache.image.bin";
198 char *res_name = "resident.image.bin";
199
200 /* error */
201 int error;
202
203 /*--------------------------------
204 CODE
205 -------------------------------------*/
206 error = 0;
207
208 edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_addr);
209 edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_bus);
210
211 sep_dev->rar_region_addr = (unsigned long) sep_dev->rar_addr;
212
213 sep_dev->cache_bus = sep_dev->rar_bus;
214 sep_dev->cache_addr = sep_dev->rar_addr;
215
216 /* load cache */
217 error = request_firmware(&fw, cache_name, &sep_dev->pdev->dev);
218 if (error) {
219 edbg("SEP Driver:cant request cache fw\n");
220 goto end_function;
221 }
222
223 edbg("SEP Driver:cache data loc is %p\n", (void *) fw->data);
224 edbg("SEP Driver:cache data size is %08Zx\n", fw->size);
225
226 memcpy((void *) sep_dev->cache_addr, (void *) fw->data, fw->size);
227
228 sep_dev->cache_size = fw->size;
229
230 cache_addr = (unsigned long) sep_dev->cache_addr;
231
232 release_firmware(fw);
233
234 sep_dev->resident_bus = sep_dev->cache_bus + sep_dev->cache_size;
235 sep_dev->resident_addr = sep_dev->cache_addr + sep_dev->cache_size;
236
237 /* load resident */
238 error = request_firmware(&fw, res_name, &sep_dev->pdev->dev);
239 if (error) {
240 edbg("SEP Driver:cant request res fw\n");
241 goto end_function;
242 }
243
244 edbg("SEP Driver:res data loc is %p\n", (void *) fw->data);
245 edbg("SEP Driver:res data size is %08Zx\n", fw->size);
246
247 memcpy((void *) sep_dev->resident_addr, (void *) fw->data, fw->size);
248
249 sep_dev->resident_size = fw->size;
250
251 release_firmware(fw);
252
253 resident_addr = (unsigned long) sep_dev->resident_addr;
254
255 edbg("SEP Driver:resident_addr (physical )is %08lx\n", sep_dev->resident_bus);
256 edbg("SEP Driver:cache_addr (physical) is %08lx\n", sep_dev->cache_bus);
257
258 edbg("SEP Driver:resident_addr (logical )is %08lx\n", resident_addr);
259 edbg("SEP Driver:cache_addr (logical) is %08lx\n", cache_addr);
260
261 edbg("SEP Driver:resident_size is %08lx\n", sep_dev->resident_size);
262 edbg("SEP Driver:cache_size is %08lx\n", sep_dev->cache_size);
263
264
265
266 /* physical addresses */
267 *dst_new_cache_addr_ptr = sep_dev->cache_bus;
268 *dst_new_resident_addr_ptr = sep_dev->resident_bus;
269 end_function:
270 return error;
271 }
272
273 /*
274 This functions maps and allocates the
275 shared area on the external RAM (device)
276 The input is shared_area_size - the size of the memory to
277 allocate. The outputs
278 are kernel_shared_area_addr_ptr - the kerenl
279 address of the mapped and allocated
280 shared area, and phys_shared_area_addr_ptr
281 - the physical address of the shared area
282 */
283 static int sep_map_and_alloc_shared_area(unsigned long shared_area_size, unsigned long *kernel_shared_area_addr_ptr, unsigned long *phys_shared_area_addr_ptr)
284 {
285 // shared_addr = ioremap_nocache(0xda00000,shared_area_size);
286 sep_dev->shared_addr = kmalloc(shared_area_size, GFP_KERNEL);
287 if (!sep_dev->shared_addr) {
288 edbg("sep_driver:shared memory kmalloc failed\n");
289 return -1;
290 }
291 /* FIXME */
292 sep_dev->shared_bus = __pa(sep_dev->shared_addr);
293 /* shared_bus = 0xda00000; */
294 *kernel_shared_area_addr_ptr = (unsigned long) sep_dev->shared_addr;
295 /* set the physical address of the shared area */
296 *phys_shared_area_addr_ptr = sep_dev->shared_bus;
297 edbg("SEP Driver:shared_addr is %p\n", sep_dev->shared_addr);
298 edbg("SEP Driver:shared_region_size is %08lx\n", shared_area_size);
299 edbg("SEP Driver:shared_physical_addr is %08lx\n", *phys_shared_area_addr_ptr);
300
301 return 0;
302 }
303
304 /*
305 This functions unmaps and deallocates the shared area
306 on the external RAM (device)
307 The input is shared_area_size - the size of the memory to deallocate,kernel_
308 shared_area_addr_ptr - the kernel address of the mapped and allocated
309 shared area,phys_shared_area_addr_ptr - the physical address of
310 the shared area
311 */
312 static void sep_unmap_and_free_shared_area(unsigned long shared_area_size, unsigned long kernel_shared_area_addr, unsigned long phys_shared_area_addr)
313 {
314 kfree((void *) kernel_shared_area_addr);
315 }
316
317 /*
318 This functions returns the physical address inside shared area according
319 to the virtual address. It can be either on the externa RAM device
320 (ioremapped), or on the system RAM
321 This implementation is for the external RAM
322 */
323 static unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address)
324 {
325 edbg("SEP Driver:sh virt to phys v %08lx\n", virt_address);
326 edbg("SEP Driver:sh virt to phys p %08lx\n", sep_dev->shared_bus + (virt_address - (unsigned long) sep_dev->shared_addr));
327
328 return (unsigned long) sep_dev->shared_bus + (virt_address - (unsigned long) sep_dev->shared_addr);
329 }
330
331 /*
332 This functions returns the virtual address inside shared area
333 according to the physical address. It can be either on the
334 externa RAM device (ioremapped), or on the system RAM This implementation
335 is for the external RAM
336 */
337 static unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address)
338 {
339 return (unsigned long) sep_dev->shared_addr + (phys_address - sep_dev->shared_bus);
340 }
341
342
343 /*----------------------------------------------------------------------
344 open function of the character driver - must only lock the mutex
345 must also release the memory data pool allocations
346 ------------------------------------------------------------------------*/
347 static int sep_open(struct inode *inode, struct file *filp)
348 {
349 int error = 0;
350
351 dbg("SEP Driver:--------> open start\n");
352
353 /* check the blocking mode */
354 if (filp->f_flags & O_NDELAY)
355 error = mutex_trylock(&sep_mutex);
356 else
357 /* lock mutex */
358 mutex_lock(&sep_mutex);
359
360 /* check the error */
361 if (error) {
362 edbg("SEP Driver: down_interruptible failed\n");
363 goto end_function;
364 }
365
366 /* release data pool allocations */
367 sep_dev->data_pool_bytes_allocated = 0;
368
369 end_function:
370 dbg("SEP Driver:<-------- open end\n");
371 return error;
372 }
373
374
375
376
377 /*------------------------------------------------------------
378 release function
379 -------------------------------------------------------------*/
380 static int sep_release(struct inode *inode_ptr, struct file *file_ptr)
381 {
382 dbg("----------->SEP Driver: sep_release start\n");
383
384 #if 0 /*!SEP_DRIVER_POLLING_MODE */
385 /* close IMR */
386 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF);
387 /* release IRQ line */
388 free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_addr);
389
390 #endif
391 /* unlock the sep mutex */
392 mutex_unlock(&sep_mutex);
393 dbg("SEP Driver:<-------- sep_release end\n");
394 return 0;
395 }
396
397
398
399
400 /*---------------------------------------------------------------
401 map function - this functions maps the message shared area
402 -----------------------------------------------------------------*/
403 static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
404 {
405 unsigned long phys_addr;
406
407 dbg("-------->SEP Driver: mmap start\n");
408
409 /* check that the size of the mapped range is as the size of the message
410 shared area */
411 if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) {
412 edbg("SEP Driver mmap requested size is more than allowed\n");
413 printk(KERN_WARNING "SEP Driver mmap requested size is more \
414 than allowed\n");
415 printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_end);
416 printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_start);
417 return -EAGAIN;
418 }
419
420 edbg("SEP Driver:sep_dev->message_shared_area_addr is %08lx\n", sep_dev->message_shared_area_addr);
421
422 /* get physical address */
423 phys_addr = sep_dev->shared_area_bus;
424
425 edbg("SEP Driver: phys_addr is %08lx\n", phys_addr);
426
427 if (remap_pfn_range(vma, vma->vm_start, phys_addr >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
428 edbg("SEP Driver remap_page_range failed\n");
429 printk(KERN_WARNING "SEP Driver remap_page_range failed\n");
430 return -EAGAIN;
431 }
432
433 dbg("SEP Driver:<-------- mmap end\n");
434
435 return 0;
436 }
437
438
439 /*-----------------------------------------------
440 poll function
441 *----------------------------------------------*/
442 static unsigned int sep_poll(struct file *filp, poll_table * wait)
443 {
444 unsigned long count;
445 unsigned int mask = 0;
446 unsigned long retVal = 0; /* flow id */
447
448 dbg("---------->SEP Driver poll: start\n");
449
450
451 #if SEP_DRIVER_POLLING_MODE
452
453 while (sep_dev->send_ct != (retVal & 0x7FFFFFFF)) {
454 retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
455
456 for (count = 0; count < 10 * 4; count += 4)
457 edbg("Poll Debug Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area + SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count)));
458 }
459
460 sep_dev->reply_ct++;
461 #else
462 /* add the event to the polling wait table */
463 poll_wait(filp, &sep_event, wait);
464
465 #endif
466
467 edbg("sep_dev->send_ct is %lu\n", sep_dev->send_ct);
468 edbg("sep_dev->reply_ct is %lu\n", sep_dev->reply_ct);
469
470 /* check if the data is ready */
471 if (sep_dev->send_ct == sep_dev->reply_ct) {
472 for (count = 0; count < 12 * 4; count += 4)
473 edbg("Sep Mesg Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area + count)));
474
475 for (count = 0; count < 10 * 4; count += 4)
476 edbg("Debug Data Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area + 0x1800 + count)));
477
478 retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
479 edbg("retVal is %lu\n", retVal);
480 /* check if the this is sep reply or request */
481 if (retVal >> 31) {
482 edbg("SEP Driver: sep request in\n");
483 /* request */
484 mask |= POLLOUT | POLLWRNORM;
485 } else {
486 edbg("SEP Driver: sep reply in\n");
487 mask |= POLLIN | POLLRDNORM;
488 }
489 }
490 dbg("SEP Driver:<-------- poll exit\n");
491 return mask;
492 }
493
494 /*
495 calculates time and sets it at the predefined address
496 */
497 static int sep_set_time(unsigned long *address_ptr, unsigned long *time_in_sec_ptr)
498 {
499 struct timeval time;
500 /* address of time in the kernel */
501 unsigned long time_addr;
502
503
504 dbg("SEP Driver:--------> sep_set_time start\n");
505
506 do_gettimeofday(&time);
507
508 /* set value in the SYSTEM MEMORY offset */
509 time_addr = sep_dev->message_shared_area_addr + SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES;
510
511 *(unsigned long *) time_addr = SEP_TIME_VAL_TOKEN;
512 *(unsigned long *) (time_addr + 4) = time.tv_sec;
513
514 edbg("SEP Driver:time.tv_sec is %lu\n", time.tv_sec);
515 edbg("SEP Driver:time_addr is %lu\n", time_addr);
516 edbg("SEP Driver:sep_dev->message_shared_area_addr is %lu\n", sep_dev->message_shared_area_addr);
517
518 /* set the output parameters if needed */
519 if (address_ptr)
520 *address_ptr = sep_shared_area_virt_to_phys(time_addr);
521
522 if (time_in_sec_ptr)
523 *time_in_sec_ptr = time.tv_sec;
524
525 dbg("SEP Driver:<-------- sep_set_time end\n");
526
527 return 0;
528 }
529
530 /*
531 This function raises interrupt to SEP that signals that is has a new
532 command from HOST
533 */
534 static void sep_send_command_handler(void)
535 {
536 unsigned long count;
537
538 dbg("SEP Driver:--------> sep_send_command_handler start\n");
539 sep_set_time(0, 0);
540
541 /* flash cache */
542 flush_cache_all();
543
544 for (count = 0; count < 12 * 4; count += 4)
545 edbg("Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area + count)));
546
547 /* update counter */
548 sep_dev->send_ct++;
549 /* send interrupt to SEP */
550 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
551 dbg("SEP Driver:<-------- sep_send_command_handler end\n");
552 return;
553 }
554
555 /*
556 This function raises interrupt to SEPm that signals that is has a
557 new command from HOST
558 */
559 static void sep_send_reply_command_handler(void)
560 {
561 unsigned long count;
562
563 dbg("SEP Driver:--------> sep_send_reply_command_handler start\n");
564
565 /* flash cache */
566 flush_cache_all();
567 for (count = 0; count < 12 * 4; count += 4)
568 edbg("Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area + count)));
569 /* update counter */
570 sep_dev->send_ct++;
571 /* send the interrupt to SEP */
572 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, sep_dev->send_ct);
573 /* update both counters */
574 sep_dev->send_ct++;
575 sep_dev->reply_ct++;
576 dbg("SEP Driver:<-------- sep_send_reply_command_handler end\n");
577 }
578
579 /*
580 This function handles the allocate data pool memory request
581 This function returns calculates the physical address of the
582 allocated memory, and the offset of this area from the mapped address.
583 Therefore, the FVOs in user space can calculate the exact virtual
584 address of this allocated memory
585 */
586 static int sep_allocate_data_pool_memory_handler(unsigned long arg)
587 {
588 int error;
589 struct sep_driver_alloc_t command_args;
590
591 dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n");
592
593 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_alloc_t));
594 if (error)
595 goto end_function;
596
597 /* allocate memory */
598 if ((sep_dev->data_pool_bytes_allocated + command_args.num_bytes) > SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) {
599 error = -ENOTTY;
600 goto end_function;
601 }
602
603 /* set the virtual and physical address */
604 command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep_dev->data_pool_bytes_allocated;
605 command_args.phys_address = sep_dev->shared_area_bus + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep_dev->data_pool_bytes_allocated;
606
607 /* write the memory back to the user space */
608 error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_alloc_t));
609 if (error)
610 goto end_function;
611
612 /* set the allocation */
613 sep_dev->data_pool_bytes_allocated += command_args.num_bytes;
614
615 end_function:
616 dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n");
617 return error;
618 }
619
620 /*
621 This function handles write into allocated data pool command
622 */
623 static int sep_write_into_data_pool_handler(unsigned long arg)
624 {
625 int error;
626 unsigned long virt_address;
627 unsigned long app_in_address;
628 unsigned long num_bytes;
629 unsigned long data_pool_area_addr;
630
631 dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n");
632
633 /* get the application address */
634 error = get_user(app_in_address, &(((struct sep_driver_write_t *) arg)->app_address));
635 if (error)
636 goto end_function;
637
638 /* get the virtual kernel address address */
639 error = get_user(virt_address, &(((struct sep_driver_write_t *) arg)->datapool_address));
640 if (error)
641 goto end_function;
642
643 /* get the number of bytes */
644 error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes));
645 if (error)
646 goto end_function;
647
648 /* calculate the start of the data pool */
649 data_pool_area_addr = sep_dev->shared_area + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
650
651
652 /* check that the range of the virtual kernel address is correct */
653 if ((virt_address < data_pool_area_addr) || (virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) {
654 error = -ENOTTY;
655 goto end_function;
656 }
657 /* copy the application data */
658 error = copy_from_user((void *) virt_address, (void *) app_in_address, num_bytes);
659 end_function:
660 dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n");
661 return error;
662 }
663
664 /*
665 this function handles the read from data pool command
666 */
667 static int sep_read_from_data_pool_handler(unsigned long arg)
668 {
669 int error;
670 /* virtual address of dest application buffer */
671 unsigned long app_out_address;
672 /* virtual address of the data pool */
673 unsigned long virt_address;
674 unsigned long num_bytes;
675 unsigned long data_pool_area_addr;
676
677 dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n");
678
679 /* get the application address */
680 error = get_user(app_out_address, &(((struct sep_driver_write_t *) arg)->app_address));
681 if (error)
682 goto end_function;
683
684 /* get the virtual kernel address address */
685 error = get_user(virt_address, &(((struct sep_driver_write_t *) arg)->datapool_address));
686 if (error)
687 goto end_function;
688
689 /* get the number of bytes */
690 error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes));
691 if (error)
692 goto end_function;
693
694 /* calculate the start of the data pool */
695 data_pool_area_addr = sep_dev->shared_area + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES;
696
697 /* check that the range of the virtual kernel address is correct */
698 if ((virt_address < data_pool_area_addr) || (virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) {
699 error = -ENOTTY;
700 goto end_function;
701 }
702
703 /* copy the application data */
704 error = copy_to_user((void *) app_out_address, (void *) virt_address, num_bytes);
705 end_function:
706 dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n");
707 return error;
708 }
709
710 /*
711 This function releases all the application virtual buffer physical pages,
712 that were previously locked
713 */
714 static int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag)
715 {
716 unsigned long count;
717
718 if (dirtyFlag) {
719 for (count = 0; count < num_pages; count++) {
720 /* the out array was written, therefore the data was changed */
721 if (!PageReserved(page_array_ptr[count]))
722 SetPageDirty(page_array_ptr[count]);
723 page_cache_release(page_array_ptr[count]);
724 }
725 } else {
726 /* free in pages - the data was only read, therefore no update was done
727 on those pages */
728 for (count = 0; count < num_pages; count++)
729 page_cache_release(page_array_ptr[count]);
730 }
731
732 if (page_array_ptr)
733 /* free the array */
734 kfree(page_array_ptr);
735
736 return 0;
737 }
738
739 /*
740 This function locks all the physical pages of the kernel virtual buffer
741 and construct a basic lli array, where each entry holds the physical
742 page address and the size that application data holds in this physical pages
743 */
744 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)
745 {
746 int error = 0;
747 /* the the page of the end address of the user space buffer */
748 unsigned long end_page;
749 /* the page of the start address of the user space buffer */
750 unsigned long start_page;
751 /* the range in pages */
752 unsigned long num_pages;
753 struct sep_lli_entry_t *lli_array;
754 /* next kernel address to map */
755 unsigned long next_kernel_address;
756 unsigned long count;
757
758 dbg("SEP Driver:--------> sep_lock_kernel_pages start\n");
759
760 /* set start and end pages and num pages */
761 end_page = (kernel_virt_addr + data_size - 1) >> PAGE_SHIFT;
762 start_page = kernel_virt_addr >> PAGE_SHIFT;
763 num_pages = end_page - start_page + 1;
764
765 edbg("SEP Driver: kernel_virt_addr is %08lx\n", kernel_virt_addr);
766 edbg("SEP Driver: data_size is %lu\n", data_size);
767 edbg("SEP Driver: start_page is %lx\n", start_page);
768 edbg("SEP Driver: end_page is %lx\n", end_page);
769 edbg("SEP Driver: num_pages is %lu\n", num_pages);
770
771 lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC);
772 if (!lli_array) {
773 edbg("SEP Driver: kmalloc for lli_array failed\n");
774 error = -ENOMEM;
775 goto end_function;
776 }
777
778 /* set the start address of the first page - app data may start not at
779 the beginning of the page */
780 lli_array[0].physical_address = (unsigned long) virt_to_phys((unsigned long *) kernel_virt_addr);
781
782 /* check that not all the data is in the first page only */
783 if ((PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK))) >= data_size)
784 lli_array[0].block_size = data_size;
785 else
786 lli_array[0].block_size = PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK));
787
788 /* debug print */
789 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);
790
791 /* advance the address to the start of the next page */
792 next_kernel_address = (kernel_virt_addr & PAGE_MASK) + PAGE_SIZE;
793
794 /* go from the second page to the prev before last */
795 for (count = 1; count < (num_pages - 1); count++) {
796 lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address);
797 lli_array[count].block_size = PAGE_SIZE;
798
799 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);
800 next_kernel_address += PAGE_SIZE;
801 }
802
803 /* if more then 1 pages locked - then update for the last page size needed */
804 if (num_pages > 1) {
805 /* update the address of the last page */
806 lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address);
807
808 /* set the size of the last page */
809 lli_array[count].block_size = (kernel_virt_addr + data_size) & (~PAGE_MASK);
810
811 if (lli_array[count].block_size == 0) {
812 dbg("app_virt_addr is %08lx\n", kernel_virt_addr);
813 dbg("data_size is %lu\n", data_size);
814 while (1);
815 }
816
817 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);
818 }
819 /* set output params */
820 *lli_array_ptr = lli_array;
821 *num_pages_ptr = num_pages;
822 *page_array_ptr = 0;
823 end_function:
824 dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n");
825 return 0;
826 }
827
828 /*
829 This function locks all the physical pages of the application virtual buffer
830 and construct a basic lli array, where each entry holds the physical page
831 address and the size that application data holds in this physical pages
832 */
833 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)
834 {
835 int error = 0;
836 /* the the page of the end address of the user space buffer */
837 unsigned long end_page;
838 /* the page of the start address of the user space buffer */
839 unsigned long start_page;
840 /* the range in pages */
841 unsigned long num_pages;
842 struct page **page_array;
843 struct sep_lli_entry_t *lli_array;
844 unsigned long count;
845 int result;
846
847 dbg("SEP Driver:--------> sep_lock_user_pages start\n");
848
849 /* set start and end pages and num pages */
850 end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
851 start_page = app_virt_addr >> PAGE_SHIFT;
852 num_pages = end_page - start_page + 1;
853
854 edbg("SEP Driver: app_virt_addr is %08lx\n", app_virt_addr);
855 edbg("SEP Driver: data_size is %lu\n", data_size);
856 edbg("SEP Driver: start_page is %lu\n", start_page);
857 edbg("SEP Driver: end_page is %lu\n", end_page);
858 edbg("SEP Driver: num_pages is %lu\n", num_pages);
859
860 /* allocate array of pages structure pointers */
861 page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
862 if (!page_array) {
863 edbg("SEP Driver: kmalloc for page_array failed\n");
864
865 error = -ENOMEM;
866 goto end_function;
867 }
868
869 lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC);
870 if (!lli_array) {
871 edbg("SEP Driver: kmalloc for lli_array failed\n");
872
873 error = -ENOMEM;
874 goto end_function_with_error1;
875 }
876
877 /* convert the application virtual address into a set of physical */
878 down_read(&current->mm->mmap_sem);
879 result = get_user_pages(current, current->mm, app_virt_addr, num_pages, 1, 0, page_array, 0);
880 up_read(&current->mm->mmap_sem);
881
882 /* check the number of pages locked - if not all then exit with error */
883 if (result != num_pages) {
884 dbg("SEP Driver: not all pages locked by get_user_pages\n");
885
886 error = -ENOMEM;
887 goto end_function_with_error2;
888 }
889
890 /* flush the cache */
891 for (count = 0; count < num_pages; count++)
892 flush_dcache_page(page_array[count]);
893
894 /* set the start address of the first page - app data may start not at
895 the beginning of the page */
896 lli_array[0].physical_address = ((unsigned long) page_to_phys(page_array[0])) + (app_virt_addr & (~PAGE_MASK));
897
898 /* check that not all the data is in the first page only */
899 if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size)
900 lli_array[0].block_size = data_size;
901 else
902 lli_array[0].block_size = PAGE_SIZE - (app_virt_addr & (~PAGE_MASK));
903
904 /* debug print */
905 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);
906
907 /* go from the second page to the prev before last */
908 for (count = 1; count < (num_pages - 1); count++) {
909 lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]);
910 lli_array[count].block_size = PAGE_SIZE;
911
912 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);
913 }
914
915 /* if more then 1 pages locked - then update for the last page size needed */
916 if (num_pages > 1) {
917 /* update the address of the last page */
918 lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]);
919
920 /* set the size of the last page */
921 lli_array[count].block_size = (app_virt_addr + data_size) & (~PAGE_MASK);
922
923 if (lli_array[count].block_size == 0) {
924 dbg("app_virt_addr is %08lx\n", app_virt_addr);
925 dbg("data_size is %lu\n", data_size);
926 while (1);
927 }
928 edbg("lli_array[%lu].physical_address is %08lx, \
929 lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size);
930 }
931
932 /* set output params */
933 *lli_array_ptr = lli_array;
934 *num_pages_ptr = num_pages;
935 *page_array_ptr = page_array;
936 goto end_function;
937
938 end_function_with_error2:
939 /* release the cache */
940 for (count = 0; count < num_pages; count++)
941 page_cache_release(page_array[count]);
942 kfree(lli_array);
943 end_function_with_error1:
944 kfree(page_array);
945 end_function:
946 dbg("SEP Driver:<-------- sep_lock_user_pages end\n");
947 return 0;
948 }
949
950
951 /*
952 this function calculates the size of data that can be inserted into the lli
953 table from this array the condition is that either the table is full
954 (all etnries are entered), or there are no more entries in the lli array
955 */
956 static unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t *lli_in_array_ptr, unsigned long num_array_entries)
957 {
958 unsigned long table_data_size = 0;
959 unsigned long counter;
960
961 /* calculate the data in the out lli table if till we fill the whole
962 table or till the data has ended */
963 for (counter = 0; (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) && (counter < num_array_entries); counter++)
964 table_data_size += lli_in_array_ptr[counter].block_size;
965 return table_data_size;
966 }
967
968 /*
969 this functions builds ont lli table from the lli_array according to
970 the given size of data
971 */
972 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)
973 {
974 unsigned long curr_table_data_size;
975 /* counter of lli array entry */
976 unsigned long array_counter;
977
978 dbg("SEP Driver:--------> sep_build_lli_table start\n");
979
980 /* init currrent table data size and lli array entry counter */
981 curr_table_data_size = 0;
982 array_counter = 0;
983 *num_table_entries_ptr = 1;
984
985 edbg("SEP Driver:table_data_size is %lu\n", table_data_size);
986
987 /* fill the table till table size reaches the needed amount */
988 while (curr_table_data_size < table_data_size) {
989 /* update the number of entries in table */
990 (*num_table_entries_ptr)++;
991
992 lli_table_ptr->physical_address = lli_array_ptr[array_counter].physical_address;
993 lli_table_ptr->block_size = lli_array_ptr[array_counter].block_size;
994 curr_table_data_size += lli_table_ptr->block_size;
995
996 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr);
997 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
998 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
999
1000 /* check for overflow of the table data */
1001 if (curr_table_data_size > table_data_size) {
1002 edbg("SEP Driver:curr_table_data_size > table_data_size\n");
1003
1004 /* update the size of block in the table */
1005 lli_table_ptr->block_size -= (curr_table_data_size - table_data_size);
1006
1007 /* update the physical address in the lli array */
1008 lli_array_ptr[array_counter].physical_address += lli_table_ptr->block_size;
1009
1010 /* update the block size left in the lli array */
1011 lli_array_ptr[array_counter].block_size = (curr_table_data_size - table_data_size);
1012 } else
1013 /* advance to the next entry in the lli_array */
1014 array_counter++;
1015
1016 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1017 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1018
1019 /* move to the next entry in table */
1020 lli_table_ptr++;
1021 }
1022
1023 /* set the info entry to default */
1024 lli_table_ptr->physical_address = 0xffffffff;
1025 lli_table_ptr->block_size = 0;
1026
1027 edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr);
1028 edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1029 edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1030
1031 /* set the output parameter */
1032 *num_processed_entries_ptr += array_counter;
1033
1034 edbg("SEP Driver:*num_processed_entries_ptr is %lu\n", *num_processed_entries_ptr);
1035 dbg("SEP Driver:<-------- sep_build_lli_table end\n");
1036 return;
1037 }
1038
1039 /*
1040 this function goes over the list of the print created tables and
1041 prints all the data
1042 */
1043 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)
1044 {
1045 unsigned long table_count;
1046 unsigned long entries_count;
1047
1048 dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n");
1049
1050 table_count = 1;
1051 while ((unsigned long) lli_table_ptr != 0xffffffff) {
1052 edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", table_count, table_data_size);
1053 edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries);
1054
1055 /* print entries of the table (without info entry) */
1056 for (entries_count = 0; entries_count < num_table_entries; entries_count++, lli_table_ptr++) {
1057 edbg("SEP Driver:lli_table_ptr address is %08lx\n", (unsigned long) lli_table_ptr);
1058 edbg("SEP Driver:phys address is %08lx block size is %lu\n", lli_table_ptr->physical_address, lli_table_ptr->block_size);
1059 }
1060
1061 /* point to the info entry */
1062 lli_table_ptr--;
1063
1064 edbg("SEP Driver:phys lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size);
1065 edbg("SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address);
1066
1067
1068 table_data_size = lli_table_ptr->block_size & 0xffffff;
1069 num_table_entries = (lli_table_ptr->block_size >> 24) & 0xff;
1070 lli_table_ptr = (struct sep_lli_entry_t *)
1071 (lli_table_ptr->physical_address);
1072
1073 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);
1074
1075 if ((unsigned long) lli_table_ptr != 0xffffffff)
1076 lli_table_ptr = (struct sep_lli_entry_t *) sep_shared_area_phys_to_virt((unsigned long) lli_table_ptr);
1077
1078 table_count++;
1079 }
1080 dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n");
1081 }
1082
1083
1084 /*
1085 This function prepares only input DMA table for synhronic symmetric
1086 operations (HASH)
1087 */
1088 static 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)
1089 {
1090 /* pointer to the info entry of the table - the last entry */
1091 struct sep_lli_entry_t *info_entry_ptr;
1092 /* array of pointers ot page */
1093 struct sep_lli_entry_t *lli_array_ptr;
1094 /* points to the first entry to be processed in the lli_in_array */
1095 unsigned long current_entry;
1096 /* num entries in the virtual buffer */
1097 unsigned long sep_lli_entries;
1098 /* lli table pointer */
1099 struct sep_lli_entry_t *in_lli_table_ptr;
1100 /* the total data in one table */
1101 unsigned long table_data_size;
1102 /* number of entries in lli table */
1103 unsigned long num_entries_in_table;
1104 /* next table address */
1105 unsigned long lli_table_alloc_addr;
1106 unsigned long result;
1107
1108 dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n");
1109
1110 edbg("SEP Driver:data_size is %lu\n", data_size);
1111 edbg("SEP Driver:block_size is %lu\n", block_size);
1112
1113 /* initialize the pages pointers */
1114 sep_dev->in_page_array = 0;
1115 sep_dev->in_num_pages = 0;
1116
1117 if (data_size == 0) {
1118 /* special case - created 2 entries table with zero data */
1119 in_lli_table_ptr = (struct sep_lli_entry_t *) (sep_dev->shared_area + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES);
1120 in_lli_table_ptr->physical_address = sep_dev->shared_area + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1121 in_lli_table_ptr->block_size = 0;
1122
1123 in_lli_table_ptr++;
1124 in_lli_table_ptr->physical_address = 0xFFFFFFFF;
1125 in_lli_table_ptr->block_size = 0;
1126
1127 *lli_table_ptr = sep_dev->shared_area_bus + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1128 *num_entries_ptr = 2;
1129 *table_data_size_ptr = 0;
1130
1131 goto end_function;
1132 }
1133
1134 /* check if the pages are in Kernel Virtual Address layout */
1135 if (isKernelVirtualAddress == true)
1136 /* lock the pages of the kernel buffer and translate them to pages */
1137 result = sep_lock_kernel_pages(app_virt_addr, data_size, &sep_dev->in_num_pages, &lli_array_ptr, &sep_dev->in_page_array);
1138 else
1139 /* lock the pages of the user buffer and translate them to pages */
1140 result = sep_lock_user_pages(app_virt_addr, data_size, &sep_dev->in_num_pages, &lli_array_ptr, &sep_dev->in_page_array);
1141
1142 if (result)
1143 return result;
1144
1145 edbg("SEP Driver:output sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages);
1146
1147 current_entry = 0;
1148 info_entry_ptr = 0;
1149 sep_lli_entries = sep_dev->in_num_pages;
1150
1151 /* initiate to point after the message area */
1152 lli_table_alloc_addr = sep_dev->shared_area + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1153
1154 /* loop till all the entries in in array are not processed */
1155 while (current_entry < sep_lli_entries) {
1156 /* set the new input and output tables */
1157 in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1158
1159 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1160
1161 /* calculate the maximum size of data for input table */
1162 table_data_size = sep_calculate_lli_table_max_size(&lli_array_ptr[current_entry], (sep_lli_entries - current_entry));
1163
1164 /* now calculate the table size so that it will be module block size */
1165 table_data_size = (table_data_size / block_size) * block_size;
1166
1167 edbg("SEP Driver:output table_data_size is %lu\n", table_data_size);
1168
1169 /* construct input lli table */
1170 sep_build_lli_table(&lli_array_ptr[current_entry], in_lli_table_ptr, &current_entry, &num_entries_in_table, table_data_size);
1171
1172 if (info_entry_ptr == 0) {
1173 /* set the output parameters to physical addresses */
1174 *lli_table_ptr = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr);
1175 *num_entries_ptr = num_entries_in_table;
1176 *table_data_size_ptr = table_data_size;
1177
1178 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_ptr);
1179 } else {
1180 /* update the info entry of the previous in table */
1181 info_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr);
1182 info_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size);
1183 }
1184
1185 /* save the pointer to the info entry of the current tables */
1186 info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
1187 }
1188
1189 /* print input tables */
1190 sep_debug_print_lli_tables((struct sep_lli_entry_t *)
1191 sep_shared_area_phys_to_virt(*lli_table_ptr), *num_entries_ptr, *table_data_size_ptr);
1192
1193 /* the array of the pages */
1194 kfree(lli_array_ptr);
1195 end_function:
1196 dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n");
1197 return 0;
1198
1199 }
1200
1201 /*
1202 This function creates the input and output dma tables for
1203 symmetric operations (AES/DES) according to the block size from LLI arays
1204 */
1205 static int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array,
1206 unsigned long sep_in_lli_entries,
1207 struct sep_lli_entry_t *lli_out_array,
1208 unsigned long sep_out_lli_entries,
1209 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)
1210 {
1211 /* points to the area where next lli table can be allocated */
1212 unsigned long lli_table_alloc_addr;
1213 /* input lli table */
1214 struct sep_lli_entry_t *in_lli_table_ptr;
1215 /* output lli table */
1216 struct sep_lli_entry_t *out_lli_table_ptr;
1217 /* pointer to the info entry of the table - the last entry */
1218 struct sep_lli_entry_t *info_in_entry_ptr;
1219 /* pointer to the info entry of the table - the last entry */
1220 struct sep_lli_entry_t *info_out_entry_ptr;
1221 /* points to the first entry to be processed in the lli_in_array */
1222 unsigned long current_in_entry;
1223 /* points to the first entry to be processed in the lli_out_array */
1224 unsigned long current_out_entry;
1225 /* max size of the input table */
1226 unsigned long in_table_data_size;
1227 /* max size of the output table */
1228 unsigned long out_table_data_size;
1229 /* flag te signifies if this is the first tables build from the arrays */
1230 unsigned long first_table_flag;
1231 /* the data size that should be in table */
1232 unsigned long table_data_size;
1233 /* number of etnries in the input table */
1234 unsigned long num_entries_in_table;
1235 /* number of etnries in the output table */
1236 unsigned long num_entries_out_table;
1237
1238 dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n");
1239
1240 /* initiate to pint after the message area */
1241 lli_table_alloc_addr = sep_dev->shared_area + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1242
1243 current_in_entry = 0;
1244 current_out_entry = 0;
1245 first_table_flag = 1;
1246 info_in_entry_ptr = 0;
1247 info_out_entry_ptr = 0;
1248
1249 /* loop till all the entries in in array are not processed */
1250 while (current_in_entry < sep_in_lli_entries) {
1251 /* set the new input and output tables */
1252 in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1253
1254 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1255
1256 /* set the first output tables */
1257 out_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr;
1258
1259 lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
1260
1261 /* calculate the maximum size of data for input table */
1262 in_table_data_size = sep_calculate_lli_table_max_size(&lli_in_array[current_in_entry], (sep_in_lli_entries - current_in_entry));
1263
1264 /* calculate the maximum size of data for output table */
1265 out_table_data_size = sep_calculate_lli_table_max_size(&lli_out_array[current_out_entry], (sep_out_lli_entries - current_out_entry));
1266
1267 edbg("SEP Driver:in_table_data_size is %lu\n", in_table_data_size);
1268 edbg("SEP Driver:out_table_data_size is %lu\n", out_table_data_size);
1269
1270 /* check where the data is smallest */
1271 table_data_size = in_table_data_size;
1272 if (table_data_size > out_table_data_size)
1273 table_data_size = out_table_data_size;
1274
1275 /* now calculate the table size so that it will be module block size */
1276 table_data_size = (table_data_size / block_size) * block_size;
1277
1278 dbg("SEP Driver:table_data_size is %lu\n", table_data_size);
1279
1280 /* construct input lli table */
1281 sep_build_lli_table(&lli_in_array[current_in_entry], in_lli_table_ptr, &current_in_entry, &num_entries_in_table, table_data_size);
1282
1283 /* construct output lli table */
1284 sep_build_lli_table(&lli_out_array[current_out_entry], out_lli_table_ptr, &current_out_entry, &num_entries_out_table, table_data_size);
1285
1286 /* if info entry is null - this is the first table built */
1287 if (info_in_entry_ptr == 0) {
1288 /* set the output parameters to physical addresses */
1289 *lli_table_in_ptr = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr);
1290 *in_num_entries_ptr = num_entries_in_table;
1291 *lli_table_out_ptr = sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr);
1292 *out_num_entries_ptr = num_entries_out_table;
1293 *table_data_size_ptr = table_data_size;
1294
1295 edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr);
1296 edbg("SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr);
1297 } else {
1298 /* update the info entry of the previous in table */
1299 info_in_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr);
1300 info_in_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size);
1301
1302 /* update the info entry of the previous in table */
1303 info_out_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr);
1304 info_out_entry_ptr->block_size = ((num_entries_out_table) << 24) | (table_data_size);
1305 }
1306
1307 /* save the pointer to the info entry of the current tables */
1308 info_in_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
1309 info_out_entry_ptr = out_lli_table_ptr + num_entries_out_table - 1;
1310
1311 edbg("SEP Driver:output num_entries_out_table is %lu\n", (unsigned long) num_entries_out_table);
1312 edbg("SEP Driver:output info_in_entry_ptr is %lu\n", (unsigned long) info_in_entry_ptr);
1313 edbg("SEP Driver:output info_out_entry_ptr is %lu\n", (unsigned long) info_out_entry_ptr);
1314 }
1315
1316 /* print input tables */
1317 sep_debug_print_lli_tables((struct sep_lli_entry_t *)
1318 sep_shared_area_phys_to_virt(*lli_table_in_ptr), *in_num_entries_ptr, *table_data_size_ptr);
1319 /* print output tables */
1320 sep_debug_print_lli_tables((struct sep_lli_entry_t *)
1321 sep_shared_area_phys_to_virt(*lli_table_out_ptr), *out_num_entries_ptr, *table_data_size_ptr);
1322 dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n");
1323 return 0;
1324 }
1325
1326
1327 /*
1328 This function builds input and output DMA tables for synhronic
1329 symmetric operations (AES, DES). It also checks that each table
1330 is of the modular block size
1331 */
1332 static int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr,
1333 unsigned long app_virt_out_addr,
1334 unsigned long data_size,
1335 unsigned long block_size,
1336 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)
1337 {
1338 /* array of pointers of page */
1339 struct sep_lli_entry_t *lli_in_array;
1340 /* array of pointers of page */
1341 struct sep_lli_entry_t *lli_out_array;
1342 int result = 0;
1343
1344 dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n");
1345
1346 /* initialize the pages pointers */
1347 sep_dev->in_page_array = 0;
1348 sep_dev->out_page_array = 0;
1349
1350 /* check if the pages are in Kernel Virtual Address layout */
1351 if (isKernelVirtualAddress == true) {
1352 /* lock the pages of the kernel buffer and translate them to pages */
1353 result = sep_lock_kernel_pages(app_virt_in_addr, data_size, &sep_dev->in_num_pages, &lli_in_array, &sep_dev->in_page_array);
1354 if (result) {
1355 edbg("SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n");
1356 goto end_function;
1357 }
1358 } else {
1359 /* lock the pages of the user buffer and translate them to pages */
1360 result = sep_lock_user_pages(app_virt_in_addr, data_size, &sep_dev->in_num_pages, &lli_in_array, &sep_dev->in_page_array);
1361 if (result) {
1362 edbg("SEP Driver: sep_lock_user_pages for input virtual buffer failed\n");
1363 goto end_function;
1364 }
1365 }
1366
1367 if (isKernelVirtualAddress == true) {
1368 result = sep_lock_kernel_pages(app_virt_out_addr, data_size, &sep_dev->out_num_pages, &lli_out_array, &sep_dev->out_page_array);
1369 if (result) {
1370 edbg("SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n");
1371 goto end_function_with_error1;
1372 }
1373 } else {
1374 result = sep_lock_user_pages(app_virt_out_addr, data_size, &sep_dev->out_num_pages, &lli_out_array, &sep_dev->out_page_array);
1375 if (result) {
1376 edbg("SEP Driver: sep_lock_user_pages for output virtual buffer failed\n");
1377 goto end_function_with_error1;
1378 }
1379 }
1380 edbg("sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages);
1381 edbg("sep_dev->out_num_pages is %lu\n", sep_dev->out_num_pages);
1382 edbg("SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
1383
1384
1385 /* call the fucntion that creates table from the lli arrays */
1386 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);
1387 if (result) {
1388 edbg("SEP Driver: sep_construct_dma_tables_from_lli failed\n");
1389 goto end_function_with_error2;
1390 }
1391
1392 /* fall through - free the lli entry arrays */
1393 dbg("in_num_entries_ptr is %08lx\n", *in_num_entries_ptr);
1394 dbg("out_num_entries_ptr is %08lx\n", *out_num_entries_ptr);
1395 dbg("table_data_size_ptr is %08lx\n", *table_data_size_ptr);
1396 end_function_with_error2:
1397 kfree(lli_out_array);
1398 end_function_with_error1:
1399 kfree(lli_in_array);
1400 end_function:
1401 dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result);
1402 return result;
1403
1404 }
1405
1406 /*
1407 this function handles tha request for creation of the DMA table
1408 for the synchronic symmetric operations (AES,DES)
1409 */
1410 static int sep_create_sync_dma_tables_handler(unsigned long arg)
1411 {
1412 int error;
1413 /* command arguments */
1414 struct sep_driver_build_sync_table_t command_args;
1415
1416 dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n");
1417
1418 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_sync_table_t));
1419 if (error)
1420 goto end_function;
1421
1422 edbg("app_in_address is %08lx\n", command_args.app_in_address);
1423 edbg("app_out_address is %08lx\n", command_args.app_out_address);
1424 edbg("data_size is %lu\n", command_args.data_in_size);
1425 edbg("block_size is %lu\n", command_args.block_size);
1426
1427 /* check if we need to build only input table or input/output */
1428 if (command_args.app_out_address)
1429 /* prepare input and output tables */
1430 error = sep_prepare_input_output_dma_table(command_args.app_in_address,
1431 command_args.app_out_address,
1432 command_args.data_in_size,
1433 command_args.block_size,
1434 &command_args.in_table_address,
1435 &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);
1436 else
1437 /* prepare input tables */
1438 error = sep_prepare_input_dma_table(command_args.app_in_address,
1439 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);
1440
1441 if (error)
1442 goto end_function;
1443 /* copy to user */
1444 error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_build_sync_table_t));
1445 end_function:
1446 dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n");
1447 return error;
1448 }
1449
1450 /*
1451 this function handles the request for freeing dma table for synhronic actions
1452 */
1453 static int sep_free_dma_table_data_handler(void)
1454 {
1455 dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n");
1456
1457 /* free input pages array */
1458 sep_free_dma_pages(sep_dev->in_page_array, sep_dev->in_num_pages, 0);
1459
1460 /* free output pages array if needed */
1461 if (sep_dev->out_page_array)
1462 sep_free_dma_pages(sep_dev->out_page_array, sep_dev->out_num_pages, 1);
1463
1464 /* reset all the values */
1465 sep_dev->in_page_array = 0;
1466 sep_dev->out_page_array = 0;
1467 sep_dev->in_num_pages = 0;
1468 sep_dev->out_num_pages = 0;
1469 dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n");
1470 return 0;
1471 }
1472
1473 /*
1474 this function find a space for the new flow dma table
1475 */
1476 static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr)
1477 {
1478 int error = 0;
1479 /* pointer to the id field of the flow dma table */
1480 unsigned long *start_table_ptr;
1481 unsigned long flow_dma_area_start_addr;
1482 unsigned long flow_dma_area_end_addr;
1483 /* maximum table size in words */
1484 unsigned long table_size_in_words;
1485
1486 /* find the start address of the flow DMA table area */
1487 flow_dma_area_start_addr = sep_dev->shared_area + SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES;
1488
1489 /* set end address of the flow table area */
1490 flow_dma_area_end_addr = flow_dma_area_start_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES;
1491
1492 /* set table size in words */
1493 table_size_in_words = SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE * (sizeof(struct sep_lli_entry_t) / sizeof(long)) + 2;
1494
1495 /* set the pointer to the start address of DMA area */
1496 start_table_ptr = (unsigned long *) flow_dma_area_start_addr;
1497
1498 /* find the space for the next table */
1499 while (((*start_table_ptr & 0x7FFFFFFF) != 0) && ((unsigned long) start_table_ptr < flow_dma_area_end_addr))
1500 start_table_ptr += table_size_in_words;
1501
1502 /* check if we reached the end of floa tables area */
1503 if ((unsigned long) start_table_ptr >= flow_dma_area_end_addr)
1504 error = -1;
1505 else
1506 *table_address_ptr = start_table_ptr;
1507
1508 return error;
1509 }
1510
1511
1512
1513 /*
1514 This function creates one DMA table for flow and returns its data,
1515 and pointer to its info entry
1516 */
1517 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)
1518 {
1519 int error;
1520 /* the range in pages */
1521 unsigned long lli_array_size;
1522 struct sep_lli_entry_t *lli_array;
1523 struct sep_lli_entry_t *flow_dma_table_entry_ptr;
1524 unsigned long *start_dma_table_ptr;
1525 /* total table data counter */
1526 unsigned long dma_table_data_count;
1527 /* pointer that will keep the pointer to the pages of the virtual buffer */
1528 struct page **page_array_ptr;
1529 unsigned long entry_count;
1530
1531 /* find the space for the new table */
1532 error = sep_find_free_flow_dma_table_space(&start_dma_table_ptr);
1533 if (error)
1534 goto end_function;
1535
1536 /* check if the pages are in Kernel Virtual Address layout */
1537 if (isKernelVirtualAddress == true)
1538 /* lock kernel buffer in the memory */
1539 error = sep_lock_kernel_pages(virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr);
1540 else
1541 /* lock user buffer in the memory */
1542 error = sep_lock_user_pages(virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr);
1543
1544 if (error)
1545 goto end_function;
1546
1547 /* set the pointer to page array at the beginning of table - this table is
1548 now considered taken */
1549 *start_dma_table_ptr = lli_array_size;
1550
1551 /* point to the place of the pages pointers of the table */
1552 start_dma_table_ptr++;
1553
1554 /* set the pages pointer */
1555 *start_dma_table_ptr = (unsigned long) page_array_ptr;
1556
1557 /* set the pointer to the first entry */
1558 flow_dma_table_entry_ptr = (struct sep_lli_entry_t *) (++start_dma_table_ptr);
1559
1560 /* now create the entries for table */
1561 for (dma_table_data_count = entry_count = 0; entry_count < lli_array_size; entry_count++) {
1562 flow_dma_table_entry_ptr->physical_address = lli_array[entry_count].physical_address;
1563
1564 flow_dma_table_entry_ptr->block_size = lli_array[entry_count].block_size;
1565
1566 /* set the total data of a table */
1567 dma_table_data_count += lli_array[entry_count].block_size;
1568
1569 flow_dma_table_entry_ptr++;
1570 }
1571
1572 /* set the physical address */
1573 table_data->physical_address = virt_to_phys(start_dma_table_ptr);
1574
1575 /* set the num_entries and total data size */
1576 table_data->block_size = ((lli_array_size + 1) << SEP_NUM_ENTRIES_OFFSET_IN_BITS) | (dma_table_data_count);
1577
1578 /* set the info entry */
1579 flow_dma_table_entry_ptr->physical_address = 0xffffffff;
1580 flow_dma_table_entry_ptr->block_size = 0;
1581
1582 /* set the pointer to info entry */
1583 *info_entry_ptr = flow_dma_table_entry_ptr;
1584
1585 /* the array of the lli entries */
1586 kfree(lli_array);
1587 end_function:
1588 return error;
1589 }
1590
1591
1592
1593 /*
1594 This function creates a list of tables for flow and returns the data for
1595 the first and last tables of the list
1596 */
1597 static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers,
1598 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)
1599 {
1600 int error;
1601 unsigned long virt_buff_addr;
1602 unsigned long virt_buff_size;
1603 struct sep_lli_entry_t table_data;
1604 struct sep_lli_entry_t *info_entry_ptr;
1605 struct sep_lli_entry_t *prev_info_entry_ptr;
1606 unsigned long i;
1607
1608 /* init vars */
1609 error = 0;
1610 prev_info_entry_ptr = 0;
1611
1612 /* init the first table to default */
1613 table_data.physical_address = 0xffffffff;
1614 first_table_data_ptr->physical_address = 0xffffffff;
1615 table_data.block_size = 0;
1616
1617 for (i = 0; i < num_virtual_buffers; i++) {
1618 /* get the virtual buffer address */
1619 error = get_user(virt_buff_addr, &first_buff_addr);
1620 if (error)
1621 goto end_function;
1622
1623 /* get the virtual buffer size */
1624 first_buff_addr++;
1625 error = get_user(virt_buff_size, &first_buff_addr);
1626 if (error)
1627 goto end_function;
1628
1629 /* advance the address to point to the next pair of address|size */
1630 first_buff_addr++;
1631
1632 /* now prepare the one flow LLI table from the data */
1633 error = sep_prepare_one_flow_dma_table(virt_buff_addr, virt_buff_size, &table_data, &info_entry_ptr, flow_data_ptr, isKernelVirtualAddress);
1634 if (error)
1635 goto end_function;
1636
1637 if (i == 0) {
1638 /* if this is the first table - save it to return to the user
1639 application */
1640 *first_table_data_ptr = table_data;
1641
1642 /* set the pointer to info entry */
1643 prev_info_entry_ptr = info_entry_ptr;
1644 } else {
1645 /* not first table - the previous table info entry should
1646 be updated */
1647 prev_info_entry_ptr->block_size = (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS) | (table_data.block_size);
1648
1649 /* set the pointer to info entry */
1650 prev_info_entry_ptr = info_entry_ptr;
1651 }
1652 }
1653
1654 /* set the last table data */
1655 *last_table_data_ptr = table_data;
1656 end_function:
1657 return error;
1658 }
1659
1660 /*
1661 this function goes over all the flow tables connected to the given
1662 table and deallocate them
1663 */
1664 static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr)
1665 {
1666 /* id pointer */
1667 unsigned long *table_ptr;
1668 /* end address of the flow dma area */
1669 unsigned long num_entries;
1670 unsigned long num_pages;
1671 struct page **pages_ptr;
1672 /* maximum table size in words */
1673 struct sep_lli_entry_t *info_entry_ptr;
1674
1675 /* set the pointer to the first table */
1676 table_ptr = (unsigned long *) first_table_ptr->physical_address;
1677
1678 /* set the num of entries */
1679 num_entries = (first_table_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS)
1680 & SEP_NUM_ENTRIES_MASK;
1681
1682 /* go over all the connected tables */
1683 while (*table_ptr != 0xffffffff) {
1684 /* get number of pages */
1685 num_pages = *(table_ptr - 2);
1686
1687 /* get the pointer to the pages */
1688 pages_ptr = (struct page **) (*(table_ptr - 1));
1689
1690 /* free the pages */
1691 sep_free_dma_pages(pages_ptr, num_pages, 1);
1692
1693 /* goto to the info entry */
1694 info_entry_ptr = ((struct sep_lli_entry_t *) table_ptr) + (num_entries - 1);
1695
1696 table_ptr = (unsigned long *) info_entry_ptr->physical_address;
1697 num_entries = (info_entry_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1698 }
1699
1700 return;
1701 }
1702
1703 /*
1704 This function returns pointer to the flow data structure
1705 that contains the given id
1706 */
1707 static int sep_find_flow_context(unsigned long flow_id, struct sep_flow_context_t **flow_data_ptr)
1708 {
1709 unsigned long count;
1710 int error = 0;
1711
1712 /*
1713 always search for flow with id default first - in case we
1714 already started working on the flow there can be no situation
1715 when 2 flows are with default flag
1716 */
1717 for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) {
1718 if (sep_dev->flows[count].flow_id == flow_id) {
1719 *flow_data_ptr = &sep_dev->flows[count];
1720 break;
1721 }
1722 }
1723
1724 if (count == SEP_DRIVER_NUM_FLOWS)
1725 /* no flow found */
1726 error = -ENOMEM;
1727
1728 return error;
1729 }
1730
1731
1732 /*
1733 this function handles the request to create the DMA tables for flow
1734 */
1735 static int sep_create_flow_dma_tables_handler(unsigned long arg)
1736 {
1737 int error;
1738 struct sep_driver_build_flow_table_t command_args;
1739 /* first table - output */
1740 struct sep_lli_entry_t first_table_data;
1741 /* dma table data */
1742 struct sep_lli_entry_t last_table_data;
1743 /* pointer to the info entry of the previuos DMA table */
1744 struct sep_lli_entry_t *prev_info_entry_ptr;
1745 /* pointer to the flow data strucutre */
1746 struct sep_flow_context_t *flow_context_ptr;
1747
1748 dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n");
1749
1750 /* init variables */
1751 prev_info_entry_ptr = 0;
1752 first_table_data.physical_address = 0xffffffff;
1753
1754 /* find the free structure for flow data */
1755 error = sep_find_flow_context(SEP_FREE_FLOW_ID, &flow_context_ptr);
1756 if (error)
1757 goto end_function;
1758
1759 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_flow_table_t));
1760 if (error)
1761 goto end_function;
1762
1763 /* create flow tables */
1764 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);
1765 if (error)
1766 goto end_function_with_error;
1767
1768 /* check if flow is static */
1769 if (!command_args.flow_type)
1770 /* point the info entry of the last to the info entry of the first */
1771 last_table_data = first_table_data;
1772
1773 /* set output params */
1774 command_args.first_table_addr = first_table_data.physical_address;
1775 command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK);
1776 command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK);
1777
1778 /* send the parameters to user application */
1779 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_build_flow_table_t));
1780 if (error)
1781 goto end_function_with_error;
1782
1783 /* all the flow created - update the flow entry with temp id */
1784 flow_context_ptr->flow_id = SEP_TEMP_FLOW_ID;
1785
1786 /* set the processing tables data in the context */
1787 if (command_args.input_output_flag == SEP_DRIVER_IN_FLAG)
1788 flow_context_ptr->input_tables_in_process = first_table_data;
1789 else
1790 flow_context_ptr->output_tables_in_process = first_table_data;
1791
1792 goto end_function;
1793
1794 end_function_with_error:
1795 /* free the allocated tables */
1796 sep_deallocated_flow_tables(&first_table_data);
1797 end_function:
1798 dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n");
1799 return error;
1800 }
1801
1802 /*
1803 this functio nhandles add tables to flow
1804 */
1805 static int sep_add_flow_tables_handler(unsigned long arg)
1806 {
1807 int error;
1808 unsigned long num_entries;
1809 struct sep_driver_add_flow_table_t command_args;
1810 struct sep_flow_context_t *flow_context_ptr;
1811 /* first dma table data */
1812 struct sep_lli_entry_t first_table_data;
1813 /* last dma table data */
1814 struct sep_lli_entry_t last_table_data;
1815 /* pointer to the info entry of the current DMA table */
1816 struct sep_lli_entry_t *info_entry_ptr;
1817
1818 dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n");
1819
1820 /* get input parameters */
1821 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_flow_table_t));
1822 if (error)
1823 goto end_function;
1824
1825 /* find the flow structure for the flow id */
1826 error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr);
1827 if (error)
1828 goto end_function;
1829
1830 /* prepare the flow dma tables */
1831 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);
1832 if (error)
1833 goto end_function_with_error;
1834
1835 /* now check if there is already an existing add table for this flow */
1836 if (command_args.inputOutputFlag == SEP_DRIVER_IN_FLAG) {
1837 /* this buffer was for input buffers */
1838 if (flow_context_ptr->input_tables_flag) {
1839 /* add table already exists - add the new tables to the end
1840 of the previous */
1841 num_entries = (flow_context_ptr->last_input_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1842
1843 info_entry_ptr = (struct sep_lli_entry_t *)
1844 (flow_context_ptr->last_input_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1)));
1845
1846 /* connect to list of tables */
1847 *info_entry_ptr = first_table_data;
1848
1849 /* set the first table data */
1850 first_table_data = flow_context_ptr->first_input_table;
1851 } else {
1852 /* set the input flag */
1853 flow_context_ptr->input_tables_flag = 1;
1854
1855 /* set the first table data */
1856 flow_context_ptr->first_input_table = first_table_data;
1857 }
1858 /* set the last table data */
1859 flow_context_ptr->last_input_table = last_table_data;
1860 } else { /* this is output tables */
1861
1862 /* this buffer was for input buffers */
1863 if (flow_context_ptr->output_tables_flag) {
1864 /* add table already exists - add the new tables to
1865 the end of the previous */
1866 num_entries = (flow_context_ptr->last_output_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK;
1867
1868 info_entry_ptr = (struct sep_lli_entry_t *)
1869 (flow_context_ptr->last_output_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1)));
1870
1871 /* connect to list of tables */
1872 *info_entry_ptr = first_table_data;
1873
1874 /* set the first table data */
1875 first_table_data = flow_context_ptr->first_output_table;
1876 } else {
1877 /* set the input flag */
1878 flow_context_ptr->output_tables_flag = 1;
1879
1880 /* set the first table data */
1881 flow_context_ptr->first_output_table = first_table_data;
1882 }
1883 /* set the last table data */
1884 flow_context_ptr->last_output_table = last_table_data;
1885 }
1886
1887 /* set output params */
1888 command_args.first_table_addr = first_table_data.physical_address;
1889 command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK);
1890 command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK);
1891
1892 /* send the parameters to user application */
1893 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_add_flow_table_t));
1894 end_function_with_error:
1895 /* free the allocated tables */
1896 sep_deallocated_flow_tables(&first_table_data);
1897 end_function:
1898 dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n");
1899 return error;
1900 }
1901
1902 /*
1903 this function add the flow add message to the specific flow
1904 */
1905 static int sep_add_flow_tables_message_handler(unsigned long arg)
1906 {
1907 int error;
1908 struct sep_driver_add_message_t command_args;
1909 struct sep_flow_context_t *flow_context_ptr;
1910
1911 dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n");
1912
1913 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_message_t));
1914 if (error)
1915 goto end_function;
1916
1917 /* check input */
1918 if (command_args.message_size_in_bytes > SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES) {
1919 error = -ENOMEM;
1920 goto end_function;
1921 }
1922
1923 /* find the flow context */
1924 error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr);
1925 if (error)
1926 goto end_function;
1927
1928 /* copy the message into context */
1929 flow_context_ptr->message_size_in_bytes = command_args.message_size_in_bytes;
1930 error = copy_from_user(flow_context_ptr->message, (void *) command_args.message_address, command_args.message_size_in_bytes);
1931 end_function:
1932 dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n");
1933 return error;
1934 }
1935
1936
1937 /*
1938 this function returns the physical and virtual addresses of the static pool
1939 */
1940 static int sep_get_static_pool_addr_handler(unsigned long arg)
1941 {
1942 int error;
1943 struct sep_driver_static_pool_addr_t command_args;
1944
1945 dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n");
1946
1947 /*prepare the output parameters in the struct */
1948 command_args.physical_static_address = sep_dev->shared_area_bus + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
1949 command_args.virtual_static_address = sep_dev->shared_area + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
1950
1951 edbg("SEP Driver:physical_static_address is %08lx, virtual_static_address %08lx\n", command_args.physical_static_address, command_args.virtual_static_address);
1952
1953 /* send the parameters to user application */
1954 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_static_pool_addr_t));
1955 dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n");
1956 return error;
1957 }
1958
1959 /*
1960 this address gets the offset of the physical address from the start
1961 of the mapped area
1962 */
1963 static int sep_get_physical_mapped_offset_handler(unsigned long arg)
1964 {
1965 int error;
1966 struct sep_driver_get_mapped_offset_t command_args;
1967
1968 dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n");
1969
1970 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_get_mapped_offset_t));
1971 if (error)
1972 goto end_function;
1973
1974 if (command_args.physical_address < sep_dev->shared_area_bus) {
1975 error = -ENOTTY;
1976 goto end_function;
1977 }
1978
1979 /*prepare the output parameters in the struct */
1980 command_args.offset = command_args.physical_address - sep_dev->shared_area_bus;
1981
1982 edbg("SEP Driver:physical_address is %08lx, offset is %lu\n", command_args.physical_address, command_args.offset);
1983
1984 /* send the parameters to user application */
1985 error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_get_mapped_offset_t));
1986 end_function:
1987 dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n");
1988 return error;
1989 }
1990
1991
1992 /*
1993 ?
1994 */
1995 static int sep_start_handler(void)
1996 {
1997 unsigned long reg_val;
1998 unsigned long error = 0;
1999
2000 dbg("SEP Driver:--------> sep_start_handler start\n");
2001
2002 /* wait in polling for message from SEP */
2003 do
2004 reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
2005 while (!reg_val);
2006
2007 /* check the value */
2008 if (reg_val == 0x1)
2009 /* fatal error - read erro status from GPRO */
2010 error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
2011 dbg("SEP Driver:<-------- sep_start_handler end\n");
2012 return error;
2013 }
2014
2015 /*
2016 this function handles the request for SEP initialization
2017 */
2018 static int sep_init_handler(unsigned long arg)
2019 {
2020 unsigned long message_word;
2021 unsigned long *message_ptr;
2022 struct sep_driver_init_t command_args;
2023 unsigned long counter;
2024 unsigned long error;
2025 unsigned long reg_val;
2026
2027 dbg("SEP Driver:--------> sep_init_handler start\n");
2028 error = 0;
2029
2030 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_init_t));
2031
2032 dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user \n");
2033
2034 if (error)
2035 goto end_function;
2036
2037 /* PATCH - configure the DMA to single -burst instead of multi-burst */
2038 /*sep_configure_dma_burst(); */
2039
2040 dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n");
2041
2042 message_ptr = (unsigned long *) command_args.message_addr;
2043
2044 /* set the base address of the SRAM */
2045 sep_write_reg(sep_dev, HW_SRAM_ADDR_REG_ADDR, HW_CC_SRAM_BASE_ADDRESS);
2046
2047 for (counter = 0; counter < command_args.message_size_in_words; counter++, message_ptr++) {
2048 get_user(message_word, message_ptr);
2049 /* write data to SRAM */
2050 sep_write_reg(sep_dev, HW_SRAM_DATA_REG_ADDR, message_word);
2051 edbg("SEP Driver:message_word is %lu\n", message_word);
2052 /* wait for write complete */
2053 sep_wait_sram_write(sep_dev);
2054 }
2055 dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n");
2056 /* signal SEP */
2057 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1);
2058
2059 do
2060 reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
2061 while (!(reg_val & 0xFFFFFFFD));
2062
2063 dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n");
2064
2065 /* check the value */
2066 if (reg_val == 0x1) {
2067 edbg("SEP Driver:init failed\n");
2068
2069 error = sep_read_reg(sep_dev, 0x8060);
2070 edbg("SEP Driver:sw monitor is %lu\n", error);
2071
2072 /* fatal error - read erro status from GPRO */
2073 error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
2074 edbg("SEP Driver:error is %lu\n", error);
2075 }
2076 end_function:
2077 dbg("SEP Driver:<-------- sep_init_handler end\n");
2078 return error;
2079
2080 }
2081
2082 /*
2083 this function handles the request cache and resident reallocation
2084 */
2085 static int sep_realloc_cache_resident_handler(unsigned long arg)
2086 {
2087 int error;
2088 unsigned long phys_cache_address;
2089 unsigned long phys_resident_address;
2090 struct sep_driver_realloc_cache_resident_t command_args;
2091
2092 /* copy the data */
2093 error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_realloc_cache_resident_t));
2094 if (error)
2095 goto end_function;
2096
2097 /* copy cache and resident to the their intended locations */
2098 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);
2099 if (error)
2100 goto end_function;
2101
2102 command_args.new_base_addr = sep_dev->shared_area_bus;
2103
2104 /* find the new base address according to the lowest address between
2105 cache, resident and shared area */
2106 if (phys_resident_address < command_args.new_base_addr)
2107 command_args.new_base_addr = phys_resident_address;
2108 if (phys_cache_address < command_args.new_base_addr)
2109 command_args.new_base_addr = phys_cache_address;
2110
2111 /* set the return parameters */
2112 command_args.new_cache_addr = phys_cache_address;
2113 command_args.new_resident_addr = phys_resident_address;
2114
2115 /* set the new shared area */
2116 command_args.new_shared_area_addr = sep_dev->shared_area_bus;
2117
2118 edbg("SEP Driver:command_args.new_shared_area is %08lx\n", command_args.new_shared_area_addr);
2119 edbg("SEP Driver:command_args.new_base_addr is %08lx\n", command_args.new_base_addr);
2120 edbg("SEP Driver:command_args.new_resident_addr is %08lx\n", command_args.new_resident_addr);
2121 edbg("SEP Driver:command_args.new_cache_addr is %08lx\n", command_args.new_cache_addr);
2122
2123 /* return to user */
2124 error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_realloc_cache_resident_t));
2125 end_function:
2126 return error;
2127 }
2128
2129 /*
2130 this function handles the request for get time
2131 */
2132 static int sep_get_time_handler(unsigned long arg)
2133 {
2134 int error;
2135 struct sep_driver_get_time_t command_args;
2136
2137 error = sep_set_time(&command_args.time_physical_address, &command_args.time_value);
2138 if (error == 0)
2139 error = copy_to_user((void __user *)arg,
2140 &command_args, sizeof(struct sep_driver_get_time_t));
2141 return error;
2142
2143 }
2144
2145 /*
2146 This API handles the end transaction request
2147 */
2148 static int sep_end_transaction_handler(unsigned long arg)
2149 {
2150 dbg("SEP Driver:--------> sep_end_transaction_handler start\n");
2151
2152 #if 0 /*!SEP_DRIVER_POLLING_MODE */
2153 /* close IMR */
2154 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF);
2155
2156 /* release IRQ line */
2157 free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_addr);
2158
2159 /* lock the sep mutex */
2160 mutex_unlock(&sep_mutex);
2161 #endif
2162
2163 dbg("SEP Driver:<-------- sep_end_transaction_handler end\n");
2164
2165 return 0;
2166 }
2167
2168
2169 /*
2170 This function handler the set flow id command
2171 */
2172 static int sep_set_flow_id_handler(unsigned long arg)
2173 {
2174 int error;
2175 unsigned long flow_id;
2176 struct sep_flow_context_t *flow_data_ptr;
2177
2178 dbg("------------>SEP Driver: sep_set_flow_id_handler start\n");
2179
2180 error = get_user(flow_id, &(((struct sep_driver_set_flow_id_t *) arg)->flow_id));
2181 if (error)
2182 goto end_function;
2183
2184 /* find the flow data structure that was just used for creating new flow
2185 - its id should be default */
2186 error = sep_find_flow_context(SEP_TEMP_FLOW_ID, &flow_data_ptr);
2187 if (error)
2188 goto end_function;
2189
2190 /* set flow id */
2191 flow_data_ptr->flow_id = flow_id;
2192
2193 end_function:
2194 dbg("SEP Driver:<-------- sep_set_flow_id_handler end\n");
2195 return error;
2196 }
2197
2198
2199
2200
2201
2202 static int sep_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
2203 {
2204 int error = 0;
2205
2206 dbg("------------>SEP Driver: ioctl start\n");
2207
2208 edbg("SEP Driver: cmd is %x\n", cmd);
2209
2210 /* check that the command is for sep device */
2211 if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER)
2212 error = -ENOTTY;
2213
2214 switch (cmd) {
2215 case SEP_IOCSENDSEPCOMMAND:
2216 /* send command to SEP */
2217 sep_send_command_handler();
2218 edbg("SEP Driver: after sep_send_command_handler\n");
2219 break;
2220 case SEP_IOCSENDSEPRPLYCOMMAND:
2221 /* send reply command to SEP */
2222 sep_send_reply_command_handler();
2223 break;
2224 case SEP_IOCALLOCDATAPOLL:
2225 /* allocate data pool */
2226 error = sep_allocate_data_pool_memory_handler(arg);
2227 break;
2228 case SEP_IOCWRITEDATAPOLL:
2229 /* write data into memory pool */
2230 error = sep_write_into_data_pool_handler(arg);
2231 break;
2232 case SEP_IOCREADDATAPOLL:
2233 /* read data from data pool into application memory */
2234 error = sep_read_from_data_pool_handler(arg);
2235 break;
2236 case SEP_IOCCREATESYMDMATABLE:
2237 /* create dma table for synhronic operation */
2238 error = sep_create_sync_dma_tables_handler(arg);
2239 break;
2240 case SEP_IOCCREATEFLOWDMATABLE:
2241 /* create flow dma tables */
2242 error = sep_create_flow_dma_tables_handler(arg);
2243 break;
2244 case SEP_IOCFREEDMATABLEDATA:
2245 /* free the pages */
2246 error = sep_free_dma_table_data_handler();
2247 break;
2248 case SEP_IOCSETFLOWID:
2249 /* set flow id */
2250 error = sep_set_flow_id_handler(arg);
2251 break;
2252 case SEP_IOCADDFLOWTABLE:
2253 /* add tables to the dynamic flow */
2254 error = sep_add_flow_tables_handler(arg);
2255 break;
2256 case SEP_IOCADDFLOWMESSAGE:
2257 /* add message of add tables to flow */
2258 error = sep_add_flow_tables_message_handler(arg);
2259 break;
2260 case SEP_IOCSEPSTART:
2261 /* start command to sep */
2262 error = sep_start_handler();
2263 break;
2264 case SEP_IOCSEPINIT:
2265 /* init command to sep */
2266 error = sep_init_handler(arg);
2267 break;
2268 case SEP_IOCGETSTATICPOOLADDR:
2269 /* get the physical and virtual addresses of the static pool */
2270 error = sep_get_static_pool_addr_handler(arg);
2271 break;
2272 case SEP_IOCENDTRANSACTION:
2273 error = sep_end_transaction_handler(arg);
2274 break;
2275 case SEP_IOCREALLOCCACHERES:
2276 error = sep_realloc_cache_resident_handler(arg);
2277 break;
2278 case SEP_IOCGETMAPPEDADDROFFSET:
2279 error = sep_get_physical_mapped_offset_handler(arg);
2280 break;
2281 case SEP_IOCGETIME:
2282 error = sep_get_time_handler(arg);
2283 break;
2284 default:
2285 error = -ENOTTY;
2286 break;
2287 }
2288 dbg("SEP Driver:<-------- ioctl end\n");
2289 return error;
2290 }
2291
2292
2293
2294 #if !SEP_DRIVER_POLLING_MODE
2295
2296 /* handler for flow done interrupt */
2297
2298 static void sep_flow_done_handler(struct work_struct *work)
2299 {
2300 struct sep_flow_context_t *flow_data_ptr;
2301
2302 /* obtain the mutex */
2303 mutex_lock(&sep_mutex);
2304
2305 /* get the pointer to context */
2306 flow_data_ptr = (struct sep_flow_context_t *) work;
2307
2308 /* free all the current input tables in sep */
2309 sep_deallocated_flow_tables(&flow_data_ptr->input_tables_in_process);
2310
2311 /* free all the current tables output tables in SEP (if needed) */
2312 if (flow_data_ptr->output_tables_in_process.physical_address != 0xffffffff)
2313 sep_deallocated_flow_tables(&flow_data_ptr->output_tables_in_process);
2314
2315 /* check if we have additional tables to be sent to SEP only input
2316 flag may be checked */
2317 if (flow_data_ptr->input_tables_flag) {
2318 /* copy the message to the shared RAM and signal SEP */
2319 memcpy((void *) flow_data_ptr->message, (void *) sep_dev->shared_area, flow_data_ptr->message_size_in_bytes);
2320
2321 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, 0x2);
2322 }
2323 mutex_unlock(&sep_mutex);
2324 }
2325 /*
2326 interrupt handler function
2327 */
2328 static irqreturn_t sep_inthandler(int irq, void *dev_id)
2329 {
2330 irqreturn_t int_error;
2331 unsigned long error;
2332 unsigned long reg_val;
2333 unsigned long flow_id;
2334 struct sep_flow_context_t *flow_context_ptr;
2335
2336 int_error = IRQ_HANDLED;
2337
2338 /* read the IRR register to check if this is SEP interrupt */
2339 reg_val = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR);
2340 edbg("SEP Interrupt - reg is %08lx\n", reg_val);
2341
2342 /* check if this is the flow interrupt */
2343 if (0 /*reg_val & (0x1 << 11) */ ) {
2344 /* read GPRO to find out the which flow is done */
2345 flow_id = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR);
2346
2347 /* find the contex of the flow */
2348 error = sep_find_flow_context(flow_id >> 28, &flow_context_ptr);
2349 if (error)
2350 goto end_function_with_error;
2351
2352 INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler);
2353
2354 /* queue the work */
2355 queue_work(sep_dev->flow_wq, &flow_context_ptr->flow_wq);
2356
2357 } else {
2358 /* check if this is reply interrupt from SEP */
2359 if (reg_val & (0x1 << 13)) {
2360 /* update the counter of reply messages */
2361 sep_dev->reply_ct++;
2362
2363 /* wake up the waiting process */
2364 wake_up(&sep_event);
2365 } else {
2366 int_error = IRQ_NONE;
2367 goto end_function;
2368 }
2369 }
2370 end_function_with_error:
2371 /* clear the interrupt */
2372 sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, reg_val);
2373 end_function:
2374 return int_error;
2375 }
2376
2377 #endif
2378
2379
2380
2381
2382
2383 static void sep_wait_busy(struct sep_device *dev)
2384 {
2385 u32 reg;
2386
2387 do {
2388 reg = sep_read_reg(sep_dev, HW_HOST_SEP_BUSY_REG_ADDR);
2389 } while (reg);
2390 }
2391
2392 /*
2393 PATCH for configuring the DMA to single burst instead of multi-burst
2394 */
2395 static void sep_configure_dma_burst(void)
2396 {
2397 #define HW_AHB_RD_WR_BURSTS_REG_ADDR 0x0E10UL
2398
2399 dbg("SEP Driver:<-------- sep_configure_dma_burst start \n");
2400
2401 /* request access to registers from SEP */
2402 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
2403
2404 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n");
2405
2406 sep_wait_busy(sep_dev);
2407
2408 dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n");
2409
2410 /* set the DMA burst register to single burst */
2411 sep_write_reg(sep_dev, HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL);
2412
2413 /* release the sep busy */
2414 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL);
2415 sep_wait_busy(sep_dev);
2416
2417 dbg("SEP Driver:<-------- sep_configure_dma_burst done \n");
2418
2419 }
2420
2421 /*
2422 function that is activaed on the succesfull probe of the SEP device
2423 */
2424 static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
2425 {
2426 int error = 0;
2427
2428 edbg("Sep pci probe starting\n");
2429
2430 /* enable the device */
2431 error = pci_enable_device(pdev);
2432 if (error) {
2433 edbg("error enabling pci device\n");
2434 goto end_function;
2435 }
2436
2437 /* set the pci dev pointer */
2438 sep_dev->pdev = pdev;
2439
2440 /* get the io memory start address */
2441 sep_dev->io_bus = pci_resource_start(pdev, 0);
2442 if (!sep_dev->io_bus) {
2443 edbg("SEP Driver error pci resource start\n");
2444 goto end_function;
2445 }
2446
2447 /* get the io memory end address */
2448 sep_dev->io_end_bus = pci_resource_end(pdev, 0);
2449 if (!sep_dev->io_end_bus) {
2450 edbg("SEP Driver error pci resource end\n");
2451 goto end_function;
2452 }
2453
2454 sep_dev->io_memory_size = sep_dev->io_end_bus - sep_dev->io_bus + 1;
2455
2456 edbg("SEP Driver:io_bus is %08lx\n", sep_dev->io_bus);
2457
2458 edbg("SEP Driver:io_memory_end_phyaical_address is %08lx\n", sep_dev->io_end_bus);
2459
2460 edbg("SEP Driver:io_memory_size is %08lx\n", sep_dev->io_memory_size);
2461
2462 sep_dev->io_addr = ioremap_nocache(sep_dev->io_bus, sep_dev->io_memory_size);
2463 if (!sep_dev->io_addr) {
2464 edbg("SEP Driver error ioremap of io memory\n");
2465 goto end_function;
2466 }
2467
2468 edbg("SEP Driver:io_addr is %p\n", sep_dev->io_addr);
2469
2470 sep_dev->reg_addr = (void __iomem *) sep_dev->io_addr;
2471
2472
2473 /* set up system base address and shared memory location */
2474
2475 sep_dev->rar_addr = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE, GFP_KERNEL);
2476
2477 if (!sep_dev->rar_addr) {
2478 edbg("SEP Driver:cant kmalloc rar\n");
2479 goto end_function;
2480 }
2481 /* FIXME */
2482 sep_dev->rar_bus = __pa(sep_dev->rar_addr);
2483
2484 edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_bus);
2485 edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_addr);
2486
2487 #if !SEP_DRIVER_POLLING_MODE
2488
2489 edbg("SEP Driver: about to write IMR and ICR REG_ADDR\n");
2490
2491 /* clear ICR register */
2492 sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
2493
2494 /* set the IMR register - open only GPR 2 */
2495 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
2496
2497 edbg("SEP Driver: about to call request_irq\n");
2498 /* get the interrupt line */
2499 error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED, "sep_driver", &sep_dev->reg_addr);
2500 if (error)
2501 goto end_function;
2502
2503 goto end_function;
2504 edbg("SEP Driver: about to write IMR REG_ADDR");
2505
2506 /* set the IMR register - open only GPR 2 */
2507 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
2508
2509 #endif /* SEP_DRIVER_POLLING_MODE */
2510 end_function:
2511 return error;
2512 }
2513
2514 static struct pci_device_id sep_pci_id_tbl[] = {
2515 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c)},
2516 {0}
2517 };
2518
2519 MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
2520
2521 /* field for registering driver to PCI device */
2522 static struct pci_driver sep_pci_driver = {
2523 .name = "sep_sec_driver",
2524 .id_table = sep_pci_id_tbl,
2525 .probe = sep_probe
2526 };
2527
2528 /* major and minor device numbers */
2529 static dev_t sep_devno;
2530
2531 /* the files operations structure of the driver */
2532 static struct file_operations sep_file_operations = {
2533 .owner = THIS_MODULE,
2534 .ioctl = sep_ioctl,
2535 .poll = sep_poll,
2536 .open = sep_open,
2537 .release = sep_release,
2538 .mmap = sep_mmap,
2539 };
2540
2541
2542 /* cdev struct of the driver */
2543 static struct cdev sep_cdev;
2544
2545 /*
2546 this function registers the driver to the file system
2547 */
2548 static int sep_register_driver_to_fs(void)
2549 {
2550 int ret_val = alloc_chrdev_region(&sep_devno, 0, 1, "sep_sec_driver");
2551 if (ret_val) {
2552 edbg("sep_driver:major number allocation failed, retval is %d\n", ret_val);
2553 goto end_function;
2554 }
2555
2556 /* init cdev */
2557 cdev_init(&sep_cdev, &sep_file_operations);
2558 sep_cdev.owner = THIS_MODULE;
2559
2560 /* register the driver with the kernel */
2561 ret_val = cdev_add(&sep_cdev, sep_devno, 1);
2562
2563 if (ret_val) {
2564 edbg("sep_driver:cdev_add failed, retval is %d\n", ret_val);
2565 goto end_function_unregister_devnum;
2566 }
2567
2568 goto end_function;
2569
2570 end_function_unregister_devnum:
2571
2572 /* unregister dev numbers */
2573 unregister_chrdev_region(sep_devno, 1);
2574
2575 end_function:
2576 return ret_val;
2577 }
2578
2579
2580 /*--------------------------------------------------------------
2581 init function
2582 ----------------------------------------------------------------*/
2583 static int __init sep_init(void)
2584 {
2585 int ret_val = 0;
2586 int counter;
2587 int size; /* size of memory for allocation */
2588
2589 dbg("SEP Driver:-------->Init start\n");
2590 edbg("sep->shared_area = %lx\n", (unsigned long) &sep_dev->shared_area);
2591
2592 /* transaction counter that coordinates the transactions between SEP
2593 and HOST */
2594 sep_dev->send_ct = 0;
2595
2596 /* counter for the messages from sep */
2597 sep_dev->reply_ct = 0;
2598
2599 /* counter for the number of bytes allocated in the pool
2600 for the current transaction */
2601 sep_dev->data_pool_bytes_allocated = 0;
2602
2603 /* FIXME: Probe can occur before we are ready to survive a probe */
2604 ret_val = pci_register_driver(&sep_pci_driver);
2605 if (ret_val) {
2606 edbg("sep_driver:sep_driver_to_device failed, ret_val is %d\n", ret_val);
2607 goto end_function_unregister_from_fs;
2608 }
2609 /* calculate the total size for allocation */
2610 size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES +
2611 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;
2612
2613 /* allocate the shared area */
2614 if (sep_map_and_alloc_shared_area(size, &sep_dev->shared_area, &sep_dev->shared_area_bus)) {
2615 ret_val = -ENOMEM;
2616 /* allocation failed */
2617 goto end_function_unmap_io_memory;
2618 }
2619 /* now set the memory regions */
2620 sep_dev->message_shared_area_addr = sep_dev->shared_area;
2621
2622 edbg("SEP Driver: sep_dev->message_shared_area_addr is %08lx\n", sep_dev->message_shared_area_addr);
2623
2624 #if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1)
2625 /* send the new SHARED MESSAGE AREA to the SEP */
2626 sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep_dev->shared_area_bus);
2627
2628 /* poll for SEP response */
2629 retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
2630 while (retVal != 0xffffffff && retVal != sep_dev->shared_area_bus)
2631 retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
2632
2633 /* check the return value (register) */
2634 if (retVal != sep_dev->shared_area_bus) {
2635 ret_val = -ENOMEM;
2636 goto end_function_deallocate_message_area;
2637 }
2638 #endif
2639 /* init the flow contextes */
2640 for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++)
2641 sep_dev->flows[counter].flow_id = SEP_FREE_FLOW_ID;
2642
2643 sep_dev->flow_wq = create_singlethread_workqueue("sepflowwq");
2644 if (sep_dev->flow_wq == NULL) {
2645 ret_val = -ENOMEM;
2646 edbg("sep_driver:flow queue creation failed\n");
2647 goto end_function_deallocate_sep_shared_area;
2648 }
2649 edbg("SEP Driver: create flow workqueue \n");
2650
2651 /* register driver to fs */
2652 ret_val = sep_register_driver_to_fs();
2653 if (ret_val)
2654 goto end_function_deallocate_sep_shared_area;
2655 /* load the rom code */
2656 sep_load_rom_code();
2657 goto end_function;
2658 end_function_unregister_from_fs:
2659 /* unregister from fs */
2660 cdev_del(&sep_cdev);
2661 /* unregister dev numbers */
2662 unregister_chrdev_region(sep_devno, 1);
2663 end_function_deallocate_sep_shared_area:
2664 /* de-allocate shared area */
2665 sep_unmap_and_free_shared_area(size, sep_dev->shared_area, sep_dev->shared_area_bus);
2666 end_function_unmap_io_memory:
2667 iounmap((void *) sep_dev->reg_addr);
2668 /* release io memory region */
2669 release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE);
2670 end_function:
2671 dbg("SEP Driver:<-------- Init end\n");
2672 return ret_val;
2673 }
2674
2675
2676 /*-------------------------------------------------------------
2677 exit function
2678 --------------------------------------------------------------*/
2679 static void __exit sep_exit(void)
2680 {
2681 int size;
2682
2683 dbg("SEP Driver:--------> Exit start\n");
2684
2685 /* unregister from fs */
2686 cdev_del(&sep_cdev);
2687 /* unregister dev numbers */
2688 unregister_chrdev_region(sep_devno, 1);
2689 /* calculate the total size for de-allocation */
2690 size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES +
2691 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;
2692 /* free shared area */
2693 sep_unmap_and_free_shared_area(size, sep_dev->shared_area, sep_dev->shared_area_bus);
2694 edbg("SEP Driver: free pages SEP SHARED AREA \n");
2695 iounmap((void *) sep_dev->reg_addr);
2696 edbg("SEP Driver: iounmap \n");
2697 /* release io memory region */
2698 release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE);
2699 edbg("SEP Driver: release_mem_region \n");
2700 dbg("SEP Driver:<-------- Exit end\n");
2701 }
2702
2703
2704 module_init(sep_init);
2705 module_exit(sep_exit);
2706
2707 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.152096 seconds and 4 git commands to generate.