projects/linux·blob master · refs

270 lines · 6.7 KiB

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 <[email protected]>
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 <[email protected]>");
269MODULE_DESCRIPTION("Core driver for Netronix EC");
270MODULE_LICENSE("GPL");