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
 41struct 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
 54static BIN_ATTR_SIMPLE_ADMIN_RO(gvt_firmware);
 55
 56static 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
108static 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 */
121void 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
130static 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
172invalid_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 */
185int 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
248out_free_fw:
249	release_firmware(fw);
250expose_firmware:
251	expose_firmware_sysfs(gvt);
252	return 0;
253}