firmware/target/arm/s3c2440/uart-s3c2440.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 by Bob Cousins
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /* Include Standard files */
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26 #include "inttypes.h"
  27 #include "string.h"
  28 #include "cpu.h"
  29 #include "system.h"
  30 #include "kernel.h"
  31 #include "thread.h"
  32
  33 #include "system-target.h"
  34 #include "uart-s3c2440.h"
  35
  36 #define MAX_PRINTF_BUF        1024
  37
  38 /****************************************************************************
  39  * serial driver API
  40  ****************************************************************************/
  41 void serial_setup (void)
  42 {
  43     uart_init();
  44     uart_init_device(DEBUG_UART_PORT);
  45 }
  46
  47 int tx_rdy(void)
  48 {
  49     if (uart_tx_ready (DEBUG_UART_PORT))
  50         return 1;
  51     else
  52         return 0;
  53 }
  54
  55 void tx_writec(unsigned char c)
  56 {
  57     uart_send_byte (DEBUG_UART_PORT, c);
  58 }
  59
  60
  61 /****************************************************************************
  62  * General purpose debug function
  63  ****************************************************************************/
  64
  65 void uart_printf (const char *format, ...)
  66 {
  67     static bool debug_uart_init = false;
  68     static char tx_buf [MAX_PRINTF_BUF];
  69
  70     int len;
  71     unsigned char *ptr;
  72     int j;
  73
  74     va_list ap;
  75     va_start(ap, format);
  76
  77     ptr = tx_buf;
  78     len = vsnprintf(ptr, sizeof(tx_buf), format, ap);
  79     va_end(ap);
  80
  81     if (!debug_uart_init)
  82     {
  83       uart_init_device(DEBUG_UART_PORT);
  84       debug_uart_init = true;
  85     }
  86
  87     for (j=0; j<len; j++)
  88     {
  89         uart_send_byte (DEBUG_UART_PORT, tx_buf[j]);
  90         if ( tx_buf[j] == '\n')
  91             uart_send_byte (DEBUG_UART_PORT, '\r');
  92     }
  93 }
  94
  95 /****************************************************************************
  96  * Device level functions specific to S3C2440
  97  *****************************************************************************/
  98
  99 bool uart_init (void)
 100 {
 101     /* anything ? */
 102     return true;
 103 }
 104
 105 bool uart_init_device (unsigned dev)
 106 {
 107     /* set GPIOs, clock enable? etc */
 108
 109     switch (dev)
 110     {
 111         case 0:
 112         {
 113             S3C2440_GPIO_CONFIG (GPHCON, 2, GPIO_FUNCTION);
 114             S3C2440_GPIO_CONFIG (GPHCON, 3, GPIO_FUNCTION);
 115             S3C2440_GPIO_PULLUP (GPHUP, 2, GPIO_PULLUP_DISABLE);
 116             S3C2440_GPIO_PULLUP (GPHUP, 3, GPIO_PULLUP_DISABLE);
 117             break;
 118         }
 119         case 1:
 120         {
 121             S3C2440_GPIO_CONFIG (GPHCON, 4, GPIO_FUNCTION);
 122             S3C2440_GPIO_CONFIG (GPHCON, 5, GPIO_FUNCTION);
 123             S3C2440_GPIO_PULLUP (GPHUP, 4, GPIO_PULLUP_DISABLE);
 124             S3C2440_GPIO_PULLUP (GPHUP, 5, GPIO_PULLUP_DISABLE);
 125             break;
 126         }
 127         case 2:
 128         {
 129             S3C2440_GPIO_CONFIG (GPHCON, 6, GPIO_FUNCTION);
 130             S3C2440_GPIO_CONFIG (GPHCON, 7, GPIO_FUNCTION);
 131             S3C2440_GPIO_PULLUP (GPHUP, 6, GPIO_PULLUP_DISABLE);
 132             S3C2440_GPIO_PULLUP (GPHUP, 7, GPIO_PULLUP_DISABLE);
 133             break;
 134         }
 135         default:
 136             return false;
 137     }
 138
 139     /* set a default configuration */
 140     uart_config (dev, 115200, 8, UART_NO_PARITY, UART_1_STOP_BIT);
 141     return true;
 142 }
 143
 144 bool uart_config (unsigned dev, unsigned speed, unsigned num_bits,
 145                   unsigned parity, unsigned stop_bits)
 146 {
 147     switch (dev)
 148     {
 149     case 0:
 150         ULCON0  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 151         UCON0   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 152         UBRDIV0 = PCLK / (speed*16);
 153         break;
 154
 155     case 1:
 156         ULCON1  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 157         UCON1   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 158         UBRDIV1 = PCLK / (speed*16);
 159         break;
 160
 161     case 2:
 162         ULCON2  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 163         UCON2   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 164         UBRDIV2 = PCLK / (speed*16);
 165         break;
 166     }
 167
 168     return true;
 169 }
 170
 171 /* transmit */
 172 bool uart_tx_ready (unsigned dev)
 173 {
 174     /* test if transmit buffer empty */
 175     switch (dev)
 176     {
 177     case 0:
 178         if (UTRSTAT0 & 0x02)
 179             return true;
 180         else
 181             return false;
 182         break;
 183     case 1:
 184         if (UTRSTAT1 & 0x02)
 185             return true;
 186         else
 187             return false;
 188         break;
 189     case 2:
 190         if (UTRSTAT2 & 0x02)
 191             return true;
 192         else
 193             return false;
 194         break;
 195     }
 196     return false;
 197 }
 198
 199 bool uart_send_byte (unsigned dev, char ch)
 200 {
 201     /* wait for transmit buffer empty */
 202     while (!uart_tx_ready(dev))
 203         ;
 204
 205     switch (dev)
 206     {
 207     case 0:
 208         UTXH0 = ch;
 209         break;
 210     case 1:
 211         UTXH1 = ch;
 212         break;
 213     case 2:
 214         UTXH2 = ch;
 215         break;
 216     }
 217
 218     return true;
 219 }
 220
 221 /* Receive */
 222
 223 bool uart_rx_ready (unsigned dev)
 224 {
 225     /* test receive buffer data ready */
 226     switch (dev)
 227     {
 228     case 0:
 229         if (UTRSTAT0 & 0x01)
 230             return true;
 231         else
 232             return false;
 233         break;
 234     case 1:
 235         if (UTRSTAT1 & 0x01)
 236             return true;
 237         else
 238             return false;
 239         break;
 240     case 2:
 241         if (UTRSTAT2 & 0x01)
 242             return true;
 243         else
 244             return false;
 245         break;
 246     }
 247     return false;
 248 }
 249
 250 char uart_read_byte (unsigned dev)
 251 {
 252     while (!uart_rx_ready(dev))
 253         ;
 254     switch (dev)
 255     {
 256     case 0:
 257         return URXH0;
 258         break;
 259     case 1:
 260         return URXH1;
 261         break;
 262     case 2:
 263         return URXH2;
 264         break;
 265     }
 266
 267     return '\0';
 268 }
 269
 270 /****************************************************************************
 271  * General
 272  *****************************************************************************/
 273
 274 bool uart_send_buf (unsigned dev, char *buf, unsigned len)
 275 {
 276     unsigned index=0;
 277     while (index<len)
 278     {
 279         uart_send_byte (dev, buf[index]);
 280         index++;
 281     }
 282     return true;
 283 }
 284
 285
 286 /****************************************************************************/