1 /* 2 * arch/parisc/kernel/firmware.c - safe PDC access routines 3 * 4 * PDC == Processor Dependent Code 5 * 6 * See http://www.parisc-linux.org/documentation/index.html 7 * for documentation describing the entry points and calling 8 * conventions defined below. 9 * 10 * Copyright 1999 SuSE GmbH Nuernberg (Philipp Rumpf, prumpf@tux.org) 11 * Copyright 1999 The Puffin Group, (Alex deVries, David Kennedy) 12 * Copyright 2003 Grant Grundler <grundler parisc-linux org> 13 * Copyright 2003,2004 Ryan Bradetich <rbrad@parisc-linux.org> 14 * Copyright 2004,2006 Thibaut VARENE <varenet@parisc-linux.org> 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License as published by 18 * the Free Software Foundation; either version 2 of the License, or 19 * (at your option) any later version. 20 * 21 */ 22 23 /* I think it would be in everyone's best interest to follow this 24 * guidelines when writing PDC wrappers: 25 * 26 * - the name of the pdc wrapper should match one of the macros 27 * used for the first two arguments 28 * - don't use caps for random parts of the name 29 * - use the static PDC result buffers and "copyout" to structs 30 * supplied by the caller to encapsulate alignment restrictions 31 * - hold pdc_lock while in PDC or using static result buffers 32 * - use __pa() to convert virtual (kernel) pointers to physical 33 * ones. 34 * - the name of the struct used for pdc return values should equal 35 * one of the macros used for the first two arguments to the 36 * corresponding PDC call 37 * - keep the order of arguments 38 * - don't be smart (setting trailing NUL bytes for strings, return 39 * something useful even if the call failed) unless you are sure 40 * it's not going to affect functionality or performance 41 * 42 * Example: 43 * int pdc_cache_info(struct pdc_cache_info *cache_info ) 44 * { 45 * int retval; 46 * 47 * spin_lock_irq(&pdc_lock); 48 * retval = mem_pdc_call(PDC_CACHE,PDC_CACHE_INFO,__pa(cache_info),0); 49 * convert_to_wide(pdc_result); 50 * memcpy(cache_info, pdc_result, sizeof(*cache_info)); 51 * spin_unlock_irq(&pdc_lock); 52 * 53 * return retval; 54 * } 55 * prumpf 991016 56 */ 57 58 #include <stdarg.h> 59 60 #include <linux/delay.h> 61 #include <linux/init.h> 62 #include <linux/kernel.h> 63 #include <linux/module.h> 64 #include <linux/string.h> 65 #include <linux/spinlock.h> 66 67 #include <asm/page.h> 68 #include <asm/pdc.h> 69 #include <asm/pdcpat.h> 70 #include <asm/processor.h> /* for boot_cpu_data */ 71 72 static DEFINE_SPINLOCK(pdc_lock); 73 extern unsigned long pdc_result[NUM_PDC_RESULT]; 74 extern unsigned long pdc_result2[NUM_PDC_RESULT]; 75 76 #ifdef CONFIG_64BIT 77 #define WIDE_FIRMWARE 0x1 78 #define NARROW_FIRMWARE 0x2 79 80 /* Firmware needs to be initially set to narrow to determine the 81 * actual firmware width. */ 82 int parisc_narrow_firmware __read_mostly = 1; 83 #endif 84 85 /* On most currently-supported platforms, IODC I/O calls are 32-bit calls 86 * and MEM_PDC calls are always the same width as the OS. 87 * Some PAT boxes may have 64-bit IODC I/O. 88 * 89 * Ryan Bradetich added the now obsolete CONFIG_PDC_NARROW to allow 90 * 64-bit kernels to run on systems with 32-bit MEM_PDC calls. 91 * This allowed wide kernels to run on Cxxx boxes. 92 * We now detect 32-bit-only PDC and dynamically switch to 32-bit mode 93 * when running a 64-bit kernel on such boxes (e.g. C200 or C360). 94 */ 95 96 #ifdef CONFIG_64BIT 97 long real64_call(unsigned long function, ...); 98 #endif 99 long real32_call(unsigned long function, ...); 100 101 #ifdef CONFIG_64BIT 102 # define MEM_PDC (unsigned long)(PAGE0->mem_pdc_hi) << 32 | PAGE0->mem_pdc 103 # define mem_pdc_call(args...) unlikely(parisc_narrow_firmware) ? real32_call(MEM_PDC, args) : real64_call(MEM_PDC, args) 104 #else 105 # define MEM_PDC (unsigned long)PAGE0->mem_pdc 106 # define mem_pdc_call(args...) real32_call(MEM_PDC, args) 107 #endif 108 109 110 /** 111 * f_extend - Convert PDC addresses to kernel addresses. 112 * @address: Address returned from PDC. 113 * 114 * This function is used to convert PDC addresses into kernel addresses 115 * when the PDC address size and kernel address size are different. 116 */ 117 static unsigned long f_extend(unsigned long address) 118 { 119 #ifdef CONFIG_64BIT 120 if(unlikely(parisc_narrow_firmware)) { 121 if((address & 0xff000000) == 0xf0000000) 122 return 0xf0f0f0f000000000UL | (u32)address; 123 124 if((address & 0xf0000000) == 0xf0000000) 125 return 0xffffffff00000000UL | (u32)address; 126 } 127 #endif 128 return address; 129 } 130 131 /** 132 * convert_to_wide - Convert the return buffer addresses into kernel addresses. 133 * @address: The return buffer from PDC. 134 * 135 * This function is used to convert the return buffer addresses retrieved from PDC 136 * into kernel addresses when the PDC address size and kernel address size are 137 * different. 138 */ 139 static void convert_to_wide(unsigned long *addr) 140 { 141 #ifdef CONFIG_64BIT 142 int i; 143 unsigned int *p = (unsigned int *)addr; 144 145 if(unlikely(parisc_narrow_firmware)) { 146 for(i = 31; i >= 0; --i) 147 addr[i] = p[i]; 148 } 149 #endif 150 } 151 152 #ifdef CONFIG_64BIT 153 void __cpuinit set_firmware_width_unlocked(void) 154 { 155 int ret; 156 157 ret = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, 158 __pa(pdc_result), 0); 159 convert_to_wide(pdc_result); 160 if (pdc_result[0] != NARROW_FIRMWARE) 161 parisc_narrow_firmware = 0; 162 } 163 164 /** 165 * set_firmware_width - Determine if the firmware is wide or narrow. 166 * 167 * This function must be called before any pdc_* function that uses the 168 * convert_to_wide function. 169 */ 170 void __cpuinit set_firmware_width(void) 171 { 172 unsigned long flags; 173 spin_lock_irqsave(&pdc_lock, flags); 174 set_firmware_width_unlocked(); 175 spin_unlock_irqrestore(&pdc_lock, flags); 176 } 177 #else 178 void __cpuinit set_firmware_width_unlocked(void) { 179 return; 180 } 181 182 void __cpuinit set_firmware_width(void) { 183 return; 184 } 185 #endif /*CONFIG_64BIT*/ 186 187 /** 188 * pdc_emergency_unlock - Unlock the linux pdc lock 189 * 190 * This call unlocks the linux pdc lock in case we need some PDC functions 191 * (like pdc_add_valid) during kernel stack dump. 192 */ 193 void pdc_emergency_unlock(void) 194 { 195 /* Spinlock DEBUG code freaks out if we unconditionally unlock */ 196 if (spin_is_locked(&pdc_lock)) 197 spin_unlock(&pdc_lock); 198 } 199 200 201 /** 202 * pdc_add_valid - Verify address can be accessed without causing a HPMC. 203 * @address: Address to be verified. 204 * 205 * This PDC call attempts to read from the specified address and verifies 206 * if the address is valid. 207 * 208 * The return value is PDC_OK (0) in case accessing this address is valid. 209 */ 210 int pdc_add_valid(unsigned long address) 211 { 212 int retval; 213 unsigned long flags; 214 215 spin_lock_irqsave(&pdc_lock, flags); 216 retval = mem_pdc_call(PDC_ADD_VALID, PDC_ADD_VALID_VERIFY, address); 217 spin_unlock_irqrestore(&pdc_lock, flags); 218 219 return retval; 220 } 221 EXPORT_SYMBOL(pdc_add_valid); 222 223 /** 224 * pdc_chassis_info - Return chassis information. 225 * @result: The return buffer. 226 * @chassis_info: The memory buffer address. 227 * @len: The size of the memory buffer address. 228 * 229 * An HVERSION dependent call for returning the chassis information. 230 */ 231 int __init pdc_chassis_info(struct pdc_chassis_info *chassis_info, void *led_info, unsigned long len) 232 { 233 int retval; 234 unsigned long flags; 235 236 spin_lock_irqsave(&pdc_lock, flags); 237 memcpy(&pdc_result, chassis_info, sizeof(*chassis_info)); 238 memcpy(&pdc_result2, led_info, len); 239 retval = mem_pdc_call(PDC_CHASSIS, PDC_RETURN_CHASSIS_INFO, 240 __pa(pdc_result), __pa(pdc_result2), len); 241 memcpy(chassis_info, pdc_result, sizeof(*chassis_info)); 242 memcpy(led_info, pdc_result2, len); 243 spin_unlock_irqrestore(&pdc_lock, flags); 244 245 return retval; 246 } 247 248 /** 249 * pdc_pat_chassis_send_log - Sends a PDC PAT CHASSIS log message. 250 * @retval: -1 on error, 0 on success. Other value are PDC errors 251 * 252 * Must be correctly formatted or expect system crash 253 */ 254 #ifdef CONFIG_64BIT 255 int pdc_pat_chassis_send_log(unsigned long state, unsigned long data) 256 { 257 int retval = 0; 258 unsigned long flags; 259 260 if (!is_pdc_pat()) 261 return -1; 262 263 spin_lock_irqsave(&pdc_lock, flags); 264 retval = mem_pdc_call(PDC_PAT_CHASSIS_LOG, PDC_PAT_CHASSIS_WRITE_LOG, __pa(&state), __pa(&data)); 265 spin_unlock_irqrestore(&pdc_lock, flags); 266 267 return retval; 268 } 269 #endif 270 271 /** 272 * pdc_chassis_disp - Updates chassis code 273 * @retval: -1 on error, 0 on success 274 */ 275 int pdc_chassis_disp(unsigned long disp) 276 { 277 int retval = 0; 278 unsigned long flags; 279 280 spin_lock_irqsave(&pdc_lock, flags); 281 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_DISP, disp); 282 spin_unlock_irqrestore(&pdc_lock, flags); 283 284 return retval; 285 } 286 287 /** 288 * pdc_chassis_warn - Fetches chassis warnings 289 * @retval: -1 on error, 0 on success 290 */ 291 int pdc_chassis_warn(unsigned long *warn) 292 { 293 int retval = 0; 294 unsigned long flags; 295 296 spin_lock_irqsave(&pdc_lock, flags); 297 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_WARN, __pa(pdc_result)); 298 *warn = pdc_result[0]; 299 spin_unlock_irqrestore(&pdc_lock, flags); 300 301 return retval; 302 } 303 304 int __cpuinit pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg *pdc_coproc_info) 305 { 306 int ret; 307 308 ret = mem_pdc_call(PDC_COPROC, PDC_COPROC_CFG, __pa(pdc_result)); 309 convert_to_wide(pdc_result); 310 pdc_coproc_info->ccr_functional = pdc_result[0]; 311 pdc_coproc_info->ccr_present = pdc_result[1]; 312 pdc_coproc_info->revision = pdc_result[17]; 313 pdc_coproc_info->model = pdc_result[18]; 314 315 return ret; 316 } 317 318 /** 319 * pdc_coproc_cfg - To identify coprocessors attached to the processor. 320 * @pdc_coproc_info: Return buffer address. 321 * 322 * This PDC call returns the presence and status of all the coprocessors 323 * attached to the processor. 324 */ 325 int __cpuinit pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info) 326 { 327 int ret; 328 unsigned long flags; 329 330 spin_lock_irqsave(&pdc_lock, flags); 331 ret = pdc_coproc_cfg_unlocked(pdc_coproc_info); 332 spin_unlock_irqrestore(&pdc_lock, flags); 333 334 return ret; 335 } 336 337 /** 338 * pdc_iodc_read - Read data from the modules IODC. 339 * @actcnt: The actual number of bytes. 340 * @hpa: The HPA of the module for the iodc read. 341 * @index: The iodc entry point. 342 * @iodc_data: A buffer memory for the iodc options. 343 * @iodc_data_size: Size of the memory buffer. 344 * 345 * This PDC call reads from the IODC of the module specified by the hpa 346 * argument. 347 */ 348 int pdc_iodc_read(unsigned long *actcnt, unsigned long hpa, unsigned int index, 349 void *iodc_data, unsigned int iodc_data_size) 350 { 351 int retval; 352 unsigned long flags; 353 354 spin_lock_irqsave(&pdc_lock, flags); 355 retval = mem_pdc_call(PDC_IODC, PDC_IODC_READ, __pa(pdc_result), hpa, 356 index, __pa(pdc_result2), iodc_data_size); 357 convert_to_wide(pdc_result); 358 *actcnt = pdc_result[0]; 359 memcpy(iodc_data, pdc_result2, iodc_data_size); 360 spin_unlock_irqrestore(&pdc_lock, flags); 361 362 return retval; 363 } 364 EXPORT_SYMBOL(pdc_iodc_read); 365 366 /** 367 * pdc_system_map_find_mods - Locate unarchitected modules. 368 * @pdc_mod_info: Return buffer address. 369 * @mod_path: pointer to dev path structure. 370 * @mod_index: fixed address module index. 371 * 372 * To locate and identify modules which reside at fixed I/O addresses, which 373 * do not self-identify via architected bus walks. 374 */ 375 int pdc_system_map_find_mods(struct pdc_system_map_mod_info *pdc_mod_info, 376 struct pdc_module_path *mod_path, long mod_index) 377 { 378 int retval; 379 unsigned long flags; 380 381 spin_lock_irqsave(&pdc_lock, flags); 382 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_MODULE, __pa(pdc_result), 383 __pa(pdc_result2), mod_index); 384 convert_to_wide(pdc_result); 385 memcpy(pdc_mod_info, pdc_result, sizeof(*pdc_mod_info)); 386 memcpy(mod_path, pdc_result2, sizeof(*mod_path)); 387 spin_unlock_irqrestore(&pdc_lock, flags); 388 389 pdc_mod_info->mod_addr = f_extend(pdc_mod_info->mod_addr); 390 return retval; 391 } 392 393 /** 394 * pdc_system_map_find_addrs - Retrieve additional address ranges. 395 * @pdc_addr_info: Return buffer address. 396 * @mod_index: Fixed address module index. 397 * @addr_index: Address range index. 398 * 399 * Retrieve additional information about subsequent address ranges for modules 400 * with multiple address ranges. 401 */ 402 int pdc_system_map_find_addrs(struct pdc_system_map_addr_info *pdc_addr_info, 403 long mod_index, long addr_index) 404 { 405 int retval; 406 unsigned long flags; 407 408 spin_lock_irqsave(&pdc_lock, flags); 409 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_ADDRESS, __pa(pdc_result), 410 mod_index, addr_index); 411 convert_to_wide(pdc_result); 412 memcpy(pdc_addr_info, pdc_result, sizeof(*pdc_addr_info)); 413 spin_unlock_irqrestore(&pdc_lock, flags); 414 415 pdc_addr_info->mod_addr = f_extend(pdc_addr_info->mod_addr); 416 return retval; 417 } 418 419 /** 420 * pdc_model_info - Return model information about the processor. 421 * @model: The return buffer. 422 * 423 * Returns the version numbers, identifiers, and capabilities from the processor module. 424 */ 425 int pdc_model_info(struct pdc_model *model) 426 { 427 int retval; 428 unsigned long flags; 429 430 spin_lock_irqsave(&pdc_lock, flags); 431 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_INFO, __pa(pdc_result), 0); 432 convert_to_wide(pdc_result); 433 memcpy(model, pdc_result, sizeof(*model)); 434 spin_unlock_irqrestore(&pdc_lock, flags); 435 436 return retval; 437 } 438 439 /** 440 * pdc_model_sysmodel - Get the system model name. 441 * @name: A char array of at least 81 characters. 442 * 443 * Get system model name from PDC ROM (e.g. 9000/715 or 9000/778/B160L). 444 * Using OS_ID_HPUX will return the equivalent of the 'modelname' command 445 * on HP/UX. 446 */ 447 int pdc_model_sysmodel(char *name) 448 { 449 int retval; 450 unsigned long flags; 451 452 spin_lock_irqsave(&pdc_lock, flags); 453 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_SYSMODEL, __pa(pdc_result), 454 OS_ID_HPUX, __pa(name)); 455 convert_to_wide(pdc_result); 456 457 if (retval == PDC_OK) { 458 name[pdc_result[0]] = '\0'; /* add trailing '\0' */ 459 } else { 460 name[0] = 0; 461 } 462 spin_unlock_irqrestore(&pdc_lock, flags); 463 464 return retval; 465 } 466 467 /** 468 * pdc_model_versions - Identify the version number of each processor. 469 * @cpu_id: The return buffer. 470 * @id: The id of the processor to check. 471 * 472 * Returns the version number for each processor component. 473 * 474 * This comment was here before, but I do not know what it means :( -RB 475 * id: 0 = cpu revision, 1 = boot-rom-version 476 */ 477 int pdc_model_versions(unsigned long *versions, int id) 478 { 479 int retval; 480 unsigned long flags; 481 482 spin_lock_irqsave(&pdc_lock, flags); 483 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_VERSIONS, __pa(pdc_result), id); 484 convert_to_wide(pdc_result); 485 *versions = pdc_result[0]; 486 spin_unlock_irqrestore(&pdc_lock, flags); 487 488 return retval; 489 } 490 491 /** 492 * pdc_model_cpuid - Returns the CPU_ID. 493 * @cpu_id: The return buffer. 494 * 495 * Returns the CPU_ID value which uniquely identifies the cpu portion of 496 * the processor module. 497 */ 498 int pdc_model_cpuid(unsigned long *cpu_id) 499 { 500 int retval; 501 unsigned long flags; 502 503 spin_lock_irqsave(&pdc_lock, flags); 504 pdc_result[0] = 0; /* preset zero (call may not be implemented!) */ 505 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CPU_ID, __pa(pdc_result), 0); 506 convert_to_wide(pdc_result); 507 *cpu_id = pdc_result[0]; 508 spin_unlock_irqrestore(&pdc_lock, flags); 509 510 return retval; 511 } 512 513 /** 514 * pdc_model_capabilities - Returns the platform capabilities. 515 * @capabilities: The return buffer. 516 * 517 * Returns information about platform support for 32- and/or 64-bit 518 * OSes, IO-PDIR coherency, and virtual aliasing. 519 */ 520 int pdc_model_capabilities(unsigned long *capabilities) 521 { 522 int retval; 523 unsigned long flags; 524 525 spin_lock_irqsave(&pdc_lock, flags); 526 pdc_result[0] = 0; /* preset zero (call may not be implemented!) */ 527 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, __pa(pdc_result), 0); 528 convert_to_wide(pdc_result); 529 if (retval == PDC_OK) { 530 *capabilities = pdc_result[0]; 531 } else { 532 *capabilities = PDC_MODEL_OS32; 533 } 534 spin_unlock_irqrestore(&pdc_lock, flags); 535 536 return retval; 537 } 538 539 /** 540 * pdc_cache_info - Return cache and TLB information. 541 * @cache_info: The return buffer. 542 * 543 * Returns information about the processor's cache and TLB. 544 */ 545 int pdc_cache_info(struct pdc_cache_info *cache_info) 546 { 547 int retval; 548 unsigned long flags; 549 550 spin_lock_irqsave(&pdc_lock, flags); 551 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_INFO, __pa(pdc_result), 0); 552 convert_to_wide(pdc_result); 553 memcpy(cache_info, pdc_result, sizeof(*cache_info)); 554 spin_unlock_irqrestore(&pdc_lock, flags); 555 556 return retval; 557 } 558 559 /** 560 * pdc_spaceid_bits - Return whether Space ID hashing is turned on. 561 * @space_bits: Should be 0, if not, bad mojo! 562 * 563 * Returns information about Space ID hashing. 564 */ 565 int pdc_spaceid_bits(unsigned long *space_bits) 566 { 567 int retval; 568 unsigned long flags; 569 570 spin_lock_irqsave(&pdc_lock, flags); 571 pdc_result[0] = 0; 572 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_RET_SPID, __pa(pdc_result), 0); 573 convert_to_wide(pdc_result); 574 *space_bits = pdc_result[0]; 575 spin_unlock_irqrestore(&pdc_lock, flags); 576 577 return retval; 578 } 579 580 #ifndef CONFIG_PA20 581 /** 582 * pdc_btlb_info - Return block TLB information. 583 * @btlb: The return buffer. 584 * 585 * Returns information about the hardware Block TLB. 586 */ 587 int pdc_btlb_info(struct pdc_btlb_info *btlb) 588 { 589 int retval; 590 unsigned long flags; 591 592 spin_lock_irqsave(&pdc_lock, flags); 593 retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_INFO, __pa(pdc_result), 0); 594 memcpy(btlb, pdc_result, sizeof(*btlb)); 595 spin_unlock_irqrestore(&pdc_lock, flags); 596 597 if(retval < 0) { 598 btlb->max_size = 0; 599 } 600 return retval; 601 } 602 603 /** 604 * pdc_mem_map_hpa - Find fixed module information. 605 * @address: The return buffer 606 * @mod_path: pointer to dev path structure. 607 * 608 * This call was developed for S700 workstations to allow the kernel to find 609 * the I/O devices (Core I/O). In the future (Kittyhawk and beyond) this 610 * call will be replaced (on workstations) by the architected PDC_SYSTEM_MAP 611 * call. 612 * 613 * This call is supported by all existing S700 workstations (up to Gecko). 614 */ 615 int pdc_mem_map_hpa(struct pdc_memory_map *address, 616 struct pdc_module_path *mod_path) 617 { 618 int retval; 619 unsigned long flags; 620 621 spin_lock_irqsave(&pdc_lock, flags); 622 memcpy(pdc_result2, mod_path, sizeof(*mod_path)); 623 retval = mem_pdc_call(PDC_MEM_MAP, PDC_MEM_MAP_HPA, __pa(pdc_result), 624 __pa(pdc_result2)); 625 memcpy(address, pdc_result, sizeof(*address)); 626 spin_unlock_irqrestore(&pdc_lock, flags); 627 628 return retval; 629 } 630 #endif /* !CONFIG_PA20 */ 631 632 /** 633 * pdc_lan_station_id - Get the LAN address. 634 * @lan_addr: The return buffer. 635 * @hpa: The network device HPA. 636 * 637 * Get the LAN station address when it is not directly available from the LAN hardware. 638 */ 639 int pdc_lan_station_id(char *lan_addr, unsigned long hpa) 640 { 641 int retval; 642 unsigned long flags; 643 644 spin_lock_irqsave(&pdc_lock, flags); 645 retval = mem_pdc_call(PDC_LAN_STATION_ID, PDC_LAN_STATION_ID_READ, 646 __pa(pdc_result), hpa); 647 if (retval < 0) { 648 /* FIXME: else read MAC from NVRAM */ 649 memset(lan_addr, 0, PDC_LAN_STATION_ID_SIZE); 650 } else { 651 memcpy(lan_addr, pdc_result, PDC_LAN_STATION_ID_SIZE); 652 } 653 spin_unlock_irqrestore(&pdc_lock, flags); 654 655 return retval; 656 } 657 EXPORT_SYMBOL(pdc_lan_station_id); 658 659 /** 660 * pdc_stable_read - Read data from Stable Storage. 661 * @staddr: Stable Storage address to access. 662 * @memaddr: The memory address where Stable Storage data shall be copied. 663 * @count: number of bytes to transfer. count is multiple of 4. 664 * 665 * This PDC call reads from the Stable Storage address supplied in staddr 666 * and copies count bytes to the memory address memaddr. 667 * The call will fail if staddr+count > PDC_STABLE size. 668 */ 669 int pdc_stable_read(unsigned long staddr, void *memaddr, unsigned long count) 670 { 671 int retval; 672 unsigned long flags; 673 674 spin_lock_irqsave(&pdc_lock, flags); 675 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_READ, staddr, 676 __pa(pdc_result), count); 677 convert_to_wide(pdc_result); 678 memcpy(memaddr, pdc_result, count); 679 spin_unlock_irqrestore(&pdc_lock, flags); 680 681 return retval; 682 } 683 EXPORT_SYMBOL(pdc_stable_read); 684 685 /** 686 * pdc_stable_write - Write data to Stable Storage. 687 * @staddr: Stable Storage address to access. 688 * @memaddr: The memory address where Stable Storage data shall be read from. 689 * @count: number of bytes to transfer. count is multiple of 4. 690 * 691 * This PDC call reads count bytes from the supplied memaddr address, 692 * and copies count bytes to the Stable Storage address staddr. 693 * The call will fail if staddr+count > PDC_STABLE size. 694 */ 695 int pdc_stable_write(unsigned long staddr, void *memaddr, unsigned long count) 696 { 697 int retval; 698 unsigned long flags; 699 700 spin_lock_irqsave(&pdc_lock, flags); 701 memcpy(pdc_result, memaddr, count); 702 convert_to_wide(pdc_result); 703 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_WRITE, staddr, 704 __pa(pdc_result), count); 705 spin_unlock_irqrestore(&pdc_lock, flags); 706 707 return retval; 708 } 709 EXPORT_SYMBOL(pdc_stable_write); 710 711 /** 712 * pdc_stable_get_size - Get Stable Storage size in bytes. 713 * @size: pointer where the size will be stored. 714 * 715 * This PDC call returns the number of bytes in the processor's Stable 716 * Storage, which is the number of contiguous bytes implemented in Stable 717 * Storage starting from staddr=0. size in an unsigned 64-bit integer 718 * which is a multiple of four. 719 */ 720 int pdc_stable_get_size(unsigned long *size) 721 { 722 int retval; 723 unsigned long flags; 724 725 spin_lock_irqsave(&pdc_lock, flags); 726 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_RETURN_SIZE, __pa(pdc_result)); 727 *size = pdc_result[0]; 728 spin_unlock_irqrestore(&pdc_lock, flags); 729 730 return retval; 731 } 732 EXPORT_SYMBOL(pdc_stable_get_size); 733 734 /** 735 * pdc_stable_verify_contents - Checks that Stable Storage contents are valid. 736 * 737 * This PDC call is meant to be used to check the integrity of the current 738 * contents of Stable Storage. 739 */ 740 int pdc_stable_verify_contents(void) 741 { 742 int retval; 743 unsigned long flags; 744 745 spin_lock_irqsave(&pdc_lock, flags); 746 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_VERIFY_CONTENTS); 747 spin_unlock_irqrestore(&pdc_lock, flags); 748 749 return retval; 750 } 751 EXPORT_SYMBOL(pdc_stable_verify_contents); 752 753 /** 754 * pdc_stable_initialize - Sets Stable Storage contents to zero and initialize 755 * the validity indicator. 756 * 757 * This PDC call will erase all contents of Stable Storage. Use with care! 758 */ 759 int pdc_stable_initialize(void) 760 { 761 int retval; 762 unsigned long flags; 763 764 spin_lock_irqsave(&pdc_lock, flags); 765 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_INITIALIZE); 766 spin_unlock_irqrestore(&pdc_lock, flags); 767 768 return retval; 769 } 770 EXPORT_SYMBOL(pdc_stable_initialize); 771 772 /** 773 * pdc_get_initiator - Get the SCSI Interface Card params (SCSI ID, SDTR, SE or LVD) 774 * @hwpath: fully bc.mod style path to the device. 775 * @initiator: the array to return the result into 776 * 777 * Get the SCSI operational parameters from PDC. 778 * Needed since HPUX never used BIOS or symbios card NVRAM. 779 * Most ncr/sym cards won't have an entry and just use whatever 780 * capabilities of the card are (eg Ultra, LVD). But there are 781 * several cases where it's useful: 782 * o set SCSI id for Multi-initiator clusters, 783 * o cable too long (ie SE scsi 10Mhz won't support 6m length), 784 * o bus width exported is less than what the interface chip supports. 785 */ 786 int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initiator) 787 { 788 int retval; 789 unsigned long flags; 790 791 spin_lock_irqsave(&pdc_lock, flags); 792 793 /* BCJ-XXXX series boxes. E.G. "9000/785/C3000" */ 794 #define IS_SPROCKETS() (strlen(boot_cpu_data.pdc.sys_model_name) == 14 && \ 795 strncmp(boot_cpu_data.pdc.sys_model_name, "9000/785", 8) == 0) 796 797 retval = mem_pdc_call(PDC_INITIATOR, PDC_GET_INITIATOR, 798 __pa(pdc_result), __pa(hwpath)); 799 if (retval < PDC_OK) 800 goto out; 801 802 if (pdc_result[0] < 16) { 803 initiator->host_id = pdc_result[0]; 804 } else { 805 initiator->host_id = -1; 806 } 807 808 /* 809 * Sprockets and Piranha return 20 or 40 (MT/s). Prelude returns 810 * 1, 2, 5 or 10 for 5, 10, 20 or 40 MT/s, respectively 811 */ 812 switch (pdc_result[1]) { 813 case 1: initiator->factor = 50; break; 814 case 2: initiator->factor = 25; break; 815 case 5: initiator->factor = 12; break; 816 case 25: initiator->factor = 10; break; 817 case 20: initiator->factor = 12; break; 818 case 40: initiator->factor = 10; break; 819 default: initiator->factor = -1; break; 820 } 821 822 if (IS_SPROCKETS()) { 823 initiator->width = pdc_result[4]; 824 initiator->mode = pdc_result[5]; 825 } else { 826 initiator->width = -1; 827 initiator->mode = -1; 828 } 829 830 out: 831 spin_unlock_irqrestore(&pdc_lock, flags); 832 833 return (retval >= PDC_OK); 834 } 835 EXPORT_SYMBOL(pdc_get_initiator); 836 837 838 /** 839 * pdc_pci_irt_size - Get the number of entries in the interrupt routing table. 840 * @num_entries: The return value. 841 * @hpa: The HPA for the device. 842 * 843 * This PDC function returns the number of entries in the specified cell's 844 * interrupt table. 845 * Similar to PDC_PAT stuff - but added for Forte/Allegro boxes 846 */ 847 int pdc_pci_irt_size(unsigned long *num_entries, unsigned long hpa) 848 { 849 int retval; 850 unsigned long flags; 851 852 spin_lock_irqsave(&pdc_lock, flags); 853 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL_SIZE, 854 __pa(pdc_result), hpa); 855 convert_to_wide(pdc_result); 856 *num_entries = pdc_result[0]; 857 spin_unlock_irqrestore(&pdc_lock, flags); 858 859 return retval; 860 } 861 862 /** 863 * pdc_pci_irt - Get the PCI interrupt routing table. 864 * @num_entries: The number of entries in the table. 865 * @hpa: The Hard Physical Address of the device. 866 * @tbl: 867 * 868 * Get the PCI interrupt routing table for the device at the given HPA. 869 * Similar to PDC_PAT stuff - but added for Forte/Allegro boxes 870 */ 871 int pdc_pci_irt(unsigned long num_entries, unsigned long hpa, void *tbl) 872 { 873 int retval; 874 unsigned long flags; 875 876 BUG_ON((unsigned long)tbl & 0x7); 877 878 spin_lock_irqsave(&pdc_lock, flags); 879 pdc_result[0] = num_entries; 880 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL, 881 __pa(pdc_result), hpa, __pa(tbl)); 882 spin_unlock_irqrestore(&pdc_lock, flags); 883 884 return retval; 885 } 886 887 888 #if 0 /* UNTEST CODE - left here in case someone needs it */ 889 890 /** 891 * pdc_pci_config_read - read PCI config space. 892 * @hpa token from PDC to indicate which PCI device 893 * @pci_addr configuration space address to read from 894 * 895 * Read PCI Configuration space *before* linux PCI subsystem is running. 896 */ 897 unsigned int pdc_pci_config_read(void *hpa, unsigned long cfg_addr) 898 { 899 int retval; 900 unsigned long flags; 901 902 spin_lock_irqsave(&pdc_lock, flags); 903 pdc_result[0] = 0; 904 pdc_result[1] = 0; 905 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_READ_CONFIG, 906 __pa(pdc_result), hpa, cfg_addr&~3UL, 4UL); 907 spin_unlock_irqrestore(&pdc_lock, flags); 908 909 return retval ? ~0 : (unsigned int) pdc_result[0]; 910 } 911 912 913 /** 914 * pdc_pci_config_write - read PCI config space. 915 * @hpa token from PDC to indicate which PCI device 916 * @pci_addr configuration space address to write 917 * @val value we want in the 32-bit register 918 * 919 * Write PCI Configuration space *before* linux PCI subsystem is running. 920 */ 921 void pdc_pci_config_write(void *hpa, unsigned long cfg_addr, unsigned int val) 922 { 923 int retval; 924 unsigned long flags; 925 926 spin_lock_irqsave(&pdc_lock, flags); 927 pdc_result[0] = 0; 928 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_WRITE_CONFIG, 929 __pa(pdc_result), hpa, 930 cfg_addr&~3UL, 4UL, (unsigned long) val); 931 spin_unlock_irqrestore(&pdc_lock, flags); 932 933 return retval; 934 } 935 #endif /* UNTESTED CODE */ 936 937 /** 938 * pdc_tod_read - Read the Time-Of-Day clock. 939 * @tod: The return buffer: 940 * 941 * Read the Time-Of-Day clock 942 */ 943 int pdc_tod_read(struct pdc_tod *tod) 944 { 945 int retval; 946 unsigned long flags; 947 948 spin_lock_irqsave(&pdc_lock, flags); 949 retval = mem_pdc_call(PDC_TOD, PDC_TOD_READ, __pa(pdc_result), 0); 950 convert_to_wide(pdc_result); 951 memcpy(tod, pdc_result, sizeof(*tod)); 952 spin_unlock_irqrestore(&pdc_lock, flags); 953 954 return retval; 955 } 956 EXPORT_SYMBOL(pdc_tod_read); 957 958 /** 959 * pdc_tod_set - Set the Time-Of-Day clock. 960 * @sec: The number of seconds since epoch. 961 * @usec: The number of micro seconds. 962 * 963 * Set the Time-Of-Day clock. 964 */ 965 int pdc_tod_set(unsigned long sec, unsigned long usec) 966 { 967 int retval; 968 unsigned long flags; 969 970 spin_lock_irqsave(&pdc_lock, flags); 971 retval = mem_pdc_call(PDC_TOD, PDC_TOD_WRITE, sec, usec); 972 spin_unlock_irqrestore(&pdc_lock, flags); 973 974 return retval; 975 } 976 EXPORT_SYMBOL(pdc_tod_set); 977 978 #ifdef CONFIG_64BIT 979 int pdc_mem_mem_table(struct pdc_memory_table_raddr *r_addr, 980 struct pdc_memory_table *tbl, unsigned long entries) 981 { 982 int retval; 983 unsigned long flags; 984 985 spin_lock_irqsave(&pdc_lock, flags); 986 retval = mem_pdc_call(PDC_MEM, PDC_MEM_TABLE, __pa(pdc_result), __pa(pdc_result2), entries); 987 convert_to_wide(pdc_result); 988 memcpy(r_addr, pdc_result, sizeof(*r_addr)); 989 memcpy(tbl, pdc_result2, entries * sizeof(*tbl)); 990 spin_unlock_irqrestore(&pdc_lock, flags); 991 992 return retval; 993 } 994 #endif /* CONFIG_64BIT */ 995 996 /* FIXME: Is this pdc used? I could not find type reference to ftc_bitmap 997 * so I guessed at unsigned long. Someone who knows what this does, can fix 998 * it later. :) 999 */ 1000 int pdc_do_firm_test_reset(unsigned long ftc_bitmap) 1001 { 1002 int retval; 1003 unsigned long flags; 1004 1005 spin_lock_irqsave(&pdc_lock, flags); 1006 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_FIRM_TEST_RESET, 1007 PDC_FIRM_TEST_MAGIC, ftc_bitmap); 1008 spin_unlock_irqrestore(&pdc_lock, flags); 1009 1010 return retval; 1011 } 1012 1013 /* 1014 * pdc_do_reset - Reset the system. 1015 * 1016 * Reset the system. 1017 */ 1018 int pdc_do_reset(void) 1019 { 1020 int retval; 1021 unsigned long flags; 1022 1023 spin_lock_irqsave(&pdc_lock, flags); 1024 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_RESET); 1025 spin_unlock_irqrestore(&pdc_lock, flags); 1026 1027 return retval; 1028 } 1029 1030 /* 1031 * pdc_soft_power_info - Enable soft power switch. 1032 * @power_reg: address of soft power register 1033 * 1034 * Return the absolute address of the soft power switch register 1035 */ 1036 int __init pdc_soft_power_info(unsigned long *power_reg) 1037 { 1038 int retval; 1039 unsigned long flags; 1040 1041 *power_reg = (unsigned long) (-1); 1042 1043 spin_lock_irqsave(&pdc_lock, flags); 1044 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_INFO, __pa(pdc_result), 0); 1045 if (retval == PDC_OK) { 1046 convert_to_wide(pdc_result); 1047 *power_reg = f_extend(pdc_result[0]); 1048 } 1049 spin_unlock_irqrestore(&pdc_lock, flags); 1050 1051 return retval; 1052 } 1053 1054 /* 1055 * pdc_soft_power_button - Control the soft power button behaviour 1056 * @sw_control: 0 for hardware control, 1 for software control 1057 * 1058 * 1059 * This PDC function places the soft power button under software or 1060 * hardware control. 1061 * Under software control the OS may control to when to allow to shut 1062 * down the system. Under hardware control pressing the power button 1063 * powers off the system immediately. 1064 */ 1065 int pdc_soft_power_button(int sw_control) 1066 { 1067 int retval; 1068 unsigned long flags; 1069 1070 spin_lock_irqsave(&pdc_lock, flags); 1071 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control); 1072 spin_unlock_irqrestore(&pdc_lock, flags); 1073 1074 return retval; 1075 } 1076 1077 /* 1078 * pdc_io_reset - Hack to avoid overlapping range registers of Bridges devices. 1079 * Primarily a problem on T600 (which parisc-linux doesn't support) but 1080 * who knows what other platform firmware might do with this OS "hook". 1081 */ 1082 void pdc_io_reset(void) 1083 { 1084 unsigned long flags; 1085 1086 spin_lock_irqsave(&pdc_lock, flags); 1087 mem_pdc_call(PDC_IO, PDC_IO_RESET, 0); 1088 spin_unlock_irqrestore(&pdc_lock, flags); 1089 } 1090 1091 /* 1092 * pdc_io_reset_devices - Hack to Stop USB controller 1093 * 1094 * If PDC used the usb controller, the usb controller 1095 * is still running and will crash the machines during iommu 1096 * setup, because of still running DMA. This PDC call 1097 * stops the USB controller. 1098 * Normally called after calling pdc_io_reset(). 1099 */ 1100 void pdc_io_reset_devices(void) 1101 { 1102 unsigned long flags; 1103 1104 spin_lock_irqsave(&pdc_lock, flags); 1105 mem_pdc_call(PDC_IO, PDC_IO_RESET_DEVICES, 0); 1106 spin_unlock_irqrestore(&pdc_lock, flags); 1107 } 1108 1109 /* locked by pdc_console_lock */ 1110 static int __attribute__((aligned(8))) iodc_retbuf[32]; 1111 static char __attribute__((aligned(64))) iodc_dbuf[4096]; 1112 1113 /** 1114 * pdc_iodc_print - Console print using IODC. 1115 * @str: the string to output. 1116 * @count: length of str 1117 * 1118 * Note that only these special chars are architected for console IODC io: 1119 * BEL, BS, CR, and LF. Others are passed through. 1120 * Since the HP console requires CR+LF to perform a 'newline', we translate 1121 * "\n" to "\r\n". 1122 */ 1123 int pdc_iodc_print(const unsigned char *str, unsigned count) 1124 { 1125 unsigned int i; 1126 unsigned long flags; 1127 1128 for (i = 0; i < count;) { 1129 switch(str[i]) { 1130 case '\n': 1131 iodc_dbuf[i+0] = '\r'; 1132 iodc_dbuf[i+1] = '\n'; 1133 i += 2; 1134 goto print; 1135 default: 1136 iodc_dbuf[i] = str[i]; 1137 i++; 1138 break; 1139 } 1140 } 1141 1142 print: 1143 spin_lock_irqsave(&pdc_lock, flags); 1144 real32_call(PAGE0->mem_cons.iodc_io, 1145 (unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT, 1146 PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers), 1147 __pa(iodc_retbuf), 0, __pa(iodc_dbuf), i, 0); 1148 spin_unlock_irqrestore(&pdc_lock, flags); 1149 1150 return i; 1151 } 1152 1153 /** 1154 * pdc_iodc_getc - Read a character (non-blocking) from the PDC console. 1155 * 1156 * Read a character (non-blocking) from the PDC console, returns -1 if 1157 * key is not present. 1158 */ 1159 int pdc_iodc_getc(void) 1160 { 1161 int ch; 1162 int status; 1163 unsigned long flags; 1164 1165 /* Bail if no console input device. */ 1166 if (!PAGE0->mem_kbd.iodc_io) 1167 return 0; 1168 1169 /* wait for a keyboard (rs232)-input */ 1170 spin_lock_irqsave(&pdc_lock, flags); 1171 real32_call(PAGE0->mem_kbd.iodc_io, 1172 (unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN, 1173 PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers), 1174 __pa(iodc_retbuf), 0, __pa(iodc_dbuf), 1, 0); 1175 1176 ch = *iodc_dbuf; 1177 status = *iodc_retbuf; 1178 spin_unlock_irqrestore(&pdc_lock, flags); 1179 1180 if (status == 0) 1181 return -1; 1182 1183 return ch; 1184 } 1185 1186 int pdc_sti_call(unsigned long func, unsigned long flags, 1187 unsigned long inptr, unsigned long outputr, 1188 unsigned long glob_cfg) 1189 { 1190 int retval; 1191 unsigned long irqflags; 1192 1193 spin_lock_irqsave(&pdc_lock, irqflags); 1194 retval = real32_call(func, flags, inptr, outputr, glob_cfg); 1195 spin_unlock_irqrestore(&pdc_lock, irqflags); 1196 1197 return retval; 1198 } 1199 EXPORT_SYMBOL(pdc_sti_call); 1200 1201 #ifdef CONFIG_64BIT 1202 /** 1203 * pdc_pat_cell_get_number - Returns the cell number. 1204 * @cell_info: The return buffer. 1205 * 1206 * This PDC call returns the cell number of the cell from which the call 1207 * is made. 1208 */ 1209 int pdc_pat_cell_get_number(struct pdc_pat_cell_num *cell_info) 1210 { 1211 int retval; 1212 unsigned long flags; 1213 1214 spin_lock_irqsave(&pdc_lock, flags); 1215 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_NUMBER, __pa(pdc_result)); 1216 memcpy(cell_info, pdc_result, sizeof(*cell_info)); 1217 spin_unlock_irqrestore(&pdc_lock, flags); 1218 1219 return retval; 1220 } 1221 1222 /** 1223 * pdc_pat_cell_module - Retrieve the cell's module information. 1224 * @actcnt: The number of bytes written to mem_addr. 1225 * @ploc: The physical location. 1226 * @mod: The module index. 1227 * @view_type: The view of the address type. 1228 * @mem_addr: The return buffer. 1229 * 1230 * This PDC call returns information about each module attached to the cell 1231 * at the specified location. 1232 */ 1233 int pdc_pat_cell_module(unsigned long *actcnt, unsigned long ploc, unsigned long mod, 1234 unsigned long view_type, void *mem_addr) 1235 { 1236 int retval; 1237 unsigned long flags; 1238 static struct pdc_pat_cell_mod_maddr_block result __attribute__ ((aligned (8))); 1239 1240 spin_lock_irqsave(&pdc_lock, flags); 1241 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_MODULE, __pa(pdc_result), 1242 ploc, mod, view_type, __pa(&result)); 1243 if(!retval) { 1244 *actcnt = pdc_result[0]; 1245 memcpy(mem_addr, &result, *actcnt); 1246 } 1247 spin_unlock_irqrestore(&pdc_lock, flags); 1248 1249 return retval; 1250 } 1251 1252 /** 1253 * pdc_pat_cpu_get_number - Retrieve the cpu number. 1254 * @cpu_info: The return buffer. 1255 * @hpa: The Hard Physical Address of the CPU. 1256 * 1257 * Retrieve the cpu number for the cpu at the specified HPA. 1258 */ 1259 int pdc_pat_cpu_get_number(struct pdc_pat_cpu_num *cpu_info, void *hpa) 1260 { 1261 int retval; 1262 unsigned long flags; 1263 1264 spin_lock_irqsave(&pdc_lock, flags); 1265 retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_NUMBER, 1266 __pa(&pdc_result), hpa); 1267 memcpy(cpu_info, pdc_result, sizeof(*cpu_info)); 1268 spin_unlock_irqrestore(&pdc_lock, flags); 1269 1270 return retval; 1271 } 1272 1273 /** 1274 * pdc_pat_get_irt_size - Retrieve the number of entries in the cell's interrupt table. 1275 * @num_entries: The return value. 1276 * @cell_num: The target cell. 1277 * 1278 * This PDC function returns the number of entries in the specified cell's 1279 * interrupt table. 1280 */ 1281 int pdc_pat_get_irt_size(unsigned long *num_entries, unsigned long cell_num) 1282 { 1283 int retval; 1284 unsigned long flags; 1285 1286 spin_lock_irqsave(&pdc_lock, flags); 1287 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE_SIZE, 1288 __pa(pdc_result), cell_num); 1289 *num_entries = pdc_result[0]; 1290 spin_unlock_irqrestore(&pdc_lock, flags); 1291 1292 return retval; 1293 } 1294 1295 /** 1296 * pdc_pat_get_irt - Retrieve the cell's interrupt table. 1297 * @r_addr: The return buffer. 1298 * @cell_num: The target cell. 1299 * 1300 * This PDC function returns the actual interrupt table for the specified cell. 1301 */ 1302 int pdc_pat_get_irt(void *r_addr, unsigned long cell_num) 1303 { 1304 int retval; 1305 unsigned long flags; 1306 1307 spin_lock_irqsave(&pdc_lock, flags); 1308 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE, 1309 __pa(r_addr), cell_num); 1310 spin_unlock_irqrestore(&pdc_lock, flags); 1311 1312 return retval; 1313 } 1314 1315 /** 1316 * pdc_pat_pd_get_addr_map - Retrieve information about memory address ranges. 1317 * @actlen: The return buffer. 1318 * @mem_addr: Pointer to the memory buffer. 1319 * @count: The number of bytes to read from the buffer. 1320 * @offset: The offset with respect to the beginning of the buffer. 1321 * 1322 */ 1323 int pdc_pat_pd_get_addr_map(unsigned long *actual_len, void *mem_addr, 1324 unsigned long count, unsigned long offset) 1325 { 1326 int retval; 1327 unsigned long flags; 1328 1329 spin_lock_irqsave(&pdc_lock, flags); 1330 retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_ADDR_MAP, __pa(pdc_result), 1331 __pa(pdc_result2), count, offset); 1332 *actual_len = pdc_result[0]; 1333 memcpy(mem_addr, pdc_result2, *actual_len); 1334 spin_unlock_irqrestore(&pdc_lock, flags); 1335 1336 return retval; 1337 } 1338 1339 /** 1340 * pdc_pat_io_pci_cfg_read - Read PCI configuration space. 1341 * @pci_addr: PCI configuration space address for which the read request is being made. 1342 * @pci_size: Size of read in bytes. Valid values are 1, 2, and 4. 1343 * @mem_addr: Pointer to return memory buffer. 1344 * 1345 */ 1346 int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr) 1347 { 1348 int retval; 1349 unsigned long flags; 1350 1351 spin_lock_irqsave(&pdc_lock, flags); 1352 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_READ, 1353 __pa(pdc_result), pci_addr, pci_size); 1354 switch(pci_size) { 1355 case 1: *(u8 *) mem_addr = (u8) pdc_result[0]; 1356 case 2: *(u16 *)mem_addr = (u16) pdc_result[0]; 1357 case 4: *(u32 *)mem_addr = (u32) pdc_result[0]; 1358 } 1359 spin_unlock_irqrestore(&pdc_lock, flags); 1360 1361 return retval; 1362 } 1363 1364 /** 1365 * pdc_pat_io_pci_cfg_write - Retrieve information about memory address ranges. 1366 * @pci_addr: PCI configuration space address for which the write request is being made. 1367 * @pci_size: Size of write in bytes. Valid values are 1, 2, and 4. 1368 * @value: Pointer to 1, 2, or 4 byte value in low order end of argument to be 1369 * written to PCI Config space. 1370 * 1371 */ 1372 int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val) 1373 { 1374 int retval; 1375 unsigned long flags; 1376 1377 spin_lock_irqsave(&pdc_lock, flags); 1378 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_WRITE, 1379 pci_addr, pci_size, val); 1380 spin_unlock_irqrestore(&pdc_lock, flags); 1381 1382 return retval; 1383 } 1384 #endif /* CONFIG_64BIT */ 1385 1386 1387 /***************** 32-bit real-mode calls ***********/ 1388 /* The struct below is used 1389 * to overlay real_stack (real2.S), preparing a 32-bit call frame. 1390 * real32_call_asm() then uses this stack in narrow real mode 1391 */ 1392 1393 struct narrow_stack { 1394 /* use int, not long which is 64 bits */ 1395 unsigned int arg13; 1396 unsigned int arg12; 1397 unsigned int arg11; 1398 unsigned int arg10; 1399 unsigned int arg9; 1400 unsigned int arg8; 1401 unsigned int arg7; 1402 unsigned int arg6; 1403 unsigned int arg5; 1404 unsigned int arg4; 1405 unsigned int arg3; 1406 unsigned int arg2; 1407 unsigned int arg1; 1408 unsigned int arg0; 1409 unsigned int frame_marker[8]; 1410 unsigned int sp; 1411 /* in reality, there's nearly 8k of stack after this */ 1412 }; 1413 1414 long real32_call(unsigned long fn, ...) 1415 { 1416 va_list args; 1417 extern struct narrow_stack real_stack; 1418 extern unsigned long real32_call_asm(unsigned int *, 1419 unsigned int *, 1420 unsigned int); 1421 1422 va_start(args, fn); 1423 real_stack.arg0 = va_arg(args, unsigned int); 1424 real_stack.arg1 = va_arg(args, unsigned int); 1425 real_stack.arg2 = va_arg(args, unsigned int); 1426 real_stack.arg3 = va_arg(args, unsigned int); 1427 real_stack.arg4 = va_arg(args, unsigned int); 1428 real_stack.arg5 = va_arg(args, unsigned int); 1429 real_stack.arg6 = va_arg(args, unsigned int); 1430 real_stack.arg7 = va_arg(args, unsigned int); 1431 real_stack.arg8 = va_arg(args, unsigned int); 1432 real_stack.arg9 = va_arg(args, unsigned int); 1433 real_stack.arg10 = va_arg(args, unsigned int); 1434 real_stack.arg11 = va_arg(args, unsigned int); 1435 real_stack.arg12 = va_arg(args, unsigned int); 1436 real_stack.arg13 = va_arg(args, unsigned int); 1437 va_end(args); 1438 1439 return real32_call_asm(&real_stack.sp, &real_stack.arg0, fn); 1440 } 1441 1442 #ifdef CONFIG_64BIT 1443 /***************** 64-bit real-mode calls ***********/ 1444 1445 struct wide_stack { 1446 unsigned long arg0; 1447 unsigned long arg1; 1448 unsigned long arg2; 1449 unsigned long arg3; 1450 unsigned long arg4; 1451 unsigned long arg5; 1452 unsigned long arg6; 1453 unsigned long arg7; 1454 unsigned long arg8; 1455 unsigned long arg9; 1456 unsigned long arg10; 1457 unsigned long arg11; 1458 unsigned long arg12; 1459 unsigned long arg13; 1460 unsigned long frame_marker[2]; /* rp, previous sp */ 1461 unsigned long sp; 1462 /* in reality, there's nearly 8k of stack after this */ 1463 }; 1464 1465 long real64_call(unsigned long fn, ...) 1466 { 1467 va_list args; 1468 extern struct wide_stack real64_stack; 1469 extern unsigned long real64_call_asm(unsigned long *, 1470 unsigned long *, 1471 unsigned long); 1472 1473 va_start(args, fn); 1474 real64_stack.arg0 = va_arg(args, unsigned long); 1475 real64_stack.arg1 = va_arg(args, unsigned long); 1476 real64_stack.arg2 = va_arg(args, unsigned long); 1477 real64_stack.arg3 = va_arg(args, unsigned long); 1478 real64_stack.arg4 = va_arg(args, unsigned long); 1479 real64_stack.arg5 = va_arg(args, unsigned long); 1480 real64_stack.arg6 = va_arg(args, unsigned long); 1481 real64_stack.arg7 = va_arg(args, unsigned long); 1482 real64_stack.arg8 = va_arg(args, unsigned long); 1483 real64_stack.arg9 = va_arg(args, unsigned long); 1484 real64_stack.arg10 = va_arg(args, unsigned long); 1485 real64_stack.arg11 = va_arg(args, unsigned long); 1486 real64_stack.arg12 = va_arg(args, unsigned long); 1487 real64_stack.arg13 = va_arg(args, unsigned long); 1488 va_end(args); 1489 1490 return real64_call_asm(&real64_stack.sp, &real64_stack.arg0, fn); 1491 } 1492 1493 #endif /* CONFIG_64BIT */ 1494 1495