1 /* $NetBSD: firmware.c,v 1.2 2021/12/18 23:45:31 riastradh Exp $ */ 2 3 /* 4 * Copyright(c) 2011-2016 Intel Corporation. All rights reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the next 14 * paragraph) shall be included in all copies or substantial portions of the 15 * Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 * SOFTWARE. 24 * 25 * Authors: 26 * Zhi Wang <zhi.a.wang (at) intel.com> 27 * 28 * Contributors: 29 * Changbin Du <changbin.du (at) intel.com> 30 * 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: firmware.c,v 1.2 2021/12/18 23:45:31 riastradh Exp $"); 35 36 #include <linux/firmware.h> 37 #include <linux/crc32.h> 38 39 #include "i915_drv.h" 40 #include "gvt.h" 41 #include "i915_pvinfo.h" 42 43 #define FIRMWARE_VERSION (0x0) 44 45 struct gvt_firmware_header { 46 u64 magic; 47 u32 crc32; /* protect the data after this field */ 48 u32 version; 49 u64 cfg_space_size; 50 u64 cfg_space_offset; /* offset in the file */ 51 u64 mmio_size; 52 u64 mmio_offset; /* offset in the file */ 53 unsigned char data[1]; 54 }; 55 56 #define dev_to_drm_minor(d) dev_get_drvdata((d)) 57 58 static ssize_t 59 gvt_firmware_read(struct file *filp, struct kobject *kobj, 60 struct bin_attribute *attr, char *buf, 61 loff_t offset, size_t count) 62 { 63 memcpy(buf, attr->private + offset, count); 64 return count; 65 } 66 67 static struct bin_attribute firmware_attr = { 68 .attr = {.name = "gvt_firmware", .mode = (S_IRUSR)}, 69 .read = gvt_firmware_read, 70 .write = NULL, 71 .mmap = NULL, 72 }; 73 74 static int mmio_snapshot_handler(struct intel_gvt *gvt, u32 offset, void *data) 75 { 76 struct drm_i915_private *i915 = gvt->dev_priv; 77 78 *(u32 *)(data + offset) = intel_uncore_read_notrace(&i915->uncore, 79 _MMIO(offset)); 80 return 0; 81 } 82 83 static int expose_firmware_sysfs(struct intel_gvt *gvt) 84 { 85 struct intel_gvt_device_info *info = &gvt->device_info; 86 struct pci_dev *pdev = gvt->dev_priv->drm.pdev; 87 struct gvt_firmware_header *h; 88 void *firmware; 89 void *p; 90 unsigned long size, crc32_start; 91 int i, ret; 92 93 size = sizeof(*h) + info->mmio_size + info->cfg_space_size; 94 firmware = vzalloc(size); 95 if (!firmware) 96 return -ENOMEM; 97 98 h = firmware; 99 100 h->magic = VGT_MAGIC; 101 h->version = FIRMWARE_VERSION; 102 h->cfg_space_size = info->cfg_space_size; 103 h->cfg_space_offset = offsetof(struct gvt_firmware_header, data); 104 h->mmio_size = info->mmio_size; 105 h->mmio_offset = h->cfg_space_offset + h->cfg_space_size; 106 107 p = firmware + h->cfg_space_offset; 108 109 for (i = 0; i < h->cfg_space_size; i += 4) 110 pci_read_config_dword(pdev, i, p + i); 111 112 memcpy(gvt->firmware.cfg_space, p, info->cfg_space_size); 113 114 p = firmware + h->mmio_offset; 115 116 /* Take a snapshot of hw mmio registers. */ 117 intel_gvt_for_each_tracked_mmio(gvt, mmio_snapshot_handler, p); 118 119 memcpy(gvt->firmware.mmio, p, info->mmio_size); 120 121 crc32_start = offsetof(struct gvt_firmware_header, crc32) + 4; 122 h->crc32 = crc32_le(0, firmware + crc32_start, size - crc32_start); 123 124 firmware_attr.size = size; 125 firmware_attr.private = firmware; 126 127 ret = device_create_bin_file(&pdev->dev, &firmware_attr); 128 if (ret) { 129 vfree(firmware); 130 return ret; 131 } 132 return 0; 133 } 134 135 static void clean_firmware_sysfs(struct intel_gvt *gvt) 136 { 137 struct pci_dev *pdev = gvt->dev_priv->drm.pdev; 138 139 device_remove_bin_file(&pdev->dev, &firmware_attr); 140 vfree(firmware_attr.private); 141 } 142 143 /** 144 * intel_gvt_free_firmware - free GVT firmware 145 * @gvt: intel gvt device 146 * 147 */ 148 void intel_gvt_free_firmware(struct intel_gvt *gvt) 149 { 150 if (!gvt->firmware.firmware_loaded) 151 clean_firmware_sysfs(gvt); 152 153 kfree(gvt->firmware.cfg_space); 154 vfree(gvt->firmware.mmio); 155 } 156 157 static int verify_firmware(struct intel_gvt *gvt, 158 const struct firmware *fw) 159 { 160 struct intel_gvt_device_info *info = &gvt->device_info; 161 struct drm_i915_private *dev_priv = gvt->dev_priv; 162 struct pci_dev *pdev = dev_priv->drm.pdev; 163 struct gvt_firmware_header *h; 164 unsigned long id, crc32_start; 165 const void *mem; 166 const char *item; 167 u64 file, request; 168 169 h = (struct gvt_firmware_header *)fw->data; 170 171 crc32_start = offsetofend(struct gvt_firmware_header, crc32); 172 mem = fw->data + crc32_start; 173 174 #define VERIFY(s, a, b) do { \ 175 item = (s); file = (u64)(a); request = (u64)(b); \ 176 if ((a) != (b)) \ 177 goto invalid_firmware; \ 178 } while (0) 179 180 VERIFY("magic number", h->magic, VGT_MAGIC); 181 VERIFY("version", h->version, FIRMWARE_VERSION); 182 VERIFY("crc32", h->crc32, crc32_le(0, mem, fw->size - crc32_start)); 183 VERIFY("cfg space size", h->cfg_space_size, info->cfg_space_size); 184 VERIFY("mmio size", h->mmio_size, info->mmio_size); 185 186 mem = (fw->data + h->cfg_space_offset); 187 188 id = *(u16 *)(mem + PCI_VENDOR_ID); 189 VERIFY("vender id", id, pdev->vendor); 190 191 id = *(u16 *)(mem + PCI_DEVICE_ID); 192 VERIFY("device id", id, pdev->device); 193 194 id = *(u8 *)(mem + PCI_REVISION_ID); 195 VERIFY("revision id", id, pdev->revision); 196 197 #undef VERIFY 198 return 0; 199 200 invalid_firmware: 201 gvt_dbg_core("Invalid firmware: %s [file] 0x%llx [request] 0x%llx\n", 202 item, file, request); 203 return -EINVAL; 204 } 205 206 #define GVT_FIRMWARE_PATH "i915/gvt" 207 208 /** 209 * intel_gvt_load_firmware - load GVT firmware 210 * @gvt: intel gvt device 211 * 212 */ 213 int intel_gvt_load_firmware(struct intel_gvt *gvt) 214 { 215 struct intel_gvt_device_info *info = &gvt->device_info; 216 struct drm_i915_private *dev_priv = gvt->dev_priv; 217 struct pci_dev *pdev = dev_priv->drm.pdev; 218 struct intel_gvt_firmware *firmware = &gvt->firmware; 219 struct gvt_firmware_header *h; 220 const struct firmware *fw; 221 char *path; 222 void *mem; 223 int ret; 224 225 path = kmalloc(PATH_MAX, GFP_KERNEL); 226 if (!path) 227 return -ENOMEM; 228 229 mem = kmalloc(info->cfg_space_size, GFP_KERNEL); 230 if (!mem) { 231 kfree(path); 232 return -ENOMEM; 233 } 234 235 firmware->cfg_space = mem; 236 237 mem = vmalloc(info->mmio_size); 238 if (!mem) { 239 kfree(path); 240 kfree(firmware->cfg_space); 241 return -ENOMEM; 242 } 243 244 firmware->mmio = mem; 245 246 sprintf(path, "%s/vid_0x%04x_did_0x%04x_rid_0x%02x.golden_hw_state", 247 GVT_FIRMWARE_PATH, pdev->vendor, pdev->device, 248 pdev->revision); 249 250 gvt_dbg_core("request hw state firmware %s...\n", path); 251 252 ret = request_firmware(&fw, path, &dev_priv->drm.pdev->dev); 253 kfree(path); 254 255 if (ret) 256 goto expose_firmware; 257 258 gvt_dbg_core("success.\n"); 259 260 ret = verify_firmware(gvt, fw); 261 if (ret) 262 goto out_free_fw; 263 264 gvt_dbg_core("verified.\n"); 265 266 h = (struct gvt_firmware_header *)fw->data; 267 268 memcpy(firmware->cfg_space, fw->data + h->cfg_space_offset, 269 h->cfg_space_size); 270 memcpy(firmware->mmio, fw->data + h->mmio_offset, 271 h->mmio_size); 272 273 release_firmware(fw); 274 firmware->firmware_loaded = true; 275 return 0; 276 277 out_free_fw: 278 release_firmware(fw); 279 expose_firmware: 280 expose_firmware_sysfs(gvt); 281 return 0; 282 } 283
Indexes created Wed Sep 24 05:09:52 GMT 2025