1 /* 2 * Copyright(c) 2011-2016 Intel 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 (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 FROM, 20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 * SOFTWARE. 22 * 23 * Authors: 24 * Zhi Wang <zhi.a.wang@intel.com> 25 * 26 * Contributors: 27 * Changbin Du <changbin.du@intel.com> 28 * 29 */ 30 31 #include <linux/firmware.h> 32 #include <linux/crc32.h> 33 #include <linux/vmalloc.h> 34 35 #include "i915_drv.h" 36 #include "gvt.h" 37 #include "i915_pvinfo.h" 38 39 #define FIRMWARE_VERSION (0x0) 40 41 struct gvt_firmware_header { 42 u64 magic; 43 u32 crc32; /* protect the data after this field */ 44 u32 version; 45 u64 cfg_space_size; 46 u64 cfg_space_offset; /* offset in the file */ 47 u64 mmio_size; 48 u64 mmio_offset; /* offset in the file */ 49 unsigned char data[]; 50 }; 51 52 #define dev_to_drm_minor(d) dev_get_drvdata((d)) 53 54 static BIN_ATTR_SIMPLE_ADMIN_RO(gvt_firmware); 55 56 static int expose_firmware_sysfs(struct intel_gvt *gvt) 57 { 58 struct intel_gvt_device_info *info = &gvt->device_info; 59 struct drm_i915_private *i915 = gvt->gt->i915; 60 struct pci_dev *pdev = to_pci_dev(i915->drm.dev); 61 struct gvt_firmware_header *h; 62 void *firmware; 63 void *p; 64 unsigned long size, crc32_start; 65 int ret; 66 67 size = offsetof(struct gvt_firmware_header, data) + info->mmio_size + info->cfg_space_size; 68 firmware = vzalloc(size); 69 if (!firmware) 70 return -ENOMEM; 71 72 h = firmware; 73 74 h->magic = VGT_MAGIC; 75 h->version = FIRMWARE_VERSION; 76 h->cfg_space_size = info->cfg_space_size; 77 h->cfg_space_offset = offsetof(struct gvt_firmware_header, data); 78 h->mmio_size = info->mmio_size; 79 h->mmio_offset = h->cfg_space_offset + h->cfg_space_size; 80 81 p = firmware + h->cfg_space_offset; 82 83 memcpy(gvt->firmware.cfg_space, i915->vgpu.initial_cfg_space, 84 info->cfg_space_size); 85 memcpy(p, gvt->firmware.cfg_space, info->cfg_space_size); 86 87 p = firmware + h->mmio_offset; 88 89 memcpy(gvt->firmware.mmio, i915->vgpu.initial_mmio, 90 info->mmio_size); 91 92 memcpy(p, gvt->firmware.mmio, info->mmio_size); 93 94 crc32_start = offsetof(struct gvt_firmware_header, version); 95 h->crc32 = crc32_le(0, firmware + crc32_start, size - crc32_start); 96 97 bin_attr_gvt_firmware.size = size; 98 bin_attr_gvt_firmware.private = firmware; 99 100 ret = device_create_bin_file(&pdev->dev, &bin_attr_gvt_firmware); 101 if (ret) { 102 vfree(firmware); 103 return ret; 104 } 105 return 0; 106 } 107 108 static void clean_firmware_sysfs(struct intel_gvt *gvt) 109 { 110 struct pci_dev *pdev = to_pci_dev(gvt->gt->i915->drm.dev); 111 112 device_remove_bin_file(&pdev->dev, &bin_attr_gvt_firmware); 113 vfree(bin_attr_gvt_firmware.private); 114 } 115 116 /** 117 * intel_gvt_free_firmware - free GVT firmware 118 * @gvt: intel gvt device 119 * 120 */ 121 void intel_gvt_free_firmware(struct intel_gvt *gvt) 122 { 123 if (!gvt->firmware.firmware_loaded) 124 clean_firmware_sysfs(gvt); 125 126 kfree(gvt->firmware.cfg_space); 127 vfree(gvt->firmware.mmio); 128 } 129 130 static int verify_firmware(struct intel_gvt *gvt, 131 const struct firmware *fw) 132 { 133 struct intel_gvt_device_info *info = &gvt->device_info; 134 struct pci_dev *pdev = to_pci_dev(gvt->gt->i915->drm.dev); 135 struct gvt_firmware_header *h; 136 unsigned long id, crc32_start; 137 const void *mem; 138 const char *item; 139 u64 file, request; 140 141 h = (struct gvt_firmware_header *)fw->data; 142 143 crc32_start = offsetofend(struct gvt_firmware_header, crc32); 144 mem = fw->data + crc32_start; 145 146 #define VERIFY(s, a, b) do { \ 147 item = (s); file = (u64)(a); request = (u64)(b); \ 148 if ((a) != (b)) \ 149 goto invalid_firmware; \ 150 } while (0) 151 152 VERIFY("magic number", h->magic, VGT_MAGIC); 153 VERIFY("version", h->version, FIRMWARE_VERSION); 154 VERIFY("crc32", h->crc32, crc32_le(0, mem, fw->size - crc32_start)); 155 VERIFY("cfg space size", h->cfg_space_size, info->cfg_space_size); 156 VERIFY("mmio size", h->mmio_size, info->mmio_size); 157 158 mem = (fw->data + h->cfg_space_offset); 159 160 id = *(u16 *)(mem + PCI_VENDOR_ID); 161 VERIFY("vendor id", id, pdev->vendor); 162 163 id = *(u16 *)(mem + PCI_DEVICE_ID); 164 VERIFY("device id", id, pdev->device); 165 166 id = *(u8 *)(mem + PCI_REVISION_ID); 167 VERIFY("revision id", id, pdev->revision); 168 169 #undef VERIFY 170 return 0; 171 172 invalid_firmware: 173 gvt_dbg_core("Invalid firmware: %s [file] 0x%llx [request] 0x%llx\n", 174 item, file, request); 175 return -EINVAL; 176 } 177 178 #define GVT_FIRMWARE_PATH "i915/gvt" 179 180 /** 181 * intel_gvt_load_firmware - load GVT firmware 182 * @gvt: intel gvt device 183 * 184 */ 185 int intel_gvt_load_firmware(struct intel_gvt *gvt) 186 { 187 struct intel_gvt_device_info *info = &gvt->device_info; 188 struct pci_dev *pdev = to_pci_dev(gvt->gt->i915->drm.dev); 189 struct intel_gvt_firmware *firmware = &gvt->firmware; 190 struct gvt_firmware_header *h; 191 const struct firmware *fw; 192 char *path; 193 void *mem; 194 int ret; 195 196 path = kmalloc(PATH_MAX, GFP_KERNEL); 197 if (!path) 198 return -ENOMEM; 199 200 mem = kmalloc(info->cfg_space_size, GFP_KERNEL); 201 if (!mem) { 202 kfree(path); 203 return -ENOMEM; 204 } 205 206 firmware->cfg_space = mem; 207 208 mem = vmalloc(info->mmio_size); 209 if (!mem) { 210 kfree(path); 211 kfree(firmware->cfg_space); 212 return -ENOMEM; 213 } 214 215 firmware->mmio = mem; 216 217 sprintf(path, "%s/vid_0x%04x_did_0x%04x_rid_0x%02x.golden_hw_state", 218 GVT_FIRMWARE_PATH, pdev->vendor, pdev->device, 219 pdev->revision); 220 221 gvt_dbg_core("request hw state firmware %s...\n", path); 222 223 ret = request_firmware(&fw, path, gvt->gt->i915->drm.dev); 224 kfree(path); 225 226 if (ret) 227 goto expose_firmware; 228 229 gvt_dbg_core("success.\n"); 230 231 ret = verify_firmware(gvt, fw); 232 if (ret) 233 goto out_free_fw; 234 235 gvt_dbg_core("verified.\n"); 236 237 h = (struct gvt_firmware_header *)fw->data; 238 239 memcpy(firmware->cfg_space, fw->data + h->cfg_space_offset, 240 h->cfg_space_size); 241 memcpy(firmware->mmio, fw->data + h->mmio_offset, 242 h->mmio_size); 243 244 release_firmware(fw); 245 firmware->firmware_loaded = true; 246 return 0; 247 248 out_free_fw: 249 release_firmware(fw); 250 expose_firmware: 251 expose_firmware_sysfs(gvt); 252 return 0; 253 } 254