1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for the TAOS evaluation modules
4  * These devices include an I2C master which can be controlled over the
5  * serial port.
6  *
7  * Copyright (C) 2007 Jean Delvare <jdelvare@suse.de>
8  */
9 
10 #include <linux/delay.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/interrupt.h>
14 #include <linux/input.h>
15 #include <linux/serio.h>
16 #include <linux/init.h>
17 #include <linux/i2c.h>
18 
19 #define TAOS_BUFFER_SIZE	63
20 
21 #define TAOS_STATE_INIT		0
22 #define TAOS_STATE_IDLE		1
23 #define TAOS_STATE_EOFF		2
24 #define TAOS_STATE_RECV		3
25 
26 #define TAOS_CMD_RESET		0x12
27 #define TAOS_CMD_ECHO_ON	'+'
28 #define TAOS_CMD_ECHO_OFF	'-'
29 
30 static DECLARE_WAIT_QUEUE_HEAD(wq);
31 
32 struct taos_data {
33 	struct i2c_adapter adapter;
34 	struct i2c_client *client;
35 	int state;
36 	u8 addr;		/* last used address */
37 	unsigned char buffer[TAOS_BUFFER_SIZE];
38 	unsigned int pos;	/* position inside the buffer */
39 };
40 
41 /* TAOS TSL2550 EVM */
42 static const struct i2c_board_info tsl2550_info = {
43 	I2C_BOARD_INFO("tsl2550", 0x39),
44 };
45 
46 /* Instantiate i2c devices based on the adapter name */
47 static struct i2c_client *taos_instantiate_device(struct i2c_adapter *adapter)
48 {
49 	if (!strncmp(adapter->name, "TAOS TSL2550 EVM", 16)) {
50 		dev_info(&adapter->dev, "Instantiating device %s at 0x%02x\n",
51 			tsl2550_info.type, tsl2550_info.addr);
52 		return i2c_new_client_device(adapter, &tsl2550_info);
53 	}
54 
55 	return ERR_PTR(-ENODEV);
56 }
57 
58 static int taos_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
59 			   unsigned short flags, char read_write, u8 command,
60 			   int size, union i2c_smbus_data *data)
61 {
62 	struct serio *serio = adapter->algo_data;
63 	struct taos_data *taos = serio_get_drvdata(serio);
64 	char *p;
65 
66 	/* Encode our transaction. "@" is for the device address, "$" for the
67 	   SMBus command and "#" for the data. */
68 	p = taos->buffer;
69 
70 	/* The device remembers the last used address, no need to send it
71 	   again if it's the same */
72 	if (addr != taos->addr)
73 		p += sprintf(p, "@%02X", addr);
74 
75 	switch (size) {
76 	case I2C_SMBUS_BYTE:
77 		if (read_write == I2C_SMBUS_WRITE)
78 			sprintf(p, "$#%02X", command);
79 		else
80 			sprintf(p, "$");
81 		break;
82 	case I2C_SMBUS_BYTE_DATA:
83 		if (read_write == I2C_SMBUS_WRITE)
84 			sprintf(p, "$%02X#%02X", command, data->byte);
85 		else
86 			sprintf(p, "$%02X", command);
87 		break;
88 	default:
89 		dev_warn(&adapter->dev, "Unsupported transaction %d\n", size);
90 		return -EOPNOTSUPP;
91 	}
92 
93 	/* Send the transaction to the TAOS EVM */
94 	dev_dbg(&adapter->dev, "Command buffer: %s\n", taos->buffer);
95 	for (p = taos->buffer; *p; p++)
96 		serio_write(serio, *p);
97 
98 	taos->addr = addr;
99 
100 	/* Start the transaction and read the answer */
101 	taos->pos = 0;
102 	taos->state = TAOS_STATE_RECV;
103 	serio_write(serio, read_write == I2C_SMBUS_WRITE ? '>' : '<');
104 	wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
105 					 msecs_to_jiffies(150));
106 	if (taos->state != TAOS_STATE_IDLE
107 	 || taos->pos != 5) {
108 		dev_err(&adapter->dev, "Transaction timeout (pos=%d)\n",
109 			taos->pos);
110 		return -EIO;
111 	}
112 	dev_dbg(&adapter->dev, "Answer buffer: %s\n", taos->buffer);
113 
114 	/* Interpret the returned string */
115 	p = taos->buffer + 1;
116 	p[3] = '\0';
117 	if (!strcmp(p, "NAK"))
118 		return -ENODEV;
119 
120 	if (read_write == I2C_SMBUS_WRITE) {
121 		if (!strcmp(p, "ACK"))
122 			return 0;
123 	} else {
124 		if (p[0] == 'x') {
125 			/*
126 			 * Voluntarily dropping error code of kstrtou8 since all
127 			 * error code that it could return are invalid according
128 			 * to Documentation/i2c/fault-codes.rst.
129 			 */
130 			if (kstrtou8(p + 1, 16, &data->byte))
131 				return -EPROTO;
132 			return 0;
133 		}
134 	}
135 
136 	return -EIO;
137 }
138 
139 static u32 taos_smbus_func(struct i2c_adapter *adapter)
140 {
141 	return I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA;
142 }
143 
144 static const struct i2c_algorithm taos_algorithm = {
145 	.smbus_xfer	= taos_smbus_xfer,
146 	.functionality	= taos_smbus_func,
147 };
148 
149 static irqreturn_t taos_interrupt(struct serio *serio, unsigned char data,
150 				  unsigned int flags)
151 {
152 	struct taos_data *taos = serio_get_drvdata(serio);
153 
154 	switch (taos->state) {
155 	case TAOS_STATE_INIT:
156 		taos->buffer[taos->pos++] = data;
157 		if (data == ':'
158 		 || taos->pos == TAOS_BUFFER_SIZE - 1) {
159 			taos->buffer[taos->pos] = '\0';
160 			taos->state = TAOS_STATE_IDLE;
161 			wake_up_interruptible(&wq);
162 		}
163 		break;
164 	case TAOS_STATE_EOFF:
165 		taos->state = TAOS_STATE_IDLE;
166 		wake_up_interruptible(&wq);
167 		break;
168 	case TAOS_STATE_RECV:
169 		taos->buffer[taos->pos++] = data;
170 		if (data == ']') {
171 			taos->buffer[taos->pos] = '\0';
172 			taos->state = TAOS_STATE_IDLE;
173 			wake_up_interruptible(&wq);
174 		}
175 		break;
176 	}
177 
178 	return IRQ_HANDLED;
179 }
180 
181 /* Extract the adapter name from the buffer received after reset.
182    The buffer is modified and a pointer inside the buffer is returned. */
183 static char *taos_adapter_name(char *buffer)
184 {
185 	char *start, *end;
186 
187 	start = strstr(buffer, "TAOS ");
188 	if (!start)
189 		return NULL;
190 
191 	end = strchr(start, '\r');
192 	if (!end)
193 		return NULL;
194 	*end = '\0';
195 
196 	return start;
197 }
198 
199 static int taos_connect(struct serio *serio, struct serio_driver *drv)
200 {
201 	struct taos_data *taos;
202 	struct i2c_adapter *adapter;
203 	char *name;
204 	int err;
205 
206 	taos = kzalloc(sizeof(struct taos_data), GFP_KERNEL);
207 	if (!taos) {
208 		err = -ENOMEM;
209 		goto exit;
210 	}
211 	taos->state = TAOS_STATE_INIT;
212 	serio_set_drvdata(serio, taos);
213 
214 	err = serio_open(serio, drv);
215 	if (err)
216 		goto exit_kfree;
217 
218 	adapter = &taos->adapter;
219 	adapter->owner = THIS_MODULE;
220 	adapter->algo = &taos_algorithm;
221 	adapter->algo_data = serio;
222 	adapter->dev.parent = &serio->dev;
223 
224 	/* Reset the TAOS evaluation module to identify it */
225 	serio_write(serio, TAOS_CMD_RESET);
226 	wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
227 					 msecs_to_jiffies(2000));
228 
229 	if (taos->state != TAOS_STATE_IDLE) {
230 		err = -ENODEV;
231 		dev_err(&serio->dev, "TAOS EVM reset failed (state=%d, "
232 			"pos=%d)\n", taos->state, taos->pos);
233 		goto exit_close;
234 	}
235 
236 	name = taos_adapter_name(taos->buffer);
237 	if (!name) {
238 		err = -ENODEV;
239 		dev_err(&serio->dev, "TAOS EVM identification failed\n");
240 		goto exit_close;
241 	}
242 	strlcpy(adapter->name, name, sizeof(adapter->name));
243 
244 	/* Turn echo off for better performance */
245 	taos->state = TAOS_STATE_EOFF;
246 	serio_write(serio, TAOS_CMD_ECHO_OFF);
247 
248 	wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
249 					 msecs_to_jiffies(250));
250 	if (taos->state != TAOS_STATE_IDLE) {
251 		err = -ENODEV;
252 		dev_err(&serio->dev, "TAOS EVM echo off failed "
253 			"(state=%d)\n", taos->state);
254 		goto exit_close;
255 	}
256 
257 	err = i2c_add_adapter(adapter);
258 	if (err)
259 		goto exit_close;
260 	dev_info(&serio->dev, "Connected to TAOS EVM\n");
261 
262 	taos->client = taos_instantiate_device(adapter);
263 	return 0;
264 
265  exit_close:
266 	serio_close(serio);
267  exit_kfree:
268 	kfree(taos);
269  exit:
270 	return err;
271 }
272 
273 static void taos_disconnect(struct serio *serio)
274 {
275 	struct taos_data *taos = serio_get_drvdata(serio);
276 
277 	i2c_unregister_device(taos->client);
278 	i2c_del_adapter(&taos->adapter);
279 	serio_close(serio);
280 	kfree(taos);
281 
282 	dev_info(&serio->dev, "Disconnected from TAOS EVM\n");
283 }
284 
285 static const struct serio_device_id taos_serio_ids[] = {
286 	{
287 		.type	= SERIO_RS232,
288 		.proto	= SERIO_TAOSEVM,
289 		.id	= SERIO_ANY,
290 		.extra	= SERIO_ANY,
291 	},
292 	{ 0 }
293 };
294 MODULE_DEVICE_TABLE(serio, taos_serio_ids);
295 
296 static struct serio_driver taos_drv = {
297 	.driver		= {
298 		.name	= "taos-evm",
299 	},
300 	.description	= "TAOS evaluation module driver",
301 	.id_table	= taos_serio_ids,
302 	.connect	= taos_connect,
303 	.disconnect	= taos_disconnect,
304 	.interrupt	= taos_interrupt,
305 };
306 
307 module_serio_driver(taos_drv);
308 
309 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
310 MODULE_DESCRIPTION("TAOS evaluation module driver");
311 MODULE_LICENSE("GPL");
312