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