blob: c671d674bce4d29f8a2a436faffcc76129255f97 [file] [log] [blame]
Greg Kroah-Hartmane3b3d0f2017-11-06 18:11:51 +01001// SPDX-License-Identifier: GPL-2.0
David S. Miller02fd4732006-02-11 02:25:21 -08002/* sunhv.c: Serial driver for SUN4V hypervisor console.
3 *
David S. Millerc7754d42007-05-15 17:03:54 -07004 * Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net)
David S. Miller02fd4732006-02-11 02:25:21 -08005 */
6
David S. Miller02fd4732006-02-11 02:25:21 -08007#include <linux/kernel.h>
8#include <linux/errno.h>
9#include <linux/tty.h>
10#include <linux/tty_flip.h>
11#include <linux/major.h>
12#include <linux/circ_buf.h>
13#include <linux/serial.h>
14#include <linux/sysrq.h>
15#include <linux/console.h>
16#include <linux/spinlock.h>
17#include <linux/slab.h>
18#include <linux/delay.h>
19#include <linux/init.h>
Rob Herring29e5c442023-07-24 14:54:38 -060020#include <linux/of.h>
21#include <linux/platform_device.h>
David S. Miller02fd4732006-02-11 02:25:21 -080022
23#include <asm/hypervisor.h>
24#include <asm/spitfire.h>
David S. Millerf4266ab2006-02-13 20:43:02 -080025#include <asm/irq.h>
David Howellsd550bbd2012-03-28 18:30:03 +010026#include <asm/setup.h>
David S. Miller02fd4732006-02-11 02:25:21 -080027
David S. Miller02fd4732006-02-11 02:25:21 -080028#include <linux/serial_core.h>
Paul Gortmaker68163832012-02-09 18:48:19 -050029#include <linux/sunserialcore.h>
David S. Miller02fd4732006-02-11 02:25:21 -080030
31#define CON_BREAK ((long)-1)
32#define CON_HUP ((long)-2)
33
David S. Miller02fd4732006-02-11 02:25:21 -080034#define IGNORE_BREAK 0x1
35#define IGNORE_ALL 0x2
36
David S. Millerc7754d42007-05-15 17:03:54 -070037static char *con_write_page;
38static char *con_read_page;
39
David S. Miller02fd4732006-02-11 02:25:21 -080040static int hung_up = 0;
41
David S. Millerc7754d42007-05-15 17:03:54 -070042static void transmit_chars_putchar(struct uart_port *port, struct circ_buf *xmit)
David S. Miller02fd4732006-02-11 02:25:21 -080043{
David S. Millerc7754d42007-05-15 17:03:54 -070044 while (!uart_circ_empty(xmit)) {
45 long status = sun4v_con_putchar(xmit->buf[xmit->tail]);
46
47 if (status != HV_EOK)
48 break;
49
Ilpo Järvinenc5fd4b72022-10-19 12:11:42 +030050 uart_xmit_advance(port, 1);
David S. Millerc7754d42007-05-15 17:03:54 -070051 }
52}
53
54static void transmit_chars_write(struct uart_port *port, struct circ_buf *xmit)
55{
56 while (!uart_circ_empty(xmit)) {
57 unsigned long ra = __pa(xmit->buf + xmit->tail);
58 unsigned long len, status, sent;
59
60 len = CIRC_CNT_TO_END(xmit->head, xmit->tail,
61 UART_XMIT_SIZE);
62 status = sun4v_con_write(ra, len, &sent);
63 if (status != HV_EOK)
64 break;
Ilpo Järvinenc5fd4b72022-10-19 12:11:42 +030065 uart_xmit_advance(port, sent);
David S. Millerc7754d42007-05-15 17:03:54 -070066 }
67}
68
Jiri Slaby05c7cd32013-01-03 15:53:04 +010069static int receive_chars_getchar(struct uart_port *port)
David S. Millerc7754d42007-05-15 17:03:54 -070070{
David S. Miller02fd4732006-02-11 02:25:21 -080071 int saw_console_brk = 0;
72 int limit = 10000;
73
David S. Miller02fd4732006-02-11 02:25:21 -080074 while (limit-- > 0) {
75 long status;
David S. Millerc7754d42007-05-15 17:03:54 -070076 long c = sun4v_con_getchar(&status);
David S. Miller02fd4732006-02-11 02:25:21 -080077
78 if (status == HV_EWOULDBLOCK)
79 break;
80
81 if (c == CON_BREAK) {
David S. Miller135066a2006-02-16 00:42:21 -080082 if (uart_handle_break(port))
83 continue;
David S. Miller02fd4732006-02-11 02:25:21 -080084 saw_console_brk = 1;
85 c = 0;
86 }
87
88 if (c == CON_HUP) {
89 hung_up = 1;
Ilpo Järvinen0388a152023-01-17 11:03:54 +020090 uart_handle_dcd_change(port, false);
David S. Miller02fd4732006-02-11 02:25:21 -080091 } else if (hung_up) {
92 hung_up = 0;
Ilpo Järvinen0388a152023-01-17 11:03:54 +020093 uart_handle_dcd_change(port, true);
David S. Miller02fd4732006-02-11 02:25:21 -080094 }
95
Jiri Slaby92a19f92013-01-03 15:53:03 +010096 if (port->state == NULL) {
David Howells7d12e782006-10-05 14:55:46 +010097 uart_handle_sysrq_char(port, c);
David S. Miller02fd4732006-02-11 02:25:21 -080098 continue;
99 }
100
David S. Miller02fd4732006-02-11 02:25:21 -0800101 port->icount.rx++;
David S. Miller02fd4732006-02-11 02:25:21 -0800102
David Howells7d12e782006-10-05 14:55:46 +0100103 if (uart_handle_sysrq_char(port, c))
David S. Miller02fd4732006-02-11 02:25:21 -0800104 continue;
105
Jiri Slaby92a19f92013-01-03 15:53:03 +0100106 tty_insert_flip_char(&port->state->port, c, TTY_NORMAL);
David S. Miller02fd4732006-02-11 02:25:21 -0800107 }
108
David S. Millerc7754d42007-05-15 17:03:54 -0700109 return saw_console_brk;
110}
111
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100112static int receive_chars_read(struct uart_port *port)
David S. Millerc7754d42007-05-15 17:03:54 -0700113{
Vijay Kumar7db60d02017-02-01 11:34:39 -0800114 static int saw_console_brk;
David S. Millerc7754d42007-05-15 17:03:54 -0700115 int limit = 10000;
116
117 while (limit-- > 0) {
118 unsigned long ra = __pa(con_read_page);
119 unsigned long bytes_read, i;
120 long stat = sun4v_con_read(ra, PAGE_SIZE, &bytes_read);
121
122 if (stat != HV_EOK) {
123 bytes_read = 0;
124
125 if (stat == CON_BREAK) {
Vijay Kumar7db60d02017-02-01 11:34:39 -0800126 if (saw_console_brk)
127 sun_do_break();
128
David S. Millerc7754d42007-05-15 17:03:54 -0700129 if (uart_handle_break(port))
130 continue;
131 saw_console_brk = 1;
132 *con_read_page = 0;
133 bytes_read = 1;
134 } else if (stat == CON_HUP) {
135 hung_up = 1;
Ilpo Järvinen0388a152023-01-17 11:03:54 +0200136 uart_handle_dcd_change(port, false);
David S. Millerc7754d42007-05-15 17:03:54 -0700137 continue;
138 } else {
139 /* HV_EWOULDBLOCK, etc. */
140 break;
141 }
142 }
143
144 if (hung_up) {
145 hung_up = 0;
Ilpo Järvinen0388a152023-01-17 11:03:54 +0200146 uart_handle_dcd_change(port, true);
David S. Millerc7754d42007-05-15 17:03:54 -0700147 }
148
Vijay Kumar079317a2015-12-23 10:55:33 -0800149 if (port->sysrq != 0 && *con_read_page) {
150 for (i = 0; i < bytes_read; i++)
151 uart_handle_sysrq_char(port, con_read_page[i]);
Vijay Kumar7db60d02017-02-01 11:34:39 -0800152 saw_console_brk = 0;
Vijay Kumar079317a2015-12-23 10:55:33 -0800153 }
David S. Millerc7754d42007-05-15 17:03:54 -0700154
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100155 if (port->state == NULL)
David S. Millerc7754d42007-05-15 17:03:54 -0700156 continue;
157
158 port->icount.rx += bytes_read;
159
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100160 tty_insert_flip_string(&port->state->port, con_read_page,
161 bytes_read);
David S. Millerc7754d42007-05-15 17:03:54 -0700162 }
163
164 return saw_console_brk;
165}
166
167struct sunhv_ops {
168 void (*transmit_chars)(struct uart_port *port, struct circ_buf *xmit);
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100169 int (*receive_chars)(struct uart_port *port);
David S. Millerc7754d42007-05-15 17:03:54 -0700170};
171
Aya Mahfouz01fd3c22015-12-15 01:37:57 +0200172static const struct sunhv_ops bychar_ops = {
David S. Millerc7754d42007-05-15 17:03:54 -0700173 .transmit_chars = transmit_chars_putchar,
174 .receive_chars = receive_chars_getchar,
175};
176
Aya Mahfouz01fd3c22015-12-15 01:37:57 +0200177static const struct sunhv_ops bywrite_ops = {
David S. Millerc7754d42007-05-15 17:03:54 -0700178 .transmit_chars = transmit_chars_write,
179 .receive_chars = receive_chars_read,
180};
181
Aya Mahfouz01fd3c22015-12-15 01:37:57 +0200182static const struct sunhv_ops *sunhv_ops = &bychar_ops;
David S. Millerc7754d42007-05-15 17:03:54 -0700183
Jiri Slaby2e124b42013-01-03 15:53:06 +0100184static struct tty_port *receive_chars(struct uart_port *port)
David S. Millerc7754d42007-05-15 17:03:54 -0700185{
Jiri Slaby2e124b42013-01-03 15:53:06 +0100186 struct tty_port *tport = NULL;
David S. Millerc7754d42007-05-15 17:03:54 -0700187
Alan Coxebd2c8f2009-09-19 13:13:28 -0700188 if (port->state != NULL) /* Unopened serial console */
Jiri Slaby2e124b42013-01-03 15:53:06 +0100189 tport = &port->state->port;
David S. Millerc7754d42007-05-15 17:03:54 -0700190
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100191 if (sunhv_ops->receive_chars(port))
David S. Miller02fd4732006-02-11 02:25:21 -0800192 sun_do_break();
193
Jiri Slaby2e124b42013-01-03 15:53:06 +0100194 return tport;
David S. Miller02fd4732006-02-11 02:25:21 -0800195}
196
197static void transmit_chars(struct uart_port *port)
198{
David S. Millerdb33f9b2006-02-15 21:56:49 -0800199 struct circ_buf *xmit;
David S. Miller02fd4732006-02-11 02:25:21 -0800200
Alan Coxebd2c8f2009-09-19 13:13:28 -0700201 if (!port->state)
David S. Millerdb33f9b2006-02-15 21:56:49 -0800202 return;
203
Alan Coxebd2c8f2009-09-19 13:13:28 -0700204 xmit = &port->state->xmit;
David S. Miller02fd4732006-02-11 02:25:21 -0800205 if (uart_circ_empty(xmit) || uart_tx_stopped(port))
206 return;
207
David S. Millerc7754d42007-05-15 17:03:54 -0700208 sunhv_ops->transmit_chars(port, xmit);
David S. Miller02fd4732006-02-11 02:25:21 -0800209
210 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
211 uart_write_wakeup(port);
212}
213
David Howells7d12e782006-10-05 14:55:46 +0100214static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
David S. Miller02fd4732006-02-11 02:25:21 -0800215{
216 struct uart_port *port = dev_id;
Jiri Slaby2e124b42013-01-03 15:53:06 +0100217 struct tty_port *tport;
David S. Miller02fd4732006-02-11 02:25:21 -0800218 unsigned long flags;
219
220 spin_lock_irqsave(&port->lock, flags);
Jiri Slaby2e124b42013-01-03 15:53:06 +0100221 tport = receive_chars(port);
David S. Miller02fd4732006-02-11 02:25:21 -0800222 transmit_chars(port);
223 spin_unlock_irqrestore(&port->lock, flags);
224
Jiri Slaby2e124b42013-01-03 15:53:06 +0100225 if (tport)
226 tty_flip_buffer_push(tport);
David S. Miller02fd4732006-02-11 02:25:21 -0800227
228 return IRQ_HANDLED;
229}
230
231/* port->lock is not held. */
232static unsigned int sunhv_tx_empty(struct uart_port *port)
233{
234 /* Transmitter is always empty for us. If the circ buffer
235 * is non-empty or there is an x_char pending, our caller
236 * will do the right thing and ignore what we return here.
237 */
238 return TIOCSER_TEMT;
239}
240
241/* port->lock held by caller. */
242static void sunhv_set_mctrl(struct uart_port *port, unsigned int mctrl)
243{
244 return;
245}
246
247/* port->lock is held by caller and interrupts are disabled. */
248static unsigned int sunhv_get_mctrl(struct uart_port *port)
249{
250 return TIOCM_DSR | TIOCM_CAR | TIOCM_CTS;
251}
252
253/* port->lock held by caller. */
254static void sunhv_stop_tx(struct uart_port *port)
255{
256 return;
257}
258
259/* port->lock held by caller. */
260static void sunhv_start_tx(struct uart_port *port)
261{
David S. Millerf7986342007-07-16 17:05:11 -0700262 transmit_chars(port);
David S. Miller02fd4732006-02-11 02:25:21 -0800263}
264
265/* port->lock is not held. */
266static void sunhv_send_xchar(struct uart_port *port, char ch)
267{
268 unsigned long flags;
269 int limit = 10000;
270
Peter Hurleydb106df2014-09-02 17:39:15 -0400271 if (ch == __DISABLED_CHAR)
272 return;
273
David S. Miller02fd4732006-02-11 02:25:21 -0800274 spin_lock_irqsave(&port->lock, flags);
275
276 while (limit-- > 0) {
David S. Millerc7754d42007-05-15 17:03:54 -0700277 long status = sun4v_con_putchar(ch);
David S. Miller02fd4732006-02-11 02:25:21 -0800278 if (status == HV_EOK)
279 break;
David S. Millerc7754d42007-05-15 17:03:54 -0700280 udelay(1);
David S. Miller02fd4732006-02-11 02:25:21 -0800281 }
282
283 spin_unlock_irqrestore(&port->lock, flags);
284}
285
286/* port->lock held by caller. */
287static void sunhv_stop_rx(struct uart_port *port)
288{
289}
290
David S. Miller02fd4732006-02-11 02:25:21 -0800291/* port->lock is not held. */
292static void sunhv_break_ctl(struct uart_port *port, int break_state)
293{
294 if (break_state) {
295 unsigned long flags;
David S. Millerc7754d42007-05-15 17:03:54 -0700296 int limit = 10000;
David S. Miller02fd4732006-02-11 02:25:21 -0800297
298 spin_lock_irqsave(&port->lock, flags);
299
300 while (limit-- > 0) {
David S. Millerc7754d42007-05-15 17:03:54 -0700301 long status = sun4v_con_putchar(CON_BREAK);
David S. Miller02fd4732006-02-11 02:25:21 -0800302 if (status == HV_EOK)
303 break;
David S. Millerc7754d42007-05-15 17:03:54 -0700304 udelay(1);
David S. Miller02fd4732006-02-11 02:25:21 -0800305 }
306
307 spin_unlock_irqrestore(&port->lock, flags);
308 }
309}
310
311/* port->lock is not held. */
312static int sunhv_startup(struct uart_port *port)
313{
314 return 0;
315}
316
317/* port->lock is not held. */
318static void sunhv_shutdown(struct uart_port *port)
319{
320}
321
322/* port->lock is not held. */
Alan Cox606d0992006-12-08 02:38:45 -0800323static void sunhv_set_termios(struct uart_port *port, struct ktermios *termios,
Ilpo Järvinenbec5b812022-08-16 14:57:37 +0300324 const struct ktermios *old)
David S. Miller02fd4732006-02-11 02:25:21 -0800325{
326 unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
327 unsigned int quot = uart_get_divisor(port, baud);
328 unsigned int iflag, cflag;
329 unsigned long flags;
330
331 spin_lock_irqsave(&port->lock, flags);
332
333 iflag = termios->c_iflag;
334 cflag = termios->c_cflag;
335
336 port->ignore_status_mask = 0;
337 if (iflag & IGNBRK)
338 port->ignore_status_mask |= IGNORE_BREAK;
339 if ((cflag & CREAD) == 0)
340 port->ignore_status_mask |= IGNORE_ALL;
341
342 /* XXX */
343 uart_update_timeout(port, cflag,
344 (port->uartclk / (16 * quot)));
345
346 spin_unlock_irqrestore(&port->lock, flags);
347}
348
349static const char *sunhv_type(struct uart_port *port)
350{
351 return "SUN4V HCONS";
352}
353
354static void sunhv_release_port(struct uart_port *port)
355{
356}
357
358static int sunhv_request_port(struct uart_port *port)
359{
360 return 0;
361}
362
363static void sunhv_config_port(struct uart_port *port, int flags)
364{
365}
366
367static int sunhv_verify_port(struct uart_port *port, struct serial_struct *ser)
368{
369 return -EINVAL;
370}
371
Bhumika Goyal2331e062017-01-25 23:18:52 +0530372static const struct uart_ops sunhv_pops = {
David S. Miller02fd4732006-02-11 02:25:21 -0800373 .tx_empty = sunhv_tx_empty,
374 .set_mctrl = sunhv_set_mctrl,
375 .get_mctrl = sunhv_get_mctrl,
376 .stop_tx = sunhv_stop_tx,
377 .start_tx = sunhv_start_tx,
378 .send_xchar = sunhv_send_xchar,
379 .stop_rx = sunhv_stop_rx,
David S. Miller02fd4732006-02-11 02:25:21 -0800380 .break_ctl = sunhv_break_ctl,
381 .startup = sunhv_startup,
382 .shutdown = sunhv_shutdown,
383 .set_termios = sunhv_set_termios,
384 .type = sunhv_type,
385 .release_port = sunhv_release_port,
386 .request_port = sunhv_request_port,
387 .config_port = sunhv_config_port,
388 .verify_port = sunhv_verify_port,
389};
390
391static struct uart_driver sunhv_reg = {
392 .owner = THIS_MODULE,
David S. Miller32039f42008-05-01 01:14:27 -0700393 .driver_name = "sunhv",
John Paul Adrian Glaubitz07a6d632019-06-11 17:38:37 +0200394 .dev_name = "ttyHV",
David S. Miller02fd4732006-02-11 02:25:21 -0800395 .major = TTY_MAJOR,
396};
397
398static struct uart_port *sunhv_port;
399
Vijay Kumar7dd4fcf2017-02-01 11:34:38 -0800400void sunhv_migrate_hvcons_irq(int cpu)
401{
402 /* Migrate hvcons irq to param cpu */
403 irq_force_affinity(sunhv_port->irq, cpumask_of(cpu));
404}
405
David S. Millerc7754d42007-05-15 17:03:54 -0700406/* Copy 's' into the con_write_page, decoding "\n" into
407 * "\r\n" along the way. We have to return two lengths
408 * because the caller needs to know how much to advance
409 * 's' and also how many bytes to output via con_write_page.
410 */
411static int fill_con_write_page(const char *s, unsigned int n,
412 unsigned long *page_bytes)
David S. Miller02fd4732006-02-11 02:25:21 -0800413{
David S. Millerc7754d42007-05-15 17:03:54 -0700414 const char *orig_s = s;
415 char *p = con_write_page;
416 int left = PAGE_SIZE;
417
418 while (n--) {
419 if (*s == '\n') {
420 if (left < 2)
421 break;
422 *p++ = '\r';
423 left--;
424 } else if (left < 1)
425 break;
426 *p++ = *s++;
427 left--;
428 }
429 *page_bytes = p - con_write_page;
430 return s - orig_s;
431}
432
433static void sunhv_console_write_paged(struct console *con, const char *s, unsigned n)
434{
435 struct uart_port *port = sunhv_port;
David S. Miller02fd4732006-02-11 02:25:21 -0800436 unsigned long flags;
David S. Millerf3c681c2007-07-15 23:53:32 -0700437 int locked = 1;
David S. Miller02fd4732006-02-11 02:25:21 -0800438
David Millere58e2412014-03-04 15:28:35 -0500439 if (port->sysrq || oops_in_progress)
440 locked = spin_trylock_irqsave(&port->lock, flags);
441 else
442 spin_lock_irqsave(&port->lock, flags);
David S. Millerf3c681c2007-07-15 23:53:32 -0700443
David S. Millerc7754d42007-05-15 17:03:54 -0700444 while (n > 0) {
445 unsigned long ra = __pa(con_write_page);
446 unsigned long page_bytes;
447 unsigned int cpy = fill_con_write_page(s, n,
448 &page_bytes);
David S. Miller02fd4732006-02-11 02:25:21 -0800449
David S. Millerc7754d42007-05-15 17:03:54 -0700450 n -= cpy;
451 s += cpy;
452 while (page_bytes > 0) {
453 unsigned long written;
454 int limit = 1000000;
455
456 while (limit--) {
457 unsigned long stat;
458
459 stat = sun4v_con_write(ra, page_bytes,
460 &written);
461 if (stat == HV_EOK)
462 break;
463 udelay(1);
464 }
Roel Kluin52e36322009-06-22 18:41:56 +0100465 if (limit < 0)
David S. Millerc7754d42007-05-15 17:03:54 -0700466 break;
467 page_bytes -= written;
468 ra += written;
469 }
David S. Miller02fd4732006-02-11 02:25:21 -0800470 }
David S. Millerf3c681c2007-07-15 23:53:32 -0700471
472 if (locked)
David Millere58e2412014-03-04 15:28:35 -0500473 spin_unlock_irqrestore(&port->lock, flags);
David S. Miller02fd4732006-02-11 02:25:21 -0800474}
475
David S. Millerc7754d42007-05-15 17:03:54 -0700476static inline void sunhv_console_putchar(struct uart_port *port, char c)
477{
478 int limit = 1000000;
479
480 while (limit-- > 0) {
481 long status = sun4v_con_putchar(c);
482 if (status == HV_EOK)
483 break;
484 udelay(1);
485 }
486}
487
488static void sunhv_console_write_bychar(struct console *con, const char *s, unsigned n)
David S. Miller02fd4732006-02-11 02:25:21 -0800489{
490 struct uart_port *port = sunhv_port;
David S. Millerc7754d42007-05-15 17:03:54 -0700491 unsigned long flags;
David S. Millerf3c681c2007-07-15 23:53:32 -0700492 int i, locked = 1;
493
David Millere58e2412014-03-04 15:28:35 -0500494 if (port->sysrq || oops_in_progress)
495 locked = spin_trylock_irqsave(&port->lock, flags);
496 else
497 spin_lock_irqsave(&port->lock, flags);
David S. Miller02fd4732006-02-11 02:25:21 -0800498
499 for (i = 0; i < n; i++) {
500 if (*s == '\n')
501 sunhv_console_putchar(port, '\r');
502 sunhv_console_putchar(port, *s++);
503 }
David S. Millerf3c681c2007-07-15 23:53:32 -0700504
505 if (locked)
David Millere58e2412014-03-04 15:28:35 -0500506 spin_unlock_irqrestore(&port->lock, flags);
David S. Miller02fd4732006-02-11 02:25:21 -0800507}
508
David S. Miller02fd4732006-02-11 02:25:21 -0800509static struct console sunhv_console = {
David S. Millerd5a2aa22006-02-13 21:28:40 -0800510 .name = "ttyHV",
David S. Millerc7754d42007-05-15 17:03:54 -0700511 .write = sunhv_console_write_bychar,
David S. Miller02fd4732006-02-11 02:25:21 -0800512 .device = uart_console_device,
David S. Miller02fd4732006-02-11 02:25:21 -0800513 .flags = CON_PRINTBUFFER,
514 .index = -1,
515 .data = &sunhv_reg,
516};
517
Bill Pemberton9671f092012-11-19 13:21:50 -0500518static int hv_probe(struct platform_device *op)
David S. Miller02fd4732006-02-11 02:25:21 -0800519{
520 struct uart_port *port;
David S. Millerc7754d42007-05-15 17:03:54 -0700521 unsigned long minor;
David S. Miller93872ba2006-06-30 00:00:22 -0700522 int err;
David S. Miller02fd4732006-02-11 02:25:21 -0800523
Grant Likely1636f8a2010-06-18 11:09:58 -0600524 if (op->archdata.irqs[0] == 0xffffffff)
David S. Miller02fd4732006-02-11 02:25:21 -0800525 return -ENODEV;
526
David S. Miller93872ba2006-06-30 00:00:22 -0700527 port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
David S. Miller02fd4732006-02-11 02:25:21 -0800528 if (unlikely(!port))
529 return -ENOMEM;
530
David S. Millerc7754d42007-05-15 17:03:54 -0700531 minor = 1;
532 if (sun4v_hvapi_register(HV_GRP_CORE, 1, &minor) == 0 &&
533 minor >= 1) {
534 err = -ENOMEM;
535 con_write_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
536 if (!con_write_page)
537 goto out_free_port;
538
539 con_read_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
540 if (!con_read_page)
541 goto out_free_con_write_page;
542
543 sunhv_console.write = sunhv_console_write_paged;
544 sunhv_ops = &bywrite_ops;
545 }
546
David S. Miller93872ba2006-06-30 00:00:22 -0700547 sunhv_port = port;
David S. Millerdb33f9b2006-02-15 21:56:49 -0800548
Dmitry Safonovb0711262019-12-13 00:06:44 +0000549 port->has_sysrq = 1;
David S. Miller02fd4732006-02-11 02:25:21 -0800550 port->line = 0;
551 port->ops = &sunhv_pops;
552 port->type = PORT_SUNHV;
553 port->uartclk = ( 29491200 / 16 ); /* arbitrary */
554
David S. Millerdb33f9b2006-02-15 21:56:49 -0800555 port->membase = (unsigned char __iomem *) __pa(port);
556
Grant Likely1636f8a2010-06-18 11:09:58 -0600557 port->irq = op->archdata.irqs[0];
David S. Miller93872ba2006-06-30 00:00:22 -0700558
559 port->dev = &op->dev;
David S. Miller02fd4732006-02-11 02:25:21 -0800560
Martin Habets58d784a2007-12-11 03:37:04 -0800561 err = sunserial_register_minors(&sunhv_reg, 1);
David S. Miller93872ba2006-06-30 00:00:22 -0700562 if (err)
David S. Millerc7754d42007-05-15 17:03:54 -0700563 goto out_free_con_read_page;
David S. Miller02fd4732006-02-11 02:25:21 -0800564
Grant Likely61c7a082010-04-13 16:12:29 -0700565 sunserial_console_match(&sunhv_console, op->dev.of_node,
David S. Miller457931d2009-11-24 14:09:56 -0800566 &sunhv_reg, port->line, false);
David S. Millerd5a2aa22006-02-13 21:28:40 -0800567
David S. Miller93872ba2006-06-30 00:00:22 -0700568 err = uart_add_one_port(&sunhv_reg, port);
569 if (err)
570 goto out_unregister_driver;
David S. Miller02fd4732006-02-11 02:25:21 -0800571
David S. Miller93872ba2006-06-30 00:00:22 -0700572 err = request_irq(port->irq, sunhv_interrupt, 0, "hvcons", port);
573 if (err)
574 goto out_remove_port;
David S. Millerdb33f9b2006-02-15 21:56:49 -0800575
Jingoo Han696faed2013-05-23 19:39:36 +0900576 platform_set_drvdata(op, port);
David S. Miller02fd4732006-02-11 02:25:21 -0800577
578 return 0;
David S. Miller93872ba2006-06-30 00:00:22 -0700579
580out_remove_port:
581 uart_remove_one_port(&sunhv_reg, port);
582
583out_unregister_driver:
Martin Habets58d784a2007-12-11 03:37:04 -0800584 sunserial_unregister_minors(&sunhv_reg, 1);
David S. Miller93872ba2006-06-30 00:00:22 -0700585
David S. Millerc7754d42007-05-15 17:03:54 -0700586out_free_con_read_page:
587 kfree(con_read_page);
588
589out_free_con_write_page:
590 kfree(con_write_page);
591
David S. Miller93872ba2006-06-30 00:00:22 -0700592out_free_port:
593 kfree(port);
594 sunhv_port = NULL;
595 return err;
David S. Miller02fd4732006-02-11 02:25:21 -0800596}
597
Bill Pembertonae8d8a12012-11-19 13:26:18 -0500598static int hv_remove(struct platform_device *dev)
David S. Miller02fd4732006-02-11 02:25:21 -0800599{
Jingoo Han696faed2013-05-23 19:39:36 +0900600 struct uart_port *port = platform_get_drvdata(dev);
David S. Miller02fd4732006-02-11 02:25:21 -0800601
David S. Millerdb33f9b2006-02-15 21:56:49 -0800602 free_irq(port->irq, port);
603
David S. Miller02fd4732006-02-11 02:25:21 -0800604 uart_remove_one_port(&sunhv_reg, port);
David S. Miller02fd4732006-02-11 02:25:21 -0800605
Martin Habets58d784a2007-12-11 03:37:04 -0800606 sunserial_unregister_minors(&sunhv_reg, 1);
Souptick Joarderfbb7d2e2016-11-14 18:07:36 +0530607 kfree(con_read_page);
608 kfree(con_write_page);
David S. Miller93872ba2006-06-30 00:00:22 -0700609 kfree(port);
David S. Miller02fd4732006-02-11 02:25:21 -0800610 sunhv_port = NULL;
David S. Miller93872ba2006-06-30 00:00:22 -0700611
David S. Miller93872ba2006-06-30 00:00:22 -0700612 return 0;
613}
614
David S. Millerfd098312008-08-31 01:23:17 -0700615static const struct of_device_id hv_match[] = {
David S. Miller93872ba2006-06-30 00:00:22 -0700616 {
617 .name = "console",
618 .compatible = "qcn",
619 },
David S. Miller7a05b592007-05-13 21:27:37 -0700620 {
621 .name = "console",
622 .compatible = "SUNW,sun4v-console",
623 },
David S. Miller93872ba2006-06-30 00:00:22 -0700624 {},
625};
David S. Miller93872ba2006-06-30 00:00:22 -0700626
Grant Likely793218d2011-02-22 21:10:26 -0700627static struct platform_driver hv_driver = {
Grant Likely40182942010-04-13 16:13:02 -0700628 .driver = {
629 .name = "hv",
Grant Likely40182942010-04-13 16:13:02 -0700630 .of_match_table = hv_match,
631 },
David S. Miller93872ba2006-06-30 00:00:22 -0700632 .probe = hv_probe,
Bill Pemberton2d47b712012-11-19 13:21:34 -0500633 .remove = hv_remove,
David S. Miller93872ba2006-06-30 00:00:22 -0700634};
635
636static int __init sunhv_init(void)
637{
638 if (tlb_type != hypervisor)
639 return -ENODEV;
640
Grant Likely793218d2011-02-22 21:10:26 -0700641 return platform_driver_register(&hv_driver);
David S. Miller93872ba2006-06-30 00:00:22 -0700642}
Paul Gortmaker4fef5352015-07-21 22:02:18 -0400643device_initcall(sunhv_init);
David S. Miller93872ba2006-06-30 00:00:22 -0700644
Paul Gortmaker4fef5352015-07-21 22:02:18 -0400645#if 0 /* ...def MODULE ; never supported as such */
David S. Miller02fd4732006-02-11 02:25:21 -0800646MODULE_AUTHOR("David S. Miller");
David S. Miller93872ba2006-06-30 00:00:22 -0700647MODULE_DESCRIPTION("SUN4V Hypervisor console driver");
648MODULE_VERSION("2.0");
David S. Miller02fd4732006-02-11 02:25:21 -0800649MODULE_LICENSE("GPL");
Paul Gortmaker4fef5352015-07-21 22:02:18 -0400650#endif