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
48static void	comc_probe(struct console *cp);
49static int	comc_init(int arg);
50static void	comc_putchar(int c);
51static int	comc_getchar(void);
52static int	comc_getspeed(void);
53static int	comc_ischar(void);
54static int	comc_parseint(const char *string);
55static uint32_t comc_parse_pcidev(const char *string);
56static int	comc_pcidev_set(struct env_var *ev, int flags,
57		    const void *value);
58static int	comc_pcidev_handle(uint32_t locator);
59static int	comc_port_set(struct env_var *ev, int flags,
60		    const void *value);
61static void	comc_setup(int speed, int port);
62static int	comc_speed_set(struct env_var *ev, int flags,
63		    const void *value);
64
65static int	comc_curspeed;
66static int	comc_port = COMPORT;
67static uint32_t	comc_locator;
68
69struct 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
80static void
81comc_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
138static int
139comc_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
150static void
151comc_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
162static int
163comc_getchar(void)
164{
165	return (comc_ischar() ? inb(comc_port + com_data) : -1);
166}
167
168static int
169comc_ischar(void)
170{
171	return (inb(comc_port + com_lsr) & LSR_RXRDY);
172}
173
174static int
175comc_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
192static int
193comc_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 */
214static uint32_t
215comc_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
257static int
258comc_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
300static int
301comc_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
320static void
321comc_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
362static int
363comc_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
375static int
376comc_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}
398