pkernel/rlt.c

   1 /*****************************************************************************/
   2 /* THIS SAMPLE CODE IS PROVIDED AS IS AND IS SUBJECT TO ALTERATIONS. FUJITSU */
   3 /* MICROELECTRONICS ACCEPTS NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR */
   4 /* ELIGIBILITY FOR ANY PURPOSES.                                             */
   5 /*                 (C) Fujitsu Microelectronics Europe GmbH                  */
   6 /*****************************************************************************/
   7
   8 #include "rlt.h"
   9
  10 #pragma section CODE=IRAM,attr=CODE
  11 void RLT_InitializeTimer(unsigned char channel, unsigned char runmode, unsigned char clockmode, unsigned char triggermode, unsigned char outputmode)
  12 {
  13         unsigned short setvalue = 0x00;
  14
  15         /*      Prepare seting for the TMCSR Register   */
  16         setvalue |= ( (clockmode << 10) | (triggermode << 7) | ((outputmode & 0x01) << 5) | ((runmode & 0x01) << 4) | 0x02 /* CNTE */ );
  17
  18         /*      Set the corresponding RLT channel       */
  19         switch(channel)
  20         {
  21                 case 0:
  22                 {
  23                         TMCSR0 = setvalue;
  24                         break;
  25                 }
  26                 case 1:
  27                 {
  28                         TMCSR1 = setvalue;
  29                         break;
  30                 }
  31                 case 2:
  32                 {
  33                         TMCSR2 = setvalue;
  34                         break;
  35                 }
  36                 case 3:
  37                 {
  38                         TMCSR3 = setvalue;
  39                         break;
  40                 }
  41                 case 4:
  42                 {
  43                         TMCSR4 = setvalue;
  44                         break;
  45                 }
  46                 case 5:
  47                 {
  48                         TMCSR5 = setvalue;
  49                         break;
  50                 }
  51                 case 6:
  52                 {
  53                         TMCSR6 = setvalue;
  54                         break;
  55                 }
  56                 case 7:
  57                 {
  58                         TMCSR7 = setvalue;
  59                         break;
  60                 }
  61         }
  62 }
  63
  64 void RLT_SetReloadValue(unsigned char channel, unsigned short int value)
  65 {
  66         switch(channel)
  67         {
  68                 case 0:
  69                 {
  70                         TMRLR0 = value;
  71                         break;
  72                 }
  73                 case 1:
  74                 {
  75                         TMRLR1 = value;
  76                         break;
  77                 }
  78                 case 2:
  79                 {
  80                         TMRLR2 = value;
  81                         break;
  82                 }
  83                 case 3:
  84                 {
  85                         TMRLR3 = value;
  86                         break;
  87                 }
  88                 case 4:
  89                 {
  90                         TMRLR4 = value;
  91                         break;
  92                 }
  93                 case 5:
  94                 {
  95                         TMRLR5 = value;
  96                         break;
  97                 }
  98                 case 6:
  99                 {
 100                         TMRLR6 = value;
 101                         break;
 102                 }
 103                 case 7:
 104                 {
 105                         TMRLR7 = value;
 106                         break;
 107                 }
 108         }
 109 }
 110
 111 void RLT_TriggerTimer(unsigned char channel)
 112 {
 113         switch(channel)
 114         {
 115                 case 0:
 116                 {
 117                         TMCSR0_TRG = 1;
 118                         break;
 119                 }
 120                 case 1:
 121                 {
 122                         TMCSR1_TRG = 1;
 123                         break;
 124                 }
 125                 case 2:
 126                 {
 127                         TMCSR2_TRG = 1;
 128                         break;
 129                 }
 130                 case 3:
 131                 {
 132                         TMCSR3_TRG = 1;
 133                         break;
 134                 }
 135                 case 4:
 136                 {
 137                         TMCSR4_TRG = 1;
 138                         break;
 139                 }
 140                 case 5:
 141                 {
 142                         TMCSR5_TRG = 1;
 143                         break;
 144                 }
 145                 case 6:
 146                 {
 147                         TMCSR6_TRG = 1;
 148                         break;
 149                 }
 150                 case 7:
 151                 {
 152                         TMCSR7_TRG = 1;
 153                         break;
 154                 }
 155         }
 156 }
 157
 158 void RLT_EnableInterrupt(unsigned char channel, unsigned char enable)
 159 {
 160         switch(channel)
 161         {
 162                 case 0:
 163                 {
 164                         /*      Clear Pending Interrupt Flag    */
 165                         TMCSR0_UF = 0;
 166
 167                         /* Enable Interrupt     */
 168                         TMCSR0_INTE = enable;
 169                         break;
 170                 }
 171                 case 1:
 172                 {
 173                         /*      Clear Pending Interrupt Flag    */
 174                         TMCSR1_UF = 0;
 175
 176                         /* Enable Interrupt     */
 177                         TMCSR1_INTE = enable;
 178                         break;
 179                 }
 180                 case 2:
 181                 {
 182                         /*      Clear Pending Interrupt Flag    */
 183                         TMCSR2_UF = 0;
 184
 185                         /* Enable Interrupt     */
 186                         TMCSR2_INTE = enable;
 187                         break;
 188                 }
 189                 case 3:
 190                 {
 191                         /*      Clear Pending Interrupt Flag    */
 192                         TMCSR3_UF = 0;
 193
 194                         /* Enable Interrupt     */
 195                         TMCSR3_INTE = enable;
 196                         break;
 197                 }
 198                 case 4:
 199                 {
 200                         /*      Clear Pending Interrupt Flag    */
 201                         TMCSR4_UF = 0;
 202
 203                         /* Enable Interrupt     */
 204                         TMCSR4_INTE = enable;
 205                         break;
 206                 }
 207                 case 5:
 208                 {
 209                         /*      Clear Pending Interrupt Flag    */
 210                         TMCSR5_UF = 0;
 211
 212                         /* Enable Interrupt     */
 213                         TMCSR5_INTE = enable;
 214                         break;
 215                 }
 216                 case 6:
 217                 {
 218                         /*      Clear Pending Interrupt Flag    */
 219                         TMCSR6_UF = 0;
 220
 221                         /* Enable Interrupt     */
 222                         TMCSR6_INTE = enable;
 223                         break;
 224                 }
 225                 case 7:
 226                 {
 227                         /*      Clear Pending Interrupt Flag    */
 228                         TMCSR7_UF = 0;
 229
 230                         /* Enable Interrupt     */
 231                         TMCSR7_INTE = enable;
 232                         break;
 233                 }
 234         }
 235 }
 236
 237 __interrupt void RLT_Channel0_ISR()
 238 {
 239         /*      Clear Pending Interrupt Flag    */
 240         TMCSR0_UF = 0;
 241
 242         /*      Do what you have to do  */
 243         PDR14--; //since the pins are low active
 244 }
 245
 246 __interrupt void RLT_Channel1_ISR()
 247 {
 248         /*      Clear Pending Interrupt Flag    */
 249         TMCSR1_UF = 0;
 250
 251         /*      Do what you have to do  */
 252 }
 253
 254 __interrupt void RLT_Channel2_ISR()
 255 {
 256         /*      Clear Pending Interrupt Flag    */
 257         TMCSR2_UF = 0;
 258
 259         /*      Do what you have to do  */
 260 }
 261
 262 __interrupt void RLT_Channel3_ISR()
 263 {
 264         /*      Clear Pending Interrupt Flag    */
 265         TMCSR3_UF = 0;
 266
 267         /*      Do what you have to do  */
 268 }
 269
 270 __interrupt void RLT_Channel4_ISR()
 271 {
 272         /*      Clear Pending Interrupt Flag    */
 273         TMCSR4_UF = 0;
 274
 275         /*      Do what you have to do  */
 276 }
 277
 278 __interrupt void RLT_Channel5_ISR()
 279 {
 280         /*      Clear Pending Interrupt Flag    */
 281         TMCSR5_UF = 0;
 282
 283         /*      Do what you have to do  */
 284 }
 285
 286 __interrupt void RLT_Channel6_ISR()
 287 {
 288         /*      Clear Pending Interrupt Flag    */
 289         TMCSR6_UF = 0;
 290
 291         /*      Do what you have to do  */
 292 }
 293
 294 __interrupt void RLT_Channel7_ISR()
 295 {
 296         /*      Clear Pending Interrupt Flag    */
 297         TMCSR7_UF = 0;
 298
 299         /*      Do what you have to do  */
 300 }