Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * SiFive UART driver
4 * Copyright (C) 2018 Paul Walmsley <paul@pwsan.com>
5 * Copyright (C) 2018-2019 SiFive
6 *
7 * Based partially on:
8 * - drivers/tty/serial/pxa.c
9 * - drivers/tty/serial/amba-pl011.c
10 * - drivers/tty/serial/uartlite.c
11 * - drivers/tty/serial/omap-serial.c
12 * - drivers/pwm/pwm-sifive.c
13 *
14 * See the following sources for further documentation:
15 * - Chapter 19 "Universal Asynchronous Receiver/Transmitter (UART)" of
16 * SiFive FE310-G000 v2p3
17 * - The tree/master/src/main/scala/devices/uart directory of
18 * https://github.com/sifive/sifive-blocks/
19 *
20 * The SiFive UART design is not 8250-compatible. The following common
21 * features are not supported:
22 * - Word lengths other than 8 bits
23 * - Break handling
24 * - Parity
25 * - Flow control
26 * - Modem signals (DSR, RI, etc.)
27 * On the other hand, the design is free from the baggage of the 8250
28 * programming model.
29 */
30
31#include <linux/clk.h>
32#include <linux/console.h>
33#include <linux/delay.h>
34#include <linux/init.h>
35#include <linux/io.h>
36#include <linux/irq.h>
37#include <linux/module.h>
38#include <linux/of.h>
39#include <linux/of_irq.h>
40#include <linux/platform_device.h>
41#include <linux/serial_core.h>
42#include <linux/serial_reg.h>
43#include <linux/slab.h>
44#include <linux/tty.h>
45#include <linux/tty_flip.h>
46
47/*
48 * Register offsets
49 */
50
51/* TXDATA */
52#define SIFIVE_SERIAL_TXDATA_OFFS 0x0
53#define SIFIVE_SERIAL_TXDATA_FULL_SHIFT 31
54#define SIFIVE_SERIAL_TXDATA_FULL_MASK (1 << SIFIVE_SERIAL_TXDATA_FULL_SHIFT)
55#define SIFIVE_SERIAL_TXDATA_DATA_SHIFT 0
56#define SIFIVE_SERIAL_TXDATA_DATA_MASK (0xff << SIFIVE_SERIAL_TXDATA_DATA_SHIFT)
57
58/* RXDATA */
59#define SIFIVE_SERIAL_RXDATA_OFFS 0x4
60#define SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT 31
61#define SIFIVE_SERIAL_RXDATA_EMPTY_MASK (1 << SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT)
62#define SIFIVE_SERIAL_RXDATA_DATA_SHIFT 0
63#define SIFIVE_SERIAL_RXDATA_DATA_MASK (0xff << SIFIVE_SERIAL_RXDATA_DATA_SHIFT)
64
65/* TXCTRL */
66#define SIFIVE_SERIAL_TXCTRL_OFFS 0x8
67#define SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT 16
68#define SIFIVE_SERIAL_TXCTRL_TXCNT_MASK (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
69#define SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT 1
70#define SIFIVE_SERIAL_TXCTRL_NSTOP_MASK (1 << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT)
71#define SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT 0
72#define SIFIVE_SERIAL_TXCTRL_TXEN_MASK (1 << SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT)
73
74/* RXCTRL */
75#define SIFIVE_SERIAL_RXCTRL_OFFS 0xC
76#define SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT 16
77#define SIFIVE_SERIAL_RXCTRL_RXCNT_MASK (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
78#define SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT 0
79#define SIFIVE_SERIAL_RXCTRL_RXEN_MASK (1 << SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT)
80
81/* IE */
82#define SIFIVE_SERIAL_IE_OFFS 0x10
83#define SIFIVE_SERIAL_IE_RXWM_SHIFT 1
84#define SIFIVE_SERIAL_IE_RXWM_MASK (1 << SIFIVE_SERIAL_IE_RXWM_SHIFT)
85#define SIFIVE_SERIAL_IE_TXWM_SHIFT 0
86#define SIFIVE_SERIAL_IE_TXWM_MASK (1 << SIFIVE_SERIAL_IE_TXWM_SHIFT)
87
88/* IP */
89#define SIFIVE_SERIAL_IP_OFFS 0x14
90#define SIFIVE_SERIAL_IP_RXWM_SHIFT 1
91#define SIFIVE_SERIAL_IP_RXWM_MASK (1 << SIFIVE_SERIAL_IP_RXWM_SHIFT)
92#define SIFIVE_SERIAL_IP_TXWM_SHIFT 0
93#define SIFIVE_SERIAL_IP_TXWM_MASK (1 << SIFIVE_SERIAL_IP_TXWM_SHIFT)
94
95/* DIV */
96#define SIFIVE_SERIAL_DIV_OFFS 0x18
97#define SIFIVE_SERIAL_DIV_DIV_SHIFT 0
98#define SIFIVE_SERIAL_DIV_DIV_MASK (0xffff << SIFIVE_SERIAL_IP_DIV_SHIFT)
99
100/*
101 * Config macros
102 */
103
104/*
105 * SIFIVE_SERIAL_MAX_PORTS: maximum number of UARTs on a device that can
106 * host a serial console
107 */
108#define SIFIVE_SERIAL_MAX_PORTS 8
109
110/*
111 * SIFIVE_DEFAULT_BAUD_RATE: default baud rate that the driver should
112 * configure itself to use
113 */
114#define SIFIVE_DEFAULT_BAUD_RATE 115200
115
116/* SIFIVE_SERIAL_NAME: our driver's name that we pass to the operating system */
117#define SIFIVE_SERIAL_NAME "sifive-serial"
118
119/* SIFIVE_TTY_PREFIX: tty name prefix for SiFive serial ports */
120#define SIFIVE_TTY_PREFIX "ttySIF"
121
122/* SIFIVE_TX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
123#define SIFIVE_TX_FIFO_DEPTH 8
124
125/* SIFIVE_RX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
126#define SIFIVE_RX_FIFO_DEPTH 8
127
128#if (SIFIVE_TX_FIFO_DEPTH != SIFIVE_RX_FIFO_DEPTH)
129#error Driver does not support configurations with different TX, RX FIFO sizes
130#endif
131
132/*
133 *
134 */
135
136/**
137 * struct sifive_serial_port - driver-specific data extension to struct uart_port
138 * @port: struct uart_port embedded in this struct
139 * @dev: struct device *
140 * @ier: shadowed copy of the interrupt enable register
141 * @baud_rate: UART serial line rate (e.g., 115200 baud)
142 * @clk: reference to this device's clock
143 * @clk_notifier: clock rate change notifier for upstream clock changes
144 *
145 * Configuration data specific to this SiFive UART.
146 */
147struct sifive_serial_port {
148 struct uart_port port;
149 struct device *dev;
150 unsigned char ier;
151 unsigned long baud_rate;
152 struct clk *clk;
153 struct notifier_block clk_notifier;
154};
155
156/*
157 * Structure container-of macros
158 */
159
160#define port_to_sifive_serial_port(p) (container_of((p), \
161 struct sifive_serial_port, \
162 port))
163
164#define notifier_to_sifive_serial_port(nb) (container_of((nb), \
165 struct sifive_serial_port, \
166 clk_notifier))
167
168/*
169 * Forward declarations
170 */
171static void sifive_serial_stop_tx(struct uart_port *port);
172
173/*
174 * Internal functions
175 */
176
177/**
178 * __ssp_early_writel() - write to a SiFive serial port register (early)
179 * @port: pointer to a struct uart_port record
180 * @offs: register address offset from the IP block base address
181 * @v: value to write to the register
182 *
183 * Given a pointer @port to a struct uart_port record, write the value
184 * @v to the IP block register address offset @offs. This function is
185 * intended for early console use.
186 *
187 * Context: Intended to be used only by the earlyconsole code.
188 */
189static void __ssp_early_writel(u32 v, u16 offs, struct uart_port *port)
190{
191 writel_relaxed(v, port->membase + offs);
192}
193
194/**
195 * __ssp_early_readl() - read from a SiFive serial port register (early)
196 * @port: pointer to a struct uart_port record
197 * @offs: register address offset from the IP block base address
198 *
199 * Given a pointer @port to a struct uart_port record, read the
200 * contents of the IP block register located at offset @offs from the
201 * IP block base and return it. This function is intended for early
202 * console use.
203 *
204 * Context: Intended to be called only by the earlyconsole code or by
205 * __ssp_readl() or __ssp_writel() (in this driver)
206 *
207 * Returns: the register value read from the UART.
208 */
209static u32 __ssp_early_readl(struct uart_port *port, u16 offs)
210{
211 return readl_relaxed(port->membase + offs);
212}
213
214/**
215 * __ssp_writel() - write to a SiFive serial port register
216 * @v: value to write to the register
217 * @offs: register address offset from the IP block base address
218 * @ssp: pointer to a struct sifive_serial_port record
219 *
220 * Write the value @v to the IP block register located at offset @offs from the
221 * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
222 *
223 * Context: Any context.
224 */
225static void __ssp_writel(u32 v, u16 offs, struct sifive_serial_port *ssp)
226{
227 __ssp_early_writel(v, offs, &ssp->port);
228}
229
230/**
231 * __ssp_readl() - read from a SiFive serial port register
232 * @ssp: pointer to a struct sifive_serial_port record
233 * @offs: register address offset from the IP block base address
234 *
235 * Read the contents of the IP block register located at offset @offs from the
236 * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
237 *
238 * Context: Any context.
239 *
240 * Returns: the value of the UART register
241 */
242static u32 __ssp_readl(struct sifive_serial_port *ssp, u16 offs)
243{
244 return __ssp_early_readl(&ssp->port, offs);
245}
246
247/**
248 * sifive_serial_is_txfifo_full() - is the TXFIFO full?
249 * @ssp: pointer to a struct sifive_serial_port
250 *
251 * Read the transmit FIFO "full" bit, returning a non-zero value if the
252 * TX FIFO is full, or zero if space remains. Intended to be used to prevent
253 * writes to the TX FIFO when it's full.
254 *
255 * Returns: SIFIVE_SERIAL_TXDATA_FULL_MASK (non-zero) if the transmit FIFO
256 * is full, or 0 if space remains.
257 */
258static int sifive_serial_is_txfifo_full(struct sifive_serial_port *ssp)
259{
260 return __ssp_readl(ssp, SIFIVE_SERIAL_TXDATA_OFFS) &
261 SIFIVE_SERIAL_TXDATA_FULL_MASK;
262}
263
264/**
265 * __ssp_transmit_char() - enqueue a byte to transmit onto the TX FIFO
266 * @ssp: pointer to a struct sifive_serial_port
267 * @ch: character to transmit
268 *
269 * Enqueue a byte @ch onto the transmit FIFO, given a pointer @ssp to the
270 * struct sifive_serial_port * to transmit on. Caller should first check to
271 * ensure that the TXFIFO has space; see sifive_serial_is_txfifo_full().
272 *
273 * Context: Any context.
274 */
275static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch)
276{
277 __ssp_writel(ch, SIFIVE_SERIAL_TXDATA_OFFS, ssp);
278}
279
280/**
281 * __ssp_transmit_chars() - enqueue multiple bytes onto the TX FIFO
282 * @ssp: pointer to a struct sifive_serial_port
283 *
284 * Transfer up to a TX FIFO size's worth of characters from the Linux serial
285 * transmit buffer to the SiFive UART TX FIFO.
286 *
287 * Context: Any context. Expects @ssp->port.lock to be held by caller.
288 */
289static void __ssp_transmit_chars(struct sifive_serial_port *ssp)
290{
291 u8 ch;
292
293 uart_port_tx_limited(&ssp->port, ch, SIFIVE_TX_FIFO_DEPTH,
294 true,
295 __ssp_transmit_char(ssp, ch),
296 ({}));
297}
298
299/**
300 * __ssp_enable_txwm() - enable transmit watermark interrupts
301 * @ssp: pointer to a struct sifive_serial_port
302 *
303 * Enable interrupt generation when the transmit FIFO watermark is reached
304 * on the SiFive UART referred to by @ssp.
305 */
306static void __ssp_enable_txwm(struct sifive_serial_port *ssp)
307{
308 if (ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK)
309 return;
310
311 ssp->ier |= SIFIVE_SERIAL_IE_TXWM_MASK;
312 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
313}
314
315/**
316 * __ssp_enable_rxwm() - enable receive watermark interrupts
317 * @ssp: pointer to a struct sifive_serial_port
318 *
319 * Enable interrupt generation when the receive FIFO watermark is reached
320 * on the SiFive UART referred to by @ssp.
321 */
322static void __ssp_enable_rxwm(struct sifive_serial_port *ssp)
323{
324 if (ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK)
325 return;
326
327 ssp->ier |= SIFIVE_SERIAL_IE_RXWM_MASK;
328 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
329}
330
331/**
332 * __ssp_disable_txwm() - disable transmit watermark interrupts
333 * @ssp: pointer to a struct sifive_serial_port
334 *
335 * Disable interrupt generation when the transmit FIFO watermark is reached
336 * on the UART referred to by @ssp.
337 */
338static void __ssp_disable_txwm(struct sifive_serial_port *ssp)
339{
340 if (!(ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK))
341 return;
342
343 ssp->ier &= ~SIFIVE_SERIAL_IE_TXWM_MASK;
344 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
345}
346
347/**
348 * __ssp_disable_rxwm() - disable receive watermark interrupts
349 * @ssp: pointer to a struct sifive_serial_port
350 *
351 * Disable interrupt generation when the receive FIFO watermark is reached
352 * on the UART referred to by @ssp.
353 */
354static void __ssp_disable_rxwm(struct sifive_serial_port *ssp)
355{
356 if (!(ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK))
357 return;
358
359 ssp->ier &= ~SIFIVE_SERIAL_IE_RXWM_MASK;
360 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
361}
362
363/**
364 * __ssp_receive_char() - receive a byte from the UART
365 * @ssp: pointer to a struct sifive_serial_port
366 * @is_empty: char pointer to return whether the RX FIFO is empty
367 *
368 * Try to read a byte from the SiFive UART RX FIFO, referenced by
369 * @ssp, and to return it. Also returns the RX FIFO empty bit in
370 * the char pointed to by @ch. The caller must pass the byte back to the
371 * Linux serial layer if needed.
372 *
373 * Returns: the byte read from the UART RX FIFO.
374 */
375static char __ssp_receive_char(struct sifive_serial_port *ssp, char *is_empty)
376{
377 u32 v;
378 u8 ch;
379
380 v = __ssp_readl(ssp, SIFIVE_SERIAL_RXDATA_OFFS);
381
382 if (!is_empty)
383 WARN_ON(1);
384 else
385 *is_empty = (v & SIFIVE_SERIAL_RXDATA_EMPTY_MASK) >>
386 SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT;
387
388 ch = (v & SIFIVE_SERIAL_RXDATA_DATA_MASK) >>
389 SIFIVE_SERIAL_RXDATA_DATA_SHIFT;
390
391 return ch;
392}
393
394/**
395 * __ssp_receive_chars() - receive multiple bytes from the UART
396 * @ssp: pointer to a struct sifive_serial_port
397 *
398 * Receive up to an RX FIFO's worth of bytes from the SiFive UART referred
399 * to by @ssp and pass them up to the Linux serial layer.
400 *
401 * Context: Expects ssp->port.lock to be held by caller.
402 */
403static void __ssp_receive_chars(struct sifive_serial_port *ssp)
404{
405 char is_empty;
406 int c;
407 u8 ch;
408
409 for (c = SIFIVE_RX_FIFO_DEPTH; c > 0; --c) {
410 ch = __ssp_receive_char(ssp, &is_empty);
411 if (is_empty)
412 break;
413
414 ssp->port.icount.rx++;
415 uart_insert_char(&ssp->port, 0, 0, ch, TTY_NORMAL);
416 }
417
418 tty_flip_buffer_push(&ssp->port.state->port);
419}
420
421/**
422 * __ssp_update_div() - calculate the divisor setting by the line rate
423 * @ssp: pointer to a struct sifive_serial_port
424 *
425 * Calculate the appropriate value of the clock divisor for the UART
426 * and target line rate referred to by @ssp and write it into the
427 * hardware.
428 */
429static void __ssp_update_div(struct sifive_serial_port *ssp)
430{
431 u16 div;
432
433 div = DIV_ROUND_UP(ssp->port.uartclk, ssp->baud_rate) - 1;
434
435 __ssp_writel(div, SIFIVE_SERIAL_DIV_OFFS, ssp);
436}
437
438/**
439 * __ssp_update_baud_rate() - set the UART "baud rate"
440 * @ssp: pointer to a struct sifive_serial_port
441 * @rate: new target bit rate
442 *
443 * Calculate the UART divisor value for the target bit rate @rate for the
444 * SiFive UART described by @ssp and program it into the UART. There may
445 * be some error between the target bit rate and the actual bit rate implemented
446 * by the UART due to clock ratio granularity.
447 */
448static void __ssp_update_baud_rate(struct sifive_serial_port *ssp,
449 unsigned int rate)
450{
451 if (ssp->baud_rate == rate)
452 return;
453
454 ssp->baud_rate = rate;
455 __ssp_update_div(ssp);
456}
457
458/**
459 * __ssp_set_stop_bits() - set the number of stop bits
460 * @ssp: pointer to a struct sifive_serial_port
461 * @nstop: 1 or 2 (stop bits)
462 *
463 * Program the SiFive UART referred to by @ssp to use @nstop stop bits.
464 */
465static void __ssp_set_stop_bits(struct sifive_serial_port *ssp, char nstop)
466{
467 u32 v;
468
469 if (nstop < 1 || nstop > 2) {
470 WARN_ON(1);
471 return;
472 }
473
474 v = __ssp_readl(ssp, SIFIVE_SERIAL_TXCTRL_OFFS);
475 v &= ~SIFIVE_SERIAL_TXCTRL_NSTOP_MASK;
476 v |= (nstop - 1) << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT;
477 __ssp_writel(v, SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
478}
479
480/**
481 * __ssp_wait_for_xmitr() - wait for an empty slot on the TX FIFO
482 * @ssp: pointer to a struct sifive_serial_port
483 *
484 * Delay while the UART TX FIFO referred to by @ssp is marked as full.
485 *
486 * Context: Any context.
487 */
488static void __maybe_unused __ssp_wait_for_xmitr(struct sifive_serial_port *ssp)
489{
490 while (sifive_serial_is_txfifo_full(ssp))
491 udelay(1); /* XXX Could probably be more intelligent here */
492}
493
494/*
495 * Linux serial API functions
496 */
497
498static void sifive_serial_stop_tx(struct uart_port *port)
499{
500 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
501
502 __ssp_disable_txwm(ssp);
503}
504
505static void sifive_serial_stop_rx(struct uart_port *port)
506{
507 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
508
509 __ssp_disable_rxwm(ssp);
510}
511
512static void sifive_serial_start_tx(struct uart_port *port)
513{
514 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
515
516 __ssp_enable_txwm(ssp);
517}
518
519static irqreturn_t sifive_serial_irq(int irq, void *dev_id)
520{
521 struct sifive_serial_port *ssp = dev_id;
522 u32 ip;
523
524 uart_port_lock(&ssp->port);
525
526 ip = __ssp_readl(ssp, SIFIVE_SERIAL_IP_OFFS);
527 if (!ip) {
528 uart_port_unlock(&ssp->port);
529 return IRQ_NONE;
530 }
531
532 if (ip & SIFIVE_SERIAL_IP_RXWM_MASK)
533 __ssp_receive_chars(ssp);
534 if (ip & SIFIVE_SERIAL_IP_TXWM_MASK)
535 __ssp_transmit_chars(ssp);
536
537 uart_port_unlock(&ssp->port);
538
539 return IRQ_HANDLED;
540}
541
542static unsigned int sifive_serial_tx_empty(struct uart_port *port)
543{
544 return TIOCSER_TEMT;
545}
546
547static unsigned int sifive_serial_get_mctrl(struct uart_port *port)
548{
549 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
550}
551
552static void sifive_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
553{
554 /* IP block does not support these signals */
555}
556
557static void sifive_serial_break_ctl(struct uart_port *port, int break_state)
558{
559 /* IP block does not support sending a break */
560}
561
562static int sifive_serial_startup(struct uart_port *port)
563{
564 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
565
566 __ssp_enable_rxwm(ssp);
567
568 return 0;
569}
570
571static void sifive_serial_shutdown(struct uart_port *port)
572{
573 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
574
575 __ssp_disable_rxwm(ssp);
576 __ssp_disable_txwm(ssp);
577}
578
579/**
580 * sifive_serial_clk_notifier() - clock post-rate-change notifier
581 * @nb: pointer to the struct notifier_block, from the notifier code
582 * @event: event mask from the notifier code
583 * @data: pointer to the struct clk_notifier_data from the notifier code
584 *
585 * On the V0 SoC, the UART IP block is derived from the CPU clock source
586 * after a synchronous divide-by-two divider, so any CPU clock rate change
587 * requires the UART baud rate to be updated. This presumably corrupts any
588 * serial word currently being transmitted or received. In order to avoid
589 * corrupting the output data stream, we drain the transmit queue before
590 * allowing the clock's rate to be changed.
591 */
592static int sifive_serial_clk_notifier(struct notifier_block *nb,
593 unsigned long event, void *data)
594{
595 struct clk_notifier_data *cnd = data;
596 struct sifive_serial_port *ssp = notifier_to_sifive_serial_port(nb);
597
598 if (event == PRE_RATE_CHANGE) {
599 /*
600 * The TX watermark is always set to 1 by this driver, which
601 * means that the TX busy bit will lower when there are 0 bytes
602 * left in the TX queue -- in other words, when the TX FIFO is
603 * empty.
604 */
605 __ssp_wait_for_xmitr(ssp);
606 /*
607 * On the cycle the TX FIFO goes empty there is still a full
608 * UART frame left to be transmitted in the shift register.
609 * The UART provides no way for software to directly determine
610 * when that last frame has been transmitted, so we just sleep
611 * here instead. As we're not tracking the number of stop bits
612 * they're just worst cased here. The rest of the serial
613 * framing parameters aren't configurable by software.
614 */
615 udelay(DIV_ROUND_UP(12 * 1000 * 1000, ssp->baud_rate));
616 }
617
618 if (event == POST_RATE_CHANGE && ssp->port.uartclk != cnd->new_rate) {
619 ssp->port.uartclk = cnd->new_rate;
620 __ssp_update_div(ssp);
621 }
622
623 return NOTIFY_OK;
624}
625
626static void sifive_serial_set_termios(struct uart_port *port,
627 struct ktermios *termios,
628 const struct ktermios *old)
629{
630 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
631 unsigned long flags;
632 u32 v, old_v;
633 int rate;
634 char nstop;
635
636 if ((termios->c_cflag & CSIZE) != CS8) {
637 dev_err_once(ssp->port.dev, "only 8-bit words supported\n");
638 termios->c_cflag &= ~CSIZE;
639 termios->c_cflag |= CS8;
640 }
641 if (termios->c_iflag & (INPCK | PARMRK))
642 dev_err_once(ssp->port.dev, "parity checking not supported\n");
643 if (termios->c_iflag & BRKINT)
644 dev_err_once(ssp->port.dev, "BREAK detection not supported\n");
645 termios->c_iflag &= ~(INPCK|PARMRK|BRKINT);
646
647 /* Set number of stop bits */
648 nstop = (termios->c_cflag & CSTOPB) ? 2 : 1;
649 __ssp_set_stop_bits(ssp, nstop);
650
651 /* Set line rate */
652 rate = uart_get_baud_rate(port, termios, old, 0,
653 ssp->port.uartclk / 16);
654 __ssp_update_baud_rate(ssp, rate);
655
656 uart_port_lock_irqsave(&ssp->port, &flags);
657
658 /* Update the per-port timeout */
659 uart_update_timeout(port, termios->c_cflag, rate);
660
661 ssp->port.read_status_mask = 0;
662
663 /* Ignore all characters if CREAD is not set */
664 v = __ssp_readl(ssp, SIFIVE_SERIAL_RXCTRL_OFFS);
665 old_v = v;
666 if ((termios->c_cflag & CREAD) == 0)
667 v &= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
668 else
669 v |= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
670 if (v != old_v)
671 __ssp_writel(v, SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
672
673 uart_port_unlock_irqrestore(&ssp->port, flags);
674}
675
676static void sifive_serial_release_port(struct uart_port *port)
677{
678}
679
680static int sifive_serial_request_port(struct uart_port *port)
681{
682 return 0;
683}
684
685static void sifive_serial_config_port(struct uart_port *port, int flags)
686{
687 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
688
689 ssp->port.type = PORT_SIFIVE_V0;
690}
691
692static int sifive_serial_verify_port(struct uart_port *port,
693 struct serial_struct *ser)
694{
695 return -EINVAL;
696}
697
698static const char *sifive_serial_type(struct uart_port *port)
699{
700 return port->type == PORT_SIFIVE_V0 ? "SiFive UART v0" : NULL;
701}
702
703#ifdef CONFIG_CONSOLE_POLL
704static int sifive_serial_poll_get_char(struct uart_port *port)
705{
706 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
707 char is_empty, ch;
708
709 ch = __ssp_receive_char(ssp, &is_empty);
710 if (is_empty)
711 return NO_POLL_CHAR;
712
713 return ch;
714}
715
716static void sifive_serial_poll_put_char(struct uart_port *port,
717 unsigned char c)
718{
719 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
720
721 __ssp_wait_for_xmitr(ssp);
722 __ssp_transmit_char(ssp, c);
723}
724#endif /* CONFIG_CONSOLE_POLL */
725
726/*
727 * Early console support
728 */
729
730#ifdef CONFIG_SERIAL_EARLYCON
731static void early_sifive_serial_putc(struct uart_port *port, unsigned char c)
732{
733 while (__ssp_early_readl(port, SIFIVE_SERIAL_TXDATA_OFFS) &
734 SIFIVE_SERIAL_TXDATA_FULL_MASK)
735 cpu_relax();
736
737 __ssp_early_writel(c, SIFIVE_SERIAL_TXDATA_OFFS, port);
738}
739
740static void early_sifive_serial_write(struct console *con, const char *s,
741 unsigned int n)
742{
743 struct earlycon_device *dev = con->data;
744 struct uart_port *port = &dev->port;
745
746 uart_console_write(port, s, n, early_sifive_serial_putc);
747}
748
749static int __init early_sifive_serial_setup(struct earlycon_device *dev,
750 const char *options)
751{
752 struct uart_port *port = &dev->port;
753
754 if (!port->membase)
755 return -ENODEV;
756
757 dev->con->write = early_sifive_serial_write;
758
759 return 0;
760}
761
762OF_EARLYCON_DECLARE(sifive, "sifive,uart0", early_sifive_serial_setup);
763OF_EARLYCON_DECLARE(sifive, "sifive,fu540-c000-uart0",
764 early_sifive_serial_setup);
765#endif /* CONFIG_SERIAL_EARLYCON */
766
767/*
768 * Linux console interface
769 */
770
771#ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
772
773static struct sifive_serial_port *sifive_serial_console_ports[SIFIVE_SERIAL_MAX_PORTS];
774
775static void sifive_serial_console_putchar(struct uart_port *port, unsigned char ch)
776{
777 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
778
779 __ssp_wait_for_xmitr(ssp);
780 __ssp_transmit_char(ssp, ch);
781}
782
783static void sifive_serial_console_write(struct console *co, const char *s,
784 unsigned int count)
785{
786 struct sifive_serial_port *ssp = sifive_serial_console_ports[co->index];
787 unsigned long flags;
788 unsigned int ier;
789 int locked = 1;
790
791 if (!ssp)
792 return;
793
794 local_irq_save(flags);
795 if (ssp->port.sysrq)
796 locked = 0;
797 else if (oops_in_progress)
798 locked = uart_port_trylock(&ssp->port);
799 else
800 uart_port_lock(&ssp->port);
801
802 ier = __ssp_readl(ssp, SIFIVE_SERIAL_IE_OFFS);
803 __ssp_writel(0, SIFIVE_SERIAL_IE_OFFS, ssp);
804
805 uart_console_write(&ssp->port, s, count, sifive_serial_console_putchar);
806
807 __ssp_writel(ier, SIFIVE_SERIAL_IE_OFFS, ssp);
808
809 if (locked)
810 uart_port_unlock(&ssp->port);
811 local_irq_restore(flags);
812}
813
814static int sifive_serial_console_setup(struct console *co, char *options)
815{
816 struct sifive_serial_port *ssp;
817 int baud = SIFIVE_DEFAULT_BAUD_RATE;
818 int bits = 8;
819 int parity = 'n';
820 int flow = 'n';
821
822 if (co->index < 0 || co->index >= SIFIVE_SERIAL_MAX_PORTS)
823 return -ENODEV;
824
825 ssp = sifive_serial_console_ports[co->index];
826 if (!ssp)
827 return -ENODEV;
828
829 if (options)
830 uart_parse_options(options, &baud, &parity, &bits, &flow);
831
832 return uart_set_options(&ssp->port, co, baud, parity, bits, flow);
833}
834
835static struct uart_driver sifive_serial_uart_driver;
836
837static struct console sifive_serial_console = {
838 .name = SIFIVE_TTY_PREFIX,
839 .write = sifive_serial_console_write,
840 .device = uart_console_device,
841 .setup = sifive_serial_console_setup,
842 .flags = CON_PRINTBUFFER,
843 .index = -1,
844 .data = &sifive_serial_uart_driver,
845};
846
847static int __init sifive_console_init(void)
848{
849 register_console(&sifive_serial_console);
850 return 0;
851}
852
853console_initcall(sifive_console_init);
854
855static void __ssp_add_console_port(struct sifive_serial_port *ssp)
856{
857 sifive_serial_console_ports[ssp->port.line] = ssp;
858}
859
860static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
861{
862 sifive_serial_console_ports[ssp->port.line] = NULL;
863}
864
865#define SIFIVE_SERIAL_CONSOLE (&sifive_serial_console)
866
867#else
868
869#define SIFIVE_SERIAL_CONSOLE NULL
870
871static void __ssp_add_console_port(struct sifive_serial_port *ssp)
872{}
873static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
874{}
875
876#endif
877
878static const struct uart_ops sifive_serial_uops = {
879 .tx_empty = sifive_serial_tx_empty,
880 .set_mctrl = sifive_serial_set_mctrl,
881 .get_mctrl = sifive_serial_get_mctrl,
882 .stop_tx = sifive_serial_stop_tx,
883 .start_tx = sifive_serial_start_tx,
884 .stop_rx = sifive_serial_stop_rx,
885 .break_ctl = sifive_serial_break_ctl,
886 .startup = sifive_serial_startup,
887 .shutdown = sifive_serial_shutdown,
888 .set_termios = sifive_serial_set_termios,
889 .type = sifive_serial_type,
890 .release_port = sifive_serial_release_port,
891 .request_port = sifive_serial_request_port,
892 .config_port = sifive_serial_config_port,
893 .verify_port = sifive_serial_verify_port,
894#ifdef CONFIG_CONSOLE_POLL
895 .poll_get_char = sifive_serial_poll_get_char,
896 .poll_put_char = sifive_serial_poll_put_char,
897#endif
898};
899
900static struct uart_driver sifive_serial_uart_driver = {
901 .owner = THIS_MODULE,
902 .driver_name = SIFIVE_SERIAL_NAME,
903 .dev_name = SIFIVE_TTY_PREFIX,
904 .nr = SIFIVE_SERIAL_MAX_PORTS,
905 .cons = SIFIVE_SERIAL_CONSOLE,
906};
907
908static int sifive_serial_probe(struct platform_device *pdev)
909{
910 struct sifive_serial_port *ssp;
911 struct resource *mem;
912 struct clk *clk;
913 void __iomem *base;
914 int irq, id, r;
915
916 irq = platform_get_irq(pdev, 0);
917 if (irq < 0)
918 return -EPROBE_DEFER;
919
920 base = devm_platform_get_and_ioremap_resource(pdev, 0, &mem);
921 if (IS_ERR(base))
922 return PTR_ERR(base);
923
924 clk = devm_clk_get_enabled(&pdev->dev, NULL);
925 if (IS_ERR(clk)) {
926 dev_err(&pdev->dev, "unable to find controller clock\n");
927 return PTR_ERR(clk);
928 }
929
930 id = of_alias_get_id(pdev->dev.of_node, "serial");
931 if (id < 0) {
932 dev_err(&pdev->dev, "missing aliases entry\n");
933 return id;
934 }
935
936#ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
937 if (id > SIFIVE_SERIAL_MAX_PORTS) {
938 dev_err(&pdev->dev, "too many UARTs (%d)\n", id);
939 return -EINVAL;
940 }
941#endif
942
943 ssp = devm_kzalloc(&pdev->dev, sizeof(*ssp), GFP_KERNEL);
944 if (!ssp)
945 return -ENOMEM;
946
947 ssp->port.dev = &pdev->dev;
948 ssp->port.type = PORT_SIFIVE_V0;
949 ssp->port.iotype = UPIO_MEM;
950 ssp->port.irq = irq;
951 ssp->port.fifosize = SIFIVE_TX_FIFO_DEPTH;
952 ssp->port.ops = &sifive_serial_uops;
953 ssp->port.line = id;
954 ssp->port.mapbase = mem->start;
955 ssp->port.membase = base;
956 ssp->dev = &pdev->dev;
957 ssp->clk = clk;
958 ssp->clk_notifier.notifier_call = sifive_serial_clk_notifier;
959
960 r = clk_notifier_register(ssp->clk, &ssp->clk_notifier);
961 if (r) {
962 dev_err(&pdev->dev, "could not register clock notifier: %d\n",
963 r);
964 goto probe_out1;
965 }
966
967 /* Set up clock divider */
968 ssp->port.uartclk = clk_get_rate(ssp->clk);
969 ssp->baud_rate = SIFIVE_DEFAULT_BAUD_RATE;
970 __ssp_update_div(ssp);
971
972 platform_set_drvdata(pdev, ssp);
973
974 /* Enable transmits and set the watermark level to 1 */
975 __ssp_writel((1 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT) |
976 SIFIVE_SERIAL_TXCTRL_TXEN_MASK,
977 SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
978
979 /* Enable receives and set the watermark level to 0 */
980 __ssp_writel((0 << SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT) |
981 SIFIVE_SERIAL_RXCTRL_RXEN_MASK,
982 SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
983
984 r = request_irq(ssp->port.irq, sifive_serial_irq, ssp->port.irqflags,
985 dev_name(&pdev->dev), ssp);
986 if (r) {
987 dev_err(&pdev->dev, "could not attach interrupt: %d\n", r);
988 goto probe_out2;
989 }
990
991 __ssp_add_console_port(ssp);
992
993 r = uart_add_one_port(&sifive_serial_uart_driver, &ssp->port);
994 if (r != 0) {
995 dev_err(&pdev->dev, "could not add uart: %d\n", r);
996 goto probe_out3;
997 }
998
999 return 0;
1000
1001probe_out3:
1002 __ssp_remove_console_port(ssp);
1003 free_irq(ssp->port.irq, ssp);
1004probe_out2:
1005 clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
1006probe_out1:
1007 return r;
1008}
1009
1010static void sifive_serial_remove(struct platform_device *dev)
1011{
1012 struct sifive_serial_port *ssp = platform_get_drvdata(dev);
1013
1014 __ssp_remove_console_port(ssp);
1015 uart_remove_one_port(&sifive_serial_uart_driver, &ssp->port);
1016 free_irq(ssp->port.irq, ssp);
1017 clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
1018}
1019
1020static int sifive_serial_suspend(struct device *dev)
1021{
1022 struct sifive_serial_port *ssp = dev_get_drvdata(dev);
1023
1024 return uart_suspend_port(&sifive_serial_uart_driver, &ssp->port);
1025}
1026
1027static int sifive_serial_resume(struct device *dev)
1028{
1029 struct sifive_serial_port *ssp = dev_get_drvdata(dev);
1030
1031 return uart_resume_port(&sifive_serial_uart_driver, &ssp->port);
1032}
1033
1034static DEFINE_SIMPLE_DEV_PM_OPS(sifive_uart_pm_ops, sifive_serial_suspend,
1035 sifive_serial_resume);
1036
1037static const struct of_device_id sifive_serial_of_match[] = {
1038 { .compatible = "sifive,fu540-c000-uart0" },
1039 { .compatible = "sifive,uart0" },
1040 {},
1041};
1042MODULE_DEVICE_TABLE(of, sifive_serial_of_match);
1043
1044static struct platform_driver sifive_serial_platform_driver = {
1045 .probe = sifive_serial_probe,
1046 .remove_new = sifive_serial_remove,
1047 .driver = {
1048 .name = SIFIVE_SERIAL_NAME,
1049 .pm = pm_sleep_ptr(&sifive_uart_pm_ops),
1050 .of_match_table = sifive_serial_of_match,
1051 },
1052};
1053
1054static int __init sifive_serial_init(void)
1055{
1056 int r;
1057
1058 r = uart_register_driver(&sifive_serial_uart_driver);
1059 if (r)
1060 goto init_out1;
1061
1062 r = platform_driver_register(&sifive_serial_platform_driver);
1063 if (r)
1064 goto init_out2;
1065
1066 return 0;
1067
1068init_out2:
1069 uart_unregister_driver(&sifive_serial_uart_driver);
1070init_out1:
1071 return r;
1072}
1073
1074static void __exit sifive_serial_exit(void)
1075{
1076 platform_driver_unregister(&sifive_serial_platform_driver);
1077 uart_unregister_driver(&sifive_serial_uart_driver);
1078}
1079
1080module_init(sifive_serial_init);
1081module_exit(sifive_serial_exit);
1082
1083MODULE_DESCRIPTION("SiFive UART serial driver");
1084MODULE_LICENSE("GPL");
1085MODULE_AUTHOR("Paul Walmsley <paul@pwsan.com>");
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * SiFive UART driver
4 * Copyright (C) 2018 Paul Walmsley <paul@pwsan.com>
5 * Copyright (C) 2018-2019 SiFive
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * Based partially on:
18 * - drivers/tty/serial/pxa.c
19 * - drivers/tty/serial/amba-pl011.c
20 * - drivers/tty/serial/uartlite.c
21 * - drivers/tty/serial/omap-serial.c
22 * - drivers/pwm/pwm-sifive.c
23 *
24 * See the following sources for further documentation:
25 * - Chapter 19 "Universal Asynchronous Receiver/Transmitter (UART)" of
26 * SiFive FE310-G000 v2p3
27 * - The tree/master/src/main/scala/devices/uart directory of
28 * https://github.com/sifive/sifive-blocks/
29 *
30 * The SiFive UART design is not 8250-compatible. The following common
31 * features are not supported:
32 * - Word lengths other than 8 bits
33 * - Break handling
34 * - Parity
35 * - Flow control
36 * - Modem signals (DSR, RI, etc.)
37 * On the other hand, the design is free from the baggage of the 8250
38 * programming model.
39 */
40
41#include <linux/clk.h>
42#include <linux/console.h>
43#include <linux/delay.h>
44#include <linux/init.h>
45#include <linux/io.h>
46#include <linux/irq.h>
47#include <linux/module.h>
48#include <linux/of.h>
49#include <linux/of_irq.h>
50#include <linux/platform_device.h>
51#include <linux/serial_core.h>
52#include <linux/serial_reg.h>
53#include <linux/slab.h>
54#include <linux/tty.h>
55#include <linux/tty_flip.h>
56
57/*
58 * Register offsets
59 */
60
61/* TXDATA */
62#define SIFIVE_SERIAL_TXDATA_OFFS 0x0
63#define SIFIVE_SERIAL_TXDATA_FULL_SHIFT 31
64#define SIFIVE_SERIAL_TXDATA_FULL_MASK (1 << SIFIVE_SERIAL_TXDATA_FULL_SHIFT)
65#define SIFIVE_SERIAL_TXDATA_DATA_SHIFT 0
66#define SIFIVE_SERIAL_TXDATA_DATA_MASK (0xff << SIFIVE_SERIAL_TXDATA_DATA_SHIFT)
67
68/* RXDATA */
69#define SIFIVE_SERIAL_RXDATA_OFFS 0x4
70#define SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT 31
71#define SIFIVE_SERIAL_RXDATA_EMPTY_MASK (1 << SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT)
72#define SIFIVE_SERIAL_RXDATA_DATA_SHIFT 0
73#define SIFIVE_SERIAL_RXDATA_DATA_MASK (0xff << SIFIVE_SERIAL_RXDATA_DATA_SHIFT)
74
75/* TXCTRL */
76#define SIFIVE_SERIAL_TXCTRL_OFFS 0x8
77#define SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT 16
78#define SIFIVE_SERIAL_TXCTRL_TXCNT_MASK (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
79#define SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT 1
80#define SIFIVE_SERIAL_TXCTRL_NSTOP_MASK (1 << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT)
81#define SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT 0
82#define SIFIVE_SERIAL_TXCTRL_TXEN_MASK (1 << SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT)
83
84/* RXCTRL */
85#define SIFIVE_SERIAL_RXCTRL_OFFS 0xC
86#define SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT 16
87#define SIFIVE_SERIAL_RXCTRL_RXCNT_MASK (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
88#define SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT 0
89#define SIFIVE_SERIAL_RXCTRL_RXEN_MASK (1 << SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT)
90
91/* IE */
92#define SIFIVE_SERIAL_IE_OFFS 0x10
93#define SIFIVE_SERIAL_IE_RXWM_SHIFT 1
94#define SIFIVE_SERIAL_IE_RXWM_MASK (1 << SIFIVE_SERIAL_IE_RXWM_SHIFT)
95#define SIFIVE_SERIAL_IE_TXWM_SHIFT 0
96#define SIFIVE_SERIAL_IE_TXWM_MASK (1 << SIFIVE_SERIAL_IE_TXWM_SHIFT)
97
98/* IP */
99#define SIFIVE_SERIAL_IP_OFFS 0x14
100#define SIFIVE_SERIAL_IP_RXWM_SHIFT 1
101#define SIFIVE_SERIAL_IP_RXWM_MASK (1 << SIFIVE_SERIAL_IP_RXWM_SHIFT)
102#define SIFIVE_SERIAL_IP_TXWM_SHIFT 0
103#define SIFIVE_SERIAL_IP_TXWM_MASK (1 << SIFIVE_SERIAL_IP_TXWM_SHIFT)
104
105/* DIV */
106#define SIFIVE_SERIAL_DIV_OFFS 0x18
107#define SIFIVE_SERIAL_DIV_DIV_SHIFT 0
108#define SIFIVE_SERIAL_DIV_DIV_MASK (0xffff << SIFIVE_SERIAL_IP_DIV_SHIFT)
109
110/*
111 * Config macros
112 */
113
114/*
115 * SIFIVE_SERIAL_MAX_PORTS: maximum number of UARTs on a device that can
116 * host a serial console
117 */
118#define SIFIVE_SERIAL_MAX_PORTS 8
119
120/*
121 * SIFIVE_DEFAULT_BAUD_RATE: default baud rate that the driver should
122 * configure itself to use
123 */
124#define SIFIVE_DEFAULT_BAUD_RATE 115200
125
126/* SIFIVE_SERIAL_NAME: our driver's name that we pass to the operating system */
127#define SIFIVE_SERIAL_NAME "sifive-serial"
128
129/* SIFIVE_TTY_PREFIX: tty name prefix for SiFive serial ports */
130#define SIFIVE_TTY_PREFIX "ttySIF"
131
132/* SIFIVE_TX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
133#define SIFIVE_TX_FIFO_DEPTH 8
134
135/* SIFIVE_RX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
136#define SIFIVE_RX_FIFO_DEPTH 8
137
138#if (SIFIVE_TX_FIFO_DEPTH != SIFIVE_RX_FIFO_DEPTH)
139#error Driver does not support configurations with different TX, RX FIFO sizes
140#endif
141
142/*
143 *
144 */
145
146/**
147 * sifive_serial_port - driver-specific data extension to struct uart_port
148 * @port: struct uart_port embedded in this struct
149 * @dev: struct device *
150 * @ier: shadowed copy of the interrupt enable register
151 * @clkin_rate: input clock to the UART IP block.
152 * @baud_rate: UART serial line rate (e.g., 115200 baud)
153 * @clk_notifier: clock rate change notifier for upstream clock changes
154 *
155 * Configuration data specific to this SiFive UART.
156 */
157struct sifive_serial_port {
158 struct uart_port port;
159 struct device *dev;
160 unsigned char ier;
161 unsigned long clkin_rate;
162 unsigned long baud_rate;
163 struct clk *clk;
164 struct notifier_block clk_notifier;
165};
166
167/*
168 * Structure container-of macros
169 */
170
171#define port_to_sifive_serial_port(p) (container_of((p), \
172 struct sifive_serial_port, \
173 port))
174
175#define notifier_to_sifive_serial_port(nb) (container_of((nb), \
176 struct sifive_serial_port, \
177 clk_notifier))
178
179/*
180 * Forward declarations
181 */
182static void sifive_serial_stop_tx(struct uart_port *port);
183
184/*
185 * Internal functions
186 */
187
188/**
189 * __ssp_early_writel() - write to a SiFive serial port register (early)
190 * @port: pointer to a struct uart_port record
191 * @offs: register address offset from the IP block base address
192 * @v: value to write to the register
193 *
194 * Given a pointer @port to a struct uart_port record, write the value
195 * @v to the IP block register address offset @offs. This function is
196 * intended for early console use.
197 *
198 * Context: Intended to be used only by the earlyconsole code.
199 */
200static void __ssp_early_writel(u32 v, u16 offs, struct uart_port *port)
201{
202 writel_relaxed(v, port->membase + offs);
203}
204
205/**
206 * __ssp_early_readl() - read from a SiFive serial port register (early)
207 * @port: pointer to a struct uart_port record
208 * @offs: register address offset from the IP block base address
209 *
210 * Given a pointer @port to a struct uart_port record, read the
211 * contents of the IP block register located at offset @offs from the
212 * IP block base and return it. This function is intended for early
213 * console use.
214 *
215 * Context: Intended to be called only by the earlyconsole code or by
216 * __ssp_readl() or __ssp_writel() (in this driver)
217 *
218 * Returns: the register value read from the UART.
219 */
220static u32 __ssp_early_readl(struct uart_port *port, u16 offs)
221{
222 return readl_relaxed(port->membase + offs);
223}
224
225/**
226 * __ssp_writel() - write to a SiFive serial port register
227 * @v: value to write to the register
228 * @offs: register address offset from the IP block base address
229 * @ssp: pointer to a struct sifive_serial_port record
230 *
231 * Write the value @v to the IP block register located at offset @offs from the
232 * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
233 *
234 * Context: Any context.
235 */
236static void __ssp_writel(u32 v, u16 offs, struct sifive_serial_port *ssp)
237{
238 __ssp_early_writel(v, offs, &ssp->port);
239}
240
241/**
242 * __ssp_readl() - read from a SiFive serial port register
243 * @ssp: pointer to a struct sifive_serial_port record
244 * @offs: register address offset from the IP block base address
245 *
246 * Read the contents of the IP block register located at offset @offs from the
247 * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
248 *
249 * Context: Any context.
250 *
251 * Returns: the value of the UART register
252 */
253static u32 __ssp_readl(struct sifive_serial_port *ssp, u16 offs)
254{
255 return __ssp_early_readl(&ssp->port, offs);
256}
257
258/**
259 * sifive_serial_is_txfifo_full() - is the TXFIFO full?
260 * @ssp: pointer to a struct sifive_serial_port
261 *
262 * Read the transmit FIFO "full" bit, returning a non-zero value if the
263 * TX FIFO is full, or zero if space remains. Intended to be used to prevent
264 * writes to the TX FIFO when it's full.
265 *
266 * Returns: SIFIVE_SERIAL_TXDATA_FULL_MASK (non-zero) if the transmit FIFO
267 * is full, or 0 if space remains.
268 */
269static int sifive_serial_is_txfifo_full(struct sifive_serial_port *ssp)
270{
271 return __ssp_readl(ssp, SIFIVE_SERIAL_TXDATA_OFFS) &
272 SIFIVE_SERIAL_TXDATA_FULL_MASK;
273}
274
275/**
276 * __ssp_transmit_char() - enqueue a byte to transmit onto the TX FIFO
277 * @ssp: pointer to a struct sifive_serial_port
278 * @ch: character to transmit
279 *
280 * Enqueue a byte @ch onto the transmit FIFO, given a pointer @ssp to the
281 * struct sifive_serial_port * to transmit on. Caller should first check to
282 * ensure that the TXFIFO has space; see sifive_serial_is_txfifo_full().
283 *
284 * Context: Any context.
285 */
286static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch)
287{
288 __ssp_writel(ch, SIFIVE_SERIAL_TXDATA_OFFS, ssp);
289}
290
291/**
292 * __ssp_transmit_chars() - enqueue multiple bytes onto the TX FIFO
293 * @ssp: pointer to a struct sifive_serial_port
294 *
295 * Transfer up to a TX FIFO size's worth of characters from the Linux serial
296 * transmit buffer to the SiFive UART TX FIFO.
297 *
298 * Context: Any context. Expects @ssp->port.lock to be held by caller.
299 */
300static void __ssp_transmit_chars(struct sifive_serial_port *ssp)
301{
302 struct circ_buf *xmit = &ssp->port.state->xmit;
303 int count;
304
305 if (ssp->port.x_char) {
306 __ssp_transmit_char(ssp, ssp->port.x_char);
307 ssp->port.icount.tx++;
308 ssp->port.x_char = 0;
309 return;
310 }
311 if (uart_circ_empty(xmit) || uart_tx_stopped(&ssp->port)) {
312 sifive_serial_stop_tx(&ssp->port);
313 return;
314 }
315 count = SIFIVE_TX_FIFO_DEPTH;
316 do {
317 __ssp_transmit_char(ssp, xmit->buf[xmit->tail]);
318 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
319 ssp->port.icount.tx++;
320 if (uart_circ_empty(xmit))
321 break;
322 } while (--count > 0);
323
324 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
325 uart_write_wakeup(&ssp->port);
326
327 if (uart_circ_empty(xmit))
328 sifive_serial_stop_tx(&ssp->port);
329}
330
331/**
332 * __ssp_enable_txwm() - enable transmit watermark interrupts
333 * @ssp: pointer to a struct sifive_serial_port
334 *
335 * Enable interrupt generation when the transmit FIFO watermark is reached
336 * on the SiFive UART referred to by @ssp.
337 */
338static void __ssp_enable_txwm(struct sifive_serial_port *ssp)
339{
340 if (ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK)
341 return;
342
343 ssp->ier |= SIFIVE_SERIAL_IE_TXWM_MASK;
344 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
345}
346
347/**
348 * __ssp_enable_rxwm() - enable receive watermark interrupts
349 * @ssp: pointer to a struct sifive_serial_port
350 *
351 * Enable interrupt generation when the receive FIFO watermark is reached
352 * on the SiFive UART referred to by @ssp.
353 */
354static void __ssp_enable_rxwm(struct sifive_serial_port *ssp)
355{
356 if (ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK)
357 return;
358
359 ssp->ier |= SIFIVE_SERIAL_IE_RXWM_MASK;
360 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
361}
362
363/**
364 * __ssp_disable_txwm() - disable transmit watermark interrupts
365 * @ssp: pointer to a struct sifive_serial_port
366 *
367 * Disable interrupt generation when the transmit FIFO watermark is reached
368 * on the UART referred to by @ssp.
369 */
370static void __ssp_disable_txwm(struct sifive_serial_port *ssp)
371{
372 if (!(ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK))
373 return;
374
375 ssp->ier &= ~SIFIVE_SERIAL_IE_TXWM_MASK;
376 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
377}
378
379/**
380 * __ssp_disable_rxwm() - disable receive watermark interrupts
381 * @ssp: pointer to a struct sifive_serial_port
382 *
383 * Disable interrupt generation when the receive FIFO watermark is reached
384 * on the UART referred to by @ssp.
385 */
386static void __ssp_disable_rxwm(struct sifive_serial_port *ssp)
387{
388 if (!(ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK))
389 return;
390
391 ssp->ier &= ~SIFIVE_SERIAL_IE_RXWM_MASK;
392 __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
393}
394
395/**
396 * __ssp_receive_char() - receive a byte from the UART
397 * @ssp: pointer to a struct sifive_serial_port
398 * @is_empty: char pointer to return whether the RX FIFO is empty
399 *
400 * Try to read a byte from the SiFive UART RX FIFO, referenced by
401 * @ssp, and to return it. Also returns the RX FIFO empty bit in
402 * the char pointed to by @ch. The caller must pass the byte back to the
403 * Linux serial layer if needed.
404 *
405 * Returns: the byte read from the UART RX FIFO.
406 */
407static char __ssp_receive_char(struct sifive_serial_port *ssp, char *is_empty)
408{
409 u32 v;
410 u8 ch;
411
412 v = __ssp_readl(ssp, SIFIVE_SERIAL_RXDATA_OFFS);
413
414 if (!is_empty)
415 WARN_ON(1);
416 else
417 *is_empty = (v & SIFIVE_SERIAL_RXDATA_EMPTY_MASK) >>
418 SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT;
419
420 ch = (v & SIFIVE_SERIAL_RXDATA_DATA_MASK) >>
421 SIFIVE_SERIAL_RXDATA_DATA_SHIFT;
422
423 return ch;
424}
425
426/**
427 * __ssp_receive_chars() - receive multiple bytes from the UART
428 * @ssp: pointer to a struct sifive_serial_port
429 *
430 * Receive up to an RX FIFO's worth of bytes from the SiFive UART referred
431 * to by @ssp and pass them up to the Linux serial layer.
432 *
433 * Context: Expects ssp->port.lock to be held by caller.
434 */
435static void __ssp_receive_chars(struct sifive_serial_port *ssp)
436{
437 unsigned char ch;
438 char is_empty;
439 int c;
440
441 for (c = SIFIVE_RX_FIFO_DEPTH; c > 0; --c) {
442 ch = __ssp_receive_char(ssp, &is_empty);
443 if (is_empty)
444 break;
445
446 ssp->port.icount.rx++;
447 uart_insert_char(&ssp->port, 0, 0, ch, TTY_NORMAL);
448 }
449
450 spin_unlock(&ssp->port.lock);
451 tty_flip_buffer_push(&ssp->port.state->port);
452 spin_lock(&ssp->port.lock);
453}
454
455/**
456 * __ssp_update_div() - calculate the divisor setting by the line rate
457 * @ssp: pointer to a struct sifive_serial_port
458 *
459 * Calculate the appropriate value of the clock divisor for the UART
460 * and target line rate referred to by @ssp and write it into the
461 * hardware.
462 */
463static void __ssp_update_div(struct sifive_serial_port *ssp)
464{
465 u16 div;
466
467 div = DIV_ROUND_UP(ssp->clkin_rate, ssp->baud_rate) - 1;
468
469 __ssp_writel(div, SIFIVE_SERIAL_DIV_OFFS, ssp);
470}
471
472/**
473 * __ssp_update_baud_rate() - set the UART "baud rate"
474 * @ssp: pointer to a struct sifive_serial_port
475 * @rate: new target bit rate
476 *
477 * Calculate the UART divisor value for the target bit rate @rate for the
478 * SiFive UART described by @ssp and program it into the UART. There may
479 * be some error between the target bit rate and the actual bit rate implemented
480 * by the UART due to clock ratio granularity.
481 */
482static void __ssp_update_baud_rate(struct sifive_serial_port *ssp,
483 unsigned int rate)
484{
485 if (ssp->baud_rate == rate)
486 return;
487
488 ssp->baud_rate = rate;
489 __ssp_update_div(ssp);
490}
491
492/**
493 * __ssp_set_stop_bits() - set the number of stop bits
494 * @ssp: pointer to a struct sifive_serial_port
495 * @nstop: 1 or 2 (stop bits)
496 *
497 * Program the SiFive UART referred to by @ssp to use @nstop stop bits.
498 */
499static void __ssp_set_stop_bits(struct sifive_serial_port *ssp, char nstop)
500{
501 u32 v;
502
503 if (nstop < 1 || nstop > 2) {
504 WARN_ON(1);
505 return;
506 }
507
508 v = __ssp_readl(ssp, SIFIVE_SERIAL_TXCTRL_OFFS);
509 v &= ~SIFIVE_SERIAL_TXCTRL_NSTOP_MASK;
510 v |= (nstop - 1) << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT;
511 __ssp_writel(v, SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
512}
513
514/**
515 * __ssp_wait_for_xmitr() - wait for an empty slot on the TX FIFO
516 * @ssp: pointer to a struct sifive_serial_port
517 *
518 * Delay while the UART TX FIFO referred to by @ssp is marked as full.
519 *
520 * Context: Any context.
521 */
522static void __maybe_unused __ssp_wait_for_xmitr(struct sifive_serial_port *ssp)
523{
524 while (sifive_serial_is_txfifo_full(ssp))
525 udelay(1); /* XXX Could probably be more intelligent here */
526}
527
528/*
529 * Linux serial API functions
530 */
531
532static void sifive_serial_stop_tx(struct uart_port *port)
533{
534 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
535
536 __ssp_disable_txwm(ssp);
537}
538
539static void sifive_serial_stop_rx(struct uart_port *port)
540{
541 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
542
543 __ssp_disable_rxwm(ssp);
544}
545
546static void sifive_serial_start_tx(struct uart_port *port)
547{
548 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
549
550 __ssp_enable_txwm(ssp);
551}
552
553static irqreturn_t sifive_serial_irq(int irq, void *dev_id)
554{
555 struct sifive_serial_port *ssp = dev_id;
556 u32 ip;
557
558 spin_lock(&ssp->port.lock);
559
560 ip = __ssp_readl(ssp, SIFIVE_SERIAL_IP_OFFS);
561 if (!ip) {
562 spin_unlock(&ssp->port.lock);
563 return IRQ_NONE;
564 }
565
566 if (ip & SIFIVE_SERIAL_IP_RXWM_MASK)
567 __ssp_receive_chars(ssp);
568 if (ip & SIFIVE_SERIAL_IP_TXWM_MASK)
569 __ssp_transmit_chars(ssp);
570
571 spin_unlock(&ssp->port.lock);
572
573 return IRQ_HANDLED;
574}
575
576static unsigned int sifive_serial_tx_empty(struct uart_port *port)
577{
578 return TIOCSER_TEMT;
579}
580
581static unsigned int sifive_serial_get_mctrl(struct uart_port *port)
582{
583 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
584}
585
586static void sifive_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
587{
588 /* IP block does not support these signals */
589}
590
591static void sifive_serial_break_ctl(struct uart_port *port, int break_state)
592{
593 /* IP block does not support sending a break */
594}
595
596static int sifive_serial_startup(struct uart_port *port)
597{
598 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
599
600 __ssp_enable_rxwm(ssp);
601
602 return 0;
603}
604
605static void sifive_serial_shutdown(struct uart_port *port)
606{
607 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
608
609 __ssp_disable_rxwm(ssp);
610 __ssp_disable_txwm(ssp);
611}
612
613/**
614 * sifive_serial_clk_notifier() - clock post-rate-change notifier
615 * @nb: pointer to the struct notifier_block, from the notifier code
616 * @event: event mask from the notifier code
617 * @data: pointer to the struct clk_notifier_data from the notifier code
618 *
619 * On the V0 SoC, the UART IP block is derived from the CPU clock source
620 * after a synchronous divide-by-two divider, so any CPU clock rate change
621 * requires the UART baud rate to be updated. This presumably could corrupt any
622 * serial word currently being transmitted or received. It would probably
623 * be better to stop receives and transmits, then complete the baud rate
624 * change, then re-enable them.
625 */
626static int sifive_serial_clk_notifier(struct notifier_block *nb,
627 unsigned long event, void *data)
628{
629 struct clk_notifier_data *cnd = data;
630 struct sifive_serial_port *ssp = notifier_to_sifive_serial_port(nb);
631
632 if (event == POST_RATE_CHANGE && ssp->clkin_rate != cnd->new_rate) {
633 ssp->clkin_rate = cnd->new_rate;
634 __ssp_update_div(ssp);
635 }
636
637 return NOTIFY_OK;
638}
639
640static void sifive_serial_set_termios(struct uart_port *port,
641 struct ktermios *termios,
642 struct ktermios *old)
643{
644 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
645 unsigned long flags;
646 u32 v, old_v;
647 int rate;
648 char nstop;
649
650 if ((termios->c_cflag & CSIZE) != CS8)
651 dev_err_once(ssp->port.dev, "only 8-bit words supported\n");
652 if (termios->c_iflag & (INPCK | PARMRK))
653 dev_err_once(ssp->port.dev, "parity checking not supported\n");
654 if (termios->c_iflag & BRKINT)
655 dev_err_once(ssp->port.dev, "BREAK detection not supported\n");
656
657 /* Set number of stop bits */
658 nstop = (termios->c_cflag & CSTOPB) ? 2 : 1;
659 __ssp_set_stop_bits(ssp, nstop);
660
661 /* Set line rate */
662 rate = uart_get_baud_rate(port, termios, old, 0, ssp->clkin_rate / 16);
663 __ssp_update_baud_rate(ssp, rate);
664
665 spin_lock_irqsave(&ssp->port.lock, flags);
666
667 /* Update the per-port timeout */
668 uart_update_timeout(port, termios->c_cflag, rate);
669
670 ssp->port.read_status_mask = 0;
671
672 /* Ignore all characters if CREAD is not set */
673 v = __ssp_readl(ssp, SIFIVE_SERIAL_RXCTRL_OFFS);
674 old_v = v;
675 if ((termios->c_cflag & CREAD) == 0)
676 v &= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
677 else
678 v |= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
679 if (v != old_v)
680 __ssp_writel(v, SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
681
682 spin_unlock_irqrestore(&ssp->port.lock, flags);
683}
684
685static void sifive_serial_release_port(struct uart_port *port)
686{
687}
688
689static int sifive_serial_request_port(struct uart_port *port)
690{
691 return 0;
692}
693
694static void sifive_serial_config_port(struct uart_port *port, int flags)
695{
696 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
697
698 ssp->port.type = PORT_SIFIVE_V0;
699}
700
701static int sifive_serial_verify_port(struct uart_port *port,
702 struct serial_struct *ser)
703{
704 return -EINVAL;
705}
706
707static const char *sifive_serial_type(struct uart_port *port)
708{
709 return port->type == PORT_SIFIVE_V0 ? "SiFive UART v0" : NULL;
710}
711
712/*
713 * Early console support
714 */
715
716#ifdef CONFIG_SERIAL_EARLYCON
717static void early_sifive_serial_putc(struct uart_port *port, int c)
718{
719 while (__ssp_early_readl(port, SIFIVE_SERIAL_TXDATA_OFFS) &
720 SIFIVE_SERIAL_TXDATA_FULL_MASK)
721 cpu_relax();
722
723 __ssp_early_writel(c, SIFIVE_SERIAL_TXDATA_OFFS, port);
724}
725
726static void early_sifive_serial_write(struct console *con, const char *s,
727 unsigned int n)
728{
729 struct earlycon_device *dev = con->data;
730 struct uart_port *port = &dev->port;
731
732 uart_console_write(port, s, n, early_sifive_serial_putc);
733}
734
735static int __init early_sifive_serial_setup(struct earlycon_device *dev,
736 const char *options)
737{
738 struct uart_port *port = &dev->port;
739
740 if (!port->membase)
741 return -ENODEV;
742
743 dev->con->write = early_sifive_serial_write;
744
745 return 0;
746}
747
748OF_EARLYCON_DECLARE(sifive, "sifive,uart0", early_sifive_serial_setup);
749OF_EARLYCON_DECLARE(sifive, "sifive,fu540-c000-uart0",
750 early_sifive_serial_setup);
751#endif /* CONFIG_SERIAL_EARLYCON */
752
753/*
754 * Linux console interface
755 */
756
757#ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
758
759static struct sifive_serial_port *sifive_serial_console_ports[SIFIVE_SERIAL_MAX_PORTS];
760
761static void sifive_serial_console_putchar(struct uart_port *port, int ch)
762{
763 struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
764
765 __ssp_wait_for_xmitr(ssp);
766 __ssp_transmit_char(ssp, ch);
767}
768
769static void sifive_serial_console_write(struct console *co, const char *s,
770 unsigned int count)
771{
772 struct sifive_serial_port *ssp = sifive_serial_console_ports[co->index];
773 unsigned long flags;
774 unsigned int ier;
775 int locked = 1;
776
777 if (!ssp)
778 return;
779
780 local_irq_save(flags);
781 if (ssp->port.sysrq)
782 locked = 0;
783 else if (oops_in_progress)
784 locked = spin_trylock(&ssp->port.lock);
785 else
786 spin_lock(&ssp->port.lock);
787
788 ier = __ssp_readl(ssp, SIFIVE_SERIAL_IE_OFFS);
789 __ssp_writel(0, SIFIVE_SERIAL_IE_OFFS, ssp);
790
791 uart_console_write(&ssp->port, s, count, sifive_serial_console_putchar);
792
793 __ssp_writel(ier, SIFIVE_SERIAL_IE_OFFS, ssp);
794
795 if (locked)
796 spin_unlock(&ssp->port.lock);
797 local_irq_restore(flags);
798}
799
800static int __init sifive_serial_console_setup(struct console *co, char *options)
801{
802 struct sifive_serial_port *ssp;
803 int baud = SIFIVE_DEFAULT_BAUD_RATE;
804 int bits = 8;
805 int parity = 'n';
806 int flow = 'n';
807
808 if (co->index < 0 || co->index >= SIFIVE_SERIAL_MAX_PORTS)
809 return -ENODEV;
810
811 ssp = sifive_serial_console_ports[co->index];
812 if (!ssp)
813 return -ENODEV;
814
815 if (options)
816 uart_parse_options(options, &baud, &parity, &bits, &flow);
817
818 return uart_set_options(&ssp->port, co, baud, parity, bits, flow);
819}
820
821static struct uart_driver sifive_serial_uart_driver;
822
823static struct console sifive_serial_console = {
824 .name = SIFIVE_TTY_PREFIX,
825 .write = sifive_serial_console_write,
826 .device = uart_console_device,
827 .setup = sifive_serial_console_setup,
828 .flags = CON_PRINTBUFFER,
829 .index = -1,
830 .data = &sifive_serial_uart_driver,
831};
832
833static int __init sifive_console_init(void)
834{
835 register_console(&sifive_serial_console);
836 return 0;
837}
838
839console_initcall(sifive_console_init);
840
841static void __ssp_add_console_port(struct sifive_serial_port *ssp)
842{
843 sifive_serial_console_ports[ssp->port.line] = ssp;
844}
845
846static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
847{
848 sifive_serial_console_ports[ssp->port.line] = 0;
849}
850
851#define SIFIVE_SERIAL_CONSOLE (&sifive_serial_console)
852
853#else
854
855#define SIFIVE_SERIAL_CONSOLE NULL
856
857static void __ssp_add_console_port(struct sifive_serial_port *ssp)
858{}
859static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
860{}
861
862#endif
863
864static const struct uart_ops sifive_serial_uops = {
865 .tx_empty = sifive_serial_tx_empty,
866 .set_mctrl = sifive_serial_set_mctrl,
867 .get_mctrl = sifive_serial_get_mctrl,
868 .stop_tx = sifive_serial_stop_tx,
869 .start_tx = sifive_serial_start_tx,
870 .stop_rx = sifive_serial_stop_rx,
871 .break_ctl = sifive_serial_break_ctl,
872 .startup = sifive_serial_startup,
873 .shutdown = sifive_serial_shutdown,
874 .set_termios = sifive_serial_set_termios,
875 .type = sifive_serial_type,
876 .release_port = sifive_serial_release_port,
877 .request_port = sifive_serial_request_port,
878 .config_port = sifive_serial_config_port,
879 .verify_port = sifive_serial_verify_port,
880};
881
882static struct uart_driver sifive_serial_uart_driver = {
883 .owner = THIS_MODULE,
884 .driver_name = SIFIVE_SERIAL_NAME,
885 .dev_name = SIFIVE_TTY_PREFIX,
886 .nr = SIFIVE_SERIAL_MAX_PORTS,
887 .cons = SIFIVE_SERIAL_CONSOLE,
888};
889
890static int sifive_serial_probe(struct platform_device *pdev)
891{
892 struct sifive_serial_port *ssp;
893 struct resource *mem;
894 struct clk *clk;
895 void __iomem *base;
896 int irq, id, r;
897
898 irq = platform_get_irq(pdev, 0);
899 if (irq < 0)
900 return -EPROBE_DEFER;
901
902 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
903 base = devm_ioremap_resource(&pdev->dev, mem);
904 if (IS_ERR(base)) {
905 dev_err(&pdev->dev, "could not acquire device memory\n");
906 return PTR_ERR(base);
907 }
908
909 clk = devm_clk_get(&pdev->dev, NULL);
910 if (IS_ERR(clk)) {
911 dev_err(&pdev->dev, "unable to find controller clock\n");
912 return PTR_ERR(clk);
913 }
914
915 id = of_alias_get_id(pdev->dev.of_node, "serial");
916 if (id < 0) {
917 dev_err(&pdev->dev, "missing aliases entry\n");
918 return id;
919 }
920
921#ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
922 if (id > SIFIVE_SERIAL_MAX_PORTS) {
923 dev_err(&pdev->dev, "too many UARTs (%d)\n", id);
924 return -EINVAL;
925 }
926#endif
927
928 ssp = devm_kzalloc(&pdev->dev, sizeof(*ssp), GFP_KERNEL);
929 if (!ssp)
930 return -ENOMEM;
931
932 ssp->port.dev = &pdev->dev;
933 ssp->port.type = PORT_SIFIVE_V0;
934 ssp->port.iotype = UPIO_MEM;
935 ssp->port.irq = irq;
936 ssp->port.fifosize = SIFIVE_TX_FIFO_DEPTH;
937 ssp->port.ops = &sifive_serial_uops;
938 ssp->port.line = id;
939 ssp->port.mapbase = mem->start;
940 ssp->port.membase = base;
941 ssp->dev = &pdev->dev;
942 ssp->clk = clk;
943 ssp->clk_notifier.notifier_call = sifive_serial_clk_notifier;
944
945 r = clk_notifier_register(ssp->clk, &ssp->clk_notifier);
946 if (r) {
947 dev_err(&pdev->dev, "could not register clock notifier: %d\n",
948 r);
949 goto probe_out1;
950 }
951
952 /* Set up clock divider */
953 ssp->clkin_rate = clk_get_rate(ssp->clk);
954 ssp->baud_rate = SIFIVE_DEFAULT_BAUD_RATE;
955 __ssp_update_div(ssp);
956
957 platform_set_drvdata(pdev, ssp);
958
959 /* Enable transmits and set the watermark level to 1 */
960 __ssp_writel((1 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT) |
961 SIFIVE_SERIAL_TXCTRL_TXEN_MASK,
962 SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
963
964 /* Enable receives and set the watermark level to 0 */
965 __ssp_writel((0 << SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT) |
966 SIFIVE_SERIAL_RXCTRL_RXEN_MASK,
967 SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
968
969 r = request_irq(ssp->port.irq, sifive_serial_irq, ssp->port.irqflags,
970 dev_name(&pdev->dev), ssp);
971 if (r) {
972 dev_err(&pdev->dev, "could not attach interrupt: %d\n", r);
973 goto probe_out2;
974 }
975
976 __ssp_add_console_port(ssp);
977
978 r = uart_add_one_port(&sifive_serial_uart_driver, &ssp->port);
979 if (r != 0) {
980 dev_err(&pdev->dev, "could not add uart: %d\n", r);
981 goto probe_out3;
982 }
983
984 return 0;
985
986probe_out3:
987 __ssp_remove_console_port(ssp);
988 free_irq(ssp->port.irq, ssp);
989probe_out2:
990 clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
991probe_out1:
992 return r;
993}
994
995static int sifive_serial_remove(struct platform_device *dev)
996{
997 struct sifive_serial_port *ssp = platform_get_drvdata(dev);
998
999 __ssp_remove_console_port(ssp);
1000 uart_remove_one_port(&sifive_serial_uart_driver, &ssp->port);
1001 free_irq(ssp->port.irq, ssp);
1002 clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
1003
1004 return 0;
1005}
1006
1007static const struct of_device_id sifive_serial_of_match[] = {
1008 { .compatible = "sifive,fu540-c000-uart0" },
1009 { .compatible = "sifive,uart0" },
1010 {},
1011};
1012MODULE_DEVICE_TABLE(of, sifive_serial_of_match);
1013
1014static struct platform_driver sifive_serial_platform_driver = {
1015 .probe = sifive_serial_probe,
1016 .remove = sifive_serial_remove,
1017 .driver = {
1018 .name = SIFIVE_SERIAL_NAME,
1019 .of_match_table = of_match_ptr(sifive_serial_of_match),
1020 },
1021};
1022
1023static int __init sifive_serial_init(void)
1024{
1025 int r;
1026
1027 r = uart_register_driver(&sifive_serial_uart_driver);
1028 if (r)
1029 goto init_out1;
1030
1031 r = platform_driver_register(&sifive_serial_platform_driver);
1032 if (r)
1033 goto init_out2;
1034
1035 return 0;
1036
1037init_out2:
1038 uart_unregister_driver(&sifive_serial_uart_driver);
1039init_out1:
1040 return r;
1041}
1042
1043static void __exit sifive_serial_exit(void)
1044{
1045 platform_driver_unregister(&sifive_serial_platform_driver);
1046 uart_unregister_driver(&sifive_serial_uart_driver);
1047}
1048
1049module_init(sifive_serial_init);
1050module_exit(sifive_serial_exit);
1051
1052MODULE_DESCRIPTION("SiFive UART serial driver");
1053MODULE_LICENSE("GPL");
1054MODULE_AUTHOR("Paul Walmsley <paul@pwsan.com>");