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
74 static DEFINE_SPINLOCK(pdc_lock);
75 #endif
76 
77 extern unsigned long pdc_result[NUM_PDC_RESULT];
78 extern 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. */
86 int 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
101 long real64_call(unsigned long function, ...);
102 #endif
103 long 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  */
f_extend(unsigned long address)121 static 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  */
convert_to_wide(unsigned long * addr)143 static 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
set_firmware_width_unlocked(void)157 void 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  */
set_firmware_width(void)174 void 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
set_firmware_width_unlocked(void)187 void set_firmware_width_unlocked(void)
188 {
189 	return;
190 }
191 
set_firmware_width(void)192 void 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  */
pdc_emergency_unlock(void)206 void 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  */
pdc_add_valid(unsigned long address)223 int 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 }
234 EXPORT_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  */
pdc_instr(unsigned int * instr)242 int __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  */
pdc_chassis_info(struct pdc_chassis_info * chassis_info,void * led_info,unsigned long len)264 int __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
pdc_pat_chassis_send_log(unsigned long state,unsigned long data)288 int 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  */
pdc_chassis_disp(unsigned long disp)308 int 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  */
__pdc_cpu_rendezvous(void)324 int __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  */
pdc_cpu_rendezvous_lock(void)335 void 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  */
pdc_cpu_rendezvous_unlock(void)343 void 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  */
pdc_pat_get_PDC_entrypoint(unsigned long * pdc_entry)352 int 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  */
pdc_chassis_warn(unsigned long * warn)374 int 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 
pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg * pdc_coproc_info)387 int 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  */
pdc_coproc_cfg(struct pdc_coproc_cfg * pdc_coproc_info)408 int 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  */
pdc_iodc_read(unsigned long * actcnt,unsigned long hpa,unsigned int index,void * iodc_data,unsigned int iodc_data_size)431 int 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 }
447 EXPORT_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  */
pdc_system_map_find_mods(struct pdc_system_map_mod_info * pdc_mod_info,struct pdc_module_path * mod_path,long mod_index)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)
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  */
pdc_system_map_find_addrs(struct pdc_system_map_addr_info * pdc_addr_info,long mod_index,long addr_index)485 int 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  */
pdc_model_info(struct pdc_model * model)508 int 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  */
pdc_model_sysmodel(char * name)530 int 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  */
pdc_model_versions(unsigned long * versions,int id)560 int 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  */
pdc_model_cpuid(unsigned long * cpu_id)581 int 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  */
pdc_model_capabilities(unsigned long * capabilities)603 int 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  */
pdc_model_platform_info(char * orig_prod_num,char * current_prod_num,char * serial_no)631 int 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  */
pdc_cache_info(struct pdc_cache_info * cache_info)652 int 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  */
pdc_spaceid_bits(unsigned long * space_bits)672 int 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  */
pdc_btlb_info(struct pdc_btlb_info * btlb)694 int 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  */
pdc_mem_map_hpa(struct pdc_memory_map * address,struct pdc_module_path * mod_path)722 int 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  */
pdc_lan_station_id(char * lan_addr,unsigned long hpa)746 int 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 }
764 EXPORT_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  */
pdc_stable_read(unsigned long staddr,void * memaddr,unsigned long count)776 int 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 }
790 EXPORT_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  */
pdc_stable_write(unsigned long staddr,void * memaddr,unsigned long count)802 int 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 }
816 EXPORT_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  */
pdc_stable_get_size(unsigned long * size)827 int 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 }
839 EXPORT_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  */
pdc_stable_verify_contents(void)847 int 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 }
858 EXPORT_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  */
pdc_stable_initialize(void)866 int 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 }
877 EXPORT_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  */
pdc_get_initiator(struct hardware_path * hwpath,struct pdc_initiator * initiator)893 int 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 }
942 EXPORT_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  */
pdc_pci_irt_size(unsigned long * num_entries,unsigned long hpa)954 int 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  */
pdc_pci_irt(unsigned long num_entries,unsigned long hpa,void * tbl)978 int 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  */
1004 unsigned 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  */
1028 void 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  */
pdc_tod_read(struct pdc_tod * tod)1050 int 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 }
1063 EXPORT_SYMBOL(pdc_tod_read);
1064 
pdc_mem_pdt_info(struct pdc_mem_retinfo * rinfo)1065 int 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 
pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt * pret,unsigned long * pdt_entries_ptr)1079 int 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  */
pdc_pim_toc11(struct pdc_toc_pim_11 * ret)1110 int 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  */
pdc_pim_toc20(struct pdc_toc_pim_20 * ret)1126 int 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  */
pdc_tod_set(unsigned long sec,unsigned long usec)1145 int 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 }
1156 EXPORT_SYMBOL(pdc_tod_set);
1157 
1158 #ifdef CONFIG_64BIT
pdc_mem_mem_table(struct pdc_memory_table_raddr * r_addr,struct pdc_memory_table * tbl,unsigned long entries)1159 int 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  */
pdc_do_firm_test_reset(unsigned long ftc_bitmap)1180 int 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  */
pdc_do_reset(void)1198 int 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  */
pdc_soft_power_info(unsigned long * power_reg)1216 int __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  */
pdc_soft_power_button(int sw_control)1245 int 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  */
pdc_io_reset(void)1262 void 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  */
pdc_io_reset_devices(void)1280 void 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 */
1292 static int __attribute__((aligned(8)))   iodc_retbuf[32];
1293 static 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  */
pdc_iodc_print(const unsigned char * str,unsigned count)1305 int 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 
1324 print:
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  */
pdc_iodc_getc(void)1342 int 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 
pdc_sti_call(unsigned long func,unsigned long flags,unsigned long inptr,unsigned long outputr,unsigned long glob_cfg)1369 int 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 }
1382 EXPORT_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  */
pdc_pat_cell_get_number(struct pdc_pat_cell_num * cell_info)1392 int 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  */
pdc_pat_cell_module(unsigned long * actcnt,unsigned long ploc,unsigned long mod,unsigned long view_type,void * mem_addr)1416 int 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  */
pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block * info,unsigned long * actcnt,unsigned long offset,unsigned long cell_number)1444 int 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  */
pdc_pat_cpu_get_number(struct pdc_pat_cpu_num * cpu_info,unsigned long hpa)1472 int 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  */
pdc_pat_get_irt_size(unsigned long * num_entries,unsigned long cell_num)1494 int 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  */
pdc_pat_get_irt(void * r_addr,unsigned long cell_num)1515 int 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  */
pdc_pat_pd_get_addr_map(unsigned long * actual_len,void * mem_addr,unsigned long count,unsigned long offset)1536 int 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  */
pdc_pat_pd_get_pdc_revisions(unsigned long * legacy_rev,unsigned long * pat_rev,unsigned long * pdc_cap)1559 int 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  */
pdc_pat_io_pci_cfg_read(unsigned long pci_addr,int pci_size,u32 * mem_addr)1586 int 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  */
pdc_pat_io_pci_cfg_write(unsigned long pci_addr,int pci_size,u32 val)1612 int 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  */
pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo * rinfo)1630 int 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  */
pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo * rinfo,unsigned long cell)1652 int 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  */
pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo * pret,unsigned long * pdt_entries_ptr,unsigned long max_entries)1675 int 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  */
pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo * pret,unsigned long * pdt_entries_ptr,unsigned long count,unsigned long offset)1707 int 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  */
pdc_pat_mem_get_dimm_phys_location(struct pdc_pat_mem_phys_mem_location * pret,unsigned long phys_addr)1736 int 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 
1764 struct 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 
real32_call(unsigned long fn,...)1785 long 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 
1816 struct 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 
real64_call(unsigned long fn,...)1836 long 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