1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/parisc/kernel/firmware.c  - safe PDC access routines
4 *
5 *	PDC == Processor Dependent Code
6 *
7 * See 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.
11 *
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>
17 */
18
19/*	I think it would be in everyone's best interest to follow this
20 *	guidelines when writing PDC wrappers:
21 *
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
29 *	   ones.
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
37 *
38 *	Example:
39 *	int pdc_cache_info(struct pdc_cache_info *cache_info )
40 *	{
41 *		int retval;
42 *
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);
48 *
49 *		return retval;
50 *	}
51 *					prumpf	991016
52 */
53
54#include <linux/stdarg.h>
55
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>
62
63#include <asm/page.h>
64#include <asm/pdc.h>
65#include <asm/pdcpat.h>
66#include <asm/processor.h>	/* for boot_cpu_data */
67
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)
73#else
74static DEFINE_SPINLOCK(pdc_lock);
75#endif
76
77extern unsigned long pdc_result[NUM_PDC_RESULT];
78extern unsigned long pdc_result2[NUM_PDC_RESULT];
79
80#ifdef CONFIG_64BIT
81#define WIDE_FIRMWARE 0x1
82#define NARROW_FIRMWARE 0x2
83
84/* Firmware needs to be initially set to narrow to determine the
85 * actual firmware width. */
86int parisc_narrow_firmware __ro_after_init = 2;
87#endif
88
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.
92 *
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).
98 */
99
100#ifdef CONFIG_64BIT
101long real64_call(unsigned long function, ...);
102#endif
103long real32_call(unsigned long function, ...);
104
105#ifdef CONFIG_64BIT
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)
108#else
109#   define MEM_PDC (unsigned long)PAGE0->mem_pdc
110#   define mem_pdc_call(args...) real32_call(MEM_PDC, args)
111#endif
112
113
114/**
115 * f_extend - Convert PDC addresses to kernel addresses.
116 * @address: Address returned from PDC.
117 *
118 * This function is used to convert PDC addresses into kernel addresses
119 * when the PDC address size and kernel address size are different.
120 */
121static unsigned long f_extend(unsigned long address)
122{
123#ifdef CONFIG_64BIT
124	if(unlikely(parisc_narrow_firmware)) {
125		if((address & 0xff000000) == 0xf0000000)
126			return 0xf0f0f0f000000000UL | (u32)address;
127
128		if((address & 0xf0000000) == 0xf0000000)
129			return 0xffffffff00000000UL | (u32)address;
130	}
131#endif
132	return address;
133}
134
135/**
136 * convert_to_wide - Convert the return buffer addresses into kernel addresses.
137 * @address: The return buffer from PDC.
138 *
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
141 * different.
142 */
143static void convert_to_wide(unsigned long *addr)
144{
145#ifdef CONFIG_64BIT
146	int i;
147	unsigned int *p = (unsigned int *)addr;
148
149	if (unlikely(parisc_narrow_firmware)) {
150		for (i = (NUM_PDC_RESULT-1); i >= 0; --i)
151			addr[i] = p[i];
152	}
153#endif
154}
155
156#ifdef CONFIG_64BIT
157void set_firmware_width_unlocked(void)
158{
159	int ret;
160
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;
166}
167
168/**
169 * set_firmware_width - Determine if the firmware is wide or narrow.
170 *
171 * This function must be called before any pdc_* function that uses the
172 * convert_to_wide function.
173 */
174void set_firmware_width(void)
175{
176	unsigned long flags;
177
178	/* already initialized? */
179	if (parisc_narrow_firmware != 2)
180		return;
181
182	spin_lock_irqsave(&pdc_lock, flags);
183	set_firmware_width_unlocked();
184	spin_unlock_irqrestore(&pdc_lock, flags);
185}
186#else
187void set_firmware_width_unlocked(void)
188{
189	return;
190}
191
192void set_firmware_width(void)
193{
194	return;
195}
196#endif /*CONFIG_64BIT*/
197
198
199#if !defined(BOOTLOADER)
200/**
201 * pdc_emergency_unlock - Unlock the linux pdc lock
202 *
203 * This call unlocks the linux pdc lock in case we need some PDC functions
204 * (like pdc_add_valid) during kernel stack dump.
205 */
206void pdc_emergency_unlock(void)
207{
208 	/* Spinlock DEBUG code freaks out if we unconditionally unlock */
209        if (spin_is_locked(&pdc_lock))
210		spin_unlock(&pdc_lock);
211}
212
213
214/**
215 * pdc_add_valid - Verify address can be accessed without causing a HPMC.
216 * @address: Address to be verified.
217 *
218 * This PDC call attempts to read from the specified address and verifies
219 * if the address is valid.
220 *
221 * The return value is PDC_OK (0) in case accessing this address is valid.
222 */
223int pdc_add_valid(unsigned long address)
224{
225        int retval;
226	unsigned long flags;
227
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);
231
232        return retval;
233}
234EXPORT_SYMBOL(pdc_add_valid);
235
236/**
237 * pdc_instr - Get instruction that invokes PDCE_CHECK in HPMC handler.
238 * @instr: Pointer to variable which will get instruction opcode.
239 *
240 * The return value is PDC_OK (0) in case call succeeded.
241 */
242int __init pdc_instr(unsigned int *instr)
243{
244	int retval;
245	unsigned long flags;
246
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);
252
253	return retval;
254}
255
256/**
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.
261 *
262 * An HVERSION dependent call for returning the chassis information.
263 */
264int __init pdc_chassis_info(struct pdc_chassis_info *chassis_info, void *led_info, unsigned long len)
265{
266        int retval;
267	unsigned long flags;
268
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);
277
278        return retval;
279}
280
281/**
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
284 *
285 * Must be correctly formatted or expect system crash
286 */
287#ifdef CONFIG_64BIT
288int pdc_pat_chassis_send_log(unsigned long state, unsigned long data)
289{
290	int retval = 0;
291	unsigned long flags;
292
293	if (!is_pdc_pat())
294		return -1;
295
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);
299
300	return retval;
301}
302#endif
303
304/**
305 * pdc_chassis_disp - Updates chassis code
306 * @retval: -1 on error, 0 on success
307 */
308int pdc_chassis_disp(unsigned long disp)
309{
310	int retval = 0;
311	unsigned long flags;
312
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);
316
317	return retval;
318}
319
320/**
321 * pdc_cpu_rendenzvous - Stop currently executing CPU
322 * @retval: -1 on error, 0 on success
323 */
324int __pdc_cpu_rendezvous(void)
325{
326	if (is_pdc_pat())
327		return mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_RENDEZVOUS);
328	else
329		return mem_pdc_call(PDC_PROC, 1, 0);
330}
331
332/**
333 * pdc_cpu_rendezvous_lock - Lock PDC while transitioning to rendezvous state
334 */
335void pdc_cpu_rendezvous_lock(void)
336{
337	spin_lock(&pdc_lock);
338}
339
340/**
341 * pdc_cpu_rendezvous_unlock - Unlock PDC after reaching rendezvous state
342 */
343void pdc_cpu_rendezvous_unlock(void)
344{
345	spin_unlock(&pdc_lock);
346}
347
348/**
349 * pdc_pat_get_PDC_entrypoint - Get PDC entry point for current CPU
350 * @retval: -1 on error, 0 on success
351 */
352int pdc_pat_get_PDC_entrypoint(unsigned long *pdc_entry)
353{
354	int retval = 0;
355	unsigned long flags;
356
357	if (!IS_ENABLED(CONFIG_SMP) || !is_pdc_pat()) {
358		*pdc_entry = MEM_PDC;
359		return 0;
360	}
361
362	spin_lock_irqsave(&pdc_lock, flags);
363	retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_PDC_ENTRYPOINT,
364			__pa(pdc_result));
365	*pdc_entry = pdc_result[0];
366	spin_unlock_irqrestore(&pdc_lock, flags);
367
368	return retval;
369}
370/**
371 * pdc_chassis_warn - Fetches chassis warnings
372 * @retval: -1 on error, 0 on success
373 */
374int pdc_chassis_warn(unsigned long *warn)
375{
376	int retval = 0;
377	unsigned long flags;
378
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);
383
384	return retval;
385}
386
387int pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg *pdc_coproc_info)
388{
389	int ret;
390
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];
397
398	return ret;
399}
400
401/**
402 * pdc_coproc_cfg - To identify coprocessors attached to the processor.
403 * @pdc_coproc_info: Return buffer address.
404 *
405 * This PDC call returns the presence and status of all the coprocessors
406 * attached to the processor.
407 */
408int pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info)
409{
410	int ret;
411	unsigned long flags;
412
413	spin_lock_irqsave(&pdc_lock, flags);
414	ret = pdc_coproc_cfg_unlocked(pdc_coproc_info);
415	spin_unlock_irqrestore(&pdc_lock, flags);
416
417	return ret;
418}
419
420/**
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.
427 *
428 * This PDC call reads from the IODC of the module specified by the hpa
429 * argument.
430 */
431int pdc_iodc_read(unsigned long *actcnt, unsigned long hpa, unsigned int index,
432		  void *iodc_data, unsigned int iodc_data_size)
433{
434	int retval;
435	unsigned long flags;
436
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);
444
445	return retval;
446}
447EXPORT_SYMBOL(pdc_iodc_read);
448
449/**
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.
454 *
455 * To locate and identify modules which reside at fixed I/O addresses, which
456 * do not self-identify via architected bus walks.
457 */
458int pdc_system_map_find_mods(struct pdc_system_map_mod_info *pdc_mod_info,
459			     struct pdc_module_path *mod_path, long mod_index)
460{
461	int retval;
462	unsigned long flags;
463
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);
471
472	pdc_mod_info->mod_addr = f_extend(pdc_mod_info->mod_addr);
473	return retval;
474}
475
476/**
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.
481 *
482 * Retrieve additional information about subsequent address ranges for modules
483 * with multiple address ranges.
484 */
485int pdc_system_map_find_addrs(struct pdc_system_map_addr_info *pdc_addr_info,
486			      long mod_index, long addr_index)
487{
488	int retval;
489	unsigned long flags;
490
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);
497
498	pdc_addr_info->mod_addr = f_extend(pdc_addr_info->mod_addr);
499	return retval;
500}
501
502/**
503 * pdc_model_info - Return model information about the processor.
504 * @model: The return buffer.
505 *
506 * Returns the version numbers, identifiers, and capabilities from the processor module.
507 */
508int pdc_model_info(struct pdc_model *model)
509{
510	int retval;
511	unsigned long flags;
512
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);
518
519	return retval;
520}
521
522/**
523 * pdc_model_sysmodel - Get the system model name.
524 * @name: A char array of at least 81 characters.
525 *
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
528 * on HP/UX.
529 */
530int pdc_model_sysmodel(char *name)
531{
532        int retval;
533	unsigned long flags;
534
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);
539
540        if (retval == PDC_OK) {
541                name[pdc_result[0]] = '\0'; /* add trailing '\0' */
542        } else {
543                name[0] = 0;
544        }
545        spin_unlock_irqrestore(&pdc_lock, flags);
546
547        return retval;
548}
549
550/**
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.
554 *
555 * Returns the version number for each processor component.
556 *
557 * This comment was here before, but I do not know what it means :( -RB
558 * id: 0 = cpu revision, 1 = boot-rom-version
559 */
560int pdc_model_versions(unsigned long *versions, int id)
561{
562        int retval;
563	unsigned long flags;
564
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);
570
571        return retval;
572}
573
574/**
575 * pdc_model_cpuid - Returns the CPU_ID.
576 * @cpu_id: The return buffer.
577 *
578 * Returns the CPU_ID value which uniquely identifies the cpu portion of
579 * the processor module.
580 */
581int pdc_model_cpuid(unsigned long *cpu_id)
582{
583        int retval;
584	unsigned long flags;
585
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);
592
593        return retval;
594}
595
596/**
597 * pdc_model_capabilities - Returns the platform capabilities.
598 * @capabilities: The return buffer.
599 *
600 * Returns information about platform support for 32- and/or 64-bit
601 * OSes, IO-PDIR coherency, and virtual aliasing.
602 */
603int pdc_model_capabilities(unsigned long *capabilities)
604{
605        int retval;
606	unsigned long flags;
607
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];
614        } else {
615                *capabilities = PDC_MODEL_OS32;
616        }
617        spin_unlock_irqrestore(&pdc_lock, flags);
618
619        return retval;
620}
621
622/**
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.
627 *
628 * Returns strings containing the original and current product numbers and the
629 * serial number of the system.
630 */
631int pdc_model_platform_info(char *orig_prod_num, char *current_prod_num,
632		char *serial_no)
633{
634	int retval;
635	unsigned long flags;
636
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);
642
643	return retval;
644}
645
646/**
647 * pdc_cache_info - Return cache and TLB information.
648 * @cache_info: The return buffer.
649 *
650 * Returns information about the processor's cache and TLB.
651 */
652int pdc_cache_info(struct pdc_cache_info *cache_info)
653{
654        int retval;
655	unsigned long flags;
656
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);
662
663        return retval;
664}
665
666/**
667 * pdc_spaceid_bits - Return whether Space ID hashing is turned on.
668 * @space_bits: Should be 0, if not, bad mojo!
669 *
670 * Returns information about Space ID hashing.
671 */
672int pdc_spaceid_bits(unsigned long *space_bits)
673{
674	int retval;
675	unsigned long flags;
676
677	spin_lock_irqsave(&pdc_lock, flags);
678	pdc_result[0] = 0;
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);
683
684	return retval;
685}
686
687#ifndef CONFIG_PA20
688/**
689 * pdc_btlb_info - Return block TLB information.
690 * @btlb: The return buffer.
691 *
692 * Returns information about the hardware Block TLB.
693 */
694int pdc_btlb_info(struct pdc_btlb_info *btlb)
695{
696        int retval;
697	unsigned long flags;
698
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);
703
704        if(retval < 0) {
705                btlb->max_size = 0;
706        }
707        return retval;
708}
709
710/**
711 * pdc_mem_map_hpa - Find fixed module information.
712 * @address: The return buffer
713 * @mod_path: pointer to dev path structure.
714 *
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
718 * call.
719 *
720 * This call is supported by all existing S700 workstations (up to  Gecko).
721 */
722int pdc_mem_map_hpa(struct pdc_memory_map *address,
723		struct pdc_module_path *mod_path)
724{
725        int retval;
726	unsigned long flags;
727
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),
731				__pa(pdc_result2));
732        memcpy(address, pdc_result, sizeof(*address));
733        spin_unlock_irqrestore(&pdc_lock, flags);
734
735        return retval;
736}
737#endif	/* !CONFIG_PA20 */
738
739/**
740 * pdc_lan_station_id - Get the LAN address.
741 * @lan_addr: The return buffer.
742 * @hpa: The network device HPA.
743 *
744 * Get the LAN station address when it is not directly available from the LAN hardware.
745 */
746int pdc_lan_station_id(char *lan_addr, unsigned long hpa)
747{
748	int retval;
749	unsigned long flags;
750
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);
754	if (retval < 0) {
755		/* FIXME: else read MAC from NVRAM */
756		memset(lan_addr, 0, PDC_LAN_STATION_ID_SIZE);
757	} else {
758		memcpy(lan_addr, pdc_result, PDC_LAN_STATION_ID_SIZE);
759	}
760	spin_unlock_irqrestore(&pdc_lock, flags);
761
762	return retval;
763}
764EXPORT_SYMBOL(pdc_lan_station_id);
765
766/**
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.
771 *
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.
775 */
776int pdc_stable_read(unsigned long staddr, void *memaddr, unsigned long count)
777{
778       int retval;
779	unsigned long flags;
780
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);
787
788       return retval;
789}
790EXPORT_SYMBOL(pdc_stable_read);
791
792/**
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.
797 *
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.
801 */
802int pdc_stable_write(unsigned long staddr, void *memaddr, unsigned long count)
803{
804       int retval;
805	unsigned long flags;
806
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);
813
814       return retval;
815}
816EXPORT_SYMBOL(pdc_stable_write);
817
818/**
819 * pdc_stable_get_size - Get Stable Storage size in bytes.
820 * @size: pointer where the size will be stored.
821 *
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.
826 */
827int pdc_stable_get_size(unsigned long *size)
828{
829       int retval;
830	unsigned long flags;
831
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);
836
837       return retval;
838}
839EXPORT_SYMBOL(pdc_stable_get_size);
840
841/**
842 * pdc_stable_verify_contents - Checks that Stable Storage contents are valid.
843 *
844 * This PDC call is meant to be used to check the integrity of the current
845 * contents of Stable Storage.
846 */
847int pdc_stable_verify_contents(void)
848{
849       int retval;
850	unsigned long flags;
851
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);
855
856       return retval;
857}
858EXPORT_SYMBOL(pdc_stable_verify_contents);
859
860/**
861 * pdc_stable_initialize - Sets Stable Storage contents to zero and initialize
862 * the validity indicator.
863 *
864 * This PDC call will erase all contents of Stable Storage. Use with care!
865 */
866int pdc_stable_initialize(void)
867{
868       int retval;
869	unsigned long flags;
870
871       spin_lock_irqsave(&pdc_lock, flags);
872       retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_INITIALIZE);
873       spin_unlock_irqrestore(&pdc_lock, flags);
874
875       return retval;
876}
877EXPORT_SYMBOL(pdc_stable_initialize);
878
879/**
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
883 *
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.
892 */
893int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initiator)
894{
895	int retval;
896	unsigned long flags;
897
898	spin_lock_irqsave(&pdc_lock, flags);
899
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)
903
904	retval = mem_pdc_call(PDC_INITIATOR, PDC_GET_INITIATOR,
905			      __pa(pdc_result), __pa(hwpath));
906	if (retval < PDC_OK)
907		goto out;
908
909	if (pdc_result[0] < 16) {
910		initiator->host_id = pdc_result[0];
911	} else {
912		initiator->host_id = -1;
913	}
914
915	/*
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
918	 */
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;
927	}
928
929	if (IS_SPROCKETS()) {
930		initiator->width = pdc_result[4];
931		initiator->mode = pdc_result[5];
932	} else {
933		initiator->width = -1;
934		initiator->mode = -1;
935	}
936
937 out:
938	spin_unlock_irqrestore(&pdc_lock, flags);
939
940	return (retval >= PDC_OK);
941}
942EXPORT_SYMBOL(pdc_get_initiator);
943
944
945/**
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.
949 *
950 * This PDC function returns the number of entries in the specified cell's
951 * interrupt table.
952 * Similar to PDC_PAT stuff - but added for Forte/Allegro boxes
953 */
954int pdc_pci_irt_size(unsigned long *num_entries, unsigned long hpa)
955{
956	int retval;
957	unsigned long flags;
958
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);
965
966	return retval;
967}
968
969/**
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.
973 * @tbl:
974 *
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
977 */
978int pdc_pci_irt(unsigned long num_entries, unsigned long hpa, void *tbl)
979{
980	int retval;
981	unsigned long flags;
982
983	BUG_ON((unsigned long)tbl & 0x7);
984
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);
990
991	return retval;
992}
993
994
995#if 0	/* UNTEST CODE - left here in case someone needs it */
996
997/**
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
1001 *
1002 * Read PCI Configuration space *before* linux PCI subsystem is running.
1003 */
1004unsigned int pdc_pci_config_read(void *hpa, unsigned long cfg_addr)
1005{
1006	int retval;
1007	unsigned long flags;
1008
1009	spin_lock_irqsave(&pdc_lock, flags);
1010	pdc_result[0] = 0;
1011	pdc_result[1] = 0;
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);
1015
1016	return retval ? ~0 : (unsigned int) pdc_result[0];
1017}
1018
1019
1020/**
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
1025 *
1026 * Write PCI Configuration space *before* linux PCI subsystem is running.
1027 */
1028void pdc_pci_config_write(void *hpa, unsigned long cfg_addr, unsigned int val)
1029{
1030	int retval;
1031	unsigned long flags;
1032
1033	spin_lock_irqsave(&pdc_lock, flags);
1034	pdc_result[0] = 0;
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);
1039
1040	return retval;
1041}
1042#endif /* UNTESTED CODE */
1043
1044/**
1045 * pdc_tod_read - Read the Time-Of-Day clock.
1046 * @tod: The return buffer:
1047 *
1048 * Read the Time-Of-Day clock
1049 */
1050int pdc_tod_read(struct pdc_tod *tod)
1051{
1052        int retval;
1053	unsigned long flags;
1054
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);
1060
1061        return retval;
1062}
1063EXPORT_SYMBOL(pdc_tod_read);
1064
1065int pdc_mem_pdt_info(struct pdc_mem_retinfo *rinfo)
1066{
1067	int retval;
1068	unsigned long flags;
1069
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);
1075
1076	return retval;
1077}
1078
1079int pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt *pret,
1080		unsigned long *pdt_entries_ptr)
1081{
1082	int retval;
1083	unsigned long flags;
1084
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));
1091	}
1092	spin_unlock_irqrestore(&pdc_lock, flags);
1093
1094#ifdef CONFIG_64BIT
1095	/*
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
1098	 */
1099	if (WARN_ON_ONCE((retval == PDC_OK) && parisc_narrow_firmware))
1100		return PDC_ERROR;
1101#endif
1102
1103	return retval;
1104}
1105
1106/**
1107 * pdc_pim_toc11 - Fetch TOC PIM 1.1 data from firmware.
1108 * @ret: pointer to return buffer
1109 */
1110int pdc_pim_toc11(struct pdc_toc_pim_11 *ret)
1111{
1112	int retval;
1113	unsigned long flags;
1114
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);
1119	return retval;
1120}
1121
1122/**
1123 * pdc_pim_toc20 - Fetch TOC PIM 2.0 data from firmware.
1124 * @ret: pointer to return buffer
1125 */
1126int pdc_pim_toc20(struct pdc_toc_pim_20 *ret)
1127{
1128	int retval;
1129	unsigned long flags;
1130
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);
1135	return retval;
1136}
1137
1138/**
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.
1142 *
1143 * Set the Time-Of-Day clock.
1144 */
1145int pdc_tod_set(unsigned long sec, unsigned long usec)
1146{
1147        int retval;
1148	unsigned long flags;
1149
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);
1153
1154        return retval;
1155}
1156EXPORT_SYMBOL(pdc_tod_set);
1157
1158#ifdef CONFIG_64BIT
1159int pdc_mem_mem_table(struct pdc_memory_table_raddr *r_addr,
1160		struct pdc_memory_table *tbl, unsigned long entries)
1161{
1162	int retval;
1163	unsigned long flags;
1164
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);
1171
1172	return retval;
1173}
1174#endif /* CONFIG_64BIT */
1175
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
1178 * it later. :)
1179 */
1180int pdc_do_firm_test_reset(unsigned long ftc_bitmap)
1181{
1182        int retval;
1183	unsigned long flags;
1184
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);
1189
1190        return retval;
1191}
1192
1193/*
1194 * pdc_do_reset - Reset the system.
1195 *
1196 * Reset the system.
1197 */
1198int pdc_do_reset(void)
1199{
1200        int retval;
1201	unsigned long flags;
1202
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);
1206
1207        return retval;
1208}
1209
1210/*
1211 * pdc_soft_power_info - Enable soft power switch.
1212 * @power_reg: address of soft power register
1213 *
1214 * Return the absolute address of the soft power switch register
1215 */
1216int __init pdc_soft_power_info(unsigned long *power_reg)
1217{
1218	int retval;
1219	unsigned long flags;
1220
1221	*power_reg = (unsigned long) (-1);
1222
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]);
1228	}
1229	spin_unlock_irqrestore(&pdc_lock, flags);
1230
1231	return retval;
1232}
1233
1234/*
1235 * pdc_soft_power_button - Control the soft power button behaviour
1236 * @sw_control: 0 for hardware control, 1 for software control
1237 *
1238 *
1239 * This PDC function places the soft power button under software or
1240 * hardware control.
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.
1244 */
1245int pdc_soft_power_button(int sw_control)
1246{
1247	int retval;
1248	unsigned long flags;
1249
1250	spin_lock_irqsave(&pdc_lock, flags);
1251	retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
1252	spin_unlock_irqrestore(&pdc_lock, flags);
1253
1254	return retval;
1255}
1256
1257/*
1258 * pdc_io_reset - Hack to avoid overlapping range registers of Bridges devices.
1259 * Primarily a problem on T600 (which parisc-linux doesn't support) but
1260 * who knows what other platform firmware might do with this OS "hook".
1261 */
1262void pdc_io_reset(void)
1263{
1264	unsigned long flags;
1265
1266	spin_lock_irqsave(&pdc_lock, flags);
1267	mem_pdc_call(PDC_IO, PDC_IO_RESET, 0);
1268	spin_unlock_irqrestore(&pdc_lock, flags);
1269}
1270
1271/*
1272 * pdc_io_reset_devices - Hack to Stop USB controller
1273 *
1274 * If PDC used the usb controller, the usb controller
1275 * is still running and will crash the machines during iommu
1276 * setup, because of still running DMA. This PDC call
1277 * stops the USB controller.
1278 * Normally called after calling pdc_io_reset().
1279 */
1280void pdc_io_reset_devices(void)
1281{
1282	unsigned long flags;
1283
1284	spin_lock_irqsave(&pdc_lock, flags);
1285	mem_pdc_call(PDC_IO, PDC_IO_RESET_DEVICES, 0);
1286	spin_unlock_irqrestore(&pdc_lock, flags);
1287}
1288
1289#endif /* defined(BOOTLOADER) */
1290
1291/* locked by pdc_console_lock */
1292static int __attribute__((aligned(8)))   iodc_retbuf[32];
1293static char __attribute__((aligned(64))) iodc_dbuf[4096];
1294
1295/**
1296 * pdc_iodc_print - Console print using IODC.
1297 * @str: the string to output.
1298 * @count: length of str
1299 *
1300 * Note that only these special chars are architected for console IODC io:
1301 * BEL, BS, CR, and LF. Others are passed through.
1302 * Since the HP console requires CR+LF to perform a 'newline', we translate
1303 * "\n" to "\r\n".
1304 */
1305int pdc_iodc_print(const unsigned char *str, unsigned count)
1306{
1307	unsigned int i;
1308	unsigned long flags;
1309
1310	for (i = 0; i < count;) {
1311		switch(str[i]) {
1312		case '\n':
1313			iodc_dbuf[i+0] = '\r';
1314			iodc_dbuf[i+1] = '\n';
1315			i += 2;
1316			goto print;
1317		default:
1318			iodc_dbuf[i] = str[i];
1319			i++;
1320			break;
1321		}
1322	}
1323
1324print:
1325        spin_lock_irqsave(&pdc_lock, flags);
1326        real32_call(PAGE0->mem_cons.iodc_io,
1327                    (unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT,
1328                    PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
1329                    __pa(iodc_retbuf), 0, __pa(iodc_dbuf), i, 0);
1330        spin_unlock_irqrestore(&pdc_lock, flags);
1331
1332	return i;
1333}
1334
1335#if !defined(BOOTLOADER)
1336/**
1337 * pdc_iodc_getc - Read a character (non-blocking) from the PDC console.
1338 *
1339 * Read a character (non-blocking) from the PDC console, returns -1 if
1340 * key is not present.
1341 */
1342int pdc_iodc_getc(void)
1343{
1344	int ch;
1345	int status;
1346	unsigned long flags;
1347
1348	/* Bail if no console input device. */
1349	if (!PAGE0->mem_kbd.iodc_io)
1350		return 0;
1351
1352	/* wait for a keyboard (rs232)-input */
1353	spin_lock_irqsave(&pdc_lock, flags);
1354	real32_call(PAGE0->mem_kbd.iodc_io,
1355		    (unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN,
1356		    PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers),
1357		    __pa(iodc_retbuf), 0, __pa(iodc_dbuf), 1, 0);
1358
1359	ch = *iodc_dbuf;
1360	status = *iodc_retbuf;
1361	spin_unlock_irqrestore(&pdc_lock, flags);
1362
1363	if (status == 0)
1364	    return -1;
1365
1366	return ch;
1367}
1368
1369int pdc_sti_call(unsigned long func, unsigned long flags,
1370                 unsigned long inptr, unsigned long outputr,
1371                 unsigned long glob_cfg)
1372{
1373        int retval;
1374	unsigned long irqflags;
1375
1376        spin_lock_irqsave(&pdc_lock, irqflags);
1377        retval = real32_call(func, flags, inptr, outputr, glob_cfg);
1378        spin_unlock_irqrestore(&pdc_lock, irqflags);
1379
1380        return retval;
1381}
1382EXPORT_SYMBOL(pdc_sti_call);
1383
1384#ifdef CONFIG_64BIT
1385/**
1386 * pdc_pat_cell_get_number - Returns the cell number.
1387 * @cell_info: The return buffer.
1388 *
1389 * This PDC call returns the cell number of the cell from which the call
1390 * is made.
1391 */
1392int pdc_pat_cell_get_number(struct pdc_pat_cell_num *cell_info)
1393{
1394	int retval;
1395	unsigned long flags;
1396
1397	spin_lock_irqsave(&pdc_lock, flags);
1398	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_NUMBER, __pa(pdc_result));
1399	memcpy(cell_info, pdc_result, sizeof(*cell_info));
1400	spin_unlock_irqrestore(&pdc_lock, flags);
1401
1402	return retval;
1403}
1404
1405/**
1406 * pdc_pat_cell_module - Retrieve the cell's module information.
1407 * @actcnt: The number of bytes written to mem_addr.
1408 * @ploc: The physical location.
1409 * @mod: The module index.
1410 * @view_type: The view of the address type.
1411 * @mem_addr: The return buffer.
1412 *
1413 * This PDC call returns information about each module attached to the cell
1414 * at the specified location.
1415 */
1416int pdc_pat_cell_module(unsigned long *actcnt, unsigned long ploc, unsigned long mod,
1417			unsigned long view_type, void *mem_addr)
1418{
1419	int retval;
1420	unsigned long flags;
1421	static struct pdc_pat_cell_mod_maddr_block result __attribute__ ((aligned (8)));
1422
1423	spin_lock_irqsave(&pdc_lock, flags);
1424	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_MODULE, __pa(pdc_result),
1425			      ploc, mod, view_type, __pa(&result));
1426	if(!retval) {
1427		*actcnt = pdc_result[0];
1428		memcpy(mem_addr, &result, *actcnt);
1429	}
1430	spin_unlock_irqrestore(&pdc_lock, flags);
1431
1432	return retval;
1433}
1434
1435/**
1436 * pdc_pat_cell_info - Retrieve the cell's information.
1437 * @info: The pointer to a struct pdc_pat_cell_info_rtn_block.
1438 * @actcnt: The number of bytes which should be written to info.
1439 * @offset: offset of the structure.
1440 * @cell_number: The cell number which should be asked, or -1 for current cell.
1441 *
1442 * This PDC call returns information about the given cell (or all cells).
1443 */
1444int pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block *info,
1445		unsigned long *actcnt, unsigned long offset,
1446		unsigned long cell_number)
1447{
1448	int retval;
1449	unsigned long flags;
1450	struct pdc_pat_cell_info_rtn_block result;
1451
1452	spin_lock_irqsave(&pdc_lock, flags);
1453	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_INFO,
1454			__pa(pdc_result), __pa(&result), *actcnt,
1455			offset, cell_number);
1456	if (!retval) {
1457		*actcnt = pdc_result[0];
1458		memcpy(info, &result, *actcnt);
1459	}
1460	spin_unlock_irqrestore(&pdc_lock, flags);
1461
1462	return retval;
1463}
1464
1465/**
1466 * pdc_pat_cpu_get_number - Retrieve the cpu number.
1467 * @cpu_info: The return buffer.
1468 * @hpa: The Hard Physical Address of the CPU.
1469 *
1470 * Retrieve the cpu number for the cpu at the specified HPA.
1471 */
1472int pdc_pat_cpu_get_number(struct pdc_pat_cpu_num *cpu_info, unsigned long hpa)
1473{
1474	int retval;
1475	unsigned long flags;
1476
1477	spin_lock_irqsave(&pdc_lock, flags);
1478	retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_NUMBER,
1479			      __pa(&pdc_result), hpa);
1480	memcpy(cpu_info, pdc_result, sizeof(*cpu_info));
1481	spin_unlock_irqrestore(&pdc_lock, flags);
1482
1483	return retval;
1484}
1485
1486/**
1487 * pdc_pat_get_irt_size - Retrieve the number of entries in the cell's interrupt table.
1488 * @num_entries: The return value.
1489 * @cell_num: The target cell.
1490 *
1491 * This PDC function returns the number of entries in the specified cell's
1492 * interrupt table.
1493 */
1494int pdc_pat_get_irt_size(unsigned long *num_entries, unsigned long cell_num)
1495{
1496	int retval;
1497	unsigned long flags;
1498
1499	spin_lock_irqsave(&pdc_lock, flags);
1500	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE_SIZE,
1501			      __pa(pdc_result), cell_num);
1502	*num_entries = pdc_result[0];
1503	spin_unlock_irqrestore(&pdc_lock, flags);
1504
1505	return retval;
1506}
1507
1508/**
1509 * pdc_pat_get_irt - Retrieve the cell's interrupt table.
1510 * @r_addr: The return buffer.
1511 * @cell_num: The target cell.
1512 *
1513 * This PDC function returns the actual interrupt table for the specified cell.
1514 */
1515int pdc_pat_get_irt(void *r_addr, unsigned long cell_num)
1516{
1517	int retval;
1518	unsigned long flags;
1519
1520	spin_lock_irqsave(&pdc_lock, flags);
1521	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE,
1522			      __pa(r_addr), cell_num);
1523	spin_unlock_irqrestore(&pdc_lock, flags);
1524
1525	return retval;
1526}
1527
1528/**
1529 * pdc_pat_pd_get_addr_map - Retrieve information about memory address ranges.
1530 * @actlen: The return buffer.
1531 * @mem_addr: Pointer to the memory buffer.
1532 * @count: The number of bytes to read from the buffer.
1533 * @offset: The offset with respect to the beginning of the buffer.
1534 *
1535 */
1536int pdc_pat_pd_get_addr_map(unsigned long *actual_len, void *mem_addr,
1537			    unsigned long count, unsigned long offset)
1538{
1539	int retval;
1540	unsigned long flags;
1541
1542	spin_lock_irqsave(&pdc_lock, flags);
1543	retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_ADDR_MAP, __pa(pdc_result),
1544			      __pa(pdc_result2), count, offset);
1545	*actual_len = pdc_result[0];
1546	memcpy(mem_addr, pdc_result2, *actual_len);
1547	spin_unlock_irqrestore(&pdc_lock, flags);
1548
1549	return retval;
1550}
1551
1552/**
1553 * pdc_pat_pd_get_PDC_interface_revisions - Retrieve PDC interface revisions.
1554 * @legacy_rev: The legacy revision.
1555 * @pat_rev: The PAT revision.
1556 * @pdc_cap: The PDC capabilities.
1557 *
1558 */
1559int pdc_pat_pd_get_pdc_revisions(unsigned long *legacy_rev,
1560		unsigned long *pat_rev, unsigned long *pdc_cap)
1561{
1562	int retval;
1563	unsigned long flags;
1564
1565	spin_lock_irqsave(&pdc_lock, flags);
1566	retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_PDC_INTERF_REV,
1567				__pa(pdc_result));
1568	if (retval == PDC_OK) {
1569		*legacy_rev = pdc_result[0];
1570		*pat_rev = pdc_result[1];
1571		*pdc_cap = pdc_result[2];
1572	}
1573	spin_unlock_irqrestore(&pdc_lock, flags);
1574
1575	return retval;
1576}
1577
1578
1579/**
1580 * pdc_pat_io_pci_cfg_read - Read PCI configuration space.
1581 * @pci_addr: PCI configuration space address for which the read request is being made.
1582 * @pci_size: Size of read in bytes. Valid values are 1, 2, and 4.
1583 * @mem_addr: Pointer to return memory buffer.
1584 *
1585 */
1586int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr)
1587{
1588	int retval;
1589	unsigned long flags;
1590
1591	spin_lock_irqsave(&pdc_lock, flags);
1592	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_READ,
1593					__pa(pdc_result), pci_addr, pci_size);
1594	switch(pci_size) {
1595		case 1: *(u8 *) mem_addr =  (u8)  pdc_result[0]; break;
1596		case 2: *(u16 *)mem_addr =  (u16) pdc_result[0]; break;
1597		case 4: *(u32 *)mem_addr =  (u32) pdc_result[0]; break;
1598	}
1599	spin_unlock_irqrestore(&pdc_lock, flags);
1600
1601	return retval;
1602}
1603
1604/**
1605 * pdc_pat_io_pci_cfg_write - Retrieve information about memory address ranges.
1606 * @pci_addr: PCI configuration space address for which the write  request is being made.
1607 * @pci_size: Size of write in bytes. Valid values are 1, 2, and 4.
1608 * @value: Pointer to 1, 2, or 4 byte value in low order end of argument to be
1609 *         written to PCI Config space.
1610 *
1611 */
1612int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val)
1613{
1614	int retval;
1615	unsigned long flags;
1616
1617	spin_lock_irqsave(&pdc_lock, flags);
1618	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_WRITE,
1619				pci_addr, pci_size, val);
1620	spin_unlock_irqrestore(&pdc_lock, flags);
1621
1622	return retval;
1623}
1624
1625/**
1626 * pdc_pat_mem_pdc_info - Retrieve information about page deallocation table
1627 * @rinfo: memory pdt information
1628 *
1629 */
1630int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo)
1631{
1632	int retval;
1633	unsigned long flags;
1634
1635	spin_lock_irqsave(&pdc_lock, flags);
1636	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_INFO,
1637			__pa(&pdc_result));
1638	if (retval == PDC_OK)
1639		memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1640	spin_unlock_irqrestore(&pdc_lock, flags);
1641
1642	return retval;
1643}
1644
1645/**
1646 * pdc_pat_mem_pdt_cell_info - Retrieve information about page deallocation
1647 *				table of a cell
1648 * @rinfo: memory pdt information
1649 * @cell: cell number
1650 *
1651 */
1652int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
1653		unsigned long cell)
1654{
1655	int retval;
1656	unsigned long flags;
1657
1658	spin_lock_irqsave(&pdc_lock, flags);
1659	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_INFO,
1660			__pa(&pdc_result), cell);
1661	if (retval == PDC_OK)
1662		memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1663	spin_unlock_irqrestore(&pdc_lock, flags);
1664
1665	return retval;
1666}
1667
1668/**
1669 * pdc_pat_mem_read_cell_pdt - Read PDT entries from (old) PAT firmware
1670 * @pret: array of PDT entries
1671 * @pdt_entries_ptr: ptr to hold number of PDT entries
1672 * @max_entries: maximum number of entries to be read
1673 *
1674 */
1675int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1676		unsigned long *pdt_entries_ptr, unsigned long max_entries)
1677{
1678	int retval;
1679	unsigned long flags, entries;
1680
1681	spin_lock_irqsave(&pdc_lock, flags);
1682	/* PDC_PAT_MEM_CELL_READ is available on early PAT machines only */
1683	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_READ,
1684			__pa(&pdc_result), parisc_cell_num,
1685			__pa(pdt_entries_ptr));
1686
1687	if (retval == PDC_OK) {
1688		/* build up return value as for PDC_PAT_MEM_PD_READ */
1689		entries = min(pdc_result[0], max_entries);
1690		pret->pdt_entries = entries;
1691		pret->actual_count_bytes = entries * sizeof(unsigned long);
1692	}
1693
1694	spin_unlock_irqrestore(&pdc_lock, flags);
1695	WARN_ON(retval == PDC_OK && pdc_result[0] > max_entries);
1696
1697	return retval;
1698}
1699/**
1700 * pdc_pat_mem_read_pd_pdt - Read PDT entries from (newer) PAT firmware
1701 * @pret: array of PDT entries
1702 * @pdt_entries_ptr: ptr to hold number of PDT entries
1703 * @count: number of bytes to read
1704 * @offset: offset to start (in bytes)
1705 *
1706 */
1707int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1708		unsigned long *pdt_entries_ptr, unsigned long count,
1709		unsigned long offset)
1710{
1711	int retval;
1712	unsigned long flags, entries;
1713
1714	spin_lock_irqsave(&pdc_lock, flags);
1715	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_READ,
1716		__pa(&pdc_result), __pa(pdt_entries_ptr),
1717		count, offset);
1718
1719	if (retval == PDC_OK) {
1720		entries = min(pdc_result[0], count);
1721		pret->actual_count_bytes = entries;
1722		pret->pdt_entries = entries / sizeof(unsigned long);
1723	}
1724
1725	spin_unlock_irqrestore(&pdc_lock, flags);
1726
1727	return retval;
1728}
1729
1730/**
1731 * pdc_pat_mem_get_dimm_phys_location - Get physical DIMM slot via PAT firmware
1732 * @pret: ptr to hold returned information
1733 * @phys_addr: physical address to examine
1734 *
1735 */
1736int pdc_pat_mem_get_dimm_phys_location(
1737		struct pdc_pat_mem_phys_mem_location *pret,
1738		unsigned long phys_addr)
1739{
1740	int retval;
1741	unsigned long flags;
1742
1743	spin_lock_irqsave(&pdc_lock, flags);
1744	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_ADDRESS,
1745		__pa(&pdc_result), phys_addr);
1746
1747	if (retval == PDC_OK)
1748		memcpy(pret, &pdc_result, sizeof(*pret));
1749
1750	spin_unlock_irqrestore(&pdc_lock, flags);
1751
1752	return retval;
1753}
1754#endif /* CONFIG_64BIT */
1755#endif /* defined(BOOTLOADER) */
1756
1757
1758/***************** 32-bit real-mode calls ***********/
1759/* The struct below is used
1760 * to overlay real_stack (real2.S), preparing a 32-bit call frame.
1761 * real32_call_asm() then uses this stack in narrow real mode
1762 */
1763
1764struct narrow_stack {
1765	/* use int, not long which is 64 bits */
1766	unsigned int arg13;
1767	unsigned int arg12;
1768	unsigned int arg11;
1769	unsigned int arg10;
1770	unsigned int arg9;
1771	unsigned int arg8;
1772	unsigned int arg7;
1773	unsigned int arg6;
1774	unsigned int arg5;
1775	unsigned int arg4;
1776	unsigned int arg3;
1777	unsigned int arg2;
1778	unsigned int arg1;
1779	unsigned int arg0;
1780	unsigned int frame_marker[8];
1781	unsigned int sp;
1782	/* in reality, there's nearly 8k of stack after this */
1783};
1784
1785long real32_call(unsigned long fn, ...)
1786{
1787	va_list args;
1788	extern struct narrow_stack real_stack;
1789	extern unsigned long real32_call_asm(unsigned int *,
1790					     unsigned int *,
1791					     unsigned int);
1792
1793	va_start(args, fn);
1794	real_stack.arg0 = va_arg(args, unsigned int);
1795	real_stack.arg1 = va_arg(args, unsigned int);
1796	real_stack.arg2 = va_arg(args, unsigned int);
1797	real_stack.arg3 = va_arg(args, unsigned int);
1798	real_stack.arg4 = va_arg(args, unsigned int);
1799	real_stack.arg5 = va_arg(args, unsigned int);
1800	real_stack.arg6 = va_arg(args, unsigned int);
1801	real_stack.arg7 = va_arg(args, unsigned int);
1802	real_stack.arg8 = va_arg(args, unsigned int);
1803	real_stack.arg9 = va_arg(args, unsigned int);
1804	real_stack.arg10 = va_arg(args, unsigned int);
1805	real_stack.arg11 = va_arg(args, unsigned int);
1806	real_stack.arg12 = va_arg(args, unsigned int);
1807	real_stack.arg13 = va_arg(args, unsigned int);
1808	va_end(args);
1809
1810	return real32_call_asm(&real_stack.sp, &real_stack.arg0, fn);
1811}
1812
1813#ifdef CONFIG_64BIT
1814/***************** 64-bit real-mode calls ***********/
1815
1816struct wide_stack {
1817	unsigned long arg0;
1818	unsigned long arg1;
1819	unsigned long arg2;
1820	unsigned long arg3;
1821	unsigned long arg4;
1822	unsigned long arg5;
1823	unsigned long arg6;
1824	unsigned long arg7;
1825	unsigned long arg8;
1826	unsigned long arg9;
1827	unsigned long arg10;
1828	unsigned long arg11;
1829	unsigned long arg12;
1830	unsigned long arg13;
1831	unsigned long frame_marker[2];	/* rp, previous sp */
1832	unsigned long sp;
1833	/* in reality, there's nearly 8k of stack after this */
1834};
1835
1836long real64_call(unsigned long fn, ...)
1837{
1838	va_list args;
1839	extern struct wide_stack real64_stack;
1840	extern unsigned long real64_call_asm(unsigned long *,
1841					     unsigned long *,
1842					     unsigned long);
1843
1844	va_start(args, fn);
1845	real64_stack.arg0 = va_arg(args, unsigned long);
1846	real64_stack.arg1 = va_arg(args, unsigned long);
1847	real64_stack.arg2 = va_arg(args, unsigned long);
1848	real64_stack.arg3 = va_arg(args, unsigned long);
1849	real64_stack.arg4 = va_arg(args, unsigned long);
1850	real64_stack.arg5 = va_arg(args, unsigned long);
1851	real64_stack.arg6 = va_arg(args, unsigned long);
1852	real64_stack.arg7 = va_arg(args, unsigned long);
1853	real64_stack.arg8 = va_arg(args, unsigned long);
1854	real64_stack.arg9 = va_arg(args, unsigned long);
1855	real64_stack.arg10 = va_arg(args, unsigned long);
1856	real64_stack.arg11 = va_arg(args, unsigned long);
1857	real64_stack.arg12 = va_arg(args, unsigned long);
1858	real64_stack.arg13 = va_arg(args, unsigned long);
1859	va_end(args);
1860
1861	return real64_call_asm(&real64_stack.sp, &real64_stack.arg0, fn);
1862}
1863
1864#endif /* CONFIG_64BIT */
1865