19196d8acSJiri Slaby /* 29196d8acSJiri Slaby * Driver for 8250/16550-type serial ports 39196d8acSJiri Slaby * 49196d8acSJiri Slaby * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o. 59196d8acSJiri Slaby * 69196d8acSJiri Slaby * Copyright (C) 2001 Russell King. 79196d8acSJiri Slaby * 89196d8acSJiri Slaby * This program is free software; you can redistribute it and/or modify 99196d8acSJiri Slaby * it under the terms of the GNU General Public License as published by 109196d8acSJiri Slaby * the Free Software Foundation; either version 2 of the License, or 119196d8acSJiri Slaby * (at your option) any later version. 129196d8acSJiri Slaby * 139196d8acSJiri Slaby * A note about mapbase / membase 149196d8acSJiri Slaby * 159196d8acSJiri Slaby * mapbase is the physical address of the IO port. 169196d8acSJiri Slaby * membase is an 'ioremapped' cookie. 179196d8acSJiri Slaby */ 189196d8acSJiri Slaby 199196d8acSJiri Slaby #if defined(CONFIG_SERIAL_8250_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 209196d8acSJiri Slaby #define SUPPORT_SYSRQ 219196d8acSJiri Slaby #endif 229196d8acSJiri Slaby 239196d8acSJiri Slaby #include <linux/module.h> 249196d8acSJiri Slaby #include <linux/moduleparam.h> 259196d8acSJiri Slaby #include <linux/ioport.h> 269196d8acSJiri Slaby #include <linux/init.h> 279196d8acSJiri Slaby #include <linux/console.h> 289196d8acSJiri Slaby #include <linux/sysrq.h> 299196d8acSJiri Slaby #include <linux/delay.h> 309196d8acSJiri Slaby #include <linux/platform_device.h> 319196d8acSJiri Slaby #include <linux/tty.h> 329196d8acSJiri Slaby #include <linux/ratelimit.h> 339196d8acSJiri Slaby #include <linux/tty_flip.h> 349196d8acSJiri Slaby #include <linux/serial_core.h> 359196d8acSJiri Slaby #include <linux/serial.h> 369196d8acSJiri Slaby #include <linux/serial_8250.h> 379196d8acSJiri Slaby #include <linux/nmi.h> 389196d8acSJiri Slaby #include <linux/mutex.h> 399196d8acSJiri Slaby #include <linux/slab.h> 400b4af1d9SRicardo Ribalda Delgado #include <linux/uaccess.h> 41d74d5d1bSSebastian Andrzej Siewior #include <linux/pm_runtime.h> 429196d8acSJiri Slaby #ifdef CONFIG_SPARC 439196d8acSJiri Slaby #include <linux/sunserialcore.h> 449196d8acSJiri Slaby #endif 459196d8acSJiri Slaby 469196d8acSJiri Slaby #include <asm/io.h> 479196d8acSJiri Slaby #include <asm/irq.h> 489196d8acSJiri Slaby 499196d8acSJiri Slaby #include "8250.h" 509196d8acSJiri Slaby 519196d8acSJiri Slaby /* 529196d8acSJiri Slaby * Configuration: 539196d8acSJiri Slaby * share_irqs - whether we pass IRQF_SHARED to request_irq(). This option 549196d8acSJiri Slaby * is unsafe when used on edge-triggered interrupts. 559196d8acSJiri Slaby */ 569196d8acSJiri Slaby static unsigned int share_irqs = SERIAL8250_SHARE_IRQS; 579196d8acSJiri Slaby 589196d8acSJiri Slaby static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS; 599196d8acSJiri Slaby 609196d8acSJiri Slaby static struct uart_driver serial8250_reg; 619196d8acSJiri Slaby 629196d8acSJiri Slaby static int serial_index(struct uart_port *port) 639196d8acSJiri Slaby { 6451c39814SPeter Hurley return port->minor - 64; 659196d8acSJiri Slaby } 669196d8acSJiri Slaby 679196d8acSJiri Slaby static unsigned int skip_txen_test; /* force skip of txen test at init time */ 689196d8acSJiri Slaby 699196d8acSJiri Slaby /* 709196d8acSJiri Slaby * Debugging. 719196d8acSJiri Slaby */ 729196d8acSJiri Slaby #if 0 739196d8acSJiri Slaby #define DEBUG_AUTOCONF(fmt...) printk(fmt) 749196d8acSJiri Slaby #else 759196d8acSJiri Slaby #define DEBUG_AUTOCONF(fmt...) do { } while (0) 769196d8acSJiri Slaby #endif 779196d8acSJiri Slaby 789196d8acSJiri Slaby #if 0 799196d8acSJiri Slaby #define DEBUG_INTR(fmt...) printk(fmt) 809196d8acSJiri Slaby #else 819196d8acSJiri Slaby #define DEBUG_INTR(fmt...) do { } while (0) 829196d8acSJiri Slaby #endif 839196d8acSJiri Slaby 849196d8acSJiri Slaby #define PASS_LIMIT 512 859196d8acSJiri Slaby 869196d8acSJiri Slaby #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE) 879196d8acSJiri Slaby 889196d8acSJiri Slaby 899196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_DETECT_IRQ 909196d8acSJiri Slaby #define CONFIG_SERIAL_DETECT_IRQ 1 919196d8acSJiri Slaby #endif 929196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_MANY_PORTS 939196d8acSJiri Slaby #define CONFIG_SERIAL_MANY_PORTS 1 949196d8acSJiri Slaby #endif 959196d8acSJiri Slaby 969196d8acSJiri Slaby /* 979196d8acSJiri Slaby * HUB6 is always on. This will be removed once the header 989196d8acSJiri Slaby * files have been cleaned. 999196d8acSJiri Slaby */ 1009196d8acSJiri Slaby #define CONFIG_HUB6 1 1019196d8acSJiri Slaby 1029196d8acSJiri Slaby #include <asm/serial.h> 1039196d8acSJiri Slaby /* 1049196d8acSJiri Slaby * SERIAL_PORT_DFNS tells us about built-in ports that have no 1059196d8acSJiri Slaby * standard enumeration mechanism. Platforms that can find all 1069196d8acSJiri Slaby * serial ports via mechanisms like ACPI or PCI need not supply it. 1079196d8acSJiri Slaby */ 1089196d8acSJiri Slaby #ifndef SERIAL_PORT_DFNS 1099196d8acSJiri Slaby #define SERIAL_PORT_DFNS 1109196d8acSJiri Slaby #endif 1119196d8acSJiri Slaby 1129196d8acSJiri Slaby static const struct old_serial_port old_serial_port[] = { 1139196d8acSJiri Slaby SERIAL_PORT_DFNS /* defined in asm/serial.h */ 1149196d8acSJiri Slaby }; 1159196d8acSJiri Slaby 1169196d8acSJiri Slaby #define UART_NR CONFIG_SERIAL_8250_NR_UARTS 1179196d8acSJiri Slaby 1189196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 1199196d8acSJiri Slaby 1209196d8acSJiri Slaby #define PORT_RSA_MAX 4 1219196d8acSJiri Slaby static unsigned long probe_rsa[PORT_RSA_MAX]; 1229196d8acSJiri Slaby static unsigned int probe_rsa_count; 1239196d8acSJiri Slaby #endif /* CONFIG_SERIAL_8250_RSA */ 1249196d8acSJiri Slaby 1259196d8acSJiri Slaby struct irq_info { 1269196d8acSJiri Slaby struct hlist_node node; 1279196d8acSJiri Slaby int irq; 1289196d8acSJiri Slaby spinlock_t lock; /* Protects list not the hash */ 1299196d8acSJiri Slaby struct list_head *head; 1309196d8acSJiri Slaby }; 1319196d8acSJiri Slaby 1329196d8acSJiri Slaby #define NR_IRQ_HASH 32 /* Can be adjusted later */ 1339196d8acSJiri Slaby static struct hlist_head irq_lists[NR_IRQ_HASH]; 1349196d8acSJiri Slaby static DEFINE_MUTEX(hash_mutex); /* Used to walk the hash */ 1359196d8acSJiri Slaby 1369196d8acSJiri Slaby /* 1379196d8acSJiri Slaby * Here we define the default xmit fifo size used for each type of UART. 1389196d8acSJiri Slaby */ 1399196d8acSJiri Slaby static const struct serial8250_config uart_config[] = { 1409196d8acSJiri Slaby [PORT_UNKNOWN] = { 1419196d8acSJiri Slaby .name = "unknown", 1429196d8acSJiri Slaby .fifo_size = 1, 1439196d8acSJiri Slaby .tx_loadsz = 1, 1449196d8acSJiri Slaby }, 1459196d8acSJiri Slaby [PORT_8250] = { 1469196d8acSJiri Slaby .name = "8250", 1479196d8acSJiri Slaby .fifo_size = 1, 1489196d8acSJiri Slaby .tx_loadsz = 1, 1499196d8acSJiri Slaby }, 1509196d8acSJiri Slaby [PORT_16450] = { 1519196d8acSJiri Slaby .name = "16450", 1529196d8acSJiri Slaby .fifo_size = 1, 1539196d8acSJiri Slaby .tx_loadsz = 1, 1549196d8acSJiri Slaby }, 1559196d8acSJiri Slaby [PORT_16550] = { 1569196d8acSJiri Slaby .name = "16550", 1579196d8acSJiri Slaby .fifo_size = 1, 1589196d8acSJiri Slaby .tx_loadsz = 1, 1599196d8acSJiri Slaby }, 1609196d8acSJiri Slaby [PORT_16550A] = { 1619196d8acSJiri Slaby .name = "16550A", 1629196d8acSJiri Slaby .fifo_size = 16, 1639196d8acSJiri Slaby .tx_loadsz = 16, 1649196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 165aef9a7bdSYoshihiro YUNOMAE .rxtrig_bytes = {1, 4, 8, 14}, 1669196d8acSJiri Slaby .flags = UART_CAP_FIFO, 1679196d8acSJiri Slaby }, 1689196d8acSJiri Slaby [PORT_CIRRUS] = { 1699196d8acSJiri Slaby .name = "Cirrus", 1709196d8acSJiri Slaby .fifo_size = 1, 1719196d8acSJiri Slaby .tx_loadsz = 1, 1729196d8acSJiri Slaby }, 1739196d8acSJiri Slaby [PORT_16650] = { 1749196d8acSJiri Slaby .name = "ST16650", 1759196d8acSJiri Slaby .fifo_size = 1, 1769196d8acSJiri Slaby .tx_loadsz = 1, 1779196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP, 1789196d8acSJiri Slaby }, 1799196d8acSJiri Slaby [PORT_16650V2] = { 1809196d8acSJiri Slaby .name = "ST16650V2", 1819196d8acSJiri Slaby .fifo_size = 32, 1829196d8acSJiri Slaby .tx_loadsz = 16, 1839196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 | 1849196d8acSJiri Slaby UART_FCR_T_TRIG_00, 185aef9a7bdSYoshihiro YUNOMAE .rxtrig_bytes = {8, 16, 24, 28}, 1869196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP, 1879196d8acSJiri Slaby }, 1889196d8acSJiri Slaby [PORT_16750] = { 1899196d8acSJiri Slaby .name = "TI16750", 1909196d8acSJiri Slaby .fifo_size = 64, 1919196d8acSJiri Slaby .tx_loadsz = 64, 1929196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 | 1939196d8acSJiri Slaby UART_FCR7_64BYTE, 194aef9a7bdSYoshihiro YUNOMAE .rxtrig_bytes = {1, 16, 32, 56}, 1959196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE, 1969196d8acSJiri Slaby }, 1979196d8acSJiri Slaby [PORT_STARTECH] = { 1989196d8acSJiri Slaby .name = "Startech", 1999196d8acSJiri Slaby .fifo_size = 1, 2009196d8acSJiri Slaby .tx_loadsz = 1, 2019196d8acSJiri Slaby }, 2029196d8acSJiri Slaby [PORT_16C950] = { 2039196d8acSJiri Slaby .name = "16C950/954", 2049196d8acSJiri Slaby .fifo_size = 128, 2059196d8acSJiri Slaby .tx_loadsz = 128, 2069196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2079196d8acSJiri Slaby /* UART_CAP_EFR breaks billionon CF bluetooth card. */ 2089196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_SLEEP, 2099196d8acSJiri Slaby }, 2109196d8acSJiri Slaby [PORT_16654] = { 2119196d8acSJiri Slaby .name = "ST16654", 2129196d8acSJiri Slaby .fifo_size = 64, 2139196d8acSJiri Slaby .tx_loadsz = 32, 2149196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 | 2159196d8acSJiri Slaby UART_FCR_T_TRIG_10, 216aef9a7bdSYoshihiro YUNOMAE .rxtrig_bytes = {8, 16, 56, 60}, 2179196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP, 2189196d8acSJiri Slaby }, 2199196d8acSJiri Slaby [PORT_16850] = { 2209196d8acSJiri Slaby .name = "XR16850", 2219196d8acSJiri Slaby .fifo_size = 128, 2229196d8acSJiri Slaby .tx_loadsz = 128, 2239196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2249196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP, 2259196d8acSJiri Slaby }, 2269196d8acSJiri Slaby [PORT_RSA] = { 2279196d8acSJiri Slaby .name = "RSA", 2289196d8acSJiri Slaby .fifo_size = 2048, 2299196d8acSJiri Slaby .tx_loadsz = 2048, 2309196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11, 2319196d8acSJiri Slaby .flags = UART_CAP_FIFO, 2329196d8acSJiri Slaby }, 2339196d8acSJiri Slaby [PORT_NS16550A] = { 2349196d8acSJiri Slaby .name = "NS16550A", 2359196d8acSJiri Slaby .fifo_size = 16, 2369196d8acSJiri Slaby .tx_loadsz = 16, 2379196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2389196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_NATSEMI, 2399196d8acSJiri Slaby }, 2409196d8acSJiri Slaby [PORT_XSCALE] = { 2419196d8acSJiri Slaby .name = "XScale", 2429196d8acSJiri Slaby .fifo_size = 32, 2439196d8acSJiri Slaby .tx_loadsz = 32, 2449196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2459196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE, 2469196d8acSJiri Slaby }, 2479196d8acSJiri Slaby [PORT_OCTEON] = { 2489196d8acSJiri Slaby .name = "OCTEON", 2499196d8acSJiri Slaby .fifo_size = 64, 2509196d8acSJiri Slaby .tx_loadsz = 64, 2519196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2529196d8acSJiri Slaby .flags = UART_CAP_FIFO, 2539196d8acSJiri Slaby }, 2549196d8acSJiri Slaby [PORT_AR7] = { 2559196d8acSJiri Slaby .name = "AR7", 2569196d8acSJiri Slaby .fifo_size = 16, 2579196d8acSJiri Slaby .tx_loadsz = 16, 2589196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00, 2599196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE, 2609196d8acSJiri Slaby }, 2619196d8acSJiri Slaby [PORT_U6_16550A] = { 2629196d8acSJiri Slaby .name = "U6_16550A", 2639196d8acSJiri Slaby .fifo_size = 64, 2649196d8acSJiri Slaby .tx_loadsz = 64, 2659196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2669196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE, 2679196d8acSJiri Slaby }, 2689196d8acSJiri Slaby [PORT_TEGRA] = { 2699196d8acSJiri Slaby .name = "Tegra", 2709196d8acSJiri Slaby .fifo_size = 32, 2719196d8acSJiri Slaby .tx_loadsz = 8, 2729196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 | 2739196d8acSJiri Slaby UART_FCR_T_TRIG_01, 274aef9a7bdSYoshihiro YUNOMAE .rxtrig_bytes = {1, 4, 8, 14}, 2759196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_RTOIE, 2769196d8acSJiri Slaby }, 2779196d8acSJiri Slaby [PORT_XR17D15X] = { 2789196d8acSJiri Slaby .name = "XR17D15X", 2799196d8acSJiri Slaby .fifo_size = 64, 2809196d8acSJiri Slaby .tx_loadsz = 64, 2819196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 2829196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR | 2839196d8acSJiri Slaby UART_CAP_SLEEP, 2849196d8acSJiri Slaby }, 2859196d8acSJiri Slaby [PORT_XR17V35X] = { 2869196d8acSJiri Slaby .name = "XR17V35X", 2879196d8acSJiri Slaby .fifo_size = 256, 2889196d8acSJiri Slaby .tx_loadsz = 256, 2899196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11 | 2909196d8acSJiri Slaby UART_FCR_T_TRIG_11, 2919196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR | 2929196d8acSJiri Slaby UART_CAP_SLEEP, 2939196d8acSJiri Slaby }, 2949196d8acSJiri Slaby [PORT_LPC3220] = { 2959196d8acSJiri Slaby .name = "LPC3220", 2969196d8acSJiri Slaby .fifo_size = 64, 2979196d8acSJiri Slaby .tx_loadsz = 32, 2989196d8acSJiri Slaby .fcr = UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO | 2999196d8acSJiri Slaby UART_FCR_R_TRIG_00 | UART_FCR_T_TRIG_00, 3009196d8acSJiri Slaby .flags = UART_CAP_FIFO, 3019196d8acSJiri Slaby }, 3029196d8acSJiri Slaby [PORT_BRCM_TRUMANAGE] = { 3039196d8acSJiri Slaby .name = "TruManage", 3049196d8acSJiri Slaby .fifo_size = 1, 3059196d8acSJiri Slaby .tx_loadsz = 1024, 3069196d8acSJiri Slaby .flags = UART_CAP_HFIFO, 3079196d8acSJiri Slaby }, 3089196d8acSJiri Slaby [PORT_8250_CIR] = { 3099196d8acSJiri Slaby .name = "CIR port" 3109196d8acSJiri Slaby }, 3119196d8acSJiri Slaby [PORT_ALTR_16550_F32] = { 3129196d8acSJiri Slaby .name = "Altera 16550 FIFO32", 3139196d8acSJiri Slaby .fifo_size = 32, 3149196d8acSJiri Slaby .tx_loadsz = 32, 3159196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 3169196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE, 3179196d8acSJiri Slaby }, 3189196d8acSJiri Slaby [PORT_ALTR_16550_F64] = { 3199196d8acSJiri Slaby .name = "Altera 16550 FIFO64", 3209196d8acSJiri Slaby .fifo_size = 64, 3219196d8acSJiri Slaby .tx_loadsz = 64, 3229196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 3239196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE, 3249196d8acSJiri Slaby }, 3259196d8acSJiri Slaby [PORT_ALTR_16550_F128] = { 3269196d8acSJiri Slaby .name = "Altera 16550 FIFO128", 3279196d8acSJiri Slaby .fifo_size = 128, 3289196d8acSJiri Slaby .tx_loadsz = 128, 3299196d8acSJiri Slaby .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10, 3309196d8acSJiri Slaby .flags = UART_CAP_FIFO | UART_CAP_AFE, 3319196d8acSJiri Slaby }, 332fddceb8bSVijay Rai /* tx_loadsz is set to 63-bytes instead of 64-bytes to implement 333fddceb8bSVijay Rai workaround of errata A-008006 which states that tx_loadsz should be 334fddceb8bSVijay Rai configured less than Maximum supported fifo bytes */ 335fddceb8bSVijay Rai [PORT_16550A_FSL64] = { 336fddceb8bSVijay Rai .name = "16550A_FSL64", 337fddceb8bSVijay Rai .fifo_size = 64, 338fddceb8bSVijay Rai .tx_loadsz = 63, 339fddceb8bSVijay Rai .fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 | 340fddceb8bSVijay Rai UART_FCR7_64BYTE, 341fddceb8bSVijay Rai .flags = UART_CAP_FIFO, 342fddceb8bSVijay Rai }, 3439196d8acSJiri Slaby }; 3449196d8acSJiri Slaby 3459196d8acSJiri Slaby /* Uart divisor latch read */ 3469196d8acSJiri Slaby static int default_serial_dl_read(struct uart_8250_port *up) 3479196d8acSJiri Slaby { 3489196d8acSJiri Slaby return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8; 3499196d8acSJiri Slaby } 3509196d8acSJiri Slaby 3519196d8acSJiri Slaby /* Uart divisor latch write */ 3529196d8acSJiri Slaby static void default_serial_dl_write(struct uart_8250_port *up, int value) 3539196d8acSJiri Slaby { 3549196d8acSJiri Slaby serial_out(up, UART_DLL, value & 0xff); 3559196d8acSJiri Slaby serial_out(up, UART_DLM, value >> 8 & 0xff); 3569196d8acSJiri Slaby } 3579196d8acSJiri Slaby 3589196d8acSJiri Slaby #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X) 3599196d8acSJiri Slaby 3609196d8acSJiri Slaby /* Au1x00/RT288x UART hardware has a weird register layout */ 3619196d8acSJiri Slaby static const u8 au_io_in_map[] = { 3629196d8acSJiri Slaby [UART_RX] = 0, 3639196d8acSJiri Slaby [UART_IER] = 2, 3649196d8acSJiri Slaby [UART_IIR] = 3, 3659196d8acSJiri Slaby [UART_LCR] = 5, 3669196d8acSJiri Slaby [UART_MCR] = 6, 3679196d8acSJiri Slaby [UART_LSR] = 7, 3689196d8acSJiri Slaby [UART_MSR] = 8, 3699196d8acSJiri Slaby }; 3709196d8acSJiri Slaby 3719196d8acSJiri Slaby static const u8 au_io_out_map[] = { 3729196d8acSJiri Slaby [UART_TX] = 1, 3739196d8acSJiri Slaby [UART_IER] = 2, 3749196d8acSJiri Slaby [UART_FCR] = 4, 3759196d8acSJiri Slaby [UART_LCR] = 5, 3769196d8acSJiri Slaby [UART_MCR] = 6, 3779196d8acSJiri Slaby }; 3789196d8acSJiri Slaby 3799196d8acSJiri Slaby static unsigned int au_serial_in(struct uart_port *p, int offset) 3809196d8acSJiri Slaby { 3819196d8acSJiri Slaby offset = au_io_in_map[offset] << p->regshift; 3829196d8acSJiri Slaby return __raw_readl(p->membase + offset); 3839196d8acSJiri Slaby } 3849196d8acSJiri Slaby 3859196d8acSJiri Slaby static void au_serial_out(struct uart_port *p, int offset, int value) 3869196d8acSJiri Slaby { 3879196d8acSJiri Slaby offset = au_io_out_map[offset] << p->regshift; 3889196d8acSJiri Slaby __raw_writel(value, p->membase + offset); 3899196d8acSJiri Slaby } 3909196d8acSJiri Slaby 3919196d8acSJiri Slaby /* Au1x00 haven't got a standard divisor latch */ 3929196d8acSJiri Slaby static int au_serial_dl_read(struct uart_8250_port *up) 3939196d8acSJiri Slaby { 3949196d8acSJiri Slaby return __raw_readl(up->port.membase + 0x28); 3959196d8acSJiri Slaby } 3969196d8acSJiri Slaby 3979196d8acSJiri Slaby static void au_serial_dl_write(struct uart_8250_port *up, int value) 3989196d8acSJiri Slaby { 3999196d8acSJiri Slaby __raw_writel(value, up->port.membase + 0x28); 4009196d8acSJiri Slaby } 4019196d8acSJiri Slaby 4029196d8acSJiri Slaby #endif 4039196d8acSJiri Slaby 4049196d8acSJiri Slaby static unsigned int hub6_serial_in(struct uart_port *p, int offset) 4059196d8acSJiri Slaby { 4069196d8acSJiri Slaby offset = offset << p->regshift; 4079196d8acSJiri Slaby outb(p->hub6 - 1 + offset, p->iobase); 4089196d8acSJiri Slaby return inb(p->iobase + 1); 4099196d8acSJiri Slaby } 4109196d8acSJiri Slaby 4119196d8acSJiri Slaby static void hub6_serial_out(struct uart_port *p, int offset, int value) 4129196d8acSJiri Slaby { 4139196d8acSJiri Slaby offset = offset << p->regshift; 4149196d8acSJiri Slaby outb(p->hub6 - 1 + offset, p->iobase); 4159196d8acSJiri Slaby outb(value, p->iobase + 1); 4169196d8acSJiri Slaby } 4179196d8acSJiri Slaby 4189196d8acSJiri Slaby static unsigned int mem_serial_in(struct uart_port *p, int offset) 4199196d8acSJiri Slaby { 4209196d8acSJiri Slaby offset = offset << p->regshift; 4219196d8acSJiri Slaby return readb(p->membase + offset); 4229196d8acSJiri Slaby } 4239196d8acSJiri Slaby 4249196d8acSJiri Slaby static void mem_serial_out(struct uart_port *p, int offset, int value) 4259196d8acSJiri Slaby { 4269196d8acSJiri Slaby offset = offset << p->regshift; 4279196d8acSJiri Slaby writeb(value, p->membase + offset); 4289196d8acSJiri Slaby } 4299196d8acSJiri Slaby 4309196d8acSJiri Slaby static void mem32_serial_out(struct uart_port *p, int offset, int value) 4319196d8acSJiri Slaby { 4329196d8acSJiri Slaby offset = offset << p->regshift; 4339196d8acSJiri Slaby writel(value, p->membase + offset); 4349196d8acSJiri Slaby } 4359196d8acSJiri Slaby 4369196d8acSJiri Slaby static unsigned int mem32_serial_in(struct uart_port *p, int offset) 4379196d8acSJiri Slaby { 4389196d8acSJiri Slaby offset = offset << p->regshift; 4399196d8acSJiri Slaby return readl(p->membase + offset); 4409196d8acSJiri Slaby } 4419196d8acSJiri Slaby 4429196d8acSJiri Slaby static unsigned int io_serial_in(struct uart_port *p, int offset) 4439196d8acSJiri Slaby { 4449196d8acSJiri Slaby offset = offset << p->regshift; 4459196d8acSJiri Slaby return inb(p->iobase + offset); 4469196d8acSJiri Slaby } 4479196d8acSJiri Slaby 4489196d8acSJiri Slaby static void io_serial_out(struct uart_port *p, int offset, int value) 4499196d8acSJiri Slaby { 4509196d8acSJiri Slaby offset = offset << p->regshift; 4519196d8acSJiri Slaby outb(value, p->iobase + offset); 4529196d8acSJiri Slaby } 4539196d8acSJiri Slaby 4549196d8acSJiri Slaby static int serial8250_default_handle_irq(struct uart_port *port); 4559196d8acSJiri Slaby static int exar_handle_irq(struct uart_port *port); 4569196d8acSJiri Slaby 4579196d8acSJiri Slaby static void set_io_from_upio(struct uart_port *p) 4589196d8acSJiri Slaby { 459b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(p); 4609196d8acSJiri Slaby 4619196d8acSJiri Slaby up->dl_read = default_serial_dl_read; 4629196d8acSJiri Slaby up->dl_write = default_serial_dl_write; 4639196d8acSJiri Slaby 4649196d8acSJiri Slaby switch (p->iotype) { 4659196d8acSJiri Slaby case UPIO_HUB6: 4669196d8acSJiri Slaby p->serial_in = hub6_serial_in; 4679196d8acSJiri Slaby p->serial_out = hub6_serial_out; 4689196d8acSJiri Slaby break; 4699196d8acSJiri Slaby 4709196d8acSJiri Slaby case UPIO_MEM: 4719196d8acSJiri Slaby p->serial_in = mem_serial_in; 4729196d8acSJiri Slaby p->serial_out = mem_serial_out; 4739196d8acSJiri Slaby break; 4749196d8acSJiri Slaby 4759196d8acSJiri Slaby case UPIO_MEM32: 4769196d8acSJiri Slaby p->serial_in = mem32_serial_in; 4779196d8acSJiri Slaby p->serial_out = mem32_serial_out; 4789196d8acSJiri Slaby break; 4799196d8acSJiri Slaby 4809196d8acSJiri Slaby #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X) 4819196d8acSJiri Slaby case UPIO_AU: 4829196d8acSJiri Slaby p->serial_in = au_serial_in; 4839196d8acSJiri Slaby p->serial_out = au_serial_out; 4849196d8acSJiri Slaby up->dl_read = au_serial_dl_read; 4859196d8acSJiri Slaby up->dl_write = au_serial_dl_write; 4869196d8acSJiri Slaby break; 4879196d8acSJiri Slaby #endif 4889196d8acSJiri Slaby 4899196d8acSJiri Slaby default: 4909196d8acSJiri Slaby p->serial_in = io_serial_in; 4919196d8acSJiri Slaby p->serial_out = io_serial_out; 4929196d8acSJiri Slaby break; 4939196d8acSJiri Slaby } 4949196d8acSJiri Slaby /* Remember loaded iotype */ 4959196d8acSJiri Slaby up->cur_iotype = p->iotype; 4969196d8acSJiri Slaby p->handle_irq = serial8250_default_handle_irq; 4979196d8acSJiri Slaby } 4989196d8acSJiri Slaby 4999196d8acSJiri Slaby static void 5009196d8acSJiri Slaby serial_port_out_sync(struct uart_port *p, int offset, int value) 5019196d8acSJiri Slaby { 5029196d8acSJiri Slaby switch (p->iotype) { 5039196d8acSJiri Slaby case UPIO_MEM: 5049196d8acSJiri Slaby case UPIO_MEM32: 5059196d8acSJiri Slaby case UPIO_AU: 5069196d8acSJiri Slaby p->serial_out(p, offset, value); 5079196d8acSJiri Slaby p->serial_in(p, UART_LCR); /* safe, no side-effects */ 5089196d8acSJiri Slaby break; 5099196d8acSJiri Slaby default: 5109196d8acSJiri Slaby p->serial_out(p, offset, value); 5119196d8acSJiri Slaby } 5129196d8acSJiri Slaby } 5139196d8acSJiri Slaby 5149196d8acSJiri Slaby /* 5159196d8acSJiri Slaby * For the 16C950 5169196d8acSJiri Slaby */ 5179196d8acSJiri Slaby static void serial_icr_write(struct uart_8250_port *up, int offset, int value) 5189196d8acSJiri Slaby { 5199196d8acSJiri Slaby serial_out(up, UART_SCR, offset); 5209196d8acSJiri Slaby serial_out(up, UART_ICR, value); 5219196d8acSJiri Slaby } 5229196d8acSJiri Slaby 5239196d8acSJiri Slaby static unsigned int serial_icr_read(struct uart_8250_port *up, int offset) 5249196d8acSJiri Slaby { 5259196d8acSJiri Slaby unsigned int value; 5269196d8acSJiri Slaby 5279196d8acSJiri Slaby serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD); 5289196d8acSJiri Slaby serial_out(up, UART_SCR, offset); 5299196d8acSJiri Slaby value = serial_in(up, UART_ICR); 5309196d8acSJiri Slaby serial_icr_write(up, UART_ACR, up->acr); 5319196d8acSJiri Slaby 5329196d8acSJiri Slaby return value; 5339196d8acSJiri Slaby } 5349196d8acSJiri Slaby 5359196d8acSJiri Slaby /* 5369196d8acSJiri Slaby * FIFO support. 5379196d8acSJiri Slaby */ 5389196d8acSJiri Slaby static void serial8250_clear_fifos(struct uart_8250_port *p) 5399196d8acSJiri Slaby { 5409196d8acSJiri Slaby if (p->capabilities & UART_CAP_FIFO) { 5419196d8acSJiri Slaby serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO); 5429196d8acSJiri Slaby serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO | 5439196d8acSJiri Slaby UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT); 5449196d8acSJiri Slaby serial_out(p, UART_FCR, 0); 5459196d8acSJiri Slaby } 5469196d8acSJiri Slaby } 5479196d8acSJiri Slaby 5489196d8acSJiri Slaby void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p) 5499196d8acSJiri Slaby { 5509196d8acSJiri Slaby serial8250_clear_fifos(p); 551aef9a7bdSYoshihiro YUNOMAE serial_out(p, UART_FCR, p->fcr); 5529196d8acSJiri Slaby } 5539196d8acSJiri Slaby EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos); 5549196d8acSJiri Slaby 55577285243SSebastian Andrzej Siewior void serial8250_rpm_get(struct uart_8250_port *p) 556d74d5d1bSSebastian Andrzej Siewior { 557d74d5d1bSSebastian Andrzej Siewior if (!(p->capabilities & UART_CAP_RPM)) 558d74d5d1bSSebastian Andrzej Siewior return; 559d74d5d1bSSebastian Andrzej Siewior pm_runtime_get_sync(p->port.dev); 560d74d5d1bSSebastian Andrzej Siewior } 56177285243SSebastian Andrzej Siewior EXPORT_SYMBOL_GPL(serial8250_rpm_get); 562d74d5d1bSSebastian Andrzej Siewior 56377285243SSebastian Andrzej Siewior void serial8250_rpm_put(struct uart_8250_port *p) 564d74d5d1bSSebastian Andrzej Siewior { 565d74d5d1bSSebastian Andrzej Siewior if (!(p->capabilities & UART_CAP_RPM)) 566d74d5d1bSSebastian Andrzej Siewior return; 567d74d5d1bSSebastian Andrzej Siewior pm_runtime_mark_last_busy(p->port.dev); 568d74d5d1bSSebastian Andrzej Siewior pm_runtime_put_autosuspend(p->port.dev); 569d74d5d1bSSebastian Andrzej Siewior } 57077285243SSebastian Andrzej Siewior EXPORT_SYMBOL_GPL(serial8250_rpm_put); 571d74d5d1bSSebastian Andrzej Siewior 572d74d5d1bSSebastian Andrzej Siewior /* 5736a529abaSSebastian Andrzej Siewior * These two wrappers ensure that enable_runtime_pm_tx() can be called more than 574d74d5d1bSSebastian Andrzej Siewior * once and disable_runtime_pm_tx() will still disable RPM because the fifo is 575d74d5d1bSSebastian Andrzej Siewior * empty and the HW can idle again. 576d74d5d1bSSebastian Andrzej Siewior */ 577d74d5d1bSSebastian Andrzej Siewior static void serial8250_rpm_get_tx(struct uart_8250_port *p) 578d74d5d1bSSebastian Andrzej Siewior { 579d74d5d1bSSebastian Andrzej Siewior unsigned char rpm_active; 580d74d5d1bSSebastian Andrzej Siewior 581d74d5d1bSSebastian Andrzej Siewior if (!(p->capabilities & UART_CAP_RPM)) 582d74d5d1bSSebastian Andrzej Siewior return; 583d74d5d1bSSebastian Andrzej Siewior 584d74d5d1bSSebastian Andrzej Siewior rpm_active = xchg(&p->rpm_tx_active, 1); 585d74d5d1bSSebastian Andrzej Siewior if (rpm_active) 586d74d5d1bSSebastian Andrzej Siewior return; 587d74d5d1bSSebastian Andrzej Siewior pm_runtime_get_sync(p->port.dev); 588d74d5d1bSSebastian Andrzej Siewior } 589d74d5d1bSSebastian Andrzej Siewior 590d74d5d1bSSebastian Andrzej Siewior static void serial8250_rpm_put_tx(struct uart_8250_port *p) 591d74d5d1bSSebastian Andrzej Siewior { 592d74d5d1bSSebastian Andrzej Siewior unsigned char rpm_active; 593d74d5d1bSSebastian Andrzej Siewior 594d74d5d1bSSebastian Andrzej Siewior if (!(p->capabilities & UART_CAP_RPM)) 595d74d5d1bSSebastian Andrzej Siewior return; 596d74d5d1bSSebastian Andrzej Siewior 597d74d5d1bSSebastian Andrzej Siewior rpm_active = xchg(&p->rpm_tx_active, 0); 598d74d5d1bSSebastian Andrzej Siewior if (!rpm_active) 599d74d5d1bSSebastian Andrzej Siewior return; 600d74d5d1bSSebastian Andrzej Siewior pm_runtime_mark_last_busy(p->port.dev); 601d74d5d1bSSebastian Andrzej Siewior pm_runtime_put_autosuspend(p->port.dev); 602d74d5d1bSSebastian Andrzej Siewior } 603d74d5d1bSSebastian Andrzej Siewior 6049196d8acSJiri Slaby /* 6059196d8acSJiri Slaby * IER sleep support. UARTs which have EFRs need the "extended 6069196d8acSJiri Slaby * capability" bit enabled. Note that on XR16C850s, we need to 6079196d8acSJiri Slaby * reset LCR to write to IER. 6089196d8acSJiri Slaby */ 6099196d8acSJiri Slaby static void serial8250_set_sleep(struct uart_8250_port *p, int sleep) 6109196d8acSJiri Slaby { 611edf4edacSSudhir Sreedharan unsigned char lcr = 0, efr = 0; 6129196d8acSJiri Slaby /* 6139196d8acSJiri Slaby * Exar UARTs have a SLEEP register that enables or disables 6149196d8acSJiri Slaby * each UART to enter sleep mode separately. On the XR17V35x the 6159196d8acSJiri Slaby * register is accessible to each UART at the UART_EXAR_SLEEP 6169196d8acSJiri Slaby * offset but the UART channel may only write to the corresponding 6179196d8acSJiri Slaby * bit. 6189196d8acSJiri Slaby */ 619d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(p); 6209196d8acSJiri Slaby if ((p->port.type == PORT_XR17V35X) || 6219196d8acSJiri Slaby (p->port.type == PORT_XR17D15X)) { 622b790f210SMichael Welling serial_out(p, UART_EXAR_SLEEP, sleep ? 0xff : 0); 623d74d5d1bSSebastian Andrzej Siewior goto out; 6249196d8acSJiri Slaby } 6259196d8acSJiri Slaby 6269196d8acSJiri Slaby if (p->capabilities & UART_CAP_SLEEP) { 6279196d8acSJiri Slaby if (p->capabilities & UART_CAP_EFR) { 628edf4edacSSudhir Sreedharan lcr = serial_in(p, UART_LCR); 629edf4edacSSudhir Sreedharan efr = serial_in(p, UART_EFR); 6309196d8acSJiri Slaby serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B); 6319196d8acSJiri Slaby serial_out(p, UART_EFR, UART_EFR_ECB); 6329196d8acSJiri Slaby serial_out(p, UART_LCR, 0); 6339196d8acSJiri Slaby } 6349196d8acSJiri Slaby serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0); 6359196d8acSJiri Slaby if (p->capabilities & UART_CAP_EFR) { 6369196d8acSJiri Slaby serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B); 637edf4edacSSudhir Sreedharan serial_out(p, UART_EFR, efr); 638edf4edacSSudhir Sreedharan serial_out(p, UART_LCR, lcr); 6399196d8acSJiri Slaby } 6409196d8acSJiri Slaby } 641d74d5d1bSSebastian Andrzej Siewior out: 642d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(p); 6439196d8acSJiri Slaby } 6449196d8acSJiri Slaby 6459196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 6469196d8acSJiri Slaby /* 6479196d8acSJiri Slaby * Attempts to turn on the RSA FIFO. Returns zero on failure. 6489196d8acSJiri Slaby * We set the port uart clock rate if we succeed. 6499196d8acSJiri Slaby */ 6509196d8acSJiri Slaby static int __enable_rsa(struct uart_8250_port *up) 6519196d8acSJiri Slaby { 6529196d8acSJiri Slaby unsigned char mode; 6539196d8acSJiri Slaby int result; 6549196d8acSJiri Slaby 6559196d8acSJiri Slaby mode = serial_in(up, UART_RSA_MSR); 6569196d8acSJiri Slaby result = mode & UART_RSA_MSR_FIFO; 6579196d8acSJiri Slaby 6589196d8acSJiri Slaby if (!result) { 6599196d8acSJiri Slaby serial_out(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO); 6609196d8acSJiri Slaby mode = serial_in(up, UART_RSA_MSR); 6619196d8acSJiri Slaby result = mode & UART_RSA_MSR_FIFO; 6629196d8acSJiri Slaby } 6639196d8acSJiri Slaby 6649196d8acSJiri Slaby if (result) 6659196d8acSJiri Slaby up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16; 6669196d8acSJiri Slaby 6679196d8acSJiri Slaby return result; 6689196d8acSJiri Slaby } 6699196d8acSJiri Slaby 6709196d8acSJiri Slaby static void enable_rsa(struct uart_8250_port *up) 6719196d8acSJiri Slaby { 6729196d8acSJiri Slaby if (up->port.type == PORT_RSA) { 6739196d8acSJiri Slaby if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) { 6749196d8acSJiri Slaby spin_lock_irq(&up->port.lock); 6759196d8acSJiri Slaby __enable_rsa(up); 6769196d8acSJiri Slaby spin_unlock_irq(&up->port.lock); 6779196d8acSJiri Slaby } 6789196d8acSJiri Slaby if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) 6799196d8acSJiri Slaby serial_out(up, UART_RSA_FRR, 0); 6809196d8acSJiri Slaby } 6819196d8acSJiri Slaby } 6829196d8acSJiri Slaby 6839196d8acSJiri Slaby /* 6849196d8acSJiri Slaby * Attempts to turn off the RSA FIFO. Returns zero on failure. 6859196d8acSJiri Slaby * It is unknown why interrupts were disabled in here. However, 6869196d8acSJiri Slaby * the caller is expected to preserve this behaviour by grabbing 6879196d8acSJiri Slaby * the spinlock before calling this function. 6889196d8acSJiri Slaby */ 6899196d8acSJiri Slaby static void disable_rsa(struct uart_8250_port *up) 6909196d8acSJiri Slaby { 6919196d8acSJiri Slaby unsigned char mode; 6929196d8acSJiri Slaby int result; 6939196d8acSJiri Slaby 6949196d8acSJiri Slaby if (up->port.type == PORT_RSA && 6959196d8acSJiri Slaby up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) { 6969196d8acSJiri Slaby spin_lock_irq(&up->port.lock); 6979196d8acSJiri Slaby 6989196d8acSJiri Slaby mode = serial_in(up, UART_RSA_MSR); 6999196d8acSJiri Slaby result = !(mode & UART_RSA_MSR_FIFO); 7009196d8acSJiri Slaby 7019196d8acSJiri Slaby if (!result) { 7029196d8acSJiri Slaby serial_out(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO); 7039196d8acSJiri Slaby mode = serial_in(up, UART_RSA_MSR); 7049196d8acSJiri Slaby result = !(mode & UART_RSA_MSR_FIFO); 7059196d8acSJiri Slaby } 7069196d8acSJiri Slaby 7079196d8acSJiri Slaby if (result) 7089196d8acSJiri Slaby up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16; 7099196d8acSJiri Slaby spin_unlock_irq(&up->port.lock); 7109196d8acSJiri Slaby } 7119196d8acSJiri Slaby } 7129196d8acSJiri Slaby #endif /* CONFIG_SERIAL_8250_RSA */ 7139196d8acSJiri Slaby 7149196d8acSJiri Slaby /* 7159196d8acSJiri Slaby * This is a quickie test to see how big the FIFO is. 7169196d8acSJiri Slaby * It doesn't work at all the time, more's the pity. 7179196d8acSJiri Slaby */ 7189196d8acSJiri Slaby static int size_fifo(struct uart_8250_port *up) 7199196d8acSJiri Slaby { 7209196d8acSJiri Slaby unsigned char old_fcr, old_mcr, old_lcr; 7219196d8acSJiri Slaby unsigned short old_dl; 7229196d8acSJiri Slaby int count; 7239196d8acSJiri Slaby 7249196d8acSJiri Slaby old_lcr = serial_in(up, UART_LCR); 7259196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 7269196d8acSJiri Slaby old_fcr = serial_in(up, UART_FCR); 7279196d8acSJiri Slaby old_mcr = serial_in(up, UART_MCR); 7289196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | 7299196d8acSJiri Slaby UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT); 7309196d8acSJiri Slaby serial_out(up, UART_MCR, UART_MCR_LOOP); 7319196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A); 7329196d8acSJiri Slaby old_dl = serial_dl_read(up); 7339196d8acSJiri Slaby serial_dl_write(up, 0x0001); 7349196d8acSJiri Slaby serial_out(up, UART_LCR, 0x03); 7359196d8acSJiri Slaby for (count = 0; count < 256; count++) 7369196d8acSJiri Slaby serial_out(up, UART_TX, count); 7379196d8acSJiri Slaby mdelay(20);/* FIXME - schedule_timeout */ 7389196d8acSJiri Slaby for (count = 0; (serial_in(up, UART_LSR) & UART_LSR_DR) && 7399196d8acSJiri Slaby (count < 256); count++) 7409196d8acSJiri Slaby serial_in(up, UART_RX); 7419196d8acSJiri Slaby serial_out(up, UART_FCR, old_fcr); 7429196d8acSJiri Slaby serial_out(up, UART_MCR, old_mcr); 7439196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A); 7449196d8acSJiri Slaby serial_dl_write(up, old_dl); 7459196d8acSJiri Slaby serial_out(up, UART_LCR, old_lcr); 7469196d8acSJiri Slaby 7479196d8acSJiri Slaby return count; 7489196d8acSJiri Slaby } 7499196d8acSJiri Slaby 7509196d8acSJiri Slaby /* 7519196d8acSJiri Slaby * Read UART ID using the divisor method - set DLL and DLM to zero 7529196d8acSJiri Slaby * and the revision will be in DLL and device type in DLM. We 7539196d8acSJiri Slaby * preserve the device state across this. 7549196d8acSJiri Slaby */ 7559196d8acSJiri Slaby static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p) 7569196d8acSJiri Slaby { 7579196d8acSJiri Slaby unsigned char old_dll, old_dlm, old_lcr; 7589196d8acSJiri Slaby unsigned int id; 7599196d8acSJiri Slaby 7609196d8acSJiri Slaby old_lcr = serial_in(p, UART_LCR); 7619196d8acSJiri Slaby serial_out(p, UART_LCR, UART_LCR_CONF_MODE_A); 7629196d8acSJiri Slaby 7639196d8acSJiri Slaby old_dll = serial_in(p, UART_DLL); 7649196d8acSJiri Slaby old_dlm = serial_in(p, UART_DLM); 7659196d8acSJiri Slaby 7669196d8acSJiri Slaby serial_out(p, UART_DLL, 0); 7679196d8acSJiri Slaby serial_out(p, UART_DLM, 0); 7689196d8acSJiri Slaby 7699196d8acSJiri Slaby id = serial_in(p, UART_DLL) | serial_in(p, UART_DLM) << 8; 7709196d8acSJiri Slaby 7719196d8acSJiri Slaby serial_out(p, UART_DLL, old_dll); 7729196d8acSJiri Slaby serial_out(p, UART_DLM, old_dlm); 7739196d8acSJiri Slaby serial_out(p, UART_LCR, old_lcr); 7749196d8acSJiri Slaby 7759196d8acSJiri Slaby return id; 7769196d8acSJiri Slaby } 7779196d8acSJiri Slaby 7789196d8acSJiri Slaby /* 7799196d8acSJiri Slaby * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's. 7809196d8acSJiri Slaby * When this function is called we know it is at least a StarTech 7819196d8acSJiri Slaby * 16650 V2, but it might be one of several StarTech UARTs, or one of 7829196d8acSJiri Slaby * its clones. (We treat the broken original StarTech 16650 V1 as a 7839196d8acSJiri Slaby * 16550, and why not? Startech doesn't seem to even acknowledge its 7849196d8acSJiri Slaby * existence.) 7859196d8acSJiri Slaby * 7869196d8acSJiri Slaby * What evil have men's minds wrought... 7879196d8acSJiri Slaby */ 7889196d8acSJiri Slaby static void autoconfig_has_efr(struct uart_8250_port *up) 7899196d8acSJiri Slaby { 7909196d8acSJiri Slaby unsigned int id1, id2, id3, rev; 7919196d8acSJiri Slaby 7929196d8acSJiri Slaby /* 7939196d8acSJiri Slaby * Everything with an EFR has SLEEP 7949196d8acSJiri Slaby */ 7959196d8acSJiri Slaby up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP; 7969196d8acSJiri Slaby 7979196d8acSJiri Slaby /* 7989196d8acSJiri Slaby * First we check to see if it's an Oxford Semiconductor UART. 7999196d8acSJiri Slaby * 8009196d8acSJiri Slaby * If we have to do this here because some non-National 8019196d8acSJiri Slaby * Semiconductor clone chips lock up if you try writing to the 8029196d8acSJiri Slaby * LSR register (which serial_icr_read does) 8039196d8acSJiri Slaby */ 8049196d8acSJiri Slaby 8059196d8acSJiri Slaby /* 8069196d8acSJiri Slaby * Check for Oxford Semiconductor 16C950. 8079196d8acSJiri Slaby * 8089196d8acSJiri Slaby * EFR [4] must be set else this test fails. 8099196d8acSJiri Slaby * 8109196d8acSJiri Slaby * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca) 8119196d8acSJiri Slaby * claims that it's needed for 952 dual UART's (which are not 8129196d8acSJiri Slaby * recommended for new designs). 8139196d8acSJiri Slaby */ 8149196d8acSJiri Slaby up->acr = 0; 8159196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); 8169196d8acSJiri Slaby serial_out(up, UART_EFR, UART_EFR_ECB); 8179196d8acSJiri Slaby serial_out(up, UART_LCR, 0x00); 8189196d8acSJiri Slaby id1 = serial_icr_read(up, UART_ID1); 8199196d8acSJiri Slaby id2 = serial_icr_read(up, UART_ID2); 8209196d8acSJiri Slaby id3 = serial_icr_read(up, UART_ID3); 8219196d8acSJiri Slaby rev = serial_icr_read(up, UART_REV); 8229196d8acSJiri Slaby 8239196d8acSJiri Slaby DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev); 8249196d8acSJiri Slaby 8259196d8acSJiri Slaby if (id1 == 0x16 && id2 == 0xC9 && 8269196d8acSJiri Slaby (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) { 8279196d8acSJiri Slaby up->port.type = PORT_16C950; 8289196d8acSJiri Slaby 8299196d8acSJiri Slaby /* 8309196d8acSJiri Slaby * Enable work around for the Oxford Semiconductor 952 rev B 8319196d8acSJiri Slaby * chip which causes it to seriously miscalculate baud rates 8329196d8acSJiri Slaby * when DLL is 0. 8339196d8acSJiri Slaby */ 8349196d8acSJiri Slaby if (id3 == 0x52 && rev == 0x01) 8359196d8acSJiri Slaby up->bugs |= UART_BUG_QUOT; 8369196d8acSJiri Slaby return; 8379196d8acSJiri Slaby } 8389196d8acSJiri Slaby 8399196d8acSJiri Slaby /* 8409196d8acSJiri Slaby * We check for a XR16C850 by setting DLL and DLM to 0, and then 8419196d8acSJiri Slaby * reading back DLL and DLM. The chip type depends on the DLM 8429196d8acSJiri Slaby * value read back: 8439196d8acSJiri Slaby * 0x10 - XR16C850 and the DLL contains the chip revision. 8449196d8acSJiri Slaby * 0x12 - XR16C2850. 8459196d8acSJiri Slaby * 0x14 - XR16C854. 8469196d8acSJiri Slaby */ 8479196d8acSJiri Slaby id1 = autoconfig_read_divisor_id(up); 8489196d8acSJiri Slaby DEBUG_AUTOCONF("850id=%04x ", id1); 8499196d8acSJiri Slaby 8509196d8acSJiri Slaby id2 = id1 >> 8; 8519196d8acSJiri Slaby if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) { 8529196d8acSJiri Slaby up->port.type = PORT_16850; 8539196d8acSJiri Slaby return; 8549196d8acSJiri Slaby } 8559196d8acSJiri Slaby 8569196d8acSJiri Slaby /* 8579196d8acSJiri Slaby * It wasn't an XR16C850. 8589196d8acSJiri Slaby * 8599196d8acSJiri Slaby * We distinguish between the '654 and the '650 by counting 8609196d8acSJiri Slaby * how many bytes are in the FIFO. I'm using this for now, 8619196d8acSJiri Slaby * since that's the technique that was sent to me in the 8629196d8acSJiri Slaby * serial driver update, but I'm not convinced this works. 8639196d8acSJiri Slaby * I've had problems doing this in the past. -TYT 8649196d8acSJiri Slaby */ 8659196d8acSJiri Slaby if (size_fifo(up) == 64) 8669196d8acSJiri Slaby up->port.type = PORT_16654; 8679196d8acSJiri Slaby else 8689196d8acSJiri Slaby up->port.type = PORT_16650V2; 8699196d8acSJiri Slaby } 8709196d8acSJiri Slaby 8719196d8acSJiri Slaby /* 8729196d8acSJiri Slaby * We detected a chip without a FIFO. Only two fall into 8739196d8acSJiri Slaby * this category - the original 8250 and the 16450. The 8749196d8acSJiri Slaby * 16450 has a scratch register (accessible with LCR=0) 8759196d8acSJiri Slaby */ 8769196d8acSJiri Slaby static void autoconfig_8250(struct uart_8250_port *up) 8779196d8acSJiri Slaby { 8789196d8acSJiri Slaby unsigned char scratch, status1, status2; 8799196d8acSJiri Slaby 8809196d8acSJiri Slaby up->port.type = PORT_8250; 8819196d8acSJiri Slaby 8829196d8acSJiri Slaby scratch = serial_in(up, UART_SCR); 8839196d8acSJiri Slaby serial_out(up, UART_SCR, 0xa5); 8849196d8acSJiri Slaby status1 = serial_in(up, UART_SCR); 8859196d8acSJiri Slaby serial_out(up, UART_SCR, 0x5a); 8869196d8acSJiri Slaby status2 = serial_in(up, UART_SCR); 8879196d8acSJiri Slaby serial_out(up, UART_SCR, scratch); 8889196d8acSJiri Slaby 8899196d8acSJiri Slaby if (status1 == 0xa5 && status2 == 0x5a) 8909196d8acSJiri Slaby up->port.type = PORT_16450; 8919196d8acSJiri Slaby } 8929196d8acSJiri Slaby 8939196d8acSJiri Slaby static int broken_efr(struct uart_8250_port *up) 8949196d8acSJiri Slaby { 8959196d8acSJiri Slaby /* 8969196d8acSJiri Slaby * Exar ST16C2550 "A2" devices incorrectly detect as 8979196d8acSJiri Slaby * having an EFR, and report an ID of 0x0201. See 8989196d8acSJiri Slaby * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html 8999196d8acSJiri Slaby */ 9009196d8acSJiri Slaby if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16) 9019196d8acSJiri Slaby return 1; 9029196d8acSJiri Slaby 9039196d8acSJiri Slaby return 0; 9049196d8acSJiri Slaby } 9059196d8acSJiri Slaby 9069196d8acSJiri Slaby /* 9079196d8acSJiri Slaby * We know that the chip has FIFOs. Does it have an EFR? The 9089196d8acSJiri Slaby * EFR is located in the same register position as the IIR and 9099196d8acSJiri Slaby * we know the top two bits of the IIR are currently set. The 9109196d8acSJiri Slaby * EFR should contain zero. Try to read the EFR. 9119196d8acSJiri Slaby */ 9129196d8acSJiri Slaby static void autoconfig_16550a(struct uart_8250_port *up) 9139196d8acSJiri Slaby { 9149196d8acSJiri Slaby unsigned char status1, status2; 9159196d8acSJiri Slaby unsigned int iersave; 9169196d8acSJiri Slaby 9179196d8acSJiri Slaby up->port.type = PORT_16550A; 9189196d8acSJiri Slaby up->capabilities |= UART_CAP_FIFO; 9199196d8acSJiri Slaby 9209196d8acSJiri Slaby /* 9219196d8acSJiri Slaby * XR17V35x UARTs have an extra divisor register, DLD 9229196d8acSJiri Slaby * that gets enabled with when DLAB is set which will 9239196d8acSJiri Slaby * cause the device to incorrectly match and assign 9249196d8acSJiri Slaby * port type to PORT_16650. The EFR for this UART is 9259196d8acSJiri Slaby * found at offset 0x09. Instead check the Deice ID (DVID) 9269196d8acSJiri Slaby * register for a 2, 4 or 8 port UART. 9279196d8acSJiri Slaby */ 9289196d8acSJiri Slaby if (up->port.flags & UPF_EXAR_EFR) { 9299196d8acSJiri Slaby status1 = serial_in(up, UART_EXAR_DVID); 9309196d8acSJiri Slaby if (status1 == 0x82 || status1 == 0x84 || status1 == 0x88) { 9319196d8acSJiri Slaby DEBUG_AUTOCONF("Exar XR17V35x "); 9329196d8acSJiri Slaby up->port.type = PORT_XR17V35X; 9339196d8acSJiri Slaby up->capabilities |= UART_CAP_AFE | UART_CAP_EFR | 9349196d8acSJiri Slaby UART_CAP_SLEEP; 9359196d8acSJiri Slaby 9369196d8acSJiri Slaby return; 9379196d8acSJiri Slaby } 9389196d8acSJiri Slaby 9399196d8acSJiri Slaby } 9409196d8acSJiri Slaby 9419196d8acSJiri Slaby /* 9429196d8acSJiri Slaby * Check for presence of the EFR when DLAB is set. 9439196d8acSJiri Slaby * Only ST16C650V1 UARTs pass this test. 9449196d8acSJiri Slaby */ 9459196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A); 9469196d8acSJiri Slaby if (serial_in(up, UART_EFR) == 0) { 9479196d8acSJiri Slaby serial_out(up, UART_EFR, 0xA8); 9489196d8acSJiri Slaby if (serial_in(up, UART_EFR) != 0) { 9499196d8acSJiri Slaby DEBUG_AUTOCONF("EFRv1 "); 9509196d8acSJiri Slaby up->port.type = PORT_16650; 9519196d8acSJiri Slaby up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP; 9529196d8acSJiri Slaby } else { 953fddceb8bSVijay Rai serial_out(up, UART_LCR, 0); 954fddceb8bSVijay Rai serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | 955fddceb8bSVijay Rai UART_FCR7_64BYTE); 956fddceb8bSVijay Rai status1 = serial_in(up, UART_IIR) >> 5; 957fddceb8bSVijay Rai serial_out(up, UART_FCR, 0); 958fddceb8bSVijay Rai serial_out(up, UART_LCR, 0); 959fddceb8bSVijay Rai 960fddceb8bSVijay Rai if (status1 == 7) 961fddceb8bSVijay Rai up->port.type = PORT_16550A_FSL64; 962fddceb8bSVijay Rai else 9639196d8acSJiri Slaby DEBUG_AUTOCONF("Motorola 8xxx DUART "); 9649196d8acSJiri Slaby } 9659196d8acSJiri Slaby serial_out(up, UART_EFR, 0); 9669196d8acSJiri Slaby return; 9679196d8acSJiri Slaby } 9689196d8acSJiri Slaby 9699196d8acSJiri Slaby /* 9709196d8acSJiri Slaby * Maybe it requires 0xbf to be written to the LCR. 9719196d8acSJiri Slaby * (other ST16C650V2 UARTs, TI16C752A, etc) 9729196d8acSJiri Slaby */ 9739196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); 9749196d8acSJiri Slaby if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) { 9759196d8acSJiri Slaby DEBUG_AUTOCONF("EFRv2 "); 9769196d8acSJiri Slaby autoconfig_has_efr(up); 9779196d8acSJiri Slaby return; 9789196d8acSJiri Slaby } 9799196d8acSJiri Slaby 9809196d8acSJiri Slaby /* 9819196d8acSJiri Slaby * Check for a National Semiconductor SuperIO chip. 9829196d8acSJiri Slaby * Attempt to switch to bank 2, read the value of the LOOP bit 9839196d8acSJiri Slaby * from EXCR1. Switch back to bank 0, change it in MCR. Then 9849196d8acSJiri Slaby * switch back to bank 2, read it from EXCR1 again and check 9859196d8acSJiri Slaby * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2 9869196d8acSJiri Slaby */ 9879196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 9889196d8acSJiri Slaby status1 = serial_in(up, UART_MCR); 9899196d8acSJiri Slaby serial_out(up, UART_LCR, 0xE0); 9909196d8acSJiri Slaby status2 = serial_in(up, 0x02); /* EXCR1 */ 9919196d8acSJiri Slaby 9929196d8acSJiri Slaby if (!((status2 ^ status1) & UART_MCR_LOOP)) { 9939196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 9949196d8acSJiri Slaby serial_out(up, UART_MCR, status1 ^ UART_MCR_LOOP); 9959196d8acSJiri Slaby serial_out(up, UART_LCR, 0xE0); 9969196d8acSJiri Slaby status2 = serial_in(up, 0x02); /* EXCR1 */ 9979196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 9989196d8acSJiri Slaby serial_out(up, UART_MCR, status1); 9999196d8acSJiri Slaby 10009196d8acSJiri Slaby if ((status2 ^ status1) & UART_MCR_LOOP) { 10019196d8acSJiri Slaby unsigned short quot; 10029196d8acSJiri Slaby 10039196d8acSJiri Slaby serial_out(up, UART_LCR, 0xE0); 10049196d8acSJiri Slaby 10059196d8acSJiri Slaby quot = serial_dl_read(up); 10069196d8acSJiri Slaby quot <<= 3; 10079196d8acSJiri Slaby 10089196d8acSJiri Slaby if (ns16550a_goto_highspeed(up)) 10099196d8acSJiri Slaby serial_dl_write(up, quot); 10109196d8acSJiri Slaby 10119196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 10129196d8acSJiri Slaby 10139196d8acSJiri Slaby up->port.uartclk = 921600*16; 10149196d8acSJiri Slaby up->port.type = PORT_NS16550A; 10159196d8acSJiri Slaby up->capabilities |= UART_NATSEMI; 10169196d8acSJiri Slaby return; 10179196d8acSJiri Slaby } 10189196d8acSJiri Slaby } 10199196d8acSJiri Slaby 10209196d8acSJiri Slaby /* 10219196d8acSJiri Slaby * No EFR. Try to detect a TI16750, which only sets bit 5 of 10229196d8acSJiri Slaby * the IIR when 64 byte FIFO mode is enabled when DLAB is set. 10239196d8acSJiri Slaby * Try setting it with and without DLAB set. Cheap clones 10249196d8acSJiri Slaby * set bit 5 without DLAB set. 10259196d8acSJiri Slaby */ 10269196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 10279196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE); 10289196d8acSJiri Slaby status1 = serial_in(up, UART_IIR) >> 5; 10299196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO); 10309196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A); 10319196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE); 10329196d8acSJiri Slaby status2 = serial_in(up, UART_IIR) >> 5; 10339196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO); 10349196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 10359196d8acSJiri Slaby 10369196d8acSJiri Slaby DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2); 10379196d8acSJiri Slaby 10389196d8acSJiri Slaby if (status1 == 6 && status2 == 7) { 10399196d8acSJiri Slaby up->port.type = PORT_16750; 10409196d8acSJiri Slaby up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP; 10419196d8acSJiri Slaby return; 10429196d8acSJiri Slaby } 10439196d8acSJiri Slaby 10449196d8acSJiri Slaby /* 10459196d8acSJiri Slaby * Try writing and reading the UART_IER_UUE bit (b6). 10469196d8acSJiri Slaby * If it works, this is probably one of the Xscale platform's 10479196d8acSJiri Slaby * internal UARTs. 10489196d8acSJiri Slaby * We're going to explicitly set the UUE bit to 0 before 10499196d8acSJiri Slaby * trying to write and read a 1 just to make sure it's not 10509196d8acSJiri Slaby * already a 1 and maybe locked there before we even start start. 10519196d8acSJiri Slaby */ 10529196d8acSJiri Slaby iersave = serial_in(up, UART_IER); 10539196d8acSJiri Slaby serial_out(up, UART_IER, iersave & ~UART_IER_UUE); 10549196d8acSJiri Slaby if (!(serial_in(up, UART_IER) & UART_IER_UUE)) { 10559196d8acSJiri Slaby /* 10569196d8acSJiri Slaby * OK it's in a known zero state, try writing and reading 10579196d8acSJiri Slaby * without disturbing the current state of the other bits. 10589196d8acSJiri Slaby */ 10599196d8acSJiri Slaby serial_out(up, UART_IER, iersave | UART_IER_UUE); 10609196d8acSJiri Slaby if (serial_in(up, UART_IER) & UART_IER_UUE) { 10619196d8acSJiri Slaby /* 10629196d8acSJiri Slaby * It's an Xscale. 10639196d8acSJiri Slaby * We'll leave the UART_IER_UUE bit set to 1 (enabled). 10649196d8acSJiri Slaby */ 10659196d8acSJiri Slaby DEBUG_AUTOCONF("Xscale "); 10669196d8acSJiri Slaby up->port.type = PORT_XSCALE; 10679196d8acSJiri Slaby up->capabilities |= UART_CAP_UUE | UART_CAP_RTOIE; 10689196d8acSJiri Slaby return; 10699196d8acSJiri Slaby } 10709196d8acSJiri Slaby } else { 10719196d8acSJiri Slaby /* 10729196d8acSJiri Slaby * If we got here we couldn't force the IER_UUE bit to 0. 10739196d8acSJiri Slaby * Log it and continue. 10749196d8acSJiri Slaby */ 10759196d8acSJiri Slaby DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 "); 10769196d8acSJiri Slaby } 10779196d8acSJiri Slaby serial_out(up, UART_IER, iersave); 10789196d8acSJiri Slaby 10799196d8acSJiri Slaby /* 10809196d8acSJiri Slaby * Exar uarts have EFR in a weird location 10819196d8acSJiri Slaby */ 10829196d8acSJiri Slaby if (up->port.flags & UPF_EXAR_EFR) { 10839196d8acSJiri Slaby DEBUG_AUTOCONF("Exar XR17D15x "); 10849196d8acSJiri Slaby up->port.type = PORT_XR17D15X; 10859196d8acSJiri Slaby up->capabilities |= UART_CAP_AFE | UART_CAP_EFR | 10869196d8acSJiri Slaby UART_CAP_SLEEP; 10879196d8acSJiri Slaby 10889196d8acSJiri Slaby return; 10899196d8acSJiri Slaby } 10909196d8acSJiri Slaby 10919196d8acSJiri Slaby /* 10929196d8acSJiri Slaby * We distinguish between 16550A and U6 16550A by counting 10939196d8acSJiri Slaby * how many bytes are in the FIFO. 10949196d8acSJiri Slaby */ 10959196d8acSJiri Slaby if (up->port.type == PORT_16550A && size_fifo(up) == 64) { 10969196d8acSJiri Slaby up->port.type = PORT_U6_16550A; 10979196d8acSJiri Slaby up->capabilities |= UART_CAP_AFE; 10989196d8acSJiri Slaby } 10999196d8acSJiri Slaby } 11009196d8acSJiri Slaby 11019196d8acSJiri Slaby /* 11029196d8acSJiri Slaby * This routine is called by rs_init() to initialize a specific serial 11039196d8acSJiri Slaby * port. It determines what type of UART chip this serial port is 11049196d8acSJiri Slaby * using: 8250, 16450, 16550, 16550A. The important question is 11059196d8acSJiri Slaby * whether or not this UART is a 16550A or not, since this will 11069196d8acSJiri Slaby * determine whether or not we can use its FIFO features or not. 11079196d8acSJiri Slaby */ 11089196d8acSJiri Slaby static void autoconfig(struct uart_8250_port *up, unsigned int probeflags) 11099196d8acSJiri Slaby { 11109196d8acSJiri Slaby unsigned char status1, scratch, scratch2, scratch3; 11119196d8acSJiri Slaby unsigned char save_lcr, save_mcr; 11129196d8acSJiri Slaby struct uart_port *port = &up->port; 11139196d8acSJiri Slaby unsigned long flags; 11149196d8acSJiri Slaby unsigned int old_capabilities; 11159196d8acSJiri Slaby 11169196d8acSJiri Slaby if (!port->iobase && !port->mapbase && !port->membase) 11179196d8acSJiri Slaby return; 11189196d8acSJiri Slaby 11199196d8acSJiri Slaby DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04lx, 0x%p): ", 11209196d8acSJiri Slaby serial_index(port), port->iobase, port->membase); 11219196d8acSJiri Slaby 11229196d8acSJiri Slaby /* 11239196d8acSJiri Slaby * We really do need global IRQs disabled here - we're going to 11249196d8acSJiri Slaby * be frobbing the chips IRQ enable register to see if it exists. 11259196d8acSJiri Slaby */ 11269196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 11279196d8acSJiri Slaby 11289196d8acSJiri Slaby up->capabilities = 0; 11299196d8acSJiri Slaby up->bugs = 0; 11309196d8acSJiri Slaby 11319196d8acSJiri Slaby if (!(port->flags & UPF_BUGGY_UART)) { 11329196d8acSJiri Slaby /* 11339196d8acSJiri Slaby * Do a simple existence test first; if we fail this, 11349196d8acSJiri Slaby * there's no point trying anything else. 11359196d8acSJiri Slaby * 11369196d8acSJiri Slaby * 0x80 is used as a nonsense port to prevent against 11379196d8acSJiri Slaby * false positives due to ISA bus float. The 11389196d8acSJiri Slaby * assumption is that 0x80 is a non-existent port; 11399196d8acSJiri Slaby * which should be safe since include/asm/io.h also 11409196d8acSJiri Slaby * makes this assumption. 11419196d8acSJiri Slaby * 11429196d8acSJiri Slaby * Note: this is safe as long as MCR bit 4 is clear 11439196d8acSJiri Slaby * and the device is in "PC" mode. 11449196d8acSJiri Slaby */ 11459196d8acSJiri Slaby scratch = serial_in(up, UART_IER); 11469196d8acSJiri Slaby serial_out(up, UART_IER, 0); 11479196d8acSJiri Slaby #ifdef __i386__ 11489196d8acSJiri Slaby outb(0xff, 0x080); 11499196d8acSJiri Slaby #endif 11509196d8acSJiri Slaby /* 11519196d8acSJiri Slaby * Mask out IER[7:4] bits for test as some UARTs (e.g. TL 11529196d8acSJiri Slaby * 16C754B) allow only to modify them if an EFR bit is set. 11539196d8acSJiri Slaby */ 11549196d8acSJiri Slaby scratch2 = serial_in(up, UART_IER) & 0x0f; 11559196d8acSJiri Slaby serial_out(up, UART_IER, 0x0F); 11569196d8acSJiri Slaby #ifdef __i386__ 11579196d8acSJiri Slaby outb(0, 0x080); 11589196d8acSJiri Slaby #endif 11599196d8acSJiri Slaby scratch3 = serial_in(up, UART_IER) & 0x0f; 11609196d8acSJiri Slaby serial_out(up, UART_IER, scratch); 11619196d8acSJiri Slaby if (scratch2 != 0 || scratch3 != 0x0F) { 11629196d8acSJiri Slaby /* 11639196d8acSJiri Slaby * We failed; there's nothing here 11649196d8acSJiri Slaby */ 11659196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 11669196d8acSJiri Slaby DEBUG_AUTOCONF("IER test failed (%02x, %02x) ", 11679196d8acSJiri Slaby scratch2, scratch3); 11689196d8acSJiri Slaby goto out; 11699196d8acSJiri Slaby } 11709196d8acSJiri Slaby } 11719196d8acSJiri Slaby 11729196d8acSJiri Slaby save_mcr = serial_in(up, UART_MCR); 11739196d8acSJiri Slaby save_lcr = serial_in(up, UART_LCR); 11749196d8acSJiri Slaby 11759196d8acSJiri Slaby /* 11769196d8acSJiri Slaby * Check to see if a UART is really there. Certain broken 11779196d8acSJiri Slaby * internal modems based on the Rockwell chipset fail this 11789196d8acSJiri Slaby * test, because they apparently don't implement the loopback 11799196d8acSJiri Slaby * test mode. So this test is skipped on the COM 1 through 11809196d8acSJiri Slaby * COM 4 ports. This *should* be safe, since no board 11819196d8acSJiri Slaby * manufacturer would be stupid enough to design a board 11829196d8acSJiri Slaby * that conflicts with COM 1-4 --- we hope! 11839196d8acSJiri Slaby */ 11849196d8acSJiri Slaby if (!(port->flags & UPF_SKIP_TEST)) { 11859196d8acSJiri Slaby serial_out(up, UART_MCR, UART_MCR_LOOP | 0x0A); 11869196d8acSJiri Slaby status1 = serial_in(up, UART_MSR) & 0xF0; 11879196d8acSJiri Slaby serial_out(up, UART_MCR, save_mcr); 11889196d8acSJiri Slaby if (status1 != 0x90) { 11899196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 11909196d8acSJiri Slaby DEBUG_AUTOCONF("LOOP test failed (%02x) ", 11919196d8acSJiri Slaby status1); 11929196d8acSJiri Slaby goto out; 11939196d8acSJiri Slaby } 11949196d8acSJiri Slaby } 11959196d8acSJiri Slaby 11969196d8acSJiri Slaby /* 11979196d8acSJiri Slaby * We're pretty sure there's a port here. Lets find out what 11989196d8acSJiri Slaby * type of port it is. The IIR top two bits allows us to find 11999196d8acSJiri Slaby * out if it's 8250 or 16450, 16550, 16550A or later. This 12009196d8acSJiri Slaby * determines what we test for next. 12019196d8acSJiri Slaby * 12029196d8acSJiri Slaby * We also initialise the EFR (if any) to zero for later. The 12039196d8acSJiri Slaby * EFR occupies the same register location as the FCR and IIR. 12049196d8acSJiri Slaby */ 12059196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); 12069196d8acSJiri Slaby serial_out(up, UART_EFR, 0); 12079196d8acSJiri Slaby serial_out(up, UART_LCR, 0); 12089196d8acSJiri Slaby 12099196d8acSJiri Slaby serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO); 12109196d8acSJiri Slaby scratch = serial_in(up, UART_IIR) >> 6; 12119196d8acSJiri Slaby 12129196d8acSJiri Slaby switch (scratch) { 12139196d8acSJiri Slaby case 0: 12149196d8acSJiri Slaby autoconfig_8250(up); 12159196d8acSJiri Slaby break; 12169196d8acSJiri Slaby case 1: 12179196d8acSJiri Slaby port->type = PORT_UNKNOWN; 12189196d8acSJiri Slaby break; 12199196d8acSJiri Slaby case 2: 12209196d8acSJiri Slaby port->type = PORT_16550; 12219196d8acSJiri Slaby break; 12229196d8acSJiri Slaby case 3: 12239196d8acSJiri Slaby autoconfig_16550a(up); 12249196d8acSJiri Slaby break; 12259196d8acSJiri Slaby } 12269196d8acSJiri Slaby 12279196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 12289196d8acSJiri Slaby /* 12299196d8acSJiri Slaby * Only probe for RSA ports if we got the region. 12309196d8acSJiri Slaby */ 12319196d8acSJiri Slaby if (port->type == PORT_16550A && probeflags & PROBE_RSA) { 12329196d8acSJiri Slaby int i; 12339196d8acSJiri Slaby 12349196d8acSJiri Slaby for (i = 0 ; i < probe_rsa_count; ++i) { 12359196d8acSJiri Slaby if (probe_rsa[i] == port->iobase && __enable_rsa(up)) { 12369196d8acSJiri Slaby port->type = PORT_RSA; 12379196d8acSJiri Slaby break; 12389196d8acSJiri Slaby } 12399196d8acSJiri Slaby } 12409196d8acSJiri Slaby } 12419196d8acSJiri Slaby #endif 12429196d8acSJiri Slaby 12439196d8acSJiri Slaby serial_out(up, UART_LCR, save_lcr); 12449196d8acSJiri Slaby 12459196d8acSJiri Slaby port->fifosize = uart_config[up->port.type].fifo_size; 12469196d8acSJiri Slaby old_capabilities = up->capabilities; 12479196d8acSJiri Slaby up->capabilities = uart_config[port->type].flags; 12489196d8acSJiri Slaby up->tx_loadsz = uart_config[port->type].tx_loadsz; 12499196d8acSJiri Slaby 12509196d8acSJiri Slaby if (port->type == PORT_UNKNOWN) 12519196d8acSJiri Slaby goto out_lock; 12529196d8acSJiri Slaby 12539196d8acSJiri Slaby /* 12549196d8acSJiri Slaby * Reset the UART. 12559196d8acSJiri Slaby */ 12569196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 12579196d8acSJiri Slaby if (port->type == PORT_RSA) 12589196d8acSJiri Slaby serial_out(up, UART_RSA_FRR, 0); 12599196d8acSJiri Slaby #endif 12609196d8acSJiri Slaby serial_out(up, UART_MCR, save_mcr); 12619196d8acSJiri Slaby serial8250_clear_fifos(up); 12629196d8acSJiri Slaby serial_in(up, UART_RX); 12639196d8acSJiri Slaby if (up->capabilities & UART_CAP_UUE) 12649196d8acSJiri Slaby serial_out(up, UART_IER, UART_IER_UUE); 12659196d8acSJiri Slaby else 12669196d8acSJiri Slaby serial_out(up, UART_IER, 0); 12679196d8acSJiri Slaby 12689196d8acSJiri Slaby out_lock: 12699196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 12709196d8acSJiri Slaby if (up->capabilities != old_capabilities) { 12719196d8acSJiri Slaby printk(KERN_WARNING 12729196d8acSJiri Slaby "ttyS%d: detected caps %08x should be %08x\n", 12739196d8acSJiri Slaby serial_index(port), old_capabilities, 12749196d8acSJiri Slaby up->capabilities); 12759196d8acSJiri Slaby } 12769196d8acSJiri Slaby out: 12779196d8acSJiri Slaby DEBUG_AUTOCONF("iir=%d ", scratch); 12789196d8acSJiri Slaby DEBUG_AUTOCONF("type=%s\n", uart_config[port->type].name); 12799196d8acSJiri Slaby } 12809196d8acSJiri Slaby 12819196d8acSJiri Slaby static void autoconfig_irq(struct uart_8250_port *up) 12829196d8acSJiri Slaby { 12839196d8acSJiri Slaby struct uart_port *port = &up->port; 12849196d8acSJiri Slaby unsigned char save_mcr, save_ier; 12859196d8acSJiri Slaby unsigned char save_ICP = 0; 12869196d8acSJiri Slaby unsigned int ICP = 0; 12879196d8acSJiri Slaby unsigned long irqs; 12889196d8acSJiri Slaby int irq; 12899196d8acSJiri Slaby 12909196d8acSJiri Slaby if (port->flags & UPF_FOURPORT) { 12919196d8acSJiri Slaby ICP = (port->iobase & 0xfe0) | 0x1f; 12929196d8acSJiri Slaby save_ICP = inb_p(ICP); 12939196d8acSJiri Slaby outb_p(0x80, ICP); 12949196d8acSJiri Slaby inb_p(ICP); 12959196d8acSJiri Slaby } 12969196d8acSJiri Slaby 12979196d8acSJiri Slaby /* forget possible initially masked and pending IRQ */ 12989196d8acSJiri Slaby probe_irq_off(probe_irq_on()); 12999196d8acSJiri Slaby save_mcr = serial_in(up, UART_MCR); 13009196d8acSJiri Slaby save_ier = serial_in(up, UART_IER); 13019196d8acSJiri Slaby serial_out(up, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2); 13029196d8acSJiri Slaby 13039196d8acSJiri Slaby irqs = probe_irq_on(); 13049196d8acSJiri Slaby serial_out(up, UART_MCR, 0); 13059196d8acSJiri Slaby udelay(10); 13069196d8acSJiri Slaby if (port->flags & UPF_FOURPORT) { 13079196d8acSJiri Slaby serial_out(up, UART_MCR, 13089196d8acSJiri Slaby UART_MCR_DTR | UART_MCR_RTS); 13099196d8acSJiri Slaby } else { 13109196d8acSJiri Slaby serial_out(up, UART_MCR, 13119196d8acSJiri Slaby UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2); 13129196d8acSJiri Slaby } 13139196d8acSJiri Slaby serial_out(up, UART_IER, 0x0f); /* enable all intrs */ 13149196d8acSJiri Slaby serial_in(up, UART_LSR); 13159196d8acSJiri Slaby serial_in(up, UART_RX); 13169196d8acSJiri Slaby serial_in(up, UART_IIR); 13179196d8acSJiri Slaby serial_in(up, UART_MSR); 13189196d8acSJiri Slaby serial_out(up, UART_TX, 0xFF); 13199196d8acSJiri Slaby udelay(20); 13209196d8acSJiri Slaby irq = probe_irq_off(irqs); 13219196d8acSJiri Slaby 13229196d8acSJiri Slaby serial_out(up, UART_MCR, save_mcr); 13239196d8acSJiri Slaby serial_out(up, UART_IER, save_ier); 13249196d8acSJiri Slaby 13259196d8acSJiri Slaby if (port->flags & UPF_FOURPORT) 13269196d8acSJiri Slaby outb_p(save_ICP, ICP); 13279196d8acSJiri Slaby 13289196d8acSJiri Slaby port->irq = (irq > 0) ? irq : 0; 13299196d8acSJiri Slaby } 13309196d8acSJiri Slaby 13319196d8acSJiri Slaby static inline void __stop_tx(struct uart_8250_port *p) 13329196d8acSJiri Slaby { 13339196d8acSJiri Slaby if (p->ier & UART_IER_THRI) { 13349196d8acSJiri Slaby p->ier &= ~UART_IER_THRI; 13359196d8acSJiri Slaby serial_out(p, UART_IER, p->ier); 1336d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put_tx(p); 13379196d8acSJiri Slaby } 13389196d8acSJiri Slaby } 13399196d8acSJiri Slaby 13409196d8acSJiri Slaby static void serial8250_stop_tx(struct uart_port *port) 13419196d8acSJiri Slaby { 1342b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 13439196d8acSJiri Slaby 1344d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 13459196d8acSJiri Slaby __stop_tx(up); 13469196d8acSJiri Slaby 13479196d8acSJiri Slaby /* 13489196d8acSJiri Slaby * We really want to stop the transmitter from sending. 13499196d8acSJiri Slaby */ 13509196d8acSJiri Slaby if (port->type == PORT_16C950) { 13519196d8acSJiri Slaby up->acr |= UART_ACR_TXDIS; 13529196d8acSJiri Slaby serial_icr_write(up, UART_ACR, up->acr); 13539196d8acSJiri Slaby } 1354d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 13559196d8acSJiri Slaby } 13569196d8acSJiri Slaby 13579196d8acSJiri Slaby static void serial8250_start_tx(struct uart_port *port) 13589196d8acSJiri Slaby { 1359b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 13609196d8acSJiri Slaby 1361d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get_tx(up); 1362a39d1da1SAndy Shevchenko 1363a39d1da1SAndy Shevchenko if (up->dma && !up->dma->tx_dma(up)) 13649196d8acSJiri Slaby return; 1365a39d1da1SAndy Shevchenko 1366a39d1da1SAndy Shevchenko if (!(up->ier & UART_IER_THRI)) { 13679196d8acSJiri Slaby up->ier |= UART_IER_THRI; 13689196d8acSJiri Slaby serial_port_out(port, UART_IER, up->ier); 13699196d8acSJiri Slaby 13709196d8acSJiri Slaby if (up->bugs & UART_BUG_TXEN) { 13719196d8acSJiri Slaby unsigned char lsr; 13729196d8acSJiri Slaby lsr = serial_in(up, UART_LSR); 13739196d8acSJiri Slaby up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS; 1374c09babfaSPeter Hurley if (lsr & UART_LSR_THRE) 13759196d8acSJiri Slaby serial8250_tx_chars(up); 13769196d8acSJiri Slaby } 13779196d8acSJiri Slaby } 13789196d8acSJiri Slaby 13799196d8acSJiri Slaby /* 13809196d8acSJiri Slaby * Re-enable the transmitter if we disabled it. 13819196d8acSJiri Slaby */ 13829196d8acSJiri Slaby if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) { 13839196d8acSJiri Slaby up->acr &= ~UART_ACR_TXDIS; 13849196d8acSJiri Slaby serial_icr_write(up, UART_ACR, up->acr); 13859196d8acSJiri Slaby } 13869196d8acSJiri Slaby } 13879196d8acSJiri Slaby 1388234abab1SSebastian Andrzej Siewior static void serial8250_throttle(struct uart_port *port) 1389234abab1SSebastian Andrzej Siewior { 1390234abab1SSebastian Andrzej Siewior port->throttle(port); 1391234abab1SSebastian Andrzej Siewior } 1392234abab1SSebastian Andrzej Siewior 1393234abab1SSebastian Andrzej Siewior static void serial8250_unthrottle(struct uart_port *port) 1394234abab1SSebastian Andrzej Siewior { 1395234abab1SSebastian Andrzej Siewior port->unthrottle(port); 1396234abab1SSebastian Andrzej Siewior } 1397234abab1SSebastian Andrzej Siewior 13989196d8acSJiri Slaby static void serial8250_stop_rx(struct uart_port *port) 13999196d8acSJiri Slaby { 1400b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 14019196d8acSJiri Slaby 1402d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 1403d74d5d1bSSebastian Andrzej Siewior 14049137568eSSebastian Andrzej Siewior up->ier &= ~(UART_IER_RLSI | UART_IER_RDI); 14059196d8acSJiri Slaby up->port.read_status_mask &= ~UART_LSR_DR; 14069196d8acSJiri Slaby serial_port_out(port, UART_IER, up->ier); 1407d74d5d1bSSebastian Andrzej Siewior 1408d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 14099196d8acSJiri Slaby } 14109196d8acSJiri Slaby 1411cab68f89SPeter Hurley static void serial8250_disable_ms(struct uart_port *port) 1412cab68f89SPeter Hurley { 1413cab68f89SPeter Hurley struct uart_8250_port *up = 1414cab68f89SPeter Hurley container_of(port, struct uart_8250_port, port); 1415cab68f89SPeter Hurley 1416cab68f89SPeter Hurley /* no MSR capabilities */ 1417cab68f89SPeter Hurley if (up->bugs & UART_BUG_NOMSR) 1418cab68f89SPeter Hurley return; 1419cab68f89SPeter Hurley 1420cab68f89SPeter Hurley up->ier &= ~UART_IER_MSI; 1421cab68f89SPeter Hurley serial_port_out(port, UART_IER, up->ier); 1422cab68f89SPeter Hurley } 1423cab68f89SPeter Hurley 14249196d8acSJiri Slaby static void serial8250_enable_ms(struct uart_port *port) 14259196d8acSJiri Slaby { 1426b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 14279196d8acSJiri Slaby 14289196d8acSJiri Slaby /* no MSR capabilities */ 14299196d8acSJiri Slaby if (up->bugs & UART_BUG_NOMSR) 14309196d8acSJiri Slaby return; 14319196d8acSJiri Slaby 14329196d8acSJiri Slaby up->ier |= UART_IER_MSI; 1433d74d5d1bSSebastian Andrzej Siewior 1434d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 14359196d8acSJiri Slaby serial_port_out(port, UART_IER, up->ier); 1436d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 14379196d8acSJiri Slaby } 14389196d8acSJiri Slaby 14399196d8acSJiri Slaby /* 14409196d8acSJiri Slaby * serial8250_rx_chars: processes according to the passed in LSR 14419196d8acSJiri Slaby * value, and returns the remaining LSR bits not handled 14429196d8acSJiri Slaby * by this Rx routine. 14439196d8acSJiri Slaby */ 14449196d8acSJiri Slaby unsigned char 14459196d8acSJiri Slaby serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr) 14469196d8acSJiri Slaby { 14479196d8acSJiri Slaby struct uart_port *port = &up->port; 14489196d8acSJiri Slaby unsigned char ch; 14499196d8acSJiri Slaby int max_count = 256; 14509196d8acSJiri Slaby char flag; 14519196d8acSJiri Slaby 14529196d8acSJiri Slaby do { 14539196d8acSJiri Slaby if (likely(lsr & UART_LSR_DR)) 14549196d8acSJiri Slaby ch = serial_in(up, UART_RX); 14559196d8acSJiri Slaby else 14569196d8acSJiri Slaby /* 14579196d8acSJiri Slaby * Intel 82571 has a Serial Over Lan device that will 14589196d8acSJiri Slaby * set UART_LSR_BI without setting UART_LSR_DR when 14599196d8acSJiri Slaby * it receives a break. To avoid reading from the 14609196d8acSJiri Slaby * receive buffer without UART_LSR_DR bit set, we 14619196d8acSJiri Slaby * just force the read character to be 0 14629196d8acSJiri Slaby */ 14639196d8acSJiri Slaby ch = 0; 14649196d8acSJiri Slaby 14659196d8acSJiri Slaby flag = TTY_NORMAL; 14669196d8acSJiri Slaby port->icount.rx++; 14679196d8acSJiri Slaby 14689196d8acSJiri Slaby lsr |= up->lsr_saved_flags; 14699196d8acSJiri Slaby up->lsr_saved_flags = 0; 14709196d8acSJiri Slaby 14719196d8acSJiri Slaby if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) { 14729196d8acSJiri Slaby if (lsr & UART_LSR_BI) { 14739196d8acSJiri Slaby lsr &= ~(UART_LSR_FE | UART_LSR_PE); 14749196d8acSJiri Slaby port->icount.brk++; 14759196d8acSJiri Slaby /* 14769196d8acSJiri Slaby * We do the SysRQ and SAK checking 14779196d8acSJiri Slaby * here because otherwise the break 14789196d8acSJiri Slaby * may get masked by ignore_status_mask 14799196d8acSJiri Slaby * or read_status_mask. 14809196d8acSJiri Slaby */ 14819196d8acSJiri Slaby if (uart_handle_break(port)) 14829196d8acSJiri Slaby goto ignore_char; 14839196d8acSJiri Slaby } else if (lsr & UART_LSR_PE) 14849196d8acSJiri Slaby port->icount.parity++; 14859196d8acSJiri Slaby else if (lsr & UART_LSR_FE) 14869196d8acSJiri Slaby port->icount.frame++; 14879196d8acSJiri Slaby if (lsr & UART_LSR_OE) 14889196d8acSJiri Slaby port->icount.overrun++; 14899196d8acSJiri Slaby 14909196d8acSJiri Slaby /* 14919196d8acSJiri Slaby * Mask off conditions which should be ignored. 14929196d8acSJiri Slaby */ 14939196d8acSJiri Slaby lsr &= port->read_status_mask; 14949196d8acSJiri Slaby 14959196d8acSJiri Slaby if (lsr & UART_LSR_BI) { 14969196d8acSJiri Slaby DEBUG_INTR("handling break...."); 14979196d8acSJiri Slaby flag = TTY_BREAK; 14989196d8acSJiri Slaby } else if (lsr & UART_LSR_PE) 14999196d8acSJiri Slaby flag = TTY_PARITY; 15009196d8acSJiri Slaby else if (lsr & UART_LSR_FE) 15019196d8acSJiri Slaby flag = TTY_FRAME; 15029196d8acSJiri Slaby } 15039196d8acSJiri Slaby if (uart_handle_sysrq_char(port, ch)) 15049196d8acSJiri Slaby goto ignore_char; 15059196d8acSJiri Slaby 15069196d8acSJiri Slaby uart_insert_char(port, lsr, UART_LSR_OE, ch, flag); 15079196d8acSJiri Slaby 15089196d8acSJiri Slaby ignore_char: 15099196d8acSJiri Slaby lsr = serial_in(up, UART_LSR); 1510c904375dSFrans Klaver } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (--max_count > 0)); 15119196d8acSJiri Slaby spin_unlock(&port->lock); 15129196d8acSJiri Slaby tty_flip_buffer_push(&port->state->port); 15139196d8acSJiri Slaby spin_lock(&port->lock); 15149196d8acSJiri Slaby return lsr; 15159196d8acSJiri Slaby } 15169196d8acSJiri Slaby EXPORT_SYMBOL_GPL(serial8250_rx_chars); 15179196d8acSJiri Slaby 15189196d8acSJiri Slaby void serial8250_tx_chars(struct uart_8250_port *up) 15199196d8acSJiri Slaby { 15209196d8acSJiri Slaby struct uart_port *port = &up->port; 15219196d8acSJiri Slaby struct circ_buf *xmit = &port->state->xmit; 15229196d8acSJiri Slaby int count; 15239196d8acSJiri Slaby 15249196d8acSJiri Slaby if (port->x_char) { 15259196d8acSJiri Slaby serial_out(up, UART_TX, port->x_char); 15269196d8acSJiri Slaby port->icount.tx++; 15279196d8acSJiri Slaby port->x_char = 0; 15289196d8acSJiri Slaby return; 15299196d8acSJiri Slaby } 15309196d8acSJiri Slaby if (uart_tx_stopped(port)) { 15319196d8acSJiri Slaby serial8250_stop_tx(port); 15329196d8acSJiri Slaby return; 15339196d8acSJiri Slaby } 15349196d8acSJiri Slaby if (uart_circ_empty(xmit)) { 15359196d8acSJiri Slaby __stop_tx(up); 15369196d8acSJiri Slaby return; 15379196d8acSJiri Slaby } 15389196d8acSJiri Slaby 15399196d8acSJiri Slaby count = up->tx_loadsz; 15409196d8acSJiri Slaby do { 15419196d8acSJiri Slaby serial_out(up, UART_TX, xmit->buf[xmit->tail]); 15429196d8acSJiri Slaby xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 15439196d8acSJiri Slaby port->icount.tx++; 15449196d8acSJiri Slaby if (uart_circ_empty(xmit)) 15459196d8acSJiri Slaby break; 15469196d8acSJiri Slaby if (up->capabilities & UART_CAP_HFIFO) { 15479196d8acSJiri Slaby if ((serial_port_in(port, UART_LSR) & BOTH_EMPTY) != 15489196d8acSJiri Slaby BOTH_EMPTY) 15499196d8acSJiri Slaby break; 15509196d8acSJiri Slaby } 15519196d8acSJiri Slaby } while (--count > 0); 15529196d8acSJiri Slaby 15539196d8acSJiri Slaby if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 15549196d8acSJiri Slaby uart_write_wakeup(port); 15559196d8acSJiri Slaby 15569196d8acSJiri Slaby DEBUG_INTR("THRE..."); 15579196d8acSJiri Slaby 1558d74d5d1bSSebastian Andrzej Siewior /* 15596a529abaSSebastian Andrzej Siewior * With RPM enabled, we have to wait until the FIFO is empty before the 1560d74d5d1bSSebastian Andrzej Siewior * HW can go idle. So we get here once again with empty FIFO and disable 1561d74d5d1bSSebastian Andrzej Siewior * the interrupt and RPM in __stop_tx() 1562d74d5d1bSSebastian Andrzej Siewior */ 1563d74d5d1bSSebastian Andrzej Siewior if (uart_circ_empty(xmit) && !(up->capabilities & UART_CAP_RPM)) 15649196d8acSJiri Slaby __stop_tx(up); 15659196d8acSJiri Slaby } 15669196d8acSJiri Slaby EXPORT_SYMBOL_GPL(serial8250_tx_chars); 15679196d8acSJiri Slaby 15685435d20fSPeter Hurley /* Caller holds uart port lock */ 15699196d8acSJiri Slaby unsigned int serial8250_modem_status(struct uart_8250_port *up) 15709196d8acSJiri Slaby { 15719196d8acSJiri Slaby struct uart_port *port = &up->port; 15729196d8acSJiri Slaby unsigned int status = serial_in(up, UART_MSR); 15739196d8acSJiri Slaby 15749196d8acSJiri Slaby status |= up->msr_saved_flags; 15759196d8acSJiri Slaby up->msr_saved_flags = 0; 15769196d8acSJiri Slaby if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI && 15779196d8acSJiri Slaby port->state != NULL) { 15789196d8acSJiri Slaby if (status & UART_MSR_TERI) 15799196d8acSJiri Slaby port->icount.rng++; 15809196d8acSJiri Slaby if (status & UART_MSR_DDSR) 15819196d8acSJiri Slaby port->icount.dsr++; 15829196d8acSJiri Slaby if (status & UART_MSR_DDCD) 15839196d8acSJiri Slaby uart_handle_dcd_change(port, status & UART_MSR_DCD); 15849196d8acSJiri Slaby if (status & UART_MSR_DCTS) 15859196d8acSJiri Slaby uart_handle_cts_change(port, status & UART_MSR_CTS); 15869196d8acSJiri Slaby 15879196d8acSJiri Slaby wake_up_interruptible(&port->state->port.delta_msr_wait); 15889196d8acSJiri Slaby } 15899196d8acSJiri Slaby 15909196d8acSJiri Slaby return status; 15919196d8acSJiri Slaby } 15929196d8acSJiri Slaby EXPORT_SYMBOL_GPL(serial8250_modem_status); 15939196d8acSJiri Slaby 15949196d8acSJiri Slaby /* 15959196d8acSJiri Slaby * This handles the interrupt from one port. 15969196d8acSJiri Slaby */ 15979196d8acSJiri Slaby int serial8250_handle_irq(struct uart_port *port, unsigned int iir) 15989196d8acSJiri Slaby { 15999196d8acSJiri Slaby unsigned char status; 16009196d8acSJiri Slaby unsigned long flags; 1601b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 16029196d8acSJiri Slaby int dma_err = 0; 16039196d8acSJiri Slaby 16049196d8acSJiri Slaby if (iir & UART_IIR_NO_INT) 16059196d8acSJiri Slaby return 0; 16069196d8acSJiri Slaby 16079196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 16089196d8acSJiri Slaby 16099196d8acSJiri Slaby status = serial_port_in(port, UART_LSR); 16109196d8acSJiri Slaby 16119196d8acSJiri Slaby DEBUG_INTR("status = %x...", status); 16129196d8acSJiri Slaby 16139196d8acSJiri Slaby if (status & (UART_LSR_DR | UART_LSR_BI)) { 16149196d8acSJiri Slaby if (up->dma) 1615f1a297bbSSebastian Andrzej Siewior dma_err = up->dma->rx_dma(up, iir); 16169196d8acSJiri Slaby 16179196d8acSJiri Slaby if (!up->dma || dma_err) 16189196d8acSJiri Slaby status = serial8250_rx_chars(up, status); 16199196d8acSJiri Slaby } 16209196d8acSJiri Slaby serial8250_modem_status(up); 1621b2202821SSebastian Andrzej Siewior if ((!up->dma || (up->dma && up->dma->tx_err)) && 1622b2202821SSebastian Andrzej Siewior (status & UART_LSR_THRE)) 16239196d8acSJiri Slaby serial8250_tx_chars(up); 16249196d8acSJiri Slaby 16259196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 16269196d8acSJiri Slaby return 1; 16279196d8acSJiri Slaby } 16289196d8acSJiri Slaby EXPORT_SYMBOL_GPL(serial8250_handle_irq); 16299196d8acSJiri Slaby 16309196d8acSJiri Slaby static int serial8250_default_handle_irq(struct uart_port *port) 16319196d8acSJiri Slaby { 1632d74d5d1bSSebastian Andrzej Siewior struct uart_8250_port *up = up_to_u8250p(port); 1633d74d5d1bSSebastian Andrzej Siewior unsigned int iir; 1634d74d5d1bSSebastian Andrzej Siewior int ret; 16359196d8acSJiri Slaby 1636d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 1637d74d5d1bSSebastian Andrzej Siewior 1638d74d5d1bSSebastian Andrzej Siewior iir = serial_port_in(port, UART_IIR); 1639d74d5d1bSSebastian Andrzej Siewior ret = serial8250_handle_irq(port, iir); 1640d74d5d1bSSebastian Andrzej Siewior 1641d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 1642d74d5d1bSSebastian Andrzej Siewior return ret; 16439196d8acSJiri Slaby } 16449196d8acSJiri Slaby 16459196d8acSJiri Slaby /* 16469196d8acSJiri Slaby * These Exar UARTs have an extra interrupt indicator that could 16479196d8acSJiri Slaby * fire for a few unimplemented interrupts. One of which is a 16489196d8acSJiri Slaby * wakeup event when coming out of sleep. Put this here just 16499196d8acSJiri Slaby * to be on the safe side that these interrupts don't go unhandled. 16509196d8acSJiri Slaby */ 16519196d8acSJiri Slaby static int exar_handle_irq(struct uart_port *port) 16529196d8acSJiri Slaby { 16539196d8acSJiri Slaby unsigned char int0, int1, int2, int3; 16549196d8acSJiri Slaby unsigned int iir = serial_port_in(port, UART_IIR); 16559196d8acSJiri Slaby int ret; 16569196d8acSJiri Slaby 16579196d8acSJiri Slaby ret = serial8250_handle_irq(port, iir); 16589196d8acSJiri Slaby 16599196d8acSJiri Slaby if ((port->type == PORT_XR17V35X) || 16609196d8acSJiri Slaby (port->type == PORT_XR17D15X)) { 16619196d8acSJiri Slaby int0 = serial_port_in(port, 0x80); 16629196d8acSJiri Slaby int1 = serial_port_in(port, 0x81); 16639196d8acSJiri Slaby int2 = serial_port_in(port, 0x82); 16649196d8acSJiri Slaby int3 = serial_port_in(port, 0x83); 16659196d8acSJiri Slaby } 16669196d8acSJiri Slaby 16679196d8acSJiri Slaby return ret; 16689196d8acSJiri Slaby } 16699196d8acSJiri Slaby 16709196d8acSJiri Slaby /* 16719196d8acSJiri Slaby * This is the serial driver's interrupt routine. 16729196d8acSJiri Slaby * 16739196d8acSJiri Slaby * Arjan thinks the old way was overly complex, so it got simplified. 16749196d8acSJiri Slaby * Alan disagrees, saying that need the complexity to handle the weird 16759196d8acSJiri Slaby * nature of ISA shared interrupts. (This is a special exception.) 16769196d8acSJiri Slaby * 16779196d8acSJiri Slaby * In order to handle ISA shared interrupts properly, we need to check 16789196d8acSJiri Slaby * that all ports have been serviced, and therefore the ISA interrupt 16799196d8acSJiri Slaby * line has been de-asserted. 16809196d8acSJiri Slaby * 16819196d8acSJiri Slaby * This means we need to loop through all ports. checking that they 16829196d8acSJiri Slaby * don't have an interrupt pending. 16839196d8acSJiri Slaby */ 16849196d8acSJiri Slaby static irqreturn_t serial8250_interrupt(int irq, void *dev_id) 16859196d8acSJiri Slaby { 16869196d8acSJiri Slaby struct irq_info *i = dev_id; 16879196d8acSJiri Slaby struct list_head *l, *end = NULL; 16889196d8acSJiri Slaby int pass_counter = 0, handled = 0; 16899196d8acSJiri Slaby 16909196d8acSJiri Slaby DEBUG_INTR("serial8250_interrupt(%d)...", irq); 16919196d8acSJiri Slaby 16929196d8acSJiri Slaby spin_lock(&i->lock); 16939196d8acSJiri Slaby 16949196d8acSJiri Slaby l = i->head; 16959196d8acSJiri Slaby do { 16969196d8acSJiri Slaby struct uart_8250_port *up; 16979196d8acSJiri Slaby struct uart_port *port; 16989196d8acSJiri Slaby 16999196d8acSJiri Slaby up = list_entry(l, struct uart_8250_port, list); 17009196d8acSJiri Slaby port = &up->port; 17019196d8acSJiri Slaby 17029196d8acSJiri Slaby if (port->handle_irq(port)) { 17039196d8acSJiri Slaby handled = 1; 17049196d8acSJiri Slaby end = NULL; 17059196d8acSJiri Slaby } else if (end == NULL) 17069196d8acSJiri Slaby end = l; 17079196d8acSJiri Slaby 17089196d8acSJiri Slaby l = l->next; 17099196d8acSJiri Slaby 17109196d8acSJiri Slaby if (l == i->head && pass_counter++ > PASS_LIMIT) { 17119196d8acSJiri Slaby /* If we hit this, we're dead. */ 17129196d8acSJiri Slaby printk_ratelimited(KERN_ERR 17139196d8acSJiri Slaby "serial8250: too much work for irq%d\n", irq); 17149196d8acSJiri Slaby break; 17159196d8acSJiri Slaby } 17169196d8acSJiri Slaby } while (l != end); 17179196d8acSJiri Slaby 17189196d8acSJiri Slaby spin_unlock(&i->lock); 17199196d8acSJiri Slaby 17209196d8acSJiri Slaby DEBUG_INTR("end.\n"); 17219196d8acSJiri Slaby 17229196d8acSJiri Slaby return IRQ_RETVAL(handled); 17239196d8acSJiri Slaby } 17249196d8acSJiri Slaby 17259196d8acSJiri Slaby /* 17269196d8acSJiri Slaby * To support ISA shared interrupts, we need to have one interrupt 17279196d8acSJiri Slaby * handler that ensures that the IRQ line has been deasserted 17289196d8acSJiri Slaby * before returning. Failing to do this will result in the IRQ 17299196d8acSJiri Slaby * line being stuck active, and, since ISA irqs are edge triggered, 17309196d8acSJiri Slaby * no more IRQs will be seen. 17319196d8acSJiri Slaby */ 17329196d8acSJiri Slaby static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up) 17339196d8acSJiri Slaby { 17349196d8acSJiri Slaby spin_lock_irq(&i->lock); 17359196d8acSJiri Slaby 17369196d8acSJiri Slaby if (!list_empty(i->head)) { 17379196d8acSJiri Slaby if (i->head == &up->list) 17389196d8acSJiri Slaby i->head = i->head->next; 17399196d8acSJiri Slaby list_del(&up->list); 17409196d8acSJiri Slaby } else { 17419196d8acSJiri Slaby BUG_ON(i->head != &up->list); 17429196d8acSJiri Slaby i->head = NULL; 17439196d8acSJiri Slaby } 17449196d8acSJiri Slaby spin_unlock_irq(&i->lock); 17459196d8acSJiri Slaby /* List empty so throw away the hash node */ 17469196d8acSJiri Slaby if (i->head == NULL) { 17479196d8acSJiri Slaby hlist_del(&i->node); 17489196d8acSJiri Slaby kfree(i); 17499196d8acSJiri Slaby } 17509196d8acSJiri Slaby } 17519196d8acSJiri Slaby 17529196d8acSJiri Slaby static int serial_link_irq_chain(struct uart_8250_port *up) 17539196d8acSJiri Slaby { 17549196d8acSJiri Slaby struct hlist_head *h; 17559196d8acSJiri Slaby struct hlist_node *n; 17569196d8acSJiri Slaby struct irq_info *i; 17579196d8acSJiri Slaby int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0; 17589196d8acSJiri Slaby 17599196d8acSJiri Slaby mutex_lock(&hash_mutex); 17609196d8acSJiri Slaby 17619196d8acSJiri Slaby h = &irq_lists[up->port.irq % NR_IRQ_HASH]; 17629196d8acSJiri Slaby 17639196d8acSJiri Slaby hlist_for_each(n, h) { 17649196d8acSJiri Slaby i = hlist_entry(n, struct irq_info, node); 17659196d8acSJiri Slaby if (i->irq == up->port.irq) 17669196d8acSJiri Slaby break; 17679196d8acSJiri Slaby } 17689196d8acSJiri Slaby 17699196d8acSJiri Slaby if (n == NULL) { 17709196d8acSJiri Slaby i = kzalloc(sizeof(struct irq_info), GFP_KERNEL); 17719196d8acSJiri Slaby if (i == NULL) { 17729196d8acSJiri Slaby mutex_unlock(&hash_mutex); 17739196d8acSJiri Slaby return -ENOMEM; 17749196d8acSJiri Slaby } 17759196d8acSJiri Slaby spin_lock_init(&i->lock); 17769196d8acSJiri Slaby i->irq = up->port.irq; 17779196d8acSJiri Slaby hlist_add_head(&i->node, h); 17789196d8acSJiri Slaby } 17799196d8acSJiri Slaby mutex_unlock(&hash_mutex); 17809196d8acSJiri Slaby 17819196d8acSJiri Slaby spin_lock_irq(&i->lock); 17829196d8acSJiri Slaby 17839196d8acSJiri Slaby if (i->head) { 17849196d8acSJiri Slaby list_add(&up->list, i->head); 17859196d8acSJiri Slaby spin_unlock_irq(&i->lock); 17869196d8acSJiri Slaby 17879196d8acSJiri Slaby ret = 0; 17889196d8acSJiri Slaby } else { 17899196d8acSJiri Slaby INIT_LIST_HEAD(&up->list); 17909196d8acSJiri Slaby i->head = &up->list; 17919196d8acSJiri Slaby spin_unlock_irq(&i->lock); 17929196d8acSJiri Slaby irq_flags |= up->port.irqflags; 17939196d8acSJiri Slaby ret = request_irq(up->port.irq, serial8250_interrupt, 17949196d8acSJiri Slaby irq_flags, "serial", i); 17959196d8acSJiri Slaby if (ret < 0) 17969196d8acSJiri Slaby serial_do_unlink(i, up); 17979196d8acSJiri Slaby } 17989196d8acSJiri Slaby 17999196d8acSJiri Slaby return ret; 18009196d8acSJiri Slaby } 18019196d8acSJiri Slaby 18029196d8acSJiri Slaby static void serial_unlink_irq_chain(struct uart_8250_port *up) 18039196d8acSJiri Slaby { 1804bd2fe272SPaul Gortmaker /* 1805bd2fe272SPaul Gortmaker * yes, some broken gcc emit "warning: 'i' may be used uninitialized" 1806bd2fe272SPaul Gortmaker * but no, we are not going to take a patch that assigns NULL below. 1807bd2fe272SPaul Gortmaker */ 18089196d8acSJiri Slaby struct irq_info *i; 18099196d8acSJiri Slaby struct hlist_node *n; 18109196d8acSJiri Slaby struct hlist_head *h; 18119196d8acSJiri Slaby 18129196d8acSJiri Slaby mutex_lock(&hash_mutex); 18139196d8acSJiri Slaby 18149196d8acSJiri Slaby h = &irq_lists[up->port.irq % NR_IRQ_HASH]; 18159196d8acSJiri Slaby 18169196d8acSJiri Slaby hlist_for_each(n, h) { 18179196d8acSJiri Slaby i = hlist_entry(n, struct irq_info, node); 18189196d8acSJiri Slaby if (i->irq == up->port.irq) 18199196d8acSJiri Slaby break; 18209196d8acSJiri Slaby } 18219196d8acSJiri Slaby 18229196d8acSJiri Slaby BUG_ON(n == NULL); 18239196d8acSJiri Slaby BUG_ON(i->head == NULL); 18249196d8acSJiri Slaby 18259196d8acSJiri Slaby if (list_empty(i->head)) 18269196d8acSJiri Slaby free_irq(up->port.irq, i); 18279196d8acSJiri Slaby 18289196d8acSJiri Slaby serial_do_unlink(i, up); 18299196d8acSJiri Slaby mutex_unlock(&hash_mutex); 18309196d8acSJiri Slaby } 18319196d8acSJiri Slaby 18329196d8acSJiri Slaby /* 18339196d8acSJiri Slaby * This function is used to handle ports that do not have an 18349196d8acSJiri Slaby * interrupt. This doesn't work very well for 16450's, but gives 18359196d8acSJiri Slaby * barely passable results for a 16550A. (Although at the expense 18369196d8acSJiri Slaby * of much CPU overhead). 18379196d8acSJiri Slaby */ 18389196d8acSJiri Slaby static void serial8250_timeout(unsigned long data) 18399196d8acSJiri Slaby { 18409196d8acSJiri Slaby struct uart_8250_port *up = (struct uart_8250_port *)data; 18419196d8acSJiri Slaby 18429196d8acSJiri Slaby up->port.handle_irq(&up->port); 18439196d8acSJiri Slaby mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port)); 18449196d8acSJiri Slaby } 18459196d8acSJiri Slaby 18469196d8acSJiri Slaby static void serial8250_backup_timeout(unsigned long data) 18479196d8acSJiri Slaby { 18489196d8acSJiri Slaby struct uart_8250_port *up = (struct uart_8250_port *)data; 18499196d8acSJiri Slaby unsigned int iir, ier = 0, lsr; 18509196d8acSJiri Slaby unsigned long flags; 18519196d8acSJiri Slaby 18529196d8acSJiri Slaby spin_lock_irqsave(&up->port.lock, flags); 18539196d8acSJiri Slaby 18549196d8acSJiri Slaby /* 18559196d8acSJiri Slaby * Must disable interrupts or else we risk racing with the interrupt 18569196d8acSJiri Slaby * based handler. 18579196d8acSJiri Slaby */ 18589196d8acSJiri Slaby if (up->port.irq) { 18599196d8acSJiri Slaby ier = serial_in(up, UART_IER); 18609196d8acSJiri Slaby serial_out(up, UART_IER, 0); 18619196d8acSJiri Slaby } 18629196d8acSJiri Slaby 18639196d8acSJiri Slaby iir = serial_in(up, UART_IIR); 18649196d8acSJiri Slaby 18659196d8acSJiri Slaby /* 18669196d8acSJiri Slaby * This should be a safe test for anyone who doesn't trust the 18679196d8acSJiri Slaby * IIR bits on their UART, but it's specifically designed for 18689196d8acSJiri Slaby * the "Diva" UART used on the management processor on many HP 18699196d8acSJiri Slaby * ia64 and parisc boxes. 18709196d8acSJiri Slaby */ 18719196d8acSJiri Slaby lsr = serial_in(up, UART_LSR); 18729196d8acSJiri Slaby up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS; 18739196d8acSJiri Slaby if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) && 18749196d8acSJiri Slaby (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) && 18759196d8acSJiri Slaby (lsr & UART_LSR_THRE)) { 18769196d8acSJiri Slaby iir &= ~(UART_IIR_ID | UART_IIR_NO_INT); 18779196d8acSJiri Slaby iir |= UART_IIR_THRI; 18789196d8acSJiri Slaby } 18799196d8acSJiri Slaby 18809196d8acSJiri Slaby if (!(iir & UART_IIR_NO_INT)) 18819196d8acSJiri Slaby serial8250_tx_chars(up); 18829196d8acSJiri Slaby 18839196d8acSJiri Slaby if (up->port.irq) 18849196d8acSJiri Slaby serial_out(up, UART_IER, ier); 18859196d8acSJiri Slaby 18869196d8acSJiri Slaby spin_unlock_irqrestore(&up->port.lock, flags); 18879196d8acSJiri Slaby 18889196d8acSJiri Slaby /* Standard timer interval plus 0.2s to keep the port running */ 18899196d8acSJiri Slaby mod_timer(&up->timer, 18909196d8acSJiri Slaby jiffies + uart_poll_timeout(&up->port) + HZ / 5); 18919196d8acSJiri Slaby } 18929196d8acSJiri Slaby 1893a4416cd1SPeter Hurley static int univ8250_setup_irq(struct uart_8250_port *up) 1894a4416cd1SPeter Hurley { 1895a4416cd1SPeter Hurley struct uart_port *port = &up->port; 1896a4416cd1SPeter Hurley int retval = 0; 1897a4416cd1SPeter Hurley 1898a4416cd1SPeter Hurley /* 1899a4416cd1SPeter Hurley * The above check will only give an accurate result the first time 1900a4416cd1SPeter Hurley * the port is opened so this value needs to be preserved. 1901a4416cd1SPeter Hurley */ 1902a4416cd1SPeter Hurley if (up->bugs & UART_BUG_THRE) { 1903a4416cd1SPeter Hurley pr_debug("ttyS%d - using backup timer\n", serial_index(port)); 1904a4416cd1SPeter Hurley 1905a4416cd1SPeter Hurley up->timer.function = serial8250_backup_timeout; 1906a4416cd1SPeter Hurley up->timer.data = (unsigned long)up; 1907a4416cd1SPeter Hurley mod_timer(&up->timer, jiffies + 1908a4416cd1SPeter Hurley uart_poll_timeout(port) + HZ / 5); 1909a4416cd1SPeter Hurley } 1910a4416cd1SPeter Hurley 1911a4416cd1SPeter Hurley /* 1912a4416cd1SPeter Hurley * If the "interrupt" for this port doesn't correspond with any 1913a4416cd1SPeter Hurley * hardware interrupt, we use a timer-based system. The original 1914a4416cd1SPeter Hurley * driver used to do this with IRQ0. 1915a4416cd1SPeter Hurley */ 1916a4416cd1SPeter Hurley if (!port->irq) { 1917a4416cd1SPeter Hurley up->timer.data = (unsigned long)up; 1918a4416cd1SPeter Hurley mod_timer(&up->timer, jiffies + uart_poll_timeout(port)); 1919a4416cd1SPeter Hurley } else 1920a4416cd1SPeter Hurley retval = serial_link_irq_chain(up); 1921a4416cd1SPeter Hurley 1922a4416cd1SPeter Hurley return retval; 1923a4416cd1SPeter Hurley } 1924a4416cd1SPeter Hurley 1925a4416cd1SPeter Hurley static void univ8250_release_irq(struct uart_8250_port *up) 1926a4416cd1SPeter Hurley { 1927a4416cd1SPeter Hurley struct uart_port *port = &up->port; 1928a4416cd1SPeter Hurley 1929a4416cd1SPeter Hurley del_timer_sync(&up->timer); 1930a4416cd1SPeter Hurley up->timer.function = serial8250_timeout; 1931a4416cd1SPeter Hurley if (port->irq) 1932a4416cd1SPeter Hurley serial_unlink_irq_chain(up); 1933a4416cd1SPeter Hurley } 1934a4416cd1SPeter Hurley 19359196d8acSJiri Slaby static unsigned int serial8250_tx_empty(struct uart_port *port) 19369196d8acSJiri Slaby { 1937b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 19389196d8acSJiri Slaby unsigned long flags; 19399196d8acSJiri Slaby unsigned int lsr; 19409196d8acSJiri Slaby 1941d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 1942d74d5d1bSSebastian Andrzej Siewior 19439196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 19449196d8acSJiri Slaby lsr = serial_port_in(port, UART_LSR); 19459196d8acSJiri Slaby up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS; 19469196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 19479196d8acSJiri Slaby 1948d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 1949d74d5d1bSSebastian Andrzej Siewior 19509196d8acSJiri Slaby return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0; 19519196d8acSJiri Slaby } 19529196d8acSJiri Slaby 19539196d8acSJiri Slaby static unsigned int serial8250_get_mctrl(struct uart_port *port) 19549196d8acSJiri Slaby { 1955b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 19569196d8acSJiri Slaby unsigned int status; 19579196d8acSJiri Slaby unsigned int ret; 19589196d8acSJiri Slaby 1959d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 19609196d8acSJiri Slaby status = serial8250_modem_status(up); 1961d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 19629196d8acSJiri Slaby 19639196d8acSJiri Slaby ret = 0; 19649196d8acSJiri Slaby if (status & UART_MSR_DCD) 19659196d8acSJiri Slaby ret |= TIOCM_CAR; 19669196d8acSJiri Slaby if (status & UART_MSR_RI) 19679196d8acSJiri Slaby ret |= TIOCM_RNG; 19689196d8acSJiri Slaby if (status & UART_MSR_DSR) 19699196d8acSJiri Slaby ret |= TIOCM_DSR; 19709196d8acSJiri Slaby if (status & UART_MSR_CTS) 19719196d8acSJiri Slaby ret |= TIOCM_CTS; 19729196d8acSJiri Slaby return ret; 19739196d8acSJiri Slaby } 19749196d8acSJiri Slaby 19754bf4ea9dSPeter Hurley void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl) 19769196d8acSJiri Slaby { 1977b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 19789196d8acSJiri Slaby unsigned char mcr = 0; 19799196d8acSJiri Slaby 19809196d8acSJiri Slaby if (mctrl & TIOCM_RTS) 19819196d8acSJiri Slaby mcr |= UART_MCR_RTS; 19829196d8acSJiri Slaby if (mctrl & TIOCM_DTR) 19839196d8acSJiri Slaby mcr |= UART_MCR_DTR; 19849196d8acSJiri Slaby if (mctrl & TIOCM_OUT1) 19859196d8acSJiri Slaby mcr |= UART_MCR_OUT1; 19869196d8acSJiri Slaby if (mctrl & TIOCM_OUT2) 19879196d8acSJiri Slaby mcr |= UART_MCR_OUT2; 19889196d8acSJiri Slaby if (mctrl & TIOCM_LOOP) 19899196d8acSJiri Slaby mcr |= UART_MCR_LOOP; 19909196d8acSJiri Slaby 19919196d8acSJiri Slaby mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr; 19929196d8acSJiri Slaby 19939196d8acSJiri Slaby serial_port_out(port, UART_MCR, mcr); 19949196d8acSJiri Slaby } 19954bf4ea9dSPeter Hurley EXPORT_SYMBOL_GPL(serial8250_do_set_mctrl); 19964bf4ea9dSPeter Hurley 19974bf4ea9dSPeter Hurley static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl) 19984bf4ea9dSPeter Hurley { 19994bf4ea9dSPeter Hurley if (port->set_mctrl) 20004bf4ea9dSPeter Hurley return port->set_mctrl(port, mctrl); 20014bf4ea9dSPeter Hurley return serial8250_do_set_mctrl(port, mctrl); 20024bf4ea9dSPeter Hurley } 20039196d8acSJiri Slaby 20049196d8acSJiri Slaby static void serial8250_break_ctl(struct uart_port *port, int break_state) 20059196d8acSJiri Slaby { 2006b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 20079196d8acSJiri Slaby unsigned long flags; 20089196d8acSJiri Slaby 2009d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 20109196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 20119196d8acSJiri Slaby if (break_state == -1) 20129196d8acSJiri Slaby up->lcr |= UART_LCR_SBC; 20139196d8acSJiri Slaby else 20149196d8acSJiri Slaby up->lcr &= ~UART_LCR_SBC; 20159196d8acSJiri Slaby serial_port_out(port, UART_LCR, up->lcr); 20169196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 2017d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 20189196d8acSJiri Slaby } 20199196d8acSJiri Slaby 20209196d8acSJiri Slaby /* 20219196d8acSJiri Slaby * Wait for transmitter & holding register to empty 20229196d8acSJiri Slaby */ 20239196d8acSJiri Slaby static void wait_for_xmitr(struct uart_8250_port *up, int bits) 20249196d8acSJiri Slaby { 20259196d8acSJiri Slaby unsigned int status, tmout = 10000; 20269196d8acSJiri Slaby 20279196d8acSJiri Slaby /* Wait up to 10ms for the character(s) to be sent. */ 20289196d8acSJiri Slaby for (;;) { 20299196d8acSJiri Slaby status = serial_in(up, UART_LSR); 20309196d8acSJiri Slaby 20319196d8acSJiri Slaby up->lsr_saved_flags |= status & LSR_SAVE_FLAGS; 20329196d8acSJiri Slaby 20339196d8acSJiri Slaby if ((status & bits) == bits) 20349196d8acSJiri Slaby break; 20359196d8acSJiri Slaby if (--tmout == 0) 20369196d8acSJiri Slaby break; 20379196d8acSJiri Slaby udelay(1); 20389196d8acSJiri Slaby } 20399196d8acSJiri Slaby 20409196d8acSJiri Slaby /* Wait up to 1s for flow control if necessary */ 20419196d8acSJiri Slaby if (up->port.flags & UPF_CONS_FLOW) { 20429196d8acSJiri Slaby unsigned int tmout; 20439196d8acSJiri Slaby for (tmout = 1000000; tmout; tmout--) { 20449196d8acSJiri Slaby unsigned int msr = serial_in(up, UART_MSR); 20459196d8acSJiri Slaby up->msr_saved_flags |= msr & MSR_SAVE_FLAGS; 20469196d8acSJiri Slaby if (msr & UART_MSR_CTS) 20479196d8acSJiri Slaby break; 20489196d8acSJiri Slaby udelay(1); 20499196d8acSJiri Slaby touch_nmi_watchdog(); 20509196d8acSJiri Slaby } 20519196d8acSJiri Slaby } 20529196d8acSJiri Slaby } 20539196d8acSJiri Slaby 20549196d8acSJiri Slaby #ifdef CONFIG_CONSOLE_POLL 20559196d8acSJiri Slaby /* 20569196d8acSJiri Slaby * Console polling routines for writing and reading from the uart while 20579196d8acSJiri Slaby * in an interrupt or debug context. 20589196d8acSJiri Slaby */ 20599196d8acSJiri Slaby 20609196d8acSJiri Slaby static int serial8250_get_poll_char(struct uart_port *port) 20619196d8acSJiri Slaby { 2062d74d5d1bSSebastian Andrzej Siewior struct uart_8250_port *up = up_to_u8250p(port); 2063d74d5d1bSSebastian Andrzej Siewior unsigned char lsr; 2064d74d5d1bSSebastian Andrzej Siewior int status; 20659196d8acSJiri Slaby 2066d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 20679196d8acSJiri Slaby 2068d74d5d1bSSebastian Andrzej Siewior lsr = serial_port_in(port, UART_LSR); 2069d74d5d1bSSebastian Andrzej Siewior 2070d74d5d1bSSebastian Andrzej Siewior if (!(lsr & UART_LSR_DR)) { 2071d74d5d1bSSebastian Andrzej Siewior status = NO_POLL_CHAR; 2072d74d5d1bSSebastian Andrzej Siewior goto out; 2073d74d5d1bSSebastian Andrzej Siewior } 2074d74d5d1bSSebastian Andrzej Siewior 2075d74d5d1bSSebastian Andrzej Siewior status = serial_port_in(port, UART_RX); 2076d74d5d1bSSebastian Andrzej Siewior out: 2077d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 2078d74d5d1bSSebastian Andrzej Siewior return status; 20799196d8acSJiri Slaby } 20809196d8acSJiri Slaby 20819196d8acSJiri Slaby 20829196d8acSJiri Slaby static void serial8250_put_poll_char(struct uart_port *port, 20839196d8acSJiri Slaby unsigned char c) 20849196d8acSJiri Slaby { 20859196d8acSJiri Slaby unsigned int ier; 2086b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 20879196d8acSJiri Slaby 2088d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 20899196d8acSJiri Slaby /* 20909196d8acSJiri Slaby * First save the IER then disable the interrupts 20919196d8acSJiri Slaby */ 20929196d8acSJiri Slaby ier = serial_port_in(port, UART_IER); 20939196d8acSJiri Slaby if (up->capabilities & UART_CAP_UUE) 20949196d8acSJiri Slaby serial_port_out(port, UART_IER, UART_IER_UUE); 20959196d8acSJiri Slaby else 20969196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 20979196d8acSJiri Slaby 20989196d8acSJiri Slaby wait_for_xmitr(up, BOTH_EMPTY); 20999196d8acSJiri Slaby /* 21009196d8acSJiri Slaby * Send the character out. 21019196d8acSJiri Slaby */ 21029196d8acSJiri Slaby serial_port_out(port, UART_TX, c); 21039196d8acSJiri Slaby 21049196d8acSJiri Slaby /* 21059196d8acSJiri Slaby * Finally, wait for transmitter to become empty 21069196d8acSJiri Slaby * and restore the IER 21079196d8acSJiri Slaby */ 21089196d8acSJiri Slaby wait_for_xmitr(up, BOTH_EMPTY); 21099196d8acSJiri Slaby serial_port_out(port, UART_IER, ier); 2110d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 21119196d8acSJiri Slaby } 21129196d8acSJiri Slaby 21139196d8acSJiri Slaby #endif /* CONFIG_CONSOLE_POLL */ 21149196d8acSJiri Slaby 2115b99b121bSSebastian Andrzej Siewior int serial8250_do_startup(struct uart_port *port) 21169196d8acSJiri Slaby { 2117b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 21189196d8acSJiri Slaby unsigned long flags; 21199196d8acSJiri Slaby unsigned char lsr, iir; 21209196d8acSJiri Slaby int retval; 21219196d8acSJiri Slaby 21229196d8acSJiri Slaby if (port->type == PORT_8250_CIR) 21239196d8acSJiri Slaby return -ENODEV; 21249196d8acSJiri Slaby 21259196d8acSJiri Slaby if (!port->fifosize) 21269196d8acSJiri Slaby port->fifosize = uart_config[port->type].fifo_size; 21279196d8acSJiri Slaby if (!up->tx_loadsz) 21289196d8acSJiri Slaby up->tx_loadsz = uart_config[port->type].tx_loadsz; 21299196d8acSJiri Slaby if (!up->capabilities) 21309196d8acSJiri Slaby up->capabilities = uart_config[port->type].flags; 21319196d8acSJiri Slaby up->mcr = 0; 21329196d8acSJiri Slaby 21339196d8acSJiri Slaby if (port->iotype != up->cur_iotype) 21349196d8acSJiri Slaby set_io_from_upio(port); 21359196d8acSJiri Slaby 2136d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 21379196d8acSJiri Slaby if (port->type == PORT_16C950) { 21389196d8acSJiri Slaby /* Wake up and initialize UART */ 21399196d8acSJiri Slaby up->acr = 0; 21409196d8acSJiri Slaby serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B); 21419196d8acSJiri Slaby serial_port_out(port, UART_EFR, UART_EFR_ECB); 21429196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 21439196d8acSJiri Slaby serial_port_out(port, UART_LCR, 0); 21449196d8acSJiri Slaby serial_icr_write(up, UART_CSR, 0); /* Reset the UART */ 21459196d8acSJiri Slaby serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B); 21469196d8acSJiri Slaby serial_port_out(port, UART_EFR, UART_EFR_ECB); 21479196d8acSJiri Slaby serial_port_out(port, UART_LCR, 0); 21489196d8acSJiri Slaby } 21499196d8acSJiri Slaby 21509196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 21519196d8acSJiri Slaby /* 21529196d8acSJiri Slaby * If this is an RSA port, see if we can kick it up to the 21539196d8acSJiri Slaby * higher speed clock. 21549196d8acSJiri Slaby */ 21559196d8acSJiri Slaby enable_rsa(up); 21569196d8acSJiri Slaby #endif 21579196d8acSJiri Slaby /* 21589196d8acSJiri Slaby * Clear the FIFO buffers and disable them. 21599196d8acSJiri Slaby * (they will be reenabled in set_termios()) 21609196d8acSJiri Slaby */ 21619196d8acSJiri Slaby serial8250_clear_fifos(up); 21629196d8acSJiri Slaby 21639196d8acSJiri Slaby /* 21649196d8acSJiri Slaby * Clear the interrupt registers. 21659196d8acSJiri Slaby */ 2166ca8bb4aeSSebastian Andrzej Siewior serial_port_in(port, UART_LSR); 21679196d8acSJiri Slaby serial_port_in(port, UART_RX); 21689196d8acSJiri Slaby serial_port_in(port, UART_IIR); 21699196d8acSJiri Slaby serial_port_in(port, UART_MSR); 21709196d8acSJiri Slaby 21719196d8acSJiri Slaby /* 21729196d8acSJiri Slaby * At this point, there's no way the LSR could still be 0xff; 21739196d8acSJiri Slaby * if it is, then bail out, because there's likely no UART 21749196d8acSJiri Slaby * here. 21759196d8acSJiri Slaby */ 21769196d8acSJiri Slaby if (!(port->flags & UPF_BUGGY_UART) && 21779196d8acSJiri Slaby (serial_port_in(port, UART_LSR) == 0xff)) { 21789196d8acSJiri Slaby printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n", 21799196d8acSJiri Slaby serial_index(port)); 2180d74d5d1bSSebastian Andrzej Siewior retval = -ENODEV; 2181d74d5d1bSSebastian Andrzej Siewior goto out; 21829196d8acSJiri Slaby } 21839196d8acSJiri Slaby 21849196d8acSJiri Slaby /* 21859196d8acSJiri Slaby * For a XR16C850, we need to set the trigger levels 21869196d8acSJiri Slaby */ 21879196d8acSJiri Slaby if (port->type == PORT_16850) { 21889196d8acSJiri Slaby unsigned char fctr; 21899196d8acSJiri Slaby 21909196d8acSJiri Slaby serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); 21919196d8acSJiri Slaby 21929196d8acSJiri Slaby fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX); 21939196d8acSJiri Slaby serial_port_out(port, UART_FCTR, 21949196d8acSJiri Slaby fctr | UART_FCTR_TRGD | UART_FCTR_RX); 21959196d8acSJiri Slaby serial_port_out(port, UART_TRG, UART_TRG_96); 21969196d8acSJiri Slaby serial_port_out(port, UART_FCTR, 21979196d8acSJiri Slaby fctr | UART_FCTR_TRGD | UART_FCTR_TX); 21989196d8acSJiri Slaby serial_port_out(port, UART_TRG, UART_TRG_96); 21999196d8acSJiri Slaby 22009196d8acSJiri Slaby serial_port_out(port, UART_LCR, 0); 22019196d8acSJiri Slaby } 22029196d8acSJiri Slaby 22039196d8acSJiri Slaby if (port->irq) { 22049196d8acSJiri Slaby unsigned char iir1; 22059196d8acSJiri Slaby /* 22069196d8acSJiri Slaby * Test for UARTs that do not reassert THRE when the 22079196d8acSJiri Slaby * transmitter is idle and the interrupt has already 22089196d8acSJiri Slaby * been cleared. Real 16550s should always reassert 22099196d8acSJiri Slaby * this interrupt whenever the transmitter is idle and 22109196d8acSJiri Slaby * the interrupt is enabled. Delays are necessary to 22119196d8acSJiri Slaby * allow register changes to become visible. 22129196d8acSJiri Slaby */ 22139196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 22149196d8acSJiri Slaby if (up->port.irqflags & IRQF_SHARED) 22159196d8acSJiri Slaby disable_irq_nosync(port->irq); 22169196d8acSJiri Slaby 22179196d8acSJiri Slaby wait_for_xmitr(up, UART_LSR_THRE); 22189196d8acSJiri Slaby serial_port_out_sync(port, UART_IER, UART_IER_THRI); 22199196d8acSJiri Slaby udelay(1); /* allow THRE to set */ 22209196d8acSJiri Slaby iir1 = serial_port_in(port, UART_IIR); 22219196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 22229196d8acSJiri Slaby serial_port_out_sync(port, UART_IER, UART_IER_THRI); 22239196d8acSJiri Slaby udelay(1); /* allow a working UART time to re-assert THRE */ 22249196d8acSJiri Slaby iir = serial_port_in(port, UART_IIR); 22259196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 22269196d8acSJiri Slaby 22279196d8acSJiri Slaby if (port->irqflags & IRQF_SHARED) 22289196d8acSJiri Slaby enable_irq(port->irq); 22299196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 22309196d8acSJiri Slaby 22319196d8acSJiri Slaby /* 22329196d8acSJiri Slaby * If the interrupt is not reasserted, or we otherwise 22339196d8acSJiri Slaby * don't trust the iir, setup a timer to kick the UART 22349196d8acSJiri Slaby * on a regular basis. 22359196d8acSJiri Slaby */ 22369196d8acSJiri Slaby if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) || 22379196d8acSJiri Slaby up->port.flags & UPF_BUG_THRE) { 22389196d8acSJiri Slaby up->bugs |= UART_BUG_THRE; 22399196d8acSJiri Slaby } 22409196d8acSJiri Slaby } 22419196d8acSJiri Slaby 2242a4416cd1SPeter Hurley retval = up->ops->setup_irq(up); 22439196d8acSJiri Slaby if (retval) 2244d74d5d1bSSebastian Andrzej Siewior goto out; 22459196d8acSJiri Slaby 22469196d8acSJiri Slaby /* 22479196d8acSJiri Slaby * Now, initialize the UART 22489196d8acSJiri Slaby */ 22499196d8acSJiri Slaby serial_port_out(port, UART_LCR, UART_LCR_WLEN8); 22509196d8acSJiri Slaby 22519196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 22529196d8acSJiri Slaby if (up->port.flags & UPF_FOURPORT) { 22539196d8acSJiri Slaby if (!up->port.irq) 22549196d8acSJiri Slaby up->port.mctrl |= TIOCM_OUT1; 22559196d8acSJiri Slaby } else 22569196d8acSJiri Slaby /* 22579196d8acSJiri Slaby * Most PC uarts need OUT2 raised to enable interrupts. 22589196d8acSJiri Slaby */ 22599196d8acSJiri Slaby if (port->irq) 22609196d8acSJiri Slaby up->port.mctrl |= TIOCM_OUT2; 22619196d8acSJiri Slaby 22629196d8acSJiri Slaby serial8250_set_mctrl(port, port->mctrl); 22639196d8acSJiri Slaby 22649196d8acSJiri Slaby /* Serial over Lan (SoL) hack: 22659196d8acSJiri Slaby Intel 8257x Gigabit ethernet chips have a 22669196d8acSJiri Slaby 16550 emulation, to be used for Serial Over Lan. 22679196d8acSJiri Slaby Those chips take a longer time than a normal 22689196d8acSJiri Slaby serial device to signalize that a transmission 22699196d8acSJiri Slaby data was queued. Due to that, the above test generally 22709196d8acSJiri Slaby fails. One solution would be to delay the reading of 22719196d8acSJiri Slaby iir. However, this is not reliable, since the timeout 22729196d8acSJiri Slaby is variable. So, let's just don't test if we receive 22739196d8acSJiri Slaby TX irq. This way, we'll never enable UART_BUG_TXEN. 22749196d8acSJiri Slaby */ 2275e13cb72bSPeter Hurley if (up->port.flags & UPF_NO_TXEN_TEST) 22769196d8acSJiri Slaby goto dont_test_tx_en; 22779196d8acSJiri Slaby 22789196d8acSJiri Slaby /* 22799196d8acSJiri Slaby * Do a quick test to see if we receive an 22809196d8acSJiri Slaby * interrupt when we enable the TX irq. 22819196d8acSJiri Slaby */ 22829196d8acSJiri Slaby serial_port_out(port, UART_IER, UART_IER_THRI); 22839196d8acSJiri Slaby lsr = serial_port_in(port, UART_LSR); 22849196d8acSJiri Slaby iir = serial_port_in(port, UART_IIR); 22859196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 22869196d8acSJiri Slaby 22879196d8acSJiri Slaby if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) { 22889196d8acSJiri Slaby if (!(up->bugs & UART_BUG_TXEN)) { 22899196d8acSJiri Slaby up->bugs |= UART_BUG_TXEN; 22909196d8acSJiri Slaby pr_debug("ttyS%d - enabling bad tx status workarounds\n", 22919196d8acSJiri Slaby serial_index(port)); 22929196d8acSJiri Slaby } 22939196d8acSJiri Slaby } else { 22949196d8acSJiri Slaby up->bugs &= ~UART_BUG_TXEN; 22959196d8acSJiri Slaby } 22969196d8acSJiri Slaby 22979196d8acSJiri Slaby dont_test_tx_en: 22989196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 22999196d8acSJiri Slaby 23009196d8acSJiri Slaby /* 23019196d8acSJiri Slaby * Clear the interrupt registers again for luck, and clear the 23029196d8acSJiri Slaby * saved flags to avoid getting false values from polling 23039196d8acSJiri Slaby * routines or the previous session. 23049196d8acSJiri Slaby */ 2305ca8bb4aeSSebastian Andrzej Siewior serial_port_in(port, UART_LSR); 23069196d8acSJiri Slaby serial_port_in(port, UART_RX); 23079196d8acSJiri Slaby serial_port_in(port, UART_IIR); 23089196d8acSJiri Slaby serial_port_in(port, UART_MSR); 23099196d8acSJiri Slaby up->lsr_saved_flags = 0; 23109196d8acSJiri Slaby up->msr_saved_flags = 0; 23119196d8acSJiri Slaby 23129196d8acSJiri Slaby /* 23139196d8acSJiri Slaby * Request DMA channels for both RX and TX. 23149196d8acSJiri Slaby */ 23159196d8acSJiri Slaby if (up->dma) { 23169196d8acSJiri Slaby retval = serial8250_request_dma(up); 23179196d8acSJiri Slaby if (retval) { 23189196d8acSJiri Slaby pr_warn_ratelimited("ttyS%d - failed to request DMA\n", 23199196d8acSJiri Slaby serial_index(port)); 23209196d8acSJiri Slaby up->dma = NULL; 23219196d8acSJiri Slaby } 23229196d8acSJiri Slaby } 23239196d8acSJiri Slaby 23249196d8acSJiri Slaby /* 23259196d8acSJiri Slaby * Finally, enable interrupts. Note: Modem status interrupts 23269196d8acSJiri Slaby * are set via set_termios(), which will be occurring imminently 23279196d8acSJiri Slaby * anyway, so we don't enable them here. 23289196d8acSJiri Slaby */ 23299196d8acSJiri Slaby up->ier = UART_IER_RLSI | UART_IER_RDI; 23309196d8acSJiri Slaby serial_port_out(port, UART_IER, up->ier); 23319196d8acSJiri Slaby 23329196d8acSJiri Slaby if (port->flags & UPF_FOURPORT) { 23339196d8acSJiri Slaby unsigned int icp; 23349196d8acSJiri Slaby /* 23359196d8acSJiri Slaby * Enable interrupts on the AST Fourport board 23369196d8acSJiri Slaby */ 23379196d8acSJiri Slaby icp = (port->iobase & 0xfe0) | 0x01f; 23389196d8acSJiri Slaby outb_p(0x80, icp); 23399196d8acSJiri Slaby inb_p(icp); 23409196d8acSJiri Slaby } 2341d74d5d1bSSebastian Andrzej Siewior retval = 0; 2342d74d5d1bSSebastian Andrzej Siewior out: 2343d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 2344d74d5d1bSSebastian Andrzej Siewior return retval; 23459196d8acSJiri Slaby } 2346b99b121bSSebastian Andrzej Siewior EXPORT_SYMBOL_GPL(serial8250_do_startup); 23479196d8acSJiri Slaby 2348b99b121bSSebastian Andrzej Siewior static int serial8250_startup(struct uart_port *port) 2349b99b121bSSebastian Andrzej Siewior { 2350b99b121bSSebastian Andrzej Siewior if (port->startup) 2351b99b121bSSebastian Andrzej Siewior return port->startup(port); 2352b99b121bSSebastian Andrzej Siewior return serial8250_do_startup(port); 23539196d8acSJiri Slaby } 23549196d8acSJiri Slaby 2355b99b121bSSebastian Andrzej Siewior void serial8250_do_shutdown(struct uart_port *port) 23569196d8acSJiri Slaby { 2357b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 23589196d8acSJiri Slaby unsigned long flags; 23599196d8acSJiri Slaby 2360d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 23619196d8acSJiri Slaby /* 23629196d8acSJiri Slaby * Disable interrupts from this port 23639196d8acSJiri Slaby */ 23649196d8acSJiri Slaby up->ier = 0; 23659196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 23669196d8acSJiri Slaby 23679196d8acSJiri Slaby if (up->dma) 23689196d8acSJiri Slaby serial8250_release_dma(up); 23699196d8acSJiri Slaby 23709196d8acSJiri Slaby spin_lock_irqsave(&port->lock, flags); 23719196d8acSJiri Slaby if (port->flags & UPF_FOURPORT) { 23729196d8acSJiri Slaby /* reset interrupts on the AST Fourport board */ 23739196d8acSJiri Slaby inb((port->iobase & 0xfe0) | 0x1f); 23749196d8acSJiri Slaby port->mctrl |= TIOCM_OUT1; 23759196d8acSJiri Slaby } else 23769196d8acSJiri Slaby port->mctrl &= ~TIOCM_OUT2; 23779196d8acSJiri Slaby 23789196d8acSJiri Slaby serial8250_set_mctrl(port, port->mctrl); 23799196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 23809196d8acSJiri Slaby 23819196d8acSJiri Slaby /* 23829196d8acSJiri Slaby * Disable break condition and FIFOs 23839196d8acSJiri Slaby */ 23849196d8acSJiri Slaby serial_port_out(port, UART_LCR, 23859196d8acSJiri Slaby serial_port_in(port, UART_LCR) & ~UART_LCR_SBC); 23869196d8acSJiri Slaby serial8250_clear_fifos(up); 23879196d8acSJiri Slaby 23889196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 23899196d8acSJiri Slaby /* 23909196d8acSJiri Slaby * Reset the RSA board back to 115kbps compat mode. 23919196d8acSJiri Slaby */ 23929196d8acSJiri Slaby disable_rsa(up); 23939196d8acSJiri Slaby #endif 23949196d8acSJiri Slaby 23959196d8acSJiri Slaby /* 23969196d8acSJiri Slaby * Read data port to reset things, and then unlink from 23979196d8acSJiri Slaby * the IRQ chain. 23989196d8acSJiri Slaby */ 23999196d8acSJiri Slaby serial_port_in(port, UART_RX); 2400d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 24019196d8acSJiri Slaby 2402a4416cd1SPeter Hurley up->ops->release_irq(up); 24039196d8acSJiri Slaby } 2404b99b121bSSebastian Andrzej Siewior EXPORT_SYMBOL_GPL(serial8250_do_shutdown); 2405b99b121bSSebastian Andrzej Siewior 2406b99b121bSSebastian Andrzej Siewior static void serial8250_shutdown(struct uart_port *port) 2407b99b121bSSebastian Andrzej Siewior { 2408b99b121bSSebastian Andrzej Siewior if (port->shutdown) 2409b99b121bSSebastian Andrzej Siewior port->shutdown(port); 2410b99b121bSSebastian Andrzej Siewior else 2411b99b121bSSebastian Andrzej Siewior serial8250_do_shutdown(port); 2412b99b121bSSebastian Andrzej Siewior } 24139196d8acSJiri Slaby 241406a4c710SPeter Hurley /* 241506a4c710SPeter Hurley * XR17V35x UARTs have an extra fractional divisor register (DLD) 241606a4c710SPeter Hurley * Calculate divisor with extra 4-bit fractional portion 241706a4c710SPeter Hurley */ 241806a4c710SPeter Hurley static unsigned int xr17v35x_get_divisor(struct uart_8250_port *up, 241906a4c710SPeter Hurley unsigned int baud, 242006a4c710SPeter Hurley unsigned int *frac) 242106a4c710SPeter Hurley { 242206a4c710SPeter Hurley struct uart_port *port = &up->port; 242306a4c710SPeter Hurley unsigned int quot_16; 242406a4c710SPeter Hurley 242506a4c710SPeter Hurley quot_16 = DIV_ROUND_CLOSEST(port->uartclk, baud); 242606a4c710SPeter Hurley *frac = quot_16 & 0x0f; 242706a4c710SPeter Hurley 242806a4c710SPeter Hurley return quot_16 >> 4; 242906a4c710SPeter Hurley } 243006a4c710SPeter Hurley 243106a4c710SPeter Hurley static unsigned int serial8250_get_divisor(struct uart_8250_port *up, 243206a4c710SPeter Hurley unsigned int baud, 243306a4c710SPeter Hurley unsigned int *frac) 24349196d8acSJiri Slaby { 2435d1f2f219SPeter Hurley struct uart_port *port = &up->port; 24369196d8acSJiri Slaby unsigned int quot; 24379196d8acSJiri Slaby 24389196d8acSJiri Slaby /* 24399196d8acSJiri Slaby * Handle magic divisors for baud rates above baud_base on 24409196d8acSJiri Slaby * SMSC SuperIO chips. 244106a4c710SPeter Hurley * 24429196d8acSJiri Slaby */ 24439196d8acSJiri Slaby if ((port->flags & UPF_MAGIC_MULTIPLIER) && 24449196d8acSJiri Slaby baud == (port->uartclk/4)) 24459196d8acSJiri Slaby quot = 0x8001; 24469196d8acSJiri Slaby else if ((port->flags & UPF_MAGIC_MULTIPLIER) && 24479196d8acSJiri Slaby baud == (port->uartclk/8)) 24489196d8acSJiri Slaby quot = 0x8002; 244906a4c710SPeter Hurley else if (up->port.type == PORT_XR17V35X) 245006a4c710SPeter Hurley quot = xr17v35x_get_divisor(up, baud, frac); 24519196d8acSJiri Slaby else 24529196d8acSJiri Slaby quot = uart_get_divisor(port, baud); 24539196d8acSJiri Slaby 2454d1f2f219SPeter Hurley /* 2455d1f2f219SPeter Hurley * Oxford Semi 952 rev B workaround 2456d1f2f219SPeter Hurley */ 2457d1f2f219SPeter Hurley if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0) 2458d1f2f219SPeter Hurley quot++; 2459d1f2f219SPeter Hurley 24609196d8acSJiri Slaby return quot; 24619196d8acSJiri Slaby } 24629196d8acSJiri Slaby 24630ec3f585SPeter Hurley static unsigned char serial8250_compute_lcr(struct uart_8250_port *up, 24640ec3f585SPeter Hurley tcflag_t c_cflag) 24659196d8acSJiri Slaby { 2466aef9a7bdSYoshihiro YUNOMAE unsigned char cval; 24679196d8acSJiri Slaby 24680ec3f585SPeter Hurley switch (c_cflag & CSIZE) { 24699196d8acSJiri Slaby case CS5: 24709196d8acSJiri Slaby cval = UART_LCR_WLEN5; 24719196d8acSJiri Slaby break; 24729196d8acSJiri Slaby case CS6: 24739196d8acSJiri Slaby cval = UART_LCR_WLEN6; 24749196d8acSJiri Slaby break; 24759196d8acSJiri Slaby case CS7: 24769196d8acSJiri Slaby cval = UART_LCR_WLEN7; 24779196d8acSJiri Slaby break; 24789196d8acSJiri Slaby default: 24799196d8acSJiri Slaby case CS8: 24809196d8acSJiri Slaby cval = UART_LCR_WLEN8; 24819196d8acSJiri Slaby break; 24829196d8acSJiri Slaby } 24839196d8acSJiri Slaby 24840ec3f585SPeter Hurley if (c_cflag & CSTOPB) 24859196d8acSJiri Slaby cval |= UART_LCR_STOP; 24860ec3f585SPeter Hurley if (c_cflag & PARENB) { 24879196d8acSJiri Slaby cval |= UART_LCR_PARITY; 24889196d8acSJiri Slaby if (up->bugs & UART_BUG_PARITY) 2489aef9a7bdSYoshihiro YUNOMAE up->fifo_bug = true; 24909196d8acSJiri Slaby } 24910ec3f585SPeter Hurley if (!(c_cflag & PARODD)) 24929196d8acSJiri Slaby cval |= UART_LCR_EPAR; 24939196d8acSJiri Slaby #ifdef CMSPAR 24940ec3f585SPeter Hurley if (c_cflag & CMSPAR) 24959196d8acSJiri Slaby cval |= UART_LCR_SPAR; 24969196d8acSJiri Slaby #endif 24979196d8acSJiri Slaby 24980ec3f585SPeter Hurley return cval; 24990ec3f585SPeter Hurley } 25000ec3f585SPeter Hurley 2501eb1527a8Skbuild test robot static void serial8250_set_divisor(struct uart_port *port, unsigned int baud, 250206a4c710SPeter Hurley unsigned int quot, unsigned int quot_frac) 2503e72abd5dSPeter Hurley { 2504e72abd5dSPeter Hurley struct uart_8250_port *up = up_to_u8250p(port); 2505e72abd5dSPeter Hurley 2506e72abd5dSPeter Hurley /* Workaround to enable 115200 baud on OMAP1510 internal ports */ 2507e72abd5dSPeter Hurley if (is_omap1510_8250(up)) { 2508e72abd5dSPeter Hurley if (baud == 115200) { 2509e72abd5dSPeter Hurley quot = 1; 2510e72abd5dSPeter Hurley serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1); 2511e72abd5dSPeter Hurley } else 2512e72abd5dSPeter Hurley serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0); 2513e72abd5dSPeter Hurley } 2514e72abd5dSPeter Hurley 2515e72abd5dSPeter Hurley /* 2516e72abd5dSPeter Hurley * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2, 2517e72abd5dSPeter Hurley * otherwise just set DLAB 2518e72abd5dSPeter Hurley */ 2519e72abd5dSPeter Hurley if (up->capabilities & UART_NATSEMI) 2520e72abd5dSPeter Hurley serial_port_out(port, UART_LCR, 0xe0); 2521e72abd5dSPeter Hurley else 2522e72abd5dSPeter Hurley serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB); 2523e72abd5dSPeter Hurley 2524e72abd5dSPeter Hurley serial_dl_write(up, quot); 2525e72abd5dSPeter Hurley 252606a4c710SPeter Hurley /* XR17V35x UARTs have an extra fractional divisor register (DLD) */ 252706a4c710SPeter Hurley if (up->port.type == PORT_XR17V35X) 252806a4c710SPeter Hurley serial_port_out(port, 0x2, quot_frac); 2529e72abd5dSPeter Hurley } 2530e72abd5dSPeter Hurley 25310ec3f585SPeter Hurley void 25320ec3f585SPeter Hurley serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios, 25330ec3f585SPeter Hurley struct ktermios *old) 25340ec3f585SPeter Hurley { 25350ec3f585SPeter Hurley struct uart_8250_port *up = up_to_u8250p(port); 25360ec3f585SPeter Hurley unsigned char cval; 25370ec3f585SPeter Hurley unsigned long flags; 253806a4c710SPeter Hurley unsigned int baud, quot, frac = 0; 25390ec3f585SPeter Hurley 25400ec3f585SPeter Hurley cval = serial8250_compute_lcr(up, termios->c_cflag); 25410ec3f585SPeter Hurley 25429196d8acSJiri Slaby /* 25439196d8acSJiri Slaby * Ask the core to calculate the divisor for us. 25449196d8acSJiri Slaby */ 25459196d8acSJiri Slaby baud = uart_get_baud_rate(port, termios, old, 25469196d8acSJiri Slaby port->uartclk / 16 / 0xffff, 25479196d8acSJiri Slaby port->uartclk / 16); 254806a4c710SPeter Hurley quot = serial8250_get_divisor(up, baud, &frac); 25499196d8acSJiri Slaby 2550e9cef862SPeter Hurley /* 2551e9cef862SPeter Hurley * Ok, we're now changing the port state. Do it with 2552e9cef862SPeter Hurley * interrupts disabled. 2553e9cef862SPeter Hurley */ 2554e9cef862SPeter Hurley serial8250_rpm_get(up); 2555e9cef862SPeter Hurley spin_lock_irqsave(&port->lock, flags); 2556e9cef862SPeter Hurley 2557e9cef862SPeter Hurley up->lcr = cval; /* Save computed LCR */ 2558e9cef862SPeter Hurley 25599196d8acSJiri Slaby if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) { 2560aef9a7bdSYoshihiro YUNOMAE /* NOTE: If fifo_bug is not set, a user can set RX_trigger. */ 2561aef9a7bdSYoshihiro YUNOMAE if ((baud < 2400 && !up->dma) || up->fifo_bug) { 2562aef9a7bdSYoshihiro YUNOMAE up->fcr &= ~UART_FCR_TRIGGER_MASK; 2563aef9a7bdSYoshihiro YUNOMAE up->fcr |= UART_FCR_TRIGGER_1; 25649196d8acSJiri Slaby } 25659196d8acSJiri Slaby } 25669196d8acSJiri Slaby 25679196d8acSJiri Slaby /* 25689196d8acSJiri Slaby * MCR-based auto flow control. When AFE is enabled, RTS will be 25699196d8acSJiri Slaby * deasserted when the receive FIFO contains more characters than 25709196d8acSJiri Slaby * the trigger, or the MCR RTS bit is cleared. In the case where 25719196d8acSJiri Slaby * the remote UART is not using CTS auto flow control, we must 25729196d8acSJiri Slaby * have sufficient FIFO entries for the latency of the remote 2573a6eec92eSPeter Hurley * UART to respond. IOW, at least 32 bytes of FIFO. 25749196d8acSJiri Slaby */ 2575a6eec92eSPeter Hurley if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) { 25769196d8acSJiri Slaby up->mcr &= ~UART_MCR_AFE; 25779196d8acSJiri Slaby if (termios->c_cflag & CRTSCTS) 25789196d8acSJiri Slaby up->mcr |= UART_MCR_AFE; 25799196d8acSJiri Slaby } 25809196d8acSJiri Slaby 25819196d8acSJiri Slaby /* 25829196d8acSJiri Slaby * Update the per-port timeout. 25839196d8acSJiri Slaby */ 25849196d8acSJiri Slaby uart_update_timeout(port, termios->c_cflag, baud); 25859196d8acSJiri Slaby 25869196d8acSJiri Slaby port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR; 25879196d8acSJiri Slaby if (termios->c_iflag & INPCK) 25889196d8acSJiri Slaby port->read_status_mask |= UART_LSR_FE | UART_LSR_PE; 2589ef8b9ddcSPeter Hurley if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK)) 25909196d8acSJiri Slaby port->read_status_mask |= UART_LSR_BI; 25919196d8acSJiri Slaby 25929196d8acSJiri Slaby /* 25939196d8acSJiri Slaby * Characteres to ignore 25949196d8acSJiri Slaby */ 25959196d8acSJiri Slaby port->ignore_status_mask = 0; 25969196d8acSJiri Slaby if (termios->c_iflag & IGNPAR) 25979196d8acSJiri Slaby port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE; 25989196d8acSJiri Slaby if (termios->c_iflag & IGNBRK) { 25999196d8acSJiri Slaby port->ignore_status_mask |= UART_LSR_BI; 26009196d8acSJiri Slaby /* 26019196d8acSJiri Slaby * If we're ignoring parity and break indicators, 26029196d8acSJiri Slaby * ignore overruns too (for real raw support). 26039196d8acSJiri Slaby */ 26049196d8acSJiri Slaby if (termios->c_iflag & IGNPAR) 26059196d8acSJiri Slaby port->ignore_status_mask |= UART_LSR_OE; 26069196d8acSJiri Slaby } 26079196d8acSJiri Slaby 26089196d8acSJiri Slaby /* 26099196d8acSJiri Slaby * ignore all characters if CREAD is not set 26109196d8acSJiri Slaby */ 26119196d8acSJiri Slaby if ((termios->c_cflag & CREAD) == 0) 26129196d8acSJiri Slaby port->ignore_status_mask |= UART_LSR_DR; 26139196d8acSJiri Slaby 26149196d8acSJiri Slaby /* 26159196d8acSJiri Slaby * CTS flow control flag and modem status interrupts 26169196d8acSJiri Slaby */ 26179196d8acSJiri Slaby up->ier &= ~UART_IER_MSI; 26189196d8acSJiri Slaby if (!(up->bugs & UART_BUG_NOMSR) && 26199196d8acSJiri Slaby UART_ENABLE_MS(&up->port, termios->c_cflag)) 26209196d8acSJiri Slaby up->ier |= UART_IER_MSI; 26219196d8acSJiri Slaby if (up->capabilities & UART_CAP_UUE) 26229196d8acSJiri Slaby up->ier |= UART_IER_UUE; 26239196d8acSJiri Slaby if (up->capabilities & UART_CAP_RTOIE) 26249196d8acSJiri Slaby up->ier |= UART_IER_RTOIE; 26259196d8acSJiri Slaby 26269196d8acSJiri Slaby serial_port_out(port, UART_IER, up->ier); 26279196d8acSJiri Slaby 26289196d8acSJiri Slaby if (up->capabilities & UART_CAP_EFR) { 26299196d8acSJiri Slaby unsigned char efr = 0; 26309196d8acSJiri Slaby /* 26319196d8acSJiri Slaby * TI16C752/Startech hardware flow control. FIXME: 26329196d8acSJiri Slaby * - TI16C752 requires control thresholds to be set. 26339196d8acSJiri Slaby * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled. 26349196d8acSJiri Slaby */ 26359196d8acSJiri Slaby if (termios->c_cflag & CRTSCTS) 26369196d8acSJiri Slaby efr |= UART_EFR_CTS; 26379196d8acSJiri Slaby 26389196d8acSJiri Slaby serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B); 26399196d8acSJiri Slaby if (port->flags & UPF_EXAR_EFR) 26409196d8acSJiri Slaby serial_port_out(port, UART_XR_EFR, efr); 26419196d8acSJiri Slaby else 26429196d8acSJiri Slaby serial_port_out(port, UART_EFR, efr); 26439196d8acSJiri Slaby } 26449196d8acSJiri Slaby 264506a4c710SPeter Hurley serial8250_set_divisor(port, baud, quot, frac); 264645a7bd63SJoe Schultz 264745a7bd63SJoe Schultz /* 26489196d8acSJiri Slaby * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR 26499196d8acSJiri Slaby * is written without DLAB set, this mode will be disabled. 26509196d8acSJiri Slaby */ 26519196d8acSJiri Slaby if (port->type == PORT_16750) 2652aef9a7bdSYoshihiro YUNOMAE serial_port_out(port, UART_FCR, up->fcr); 26539196d8acSJiri Slaby 2654e72abd5dSPeter Hurley serial_port_out(port, UART_LCR, up->lcr); /* reset DLAB */ 26559196d8acSJiri Slaby if (port->type != PORT_16750) { 26569196d8acSJiri Slaby /* emulated UARTs (Lucent Venus 167x) need two steps */ 2657aef9a7bdSYoshihiro YUNOMAE if (up->fcr & UART_FCR_ENABLE_FIFO) 26589196d8acSJiri Slaby serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO); 2659aef9a7bdSYoshihiro YUNOMAE serial_port_out(port, UART_FCR, up->fcr); /* set fcr */ 26609196d8acSJiri Slaby } 26619196d8acSJiri Slaby serial8250_set_mctrl(port, port->mctrl); 26629196d8acSJiri Slaby spin_unlock_irqrestore(&port->lock, flags); 2663d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 2664d74d5d1bSSebastian Andrzej Siewior 26659196d8acSJiri Slaby /* Don't rewrite B0 */ 26669196d8acSJiri Slaby if (tty_termios_baud_rate(termios)) 26679196d8acSJiri Slaby tty_termios_encode_baud_rate(termios, baud, baud); 26689196d8acSJiri Slaby } 26699196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_do_set_termios); 26709196d8acSJiri Slaby 26719196d8acSJiri Slaby static void 26729196d8acSJiri Slaby serial8250_set_termios(struct uart_port *port, struct ktermios *termios, 26739196d8acSJiri Slaby struct ktermios *old) 26749196d8acSJiri Slaby { 26759196d8acSJiri Slaby if (port->set_termios) 26769196d8acSJiri Slaby port->set_termios(port, termios, old); 26779196d8acSJiri Slaby else 26789196d8acSJiri Slaby serial8250_do_set_termios(port, termios, old); 26799196d8acSJiri Slaby } 26809196d8acSJiri Slaby 26819196d8acSJiri Slaby static void 2682732a84a0SPeter Hurley serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios) 26839196d8acSJiri Slaby { 2684732a84a0SPeter Hurley if (termios->c_line == N_PPS) { 26859196d8acSJiri Slaby port->flags |= UPF_HARDPPS_CD; 2686d41510ceSPeter Hurley spin_lock_irq(&port->lock); 26879196d8acSJiri Slaby serial8250_enable_ms(port); 2688d41510ceSPeter Hurley spin_unlock_irq(&port->lock); 2689cab68f89SPeter Hurley } else { 26909196d8acSJiri Slaby port->flags &= ~UPF_HARDPPS_CD; 2691cab68f89SPeter Hurley if (!UART_ENABLE_MS(port, termios->c_cflag)) { 2692cab68f89SPeter Hurley spin_lock_irq(&port->lock); 2693cab68f89SPeter Hurley serial8250_disable_ms(port); 2694cab68f89SPeter Hurley spin_unlock_irq(&port->lock); 2695cab68f89SPeter Hurley } 2696cab68f89SPeter Hurley } 26979196d8acSJiri Slaby } 26989196d8acSJiri Slaby 26999196d8acSJiri Slaby 27009196d8acSJiri Slaby void serial8250_do_pm(struct uart_port *port, unsigned int state, 27019196d8acSJiri Slaby unsigned int oldstate) 27029196d8acSJiri Slaby { 2703b1261c86SAndy Shevchenko struct uart_8250_port *p = up_to_u8250p(port); 27049196d8acSJiri Slaby 27059196d8acSJiri Slaby serial8250_set_sleep(p, state != 0); 27069196d8acSJiri Slaby } 27079196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_do_pm); 27089196d8acSJiri Slaby 27099196d8acSJiri Slaby static void 27109196d8acSJiri Slaby serial8250_pm(struct uart_port *port, unsigned int state, 27119196d8acSJiri Slaby unsigned int oldstate) 27129196d8acSJiri Slaby { 27139196d8acSJiri Slaby if (port->pm) 27149196d8acSJiri Slaby port->pm(port, state, oldstate); 27159196d8acSJiri Slaby else 27169196d8acSJiri Slaby serial8250_do_pm(port, state, oldstate); 27179196d8acSJiri Slaby } 27189196d8acSJiri Slaby 27199196d8acSJiri Slaby static unsigned int serial8250_port_size(struct uart_8250_port *pt) 27209196d8acSJiri Slaby { 27219b8777e3SJohn Crispin if (pt->port.iotype == UPIO_AU) { 27229b8777e3SJohn Crispin if (pt->port.type == PORT_RT2880) 27239b8777e3SJohn Crispin return 0x100; 27249196d8acSJiri Slaby return 0x1000; 27259b8777e3SJohn Crispin } 27269196d8acSJiri Slaby if (is_omap1_8250(pt)) 27279196d8acSJiri Slaby return 0x16 << pt->port.regshift; 27289196d8acSJiri Slaby 27299196d8acSJiri Slaby return 8 << pt->port.regshift; 27309196d8acSJiri Slaby } 27319196d8acSJiri Slaby 27329196d8acSJiri Slaby /* 27339196d8acSJiri Slaby * Resource handling. 27349196d8acSJiri Slaby */ 27359196d8acSJiri Slaby static int serial8250_request_std_resource(struct uart_8250_port *up) 27369196d8acSJiri Slaby { 27379196d8acSJiri Slaby unsigned int size = serial8250_port_size(up); 27389196d8acSJiri Slaby struct uart_port *port = &up->port; 27399196d8acSJiri Slaby int ret = 0; 27409196d8acSJiri Slaby 27419196d8acSJiri Slaby switch (port->iotype) { 27429196d8acSJiri Slaby case UPIO_AU: 27439196d8acSJiri Slaby case UPIO_TSI: 27449196d8acSJiri Slaby case UPIO_MEM32: 27459196d8acSJiri Slaby case UPIO_MEM: 27469196d8acSJiri Slaby if (!port->mapbase) 27479196d8acSJiri Slaby break; 27489196d8acSJiri Slaby 27499196d8acSJiri Slaby if (!request_mem_region(port->mapbase, size, "serial")) { 27509196d8acSJiri Slaby ret = -EBUSY; 27519196d8acSJiri Slaby break; 27529196d8acSJiri Slaby } 27539196d8acSJiri Slaby 27549196d8acSJiri Slaby if (port->flags & UPF_IOREMAP) { 27559196d8acSJiri Slaby port->membase = ioremap_nocache(port->mapbase, size); 27569196d8acSJiri Slaby if (!port->membase) { 27579196d8acSJiri Slaby release_mem_region(port->mapbase, size); 27589196d8acSJiri Slaby ret = -ENOMEM; 27599196d8acSJiri Slaby } 27609196d8acSJiri Slaby } 27619196d8acSJiri Slaby break; 27629196d8acSJiri Slaby 27639196d8acSJiri Slaby case UPIO_HUB6: 27649196d8acSJiri Slaby case UPIO_PORT: 27659196d8acSJiri Slaby if (!request_region(port->iobase, size, "serial")) 27669196d8acSJiri Slaby ret = -EBUSY; 27679196d8acSJiri Slaby break; 27689196d8acSJiri Slaby } 27699196d8acSJiri Slaby return ret; 27709196d8acSJiri Slaby } 27719196d8acSJiri Slaby 27729196d8acSJiri Slaby static void serial8250_release_std_resource(struct uart_8250_port *up) 27739196d8acSJiri Slaby { 27749196d8acSJiri Slaby unsigned int size = serial8250_port_size(up); 27759196d8acSJiri Slaby struct uart_port *port = &up->port; 27769196d8acSJiri Slaby 27779196d8acSJiri Slaby switch (port->iotype) { 27789196d8acSJiri Slaby case UPIO_AU: 27799196d8acSJiri Slaby case UPIO_TSI: 27809196d8acSJiri Slaby case UPIO_MEM32: 27819196d8acSJiri Slaby case UPIO_MEM: 27829196d8acSJiri Slaby if (!port->mapbase) 27839196d8acSJiri Slaby break; 27849196d8acSJiri Slaby 27859196d8acSJiri Slaby if (port->flags & UPF_IOREMAP) { 27869196d8acSJiri Slaby iounmap(port->membase); 27879196d8acSJiri Slaby port->membase = NULL; 27889196d8acSJiri Slaby } 27899196d8acSJiri Slaby 27909196d8acSJiri Slaby release_mem_region(port->mapbase, size); 27919196d8acSJiri Slaby break; 27929196d8acSJiri Slaby 27939196d8acSJiri Slaby case UPIO_HUB6: 27949196d8acSJiri Slaby case UPIO_PORT: 27959196d8acSJiri Slaby release_region(port->iobase, size); 27969196d8acSJiri Slaby break; 27979196d8acSJiri Slaby } 27989196d8acSJiri Slaby } 27999196d8acSJiri Slaby 28009196d8acSJiri Slaby static int serial8250_request_rsa_resource(struct uart_8250_port *up) 28019196d8acSJiri Slaby { 28029196d8acSJiri Slaby unsigned long start = UART_RSA_BASE << up->port.regshift; 28039196d8acSJiri Slaby unsigned int size = 8 << up->port.regshift; 28049196d8acSJiri Slaby struct uart_port *port = &up->port; 28059196d8acSJiri Slaby int ret = -EINVAL; 28069196d8acSJiri Slaby 28079196d8acSJiri Slaby switch (port->iotype) { 28089196d8acSJiri Slaby case UPIO_HUB6: 28099196d8acSJiri Slaby case UPIO_PORT: 28109196d8acSJiri Slaby start += port->iobase; 28119196d8acSJiri Slaby if (request_region(start, size, "serial-rsa")) 28129196d8acSJiri Slaby ret = 0; 28139196d8acSJiri Slaby else 28149196d8acSJiri Slaby ret = -EBUSY; 28159196d8acSJiri Slaby break; 28169196d8acSJiri Slaby } 28179196d8acSJiri Slaby 28189196d8acSJiri Slaby return ret; 28199196d8acSJiri Slaby } 28209196d8acSJiri Slaby 28219196d8acSJiri Slaby static void serial8250_release_rsa_resource(struct uart_8250_port *up) 28229196d8acSJiri Slaby { 28239196d8acSJiri Slaby unsigned long offset = UART_RSA_BASE << up->port.regshift; 28249196d8acSJiri Slaby unsigned int size = 8 << up->port.regshift; 28259196d8acSJiri Slaby struct uart_port *port = &up->port; 28269196d8acSJiri Slaby 28279196d8acSJiri Slaby switch (port->iotype) { 28289196d8acSJiri Slaby case UPIO_HUB6: 28299196d8acSJiri Slaby case UPIO_PORT: 28309196d8acSJiri Slaby release_region(port->iobase + offset, size); 28319196d8acSJiri Slaby break; 28329196d8acSJiri Slaby } 28339196d8acSJiri Slaby } 28349196d8acSJiri Slaby 28359196d8acSJiri Slaby static void serial8250_release_port(struct uart_port *port) 28369196d8acSJiri Slaby { 2837b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 28389196d8acSJiri Slaby 28399196d8acSJiri Slaby serial8250_release_std_resource(up); 28409196d8acSJiri Slaby if (port->type == PORT_RSA) 28419196d8acSJiri Slaby serial8250_release_rsa_resource(up); 28429196d8acSJiri Slaby } 28439196d8acSJiri Slaby 28449196d8acSJiri Slaby static int serial8250_request_port(struct uart_port *port) 28459196d8acSJiri Slaby { 2846b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 28479196d8acSJiri Slaby int ret; 28489196d8acSJiri Slaby 28499196d8acSJiri Slaby if (port->type == PORT_8250_CIR) 28509196d8acSJiri Slaby return -ENODEV; 28519196d8acSJiri Slaby 28529196d8acSJiri Slaby ret = serial8250_request_std_resource(up); 28539196d8acSJiri Slaby if (ret == 0 && port->type == PORT_RSA) { 28549196d8acSJiri Slaby ret = serial8250_request_rsa_resource(up); 28559196d8acSJiri Slaby if (ret < 0) 28569196d8acSJiri Slaby serial8250_release_std_resource(up); 28579196d8acSJiri Slaby } 28589196d8acSJiri Slaby 28599196d8acSJiri Slaby return ret; 28609196d8acSJiri Slaby } 28619196d8acSJiri Slaby 2862aef9a7bdSYoshihiro YUNOMAE static int fcr_get_rxtrig_bytes(struct uart_8250_port *up) 2863aef9a7bdSYoshihiro YUNOMAE { 2864aef9a7bdSYoshihiro YUNOMAE const struct serial8250_config *conf_type = &uart_config[up->port.type]; 2865aef9a7bdSYoshihiro YUNOMAE unsigned char bytes; 2866aef9a7bdSYoshihiro YUNOMAE 2867aef9a7bdSYoshihiro YUNOMAE bytes = conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(up->fcr)]; 2868aef9a7bdSYoshihiro YUNOMAE 2869aef9a7bdSYoshihiro YUNOMAE return bytes ? bytes : -EOPNOTSUPP; 2870aef9a7bdSYoshihiro YUNOMAE } 2871aef9a7bdSYoshihiro YUNOMAE 2872aef9a7bdSYoshihiro YUNOMAE static int bytes_to_fcr_rxtrig(struct uart_8250_port *up, unsigned char bytes) 2873aef9a7bdSYoshihiro YUNOMAE { 2874aef9a7bdSYoshihiro YUNOMAE const struct serial8250_config *conf_type = &uart_config[up->port.type]; 2875aef9a7bdSYoshihiro YUNOMAE int i; 2876aef9a7bdSYoshihiro YUNOMAE 2877aef9a7bdSYoshihiro YUNOMAE if (!conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(UART_FCR_R_TRIG_00)]) 2878aef9a7bdSYoshihiro YUNOMAE return -EOPNOTSUPP; 2879aef9a7bdSYoshihiro YUNOMAE 2880aef9a7bdSYoshihiro YUNOMAE for (i = 1; i < UART_FCR_R_TRIG_MAX_STATE; i++) { 2881aef9a7bdSYoshihiro YUNOMAE if (bytes < conf_type->rxtrig_bytes[i]) 2882aef9a7bdSYoshihiro YUNOMAE /* Use the nearest lower value */ 2883aef9a7bdSYoshihiro YUNOMAE return (--i) << UART_FCR_R_TRIG_SHIFT; 2884aef9a7bdSYoshihiro YUNOMAE } 2885aef9a7bdSYoshihiro YUNOMAE 2886aef9a7bdSYoshihiro YUNOMAE return UART_FCR_R_TRIG_11; 2887aef9a7bdSYoshihiro YUNOMAE } 2888aef9a7bdSYoshihiro YUNOMAE 2889aef9a7bdSYoshihiro YUNOMAE static int do_get_rxtrig(struct tty_port *port) 2890aef9a7bdSYoshihiro YUNOMAE { 2891aef9a7bdSYoshihiro YUNOMAE struct uart_state *state = container_of(port, struct uart_state, port); 2892aef9a7bdSYoshihiro YUNOMAE struct uart_port *uport = state->uart_port; 2893aef9a7bdSYoshihiro YUNOMAE struct uart_8250_port *up = 2894aef9a7bdSYoshihiro YUNOMAE container_of(uport, struct uart_8250_port, port); 2895aef9a7bdSYoshihiro YUNOMAE 2896aef9a7bdSYoshihiro YUNOMAE if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1) 2897aef9a7bdSYoshihiro YUNOMAE return -EINVAL; 2898aef9a7bdSYoshihiro YUNOMAE 2899aef9a7bdSYoshihiro YUNOMAE return fcr_get_rxtrig_bytes(up); 2900aef9a7bdSYoshihiro YUNOMAE } 2901aef9a7bdSYoshihiro YUNOMAE 2902aef9a7bdSYoshihiro YUNOMAE static int do_serial8250_get_rxtrig(struct tty_port *port) 2903aef9a7bdSYoshihiro YUNOMAE { 2904aef9a7bdSYoshihiro YUNOMAE int rxtrig_bytes; 2905aef9a7bdSYoshihiro YUNOMAE 2906aef9a7bdSYoshihiro YUNOMAE mutex_lock(&port->mutex); 2907aef9a7bdSYoshihiro YUNOMAE rxtrig_bytes = do_get_rxtrig(port); 2908aef9a7bdSYoshihiro YUNOMAE mutex_unlock(&port->mutex); 2909aef9a7bdSYoshihiro YUNOMAE 2910aef9a7bdSYoshihiro YUNOMAE return rxtrig_bytes; 2911aef9a7bdSYoshihiro YUNOMAE } 2912aef9a7bdSYoshihiro YUNOMAE 2913aef9a7bdSYoshihiro YUNOMAE static ssize_t serial8250_get_attr_rx_trig_bytes(struct device *dev, 2914aef9a7bdSYoshihiro YUNOMAE struct device_attribute *attr, char *buf) 2915aef9a7bdSYoshihiro YUNOMAE { 2916aef9a7bdSYoshihiro YUNOMAE struct tty_port *port = dev_get_drvdata(dev); 2917aef9a7bdSYoshihiro YUNOMAE int rxtrig_bytes; 2918aef9a7bdSYoshihiro YUNOMAE 2919aef9a7bdSYoshihiro YUNOMAE rxtrig_bytes = do_serial8250_get_rxtrig(port); 2920aef9a7bdSYoshihiro YUNOMAE if (rxtrig_bytes < 0) 2921aef9a7bdSYoshihiro YUNOMAE return rxtrig_bytes; 2922aef9a7bdSYoshihiro YUNOMAE 2923aef9a7bdSYoshihiro YUNOMAE return snprintf(buf, PAGE_SIZE, "%d\n", rxtrig_bytes); 2924aef9a7bdSYoshihiro YUNOMAE } 2925aef9a7bdSYoshihiro YUNOMAE 2926aef9a7bdSYoshihiro YUNOMAE static int do_set_rxtrig(struct tty_port *port, unsigned char bytes) 2927aef9a7bdSYoshihiro YUNOMAE { 2928aef9a7bdSYoshihiro YUNOMAE struct uart_state *state = container_of(port, struct uart_state, port); 2929aef9a7bdSYoshihiro YUNOMAE struct uart_port *uport = state->uart_port; 2930aef9a7bdSYoshihiro YUNOMAE struct uart_8250_port *up = 2931aef9a7bdSYoshihiro YUNOMAE container_of(uport, struct uart_8250_port, port); 2932aef9a7bdSYoshihiro YUNOMAE int rxtrig; 2933aef9a7bdSYoshihiro YUNOMAE 2934aef9a7bdSYoshihiro YUNOMAE if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1 || 2935aef9a7bdSYoshihiro YUNOMAE up->fifo_bug) 2936aef9a7bdSYoshihiro YUNOMAE return -EINVAL; 2937aef9a7bdSYoshihiro YUNOMAE 2938aef9a7bdSYoshihiro YUNOMAE rxtrig = bytes_to_fcr_rxtrig(up, bytes); 2939aef9a7bdSYoshihiro YUNOMAE if (rxtrig < 0) 2940aef9a7bdSYoshihiro YUNOMAE return rxtrig; 2941aef9a7bdSYoshihiro YUNOMAE 2942aef9a7bdSYoshihiro YUNOMAE serial8250_clear_fifos(up); 2943aef9a7bdSYoshihiro YUNOMAE up->fcr &= ~UART_FCR_TRIGGER_MASK; 2944aef9a7bdSYoshihiro YUNOMAE up->fcr |= (unsigned char)rxtrig; 2945aef9a7bdSYoshihiro YUNOMAE serial_out(up, UART_FCR, up->fcr); 2946aef9a7bdSYoshihiro YUNOMAE return 0; 2947aef9a7bdSYoshihiro YUNOMAE } 2948aef9a7bdSYoshihiro YUNOMAE 2949aef9a7bdSYoshihiro YUNOMAE static int do_serial8250_set_rxtrig(struct tty_port *port, unsigned char bytes) 2950aef9a7bdSYoshihiro YUNOMAE { 2951aef9a7bdSYoshihiro YUNOMAE int ret; 2952aef9a7bdSYoshihiro YUNOMAE 2953aef9a7bdSYoshihiro YUNOMAE mutex_lock(&port->mutex); 2954aef9a7bdSYoshihiro YUNOMAE ret = do_set_rxtrig(port, bytes); 2955aef9a7bdSYoshihiro YUNOMAE mutex_unlock(&port->mutex); 2956aef9a7bdSYoshihiro YUNOMAE 2957aef9a7bdSYoshihiro YUNOMAE return ret; 2958aef9a7bdSYoshihiro YUNOMAE } 2959aef9a7bdSYoshihiro YUNOMAE 2960aef9a7bdSYoshihiro YUNOMAE static ssize_t serial8250_set_attr_rx_trig_bytes(struct device *dev, 2961aef9a7bdSYoshihiro YUNOMAE struct device_attribute *attr, const char *buf, size_t count) 2962aef9a7bdSYoshihiro YUNOMAE { 2963aef9a7bdSYoshihiro YUNOMAE struct tty_port *port = dev_get_drvdata(dev); 2964aef9a7bdSYoshihiro YUNOMAE unsigned char bytes; 2965aef9a7bdSYoshihiro YUNOMAE int ret; 2966aef9a7bdSYoshihiro YUNOMAE 2967aef9a7bdSYoshihiro YUNOMAE if (!count) 2968aef9a7bdSYoshihiro YUNOMAE return -EINVAL; 2969aef9a7bdSYoshihiro YUNOMAE 2970aef9a7bdSYoshihiro YUNOMAE ret = kstrtou8(buf, 10, &bytes); 2971aef9a7bdSYoshihiro YUNOMAE if (ret < 0) 2972aef9a7bdSYoshihiro YUNOMAE return ret; 2973aef9a7bdSYoshihiro YUNOMAE 2974aef9a7bdSYoshihiro YUNOMAE ret = do_serial8250_set_rxtrig(port, bytes); 2975aef9a7bdSYoshihiro YUNOMAE if (ret < 0) 2976aef9a7bdSYoshihiro YUNOMAE return ret; 2977aef9a7bdSYoshihiro YUNOMAE 2978aef9a7bdSYoshihiro YUNOMAE return count; 2979aef9a7bdSYoshihiro YUNOMAE } 2980aef9a7bdSYoshihiro YUNOMAE 2981aef9a7bdSYoshihiro YUNOMAE static DEVICE_ATTR(rx_trig_bytes, S_IRUSR | S_IWUSR | S_IRGRP, 2982aef9a7bdSYoshihiro YUNOMAE serial8250_get_attr_rx_trig_bytes, 2983aef9a7bdSYoshihiro YUNOMAE serial8250_set_attr_rx_trig_bytes); 2984aef9a7bdSYoshihiro YUNOMAE 2985aef9a7bdSYoshihiro YUNOMAE static struct attribute *serial8250_dev_attrs[] = { 2986aef9a7bdSYoshihiro YUNOMAE &dev_attr_rx_trig_bytes.attr, 2987aef9a7bdSYoshihiro YUNOMAE NULL, 2988aef9a7bdSYoshihiro YUNOMAE }; 2989aef9a7bdSYoshihiro YUNOMAE 2990aef9a7bdSYoshihiro YUNOMAE static struct attribute_group serial8250_dev_attr_group = { 2991aef9a7bdSYoshihiro YUNOMAE .attrs = serial8250_dev_attrs, 2992aef9a7bdSYoshihiro YUNOMAE }; 2993aef9a7bdSYoshihiro YUNOMAE 2994aef9a7bdSYoshihiro YUNOMAE static void register_dev_spec_attr_grp(struct uart_8250_port *up) 2995aef9a7bdSYoshihiro YUNOMAE { 2996aef9a7bdSYoshihiro YUNOMAE const struct serial8250_config *conf_type = &uart_config[up->port.type]; 2997aef9a7bdSYoshihiro YUNOMAE 2998aef9a7bdSYoshihiro YUNOMAE if (conf_type->rxtrig_bytes[0]) 2999aef9a7bdSYoshihiro YUNOMAE up->port.attr_group = &serial8250_dev_attr_group; 3000aef9a7bdSYoshihiro YUNOMAE } 3001aef9a7bdSYoshihiro YUNOMAE 30029196d8acSJiri Slaby static void serial8250_config_port(struct uart_port *port, int flags) 30039196d8acSJiri Slaby { 3004b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 30059196d8acSJiri Slaby int probeflags = PROBE_ANY; 30069196d8acSJiri Slaby int ret; 30079196d8acSJiri Slaby 30089196d8acSJiri Slaby if (port->type == PORT_8250_CIR) 30099196d8acSJiri Slaby return; 30109196d8acSJiri Slaby 30119196d8acSJiri Slaby /* 30129196d8acSJiri Slaby * Find the region that we can probe for. This in turn 30139196d8acSJiri Slaby * tells us whether we can probe for the type of port. 30149196d8acSJiri Slaby */ 30159196d8acSJiri Slaby ret = serial8250_request_std_resource(up); 30169196d8acSJiri Slaby if (ret < 0) 30179196d8acSJiri Slaby return; 30189196d8acSJiri Slaby 30199196d8acSJiri Slaby ret = serial8250_request_rsa_resource(up); 30209196d8acSJiri Slaby if (ret < 0) 30219196d8acSJiri Slaby probeflags &= ~PROBE_RSA; 30229196d8acSJiri Slaby 30239196d8acSJiri Slaby if (port->iotype != up->cur_iotype) 30249196d8acSJiri Slaby set_io_from_upio(port); 30259196d8acSJiri Slaby 30269196d8acSJiri Slaby if (flags & UART_CONFIG_TYPE) 30279196d8acSJiri Slaby autoconfig(up, probeflags); 30289196d8acSJiri Slaby 30299196d8acSJiri Slaby /* if access method is AU, it is a 16550 with a quirk */ 30309196d8acSJiri Slaby if (port->type == PORT_16550A && port->iotype == UPIO_AU) 30319196d8acSJiri Slaby up->bugs |= UART_BUG_NOMSR; 30329196d8acSJiri Slaby 30333685f19eSStephen Warren /* HW bugs may trigger IRQ while IIR == NO_INT */ 30343685f19eSStephen Warren if (port->type == PORT_TEGRA) 30353685f19eSStephen Warren up->bugs |= UART_BUG_NOMSR; 30363685f19eSStephen Warren 30379196d8acSJiri Slaby if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ) 30389196d8acSJiri Slaby autoconfig_irq(up); 30399196d8acSJiri Slaby 30409196d8acSJiri Slaby if (port->type != PORT_RSA && probeflags & PROBE_RSA) 30419196d8acSJiri Slaby serial8250_release_rsa_resource(up); 30429196d8acSJiri Slaby if (port->type == PORT_UNKNOWN) 30439196d8acSJiri Slaby serial8250_release_std_resource(up); 30449196d8acSJiri Slaby 30459196d8acSJiri Slaby /* Fixme: probably not the best place for this */ 30469196d8acSJiri Slaby if ((port->type == PORT_XR17V35X) || 30479196d8acSJiri Slaby (port->type == PORT_XR17D15X)) 30489196d8acSJiri Slaby port->handle_irq = exar_handle_irq; 3049aef9a7bdSYoshihiro YUNOMAE 3050aef9a7bdSYoshihiro YUNOMAE register_dev_spec_attr_grp(up); 3051aef9a7bdSYoshihiro YUNOMAE up->fcr = uart_config[up->port.type].fcr; 30529196d8acSJiri Slaby } 30539196d8acSJiri Slaby 30549196d8acSJiri Slaby static int 30559196d8acSJiri Slaby serial8250_verify_port(struct uart_port *port, struct serial_struct *ser) 30569196d8acSJiri Slaby { 30579196d8acSJiri Slaby if (ser->irq >= nr_irqs || ser->irq < 0 || 30589196d8acSJiri Slaby ser->baud_base < 9600 || ser->type < PORT_UNKNOWN || 30599196d8acSJiri Slaby ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS || 30609196d8acSJiri Slaby ser->type == PORT_STARTECH) 30619196d8acSJiri Slaby return -EINVAL; 30629196d8acSJiri Slaby return 0; 30639196d8acSJiri Slaby } 30649196d8acSJiri Slaby 30659196d8acSJiri Slaby static const char * 30669196d8acSJiri Slaby serial8250_type(struct uart_port *port) 30679196d8acSJiri Slaby { 30689196d8acSJiri Slaby int type = port->type; 30699196d8acSJiri Slaby 30709196d8acSJiri Slaby if (type >= ARRAY_SIZE(uart_config)) 30719196d8acSJiri Slaby type = 0; 30729196d8acSJiri Slaby return uart_config[type].name; 30739196d8acSJiri Slaby } 30749196d8acSJiri Slaby 30759196d8acSJiri Slaby static struct uart_ops serial8250_pops = { 30769196d8acSJiri Slaby .tx_empty = serial8250_tx_empty, 30779196d8acSJiri Slaby .set_mctrl = serial8250_set_mctrl, 30789196d8acSJiri Slaby .get_mctrl = serial8250_get_mctrl, 30799196d8acSJiri Slaby .stop_tx = serial8250_stop_tx, 30809196d8acSJiri Slaby .start_tx = serial8250_start_tx, 3081234abab1SSebastian Andrzej Siewior .throttle = serial8250_throttle, 3082234abab1SSebastian Andrzej Siewior .unthrottle = serial8250_unthrottle, 30839196d8acSJiri Slaby .stop_rx = serial8250_stop_rx, 30849196d8acSJiri Slaby .enable_ms = serial8250_enable_ms, 30859196d8acSJiri Slaby .break_ctl = serial8250_break_ctl, 30869196d8acSJiri Slaby .startup = serial8250_startup, 30879196d8acSJiri Slaby .shutdown = serial8250_shutdown, 30889196d8acSJiri Slaby .set_termios = serial8250_set_termios, 30899196d8acSJiri Slaby .set_ldisc = serial8250_set_ldisc, 30909196d8acSJiri Slaby .pm = serial8250_pm, 30919196d8acSJiri Slaby .type = serial8250_type, 30929196d8acSJiri Slaby .release_port = serial8250_release_port, 30939196d8acSJiri Slaby .request_port = serial8250_request_port, 30949196d8acSJiri Slaby .config_port = serial8250_config_port, 30959196d8acSJiri Slaby .verify_port = serial8250_verify_port, 30969196d8acSJiri Slaby #ifdef CONFIG_CONSOLE_POLL 30979196d8acSJiri Slaby .poll_get_char = serial8250_get_poll_char, 30989196d8acSJiri Slaby .poll_put_char = serial8250_put_poll_char, 30999196d8acSJiri Slaby #endif 31009196d8acSJiri Slaby }; 31019196d8acSJiri Slaby 3102a4416cd1SPeter Hurley static const struct uart_8250_ops univ8250_driver_ops = { 3103a4416cd1SPeter Hurley .setup_irq = univ8250_setup_irq, 3104a4416cd1SPeter Hurley .release_irq = univ8250_release_irq, 3105a4416cd1SPeter Hurley }; 3106a4416cd1SPeter Hurley 31079196d8acSJiri Slaby static struct uart_8250_port serial8250_ports[UART_NR]; 31089196d8acSJiri Slaby 3109ae14a795SSebastian Andrzej Siewior /** 3110ae14a795SSebastian Andrzej Siewior * serial8250_get_port - retrieve struct uart_8250_port 3111ae14a795SSebastian Andrzej Siewior * @line: serial line number 3112ae14a795SSebastian Andrzej Siewior * 3113ae14a795SSebastian Andrzej Siewior * This function retrieves struct uart_8250_port for the specific line. 3114ae14a795SSebastian Andrzej Siewior * This struct *must* *not* be used to perform a 8250 or serial core operation 3115ae14a795SSebastian Andrzej Siewior * which is not accessible otherwise. Its only purpose is to make the struct 3116ae14a795SSebastian Andrzej Siewior * accessible to the runtime-pm callbacks for context suspend/restore. 3117ae14a795SSebastian Andrzej Siewior * The lock assumption made here is none because runtime-pm suspend/resume 3118ae14a795SSebastian Andrzej Siewior * callbacks should not be invoked if there is any operation performed on the 3119ae14a795SSebastian Andrzej Siewior * port. 3120ae14a795SSebastian Andrzej Siewior */ 3121ae14a795SSebastian Andrzej Siewior struct uart_8250_port *serial8250_get_port(int line) 3122ae14a795SSebastian Andrzej Siewior { 3123ae14a795SSebastian Andrzej Siewior return &serial8250_ports[line]; 3124ae14a795SSebastian Andrzej Siewior } 3125ae14a795SSebastian Andrzej Siewior EXPORT_SYMBOL_GPL(serial8250_get_port); 3126ae14a795SSebastian Andrzej Siewior 31279196d8acSJiri Slaby static void (*serial8250_isa_config)(int port, struct uart_port *up, 31289196d8acSJiri Slaby unsigned short *capabilities); 31299196d8acSJiri Slaby 31309196d8acSJiri Slaby void serial8250_set_isa_configurator( 31319196d8acSJiri Slaby void (*v)(int port, struct uart_port *up, unsigned short *capabilities)) 31329196d8acSJiri Slaby { 31339196d8acSJiri Slaby serial8250_isa_config = v; 31349196d8acSJiri Slaby } 31359196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_set_isa_configurator); 31369196d8acSJiri Slaby 31370a16e2c1SPeter Hurley static void serial8250_init_port(struct uart_8250_port *up) 31380a16e2c1SPeter Hurley { 31390a16e2c1SPeter Hurley struct uart_port *port = &up->port; 31400a16e2c1SPeter Hurley 31410a16e2c1SPeter Hurley spin_lock_init(&port->lock); 31420a16e2c1SPeter Hurley port->ops = &serial8250_pops; 31430a16e2c1SPeter Hurley 31440a16e2c1SPeter Hurley up->cur_iotype = 0xFF; 31450a16e2c1SPeter Hurley } 31460a16e2c1SPeter Hurley 31471a53e079SPeter Hurley static void serial8250_set_defaults(struct uart_8250_port *up) 31481a53e079SPeter Hurley { 31491a53e079SPeter Hurley struct uart_port *port = &up->port; 31501a53e079SPeter Hurley 3151afd483bdSPeter Hurley if (up->port.flags & UPF_FIXED_TYPE) { 3152afd483bdSPeter Hurley unsigned int type = up->port.type; 3153afd483bdSPeter Hurley 3154afd483bdSPeter Hurley if (!up->port.fifosize) 3155afd483bdSPeter Hurley up->port.fifosize = uart_config[type].fifo_size; 3156afd483bdSPeter Hurley if (!up->tx_loadsz) 3157afd483bdSPeter Hurley up->tx_loadsz = uart_config[type].tx_loadsz; 3158afd483bdSPeter Hurley if (!up->capabilities) 3159afd483bdSPeter Hurley up->capabilities = uart_config[type].flags; 3160afd483bdSPeter Hurley } 3161afd483bdSPeter Hurley 31621a53e079SPeter Hurley set_io_from_upio(port); 3163d53e1428SPeter Hurley 3164d53e1428SPeter Hurley /* default dma handlers */ 3165d53e1428SPeter Hurley if (up->dma) { 3166d53e1428SPeter Hurley if (!up->dma->tx_dma) 3167d53e1428SPeter Hurley up->dma->tx_dma = serial8250_tx_dma; 3168d53e1428SPeter Hurley if (!up->dma->rx_dma) 3169d53e1428SPeter Hurley up->dma->rx_dma = serial8250_rx_dma; 3170d53e1428SPeter Hurley } 31711a53e079SPeter Hurley } 31721a53e079SPeter Hurley 31739196d8acSJiri Slaby static void __init serial8250_isa_init_ports(void) 31749196d8acSJiri Slaby { 31759196d8acSJiri Slaby struct uart_8250_port *up; 31769196d8acSJiri Slaby static int first = 1; 31779196d8acSJiri Slaby int i, irqflag = 0; 31789196d8acSJiri Slaby 31799196d8acSJiri Slaby if (!first) 31809196d8acSJiri Slaby return; 31819196d8acSJiri Slaby first = 0; 31829196d8acSJiri Slaby 31839196d8acSJiri Slaby if (nr_uarts > UART_NR) 31849196d8acSJiri Slaby nr_uarts = UART_NR; 31859196d8acSJiri Slaby 3186317a6842SKyle McMartin for (i = 0; i < nr_uarts; i++) { 31879196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[i]; 31889196d8acSJiri Slaby struct uart_port *port = &up->port; 31899196d8acSJiri Slaby 31909196d8acSJiri Slaby port->line = i; 31910a16e2c1SPeter Hurley serial8250_init_port(up); 31929196d8acSJiri Slaby 31939196d8acSJiri Slaby init_timer(&up->timer); 31949196d8acSJiri Slaby up->timer.function = serial8250_timeout; 31959196d8acSJiri Slaby 3196a4416cd1SPeter Hurley up->ops = &univ8250_driver_ops; 3197a4416cd1SPeter Hurley 31989196d8acSJiri Slaby /* 31999196d8acSJiri Slaby * ALPHA_KLUDGE_MCR needs to be killed. 32009196d8acSJiri Slaby */ 32019196d8acSJiri Slaby up->mcr_mask = ~ALPHA_KLUDGE_MCR; 32029196d8acSJiri Slaby up->mcr_force = ALPHA_KLUDGE_MCR; 32039196d8acSJiri Slaby } 32049196d8acSJiri Slaby 32059196d8acSJiri Slaby if (share_irqs) 32069196d8acSJiri Slaby irqflag = IRQF_SHARED; 32079196d8acSJiri Slaby 32089196d8acSJiri Slaby for (i = 0, up = serial8250_ports; 32099196d8acSJiri Slaby i < ARRAY_SIZE(old_serial_port) && i < nr_uarts; 32109196d8acSJiri Slaby i++, up++) { 32119196d8acSJiri Slaby struct uart_port *port = &up->port; 32129196d8acSJiri Slaby 32139196d8acSJiri Slaby port->iobase = old_serial_port[i].port; 32149196d8acSJiri Slaby port->irq = irq_canonicalize(old_serial_port[i].irq); 32159196d8acSJiri Slaby port->irqflags = old_serial_port[i].irqflags; 32169196d8acSJiri Slaby port->uartclk = old_serial_port[i].baud_base * 16; 32179196d8acSJiri Slaby port->flags = old_serial_port[i].flags; 32189196d8acSJiri Slaby port->hub6 = old_serial_port[i].hub6; 32199196d8acSJiri Slaby port->membase = old_serial_port[i].iomem_base; 32209196d8acSJiri Slaby port->iotype = old_serial_port[i].io_type; 32219196d8acSJiri Slaby port->regshift = old_serial_port[i].iomem_reg_shift; 32221a53e079SPeter Hurley serial8250_set_defaults(up); 32231a53e079SPeter Hurley 32249196d8acSJiri Slaby port->irqflags |= irqflag; 32259196d8acSJiri Slaby if (serial8250_isa_config != NULL) 32269196d8acSJiri Slaby serial8250_isa_config(i, &up->port, &up->capabilities); 32279196d8acSJiri Slaby } 32289196d8acSJiri Slaby } 32299196d8acSJiri Slaby 32309196d8acSJiri Slaby static void __init 32319196d8acSJiri Slaby serial8250_register_ports(struct uart_driver *drv, struct device *dev) 32329196d8acSJiri Slaby { 32339196d8acSJiri Slaby int i; 32349196d8acSJiri Slaby 32359196d8acSJiri Slaby for (i = 0; i < nr_uarts; i++) { 32369196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[i]; 32379196d8acSJiri Slaby 32389196d8acSJiri Slaby if (up->port.dev) 32399196d8acSJiri Slaby continue; 32409196d8acSJiri Slaby 32419196d8acSJiri Slaby up->port.dev = dev; 32429196d8acSJiri Slaby 3243e13cb72bSPeter Hurley if (skip_txen_test) 3244e13cb72bSPeter Hurley up->port.flags |= UPF_NO_TXEN_TEST; 3245e13cb72bSPeter Hurley 32469196d8acSJiri Slaby uart_add_one_port(drv, &up->port); 32479196d8acSJiri Slaby } 32489196d8acSJiri Slaby } 32499196d8acSJiri Slaby 32509196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_CONSOLE 32519196d8acSJiri Slaby 32529196d8acSJiri Slaby static void serial8250_console_putchar(struct uart_port *port, int ch) 32539196d8acSJiri Slaby { 3254b1261c86SAndy Shevchenko struct uart_8250_port *up = up_to_u8250p(port); 32559196d8acSJiri Slaby 32569196d8acSJiri Slaby wait_for_xmitr(up, UART_LSR_THRE); 32579196d8acSJiri Slaby serial_port_out(port, UART_TX, ch); 32589196d8acSJiri Slaby } 32599196d8acSJiri Slaby 32609196d8acSJiri Slaby /* 32619196d8acSJiri Slaby * Print a string to the serial port trying not to disturb 32629196d8acSJiri Slaby * any possible real use of the port... 32639196d8acSJiri Slaby * 32649196d8acSJiri Slaby * The console_lock must be held when we get here. 32659196d8acSJiri Slaby */ 32666e281571SPeter Hurley static void serial8250_console_write(struct uart_8250_port *up, const char *s, 32676e281571SPeter Hurley unsigned int count) 32689196d8acSJiri Slaby { 32699196d8acSJiri Slaby struct uart_port *port = &up->port; 32709196d8acSJiri Slaby unsigned long flags; 32719196d8acSJiri Slaby unsigned int ier; 32729196d8acSJiri Slaby int locked = 1; 32739196d8acSJiri Slaby 32749196d8acSJiri Slaby touch_nmi_watchdog(); 32759196d8acSJiri Slaby 3276d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_get(up); 3277d74d5d1bSSebastian Andrzej Siewior 32786fad18faSRabin Vincent if (port->sysrq) 32796fad18faSRabin Vincent locked = 0; 32806fad18faSRabin Vincent else if (oops_in_progress) 3281ebade5e8SIngo Molnar locked = spin_trylock_irqsave(&port->lock, flags); 3282ebade5e8SIngo Molnar else 3283ebade5e8SIngo Molnar spin_lock_irqsave(&port->lock, flags); 32849196d8acSJiri Slaby 32859196d8acSJiri Slaby /* 32869196d8acSJiri Slaby * First save the IER then disable the interrupts 32879196d8acSJiri Slaby */ 32889196d8acSJiri Slaby ier = serial_port_in(port, UART_IER); 32899196d8acSJiri Slaby 32909196d8acSJiri Slaby if (up->capabilities & UART_CAP_UUE) 32919196d8acSJiri Slaby serial_port_out(port, UART_IER, UART_IER_UUE); 32929196d8acSJiri Slaby else 32939196d8acSJiri Slaby serial_port_out(port, UART_IER, 0); 32949196d8acSJiri Slaby 32954516d50aSPeter Hurley /* check scratch reg to see if port powered off during system sleep */ 32964516d50aSPeter Hurley if (up->canary && (up->canary != serial_port_in(port, UART_SCR))) { 32974516d50aSPeter Hurley struct ktermios termios; 32984516d50aSPeter Hurley unsigned int baud, quot, frac = 0; 32994516d50aSPeter Hurley 33004516d50aSPeter Hurley termios.c_cflag = port->cons->cflag; 33014516d50aSPeter Hurley if (port->state->port.tty && termios.c_cflag == 0) 33024516d50aSPeter Hurley termios.c_cflag = port->state->port.tty->termios.c_cflag; 33034516d50aSPeter Hurley 33044516d50aSPeter Hurley baud = uart_get_baud_rate(port, &termios, NULL, 33054516d50aSPeter Hurley port->uartclk / 16 / 0xffff, 33064516d50aSPeter Hurley port->uartclk / 16); 33074516d50aSPeter Hurley quot = serial8250_get_divisor(up, baud, &frac); 33084516d50aSPeter Hurley 33094516d50aSPeter Hurley serial8250_set_divisor(port, baud, quot, frac); 33104516d50aSPeter Hurley serial_port_out(port, UART_LCR, up->lcr); 33114516d50aSPeter Hurley serial_port_out(port, UART_MCR, UART_MCR_DTR | UART_MCR_RTS); 33124516d50aSPeter Hurley 33134516d50aSPeter Hurley up->canary = 0; 33144516d50aSPeter Hurley } 33154516d50aSPeter Hurley 33169196d8acSJiri Slaby uart_console_write(port, s, count, serial8250_console_putchar); 33179196d8acSJiri Slaby 33189196d8acSJiri Slaby /* 33199196d8acSJiri Slaby * Finally, wait for transmitter to become empty 33209196d8acSJiri Slaby * and restore the IER 33219196d8acSJiri Slaby */ 33229196d8acSJiri Slaby wait_for_xmitr(up, BOTH_EMPTY); 33239196d8acSJiri Slaby serial_port_out(port, UART_IER, ier); 33249196d8acSJiri Slaby 33259196d8acSJiri Slaby /* 33269196d8acSJiri Slaby * The receive handling will happen properly because the 33279196d8acSJiri Slaby * receive ready bit will still be set; it is not cleared 33289196d8acSJiri Slaby * on read. However, modem control will not, we must 33299196d8acSJiri Slaby * call it if we have saved something in the saved flags 33309196d8acSJiri Slaby * while processing with interrupts off. 33319196d8acSJiri Slaby */ 33329196d8acSJiri Slaby if (up->msr_saved_flags) 33339196d8acSJiri Slaby serial8250_modem_status(up); 33349196d8acSJiri Slaby 33359196d8acSJiri Slaby if (locked) 3336ebade5e8SIngo Molnar spin_unlock_irqrestore(&port->lock, flags); 3337d74d5d1bSSebastian Andrzej Siewior serial8250_rpm_put(up); 33389196d8acSJiri Slaby } 33399196d8acSJiri Slaby 33406e281571SPeter Hurley static void univ8250_console_write(struct console *co, const char *s, 33416e281571SPeter Hurley unsigned int count) 33429196d8acSJiri Slaby { 33436e281571SPeter Hurley struct uart_8250_port *up = &serial8250_ports[co->index]; 33446e281571SPeter Hurley 33456e281571SPeter Hurley serial8250_console_write(up, s, count); 33466e281571SPeter Hurley } 33476e281571SPeter Hurley 33486e281571SPeter Hurley static int serial8250_console_setup(struct uart_8250_port *up, char *options) 33496e281571SPeter Hurley { 33506e281571SPeter Hurley struct uart_port *port = &up->port; 33519196d8acSJiri Slaby int baud = 9600; 33529196d8acSJiri Slaby int bits = 8; 33539196d8acSJiri Slaby int parity = 'n'; 33549196d8acSJiri Slaby int flow = 'n'; 33559196d8acSJiri Slaby 33566e281571SPeter Hurley if (!port->iobase && !port->membase) 33576e281571SPeter Hurley return -ENODEV; 33586e281571SPeter Hurley 33596e281571SPeter Hurley if (options) 33606e281571SPeter Hurley uart_parse_options(options, &baud, &parity, &bits, &flow); 33616e281571SPeter Hurley 33626e281571SPeter Hurley return uart_set_options(port, port->cons, baud, parity, bits, flow); 33636e281571SPeter Hurley } 33646e281571SPeter Hurley 33656e281571SPeter Hurley static int univ8250_console_setup(struct console *co, char *options) 33666e281571SPeter Hurley { 33676e281571SPeter Hurley struct uart_8250_port *up; 33686e281571SPeter Hurley 33699196d8acSJiri Slaby /* 33709196d8acSJiri Slaby * Check whether an invalid uart number has been specified, and 33719196d8acSJiri Slaby * if so, search for the first available port that does have 33729196d8acSJiri Slaby * console support. 33739196d8acSJiri Slaby */ 3374317a6842SKyle McMartin if (co->index >= nr_uarts) 33759196d8acSJiri Slaby co->index = 0; 33766e281571SPeter Hurley up = &serial8250_ports[co->index]; 33776e281571SPeter Hurley /* link port to console */ 33786e281571SPeter Hurley up->port.cons = co; 33799196d8acSJiri Slaby 33806e281571SPeter Hurley return serial8250_console_setup(up, options); 33819196d8acSJiri Slaby } 33829196d8acSJiri Slaby 3383c7cef0a8SPeter Hurley /** 33846e281571SPeter Hurley * univ8250_console_match - non-standard console matching 3385c7cef0a8SPeter Hurley * @co: registering console 3386c7cef0a8SPeter Hurley * @name: name from console command line 3387c7cef0a8SPeter Hurley * @idx: index from console command line 3388c7cef0a8SPeter Hurley * @options: ptr to option string from console command line 3389c7cef0a8SPeter Hurley * 3390c7cef0a8SPeter Hurley * Only attempts to match console command lines of the form: 3391c7cef0a8SPeter Hurley * console=uart<>,io|mmio|mmio32,<addr>,<options> 3392c7cef0a8SPeter Hurley * console=uart<>,<addr>,options 3393c7cef0a8SPeter Hurley * This form is used to register an initial earlycon boot console and 3394c7cef0a8SPeter Hurley * replace it with the serial8250_console at 8250 driver init. 3395c7cef0a8SPeter Hurley * 3396c7cef0a8SPeter Hurley * Performs console setup for a match (as required by interface) 3397c7cef0a8SPeter Hurley * 3398c7cef0a8SPeter Hurley * Returns 0 if console matches; otherwise non-zero to use default matching 3399c7cef0a8SPeter Hurley */ 34006e281571SPeter Hurley static int univ8250_console_match(struct console *co, char *name, int idx, 3401c7cef0a8SPeter Hurley char *options) 34029196d8acSJiri Slaby { 3403c7cef0a8SPeter Hurley char match[] = "uart"; /* 8250-specific earlycon name */ 3404c7cef0a8SPeter Hurley unsigned char iotype; 3405c7cef0a8SPeter Hurley unsigned long addr; 3406c7cef0a8SPeter Hurley int i; 3407c7cef0a8SPeter Hurley 3408c7cef0a8SPeter Hurley if (strncmp(name, match, 4) != 0) 3409c7cef0a8SPeter Hurley return -ENODEV; 3410c7cef0a8SPeter Hurley 3411c7cef0a8SPeter Hurley if (uart_parse_earlycon(options, &iotype, &addr, &options)) 3412c7cef0a8SPeter Hurley return -ENODEV; 3413c7cef0a8SPeter Hurley 3414c7cef0a8SPeter Hurley /* try to match the port specified on the command line */ 3415c7cef0a8SPeter Hurley for (i = 0; i < nr_uarts; i++) { 3416c7cef0a8SPeter Hurley struct uart_port *port = &serial8250_ports[i].port; 3417c7cef0a8SPeter Hurley 3418c7cef0a8SPeter Hurley if (port->iotype != iotype) 3419c7cef0a8SPeter Hurley continue; 3420c7cef0a8SPeter Hurley if ((iotype == UPIO_MEM || iotype == UPIO_MEM32) && 3421c7cef0a8SPeter Hurley (port->mapbase != addr)) 3422c7cef0a8SPeter Hurley continue; 3423c7cef0a8SPeter Hurley if (iotype == UPIO_PORT && port->iobase != addr) 3424c7cef0a8SPeter Hurley continue; 3425c7cef0a8SPeter Hurley 3426c7cef0a8SPeter Hurley co->index = i; 34276e281571SPeter Hurley return univ8250_console_setup(co, options); 3428c7cef0a8SPeter Hurley } 3429c7cef0a8SPeter Hurley 3430c7cef0a8SPeter Hurley return -ENODEV; 34319196d8acSJiri Slaby } 34329196d8acSJiri Slaby 34336e281571SPeter Hurley static struct console univ8250_console = { 34349196d8acSJiri Slaby .name = "ttyS", 34356e281571SPeter Hurley .write = univ8250_console_write, 34369196d8acSJiri Slaby .device = uart_console_device, 34376e281571SPeter Hurley .setup = univ8250_console_setup, 34386e281571SPeter Hurley .match = univ8250_console_match, 34399196d8acSJiri Slaby .flags = CON_PRINTBUFFER | CON_ANYTIME, 34409196d8acSJiri Slaby .index = -1, 34419196d8acSJiri Slaby .data = &serial8250_reg, 34429196d8acSJiri Slaby }; 34439196d8acSJiri Slaby 34446e281571SPeter Hurley static int __init univ8250_console_init(void) 34459196d8acSJiri Slaby { 34469196d8acSJiri Slaby serial8250_isa_init_ports(); 34476e281571SPeter Hurley register_console(&univ8250_console); 34489196d8acSJiri Slaby return 0; 34499196d8acSJiri Slaby } 34506e281571SPeter Hurley console_initcall(univ8250_console_init); 34519196d8acSJiri Slaby 34526e281571SPeter Hurley #define SERIAL8250_CONSOLE &univ8250_console 34539196d8acSJiri Slaby #else 34549196d8acSJiri Slaby #define SERIAL8250_CONSOLE NULL 34559196d8acSJiri Slaby #endif 34569196d8acSJiri Slaby 34579196d8acSJiri Slaby static struct uart_driver serial8250_reg = { 34589196d8acSJiri Slaby .owner = THIS_MODULE, 34599196d8acSJiri Slaby .driver_name = "serial", 34609196d8acSJiri Slaby .dev_name = "ttyS", 34619196d8acSJiri Slaby .major = TTY_MAJOR, 34629196d8acSJiri Slaby .minor = 64, 34639196d8acSJiri Slaby .cons = SERIAL8250_CONSOLE, 34649196d8acSJiri Slaby }; 34659196d8acSJiri Slaby 34669196d8acSJiri Slaby /* 34679196d8acSJiri Slaby * early_serial_setup - early registration for 8250 ports 34689196d8acSJiri Slaby * 34699196d8acSJiri Slaby * Setup an 8250 port structure prior to console initialisation. Use 34709196d8acSJiri Slaby * after console initialisation will cause undefined behaviour. 34719196d8acSJiri Slaby */ 34729196d8acSJiri Slaby int __init early_serial_setup(struct uart_port *port) 34739196d8acSJiri Slaby { 34749196d8acSJiri Slaby struct uart_port *p; 34759196d8acSJiri Slaby 34769196d8acSJiri Slaby if (port->line >= ARRAY_SIZE(serial8250_ports)) 34779196d8acSJiri Slaby return -ENODEV; 34789196d8acSJiri Slaby 34799196d8acSJiri Slaby serial8250_isa_init_ports(); 34809196d8acSJiri Slaby p = &serial8250_ports[port->line].port; 34819196d8acSJiri Slaby p->iobase = port->iobase; 34829196d8acSJiri Slaby p->membase = port->membase; 34839196d8acSJiri Slaby p->irq = port->irq; 34849196d8acSJiri Slaby p->irqflags = port->irqflags; 34859196d8acSJiri Slaby p->uartclk = port->uartclk; 34869196d8acSJiri Slaby p->fifosize = port->fifosize; 34879196d8acSJiri Slaby p->regshift = port->regshift; 34889196d8acSJiri Slaby p->iotype = port->iotype; 34899196d8acSJiri Slaby p->flags = port->flags; 34909196d8acSJiri Slaby p->mapbase = port->mapbase; 34919196d8acSJiri Slaby p->private_data = port->private_data; 34929196d8acSJiri Slaby p->type = port->type; 34939196d8acSJiri Slaby p->line = port->line; 34949196d8acSJiri Slaby 34951a53e079SPeter Hurley serial8250_set_defaults(up_to_u8250p(p)); 34961a53e079SPeter Hurley 34979196d8acSJiri Slaby if (port->serial_in) 34989196d8acSJiri Slaby p->serial_in = port->serial_in; 34999196d8acSJiri Slaby if (port->serial_out) 35009196d8acSJiri Slaby p->serial_out = port->serial_out; 35019196d8acSJiri Slaby if (port->handle_irq) 35029196d8acSJiri Slaby p->handle_irq = port->handle_irq; 35039196d8acSJiri Slaby 35049196d8acSJiri Slaby return 0; 35059196d8acSJiri Slaby } 35069196d8acSJiri Slaby 35079196d8acSJiri Slaby /** 35089196d8acSJiri Slaby * serial8250_suspend_port - suspend one serial port 35099196d8acSJiri Slaby * @line: serial line number 35109196d8acSJiri Slaby * 35119196d8acSJiri Slaby * Suspend one serial port. 35129196d8acSJiri Slaby */ 35139196d8acSJiri Slaby void serial8250_suspend_port(int line) 35149196d8acSJiri Slaby { 35154516d50aSPeter Hurley struct uart_8250_port *up = &serial8250_ports[line]; 35164516d50aSPeter Hurley struct uart_port *port = &up->port; 35174516d50aSPeter Hurley 35184516d50aSPeter Hurley if (!console_suspend_enabled && uart_console(port) && 35194516d50aSPeter Hurley port->type != PORT_8250) { 35204516d50aSPeter Hurley unsigned char canary = 0xa5; 35214516d50aSPeter Hurley serial_out(up, UART_SCR, canary); 35224516d50aSPeter Hurley up->canary = canary; 35234516d50aSPeter Hurley } 35244516d50aSPeter Hurley 35254516d50aSPeter Hurley uart_suspend_port(&serial8250_reg, port); 35269196d8acSJiri Slaby } 35279196d8acSJiri Slaby 35289196d8acSJiri Slaby /** 35299196d8acSJiri Slaby * serial8250_resume_port - resume one serial port 35309196d8acSJiri Slaby * @line: serial line number 35319196d8acSJiri Slaby * 35329196d8acSJiri Slaby * Resume one serial port. 35339196d8acSJiri Slaby */ 35349196d8acSJiri Slaby void serial8250_resume_port(int line) 35359196d8acSJiri Slaby { 35369196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[line]; 35379196d8acSJiri Slaby struct uart_port *port = &up->port; 35389196d8acSJiri Slaby 35394516d50aSPeter Hurley up->canary = 0; 35404516d50aSPeter Hurley 35419196d8acSJiri Slaby if (up->capabilities & UART_NATSEMI) { 35429196d8acSJiri Slaby /* Ensure it's still in high speed mode */ 35439196d8acSJiri Slaby serial_port_out(port, UART_LCR, 0xE0); 35449196d8acSJiri Slaby 35459196d8acSJiri Slaby ns16550a_goto_highspeed(up); 35469196d8acSJiri Slaby 35479196d8acSJiri Slaby serial_port_out(port, UART_LCR, 0); 35489196d8acSJiri Slaby port->uartclk = 921600*16; 35499196d8acSJiri Slaby } 35509196d8acSJiri Slaby uart_resume_port(&serial8250_reg, port); 35519196d8acSJiri Slaby } 35529196d8acSJiri Slaby 35539196d8acSJiri Slaby /* 35549196d8acSJiri Slaby * Register a set of serial devices attached to a platform device. The 35559196d8acSJiri Slaby * list is terminated with a zero flags entry, which means we expect 35569196d8acSJiri Slaby * all entries to have at least UPF_BOOT_AUTOCONF set. 35579196d8acSJiri Slaby */ 35589196d8acSJiri Slaby static int serial8250_probe(struct platform_device *dev) 35599196d8acSJiri Slaby { 3560574de559SJingoo Han struct plat_serial8250_port *p = dev_get_platdata(&dev->dev); 35619196d8acSJiri Slaby struct uart_8250_port uart; 35629196d8acSJiri Slaby int ret, i, irqflag = 0; 35639196d8acSJiri Slaby 35649196d8acSJiri Slaby memset(&uart, 0, sizeof(uart)); 35659196d8acSJiri Slaby 35669196d8acSJiri Slaby if (share_irqs) 35679196d8acSJiri Slaby irqflag = IRQF_SHARED; 35689196d8acSJiri Slaby 35699196d8acSJiri Slaby for (i = 0; p && p->flags != 0; p++, i++) { 35709196d8acSJiri Slaby uart.port.iobase = p->iobase; 35719196d8acSJiri Slaby uart.port.membase = p->membase; 35729196d8acSJiri Slaby uart.port.irq = p->irq; 35739196d8acSJiri Slaby uart.port.irqflags = p->irqflags; 35749196d8acSJiri Slaby uart.port.uartclk = p->uartclk; 35759196d8acSJiri Slaby uart.port.regshift = p->regshift; 35769196d8acSJiri Slaby uart.port.iotype = p->iotype; 35779196d8acSJiri Slaby uart.port.flags = p->flags; 35789196d8acSJiri Slaby uart.port.mapbase = p->mapbase; 35799196d8acSJiri Slaby uart.port.hub6 = p->hub6; 35809196d8acSJiri Slaby uart.port.private_data = p->private_data; 35819196d8acSJiri Slaby uart.port.type = p->type; 35829196d8acSJiri Slaby uart.port.serial_in = p->serial_in; 35839196d8acSJiri Slaby uart.port.serial_out = p->serial_out; 35849196d8acSJiri Slaby uart.port.handle_irq = p->handle_irq; 35859196d8acSJiri Slaby uart.port.handle_break = p->handle_break; 35869196d8acSJiri Slaby uart.port.set_termios = p->set_termios; 35879196d8acSJiri Slaby uart.port.pm = p->pm; 35889196d8acSJiri Slaby uart.port.dev = &dev->dev; 35899196d8acSJiri Slaby uart.port.irqflags |= irqflag; 35909196d8acSJiri Slaby ret = serial8250_register_8250_port(&uart); 35919196d8acSJiri Slaby if (ret < 0) { 35929196d8acSJiri Slaby dev_err(&dev->dev, "unable to register port at index %d " 35939196d8acSJiri Slaby "(IO%lx MEM%llx IRQ%d): %d\n", i, 35949196d8acSJiri Slaby p->iobase, (unsigned long long)p->mapbase, 35959196d8acSJiri Slaby p->irq, ret); 35969196d8acSJiri Slaby } 35979196d8acSJiri Slaby } 35989196d8acSJiri Slaby return 0; 35999196d8acSJiri Slaby } 36009196d8acSJiri Slaby 36019196d8acSJiri Slaby /* 36029196d8acSJiri Slaby * Remove serial ports registered against a platform device. 36039196d8acSJiri Slaby */ 36049196d8acSJiri Slaby static int serial8250_remove(struct platform_device *dev) 36059196d8acSJiri Slaby { 36069196d8acSJiri Slaby int i; 36079196d8acSJiri Slaby 3608317a6842SKyle McMartin for (i = 0; i < nr_uarts; i++) { 36099196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[i]; 36109196d8acSJiri Slaby 36119196d8acSJiri Slaby if (up->port.dev == &dev->dev) 36129196d8acSJiri Slaby serial8250_unregister_port(i); 36139196d8acSJiri Slaby } 36149196d8acSJiri Slaby return 0; 36159196d8acSJiri Slaby } 36169196d8acSJiri Slaby 36179196d8acSJiri Slaby static int serial8250_suspend(struct platform_device *dev, pm_message_t state) 36189196d8acSJiri Slaby { 36199196d8acSJiri Slaby int i; 36209196d8acSJiri Slaby 36219196d8acSJiri Slaby for (i = 0; i < UART_NR; i++) { 36229196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[i]; 36239196d8acSJiri Slaby 36249196d8acSJiri Slaby if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev) 36259196d8acSJiri Slaby uart_suspend_port(&serial8250_reg, &up->port); 36269196d8acSJiri Slaby } 36279196d8acSJiri Slaby 36289196d8acSJiri Slaby return 0; 36299196d8acSJiri Slaby } 36309196d8acSJiri Slaby 36319196d8acSJiri Slaby static int serial8250_resume(struct platform_device *dev) 36329196d8acSJiri Slaby { 36339196d8acSJiri Slaby int i; 36349196d8acSJiri Slaby 36359196d8acSJiri Slaby for (i = 0; i < UART_NR; i++) { 36369196d8acSJiri Slaby struct uart_8250_port *up = &serial8250_ports[i]; 36379196d8acSJiri Slaby 36389196d8acSJiri Slaby if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev) 36399196d8acSJiri Slaby serial8250_resume_port(i); 36409196d8acSJiri Slaby } 36419196d8acSJiri Slaby 36429196d8acSJiri Slaby return 0; 36439196d8acSJiri Slaby } 36449196d8acSJiri Slaby 36459196d8acSJiri Slaby static struct platform_driver serial8250_isa_driver = { 36469196d8acSJiri Slaby .probe = serial8250_probe, 36479196d8acSJiri Slaby .remove = serial8250_remove, 36489196d8acSJiri Slaby .suspend = serial8250_suspend, 36499196d8acSJiri Slaby .resume = serial8250_resume, 36509196d8acSJiri Slaby .driver = { 36519196d8acSJiri Slaby .name = "serial8250", 36529196d8acSJiri Slaby }, 36539196d8acSJiri Slaby }; 36549196d8acSJiri Slaby 36559196d8acSJiri Slaby /* 36569196d8acSJiri Slaby * This "device" covers _all_ ISA 8250-compatible serial devices listed 36579196d8acSJiri Slaby * in the table in include/asm/serial.h 36589196d8acSJiri Slaby */ 36599196d8acSJiri Slaby static struct platform_device *serial8250_isa_devs; 36609196d8acSJiri Slaby 36619196d8acSJiri Slaby /* 36629196d8acSJiri Slaby * serial8250_register_8250_port and serial8250_unregister_port allows for 36639196d8acSJiri Slaby * 16x50 serial ports to be configured at run-time, to support PCMCIA 36649196d8acSJiri Slaby * modems and PCI multiport cards. 36659196d8acSJiri Slaby */ 36669196d8acSJiri Slaby static DEFINE_MUTEX(serial_mutex); 36679196d8acSJiri Slaby 36689196d8acSJiri Slaby static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port) 36699196d8acSJiri Slaby { 36709196d8acSJiri Slaby int i; 36719196d8acSJiri Slaby 36729196d8acSJiri Slaby /* 36739196d8acSJiri Slaby * First, find a port entry which matches. 36749196d8acSJiri Slaby */ 3675317a6842SKyle McMartin for (i = 0; i < nr_uarts; i++) 36769196d8acSJiri Slaby if (uart_match_port(&serial8250_ports[i].port, port)) 36779196d8acSJiri Slaby return &serial8250_ports[i]; 36789196d8acSJiri Slaby 367959b3e898SSebastian Andrzej Siewior /* try line number first if still available */ 368059b3e898SSebastian Andrzej Siewior i = port->line; 368159b3e898SSebastian Andrzej Siewior if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN && 368259b3e898SSebastian Andrzej Siewior serial8250_ports[i].port.iobase == 0) 368359b3e898SSebastian Andrzej Siewior return &serial8250_ports[i]; 36849196d8acSJiri Slaby /* 36859196d8acSJiri Slaby * We didn't find a matching entry, so look for the first 36869196d8acSJiri Slaby * free entry. We look for one which hasn't been previously 36879196d8acSJiri Slaby * used (indicated by zero iobase). 36889196d8acSJiri Slaby */ 3689317a6842SKyle McMartin for (i = 0; i < nr_uarts; i++) 36909196d8acSJiri Slaby if (serial8250_ports[i].port.type == PORT_UNKNOWN && 36919196d8acSJiri Slaby serial8250_ports[i].port.iobase == 0) 36929196d8acSJiri Slaby return &serial8250_ports[i]; 36939196d8acSJiri Slaby 36949196d8acSJiri Slaby /* 36959196d8acSJiri Slaby * That also failed. Last resort is to find any entry which 36969196d8acSJiri Slaby * doesn't have a real port associated with it. 36979196d8acSJiri Slaby */ 3698317a6842SKyle McMartin for (i = 0; i < nr_uarts; i++) 36999196d8acSJiri Slaby if (serial8250_ports[i].port.type == PORT_UNKNOWN) 37009196d8acSJiri Slaby return &serial8250_ports[i]; 37019196d8acSJiri Slaby 37029196d8acSJiri Slaby return NULL; 37039196d8acSJiri Slaby } 37049196d8acSJiri Slaby 37059196d8acSJiri Slaby /** 37069196d8acSJiri Slaby * serial8250_register_8250_port - register a serial port 37079196d8acSJiri Slaby * @up: serial port template 37089196d8acSJiri Slaby * 37099196d8acSJiri Slaby * Configure the serial port specified by the request. If the 37109196d8acSJiri Slaby * port exists and is in use, it is hung up and unregistered 37119196d8acSJiri Slaby * first. 37129196d8acSJiri Slaby * 37139196d8acSJiri Slaby * The port is then probed and if necessary the IRQ is autodetected 37149196d8acSJiri Slaby * If this fails an error is returned. 37159196d8acSJiri Slaby * 37169196d8acSJiri Slaby * On success the port is ready to use and the line number is returned. 37179196d8acSJiri Slaby */ 37189196d8acSJiri Slaby int serial8250_register_8250_port(struct uart_8250_port *up) 37199196d8acSJiri Slaby { 37209196d8acSJiri Slaby struct uart_8250_port *uart; 37219196d8acSJiri Slaby int ret = -ENOSPC; 37229196d8acSJiri Slaby 37239196d8acSJiri Slaby if (up->port.uartclk == 0) 37249196d8acSJiri Slaby return -EINVAL; 37259196d8acSJiri Slaby 37269196d8acSJiri Slaby mutex_lock(&serial_mutex); 37279196d8acSJiri Slaby 37289196d8acSJiri Slaby uart = serial8250_find_match_or_unused(&up->port); 37299196d8acSJiri Slaby if (uart && uart->port.type != PORT_8250_CIR) { 37309196d8acSJiri Slaby if (uart->port.dev) 37319196d8acSJiri Slaby uart_remove_one_port(&serial8250_reg, &uart->port); 37329196d8acSJiri Slaby 37339196d8acSJiri Slaby uart->port.iobase = up->port.iobase; 37349196d8acSJiri Slaby uart->port.membase = up->port.membase; 37359196d8acSJiri Slaby uart->port.irq = up->port.irq; 37369196d8acSJiri Slaby uart->port.irqflags = up->port.irqflags; 37379196d8acSJiri Slaby uart->port.uartclk = up->port.uartclk; 37389196d8acSJiri Slaby uart->port.fifosize = up->port.fifosize; 37399196d8acSJiri Slaby uart->port.regshift = up->port.regshift; 37409196d8acSJiri Slaby uart->port.iotype = up->port.iotype; 37419196d8acSJiri Slaby uart->port.flags = up->port.flags | UPF_BOOT_AUTOCONF; 37429196d8acSJiri Slaby uart->bugs = up->bugs; 37439196d8acSJiri Slaby uart->port.mapbase = up->port.mapbase; 37449196d8acSJiri Slaby uart->port.private_data = up->port.private_data; 37459196d8acSJiri Slaby uart->port.fifosize = up->port.fifosize; 37469196d8acSJiri Slaby uart->tx_loadsz = up->tx_loadsz; 37479196d8acSJiri Slaby uart->capabilities = up->capabilities; 3748234abab1SSebastian Andrzej Siewior uart->port.throttle = up->port.throttle; 3749234abab1SSebastian Andrzej Siewior uart->port.unthrottle = up->port.unthrottle; 375046c55b4bSRicardo Ribalda Delgado uart->port.rs485_config = up->port.rs485_config; 375146c55b4bSRicardo Ribalda Delgado uart->port.rs485 = up->port.rs485; 3752d53e1428SPeter Hurley uart->dma = up->dma; 37539196d8acSJiri Slaby 3754ef99f3aeSGreg Kroah-Hartman /* Take tx_loadsz from fifosize if it wasn't set separately */ 3755ef99f3aeSGreg Kroah-Hartman if (uart->port.fifosize && !uart->tx_loadsz) 3756ef99f3aeSGreg Kroah-Hartman uart->tx_loadsz = uart->port.fifosize; 3757ef99f3aeSGreg Kroah-Hartman 37589196d8acSJiri Slaby if (up->port.dev) 37599196d8acSJiri Slaby uart->port.dev = up->port.dev; 37609196d8acSJiri Slaby 3761e13cb72bSPeter Hurley if (skip_txen_test) 3762e13cb72bSPeter Hurley uart->port.flags |= UPF_NO_TXEN_TEST; 3763e13cb72bSPeter Hurley 37649196d8acSJiri Slaby if (up->port.flags & UPF_FIXED_TYPE) 3765afd483bdSPeter Hurley uart->port.type = up->port.type; 37669196d8acSJiri Slaby 37671a53e079SPeter Hurley serial8250_set_defaults(uart); 37681a53e079SPeter Hurley 37699196d8acSJiri Slaby /* Possibly override default I/O functions. */ 37709196d8acSJiri Slaby if (up->port.serial_in) 37719196d8acSJiri Slaby uart->port.serial_in = up->port.serial_in; 37729196d8acSJiri Slaby if (up->port.serial_out) 37739196d8acSJiri Slaby uart->port.serial_out = up->port.serial_out; 37749196d8acSJiri Slaby if (up->port.handle_irq) 37759196d8acSJiri Slaby uart->port.handle_irq = up->port.handle_irq; 37769196d8acSJiri Slaby /* Possibly override set_termios call */ 37779196d8acSJiri Slaby if (up->port.set_termios) 37789196d8acSJiri Slaby uart->port.set_termios = up->port.set_termios; 37794bf4ea9dSPeter Hurley if (up->port.set_mctrl) 37804bf4ea9dSPeter Hurley uart->port.set_mctrl = up->port.set_mctrl; 3781b99b121bSSebastian Andrzej Siewior if (up->port.startup) 3782b99b121bSSebastian Andrzej Siewior uart->port.startup = up->port.startup; 3783b99b121bSSebastian Andrzej Siewior if (up->port.shutdown) 3784b99b121bSSebastian Andrzej Siewior uart->port.shutdown = up->port.shutdown; 37859196d8acSJiri Slaby if (up->port.pm) 37869196d8acSJiri Slaby uart->port.pm = up->port.pm; 37879196d8acSJiri Slaby if (up->port.handle_break) 37889196d8acSJiri Slaby uart->port.handle_break = up->port.handle_break; 37899196d8acSJiri Slaby if (up->dl_read) 37909196d8acSJiri Slaby uart->dl_read = up->dl_read; 37919196d8acSJiri Slaby if (up->dl_write) 37929196d8acSJiri Slaby uart->dl_write = up->dl_write; 37939196d8acSJiri Slaby 37949196d8acSJiri Slaby if (serial8250_isa_config != NULL) 37959196d8acSJiri Slaby serial8250_isa_config(0, &uart->port, 37969196d8acSJiri Slaby &uart->capabilities); 37979196d8acSJiri Slaby 37989196d8acSJiri Slaby ret = uart_add_one_port(&serial8250_reg, &uart->port); 37999196d8acSJiri Slaby if (ret == 0) 38009196d8acSJiri Slaby ret = uart->port.line; 38019196d8acSJiri Slaby } 38029196d8acSJiri Slaby mutex_unlock(&serial_mutex); 38039196d8acSJiri Slaby 38049196d8acSJiri Slaby return ret; 38059196d8acSJiri Slaby } 38069196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_register_8250_port); 38079196d8acSJiri Slaby 38089196d8acSJiri Slaby /** 38099196d8acSJiri Slaby * serial8250_unregister_port - remove a 16x50 serial port at runtime 38109196d8acSJiri Slaby * @line: serial line number 38119196d8acSJiri Slaby * 38129196d8acSJiri Slaby * Remove one serial port. This may not be called from interrupt 38139196d8acSJiri Slaby * context. We hand the port back to the our control. 38149196d8acSJiri Slaby */ 38159196d8acSJiri Slaby void serial8250_unregister_port(int line) 38169196d8acSJiri Slaby { 38179196d8acSJiri Slaby struct uart_8250_port *uart = &serial8250_ports[line]; 38189196d8acSJiri Slaby 38199196d8acSJiri Slaby mutex_lock(&serial_mutex); 38209196d8acSJiri Slaby uart_remove_one_port(&serial8250_reg, &uart->port); 38219196d8acSJiri Slaby if (serial8250_isa_devs) { 38229196d8acSJiri Slaby uart->port.flags &= ~UPF_BOOT_AUTOCONF; 3823e13cb72bSPeter Hurley if (skip_txen_test) 3824e13cb72bSPeter Hurley uart->port.flags |= UPF_NO_TXEN_TEST; 38259196d8acSJiri Slaby uart->port.type = PORT_UNKNOWN; 38269196d8acSJiri Slaby uart->port.dev = &serial8250_isa_devs->dev; 38275db496b9SPeter Hurley uart->capabilities = 0; 38289196d8acSJiri Slaby uart_add_one_port(&serial8250_reg, &uart->port); 38299196d8acSJiri Slaby } else { 38309196d8acSJiri Slaby uart->port.dev = NULL; 38319196d8acSJiri Slaby } 38329196d8acSJiri Slaby mutex_unlock(&serial_mutex); 38339196d8acSJiri Slaby } 38349196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_unregister_port); 38359196d8acSJiri Slaby 38369196d8acSJiri Slaby static int __init serial8250_init(void) 38379196d8acSJiri Slaby { 38389196d8acSJiri Slaby int ret; 38399196d8acSJiri Slaby 38409196d8acSJiri Slaby serial8250_isa_init_ports(); 38419196d8acSJiri Slaby 38429196d8acSJiri Slaby printk(KERN_INFO "Serial: 8250/16550 driver, " 38439196d8acSJiri Slaby "%d ports, IRQ sharing %sabled\n", nr_uarts, 38449196d8acSJiri Slaby share_irqs ? "en" : "dis"); 38459196d8acSJiri Slaby 38469196d8acSJiri Slaby #ifdef CONFIG_SPARC 38479196d8acSJiri Slaby ret = sunserial_register_minors(&serial8250_reg, UART_NR); 38489196d8acSJiri Slaby #else 38499196d8acSJiri Slaby serial8250_reg.nr = UART_NR; 38509196d8acSJiri Slaby ret = uart_register_driver(&serial8250_reg); 38519196d8acSJiri Slaby #endif 38529196d8acSJiri Slaby if (ret) 38539196d8acSJiri Slaby goto out; 38549196d8acSJiri Slaby 38559196d8acSJiri Slaby ret = serial8250_pnp_init(); 38569196d8acSJiri Slaby if (ret) 38579196d8acSJiri Slaby goto unreg_uart_drv; 38589196d8acSJiri Slaby 38599196d8acSJiri Slaby serial8250_isa_devs = platform_device_alloc("serial8250", 38609196d8acSJiri Slaby PLAT8250_DEV_LEGACY); 38619196d8acSJiri Slaby if (!serial8250_isa_devs) { 38629196d8acSJiri Slaby ret = -ENOMEM; 38639196d8acSJiri Slaby goto unreg_pnp; 38649196d8acSJiri Slaby } 38659196d8acSJiri Slaby 38669196d8acSJiri Slaby ret = platform_device_add(serial8250_isa_devs); 38679196d8acSJiri Slaby if (ret) 38689196d8acSJiri Slaby goto put_dev; 38699196d8acSJiri Slaby 38709196d8acSJiri Slaby serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev); 38719196d8acSJiri Slaby 38729196d8acSJiri Slaby ret = platform_driver_register(&serial8250_isa_driver); 38739196d8acSJiri Slaby if (ret == 0) 38749196d8acSJiri Slaby goto out; 38759196d8acSJiri Slaby 38769196d8acSJiri Slaby platform_device_del(serial8250_isa_devs); 38779196d8acSJiri Slaby put_dev: 38789196d8acSJiri Slaby platform_device_put(serial8250_isa_devs); 38799196d8acSJiri Slaby unreg_pnp: 38809196d8acSJiri Slaby serial8250_pnp_exit(); 38819196d8acSJiri Slaby unreg_uart_drv: 38829196d8acSJiri Slaby #ifdef CONFIG_SPARC 38839196d8acSJiri Slaby sunserial_unregister_minors(&serial8250_reg, UART_NR); 38849196d8acSJiri Slaby #else 38859196d8acSJiri Slaby uart_unregister_driver(&serial8250_reg); 38869196d8acSJiri Slaby #endif 38879196d8acSJiri Slaby out: 38889196d8acSJiri Slaby return ret; 38899196d8acSJiri Slaby } 38909196d8acSJiri Slaby 38919196d8acSJiri Slaby static void __exit serial8250_exit(void) 38929196d8acSJiri Slaby { 38939196d8acSJiri Slaby struct platform_device *isa_dev = serial8250_isa_devs; 38949196d8acSJiri Slaby 38959196d8acSJiri Slaby /* 38969196d8acSJiri Slaby * This tells serial8250_unregister_port() not to re-register 38979196d8acSJiri Slaby * the ports (thereby making serial8250_isa_driver permanently 38989196d8acSJiri Slaby * in use.) 38999196d8acSJiri Slaby */ 39009196d8acSJiri Slaby serial8250_isa_devs = NULL; 39019196d8acSJiri Slaby 39029196d8acSJiri Slaby platform_driver_unregister(&serial8250_isa_driver); 39039196d8acSJiri Slaby platform_device_unregister(isa_dev); 39049196d8acSJiri Slaby 39059196d8acSJiri Slaby serial8250_pnp_exit(); 39069196d8acSJiri Slaby 39079196d8acSJiri Slaby #ifdef CONFIG_SPARC 39089196d8acSJiri Slaby sunserial_unregister_minors(&serial8250_reg, UART_NR); 39099196d8acSJiri Slaby #else 39109196d8acSJiri Slaby uart_unregister_driver(&serial8250_reg); 39119196d8acSJiri Slaby #endif 39129196d8acSJiri Slaby } 39139196d8acSJiri Slaby 39149196d8acSJiri Slaby module_init(serial8250_init); 39159196d8acSJiri Slaby module_exit(serial8250_exit); 39169196d8acSJiri Slaby 39179196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_suspend_port); 39189196d8acSJiri Slaby EXPORT_SYMBOL(serial8250_resume_port); 39199196d8acSJiri Slaby 39209196d8acSJiri Slaby MODULE_LICENSE("GPL"); 39219196d8acSJiri Slaby MODULE_DESCRIPTION("Generic 8250/16x50 serial driver"); 39229196d8acSJiri Slaby 39239196d8acSJiri Slaby module_param(share_irqs, uint, 0644); 39249196d8acSJiri Slaby MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices" 39259196d8acSJiri Slaby " (unsafe)"); 39269196d8acSJiri Slaby 39279196d8acSJiri Slaby module_param(nr_uarts, uint, 0644); 39289196d8acSJiri Slaby MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")"); 39299196d8acSJiri Slaby 39309196d8acSJiri Slaby module_param(skip_txen_test, uint, 0644); 39319196d8acSJiri Slaby MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time"); 39329196d8acSJiri Slaby 39339196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 39349196d8acSJiri Slaby module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444); 39359196d8acSJiri Slaby MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA"); 39369196d8acSJiri Slaby #endif 39379196d8acSJiri Slaby MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR); 39389196d8acSJiri Slaby 39399326b047SJiri Slaby #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS 39409196d8acSJiri Slaby #ifndef MODULE 39419196d8acSJiri Slaby /* This module was renamed to 8250_core in 3.7. Keep the old "8250" name 39429196d8acSJiri Slaby * working as well for the module options so we don't break people. We 39439196d8acSJiri Slaby * need to keep the names identical and the convenient macros will happily 39449196d8acSJiri Slaby * refuse to let us do that by failing the build with redefinition errors 39459196d8acSJiri Slaby * of global variables. So we stick them inside a dummy function to avoid 39469196d8acSJiri Slaby * those conflicts. The options still get parsed, and the redefined 39479196d8acSJiri Slaby * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive. 39489196d8acSJiri Slaby * 39499196d8acSJiri Slaby * This is hacky. I'm sorry. 39509196d8acSJiri Slaby */ 39519196d8acSJiri Slaby static void __used s8250_options(void) 39529196d8acSJiri Slaby { 39539196d8acSJiri Slaby #undef MODULE_PARAM_PREFIX 39549196d8acSJiri Slaby #define MODULE_PARAM_PREFIX "8250_core." 39559196d8acSJiri Slaby 39569196d8acSJiri Slaby module_param_cb(share_irqs, ¶m_ops_uint, &share_irqs, 0644); 39579196d8acSJiri Slaby module_param_cb(nr_uarts, ¶m_ops_uint, &nr_uarts, 0644); 39589196d8acSJiri Slaby module_param_cb(skip_txen_test, ¶m_ops_uint, &skip_txen_test, 0644); 39599196d8acSJiri Slaby #ifdef CONFIG_SERIAL_8250_RSA 39609196d8acSJiri Slaby __module_param_call(MODULE_PARAM_PREFIX, probe_rsa, 39619196d8acSJiri Slaby ¶m_array_ops, .arr = &__param_arr_probe_rsa, 396291f9d330SJani Nikula 0444, -1, 0); 39639196d8acSJiri Slaby #endif 39649196d8acSJiri Slaby } 39659196d8acSJiri Slaby #else 39669196d8acSJiri Slaby MODULE_ALIAS("8250_core"); 39679196d8acSJiri Slaby #endif 39689326b047SJiri Slaby #endif 3969