src/northbridge/amd/amdfam10/northbridge.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2007 Advanced Micro Devices, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 #include <console/console.h>
  21 #include <arch/io.h>
  22 #include <stdint.h>
  23 #include <device/device.h>
  24 #include <device/pci.h>
  25 #include <device/pci_ids.h>
  26 #include <device/hypertransport.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <bitops.h>
  30 #include <cpu/cpu.h>
  31
  32 #include <cpu/x86/lapic.h>
  33
  34 #if CONFIG_LOGICAL_CPUS==1
  35 #include <cpu/amd/multicore.h>
  36 #include <pc80/mc146818rtc.h>
  37 #endif
  38
  39 #include "chip.h"
  40 #include "root_complex/chip.h"
  41 #include "northbridge.h"
  42
  43 #include "amdfam10.h"
  44
  45 #if CONFIG_HW_MEM_HOLE_SIZEK != 0
  46 #include <cpu/amd/model_10xxx_rev.h>
  47 #endif
  48
  49 #include <cpu/amd/amdfam10_sysconf.h>
  50
  51 struct amdfam10_sysconf_t sysconf;
  52
  53 #define FX_DEVS NODE_NUMS
  54 static device_t __f0_dev[FX_DEVS];
  55 static device_t __f1_dev[FX_DEVS];
  56 static device_t __f2_dev[FX_DEVS];
  57 static device_t __f4_dev[FX_DEVS];
  58 static unsigned fx_devs=0;
  59
  60 device_t get_node_pci(u32 nodeid, u32 fn)
  61 {
  62 #if NODE_NUMS == 64
  63         if(nodeid<32) {
  64                 return dev_find_slot(CONFIG_CBB, PCI_DEVFN(CONFIG_CDB + nodeid, fn));
  65         } else {
  66                 return dev_find_slot(CONFIG_CBB-1, PCI_DEVFN(CONFIG_CDB + nodeid - 32, fn));
  67         }
  68
  69 #else
  70         return dev_find_slot(CONFIG_CBB, PCI_DEVFN(CONFIG_CDB + nodeid, fn));
  71 #endif
  72 }
  73
  74 static void get_fx_devs(void)
  75 {
  76         int i;
  77         for(i = 0; i < FX_DEVS; i++) {
  78                 __f0_dev[i] = get_node_pci(i, 0);
  79                 __f1_dev[i] = get_node_pci(i, 1);
  80                 __f2_dev[i] = get_node_pci(i, 2);
  81                 __f4_dev[i] = get_node_pci(i, 4);
  82                 if (__f0_dev[i] != NULL && __f1_dev[i] != NULL)
  83                         fx_devs = i+1;
  84         }
  85         if (__f1_dev[0] == NULL || __f0_dev[0] == NULL || fx_devs == 0) {
  86                 die("Cannot find 0:0x18.[0|1]\n");
  87         }
  88 }
  89
  90 static u32 f1_read_config32(unsigned reg)
  91 {
  92         if (fx_devs == 0)
  93                 get_fx_devs();
  94         return pci_read_config32(__f1_dev[0], reg);
  95 }
  96
  97 static void f1_write_config32(unsigned reg, u32 value)
  98 {
  99         int i;
 100         if (fx_devs == 0)
 101                 get_fx_devs();
 102         for(i = 0; i < fx_devs; i++) {
 103                 device_t dev;
 104                 dev = __f1_dev[i];
 105                 if (dev && dev->enabled) {
 106                         pci_write_config32(dev, reg, value);
 107                 }
 108         }
 109 }
 110
 111 static u32 amdfam10_nodeid(device_t dev)
 112 {
 113 #if NODE_NUMS == 64
 114         unsigned busn;
 115         busn = dev->bus->secondary;
 116         if(busn != CONFIG_CBB) {
 117                 return (dev->path.pci.devfn >> 3) - CONFIG_CDB + 32;
 118         } else {
 119                 return (dev->path.pci.devfn >> 3) - CONFIG_CDB;
 120         }
 121
 122 #else
 123         return (dev->path.pci.devfn >> 3) - CONFIG_CDB;
 124 #endif
 125 }
 126
 127 #include "conf.c"
 128
 129 static void set_vga_enable_reg(u32 nodeid, u32 linkn)
 130 {
 131         u32 val;
 132
 133         val =  1 | (nodeid<<4) | (linkn<<12);
 134         /* it will routing (1)mmio  0xa0000:0xbffff (2) io 0x3b0:0x3bb,
 135          0x3c0:0x3df */
 136         f1_write_config32(0xf4, val);
 137
 138 }
 139
 140 static u32 amdfam10_scan_chain(device_t dev, u32 nodeid, struct bus *link, u32 link_num, u32 sblink,
 141                                 u32 max, u32 offset_unitid)
 142 {
 143 //      I want to put sb chain in bus 0 can I?
 144
 145
 146                 u32 link_type;
 147                 int i;
 148                 u32 ht_c_index;
 149                 u32 ht_unitid_base[4]; // here assume only 4 HT device on chain
 150                 u32 max_bus;
 151                 u32 min_bus;
 152                 u32 is_sublink1 = (link_num>3);
 153                 device_t devx;
 154                 u32 busses;
 155                 u32 segn = max>>8;
 156 #if CONFIG_SB_HT_CHAIN_ON_BUS0 > 1
 157                 u32 busn = max&0xff;
 158 #endif
 159                 u32 max_devfn;
 160
 161 #if CONFIG_HT3_SUPPORT==1
 162                 if(is_sublink1) {
 163                         u32 regpos;
 164                         u32 reg;
 165                         regpos = 0x170 + 4 * (link_num&3); // it is only on sublink0
 166                         reg = pci_read_config32(dev, regpos);
 167                         if(reg & 1) return max; // already ganged no sblink1
 168                         devx = get_node_pci(nodeid, 4);
 169                 } else
 170 #endif
 171                         devx = dev;
 172
 173
 174                 link->cap = 0x80 + ((link_num&3) *0x20);
 175                 do {
 176                         link_type = pci_read_config32(devx, link->cap + 0x18);
 177                 } while(link_type & ConnectionPending);
 178                 if (!(link_type & LinkConnected)) {
 179                         return max;
 180                 }
 181                 do {
 182                         link_type = pci_read_config32(devx, link->cap + 0x18);
 183                 } while(!(link_type & InitComplete));
 184                 if (!(link_type & NonCoherent)) {
 185                         return max;
 186                 }
 187                 /* See if there is an available configuration space mapping
 188                  * register in function 1.
 189                  */
 190                 ht_c_index = get_ht_c_index(nodeid, link_num, &sysconf);
 191
 192 #if CONFIG_EXT_CONF_SUPPORT == 0
 193                 if(ht_c_index>=4) return max;
 194 #endif
 195
 196                 /* Set up the primary, secondary and subordinate bus numbers.
 197                  * We have no idea how many busses are behind this bridge yet,
 198                  * so we set the subordinate bus number to 0xff for the moment.
 199                  */
 200 #if CONFIG_SB_HT_CHAIN_ON_BUS0 > 0
 201                 // first chain will on bus 0
 202                 if((nodeid == 0) && (sblink==link_num)) { // actually max is 0 here
 203                         min_bus = max;
 204                 }
 205         #if CONFIG_SB_HT_CHAIN_ON_BUS0 > 1
 206                 // second chain will be on 0x40, third 0x80, forth 0xc0
 207                 // i would refined that to  2, 3, 4 ==> 0, 0x, 40, 0x80, 0xc0
 208                 //                          >4 will use  more segments, We can have 16 segmment and every segment have 256 bus, For that case need the kernel support mmio pci config.
 209                 else {
 210                         min_bus = ((busn>>3) + 1) << 3; // one node can have 8 link and segn is the same
 211                 }
 212                 max = min_bus | (segn<<8);
 213         #else
 214                 //other ...
 215                 else {
 216                         min_bus = ++max;
 217                 }
 218         #endif
 219 #else
 220                 min_bus = ++max;
 221 #endif
 222                 max_bus = 0xfc | (segn<<8);
 223
 224                 link->secondary = min_bus;
 225                 link->subordinate = max_bus;
 226
 227                 /* Read the existing primary/secondary/subordinate bus
 228                  * number configuration.
 229                  */
 230                 busses = pci_read_config32(devx, link->cap + 0x14);
 231
 232                 /* Configure the bus numbers for this bridge: the configuration
 233                  * transactions will not be propagates by the bridge if it is
 234                  * not correctly configured
 235                  */
 236                 busses &= 0xffff00ff;
 237                 busses |= ((u32)(link->secondary) << 8);
 238                 pci_write_config32(devx, link->cap + 0x14, busses);
 239
 240
 241                 /* set the config map space */
 242
 243                 set_config_map_reg(nodeid, link_num, ht_c_index, link->secondary, link->subordinate, sysconf.segbit, sysconf.nodes);
 244
 245                 /* Now we can scan all of the subordinate busses i.e. the
 246                  * chain on the hypertranport link
 247                  */
 248                 for(i=0;i<4;i++) {
 249                         ht_unitid_base[i] = 0x20;
 250                 }
 251
 252                 //if ext conf is enabled, only need use 0x1f
 253                 if (min_bus == 0)
 254                         max_devfn = (0x17<<3) | 7;
 255                 else
 256                         max_devfn = (0x1f<<3) | 7;
 257
 258                 max = hypertransport_scan_chain(link, 0, max_devfn, max, ht_unitid_base, offset_unitid);
 259
 260                 /* We know the number of busses behind this bridge.  Set the
 261                  * subordinate bus number to it's real value
 262                  */
 263                 if(ht_c_index>3) { // clear the extend reg
 264                         clear_config_map_reg(nodeid, link_num, ht_c_index, (max+1)>>sysconf.segbit, (link->subordinate)>>sysconf.segbit, sysconf.nodes);
 265                 }
 266
 267                 link->subordinate = max;
 268                 set_config_map_reg(nodeid, link_num, ht_c_index, link->secondary, link->subordinate, sysconf.segbit, sysconf.nodes);
 269                 sysconf.ht_c_num++;
 270
 271                 {
 272                         // use ht_unitid_base to update hcdn_reg
 273                         u32 temp = 0;
 274                         for(i=0;i<4;i++) {
 275                                 temp |= (ht_unitid_base[i] & 0xff) << (i*8);
 276                         }
 277
 278                         sysconf.hcdn_reg[ht_c_index] = temp;
 279
 280                 }
 281         store_ht_c_conf_bus(nodeid, link_num, ht_c_index, link->secondary, link->subordinate, &sysconf);
 282         return max;
 283 }
 284
 285 static unsigned amdfam10_scan_chains(device_t dev, unsigned max)
 286 {
 287         unsigned nodeid;
 288         struct bus *link;
 289         unsigned sblink = sysconf.sblk;
 290         unsigned offset_unitid = 0;
 291
 292         nodeid = amdfam10_nodeid(dev);
 293
 294 // Put sb chain in bus 0
 295 #if CONFIG_SB_HT_CHAIN_ON_BUS0 > 0
 296         if(nodeid==0) {
 297         #if ((CONFIG_HT_CHAIN_UNITID_BASE != 1) || (CONFIG_HT_CHAIN_END_UNITID_BASE != 0x20))
 298                 offset_unitid = 1;
 299         #endif
 300                 for (link = dev->link_list; link; link = link->next)
 301                         if (link->link_num == sblink)
 302                                 max = amdfam10_scan_chain(dev, nodeid, link, sblink, sblink, max, offset_unitid ); // do sb ht chain at first, in case s2885 put sb chain (8131/8111) on link2, but put 8151 on link0
 303         }
 304 #endif
 305
 306 #if CONFIG_PCI_BUS_SEGN_BITS
 307         max = check_segn(dev, max, sysconf.nodes, &sysconf);
 308 #endif
 309
 310         for(link = dev->link_list; link; link = link->next) {
 311 #if CONFIG_SB_HT_CHAIN_ON_BUS0 > 0
 312                 if( (nodeid == 0) && (sblink == link->link_num) ) continue; //already done
 313 #endif
 314                 offset_unitid = 0;
 315                 #if ((CONFIG_HT_CHAIN_UNITID_BASE != 1) || (CONFIG_HT_CHAIN_END_UNITID_BASE != 0x20))
 316                         #if CONFIG_SB_HT_CHAIN_UNITID_OFFSET_ONLY == 1
 317                         if((nodeid == 0) && (sblink == link->link_num))
 318                         #endif
 319                                 offset_unitid = 1;
 320                 #endif
 321
 322                 max = amdfam10_scan_chain(dev, nodeid, link, link->link_num, sblink, max, offset_unitid);
 323         }
 324         return max;
 325 }
 326
 327
 328 static int reg_useable(unsigned reg, device_t goal_dev, unsigned goal_nodeid,
 329                         unsigned goal_link)
 330 {
 331         struct resource *res;
 332         unsigned nodeid, link = 0;
 333         int result;
 334         res = 0;
 335         for(nodeid = 0; !res && (nodeid < fx_devs); nodeid++) {
 336                 device_t dev;
 337                 dev = __f0_dev[nodeid];
 338                 if (!dev)
 339                         continue;
 340                 for(link = 0; !res && (link < 8); link++) {
 341                         res = probe_resource(dev, IOINDEX(0x1000 + reg, link));
 342                 }
 343         }
 344         result = 2;
 345         if (res) {
 346                 result = 0;
 347                 if (    (goal_link == (link - 1)) &&
 348                         (goal_nodeid == (nodeid - 1)) &&
 349                         (res->flags <= 1)) {
 350                         result = 1;
 351                 }
 352         }
 353         return result;
 354 }
 355
 356 static struct resource *amdfam10_find_iopair(device_t dev, unsigned nodeid, unsigned link)
 357 {
 358         struct resource *resource;
 359         u32 free_reg, reg;
 360         resource = 0;
 361         free_reg = 0;
 362         for(reg = 0xc0; reg <= 0xd8; reg += 0x8) {
 363                 int result;
 364                 result = reg_useable(reg, dev, nodeid, link);
 365                 if (result == 1) {
 366                         /* I have been allocated this one */
 367                         break;
 368                 }
 369                 else if (result > 1) {
 370                         /* I have a free register pair */
 371                         free_reg = reg;
 372                 }
 373         }
 374         if (reg > 0xd8) {
 375                 reg = free_reg; // if no free, the free_reg still be 0
 376         }
 377
 378         //Ext conf space
 379         if(!reg) {
 380                 //because of Extend conf space, we will never run out of reg, but we need one index to differ them. so same node and same link can have multi range
 381                 u32 index = get_io_addr_index(nodeid, link);
 382                 reg = 0x110+ (index<<24) + (4<<20); // index could be 0, 255
 383         }
 384
 385                 resource = new_resource(dev, IOINDEX(0x1000 + reg, link));
 386
 387         return resource;
 388 }
 389
 390 static struct resource *amdfam10_find_mempair(device_t dev, u32 nodeid, u32 link)
 391 {
 392         struct resource *resource;
 393         u32 free_reg, reg;
 394         resource = 0;
 395         free_reg = 0;
 396         for(reg = 0x80; reg <= 0xb8; reg += 0x8) {
 397                 int result;
 398                 result = reg_useable(reg, dev, nodeid, link);
 399                 if (result == 1) {
 400                         /* I have been allocated this one */
 401                         break;
 402                 }
 403                 else if (result > 1) {
 404                         /* I have a free register pair */
 405                         free_reg = reg;
 406                 }
 407         }
 408         if (reg > 0xb8) {
 409                 reg = free_reg;
 410         }
 411
 412         //Ext conf space
 413         if(!reg) {
 414                 //because of Extend conf space, we will never run out of reg,
 415                 // but we need one index to differ them. so same node and
 416                 // same link can have multi range
 417                 u32 index = get_mmio_addr_index(nodeid, link);
 418                 reg = 0x110+ (index<<24) + (6<<20); // index could be 0, 63
 419
 420         }
 421         resource = new_resource(dev, IOINDEX(0x1000 + reg, link));
 422         return resource;
 423 }
 424
 425
 426 static void amdfam10_link_read_bases(device_t dev, u32 nodeid, u32 link)
 427 {
 428         struct resource *resource;
 429
 430         /* Initialize the io space constraints on the current bus */
 431         resource = amdfam10_find_iopair(dev, nodeid, link);
 432         if (resource) {
 433                 u32 align;
 434 #if CONFIG_EXT_CONF_SUPPORT == 1
 435                 if((resource->index & 0x1fff) == 0x1110) { // ext
 436                         align = 8;
 437                 }
 438                 else
 439 #endif
 440                         align = log2(HT_IO_HOST_ALIGN);
 441                 resource->base  = 0;
 442                 resource->size  = 0;
 443                 resource->align = align;
 444                 resource->gran  = align;
 445                 resource->limit = 0xffffUL;
 446                 resource->flags = IORESOURCE_IO | IORESOURCE_BRIDGE;
 447         }
 448
 449         /* Initialize the prefetchable memory constraints on the current bus */
 450         resource = amdfam10_find_mempair(dev, nodeid, link);
 451         if (resource) {
 452                 resource->base = 0;
 453                 resource->size = 0;
 454                 resource->align = log2(HT_MEM_HOST_ALIGN);
 455                 resource->gran = log2(HT_MEM_HOST_ALIGN);
 456                 resource->limit = 0xffffffffffULL;
 457                 resource->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH;
 458                 resource->flags |= IORESOURCE_BRIDGE;
 459
 460 #if CONFIG_EXT_CONF_SUPPORT == 1
 461                 if((resource->index & 0x1fff) == 0x1110) { // ext
 462                         normalize_resource(resource);
 463                 }
 464 #endif
 465
 466         }
 467
 468         /* Initialize the memory constraints on the current bus */
 469         resource = amdfam10_find_mempair(dev, nodeid, link);
 470         if (resource) {
 471                 resource->base = 0;
 472                 resource->size = 0;
 473                 resource->align = log2(HT_MEM_HOST_ALIGN);
 474                 resource->gran = log2(HT_MEM_HOST_ALIGN);
 475                 resource->limit = 0xffffffffffULL;
 476                 resource->flags = IORESOURCE_MEM | IORESOURCE_BRIDGE;
 477 #if CONFIG_EXT_CONF_SUPPORT == 1
 478                 if((resource->index & 0x1fff) == 0x1110) { // ext
 479                         normalize_resource(resource);
 480                 }
 481 #endif
 482         }
 483 }
 484
 485 static void amdfam10_read_resources(device_t dev)
 486 {
 487         u32 nodeid;
 488         struct bus *link;
 489         nodeid = amdfam10_nodeid(dev);
 490         for(link = dev->link_list; link; link = link->next) {
 491                 if (link->children) {
 492                         amdfam10_link_read_bases(dev, nodeid, link->link_num);
 493                 }
 494         }
 495 }
 496
 497 static void amdfam10_set_resource(device_t dev, struct resource *resource,
 498                                 u32 nodeid)
 499 {
 500         resource_t rbase, rend;
 501         unsigned reg, link_num;
 502         char buf[50];
 503
 504         /* Make certain the resource has actually been set */
 505         if (!(resource->flags & IORESOURCE_ASSIGNED)) {
 506                 return;
 507         }
 508
 509         /* If I have already stored this resource don't worry about it */
 510         if (resource->flags & IORESOURCE_STORED) {
 511                 return;
 512         }
 513
 514         /* Only handle PCI memory and IO resources */
 515         if (!(resource->flags & (IORESOURCE_MEM | IORESOURCE_IO)))
 516                 return;
 517
 518         /* Ensure I am actually looking at a resource of function 1 */
 519         if ((resource->index & 0xffff) < 0x1000) {
 520                 return;
 521         }
 522         /* Get the base address */
 523         rbase = resource->base;
 524
 525         /* Get the limit (rounded up) */
 526         rend  = resource_end(resource);
 527
 528         /* Get the register and link */
 529         reg  = resource->index & 0xfff; // 4k
 530         link_num = IOINDEX_LINK(resource->index);
 531
 532         if (resource->flags & IORESOURCE_IO) {
 533
 534                 set_io_addr_reg(dev, nodeid, link_num, reg, rbase>>8, rend>>8);
 535                 store_conf_io_addr(nodeid, link_num, reg, (resource->index >> 24), rbase>>8, rend>>8);
 536         }
 537         else if (resource->flags & IORESOURCE_MEM) {
 538                 set_mmio_addr_reg(nodeid, link_num, reg, (resource->index >>24), rbase>>8, rend>>8, sysconf.nodes) ;// [39:8]
 539                 store_conf_mmio_addr(nodeid, link_num, reg, (resource->index >>24), rbase>>8, rend>>8);
 540         }
 541         resource->flags |= IORESOURCE_STORED;
 542         sprintf(buf, " <node %x link %x>",
 543                 nodeid, link_num);
 544         report_resource_stored(dev, resource, buf);
 545 }
 546
 547 /**
 548  * I tried to reuse the resource allocation code in amdfam10_set_resource()
 549  * but it is too difficult to deal with the resource allocation magic.
 550  */
 551
 552 static void amdfam10_create_vga_resource(device_t dev, unsigned nodeid)
 553 {
 554         struct bus *link;
 555
 556         /* find out which link the VGA card is connected,
 557          * we only deal with the 'first' vga card */
 558         for (link = dev->link_list; link; link = link->next) {
 559                 if (link->bridge_ctrl & PCI_BRIDGE_CTL_VGA) {
 560 #if CONFIG_MULTIPLE_VGA_ADAPTERS == 1
 561                         extern device_t vga_pri; // the primary vga device, defined in device.c
 562                         printk(BIOS_DEBUG, "VGA: vga_pri bus num = %d bus range [%d,%d]\n", vga_pri->bus->secondary,
 563                                 link->secondary,link->subordinate);
 564                         /* We need to make sure the vga_pri is under the link */
 565                         if((vga_pri->bus->secondary >= link->secondary ) &&
 566                                 (vga_pri->bus->secondary <= link->subordinate )
 567                         )
 568 #endif
 569                         break;
 570                 }
 571         }
 572
 573         /* no VGA card installed */
 574         if (link == NULL)
 575                 return;
 576
 577         printk(BIOS_DEBUG, "VGA: %s (aka node %d) link %d has VGA device\n", dev_path(dev), nodeid, link->link_num);
 578         set_vga_enable_reg(nodeid, link->link_num);
 579 }
 580
 581 static void amdfam10_set_resources(device_t dev)
 582 {
 583         unsigned nodeid;
 584         struct bus *bus;
 585         struct resource *res;
 586
 587         /* Find the nodeid */
 588         nodeid = amdfam10_nodeid(dev);
 589
 590         amdfam10_create_vga_resource(dev, nodeid);
 591
 592         /* Set each resource we have found */
 593         for(res = dev->resource_list; res; res = res->next) {
 594                 amdfam10_set_resource(dev, res, nodeid);
 595         }
 596
 597         for(bus = dev->link_list; bus; bus = bus->next) {
 598                 if (bus->children) {
 599                         assign_resources(bus);
 600                 }
 601         }
 602 }
 603
 604 static void mcf0_control_init(struct device *dev)
 605 {
 606 }
 607
 608 static struct device_operations northbridge_operations = {
 609         .read_resources   = amdfam10_read_resources,
 610         .set_resources    = amdfam10_set_resources,
 611         .enable_resources = pci_dev_enable_resources,
 612         .init             = mcf0_control_init,
 613         .scan_bus         = amdfam10_scan_chains,
 614         .enable           = 0,
 615         .ops_pci          = 0,
 616 };
 617
 618
 619 static const struct pci_driver mcf0_driver __pci_driver = {
 620         .ops    = &northbridge_operations,
 621         .vendor = PCI_VENDOR_ID_AMD,
 622         .device = 0x1200,
 623 };
 624
 625 struct chip_operations northbridge_amd_amdfam10_ops = {
 626         CHIP_NAME("AMD FAM10 Northbridge")
 627         .enable_dev = 0,
 628 };
 629
 630 static void amdfam10_domain_read_resources(device_t dev)
 631 {
 632         unsigned reg;
 633
 634         /* Find the already assigned resource pairs */
 635         get_fx_devs();
 636         for(reg = 0x80; reg <= 0xd8; reg+= 0x08) {
 637                 u32 base, limit;
 638                 base  = f1_read_config32(reg);
 639                 limit = f1_read_config32(reg + 0x04);
 640                 /* Is this register allocated? */
 641                 if ((base & 3) != 0) {
 642                         unsigned nodeid, reg_link;
 643                         device_t reg_dev;
 644                         if(reg<0xc0) { // mmio
 645                                 nodeid = (limit & 0xf) + (base&0x30);
 646                         } else { // io
 647                                 nodeid =  (limit & 0xf) + ((base>>4)&0x30);
 648                         }
 649                         reg_link = (limit >> 4) & 7;
 650                         reg_dev = __f0_dev[nodeid];
 651                         if (reg_dev) {
 652                                 /* Reserve the resource  */
 653                                 struct resource *res;
 654                                 res = new_resource(reg_dev, IOINDEX(0x1000 + reg, reg_link));
 655                                 if (res) {
 656                                         res->flags = 1;
 657                                 }
 658                         }
 659                 }
 660         }
 661         /* FIXME: do we need to check extend conf space?
 662            I don't believe that much preset value */
 663
 664 #if CONFIG_PCI_64BIT_PREF_MEM == 0
 665         pci_domain_read_resources(dev);
 666 #else
 667         struct bus *link;
 668         struct resource *resource;
 669         for(link=dev->link_list; link; link = link->next) {
 670                 /* Initialize the system wide io space constraints */
 671                 resource = new_resource(dev, 0|(link->link_num<<2));
 672                 resource->base  = 0x400;
 673                 resource->limit = 0xffffUL;
 674                 resource->flags = IORESOURCE_IO;
 675
 676                 /* Initialize the system wide prefetchable memory resources constraints */
 677                 resource = new_resource(dev, 1|(link->link_num<<2));
 678                 resource->limit = 0xfcffffffffULL;
 679                 resource->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH;
 680
 681                 /* Initialize the system wide memory resources constraints */
 682                 resource = new_resource(dev, 2|(link->link_num<<2));
 683                 resource->limit = 0xfcffffffffULL;
 684                 resource->flags = IORESOURCE_MEM;
 685         }
 686 #endif
 687 #if CONFIG_MMCONF_SUPPORT
 688         struct resource *res = new_resource(dev, 0xc0010058);
 689         res->base = CONFIG_MMCONF_BASE_ADDRESS;
 690         res->size = CONFIG_MMCONF_BUS_NUMBER * 4096*256;
 691         res->flags = IORESOURCE_MEM | IORESOURCE_RESERVE |
 692                 IORESOURCE_FIXED | IORESOURCE_STORED |  IORESOURCE_ASSIGNED;
 693 #endif
 694 }
 695
 696 static u32 my_find_pci_tolm(struct bus *bus, u32 tolm)
 697 {
 698         struct resource *min;
 699         min = 0;
 700         search_bus_resources(bus, IORESOURCE_MEM, IORESOURCE_MEM, tolm_test, &min);
 701         if (min && tolm > min->base) {
 702                 tolm = min->base;
 703         }
 704         return tolm;
 705 }
 706
 707 #if CONFIG_HW_MEM_HOLE_SIZEK != 0
 708
 709 struct hw_mem_hole_info {
 710         unsigned hole_startk;
 711         int node_id;
 712 };
 713
 714 static struct hw_mem_hole_info get_hw_mem_hole_info(void)
 715 {
 716                 struct hw_mem_hole_info mem_hole;
 717                 int i;
 718
 719                 mem_hole.hole_startk = CONFIG_HW_MEM_HOLE_SIZEK;
 720                 mem_hole.node_id = -1;
 721
 722                 for (i = 0; i < sysconf.nodes; i++) {
 723                         struct dram_base_mask_t d;
 724                         u32 hole;
 725                         d = get_dram_base_mask(i);
 726                         if(!(d.mask & 1)) continue; // no memory on this node
 727
 728                         hole = pci_read_config32(__f1_dev[i], 0xf0);
 729                         if(hole & 1) { // we find the hole
 730                                 mem_hole.hole_startk = (hole & (0xff<<24)) >> 10;
 731                                 mem_hole.node_id = i; // record the node No with hole
 732                                 break; // only one hole
 733                         }
 734                 }
 735
 736                 //We need to double check if there is speical set on base reg and limit reg are not continous instead of hole, it will find out it's hole_startk
 737                 if(mem_hole.node_id==-1) {
 738                         resource_t limitk_pri = 0;
 739                         for(i=0; i<sysconf.nodes; i++) {
 740                                 struct dram_base_mask_t d;
 741                                 resource_t base_k, limit_k;
 742                                 d = get_dram_base_mask(i);
 743                                 if(!(d.base & 1)) continue;
 744
 745                                 base_k = ((resource_t)(d.base & 0x1fffff00)) <<9;
 746                                 if(base_k > 4 *1024 * 1024) break; // don't need to go to check
 747                                 if(limitk_pri != base_k) { // we find the hole
 748                                         mem_hole.hole_startk = (unsigned)limitk_pri; // must beblow 4G
 749                                         mem_hole.node_id = i;
 750                                         break; //only one hole
 751                                 }
 752
 753                                 limit_k = ((resource_t)((d.mask + 0x00000100) & 0x1fffff00)) << 9;
 754                                 limitk_pri = limit_k;
 755                         }
 756                 }
 757                 return mem_hole;
 758 }
 759
 760 // WHY this check? CONFIG_AMDMCT is enabled on all Fam10 boards.
 761 // Does it make sense not to?
 762 #if CONFIG_AMDMCT == 0
 763 static void disable_hoist_memory(unsigned long hole_startk, int node_id)
 764 {
 765         int i;
 766         device_t dev;
 767         struct dram_base_mask_t d;
 768         u32 sel_m;
 769         u32 sel_hi_en;
 770         u32 hoist;
 771         u32 hole_sizek;
 772
 773         u32 one_DCT;
 774         struct sys_info *sysinfox = (struct sys_info *)((CONFIG_RAMTOP) - CONFIG_DCACHE_RAM_GLOBAL_VAR_SIZE); // in RAM
 775         struct mem_info *meminfo;
 776         meminfo = &sysinfox->meminfo[node_id];
 777
 778         one_DCT = get_one_DCT(meminfo);
 779
 780         // 1. find which node has hole
 781         // 2. change limit in that node.
 782         // 3. change base and limit in later node
 783         // 4. clear that node f0
 784
 785         // if there is not mem hole enabled, we need to change it's base instead
 786
 787         hole_sizek = (4*1024*1024) - hole_startk;
 788
 789         for(i=NODE_NUMS-1;i>node_id;i--) {
 790
 791                 d = get_dram_base_mask(i);
 792
 793                 if(!(d.mask & 1)) continue;
 794
 795                 d.base -= (hole_sizek>>9);
 796                 d.mask -= (hole_sizek>>9);
 797                 set_dram_base_mask(i, d, sysconf.nodes);
 798
 799                 if(get_DctSelHiEn(i) & 1) {
 800                         sel_m = get_DctSelBaseAddr(i);
 801                         sel_m -= hole_startk>>10;
 802                         set_DctSelBaseAddr(i, sel_m);
 803                 }
 804         }
 805
 806         d = get_dram_base_mask(node_id);
 807         dev = __f1_dev[node_id];
 808         sel_hi_en = get_DctSelHiEn(node_id);
 809
 810         if(sel_hi_en & 1) {
 811                 sel_m = get_DctSelBaseAddr(node_id);
 812         }
 813         hoist = pci_read_config32(dev, 0xf0);
 814         if(hoist & 1) {
 815                 pci_write_config32(dev, 0xf0, 0);
 816                 d.mask -= (hole_sizek>>9);
 817                 set_dram_base_mask(node_id, d, sysconf.nodes);
 818                 if(one_DCT || (sel_m >= (hole_startk>>10))) {
 819                         if(sel_hi_en & 1) {
 820                                 sel_m -= hole_startk>>10;
 821                                 set_DctSelBaseAddr(node_id, sel_m);
 822                         }
 823                 }
 824                 if(sel_hi_en & 1) {
 825                         set_DctSelBaseOffset(node_id, 0);
 826                 }
 827         } else {
 828                 d.base -= (hole_sizek>>9);
 829                 d.mask -= (hole_sizek>>9);
 830                 set_dram_base_mask(node_id, d, sysconf.nodes);
 831
 832                 if(sel_hi_en & 1) {
 833                         sel_m -= hole_startk>>10;
 834                         set_DctSelBaseAddr(node_id, sel_m);
 835                 }
 836         }
 837
 838 }
 839 #endif
 840
 841 #endif
 842
 843 #if CONFIG_WRITE_HIGH_TABLES==1
 844 #include <cbmem.h>
 845 #endif
 846
 847 #if CONFIG_GFXUMA == 1
 848 extern uint64_t uma_memory_base, uma_memory_size;
 849
 850 static void add_uma_resource(struct device *dev, int index)
 851 {
 852         struct resource *resource;
 853
 854         printk(BIOS_DEBUG, "Adding UMA memory area\n");
 855         resource = new_resource(dev, index);
 856         resource->base = (resource_t) uma_memory_base;
 857         resource->size = (resource_t) uma_memory_size;
 858         resource->flags = IORESOURCE_MEM | IORESOURCE_RESERVE |
 859             IORESOURCE_FIXED | IORESOURCE_STORED | IORESOURCE_ASSIGNED;
 860 }
 861 #endif
 862
 863 static void amdfam10_domain_set_resources(device_t dev)
 864 {
 865 #if CONFIG_PCI_64BIT_PREF_MEM == 1
 866         struct resource *io, *mem1, *mem2;
 867         struct resource *res;
 868 #endif
 869         unsigned long mmio_basek;
 870         u32 pci_tolm;
 871         int i, idx;
 872         struct bus *link;
 873 #if CONFIG_HW_MEM_HOLE_SIZEK != 0
 874         struct hw_mem_hole_info mem_hole;
 875         u32 reset_memhole = 1;
 876 #endif
 877
 878 #if CONFIG_PCI_64BIT_PREF_MEM == 1
 879
 880         for(link = dev->link_list; link; link = link->next) {
 881                 /* Now reallocate the pci resources memory with the
 882                  * highest addresses I can manage.
 883                  */
 884                 mem1 = find_resource(dev, 1|(link->link_num<<2));
 885                 mem2 = find_resource(dev, 2|(link->link_num<<2));
 886
 887                 printk(BIOS_DEBUG, "base1: 0x%08Lx limit1: 0x%08Lx size: 0x%08Lx align: %d\n",
 888                         mem1->base, mem1->limit, mem1->size, mem1->align);
 889                 printk(BIOS_DEBUG, "base2: 0x%08Lx limit2: 0x%08Lx size: 0x%08Lx align: %d\n",
 890                         mem2->base, mem2->limit, mem2->size, mem2->align);
 891
 892                 /* See if both resources have roughly the same limits */
 893                 if (((mem1->limit <= 0xffffffff) && (mem2->limit <= 0xffffffff)) ||
 894                         ((mem1->limit > 0xffffffff) && (mem2->limit > 0xffffffff)))
 895                 {
 896                         /* If so place the one with the most stringent alignment first
 897                          */
 898                         if (mem2->align > mem1->align) {
 899                                 struct resource *tmp;
 900                                 tmp = mem1;
 901                                 mem1 = mem2;
 902                                 mem2 = tmp;
 903                         }
 904                         /* Now place the memory as high up as it will go */
 905                         mem2->base = resource_max(mem2);
 906                         mem1->limit = mem2->base - 1;
 907                         mem1->base = resource_max(mem1);
 908                 }
 909                 else {
 910                         /* Place the resources as high up as they will go */
 911                         mem2->base = resource_max(mem2);
 912                         mem1->base = resource_max(mem1);
 913                 }
 914
 915                 printk(BIOS_DEBUG, "base1: 0x%08Lx limit1: 0x%08Lx size: 0x%08Lx align: %d\n",
 916                         mem1->base, mem1->limit, mem1->size, mem1->align);
 917                 printk(BIOS_DEBUG, "base2: 0x%08Lx limit2: 0x%08Lx size: 0x%08Lx align: %d\n",
 918                         mem2->base, mem2->limit, mem2->size, mem2->align);
 919         }
 920
 921         for(res = &dev->resource_list; res; res = res->next)
 922         {
 923                 res->flags |= IORESOURCE_ASSIGNED;
 924                 res->flags |= IORESOURCE_STORED;
 925                 report_resource_stored(dev, res, "");
 926         }
 927 #endif
 928
 929         pci_tolm = 0xffffffffUL;
 930         for(link = dev->link_list; link; link = link->next) {
 931                 pci_tolm = my_find_pci_tolm(link, pci_tolm);
 932         }
 933
 934         // FIXME handle interleaved nodes. If you fix this here, please fix
 935         // amdk8, too.
 936         mmio_basek = pci_tolm >> 10;
 937         /* Round mmio_basek to something the processor can support */
 938         mmio_basek &= ~((1 << 6) -1);
 939
 940         // FIXME improve mtrr.c so we don't use up all of the mtrrs with a 64M
 941         // MMIO hole. If you fix this here, please fix amdk8, too.
 942         /* Round the mmio hole to 64M */
 943         mmio_basek &= ~((64*1024) - 1);
 944
 945 #if CONFIG_HW_MEM_HOLE_SIZEK != 0
 946 /* if the hw mem hole is already set in raminit stage, here we will compare
 947  * mmio_basek and hole_basek. if mmio_basek is bigger that hole_basek and will
 948  * use hole_basek as mmio_basek and we don't need to reset hole.
 949  * otherwise We reset the hole to the mmio_basek
 950  */
 951
 952         mem_hole = get_hw_mem_hole_info();
 953
 954         // Use hole_basek as mmio_basek, and we don't need to reset hole anymore
 955         if ((mem_hole.node_id !=  -1) && (mmio_basek > mem_hole.hole_startk)) {
 956                 mmio_basek = mem_hole.hole_startk;
 957                 reset_memhole = 0;
 958         }
 959
 960         #if CONFIG_AMDMCT == 0
 961         //mmio_basek = 3*1024*1024; // for debug to meet boundary
 962
 963         if(reset_memhole) {
 964                 if(mem_hole.node_id!=-1) {
 965                 /* We need to select CONFIG_HW_MEM_HOLE_SIZEK for raminit, it can not
 966                     make hole_startk to some basek too!
 967                    We need to reset our Mem Hole, because We want more big HOLE
 968                     than we already set
 969                    Before that We need to disable mem hole at first, becase
 970                     memhole could already be set on i+1 instead
 971                  */
 972                         disable_hoist_memory(mem_hole.hole_startk, mem_hole.node_id);
 973                 }
 974
 975         #if CONFIG_HW_MEM_HOLE_SIZE_AUTO_INC == 1
 976                 // We need to double check if the mmio_basek is valid for hole
 977                 // setting, if it is equal to basek, we need to decrease it some
 978                 resource_t basek_pri;
 979                 for (i = 0; i < sysconf.nodes; i++) {
 980                         struct dram_base_mask_t d;
 981                         resource_t basek;
 982                         d = get_dram_base_mask(i);
 983
 984                         if(!(d.mask &1)) continue;
 985
 986                         basek = ((resource_t)(d.base & 0x1fffff00)) << 9;
 987                         if(mmio_basek == (u32)basek) {
 988                                 mmio_basek -= (uin32_t)(basek - basek_pri); // increase mem hole size to make sure it is on middle of pri node
 989                                 break;
 990                         }
 991                         basek_pri = basek;
 992                 }
 993         #endif
 994         }
 995         #endif
 996
 997
 998 #endif
 999
1000         idx = 0x10;
1001         for(i = 0; i < sysconf.nodes; i++) {
1002                 struct dram_base_mask_t d;
1003                 resource_t basek, limitk, sizek; // 4 1T
1004                 d = get_dram_base_mask(i);
1005
1006                 if(!(d.mask & 1)) continue;
1007                 basek = ((resource_t)(d.base & 0x1fffff00)) << 9; // could overflow, we may lost 6 bit here
1008                 limitk = ((resource_t)((d.mask + 0x00000100) & 0x1fffff00)) << 9 ;
1009                 sizek = limitk - basek;
1010
1011                 /* see if we need a hole from 0xa0000 to 0xbffff */
1012                 if ((basek < ((8*64)+(8*16))) && (sizek > ((8*64)+(16*16)))) {
1013                         ram_resource(dev, (idx | i), basek, ((8*64)+(8*16)) - basek);
1014                         idx += 0x10;
1015                         basek = (8*64)+(16*16);
1016                         sizek = limitk - ((8*64)+(16*16));
1017
1018                 }
1019
1020 //              printk(BIOS_DEBUG, "node %d : mmio_basek=%08x, basek=%08x, limitk=%08x\n", i, mmio_basek, basek, limitk);
1021
1022                 /* split the region to accomodate pci memory space */
1023                 if ( (basek < 4*1024*1024 ) && (limitk > mmio_basek) ) {
1024                         if (basek <= mmio_basek) {
1025                                 unsigned pre_sizek;
1026                                 pre_sizek = mmio_basek - basek;
1027                                 if(pre_sizek>0) {
1028                                         ram_resource(dev, (idx | i), basek, pre_sizek);
1029                                         idx += 0x10;
1030                                         sizek -= pre_sizek;
1031 #if CONFIG_WRITE_HIGH_TABLES==1
1032                                         if (high_tables_base==0) {
1033                                         /* Leave some space for ACPI, PIRQ and MP tables */
1034 #if CONFIG_GFXUMA == 1
1035                                                 high_tables_base = uma_memory_base - HIGH_MEMORY_SIZE;
1036 #else
1037                                                 high_tables_base = (mmio_basek * 1024) - HIGH_MEMORY_SIZE;
1038 #endif
1039                                                 high_tables_size = HIGH_MEMORY_SIZE;
1040                                                 printk(BIOS_DEBUG, " split: %dK table at =%08llx\n",
1041                                                         HIGH_MEMORY_SIZE / 1024, high_tables_base);
1042                                         }
1043 #endif
1044                                 }
1045                                 #if CONFIG_AMDMCT == 0
1046                                 #if CONFIG_HW_MEM_HOLE_SIZEK != 0
1047                                 if(reset_memhole) {
1048                                         struct sys_info *sysinfox = (struct sys_info *)((CONFIG_RAMTOP) - CONFIG_DCACHE_RAM_GLOBAL_VAR_SIZE); // in RAM
1049                                         struct mem_info *meminfo;
1050                                         meminfo = &sysinfox->meminfo[i];
1051                                         sizek += hoist_memory(mmio_basek,i, get_one_DCT(meminfo), sysconf.nodes);
1052                                 }
1053                                 #endif
1054                                 #endif
1055
1056                                 basek = mmio_basek;
1057                         }
1058                         if ((basek + sizek) <= 4*1024*1024) {
1059                                 sizek = 0;
1060                         }
1061                         else {
1062                                 basek = 4*1024*1024;
1063                                 sizek -= (4*1024*1024 - mmio_basek);
1064                         }
1065                 }
1066
1067 #if CONFIG_GFXUMA == 1
1068                 /* Deduct uma memory before reporting because
1069                  * this is what the mtrr code expects */
1070                 sizek -= uma_memory_size / 1024;
1071 #endif
1072                 ram_resource(dev, (idx | i), basek, sizek);
1073                 idx += 0x10;
1074 #if CONFIG_WRITE_HIGH_TABLES==1
1075                 printk(BIOS_DEBUG, "%d: mmio_basek=%08lx, basek=%08llx, limitk=%08llx\n",
1076                              i, mmio_basek, basek, limitk);
1077                 if (high_tables_base==0) {
1078                 /* Leave some space for ACPI, PIRQ and MP tables */
1079 #if CONFIG_GFXUMA == 1
1080                         high_tables_base = uma_memory_base - HIGH_MEMORY_SIZE;
1081 #else
1082                         high_tables_base = (limitk * 1024) - HIGH_MEMORY_SIZE;
1083 #endif
1084                         high_tables_size = HIGH_MEMORY_SIZE;
1085                 }
1086 #endif
1087         }
1088
1089 #if CONFIG_GFXUMA == 1
1090         add_uma_resource(dev, 7);
1091 #endif
1092
1093         for(link = dev->link_list; link; link = link->next) {
1094                 if (link->children) {
1095                         assign_resources(link);
1096                 }
1097         }
1098 }
1099
1100 static u32 amdfam10_domain_scan_bus(device_t dev, u32 max)
1101 {
1102         u32 reg;
1103         int i;
1104         struct bus *link;
1105         /* Unmap all of the HT chains */
1106         for(reg = 0xe0; reg <= 0xec; reg += 4) {
1107                 f1_write_config32(reg, 0);
1108         }
1109 #if CONFIG_EXT_CONF_SUPPORT == 1
1110         // all nodes
1111         for(i = 0; i< sysconf.nodes; i++) {
1112                 int index;
1113                 for(index = 0; index < 64; index++) {
1114                         pci_write_config32(__f1_dev[i], 0x110, index | (6<<28));
1115                         pci_write_config32(__f1_dev[i], 0x114, 0);
1116                 }
1117
1118         }
1119 #endif
1120
1121
1122         for(link = dev->link_list; link; link = link->next) {
1123                 max = pci_scan_bus(link, PCI_DEVFN(CONFIG_CDB, 0), 0xff, max);
1124         }
1125
1126         /* Tune the hypertransport transaction for best performance.
1127          * Including enabling relaxed ordering if it is safe.
1128          */
1129         get_fx_devs();
1130         for(i = 0; i < fx_devs; i++) {
1131                 device_t f0_dev;
1132                 f0_dev = __f0_dev[i];
1133                 if (f0_dev && f0_dev->enabled) {
1134                         u32 httc;
1135                         httc = pci_read_config32(f0_dev, HT_TRANSACTION_CONTROL);
1136                         httc &= ~HTTC_RSP_PASS_PW;
1137                         if (!dev->link_list->disable_relaxed_ordering) {
1138                                 httc |= HTTC_RSP_PASS_PW;
1139                         }
1140                         printk(BIOS_SPEW, "%s passpw: %s\n",
1141                                 dev_path(dev),
1142                                 (!dev->link_list->disable_relaxed_ordering)?
1143                                 "enabled":"disabled");
1144                         pci_write_config32(f0_dev, HT_TRANSACTION_CONTROL, httc);
1145                 }
1146         }
1147         return max;
1148 }
1149
1150 static struct device_operations pci_domain_ops = {
1151         .read_resources   = amdfam10_domain_read_resources,
1152         .set_resources    = amdfam10_domain_set_resources,
1153         .enable_resources = NULL,
1154         .init             = NULL,
1155         .scan_bus         = amdfam10_domain_scan_bus,
1156 #if CONFIG_MMCONF_SUPPORT_DEFAULT
1157         .ops_pci_bus      = &pci_ops_mmconf,
1158 #else
1159         .ops_pci_bus      = &pci_cf8_conf1,
1160 #endif
1161 };
1162
1163 static void sysconf_init(device_t dev) // first node
1164 {
1165         sysconf.sblk = (pci_read_config32(dev, 0x64)>>8) & 7; // don't forget sublink1
1166         sysconf.segbit = 0;
1167         sysconf.ht_c_num = 0;
1168
1169         unsigned ht_c_index;
1170
1171         for(ht_c_index=0; ht_c_index<32; ht_c_index++) {
1172                 sysconf.ht_c_conf_bus[ht_c_index] = 0;
1173         }
1174
1175         sysconf.nodes = ((pci_read_config32(dev, 0x60)>>4) & 7) + 1;
1176 #if CONFIG_MAX_PHYSICAL_CPUS > 8
1177         sysconf.nodes += (((pci_read_config32(dev, 0x160)>>4) & 7)<<3);
1178 #endif
1179
1180         sysconf.enabled_apic_ext_id = 0;
1181         sysconf.lift_bsp_apicid = 0;
1182
1183         /* Find the bootstrap processors apicid */
1184         sysconf.bsp_apicid = lapicid();
1185         sysconf.apicid_offset = sysconf.bsp_apicid;
1186
1187 #if (CONFIG_ENABLE_APIC_EXT_ID == 1)
1188         if (pci_read_config32(dev, 0x68) & (HTTC_APIC_EXT_ID|HTTC_APIC_EXT_BRD_CST))
1189         {
1190                 sysconf.enabled_apic_ext_id = 1;
1191         }
1192         #if (CONFIG_APIC_ID_OFFSET>0)
1193         if(sysconf.enabled_apic_ext_id) {
1194                 if(sysconf.bsp_apicid == 0) {
1195                         /* bsp apic id is not changed */
1196                         sysconf.apicid_offset = CONFIG_APIC_ID_OFFSET;
1197                 } else {
1198                         sysconf.lift_bsp_apicid = 1;
1199                 }
1200         }
1201         #endif
1202 #endif
1203 }
1204
1205 static void add_more_links(device_t dev, unsigned total_links)
1206 {
1207         struct bus *link, *last = NULL;
1208         int link_num;
1209
1210         for (link = dev->link_list; link; link = link->next)
1211                 last = link;
1212
1213         if (last) {
1214                 int links = total_links - last->link_num;
1215                 link_num = last->link_num;
1216                 if (links > 0) {
1217                         link = malloc(links*sizeof(*link));
1218                         if (!link)
1219                                 die("Couldn't allocate more links!\n");
1220                         memset(link, 0, links*sizeof(*link));
1221                         last->next = link;
1222                 }
1223         }
1224         else {
1225                 link_num = -1;
1226                 link = malloc(total_links*sizeof(*link));
1227                 memset(link, 0, total_links*sizeof(*link));
1228                 dev->link_list = link;
1229         }
1230
1231         for (link_num = link_num + 1; link_num < total_links; link_num++) {
1232                 link->link_num = link_num;
1233                 link->dev = dev;
1234                 link->next = link + 1;
1235                 last = link;
1236                 link = link->next;
1237         }
1238         last->next = NULL;
1239 }
1240
1241 static u32 cpu_bus_scan(device_t dev, u32 max)
1242 {
1243         struct bus *cpu_bus;
1244         device_t dev_mc;
1245 #if CONFIG_CBB
1246         device_t pci_domain;
1247 #endif
1248         int i,j;
1249         int nodes;
1250         unsigned nb_cfg_54;
1251         unsigned siblings;
1252         int cores_found;
1253         int disable_siblings;
1254         unsigned ApicIdCoreIdSize;
1255
1256         nb_cfg_54 = 0;
1257         ApicIdCoreIdSize = (cpuid_ecx(0x80000008)>>12 & 0xf);
1258         if(ApicIdCoreIdSize) {
1259                 siblings = (1<<ApicIdCoreIdSize)-1;
1260         } else {
1261                 siblings = 3; //quad core
1262         }
1263
1264         disable_siblings = !CONFIG_LOGICAL_CPUS;
1265 #if CONFIG_LOGICAL_CPUS == 1
1266         get_option(&disable_siblings, "multi_core");
1267 #endif
1268
1269         // How can I get the nb_cfg_54 of every node's nb_cfg_54 in bsp???
1270         nb_cfg_54 = read_nb_cfg_54();
1271
1272 #if CONFIG_CBB
1273         dev_mc = dev_find_slot(0, PCI_DEVFN(CONFIG_CDB, 0)); //0x00
1274         if(dev_mc && dev_mc->bus) {
1275                 printk(BIOS_DEBUG, "%s found", dev_path(dev_mc));
1276                 pci_domain = dev_mc->bus->dev;
1277                 if(pci_domain && (pci_domain->path.type == DEVICE_PATH_PCI_DOMAIN)) {
1278                         printk(BIOS_DEBUG, "\n%s move to ",dev_path(dev_mc));
1279                         dev_mc->bus->secondary = CONFIG_CBB; // move to 0xff
1280                         printk(BIOS_DEBUG, "%s",dev_path(dev_mc));
1281
1282                 } else {
1283                         printk(BIOS_DEBUG, " but it is not under pci_domain directly ");
1284                 }
1285                 printk(BIOS_DEBUG, "\n");
1286         }
1287         dev_mc = dev_find_slot(CONFIG_CBB, PCI_DEVFN(CONFIG_CDB, 0));
1288         if(!dev_mc) {
1289                 dev_mc = dev_find_slot(0, PCI_DEVFN(0x18, 0));
1290                 if (dev_mc && dev_mc->bus) {
1291                         printk(BIOS_DEBUG, "%s found\n", dev_path(dev_mc));
1292                         pci_domain = dev_mc->bus->dev;
1293                         if(pci_domain && (pci_domain->path.type == DEVICE_PATH_PCI_DOMAIN)) {
1294                                 if((pci_domain->link_list) && (pci_domain->link_list->children == dev_mc)) {
1295                                         printk(BIOS_DEBUG, "%s move to ",dev_path(dev_mc));
1296                                         dev_mc->bus->secondary = CONFIG_CBB; // move to 0xff
1297                                         printk(BIOS_DEBUG, "%s\n",dev_path(dev_mc));
1298                                         while(dev_mc){
1299                                                 printk(BIOS_DEBUG, "%s move to ",dev_path(dev_mc));
1300                                                 dev_mc->path.pci.devfn -= PCI_DEVFN(0x18,0);
1301                                                 printk(BIOS_DEBUG, "%s\n",dev_path(dev_mc));
1302                                                 dev_mc = dev_mc->sibling;
1303                                         }
1304                                 }
1305                         }
1306                 }
1307         }
1308
1309 #endif
1310
1311         dev_mc = dev_find_slot(CONFIG_CBB, PCI_DEVFN(CONFIG_CDB, 0));
1312         if (!dev_mc) {
1313                 printk(BIOS_ERR, "%02x:%02x.0 not found", CONFIG_CBB, CONFIG_CDB);
1314                 die("");
1315         }
1316
1317         sysconf_init(dev_mc);
1318
1319         nodes = sysconf.nodes;
1320
1321 #if CONFIG_CBB && (NODE_NUMS > 32)
1322         if(nodes>32) { // need to put node 32 to node 63 to bus 0xfe
1323                 if(pci_domain->link_list && !pci_domain->link_list->next) {
1324                         struct bus *new_link = new_link(pci_domain);
1325                         pci_domain->link_list->next = new_link;
1326                         new_link->link_num = 1;
1327                         new_link->dev = pci_domain;
1328                         new_link->children = 0;
1329                         printk(BIOS_DEBUG, "%s links now 2\n", dev_path(pci_domain));
1330                 }
1331                 pci_domain->link_list->next->secondary = CONFIG_CBB - 1;
1332         }
1333 #endif
1334         /* Find which cpus are present */
1335         cpu_bus = dev->link_list;
1336         for(i = 0; i < nodes; i++) {
1337                 device_t cdb_dev, cpu;
1338                 struct device_path cpu_path;
1339                 unsigned busn, devn;
1340                 struct bus *pbus;
1341
1342                 busn = CONFIG_CBB;
1343                 devn = CONFIG_CDB+i;
1344                 pbus = dev_mc->bus;
1345 #if CONFIG_CBB && (NODE_NUMS > 32)
1346                 if(i>=32) {
1347                         busn--;
1348                         devn-=32;
1349                         pbus = pci_domain->link_list->next);
1350                 }
1351 #endif
1352
1353                 /* Find the cpu's pci device */
1354                 cdb_dev = dev_find_slot(busn, PCI_DEVFN(devn, 0));
1355                 if (!cdb_dev) {
1356                         /* If I am probing things in a weird order
1357                          * ensure all of the cpu's pci devices are found.
1358                          */
1359                         int fn;
1360                         for(fn = 0; fn <= 5; fn++) { //FBDIMM?
1361                                 cdb_dev = pci_probe_dev(NULL, pbus,
1362                                         PCI_DEVFN(devn, fn));
1363                         }
1364                         cdb_dev = dev_find_slot(busn, PCI_DEVFN(devn, 0));
1365                 }
1366                 if (cdb_dev) {
1367                         /* Ok, We need to set the links for that device.
1368                          * otherwise the device under it will not be scanned
1369                          */
1370                         int linknum;
1371 #if CONFIG_HT3_SUPPORT==1
1372                         linknum = 8;
1373 #else
1374                         linknum = 4;
1375 #endif
1376                         add_more_links(cdb_dev, linknum);
1377                 }
1378
1379                 cores_found = 0; // one core
1380                 cdb_dev = dev_find_slot(busn, PCI_DEVFN(devn, 3));
1381                 if (cdb_dev && cdb_dev->enabled) {
1382                         j = pci_read_config32(cdb_dev, 0xe8);
1383                         cores_found = (j >> 12) & 3; // dev is func 3
1384                         if (siblings > 3)
1385                                 cores_found |= (j >> 13) & 4;
1386                         printk(BIOS_DEBUG, "  %s siblings=%d\n", dev_path(cdb_dev), cores_found);
1387                 }
1388
1389                 u32 jj;
1390                 if(disable_siblings) {
1391                         jj = 0;
1392                 } else
1393                 {
1394                         jj = cores_found;
1395                 }
1396
1397                 for (j = 0; j <=jj; j++ ) {
1398
1399                         /* Build the cpu device path */
1400                         cpu_path.type = DEVICE_PATH_APIC;
1401                         cpu_path.apic.apic_id = i * (nb_cfg_54?(siblings+1):1) + j * (nb_cfg_54?1:64); // ?
1402
1403                         /* See if I can find the cpu */
1404                         cpu = find_dev_path(cpu_bus, &cpu_path);
1405
1406                         /* Enable the cpu if I have the processor */
1407                         if (cdb_dev && cdb_dev->enabled) {
1408                                 if (!cpu) {
1409                                         cpu = alloc_dev(cpu_bus, &cpu_path);
1410                                 }
1411                                 if (cpu) {
1412                                         cpu->enabled = 1;
1413                                 }
1414                         }
1415
1416                         /* Disable the cpu if I don't have the processor */
1417                         if (cpu && (!cdb_dev || !cdb_dev->enabled)) {
1418                                 cpu->enabled = 0;
1419                         }
1420
1421                         /* Report what I have done */
1422                         if (cpu) {
1423                                 cpu->path.apic.node_id = i;
1424                                 cpu->path.apic.core_id = j;
1425         #if (CONFIG_ENABLE_APIC_EXT_ID == 1) && (CONFIG_APIC_ID_OFFSET>0)
1426                                 if(sysconf.enabled_apic_ext_id) {
1427                                         if(sysconf.lift_bsp_apicid) {
1428                                                 cpu->path.apic.apic_id += sysconf.apicid_offset;
1429                                         } else
1430                                         {
1431                                                 if (cpu->path.apic.apic_id != 0)
1432                                                         cpu->path.apic.apic_id += sysconf.apicid_offset;
1433                                         }
1434                                 }
1435         #endif
1436                                 printk(BIOS_DEBUG, "CPU: %s %s\n",
1437                                         dev_path(cpu), cpu->enabled?"enabled":"disabled");
1438                         }
1439
1440                 } //j
1441         }
1442         return max;
1443 }
1444
1445 static void cpu_bus_init(device_t dev)
1446 {
1447         initialize_cpus(dev->link_list);
1448 }
1449
1450 static void cpu_bus_noop(device_t dev)
1451 {
1452 }
1453
1454 static void cpu_bus_read_resources(device_t dev)
1455 {
1456 }
1457
1458 static void cpu_bus_set_resources(device_t dev)
1459 {
1460         struct resource *resource = find_resource(dev, 0xc0010058);
1461         if (resource) {
1462                 report_resource_stored(dev, resource, " <mmconfig>");
1463         }
1464         pci_dev_set_resources(dev);
1465 }
1466
1467 static struct device_operations cpu_bus_ops = {
1468         .read_resources   = cpu_bus_read_resources,
1469         .set_resources    = cpu_bus_set_resources,
1470         .enable_resources = cpu_bus_noop,
1471         .init             = cpu_bus_init,
1472         .scan_bus         = cpu_bus_scan,
1473 };
1474
1475 static void root_complex_enable_dev(struct device *dev)
1476 {
1477         /* Set the operations if it is a special bus type */
1478         if (dev->path.type == DEVICE_PATH_PCI_DOMAIN) {
1479                 dev->ops = &pci_domain_ops;
1480         }
1481         else if (dev->path.type == DEVICE_PATH_APIC_CLUSTER) {
1482                 dev->ops = &cpu_bus_ops;
1483         }
1484 }
1485
1486 struct chip_operations northbridge_amd_amdfam10_root_complex_ops = {
1487         CHIP_NAME("AMD FAM10 Root Complex")
1488         .enable_dev = root_complex_enable_dev,
1489 };