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