drivers/tty/hvc/hvc_vio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * vio driver interface to hvc_console.c
   4  *
   5  * This code was moved here to allow the remaining code to be reused as a
   6  * generic polling mode with semi-reliable transport driver core to the
   7  * console and tty subsystems.
   8  *
   9  *
  10  * Copyright (C) 2001 Anton Blanchard <[email protected]>, IBM
  11  * Copyright (C) 2001 Paul Mackerras <[email protected]>, IBM
  12  * Copyright (C) 2004 Benjamin Herrenschmidt <[email protected]>, IBM Corp.
  13  * Copyright (C) 2004 IBM Corporation
  14  *
  15  * Additional Author(s):
  16  *  Ryan S. Arnold <[email protected]>
  17  *
  18  * TODO:
  19  *
  20  *   - handle error in sending hvsi protocol packets
  21  *   - retry nego on subsequent sends ?
  22  */
  23
  24 #undef DEBUG
  25
  26 #include <linux/types.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/slab.h>
  30 #include <linux/console.h>
  31
  32 #include <asm/hvconsole.h>
  33 #include <asm/vio.h>
  34 #include <asm/prom.h>
  35 #include <asm/hvsi.h>
  36 #include <asm/udbg.h>
  37 #include <asm/machdep.h>
  38
  39 #include "hvc_console.h"
  40
  41 static const char hvc_driver_name[] = "hvc_console";
  42
  43 static const struct vio_device_id hvc_driver_table[] = {
  44         {"serial", "hvterm1"},
  45 #ifndef HVC_OLD_HVSI
  46         {"serial", "hvterm-protocol"},
  47 #endif
  48         { "", "" }
  49 };
  50
  51 typedef enum hv_protocol {
  52         HV_PROTOCOL_RAW,
  53         HV_PROTOCOL_HVSI
  54 } hv_protocol_t;
  55
  56 struct hvterm_priv {
  57         u32                     termno; /* HV term number */
  58         hv_protocol_t           proto;  /* Raw data or HVSI packets */
  59         struct hvsi_priv        hvsi;   /* HVSI specific data */
  60         spinlock_t              buf_lock;
  61         char                    buf[SIZE_VIO_GET_CHARS];
  62         int                     left;
  63         int                     offset;
  64 };
  65 static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
  66 /* For early boot console */
  67 static struct hvterm_priv hvterm_priv0;
  68
  69 static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
  70 {
  71         struct hvterm_priv *pv = hvterm_privs[vtermno];
  72         unsigned long i;
  73         unsigned long flags;
  74         int got;
  75
  76         if (WARN_ON(!pv))
  77                 return 0;
  78
  79         spin_lock_irqsave(&pv->buf_lock, flags);
  80
  81         if (pv->left == 0) {
  82                 pv->offset = 0;
  83                 pv->left = hvc_get_chars(pv->termno, pv->buf, count);
  84
  85                 /*
  86                  * Work around a HV bug where it gives us a null
  87                  * after every \r.  -- paulus
  88                  */
  89                 for (i = 1; i < pv->left; ++i) {
  90                         if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
  91                                 --pv->left;
  92                                 if (i < pv->left) {
  93                                         memmove(&pv->buf[i], &pv->buf[i+1],
  94                                                 pv->left - i);
  95                                 }
  96                         }
  97                 }
  98         }
  99
 100         got = min(count, pv->left);
 101         memcpy(buf, &pv->buf[pv->offset], got);
 102         pv->offset += got;
 103         pv->left -= got;
 104
 105         spin_unlock_irqrestore(&pv->buf_lock, flags);
 106
 107         return got;
 108 }
 109
 110 static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
 111 {
 112         struct hvterm_priv *pv = hvterm_privs[vtermno];
 113
 114         if (WARN_ON(!pv))
 115                 return 0;
 116
 117         return hvc_put_chars(pv->termno, buf, count);
 118 }
 119
 120 static const struct hv_ops hvterm_raw_ops = {
 121         .get_chars = hvterm_raw_get_chars,
 122         .put_chars = hvterm_raw_put_chars,
 123         .notifier_add = notifier_add_irq,
 124         .notifier_del = notifier_del_irq,
 125         .notifier_hangup = notifier_hangup_irq,
 126 };
 127
 128 static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
 129 {
 130         struct hvterm_priv *pv = hvterm_privs[vtermno];
 131
 132         if (WARN_ON(!pv))
 133                 return 0;
 134
 135         return hvsilib_get_chars(&pv->hvsi, buf, count);
 136 }
 137
 138 static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
 139 {
 140         struct hvterm_priv *pv = hvterm_privs[vtermno];
 141
 142         if (WARN_ON(!pv))
 143                 return 0;
 144
 145         return hvsilib_put_chars(&pv->hvsi, buf, count);
 146 }
 147
 148 static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
 149 {
 150         struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
 151         int rc;
 152
 153         pr_devel("HVSI@%x: open !\n", pv->termno);
 154
 155         rc = notifier_add_irq(hp, data);
 156         if (rc)
 157                 return rc;
 158
 159         return hvsilib_open(&pv->hvsi, hp);
 160 }
 161
 162 static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
 163 {
 164         struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
 165
 166         pr_devel("HVSI@%x: do close !\n", pv->termno);
 167
 168         hvsilib_close(&pv->hvsi, hp);
 169
 170         notifier_del_irq(hp, data);
 171 }
 172
 173 void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
 174 {
 175         struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
 176
 177         pr_devel("HVSI@%x: do hangup !\n", pv->termno);
 178
 179         hvsilib_close(&pv->hvsi, hp);
 180
 181         notifier_hangup_irq(hp, data);
 182 }
 183
 184 static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
 185 {
 186         struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
 187
 188         if (!pv)
 189                 return -EINVAL;
 190         return pv->hvsi.mctrl;
 191 }
 192
 193 static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
 194                                 unsigned int clear)
 195 {
 196         struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
 197
 198         pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
 199                  pv->termno, set, clear);
 200
 201         if (set & TIOCM_DTR)
 202                 hvsilib_write_mctrl(&pv->hvsi, 1);
 203         else if (clear & TIOCM_DTR)
 204                 hvsilib_write_mctrl(&pv->hvsi, 0);
 205
 206         return 0;
 207 }
 208
 209 static const struct hv_ops hvterm_hvsi_ops = {
 210         .get_chars = hvterm_hvsi_get_chars,
 211         .put_chars = hvterm_hvsi_put_chars,
 212         .notifier_add = hvterm_hvsi_open,
 213         .notifier_del = hvterm_hvsi_close,
 214         .notifier_hangup = hvterm_hvsi_hangup,
 215         .tiocmget = hvterm_hvsi_tiocmget,
 216         .tiocmset = hvterm_hvsi_tiocmset,
 217 };
 218
 219 static void udbg_hvc_putc(char c)
 220 {
 221         int count = -1;
 222
 223         if (!hvterm_privs[0])
 224                 return;
 225
 226         if (c == '\n')
 227                 udbg_hvc_putc('\r');
 228
 229         do {
 230                 switch(hvterm_privs[0]->proto) {
 231                 case HV_PROTOCOL_RAW:
 232                         count = hvterm_raw_put_chars(0, &c, 1);
 233                         break;
 234                 case HV_PROTOCOL_HVSI:
 235                         count = hvterm_hvsi_put_chars(0, &c, 1);
 236                         break;
 237                 }
 238         } while(count == 0);
 239 }
 240
 241 static int udbg_hvc_getc_poll(void)
 242 {
 243         int rc = 0;
 244         char c;
 245
 246         if (!hvterm_privs[0])
 247                 return -1;
 248
 249         switch(hvterm_privs[0]->proto) {
 250         case HV_PROTOCOL_RAW:
 251                 rc = hvterm_raw_get_chars(0, &c, 1);
 252                 break;
 253         case HV_PROTOCOL_HVSI:
 254                 rc = hvterm_hvsi_get_chars(0, &c, 1);
 255                 break;
 256         }
 257         if (!rc)
 258                 return -1;
 259         return c;
 260 }
 261
 262 static int udbg_hvc_getc(void)
 263 {
 264         int ch;
 265
 266         if (!hvterm_privs[0])
 267                 return -1;
 268
 269         for (;;) {
 270                 ch = udbg_hvc_getc_poll();
 271                 if (ch == -1) {
 272                         /* This shouldn't be needed...but... */
 273                         volatile unsigned long delay;
 274                         for (delay=0; delay < 2000000; delay++)
 275                                 ;
 276                 } else {
 277                         return ch;
 278                 }
 279         }
 280 }
 281
 282 static int hvc_vio_probe(struct vio_dev *vdev,
 283                                    const struct vio_device_id *id)
 284 {
 285         const struct hv_ops *ops;
 286         struct hvc_struct *hp;
 287         struct hvterm_priv *pv;
 288         hv_protocol_t proto;
 289         int i, termno = -1;
 290
 291         /* probed with invalid parameters. */
 292         if (!vdev || !id)
 293                 return -EPERM;
 294
 295         if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
 296                 proto = HV_PROTOCOL_RAW;
 297                 ops = &hvterm_raw_ops;
 298         } else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
 299                 proto = HV_PROTOCOL_HVSI;
 300                 ops = &hvterm_hvsi_ops;
 301         } else {
 302                 pr_err("hvc_vio: Unknown protocol for %pOF\n", vdev->dev.of_node);
 303                 return -ENXIO;
 304         }
 305
 306         pr_devel("hvc_vio_probe() device %pOF, using %s protocol\n",
 307                  vdev->dev.of_node,
 308                  proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
 309
 310         /* Is it our boot one ? */
 311         if (hvterm_privs[0] == &hvterm_priv0 &&
 312             vdev->unit_address == hvterm_priv0.termno) {
 313                 pv = hvterm_privs[0];
 314                 termno = 0;
 315                 pr_devel("->boot console, using termno 0\n");
 316         }
 317         /* nope, allocate a new one */
 318         else {
 319                 for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
 320                         if (!hvterm_privs[i])
 321                                 termno = i;
 322                 pr_devel("->non-boot console, using termno %d\n", termno);
 323                 if (termno < 0)
 324                         return -ENODEV;
 325                 pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
 326                 if (!pv)
 327                         return -ENOMEM;
 328                 pv->termno = vdev->unit_address;
 329                 pv->proto = proto;
 330                 spin_lock_init(&pv->buf_lock);
 331                 hvterm_privs[termno] = pv;
 332                 hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
 333                              pv->termno, 0);
 334         }
 335
 336         hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
 337         if (IS_ERR(hp))
 338                 return PTR_ERR(hp);
 339         dev_set_drvdata(&vdev->dev, hp);
 340
 341         /* register udbg if it's not there already for console 0 */
 342         if (hp->index == 0 && !udbg_putc) {
 343                 udbg_putc = udbg_hvc_putc;
 344                 udbg_getc = udbg_hvc_getc;
 345                 udbg_getc_poll = udbg_hvc_getc_poll;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static struct vio_driver hvc_vio_driver = {
 352         .id_table       = hvc_driver_table,
 353         .probe          = hvc_vio_probe,
 354         .name           = hvc_driver_name,
 355         .driver = {
 356                 .suppress_bind_attrs    = true,
 357         },
 358 };
 359
 360 static int __init hvc_vio_init(void)
 361 {
 362         int rc;
 363
 364         /* Register as a vio device to receive callbacks */
 365         rc = vio_register_driver(&hvc_vio_driver);
 366
 367         return rc;
 368 }
 369 device_initcall(hvc_vio_init); /* after drivers/tty/hvc/hvc_console.c */
 370
 371 void __init hvc_vio_init_early(void)
 372 {
 373         const __be32 *termno;
 374         const struct hv_ops *ops;
 375
 376         /* find the boot console from /chosen/stdout */
 377         /* Check if it's a virtual terminal */
 378         if (!of_node_name_prefix(of_stdout, "vty"))
 379                 return;
 380         termno = of_get_property(of_stdout, "reg", NULL);
 381         if (termno == NULL)
 382                 return;
 383         hvterm_priv0.termno = of_read_number(termno, 1);
 384         spin_lock_init(&hvterm_priv0.buf_lock);
 385         hvterm_privs[0] = &hvterm_priv0;
 386
 387         /* Check the protocol */
 388         if (of_device_is_compatible(of_stdout, "hvterm1")) {
 389                 hvterm_priv0.proto = HV_PROTOCOL_RAW;
 390                 ops = &hvterm_raw_ops;
 391         }
 392         else if (of_device_is_compatible(of_stdout, "hvterm-protocol")) {
 393                 hvterm_priv0.proto = HV_PROTOCOL_HVSI;
 394                 ops = &hvterm_hvsi_ops;
 395                 hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
 396                              hvterm_priv0.termno, 1);
 397                 /* HVSI, perform the handshake now */
 398                 hvsilib_establish(&hvterm_priv0.hvsi);
 399         } else
 400                 return;
 401         udbg_putc = udbg_hvc_putc;
 402         udbg_getc = udbg_hvc_getc;
 403         udbg_getc_poll = udbg_hvc_getc_poll;
 404 #ifdef HVC_OLD_HVSI
 405         /* When using the old HVSI driver don't register the HVC
 406          * backend for HVSI, only do udbg
 407          */
 408         if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
 409                 return;
 410 #endif
 411         /* Check whether the user has requested a different console. */
 412         if (!strstr(boot_command_line, "console="))
 413                 add_preferred_console("hvc", 0, NULL);
 414         hvc_instantiate(0, 0, ops);
 415 }
 416
 417 /* call this from early_init() for a working debug console on
 418  * vterm capable LPAR machines
 419  */
 420 #ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
 421 void __init udbg_init_debug_lpar(void)
 422 {
 423         /*
 424          * If we're running as a hypervisor then we definitely can't call the
 425          * hypervisor to print debug output (we *are* the hypervisor), so don't
 426          * register if we detect that MSR_HV=1.
 427          */
 428         if (mfmsr() & MSR_HV)
 429                 return;
 430
 431         hvterm_privs[0] = &hvterm_priv0;
 432         hvterm_priv0.termno = 0;
 433         hvterm_priv0.proto = HV_PROTOCOL_RAW;
 434         spin_lock_init(&hvterm_priv0.buf_lock);
 435         udbg_putc = udbg_hvc_putc;
 436         udbg_getc = udbg_hvc_getc;
 437         udbg_getc_poll = udbg_hvc_getc_poll;
 438 }
 439 #endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
 440
 441 #ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
 442 void __init udbg_init_debug_lpar_hvsi(void)
 443 {
 444         /* See comment above in udbg_init_debug_lpar() */
 445         if (mfmsr() & MSR_HV)
 446                 return;
 447
 448         hvterm_privs[0] = &hvterm_priv0;
 449         hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
 450         hvterm_priv0.proto = HV_PROTOCOL_HVSI;
 451         spin_lock_init(&hvterm_priv0.buf_lock);
 452         udbg_putc = udbg_hvc_putc;
 453         udbg_getc = udbg_hvc_getc;
 454         udbg_getc_poll = udbg_hvc_getc_poll;
 455         hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
 456                      hvterm_priv0.termno, 1);
 457         hvsilib_establish(&hvterm_priv0.hvsi);
 458 }
 459 #endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */