stand/i386/libi386/comconsole.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith (msmith@freebsd.org)
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <stand.h>
  30 #include <bootstrap.h>
  31 #include <machine/cpufunc.h>
  32 #include <dev/ic/ns16550.h>
  33 #include <dev/pci/pcireg.h>
  34 #include "libi386.h"
  35
  36 #define COMC_FMT        0x3             /* 8N1 */
  37 #define COMC_TXWAIT     0x40000         /* transmit timeout */
  38 #define COMC_BPS(x)     (115200 / (x))  /* speed to DLAB divisor */
  39 #define COMC_DIV2BPS(x) (115200 / (x))  /* DLAB divisor to speed */
  40
  41 #ifndef COMPORT
  42 #define COMPORT         0x3f8
  43 #endif
  44 #ifndef COMSPEED
  45 #define COMSPEED        9600
  46 #endif
  47
  48 static void     comc_probe(struct console *cp);
  49 static int      comc_init(int arg);
  50 static void     comc_putchar(int c);
  51 static int      comc_getchar(void);
  52 static int      comc_getspeed(void);
  53 static int      comc_ischar(void);
  54 static int      comc_parseint(const char *string);
  55 static uint32_t comc_parse_pcidev(const char *string);
  56 static int      comc_pcidev_set(struct env_var *ev, int flags,
  57                     const void *value);
  58 static int      comc_pcidev_handle(uint32_t locator);
  59 static int      comc_port_set(struct env_var *ev, int flags,
  60                     const void *value);
  61 static void     comc_setup(int speed, int port);
  62 static int      comc_speed_set(struct env_var *ev, int flags,
  63                     const void *value);
  64
  65 static int      comc_curspeed;
  66 static int      comc_port = COMPORT;
  67 static uint32_t comc_locator;
  68
  69 struct console comconsole = {
  70         .c_name = "comconsole",
  71         .c_desc = "serial port",
  72         .c_flags = 0,
  73         .c_probe = comc_probe,
  74         .c_init = comc_init,
  75         .c_out = comc_putchar,
  76         .c_in = comc_getchar,
  77         .c_ready = comc_ischar
  78 };
  79
  80 static void
  81 comc_probe(struct console *cp)
  82 {
  83         char intbuf[16];
  84         char *cons, *env;
  85         int speed, port;
  86         uint32_t locator;
  87
  88         if (comc_curspeed == 0) {
  89                 comc_curspeed = COMSPEED;
  90                 /*
  91                  * Assume that the speed was set by an earlier boot loader if
  92                  * comconsole is already the preferred console.
  93                  */
  94                 cons = getenv("console");
  95                 if ((cons != NULL && strcmp(cons, comconsole.c_name) == 0) ||
  96                     getenv("boot_multicons") != NULL) {
  97                         comc_curspeed = comc_getspeed();
  98                 }
  99
 100                 env = getenv("comconsole_speed");
 101                 if (env != NULL) {
 102                         speed = comc_parseint(env);
 103                         if (speed > 0)
 104                                 comc_curspeed = speed;
 105                 }
 106
 107                 sprintf(intbuf, "%d", comc_curspeed);
 108                 unsetenv("comconsole_speed");
 109                 env_setenv("comconsole_speed", EV_VOLATILE, intbuf,
 110                     comc_speed_set, env_nounset);
 111
 112                 env = getenv("comconsole_port");
 113                 if (env != NULL) {
 114                         port = comc_parseint(env);
 115                         if (port > 0)
 116                                 comc_port = port;
 117                 }
 118
 119                 sprintf(intbuf, "%d", comc_port);
 120                 unsetenv("comconsole_port");
 121                 env_setenv("comconsole_port", EV_VOLATILE, intbuf,
 122                     comc_port_set, env_nounset);
 123
 124                 env = getenv("comconsole_pcidev");
 125                 if (env != NULL) {
 126                         locator = comc_parse_pcidev(env);
 127                         if (locator != 0)
 128                                 comc_pcidev_handle(locator);
 129                 }
 130
 131                 unsetenv("comconsole_pcidev");
 132                 env_setenv("comconsole_pcidev", EV_VOLATILE, env,
 133                     comc_pcidev_set, env_nounset);
 134         }
 135         comc_setup(comc_curspeed, comc_port);
 136 }
 137
 138 static int
 139 comc_init(int arg)
 140 {
 141
 142         comc_setup(comc_curspeed, comc_port);
 143
 144         if ((comconsole.c_flags & (C_PRESENTIN | C_PRESENTOUT)) ==
 145             (C_PRESENTIN | C_PRESENTOUT))
 146                 return (CMD_OK);
 147         return (CMD_ERROR);
 148 }
 149
 150 static void
 151 comc_putchar(int c)
 152 {
 153         int wait;
 154
 155         for (wait = COMC_TXWAIT; wait > 0; wait--)
 156                 if (inb(comc_port + com_lsr) & LSR_TXRDY) {
 157                         outb(comc_port + com_data, (u_char)c);
 158                         break;
 159                 }
 160 }
 161
 162 static int
 163 comc_getchar(void)
 164 {
 165         return (comc_ischar() ? inb(comc_port + com_data) : -1);
 166 }
 167
 168 static int
 169 comc_ischar(void)
 170 {
 171         return (inb(comc_port + com_lsr) & LSR_RXRDY);
 172 }
 173
 174 static int
 175 comc_speed_set(struct env_var *ev, int flags, const void *value)
 176 {
 177         int speed;
 178
 179         if (value == NULL || (speed = comc_parseint(value)) <= 0) {
 180                 printf("Invalid speed\n");
 181                 return (CMD_ERROR);
 182         }
 183
 184         if (comc_curspeed != speed)
 185                 comc_setup(speed, comc_port);
 186
 187         env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
 188
 189         return (CMD_OK);
 190 }
 191
 192 static int
 193 comc_port_set(struct env_var *ev, int flags, const void *value)
 194 {
 195         int port;
 196
 197         if (value == NULL || (port = comc_parseint(value)) <= 0) {
 198                 printf("Invalid port\n");
 199                 return (CMD_ERROR);
 200         }
 201
 202         if (comc_port != port)
 203                 comc_setup(comc_curspeed, port);
 204
 205         env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
 206
 207         return (CMD_OK);
 208 }
 209
 210 /*
 211  * Input: bus:dev:func[:bar]. If bar is not specified, it is 0x10.
 212  * Output: bar[24:16] bus[15:8] dev[7:3] func[2:0]
 213  */
 214 static uint32_t
 215 comc_parse_pcidev(const char *string)
 216 {
 217 #ifdef EFI
 218         /* We don't support PCI in EFI yet */
 219         return (0);
 220 #else
 221         char *p, *p1;
 222         uint8_t bus, dev, func, bar;
 223         uint32_t locator;
 224         int pres;
 225
 226         pres = strtol(string, &p, 0);
 227         if (p == string || *p != ':' || pres < 0 )
 228                 return (0);
 229         bus = pres;
 230         p1 = ++p;
 231
 232         pres = strtol(p1, &p, 0);
 233         if (p == string || *p != ':' || pres < 0 )
 234                 return (0);
 235         dev = pres;
 236         p1 = ++p;
 237
 238         pres = strtol(p1, &p, 0);
 239         if (p == string || (*p != ':' && *p != '\0') || pres < 0 )
 240                 return (0);
 241         func = pres;
 242
 243         if (*p == ':') {
 244                 p1 = ++p;
 245                 pres = strtol(p1, &p, 0);
 246                 if (p == string || *p != '\0' || pres <= 0 )
 247                         return (0);
 248                 bar = pres;
 249         } else
 250                 bar = 0x10;
 251
 252         locator = (bar << 16) | biospci_locator(bus, dev, func);
 253         return (locator);
 254 #endif
 255 }
 256
 257 static int
 258 comc_pcidev_handle(uint32_t locator)
 259 {
 260 #ifdef EFI
 261         /* We don't support PCI in EFI yet */
 262         return (CMD_ERROR);
 263 #else
 264         char intbuf[64];
 265         uint32_t port;
 266
 267         if (biospci_read_config(locator & 0xffff,
 268             (locator & 0xff0000) >> 16, BIOSPCI_32BITS, &port) == -1) {
 269                 printf("Cannot read bar at 0x%x\n", locator);
 270                 return (CMD_ERROR);
 271         }
 272
 273         /*
 274          * biospci_read_config() sets port == 0xffffffff if the pcidev
 275          * isn't found on the bus.  Check for 0xffffffff and return to not
 276          * panic in BTX.
 277          */
 278         if (port == 0xffffffff) {
 279                 printf("Cannot find specified pcidev\n");
 280                 return (CMD_ERROR);
 281         }
 282         if (!PCI_BAR_IO(port)) {
 283                 printf("Memory bar at 0x%x\n", locator);
 284                 return (CMD_ERROR);
 285         }
 286         port &= PCIM_BAR_IO_BASE;
 287
 288         sprintf(intbuf, "%d", port);
 289         unsetenv("comconsole_port");
 290         env_setenv("comconsole_port", EV_VOLATILE, intbuf,
 291                    comc_port_set, env_nounset);
 292
 293         comc_setup(comc_curspeed, port);
 294         comc_locator = locator;
 295
 296         return (CMD_OK);
 297 #endif
 298 }
 299
 300 static int
 301 comc_pcidev_set(struct env_var *ev, int flags, const void *value)
 302 {
 303         uint32_t locator;
 304         int error;
 305
 306         if (value == NULL || (locator = comc_parse_pcidev(value)) <= 0) {
 307                 printf("Invalid pcidev\n");
 308                 return (CMD_ERROR);
 309         }
 310         if ((comconsole.c_flags & (C_ACTIVEIN | C_ACTIVEOUT)) != 0 &&
 311             comc_locator != locator) {
 312                 error = comc_pcidev_handle(locator);
 313                 if (error != CMD_OK)
 314                         return (error);
 315         }
 316         env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
 317         return (CMD_OK);
 318 }
 319
 320 static void
 321 comc_setup(int speed, int port)
 322 {
 323         static int TRY_COUNT = 1000000;
 324         char intbuf[64];
 325         int tries;
 326
 327         unsetenv("hw.uart.console");
 328         comc_curspeed = speed;
 329         comc_port = port;
 330         if ((comconsole.c_flags & (C_ACTIVEIN | C_ACTIVEOUT)) == 0)
 331                 return;
 332
 333 #define COMC_TEST       0xbb
 334         /*
 335          * Write byte to scratch register and read it out.
 336          */
 337         outb(comc_port + com_scr, COMC_TEST);
 338         if (inb(comc_port + com_scr) != COMC_TEST) {
 339                 comconsole.c_flags &= ~(C_PRESENTIN | C_PRESENTOUT);
 340                 return;
 341         }
 342
 343         outb(comc_port + com_cfcr, CFCR_DLAB | COMC_FMT);
 344         outb(comc_port + com_dlbl, COMC_BPS(speed) & 0xff);
 345         outb(comc_port + com_dlbh, COMC_BPS(speed) >> 8);
 346         outb(comc_port + com_cfcr, COMC_FMT);
 347         outb(comc_port + com_mcr, MCR_RTS | MCR_DTR);
 348
 349         tries = 0;
 350         do
 351                 inb(comc_port + com_data);
 352         while (inb(comc_port + com_lsr) & LSR_RXRDY && ++tries < TRY_COUNT);
 353
 354         if (tries < TRY_COUNT) {
 355                 comconsole.c_flags |= (C_PRESENTIN | C_PRESENTOUT);
 356                 sprintf(intbuf, "io:%d,br:%d", comc_port, comc_curspeed);
 357                 env_setenv("hw.uart.console", EV_VOLATILE, intbuf, NULL, NULL);
 358         } else
 359                 comconsole.c_flags &= ~(C_PRESENTIN | C_PRESENTOUT);
 360 }
 361
 362 static int
 363 comc_parseint(const char *speedstr)
 364 {
 365         char *p;
 366         int speed;
 367
 368         speed = strtol(speedstr, &p, 0);
 369         if (p == speedstr || *p != '\0' || speed <= 0)
 370                 return (-1);
 371
 372         return (speed);
 373 }
 374
 375 static int
 376 comc_getspeed(void)
 377 {
 378         u_int   divisor;
 379         u_char  dlbh;
 380         u_char  dlbl;
 381         u_char  cfcr;
 382
 383         cfcr = inb(comc_port + com_cfcr);
 384         outb(comc_port + com_cfcr, CFCR_DLAB | cfcr);
 385
 386         dlbl = inb(comc_port + com_dlbl);
 387         dlbh = inb(comc_port + com_dlbh);
 388
 389         outb(comc_port + com_cfcr, cfcr);
 390
 391         divisor = dlbh << 8 | dlbl;
 392
 393         /* XXX there should be more sanity checking. */
 394         if (divisor == 0)
 395                 return (COMSPEED);
 396         return (COMC_DIV2BPS(divisor));
 397 }