arch/arm/mach-omap2/serial.c

   1 /*
   2  * arch/arm/mach-omap2/serial.c
   3  *
   4  * OMAP2 serial support.
   5  *
   6  * Copyright (C) 2005 Nokia Corporation
   7  * Author: Paul Mundt <paul.mundt@nokia.com>
   8  *
   9  * Based off of arch/arm/mach-omap/omap1/serial.c
  10  *
  11  * This file is subject to the terms and conditions of the GNU General Public
  12  * License. See the file "COPYING" in the main directory of this archive
  13  * for more details.
  14  */
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/serial_8250.h>
  18 #include <linux/serial_reg.h>
  19 #include <linux/clk.h>
  20
  21 #include <asm/io.h>
  22
  23 #include <asm/arch/common.h>
  24 #include <asm/arch/board.h>
  25
  26 static struct clk * uart1_ick = NULL;
  27 static struct clk * uart1_fck = NULL;
  28 static struct clk * uart2_ick = NULL;
  29 static struct clk * uart2_fck = NULL;
  30 static struct clk * uart3_ick = NULL;
  31 static struct clk * uart3_fck = NULL;
  32
  33 static struct plat_serial8250_port serial_platform_data[] = {
  34         {
  35                 .membase        = (char *)IO_ADDRESS(OMAP_UART1_BASE),
  36                 .mapbase        = (unsigned long)OMAP_UART1_BASE,
  37                 .irq            = 72,
  38                 .flags          = UPF_BOOT_AUTOCONF,
  39                 .iotype         = UPIO_MEM,
  40                 .regshift       = 2,
  41                 .uartclk        = OMAP24XX_BASE_BAUD * 16,
  42         }, {
  43                 .membase        = (char *)IO_ADDRESS(OMAP_UART2_BASE),
  44                 .mapbase        = (unsigned long)OMAP_UART2_BASE,
  45                 .irq            = 73,
  46                 .flags          = UPF_BOOT_AUTOCONF,
  47                 .iotype         = UPIO_MEM,
  48                 .regshift       = 2,
  49                 .uartclk        = OMAP24XX_BASE_BAUD * 16,
  50         }, {
  51                 .membase        = (char *)IO_ADDRESS(OMAP_UART3_BASE),
  52                 .mapbase        = (unsigned long)OMAP_UART3_BASE,
  53                 .irq            = 74,
  54                 .flags          = UPF_BOOT_AUTOCONF,
  55                 .iotype         = UPIO_MEM,
  56                 .regshift       = 2,
  57                 .uartclk        = OMAP24XX_BASE_BAUD * 16,
  58         }, {
  59                 .flags          = 0
  60         }
  61 };
  62
  63 static inline unsigned int serial_read_reg(struct plat_serial8250_port *up,
  64                                            int offset)
  65 {
  66         offset <<= up->regshift;
  67         return (unsigned int)__raw_readb(up->membase + offset);
  68 }
  69
  70 static inline void serial_write_reg(struct plat_serial8250_port *p, int offset,
  71                                     int value)
  72 {
  73         offset <<= p->regshift;
  74         __raw_writeb(value, (unsigned long)(p->membase + offset));
  75 }
  76
  77 /*
  78  * Internal UARTs need to be initialized for the 8250 autoconfig to work
  79  * properly. Note that the TX watermark initialization may not be needed
  80  * once the 8250.c watermark handling code is merged.
  81  */
  82 static inline void __init omap_serial_reset(struct plat_serial8250_port *p)
  83 {
  84         serial_write_reg(p, UART_OMAP_MDR1, 0x07);
  85         serial_write_reg(p, UART_OMAP_SCR, 0x08);
  86         serial_write_reg(p, UART_OMAP_MDR1, 0x00);
  87         serial_write_reg(p, UART_OMAP_SYSC, (0x02 << 3) | (1 << 2) | (1 << 0));
  88 }
  89
  90 void __init omap_serial_init(void)
  91 {
  92         int i;
  93         const struct omap_uart_config *info;
  94
  95         /*
  96          * Make sure the serial ports are muxed on at this point.
  97          * You have to mux them off in device drivers later on
  98          * if not needed.
  99          */
 100
 101         info = omap_get_config(OMAP_TAG_UART, struct omap_uart_config);
 102
 103         if (info == NULL)
 104                 return;
 105
 106         for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
 107                 struct plat_serial8250_port *p = serial_platform_data + i;
 108
 109                 if (!(info->enabled_uarts & (1 << i))) {
 110                         p->membase = 0;
 111                         p->mapbase = 0;
 112                         continue;
 113                 }
 114
 115                 switch (i) {
 116                 case 0:
 117                         uart1_ick = clk_get(NULL, "uart1_ick");
 118                         if (IS_ERR(uart1_ick))
 119                                 printk("Could not get uart1_ick\n");
 120                         else
 121                                 clk_enable(uart1_ick);
 122
 123                         uart1_fck = clk_get(NULL, "uart1_fck");
 124                         if (IS_ERR(uart1_fck))
 125                                 printk("Could not get uart1_fck\n");
 126                         else
 127                                 clk_enable(uart1_fck);
 128                         break;
 129                 case 1:
 130                         uart2_ick = clk_get(NULL, "uart2_ick");
 131                         if (IS_ERR(uart2_ick))
 132                                 printk("Could not get uart2_ick\n");
 133                         else
 134                                 clk_enable(uart2_ick);
 135
 136                         uart2_fck = clk_get(NULL, "uart2_fck");
 137                         if (IS_ERR(uart2_fck))
 138                                 printk("Could not get uart2_fck\n");
 139                         else
 140                                 clk_enable(uart2_fck);
 141                         break;
 142                 case 2:
 143                         uart3_ick = clk_get(NULL, "uart3_ick");
 144                         if (IS_ERR(uart3_ick))
 145                                 printk("Could not get uart3_ick\n");
 146                         else
 147                                 clk_enable(uart3_ick);
 148
 149                         uart3_fck = clk_get(NULL, "uart3_fck");
 150                         if (IS_ERR(uart3_fck))
 151                                 printk("Could not get uart3_fck\n");
 152                         else
 153                                 clk_enable(uart3_fck);
 154                         break;
 155                 }
 156
 157                 omap_serial_reset(p);
 158         }
 159 }
 160
 161 static struct platform_device serial_device = {
 162         .name                   = "serial8250",
 163         .id                     = PLAT8250_DEV_PLATFORM,
 164         .dev                    = {
 165                 .platform_data  = serial_platform_data,
 166         },
 167 };
 168
 169 static int __init omap_init(void)
 170 {
 171         return platform_device_register(&serial_device);
 172 }
 173 arch_initcall(omap_init);