1 // SPDX-License-Identifier: GPL-2.0+
2 
3 /*
4  * Support for EC-connected GPIOs for identify
5  * LED/button on Barco P50 board
6  *
7  * Copyright (C) 2021 Barco NV
8  * Author: Santosh Kumar Yadav <santoshkumar.yadav@barco.com>
9  */
10 
11 #define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt
12 
13 #include <linux/io.h>
14 #include <linux/delay.h>
15 #include <linux/dmi.h>
16 #include <linux/err.h>
17 #include <linux/io.h>
18 #include <linux/kernel.h>
19 #include <linux/leds.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/gpio_keys.h>
23 #include <linux/gpio/driver.h>
24 #include <linux/gpio/machine.h>
25 #include <linux/input.h>
26 
27 
28 #define DRIVER_NAME		"barco-p50-gpio"
29 
30 /* GPIO lines */
31 #define P50_GPIO_LINE_LED	0
32 #define P50_GPIO_LINE_BTN	1
33 
34 /* GPIO IO Ports */
35 #define P50_GPIO_IO_PORT_BASE	0x299
36 
37 #define P50_PORT_DATA		0x00
38 #define P50_PORT_CMD		0x01
39 
40 #define P50_STATUS_OBF		0x01 /* EC output buffer full */
41 #define P50_STATUS_IBF		0x02 /* EC input buffer full */
42 
43 #define P50_CMD_READ		0xa0
44 #define P50_CMD_WRITE		0x50
45 
46 /* EC mailbox registers */
47 #define P50_MBOX_REG_CMD	0x00
48 #define P50_MBOX_REG_STATUS	0x01
49 #define P50_MBOX_REG_PARAM	0x02
50 #define P50_MBOX_REG_DATA	0x03
51 
52 #define P50_MBOX_CMD_READ_GPIO	0x11
53 #define P50_MBOX_CMD_WRITE_GPIO	0x12
54 #define P50_MBOX_CMD_CLEAR	0xff
55 
56 #define P50_MBOX_STATUS_SUCCESS	0x01
57 
58 #define P50_MBOX_PARAM_LED	0x12
59 #define P50_MBOX_PARAM_BTN	0x13
60 
61 
62 struct p50_gpio {
63 	struct gpio_chip gc;
64 	struct mutex lock;
65 	unsigned long base;
66 	struct platform_device *leds_pdev;
67 	struct platform_device *keys_pdev;
68 };
69 
70 static struct platform_device *gpio_pdev;
71 
72 static int gpio_params[] = {
73 	[P50_GPIO_LINE_LED] = P50_MBOX_PARAM_LED,
74 	[P50_GPIO_LINE_BTN] = P50_MBOX_PARAM_BTN,
75 };
76 
77 static const char * const gpio_names[] = {
78 	[P50_GPIO_LINE_LED] = "identify-led",
79 	[P50_GPIO_LINE_BTN] = "identify-button",
80 };
81 
82 
83 static struct gpiod_lookup_table p50_gpio_led_table = {
84 	.dev_id = "leds-gpio",
85 	.table = {
86 		GPIO_LOOKUP_IDX(DRIVER_NAME, P50_GPIO_LINE_LED, NULL, 0, GPIO_ACTIVE_HIGH),
87 		{}
88 	}
89 };
90 
91 /* GPIO LEDs */
92 static struct gpio_led leds[] = {
93 	{ .name = "identify" }
94 };
95 
96 static struct gpio_led_platform_data leds_pdata = {
97 	.num_leds = ARRAY_SIZE(leds),
98 	.leds = leds,
99 };
100 
101 /* GPIO keyboard */
102 static struct gpio_keys_button buttons[] = {
103 	{
104 		.code = KEY_VENDOR,
105 		.gpio = P50_GPIO_LINE_BTN,
106 		.active_low = 1,
107 		.type = EV_KEY,
108 		.value = 1,
109 	},
110 };
111 
112 static struct gpio_keys_platform_data keys_pdata = {
113 	.buttons = buttons,
114 	.nbuttons = ARRAY_SIZE(buttons),
115 	.poll_interval = 100,
116 	.rep = 0,
117 	.name = "identify",
118 };
119 
120 
121 /* low level access routines */
122 
123 static int p50_wait_ec(struct p50_gpio *p50, int mask, int expected)
124 {
125 	int i, val;
126 
127 	for (i = 0; i < 100; i++) {
128 		val = inb(p50->base + P50_PORT_CMD) & mask;
129 		if (val == expected)
130 			return 0;
131 		usleep_range(500, 2000);
132 	}
133 
134 	dev_err(p50->gc.parent, "Timed out waiting for EC (0x%x)\n", val);
135 	return -ETIMEDOUT;
136 }
137 
138 
139 static int p50_read_mbox_reg(struct p50_gpio *p50, int reg)
140 {
141 	int ret;
142 
143 	ret = p50_wait_ec(p50, P50_STATUS_IBF, 0);
144 	if (ret)
145 		return ret;
146 
147 	/* clear output buffer flag, prevent unfinished commands */
148 	inb(p50->base + P50_PORT_DATA);
149 
150 	/* cmd/address */
151 	outb(P50_CMD_READ | reg, p50->base + P50_PORT_CMD);
152 
153 	ret = p50_wait_ec(p50, P50_STATUS_OBF, P50_STATUS_OBF);
154 	if (ret)
155 		return ret;
156 
157 	return inb(p50->base + P50_PORT_DATA);
158 }
159 
160 static int p50_write_mbox_reg(struct p50_gpio *p50, int reg, int val)
161 {
162 	int ret;
163 
164 	ret = p50_wait_ec(p50, P50_STATUS_IBF, 0);
165 	if (ret)
166 		return ret;
167 
168 	/* cmd/address */
169 	outb(P50_CMD_WRITE | reg, p50->base + P50_PORT_CMD);
170 
171 	ret = p50_wait_ec(p50, P50_STATUS_IBF, 0);
172 	if (ret)
173 		return ret;
174 
175 	/* data */
176 	outb(val, p50->base + P50_PORT_DATA);
177 
178 	return 0;
179 }
180 
181 
182 /* mbox routines */
183 
184 static int p50_wait_mbox_idle(struct p50_gpio *p50)
185 {
186 	int i, val;
187 
188 	for (i = 0; i < 1000; i++) {
189 		val = p50_read_mbox_reg(p50, P50_MBOX_REG_CMD);
190 		/* cmd is 0 when idle */
191 		if (val <= 0)
192 			return val;
193 
194 		usleep_range(500, 2000);
195 	}
196 
197 	dev_err(p50->gc.parent,	"Timed out waiting for EC mbox idle (CMD: 0x%x)\n", val);
198 
199 	return -ETIMEDOUT;
200 }
201 
202 static int p50_send_mbox_cmd(struct p50_gpio *p50, int cmd, int param, int data)
203 {
204 	int ret;
205 
206 	ret = p50_wait_mbox_idle(p50);
207 	if (ret)
208 		return ret;
209 
210 	ret = p50_write_mbox_reg(p50, P50_MBOX_REG_DATA, data);
211 	if (ret)
212 		return ret;
213 
214 	ret = p50_write_mbox_reg(p50, P50_MBOX_REG_PARAM, param);
215 	if (ret)
216 		return ret;
217 
218 	ret = p50_write_mbox_reg(p50, P50_MBOX_REG_CMD, cmd);
219 	if (ret)
220 		return ret;
221 
222 	ret = p50_wait_mbox_idle(p50);
223 	if (ret)
224 		return ret;
225 
226 	ret = p50_read_mbox_reg(p50, P50_MBOX_REG_STATUS);
227 	if (ret < 0)
228 		return ret;
229 
230 	if (ret == P50_MBOX_STATUS_SUCCESS)
231 		return 0;
232 
233 	dev_err(p50->gc.parent,	"Mbox command failed (CMD=0x%x STAT=0x%x PARAM=0x%x DATA=0x%x)\n",
234 		cmd, ret, param, data);
235 
236 	return -EIO;
237 }
238 
239 
240 /* gpio routines */
241 
242 static int p50_gpio_get_direction(struct gpio_chip *gc, unsigned int offset)
243 {
244 	switch (offset) {
245 	case P50_GPIO_LINE_BTN:
246 		return GPIO_LINE_DIRECTION_IN;
247 
248 	case P50_GPIO_LINE_LED:
249 		return GPIO_LINE_DIRECTION_OUT;
250 
251 	default:
252 		return -EINVAL;
253 	}
254 }
255 
256 static int p50_gpio_get(struct gpio_chip *gc, unsigned int offset)
257 {
258 	struct p50_gpio *p50 = gpiochip_get_data(gc);
259 	int ret;
260 
261 	mutex_lock(&p50->lock);
262 
263 	ret = p50_send_mbox_cmd(p50, P50_MBOX_CMD_READ_GPIO, gpio_params[offset], 0);
264 	if (ret == 0)
265 		ret = p50_read_mbox_reg(p50, P50_MBOX_REG_DATA);
266 
267 	mutex_unlock(&p50->lock);
268 
269 	return ret;
270 }
271 
272 static void p50_gpio_set(struct gpio_chip *gc, unsigned int offset, int value)
273 {
274 	struct p50_gpio *p50 = gpiochip_get_data(gc);
275 
276 	mutex_lock(&p50->lock);
277 
278 	p50_send_mbox_cmd(p50, P50_MBOX_CMD_WRITE_GPIO, gpio_params[offset], value);
279 
280 	mutex_unlock(&p50->lock);
281 }
282 
283 static int p50_gpio_probe(struct platform_device *pdev)
284 {
285 	struct p50_gpio *p50;
286 	struct resource *res;
287 	int ret;
288 
289 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
290 	if (!res) {
291 		dev_err(&pdev->dev, "Cannot get I/O ports\n");
292 		return -ENODEV;
293 	}
294 
295 	if (!devm_request_region(&pdev->dev, res->start, resource_size(res), pdev->name)) {
296 		dev_err(&pdev->dev, "Unable to reserve I/O region\n");
297 		return -EBUSY;
298 	}
299 
300 	p50 = devm_kzalloc(&pdev->dev, sizeof(*p50), GFP_KERNEL);
301 	if (!p50)
302 		return -ENOMEM;
303 
304 	platform_set_drvdata(pdev, p50);
305 	mutex_init(&p50->lock);
306 	p50->base = res->start;
307 	p50->gc.owner = THIS_MODULE;
308 	p50->gc.parent = &pdev->dev;
309 	p50->gc.label = dev_name(&pdev->dev);
310 	p50->gc.ngpio = ARRAY_SIZE(gpio_names);
311 	p50->gc.names = gpio_names;
312 	p50->gc.can_sleep = true;
313 	p50->gc.base = -1;
314 	p50->gc.get_direction = p50_gpio_get_direction;
315 	p50->gc.get = p50_gpio_get;
316 	p50->gc.set = p50_gpio_set;
317 
318 
319 	/* reset mbox */
320 	ret = p50_wait_mbox_idle(p50);
321 	if (ret)
322 		return ret;
323 
324 	ret = p50_write_mbox_reg(p50, P50_MBOX_REG_CMD, P50_MBOX_CMD_CLEAR);
325 	if (ret)
326 		return ret;
327 
328 	ret = p50_wait_mbox_idle(p50);
329 	if (ret)
330 		return ret;
331 
332 
333 	ret = devm_gpiochip_add_data(&pdev->dev, &p50->gc, p50);
334 	if (ret < 0) {
335 		dev_err(&pdev->dev, "Could not register gpiochip: %d\n", ret);
336 		return ret;
337 	}
338 
339 	gpiod_add_lookup_table(&p50_gpio_led_table);
340 
341 	p50->leds_pdev = platform_device_register_data(&pdev->dev,
342 		"leds-gpio", PLATFORM_DEVID_NONE, &leds_pdata, sizeof(leds_pdata));
343 
344 	if (IS_ERR(p50->leds_pdev)) {
345 		ret = PTR_ERR(p50->leds_pdev);
346 		dev_err(&pdev->dev, "Could not register leds-gpio: %d\n", ret);
347 		goto err_leds;
348 	}
349 
350 	/* gpio-keys-polled uses old-style gpio interface, pass the right identifier */
351 	buttons[0].gpio += p50->gc.base;
352 
353 	p50->keys_pdev =
354 		platform_device_register_data(&pdev->dev, "gpio-keys-polled",
355 					      PLATFORM_DEVID_NONE,
356 					      &keys_pdata, sizeof(keys_pdata));
357 
358 	if (IS_ERR(p50->keys_pdev)) {
359 		ret = PTR_ERR(p50->keys_pdev);
360 		dev_err(&pdev->dev, "Could not register gpio-keys-polled: %d\n", ret);
361 		goto err_keys;
362 	}
363 
364 	return 0;
365 
366 err_keys:
367 	platform_device_unregister(p50->leds_pdev);
368 err_leds:
369 	gpiod_remove_lookup_table(&p50_gpio_led_table);
370 
371 	return ret;
372 }
373 
374 static int p50_gpio_remove(struct platform_device *pdev)
375 {
376 	struct p50_gpio *p50 = platform_get_drvdata(pdev);
377 
378 	platform_device_unregister(p50->keys_pdev);
379 	platform_device_unregister(p50->leds_pdev);
380 
381 	gpiod_remove_lookup_table(&p50_gpio_led_table);
382 
383 	return 0;
384 }
385 
386 static struct platform_driver p50_gpio_driver = {
387 	.driver = {
388 		.name = DRIVER_NAME,
389 	},
390 	.probe = p50_gpio_probe,
391 	.remove = p50_gpio_remove,
392 };
393 
394 /* Board setup */
395 static const struct dmi_system_id dmi_ids[] __initconst = {
396 	{
397 		.matches = {
398 			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Barco"),
399 			DMI_EXACT_MATCH(DMI_PRODUCT_FAMILY, "P50")
400 		},
401 	},
402 	{}
403 };
404 MODULE_DEVICE_TABLE(dmi, dmi_ids);
405 
406 static int __init p50_module_init(void)
407 {
408 	struct resource res = DEFINE_RES_IO(P50_GPIO_IO_PORT_BASE, P50_PORT_CMD + 1);
409 
410 	if (!dmi_first_match(dmi_ids))
411 		return -ENODEV;
412 
413 	platform_driver_register(&p50_gpio_driver);
414 
415 	gpio_pdev = platform_device_register_simple(DRIVER_NAME, PLATFORM_DEVID_NONE, &res, 1);
416 	if (IS_ERR(gpio_pdev)) {
417 		pr_err("failed registering %s: %ld\n", DRIVER_NAME, PTR_ERR(gpio_pdev));
418 		platform_driver_unregister(&p50_gpio_driver);
419 		return PTR_ERR(gpio_pdev);
420 	}
421 
422 	return 0;
423 }
424 
425 static void __exit p50_module_exit(void)
426 {
427 	platform_device_unregister(gpio_pdev);
428 	platform_driver_unregister(&p50_gpio_driver);
429 }
430 
431 module_init(p50_module_init);
432 module_exit(p50_module_exit);
433 
434 MODULE_AUTHOR("Santosh Kumar Yadav, Barco NV <santoshkumar.yadav@barco.com>");
435 MODULE_DESCRIPTION("Barco P50 identify GPIOs driver");
436 MODULE_LICENSE("GPL");
437