src/southbridge/amd/rs780/rs780_cmn.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 #include <console/console.h>
  21
  22 #include <arch/io.h>
  23
  24 #include <device/device.h>
  25 #include <device/pci.h>
  26 #include <device/pci_ids.h>
  27 #include <device/pci_ops.h>
  28 #include <cpu/x86/msr.h>
  29 #include <cpu/amd/mtrr.h>
  30 #include <boot/coreboot_tables.h>
  31 #include <delay.h>
  32 #include "rs780.h"
  33
  34 static u32 nb_read_index(device_t dev, u32 index_reg, u32 index)
  35 {
  36         pci_write_config32(dev, index_reg, index);
  37         return pci_read_config32(dev, index_reg + 0x4);
  38 }
  39
  40 static void nb_write_index(device_t dev, u32 index_reg, u32 index, u32 data)
  41 {
  42         pci_write_config32(dev, index_reg, index);
  43         pci_write_config32(dev, index_reg + 0x4, data);
  44 }
  45
  46 /* extension registers */
  47 u32 pci_ext_read_config32(device_t nb_dev, device_t dev, u32 reg)
  48 {
  49         /*get BAR3 base address for nbcfg0x1c */
  50         u32 addr = pci_read_config32(nb_dev, 0x1c) & ~0xF;
  51         printk_debug("addr=%x,bus=%x,devfn=%x\n", addr, dev->bus->secondary,
  52                      dev->path.pci.devfn);
  53         addr |= dev->bus->secondary << 20 |     /* bus num */
  54             dev->path.pci.devfn << 12 | reg;
  55         return *((u32 *) addr);
  56 }
  57
  58 void pci_ext_write_config32(device_t nb_dev, device_t dev, u32 reg_pos, u32 mask, u32 val)
  59 {
  60         u32 reg_old, reg;
  61
  62         /*get BAR3 base address for nbcfg0x1c */
  63         u32 addr = pci_read_config32(nb_dev, 0x1c) & ~0xF;
  64         /*printk_debug("write: addr=%x,bus=%x,devfn=%x\n", addr, dev->bus->secondary,
  65                      dev->path.pci.devfn);*/
  66         addr |= dev->bus->secondary << 20 |     /* bus num */
  67             dev->path.pci.devfn << 12 | reg_pos;
  68
  69         reg = reg_old = *((u32 *) addr);
  70         reg &= ~mask;
  71         reg |= val;
  72         if (reg != reg_old) {
  73                 *((u32 *) addr) = val;
  74         }
  75 }
  76
  77 u32 nbmisc_read_index(device_t nb_dev, u32 index)
  78 {
  79         return nb_read_index((nb_dev), NBMISC_INDEX, (index));
  80 }
  81
  82 void nbmisc_write_index(device_t nb_dev, u32 index, u32 data)
  83 {
  84         nb_write_index((nb_dev), NBMISC_INDEX, ((index) | 0x80), (data));
  85 }
  86
  87 u32 nbpcie_p_read_index(device_t dev, u32 index)
  88 {
  89         return nb_read_index((dev), NBPCIE_INDEX, (index));
  90 }
  91
  92 void nbpcie_p_write_index(device_t dev, u32 index, u32 data)
  93 {
  94         nb_write_index((dev), NBPCIE_INDEX, (index), (data));
  95 }
  96
  97 u32 nbpcie_ind_read_index(device_t nb_dev, u32 index)
  98 {
  99         return nb_read_index((nb_dev), NBPCIE_INDEX, (index));
 100 }
 101
 102 void nbpcie_ind_write_index(device_t nb_dev, u32 index, u32 data)
 103 {
 104         nb_write_index((nb_dev), NBPCIE_INDEX, (index), (data));
 105 }
 106
 107 u32 htiu_read_index(device_t nb_dev, u32 index)
 108 {
 109         return nb_read_index((nb_dev), NBHTIU_INDEX, (index));
 110 }
 111
 112 void htiu_write_index(device_t nb_dev, u32 index, u32 data)
 113 {
 114         nb_write_index((nb_dev), NBHTIU_INDEX, ((index) | 0x100), (data));
 115 }
 116
 117 u32 nbmc_read_index(device_t nb_dev, u32 index)
 118 {
 119         return nb_read_index((nb_dev), NBMC_INDEX, (index));
 120 }
 121
 122 void nbmc_write_index(device_t nb_dev, u32 index, u32 data)
 123 {
 124         nb_write_index((nb_dev), NBMC_INDEX, ((index) | 1 << 9), (data));
 125 }
 126
 127 void set_nbcfg_enable_bits(device_t nb_dev, u32 reg_pos, u32 mask, u32 val)
 128 {
 129         u32 reg_old, reg;
 130         reg = reg_old = pci_read_config32(nb_dev, reg_pos);
 131         reg &= ~mask;
 132         reg |= val;
 133         if (reg != reg_old) {
 134                 pci_write_config32(nb_dev, reg_pos, reg);
 135         }
 136 }
 137
 138 void set_nbcfg_enable_bits_8(device_t nb_dev, u32 reg_pos, u8 mask, u8 val)
 139 {
 140         u8 reg_old, reg;
 141         reg = reg_old = pci_read_config8(nb_dev, reg_pos);
 142         reg &= ~mask;
 143         reg |= val;
 144         if (reg != reg_old) {
 145                 pci_write_config8(nb_dev, reg_pos, reg);
 146         }
 147 }
 148
 149 void set_nbmc_enable_bits(device_t nb_dev, u32 reg_pos, u32 mask, u32 val)
 150 {
 151         u32 reg_old, reg;
 152         reg = reg_old = nbmc_read_index(nb_dev, reg_pos);
 153         reg &= ~mask;
 154         reg |= val;
 155         if (reg != reg_old) {
 156                 nbmc_write_index(nb_dev, reg_pos, reg);
 157         }
 158 }
 159
 160 void set_htiu_enable_bits(device_t nb_dev, u32 reg_pos, u32 mask, u32 val)
 161 {
 162         u32 reg_old, reg;
 163         reg = reg_old = htiu_read_index(nb_dev, reg_pos);
 164         reg &= ~mask;
 165         reg |= val;
 166         if (reg != reg_old) {
 167                 htiu_write_index(nb_dev, reg_pos, reg);
 168         }
 169 }
 170
 171 void set_nbmisc_enable_bits(device_t nb_dev, u32 reg_pos, u32 mask, u32 val)
 172 {
 173         u32 reg_old, reg;
 174         reg = reg_old = nbmisc_read_index(nb_dev, reg_pos);
 175         reg &= ~mask;
 176         reg |= val;
 177         if (reg != reg_old) {
 178                 nbmisc_write_index(nb_dev, reg_pos, reg);
 179         }
 180 }
 181
 182 void set_pcie_enable_bits(device_t dev, u32 reg_pos, u32 mask, u32 val)
 183 {
 184         u32 reg_old, reg;
 185         reg = reg_old = nb_read_index(dev, NBPCIE_INDEX, reg_pos);
 186         reg &= ~mask;
 187         reg |= val;
 188         if (reg != reg_old) {
 189                 nb_write_index(dev, NBPCIE_INDEX, reg_pos, reg);
 190         }
 191 }
 192
 193 /***********************************************************
 194 * To access bar3 we need to program PCI MMIO 7 in K8.
 195 * in_out:
 196 *       1: enable/enter k8 temp mmio base
 197 *       0: disable/restore
 198 ***********************************************************/
 199 void ProgK8TempMmioBase(u8 in_out, u32 pcie_base_add, u32 mmio_base_add)
 200 {
 201         /* K8 Function1 is address map */
 202         device_t k8_f1 = dev_find_slot(0, PCI_DEVFN(0x18, 1));
 203
 204         if (in_out) {
 205                 pci_write_config32(k8_f1, 0xbc,
 206                                    (((pcie_base_add + 0x10000000 -
 207                                      1) >> 8) & 0xffffff00) | 0x8);
 208                 pci_write_config32(k8_f1, 0xb8, (pcie_base_add >> 8) | 0x3);
 209                 pci_write_config32(k8_f1, 0xb4,
 210                                    ((mmio_base_add + 0x10000000 -
 211                                      1) >> 8) & 0xffffff00);
 212                 pci_write_config32(k8_f1, 0xb0, (mmio_base_add >> 8) | 0x3);
 213         } else {
 214                 pci_write_config32(k8_f1, 0xb8, 0);
 215                 pci_write_config32(k8_f1, 0xbc, 0);
 216                 pci_write_config32(k8_f1, 0xb0, 0);
 217                 pci_write_config32(k8_f1, 0xb4, 0);
 218         }
 219 }
 220
 221 void PcieReleasePortTraining(device_t nb_dev, device_t dev, u32 port)
 222 {
 223         switch (port) {
 224         case 2:         /* GFX, bit4-5 */
 225         case 3:
 226                 set_nbmisc_enable_bits(nb_dev, PCIE_LINK_CFG,
 227                                        1 << (port + 2), 0 << (port + 2));
 228                 break;
 229         case 4:         /* GPPSB, bit20-24 */
 230         case 5:
 231         case 6:
 232         case 7:
 233                 set_nbmisc_enable_bits(nb_dev, PCIE_LINK_CFG,
 234                                        1 << (port + 17), 0 << (port + 17));
 235                 break;
 236         case 9:         /* GPP, bit 4,5 of miscind 0x2D */
 237         case 10:
 238                 set_nbmisc_enable_bits(nb_dev, 0x2D,
 239                                       1 << (port - 5), 0 << (port - 5));
 240                 break;
 241         }
 242 }
 243
 244 /********************************************************************************************************
 245 * Output:
 246 *       0: no device is present.
 247 *       1: device is present and is trained.
 248 ********************************************************************************************************/
 249 u8 PcieTrainPort(device_t nb_dev, device_t dev, u32 port)
 250 {
 251         u16 count = 5000;
 252         u32 lc_state, reg, current_link_width, lane_mask;
 253         int8_t current, res = 0;
 254         u32 gfx_gpp_sb_sel;
 255         void set_pcie_dereset();
 256         void set_pcie_reset();
 257
 258         switch (port) {
 259         case 2 ... 3:
 260                 gfx_gpp_sb_sel = PCIE_CORE_INDEX_GFX;
 261                 break;
 262         case 4 ... 7:
 263                 gfx_gpp_sb_sel = PCIE_CORE_INDEX_GPPSB;
 264                 break;
 265         case 9 ... 10:
 266                 gfx_gpp_sb_sel = PCIE_CORE_INDEX_GPP;
 267                 break;
 268         }
 269
 270         while (count--) {
 271                 mdelay(40);
 272                 udelay(200);
 273                 lc_state = nbpcie_p_read_index(dev, 0xa5);      /* lc_state */
 274                 printk_debug("PcieLinkTraining port=%x:lc current state=%x\n",
 275                              port, lc_state);
 276                 current = lc_state & 0x3f;      /* get LC_CURRENT_STATE, bit0-5 */
 277
 278                 switch (current) {
 279                 case 0x00:      /* 0x00-0x04 means no device is present */
 280                 case 0x01:
 281                 case 0x02:
 282                 case 0x03:
 283                 case 0x04:
 284                         res = 0;
 285                         count = 0;
 286                         break;
 287                 case 0x06:
 288                         /* read back current link width [6:4]. */
 289                         current_link_width = (nbpcie_p_read_index(dev, 0xA2) >> 4) & 0x7;
 290                         /* 4 means 7:4 and 15:12
 291                          * 3 means 7:2 and 15:10
 292                          * 2 means 7:1 and 15:9
 293                          * egnoring the reversal case
 294                          */
 295                         lane_mask = (0xFF << (current_link_width - 2) * 2) & 0xFF;
 296                         reg = nbpcie_ind_read_index(nb_dev, 0x65 | gfx_gpp_sb_sel);
 297                         reg |= lane_mask << 8 | lane_mask;
 298                         reg = 0xE0E0; /* TODO: See the comments in rs780_pcie.c, at about line 145. */
 299                         nbpcie_ind_write_index(nb_dev, 0x65 | gfx_gpp_sb_sel, reg);
 300                         printk_debug("link_width=%x, lane_mask=%x",
 301                                      current_link_width, lane_mask);
 302                         set_pcie_reset();
 303                         mdelay(1);
 304                         set_pcie_dereset();
 305                         break;
 306                 case 0x07:      /* device is in compliance state (training sequence is done). Move to train the next device */
 307                         res = 0;
 308                         count = 0;
 309                         break;
 310                 case 0x10:
 311                         reg =
 312                             pci_ext_read_config32(nb_dev, dev,
 313                                                   PCIE_VC0_RESOURCE_STATUS);
 314                         printk_debug("PcieTrainPort reg=0x%x\n", reg);
 315                         /* check bit1 */
 316                         if (reg & VC_NEGOTIATION_PENDING) {     /* bit1=1 means the link needs to be re-trained. */
 317                                 /* set bit8=1, bit0-2=bit4-6 */
 318                                 u32 tmp;
 319                                 reg =
 320                                     nbpcie_p_read_index(dev,
 321                                                         PCIE_LC_LINK_WIDTH);
 322                                 tmp = (reg >> 4) && 0x3;        /* get bit4-6 */
 323                                 reg &= 0xfff8;  /* clear bit0-2 */
 324                                 reg += tmp;     /* merge */
 325                                 reg |= 1 << 8;
 326                                 count++;        /* CIM said "keep in loop"?  */
 327                         } else {
 328                                 res = 1;
 329                                 count = 0;
 330                         }
 331                         break;
 332                 default:        /* reset pcie */
 333                         res = 0;
 334                         count = 0;      /* break loop */
 335                         break;
 336                 }
 337         }
 338         return res;
 339 }
 340
 341 /*
 342 * Compliant with CIM_33's ATINB_SetToms.
 343 * Set Top Of Memory below and above 4G.
 344 */
 345 void rs780_set_tom(device_t nb_dev)
 346 {
 347         extern uint64_t uma_memory_base;
 348
 349         /* set TOM */
 350         pci_write_config32(nb_dev, 0x90, uma_memory_base);
 351         //nbmc_write_index(nb_dev, 0x1e, uma_memory_base);
 352 }