Changeset 9ac9883 in rtems


Ignore:
Timestamp:
Sep 3, 2008, 3:36:45 PM (11 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, 4.9, master
Children:
82bd8d9d
Parents:
7dc035b
Message:

Moved general MSCAN functions into

separate header and source files (include/mscan-base.h and
mscan/mscan-base.c). Formatted code.

Location:
c/src/lib/libbsp/powerpc/gen5200/mscan
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/gen5200/mscan/mscan.c

    r7dc035b r9ac9883  
    2424#include <rtems/libio.h>
    2525#include <string.h>
     26
    2627#include "../include/bsp.h"
    27 #include "../irq/irq.h"
    28 #include "../include/mpc5200.h"
     28#include <bsp/irq.h>
    2929#include "../mscan/mscan_int.h"
    3030
     
    3434static struct mscan_channel_info chan_info[MPC5200_CAN_NO];
    3535
    36 /* time segmant table  */
    37 uint8_t can_time_segment_table[CAN_MAX_NO_OF_TQ - MIN_NO_OF_TQ + 1][NO_OF_TABLE_ENTRIES] = {
    38 
    39 /* Total no. of time quantas */   /* Time Segment 1*/    /* Time Segment 2 */     /* Sync: Jump width */
    40 {         7,                                4,                     2,                       1          },
    41 {         8,                                5,                     2,                       1          },
    42 {         9,                                6,                     2,                       2          },
    43 {        10,                                6,                     3,                       2          },
    44 {        11,                                7,                     3,                       2          },
    45 {        12,                                8,                     3,                       2          },
    46 {        13,                                8,                     4,                       2          },
    47 {        14,                                9,                     4,                       2          },
    48 {        15,                               10,                     4,                       2          },
    49 {        16,                               10,                     5,                       2          },
    50 {        17,                               11,                     5,                       2          },
    51 {        18,                               12,                     5,                       2          },
    52 {        19,                               12,                     6,                       2          },
    53 {        20,                               13,                     6,                       2          },
    54 {        21,                               14,                     6,                       2          },
    55 {        22,                               14,                     7,                       2          },
    56 {        23,                               15,                     7,                       2          },
    57 {        24,                               15,                     8,                       2          },
    58 {        25,                               16,                     8,                       2          }};
    59 
    60 
    6136/*
    6237 * MPC5x00 MSCAN tx ring buffer function to get a can message buffer from the head of the tx ring buffer
    6338 */
    64 static struct can_message * get_tx_buffer(struct mscan_channel_info *chan)
    65   {
     39static struct can_message *get_tx_buffer(struct mscan_channel_info *chan)
     40{
    6641  /* define a temp. mess ptr. */
    67   struct can_message * tmp_mess_ptr = NULL, *temp_head_ptr;
     42  struct can_message *tmp_mess_ptr = NULL,
     43    *temp_head_ptr;
    6844
    6945  /* set temp. head pointer */
     
    7147
    7248  /* check buffer empty condition */
    73   if(temp_head_ptr != chan->tx_ring_buf.tail_ptr)
    74     {
     49  if (temp_head_ptr != chan->tx_ring_buf.tail_ptr) {
    7550
    7651    /* current buffer head. ptr. */
     
    8156
    8257    /* check for wrap around condition */
    83     if(temp_head_ptr > chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF)
    84       {
     58    if (temp_head_ptr > chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF) {
    8559
    8660      /* set head ptr. to the begin of the ring buffer */
    8761      temp_head_ptr = chan->tx_ring_buf.buf_ptr;
    8862
    89       }
     63    }
    9064
    9165    /* end of crtical section restore head ptr. */
    9266    chan->tx_ring_buf.head_ptr = temp_head_ptr;
    93     }
     67  }
    9468
    9569  /* return the current head pointer */
    9670  return tmp_mess_ptr;
    97   }
     71}
    9872
    9973/*
    10074 * MPC5x00 MSCAN tx ring buffer function to write a can message buffer to the tail of the tx ring buffer
    10175 */
    102 static struct can_message * fill_tx_buffer(struct mscan_channel_info *chan, struct can_message * mess_ptr)
    103   {
     76static struct can_message *fill_tx_buffer(struct mscan_channel_info *chan,
     77                                          struct can_message *mess_ptr)
     78{
    10479  /* define a temp. mess ptr. to the entry which follows the current tail entry */
    105   struct can_message * tmp_mess_ptr = chan->tx_ring_buf.tail_ptr + 1;
     80  struct can_message *tmp_mess_ptr = chan->tx_ring_buf.tail_ptr + 1;
    10681
    10782  /* check for the wrap around condition */
    108   if(tmp_mess_ptr >  chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF)
    109     {
    110         /* set temp. mess. ptr to the begin of the ring buffer */
    111         tmp_mess_ptr = chan->tx_ring_buf.buf_ptr;
    112     }
     83  if (tmp_mess_ptr > chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF) {
     84    /* set temp. mess. ptr to the begin of the ring buffer */
     85    tmp_mess_ptr = chan->tx_ring_buf.buf_ptr;
     86  }
    11387
    11488  /* check buffer full condition */
    115   if(tmp_mess_ptr == chan->tx_ring_buf.head_ptr)
    116     {
    117         /* return NULL in case buffer is full */
    118         return NULL;
    119     }
    120   else
    121     {
    122         /* copy the can mess. to the tail of the buffer */
    123     memcpy((void *)chan->tx_ring_buf.tail_ptr, (void *)mess_ptr, sizeof(struct can_message));
     89  if (tmp_mess_ptr == chan->tx_ring_buf.head_ptr) {
     90    /* return NULL in case buffer is full */
     91    return NULL;
     92  } else {
     93    /* copy the can mess. to the tail of the buffer */
     94    memcpy((void *) chan->tx_ring_buf.tail_ptr, (void *) mess_ptr,
     95           sizeof (struct can_message));
    12496
    12597    /* set new tail equal to temp. mess. ptr. */
    12698    chan->tx_ring_buf.tail_ptr = tmp_mess_ptr;
    127     }
     99  }
    128100
    129101  /* return the actual tail ptr. (next free entry) */
    130102  return chan->tx_ring_buf.tail_ptr;
    131   }
     103}
    132104
    133105/*
     
    135107 */
    136108static void mpc5200_mscan_interrupt_handler(rtems_irq_hdl_param handle)
    137   {
     109{
    138110  rtems_status_code status;
    139   mscan_handle *mscan_hdl = (mscan_handle *)handle;
     111  mscan_handle *mscan_hdl = (mscan_handle *) handle;
    140112  struct mscan_channel_info *chan = &chan_info[mscan_hdl->mscan_channel];
    141   struct can_message rx_mess, *rx_mess_ptr, *tx_mess_ptr;
    142   volatile struct mpc5200_mscan *mscan = chan->regs;
     113  struct can_message rx_mess,
     114   *rx_mess_ptr,
     115   *tx_mess_ptr;
     116  mscan *m = chan->regs;
    143117  register uint8_t idx;
    144118
    145119  /*
    146    handle tx ring buffer
     120     handle tx ring buffer
    147121   */
    148122
    149123  /* loop over all 3 tx buffers */
    150   for(idx = TFLG_TXE0; idx <= TFLG_TXE2; idx=idx<<1)
    151     {
     124  for (idx = TFLG_TXE0; idx <= TFLG_TXE2; idx = idx << 1) {
    152125
    153126    /* check for tx buffer vacation */
    154     if((mscan->tflg) & idx)
    155       {
     127    if ((m->tflg) & idx) {
    156128
    157129      /* try to get a message */
     
    159131
    160132      /* check for new tx message */
    161       if(tx_mess_ptr != NULL)
    162         {
     133      if (tx_mess_ptr != NULL) {
    163134
    164135        /* select the tx buffer */
    165         mscan->bsel = idx;
     136        m->bsel = idx;
    166137
    167138        /* check for toucan interface */
    168         if((mscan_hdl->toucan_callback) == NULL)
    169           {
     139        if ((mscan_hdl->toucan_callback) == NULL) {
    170140
    171141          /* set tx id */
    172                   mscan->txidr0 = SET_IDR0(tx_mess_ptr->mess_id);
    173                   mscan->txidr1 = SET_IDR1(tx_mess_ptr->mess_id);
    174                   mscan->txidr2 = 0;
    175           mscan->txidr3 = 0;
    176 
    177               }
     142          m->txidr0 = SET_IDR0(tx_mess_ptr->mess_id);
     143          m->txidr1 = SET_IDR1(tx_mess_ptr->mess_id);
     144          m->txidr2 = 0;
     145          m->txidr3 = 0;
     146
     147        }
    178148
    179149        /* fill in tx data if TOUCAN is activ an TOUCAN index have a match with the tx buffer or TOUCAN is disabled */
    180         if(((mscan_hdl->toucan_callback) == NULL) || (((mscan_hdl->toucan_callback) != NULL) && ((tx_mess_ptr->toucan_tx_idx) == idx)))
    181           {
    182 
    183           /* insert dlc into mscan register */
    184                   mscan->txdlr = (uint8_t)((tx_mess_ptr->mess_len) & 0x000F);
     150        if (((mscan_hdl->toucan_callback) == NULL)
     151            || (((mscan_hdl->toucan_callback) != NULL)
     152                && ((tx_mess_ptr->toucan_tx_idx) == idx))) {
     153
     154          /* insert dlc into m register */
     155          m->txdlr = (uint8_t) ((tx_mess_ptr->mess_len) & 0x000F);
    185156
    186157          /* skip data copy in case of RTR */
    187           if(!(MSCAN_MESS_ID_HAS_RTR(tx_mess_ptr->mess_id)))
    188             {
     158          if (!(MSCAN_MESS_ID_HAS_RTR(tx_mess_ptr->mess_id))) {
    189159            /* copy tx data to MSCAN registers */
    190             switch(mscan->txdlr)
    191               {
     160            switch (m->txdlr) {
    192161              case 8:
    193                 mscan->txdsr7 = tx_mess_ptr->mess_data[7];
     162                m->txdsr7 = tx_mess_ptr->mess_data[7];
    194163              case 7:
    195                 mscan->txdsr6 = tx_mess_ptr->mess_data[6];
     164                m->txdsr6 = tx_mess_ptr->mess_data[6];
    196165              case 6:
    197                 mscan->txdsr5 = tx_mess_ptr->mess_data[5];
     166                m->txdsr5 = tx_mess_ptr->mess_data[5];
    198167              case 5:
    199                 mscan->txdsr4 = tx_mess_ptr->mess_data[4];
     168                m->txdsr4 = tx_mess_ptr->mess_data[4];
    200169              case 4:
    201                 mscan->txdsr3 = tx_mess_ptr->mess_data[3];
     170                m->txdsr3 = tx_mess_ptr->mess_data[3];
    202171              case 3:
    203                 mscan->txdsr2 = tx_mess_ptr->mess_data[2];
     172                m->txdsr2 = tx_mess_ptr->mess_data[2];
    204173              case 2:
    205                 mscan->txdsr1 = tx_mess_ptr->mess_data[1];
     174                m->txdsr1 = tx_mess_ptr->mess_data[1];
    206175              case 1:
    207                 mscan->txdsr0 = tx_mess_ptr->mess_data[0];
     176                m->txdsr0 = tx_mess_ptr->mess_data[0];
    208177                break;
    209178              default:
    210179                break;
    211               }
    212                     }
     180            }
     181          }
    213182
    214183          /* enable message buffer specific interrupt */
    215               mscan->tier |= mscan->bsel;
    216 
    217               /* start transfer */
    218           mscan->tflg = mscan->bsel;
     184          m->tier |= m->bsel;
     185
     186          /* start transfer */
     187          m->tflg = m->bsel;
    219188
    220189          /* release counting semaphore of tx ring buffer */
    221                   rtems_semaphore_release((rtems_id)(chan->tx_rb_sid));
    222 
    223           }
    224         else
    225           {
     190          rtems_semaphore_release((rtems_id) (chan->tx_rb_sid));
     191
     192        } else {
    226193
    227194          /* refill the tx ring buffer with the message */
    228195          fill_tx_buffer(chan, tx_mess_ptr);
    229196
    230               }
    231             }
    232           else
    233             {
    234                 /* reset interrupt enable bit */
    235             mscan->tier &= ~(idx);
    236             }
     197        }
     198      } else {
     199        /* reset interrupt enable bit */
     200        m->tier &= ~(idx);
    237201      }
    238202    }
     203  }
    239204
    240205  /*
    241    handle rx interrupts
     206     handle rx interrupts
    242207   */
    243208
    244209  /* check for rx interrupt source */
    245   if(mscan->rier & RIER_RXFIE)
    246     {
     210  if (m->rier & RIER_RXFIE) {
    247211
    248212    /* can messages received ? */
    249     while(mscan->rflg & RFLG_RXF)
    250       {
    251 
    252       if(mscan_hdl->toucan_callback == NULL)
    253         {
     213    while (m->rflg & RFLG_RXF) {
     214
     215      if (mscan_hdl->toucan_callback == NULL) {
    254216
    255217        /* select temporary rx buffer */
    256218        rx_mess_ptr = &rx_mess;
    257219
    258         }
    259       else
    260         {
     220      } else {
    261221
    262222        /* check the rx fliter-match indicators (16-bit filter mode) */
    263223        /* in case of more than one hit, lower hit has priority */
    264           idx = (mscan->idac) & 0x7;
    265           switch(idx)
    266           {
     224        idx = (m->idac) & 0x7;
     225        switch (idx) {
    267226
    268227          case 0:
    269           case 1:
    270           case 2:
    271           case 3:
     228          case 1:
     229          case 2:
     230          case 3:
    272231            rx_mess_ptr =
    273               (struct can_message *)&(mpc5200_mscan_rx_cntrl[mscan_hdl->mscan_channel].can_rx_message[idx]);
     232              (struct can_message *)
     233              &(mpc5200_mscan_rx_cntrl[mscan_hdl->mscan_channel].
     234                can_rx_message[idx]);
    274235            break;
    275236
    276           /* this case should never happen */
    277                   default:
     237            /* this case should never happen */
     238          default:
    278239            /* reset the rx indication flag */
    279             mscan->rflg |= RFLG_RXF;
     240            m->rflg |= RFLG_RXF;
    280241
    281242            return;
    282243            break;
    283               }
    284 
    285244        }
    286245
     246      }
     247
    287248      /* get rx ID */
    288       rx_mess_ptr->mess_id = GET_IDR0(mscan->rxidr0) | GET_IDR1(mscan->rxidr1);
     249      rx_mess_ptr->mess_id = GET_IDR0(m->rxidr0) | GET_IDR1(m->rxidr1);
    289250
    290251      /* get rx len */
    291       rx_mess_ptr->mess_len = ((mscan->rxdlr) & 0x0F);
     252      rx_mess_ptr->mess_len = ((m->rxdlr) & 0x0F);
    292253
    293254      /* get time stamp */
    294       rx_mess_ptr->mess_time_stamp = ((mscan->rxtimh << 8) | (mscan->rxtiml));
     255      rx_mess_ptr->mess_time_stamp = ((m->rxtimh << 8) | (m->rxtiml));
    295256
    296257      /* skip data copy in case of RTR */
    297       if(!(MSCAN_MESS_ID_HAS_RTR(rx_mess_ptr->mess_id)))
    298 
    299         {
    300 
    301          /* get the data */
    302              switch(rx_mess_ptr->mess_len)
    303                {
    304                case 8:
    305                  rx_mess_ptr->mess_data[7] = mscan->rxdsr7;
    306                case 7:
    307                  rx_mess_ptr->mess_data[6] = mscan->rxdsr6;
    308                case 6:
    309                  rx_mess_ptr->mess_data[5] = mscan->rxdsr5;
    310                case 5:
    311                  rx_mess_ptr->mess_data[4] = mscan->rxdsr4;
    312                case 4:
    313                  rx_mess_ptr->mess_data[3] = mscan->rxdsr3;
    314                case 3:
    315                  rx_mess_ptr->mess_data[2] = mscan->rxdsr2;
    316                case 2:
    317                  rx_mess_ptr->mess_data[1] = mscan->rxdsr1;
    318                case 1:
    319                  rx_mess_ptr->mess_data[0] = mscan->rxdsr0;
    320                case 0:
    321                default:
    322                  break;
    323                }
    324             }
    325 
    326       if(mscan_hdl->toucan_callback == NULL)
    327         {
    328 
    329         if((status = rtems_message_queue_send(chan->rx_qid, (void *)rx_mess_ptr, sizeof(struct can_message))) != RTEMS_SUCCESSFUL)
    330                   {
    331 
    332                   chan->int_rx_err++;
    333 
    334           }
    335 
    336             }
    337       else
    338         {
    339 
    340         mscan_hdl->toucan_callback((int16_t)(((mscan->idac) & 0x7) + 3));
    341 
    342             }
     258      if (!(MSCAN_MESS_ID_HAS_RTR(rx_mess_ptr->mess_id)))
     259      {
     260
     261        /* get the data */
     262        switch (rx_mess_ptr->mess_len) {
     263          case 8:
     264            rx_mess_ptr->mess_data[7] = m->rxdsr7;
     265          case 7:
     266            rx_mess_ptr->mess_data[6] = m->rxdsr6;
     267          case 6:
     268            rx_mess_ptr->mess_data[5] = m->rxdsr5;
     269          case 5:
     270            rx_mess_ptr->mess_data[4] = m->rxdsr4;
     271          case 4:
     272            rx_mess_ptr->mess_data[3] = m->rxdsr3;
     273          case 3:
     274            rx_mess_ptr->mess_data[2] = m->rxdsr2;
     275          case 2:
     276            rx_mess_ptr->mess_data[1] = m->rxdsr1;
     277          case 1:
     278            rx_mess_ptr->mess_data[0] = m->rxdsr0;
     279          case 0:
     280          default:
     281            break;
     282        }
     283      }
     284
     285      if (mscan_hdl->toucan_callback == NULL) {
     286
     287        if ((status =
     288             rtems_message_queue_send(chan->rx_qid, (void *) rx_mess_ptr,
     289                                      sizeof (struct can_message))) !=
     290            RTEMS_SUCCESSFUL) {
     291
     292          chan->int_rx_err++;
     293
     294        }
     295
     296      } else {
     297
     298        mscan_hdl->toucan_callback((int16_t) (((m->idac) & 0x7) + 3));
     299
     300      }
    343301
    344302      /* reset the rx indication flag */
    345       mscan->rflg |= RFLG_RXF;
    346 
    347       } /* end of while(mscan->rflg & RFLG_RXF) */
     303      m->rflg |= RFLG_RXF;
     304
     305    }                           /* end of while(m->rflg & RFLG_RXF) */
     306
     307  }
     308
     309  /* status change detected */
     310  if (m->rflg & RFLG_CSCIF) {
     311
     312    m->rflg |= RFLG_CSCIF;
     313
     314    if (mscan_hdl->toucan_callback != NULL) {
     315
     316      mscan_hdl->toucan_callback((int16_t) (-1));
    348317
    349318    }
    350319
    351     /* status change detected */
    352     if(mscan->rflg & RFLG_CSCIF)
    353       {
    354 
    355       mscan->rflg |= RFLG_CSCIF;
    356 
    357       if(mscan_hdl->toucan_callback != NULL)
    358         {
    359 
    360         mscan_hdl->toucan_callback((int16_t)(-1));
    361 
    362         }
    363 
    364       }
    365 
    366   }
    367 
    368 
    369 /*
    370  * Disable MSCAN ints.
    371  */
    372 void mpc5200_mscan_int_disable(volatile struct mpc5200_mscan *mscan)
    373   {
    374 
    375   /* RX Interrupt Enable on MSCAN_A/_B -----------------------------*/
    376   /*    [07]:WUPIE         0 : WakeUp interrupt disabled            */
    377   /*    [06]:CSCIE         0 : Status Change interrupt disabled     */
    378   /*    [05]:RSTATE1       0 : Recv. Status Change int. ,Bit 1      */
    379   /*    [04]:RSTATE0       0 : Recv. Status Change int. ,Bit 0      */
    380   /*                           -> 00 rx status change int. disabled */
    381   /*    [03]:TSTAT1        0 : Transmit. Status Change int. , Bit 1 */
    382   /*    [02]:TSTAT0        0 : Transmit. Status Change int. , Bit 0 */
    383   /*                           -> 00 tx status change int. disabled */
    384   /*    [01]:OVRIE         0 : Overrun Interrupt is disabled        */
    385   /*    [00]:RXFIE         0 : Recv. Full interrupt is disabled     */
    386   mscan->rier &= ~(RIER_CSCIE | RIER_RXFIE);
    387 
    388   /* TX Interrupt Enable on MSCAN_A/_B -----------------------------*/
    389   /*    [07]:res.          0 : reserved                             */
    390   /*    [06]:res.          0 : reserved                             */
    391   /*    [05]:res.          0 : reserved                             */
    392   /*    [04]:res.          0 : reserved                             */
    393   /*    [03]:res.          0 : reserved                             */
    394   /*    [02]:TSEG12        0 : TX2message buffer int. is disabled   */
    395   /*    [01]:TSEG11        0 : TX1 message buffer int. is disabled  */
    396   /*    [00]:TSEG10        0 : TX0 message buffer int. is disabled  */
    397   mscan->tier &= ~(TIER_TXEI2 | TIER_TXEI1 | TIER_TXEI0);
    398 
    399   return;
    400 
    401   }
    402 
    403 
    404 /*
    405  * Enable MSCAN ints.
    406  */
    407 void mpc5200_mscan_int_enable(volatile struct mpc5200_mscan *mscan)
    408   {
    409 
    410   /* RX Interrupt Enable on MSCAN_A/_B -----------------------------*/
     320  }
     321
     322}
     323
     324/**
     325 * @brief Enables some interrupts for the MSCAN module @a m.
     326 *
     327 * Enabled interrupts:
     328 *  - Receiver or transmitter enters or leaves bus off state
     329 *  - Receiver buffer full
     330 */
     331static void mscan_interrupts_enable(mscan *m)
     332{
     333
     334  /* RX Interrupt Enable on MSCAN_A/_B ----------------------------- */
    411335  /*    [07]:WUPIE         0 : WakeUp interrupt disabled            */
    412336  /*    [06]:CSCIE         1 : Status Change interrupt enabled      */
     
    419343  /*    [01]:OVRIE         0 : Overrun Interrupt is disabled        */
    420344  /*    [00]:RXFIE         1 : Recv. Full interrupt is enabled      */
    421   mscan->rier |= (RIER_CSCIE | RIER_RXFIE | RIER_RSTAT(1) | RIER_TSTAT(1));
     345  m->rier |= (RIER_CSCIE | RIER_RXFIE | RIER_RSTAT(1) | RIER_TSTAT(1));
    422346
    423347  return;
    424348
    425   }
     349}
    426350
    427351/*
    428352 * Unmask MPC5x00 MSCAN_A interrupts
    429353 */
    430 void mpc5200_mscan_a_on(const rtems_irq_connect_data* ptr)
    431   {
    432   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_A])->regs;
    433 
    434   mpc5200_mscan_int_enable(mscan);
     354void mpc5200_mscan_a_on(const rtems_irq_connect_data * ptr)
     355{
     356  mscan *m = (&chan_info[MSCAN_A])->regs;
     357
     358  mscan_interrupts_enable(m);
    435359
    436360  return;
    437361
    438   }
    439 
     362}
    440363
    441364/*
    442365 * Mask MPC5x00 MSCAN_A interrupts
    443366 */
    444 void mpc5200_mscan_a_off(const rtems_irq_connect_data* ptr)
    445   {
    446   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_A])->regs;
    447 
    448   mpc5200_mscan_int_disable(mscan);
     367void mpc5200_mscan_a_off(const rtems_irq_connect_data * ptr)
     368{
     369  mscan *m = (&chan_info[MSCAN_A])->regs;
     370
     371  mscan_interrupts_disable(m);
    449372
    450373  return;
    451374
    452   }
    453 
     375}
    454376
    455377/*
    456378 *  Get MSCAN_A interrupt mask setting
    457379 */
    458 int mpc5200_mscan_a_isOn(const rtems_irq_connect_data* ptr)
    459   {
    460   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_A])->regs;
    461 
    462   if((mscan->rier & RIER_CSCIE) && (mscan->rier & RIER_RXFIE))
     380int mpc5200_mscan_a_isOn(const rtems_irq_connect_data * ptr)
     381{
     382  mscan *m = (&chan_info[MSCAN_A])->regs;
     383
     384  if ((m->rier & RIER_CSCIE) && (m->rier & RIER_RXFIE))
    463385    return RTEMS_SUCCESSFUL;
    464386  else
     
    467389  return RTEMS_SUCCESSFUL;
    468390
    469   }
    470 
     391}
    471392
    472393/*
    473394 * Unmask MPC5x00 MSCAN_B interrupts
    474395 */
    475 void mpc5200_mscan_b_on(const rtems_irq_connect_data* ptr)
    476   {
    477   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_B])->regs;
    478 
    479   mpc5200_mscan_int_enable(mscan);
     396void mpc5200_mscan_b_on(const rtems_irq_connect_data * ptr)
     397{
     398  mscan *m = (&chan_info[MSCAN_B])->regs;
     399
     400  mscan_interrupts_enable(m);
    480401
    481402  return;
    482403
    483   }
    484 
     404}
    485405
    486406/*
    487407 * Mask MPC5x00 MSCAN_B interrupts
    488408 */
    489 void mpc5200_mscan_b_off(const rtems_irq_connect_data* ptr)
    490   {
    491   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_B])->regs;
    492 
    493   mpc5200_mscan_int_disable(mscan);
     409void mpc5200_mscan_b_off(const rtems_irq_connect_data * ptr)
     410{
     411  mscan *m = (&chan_info[MSCAN_B])->regs;
     412
     413  mscan_interrupts_disable(m);
    494414
    495415  return;
    496416
    497   }
    498 
     417}
    499418
    500419/*
    501420 *  Get MSCAN_B interrupt mask setting
    502421 */
    503 int mpc5200_mscan_b_isOn(const rtems_irq_connect_data* ptr)
    504   {
    505   volatile struct mpc5200_mscan *mscan = (&chan_info[MSCAN_B])->regs;
    506 
    507   if((mscan->rier & RIER_CSCIE) && (mscan->rier & RIER_RXFIE))
     422int mpc5200_mscan_b_isOn(const rtems_irq_connect_data * ptr)
     423{
     424  mscan *m = (&chan_info[MSCAN_B])->regs;
     425
     426  if ((m->rier & RIER_CSCIE) && (m->rier & RIER_RXFIE))
    508427    return RTEMS_SUCCESSFUL;
    509428  else
     
    512431  return RTEMS_SUCCESSFUL;
    513432
    514   }
    515 
    516 static mscan_handle mscan_a_handle =
    517   {
     433}
     434
     435static mscan_handle mscan_a_handle = {
    518436  MSCAN_A,
    519437  NULL
    520   };
    521 
    522 
    523 static mscan_handle mscan_b_handle =
    524   {
     438};
     439
     440static mscan_handle mscan_b_handle = {
    525441  MSCAN_B,
    526442  NULL
    527   };
     443};
    528444
    529445/*
    530446 * MPC5x00 MSCAN_A/_B irq data
    531447 */
    532 static rtems_irq_connect_data mpc5200_mscan_irq_data[MPC5200_CAN_NO] =
    533   {{
    534   BSP_SIU_IRQ_MSCAN1,
    535   (rtems_irq_hdl) mpc5200_mscan_interrupt_handler,
    536   (rtems_irq_hdl_param) &mscan_a_handle,
    537   (rtems_irq_enable) mpc5200_mscan_a_on,
    538   (rtems_irq_disable) mpc5200_mscan_a_off,
    539   (rtems_irq_is_enabled) mpc5200_mscan_a_isOn
    540   },
     448static rtems_irq_connect_data mpc5200_mscan_irq_data[MPC5200_CAN_NO] = {
    541449  {
    542   BSP_SIU_IRQ_MSCAN2,
    543   (rtems_irq_hdl) mpc5200_mscan_interrupt_handler,
    544   (rtems_irq_hdl_param) &mscan_b_handle,
    545   (rtems_irq_enable) mpc5200_mscan_b_on,
    546   (rtems_irq_disable) mpc5200_mscan_b_off,
    547   (rtems_irq_is_enabled) mpc5200_mscan_b_isOn
    548   }};
    549 
    550 
    551 /*
    552  * Enter MSCAN sleep mode
    553  */
    554 void mpc5200_mscan_enter_sleep_mode(volatile struct mpc5200_mscan *mscan)
    555   {
    556 
    557   /* Control Register 0 --------------------------------------------*/
    558   /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    559   /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
    560   /*    [05]:CSWAI       0 : CAN Stops in Wait Mode                 */
    561   /*    [04]:SYNCH       0 : Synchronized, Status Bit (rd. only)    */
    562   /*    [03]:TIME        1 : Generate Timestamps                    */
    563   /*    [02]:WUPE        1 : WakeUp Enabled                         */
    564   /*    [01]:SLPRQ    0->1 : Sleep Mode Request                     */
    565   /*    [00]:INITRQ      0 : No init. Mode Request                  */
    566   /* select sleep mode */
    567   mscan->ctl0 |= (CTL0_SLPRQ);
    568 
    569   /* Control Register 1 --------------------------------------------*/
    570   /*    [07]:CANE        0 : MSCAN Module is disabled               */
    571   /*    [06]:CLKSRC      1 : Clock Source -> IPB-Clock (33 MHz)     */
    572   /*    [05]:LOOPB       0 : No Loopback                            */
    573   /*    [04]:LISTEN      0 : Normal Operation                       */
    574   /*    [03]:res         0 : reserved                               */
    575   /*    [02]:WUPM        0 : No protect. from spurious WakeUp       */
    576   /*    [01]:SLPAK    0->1 : Sleep Mode Acknowledge (rd. only)      */
    577   /*    [00]:INITAK      0 : Init. Mode Acknowledge (rd. only)      */
    578   /* wait for sleep mode acknowledge */
    579   while(!(mscan->ctl1 & CTL1_SLPAK));
    580 
    581   return;
    582 
    583   }
    584 
    585 
    586 /*
    587  * Exit MSCAN sleep mode
    588  */
    589 void mpc5200_mscan_exit_sleep_mode(volatile struct mpc5200_mscan *mscan)
    590   {
    591 
    592   /* Control Register 0 --------------------------------------------*/
    593   /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    594   /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
    595   /*    [05]:CSWAI       0 : CAN Stops in Wait Mode                 */
    596   /*    [04]:SYNCH       0 : Synchronized, Status Bit (rd. only)    */
    597   /*    [03]:TIME        1 : Generate Timestamps                    */
    598   /*    [02]:WUPE        1 : WakeUp Enabled                         */
    599   /*    [01]:SLPRQ    0->1 : Sleep Mode Request                     */
    600   /*    [00]:INITRQ      0 : No init. Mode Request                  */
    601   /* select sleep mode */
    602   mscan->ctl0 &= ~(CTL0_SLPRQ);
    603 
    604   /* Control Register 1 --------------------------------------------*/
    605   /*    [07]:CANE        0 : MSCAN Module is disabled               */
    606   /*    [06]:CLKSRC      1 : Clock Source -> IPB-Clock (33 MHz)     */
    607   /*    [05]:LOOPB       0 : No Loopback                            */
    608   /*    [04]:LISTEN      0 : Normal Operation                       */
    609   /*    [03]:res         0 : reserved                               */
    610   /*    [02]:WUPM        0 : No protect. from spurious WakeUp       */
    611   /*    [01]:SLPAK    0->1 : Sleep Mode Acknowledge (rd. only)      */
    612   /*    [00]:INITAK      0 : Init. Mode Acknowledge (rd. only)      */
    613   /* wait for sleep mode acknowledge */
    614   while((mscan->ctl1 & CTL1_SLPAK));
    615 
    616   return;
    617 
    618   }
    619 
    620 
    621 /*
    622  * Enter MSCAN init mode and disconnect from bus
    623  */
    624 void mpc5200_mscan_enter_init_mode(volatile struct mpc5200_mscan *mscan)
    625   {
    626 
    627   /* Control Register 0 --------------------------------------------*/
    628   /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    629   /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
    630   /*    [05]:CSWAI       0 : CAN Stops in Wait Mode                 */
    631   /*    [04]:SYNCH       0 : Synchronized, Status Bit (rd. only)    */
    632   /*    [03]:TIME        1 : Generate Timestamps                    */
    633   /*    [02]:WUPE        0 : WakeUp disabled                        */
    634   /*    [01]:SLPRQ       0 : No Sleep Mode Request                  */
    635   /*    [00]:INITRQ   0->1 : Init. Mode Request                     */
    636   /* select init mode */
    637   mscan->ctl0 |= (CTL0_INITRQ);
    638 
    639   /* Control Register 1 --------------------------------------------*/
    640   /*    [07]:CANE        0 : MSCAN Module is disabled               */
    641   /*    [06]:CLKSRC      1 : Clock Source -> IPB-Clock (33 MHz)     */
    642   /*    [05]:LOOPB       0 : No Loopback                            */
    643   /*    [04]:LISTEN      0 : Normal Operation                       */
    644   /*    [03]:res         0 : reserved                               */
    645   /*    [02]:WUPM        0 : No protect. from spurious WakeUp       */
    646   /*    [01]:SLPAK       0 : Sleep Mode Acknowledge (rd. only)      */
    647   /*    [00]:INITAK   0->1 : Init. Mode Acknowledge (rd. only)      */
    648   /* wait for init mode acknowledge */
    649   while(!(mscan->ctl1 & CTL1_INITAK));
    650 
    651   return;
    652 
    653   }
    654 
    655 
    656 /*
    657  * Exit MSCAN init mode
    658  */
    659 void mpc5200_mscan_exit_init_mode(volatile struct mpc5200_mscan *mscan)
    660   {
    661 
    662   /* Control Register 0 --------------------------------------------*/
    663   /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    664   /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
    665   /*    [05]:CSWAI       0 : CAN Stops in Wait Mode                 */
    666   /*    [04]:SYNCH       0 : Synchronized, Status Bit (rd. only)    */
    667   /*    [03]:TIME        1 : Generate Timestamps                    */
    668   /*    [02]:WUPE        0 : WakeUp Disabled                        */
    669   /*    [01]:SLPRQ       0 : No Sleep Mode Request                  */
    670   /*    [00]:INITRQ   1->0 : Init. Mode Request                     */
    671   /* select normal mode */
    672   mscan->ctl0 &= ~(CTL0_INITRQ);
    673 
    674   /* Control Register 1 --------------------------------------------*/
    675   /*    [07]:CANE        0 : MSCAN Module is disabled               */
    676   /*    [06]:CLKSRC      1 : Clock Source -> IPB-Clock (33 MHz)     */
    677   /*    [05]:LOOPB       0 : No Loopback                            */
    678   /*    [04]:LISTEN      0 : Normal Operation                       */
    679   /*    [03]:res         0 : reserved                               */
    680   /*    [02]:WUPM        0 : No protect. from spurious WakeUp       */
    681   /*    [01]:SLPAK       0 : Sleep Mode Acknowledge (rd. only)      */
    682   /*    [00]:INITAK   1->0 : Init. Mode Acknowledge (rd. only)      */
    683   /* wait for normal mode acknowledge */
    684   while(mscan->ctl1 & CTL1_INITAK);
    685 
    686   return;
    687 
    688   }
    689 
     450    BSP_SIU_IRQ_MSCAN1,
     451    (rtems_irq_hdl) mpc5200_mscan_interrupt_handler,
     452    (rtems_irq_hdl_param) & mscan_a_handle,
     453    (rtems_irq_enable) mpc5200_mscan_a_on,
     454    (rtems_irq_disable) mpc5200_mscan_a_off,
     455    (rtems_irq_is_enabled) mpc5200_mscan_a_isOn
     456  }, {
     457    BSP_SIU_IRQ_MSCAN2,
     458    (rtems_irq_hdl) mpc5200_mscan_interrupt_handler,
     459    (rtems_irq_hdl_param) & mscan_b_handle,
     460    (rtems_irq_enable) mpc5200_mscan_b_on,
     461    (rtems_irq_disable) mpc5200_mscan_b_off,
     462    (rtems_irq_is_enabled) mpc5200_mscan_b_isOn
     463  }
     464};
    690465
    691466/*
    692467 * MPC5x00 MSCAN wait for sync. with CAN bus
    693468 */
    694 void mpc5200_mscan_wait_sync(volatile struct mpc5200_mscan *mscan)
    695   {
    696 
    697   /* Control Register 0 --------------------------------------------*/
     469void mpc5200_mscan_wait_sync(mscan *m)
     470{
     471
     472  /* Control Register 0 -------------------------------------------- */
    698473  /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    699474  /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
     
    706481  /* wait for MSCAN A_/_B bus synch. */
    707482
    708 #if 0 /* we don't have a need to wait for sync. */
    709   while(!((mscan->ctl0) & CTL0_SYNCH));
     483#if 0                           /* we don't have a need to wait for sync. */
     484  while (!((m->ctl0) & CTL0_SYNCH));
    710485#endif
    711486  return;
    712487
    713   }
    714 
    715 /* calculate the can clock prescaler value */
    716 uint8_t prescaler_calculation(uint32_t can_bit_rate, uint32_t can_clock_frq, uint8_t *tq_no) {
    717 
    718 /* local variables */
    719 uint8_t presc_val, tq_no_dev_min = 0;
    720 uint32_t bit_rate, bit_rate_dev, frq_tq, bit_rate_dev_min = 0xFFFFFFFF;
    721 
    722 /* loop through all values of time quantas */
    723 for(*tq_no = CAN_MAX_NO_OF_TQ; *tq_no >= MIN_NO_OF_TQ; (*tq_no)--) {
    724 
    725   /* calculate time quanta freq. */
    726   frq_tq = *tq_no * can_bit_rate;
    727 
    728   /* calculate the optimized prescal. val. */
    729   presc_val = (can_clock_frq+frq_tq/2)/frq_tq;
    730 
    731   /* calculate the bitrate */
    732   bit_rate = can_clock_frq/(*tq_no * presc_val);
    733 
    734   /* calculate the bitrate deviation */
    735   if(can_bit_rate >= bit_rate)
    736     {
    737     /* calculate the bitrate deviation */
    738     bit_rate_dev = can_bit_rate - bit_rate;
    739     }
    740   else
    741     {
    742     /* calculate the bitrate deviation */
    743     bit_rate_dev = bit_rate - can_bit_rate;
    744     }
    745 
    746   /* check the deviation freq. */
    747   if(bit_rate_dev == 0) {
    748 
    749     /* return if best match (zero deviation) */
    750    return (uint8_t)(presc_val);
    751     }
    752   else
    753     {
    754 
    755     /* check for minimum of bit rate deviation */
    756     if(bit_rate_dev < bit_rate_dev_min) {
    757 
    758       /* recognize the minimum freq. deviation */
    759       bit_rate_dev_min = bit_rate_dev;
    760 
    761       /* recognize the no. of time quantas */
    762       tq_no_dev_min = *tq_no;
    763           }
    764         }
    765   }
    766 
    767   /* get the no of tq's */
    768   *tq_no = tq_no_dev_min;
    769 
    770   /* calculate time quanta freq. */
    771   frq_tq = *tq_no * can_bit_rate;
    772 
    773   /* return the optimized prescaler value */
    774   return (uint8_t)((can_clock_frq+frq_tq/2)/frq_tq);
    775 }
    776 
    777 /*
    778  * MPC5x00 MSCAN set up the bit timing
    779  */
    780 void mpc5200_mscan_perform_bit_time_settings(volatile struct mpc5200_mscan *mscan, uint32_t can_bit_rate, uint32_t can_clock_frq)
    781 {
    782   uint32_t prescale_val = 0;
    783   uint8_t tq_no, tseg_1, tseg_2, sseg;
    784 
    785   /* get optimized prescaler value */
    786   prescale_val = prescaler_calculation(can_bit_rate, can_clock_frq, &tq_no);
    787 
    788   /* get time segment length from time segment table */
    789   tseg_1 = can_time_segment_table[tq_no - MIN_NO_OF_TQ][TSEG_1];
    790   tseg_2 = can_time_segment_table[tq_no - MIN_NO_OF_TQ][TSEG_2];
    791   sseg    = can_time_segment_table[tq_no - MIN_NO_OF_TQ][SJW];
    792 
    793   /* Bus Timing Register 0 MSCAN_A/_B ------------------------------*/
    794   /*    [07]:SJW1        1 : Synchronization jump width, Bit1       */
    795   /*    [06]:SJW0        0 : Synchronization jump width, Bit0       */
    796   /*                         SJW = 2 -> 3 Tq clock cycles           */
    797   /*    [05]:BRP5        0 : Baud Rate Prescaler, Bit 5             */
    798   /*    [04]:BRP4        0 : Baud Rate Prescaler, Bit 4             */
    799   /*    [03]:BRP3        0 : Baud Rate Prescaler, Bit 3             */
    800   /*    [02]:BRP2        1 : Baud Rate Prescaler, Bit 2             */
    801   /*    [01]:BRP1        0 : Baud Rate Prescaler, Bit 1             */
    802   /*    [00]:BRP0        1 : Baud Rate Prescaler, Bit 0             */
    803   mscan->btr0 = (BTR0_SJW(sseg-1) | BTR0_BRP(prescale_val-1));
    804 
    805   /* Bus Timing Register 1 MSCAN_A/_B ------------------------------*/
    806   /*    [07]:SAMP        0 : One Sample per bit                     */
    807   /*    [06]:TSEG22      0 : Time Segment 2, Bit 2                  */
    808   /*    [05]:TSEG21      1 : Time Segment 2, Bit 1                  */
    809   /*    [04]:TSEG20      0 : Time Segment 2, Bit 0                  */
    810   /*                         -> PHASE_SEG2 = 3 Tq                   */
    811   /*    [03]:TSEG13      0 : Time Segment 1, Bit 3                  */
    812   /*    [02]:TSEG12      1 : Time Segment 1, Bit 2                  */
    813   /*    [01]:TSEG11      1 : Time Segment 1, Bit 1                  */
    814   /*    [00]:TSEG10      0 : Time Segment 1, Bit 0                  */
    815   mscan->btr1 =  (BTR1_TSEG_22_20(tseg_2-1) | BTR1_TSEG_13_10(tseg_1-1));
    816 
    817   return;
    818 
    819   }
    820 
     488}
    821489
    822490/*
    823491 * MPC5x00 MSCAN perform settings in init mode
    824492 */
    825 void mpc5200_mscan_perform_init_mode_settings(volatile struct mpc5200_mscan *mscan)
    826   {
     493void mpc5200_mscan_perform_initialization_mode_settings(mscan *m)
     494{
     495  mscan_context context;
    827496
    828497  /* perform all can bit time settings */
    829   mpc5200_mscan_perform_bit_time_settings(mscan,CAN_BIT_RATE,IPB_CLOCK);
    830 
    831   /* Control Register 1 --------------------------------------------*/
     498  mscan_set_bit_rate(m, CAN_BIT_RATE);
     499
     500  /* Enter initialization mode */
     501  mscan_initialization_mode_enter( m, &context);
     502
     503  /* Control Register 1 -------------------------------------------- */
    832504  /*    [07]:CANE        0 : MSCAN Module is disabled               */
    833505  /*    [06]:CLKSRC      0 : Clock Source -> IPB_CLOCK (bsp.h)      */
     
    840512  /* Set CLK source, disable loopback & listen-only mode */
    841513#ifndef MSCAN_LOOPBACK
    842   mscan->ctl1 &= ~(CTL1_LISTEN | CTL1_LOOPB | CTL1_CLKSRC);
     514  m->ctl1 &= ~(CTL1_LISTEN | CTL1_LOOPB | CTL1_CLKSRC);
    843515#else
    844   mscan->ctl1 &= ~(CTL1_LISTEN | CTL1_CLKSRC);
    845   mscan->ctl1 |= (CTL1_LOOPB);
     516  m->ctl1 &= ~(CTL1_LISTEN | CTL1_CLKSRC);
     517  m->ctl1 |= (CTL1_LOOPB);
    846518#endif
    847519
    848   /* IPB clock                  -> IPB_CLOCK (bsp.h)                                                    */
    849   /* bitrate                    -> CAN_BIT_RATE (mscan.h)                                               */
    850   /* Max. no of Tq              -> CAN_MAX_NO_OF_TQ (mscan.h)                                           */
    851   /* Prescaler value            -> prescale_val = ROUND_UP(IPB_CLOCK/(CAN_BIT_RATE * CAN_MAX_NO_OF_TQ)) */
    852   /* SYNC_SEG                   ->  1 tq                                                                */
    853   /* time segment 1             -> 16 tq (PROP_SEG+PHASE_SEG), CAN_MAX_NO_OF_TQ_TSEG1 = 15 (mscan.h)    */
    854   /* time segment 2             ->  8 tq (PHASE_SEG2)        , CAN_MAX_NO_OF_TQ_TSEG2 =  7 (mscan.h)    */
    855   /* SJW                        ->  3 (fixed 0...3)          , CAN_MAX_NO_OF_TQ_SJW   =  2 (mscan.h)    */
    856 
    857   /* ID Acceptance Control MSCAN_A/_B ------------------------------*/
     520  /* IPB clock       -> IPB_CLOCK                                                            */
     521  /* bitrate         -> CAN_BIT_RATE                                                         */
     522  /* Max. no of Tq   -> CAN_MAX_NO_OF_TQ                                                     */
     523  /* Prescaler value -> prescale_val = ROUND_UP(IPB_CLOCK/(CAN_BIT_RATE * CAN_MAX_NO_OF_TQ)) */
     524  /* SYNC_SEG        ->  1 tq                                                                */
     525  /* time segment 1  -> 16 tq (PROP_SEG+PHASE_SEG), CAN_MAX_NO_OF_TQ_TSEG1 = 15              */
     526  /* time segment 2  ->  8 tq (PHASE_SEG2)        , CAN_MAX_NO_OF_TQ_TSEG2 =  7              */
     527  /* SJW             ->  3 (fixed 0...3)          , CAN_MAX_NO_OF_TQ_SJW   =  2              */
     528
     529  /* ID Acceptance Control MSCAN_A/_B ------------------------------ */
    858530  /*    [07]:res.        0 : reserved                               */
    859531  /*    [06]:res.        0 : reserved                               */
     
    865537  /*    [01]:IDHIT1      0 : ID acceptance hit indication, Bit 1    */
    866538  /*    [00]:IDHIT0      0 : ID acceptance hit indication, Bit 0    */
    867   mscan->idac &= ~(IDAC_IDAM1);
    868   mscan->idac |= (IDAC_IDAM0);
     539  m->idac &= ~(IDAC_IDAM1);
     540  m->idac |= (IDAC_IDAM0);
    869541
    870542  /* initialize rx filter masks (16 bit), don't care including rtr */
    871   mscan->idmr0 = SET_IDMR0(0x7FF);
    872   mscan->idmr1 = SET_IDMR1(0x7FF);
    873   mscan->idmr2 = SET_IDMR2(0x7FF);
    874   mscan->idmr3 = SET_IDMR3(0x7FF);
    875   mscan->idmr4 = SET_IDMR4(0x7FF);
    876   mscan->idmr5 = SET_IDMR5(0x7FF);
    877   mscan->idmr6 = SET_IDMR6(0x7FF);
    878   mscan->idmr7 = SET_IDMR7(0x7FF);
    879 
    880   /* Control Register 1 --------------------------------------------*/
     543  m->idmr0 = SET_IDMR0(0x7FF);
     544  m->idmr1 = SET_IDMR1(0x7FF);
     545  m->idmr2 = SET_IDMR2(0x7FF);
     546  m->idmr3 = SET_IDMR3(0x7FF);
     547  m->idmr4 = SET_IDMR4(0x7FF);
     548  m->idmr5 = SET_IDMR5(0x7FF);
     549  m->idmr6 = SET_IDMR6(0x7FF);
     550  m->idmr7 = SET_IDMR7(0x7FF);
     551
     552  /* Control Register 1 -------------------------------------------- */
    881553  /*    [07]:CANE     0->1 : MSCAN Module is enabled                */
    882554  /*    [06]:CLKSRC      1 : Clock Source -> IPB_CLOCK (bsp.h)      */
     
    888560  /*    [00]:INITAK      0 : Init. Mode Acknowledge (rd. only)      */
    889561  /* enable MSCAN A_/_B */
    890   mscan->ctl1 |= (CTL1_CANE);
     562  m->ctl1 |= (CTL1_CANE);
     563
     564  /* Leave initialization mode */
     565  mscan_initialization_mode_leave( m, &context);
    891566
    892567  return;
    893568
    894   }
    895 
     569}
    896570
    897571/*
    898572 * MPC5x00 MSCAN perform settings in normal mode
    899573 */
    900 void mpc5200_mscan_perform_normal_mode_settings(volatile struct mpc5200_mscan *mscan)
    901   {
    902 
    903   /* Control Register 0 --------------------------------------------*/
     574void mpc5200_mscan_perform_normal_mode_settings(mscan
     575                                                *m)
     576{
     577
     578  /* Control Register 0 -------------------------------------------- */
    904579  /*    [07]:RXFRM       0 : Recv. Frame, Flag Bit (rd.&clear only) */
    905580  /*    [06]:RXACT       0 : Recv. Active, Status Bit (rd. only)    */
     
    911586  /*    [00]:INITRQ      0 : No init. Mode Request                  */
    912587  /* Disable wait mode, enable timestamps */
    913   mscan->ctl0 &= ~(CTL0_CSWAI);
    914   mscan->ctl0 |= (CTL0_TIME);
     588  m->ctl0 &= ~(CTL0_CSWAI);
     589  m->ctl0 |= (CTL0_TIME);
    915590
    916591  return;
    917592
    918   }
    919 
    920 rtems_status_code mpc5200_mscan_set_mode(rtems_device_minor_number minor, uint8_t mode)
    921   {
     593}
     594
     595rtems_status_code mpc5200_mscan_set_mode(rtems_device_minor_number minor,
     596                                         uint8_t mode)
     597{
    922598  struct mscan_channel_info *chan = NULL;
    923   volatile struct mpc5200_mscan *mscan     = NULL;
    924 
    925   switch(minor)
    926     {
    927 
    928     case MSCAN_A:
    929     case MSCAN_B:
    930       chan  = &chan_info[minor];
    931       mscan = chan->regs;
    932       break;
    933 
    934     default:
    935       return RTEMS_UNSATISFIED;
    936       break;
    937     }
    938 
    939   if(chan->mode == mode)
    940     return RTEMS_SUCCESSFUL;
    941 
    942   switch(mode)
    943     {
    944 
    945     case MSCAN_INIT_NORMAL_MODE:
    946       /* if not already set enter init mode */
    947           mpc5200_mscan_enter_init_mode(mscan);
    948           /* perform initialization which has to be done in init mode */
    949       mpc5200_mscan_perform_init_mode_settings(mscan);
    950       break;
    951 
    952     case MSCAN_NORMAL_MODE:
    953       /* if not already set enter init mode */
    954       mpc5200_mscan_enter_init_mode(mscan);
    955 
    956       if((chan->mode) == MSCAN_INITIALIZED_MODE)
    957         {
    958 
    959         /* perform initialization which has to be done in init mode */
    960         mpc5200_mscan_perform_init_mode_settings(mscan);
    961             }
    962 
    963       if((chan->mode) == MSCAN_SLEEP_MODE)
    964         {
    965 
    966         /* exit sleep mode */
    967             mpc5200_mscan_exit_sleep_mode(mscan);
    968             }
    969 
    970       /* exit init mode */
    971       mpc5200_mscan_exit_init_mode(mscan);
    972       /* enable ints. */
    973       mpc5200_mscan_int_enable(mscan);
    974       /* wait for bus sync. */
    975       mpc5200_mscan_wait_sync(mscan);
    976       break;
    977 
    978     case MSCAN_SLEEP_MODE:
    979       /* disable ints. */
    980       mpc5200_mscan_int_disable(mscan);
    981       /* exit sleep mode */
    982           mpc5200_mscan_enter_sleep_mode(mscan);
    983       break;
    984 
    985     default:
    986       return RTEMS_UNSATISFIED;
    987       break;
    988 
    989     }
    990 
    991   /* set new channel mode */
    992   chan->mode = mode;
    993 
    994   return RTEMS_SUCCESSFUL;
    995 
    996   }
    997 
    998 
    999 /*
    1000  * initialization of channel info.
    1001  */
    1002 rtems_status_code mscan_channel_initialize(rtems_device_major_number major, rtems_device_minor_number minor)
    1003   {
    1004   rtems_status_code status;
    1005   struct mscan_channel_info *chan = &chan_info[minor];
    1006 
    1007 
    1008   /* set registers according to MSCAN channel information */
    1009   switch(minor)
    1010     {
    1011 
    1012     case MSCAN_A:
    1013       chan->rx_qname = rtems_build_name ('C', 'N', 'A', 'Q');
    1014       chan->tx_rb_sname = rtems_build_name ('C', 'N', 'A', 'S');
    1015 
    1016       /* register RTEMS device names for MSCAN A */
    1017       if((status = rtems_io_register_name (MSCAN_A_DEV_NAME, major, MSCAN_A)) != RTEMS_SUCCESSFUL)
    1018             return status;
    1019 
    1020       /* register RTEMS device names for MSCAN 0 */
    1021       if((status = rtems_io_register_name (MSCAN_0_DEV_NAME, major, MSCAN_A)) != RTEMS_SUCCESSFUL)
    1022             return status;
    1023 
    1024           /* allocate the space for MSCAN A tx ring buffer */
    1025           if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*(NO_OF_MSCAN_TX_BUFF+1))) != NULL)
    1026             {
    1027         chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
    1028             }
    1029           else
    1030             {
    1031                 return RTEMS_UNSATISFIED;
    1032             }
    1033       break;
    1034 
    1035     case MSCAN_B:
    1036           chan->rx_qname = rtems_build_name ('C', 'N', 'B', 'Q');
    1037       chan->tx_rb_sname = rtems_build_name ('C', 'N', 'B', 'S');
    1038 
    1039           /* register RTEMS device names for MSCAN B */
    1040           if((status = rtems_io_register_name (MSCAN_B_DEV_NAME, major, MSCAN_B)) != RTEMS_SUCCESSFUL)
    1041             return status;
    1042 
    1043       /* register RTEMS device names for MSCAN 1 */
    1044           if((status = rtems_io_register_name (MSCAN_1_DEV_NAME, major, MSCAN_B)) != RTEMS_SUCCESSFUL)
    1045             return status;
    1046 
    1047       /* allocate the space for MSCAN B tx ring buffer */
    1048           if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*(NO_OF_MSCAN_TX_BUFF+1))) != NULL)
    1049             {
    1050                 chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
    1051             }
    1052           else
    1053             {
    1054                 return RTEMS_UNSATISFIED;
    1055             }
    1056       break;
    1057 
    1058     default:
    1059       return RTEMS_UNSATISFIED;
    1060       break;
    1061     }
    1062 
    1063   /* create RTEMS rx message queue */
    1064   status = rtems_message_queue_create(chan->rx_qname,
    1065                                              (uint32_t) NO_OF_MSCAN_RX_BUFF,
    1066                                              (uint32_t) MSCAN_MESSAGE_SIZE(sizeof(struct can_message)),
    1067                                              (rtems_attribute) RTEMS_LOCAL | RTEMS_FIFO,
    1068                                              (rtems_id *)&(chan->rx_qid));
    1069 
    1070   /* create counting RTEMS tx ring buffer semaphore */
    1071   status = rtems_semaphore_create(chan->tx_rb_sname,
    1072                                  (uint32_t)(NO_OF_MSCAN_TX_BUFF),
    1073                                   RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
    1074                                  (rtems_task_priority)0,
    1075                                  (rtems_id *)&(chan->tx_rb_sid));
    1076 
    1077   /* Set up interrupts */
    1078   if(!BSP_install_rtems_irq_handler(&(mpc5200_mscan_irq_data[minor])))
    1079     rtems_panic("Can't attach MPC5x00 MSCAN interrupt handler %d\n", minor);
    1080 
    1081   /* basic setup for channel info. struct. */
    1082   chan->regs           = (struct mpc5200_mscan *)&(mpc5200.mscan[minor]);
    1083   chan->int_rx_err     = 0;
    1084   chan->id_extended    = FALSE;
    1085   chan->mode           = MSCAN_INITIALIZED_MODE;
    1086   chan->tx_buf_no      = NO_OF_MSCAN_TX_BUFF;
    1087 
    1088   return status;
    1089 
    1090   }
    1091 
    1092 
    1093 /*
    1094  * MPC5x00 MSCAN device initialization
    1095  */
    1096 rtems_device_driver mscan_initialize(rtems_device_major_number major,
    1097                                      rtems_device_minor_number minor,
    1098                                      void *arg
    1099                                     )
    1100   {
    1101   rtems_status_code status;
    1102 
    1103   /* Initialization requested via RTEMS */
    1104   if((status = mscan_channel_initialize(major,MSCAN_A)) != RTEMS_SUCCESSFUL)
    1105     rtems_fatal_error_occurred(status);
    1106 
    1107   if((status = mscan_channel_initialize(major,MSCAN_B)) != RTEMS_SUCCESSFUL)
    1108     rtems_fatal_error_occurred(status);
    1109 
    1110   if((status = mpc5200_mscan_set_mode(MSCAN_A, MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
    1111     rtems_fatal_error_occurred(status);
    1112 
    1113   if((status = mpc5200_mscan_set_mode(MSCAN_B, MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
    1114     rtems_fatal_error_occurred(status);
    1115 
    1116   return status;
    1117 
    1118   }
    1119 
    1120 
    1121 /*
    1122  * MPC5x00 MSCAN device open
    1123  */
    1124 rtems_device_driver mscan_open( rtems_device_major_number major,
    1125                                  rtems_device_minor_number minor,
    1126                                  void * arg
    1127                                )
    1128   {
    1129   rtems_status_code status = RTEMS_SUCCESSFUL;
    1130   struct mscan_channel_info *chan = NULL;
    1131 
    1132   switch(minor)
    1133     {
     599  mscan *m = NULL;
     600
     601  switch (minor) {
    1134602
    1135603    case MSCAN_A:
    1136604    case MSCAN_B:
    1137605      chan = &chan_info[minor];
     606      m = chan->regs;
    1138607      break;
    1139608
     
    1141610      return RTEMS_UNSATISFIED;
    1142611      break;
    1143     }
    1144 
     612  }
     613
     614  if (chan->mode == mode)
     615    return RTEMS_SUCCESSFUL;
     616
     617  switch (mode) {
     618
     619    case MSCAN_INIT_NORMAL_MODE:
     620      /* perform initialization which has to be done in init mode */
     621      mpc5200_mscan_perform_initialization_mode_settings(m);
     622      break;
     623
     624    case MSCAN_NORMAL_MODE:
     625      if ((chan->mode) == MSCAN_INITIALIZED_MODE) {
     626        /* perform initialization which has to be done in init mode */
     627        mpc5200_mscan_perform_initialization_mode_settings(m);
     628      }
     629
     630      if ((chan->mode) == MSCAN_SLEEP_MODE) {
     631
     632        /* exit sleep mode */
     633        mscan_sleep_mode_leave(m);
     634      }
     635      /* enable ints. */
     636      mscan_interrupts_enable(m);
     637      /* wait for bus sync. */
     638      mpc5200_mscan_wait_sync(m);
     639      break;
     640
     641    case MSCAN_SLEEP_MODE:
     642      /* disable ints. */
     643      mscan_interrupts_disable(m);
     644      /* knter sleep mode */
     645      mscan_sleep_mode_enter(m);
     646      break;
     647
     648    default:
     649      return RTEMS_UNSATISFIED;
     650      break;
     651
     652  }
     653
     654  /* set new channel mode */
     655  chan->mode = mode;
     656
     657  return RTEMS_SUCCESSFUL;
     658
     659}
     660
     661/*
     662 * initialization of channel info.
     663 */
     664rtems_status_code mscan_channel_initialize(rtems_device_major_number major,
     665                                           rtems_device_minor_number minor)
     666{
     667  rtems_status_code status;
     668  struct mscan_channel_info *chan = &chan_info[minor];
     669
     670  /* set registers according to MSCAN channel information */
     671  switch (minor) {
     672
     673    case MSCAN_A:
     674      chan->rx_qname = rtems_build_name('C', 'N', 'A', 'Q');
     675      chan->tx_rb_sname = rtems_build_name('C', 'N', 'A', 'S');
     676
     677      /* register RTEMS device names for MSCAN A */
     678      if ((status =
     679           rtems_io_register_name(MSCAN_A_DEV_NAME, major,
     680                                  MSCAN_A)) != RTEMS_SUCCESSFUL)
     681        return status;
     682
     683      /* register RTEMS device names for MSCAN 0 */
     684      if ((status =
     685           rtems_io_register_name(MSCAN_0_DEV_NAME, major,
     686                                  MSCAN_A)) != RTEMS_SUCCESSFUL)
     687        return status;
     688
     689      /* allocate the space for MSCAN A tx ring buffer */
     690      if (((chan->tx_ring_buf.buf_ptr) =
     691           malloc(sizeof (struct can_message) * (NO_OF_MSCAN_TX_BUFF + 1))) !=
     692          NULL) {
     693        chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr =
     694          chan->tx_ring_buf.buf_ptr;
     695      } else {
     696        return RTEMS_UNSATISFIED;
     697      }
     698      break;
     699
     700    case MSCAN_B:
     701      chan->rx_qname = rtems_build_name('C', 'N', 'B', 'Q');
     702      chan->tx_rb_sname = rtems_build_name('C', 'N', 'B', 'S');
     703
     704      /* register RTEMS device names for MSCAN B */
     705      if ((status =
     706           rtems_io_register_name(MSCAN_B_DEV_NAME, major,
     707                                  MSCAN_B)) != RTEMS_SUCCESSFUL)
     708        return status;
     709
     710      /* register RTEMS device names for MSCAN 1 */
     711      if ((status =
     712           rtems_io_register_name(MSCAN_1_DEV_NAME, major,
     713                                  MSCAN_B)) != RTEMS_SUCCESSFUL)
     714        return status;
     715
     716      /* allocate the space for MSCAN B tx ring buffer */
     717      if (((chan->tx_ring_buf.buf_ptr) =
     718           malloc(sizeof (struct can_message) * (NO_OF_MSCAN_TX_BUFF + 1))) !=
     719          NULL) {
     720        chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr =
     721          chan->tx_ring_buf.buf_ptr;
     722      } else {
     723        return RTEMS_UNSATISFIED;
     724      }
     725      break;
     726
     727    default:
     728      return RTEMS_UNSATISFIED;
     729      break;
     730  }
     731
     732  /* create RTEMS rx message queue */
     733  status =
     734    rtems_message_queue_create(chan->rx_qname, (uint32_t) NO_OF_MSCAN_RX_BUFF,
     735                               (uint32_t)
     736                               MSCAN_MESSAGE_SIZE(sizeof (struct can_message)),
     737                               (rtems_attribute) RTEMS_LOCAL | RTEMS_FIFO,
     738                               (rtems_id *) & (chan->rx_qid));
     739
     740  /* create counting RTEMS tx ring buffer semaphore */
     741  status =
     742    rtems_semaphore_create(chan->tx_rb_sname, (uint32_t) (NO_OF_MSCAN_TX_BUFF),
     743                           RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
     744                           | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
     745                           (rtems_task_priority) 0,
     746                           (rtems_id *) & (chan->tx_rb_sid));
     747
     748  /* Set up interrupts */
     749  if (!BSP_install_rtems_irq_handler(&(mpc5200_mscan_irq_data[minor])))
     750    rtems_panic("Can't attach MPC5x00 MSCAN interrupt handler %d\n", minor);
     751
     752  /* basic setup for channel info. struct. */
     753  chan->regs = (mscan *) &(mpc5200.mscan[minor]);
     754  chan->int_rx_err = 0;
     755  chan->id_extended = FALSE;
     756  chan->mode = MSCAN_INITIALIZED_MODE;
     757  chan->tx_buf_no = NO_OF_MSCAN_TX_BUFF;
     758
     759  return status;
     760
     761}
     762
     763/*
     764 * MPC5x00 MSCAN device initialization
     765 */
     766rtems_device_driver mscan_initialize(rtems_device_major_number major,
     767                                     rtems_device_minor_number minor, void *arg)
     768{
     769  rtems_status_code status;
     770
     771  /* Initialization requested via RTEMS */
     772  if ((status = mscan_channel_initialize(major, MSCAN_A)) != RTEMS_SUCCESSFUL)
     773    rtems_fatal_error_occurred(status);
     774
     775  if ((status = mscan_channel_initialize(major, MSCAN_B)) != RTEMS_SUCCESSFUL)
     776    rtems_fatal_error_occurred(status);
     777
     778  if ((status =
     779       mpc5200_mscan_set_mode(MSCAN_A,
     780                              MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
     781    rtems_fatal_error_occurred(status);
     782
     783  if ((status =
     784       mpc5200_mscan_set_mode(MSCAN_B,
     785                              MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
     786    rtems_fatal_error_occurred(status);
     787
     788  return status;
     789
     790}
     791
     792/*
     793 * MPC5x00 MSCAN device open
     794 */
     795rtems_device_driver mscan_open(rtems_device_major_number major,
     796                               rtems_device_minor_number minor, void *arg)
     797{
     798  rtems_status_code status = RTEMS_SUCCESSFUL;
     799  struct mscan_channel_info *chan = NULL;
     800
     801  switch (minor) {
     802
     803    case MSCAN_A:
     804    case MSCAN_B:
     805      chan = &chan_info[minor];
     806      break;
     807
     808    default:
     809      return RTEMS_UNSATISFIED;
     810      break;
     811  }
    1145812
    1146813  /* check mode */
    1147   if((chan->mode) == MSCAN_SLEEP_MODE)
    1148     {
     814  if ((chan->mode) == MSCAN_SLEEP_MODE) {
    1149815
    1150816    /* if not already set enter init mode */
    1151817    status = mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
    1152     }
     818  }
    1153819
    1154820  return status;
    1155821
    1156   }
    1157 
     822}
    1158823
    1159824/*
    1160825 * MPC5x00 MSCAN device close
    1161826 */
    1162 rtems_device_driver mscan_close( rtems_device_major_number major,
    1163                                   rtems_device_minor_number minor,
    1164                                   void * arg
    1165                                 )
    1166   {
     827rtems_device_driver mscan_close(rtems_device_major_number major,
     828                                rtems_device_minor_number minor, void *arg)
     829{
    1167830  rtems_status_code status;
    1168831  struct mscan_channel_info *chan = NULL;
    1169832
    1170   switch(minor)
    1171     {
     833  switch (minor) {
    1172834
    1173835    case MSCAN_A:
    1174836    case MSCAN_B:
    1175           chan = &chan_info[minor];
     837      chan = &chan_info[minor];
    1176838      break;
    1177839
     
    1179841      return RTEMS_UNSATISFIED;
    1180842      break;
    1181     }
     843  }
    1182844
    1183845  /* enter deep sleep mode */
     
    1186848  return status;
    1187849
    1188   }
    1189 
     850}
    1190851
    1191852/*
    1192853 * MPC5x00 MSCAN device read
    1193854 */
    1194 rtems_device_driver mscan_read( rtems_device_major_number major,
    1195                                  rtems_device_minor_number minor,
    1196                                  void * arg
    1197                                )
    1198   {
    1199   rtems_status_code          status;
    1200   size_t                     message_size = 0;
    1201   rtems_libio_rw_args_t     *parms       = (rtems_libio_rw_args_t *)arg;
    1202   struct mscan_rx_parms     *rx_parms    = (struct mscan_rx_parms *)(parms->buffer);
    1203   struct can_message        *rx_mess     = (struct can_message *)(rx_parms->rx_mess);
    1204   struct mscan_channel_info *chan        = NULL;
    1205 
    1206   switch(minor)
    1207     {
     855rtems_device_driver mscan_read(rtems_device_major_number major,
     856                               rtems_device_minor_number minor, void *arg)
     857{
     858  rtems_status_code status;
     859  size_t message_size = 0;
     860  rtems_libio_rw_args_t *parms = (rtems_libio_rw_args_t *) arg;
     861  struct mscan_rx_parms *rx_parms = (struct mscan_rx_parms *) (parms->buffer);
     862  struct can_message *rx_mess = (struct can_message *) (rx_parms->rx_mess);
     863  struct mscan_channel_info *chan = NULL;
     864
     865  switch (minor) {
    1208866
    1209867    case MSCAN_A:
    1210868    case MSCAN_B:
    1211           chan = &chan_info[minor];
     869      chan = &chan_info[minor];
    1212870      break;
    1213871
     
    1215873      return RTEMS_UNSATISFIED;
    1216874      break;
    1217     }
    1218 
     875  }
    1219876
    1220877  /* end init mode if it is first read */
    1221   if((chan->mode) == MSCAN_INIT_NORMAL_MODE)
    1222     {
     878  if ((chan->mode) == MSCAN_INIT_NORMAL_MODE) {
    1223879
    1224880    /* if not already set enter init mode */
    1225881    mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
    1226     }
    1227 
    1228   if((status = rtems_message_queue_receive(chan->rx_qid,
    1229                                           (void *)(rx_mess),
    1230                                           &message_size,
    1231                                           (uint32_t)(rx_parms->rx_flags),
    1232                                           (rtems_interval)(rx_parms->rx_timeout)))
    1233                                           != RTEMS_SUCCESSFUL)
    1234     {
     882  }
     883
     884  if ((status =
     885       rtems_message_queue_receive(chan->rx_qid, (void *) (rx_mess),
     886                                   &message_size,
     887                                   (uint32_t) (rx_parms->rx_flags),
     888                                   (rtems_interval) (rx_parms->rx_timeout)))
     889      != RTEMS_SUCCESSFUL) {
    1235890
    1236891    parms->bytes_moved = 0;
    1237892
    1238     }
    1239   else
    1240     {
    1241 
    1242     parms->bytes_moved = sizeof(struct can_message);
    1243 
    1244     }
     893  } else {
     894
     895    parms->bytes_moved = sizeof (struct can_message);
     896
     897  }
    1245898
    1246899  return status;
    1247900
    1248   }
    1249 
     901}
    1250902
    1251903/*
    1252904 * MPC5x00 MSCAN device write
    1253905 */
    1254 rtems_device_driver mscan_write( rtems_device_major_number major,
    1255                                  rtems_device_minor_number minor,
    1256                                  void * arg
    1257                                 )
    1258   {
     906rtems_device_driver mscan_write(rtems_device_major_number major,
     907                                rtems_device_minor_number minor, void *arg)
     908{
    1259909  rtems_status_code status;
    1260   rtems_libio_rw_args_t         *parms       = (rtems_libio_rw_args_t *)arg;
    1261   struct mscan_tx_parms         *tx_parms    = (struct mscan_tx_parms *)(parms->buffer);
    1262   struct can_message            *tx_mess     = (struct can_message *)(tx_parms->tx_mess);
    1263   struct mscan_channel_info     *chan        = NULL;
    1264   mscan_handle                  *mscan_hdl   = NULL;
    1265   volatile struct mpc5200_mscan *mscan       = NULL;
    1266 
    1267   switch(minor)
    1268     {
     910  rtems_libio_rw_args_t *parms = (rtems_libio_rw_args_t *) arg;
     911  struct mscan_tx_parms *tx_parms = (struct mscan_tx_parms *) (parms->buffer);
     912  struct can_message *tx_mess = (struct can_message *) (tx_parms->tx_mess);
     913  struct mscan_channel_info *chan = NULL;
     914  mscan_handle *mscan_hdl = NULL;
     915  mscan *m = NULL;
     916
     917  switch (minor) {
    1269918    case MSCAN_A:
    1270919    case MSCAN_B:
    1271           chan      = &chan_info[minor];
     920      chan = &chan_info[minor];
    1272921      mscan_hdl = mpc5200_mscan_irq_data[minor].handle;
    1273       mscan    = chan->regs;
     922      m = chan->regs;
    1274923      break;
    1275924
     
    1277926      return RTEMS_UNSATISFIED;
    1278927      break;
    1279     }
     928  }
    1280929
    1281930  /* end init mode if it is first write */
    1282   if((chan->mode) == MSCAN_INIT_NORMAL_MODE)
    1283     {
     931  if ((chan->mode) == MSCAN_INIT_NORMAL_MODE) {
    1284932
    1285933    /* if not already set enter init mode */
    1286934    mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
    1287     }
     935  }
    1288936
    1289937  /* preset moved bytes */
     
    1291939
    1292940  /* obtain counting semaphore of tx ring buffer */
    1293   if((status = rtems_semaphore_obtain((rtems_id)(chan->tx_rb_sid),
    1294                                        RTEMS_NO_WAIT,
    1295                                           (rtems_interval)0))
    1296                                         == RTEMS_SUCCESSFUL)
    1297     {
     941  if ((status =
     942       rtems_semaphore_obtain((rtems_id) (chan->tx_rb_sid), RTEMS_NO_WAIT,
     943                              (rtems_interval) 0))
     944      == RTEMS_SUCCESSFUL) {
    1298945
    1299946    /* append the TOUCAN tx_id to the mess. due to interrupt handling */
    1300         tx_mess->toucan_tx_idx = tx_parms->tx_idx;
     947    tx_mess->toucan_tx_idx = tx_parms->tx_idx;
    1301948
    1302949    /* fill the tx ring buffer with the message */
     
    1304951
    1305952    /* enable message buffer specific interrupt */
    1306     mscan->tier |= (TIER_TXEI0 | TIER_TXEI1 | TIER_TXEI2);
     953    m->tier |= (TIER_TXEI0 | TIER_TXEI1 | TIER_TXEI2);
    1307954
    1308955    /* calculate moved bytes */
    1309956    parms->bytes_moved = (tx_mess->mess_len) & 0x000F;
    1310957
    1311     }
     958  }
    1312959
    1313960  return status;
    1314961
    1315   }
    1316 
     962}
    1317963
    1318964/*
    1319965 * MPC5x00 MSCAN device control
    1320966 */
    1321 rtems_device_driver mscan_control( rtems_device_major_number major,
    1322                                     rtems_device_minor_number minor,
    1323                                     void * arg
    1324                                   )
    1325   {
     967rtems_device_driver mscan_control(rtems_device_major_number major,
     968                                  rtems_device_minor_number minor, void *arg)
     969{
    1326970  rtems_status_code status;
    1327971  uint16_t tx_id;
    1328   rtems_libio_ioctl_args_t      *parms       = (rtems_libio_ioctl_args_t *)arg;
    1329   struct mscan_ctrl_parms       *ctrl_parms  = (struct mscan_ctrl_parms *)(parms->buffer);
    1330   struct mscan_channel_info     *chan        = NULL;
    1331   mscan_handle                  *mscan_hdl   = NULL;
    1332   volatile struct mpc5200_mscan *mscan       = NULL;
    1333   uint8_t                       tx_buf_count = 0;
    1334 
    1335   switch(minor)
    1336     {
     972  rtems_libio_ioctl_args_t *parms = (rtems_libio_ioctl_args_t *) arg;
     973  struct mscan_ctrl_parms *ctrl_parms =
     974    (struct mscan_ctrl_parms *) (parms->buffer);
     975  struct mscan_channel_info *chan = NULL;
     976  mscan_handle *mscan_hdl = NULL;
     977  mscan *m = NULL;
     978  mscan_context context;
     979  uint8_t tx_buf_count = 0;
     980
     981  switch (minor) {
    1337982
    1338983    case MSCAN_A:
    1339984    case MSCAN_B:
    1340           chan = &chan_info[minor];
    1341       mscan_hdl  = mpc5200_mscan_irq_data[minor].handle;
    1342       mscan = chan->regs;
     985      chan = &chan_info[minor];
     986      mscan_hdl = mpc5200_mscan_irq_data[minor].handle;
     987      m = chan->regs;
    1343988      break;
    1344989
     
    1346991      return RTEMS_UNSATISFIED;
    1347992      break;
    1348     }
    1349 
    1350   switch(parms->command)
    1351     {
     993  }
     994
     995  switch (parms->command) {
    1352996
    1353997      /* TOUCAN callback initialization for MSCAN */
     
    13561000      break;
    13571001
    1358     /* set rx buffer ID */
     1002      /* set rx buffer ID */
    13591003    case MSCAN_SET_RX_ID:
    13601004
    13611005      /* enter init mode */
    1362       mpc5200_mscan_enter_init_mode(mscan);
    1363 
    1364       switch(ctrl_parms->ctrl_reg_no)
    1365         {
     1006      mscan_initialization_mode_enter(m, &context);
     1007
     1008      switch (ctrl_parms->ctrl_reg_no) {
    13661009
    13671010        case RX_BUFFER_0:
    1368           mscan->idar0 = SET_IDR0(ctrl_parms->ctrl_id);
    1369           mscan->idar1 = SET_IDR1(ctrl_parms->ctrl_id);
     1011          m->idar0 = SET_IDR0(ctrl_parms->ctrl_id);
     1012          m->idar1 = SET_IDR1(ctrl_parms->ctrl_id);
    13701013          break;
    13711014
    13721015        case RX_BUFFER_1:
    1373           mscan->idar2 = SET_IDR2(ctrl_parms->ctrl_id);
    1374           mscan->idar3 = SET_IDR3(ctrl_parms->ctrl_id);
     1016          m->idar2 = SET_IDR2(ctrl_parms->ctrl_id);
     1017          m->idar3 = SET_IDR3(ctrl_parms->ctrl_id);
    13751018          break;
    13761019
    13771020        case RX_BUFFER_2:
    1378           mscan->idar4 = SET_IDR4(ctrl_parms->ctrl_id);
    1379           mscan->idar5 = SET_IDR5(ctrl_parms->ctrl_id);
     1021          m->idar4 = SET_IDR4(ctrl_parms->ctrl_id);
     1022          m->idar5 = SET_IDR5(ctrl_parms->ctrl_id);
    13801023          break;
    13811024
    13821025        case RX_BUFFER_3:
    1383           mscan->idar6 = SET_IDR6(ctrl_parms->ctrl_id);
    1384           mscan->idar7 = SET_IDR7(ctrl_parms->ctrl_id);
     1026          m->idar6 = SET_IDR6(ctrl_parms->ctrl_id);
     1027          m->idar7 = SET_IDR7(ctrl_parms->ctrl_id);
    13851028          break;
    13861029
    13871030        default:
    1388         break;
    1389 
    1390         }
     1031          break;
     1032
     1033      }
    13911034
    13921035      /* exit init mode and perform further initialization which is required in the normal mode */
    1393       mpc5200_mscan_exit_init_mode(mscan);
     1036      mscan_initialization_mode_leave(m, &context);
    13941037
    13951038      /* enable ints. */
    1396       mpc5200_mscan_int_enable(mscan);
     1039      mscan_interrupts_enable(m);
    13971040
    13981041      /* wait for bus sync. */
    1399       mpc5200_mscan_wait_sync(mscan);
     1042      mpc5200_mscan_wait_sync(m);
    14001043
    14011044      return RTEMS_SUCCESSFUL;
    14021045      break;
    14031046
    1404     /* get rx buffer ID */
     1047      /* get rx buffer ID */
    14051048    case MSCAN_GET_RX_ID:
    14061049
    1407       switch(ctrl_parms->ctrl_reg_no)
    1408             {
     1050      switch (ctrl_parms->ctrl_reg_no) {
    14091051
    14101052        case RX_BUFFER_0:
    1411           ctrl_parms->ctrl_id = GET_IDR0(mscan->idar0) | GET_IDR1(mscan->idar1);
     1053          ctrl_parms->ctrl_id = GET_IDR0(m->idar0) | GET_IDR1(m->idar1);
    14121054          break;
    14131055
    14141056        case RX_BUFFER_1:
    1415           ctrl_parms->ctrl_id = GET_IDR2(mscan->idar2) | GET_IDR3(mscan->idar3);
     1057          ctrl_parms->ctrl_id = GET_IDR2(m->idar2) | GET_IDR3(m->idar3);
    14161058          break;
    14171059
    14181060        case RX_BUFFER_2:
    1419           ctrl_parms->ctrl_id = GET_IDR4(mscan->idar4) | GET_IDR5(mscan->idar5);
     1061          ctrl_parms->ctrl_id = GET_IDR4(m->idar4) | GET_IDR5(m->idar5);
    14201062          break;
    14211063
    14221064        case RX_BUFFER_3:
    1423           ctrl_parms->ctrl_id = GET_IDR6(mscan->idar6) | GET_IDR7(mscan->idar7);
     1065          ctrl_parms->ctrl_id = GET_IDR6(m->idar6) | GET_IDR7(m->idar7);
    14241066          break;
    14251067
    14261068        default:
    1427         break;
    1428 
    1429         }
    1430 
    1431       break;
    1432 
    1433     /* set rx buffer ID mask */
     1069          break;
     1070
     1071      }
     1072
     1073      break;
     1074
     1075      /* set rx buffer ID mask */
    14341076    case MSCAN_SET_RX_ID_MASK:
    14351077
    14361078      /* enter init mode */
    1437       mpc5200_mscan_enter_init_mode(mscan);
    1438 
    1439       switch(ctrl_parms->ctrl_reg_no)
    1440         {
     1079      mscan_initialization_mode_enter(m, &context);
     1080
     1081      switch (ctrl_parms->ctrl_reg_no) {
    14411082
    14421083        case RX_BUFFER_0:
    1443           mscan->idmr0 = SET_IDMR0(ctrl_parms->ctrl_id_mask);
    1444           mscan->idmr1 = SET_IDMR1(ctrl_parms->ctrl_id_mask);
     1084          m->idmr0 = SET_IDMR0(ctrl_parms->ctrl_id_mask);
     1085          m->idmr1 = SET_IDMR1(ctrl_parms->ctrl_id_mask);
    14451086          break;
    14461087
    14471088        case RX_BUFFER_1:
    1448           mscan->idmr2 = SET_IDMR2(ctrl_parms->ctrl_id_mask);
    1449           mscan->idmr3 = SET_IDMR3(ctrl_parms->ctrl_id_mask);
     1089          m->idmr2 = SET_IDMR2(ctrl_parms->ctrl_id_mask);
     1090          m->idmr3 = SET_IDMR3(ctrl_parms->ctrl_id_mask);
    14501091          break;
    14511092
    14521093        case RX_BUFFER_2:
    1453           mscan->idmr4 = SET_IDMR4(ctrl_parms->ctrl_id_mask);
    1454           mscan->idmr5 = SET_IDMR5(ctrl_parms->ctrl_id_mask);
     1094          m->idmr4 = SET_IDMR4(ctrl_parms->ctrl_id_mask);
     1095          m->idmr5 = SET_IDMR5(ctrl_parms->ctrl_id_mask);
    14551096          break;
    14561097
    14571098        case RX_BUFFER_3:
    1458           mscan->idmr6 = SET_IDMR6(ctrl_parms->ctrl_id_mask);
    1459           mscan->idmr7 = SET_IDMR7(ctrl_parms->ctrl_id_mask);
     1099          m->idmr6 = SET_IDMR6(ctrl_parms->ctrl_id_mask);
     1100          m->idmr7 = SET_IDMR7(ctrl_parms->ctrl_id_mask);
    14601101          break;
    14611102
    14621103        default:
    1463         break;
    1464 
    1465         }
     1104          break;
     1105
     1106      }
    14661107
    14671108      /* exit init mode and perform further initialization which is required in the normal mode */
    1468       mpc5200_mscan_exit_init_mode(mscan);
     1109      mscan_initialization_mode_leave(m, &context);
    14691110
    14701111      /* enable ints. */
    1471       mpc5200_mscan_int_enable(mscan);
     1112      mscan_interrupts_enable(m);
    14721113
    14731114      /* wait for bus sync. */
    1474       mpc5200_mscan_wait_sync(mscan);
    1475 
    1476       break;
    1477 
    1478     /* get rx buffer ID mask */
     1115      mpc5200_mscan_wait_sync(m);
     1116
     1117      break;
     1118
     1119      /* get rx buffer ID mask */
    14791120    case MSCAN_GET_RX_ID_MASK:
    14801121
    1481       switch(ctrl_parms->ctrl_reg_no)
    1482         {
     1122      switch (ctrl_parms->ctrl_reg_no) {
    14831123
    14841124        case RX_BUFFER_0:
    1485           ctrl_parms->ctrl_id_mask = (GET_IDMR0(mscan->idmr0) | GET_IDMR1(mscan->idmr1));
     1125          ctrl_parms->ctrl_id_mask =
     1126            (GET_IDMR0(m->idmr0) | GET_IDMR1(m->idmr1));
    14861127          break;
    14871128
    14881129        case RX_BUFFER_1:
    1489           ctrl_parms->ctrl_id_mask = (GET_IDMR2(mscan->idmr2) | GET_IDMR3(mscan->idmr3));
     1130          ctrl_parms->ctrl_id_mask =
     1131            (GET_IDMR2(m->idmr2) | GET_IDMR3(m->idmr3));
    14901132          break;
    14911133
    14921134        case RX_BUFFER_2:
    1493           ctrl_parms->ctrl_id_mask = (GET_IDMR4(mscan->idmr4) | GET_IDMR5(mscan->idmr5));
     1135          ctrl_parms->ctrl_id_mask =
     1136            (GET_IDMR4(m->idmr4) | GET_IDMR5(m->idmr5));
    14941137          break;
    14951138
    14961139        case RX_BUFFER_3:
    1497           ctrl_parms->ctrl_id_mask = (GET_IDMR6(mscan->idmr6) | GET_IDMR7(mscan->idmr7));
     1140          ctrl_parms->ctrl_id_mask =
     1141            (GET_IDMR6(m->idmr6) | GET_IDMR7(m->idmr7));
    14981142          break;
    14991143
    15001144        default:
    1501         break;
    1502 
    1503         }
    1504 
    1505     /* set tx buffer ID */
     1145          break;
     1146
     1147      }
     1148
     1149      /* set tx buffer ID */
    15061150    case MSCAN_SET_TX_ID:
    15071151
    15081152      /* check for availability of tx buffer */
    1509       if(!((mscan->tflg) & (uint8_t)(ctrl_parms->ctrl_reg_no)))
    1510         {
     1153      if (!((m->tflg) & (uint8_t) (ctrl_parms->ctrl_reg_no))) {
    15111154
    15121155        /* do abort tx buf. request */
    1513         mscan->tarq = (uint8_t)(ctrl_parms->ctrl_reg_no);
     1156        m->tarq = (uint8_t) (ctrl_parms->ctrl_reg_no);
    15141157
    15151158        /* wait for abort tx buf. ack. */
    1516         while((mscan->taak) & (uint8_t)(ctrl_parms->ctrl_reg_no));
    1517 
    1518         }
     1159        while ((m->taak) & (uint8_t) (ctrl_parms->ctrl_reg_no));
     1160
     1161      }
    15191162
    15201163      /* select tx buf. */
    1521       mscan->bsel   = (uint8_t)(ctrl_parms->ctrl_reg_no);
     1164      m->bsel = (uint8_t) (ctrl_parms->ctrl_reg_no);
    15221165
    15231166      /* set the tx id of selected buf. */
    15241167      tx_id = ctrl_parms->ctrl_id;
    1525       mscan->txidr0 = SET_IDR0(tx_id);
    1526       mscan->txidr1 = SET_IDR1(tx_id);
    1527       mscan->txidr2 = 0;
    1528       mscan->txidr3 = 0;
    1529 
    1530       break;
    1531 
    1532     /* get tx buffer ID */
     1168      m->txidr0 = SET_IDR0(tx_id);
     1169      m->txidr1 = SET_IDR1(tx_id);
     1170      m->txidr2 = 0;
     1171      m->txidr3 = 0;
     1172
     1173      break;
     1174
     1175      /* get tx buffer ID */
    15331176    case MSCAN_GET_TX_ID:
    15341177
    15351178      /* select tx buf. */
    1536       mscan->bsel   = (uint8_t)(ctrl_parms->ctrl_reg_no);
     1179      m->bsel = (uint8_t) (ctrl_parms->ctrl_reg_no);
    15371180
    15381181      /* get tx id. of selected buf. */
    1539       ctrl_parms->ctrl_id = GET_IDR0(mscan->txidr0) | GET_IDR1(mscan->txidr1);
    1540 
    1541       break;
    1542 
    1543     /* set can bitrate */
     1182      ctrl_parms->ctrl_id = GET_IDR0(m->txidr0) | GET_IDR1(m->txidr1);
     1183
     1184      break;
     1185
     1186      /* set can bitrate */
    15441187    case MSCAN_SET_BAUDRATE:
    15451188
    15461189      /* check bitrate settings */
    1547       if(((ctrl_parms->ctrl_can_bitrate) >= CAN_BIT_RATE_MIN) && ((ctrl_parms->ctrl_can_bitrate) <= CAN_BIT_RATE_MAX)) {
    1548 
    1549         /* enter init mode */
    1550         mpc5200_mscan_enter_init_mode(mscan);
     1190      if (((ctrl_parms->ctrl_can_bitrate) >= CAN_BIT_RATE_MIN)
     1191          && ((ctrl_parms->ctrl_can_bitrate) <= CAN_BIT_RATE_MAX)) {
    15511192
    15521193        /* perform all can bit time settings */
    1553         mpc5200_mscan_perform_bit_time_settings(mscan,(uint32_t)(ctrl_parms->ctrl_can_bitrate),IPB_CLOCK);
    1554 
    1555         /* exit init mode and perform further initialization which is required in the normal mode */
    1556         mpc5200_mscan_exit_init_mode(mscan);
     1194        mscan_set_bit_rate(m, ctrl_parms->ctrl_can_bitrate);
    15571195
    15581196        /* enable ints. */
    1559         mpc5200_mscan_int_enable(mscan);
     1197        mscan_interrupts_enable(m);
    15601198
    15611199        /* wait for bus sync. */
    1562         mpc5200_mscan_wait_sync(mscan);
    1563 
    1564             return RTEMS_SUCCESSFUL;
    1565             }
    1566           else {
    1567 
    1568              return RTEMS_UNSATISFIED;
    1569              }
     1200        mpc5200_mscan_wait_sync(m);
     1201
     1202        return RTEMS_SUCCESSFUL;
     1203      } else {
     1204
     1205        return RTEMS_UNSATISFIED;
     1206      }
    15701207
    15711208      break;
     
    15741211
    15751212      /* check for different settings of tx ring buffer */
    1576       if((tx_buf_count = chan->tx_buf_no) != (uint8_t)(ctrl_parms->ctrl_tx_buf_no))
    1577         {
     1213      if ((tx_buf_count =
     1214           chan->tx_buf_no) != (uint8_t) (ctrl_parms->ctrl_tx_buf_no)) {
    15781215
    15791216        /* preset the channel specific no of messages in the tx ring buffer */
     
    15811218
    15821219        /* try to obtain all of the tx ring buffers */
    1583         while(tx_buf_count > 0)
    1584           {
     1220        while (tx_buf_count > 0) {
    15851221
    15861222          /* obtain semaphore of all tx ring buffers */
    1587                   if((status = rtems_semaphore_obtain((rtems_id)(chan->tx_rb_sid),
    1588                                                            RTEMS_WAIT,
    1589                                                           (rtems_interval)10))
    1590                                                 == RTEMS_SUCCESSFUL)
    1591                 {
    1592 
    1593                     tx_buf_count--;
    1594 
    1595                 }
     1223          if ((status =
     1224               rtems_semaphore_obtain((rtems_id) (chan->tx_rb_sid), RTEMS_WAIT,
     1225                                      (rtems_interval) 10))
     1226              == RTEMS_SUCCESSFUL) {
     1227
     1228            tx_buf_count--;
    15961229
    15971230          }
    15981231
     1232        }
     1233
    15991234        /* free the former tx ring buffer */
    1600         free((void *)chan->tx_ring_buf.buf_ptr);
     1235        free((void *) chan->tx_ring_buf.buf_ptr);
    16011236
    16021237        /* allocate the tx ring buffer with new size */
    1603             if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*((uint8_t)(ctrl_parms->ctrl_tx_buf_no)+1))) != NULL)
    1604               {
    1605                   chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
    1606               }
    1607             else
    1608               {
    1609                   return RTEMS_UNSATISFIED;
    1610               }
     1238        if (((chan->tx_ring_buf.buf_ptr) =
     1239             malloc(sizeof (struct can_message) *
     1240                    ((uint8_t) (ctrl_parms->ctrl_tx_buf_no) + 1))) != NULL) {
     1241          chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr =
     1242            chan->tx_ring_buf.buf_ptr;
     1243        } else {
     1244          return RTEMS_UNSATISFIED;
     1245        }
    16111246
    16121247        /* set the new amount of tx buffers */
    1613         chan->tx_buf_no =  (uint8_t)(ctrl_parms->ctrl_tx_buf_no);
     1248        chan->tx_buf_no = (uint8_t) (ctrl_parms->ctrl_tx_buf_no);
    16141249
    16151250        /* release the semaphore of all tx ring buffers */
    1616         while(tx_buf_count < chan->tx_buf_no)
    1617                   {
    1618 
    1619                   /* obtain semaphore of all tx ring buffers */
    1620               rtems_semaphore_release((rtems_id)(chan->tx_rb_sid));
    1621 
    1622                   tx_buf_count++;
    1623 
    1624                   }
    1625 
    1626             }
    1627           else
    1628             {
     1251        while (tx_buf_count < chan->tx_buf_no) {
     1252
     1253          /* obtain semaphore of all tx ring buffers */
     1254          rtems_semaphore_release((rtems_id) (chan->tx_rb_sid));
     1255
     1256          tx_buf_count++;
     1257
     1258        }
     1259
     1260      } else {
    16291261
    16301262        return RTEMS_SUCCESSFUL;
    16311263
    1632             }
     1264      }
    16331265      break;
    16341266
     
    16361268      break;
    16371269
    1638     }
     1270  }
    16391271
    16401272  return RTEMS_SUCCESSFUL;
    16411273
    1642   }
    1643 
     1274}
  • c/src/lib/libbsp/powerpc/gen5200/mscan/mscan_int.h

    r7dc035b r9ac9883  
    1818|                                                                 |
    1919+-----------------------------------------------------------------+
    20 | this file has to be included by the mscan driver                |
     20| this file has to be included by the m driver                |
    2121\*===============================================================*/
    2222#ifndef __MSCAN_INT_H__
     
    2727#endif
    2828
     29#include <bsp/mscan-base.h>
     30
    2931#include "../mscan/mscan.h"
    30 
    31 #define MIN_NO_OF_TQ         7
    32 #define NO_OF_TABLE_ENTRIES  4
    33 #define TSEG_1               1
    34 #define TSEG_2               2
    35 #define SJW                  3
    3632
    3733#define MSCAN_RX_BUFF_NUM        4
     
    4642#define CAN_BIT_RATE_MAX         1000000
    4743#define CAN_BIT_RATE_MIN         100000
    48 
    4944#define CAN_BIT_RATE             100000
    50 #define CAN_MAX_NO_OF_TQ         25
    51 #define CAN_MAX_NO_OF_TQ_TSEG1   15
    52 #define CAN_MAX_NO_OF_TQ_TSEG2   7
    53 #define CAN_MAX_NO_OF_TQ_SJW     2
    5445
    5546#define MSCAN_RX_BUFF_NOACTIVE   (0 << 4)
     
    7263#define MSCAN_READ_RXBUFF_3      (1 << 2)
    7364
    74 #define CTL0_RXFRM               (1 << 7)
    75 #define CTL0_RXACT               (1 << 6)
    76 #define CTL0_CSWAI               (1 << 5)
    77 #define CTL0_SYNCH               (1 << 4)
    78 #define CTL0_TIME                (1 << 3)
    79 #define CTL0_WUPE                (1 << 2)
    80 #define CTL0_SLPRQ               (1 << 1)
    81 #define CTL0_INITRQ              (1 << 0)
    82 
    83 #define CTL1_CANE                (1 << 7)
    84 #define CTL1_CLKSRC              (1 << 6)
    85 #define CTL1_LOOPB               (1 << 5)
    86 #define CTL1_LISTEN              (1 << 4)
    87 #define CTL1_WUPM                (1 << 2)
    88 #define CTL1_SLPAK               (1 << 1)
    89 #define CTL1_INITAK              (1 << 0)
    90 
    91 #define BTR0_SJW(btr0)           ((btr0) << 6)
    92 #define BTR0_BRP(btr0)           ((btr0) << 0)
    93 
    94 #define BTR1_SAMP                (1 << 7)
    95 #define BTR1_TSEG_22_20(btr1)    ((btr1) << 4)
    96 #define BTR1_TSEG_13_10(btr1)    ((btr1) << 0)
    97 
    98 #define RFLG_WUPIF               (1 << 7)
    99 #define RFLG_CSCIF               (1 << 6)
    100 #define RFLG_RSTAT               (3 << 4)
    101 #define RFLG_TSTAT               (3 << 2)
    102 #define RFLG_OVRIF               (1 << 1)
    103 #define RFLG_RXF                 (1 << 0)
    104 #define RFLG_GET_RX_STATE(rflg)  (((rflg) >> 4) & 0x03)
    105 #define RFLG_GET_TX_STATE(rflg)  (((rflg) >> 2) & 0x03)
    106 
    10765#define MSCAN_STATE_OK           0
    10866#define MSCAN_STATE_ERR          1
    10967#define MSCAN_STATE_WRN              2
    11068#define MSCAN_STATE_BUSOFF       3
    111 
    112 #define RIER_WUPIE               (1 << 7)
    113 #define RIER_CSCIE               (1 << 6)
    114 #define RIER_RSTAT(rier)         ((rier) << 4)
    115 #define RIER_TSTAT(rier)         ((rier) << 2)
    116 #define RIER_OVRIE               (1 << 1)
    117 #define RIER_RXFIE               (1 << 0)
    118 
    119 #define TFLG_TXE2                (1 << 2)
    120 #define TFLG_TXE1                (1 << 1)
    121 #define TFLG_TXE0                (1 << 0)
    122 
    123 #define TIER_TXEI2               (1 << 2)
    124 #define TIER_TXEI1               (1 << 1)
    125 #define TIER_TXEI0               (1 << 0)
    126 
    127 #define TARQ_ABTRQ2              (1 << 2)
    128 #define TARQ_ABTRQ1              (1 << 1)
    129 #define TARQ_ABTRQ0              (1 << 0)
    130 
    131 #define TAAK_ABTRQ2              (1 << 2)
    132 #define TAAK_ABTRQ1              (1 << 1)
    133 #define TAAK_ABTRQ0              (1 << 0)
    134 
    135 #define BSEL_TX2                 (1 << 2)
    136 #define BSEL_TX1                 (1 << 1)
    137 #define BSEL_TX0                 (1 << 0)
    138 
    139 #define IDAC_IDAM1               (1 << 5)
    140 #define IDAC_IDAM0               (1 << 4)
    141 #define IDAC_IDHIT(idac)         ((idac) & 0x7)
    14269
    14370#define TX_MBUF_SEL(buf_no)      (1 << (buf_no))
     
    233160struct mscan_channel_info
    234161  {
    235   volatile struct mpc5200_mscan *regs;
     162  mscan *regs;
    236163  uint32_t   int_rx_err;
    237164  rtems_id   rx_qid;
     
    250177/*MSCAN driver internal functions */
    251178void mscan_hardware_initialize(rtems_device_major_number, uint32_t, void *);
    252 void mpc5200_mscan_int_enable(volatile struct mpc5200_mscan *);
    253 void mpc5200_mscan_int_disable(volatile struct mpc5200_mscan *);
    254 void mpc5200_mscan_enter_sleep_mode(volatile struct mpc5200_mscan *);
    255 void mpc5200_mscan_exit_sleep_mode(volatile struct mpc5200_mscan *);
    256 void mpc5200_mscan_enter_init_mode(volatile struct mpc5200_mscan *);
    257 void mpc5200_mscan_exit_init_mode(volatile struct mpc5200_mscan *);
    258 void mpc5200_mscan_wait_sync(volatile struct mpc5200_mscan *);
    259 void mpc5200_mscan_perform_init_mode_settings(volatile struct mpc5200_mscan *);
    260 void mpc5200_mscan_perform_normal_mode_settings(volatile struct mpc5200_mscan *);
     179void mpc5200_mscan_wait_sync(mscan *);
     180void mpc5200_mscan_perform_init_mode_settings(mscan *);
     181void mpc5200_mscan_perform_normal_mode_settings(mscan *);
    261182rtems_status_code mpc5200_mscan_set_mode(rtems_device_minor_number, uint8_t);
    262183rtems_status_code mscan_channel_initialize(rtems_device_major_number, rtems_device_minor_number);
    263 uint8_t prescaler_calculation(uint32_t, uint32_t, uint8_t *);
    264 void mpc5200_mscan_perform_bit_time_settings(volatile struct mpc5200_mscan *, uint32_t, uint32_t);
    265 
    266184
    267185#ifdef __cplusplus
Note: See TracChangeset for help on using the changeset viewer.