src/northbridge/amd/amdk8/setup_resource_map.c

   1 #define RES_DEBUG 0
   2
   3 #define RES_PCI_IO 0x10
   4 #define RES_PORT_IO_8 0x22
   5 #define RES_PORT_IO_32 0x20
   6 #define RES_MEM_IO 0x30
   7
   8 static void setup_resource_map_x(const unsigned int *register_values, int max)
   9 {
  10         int i;
  11
  12 #if RES_DEBUG
  13         print_debug("setting up resource map ex....");
  14
  15 #endif
  16
  17 #if RES_DEBUG
  18         print_debug("\r\n");
  19 #endif
  20         for(i = 0; i < max; i += 4) {
  21 #if RES_DEBUG
  22                 print_debug_hex16(i/4);
  23                 print_debug(": ");
  24                 print_debug_hex8(register_values[i]);
  25                 print_debug(" ");
  26                 print_debug_hex32(register_values[i+1]);
  27                 print_debug(" <- & ");
  28                 print_debug_hex32(register_values[i+2]);
  29                 print_debug(" | ");
  30                 print_debug_hex32(register_values[i+3]);
  31                 print_debug("\r\n");
  32 #endif
  33                 switch (register_values[i]) {
  34                 case RES_PCI_IO: //PCI
  35                         {
  36                         device_t dev;
  37                         unsigned where;
  38                         unsigned long reg;
  39                         dev = register_values[i+1] & ~0xff;
  40                         where = register_values[i+1] & 0xff;
  41                         reg = pci_read_config32(dev, where);
  42                         reg &= register_values[i+2];
  43                         reg |= register_values[i+3];
  44                         pci_write_config32(dev, where, reg);
  45                         }
  46                         break;
  47                 case RES_PORT_IO_8: // io 8
  48                         {
  49                         unsigned where;
  50                         unsigned reg;
  51                         where = register_values[i+1];
  52                         reg = inb(where);
  53                         reg &= register_values[i+2];
  54                         reg |= register_values[i+3];
  55                         outb(reg, where);
  56                         }
  57                         break;
  58                 case RES_PORT_IO_32:  //io32
  59                         {
  60                         unsigned where;
  61                         unsigned long reg;
  62                         where = register_values[i+1];
  63                         reg = inl(where);
  64                         reg &= register_values[i+2];
  65                         reg |= register_values[i+3];
  66                         outl(reg, where);
  67                         }
  68                         break;
  69 #if 0
  70                 case RES_MEM_IO: //mem
  71                         {
  72                         unsigned where;
  73                         unsigned long reg;
  74                         where = register_values[i+1];
  75                         reg = read32(where);
  76                         reg &= register_values[i+2];
  77                         reg |= register_values[i+3];
  78                         write32( where, reg);
  79                         }
  80                         break;
  81 #endif
  82
  83                 } // switch
  84
  85
  86         }
  87
  88 #if RES_DEBUG
  89         print_debug("done.\r\n");
  90 #endif
  91 }
  92
  93
  94 static void setup_iob_resource_map(const unsigned int *register_values, int max)
  95 {
  96         int i;
  97
  98         for(i = 0; i < max; i += 3) {
  99                 unsigned where;
 100                 unsigned reg;
 101
 102                 where = register_values[i];
 103 #if 0
 104                 udelay(2000);
 105                 print_debug_hex16(where);
 106 #endif
 107                 reg = inb(where);
 108 #if 0
 109                 print_debug("=");
 110                 print_debug_hex8(reg);
 111 #endif
 112
 113                 reg &= register_values[i+1];
 114                 reg |= register_values[i+2];
 115 #if 0
 116                 print_debug(" <-  ");
 117                 print_debug_hex8(reg);
 118 #endif
 119                 outb(reg, where);
 120 #if 0
 121
 122                 print_debug(" -> ");
 123                 reg = inb(where);
 124                 print_debug_hex8(reg);
 125                 print_debug("\r\n");
 126 #endif
 127         }
 128 }
 129
 130 static void setup_io_resource_map(const unsigned int *register_values, int max)
 131 {
 132         int i;
 133
 134         for(i = 0; i < max; i += 3) {
 135                 unsigned where;
 136                 unsigned long reg;
 137
 138                 where = register_values[i];
 139 #if 0
 140                 udelay(2000);
 141                 print_debug_hex16(where);
 142 #endif
 143
 144                 reg = inl(where);
 145 #if 0
 146                 udelay(2000);
 147                 print_debug("=");
 148                 print_debug_hex32(reg);
 149 #endif
 150                 reg &= register_values[i+1];
 151                 reg |= register_values[i+2];
 152
 153 #if 0
 154                 udelay(2000);
 155                 print_debug(" <-  ");
 156                 print_debug_hex32(reg);
 157 #endif
 158                 outl(reg, where);
 159 #if 0
 160                 udelay(2000);
 161                 print_debug(" -> ");
 162                 reg = inl(where);
 163                 print_debug_hex32(reg);
 164                 print_debug("\r\n");
 165 #endif
 166         }
 167 }
 168
 169 #if 0
 170 static void setup_mem_resource_map(const unsigned int *register_values, int max)
 171 {
 172         int i;
 173
 174         for(i = 0; i < max; i += 3) {
 175                 unsigned where;
 176                 unsigned long reg;
 177 #if 0
 178                 print_debug_hex32(register_values[i]);
 179                 print_debug(" <-");
 180                 print_debug_hex32(register_values[i+2]);
 181 #endif
 182                 where = register_values[i];
 183                 reg = read32(where);
 184                 reg &= register_values[i+1];
 185                 reg |= register_values[i+2];
 186                 write32( where, reg);
 187 #if 0
 188                 print_debug(" RB ");
 189                 reg = read32(where);
 190                 print_debug_hex32(reg);
 191                 print_debug("\r\n");
 192 #endif
 193         }
 194 }
 195 #endif
 196