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 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 struct meson_sm_firmware fw;
  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  * @cmd_index:  Index of the SMC32 function ID
  94  * @ret:        Returned value
  95  * @arg0:       SMC32 Argument 0
  96  * @arg1:       SMC32 Argument 1
  97  * @arg2:       SMC32 Argument 2
  98  * @arg3:       SMC32 Argument 3
  99  * @arg4:       SMC32 Argument 4
 100  *
 101  * Return:      0 on success, a negative value on error
 102  */
 103 int meson_sm_call(unsigned int cmd_index, u32 *ret, u32 arg0,
 104                   u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 105 {
 106         u32 cmd, lret;
 107
 108         if (!fw.chip)
 109                 return -ENOENT;
 110
 111         cmd = meson_sm_get_cmd(fw.chip, cmd_index);
 112         if (!cmd)
 113                 return -EINVAL;
 114
 115         lret = __meson_sm_call(cmd, arg0, arg1, arg2, arg3, arg4);
 116
 117         if (ret)
 118                 *ret = lret;
 119
 120         return 0;
 121 }
 122 EXPORT_SYMBOL(meson_sm_call);
 123
 124 /**
 125  * meson_sm_call_read - retrieve data from secure-monitor
 126  *
 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(void *buffer, unsigned int bsize, unsigned int cmd_index,
 141                        u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 142 {
 143         u32 size;
 144         int ret;
 145
 146         if (!fw.chip)
 147                 return -ENOENT;
 148
 149         if (!fw.chip->cmd_shmem_out_base)
 150                 return -EINVAL;
 151
 152         if (bsize > fw.chip->shmem_size)
 153                 return -EINVAL;
 154
 155         if (meson_sm_call(cmd_index, &size, arg0, arg1, arg2, arg3, arg4) < 0)
 156                 return -EINVAL;
 157
 158         if (size > bsize)
 159                 return -EINVAL;
 160
 161         ret = size;
 162
 163         if (!size)
 164                 size = bsize;
 165
 166         if (buffer)
 167                 memcpy(buffer, fw.sm_shmem_out_base, size);
 168
 169         return ret;
 170 }
 171 EXPORT_SYMBOL(meson_sm_call_read);
 172
 173 /**
 174  * meson_sm_call_write - send data to secure-monitor
 175  *
 176  * @buffer:     Buffer containing data to send
 177  * @size:       Size of the data to send
 178  * @cmd_index:  Index of the SMC32 function ID
 179  * @arg0:       SMC32 Argument 0
 180  * @arg1:       SMC32 Argument 1
 181  * @arg2:       SMC32 Argument 2
 182  * @arg3:       SMC32 Argument 3
 183  * @arg4:       SMC32 Argument 4
 184  *
 185  * Return:      size of sent data on success, a negative value on error
 186  */
 187 int meson_sm_call_write(void *buffer, unsigned int size, unsigned int cmd_index,
 188                         u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 189 {
 190         u32 written;
 191
 192         if (!fw.chip)
 193                 return -ENOENT;
 194
 195         if (size > fw.chip->shmem_size)
 196                 return -EINVAL;
 197
 198         if (!fw.chip->cmd_shmem_in_base)
 199                 return -EINVAL;
 200
 201         memcpy(fw.sm_shmem_in_base, buffer, size);
 202
 203         if (meson_sm_call(cmd_index, &written, arg0, arg1, arg2, arg3, arg4) < 0)
 204                 return -EINVAL;
 205
 206         if (!written)
 207                 return -EINVAL;
 208
 209         return written;
 210 }
 211 EXPORT_SYMBOL(meson_sm_call_write);
 212
 213 #define SM_CHIP_ID_LENGTH       119
 214 #define SM_CHIP_ID_OFFSET       4
 215 #define SM_CHIP_ID_SIZE         12
 216
 217 static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
 218                          char *buf)
 219 {
 220         uint8_t *id_buf;
 221         int ret;
 222
 223         id_buf = kmalloc(SM_CHIP_ID_LENGTH, GFP_KERNEL);
 224         if (!id_buf)
 225                 return -ENOMEM;
 226
 227         ret = meson_sm_call_read(id_buf, SM_CHIP_ID_LENGTH, SM_GET_CHIP_ID,
 228                                  0, 0, 0, 0, 0);
 229         if (ret < 0) {
 230                 kfree(id_buf);
 231                 return ret;
 232         }
 233
 234         ret = sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
 235                         id_buf[SM_CHIP_ID_OFFSET + 0],
 236                         id_buf[SM_CHIP_ID_OFFSET + 1],
 237                         id_buf[SM_CHIP_ID_OFFSET + 2],
 238                         id_buf[SM_CHIP_ID_OFFSET + 3],
 239                         id_buf[SM_CHIP_ID_OFFSET + 4],
 240                         id_buf[SM_CHIP_ID_OFFSET + 5],
 241                         id_buf[SM_CHIP_ID_OFFSET + 6],
 242                         id_buf[SM_CHIP_ID_OFFSET + 7],
 243                         id_buf[SM_CHIP_ID_OFFSET + 8],
 244                         id_buf[SM_CHIP_ID_OFFSET + 9],
 245                         id_buf[SM_CHIP_ID_OFFSET + 10],
 246                         id_buf[SM_CHIP_ID_OFFSET + 11]);
 247
 248         kfree(id_buf);
 249
 250         return ret;
 251 }
 252
 253 static DEVICE_ATTR_RO(serial);
 254
 255 static struct attribute *meson_sm_sysfs_attributes[] = {
 256         &dev_attr_serial.attr,
 257         NULL,
 258 };
 259
 260 static const struct attribute_group meson_sm_sysfs_attr_group = {
 261         .attrs = meson_sm_sysfs_attributes,
 262 };
 263
 264 static const struct of_device_id meson_sm_ids[] = {
 265         { .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip },
 266         { /* sentinel */ },
 267 };
 268
 269 static int __init meson_sm_probe(struct platform_device *pdev)
 270 {
 271         const struct meson_sm_chip *chip;
 272
 273         chip = of_match_device(meson_sm_ids, &pdev->dev)->data;
 274
 275         if (chip->cmd_shmem_in_base) {
 276                 fw.sm_shmem_in_base = meson_sm_map_shmem(chip->cmd_shmem_in_base,
 277                                                          chip->shmem_size);
 278                 if (WARN_ON(!fw.sm_shmem_in_base))
 279                         goto out;
 280         }
 281
 282         if (chip->cmd_shmem_out_base) {
 283                 fw.sm_shmem_out_base = meson_sm_map_shmem(chip->cmd_shmem_out_base,
 284                                                           chip->shmem_size);
 285                 if (WARN_ON(!fw.sm_shmem_out_base))
 286                         goto out_in_base;
 287         }
 288
 289         fw.chip = chip;
 290         pr_info("secure-monitor enabled\n");
 291
 292         if (sysfs_create_group(&pdev->dev.kobj, &meson_sm_sysfs_attr_group))
 293                 goto out_in_base;
 294
 295         return 0;
 296
 297 out_in_base:
 298         iounmap(fw.sm_shmem_in_base);
 299 out:
 300         return -EINVAL;
 301 }
 302
 303 static struct platform_driver meson_sm_driver = {
 304         .driver = {
 305                 .name = "meson-sm",
 306                 .of_match_table = of_match_ptr(meson_sm_ids),
 307         },
 308 };
 309 module_platform_driver_probe(meson_sm_driver, meson_sm_probe);