drivers/gpu/drm/i915/intel_uc_fw.c

   1 /*
   2  * Copyright © 2016-2017 Intel Corporation
   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 (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include <linux/firmware.h>
  26 #include <drm/drm_print.h>
  27
  28 #include "intel_uc_fw.h"
  29 #include "i915_drv.h"
  30
  31 /**
  32  * intel_uc_fw_fetch - fetch uC firmware
  33  *
  34  * @dev_priv: device private
  35  * @uc_fw: uC firmware
  36  *
  37  * Fetch uC firmware into GEM obj.
  38  */
  39 void intel_uc_fw_fetch(struct drm_i915_private *dev_priv,
  40                        struct intel_uc_fw *uc_fw)
  41 {
  42         struct pci_dev *pdev = dev_priv->drm.pdev;
  43         struct drm_i915_gem_object *obj;
  44         const struct firmware *fw = NULL;
  45         struct uc_css_header *css;
  46         size_t size;
  47         int err;
  48
  49         DRM_DEBUG_DRIVER("%s fw fetch %s\n",
  50                          intel_uc_fw_type_repr(uc_fw->type), uc_fw->path);
  51
  52         if (!uc_fw->path)
  53                 return;
  54
  55         uc_fw->fetch_status = INTEL_UC_FIRMWARE_PENDING;
  56         DRM_DEBUG_DRIVER("%s fw fetch %s\n",
  57                          intel_uc_fw_type_repr(uc_fw->type),
  58                          intel_uc_fw_status_repr(uc_fw->fetch_status));
  59
  60         err = request_firmware(&fw, uc_fw->path, &pdev->dev);
  61         if (err) {
  62                 DRM_DEBUG_DRIVER("%s fw request_firmware err=%d\n",
  63                                  intel_uc_fw_type_repr(uc_fw->type), err);
  64                 goto fail;
  65         }
  66
  67         DRM_DEBUG_DRIVER("%s fw size %zu ptr %p\n",
  68                          intel_uc_fw_type_repr(uc_fw->type), fw->size, fw);
  69
  70         /* Check the size of the blob before examining buffer contents */
  71         if (fw->size < sizeof(struct uc_css_header)) {
  72                 DRM_WARN("%s: Unexpected firmware size (%zu, min %zu)\n",
  73                          intel_uc_fw_type_repr(uc_fw->type),
  74                          fw->size, sizeof(struct uc_css_header));
  75                 err = -ENODATA;
  76                 goto fail;
  77         }
  78
  79         css = (struct uc_css_header *)fw->data;
  80
  81         /* Firmware bits always start from header */
  82         uc_fw->header_offset = 0;
  83         uc_fw->header_size = (css->header_size_dw - css->modulus_size_dw -
  84                               css->key_size_dw - css->exponent_size_dw) *
  85                              sizeof(u32);
  86
  87         if (uc_fw->header_size != sizeof(struct uc_css_header)) {
  88                 DRM_WARN("%s: Mismatched firmware header definition\n",
  89                          intel_uc_fw_type_repr(uc_fw->type));
  90                 err = -ENOEXEC;
  91                 goto fail;
  92         }
  93
  94         /* then, uCode */
  95         uc_fw->ucode_offset = uc_fw->header_offset + uc_fw->header_size;
  96         uc_fw->ucode_size = (css->size_dw - css->header_size_dw) * sizeof(u32);
  97
  98         /* Header and uCode will be loaded to WOPCM */
  99         size = uc_fw->header_size + uc_fw->ucode_size;
 100         if (size > intel_guc_wopcm_size(dev_priv)) {
 101                 DRM_WARN("%s: Firmware is too large to fit in WOPCM\n",
 102                          intel_uc_fw_type_repr(uc_fw->type));
 103                 err = -E2BIG;
 104                 goto fail;
 105         }
 106
 107         /* now RSA */
 108         if (css->key_size_dw != UOS_RSA_SCRATCH_COUNT) {
 109                 DRM_WARN("%s: Mismatched firmware RSA key size (%u)\n",
 110                          intel_uc_fw_type_repr(uc_fw->type), css->key_size_dw);
 111                 err = -ENOEXEC;
 112                 goto fail;
 113         }
 114         uc_fw->rsa_offset = uc_fw->ucode_offset + uc_fw->ucode_size;
 115         uc_fw->rsa_size = css->key_size_dw * sizeof(u32);
 116
 117         /* At least, it should have header, uCode and RSA. Size of all three. */
 118         size = uc_fw->header_size + uc_fw->ucode_size + uc_fw->rsa_size;
 119         if (fw->size < size) {
 120                 DRM_WARN("%s: Truncated firmware (%zu, expected %zu)\n",
 121                          intel_uc_fw_type_repr(uc_fw->type), fw->size, size);
 122                 err = -ENOEXEC;
 123                 goto fail;
 124         }
 125
 126         /*
 127          * The GuC firmware image has the version number embedded at a
 128          * well-known offset within the firmware blob; note that major / minor
 129          * version are TWO bytes each (i.e. u16), although all pointers and
 130          * offsets are defined in terms of bytes (u8).
 131          */
 132         switch (uc_fw->type) {
 133         case INTEL_UC_FW_TYPE_GUC:
 134                 uc_fw->major_ver_found = css->guc.sw_version >> 16;
 135                 uc_fw->minor_ver_found = css->guc.sw_version & 0xFFFF;
 136                 break;
 137
 138         case INTEL_UC_FW_TYPE_HUC:
 139                 uc_fw->major_ver_found = css->huc.sw_version >> 16;
 140                 uc_fw->minor_ver_found = css->huc.sw_version & 0xFFFF;
 141                 break;
 142
 143         default:
 144                 MISSING_CASE(uc_fw->type);
 145                 break;
 146         }
 147
 148         DRM_DEBUG_DRIVER("%s fw version %u.%u (wanted %u.%u)\n",
 149                          intel_uc_fw_type_repr(uc_fw->type),
 150                          uc_fw->major_ver_found, uc_fw->minor_ver_found,
 151                          uc_fw->major_ver_wanted, uc_fw->minor_ver_wanted);
 152
 153         if (uc_fw->major_ver_wanted == 0 && uc_fw->minor_ver_wanted == 0) {
 154                 DRM_NOTE("%s: Skipping firmware version check\n",
 155                          intel_uc_fw_type_repr(uc_fw->type));
 156         } else if (uc_fw->major_ver_found != uc_fw->major_ver_wanted ||
 157                    uc_fw->minor_ver_found < uc_fw->minor_ver_wanted) {
 158                 DRM_NOTE("%s: Wrong firmware version (%u.%u, required %u.%u)\n",
 159                          intel_uc_fw_type_repr(uc_fw->type),
 160                          uc_fw->major_ver_found, uc_fw->minor_ver_found,
 161                          uc_fw->major_ver_wanted, uc_fw->minor_ver_wanted);
 162                 err = -ENOEXEC;
 163                 goto fail;
 164         }
 165
 166         obj = i915_gem_object_create_from_data(dev_priv, fw->data, fw->size);
 167         if (IS_ERR(obj)) {
 168                 err = PTR_ERR(obj);
 169                 DRM_DEBUG_DRIVER("%s fw object_create err=%d\n",
 170                                  intel_uc_fw_type_repr(uc_fw->type), err);
 171                 goto fail;
 172         }
 173
 174         uc_fw->obj = obj;
 175         uc_fw->size = fw->size;
 176         uc_fw->fetch_status = INTEL_UC_FIRMWARE_SUCCESS;
 177         DRM_DEBUG_DRIVER("%s fw fetch %s\n",
 178                          intel_uc_fw_type_repr(uc_fw->type),
 179                          intel_uc_fw_status_repr(uc_fw->fetch_status));
 180
 181         release_firmware(fw);
 182         return;
 183
 184 fail:
 185         uc_fw->fetch_status = INTEL_UC_FIRMWARE_FAIL;
 186         DRM_DEBUG_DRIVER("%s fw fetch %s\n",
 187                          intel_uc_fw_type_repr(uc_fw->type),
 188                          intel_uc_fw_status_repr(uc_fw->fetch_status));
 189
 190         DRM_WARN("%s: Failed to fetch firmware %s (error %d)\n",
 191                  intel_uc_fw_type_repr(uc_fw->type), uc_fw->path, err);
 192         DRM_INFO("%s: Firmware can be downloaded from %s\n",
 193                  intel_uc_fw_type_repr(uc_fw->type), INTEL_UC_FIRMWARE_URL);
 194
 195         release_firmware(fw);           /* OK even if fw is NULL */
 196 }
 197
 198 /**
 199  * intel_uc_fw_upload - load uC firmware using custom loader
 200  *
 201  * @uc_fw: uC firmware
 202  * @loader: custom uC firmware loader function
 203  *
 204  * Loads uC firmware using custom loader and updates internal flags.
 205  */
 206 int intel_uc_fw_upload(struct intel_uc_fw *uc_fw,
 207                        int (*xfer)(struct intel_uc_fw *uc_fw,
 208                                    struct i915_vma *vma))
 209 {
 210         struct i915_vma *vma;
 211         int err;
 212
 213         DRM_DEBUG_DRIVER("%s fw load %s\n",
 214                          intel_uc_fw_type_repr(uc_fw->type), uc_fw->path);
 215
 216         if (uc_fw->fetch_status != INTEL_UC_FIRMWARE_SUCCESS)
 217                 return -ENOEXEC;
 218
 219         uc_fw->load_status = INTEL_UC_FIRMWARE_PENDING;
 220         DRM_DEBUG_DRIVER("%s fw load %s\n",
 221                          intel_uc_fw_type_repr(uc_fw->type),
 222                          intel_uc_fw_status_repr(uc_fw->load_status));
 223
 224         /* Pin object with firmware */
 225         err = i915_gem_object_set_to_gtt_domain(uc_fw->obj, false);
 226         if (err) {
 227                 DRM_DEBUG_DRIVER("%s fw set-domain err=%d\n",
 228                                  intel_uc_fw_type_repr(uc_fw->type), err);
 229                 goto fail;
 230         }
 231
 232         vma = i915_gem_object_ggtt_pin(uc_fw->obj, NULL, 0, 0,
 233                                        PIN_OFFSET_BIAS | GUC_WOPCM_TOP);
 234         if (IS_ERR(vma)) {
 235                 err = PTR_ERR(vma);
 236                 DRM_DEBUG_DRIVER("%s fw ggtt-pin err=%d\n",
 237                                  intel_uc_fw_type_repr(uc_fw->type), err);
 238                 goto fail;
 239         }
 240
 241         /* Call custom loader */
 242         err = xfer(uc_fw, vma);
 243
 244         /*
 245          * We keep the object pages for reuse during resume. But we can unpin it
 246          * now that DMA has completed, so it doesn't continue to take up space.
 247          */
 248         i915_vma_unpin(vma);
 249
 250         if (err)
 251                 goto fail;
 252
 253         uc_fw->load_status = INTEL_UC_FIRMWARE_SUCCESS;
 254         DRM_DEBUG_DRIVER("%s fw load %s\n",
 255                          intel_uc_fw_type_repr(uc_fw->type),
 256                          intel_uc_fw_status_repr(uc_fw->load_status));
 257
 258         DRM_INFO("%s: Loaded firmware %s (version %u.%u)\n",
 259                  intel_uc_fw_type_repr(uc_fw->type),
 260                  uc_fw->path,
 261                  uc_fw->major_ver_found, uc_fw->minor_ver_found);
 262
 263         return 0;
 264
 265 fail:
 266         uc_fw->load_status = INTEL_UC_FIRMWARE_FAIL;
 267         DRM_DEBUG_DRIVER("%s fw load %s\n",
 268                          intel_uc_fw_type_repr(uc_fw->type),
 269                          intel_uc_fw_status_repr(uc_fw->load_status));
 270
 271         DRM_WARN("%s: Failed to load firmware %s (error %d)\n",
 272                  intel_uc_fw_type_repr(uc_fw->type), uc_fw->path, err);
 273
 274         return err;
 275 }
 276
 277 /**
 278  * intel_uc_fw_fini - cleanup uC firmware
 279  *
 280  * @uc_fw: uC firmware
 281  *
 282  * Cleans up uC firmware by releasing the firmware GEM obj.
 283  */
 284 void intel_uc_fw_fini(struct intel_uc_fw *uc_fw)
 285 {
 286         struct drm_i915_gem_object *obj;
 287
 288         obj = fetch_and_zero(&uc_fw->obj);
 289         if (obj)
 290                 i915_gem_object_put(obj);
 291
 292         uc_fw->fetch_status = INTEL_UC_FIRMWARE_NONE;
 293 }
 294
 295 /**
 296  * intel_uc_fw_dump - dump information about uC firmware
 297  * @uc_fw: uC firmware
 298  * @p: the &drm_printer
 299  *
 300  * Pretty printer for uC firmware.
 301  */
 302 void intel_uc_fw_dump(const struct intel_uc_fw *uc_fw, struct drm_printer *p)
 303 {
 304         drm_printf(p, "%s firmware: %s\n",
 305                    intel_uc_fw_type_repr(uc_fw->type), uc_fw->path);
 306         drm_printf(p, "\tstatus: fetch %s, load %s\n",
 307                    intel_uc_fw_status_repr(uc_fw->fetch_status),
 308                    intel_uc_fw_status_repr(uc_fw->load_status));
 309         drm_printf(p, "\tversion: wanted %u.%u, found %u.%u\n",
 310                    uc_fw->major_ver_wanted, uc_fw->minor_ver_wanted,
 311                    uc_fw->major_ver_found, uc_fw->minor_ver_found);
 312         drm_printf(p, "\theader: offset %u, size %u\n",
 313                    uc_fw->header_offset, uc_fw->header_size);
 314         drm_printf(p, "\tuCode: offset %u, size %u\n",
 315                    uc_fw->ucode_offset, uc_fw->ucode_size);
 316         drm_printf(p, "\tRSA: offset %u, size %u\n",
 317                    uc_fw->rsa_offset, uc_fw->rsa_size);
 318 }