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 | |
29 | #include "amdgpu.h" |
30 | #include "atom.h" |
31 | |
32 | #include <linux/device.h> |
33 | #include <linux/pci.h> |
34 | #include <linux/slab.h> |
35 | #include <linux/acpi.h> |
36 | /* |
37 | * BIOS. |
38 | */ |
39 | |
40 | #define AMD_VBIOS_SIGNATURE " 761295520" |
41 | #define AMD_VBIOS_SIGNATURE_OFFSET 0x30 |
42 | #define AMD_VBIOS_SIGNATURE_SIZE sizeof(AMD_VBIOS_SIGNATURE) |
43 | #define AMD_VBIOS_SIGNATURE_END (AMD_VBIOS_SIGNATURE_OFFSET + AMD_VBIOS_SIGNATURE_SIZE) |
44 | #define AMD_IS_VALID_VBIOS(p) ((p)[0] == 0x55 && (p)[1] == 0xAA) |
45 | #define AMD_VBIOS_LENGTH(p) ((p)[2] << 9) |
46 | |
47 | /* Check if current bios is an ATOM BIOS. |
48 | * Return true if it is ATOM BIOS. Otherwise, return false. |
49 | */ |
50 | static bool check_atom_bios(uint8_t *bios, size_t size) |
51 | { |
52 | uint16_t tmp, ; |
53 | |
54 | if (!bios || size < 0x49) { |
55 | DRM_INFO("vbios mem is null or mem size is wrong\n" ); |
56 | return false; |
57 | } |
58 | |
59 | if (!AMD_IS_VALID_VBIOS(bios)) { |
60 | DRM_INFO("BIOS signature incorrect %x %x\n" , bios[0], bios[1]); |
61 | return false; |
62 | } |
63 | |
64 | bios_header_start = bios[0x48] | (bios[0x49] << 8); |
65 | if (!bios_header_start) { |
66 | DRM_INFO("Can't locate bios header\n" ); |
67 | return false; |
68 | } |
69 | |
70 | tmp = bios_header_start + 4; |
71 | if (size < tmp) { |
72 | DRM_INFO("BIOS header is broken\n" ); |
73 | return false; |
74 | } |
75 | |
76 | if (!memcmp(p: bios + tmp, q: "ATOM" , size: 4) || |
77 | !memcmp(p: bios + tmp, q: "MOTA" , size: 4)) { |
78 | DRM_DEBUG("ATOMBIOS detected\n" ); |
79 | return true; |
80 | } |
81 | |
82 | return false; |
83 | } |
84 | |
85 | /* If you boot an IGP board with a discrete card as the primary, |
86 | * the IGP rom is not accessible via the rom bar as the IGP rom is |
87 | * part of the system bios. On boot, the system bios puts a |
88 | * copy of the igp rom at the start of vram if a discrete card is |
89 | * present. |
90 | */ |
91 | static bool igp_read_bios_from_vram(struct amdgpu_device *adev) |
92 | { |
93 | uint8_t __iomem *bios; |
94 | resource_size_t vram_base; |
95 | resource_size_t size = 256 * 1024; /* ??? */ |
96 | |
97 | if (!(adev->flags & AMD_IS_APU)) |
98 | if (amdgpu_device_need_post(adev)) |
99 | return false; |
100 | |
101 | /* FB BAR not enabled */ |
102 | if (pci_resource_len(adev->pdev, 0) == 0) |
103 | return false; |
104 | |
105 | adev->bios = NULL; |
106 | vram_base = pci_resource_start(adev->pdev, 0); |
107 | bios = ioremap_wc(offset: vram_base, size); |
108 | if (!bios) |
109 | return false; |
110 | |
111 | adev->bios = kmalloc(size, GFP_KERNEL); |
112 | if (!adev->bios) { |
113 | iounmap(addr: bios); |
114 | return false; |
115 | } |
116 | adev->bios_size = size; |
117 | memcpy_fromio(adev->bios, bios, size); |
118 | iounmap(addr: bios); |
119 | |
120 | if (!check_atom_bios(bios: adev->bios, size)) { |
121 | kfree(objp: adev->bios); |
122 | return false; |
123 | } |
124 | |
125 | return true; |
126 | } |
127 | |
128 | bool amdgpu_read_bios(struct amdgpu_device *adev) |
129 | { |
130 | uint8_t __iomem *bios; |
131 | size_t size; |
132 | |
133 | adev->bios = NULL; |
134 | /* XXX: some cards may return 0 for rom size? ddx has a workaround */ |
135 | bios = pci_map_rom(pdev: adev->pdev, size: &size); |
136 | if (!bios) |
137 | return false; |
138 | |
139 | adev->bios = kzalloc(size, GFP_KERNEL); |
140 | if (adev->bios == NULL) { |
141 | pci_unmap_rom(pdev: adev->pdev, rom: bios); |
142 | return false; |
143 | } |
144 | adev->bios_size = size; |
145 | memcpy_fromio(adev->bios, bios, size); |
146 | pci_unmap_rom(pdev: adev->pdev, rom: bios); |
147 | |
148 | if (!check_atom_bios(bios: adev->bios, size)) { |
149 | kfree(objp: adev->bios); |
150 | return false; |
151 | } |
152 | |
153 | return true; |
154 | } |
155 | |
156 | static bool amdgpu_read_bios_from_rom(struct amdgpu_device *adev) |
157 | { |
158 | u8 [AMD_VBIOS_SIGNATURE_END+1] = {0}; |
159 | int len; |
160 | |
161 | if (!adev->asic_funcs || !adev->asic_funcs->read_bios_from_rom) |
162 | return false; |
163 | |
164 | /* validate VBIOS signature */ |
165 | if (amdgpu_asic_read_bios_from_rom(adev, &header[0], sizeof(header)) == false) |
166 | return false; |
167 | header[AMD_VBIOS_SIGNATURE_END] = 0; |
168 | |
169 | if ((!AMD_IS_VALID_VBIOS(header)) || |
170 | memcmp(p: (char *)&header[AMD_VBIOS_SIGNATURE_OFFSET], |
171 | AMD_VBIOS_SIGNATURE, |
172 | strlen(AMD_VBIOS_SIGNATURE)) != 0) |
173 | return false; |
174 | |
175 | /* valid vbios, go on */ |
176 | len = AMD_VBIOS_LENGTH(header); |
177 | len = ALIGN(len, 4); |
178 | adev->bios = kmalloc(size: len, GFP_KERNEL); |
179 | if (!adev->bios) { |
180 | DRM_ERROR("no memory to allocate for BIOS\n" ); |
181 | return false; |
182 | } |
183 | adev->bios_size = len; |
184 | |
185 | /* read complete BIOS */ |
186 | amdgpu_asic_read_bios_from_rom(adev, adev->bios, len); |
187 | |
188 | if (!check_atom_bios(bios: adev->bios, size: len)) { |
189 | kfree(objp: adev->bios); |
190 | return false; |
191 | } |
192 | |
193 | return true; |
194 | } |
195 | |
196 | static bool amdgpu_read_platform_bios(struct amdgpu_device *adev) |
197 | { |
198 | phys_addr_t rom = adev->pdev->rom; |
199 | size_t romlen = adev->pdev->romlen; |
200 | void __iomem *bios; |
201 | |
202 | adev->bios = NULL; |
203 | |
204 | if (!rom || romlen == 0) |
205 | return false; |
206 | |
207 | adev->bios = kzalloc(size: romlen, GFP_KERNEL); |
208 | if (!adev->bios) |
209 | return false; |
210 | |
211 | bios = ioremap(offset: rom, size: romlen); |
212 | if (!bios) |
213 | goto free_bios; |
214 | |
215 | memcpy_fromio(adev->bios, bios, romlen); |
216 | iounmap(addr: bios); |
217 | |
218 | if (!check_atom_bios(bios: adev->bios, size: romlen)) |
219 | goto free_bios; |
220 | |
221 | adev->bios_size = romlen; |
222 | |
223 | return true; |
224 | free_bios: |
225 | kfree(objp: adev->bios); |
226 | return false; |
227 | } |
228 | |
229 | #ifdef CONFIG_ACPI |
230 | /* ATRM is used to get the BIOS on the discrete cards in |
231 | * dual-gpu systems. |
232 | */ |
233 | /* retrieve the ROM in 4k blocks */ |
234 | #define ATRM_BIOS_PAGE 4096 |
235 | /** |
236 | * amdgpu_atrm_call - fetch a chunk of the vbios |
237 | * |
238 | * @atrm_handle: acpi ATRM handle |
239 | * @bios: vbios image pointer |
240 | * @offset: offset of vbios image data to fetch |
241 | * @len: length of vbios image data to fetch |
242 | * |
243 | * Executes ATRM to fetch a chunk of the discrete |
244 | * vbios image on PX systems (all asics). |
245 | * Returns the length of the buffer fetched. |
246 | */ |
247 | static int amdgpu_atrm_call(acpi_handle atrm_handle, uint8_t *bios, |
248 | int offset, int len) |
249 | { |
250 | acpi_status status; |
251 | union acpi_object atrm_arg_elements[2], *obj; |
252 | struct acpi_object_list atrm_arg; |
253 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL}; |
254 | |
255 | atrm_arg.count = 2; |
256 | atrm_arg.pointer = &atrm_arg_elements[0]; |
257 | |
258 | atrm_arg_elements[0].type = ACPI_TYPE_INTEGER; |
259 | atrm_arg_elements[0].integer.value = offset; |
260 | |
261 | atrm_arg_elements[1].type = ACPI_TYPE_INTEGER; |
262 | atrm_arg_elements[1].integer.value = len; |
263 | |
264 | status = acpi_evaluate_object(object: atrm_handle, NULL, parameter_objects: &atrm_arg, return_object_buffer: &buffer); |
265 | if (ACPI_FAILURE(status)) { |
266 | DRM_ERROR("failed to evaluate ATRM got %s\n" , acpi_format_exception(status)); |
267 | return -ENODEV; |
268 | } |
269 | |
270 | obj = (union acpi_object *)buffer.pointer; |
271 | memcpy(bios+offset, obj->buffer.pointer, obj->buffer.length); |
272 | len = obj->buffer.length; |
273 | kfree(objp: buffer.pointer); |
274 | return len; |
275 | } |
276 | |
277 | static bool amdgpu_atrm_get_bios(struct amdgpu_device *adev) |
278 | { |
279 | int ret; |
280 | int size = 256 * 1024; |
281 | int i; |
282 | struct pci_dev *pdev = NULL; |
283 | acpi_handle dhandle, atrm_handle; |
284 | acpi_status status; |
285 | bool found = false; |
286 | |
287 | /* ATRM is for the discrete card only */ |
288 | if (adev->flags & AMD_IS_APU) |
289 | return false; |
290 | |
291 | /* ATRM is for on-platform devices only */ |
292 | if (dev_is_removable(dev: &adev->pdev->dev)) |
293 | return false; |
294 | |
295 | while ((pdev = pci_get_base_class(PCI_BASE_CLASS_DISPLAY, from: pdev))) { |
296 | if ((pdev->class != PCI_CLASS_DISPLAY_VGA << 8) && |
297 | (pdev->class != PCI_CLASS_DISPLAY_OTHER << 8)) |
298 | continue; |
299 | |
300 | dhandle = ACPI_HANDLE(&pdev->dev); |
301 | if (!dhandle) |
302 | continue; |
303 | |
304 | status = acpi_get_handle(parent: dhandle, pathname: "ATRM" , ret_handle: &atrm_handle); |
305 | if (ACPI_SUCCESS(status)) { |
306 | found = true; |
307 | break; |
308 | } |
309 | } |
310 | |
311 | if (!found) |
312 | return false; |
313 | pci_dev_put(dev: pdev); |
314 | |
315 | adev->bios = kmalloc(size, GFP_KERNEL); |
316 | if (!adev->bios) { |
317 | dev_err(adev->dev, "Unable to allocate bios\n" ); |
318 | return false; |
319 | } |
320 | |
321 | for (i = 0; i < size / ATRM_BIOS_PAGE; i++) { |
322 | ret = amdgpu_atrm_call(atrm_handle, |
323 | bios: adev->bios, |
324 | offset: (i * ATRM_BIOS_PAGE), |
325 | ATRM_BIOS_PAGE); |
326 | if (ret < ATRM_BIOS_PAGE) |
327 | break; |
328 | } |
329 | |
330 | if (!check_atom_bios(bios: adev->bios, size)) { |
331 | kfree(objp: adev->bios); |
332 | return false; |
333 | } |
334 | adev->bios_size = size; |
335 | return true; |
336 | } |
337 | #else |
338 | static inline bool amdgpu_atrm_get_bios(struct amdgpu_device *adev) |
339 | { |
340 | return false; |
341 | } |
342 | #endif |
343 | |
344 | static bool amdgpu_read_disabled_bios(struct amdgpu_device *adev) |
345 | { |
346 | if (adev->flags & AMD_IS_APU) |
347 | return igp_read_bios_from_vram(adev); |
348 | else |
349 | return (!adev->asic_funcs || !adev->asic_funcs->read_disabled_bios) ? |
350 | false : amdgpu_asic_read_disabled_bios(adev); |
351 | } |
352 | |
353 | #ifdef CONFIG_ACPI |
354 | static bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev) |
355 | { |
356 | struct acpi_table_header *hdr; |
357 | acpi_size tbl_size; |
358 | UEFI_ACPI_VFCT *vfct; |
359 | unsigned int offset; |
360 | |
361 | if (!ACPI_SUCCESS(acpi_get_table("VFCT" , 1, &hdr))) |
362 | return false; |
363 | tbl_size = hdr->length; |
364 | if (tbl_size < sizeof(UEFI_ACPI_VFCT)) { |
365 | dev_info(adev->dev, "ACPI VFCT table present but broken (too short #1),skipping\n" ); |
366 | return false; |
367 | } |
368 | |
369 | vfct = (UEFI_ACPI_VFCT *)hdr; |
370 | offset = vfct->VBIOSImageOffset; |
371 | |
372 | while (offset < tbl_size) { |
373 | GOP_VBIOS_CONTENT *vbios = (GOP_VBIOS_CONTENT *)((char *)hdr + offset); |
374 | VFCT_IMAGE_HEADER *vhdr = &vbios->VbiosHeader; |
375 | |
376 | offset += sizeof(VFCT_IMAGE_HEADER); |
377 | if (offset > tbl_size) { |
378 | dev_info(adev->dev, "ACPI VFCT image header truncated,skipping\n" ); |
379 | return false; |
380 | } |
381 | |
382 | offset += vhdr->ImageLength; |
383 | if (offset > tbl_size) { |
384 | dev_info(adev->dev, "ACPI VFCT image truncated,skipping\n" ); |
385 | return false; |
386 | } |
387 | |
388 | if (vhdr->ImageLength && |
389 | vhdr->PCIBus == adev->pdev->bus->number && |
390 | vhdr->PCIDevice == PCI_SLOT(adev->pdev->devfn) && |
391 | vhdr->PCIFunction == PCI_FUNC(adev->pdev->devfn) && |
392 | vhdr->VendorID == adev->pdev->vendor && |
393 | vhdr->DeviceID == adev->pdev->device) { |
394 | adev->bios = kmemdup(p: &vbios->VbiosContent, |
395 | size: vhdr->ImageLength, |
396 | GFP_KERNEL); |
397 | |
398 | if (!check_atom_bios(bios: adev->bios, size: vhdr->ImageLength)) { |
399 | kfree(objp: adev->bios); |
400 | return false; |
401 | } |
402 | adev->bios_size = vhdr->ImageLength; |
403 | return true; |
404 | } |
405 | } |
406 | |
407 | dev_info(adev->dev, "ACPI VFCT table present but broken (too short #2),skipping\n" ); |
408 | return false; |
409 | } |
410 | #else |
411 | static inline bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev) |
412 | { |
413 | return false; |
414 | } |
415 | #endif |
416 | |
417 | bool amdgpu_get_bios(struct amdgpu_device *adev) |
418 | { |
419 | if (amdgpu_atrm_get_bios(adev)) { |
420 | dev_info(adev->dev, "Fetched VBIOS from ATRM\n" ); |
421 | goto success; |
422 | } |
423 | |
424 | if (amdgpu_acpi_vfct_bios(adev)) { |
425 | dev_info(adev->dev, "Fetched VBIOS from VFCT\n" ); |
426 | goto success; |
427 | } |
428 | |
429 | if (igp_read_bios_from_vram(adev)) { |
430 | dev_info(adev->dev, "Fetched VBIOS from VRAM BAR\n" ); |
431 | goto success; |
432 | } |
433 | |
434 | if (amdgpu_read_bios(adev)) { |
435 | dev_info(adev->dev, "Fetched VBIOS from ROM BAR\n" ); |
436 | goto success; |
437 | } |
438 | |
439 | if (amdgpu_read_bios_from_rom(adev)) { |
440 | dev_info(adev->dev, "Fetched VBIOS from ROM\n" ); |
441 | goto success; |
442 | } |
443 | |
444 | if (amdgpu_read_disabled_bios(adev)) { |
445 | dev_info(adev->dev, "Fetched VBIOS from disabled ROM BAR\n" ); |
446 | goto success; |
447 | } |
448 | |
449 | if (amdgpu_read_platform_bios(adev)) { |
450 | dev_info(adev->dev, "Fetched VBIOS from platform\n" ); |
451 | goto success; |
452 | } |
453 | |
454 | dev_err(adev->dev, "Unable to locate a BIOS ROM\n" ); |
455 | return false; |
456 | |
457 | success: |
458 | adev->is_atom_fw = adev->asic_type >= CHIP_VEGA10; |
459 | return true; |
460 | } |
461 | |
462 | /* helper function for soc15 and onwards to read bios from rom */ |
463 | bool amdgpu_soc15_read_bios_from_rom(struct amdgpu_device *adev, |
464 | u8 *bios, u32 length_bytes) |
465 | { |
466 | u32 *dw_ptr; |
467 | u32 i, length_dw; |
468 | u32 rom_offset; |
469 | u32 rom_index_offset; |
470 | u32 rom_data_offset; |
471 | |
472 | if (bios == NULL) |
473 | return false; |
474 | if (length_bytes == 0) |
475 | return false; |
476 | /* APU vbios image is part of sbios image */ |
477 | if (adev->flags & AMD_IS_APU) |
478 | return false; |
479 | if (!adev->smuio.funcs || |
480 | !adev->smuio.funcs->get_rom_index_offset || |
481 | !adev->smuio.funcs->get_rom_data_offset) |
482 | return false; |
483 | |
484 | dw_ptr = (u32 *)bios; |
485 | length_dw = ALIGN(length_bytes, 4) / 4; |
486 | |
487 | rom_index_offset = |
488 | adev->smuio.funcs->get_rom_index_offset(adev); |
489 | rom_data_offset = |
490 | adev->smuio.funcs->get_rom_data_offset(adev); |
491 | |
492 | if (adev->nbio.funcs && |
493 | adev->nbio.funcs->get_rom_offset) { |
494 | rom_offset = adev->nbio.funcs->get_rom_offset(adev); |
495 | rom_offset = rom_offset << 17; |
496 | } else { |
497 | rom_offset = 0; |
498 | } |
499 | |
500 | /* set rom index to rom_offset */ |
501 | WREG32(rom_index_offset, rom_offset); |
502 | /* read out the rom data */ |
503 | for (i = 0; i < length_dw; i++) |
504 | dw_ptr[i] = RREG32(rom_data_offset); |
505 | |
506 | return true; |
507 | } |
508 | |