Pileus Git - ~andy/linux/blob - arch/arm/mach-omap2/serial.c

   1 /*
   2  * arch/arm/mach-omap2/serial.c
   3  *
   4  * OMAP2 serial support.
   5  *
   6  * Copyright (C) 2005-2008 Nokia Corporation
   7  * Author: Paul Mundt <paul.mundt@nokia.com>
   8  *
   9  * Major rework for PM support by Kevin Hilman
  10  *
  11  * Based off of arch/arm/mach-omap/omap1/serial.c
  12  *
  13  * Copyright (C) 2009 Texas Instruments
  14  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com
  15  *
  16  * This file is subject to the terms and conditions of the GNU General Public
  17  * License. See the file "COPYING" in the main directory of this archive
  18  * for more details.
  19  */
  20 #include <linux/kernel.h>
  21 #include <linux/init.h>
  22 #include <linux/clk.h>
  23 #include <linux/io.h>
  24 #include <linux/delay.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/slab.h>
  27 #include <linux/pm_runtime.h>
  28 #include <linux/console.h>
  29
  30 #include <plat/omap-serial.h>
  31 #include "common.h"
  32 #include <plat/board.h>
  33 #include <plat/dma.h>
  34 #include <plat/omap_hwmod.h>
  35 #include <plat/omap_device.h>
  36 #include <plat/omap-pm.h>
  37
  38 #include "prm2xxx_3xxx.h"
  39 #include "pm.h"
  40 #include "cm2xxx_3xxx.h"
  41 #include "prm-regbits-34xx.h"
  42 #include "control.h"
  43 #include "mux.h"
  44
  45 /*
  46  * NOTE: By default the serial auto_suspend timeout is disabled as it causes
  47  * lost characters over the serial ports. This means that the UART clocks will
  48  * stay on until power/autosuspend_delay is set for the uart from sysfs.
  49  * This also causes that any deeper omap sleep states are blocked.
  50  */
  51 #define DEFAULT_AUTOSUSPEND_DELAY       -1
  52
  53 #define MAX_UART_HWMOD_NAME_LEN         16
  54
  55 struct omap_uart_state {
  56         int num;
  57         int can_sleep;
  58
  59         struct list_head node;
  60         struct omap_hwmod *oh;
  61         struct platform_device *pdev;
  62 };
  63
  64 static LIST_HEAD(uart_list);
  65 static u8 num_uarts;
  66 static u8 console_uart_id = -1;
  67 static u8 no_console_suspend;
  68
  69 #define DEFAULT_RXDMA_POLLRATE          1       /* RX DMA polling rate (us) */
  70 #define DEFAULT_RXDMA_BUFSIZE           4096    /* RX DMA buffer size */
  71 #define DEFAULT_RXDMA_TIMEOUT           (3 * HZ)/* RX DMA timeout (jiffies) */
  72
  73 static struct omap_uart_port_info omap_serial_default_info[] __initdata = {
  74         {
  75                 .dma_enabled    = false,
  76                 .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE,
  77                 .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE,
  78                 .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT,
  79                 .autosuspend_timeout = DEFAULT_AUTOSUSPEND_DELAY,
  80         },
  81 };
  82
  83 #ifdef CONFIG_PM
  84
  85 int omap_uart_can_sleep(void)
  86 {
  87         struct omap_uart_state *uart;
  88         int can_sleep = 1;
  89
  90         list_for_each_entry(uart, &uart_list, node) {
  91                 if (!uart->clocked)
  92                         continue;
  93
  94                 if (!uart->can_sleep) {
  95                         can_sleep = 0;
  96                         continue;
  97                 }
  98
  99                 /* This UART can now safely sleep. */
 100                 omap_uart_allow_sleep(uart);
 101         }
 102
 103         return can_sleep;
 104 }
 105
 106 static void omap_uart_enable_wakeup(struct platform_device *pdev, bool enable)
 107 {
 108         struct omap_device *od = to_omap_device(pdev);
 109
 110         if (!od)
 111                 return;
 112
 113         if (enable)
 114                 omap_hwmod_enable_wakeup(od->hwmods[0]);
 115         else
 116                 omap_hwmod_disable_wakeup(od->hwmods[0]);
 117 }
 118
 119 /*
 120  * Errata i291: [UART]:Cannot Acknowledge Idle Requests
 121  * in Smartidle Mode When Configured for DMA Operations.
 122  * WA: configure uart in force idle mode.
 123  */
 124 static void omap_uart_set_noidle(struct platform_device *pdev)
 125 {
 126         struct omap_device *od = to_omap_device(pdev);
 127
 128         omap_hwmod_set_slave_idlemode(od->hwmods[0], HWMOD_IDLEMODE_NO);
 129 }
 130
 131 static void omap_uart_set_forceidle(struct platform_device *pdev)
 132 {
 133         struct omap_device *od = to_omap_device(pdev);
 134
 135         omap_hwmod_set_slave_idlemode(od->hwmods[0], HWMOD_IDLEMODE_FORCE);
 136 }
 137
 138 #else
 139 static void omap_uart_enable_wakeup(struct platform_device *pdev, bool enable)
 140 {}
 141 static void omap_uart_set_noidle(struct platform_device *pdev) {}
 142 static void omap_uart_set_forceidle(struct platform_device *pdev) {}
 143 #endif /* CONFIG_PM */
 144
 145 #ifdef CONFIG_OMAP_MUX
 146 static struct omap_device_pad default_uart1_pads[] __initdata = {
 147         {
 148                 .name   = "uart1_cts.uart1_cts",
 149                 .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 150         },
 151         {
 152                 .name   = "uart1_rts.uart1_rts",
 153                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 154         },
 155         {
 156                 .name   = "uart1_tx.uart1_tx",
 157                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 158         },
 159         {
 160                 .name   = "uart1_rx.uart1_rx",
 161                 .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
 162                 .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 163                 .idle   = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 164         },
 165 };
 166
 167 static struct omap_device_pad default_uart2_pads[] __initdata = {
 168         {
 169                 .name   = "uart2_cts.uart2_cts",
 170                 .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 171         },
 172         {
 173                 .name   = "uart2_rts.uart2_rts",
 174                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 175         },
 176         {
 177                 .name   = "uart2_tx.uart2_tx",
 178                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 179         },
 180         {
 181                 .name   = "uart2_rx.uart2_rx",
 182                 .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
 183                 .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 184                 .idle   = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 185         },
 186 };
 187
 188 static struct omap_device_pad default_uart3_pads[] __initdata = {
 189         {
 190                 .name   = "uart3_cts_rctx.uart3_cts_rctx",
 191                 .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
 192         },
 193         {
 194                 .name   = "uart3_rts_sd.uart3_rts_sd",
 195                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 196         },
 197         {
 198                 .name   = "uart3_tx_irtx.uart3_tx_irtx",
 199                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 200         },
 201         {
 202                 .name   = "uart3_rx_irrx.uart3_rx_irrx",
 203                 .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
 204                 .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
 205                 .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
 206         },
 207 };
 208
 209 static struct omap_device_pad default_omap36xx_uart4_pads[] __initdata = {
 210         {
 211                 .name   = "gpmc_wait2.uart4_tx",
 212                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 213         },
 214         {
 215                 .name   = "gpmc_wait3.uart4_rx",
 216                 .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
 217                 .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE2,
 218                 .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE2,
 219         },
 220 };
 221
 222 static struct omap_device_pad default_omap4_uart4_pads[] __initdata = {
 223         {
 224                 .name   = "uart4_tx.uart4_tx",
 225                 .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
 226         },
 227         {
 228                 .name   = "uart4_rx.uart4_rx",
 229                 .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
 230                 .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
 231                 .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
 232         },
 233 };
 234
 235 static void omap_serial_fill_default_pads(struct omap_board_data *bdata)
 236 {
 237         switch (bdata->id) {
 238         case 0:
 239                 bdata->pads = default_uart1_pads;
 240                 bdata->pads_cnt = ARRAY_SIZE(default_uart1_pads);
 241                 break;
 242         case 1:
 243                 bdata->pads = default_uart2_pads;
 244                 bdata->pads_cnt = ARRAY_SIZE(default_uart2_pads);
 245                 break;
 246         case 2:
 247                 bdata->pads = default_uart3_pads;
 248                 bdata->pads_cnt = ARRAY_SIZE(default_uart3_pads);
 249                 break;
 250         case 3:
 251                 if (cpu_is_omap44xx()) {
 252                         bdata->pads = default_omap4_uart4_pads;
 253                         bdata->pads_cnt =
 254                                 ARRAY_SIZE(default_omap4_uart4_pads);
 255                 } else if (cpu_is_omap3630()) {
 256                         bdata->pads = default_omap36xx_uart4_pads;
 257                         bdata->pads_cnt =
 258                                 ARRAY_SIZE(default_omap36xx_uart4_pads);
 259                 }
 260                 break;
 261         default:
 262                 break;
 263         }
 264 }
 265 #else
 266 static void omap_serial_fill_default_pads(struct omap_board_data *bdata) {}
 267 #endif
 268
 269 char *cmdline_find_option(char *str)
 270 {
 271         extern char *saved_command_line;
 272
 273         return strstr(saved_command_line, str);
 274 }
 275
 276 static int __init omap_serial_early_init(void)
 277 {
 278         do {
 279                 char oh_name[MAX_UART_HWMOD_NAME_LEN];
 280                 struct omap_hwmod *oh;
 281                 struct omap_uart_state *uart;
 282                 char uart_name[MAX_UART_HWMOD_NAME_LEN];
 283
 284                 snprintf(oh_name, MAX_UART_HWMOD_NAME_LEN,
 285                          "uart%d", num_uarts + 1);
 286                 oh = omap_hwmod_lookup(oh_name);
 287                 if (!oh)
 288                         break;
 289
 290                 uart = kzalloc(sizeof(struct omap_uart_state), GFP_KERNEL);
 291                 if (WARN_ON(!uart))
 292                         return -ENODEV;
 293
 294                 uart->oh = oh;
 295                 uart->num = num_uarts++;
 296                 list_add_tail(&uart->node, &uart_list);
 297                 snprintf(uart_name, MAX_UART_HWMOD_NAME_LEN,
 298                                 "%s%d", OMAP_SERIAL_NAME, uart->num);
 299
 300                 if (cmdline_find_option(uart_name)) {
 301                         console_uart_id = uart->num;
 302
 303                         if (cmdline_find_option("no_console_suspend"))
 304                                 no_console_suspend = true;
 305
 306                         /*
 307                          * omap-uart can be used for earlyprintk logs
 308                          * So if omap-uart is used as console then prevent
 309                          * uart reset and idle to get logs from omap-uart
 310                          * until uart console driver is available to take
 311                          * care for console messages.
 312                          * Idling or resetting omap-uart while printing logs
 313                          * early boot logs can stall the boot-up.
 314                          */
 315                         oh->flags |= HWMOD_INIT_NO_IDLE | HWMOD_INIT_NO_RESET;
 316                 }
 317         } while (1);
 318
 319         return 0;
 320 }
 321 core_initcall(omap_serial_early_init);
 322
 323 /**
 324  * omap_serial_init_port() - initialize single serial port
 325  * @bdata: port specific board data pointer
 326  * @info: platform specific data pointer
 327  *
 328  * This function initialies serial driver for given port only.
 329  * Platforms can call this function instead of omap_serial_init()
 330  * if they don't plan to use all available UARTs as serial ports.
 331  *
 332  * Don't mix calls to omap_serial_init_port() and omap_serial_init(),
 333  * use only one of the two.
 334  */
 335 void __init omap_serial_init_port(struct omap_board_data *bdata,
 336                         struct omap_uart_port_info *info)
 337 {
 338         struct omap_uart_state *uart;
 339         struct omap_hwmod *oh;
 340         struct platform_device *pdev;
 341         void *pdata = NULL;
 342         u32 pdata_size = 0;
 343         char *name;
 344         struct omap_uart_port_info omap_up;
 345
 346         if (WARN_ON(!bdata))
 347                 return;
 348         if (WARN_ON(bdata->id < 0))
 349                 return;
 350         if (WARN_ON(bdata->id >= num_uarts))
 351                 return;
 352
 353         list_for_each_entry(uart, &uart_list, node)
 354                 if (bdata->id == uart->num)
 355                         break;
 356         if (!info)
 357                 info = omap_serial_default_info;
 358
 359         oh = uart->oh;
 360         name = DRIVER_NAME;
 361
 362         omap_up.dma_enabled = info->dma_enabled;
 363         omap_up.uartclk = OMAP24XX_BASE_BAUD * 16;
 364         omap_up.flags = UPF_BOOT_AUTOCONF;
 365         omap_up.get_context_loss_count = omap_pm_get_dev_context_loss_count;
 366         omap_up.set_forceidle = omap_uart_set_forceidle;
 367         omap_up.set_noidle = omap_uart_set_noidle;
 368         omap_up.enable_wakeup = omap_uart_enable_wakeup;
 369         omap_up.dma_rx_buf_size = info->dma_rx_buf_size;
 370         omap_up.dma_rx_timeout = info->dma_rx_timeout;
 371         omap_up.dma_rx_poll_rate = info->dma_rx_poll_rate;
 372         omap_up.autosuspend_timeout = info->autosuspend_timeout;
 373
 374         /* Enable the MDR1 Errata i202 for OMAP2430/3xxx/44xx */
 375         if (!cpu_is_omap2420() && !cpu_is_ti816x())
 376                 omap_up.errata |= UART_ERRATA_i202_MDR1_ACCESS;
 377
 378         /* Enable DMA Mode Force Idle Errata i291 for omap34xx/3630 */
 379         if (cpu_is_omap34xx() || cpu_is_omap3630())
 380                 omap_up.errata |= UART_ERRATA_i291_DMA_FORCEIDLE;
 381
 382         pdata = &omap_up;
 383         pdata_size = sizeof(struct omap_uart_port_info);
 384
 385         if (WARN_ON(!oh))
 386                 return;
 387
 388         pdev = omap_device_build(name, uart->num, oh, pdata, pdata_size,
 389                                  NULL, 0, false);
 390         WARN(IS_ERR(pdev), "Could not build omap_device for %s: %s.\n",
 391              name, oh->name);
 392
 393         if ((console_uart_id == bdata->id) && no_console_suspend)
 394                 omap_device_disable_idle_on_suspend(pdev);
 395
 396         oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);
 397
 398         uart->pdev = pdev;
 399
 400         oh->dev_attr = uart;
 401
 402         if ((cpu_is_omap34xx() || cpu_is_omap44xx()) && bdata->pads)
 403                 device_init_wakeup(&pdev->dev, true);
 404 }
 405
 406 /**
 407  * omap_serial_board_init() - initialize all supported serial ports
 408  * @info: platform specific data pointer
 409  *
 410  * Initializes all available UARTs as serial ports. Platforms
 411  * can call this function when they want to have default behaviour
 412  * for serial ports (e.g initialize them all as serial ports).
 413  */
 414 void __init omap_serial_board_init(struct omap_uart_port_info *info)
 415 {
 416         struct omap_uart_state *uart;
 417         struct omap_board_data bdata;
 418
 419         list_for_each_entry(uart, &uart_list, node) {
 420                 bdata.id = uart->num;
 421                 bdata.flags = 0;
 422                 bdata.pads = NULL;
 423                 bdata.pads_cnt = 0;
 424
 425                 if (cpu_is_omap44xx() || cpu_is_omap34xx())
 426                         omap_serial_fill_default_pads(&bdata);
 427
 428                 if (!info)
 429                         omap_serial_init_port(&bdata, NULL);
 430                 else
 431                         omap_serial_init_port(&bdata, &info[uart->num]);
 432         }
 433 }
 434
 435 /**
 436  * omap_serial_init() - initialize all supported serial ports
 437  *
 438  * Initializes all available UARTs.
 439  * Platforms can call this function when they want to have default behaviour
 440  * for serial ports (e.g initialize them all as serial ports).
 441  */
 442 void __init omap_serial_init(void)
 443 {
 444         omap_serial_board_init(NULL);
 445 }