src/southbridge/amd/rs780/gfx.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2010 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 /*
  21  *  for rs780 internal graphics device
  22  *  device id of internal grphics:
  23  *      RS780:  0x9610
  24  *      RS780C: 0x9611
  25  *      RS780M: 0x9612
  26  *      RS780MC:0x9613
  27  *      RS780E: 0x9615
  28  *      RS785G: 0x9710 - just works, not much tested
  29  *      RS785C: 0x9711
  30  *      RS785M: 0x9712
  31  *      RS785MC:0x9713
  32  *      RS785D: 0x9714
  33  */
  34 #include <console/console.h>
  35 #include <device/device.h>
  36 #include <device/pci.h>
  37 #include <device/pci_ids.h>
  38 #include <device/pci_ops.h>
  39 #include <delay.h>
  40 #include <cpu/x86/msr.h>
  41 #include "rs780.h"
  42 extern int is_dev3_present(void);
  43 void set_pcie_reset(void);
  44 void set_pcie_dereset(void);
  45
  46 extern uint64_t uma_memory_base, uma_memory_size;
  47
  48 /* Trust the original resource allocation. Don't do it again. */
  49 #undef DONT_TRUST_RESOURCE_ALLOCATION
  50 //#define DONT_TRUST_RESOURCE_ALLOCATION
  51
  52 #define CLK_CNTL_INDEX  0x8
  53 #define CLK_CNTL_DATA   0xC
  54
  55 /* The Integrated Info Table. */
  56 ATOM_INTEGRATED_SYSTEM_INFO_V2 vgainfo;
  57
  58 #ifdef UNUSED_CODE
  59 static u32 clkind_read(device_t dev, u32 index)
  60 {
  61         u32     gfx_bar2 = pci_read_config32(dev, 0x18) & ~0xF;
  62
  63         *(u32*)(gfx_bar2+CLK_CNTL_INDEX) = index & 0x7F;
  64         return *(u32*)(gfx_bar2+CLK_CNTL_DATA);
  65 }
  66 #endif
  67
  68 static void clkind_write(device_t dev, u32 index, u32 data)
  69 {
  70         u32     gfx_bar2 = pci_read_config32(dev, 0x18) & ~0xF;
  71         /* printk(BIOS_DEBUG, "gfx bar 2 %02x\n", gfx_bar2); */
  72
  73         *(u32*)(gfx_bar2+CLK_CNTL_INDEX) = index | 1<<7;
  74         *(u32*)(gfx_bar2+CLK_CNTL_DATA)  = data;
  75 }
  76
  77 /*
  78 * pci_dev_read_resources thinks it is a IO type.
  79 * We have to force it to mem type.
  80 */
  81 static void rs780_gfx_read_resources(device_t dev)
  82 {
  83         printk(BIOS_DEBUG, "rs780_gfx_read_resources.\n");
  84
  85         /* The initial value of 0x24 is 0xFFFFFFFF, which is confusing.
  86            Even if we write 0xFFFFFFFF into it, it will be 0xFFF00000,
  87            which tells us it is a memory address base.
  88          */
  89         pci_write_config32(dev, 0x24, 0x00000000);
  90
  91         /* Get the normal pci resources of this device */
  92         pci_dev_read_resources(dev);
  93         compact_resources(dev);
  94 }
  95
  96 typedef struct _MMIORANGE
  97 {
  98         u32     Base;
  99         u32     Limit;
 100         u8      Attribute;
 101 } MMIORANGE;
 102
 103 MMIORANGE MMIO[8], CreativeMMIO[8];
 104
 105 #define CIM_STATUS u32
 106 #define CIM_SUCCESS 0x00000000
 107 #define CIM_ERROR       0x80000000
 108 #define CIM_UNSUPPORTED 0x80000001
 109 #define CIM_DISABLEPORT 0x80000002
 110
 111 #define MMIO_ATTRIB_NP_ONLY     1
 112 #define MMIO_ATTRIB_BOTTOM_TO_TOP 1<<1
 113 #define MMIO_ATTRIB_SKIP_ZERO 1<<2
 114
 115 #ifdef DONT_TRUST_RESOURCE_ALLOCATION
 116 static MMIORANGE* AllocMMIO(MMIORANGE* pMMIO)
 117 {
 118         int i;
 119         for (i=0; i<8; i++) {
 120                 if (pMMIO[i].Limit == 0)
 121                                 return &pMMIO[i];
 122         }
 123         return 0;
 124 }
 125
 126 static void FreeMMIO(MMIORANGE* pMMIO)
 127 {
 128         pMMIO->Base = 0;
 129         pMMIO->Limit = 0;
 130 }
 131
 132 static u32 SetMMIO(u32 Base, u32 Limit, u8 Attribute, MMIORANGE *pMMIO)
 133 {
 134         int i;
 135         MMIORANGE * TempRange;
 136         for(i=0; i<8; i++)
 137         {
 138                 if(pMMIO[i].Attribute != Attribute && Base >= pMMIO[i].Base && Limit <= pMMIO[i].Limit)
 139                 {
 140                         TempRange = AllocMMIO(pMMIO);
 141                         if(TempRange == 0) return 0x80000000;
 142                         TempRange->Base = Limit;
 143                         TempRange->Limit = pMMIO[i].Limit;
 144                         TempRange->Attribute = pMMIO[i].Attribute;
 145                         pMMIO[i].Limit = Base;
 146                 }
 147         }
 148         TempRange = AllocMMIO(pMMIO);
 149         if(TempRange == 0) return 0x80000000;
 150         TempRange->Base = Base;
 151         TempRange->Limit = Limit;
 152         TempRange->Attribute = Attribute;
 153         return 0;
 154 }
 155
 156 static u8 FinalizeMMIO(MMIORANGE *pMMIO)
 157 {
 158         int i, j, n = 0;
 159         for(i=0; i<8; i++)
 160         {
 161                 if (pMMIO[i].Base == pMMIO[i].Limit)
 162                 {
 163                         FreeMMIO(&pMMIO[i]);
 164                         continue;
 165                 }
 166                 for(j=0; j<i; j++)
 167                 {
 168                         if (i!=j && pMMIO[i].Attribute == pMMIO[j].Attribute)
 169                         {
 170                                 if (pMMIO[i].Base == pMMIO[j].Limit)
 171                                 {
 172                                         pMMIO[j].Limit = pMMIO[i].Limit;
 173                                          FreeMMIO(&pMMIO[i]);
 174                                 }
 175                                 if (pMMIO[i].Limit == pMMIO[j].Base)
 176                                 {
 177                                         pMMIO[j].Base = pMMIO[i].Base;
 178                                    FreeMMIO(&pMMIO[i]);
 179                                 }
 180                         }
 181                 }
 182         }
 183         for (i=0; i<8; i++)
 184         {
 185                 if (pMMIO[i].Limit != 0) n++;
 186         }
 187         return n;
 188 }
 189
 190 static CIM_STATUS GetCreativeMMIO(MMIORANGE *pMMIO)
 191 {
 192         CIM_STATUS Status = CIM_UNSUPPORTED;
 193         u8 Bus, Dev, Reg, BusStart, BusEnd;
 194         u32     Value;
 195         device_t dev0x14 = dev_find_slot(0, PCI_DEVFN(0x14, 4));
 196         device_t tempdev;
 197         Value = pci_read_config32(dev0x14, 0x18);
 198         BusStart = (Value >> 8) & 0xFF;
 199         BusEnd = (Value >> 16) & 0xFF;
 200         for(Bus = BusStart; Bus <= BusEnd; Bus++)
 201         {
 202                 for(Dev = 0; Dev <= 0x1f; Dev++)
 203                 {
 204                         tempdev = dev_find_slot(Bus, Dev << 3);
 205                         Value = pci_read_config32(tempdev, 0);
 206                         printk(BIOS_DEBUG, "Dev ID %x \n", Value);
 207                         if((Value & 0xffff) == 0x1102)
 208                         {//Creative
 209                                 //Found Creative SB
 210                                 u32     MMIOStart = 0xffffffff;
 211                                 u32 MMIOLimit = 0;
 212                                 for(Reg = 0x10; Reg < 0x20; Reg+=4)
 213                                 {
 214                                         u32     BaseA, LimitA;
 215                                         BaseA = pci_read_config32(tempdev, Reg);
 216                                         Value = BaseA;
 217                                         if(!(Value & 0x01))
 218                                         {
 219                                                 Value = Value & 0xffffff00;
 220                                                 if(Value !=  0)
 221                                                 {
 222                                                         if(MMIOStart > Value)
 223                                                                 MMIOStart = Value;
 224                                                         LimitA = 0xffffffff;
 225                                                         //WritePCI(PciAddress,AccWidthUint32,&LimitA);
 226                                                         pci_write_config32(tempdev, Reg, LimitA);
 227                                                         //ReadPCI(PciAddress,AccWidthUint32,&LimitA);
 228                                                         LimitA = pci_read_config32(tempdev, Reg);
 229                                                         LimitA = Value + (~LimitA + 1);
 230                                                         //WritePCI(PciAddress,AccWidthUint32,&BaseA);
 231                                                         pci_write_config32(tempdev, Reg, BaseA);
 232                                                         if (LimitA > MMIOLimit)
 233                                                                 MMIOLimit = LimitA;
 234                                                 }
 235                                         }
 236                                 }
 237                                 printk(BIOS_DEBUG, " MMIOStart %x MMIOLimit %x \n", MMIOStart, MMIOLimit);
 238                                 if (MMIOStart < MMIOLimit)
 239                                 {
 240                                         Status = SetMMIO(MMIOStart>>8, MMIOLimit>>8, 0x80, pMMIO);
 241                                         if(Status == CIM_ERROR) return Status;
 242                                 }
 243                         }
 244                 }
 245         }
 246         if(Status == CIM_SUCCESS)
 247         {
 248                 //Lets optimize MMIO
 249                 if(FinalizeMMIO(pMMIO) > 4)
 250                 {
 251                         Status = CIM_ERROR;
 252                 }
 253         }
 254
 255         return Status;
 256 }
 257
 258 static void ProgramMMIO(MMIORANGE *pMMIO, u8 LinkID, u8 Attribute)
 259 {
 260         int i, j, n = 7;
 261         device_t k8_f1;
 262
 263         k8_f1 = dev_find_slot(0, PCI_DEVFN(0x18, 1));
 264
 265         for(i = 0; i < 8; i++)
 266         {
 267                 int k = 0, MmioReg;
 268                 u32 Base = 0;
 269                 u32 Limit = 0;
 270                 for(j = 0; j < 8; j++)
 271                 {
 272                         if (Base < pMMIO[j].Base)
 273                         {
 274                                 Base = pMMIO[j].Base;
 275                                 k = j;
 276                         }
 277                 }
 278                 if(pMMIO[k].Limit != 0)
 279                 {
 280                         if(Attribute & MMIO_ATTRIB_NP_ONLY && pMMIO[k].Attribute == 0 )
 281                         {
 282                                 Base = 0;
 283                         }
 284                         else
 285                         {
 286                                 Base = pMMIO[k].Base | 0x3;
 287                                 Limit= ((pMMIO[k].Limit - 1) & 0xffffff00) | pMMIO[k].Attribute | (LinkID << 4);
 288                         }
 289                         FreeMMIO(&pMMIO[k]);
 290                 }
 291                 if (Attribute & MMIO_ATTRIB_SKIP_ZERO && Base == 0 && Limit == 0) continue;
 292                 MmioReg = (Attribute & MMIO_ATTRIB_BOTTOM_TO_TOP)?n:(7-n);
 293                 n--;
 294                 //RWPCI(PCI_ADDRESS(0,CPU_DEV,CPU_F1,0x80+MmioReg*8),AccWidthUint32 |S3_SAVE,0x0,0x0);
 295                 pci_write_config32(k8_f1, 0x80+MmioReg*8, 0);
 296
 297                 //WritePCI(PCI_ADDRESS(0,CPU_DEV,CPU_F1,0x84+MmioReg*8),AccWidthUint32 |S3_SAVE,&Limit);
 298                 pci_write_config32(k8_f1, 0x84+MmioReg*8, Limit);
 299
 300                 //WritePCI(PCI_ADDRESS(0,CPU_DEV,CPU_F1,0x80+MmioReg*8),AccWidthUint32 |S3_SAVE,&Base);
 301                 pci_write_config32(k8_f1, 0x80+MmioReg*8, Base);
 302         }
 303 }
 304 #endif
 305
 306 #define GFX_CONFIG_DDI1         0x04
 307 #define GFX_CONFIG_DDI2         0x08
 308 #define GFX_CONFIG_DDI          (GFX_CONFIG_DDI1 | GFX_CONFIG_DDI2)
 309
 310 /**
 311  * Force poweron pads for lanes used for DDI
 312  * reference CIMx PCIEL_PowerOnDDILanes()
 313  *
 314  * Inactive    B_PRX_PDNB_FDIS  B_PTX_PDNB_FDIS
 315  *  Lanes
 316  * Lanes  0-1   Bit  8           Bit 0
 317  * Lanes  2-3   Bit  9           Bit 1
 318  * Lanes  4-5   Bit 10           Bit 2
 319  * Lanes  6-7   Bit 11           Bit 3
 320  * Lanes  8-9   Bit 12           Bit 4
 321  * Lanes 10-11  Bit 13           Bit 5
 322  * Lanes 12-13  Bit 14           Bit 6
 323  * Lanes 14-15  Bit 15           Bit 7
 324  */
 325 static void poweron_ddi_lanes(device_t nb_dev)
 326 {
 327         u8 i;
 328         u32 gfx_cfg = 0;
 329         u32 ddi_pads = 0;
 330
 331         ddi_pads = ~(nbpcie_ind_read_index(nb_dev, 0x65)); /* save original setting */
 332         gfx_cfg = nbmisc_read_index(nb_dev, 0x74);
 333         for (i = 0; i < 3 ; i++) {
 334                 if (gfx_cfg & GFX_CONFIG_DDI) {
 335                         ddi_pads |= (3 << (i * 2));
 336                 }
 337                 gfx_cfg >>= 8;
 338         }
 339         ddi_pads |= ddi_pads << 8; /* both TX and RX */
 340         nbpcie_ind_write_index(nb_dev, 0x65, ~ddi_pads);
 341 }
 342
 343 static void internal_gfx_pci_dev_init(struct device *dev)
 344 {
 345         unsigned char * bpointer;
 346         volatile u32 * GpuF0MMReg;
 347         volatile u32 * pointer;
 348         int i;
 349         u16 command;
 350         u32 value;
 351         u16 deviceid, vendorid;
 352         device_t nb_dev = dev_find_slot(0, 0);
 353         device_t k8_f2 = dev_find_slot(0, PCI_DEVFN(0x18, 2));
 354         device_t k8_f0 = dev_find_slot(0, PCI_DEVFN(0x18, 0));
 355         static const u8 ht_freq_lookup [] = {2, 0, 4, 0, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 0, 0, 28, 30, 32};
 356         static const u8 ht_width_lookup [] = {8, 16, 0, 0, 2, 4, 0, 0};
 357         static const u16 memclk_lookup_fam0F [] = {100, 0, 133, 0, 0, 166, 0, 200};
 358         static const u16 memclk_lookup_fam10 [] = {200, 266, 333, 400, 533, 667, 800, 800};
 359
 360         /* We definetely will use this in future. Just leave it here. */
 361         /*struct southbridge_amd_rs780_config *cfg =
 362            (struct southbridge_amd_rs780_config *)dev->chip_info;*/
 363
 364         deviceid = pci_read_config16(dev, PCI_DEVICE_ID);
 365         vendorid = pci_read_config16(dev, PCI_VENDOR_ID);
 366         printk(BIOS_DEBUG, "internal_gfx_pci_dev_init device=%x, vendor=%x.\n",
 367              deviceid, vendorid);
 368
 369         command = pci_read_config16(dev, 0x04);
 370         command |= 0x7;
 371         pci_write_config16(dev, 0x04, command);
 372
 373         /* Clear vgainfo. */
 374         bpointer = (unsigned char *) &vgainfo;
 375         for(i=0; i<sizeof(ATOM_INTEGRATED_SYSTEM_INFO_V2); i++)
 376         {
 377                 *bpointer = 0;
 378                 bpointer++;
 379         }
 380
 381         GpuF0MMReg = (u32 *)pci_read_config32(dev, 0x18);
 382
 383         /* GFX_InitFBAccess. */
 384         value = nbmc_read_index(nb_dev, 0x10);
 385         *(GpuF0MMReg + 0x2000/4) = 0x11;
 386         *(GpuF0MMReg + 0x2180/4) = ((value&0xff00)>>8)|((value&0xff000000)>>8);
 387         *(GpuF0MMReg + 0x2c04/4) = ((value&0xff00)<<8);
 388         *(GpuF0MMReg + 0x5428/4) = ((value&0xffff0000)+0x10000)-((value&0xffff)<<16);
 389         *(GpuF0MMReg + 0xF774/4) = 0xffffffff;
 390         *(GpuF0MMReg + 0xF770/4) = 0x00000001;
 391         *(GpuF0MMReg + 0x2000/4) = 0x00000011;
 392         *(GpuF0MMReg + 0x200c/4) = 0x00000020;
 393         *(GpuF0MMReg + 0x2010/4) = 0x10204810;
 394         *(GpuF0MMReg + 0x2010/4) = 0x00204810;
 395         *(GpuF0MMReg + 0x2014/4) = 0x10408810;
 396         *(GpuF0MMReg + 0x2014/4) = 0x00408810;
 397         *(GpuF0MMReg + 0x2414/4) = 0x00000080;
 398         *(GpuF0MMReg + 0x2418/4) = 0x84422415;
 399         *(GpuF0MMReg + 0x2418/4) = 0x04422415;
 400         *(GpuF0MMReg + 0x5490/4) = 0x00000001;
 401         *(GpuF0MMReg + 0x7de4/4) |= (1<<3) | (1<<4);
 402         /* Force allow LDT_STOP Cool'n'Quiet workaround. */
 403         *(GpuF0MMReg + 0x655c/4) |= 1<<4;
 404
 405         // disable write combining, needed for stability
 406         // reference bios does this only for RS780 rev A11
 407         // need to figure out why we need it for all revs
 408         *(GpuF0MMReg + 0x2000/4) = 0x00000010;
 409         *(GpuF0MMReg + 0x2408/4) = 1 << 9;
 410         *(GpuF0MMReg + 0x2000/4) = 0x00000011;
 411
 412         /* GFX_InitFBAccess finished. */
 413
 414 #if (CONFIG_GFXUMA == 1) /* for UMA mode. */
 415         /* GFX_StartMC. */
 416         set_nbmc_enable_bits(nb_dev, 0x02, 0x00000000, 0x80000000);
 417         set_nbmc_enable_bits(nb_dev, 0x01, 0x00000000, 0x00000001);
 418         set_nbmc_enable_bits(nb_dev, 0x01, 0x00000000, 0x00000004);
 419         set_nbmc_enable_bits(nb_dev, 0x01, 0x00040000, 0x00000000);
 420         set_nbmc_enable_bits(nb_dev, 0xB1, 0xFFFF0000, 0x00000040);
 421         set_nbmc_enable_bits(nb_dev, 0xC3, 0x00000000, 0x00000001);
 422         set_nbmc_enable_bits(nb_dev, 0x07, 0xFFFFFFFF, 0x00000018);
 423         set_nbmc_enable_bits(nb_dev, 0x06, 0xFFFFFFFF, 0x00000102);
 424         set_nbmc_enable_bits(nb_dev, 0x09, 0xFFFFFFFF, 0x40000008);
 425         set_nbmc_enable_bits(nb_dev, 0x06, 0x00000000, 0x80000000);
 426         /* GFX_StartMC finished. */
 427 #else
 428         /* for SP mode. */
 429         set_nbmc_enable_bits(nb_dev, 0xaa, 0xf0, 0x30);
 430         set_nbmc_enable_bits(nb_dev, 0xce, 0xf0, 0x30);
 431         set_nbmc_enable_bits(nb_dev, 0xca, 0xff000000, 0x47000000);
 432         set_nbmc_enable_bits(nb_dev, 0xcb, 0x3f000000, 0x01000000);
 433         set_nbmc_enable_bits(nb_dev, 0x01, 0, 1<<0);
 434         set_nbmc_enable_bits(nb_dev, 0x04, 0, 1<<31);
 435         set_nbmc_enable_bits(nb_dev, 0xb4, 0x3f, 0x3f);
 436         set_nbmc_enable_bits(nb_dev, 0xb4, 0, 1<<6);
 437         set_nbmc_enable_bits(nb_dev, 0xc3, 1<<11, 0);
 438         set_nbmc_enable_bits(nb_dev, 0xa0, 1<<29, 0);
 439         nbmc_write_index(nb_dev, 0xa4, 0x3484576f);
 440         nbmc_write_index(nb_dev, 0xa5, 0x222222df);
 441         nbmc_write_index(nb_dev, 0xa6, 0x00000000);
 442         nbmc_write_index(nb_dev, 0xa7, 0x00000000);
 443         set_nbmc_enable_bits(nb_dev, 0xc3, 1<<8, 0);
 444         udelay(10);
 445         set_nbmc_enable_bits(nb_dev, 0xc3, 1<<9, 0);
 446         udelay(10);
 447         set_nbmc_enable_bits(nb_dev, 0x01, 0, 1<<2);
 448         udelay(200);
 449         set_nbmc_enable_bits(nb_dev, 0x01, 0, 1<<3);
 450         set_nbmc_enable_bits(nb_dev, 0xa0, 0, 1<<31);
 451         udelay(500);
 452         set_nbmc_enable_bits(nb_dev, 0x02, 0, 1<<31);
 453         set_nbmc_enable_bits(nb_dev, 0xa0, 0, 1<<30);
 454         set_nbmc_enable_bits(nb_dev, 0xa0, 1<<31, 0);
 455         set_nbmc_enable_bits(nb_dev, 0xa0, 0, 1<<29);
 456         nbmc_write_index(nb_dev, 0xa4, 0x23484576);
 457         nbmc_write_index(nb_dev, 0xa5, 0x00000000);
 458         nbmc_write_index(nb_dev, 0xa6, 0x00000000);
 459         nbmc_write_index(nb_dev, 0xa7, 0x00000000);
 460         /* GFX_StartMC finished. */
 461
 462         /* GFX_SPPowerManagment, don't care for new. */
 463         /* Post MC Init table programming. */
 464         set_nbmc_enable_bits(nb_dev, 0xac, ~(0xfffffff0), 0x0b);
 465
 466         /* Do we need Write and Read Calibration? */
 467         /* GFX_Init finished. */
 468 #endif
 469
 470         /* GFX_InitIntegratedInfo. */
 471         /* fill the Integrated Info Table. */
 472         vgainfo.sHeader.usStructureSize = sizeof(ATOM_INTEGRATED_SYSTEM_INFO_V2);
 473         vgainfo.sHeader.ucTableFormatRevision = 1;
 474         vgainfo.sHeader.ucTableContentRevision = 2;
 475
 476 #if (CONFIG_GFXUMA == 0) /* SP mode. */
 477         // Side port support is incomplete, do not use it
 478         // These parameters must match the motherboard
 479         vgainfo.ulBootUpSidePortClock = 667*100;
 480         vgainfo.ucMemoryType = 3;  // 3=ddr3 sp mem, 2=ddr2 sp mem
 481         vgainfo.ulMinSidePortClock = 333*100;
 482 #endif
 483
 484         vgainfo.ulBootUpEngineClock = 500 * 100;                // setup option on reference BIOS, 500 is default
 485
 486         // find the DDR memory frequency
 487         if (is_family10h()) {
 488                 value = pci_read_config32(k8_f2, 0x94);         // read channel 0 DRAM Configuration High Register
 489                 if (extractbit(value, 14))                      // if channel 0 disabled, channel 1 must have memory
 490                         value = pci_read_config32(k8_f2, 0x194);// read channel 1 DRAM Configuration High Register
 491                 vgainfo.ulBootUpUMAClock = memclk_lookup_fam10 [extractbits (value, 0, 2)] * 100;
 492         }
 493         if (is_family0Fh()) {
 494                 value = pci_read_config32(k8_f2, 0x94);
 495                 vgainfo.ulBootUpUMAClock = memclk_lookup_fam0F [extractbits (value, 20, 22)] * 100;
 496         }
 497
 498         /* UMA Channel Number: 1 or 2. */
 499         vgainfo.ucUMAChannelNumber = 1;
 500         if (is_family0Fh()) {
 501                 value = pci_read_config32(k8_f2, 0x90);
 502         if (extractbit(value, 11))  // 128-bit mode
 503                 vgainfo.ucUMAChannelNumber = 2;
 504         }
 505         if (is_family10h()) {
 506                 u32 dch0 = pci_read_config32(k8_f2, 0x94);
 507                 u32 dch1 = pci_read_config32(k8_f2, 0x194);
 508                 if (extractbit(dch0, 14) == 0 && extractbit(dch1, 14) == 0) { // both channels enabled
 509                         value = pci_read_config32(k8_f2, 0x110);
 510                         if (extractbit(value, 4))  // ganged mode
 511                         vgainfo.ucUMAChannelNumber = 2;
 512                 }
 513         }
 514
 515         // processor type
 516         if (is_family0Fh())
 517                 vgainfo.ulCPUCapInfo = 3;
 518         if (is_family10h())
 519                 vgainfo.ulCPUCapInfo = 2;
 520
 521         /* HT speed */
 522         value = pci_read_config8(nb_dev, 0xd1);
 523         value = ht_freq_lookup [value] * 100;  // HT link frequency in MHz
 524         vgainfo.ulHTLinkFreq = value * 100;    // HT frequency in units of 100 MHz
 525         vgainfo.ulHighVoltageHTLinkFreq = vgainfo.ulHTLinkFreq;
 526         vgainfo.ulLowVoltageHTLinkFreq = vgainfo.ulHTLinkFreq;
 527
 528         if (value <= 1800)
 529                 vgainfo.ulLowVoltageHTLinkFreq = vgainfo.ulHTLinkFreq;
 530         else {
 531                 int sblink, cpuLnkFreqCap, nbLnkFreqCap;
 532                 value = pci_read_config32(k8_f0, 0x64);
 533                 sblink = extractbits(value, 8, 10);
 534                 cpuLnkFreqCap = pci_read_config16(k8_f0, 0x8a + sblink * 0x20);
 535                 nbLnkFreqCap = pci_read_config16(nb_dev, 0xd2);
 536                 if (cpuLnkFreqCap & nbLnkFreqCap & (1 << 10)) // if both 1800 MHz capable
 537                 vgainfo.ulLowVoltageHTLinkFreq = 1800*100;
 538         }
 539
 540         /* HT width. */
 541         value = pci_read_config8(nb_dev, 0xcb);
 542         vgainfo.usMinDownStreamHTLinkWidth =
 543         vgainfo.usMaxDownStreamHTLinkWidth =
 544         vgainfo.usMinUpStreamHTLinkWidth =
 545         vgainfo.usMaxUpStreamHTLinkWidth =
 546         vgainfo.usMinHTLinkWidth =
 547         vgainfo.usMaxHTLinkWidth = ht_width_lookup [extractbits(value, 0, 2)];
 548
 549         if (is_family0Fh()) {
 550                 vgainfo.usUMASyncStartDelay = 322;
 551                 vgainfo.usUMADataReturnTime = 286;
 552         }
 553
 554         if (is_family10h()) {
 555                 static u16 t0mult_lookup [] = {10, 50, 200, 2000};
 556                 int t0time, t0scale;
 557                 value = pci_read_config32(k8_f0, 0x16c);
 558                 t0time = extractbits(value, 0, 3);
 559                 t0scale = extractbits(value, 4, 5);
 560                 vgainfo.usLinkStatusZeroTime = t0mult_lookup [t0scale] * t0time;
 561                 vgainfo.usUMASyncStartDelay = 100;
 562                 if (vgainfo.ulHTLinkFreq < 1000 * 100) { // less than 1000 MHz
 563                         vgainfo.usUMADataReturnTime = 300;
 564                         vgainfo.usLinkStatusZeroTime = 6 * 100;   // 6us for GH in HT1 mode
 565                 }
 566                 else {
 567                         int lssel;
 568                         value = pci_read_config32(nb_dev, 0xac);
 569                         lssel = extractbits (value, 7, 8);
 570                         vgainfo.usUMADataReturnTime = 1300;
 571                         if (lssel == 0) vgainfo.usUMADataReturnTime = 150;
 572                 }
 573         }
 574
 575         /* Poweron DDI Lanes */
 576         poweron_ddi_lanes(nb_dev);
 577
 578         /* Transfer the Table to VBIOS. */
 579         pointer = (u32 *)&vgainfo;
 580         for(i=0; i<sizeof(ATOM_INTEGRATED_SYSTEM_INFO_V2); i+=4)
 581         {
 582 #if (CONFIG_GFXUMA == 1)
 583                 *GpuF0MMReg = 0x80000000 + uma_memory_size - 512 + i;
 584 #else
 585                 *GpuF0MMReg = 0x80000000 + 0x8000000 - 512 + i;
 586 #endif
 587                 *(GpuF0MMReg+1) = *pointer++;
 588         }
 589
 590         /* GFX_InitLate. */
 591         {
 592                 u32 temp;
 593                 temp = pci_read_config8(dev, 0x4);
 594                 //temp &= ~1; /* CIM clears this bit. Strangely, I can'd. */
 595                 temp |= 1<<1|1<<2;
 596                 pci_write_config8(dev, 0x4, temp);
 597
 598                 // if the GFX debug bar is writable, then it has
 599                 // been programmed and can be safely enabled now
 600                 temp = pci_read_config32(nb_dev, 0x8c);
 601
 602                 // if bits 1 (intgfx_enable) and 9 (gfx_debug_bar_enable)
 603                 // then enable gfx debug bar (set gxf_debug_decode_enable)
 604                 if (temp & 0x202)
 605                         temp |= (1 << 10);
 606                 pci_write_config32(nb_dev, 0x8c, temp);
 607
 608         }
 609
 610 #ifdef DONT_TRUST_RESOURCE_ALLOCATION
 611         /* NB_SetupMGMMIO. */
 612
 613         /* clear MMIO and CreativeMMIO. */
 614         bpointer = (unsigned char *)MMIO;
 615         for(i=0; i<sizeof(MMIO); i++)
 616         {
 617                 *bpointer = 0;
 618                 bpointer++;
 619         }
 620         bpointer = (unsigned char *)CreativeMMIO;
 621         for(i=0; i<sizeof(CreativeMMIO); i++)
 622         {
 623                 *bpointer = 0;
 624                 bpointer++;
 625         }
 626
 627         /* Set MMIO ranges in K8. */
 628         /* Set MMIO TOM - 4G. */
 629         SetMMIO(0x400<<12, 0x1000000, 0x80, &MMIO[0]);
 630         /* Set MMIO for VGA Legacy FB. */
 631         SetMMIO(0xa00, 0xc00, 0x80, &MMIO[0]);
 632
 633         /* Set MMIO for non prefetchable P2P. */
 634         temp = pci_read_config32(dev0x14, 0x20);
 635         Base32 = (temp & 0x0fff0) << 8;
 636         Limit32 = ((temp & 0x0fff00000) + 0x100000) >> 8;
 637         if(Base32 < Limit32)
 638         {
 639                 Status = GetCreativeMMIO(&CreativeMMIO[0]);
 640                 if(Status != CIM_ERROR)
 641                         SetMMIO(Base32, Limit32, 0x0, &MMIO[0]);
 642         }
 643         /* Set MMIO for prefetchable P2P. */
 644         if(Status != CIM_ERROR)
 645         {
 646                 temp = pci_read_config32(dev0x14, 0x24);
 647
 648                 Base32 = (temp & 0x0fff0) <<8;
 649                 Limit32 = ((temp & 0x0fff00000) + 0x100000) >> 8;
 650                 if(Base32 < Limit32)
 651                         SetMMIO(Base32, Limit32, 0x0, &MMIO[0]);
 652         }
 653
 654         FinalizeMMIO(&MMIO[0]);
 655
 656         ProgramMMIO(&CreativeMMIO[0], 0, MMIO_ATTRIB_NP_ONLY);
 657         ProgramMMIO(&MMIO[0], 0, MMIO_ATTRIB_NP_ONLY | MMIO_ATTRIB_BOTTOM_TO_TOP | MMIO_ATTRIB_SKIP_ZERO);
 658 #endif
 659
 660         pci_dev_init(dev);
 661
 662         /* clk ind */
 663         clkind_write(dev, 0x08, 0x01);
 664         clkind_write(dev, 0x0C, 0x22);
 665         clkind_write(dev, 0x0F, 0x0);
 666         clkind_write(dev, 0x11, 0x0);
 667         clkind_write(dev, 0x12, 0x0);
 668         clkind_write(dev, 0x14, 0x0);
 669         clkind_write(dev, 0x15, 0x0);
 670         clkind_write(dev, 0x16, 0x0);
 671         clkind_write(dev, 0x17, 0x0);
 672         clkind_write(dev, 0x18, 0x0);
 673         clkind_write(dev, 0x19, 0x0);
 674         clkind_write(dev, 0x1A, 0x0);
 675         clkind_write(dev, 0x1B, 0x0);
 676         clkind_write(dev, 0x1C, 0x0);
 677         clkind_write(dev, 0x1D, 0x0);
 678         clkind_write(dev, 0x1E, 0x0);
 679         clkind_write(dev, 0x26, 0x0);
 680         clkind_write(dev, 0x27, 0x0);
 681         clkind_write(dev, 0x28, 0x0);
 682         clkind_write(dev, 0x5C, 0x0);
 683 }
 684
 685
 686 /*
 687 * Set registers in RS780 and CPU to enable the internal GFX.
 688 * Please refer to CIM source code and BKDG.
 689 */
 690
 691 static void rs780_internal_gfx_enable(device_t dev)
 692 {
 693         u32 l_dword;
 694         int i;
 695         device_t nb_dev = dev_find_slot(0, 0);
 696         msr_t sysmem;
 697
 698 #if (CONFIG_GFXUMA == 0)
 699         u32 FB_Start, FB_End;
 700 #endif
 701
 702         printk(BIOS_DEBUG, "rs780_internal_gfx_enable dev = 0x%p, nb_dev = 0x%p.\n", dev, nb_dev);
 703
 704         /* The system top memory in 780. */
 705         sysmem = rdmsr(0xc001001a);
 706         printk(BIOS_DEBUG, "Sysmem TOM = %x_%x\n", sysmem.hi, sysmem.lo);
 707         pci_write_config32(nb_dev, 0x90, sysmem.lo);
 708
 709         sysmem = rdmsr(0xc001001D);
 710         printk(BIOS_DEBUG, "Sysmem TOM2 = %x_%x\n", sysmem.hi, sysmem.lo);
 711         htiu_write_index(nb_dev, 0x31, sysmem.hi);
 712         htiu_write_index(nb_dev, 0x30, sysmem.lo | 1);
 713
 714         /* Disable external GFX and enable internal GFX. */
 715         l_dword = pci_read_config32(nb_dev, 0x8c);
 716         l_dword &= ~(1<<0);
 717         l_dword |= 1<<1;
 718         pci_write_config32(nb_dev, 0x8c, l_dword);
 719
 720         /* NB_SetDefaultIndexes */
 721         pci_write_config32(nb_dev, 0x94, 0x7f);
 722         pci_write_config32(nb_dev, 0x60, 0x7f);
 723         pci_write_config32(nb_dev, 0xe0, 0);
 724
 725         /* NB_InitEarlyNB finished. */
 726
 727         /* LPC DMA Deadlock workaround? */
 728         /* GFX_InitCommon*/
 729         device_t k8_f0 = dev_find_slot(0, PCI_DEVFN(0x18, 0));
 730         l_dword = pci_read_config32(k8_f0, 0x68);
 731         l_dword &= ~(3 << 21);
 732         l_dword |= (1 << 21);
 733         pci_write_config32(k8_f0, 0x68, l_dword);
 734
 735         /* GFX_InitCommon. */
 736         nbmc_write_index(nb_dev, 0x23, 0x00c00010);
 737         set_nbmc_enable_bits(nb_dev, 0x16, 1<<15, 1<<15);
 738         set_nbmc_enable_bits(nb_dev, 0x25, 0xffffffff, 0x111f111f);
 739         set_htiu_enable_bits(nb_dev, 0x37, 1<<24, 1<<24);
 740
 741 #if (CONFIG_GFXUMA == 1)
 742         /* GFX_InitUMA. */
 743         /* Copy CPU DDR Controller to NB MC. */
 744         device_t k8_f1 = dev_find_slot(0, PCI_DEVFN(0x18, 1));
 745         device_t k8_f2 = dev_find_slot(0, PCI_DEVFN(0x18, 2));
 746         device_t k8_f4 = dev_find_slot(0, PCI_DEVFN(0x18, 4));
 747         for (i = 0; i < 12; i++)
 748         {
 749                 l_dword = pci_read_config32(k8_f2, 0x40 + i * 4);
 750                 nbmc_write_index(nb_dev, 0x30 + i, l_dword);
 751         }
 752
 753         l_dword = pci_read_config32(k8_f2, 0x80);
 754         nbmc_write_index(nb_dev, 0x3c, l_dword);
 755         l_dword = pci_read_config32(k8_f2, 0x94);
 756         set_nbmc_enable_bits(nb_dev, 0x3c, 0, !!(l_dword & (1<<22))<<16);
 757         set_nbmc_enable_bits(nb_dev, 0x3c, 0, !!(l_dword & (1<< 8))<<17);
 758         l_dword = pci_read_config32(k8_f2, 0x90);
 759         set_nbmc_enable_bits(nb_dev, 0x3c, 0, !!(l_dword & (1<<10))<<18);
 760    if (is_family10h())
 761    {
 762            for (i = 0; i < 12; i++)
 763            {
 764                    l_dword = pci_read_config32(k8_f2, 0x140 + i * 4);
 765                    nbmc_write_index(nb_dev, 0x3d + i, l_dword);
 766            }
 767
 768            l_dword = pci_read_config32(k8_f2, 0x180);
 769            nbmc_write_index(nb_dev, 0x49, l_dword);
 770            l_dword = pci_read_config32(k8_f2, 0x194);
 771            set_nbmc_enable_bits(nb_dev, 0x49, 0, !!(l_dword & (1<<22))<<16);
 772            set_nbmc_enable_bits(nb_dev, 0x49, 0, !!(l_dword & (1<< 8))<<17);
 773            l_dword = pci_read_config32(k8_f2, 0x190);
 774            set_nbmc_enable_bits(nb_dev, 0x49, 0, !!(l_dword & (1<<10))<<18);
 775
 776            l_dword = pci_read_config32(k8_f2, 0x110);
 777            nbmc_write_index(nb_dev, 0x4a, l_dword);
 778            l_dword = pci_read_config32(k8_f2, 0x114);
 779            nbmc_write_index(nb_dev, 0x4b, l_dword);
 780            l_dword = pci_read_config32(k8_f4, 0x44);
 781            set_nbmc_enable_bits(nb_dev, 0x4a, 0, !!(l_dword & (1<<22))<<24);
 782            l_dword = pci_read_config32(k8_f1, 0x40);
 783            nbmc_write_index(nb_dev, 0x4c, l_dword);
 784            l_dword = pci_read_config32(k8_f1, 0xf0);
 785            nbmc_write_index(nb_dev, 0x4d, l_dword);
 786    }
 787
 788
 789         /* Set UMA in the 780 side. */
 790         /* UMA start address, size. */
 791         /* The UMA starts at 0xC0000000 of internal RS780 address space
 792             [31:16] addr of last byte | [31:16] addr of first byte
 793         */
 794         nbmc_write_index(nb_dev, 0x10, ((uma_memory_size - 1 + 0xC0000000) & (~0xffff)) | 0xc000);
 795         nbmc_write_index(nb_dev, 0x11, uma_memory_base);
 796         nbmc_write_index(nb_dev, 0x12, 0);
 797         nbmc_write_index(nb_dev, 0xf0, uma_memory_size >> 20);
 798         /* GFX_InitUMA finished. */
 799 #else
 800         /* GFX_InitSP. */
 801         /* SP memory:Hynix HY5TQ1G631ZNFP. 128MB = 64M * 16. 667MHz. DDR3. */
 802
 803         /* Enable Async mode. */
 804         set_nbmc_enable_bits(nb_dev, 0x06, 7<<8, 1<<8);
 805         set_nbmc_enable_bits(nb_dev, 0x08, 1<<10, 0);
 806         /* The last item in AsynchMclkTaskFileIndex. Why? */
 807         /* MC_MPLL_CONTROL2. */
 808         nbmc_write_index(nb_dev, 0x07, 0x40100028);
 809         /* MC_MPLL_DIV_CONTROL. */
 810         nbmc_write_index(nb_dev, 0x0b, 0x00000028);
 811         /* MC_MPLL_FREQ_CONTROL. */
 812         set_nbmc_enable_bits(nb_dev, 0x09, 3<<12|15<<16|15<<8, 1<<12|4<<16|0<<8);
 813         /* MC_MPLL_CONTROL3. For PM. */
 814         set_nbmc_enable_bits(nb_dev, 0x08, 0xff<<13, 1<<13|1<<18);
 815         /* MPLL_CAL_TRIGGER. */
 816         set_nbmc_enable_bits(nb_dev, 0x06, 0, 1<<0);
 817         udelay(200); /* time is long enough? */
 818         set_nbmc_enable_bits(nb_dev, 0x06, 0, 1<<1);
 819         set_nbmc_enable_bits(nb_dev, 0x06, 1<<0, 0);
 820         /* MCLK_SRC_USE_MPLL. */
 821         set_nbmc_enable_bits(nb_dev, 0x02, 0, 1<<20);
 822
 823         /* Pre Init MC. */
 824         nbmc_write_index(nb_dev, 0x01, 0x88108280);
 825         set_nbmc_enable_bits(nb_dev, 0x02, ~(1<<20), 0x00030200);
 826         nbmc_write_index(nb_dev, 0x04, 0x08881018);
 827         nbmc_write_index(nb_dev, 0x05, 0x000000bb);
 828         nbmc_write_index(nb_dev, 0x0c, 0x0f00001f);
 829         nbmc_write_index(nb_dev, 0xa1, 0x01f10000);
 830         /* MCA_INIT_DLL_PM. */
 831         set_nbmc_enable_bits(nb_dev, 0xc9, 1<<24, 1<<24);
 832         nbmc_write_index(nb_dev, 0xa2, 0x74f20000);
 833         nbmc_write_index(nb_dev, 0xa3, 0x8af30000);
 834         nbmc_write_index(nb_dev, 0xaf, 0x47d0a41c);
 835         nbmc_write_index(nb_dev, 0xb0, 0x88800130);
 836         nbmc_write_index(nb_dev, 0xb1, 0x00000040);
 837         nbmc_write_index(nb_dev, 0xb4, 0x41247000);
 838         nbmc_write_index(nb_dev, 0xb5, 0x00066664);
 839         nbmc_write_index(nb_dev, 0xb6, 0x00000022);
 840         nbmc_write_index(nb_dev, 0xb7, 0x00000044);
 841         nbmc_write_index(nb_dev, 0xb8, 0xbbbbbbbb);
 842         nbmc_write_index(nb_dev, 0xb9, 0xbbbbbbbb);
 843         nbmc_write_index(nb_dev, 0xba, 0x55555555);
 844         nbmc_write_index(nb_dev, 0xc1, 0x00000000);
 845         nbmc_write_index(nb_dev, 0xc2, 0x00000000);
 846         nbmc_write_index(nb_dev, 0xc3, 0x80006b00);
 847         nbmc_write_index(nb_dev, 0xc4, 0x00066664);
 848         nbmc_write_index(nb_dev, 0xc5, 0x00000000);
 849         nbmc_write_index(nb_dev, 0xd2, 0x00000022);
 850         nbmc_write_index(nb_dev, 0xd3, 0x00000044);
 851         nbmc_write_index(nb_dev, 0xd6, 0x00050005);
 852         nbmc_write_index(nb_dev, 0xd7, 0x00000000);
 853         nbmc_write_index(nb_dev, 0xd8, 0x00700070);
 854         nbmc_write_index(nb_dev, 0xd9, 0x00700070);
 855         nbmc_write_index(nb_dev, 0xe0, 0x00200020);
 856         nbmc_write_index(nb_dev, 0xe1, 0x00200020);
 857         nbmc_write_index(nb_dev, 0xe8, 0x00200020);
 858         nbmc_write_index(nb_dev, 0xe9, 0x00200020);
 859         nbmc_write_index(nb_dev, 0xe0, 0x00180018);
 860         nbmc_write_index(nb_dev, 0xe1, 0x00180018);
 861         nbmc_write_index(nb_dev, 0xe8, 0x00180018);
 862         nbmc_write_index(nb_dev, 0xe9, 0x00180018);
 863
 864         /* Misc options. */
 865         /* Memory Termination. */
 866         set_nbmc_enable_bits(nb_dev, 0xa1, 0x0ff, 0x044);
 867         set_nbmc_enable_bits(nb_dev, 0xb4, 0xf00, 0xb00);
 868 #if 0
 869         /* Controller Termation. */
 870         set_nbmc_enable_bits(nb_dev, 0xb1, 0x77770000, 0x77770000);
 871 #endif
 872
 873         /* OEM Init MC. 667MHz. */
 874         nbmc_write_index(nb_dev, 0xa8, 0x7a5aaa78);
 875         nbmc_write_index(nb_dev, 0xa9, 0x514a2319);
 876         nbmc_write_index(nb_dev, 0xaa, 0x54400520);
 877         nbmc_write_index(nb_dev, 0xab, 0x441460ff);
 878         nbmc_write_index(nb_dev, 0xa0, 0x20f00a48);
 879         set_nbmc_enable_bits(nb_dev, 0xa2, ~(0xffffffc7), 0x10);
 880         nbmc_write_index(nb_dev, 0xb2, 0x00000303);
 881         set_nbmc_enable_bits(nb_dev, 0xb1, ~(0xffffff70), 0x45);
 882         /* Do it later. */
 883         /* set_nbmc_enable_bits(nb_dev, 0xac, ~(0xfffffff0), 0x0b); */
 884
 885         /* Init PM timing. */
 886         for(i=0; i<4; i++)
 887         {
 888                 l_dword = nbmc_read_index(nb_dev, 0xa0+i);
 889                 nbmc_write_index(nb_dev, 0xc8+i, l_dword);
 890         }
 891         for(i=0; i<4; i++)
 892         {
 893                 l_dword = nbmc_read_index(nb_dev, 0xa8+i);
 894                 nbmc_write_index(nb_dev, 0xcc+i, l_dword);
 895         }
 896         l_dword = nbmc_read_index(nb_dev, 0xb1);
 897         set_nbmc_enable_bits(nb_dev, 0xc8, 0xff<<24, ((l_dword&0x0f)<<24)|((l_dword&0xf00)<<20));
 898
 899         /* Init MC FB. */
 900         /* FB_Start = ; FB_End = ; iSpSize = 0x0080, 128MB. */
 901         nbmc_write_index(nb_dev, 0x11, 0x40000000);
 902         FB_Start = 0xc00 + 0x080;
 903         FB_End = 0xc00 + 0x080;
 904         nbmc_write_index(nb_dev, 0x10, (((FB_End&0xfff)<<20)-0x10000)|(((FB_Start&0xfff)-0x080)<<4));
 905         set_nbmc_enable_bits(nb_dev, 0x0d, ~0x000ffff0, (FB_Start&0xfff)<<20);
 906         nbmc_write_index(nb_dev, 0x0f, 0);
 907         nbmc_write_index(nb_dev, 0x0e, (FB_Start&0xfff)|(0xaaaa<<12));
 908 #endif
 909
 910         /* GFX_InitSP finished. */
 911 }
 912
 913 static struct pci_operations lops_pci = {
 914         .set_subsystem = pci_dev_set_subsystem,
 915 };
 916
 917 static struct device_operations pcie_ops = {
 918         .read_resources = rs780_gfx_read_resources,
 919         .set_resources = pci_dev_set_resources,
 920         .enable_resources = pci_dev_enable_resources,
 921         .init = internal_gfx_pci_dev_init,      /* The option ROM initializes the device. rs780_gfx_init, */
 922         .scan_bus = 0,
 923         .enable = rs780_internal_gfx_enable,
 924         .ops_pci = &lops_pci,
 925 };
 926
 927 /*
 928  * We should list all of them here.
 929  * */
 930 static const struct pci_driver pcie_driver_780 __pci_driver = {
 931         .ops = &pcie_ops,
 932         .vendor = PCI_VENDOR_ID_ATI,
 933         .device = PCI_DEVICE_ID_ATI_RS780_INT_GFX,
 934 };
 935
 936 static const struct pci_driver pcie_driver_780c __pci_driver = {
 937         .ops = &pcie_ops,
 938         .vendor = PCI_VENDOR_ID_ATI,
 939         .device = PCI_DEVICE_ID_ATI_RS780C_INT_GFX,
 940 };
 941 static const struct pci_driver pcie_driver_780m __pci_driver = {
 942         .ops = &pcie_ops,
 943         .vendor = PCI_VENDOR_ID_ATI,
 944         .device = PCI_DEVICE_ID_ATI_RS780M_INT_GFX,
 945 };
 946 static const struct pci_driver pcie_driver_780mc __pci_driver = {
 947         .ops = &pcie_ops,
 948         .vendor = PCI_VENDOR_ID_ATI,
 949         .device = PCI_DEVICE_ID_ATI_RS780MC_INT_GFX,
 950 };
 951 static const struct pci_driver pcie_driver_780e __pci_driver = {
 952         .ops = &pcie_ops,
 953         .vendor = PCI_VENDOR_ID_ATI,
 954         .device = PCI_DEVICE_ID_ATI_RS780E_INT_GFX,
 955 };
 956 static const struct pci_driver pcie_driver_785g __pci_driver = {
 957         .ops = &pcie_ops,
 958         .vendor = PCI_VENDOR_ID_ATI,
 959         .device = PCI_DEVICE_ID_ATI_RS785G_INT_GFX,
 960 };
 961 static const struct pci_driver pcie_driver_785c __pci_driver = {
 962         .ops = &pcie_ops,
 963         .vendor = PCI_VENDOR_ID_ATI,
 964         .device = PCI_DEVICE_ID_ATI_RS785C_INT_GFX,
 965 };
 966 static const struct pci_driver pcie_driver_785m __pci_driver = {
 967         .ops = &pcie_ops,
 968         .vendor = PCI_VENDOR_ID_ATI,
 969         .device = PCI_DEVICE_ID_ATI_RS785M_INT_GFX,
 970 };
 971 static const struct pci_driver pcie_driver_785mc __pci_driver = {
 972         .ops = &pcie_ops,
 973         .vendor = PCI_VENDOR_ID_ATI,
 974         .device = PCI_DEVICE_ID_ATI_RS785MC_INT_GFX,
 975 };
 976 static const struct pci_driver pcie_driver_785d __pci_driver = {
 977         .ops = &pcie_ops,
 978         .vendor = PCI_VENDOR_ID_ATI,
 979         .device = PCI_DEVICE_ID_ATI_RS785D_INT_GFX,
 980 };
 981
 982 /* step 12 ~ step 14 from rpr */
 983 static void single_port_configuration(device_t nb_dev, device_t dev)
 984 {
 985         u8 result, width;
 986         u32 reg32;
 987         struct southbridge_amd_rs780_config *cfg =
 988             (struct southbridge_amd_rs780_config *)nb_dev->chip_info;
 989
 990         printk(BIOS_DEBUG, "rs780_gfx_init single_port_configuration.\n");
 991
 992         /* step 12 training, releases hold training for GFX port 0 (device 2) */
 993         PcieReleasePortTraining(nb_dev, dev, 2);
 994         result = PcieTrainPort(nb_dev, dev, 2);
 995         printk(BIOS_DEBUG, "rs780_gfx_init single_port_configuration step12.\n");
 996
 997         /* step 13 Power Down Control */
 998         /* step 13.1 Enables powering down transmitter and receiver pads along with PLL macros. */
 999         set_pcie_enable_bits(nb_dev, 0x40, 1 << 0, 1 << 0);
1000
1001         /* step 13.a Link Training was NOT successful */
1002         if (!result) {
1003                 set_nbmisc_enable_bits(nb_dev, 0x8, 0, 0x3 << 4); /* prevent from training. */
1004                 set_nbmisc_enable_bits(nb_dev, 0xc, 0, 0x3 << 2); /* hide the GFX bridge. */
1005                 if (cfg->gfx_tmds)
1006                         nbpcie_ind_write_index(nb_dev, 0x65, 0xccf0f0);
1007                 else {
1008                         nbpcie_ind_write_index(nb_dev, 0x65, 0xffffffff);
1009                         set_nbmisc_enable_bits(nb_dev, 0x7, 1 << 3, 1 << 3);
1010                 }
1011         } else {                /* step 13.b Link Training was successful */
1012                 set_pcie_enable_bits(dev, 0xA2, 0xFF, 0x1);
1013                 reg32 = nbpcie_p_read_index(dev, 0x29);
1014                 width = reg32 & 0xFF;
1015                 printk(BIOS_DEBUG, "GFX Inactive Lanes = 0x%x.\n", width);
1016                 switch (width) {
1017                 case 1:
1018                 case 2:
1019                         nbpcie_ind_write_index(nb_dev, 0x65,
1020                                                cfg->gfx_lane_reversal ? 0x7f7f : 0xccfefe);
1021                         break;
1022                 case 4:
1023                         nbpcie_ind_write_index(nb_dev, 0x65,
1024                                                cfg->gfx_lane_reversal ? 0x3f3f : 0xccfcfc);
1025                         break;
1026                 case 8:
1027                         nbpcie_ind_write_index(nb_dev, 0x65,
1028                                                cfg->gfx_lane_reversal ? 0x0f0f : 0xccf0f0);
1029                         break;
1030                 }
1031         }
1032         printk(BIOS_DEBUG, "rs780_gfx_init single_port_configuration step13.\n");
1033
1034         /* step 14 Reset Enumeration Timer, disables the shortening of the enumeration timer */
1035         set_pcie_enable_bits(dev, 0x70, 1 << 19, 1 << 19);
1036         printk(BIOS_DEBUG, "rs780_gfx_init single_port_configuration step14.\n");
1037 }
1038
1039 static void dual_port_configuration(device_t nb_dev, device_t dev)
1040 {
1041         u8 result, width;
1042         u32 reg32, dev_ind = dev->path.pci.devfn >> 3;
1043         struct southbridge_amd_rs780_config *cfg =
1044                     (struct southbridge_amd_rs780_config *)nb_dev->chip_info;
1045
1046         /* 5.4.1.2 Dual Port Configuration */
1047         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 1 << 31);
1048         set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1049         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 0 << 31);
1050
1051         /* 5.7. Training for Device 2 */
1052         /* 5.7.1. Releases hold training for GFX port 0 (device 2) */
1053         PcieReleasePortTraining(nb_dev, dev, dev_ind);
1054         /* 5.7.2- 5.7.9. PCIE Link Training Sequence */
1055         result = PcieTrainPort(nb_dev, dev, dev_ind);
1056
1057         /* Power Down Control for Device 2 */
1058         /* Link Training was NOT successful */
1059         if (!result) {
1060                 /* Powers down all lanes for port A */
1061                 /* nbpcie_ind_write_index(nb_dev, 0x65, 0x0f0f); */
1062                 /* Note: I have to disable the slot where there isnt a device,
1063                  * otherwise the system will hang. I dont know why. */
1064                 set_nbmisc_enable_bits(nb_dev, 0x0c, 1 << dev_ind, 1 << dev_ind);
1065
1066         } else {                /* step 16.b Link Training was successful */
1067                 reg32 = nbpcie_p_read_index(dev, 0xa2);
1068                 width = (reg32 >> 4) & 0x7;
1069                 printk(BIOS_DEBUG, "GFX LC_LINK_WIDTH = 0x%x.\n", width);
1070                 switch (width) {
1071                 case 1:
1072                 case 2:
1073                         nbpcie_ind_write_index(nb_dev, 0x65,
1074                                                cfg->gfx_lane_reversal ? 0x0707 : 0x0e0e);
1075                         break;
1076                 case 4:
1077                         nbpcie_ind_write_index(nb_dev, 0x65,
1078                                                cfg->gfx_lane_reversal ? 0x0303 : 0x0c0c);
1079                         break;
1080                 }
1081         }
1082 }
1083
1084 /* For single port GFX configuration Only
1085 * width:
1086 *       000 = x16
1087 *       001 = x1
1088 *       010 = x2
1089 *       011 = x4
1090 *       100 = x8
1091 *       101 = x12 (not supported)
1092 *       110 = x16
1093 */
1094 static void dynamic_link_width_control(device_t nb_dev, device_t dev, u8 width)
1095 {
1096         u32 reg32;
1097         device_t sb_dev;
1098         struct southbridge_amd_rs780_config *cfg =
1099             (struct southbridge_amd_rs780_config *)nb_dev->chip_info;
1100
1101         /* step 5.9.1.1 */
1102         reg32 = nbpcie_p_read_index(dev, 0xa2);
1103
1104         /* step 5.9.1.2 */
1105         set_pcie_enable_bits(nb_dev, 0x40, 1 << 0, 1 << 0);
1106         /* step 5.9.1.3 */
1107         set_pcie_enable_bits(dev, 0xa2, 3 << 0, width << 0);
1108         /* step 5.9.1.4 */
1109         set_pcie_enable_bits(dev, 0xa2, 1 << 8, 1 << 8);
1110         /* step 5.9.2.4 */
1111         if (0 == cfg->gfx_reconfiguration)
1112                 set_pcie_enable_bits(dev, 0xa2, 1 << 11, 1 << 11);
1113
1114         /* step 5.9.1.5 */
1115         do {
1116                 reg32 = nbpcie_p_read_index(dev, 0xa2);
1117         }
1118         while (reg32 & 0x100);
1119
1120         /* step 5.9.1.6 */
1121         sb_dev = dev_find_slot(0, PCI_DEVFN(8, 0));
1122         do {
1123                 reg32 = pci_ext_read_config32(nb_dev, sb_dev,
1124                                           PCIE_VC0_RESOURCE_STATUS);
1125         } while (reg32 & VC_NEGOTIATION_PENDING);
1126
1127         /* step 5.9.1.7 */
1128         reg32 = nbpcie_p_read_index(dev, 0xa2);
1129         if (((reg32 & 0x70) >> 4) != 0x6) {
1130                 /* the unused lanes should be powered off. */
1131         }
1132
1133         /* step 5.9.1.8 */
1134         set_pcie_enable_bits(nb_dev, 0x40, 1 << 0, 0 << 0);
1135 }
1136
1137 /*
1138 * GFX Core initialization, dev2, dev3
1139 */
1140 void rs780_gfx_init(device_t nb_dev, device_t dev, u32 port)
1141 {
1142         u32 reg32;
1143         struct southbridge_amd_rs780_config *cfg =
1144             (struct southbridge_amd_rs780_config *)nb_dev->chip_info;
1145
1146         printk(BIOS_DEBUG, "rs780_gfx_init, nb_dev=0x%p, dev=0x%p, port=0x%x.\n",
1147                     nb_dev, dev, port);
1148
1149         /* GFX Core Initialization */
1150         //if (port == 2) return;
1151
1152         /* step 2, TMDS, (only need if CMOS option is enabled) */
1153         if (cfg->gfx_tmds) {
1154                 /**
1155                  * PCIe Initialization for DDI.
1156                  * The VBIOS/Driver is responsible for DDI programming sequence,
1157                  * The SBIOS is responsible for programming the lane and clock muxing specific to each case.
1158                  * Refer to RPR Chapter 7: "PCIe Initialization for DDI".
1159                  * Note: This programming must be done before hold training is released.
1160                  */
1161                 switch (cfg->gfx_pcie_config) {
1162                         case 1: /* 1x16 GFX -default case, no programming required */
1163                                 break;
1164                         case 2: /* 1x8 GFX on Lanes 0-7 */
1165                         case 5: /* 1x4 GPP on Lanes 0-3 */
1166                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 6, 0x1 << 6); /* Disables PCIe mode on PHY Lanes  8-11 */
1167                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 7, 0x1 << 7); /* Disables PCIe mode on PHY Lanes 12-15 */
1168                                 break;
1169                         case 3: /* 1x8 on Lanes 8-15 */
1170                         case 7: /* 1x4 GPP on Lanes 8-11 */
1171                                 /* TXCLK */
1172                                 set_nbmisc_enable_bits(nb_dev, 0x07, 1 << 16, 1 << 16);
1173                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0xF << 12, 0xF << 12);
1174                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 24, 0x2 << 24);
1175                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x3 << 0, 0x0 << 0);
1176                                 /* RXCLK */
1177                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 8, 0x2 << 8);
1178                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 10, 0x2 << 10);
1179                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 12, 0x2 << 12);
1180                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 14, 0x2 << 14);
1181                                 /* TX Lane Muxing */
1182                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 2, 0x1 << 2);
1183                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 3, 0x1 << 3);
1184                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 4, 0x1 << 4);
1185                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 5, 0x1 << 5);
1186                                 break;
1187                         case 4:  /* 2x8 */
1188                         case 10: /* 1x4 GPP on Lanes 0-3 and 1x4 GPP on Lanes 8-11 */
1189                         case 14: /* 1x8 GFX on Lanes 0-7 and 1x4 GPP on Lanes 8-11 */
1190                         case 17: /* 1x4 GPP on Lanes 0-3 and 1x8 GFX on Lanes 8-15 */
1191                                 /* Set dual slot configuration */
1192                                 set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1193                                 break;
1194                         case 9: /* PCIe 2x4 GPPs on Lanes 0-7 */
1195                         case 6: /* PCIe 1x4 GPP on Lanes 4-7 */
1196                                 /* Set dual slot configuration */
1197                                 set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1198                                 /* TXCLK */
1199                                 set_nbmisc_enable_bits(nb_dev, 0x07, 1 << 16, 0 << 16);
1200                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0xF << 12, 0x0 << 12);
1201                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 20, 0x0 << 20);
1202                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x1 << 0, 0x0 << 0);
1203                                 /* RXCLK */
1204                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 8, 0x0 << 8);
1205                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 10, 0x1 << 10);
1206                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 12, 0x3 << 12);
1207                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 14, 0x0 << 14);
1208                                 /* TX Lane Muxing */
1209                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 1, 0x1 << 1);
1210                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 6, 0x1 << 6);
1211                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 7, 0x1 << 7);
1212                                 break;
1213                         case 13: /* 2x4 GPPs on Lanes 8-15 */
1214                         case 8:  /* 1x4 GPP on Lanes 12-15 */
1215                                 /* Set dual slot configuration */
1216                                 set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1217                                 /* TXCLK */
1218                                 set_nbmisc_enable_bits(nb_dev, 0x07, 1 << 16, 1 << 16);
1219                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0xF << 12, 0xF << 12);
1220                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 24, 0x2 << 24);
1221                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x3 << 0, 0x3 << 0);
1222                                 /* RXCLK */
1223                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 8, 0x2 << 8);
1224                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 10, 0x3 << 10);
1225                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 12, 0x1 << 12);
1226                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 14, 0x2 << 14);
1227                                 /* TX Lane Muxing */
1228                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 2, 0x1 << 2);
1229                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x1 << 14, 0x1 << 14);
1230                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 4, 0x1 << 4);
1231                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 5, 0x1 << 5);
1232                                 break;
1233                         case 15: /* 1x8 GFX on Lanes 0-7 and 1x4 GPP on Lanes 12-15 */
1234                         case 11: /* 1x4 GPP on Lanes 0-3 and 1x4 GPP on Lanes 12-15 */
1235                                 /* Set dual slot configuration */
1236                                 set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1237                                 /* TXCLK */
1238                                 set_nbmisc_enable_bits(nb_dev, 0x07, 1 << 16, 0 << 16);
1239                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0xF << 12, 0x0 << 12);
1240                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 20, 0x0 << 20);
1241                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x3 << 0, 0x1 << 0);
1242                                 /* RXCLK */
1243                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 8, 0x0 << 8);
1244                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 10, 0x0 << 10);
1245                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 12, 0x1 << 12);
1246                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 14, 0x3 << 14);
1247                                 /* TX Lane Muxing */
1248                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x1 << 14, 0x1 << 14);
1249                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 6, 0x1 << 6);
1250                                 break;
1251                         case 16: /* 1x8 GFX on Lanes 8-15 and 1x4 GPP on Lanes 4-7 */
1252                         case 12: /* 1x4 GPP on Lanes 4-7 and 1x8 GFX on Lanes 8-15 */
1253                                 /* Set dual slot configuration */
1254                                 set_nbmisc_enable_bits(nb_dev, 0x08, 0xF << 8, 0x5 << 8);
1255                                 /* TXCLK */
1256                                 set_nbmisc_enable_bits(nb_dev, 0x07, 1 << 16, 1 << 16);
1257                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0xF << 12, 0xF << 12);
1258                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 24, 0x2 << 24);
1259                                 set_nbmisc_enable_bits(nb_dev, 0x07, 0x3 << 22, 0x2 << 22);
1260                                 set_nbmisc_enable_bits(nb_dev, 0x28, 0x3 << 0, 0x2 << 0);
1261                                 /* RXCLK */
1262                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 8, 0x2 << 8);
1263                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 10, 0x2 << 10);
1264                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 12, 0x3 << 12);
1265                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x3 << 14, 0x1 << 14);
1266                                 /* TX Lane Muxing */
1267                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 2, 0x1 << 2);
1268                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 3, 0x1 << 3);
1269                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 1, 0x1 << 1);
1270                                 set_nbmisc_enable_bits(nb_dev, 0x27, 0x1 << 4, 0x1 << 4);
1271                                 break;
1272                         default:
1273                                 printk(BIOS_INFO, "Incorrect configuration of external GFX slot.\n");
1274                                 break;
1275                 }
1276
1277                 /* DDI Configuration */
1278                 switch (cfg->gfx_ddi_config) {
1279                         case 1: /* DDI_SL lanes0-3 */
1280                                 nbmisc_write_index(nb_dev, 0x74, GFX_CONFIG_DDI);
1281                                 break;
1282                         case 2: /* DDI_SL lanes4-7 */
1283                                 nbmisc_write_index(nb_dev, 0x74, (GFX_CONFIG_DDI << 8));
1284                                 break;
1285                         case 5: /* DDI_SL lanes0-4, lanes4-7 */
1286                                 nbmisc_write_index(nb_dev, 0x74, (GFX_CONFIG_DDI << 8) | GFX_CONFIG_DDI);
1287                                 break;
1288                         case 6: /* DDI_DL lanes0-7 */
1289                                 nbmisc_write_index(nb_dev, 0x74, (GFX_CONFIG_DDI << 8) | GFX_CONFIG_DDI);
1290                                 break;
1291                         default:
1292                                 printk(BIOS_INFO, "Incorrect configuration of external GFX slot.\n");
1293                                 break;
1294                 }
1295         }
1296
1297 #if 1                           /* external clock mode */
1298         /* table 5-22, 5.9.1. REFCLK */
1299         /* 5.9.1.1. Disables the GFX REFCLK transmitter so that the GFX
1300          * REFCLK PAD can be driven by an external source. */
1301         /* 5.9.1.2. Enables GFX REFCLK receiver to receive the REFCLK from an external source. */
1302         set_nbmisc_enable_bits(nb_dev, 0x38, 1 << 29 | 1 << 28 | 1 << 26, 1 << 28);
1303
1304         /* 5.9.1.3 Selects the GFX REFCLK to be the source for PLL A. */
1305         /* 5.9.1.4 Selects the GFX REFCLK to be the source for PLL B. */
1306         /* 5.9.1.5 Selects the GFX REFCLK to be the source for PLL C. */
1307         reg32 = nbmisc_read_index(nb_dev, 0x28);
1308         printk(BIOS_DEBUG, "misc 28 = %x\n", reg32);
1309
1310         /* 5.9.1.6.Selects the single ended GFX REFCLK to be the source for core logic. */
1311         set_nbmisc_enable_bits(nb_dev, 0x6C, 1 << 31, 1 << 31);
1312 #else                           /* internal clock mode */
1313         /* table 5-23, 5.9.1. REFCLK */
1314         /* 5.9.1.1. Enables the GFX REFCLK transmitter so that the GFX
1315          * REFCLK PAD can be driven by the SB REFCLK. */
1316         /* 5.9.1.2. Disables GFX REFCLK receiver from receiving the
1317          * REFCLK from an external source.*/
1318         set_nbmisc_enable_bits(nb_dev, 0x38, 1 << 29 | 1 << 28, 1 << 29 | 0 << 28);
1319
1320         /* 5.9.1.3 Selects the GFX REFCLK to be the source for PLL A. */
1321         /* 5.9.1.4 Selects the GFX REFCLK to be the source for PLL B. */
1322         /* 5.9.1.5 Selects the GFX REFCLK to be the source for PLL C. */
1323         set_nbmisc_enable_bits(nb_dev, 0x28, 3 << 6 | 3 << 8 | 3 << 10,
1324                                0);
1325         reg32 = nbmisc_read_index(nb_dev, 0x28);
1326         printk(BIOS_DEBUG, "misc 28 = %x\n", reg32);
1327
1328         /* 5.9.1.6.Selects the single ended GFX REFCLK to be the source for core logic. */
1329         set_nbmisc_enable_bits(nb_dev, 0x6C, 1 << 31, 0 << 31);
1330 #endif
1331
1332         /* step 5.9.3, GFX overclocking, (only need if CMOS option is enabled) */
1333         /* 5.9.3.1. Increases PLL BW for 6G operation.*/
1334         /* set_nbmisc_enable_bits(nb_dev, 0x36, 0x3FF << 4, 0xB5 << 4); */
1335         /* skip */
1336
1337         /* step 5.9.4, reset the GFX link */
1338         /* step 5.9.4.1 asserts both calibration reset and global reset */
1339         set_nbmisc_enable_bits(nb_dev, 0x8, 0x3 << 14, 0x3 << 14);
1340
1341         /* step 5.9.4.2 de-asserts calibration reset */
1342         set_nbmisc_enable_bits(nb_dev, 0x8, 1 << 14, 0 << 14);
1343
1344         /* step 5.9.4.3 wait for at least 200us */
1345         udelay(300);
1346
1347         /* step 5.9.4.4 de-asserts global reset */
1348         set_nbmisc_enable_bits(nb_dev, 0x8, 1 << 15, 0 << 15);
1349
1350         /* 5.9.5 Reset PCIE_GFX Slot */
1351         /* It is done in mainboard.c */
1352         set_pcie_reset();
1353         mdelay(1);
1354         set_pcie_dereset();
1355
1356         /* step 5.9.8 program PCIE memory mapped configuration space */
1357         /* done by enable_pci_bar3() before */
1358
1359         /* step 7 compliance state, (only need if CMOS option is enabled) */
1360         /* the compliance stete is just for test. refer to 4.2.5.2 of PCIe specification */
1361         if (cfg->gfx_compliance) {
1362                 /* force compliance */
1363                 set_nbmisc_enable_bits(nb_dev, 0x32, 1 << 6, 1 << 6);
1364                 /* release hold training for device 2. GFX initialization is done. */
1365                 set_nbmisc_enable_bits(nb_dev, 0x8, 1 << 4, 0 << 4);
1366                 dynamic_link_width_control(nb_dev, dev, cfg->gfx_link_width);
1367                 printk(BIOS_DEBUG, "rs780_gfx_init step7.\n");
1368                 return;
1369         }
1370
1371         /* 5.9.12 Core Initialization. */
1372         /* 5.9.12.1 sets RCB timeout to be 25ms */
1373         /* 5.9.12.2. RCB Cpl timeout on link down. */
1374         set_pcie_enable_bits(dev, 0x70, 7 << 16 | 1 << 19, 4 << 16 | 1 << 19);
1375         printk(BIOS_DEBUG, "rs780_gfx_init step5.9.12.1.\n");
1376
1377         /* step 5.9.12.3 disables slave ordering logic */
1378         set_pcie_enable_bits(nb_dev, 0x20, 1 << 8, 1 << 8);
1379         printk(BIOS_DEBUG, "rs780_gfx_init step5.9.12.3.\n");
1380
1381         /* step 5.9.12.4 sets DMA payload size to 64 bytes */
1382         set_pcie_enable_bits(nb_dev, 0x10, 7 << 10, 4 << 10);
1383         /* 5.9.12.5. Blocks DMA traffic during C3 state. */
1384         set_pcie_enable_bits(dev, 0x10, 1 << 0, 0 << 0);
1385
1386         /* 5.9.12.6. Disables RC ordering logic */
1387         set_pcie_enable_bits(nb_dev, 0x20, 1 << 9, 1 << 9);
1388
1389         /* Enabels TLP flushing. */
1390         /* Note: It is got from RS690. The system will hang without this action. */
1391         set_pcie_enable_bits(dev, 0x20, 1 << 19, 0 << 19);
1392
1393         /* 5.9.12.7. Ignores DLLPs during L1 so that txclk can be turned off */
1394         set_pcie_enable_bits(nb_dev, 0x2, 1 << 0, 1 << 0);
1395
1396         /* 5.9.12.8 Prevents LC to go from L0 to Rcv_L0s if L1 is armed. */
1397         set_pcie_enable_bits(dev, 0xA1, 1 << 11, 1 << 11);
1398
1399         /* 5.9.12.9 CMGOOD_OVERRIDE for end point initiated lane degradation. */
1400         set_nbmisc_enable_bits(nb_dev, 0x6a, 1 << 17, 1 << 17);
1401         printk(BIOS_DEBUG, "rs780_gfx_init step5.9.12.9.\n");
1402
1403         /* 5.9.12.10 Sets the timer in Config state from 20us to */
1404         /* 5.9.12.11 De-asserts RX_EN in L0s. */
1405         /* 5.9.12.12 Enables de-assertion of PG2RX_CR_EN to lock clock
1406          * recovery parameter when lane is in electrical idle in L0s.*/
1407         set_pcie_enable_bits(dev, 0xB1, 1 << 23 | 1 << 19 | 1 << 28, 1 << 23 | 1 << 19 | 1 << 28);
1408
1409         /* 5.9.12.13. Turns off offset calibration. */
1410         /* 5.9.12.14. Enables Rx Clock gating in CDR */
1411         set_nbmisc_enable_bits(nb_dev, 0x34, 1 << 10/* | 1 << 22 */, 1 << 10/* | 1 << 22 */);
1412
1413         /* 5.9.12.15. Sets number of TX Clocks to drain TX Pipe to 3. */
1414         set_pcie_enable_bits(dev, 0xA0, 0xF << 4, 3 << 4);
1415
1416         /* 5.9.12.16. Lets PI use Electrical Idle from PHY when
1417          * turning off PLL in L1 at Gen2 speed instead Inferred Electrical Idle. */
1418         set_pcie_enable_bits(nb_dev, 0x40, 3 << 14, 2 << 14);
1419
1420         /* 5.9.12.17. Prevents the Electrical Idle from causing a transition from Rcv_L0 to Rcv_L0s. */
1421         set_pcie_enable_bits(dev, 0xB1, 1 << 20, 1 << 20);
1422
1423         /* 5.9.12.18. Prevents the LTSSM from going to Rcv_L0s if it has already
1424          * acknowledged a request to go to L1. */
1425         set_pcie_enable_bits(dev, 0xA1, 1 << 11, 1 << 11);
1426
1427         /* 5.9.12.19. LDSK only taking deskew on deskewing error detect */
1428         set_pcie_enable_bits(nb_dev, 0x40, 1 << 28, 0 << 28);
1429
1430         /* 5.9.12.20. Bypasses lane de-skew logic if in x1 */
1431         set_pcie_enable_bits(nb_dev, 0xC2, 1 << 14, 1 << 14);
1432
1433         /* 5.9.12.21. Sets Electrical Idle Threshold. */
1434         set_nbmisc_enable_bits(nb_dev, 0x35, 3 << 21, 2 << 21);
1435
1436         /* 5.9.12.22. Advertises -6 dB de-emphasis value in TS1 Data Rate Identifier
1437          * Only if CMOS Option in section. skip */
1438
1439         /* 5.9.12.23. Disables GEN2 capability of the device. */
1440         set_pcie_enable_bits(dev, 0xA4, 1 << 0, 0 << 0);
1441
1442         /* 5.9.12.24.Disables advertising Upconfigure Support. */
1443         set_pcie_enable_bits(dev, 0xA2, 1 << 13, 1 << 13);
1444
1445         /* 5.9.12.25. No comment in RPR. */
1446         set_nbmisc_enable_bits(nb_dev, 0x39, 1 << 10, 0 << 10);
1447
1448         /* 5.9.12.26. This capacity is required since links wider than x1 and/or multiple link
1449          * speed are supported */
1450         set_pcie_enable_bits(nb_dev, 0xC1, 1 << 0, 1 << 0);
1451
1452         /* 5.9.12.27. Enables NVG86 ECO. A13 above only. */
1453         if (get_nb_rev(nb_dev) == REV_RS780_A12)                        /* A12 */
1454                 set_pcie_enable_bits(dev, 0x02, 1 << 11, 1 << 11);
1455
1456         /* 5.9.12.28 Hides and disables the completion timeout method. */
1457         set_pcie_enable_bits(nb_dev, 0xC1, 1 << 2, 0 << 2);
1458
1459         /* 5.9.12.29. Use the bif_core de-emphasis strength by default. */
1460         /* set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 28, 1 << 28); */
1461
1462         /* 5.9.12.30. Set TX arbitration algorithm to round robin */
1463         set_pcie_enable_bits(nb_dev, 0x1C,
1464                              1 << 0 | 0x1F << 1 | 0x1F << 6,
1465                              1 << 0 | 0x04 << 1 | 0x04 << 6);
1466
1467         /* Single-port/Dual-port configureation. */
1468         switch (cfg->gfx_dual_slot) {
1469         case 0:
1470                 /* step 1, lane reversal (only need if build config option is enabled) */
1471                 if (cfg->gfx_lane_reversal) {
1472                         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 1 << 31);
1473                         set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 2, 1 << 2);
1474                         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 0 << 31);
1475                 }
1476                 printk(BIOS_DEBUG, "rs780_gfx_init step1.\n");
1477
1478                 printk(BIOS_DEBUG, "device = %x\n", dev->path.pci.devfn >> 3);
1479                 if((dev->path.pci.devfn >> 3) == 2) {
1480                         single_port_configuration(nb_dev, dev);
1481                 } else {
1482                         set_nbmisc_enable_bits(nb_dev, 0xc, 0, 0x2 << 2); /* hide the GFX bridge. */
1483                         printk(BIOS_INFO, "Single port. Do nothing.\n"); // If dev3
1484                 }
1485
1486                 break;
1487         case 1:
1488                 /* step 1, lane reversal (only need if build config option is enabled) */
1489                 if (cfg->gfx_lane_reversal) {
1490                         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 1 << 31);
1491                         set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 2, 1 << 2);
1492                         set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 3, 1 << 3);
1493                         set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 0 << 31);
1494                 }
1495                 printk(BIOS_DEBUG, "rs780_gfx_init step1.\n");
1496                 /* step 1.1, dual-slot gfx configuration (only need if CMOS option is enabled) */
1497                 /* AMD calls the configuration CrossFire */
1498                 set_nbmisc_enable_bits(nb_dev, 0x0, 0xf << 8, 5 << 8);
1499                 printk(BIOS_DEBUG, "rs780_gfx_init step2.\n");
1500
1501                 printk(BIOS_DEBUG, "device = %x\n", dev->path.pci.devfn >> 3);
1502                 dual_port_configuration(nb_dev, dev);
1503                 break;
1504
1505         case 2:
1506                 if(is_dev3_present()){
1507                         /* step 1, lane reversal (only need if CMOS option is enabled) */
1508                         if (cfg->gfx_lane_reversal) {
1509                                 set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 1 << 31);
1510                                 set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 2, 1 << 2);
1511                                 set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 3, 1 << 3);
1512                                 set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 0 << 31);
1513                         }
1514                         printk(BIOS_DEBUG, "rs780_gfx_init step1.\n");
1515                         /* step 1.1, dual-slot gfx configuration (only need if CMOS option is enabled) */
1516                         /* AMD calls the configuration CrossFire */
1517                         set_nbmisc_enable_bits(nb_dev, 0x0, 0xf << 8, 5 << 8);
1518                         printk(BIOS_DEBUG, "rs780_gfx_init step2.\n");
1519
1520
1521                         printk(BIOS_DEBUG, "device = %x\n", dev->path.pci.devfn >> 3);
1522                         dual_port_configuration(nb_dev, dev);
1523
1524                 }else{
1525                         if (cfg->gfx_lane_reversal) {
1526                                 set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 1 << 31);
1527                                 set_nbmisc_enable_bits(nb_dev, 0x33, 1 << 2, 1 << 2);
1528                                 set_nbmisc_enable_bits(nb_dev, 0x36, 1 << 31, 0 << 31);
1529                         }
1530                         printk(BIOS_DEBUG, "rs780_gfx_init step1.\n");
1531
1532                         if((dev->path.pci.devfn >> 3) == 2)
1533                                 single_port_configuration(nb_dev, dev);
1534                         else{
1535                                 set_nbmisc_enable_bits(nb_dev, 0xc, 0, 0x2 << 2); /* hide the GFX bridge. */
1536                                 printk(BIOS_DEBUG, "If dev3.., single port. Do nothing.\n");
1537                             }
1538                 }
1539                 break;
1540
1541         default:
1542                 printk(BIOS_INFO, "Incorrect configuration of external GFX slot.\n");
1543                 break;
1544         }
1545 }