1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * CZ.NIC's Turris Omnia MCU system off and RTC wakeup driver
4 *
5 * This is not a true RTC driver (in the sense that it does not provide a
6 * real-time clock), rather the MCU implements a wakeup from powered off state
7 * at a specified time relative to MCU boot, and we expose this feature via RTC
8 * alarm, so that it can be used via the rtcwake command, which is the standard
9 * Linux command for this.
10 *
11 * 2024 by Marek Behún <kabel@kernel.org>
12 */
13
14 #include <linux/crc32.h>
15 #include <linux/delay.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/i2c.h>
19 #include <linux/kstrtox.h>
20 #include <linux/reboot.h>
21 #include <linux/rtc.h>
22 #include <linux/sysfs.h>
23 #include <linux/types.h>
24
25 #include <linux/turris-omnia-mcu-interface.h>
26 #include "turris-omnia-mcu.h"
27
omnia_get_uptime_wakeup(const struct i2c_client * client,u32 * uptime,u32 * wakeup)28 static int omnia_get_uptime_wakeup(const struct i2c_client *client, u32 *uptime,
29 u32 *wakeup)
30 {
31 __le32 reply[2];
32 int err;
33
34 err = omnia_cmd_read(client, OMNIA_CMD_GET_UPTIME_AND_WAKEUP, reply,
35 sizeof(reply));
36 if (err)
37 return err;
38
39 if (uptime)
40 *uptime = le32_to_cpu(reply[0]);
41
42 if (wakeup)
43 *wakeup = le32_to_cpu(reply[1]);
44
45 return 0;
46 }
47
omnia_read_time(struct device * dev,struct rtc_time * tm)48 static int omnia_read_time(struct device *dev, struct rtc_time *tm)
49 {
50 u32 uptime;
51 int err;
52
53 err = omnia_get_uptime_wakeup(to_i2c_client(dev), &uptime, NULL);
54 if (err)
55 return err;
56
57 rtc_time64_to_tm(uptime, tm);
58
59 return 0;
60 }
61
omnia_read_alarm(struct device * dev,struct rtc_wkalrm * alrm)62 static int omnia_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
63 {
64 struct i2c_client *client = to_i2c_client(dev);
65 struct omnia_mcu *mcu = i2c_get_clientdata(client);
66 u32 wakeup;
67 int err;
68
69 err = omnia_get_uptime_wakeup(client, NULL, &wakeup);
70 if (err)
71 return err;
72
73 alrm->enabled = !!wakeup;
74 rtc_time64_to_tm(wakeup ?: mcu->rtc_alarm, &alrm->time);
75
76 return 0;
77 }
78
omnia_set_alarm(struct device * dev,struct rtc_wkalrm * alrm)79 static int omnia_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
80 {
81 struct i2c_client *client = to_i2c_client(dev);
82 struct omnia_mcu *mcu = i2c_get_clientdata(client);
83
84 mcu->rtc_alarm = rtc_tm_to_time64(&alrm->time);
85
86 if (alrm->enabled)
87 return omnia_cmd_write_u32(client, OMNIA_CMD_SET_WAKEUP,
88 mcu->rtc_alarm);
89
90 return 0;
91 }
92
omnia_alarm_irq_enable(struct device * dev,unsigned int enabled)93 static int omnia_alarm_irq_enable(struct device *dev, unsigned int enabled)
94 {
95 struct i2c_client *client = to_i2c_client(dev);
96 struct omnia_mcu *mcu = i2c_get_clientdata(client);
97
98 return omnia_cmd_write_u32(client, OMNIA_CMD_SET_WAKEUP,
99 enabled ? mcu->rtc_alarm : 0);
100 }
101
102 static const struct rtc_class_ops omnia_rtc_ops = {
103 .read_time = omnia_read_time,
104 .read_alarm = omnia_read_alarm,
105 .set_alarm = omnia_set_alarm,
106 .alarm_irq_enable = omnia_alarm_irq_enable,
107 };
108
omnia_power_off(struct sys_off_data * data)109 static int omnia_power_off(struct sys_off_data *data)
110 {
111 struct omnia_mcu *mcu = data->cb_data;
112 __be32 tmp;
113 u8 cmd[9];
114 u16 arg;
115 int err;
116
117 if (mcu->front_button_poweron)
118 arg = OMNIA_CMD_POWER_OFF_POWERON_BUTTON;
119 else
120 arg = 0;
121
122 cmd[0] = OMNIA_CMD_POWER_OFF;
123 put_unaligned_le16(OMNIA_CMD_POWER_OFF_MAGIC, &cmd[1]);
124 put_unaligned_le16(arg, &cmd[3]);
125
126 /*
127 * Although all values from and to MCU are passed in little-endian, the
128 * MCU's CRC unit uses big-endian CRC32 polynomial (0x04c11db7), so we
129 * need to use crc32_be() here.
130 */
131 tmp = cpu_to_be32(get_unaligned_le32(&cmd[1]));
132 put_unaligned_le32(crc32_be(~0, (void *)&tmp, sizeof(tmp)), &cmd[5]);
133
134 err = omnia_cmd_write(mcu->client, cmd, sizeof(cmd));
135 if (err)
136 dev_err(&mcu->client->dev,
137 "Unable to send the poweroff command: %d\n", err);
138
139 return NOTIFY_DONE;
140 }
141
omnia_restart(struct sys_off_data * data)142 static int omnia_restart(struct sys_off_data *data)
143 {
144 struct omnia_mcu *mcu = data->cb_data;
145 u8 cmd[3];
146 int err;
147
148 cmd[0] = OMNIA_CMD_GENERAL_CONTROL;
149
150 if (reboot_mode == REBOOT_HARD)
151 cmd[1] = cmd[2] = OMNIA_CTL_HARD_RST;
152 else
153 cmd[1] = cmd[2] = OMNIA_CTL_LIGHT_RST;
154
155 err = omnia_cmd_write(mcu->client, cmd, sizeof(cmd));
156 if (err)
157 dev_err(&mcu->client->dev,
158 "Unable to send the restart command: %d\n", err);
159
160 /*
161 * MCU needs a little bit to process the I2C command, otherwise it will
162 * do a light reset based on SOC SYSRES_OUT pin.
163 */
164 mdelay(1);
165
166 return NOTIFY_DONE;
167 }
168
front_button_poweron_show(struct device * dev,struct device_attribute * a,char * buf)169 static ssize_t front_button_poweron_show(struct device *dev,
170 struct device_attribute *a, char *buf)
171 {
172 struct omnia_mcu *mcu = dev_get_drvdata(dev);
173
174 return sysfs_emit(buf, "%d\n", mcu->front_button_poweron);
175 }
176
front_button_poweron_store(struct device * dev,struct device_attribute * a,const char * buf,size_t count)177 static ssize_t front_button_poweron_store(struct device *dev,
178 struct device_attribute *a,
179 const char *buf, size_t count)
180 {
181 struct omnia_mcu *mcu = dev_get_drvdata(dev);
182 bool val;
183 int err;
184
185 err = kstrtobool(buf, &val);
186 if (err)
187 return err;
188
189 mcu->front_button_poweron = val;
190
191 return count;
192 }
193 static DEVICE_ATTR_RW(front_button_poweron);
194
195 static struct attribute *omnia_mcu_poweroff_attrs[] = {
196 &dev_attr_front_button_poweron.attr,
197 NULL
198 };
199
poweroff_attrs_visible(struct kobject * kobj,struct attribute * a,int n)200 static umode_t poweroff_attrs_visible(struct kobject *kobj, struct attribute *a,
201 int n)
202 {
203 struct device *dev = kobj_to_dev(kobj);
204 struct omnia_mcu *mcu = dev_get_drvdata(dev);
205
206 if (mcu->features & OMNIA_FEAT_POWEROFF_WAKEUP)
207 return a->mode;
208
209 return 0;
210 }
211
212 const struct attribute_group omnia_mcu_poweroff_group = {
213 .attrs = omnia_mcu_poweroff_attrs,
214 .is_visible = poweroff_attrs_visible,
215 };
216
omnia_mcu_register_sys_off_and_wakeup(struct omnia_mcu * mcu)217 int omnia_mcu_register_sys_off_and_wakeup(struct omnia_mcu *mcu)
218 {
219 struct device *dev = &mcu->client->dev;
220 int err;
221
222 /* MCU restart is always available */
223 err = devm_register_sys_off_handler(dev, SYS_OFF_MODE_RESTART,
224 SYS_OFF_PRIO_FIRMWARE,
225 omnia_restart, mcu);
226 if (err)
227 return dev_err_probe(dev, err,
228 "Cannot register system restart handler\n");
229
230 /*
231 * Poweroff and wakeup are available only if POWEROFF_WAKEUP feature is
232 * present.
233 */
234 if (!(mcu->features & OMNIA_FEAT_POWEROFF_WAKEUP))
235 return 0;
236
237 err = devm_register_sys_off_handler(dev, SYS_OFF_MODE_POWER_OFF,
238 SYS_OFF_PRIO_FIRMWARE,
239 omnia_power_off, mcu);
240 if (err)
241 return dev_err_probe(dev, err,
242 "Cannot register system power off handler\n");
243
244 mcu->rtcdev = devm_rtc_allocate_device(dev);
245 if (IS_ERR(mcu->rtcdev))
246 return dev_err_probe(dev, PTR_ERR(mcu->rtcdev),
247 "Cannot allocate RTC device\n");
248
249 mcu->rtcdev->ops = &omnia_rtc_ops;
250 mcu->rtcdev->range_max = U32_MAX;
251 set_bit(RTC_FEATURE_ALARM_WAKEUP_ONLY, mcu->rtcdev->features);
252
253 err = devm_rtc_register_device(mcu->rtcdev);
254 if (err)
255 return dev_err_probe(dev, err, "Cannot register RTC device\n");
256
257 mcu->front_button_poweron = true;
258
259 return 0;
260 }
261