drivers/firmware/meson/meson_sm.c

   1 /*
   2  * Amlogic Secure Monitor driver
   3  *
   4  * Copyright (C) 2016 Endless Mobile, Inc.
   5  * Author: Carlo Caione <carlo@endlessm.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * version 2 as published by the Free Software Foundation.
  10  *
  11  * You should have received a copy of the GNU General Public License
  12  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  13  */
  14
  15 #define pr_fmt(fmt) "meson-sm: " fmt
  16
  17 #include <linux/arm-smccc.h>
  18 #include <linux/bug.h>
  19 #include <linux/io.h>
  20 #include <linux/of.h>
  21 #include <linux/of_device.h>
  22 #include <linux/printk.h>
  23 #include <linux/types.h>
  24 #include <linux/sizes.h>
  25
  26 #include <linux/firmware/meson/meson_sm.h>
  27
  28 struct meson_sm_cmd {
  29         unsigned int index;
  30         u32 smc_id;
  31 };
  32 #define CMD(d, s) { .index = (d), .smc_id = (s), }
  33
  34 struct meson_sm_chip {
  35         unsigned int shmem_size;
  36         u32 cmd_shmem_in_base;
  37         u32 cmd_shmem_out_base;
  38         struct meson_sm_cmd cmd[];
  39 };
  40
  41 struct meson_sm_chip gxbb_chip = {
  42         .shmem_size             = SZ_4K,
  43         .cmd_shmem_in_base      = 0x82000020,
  44         .cmd_shmem_out_base     = 0x82000021,
  45         .cmd = {
  46                 CMD(SM_EFUSE_READ,      0x82000030),
  47                 CMD(SM_EFUSE_WRITE,     0x82000031),
  48                 CMD(SM_EFUSE_USER_MAX,  0x82000033),
  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 struct meson_sm_firmware fw;
  60
  61 static u32 meson_sm_get_cmd(const struct meson_sm_chip *chip,
  62                             unsigned int cmd_index)
  63 {
  64         const struct meson_sm_cmd *cmd = chip->cmd;
  65
  66         while (cmd->smc_id && cmd->index != cmd_index)
  67                 cmd++;
  68
  69         return cmd->smc_id;
  70 }
  71
  72 static u32 __meson_sm_call(u32 cmd, u32 arg0, u32 arg1, u32 arg2,
  73                            u32 arg3, u32 arg4)
  74 {
  75         struct arm_smccc_res res;
  76
  77         arm_smccc_smc(cmd, arg0, arg1, arg2, arg3, arg4, 0, 0, &res);
  78         return res.a0;
  79 }
  80
  81 static void __iomem *meson_sm_map_shmem(u32 cmd_shmem, unsigned int size)
  82 {
  83         u32 sm_phy_base;
  84
  85         sm_phy_base = __meson_sm_call(cmd_shmem, 0, 0, 0, 0, 0);
  86         if (!sm_phy_base)
  87                 return 0;
  88
  89         return ioremap_cache(sm_phy_base, size);
  90 }
  91
  92 /**
  93  * meson_sm_call - generic SMC32 call to the secure-monitor
  94  *
  95  * @cmd_index:  Index of the SMC32 function ID
  96  * @ret:        Returned value
  97  * @arg0:       SMC32 Argument 0
  98  * @arg1:       SMC32 Argument 1
  99  * @arg2:       SMC32 Argument 2
 100  * @arg3:       SMC32 Argument 3
 101  * @arg4:       SMC32 Argument 4
 102  *
 103  * Return:      0 on success, a negative value on error
 104  */
 105 int meson_sm_call(unsigned int cmd_index, u32 *ret, u32 arg0,
 106                   u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 107 {
 108         u32 cmd, lret;
 109
 110         if (!fw.chip)
 111                 return -ENOENT;
 112
 113         cmd = meson_sm_get_cmd(fw.chip, cmd_index);
 114         if (!cmd)
 115                 return -EINVAL;
 116
 117         lret = __meson_sm_call(cmd, arg0, arg1, arg2, arg3, arg4);
 118
 119         if (ret)
 120                 *ret = lret;
 121
 122         return 0;
 123 }
 124 EXPORT_SYMBOL(meson_sm_call);
 125
 126 /**
 127  * meson_sm_call_read - retrieve data from secure-monitor
 128  *
 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(void *buffer, unsigned int bsize, unsigned int cmd_index,
 143                        u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 144 {
 145         u32 size;
 146         int ret;
 147
 148         if (!fw.chip)
 149                 return -ENOENT;
 150
 151         if (!fw.chip->cmd_shmem_out_base)
 152                 return -EINVAL;
 153
 154         if (bsize > fw.chip->shmem_size)
 155                 return -EINVAL;
 156
 157         if (meson_sm_call(cmd_index, &size, arg0, arg1, arg2, arg3, arg4) < 0)
 158                 return -EINVAL;
 159
 160         if (size > bsize)
 161                 return -EINVAL;
 162
 163         ret = size;
 164
 165         if (!size)
 166                 size = bsize;
 167
 168         if (buffer)
 169                 memcpy(buffer, fw.sm_shmem_out_base, size);
 170
 171         return ret;
 172 }
 173 EXPORT_SYMBOL(meson_sm_call_read);
 174
 175 /**
 176  * meson_sm_call_write - send data to secure-monitor
 177  *
 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(void *buffer, unsigned int size, unsigned int cmd_index,
 190                         u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 191 {
 192         u32 written;
 193
 194         if (!fw.chip)
 195                 return -ENOENT;
 196
 197         if (size > fw.chip->shmem_size)
 198                 return -EINVAL;
 199
 200         if (!fw.chip->cmd_shmem_in_base)
 201                 return -EINVAL;
 202
 203         memcpy(fw.sm_shmem_in_base, buffer, size);
 204
 205         if (meson_sm_call(cmd_index, &written, arg0, arg1, arg2, arg3, arg4) < 0)
 206                 return -EINVAL;
 207
 208         if (!written)
 209                 return -EINVAL;
 210
 211         return written;
 212 }
 213 EXPORT_SYMBOL(meson_sm_call_write);
 214
 215 static const struct of_device_id meson_sm_ids[] = {
 216         { .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip },
 217         { /* sentinel */ },
 218 };
 219
 220 int __init meson_sm_init(void)
 221 {
 222         const struct meson_sm_chip *chip;
 223         const struct of_device_id *matched_np;
 224         struct device_node *np;
 225
 226         np = of_find_matching_node_and_match(NULL, meson_sm_ids, &matched_np);
 227         if (!np)
 228                 return -ENODEV;
 229
 230         chip = matched_np->data;
 231         if (!chip) {
 232                 pr_err("unable to setup secure-monitor data\n");
 233                 goto out;
 234         }
 235
 236         if (chip->cmd_shmem_in_base) {
 237                 fw.sm_shmem_in_base = meson_sm_map_shmem(chip->cmd_shmem_in_base,
 238                                                          chip->shmem_size);
 239                 if (WARN_ON(!fw.sm_shmem_in_base))
 240                         goto out;
 241         }
 242
 243         if (chip->cmd_shmem_out_base) {
 244                 fw.sm_shmem_out_base = meson_sm_map_shmem(chip->cmd_shmem_out_base,
 245                                                           chip->shmem_size);
 246                 if (WARN_ON(!fw.sm_shmem_out_base))
 247                         goto out_in_base;
 248         }
 249
 250         fw.chip = chip;
 251         pr_info("secure-monitor enabled\n");
 252
 253         return 0;
 254
 255 out_in_base:
 256         iounmap(fw.sm_shmem_in_base);
 257 out:
 258         return -EINVAL;
 259 }
 260 device_initcall(meson_sm_init);