1e3b3d0f5SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2ab4382d2SGreg Kroah-Hartman /* 3ab4382d2SGreg Kroah-Hartman * uartlite.c: Serial driver for Xilinx uartlite serial controller 4ab4382d2SGreg Kroah-Hartman * 5ab4382d2SGreg Kroah-Hartman * Copyright (C) 2006 Peter Korsgaard <jacmet@sunsite.dk> 6ab4382d2SGreg Kroah-Hartman * Copyright (C) 2007 Secret Lab Technologies Ltd. 7ab4382d2SGreg Kroah-Hartman */ 8ab4382d2SGreg Kroah-Hartman 9ab4382d2SGreg Kroah-Hartman #include <linux/platform_device.h> 10ab4382d2SGreg Kroah-Hartman #include <linux/module.h> 11ea017f58SSean Anderson #include <linux/bitfield.h> 12ab4382d2SGreg Kroah-Hartman #include <linux/console.h> 13ab4382d2SGreg Kroah-Hartman #include <linux/serial.h> 14ab4382d2SGreg Kroah-Hartman #include <linux/serial_core.h> 15ab4382d2SGreg Kroah-Hartman #include <linux/tty.h> 16ee160a38SJiri Slaby #include <linux/tty_flip.h> 17ab4382d2SGreg Kroah-Hartman #include <linux/delay.h> 18ab4382d2SGreg Kroah-Hartman #include <linux/interrupt.h> 19ab4382d2SGreg Kroah-Hartman #include <linux/init.h> 203240b48dSMichal Simek #include <linux/io.h> 212e5f3a69SSean Anderson #include <linux/iopoll.h> 22ab4382d2SGreg Kroah-Hartman #include <linux/of.h> 23ab4382d2SGreg Kroah-Hartman #include <linux/of_address.h> 24ab4382d2SGreg Kroah-Hartman #include <linux/of_device.h> 25ab4382d2SGreg Kroah-Hartman #include <linux/of_platform.h> 2614288befSShubhrajyoti Datta #include <linux/clk.h> 275bbe10a6SShubhrajyoti Datta #include <linux/pm_runtime.h> 28ab4382d2SGreg Kroah-Hartman 29ab4382d2SGreg Kroah-Hartman #define ULITE_NAME "ttyUL" 30ab4382d2SGreg Kroah-Hartman #define ULITE_MAJOR 204 31ab4382d2SGreg Kroah-Hartman #define ULITE_MINOR 187 32b44b96a0SSam Povilus #define ULITE_NR_UARTS CONFIG_SERIAL_UARTLITE_NR_UARTS 33ab4382d2SGreg Kroah-Hartman 34ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 35ab4382d2SGreg Kroah-Hartman * Register definitions 36ab4382d2SGreg Kroah-Hartman * 37ab4382d2SGreg Kroah-Hartman * For register details see datasheet: 3882ee0b14SAlexander A. Klimov * https://www.xilinx.com/support/documentation/ip_documentation/opb_uartlite.pdf 39ab4382d2SGreg Kroah-Hartman */ 40ab4382d2SGreg Kroah-Hartman 41ab4382d2SGreg Kroah-Hartman #define ULITE_RX 0x00 42ab4382d2SGreg Kroah-Hartman #define ULITE_TX 0x04 43ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS 0x08 44ab4382d2SGreg Kroah-Hartman #define ULITE_CONTROL 0x0c 45ab4382d2SGreg Kroah-Hartman 46ab4382d2SGreg Kroah-Hartman #define ULITE_REGION 16 47ab4382d2SGreg Kroah-Hartman 48ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_RXVALID 0x01 49ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_RXFULL 0x02 50ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_TXEMPTY 0x04 51ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_TXFULL 0x08 52ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_IE 0x10 53ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_OVERRUN 0x20 54ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_FRAME 0x40 55ab4382d2SGreg Kroah-Hartman #define ULITE_STATUS_PARITY 0x80 56ab4382d2SGreg Kroah-Hartman 57ab4382d2SGreg Kroah-Hartman #define ULITE_CONTROL_RST_TX 0x01 58ab4382d2SGreg Kroah-Hartman #define ULITE_CONTROL_RST_RX 0x02 59ab4382d2SGreg Kroah-Hartman #define ULITE_CONTROL_IE 0x10 605bbe10a6SShubhrajyoti Datta #define UART_AUTOSUSPEND_TIMEOUT 3000 /* ms */ 61ab4382d2SGreg Kroah-Hartman 62deeb33e8SShubhrajyoti Datta /* Static pointer to console port */ 63deeb33e8SShubhrajyoti Datta #ifdef CONFIG_SERIAL_UARTLITE_CONSOLE 64deeb33e8SShubhrajyoti Datta static struct uart_port *console_port; 65deeb33e8SShubhrajyoti Datta #endif 66deeb33e8SShubhrajyoti Datta 67ea017f58SSean Anderson /** 68ea017f58SSean Anderson * struct uartlite_data: Driver private data 69ea017f58SSean Anderson * reg_ops: Functions to read/write registers 70ea017f58SSean Anderson * clk: Our parent clock, if present 71ea017f58SSean Anderson * baud: The baud rate configured when this device was synthesized 72ea017f58SSean Anderson * cflags: The cflags for parity and data bits 73ea017f58SSean Anderson */ 74da7bf20eSShubhrajyoti Datta struct uartlite_data { 75da7bf20eSShubhrajyoti Datta const struct uartlite_reg_ops *reg_ops; 7614288befSShubhrajyoti Datta struct clk *clk; 77ea017f58SSean Anderson unsigned int baud; 78ea017f58SSean Anderson tcflag_t cflags; 79da7bf20eSShubhrajyoti Datta }; 80da7bf20eSShubhrajyoti Datta 816d53c3b7SMichal Simek struct uartlite_reg_ops { 826d53c3b7SMichal Simek u32 (*in)(void __iomem *addr); 836d53c3b7SMichal Simek void (*out)(u32 val, void __iomem *addr); 846d53c3b7SMichal Simek }; 856d53c3b7SMichal Simek 866d53c3b7SMichal Simek static u32 uartlite_inbe32(void __iomem *addr) 876d53c3b7SMichal Simek { 886d53c3b7SMichal Simek return ioread32be(addr); 896d53c3b7SMichal Simek } 906d53c3b7SMichal Simek 916d53c3b7SMichal Simek static void uartlite_outbe32(u32 val, void __iomem *addr) 926d53c3b7SMichal Simek { 936d53c3b7SMichal Simek iowrite32be(val, addr); 946d53c3b7SMichal Simek } 956d53c3b7SMichal Simek 96973ea59eSMaarten Brock static const struct uartlite_reg_ops uartlite_be = { 976d53c3b7SMichal Simek .in = uartlite_inbe32, 986d53c3b7SMichal Simek .out = uartlite_outbe32, 996d53c3b7SMichal Simek }; 1006d53c3b7SMichal Simek 1016d53c3b7SMichal Simek static u32 uartlite_inle32(void __iomem *addr) 1026d53c3b7SMichal Simek { 1036d53c3b7SMichal Simek return ioread32(addr); 1046d53c3b7SMichal Simek } 1056d53c3b7SMichal Simek 1066d53c3b7SMichal Simek static void uartlite_outle32(u32 val, void __iomem *addr) 1076d53c3b7SMichal Simek { 1086d53c3b7SMichal Simek iowrite32(val, addr); 1096d53c3b7SMichal Simek } 1106d53c3b7SMichal Simek 111973ea59eSMaarten Brock static const struct uartlite_reg_ops uartlite_le = { 1126d53c3b7SMichal Simek .in = uartlite_inle32, 1136d53c3b7SMichal Simek .out = uartlite_outle32, 1146d53c3b7SMichal Simek }; 1156d53c3b7SMichal Simek 1166d53c3b7SMichal Simek static inline u32 uart_in32(u32 offset, struct uart_port *port) 1176d53c3b7SMichal Simek { 118da7bf20eSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 1196d53c3b7SMichal Simek 120da7bf20eSShubhrajyoti Datta return pdata->reg_ops->in(port->membase + offset); 1216d53c3b7SMichal Simek } 1226d53c3b7SMichal Simek 1236d53c3b7SMichal Simek static inline void uart_out32(u32 val, u32 offset, struct uart_port *port) 1246d53c3b7SMichal Simek { 125da7bf20eSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 1266d53c3b7SMichal Simek 127da7bf20eSShubhrajyoti Datta pdata->reg_ops->out(val, port->membase + offset); 1286d53c3b7SMichal Simek } 129ab4382d2SGreg Kroah-Hartman 130ab4382d2SGreg Kroah-Hartman static struct uart_port ulite_ports[ULITE_NR_UARTS]; 131ab4382d2SGreg Kroah-Hartman 132ea017f58SSean Anderson static struct uart_driver ulite_uart_driver; 133ea017f58SSean Anderson 134ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 135ab4382d2SGreg Kroah-Hartman * Core UART driver operations 136ab4382d2SGreg Kroah-Hartman */ 137ab4382d2SGreg Kroah-Hartman 138ab4382d2SGreg Kroah-Hartman static int ulite_receive(struct uart_port *port, int stat) 139ab4382d2SGreg Kroah-Hartman { 14092a19f9cSJiri Slaby struct tty_port *tport = &port->state->port; 141ab4382d2SGreg Kroah-Hartman unsigned char ch = 0; 142ab4382d2SGreg Kroah-Hartman char flag = TTY_NORMAL; 143ab4382d2SGreg Kroah-Hartman 144ab4382d2SGreg Kroah-Hartman if ((stat & (ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN 145ab4382d2SGreg Kroah-Hartman | ULITE_STATUS_FRAME)) == 0) 146ab4382d2SGreg Kroah-Hartman return 0; 147ab4382d2SGreg Kroah-Hartman 148ab4382d2SGreg Kroah-Hartman /* stats */ 149ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_RXVALID) { 150ab4382d2SGreg Kroah-Hartman port->icount.rx++; 1516d53c3b7SMichal Simek ch = uart_in32(ULITE_RX, port); 152ab4382d2SGreg Kroah-Hartman 153ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_PARITY) 154ab4382d2SGreg Kroah-Hartman port->icount.parity++; 155ab4382d2SGreg Kroah-Hartman } 156ab4382d2SGreg Kroah-Hartman 157ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_OVERRUN) 158ab4382d2SGreg Kroah-Hartman port->icount.overrun++; 159ab4382d2SGreg Kroah-Hartman 160ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_FRAME) 161ab4382d2SGreg Kroah-Hartman port->icount.frame++; 162ab4382d2SGreg Kroah-Hartman 163ab4382d2SGreg Kroah-Hartman 164ab4382d2SGreg Kroah-Hartman /* drop byte with parity error if IGNPAR specificed */ 165ab4382d2SGreg Kroah-Hartman if (stat & port->ignore_status_mask & ULITE_STATUS_PARITY) 166ab4382d2SGreg Kroah-Hartman stat &= ~ULITE_STATUS_RXVALID; 167ab4382d2SGreg Kroah-Hartman 168ab4382d2SGreg Kroah-Hartman stat &= port->read_status_mask; 169ab4382d2SGreg Kroah-Hartman 170ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_PARITY) 171ab4382d2SGreg Kroah-Hartman flag = TTY_PARITY; 172ab4382d2SGreg Kroah-Hartman 173ab4382d2SGreg Kroah-Hartman 174ab4382d2SGreg Kroah-Hartman stat &= ~port->ignore_status_mask; 175ab4382d2SGreg Kroah-Hartman 176ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_RXVALID) 17792a19f9cSJiri Slaby tty_insert_flip_char(tport, ch, flag); 178ab4382d2SGreg Kroah-Hartman 179ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_FRAME) 18092a19f9cSJiri Slaby tty_insert_flip_char(tport, 0, TTY_FRAME); 181ab4382d2SGreg Kroah-Hartman 182ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_OVERRUN) 18392a19f9cSJiri Slaby tty_insert_flip_char(tport, 0, TTY_OVERRUN); 184ab4382d2SGreg Kroah-Hartman 185ab4382d2SGreg Kroah-Hartman return 1; 186ab4382d2SGreg Kroah-Hartman } 187ab4382d2SGreg Kroah-Hartman 188ab4382d2SGreg Kroah-Hartman static int ulite_transmit(struct uart_port *port, int stat) 189ab4382d2SGreg Kroah-Hartman { 190ab4382d2SGreg Kroah-Hartman struct circ_buf *xmit = &port->state->xmit; 191ab4382d2SGreg Kroah-Hartman 192ab4382d2SGreg Kroah-Hartman if (stat & ULITE_STATUS_TXFULL) 193ab4382d2SGreg Kroah-Hartman return 0; 194ab4382d2SGreg Kroah-Hartman 195ab4382d2SGreg Kroah-Hartman if (port->x_char) { 1966d53c3b7SMichal Simek uart_out32(port->x_char, ULITE_TX, port); 197ab4382d2SGreg Kroah-Hartman port->x_char = 0; 198ab4382d2SGreg Kroah-Hartman port->icount.tx++; 199ab4382d2SGreg Kroah-Hartman return 1; 200ab4382d2SGreg Kroah-Hartman } 201ab4382d2SGreg Kroah-Hartman 202ab4382d2SGreg Kroah-Hartman if (uart_circ_empty(xmit) || uart_tx_stopped(port)) 203ab4382d2SGreg Kroah-Hartman return 0; 204ab4382d2SGreg Kroah-Hartman 2056d53c3b7SMichal Simek uart_out32(xmit->buf[xmit->tail], ULITE_TX, port); 206852322ffSIlpo Järvinen uart_xmit_advance(port, 1); 207ab4382d2SGreg Kroah-Hartman 208ab4382d2SGreg Kroah-Hartman /* wake up */ 209ab4382d2SGreg Kroah-Hartman if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 210ab4382d2SGreg Kroah-Hartman uart_write_wakeup(port); 211ab4382d2SGreg Kroah-Hartman 212ab4382d2SGreg Kroah-Hartman return 1; 213ab4382d2SGreg Kroah-Hartman } 214ab4382d2SGreg Kroah-Hartman 215ab4382d2SGreg Kroah-Hartman static irqreturn_t ulite_isr(int irq, void *dev_id) 216ab4382d2SGreg Kroah-Hartman { 217ab4382d2SGreg Kroah-Hartman struct uart_port *port = dev_id; 21819606eafSMaarten Brock int stat, busy, n = 0; 2199e370d2cSRich Felker unsigned long flags; 220ab4382d2SGreg Kroah-Hartman 221ab4382d2SGreg Kroah-Hartman do { 22219606eafSMaarten Brock spin_lock_irqsave(&port->lock, flags); 22319606eafSMaarten Brock stat = uart_in32(ULITE_STATUS, port); 224ab4382d2SGreg Kroah-Hartman busy = ulite_receive(port, stat); 225ab4382d2SGreg Kroah-Hartman busy |= ulite_transmit(port, stat); 22619606eafSMaarten Brock spin_unlock_irqrestore(&port->lock, flags); 227ab4382d2SGreg Kroah-Hartman n++; 228ab4382d2SGreg Kroah-Hartman } while (busy); 229ab4382d2SGreg Kroah-Hartman 230ab4382d2SGreg Kroah-Hartman /* work done? */ 231ab4382d2SGreg Kroah-Hartman if (n > 1) { 2322e124b4aSJiri Slaby tty_flip_buffer_push(&port->state->port); 233ab4382d2SGreg Kroah-Hartman return IRQ_HANDLED; 234ab4382d2SGreg Kroah-Hartman } else { 235ab4382d2SGreg Kroah-Hartman return IRQ_NONE; 236ab4382d2SGreg Kroah-Hartman } 237ab4382d2SGreg Kroah-Hartman } 238ab4382d2SGreg Kroah-Hartman 239ab4382d2SGreg Kroah-Hartman static unsigned int ulite_tx_empty(struct uart_port *port) 240ab4382d2SGreg Kroah-Hartman { 241ab4382d2SGreg Kroah-Hartman unsigned long flags; 242ab4382d2SGreg Kroah-Hartman unsigned int ret; 243ab4382d2SGreg Kroah-Hartman 244ab4382d2SGreg Kroah-Hartman spin_lock_irqsave(&port->lock, flags); 2456d53c3b7SMichal Simek ret = uart_in32(ULITE_STATUS, port); 246ab4382d2SGreg Kroah-Hartman spin_unlock_irqrestore(&port->lock, flags); 247ab4382d2SGreg Kroah-Hartman 248ab4382d2SGreg Kroah-Hartman return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0; 249ab4382d2SGreg Kroah-Hartman } 250ab4382d2SGreg Kroah-Hartman 251ab4382d2SGreg Kroah-Hartman static unsigned int ulite_get_mctrl(struct uart_port *port) 252ab4382d2SGreg Kroah-Hartman { 253ab4382d2SGreg Kroah-Hartman return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; 254ab4382d2SGreg Kroah-Hartman } 255ab4382d2SGreg Kroah-Hartman 256ab4382d2SGreg Kroah-Hartman static void ulite_set_mctrl(struct uart_port *port, unsigned int mctrl) 257ab4382d2SGreg Kroah-Hartman { 258ab4382d2SGreg Kroah-Hartman /* N/A */ 259ab4382d2SGreg Kroah-Hartman } 260ab4382d2SGreg Kroah-Hartman 261ab4382d2SGreg Kroah-Hartman static void ulite_stop_tx(struct uart_port *port) 262ab4382d2SGreg Kroah-Hartman { 263ab4382d2SGreg Kroah-Hartman /* N/A */ 264ab4382d2SGreg Kroah-Hartman } 265ab4382d2SGreg Kroah-Hartman 266ab4382d2SGreg Kroah-Hartman static void ulite_start_tx(struct uart_port *port) 267ab4382d2SGreg Kroah-Hartman { 2686d53c3b7SMichal Simek ulite_transmit(port, uart_in32(ULITE_STATUS, port)); 269ab4382d2SGreg Kroah-Hartman } 270ab4382d2SGreg Kroah-Hartman 271ab4382d2SGreg Kroah-Hartman static void ulite_stop_rx(struct uart_port *port) 272ab4382d2SGreg Kroah-Hartman { 273ab4382d2SGreg Kroah-Hartman /* don't forward any more data (like !CREAD) */ 274ab4382d2SGreg Kroah-Hartman port->ignore_status_mask = ULITE_STATUS_RXVALID | ULITE_STATUS_PARITY 275ab4382d2SGreg Kroah-Hartman | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN; 276ab4382d2SGreg Kroah-Hartman } 277ab4382d2SGreg Kroah-Hartman 278ab4382d2SGreg Kroah-Hartman static void ulite_break_ctl(struct uart_port *port, int ctl) 279ab4382d2SGreg Kroah-Hartman { 280ab4382d2SGreg Kroah-Hartman /* N/A */ 281ab4382d2SGreg Kroah-Hartman } 282ab4382d2SGreg Kroah-Hartman 283ab4382d2SGreg Kroah-Hartman static int ulite_startup(struct uart_port *port) 284ab4382d2SGreg Kroah-Hartman { 28514288befSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 286ab4382d2SGreg Kroah-Hartman int ret; 287ab4382d2SGreg Kroah-Hartman 28814288befSShubhrajyoti Datta ret = clk_enable(pdata->clk); 28914288befSShubhrajyoti Datta if (ret) { 29014288befSShubhrajyoti Datta dev_err(port->dev, "Failed to enable clock\n"); 29114288befSShubhrajyoti Datta return ret; 29214288befSShubhrajyoti Datta } 29314288befSShubhrajyoti Datta 294106020ccSMaarten Brock ret = request_irq(port->irq, ulite_isr, IRQF_SHARED | IRQF_TRIGGER_RISING, 295106020ccSMaarten Brock "uartlite", port); 296ab4382d2SGreg Kroah-Hartman if (ret) 297ab4382d2SGreg Kroah-Hartman return ret; 298ab4382d2SGreg Kroah-Hartman 2996d53c3b7SMichal Simek uart_out32(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX, 3006d53c3b7SMichal Simek ULITE_CONTROL, port); 3016d53c3b7SMichal Simek uart_out32(ULITE_CONTROL_IE, ULITE_CONTROL, port); 302ab4382d2SGreg Kroah-Hartman 303ab4382d2SGreg Kroah-Hartman return 0; 304ab4382d2SGreg Kroah-Hartman } 305ab4382d2SGreg Kroah-Hartman 306ab4382d2SGreg Kroah-Hartman static void ulite_shutdown(struct uart_port *port) 307ab4382d2SGreg Kroah-Hartman { 30814288befSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 30914288befSShubhrajyoti Datta 3106d53c3b7SMichal Simek uart_out32(0, ULITE_CONTROL, port); 3116d53c3b7SMichal Simek uart_in32(ULITE_CONTROL, port); /* dummy */ 312ab4382d2SGreg Kroah-Hartman free_irq(port->irq, port); 31314288befSShubhrajyoti Datta clk_disable(pdata->clk); 314ab4382d2SGreg Kroah-Hartman } 315ab4382d2SGreg Kroah-Hartman 316bec5b814SIlpo Järvinen static void ulite_set_termios(struct uart_port *port, 317bec5b814SIlpo Järvinen struct ktermios *termios, 318bec5b814SIlpo Järvinen const struct ktermios *old) 319ab4382d2SGreg Kroah-Hartman { 320ab4382d2SGreg Kroah-Hartman unsigned long flags; 321ea017f58SSean Anderson struct uartlite_data *pdata = port->private_data; 322ea017f58SSean Anderson 323ea017f58SSean Anderson /* Set termios to what the hardware supports */ 3243f7fed40SIlpo Järvinen termios->c_iflag &= ~BRKINT; 3253f7fed40SIlpo Järvinen termios->c_cflag &= ~(CSTOPB | PARENB | PARODD | CSIZE); 326ea017f58SSean Anderson termios->c_cflag |= pdata->cflags & (PARENB | PARODD | CSIZE); 327ea017f58SSean Anderson tty_termios_encode_baud_rate(termios, pdata->baud, pdata->baud); 328ab4382d2SGreg Kroah-Hartman 329ab4382d2SGreg Kroah-Hartman spin_lock_irqsave(&port->lock, flags); 330ab4382d2SGreg Kroah-Hartman 331ab4382d2SGreg Kroah-Hartman port->read_status_mask = ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN 332ab4382d2SGreg Kroah-Hartman | ULITE_STATUS_TXFULL; 333ab4382d2SGreg Kroah-Hartman 334ab4382d2SGreg Kroah-Hartman if (termios->c_iflag & INPCK) 335ab4382d2SGreg Kroah-Hartman port->read_status_mask |= 336ab4382d2SGreg Kroah-Hartman ULITE_STATUS_PARITY | ULITE_STATUS_FRAME; 337ab4382d2SGreg Kroah-Hartman 338ab4382d2SGreg Kroah-Hartman port->ignore_status_mask = 0; 339ab4382d2SGreg Kroah-Hartman if (termios->c_iflag & IGNPAR) 340ab4382d2SGreg Kroah-Hartman port->ignore_status_mask |= ULITE_STATUS_PARITY 341ab4382d2SGreg Kroah-Hartman | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN; 342ab4382d2SGreg Kroah-Hartman 343ab4382d2SGreg Kroah-Hartman /* ignore all characters if CREAD is not set */ 344ab4382d2SGreg Kroah-Hartman if ((termios->c_cflag & CREAD) == 0) 345ab4382d2SGreg Kroah-Hartman port->ignore_status_mask |= 346ab4382d2SGreg Kroah-Hartman ULITE_STATUS_RXVALID | ULITE_STATUS_PARITY 347ab4382d2SGreg Kroah-Hartman | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN; 348ab4382d2SGreg Kroah-Hartman 349ab4382d2SGreg Kroah-Hartman /* update timeout */ 350ea017f58SSean Anderson uart_update_timeout(port, termios->c_cflag, pdata->baud); 351ab4382d2SGreg Kroah-Hartman 352ab4382d2SGreg Kroah-Hartman spin_unlock_irqrestore(&port->lock, flags); 353ab4382d2SGreg Kroah-Hartman } 354ab4382d2SGreg Kroah-Hartman 355ab4382d2SGreg Kroah-Hartman static const char *ulite_type(struct uart_port *port) 356ab4382d2SGreg Kroah-Hartman { 357ab4382d2SGreg Kroah-Hartman return port->type == PORT_UARTLITE ? "uartlite" : NULL; 358ab4382d2SGreg Kroah-Hartman } 359ab4382d2SGreg Kroah-Hartman 360ab4382d2SGreg Kroah-Hartman static void ulite_release_port(struct uart_port *port) 361ab4382d2SGreg Kroah-Hartman { 362ab4382d2SGreg Kroah-Hartman release_mem_region(port->mapbase, ULITE_REGION); 363ab4382d2SGreg Kroah-Hartman iounmap(port->membase); 364ab4382d2SGreg Kroah-Hartman port->membase = NULL; 365ab4382d2SGreg Kroah-Hartman } 366ab4382d2SGreg Kroah-Hartman 367ab4382d2SGreg Kroah-Hartman static int ulite_request_port(struct uart_port *port) 368ab4382d2SGreg Kroah-Hartman { 369da7bf20eSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 3706d53c3b7SMichal Simek int ret; 3716d53c3b7SMichal Simek 372ab4382d2SGreg Kroah-Hartman pr_debug("ulite console: port=%p; port->mapbase=%llx\n", 373ab4382d2SGreg Kroah-Hartman port, (unsigned long long) port->mapbase); 374ab4382d2SGreg Kroah-Hartman 375ab4382d2SGreg Kroah-Hartman if (!request_mem_region(port->mapbase, ULITE_REGION, "uartlite")) { 376ab4382d2SGreg Kroah-Hartman dev_err(port->dev, "Memory region busy\n"); 377ab4382d2SGreg Kroah-Hartman return -EBUSY; 378ab4382d2SGreg Kroah-Hartman } 379ab4382d2SGreg Kroah-Hartman 380ab4382d2SGreg Kroah-Hartman port->membase = ioremap(port->mapbase, ULITE_REGION); 381ab4382d2SGreg Kroah-Hartman if (!port->membase) { 382ab4382d2SGreg Kroah-Hartman dev_err(port->dev, "Unable to map registers\n"); 383ab4382d2SGreg Kroah-Hartman release_mem_region(port->mapbase, ULITE_REGION); 384ab4382d2SGreg Kroah-Hartman return -EBUSY; 385ab4382d2SGreg Kroah-Hartman } 386ab4382d2SGreg Kroah-Hartman 387da7bf20eSShubhrajyoti Datta pdata->reg_ops = &uartlite_be; 3886d53c3b7SMichal Simek ret = uart_in32(ULITE_CONTROL, port); 3896d53c3b7SMichal Simek uart_out32(ULITE_CONTROL_RST_TX, ULITE_CONTROL, port); 3906d53c3b7SMichal Simek ret = uart_in32(ULITE_STATUS, port); 3916d53c3b7SMichal Simek /* Endianess detection */ 3926d53c3b7SMichal Simek if ((ret & ULITE_STATUS_TXEMPTY) != ULITE_STATUS_TXEMPTY) 393da7bf20eSShubhrajyoti Datta pdata->reg_ops = &uartlite_le; 3946d53c3b7SMichal Simek 395ab4382d2SGreg Kroah-Hartman return 0; 396ab4382d2SGreg Kroah-Hartman } 397ab4382d2SGreg Kroah-Hartman 398ab4382d2SGreg Kroah-Hartman static void ulite_config_port(struct uart_port *port, int flags) 399ab4382d2SGreg Kroah-Hartman { 400ab4382d2SGreg Kroah-Hartman if (!ulite_request_port(port)) 401ab4382d2SGreg Kroah-Hartman port->type = PORT_UARTLITE; 402ab4382d2SGreg Kroah-Hartman } 403ab4382d2SGreg Kroah-Hartman 404ab4382d2SGreg Kroah-Hartman static int ulite_verify_port(struct uart_port *port, struct serial_struct *ser) 405ab4382d2SGreg Kroah-Hartman { 406ab4382d2SGreg Kroah-Hartman /* we don't want the core code to modify any port params */ 407ab4382d2SGreg Kroah-Hartman return -EINVAL; 408ab4382d2SGreg Kroah-Hartman } 409ab4382d2SGreg Kroah-Hartman 41014288befSShubhrajyoti Datta static void ulite_pm(struct uart_port *port, unsigned int state, 41114288befSShubhrajyoti Datta unsigned int oldstate) 41214288befSShubhrajyoti Datta { 4135bbe10a6SShubhrajyoti Datta int ret; 41407e5d4ffSGreg Kroah-Hartman 4155bbe10a6SShubhrajyoti Datta if (!state) { 4165bbe10a6SShubhrajyoti Datta ret = pm_runtime_get_sync(port->dev); 4175bbe10a6SShubhrajyoti Datta if (ret < 0) 4185bbe10a6SShubhrajyoti Datta dev_err(port->dev, "Failed to enable clocks\n"); 4195bbe10a6SShubhrajyoti Datta } else { 4205bbe10a6SShubhrajyoti Datta pm_runtime_mark_last_busy(port->dev); 4215bbe10a6SShubhrajyoti Datta pm_runtime_put_autosuspend(port->dev); 4225bbe10a6SShubhrajyoti Datta } 42314288befSShubhrajyoti Datta } 42414288befSShubhrajyoti Datta 425ab4382d2SGreg Kroah-Hartman #ifdef CONFIG_CONSOLE_POLL 426ab4382d2SGreg Kroah-Hartman static int ulite_get_poll_char(struct uart_port *port) 427ab4382d2SGreg Kroah-Hartman { 4286d53c3b7SMichal Simek if (!(uart_in32(ULITE_STATUS, port) & ULITE_STATUS_RXVALID)) 429ab4382d2SGreg Kroah-Hartman return NO_POLL_CHAR; 430ab4382d2SGreg Kroah-Hartman 4316d53c3b7SMichal Simek return uart_in32(ULITE_RX, port); 432ab4382d2SGreg Kroah-Hartman } 433ab4382d2SGreg Kroah-Hartman 434ab4382d2SGreg Kroah-Hartman static void ulite_put_poll_char(struct uart_port *port, unsigned char ch) 435ab4382d2SGreg Kroah-Hartman { 4366d53c3b7SMichal Simek while (uart_in32(ULITE_STATUS, port) & ULITE_STATUS_TXFULL) 437ab4382d2SGreg Kroah-Hartman cpu_relax(); 438ab4382d2SGreg Kroah-Hartman 439ab4382d2SGreg Kroah-Hartman /* write char to device */ 4406d53c3b7SMichal Simek uart_out32(ch, ULITE_TX, port); 441ab4382d2SGreg Kroah-Hartman } 442ab4382d2SGreg Kroah-Hartman #endif 443ab4382d2SGreg Kroah-Hartman 44431d054dcSJulia Lawall static const struct uart_ops ulite_ops = { 445ab4382d2SGreg Kroah-Hartman .tx_empty = ulite_tx_empty, 446ab4382d2SGreg Kroah-Hartman .set_mctrl = ulite_set_mctrl, 447ab4382d2SGreg Kroah-Hartman .get_mctrl = ulite_get_mctrl, 448ab4382d2SGreg Kroah-Hartman .stop_tx = ulite_stop_tx, 449ab4382d2SGreg Kroah-Hartman .start_tx = ulite_start_tx, 450ab4382d2SGreg Kroah-Hartman .stop_rx = ulite_stop_rx, 451ab4382d2SGreg Kroah-Hartman .break_ctl = ulite_break_ctl, 452ab4382d2SGreg Kroah-Hartman .startup = ulite_startup, 453ab4382d2SGreg Kroah-Hartman .shutdown = ulite_shutdown, 454ab4382d2SGreg Kroah-Hartman .set_termios = ulite_set_termios, 455ab4382d2SGreg Kroah-Hartman .type = ulite_type, 456ab4382d2SGreg Kroah-Hartman .release_port = ulite_release_port, 457ab4382d2SGreg Kroah-Hartman .request_port = ulite_request_port, 458ab4382d2SGreg Kroah-Hartman .config_port = ulite_config_port, 459ab4382d2SGreg Kroah-Hartman .verify_port = ulite_verify_port, 46014288befSShubhrajyoti Datta .pm = ulite_pm, 461ab4382d2SGreg Kroah-Hartman #ifdef CONFIG_CONSOLE_POLL 462ab4382d2SGreg Kroah-Hartman .poll_get_char = ulite_get_poll_char, 463ab4382d2SGreg Kroah-Hartman .poll_put_char = ulite_put_poll_char, 464ab4382d2SGreg Kroah-Hartman #endif 465ab4382d2SGreg Kroah-Hartman }; 466ab4382d2SGreg Kroah-Hartman 467ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 468ab4382d2SGreg Kroah-Hartman * Console driver operations 469ab4382d2SGreg Kroah-Hartman */ 470ab4382d2SGreg Kroah-Hartman 471ab4382d2SGreg Kroah-Hartman #ifdef CONFIG_SERIAL_UARTLITE_CONSOLE 472ab4382d2SGreg Kroah-Hartman static void ulite_console_wait_tx(struct uart_port *port) 473ab4382d2SGreg Kroah-Hartman { 474ab4382d2SGreg Kroah-Hartman u8 val; 475ab4382d2SGreg Kroah-Hartman 476d3352154SMichal Simek /* 477d3352154SMichal Simek * Spin waiting for TX fifo to have space available. 478d3352154SMichal Simek * When using the Microblaze Debug Module this can take up to 1s 479d3352154SMichal Simek */ 4802e5f3a69SSean Anderson if (read_poll_timeout_atomic(uart_in32, val, !(val & ULITE_STATUS_TXFULL), 4812e5f3a69SSean Anderson 0, 1000000, false, ULITE_STATUS, port)) 482d3352154SMichal Simek dev_warn(port->dev, 483d3352154SMichal Simek "timeout waiting for TX buffer empty\n"); 484ab4382d2SGreg Kroah-Hartman } 485ab4382d2SGreg Kroah-Hartman 4863f8bab17SJiri Slaby static void ulite_console_putchar(struct uart_port *port, unsigned char ch) 487ab4382d2SGreg Kroah-Hartman { 488ab4382d2SGreg Kroah-Hartman ulite_console_wait_tx(port); 4896d53c3b7SMichal Simek uart_out32(ch, ULITE_TX, port); 490ab4382d2SGreg Kroah-Hartman } 491ab4382d2SGreg Kroah-Hartman 492ab4382d2SGreg Kroah-Hartman static void ulite_console_write(struct console *co, const char *s, 493ab4382d2SGreg Kroah-Hartman unsigned int count) 494ab4382d2SGreg Kroah-Hartman { 495deeb33e8SShubhrajyoti Datta struct uart_port *port = console_port; 496ab4382d2SGreg Kroah-Hartman unsigned long flags; 497ab4382d2SGreg Kroah-Hartman unsigned int ier; 498ab4382d2SGreg Kroah-Hartman int locked = 1; 499ab4382d2SGreg Kroah-Hartman 500ab4382d2SGreg Kroah-Hartman if (oops_in_progress) { 501ab4382d2SGreg Kroah-Hartman locked = spin_trylock_irqsave(&port->lock, flags); 502ab4382d2SGreg Kroah-Hartman } else 503ab4382d2SGreg Kroah-Hartman spin_lock_irqsave(&port->lock, flags); 504ab4382d2SGreg Kroah-Hartman 505ab4382d2SGreg Kroah-Hartman /* save and disable interrupt */ 5066d53c3b7SMichal Simek ier = uart_in32(ULITE_STATUS, port) & ULITE_STATUS_IE; 5076d53c3b7SMichal Simek uart_out32(0, ULITE_CONTROL, port); 508ab4382d2SGreg Kroah-Hartman 509ab4382d2SGreg Kroah-Hartman uart_console_write(port, s, count, ulite_console_putchar); 510ab4382d2SGreg Kroah-Hartman 511ab4382d2SGreg Kroah-Hartman ulite_console_wait_tx(port); 512ab4382d2SGreg Kroah-Hartman 513ab4382d2SGreg Kroah-Hartman /* restore interrupt state */ 514ab4382d2SGreg Kroah-Hartman if (ier) 5156d53c3b7SMichal Simek uart_out32(ULITE_CONTROL_IE, ULITE_CONTROL, port); 516ab4382d2SGreg Kroah-Hartman 517ab4382d2SGreg Kroah-Hartman if (locked) 518ab4382d2SGreg Kroah-Hartman spin_unlock_irqrestore(&port->lock, flags); 519ab4382d2SGreg Kroah-Hartman } 520ab4382d2SGreg Kroah-Hartman 5219671f099SBill Pemberton static int ulite_console_setup(struct console *co, char *options) 522ab4382d2SGreg Kroah-Hartman { 523d157fca7SDaniel Mack struct uart_port *port = NULL; 524ab4382d2SGreg Kroah-Hartman int baud = 9600; 525ab4382d2SGreg Kroah-Hartman int bits = 8; 526ab4382d2SGreg Kroah-Hartman int parity = 'n'; 527ab4382d2SGreg Kroah-Hartman int flow = 'n'; 528ab4382d2SGreg Kroah-Hartman 529d157fca7SDaniel Mack if (co->index >= 0 && co->index < ULITE_NR_UARTS) 530d157fca7SDaniel Mack port = ulite_ports + co->index; 531ab4382d2SGreg Kroah-Hartman 532ab4382d2SGreg Kroah-Hartman /* Has the device been initialized yet? */ 533d157fca7SDaniel Mack if (!port || !port->mapbase) { 534ab4382d2SGreg Kroah-Hartman pr_debug("console on ttyUL%i not present\n", co->index); 535ab4382d2SGreg Kroah-Hartman return -ENODEV; 536ab4382d2SGreg Kroah-Hartman } 537ab4382d2SGreg Kroah-Hartman 538d157fca7SDaniel Mack console_port = port; 539d157fca7SDaniel Mack 540ab4382d2SGreg Kroah-Hartman /* not initialized yet? */ 541ab4382d2SGreg Kroah-Hartman if (!port->membase) { 542ab4382d2SGreg Kroah-Hartman if (ulite_request_port(port)) 543ab4382d2SGreg Kroah-Hartman return -ENODEV; 544ab4382d2SGreg Kroah-Hartman } 545ab4382d2SGreg Kroah-Hartman 546ab4382d2SGreg Kroah-Hartman if (options) 547ab4382d2SGreg Kroah-Hartman uart_parse_options(options, &baud, &parity, &bits, &flow); 548ab4382d2SGreg Kroah-Hartman 549ab4382d2SGreg Kroah-Hartman return uart_set_options(port, co, baud, parity, bits, flow); 550ab4382d2SGreg Kroah-Hartman } 551ab4382d2SGreg Kroah-Hartman 552ab4382d2SGreg Kroah-Hartman static struct console ulite_console = { 553ab4382d2SGreg Kroah-Hartman .name = ULITE_NAME, 554ab4382d2SGreg Kroah-Hartman .write = ulite_console_write, 555ab4382d2SGreg Kroah-Hartman .device = uart_console_device, 556ab4382d2SGreg Kroah-Hartman .setup = ulite_console_setup, 557ab4382d2SGreg Kroah-Hartman .flags = CON_PRINTBUFFER, 558ab4382d2SGreg Kroah-Hartman .index = -1, /* Specified on the cmdline (e.g. console=ttyUL0 ) */ 559ab4382d2SGreg Kroah-Hartman .data = &ulite_uart_driver, 560ab4382d2SGreg Kroah-Hartman }; 561ab4382d2SGreg Kroah-Hartman 5623f8bab17SJiri Slaby static void early_uartlite_putc(struct uart_port *port, unsigned char c) 5637cdcc29eSRich Felker { 5647cdcc29eSRich Felker /* 5657cdcc29eSRich Felker * Limit how many times we'll spin waiting for TX FIFO status. 5667cdcc29eSRich Felker * This will prevent lockups if the base address is incorrectly 5677cdcc29eSRich Felker * set, or any other issue on the UARTLITE. 5687cdcc29eSRich Felker * This limit is pretty arbitrary, unless we are at about 10 baud 5697cdcc29eSRich Felker * we'll never timeout on a working UART. 5707cdcc29eSRich Felker */ 5717cdcc29eSRich Felker unsigned retries = 1000000; 5723620a89bSSean Anderson 5733620a89bSSean Anderson while (--retries && 5743620a89bSSean Anderson (readl(port->membase + ULITE_STATUS) & ULITE_STATUS_TXFULL)) 5757cdcc29eSRich Felker ; 5767cdcc29eSRich Felker 5777cdcc29eSRich Felker /* Only attempt the iowrite if we didn't timeout */ 5787cdcc29eSRich Felker if (retries) 5793620a89bSSean Anderson writel(c & 0xff, port->membase + ULITE_TX); 5807cdcc29eSRich Felker } 5817cdcc29eSRich Felker 5827cdcc29eSRich Felker static void early_uartlite_write(struct console *console, 5837cdcc29eSRich Felker const char *s, unsigned n) 5847cdcc29eSRich Felker { 5857cdcc29eSRich Felker struct earlycon_device *device = console->data; 5867cdcc29eSRich Felker uart_console_write(&device->port, s, n, early_uartlite_putc); 5877cdcc29eSRich Felker } 5887cdcc29eSRich Felker 5897cdcc29eSRich Felker static int __init early_uartlite_setup(struct earlycon_device *device, 5907cdcc29eSRich Felker const char *options) 5917cdcc29eSRich Felker { 5927cdcc29eSRich Felker if (!device->port.membase) 5937cdcc29eSRich Felker return -ENODEV; 5947cdcc29eSRich Felker 5957cdcc29eSRich Felker device->con->write = early_uartlite_write; 5967cdcc29eSRich Felker return 0; 5977cdcc29eSRich Felker } 5987cdcc29eSRich Felker EARLYCON_DECLARE(uartlite, early_uartlite_setup); 5997cdcc29eSRich Felker OF_EARLYCON_DECLARE(uartlite_b, "xlnx,opb-uartlite-1.00.b", early_uartlite_setup); 6007cdcc29eSRich Felker OF_EARLYCON_DECLARE(uartlite_a, "xlnx,xps-uartlite-1.00.a", early_uartlite_setup); 6017cdcc29eSRich Felker 602ab4382d2SGreg Kroah-Hartman #endif /* CONFIG_SERIAL_UARTLITE_CONSOLE */ 603ab4382d2SGreg Kroah-Hartman 604ab4382d2SGreg Kroah-Hartman static struct uart_driver ulite_uart_driver = { 605ab4382d2SGreg Kroah-Hartman .owner = THIS_MODULE, 606ab4382d2SGreg Kroah-Hartman .driver_name = "uartlite", 607ab4382d2SGreg Kroah-Hartman .dev_name = ULITE_NAME, 608ab4382d2SGreg Kroah-Hartman .major = ULITE_MAJOR, 609ab4382d2SGreg Kroah-Hartman .minor = ULITE_MINOR, 610ab4382d2SGreg Kroah-Hartman .nr = ULITE_NR_UARTS, 611ab4382d2SGreg Kroah-Hartman #ifdef CONFIG_SERIAL_UARTLITE_CONSOLE 612ab4382d2SGreg Kroah-Hartman .cons = &ulite_console, 613ab4382d2SGreg Kroah-Hartman #endif 614ab4382d2SGreg Kroah-Hartman }; 615ab4382d2SGreg Kroah-Hartman 616ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 617ab4382d2SGreg Kroah-Hartman * Port assignment functions (mapping devices to uart_port structures) 618ab4382d2SGreg Kroah-Hartman */ 619ab4382d2SGreg Kroah-Hartman 620ab4382d2SGreg Kroah-Hartman /** ulite_assign: register a uartlite device with the driver 621ab4382d2SGreg Kroah-Hartman * 622ab4382d2SGreg Kroah-Hartman * @dev: pointer to device structure 623ab4382d2SGreg Kroah-Hartman * @id: requested id number. Pass -1 for automatic port assignment 624ab4382d2SGreg Kroah-Hartman * @base: base address of uartlite registers 625ab4382d2SGreg Kroah-Hartman * @irq: irq number for uartlite 626da7bf20eSShubhrajyoti Datta * @pdata: private data for uartlite 627ab4382d2SGreg Kroah-Hartman * 628ab4382d2SGreg Kroah-Hartman * Returns: 0 on success, <0 otherwise 629ab4382d2SGreg Kroah-Hartman */ 6303672fb65SLizhi Hou static int ulite_assign(struct device *dev, int id, phys_addr_t base, int irq, 631da7bf20eSShubhrajyoti Datta struct uartlite_data *pdata) 632ab4382d2SGreg Kroah-Hartman { 633ab4382d2SGreg Kroah-Hartman struct uart_port *port; 634ab4382d2SGreg Kroah-Hartman int rc; 635ab4382d2SGreg Kroah-Hartman 636ab4382d2SGreg Kroah-Hartman /* if id = -1; then scan for a free id and use that */ 637ab4382d2SGreg Kroah-Hartman if (id < 0) { 638ab4382d2SGreg Kroah-Hartman for (id = 0; id < ULITE_NR_UARTS; id++) 639ab4382d2SGreg Kroah-Hartman if (ulite_ports[id].mapbase == 0) 640ab4382d2SGreg Kroah-Hartman break; 641ab4382d2SGreg Kroah-Hartman } 642ab4382d2SGreg Kroah-Hartman if (id < 0 || id >= ULITE_NR_UARTS) { 643ab4382d2SGreg Kroah-Hartman dev_err(dev, "%s%i too large\n", ULITE_NAME, id); 644ab4382d2SGreg Kroah-Hartman return -EINVAL; 645ab4382d2SGreg Kroah-Hartman } 646ab4382d2SGreg Kroah-Hartman 647ab4382d2SGreg Kroah-Hartman if ((ulite_ports[id].mapbase) && (ulite_ports[id].mapbase != base)) { 648ab4382d2SGreg Kroah-Hartman dev_err(dev, "cannot assign to %s%i; it is already in use\n", 649ab4382d2SGreg Kroah-Hartman ULITE_NAME, id); 650ab4382d2SGreg Kroah-Hartman return -EBUSY; 651ab4382d2SGreg Kroah-Hartman } 652ab4382d2SGreg Kroah-Hartman 653ab4382d2SGreg Kroah-Hartman port = &ulite_ports[id]; 654ab4382d2SGreg Kroah-Hartman 655ab4382d2SGreg Kroah-Hartman spin_lock_init(&port->lock); 656ab4382d2SGreg Kroah-Hartman port->fifosize = 16; 657ab4382d2SGreg Kroah-Hartman port->regshift = 2; 658ab4382d2SGreg Kroah-Hartman port->iotype = UPIO_MEM; 659ab4382d2SGreg Kroah-Hartman port->iobase = 1; /* mark port in use */ 660ab4382d2SGreg Kroah-Hartman port->mapbase = base; 661ab4382d2SGreg Kroah-Hartman port->membase = NULL; 662ab4382d2SGreg Kroah-Hartman port->ops = &ulite_ops; 663ab4382d2SGreg Kroah-Hartman port->irq = irq; 664ab4382d2SGreg Kroah-Hartman port->flags = UPF_BOOT_AUTOCONF; 665ab4382d2SGreg Kroah-Hartman port->dev = dev; 666ab4382d2SGreg Kroah-Hartman port->type = PORT_UNKNOWN; 667ab4382d2SGreg Kroah-Hartman port->line = id; 668da7bf20eSShubhrajyoti Datta port->private_data = pdata; 669ab4382d2SGreg Kroah-Hartman 670ab4382d2SGreg Kroah-Hartman dev_set_drvdata(dev, port); 671ab4382d2SGreg Kroah-Hartman 672ab4382d2SGreg Kroah-Hartman /* Register the port */ 67361ad2a02SGreg Kroah-Hartman rc = uart_add_one_port(&ulite_uart_driver, port); 674ab4382d2SGreg Kroah-Hartman if (rc) { 675ab4382d2SGreg Kroah-Hartman dev_err(dev, "uart_add_one_port() failed; err=%i\n", rc); 676ab4382d2SGreg Kroah-Hartman port->mapbase = 0; 677ab4382d2SGreg Kroah-Hartman dev_set_drvdata(dev, NULL); 678ab4382d2SGreg Kroah-Hartman return rc; 679ab4382d2SGreg Kroah-Hartman } 680ab4382d2SGreg Kroah-Hartman 681ab4382d2SGreg Kroah-Hartman return 0; 682ab4382d2SGreg Kroah-Hartman } 683ab4382d2SGreg Kroah-Hartman 684ab4382d2SGreg Kroah-Hartman /** ulite_release: register a uartlite device with the driver 685ab4382d2SGreg Kroah-Hartman * 686ab4382d2SGreg Kroah-Hartman * @dev: pointer to device structure 687ab4382d2SGreg Kroah-Hartman */ 688*d5b3d02dSUwe Kleine-König static void ulite_release(struct device *dev) 689ab4382d2SGreg Kroah-Hartman { 690ab4382d2SGreg Kroah-Hartman struct uart_port *port = dev_get_drvdata(dev); 691ab4382d2SGreg Kroah-Hartman 692ab4382d2SGreg Kroah-Hartman if (port) { 693*d5b3d02dSUwe Kleine-König uart_remove_one_port(&ulite_uart_driver, port); 694ab4382d2SGreg Kroah-Hartman dev_set_drvdata(dev, NULL); 695ab4382d2SGreg Kroah-Hartman port->mapbase = 0; 696ab4382d2SGreg Kroah-Hartman } 697ab4382d2SGreg Kroah-Hartman } 698ab4382d2SGreg Kroah-Hartman 699a3a10614SShubhrajyoti Datta /** 700a3a10614SShubhrajyoti Datta * ulite_suspend - Stop the device. 701a3a10614SShubhrajyoti Datta * 702a3a10614SShubhrajyoti Datta * @dev: handle to the device structure. 703a3a10614SShubhrajyoti Datta * Return: 0 always. 704a3a10614SShubhrajyoti Datta */ 705a3a10614SShubhrajyoti Datta static int __maybe_unused ulite_suspend(struct device *dev) 706a3a10614SShubhrajyoti Datta { 707a3a10614SShubhrajyoti Datta struct uart_port *port = dev_get_drvdata(dev); 708ee0a29baSColin Ian King 7095d8508aaSGreg Kroah-Hartman if (port) 7105d8508aaSGreg Kroah-Hartman uart_suspend_port(&ulite_uart_driver, port); 711a3a10614SShubhrajyoti Datta 712a3a10614SShubhrajyoti Datta return 0; 713a3a10614SShubhrajyoti Datta } 714a3a10614SShubhrajyoti Datta 715a3a10614SShubhrajyoti Datta /** 716a3a10614SShubhrajyoti Datta * ulite_resume - Resume the device. 717a3a10614SShubhrajyoti Datta * 718a3a10614SShubhrajyoti Datta * @dev: handle to the device structure. 719a3a10614SShubhrajyoti Datta * Return: 0 on success, errno otherwise. 720a3a10614SShubhrajyoti Datta */ 721a3a10614SShubhrajyoti Datta static int __maybe_unused ulite_resume(struct device *dev) 722a3a10614SShubhrajyoti Datta { 723a3a10614SShubhrajyoti Datta struct uart_port *port = dev_get_drvdata(dev); 724ee0a29baSColin Ian King 7255d8508aaSGreg Kroah-Hartman if (port) 7265d8508aaSGreg Kroah-Hartman uart_resume_port(&ulite_uart_driver, port); 727a3a10614SShubhrajyoti Datta 728a3a10614SShubhrajyoti Datta return 0; 729a3a10614SShubhrajyoti Datta } 730a3a10614SShubhrajyoti Datta 7315bbe10a6SShubhrajyoti Datta static int __maybe_unused ulite_runtime_suspend(struct device *dev) 7325bbe10a6SShubhrajyoti Datta { 7335bbe10a6SShubhrajyoti Datta struct uart_port *port = dev_get_drvdata(dev); 7345bbe10a6SShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 7355bbe10a6SShubhrajyoti Datta 7365bbe10a6SShubhrajyoti Datta clk_disable(pdata->clk); 7375bbe10a6SShubhrajyoti Datta return 0; 7385bbe10a6SShubhrajyoti Datta }; 7395bbe10a6SShubhrajyoti Datta 7405bbe10a6SShubhrajyoti Datta static int __maybe_unused ulite_runtime_resume(struct device *dev) 7415bbe10a6SShubhrajyoti Datta { 7425bbe10a6SShubhrajyoti Datta struct uart_port *port = dev_get_drvdata(dev); 7435bbe10a6SShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 7445bbe10a6SShubhrajyoti Datta int ret; 7455bbe10a6SShubhrajyoti Datta 7465bbe10a6SShubhrajyoti Datta ret = clk_enable(pdata->clk); 7475bbe10a6SShubhrajyoti Datta if (ret) { 7485bbe10a6SShubhrajyoti Datta dev_err(dev, "Cannot enable clock.\n"); 7495bbe10a6SShubhrajyoti Datta return ret; 7505bbe10a6SShubhrajyoti Datta } 7515bbe10a6SShubhrajyoti Datta return 0; 7525bbe10a6SShubhrajyoti Datta } 7535bbe10a6SShubhrajyoti Datta 754ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 755ab4382d2SGreg Kroah-Hartman * Platform bus binding 756ab4382d2SGreg Kroah-Hartman */ 757a3a10614SShubhrajyoti Datta 7585bbe10a6SShubhrajyoti Datta static const struct dev_pm_ops ulite_pm_ops = { 7595bbe10a6SShubhrajyoti Datta SET_SYSTEM_SLEEP_PM_OPS(ulite_suspend, ulite_resume) 7605bbe10a6SShubhrajyoti Datta SET_RUNTIME_PM_OPS(ulite_runtime_suspend, 7615bbe10a6SShubhrajyoti Datta ulite_runtime_resume, NULL) 7625bbe10a6SShubhrajyoti Datta }; 763a3a10614SShubhrajyoti Datta 764e5263a51SGrant Likely #if defined(CONFIG_OF) 765e5263a51SGrant Likely /* Match table for of_platform binding */ 766ed0bb232SFabian Frederick static const struct of_device_id ulite_of_match[] = { 767e5263a51SGrant Likely { .compatible = "xlnx,opb-uartlite-1.00.b", }, 768e5263a51SGrant Likely { .compatible = "xlnx,xps-uartlite-1.00.a", }, 769e5263a51SGrant Likely {} 770e5263a51SGrant Likely }; 771e5263a51SGrant Likely MODULE_DEVICE_TABLE(of, ulite_of_match); 772e5263a51SGrant Likely #endif /* CONFIG_OF */ 773e5263a51SGrant Likely 7749671f099SBill Pemberton static int ulite_probe(struct platform_device *pdev) 775ab4382d2SGreg Kroah-Hartman { 7765c90c07bSMichal Simek struct resource *res; 777da7bf20eSShubhrajyoti Datta struct uartlite_data *pdata; 77814288befSShubhrajyoti Datta int irq, ret; 779e5263a51SGrant Likely int id = pdev->id; 780e5263a51SGrant Likely 781da7bf20eSShubhrajyoti Datta pdata = devm_kzalloc(&pdev->dev, sizeof(struct uartlite_data), 782da7bf20eSShubhrajyoti Datta GFP_KERNEL); 783da7bf20eSShubhrajyoti Datta if (!pdata) 784da7bf20eSShubhrajyoti Datta return -ENOMEM; 785ab4382d2SGreg Kroah-Hartman 786ea017f58SSean Anderson if (IS_ENABLED(CONFIG_OF)) { 787ea017f58SSean Anderson const char *prop; 788ea017f58SSean Anderson struct device_node *np = pdev->dev.of_node; 789ea017f58SSean Anderson u32 val = 0; 790ea017f58SSean Anderson 791ea017f58SSean Anderson prop = "port-number"; 792ea017f58SSean Anderson ret = of_property_read_u32(np, prop, &id); 793ea017f58SSean Anderson if (ret && ret != -EINVAL) 794ea017f58SSean Anderson of_err: 795ea017f58SSean Anderson return dev_err_probe(&pdev->dev, ret, 796ea017f58SSean Anderson "could not read %s\n", prop); 797ea017f58SSean Anderson 798ea017f58SSean Anderson prop = "current-speed"; 799ea017f58SSean Anderson ret = of_property_read_u32(np, prop, &pdata->baud); 800ea017f58SSean Anderson if (ret) 801ea017f58SSean Anderson goto of_err; 802ea017f58SSean Anderson 803ea017f58SSean Anderson prop = "xlnx,use-parity"; 804ea017f58SSean Anderson ret = of_property_read_u32(np, prop, &val); 805ea017f58SSean Anderson if (ret && ret != -EINVAL) 806ea017f58SSean Anderson goto of_err; 807ea017f58SSean Anderson 808ea017f58SSean Anderson if (val) { 809ea017f58SSean Anderson prop = "xlnx,odd-parity"; 810ea017f58SSean Anderson ret = of_property_read_u32(np, prop, &val); 811ea017f58SSean Anderson if (ret) 812ea017f58SSean Anderson goto of_err; 813ea017f58SSean Anderson 814ea017f58SSean Anderson if (val) 815ea017f58SSean Anderson pdata->cflags |= PARODD; 816ea017f58SSean Anderson pdata->cflags |= PARENB; 817ea017f58SSean Anderson } 818ea017f58SSean Anderson 819ea017f58SSean Anderson val = 8; 820ea017f58SSean Anderson prop = "xlnx,data-bits"; 821ea017f58SSean Anderson ret = of_property_read_u32(np, prop, &val); 822ea017f58SSean Anderson if (ret && ret != -EINVAL) 823ea017f58SSean Anderson goto of_err; 824ea017f58SSean Anderson 825ea017f58SSean Anderson switch (val) { 826ea017f58SSean Anderson case 5: 827ea017f58SSean Anderson pdata->cflags |= CS5; 828ea017f58SSean Anderson break; 829ea017f58SSean Anderson case 6: 830ea017f58SSean Anderson pdata->cflags |= CS6; 831ea017f58SSean Anderson break; 832ea017f58SSean Anderson case 7: 833ea017f58SSean Anderson pdata->cflags |= CS7; 834ea017f58SSean Anderson break; 835ea017f58SSean Anderson case 8: 836ea017f58SSean Anderson pdata->cflags |= CS8; 837ea017f58SSean Anderson break; 838ea017f58SSean Anderson default: 839ea017f58SSean Anderson return dev_err_probe(&pdev->dev, -EINVAL, 840ea017f58SSean Anderson "bad data bits %d\n", val); 841ea017f58SSean Anderson } 842ea017f58SSean Anderson } else { 843ea017f58SSean Anderson pdata->baud = 9600; 844ea017f58SSean Anderson pdata->cflags = CS8; 845ea017f58SSean Anderson } 846ea017f58SSean Anderson 847ab4382d2SGreg Kroah-Hartman res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 848ab4382d2SGreg Kroah-Hartman if (!res) 849ab4382d2SGreg Kroah-Hartman return -ENODEV; 850ab4382d2SGreg Kroah-Hartman 8515c90c07bSMichal Simek irq = platform_get_irq(pdev, 0); 8520b60525bSAlexander Sverdlin if (irq < 0) 8530b60525bSAlexander Sverdlin return irq; 854ab4382d2SGreg Kroah-Hartman 85514288befSShubhrajyoti Datta pdata->clk = devm_clk_get(&pdev->dev, "s_axi_aclk"); 85614288befSShubhrajyoti Datta if (IS_ERR(pdata->clk)) { 85714288befSShubhrajyoti Datta if (PTR_ERR(pdata->clk) != -ENOENT) 85814288befSShubhrajyoti Datta return PTR_ERR(pdata->clk); 85914288befSShubhrajyoti Datta 86014288befSShubhrajyoti Datta /* 86114288befSShubhrajyoti Datta * Clock framework support is optional, continue on 86214288befSShubhrajyoti Datta * anyways if we don't find a matching clock. 86314288befSShubhrajyoti Datta */ 86414288befSShubhrajyoti Datta pdata->clk = NULL; 86514288befSShubhrajyoti Datta } 86614288befSShubhrajyoti Datta 867ea42d7a6SShubhrajyoti Datta ret = clk_prepare_enable(pdata->clk); 86814288befSShubhrajyoti Datta if (ret) { 86914288befSShubhrajyoti Datta dev_err(&pdev->dev, "Failed to prepare clock\n"); 87014288befSShubhrajyoti Datta return ret; 87114288befSShubhrajyoti Datta } 87214288befSShubhrajyoti Datta 8735bbe10a6SShubhrajyoti Datta pm_runtime_use_autosuspend(&pdev->dev); 8745bbe10a6SShubhrajyoti Datta pm_runtime_set_autosuspend_delay(&pdev->dev, UART_AUTOSUSPEND_TIMEOUT); 8755bbe10a6SShubhrajyoti Datta pm_runtime_set_active(&pdev->dev); 8765bbe10a6SShubhrajyoti Datta pm_runtime_enable(&pdev->dev); 8775bbe10a6SShubhrajyoti Datta 878f4c47547SGreg Kroah-Hartman if (!ulite_uart_driver.state) { 879f4c47547SGreg Kroah-Hartman dev_dbg(&pdev->dev, "uartlite: calling uart_register_driver()\n"); 880f4c47547SGreg Kroah-Hartman ret = uart_register_driver(&ulite_uart_driver); 881f4c47547SGreg Kroah-Hartman if (ret < 0) { 882f4c47547SGreg Kroah-Hartman dev_err(&pdev->dev, "Failed to register driver\n"); 883ed623dffSShubhrajyoti Datta clk_disable_unprepare(pdata->clk); 884f4c47547SGreg Kroah-Hartman return ret; 885f4c47547SGreg Kroah-Hartman } 886f4c47547SGreg Kroah-Hartman } 887f4c47547SGreg Kroah-Hartman 888ea42d7a6SShubhrajyoti Datta ret = ulite_assign(&pdev->dev, id, res->start, irq, pdata); 889ea42d7a6SShubhrajyoti Datta 8905bbe10a6SShubhrajyoti Datta pm_runtime_mark_last_busy(&pdev->dev); 8915bbe10a6SShubhrajyoti Datta pm_runtime_put_autosuspend(&pdev->dev); 892ea42d7a6SShubhrajyoti Datta 893ea42d7a6SShubhrajyoti Datta return ret; 894ab4382d2SGreg Kroah-Hartman } 895ab4382d2SGreg Kroah-Hartman 896ae8d8a14SBill Pemberton static int ulite_remove(struct platform_device *pdev) 897ab4382d2SGreg Kroah-Hartman { 89814288befSShubhrajyoti Datta struct uart_port *port = dev_get_drvdata(&pdev->dev); 89914288befSShubhrajyoti Datta struct uartlite_data *pdata = port->private_data; 90014288befSShubhrajyoti Datta 9016a7ce07dSChuhong Yuan clk_disable_unprepare(pdata->clk); 902*d5b3d02dSUwe Kleine-König ulite_release(&pdev->dev); 9035bbe10a6SShubhrajyoti Datta pm_runtime_disable(&pdev->dev); 9045bbe10a6SShubhrajyoti Datta pm_runtime_set_suspended(&pdev->dev); 9055bbe10a6SShubhrajyoti Datta pm_runtime_dont_use_autosuspend(&pdev->dev); 906*d5b3d02dSUwe Kleine-König return 0; 907ab4382d2SGreg Kroah-Hartman } 908ab4382d2SGreg Kroah-Hartman 909ab4382d2SGreg Kroah-Hartman /* work with hotplug and coldplug */ 910ab4382d2SGreg Kroah-Hartman MODULE_ALIAS("platform:uartlite"); 911ab4382d2SGreg Kroah-Hartman 912ab4382d2SGreg Kroah-Hartman static struct platform_driver ulite_platform_driver = { 913ab4382d2SGreg Kroah-Hartman .probe = ulite_probe, 9142d47b716SBill Pemberton .remove = ulite_remove, 915ab4382d2SGreg Kroah-Hartman .driver = { 916ab4382d2SGreg Kroah-Hartman .name = "uartlite", 91785888069SBen Dooks .of_match_table = of_match_ptr(ulite_of_match), 918a3a10614SShubhrajyoti Datta .pm = &ulite_pm_ops, 919ab4382d2SGreg Kroah-Hartman }, 920ab4382d2SGreg Kroah-Hartman }; 921ab4382d2SGreg Kroah-Hartman 922ab4382d2SGreg Kroah-Hartman /* --------------------------------------------------------------------- 923ab4382d2SGreg Kroah-Hartman * Module setup/teardown 924ab4382d2SGreg Kroah-Hartman */ 925ab4382d2SGreg Kroah-Hartman 9263240b48dSMichal Simek static int __init ulite_init(void) 927ab4382d2SGreg Kroah-Hartman { 928ab4382d2SGreg Kroah-Hartman 929ab4382d2SGreg Kroah-Hartman pr_debug("uartlite: calling platform_driver_register()\n"); 930415b43bdSShubhrajyoti Datta return platform_driver_register(&ulite_platform_driver); 931ab4382d2SGreg Kroah-Hartman } 932ab4382d2SGreg Kroah-Hartman 9333240b48dSMichal Simek static void __exit ulite_exit(void) 934ab4382d2SGreg Kroah-Hartman { 935ab4382d2SGreg Kroah-Hartman platform_driver_unregister(&ulite_platform_driver); 936a553add0SRandy Dunlap if (ulite_uart_driver.state) 937ab4382d2SGreg Kroah-Hartman uart_unregister_driver(&ulite_uart_driver); 938ab4382d2SGreg Kroah-Hartman } 939ab4382d2SGreg Kroah-Hartman 940ab4382d2SGreg Kroah-Hartman module_init(ulite_init); 941ab4382d2SGreg Kroah-Hartman module_exit(ulite_exit); 942ab4382d2SGreg Kroah-Hartman 943ab4382d2SGreg Kroah-Hartman MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>"); 944ab4382d2SGreg Kroah-Hartman MODULE_DESCRIPTION("Xilinx uartlite serial driver"); 945ab4382d2SGreg Kroah-Hartman MODULE_LICENSE("GPL"); 946