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