1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * The Netronix embedded controller is a microcontroller found in some
  4 * e-book readers designed by the original design manufacturer Netronix, Inc.
  5 * It contains RTC, battery monitoring, system power management, and PWM
  6 * functionality.
  7 *
  8 * This driver implements register access, version detection, and system
  9 * power-off/reset.
 10 *
 11 * Copyright 2020 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
 12 */
 13
 14#include <linux/delay.h>
 15#include <linux/errno.h>
 16#include <linux/i2c.h>
 17#include <linux/mfd/core.h>
 18#include <linux/mfd/ntxec.h>
 19#include <linux/module.h>
 20#include <linux/pm.h>
 21#include <linux/reboot.h>
 22#include <linux/regmap.h>
 23#include <linux/types.h>
 24#include <linux/unaligned.h>
 25
 26#define NTXEC_REG_VERSION	0x00
 27#define NTXEC_REG_POWEROFF	0x50
 28#define NTXEC_REG_POWERKEEP	0x70
 29#define NTXEC_REG_RESET		0x90
 30
 31#define NTXEC_POWEROFF_VALUE	0x0100
 32#define NTXEC_POWERKEEP_VALUE	0x0800
 33#define NTXEC_RESET_VALUE	0xff00
 34
 35static struct i2c_client *poweroff_restart_client;
 36
 37static void ntxec_poweroff(void)
 38{
 39	int res;
 40	u8 buf[3] = { NTXEC_REG_POWEROFF };
 41	struct i2c_msg msgs[] = {
 42		{
 43			.addr = poweroff_restart_client->addr,
 44			.flags = 0,
 45			.len = sizeof(buf),
 46			.buf = buf,
 47		},
 48	};
 49
 50	put_unaligned_be16(NTXEC_POWEROFF_VALUE, buf + 1);
 51
 52	res = i2c_transfer(poweroff_restart_client->adapter, msgs, ARRAY_SIZE(msgs));
 53	if (res < 0)
 54		dev_warn(&poweroff_restart_client->dev,
 55			 "Failed to power off (err = %d)\n", res);
 56
 57	/*
 58	 * The time from the register write until the host CPU is powered off
 59	 * has been observed to be about 2.5 to 3 seconds. Sleep long enough to
 60	 * safely avoid returning from the poweroff handler.
 61	 */
 62	msleep(5000);
 63}
 64
 65static int ntxec_restart(struct notifier_block *nb,
 66			 unsigned long action, void *data)
 67{
 68	int res;
 69	u8 buf[3] = { NTXEC_REG_RESET };
 70	/*
 71	 * NOTE: The lower half of the reset value is not sent, because sending
 72	 * it causes an I2C error. (The reset handler in the downstream driver
 73	 * does send the full two-byte value, but doesn't check the result).
 74	 */
 75	struct i2c_msg msgs[] = {
 76		{
 77			.addr = poweroff_restart_client->addr,
 78			.flags = 0,
 79			.len = sizeof(buf) - 1,
 80			.buf = buf,
 81		},
 82	};
 83
 84	put_unaligned_be16(NTXEC_RESET_VALUE, buf + 1);
 85
 86	res = i2c_transfer(poweroff_restart_client->adapter, msgs, ARRAY_SIZE(msgs));
 87	if (res < 0)
 88		dev_warn(&poweroff_restart_client->dev,
 89			 "Failed to restart (err = %d)\n", res);
 90
 91	return NOTIFY_DONE;
 92}
 93
 94static struct notifier_block ntxec_restart_handler = {
 95	.notifier_call = ntxec_restart,
 96	.priority = 128,
 97};
 98
 99static int regmap_ignore_write(void *context,
100			       unsigned int reg, unsigned int val)
101
102{
103	struct regmap *regmap = context;
104
105	regmap_write(regmap, reg, val);
106
107	return 0;
108}
109
110static int regmap_wrap_read(void *context, unsigned int reg,
111			    unsigned int *val)
112{
113	struct regmap *regmap = context;
114
115	return regmap_read(regmap, reg, val);
116}
117
118/*
119 * Some firmware versions do not ack written data, add a wrapper. It
120 * is used to stack another regmap on top.
121 */
122static const struct regmap_config regmap_config_noack = {
123	.name = "ntxec_noack",
124	.reg_bits = 8,
125	.val_bits = 16,
126	.cache_type = REGCACHE_NONE,
127	.reg_write = regmap_ignore_write,
128	.reg_read = regmap_wrap_read
129};
130
131static const struct regmap_config regmap_config = {
132	.name = "ntxec",
133	.reg_bits = 8,
134	.val_bits = 16,
135	.cache_type = REGCACHE_NONE,
136	.val_format_endian = REGMAP_ENDIAN_BIG,
137};
138
139static const struct mfd_cell ntxec_subdev[] = {
140	{ .name = "ntxec-rtc" },
141	{ .name = "ntxec-pwm" },
142};
143
144static const struct mfd_cell ntxec_subdev_pwm[] = {
145	{ .name = "ntxec-pwm" },
146};
147
148static int ntxec_probe(struct i2c_client *client)
149{
150	struct ntxec *ec;
151	unsigned int version;
152	int res;
153	const struct mfd_cell *subdevs;
154	size_t n_subdevs;
155
156	ec = devm_kmalloc(&client->dev, sizeof(*ec), GFP_KERNEL);
157	if (!ec)
158		return -ENOMEM;
159
160	ec->dev = &client->dev;
161
162	ec->regmap = devm_regmap_init_i2c(client, &regmap_config);
163	if (IS_ERR(ec->regmap)) {
164		dev_err(ec->dev, "Failed to set up regmap for device\n");
165		return PTR_ERR(ec->regmap);
166	}
167
168	/* Determine the firmware version */
169	res = regmap_read(ec->regmap, NTXEC_REG_VERSION, &version);
170	if (res < 0) {
171		dev_err(ec->dev, "Failed to read firmware version number\n");
172		return res;
173	}
174
175	/* Bail out if we encounter an unknown firmware version */
176	switch (version) {
177	case NTXEC_VERSION_KOBO_AURA:
178	case NTXEC_VERSION_TOLINO_VISION:
179		subdevs = ntxec_subdev;
180		n_subdevs = ARRAY_SIZE(ntxec_subdev);
181		break;
182	case NTXEC_VERSION_TOLINO_SHINE2:
183		subdevs = ntxec_subdev_pwm;
184		n_subdevs = ARRAY_SIZE(ntxec_subdev_pwm);
185		/* Another regmap stacked on top of the other */
186		ec->regmap = devm_regmap_init(ec->dev, NULL,
187					      ec->regmap,
188					      &regmap_config_noack);
189		if (IS_ERR(ec->regmap))
190			return PTR_ERR(ec->regmap);
191		break;
192	default:
193		dev_err(ec->dev,
194			"Netronix embedded controller version %04x is not supported.\n",
195			version);
196		return -ENODEV;
197	}
198
199	dev_info(ec->dev,
200		 "Netronix embedded controller version %04x detected.\n", version);
201
202	if (of_device_is_system_power_controller(ec->dev->of_node)) {
203		/*
204		 * Set the 'powerkeep' bit. This is necessary on some boards
205		 * in order to keep the system running.
206		 */
207		res = regmap_write(ec->regmap, NTXEC_REG_POWERKEEP,
208				   NTXEC_POWERKEEP_VALUE);
209		if (res < 0)
210			return res;
211
212		if (poweroff_restart_client)
213			/*
214			 * Another instance of the driver already took
215			 * poweroff/restart duties.
216			 */
217			dev_err(ec->dev, "poweroff_restart_client already assigned\n");
218		else
219			poweroff_restart_client = client;
220
221		if (pm_power_off)
222			/* Another driver already registered a poweroff handler. */
223			dev_err(ec->dev, "pm_power_off already assigned\n");
224		else
225			pm_power_off = ntxec_poweroff;
226
227		res = register_restart_handler(&ntxec_restart_handler);
228		if (res)
229			dev_err(ec->dev,
230				"Failed to register restart handler: %d\n", res);
231	}
232
233	i2c_set_clientdata(client, ec);
234
235	res = devm_mfd_add_devices(ec->dev, PLATFORM_DEVID_NONE,
236				   subdevs, n_subdevs, NULL, 0, NULL);
237	if (res)
238		dev_err(ec->dev, "Failed to add subdevices: %d\n", res);
239
240	return res;
241}
242
243static void ntxec_remove(struct i2c_client *client)
244{
245	if (client == poweroff_restart_client) {
246		poweroff_restart_client = NULL;
247		pm_power_off = NULL;
248		unregister_restart_handler(&ntxec_restart_handler);
249	}
250}
251
252static const struct of_device_id of_ntxec_match_table[] = {
253	{ .compatible = "netronix,ntxec", },
254	{}
255};
256MODULE_DEVICE_TABLE(of, of_ntxec_match_table);
257
258static struct i2c_driver ntxec_driver = {
259	.driver = {
260		.name = "ntxec",
261		.of_match_table = of_ntxec_match_table,
262	},
263	.probe = ntxec_probe,
264	.remove = ntxec_remove,
265};
266module_i2c_driver(ntxec_driver);
267
268MODULE_AUTHOR("Jonathan Neuschäfer <j.neuschaefer@gmx.net>");
269MODULE_DESCRIPTION("Core driver for Netronix EC");
270MODULE_LICENSE("GPL");