1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2023 Rockchip Electronics Co., Ltd.
5 */
6
7 #define pr_fmt(fmt) "Minidump: " fmt
8
9 #include <linux/init.h>
10 #include <linux/export.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/platform_device.h>
15 #include <linux/err.h>
16 #include <linux/elf.h>
17 #include <linux/errno.h>
18 #include <linux/string.h>
19 #include <linux/slab.h>
20 #include <linux/android_debug_symbols.h>
21 #include <linux/soc/qcom/smem.h>
22 #include <soc/rockchip/rk_minidump.h>
23 #include <linux/of_address.h>
24 #include <linux/proc_fs.h>
25 #include <asm/cacheflush.h>
26 #include "minidump_private.h"
27 #include "elf.h"
28
29 #define MAX_NUM_ENTRIES (CONFIG_ROCKCHIP_MINIDUMP_MAX_ENTRIES + 1)
30 #define MAX_STRTBL_SIZE (MAX_NUM_ENTRIES * MAX_REGION_NAME_LENGTH)
31
32 /**
33 * md_table : Local Minidump toc holder
34 * @num_regions : Number of regions requested
35 * @md_ss_toc : HLOS toc pointer
36 * @md_gbl_toc : Global toc pointer
37 * @md_regions : HLOS regions base pointer
38 * @entry : array of HLOS regions requested
39 */
40 struct md_table {
41 u32 revision;
42 u32 num_regions;
43 struct md_ss_toc *md_ss_toc;
44 struct md_global_toc *md_gbl_toc;
45 struct md_ss_region *md_regions;
46 struct md_region entry[MAX_NUM_ENTRIES];
47 };
48
49 /**
50 * md_elfhdr: Minidump table elf header
51 * @ehdr: elf main header
52 * @shdr: Section header
53 * @phdr: Program header
54 * @elf_offset: section offset in elf
55 * @strtable_idx: string table current index position
56 */
57 struct md_elfhdr {
58 struct elfhdr *ehdr;
59 struct elf_shdr *shdr;
60 struct elf_phdr *phdr;
61 u64 elf_offset;
62 u64 strtable_idx;
63 };
64
65 /* Protect elfheader and smem table from deferred calls contention */
66 static DEFINE_SPINLOCK(mdt_lock);
67 static DEFINE_RWLOCK(mdt_remove_lock);
68 static struct md_table minidump_table;
69 static struct md_elfhdr minidump_elfheader;
70 static int first_removed_entry = INT_MAX;
71 static bool md_init_done;
72 static void __iomem *md_elf_mem;
73 static resource_size_t md_elf_size;
74 static struct proc_dir_entry *proc_rk_minidump;
75
76 /* Number of pending entries to be added in ToC regions */
77 static unsigned int pendings;
78
elf_lookup_string(struct elfhdr * hdr,int offset)79 static inline char *elf_lookup_string(struct elfhdr *hdr, int offset)
80 {
81 char *strtab = elf_str_table(hdr);
82
83 if ((strtab == NULL) || (minidump_elfheader.strtable_idx < offset))
84 return NULL;
85 return strtab + offset;
86 }
87
set_section_name(const char * name)88 static inline unsigned int set_section_name(const char *name)
89 {
90 char *strtab = elf_str_table(minidump_elfheader.ehdr);
91 int idx = minidump_elfheader.strtable_idx;
92 int ret = 0;
93
94 if ((strtab == NULL) || (name == NULL))
95 return 0;
96
97 ret = idx;
98 idx += strscpy((strtab + idx), name, MAX_REGION_NAME_LENGTH);
99 minidump_elfheader.strtable_idx = idx + 1;
100
101 return ret;
102 }
103
md_get_region(char * name)104 struct md_region *md_get_region(char *name)
105 {
106 struct md_region *mdr;
107 int i, regno = minidump_table.num_regions;
108
109 for (i = 0; i < regno; i++) {
110 mdr = &minidump_table.entry[i];
111 if (!strcmp(mdr->name, name))
112 return mdr;
113 }
114 return NULL;
115 }
116
md_region_num(const char * name,int * seqno)117 static inline int md_region_num(const char *name, int *seqno)
118 {
119 struct md_ss_region *mde = minidump_table.md_regions;
120 int i, regno = minidump_table.md_ss_toc->ss_region_count;
121 int ret = -EINVAL;
122
123 for (i = 0; i < regno; i++, mde++) {
124 if (!strcmp(mde->name, name)) {
125 ret = i;
126 if (mde->seq_num > *seqno)
127 *seqno = mde->seq_num;
128 }
129 }
130 return ret;
131 }
132
md_entry_num(const struct md_region * entry)133 static inline int md_entry_num(const struct md_region *entry)
134 {
135 struct md_region *mdr;
136 int i, regno = minidump_table.num_regions;
137
138 for (i = 0; i < regno; i++) {
139 mdr = &minidump_table.entry[i];
140 if (!strcmp(mdr->name, entry->name))
141 return i;
142 }
143 return -ENOENT;
144 }
145
146 /* Update Mini dump table in SMEM */
md_update_ss_toc(const struct md_region * entry)147 static void md_update_ss_toc(const struct md_region *entry)
148 {
149 struct md_ss_region *mdr;
150 struct elfhdr *hdr = minidump_elfheader.ehdr;
151 struct elf_shdr *shdr = elf_section(hdr, hdr->e_shnum++);
152 struct elf_phdr *phdr = elf_program(hdr, hdr->e_phnum++);
153 int seq = 0, reg_cnt = minidump_table.md_ss_toc->ss_region_count;
154
155 mdr = &minidump_table.md_regions[reg_cnt];
156
157 strscpy(mdr->name, entry->name, sizeof(mdr->name));
158 mdr->region_base_address = entry->phys_addr;
159 mdr->region_size = entry->size;
160 if (md_region_num(entry->name, &seq) >= 0)
161 mdr->seq_num = seq + 1;
162
163 /* Update elf header */
164 shdr->sh_type = SHT_PROGBITS;
165 shdr->sh_name = set_section_name(mdr->name);
166 shdr->sh_addr = (elf_addr_t)entry->virt_addr;
167 shdr->sh_size = mdr->region_size;
168 shdr->sh_flags = SHF_WRITE;
169 shdr->sh_offset = minidump_elfheader.elf_offset;
170 shdr->sh_entsize = 0;
171
172 if (strstr((const char *)mdr->name, "note"))
173 phdr->p_type = PT_NOTE;
174 else
175 phdr->p_type = PT_LOAD;
176 phdr->p_offset = minidump_elfheader.elf_offset;
177 phdr->p_vaddr = entry->virt_addr;
178 phdr->p_paddr = entry->phys_addr;
179 phdr->p_filesz = phdr->p_memsz = mdr->region_size;
180 phdr->p_flags = PF_R | PF_W;
181 minidump_elfheader.elf_offset += shdr->sh_size;
182 mdr->md_valid = MD_REGION_VALID;
183 minidump_table.md_ss_toc->ss_region_count++;
184 }
185
rk_minidump_enabled(void)186 bool rk_minidump_enabled(void)
187 {
188 bool ret = false;
189 unsigned long flags;
190
191 spin_lock_irqsave(&mdt_lock, flags);
192 if (minidump_table.md_ss_toc &&
193 (minidump_table.md_ss_toc->md_ss_enable_status ==
194 MD_SS_ENABLED))
195 ret = true;
196 spin_unlock_irqrestore(&mdt_lock, flags);
197 return ret;
198 }
199 EXPORT_SYMBOL(rk_minidump_enabled);
200
validate_region(const struct md_region * entry)201 static inline int validate_region(const struct md_region *entry)
202 {
203 if (!entry)
204 return -EINVAL;
205
206 if ((strlen(entry->name) > MD_MAX_NAME_LENGTH) || !entry->virt_addr ||
207 (!IS_ALIGNED(entry->size, 4))) {
208 pr_err("Invalid entry details\n");
209 return -EINVAL;
210 }
211
212 return 0;
213 }
214
rk_minidump_update_region(int regno,const struct md_region * entry)215 int rk_minidump_update_region(int regno, const struct md_region *entry)
216 {
217 int ret = 0;
218 struct md_region *mdr;
219 struct md_ss_region *mdssr;
220 struct elfhdr *hdr = minidump_elfheader.ehdr;
221 struct elf_shdr *shdr;
222 struct elf_phdr *phdr;
223 unsigned long flags;
224
225 /* Ensure that init completes before we update regions */
226 if (!smp_load_acquire(&md_init_done))
227 return -EINVAL;
228
229 if (validate_region(entry) || (regno >= MAX_NUM_ENTRIES))
230 return -EINVAL;
231
232 read_lock_irqsave(&mdt_remove_lock, flags);
233
234 if (regno >= first_removed_entry) {
235 pr_err("Region:[%s] was moved\n", entry->name);
236 ret = -EINVAL;
237 goto err_unlock;
238 }
239
240 ret = md_entry_num(entry);
241 if (ret < 0) {
242 pr_err("Region:[%s] does not exist to update.\n", entry->name);
243 goto err_unlock;
244 }
245
246 mdr = &minidump_table.entry[regno];
247 mdr->virt_addr = entry->virt_addr;
248 mdr->phys_addr = entry->phys_addr;
249
250 mdssr = &minidump_table.md_regions[regno + 1];
251 mdssr->region_base_address = entry->phys_addr;
252
253 shdr = elf_section(hdr, regno + 4);
254 phdr = elf_program(hdr, regno + 1);
255
256 shdr->sh_addr = (elf_addr_t)entry->virt_addr;
257 phdr->p_vaddr = entry->virt_addr;
258 phdr->p_paddr = entry->phys_addr;
259
260 err_unlock:
261 read_unlock_irqrestore(&mdt_remove_lock, flags);
262 rk_md_flush_dcache_area((void *)entry, sizeof(*entry));
263 return ret;
264 }
265 EXPORT_SYMBOL(rk_minidump_update_region);
266
rk_minidump_add_region(const struct md_region * entry)267 int rk_minidump_add_region(const struct md_region *entry)
268 {
269 u32 entries;
270 u32 toc_init;
271 struct md_region *mdr;
272 unsigned long flags;
273
274 if (validate_region(entry))
275 return -EINVAL;
276
277 spin_lock_irqsave(&mdt_lock, flags);
278 if (md_entry_num(entry) >= 0) {
279 spin_unlock_irqrestore(&mdt_lock, flags);
280 pr_info("Entry name already exist.\n");
281 return -EEXIST;
282 }
283
284 entries = minidump_table.num_regions;
285 if (entries >= MAX_NUM_ENTRIES) {
286 pr_err("Maximum entries reached.\n");
287 spin_unlock_irqrestore(&mdt_lock, flags);
288 return -ENOMEM;
289 }
290
291 toc_init = 0;
292 if (minidump_table.md_ss_toc &&
293 (minidump_table.md_ss_toc->md_ss_enable_status ==
294 MD_SS_ENABLED)) {
295 toc_init = 1;
296 if (minidump_table.md_ss_toc->ss_region_count >= MAX_NUM_ENTRIES) {
297 spin_unlock_irqrestore(&mdt_lock, flags);
298 pr_err("Maximum regions in minidump table reached.\n");
299 return -ENOMEM;
300 }
301 }
302
303 mdr = &minidump_table.entry[entries];
304 strscpy(mdr->name, entry->name, sizeof(mdr->name));
305 mdr->virt_addr = entry->virt_addr;
306 mdr->phys_addr = entry->phys_addr;
307 mdr->size = entry->size;
308 mdr->id = entry->id;
309
310 minidump_table.num_regions = entries + 1;
311
312 if (toc_init)
313 md_update_ss_toc(entry);
314 else
315 pendings++;
316
317 spin_unlock_irqrestore(&mdt_lock, flags);
318
319 return entries;
320 }
321 EXPORT_SYMBOL(rk_minidump_add_region);
322
rk_minidump_clear_headers(const struct md_region * entry)323 int rk_minidump_clear_headers(const struct md_region *entry)
324 {
325 struct elfhdr *hdr = minidump_elfheader.ehdr;
326 struct elf_shdr *shdr = NULL, *tshdr = NULL;
327 struct elf_phdr *phdr = NULL, *tphdr = NULL;
328 int pidx, shidx, strln, i;
329 char *shname;
330 u64 esize;
331
332 esize = entry->size;
333 for (i = 0; i < hdr->e_phnum; i++) {
334 phdr = elf_program(hdr, i);
335 if ((phdr->p_paddr == entry->phys_addr) &&
336 (phdr->p_memsz == entry->size))
337 break;
338 }
339 if (i == hdr->e_phnum) {
340 pr_err("Cannot find entry in elf\n");
341 return -EINVAL;
342 }
343 pidx = i;
344
345 for (i = 0; i < hdr->e_shnum; i++) {
346 shdr = elf_section(hdr, i);
347 shname = elf_lookup_string(hdr, shdr->sh_name);
348 if (shname && !strcmp(shname, entry->name))
349 if ((shdr->sh_addr == entry->virt_addr) &&
350 (shdr->sh_size == entry->size))
351 break;
352
353 }
354 if (i == hdr->e_shnum) {
355 pr_err("Cannot find entry in elf\n");
356 return -EINVAL;
357 }
358 shidx = i;
359
360 if (shdr->sh_offset != phdr->p_offset) {
361 pr_err("Invalid entry details in elf, Minidump broken..\n");
362 return -EINVAL;
363 }
364
365 /* Clear name in string table */
366 strln = strlen(shname) + 1;
367 memmove(shname, shname + strln,
368 (minidump_elfheader.strtable_idx - shdr->sh_name));
369 minidump_elfheader.strtable_idx -= strln;
370
371 /* Clear program header */
372 tphdr = elf_program(hdr, pidx);
373 for (i = pidx; i < hdr->e_phnum - 1; i++) {
374 tphdr = elf_program(hdr, i + 1);
375 phdr = elf_program(hdr, i);
376 memcpy(phdr, tphdr, sizeof(struct elf_phdr));
377 phdr->p_offset = phdr->p_offset - esize;
378 }
379 memset(tphdr, 0, sizeof(struct elf_phdr));
380 hdr->e_phnum--;
381
382 /* Clear section header */
383 tshdr = elf_section(hdr, shidx);
384 for (i = shidx; i < hdr->e_shnum - 1; i++) {
385 tshdr = elf_section(hdr, i + 1);
386 shdr = elf_section(hdr, i);
387 memcpy(shdr, tshdr, sizeof(struct elf_shdr));
388 shdr->sh_offset -= esize;
389 shdr->sh_name -= strln;
390 }
391 memset(tshdr, 0, sizeof(struct elf_shdr));
392 hdr->e_shnum--;
393
394 minidump_elfheader.elf_offset -= esize;
395 return 0;
396 }
397
rk_minidump_remove_region(const struct md_region * entry)398 int rk_minidump_remove_region(const struct md_region *entry)
399 {
400 int rcount, ecount, seq = 0, rgno, entryno, ret;
401 unsigned long flags;
402
403 if (!entry || !minidump_table.md_ss_toc ||
404 (minidump_table.md_ss_toc->md_ss_enable_status !=
405 MD_SS_ENABLED))
406 return -EINVAL;
407
408 spin_lock_irqsave(&mdt_lock, flags);
409 write_lock(&mdt_remove_lock);
410 ret = md_entry_num(entry);
411 if (ret < 0) {
412 write_unlock(&mdt_remove_lock);
413 spin_unlock_irqrestore(&mdt_lock, flags);
414 pr_info("Not able to find the entry %s in table\n", entry->name);
415 return ret;
416 }
417 entryno = ret;
418 rgno = md_region_num(entry->name, &seq);
419 if (rgno < 0) {
420 write_unlock(&mdt_remove_lock);
421 spin_unlock_irqrestore(&mdt_lock, flags);
422 pr_err("Not able to find the region %s (%d,%d) in table\n",
423 entry->name, entryno, rgno);
424 return -EINVAL;
425 }
426 ecount = minidump_table.num_regions;
427 rcount = minidump_table.md_ss_toc->ss_region_count;
428 if (first_removed_entry > entryno)
429 first_removed_entry = entryno;
430 minidump_table.md_ss_toc->md_ss_toc_init = 0;
431
432 /* Remove entry from: entry list, ss region list and elf header */
433 memmove(&minidump_table.entry[entryno],
434 &minidump_table.entry[entryno + 1],
435 ((ecount - entryno - 1) * sizeof(struct md_region)));
436 memset(&minidump_table.entry[ecount - 1], 0, sizeof(struct md_region));
437
438
439 memmove(&minidump_table.md_regions[rgno],
440 &minidump_table.md_regions[rgno + 1],
441 ((rcount - rgno - 1) * sizeof(struct md_ss_region)));
442 memset(&minidump_table.md_regions[rcount - 1], 0,
443 sizeof(struct md_ss_region));
444
445 ret = rk_minidump_clear_headers(entry);
446 if (ret)
447 goto out;
448
449 minidump_table.md_ss_toc->ss_region_count--;
450 minidump_table.md_ss_toc->md_ss_toc_init = 1;
451 minidump_table.num_regions--;
452 out:
453 write_unlock(&mdt_remove_lock);
454 spin_unlock_irqrestore(&mdt_lock, flags);
455
456 if (ret)
457 pr_err("Minidump is broken..disable Minidump collection\n");
458 return ret;
459 }
460 EXPORT_SYMBOL(rk_minidump_remove_region);
461
rk_minidump_flush_elfheader(void)462 void rk_minidump_flush_elfheader(void)
463 {
464 rk_md_flush_dcache_area((void *)minidump_elfheader.ehdr, minidump_table.md_regions[0].region_size);
465 }
466
rk_minidump_add_header(void)467 static int rk_minidump_add_header(void)
468 {
469 struct md_ss_region *mdreg = &minidump_table.md_regions[0];
470 struct elfhdr *ehdr;
471 struct elf_shdr *shdr;
472 struct elf_phdr *phdr;
473 unsigned int strtbl_off, elfh_size, phdr_off;
474 char *banner, *linux_banner;
475 #ifdef CONFIG_ANDROID_DEBUG_SYMBOLS
476 linux_banner = android_debug_symbol(ADS_LINUX_BANNER);
477 #else
478 linux_banner = "This is rockchip minidump, welcome!";
479 #endif
480
481 /* Header buffer contains:
482 * elf header, MAX_NUM_ENTRIES+4 of section and program elf headers,
483 * string table section and linux banner.
484 */
485 elfh_size = sizeof(*ehdr) + MAX_STRTBL_SIZE +
486 (strlen(linux_banner) + 1) +
487 ((sizeof(*shdr) + sizeof(*phdr))
488 * (MAX_NUM_ENTRIES + 4));
489
490 elfh_size = ALIGN(elfh_size, 4);
491
492 minidump_elfheader.ehdr = kzalloc(elfh_size, GFP_KERNEL);
493 if (!minidump_elfheader.ehdr)
494 return -ENOMEM;
495
496 strscpy(mdreg->name, "KELF_HEADER", sizeof(mdreg->name));
497 mdreg->region_base_address = virt_to_phys(minidump_elfheader.ehdr);
498 mdreg->region_size = elfh_size;
499
500 ehdr = minidump_elfheader.ehdr;
501 /* Assign section/program headers offset */
502 minidump_elfheader.shdr = shdr = (struct elf_shdr *)(ehdr + 1);
503 minidump_elfheader.phdr = phdr =
504 (struct elf_phdr *)(shdr + MAX_NUM_ENTRIES);
505 phdr_off = sizeof(*ehdr) + (sizeof(*shdr) * MAX_NUM_ENTRIES);
506
507 memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
508 ehdr->e_ident[EI_CLASS] = ELF_CLASS;
509 ehdr->e_ident[EI_DATA] = ELF_DATA;
510 ehdr->e_ident[EI_VERSION] = EV_CURRENT;
511 ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
512 ehdr->e_type = ET_CORE;
513 ehdr->e_machine = ELF_ARCH;
514 ehdr->e_version = EV_CURRENT;
515 ehdr->e_ehsize = sizeof(*ehdr);
516 ehdr->e_phoff = phdr_off;
517 ehdr->e_phentsize = sizeof(*phdr);
518 ehdr->e_shoff = sizeof(*ehdr);
519 ehdr->e_shentsize = sizeof(*shdr);
520 ehdr->e_shstrndx = 1;
521
522 minidump_elfheader.elf_offset = elfh_size;
523
524 /*
525 * First section header should be NULL,
526 * 2nd section is string table.
527 */
528 minidump_elfheader.strtable_idx = 1;
529 strtbl_off = sizeof(*ehdr) +
530 ((sizeof(*phdr) + sizeof(*shdr)) * MAX_NUM_ENTRIES);
531 shdr++;
532 shdr->sh_type = SHT_STRTAB;
533 shdr->sh_offset = (elf_addr_t)strtbl_off;
534 shdr->sh_size = MAX_STRTBL_SIZE;
535 shdr->sh_entsize = 0;
536 shdr->sh_flags = 0;
537 shdr->sh_name = set_section_name("STR_TBL");
538 shdr++;
539
540 /* 3rd section is for minidump_table VA, used by parsers */
541 shdr->sh_type = SHT_PROGBITS;
542 shdr->sh_entsize = 0;
543 shdr->sh_flags = 0;
544 shdr->sh_addr = (elf_addr_t)&minidump_table;
545 shdr->sh_name = set_section_name("minidump_table");
546 shdr++;
547
548 /* 4th section is linux banner */
549 banner = (char *)ehdr + strtbl_off + MAX_STRTBL_SIZE;
550 strscpy(banner, linux_banner, MAX_STRTBL_SIZE);
551
552 shdr->sh_type = SHT_PROGBITS;
553 shdr->sh_offset = (elf_addr_t)(strtbl_off + MAX_STRTBL_SIZE);
554 shdr->sh_size = strlen(linux_banner) + 1;
555 shdr->sh_addr = (elf_addr_t)linux_banner;
556 shdr->sh_entsize = 0;
557 shdr->sh_flags = SHF_WRITE;
558 shdr->sh_name = set_section_name("linux_banner");
559
560 phdr->p_type = PT_LOAD;
561 phdr->p_offset = (elf_addr_t)(strtbl_off + MAX_STRTBL_SIZE);
562 phdr->p_vaddr = (elf_addr_t)linux_banner;
563 phdr->p_paddr = virt_to_phys(linux_banner);
564 phdr->p_filesz = phdr->p_memsz = strlen(linux_banner) + 1;
565 phdr->p_flags = PF_R | PF_W;
566
567 /* Update headers count*/
568 ehdr->e_phnum = 1;
569 ehdr->e_shnum = 4;
570
571 mdreg->md_valid = MD_REGION_VALID;
572 return 0;
573 }
574
rk_minidump_driver_remove(struct platform_device * pdev)575 static int rk_minidump_driver_remove(struct platform_device *pdev)
576 {
577 /* TO-DO.
578 *Free the required resources and set the global
579 * variables as minidump is not initialized.
580 */
581 return 0;
582 }
583
rk_minidump_read_elf(struct file * file,char __user * buffer,size_t buflen,loff_t * fpos)584 static ssize_t rk_minidump_read_elf(struct file *file, char __user *buffer,
585 size_t buflen, loff_t *fpos)
586 {
587 size_t size = 0;
588
589 size = simple_read_from_buffer(buffer, buflen, fpos, (const void *)md_elf_mem, md_elf_size);
590
591 return size;
592 }
593
594 static const struct proc_ops rk_minidump_proc_ops = {
595 .proc_read = rk_minidump_read_elf,
596 };
597
rk_minidump_driver_probe(struct platform_device * pdev)598 static int rk_minidump_driver_probe(struct platform_device *pdev)
599 {
600 unsigned int i;
601 struct md_region *mdr;
602 struct md_global_toc *md_global_toc;
603 struct md_ss_toc *md_ss_toc;
604 unsigned long flags;
605 struct device_node *np;
606 struct resource r;
607 resource_size_t r_size;
608 struct device *dev = &pdev->dev;
609 Elf64_Ehdr *ehdr; /* Elf header structure pointer */
610 Elf64_Phdr *phdr; /* Program header structure pointer */
611 int ret;
612 struct proc_dir_entry *base_dir = proc_mkdir("rk_md", NULL);
613
614 if (!base_dir) {
615 dev_err(dev, "Couldn't create base dir /proc/rk_md\n");
616 return -ENOMEM;
617 }
618
619 np = of_parse_phandle(dev->of_node, "smem-region", 0);
620 if (!np) {
621 dev_err(dev, "No smem-region specified\n");
622 return -EINVAL;
623 }
624 ret = of_address_to_resource(np, 0, &r);
625 of_node_put(np);
626 if (ret)
627 return ret;
628 r_size = resource_size(&r);
629 md_global_toc = devm_ioremap_wc(dev, r.start, r_size);
630 if (!md_global_toc) {
631 pr_err("unable to map memory region: %pa+%pa\n", &r.start, &r_size);
632 return -ENOMEM;
633 }
634
635 np = of_parse_phandle(dev->of_node, "minidump-region", 0);
636 if (!np) {
637 dev_err(dev, "No minidump-region specified\n");
638 return -EINVAL;
639 }
640
641 ret = of_address_to_resource(np, 0, &r);
642 of_node_put(np);
643 if (ret)
644 return ret;
645 r_size = resource_size(&r);
646 md_elf_mem = devm_ioremap_wc(dev, r.start, r_size);
647 if (!md_elf_mem) {
648 pr_err("unable to map memory region: %pa+%pa\n", &r.start, &r_size);
649 return -ENOMEM;
650 }
651
652 ehdr = (Elf64_Ehdr *)md_elf_mem;
653
654 if (!strncmp((const char *)ehdr, ELFMAG, 4)) {
655 phdr = (Elf64_Phdr *)(md_elf_mem + (ulong)ehdr->e_phoff);
656 phdr += ehdr->e_phnum - 1;
657 md_elf_size = phdr->p_memsz + phdr->p_offset;
658
659 pr_info("Create /proc/rk_md/minidump...\n");
660 proc_rk_minidump = proc_create("minidump", 0400, base_dir, &rk_minidump_proc_ops);
661 }
662
663 /* Check global minidump support initialization */
664 if (!md_global_toc->md_toc_init) {
665 pr_err("System Minidump TOC not initialized\n");
666 return -ENODEV;
667 }
668
669 minidump_table.md_gbl_toc = md_global_toc;
670 minidump_table.revision = md_global_toc->md_revision;
671 md_ss_toc = &md_global_toc->md_ss_toc[MD_SS_HLOS_ID];
672
673 md_ss_toc->encryption_status = MD_SS_ENCR_NONE;
674 md_ss_toc->encryption_required = MD_SS_ENCR_REQ;
675 md_ss_toc->elf_header = (u64)r.start;
676
677 minidump_table.md_ss_toc = md_ss_toc;
678 minidump_table.md_regions = devm_kzalloc(&pdev->dev, (MAX_NUM_ENTRIES *
679 sizeof(struct md_ss_region)), GFP_KERNEL);
680 if (!minidump_table.md_regions)
681 return -ENOMEM;
682
683 md_ss_toc->md_ss_smem_regions_baseptr =
684 virt_to_phys(minidump_table.md_regions);
685
686 /* First entry would be ELF header */
687 md_ss_toc->ss_region_count = 1;
688 rk_minidump_add_header();
689
690 /* Add pending entries to HLOS TOC */
691 spin_lock_irqsave(&mdt_lock, flags);
692 md_ss_toc->md_ss_toc_init = 1;
693 md_ss_toc->md_ss_enable_status = MD_SS_ENABLED;
694 for (i = 0; i < pendings; i++) {
695 mdr = &minidump_table.entry[i];
696 md_update_ss_toc(mdr);
697 }
698
699 pendings = 0;
700 spin_unlock_irqrestore(&mdt_lock, flags);
701
702 /* All updates above should be visible, before init completes */
703 smp_store_release(&md_init_done, true);
704 rk_minidump_log_init();
705 pr_info("Enabled with max number of regions %d\n",
706 CONFIG_ROCKCHIP_MINIDUMP_MAX_ENTRIES);
707
708 return 0;
709 }
710
711 static const struct of_device_id rk_minidump_of_match[] = {
712 { .compatible = "rockchip,minidump" },
713 { }
714 };
715 MODULE_DEVICE_TABLE(of, rk_minidump_of_match);
716
717 static struct platform_driver rk_minidump_driver = {
718 .driver = {
719 .name = "rockchip-minidump",
720 .of_match_table = rk_minidump_of_match,
721 },
722 .probe = rk_minidump_driver_probe,
723 .remove = rk_minidump_driver_remove,
724 };
725 module_platform_driver(rk_minidump_driver);
726
727 MODULE_DESCRIPTION("RK Mini Dump Driver");
728 MODULE_LICENSE("GPL");
729