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