1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * I2C slave mode testunit
  4 *
  5 * Copyright (C) 2020 by Wolfram Sang, Sang Engineering <wsa@sang-engineering.com>
  6 * Copyright (C) 2020 by Renesas Electronics Corporation
  7 */
  8
  9#include <linux/bitops.h>
 10#include <linux/i2c.h>
 11#include <linux/init.h>
 12#include <linux/module.h>
 13#include <linux/of.h>
 14#include <linux/slab.h>
 15#include <linux/workqueue.h> /* FIXME: is system_long_wq the best choice? */
 16
 17#define TU_CUR_VERSION 0x01
 18
 19enum testunit_cmds {
 20	TU_CMD_READ_BYTES = 1,	/* save 0 for ABORT, RESET or similar */
 21	TU_CMD_HOST_NOTIFY,
 22	TU_CMD_SMBUS_BLOCK_PROC_CALL,
 23	TU_NUM_CMDS
 24};
 25
 26enum testunit_regs {
 27	TU_REG_CMD,
 28	TU_REG_DATAL,
 29	TU_REG_DATAH,
 30	TU_REG_DELAY,
 31	TU_NUM_REGS
 32};
 33
 34enum testunit_flags {
 35	TU_FLAG_IN_PROCESS,
 36};
 37
 38struct testunit_data {
 39	unsigned long flags;
 40	u8 regs[TU_NUM_REGS];
 41	u8 reg_idx;
 42	struct i2c_client *client;
 43	struct delayed_work worker;
 44};
 45
 46static void i2c_slave_testunit_work(struct work_struct *work)
 47{
 48	struct testunit_data *tu = container_of(work, struct testunit_data, worker.work);
 49	struct i2c_msg msg;
 50	u8 msgbuf[256];
 51	int ret = 0;
 52
 53	msg.addr = I2C_CLIENT_END;
 54	msg.buf = msgbuf;
 55
 56	switch (tu->regs[TU_REG_CMD]) {
 57	case TU_CMD_READ_BYTES:
 58		msg.addr = tu->regs[TU_REG_DATAL];
 59		msg.flags = I2C_M_RD;
 60		msg.len = tu->regs[TU_REG_DATAH];
 61		break;
 62
 63	case TU_CMD_HOST_NOTIFY:
 64		msg.addr = 0x08;
 65		msg.flags = 0;
 66		msg.len = 3;
 67		msgbuf[0] = tu->client->addr;
 68		msgbuf[1] = tu->regs[TU_REG_DATAL];
 69		msgbuf[2] = tu->regs[TU_REG_DATAH];
 70		break;
 71
 72	default:
 73		break;
 74	}
 75
 76	if (msg.addr != I2C_CLIENT_END) {
 77		ret = i2c_transfer(tu->client->adapter, &msg, 1);
 78		/* convert '0 msgs transferred' to errno */
 79		ret = (ret == 0) ? -EIO : ret;
 80	}
 81
 82	if (ret < 0)
 83		dev_err(&tu->client->dev, "CMD%02X failed (%d)\n", tu->regs[TU_REG_CMD], ret);
 84
 85	clear_bit(TU_FLAG_IN_PROCESS, &tu->flags);
 86}
 87
 88static int i2c_slave_testunit_slave_cb(struct i2c_client *client,
 89				     enum i2c_slave_event event, u8 *val)
 90{
 91	struct testunit_data *tu = i2c_get_clientdata(client);
 92	bool is_proc_call = tu->reg_idx == 3 && tu->regs[TU_REG_DATAL] == 1 &&
 93			    tu->regs[TU_REG_CMD] == TU_CMD_SMBUS_BLOCK_PROC_CALL;
 94	int ret = 0;
 95
 96	switch (event) {
 97	case I2C_SLAVE_WRITE_RECEIVED:
 98		if (test_bit(TU_FLAG_IN_PROCESS, &tu->flags))
 99			return -EBUSY;
100
101		if (tu->reg_idx < TU_NUM_REGS)
102			tu->regs[tu->reg_idx] = *val;
103		else
104			ret = -EMSGSIZE;
105
106		if (tu->reg_idx <= TU_NUM_REGS)
107			tu->reg_idx++;
108
109		/* TU_REG_CMD always written at this point */
110		if (tu->regs[TU_REG_CMD] >= TU_NUM_CMDS)
111			ret = -EINVAL;
112
113		break;
114
115	case I2C_SLAVE_STOP:
116		if (tu->reg_idx == TU_NUM_REGS) {
117			set_bit(TU_FLAG_IN_PROCESS, &tu->flags);
118			queue_delayed_work(system_long_wq, &tu->worker,
119					   msecs_to_jiffies(10 * tu->regs[TU_REG_DELAY]));
120		}
121		fallthrough;
122
123	case I2C_SLAVE_WRITE_REQUESTED:
124		memset(tu->regs, 0, TU_NUM_REGS);
125		tu->reg_idx = 0;
126		break;
127
128	case I2C_SLAVE_READ_PROCESSED:
129		if (is_proc_call && tu->regs[TU_REG_DATAH])
130			tu->regs[TU_REG_DATAH]--;
131		fallthrough;
132
133	case I2C_SLAVE_READ_REQUESTED:
134		*val = is_proc_call ? tu->regs[TU_REG_DATAH] : TU_CUR_VERSION;
135		break;
136	}
137
138	return ret;
139}
140
141static int i2c_slave_testunit_probe(struct i2c_client *client)
142{
143	struct testunit_data *tu;
144
145	tu = devm_kzalloc(&client->dev, sizeof(struct testunit_data), GFP_KERNEL);
146	if (!tu)
147		return -ENOMEM;
148
149	tu->client = client;
150	i2c_set_clientdata(client, tu);
151	INIT_DELAYED_WORK(&tu->worker, i2c_slave_testunit_work);
152
153	return i2c_slave_register(client, i2c_slave_testunit_slave_cb);
154};
155
156static void i2c_slave_testunit_remove(struct i2c_client *client)
157{
158	struct testunit_data *tu = i2c_get_clientdata(client);
159
160	cancel_delayed_work_sync(&tu->worker);
161	i2c_slave_unregister(client);
162}
163
164static const struct i2c_device_id i2c_slave_testunit_id[] = {
165	{ "slave-testunit", 0 },
166	{ }
167};
168MODULE_DEVICE_TABLE(i2c, i2c_slave_testunit_id);
169
170static struct i2c_driver i2c_slave_testunit_driver = {
171	.driver = {
172		.name = "i2c-slave-testunit",
173	},
174	.probe_new = i2c_slave_testunit_probe,
175	.remove = i2c_slave_testunit_remove,
176	.id_table = i2c_slave_testunit_id,
177};
178module_i2c_driver(i2c_slave_testunit_driver);
179
180MODULE_AUTHOR("Wolfram Sang <wsa@sang-engineering.com>");
181MODULE_DESCRIPTION("I2C slave mode test unit");
182MODULE_LICENSE("GPL v2");