1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Amlogic Secure Monitor driver 4 * 5 * Copyright (C) 2016 Endless Mobile, Inc. 6 * Author: Carlo Caione <carlo@endlessm.com> 7 */ 8 9 #define pr_fmt(fmt) "meson-sm: " fmt 10 11 #include <linux/arm-smccc.h> 12 #include <linux/bug.h> 13 #include <linux/io.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_device.h> 17 #include <linux/platform_device.h> 18 #include <linux/printk.h> 19 #include <linux/types.h> 20 #include <linux/sizes.h> 21 #include <linux/slab.h> 22 23 #include <linux/firmware/meson/meson_sm.h> 24 25 struct meson_sm_cmd { 26 unsigned int index; 27 u32 smc_id; 28 }; 29 #define CMD(d, s) { .index = (d), .smc_id = (s), } 30 31 struct meson_sm_chip { 32 unsigned int shmem_size; 33 u32 cmd_shmem_in_base; 34 u32 cmd_shmem_out_base; 35 struct meson_sm_cmd cmd[]; 36 }; 37 38 static const struct meson_sm_chip gxbb_chip = { 39 .shmem_size = SZ_4K, 40 .cmd_shmem_in_base = 0x82000020, 41 .cmd_shmem_out_base = 0x82000021, 42 .cmd = { 43 CMD(SM_EFUSE_READ, 0x82000030), 44 CMD(SM_EFUSE_WRITE, 0x82000031), 45 CMD(SM_EFUSE_USER_MAX, 0x82000033), 46 CMD(SM_GET_CHIP_ID, 0x82000044), 47 { /* sentinel */ }, 48 }, 49 }; 50 51 struct meson_sm_firmware { 52 const struct meson_sm_chip *chip; 53 void __iomem *sm_shmem_in_base; 54 void __iomem *sm_shmem_out_base; 55 }; 56 57 static u32 meson_sm_get_cmd(const struct meson_sm_chip *chip, 58 unsigned int cmd_index) 59 { 60 const struct meson_sm_cmd *cmd = chip->cmd; 61 62 while (cmd->smc_id && cmd->index != cmd_index) 63 cmd++; 64 65 return cmd->smc_id; 66 } 67 68 static u32 __meson_sm_call(u32 cmd, u32 arg0, u32 arg1, u32 arg2, 69 u32 arg3, u32 arg4) 70 { 71 struct arm_smccc_res res; 72 73 arm_smccc_smc(cmd, arg0, arg1, arg2, arg3, arg4, 0, 0, &res); 74 return res.a0; 75 } 76 77 static void __iomem *meson_sm_map_shmem(u32 cmd_shmem, unsigned int size) 78 { 79 u32 sm_phy_base; 80 81 sm_phy_base = __meson_sm_call(cmd_shmem, 0, 0, 0, 0, 0); 82 if (!sm_phy_base) 83 return 0; 84 85 return ioremap_cache(sm_phy_base, size); 86 } 87 88 /** 89 * meson_sm_call - generic SMC32 call to the secure-monitor 90 * 91 * @fw: Pointer to secure-monitor firmware 92 * @cmd_index: Index of the SMC32 function ID 93 * @ret: Returned value 94 * @arg0: SMC32 Argument 0 95 * @arg1: SMC32 Argument 1 96 * @arg2: SMC32 Argument 2 97 * @arg3: SMC32 Argument 3 98 * @arg4: SMC32 Argument 4 99 * 100 * Return: 0 on success, a negative value on error 101 */ 102 int meson_sm_call(struct meson_sm_firmware *fw, unsigned int cmd_index, 103 u32 *ret, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4) 104 { 105 u32 cmd, lret; 106 107 if (!fw->chip) 108 return -ENOENT; 109 110 cmd = meson_sm_get_cmd(fw->chip, cmd_index); 111 if (!cmd) 112 return -EINVAL; 113 114 lret = __meson_sm_call(cmd, arg0, arg1, arg2, arg3, arg4); 115 116 if (ret) 117 *ret = lret; 118 119 return 0; 120 } 121 EXPORT_SYMBOL(meson_sm_call); 122 123 /** 124 * meson_sm_call_read - retrieve data from secure-monitor 125 * 126 * @fw: Pointer to secure-monitor firmware 127 * @buffer: Buffer to store the retrieved data 128 * @bsize: Size of the buffer 129 * @cmd_index: Index of the SMC32 function ID 130 * @arg0: SMC32 Argument 0 131 * @arg1: SMC32 Argument 1 132 * @arg2: SMC32 Argument 2 133 * @arg3: SMC32 Argument 3 134 * @arg4: SMC32 Argument 4 135 * 136 * Return: size of read data on success, a negative value on error 137 * When 0 is returned there is no guarantee about the amount of 138 * data read and bsize bytes are copied in buffer. 139 */ 140 int meson_sm_call_read(struct meson_sm_firmware *fw, void *buffer, 141 unsigned int bsize, unsigned int cmd_index, u32 arg0, 142 u32 arg1, u32 arg2, u32 arg3, u32 arg4) 143 { 144 u32 size; 145 int ret; 146 147 if (!fw->chip) 148 return -ENOENT; 149 150 if (!fw->chip->cmd_shmem_out_base) 151 return -EINVAL; 152 153 if (bsize > fw->chip->shmem_size) 154 return -EINVAL; 155 156 if (meson_sm_call(fw, cmd_index, &size, arg0, arg1, arg2, arg3, arg4) < 0) 157 return -EINVAL; 158 159 if (size > bsize) 160 return -EINVAL; 161 162 ret = size; 163 164 if (!size) 165 size = bsize; 166 167 if (buffer) 168 memcpy(buffer, fw->sm_shmem_out_base, size); 169 170 return ret; 171 } 172 EXPORT_SYMBOL(meson_sm_call_read); 173 174 /** 175 * meson_sm_call_write - send data to secure-monitor 176 * 177 * @fw: Pointer to secure-monitor firmware 178 * @buffer: Buffer containing data to send 179 * @size: Size of the data to send 180 * @cmd_index: Index of the SMC32 function ID 181 * @arg0: SMC32 Argument 0 182 * @arg1: SMC32 Argument 1 183 * @arg2: SMC32 Argument 2 184 * @arg3: SMC32 Argument 3 185 * @arg4: SMC32 Argument 4 186 * 187 * Return: size of sent data on success, a negative value on error 188 */ 189 int meson_sm_call_write(struct meson_sm_firmware *fw, void *buffer, 190 unsigned int size, unsigned int cmd_index, u32 arg0, 191 u32 arg1, u32 arg2, u32 arg3, u32 arg4) 192 { 193 u32 written; 194 195 if (!fw->chip) 196 return -ENOENT; 197 198 if (size > fw->chip->shmem_size) 199 return -EINVAL; 200 201 if (!fw->chip->cmd_shmem_in_base) 202 return -EINVAL; 203 204 memcpy(fw->sm_shmem_in_base, buffer, size); 205 206 if (meson_sm_call(fw, cmd_index, &written, arg0, arg1, arg2, arg3, arg4) < 0) 207 return -EINVAL; 208 209 if (!written) 210 return -EINVAL; 211 212 return written; 213 } 214 EXPORT_SYMBOL(meson_sm_call_write); 215 216 /** 217 * meson_sm_get - get pointer to meson_sm_firmware structure. 218 * 219 * @sm_node: Pointer to the secure-monitor Device Tree node. 220 * 221 * Return: NULL is the secure-monitor device is not ready. 222 */ 223 struct meson_sm_firmware *meson_sm_get(struct device_node *sm_node) 224 { 225 struct platform_device *pdev = of_find_device_by_node(sm_node); 226 227 if (!pdev) 228 return NULL; 229 230 return platform_get_drvdata(pdev); 231 } 232 EXPORT_SYMBOL_GPL(meson_sm_get); 233 234 #define SM_CHIP_ID_LENGTH 119 235 #define SM_CHIP_ID_OFFSET 4 236 #define SM_CHIP_ID_SIZE 12 237 238 static ssize_t serial_show(struct device *dev, struct device_attribute *attr, 239 char *buf) 240 { 241 struct platform_device *pdev = to_platform_device(dev); 242 struct meson_sm_firmware *fw; 243 uint8_t *id_buf; 244 int ret; 245 246 fw = platform_get_drvdata(pdev); 247 248 id_buf = kmalloc(SM_CHIP_ID_LENGTH, GFP_KERNEL); 249 if (!id_buf) 250 return -ENOMEM; 251 252 ret = meson_sm_call_read(fw, id_buf, SM_CHIP_ID_LENGTH, SM_GET_CHIP_ID, 253 0, 0, 0, 0, 0); 254 if (ret < 0) { 255 kfree(id_buf); 256 return ret; 257 } 258 259 ret = sprintf(buf, "%12phN\n", &id_buf[SM_CHIP_ID_OFFSET]); 260 261 kfree(id_buf); 262 263 return ret; 264 } 265 266 static DEVICE_ATTR_RO(serial); 267 268 static struct attribute *meson_sm_sysfs_attributes[] = { 269 &dev_attr_serial.attr, 270 NULL, 271 }; 272 273 static const struct attribute_group meson_sm_sysfs_attr_group = { 274 .attrs = meson_sm_sysfs_attributes, 275 }; 276 277 static const struct of_device_id meson_sm_ids[] = { 278 { .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip }, 279 { /* sentinel */ }, 280 }; 281 282 static int __init meson_sm_probe(struct platform_device *pdev) 283 { 284 struct device *dev = &pdev->dev; 285 const struct meson_sm_chip *chip; 286 struct meson_sm_firmware *fw; 287 288 fw = devm_kzalloc(dev, sizeof(*fw), GFP_KERNEL); 289 if (!fw) 290 return -ENOMEM; 291 292 chip = of_match_device(meson_sm_ids, dev)->data; 293 294 if (chip->cmd_shmem_in_base) { 295 fw->sm_shmem_in_base = meson_sm_map_shmem(chip->cmd_shmem_in_base, 296 chip->shmem_size); 297 if (WARN_ON(!fw->sm_shmem_in_base)) 298 goto out; 299 } 300 301 if (chip->cmd_shmem_out_base) { 302 fw->sm_shmem_out_base = meson_sm_map_shmem(chip->cmd_shmem_out_base, 303 chip->shmem_size); 304 if (WARN_ON(!fw->sm_shmem_out_base)) 305 goto out_in_base; 306 } 307 308 fw->chip = chip; 309 310 platform_set_drvdata(pdev, fw); 311 312 pr_info("secure-monitor enabled\n"); 313 314 if (sysfs_create_group(&pdev->dev.kobj, &meson_sm_sysfs_attr_group)) 315 goto out_in_base; 316 317 return 0; 318 319 out_in_base: 320 iounmap(fw->sm_shmem_in_base); 321 out: 322 return -EINVAL; 323 } 324 325 static struct platform_driver meson_sm_driver = { 326 .driver = { 327 .name = "meson-sm", 328 .of_match_table = of_match_ptr(meson_sm_ids), 329 }, 330 }; 331 module_platform_driver_probe(meson_sm_driver, meson_sm_probe); 332