drivers/gpu/drm/nouveau/nvkm/subdev/secboot/base.c

   1 /*
   2  * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  20  * DEALINGS IN THE SOFTWARE.
  21  */
  22 #include "priv.h"
  23
  24 #include <subdev/mc.h>
  25 #include <subdev/timer.h>
  26
  27 static const char *
  28 managed_falcons_names[] = {
  29         [NVKM_SECBOOT_FALCON_PMU] = "PMU",
  30         [NVKM_SECBOOT_FALCON_RESERVED] = "<reserved>",
  31         [NVKM_SECBOOT_FALCON_FECS] = "FECS",
  32         [NVKM_SECBOOT_FALCON_GPCCS] = "GPCCS",
  33         [NVKM_SECBOOT_FALCON_END] = "<invalid>",
  34 };
  35
  36 /*
  37  * Helper falcon functions
  38  */
  39
  40 static int
  41 falcon_clear_halt_interrupt(struct nvkm_device *device, u32 base)
  42 {
  43         int ret;
  44
  45         /* clear halt interrupt */
  46         nvkm_mask(device, base + 0x004, 0x10, 0x10);
  47         /* wait until halt interrupt is cleared */
  48         ret = nvkm_wait_msec(device, 10, base + 0x008, 0x10, 0x0);
  49         if (ret < 0)
  50                 return ret;
  51
  52         return 0;
  53 }
  54
  55 static int
  56 falcon_wait_idle(struct nvkm_device *device, u32 base)
  57 {
  58         int ret;
  59
  60         ret = nvkm_wait_msec(device, 10, base + 0x04c, 0xffff, 0x0);
  61         if (ret < 0)
  62                 return ret;
  63
  64         return 0;
  65 }
  66
  67 static int
  68 nvkm_secboot_falcon_enable(struct nvkm_secboot *sb)
  69 {
  70         struct nvkm_device *device = sb->subdev.device;
  71         int ret;
  72
  73         /* enable engine */
  74         nvkm_mc_enable(device, sb->devidx);
  75         ret = nvkm_wait_msec(device, 10, sb->base + 0x10c, 0x6, 0x0);
  76         if (ret < 0) {
  77                 nvkm_error(&sb->subdev, "Falcon mem scrubbing timeout\n");
  78                 nvkm_mc_disable(device, sb->devidx);
  79                 return ret;
  80         }
  81
  82         ret = falcon_wait_idle(device, sb->base);
  83         if (ret)
  84                 return ret;
  85
  86         /* enable IRQs */
  87         nvkm_wr32(device, sb->base + 0x010, 0xff);
  88         nvkm_mc_intr_mask(device, sb->devidx, true);
  89
  90         return 0;
  91 }
  92
  93 static int
  94 nvkm_secboot_falcon_disable(struct nvkm_secboot *sb)
  95 {
  96         struct nvkm_device *device = sb->subdev.device;
  97
  98         /* disable IRQs and wait for any previous code to complete */
  99         nvkm_mc_intr_mask(device, sb->devidx, false);
 100         nvkm_wr32(device, sb->base + 0x014, 0xff);
 101
 102         falcon_wait_idle(device, sb->base);
 103
 104         /* disable engine */
 105         nvkm_mc_disable(device, sb->devidx);
 106
 107         return 0;
 108 }
 109
 110 int
 111 nvkm_secboot_falcon_reset(struct nvkm_secboot *sb)
 112 {
 113         int ret;
 114
 115         ret = nvkm_secboot_falcon_disable(sb);
 116         if (ret)
 117                 return ret;
 118
 119         ret = nvkm_secboot_falcon_enable(sb);
 120         if (ret)
 121                 return ret;
 122
 123         return 0;
 124 }
 125
 126 /**
 127  * nvkm_secboot_falcon_run - run the falcon that will perform secure boot
 128  *
 129  * This function is to be called after all chip-specific preparations have
 130  * been completed. It will start the falcon to perform secure boot, wait for
 131  * it to halt, and report if an error occurred.
 132  */
 133 int
 134 nvkm_secboot_falcon_run(struct nvkm_secboot *sb)
 135 {
 136         struct nvkm_device *device = sb->subdev.device;
 137         int ret;
 138
 139         /* Start falcon */
 140         nvkm_wr32(device, sb->base + 0x100, 0x2);
 141
 142         /* Wait for falcon halt */
 143         ret = nvkm_wait_msec(device, 100, sb->base + 0x100, 0x10, 0x10);
 144         if (ret < 0)
 145                 return ret;
 146
 147         /* If mailbox register contains an error code, then ACR has failed */
 148         ret = nvkm_rd32(device, sb->base + 0x040);
 149         if (ret) {
 150                 nvkm_error(&sb->subdev, "ACR boot failed, ret 0x%08x", ret);
 151                 falcon_clear_halt_interrupt(device, sb->base);
 152                 return -EINVAL;
 153         }
 154
 155         return 0;
 156 }
 157
 158
 159 /**
 160  * nvkm_secboot_reset() - reset specified falcon
 161  */
 162 int
 163 nvkm_secboot_reset(struct nvkm_secboot *sb, u32 falcon)
 164 {
 165         /* Unmanaged falcon? */
 166         if (!(BIT(falcon) & sb->func->managed_falcons)) {
 167                 nvkm_error(&sb->subdev, "cannot reset unmanaged falcon!\n");
 168                 return -EINVAL;
 169         }
 170
 171         return sb->func->reset(sb, falcon);
 172 }
 173
 174 /**
 175  * nvkm_secboot_start() - start specified falcon
 176  */
 177 int
 178 nvkm_secboot_start(struct nvkm_secboot *sb, u32 falcon)
 179 {
 180         /* Unmanaged falcon? */
 181         if (!(BIT(falcon) & sb->func->managed_falcons)) {
 182                 nvkm_error(&sb->subdev, "cannot start unmanaged falcon!\n");
 183                 return -EINVAL;
 184         }
 185
 186         return sb->func->start(sb, falcon);
 187 }
 188
 189 /**
 190  * nvkm_secboot_is_managed() - check whether a given falcon is securely-managed
 191  */
 192 bool
 193 nvkm_secboot_is_managed(struct nvkm_secboot *secboot,
 194                         enum nvkm_secboot_falcon fid)
 195 {
 196         if (!secboot)
 197                 return false;
 198
 199         return secboot->func->managed_falcons & BIT(fid);
 200 }
 201
 202 static int
 203 nvkm_secboot_oneinit(struct nvkm_subdev *subdev)
 204 {
 205         struct nvkm_secboot *sb = nvkm_secboot(subdev);
 206         int ret = 0;
 207
 208         /* Call chip-specific init function */
 209         if (sb->func->init)
 210                 ret = sb->func->init(sb);
 211         if (ret) {
 212                 nvkm_error(subdev, "Secure Boot initialization failed: %d\n",
 213                            ret);
 214                 return ret;
 215         }
 216
 217         /*
 218          * Build all blobs - the same blobs can be used to perform secure boot
 219          * multiple times
 220          */
 221         if (sb->func->prepare_blobs)
 222                 ret = sb->func->prepare_blobs(sb);
 223
 224         return ret;
 225 }
 226
 227 static int
 228 nvkm_secboot_fini(struct nvkm_subdev *subdev, bool suspend)
 229 {
 230         struct nvkm_secboot *sb = nvkm_secboot(subdev);
 231         int ret = 0;
 232
 233         if (sb->func->fini)
 234                 ret = sb->func->fini(sb, suspend);
 235
 236         return ret;
 237 }
 238
 239 static void *
 240 nvkm_secboot_dtor(struct nvkm_subdev *subdev)
 241 {
 242         struct nvkm_secboot *sb = nvkm_secboot(subdev);
 243         void *ret = NULL;
 244
 245         if (sb->func->dtor)
 246                 ret = sb->func->dtor(sb);
 247
 248         return ret;
 249 }
 250
 251 static const struct nvkm_subdev_func
 252 nvkm_secboot = {
 253         .oneinit = nvkm_secboot_oneinit,
 254         .fini = nvkm_secboot_fini,
 255         .dtor = nvkm_secboot_dtor,
 256 };
 257
 258 int
 259 nvkm_secboot_ctor(const struct nvkm_secboot_func *func,
 260                   struct nvkm_device *device, int index,
 261                   struct nvkm_secboot *sb)
 262 {
 263         unsigned long fid;
 264
 265         nvkm_subdev_ctor(&nvkm_secboot, device, index, &sb->subdev);
 266         sb->func = func;
 267
 268         /* setup the performing falcon's base address and masks */
 269         switch (func->boot_falcon) {
 270         case NVKM_SECBOOT_FALCON_PMU:
 271                 sb->devidx = NVKM_SUBDEV_PMU;
 272                 sb->base = 0x10a000;
 273                 break;
 274         default:
 275                 nvkm_error(&sb->subdev, "invalid secure boot falcon\n");
 276                 return -EINVAL;
 277         };
 278
 279         nvkm_debug(&sb->subdev, "securely managed falcons:\n");
 280         for_each_set_bit(fid, &sb->func->managed_falcons,
 281                          NVKM_SECBOOT_FALCON_END)
 282                 nvkm_debug(&sb->subdev, "- %s\n", managed_falcons_names[fid]);
 283
 284         return 0;
 285 }