src/northbridge/amd/amdfam10/setup_resource_map.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2007 Advanced Micro Devices, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20
  21 #define RES_DEBUG 0
  22
  23 static void setup_resource_map(const u32 *register_values, u32 max)
  24 {
  25         u32 i;
  26 //      print_debug("setting up resource map....");
  27
  28         for(i = 0; i < max; i += 3) {
  29                 device_t dev;
  30                 u32 where;
  31                 u32 reg;
  32
  33                 dev = register_values[i] & ~0xff;
  34                 where = register_values[i] & 0xff;
  35                 reg = pci_read_config32(dev, where);
  36                 reg &= register_values[i+1];
  37                 reg |= register_values[i+2];
  38                 pci_write_config32(dev, where, reg);
  39         }
  40 //      print_debug("done.\n");
  41 }
  42
  43
  44 static void setup_resource_map_offset(const u32 *register_values,
  45                                         u32 max, u32 offset_pci_dev,
  46                                         u32 offset_io_base)
  47 {
  48         u32 i;
  49 //      print_debug("setting up resource map offset....");
  50         for(i = 0; i < max; i += 3) {
  51                 device_t dev;
  52                 u32 where;
  53                 unsigned long reg;
  54                 dev = (register_values[i] & ~0xfff) + offset_pci_dev;
  55                 where = register_values[i] & 0xfff;
  56                 reg = pci_read_config32(dev, where);
  57                 reg &= register_values[i+1];
  58                 reg |= register_values[i+2] + offset_io_base;
  59                 pci_write_config32(dev, where, reg);
  60         }
  61 //      print_debug("done.\n");
  62 }
  63
  64 #define RES_PCI_IO 0x10
  65 #define RES_PORT_IO_8 0x22
  66 #define RES_PORT_IO_32 0x20
  67 #define RES_MEM_IO 0x40
  68
  69 static void setup_resource_map_x_offset(const u32 *register_values, u32 max,
  70                                         u32 offset_pci_dev, u32 offset_io_base)
  71 {
  72         u32 i;
  73
  74 #if RES_DEBUG
  75         print_debug("setting up resource map ex offset....");
  76
  77 #endif
  78
  79 #if RES_DEBUG
  80         print_debug("\n");
  81 #endif
  82         for(i = 0; i < max; i += 4) {
  83 #if RES_DEBUG
  84                 printk(BIOS_DEBUG, "%04x: %02x %08x <- & %08x | %08x\n",
  85                         i/4, register_values[i],
  86                         register_values[i+1] + ( (register_values[i]==RES_PCI_IO) ? offset_pci_dev : 0),
  87                         register_values[i+2],
  88                         register_values[i+3] + ( ( (register_values[i] & RES_PORT_IO_32) == RES_PORT_IO_32) ? offset_io_base : 0)
  89                         );
  90 #endif
  91                 switch (register_values[i]) {
  92                 case RES_PCI_IO: //PCI
  93                         {
  94                         device_t dev;
  95                         u32 where;
  96                         u32 reg;
  97                         dev = (register_values[i+1] & ~0xfff) + offset_pci_dev;
  98                         where = register_values[i+1] & 0xfff;
  99                         reg = pci_read_config32(dev, where);
 100                         reg &= register_values[i+2];
 101                         reg |= register_values[i+3];
 102                         pci_write_config32(dev, where, reg);
 103                         }
 104                         break;
 105                 case RES_PORT_IO_8: // io 8
 106                         {
 107                         u32 where;
 108                         u32 reg;
 109                         where = register_values[i+1] + offset_io_base;
 110                         reg = inb(where);
 111                         reg &= register_values[i+2];
 112                         reg |= register_values[i+3];
 113                         outb(reg, where);
 114                         }
 115                         break;
 116                 case RES_PORT_IO_32:  //io32
 117                         {
 118                         u32 where;
 119                         u32 reg;
 120                         where = register_values[i+1] + offset_io_base;
 121                         reg = inl(where);
 122                         reg &= register_values[i+2];
 123                         reg |= register_values[i+3];
 124                         outl(reg, where);
 125                         }
 126                         break;
 127                 } // switch
 128
 129
 130         }
 131
 132 #if RES_DEBUG
 133         print_debug("done.\n");
 134 #endif
 135 }
 136 static void setup_resource_map_x(const u32 *register_values, u32 max)
 137 {
 138         u32 i;
 139
 140 #if RES_DEBUG
 141         print_debug("setting up resource map ex offset....");
 142 #endif
 143
 144 #if RES_DEBUG
 145         print_debug("\n");
 146 #endif
 147         for(i = 0; i < max; i += 4) {
 148 #if RES_DEBUG
 149                 printk(BIOS_DEBUG, "%04x: %02x %08x <- & %08x | %08x\n",
 150                 i/4, register_values[i],register_values[i+1], register_values[i+2], register_values[i+3]);
 151 #endif
 152                 switch (register_values[i]) {
 153                 case RES_PCI_IO: //PCI
 154                         {
 155                         device_t dev;
 156                         u32 where;
 157                         u32 reg;
 158                         dev = register_values[i+1] & ~0xff;
 159                         where = register_values[i+1] & 0xff;
 160                         reg = pci_read_config32(dev, where);
 161                         reg &= register_values[i+2];
 162                         reg |= register_values[i+3];
 163                         pci_write_config32(dev, where, reg);
 164                         }
 165                         break;
 166                 case RES_PORT_IO_8: // io 8
 167                         {
 168                         u32 where;
 169                         u32 reg;
 170                         where = register_values[i+1];
 171                         reg = inb(where);
 172                         reg &= register_values[i+2];
 173                         reg |= register_values[i+3];
 174                         outb(reg, where);
 175                         }
 176                         break;
 177                 case RES_PORT_IO_32:  //io32
 178                         {
 179                         u32 where;
 180                         u32 reg;
 181                         where = register_values[i+1];
 182                         reg = inl(where);
 183                         reg &= register_values[i+2];
 184                         reg |= register_values[i+3];
 185                         outl(reg, where);
 186                         }
 187                         break;
 188                 } // switch
 189
 190
 191         }
 192
 193 #if RES_DEBUG
 194         print_debug("done.\n");
 195 #endif
 196 }
 197
 198 static void setup_iob_resource_map(const u32 *register_values, u32 max)
 199 {
 200         u32 i;
 201
 202         for(i = 0; i < max; i += 3) {
 203                 u32 where;
 204                 u32 reg;
 205
 206                 where = register_values[i];
 207                 reg = inb(where);
 208                 reg &= register_values[i+1];
 209                 reg |= register_values[i+2];
 210                 outb(reg, where);
 211         }
 212 }
 213
 214 static void setup_io_resource_map(const u32 *register_values, u32 max)
 215 {
 216         u32 i;
 217
 218         for(i = 0; i < max; i += 3) {
 219                 u32 where;
 220                 u32 reg;
 221
 222                 where = register_values[i];
 223                 reg = inl(where);
 224                 reg &= register_values[i+1];
 225                 reg |= register_values[i+2];
 226
 227                 outl(reg, where);
 228         }
 229 }
 230
 231