drivers/firmware/meson/meson_sm.c

   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);