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 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 }