1 /*
2  * Copyright 2008 Advanced Micro Devices, Inc.
3  * Copyright 2008 Red Hat Inc.
4  * Copyright 2009 Jerome Glisse.
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 shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22  * OTHER DEALINGS IN THE SOFTWARE.
23  *
24  * Authors: Dave Airlie
25  *          Alex Deucher
26  *          Jerome Glisse
27  */
28 #include <drm/drmP.h>
29 #include "amdgpu.h"
30 #include "atom.h"
31 
32 #include <linux/slab.h>
33 #include <linux/acpi.h>
34 /*
35  * BIOS.
36  */
37 
38 #define AMD_VBIOS_SIGNATURE " 761295520"
39 #define AMD_VBIOS_SIGNATURE_OFFSET 0x30
40 #define AMD_VBIOS_SIGNATURE_SIZE sizeof(AMD_VBIOS_SIGNATURE)
41 #define AMD_VBIOS_SIGNATURE_END (AMD_VBIOS_SIGNATURE_OFFSET + AMD_VBIOS_SIGNATURE_SIZE)
42 #define AMD_IS_VALID_VBIOS(p) ((p)[0] == 0x55 && (p)[1] == 0xAA)
43 #define AMD_VBIOS_LENGTH(p) ((p)[2] << 9)
44 
45 /* Check if current bios is an ATOM BIOS.
46  * Return true if it is ATOM BIOS. Otherwise, return false.
47  */
48 static bool check_atom_bios(uint8_t *bios, size_t size)
49 {
50 	uint16_t tmp, bios_header_start;
51 
52 	if (!bios || size < 0x49) {
53 		DRM_INFO("vbios mem is null or mem size is wrong\n");
54 		return false;
55 	}
56 
57 	if (!AMD_IS_VALID_VBIOS(bios)) {
58 		DRM_INFO("BIOS signature incorrect %x %x\n", bios[0], bios[1]);
59 		return false;
60 	}
61 
62 	tmp = bios[0x18] | (bios[0x19] << 8);
63 	if (bios[tmp + 0x14] != 0x0) {
64 		DRM_INFO("Not an x86 BIOS ROM\n");
65 		return false;
66 	}
67 
68 	bios_header_start = bios[0x48] | (bios[0x49] << 8);
69 	if (!bios_header_start) {
70 		DRM_INFO("Can't locate bios header\n");
71 		return false;
72 	}
73 
74 	tmp = bios_header_start + 4;
75 	if (size < tmp) {
76 		DRM_INFO("BIOS header is broken\n");
77 		return false;
78 	}
79 
80 	if (!memcmp(bios + tmp, "ATOM", 4) ||
81 	    !memcmp(bios + tmp, "MOTA", 4)) {
82 		DRM_DEBUG("ATOMBIOS detected\n");
83 		return true;
84 	}
85 
86 	return false;
87 }
88 
89 static bool is_atom_fw(uint8_t *bios)
90 {
91 	uint16_t bios_header_start = bios[0x48] | (bios[0x49] << 8);
92 	uint8_t frev = bios[bios_header_start + 2];
93 	uint8_t crev = bios[bios_header_start + 3];
94 
95 	if ((frev < 3) ||
96 	    ((frev == 3) && (crev < 3)))
97 		return false;
98 
99 	return true;
100 }
101 
102 /* If you boot an IGP board with a discrete card as the primary,
103  * the IGP rom is not accessible via the rom bar as the IGP rom is
104  * part of the system bios.  On boot, the system bios puts a
105  * copy of the igp rom at the start of vram if a discrete card is
106  * present.
107  */
108 static bool igp_read_bios_from_vram(struct amdgpu_device *adev)
109 {
110 	uint8_t __iomem *bios;
111 	resource_size_t vram_base;
112 	resource_size_t size = 256 * 1024; /* ??? */
113 
114 	if (!(adev->flags & AMD_IS_APU))
115 		if (amdgpu_need_post(adev))
116 			return false;
117 
118 	adev->bios = NULL;
119 	vram_base = pci_resource_start(adev->pdev, 0);
120 	bios = ioremap(vram_base, size);
121 	if (!bios) {
122 		return false;
123 	}
124 
125 	adev->bios = kmalloc(size, GFP_KERNEL);
126 	if (!adev->bios) {
127 		iounmap(bios);
128 		return false;
129 	}
130 	adev->bios_size = size;
131 	memcpy_fromio(adev->bios, bios, size);
132 	iounmap(bios);
133 
134 	if (!check_atom_bios(adev->bios, size)) {
135 		kfree(adev->bios);
136 		return false;
137 	}
138 
139 	return true;
140 }
141 
142 bool amdgpu_read_bios(struct amdgpu_device *adev)
143 {
144 	uint8_t __iomem *bios;
145 	size_t size;
146 
147 	adev->bios = NULL;
148 	/* XXX: some cards may return 0 for rom size? ddx has a workaround */
149 	bios = pci_map_rom(adev->pdev, &size);
150 	if (!bios) {
151 		return false;
152 	}
153 
154 	adev->bios = kzalloc(size, GFP_KERNEL);
155 	if (adev->bios == NULL) {
156 		pci_unmap_rom(adev->pdev, bios);
157 		return false;
158 	}
159 	adev->bios_size = size;
160 	memcpy_fromio(adev->bios, bios, size);
161 	pci_unmap_rom(adev->pdev, bios);
162 
163 	if (!check_atom_bios(adev->bios, size)) {
164 		kfree(adev->bios);
165 		return false;
166 	}
167 
168 	return true;
169 }
170 
171 static bool amdgpu_read_bios_from_rom(struct amdgpu_device *adev)
172 {
173 	u8 header[AMD_VBIOS_SIGNATURE_END+1] = {0};
174 	int len;
175 
176 	if (!adev->asic_funcs->read_bios_from_rom)
177 		return false;
178 
179 	/* validate VBIOS signature */
180 	if (amdgpu_asic_read_bios_from_rom(adev, &header[0], sizeof(header)) == false)
181 		return false;
182 	header[AMD_VBIOS_SIGNATURE_END] = 0;
183 
184 	if ((!AMD_IS_VALID_VBIOS(header)) ||
185 	    0 != memcmp((char *)&header[AMD_VBIOS_SIGNATURE_OFFSET],
186 			AMD_VBIOS_SIGNATURE,
187 			strlen(AMD_VBIOS_SIGNATURE)))
188 		return false;
189 
190 	/* valid vbios, go on */
191 	len = AMD_VBIOS_LENGTH(header);
192 	len = ALIGN(len, 4);
193 	adev->bios = kmalloc(len, GFP_KERNEL);
194 	if (!adev->bios) {
195 		DRM_ERROR("no memory to allocate for BIOS\n");
196 		return false;
197 	}
198 	adev->bios_size = len;
199 
200 	/* read complete BIOS */
201 	amdgpu_asic_read_bios_from_rom(adev, adev->bios, len);
202 
203 	if (!check_atom_bios(adev->bios, len)) {
204 		kfree(adev->bios);
205 		return false;
206 	}
207 
208 	return true;
209 }
210 
211 static bool amdgpu_read_platform_bios(struct amdgpu_device *adev)
212 {
213 	uint8_t __iomem *bios;
214 	size_t size;
215 
216 	adev->bios = NULL;
217 
218 	bios = pci_platform_rom(adev->pdev, &size);
219 	if (!bios) {
220 		return false;
221 	}
222 
223 	adev->bios = kzalloc(size, GFP_KERNEL);
224 	if (adev->bios == NULL)
225 		return false;
226 
227 	memcpy_fromio(adev->bios, bios, size);
228 
229 	if (!check_atom_bios(adev->bios, size)) {
230 		kfree(adev->bios);
231 		return false;
232 	}
233 
234 	adev->bios_size = size;
235 
236 	return true;
237 }
238 
239 #ifdef CONFIG_ACPI
240 /* ATRM is used to get the BIOS on the discrete cards in
241  * dual-gpu systems.
242  */
243 /* retrieve the ROM in 4k blocks */
244 #define ATRM_BIOS_PAGE 4096
245 /**
246  * amdgpu_atrm_call - fetch a chunk of the vbios
247  *
248  * @atrm_handle: acpi ATRM handle
249  * @bios: vbios image pointer
250  * @offset: offset of vbios image data to fetch
251  * @len: length of vbios image data to fetch
252  *
253  * Executes ATRM to fetch a chunk of the discrete
254  * vbios image on PX systems (all asics).
255  * Returns the length of the buffer fetched.
256  */
257 static int amdgpu_atrm_call(acpi_handle atrm_handle, uint8_t *bios,
258 			    int offset, int len)
259 {
260 	acpi_status status;
261 	union acpi_object atrm_arg_elements[2], *obj;
262 	struct acpi_object_list atrm_arg;
263 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
264 
265 	atrm_arg.count = 2;
266 	atrm_arg.pointer = &atrm_arg_elements[0];
267 
268 	atrm_arg_elements[0].type = ACPI_TYPE_INTEGER;
269 	atrm_arg_elements[0].integer.value = offset;
270 
271 	atrm_arg_elements[1].type = ACPI_TYPE_INTEGER;
272 	atrm_arg_elements[1].integer.value = len;
273 
274 	status = acpi_evaluate_object(atrm_handle, NULL, &atrm_arg, &buffer);
275 	if (ACPI_FAILURE(status)) {
276 		printk("failed to evaluate ATRM got %s\n", acpi_format_exception(status));
277 		return -ENODEV;
278 	}
279 
280 	obj = (union acpi_object *)buffer.pointer;
281 	memcpy(bios+offset, obj->buffer.pointer, obj->buffer.length);
282 	len = obj->buffer.length;
283 	kfree(buffer.pointer);
284 	return len;
285 }
286 
287 static bool amdgpu_atrm_get_bios(struct amdgpu_device *adev)
288 {
289 	int ret;
290 	int size = 256 * 1024;
291 	int i;
292 	struct pci_dev *pdev = NULL;
293 	acpi_handle dhandle, atrm_handle;
294 	acpi_status status;
295 	bool found = false;
296 
297 	/* ATRM is for the discrete card only */
298 	if (adev->flags & AMD_IS_APU)
299 		return false;
300 
301 	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
302 		dhandle = ACPI_HANDLE(&pdev->dev);
303 		if (!dhandle)
304 			continue;
305 
306 		status = acpi_get_handle(dhandle, "ATRM", &atrm_handle);
307 		if (!ACPI_FAILURE(status)) {
308 			found = true;
309 			break;
310 		}
311 	}
312 
313 	if (!found) {
314 		while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) {
315 			dhandle = ACPI_HANDLE(&pdev->dev);
316 			if (!dhandle)
317 				continue;
318 
319 			status = acpi_get_handle(dhandle, "ATRM", &atrm_handle);
320 			if (!ACPI_FAILURE(status)) {
321 				found = true;
322 				break;
323 			}
324 		}
325 	}
326 
327 	if (!found)
328 		return false;
329 
330 	adev->bios = kmalloc(size, GFP_KERNEL);
331 	if (!adev->bios) {
332 		DRM_ERROR("Unable to allocate bios\n");
333 		return false;
334 	}
335 
336 	for (i = 0; i < size / ATRM_BIOS_PAGE; i++) {
337 		ret = amdgpu_atrm_call(atrm_handle,
338 				       adev->bios,
339 				       (i * ATRM_BIOS_PAGE),
340 				       ATRM_BIOS_PAGE);
341 		if (ret < ATRM_BIOS_PAGE)
342 			break;
343 	}
344 
345 	if (!check_atom_bios(adev->bios, size)) {
346 		kfree(adev->bios);
347 		return false;
348 	}
349 	adev->bios_size = size;
350 	return true;
351 }
352 #else
353 static inline bool amdgpu_atrm_get_bios(struct amdgpu_device *adev)
354 {
355 	return false;
356 }
357 #endif
358 
359 static bool amdgpu_read_disabled_bios(struct amdgpu_device *adev)
360 {
361 	if (adev->flags & AMD_IS_APU)
362 		return igp_read_bios_from_vram(adev);
363 	else
364 		return amdgpu_asic_read_disabled_bios(adev);
365 }
366 
367 #ifdef CONFIG_ACPI
368 static bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev)
369 {
370 	struct acpi_table_header *hdr;
371 	acpi_size tbl_size;
372 	UEFI_ACPI_VFCT *vfct;
373 	unsigned offset;
374 
375 	if (!ACPI_SUCCESS(acpi_get_table("VFCT", 1, &hdr)))
376 		return false;
377 	tbl_size = hdr->length;
378 	if (tbl_size < sizeof(UEFI_ACPI_VFCT)) {
379 		DRM_ERROR("ACPI VFCT table present but broken (too short #1)\n");
380 		return false;
381 	}
382 
383 	vfct = (UEFI_ACPI_VFCT *)hdr;
384 	offset = vfct->VBIOSImageOffset;
385 
386 	while (offset < tbl_size) {
387 		GOP_VBIOS_CONTENT *vbios = (GOP_VBIOS_CONTENT *)((char *)hdr + offset);
388 		VFCT_IMAGE_HEADER *vhdr = &vbios->VbiosHeader;
389 
390 		offset += sizeof(VFCT_IMAGE_HEADER);
391 		if (offset > tbl_size) {
392 			DRM_ERROR("ACPI VFCT image header truncated\n");
393 			return false;
394 		}
395 
396 		offset += vhdr->ImageLength;
397 		if (offset > tbl_size) {
398 			DRM_ERROR("ACPI VFCT image truncated\n");
399 			return false;
400 		}
401 
402 		if (vhdr->ImageLength &&
403 		    vhdr->PCIBus == adev->pdev->bus->number &&
404 		    vhdr->PCIDevice == PCI_SLOT(adev->pdev->devfn) &&
405 		    vhdr->PCIFunction == PCI_FUNC(adev->pdev->devfn) &&
406 		    vhdr->VendorID == adev->pdev->vendor &&
407 		    vhdr->DeviceID == adev->pdev->device) {
408 			adev->bios = kmemdup(&vbios->VbiosContent,
409 					     vhdr->ImageLength,
410 					     GFP_KERNEL);
411 
412 			if (!check_atom_bios(adev->bios, vhdr->ImageLength)) {
413 				kfree(adev->bios);
414 				return false;
415 			}
416 			adev->bios_size = vhdr->ImageLength;
417 			return true;
418 		}
419 	}
420 
421 	DRM_ERROR("ACPI VFCT table present but broken (too short #2)\n");
422 	return false;
423 }
424 #else
425 static inline bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev)
426 {
427 	return false;
428 }
429 #endif
430 
431 bool amdgpu_get_bios(struct amdgpu_device *adev)
432 {
433 	if (amdgpu_atrm_get_bios(adev))
434 		goto success;
435 
436 	if (amdgpu_acpi_vfct_bios(adev))
437 		goto success;
438 
439 	if (igp_read_bios_from_vram(adev))
440 		goto success;
441 
442 	if (amdgpu_read_bios(adev))
443 		goto success;
444 
445 	if (amdgpu_read_bios_from_rom(adev))
446 		goto success;
447 
448 	if (amdgpu_read_disabled_bios(adev))
449 		goto success;
450 
451 	if (amdgpu_read_platform_bios(adev))
452 		goto success;
453 
454 	DRM_ERROR("Unable to locate a BIOS ROM\n");
455 	return false;
456 
457 success:
458 	adev->is_atom_fw = is_atom_fw(adev->bios);
459 	return true;
460 }
461