serial.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377
  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. #include <plat/omap-serial.h>
  30. #include "common.h"
  31. #include <plat/dma.h>
  32. #include <plat/omap_hwmod.h>
  33. #include <plat/omap_device.h>
  34. #include <plat/omap-pm.h>
  35. #include <plat/serial.h>
  36. #include "prm2xxx_3xxx.h"
  37. #include "pm.h"
  38. #include "cm2xxx_3xxx.h"
  39. #include "prm-regbits-34xx.h"
  40. #include "control.h"
  41. #include "mux.h"
  42. /*
  43. * NOTE: By default the serial auto_suspend timeout is disabled as it causes
  44. * lost characters over the serial ports. This means that the UART clocks will
  45. * stay on until power/autosuspend_delay is set for the uart from sysfs.
  46. * This also causes that any deeper omap sleep states are blocked.
  47. */
  48. #define DEFAULT_AUTOSUSPEND_DELAY -1
  49. #define MAX_UART_HWMOD_NAME_LEN 16
  50. struct omap_uart_state {
  51. int num;
  52. struct list_head node;
  53. struct omap_hwmod *oh;
  54. struct omap_device_pad default_omap_uart_pads[2];
  55. };
  56. static LIST_HEAD(uart_list);
  57. static u8 num_uarts;
  58. static u8 console_uart_id = -1;
  59. static u8 no_console_suspend;
  60. static u8 uart_debug;
  61. #define DEFAULT_RXDMA_POLLRATE 1 /* RX DMA polling rate (us) */
  62. #define DEFAULT_RXDMA_BUFSIZE 4096 /* RX DMA buffer size */
  63. #define DEFAULT_RXDMA_TIMEOUT (3 * HZ)/* RX DMA timeout (jiffies) */
  64. static struct omap_uart_port_info omap_serial_default_info[] __initdata = {
  65. {
  66. .dma_enabled = false,
  67. .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE,
  68. .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE,
  69. .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT,
  70. .autosuspend_timeout = DEFAULT_AUTOSUSPEND_DELAY,
  71. },
  72. };
  73. #ifdef CONFIG_PM
  74. static void omap_uart_enable_wakeup(struct device *dev, bool enable)
  75. {
  76. struct platform_device *pdev = to_platform_device(dev);
  77. struct omap_device *od = to_omap_device(pdev);
  78. if (!od)
  79. return;
  80. if (enable)
  81. omap_hwmod_enable_wakeup(od->hwmods[0]);
  82. else
  83. omap_hwmod_disable_wakeup(od->hwmods[0]);
  84. }
  85. /*
  86. * Errata i291: [UART]:Cannot Acknowledge Idle Requests
  87. * in Smartidle Mode When Configured for DMA Operations.
  88. * WA: configure uart in force idle mode.
  89. */
  90. static void omap_uart_set_noidle(struct device *dev)
  91. {
  92. struct platform_device *pdev = to_platform_device(dev);
  93. struct omap_device *od = to_omap_device(pdev);
  94. omap_hwmod_set_slave_idlemode(od->hwmods[0], HWMOD_IDLEMODE_NO);
  95. }
  96. static void omap_uart_set_smartidle(struct device *dev)
  97. {
  98. struct platform_device *pdev = to_platform_device(dev);
  99. struct omap_device *od = to_omap_device(pdev);
  100. u8 idlemode;
  101. if (od->hwmods[0]->class->sysc->idlemodes & SIDLE_SMART_WKUP)
  102. idlemode = HWMOD_IDLEMODE_SMART_WKUP;
  103. else
  104. idlemode = HWMOD_IDLEMODE_SMART;
  105. omap_hwmod_set_slave_idlemode(od->hwmods[0], idlemode);
  106. }
  107. #else
  108. static void omap_uart_enable_wakeup(struct device *dev, bool enable)
  109. {}
  110. static void omap_uart_set_noidle(struct device *dev) {}
  111. static void omap_uart_set_smartidle(struct device *dev) {}
  112. #endif /* CONFIG_PM */
  113. #ifdef CONFIG_OMAP_MUX
  114. #define OMAP_UART_DEFAULT_PAD_NAME_LEN 28
  115. static char rx_pad_name[OMAP_UART_DEFAULT_PAD_NAME_LEN],
  116. tx_pad_name[OMAP_UART_DEFAULT_PAD_NAME_LEN] __initdata;
  117. static void __init
  118. omap_serial_fill_uart_tx_rx_pads(struct omap_board_data *bdata,
  119. struct omap_uart_state *uart)
  120. {
  121. uart->default_omap_uart_pads[0].name = rx_pad_name;
  122. uart->default_omap_uart_pads[0].flags = OMAP_DEVICE_PAD_REMUX |
  123. OMAP_DEVICE_PAD_WAKEUP;
  124. uart->default_omap_uart_pads[0].enable = OMAP_PIN_INPUT |
  125. OMAP_MUX_MODE0;
  126. uart->default_omap_uart_pads[0].idle = OMAP_PIN_INPUT | OMAP_MUX_MODE0;
  127. uart->default_omap_uart_pads[1].name = tx_pad_name;
  128. uart->default_omap_uart_pads[1].enable = OMAP_PIN_OUTPUT |
  129. OMAP_MUX_MODE0;
  130. bdata->pads = uart->default_omap_uart_pads;
  131. bdata->pads_cnt = ARRAY_SIZE(uart->default_omap_uart_pads);
  132. }
  133. static void __init omap_serial_check_wakeup(struct omap_board_data *bdata,
  134. struct omap_uart_state *uart)
  135. {
  136. struct omap_mux_partition *tx_partition = NULL, *rx_partition = NULL;
  137. struct omap_mux *rx_mux = NULL, *tx_mux = NULL;
  138. char *rx_fmt, *tx_fmt;
  139. int uart_nr = bdata->id + 1;
  140. if (bdata->id != 2) {
  141. rx_fmt = "uart%d_rx.uart%d_rx";
  142. tx_fmt = "uart%d_tx.uart%d_tx";
  143. } else {
  144. rx_fmt = "uart%d_rx_irrx.uart%d_rx_irrx";
  145. tx_fmt = "uart%d_tx_irtx.uart%d_tx_irtx";
  146. }
  147. snprintf(rx_pad_name, OMAP_UART_DEFAULT_PAD_NAME_LEN, rx_fmt,
  148. uart_nr, uart_nr);
  149. snprintf(tx_pad_name, OMAP_UART_DEFAULT_PAD_NAME_LEN, tx_fmt,
  150. uart_nr, uart_nr);
  151. if (omap_mux_get_by_name(rx_pad_name, &rx_partition, &rx_mux) >= 0 &&
  152. omap_mux_get_by_name
  153. (tx_pad_name, &tx_partition, &tx_mux) >= 0) {
  154. u16 tx_mode, rx_mode;
  155. tx_mode = omap_mux_read(tx_partition, tx_mux->reg_offset);
  156. rx_mode = omap_mux_read(rx_partition, rx_mux->reg_offset);
  157. /*
  158. * Check if uart is used in default tx/rx mode i.e. in mux mode0
  159. * if yes then configure rx pin for wake up capability
  160. */
  161. if (OMAP_MODE_UART(rx_mode) && OMAP_MODE_UART(tx_mode))
  162. omap_serial_fill_uart_tx_rx_pads(bdata, uart);
  163. }
  164. }
  165. #else
  166. static void __init omap_serial_check_wakeup(struct omap_board_data *bdata,
  167. struct omap_uart_state *uart)
  168. {
  169. }
  170. #endif
  171. static char *cmdline_find_option(char *str)
  172. {
  173. extern char *saved_command_line;
  174. return strstr(saved_command_line, str);
  175. }
  176. static int __init omap_serial_early_init(void)
  177. {
  178. do {
  179. char oh_name[MAX_UART_HWMOD_NAME_LEN];
  180. struct omap_hwmod *oh;
  181. struct omap_uart_state *uart;
  182. char uart_name[MAX_UART_HWMOD_NAME_LEN];
  183. snprintf(oh_name, MAX_UART_HWMOD_NAME_LEN,
  184. "uart%d", num_uarts + 1);
  185. oh = omap_hwmod_lookup(oh_name);
  186. if (!oh)
  187. break;
  188. uart = kzalloc(sizeof(struct omap_uart_state), GFP_KERNEL);
  189. if (WARN_ON(!uart))
  190. return -ENODEV;
  191. uart->oh = oh;
  192. uart->num = num_uarts++;
  193. list_add_tail(&uart->node, &uart_list);
  194. snprintf(uart_name, MAX_UART_HWMOD_NAME_LEN,
  195. "%s%d", OMAP_SERIAL_NAME, uart->num);
  196. if (cmdline_find_option(uart_name)) {
  197. console_uart_id = uart->num;
  198. if (console_loglevel >= 10) {
  199. uart_debug = true;
  200. pr_info("%s used as console in debug mode: uart%d clocks will not be gated",
  201. uart_name, uart->num);
  202. }
  203. if (cmdline_find_option("no_console_suspend"))
  204. no_console_suspend = true;
  205. /*
  206. * omap-uart can be used for earlyprintk logs
  207. * So if omap-uart is used as console then prevent
  208. * uart reset and idle to get logs from omap-uart
  209. * until uart console driver is available to take
  210. * care for console messages.
  211. * Idling or resetting omap-uart while printing logs
  212. * early boot logs can stall the boot-up.
  213. */
  214. oh->flags |= HWMOD_INIT_NO_IDLE | HWMOD_INIT_NO_RESET;
  215. }
  216. } while (1);
  217. return 0;
  218. }
  219. core_initcall(omap_serial_early_init);
  220. /**
  221. * omap_serial_init_port() - initialize single serial port
  222. * @bdata: port specific board data pointer
  223. * @info: platform specific data pointer
  224. *
  225. * This function initialies serial driver for given port only.
  226. * Platforms can call this function instead of omap_serial_init()
  227. * if they don't plan to use all available UARTs as serial ports.
  228. *
  229. * Don't mix calls to omap_serial_init_port() and omap_serial_init(),
  230. * use only one of the two.
  231. */
  232. void __init omap_serial_init_port(struct omap_board_data *bdata,
  233. struct omap_uart_port_info *info)
  234. {
  235. struct omap_uart_state *uart;
  236. struct omap_hwmod *oh;
  237. struct platform_device *pdev;
  238. void *pdata = NULL;
  239. u32 pdata_size = 0;
  240. char *name;
  241. struct omap_uart_port_info omap_up;
  242. if (WARN_ON(!bdata))
  243. return;
  244. if (WARN_ON(bdata->id < 0))
  245. return;
  246. if (WARN_ON(bdata->id >= num_uarts))
  247. return;
  248. list_for_each_entry(uart, &uart_list, node)
  249. if (bdata->id == uart->num)
  250. break;
  251. if (!info)
  252. info = omap_serial_default_info;
  253. oh = uart->oh;
  254. name = DRIVER_NAME;
  255. omap_up.dma_enabled = info->dma_enabled;
  256. omap_up.uartclk = OMAP24XX_BASE_BAUD * 16;
  257. omap_up.flags = UPF_BOOT_AUTOCONF;
  258. omap_up.get_context_loss_count = omap_pm_get_dev_context_loss_count;
  259. omap_up.set_forceidle = omap_uart_set_smartidle;
  260. omap_up.set_noidle = omap_uart_set_noidle;
  261. omap_up.enable_wakeup = omap_uart_enable_wakeup;
  262. omap_up.dma_rx_buf_size = info->dma_rx_buf_size;
  263. omap_up.dma_rx_timeout = info->dma_rx_timeout;
  264. omap_up.dma_rx_poll_rate = info->dma_rx_poll_rate;
  265. omap_up.autosuspend_timeout = info->autosuspend_timeout;
  266. omap_up.DTR_gpio = info->DTR_gpio;
  267. omap_up.DTR_inverted = info->DTR_inverted;
  268. omap_up.DTR_present = info->DTR_present;
  269. pdata = &omap_up;
  270. pdata_size = sizeof(struct omap_uart_port_info);
  271. if (WARN_ON(!oh))
  272. return;
  273. pdev = omap_device_build(name, uart->num, oh, pdata, pdata_size,
  274. NULL, 0, false);
  275. if (IS_ERR(pdev)) {
  276. WARN(1, "Could not build omap_device for %s: %s.\n", name,
  277. oh->name);
  278. return;
  279. }
  280. if ((console_uart_id == bdata->id) && no_console_suspend)
  281. omap_device_disable_idle_on_suspend(pdev);
  282. oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);
  283. oh->dev_attr = uart;
  284. if (((cpu_is_omap34xx() || cpu_is_omap44xx()) && bdata->pads)
  285. && !uart_debug)
  286. device_init_wakeup(&pdev->dev, true);
  287. }
  288. /**
  289. * omap_serial_board_init() - initialize all supported serial ports
  290. * @info: platform specific data pointer
  291. *
  292. * Initializes all available UARTs as serial ports. Platforms
  293. * can call this function when they want to have default behaviour
  294. * for serial ports (e.g initialize them all as serial ports).
  295. */
  296. void __init omap_serial_board_init(struct omap_uart_port_info *info)
  297. {
  298. struct omap_uart_state *uart;
  299. struct omap_board_data bdata;
  300. list_for_each_entry(uart, &uart_list, node) {
  301. bdata.id = uart->num;
  302. bdata.flags = 0;
  303. bdata.pads = NULL;
  304. bdata.pads_cnt = 0;
  305. omap_serial_check_wakeup(&bdata, uart);
  306. if (!info)
  307. omap_serial_init_port(&bdata, NULL);
  308. else
  309. omap_serial_init_port(&bdata, &info[uart->num]);
  310. }
  311. }
  312. /**
  313. * omap_serial_init() - initialize all supported serial ports
  314. *
  315. * Initializes all available UARTs.
  316. * Platforms can call this function when they want to have default behaviour
  317. * for serial ports (e.g initialize them all as serial ports).
  318. */
  319. void __init omap_serial_init(void)
  320. {
  321. omap_serial_board_init(NULL);
  322. }