arch/parisc/kernel/firmware.c

   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  */
 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  */
 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
 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  */
 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
 187 void set_firmware_width_unlocked(void)
 188 {
 189         return;
 190 }
 191
 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  */
 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  */
 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  */
 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  */
 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
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
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
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
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  */
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  */
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  */
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
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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
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
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 */