1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * arch/parisc/kernel/firmware.c - safe PDC access routines
5 * PDC == Processor Dependent Code
7 * See PDC documentation at
8 * https://parisc.wiki.kernel.org/index.php/Technical_Documentation
9 * for documentation describing the entry points and calling
10 * conventions defined below.
12 * Copyright 1999 SuSE GmbH Nuernberg (Philipp Rumpf, prumpf@tux.org)
13 * Copyright 1999 The Puffin Group, (Alex deVries, David Kennedy)
14 * Copyright 2003 Grant Grundler <grundler parisc-linux org>
15 * Copyright 2003,2004 Ryan Bradetich <rbrad@parisc-linux.org>
16 * Copyright 2004,2006 Thibaut VARENE <varenet@parisc-linux.org>
19 /* I think it would be in everyone's best interest to follow this
20 * guidelines when writing PDC wrappers:
22 * - the name of the pdc wrapper should match one of the macros
23 * used for the first two arguments
24 * - don't use caps for random parts of the name
25 * - use the static PDC result buffers and "copyout" to structs
26 * supplied by the caller to encapsulate alignment restrictions
27 * - hold pdc_lock while in PDC or using static result buffers
28 * - use __pa() to convert virtual (kernel) pointers to physical
30 * - the name of the struct used for pdc return values should equal
31 * one of the macros used for the first two arguments to the
32 * corresponding PDC call
33 * - keep the order of arguments
34 * - don't be smart (setting trailing NUL bytes for strings, return
35 * something useful even if the call failed) unless you are sure
36 * it's not going to affect functionality or performance
39 * int pdc_cache_info(struct pdc_cache_info *cache_info )
43 * spin_lock_irq(&pdc_lock);
44 * retval = mem_pdc_call(PDC_CACHE,PDC_CACHE_INFO,__pa(cache_info),0);
45 * convert_to_wide(pdc_result);
46 * memcpy(cache_info, pdc_result, sizeof(*cache_info));
47 * spin_unlock_irq(&pdc_lock);
54 #include <linux/stdarg.h>
56 #include <linux/delay.h>
57 #include <linux/init.h>
58 #include <linux/kernel.h>
59 #include <linux/module.h>
60 #include <linux/string.h>
61 #include <linux/spinlock.h>
65 #include <asm/pdcpat.h>
66 #include <asm/processor.h> /* for boot_cpu_data */
68 #if defined(BOOTLOADER)
69 # undef spin_lock_irqsave
70 # define spin_lock_irqsave(a, b) { b = 1; }
71 # undef spin_unlock_irqrestore
72 # define spin_unlock_irqrestore(a, b)
74 static DEFINE_SPINLOCK(pdc_lock);
77 extern unsigned long pdc_result[NUM_PDC_RESULT];
78 extern unsigned long pdc_result2[NUM_PDC_RESULT];
81 #define WIDE_FIRMWARE 0x1
82 #define NARROW_FIRMWARE 0x2
84 /* Firmware needs to be initially set to narrow to determine the
85 * actual firmware width. */
86 int parisc_narrow_firmware __ro_after_init = 2;
89 /* On most currently-supported platforms, IODC I/O calls are 32-bit calls
90 * and MEM_PDC calls are always the same width as the OS.
91 * Some PAT boxes may have 64-bit IODC I/O.
93 * Ryan Bradetich added the now obsolete CONFIG_PDC_NARROW to allow
94 * 64-bit kernels to run on systems with 32-bit MEM_PDC calls.
95 * This allowed wide kernels to run on Cxxx boxes.
96 * We now detect 32-bit-only PDC and dynamically switch to 32-bit mode
97 * when running a 64-bit kernel on such boxes (e.g. C200 or C360).
101 long real64_call(unsigned long function, ...);
103 long real32_call(unsigned long function, ...);
106 # define MEM_PDC (unsigned long)(PAGE0->mem_pdc_hi) << 32 | PAGE0->mem_pdc
107 # define mem_pdc_call(args...) unlikely(parisc_narrow_firmware) ? real32_call(MEM_PDC, args) : real64_call(MEM_PDC, args)
109 # define MEM_PDC (unsigned long)PAGE0->mem_pdc
110 # define mem_pdc_call(args...) real32_call(MEM_PDC, args)
115 * f_extend - Convert PDC addresses to kernel addresses.
116 * @address: Address returned from PDC.
118 * This function is used to convert PDC addresses into kernel addresses
119 * when the PDC address size and kernel address size are different.
121 static unsigned long f_extend(unsigned long address)
124 if(unlikely(parisc_narrow_firmware)) {
125 if((address & 0xff000000) == 0xf0000000)
126 return (0xfffffff0UL << 32) | (u32)address;
128 if((address & 0xf0000000) == 0xf0000000)
129 return (0xffffffffUL << 32) | (u32)address;
136 * convert_to_wide - Convert the return buffer addresses into kernel addresses.
137 * @address: The return buffer from PDC.
139 * This function is used to convert the return buffer addresses retrieved from PDC
140 * into kernel addresses when the PDC address size and kernel address size are
143 static void convert_to_wide(unsigned long *addr)
147 unsigned int *p = (unsigned int *)addr;
149 if (unlikely(parisc_narrow_firmware)) {
150 for (i = (NUM_PDC_RESULT-1); i >= 0; --i)
157 void set_firmware_width_unlocked(void)
161 ret = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES,
162 __pa(pdc_result), 0);
163 convert_to_wide(pdc_result);
164 if (pdc_result[0] != NARROW_FIRMWARE)
165 parisc_narrow_firmware = 0;
169 * set_firmware_width - Determine if the firmware is wide or narrow.
171 * This function must be called before any pdc_* function that uses the
172 * convert_to_wide function.
174 void set_firmware_width(void)
178 /* already initialized? */
179 if (parisc_narrow_firmware != 2)
182 spin_lock_irqsave(&pdc_lock, flags);
183 set_firmware_width_unlocked();
184 spin_unlock_irqrestore(&pdc_lock, flags);
187 void set_firmware_width_unlocked(void)
192 void set_firmware_width(void)
196 #endif /*CONFIG_64BIT*/
199 #if !defined(BOOTLOADER)
201 * pdc_emergency_unlock - Unlock the linux pdc lock
203 * This call unlocks the linux pdc lock in case we need some PDC functions
204 * (like pdc_add_valid) during kernel stack dump.
206 void pdc_emergency_unlock(void)
208 /* Spinlock DEBUG code freaks out if we unconditionally unlock */
209 if (spin_is_locked(&pdc_lock))
210 spin_unlock(&pdc_lock);
215 * pdc_add_valid - Verify address can be accessed without causing a HPMC.
216 * @address: Address to be verified.
218 * This PDC call attempts to read from the specified address and verifies
219 * if the address is valid.
221 * The return value is PDC_OK (0) in case accessing this address is valid.
223 int pdc_add_valid(unsigned long address)
228 spin_lock_irqsave(&pdc_lock, flags);
229 retval = mem_pdc_call(PDC_ADD_VALID, PDC_ADD_VALID_VERIFY, address);
230 spin_unlock_irqrestore(&pdc_lock, flags);
234 EXPORT_SYMBOL(pdc_add_valid);
237 * pdc_instr - Get instruction that invokes PDCE_CHECK in HPMC handler.
238 * @instr: Pointer to variable which will get instruction opcode.
240 * The return value is PDC_OK (0) in case call succeeded.
242 int __init pdc_instr(unsigned int *instr)
247 spin_lock_irqsave(&pdc_lock, flags);
248 retval = mem_pdc_call(PDC_INSTR, 0UL, __pa(pdc_result));
249 convert_to_wide(pdc_result);
250 *instr = pdc_result[0];
251 spin_unlock_irqrestore(&pdc_lock, flags);
257 * pdc_chassis_info - Return chassis information.
258 * @result: The return buffer.
259 * @chassis_info: The memory buffer address.
260 * @len: The size of the memory buffer address.
262 * An HVERSION dependent call for returning the chassis information.
264 int __init pdc_chassis_info(struct pdc_chassis_info *chassis_info, void *led_info, unsigned long len)
269 spin_lock_irqsave(&pdc_lock, flags);
270 memcpy(&pdc_result, chassis_info, sizeof(*chassis_info));
271 memcpy(&pdc_result2, led_info, len);
272 retval = mem_pdc_call(PDC_CHASSIS, PDC_RETURN_CHASSIS_INFO,
273 __pa(pdc_result), __pa(pdc_result2), len);
274 memcpy(chassis_info, pdc_result, sizeof(*chassis_info));
275 memcpy(led_info, pdc_result2, len);
276 spin_unlock_irqrestore(&pdc_lock, flags);
282 * pdc_pat_chassis_send_log - Sends a PDC PAT CHASSIS log message.
283 * @retval: -1 on error, 0 on success. Other value are PDC errors
285 * Must be correctly formatted or expect system crash
288 int pdc_pat_chassis_send_log(unsigned long state, unsigned long data)
296 spin_lock_irqsave(&pdc_lock, flags);
297 retval = mem_pdc_call(PDC_PAT_CHASSIS_LOG, PDC_PAT_CHASSIS_WRITE_LOG, __pa(&state), __pa(&data));
298 spin_unlock_irqrestore(&pdc_lock, flags);
305 * pdc_chassis_disp - Updates chassis code
306 * @retval: -1 on error, 0 on success
308 int pdc_chassis_disp(unsigned long disp)
313 spin_lock_irqsave(&pdc_lock, flags);
314 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_DISP, disp);
315 spin_unlock_irqrestore(&pdc_lock, flags);
321 * pdc_cpu_rendenzvous - Stop currently executing CPU
322 * @retval: -1 on error, 0 on success
324 int __pdc_cpu_rendezvous(void)
327 return mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_RENDEZVOUS);
329 return mem_pdc_call(PDC_PROC, 1, 0);
333 * pdc_cpu_rendezvous_lock - Lock PDC while transitioning to rendezvous state
335 void pdc_cpu_rendezvous_lock(void)
337 spin_lock(&pdc_lock);
341 * pdc_cpu_rendezvous_unlock - Unlock PDC after reaching rendezvous state
343 void pdc_cpu_rendezvous_unlock(void)
345 spin_unlock(&pdc_lock);
349 * pdc_pat_get_PDC_entrypoint - Get PDC entry point for current CPU
350 * @retval: -1 on error, 0 on success
352 int pdc_pat_get_PDC_entrypoint(unsigned long *pdc_entry)
357 if (!IS_ENABLED(CONFIG_SMP) || !is_pdc_pat()) {
358 *pdc_entry = MEM_PDC;
362 spin_lock_irqsave(&pdc_lock, flags);
363 retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_PDC_ENTRYPOINT,
365 *pdc_entry = pdc_result[0];
366 spin_unlock_irqrestore(&pdc_lock, flags);
371 * pdc_chassis_warn - Fetches chassis warnings
372 * @retval: -1 on error, 0 on success
374 int pdc_chassis_warn(unsigned long *warn)
379 spin_lock_irqsave(&pdc_lock, flags);
380 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_WARN, __pa(pdc_result));
381 *warn = pdc_result[0];
382 spin_unlock_irqrestore(&pdc_lock, flags);
387 int pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg *pdc_coproc_info)
391 ret = mem_pdc_call(PDC_COPROC, PDC_COPROC_CFG, __pa(pdc_result));
392 convert_to_wide(pdc_result);
393 pdc_coproc_info->ccr_functional = pdc_result[0];
394 pdc_coproc_info->ccr_present = pdc_result[1];
395 pdc_coproc_info->revision = pdc_result[17];
396 pdc_coproc_info->model = pdc_result[18];
402 * pdc_coproc_cfg - To identify coprocessors attached to the processor.
403 * @pdc_coproc_info: Return buffer address.
405 * This PDC call returns the presence and status of all the coprocessors
406 * attached to the processor.
408 int pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info)
413 spin_lock_irqsave(&pdc_lock, flags);
414 ret = pdc_coproc_cfg_unlocked(pdc_coproc_info);
415 spin_unlock_irqrestore(&pdc_lock, flags);
421 * pdc_iodc_read - Read data from the modules IODC.
422 * @actcnt: The actual number of bytes.
423 * @hpa: The HPA of the module for the iodc read.
424 * @index: The iodc entry point.
425 * @iodc_data: A buffer memory for the iodc options.
426 * @iodc_data_size: Size of the memory buffer.
428 * This PDC call reads from the IODC of the module specified by the hpa
431 int pdc_iodc_read(unsigned long *actcnt, unsigned long hpa, unsigned int index,
432 void *iodc_data, unsigned int iodc_data_size)
437 spin_lock_irqsave(&pdc_lock, flags);
438 retval = mem_pdc_call(PDC_IODC, PDC_IODC_READ, __pa(pdc_result), hpa,
439 index, __pa(pdc_result2), iodc_data_size);
440 convert_to_wide(pdc_result);
441 *actcnt = pdc_result[0];
442 memcpy(iodc_data, pdc_result2, iodc_data_size);
443 spin_unlock_irqrestore(&pdc_lock, flags);
447 EXPORT_SYMBOL(pdc_iodc_read);
450 * pdc_system_map_find_mods - Locate unarchitected modules.
451 * @pdc_mod_info: Return buffer address.
452 * @mod_path: pointer to dev path structure.
453 * @mod_index: fixed address module index.
455 * To locate and identify modules which reside at fixed I/O addresses, which
456 * do not self-identify via architected bus walks.
458 int pdc_system_map_find_mods(struct pdc_system_map_mod_info *pdc_mod_info,
459 struct pdc_module_path *mod_path, long mod_index)
464 spin_lock_irqsave(&pdc_lock, flags);
465 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_MODULE, __pa(pdc_result),
466 __pa(pdc_result2), mod_index);
467 convert_to_wide(pdc_result);
468 memcpy(pdc_mod_info, pdc_result, sizeof(*pdc_mod_info));
469 memcpy(mod_path, pdc_result2, sizeof(*mod_path));
470 spin_unlock_irqrestore(&pdc_lock, flags);
472 pdc_mod_info->mod_addr = f_extend(pdc_mod_info->mod_addr);
477 * pdc_system_map_find_addrs - Retrieve additional address ranges.
478 * @pdc_addr_info: Return buffer address.
479 * @mod_index: Fixed address module index.
480 * @addr_index: Address range index.
482 * Retrieve additional information about subsequent address ranges for modules
483 * with multiple address ranges.
485 int pdc_system_map_find_addrs(struct pdc_system_map_addr_info *pdc_addr_info,
486 long mod_index, long addr_index)
491 spin_lock_irqsave(&pdc_lock, flags);
492 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_ADDRESS, __pa(pdc_result),
493 mod_index, addr_index);
494 convert_to_wide(pdc_result);
495 memcpy(pdc_addr_info, pdc_result, sizeof(*pdc_addr_info));
496 spin_unlock_irqrestore(&pdc_lock, flags);
498 pdc_addr_info->mod_addr = f_extend(pdc_addr_info->mod_addr);
503 * pdc_model_info - Return model information about the processor.
504 * @model: The return buffer.
506 * Returns the version numbers, identifiers, and capabilities from the processor module.
508 int pdc_model_info(struct pdc_model *model)
513 spin_lock_irqsave(&pdc_lock, flags);
514 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_INFO, __pa(pdc_result), 0);
515 convert_to_wide(pdc_result);
516 memcpy(model, pdc_result, sizeof(*model));
517 spin_unlock_irqrestore(&pdc_lock, flags);
523 * pdc_model_sysmodel - Get the system model name.
524 * @name: A char array of at least 81 characters.
526 * Get system model name from PDC ROM (e.g. 9000/715 or 9000/778/B160L).
527 * Using OS_ID_HPUX will return the equivalent of the 'modelname' command
530 int pdc_model_sysmodel(char *name)
535 spin_lock_irqsave(&pdc_lock, flags);
536 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_SYSMODEL, __pa(pdc_result),
537 OS_ID_HPUX, __pa(name));
538 convert_to_wide(pdc_result);
540 if (retval == PDC_OK) {
541 name[pdc_result[0]] = '\0'; /* add trailing '\0' */
545 spin_unlock_irqrestore(&pdc_lock, flags);
551 * pdc_model_versions - Identify the version number of each processor.
552 * @cpu_id: The return buffer.
553 * @id: The id of the processor to check.
555 * Returns the version number for each processor component.
557 * This comment was here before, but I do not know what it means :( -RB
558 * id: 0 = cpu revision, 1 = boot-rom-version
560 int pdc_model_versions(unsigned long *versions, int id)
565 spin_lock_irqsave(&pdc_lock, flags);
566 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_VERSIONS, __pa(pdc_result), id);
567 convert_to_wide(pdc_result);
568 *versions = pdc_result[0];
569 spin_unlock_irqrestore(&pdc_lock, flags);
575 * pdc_model_cpuid - Returns the CPU_ID.
576 * @cpu_id: The return buffer.
578 * Returns the CPU_ID value which uniquely identifies the cpu portion of
579 * the processor module.
581 int pdc_model_cpuid(unsigned long *cpu_id)
586 spin_lock_irqsave(&pdc_lock, flags);
587 pdc_result[0] = 0; /* preset zero (call may not be implemented!) */
588 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CPU_ID, __pa(pdc_result), 0);
589 convert_to_wide(pdc_result);
590 *cpu_id = pdc_result[0];
591 spin_unlock_irqrestore(&pdc_lock, flags);
597 * pdc_model_capabilities - Returns the platform capabilities.
598 * @capabilities: The return buffer.
600 * Returns information about platform support for 32- and/or 64-bit
601 * OSes, IO-PDIR coherency, and virtual aliasing.
603 int pdc_model_capabilities(unsigned long *capabilities)
608 spin_lock_irqsave(&pdc_lock, flags);
609 pdc_result[0] = 0; /* preset zero (call may not be implemented!) */
610 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, __pa(pdc_result), 0);
611 convert_to_wide(pdc_result);
612 if (retval == PDC_OK) {
613 *capabilities = pdc_result[0];
615 *capabilities = PDC_MODEL_OS32;
617 spin_unlock_irqrestore(&pdc_lock, flags);
623 * pdc_model_platform_info - Returns machine product and serial number.
624 * @orig_prod_num: Return buffer for original product number.
625 * @current_prod_num: Return buffer for current product number.
626 * @serial_no: Return buffer for serial number.
628 * Returns strings containing the original and current product numbers and the
629 * serial number of the system.
631 int pdc_model_platform_info(char *orig_prod_num, char *current_prod_num,
637 spin_lock_irqsave(&pdc_lock, flags);
638 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_GET_PLATFORM_INFO,
639 __pa(orig_prod_num), __pa(current_prod_num), __pa(serial_no));
640 convert_to_wide(pdc_result);
641 spin_unlock_irqrestore(&pdc_lock, flags);
647 * pdc_cache_info - Return cache and TLB information.
648 * @cache_info: The return buffer.
650 * Returns information about the processor's cache and TLB.
652 int pdc_cache_info(struct pdc_cache_info *cache_info)
657 spin_lock_irqsave(&pdc_lock, flags);
658 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_INFO, __pa(pdc_result), 0);
659 convert_to_wide(pdc_result);
660 memcpy(cache_info, pdc_result, sizeof(*cache_info));
661 spin_unlock_irqrestore(&pdc_lock, flags);
667 * pdc_spaceid_bits - Return whether Space ID hashing is turned on.
668 * @space_bits: Should be 0, if not, bad mojo!
670 * Returns information about Space ID hashing.
672 int pdc_spaceid_bits(unsigned long *space_bits)
677 spin_lock_irqsave(&pdc_lock, flags);
679 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_RET_SPID, __pa(pdc_result), 0);
680 convert_to_wide(pdc_result);
681 *space_bits = pdc_result[0];
682 spin_unlock_irqrestore(&pdc_lock, flags);
689 * pdc_btlb_info - Return block TLB information.
690 * @btlb: The return buffer.
692 * Returns information about the hardware Block TLB.
694 int pdc_btlb_info(struct pdc_btlb_info *btlb)
699 spin_lock_irqsave(&pdc_lock, flags);
700 retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_INFO, __pa(pdc_result), 0);
701 memcpy(btlb, pdc_result, sizeof(*btlb));
702 spin_unlock_irqrestore(&pdc_lock, flags);
711 * pdc_mem_map_hpa - Find fixed module information.
712 * @address: The return buffer
713 * @mod_path: pointer to dev path structure.
715 * This call was developed for S700 workstations to allow the kernel to find
716 * the I/O devices (Core I/O). In the future (Kittyhawk and beyond) this
717 * call will be replaced (on workstations) by the architected PDC_SYSTEM_MAP
720 * This call is supported by all existing S700 workstations (up to Gecko).
722 int pdc_mem_map_hpa(struct pdc_memory_map *address,
723 struct pdc_module_path *mod_path)
728 spin_lock_irqsave(&pdc_lock, flags);
729 memcpy(pdc_result2, mod_path, sizeof(*mod_path));
730 retval = mem_pdc_call(PDC_MEM_MAP, PDC_MEM_MAP_HPA, __pa(pdc_result),
732 memcpy(address, pdc_result, sizeof(*address));
733 spin_unlock_irqrestore(&pdc_lock, flags);
737 #endif /* !CONFIG_PA20 */
740 * pdc_lan_station_id - Get the LAN address.
741 * @lan_addr: The return buffer.
742 * @hpa: The network device HPA.
744 * Get the LAN station address when it is not directly available from the LAN hardware.
746 int pdc_lan_station_id(char *lan_addr, unsigned long hpa)
751 spin_lock_irqsave(&pdc_lock, flags);
752 retval = mem_pdc_call(PDC_LAN_STATION_ID, PDC_LAN_STATION_ID_READ,
753 __pa(pdc_result), hpa);
755 /* FIXME: else read MAC from NVRAM */
756 memset(lan_addr, 0, PDC_LAN_STATION_ID_SIZE);
758 memcpy(lan_addr, pdc_result, PDC_LAN_STATION_ID_SIZE);
760 spin_unlock_irqrestore(&pdc_lock, flags);
764 EXPORT_SYMBOL(pdc_lan_station_id);
767 * pdc_stable_read - Read data from Stable Storage.
768 * @staddr: Stable Storage address to access.
769 * @memaddr: The memory address where Stable Storage data shall be copied.
770 * @count: number of bytes to transfer. count is multiple of 4.
772 * This PDC call reads from the Stable Storage address supplied in staddr
773 * and copies count bytes to the memory address memaddr.
774 * The call will fail if staddr+count > PDC_STABLE size.
776 int pdc_stable_read(unsigned long staddr, void *memaddr, unsigned long count)
781 spin_lock_irqsave(&pdc_lock, flags);
782 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_READ, staddr,
783 __pa(pdc_result), count);
784 convert_to_wide(pdc_result);
785 memcpy(memaddr, pdc_result, count);
786 spin_unlock_irqrestore(&pdc_lock, flags);
790 EXPORT_SYMBOL(pdc_stable_read);
793 * pdc_stable_write - Write data to Stable Storage.
794 * @staddr: Stable Storage address to access.
795 * @memaddr: The memory address where Stable Storage data shall be read from.
796 * @count: number of bytes to transfer. count is multiple of 4.
798 * This PDC call reads count bytes from the supplied memaddr address,
799 * and copies count bytes to the Stable Storage address staddr.
800 * The call will fail if staddr+count > PDC_STABLE size.
802 int pdc_stable_write(unsigned long staddr, void *memaddr, unsigned long count)
807 spin_lock_irqsave(&pdc_lock, flags);
808 memcpy(pdc_result, memaddr, count);
809 convert_to_wide(pdc_result);
810 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_WRITE, staddr,
811 __pa(pdc_result), count);
812 spin_unlock_irqrestore(&pdc_lock, flags);
816 EXPORT_SYMBOL(pdc_stable_write);
819 * pdc_stable_get_size - Get Stable Storage size in bytes.
820 * @size: pointer where the size will be stored.
822 * This PDC call returns the number of bytes in the processor's Stable
823 * Storage, which is the number of contiguous bytes implemented in Stable
824 * Storage starting from staddr=0. size in an unsigned 64-bit integer
825 * which is a multiple of four.
827 int pdc_stable_get_size(unsigned long *size)
832 spin_lock_irqsave(&pdc_lock, flags);
833 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_RETURN_SIZE, __pa(pdc_result));
834 *size = pdc_result[0];
835 spin_unlock_irqrestore(&pdc_lock, flags);
839 EXPORT_SYMBOL(pdc_stable_get_size);
842 * pdc_stable_verify_contents - Checks that Stable Storage contents are valid.
844 * This PDC call is meant to be used to check the integrity of the current
845 * contents of Stable Storage.
847 int pdc_stable_verify_contents(void)
852 spin_lock_irqsave(&pdc_lock, flags);
853 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_VERIFY_CONTENTS);
854 spin_unlock_irqrestore(&pdc_lock, flags);
858 EXPORT_SYMBOL(pdc_stable_verify_contents);
861 * pdc_stable_initialize - Sets Stable Storage contents to zero and initialize
862 * the validity indicator.
864 * This PDC call will erase all contents of Stable Storage. Use with care!
866 int pdc_stable_initialize(void)
871 spin_lock_irqsave(&pdc_lock, flags);
872 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_INITIALIZE);
873 spin_unlock_irqrestore(&pdc_lock, flags);
877 EXPORT_SYMBOL(pdc_stable_initialize);
880 * pdc_get_initiator - Get the SCSI Interface Card params (SCSI ID, SDTR, SE or LVD)
881 * @hwpath: fully bc.mod style path to the device.
882 * @initiator: the array to return the result into
884 * Get the SCSI operational parameters from PDC.
885 * Needed since HPUX never used BIOS or symbios card NVRAM.
886 * Most ncr/sym cards won't have an entry and just use whatever
887 * capabilities of the card are (eg Ultra, LVD). But there are
888 * several cases where it's useful:
889 * o set SCSI id for Multi-initiator clusters,
890 * o cable too long (ie SE scsi 10Mhz won't support 6m length),
891 * o bus width exported is less than what the interface chip supports.
893 int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initiator)
898 spin_lock_irqsave(&pdc_lock, flags);
900 /* BCJ-XXXX series boxes. E.G. "9000/785/C3000" */
901 #define IS_SPROCKETS() (strlen(boot_cpu_data.pdc.sys_model_name) == 14 && \
902 strncmp(boot_cpu_data.pdc.sys_model_name, "9000/785", 8) == 0)
904 retval = mem_pdc_call(PDC_INITIATOR, PDC_GET_INITIATOR,
905 __pa(pdc_result), __pa(hwpath));
909 if (pdc_result[0] < 16) {
910 initiator->host_id = pdc_result[0];
912 initiator->host_id = -1;
916 * Sprockets and Piranha return 20 or 40 (MT/s). Prelude returns
917 * 1, 2, 5 or 10 for 5, 10, 20 or 40 MT/s, respectively
919 switch (pdc_result[1]) {
920 case 1: initiator->factor = 50; break;
921 case 2: initiator->factor = 25; break;
922 case 5: initiator->factor = 12; break;
923 case 25: initiator->factor = 10; break;
924 case 20: initiator->factor = 12; break;
925 case 40: initiator->factor = 10; break;
926 default: initiator->factor = -1; break;
929 if (IS_SPROCKETS()) {
930 initiator->width = pdc_result[4];
931 initiator->mode = pdc_result[5];
933 initiator->width = -1;
934 initiator->mode = -1;
938 spin_unlock_irqrestore(&pdc_lock, flags);
940 return (retval >= PDC_OK);
942 EXPORT_SYMBOL(pdc_get_initiator);
946 * pdc_pci_irt_size - Get the number of entries in the interrupt routing table.
947 * @num_entries: The return value.
948 * @hpa: The HPA for the device.
950 * This PDC function returns the number of entries in the specified cell's
952 * Similar to PDC_PAT stuff - but added for Forte/Allegro boxes
954 int pdc_pci_irt_size(unsigned long *num_entries, unsigned long hpa)
959 spin_lock_irqsave(&pdc_lock, flags);
960 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL_SIZE,
961 __pa(pdc_result), hpa);
962 convert_to_wide(pdc_result);
963 *num_entries = pdc_result[0];
964 spin_unlock_irqrestore(&pdc_lock, flags);
970 * pdc_pci_irt - Get the PCI interrupt routing table.
971 * @num_entries: The number of entries in the table.
972 * @hpa: The Hard Physical Address of the device.
975 * Get the PCI interrupt routing table for the device at the given HPA.
976 * Similar to PDC_PAT stuff - but added for Forte/Allegro boxes
978 int pdc_pci_irt(unsigned long num_entries, unsigned long hpa, void *tbl)
983 BUG_ON((unsigned long)tbl & 0x7);
985 spin_lock_irqsave(&pdc_lock, flags);
986 pdc_result[0] = num_entries;
987 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL,
988 __pa(pdc_result), hpa, __pa(tbl));
989 spin_unlock_irqrestore(&pdc_lock, flags);
995 #if 0 /* UNTEST CODE - left here in case someone needs it */
998 * pdc_pci_config_read - read PCI config space.
999 * @hpa token from PDC to indicate which PCI device
1000 * @pci_addr configuration space address to read from
1002 * Read PCI Configuration space *before* linux PCI subsystem is running.
1004 unsigned int pdc_pci_config_read(void *hpa, unsigned long cfg_addr)
1007 unsigned long flags;
1009 spin_lock_irqsave(&pdc_lock, flags);
1012 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_READ_CONFIG,
1013 __pa(pdc_result), hpa, cfg_addr&~3UL, 4UL);
1014 spin_unlock_irqrestore(&pdc_lock, flags);
1016 return retval ? ~0 : (unsigned int) pdc_result[0];
1021 * pdc_pci_config_write - read PCI config space.
1022 * @hpa token from PDC to indicate which PCI device
1023 * @pci_addr configuration space address to write
1024 * @val value we want in the 32-bit register
1026 * Write PCI Configuration space *before* linux PCI subsystem is running.
1028 void pdc_pci_config_write(void *hpa, unsigned long cfg_addr, unsigned int val)
1031 unsigned long flags;
1033 spin_lock_irqsave(&pdc_lock, flags);
1035 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_WRITE_CONFIG,
1036 __pa(pdc_result), hpa,
1037 cfg_addr&~3UL, 4UL, (unsigned long) val);
1038 spin_unlock_irqrestore(&pdc_lock, flags);
1042 #endif /* UNTESTED CODE */
1045 * pdc_tod_read - Read the Time-Of-Day clock.
1046 * @tod: The return buffer:
1048 * Read the Time-Of-Day clock
1050 int pdc_tod_read(struct pdc_tod *tod)
1053 unsigned long flags;
1055 spin_lock_irqsave(&pdc_lock, flags);
1056 retval = mem_pdc_call(PDC_TOD, PDC_TOD_READ, __pa(pdc_result), 0);
1057 convert_to_wide(pdc_result);
1058 memcpy(tod, pdc_result, sizeof(*tod));
1059 spin_unlock_irqrestore(&pdc_lock, flags);
1063 EXPORT_SYMBOL(pdc_tod_read);
1065 int pdc_mem_pdt_info(struct pdc_mem_retinfo *rinfo)
1068 unsigned long flags;
1070 spin_lock_irqsave(&pdc_lock, flags);
1071 retval = mem_pdc_call(PDC_MEM, PDC_MEM_MEMINFO, __pa(pdc_result), 0);
1072 convert_to_wide(pdc_result);
1073 memcpy(rinfo, pdc_result, sizeof(*rinfo));
1074 spin_unlock_irqrestore(&pdc_lock, flags);
1079 int pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt *pret,
1080 unsigned long *pdt_entries_ptr)
1083 unsigned long flags;
1085 spin_lock_irqsave(&pdc_lock, flags);
1086 retval = mem_pdc_call(PDC_MEM, PDC_MEM_READ_PDT, __pa(pdc_result),
1087 __pa(pdt_entries_ptr));
1088 if (retval == PDC_OK) {
1089 convert_to_wide(pdc_result);
1090 memcpy(pret, pdc_result, sizeof(*pret));
1092 spin_unlock_irqrestore(&pdc_lock, flags);
1096 * 64-bit kernels should not call this PDT function in narrow mode.
1097 * The pdt_entries_ptr array above will now contain 32-bit values
1099 if (WARN_ON_ONCE((retval == PDC_OK) && parisc_narrow_firmware))
1107 * pdc_pim_toc11 - Fetch TOC PIM 1.1 data from firmware.
1108 * @ret: pointer to return buffer
1110 int pdc_pim_toc11(struct pdc_toc_pim_11 *ret)
1113 unsigned long flags;
1115 spin_lock_irqsave(&pdc_lock, flags);
1116 retval = mem_pdc_call(PDC_PIM, PDC_PIM_TOC, __pa(pdc_result),
1117 __pa(ret), sizeof(*ret));
1118 spin_unlock_irqrestore(&pdc_lock, flags);
1123 * pdc_pim_toc20 - Fetch TOC PIM 2.0 data from firmware.
1124 * @ret: pointer to return buffer
1126 int pdc_pim_toc20(struct pdc_toc_pim_20 *ret)
1129 unsigned long flags;
1131 spin_lock_irqsave(&pdc_lock, flags);
1132 retval = mem_pdc_call(PDC_PIM, PDC_PIM_TOC, __pa(pdc_result),
1133 __pa(ret), sizeof(*ret));
1134 spin_unlock_irqrestore(&pdc_lock, flags);
1139 * pdc_tod_set - Set the Time-Of-Day clock.
1140 * @sec: The number of seconds since epoch.
1141 * @usec: The number of micro seconds.
1143 * Set the Time-Of-Day clock.
1145 int pdc_tod_set(unsigned long sec, unsigned long usec)
1148 unsigned long flags;
1150 spin_lock_irqsave(&pdc_lock, flags);
1151 retval = mem_pdc_call(PDC_TOD, PDC_TOD_WRITE, sec, usec);
1152 spin_unlock_irqrestore(&pdc_lock, flags);
1156 EXPORT_SYMBOL(pdc_tod_set);
1159 int pdc_mem_mem_table(struct pdc_memory_table_raddr *r_addr,
1160 struct pdc_memory_table *tbl, unsigned long entries)
1163 unsigned long flags;
1165 spin_lock_irqsave(&pdc_lock, flags);
1166 retval = mem_pdc_call(PDC_MEM, PDC_MEM_TABLE, __pa(pdc_result), __pa(pdc_result2), entries);
1167 convert_to_wide(pdc_result);
1168 memcpy(r_addr, pdc_result, sizeof(*r_addr));
1169 memcpy(tbl, pdc_result2, entries * sizeof(*tbl));
1170 spin_unlock_irqrestore(&pdc_lock, flags);
1174 #endif /* CONFIG_64BIT */
1176 /* FIXME: Is this pdc used? I could not find type reference to ftc_bitmap
1177 * so I guessed at unsigned long. Someone who knows what this does, can fix
1180 int pdc_do_firm_test_reset(unsigned long ftc_bitmap)
1183 unsigned long flags;
1185 spin_lock_irqsave(&pdc_lock, flags);
1186 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_FIRM_TEST_RESET,
1187 PDC_FIRM_TEST_MAGIC, ftc_bitmap);
1188 spin_unlock_irqrestore(&pdc_lock, flags);
1194 * pdc_do_reset - Reset the system.
1198 int pdc_do_reset(void)
1201 unsigned long flags;
1203 spin_lock_irqsave(&pdc_lock, flags);
1204 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_RESET);
1205 spin_unlock_irqrestore(&pdc_lock, flags);
1211 * pdc_soft_power_info - Enable soft power switch.
1212 * @power_reg: address of soft power register
1214 * Return the absolute address of the soft power switch register
1216 int __init pdc_soft_power_info(unsigned long *power_reg)
1219 unsigned long flags;
1221 *power_reg = (unsigned long) (-1);
1223 spin_lock_irqsave(&pdc_lock, flags);
1224 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_INFO, __pa(pdc_result), 0);
1225 if (retval == PDC_OK) {
1226 convert_to_wide(pdc_result);
1227 *power_reg = f_extend(pdc_result[0]);
1229 spin_unlock_irqrestore(&pdc_lock, flags);
1235 * pdc_soft_power_button{_panic} - Control the soft power button behaviour
1236 * @sw_control: 0 for hardware control, 1 for software control
1239 * This PDC function places the soft power button under software or
1241 * Under software control the OS may control to when to allow to shut
1242 * down the system. Under hardware control pressing the power button
1243 * powers off the system immediately.
1245 * The _panic version relies on spin_trylock to prevent deadlock
1248 int pdc_soft_power_button(int sw_control)
1251 unsigned long flags;
1253 spin_lock_irqsave(&pdc_lock, flags);
1254 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
1255 spin_unlock_irqrestore(&pdc_lock, flags);
1260 int pdc_soft_power_button_panic(int sw_control)
1263 unsigned long flags;
1265 if (!spin_trylock_irqsave(&pdc_lock, flags)) {
1266 pr_emerg("Couldn't enable soft power button\n");
1267 return -EBUSY; /* ignored by the panic notifier */
1270 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
1271 spin_unlock_irqrestore(&pdc_lock, flags);
1277 * pdc_io_reset - Hack to avoid overlapping range registers of Bridges devices.
1278 * Primarily a problem on T600 (which parisc-linux doesn't support) but
1279 * who knows what other platform firmware might do with this OS "hook".
1281 void pdc_io_reset(void)
1283 unsigned long flags;
1285 spin_lock_irqsave(&pdc_lock, flags);
1286 mem_pdc_call(PDC_IO, PDC_IO_RESET, 0);
1287 spin_unlock_irqrestore(&pdc_lock, flags);
1291 * pdc_io_reset_devices - Hack to Stop USB controller
1293 * If PDC used the usb controller, the usb controller
1294 * is still running and will crash the machines during iommu
1295 * setup, because of still running DMA. This PDC call
1296 * stops the USB controller.
1297 * Normally called after calling pdc_io_reset().
1299 void pdc_io_reset_devices(void)
1301 unsigned long flags;
1303 spin_lock_irqsave(&pdc_lock, flags);
1304 mem_pdc_call(PDC_IO, PDC_IO_RESET_DEVICES, 0);
1305 spin_unlock_irqrestore(&pdc_lock, flags);
1308 #endif /* defined(BOOTLOADER) */
1310 /* locked by pdc_lock */
1311 static char iodc_dbuf[4096] __page_aligned_bss;
1314 * pdc_iodc_print - Console print using IODC.
1315 * @str: the string to output.
1316 * @count: length of str
1318 * Note that only these special chars are architected for console IODC io:
1319 * BEL, BS, CR, and LF. Others are passed through.
1320 * Since the HP console requires CR+LF to perform a 'newline', we translate
1323 int pdc_iodc_print(const unsigned char *str, unsigned count)
1325 unsigned int i, found = 0;
1326 unsigned long flags;
1328 count = min_t(unsigned int, count, sizeof(iodc_dbuf));
1330 spin_lock_irqsave(&pdc_lock, flags);
1331 for (i = 0; i < count;) {
1334 iodc_dbuf[i+0] = '\r';
1335 iodc_dbuf[i+1] = '\n';
1340 iodc_dbuf[i] = str[i];
1347 real32_call(PAGE0->mem_cons.iodc_io,
1348 (unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT,
1349 PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
1350 __pa(pdc_result), 0, __pa(iodc_dbuf), i, 0);
1351 spin_unlock_irqrestore(&pdc_lock, flags);
1356 #if !defined(BOOTLOADER)
1358 * pdc_iodc_getc - Read a character (non-blocking) from the PDC console.
1360 * Read a character (non-blocking) from the PDC console, returns -1 if
1361 * key is not present.
1363 int pdc_iodc_getc(void)
1367 unsigned long flags;
1369 /* Bail if no console input device. */
1370 if (!PAGE0->mem_kbd.iodc_io)
1373 /* wait for a keyboard (rs232)-input */
1374 spin_lock_irqsave(&pdc_lock, flags);
1375 real32_call(PAGE0->mem_kbd.iodc_io,
1376 (unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN,
1377 PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers),
1378 __pa(pdc_result), 0, __pa(iodc_dbuf), 1, 0);
1381 /* like convert_to_wide() but for first return value only: */
1382 status = *(int *)&pdc_result;
1383 spin_unlock_irqrestore(&pdc_lock, flags);
1391 int pdc_sti_call(unsigned long func, unsigned long flags,
1392 unsigned long inptr, unsigned long outputr,
1393 unsigned long glob_cfg)
1396 unsigned long irqflags;
1398 spin_lock_irqsave(&pdc_lock, irqflags);
1399 retval = real32_call(func, flags, inptr, outputr, glob_cfg);
1400 spin_unlock_irqrestore(&pdc_lock, irqflags);
1404 EXPORT_SYMBOL(pdc_sti_call);
1408 * pdc_pat_cell_get_number - Returns the cell number.
1409 * @cell_info: The return buffer.
1411 * This PDC call returns the cell number of the cell from which the call
1414 int pdc_pat_cell_get_number(struct pdc_pat_cell_num *cell_info)
1417 unsigned long flags;
1419 spin_lock_irqsave(&pdc_lock, flags);
1420 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_NUMBER, __pa(pdc_result));
1421 memcpy(cell_info, pdc_result, sizeof(*cell_info));
1422 spin_unlock_irqrestore(&pdc_lock, flags);
1428 * pdc_pat_cell_module - Retrieve the cell's module information.
1429 * @actcnt: The number of bytes written to mem_addr.
1430 * @ploc: The physical location.
1431 * @mod: The module index.
1432 * @view_type: The view of the address type.
1433 * @mem_addr: The return buffer.
1435 * This PDC call returns information about each module attached to the cell
1436 * at the specified location.
1438 int pdc_pat_cell_module(unsigned long *actcnt, unsigned long ploc, unsigned long mod,
1439 unsigned long view_type, void *mem_addr)
1442 unsigned long flags;
1443 static struct pdc_pat_cell_mod_maddr_block result __attribute__ ((aligned (8)));
1445 spin_lock_irqsave(&pdc_lock, flags);
1446 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_MODULE, __pa(pdc_result),
1447 ploc, mod, view_type, __pa(&result));
1449 *actcnt = pdc_result[0];
1450 memcpy(mem_addr, &result, *actcnt);
1452 spin_unlock_irqrestore(&pdc_lock, flags);
1458 * pdc_pat_cell_info - Retrieve the cell's information.
1459 * @info: The pointer to a struct pdc_pat_cell_info_rtn_block.
1460 * @actcnt: The number of bytes which should be written to info.
1461 * @offset: offset of the structure.
1462 * @cell_number: The cell number which should be asked, or -1 for current cell.
1464 * This PDC call returns information about the given cell (or all cells).
1466 int pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block *info,
1467 unsigned long *actcnt, unsigned long offset,
1468 unsigned long cell_number)
1471 unsigned long flags;
1472 struct pdc_pat_cell_info_rtn_block result;
1474 spin_lock_irqsave(&pdc_lock, flags);
1475 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_INFO,
1476 __pa(pdc_result), __pa(&result), *actcnt,
1477 offset, cell_number);
1479 *actcnt = pdc_result[0];
1480 memcpy(info, &result, *actcnt);
1482 spin_unlock_irqrestore(&pdc_lock, flags);
1488 * pdc_pat_cpu_get_number - Retrieve the cpu number.
1489 * @cpu_info: The return buffer.
1490 * @hpa: The Hard Physical Address of the CPU.
1492 * Retrieve the cpu number for the cpu at the specified HPA.
1494 int pdc_pat_cpu_get_number(struct pdc_pat_cpu_num *cpu_info, unsigned long hpa)
1497 unsigned long flags;
1499 spin_lock_irqsave(&pdc_lock, flags);
1500 retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_NUMBER,
1501 __pa(&pdc_result), hpa);
1502 memcpy(cpu_info, pdc_result, sizeof(*cpu_info));
1503 spin_unlock_irqrestore(&pdc_lock, flags);
1509 * pdc_pat_get_irt_size - Retrieve the number of entries in the cell's interrupt table.
1510 * @num_entries: The return value.
1511 * @cell_num: The target cell.
1513 * This PDC function returns the number of entries in the specified cell's
1516 int pdc_pat_get_irt_size(unsigned long *num_entries, unsigned long cell_num)
1519 unsigned long flags;
1521 spin_lock_irqsave(&pdc_lock, flags);
1522 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE_SIZE,
1523 __pa(pdc_result), cell_num);
1524 *num_entries = pdc_result[0];
1525 spin_unlock_irqrestore(&pdc_lock, flags);
1531 * pdc_pat_get_irt - Retrieve the cell's interrupt table.
1532 * @r_addr: The return buffer.
1533 * @cell_num: The target cell.
1535 * This PDC function returns the actual interrupt table for the specified cell.
1537 int pdc_pat_get_irt(void *r_addr, unsigned long cell_num)
1540 unsigned long flags;
1542 spin_lock_irqsave(&pdc_lock, flags);
1543 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE,
1544 __pa(r_addr), cell_num);
1545 spin_unlock_irqrestore(&pdc_lock, flags);
1551 * pdc_pat_pd_get_addr_map - Retrieve information about memory address ranges.
1552 * @actlen: The return buffer.
1553 * @mem_addr: Pointer to the memory buffer.
1554 * @count: The number of bytes to read from the buffer.
1555 * @offset: The offset with respect to the beginning of the buffer.
1558 int pdc_pat_pd_get_addr_map(unsigned long *actual_len, void *mem_addr,
1559 unsigned long count, unsigned long offset)
1562 unsigned long flags;
1564 spin_lock_irqsave(&pdc_lock, flags);
1565 retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_ADDR_MAP, __pa(pdc_result),
1566 __pa(pdc_result2), count, offset);
1567 *actual_len = pdc_result[0];
1568 memcpy(mem_addr, pdc_result2, *actual_len);
1569 spin_unlock_irqrestore(&pdc_lock, flags);
1575 * pdc_pat_pd_get_PDC_interface_revisions - Retrieve PDC interface revisions.
1576 * @legacy_rev: The legacy revision.
1577 * @pat_rev: The PAT revision.
1578 * @pdc_cap: The PDC capabilities.
1581 int pdc_pat_pd_get_pdc_revisions(unsigned long *legacy_rev,
1582 unsigned long *pat_rev, unsigned long *pdc_cap)
1585 unsigned long flags;
1587 spin_lock_irqsave(&pdc_lock, flags);
1588 retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_PDC_INTERF_REV,
1590 if (retval == PDC_OK) {
1591 *legacy_rev = pdc_result[0];
1592 *pat_rev = pdc_result[1];
1593 *pdc_cap = pdc_result[2];
1595 spin_unlock_irqrestore(&pdc_lock, flags);
1602 * pdc_pat_io_pci_cfg_read - Read PCI configuration space.
1603 * @pci_addr: PCI configuration space address for which the read request is being made.
1604 * @pci_size: Size of read in bytes. Valid values are 1, 2, and 4.
1605 * @mem_addr: Pointer to return memory buffer.
1608 int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr)
1611 unsigned long flags;
1613 spin_lock_irqsave(&pdc_lock, flags);
1614 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_READ,
1615 __pa(pdc_result), pci_addr, pci_size);
1617 case 1: *(u8 *) mem_addr = (u8) pdc_result[0]; break;
1618 case 2: *(u16 *)mem_addr = (u16) pdc_result[0]; break;
1619 case 4: *(u32 *)mem_addr = (u32) pdc_result[0]; break;
1621 spin_unlock_irqrestore(&pdc_lock, flags);
1627 * pdc_pat_io_pci_cfg_write - Retrieve information about memory address ranges.
1628 * @pci_addr: PCI configuration space address for which the write request is being made.
1629 * @pci_size: Size of write in bytes. Valid values are 1, 2, and 4.
1630 * @value: Pointer to 1, 2, or 4 byte value in low order end of argument to be
1631 * written to PCI Config space.
1634 int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val)
1637 unsigned long flags;
1639 spin_lock_irqsave(&pdc_lock, flags);
1640 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_WRITE,
1641 pci_addr, pci_size, val);
1642 spin_unlock_irqrestore(&pdc_lock, flags);
1648 * pdc_pat_mem_pdc_info - Retrieve information about page deallocation table
1649 * @rinfo: memory pdt information
1652 int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo)
1655 unsigned long flags;
1657 spin_lock_irqsave(&pdc_lock, flags);
1658 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_INFO,
1660 if (retval == PDC_OK)
1661 memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1662 spin_unlock_irqrestore(&pdc_lock, flags);
1668 * pdc_pat_mem_pdt_cell_info - Retrieve information about page deallocation
1670 * @rinfo: memory pdt information
1671 * @cell: cell number
1674 int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
1678 unsigned long flags;
1680 spin_lock_irqsave(&pdc_lock, flags);
1681 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_INFO,
1682 __pa(&pdc_result), cell);
1683 if (retval == PDC_OK)
1684 memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1685 spin_unlock_irqrestore(&pdc_lock, flags);
1691 * pdc_pat_mem_read_cell_pdt - Read PDT entries from (old) PAT firmware
1692 * @pret: array of PDT entries
1693 * @pdt_entries_ptr: ptr to hold number of PDT entries
1694 * @max_entries: maximum number of entries to be read
1697 int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1698 unsigned long *pdt_entries_ptr, unsigned long max_entries)
1701 unsigned long flags, entries;
1703 spin_lock_irqsave(&pdc_lock, flags);
1704 /* PDC_PAT_MEM_CELL_READ is available on early PAT machines only */
1705 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_READ,
1706 __pa(&pdc_result), parisc_cell_num,
1707 __pa(pdt_entries_ptr));
1709 if (retval == PDC_OK) {
1710 /* build up return value as for PDC_PAT_MEM_PD_READ */
1711 entries = min(pdc_result[0], max_entries);
1712 pret->pdt_entries = entries;
1713 pret->actual_count_bytes = entries * sizeof(unsigned long);
1716 spin_unlock_irqrestore(&pdc_lock, flags);
1717 WARN_ON(retval == PDC_OK && pdc_result[0] > max_entries);
1722 * pdc_pat_mem_read_pd_pdt - Read PDT entries from (newer) PAT firmware
1723 * @pret: array of PDT entries
1724 * @pdt_entries_ptr: ptr to hold number of PDT entries
1725 * @count: number of bytes to read
1726 * @offset: offset to start (in bytes)
1729 int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1730 unsigned long *pdt_entries_ptr, unsigned long count,
1731 unsigned long offset)
1734 unsigned long flags, entries;
1736 spin_lock_irqsave(&pdc_lock, flags);
1737 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_READ,
1738 __pa(&pdc_result), __pa(pdt_entries_ptr),
1741 if (retval == PDC_OK) {
1742 entries = min(pdc_result[0], count);
1743 pret->actual_count_bytes = entries;
1744 pret->pdt_entries = entries / sizeof(unsigned long);
1747 spin_unlock_irqrestore(&pdc_lock, flags);
1753 * pdc_pat_mem_get_dimm_phys_location - Get physical DIMM slot via PAT firmware
1754 * @pret: ptr to hold returned information
1755 * @phys_addr: physical address to examine
1758 int pdc_pat_mem_get_dimm_phys_location(
1759 struct pdc_pat_mem_phys_mem_location *pret,
1760 unsigned long phys_addr)
1763 unsigned long flags;
1765 spin_lock_irqsave(&pdc_lock, flags);
1766 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_ADDRESS,
1767 __pa(&pdc_result), phys_addr);
1769 if (retval == PDC_OK)
1770 memcpy(pret, &pdc_result, sizeof(*pret));
1772 spin_unlock_irqrestore(&pdc_lock, flags);
1776 #endif /* CONFIG_64BIT */
1777 #endif /* defined(BOOTLOADER) */
1780 /***************** 32-bit real-mode calls ***********/
1781 /* The struct below is used
1782 * to overlay real_stack (real2.S), preparing a 32-bit call frame.
1783 * real32_call_asm() then uses this stack in narrow real mode
1786 struct narrow_stack {
1787 /* use int, not long which is 64 bits */
1802 unsigned int frame_marker[8];
1804 /* in reality, there's nearly 8k of stack after this */
1807 long real32_call(unsigned long fn, ...)
1810 extern struct narrow_stack real_stack;
1811 extern unsigned long real32_call_asm(unsigned int *,
1816 real_stack.arg0 = va_arg(args, unsigned int);
1817 real_stack.arg1 = va_arg(args, unsigned int);
1818 real_stack.arg2 = va_arg(args, unsigned int);
1819 real_stack.arg3 = va_arg(args, unsigned int);
1820 real_stack.arg4 = va_arg(args, unsigned int);
1821 real_stack.arg5 = va_arg(args, unsigned int);
1822 real_stack.arg6 = va_arg(args, unsigned int);
1823 real_stack.arg7 = va_arg(args, unsigned int);
1824 real_stack.arg8 = va_arg(args, unsigned int);
1825 real_stack.arg9 = va_arg(args, unsigned int);
1826 real_stack.arg10 = va_arg(args, unsigned int);
1827 real_stack.arg11 = va_arg(args, unsigned int);
1828 real_stack.arg12 = va_arg(args, unsigned int);
1829 real_stack.arg13 = va_arg(args, unsigned int);
1832 return real32_call_asm(&real_stack.sp, &real_stack.arg0, fn);
1836 /***************** 64-bit real-mode calls ***********/
1849 unsigned long arg10;
1850 unsigned long arg11;
1851 unsigned long arg12;
1852 unsigned long arg13;
1853 unsigned long frame_marker[2]; /* rp, previous sp */
1855 /* in reality, there's nearly 8k of stack after this */
1858 long real64_call(unsigned long fn, ...)
1861 extern struct wide_stack real64_stack;
1862 extern unsigned long real64_call_asm(unsigned long *,
1867 real64_stack.arg0 = va_arg(args, unsigned long);
1868 real64_stack.arg1 = va_arg(args, unsigned long);
1869 real64_stack.arg2 = va_arg(args, unsigned long);
1870 real64_stack.arg3 = va_arg(args, unsigned long);
1871 real64_stack.arg4 = va_arg(args, unsigned long);
1872 real64_stack.arg5 = va_arg(args, unsigned long);
1873 real64_stack.arg6 = va_arg(args, unsigned long);
1874 real64_stack.arg7 = va_arg(args, unsigned long);
1875 real64_stack.arg8 = va_arg(args, unsigned long);
1876 real64_stack.arg9 = va_arg(args, unsigned long);
1877 real64_stack.arg10 = va_arg(args, unsigned long);
1878 real64_stack.arg11 = va_arg(args, unsigned long);
1879 real64_stack.arg12 = va_arg(args, unsigned long);
1880 real64_stack.arg13 = va_arg(args, unsigned long);
1883 return real64_call_asm(&real64_stack.sp, &real64_stack.arg0, fn);
1886 #endif /* CONFIG_64BIT */