1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (c) 2016, Fuzhou Rockchip Electronics Co., Ltd |
4 | */ |
5 | |
6 | #include <linux/device.h> |
7 | #include <linux/init.h> |
8 | #include <linux/kernel.h> |
9 | #include <linux/module.h> |
10 | #include <linux/of.h> |
11 | #include <linux/reboot.h> |
12 | #include <linux/reboot-mode.h> |
13 | |
14 | #define PREFIX "mode-" |
15 | |
16 | struct mode_info { |
17 | const char *mode; |
18 | u32 magic; |
19 | struct list_head list; |
20 | }; |
21 | |
22 | static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot, |
23 | const char *cmd) |
24 | { |
25 | const char *normal = "normal" ; |
26 | int magic = 0; |
27 | struct mode_info *info; |
28 | |
29 | if (!cmd) |
30 | cmd = normal; |
31 | |
32 | list_for_each_entry(info, &reboot->head, list) { |
33 | if (!strcmp(info->mode, cmd)) { |
34 | magic = info->magic; |
35 | break; |
36 | } |
37 | } |
38 | |
39 | return magic; |
40 | } |
41 | |
42 | static int reboot_mode_notify(struct notifier_block *this, |
43 | unsigned long mode, void *cmd) |
44 | { |
45 | struct reboot_mode_driver *reboot; |
46 | unsigned int magic; |
47 | |
48 | reboot = container_of(this, struct reboot_mode_driver, reboot_notifier); |
49 | magic = get_reboot_mode_magic(reboot, cmd); |
50 | if (magic) |
51 | reboot->write(reboot, magic); |
52 | |
53 | return NOTIFY_DONE; |
54 | } |
55 | |
56 | /** |
57 | * reboot_mode_register - register a reboot mode driver |
58 | * @reboot: reboot mode driver |
59 | * |
60 | * Returns: 0 on success or a negative error code on failure. |
61 | */ |
62 | int reboot_mode_register(struct reboot_mode_driver *reboot) |
63 | { |
64 | struct mode_info *info; |
65 | struct property *prop; |
66 | struct device_node *np = reboot->dev->of_node; |
67 | size_t len = strlen(PREFIX); |
68 | int ret; |
69 | |
70 | INIT_LIST_HEAD(list: &reboot->head); |
71 | |
72 | for_each_property_of_node(np, prop) { |
73 | if (strncmp(prop->name, PREFIX, len)) |
74 | continue; |
75 | |
76 | info = devm_kzalloc(dev: reboot->dev, size: sizeof(*info), GFP_KERNEL); |
77 | if (!info) { |
78 | ret = -ENOMEM; |
79 | goto error; |
80 | } |
81 | |
82 | if (of_property_read_u32(np, propname: prop->name, out_value: &info->magic)) { |
83 | dev_err(reboot->dev, "reboot mode %s without magic number\n" , |
84 | info->mode); |
85 | devm_kfree(dev: reboot->dev, p: info); |
86 | continue; |
87 | } |
88 | |
89 | info->mode = kstrdup_const(s: prop->name + len, GFP_KERNEL); |
90 | if (!info->mode) { |
91 | ret = -ENOMEM; |
92 | goto error; |
93 | } else if (info->mode[0] == '\0') { |
94 | kfree_const(x: info->mode); |
95 | ret = -EINVAL; |
96 | dev_err(reboot->dev, "invalid mode name(%s): too short!\n" , |
97 | prop->name); |
98 | goto error; |
99 | } |
100 | |
101 | list_add_tail(new: &info->list, head: &reboot->head); |
102 | } |
103 | |
104 | reboot->reboot_notifier.notifier_call = reboot_mode_notify; |
105 | register_reboot_notifier(&reboot->reboot_notifier); |
106 | |
107 | return 0; |
108 | |
109 | error: |
110 | list_for_each_entry(info, &reboot->head, list) |
111 | kfree_const(x: info->mode); |
112 | |
113 | return ret; |
114 | } |
115 | EXPORT_SYMBOL_GPL(reboot_mode_register); |
116 | |
117 | /** |
118 | * reboot_mode_unregister - unregister a reboot mode driver |
119 | * @reboot: reboot mode driver |
120 | */ |
121 | int reboot_mode_unregister(struct reboot_mode_driver *reboot) |
122 | { |
123 | struct mode_info *info; |
124 | |
125 | unregister_reboot_notifier(&reboot->reboot_notifier); |
126 | |
127 | list_for_each_entry(info, &reboot->head, list) |
128 | kfree_const(x: info->mode); |
129 | |
130 | return 0; |
131 | } |
132 | EXPORT_SYMBOL_GPL(reboot_mode_unregister); |
133 | |
134 | static void devm_reboot_mode_release(struct device *dev, void *res) |
135 | { |
136 | reboot_mode_unregister(*(struct reboot_mode_driver **)res); |
137 | } |
138 | |
139 | /** |
140 | * devm_reboot_mode_register() - resource managed reboot_mode_register() |
141 | * @dev: device to associate this resource with |
142 | * @reboot: reboot mode driver |
143 | * |
144 | * Returns: 0 on success or a negative error code on failure. |
145 | */ |
146 | int devm_reboot_mode_register(struct device *dev, |
147 | struct reboot_mode_driver *reboot) |
148 | { |
149 | struct reboot_mode_driver **dr; |
150 | int rc; |
151 | |
152 | dr = devres_alloc(devm_reboot_mode_release, sizeof(*dr), GFP_KERNEL); |
153 | if (!dr) |
154 | return -ENOMEM; |
155 | |
156 | rc = reboot_mode_register(reboot); |
157 | if (rc) { |
158 | devres_free(res: dr); |
159 | return rc; |
160 | } |
161 | |
162 | *dr = reboot; |
163 | devres_add(dev, res: dr); |
164 | |
165 | return 0; |
166 | } |
167 | EXPORT_SYMBOL_GPL(devm_reboot_mode_register); |
168 | |
169 | static int devm_reboot_mode_match(struct device *dev, void *res, void *data) |
170 | { |
171 | struct reboot_mode_driver **p = res; |
172 | |
173 | if (WARN_ON(!p || !*p)) |
174 | return 0; |
175 | |
176 | return *p == data; |
177 | } |
178 | |
179 | /** |
180 | * devm_reboot_mode_unregister() - resource managed reboot_mode_unregister() |
181 | * @dev: device to associate this resource with |
182 | * @reboot: reboot mode driver |
183 | */ |
184 | void devm_reboot_mode_unregister(struct device *dev, |
185 | struct reboot_mode_driver *reboot) |
186 | { |
187 | WARN_ON(devres_release(dev, |
188 | devm_reboot_mode_release, |
189 | devm_reboot_mode_match, reboot)); |
190 | } |
191 | EXPORT_SYMBOL_GPL(devm_reboot_mode_unregister); |
192 | |
193 | MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>" ); |
194 | MODULE_DESCRIPTION("System reboot mode core library" ); |
195 | MODULE_LICENSE("GPL v2" ); |
196 | |