1 /* 2 * Copyright (C) 2013 Broadcom Corporation 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation version 2. 7 * 8 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 9 * kind, whether express or implied; without even the implied warranty 10 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 #include <linux/smp.h> 14 #include <linux/io.h> 15 #include <linux/ioport.h> 16 17 #include <asm/cacheflush.h> 18 #include <linux/of_address.h> 19 20 #include "bcm_kona_smc.h" 21 22 static u32 bcm_smc_buffer_phys; /* physical address */ 23 static void __iomem *bcm_smc_buffer; /* virtual address */ 24 25 struct bcm_kona_smc_data { 26 unsigned service_id; 27 unsigned arg0; 28 unsigned arg1; 29 unsigned arg2; 30 unsigned arg3; 31 unsigned result; 32 }; 33 34 static const struct of_device_id bcm_kona_smc_ids[] __initconst = { 35 {.compatible = "brcm,kona-smc"}, 36 {.compatible = "bcm,kona-smc"}, /* deprecated name */ 37 {}, 38 }; 39 40 /* Map in the args buffer area */ 41 int __init bcm_kona_smc_init(void) 42 { 43 struct device_node *node; 44 const __be32 *prop_val; 45 u64 prop_size = 0; 46 unsigned long buffer_size; 47 u32 buffer_phys; 48 49 /* Read buffer addr and size from the device tree node */ 50 node = of_find_matching_node(NULL, bcm_kona_smc_ids); 51 if (!node) 52 return -ENODEV; 53 54 prop_val = of_get_address(node, 0, &prop_size, NULL); 55 of_node_put(node); 56 if (!prop_val) 57 return -EINVAL; 58 59 /* We assume space for four 32-bit arguments */ 60 if (prop_size < 4 * sizeof(u32) || prop_size > (u64)ULONG_MAX) 61 return -EINVAL; 62 buffer_size = (unsigned long)prop_size; 63 64 buffer_phys = be32_to_cpup(prop_val); 65 if (!buffer_phys) 66 return -EINVAL; 67 68 bcm_smc_buffer = ioremap(buffer_phys, buffer_size); 69 if (!bcm_smc_buffer) 70 return -ENOMEM; 71 bcm_smc_buffer_phys = buffer_phys; 72 73 pr_info("Kona Secure API initialized\n"); 74 75 return 0; 76 } 77 78 /* 79 * int bcm_kona_do_smc(u32 service_id, u32 buffer_addr) 80 * 81 * Only core 0 can run the secure monitor code. If an "smc" request 82 * is initiated on a different core it must be redirected to core 0 83 * for execution. We rely on the caller to handle this. 84 * 85 * Each "smc" request supplies a service id and the address of a 86 * buffer containing parameters related to the service to be 87 * performed. A flags value defines the behavior of the level 2 88 * cache and interrupt handling while the secure monitor executes. 89 * 90 * Parameters to the "smc" request are passed in r4-r6 as follows: 91 * r4 service id 92 * r5 flags (SEC_ROM_*) 93 * r6 physical address of buffer with other parameters 94 * 95 * Execution of an "smc" request produces two distinct results. 96 * 97 * First, the secure monitor call itself (regardless of the specific 98 * service request) can succeed, or can produce an error. When an 99 * "smc" request completes this value is found in r12; it should 100 * always be SEC_EXIT_NORMAL. 101 * 102 * In addition, the particular service performed produces a result. 103 * The values that should be expected depend on the service. We 104 * therefore return this value to the caller, so it can handle the 105 * request result appropriately. This result value is found in r0 106 * when the "smc" request completes. 107 */ 108 static int bcm_kona_do_smc(u32 service_id, u32 buffer_phys) 109 { 110 register u32 ip asm("ip"); /* Also called r12 */ 111 register u32 r0 asm("r0"); 112 register u32 r4 asm("r4"); 113 register u32 r5 asm("r5"); 114 register u32 r6 asm("r6"); 115 116 r4 = service_id; 117 r5 = 0x3; /* Keep IRQ and FIQ off in SM */ 118 r6 = buffer_phys; 119 120 asm volatile ( 121 /* Make sure we got the registers we want */ 122 __asmeq("%0", "ip") 123 __asmeq("%1", "r0") 124 __asmeq("%2", "r4") 125 __asmeq("%3", "r5") 126 __asmeq("%4", "r6") 127 ".arch_extension sec\n" 128 " smc #0\n" 129 : "=r" (ip), "=r" (r0) 130 : "r" (r4), "r" (r5), "r" (r6) 131 : "r1", "r2", "r3", "r7", "lr"); 132 133 BUG_ON(ip != SEC_EXIT_NORMAL); 134 135 return r0; 136 } 137 138 /* __bcm_kona_smc() should only run on CPU 0, with pre-emption disabled */ 139 static void __bcm_kona_smc(void *info) 140 { 141 struct bcm_kona_smc_data *data = info; 142 u32 __iomem *args = bcm_smc_buffer; 143 144 BUG_ON(smp_processor_id() != 0); 145 BUG_ON(!args); 146 147 /* Copy the four 32 bit argument values into the bounce area */ 148 writel_relaxed(data->arg0, args++); 149 writel_relaxed(data->arg1, args++); 150 writel_relaxed(data->arg2, args++); 151 writel(data->arg3, args); 152 153 /* Flush caches for input data passed to Secure Monitor */ 154 flush_cache_all(); 155 156 /* Trap into Secure Monitor and record the request result */ 157 data->result = bcm_kona_do_smc(data->service_id, bcm_smc_buffer_phys); 158 } 159 160 unsigned bcm_kona_smc(unsigned service_id, unsigned arg0, unsigned arg1, 161 unsigned arg2, unsigned arg3) 162 { 163 struct bcm_kona_smc_data data; 164 165 data.service_id = service_id; 166 data.arg0 = arg0; 167 data.arg1 = arg1; 168 data.arg2 = arg2; 169 data.arg3 = arg3; 170 data.result = 0; 171 172 /* 173 * Due to a limitation of the secure monitor, we must use the SMP 174 * infrastructure to forward all secure monitor calls to Core 0. 175 */ 176 smp_call_function_single(0, __bcm_kona_smc, &data, 1); 177 178 return data.result; 179 } 180