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