1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/device.h>
3 #include <linux/kernel.h>
4 #include <linux/module.h>
5 #include <linux/io.h>
6 #include <linux/mcb.h>
7 #include <linux/serial.h>
8 #include <linux/serial_core.h>
9 #include <linux/serial_8250.h>
10 
11 #define MEN_UART_ID_Z025 0x19
12 #define MEN_UART_ID_Z057 0x39
13 #define MEN_UART_ID_Z125 0x7d
14 
15 /*
16  * IP Cores Z025 and Z057 can have up to 4 UART
17  * The UARTs available are stored in a global
18  * register saved in physical address + 0x40
19  * Is saved as follows:
20  *
21  * 7                                                              0
22  * +------+-------+-------+-------+-------+-------+-------+-------+
23  * |UART4 | UART3 | UART2 | UART1 | U4irq | U3irq | U2irq | U1irq |
24  * +------+-------+-------+-------+-------+-------+-------+-------+
25  */
26 #define MEN_UART1_MASK	0x01
27 #define MEN_UART2_MASK	0x02
28 #define MEN_UART3_MASK	0x04
29 #define MEN_UART4_MASK	0x08
30 
31 #define MEN_Z125_UARTS_AVAILABLE	0x01
32 
33 #define MEN_Z025_MAX_UARTS		4
34 #define MEN_UART_MEM_SIZE		0x10
35 #define MEM_UART_REGISTER_SIZE		0x01
36 #define MEN_Z025_REGISTER_OFFSET	0x40
37 
38 #define MEN_UART1_OFFSET	0
39 #define MEN_UART2_OFFSET	(MEN_UART1_OFFSET + MEN_UART_MEM_SIZE)
40 #define MEN_UART3_OFFSET	(MEN_UART2_OFFSET + MEN_UART_MEM_SIZE)
41 #define MEN_UART4_OFFSET	(MEN_UART3_OFFSET + MEN_UART_MEM_SIZE)
42 
43 #define MEN_READ_REGISTER(addr)	readb(addr)
44 
45 #define MAX_PORTS	4
46 
47 struct serial_8250_men_mcb_data {
48 	int num_ports;
49 	int line[MAX_PORTS];
50 	unsigned int offset[MAX_PORTS];
51 };
52 
53 /*
54  * The Z125 16550-compatible UART has no fixed base clock assigned
55  * So, depending on the board we're on, we need to adjust the
56  * parameter in order to really set the correct baudrate, and
57  * do so if possible without user interaction
58  */
59 static u32 men_lookup_uartclk(struct mcb_device *mdev)
60 {
61 	/* use default value if board is not available below */
62 	u32 clkval = 1041666;
63 
64 	dev_info(&mdev->dev, "%s on board %s\n",
65 		dev_name(&mdev->dev),
66 		mdev->bus->name);
67 	if  (strncmp(mdev->bus->name, "F075", 4) == 0)
68 		clkval = 1041666;
69 	else if (strncmp(mdev->bus->name, "F216", 4) == 0)
70 		clkval = 1843200;
71 	else if (strncmp(mdev->bus->name, "F210", 4) == 0)
72 		clkval = 115200;
73 	else if (strstr(mdev->bus->name, "215"))
74 		clkval = 1843200;
75 	else
76 		dev_info(&mdev->dev,
77 			 "board not detected, using default uartclk\n");
78 
79 	clkval = clkval  << 4;
80 
81 	return clkval;
82 }
83 
84 static int read_uarts_available_from_register(struct resource *mem_res,
85 					      u8 *uarts_available)
86 {
87 	void __iomem *mem;
88 	int reg_value;
89 
90 	if (!request_mem_region(mem_res->start + MEN_Z025_REGISTER_OFFSET,
91 				MEM_UART_REGISTER_SIZE,  KBUILD_MODNAME)) {
92 		return -EBUSY;
93 	}
94 
95 	mem = ioremap(mem_res->start + MEN_Z025_REGISTER_OFFSET,
96 		      MEM_UART_REGISTER_SIZE);
97 	if (!mem) {
98 		release_mem_region(mem_res->start + MEN_Z025_REGISTER_OFFSET,
99 				   MEM_UART_REGISTER_SIZE);
100 		return -ENOMEM;
101 	}
102 
103 	reg_value = MEN_READ_REGISTER(mem);
104 
105 	iounmap(mem);
106 
107 	release_mem_region(mem_res->start + MEN_Z025_REGISTER_OFFSET,
108 			   MEM_UART_REGISTER_SIZE);
109 
110 	*uarts_available = reg_value >> 4;
111 
112 	return 0;
113 }
114 
115 static int read_serial_data(struct mcb_device *mdev,
116 			    struct resource *mem_res,
117 			    struct serial_8250_men_mcb_data *serial_data)
118 {
119 	u8 uarts_available;
120 	int count = 0;
121 	int mask;
122 	int res;
123 	int i;
124 
125 	res = read_uarts_available_from_register(mem_res, &uarts_available);
126 	if (res < 0)
127 		return res;
128 
129 	for (i = 0; i < MAX_PORTS; i++) {
130 		mask = 0x1 << i;
131 		switch (uarts_available & mask) {
132 		case MEN_UART1_MASK:
133 			serial_data->offset[count] = MEN_UART1_OFFSET;
134 			count++;
135 			break;
136 		case MEN_UART2_MASK:
137 			serial_data->offset[count] = MEN_UART2_OFFSET;
138 			count++;
139 			break;
140 		case MEN_UART3_MASK:
141 			serial_data->offset[count] = MEN_UART3_OFFSET;
142 			count++;
143 			break;
144 		case MEN_UART4_MASK:
145 			serial_data->offset[count] = MEN_UART4_OFFSET;
146 			count++;
147 			break;
148 		default:
149 			return -EINVAL;
150 		}
151 	}
152 
153 	if (count <= 0 || count > MAX_PORTS) {
154 		dev_err(&mdev->dev, "unexpected number of ports: %u\n",
155 			count);
156 		return -ENODEV;
157 	}
158 
159 	serial_data->num_ports = count;
160 
161 	return 0;
162 }
163 
164 static int init_serial_data(struct mcb_device *mdev,
165 			    struct resource *mem_res,
166 			    struct serial_8250_men_mcb_data *serial_data)
167 {
168 	switch (mdev->id) {
169 	case MEN_UART_ID_Z125:
170 		serial_data->num_ports = 1;
171 		serial_data->offset[0] = 0;
172 		return 0;
173 	case MEN_UART_ID_Z025:
174 	case MEN_UART_ID_Z057:
175 		return read_serial_data(mdev, mem_res, serial_data);
176 	default:
177 		dev_err(&mdev->dev, "no supported device!\n");
178 		return -ENODEV;
179 	}
180 }
181 
182 static int serial_8250_men_mcb_probe(struct mcb_device *mdev,
183 				     const struct mcb_device_id *id)
184 {
185 	struct uart_8250_port uart;
186 	struct serial_8250_men_mcb_data *data;
187 	struct resource *mem;
188 	int i;
189 	int res;
190 
191 	mem = mcb_get_resource(mdev, IORESOURCE_MEM);
192 	if (mem == NULL)
193 		return -ENXIO;
194 
195 	data = devm_kzalloc(&mdev->dev,
196 			    sizeof(struct serial_8250_men_mcb_data),
197 			    GFP_KERNEL);
198 	if (!data)
199 		return -ENOMEM;
200 
201 	res = init_serial_data(mdev, mem, data);
202 	if (res < 0)
203 		return res;
204 
205 	dev_dbg(&mdev->dev, "found a 16z%03u with %u ports\n",
206 		mdev->id, data->num_ports);
207 
208 	mcb_set_drvdata(mdev, data);
209 
210 	for (i = 0; i < data->num_ports; i++) {
211 		memset(&uart, 0, sizeof(struct uart_8250_port));
212 		spin_lock_init(&uart.port.lock);
213 
214 		uart.port.flags = UPF_SKIP_TEST |
215 				  UPF_SHARE_IRQ |
216 				  UPF_BOOT_AUTOCONF |
217 				  UPF_IOREMAP;
218 		uart.port.iotype = UPIO_MEM;
219 		uart.port.uartclk = men_lookup_uartclk(mdev);
220 		uart.port.irq = mcb_get_irq(mdev);
221 		uart.port.mapbase = (unsigned long) mem->start
222 					    + data->offset[i];
223 
224 		/* ok, register the port */
225 		res = serial8250_register_8250_port(&uart);
226 		if (res < 0) {
227 			dev_err(&mdev->dev, "unable to register UART port\n");
228 			return res;
229 		}
230 
231 		data->line[i] = res;
232 		dev_info(&mdev->dev, "found MCB UART: ttyS%d\n", data->line[i]);
233 	}
234 
235 	return 0;
236 }
237 
238 static void serial_8250_men_mcb_remove(struct mcb_device *mdev)
239 {
240 	int i;
241 	struct serial_8250_men_mcb_data *data = mcb_get_drvdata(mdev);
242 
243 	if (!data)
244 		return;
245 
246 	for (i = 0; i < data->num_ports; i++)
247 		serial8250_unregister_port(data->line[i]);
248 }
249 
250 static const struct mcb_device_id serial_8250_men_mcb_ids[] = {
251 	{ .device = MEN_UART_ID_Z025 },
252 	{ .device = MEN_UART_ID_Z057 },
253 	{ .device = MEN_UART_ID_Z125 },
254 	{ }
255 };
256 MODULE_DEVICE_TABLE(mcb, serial_8250_men_mcb_ids);
257 
258 static struct mcb_driver mcb_driver = {
259 	.driver = {
260 		.name = "8250_men_mcb",
261 	},
262 	.probe = serial_8250_men_mcb_probe,
263 	.remove = serial_8250_men_mcb_remove,
264 	.id_table = serial_8250_men_mcb_ids,
265 };
266 module_mcb_driver(mcb_driver);
267 
268 MODULE_LICENSE("GPL v2");
269 MODULE_DESCRIPTION("MEN 8250 UART driver");
270 MODULE_AUTHOR("Michael Moese <michael.moese@men.de");
271 MODULE_ALIAS("mcb:16z125");
272 MODULE_ALIAS("mcb:16z025");
273 MODULE_ALIAS("mcb:16z057");
274 MODULE_IMPORT_NS(MCB);
275