1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
|
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2020 The Linux Foundation. All rights reserved.
*/
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/pm.h>
#include <linux/qcom_scm.h>
#include <soc/qcom/minidump.h>
#if IS_ENABLED(CONFIG_SEC_DEBUG)
#include <linux/sec_debug.h>
#endif
enum qcom_download_dest {
QCOM_DOWNLOAD_DEST_UNKNOWN = -1,
QCOM_DOWNLOAD_DEST_QPST = 0,
QCOM_DOWNLOAD_DEST_EMMC = 2,
};
struct qcom_dload {
struct notifier_block panic_nb;
struct notifier_block reboot_nb;
struct kobject kobj;
bool in_panic;
void __iomem *dload_dest_addr;
};
#define to_qcom_dload(o) container_of(o, struct qcom_dload, kobj)
#define QCOM_DOWNLOAD_BOTHDUMP (QCOM_DOWNLOAD_FULLDUMP | QCOM_DOWNLOAD_MINIDUMP)
static bool enable_dump =
IS_ENABLED(CONFIG_POWER_RESET_QCOM_DOWNLOAD_MODE_DEFAULT);
static enum qcom_download_mode current_download_mode = QCOM_DOWNLOAD_NODUMP;
static enum qcom_download_mode dump_mode = QCOM_DOWNLOAD_FULLDUMP;
static int set_download_mode(enum qcom_download_mode mode)
{
if ((mode & QCOM_DOWNLOAD_MINIDUMP) && !msm_minidump_enabled()) {
mode &= ~QCOM_DOWNLOAD_MINIDUMP;
pr_warn("Minidump not enabled.\n");
if (!mode)
return -ENODEV;
}
current_download_mode = mode;
qcom_scm_set_download_mode(mode, 0);
return 0;
}
static int set_dump_mode(enum qcom_download_mode mode)
{
int ret = 0;
if (enable_dump) {
ret = set_download_mode(mode);
if (likely(!ret))
dump_mode = mode;
} else
dump_mode = mode;
return ret;
}
static void msm_enable_dump_mode(bool enable)
{
if (enable)
set_download_mode(dump_mode);
else
set_download_mode(QCOM_DOWNLOAD_NODUMP);
}
#if IS_ENABLED(CONFIG_SEC_DEBUG)
void set_dload_mode(int on)
{
if (on)
set_download_mode(QCOM_DOWNLOAD_FULLDUMP);
else
set_download_mode(QCOM_DOWNLOAD_NODUMP);
pr_err("set_dload_mode <%d> ( %lx )\n", on, CALLER_ADDR0);
}
#endif
static void set_download_dest(struct qcom_dload *poweroff,
enum qcom_download_dest dest)
{
if (poweroff->dload_dest_addr)
__raw_writel(dest, poweroff->dload_dest_addr);
}
static enum qcom_download_dest get_download_dest(struct qcom_dload *poweroff)
{
if (poweroff->dload_dest_addr)
return __raw_readl(poweroff->dload_dest_addr);
else
return QCOM_DOWNLOAD_DEST_UNKNOWN;
}
static int param_set_download_mode(const char *val,
const struct kernel_param *kp)
{
int ret;
/* update enable_dump according to user input */
ret = param_set_bool(val, kp);
if (ret)
return ret;
msm_enable_dump_mode(true);
return 0;
}
module_param_call(download_mode, param_set_download_mode, param_get_int,
&enable_dump, 0644);
/* interface for exporting attributes */
struct reset_attribute {
struct attribute attr;
ssize_t (*show)(struct kobject *kobj, struct attribute *attr,
char *buf);
ssize_t (*store)(struct kobject *kobj, struct attribute *attr,
const char *buf, size_t count);
};
#define to_reset_attr(_attr) \
container_of(_attr, struct reset_attribute, attr)
static ssize_t attr_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct reset_attribute *reset_attr = to_reset_attr(attr);
ssize_t ret = -EIO;
if (reset_attr->show)
ret = reset_attr->show(kobj, attr, buf);
return ret;
}
static ssize_t attr_store(struct kobject *kobj, struct attribute *attr,
const char *buf, size_t count)
{
struct reset_attribute *reset_attr = to_reset_attr(attr);
ssize_t ret = -EIO;
if (reset_attr->store)
ret = reset_attr->store(kobj, attr, buf, count);
return ret;
}
static const struct sysfs_ops reset_sysfs_ops = {
.show = attr_show,
.store = attr_store,
};
static struct kobj_type qcom_dload_kobj_type = {
.sysfs_ops = &reset_sysfs_ops,
};
static ssize_t emmc_dload_show(struct kobject *kobj,
struct attribute *this,
char *buf)
{
struct qcom_dload *poweroff = to_qcom_dload(kobj);
if (!poweroff->dload_dest_addr)
return -ENODEV;
return scnprintf(buf, PAGE_SIZE, "%u\n",
get_download_dest(poweroff) == QCOM_DOWNLOAD_DEST_EMMC);
}
static ssize_t emmc_dload_store(struct kobject *kobj,
struct attribute *this,
const char *buf, size_t count)
{
int ret;
bool enabled;
struct qcom_dload *poweroff = to_qcom_dload(kobj);
if (!poweroff->dload_dest_addr)
return -ENODEV;
ret = kstrtobool(buf, &enabled);
if (ret < 0)
return ret;
if (enabled)
set_download_dest(poweroff, QCOM_DOWNLOAD_DEST_EMMC);
else
set_download_dest(poweroff, QCOM_DOWNLOAD_DEST_QPST);
return count;
}
static struct reset_attribute attr_emmc_dload = __ATTR_RW(emmc_dload);
static ssize_t dload_mode_show(struct kobject *kobj,
struct attribute *this,
char *buf)
{
const char *mode;
switch ((unsigned int)dump_mode) {
case QCOM_DOWNLOAD_FULLDUMP:
mode = "full";
break;
case QCOM_DOWNLOAD_MINIDUMP:
mode = "mini";
break;
case QCOM_DOWNLOAD_BOTHDUMP:
mode = "both";
break;
default:
mode = "unknown";
break;
}
return scnprintf(buf, PAGE_SIZE, "DLOAD dump type: %s\n", mode);
}
static ssize_t dload_mode_store(struct kobject *kobj,
struct attribute *this,
const char *buf, size_t count)
{
enum qcom_download_mode mode;
if (sysfs_streq(buf, "full"))
mode = QCOM_DOWNLOAD_FULLDUMP;
else if (sysfs_streq(buf, "mini"))
mode = QCOM_DOWNLOAD_MINIDUMP;
else if (sysfs_streq(buf, "both"))
mode = QCOM_DOWNLOAD_BOTHDUMP;
else {
pr_err("Invalid dump mode request...\n");
pr_err("Supported dumps: 'full', 'mini', or 'both'\n");
return -EINVAL;
}
return set_dump_mode(mode) ? : count;
}
static struct reset_attribute attr_dload_mode = __ATTR_RW(dload_mode);
static struct attribute *qcom_dload_attrs[] = {
&attr_emmc_dload.attr,
&attr_dload_mode.attr,
NULL
};
static struct attribute_group qcom_dload_attr_group = {
.attrs = qcom_dload_attrs,
};
static int qcom_dload_panic(struct notifier_block *this, unsigned long event,
void *ptr)
{
struct qcom_dload *poweroff = container_of(this, struct qcom_dload,
panic_nb);
poweroff->in_panic = true;
if (enable_dump)
msm_enable_dump_mode(true);
return NOTIFY_OK;
}
static int qcom_dload_reboot(struct notifier_block *this, unsigned long event,
void *ptr)
{
char *cmd = ptr;
struct qcom_dload *poweroff = container_of(this, struct qcom_dload,
reboot_nb);
pr_debug("%s : cmd : %s\n", __func__, cmd);
/* Clean shutdown, disable dump mode to allow normal restart */
if (!poweroff->in_panic)
set_download_mode(QCOM_DOWNLOAD_NODUMP);
#if !IS_ENABLED(CONFIG_SEC_DEBUG)
if (cmd) {
if (!strcmp(cmd, "edl"))
set_download_mode(QCOM_DOWNLOAD_EDL);
else if (!strcmp(cmd, "qcom_dload"))
msm_enable_dump_mode(true);
}
#endif
if (current_download_mode != QCOM_DOWNLOAD_NODUMP)
reboot_mode = REBOOT_WARM;
return NOTIFY_OK;
}
static void __iomem *map_prop_mem(const char *propname)
{
struct device_node *np = of_find_compatible_node(NULL, NULL, propname);
void __iomem *addr;
if (!np) {
pr_err("Unable to find DT property: %s\n", propname);
return NULL;
}
addr = of_iomap(np, 0);
if (!addr)
pr_err("Unable to map memory for DT property: %s\n", propname);
return addr;
}
#ifdef CONFIG_RANDOMIZE_BASE
#define KASLR_OFFSET_MASK 0x00000000FFFFFFFF
static void store_kaslr_offset(void)
{
void __iomem *mem = map_prop_mem("qcom,msm-imem-kaslr_offset");
if (!mem)
return;
__raw_writel(0xdead4ead, mem);
__raw_writel((kimage_vaddr - KIMAGE_VADDR) & KASLR_OFFSET_MASK,
mem + 4);
__raw_writel(((kimage_vaddr - KIMAGE_VADDR) >> 32) & KASLR_OFFSET_MASK,
mem + 8);
iounmap(mem);
}
#else
static void store_kaslr_offset(void) {}
#endif /* CONFIG_RANDOMIZE_BASE */
static int qcom_dload_probe(struct platform_device *pdev)
{
struct qcom_dload *poweroff;
int ret;
poweroff = devm_kzalloc(&pdev->dev, sizeof(*poweroff), GFP_KERNEL);
if (!poweroff)
return -ENOMEM;
ret = kobject_init_and_add(&poweroff->kobj, &qcom_dload_kobj_type,
kernel_kobj, "dload");
if (ret) {
pr_err("%s: Error in creation kobject_add\n", __func__);
kobject_put(&poweroff->kobj);
return ret;
}
ret = sysfs_create_group(&poweroff->kobj, &qcom_dload_attr_group);
if (ret) {
pr_err("%s: Error in creation sysfs_create_group\n", __func__);
kobject_del(&poweroff->kobj);
return ret;
}
poweroff->dload_dest_addr = map_prop_mem("qcom,msm-imem-dload-type");
store_kaslr_offset();
#if IS_ENABLED(CONFIG_SEC_DEBUG)
enable_dump = true;
msm_enable_dump_mode(enable_dump);
#else
msm_enable_dump_mode(enable_dump);
if (!enable_dump)
qcom_scm_disable_sdi();
#endif
poweroff->panic_nb.notifier_call = qcom_dload_panic;
poweroff->panic_nb.priority = INT_MAX;
atomic_notifier_chain_register(&panic_notifier_list,
&poweroff->panic_nb);
poweroff->reboot_nb.notifier_call = qcom_dload_reboot;
poweroff->reboot_nb.priority = 255;
register_reboot_notifier(&poweroff->reboot_nb);
platform_set_drvdata(pdev, poweroff);
return 0;
}
static int qcom_dload_remove(struct platform_device *pdev)
{
struct qcom_dload *poweroff = platform_get_drvdata(pdev);
atomic_notifier_chain_unregister(&panic_notifier_list,
&poweroff->panic_nb);
unregister_reboot_notifier(&poweroff->reboot_nb);
if (poweroff->dload_dest_addr)
iounmap(poweroff->dload_dest_addr);
return 0;
}
static const struct of_device_id of_qcom_dload_match[] = {
{ .compatible = "qcom,dload-mode", },
{},
};
MODULE_DEVICE_TABLE(of, of_qcom_dload_match);
static struct platform_driver qcom_dload_driver = {
.probe = qcom_dload_probe,
.remove = qcom_dload_remove,
.driver = {
.name = "qcom-dload-mode",
.of_match_table = of_match_ptr(of_qcom_dload_match),
},
};
static int __init qcom_dload_driver_init(void)
{
return platform_driver_register(&qcom_dload_driver);
}
#if IS_MODULE(CONFIG_POWER_RESET_QCOM_DOWNLOAD_MODE)
module_init(qcom_dload_driver_init);
#else
pure_initcall(qcom_dload_driver_init);
#endif
static void __exit qcom_dload_driver_exit(void)
{
return platform_driver_unregister(&qcom_dload_driver);
}
module_exit(qcom_dload_driver_exit);
MODULE_DESCRIPTION("MSM Download Mode Driver");
MODULE_LICENSE("GPL v2");
|