arch/x86/pci/direct.c

   1 /*
   2  * direct.c - Low-level direct PCI config space access
   3  */
   4
   5 #include <linux/pci.h>
   6 #include <linux/init.h>
   7 #include <linux/dmi.h>
   8 #include "pci.h"
   9
  10 /*
  11  * Functions for accessing PCI configuration space with type 1 accesses
  12  */
  13
  14 #define PCI_CONF1_ADDRESS(bus, devfn, reg) \
  15         (0x80000000 | (bus << 16) | (devfn << 8) | (reg & ~3))
  16
  17 static int pci_conf1_read(unsigned int seg, unsigned int bus,
  18                           unsigned int devfn, int reg, int len, u32 *value)
  19 {
  20         unsigned long flags;
  21
  22         if ((bus > 255) || (devfn > 255) || (reg > 255)) {
  23                 *value = -1;
  24                 return -EINVAL;
  25         }
  26
  27         spin_lock_irqsave(&pci_config_lock, flags);
  28
  29         outl(PCI_CONF1_ADDRESS(bus, devfn, reg), 0xCF8);
  30
  31         switch (len) {
  32         case 1:
  33                 *value = inb(0xCFC + (reg & 3));
  34                 break;
  35         case 2:
  36                 *value = inw(0xCFC + (reg & 2));
  37                 break;
  38         case 4:
  39                 *value = inl(0xCFC);
  40                 break;
  41         }
  42
  43         spin_unlock_irqrestore(&pci_config_lock, flags);
  44
  45         return 0;
  46 }
  47
  48 static int pci_conf1_write(unsigned int seg, unsigned int bus,
  49                            unsigned int devfn, int reg, int len, u32 value)
  50 {
  51         unsigned long flags;
  52
  53         if ((bus > 255) || (devfn > 255) || (reg > 255))
  54                 return -EINVAL;
  55
  56         spin_lock_irqsave(&pci_config_lock, flags);
  57
  58         outl(PCI_CONF1_ADDRESS(bus, devfn, reg), 0xCF8);
  59
  60         switch (len) {
  61         case 1:
  62                 outb((u8)value, 0xCFC + (reg & 3));
  63                 break;
  64         case 2:
  65                 outw((u16)value, 0xCFC + (reg & 2));
  66                 break;
  67         case 4:
  68                 outl((u32)value, 0xCFC);
  69                 break;
  70         }
  71
  72         spin_unlock_irqrestore(&pci_config_lock, flags);
  73
  74         return 0;
  75 }
  76
  77 #undef PCI_CONF1_ADDRESS
  78
  79 struct pci_raw_ops pci_direct_conf1 = {
  80         .read =         pci_conf1_read,
  81         .write =        pci_conf1_write,
  82 };
  83
  84
  85 /*
  86  * Functions for accessing PCI configuration space with type 2 accesses
  87  */
  88
  89 #define PCI_CONF2_ADDRESS(dev, reg)     (u16)(0xC000 | (dev << 8) | reg)
  90
  91 static int pci_conf2_read(unsigned int seg, unsigned int bus,
  92                           unsigned int devfn, int reg, int len, u32 *value)
  93 {
  94         unsigned long flags;
  95         int dev, fn;
  96
  97         if ((bus > 255) || (devfn > 255) || (reg > 255)) {
  98                 *value = -1;
  99                 return -EINVAL;
 100         }
 101
 102         dev = PCI_SLOT(devfn);
 103         fn = PCI_FUNC(devfn);
 104
 105         if (dev & 0x10)
 106                 return PCIBIOS_DEVICE_NOT_FOUND;
 107
 108         spin_lock_irqsave(&pci_config_lock, flags);
 109
 110         outb((u8)(0xF0 | (fn << 1)), 0xCF8);
 111         outb((u8)bus, 0xCFA);
 112
 113         switch (len) {
 114         case 1:
 115                 *value = inb(PCI_CONF2_ADDRESS(dev, reg));
 116                 break;
 117         case 2:
 118                 *value = inw(PCI_CONF2_ADDRESS(dev, reg));
 119                 break;
 120         case 4:
 121                 *value = inl(PCI_CONF2_ADDRESS(dev, reg));
 122                 break;
 123         }
 124
 125         outb(0, 0xCF8);
 126
 127         spin_unlock_irqrestore(&pci_config_lock, flags);
 128
 129         return 0;
 130 }
 131
 132 static int pci_conf2_write(unsigned int seg, unsigned int bus,
 133                            unsigned int devfn, int reg, int len, u32 value)
 134 {
 135         unsigned long flags;
 136         int dev, fn;
 137
 138         if ((bus > 255) || (devfn > 255) || (reg > 255))
 139                 return -EINVAL;
 140
 141         dev = PCI_SLOT(devfn);
 142         fn = PCI_FUNC(devfn);
 143
 144         if (dev & 0x10)
 145                 return PCIBIOS_DEVICE_NOT_FOUND;
 146
 147         spin_lock_irqsave(&pci_config_lock, flags);
 148
 149         outb((u8)(0xF0 | (fn << 1)), 0xCF8);
 150         outb((u8)bus, 0xCFA);
 151
 152         switch (len) {
 153         case 1:
 154                 outb((u8)value, PCI_CONF2_ADDRESS(dev, reg));
 155                 break;
 156         case 2:
 157                 outw((u16)value, PCI_CONF2_ADDRESS(dev, reg));
 158                 break;
 159         case 4:
 160                 outl((u32)value, PCI_CONF2_ADDRESS(dev, reg));
 161                 break;
 162         }
 163
 164         outb(0, 0xCF8);
 165
 166         spin_unlock_irqrestore(&pci_config_lock, flags);
 167
 168         return 0;
 169 }
 170
 171 #undef PCI_CONF2_ADDRESS
 172
 173 static struct pci_raw_ops pci_direct_conf2 = {
 174         .read =         pci_conf2_read,
 175         .write =        pci_conf2_write,
 176 };
 177
 178
 179 /*
 180  * Before we decide to use direct hardware access mechanisms, we try to do some
 181  * trivial checks to ensure it at least _seems_ to be working -- we just test
 182  * whether bus 00 contains a host bridge (this is similar to checking
 183  * techniques used in XFree86, but ours should be more reliable since we
 184  * attempt to make use of direct access hints provided by the PCI BIOS).
 185  *
 186  * This should be close to trivial, but it isn't, because there are buggy
 187  * chipsets (yes, you guessed it, by Intel and Compaq) that have no class ID.
 188  */
 189 static int __init pci_sanity_check(struct pci_raw_ops *o)
 190 {
 191         u32 x = 0;
 192         int devfn;
 193
 194         if (pci_probe & PCI_NO_CHECKS)
 195                 return 1;
 196         /* Assume Type 1 works for newer systems.
 197            This handles machines that don't have anything on PCI Bus 0. */
 198         if (dmi_get_year(DMI_BIOS_DATE) >= 2001)
 199                 return 1;
 200
 201         for (devfn = 0; devfn < 0x100; devfn++) {
 202                 if (o->read(0, 0, devfn, PCI_CLASS_DEVICE, 2, &x))
 203                         continue;
 204                 if (x == PCI_CLASS_BRIDGE_HOST || x == PCI_CLASS_DISPLAY_VGA)
 205                         return 1;
 206
 207                 if (o->read(0, 0, devfn, PCI_VENDOR_ID, 2, &x))
 208                         continue;
 209                 if (x == PCI_VENDOR_ID_INTEL || x == PCI_VENDOR_ID_COMPAQ)
 210                         return 1;
 211         }
 212
 213         DBG(KERN_WARNING "PCI: Sanity check failed\n");
 214         return 0;
 215 }
 216
 217 static int __init pci_check_type1(void)
 218 {
 219         unsigned long flags;
 220         unsigned int tmp;
 221         int works = 0;
 222
 223         local_irq_save(flags);
 224
 225         outb(0x01, 0xCFB);
 226         tmp = inl(0xCF8);
 227         outl(0x80000000, 0xCF8);
 228         if (inl(0xCF8) == 0x80000000 && pci_sanity_check(&pci_direct_conf1)) {
 229                 works = 1;
 230         }
 231         outl(tmp, 0xCF8);
 232         local_irq_restore(flags);
 233
 234         return works;
 235 }
 236
 237 static int __init pci_check_type2(void)
 238 {
 239         unsigned long flags;
 240         int works = 0;
 241
 242         local_irq_save(flags);
 243
 244         outb(0x00, 0xCFB);
 245         outb(0x00, 0xCF8);
 246         outb(0x00, 0xCFA);
 247         if (inb(0xCF8) == 0x00 && inb(0xCFA) == 0x00 &&
 248             pci_sanity_check(&pci_direct_conf2)) {
 249                 works = 1;
 250         }
 251
 252         local_irq_restore(flags);
 253
 254         return works;
 255 }
 256
 257 void __init pci_direct_init(int type)
 258 {
 259         if (type == 0)
 260                 return;
 261         printk(KERN_INFO "PCI: Using configuration type %d\n", type);
 262         if (type == 1)
 263                 raw_pci_ops = &pci_direct_conf1;
 264         else
 265                 raw_pci_ops = &pci_direct_conf2;
 266 }
 267
 268 int __init pci_direct_probe(void)
 269 {
 270         struct resource *region, *region2;
 271
 272         if ((pci_probe & PCI_PROBE_CONF1) == 0)
 273                 goto type2;
 274         region = request_region(0xCF8, 8, "PCI conf1");
 275         if (!region)
 276                 goto type2;
 277
 278         if (pci_check_type1())
 279                 return 1;
 280         release_resource(region);
 281
 282  type2:
 283         if ((pci_probe & PCI_PROBE_CONF2) == 0)
 284                 return 0;
 285         region = request_region(0xCF8, 4, "PCI conf2");
 286         if (!region)
 287                 return 0;
 288         region2 = request_region(0xC000, 0x1000, "PCI conf2");
 289         if (!region2)
 290                 goto fail2;
 291
 292         if (pci_check_type2()) {
 293                 printk(KERN_INFO "PCI: Using configuration type 2\n");
 294                 raw_pci_ops = &pci_direct_conf2;
 295                 return 2;
 296         }
 297
 298         release_resource(region2);
 299  fail2:
 300         release_resource(region);
 301         return 0;
 302 }