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 static int uart_push(void *user_data, unsigned char ch)
  62 {
  63     (void)user_data;
  64
  65     uart_send_byte(DEBUG_UART_PORT, ch);
  66     if (ch == '\n')
  67         uart_send_byte(DEBUG_UART_PORT, '\r');
  68     return 1;
  69 }
  70
  71 /****************************************************************************
  72  * General purpose debug function
  73  ****************************************************************************/
  74 void uart_printf (const char *format, ...)
  75 {
  76     static bool debug_uart_init = false;
  77     va_list ap;
  78
  79     if (!debug_uart_init)
  80     {
  81       uart_init_device(DEBUG_UART_PORT);
  82       debug_uart_init = true;
  83     }
  84
  85     va_start(ap, format);
  86     vuprintf(uart_push, NULL, format, ap);
  87     va_end(ap);
  88 }
  89
  90 /****************************************************************************
  91  * Device level functions specific to S3C2440
  92  *****************************************************************************/
  93
  94 bool uart_init (void)
  95 {
  96     /* anything ? */
  97     return true;
  98 }
  99
 100 bool uart_init_device (unsigned dev)
 101 {
 102     /* set GPIOs, clock enable? etc */
 103
 104     switch (dev)
 105     {
 106         case 0:
 107         {
 108             S3C2440_GPIO_CONFIG (GPHCON, 2, GPIO_FUNCTION);
 109             S3C2440_GPIO_CONFIG (GPHCON, 3, GPIO_FUNCTION);
 110             S3C2440_GPIO_PULLUP (GPHUP, 2, GPIO_PULLUP_DISABLE);
 111             S3C2440_GPIO_PULLUP (GPHUP, 3, GPIO_PULLUP_DISABLE);
 112             break;
 113         }
 114         case 1:
 115         {
 116             S3C2440_GPIO_CONFIG (GPHCON, 4, GPIO_FUNCTION);
 117             S3C2440_GPIO_CONFIG (GPHCON, 5, GPIO_FUNCTION);
 118             S3C2440_GPIO_PULLUP (GPHUP, 4, GPIO_PULLUP_DISABLE);
 119             S3C2440_GPIO_PULLUP (GPHUP, 5, GPIO_PULLUP_DISABLE);
 120             break;
 121         }
 122         case 2:
 123         {
 124             S3C2440_GPIO_CONFIG (GPHCON, 6, GPIO_FUNCTION);
 125             S3C2440_GPIO_CONFIG (GPHCON, 7, GPIO_FUNCTION);
 126             S3C2440_GPIO_PULLUP (GPHUP, 6, GPIO_PULLUP_DISABLE);
 127             S3C2440_GPIO_PULLUP (GPHUP, 7, GPIO_PULLUP_DISABLE);
 128             break;
 129         }
 130         default:
 131             return false;
 132     }
 133
 134     /* set a default configuration */
 135     uart_config (dev, 115200, 8, UART_NO_PARITY, UART_1_STOP_BIT);
 136     return true;
 137 }
 138
 139 bool uart_config (unsigned dev, unsigned speed, unsigned num_bits,
 140                   unsigned parity, unsigned stop_bits)
 141 {
 142     switch (dev)
 143     {
 144     case 0:
 145         ULCON0  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 146         UCON0   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 147         UBRDIV0 = PCLK / (speed*16);
 148         break;
 149
 150     case 1:
 151         ULCON1  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 152         UCON1   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 153         UBRDIV1 = PCLK / (speed*16);
 154         break;
 155
 156     case 2:
 157         ULCON2  = (parity << 3) + (stop_bits << 2) + (num_bits-5);
 158         UCON2   = (1 << 2) + (1 << 0);   /* enable TX, RX, use PCLK */
 159         UBRDIV2 = PCLK / (speed*16);
 160         break;
 161     }
 162
 163     return true;
 164 }
 165
 166 /* transmit */
 167 bool uart_tx_ready (unsigned dev)
 168 {
 169     /* test if transmit buffer empty */
 170     switch (dev)
 171     {
 172     case 0:
 173         if (UTRSTAT0 & 0x02)
 174             return true;
 175         else
 176             return false;
 177         break;
 178     case 1:
 179         if (UTRSTAT1 & 0x02)
 180             return true;
 181         else
 182             return false;
 183         break;
 184     case 2:
 185         if (UTRSTAT2 & 0x02)
 186             return true;
 187         else
 188             return false;
 189         break;
 190     }
 191     return false;
 192 }
 193
 194 bool uart_send_byte (unsigned dev, char ch)
 195 {
 196     /* wait for transmit buffer empty */
 197     while (!uart_tx_ready(dev))
 198         ;
 199
 200     switch (dev)
 201     {
 202     case 0:
 203         UTXH0 = ch;
 204         break;
 205     case 1:
 206         UTXH1 = ch;
 207         break;
 208     case 2:
 209         UTXH2 = ch;
 210         break;
 211     }
 212
 213     return true;
 214 }
 215
 216 /* Receive */
 217
 218 bool uart_rx_ready (unsigned dev)
 219 {
 220     /* test receive buffer data ready */
 221     switch (dev)
 222     {
 223     case 0:
 224         if (UTRSTAT0 & 0x01)
 225             return true;
 226         else
 227             return false;
 228         break;
 229     case 1:
 230         if (UTRSTAT1 & 0x01)
 231             return true;
 232         else
 233             return false;
 234         break;
 235     case 2:
 236         if (UTRSTAT2 & 0x01)
 237             return true;
 238         else
 239             return false;
 240         break;
 241     }
 242     return false;
 243 }
 244
 245 char uart_read_byte (unsigned dev)
 246 {
 247     while (!uart_rx_ready(dev))
 248         ;
 249     switch (dev)
 250     {
 251     case 0:
 252         return URXH0;
 253         break;
 254     case 1:
 255         return URXH1;
 256         break;
 257     case 2:
 258         return URXH2;
 259         break;
 260     }
 261
 262     return '\0';
 263 }
 264
 265 /****************************************************************************
 266  * General
 267  *****************************************************************************/
 268
 269 bool uart_send_buf (unsigned dev, char *buf, unsigned len)
 270 {
 271     unsigned index=0;
 272     while (index<len)
 273     {
 274         uart_send_byte (dev, buf[index]);
 275         index++;
 276     }
 277     return true;
 278 }
 279
 280
 281 /****************************************************************************/