src/southbridge/amd/rs690/rs690_cmn.c

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