sys/arm/allwinner/aw_sid.c

   1 /*-
   2  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  18  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  20  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  21  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 /*
  29  * Allwinner secure ID controller
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/endian.h>
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39 #include <sys/rman.h>
  40 #include <sys/kernel.h>
  41 #include <sys/lock.h>
  42 #include <sys/mutex.h>
  43 #include <sys/module.h>
  44 #include <sys/sysctl.h>
  45 #include <machine/bus.h>
  46
  47 #include <dev/ofw/ofw_bus.h>
  48 #include <dev/ofw/ofw_bus_subr.h>
  49
  50 #include <arm/allwinner/aw_sid.h>
  51
  52 #include "nvmem_if.h"
  53
  54 /*
  55  * Starting at least from sun8iw6 (A83T) EFUSE starts at 0x200
  56  * There is 3 registers in the low area to read/write protected EFUSE.
  57  */
  58 #define SID_PRCTL               0x40
  59 #define  SID_PRCTL_OFFSET_MASK  0xff
  60 #define  SID_PRCTL_OFFSET(n)    (((n) & SID_PRCTL_OFFSET_MASK) << 16)
  61 #define  SID_PRCTL_LOCK         (0xac << 8)
  62 #define  SID_PRCTL_READ         (0x01 << 1)
  63 #define  SID_PRCTL_WRITE        (0x01 << 0)
  64 #define SID_PRKEY               0x50
  65 #define SID_RDKEY               0x60
  66
  67 #define EFUSE_OFFSET            0x200
  68 #define EFUSE_NAME_SIZE         32
  69 #define EFUSE_DESC_SIZE         64
  70
  71 struct aw_sid_efuse {
  72         char                    name[EFUSE_NAME_SIZE];
  73         char                    desc[EFUSE_DESC_SIZE];
  74         bus_size_t              base;
  75         bus_size_t              offset;
  76         uint32_t                size;
  77         enum aw_sid_fuse_id     id;
  78         bool                    public;
  79 };
  80
  81 static struct aw_sid_efuse a10_efuses[] = {
  82         {
  83                 .name = "rootkey",
  84                 .desc = "Root Key or ChipID",
  85                 .offset = 0x0,
  86                 .size = 16,
  87                 .id = AW_SID_FUSE_ROOTKEY,
  88                 .public = true,
  89         },
  90 };
  91
  92 static struct aw_sid_efuse a64_efuses[] = {
  93         {
  94                 .name = "rootkey",
  95                 .desc = "Root Key or ChipID",
  96                 .base = EFUSE_OFFSET,
  97                 .offset = 0x00,
  98                 .size = 16,
  99                 .id = AW_SID_FUSE_ROOTKEY,
 100                 .public = true,
 101         },
 102         {
 103                 .name = "calibration",
 104                 .desc = "Thermal Sensor Calibration Data",
 105                 .base = EFUSE_OFFSET,
 106                 .offset = 0x34,
 107                 .size = 8,
 108                 .id = AW_SID_FUSE_THSSENSOR,
 109                 .public = true,
 110         },
 111 };
 112
 113 static struct aw_sid_efuse a83t_efuses[] = {
 114         {
 115                 .name = "rootkey",
 116                 .desc = "Root Key or ChipID",
 117                 .base = EFUSE_OFFSET,
 118                 .offset = 0x00,
 119                 .size = 16,
 120                 .id = AW_SID_FUSE_ROOTKEY,
 121                 .public = true,
 122         },
 123         {
 124                 .name = "calibration",
 125                 .desc = "Thermal Sensor Calibration Data",
 126                 .base = EFUSE_OFFSET,
 127                 .offset = 0x34,
 128                 .size = 8,
 129                 .id = AW_SID_FUSE_THSSENSOR,
 130                 .public = true,
 131         },
 132 };
 133
 134 static struct aw_sid_efuse h3_efuses[] = {
 135         {
 136                 .name = "rootkey",
 137                 .desc = "Root Key or ChipID",
 138                 .base = EFUSE_OFFSET,
 139                 .offset = 0x00,
 140                 .size = 16,
 141                 .id = AW_SID_FUSE_ROOTKEY,
 142                 .public = true,
 143         },
 144         {
 145                 .name = "calibration",
 146                 .desc = "Thermal Sensor Calibration Data",
 147                 .base = EFUSE_OFFSET,
 148                 .offset = 0x34,
 149                 .size = 4,
 150                 .id = AW_SID_FUSE_THSSENSOR,
 151                 .public = false,
 152         },
 153 };
 154
 155 static struct aw_sid_efuse h5_efuses[] = {
 156         {
 157                 .name = "rootkey",
 158                 .desc = "Root Key or ChipID",
 159                 .base = EFUSE_OFFSET,
 160                 .offset = 0x00,
 161                 .size = 16,
 162                 .id = AW_SID_FUSE_ROOTKEY,
 163                 .public = true,
 164         },
 165         {
 166                 .name = "calibration",
 167                 .desc = "Thermal Sensor Calibration Data",
 168                 .base = EFUSE_OFFSET,
 169                 .offset = 0x34,
 170                 .size = 4,
 171                 .id = AW_SID_FUSE_THSSENSOR,
 172                 .public = true,
 173         },
 174 };
 175
 176 struct aw_sid_conf {
 177         struct aw_sid_efuse     *efuses;
 178         size_t                  nfuses;
 179 };
 180
 181 static const struct aw_sid_conf a10_conf = {
 182         .efuses = a10_efuses,
 183         .nfuses = nitems(a10_efuses),
 184 };
 185
 186 static const struct aw_sid_conf a20_conf = {
 187         .efuses = a10_efuses,
 188         .nfuses = nitems(a10_efuses),
 189 };
 190
 191 static const struct aw_sid_conf a64_conf = {
 192         .efuses = a64_efuses,
 193         .nfuses = nitems(a64_efuses),
 194 };
 195
 196 static const struct aw_sid_conf a83t_conf = {
 197         .efuses = a83t_efuses,
 198         .nfuses = nitems(a83t_efuses),
 199 };
 200
 201 static const struct aw_sid_conf h3_conf = {
 202         .efuses = h3_efuses,
 203         .nfuses = nitems(h3_efuses),
 204 };
 205
 206 static const struct aw_sid_conf h5_conf = {
 207         .efuses = h5_efuses,
 208         .nfuses = nitems(h5_efuses),
 209 };
 210
 211 static struct ofw_compat_data compat_data[] = {
 212         { "allwinner,sun4i-a10-sid",            (uintptr_t)&a10_conf},
 213         { "allwinner,sun7i-a20-sid",            (uintptr_t)&a20_conf},
 214         { "allwinner,sun50i-a64-sid",           (uintptr_t)&a64_conf},
 215         { "allwinner,sun8i-a83t-sid",           (uintptr_t)&a83t_conf},
 216         { "allwinner,sun8i-h3-sid",             (uintptr_t)&h3_conf},
 217         { "allwinner,sun50i-h5-sid",            (uintptr_t)&h5_conf},
 218         { NULL,                                 0 }
 219 };
 220
 221 struct aw_sid_softc {
 222         device_t                sid_dev;
 223         struct resource         *res;
 224         struct aw_sid_conf      *sid_conf;
 225         struct mtx              prctl_mtx;
 226 };
 227
 228 static struct aw_sid_softc *aw_sid_sc;
 229
 230 static struct resource_spec aw_sid_spec[] = {
 231         { SYS_RES_MEMORY,       0,      RF_ACTIVE },
 232         { -1, 0 }
 233 };
 234
 235 #define RD1(sc, reg)            bus_read_1((sc)->res, (reg))
 236 #define RD4(sc, reg)            bus_read_4((sc)->res, (reg))
 237 #define WR4(sc, reg, val)       bus_write_4((sc)->res, (reg), (val))
 238
 239 static int aw_sid_sysctl(SYSCTL_HANDLER_ARGS);
 240
 241 static int
 242 aw_sid_probe(device_t dev)
 243 {
 244         if (!ofw_bus_status_okay(dev))
 245                 return (ENXIO);
 246
 247         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 248                 return (ENXIO);
 249
 250         device_set_desc(dev, "Allwinner Secure ID Controller");
 251         return (BUS_PROBE_DEFAULT);
 252 }
 253
 254 static int
 255 aw_sid_attach(device_t dev)
 256 {
 257         struct aw_sid_softc *sc;
 258         phandle_t node;
 259         int i;
 260
 261         node = ofw_bus_get_node(dev);
 262         sc = device_get_softc(dev);
 263         sc->sid_dev = dev;
 264
 265         if (bus_alloc_resources(dev, aw_sid_spec, &sc->res) != 0) {
 266                 device_printf(dev, "cannot allocate resources for device\n");
 267                 return (ENXIO);
 268         }
 269
 270         mtx_init(&sc->prctl_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 271         sc->sid_conf = (struct aw_sid_conf *)ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 272         aw_sid_sc = sc;
 273
 274         /* Register ourself so device can resolve who we are */
 275         OF_device_register_xref(OF_xref_from_node(node), dev);
 276
 277         for (i = 0; i < sc->sid_conf->nfuses ;i++) {\
 278                 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 279                     SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 280                     OID_AUTO, sc->sid_conf->efuses[i].name,
 281                     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 282                     dev, sc->sid_conf->efuses[i].id, aw_sid_sysctl,
 283                     "A", sc->sid_conf->efuses[i].desc);
 284         }
 285         return (0);
 286 }
 287
 288 int
 289 aw_sid_get_fuse(enum aw_sid_fuse_id id, uint8_t *out, uint32_t *size)
 290 {
 291         struct aw_sid_softc *sc;
 292         uint32_t val;
 293         int i, j;
 294
 295         sc = aw_sid_sc;
 296         if (sc == NULL)
 297                 return (ENXIO);
 298
 299         for (i = 0; i < sc->sid_conf->nfuses; i++)
 300                 if (id == sc->sid_conf->efuses[i].id)
 301                         break;
 302
 303         if (i == sc->sid_conf->nfuses)
 304                 return (ENOENT);
 305
 306         if (*size != sc->sid_conf->efuses[i].size) {
 307                 *size = sc->sid_conf->efuses[i].size;
 308                 return (ENOMEM);
 309         }
 310
 311         if (out == NULL)
 312                 return (ENOMEM);
 313
 314         if (sc->sid_conf->efuses[i].public == false)
 315                 mtx_lock(&sc->prctl_mtx);
 316         for (j = 0; j < sc->sid_conf->efuses[i].size; j += 4) {
 317                 if (sc->sid_conf->efuses[i].public == false) {
 318                         val = SID_PRCTL_OFFSET(sc->sid_conf->efuses[i].offset + j) |
 319                                 SID_PRCTL_LOCK |
 320                                 SID_PRCTL_READ;
 321                         WR4(sc, SID_PRCTL, val);
 322                         /* Read bit will be cleared once read has concluded */
 323                         while (RD4(sc, SID_PRCTL) & SID_PRCTL_READ)
 324                                 continue;
 325                         val = RD4(sc, SID_RDKEY);
 326                 } else
 327                         val = RD4(sc, sc->sid_conf->efuses[i].base +
 328                             sc->sid_conf->efuses[i].offset + j);
 329                 out[j] = val & 0xFF;
 330                 if (j + 1 < *size)
 331                         out[j + 1] = (val & 0xFF00) >> 8;
 332                 if (j + 2 < *size)
 333                         out[j + 2] = (val & 0xFF0000) >> 16;
 334                 if (j + 3 < *size)
 335                         out[j + 3] = (val & 0xFF000000) >> 24;
 336         }
 337         if (sc->sid_conf->efuses[i].public == false)
 338                 mtx_unlock(&sc->prctl_mtx);
 339
 340         return (0);
 341 }
 342
 343 static int
 344 aw_sid_read(device_t dev, uint32_t offset, uint32_t size, uint8_t *buffer)
 345 {
 346         struct aw_sid_softc *sc;
 347         enum aw_sid_fuse_id fuse_id = 0;
 348         int i;
 349
 350         sc = device_get_softc(dev);
 351
 352         for (i = 0; i < sc->sid_conf->nfuses; i++)
 353                 if (offset == sc->sid_conf->efuses[i].offset) {
 354                         fuse_id = sc->sid_conf->efuses[i].id;
 355                         break;
 356                 }
 357
 358         if (fuse_id == 0)
 359                 return (ENOENT);
 360
 361         return (aw_sid_get_fuse(fuse_id, buffer, &size));
 362 }
 363
 364 static int
 365 aw_sid_sysctl(SYSCTL_HANDLER_ARGS)
 366 {
 367         struct aw_sid_softc *sc;
 368         device_t dev = arg1;
 369         enum aw_sid_fuse_id fuse = arg2;
 370         uint8_t data[32];
 371         char out[128];
 372         uint32_t size;
 373         int ret, i;
 374
 375         sc = device_get_softc(dev);
 376
 377         /* Get the size of the efuse data */
 378         size = 0;
 379         aw_sid_get_fuse(fuse, NULL, &size);
 380         /* We now have the real size */
 381         ret = aw_sid_get_fuse(fuse, data, &size);
 382         if (ret != 0) {
 383                 device_printf(dev, "Cannot get fuse id %d: %d\n", fuse, ret);
 384                 return (ENOENT);
 385         }
 386
 387         for (i = 0; i < size; i++)
 388                 snprintf(out + (i * 2), sizeof(out) - (i * 2),
 389                   "%.2x", data[i]);
 390
 391         return sysctl_handle_string(oidp, out, sizeof(out), req);
 392 }
 393
 394 static device_method_t aw_sid_methods[] = {
 395         /* Device interface */
 396         DEVMETHOD(device_probe,         aw_sid_probe),
 397         DEVMETHOD(device_attach,        aw_sid_attach),
 398
 399         /* NVMEM interface */
 400         DEVMETHOD(nvmem_read,           aw_sid_read),
 401         DEVMETHOD_END
 402 };
 403
 404 static driver_t aw_sid_driver = {
 405         "aw_sid",
 406         aw_sid_methods,
 407         sizeof(struct aw_sid_softc),
 408 };
 409
 410 static devclass_t aw_sid_devclass;
 411
 412 EARLY_DRIVER_MODULE(aw_sid, simplebus, aw_sid_driver, aw_sid_devclass, 0, 0,
 413     BUS_PASS_SUPPORTDEV + BUS_PASS_ORDER_FIRST);
 414 MODULE_VERSION(aw_sid, 1);
 415 SIMPLEBUS_PNP_INFO(compat_data);