xref: /openbmc/u-boot/drivers/serial/sandbox.c (revision 8a86152d)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2011 The Chromium OS Authors.
4  */
5 
6 /*
7  * This provide a test serial port. It provides an emulated serial port where
8  * a test program and read out the serial output and inject serial input for
9  * U-Boot.
10  */
11 
12 #include <common.h>
13 #include <console.h>
14 #include <dm.h>
15 #include <fdtdec.h>
16 #include <lcd.h>
17 #include <os.h>
18 #include <serial.h>
19 #include <video.h>
20 #include <linux/compiler.h>
21 #include <asm/state.h>
22 
23 DECLARE_GLOBAL_DATA_PTR;
24 
25 /*
26  *
27  *   serial_buf: A buffer that holds keyboard characters for the
28  *		 Sandbox U-Boot.
29  *
30  * invariants:
31  *   serial_buf_write		 == serial_buf_read -> empty buffer
32  *   (serial_buf_write + 1) % 16 == serial_buf_read -> full buffer
33  */
34 static char serial_buf[16];
35 static unsigned int serial_buf_write;
36 static unsigned int serial_buf_read;
37 
38 struct sandbox_serial_platdata {
39 	int colour;	/* Text colour to use for output, -1 for none */
40 };
41 
42 struct sandbox_serial_priv {
43 	bool start_of_line;
44 };
45 
46 /**
47  * output_ansi_colour() - Output an ANSI colour code
48  *
49  * @colour: Colour to output (0-7)
50  */
51 static void output_ansi_colour(int colour)
52 {
53 	char ansi_code[] = "\x1b[1;3Xm";
54 
55 	ansi_code[5] = '0' + colour;
56 	os_write(1, ansi_code, sizeof(ansi_code) - 1);
57 }
58 
59 static void output_ansi_reset(void)
60 {
61 	os_write(1, "\x1b[0m", 4);
62 }
63 
64 static int sandbox_serial_probe(struct udevice *dev)
65 {
66 	struct sandbox_state *state = state_get_current();
67 	struct sandbox_serial_priv *priv = dev_get_priv(dev);
68 
69 	if (state->term_raw != STATE_TERM_COOKED)
70 		os_tty_raw(0, state->term_raw == STATE_TERM_RAW_WITH_SIGS);
71 	priv->start_of_line = 0;
72 
73 	if (state->term_raw != STATE_TERM_RAW)
74 		disable_ctrlc(1);
75 
76 	return 0;
77 }
78 
79 static int sandbox_serial_remove(struct udevice *dev)
80 {
81 	struct sandbox_serial_platdata *plat = dev->platdata;
82 
83 	if (plat->colour != -1)
84 		output_ansi_reset();
85 
86 	return 0;
87 }
88 
89 static int sandbox_serial_putc(struct udevice *dev, const char ch)
90 {
91 	struct sandbox_serial_priv *priv = dev_get_priv(dev);
92 	struct sandbox_serial_platdata *plat = dev->platdata;
93 
94 	if (priv->start_of_line && plat->colour != -1) {
95 		priv->start_of_line = false;
96 		output_ansi_colour(plat->colour);
97 	}
98 
99 	os_write(1, &ch, 1);
100 	if (ch == '\n')
101 		priv->start_of_line = true;
102 
103 	return 0;
104 }
105 
106 static unsigned int increment_buffer_index(unsigned int index)
107 {
108 	return (index + 1) % ARRAY_SIZE(serial_buf);
109 }
110 
111 static int sandbox_serial_pending(struct udevice *dev, bool input)
112 {
113 	const unsigned int next_index =
114 		increment_buffer_index(serial_buf_write);
115 	ssize_t count;
116 
117 	if (!input)
118 		return 0;
119 
120 	os_usleep(100);
121 #ifndef CONFIG_SPL_BUILD
122 	video_sync_all();
123 #endif
124 	if (next_index == serial_buf_read)
125 		return 1;	/* buffer full */
126 
127 	count = os_read_no_block(0, &serial_buf[serial_buf_write], 1);
128 	if (count == 1)
129 		serial_buf_write = next_index;
130 
131 	return serial_buf_write != serial_buf_read;
132 }
133 
134 static int sandbox_serial_getc(struct udevice *dev)
135 {
136 	int result;
137 
138 	if (!sandbox_serial_pending(dev, true))
139 		return -EAGAIN;	/* buffer empty */
140 
141 	result = serial_buf[serial_buf_read];
142 	serial_buf_read = increment_buffer_index(serial_buf_read);
143 	return result;
144 }
145 
146 static int sandbox_serial_setconfig(struct udevice *dev, uint serial_config)
147 {
148 	u8 parity = SERIAL_GET_PARITY(serial_config);
149 	u8 bits = SERIAL_GET_BITS(serial_config);
150 	u8 stop = SERIAL_GET_STOP(serial_config);
151 
152 	if (bits != SERIAL_8_BITS || stop != SERIAL_ONE_STOP ||
153 	    parity != SERIAL_PAR_NONE)
154 		return -ENOTSUPP; /* not supported in driver*/
155 
156 	return 0;
157 }
158 
159 static const char * const ansi_colour[] = {
160 	"black", "red", "green", "yellow", "blue", "megenta", "cyan",
161 	"white",
162 };
163 
164 static int sandbox_serial_ofdata_to_platdata(struct udevice *dev)
165 {
166 	struct sandbox_serial_platdata *plat = dev->platdata;
167 	const char *colour;
168 	int i;
169 
170 	plat->colour = -1;
171 	colour = fdt_getprop(gd->fdt_blob, dev_of_offset(dev),
172 			     "sandbox,text-colour", NULL);
173 	if (colour) {
174 		for (i = 0; i < ARRAY_SIZE(ansi_colour); i++) {
175 			if (!strcmp(colour, ansi_colour[i])) {
176 				plat->colour = i;
177 				break;
178 			}
179 		}
180 	}
181 
182 	return 0;
183 }
184 
185 static const struct dm_serial_ops sandbox_serial_ops = {
186 	.putc = sandbox_serial_putc,
187 	.pending = sandbox_serial_pending,
188 	.getc = sandbox_serial_getc,
189 	.setconfig = sandbox_serial_setconfig,
190 };
191 
192 static const struct udevice_id sandbox_serial_ids[] = {
193 	{ .compatible = "sandbox,serial" },
194 	{ }
195 };
196 
197 U_BOOT_DRIVER(serial_sandbox) = {
198 	.name	= "serial_sandbox",
199 	.id	= UCLASS_SERIAL,
200 	.of_match = sandbox_serial_ids,
201 	.ofdata_to_platdata = sandbox_serial_ofdata_to_platdata,
202 	.platdata_auto_alloc_size = sizeof(struct sandbox_serial_platdata),
203 	.priv_auto_alloc_size = sizeof(struct sandbox_serial_priv),
204 	.probe = sandbox_serial_probe,
205 	.remove = sandbox_serial_remove,
206 	.ops	= &sandbox_serial_ops,
207 	.flags = DM_FLAG_PRE_RELOC,
208 };
209 
210 static const struct sandbox_serial_platdata platdata_non_fdt = {
211 	.colour = -1,
212 };
213 
214 U_BOOT_DEVICE(serial_sandbox_non_fdt) = {
215 	.name = "serial_sandbox",
216 	.platdata = &platdata_non_fdt,
217 };
218