drivers/firmware/turris-mox-rwtm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Turris Mox rWTM firmware driver
   4  *
   5  * Copyright (C) 2019 Marek Behun <marek.behun@nic.cz>
   6  */
   7
   8 #include <linux/armada-37xx-rwtm-mailbox.h>
   9 #include <linux/completion.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/hw_random.h>
  12 #include <linux/mailbox_client.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/slab.h>
  18
  19 #define DRIVER_NAME             "turris-mox-rwtm"
  20
  21 /*
  22  * The macros and constants below come from Turris Mox's rWTM firmware code.
  23  * This firmware is open source and it's sources can be found at
  24  * https://gitlab.labs.nic.cz/turris/mox-boot-builder/tree/master/wtmi.
  25  */
  26
  27 #define MBOX_STS_SUCCESS        (0 << 30)
  28 #define MBOX_STS_FAIL           (1 << 30)
  29 #define MBOX_STS_BADCMD         (2 << 30)
  30 #define MBOX_STS_ERROR(s)       ((s) & (3 << 30))
  31 #define MBOX_STS_VALUE(s)       (((s) >> 10) & 0xfffff)
  32 #define MBOX_STS_CMD(s)         ((s) & 0x3ff)
  33
  34 enum mbox_cmd {
  35         MBOX_CMD_GET_RANDOM     = 1,
  36         MBOX_CMD_BOARD_INFO     = 2,
  37         MBOX_CMD_ECDSA_PUB_KEY  = 3,
  38         MBOX_CMD_HASH           = 4,
  39         MBOX_CMD_SIGN           = 5,
  40         MBOX_CMD_VERIFY         = 6,
  41
  42         MBOX_CMD_OTP_READ       = 7,
  43         MBOX_CMD_OTP_WRITE      = 8,
  44 };
  45
  46 struct mox_kobject;
  47
  48 struct mox_rwtm {
  49         struct device *dev;
  50         struct mbox_client mbox_client;
  51         struct mbox_chan *mbox;
  52         struct mox_kobject *kobj;
  53         struct hwrng hwrng;
  54
  55         struct armada_37xx_rwtm_rx_msg reply;
  56
  57         void *buf;
  58         dma_addr_t buf_phys;
  59
  60         struct mutex busy;
  61         struct completion cmd_done;
  62
  63         /* board information */
  64         int has_board_info;
  65         u64 serial_number;
  66         int board_version, ram_size;
  67         u8 mac_address1[6], mac_address2[6];
  68
  69         /* public key burned in eFuse */
  70         int has_pubkey;
  71         u8 pubkey[135];
  72 };
  73
  74 struct mox_kobject {
  75         struct kobject kobj;
  76         struct mox_rwtm *rwtm;
  77 };
  78
  79 static inline struct kobject *rwtm_to_kobj(struct mox_rwtm *rwtm)
  80 {
  81         return &rwtm->kobj->kobj;
  82 }
  83
  84 static inline struct mox_rwtm *to_rwtm(struct kobject *kobj)
  85 {
  86         return container_of(kobj, struct mox_kobject, kobj)->rwtm;
  87 }
  88
  89 static void mox_kobj_release(struct kobject *kobj)
  90 {
  91         kfree(to_rwtm(kobj)->kobj);
  92 }
  93
  94 static struct kobj_type mox_kobj_ktype = {
  95         .release        = mox_kobj_release,
  96         .sysfs_ops      = &kobj_sysfs_ops,
  97 };
  98
  99 static int mox_kobj_create(struct mox_rwtm *rwtm)
 100 {
 101         rwtm->kobj = kzalloc(sizeof(*rwtm->kobj), GFP_KERNEL);
 102         if (!rwtm->kobj)
 103                 return -ENOMEM;
 104
 105         kobject_init(rwtm_to_kobj(rwtm), &mox_kobj_ktype);
 106         if (kobject_add(rwtm_to_kobj(rwtm), firmware_kobj, "turris-mox-rwtm")) {
 107                 kobject_put(rwtm_to_kobj(rwtm));
 108                 return -ENXIO;
 109         }
 110
 111         rwtm->kobj->rwtm = rwtm;
 112
 113         return 0;
 114 }
 115
 116 #define MOX_ATTR_RO(name, format, cat)                          \
 117 static ssize_t                                                  \
 118 name##_show(struct kobject *kobj, struct kobj_attribute *a,     \
 119             char *buf)                                          \
 120 {                                                               \
 121         struct mox_rwtm *rwtm = to_rwtm(kobj);  \
 122         if (!rwtm->has_##cat)                                   \
 123                 return -ENODATA;                                \
 124         return sprintf(buf, format, rwtm->name);                \
 125 }                                                               \
 126 static struct kobj_attribute mox_attr_##name = __ATTR_RO(name)
 127
 128 MOX_ATTR_RO(serial_number, "%016llX\n", board_info);
 129 MOX_ATTR_RO(board_version, "%i\n", board_info);
 130 MOX_ATTR_RO(ram_size, "%i\n", board_info);
 131 MOX_ATTR_RO(mac_address1, "%pM\n", board_info);
 132 MOX_ATTR_RO(mac_address2, "%pM\n", board_info);
 133 MOX_ATTR_RO(pubkey, "%s\n", pubkey);
 134
 135 static int mox_get_status(enum mbox_cmd cmd, u32 retval)
 136 {
 137         if (MBOX_STS_CMD(retval) != cmd ||
 138             MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS)
 139                 return -EIO;
 140         else if (MBOX_STS_ERROR(retval) == MBOX_STS_FAIL)
 141                 return -(int)MBOX_STS_VALUE(retval);
 142         else
 143                 return MBOX_STS_VALUE(retval);
 144 }
 145
 146 static const struct attribute *mox_rwtm_attrs[] = {
 147         &mox_attr_serial_number.attr,
 148         &mox_attr_board_version.attr,
 149         &mox_attr_ram_size.attr,
 150         &mox_attr_mac_address1.attr,
 151         &mox_attr_mac_address2.attr,
 152         &mox_attr_pubkey.attr,
 153         NULL
 154 };
 155
 156 static void mox_rwtm_rx_callback(struct mbox_client *cl, void *data)
 157 {
 158         struct mox_rwtm *rwtm = dev_get_drvdata(cl->dev);
 159         struct armada_37xx_rwtm_rx_msg *msg = data;
 160
 161         rwtm->reply = *msg;
 162         complete(&rwtm->cmd_done);
 163 }
 164
 165 static void reply_to_mac_addr(u8 *mac, u32 t1, u32 t2)
 166 {
 167         mac[0] = t1 >> 8;
 168         mac[1] = t1;
 169         mac[2] = t2 >> 24;
 170         mac[3] = t2 >> 16;
 171         mac[4] = t2 >> 8;
 172         mac[5] = t2;
 173 }
 174
 175 static int mox_get_board_info(struct mox_rwtm *rwtm)
 176 {
 177         struct armada_37xx_rwtm_tx_msg msg;
 178         struct armada_37xx_rwtm_rx_msg *reply = &rwtm->reply;
 179         int ret;
 180
 181         msg.command = MBOX_CMD_BOARD_INFO;
 182         ret = mbox_send_message(rwtm->mbox, &msg);
 183         if (ret < 0)
 184                 return ret;
 185
 186         ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2);
 187         if (ret < 0)
 188                 return ret;
 189
 190         ret = mox_get_status(MBOX_CMD_BOARD_INFO, reply->retval);
 191         if (ret < 0 && ret != -ENODATA) {
 192                 return ret;
 193         } else if (ret == -ENODATA) {
 194                 dev_warn(rwtm->dev,
 195                          "Board does not have manufacturing information burned!\n");
 196         } else {
 197                 rwtm->serial_number = reply->status[1];
 198                 rwtm->serial_number <<= 32;
 199                 rwtm->serial_number |= reply->status[0];
 200                         rwtm->board_version = reply->status[2];
 201                 rwtm->ram_size = reply->status[3];
 202                 reply_to_mac_addr(rwtm->mac_address1, reply->status[4],
 203                                   reply->status[5]);
 204                 reply_to_mac_addr(rwtm->mac_address2, reply->status[6],
 205                                   reply->status[7]);
 206                 rwtm->has_board_info = 1;
 207
 208                 pr_info("Turris Mox serial number %016llX\n",
 209                         rwtm->serial_number);
 210                 pr_info("           board version %i\n", rwtm->board_version);
 211                 pr_info("           burned RAM size %i MiB\n", rwtm->ram_size);
 212         }
 213
 214         msg.command = MBOX_CMD_ECDSA_PUB_KEY;
 215         ret = mbox_send_message(rwtm->mbox, &msg);
 216         if (ret < 0)
 217                 return ret;
 218
 219         ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2);
 220         if (ret < 0)
 221                 return ret;
 222
 223         ret = mox_get_status(MBOX_CMD_ECDSA_PUB_KEY, reply->retval);
 224         if (ret < 0 && ret != -ENODATA) {
 225                 return ret;
 226         } else if (ret == -ENODATA) {
 227                 dev_warn(rwtm->dev, "Board has no public key burned!\n");
 228         } else {
 229                 u32 *s = reply->status;
 230
 231                 rwtm->has_pubkey = 1;
 232                 sprintf(rwtm->pubkey,
 233                         "%06x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
 234                         ret, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
 235                         s[8], s[9], s[10], s[11], s[12], s[13], s[14], s[15]);
 236         }
 237
 238         return 0;
 239 }
 240
 241 static int mox_hwrng_read(struct hwrng *rng, void *data, size_t max, bool wait)
 242 {
 243         struct mox_rwtm *rwtm = (struct mox_rwtm *) rng->priv;
 244         struct armada_37xx_rwtm_tx_msg msg;
 245         int ret;
 246
 247         if (max > 4096)
 248                 max = 4096;
 249
 250         msg.command = MBOX_CMD_GET_RANDOM;
 251         msg.args[0] = 1;
 252         msg.args[1] = rwtm->buf_phys;
 253         msg.args[2] = (max + 3) & ~3;
 254
 255         if (!wait) {
 256                 if (!mutex_trylock(&rwtm->busy))
 257                         return -EBUSY;
 258         } else {
 259                 mutex_lock(&rwtm->busy);
 260         }
 261
 262         ret = mbox_send_message(rwtm->mbox, &msg);
 263         if (ret < 0)
 264                 goto unlock_mutex;
 265
 266         ret = wait_for_completion_interruptible(&rwtm->cmd_done);
 267         if (ret < 0)
 268                 goto unlock_mutex;
 269
 270         ret = mox_get_status(MBOX_CMD_GET_RANDOM, rwtm->reply.retval);
 271         if (ret < 0)
 272                 goto unlock_mutex;
 273
 274         memcpy(data, rwtm->buf, max);
 275         ret = max;
 276
 277 unlock_mutex:
 278         mutex_unlock(&rwtm->busy);
 279         return ret;
 280 }
 281
 282 static int turris_mox_rwtm_probe(struct platform_device *pdev)
 283 {
 284         struct mox_rwtm *rwtm;
 285         struct device *dev = &pdev->dev;
 286         int ret;
 287
 288         rwtm = devm_kzalloc(dev, sizeof(*rwtm), GFP_KERNEL);
 289         if (!rwtm)
 290                 return -ENOMEM;
 291
 292         rwtm->dev = dev;
 293         rwtm->buf = dmam_alloc_coherent(dev, PAGE_SIZE, &rwtm->buf_phys,
 294                                         GFP_KERNEL);
 295         if (!rwtm->buf)
 296                 return -ENOMEM;
 297
 298         ret = mox_kobj_create(rwtm);
 299         if (ret < 0) {
 300                 dev_err(dev, "Cannot create turris-mox-rwtm kobject!\n");
 301                 return ret;
 302         }
 303
 304         ret = sysfs_create_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
 305         if (ret < 0) {
 306                 dev_err(dev, "Cannot create sysfs files!\n");
 307                 goto put_kobj;
 308         }
 309
 310         platform_set_drvdata(pdev, rwtm);
 311
 312         mutex_init(&rwtm->busy);
 313
 314         rwtm->mbox_client.dev = dev;
 315         rwtm->mbox_client.rx_callback = mox_rwtm_rx_callback;
 316
 317         rwtm->mbox = mbox_request_channel(&rwtm->mbox_client, 0);
 318         if (IS_ERR(rwtm->mbox)) {
 319                 ret = PTR_ERR(rwtm->mbox);
 320                 if (ret != -EPROBE_DEFER)
 321                         dev_err(dev, "Cannot request mailbox channel: %i\n",
 322                                 ret);
 323                 goto remove_files;
 324         }
 325
 326         init_completion(&rwtm->cmd_done);
 327
 328         ret = mox_get_board_info(rwtm);
 329         if (ret < 0)
 330                 dev_warn(dev, "Cannot read board information: %i\n", ret);
 331
 332         rwtm->hwrng.name = DRIVER_NAME "_hwrng";
 333         rwtm->hwrng.read = mox_hwrng_read;
 334         rwtm->hwrng.priv = (unsigned long) rwtm;
 335         rwtm->hwrng.quality = 1024;
 336
 337         ret = devm_hwrng_register(dev, &rwtm->hwrng);
 338         if (ret < 0) {
 339                 dev_err(dev, "Cannot register HWRNG: %i\n", ret);
 340                 goto free_channel;
 341         }
 342
 343         return 0;
 344
 345 free_channel:
 346         mbox_free_channel(rwtm->mbox);
 347 remove_files:
 348         sysfs_remove_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
 349 put_kobj:
 350         kobject_put(rwtm_to_kobj(rwtm));
 351         return ret;
 352 }
 353
 354 static int turris_mox_rwtm_remove(struct platform_device *pdev)
 355 {
 356         struct mox_rwtm *rwtm = platform_get_drvdata(pdev);
 357
 358         sysfs_remove_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
 359         kobject_put(rwtm_to_kobj(rwtm));
 360         mbox_free_channel(rwtm->mbox);
 361
 362         return 0;
 363 }
 364
 365 static const struct of_device_id turris_mox_rwtm_match[] = {
 366         { .compatible = "cznic,turris-mox-rwtm", },
 367         { },
 368 };
 369
 370 MODULE_DEVICE_TABLE(of, turris_mox_rwtm_match);
 371
 372 static struct platform_driver turris_mox_rwtm_driver = {
 373         .probe  = turris_mox_rwtm_probe,
 374         .remove = turris_mox_rwtm_remove,
 375         .driver = {
 376                 .name           = DRIVER_NAME,
 377                 .of_match_table = turris_mox_rwtm_match,
 378         },
 379 };
 380 module_platform_driver(turris_mox_rwtm_driver);
 381
 382 MODULE_LICENSE("GPL v2");
 383 MODULE_DESCRIPTION("Turris Mox rWTM firmware driver");
 384 MODULE_AUTHOR("Marek Behun <marek.behun@nic.cz>");