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 <asm/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 
35 static struct i2c_client *poweroff_restart_client;
36 
ntxec_poweroff(void)37 static 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 
ntxec_restart(struct notifier_block * nb,unsigned long action,void * data)65 static 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 
94 static struct notifier_block ntxec_restart_handler = {
95 	.notifier_call = ntxec_restart,
96 	.priority = 128,
97 };
98 
regmap_ignore_write(void * context,unsigned int reg,unsigned int val)99 static 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 
regmap_wrap_read(void * context,unsigned int reg,unsigned int * val)110 static 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  */
122 static 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 
131 static 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 
139 static const struct mfd_cell ntxec_subdev[] = {
140 	{ .name = "ntxec-rtc" },
141 	{ .name = "ntxec-pwm" },
142 };
143 
144 static const struct mfd_cell ntxec_subdev_pwm[] = {
145 	{ .name = "ntxec-pwm" },
146 };
147 
ntxec_probe(struct i2c_client * client)148 static 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 
ntxec_remove(struct i2c_client * client)243 static 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 
252 static const struct of_device_id of_ntxec_match_table[] = {
253 	{ .compatible = "netronix,ntxec", },
254 	{}
255 };
256 MODULE_DEVICE_TABLE(of, of_ntxec_match_table);
257 
258 static 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 };
266 module_i2c_driver(ntxec_driver);
267 
268 MODULE_AUTHOR("Jonathan Neuschäfer <j.neuschaefer@gmx.net>");
269 MODULE_DESCRIPTION("Core driver for Netronix EC");
270 MODULE_LICENSE("GPL");
271