[mirror_ubuntu-jammy-kernel.git] / drivers / auxdisplay / lcd2s.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  console driver for LCD2S 4x20 character displays connected through i2c.
 *  The display also has a spi interface, but the driver does not support
 *  this yet.
 *
 *  This is a driver allowing you to use a LCD2S 4x20 from modtronix
 *  engineering as auxdisplay character device.
 *
 *  (C) 2019 by Lemonage Software GmbH
 *  Author: Lars Pöschel <poeschel@lemonage.de>
 *  All rights reserved.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/delay.h>

#include "charlcd.h"

#define LCD2S_CMD_CUR_MOVES_FWD		0x09
#define LCD2S_CMD_CUR_BLINK_OFF		0x10
#define LCD2S_CMD_CUR_UL_OFF		0x11
#define LCD2S_CMD_DISPLAY_OFF		0x12
#define LCD2S_CMD_CUR_BLINK_ON		0x18
#define LCD2S_CMD_CUR_UL_ON		0x19
#define LCD2S_CMD_DISPLAY_ON		0x1a
#define LCD2S_CMD_BACKLIGHT_OFF		0x20
#define LCD2S_CMD_BACKLIGHT_ON		0x28
#define LCD2S_CMD_WRITE			0x80
#define LCD2S_CMD_MOV_CUR_RIGHT		0x83
#define LCD2S_CMD_MOV_CUR_LEFT		0x84
#define LCD2S_CMD_SHIFT_RIGHT		0x85
#define LCD2S_CMD_SHIFT_LEFT		0x86
#define LCD2S_CMD_SHIFT_UP		0x87
#define LCD2S_CMD_SHIFT_DOWN		0x88
#define LCD2S_CMD_CUR_ADDR		0x89
#define LCD2S_CMD_CUR_POS		0x8a
#define LCD2S_CMD_CUR_RESET		0x8b
#define LCD2S_CMD_CLEAR			0x8c
#define LCD2S_CMD_DEF_CUSTOM_CHAR	0x92
#define LCD2S_CMD_READ_STATUS		0xd0

#define LCD2S_CHARACTER_SIZE		8

#define LCD2S_STATUS_BUF_MASK		0x7f

struct lcd2s_data {
	struct i2c_client *i2c;
	struct charlcd *charlcd;
};

static s32 lcd2s_wait_buf_free(const struct i2c_client *client, int count)
{
	s32 status;

	status = i2c_smbus_read_byte_data(client, LCD2S_CMD_READ_STATUS);
	if (status < 0)
		return status;

	while ((status & LCD2S_STATUS_BUF_MASK) < count) {
		mdelay(1);
		status = i2c_smbus_read_byte_data(client,
						  LCD2S_CMD_READ_STATUS);
		if (status < 0)
			return status;
	}
	return 0;
}

static int lcd2s_i2c_master_send(const struct i2c_client *client,
				 const char *buf, int count)
{
	s32 status;

	status = lcd2s_wait_buf_free(client, count);
	if (status < 0)
		return status;

	return i2c_master_send(client, buf, count);
}

static int lcd2s_i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
{
	s32 status;

	status = lcd2s_wait_buf_free(client, 1);
	if (status < 0)
		return status;

	return i2c_smbus_write_byte(client, value);
}

static int lcd2s_print(struct charlcd *lcd, int c)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;
	u8 buf[2] = { LCD2S_CMD_WRITE, c };

	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));
	return 0;
}

static int lcd2s_gotoxy(struct charlcd *lcd, unsigned int x, unsigned int y)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;
	u8 buf[] = { LCD2S_CMD_CUR_POS, y + 1, x + 1};

	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));

	return 0;
}

static int lcd2s_home(struct charlcd *lcd)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_RESET);
	return 0;
}

static int lcd2s_init_display(struct charlcd *lcd)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	/* turn everything off, but display on */
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON);
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF);
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_MOVES_FWD);
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF);
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF);
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR);

	return 0;
}

static int lcd2s_shift_cursor(struct charlcd *lcd, enum charlcd_shift_dir dir)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (dir == CHARLCD_SHIFT_LEFT)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_LEFT);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_RIGHT);

	return 0;
}

static int lcd2s_shift_display(struct charlcd *lcd, enum charlcd_shift_dir dir)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (dir == CHARLCD_SHIFT_LEFT)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_LEFT);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_RIGHT);

	return 0;
}

static void lcd2s_backlight(struct charlcd *lcd, enum charlcd_onoff on)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (on)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_ON);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF);
}

static int lcd2s_display(struct charlcd *lcd, enum charlcd_onoff on)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (on)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_OFF);

	return 0;
}

static int lcd2s_cursor(struct charlcd *lcd, enum charlcd_onoff on)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (on)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_ON);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF);

	return 0;
}

static int lcd2s_blink(struct charlcd *lcd, enum charlcd_onoff on)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	if (on)
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_ON);
	else
		lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF);

	return 0;
}

static int lcd2s_fontsize(struct charlcd *lcd, enum charlcd_fontsize size)
{
	return 0;
}

static int lcd2s_lines(struct charlcd *lcd, enum charlcd_lines lines)
{
	return 0;
}

static int lcd2s_redefine_char(struct charlcd *lcd, char *esc)
{
	/* Generator : LGcxxxxx...xx; must have <c> between '0'
	 * and '7', representing the numerical ASCII code of the
	 * redefined character, and <xx...xx> a sequence of 16
	 * hex digits representing 8 bytes for each character.
	 * Most LCDs will only use 5 lower bits of the 7 first
	 * bytes.
	 */

	struct lcd2s_data *lcd2s = lcd->drvdata;
	u8 buf[LCD2S_CHARACTER_SIZE + 2] = { LCD2S_CMD_DEF_CUSTOM_CHAR };
	u8 value;
	int shift, i;

	if (!strchr(esc, ';'))
		return 0;

	esc++;

	buf[1] = *(esc++) - '0';
	if (buf[1] > 7)
		return 1;

	i = 2;
	shift = 0;
	value = 0;
	while (*esc && i < LCD2S_CHARACTER_SIZE + 2) {
		int half;

		shift ^= 4;
		half = hex_to_bin(*esc++);
		if (half < 0)
			continue;

		value |= half << shift;
		if (shift == 0) {
			buf[i++] = value;
			value = 0;
		}
	}

	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));
	return 1;
}

static int lcd2s_clear_display(struct charlcd *lcd)
{
	struct lcd2s_data *lcd2s = lcd->drvdata;

	/* This implicitly sets cursor to first row and column */
	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR);
	return 0;
}

static const struct charlcd_ops lcd2s_ops = {
	.print		= lcd2s_print,
	.backlight	= lcd2s_backlight,
	.gotoxy		= lcd2s_gotoxy,
	.home		= lcd2s_home,
	.clear_display	= lcd2s_clear_display,
	.init_display	= lcd2s_init_display,
	.shift_cursor	= lcd2s_shift_cursor,
	.shift_display	= lcd2s_shift_display,
	.display	= lcd2s_display,
	.cursor		= lcd2s_cursor,
	.blink		= lcd2s_blink,
	.fontsize	= lcd2s_fontsize,
	.lines		= lcd2s_lines,
	.redefine_char	= lcd2s_redefine_char,
};

static int lcd2s_i2c_probe(struct i2c_client *i2c,
				const struct i2c_device_id *id)
{
	struct charlcd *lcd;
	struct lcd2s_data *lcd2s;
	int err;

	if (!i2c_check_functionality(i2c->adapter,
			I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
			I2C_FUNC_SMBUS_WRITE_BLOCK_DATA))
		return -EIO;

	lcd2s = devm_kzalloc(&i2c->dev, sizeof(*lcd2s), GFP_KERNEL);
	if (!lcd2s)
		return -ENOMEM;

	/* Test, if the display is responding */
	err = lcd2s_i2c_smbus_write_byte(i2c, LCD2S_CMD_DISPLAY_OFF);
	if (err < 0)
		return err;

	lcd = charlcd_alloc();
	if (!lcd)
		return -ENOMEM;

	lcd->drvdata = lcd2s;
	lcd2s->i2c = i2c;
	lcd2s->charlcd = lcd;

	/* Required properties */
	err = device_property_read_u32(&i2c->dev, "display-height-chars",
			&lcd->height);
	if (err)
		goto fail1;

	err = device_property_read_u32(&i2c->dev, "display-width-chars",
			&lcd->width);
	if (err)
		goto fail1;

	lcd->ops = &lcd2s_ops;

	err = charlcd_register(lcd2s->charlcd);
	if (err)
		goto fail1;

	i2c_set_clientdata(i2c, lcd2s);
	return 0;

fail1:
	charlcd_free(lcd2s->charlcd);
	return err;
}

static int lcd2s_i2c_remove(struct i2c_client *i2c)
{
	struct lcd2s_data *lcd2s = i2c_get_clientdata(i2c);

	charlcd_unregister(lcd2s->charlcd);
	charlcd_free(lcd2s->charlcd);
	return 0;
}

static const struct i2c_device_id lcd2s_i2c_id[] = {
	{ "lcd2s", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lcd2s_i2c_id);

#ifdef CONFIG_OF
static const struct of_device_id lcd2s_of_table[] = {
	{ .compatible = "modtronix,lcd2s" },
	{ }
};
MODULE_DEVICE_TABLE(of, lcd2s_of_table);
#endif

static struct i2c_driver lcd2s_i2c_driver = {
	.driver = {
		.name = "lcd2s",
#ifdef CONFIG_OF
		.of_match_table = of_match_ptr(lcd2s_of_table),
#endif
	},
	.probe = lcd2s_i2c_probe,
	.remove = lcd2s_i2c_remove,
	.id_table = lcd2s_i2c_id,
};

static int __init lcd2s_modinit(void)
{
	int ret = 0;

	ret = i2c_add_driver(&lcd2s_i2c_driver);
	if (ret != 0)
		pr_err("Failed to register lcd2s driver\n");

	return ret;
}
module_init(lcd2s_modinit)

static void __exit lcd2s_exit(void)
{
	i2c_del_driver(&lcd2s_i2c_driver);
}
module_exit(lcd2s_exit)

MODULE_DESCRIPTION("LCD2S character display driver");
MODULE_AUTHOR("Lars Poeschel");
MODULE_LICENSE("GPL");
Commit	Line	Data
8c9108d0 LP	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* console driver for LCD2S 4x20 character displays connected through i2c.
	4	* The display also has a spi interface, but the driver does not support
	5	* this yet.
	6	*
	7	* This is a driver allowing you to use a LCD2S 4x20 from modtronix
	8	* engineering as auxdisplay character device.
	9	*
	10	* (C) 2019 by Lemonage Software GmbH
	11	* Author: Lars Pöschel <poeschel@lemonage.de>
	12	* All rights reserved.
	13	*/
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/slab.h>
	17	#include <linux/i2c.h>
	18	#include <linux/delay.h>
	19
	20	#include "charlcd.h"
	21
	22	#define LCD2S_CMD_CUR_MOVES_FWD 0x09
	23	#define LCD2S_CMD_CUR_BLINK_OFF 0x10
	24	#define LCD2S_CMD_CUR_UL_OFF 0x11
	25	#define LCD2S_CMD_DISPLAY_OFF 0x12
	26	#define LCD2S_CMD_CUR_BLINK_ON 0x18
	27	#define LCD2S_CMD_CUR_UL_ON 0x19
	28	#define LCD2S_CMD_DISPLAY_ON 0x1a
	29	#define LCD2S_CMD_BACKLIGHT_OFF 0x20
	30	#define LCD2S_CMD_BACKLIGHT_ON 0x28
	31	#define LCD2S_CMD_WRITE 0x80
	32	#define LCD2S_CMD_MOV_CUR_RIGHT 0x83
	33	#define LCD2S_CMD_MOV_CUR_LEFT 0x84
	34	#define LCD2S_CMD_SHIFT_RIGHT 0x85
	35	#define LCD2S_CMD_SHIFT_LEFT 0x86
	36	#define LCD2S_CMD_SHIFT_UP 0x87
	37	#define LCD2S_CMD_SHIFT_DOWN 0x88
	38	#define LCD2S_CMD_CUR_ADDR 0x89
	39	#define LCD2S_CMD_CUR_POS 0x8a
	40	#define LCD2S_CMD_CUR_RESET 0x8b
	41	#define LCD2S_CMD_CLEAR 0x8c
	42	#define LCD2S_CMD_DEF_CUSTOM_CHAR 0x92
	43	#define LCD2S_CMD_READ_STATUS 0xd0
	44
	45	#define LCD2S_CHARACTER_SIZE 8
	46
	47	#define LCD2S_STATUS_BUF_MASK 0x7f
	48
	49	struct lcd2s_data {
	50	struct i2c_client *i2c;
	51	struct charlcd *charlcd;
	52	};
	53
	54	static s32 lcd2s_wait_buf_free(const struct i2c_client *client, int count)
	55	{
	56	s32 status;
	57
	58	status = i2c_smbus_read_byte_data(client, LCD2S_CMD_READ_STATUS);
	59	if (status < 0)
	60	return status;
	61
	62	while ((status & LCD2S_STATUS_BUF_MASK) < count) {
	63	mdelay(1);
	64	status = i2c_smbus_read_byte_data(client,
65	LCD2S_CMD_READ_STATUS);
66	if (status < 0)
67	return status;
68	}
69	return 0;
70	}
71
72	static int lcd2s_i2c_master_send(const struct i2c_client *client,
73	const char *buf, int count)
74	{
75	s32 status;
76
77	status = lcd2s_wait_buf_free(client, count);
78	if (status < 0)
79	return status;
80
81	return i2c_master_send(client, buf, count);
82	}
83
84	static int lcd2s_i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
85	{
86	s32 status;
87
88	status = lcd2s_wait_buf_free(client, 1);
89	if (status < 0)
90	return status;
91
92	return i2c_smbus_write_byte(client, value);
93	}
94
95	static int lcd2s_print(struct charlcd *lcd, int c)
96	{
97	struct lcd2s_data *lcd2s = lcd->drvdata;
98	u8 buf[2] = { LCD2S_CMD_WRITE, c };
99
100	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));
101	return 0;
102	}
103
104	static int lcd2s_gotoxy(struct charlcd *lcd, unsigned int x, unsigned int y)
105	{
106	struct lcd2s_data *lcd2s = lcd->drvdata;
107	u8 buf[] = { LCD2S_CMD_CUR_POS, y + 1, x + 1};
108
109	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));
110
111	return 0;
112	}
113
114	static int lcd2s_home(struct charlcd *lcd)
115	{
116	struct lcd2s_data *lcd2s = lcd->drvdata;
117
118	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_RESET);
119	return 0;
120	}
121
122	static int lcd2s_init_display(struct charlcd *lcd)
123	{
124	struct lcd2s_data *lcd2s = lcd->drvdata;
125
126	/* turn everything off, but display on */
127	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON);
128	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF);
129	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_MOVES_FWD);
130	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF);
131	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF);
132	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR);
133
134	return 0;
135	}
136
137	static int lcd2s_shift_cursor(struct charlcd *lcd, enum charlcd_shift_dir dir)
138	{
139	struct lcd2s_data *lcd2s = lcd->drvdata;
140
141	if (dir == CHARLCD_SHIFT_LEFT)
142	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_LEFT);
143	else
144	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_MOV_CUR_RIGHT);
145
146	return 0;
147	}
148
149	static int lcd2s_shift_display(struct charlcd *lcd, enum charlcd_shift_dir dir)
150	{
151	struct lcd2s_data *lcd2s = lcd->drvdata;
152
153	if (dir == CHARLCD_SHIFT_LEFT)
154	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_LEFT);
155	else
156	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_SHIFT_RIGHT);
157
158	return 0;
159	}
160
161	static void lcd2s_backlight(struct charlcd *lcd, enum charlcd_onoff on)
162	{
163	struct lcd2s_data *lcd2s = lcd->drvdata;
164
165	if (on)
166	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_ON);
167	else
168	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_BACKLIGHT_OFF);
169	}
170
171	static int lcd2s_display(struct charlcd *lcd, enum charlcd_onoff on)
172	{
173	struct lcd2s_data *lcd2s = lcd->drvdata;
174
175	if (on)
176	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_ON);
177	else
178	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_DISPLAY_OFF);
179
180	return 0;
181	}
182
183	static int lcd2s_cursor(struct charlcd *lcd, enum charlcd_onoff on)
184	{
185	struct lcd2s_data *lcd2s = lcd->drvdata;
186
187	if (on)
188	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_ON);
189	else
190	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_UL_OFF);
191
192	return 0;
193	}
194
195	static int lcd2s_blink(struct charlcd *lcd, enum charlcd_onoff on)
196	{
197	struct lcd2s_data *lcd2s = lcd->drvdata;
198
199	if (on)
200	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_ON);
201	else
202	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CUR_BLINK_OFF);
203
204	return 0;
205	}
206
207	static int lcd2s_fontsize(struct charlcd *lcd, enum charlcd_fontsize size)
208	{
209	return 0;
210	}
211
212	static int lcd2s_lines(struct charlcd *lcd, enum charlcd_lines lines)
213	{
214	return 0;
215	}
216
217	static int lcd2s_redefine_char(struct charlcd lcd, char esc)
218	{
219	/* Generator : LGcxxxxx...xx; must have <c> between '0'
220	* and '7', representing the numerical ASCII code of the
221	* redefined character, and <xx...xx> a sequence of 16
222	* hex digits representing 8 bytes for each character.
223	* Most LCDs will only use 5 lower bits of the 7 first
224	* bytes.
225	*/
226
227	struct lcd2s_data *lcd2s = lcd->drvdata;
228	u8 buf[LCD2S_CHARACTER_SIZE + 2] = { LCD2S_CMD_DEF_CUSTOM_CHAR };
229	u8 value;
230	int shift, i;
231
232	if (!strchr(esc, ';'))
233	return 0;
234
235	esc++;
236
237	buf[1] = *(esc++) - '0';
238	if (buf[1] > 7)
239	return 1;
240
03bea249	241	i = 2;
8c9108d0 LP	242	shift = 0;
	243	value = 0;
	244	while (*esc && i < LCD2S_CHARACTER_SIZE + 2) {
	245	int half;
	246
	247	shift ^= 4;
	248	half = hex_to_bin(*esc++);
	249	if (half < 0)
	250	continue;
	251
	252	value \|= half << shift;
	253	if (shift == 0) {
	254	buf[i++] = value;
	255	value = 0;
	256	}
	257	}
	258
	259	lcd2s_i2c_master_send(lcd2s->i2c, buf, sizeof(buf));
	260	return 1;
	261	}
	262
	263	static int lcd2s_clear_display(struct charlcd *lcd)
	264	{
	265	struct lcd2s_data *lcd2s = lcd->drvdata;
	266
	267	/* This implicitly sets cursor to first row and column */
	268	lcd2s_i2c_smbus_write_byte(lcd2s->i2c, LCD2S_CMD_CLEAR);
	269	return 0;
	270	}
	271
	272	static const struct charlcd_ops lcd2s_ops = {
	273	.print = lcd2s_print,
	274	.backlight = lcd2s_backlight,
	275	.gotoxy = lcd2s_gotoxy,
	276	.home = lcd2s_home,
	277	.clear_display = lcd2s_clear_display,
	278	.init_display = lcd2s_init_display,
	279	.shift_cursor = lcd2s_shift_cursor,
	280	.shift_display = lcd2s_shift_display,
	281	.display = lcd2s_display,
	282	.cursor = lcd2s_cursor,
	283	.blink = lcd2s_blink,
	284	.fontsize = lcd2s_fontsize,
	285	.lines = lcd2s_lines,
	286	.redefine_char = lcd2s_redefine_char,
	287	};
	288
	289	static int lcd2s_i2c_probe(struct i2c_client *i2c,
	290	const struct i2c_device_id *id)
	291	{
	292	struct charlcd *lcd;
	293	struct lcd2s_data *lcd2s;
	294	int err;
	295
	296	if (!i2c_check_functionality(i2c->adapter,
	297	I2C_FUNC_SMBUS_WRITE_BYTE_DATA \|
	298	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA))
	299	return -EIO;
	300
35e6a22e AS	301	lcd2s = devm_kzalloc(&i2c->dev, sizeof(*lcd2s), GFP_KERNEL);
	302	if (!lcd2s)
	303	return -ENOMEM;
	304
8c9108d0 LP	305	/* Test, if the display is responding */
	306	err = lcd2s_i2c_smbus_write_byte(i2c, LCD2S_CMD_DISPLAY_OFF);
	307	if (err < 0)
	308	return err;
	309
	310	lcd = charlcd_alloc();
	311	if (!lcd)
	312	return -ENOMEM;
	313
8c9108d0 LP	314	lcd->drvdata = lcd2s;
	315	lcd2s->i2c = i2c;
	316	lcd2s->charlcd = lcd;
	317
	318	/* Required properties */
	319	err = device_property_read_u32(&i2c->dev, "display-height-chars",
	320	&lcd->height);
	321	if (err)
35e6a22e	322	goto fail1;
8c9108d0 LP	323
	324	err = device_property_read_u32(&i2c->dev, "display-width-chars",
	325	&lcd->width);
	326	if (err)
35e6a22e	327	goto fail1;
8c9108d0 LP	328
	329	lcd->ops = &lcd2s_ops;
	330
	331	err = charlcd_register(lcd2s->charlcd);
	332	if (err)
35e6a22e	333	goto fail1;
8c9108d0 LP	334
	335	i2c_set_clientdata(i2c, lcd2s);
	336	return 0;
	337
8c9108d0	338	fail1:
ece0faff	339	charlcd_free(lcd2s->charlcd);
8c9108d0 LP	340	return err;
	341	}
	342
	343	static int lcd2s_i2c_remove(struct i2c_client *i2c)
	344	{
	345	struct lcd2s_data *lcd2s = i2c_get_clientdata(i2c);
	346
8c9108d0	347	charlcd_unregister(lcd2s->charlcd);
ece0faff	348	charlcd_free(lcd2s->charlcd);
8c9108d0 LP	349	return 0;
	350	}
	351
	352	static const struct i2c_device_id lcd2s_i2c_id[] = {
	353	{ "lcd2s", 0 },
	354	{ }
	355	};
	356	MODULE_DEVICE_TABLE(i2c, lcd2s_i2c_id);
	357
	358	#ifdef CONFIG_OF
	359	static const struct of_device_id lcd2s_of_table[] = {
	360	{ .compatible = "modtronix,lcd2s" },
	361	{ }
	362	};
	363	MODULE_DEVICE_TABLE(of, lcd2s_of_table);
	364	#endif
	365
	366	static struct i2c_driver lcd2s_i2c_driver = {
	367	.driver = {
	368	.name = "lcd2s",
8c9108d0 LP	369	#ifdef CONFIG_OF
	370	.of_match_table = of_match_ptr(lcd2s_of_table),
	371	#endif
	372	},
	373	.probe = lcd2s_i2c_probe,
	374	.remove = lcd2s_i2c_remove,
	375	.id_table = lcd2s_i2c_id,
	376	};
	377
	378	static int __init lcd2s_modinit(void)
	379	{
	380	int ret = 0;
	381
	382	ret = i2c_add_driver(&lcd2s_i2c_driver);
	383	if (ret != 0)
	384	pr_err("Failed to register lcd2s driver\n");
	385
	386	return ret;
	387	}
	388	module_init(lcd2s_modinit)
	389
	390	static void __exit lcd2s_exit(void)
	391	{
	392	i2c_del_driver(&lcd2s_i2c_driver);
	393	}
	394	module_exit(lcd2s_exit)
	395
	396	MODULE_DESCRIPTION("LCD2S character display driver");
	397	MODULE_AUTHOR("Lars Poeschel");
	398	MODULE_LICENSE("GPL");