drivers/tty/serial/sunhv.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* sunhv.c: Serial driver for SUN4V hypervisor console.
   3  *
   4  * Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net)
   5  */
   6
   7 #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>
  20 #include <linux/of.h>
  21 #include <linux/platform_device.h>
  22
  23 #include <asm/hypervisor.h>
  24 #include <asm/spitfire.h>
  25 #include <asm/irq.h>
  26 #include <asm/setup.h>
  27
  28 #include <linux/serial_core.h>
  29 #include <linux/sunserialcore.h>
  30
  31 #define CON_BREAK       ((long)-1)
  32 #define CON_HUP         ((long)-2)
  33
  34 #define IGNORE_BREAK    0x1
  35 #define IGNORE_ALL      0x2
  36
  37 static char *con_write_page;
  38 static char *con_read_page;
  39
  40 static int hung_up = 0;
  41
  42 static void transmit_chars_putchar(struct uart_port *port,
  43                 struct tty_port *tport)
  44 {
  45         unsigned char ch;
  46
  47         while (kfifo_peek(&tport->xmit_fifo, &ch)) {
  48                 long status = sun4v_con_putchar(ch);
  49
  50                 if (status != HV_EOK)
  51                         break;
  52
  53                 uart_xmit_advance(port, 1);
  54         }
  55 }
  56
  57 static void transmit_chars_write(struct uart_port *port, struct tty_port *tport)
  58 {
  59         while (!kfifo_is_empty(&tport->xmit_fifo)) {
  60                 unsigned long len, ra, status, sent;
  61                 unsigned char *tail;
  62
  63                 len = kfifo_out_linear_ptr(&tport->xmit_fifo, &tail,
  64                                 UART_XMIT_SIZE);
  65                 ra = __pa(tail);
  66
  67                 status = sun4v_con_write(ra, len, &sent);
  68                 if (status != HV_EOK)
  69                         break;
  70                 uart_xmit_advance(port, sent);
  71         }
  72 }
  73
  74 static int receive_chars_getchar(struct uart_port *port)
  75 {
  76         int saw_console_brk = 0;
  77         int limit = 10000;
  78
  79         while (limit-- > 0) {
  80                 long status;
  81                 long c = sun4v_con_getchar(&status);
  82
  83                 if (status == HV_EWOULDBLOCK)
  84                         break;
  85
  86                 if (c == CON_BREAK) {
  87                         if (uart_handle_break(port))
  88                                 continue;
  89                         saw_console_brk = 1;
  90                         c = 0;
  91                 }
  92
  93                 if (c == CON_HUP) {
  94                         hung_up = 1;
  95                         uart_handle_dcd_change(port, false);
  96                 } else if (hung_up) {
  97                         hung_up = 0;
  98                         uart_handle_dcd_change(port, true);
  99                 }
 100
 101                 if (port->state == NULL) {
 102                         uart_handle_sysrq_char(port, c);
 103                         continue;
 104                 }
 105
 106                 port->icount.rx++;
 107
 108                 if (uart_handle_sysrq_char(port, c))
 109                         continue;
 110
 111                 tty_insert_flip_char(&port->state->port, c, TTY_NORMAL);
 112         }
 113
 114         return saw_console_brk;
 115 }
 116
 117 static int receive_chars_read(struct uart_port *port)
 118 {
 119         static int saw_console_brk;
 120         int limit = 10000;
 121
 122         while (limit-- > 0) {
 123                 unsigned long ra = __pa(con_read_page);
 124                 unsigned long bytes_read, i;
 125                 long stat = sun4v_con_read(ra, PAGE_SIZE, &bytes_read);
 126
 127                 if (stat != HV_EOK) {
 128                         bytes_read = 0;
 129
 130                         if (stat == CON_BREAK) {
 131                                 if (saw_console_brk)
 132                                         sun_do_break();
 133
 134                                 if (uart_handle_break(port))
 135                                         continue;
 136                                 saw_console_brk = 1;
 137                                 *con_read_page = 0;
 138                                 bytes_read = 1;
 139                         } else if (stat == CON_HUP) {
 140                                 hung_up = 1;
 141                                 uart_handle_dcd_change(port, false);
 142                                 continue;
 143                         } else {
 144                                 /* HV_EWOULDBLOCK, etc.  */
 145                                 break;
 146                         }
 147                 }
 148
 149                 if (hung_up) {
 150                         hung_up = 0;
 151                         uart_handle_dcd_change(port, true);
 152                 }
 153
 154                 if (port->sysrq != 0 &&  *con_read_page) {
 155                         for (i = 0; i < bytes_read; i++)
 156                                 uart_handle_sysrq_char(port, con_read_page[i]);
 157                         saw_console_brk = 0;
 158                 }
 159
 160                 if (port->state == NULL)
 161                         continue;
 162
 163                 port->icount.rx += bytes_read;
 164
 165                 tty_insert_flip_string(&port->state->port, con_read_page,
 166                                 bytes_read);
 167         }
 168
 169         return saw_console_brk;
 170 }
 171
 172 struct sunhv_ops {
 173         void (*transmit_chars)(struct uart_port *port, struct tty_port *tport);
 174         int (*receive_chars)(struct uart_port *port);
 175 };
 176
 177 static const struct sunhv_ops bychar_ops = {
 178         .transmit_chars = transmit_chars_putchar,
 179         .receive_chars = receive_chars_getchar,
 180 };
 181
 182 static const struct sunhv_ops bywrite_ops = {
 183         .transmit_chars = transmit_chars_write,
 184         .receive_chars = receive_chars_read,
 185 };
 186
 187 static const struct sunhv_ops *sunhv_ops = &bychar_ops;
 188
 189 static struct tty_port *receive_chars(struct uart_port *port)
 190 {
 191         struct tty_port *tport = NULL;
 192
 193         if (port->state != NULL)                /* Unopened serial console */
 194                 tport = &port->state->port;
 195
 196         if (sunhv_ops->receive_chars(port))
 197                 sun_do_break();
 198
 199         return tport;
 200 }
 201
 202 static void transmit_chars(struct uart_port *port)
 203 {
 204         struct tty_port *tport;
 205
 206         if (!port->state)
 207                 return;
 208
 209         tport = &port->state->port;
 210         if (kfifo_is_empty(&tport->xmit_fifo) || uart_tx_stopped(port))
 211                 return;
 212
 213         sunhv_ops->transmit_chars(port, tport);
 214
 215         if (kfifo_len(&tport->xmit_fifo) < WAKEUP_CHARS)
 216                 uart_write_wakeup(port);
 217 }
 218
 219 static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
 220 {
 221         struct uart_port *port = dev_id;
 222         struct tty_port *tport;
 223         unsigned long flags;
 224
 225         uart_port_lock_irqsave(port, &flags);
 226         tport = receive_chars(port);
 227         transmit_chars(port);
 228         uart_port_unlock_irqrestore(port, flags);
 229
 230         if (tport)
 231                 tty_flip_buffer_push(tport);
 232
 233         return IRQ_HANDLED;
 234 }
 235
 236 /* port->lock is not held.  */
 237 static unsigned int sunhv_tx_empty(struct uart_port *port)
 238 {
 239         /* Transmitter is always empty for us.  If the circ buffer
 240          * is non-empty or there is an x_char pending, our caller
 241          * will do the right thing and ignore what we return here.
 242          */
 243         return TIOCSER_TEMT;
 244 }
 245
 246 /* port->lock held by caller.  */
 247 static void sunhv_set_mctrl(struct uart_port *port, unsigned int mctrl)
 248 {
 249         return;
 250 }
 251
 252 /* port->lock is held by caller and interrupts are disabled.  */
 253 static unsigned int sunhv_get_mctrl(struct uart_port *port)
 254 {
 255         return TIOCM_DSR | TIOCM_CAR | TIOCM_CTS;
 256 }
 257
 258 /* port->lock held by caller.  */
 259 static void sunhv_stop_tx(struct uart_port *port)
 260 {
 261         return;
 262 }
 263
 264 /* port->lock held by caller.  */
 265 static void sunhv_start_tx(struct uart_port *port)
 266 {
 267         transmit_chars(port);
 268 }
 269
 270 /* port->lock is not held.  */
 271 static void sunhv_send_xchar(struct uart_port *port, char ch)
 272 {
 273         unsigned long flags;
 274         int limit = 10000;
 275
 276         if (ch == __DISABLED_CHAR)
 277                 return;
 278
 279         uart_port_lock_irqsave(port, &flags);
 280
 281         while (limit-- > 0) {
 282                 long status = sun4v_con_putchar(ch);
 283                 if (status == HV_EOK)
 284                         break;
 285                 udelay(1);
 286         }
 287
 288         uart_port_unlock_irqrestore(port, flags);
 289 }
 290
 291 /* port->lock held by caller.  */
 292 static void sunhv_stop_rx(struct uart_port *port)
 293 {
 294 }
 295
 296 /* port->lock is not held.  */
 297 static void sunhv_break_ctl(struct uart_port *port, int break_state)
 298 {
 299         if (break_state) {
 300                 unsigned long flags;
 301                 int limit = 10000;
 302
 303                 uart_port_lock_irqsave(port, &flags);
 304
 305                 while (limit-- > 0) {
 306                         long status = sun4v_con_putchar(CON_BREAK);
 307                         if (status == HV_EOK)
 308                                 break;
 309                         udelay(1);
 310                 }
 311
 312                 uart_port_unlock_irqrestore(port, flags);
 313         }
 314 }
 315
 316 /* port->lock is not held.  */
 317 static int sunhv_startup(struct uart_port *port)
 318 {
 319         return 0;
 320 }
 321
 322 /* port->lock is not held.  */
 323 static void sunhv_shutdown(struct uart_port *port)
 324 {
 325 }
 326
 327 /* port->lock is not held.  */
 328 static void sunhv_set_termios(struct uart_port *port, struct ktermios *termios,
 329                               const struct ktermios *old)
 330 {
 331         unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
 332         unsigned int quot = uart_get_divisor(port, baud);
 333         unsigned int iflag, cflag;
 334         unsigned long flags;
 335
 336         uart_port_lock_irqsave(port, &flags);
 337
 338         iflag = termios->c_iflag;
 339         cflag = termios->c_cflag;
 340
 341         port->ignore_status_mask = 0;
 342         if (iflag & IGNBRK)
 343                 port->ignore_status_mask |= IGNORE_BREAK;
 344         if ((cflag & CREAD) == 0)
 345                 port->ignore_status_mask |= IGNORE_ALL;
 346
 347         /* XXX */
 348         uart_update_timeout(port, cflag,
 349                             (port->uartclk / (16 * quot)));
 350
 351         uart_port_unlock_irqrestore(port, flags);
 352 }
 353
 354 static const char *sunhv_type(struct uart_port *port)
 355 {
 356         return "SUN4V HCONS";
 357 }
 358
 359 static void sunhv_release_port(struct uart_port *port)
 360 {
 361 }
 362
 363 static int sunhv_request_port(struct uart_port *port)
 364 {
 365         return 0;
 366 }
 367
 368 static void sunhv_config_port(struct uart_port *port, int flags)
 369 {
 370 }
 371
 372 static int sunhv_verify_port(struct uart_port *port, struct serial_struct *ser)
 373 {
 374         return -EINVAL;
 375 }
 376
 377 static const struct uart_ops sunhv_pops = {
 378         .tx_empty       = sunhv_tx_empty,
 379         .set_mctrl      = sunhv_set_mctrl,
 380         .get_mctrl      = sunhv_get_mctrl,
 381         .stop_tx        = sunhv_stop_tx,
 382         .start_tx       = sunhv_start_tx,
 383         .send_xchar     = sunhv_send_xchar,
 384         .stop_rx        = sunhv_stop_rx,
 385         .break_ctl      = sunhv_break_ctl,
 386         .startup        = sunhv_startup,
 387         .shutdown       = sunhv_shutdown,
 388         .set_termios    = sunhv_set_termios,
 389         .type           = sunhv_type,
 390         .release_port   = sunhv_release_port,
 391         .request_port   = sunhv_request_port,
 392         .config_port    = sunhv_config_port,
 393         .verify_port    = sunhv_verify_port,
 394 };
 395
 396 static struct uart_driver sunhv_reg = {
 397         .owner                  = THIS_MODULE,
 398         .driver_name            = "sunhv",
 399         .dev_name               = "ttyHV",
 400         .major                  = TTY_MAJOR,
 401 };
 402
 403 static struct uart_port *sunhv_port;
 404
 405 void sunhv_migrate_hvcons_irq(int cpu)
 406 {
 407         /* Migrate hvcons irq to param cpu */
 408         irq_force_affinity(sunhv_port->irq, cpumask_of(cpu));
 409 }
 410
 411 /* Copy 's' into the con_write_page, decoding "\n" into
 412  * "\r\n" along the way.  We have to return two lengths
 413  * because the caller needs to know how much to advance
 414  * 's' and also how many bytes to output via con_write_page.
 415  */
 416 static int fill_con_write_page(const char *s, unsigned int n,
 417                                unsigned long *page_bytes)
 418 {
 419         const char *orig_s = s;
 420         char *p = con_write_page;
 421         int left = PAGE_SIZE;
 422
 423         while (n--) {
 424                 if (*s == '\n') {
 425                         if (left < 2)
 426                                 break;
 427                         *p++ = '\r';
 428                         left--;
 429                 } else if (left < 1)
 430                         break;
 431                 *p++ = *s++;
 432                 left--;
 433         }
 434         *page_bytes = p - con_write_page;
 435         return s - orig_s;
 436 }
 437
 438 static void sunhv_console_write_paged(struct console *con, const char *s, unsigned n)
 439 {
 440         struct uart_port *port = sunhv_port;
 441         unsigned long flags;
 442         int locked = 1;
 443
 444         if (port->sysrq || oops_in_progress)
 445                 locked = uart_port_trylock_irqsave(port, &flags);
 446         else
 447                 uart_port_lock_irqsave(port, &flags);
 448
 449         while (n > 0) {
 450                 unsigned long ra = __pa(con_write_page);
 451                 unsigned long page_bytes;
 452                 unsigned int cpy = fill_con_write_page(s, n,
 453                                                        &page_bytes);
 454
 455                 n -= cpy;
 456                 s += cpy;
 457                 while (page_bytes > 0) {
 458                         unsigned long written;
 459                         int limit = 1000000;
 460
 461                         while (limit--) {
 462                                 unsigned long stat;
 463
 464                                 stat = sun4v_con_write(ra, page_bytes,
 465                                                        &written);
 466                                 if (stat == HV_EOK)
 467                                         break;
 468                                 udelay(1);
 469                         }
 470                         if (limit < 0)
 471                                 break;
 472                         page_bytes -= written;
 473                         ra += written;
 474                 }
 475         }
 476
 477         if (locked)
 478                 uart_port_unlock_irqrestore(port, flags);
 479 }
 480
 481 static inline void sunhv_console_putchar(struct uart_port *port, char c)
 482 {
 483         int limit = 1000000;
 484
 485         while (limit-- > 0) {
 486                 long status = sun4v_con_putchar(c);
 487                 if (status == HV_EOK)
 488                         break;
 489                 udelay(1);
 490         }
 491 }
 492
 493 static void sunhv_console_write_bychar(struct console *con, const char *s, unsigned n)
 494 {
 495         struct uart_port *port = sunhv_port;
 496         unsigned long flags;
 497         int i, locked = 1;
 498
 499         if (port->sysrq || oops_in_progress)
 500                 locked = uart_port_trylock_irqsave(port, &flags);
 501         else
 502                 uart_port_lock_irqsave(port, &flags);
 503
 504         for (i = 0; i < n; i++) {
 505                 if (*s == '\n')
 506                         sunhv_console_putchar(port, '\r');
 507                 sunhv_console_putchar(port, *s++);
 508         }
 509
 510         if (locked)
 511                 uart_port_unlock_irqrestore(port, flags);
 512 }
 513
 514 static struct console sunhv_console = {
 515         .name   =       "ttyHV",
 516         .write  =       sunhv_console_write_bychar,
 517         .device =       uart_console_device,
 518         .flags  =       CON_PRINTBUFFER,
 519         .index  =       -1,
 520         .data   =       &sunhv_reg,
 521 };
 522
 523 static int hv_probe(struct platform_device *op)
 524 {
 525         struct uart_port *port;
 526         unsigned long minor;
 527         int err;
 528
 529         if (op->archdata.irqs[0] == 0xffffffff)
 530                 return -ENODEV;
 531
 532         port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
 533         if (unlikely(!port))
 534                 return -ENOMEM;
 535
 536         minor = 1;
 537         if (sun4v_hvapi_register(HV_GRP_CORE, 1, &minor) == 0 &&
 538             minor >= 1) {
 539                 err = -ENOMEM;
 540                 con_write_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
 541                 if (!con_write_page)
 542                         goto out_free_port;
 543
 544                 con_read_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
 545                 if (!con_read_page)
 546                         goto out_free_con_write_page;
 547
 548                 sunhv_console.write = sunhv_console_write_paged;
 549                 sunhv_ops = &bywrite_ops;
 550         }
 551
 552         sunhv_port = port;
 553
 554         port->has_sysrq = 1;
 555         port->line = 0;
 556         port->ops = &sunhv_pops;
 557         port->type = PORT_SUNHV;
 558         port->uartclk = ( 29491200 / 16 ); /* arbitrary */
 559
 560         port->membase = (unsigned char __iomem *) __pa(port);
 561
 562         port->irq = op->archdata.irqs[0];
 563
 564         port->dev = &op->dev;
 565
 566         err = sunserial_register_minors(&sunhv_reg, 1);
 567         if (err)
 568                 goto out_free_con_read_page;
 569
 570         sunserial_console_match(&sunhv_console, op->dev.of_node,
 571                                 &sunhv_reg, port->line, false);
 572
 573         err = uart_add_one_port(&sunhv_reg, port);
 574         if (err)
 575                 goto out_unregister_driver;
 576
 577         err = request_irq(port->irq, sunhv_interrupt, 0, "hvcons", port);
 578         if (err)
 579                 goto out_remove_port;
 580
 581         platform_set_drvdata(op, port);
 582
 583         return 0;
 584
 585 out_remove_port:
 586         uart_remove_one_port(&sunhv_reg, port);
 587
 588 out_unregister_driver:
 589         sunserial_unregister_minors(&sunhv_reg, 1);
 590
 591 out_free_con_read_page:
 592         kfree(con_read_page);
 593
 594 out_free_con_write_page:
 595         kfree(con_write_page);
 596
 597 out_free_port:
 598         kfree(port);
 599         sunhv_port = NULL;
 600         return err;
 601 }
 602
 603 static void hv_remove(struct platform_device *dev)
 604 {
 605         struct uart_port *port = platform_get_drvdata(dev);
 606
 607         free_irq(port->irq, port);
 608
 609         uart_remove_one_port(&sunhv_reg, port);
 610
 611         sunserial_unregister_minors(&sunhv_reg, 1);
 612         kfree(con_read_page);
 613         kfree(con_write_page);
 614         kfree(port);
 615         sunhv_port = NULL;
 616 }
 617
 618 static const struct of_device_id hv_match[] = {
 619         {
 620                 .name = "console",
 621                 .compatible = "qcn",
 622         },
 623         {
 624                 .name = "console",
 625                 .compatible = "SUNW,sun4v-console",
 626         },
 627         {},
 628 };
 629
 630 static struct platform_driver hv_driver = {
 631         .driver = {
 632                 .name = "hv",
 633                 .of_match_table = hv_match,
 634         },
 635         .probe          = hv_probe,
 636         .remove         = hv_remove,
 637 };
 638
 639 static int __init sunhv_init(void)
 640 {
 641         if (tlb_type != hypervisor)
 642                 return -ENODEV;
 643
 644         return platform_driver_register(&hv_driver);
 645 }
 646 device_initcall(sunhv_init);
 647
 648 #if 0 /* ...def MODULE ; never supported as such */
 649 MODULE_AUTHOR("David S. Miller");
 650 MODULE_DESCRIPTION("SUN4V Hypervisor console driver");
 651 MODULE_VERSION("2.0");
 652 MODULE_LICENSE("GPL");
 653 #endif