drivers/gpu/drm/amd/amdgpu/amdgpu_bios.c

   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
  90 /* If you boot an IGP board with a discrete card as the primary,
  91  * the IGP rom is not accessible via the rom bar as the IGP rom is
  92  * part of the system bios.  On boot, the system bios puts a
  93  * copy of the igp rom at the start of vram if a discrete card is
  94  * present.
  95  */
  96 static bool igp_read_bios_from_vram(struct amdgpu_device *adev)
  97 {
  98         uint8_t __iomem *bios;
  99         resource_size_t vram_base;
 100         resource_size_t size = 256 * 1024; /* ??? */
 101
 102         if (!(adev->flags & AMD_IS_APU))
 103                 if (amdgpu_need_post(adev))
 104                         return false;
 105
 106         adev->bios = NULL;
 107         vram_base = pci_resource_start(adev->pdev, 0);
 108         bios = ioremap(vram_base, size);
 109         if (!bios) {
 110                 return false;
 111         }
 112
 113         adev->bios = kmalloc(size, GFP_KERNEL);
 114         if (!adev->bios) {
 115                 iounmap(bios);
 116                 return false;
 117         }
 118         adev->bios_size = size;
 119         memcpy_fromio(adev->bios, bios, size);
 120         iounmap(bios);
 121
 122         if (!check_atom_bios(adev->bios, size)) {
 123                 kfree(adev->bios);
 124                 return false;
 125         }
 126
 127         return true;
 128 }
 129
 130 bool amdgpu_read_bios(struct amdgpu_device *adev)
 131 {
 132         uint8_t __iomem *bios;
 133         size_t size;
 134
 135         adev->bios = NULL;
 136         /* XXX: some cards may return 0 for rom size? ddx has a workaround */
 137         bios = pci_map_rom(adev->pdev, &size);
 138         if (!bios) {
 139                 return false;
 140         }
 141
 142         adev->bios = kzalloc(size, GFP_KERNEL);
 143         if (adev->bios == NULL) {
 144                 pci_unmap_rom(adev->pdev, bios);
 145                 return false;
 146         }
 147         adev->bios_size = size;
 148         memcpy_fromio(adev->bios, bios, size);
 149         pci_unmap_rom(adev->pdev, bios);
 150
 151         if (!check_atom_bios(adev->bios, size)) {
 152                 kfree(adev->bios);
 153                 return false;
 154         }
 155
 156         return true;
 157 }
 158
 159 static bool amdgpu_read_bios_from_rom(struct amdgpu_device *adev)
 160 {
 161         u8 header[AMD_VBIOS_SIGNATURE_END+1] = {0};
 162         int len;
 163
 164         if (!adev->asic_funcs->read_bios_from_rom)
 165                 return false;
 166
 167         /* validate VBIOS signature */
 168         if (amdgpu_asic_read_bios_from_rom(adev, &header[0], sizeof(header)) == false)
 169                 return false;
 170         header[AMD_VBIOS_SIGNATURE_END] = 0;
 171
 172         if ((!AMD_IS_VALID_VBIOS(header)) ||
 173             0 != memcmp((char *)&header[AMD_VBIOS_SIGNATURE_OFFSET],
 174                         AMD_VBIOS_SIGNATURE,
 175                         strlen(AMD_VBIOS_SIGNATURE)))
 176                 return false;
 177
 178         /* valid vbios, go on */
 179         len = AMD_VBIOS_LENGTH(header);
 180         len = ALIGN(len, 4);
 181         adev->bios = kmalloc(len, GFP_KERNEL);
 182         if (!adev->bios) {
 183                 DRM_ERROR("no memory to allocate for BIOS\n");
 184                 return false;
 185         }
 186         adev->bios_size = len;
 187
 188         /* read complete BIOS */
 189         amdgpu_asic_read_bios_from_rom(adev, adev->bios, len);
 190
 191         if (!check_atom_bios(adev->bios, len)) {
 192                 kfree(adev->bios);
 193                 return false;
 194         }
 195
 196         return true;
 197 }
 198
 199 static bool amdgpu_read_platform_bios(struct amdgpu_device *adev)
 200 {
 201         uint8_t __iomem *bios;
 202         size_t size;
 203
 204         adev->bios = NULL;
 205
 206         bios = pci_platform_rom(adev->pdev, &size);
 207         if (!bios) {
 208                 return false;
 209         }
 210
 211         adev->bios = kzalloc(size, GFP_KERNEL);
 212         if (adev->bios == NULL)
 213                 return false;
 214
 215         memcpy_fromio(adev->bios, bios, size);
 216
 217         if (!check_atom_bios(adev->bios, size)) {
 218                 kfree(adev->bios);
 219                 return false;
 220         }
 221
 222         adev->bios_size = size;
 223
 224         return true;
 225 }
 226
 227 #ifdef CONFIG_ACPI
 228 /* ATRM is used to get the BIOS on the discrete cards in
 229  * dual-gpu systems.
 230  */
 231 /* retrieve the ROM in 4k blocks */
 232 #define ATRM_BIOS_PAGE 4096
 233 /**
 234  * amdgpu_atrm_call - fetch a chunk of the vbios
 235  *
 236  * @atrm_handle: acpi ATRM handle
 237  * @bios: vbios image pointer
 238  * @offset: offset of vbios image data to fetch
 239  * @len: length of vbios image data to fetch
 240  *
 241  * Executes ATRM to fetch a chunk of the discrete
 242  * vbios image on PX systems (all asics).
 243  * Returns the length of the buffer fetched.
 244  */
 245 static int amdgpu_atrm_call(acpi_handle atrm_handle, uint8_t *bios,
 246                             int offset, int len)
 247 {
 248         acpi_status status;
 249         union acpi_object atrm_arg_elements[2], *obj;
 250         struct acpi_object_list atrm_arg;
 251         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
 252
 253         atrm_arg.count = 2;
 254         atrm_arg.pointer = &atrm_arg_elements[0];
 255
 256         atrm_arg_elements[0].type = ACPI_TYPE_INTEGER;
 257         atrm_arg_elements[0].integer.value = offset;
 258
 259         atrm_arg_elements[1].type = ACPI_TYPE_INTEGER;
 260         atrm_arg_elements[1].integer.value = len;
 261
 262         status = acpi_evaluate_object(atrm_handle, NULL, &atrm_arg, &buffer);
 263         if (ACPI_FAILURE(status)) {
 264                 printk("failed to evaluate ATRM got %s\n", acpi_format_exception(status));
 265                 return -ENODEV;
 266         }
 267
 268         obj = (union acpi_object *)buffer.pointer;
 269         memcpy(bios+offset, obj->buffer.pointer, obj->buffer.length);
 270         len = obj->buffer.length;
 271         kfree(buffer.pointer);
 272         return len;
 273 }
 274
 275 static bool amdgpu_atrm_get_bios(struct amdgpu_device *adev)
 276 {
 277         int ret;
 278         int size = 256 * 1024;
 279         int i;
 280         struct pci_dev *pdev = NULL;
 281         acpi_handle dhandle, atrm_handle;
 282         acpi_status status;
 283         bool found = false;
 284
 285         /* ATRM is for the discrete card only */
 286         if (adev->flags & AMD_IS_APU)
 287                 return false;
 288
 289         while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
 290                 dhandle = ACPI_HANDLE(&pdev->dev);
 291                 if (!dhandle)
 292                         continue;
 293
 294                 status = acpi_get_handle(dhandle, "ATRM", &atrm_handle);
 295                 if (!ACPI_FAILURE(status)) {
 296                         found = true;
 297                         break;
 298                 }
 299         }
 300
 301         if (!found) {
 302                 while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) {
 303                         dhandle = ACPI_HANDLE(&pdev->dev);
 304                         if (!dhandle)
 305                                 continue;
 306
 307                         status = acpi_get_handle(dhandle, "ATRM", &atrm_handle);
 308                         if (!ACPI_FAILURE(status)) {
 309                                 found = true;
 310                                 break;
 311                         }
 312                 }
 313         }
 314
 315         if (!found)
 316                 return false;
 317
 318         adev->bios = kmalloc(size, GFP_KERNEL);
 319         if (!adev->bios) {
 320                 DRM_ERROR("Unable to allocate bios\n");
 321                 return false;
 322         }
 323
 324         for (i = 0; i < size / ATRM_BIOS_PAGE; i++) {
 325                 ret = amdgpu_atrm_call(atrm_handle,
 326                                        adev->bios,
 327                                        (i * ATRM_BIOS_PAGE),
 328                                        ATRM_BIOS_PAGE);
 329                 if (ret < ATRM_BIOS_PAGE)
 330                         break;
 331         }
 332
 333         if (!check_atom_bios(adev->bios, size)) {
 334                 kfree(adev->bios);
 335                 return false;
 336         }
 337         adev->bios_size = size;
 338         return true;
 339 }
 340 #else
 341 static inline bool amdgpu_atrm_get_bios(struct amdgpu_device *adev)
 342 {
 343         return false;
 344 }
 345 #endif
 346
 347 static bool amdgpu_read_disabled_bios(struct amdgpu_device *adev)
 348 {
 349         if (adev->flags & AMD_IS_APU)
 350                 return igp_read_bios_from_vram(adev);
 351         else
 352                 return amdgpu_asic_read_disabled_bios(adev);
 353 }
 354
 355 #ifdef CONFIG_ACPI
 356 static bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev)
 357 {
 358         struct acpi_table_header *hdr;
 359         acpi_size tbl_size;
 360         UEFI_ACPI_VFCT *vfct;
 361         unsigned offset;
 362
 363         if (!ACPI_SUCCESS(acpi_get_table("VFCT", 1, &hdr)))
 364                 return false;
 365         tbl_size = hdr->length;
 366         if (tbl_size < sizeof(UEFI_ACPI_VFCT)) {
 367                 DRM_ERROR("ACPI VFCT table present but broken (too short #1)\n");
 368                 return false;
 369         }
 370
 371         vfct = (UEFI_ACPI_VFCT *)hdr;
 372         offset = vfct->VBIOSImageOffset;
 373
 374         while (offset < tbl_size) {
 375                 GOP_VBIOS_CONTENT *vbios = (GOP_VBIOS_CONTENT *)((char *)hdr + offset);
 376                 VFCT_IMAGE_HEADER *vhdr = &vbios->VbiosHeader;
 377
 378                 offset += sizeof(VFCT_IMAGE_HEADER);
 379                 if (offset > tbl_size) {
 380                         DRM_ERROR("ACPI VFCT image header truncated\n");
 381                         return false;
 382                 }
 383
 384                 offset += vhdr->ImageLength;
 385                 if (offset > tbl_size) {
 386                         DRM_ERROR("ACPI VFCT image truncated\n");
 387                         return false;
 388                 }
 389
 390                 if (vhdr->ImageLength &&
 391                     vhdr->PCIBus == adev->pdev->bus->number &&
 392                     vhdr->PCIDevice == PCI_SLOT(adev->pdev->devfn) &&
 393                     vhdr->PCIFunction == PCI_FUNC(adev->pdev->devfn) &&
 394                     vhdr->VendorID == adev->pdev->vendor &&
 395                     vhdr->DeviceID == adev->pdev->device) {
 396                         adev->bios = kmemdup(&vbios->VbiosContent,
 397                                              vhdr->ImageLength,
 398                                              GFP_KERNEL);
 399
 400                         if (!check_atom_bios(adev->bios, vhdr->ImageLength)) {
 401                                 kfree(adev->bios);
 402                                 return false;
 403                         }
 404                         adev->bios_size = vhdr->ImageLength;
 405                         return true;
 406                 }
 407         }
 408
 409         DRM_ERROR("ACPI VFCT table present but broken (too short #2)\n");
 410         return false;
 411 }
 412 #else
 413 static inline bool amdgpu_acpi_vfct_bios(struct amdgpu_device *adev)
 414 {
 415         return false;
 416 }
 417 #endif
 418
 419 bool amdgpu_get_bios(struct amdgpu_device *adev)
 420 {
 421         if (amdgpu_atrm_get_bios(adev))
 422                 return true;
 423
 424         if (amdgpu_acpi_vfct_bios(adev))
 425                 return true;
 426
 427         if (igp_read_bios_from_vram(adev))
 428                 return true;
 429
 430         if (amdgpu_read_bios(adev))
 431                 return true;
 432
 433         if (amdgpu_read_bios_from_rom(adev))
 434                 return true;
 435
 436         if (amdgpu_read_disabled_bios(adev))
 437                 return true;
 438
 439         if (amdgpu_read_platform_bios(adev))
 440                 return true;
 441
 442         DRM_ERROR("Unable to locate a BIOS ROM\n");
 443         return false;
 444 }