1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2016 Imagination Technologies
  4 * Author: Paul Burton <paul.burton@mips.com>
  5 */
  6
  7#include <linux/kernel.h>
  8#include <linux/io.h>
  9#include <linux/mfd/syscon.h>
 10#include <linux/module.h>
 11#include <linux/of.h>
 12#include <linux/platform_device.h>
 13#include <linux/property.h>
 14#include <linux/regmap.h>
 15#include <linux/slab.h>
 16
 17#include "line-display.h"
 18
 19struct img_ascii_lcd_ctx;
 20
 21/**
 22 * struct img_ascii_lcd_config - Configuration information about an LCD model
 23 * @num_chars: the number of characters the LCD can display
 24 * @external_regmap: true if registers are in a system controller, else false
 25 * @update: function called to update the LCD
 26 */
 27struct img_ascii_lcd_config {
 28	unsigned int num_chars;
 29	bool external_regmap;
 30	void (*update)(struct linedisp *linedisp);
 31};
 32
 33/**
 34 * struct img_ascii_lcd_ctx - Private data structure
 35 * @base: the base address of the LCD registers
 36 * @regmap: the regmap through which LCD registers are accessed
 37 * @offset: the offset within regmap to the start of the LCD registers
 38 * @cfg: pointer to the LCD model configuration
 39 * @linedisp: line display structure
 40 * @curr: the string currently displayed on the LCD
 41 */
 42struct img_ascii_lcd_ctx {
 43	union {
 44		void __iomem *base;
 45		struct regmap *regmap;
 46	};
 47	u32 offset;
 48	const struct img_ascii_lcd_config *cfg;
 49	struct linedisp linedisp;
 50	char curr[] __aligned(8);
 51};
 52
 53/*
 54 * MIPS Boston development board
 55 */
 56
 57static void boston_update(struct linedisp *linedisp)
 58{
 59	struct img_ascii_lcd_ctx *ctx =
 60		container_of(linedisp, struct img_ascii_lcd_ctx, linedisp);
 61	ulong val;
 62
 63#if BITS_PER_LONG == 64
 64	val = *((u64 *)&ctx->curr[0]);
 65	__raw_writeq(val, ctx->base);
 66#elif BITS_PER_LONG == 32
 67	val = *((u32 *)&ctx->curr[0]);
 68	__raw_writel(val, ctx->base);
 69	val = *((u32 *)&ctx->curr[4]);
 70	__raw_writel(val, ctx->base + 4);
 71#else
 72# error Not 32 or 64 bit
 73#endif
 74}
 75
 76static struct img_ascii_lcd_config boston_config = {
 77	.num_chars = 8,
 78	.update = boston_update,
 79};
 80
 81/*
 82 * MIPS Malta development board
 83 */
 84
 85static void malta_update(struct linedisp *linedisp)
 86{
 87	struct img_ascii_lcd_ctx *ctx =
 88		container_of(linedisp, struct img_ascii_lcd_ctx, linedisp);
 89	unsigned int i;
 90	int err = 0;
 91
 92	for (i = 0; i < linedisp->num_chars; i++) {
 93		err = regmap_write(ctx->regmap,
 94				   ctx->offset + (i * 8), ctx->curr[i]);
 95		if (err)
 96			break;
 97	}
 98
 99	if (unlikely(err))
100		pr_err_ratelimited("Failed to update LCD display: %d\n", err);
101}
102
103static struct img_ascii_lcd_config malta_config = {
104	.num_chars = 8,
105	.external_regmap = true,
106	.update = malta_update,
107};
108
109/*
110 * MIPS SEAD3 development board
111 */
112
113enum {
114	SEAD3_REG_LCD_CTRL		= 0x00,
115#define SEAD3_REG_LCD_CTRL_SETDRAM	BIT(7)
116	SEAD3_REG_LCD_DATA		= 0x08,
117	SEAD3_REG_CPLD_STATUS		= 0x10,
118#define SEAD3_REG_CPLD_STATUS_BUSY	BIT(0)
119	SEAD3_REG_CPLD_DATA		= 0x18,
120#define SEAD3_REG_CPLD_DATA_BUSY	BIT(7)
121};
122
123static int sead3_wait_sm_idle(struct img_ascii_lcd_ctx *ctx)
124{
125	unsigned int status;
126	int err;
127
128	do {
129		err = regmap_read(ctx->regmap,
130				  ctx->offset + SEAD3_REG_CPLD_STATUS,
131				  &status);
132		if (err)
133			return err;
134	} while (status & SEAD3_REG_CPLD_STATUS_BUSY);
135
136	return 0;
137
138}
139
140static int sead3_wait_lcd_idle(struct img_ascii_lcd_ctx *ctx)
141{
142	unsigned int cpld_data;
143	int err;
144
145	err = sead3_wait_sm_idle(ctx);
146	if (err)
147		return err;
148
149	do {
150		err = regmap_read(ctx->regmap,
151				  ctx->offset + SEAD3_REG_LCD_CTRL,
152				  &cpld_data);
153		if (err)
154			return err;
155
156		err = sead3_wait_sm_idle(ctx);
157		if (err)
158			return err;
159
160		err = regmap_read(ctx->regmap,
161				  ctx->offset + SEAD3_REG_CPLD_DATA,
162				  &cpld_data);
163		if (err)
164			return err;
165	} while (cpld_data & SEAD3_REG_CPLD_DATA_BUSY);
166
167	return 0;
168}
169
170static void sead3_update(struct linedisp *linedisp)
171{
172	struct img_ascii_lcd_ctx *ctx =
173		container_of(linedisp, struct img_ascii_lcd_ctx, linedisp);
174	unsigned int i;
175	int err = 0;
176
177	for (i = 0; i < linedisp->num_chars; i++) {
178		err = sead3_wait_lcd_idle(ctx);
179		if (err)
180			break;
181
182		err = regmap_write(ctx->regmap,
183				   ctx->offset + SEAD3_REG_LCD_CTRL,
184				   SEAD3_REG_LCD_CTRL_SETDRAM | i);
185		if (err)
186			break;
187
188		err = sead3_wait_lcd_idle(ctx);
189		if (err)
190			break;
191
192		err = regmap_write(ctx->regmap,
193				   ctx->offset + SEAD3_REG_LCD_DATA,
194				   ctx->curr[i]);
195		if (err)
196			break;
197	}
198
199	if (unlikely(err))
200		pr_err_ratelimited("Failed to update LCD display: %d\n", err);
201}
202
203static struct img_ascii_lcd_config sead3_config = {
204	.num_chars = 16,
205	.external_regmap = true,
206	.update = sead3_update,
207};
208
209static const struct of_device_id img_ascii_lcd_matches[] = {
210	{ .compatible = "img,boston-lcd", .data = &boston_config },
211	{ .compatible = "mti,malta-lcd", .data = &malta_config },
212	{ .compatible = "mti,sead3-lcd", .data = &sead3_config },
213	{ /* sentinel */ }
214};
215MODULE_DEVICE_TABLE(of, img_ascii_lcd_matches);
216
217/**
218 * img_ascii_lcd_probe() - probe an LCD display device
219 * @pdev: the LCD platform device
220 *
221 * Probe an LCD display device, ensuring that we have the required resources in
222 * order to access the LCD & setting up private data as well as sysfs files.
223 *
224 * Return: 0 on success, else -ERRNO
225 */
226static int img_ascii_lcd_probe(struct platform_device *pdev)
227{
228	struct device *dev = &pdev->dev;
229	const struct img_ascii_lcd_config *cfg = device_get_match_data(dev);
230	struct img_ascii_lcd_ctx *ctx;
231	int err;
232
233	ctx = devm_kzalloc(dev, sizeof(*ctx) + cfg->num_chars, GFP_KERNEL);
234	if (!ctx)
235		return -ENOMEM;
236
237	if (cfg->external_regmap) {
238		ctx->regmap = syscon_node_to_regmap(dev->parent->of_node);
239		if (IS_ERR(ctx->regmap))
240			return PTR_ERR(ctx->regmap);
241
242		if (of_property_read_u32(dev->of_node, "offset", &ctx->offset))
243			return -EINVAL;
244	} else {
245		ctx->base = devm_platform_ioremap_resource(pdev, 0);
246		if (IS_ERR(ctx->base))
247			return PTR_ERR(ctx->base);
248	}
249
250	err = linedisp_register(&ctx->linedisp, dev, cfg->num_chars, ctx->curr,
251				cfg->update);
252	if (err)
253		return err;
254
255	/* for backwards compatibility */
256	err = compat_only_sysfs_link_entry_to_kobj(&dev->kobj,
257						   &ctx->linedisp.dev.kobj,
258						   "message", NULL);
259	if (err)
260		goto err_unregister;
261
262	platform_set_drvdata(pdev, ctx);
263	return 0;
264
265err_unregister:
266	linedisp_unregister(&ctx->linedisp);
267	return err;
268}
269
270/**
271 * img_ascii_lcd_remove() - remove an LCD display device
272 * @pdev: the LCD platform device
273 *
274 * Remove an LCD display device, freeing private resources & ensuring that the
275 * driver stops using the LCD display registers.
276 *
277 * Return: 0
278 */
279static int img_ascii_lcd_remove(struct platform_device *pdev)
280{
281	struct img_ascii_lcd_ctx *ctx = platform_get_drvdata(pdev);
282
283	sysfs_remove_link(&pdev->dev.kobj, "message");
284	linedisp_unregister(&ctx->linedisp);
285	return 0;
286}
287
288static struct platform_driver img_ascii_lcd_driver = {
289	.driver = {
290		.name		= "img-ascii-lcd",
291		.of_match_table	= img_ascii_lcd_matches,
292	},
293	.probe	= img_ascii_lcd_probe,
294	.remove	= img_ascii_lcd_remove,
295};
296module_platform_driver(img_ascii_lcd_driver);
297
298MODULE_DESCRIPTION("Imagination Technologies ASCII LCD Display");
299MODULE_AUTHOR("Paul Burton <paul.burton@mips.com>");
300MODULE_LICENSE("GPL");