src/northbridge/amd/amdk8/setup_resource_map.c

   1 #define RES_DEBUG 0
   2
   3 static void setup_resource_map_offset(const unsigned int *register_values, int max, unsigned offset_pci_dev, unsigned offset_io_base)
   4 {
   5         int i;
   6 //      print_debug("setting up resource map offset....");
   7 #if 0
   8         print_debug("\r\n");
   9 #endif
  10         for(i = 0; i < max; i += 3) {
  11                 device_t dev;
  12                 unsigned where;
  13                 unsigned long reg;
  14 #if 0
  15         #if CONFIG_USE_PRINTK_IN_CAR
  16                 prink_debug("%08x <- %08x\r\n", register_values[i] +  offset_pci_dev, register_values[i+2]);
  17         #else
  18                 print_debug_hex32(register_values[i] + offset_pci_dev);
  19                 print_debug(" <-");
  20                 print_debug_hex32(register_values[i+2]);
  21                 print_debug("\r\n");
  22         #endif
  23 #endif
  24                 dev = (register_values[i] & ~0xfff) + offset_pci_dev;
  25                 where = register_values[i] & 0xfff;
  26                 reg = pci_read_config32(dev, where);
  27                 reg &= register_values[i+1];
  28                 reg |= register_values[i+2] + offset_io_base;
  29                 pci_write_config32(dev, where, reg);
  30 #if 0
  31                 reg = pci_read_config32(register_values[i]);
  32                 reg &= register_values[i+1];
  33                 reg |= register_values[i+2] & ~register_values[i+1];
  34                 pci_write_config32(register_values[i], reg);
  35 #endif
  36         }
  37 //      print_debug("done.\r\n");
  38 }
  39
  40 #define RES_PCI_IO 0x10
  41 #define RES_PORT_IO_8 0x22
  42 #define RES_PORT_IO_32 0x20
  43 #define RES_MEM_IO 0x40
  44
  45 static void setup_resource_map_x_offset(const unsigned int *register_values, int max, unsigned offset_pci_dev, unsigned offset_io_base)
  46 {
  47         int i;
  48
  49 #if RES_DEBUG
  50         print_debug("setting up resource map ex offset....");
  51
  52 #endif
  53
  54 #if RES_DEBUG
  55         print_debug("\r\n");
  56 #endif
  57         for(i = 0; i < max; i += 4) {
  58 #if RES_DEBUG
  59         #if CONFIG_USE_PRINTK_IN_CAR
  60                 printk_debug("%04x: %02x %08x <- & %08x | %08x\r\n",
  61                         i>>2, register_values[i],
  62                         register_values[i+1] + ( (register_values[i]==RES_PCI_IO) ? offset_pci_dev : 0),
  63                         register_values[i+2],
  64                         register_values[i+3] + ( ( (register_values[i] & RES_PORT_IO_32) == RES_PORT_IO_32) ? offset_io_base : 0)
  65                         );
  66         #else
  67                 print_debug_hex16(i>>2);
  68                 print_debug(": ");
  69                 print_debug_hex8(register_values[i]);
  70                 print_debug(" ");
  71                 print_debug_hex32(register_values[i+1] + ( (register_values[i]==RES_PCI_IO) ? offset_pci_dev : 0) );
  72                 print_debug(" <- & ");
  73                 print_debug_hex32(register_values[i+2]);
  74                 print_debug(" | ");
  75                 print_debug_hex32(register_values[i+3] +
  76                         (((register_values[i] & RES_PORT_IO_32) == RES_PORT_IO_32) ? offset_io_base : 0)
  77                         );
  78                 print_debug("\r\n");
  79         #endif
  80 #endif
  81                 switch (register_values[i]) {
  82                 case RES_PCI_IO: //PCI
  83                         {
  84                         device_t dev;
  85                         unsigned where;
  86                         unsigned long reg;
  87                         dev = (register_values[i+1] & ~0xfff) + offset_pci_dev;
  88                         where = register_values[i+1] & 0xfff;
  89                         reg = pci_read_config32(dev, where);
  90                         reg &= register_values[i+2];
  91                         reg |= register_values[i+3];
  92                         pci_write_config32(dev, where, reg);
  93                         }
  94                         break;
  95                 case RES_PORT_IO_8: // io 8
  96                         {
  97                         unsigned where;
  98                         unsigned reg;
  99                         where = register_values[i+1] + offset_io_base;
 100                         reg = inb(where);
 101                         reg &= register_values[i+2];
 102                         reg |= register_values[i+3];
 103                         outb(reg, where);
 104                         }
 105                         break;
 106                 case RES_PORT_IO_32:  //io32
 107                         {
 108                         unsigned where;
 109                         unsigned long reg;
 110                         where = register_values[i+1] + offset_io_base;
 111                         reg = inl(where);
 112                         reg &= register_values[i+2];
 113                         reg |= register_values[i+3];
 114                         outl(reg, where);
 115                         }
 116                         break;
 117 #if 0
 118                 case RES_MEM_IO: //mem
 119                         {
 120                         unsigned where;
 121                         unsigned long reg;
 122                         where = register_values[i+1];
 123                         reg = read32(where);
 124                         reg &= register_values[i+2];
 125                         reg |= register_values[i+3];
 126                         write32( where, reg);
 127                         }
 128                         break;
 129 #endif
 130
 131                 } // switch
 132
 133
 134         }
 135
 136 #if RES_DEBUG
 137         print_debug("done.\r\n");
 138 #endif
 139 }
 140 static void setup_resource_map_x(const unsigned int *register_values, int max)
 141 {
 142         int i;
 143
 144 #if RES_DEBUG
 145         print_debug("setting up resource map ex offset....");
 146
 147 #endif
 148
 149 #if RES_DEBUG
 150         print_debug("\r\n");
 151 #endif
 152         for(i = 0; i < max; i += 4) {
 153 #if RES_DEBUG
 154         #if CONFIG_USE_PRINTK_IN_CAR
 155                 printk_debug("%04x: %02x %08x <- & %08x | %08x\r\n",
 156                         i/4, register_values[i],register_values[i+1], register_values[i+2], register_values[i+3]);
 157         #else
 158                 print_debug_hex16(i/4);
 159                 print_debug(": ");
 160                 print_debug_hex8(register_values[i]);
 161                 print_debug(" ");
 162                 print_debug_hex32(register_values[i+1]);
 163                 print_debug(" <- & ");
 164                 print_debug_hex32(register_values[i+2]);
 165                 print_debug(" | ");
 166                 print_debug_hex32(register_values[i+3]);
 167                 print_debug("\r\n");
 168         #endif
 169 #endif
 170                 switch (register_values[i]) {
 171                 case RES_PCI_IO: //PCI
 172                         {
 173                         device_t dev;
 174                         unsigned where;
 175                         unsigned long reg;
 176                         dev = register_values[i+1] & ~0xfff;
 177                         where = register_values[i+1] & 0xfff;
 178                         reg = pci_read_config32(dev, where);
 179                         reg &= register_values[i+2];
 180                         reg |= register_values[i+3];
 181                         pci_write_config32(dev, where, reg);
 182                         }
 183                         break;
 184                 case RES_PORT_IO_8: // io 8
 185                         {
 186                         unsigned where;
 187                         unsigned reg;
 188                         where = register_values[i+1];
 189                         reg = inb(where);
 190                         reg &= register_values[i+2];
 191                         reg |= register_values[i+3];
 192                         outb(reg, where);
 193                         }
 194                         break;
 195                 case RES_PORT_IO_32:  //io32
 196                         {
 197                         unsigned where;
 198                         unsigned long reg;
 199                         where = register_values[i+1];
 200                         reg = inl(where);
 201                         reg &= register_values[i+2];
 202                         reg |= register_values[i+3];
 203                         outl(reg, where);
 204                         }
 205                         break;
 206 #if 0
 207                 case RES_MEM_IO: //mem
 208                         {
 209                         unsigned where;
 210                         unsigned long reg;
 211                         where = register_values[i+1];
 212                         reg = read32(where);
 213                         reg &= register_values[i+2];
 214                         reg |= register_values[i+3];
 215                         write32( where, reg);
 216                         }
 217                         break;
 218 #endif
 219
 220                 } // switch
 221
 222
 223         }
 224
 225 #if RES_DEBUG
 226         print_debug("done.\r\n");
 227 #endif
 228 }
 229
 230 static void setup_iob_resource_map(const unsigned int *register_values, int max)
 231 {
 232         int i;
 233
 234         for(i = 0; i < max; i += 3) {
 235                 unsigned where;
 236                 unsigned reg;
 237
 238                 where = register_values[i];
 239 #if 0
 240                 udelay(2000);
 241                 print_debug_hex16(where);
 242 #endif
 243                 reg = inb(where);
 244 #if 0
 245                 print_debug("=");
 246                 print_debug_hex8(reg);
 247 #endif
 248
 249                 reg &= register_values[i+1];
 250                 reg |= register_values[i+2];
 251 #if 0
 252                 print_debug(" <-  ");
 253                 print_debug_hex8(reg);
 254 #endif
 255                 outb(reg, where);
 256 #if 0
 257
 258                 print_debug(" -> ");
 259                 reg = inb(where);
 260                 print_debug_hex8(reg);
 261                 print_debug("\r\n");
 262 #endif
 263         }
 264 }
 265
 266 static void setup_io_resource_map(const unsigned int *register_values, int max)
 267 {
 268         int i;
 269
 270         for(i = 0; i < max; i += 3) {
 271                 unsigned where;
 272                 unsigned long reg;
 273
 274                 where = register_values[i];
 275 #if 0
 276                 udelay(2000);
 277                 print_debug_hex16(where);
 278 #endif
 279
 280                 reg = inl(where);
 281 #if 0
 282                 udelay(2000);
 283                 print_debug("=");
 284                 print_debug_hex32(reg);
 285 #endif
 286                 reg &= register_values[i+1];
 287                 reg |= register_values[i+2];
 288
 289 #if 0
 290                 udelay(2000);
 291                 print_debug(" <-  ");
 292                 print_debug_hex32(reg);
 293 #endif
 294                 outl(reg, where);
 295 #if 0
 296                 udelay(2000);
 297                 print_debug(" -> ");
 298                 reg = inl(where);
 299                 print_debug_hex32(reg);
 300                 print_debug("\r\n");
 301 #endif
 302         }
 303 }
 304
 305 #if 0
 306 static void setup_mem_resource_map(const unsigned int *register_values, int max)
 307 {
 308         int i;
 309
 310         for(i = 0; i < max; i += 3) {
 311                 unsigned where;
 312                 unsigned long reg;
 313 #if 0
 314                 print_debug_hex32(register_values[i]);
 315                 print_debug(" <-");
 316                 print_debug_hex32(register_values[i+2]);
 317 #endif
 318                 where = register_values[i];
 319                 reg = read32(where);
 320                 reg &= register_values[i+1];
 321                 reg |= register_values[i+2];
 322                 write32( where, reg);
 323 #if 0
 324                 print_debug(" RB ");
 325                 reg = read32(where);
 326                 print_debug_hex32(reg);
 327                 print_debug("\r\n");
 328 #endif
 329         }
 330 }
 331 #endif
 332