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