Changeset a94fb39 in rtems


Ignore:
Timestamp:
Oct 15, 2014, 11:34:36 PM (7 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.11, 5, master
Children:
425fe40d
Parents:
46dad9d4
git-author:
Joel Sherrill <joel.sherrill@…> (10/15/14 23:34:36)
git-committer:
Joel Sherrill <joel.sherrill@…> (10/19/14 22:00:55)
Message:

mcf5206 libcpu and mcf5206elite: Fix warnings

Location:
c/src/lib
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/m68k/mcf5206elite/console/console.c

    r46dad9d4 ra94fb39  
    11/*
    22 * Console driver for Motorola MCF5206E UART modules
    3  *
     3 */
     4
     5/*
    46 * Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
    57 * Author: Victor V. Vengerov <vvv@oktet.ru>
     
    4749console_poll_read(int minor)
    4850{
    49     return mcfuart_poll_read(&uart[minor]);
     51  return mcfuart_poll_read(&uart[minor]);
    5052}
    5153
     
    6466console_interrupt_write(int minor, const char *buf, size_t len)
    6567{
    66     return mcfuart_interrupt_write(&uart[minor], buf, len);
     68  return mcfuart_interrupt_write(&uart[minor], buf, len);
    6769}
    6870
     
    8183console_poll_write(int minor, const char *buf, size_t len)
    8284{
    83     return mcfuart_poll_write(&uart[minor], buf, len);
     85  return mcfuart_poll_write(&uart[minor], buf, len);
    8486}
    8587
     
    9799console_set_attributes(int minor, const struct termios *t)
    98100{
    99     return mcfuart_set_attributes(&uart[minor], t);
     101  return mcfuart_set_attributes(&uart[minor], t);
    100102}
    101103
     
    112114console_stop_remote_tx(int minor)
    113115{
    114     if (minor < sizeof(uart)/sizeof(uart[0]))
    115         return mcfuart_stop_remote_tx(&uart[minor]);
    116     else
    117         return RTEMS_INVALID_NUMBER;
     116  if (minor < sizeof(uart)/sizeof(uart[0]))
     117    return mcfuart_stop_remote_tx(&uart[minor]);
     118  else
     119    return RTEMS_INVALID_NUMBER;
    118120}
    119121
     
    128130console_start_remote_tx(int minor)
    129131{
    130     if (minor < sizeof(uart)/sizeof(uart[0]))
    131         return mcfuart_start_remote_tx(&uart[minor]);
    132     else
    133         return RTEMS_INVALID_NUMBER;
     132  if (minor < sizeof(uart)/sizeof(uart[0]))
     133    return mcfuart_start_remote_tx(&uart[minor]);
     134  else
     135    return RTEMS_INVALID_NUMBER;
    134136}
    135137
     
    148150console_first_open(int major, int minor, void *arg)
    149151{
    150     rtems_libio_open_close_args_t *args = arg;
    151     rtems_status_code sc;
    152     uint8_t         intvec;
    153 
    154     switch (minor)
    155     {
    156         case 0: intvec = BSP_INTVEC_UART1; break;
    157         case 1: intvec = BSP_INTVEC_UART2; break;
    158         default:
    159             return RTEMS_INVALID_NUMBER;
    160     }
    161 
    162     if (console_mode != CONSOLE_MODE_INT)
    163     {
    164         intvec = 0;
    165     }
    166 
    167     sc = mcfuart_init(&uart[minor],          /* uart */
    168                       args->iop->data1,      /* tty */
    169                       intvec,                /* interrupt vector number */
    170                       minor+1);
    171 
    172     if (sc == RTEMS_SUCCESSFUL)
    173         sc = mcfuart_reset(&uart[minor]);
    174 
    175     return sc;
     152  rtems_libio_open_close_args_t *args = arg;
     153  rtems_status_code sc;
     154  uint8_t         intvec;
     155
     156  switch (minor) {
     157    case 0: intvec = BSP_INTVEC_UART1; break;
     158    case 1: intvec = BSP_INTVEC_UART2; break;
     159    default:
     160      return RTEMS_INVALID_NUMBER;
     161  }
     162
     163  if (console_mode != CONSOLE_MODE_INT) {
     164    intvec = 0;
     165  }
     166
     167  sc = mcfuart_init(
     168    &uart[minor],          /* uart */
     169    args->iop->data1,      /* tty */
     170    intvec,                /* interrupt vector number */
     171    minor+1);
     172
     173  if (sc == RTEMS_SUCCESSFUL)
     174    sc = mcfuart_reset(&uart[minor]);
     175
     176  return sc;
    176177}
    177178
     
    190191console_last_close(int major, int minor, void *arg)
    191192{
    192     return mcfuart_disable(&uart[minor]);
     193  return mcfuart_disable(&uart[minor]);
    193194}
    194195
     
    205206 *     RTEMS error code (RTEMS_SUCCESSFUL if device initialized successfuly)
    206207 */
    207 rtems_device_driver
    208 console_initialize(rtems_device_major_number major,
    209                    rtems_device_minor_number minor,
    210                    void *arg)
    211 {
    212     rtems_status_code status;
    213 
    214     /*
    215      * Set up TERMIOS
    216      */
    217     if (console_mode != CONSOLE_MODE_RAW)
    218         rtems_termios_initialize ();
    219 
    220     /*
    221      * Register the devices
    222      */
    223     status = rtems_io_register_name ("/dev/console", major, 0);
    224     if (status != RTEMS_SUCCESSFUL)
    225         rtems_fatal_error_occurred (status);
    226     status = rtems_io_register_name ("/dev/aux", major, 1);
    227     if (status != RTEMS_SUCCESSFUL)
    228         rtems_fatal_error_occurred (status);
    229 
    230     if (console_mode == CONSOLE_MODE_RAW)
    231     {
    232         rtems_status_code sc;
    233         sc = mcfuart_init(&uart[0],              /* uart */
    234                           NULL,                  /* tty */
    235                           0,                     /* interrupt vector number */
    236                           1);                    /* UART channel number */
    237 
    238         if (sc == RTEMS_SUCCESSFUL)
    239             sc = mcfuart_reset(&uart[0]);
    240 
    241         sc = mcfuart_init(&uart[1],              /* uart */
    242                           NULL,                  /* tty */
    243                           0,                     /* interrupt vector number */
    244                           2);                    /* UART channel number */
    245 
    246         if (sc == RTEMS_SUCCESSFUL)
    247             sc = mcfuart_reset(&uart[1]);
    248         return sc;
    249     }
    250 
    251     return RTEMS_SUCCESSFUL;
     208rtems_device_driver console_initialize(
     209  rtems_device_major_number major,
     210  rtems_device_minor_number minor,
     211  void *arg)
     212{
     213  rtems_status_code status;
     214
     215  /*
     216   * Set up TERMIOS
     217   */
     218  if (console_mode != CONSOLE_MODE_RAW)
     219      rtems_termios_initialize ();
     220
     221  /*
     222   * Register the devices
     223   */
     224  status = rtems_io_register_name ("/dev/console", major, 0);
     225  if (status != RTEMS_SUCCESSFUL)
     226    rtems_fatal_error_occurred (status);
     227
     228  status = rtems_io_register_name ("/dev/aux", major, 1);
     229  if (status != RTEMS_SUCCESSFUL)
     230    rtems_fatal_error_occurred (status);
     231
     232  if (console_mode == CONSOLE_MODE_RAW) {
     233    rtems_status_code sc;
     234    sc = mcfuart_init(&uart[0],              /* uart */
     235                      NULL,                  /* tty */
     236                      0,                     /* interrupt vector number */
     237                      1);                    /* UART channel number */
     238
     239    if (sc == RTEMS_SUCCESSFUL)
     240        sc = mcfuart_reset(&uart[0]);
     241
     242    sc = mcfuart_init(&uart[1],              /* uart */
     243                      NULL,                  /* tty */
     244                      0,                     /* interrupt vector number */
     245                      2);                    /* UART channel number */
     246
     247    if (sc == RTEMS_SUCCESSFUL)
     248      sc = mcfuart_reset(&uart[1]);
     249    return sc;
     250  }
     251
     252  return RTEMS_SUCCESSFUL;
    252253}
    253254
     
    269270             void *arg)
    270271{
    271     static const rtems_termios_callbacks intr_callbacks = {
    272         console_first_open,        /* firstOpen */
    273         console_last_close,        /* lastClose */
    274         NULL,                      /* pollRead */
    275         console_interrupt_write,   /* write */
    276         console_set_attributes,    /* setAttributes */
    277         console_stop_remote_tx,    /* stopRemoteTx */
    278         console_start_remote_tx,   /* startRemoteTx */
    279         1                          /* outputUsesInterrupts */
    280     };
    281     static const rtems_termios_callbacks poll_callbacks = {
    282         console_first_open,        /* firstOpen */
    283         console_last_close,        /* lastClose */
    284         console_poll_read,         /* pollRead */
    285         console_poll_write,        /* write */
    286         console_set_attributes,    /* setAttributes */
    287         console_stop_remote_tx,    /* stopRemoteTx */
    288         console_start_remote_tx,   /* startRemoteTx */
    289         0                          /* outputUsesInterrupts */
    290     };
    291 
    292     switch (console_mode)
    293     {
    294         case CONSOLE_MODE_RAW:
    295             return RTEMS_SUCCESSFUL;
    296 
    297         case CONSOLE_MODE_INT:
    298             return rtems_termios_open(major, minor, arg, &intr_callbacks);
    299 
    300         case CONSOLE_MODE_POLL:
    301             return rtems_termios_open(major, minor, arg, &poll_callbacks);
    302 
    303         default:
    304             rtems_fatal_error_occurred(0xC07A1310);
    305     }
    306     return RTEMS_INTERNAL_ERROR;
     272  static const rtems_termios_callbacks intr_callbacks = {
     273    console_first_open,        /* firstOpen */
     274    console_last_close,        /* lastClose */
     275    NULL,                      /* pollRead */
     276    console_interrupt_write,   /* write */
     277    console_set_attributes,    /* setAttributes */
     278    console_stop_remote_tx,    /* stopRemoteTx */
     279    console_start_remote_tx,   /* startRemoteTx */
     280    1                          /* outputUsesInterrupts */
     281  };
     282  static const rtems_termios_callbacks poll_callbacks = {
     283    console_first_open,        /* firstOpen */
     284    console_last_close,        /* lastClose */
     285    console_poll_read,         /* pollRead */
     286    console_poll_write,        /* write */
     287    console_set_attributes,    /* setAttributes */
     288    console_stop_remote_tx,    /* stopRemoteTx */
     289    console_start_remote_tx,   /* startRemoteTx */
     290    0                          /* outputUsesInterrupts */
     291  };
     292
     293  switch (console_mode) {
     294    case CONSOLE_MODE_RAW:
     295      return RTEMS_SUCCESSFUL;
     296
     297    case CONSOLE_MODE_INT:
     298      return rtems_termios_open(major, minor, arg, &intr_callbacks);
     299
     300      case CONSOLE_MODE_POLL:
     301        return rtems_termios_open(major, minor, arg, &poll_callbacks);
     302
     303      default:
     304        rtems_fatal_error_occurred(0xC07A1310);
     305  }
     306  return RTEMS_INTERNAL_ERROR;
    307307}
    308308
     
    323323              void *arg)
    324324{
    325     if (console_mode != CONSOLE_MODE_RAW)
    326         return rtems_termios_close (arg);
    327     else
    328         return RTEMS_SUCCESSFUL;
     325  if (console_mode != CONSOLE_MODE_RAW)
     326    return rtems_termios_close (arg);
     327  else
     328    return RTEMS_SUCCESSFUL;
    329329}
    330330
     
    345345             void *arg)
    346346{
    347     if (console_mode != CONSOLE_MODE_RAW)
    348     {
    349         return rtems_termios_read (arg);
     347  if (console_mode != CONSOLE_MODE_RAW) {
     348    return rtems_termios_read (arg);
     349  } else {
     350    rtems_libio_rw_args_t *argp = arg;
     351    char *buf = argp->buffer;
     352    int count = argp->count;
     353    int n = 0;
     354    int c;
     355
     356    while (n < count) {
     357      do {
     358        c = mcfuart_poll_read(&uart[minor]);
     359      } while (c == -1);
     360      if (c == '\r')
     361        c = '\n';
     362      *(buf++) = c;
     363      n++;
     364      if (c == '\n')
     365        break;
    350366    }
    351     else
    352     {
    353         rtems_libio_rw_args_t *argp = arg;
    354         char *buf = argp->buffer;
    355         int count = argp->count;
    356         int n = 0;
    357         int c;
    358         while (n < count)
    359         {
    360             do {
    361                 c = mcfuart_poll_read(&uart[minor]);
    362             } while (c == -1);
    363             if (c == '\r')
    364                 c = '\n';
    365             *(buf++) = c;
    366             n++;
    367             if (c == '\n')
    368                 break;
    369         }
    370         argp->bytes_moved = n;
    371         return RTEMS_SUCCESSFUL;
    372     }
     367    argp->bytes_moved = n;
     368    return RTEMS_SUCCESSFUL;
     369  }
    373370}
    374371
     
    390387)
    391388{
    392     if (console_mode != CONSOLE_MODE_RAW)
    393     {
    394         return rtems_termios_write (arg);
     389  if (console_mode != CONSOLE_MODE_RAW) {
     390    return rtems_termios_write (arg);
     391  } else {
     392    rtems_libio_rw_args_t *argp = arg;
     393    char cr = '\r';
     394    char *buf = argp->buffer;
     395    int count = argp->count;
     396    int i;
     397
     398    for (i = 0; i < count; i++) {
     399        if (*buf == '\n')
     400            mcfuart_poll_write(&uart[minor], &cr, 1);
     401        mcfuart_poll_write(&uart[minor], buf, 1);
     402        buf++;
    395403    }
    396     else
    397     {
    398         rtems_libio_rw_args_t *argp = arg;
    399         char cr = '\r';
    400         char *buf = argp->buffer;
    401         int count = argp->count;
    402         int i;
    403         for (i = 0; i < count; i++)
    404         {
    405             if (*buf == '\n')
    406                 mcfuart_poll_write(&uart[minor], &cr, 1);
    407             mcfuart_poll_write(&uart[minor], buf, 1);
    408             buf++;
    409         }
    410         argp->bytes_moved = count;
    411         return RTEMS_SUCCESSFUL;
    412     }
     404    argp->bytes_moved = count;
     405    return RTEMS_SUCCESSFUL;
     406  }
    413407}
    414408
     
    429423                void *arg)
    430424{
    431     if (console_mode != CONSOLE_MODE_RAW)
    432     {
    433         return rtems_termios_ioctl (arg);
    434     }
    435     else
    436     {
    437         return RTEMS_SUCCESSFUL;
    438     }
    439 }
     425  if (console_mode != CONSOLE_MODE_RAW) {
     426    return rtems_termios_ioctl (arg);
     427  } else {
     428    return RTEMS_SUCCESSFUL;
     429  }
     430}
  • c/src/lib/libbsp/m68k/mcf5206elite/include/bsp.h

    r46dad9d4 ra94fb39  
    174174);
    175175
     176/*
     177 * Prototypes for BSP methods that cross file boundaries
     178 */
     179void Init5206e(void);
     180
    176181#ifdef __cplusplus
    177182}
  • c/src/lib/libbsp/m68k/mcf5206elite/start/start.S

    r46dad9d4 ra94fb39  
    66 *  It jumps to the BSP which is responsible for performing
    77 *  all initialization.
    8  *
     8 */
     9
     10/*
    911 *  Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
    1012 *  Author: Victor V. Vengerov <vvv@oktet.ru>
  • c/src/lib/libbsp/m68k/mcf5206elite/startup/init5206e.c

    r46dad9d4 ra94fb39  
    99 *  monitor. This must be changed if you like to run it immediately
    1010 *  after reset.
    11  *
     11 */
     12
     13/*
    1214 *  Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
    1315 *  Author: Victor V. Vengerov <vvv@oktet.ru>
     
    5456                  : : "d" (MCF5206E_CACR_CINV) )
    5557
    56 /* Init5206e --
    57  *     Initialize MCF5206e on-chip modules
    58  *
    59  * PARAMETERS:
    60  *     none
    61  *
    62  * RETURNS:
    63  *     none
     58/*
     59 * Initialize MCF5206e on-chip modules
    6460 */
    65 void
    66 Init5206e(void)
     61void Init5206e(void)
    6762{
    68 
    69     /* Set Module Base Address register */
    70     m68k_set_mbar((MBAR & MCF5206E_MBAR_BA) | MCF5206E_MBAR_V);
    71 
    72     /* Set System Protection Control Register (SYPCR):
    73      * Bus Monitor Enable, Bus Monitor Timing = 1024 clocks,
    74      * Software watchdog disabled
    75      */
    76     *MCF5206E_SYPCR(MBAR) = MCF5206E_SYPCR_BME |
    77                             MCF5206E_SYPCR_BMT_1024;
    78 
    79     /* Set Pin Assignment Register (PAR):
    80      *     Output Timer 0 (not DREQ) on *TOUT[0] / *DREQ[1]
    81      *     Input Timer 0 (not DREQ) on *TIN[0] / *DREQ[0]
    82      *     IRQ, not IPL
    83      *     UART2 RTS signal (not \RSTO)
    84      *     PST/DDATA (not PPIO)
    85      *     *WE (not CS/A)
    86      */
    87     *MCF5206E_PAR(MBAR) = MCF5206E_PAR_PAR9_TOUT |
    88                           MCF5206E_PAR_PAR8_TIN0 |
    89                           MCF5206E_PAR_PAR7_UART2 |
    90                           MCF5206E_PAR_PAR6_IRQ |
    91                           MCF5206E_PAR_PAR5_PST |
    92                           MCF5206E_PAR_PAR4_DDATA |
    93                           MCF5206E_PAR_WE0_WE1_WE2_WE3;
    94 
    95     /* Set SIM Configuration Register (SIMR):
    96      * Disable software watchdog timer and bus timeout monitor when
    97      * internal freeze signal is asserted.
    98      */
    99     *MCF5206E_SIMR(MBAR) = MCF5206E_SIMR_FRZ0 | MCF5206E_SIMR_FRZ1;
    100 
    101     /* Set Interrupt Mask Register: Disable all interrupts */
    102     *MCF5206E_IMR(MBAR) = 0xFFFF;
    103 
    104     /* Assign Interrupt Control Registers as it is defined in bsp.h */
    105     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL1) =
    106                             (BSP_INTLVL_AVEC1 << MCF5206E_ICR_IL_S) |
    107                             (BSP_INTPRIO_AVEC1 << MCF5206E_ICR_IP_S) |
    108                             MCF5206E_ICR_AVEC;
    109     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL2) =
    110                             (BSP_INTLVL_AVEC2 << MCF5206E_ICR_IL_S) |
    111                             (BSP_INTPRIO_AVEC2 << MCF5206E_ICR_IP_S) |
    112                             MCF5206E_ICR_AVEC;
    113     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL3) =
    114                             (BSP_INTLVL_AVEC3 << MCF5206E_ICR_IL_S) |
    115                             (BSP_INTPRIO_AVEC3 << MCF5206E_ICR_IP_S) |
    116                             MCF5206E_ICR_AVEC;
    117     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL4) =
    118                             (BSP_INTLVL_AVEC4 << MCF5206E_ICR_IL_S) |
    119                             (BSP_INTPRIO_AVEC4 << MCF5206E_ICR_IP_S) |
    120                             MCF5206E_ICR_AVEC;
    121     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL5) =
    122                             (BSP_INTLVL_AVEC5 << MCF5206E_ICR_IL_S) |
    123                             (BSP_INTPRIO_AVEC5 << MCF5206E_ICR_IP_S) |
    124                             MCF5206E_ICR_AVEC;
    125     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL6) =
    126                             (BSP_INTLVL_AVEC6 << MCF5206E_ICR_IL_S) |
    127                             (BSP_INTPRIO_AVEC6 << MCF5206E_ICR_IP_S) |
    128                             MCF5206E_ICR_AVEC;
    129     *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL7) =
    130                             (BSP_INTLVL_AVEC7 << MCF5206E_ICR_IL_S) |
    131                             (BSP_INTPRIO_AVEC7 << MCF5206E_ICR_IP_S) |
    132                             MCF5206E_ICR_AVEC;
    133     *MCF5206E_ICR(MBAR,MCF5206E_INTR_TIMER_1) =
    134                             (BSP_INTLVL_TIMER1 << MCF5206E_ICR_IL_S) |
    135                             (BSP_INTPRIO_TIMER1 << MCF5206E_ICR_IP_S) |
    136                             MCF5206E_ICR_AVEC;
    137     *MCF5206E_ICR(MBAR,MCF5206E_INTR_TIMER_2) =
    138                             (BSP_INTLVL_TIMER2 << MCF5206E_ICR_IL_S) |
    139                             (BSP_INTPRIO_TIMER2 << MCF5206E_ICR_IP_S) |
    140                             MCF5206E_ICR_AVEC;
    141     *MCF5206E_ICR(MBAR,MCF5206E_INTR_MBUS) =
    142                             (BSP_INTLVL_MBUS << MCF5206E_ICR_IL_S) |
    143                             (BSP_INTPRIO_MBUS << MCF5206E_ICR_IP_S) |
    144                             MCF5206E_ICR_AVEC;
    145     *MCF5206E_ICR(MBAR,MCF5206E_INTR_UART_1) =
    146                             (BSP_INTLVL_UART1 << MCF5206E_ICR_IL_S) |
    147                             (BSP_INTPRIO_UART1 << MCF5206E_ICR_IP_S);
    148     *MCF5206E_ICR(MBAR,MCF5206E_INTR_UART_2) =
    149                             (BSP_INTLVL_UART2 << MCF5206E_ICR_IL_S) |
    150                             (BSP_INTPRIO_UART2 << MCF5206E_ICR_IP_S);
    151     *MCF5206E_ICR(MBAR,MCF5206E_INTR_DMA_0) =
    152                             (BSP_INTLVL_DMA0 << MCF5206E_ICR_IL_S) |
    153                             (BSP_INTPRIO_DMA0 << MCF5206E_ICR_IP_S) |
    154                             MCF5206E_ICR_AVEC;
    155     *MCF5206E_ICR(MBAR,MCF5206E_INTR_DMA_1) =
    156                             (BSP_INTLVL_DMA1 << MCF5206E_ICR_IL_S) |
    157                             (BSP_INTPRIO_DMA1 << MCF5206E_ICR_IP_S) |
    158                             MCF5206E_ICR_AVEC;
    159 
    160     /* Software Watchdog timer (not used now) */
    161     *MCF5206E_SWIVR(MBAR) = 0x0F; /* Uninitialized interrupt */
    162     *MCF5206E_SWSR(MBAR) = MCF5206E_SWSR_KEY1;
    163     *MCF5206E_SWSR(MBAR) = MCF5206E_SWSR_KEY2;
    164 
    165     /* Configuring Chip Selects */
    166     /* CS2: SRAM memory */
    167     *MCF5206E_CSAR(MBAR,2) = BSP_MEM_ADDR_ESRAM >> 16;
    168     *MCF5206E_CSMR(MBAR,2) = BSP_MEM_MASK_ESRAM;
    169     *MCF5206E_CSCR(MBAR,2) = MCF5206E_CSCR_WS1 |
    170                              MCF5206E_CSCR_PS_32 |
    171                              MCF5206E_CSCR_AA |
    172                              MCF5206E_CSCR_EMAA |
    173                              MCF5206E_CSCR_WR |
    174                              MCF5206E_CSCR_RD;
    175 
    176     /* CS3: GPIO on eLITE board */
    177     *MCF5206E_CSAR(MBAR,3) = BSP_MEM_ADDR_GPIO >> 16;
    178     *MCF5206E_CSMR(MBAR,3) = BSP_MEM_MASK_GPIO;
    179     *MCF5206E_CSCR(MBAR,3) = MCF5206E_CSCR_WS15 |
    180                              MCF5206E_CSCR_PS_16 |
    181                              MCF5206E_CSCR_AA |
    182                              MCF5206E_CSCR_EMAA |
    183                              MCF5206E_CSCR_WR |
    184                              MCF5206E_CSCR_RD;
    185 
    186     {
    187         uint32_t         *inttab = (uint32_t*)&INTERRUPT_VECTOR;
    188         uint32_t         *intvec = (uint32_t*)BSP_MEM_ADDR_ESRAM;
    189         register int i;
    190         for (i = 0; i < 256; i++)
    191         {
    192             *(intvec++) = *(inttab++);
    193         }
     63  /* Set Module Base Address register */
     64  m68k_set_mbar((MBAR & MCF5206E_MBAR_BA) | MCF5206E_MBAR_V);
     65
     66  /* Set System Protection Control Register (SYPCR):
     67   * Bus Monitor Enable, Bus Monitor Timing = 1024 clocks,
     68   * Software watchdog disabled
     69   */
     70  *MCF5206E_SYPCR(MBAR) = MCF5206E_SYPCR_BME |
     71                          MCF5206E_SYPCR_BMT_1024;
     72
     73  /* Set Pin Assignment Register (PAR):
     74   *     Output Timer 0 (not DREQ) on *TOUT[0] / *DREQ[1]
     75   *     Input Timer 0 (not DREQ) on *TIN[0] / *DREQ[0]
     76   *     IRQ, not IPL
     77   *     UART2 RTS signal (not \RSTO)
     78   *     PST/DDATA (not PPIO)
     79   *     *WE (not CS/A)
     80   */
     81  *MCF5206E_PAR(MBAR) = MCF5206E_PAR_PAR9_TOUT |
     82                        MCF5206E_PAR_PAR8_TIN0 |
     83                        MCF5206E_PAR_PAR7_UART2 |
     84                        MCF5206E_PAR_PAR6_IRQ |
     85                        MCF5206E_PAR_PAR5_PST |
     86                        MCF5206E_PAR_PAR4_DDATA |
     87                        MCF5206E_PAR_WE0_WE1_WE2_WE3;
     88
     89  /* Set SIM Configuration Register (SIMR):
     90   * Disable software watchdog timer and bus timeout monitor when
     91   * internal freeze signal is asserted.
     92   */
     93  *MCF5206E_SIMR(MBAR) = MCF5206E_SIMR_FRZ0 | MCF5206E_SIMR_FRZ1;
     94
     95  /* Set Interrupt Mask Register: Disable all interrupts */
     96  *MCF5206E_IMR(MBAR) = 0xFFFF;
     97
     98  /* Assign Interrupt Control Registers as it is defined in bsp.h */
     99  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL1) =
     100                          (BSP_INTLVL_AVEC1 << MCF5206E_ICR_IL_S) |
     101                          (BSP_INTPRIO_AVEC1 << MCF5206E_ICR_IP_S) |
     102                          MCF5206E_ICR_AVEC;
     103  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL2) =
     104                          (BSP_INTLVL_AVEC2 << MCF5206E_ICR_IL_S) |
     105                          (BSP_INTPRIO_AVEC2 << MCF5206E_ICR_IP_S) |
     106                          MCF5206E_ICR_AVEC;
     107  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL3) =
     108                          (BSP_INTLVL_AVEC3 << MCF5206E_ICR_IL_S) |
     109                          (BSP_INTPRIO_AVEC3 << MCF5206E_ICR_IP_S) |
     110                          MCF5206E_ICR_AVEC;
     111  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL4) =
     112                          (BSP_INTLVL_AVEC4 << MCF5206E_ICR_IL_S) |
     113                          (BSP_INTPRIO_AVEC4 << MCF5206E_ICR_IP_S) |
     114                          MCF5206E_ICR_AVEC;
     115  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL5) =
     116                          (BSP_INTLVL_AVEC5 << MCF5206E_ICR_IL_S) |
     117                          (BSP_INTPRIO_AVEC5 << MCF5206E_ICR_IP_S) |
     118                          MCF5206E_ICR_AVEC;
     119  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL6) =
     120                          (BSP_INTLVL_AVEC6 << MCF5206E_ICR_IL_S) |
     121                          (BSP_INTPRIO_AVEC6 << MCF5206E_ICR_IP_S) |
     122                          MCF5206E_ICR_AVEC;
     123  *MCF5206E_ICR(MBAR,MCF5206E_INTR_EXT_IPL7) =
     124                          (BSP_INTLVL_AVEC7 << MCF5206E_ICR_IL_S) |
     125                          (BSP_INTPRIO_AVEC7 << MCF5206E_ICR_IP_S) |
     126                          MCF5206E_ICR_AVEC;
     127  *MCF5206E_ICR(MBAR,MCF5206E_INTR_TIMER_1) =
     128                          (BSP_INTLVL_TIMER1 << MCF5206E_ICR_IL_S) |
     129                          (BSP_INTPRIO_TIMER1 << MCF5206E_ICR_IP_S) |
     130                          MCF5206E_ICR_AVEC;
     131  *MCF5206E_ICR(MBAR,MCF5206E_INTR_TIMER_2) =
     132                          (BSP_INTLVL_TIMER2 << MCF5206E_ICR_IL_S) |
     133                          (BSP_INTPRIO_TIMER2 << MCF5206E_ICR_IP_S) |
     134                          MCF5206E_ICR_AVEC;
     135  *MCF5206E_ICR(MBAR,MCF5206E_INTR_MBUS) =
     136                          (BSP_INTLVL_MBUS << MCF5206E_ICR_IL_S) |
     137                          (BSP_INTPRIO_MBUS << MCF5206E_ICR_IP_S) |
     138                          MCF5206E_ICR_AVEC;
     139  *MCF5206E_ICR(MBAR,MCF5206E_INTR_UART_1) =
     140                          (BSP_INTLVL_UART1 << MCF5206E_ICR_IL_S) |
     141                          (BSP_INTPRIO_UART1 << MCF5206E_ICR_IP_S);
     142  *MCF5206E_ICR(MBAR,MCF5206E_INTR_UART_2) =
     143                          (BSP_INTLVL_UART2 << MCF5206E_ICR_IL_S) |
     144                          (BSP_INTPRIO_UART2 << MCF5206E_ICR_IP_S);
     145  *MCF5206E_ICR(MBAR,MCF5206E_INTR_DMA_0) =
     146                          (BSP_INTLVL_DMA0 << MCF5206E_ICR_IL_S) |
     147                          (BSP_INTPRIO_DMA0 << MCF5206E_ICR_IP_S) |
     148                          MCF5206E_ICR_AVEC;
     149  *MCF5206E_ICR(MBAR,MCF5206E_INTR_DMA_1) =
     150                          (BSP_INTLVL_DMA1 << MCF5206E_ICR_IL_S) |
     151                          (BSP_INTPRIO_DMA1 << MCF5206E_ICR_IP_S) |
     152                          MCF5206E_ICR_AVEC;
     153
     154  /* Software Watchdog timer (not used now) */
     155  *MCF5206E_SWIVR(MBAR) = 0x0F; /* Uninitialized interrupt */
     156  *MCF5206E_SWSR(MBAR) = MCF5206E_SWSR_KEY1;
     157  *MCF5206E_SWSR(MBAR) = MCF5206E_SWSR_KEY2;
     158
     159  /* Configuring Chip Selects */
     160  /* CS2: SRAM memory */
     161  *MCF5206E_CSAR(MBAR,2) = BSP_MEM_ADDR_ESRAM >> 16;
     162  *MCF5206E_CSMR(MBAR,2) = BSP_MEM_MASK_ESRAM;
     163  *MCF5206E_CSCR(MBAR,2) = MCF5206E_CSCR_WS1 |
     164                           MCF5206E_CSCR_PS_32 |
     165                           MCF5206E_CSCR_AA |
     166                           MCF5206E_CSCR_EMAA |
     167                           MCF5206E_CSCR_WR |
     168                           MCF5206E_CSCR_RD;
     169
     170  /* CS3: GPIO on eLITE board */
     171  *MCF5206E_CSAR(MBAR,3) = BSP_MEM_ADDR_GPIO >> 16;
     172  *MCF5206E_CSMR(MBAR,3) = BSP_MEM_MASK_GPIO;
     173  *MCF5206E_CSCR(MBAR,3) = MCF5206E_CSCR_WS15 |
     174                           MCF5206E_CSCR_PS_16 |
     175                           MCF5206E_CSCR_AA |
     176                           MCF5206E_CSCR_EMAA |
     177                           MCF5206E_CSCR_WR |
     178                           MCF5206E_CSCR_RD;
     179
     180  {
     181    uint32_t         *inttab = (uint32_t*)&INTERRUPT_VECTOR;
     182    uint32_t         *intvec = (uint32_t*)BSP_MEM_ADDR_ESRAM;
     183    register int i;
     184
     185    for (i = 0; i < 256; i++) {
     186      *(intvec++) = *(inttab++);
    194187    }
    195     m68k_set_vbr(BSP_MEM_ADDR_ESRAM);
    196 
    197     /* CS0: Flash EEPROM */
    198     *MCF5206E_CSAR(MBAR,0) = BSP_MEM_ADDR_FLASH >> 16;
    199     *MCF5206E_CSCR(MBAR,0) = MCF5206E_CSCR_WS3 |
    200                              MCF5206E_CSCR_AA |
    201                              MCF5206E_CSCR_PS_16 |
    202                              MCF5206E_CSCR_EMAA |
    203                              MCF5206E_CSCR_WR |
    204                              MCF5206E_CSCR_RD;
    205     *MCF5206E_CSMR(MBAR,0) = BSP_MEM_MASK_FLASH;
    206 
    207     /*
    208      * Invalidate the cache and disable it
    209      */
    210     mcf5206e_disable_cache();
    211 
    212     /*
    213      * Setup ACRs so that if cache turned on, periphal accesses
    214      * are not messed up.  (Non-cacheable, serialized)
    215      */
    216     m68k_set_acr0 ( 0
    217         | MCF5206E_ACR_BASE(BSP_MEM_ADDR_ESRAM)
    218         | MCF5206E_ACR_MASK(BSP_MEM_MASK_ESRAM)
    219         | MCF5206E_ACR_EN
    220         | MCF5206E_ACR_SM_ANY
    221     );
    222     m68k_set_acr1 ( 0
    223         | MCF5206E_ACR_BASE(BSP_MEM_ADDR_FLASH)
    224         | MCF5206E_ACR_MASK(BSP_MEM_MASK_FLASH)
    225         | MCF5206E_ACR_EN
    226         | MCF5206E_ACR_SM_ANY
    227     );
    228 
    229     mcf5206e_enable_cache();
     188  }
     189  m68k_set_vbr(BSP_MEM_ADDR_ESRAM);
     190
     191  /* CS0: Flash EEPROM */
     192  *MCF5206E_CSAR(MBAR,0) = BSP_MEM_ADDR_FLASH >> 16;
     193  *MCF5206E_CSCR(MBAR,0) = MCF5206E_CSCR_WS3 |
     194                           MCF5206E_CSCR_AA |
     195                           MCF5206E_CSCR_PS_16 |
     196                           MCF5206E_CSCR_EMAA |
     197                           MCF5206E_CSCR_WR |
     198                           MCF5206E_CSCR_RD;
     199  *MCF5206E_CSMR(MBAR,0) = BSP_MEM_MASK_FLASH;
     200
     201  /*
     202   * Invalidate the cache and disable it
     203   */
     204  mcf5206e_disable_cache();
     205
     206  /*
     207   * Setup ACRs so that if cache turned on, periphal accesses
     208   * are not messed up.  (Non-cacheable, serialized)
     209   */
     210  m68k_set_acr0 ( 0
     211      | MCF5206E_ACR_BASE(BSP_MEM_ADDR_ESRAM)
     212      | MCF5206E_ACR_MASK(BSP_MEM_MASK_ESRAM)
     213      | MCF5206E_ACR_EN
     214      | MCF5206E_ACR_SM_ANY
     215  );
     216  m68k_set_acr1 ( 0
     217      | MCF5206E_ACR_BASE(BSP_MEM_ADDR_FLASH)
     218      | MCF5206E_ACR_MASK(BSP_MEM_MASK_FLASH)
     219      | MCF5206E_ACR_EN
     220      | MCF5206E_ACR_SM_ANY
     221  );
     222
     223  mcf5206e_enable_cache();
    230224
    231225  /*
  • c/src/lib/libbsp/m68k/mcf5206elite/tod/ds1307.c

    r46dad9d4 ra94fb39  
    1717 *    + two digit years 00-87 are mapped to 2000-2087
    1818 *    + two digit years 88-99 are mapped to 1988-1999
    19  *
     19 */
     20
     21/*
    2022 * Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
    2123 * Author: Victor V. Vengerov <vvv@oktet.ru>
     
    2325 * The license and distribution terms for this file may be
    2426 * found in the file LICENSE in this distribution or at
    25  *
    2627 * http://www.rtems.org/license/LICENSE.
    2728 */
     
    4445 *     minor -- minor RTC device number
    4546 */
    46 void
    47 ds1307_initialize(int minor)
     47static void ds1307_initialize(int minor)
    4848{
    49     i2c_message_status status;
    50     int try;
    51     uint8_t         sec;
    52     i2c_bus_number bus;
    53     i2c_address addr;
    54 
    55     bus = RTC_Table[minor].ulCtrlPort1;
    56     addr = RTC_Table[minor].ulDataPort;
    57 
    58     /* Read SECONDS register */
    59     try = 0;
    60     do {
    61         status = i2c_wbrd(bus, addr, 0, &sec, sizeof(sec));
    62         try++;
    63     } while ((status != I2C_SUCCESSFUL) && (try < 15));
    64 
    65     /* If clock is halted, reset and start the clock */
    66     if ((sec & DS1307_SECOND_HALT) != 0)
    67     {
    68         uint8_t         start[8];
    69         memset(start, 0, sizeof(start));
    70         start[0] = DS1307_SECOND;
    71         try = 0;
    72         do {
    73             status = i2c_write(bus, addr, start, 2);
    74         } while ((status != I2C_SUCCESSFUL) && (try < 15));
    75     }
     49  i2c_message_status status;
     50  int try;
     51  uint8_t         sec;
     52  i2c_bus_number bus;
     53  i2c_address addr;
     54
     55  bus = RTC_Table[minor].ulCtrlPort1;
     56  addr = RTC_Table[minor].ulDataPort;
     57
     58  /* Read SECONDS register */
     59  try = 0;
     60  do {
     61    status = i2c_wbrd(bus, addr, 0, &sec, sizeof(sec));
     62    try++;
     63  } while ((status != I2C_SUCCESSFUL) && (try < 15));
     64
     65  /* If clock is halted, reset and start the clock */
     66  if ((sec & DS1307_SECOND_HALT) != 0) {
     67      uint8_t         start[8];
     68      memset(start, 0, sizeof(start));
     69      start[0] = DS1307_SECOND;
     70      try = 0;
     71      do {
     72          status = i2c_write(bus, addr, start, 2);
     73      } while ((status != I2C_SUCCESSFUL) && (try < 15));
     74  }
    7675}
    7776
     
    8887 *     -1, if error occured
    8988 */
    90 int
    91 ds1307_get_time(int minor, rtems_time_of_day *time)
     89static int ds1307_get_time(int minor, rtems_time_of_day *time)
    9290{
    93     i2c_bus_number bus;
    94     i2c_address addr;
    95     uint8_t         info[8];
    96     uint32_t         v1, v2;
    97     i2c_message_status status;
    98     int try;
    99 
    100     if (time == NULL)
    101         return -1;
    102 
    103     bus = RTC_Table[minor].ulCtrlPort1;
    104     addr = RTC_Table[minor].ulDataPort;
    105 
    106     memset(time, 0, sizeof(rtems_time_of_day));
    107     try = 0;
    108     do {
    109         status = i2c_wbrd(bus, addr, 0, info, sizeof(info));
    110         try++;
    111     } while ((status != I2C_SUCCESSFUL) && (try < 10));
    112 
    113     if (status != I2C_SUCCESSFUL)
    114     {
    115         return -1;
     91  i2c_bus_number bus;
     92  i2c_address addr;
     93  uint8_t         info[8];
     94  uint32_t         v1, v2;
     95  i2c_message_status status;
     96  int try;
     97
     98  if (time == NULL)
     99    return -1;
     100
     101  bus = RTC_Table[minor].ulCtrlPort1;
     102  addr = RTC_Table[minor].ulDataPort;
     103
     104  memset(time, 0, sizeof(rtems_time_of_day));
     105  try = 0;
     106  do {
     107    status = i2c_wbrd(bus, addr, 0, info, sizeof(info));
     108    try++;
     109  } while ((status != I2C_SUCCESSFUL) && (try < 10));
     110
     111  if (status != I2C_SUCCESSFUL) {
     112    return -1;
     113  }
     114
     115  v1 = info[DS1307_YEAR];
     116  v2 = From_BCD(v1);
     117  if (v2 < 88)
     118    time->year = 2000 + v2;
     119  else
     120    time->year = 1900 + v2;
     121
     122  v1 = info[DS1307_MONTH] & ~0xE0;
     123  time->month = From_BCD(v1);
     124
     125  v1 = info[DS1307_DAY] & ~0xC0;
     126  time->day = From_BCD(v1);
     127
     128  v1 = info[DS1307_HOUR];
     129  if (v1 & DS1307_HOUR_12) {
     130    v2 = v1 & ~0xE0;
     131    if (v1 & DS1307_HOUR_PM) {
     132      time->hour = From_BCD(v2) + 12;
     133    } else {
     134      time->hour = From_BCD(v2);
    116135    }
    117 
    118     v1 = info[DS1307_YEAR];
    119     v2 = From_BCD(v1);
    120     if (v2 < 88)
    121         time->year = 2000 + v2;
    122     else
    123         time->year = 1900 + v2;
    124 
    125     v1 = info[DS1307_MONTH] & ~0xE0;
    126     time->month = From_BCD(v1);
    127 
    128     v1 = info[DS1307_DAY] & ~0xC0;
    129     time->day = From_BCD(v1);
    130 
    131     v1 = info[DS1307_HOUR];
    132     if (v1 & DS1307_HOUR_12)
    133     {
    134         v2 = v1 & ~0xE0;
    135         if (v1 & DS1307_HOUR_PM)
    136         {
    137             time->hour = From_BCD(v2) + 12;
    138         }
    139         else
    140         {
    141             time->hour = From_BCD(v2);
    142         }
    143     }
    144     else
    145     {
    146         v2 = v1 & ~0xC0;
    147         time->hour = From_BCD(v2);
    148     }
    149 
    150     v1 = info[DS1307_MINUTE] & ~0x80;
    151     time->minute = From_BCD(v1);
    152 
    153     v1 = info[DS1307_SECOND];
    154     v2 = v1 & ~0x80;
    155     time->second = From_BCD(v2);
    156 
    157     return 0;
     136  } else {
     137    v2 = v1 & ~0xC0;
     138    time->hour = From_BCD(v2);
     139  }
     140
     141  v1 = info[DS1307_MINUTE] & ~0x80;
     142  time->minute = From_BCD(v1);
     143
     144  v1 = info[DS1307_SECOND];
     145  v2 = v1 & ~0x80;
     146  time->second = From_BCD(v2);
     147
     148  return 0;
    158149}
    159150
     
    169160 *     -1, if error occured
    170161 */
    171 int
    172 ds1307_set_time(int minor, const rtems_time_of_day *time)
     162static int ds1307_set_time(int minor, const rtems_time_of_day *time)
    173163{
    174     i2c_bus_number bus;
    175     i2c_address addr;
    176     uint8_t         info[8];
    177     i2c_message_status status;
    178     int try;
    179 
    180     if (time == NULL)
    181         return -1;
    182 
    183     bus = RTC_Table[minor].ulCtrlPort1;
    184     addr = RTC_Table[minor].ulDataPort;
    185 
    186     if (time->year >= 2088)
    187         rtems_fatal_error_occurred(RTEMS_INVALID_NUMBER);
    188 
    189     info[0] = DS1307_SECOND;
    190     info[1 + DS1307_YEAR] = To_BCD(time->year % 100);
    191     info[1 + DS1307_MONTH] = To_BCD(time->month);
    192     info[1 + DS1307_DAY] = To_BCD(time->day);
    193     info[1 + DS1307_HOUR] = To_BCD(time->hour);
    194     info[1 + DS1307_MINUTE] = To_BCD(time->minute);
    195     info[1 + DS1307_SECOND] = To_BCD(time->second);
    196     info[1 + DS1307_DAY_OF_WEEK] = 1; /* Do not set day of week */
    197 
    198     try = 0;
    199     do {
    200         status = i2c_write(bus, addr, info, 8);
    201         try++;
    202     } while ((status != I2C_SUCCESSFUL) && (try < 10));
    203 
    204     if (status != I2C_SUCCESSFUL)
    205         return -1;
    206     else
    207         return 0;
     164  i2c_bus_number bus;
     165  i2c_address addr;
     166  uint8_t         info[8];
     167  i2c_message_status status;
     168  int try;
     169
     170  if (time == NULL)
     171    return -1;
     172
     173  bus = RTC_Table[minor].ulCtrlPort1;
     174  addr = RTC_Table[minor].ulDataPort;
     175
     176  if (time->year >= 2088)
     177      rtems_fatal_error_occurred(RTEMS_INVALID_NUMBER);
     178
     179  info[0] = DS1307_SECOND;
     180  info[1 + DS1307_YEAR] = To_BCD(time->year % 100);
     181  info[1 + DS1307_MONTH] = To_BCD(time->month);
     182  info[1 + DS1307_DAY] = To_BCD(time->day);
     183  info[1 + DS1307_HOUR] = To_BCD(time->hour);
     184  info[1 + DS1307_MINUTE] = To_BCD(time->minute);
     185  info[1 + DS1307_SECOND] = To_BCD(time->second);
     186  info[1 + DS1307_DAY_OF_WEEK] = 1; /* Do not set day of week */
     187
     188  try = 0;
     189  do {
     190    status = i2c_write(bus, addr, info, 8);
     191    try++;
     192  } while ((status != I2C_SUCCESSFUL) && (try < 10));
     193
     194  if (status != I2C_SUCCESSFUL)
     195    return -1;
     196  else
     197    return 0;
    208198}
    209199
     
    211201
    212202rtc_fns ds1307_fns = {
    213     ds1307_initialize,
    214     ds1307_get_time,
    215     ds1307_set_time
     203  ds1307_initialize,
     204  ds1307_get_time,
     205  ds1307_set_time
    216206};
  • c/src/lib/libcpu/m68k/mcf5206/console/mcfuart.c

    r46dad9d4 ra94fb39  
    11/*
    22 * Generic UART Serial driver for Motorola Coldfire processors
    3  *
     3 */
     4
     5/*
    46 * Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russian Fed.
    57 * Author: Victor V. Vengerov <vvv@oktet.ru>
     
    1113 *  found in the file LICENSE in this distribution or at
    1214 *  http://www.rtems.org/license/LICENSE.
    13  *
    1415 */
    1516
     
    2425 */
    2526static struct {
    26     mcfuart *uart;
    27     int      vec;
     27  mcfuart *uart;
     28  int      vec;
    2829} int_driven_uart[2];
    2930
     
    4950 */
    5051rtems_status_code
    51 mcfuart_init(mcfuart *uart, void *tty, uint8_t   intvec,
    52              uint32_t   chn)
    53 {
    54     if (uart == NULL)
    55         return RTEMS_INVALID_ADDRESS;
    56 
    57     if ((chn <= 0) || (chn > MCF5206E_UART_CHANNELS))
    58         return RTEMS_INVALID_NUMBER;
    59 
    60     uart->chn = chn;
    61     uart->intvec = intvec;
    62     uart->tty = tty;
    63 
    64     return RTEMS_SUCCESSFUL;
     52mcfuart_init(
     53  mcfuart   *uart,
     54  void      *tty,
     55  uint8_t    intvec,
     56  uint32_t   chn
     57)
     58{
     59  if (uart == NULL)
     60      return RTEMS_INVALID_ADDRESS;
     61
     62  if ((chn <= 0) || (chn > MCF5206E_UART_CHANNELS))
     63      return RTEMS_INVALID_NUMBER;
     64
     65  uart->chn = chn;
     66  uart->intvec = intvec;
     67  uart->tty = tty;
     68
     69  return RTEMS_SUCCESSFUL;
    6570}
    6671
     
    7883mcfuart_set_baudrate(mcfuart *uart, speed_t baud)
    7984{
    80     uint32_t   div;
    81     uint32_t   rate;
    82     switch (baud)
    83     {
    84         case B50:     rate = 50; break;
    85         case B75:     rate = 75; break;
    86         case B110:    rate = 110; break;
    87         case B134:    rate = 134; break;
    88         case B150:    rate = 150; break;
    89         case B200:    rate = 200; break;
    90         case B300:    rate = 300; break;
    91         case B600:    rate = 600; break;
    92         case B1200:   rate = 1200; break;
    93         case B2400:   rate = 2400; break;
    94         case B4800:   rate = 4800; break;
    95         case B9600:   rate = 9600; break;
    96         case B19200:  rate = 19200; break;
    97         case B38400:  rate = 38400; break;
    98         case B57600:  rate = 57600; break;
     85  uint32_t   div;
     86  uint32_t   rate;
     87
     88    switch (baud) {
     89      case B50:     rate = 50; break;
     90      case B75:     rate = 75; break;
     91      case B110:    rate = 110; break;
     92      case B134:    rate = 134; break;
     93      case B150:    rate = 150; break;
     94      case B200:    rate = 200; break;
     95      case B300:    rate = 300; break;
     96      case B600:    rate = 600; break;
     97      case B1200:   rate = 1200; break;
     98      case B2400:   rate = 2400; break;
     99      case B4800:   rate = 4800; break;
     100      case B9600:   rate = 9600; break;
     101      case B19200:  rate = 19200; break;
     102      case B38400:  rate = 38400; break;
     103      case B57600:  rate = 57600; break;
    99104#ifdef B115200
    100         case B115200: rate = 115200; break;
     105      case B115200: rate = 115200; break;
    101106#endif
    102107#ifdef B230400
    103         case B230400: rate = 230400; break;
     108      case B230400: rate = 230400; break;
    104109#endif
    105         default:      rate = 9600; break;
    106     }
    107 
    108     div = SYSTEM_CLOCK_FREQUENCY / (rate * 32);
    109 
    110     *MCF5206E_UBG1(MBAR,uart->chn) = (uint8_t)((div >> 8) & 0xff);
    111     *MCF5206E_UBG2(MBAR,uart->chn) = (uint8_t)(div & 0xff);
     110      default:      rate = 9600; break;
     111    }
     112
     113  div = SYSTEM_CLOCK_FREQUENCY / (rate * 32);
     114
     115  *MCF5206E_UBG1(MBAR,uart->chn) = (uint8_t)((div >> 8) & 0xff);
     116  *MCF5206E_UBG2(MBAR,uart->chn) = (uint8_t)(div & 0xff);
    112117}
    113118
     
    129134 *     User's Manual, 12.5 UART Module Initialization Sequence
    130135 */
    131 rtems_status_code
    132 mcfuart_reset(mcfuart *uart)
    133 {
    134     register uint32_t   chn;
    135     rtems_status_code rc;
    136 
    137     if (uart == NULL)
    138         return RTEMS_INVALID_ADDRESS;
    139 
    140     chn = uart->chn;
    141 
    142     /* Reset the receiver and transmitter */
    143     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_RX;
    144     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_TX;
    145 
    146     /*
    147      * Program the vector number for a UART module interrupt, or
    148      * disable UART interrupts if polled I/O. Enable the desired
    149      * interrupt sources.
    150      */
    151     if (uart->intvec != 0)
    152     {
    153         int_driven_uart[chn - 1].uart = uart;
    154         int_driven_uart[chn - 1].vec = uart->intvec;
    155         rc = rtems_interrupt_catch(mcfuart_interrupt_handler, uart->intvec,
    156                                    &uart->old_handler);
    157         if (rc != RTEMS_SUCCESSFUL)
    158             return rc;
    159         *MCF5206E_UIVR(MBAR,chn) = uart->intvec;
    160         *MCF5206E_UIMR(MBAR,chn) = MCF5206E_UIMR_FFULL;
    161         *MCF5206E_UACR(MBAR,chn) = MCF5206E_UACR_IEC;
    162         *MCF5206E_IMR(MBAR) &= ~MCF5206E_INTR_BIT(uart->chn == 1 ?
    163                                                   MCF5206E_INTR_UART_1 :
    164                                                   MCF5206E_INTR_UART_2);
    165     }
    166     else
    167     {
    168         *MCF5206E_UIMR(MBAR,chn) = 0;
    169     }
    170 
    171     /* Select the receiver and transmitter clock. */
    172     mcfuart_set_baudrate(uart, B19200); /* dBUG defaults (unfortunately,
    173                                            it is differ to termios default */
    174     *MCF5206E_UCSR(MBAR,chn) =
    175         MCF5206E_UCSR_RCS_TIMER | MCF5206E_UCSR_TCS_TIMER;
    176 
    177     /* Mode Registers 1,2 - set termios defaults (8N1) */
    178     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_MR;
    179     *MCF5206E_UMR(MBAR,chn) =
     136rtems_status_code mcfuart_reset(mcfuart *uart)
     137{
     138  register uint32_t   chn;
     139  rtems_status_code rc;
     140
     141  if (uart == NULL)
     142    return RTEMS_INVALID_ADDRESS;
     143
     144  chn = uart->chn;
     145
     146  /* Reset the receiver and transmitter */
     147  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_RX;
     148  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_TX;
     149
     150  /*
     151   * Program the vector number for a UART module interrupt, or
     152   * disable UART interrupts if polled I/O. Enable the desired
     153   * interrupt sources.
     154   */
     155  if (uart->intvec != 0) {
     156    int_driven_uart[chn - 1].uart = uart;
     157    int_driven_uart[chn - 1].vec = uart->intvec;
     158    rc = rtems_interrupt_catch(mcfuart_interrupt_handler, uart->intvec,
     159                               &uart->old_handler);
     160    if (rc != RTEMS_SUCCESSFUL)
     161      return rc;
     162    *MCF5206E_UIVR(MBAR,chn) = uart->intvec;
     163    *MCF5206E_UIMR(MBAR,chn) = MCF5206E_UIMR_FFULL;
     164    *MCF5206E_UACR(MBAR,chn) = MCF5206E_UACR_IEC;
     165    *MCF5206E_IMR(MBAR) &= ~MCF5206E_INTR_BIT(uart->chn == 1 ?
     166                                              MCF5206E_INTR_UART_1 :
     167                                              MCF5206E_INTR_UART_2);
     168  } else {
     169    *MCF5206E_UIMR(MBAR,chn) = 0;
     170  }
     171
     172  /* Select the receiver and transmitter clock. */
     173  mcfuart_set_baudrate(uart, B19200); /* dBUG defaults (unfortunately,
     174                                         it is differ to termios default */
     175  *MCF5206E_UCSR(MBAR,chn) = MCF5206E_UCSR_RCS_TIMER | MCF5206E_UCSR_TCS_TIMER;
     176
     177  /* Mode Registers 1,2 - set termios defaults (8N1) */
     178  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_MR;
     179  *MCF5206E_UMR(MBAR,chn) =
    180180/*      MCF5206E_UMR1_RXRTS | */
    181         MCF5206E_UMR1_PM_NO_PARITY |
    182         MCF5206E_UMR1_BC_8;
    183     *MCF5206E_UMR(MBAR,chn) =
    184         MCF5206E_UMR2_CM_NORMAL |
     181      MCF5206E_UMR1_PM_NO_PARITY |
     182      MCF5206E_UMR1_BC_8;
     183  *MCF5206E_UMR(MBAR,chn) =
     184      MCF5206E_UMR2_CM_NORMAL |
    185185/*      MCF5206E_UMR2_TXCTS | */
    186         MCF5206E_UMR2_SB_1;
    187 
    188     /* Enable Receiver and Transmitter */
    189     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_ERR;
    190     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_TC_ENABLE;
    191     *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_RC_ENABLE;
    192 
    193     return RTEMS_SUCCESSFUL;
     186      MCF5206E_UMR2_SB_1;
     187
     188  /* Enable Receiver and Transmitter */
     189  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_MISC_RESET_ERR;
     190  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_TC_ENABLE;
     191  *MCF5206E_UCR(MBAR,chn) = MCF5206E_UCR_RC_ENABLE;
     192
     193  return RTEMS_SUCCESSFUL;
    194194}
    195195
     
    206206 *     other case
    207207 */
    208 rtems_status_code
    209 mcfuart_disable(mcfuart *uart)
    210 {
    211     rtems_status_code rc;
    212     *MCF5206E_UCR(MBAR,uart->chn) =
    213         MCF5206E_UCR_TC_DISABLE |
    214         MCF5206E_UCR_RC_DISABLE;
    215     if (uart->intvec != 0)
    216     {
    217         *MCF5206E_IMR(MBAR) |=  MCF5206E_INTR_BIT(uart->chn == 1 ?
    218                                                   MCF5206E_INTR_UART_1 :
    219                                                   MCF5206E_INTR_UART_2);
    220         rc = rtems_interrupt_catch(uart->old_handler, uart->intvec, NULL);
    221         int_driven_uart[uart->chn - 1].uart = NULL;
    222         int_driven_uart[uart->chn - 1].vec = 0;
    223         if (rc != RTEMS_SUCCESSFUL)
    224             return rc;
    225     }
    226     return RTEMS_SUCCESSFUL;
     208rtems_status_code mcfuart_disable(mcfuart *uart)
     209{
     210  rtems_status_code rc;
     211
     212  *MCF5206E_UCR(MBAR,uart->chn) =
     213      MCF5206E_UCR_TC_DISABLE |
     214      MCF5206E_UCR_RC_DISABLE;
     215  if (uart->intvec != 0) {
     216      *MCF5206E_IMR(MBAR) |=  MCF5206E_INTR_BIT(uart->chn == 1 ?
     217                                                MCF5206E_INTR_UART_1 :
     218                                                MCF5206E_INTR_UART_2);
     219      rc = rtems_interrupt_catch(uart->old_handler, uart->intvec, NULL);
     220      int_driven_uart[uart->chn - 1].uart = NULL;
     221      int_driven_uart[uart->chn - 1].vec = 0;
     222      if (rc != RTEMS_SUCCESSFUL)
     223          return rc;
     224  }
     225  return RTEMS_SUCCESSFUL;
    227226}
    228227
     
    239238 *     RTEMS_SUCCESSFUL
    240239 */
    241 int
    242 mcfuart_set_attributes(mcfuart *uart, const struct termios *t)
    243 {
    244     int level;
    245     speed_t baud;
    246     uint8_t   umr1, umr2;
    247 
    248     baud = cfgetospeed(t);
    249     umr1 = 0;
    250     umr2 = MCF5206E_UMR2_CM_NORMAL;
    251 
    252     /* Set flow control */
    253     if ((t->c_cflag & CRTSCTS) != 0)
    254     {
    255         umr1 |= MCF5206E_UMR1_RXRTS;
    256         umr2 |= MCF5206E_UMR2_TXCTS;
    257     }
    258 
    259     /* Set character size */
    260     switch (t->c_cflag & CSIZE)
    261     {
    262         case CS5: umr1 |= MCF5206E_UMR1_BC_5; break;
    263         case CS6: umr1 |= MCF5206E_UMR1_BC_6; break;
    264         case CS7: umr1 |= MCF5206E_UMR1_BC_7; break;
    265         case CS8: umr1 |= MCF5206E_UMR1_BC_8; break;
    266     }
    267 
    268     /* Set number of stop bits */
    269     if ((t->c_cflag & CSTOPB) != 0)
    270     {
    271         if ((t->c_cflag & CSIZE) == CS5)
    272         {
    273             umr2 |= MCF5206E_UMR2_SB5_2;
    274         }
    275         else
    276         {
    277             umr2 |= MCF5206E_UMR2_SB_2;
    278         }
    279     }
    280     else
    281     {
    282         if ((t->c_cflag & CSIZE) == CS5)
    283         {
    284             umr2 |= MCF5206E_UMR2_SB5_1;
    285         }
    286         else
    287         {
    288             umr2 |= MCF5206E_UMR2_SB_1;
    289         }
    290     }
    291 
    292     /* Set parity mode */
    293     if ((t->c_cflag & PARENB) != 0)
    294     {
    295         if ((t->c_cflag & PARODD) != 0)
    296         {
    297             umr1 |= MCF5206E_UMR1_PM_ODD;
    298         }
    299         else
    300         {
    301             umr1 |= MCF5206E_UMR1_PM_EVEN;
    302         }
    303     }
    304     else
    305     {
    306         umr1 |= MCF5206E_UMR1_PM_NO_PARITY;
    307     }
    308 
    309     rtems_interrupt_disable(level);
     240int mcfuart_set_attributes(mcfuart *uart, const struct termios *t)
     241{
     242  int level;
     243  speed_t baud;
     244  uint8_t   umr1, umr2;
     245
     246  baud = cfgetospeed(t);
     247  umr1 = 0;
     248  umr2 = MCF5206E_UMR2_CM_NORMAL;
     249
     250  /* Set flow control */
     251  if ((t->c_cflag & CRTSCTS) != 0) {
     252    umr1 |= MCF5206E_UMR1_RXRTS;
     253    umr2 |= MCF5206E_UMR2_TXCTS;
     254  }
     255
     256  /* Set character size */
     257  switch (t->c_cflag & CSIZE) {
     258    case CS5: umr1 |= MCF5206E_UMR1_BC_5; break;
     259    case CS6: umr1 |= MCF5206E_UMR1_BC_6; break;
     260    case CS7: umr1 |= MCF5206E_UMR1_BC_7; break;
     261    case CS8: umr1 |= MCF5206E_UMR1_BC_8; break;
     262  }
     263
     264  /* Set number of stop bits */
     265  if ((t->c_cflag & CSTOPB) != 0) {
     266    if ((t->c_cflag & CSIZE) == CS5) {
     267      umr2 |= MCF5206E_UMR2_SB5_2;
     268    } else {
     269      umr2 |= MCF5206E_UMR2_SB_2;
     270    }
     271  } else {
     272    if ((t->c_cflag & CSIZE) == CS5) {
     273      umr2 |= MCF5206E_UMR2_SB5_1;
     274    } else {
     275      umr2 |= MCF5206E_UMR2_SB_1;
     276    }
     277  }
     278
     279  /* Set parity mode */
     280  if ((t->c_cflag & PARENB) != 0) {
     281    if ((t->c_cflag & PARODD) != 0) {
     282      umr1 |= MCF5206E_UMR1_PM_ODD;
     283    } else {
     284      umr1 |= MCF5206E_UMR1_PM_EVEN;
     285    }
     286  } else {
     287    umr1 |= MCF5206E_UMR1_PM_NO_PARITY;
     288  }
     289
     290  rtems_interrupt_disable(level);
     291  *MCF5206E_UCR(MBAR,uart->chn) =
     292      MCF5206E_UCR_TC_DISABLE | MCF5206E_UCR_RC_DISABLE;
     293  mcfuart_set_baudrate(uart, baud);
     294  *MCF5206E_UCR(MBAR,uart->chn) = MCF5206E_UCR_MISC_RESET_MR;
     295  *MCF5206E_UMR(MBAR,uart->chn) = umr1;
     296  *MCF5206E_UMR(MBAR,uart->chn) = umr2;
     297  if ((t->c_cflag & CREAD) != 0) {
    310298    *MCF5206E_UCR(MBAR,uart->chn) =
    311         MCF5206E_UCR_TC_DISABLE | MCF5206E_UCR_RC_DISABLE;
    312     mcfuart_set_baudrate(uart, baud);
    313     *MCF5206E_UCR(MBAR,uart->chn) = MCF5206E_UCR_MISC_RESET_MR;
    314     *MCF5206E_UMR(MBAR,uart->chn) = umr1;
    315     *MCF5206E_UMR(MBAR,uart->chn) = umr2;
    316     if ((t->c_cflag & CREAD) != 0)
    317     {
    318         *MCF5206E_UCR(MBAR,uart->chn) =
    319             MCF5206E_UCR_TC_ENABLE | MCF5206E_UCR_RC_ENABLE;
    320     }
    321     else
    322     {
    323         *MCF5206E_UCR(MBAR,uart->chn) = MCF5206E_UCR_TC_ENABLE;
    324     }
    325     rtems_interrupt_enable(level);
    326 
    327     return RTEMS_SUCCESSFUL;
     299        MCF5206E_UCR_TC_ENABLE | MCF5206E_UCR_RC_ENABLE;
     300  } else {
     301    *MCF5206E_UCR(MBAR,uart->chn) = MCF5206E_UCR_TC_ENABLE;
     302  }
     303  rtems_interrupt_enable(level);
     304
     305  return RTEMS_SUCCESSFUL;
    328306}
    329307
     
    344322 *     code of received character or -1 if no characters received.
    345323 */
    346 int
    347 mcfuart_poll_read(mcfuart *uart)
    348 {
    349     uint8_t   usr;
    350     int ch;
    351     if (uart->parerr_mark_flag == true)
    352     {
    353         uart->parerr_mark_flag = false;
    354         return 0;
    355     }
    356     usr = *MCF5206E_USR(MBAR,uart->chn);
    357     if ((usr & MCF5206E_USR_RXRDY) != 0)
    358     {
    359         if (((usr & (MCF5206E_USR_FE | MCF5206E_USR_PE)) != 0) &&
    360             !(uart->c_iflag & IGNPAR))
    361         {
    362             ch = *MCF5206E_URB(MBAR,uart->chn); /* Clear error bits */
    363             if (uart->c_iflag & PARMRK)
    364             {
    365                 uart->parerr_mark_flag = true;
    366                 ch = 0xff;
    367             }
    368             else
    369             {
    370                 ch = 0;
    371             }
    372         }
    373         else
    374         {
    375             ch = *MCF5206E_URB(MBAR,uart->chn);
    376         }
    377     }
    378     else
    379         ch = -1;
    380     return ch;
     324int mcfuart_poll_read(mcfuart *uart)
     325{
     326  uint8_t   usr;
     327  int ch;
     328
     329  if (uart->parerr_mark_flag == true) {
     330    uart->parerr_mark_flag = false;
     331    return 0;
     332  }
     333
     334  usr = *MCF5206E_USR(MBAR,uart->chn);
     335  if ((usr & MCF5206E_USR_RXRDY) != 0) {
     336    if (((usr & (MCF5206E_USR_FE | MCF5206E_USR_PE)) != 0) &&
     337        !(uart->c_iflag & IGNPAR)) {
     338      ch = *MCF5206E_URB(MBAR,uart->chn); /* Clear error bits */
     339      if (uart->c_iflag & PARMRK) {
     340        uart->parerr_mark_flag = true;
     341        ch = 0xff;
     342      } else {
     343        ch = 0;
     344      }
     345    } else {
     346      ch = *MCF5206E_URB(MBAR,uart->chn);
     347    }
     348  } else
     349    ch = -1;
     350  return ch;
    381351}
    382352
     
    393363 *     0
    394364 */
    395 ssize_t
    396 mcfuart_poll_write(mcfuart *uart, const char *buf, size_t len)
     365ssize_t mcfuart_poll_write(mcfuart *uart, const char *buf, size_t len)
    397366{
    398367  size_t retval = len;
    399368
    400     while (len--)
    401     {
    402         while ((*MCF5206E_USR(MBAR, uart->chn) & MCF5206E_USR_TXRDY) == 0);
    403         *MCF5206E_UTB(MBAR, uart->chn) = *buf++;
    404     }
    405     return retval;
     369  while (len--) {
     370    while ((*MCF5206E_USR(MBAR, uart->chn) & MCF5206E_USR_TXRDY) == 0);
     371    *MCF5206E_UTB(MBAR, uart->chn) = *buf++;
     372  }
     373  return retval;
    406374}
    407375
     
    415383 *     none
    416384 */
    417 static rtems_isr
    418 mcfuart_interrupt_handler(rtems_vector_number vec)
    419 {
    420     mcfuart *uart;
    421     register uint8_t   usr;
    422     register uint8_t   uisr;
    423     register int chn;
    424     register int bp = 0;
    425 
    426     /* Find UART descriptor from vector number */
    427     if (int_driven_uart[0].vec == vec)
    428         uart = int_driven_uart[0].uart;
    429     else if (int_driven_uart[1].vec == vec)
    430         uart = int_driven_uart[1].uart;
     385static rtems_isr mcfuart_interrupt_handler(rtems_vector_number vec)
     386{
     387  mcfuart *uart;
     388  register uint8_t   usr;
     389  register uint8_t   uisr;
     390  register int chn;
     391  register int bp = 0;
     392
     393  /* Find UART descriptor from vector number */
     394  if (int_driven_uart[0].vec == vec)
     395    uart = int_driven_uart[0].uart;
     396  else if (int_driven_uart[1].vec == vec)
     397    uart = int_driven_uart[1].uart;
     398  else
     399    return;
     400
     401  chn = uart->chn;
     402
     403  uisr = *MCF5206E_UISR(MBAR, chn);
     404  if (uisr & MCF5206E_UISR_DB) {
     405    *MCF5206E_UCR(MBAR, chn) = MCF5206E_UCR_MISC_RESET_BRK;
     406  }
     407
     408  /* Receiving */
     409  while (1) {
     410    char buf[32];
     411    usr = *MCF5206E_USR(MBAR,chn);
     412    if ((bp < sizeof(buf) - 1) && ((usr & MCF5206E_USR_RXRDY) != 0)) {
     413      /* Receive character and handle frame/parity errors */
     414      if (((usr & (MCF5206E_USR_FE | MCF5206E_USR_PE)) != 0) &&
     415          !(uart->c_iflag & IGNPAR)) {
     416          if (uart->c_iflag & PARMRK) {
     417            buf[bp++] = 0xff;
     418            buf[bp++] = 0x00;
     419          } else {
     420            buf[bp++] = 0x00;
     421          }
     422      } else {
     423        buf[bp++] = *MCF5206E_URB(MBAR, chn);
     424      }
     425
     426      /* Reset error condition if any errors has been detected */
     427      if (usr & (MCF5206E_USR_RB | MCF5206E_USR_FE |
     428                 MCF5206E_USR_PE | MCF5206E_USR_OE)) {
     429        *MCF5206E_UCR(MBAR, chn) = MCF5206E_UCR_MISC_RESET_ERR;
     430      }
     431    } else {
     432      if (bp != 0)
     433        rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
     434      break;
     435    }
     436  }
     437
     438  /* Transmitting */
     439  while (1) {
     440    if ((*MCF5206E_USR(MBAR, chn) & MCF5206E_USR_TXRDY) == 0)
     441      break;
     442    if (uart->tx_buf != NULL) {
     443      if (uart->tx_ptr >= uart->tx_buf_len) {
     444        register int dequeue = uart->tx_buf_len;
     445
     446        *MCF5206E_UIMR(MBAR, uart->chn) = MCF5206E_UIMR_FFULL;
     447        uart->tx_buf = NULL;
     448        uart->tx_ptr = uart->tx_buf_len = 0;
     449        rtems_termios_dequeue_characters(uart->tty, dequeue);
     450      } else {
     451        *MCF5206E_UTB(MBAR, chn) = uart->tx_buf[uart->tx_ptr++];
     452      }
     453    }
    431454    else
    432         return;
    433 
    434     chn = uart->chn;
    435 
    436     uisr = *MCF5206E_UISR(MBAR, chn);
    437     if (uisr & MCF5206E_UISR_DB)
    438     {
    439         *MCF5206E_UCR(MBAR, chn) = MCF5206E_UCR_MISC_RESET_BRK;
    440     }
    441 
    442     /* Receiving */
    443     while (1)
    444     {
    445         char buf[32];
    446         usr = *MCF5206E_USR(MBAR,chn);
    447         if ((bp < sizeof(buf) - 1) && ((usr & MCF5206E_USR_RXRDY) != 0))
    448         {
    449             /* Receive character and handle frame/parity errors */
    450             if (((usr & (MCF5206E_USR_FE | MCF5206E_USR_PE)) != 0) &&
    451                 !(uart->c_iflag & IGNPAR))
    452             {
    453                 if (uart->c_iflag & PARMRK)
    454                 {
    455                     buf[bp++] = 0xff;
    456                     buf[bp++] = 0x00;
    457                 }
    458                 else
    459                 {
    460                     buf[bp++] = 0x00;
    461                 }
    462             }
    463             else
    464             {
    465                 buf[bp++] = *MCF5206E_URB(MBAR, chn);
    466             }
    467 
    468             /* Reset error condition if any errors has been detected */
    469             if (usr & (MCF5206E_USR_RB | MCF5206E_USR_FE |
    470                        MCF5206E_USR_PE | MCF5206E_USR_OE))
    471             {
    472                 *MCF5206E_UCR(MBAR, chn) = MCF5206E_UCR_MISC_RESET_ERR;
    473             }
    474         }
    475         else
    476         {
    477             if (bp != 0)
    478                 rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
    479             break;
    480         }
    481     }
    482 
    483     /* Transmitting */
    484     while (1)
    485     {
    486         if ((*MCF5206E_USR(MBAR, chn) & MCF5206E_USR_TXRDY) == 0)
    487             break;
    488         if (uart->tx_buf != NULL)
    489         {
    490             if (uart->tx_ptr >= uart->tx_buf_len)
    491             {
    492                 register int dequeue = uart->tx_buf_len;
    493                 *MCF5206E_UIMR(MBAR, uart->chn) = MCF5206E_UIMR_FFULL;
    494                 uart->tx_buf = NULL;
    495                 uart->tx_ptr = uart->tx_buf_len = 0;
    496                 rtems_termios_dequeue_characters(uart->tty, dequeue);
    497             }
    498             else
    499             {
    500                 *MCF5206E_UTB(MBAR, chn) = uart->tx_buf[uart->tx_ptr++];
    501             }
    502         }
    503         else
    504             break;
    505     }
     455      break;
     456  }
    506457}
    507458
     
    517468 *     0
    518469 */
    519 ssize_t
    520 mcfuart_interrupt_write(mcfuart *uart, const char *buf, size_t len)
    521 {
    522     if (len > 0)
    523     {
    524         uart->tx_buf = buf;
    525         uart->tx_buf_len = len;
    526         uart->tx_ptr = 0;
    527         *MCF5206E_UIMR(MBAR, uart->chn) =
    528                 MCF5206E_UIMR_FFULL | MCF5206E_UIMR_TXRDY;
    529         while (((*MCF5206E_USR(MBAR,uart->chn) & MCF5206E_USR_TXRDY) != 0) &&
    530                (uart->tx_ptr < uart->tx_buf_len))
    531         {
    532             *MCF5206E_UTB(MBAR,uart->chn) = uart->tx_buf[uart->tx_ptr++];
    533         }
    534     }
    535 
    536     return 0;
     470ssize_t mcfuart_interrupt_write(
     471  mcfuart *uart,
     472  const char *buf,
     473  size_t len
     474)
     475{
     476  if (len > 0) {
     477    uart->tx_buf = buf;
     478    uart->tx_buf_len = len;
     479    uart->tx_ptr = 0;
     480    *MCF5206E_UIMR(MBAR, uart->chn) =
     481            MCF5206E_UIMR_FFULL | MCF5206E_UIMR_TXRDY;
     482    while (((*MCF5206E_USR(MBAR,uart->chn) & MCF5206E_USR_TXRDY) != 0) &&
     483           (uart->tx_ptr < uart->tx_buf_len)) {
     484        *MCF5206E_UTB(MBAR,uart->chn) = uart->tx_buf[uart->tx_ptr++];
     485    }
     486  }
     487
     488  return 0;
    537489}
    538490
     
    546498 *     RTEMS_SUCCESSFUL
    547499 */
    548 int
    549 mcfuart_stop_remote_tx(mcfuart *uart)
    550 {
    551     *MCF5206E_UOP0(MBAR, uart->chn) = 1;
    552     return RTEMS_SUCCESSFUL;
     500int mcfuart_stop_remote_tx(mcfuart *uart)
     501{
     502  *MCF5206E_UOP0(MBAR, uart->chn) = 1;
     503  return RTEMS_SUCCESSFUL;
    553504}
    554505
     
    562513 *     RTEMS_SUCCESSFUL
    563514 */
    564 int
    565 mcfuart_start_remote_tx(mcfuart *uart)
    566 {
    567     *MCF5206E_UOP1(MBAR, uart->chn) = 1;
    568     return RTEMS_SUCCESSFUL;
    569 }
     515int mcfuart_start_remote_tx(mcfuart *uart)
     516{
     517  *MCF5206E_UOP1(MBAR, uart->chn) = 1;
     518  return RTEMS_SUCCESSFUL;
     519}
  • c/src/lib/libcpu/m68k/mcf5206/include/mcfmbus.h

    r46dad9d4 ra94fb39  
    3737    rtems_id               sema; /* MBUS semaphore */
    3838    i2c_transfer_done      done; /* Transfer done function */
    39     uint32_t       done_arg_ptr; /* Done function argument ptr */
     39    uintptr_t      done_arg_ptr; /* Done function argument ptr */
    4040} mcfmbus;
    4141
  • c/src/lib/libcpu/m68k/mcf5206/include/mcfuart.h

    r46dad9d4 ra94fb39  
    3535   void               *tty;              /* termios channel descriptor */
    3636
    37    volatile const uint8_t  *tx_buf;      /* Transmit buffer from termios */
     37   volatile const char     *tx_buf;      /* Transmit buffer from termios */
    3838   volatile uint32_t        tx_buf_len;  /* Transmit buffer length */
    3939   volatile uint32_t        tx_ptr;      /* Index of next char to transmit*/
  • c/src/lib/libcpu/m68k/mcf5206/mbus/mcfmbus.c

    r46dad9d4 ra94fb39  
    11/*
    22 *  MCF5206e MBUS module (I2C bus) driver
    3  *
     3 */
     4
     5/*
    46 *  Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
    57 *  Author: Victor V. Vengerov <vvv@oktet.ru>
     
    1618/* Events of I2C machine */
    1719typedef enum i2c_event {
    18     EVENT_NONE,      /* Spurious event */
    19     EVENT_TRANSFER,  /* Start new transfer */
    20     EVENT_NEXTMSG,   /* Start processing of next message in transfer */
    21     EVENT_ACK,       /* Sending finished with ACK */
    22     EVENT_NACK,      /* Sending finished with NACK */
    23     EVENT_TIMEOUT,   /* Timeout occured */
    24     EVENT_DATA_RECV, /* Data received */
    25     EVENT_ARB_LOST,  /* Arbitration lost */
    26     EVENT_SLAVE      /* Addressed as a slave */
     20  EVENT_NONE,      /* Spurious event */
     21  EVENT_TRANSFER,  /* Start new transfer */
     22  EVENT_NEXTMSG,   /* Start processing of next message in transfer */
     23  EVENT_ACK,       /* Sending finished with ACK */
     24  EVENT_NACK,      /* Sending finished with NACK */
     25  EVENT_TIMEOUT,   /* Timeout occured */
     26  EVENT_DATA_RECV, /* Data received */
     27  EVENT_ARB_LOST,  /* Arbitration lost */
     28  EVENT_SLAVE      /* Addressed as a slave */
    2729} i2c_event;
    2830
     
    110112mcfmbus_get_event(mcfmbus *bus)
    111113{
    112     i2c_event event;
    113     uint8_t   status, control;
    114     rtems_interrupt_level level;
    115     rtems_interrupt_disable(level);
    116     status = *MCF5206E_MBSR(bus->base);
    117     control = *MCF5206E_MBCR(bus->base);
    118     if (status & MCF5206E_MBSR_MIF) /* Interrupt occured */
    119     {
    120         if (status & MCF5206E_MBSR_MAAS)
    121         {
    122             event = EVENT_SLAVE;
    123             *MCF5206E_MBCR(bus->base) = control; /* To clear Addressed As Slave
    124                                                     condition */
    125         }
    126         else if (status & MCF5206E_MBSR_MAL) /* Arbitration lost */
    127         {
    128             *MCF5206E_MBSR(bus->base) = status & ~MCF5206E_MBSR_MAL;
    129             event = EVENT_ARB_LOST;
    130         }
    131         else if (control & MCF5206E_MBCR_MTX) /* Trasmit mode */
    132         {
    133             if (status & MCF5206E_MBSR_RXAK)
    134                 event = EVENT_NACK;
    135             else
    136                 event = EVENT_ACK;
    137         }
    138         else /* Received */
    139         {
    140             event = EVENT_DATA_RECV;
    141         }
    142 
    143         /* Clear interrupt condition */
    144         *MCF5206E_MBSR(bus->base) &= ~MCF5206E_MBSR_MIF;
     114  i2c_event event;
     115  uint8_t   status, control;
     116  rtems_interrupt_level level;
     117  rtems_interrupt_disable(level);
     118  status = *MCF5206E_MBSR(bus->base);
     119  control = *MCF5206E_MBCR(bus->base);
     120
     121  if (status & MCF5206E_MBSR_MIF) { /* Interrupt occured */
     122    if (status & MCF5206E_MBSR_MAAS) {
     123      event = EVENT_SLAVE;
     124      *MCF5206E_MBCR(bus->base) = control; /* To clear Addressed As Slave
     125                                              condition */
     126    } else if (status & MCF5206E_MBSR_MAL) { /* Arbitration lost */
     127      *MCF5206E_MBSR(bus->base) = status & ~MCF5206E_MBSR_MAL;
     128      event = EVENT_ARB_LOST;
    145129    }
    146     else
    147     {
    148         event = EVENT_NONE;
     130    else if (control & MCF5206E_MBCR_MTX) { /* Trasmit mode */
     131      if (status & MCF5206E_MBSR_RXAK)
     132        event = EVENT_NACK;
     133      else
     134        event = EVENT_ACK;
     135    } else { /* Received */
     136      event = EVENT_DATA_RECV;
    149137    }
    150     rtems_interrupt_enable(level);
    151     return event;
    152 }
    153 
    154 static void
    155 mcfmbus_machine_error(mcfmbus *bus, i2c_event event)
    156 {
    157     return;
     138
     139    /* Clear interrupt condition */
     140    *MCF5206E_MBSR(bus->base) &= ~MCF5206E_MBSR_MIF;
     141  } else {
     142    event = EVENT_NONE;
     143  }
     144  rtems_interrupt_enable(level);
     145  return event;
     146}
     147
     148static void mcfmbus_machine_error(mcfmbus *bus, i2c_event event)
     149{
    158150}
    159151
     
    168160 *     none
    169161 */
    170 static void
    171 mcfmbus_machine(mcfmbus *bus, i2c_event event)
    172 {
    173     uint8_t   b;
    174     switch (bus->state)
    175     {
    176         case STATE_IDLE:
    177             switch (event)
    178             {
    179                 case EVENT_NEXTMSG:  /* Start new message processing */
    180                     bus->cmsg++;
    181                     /* FALLTHRU */
    182 
    183                 case EVENT_TRANSFER: /* Initiate new transfer */
    184                     if (bus->cmsg - bus->msg >= bus->nmsg)
    185                     {
    186                         mcfmbus_stop(bus);
    187                         next_state(bus, STATE_IDLE);
    188                         bus->msg = bus->cmsg = NULL;
    189                         bus->nmsg = bus->byte = 0;
    190                         bus->done(bus->done_arg_ptr);
    191                         break;
    192                     }
    193 
    194                     /* Initiate START or REPEATED START condition on the bus */
    195                     if (event == EVENT_TRANSFER)
    196                     {
    197                         mcfmbus_start(bus);
    198                     }
    199                     else /* (event == EVENT_NEXTMSG) */
    200                     {
    201                         mcfmbus_rstart(bus);
    202                     }
    203 
    204                     bus->byte = 0;
    205                     mcfmbus_tx_mode(bus);
    206 
    207                     /* Initiate slave address sending */
    208                     if (bus->cmsg->flags & I2C_MSG_ADDR_10)
    209                     {
    210                         i2c_address a = bus->cmsg->addr;
    211                         b = 0xf0 | (((a >> 8) & 0x03) << 1);
    212                         if (bus->cmsg->flags & I2C_MSG_WR)
    213                         {
    214                             mcfmbus_send(bus, b);
    215                             next_state(bus, STATE_ADDR_1_W);
    216                         }
    217                         else
    218                         {
    219                             mcfmbus_send(bus, b | 1);
    220                             next_state(bus, STATE_ADDR_1_R);
    221                         }
    222                     }
    223                     else
    224                     {
    225                         b = (bus->cmsg->addr & ~0x01);
    226 
    227                         if (bus->cmsg->flags & I2C_MSG_WR)
    228                         {
    229                             next_state(bus, STATE_SENDING);
    230                         }
    231                         else
    232                         {
    233                             next_state(bus, STATE_ADDR_7);
    234                             b |= 1;
    235                         }
    236 
    237                         mcfmbus_send(bus, b);
    238                     }
    239                     break;
    240 
    241                 default:
    242                     mcfmbus_machine_error(bus, event);
    243                     break;
     162static void mcfmbus_machine(mcfmbus *bus, i2c_event event)
     163{
     164  uint8_t   b;
     165
     166  switch (bus->state) {
     167    case STATE_IDLE:
     168      switch (event) {
     169        case EVENT_NEXTMSG:  /* Start new message processing */
     170          bus->cmsg++;
     171          /* FALLTHRU */
     172
     173        case EVENT_TRANSFER: /* Initiate new transfer */
     174          if (bus->cmsg - bus->msg >= bus->nmsg) {
     175            mcfmbus_stop(bus);
     176            next_state(bus, STATE_IDLE);
     177            bus->msg = bus->cmsg = NULL;
     178            bus->nmsg = bus->byte = 0;
     179            bus->done((void *)bus->done_arg_ptr);
     180            break;
     181          }
     182
     183          /* Initiate START or REPEATED START condition on the bus */
     184          if (event == EVENT_TRANSFER) {
     185            mcfmbus_start(bus);
     186          } else { /* (event == EVENT_NEXTMSG) */
     187            mcfmbus_rstart(bus);
     188          }
     189
     190          bus->byte = 0;
     191          mcfmbus_tx_mode(bus);
     192
     193          /* Initiate slave address sending */
     194          if (bus->cmsg->flags & I2C_MSG_ADDR_10) {
     195            i2c_address a = bus->cmsg->addr;
     196            b = 0xf0 | (((a >> 8) & 0x03) << 1);
     197            if (bus->cmsg->flags & I2C_MSG_WR) {
     198              mcfmbus_send(bus, b);
     199              next_state(bus, STATE_ADDR_1_W);
     200            } else {
     201              mcfmbus_send(bus, b | 1);
     202              next_state(bus, STATE_ADDR_1_R);
    244203            }
     204          } else {
     205            b = (bus->cmsg->addr & ~0x01);
     206
     207            if (bus->cmsg->flags & I2C_MSG_WR) {
     208              next_state(bus, STATE_SENDING);
     209            } else {
     210              next_state(bus, STATE_ADDR_7);
     211              b |= 1;
     212            }
     213
     214            mcfmbus_send(bus, b);
     215          }
     216          break;
     217
     218        default:
     219          mcfmbus_machine_error(bus, event);
    245220            break;
    246 
    247         case STATE_ADDR_7:
    248             switch (event)
    249             {
    250                 case EVENT_ACK:
    251                     mcfmbus_rx_mode(bus);
    252                     if (bus->cmsg->len <= 1)
    253                         mcfmbus_send_nack(bus);
    254                     else
    255                         mcfmbus_send_ack(bus);
    256                     next_state(bus, STATE_RECEIVING);
    257                     break;
    258 
    259                 case EVENT_NACK:
    260                     mcfmbus_error(bus, I2C_NO_DEVICE);
    261                     next_state(bus, STATE_IDLE);
    262                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    263                     break;
    264 
    265                 case EVENT_ARB_LOST:
    266                     mcfmbus_error(bus, I2C_ARBITRATION_LOST);
    267                     next_state(bus, STATE_IDLE);
    268                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    269                     break;
    270 
    271                 default:
    272                     mcfmbus_machine_error(bus, event);
    273                     break;
     221      }
     222      break;
     223
     224    case STATE_ADDR_7:
     225      switch (event) {
     226        case EVENT_ACK:
     227          mcfmbus_rx_mode(bus);
     228          if (bus->cmsg->len <= 1)
     229            mcfmbus_send_nack(bus);
     230          else
     231            mcfmbus_send_ack(bus);
     232          next_state(bus, STATE_RECEIVING);
     233          break;
     234
     235        case EVENT_NACK:
     236          mcfmbus_error(bus, I2C_NO_DEVICE);
     237          next_state(bus, STATE_IDLE);
     238          mcfmbus_machine(bus, EVENT_NEXTMSG);
     239          break;
     240
     241        case EVENT_ARB_LOST:
     242          mcfmbus_error(bus, I2C_ARBITRATION_LOST);
     243          next_state(bus, STATE_IDLE);
     244          mcfmbus_machine(bus, EVENT_NEXTMSG);
     245          break;
     246
     247        default:
     248          mcfmbus_machine_error(bus, event);
     249          break;
     250      }
     251      break;
     252
     253    case STATE_ADDR_1_R:
     254    case STATE_ADDR_1_W:
     255      switch (event) {
     256        case EVENT_ACK: {
     257          uint8_t   b = (bus->cmsg->addr & 0xff);
     258          mcfmbus_send(bus, b);
     259          if (bus->state == STATE_ADDR_1_W) {
     260              next_state(bus, STATE_SENDING);
     261          } else {
     262              i2c_address a;
     263              mcfmbus_rstart(bus);
     264              mcfmbus_tx_mode(bus);
     265              a = bus->cmsg->addr;
     266              b = 0xf0 | (((a >> 8) & 0x03) << 1) | 1;
     267              mcfmbus_send(bus, b);
     268              next_state(bus, STATE_ADDR_7);
     269          }
     270          break;
     271        }
     272
     273        case EVENT_NACK:
     274          mcfmbus_error(bus, I2C_NO_DEVICE);
     275          next_state(bus, STATE_IDLE);
     276          mcfmbus_machine(bus, EVENT_NEXTMSG);
     277          break;
     278
     279        case EVENT_ARB_LOST:
     280          mcfmbus_error(bus, I2C_ARBITRATION_LOST);
     281          next_state(bus, STATE_IDLE);
     282          mcfmbus_machine(bus, EVENT_NEXTMSG);
     283          break;
     284
     285        default:
     286          mcfmbus_machine_error(bus, event);
     287          break;
     288    }
     289      break;
     290
     291    case STATE_SENDING:
     292      switch (event) {
     293        case EVENT_ACK:
     294          if (bus->byte == bus->cmsg->len) {
     295            next_state(bus, STATE_IDLE);
     296            mcfmbus_machine(bus, EVENT_NEXTMSG);
     297          } else {
     298            mcfmbus_send(bus, bus->cmsg->buf[bus->byte++]);
     299            next_state(bus, STATE_SENDING);
     300          }
     301          break;
     302
     303        case EVENT_NACK:
     304          if (bus->byte == 0) {
     305            mcfmbus_error(bus, I2C_NO_DEVICE);
     306          } else {
     307            mcfmbus_error(bus, I2C_NO_ACKNOWLEDGE);
     308          }
     309          next_state(bus, STATE_IDLE);
     310          mcfmbus_machine(bus, EVENT_NEXTMSG);
     311          break;
     312
     313        case EVENT_ARB_LOST:
     314          mcfmbus_error(bus, I2C_ARBITRATION_LOST);
     315          next_state(bus, STATE_IDLE);
     316          mcfmbus_machine(bus, EVENT_NEXTMSG);
     317          break;
     318
     319        default:
     320          mcfmbus_machine_error(bus, event);
     321          break;
     322      }
     323      break;
     324
     325    case STATE_RECEIVING:
     326      switch (event) {
     327        case EVENT_DATA_RECV:
     328          if (bus->cmsg->len - bus->byte <= 2) {
     329            mcfmbus_send_nack(bus);
     330            if (bus->cmsg->len - bus->byte <= 1) {
     331                if (bus->cmsg - bus->msg + 1 == bus->nmsg)
     332                  mcfmbus_stop(bus);
     333                else
     334                  mcfmbus_rstart(bus);
    274335            }
    275             break;
    276 
    277         case STATE_ADDR_1_R:
    278         case STATE_ADDR_1_W:
    279             switch (event)
    280             {
    281                 case EVENT_ACK:
    282                 {
    283                     uint8_t   b = (bus->cmsg->addr & 0xff);
    284                     mcfmbus_send(bus, b);
    285                     if (bus->state == STATE_ADDR_1_W)
    286                     {
    287                         next_state(bus, STATE_SENDING);
    288                     }
    289                     else
    290                     {
    291                         i2c_address a;
    292                         mcfmbus_rstart(bus);
    293                         mcfmbus_tx_mode(bus);
    294                         a = bus->cmsg->addr;
    295                         b = 0xf0 | (((a >> 8) & 0x03) << 1) | 1;
    296                         mcfmbus_send(bus, b);
    297                         next_state(bus, STATE_ADDR_7);
    298                     }
    299                     break;
    300                 }
    301 
    302                 case EVENT_NACK:
    303                     mcfmbus_error(bus, I2C_NO_DEVICE);
    304                     next_state(bus, STATE_IDLE);
    305                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    306                     break;
    307 
    308                 case EVENT_ARB_LOST:
    309                     mcfmbus_error(bus, I2C_ARBITRATION_LOST);
    310                     next_state(bus, STATE_IDLE);
    311                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    312                     break;
    313 
    314                 default:
    315                     mcfmbus_machine_error(bus, event);
    316                     break;
    317             }
    318             break;
    319 
    320         case STATE_SENDING:
    321             switch (event)
    322             {
    323                 case EVENT_ACK:
    324                     if (bus->byte == bus->cmsg->len)
    325                     {
    326                         next_state(bus, STATE_IDLE);
    327                         mcfmbus_machine(bus, EVENT_NEXTMSG);
    328                     }
    329                     else
    330                     {
    331                         mcfmbus_send(bus, bus->cmsg->buf[bus->byte++]);
    332                         next_state(bus, STATE_SENDING);
    333                     }
    334                     break;
    335 
    336                 case EVENT_NACK:
    337                     if (bus->byte == 0)
    338                     {
    339                         mcfmbus_error(bus, I2C_NO_DEVICE);
    340                     }
    341                     else
    342                     {
    343                         mcfmbus_error(bus, I2C_NO_ACKNOWLEDGE);
    344                     }
    345                     next_state(bus, STATE_IDLE);
    346                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    347                     break;
    348 
    349                 case EVENT_ARB_LOST:
    350                     mcfmbus_error(bus, I2C_ARBITRATION_LOST);
    351                     next_state(bus, STATE_IDLE);
    352                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    353                     break;
    354 
    355                 default:
    356                     mcfmbus_machine_error(bus, event);
    357                     break;
    358 
    359             }
    360             break;
    361 
    362         case STATE_RECEIVING:
    363             switch (event)
    364             {
    365                 case EVENT_DATA_RECV:
    366                     if (bus->cmsg->len - bus->byte <= 2)
    367                     {
    368                         mcfmbus_send_nack(bus);
    369                         if (bus->cmsg->len - bus->byte <= 1)
    370                         {
    371                             if (bus->cmsg - bus->msg + 1 == bus->nmsg)
    372                                 mcfmbus_stop(bus);
    373                             else
    374                                 mcfmbus_rstart(bus);
    375                         }
    376                     }
    377                     else
    378                     {
    379                         mcfmbus_send_ack(bus);
    380                     }
    381                     bus->cmsg->buf[bus->byte++] = *MCF5206E_MBDR(bus->base);
    382                     if (bus->cmsg->len == bus->byte)
    383                     {
    384                         next_state(bus,STATE_IDLE);
    385                         mcfmbus_machine(bus, EVENT_NEXTMSG);
    386                     }
    387                     else
    388                     {
    389                         next_state(bus,STATE_RECEIVING);
    390                     }
    391                     break;
    392 
    393                 case EVENT_ARB_LOST:
    394                     mcfmbus_error(bus, I2C_ARBITRATION_LOST);
    395                     next_state(bus, STATE_IDLE);
    396                     mcfmbus_machine(bus, EVENT_NEXTMSG);
    397                     break;
    398 
    399                 default:
    400                     mcfmbus_machine_error(bus, event);
    401                     break;
    402             }
    403             break;
    404     }
     336          } else {
     337            mcfmbus_send_ack(bus);
     338          }
     339          bus->cmsg->buf[bus->byte++] = *MCF5206E_MBDR(bus->base);
     340          if (bus->cmsg->len == bus->byte) {
     341            next_state(bus,STATE_IDLE);
     342            mcfmbus_machine(bus, EVENT_NEXTMSG);
     343          } else {
     344            next_state(bus,STATE_RECEIVING);
     345          }
     346          break;
     347
     348        case EVENT_ARB_LOST:
     349          mcfmbus_error(bus, I2C_ARBITRATION_LOST);
     350          next_state(bus, STATE_IDLE);
     351          mcfmbus_machine(bus, EVENT_NEXTMSG);
     352          break;
     353
     354        default:
     355          mcfmbus_machine_error(bus, event);
     356          break;
     357      }
     358      break;
     359  }
    405360}
    406361
    407362/* mcfmbus_interrupt_handler --
    408  *     MBUS module interrupt handler routine
    409  *
    410  * PARAMETERS:
    411  *     vector - interrupt vector number (not used)
    412  *
    413  * RETURNS:
    414  *     none
    415  */
    416 rtems_isr
    417 mcfmbus_interrupt_handler(rtems_vector_number vector)
    418 {
    419     i2c_event event;
    420     event = mcfmbus_get_event(mbus);
    421     mcfmbus_machine(mbus, event);
     363*     MBUS module interrupt handler routine
     364*
     365* PARAMETERS:
     366*     vector - interrupt vector number (not used)
     367*
     368* RETURNS:
     369*     none
     370*/
     371static rtems_isr mcfmbus_interrupt_handler(rtems_vector_number vector)
     372{
     373  i2c_event event;
     374  event = mcfmbus_get_event(mbus);
     375  mcfmbus_machine(mbus, event);
    422376}
    423377
    424378/* mcfmbus_poll --
    425  *     MBUS module poll routine; used to poll events when I2C driver
    426  *     operates in poll-driven mode.
    427  *
    428  * PARAMETERS:
    429  *     none
    430  *
    431  * RETURNS:
    432  *     none
    433  */
     379*     MBUS module poll routine; used to poll events when I2C driver
     380*     operates in poll-driven mode.
     381*
     382* PARAMETERS:
     383*     none
     384*
     385* RETURNS:
     386*     none
     387*/
    434388void
    435389mcfmbus_poll(mcfmbus *bus)
    436390{
    437     i2c_event event;
    438     event = mcfmbus_get_event(bus);
    439     if (event != EVENT_NONE)
    440         mcfmbus_machine(bus, event);
     391  i2c_event event;
     392  event = mcfmbus_get_event(bus);
     393  if (event != EVENT_NONE)
     394      mcfmbus_machine(bus, event);
    441395}
    442396
    443397/* mcfmbus_select_clock_divider --
    444  *     Select divider for system clock which is used for I2C bus clock
    445  *     generation. Not each divider can be selected for I2C bus; this
    446  *     function select nearest larger or equal divider.
    447  *
    448  * PARAMETERS:
    449  *     i2c_bus - pointer to the bus descriptor structure
    450  *     divider - system frequency divider for I2C serial clock.
    451  * RETURNS:
    452  *     RTEMS_SUCCESSFUL, if operation performed successfully, or
    453  *     RTEMS error code when failed.
    454  */
     398*     Select divider for system clock which is used for I2C bus clock
     399*     generation. Not each divider can be selected for I2C bus; this
     400*     function select nearest larger or equal divider.
     401*
     402* PARAMETERS:
     403*     i2c_bus - pointer to the bus descriptor structure
     404*     divider - system frequency divider for I2C serial clock.
     405* RETURNS:
     406*     RTEMS_SUCCESSFUL, if operation performed successfully, or
     407*     RTEMS error code when failed.
     408*/
    455409rtems_status_code
    456410mcfmbus_select_clock_divider(mcfmbus *i2c_bus, int divider)
    457411{
    458     int i;
    459     int mbc;
    460     struct {
    461         int divider;
    462         int mbc;
    463     } dividers[] ={
    464         { 20,   0x20 }, { 22,   0x21 }, { 24,   0x22 }, { 26,   0x23 },
    465         { 28,   0x00 }, { 30,   0x01 }, { 32,   0x25 }, { 34,   0x02 },
    466         { 36,   0x26 }, { 40,   0x03 }, { 44,   0x04 }, { 48,   0x05 },
    467         { 56,   0x06 }, { 64,   0x2a }, { 68,   0x07 }, { 72,   0x2B },
    468         { 80,   0x08 }, { 88,   0x09 }, { 96,   0x2D }, { 104,  0x0A },
    469         { 112,  0x2E }, { 128,  0x0B }, { 144,  0x0C }, { 160,  0x0D },
    470         { 192,  0x0E }, { 224,  0x32 }, { 240,  0x0F }, { 256,  0x33 },
    471         { 288,  0x10 }, { 320,  0x11 }, { 384,  0x12 }, { 448,  0x36 },
    472         { 480,  0x13 }, { 512,  0x37 }, { 576,  0x14 }, { 640,  0x15 },
    473         { 768,  0x16 }, { 896,  0x3A }, { 960,  0x17 }, { 1024, 0x3B },
    474         { 1152, 0x18 }, { 1280, 0x19 }, { 1536, 0x1A }, { 1792, 0x3E },
    475         { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
    476         { 3072, 0x1E }, { 3840, 0x1F }
    477     };
    478 
    479     if (i2c_bus == NULL)
    480         return RTEMS_INVALID_ADDRESS;
    481 
    482     for (i = 0, mbc = -1; i < sizeof(dividers)/sizeof(dividers[0]); i++)
    483     {
    484         mbc = dividers[i].mbc;
    485         if (dividers[i].divider >= divider)
    486         {
    487             break;
    488         }
     412  int i;
     413  int mbc;
     414  struct {
     415      int divider;
     416      int mbc;
     417  } dividers[] ={
     418      { 20,   0x20 }, { 22,   0x21 }, { 24,   0x22 }, { 26,   0x23 },
     419      { 28,   0x00 }, { 30,   0x01 }, { 32,   0x25 }, { 34,   0x02 },
     420      { 36,   0x26 }, { 40,   0x03 }, { 44,   0x04 }, { 48,   0x05 },
     421      { 56,   0x06 }, { 64,   0x2a }, { 68,   0x07 }, { 72,   0x2B },
     422      { 80,   0x08 }, { 88,   0x09 }, { 96,   0x2D }, { 104,  0x0A },
     423      { 112,  0x2E }, { 128,  0x0B }, { 144,  0x0C }, { 160,  0x0D },
     424      { 192,  0x0E }, { 224,  0x32 }, { 240,  0x0F }, { 256,  0x33 },
     425      { 288,  0x10 }, { 320,  0x11 }, { 384,  0x12 }, { 448,  0x36 },
     426      { 480,  0x13 }, { 512,  0x37 }, { 576,  0x14 }, { 640,  0x15 },
     427      { 768,  0x16 }, { 896,  0x3A }, { 960,  0x17 }, { 1024, 0x3B },
     428      { 1152, 0x18 }, { 1280, 0x19 }, { 1536, 0x1A }, { 1792, 0x3E },
     429      { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
     430      { 3072, 0x1E }, { 3840, 0x1F }
     431  };
     432
     433  if (i2c_bus == NULL)
     434    return RTEMS_INVALID_ADDRESS;
     435
     436  for (i = 0, mbc = -1; i < sizeof(dividers)/sizeof(dividers[0]); i++) {
     437    mbc = dividers[i].mbc;
     438    if (dividers[i].divider >= divider) {
     439      break;
    489440    }
    490     *MCF5206E_MFDR(i2c_bus->base) = mbc;
    491     return RTEMS_SUCCESSFUL;
     441  }
     442  *MCF5206E_MFDR(i2c_bus->base) = mbc;
     443  return RTEMS_SUCCESSFUL;
    492444}
    493445
    494446/* mcfmbus_initialize --
    495  *     Initialize ColdFire MBUS I2C bus controller.
    496  *
    497  * PARAMETERS:
    498  *     i2c_bus - pointer to the bus descriptor structure
    499  *     base    - ColdFire internal peripherial base address
    500  *
    501  * RETURNS:
    502  *     RTEMS_SUCCESSFUL, or RTEMS error code when initialization failed.
    503  */
    504 rtems_status_code
    505 mcfmbus_initialize(mcfmbus *i2c_bus, uint32_t   base)
    506 {
    507     rtems_interrupt_level level;
    508     rtems_status_code sc;
    509 
    510     if (mbus != NULL) /* Check if already initialized */
    511         return RTEMS_RESOURCE_IN_USE;
    512 
    513     if (i2c_bus == NULL)
    514         return RTEMS_INVALID_ADDRESS;
    515 
    516 
    517     i2c_bus->base = base;
    518     i2c_bus->state = STATE_IDLE;
    519     i2c_bus->msg = NULL;
    520     i2c_bus->cmsg = NULL;
    521     i2c_bus->nmsg = 0;
    522     i2c_bus->byte = 0;
    523 
    524     sc = rtems_interrupt_catch(
    525         mcfmbus_interrupt_handler,
    526         24 + ((*MCF5206E_ICR(base, MCF5206E_INTR_MBUS) & MCF5206E_ICR_IL) >>
    527                                    MCF5206E_ICR_IL_S),
    528         &i2c_bus->oldisr
    529     );
    530     if (sc != RTEMS_SUCCESSFUL)
    531         return sc;
    532 
    533     mbus = i2c_bus;
    534     rtems_interrupt_disable(level);
    535     *MCF5206E_IMR(base) &= ~MCF5206E_INTR_BIT(MCF5206E_INTR_MBUS);
    536     *MCF5206E_MBCR(base) = 0;
    537     *MCF5206E_MBSR(base) = 0;
    538     *MCF5206E_MBDR(base) = 0x1F; /* Maximum possible divider is 3840 */
    539     *MCF5206E_MBCR(base) = MCF5206E_MBCR_MEN | MCF5206E_MBCR_MIEN;
    540     rtems_interrupt_enable(level);
    541 
    542     return RTEMS_SUCCESSFUL;
     447*     Initialize ColdFire MBUS I2C bus controller.
     448*
     449* PARAMETERS:
     450*     i2c_bus - pointer to the bus descriptor structure
     451*     base    - ColdFire internal peripherial base address
     452*
     453* RETURNS:
     454*     RTEMS_SUCCESSFUL, or RTEMS error code when initialization failed.
     455*/
     456rtems_status_code mcfmbus_initialize(mcfmbus *i2c_bus, uint32_t   base)
     457{
     458  rtems_interrupt_level level;
     459  rtems_status_code sc;
     460
     461  if (mbus != NULL) /* Check if already initialized */
     462    return RTEMS_RESOURCE_IN_USE;
     463
     464  if (i2c_bus == NULL)
     465    return RTEMS_INVALID_ADDRESS;
     466
     467
     468  i2c_bus->base = base;
     469  i2c_bus->state = STATE_IDLE;
     470  i2c_bus->msg = NULL;
     471  i2c_bus->cmsg = NULL;
     472  i2c_bus->nmsg = 0;
     473  i2c_bus->byte = 0;
     474
     475  sc = rtems_interrupt_catch(
     476      mcfmbus_interrupt_handler,
     477      24 + ((*MCF5206E_ICR(base, MCF5206E_INTR_MBUS) & MCF5206E_ICR_IL) >>
     478                                 MCF5206E_ICR_IL_S),
     479      &i2c_bus->oldisr
     480  );
     481  if (sc != RTEMS_SUCCESSFUL)
     482    return sc;
     483
     484  mbus = i2c_bus;
     485  rtems_interrupt_disable(level);
     486  *MCF5206E_IMR(base) &= ~MCF5206E_INTR_BIT(MCF5206E_INTR_MBUS);
     487  *MCF5206E_MBCR(base) = 0;
     488  *MCF5206E_MBSR(base) = 0;
     489  *MCF5206E_MBDR(base) = 0x1F; /* Maximum possible divider is 3840 */
     490  *MCF5206E_MBCR(base) = MCF5206E_MBCR_MEN | MCF5206E_MBCR_MIEN;
     491  rtems_interrupt_enable(level);
     492
     493  return RTEMS_SUCCESSFUL;
    543494}
    544495
    545496/* mcfmbus_i2c_transfer --
    546  *     Initiate multiple-messages transfer over I2C bus via ColdFire MBUS
    547  *     controller.
    548  *
    549  * PARAMETERS:
    550  *     bus - pointer to MBUS controller descriptor
    551  *     nmsg - number of messages
    552  *     msg - pointer to messages array
    553  *     done - function which is called when transfer is finished
    554  *     done_arg_ptr - arbitrary argument ptr passed to done funciton
    555  *
    556  * RETURNS:
    557  *     RTEMS_SUCCESSFUL if transfer initiated successfully, or error
    558  *     code when failed.
    559  */
    560 rtems_status_code
    561 mcfmbus_i2c_transfer(mcfmbus *bus, int nmsg, i2c_message *msg,
    562                      i2c_transfer_done done, void *done_arg_ptr)
    563 {
    564     if (bus != mbus)
    565         return RTEMS_NOT_CONFIGURED;
    566 
    567     bus->done = done;
    568     bus->done_arg_ptr = done_arg_ptr;
    569     bus->cmsg = bus->msg = msg;
    570     bus->nmsg = nmsg;
    571     bus->byte = 0;
    572     bus->state = STATE_IDLE;
    573     mcfmbus_machine(bus, EVENT_TRANSFER);
    574     return RTEMS_SUCCESSFUL;
     497*     Initiate multiple-messages transfer over I2C bus via ColdFire MBUS
     498*     controller.
     499*
     500* PARAMETERS:
     501*     bus - pointer to MBUS controller descriptor
     502*     nmsg - number of messages
     503*     msg - pointer to messages array
     504*     done - function which is called when transfer is finished
     505*     done_arg_ptr - arbitrary argument ptr passed to done funciton
     506*
     507* RETURNS:
     508*     RTEMS_SUCCESSFUL if transfer initiated successfully, or error
     509*     code when failed.
     510*/
     511rtems_status_code mcfmbus_i2c_transfer(
     512  mcfmbus *bus,
     513  int nmsg,
     514  i2c_message *msg,
     515  i2c_transfer_done done,
     516  void *done_arg_ptr
     517)
     518{
     519  if (bus != mbus)
     520    return RTEMS_NOT_CONFIGURED;
     521
     522  bus->done = done;
     523  bus->done_arg_ptr = (uintptr_t) done_arg_ptr;
     524  bus->cmsg = bus->msg = msg;
     525  bus->nmsg = nmsg;
     526  bus->byte = 0;
     527  bus->state = STATE_IDLE;
     528  mcfmbus_machine(bus, EVENT_TRANSFER);
     529  return RTEMS_SUCCESSFUL;
    575530}
    576531
    577532
    578533/* mcfmbus_i2c_done --
    579  *     Close ColdFire MBUS I2C bus controller and release all resources.
    580  *
    581  * PARAMETERS:
    582  *     bus - pointer to MBUS controller descriptor
    583  *
    584  * RETURNS:
    585  *     RTEMS_SUCCESSFUL, if transfer initiated successfully, or error
    586  *     code when failed.
    587  */
    588 rtems_status_code
    589 mcfmbus_i2c_done(mcfmbus *i2c_bus)
    590 {
    591     rtems_status_code sc;
    592     uint32_t   base;
    593     if (mbus == NULL)
    594         return RTEMS_NOT_CONFIGURED;
    595 
    596     if (mbus != i2c_bus)
    597         return RTEMS_INVALID_ADDRESS;
    598 
    599     base = i2c_bus->base;
    600 
    601     *MCF5206E_IMR(base) |= MCF5206E_INTR_BIT(MCF5206E_INTR_MBUS);
    602     *MCF5206E_MBCR(base) = 0;
    603 
    604     sc = rtems_interrupt_catch(
    605         i2c_bus->oldisr,
    606         24 + ((*MCF5206E_ICR(base, MCF5206E_INTR_MBUS) & MCF5206E_ICR_IL) >>
    607                                    MCF5206E_ICR_IL_S),
    608         NULL
    609     );
    610     return sc;
    611 }
     534*     Close ColdFire MBUS I2C bus controller and release all resources.
     535*
     536* PARAMETERS:
     537*     bus - pointer to MBUS controller descriptor
     538*
     539* RETURNS:
     540*     RTEMS_SUCCESSFUL, if transfer initiated successfully, or error
     541*     code when failed.
     542*/
     543rtems_status_code mcfmbus_i2c_done(mcfmbus *i2c_bus)
     544{
     545  rtems_status_code sc;
     546  uint32_t   base;
     547  if (mbus == NULL)
     548    return RTEMS_NOT_CONFIGURED;
     549
     550  if (mbus != i2c_bus)
     551    return RTEMS_INVALID_ADDRESS;
     552
     553  base = i2c_bus->base;
     554
     555  *MCF5206E_IMR(base) |= MCF5206E_INTR_BIT(MCF5206E_INTR_MBUS);
     556  *MCF5206E_MBCR(base) = 0;
     557
     558  sc = rtems_interrupt_catch(
     559      i2c_bus->oldisr,
     560      24 + ((*MCF5206E_ICR(base, MCF5206E_INTR_MBUS) & MCF5206E_ICR_IL) >>
     561                                 MCF5206E_ICR_IL_S),
     562      NULL
     563  );
     564  return sc;
     565}
Note: See TracChangeset for help on using the changeset viewer.