tool/mbed/mbed-sdk/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/TARGET_KL43Z/serial_api.c

   1 /* mbed Microcontroller Library
   2  * Copyright (c) 2006-2013 ARM Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include "mbed_assert.h"
  17 #include "serial_api.h"
  18
  19 // math.h required for floating point operations for baud rate calculation
  20 #include <math.h>
  21
  22 #include <string.h>
  23
  24 #include "cmsis.h"
  25 #include "pinmap.h"
  26 #include "clk_freqs.h"
  27 #include "PeripheralPins.h"
  28
  29 #define UART_NUM        2
  30
  31 /******************************************************************************
  32  * INITIALIZATION
  33  ******************************************************************************/
  34
  35 static uint32_t serial_irq_ids[UART_NUM] = {0};
  36 static uart_irq_handler irq_handler;
  37
  38 int stdio_uart_inited = 0;
  39 serial_t stdio_uart;
  40
  41 static inline uint32_t serial_get_src_clock(serial_t *obj) {
  42   uint32_t mux, srcclk;
  43
  44   switch ((int)obj->uart) {
  45       case UART_0:
  46         mux = (SIM->SOPT2 & SIM_SOPT2_LPUART0SRC_MASK) >> SIM_SOPT2_LPUART0SRC_SHIFT;
  47         break;
  48       case UART_1:
  49         mux = (SIM->SOPT2 & SIM_SOPT2_LPUART1SRC_MASK) >> SIM_SOPT2_LPUART1SRC_SHIFT;
  50         break;
  51       case UART_2: /* TODO: add UART2 support */ break;
  52   }
  53
  54   switch (mux) {
  55     case 1: srcclk = fastirc_frequency(); break;
  56     case 2: srcclk = extosc_frequency();  break;
  57     case 3: srcclk = mcgirc_frequency();  break;
  58     default: srcclk = 0; break;
  59   }
  60
  61   return srcclk;
  62 }
  63
  64 void serial_init(serial_t *obj, PinName tx, PinName rx) {
  65     // determine the UART to use
  66     UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX);
  67     UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX);
  68     UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx);
  69     MBED_ASSERT((int)uart != NC);
  70
  71     obj->uart = (LPUART_Type *)uart;
  72
  73     // enable clk
  74     switch (uart) {
  75         case UART_0:
  76           SIM->SOPT2 |= SIM_SOPT2_LPUART0SRC(1);
  77           SIM->SCGC5 |= SIM_SCGC5_LPUART0_MASK;
  78           break;
  79         case UART_1:
  80           SIM->SOPT2 |= SIM_SOPT2_LPUART1SRC(1);
  81           SIM->SCGC5 |= SIM_SCGC5_LPUART1_MASK;
  82           break;
  83         case UART_2: /* TODO: add UART2 support */ break;
  84     }
  85
  86     // reset UART registers
  87     obj->uart->BAUD  = 0x0F000004;
  88     obj->uart->STAT  = 0xC01FC000;
  89     obj->uart->CTRL  = 0x00000000;
  90     obj->uart->MATCH = 0x00000000;
  91
  92     switch (uart) {
  93         case UART_0: obj->index = 0; break;
  94         case UART_1: obj->index = 1; break;
  95         case UART_2: /* TODO: add UART2 support */ break;
  96     }
  97
  98     // set default baud rate and format
  99     serial_baud  (obj, 9600);
 100     serial_format(obj, 8, ParityNone, 1);
 101
 102     // pinout the chosen uart
 103     pinmap_pinout(tx, PinMap_UART_TX);
 104     pinmap_pinout(rx, PinMap_UART_RX);
 105
 106     // set rx/tx pins in PullUp mode
 107     if (tx != NC) pin_mode(tx, PullUp);
 108     if (rx != NC) pin_mode(rx, PullUp);
 109
 110     obj->uart->CTRL |= (LPUART_CTRL_RE_MASK | LPUART_CTRL_TE_MASK);
 111
 112     if (uart == STDIO_UART) {
 113         stdio_uart_inited = 1;
 114         memcpy(&stdio_uart, obj, sizeof(serial_t));
 115     }
 116 }
 117
 118 void serial_free(serial_t *obj) {
 119     serial_irq_ids[obj->index] = 0;
 120 }
 121
 122 // serial_baud
 123 //
 124 // set the baud rate, taking in to account the current SystemFrequency
 125 void serial_baud(serial_t *obj, int baudrate) {
 126     int calcBaudrate;
 127     uint32_t i, sbr, sbrTemp, osr, temp, baud, baudDiff;
 128
 129     /* get value of serial source clock */
 130     uint32_t PCLK = serial_get_src_clock(obj);
 131
 132     /* loop to find the best osr value possible, one that generates minimum baudDiff
 133      * iterate through the rest of the supported values of osr */
 134     temp = 0xFFFFFFFF;
 135     for (i = 5; i <= 33; i++) {
 136         /* calculate the temporary sbr value   */
 137         sbrTemp = PCLK / (baudrate * i);
 138
 139         /* calculate the baud rate based on the temporary osr and sbr values */
 140         calcBaudrate = PCLK / (i * sbrTemp);
 141
 142         if (calcBaudrate > baudrate) {
 143             baudDiff = calcBaudrate - baudrate;
 144         } else {
 145             baudDiff = baudrate - calcBaudrate;
 146         }
 147
 148         if (baudDiff < temp) {
 149             osr = i - 1;    /* update and store the best osr value calculated */
 150             sbr = sbrTemp;  /* update store the best sbr value calculated */
 151
 152             if(baudDiff == 0) {
 153               break;        /* end for loop if founded the best osr and sbr value */
 154             } else {
 155               temp = baudDiff;
 156             }
 157         }
 158     }
 159
 160
 161     /* save C2 state */
 162     temp = obj->uart->CTRL & (LPUART_CTRL_RE_MASK | LPUART_CTRL_TE_MASK);
 163
 164     /* disable UART before changing registers */
 165     obj->uart->CTRL &= ~(LPUART_CTRL_RE_MASK | LPUART_CTRL_TE_MASK);
 166
 167     /* read BAUD register with clearing old baudrate settings into baud variable */
 168     baud = obj->uart->BAUD & ~(LPUART_BAUD_SBR_MASK | LPUART_BAUD_OSR_MASK | LPUART_BAUD_BOTHEDGE_MASK);
 169
 170     /* write the new osr and sbr values */
 171     baud |= (LPUART_BAUD_SBR(sbr) | LPUART_BAUD_OSR(osr));
 172
 173     /* Check if osr is between 4x and 7x oversampling.
 174      * If so, then "BOTHEDGE" sampling must be turned on */
 175     if ((osr > 3) && (osr < 8)) {
 176       baud |= LPUART_BAUD_BOTHEDGE_MASK;
 177     }
 178
 179     /* write new values into BAUD register */
 180     obj->uart->BAUD = baud;
 181
 182     /* restore C2 state */
 183     obj->uart->CTRL |= temp;
 184 }
 185
 186 void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits) {
 187     MBED_ASSERT((stop_bits == 1) || (stop_bits == 2));
 188     MBED_ASSERT((parity == ParityNone) || (parity == ParityOdd) || (parity == ParityEven));
 189     MBED_ASSERT(data_bits == 8); // TODO: Support other number of data bits (also in the write method!)
 190
 191     // save C2 state
 192     uint32_t c2_state = obj->uart->CTRL & (LPUART_CTRL_RE_MASK | LPUART_CTRL_TE_MASK);
 193
 194     // disable UART before changing registers
 195     obj->uart->CTRL &= ~(LPUART_CTRL_RE_MASK | LPUART_CTRL_TE_MASK);
 196
 197
 198     uint8_t parity_enable = 0, parity_select = 0;
 199     switch (parity) {
 200         case ParityNone: parity_enable = 0; parity_select = 0; break;
 201         case ParityOdd : parity_enable = 1; parity_select = 1; data_bits++; break;
 202         case ParityEven: parity_enable = 1; parity_select = 0; data_bits++; break;
 203         default:
 204             break;
 205     }
 206
 207     stop_bits -= 1;
 208
 209     // data bits, parity and parity mode
 210     obj->uart->CTRL = ((parity_enable << 1) |  (parity_select << 0));
 211
 212     // stop bits
 213     obj->uart->BAUD &= ~LPUART_BAUD_SBNS_MASK;
 214     obj->uart->BAUD |= (stop_bits << LPUART_BAUD_SBNS_SHIFT);
 215
 216     // restore C2 state
 217     obj->uart->CTRL |= c2_state;
 218 }
 219
 220 /******************************************************************************
 221  * INTERRUPTS HANDLING
 222  ******************************************************************************/
 223 static inline void uart_irq(uint32_t status, uint32_t index) {
 224     if (serial_irq_ids[index] != 0) {
 225         if (status & LPUART_STAT_TDRE_MASK)
 226             irq_handler(serial_irq_ids[index], TxIrq);
 227
 228         if (status & LPUART_STAT_RDRF_MASK)
 229             irq_handler(serial_irq_ids[index], RxIrq);
 230     }
 231 }
 232
 233 void uart0_irq() {uart_irq(LPUART0->STAT, 0);}
 234 void uart1_irq() {uart_irq(LPUART1->STAT, 1);}
 235
 236 void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) {
 237     irq_handler = handler;
 238     serial_irq_ids[obj->index] = id;
 239 }
 240
 241 void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) {
 242     IRQn_Type irq_n = (IRQn_Type)0;
 243     uint32_t vector = 0;
 244     switch ((int)obj->uart) {
 245         case UART_0: irq_n=LPUART0_IRQn; vector = (uint32_t)&uart0_irq; break;
 246         case UART_1: irq_n=LPUART1_IRQn; vector = (uint32_t)&uart1_irq; break;
 247     }
 248
 249     if (enable) {
 250         switch (irq) {
 251             case RxIrq: obj->uart->CTRL |= LPUART_CTRL_RIE_MASK; break;
 252             case TxIrq: obj->uart->CTRL |= LPUART_CTRL_TIE_MASK; break;
 253         }
 254         NVIC_SetVector(irq_n, vector);
 255         NVIC_EnableIRQ(irq_n);
 256
 257     } else { // disable
 258         int all_disabled = 0;
 259         SerialIrq other_irq = (irq == RxIrq) ? (TxIrq) : (RxIrq);
 260         switch (irq) {
 261             case RxIrq: obj->uart->CTRL &= ~(LPUART_CTRL_RIE_MASK); break;
 262             case TxIrq: obj->uart->CTRL &= ~(LPUART_CTRL_TIE_MASK); break;
 263         }
 264         switch (other_irq) {
 265             case RxIrq: all_disabled = (obj->uart->CTRL & LPUART_CTRL_RIE_MASK) == 0; break;
 266             case TxIrq: all_disabled = (obj->uart->CTRL & LPUART_CTRL_TIE_MASK) == 0; break;
 267         }
 268         if (all_disabled)
 269             NVIC_DisableIRQ(irq_n);
 270     }
 271 }
 272
 273 /******************************************************************************
 274  * READ/WRITE
 275  ******************************************************************************/
 276 int serial_getc(serial_t *obj) {
 277     while (!serial_readable(obj));
 278     return (obj->uart->DATA & 0xFFu);
 279 }
 280
 281 void serial_putc(serial_t *obj, int c) {
 282     while (!serial_writable(obj));
 283     obj->uart->DATA = c;
 284 }
 285
 286 int serial_readable(serial_t *obj) {
 287     // check overrun
 288     if (obj->uart->STAT &  LPUART_STAT_OR_MASK) {
 289         obj->uart->STAT |= LPUART_STAT_OR_MASK;
 290     }
 291     return (obj->uart->STAT & LPUART_STAT_RDRF_MASK);
 292 }
 293
 294 int serial_writable(serial_t *obj) {
 295     // check overrun
 296     if (obj->uart->STAT &  LPUART_STAT_OR_MASK) {
 297         obj->uart->STAT |= LPUART_STAT_OR_MASK;
 298     }
 299     return (obj->uart->STAT & LPUART_STAT_TDRE_MASK);
 300 }
 301
 302 void serial_clear(serial_t *obj) {
 303 }
 304
 305 void serial_pinout_tx(PinName tx) {
 306     pinmap_pinout(tx, PinMap_UART_TX);
 307 }
 308
 309 void serial_break_set(serial_t *obj) {
 310     obj->uart->CTRL |= LPUART_CTRL_SBK_MASK;
 311 }
 312
 313 void serial_break_clear(serial_t *obj) {
 314     obj->uart->CTRL &= ~LPUART_CTRL_SBK_MASK;
 315 }
 316