bootInit.c
上传用户:dqzhongke1
上传日期:2022-06-26
资源大小:667k
文件大小:20k
源码类别:

VxWorks

开发平台:

C/C++

  1. /* bootInit.c - ROM initialization module */
  2. /*
  3.  * Copyright (c) 1989-2005 Wind River Systems, Inc.
  4.  *
  5.  * The right to copy, distribute, modify or otherwise make use
  6.  * of this software may be licensed only pursuant to the terms
  7.  * of an applicable Wind River license agreement.
  8.  */
  9. /*
  10. modification history
  11. --------------------
  12. 04t,26jul05,rec  coldfire support
  13. 04s,06sep05,h_k  replaced compressedEntry with sysInit and usrEntry in a
  14.                  comment. (SPR #111954)
  15. 04r,19apr05,h_k  force to call fillLongs() resides in ROM for compressed
  16.                  image. (SPR #108169)
  17. 04q,24feb05,rec  ARM fillLongs should not be volatile - SPR 106411
  18. 04p,04oct04,mdo  Documentation fixes for apigen
  19. 04o,16sep04,j_b  correct RAM clearing (SPR 99727)
  20. 04n,18aug04,j_b  PM_RESERVED_MEM is dependent on INCLUDE_EDR_PM
  21. 04m,11may04,j_b  add support for PM_RESERVED_MEM
  22. 04l,26mar02,sbs  correcting data section relocation for ROM compressed images
  23.                  (SPR 73785)
  24. 04k,19mar02,dat  Removing previous fix for MIPS, no longer needed (72825)
  25. 04j,18jan02,dat  Don't use loop unrolling for MIPS
  26. 04i,22jan02,scm  Xscale specific validation added to update cache (to match
  27.                  updates...)
  28. 04h,19dec01,aeg  prevented pc-relative addressing on MC680X0.
  29. 04g,10dec01,sbs  Corrected conditions around call to copyLongs for ROM
  30.                  resident images.
  31. 04f,27nov01,sbs  Added new labels, wrs_kernel_data_start and wrs_kernel_data_end
  32.                  for sdata and edata respectively. Added second copy for data
  33.                  section of compressed ROM images. Corrected definition for
  34.                  binArrayEnd. Corrected definition for RESIDENT_DATA.
  35. 04e,27nov01,tpw  Manually unroll copyLongs and fillLongs.
  36. 04d,25oct01,pad  Removed definitions of _binArrayStart and _binArrayEnd, now
  37.                  unnecessary.
  38. 04c,03oct01,dee  Merge from ColdFire T2.1.0 release
  39. 04b,11jan01,scm  Xscale specific validation added to update cache, can not assume uncached area....
  40. 04a,10jun99,jpd  fix error when BOOTCODE_IN_RAM defined (SPR #27775).
  41. 03z,13nov98,cdp  make Thumb support for ARM CPUs dependent on ARM_THUMB.
  42. 03y,10feb99,db   Fix to ensure that default bootline gets copied for
  43.                  standalone and rom-resident images(SPR #21763).
  44. 03x,05oct98,jmp  doc: cleanup.
  45. 03w,17apr98,cdp  backed out 04t and made absEntry volatile for ARM.
  46. 03v,16apr98,cdp  for ARM, make UNCOMPRESS entry point in RAM.
  47. 03u,20mar98,cdp  make ROM_COPY_SIZE subject to #ifndef.
  48. 03t,11nov97,cdp  ARM7TDMI_T: force romStart to call entry point in Thumb state.
  49.                  (SPR# 9716)
  50. 03s,14jul97,tam  changed remaining references to bfillLong to fillLong.
  51. 03r,12feb97,dat  Added USER_RESERVED_MEM, SYS_MEM_TOP, SYS_MEM_BOTTOM, SPR 8030
  52. 03q,04feb97,ms   fixed compiler warning about protoype for bcopyLongs.
  53. 03p,28nov96,cdp  added ARM support.
  54. 03o,03sep96,hdn  added the compression support for pc[34]86 BSP.
  55. 03n,19aug96,ms   added UNCMP_RTN macro to use inflate instead of uncompress
  56. 03m,21jun96,jmb  long modhist -- deleted entries prior to 1994.  SPR #6528
  57. 03l,10jun96,tam  added rom resident support for PPC architecture.
  58. 03k,14may96,dat  fixed compiler warnings for copyLongs, fillLongs. SPR #6536
  59. 03j,06mar96,tpr  changed absEntry to be volatile for PowerPC.
  60. 03i,22aug95,hdn  added support for I80X86.
  61. 03h,14mar95,caf  restored mips resident rom support (SPR #3856).
  62. 03g,16feb95,jdi  doc format change.
  63. 03f,23may95,yao  define binArrayStart and binArrayEnd for PowerPC
  64.                  because tools don't prepend "_".
  65. 03e,09dec94,caf  undid mod 03a, use sdata for resident roms (SPR #3856).
  66. 03d,22jun94,caf  undid 16-byte alignment portion of mod 03c, below.
  67. 03c,14jun94,cd   corrected definitions of etext, edata and end.
  68.            +caf  for R4000 resident ROMs: data starts on 16-byte boundary.
  69.                  for R4000 uncompressed ROMs: added volatile to absEntry type.
  70. */
  71. /*
  72. DESCRIPTION
  73. This module provides a generic boot ROM facility.  The target-specific
  74. romInit.s module performs the minimal preliminary board initialization and
  75. then jumps to the C routine romStart().  This routine, still executing out
  76. of ROM, copies the first stage of the startup code to a RAM address and
  77. jumps to it.  The next stage clears memory and then uncompresses the
  78. remainder of ROM into the final VxWorks ROM image in RAM.
  79. A modified version of the Public Domain f3zlibfP library is used to
  80. uncompress the VxWorks boot ROM executable linked with it.  Compressing
  81. object code typically achieves over 55% compression, permitting much
  82. larger systems to be burned into ROM.  The only expense is the added few
  83. seconds delay while the first two stages complete.
  84. ROM AND RAM MEMORY LAYOUT
  85. Example memory layout for a 1-megabyte board:
  86. cs
  87.     --------------  0x00100000 = LOCAL_MEM_SIZE = sysMemTop()
  88.     |            |
  89.     |    RAM     |
  90.     |  0 filled  |
  91.     |            |
  92.     |------------| = (romInit+ROM_COPY_SIZE) or binArrayStart
  93.     | ROM image  |
  94.     |----------- |  0x00090000  = RAM_HIGH_ADRS
  95.     | STACK_SAVE |
  96.     |------------|
  97.     |            |  0x00080000  = 0.5 Megabytes
  98.     |            |
  99.     |            |
  100.     | 0 filled   |
  101.     |            |
  102.     |            |  0x00001000  = RAM_ADRS & RAM_LOW_ADRS
  103.     |            |
  104.     |            |  exc vectors, bp anchor, exc msg, bootline
  105.     |            |
  106.     |            |
  107.     --------------  0x00000000  = LOCAL_MEM_LOCAL_ADRS
  108. ce
  109. cs
  110.     --------------
  111.     |    ROM     |
  112.     |            |  0xff8xxxxx  = binArrayStart
  113.     |            |
  114.     |            |  0xff800008  = ROM_TEXT_ADRS
  115.     --------------  0xff800000  = ROM_BASE_ADRS
  116. ce
  117. SEE ALSO:
  118. inflate(), romInit(), and deflate
  119. AUTHOR
  120. The original compression software for zlib was written by Jean-loup Gailly
  121. and Mark Adler. See the manual pages of inflate and deflate for
  122. more information on their freely available compression software.
  123. */
  124. #include "vxWorks.h"
  125. #include "sysLib.h"
  126. #include "config.h"
  127. #include "errno.h"
  128. #include "sioLib.h"
  129. #define UNCMP_RTN   inflate
  130. #ifndef USER_RESERVED_MEM
  131. #   define USER_RESERVED_MEM 0
  132. #endif
  133. /*
  134.  * If memory is to be cleared, it will be cleared from SYS_MEM_BOTTOM
  135.  * up to (but not including) SYS_MEM_TOP, except for text and data segments.
  136.  * The user reserved area is not cleared.
  137.  */
  138. #ifdef  INCLUDE_EDR_PM
  139. #    define SYS_MEM_TOP 
  140.         (LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE - USER_RESERVED_MEM 
  141.          - PM_RESERVED_MEM)
  142. #else
  143. #    define SYS_MEM_TOP 
  144.         (LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE - USER_RESERVED_MEM)
  145. #endif
  146. #define SYS_MEM_BOTTOM 
  147.     (LOCAL_MEM_LOCAL_ADRS + RESERVED)
  148. #define BINARRAYEND_ROUNDOFF    (ROUND_DOWN(binArrayEnd, sizeof(long)))
  149. IMPORT void romInit ();
  150. IMPORT STATUS   UNCMP_RTN ();
  151. IMPORT void usrInit ();
  152. IMPORT void sysInitAlt ();
  153. IMPORT void start ();
  154. IMPORT UCHAR    binArrayStart [];   /* compressed binary image */
  155. IMPORT UCHAR    binArrayEnd [];     /* end of compressed binary image */
  156. IMPORT char etext [];       /* defined by the loader */
  157. IMPORT char end [];         /* defined by the loader */
  158. IMPORT UCHAR    wrs_kernel_data_start [];  /* defined by the loader */
  159. IMPORT UCHAR    wrs_kernel_data_end [];    /* defined by the loader */
  160. #if ((CPU_FAMILY == MIPS) || (CPU_FAMILY==PPC) || 
  161.      (CPU_FAMILY==COLDFIRE))
  162. #  define RESIDENT_DATA   RAM_DST_ADRS
  163. #else
  164. #  define RESIDENT_DATA   wrs_kernel_data_start
  165. #endif
  166. #ifndef RAM_DST_ADRS                    /* default uncompress dest. */
  167. #  define RAM_DST_ADRS        RAM_HIGH_ADRS
  168. #endif
  169. /* If the boot code is in RAM and the RAM is already initialized,
  170.  * clearing the RAM is not necessary.  Macro BOOTCODE_IN_RAM is
  171.  * used not to clear the RAM.
  172.  */
  173. #ifdef  BOOTCODE_IN_RAM         /* not to clear RAM */
  174. #  undef  ROM_TEXT_ADRS
  175. #  undef  ROM_BASE_ADRS
  176. #  define ROM_TEXT_ADRS   ((UINT)romInit)
  177. #  define ROM_BASE_ADRS   ((UINT)romInit)
  178. #endif  /* BOOTCODE_IN_RAM */
  179. /* #if  defined (UNCOMPRESS) */
  180. #ifndef ROM_COPY_SIZE
  181. #  define ROM_COPY_SIZE   ((UINT)end - (UINT)romInit)
  182. #endif
  183. /* #endif*/ /* UNCOMPRESS */
  184. #define ROM_OFFSET(adr) (((UINT)adr - (UINT)romInit) + ROM_TEXT_ADRS)
  185. #if !defined (UNCOMPRESS) && !defined (ROM_RESIDENT)
  186. # define LD_IMAGE_END  ((UINT)RAM_DST_ADRS + 
  187.                (UINT)(ROUND_UP(binArrayEnd - binArrayStart, sizeof(long))))
  188. #endif /* !defined (UNCOMPRESS) && !defined (ROM_RESIDENT) */
  189. /* forward declarations */
  190. LOCAL void copyLongs (FAST UINT *source, FAST UINT *destination, UINT nlongs);
  191. #ifndef BOOTCODE_IN_RAM
  192. LOCAL void fillLongs (FAST UINT *buf, UINT nlongs, FAST UINT val);
  193. #endif  /* BOOTCODE_IN_RAM */
  194. #if (CPU==XSCALE)
  195. int checkLongs (FAST UINT *source, FAST UINT *destination, UINT nlongs);
  196. #endif
  197. /*******************************************************************************
  198. *
  199. * romStart - generic ROM initialization
  200. *
  201. * This is the first C code executed after reset.
  202. *
  203. * This routine is called by the assembly start-up code in romInit().
  204. * It clears memory, copies ROM to RAM, and possibly invokes the uncompressor.
  205. * It then jumps to the entry point of the uncompressed object code.
  206. *
  207. * RETURNS: N/A
  208. *
  209. * ERRNO
  210. */
  211. void romStart
  212.     (
  213.     FAST int startType      /* start type */
  214.     )
  215.     {
  216. #if ((CPU_FAMILY==SPARC) || (CPU_FAMILY==MIPS) || (CPU_FAMILY==I80X86) || 
  217.      (CPU_FAMILY==PPC) || (CPU_FAMILY==ARM) || (CPU_FAMILY==COLDFIRE))
  218.     volatile            /* to force absolute addressing */
  219. #endif /* (CPU_FAMILY==SPARC) */
  220.     FUNCPTR absEntry;       /* to avoid PC Relative Jump Subroutine */
  221. #if (CPU_FAMILY==MC680X0) && !defined(ROM_RESIDENT) && !defined(BOOTCODE_IN_RAM)
  222.     volatile VOIDFUNCPTR romcopyLongs = &copyLongs;  /* force call to ROM */
  223. # define copyLongs romcopyLongs
  224. #endif /* (CPU_FAMILY==MC680X0) */
  225.     /*
  226.      * Copy from ROM to RAM, minus the compressed image
  227.      * if compressed boot ROM which relies on binArray
  228.      * appearing last in DATA segment.
  229.      */
  230. #ifdef ROM_RESIDENT
  231.     /* If ROM resident code, then copy only data segment
  232.      * from ROM to RAM, initialize memory and jump
  233.      * to usrInit.
  234.      */
  235. # if  (CPU_FAMILY == SPARC)
  236.     copyLongs ((UINT *)(etext + 8), (UINT *) RESIDENT_DATA,
  237. # else
  238.     copyLongs ((UINT *)etext, (UINT *) RESIDENT_DATA,
  239. # endif
  240.         ((UINT) wrs_kernel_data_end - (UINT) RESIDENT_DATA) / sizeof (long));
  241. #else   /* ROM_RESIDENT */
  242. # ifdef UNCOMPRESS
  243. #  if (CPU_FAMILY == MIPS)
  244.     /*
  245.      * copy text to uncached locations to avoid problems with
  246.      * copy back caches
  247.      */
  248.     ((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)K0_TO_K1(romInit),
  249.         ROM_COPY_SIZE / sizeof (long));
  250. #  else   /* CPU_FAMILY == MIPS */
  251.     ((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)romInit,
  252.         ROM_COPY_SIZE / sizeof (long));
  253. #  endif  /* CPU_FAMILY == MIPS */
  254. # else   /* UNCOMPRESS */
  255. #  if (CPU_FAMILY == MIPS)
  256.     /*
  257.      * copy text to uncached locations to avoid problems with
  258.      * copy back caches
  259.      * copy the entire data segment because there is no way to ensure that
  260.      * binArray is the last thing in the data segment because of GP relative
  261.      * addressing
  262.      */
  263.     ((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)K0_TO_K1(romInit),
  264.         ((UINT)wrs_kernel_data_end - (UINT)romInit) / sizeof (long));
  265. #  else   /* CPU_FAMILY == MIPS */
  266.     ((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)romInit,
  267.         ((UINT)binArrayStart - (UINT)romInit)/ sizeof (long));
  268.     ((FUNCPTR)ROM_OFFSET(copyLongs))
  269.            ((UINT *)((UINT)ROM_TEXT_ADRS + ((UINT)BINARRAYEND_ROUNDOFF -
  270.            (UINT)romInit)), (UINT *)BINARRAYEND_ROUNDOFF,
  271.            ((UINT)wrs_kernel_data_end - (UINT)binArrayEnd) / sizeof (long));
  272. #   if (CPU==XSCALE)
  273.     /* validate coherence, can not assume uncached area... */
  274.     ((FUNCPTR)ROM_OFFSET(checkLongs))
  275.                  (ROM_TEXT_ADRS, (UINT)romInit,
  276.                  ((UINT)binArrayStart - (UINT)romInit) / sizeof (long));
  277.     ((FUNCPTR)ROM_OFFSET(checkLongs))
  278.            ((UINT *)((UINT)ROM_TEXT_ADRS + ((UINT)BINARRAYEND_ROUNDOFF -
  279.             (UINT)romInit)), (UINT *)BINARRAYEND_ROUNDOFF,
  280.             ((UINT)wrs_kernel_data_end - (UINT)binArrayEnd) / sizeof (long));
  281. #   endif /* CPU==XSCALE */
  282. #  endif  /* CPU_FAMILY == MIPS */
  283. # endif  /* UNCOMPRESS */
  284. #endif  /* ROM_RESIDENT */
  285. #if (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM))
  286.     /* clear all memory if cold booting */
  287.     if (startType & BOOT_CLEAR)
  288.     {
  289. # ifdef ROM_RESIDENT
  290.     /* Clear memory not loaded with text & data.
  291.      *
  292.      * We are careful about initializing all memory (except
  293.      * STACK_SAVE bytes) due to parity error generation (on
  294.      * some hardware) at a later stage.  This is usually
  295.      * caused by read accesses without initialization.
  296.      */
  297.     /* clear from the bottom of memory to the stack */
  298.     fillLongs ((UINT *)SYS_MEM_BOTTOM,
  299.         ((UINT) RESIDENT_DATA - STACK_SAVE - (UINT)SYS_MEM_BOTTOM) /
  300.         sizeof(long), 0);
  301.     /* fill from the load image to the top of memory */
  302.     fillLongs ((UINT *)end, ((UINT)SYS_MEM_TOP - (UINT)end) / sizeof (long), 0);
  303. # else   /* ROM_RESIDENT */
  304. #  if defined (UNCOMPRESS)
  305.     /* clear from the bottom of memory to the stack */
  306.     fillLongs ((UINT *)(SYS_MEM_BOTTOM),
  307.         ((UINT)romInit - STACK_SAVE - (UINT)SYS_MEM_BOTTOM) /
  308.         sizeof(long), 0);
  309.     /* fill from the load image to the top of memory */
  310.     fillLongs ((UINT *)end, ((UINT)SYS_MEM_TOP - (UINT)end) / sizeof (long), 0);
  311. #  else  /* UNCOMPRESS */
  312. #   if (RAM_DST_ADRS == RAM_HIGH_ADRS)
  313.         /* clear from the bottom of memory to the stack */
  314.         fillLongs ((UINT *)(SYS_MEM_BOTTOM),
  315.             ((UINT)romInit - STACK_SAVE - (UINT)SYS_MEM_BOTTOM) /
  316.             sizeof(long), 0);
  317.         /*
  318.         * fill from the end of the load image to the top of memory
  319.         * (end of decompressed image isn't known, so the end of the
  320.         *  compressed image is used -- should still be more efficient than
  321.         *  clearing from RAM_DST_ADRS all the way to the top of memory)
  322.         */
  323.         fillLongs ((UINT *)LD_IMAGE_END,
  324.             ((UINT)SYS_MEM_TOP - LD_IMAGE_END) / sizeof (long), 0);
  325. #   else  /* RAM_DST_ADRS == RAM_HIGH_ADRS */
  326.         /* fill from the bottom of memory to the load image */
  327.         fillLongs ((UINT *)(SYS_MEM_BOTTOM),
  328.         ((UINT)RAM_DST_ADRS - (UINT)SYS_MEM_BOTTOM) / sizeof (long), 0);
  329.         /*
  330.         * fill from the end of the load image to the stack
  331.         * (end of decompressed image isn't known, so the end of the
  332.         *  compressed image is used -- should still be more efficient than
  333.         *  clearing from bottom of memory all the way to the stack)
  334.         */
  335.         fillLongs ((UINT *)LD_IMAGE_END,
  336.             ((UINT)romInit - STACK_SAVE - LD_IMAGE_END) /
  337.             sizeof (long), 0);
  338. #   endif  /* RAM_DST_ADRS == RAM_HIGH_ADRS */
  339. #  endif  /* UNCOMPRESS */
  340. # endif  /* ROM_RESIDENT */
  341.     /*
  342.      * Ensure the boot line is null. This is necessary for those
  343.      * targets whose boot line is excluded from cleaning.
  344.      */
  345.     *(BOOT_LINE_ADRS) = EOS;
  346.     }
  347. #endif  /* (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM)) */
  348.     /* jump to VxWorks entry point (after uncompressing) */
  349. #if defined (UNCOMPRESS) || defined (ROM_RESIDENT)
  350. # if (CPU_FAMILY == I960)
  351.     absEntry = (FUNCPTR)sysInitAlt;         /* reinit proc tbl */
  352. # else
  353.     absEntry = (FUNCPTR)usrInit;            /* on to bootConfig */
  354. # endif  /* CPU_FAMILY == I960 */
  355. #else   /* defined UNCOMPRESS || defined ROM_RESIDENT */
  356.     {
  357. # if (CPU_FAMILY == MIPS)
  358.     volatile FUNCPTR absUncompress = (FUNCPTR) UNCMP_RTN;
  359.     if ((absUncompress) ((UCHAR *)ROM_OFFSET(binArrayStart),
  360.              (UCHAR *)K0_TO_K1(RAM_DST_ADRS),
  361.              (int)((UINT)binArrayEnd - (UINT)binArrayStart)) != OK)
  362. # elif   (CPU_FAMILY == I80X86) || (CPU_FAMILY == ARM) || (CPU_FAMILY == COLDFIRE)
  363.     volatile FUNCPTR absUncompress = (FUNCPTR) UNCMP_RTN;
  364.     if ((absUncompress) ((UCHAR *)ROM_OFFSET(binArrayStart),
  365.                 (UCHAR *)RAM_DST_ADRS, binArrayEnd - binArrayStart) != OK)
  366. # else
  367.     if (UNCMP_RTN ((UCHAR *)ROM_OFFSET(binArrayStart),
  368.                 (UCHAR *)RAM_DST_ADRS, binArrayEnd - binArrayStart) != OK)
  369. # endif  /* (CPU_FAMILY == MIPS) */
  370.     return;     /* if we return then ROM's will halt */
  371.     absEntry = (FUNCPTR)RAM_DST_ADRS;           /* sysInit() or usrEntry() */
  372. # if (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM))
  373.     /* if cold booting, finish clearing memory */
  374.     if (startType & BOOT_CLEAR)
  375.         {
  376. #  if (RAM_DST_ADRS == RAM_HIGH_ADRS)
  377.         /* clear past the stack to the decompressed image */
  378.         ((FUNCPTR)ROM_OFFSET(fillLongs)) ((UINT *)romInit,
  379.             ((UINT)RAM_DST_ADRS - (UINT)romInit) / sizeof(long), 0);
  380. #  else
  381.         /* clear past the stack to the top of memory */
  382.         ((FUNCPTR)ROM_OFFSET(fillLongs)) ((UINT *)romInit,
  383.             ((UINT)SYS_MEM_TOP - (UINT)romInit) / sizeof(long), 0);
  384. #  endif /* RAM_DST_ADRS == RAM_HIGH_ADRS */
  385.         }
  386. # endif  /* (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM)) */
  387.     }
  388. #endif  /* defined UNCOMPRESS || defined ROM_RESIDENT */
  389. #if ((CPU_FAMILY == ARM) && ARM_THUMB)
  390.     absEntry = (FUNCPTR)((UINT32)absEntry | 1);     /* force Thumb state */
  391. #endif  /* CPU_FAMILY == ARM */
  392.     (absEntry) (startType);
  393.     }
  394. #if     (CPU_FAMILY==ARM) && (!defined(ROM_RESIDENT))
  395. # undef fillLongs
  396. #endif  /* (CPU_FAMILY==ARM) */
  397. #if (CPU_FAMILY==MC680X0) && !defined(ROM_RESIDENT) && !defined(BOOTCODE_IN_RAM)
  398. # undef copyLongs    /* undo effects from above define */
  399. #endif /* CPU_FAMILY==MC680X0 */
  400. /*******************************************************************************
  401. *
  402. * copyLongs - copy one buffer to another a long at a time
  403. *
  404. * This routine copies the first <nlongs> longs from <source> to <destination>.
  405. *
  406. * RETURNS:
  407. *
  408. * ERRNO
  409. */
  410. LOCAL void copyLongs 
  411.     (
  412.     source,
  413.     destination,
  414.     nlongs
  415.     )
  416.     FAST UINT *source;      /* pointer to source buffer      */
  417.     FAST UINT *destination; /* pointer to destination buffer */
  418.     UINT nlongs;        /* number of longs to copy       */
  419.     {
  420.     FAST UINT *dstend = destination + nlongs;
  421.     FAST UINT nchunks;
  422.     /* Hop by chunks of longs, for speed. */
  423.     for (nchunks = nlongs / 8; nchunks; --nchunks)
  424.         {
  425. #if (CPU_FAMILY == MC680X0)
  426.         *destination++ = *source++; /* 0 */
  427.         *destination++ = *source++; /* 1 */
  428.         *destination++ = *source++; /* 2 */
  429.         *destination++ = *source++; /* 3 */
  430.         *destination++ = *source++; /* 4 */
  431.         *destination++ = *source++; /* 5 */
  432.         *destination++ = *source++; /* 6 */
  433.         *destination++ = *source++; /* 7 */
  434. #else
  435.         destination[0] = source[0];
  436.         destination[1] = source[1];
  437.         destination[2] = source[2];
  438.         destination[3] = source[3];
  439.         destination[4] = source[4];
  440.         destination[5] = source[5];
  441.         destination[6] = source[6];
  442.         destination[7] = source[7];
  443.         destination += 8, source += 8;
  444. #endif /* CPU_FAMILY == MC680X0 */
  445.         }
  446.     /* Do the remainder one long at a time. */
  447.     while (destination < dstend)
  448.         *destination++ = *source++;
  449.     }
  450. #ifndef BOOTCODE_IN_RAM
  451. /*******************************************************************************
  452. *
  453. * fillLongs - fill a buffer with a value a long at a time
  454. *
  455. * This routine fills the first <nlongs> longs of the buffer with <val>.
  456. *
  457. * RETURNS:
  458. *
  459. * ERRNO
  460. */
  461. LOCAL void fillLongs 
  462.     (
  463.     buf,
  464.     nlongs,
  465.     val
  466.     )
  467.     FAST UINT *buf; /* pointer to buffer              */
  468.     UINT nlongs;    /* number of longs to fill        */
  469.     FAST UINT val;  /* char with which to fill buffer */
  470.     {
  471.     FAST UINT *bufend = buf + nlongs;
  472.     FAST UINT nchunks;
  473.     /* Hop by chunks of longs, for speed. */
  474.     for (nchunks = nlongs / 8; nchunks; --nchunks)
  475.         {
  476. #if (CPU_FAMILY == MC680X0)
  477.         *buf++ = val;   /* 0 */
  478.         *buf++ = val;   /* 1 */
  479.         *buf++ = val;   /* 2 */
  480.         *buf++ = val;   /* 3 */
  481.         *buf++ = val;   /* 4 */
  482.         *buf++ = val;   /* 5 */
  483.         *buf++ = val;   /* 6 */
  484.         *buf++ = val;   /* 7 */
  485. #else
  486.         buf[0] = val;
  487.         buf[1] = val;
  488.         buf[2] = val;
  489.         buf[3] = val;
  490.         buf[4] = val;
  491.         buf[5] = val;
  492.         buf[6] = val;
  493.         buf[7] = val;
  494.         buf += 8;
  495. #endif /* CPU_FAMILY == MC680X0 */
  496.         }
  497.     /* Do the remainder one long at a time. */
  498.     while (buf < bufend)
  499.         *buf++ = val;
  500.     }
  501. #endif  /* BOOTCODE_IN_RAM */
  502. #if (CPU==XSCALE)
  503. int checkLongs (source, destination, nlongs)
  504. FAST UINT *source;          /* pointer to source buffer      */
  505. FAST UINT *destination;     /* pointer to destination buffer */
  506. UINT nlongs;                /* number of longs to copy       */
  507.     {
  508.     int fine = 1;
  509.     FAST UINT *dstend = destination + nlongs;
  510.     while (destination < dstend)
  511.         {
  512.         if (*destination++ != *source++)
  513.             {
  514.             fine = 0;
  515.             break;
  516.             }
  517.         }
  518.     return fine;
  519.     }
  520. #endif