3 * sep_ext_with_pci_driver.c - Security Processor Driver
4 * pci initialization functions
6 * Copyright(c) 2009 Intel Corporation. All rights reserved.
7 * Copyright(c) 2009 Discretix. All rights reserved.
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * You should have received a copy of the GNU General Public License along with
20 * this program; if not, write to the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Mark Allyn mark.a.allyn@intel.com
29 * 2009.06.26 Initial publish
33 #include <linux/init.h>
34 #include <linux/module.h>
36 #include <linux/cdev.h>
37 #include <linux/kdev_t.h>
38 #include <linux/semaphore.h>
40 #include <linux/poll.h>
41 #include <linux/wait.h>
42 #include <linux/ioctl.h>
43 #include <linux/ioport.h>
45 #include <linux/interrupt.h>
46 #include <linux/pagemap.h>
47 #include <linux/pci.h>
48 #include <linux/firmware.h>
49 #include <linux/sched.h>
50 #include "sep_driver_hw_defs.h"
51 #include "sep_driver_config.h"
52 #include "sep_driver_api.h"
53 #include "sep_driver_ext_api.h"
56 #if SEP_DRIVER_ARM_DEBUG_MODE
58 #define CRYS_SEP_ROM_length 0x4000
60 #define CRYS_SEP_ROM_start_address 0x8000C000UL
62 #define CRYS_SEP_ROM_start_address_offset 0xC000UL
64 #define SEP_ROM_BANK_register 0x80008420UL
66 #define SEP_ROM_BANK_register_offset 0x8420UL
68 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0x82000000
71 /* #define SEP_RAR_IO_MEM_REGION_SIZE (1024*1024*2)
73 static unsigned long CRYS_SEP_ROM[] = {
74 #include "SEP_ROM_image.h"
81 THOSE 2 definitions are specific to the board - must be
82 defined during integration
84 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0xFF0D0000
88 #endif /* SEP_DRIVER_ARM_DEBUG_MODE */
90 #define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000
91 #define SEP_RAR_IO_MEM_REGION_SIZE 0x40000
93 irqreturn_t sep_inthandler(int irq , void* dev_id);
95 /* Keep this a single static object for now to keep the conversion easy */
97 static struct sep_device sep_instance;
98 struct sep_device *sep_dev = &sep_instance;
101 unsigned long jiffies_future;
103 /*-----------------------------
105 --------------------------------*/
108 function that is activated on the succesfull probe of the SEP device
110 static int __devinit sep_probe(struct pci_dev *pdev,
111 const struct pci_device_id *ent);
113 static struct pci_device_id sep_pci_id_tbl[] = {
114 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c) },
118 MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
122 /* field for registering driver to PCI device */
123 static struct pci_driver sep_pci_driver = {
124 .name = "sep_sec_driver",
125 .id_table = sep_pci_id_tbl,
131 This functions locks the area of the resisnd and cache sep code
133 void sep_lock_cache_resident_area(void)
140 This functions copies the cache and resident from their source location into
141 destination memory, which is external to Linux VM and is given as
144 int sep_copy_cache_resident_to_area(unsigned long src_cache_addr,
145 unsigned long cache_size_in_bytes,
146 unsigned long src_resident_addr,
147 unsigned long resident_size_in_bytes,
148 unsigned long *dst_new_cache_addr_ptr,
149 unsigned long *dst_new_resident_addr_ptr)
151 /* resident address in user space */
152 unsigned long resident_addr;
154 /* cahce address in user space */
155 unsigned long cache_addr;
157 const struct firmware *fw;
159 char *cache_name = "cache.image.bin";
160 char *res_name = "resident.image.bin";
165 /*--------------------------------
167 -------------------------------------*/
170 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
171 "SEP Driver:rar_virtual is %p\n",
172 sep_dev->rar_virtual_address);
173 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
174 "SEP Driver:rar_physical is %08lx\n",
175 sep_dev->rar_physical_address);
177 sep_dev->rar_region_addr = (unsigned long)sep_dev->rar_virtual_address;
179 sep_dev->cache_physical_address = sep_dev->rar_physical_address;
180 sep_dev->cache_virtual_address = sep_dev->rar_virtual_address;
183 error = request_firmware(&fw, cache_name, &sep_dev->sep_pci_dev_ptr->dev);
185 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
186 "SEP Driver:cant request cache fw\n");
190 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
191 "SEP Driver:cache data loc is %p\n",
193 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
194 "SEP Driver:cache data size is %08Zx\n",
197 memcpy((void *)sep_dev->cache_virtual_address, (void *)fw->data, fw->size);
199 sep_dev->cache_size = fw->size;
201 cache_addr = (unsigned long)sep_dev->cache_virtual_address;
203 release_firmware(fw);
205 sep_dev->resident_physical_address = sep_dev->cache_physical_address
206 + sep_dev->cache_size;
207 sep_dev->resident_virtual_address = sep_dev->cache_virtual_address
208 + sep_dev->cache_size;
211 error = request_firmware(&fw, res_name, &sep_dev->sep_pci_dev_ptr->dev);
213 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
214 "SEP Driver:cant request res fw\n");
218 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
219 "SEP Driver:res data loc is %p\n",
221 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
222 "SEP Driver:res data size is %08Zx\n",
225 memcpy((void *)sep_dev->resident_virtual_address, (void *)fw->data, fw->size);
227 sep_dev->resident_size = fw->size;
229 release_firmware(fw);
231 resident_addr = (unsigned long)sep_dev->resident_virtual_address;
233 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
234 "SEP Driver:resident_addr (physical )is %08lx\n",
235 sep_dev->resident_physical_address);
236 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
237 "SEP Driver:cache_addr (physical) is %08lx\n",
238 sep_dev->cache_physical_address);
240 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
241 "SEP Driver:resident_addr (logical )is %08lx\n",
243 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
244 "SEP Driver:cache_addr (logical) is %08lx\n",
247 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
248 "SEP Driver:resident_size is %08lx\n", sep_dev->resident_size);
249 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
250 "SEP Driver:cache_size is %08lx\n", sep_dev->cache_size);
254 /* physical addresses */
255 *dst_new_cache_addr_ptr = sep_dev->cache_physical_address;
256 *dst_new_resident_addr_ptr = sep_dev->resident_physical_address;
264 This functions maps and allocates the
265 shared area on the external RAM (device)
266 The input is shared_area_size - the size of the memory to
267 allocate. The outputs
268 are kernel_shared_area_addr_ptr - the kerenl
269 address of the mapped and allocated
270 shared area, and phys_shared_area_addr_ptr
271 - the physical address of the shared area
273 int sep_map_and_alloc_shared_area(unsigned long shared_area_size,
274 unsigned long *kernel_shared_area_addr_ptr,
275 unsigned long *phys_shared_area_addr_ptr)
277 // shared_virtual_address = ioremap_nocache(0xda00000,shared_area_size);
278 sep_dev->shared_virtual_address = kmalloc(shared_area_size, GFP_KERNEL);
279 if (!sep_dev->shared_virtual_address) {
280 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
281 "sep_driver:shared memory kmalloc failed\n");
286 sep_dev->shared_physical_address = __pa(sep_dev->shared_virtual_address);
287 // shared_physical_address = 0xda00000;
289 *kernel_shared_area_addr_ptr = (unsigned long)sep_dev->shared_virtual_address;
290 /* set the physical address of the shared area */
291 *phys_shared_area_addr_ptr = sep_dev->shared_physical_address;
293 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
294 "SEP Driver:shared_virtual_address is %p\n",
295 sep_dev->shared_virtual_address);
296 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
297 "SEP Driver:shared_region_size is %08lx\n",
299 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
300 "SEP Driver:shared_physical_addr is %08lx\n",
301 *phys_shared_area_addr_ptr);
307 This functions unmaps and deallocates the shared area
308 on the external RAM (device)
309 The input is shared_area_size - the size of the memory to deallocate,kernel_
310 shared_area_addr_ptr - the kernel address of the mapped and allocated
311 shared area,phys_shared_area_addr_ptr - the physical address of
314 void sep_unmap_and_free_shared_area(unsigned long shared_area_size,
315 unsigned long kernel_shared_area_addr,
316 unsigned long phys_shared_area_addr)
318 kfree((void *)kernel_shared_area_addr);
323 This functions returns the physical address inside shared area according
324 to the virtual address. It can be either on the externa RAM device
325 (ioremapped), or on the system RAM
326 This implementation is for the external RAM
328 unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address)
330 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
331 "SEP Driver:sh virt to phys v %08lx\n",
333 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
334 "SEP Driver:sh virt to phys p %08lx\n",
335 sep_dev->shared_physical_address
336 + (virt_address - (unsigned long)sep_dev->shared_virtual_address));
338 return (unsigned long)sep_dev->shared_physical_address +
339 (virt_address - (unsigned long)sep_dev->shared_virtual_address);
343 This functions returns the virtual address inside shared area
344 according to the physical address. It can be either on the
345 externa RAM device (ioremapped), or on the system RAM This implementation
346 is for the external RAM
348 unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address)
350 return (unsigned long)sep_dev->shared_virtual_address
351 + (phys_address - sep_dev->shared_physical_address);
356 function that is activaed on the succesfull probe of the SEP device
358 static int __devinit sep_probe(struct pci_dev *pdev,
359 const struct pci_device_id *ent)
364 /*------------------------
366 ---------------------------*/
368 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
369 "Sep pci probe starting\n");
372 /* enable the device */
373 error = pci_enable_device(pdev);
375 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
376 "error enabling pci device\n");
380 /* set the pci dev pointer */
381 sep_dev->sep_pci_dev_ptr = pdev;
383 /* get the io memory start address */
384 sep_dev->io_memory_start_physical_address = pci_resource_start(pdev, 0);
385 if (!sep_dev->io_memory_start_physical_address) {
386 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
387 "SEP Driver error pci resource start\n");
391 /* get the io memory end address */
392 sep_dev->io_memory_end_physical_address = pci_resource_end(pdev, 0);
393 if (!sep_dev->io_memory_end_physical_address) {
394 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
395 "SEP Driver error pci resource end\n");
399 sep_dev->io_memory_size = sep_dev->io_memory_end_physical_address -
400 sep_dev->io_memory_start_physical_address + 1;
402 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
403 "SEP Driver:io_memory_start_physical_address is %08lx\n",
404 sep_dev->io_memory_start_physical_address);
406 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
407 "SEP Driver:io_memory_end_phyaical_address is %08lx\n",
408 sep_dev->io_memory_end_physical_address);
410 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
411 "SEP Driver:io_memory_size is %08lx\n",
412 sep_dev->io_memory_size);
414 sep_dev->io_memory_start_virtual_address =
415 ioremap_nocache(sep_dev->io_memory_start_physical_address,
416 sep_dev->io_memory_size);
417 if (!sep_dev->io_memory_start_virtual_address) {
418 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
419 "SEP Driver error ioremap of io memory\n");
423 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
424 "SEP Driver:io_memory_start_virtual_address is %p\n",
425 sep_dev->io_memory_start_virtual_address);
427 sep_dev->reg_base_address = (unsigned long)sep_dev->io_memory_start_virtual_address;
430 /* set up system base address and shared memory location */
432 sep_dev->rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE,
435 if (!sep_dev->rar_virtual_address) {
436 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
437 "SEP Driver:cant kmalloc rar\n");
441 sep_dev->rar_physical_address = __pa(sep_dev->rar_virtual_address);
443 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
444 "SEP Driver:rar_physical is %08lx\n",
445 sep_dev->rar_physical_address);
447 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
448 "SEP Driver:rar_virtual is %p\n",
449 sep_dev->rar_virtual_address);
452 #if !SEP_DRIVER_POLLING_MODE
454 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
455 "SEP Driver: about to write IMR and ICR REG_ADDR\n");
457 /* clear ICR register */
458 SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_ICR_REG_ADDR,
461 /* set the IMR register - open only GPR 2 */
462 SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR,
465 /* figure out our irq */
467 error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *)&sep_dev->sep_irq);
469 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
470 "SEP Driver: my irq is %d\n", sep_irq);
472 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
473 "SEP Driver: about to call request_irq\n");
474 /* get the interrupt line */
475 error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED,
476 "sep_driver", &sep_dev->reg_base_address);
481 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
482 "SEP Driver: about to write IMR REG_ADDR");
484 /* set the IMR register - open only GPR 2 */
485 SEP_WRITE_REGISTER(sep_dev->reg_base_address + HW_HOST_IMR_REG_ADDR,
488 #endif /* SEP_DRIVER_POLLING_MODE */
496 this function registers th driver to
497 the device subsystem( either PCI, USB, etc)
499 int sep_register_driver_to_device(void)
501 return pci_register_driver(&sep_pci_driver);
506 void sep_load_rom_code(void)
508 #if SEP_DRIVER_ARM_DEBUG_MODE
509 /* Index variables */
510 unsigned long i, k, j;
511 unsigned long regVal;
513 unsigned long warning;
515 /* Loading ROM from SEP_ROM_image.h file */
516 k = sizeof(CRYS_SEP_ROM);
518 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
519 "SEP Driver: DX_CC_TST_SepRomLoader start\n");
521 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
522 "SEP Driver: k is %lu\n", k);
523 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
524 "SEP Driver: sep_dev->reg_base_address is %p\n",
525 sep_dev->reg_base_address);
526 DEBUG_PRINT_1(SEP_DEBUG_LEVEL_EXTENDED,
527 "SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n",
528 CRYS_SEP_ROM_start_address_offset);
530 for (i = 0; i < 4; i++) {
532 SEP_WRITE_REGISTER(sep_dev->reg_base_address
533 + SEP_ROM_BANK_register_offset, i);
535 for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) {
536 SEP_WRITE_REGISTER(sep_dev->reg_base_address +
537 CRYS_SEP_ROM_start_address_offset + 4*j,
538 CRYS_SEP_ROM[i * 0x1000 + j]);
543 j = CRYS_SEP_ROM_length;
550 SEP_WRITE_REGISTER(sep_dev->reg_base_address
551 + HW_HOST_SEP_SW_RST_REG_ADDR, 0x1);
553 /* poll for SEP ROM boot finish */
555 SEP_READ_REGISTER(sep_dev->reg_base_address
556 + HW_HOST_SEP_HOST_GPR3_REG_ADDR, regVal);
559 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
560 "SEP Driver: ROM polling ended\n");
564 /* fatal error - read erro status from GPRO */
565 SEP_READ_REGISTER(sep_dev->reg_base_address
566 + HW_HOST_SEP_HOST_GPR0_REG_ADDR, Error);
567 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
568 "SEP Driver: ROM polling case 1\n");
571 /* Boot First Phase ended */
572 SEP_READ_REGISTER(sep_dev->reg_base_address
573 + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
574 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
575 "SEP Driver: ROM polling case 2\n");
578 /* Cold boot ended successfully */
579 SEP_READ_REGISTER(sep_dev->reg_base_address
580 + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
581 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
582 "SEP Driver: ROM polling case 4\n");
586 /* Warmboot ended successfully */
587 SEP_READ_REGISTER(sep_dev->reg_base_address
588 + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
589 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
590 "SEP Driver: ROM polling case 8\n");
594 /* ColdWarm boot ended successfully */
595 SEP_READ_REGISTER(sep_dev->reg_base_address
596 + HW_HOST_SEP_HOST_GPR0_REG_ADDR, warning);
597 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
598 "SEP Driver: ROM polling case 16\n");
602 DEBUG_PRINT_0(SEP_DEBUG_LEVEL_EXTENDED,
603 "SEP Driver: ROM polling case 32\n");