fbd68c4b4c
compilation of kernels without ns8250 support but using the uart framework. These kernels will be for machines where size matters more, so including code that can never be executed is undesriable...
269 lines
6.3 KiB
C
269 lines
6.3 KiB
C
/*-
|
|
* Copyright (c) 2004 Marcel Moolenaar
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/bus.h>
|
|
|
|
#include <machine/bus.h>
|
|
#include <machine/vmparam.h>
|
|
|
|
#include <dev/uart/uart.h>
|
|
#include <dev/uart/uart_cpu.h>
|
|
|
|
#define UART_TAG_BR 0
|
|
#define UART_TAG_CH 1
|
|
#define UART_TAG_DB 2
|
|
#define UART_TAG_DT 3
|
|
#define UART_TAG_IO 4
|
|
#define UART_TAG_MM 5
|
|
#define UART_TAG_PA 6
|
|
#define UART_TAG_RS 7
|
|
#define UART_TAG_SB 8
|
|
#define UART_TAG_XO 9
|
|
|
|
static bus_addr_t
|
|
uart_parse_addr(__const char **p)
|
|
{
|
|
return (strtoul(*p, (char**)(uintptr_t)p, 0));
|
|
}
|
|
|
|
static long
|
|
uart_parse_long(__const char **p)
|
|
{
|
|
return (strtol(*p, (char**)(uintptr_t)p, 0));
|
|
}
|
|
|
|
static int
|
|
uart_parse_parity(__const char **p)
|
|
{
|
|
if (!strncmp(*p, "even", 4)) {
|
|
*p += 4;
|
|
return UART_PARITY_EVEN;
|
|
}
|
|
if (!strncmp(*p, "mark", 4)) {
|
|
*p += 4;
|
|
return UART_PARITY_MARK;
|
|
}
|
|
if (!strncmp(*p, "none", 4)) {
|
|
*p += 4;
|
|
return UART_PARITY_NONE;
|
|
}
|
|
if (!strncmp(*p, "odd", 3)) {
|
|
*p += 3;
|
|
return UART_PARITY_ODD;
|
|
}
|
|
if (!strncmp(*p, "space", 5)) {
|
|
*p += 5;
|
|
return UART_PARITY_SPACE;
|
|
}
|
|
return (-1);
|
|
}
|
|
|
|
static int
|
|
uart_parse_tag(__const char **p)
|
|
{
|
|
int tag;
|
|
|
|
if ((*p)[0] == 'b' && (*p)[1] == 'r') {
|
|
tag = UART_TAG_BR;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'c' && (*p)[1] == 'h') {
|
|
tag = UART_TAG_CH;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'd' && (*p)[1] == 'b') {
|
|
tag = UART_TAG_DB;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'd' && (*p)[1] == 't') {
|
|
tag = UART_TAG_DT;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'i' && (*p)[1] == 'o') {
|
|
tag = UART_TAG_IO;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'm' && (*p)[1] == 'm') {
|
|
tag = UART_TAG_MM;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'p' && (*p)[1] == 'a') {
|
|
tag = UART_TAG_PA;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'r' && (*p)[1] == 's') {
|
|
tag = UART_TAG_RS;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 's' && (*p)[1] == 'b') {
|
|
tag = UART_TAG_SB;
|
|
goto out;
|
|
}
|
|
if ((*p)[0] == 'x' && (*p)[1] == 'o') {
|
|
tag = UART_TAG_XO;
|
|
goto out;
|
|
}
|
|
return (-1);
|
|
|
|
out:
|
|
*p += 2;
|
|
if ((*p)[0] != ':')
|
|
return (-1);
|
|
(*p)++;
|
|
return (tag);
|
|
}
|
|
|
|
/*
|
|
* Parse a device specification. The specification is a list of attributes
|
|
* seperated by commas. Each attribute is a tag-value pair with the tag and
|
|
* value seperated by a colon. Supported tags are:
|
|
*
|
|
* br = Baudrate
|
|
* ch = Channel
|
|
* db = Data bits
|
|
* dt = Device type
|
|
* io = I/O port address
|
|
* mm = Memory mapped I/O address
|
|
* pa = Parity
|
|
* rs = Register shift
|
|
* sb = Stopbits
|
|
* xo = Device clock (xtal oscillator)
|
|
*
|
|
* The io and mm tags are mutually exclusive.
|
|
*/
|
|
|
|
int
|
|
uart_getenv(int devtype, struct uart_devinfo *di)
|
|
{
|
|
__const char *spec;
|
|
bus_addr_t addr = ~0U;
|
|
|
|
/*
|
|
* Check the environment variables "hw.uart.console" and
|
|
* "hw.uart.dbgport". These variables, when present, specify
|
|
* which UART port is to be used as serial console or debug
|
|
* port (resp).
|
|
*/
|
|
if (devtype == UART_DEV_CONSOLE)
|
|
spec = getenv("hw.uart.console");
|
|
else if (devtype == UART_DEV_DBGPORT)
|
|
spec = getenv("hw.uart.dbgport");
|
|
else
|
|
spec = NULL;
|
|
if (spec == NULL)
|
|
return (ENXIO);
|
|
|
|
/* Set defaults. */
|
|
di->bas.chan = 0;
|
|
di->bas.regshft = 0;
|
|
di->bas.rclk = 0;
|
|
di->baudrate = 0;
|
|
di->databits = 8;
|
|
di->stopbits = 1;
|
|
di->parity = UART_PARITY_NONE;
|
|
|
|
/* Parse the attributes. */
|
|
while (1) {
|
|
switch (uart_parse_tag(&spec)) {
|
|
case UART_TAG_BR:
|
|
di->baudrate = uart_parse_long(&spec);
|
|
break;
|
|
case UART_TAG_CH:
|
|
di->bas.chan = uart_parse_long(&spec);
|
|
break;
|
|
case UART_TAG_DB:
|
|
di->databits = uart_parse_long(&spec);
|
|
break;
|
|
case UART_TAG_DT:
|
|
return (EINVAL); /* XXX not yet implemented. */
|
|
break;
|
|
case UART_TAG_IO:
|
|
di->bas.bst = uart_bus_space_io;
|
|
addr = uart_parse_addr(&spec);
|
|
break;
|
|
case UART_TAG_MM:
|
|
di->bas.bst = uart_bus_space_mem;
|
|
addr = uart_parse_addr(&spec);
|
|
break;
|
|
case UART_TAG_PA:
|
|
di->parity = uart_parse_parity(&spec);
|
|
break;
|
|
case UART_TAG_RS:
|
|
di->bas.regshft = uart_parse_long(&spec);
|
|
break;
|
|
case UART_TAG_SB:
|
|
di->stopbits = uart_parse_long(&spec);
|
|
break;
|
|
case UART_TAG_XO:
|
|
di->bas.rclk = uart_parse_long(&spec);
|
|
break;
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
if (*spec == '\0')
|
|
break;
|
|
if (*spec != ',')
|
|
return (EINVAL);
|
|
spec++;
|
|
}
|
|
|
|
/*
|
|
* If we still have an invalid address, the specification must be
|
|
* missing an I/O port or memory address. We don't like that.
|
|
*/
|
|
if (addr == ~0U)
|
|
return (EINVAL);
|
|
|
|
/*
|
|
* Accept only the well-known baudrates. Any invalid baudrate
|
|
* is silently replaced with a 0-valued baudrate. The 0 baudrate
|
|
* has special meaning. It means that we're not supposed to
|
|
* program the baudrate and simply communicate with whatever
|
|
* speed the hardware is currently programmed for.
|
|
*/
|
|
if (di->baudrate >= 19200) {
|
|
if (di->baudrate % 19200)
|
|
di->baudrate = 0;
|
|
} else if (di->baudrate >= 1200) {
|
|
if (di->baudrate % 1200)
|
|
di->baudrate = 0;
|
|
} else if (di->baudrate > 0) {
|
|
if (di->baudrate % 75)
|
|
di->baudrate = 0;
|
|
} else
|
|
di->baudrate = 0;
|
|
|
|
/* XXX the size of the mapping depends on the UART class. */
|
|
if (bus_space_map(di->bas.bst, addr, 8, 0, &di->bas.bsh) != 0)
|
|
return (EINVAL);
|
|
return (0);
|
|
}
|