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