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
59 #define CRYS_SEP_ROM_start_address 0x8000C000UL
60 #define CRYS_SEP_ROM_start_address_offset 0xC000UL
61 #define SEP_ROM_BANK_register 0x80008420UL
62 #define SEP_ROM_BANK_register_offset 0x8420UL
63 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0x82000000
66 * THESE 2 definitions are specific to the board - must be
67 * defined during integration
69 #define SEP_RAR_IO_MEM_REGION_START_ADDRESS 0xFF0D0000
73 void sep_load_rom_code(void)
76 unsigned long i, k, j;
79 unsigned long warning;
81 /* Loading ROM from SEP_ROM_image.h file */
82 k = sizeof(CRYS_SEP_ROM);
84 edbg("SEP Driver: DX_CC_TST_SepRomLoader start\n");
86 edbg("SEP Driver: k is %lu\n", k);
87 edbg("SEP Driver: sep_dev->reg_base_address is %p\n", sep_dev->reg_base_address);
88 edbg("SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", CRYS_SEP_ROM_start_address_offset);
90 for (i = 0; i < 4; i++) {
92 sep_write_reg(sep_dev, SEP_ROM_BANK_register_offset, i);
94 for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) {
95 sep_write_reg(sep_dev, CRYS_SEP_ROM_start_address_offset + 4 * j, CRYS_SEP_ROM[i * 0x1000 + j]);
100 j = CRYS_SEP_ROM_length;
107 sep_write_reg(sep_dev, HW_HOST_SEP_SW_RST_REG_ADDR, 0x1);
109 /* poll for SEP ROM boot finish */
111 retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
114 edbg("SEP Driver: ROM polling ended\n");
118 /* fatal error - read erro status from GPRO */
119 Error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
120 edbg("SEP Driver: ROM polling case 1\n");
123 /* Boot First Phase ended */
124 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
125 edbg("SEP Driver: ROM polling case 2\n");
128 /* Cold boot ended successfully */
129 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
130 edbg("SEP Driver: ROM polling case 4\n");
134 /* Warmboot ended successfully */
135 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
136 edbg("SEP Driver: ROM polling case 8\n");
140 /* ColdWarm boot ended successfully */
141 warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
142 edbg("SEP Driver: ROM polling case 16\n");
146 edbg("SEP Driver: ROM polling case 32\n");
153 void sep_load_rom_code(void) { }
154 #endif /* SEP_DRIVER_ARM_DEBUG_MODE */
156 #define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000
157 #define SEP_RAR_IO_MEM_REGION_SIZE 0x40000
159 irqreturn_t sep_inthandler(int irq, void *dev_id);
161 /* Keep this a single static object for now to keep the conversion easy */
163 static struct sep_device sep_instance;
164 struct sep_device *sep_dev = &sep_instance;
167 unsigned long jiffies_future;
169 /*-----------------------------
171 --------------------------------*/
174 function that is activated on the succesfull probe of the SEP device
176 static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
178 static struct pci_device_id sep_pci_id_tbl[] = {
179 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c)},
183 MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
185 /* field for registering driver to PCI device */
186 static struct pci_driver sep_pci_driver = {
187 .name = "sep_sec_driver",
188 .id_table = sep_pci_id_tbl,
193 This functions locks the area of the resisnd and cache sep code
195 void sep_lock_cache_resident_area(void)
201 This functions copies the cache and resident from their source location into
202 destination memory, which is external to Linux VM and is given as
205 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)
207 unsigned long resident_addr;
208 unsigned long cache_addr;
209 const struct firmware *fw;
211 char *cache_name = "cache.image.bin";
212 char *res_name = "resident.image.bin";
217 /*--------------------------------
219 -------------------------------------*/
222 edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_virtual_address);
223 edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_physical_address);
225 sep_dev->rar_region_addr = (unsigned long) sep_dev->rar_virtual_address;
227 sep_dev->cache_physical_address = sep_dev->rar_physical_address;
228 sep_dev->cache_virtual_address = sep_dev->rar_virtual_address;
231 error = request_firmware(&fw, cache_name, &sep_dev->sep_pci_dev_ptr->dev);
233 edbg("SEP Driver:cant request cache fw\n");
237 edbg("SEP Driver:cache data loc is %p\n", (void *) fw->data);
238 edbg("SEP Driver:cache data size is %08Zx\n", fw->size);
240 memcpy((void *) sep_dev->cache_virtual_address, (void *) fw->data, fw->size);
242 sep_dev->cache_size = fw->size;
244 cache_addr = (unsigned long) sep_dev->cache_virtual_address;
246 release_firmware(fw);
248 sep_dev->resident_physical_address = sep_dev->cache_physical_address + sep_dev->cache_size;
249 sep_dev->resident_virtual_address = sep_dev->cache_virtual_address + sep_dev->cache_size;
252 error = request_firmware(&fw, res_name, &sep_dev->sep_pci_dev_ptr->dev);
254 edbg("SEP Driver:cant request res fw\n");
258 edbg("SEP Driver:res data loc is %p\n", (void *) fw->data);
259 edbg("SEP Driver:res data size is %08Zx\n", fw->size);
261 memcpy((void *) sep_dev->resident_virtual_address, (void *) fw->data, fw->size);
263 sep_dev->resident_size = fw->size;
265 release_firmware(fw);
267 resident_addr = (unsigned long) sep_dev->resident_virtual_address;
269 edbg("SEP Driver:resident_addr (physical )is %08lx\n", sep_dev->resident_physical_address);
270 edbg("SEP Driver:cache_addr (physical) is %08lx\n", sep_dev->cache_physical_address);
272 edbg("SEP Driver:resident_addr (logical )is %08lx\n", resident_addr);
273 edbg("SEP Driver:cache_addr (logical) is %08lx\n", cache_addr);
275 edbg("SEP Driver:resident_size is %08lx\n", sep_dev->resident_size);
276 edbg("SEP Driver:cache_size is %08lx\n", sep_dev->cache_size);
280 /* physical addresses */
281 *dst_new_cache_addr_ptr = sep_dev->cache_physical_address;
282 *dst_new_resident_addr_ptr = sep_dev->resident_physical_address;
288 This functions maps and allocates the
289 shared area on the external RAM (device)
290 The input is shared_area_size - the size of the memory to
291 allocate. The outputs
292 are kernel_shared_area_addr_ptr - the kerenl
293 address of the mapped and allocated
294 shared area, and phys_shared_area_addr_ptr
295 - the physical address of the shared area
297 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)
299 // shared_virtual_address = ioremap_nocache(0xda00000,shared_area_size);
300 sep_dev->shared_virtual_address = kmalloc(shared_area_size, GFP_KERNEL);
301 if (!sep_dev->shared_virtual_address) {
302 edbg("sep_driver:shared memory kmalloc failed\n");
306 sep_dev->shared_physical_address = __pa(sep_dev->shared_virtual_address);
307 /* shared_physical_address = 0xda00000; */
308 *kernel_shared_area_addr_ptr = (unsigned long) sep_dev->shared_virtual_address;
309 /* set the physical address of the shared area */
310 *phys_shared_area_addr_ptr = sep_dev->shared_physical_address;
311 edbg("SEP Driver:shared_virtual_address is %p\n", sep_dev->shared_virtual_address);
312 edbg("SEP Driver:shared_region_size is %08lx\n", shared_area_size);
313 edbg("SEP Driver:shared_physical_addr is %08lx\n", *phys_shared_area_addr_ptr);
319 This functions unmaps and deallocates the shared area
320 on the external RAM (device)
321 The input is shared_area_size - the size of the memory to deallocate,kernel_
322 shared_area_addr_ptr - the kernel address of the mapped and allocated
323 shared area,phys_shared_area_addr_ptr - the physical address of
326 void sep_unmap_and_free_shared_area(unsigned long shared_area_size, unsigned long kernel_shared_area_addr, unsigned long phys_shared_area_addr)
328 kfree((void *) kernel_shared_area_addr);
332 This functions returns the physical address inside shared area according
333 to the virtual address. It can be either on the externa RAM device
334 (ioremapped), or on the system RAM
335 This implementation is for the external RAM
337 unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address)
339 edbg("SEP Driver:sh virt to phys v %08lx\n", virt_address);
340 edbg("SEP Driver:sh virt to phys p %08lx\n", sep_dev->shared_physical_address + (virt_address - (unsigned long) sep_dev->shared_virtual_address));
342 return (unsigned long) sep_dev->shared_physical_address + (virt_address - (unsigned long) sep_dev->shared_virtual_address);
346 This functions returns the virtual address inside shared area
347 according to the physical address. It can be either on the
348 externa RAM device (ioremapped), or on the system RAM This implementation
349 is for the external RAM
351 unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address)
353 return (unsigned long) sep_dev->shared_virtual_address + (phys_address - sep_dev->shared_physical_address);
358 function that is activaed on the succesfull probe of the SEP device
360 static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
364 edbg("Sep pci probe starting\n");
366 /* enable the device */
367 error = pci_enable_device(pdev);
369 edbg("error enabling pci device\n");
373 /* set the pci dev pointer */
374 sep_dev->sep_pci_dev_ptr = pdev;
376 /* get the io memory start address */
377 sep_dev->io_memory_start_physical_address = pci_resource_start(pdev, 0);
378 if (!sep_dev->io_memory_start_physical_address) {
379 edbg("SEP Driver error pci resource start\n");
383 /* get the io memory end address */
384 sep_dev->io_memory_end_physical_address = pci_resource_end(pdev, 0);
385 if (!sep_dev->io_memory_end_physical_address) {
386 edbg("SEP Driver error pci resource end\n");
390 sep_dev->io_memory_size = sep_dev->io_memory_end_physical_address - sep_dev->io_memory_start_physical_address + 1;
392 edbg("SEP Driver:io_memory_start_physical_address is %08lx\n", sep_dev->io_memory_start_physical_address);
394 edbg("SEP Driver:io_memory_end_phyaical_address is %08lx\n", sep_dev->io_memory_end_physical_address);
396 edbg("SEP Driver:io_memory_size is %08lx\n", sep_dev->io_memory_size);
398 sep_dev->io_memory_start_virtual_address = ioremap_nocache(sep_dev->io_memory_start_physical_address, sep_dev->io_memory_size);
399 if (!sep_dev->io_memory_start_virtual_address) {
400 edbg("SEP Driver error ioremap of io memory\n");
404 edbg("SEP Driver:io_memory_start_virtual_address is %p\n", sep_dev->io_memory_start_virtual_address);
406 sep_dev->reg_base_address = (void __iomem *) sep_dev->io_memory_start_virtual_address;
409 /* set up system base address and shared memory location */
411 sep_dev->rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE, GFP_KERNEL);
413 if (!sep_dev->rar_virtual_address) {
414 edbg("SEP Driver:cant kmalloc rar\n");
418 sep_dev->rar_physical_address = __pa(sep_dev->rar_virtual_address);
420 edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_physical_address);
421 edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_virtual_address);
423 #if !SEP_DRIVER_POLLING_MODE
425 edbg("SEP Driver: about to write IMR and ICR REG_ADDR\n");
427 /* clear ICR register */
428 sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
430 /* set the IMR register - open only GPR 2 */
431 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
433 /* figure out our irq */
435 error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *) & sep_dev->sep_irq);
437 edbg("SEP Driver: my irq is %d\n", sep_irq);
439 edbg("SEP Driver: about to call request_irq\n");
440 /* get the interrupt line */
441 error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED, "sep_driver", &sep_dev->reg_base_address);
446 edbg("SEP Driver: about to write IMR REG_ADDR");
448 /* set the IMR register - open only GPR 2 */
449 sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
451 #endif /* SEP_DRIVER_POLLING_MODE */
457 this function registers th driver to
458 the device subsystem( either PCI, USB, etc)
460 int sep_register_driver_to_device(void)
462 return pci_register_driver(&sep_pci_driver);