1 /* 2 * BIOS32 and PCI BIOS handling. 3 */ 4 5 #include <linux/pci.h> 6 #include <linux/init.h> 7 #include <linux/module.h> 8 #include <linux/uaccess.h> 9 #include <asm/pci_x86.h> 10 #include <asm/pci-functions.h> 11 12 /* BIOS32 signature: "_32_" */ 13 #define BIOS32_SIGNATURE (('_' << 0) + ('3' << 8) + ('2' << 16) + ('_' << 24)) 14 15 /* PCI signature: "PCI " */ 16 #define PCI_SIGNATURE (('P' << 0) + ('C' << 8) + ('I' << 16) + (' ' << 24)) 17 18 /* PCI service signature: "$PCI" */ 19 #define PCI_SERVICE (('$' << 0) + ('P' << 8) + ('C' << 16) + ('I' << 24)) 20 21 /* PCI BIOS hardware mechanism flags */ 22 #define PCIBIOS_HW_TYPE1 0x01 23 #define PCIBIOS_HW_TYPE2 0x02 24 #define PCIBIOS_HW_TYPE1_SPEC 0x10 25 #define PCIBIOS_HW_TYPE2_SPEC 0x20 26 27 /* 28 * This is the standard structure used to identify the entry point 29 * to the BIOS32 Service Directory, as documented in 30 * Standard BIOS 32-bit Service Directory Proposal 31 * Revision 0.4 May 24, 1993 32 * Phoenix Technologies Ltd. 33 * Norwood, MA 34 * and the PCI BIOS specification. 35 */ 36 37 union bios32 { 38 struct { 39 unsigned long signature; /* _32_ */ 40 unsigned long entry; /* 32 bit physical address */ 41 unsigned char revision; /* Revision level, 0 */ 42 unsigned char length; /* Length in paragraphs should be 01 */ 43 unsigned char checksum; /* All bytes must add up to zero */ 44 unsigned char reserved[5]; /* Must be zero */ 45 } fields; 46 char chars[16]; 47 }; 48 49 /* 50 * Physical address of the service directory. I don't know if we're 51 * allowed to have more than one of these or not, so just in case 52 * we'll make pcibios_present() take a memory start parameter and store 53 * the array there. 54 */ 55 56 static struct { 57 unsigned long address; 58 unsigned short segment; 59 } bios32_indirect = { 0, __KERNEL_CS }; 60 61 /* 62 * Returns the entry point for the given service, NULL on error 63 */ 64 65 static unsigned long bios32_service(unsigned long service) 66 { 67 unsigned char return_code; /* %al */ 68 unsigned long address; /* %ebx */ 69 unsigned long length; /* %ecx */ 70 unsigned long entry; /* %edx */ 71 unsigned long flags; 72 73 local_irq_save(flags); 74 __asm__("lcall *(%%edi); cld" 75 : "=a" (return_code), 76 "=b" (address), 77 "=c" (length), 78 "=d" (entry) 79 : "0" (service), 80 "1" (0), 81 "D" (&bios32_indirect)); 82 local_irq_restore(flags); 83 84 switch (return_code) { 85 case 0: 86 return address + entry; 87 case 0x80: /* Not present */ 88 printk(KERN_WARNING "bios32_service(0x%lx): not present\n", service); 89 return 0; 90 default: /* Shouldn't happen */ 91 printk(KERN_WARNING "bios32_service(0x%lx): returned 0x%x -- BIOS bug!\n", 92 service, return_code); 93 return 0; 94 } 95 } 96 97 static struct { 98 unsigned long address; 99 unsigned short segment; 100 } pci_indirect = { 0, __KERNEL_CS }; 101 102 static int pci_bios_present; 103 104 static int __devinit check_pcibios(void) 105 { 106 u32 signature, eax, ebx, ecx; 107 u8 status, major_ver, minor_ver, hw_mech; 108 unsigned long flags, pcibios_entry; 109 110 if ((pcibios_entry = bios32_service(PCI_SERVICE))) { 111 pci_indirect.address = pcibios_entry + PAGE_OFFSET; 112 113 local_irq_save(flags); 114 __asm__( 115 "lcall *(%%edi); cld\n\t" 116 "jc 1f\n\t" 117 "xor %%ah, %%ah\n" 118 "1:" 119 : "=d" (signature), 120 "=a" (eax), 121 "=b" (ebx), 122 "=c" (ecx) 123 : "1" (PCIBIOS_PCI_BIOS_PRESENT), 124 "D" (&pci_indirect) 125 : "memory"); 126 local_irq_restore(flags); 127 128 status = (eax >> 8) & 0xff; 129 hw_mech = eax & 0xff; 130 major_ver = (ebx >> 8) & 0xff; 131 minor_ver = ebx & 0xff; 132 if (pcibios_last_bus < 0) 133 pcibios_last_bus = ecx & 0xff; 134 DBG("PCI: BIOS probe returned s=%02x hw=%02x ver=%02x.%02x l=%02x\n", 135 status, hw_mech, major_ver, minor_ver, pcibios_last_bus); 136 if (status || signature != PCI_SIGNATURE) { 137 printk (KERN_ERR "PCI: BIOS BUG #%x[%08x] found\n", 138 status, signature); 139 return 0; 140 } 141 printk(KERN_INFO "PCI: PCI BIOS revision %x.%02x entry at 0x%lx, last bus=%d\n", 142 major_ver, minor_ver, pcibios_entry, pcibios_last_bus); 143 #ifdef CONFIG_PCI_DIRECT 144 if (!(hw_mech & PCIBIOS_HW_TYPE1)) 145 pci_probe &= ~PCI_PROBE_CONF1; 146 if (!(hw_mech & PCIBIOS_HW_TYPE2)) 147 pci_probe &= ~PCI_PROBE_CONF2; 148 #endif 149 return 1; 150 } 151 return 0; 152 } 153 154 static int pci_bios_read(unsigned int seg, unsigned int bus, 155 unsigned int devfn, int reg, int len, u32 *value) 156 { 157 unsigned long result = 0; 158 unsigned long flags; 159 unsigned long bx = (bus << 8) | devfn; 160 161 if (!value || (bus > 255) || (devfn > 255) || (reg > 255)) 162 return -EINVAL; 163 164 spin_lock_irqsave(&pci_config_lock, flags); 165 166 switch (len) { 167 case 1: 168 __asm__("lcall *(%%esi); cld\n\t" 169 "jc 1f\n\t" 170 "xor %%ah, %%ah\n" 171 "1:" 172 : "=c" (*value), 173 "=a" (result) 174 : "1" (PCIBIOS_READ_CONFIG_BYTE), 175 "b" (bx), 176 "D" ((long)reg), 177 "S" (&pci_indirect)); 178 /* 179 * Zero-extend the result beyond 8 bits, do not trust the 180 * BIOS having done it: 181 */ 182 *value &= 0xff; 183 break; 184 case 2: 185 __asm__("lcall *(%%esi); cld\n\t" 186 "jc 1f\n\t" 187 "xor %%ah, %%ah\n" 188 "1:" 189 : "=c" (*value), 190 "=a" (result) 191 : "1" (PCIBIOS_READ_CONFIG_WORD), 192 "b" (bx), 193 "D" ((long)reg), 194 "S" (&pci_indirect)); 195 /* 196 * Zero-extend the result beyond 16 bits, do not trust the 197 * BIOS having done it: 198 */ 199 *value &= 0xffff; 200 break; 201 case 4: 202 __asm__("lcall *(%%esi); cld\n\t" 203 "jc 1f\n\t" 204 "xor %%ah, %%ah\n" 205 "1:" 206 : "=c" (*value), 207 "=a" (result) 208 : "1" (PCIBIOS_READ_CONFIG_DWORD), 209 "b" (bx), 210 "D" ((long)reg), 211 "S" (&pci_indirect)); 212 break; 213 } 214 215 spin_unlock_irqrestore(&pci_config_lock, flags); 216 217 return (int)((result & 0xff00) >> 8); 218 } 219 220 static int pci_bios_write(unsigned int seg, unsigned int bus, 221 unsigned int devfn, int reg, int len, u32 value) 222 { 223 unsigned long result = 0; 224 unsigned long flags; 225 unsigned long bx = (bus << 8) | devfn; 226 227 if ((bus > 255) || (devfn > 255) || (reg > 255)) 228 return -EINVAL; 229 230 spin_lock_irqsave(&pci_config_lock, flags); 231 232 switch (len) { 233 case 1: 234 __asm__("lcall *(%%esi); cld\n\t" 235 "jc 1f\n\t" 236 "xor %%ah, %%ah\n" 237 "1:" 238 : "=a" (result) 239 : "0" (PCIBIOS_WRITE_CONFIG_BYTE), 240 "c" (value), 241 "b" (bx), 242 "D" ((long)reg), 243 "S" (&pci_indirect)); 244 break; 245 case 2: 246 __asm__("lcall *(%%esi); cld\n\t" 247 "jc 1f\n\t" 248 "xor %%ah, %%ah\n" 249 "1:" 250 : "=a" (result) 251 : "0" (PCIBIOS_WRITE_CONFIG_WORD), 252 "c" (value), 253 "b" (bx), 254 "D" ((long)reg), 255 "S" (&pci_indirect)); 256 break; 257 case 4: 258 __asm__("lcall *(%%esi); cld\n\t" 259 "jc 1f\n\t" 260 "xor %%ah, %%ah\n" 261 "1:" 262 : "=a" (result) 263 : "0" (PCIBIOS_WRITE_CONFIG_DWORD), 264 "c" (value), 265 "b" (bx), 266 "D" ((long)reg), 267 "S" (&pci_indirect)); 268 break; 269 } 270 271 spin_unlock_irqrestore(&pci_config_lock, flags); 272 273 return (int)((result & 0xff00) >> 8); 274 } 275 276 277 /* 278 * Function table for BIOS32 access 279 */ 280 281 static struct pci_raw_ops pci_bios_access = { 282 .read = pci_bios_read, 283 .write = pci_bios_write 284 }; 285 286 /* 287 * Try to find PCI BIOS. 288 */ 289 290 static struct pci_raw_ops * __devinit pci_find_bios(void) 291 { 292 union bios32 *check; 293 unsigned char sum; 294 int i, length; 295 296 /* 297 * Follow the standard procedure for locating the BIOS32 Service 298 * directory by scanning the permissible address range from 299 * 0xe0000 through 0xfffff for a valid BIOS32 structure. 300 */ 301 302 for (check = (union bios32 *) __va(0xe0000); 303 check <= (union bios32 *) __va(0xffff0); 304 ++check) { 305 long sig; 306 if (probe_kernel_address(&check->fields.signature, sig)) 307 continue; 308 309 if (check->fields.signature != BIOS32_SIGNATURE) 310 continue; 311 length = check->fields.length * 16; 312 if (!length) 313 continue; 314 sum = 0; 315 for (i = 0; i < length ; ++i) 316 sum += check->chars[i]; 317 if (sum != 0) 318 continue; 319 if (check->fields.revision != 0) { 320 printk("PCI: unsupported BIOS32 revision %d at 0x%p\n", 321 check->fields.revision, check); 322 continue; 323 } 324 DBG("PCI: BIOS32 Service Directory structure at 0x%p\n", check); 325 if (check->fields.entry >= 0x100000) { 326 printk("PCI: BIOS32 entry (0x%p) in high memory, " 327 "cannot use.\n", check); 328 return NULL; 329 } else { 330 unsigned long bios32_entry = check->fields.entry; 331 DBG("PCI: BIOS32 Service Directory entry at 0x%lx\n", 332 bios32_entry); 333 bios32_indirect.address = bios32_entry + PAGE_OFFSET; 334 if (check_pcibios()) 335 return &pci_bios_access; 336 } 337 break; /* Hopefully more than one BIOS32 cannot happen... */ 338 } 339 340 return NULL; 341 } 342 343 /* 344 * BIOS Functions for IRQ Routing 345 */ 346 347 struct irq_routing_options { 348 u16 size; 349 struct irq_info *table; 350 u16 segment; 351 } __attribute__((packed)); 352 353 struct irq_routing_table * pcibios_get_irq_routing_table(void) 354 { 355 struct irq_routing_options opt; 356 struct irq_routing_table *rt = NULL; 357 int ret, map; 358 unsigned long page; 359 360 if (!pci_bios_present) 361 return NULL; 362 page = __get_free_page(GFP_KERNEL); 363 if (!page) 364 return NULL; 365 opt.table = (struct irq_info *) page; 366 opt.size = PAGE_SIZE; 367 opt.segment = __KERNEL_DS; 368 369 DBG("PCI: Fetching IRQ routing table... "); 370 __asm__("push %%es\n\t" 371 "push %%ds\n\t" 372 "pop %%es\n\t" 373 "lcall *(%%esi); cld\n\t" 374 "pop %%es\n\t" 375 "jc 1f\n\t" 376 "xor %%ah, %%ah\n" 377 "1:" 378 : "=a" (ret), 379 "=b" (map), 380 "=m" (opt) 381 : "0" (PCIBIOS_GET_ROUTING_OPTIONS), 382 "1" (0), 383 "D" ((long) &opt), 384 "S" (&pci_indirect), 385 "m" (opt) 386 : "memory"); 387 DBG("OK ret=%d, size=%d, map=%x\n", ret, opt.size, map); 388 if (ret & 0xff00) 389 printk(KERN_ERR "PCI: Error %02x when fetching IRQ routing table.\n", (ret >> 8) & 0xff); 390 else if (opt.size) { 391 rt = kmalloc(sizeof(struct irq_routing_table) + opt.size, GFP_KERNEL); 392 if (rt) { 393 memset(rt, 0, sizeof(struct irq_routing_table)); 394 rt->size = opt.size + sizeof(struct irq_routing_table); 395 rt->exclusive_irqs = map; 396 memcpy(rt->slots, (void *) page, opt.size); 397 printk(KERN_INFO "PCI: Using BIOS Interrupt Routing Table\n"); 398 } 399 } 400 free_page(page); 401 return rt; 402 } 403 EXPORT_SYMBOL(pcibios_get_irq_routing_table); 404 405 int pcibios_set_irq_routing(struct pci_dev *dev, int pin, int irq) 406 { 407 int ret; 408 409 __asm__("lcall *(%%esi); cld\n\t" 410 "jc 1f\n\t" 411 "xor %%ah, %%ah\n" 412 "1:" 413 : "=a" (ret) 414 : "0" (PCIBIOS_SET_PCI_HW_INT), 415 "b" ((dev->bus->number << 8) | dev->devfn), 416 "c" ((irq << 8) | (pin + 10)), 417 "S" (&pci_indirect)); 418 return !(ret & 0xff00); 419 } 420 EXPORT_SYMBOL(pcibios_set_irq_routing); 421 422 void __init pci_pcbios_init(void) 423 { 424 if ((pci_probe & PCI_PROBE_BIOS) 425 && ((raw_pci_ops = pci_find_bios()))) { 426 pci_bios_present = 1; 427 } 428 } 429 430