Changeset c9b005a9 in rtems


Ignore:
Timestamp:
Jul 9, 2006, 10:05:27 AM (14 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
9807f04
Parents:
a650ebb1
Message:

applied patches for PR1117/1118/1119/1120

Files:
28 edited

Legend:

Unmodified
Added
Removed
  • aclocal/bsp-alias.m4

    ra650ebb1 rc9b005a9  
    2626    pc686)        $2=pc386            ;; # i386 - PC with PentiumPro
    2727    pck6)         $2=pc386            ;; # i386 - PC with K6
     28    brs5l*)       $2=gen5200          ;; # MPC5200 based board
    2829    pm520*)       $2=gen5200          ;; # MPC5200 based board
    2930    simcpu32)     $2=sim68000         ;; # BSVC CPU32 variant
  • aclocal/check-bsps.m4

    ra650ebb1 rc9b005a9  
    2727                             bsps="$bsps mbx860_005b"
    2828                             ;;
    29           gen5200)           bsps="pm520_cr825 pm520_ze30";;
     29          gen5200)           bsps="pm520_cr825 pm520_ze30 brs5l";;
    3030          motorola_powerpc)  bsps="mvme2307 mcp750 mtx603e mvme2100";;
    3131          pc386)             bsps="pc386 pc386dx pc486 pc586 pc686 pck6";;
  • c/src/lib/libbsp/powerpc/gen5200/Makefile.am

    ra650ebb1 rc9b005a9  
    3030project_lib_DATA = start.$(OBJEXT)
    3131
    32 dist_project_lib_DATA += startup/linkcmds startup/linkcmds.pm520
     32dist_project_lib_DATA += startup/linkcmds.brs5l startup/linkcmds.pm520
    3333
    3434noinst_PROGRAMS += bestcomm.rel
     
    9191nvram_rel_CPPFLAGS = $(AM_CPPFLAGS)
    9292nvram_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
     93include_bsp_HEADERS += nvram/nvram.h
    9394
    9495noinst_PROGRAMS += slicetimer.rel
     
    9697slicetimer_rel_CPPFLAGS = $(AM_CPPFLAGS)
    9798slicetimer_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
     99include_bsp_HEADERS += slicetimer/slicetimer.h
    98100
    99101noinst_PROGRAMS += tod.rel
     
    109111    ../../shared/bsppost.c startup/bspstart.c ../../shared/bootcard.c \
    110112    ../../shared/main.c ../../shared/sbrk.c \
    111     ../../shared/gnatinstallhandler.c startup/cpuinit.c
     113    ../../shared/gnatinstallhandler.c startup/cpuinit.c start/start.S
    112114startup_rel_CPPFLAGS = $(AM_CPPFLAGS)
    113115startup_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
  • c/src/lib/libbsp/powerpc/gen5200/bestcomm/bestcomm_glue.c

    ra650ebb1 rc9b005a9  
    4747\*=========================================================================*/
    4848{
     49  rtems_interrupt_level level;
    4950  if (0 != ((1UL<<bestcomm_taskno) & SDMA_INT_BIT_IMPL)) {
     51    rtems_interrupt_disable(level);
    5052    /*
    5153     * valid task number
     
    5355     */
    5456    SDMA_INT_ENABLE(&mpc5200.IntMask,bestcomm_taskno);
     57    rtems_interrupt_enable(level);
    5558  }
    5659}
     
    7477\*=========================================================================*/
    7578{
     79  rtems_interrupt_level level;
    7680  if (0 != ((1UL<<bestcomm_taskno) & SDMA_INT_BIT_IMPL)) {
     81    rtems_interrupt_disable(level);
    7782    /*
    7883     * valid task number
     
    8085     */
    8186    SDMA_INT_DISABLE(&mpc5200.IntMask,bestcomm_taskno);
     87    rtems_interrupt_enable(level);
    8288  }
    8389}
     
    246252
    247253    /*
    248      * FIXME: initialize interrupt dispatcher
     254     * initialize interrupt dispatcher
    249255     */
    250256      if(!BSP_install_rtems_irq_handler (&bestcomm_glue_irq_data)) {
  • c/src/lib/libbsp/powerpc/gen5200/bsp_specs

    ra650ebb1 rc9b005a9  
    1111
    1212*startfile:
    13 %{!qrtems: %(old_startfile)} %{!nostdlib: %{qrtems:  ecrti%O%s \
    14 %{!qrtems_debug: start.o%s} \
    15 %{qrtems_debug: start_g.o%s}}}
     13%{!qrtems: %(old_startfile)} %{!nostdlib: %{qrtems: \
     14%{!qrtems_debug: } \
     15%{qrtems_debug: } ecrti%O%s}}
    1616
    1717*endfile:
  • c/src/lib/libbsp/powerpc/gen5200/console/console.c

    ra650ebb1 rc9b005a9  
    117117uint32_t mpc5200_uart_avail_mask = GEN5200_UART_AVAIL_MASK;
    118118
    119 uint8_t psc_minor_to_irqname[NUM_PORTS] = 
     119uint8_t psc_minor_to_irqname[NUM_PORTS] =
    120120  {BSP_SIU_IRQ_PSC1,
    121121   BSP_SIU_IRQ_PSC2,
     
    167167struct per_channel_info channel_info[NUM_PORTS];
    168168
    169   /* 
     169  /*
    170170   * XXX: there are only 6 PSCs, but PSC6 has an extra register gap
    171171   *      from PSC5, therefore we instantiate seven(!) PSC register sets
     
    180180  int baud;
    181181  uint8_t csize=0, cstopb, parenb, parodd;
    182   struct mpc5200_psc *psc = 
     182  struct mpc5200_psc *psc =
    183183    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    184184
     
    213213   /*
    214214        * Calculate baud rate
     215        * round divider to nearest!
    215216    */
    216     baud = IPB_CLOCK / (baud * 32);
     217    baud = (IPB_CLOCK + baud *16) / (baud * 32);
    217218
    218219    }
     
    315316  int nb_overflow;
    316317  int minor = (int)handle;
    317   struct mpc5200_psc *psc = 
     318  struct mpc5200_psc *psc =
    318319    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    319320
     
    342343      c = (psc->rb_tb >> 24);
    343344
    344       nb_overflow = rtems_termios_enqueue_raw_characters((void *)ttyp[minor], (char *)&c, (int)1);
    345 
    346       channel_info[minor].rx_characters++;
     345      if (ttyp[minor] != NULL) {
     346        nb_overflow = rtems_termios_enqueue_raw_characters((void *)ttyp[minor], (char *)&c, (int)1);
     347        channel_info[minor].rx_characters++;
     348      }
    347349
    348350#ifndef SINGLE_CHAR_MODE
     
    365367        psc->isr_imr = channel_info[minor].shadow_imr &= ~(IMR_TX_RDY);
    366368
     369        if (ttyp[minor] != NULL) {
    367370#ifndef SINGLE_CHAR_MODE
    368     rtems_termios_dequeue_characters((void *)ttyp[minor], channel_info[minor].cur_tx_len);
    369 
    370     channel_info[minor].tx_characters += channel_info[minor].cur_tx_len;
     371           rtems_termios_dequeue_characters((void *)ttyp[minor], channel_info[minor].cur_tx_len);
     372
     373           channel_info[minor].tx_characters += channel_info[minor].cur_tx_len;
    371374#else
    372     rtems_termios_dequeue_characters((void *)ttyp[minor], (int)1);
    373 
    374     channel_info[minor].tx_characters++;
    375 #endif
    376 
     375           rtems_termios_dequeue_characters((void *)ttyp[minor], (int)1);
     376
     377           channel_info[minor].tx_characters++;
     378#endif
     379        }
    377380    }
    378381
     
    404407  struct mpc5200_psc *psc;
    405408  int minor =  mpc5200_psc_irqname_to_minor(ptr->name);
    406  
     409
    407410  if (minor >= 0) {
    408411    psc = (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    409     psc->isr_imr = channel_info[minor].shadow_imr |= 
     412    psc->isr_imr = channel_info[minor].shadow_imr |=
    410413      (IMR_RX_RDY_FULL | IMR_TX_RDY);
    411414  }
     
    416419  struct mpc5200_psc *psc;
    417420  int minor =  mpc5200_psc_irqname_to_minor(ptr->name);
    418  
     421
    419422  if (minor >= 0) {
    420423    psc = (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    421     psc->isr_imr = channel_info[minor].shadow_imr &= 
     424    psc->isr_imr = channel_info[minor].shadow_imr &=
    422425      ~(IMR_RX_RDY_FULL | IMR_TX_RDY);
    423426  }
     
    428431  struct mpc5200_psc *psc;
    429432  int minor =  mpc5200_psc_irqname_to_minor(ptr->name);
    430  
     433
    431434  if (minor >= 0) {
    432435    psc = (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
     
    444447void mpc5200_uart_psc_initialize(int minor) {
    445448  uint32_t baud_divider;
    446   struct mpc5200_psc *psc = 
     449  struct mpc5200_psc *psc =
    447450    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    448451
     
    505508   * Set lower timer counter
    506509   */
    507  
     510
    508511  psc->ctlr = baud_divider & 0x0000ffff;
    509512
     
    573576  {
    574577  unsigned char c;
    575   struct mpc5200_psc *psc = 
     578  struct mpc5200_psc *psc =
    576579    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    577580
     
    589592  {
    590593  const char *tmp_buf = buf;
    591   struct mpc5200_psc *psc = 
     594  struct mpc5200_psc *psc =
    592595    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    593596
     
    615618  int frame_len = len;
    616619  const char *frame_buf = buf;
    617   struct mpc5200_psc *psc = 
     620  struct mpc5200_psc *psc =
    618621    (struct mpc5200_psc *)(&mpc5200.psc[psc_minor_to_regset[minor]]);
    619622
     
    685688  rtems_device_minor_number console_minor;
    686689  char dev_name[] = "/dev/ttyx";
     690  uint32_t tty_num = 0;
     691
    687692  /*
    688693   * Always use and set up TERMIOS
     
    691696  rtems_termios_initialize();
    692697
    693   for (console_minor = PSC1_MINOR; 
    694        console_minor < PSC1_MINOR + NUM_PORTS;
    695        console_minor++) {
    696     /*
    697      * check, whether UART is available for this board
    698      */
     698  for (console_minor = PSC1_MINOR;
     699      console_minor < PSC1_MINOR + NUM_PORTS;
     700      console_minor++) {
     701     /*
     702      * check, whether UART is available for this board
     703      */
    699704    if (0 != ((1 << console_minor) & (mpc5200_uart_avail_mask))) {
    700705      /*
     
    702707       */
    703708      mpc5200_uart_psc_initialize(console_minor); /* /dev/tty0 */
    704       dev_name[8] = '0' + console_minor - PSC1_MINOR;
     709      dev_name[8] = '0' + tty_num;
    705710      status = rtems_io_register_name (dev_name, major, console_minor);
    706      
     711
    707712      if(status != RTEMS_SUCCESSFUL)
    708         rtems_fatal_error_occurred(status);
    709     }
    710   }
     713        {
     714            rtems_fatal_error_occurred(status);
     715        }
     716
     717          tty_num++;
     718    }
     719  }
     720
    711721  /* Now register the RTEMS console */
    712722  status = rtems_io_register_name ("/dev/console", major, PSC1_MINOR);
     
    781791    return RTEMS_INVALID_NUMBER;
    782792
     793  ttyp[minor] = NULL; /* mark for int handler: tty no longer open */
     794
    783795  return rtems_termios_close( arg );
    784 
    785796  return 0;
    786797
  • c/src/lib/libbsp/powerpc/gen5200/include/bsp.h

    ra650ebb1 rc9b005a9  
    6262/* ROM definitions (2 MB) */
    6363#define ROM_START       0xFFE00000
    64 #define ROM_END         0xFFFFFFFF
     64#define ROM_SIZE        0x00200000
     65#define ROM_END         (ROM_START+ROM_SIZE-1)
    6566#define BOOT_START      ROM_START
    6667#define BOOT_END        ROM_END
    6768
    6869/* SDRAM definitions (256 MB) */
    69 #define RAM_START    0x00000000
    70 #define RAM_END      0x0FFFFFFF
     70#define RAM_START       0x00000000
     71#define RAM_SIZE        0x10000000
     72#define RAM_END         (RAM_START+RAM_SIZE-1)
    7173
    7274/* DPRAM definitions (64 KB) */
     
    199201
    200202/* ata modes */
    201 #undef ATA_USE_INT
     203/* #undef ATA_USE_INT */
     204#define ATA_USE_INT
    202205
    203206/* clock settings */
     
    212215#endif
    213216
     217/*
     218 *  Convert decrement value to tenths of microsecnds (used by
     219 *  shared timer driver).
     220 *
     221 *    + CPU has a XLB_CLOCK bus,
     222 *    + There are 4 bus cycles per click
     223 *    + We return value in 1/10 microsecond units.
     224 *   Modified following equation to integer equation to remove
     225 *   floating point math.
     226 *   (int) ((float)(_value) / ((XLB_CLOCK/1000000 * 0.1) / 4.0))
     227 */
     228
     229#define BSP_Convert_decrementer( _value ) \
     230  (int) (((_value) * 4000) / (XLB_CLOCK/10000))
     231
    214232/* slicetimer settings */
    215233#define USE_SLICETIMER_0     TRUE
  • c/src/lib/libbsp/powerpc/gen5200/include/mpc5200.h

    ra650ebb1 rc9b005a9  
    301301#define GPT_STATUS_TEXP            (1 << 3)
    302302#define GPT_STATUS_PIN             (1 << 8)
     303#define GPT_EMSEL_GPIO_DIR         (2 << 4)
     304#define GPT_EMSEL_GPIO_OUT         (1 << 4)
    303305#define GPT_EMSEL_GPIO_OUT_HIGH    (3 << 4)
    304306#define GPT_EMSEL_TIMER_MS_GPIO    (4 << 0)
     
    307309#define GPT_EMSEL_ST_CONT          (1 << 10)
    308310#define GPT_EMSEL_INTEN            (1 << 8)
     311#define GPT_EMSEL_WDEN                            (1 << 15)
    309312
    310313#define GPT0                       0
  • c/src/lib/libbsp/powerpc/gen5200/include/tm27.h

    ra650ebb1 rc9b005a9  
    1616#define __tm27_h
    1717
     18#include <bsp/irq.h>
     19
    1820/*
    1921 *  Stuff for Time Test 27
    2022 */
    2123
    22 #define MUST_WAIT_FOR_INTERRUPT 0
     24#define MUST_WAIT_FOR_INTERRUPT 1
    2325
    24 #define Install_tm27_vector( handler ) \
    25    do { \
    26         static rtems_irq_connect_data scIrqData = { \
    27           PPC_IRQ_SCALL, \
    28           (rtems_irq_hdl) handler, \
    29           NULL, \
    30           NULL, \
    31           NULL  \
    32         }; \
    33         BSP_install_rtems_irq_handler (&scIrqData); \
    34    } while(0)
     26void nullFunc() {}
    3527
    36 #define Cause_tm27_intr() asm volatile ("sc")
     28static rtems_irq_connect_data clockIrqData = {BSP_DECREMENTER,
     29                                              0,
     30                                              (rtems_irq_enable)nullFunc,
     31                                              (rtems_irq_disable)nullFunc,
     32                                              (rtems_irq_is_enabled) nullFunc};
     33void Install_tm27_vector(void (*_handler)())
     34{
     35  clockIrqData.hdl = _handler;
     36  if (!BSP_install_rtems_irq_handler (&clockIrqData)) {
     37        printk("Error installing clock interrupt handler!\n");
     38        rtems_fatal_error_occurred(1);
     39  }
     40}
    3741
    38 #define Clear_tm27_intr() /* empty */
     42#define Cause_tm27_intr()  \
     43  do { \
     44    uint32_t   _clicks = 8; \
     45    asm volatile( "mtdec %0" : "=r" ((_clicks)) : "r" ((_clicks)) ); \
     46  } while (0)
    3947
    40 #define Lower_tm27_intr() /* empty */
     48#define Clear_tm27_intr() \
     49  do { \
     50    uint32_t   _clicks = 0xffffffff; \
     51    asm volatile( "mtdec %0" : "=r" ((_clicks)) : "r" ((_clicks)) ); \
     52  } while (0)
     53
     54#define Lower_tm27_intr() \
     55  do { \
     56    uint32_t   _msr = 0; \
     57    _ISR_Set_level( 0 ); \
     58    asm volatile( "mfmsr %0 ;" : "=r" (_msr) : "r" (_msr) ); \
     59    _msr |=  0x8002; \
     60    asm volatile( "mtmsr %0 ;" : "=r" (_msr) : "r" (_msr) ); \
     61  } while (0)
    4162
    4263#endif
  • c/src/lib/libbsp/powerpc/gen5200/mscan/mscan.c

    ra650ebb1 rc9b005a9  
    3131/* #define MSCAN_LOOPBACK */
    3232
     33volatile uint32_t tx_int_wr_count = 0;
     34
    3335struct mpc5200_rx_cntrl mpc5200_mscan_rx_cntrl[MPC5200_CAN_NO];
    34 static struct mscan_channel_info chan_info[MPC5200_CAN_NO];
     36volatile static struct mscan_channel_info chan_info[MPC5200_CAN_NO];
     37
     38/* time segmant table  */
     39uint8_t can_time_segment_table[CAN_MAX_NO_OF_TQ - MIN_NO_OF_TQ + 1][NO_OF_TABLE_ENTRIES] = {
     40
     41/* Total no. of time quantas */   /* Time Segment 1*/    /* Time Segment 2 */     /* Sync: Jump width */
     42{         7,                                4,                     2,                       1          },
     43{         8,                                5,                     2,                       1          },
     44{         9,                                6,                     2,                       2          },
     45{        10,                                6,                     3,                       2          },
     46{        11,                                7,                     3,                       2          },
     47{        12,                                8,                     3,                       2          },
     48{        13,                                8,                     4,                       2          },
     49{        14,                                9,                     4,                       2          },
     50{        15,                               10,                     4,                       2          },
     51{        16,                               10,                     5,                       2          },
     52{        17,                               11,                     5,                       2          },
     53{        18,                               12,                     5,                       2          },
     54{        19,                               12,                     6,                       2          },
     55{        20,                               13,                     6,                       2          },
     56{        21,                               14,                     6,                       2          },
     57{        22,                               14,                     7,                       2          },
     58{        23,                               15,                     7,                       2          },
     59{        24,                               15,                     8,                       2          },
     60{        25,                               16,                     8,                       2          }};
     61
     62
     63/*
     64 * MPC5x00 MSCAN tx ring buffer function to get a can message buffer from the head of the tx ring buffer
     65 */
     66volatile static struct can_message * get_tx_buffer(struct mscan_channel_info *chan)
     67  {
     68  /* define a temp. mess ptr. */
     69  volatile struct can_message * tmp_mess_ptr = NULL, *temp_head_ptr;
     70
     71  /* set temp. head pointer */
     72  temp_head_ptr = chan->tx_ring_buf.head_ptr;
     73
     74  /* check buffer empty condition */
     75  if(temp_head_ptr != chan->tx_ring_buf.tail_ptr)
     76    {
     77
     78    /* current buffer head. ptr. */
     79    tmp_mess_ptr = temp_head_ptr;
     80
     81    /* increment the head pointer */
     82    temp_head_ptr++;
     83
     84    /* check for wrap around condition */
     85    if(temp_head_ptr > chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF)
     86      {
     87
     88      /* set head ptr. to the begin of the ring buffer */
     89      temp_head_ptr = chan->tx_ring_buf.buf_ptr;
     90
     91      }
     92
     93    /* end of crtical section restore head ptr. */
     94    chan->tx_ring_buf.head_ptr = temp_head_ptr;
     95    }
     96
     97  /* return the current head pointer */
     98  return tmp_mess_ptr;
     99  }
     100
     101/*
     102 * MPC5x00 MSCAN tx ring buffer function to write a can message buffer to the tail of the tx ring buffer
     103 */
     104volatile static struct can_message * fill_tx_buffer(struct mscan_channel_info *chan, struct can_message * mess_ptr)
     105  {
     106  /* define a temp. mess ptr. to the entry which follows the current tail entry */
     107  struct can_message * tmp_mess_ptr = chan->tx_ring_buf.tail_ptr + 1;
     108
     109  /* check for the wrap around condition */
     110  if(tmp_mess_ptr >  chan->tx_ring_buf.buf_ptr + NO_OF_MSCAN_TX_BUFF)
     111    {
     112        /* set temp. mess. ptr to the begin of the ring buffer */
     113        tmp_mess_ptr = chan->tx_ring_buf.buf_ptr;
     114    }
     115
     116  /* check buffer full condition */
     117  if(tmp_mess_ptr == chan->tx_ring_buf.head_ptr)
     118    {
     119        /* return NULL in case buffer is full */
     120        return NULL;
     121    }
     122  else
     123    {
     124        /* copy the can mess. to the tail of the buffer */
     125    memcpy((void *)chan->tx_ring_buf.tail_ptr, (void *)mess_ptr, sizeof(struct can_message));
     126
     127    /* set new tail equal to temp. mess. ptr. */
     128    chan->tx_ring_buf.tail_ptr = tmp_mess_ptr;
     129    }
     130
     131  /* return the actual tail ptr. (next free entry) */
     132  return chan->tx_ring_buf.tail_ptr;
     133  }
    35134
    36135/*
     
    42141  mscan_handle *mscan_hdl = (mscan_handle *)handle;
    43142  struct mscan_channel_info *chan = &chan_info[mscan_hdl->mscan_channel];
    44   struct can_message rx_mess, *rx_mess_ptr;
     143  struct can_message rx_mess, *rx_mess_ptr, *tx_mess_ptr;
    45144  volatile struct mpc5200_mscan *mscan = chan->regs;
     145  register uint8_t idx;
    46146
    47147  /*
    48    handle tx interrupts
     148   handle tx ring buffer
    49149   */
    50150
    51   /* check and disable tx interrupt for message buffer 0 */
    52   if(mscan->tier & MSCAN_TX_BUFF0)
    53     mscan->tier &= ~(MSCAN_TX_BUFF0);
    54 
    55   /* check and disable tx interrupt for message buffer 1 */
    56   if(mscan->tier & MSCAN_TX_BUFF1)
    57     mscan->tier &= ~(MSCAN_TX_BUFF1);
    58 
    59   /* check and disable tx interrupt for message buffer 2 */
    60   if(mscan->tier & MSCAN_TX_BUFF2)
    61     mscan->tier &= ~(MSCAN_TX_BUFF2);
     151  /* loop over all 3 tx buffers */
     152  for(idx = TFLG_TXE0; idx <= TFLG_TXE2; idx=idx<<1)
     153    {
     154
     155    /* check for tx buffer vacation */
     156    if((mscan->tflg) & idx)
     157      {
     158
     159      /* try to get a message */
     160      tx_mess_ptr = get_tx_buffer(chan);
     161
     162      /* check for new tx message */
     163      if(tx_mess_ptr != NULL)
     164        {
     165
     166        /* select the tx buffer */
     167        mscan->bsel  = idx;
     168
     169        /* check for toucan interface */
     170        if((mscan_hdl->toucan_callback) == NULL)
     171          {
     172
     173          /* set tx id */
     174                  mscan->txidr0 = SET_IDR0(tx_mess_ptr->mess_id);
     175                  mscan->txidr1 = SET_IDR1(tx_mess_ptr->mess_id);
     176                  mscan->txidr2 = 0;
     177          mscan->txidr3 = 0;
     178
     179          /* insert dlc into mscan register */
     180                  mscan->txdlr = (uint8_t)((tx_mess_ptr->mess_len) & 0x000F);
     181              }
     182
     183        /* select one free tx buffer if TOUCAN not registered) */
     184        if(((mscan_hdl->toucan_callback) == NULL) || (((mscan_hdl->toucan_callback) != NULL) && ((tx_mess_ptr->toucan_tx_id) == idx)))
     185          {
     186
     187          /* set tx id */
     188                  mscan->txidr0 = SET_IDR0(tx_mess_ptr->mess_id);
     189                  mscan->txidr1 = SET_IDR1(tx_mess_ptr->mess_id);
     190                  mscan->txidr2 = 0;
     191          mscan->txidr3 = 0;
     192
     193          /* insert dlc into mscan register */
     194                  mscan->txdlr = (uint8_t)((tx_mess_ptr->mess_len) & 0x000F);
     195
     196          /* copy tx data to MSCAN registers */
     197          switch(mscan->txdlr)
     198            {
     199            case 8:
     200              mscan->txdsr7 = tx_mess_ptr->mess_data[7];
     201            case 7:
     202              mscan->txdsr6 = tx_mess_ptr->mess_data[6];
     203            case 6:
     204              mscan->txdsr5 = tx_mess_ptr->mess_data[5];
     205            case 5:
     206              mscan->txdsr4 = tx_mess_ptr->mess_data[4];
     207            case 4:
     208              mscan->txdsr3 = tx_mess_ptr->mess_data[3];
     209            case 3:
     210              mscan->txdsr2 = tx_mess_ptr->mess_data[2];
     211            case 2:
     212              mscan->txdsr1 = tx_mess_ptr->mess_data[1];
     213            case 1:
     214              mscan->txdsr0 = tx_mess_ptr->mess_data[0];
     215              break;
     216            default:
     217              break;
     218            }
     219
     220          /* enable message buffer specific interrupt */
     221              mscan->tier |= mscan->bsel;
     222
     223              /* start transfer */
     224          mscan->tflg = mscan->bsel;
     225
     226          /* release counting semaphore of tx ring buffer */
     227                  rtems_semaphore_release((rtems_id)(chan->tx_rb_sid));
     228
     229                  tx_int_wr_count++;
     230
     231          }
     232        else
     233          {
     234
     235          /* refill the tx ring buffer with the message */
     236          fill_tx_buffer(chan, tx_mess_ptr);
     237
     238              }
     239            }
     240          else
     241            {
     242                /* reset interrupt enable bit */
     243            mscan->tier &= ~(idx);
     244            }
     245      }
     246    }
    62247
    63248  /*
     
    85270        /* check the rx fliter-match indicators (16-bit filter mode) */
    86271        /* in case of more than one hit, lower hit has priority */
    87         switch((mscan->idac) & 0x7)
     272          idx = (mscan->idac) & 0x7;
     273          switch(idx)
    88274          {
    89275
    90276          case 0:
    91             rx_mess_ptr = (struct can_message *)&(mpc5200_mscan_rx_cntrl[MSCAN_A].can_rx_message[0]);
     277          case 1:
     278          case 2:
     279          case 3:
     280            rx_mess_ptr =
     281              (struct can_message *)&(mpc5200_mscan_rx_cntrl[mscan_hdl->mscan_channel].can_rx_message[idx]);
    92282            break;
    93 
    94               case 1:
    95             rx_mess_ptr = (struct can_message *)&(mpc5200_mscan_rx_cntrl[MSCAN_A].can_rx_message[1]);
    96             break;
    97 
    98           case 2:
    99             rx_mess_ptr = (struct can_message *)&(mpc5200_mscan_rx_cntrl[MSCAN_A].can_rx_message[2]);
    100                     break;
    101 
    102                   case 3:
    103             rx_mess_ptr = (struct can_message *)&(mpc5200_mscan_rx_cntrl[MSCAN_A].can_rx_message[3]);
    104                     break;
    105283
    106284          /* this case should never happen */
     
    531709  /*    [00]:INITRQ      0 : No init. Mode Request                  */
    532710  /* wait for MSCAN A_/_B bus synch. */
     711
     712#if 0 /* we don't have a need to wait for sync. */
    533713  while(!((mscan->ctl0) & CTL0_SYNCH));
    534 
     714#endif
    535715  return;
    536716
    537717  }
    538718
     719/* calculate the can clock prescaler value */
     720uint8_t prescaler_calculation(uint32_t can_bit_rate, uint32_t can_clock_frq, uint8_t *tq_no) {
     721
     722/* local variables */
     723uint8_t tq_no_min_dev = 0;
     724uint32_t frq_tq, frq_dev, frq_dev_min = 0xFFFFFFFF;
     725
     726/* loop through all values of time quantas */
     727for(*tq_no = CAN_MAX_NO_OF_TQ; *tq_no >= MIN_NO_OF_TQ; (*tq_no)--) {
     728
     729  /* calculate time quanta freq. */
     730  frq_tq = *tq_no * can_bit_rate;
     731
     732  /* calculate the deviation from requested tq freq. */
     733  frq_dev = can_clock_frq%frq_tq;
     734
     735  /* check the deviation freq. */
     736  if(frq_dev == 0) {
     737
     738    /* return if best match (zero deviation) */
     739   return (uint8_t)(can_clock_frq/frq_tq);
     740    }
     741  else
     742    {
     743
     744    /* check for minimum of freq. deviation */
     745    if(frq_dev < frq_dev_min) {
     746
     747      /* recognize the minimum freq. deviation */
     748      frq_dev_min = frq_dev;
     749
     750      /* recognize the no. of time quantas */
     751      tq_no_min_dev = *tq_no;
     752          }
     753        }
     754  }
     755
     756/* return the optimized prescaler value */
     757 *tq_no = tq_no_min_dev;
     758 return (uint8_t)(can_clock_frq/(tq_no_min_dev * can_bit_rate));
     759}
    539760
    540761/*
    541762 * MPC5x00 MSCAN set up the bit timing
    542763 */
    543 void mpc5200_mscan_perform_bit_time_settings(volatile struct mpc5200_mscan *mscan)
     764void mpc5200_mscan_perform_bit_time_settings(volatile struct mpc5200_mscan *mscan, uint32_t can_bit_rate, uint32_t can_clock_frq)
    544765{
    545766  uint32_t prescale_val = 0;
    546   uint32_t tq_num;
    547   uint32_t sync_seg,tseg1,tseg2;
    548  
    549   if(IPB_CLOCK%(CAN_BIT_RATE * CAN_MAX_NO_OF_TQ))
    550     prescale_val = (IPB_CLOCK/(CAN_BIT_RATE * (CAN_MAX_NO_OF_TQ*2/3))) + 1;
    551   else
    552     prescale_val = IPB_CLOCK/(CAN_BIT_RATE* (CAN_MAX_NO_OF_TQ*2/3));
    553  
    554   tq_num = ((IPB_CLOCK/prescale_val)+CAN_BIT_RATE/2)/CAN_BIT_RATE;
    555   /*
    556    * XXX: make this table controlled according to MPC5200UM/Rev.3,Table 19-34
    557    */
    558   sync_seg = 2;
    559   tseg2 = (tq_num-sync_seg)/6;
    560   tseg1 = tq_num - sync_seg - tseg2;
     767  uint8_t tq_no, tseg_1, tseg_2, sseg;
     768
     769  /* get optimized prescaler value */
     770  prescale_val = prescaler_calculation(can_bit_rate, can_clock_frq, &tq_no);
     771
     772  /* get time segment length from time segment table */
     773  tseg_1 = can_time_segment_table[tq_no - MIN_NO_OF_TQ][TSEG_1];
     774  tseg_2 = can_time_segment_table[tq_no - MIN_NO_OF_TQ][TSEG_2];
     775  sseg    = can_time_segment_table[tq_no - MIN_NO_OF_TQ][SJW];
    561776
    562777  /* Bus Timing Register 0 MSCAN_A/_B ------------------------------*/
     
    570785  /*    [01]:BRP1        0 : Baud Rate Prescaler, Bit 1             */
    571786  /*    [00]:BRP0        1 : Baud Rate Prescaler, Bit 0             */
    572   mscan->btr0 |= (BTR0_SJW(sync_seg-1) | BTR0_BRP(prescale_val - 1));
     787  mscan->btr0 = (BTR0_SJW(sseg-1) | BTR0_BRP(prescale_val-1));
    573788
    574789  /* Bus Timing Register 1 MSCAN_A/_B ------------------------------*/
     
    582797  /*    [01]:TSEG11      1 : Time Segment 1, Bit 1                  */
    583798  /*    [00]:TSEG10      0 : Time Segment 1, Bit 0                  */
    584   mscan->btr1 &= ~(BTR1_SAMP);
    585   mscan->btr1 |=  (BTR1_TSEG_22_20(tseg2-1) | BTR1_TSEG_13_10(tseg1-1));
     799  mscan->btr1 =  (BTR1_TSEG_22_20(tseg_2-1) | BTR1_TSEG_13_10(tseg_1-1));
    586800
    587801  return;
     
    595809void mpc5200_mscan_perform_init_mode_settings(volatile struct mpc5200_mscan *mscan)
    596810  {
    597     mpc5200_mscan_perform_bit_time_settings(mscan);
     811
     812  /* perform all can bit time settings */
     813  mpc5200_mscan_perform_bit_time_settings(mscan,CAN_BIT_RATE,IPB_CLOCK);
     814
    598815  /* Control Register 1 --------------------------------------------*/
    599816  /*    [07]:CANE        0 : MSCAN Module is disabled               */
     
    635852  mscan->idac |=  (IDAC_IDAM0);
    636853
    637   /* initialize rx filter masks: only accept exact matches */
    638   mscan->idmr0  = 0x00;
    639   mscan->idmr1  = 0x00;
    640   mscan->idmr2  = 0x00;
    641   mscan->idmr3  = 0x00;
    642   mscan->idmr4  = 0x00;
    643   mscan->idmr5  = 0x00;
    644   mscan->idmr6  = 0x00;
    645   mscan->idmr7  = 0x00;
    646 
    647   /* initialize rx filters: set to illegal values, so no matches occure */
    648   mscan->idar0  = 0xff;
    649   mscan->idar1  = 0xff;
    650   mscan->idar2  = 0xff;
    651   mscan->idar3  = 0xff;
    652   mscan->idar4  = 0xff;
    653   mscan->idar5  = 0xff;
    654   mscan->idar6  = 0xff;
    655   mscan->idar7  = 0xff;
     854  /* initialize rx filter masks (16 bit) */
     855  mscan->idmr0  = SET_IDMR0(0x07FF);
     856  mscan->idmr1  = SET_IDMR1(0x07FF);
     857  mscan->idmr2  = SET_IDMR2(0x07FF);
     858  mscan->idmr3  = SET_IDMR3(0x07FF);
     859  mscan->idmr4  = SET_IDMR4(0x07FF);
     860  mscan->idmr5  = SET_IDMR5(0x07FF);
     861  mscan->idmr6  = SET_IDMR6(0x07FF);
     862  mscan->idmr7  = SET_IDMR7(0x07FF);
    656863
    657864  /* Control Register 1 --------------------------------------------*/
     
    720927    {
    721928
     929    case MSCAN_INIT_NORMAL_MODE:
     930      /* if not already set enter init mode */
     931          mpc5200_mscan_enter_init_mode(mscan);
     932          /* perform initialization which has to be done in init mode */
     933      mpc5200_mscan_perform_init_mode_settings(mscan);
     934      break;
     935
    722936    case MSCAN_NORMAL_MODE:
    723937      /* if not already set enter init mode */
     
    725939
    726940      if((chan->mode) == MSCAN_INITIALIZED_MODE)
     941        {
     942
    727943        /* perform initialization which has to be done in init mode */
    728944        mpc5200_mscan_perform_init_mode_settings(mscan);
    729       else
     945            }
     946
     947      if((chan->mode) == MSCAN_SLEEP_MODE)
     948        {
     949
    730950        /* exit sleep mode */
    731951            mpc5200_mscan_exit_sleep_mode(mscan);
    732 
    733           /* exit init mode */
     952            }
     953
     954      /* exit init mode */
    734955      mpc5200_mscan_exit_init_mode(mscan);
    735956      /* enable ints. */
     
    737958      /* wait for bus sync. */
    738959      mpc5200_mscan_wait_sync(mscan);
    739       return RTEMS_SUCCESSFUL;
    740960      break;
    741961
    742962    case MSCAN_SLEEP_MODE:
    743       /* enable ints. */
     963      /* disable ints. */
    744964      mpc5200_mscan_int_disable(mscan);
    745       /* if not already set enter init mode */
    746       mpc5200_mscan_enter_init_mode(mscan);
    747965      /* exit sleep mode */
    748966          mpc5200_mscan_enter_sleep_mode(mscan);
    749           /* exit init mode */
    750       mpc5200_mscan_exit_init_mode(mscan);
    751       return RTEMS_SUCCESSFUL;
    752967      break;
    753968
     
    774989  struct mscan_channel_info *chan = &chan_info[minor];
    775990
     991
    776992  /* set registers according to MSCAN channel information */
    777993  switch(minor)
     
    780996    case MSCAN_A:
    781997      chan->rx_qname = rtems_build_name ('C', 'N', 'A', 'Q');
     998      chan->tx_rb_sname = rtems_build_name ('C', 'N', 'A', 'S');
    782999
    7831000      /* register RTEMS device names for MSCAN A */
    784           if((status = rtems_io_register_name (MSCAN_A_DEV_NAME, major, MSCAN_A)) != RTEMS_SUCCESSFUL)
     1001      if((status = rtems_io_register_name (MSCAN_A_DEV_NAME, major, MSCAN_A)) != RTEMS_SUCCESSFUL)
    7851002            return status;
    7861003
     1004      /* register RTEMS device names for MSCAN 0 */
     1005      if((status = rtems_io_register_name (MSCAN_0_DEV_NAME, major, MSCAN_A)) != RTEMS_SUCCESSFUL)
     1006            return status;
     1007
     1008          /* allocate the space for MSCAN A tx ring buffer */
     1009          if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*(NO_OF_MSCAN_TX_BUFF+1))) != NULL)
     1010            {
     1011        chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
     1012            }
     1013          else
     1014            {
     1015                return RTEMS_UNSATISFIED;
     1016            }
    7871017      break;
    7881018
    7891019    case MSCAN_B:
    7901020          chan->rx_qname = rtems_build_name ('C', 'N', 'B', 'Q');
     1021      chan->tx_rb_sname = rtems_build_name ('C', 'N', 'B', 'S');
    7911022
    7921023          /* register RTEMS device names for MSCAN B */
     
    7941025            return status;
    7951026
     1027      /* register RTEMS device names for MSCAN 1 */
     1028          if((status = rtems_io_register_name (MSCAN_1_DEV_NAME, major, MSCAN_B)) != RTEMS_SUCCESSFUL)
     1029            return status;
     1030
     1031      /* allocate the space for MSCAN B tx ring buffer */
     1032          if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*(NO_OF_MSCAN_TX_BUFF+1))) != NULL)
     1033            {
     1034                chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
     1035            }
     1036          else
     1037            {
     1038                return RTEMS_UNSATISFIED;
     1039            }
    7961040      break;
    7971041
     
    8011045    }
    8021046
    803   /* create RTEMS rx message queue for MSCAN A */
    804   if((status = rtems_message_queue_create(chan->rx_qname,
    805                                                  (uint32_t) NO_OF_MSCAN_A_RX_BUFF,
    806                                                  (uint32_t) MSCAN_MESSAGE_SIZE(sizeof(struct can_message)),
    807                                                  (rtems_attribute) RTEMS_LOCAL | RTEMS_FIFO,
    808                                                  (rtems_id *)&(chan->rx_qid)))
    809                                                  != RTEMS_SUCCESSFUL)
    810     {
    811       return status;
    812 
    813     }
    814 
    815   /* Set up interrupts MSCAN A */
     1047  /* create RTEMS rx message queue */
     1048  status = rtems_message_queue_create(chan->rx_qname,
     1049                                             (uint32_t) NO_OF_MSCAN_RX_BUFF,
     1050                                             (uint32_t) MSCAN_MESSAGE_SIZE(sizeof(struct can_message)),
     1051                                             (rtems_attribute) RTEMS_LOCAL | RTEMS_FIFO,
     1052                                             (rtems_id *)&(chan->rx_qid));
     1053
     1054  /* create counting RTEMS tx ring buffer semaphore */
     1055  status = rtems_semaphore_create(chan->tx_rb_sname,
     1056                                 (uint32_t)(NO_OF_MSCAN_TX_BUFF),
     1057                                  RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
     1058                                 (rtems_task_priority)0,
     1059                                 (rtems_id *)&(chan->tx_rb_sid));
     1060
     1061  /* Set up interrupts */
    8161062  if(!BSP_install_rtems_irq_handler(&(mpc5200_mscan_irq_data[minor])))
    8171063    rtems_panic("Can't attach MPC5x00 MSCAN interrupt handler %d\n", minor);
    8181064
    8191065  /* basic setup for channel info. struct. */
    820   chan->regs        = (struct mpc5200_mscan *)&(mpc5200.mscan[minor]);
    821   chan->int_rx_err  = 0;
    822   chan->id_extended = FALSE;
    823   chan->mode        = MSCAN_INITIALIZED_MODE;
     1066  chan->regs           = (struct mpc5200_mscan *)&(mpc5200.mscan[minor]);
     1067  chan->int_rx_err     = 0;
     1068  chan->id_extended    = FALSE;
     1069  chan->mode           = MSCAN_INITIALIZED_MODE;
     1070  chan->tx_buf_no      = NO_OF_MSCAN_TX_BUFF;
    8241071
    8251072  return status;
     
    8451092    rtems_fatal_error_occurred(status);
    8461093
    847   if((status = mpc5200_mscan_set_mode(MSCAN_A, MSCAN_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
     1094  if((status = mpc5200_mscan_set_mode(MSCAN_A, MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
    8481095    rtems_fatal_error_occurred(status);
    8491096
    850   if((status = mpc5200_mscan_set_mode(MSCAN_B, MSCAN_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
     1097  if((status = mpc5200_mscan_set_mode(MSCAN_B, MSCAN_INIT_NORMAL_MODE)) != RTEMS_SUCCESSFUL)
    8511098    rtems_fatal_error_occurred(status);
    8521099
     
    8641111                               )
    8651112  {
    866   rtems_status_code status;
     1113  rtems_status_code status = RTEMS_SUCCESSFUL;
    8671114  struct mscan_channel_info *chan = NULL;
    8681115
     
    8801127    }
    8811128
    882   /* if not already set enter init mode */
    883   status = mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
     1129
     1130  /* check mode */
     1131  if((chan->mode) == MSCAN_SLEEP_MODE)
     1132    {
     1133
     1134    /* if not already set enter init mode */
     1135    status = mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
     1136    }
    8841137
    8851138  return status;
     
    9481201    }
    9491202
     1203
     1204  /* end init mode if it is first read */
     1205  if((chan->mode) == MSCAN_INIT_NORMAL_MODE)
     1206    {
     1207
     1208    /* if not already set enter init mode */
     1209    mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
     1210    }
     1211
    9501212  if((status = rtems_message_queue_receive(chan->rx_qid,
    9511213                                          (void *)(rx_mess),
     
    9791241                                )
    9801242  {
    981   rtems_libio_rw_args_t         *parms      = (rtems_libio_rw_args_t *)arg;
    982   struct mscan_tx_parms         *tx_parms   = (struct mscan_tx_parms *)(parms->buffer);
    983   struct can_message            *tx_mess    = (struct can_message *)(tx_parms->tx_mess);
    984   struct mscan_channel_info     *chan       = NULL;
    985   mscan_handle                  *mscan_hdl  = NULL;
    986   volatile struct mpc5200_mscan *mscan      = NULL;
     1243  rtems_status_code status;
     1244  rtems_libio_rw_args_t         *parms       = (rtems_libio_rw_args_t *)arg;
     1245  struct mscan_tx_parms         *tx_parms    = (struct mscan_tx_parms *)(parms->buffer);
     1246  struct can_message            *tx_mess     = (struct can_message *)(tx_parms->tx_mess);
     1247  struct mscan_channel_info     *chan        = NULL;
     1248  mscan_handle                  *mscan_hdl   = NULL;
     1249  volatile struct mpc5200_mscan *mscan       = NULL;
    9871250
    9881251  switch(minor)
    9891252    {
    990 
    9911253    case MSCAN_A:
    9921254    case MSCAN_B:
     
    10011263    }
    10021264
    1003   /* select one free tx buffer (TOUCAN not registered) */
    1004   if((mscan_hdl->toucan_callback) == NULL)
    1005     {
    1006 
    1007     if(mscan->tflg & MSCAN_TX_BUFF2)
    1008       mscan->bsel  = MSCAN_TX_BUFF2;
    1009 
    1010     if(mscan->tflg & MSCAN_TX_BUFF1)
    1011       mscan->bsel  = MSCAN_TX_BUFF1;
    1012 
    1013     if(mscan->tflg & MSCAN_TX_BUFF0)
    1014       mscan->bsel  = MSCAN_TX_BUFF0;
    1015     }
    1016   else
    1017     {
    1018 
    1019     /* select a specific, preconfigured tx buffer (TOUCAN registered) */
    1020     switch(tx_parms->tx_id)
    1021       {
    1022 
    1023       case 0:
    1024                 if(mscan->tflg & MSCAN_TX_BUFF0)
    1025           mscan->bsel  = MSCAN_TX_BUFF0;
    1026         break;
    1027 
    1028           case 1:
    1029             if(mscan->tflg & MSCAN_TX_BUFF1)
    1030           mscan->bsel  = MSCAN_TX_BUFF1;
    1031             break;
    1032 
    1033           case 2:
    1034                 if(mscan->tflg & MSCAN_TX_BUFF2)
    1035           mscan->bsel  = MSCAN_TX_BUFF2;
    1036             break;
    1037 
    1038       default:
    1039         break;
    1040 
    1041           }
    1042 
    1043     }
    1044 
    1045   /* if no tx buffer is available, teminate the write request */
    1046   if(!(mscan->bsel))
    1047     {
    1048 
    1049     parms->bytes_moved = 0;
    1050     return RTEMS_UNSATISFIED;
    1051 
    1052     }
    1053 
    1054   /* prepare tx id and dlc (TOUCAN not initialized) */
    1055   if((mscan_hdl->toucan_callback) == NULL)
    1056     {
    1057 
    1058     /* check for tx length */
    1059     if((tx_mess->mess_len) & 0x000F)
    1060       {
    1061 
    1062       /* set tx id */
    1063       mscan->txidr0 = SET_IDR0(tx_mess->mess_id);
    1064       mscan->txidr1 = SET_IDR1(tx_mess->mess_id);
    1065       mscan->txidr2 = 0;
    1066       mscan->txidr3 = 0;
    1067 
    1068       /* insert dlc into mscan register */
    1069       mscan->txdlr = (uint8_t)((tx_mess->mess_len) & 0x000F);
    1070 
    1071       }
    1072     else
    1073       {
    1074 
    1075       parms->bytes_moved = 0;
    1076           return RTEMS_UNSATISFIED;
    1077 
    1078       }
    1079 
    1080     }
    1081 
    1082   /* copy tx data to MSCAN registers */
    1083   switch(mscan->txdlr)
    1084     {
    1085 
    1086     case 8:
    1087       mscan->txdsr7 = tx_mess->mess_data[7];
    1088     case 7:
    1089       mscan->txdsr6 = tx_mess->mess_data[6];
    1090     case 6:
    1091       mscan->txdsr5 = tx_mess->mess_data[5];
    1092     case 5:
    1093       mscan->txdsr4 = tx_mess->mess_data[4];
    1094     case 4:
    1095       mscan->txdsr3 = tx_mess->mess_data[3];
    1096     case 3:
    1097       mscan->txdsr2 = tx_mess->mess_data[2];
    1098     case 2:
    1099       mscan->txdsr1 = tx_mess->mess_data[1];
    1100     case 1:
    1101       mscan->txdsr0 = tx_mess->mess_data[0];
    1102       break;
    1103     default:
    1104       break;
    1105 
    1106     }
    1107 
    1108   /* enable message buffer specific interrupt */
    1109   mscan->tier |= mscan->bsel;
    1110 
    1111   /* start transfer */
    1112   mscan->tflg = mscan->bsel;
    1113 
    1114   return RTEMS_SUCCESSFUL;
     1265  /* end init mode if it is first write */
     1266  if((chan->mode) == MSCAN_INIT_NORMAL_MODE)
     1267    {
     1268
     1269    /* if not already set enter init mode */
     1270    mpc5200_mscan_set_mode(minor, MSCAN_NORMAL_MODE);
     1271    }
     1272
     1273  /* preset moved bytes */
     1274  parms->bytes_moved = 0;
     1275
     1276  /* obtain counting semaphore of tx ring buffer */
     1277  if((status = rtems_semaphore_obtain((rtems_id)(chan->tx_rb_sid),
     1278                                       RTEMS_NO_WAIT,
     1279                                          (rtems_interval)0))
     1280                                        == RTEMS_SUCCESSFUL)
     1281    {
     1282
     1283    /* append the TOUCAN tx_id to the mess. due to interrupt handling */
     1284        tx_mess->toucan_tx_id = tx_parms->tx_id;
     1285
     1286    /* fill the tx ring buffer with the message */
     1287    fill_tx_buffer(chan, tx_mess);
     1288
     1289    /* enable message buffer specific interrupt */
     1290    mscan->tier |= (TIER_TXEI0 | TIER_TXEI1 | TIER_TXEI2);
     1291
     1292    /* calculate moved bytes */
     1293    parms->bytes_moved = (tx_mess->mess_len) & 0x000F;
     1294
     1295    }
     1296
     1297  return status;
    11151298
    11161299  }
     
    11251308                                  )
    11261309  {
     1310  rtems_status_code status;
    11271311  uint16_t tx_id;
    1128   rtems_libio_ioctl_args_t      *parms      = (rtems_libio_ioctl_args_t *)arg;
    1129   struct mscan_ctrl_parms       *ctrl_parms = (struct mscan_ctrl_parms *)(parms->buffer);
    1130   struct mscan_channel_info     *chan       = NULL;
    1131   mscan_handle                  *mscan_hdl  = NULL;
    1132   volatile struct mpc5200_mscan *mscan      = NULL;
     1312  rtems_libio_ioctl_args_t      *parms       = (rtems_libio_ioctl_args_t *)arg;
     1313  struct mscan_ctrl_parms       *ctrl_parms  = (struct mscan_ctrl_parms *)(parms->buffer);
     1314  struct mscan_channel_info     *chan        = NULL;
     1315  mscan_handle                  *mscan_hdl   = NULL;
     1316  volatile struct mpc5200_mscan *mscan       = NULL;
     1317  uint8_t                       tx_buf_count = 0;
    11331318
    11341319  switch(minor)
     
    12401425
    12411426        case RX_BUFFER_0:
    1242           mscan->idmr0  = SET_IDR0(ctrl_parms->ctrl_id_mask);
    1243           mscan->idmr1  = SET_IDR1(ctrl_parms->ctrl_id_mask);
     1427          mscan->idmr0  = SET_IDMR0(ctrl_parms->ctrl_id_mask);
     1428          mscan->idmr1  = SET_IDMR1(ctrl_parms->ctrl_id_mask);
    12441429          break;
    12451430
    12461431        case RX_BUFFER_1:
    1247           mscan->idmr2  = SET_IDR2(ctrl_parms->ctrl_id_mask);
    1248           mscan->idmr3  = SET_IDR3(ctrl_parms->ctrl_id_mask);
     1432          mscan->idmr2  = SET_IDMR2(ctrl_parms->ctrl_id_mask);
     1433          mscan->idmr3  = SET_IDMR3(ctrl_parms->ctrl_id_mask);
    12491434          break;
    12501435
    12511436        case RX_BUFFER_2:
    1252           mscan->idmr4  = SET_IDR4(ctrl_parms->ctrl_id_mask);
    1253           mscan->idmr5  = SET_IDR5(ctrl_parms->ctrl_id_mask);
     1437          mscan->idmr4  = SET_IDMR4(ctrl_parms->ctrl_id_mask);
     1438          mscan->idmr5  = SET_IDMR5(ctrl_parms->ctrl_id_mask);
    12541439          break;
    12551440
    12561441        case RX_BUFFER_3:
    1257           mscan->idmr6  = SET_IDR6(ctrl_parms->ctrl_id_mask);
    1258           mscan->idmr7  = SET_IDR7(ctrl_parms->ctrl_id_mask);
     1442          mscan->idmr6  = SET_IDMR6(ctrl_parms->ctrl_id_mask);
     1443          mscan->idmr7  = SET_IDMR7(ctrl_parms->ctrl_id_mask);
    12591444          break;
    12601445
     
    12821467
    12831468        case RX_BUFFER_0:
    1284           ctrl_parms->ctrl_id_mask = GET_IDR0(mscan->idmr0) | GET_IDR1(mscan->idmr1);
     1469          ctrl_parms->ctrl_id_mask = GET_IDMR0(mscan->idmr0) | GET_IDMR1(mscan->idmr1);
    12851470          break;
    12861471
    12871472        case RX_BUFFER_1:
    1288           ctrl_parms->ctrl_id_mask = GET_IDR2(mscan->idmr2) | GET_IDR3(mscan->idmr3);
     1473          ctrl_parms->ctrl_id_mask = GET_IDMR2(mscan->idmr2) | GET_IDMR3(mscan->idmr3);
    12891474          break;
    12901475
    12911476        case RX_BUFFER_2:
    1292           ctrl_parms->ctrl_id_mask = GET_IDR4(mscan->idmr4) | GET_IDR5(mscan->idmr5);
     1477          ctrl_parms->ctrl_id_mask = GET_IDMR4(mscan->idmr4) | GET_IDMR5(mscan->idmr5);
    12931478          break;
    12941479
    12951480        case RX_BUFFER_3:
    1296           ctrl_parms->ctrl_id_mask = GET_IDR6(mscan->idmr6) | GET_IDR7(mscan->idmr7);
     1481          ctrl_parms->ctrl_id_mask = GET_IDMR6(mscan->idmr6) | GET_IDMR7(mscan->idmr7);
    12971482          break;
    12981483
     
    13401525      break;
    13411526
     1527    /* set can bitrate */
     1528    case MSCAN_SET_BAUDRATE:
     1529
     1530      /* check bitrate settings */
     1531      if(((ctrl_parms->ctrl_can_bitrate) >= CAN_BIT_RATE_MIN) && ((ctrl_parms->ctrl_can_bitrate) <= CAN_BIT_RATE_MAX)) {
     1532
     1533        /* enter init mode */
     1534        mpc5200_mscan_enter_init_mode(mscan);
     1535
     1536        /* perform all can bit time settings */
     1537        mpc5200_mscan_perform_bit_time_settings(mscan,(uint32_t)(ctrl_parms->ctrl_can_bitrate),IPB_CLOCK);
     1538
     1539        /* exit init mode and perform further initialization which is required in the normal mode */
     1540        mpc5200_mscan_exit_init_mode(mscan);
     1541
     1542        /* enable ints. */
     1543        mpc5200_mscan_int_enable(mscan);
     1544
     1545        /* wait for bus sync. */
     1546        mpc5200_mscan_wait_sync(mscan);
     1547
     1548            return RTEMS_SUCCESSFUL;
     1549            }
     1550          else {
     1551
     1552             return RTEMS_UNSATISFIED;
     1553             }
     1554
     1555      break;
     1556
     1557    case SET_TX_BUF_NO:
     1558
     1559      /* check for different settings of tx ring buffer */
     1560      if((tx_buf_count = chan->tx_buf_no) != (uint8_t)(ctrl_parms->ctrl_tx_buf_no))
     1561        {
     1562
     1563        /* preset the channel specific no of messages in the tx ring buffer */
     1564        tx_buf_count = chan->tx_buf_no;
     1565
     1566        /* try to obtain all of the tx ring buffers */
     1567        while(tx_buf_count > 0)
     1568          {
     1569
     1570          /* obtain semaphore of all tx ring buffers */
     1571                  if((status = rtems_semaphore_obtain((rtems_id)(chan->tx_rb_sid),
     1572                                                           RTEMS_WAIT,
     1573                                                          (rtems_interval)10))
     1574                                                == RTEMS_SUCCESSFUL)
     1575                {
     1576
     1577                    tx_buf_count--;
     1578
     1579                }
     1580
     1581          }
     1582
     1583        /* free the former tx ring buffer */
     1584        free((void *)chan->tx_ring_buf.buf_ptr);
     1585
     1586        /* allocate the tx ring buffer with new size */
     1587            if(((chan->tx_ring_buf.buf_ptr) = malloc(sizeof(struct can_message)*((uint8_t)(ctrl_parms->ctrl_tx_buf_no)+1))) != NULL)
     1588              {
     1589                  chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr = chan->tx_ring_buf.buf_ptr;
     1590              }
     1591            else
     1592              {
     1593                  return RTEMS_UNSATISFIED;
     1594              }
     1595
     1596        /* set the new amount of tx buffers */
     1597        chan->tx_buf_no =  (uint8_t)(ctrl_parms->ctrl_tx_buf_no);
     1598
     1599        /* release the semaphore of all tx ring buffers */
     1600        while(tx_buf_count < chan->tx_buf_no)
     1601                  {
     1602
     1603                  /* obtain semaphore of all tx ring buffers */
     1604              rtems_semaphore_release((rtems_id)(chan->tx_rb_sid));
     1605
     1606                  tx_buf_count++;
     1607
     1608                  }
     1609
     1610            }
     1611          else
     1612            {
     1613
     1614        return RTEMS_SUCCESSFUL;
     1615
     1616            }
     1617      break;
     1618
    13421619    default:
    13431620      break;
  • c/src/lib/libbsp/powerpc/gen5200/mscan/mscan.h

    ra650ebb1 rc9b005a9  
    2727#endif
    2828
     29#define MIN_NO_OF_TQ         7
     30#define NO_OF_TABLE_ENTRIES  4
     31#define TSEG_1               1
     32#define TSEG_2               2
     33#define SJW                  3
    2934
    3035#define MSCAN_MAX_DATA_BYTES     8
     
    3540#define MSCAN_A_DEV_NAME         "/dev/mscana"
    3641#define MSCAN_B_DEV_NAME         "/dev/mscanb"
     42#define MSCAN_0_DEV_NAME         "/dev/mscan0"
     43#define MSCAN_1_DEV_NAME         "/dev/mscan1"
    3744#define MSCAN_A                  0
    3845#define MSCAN_B                  1
    3946
    40 #define MSCAN_INITIALIZED_MODE   0
    41 #define MSCAN_INIT_NORMAL_MODE   1
    42 #define MSCAN_NORMAL_MODE        2
    43 #define MSCAN_SLEEP_MODE         4
     47#define MSCAN_NON_INITIALIZED_MODE   0
     48#define MSCAN_INITIALIZED_MODE       1
     49#define MSCAN_INIT_NORMAL_MODE       2
     50#define MSCAN_NORMAL_MODE            4
     51#define MSCAN_SLEEP_MODE             8
     52
     53#define CAN_BIT_RATE_MAX         1000000
     54#define CAN_BIT_RATE_MIN         100000
    4455
    4556#define CAN_BIT_RATE             100000
     
    5566#define MSCAN_SET_TX_ID          5
    5667#define MSCAN_GET_TX_ID          6
     68
    5769#define TOUCAN_MSCAN_INIT        7
     70#define MSCAN_SET_BAUDRATE       8
     71#define SET_TX_BUF_NO            9
    5872
    5973#define MSCAN_RX_BUFF_NOACTIVE   (0 << 4)
     
    6377#define MSCAN_RX_BUFF_BUSY       (1 << 4)
    6478
    65 #define MSCAN_A_MBUFF_MASK       0x07
    66 #define MSCAN_B_MBUFF_MASK       0x07
     79#define MSCAN_MBUFF_MASK         0x07
    6780
    6881#define MSCAN_TX_BUFF0           (1 << 0)
     
    176189
    177190#define GET_IDR0(u16)            ((uint16_t) ((u16) << 3))
    178 #define GET_IDR1(u16)            ((uint16_t)((u16) >> 5))
     191#define GET_IDR1(u16)            ((uint16_t)(((u16) >> 5)&0x0007))
    179192
    180193#define GET_IDR2(u16)            GET_IDR0(u16)
     
    187200#define GET_IDR7(u16)            GET_IDR1(u16)
    188201
    189 #define NO_OF_MSCAN_A_RX_BUFF    20
    190 #define NO_OF_MSCAN_B_RX_BUFF    20
     202#define SET_IDMR0(u16)           ((uint8_t)((u16) >> 3))
     203#define SET_IDMR1(u16)           ((uint8_t)((((u16) & 0x0007) << 5))|0x001F)
     204
     205#define SET_IDMR2(u16)           SET_IDMR0(u16)
     206#define SET_IDMR3(u16)           SET_IDMR1(u16)
     207
     208#define SET_IDMR4(u16)           SET_IDMR0(u16)
     209#define SET_IDMR5(u16)           SET_IDMR1(u16)
     210
     211#define SET_IDMR6(u16)           SET_IDMR0(u16)
     212#define SET_IDMR7(u16)           SET_IDMR1(u16)
     213
     214#define GET_IDMR0(u16)           ((uint16_t) ((u16) << 3))
     215#define GET_IDMR1(u16)           ((uint16_t)(((u16) >> 5)&0x0007))
     216
     217#define GET_IDMR2(u16)           GET_IDMR0(u16)
     218#define GET_IDMR3(u16)           GET_IDMR1(u16)
     219
     220#define GET_IDMR4(u16)           GET_IDMR0(u16)
     221#define GET_IDMR5(u16)           GET_IDMR1(u16)
     222
     223#define GET_IDMR6(u16)           GET_IDMR0(u16)
     224#define GET_IDMR7(u16)           GET_IDMR1(u16)
     225
     226#define NO_OF_MSCAN_RX_BUFF      20
    191227#define MSCAN_MESSAGE_SIZE(size) (((size)%CPU_ALIGNMENT) ? (((size) + CPU_ALIGNMENT)-((size) + CPU_ALIGNMENT)%CPU_ALIGNMENT) : (size))
    192228
     
    199235#define RX_BUFFER_2              2
    200236#define RX_BUFFER_3              3
     237
     238#define NO_OF_MSCAN_TX_BUFF      20
     239#define RING_BUFFER_EMPTY(rbuff) ((((rbuff)->head) == ((rbuff)->tail)) ? TRUE : FALSE)
     240#define RING_BUFFER_FULL(rbuff)  ((((rbuff)->head) == ((rbuff)->tail)) ? TRUE : FALSE)
     241
    201242
    202243typedef struct _mscan_handle
     
    213254  uint8_t  mess_data[MSCAN_MAX_DATA_BYTES];
    214255  uint8_t  mess_len;
    215   };
     256  uint32_t toucan_tx_id;
     257  };
     258
     259volatile struct ring_buf
     260    {
     261    volatile struct can_message *buf_ptr;
     262    volatile struct can_message *head_ptr;
     263    volatile struct can_message *tail_ptr;
     264    };
    216265
    217266struct mpc5200_rx_cntrl
     
    219268  struct can_message can_rx_message[MSCAN_RX_BUFF_NUM];
    220269  };
    221 
    222270
    223271struct mscan_channel_info
     
    225273  volatile struct mpc5200_mscan *regs;
    226274  uint32_t   int_rx_err;
    227   rtems_id           rx_qid;
     275  rtems_id   rx_qid;
    228276  uint32_t   rx_qname;
     277  rtems_id   tx_rb_sid;
     278  uint32_t   tx_rb_sname;
    229279  uint8_t    id_extended;
    230280  uint8_t    mode;
     281  uint8_t    tx_buf_no;
     282  volatile struct ring_buf tx_ring_buf;
    231283  };
    232284
     
    249301    uint32_t ctrl_id_mask;
    250302    uint8_t  ctrl_reg_no;
     303    uint8_t  ctrl_tx_buf_no;
     304    uint32_t ctrl_can_bitrate;
    251305    void (*toucan_cb_fnc)(int16_t);
    252306  };
     
    305359rtems_status_code mpc5200_mscan_set_mode(rtems_device_minor_number, uint8_t);
    306360rtems_status_code mscan_channel_initialize(rtems_device_major_number, rtems_device_minor_number);
     361uint8_t prescaler_calculation(uint32_t, uint32_t, uint8_t *);
     362void mpc5200_mscan_perform_bit_time_settings(volatile struct mpc5200_mscan *, uint32_t, uint32_t);
    307363
    308364
  • c/src/lib/libbsp/powerpc/gen5200/network_5200/network.c

    ra650ebb1 rc9b005a9  
    7979#define SDMA_BD_TFD     0x08000000      /*< Transmit Frame Done         */
    8080#define SDMA_BD_INT     0x04000000      /*< Interrupt on frame done     */
    81 #define SDMA_BD_RX_NUM  32 /* Number of receive buffer descriptors      */
    82 #define SDMA_BD_TX_NUM  48 /* Number of transmit buffer descriptors     */
     81#define SDMA_BD_RX_NUM  64 /* Number of receive buffer descriptors      */
     82#define SDMA_BD_TX_NUM  64 /* Number of transmit buffer descriptors     */
    8383
    8484#define SET_BD_STATUS(bd, stat) {               \
     
    128128 */
    129129#define INTERRUPT_EVENT RTEMS_EVENT_1
     130#define FATAL_INT_EVENT RTEMS_EVENT_3
    130131
    131132/*
     
    198199
    199200
     201#define FEC_INTR_MASK_USED \
     202(FEC_INTR_LCEN  |FEC_INTR_CRLEN |\
     203 FEC_INTR_XFUNEN|FEC_INTR_XFERREN|FEC_INTR_RFERREN)
     204
    200205/*
    201206 * Device data
     
    236241  };
    237242
    238 uint8_t tx_shadow_buffer[TX_BUF_COUNT][(ETHER_MAX_LEN+3)&~3];
    239 
    240243static struct mpc5200_enet_struct enet_driver[NIFACES];
    241244
    242245extern int taskTable;
     246static void mpc5200_fec_restart(struct mpc5200_enet_struct *sc);
    243247
    244248
     
    276280    if (bdi != rxBdIndex) {
    277281      rtems_panic("network rx buffer indices out of sync");
     282    }
     283  }
     284}
     285
     286/*
     287 * Function:    mpc5200_fec_rx_bd_cleanup
     288 *
     289 * Description: put all mbufs pending in rx BDs back to buffer pool
     290 *
     291 * Returns:             void
     292 *
     293 */
     294static void mpc5200_fec_rx_bd_cleanup(struct mpc5200_enet_struct *sc) {
     295  int rxBdIndex;
     296  struct mbuf *m,*n;
     297
     298  /*
     299   * Drain RX buffer descriptor ring.
     300   */
     301  for( rxBdIndex = 0; rxBdIndex < sc->rxBdCount; rxBdIndex++ ) {
     302    n = sc->rxMbuf[rxBdIndex];
     303    while (n != NULL) {
     304      m = n;
     305      MFREE(m,n);
    278306    }
    279307  }
     
    493521 */
    494522static int mpc5200_fec_reset(struct mpc5200_enet_struct *sc) {
     523  volatile int delay;
    495524  /*
    496525   * Clear FIFO status registers
     
    500529 
    501530  /*
    502    *
    503    */
     531   * reset the FIFOs
     532   */
     533  mpc5200.reset_cntrl = 0x03000000;
     534
     535  for (delay = 0;delay < 16*4;delay++) {};
     536
    504537  mpc5200.reset_cntrl = 0x01000000;
    505538 
     
    512545   * wait at least 16 clock cycles
    513546   */
    514   rtems_task_wake_after(2);
     547  for (delay = 0;delay < 16*4;delay++) {};
    515548 
    516549  return TRUE;
     
    555588
    556589 /*
    557   * mask FEC chip interrupts
    558   */
    559   mpc5200.imask = FEC_INTR_MASK_ALL;
     590  * block FEC chip interrupts
     591  */
     592  mpc5200.imask = 0;
    560593
    561594 /*
     
    566599 /*
    567600  * wait for graceful stop to register
     601  * FIXME: add rtems_task_wake_after here, if it takes to long
    568602  */
    569603  while((counter--) && (!(mpc5200.ievent & FEC_INTR_GRA)));
     
    585619  mpc5200.ecntrl &= ~(FEC_ECNTRL_OE | FEC_ECNTRL_EN);
    586620
    587   }
    588 
     621  /*
     622   * cleanup all buffers
     623   */
     624  mpc5200_fec_rx_bd_cleanup(sc);
     625
     626  }
     627
     628/*
     629 * MPC5200 FEC interrupt handler
     630 */
     631void mpc5200_fec_irq_handler(rtems_irq_hdl_param handle)
     632{
     633  struct mpc5200_enet_struct *sc = (struct mpc5200_enet_struct *) handle;
     634  volatile uint32_t ievent;
     635
     636  ievent = mpc5200.ievent;
     637
     638  mpc5200.ievent = ievent;
     639  /*
     640   * check errors, update statistics
     641   */
     642  if (ievent & FEC_INTR_LATE_COL) {
     643    sc->txLateCollision++;
     644  }
     645  if (ievent & FEC_INTR_COL_RETRY) {
     646    sc->txRetryLimit++;
     647  }
     648  if (ievent & FEC_INTR_XFIFO_UN) {
     649    sc->txUnderrun++;
     650  }
     651  if (ievent & FEC_INTR_XFIFO_ERR) {
     652    sc->txUnderrun++;
     653  }
     654  if (ievent & FEC_INTR_RFIFO_ERR) {
     655    sc->rxOverrun++;
     656  }
     657  /*
     658   * fatal error ocurred?
     659   */
     660  if (ievent & (FEC_INTR_XFIFO_ERR | FEC_INTR_RFIFO_ERR)) {
     661    mpc5200.imask &= ~(FEC_INTR_XFERREN | FEC_INTR_RFERREN);
     662    rtems_event_send(enet_driver[0].rxDaemonTid, FATAL_INT_EVENT);
     663  }
     664}
    589665
    590666/*
     
    593669void mpc5200_smartcomm_rx_irq_handler(rtems_irq_hdl_param unused)
    594670  {
    595   volatile uint32_t ievent;
    596 
    597   ievent = mpc5200.ievent;
    598 
    599 
    600671 /* Frame received? */
    601672  if(GET_SDMA_PENDINGBIT(FEC_RECV_TASK_NO))
     
    618689void mpc5200_smartcomm_tx_irq_handler(rtems_irq_hdl_param unused)
    619690  {
    620   volatile uint32_t ievent;
    621 
    622   ievent = mpc5200.ievent;
    623 
    624 
    625691 /* Buffer transmitted or transmitter error? */
    626692  if(GET_SDMA_PENDINGBIT(FEC_XMIT_TASK_NO))
     
    653719  *
    654720  */
    655 static void mpc5200_fec_retire_tbd(struct mpc5200_enet_struct *sc)
     721static void mpc5200_fec_retire_tbd(struct mpc5200_enet_struct *sc,
     722                                   boolean force)
    656723{
    657724  struct mbuf *n;
     
    663730 
    664731  while ((sc->txBdActiveCount > 0) &&
    665          (bdRing[sc->txBdTail].Status == 0x0)) {
     732         (force || (bdRing[sc->txBdTail].Status == 0x0))) {
    666733    if (sc->txMbuf[sc->txBdTail] != NULL) {
    667734      /*
     
    678745}
    679746
     747 /*
     748  * Function:        mpc5200_fec_tx_bd_requeue
     749  *
     750  * Description:        put buffers back to interface output queue
     751  *
     752  * Returns:            void
     753  *
     754  * Notes:
     755  *
     756  */
     757static void mpc5200_fec_tx_bd_requeue(struct mpc5200_enet_struct *sc)
     758{
     759  /*
     760   * Clear already transmitted BDs first. Will not work calling same
     761   * from fecExceptionHandler(TFINT).
     762   */
     763 
     764  while (sc->txBdActiveCount > 0) {
     765    if (sc->txMbuf[sc->txBdHead] != NULL) {
     766      /*
     767       * NOTE: txMbuf can be NULL, if mbuf has been split into different BDs
     768       */
     769      IF_PREPEND(&(sc->arpcom.ac_if.if_snd),sc->txMbuf[sc->txBdHead]);
     770      sc->txMbuf[sc->txBdHead] = NULL;
     771    }
     772    sc->txBdActiveCount--;
     773    if(--sc->txBdHead < 0) {
     774      sc->txBdHead = sc->txBdCount-1;
     775    }   
     776  }
     777}
    680778
    681779static void mpc5200_fec_sendpacket(struct ifnet *ifp,struct mbuf *m) {
     
    694792  * Free up buffer descriptors
    695793  */
    696   mpc5200_fec_retire_tbd(sc);
     794  mpc5200_fec_retire_tbd(sc,FALSE);
    697795
    698796 /*
     
    729827       * an interrupt.
    730828       */
    731       mpc5200_fec_retire_tbd(sc);
     829      mpc5200_fec_retire_tbd(sc,FALSE);
    732830     
    733831      while((sc->txBdActiveCount + nAdded) == sc->txBdCount) {
     
    736834                                   RTEMS_WAIT | RTEMS_EVENT_ANY,
    737835                                   RTEMS_NO_TIMEOUT, &events);
    738         mpc5200_fec_retire_tbd(sc);
     836        mpc5200_fec_retire_tbd(sc,FALSE);
    739837      }
    740838    }
     
    769867                            ? TASK_BD_TFD | TASK_BD_INT
    770868                            : 0);
    771     /*
    772      * Don't set the READY flag till the
    773      * whole packet has been readied.
    774      */
     869      /*
     870       * Don't set the READY flag till the
     871       * whole packet has been readied.
     872       */
    775873      if (firstBd != NULL) {
    776874        status |= (uint32)SDMA_BD_MASK_READY;
     
    822920  rtems_event_set events;
    823921
    824   for(;;)
    825     {
     922  for(;;) {
    826923   /*
    827924    * Wait for packet
    828925    */
     926    bestcomm_glue_irq_enable(FEC_XMIT_TASK_NO);
    829927    rtems_bsdnet_event_receive(START_TRANSMIT_EVENT|INTERRUPT_EVENT,
    830928                               RTEMS_EVENT_ANY | RTEMS_WAIT,
     
    9451043    bestcomm_glue_irq_enable(FEC_RECV_TASK_NO);
    9461044     
    947     rtems_bsdnet_event_receive (INTERRUPT_EVENT,
     1045    rtems_bsdnet_event_receive (INTERRUPT_EVENT | FATAL_INT_EVENT,
    9481046                                RTEMS_WAIT | RTEMS_EVENT_ANY,
    9491047                                RTEMS_NO_TIMEOUT, &events);
    950 
     1048    if (events & FATAL_INT_EVENT) {
     1049      /*
     1050       * fatal interrupt ocurred, so reinit fec and restart bestcomm tasks
     1051       */
     1052      mpc5200_fec_restart(sc);
     1053      rxBdIndex = 0;
     1054    }
    9511055  }
    9521056}
     
    9661070static void mpc5200_fec_initialize_hardware(struct mpc5200_enet_struct *sc)
    9671071  {
    968   int            timeout;
    969   unsigned short phyAddr = 0;
    9701072
    9711073 /*
     
    9821084  * Set interrupt mask register
    9831085  */
    984   mpc5200.imask = (FEC_INTR_HBEEN
    985                  | FEC_INTR_BREN
    986                  | FEC_INTR_BTEN
    987                  | FEC_INTR_GRAEN
    988                  | FEC_INTR_LATE_COL
    989                  | FEC_INTR_COL_RETRY
    990                  | FEC_INTR_XFIFO_UN
    991                  | FEC_INTR_XFIFO_ERR
    992                  | FEC_INTR_RFIFO_ERR
    993                  | FEC_INTR_TFINT
    994                  );
     1086  mpc5200.imask = FEC_INTR_MASK_USED;
    9951087  /*
    9961088   * Set FEC-Lite receive control register (R_CNTRL)
     
    10551147  */
    10561148  mpc5200.xmit_fsm = FEC_FSM_CRC | FEC_FSM_ENFSM;
     1149  }
    10571150
    10581151 /*
     
    10761169  *   The physical address is dependent on hardware configuration.
    10771170  *
    1078   */
     1171  * Returns:            void
     1172  *
     1173  * Notes:
     1174  *
     1175  */
     1176static void mpc5200_fec_initialize_phy(struct mpc5200_enet_struct *sc)
     1177  {
     1178  int            timeout;
     1179  unsigned short phyAddr = 0;
     1180
    10791181
    10801182 /*
     
    11811283 * set up sdma tasks for ethernet
    11821284 */
    1183 static void mpc5200_sdma_task_setup(void) {
     1285static void mpc5200_sdma_task_setup(struct mpc5200_enet_struct *sc) {
    11841286  TaskSetupParamSet_t   rxParam;        /* RX task setup parameters     */
    11851287  TaskSetupParamSet_t   txParam;        /* TX task setup parameters     */
     
    11881290   * Setup the SDMA RX task.
    11891291   */
    1190   rxParam.NumBD        = SDMA_BD_RX_NUM;
     1292  rxParam.NumBD        = sc->rxBdCount;
    11911293  rxParam.Size.MaxBuf  = ETHER_MAX_LEN;
    11921294  rxParam.Initiator    = 0;
     
    12021304   * Setup the TX task.
    12031305   */
    1204   txParam.NumBD        = SDMA_BD_TX_NUM;
     1306  txParam.NumBD        = sc->txBdCount;
    12051307  txParam.Size.MaxBuf  = ETHER_MAX_LEN;
    12061308  txParam.Initiator    = 0;
     
    12161318}
    12171319
     1320void mpc5200_fec_irq_on(const rtems_irq_connect_data* ptr)
     1321{
     1322  mpc5200.imask = FEC_INTR_MASK_USED;
     1323}
     1324
     1325
     1326int mpc5200_fec_irq_isOn(const rtems_irq_connect_data* ptr)
     1327{
     1328  return mpc5200.imask != 0;
     1329}
     1330
     1331
     1332void mpc5200_fec_irq_off(const rtems_irq_connect_data* ptr)
     1333{
     1334  mpc5200.imask = 0;
     1335}
     1336
    12181337
    12191338/*
     
    12241343  struct mpc5200_enet_struct *sc = (struct mpc5200_enet_struct *)arg;
    12251344  struct ifnet *ifp = &sc->arpcom.ac_if;
     1345  rtems_irq_connect_data fec_irq_data = {
     1346    BSP_SIU_IRQ_ETH,
     1347    mpc5200_fec_irq_handler, /* rtems_irq_hdl           */
     1348    (rtems_irq_hdl_param)sc, /* (rtems_irq_hdl_param)   */
     1349    mpc5200_fec_irq_on,      /* (rtems_irq_enable)      */
     1350    mpc5200_fec_irq_off,     /* (rtems_irq_disable)     */
     1351    mpc5200_fec_irq_isOn     /* (rtems_irq_is_enabled)  */
     1352  };
     1353
    12261354
    12271355  if(sc->txDaemonTid == 0)
     
    12401368      bestcomm_glue_init();
    12411369
    1242       mpc5200_sdma_task_setup();
     1370      mpc5200_sdma_task_setup(sc);
    12431371   
    12441372      /*
     
    12511379                                mpc5200_smartcomm_tx_irq_handler,
    12521380                                NULL);
     1381      if(!BSP_install_rtems_irq_handler (&fec_irq_data)) {
     1382        rtems_panic ("Can't attach MPC5x00 FEX interrupt handler\n");
     1383      }
     1384
    12531385      /* mpc5200_fec_tx_bd_init(sc); */
    12541386      mpc5200_fec_rx_bd_init(sc);
     
    12581390       */
    12591391      mpc5200_fec_initialize_hardware(sc);
     1392      /*
     1393       * Set up the phy
     1394       */
     1395      mpc5200_fec_initialize_phy(sc);
    12601396      /*
    12611397       * Set priority of different initiators
     
    13231459}
    13241460
     1461/*
     1462 * restart the driver, reinit the fec
     1463 * this function is responsible to reinitialize the FEC in case a fatal
     1464 * error has ocurred. This is needed, wen a RxFIFO Overrun or a TxFIFO underrun
     1465 * has ocurred. In these cases, the FEC is automatically disabled, and
     1466 * both FIFOs must be reset and the BestComm tasks must be restarted
     1467 *
     1468 * Note: the daemon tasks will continue to run
     1469 * (in fact this function will be called in the context of the rx daemon task)
     1470 */
     1471#define NEW_SDMA_SETUP
     1472
     1473static void mpc5200_fec_restart(struct mpc5200_enet_struct *sc)
     1474{
     1475  /*
     1476   * FIXME: bring Tx Daemon into idle state
     1477   */
     1478#ifdef NEW_SDMA_SETUP
     1479  /*
     1480   * cleanup remaining receive mbufs
     1481   */
     1482  mpc5200_fec_rx_bd_cleanup(sc);
     1483#endif
     1484  /*
     1485   * Stop SDMA tasks
     1486   */
     1487  TaskStop( rxTaskId);
     1488  TaskStop( txTaskId);
     1489  /*
     1490   * FIXME: wait, until Tx Daemon is in idle state
     1491   */
     1492
     1493  /*
     1494   * Disable transmit / receive interrupts
     1495   */
     1496  bestcomm_glue_irq_disable(FEC_XMIT_TASK_NO);
     1497  bestcomm_glue_irq_disable(FEC_RECV_TASK_NO);
     1498#ifdef NEW_SDMA_SETUP
     1499  /*
     1500   * recycle pending tx buffers
     1501   * FIXME: try to extract pending Tx buffers
     1502   */
     1503#if 0
     1504  mpc5200_fec_tx_bd_requeue(sc);
     1505#else
     1506  mpc5200_fec_retire_tbd(sc,TRUE);
     1507#endif
     1508#endif
     1509  /*
     1510   * re-initialize the FEC hardware
     1511   */
     1512  mpc5200_fec_initialize_hardware(sc);
     1513
     1514#ifdef NEW_SDMA_SETUP
     1515  /*
     1516   * completely reinitialize Bestcomm tasks
     1517   */
     1518  mpc5200_sdma_task_setup(sc);
     1519
     1520  /*
     1521   * reinit receive mbufs
     1522   */
     1523  mpc5200_fec_rx_bd_init(sc);
     1524#endif
     1525  /*
     1526   * Clear SmartDMA task interrupt pending bits.
     1527   */
     1528  TaskIntClear( rxTaskId );
     1529 
     1530  /*
     1531   * Enable the SmartDMA receive/transmit task.
     1532   */
     1533  TaskStart( rxTaskId, 1, rxTaskId, 1 );
     1534  TaskStart( txTaskId, 1, txTaskId, 1 );
     1535  /*
     1536   * reenable rx/tx interrupts
     1537   */
     1538  bestcomm_glue_irq_enable(FEC_XMIT_TASK_NO);
     1539  bestcomm_glue_irq_enable(FEC_RECV_TASK_NO);
     1540  /*
     1541   * (re-)init fec hardware
     1542   */
     1543  mpc5200_fec_initialize_hardware(sc);
     1544  /*
     1545   * reenable fec FIFO error interrupts
     1546   */
     1547  mpc5200.imask = FEC_INTR_MASK_USED;
     1548  /*
     1549   * Enable FEC-Lite controller
     1550   */
     1551  mpc5200.ecntrl |= (FEC_ECNTRL_OE | FEC_ECNTRL_EN);
     1552}
     1553
    13251554
    13261555/*
  • c/src/lib/libbsp/powerpc/gen5200/preinstall.am

    ra650ebb1 rc9b005a9  
    7878TMPINSTALL_FILES += $(PROJECT_LIB)/start.$(OBJEXT)
    7979
    80 $(PROJECT_LIB)/linkcmds: startup/linkcmds $(PROJECT_LIB)/$(dirstamp)
    81         $(INSTALL_DATA) $< $(PROJECT_LIB)/linkcmds
    82 PREINSTALL_FILES += $(PROJECT_LIB)/linkcmds
     80$(PROJECT_LIB)/linkcmds.brs5l: startup/linkcmds.brs5l $(PROJECT_LIB)/$(dirstamp)
     81        $(INSTALL_DATA) $< $(PROJECT_LIB)/linkcmds.brs5l
     82PREINSTALL_FILES += $(PROJECT_LIB)/linkcmds.brs5l
     83
     84$(PROJECT_LIB)/linkcmds.pm520: startup/linkcmds.pm520 $(PROJECT_LIB)/$(dirstamp)
     85        $(INSTALL_DATA) $< $(PROJECT_LIB)/linkcmds.pm520
     86PREINSTALL_FILES += $(PROJECT_LIB)/linkcmds.pm520
    8387
    8488$(PROJECT_LIB)/linkcmds.pm520: startup/linkcmds.pm520 $(PROJECT_LIB)/$(dirstamp)
  • c/src/lib/libbsp/powerpc/gen5200/start/start.S

    ra650ebb1 rc9b005a9  
    112112
    113113.macro LWI reg, value
    114         lis \reg , \value@h
    115         ori \reg , \reg, \value@l
     114        lis \reg , (\value)@h
     115        ori \reg , \reg, (\value)@l
    116116        sync
    117117.endm
     
    287287       
    288288
    289 #ifdef RSM5LOG 
     289#ifdef BRS5L
    290290        LWI     r30, CSBOOTROM_VAL
    291291        stw     r30, CSBOOTROM(r31)             /* Set CSBOOTROM */
     
    300300        stw     r30, CS0STR(r31)                /* Set CS0STR */       
    301301                       
    302         LWI     r30, ROM_END
     302        lis     r30, ROM_END@h
     303        ori     r30, r30, ROM_END@l
     304       
    303305        rlwinm  r30, r30,17,15,31
    304306        stw     r30, CS0STP(r31)                /* Set CS0STP */
     
    328330        stw     r30,SDRAMCS0(r31)               /* Set SDRAMCS0 */
    329331
    330         LWI     r30,(RAM_END+1-RAM_START)/2
     332        LWI     r30,(RAM_SIZE)>>1
    331333        ori     r30,r30,0x1a                    /* size code: bank is 128MByte */
    332334        stw     r30, SDRAMCS1(r31)              /* Set SDRAMCS1 */
     
    442444
    443445/* clear entire on chip SRAM (unique for ROM startup) */
    444         LWI     r30, (MBAR+ONCHIP_SRAM_OFFSET)  /* get start address of onchip SRAM */
     446        lis     r30, (MBAR+ONCHIP_SRAM_OFFSET)@h        /* get start address of onchip SRAM */
     447        ori     r30,r30,(MBAR+ONCHIP_SRAM_OFFSET)@l
    445448        LWI     r29, ONCHIP_SRAM_SIZE           /* get size of onchip SRAM */
    446449       
    447450        bl      clr_mem                         /* Clear onchip SRAM */
    448451       
    449 #endif /* defined(RSM5LOG) */
     452#endif /* defined(BRS5L) */
    450453/* clear .bss section (unique for ROM startup) */
    451454        LWI     r30, _bss_start                 /* get start address of bss section */
     
    523526        stw     r30, CFG2(r31)                  /* Burst Read2Write delay=0xB, Burst length=0x7, Read Tap=0x4 */
    524527       
    525 #ifdef RSM5LOG
     528#ifdef BRS5L
    526529        LWI     r30, 0xD1470000                 /* Mode Set enabled, Clock enabled, Auto refresh enabled, Mem. data drv */
    527530        stw     r30, CTRL(r31)                  /* Refresh counter=0xFFFF */
     
    609612copy_image_end:
    610613        blr
    611 #endif /* defined(RSM5LOG) */
     614#endif /* defined(BRS5L) */
    612615
    613616FID_DCache:
     
    741744        mtfsfi  7, 0
    742745               
    743          
    744         CLRBITS r30, r29, MSR_FP                /* disable FPU and FPU exceptions  */
    745         mtmsr   r30
    746        
    747746        blr
    748747
  • c/src/lib/libbsp/powerpc/gen5200/tod/pcf8563.c

    ra650ebb1 rc9b005a9  
    149149    time->day = From_BCD(v1);
    150150
    151     v1 = info[PCF8563_HOUR_ADR-PCF8563_SECOND_ADR] & PCF8563_HOUR_ADR;
     151    v1 = info[PCF8563_HOUR_ADR-PCF8563_SECOND_ADR] & PCF8563_HOUR_MASK;
    152152    time->hour = From_BCD(v1);
    153153
     
    212212    try = 0;
    213213    do {
    214         status = i2c_write(bus, addr, info, 8);
     214        status = i2c_write(bus, addr, info,sizeof(info));
    215215        try++;
    216216    } while ((status != I2C_SUCCESSFUL) && (try < 10));
  • c/src/libchip/ide/ata.c

    ra650ebb1 rc9b005a9  
    10131013    dev_t              device;
    10141014    ata_int_st_t      *int_st;
     1015
    10151016#if defined(ATA_USE_OLD_EXCEPTIONS)
    10161017    rtems_isr_entry    old_isr;
     
    10461047    status = rtems_task_create(
    10471048                 rtems_build_name ('A', 'T', 'A', 'T'),
    1048                  ATA_DRIVER_TASK_PRIORITY,
     1049                 ((ata_driver_task_priority > 0)
     1050                  ? ata_driver_task_priority
     1051                  : ATA_DRIVER_TASK_DEFAULT_PRIORITY),
    10491052                 ATA_DRIVER_TASK_STACK_SIZE,
    10501053                 RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_ASR |
  • c/src/libchip/ide/ata.h

    ra650ebb1 rc9b005a9  
    4242 */
    4343#define ATA_DRIVER_MESSAGE_QUEUE_SIZE    50
    44 #define ATA_DRIVER_TASK_PRIORITY         140
    4544#define ATA_DRIVER_TASK_STACK_SIZE       16*1024
    46 
     45#define ATA_DRIVER_TASK_DEFAULT_PRIORITY 140
     46  extern rtems_task_priority ata_driver_task_priority;
    4747#ifdef __cplusplus
    4848}
  • cpukit/libblock/include/rtems/bdbuf.h

    ra650ebb1 rc9b005a9  
    9292extern int rtems_bdbuf_configuration_size;
    9393
     94#define SWAPOUT_TASK_DEFAULT_PRIORITY 15
     95extern rtems_task_priority swapout_task_priority;
     96
    9497/* rtems_bdbuf_init --
    9598 *     Prepare buffering layer to work - initialize buffer descritors
  • cpukit/libblock/src/bdbuf.c

    ra650ebb1 rc9b005a9  
    2929
    3030
    31 #define SWAPOUT_PRIORITY 15
    32 #define SWAPOUT_STACK_SIZE (RTEMS_MINIMUM_STACK_SIZE * 2)
     31#define SWAPOUT_TASK_STACK_SIZE (RTEMS_MINIMUM_STACK_SIZE * 2)
    3332
    3433#define READ_MULTIPLE
     
    864863    /* Create and start swapout task */
    865864    rc = rtems_task_create(
    866         rtems_build_name('B', 'S', 'W', 'P'),
    867         SWAPOUT_PRIORITY,
    868         SWAPOUT_STACK_SIZE,
     865        rtems_build_name('B', 'S', 'W', 'P'),   
     866        ((swapout_task_priority > 0)
     867         ? swapout_task_priority
     868         : SWAPOUT_TASK_DEFAULT_PRIORITY),
     869        SWAPOUT_TASK_STACK_SIZE,
    869870        RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
    870871        RTEMS_DEFAULT_ATTRIBUTES,
  • cpukit/libcsupport/include/sys/cdefs.h

    ra650ebb1 rc9b005a9  
    117117#define __pure2
    118118#define __unused
     119#define __used
    119120#define __attribute__(x)
    120121#endif
     
    125126#define __pure2
    126127#define __unused
     128#define __used
    127129#endif
    128130#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7
     
    132134#define __pure2         __attribute__((__const__))
    133135#define __unused
     136#define __used
    134137#endif
    135138#if __GNUC__ == 2 && __GNUC_MINOR__ >= 7 || __GNUC__ >= 3
     
    139142#define __pure2         __attribute__((__const__))
    140143#define __unused        __attribute__((__unused__))
     144#define __used          __attribute__((__used__))
    141145#endif
    142146
  • cpukit/libfs/src/imfs/imfs.h

    ra650ebb1 rc9b005a9  
    8181 */
    8282
    83 #define IMFS_MEMFILE_BYTES_PER_BLOCK     128
     83#define IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK     128
     84  extern int imfs_rq_memfile_bytes_per_block;
     85  /*
     86   * FIXME: make and use derivates from this,
     87   * a shift count and a mask
     88   */
     89  extern int imfs_memfile_bytes_per_block;
     90
     91#define IMFS_MEMFILE_BYTES_PER_BLOCK imfs_memfile_bytes_per_block 
    8492#define IMFS_MEMFILE_BLOCK_SLOTS \
    8593  (IMFS_MEMFILE_BYTES_PER_BLOCK / sizeof(void *))
  • cpukit/libfs/src/imfs/imfs_initsupp.c

    ra650ebb1 rc9b005a9  
    3232
    3333/*
     34 *  IMFS_determine_bytes_per_block
     35 */
     36int imfs_memfile_bytes_per_block = 0;
     37
     38static int IMFS_determine_bytes_per_block(
     39  int *dest_bytes_per_block,
     40  int requested_bytes_per_block,
     41  int default_bytes_per_block
     42)
     43{
     44  rtems_boolean is_valid = FALSE;
     45  int bit_mask;
     46  /*
     47   * check, whether requested bytes per block is valid
     48   */
     49  for (bit_mask = 16;
     50       !is_valid && (bit_mask <= 512);
     51       bit_mask <<= 1) {
     52    if (bit_mask == requested_bytes_per_block) {
     53      is_valid = TRUE;
     54    }
     55  }
     56  *dest_bytes_per_block = ((is_valid)
     57                           ? requested_bytes_per_block
     58                           : default_bytes_per_block);
     59  return 0;
     60   
     61}
     62
     63
     64/*
    3465 *  IMFS_initialize
    3566 */
     
    4576  IMFS_jnode_t                          *jnode;
    4677
     78  /*
     79   * determine/check value for imfs_memfile_bytes_per_block
     80   */
     81  IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
     82                                 imfs_rq_memfile_bytes_per_block,
     83                                 IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK);
     84 
    4785  /*
    4886   *  Create the root node
  • cpukit/libmisc/shell/shell.c

    ra650ebb1 rc9b005a9  
    543543  rtems_current_user_env->euid=
    544544  rtems_current_user_env->egid=0;
     545
     546  /*
     547   * newlib delays the creation of default stdio 'til the
     548   * first I/O operation, therefore we must perform dummy
     549   * operations before we redirect stdio
     550   */
     551  ftell(stdin);
     552  ftell(stdout);
     553  ftell(stderr);
    545554
    546555  stdin =fopen(devname,"r+");
  • cpukit/libnetworking/netinet/tcp_var.h

    ra650ebb1 rc9b005a9  
    4444 */
    4545
     46#ifdef __BSD_VISIBLE
    4647/*
    4748 * Tcp control block, one per tcp; fields:
     
    197198#define intotw(ip)      ((struct tcptw *)(ip)->inp_ppcb)
    198199#define sototcpcb(so)   (intotcpcb(sotoinpcb(so)))
     200#endif /* __BSD_VISIBLE */
    199201
    200202/*
  • cpukit/libnetworking/sys/linker_set.h

    ra650ebb1 rc9b005a9  
    4343#define __MAKE_SET(set, sym)                                            \
    4444        static void const * const __set_##set##_sym_##sym               \
    45         __attribute((section("set_" #set))) __unused = &sym
     45        __attribute((section("set_" #set))) __used = &sym
    4646#else /* !__GNUC__ */
    4747#ifndef lint
  • cpukit/sapi/include/confdefs.h

    ra650ebb1 rc9b005a9  
    124124#include <rtems/imfs.h>
    125125
    126 #ifdef CONFIGURE_INIT
    127 
     126#ifndef CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK
     127#define CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK \
     128                  IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
     129#endif
     130#ifdef CONFIGURE_INIT
     131  int imfs_rq_memfile_bytes_per_block = CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK;
     132#endif /* CONFIGURE_INIT */
     133
     134#ifdef CONFIGURE_INIT
    128135#ifndef CONFIGURE_HAS_OWN_MOUNT_TABLE
    129136rtems_filesystem_mount_table_t configuration_mount_table = {
     
    297304#endif
    298305
     306#ifdef CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
     307  /* the ide driver needs the ATA driver */
     308#  ifndef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     309#  define CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     310#  endif
     311#include <libchip/ide_ctrl.h>
     312#endif
     313
     314#ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     315#include <libchip/ata.h>
     316#endif
     317
    299318#ifndef CONFIGURE_HAS_OWN_DEVICE_DRIVER_TABLE
    300319
     
    312331#ifdef CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER
    313332  DEVNULL_DRIVER_TABLE_ENTRY,
     333#endif
     334#ifdef CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
     335  IDE_CONTROLLER_DRIVER_TABLE_ENTRY,
     336#endif
     337#ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     338  ATA_DRIVER_TABLE_ENTRY,
    314339#endif
    315340#ifdef CONFIGURE_APPLICATION_NEEDS_NULL_DRIVER
     
    318343    !defined(CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER) && \
    319344    !defined(CONFIGURE_APPLICATION_NEEDS_RTC_DRIVER) && \
    320     !defined(CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER)
     345    !defined(CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER) && \
     346    !defined(CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER)  && \
     347    !defined(CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER)
    321348  NULL_DRIVER_TABLE_ENTRY
    322349#endif
     
    347374#endif
    348375
     376#ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     377  /*
     378   * configure the priority of the ATA driver task
     379   */
     380#  ifndef CONFIGURE_ATA_DRIVER_TASK_PRIORITY
     381#    define CONFIGURE_ATA_DRIVER_TASK_PRIORITY ATA_DRIVER_TASK_DEFAULT_PRIORITY
     382#  endif
     383#  ifdef CONFIGURE_INIT
     384  rtems_task_priority ata_driver_task_priority
     385    = CONFIGURE_ATA_DRIVER_TASK_PRIORITY;
     386#  endif /* CONFIGURE_INIT */
     387#endif
     388
     389/*
     390 * add bdbuf configuration and values for swapout task priority
     391 */
     392#ifdef CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
     393#include <rtems/bdbuf.h>
     394/*
     395 * configure the priority of the bdbuf swapout task
     396 */
     397#ifndef CONFIGURE_SWAPOUT_TASK_PRIORITY
     398#define CONFIGURE_SWAPOUT_TASK_PRIORITY SWAPOUT_TASK_DEFAULT_PRIORITY
     399#endif
     400#ifdef CONFIGURE_INIT
     401  rtems_task_priority swapout_task_priority
     402    = CONFIGURE_SWAPOUT_TASK_PRIORITY;
     403#endif  /* CONFIGURE_INIT */
     404#ifndef CONFIGURE_HAS_OWN_BDBUF_TABLE
     405
     406#ifndef CONFIGURE_BDBUF_BUFFER_COUNT
     407#define CONFIGURE_BDBUF_BUFFER_COUNT 64
     408#endif /* CONFIGURE_BDBUF_BUFFER_COUNT */
     409
     410#ifndef CONFIGURE_BDBUF_BUFFER_SIZE
     411#define CONFIGURE_BDBUF_BUFFER_SIZE 512
     412#endif /* CONFIGURE_BDBUF_BUFFER_SIZE */
     413#ifdef CONFIGURE_INIT
     414rtems_bdbuf_config rtems_bdbuf_configuration[] = {
     415  {CONFIGURE_BDBUF_BUFFER_SIZE,CONFIGURE_BDBUF_BUFFER_COUNT,NULL}
     416};
     417int rtems_bdbuf_configuration_size =( sizeof(rtems_bdbuf_configuration)
     418                                     /sizeof(rtems_bdbuf_configuration[0]));
     419#endif /* CONFIGURE_INIT */
     420#endif /* CONFIGURE_HAS_OWN_BDBUF_TABLE        */
     421#endif /* CONFIGURE_APPLICATION_NEEDS_LIBBLOCK */
    349422/*
    350423 *  Default Multiprocessing Configuration Table.  The defaults are
  • make/custom/mpc8260ads.cfg

    ra650ebb1 rc9b005a9  
    2323# -O4 is ok for RTEMS
    2424# NOTE: some level of -O may be actually required by inline assembler
    25 CFLAGS_OPTIMIZE_V=-O4 -fno-keep-inline-functions
     25CFLAGS_OPTIMIZE_V=-O4 -fno-keep-inline-functions -g
    2626
    2727# The following are definitions of make-exe which will work using ld as
  • testsuites/samples/fileio/system.h

    ra650ebb1 rc9b005a9  
    3333#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
    3434#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
     35#define CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
     36#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
    3537#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
    36 
    37 #define CONFIGURE_HAS_OWN_DEVICE_DRIVER_TABLE
    38 
    39 #ifdef CONFIGURE_INIT
    40 rtems_driver_address_table Device_drivers[] =
    41         {
    42         CONSOLE_DRIVER_TABLE_ENTRY
    43         ,CLOCK_DRIVER_TABLE_ENTRY
    44 #ifdef RTEMS_BSP_HAS_IDE_DRIVER
    45         ,IDE_CONTROLLER_DRIVER_TABLE_ENTRY
    46         /* important: ATA driver must be after ide drivers */
    47         ,ATA_DRIVER_TABLE_ENTRY
    48 #endif
    49         };
    50 
    51 #include <rtems/bdbuf.h>
    52 rtems_bdbuf_config rtems_bdbuf_configuration[] = {
    53   {512,128,NULL}
    54 };
    55 int rtems_bdbuf_configuration_size =( sizeof(rtems_bdbuf_configuration)
    56                                      /sizeof(rtems_bdbuf_configuration[0]));
    57 #endif
    58 
    5938
    6039/*
Note: See TracChangeset for help on using the changeset viewer.