/*****************************************************************************/ /* C6X.H v8.2.2 */ /* */ /* Copyright (c) 1996-2017 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ #include "vect.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /*****************************************************************************/ /* */ /* NOTICE TO THOSE WHO USE INTRINSICS AND PACKED DATA */ /* */ /* This note contains information on a new __float2_t type. */ /* It also contains recommendations on the use of the "double" type. */ /* */ /* In order to better support packed data compiler optimizations in the */ /* future, the use of the type "double" for packed data is now discouraged */ /* and its support may be discontinued in the future. */ /* */ /* There are several recommendations and changes as a result. Note that */ /* these changes do NOT break compatibility with older code (source files */ /* or object files). */ /* */ /* (1) long long should be used for 64-bit packed integer data. The double */ /* type should be used only for double-precision floating point values. */ /* */ /* (2) There is a new type, __float2_t, that holds two floats and should */ /* be used instead of double for holding two floats. For now, this new */ /* type is typedef'ed to double in c6x.h, but could be changed in the */ /* future to a structure or vector type to allow better optimization of */ /* packed data floats. We recommend the use of __float2_t for any */ /* float x2 data instead of double. */ /* */ /* (3) There are new __float2_t manipulation intrinsics (see below) that */ /* should be used to create and manipulate objects of type __float2_t. */ /* */ /* (4) C66 intrinsics that deal with packed float data are now declared */ /* using __float2_t instead of double. (Those intrinsics are declared */ /* in this file, c6x.h.) */ /* */ /* (5) When using any intrinsic that involves __float2_t, c6x.h must be */ /* included. */ /* */ /* (6) Certain intrinsics that used double to store fixed-point packed */ /* data have been deprecated. They will still be supported in the */ /* near future, but their descriptions will be removed from the */ /* compiler user's guide (spru187). Deprecated: _mpy2, _mpyhi, _mpyli, */ /* _mpysu4, _mpyu4, and _smpy2. Use the long long versions instead. */ /* */ /* Please see */ /* http://processors.wiki.ti.com/index.php/C6000_Intrinsics_and_Type_Double */ /* and the C6000 Compiler User's Guide (v7.2), spru187, for more */ /* information. */ /* */ /*****************************************************************************/ /* If not using host intrinsics, define __float2_t items. */ #ifndef __FLOAT2_DEFINES__ #define __FLOAT2_DEFINES__ typedef double __float2_t; /*-------------------------------------------------------------------------*/ /* __float2_t manipulation intrinsics */ /* */ /* Since __float2_t is just a typedef to double at this time, we simply */ /* use #defines to "create" the __float2_t manipulation intrinsics. The */ /* __float2_t intrinsics are listed in this comment for convenience. */ /* */ /* __float2_t _lltof2(long long) Reinterpret long long as __float2_t */ /* long long _f2toll(__float2_t) Reinterpret __float2_t as long long */ /* __float2_t _ftof2(float, float) Create a __float2_t from 2 floats */ /* float _hif2(__float2_t) Return the hi 32 bits of a __float2_t */ /* float _lof2(__float2_t) Return the lo 32 bits of a __float2_t */ /* __int40_t _f2tol(__float2_t) Reinterpret __float2_t as 40-bit type */ /* __float2_t _ltof2(__int40_t) Reinterpret 40-bit type as __float2_t */ /* */ /* __float2_t & _amem8_f2(void *) | */ /* __float2_t & _amem8_f2_const(void *) | Allows (un)aligned loads and */ /* __float2_t & _mem8_f2(void *) | stores of 8 bytes to and from */ /* __float2_t & _mem8_f2_const(void *) | memory. */ /* */ /* __float2_t _fdmv_f2(float, float) Move two floats with one instruction */ /* __float2_t _hif2_128(__x128_t) Return hi 64 bits of __x128_t */ /* __float2_t _lof2_128(__x128_t) Return hi 64 bits of __x128_t */ /* __x128_t _f2to128(__float2_t, __float2_t) Compose __x128_t */ /* __float2_t _fdmvd_f2(float, float) Delayed move of two floats */ /*-------------------------------------------------------------------------*/ #define _lltof2 _lltod #define _f2toll _dtoll #define _ftof2 _ftod #define _hif2 _hif #define _lof2 _lof #define _f2tol _dtol #define _ltof2 _ltod #define _amem8_f2 _amemd8 #define _amem8_f2_const _amemd8_const /* _mem8_f2 and _mem8_f2_const for C6400 and compatible */ #if defined(_TMS320C6400) || defined (_TMS320C6740) || \ defined(_TMS320C6600) #define _mem8_f2 _memd8 #define _mem8_f2_const _memd8_const #endif /* _fdmv_f2 for C6400+ and compatible */ #if defined(_TMS320C6400_PLUS) || defined(_TMS320C6740) || \ defined(_TMS320C6600) #define _fdmv_f2 _fdmv #endif /* __float2_t manipulation intrinsics for __x128_t and C6600 */ #ifdef _TMS320C6600 #define _hif2_128 _hid128 #define _lof2_128 _lod128 #define _f2to128 _dto128 #define _fdmvd_f2 _fdmvd #endif #endif unsigned _extu (unsigned, unsigned, unsigned); int _ext (int, unsigned, unsigned); unsigned _set (unsigned, unsigned, unsigned); unsigned _clr (unsigned, unsigned, unsigned); unsigned _extur (unsigned, int); int _extr (int, int); unsigned _setr (unsigned, int); unsigned _clrr (unsigned, int); int _sadd (int, int); int _ssub (int, int); int _sshl (int, unsigned); int _add2 (int, int); int _sub2 (int, int); unsigned _subc (unsigned, unsigned); unsigned _lmbd (unsigned, unsigned); int _abs (int); __int40_t _labs (__int40_t); unsigned _norm (int); int _smpy (int, int); int _smpyhl (int, int); int _smpylh (int, int); int _smpyh (int, int); int _mpy (int, int); int _mpyus (unsigned, int); int _mpysu (int, unsigned); unsigned _mpyu (unsigned, unsigned); int _mpyhl (int, int); int _mpyhuls (unsigned, int); int _mpyhslu (int, unsigned); unsigned _mpyhlu (unsigned, unsigned); int _mpylh (int, int); int _mpyluhs (unsigned, int); int _mpylshu (int, unsigned); unsigned _mpylhu (unsigned, unsigned); int _mpyh (int, int); int _mpyhus (unsigned, int); int _mpyhsu (int, unsigned); unsigned _mpyhu (unsigned, unsigned); __int40_t _lsadd (int, __int40_t); __int40_t _lssub (int, __int40_t); int _sat (__int40_t); unsigned _lnorm (__int40_t); #ifdef _TMS320C6700 double _fabs (double); float _fabsf (float); long long _mpyidll (int, int); int _spint (float); int _dpint (double); float _rcpsp (float); double _rcpdp (double); float _rsqrsp (float); double _rsqrdp (double); /*double _mpyid (int, int); Deprecated. Use _mpyidll instead. */ #endif unsigned _hi(double); /* Return the hi 32 bits of a double as an int */ float _hif(double); /* Return the hi 32 bits of a double as a float */ unsigned _hill(long long); /* Return the hi 32 bits of a long long as an int */ unsigned _lo(double); /* Return the lo 32 bits of a double as an int */ float _lof(double); /* Return the lo 32 bits of a double as a float */ unsigned _loll(long long); /* Return the lo 32 bits of a long long as an int */ double _itod(unsigned, unsigned); /* Create a double from 2 ints */ double _ftod(float, float); /* Create a double from 2 floats */ long long _itoll(unsigned, unsigned); /* Create a long long from 2 ints */ float _itof(unsigned); /* Reinterpret int as float. */ unsigned _ftoi(float); /* Reinterpret float as int. */ __int40_t _dtol(double); /* Reinterpret double as 40-bit type */ double _ltod(__int40_t); /* Reinterpret 40-bit type as double */ long long _dtoll(double); /* Reinterpret double as long long */ double _lltod(long long); /* Reinterpret long long as double */ #if defined(_TMS320C6400) || defined(_TMS320C6740) || defined(_TMS320C6600) /* Define pseudo intrinsics for some pseudo instructions */ #ifndef _cmplt2 #define _cmplt2(src1, src2) _cmpgt2((src2), (src1)) #endif #ifndef _cmpltu4 #define _cmpltu4(src1, src2) _cmpgtu4((src2), (src1)) #endif #ifndef _dotpnrus2 #define _dotpnrus2(src1, src2) _dotpnrsu2((src2), (src1)) #endif #ifndef _dotpus4 #define _dotpus4(src1, src2) _dotpsu4((src2), (src1)) #endif #ifndef _mpyihll #define _mpyihll(src1, src2) _mpyhill((src2), (src1)) #endif #ifndef _mpyihr #define _mpyihr(src1, src2) _mpyhir((src2), (src1)) #endif #ifndef _mpyilll #define _mpyilll(src1, src2) _mpylill((src2), (src1)) #endif #ifndef _mpyilr #define _mpyilr(src1, src2) _mpylir((src2), (src1)) #endif #ifndef _mpyus4ll #define _mpyus4ll(src1, src2) _mpysu4ll((src2), (src1)) #endif #ifndef _saddsu2 #define _saddsu2(src1, src2) _saddus2((src2), (src1)) #endif #ifndef _swap2 #define _swap2(src) _packlh2((src), (src)) #endif int _add4 (int, int); int _avg2 (int, int); unsigned _avgu4 (unsigned, unsigned); int _cmpeq2 (int, int); int _cmpeq4 (int, int); int _cmpgt2 (int, int); unsigned _cmpgtu4 (unsigned, unsigned); int _dotp2 (int, int); int _dotpn2 (int, int); int _dotpnrsu2 (int, unsigned); int _dotprsu2 (int, unsigned); int _dotpsu4 (int, unsigned); unsigned _dotpu4 (unsigned, unsigned); int _gmpy4 (int, int); __int40_t _ldotp2 (int, int); int _max2 (int, int); unsigned _maxu4 (unsigned, unsigned); int _min2 (int, int); unsigned _minu4 (unsigned, unsigned); long long _mpy2ll (int, int); long long _mpyhill (int, int); int _mpyhir (int, int); long long _mpylill (int, int); int _mpylir (int, int); long long _mpysu4ll (int, unsigned); long long _mpyu4ll (unsigned, unsigned); unsigned _pack2 (unsigned, unsigned); unsigned _packh2 (unsigned, unsigned); unsigned _packh4 (unsigned, unsigned); unsigned _packhl2 (unsigned, unsigned); unsigned _packl4 (unsigned, unsigned); unsigned _packlh2 (unsigned, unsigned); unsigned _rotl (unsigned, unsigned); int _sadd2 (int, int); unsigned _saddu4 (unsigned, unsigned); int _saddus2 (unsigned, int); unsigned _shlmb (unsigned, unsigned); int _shr2 (int, unsigned); unsigned _shrmb (unsigned, unsigned); unsigned _shru2 (unsigned, unsigned); long long _smpy2ll (int, int); int _spack2 (int, int); unsigned _spacku4 (int, int); int _sshvl (int, int); int _sshvr (int, int); int _sub4 (int, int); int _subabs4 (int, int); int _abs2 (int); unsigned _bitc4 (unsigned); unsigned _bitr (unsigned); unsigned _deal (unsigned); int _mvd (int); unsigned _shfl (unsigned); unsigned _swap4 (unsigned); unsigned _unpkhu4 (unsigned); unsigned _unpklu4 (unsigned); unsigned _xpnd2 (unsigned); unsigned _xpnd4 (unsigned); /*double _mpy2 (int, int); Deprecated: use _mpy2ll instead */ /*double _mpyhi (int, int); Deprecated: use _mpyhill instead */ /*double _mpysu4 (int, unsigned); Deprecated: use _mpysu4ll instead */ /*double _mpyu4 (unsigned, unsigned); Deprecated: use _mpyu4ll instead */ /*double _smpy2 (int, int); Deprecated: use _smpy2ll instead */ #endif #if defined(_TMS320C6400_PLUS) || defined(_TMS320C6740) || defined(_TMS320C6600) long long _addsub (int, int); long long _addsub2 (unsigned, unsigned); long long _cmpy (unsigned, unsigned); unsigned _cmpyr (unsigned, unsigned); unsigned _cmpyr1 (unsigned, unsigned); long long _ddotph2 (long long, unsigned); unsigned _ddotph2r (long long, unsigned); long long _ddotpl2 (long long, unsigned); unsigned _ddotpl2r (long long, unsigned); long long _ddotp4 (unsigned, unsigned); long long _dpack2 (unsigned, unsigned); long long _dpackx2 (unsigned, unsigned); long long _dmv (unsigned, unsigned); double _fdmv (float, float); unsigned _gmpy (unsigned, unsigned); long long _mpy32ll (int, int); int _mpy32 (int, int); long long _mpy32su (int, unsigned); long long _mpy32us (unsigned, int); long long _mpy32u (unsigned, unsigned); long long _mpy2ir (unsigned, int); unsigned _rpack2 (unsigned, unsigned); long long _saddsub (int, int); long long _saddsub2 (unsigned, unsigned); long long _shfl3 (unsigned, unsigned); int _smpy32 (int, int); int _ssub2 (int, int); unsigned _xormpy (unsigned, unsigned); #endif #if defined(_TMS320C6600) long long _dcmpyr1 (long long, long long); long long _dccmpyr1 (long long, long long); long long _cmpy32r1 (long long, long long); long long _ccmpy32r1 (long long, long long); long long _mpyu2 (unsigned, unsigned); int _dotp4h (long long, long long); long long _dotp4hll (long long, long long); int _dotpsu4h (long long, long long); long long _dotpsu4hll (long long, long long); long long _dadd (long long, long long); long long _dadd_c (int, long long); long long _dsadd (long long, long long); long long _dadd2 (long long, long long); long long _dsadd2 (long long, long long); long long _dsub (long long, long long); long long _dssub (long long, long long); long long _dssub2 (long long, long long); long long _dapys2 (long long, long long); long long _dshr (long long, unsigned); long long _dshru (long long, unsigned); long long _dshl (long long, unsigned); long long _dshr2 (long long, unsigned); long long _dshru2 (long long, unsigned); unsigned _shl2 (unsigned , unsigned); long long _dshl2 (long long, unsigned); long long _dxpnd4 (unsigned); long long _dxpnd2 (unsigned); int _crot90 (int); long long _dcrot90 (long long); int _crot270 (int); long long _dcrot270 (long long); long long _dmax2 (long long, long long); long long _dmin2 (long long, long long); long long _dmaxu4 (long long, long long); long long _dminu4 (long long, long long); unsigned _dcmpgt2 (long long, long long); unsigned _dcmpeq2 (long long, long long); unsigned _dcmpgtu4 (long long, long long); unsigned _dcmpeq4 (long long, long long); long long _davg2 (long long, long long); long long _davgu4 (long long, long long); long long _davgnr2 (long long, long long); long long _davgnru4 (long long, long long); long long _unpkbu4 (unsigned); long long _unpkh2 (unsigned); long long _unpkhu2 (unsigned); long long _dpackl2 (long long, long long); long long _dpackh2 (long long, long long); long long _dpackhl2 (long long, long long); long long _dpacklh4 (unsigned, unsigned); long long _dpackl4 (long long, long long); long long _dpackh4 (long long, long long); long long _dspacku4 (long long, long long); void _mfence (); __float2_t _dmpysp (__float2_t, __float2_t); __float2_t _daddsp (__float2_t, __float2_t); __float2_t _dsubsp (__float2_t, __float2_t); __float2_t _dinthsp (unsigned); __float2_t _dinthspu (unsigned); __float2_t _dintsp (long long); __float2_t _dintspu (long long); unsigned _dspinth (__float2_t); long long _dspint (__float2_t); int _land (int, int); int _landn (int, int); int _lor (int, int); long long _dmvd (int, int); double _fdmvd (float, float); __float2_t _complex_mpysp (__float2_t, __float2_t); /* CMPYSP then DADDSP */ __float2_t _complex_conjugate_mpysp (__float2_t, __float2_t); /* CMPYSP then DSUBSP */ long long _xorll_c (int, long long); __x128_t __BUILTIN _dcmpy (long long, long long); __x128_t __BUILTIN _dccmpy (long long, long long); long long __BUILTIN _cmatmpyr1 (long long, __x128_t); long long __BUILTIN _ccmatmpyr1 (long long, __x128_t); __x128_t __BUILTIN _cmatmpy (long long, __x128_t); __x128_t __BUILTIN _ccmatmpy (long long, __x128_t); __x128_t __BUILTIN _qsmpy32r1 (__x128_t, __x128_t); __x128_t __BUILTIN _qmpy32 (__x128_t, __x128_t); __x128_t __BUILTIN _dsmpy2 (long long, long long); __x128_t __BUILTIN _dmpy2 (long long, long long); __x128_t __BUILTIN _dmpyu2 (long long, long long); __x128_t __BUILTIN _dmpysu4 (long long, long long); __x128_t __BUILTIN _dmpyu4 (long long, long long); __x128_t __BUILTIN _cmpysp (__float2_t, __float2_t); __x128_t __BUILTIN _qmpysp (__x128_t, __x128_t); long long __BUILTIN _ddotp4h (__x128_t, __x128_t); long long __BUILTIN _ddotpsu4h (__x128_t, __x128_t); __x128_t __BUILTIN _ito128 (unsigned, unsigned, unsigned, unsigned); __x128_t __BUILTIN _fto128 (float, float, float, float); __x128_t __BUILTIN _llto128 (long long, long long); __x128_t __BUILTIN _dto128 (double, double); long long __BUILTIN _hi128 (__x128_t); double __BUILTIN _hid128 (__x128_t); long long __BUILTIN _lo128 (__x128_t); double __BUILTIN _lod128 (__x128_t); unsigned __BUILTIN _get32_128 (__x128_t, __CONST(0,3) unsigned); float __BUILTIN _get32f_128 (__x128_t, __CONST(0,3) unsigned); __x128_t __BUILTIN _dup32_128 (unsigned); #endif extern __cregister volatile unsigned int AMR; extern __cregister volatile unsigned int CSR; extern __cregister volatile unsigned int IFR; extern __cregister volatile unsigned int ISR; extern __cregister volatile unsigned int ICR; extern __cregister volatile unsigned int IER; extern __cregister volatile unsigned int ISTP; extern __cregister volatile unsigned int IRP; extern __cregister volatile unsigned int NRP; #if defined(_TMS320C6400) || defined(_TMS320C6740) || defined(_TMS320C6600) extern __cregister volatile unsigned int GFPGFR; extern __cregister volatile unsigned int DIER; #endif #ifdef _TMS320C6700 extern __cregister volatile unsigned int FADCR; extern __cregister volatile unsigned int FAUCR; extern __cregister volatile unsigned int FMCR; #endif #ifdef _TMS320C6700_PLUS extern __cregister volatile unsigned int DESR; extern __cregister volatile unsigned int DETR; #endif #if defined(_TMS320C6400_PLUS) || defined(_TMS320C6740) || defined(_TMS320C6600) extern __cregister volatile unsigned int REP; extern __cregister volatile unsigned int TSCL; extern __cregister volatile unsigned int TSCH; extern __cregister volatile unsigned int ARP; extern __cregister volatile unsigned int ILC; extern __cregister volatile unsigned int RILC; extern __cregister volatile unsigned int PCE1; extern __cregister volatile unsigned int DNUM; extern __cregister volatile unsigned int SSR; extern __cregister volatile unsigned int GPLYA; extern __cregister volatile unsigned int GPLYB; extern __cregister volatile unsigned int TSR; extern __cregister volatile unsigned int ITSR; extern __cregister volatile unsigned int NTSR; extern __cregister volatile unsigned int ECR; extern __cregister volatile unsigned int EFR; extern __cregister volatile unsigned int IERR; extern __cregister volatile unsigned int DMSG; extern __cregister volatile unsigned int CMSG; extern __cregister volatile unsigned int DT_DMA_ADDR; extern __cregister volatile unsigned int DT_DMA_DATA; extern __cregister volatile unsigned int DT_DMA_CNTL; extern __cregister volatile unsigned int TCU_CNTL; extern __cregister volatile unsigned int RTDX_REC_CNTL; extern __cregister volatile unsigned int RTDX_XMT_CNTL; extern __cregister volatile unsigned int RTDX_CFG; extern __cregister volatile unsigned int RTDX_RDATA; extern __cregister volatile unsigned int RTDX_WDATA; extern __cregister volatile unsigned int RTDX_RADDR; extern __cregister volatile unsigned int RTDX_WADDR; extern __cregister volatile unsigned int MFREG0; extern __cregister volatile unsigned int DBG_STAT; extern __cregister volatile unsigned int BRK_EN; extern __cregister volatile unsigned int HWBP0_CNT; extern __cregister volatile unsigned int HWBP0; extern __cregister volatile unsigned int HWBP1; extern __cregister volatile unsigned int HWBP2; extern __cregister volatile unsigned int HWBP3; extern __cregister volatile unsigned int OVERLAY; extern __cregister volatile unsigned int PC_PROF; extern __cregister volatile unsigned int ATSR; extern __cregister volatile unsigned int TRR; extern __cregister volatile unsigned int TCRR; #endif #ifdef __cplusplus } /* extern "C" */ #endif /* __cplusplus */ /*****************************************************************************/ /* DATA_IS_ALIGNED_2, DATA_IS_ALIGNED_4, DATA_IS_ALIGNED_8 - */ /* Tell the compiler that data is already aligned to a 2-byte, 4-byte */ /* or 8-byte boundary. Note: this macro does not change the */ /* alignment of data. Use DATA_ALIGN to change alignment. */ /*****************************************************************************/ #define DATA_IS_ALIGNED_2(x) (_nassert(((unsigned int)(x) & 0x1) == 0)) #define DATA_IS_ALIGNED_4(x) (_nassert(((unsigned int)(x) & 0x3) == 0)) #define DATA_IS_ALIGNED_8(x) (_nassert(((unsigned int)(x) & 0x7) == 0)) /*****************************************************************************/ /* SAVE_AMR - */ /* Define a local 'volatile unsigned int' variable in your interrupt */ /* routine. */ /* When invoking this macro, pass that local variable to save the AMR. */ /* */ /* If you interrupted an assembly coded routine that may be using */ /* circular addressing, and you interrupt into a C coded interrupt */ /* service routine, you need to set the AMR to 0 for the C code and save */ /* off the AMR register, so that it will have the correct value upon */ /* leaving the C interrupt service routine and returning to the assembly */ /* code. */ /* */ /* Add this routine immediately after your local variable definitions */ /* and before the start of your C interrupt code. */ /*****************************************************************************/ #define SAVE_AMR(temp_AMR) \ do { \ temp_AMR = AMR; \ AMR = 0; \ } while (0) /*****************************************************************************/ /* RESTORE_AMR - */ /* When invoking this macro, pass the same local variable that was passed */ /* to the SAVE_AMR macro. This macro will restore the AMR to the value */ /* it had when interrupted out of the hand assembly routine. */ /* */ /* Add this macro immediately before exiting the C interrupt service */ /* routine. */ /*****************************************************************************/ #define RESTORE_AMR(temp_AMR) \ do { \ AMR = temp_AMR; \ } while (0) /*****************************************************************************/ /* SAVE_SAT - */ /* Define a local 'volatile unsigned int' variable in your interrupt */ /* routine. */ /* When invoking this macro, pass that local variable to save the SAT */ /* bit. */ /* */ /* If you interrupted a routine that was performing saturated arithmetic */ /* and the interrupt service routine is also performing saturated */ /* arithmetic, then you must save and restore the SAT bit in your */ /* interrupt service routine. */ /* */ /* Add this routine immediately after your local variable definitions */ /* and before the start of your C interrupt code. */ /*****************************************************************************/ #define SAVE_SAT(temp_SAT) \ do { \ temp_SAT = _extu(CSR, 22, 31); \ } while (0) /*****************************************************************************/ /* RESTORE_SAT - */ /* When invoking this macro, pass the same local variable that was passed */ /* to the SAVE_SAT macro. This macro will restore the SAT bit to the */ /* value it had when your application was interrupted. */ /* */ /* Add this macro immediately before exiting the C interrupt service */ /* routine. */ /*****************************************************************************/ #define RESTORE_SAT(temp_SAT) \ do { \ CSR = _clr(CSR, 9, 9); \ temp_SAT = _sshl(temp_SAT, 31); \ } while (0)