arch/x86/kernel/aperture_64.c

   1 /*
   2  * Firmware replacement code.
   3  *
   4  * Work around broken BIOSes that don't set an aperture or only set the
   5  * aperture in the AGP bridge.
   6  * If all fails map the aperture over some low memory.  This is cheaper than
   7  * doing bounce buffering. The memory is lost. This is done at early boot
   8  * because only the bootmem allocator can allocate 32+MB.
   9  *
  10  * Copyright 2002 Andi Kleen, SuSE Labs.
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/types.h>
  14 #include <linux/init.h>
  15 #include <linux/bootmem.h>
  16 #include <linux/mmzone.h>
  17 #include <linux/pci_ids.h>
  18 #include <linux/pci.h>
  19 #include <linux/bitops.h>
  20 #include <linux/ioport.h>
  21 #include <linux/suspend.h>
  22 #include <asm/e820.h>
  23 #include <asm/io.h>
  24 #include <asm/gart.h>
  25 #include <asm/pci-direct.h>
  26 #include <asm/dma.h>
  27 #include <asm/k8.h>
  28
  29 int gart_iommu_aperture;
  30 int gart_iommu_aperture_disabled __initdata;
  31 int gart_iommu_aperture_allowed __initdata;
  32
  33 int fallback_aper_order __initdata = 1; /* 64MB */
  34 int fallback_aper_force __initdata;
  35
  36 int fix_aperture __initdata = 1;
  37
  38 static struct resource gart_resource = {
  39         .name   = "GART",
  40         .flags  = IORESOURCE_MEM,
  41 };
  42
  43 static void __init insert_aperture_resource(u32 aper_base, u32 aper_size)
  44 {
  45         gart_resource.start = aper_base;
  46         gart_resource.end = aper_base + aper_size - 1;
  47         insert_resource(&iomem_resource, &gart_resource);
  48 }
  49
  50 /* This code runs before the PCI subsystem is initialized, so just
  51    access the northbridge directly. */
  52
  53 static u32 __init allocate_aperture(void)
  54 {
  55         u32 aper_size;
  56         void *p;
  57
  58         if (fallback_aper_order > 7)
  59                 fallback_aper_order = 7;
  60         aper_size = (32 * 1024 * 1024) << fallback_aper_order;
  61
  62         /*
  63          * Aperture has to be naturally aligned. This means a 2GB aperture
  64          * won't have much chance of finding a place in the lower 4GB of
  65          * memory. Unfortunately we cannot move it up because that would
  66          * make the IOMMU useless.
  67          */
  68         p = __alloc_bootmem_nopanic(aper_size, aper_size, 0);
  69         if (!p || __pa(p)+aper_size > 0xffffffff) {
  70                 printk(KERN_ERR
  71                         "Cannot allocate aperture memory hole (%p,%uK)\n",
  72                                 p, aper_size>>10);
  73                 if (p)
  74                         free_bootmem(__pa(p), aper_size);
  75                 return 0;
  76         }
  77         printk(KERN_INFO "Mapping aperture over %d KB of RAM @ %lx\n",
  78                         aper_size >> 10, __pa(p));
  79         insert_aperture_resource((u32)__pa(p), aper_size);
  80         register_nosave_region((u32)__pa(p) >> PAGE_SHIFT,
  81                                 (u32)__pa(p+aper_size) >> PAGE_SHIFT);
  82
  83         return (u32)__pa(p);
  84 }
  85
  86 static int __init aperture_valid(u64 aper_base, u32 aper_size, u32 min_size)
  87 {
  88         if (!aper_base)
  89                 return 0;
  90
  91         if (aper_base + aper_size > 0x100000000UL) {
  92                 printk(KERN_ERR "Aperture beyond 4GB. Ignoring.\n");
  93                 return 0;
  94         }
  95         if (e820_any_mapped(aper_base, aper_base + aper_size, E820_RAM)) {
  96                 printk(KERN_ERR "Aperture pointing to e820 RAM. Ignoring.\n");
  97                 return 0;
  98         }
  99         if (aper_size < min_size) {
 100                 printk(KERN_ERR "Aperture too small (%d MB) than (%d MB)\n",
 101                                  aper_size>>20, min_size>>20);
 102                 return 0;
 103         }
 104
 105         return 1;
 106 }
 107
 108 /* Find a PCI capability */
 109 static __u32 __init find_cap(int num, int slot, int func, int cap)
 110 {
 111         int bytes;
 112         u8 pos;
 113
 114         if (!(read_pci_config_16(num, slot, func, PCI_STATUS) &
 115                                                 PCI_STATUS_CAP_LIST))
 116                 return 0;
 117
 118         pos = read_pci_config_byte(num, slot, func, PCI_CAPABILITY_LIST);
 119         for (bytes = 0; bytes < 48 && pos >= 0x40; bytes++) {
 120                 u8 id;
 121
 122                 pos &= ~3;
 123                 id = read_pci_config_byte(num, slot, func, pos+PCI_CAP_LIST_ID);
 124                 if (id == 0xff)
 125                         break;
 126                 if (id == cap)
 127                         return pos;
 128                 pos = read_pci_config_byte(num, slot, func,
 129                                                 pos+PCI_CAP_LIST_NEXT);
 130         }
 131         return 0;
 132 }
 133
 134 /* Read a standard AGPv3 bridge header */
 135 static __u32 __init read_agp(int num, int slot, int func, int cap, u32 *order)
 136 {
 137         u32 apsize;
 138         u32 apsizereg;
 139         int nbits;
 140         u32 aper_low, aper_hi;
 141         u64 aper;
 142         u32 old_order;
 143
 144         printk(KERN_INFO "AGP bridge at %02x:%02x:%02x\n", num, slot, func);
 145         apsizereg = read_pci_config_16(num, slot, func, cap + 0x14);
 146         if (apsizereg == 0xffffffff) {
 147                 printk(KERN_ERR "APSIZE in AGP bridge unreadable\n");
 148                 return 0;
 149         }
 150
 151         /* old_order could be the value from NB gart setting */
 152         old_order = *order;
 153
 154         apsize = apsizereg & 0xfff;
 155         /* Some BIOS use weird encodings not in the AGPv3 table. */
 156         if (apsize & 0xff)
 157                 apsize |= 0xf00;
 158         nbits = hweight16(apsize);
 159         *order = 7 - nbits;
 160         if ((int)*order < 0) /* < 32MB */
 161                 *order = 0;
 162
 163         aper_low = read_pci_config(num, slot, func, 0x10);
 164         aper_hi = read_pci_config(num, slot, func, 0x14);
 165         aper = (aper_low & ~((1<<22)-1)) | ((u64)aper_hi << 32);
 166
 167         /*
 168          * On some sick chips, APSIZE is 0. It means it wants 4G
 169          * so let double check that order, and lets trust AMD NB settings:
 170          */
 171         printk(KERN_INFO "Aperture from AGP @ %Lx old size %u MB\n",
 172                         aper, 32 << old_order);
 173         if (aper + (32ULL<<(20 + *order)) > 0x100000000ULL) {
 174                 printk(KERN_INFO "Aperture size %u MB (APSIZE %x) is not right, using settings from NB\n",
 175                                 32 << *order, apsizereg);
 176                 *order = old_order;
 177         }
 178
 179         printk(KERN_INFO "Aperture from AGP @ %Lx size %u MB (APSIZE %x)\n",
 180                         aper, 32 << *order, apsizereg);
 181
 182         if (!aperture_valid(aper, (32*1024*1024) << *order, 32<<20))
 183                 return 0;
 184         return (u32)aper;
 185 }
 186
 187 /*
 188  * Look for an AGP bridge. Windows only expects the aperture in the
 189  * AGP bridge and some BIOS forget to initialize the Northbridge too.
 190  * Work around this here.
 191  *
 192  * Do an PCI bus scan by hand because we're running before the PCI
 193  * subsystem.
 194  *
 195  * All K8 AGP bridges are AGPv3 compliant, so we can do this scan
 196  * generically. It's probably overkill to always scan all slots because
 197  * the AGP bridges should be always an own bus on the HT hierarchy,
 198  * but do it here for future safety.
 199  */
 200 static __u32 __init search_agp_bridge(u32 *order, int *valid_agp)
 201 {
 202         int num, slot, func;
 203
 204         /* Poor man's PCI discovery */
 205         for (num = 0; num < 256; num++) {
 206                 for (slot = 0; slot < 32; slot++) {
 207                         for (func = 0; func < 8; func++) {
 208                                 u32 class, cap;
 209                                 u8 type;
 210                                 class = read_pci_config(num, slot, func,
 211                                                         PCI_CLASS_REVISION);
 212                                 if (class == 0xffffffff)
 213                                         break;
 214
 215                                 switch (class >> 16) {
 216                                 case PCI_CLASS_BRIDGE_HOST:
 217                                 case PCI_CLASS_BRIDGE_OTHER: /* needed? */
 218                                         /* AGP bridge? */
 219                                         cap = find_cap(num, slot, func,
 220                                                         PCI_CAP_ID_AGP);
 221                                         if (!cap)
 222                                                 break;
 223                                         *valid_agp = 1;
 224                                         return read_agp(num, slot, func, cap,
 225                                                         order);
 226                                 }
 227
 228                                 /* No multi-function device? */
 229                                 type = read_pci_config_byte(num, slot, func,
 230                                                                PCI_HEADER_TYPE);
 231                                 if (!(type & 0x80))
 232                                         break;
 233                         }
 234                 }
 235         }
 236         printk(KERN_INFO "No AGP bridge found\n");
 237
 238         return 0;
 239 }
 240
 241 static int gart_fix_e820 __initdata = 1;
 242
 243 static int __init parse_gart_mem(char *p)
 244 {
 245         if (!p)
 246                 return -EINVAL;
 247
 248         if (!strncmp(p, "off", 3))
 249                 gart_fix_e820 = 0;
 250         else if (!strncmp(p, "on", 2))
 251                 gart_fix_e820 = 1;
 252
 253         return 0;
 254 }
 255 early_param("gart_fix_e820", parse_gart_mem);
 256
 257 void __init early_gart_iommu_check(void)
 258 {
 259         /*
 260          * in case it is enabled before, esp for kexec/kdump,
 261          * previous kernel already enable that. memset called
 262          * by allocate_aperture/__alloc_bootmem_nopanic cause restart.
 263          * or second kernel have different position for GART hole. and new
 264          * kernel could use hole as RAM that is still used by GART set by
 265          * first kernel
 266          * or BIOS forget to put that in reserved.
 267          * try to update e820 to make that region as reserved.
 268          */
 269         int fix, num;
 270         u32 ctl;
 271         u32 aper_size = 0, aper_order = 0, last_aper_order = 0;
 272         u64 aper_base = 0, last_aper_base = 0;
 273         int aper_enabled = 0, last_aper_enabled = 0;
 274
 275         if (!early_pci_allowed())
 276                 return;
 277
 278         fix = 0;
 279         for (num = 24; num < 32; num++) {
 280                 if (!early_is_k8_nb(read_pci_config(0, num, 3, 0x00)))
 281                         continue;
 282
 283                 ctl = read_pci_config(0, num, 3, 0x90);
 284                 aper_enabled = ctl & 1;
 285                 aper_order = (ctl >> 1) & 7;
 286                 aper_size = (32 * 1024 * 1024) << aper_order;
 287                 aper_base = read_pci_config(0, num, 3, 0x94) & 0x7fff;
 288                 aper_base <<= 25;
 289
 290                 if ((last_aper_order && aper_order != last_aper_order) ||
 291                     (last_aper_base && aper_base != last_aper_base) ||
 292                     (last_aper_enabled && aper_enabled != last_aper_enabled)) {
 293                         fix = 1;
 294                         break;
 295                 }
 296                 last_aper_order = aper_order;
 297                 last_aper_base = aper_base;
 298                 last_aper_enabled = aper_enabled;
 299         }
 300
 301         if (!fix && !aper_enabled)
 302                 return;
 303
 304         if (!aper_base || !aper_size || aper_base + aper_size > 0x100000000UL)
 305                 fix = 1;
 306
 307         if (gart_fix_e820 && !fix && aper_enabled) {
 308                 if (!e820_all_mapped(aper_base, aper_base + aper_size,
 309                                     E820_RESERVED)) {
 310                         /* reserved it, so we can resuse it in second kernel */
 311                         printk(KERN_INFO "update e820 for GART\n");
 312                         add_memory_region(aper_base, aper_size, E820_RESERVED);
 313                         update_e820();
 314                 }
 315                 return;
 316         }
 317
 318         /* different nodes have different setting, disable them all at first*/
 319         for (num = 24; num < 32; num++) {
 320                 if (!early_is_k8_nb(read_pci_config(0, num, 3, 0x00)))
 321                         continue;
 322
 323                 ctl = read_pci_config(0, num, 3, 0x90);
 324                 ctl &= ~1;
 325                 write_pci_config(0, num, 3, 0x90, ctl);
 326         }
 327
 328 }
 329
 330 static int __initdata printed_gart_size_msg;
 331
 332 void __init gart_iommu_hole_init(void)
 333 {
 334         u32 agp_aper_base = 0, agp_aper_order = 0;
 335         u32 aper_size, aper_alloc = 0, aper_order = 0, last_aper_order = 0;
 336         u64 aper_base, last_aper_base = 0;
 337         int fix, num, valid_agp = 0;
 338         int node;
 339
 340         if (gart_iommu_aperture_disabled || !fix_aperture ||
 341             !early_pci_allowed())
 342                 return;
 343
 344         printk(KERN_INFO  "Checking aperture...\n");
 345
 346         if (!fallback_aper_force)
 347                 agp_aper_base = search_agp_bridge(&agp_aper_order, &valid_agp);
 348
 349         fix = 0;
 350         node = 0;
 351         for (num = 24; num < 32; num++) {
 352                 if (!early_is_k8_nb(read_pci_config(0, num, 3, 0x00)))
 353                         continue;
 354
 355                 iommu_detected = 1;
 356                 gart_iommu_aperture = 1;
 357
 358                 aper_order = (read_pci_config(0, num, 3, 0x90) >> 1) & 7;
 359                 aper_size = (32 * 1024 * 1024) << aper_order;
 360                 aper_base = read_pci_config(0, num, 3, 0x94) & 0x7fff;
 361                 aper_base <<= 25;
 362
 363                 printk(KERN_INFO "Node %d: aperture @ %Lx size %u MB\n",
 364                                 node, aper_base, aper_size >> 20);
 365                 node++;
 366
 367                 if (!aperture_valid(aper_base, aper_size, 64<<20)) {
 368                         if (valid_agp && agp_aper_base &&
 369                             agp_aper_base == aper_base &&
 370                             agp_aper_order == aper_order) {
 371                                 /* the same between two setting from NB and agp */
 372                                 if (!no_iommu && end_pfn > MAX_DMA32_PFN && !printed_gart_size_msg) {
 373                                         printk(KERN_ERR "you are using iommu with agp, but GART size is less than 64M\n");
 374                                         printk(KERN_ERR "please increase GART size in your BIOS setup\n");
 375                                         printk(KERN_ERR "if BIOS doesn't have that option, contact your HW vendor!\n");
 376                                         printed_gart_size_msg = 1;
 377                                 }
 378                         } else {
 379                                 fix = 1;
 380                                 break;
 381                         }
 382                 }
 383
 384                 if ((last_aper_order && aper_order != last_aper_order) ||
 385                     (last_aper_base && aper_base != last_aper_base)) {
 386                         fix = 1;
 387                         break;
 388                 }
 389                 last_aper_order = aper_order;
 390                 last_aper_base = aper_base;
 391         }
 392
 393         if (!fix && !fallback_aper_force) {
 394                 if (last_aper_base) {
 395                         unsigned long n = (32 * 1024 * 1024) << last_aper_order;
 396
 397                         insert_aperture_resource((u32)last_aper_base, n);
 398                 }
 399                 return;
 400         }
 401
 402         if (!fallback_aper_force) {
 403                 aper_alloc = agp_aper_base;
 404                 aper_order = agp_aper_order;
 405         }
 406
 407         if (aper_alloc) {
 408                 /* Got the aperture from the AGP bridge */
 409         } else if (swiotlb && !valid_agp) {
 410                 /* Do nothing */
 411         } else if ((!no_iommu && end_pfn > MAX_DMA32_PFN) ||
 412                    force_iommu ||
 413                    valid_agp ||
 414                    fallback_aper_force) {
 415                 printk(KERN_ERR
 416                         "Your BIOS doesn't leave a aperture memory hole\n");
 417                 printk(KERN_ERR
 418                         "Please enable the IOMMU option in the BIOS setup\n");
 419                 printk(KERN_ERR
 420                         "This costs you %d MB of RAM\n",
 421                                 32 << fallback_aper_order);
 422
 423                 aper_order = fallback_aper_order;
 424                 aper_alloc = allocate_aperture();
 425                 if (!aper_alloc) {
 426                         /*
 427                          * Could disable AGP and IOMMU here, but it's
 428                          * probably not worth it. But the later users
 429                          * cannot deal with bad apertures and turning
 430                          * on the aperture over memory causes very
 431                          * strange problems, so it's better to panic
 432                          * early.
 433                          */
 434                         panic("Not enough memory for aperture");
 435                 }
 436         } else {
 437                 return;
 438         }
 439
 440         /* Fix up the north bridges */
 441         for (num = 24; num < 32; num++) {
 442                 if (!early_is_k8_nb(read_pci_config(0, num, 3, 0x00)))
 443                         continue;
 444
 445                 /*
 446                  * Don't enable translation yet. That is done later.
 447                  * Assume this BIOS didn't initialise the GART so
 448                  * just overwrite all previous bits
 449                  */
 450                 write_pci_config(0, num, 3, 0x90, aper_order<<1);
 451                 write_pci_config(0, num, 3, 0x94, aper_alloc>>25);
 452         }
 453 }