1
2
3
4
5
6
7
8#define pr_fmt(fmt) "pseries-hotplug-mem: " fmt
9
10#include <linux/of.h>
11#include <linux/of_address.h>
12#include <linux/memblock.h>
13#include <linux/memory.h>
14#include <linux/memory_hotplug.h>
15#include <linux/slab.h>
16
17#include <asm/firmware.h>
18#include <asm/machdep.h>
19#include <asm/prom.h>
20#include <asm/sparsemem.h>
21#include <asm/fadump.h>
22#include <asm/drmem.h>
23#include "pseries.h"
24
25unsigned long pseries_memory_block_size(void)
26{
27 struct device_node *np;
28 u64 memblock_size = MIN_MEMORY_BLOCK_SIZE;
29 struct resource r;
30
31 np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
32 if (np) {
33 int len;
34 int size_cells;
35 const __be32 *prop;
36
37 size_cells = of_n_size_cells(np);
38
39 prop = of_get_property(np, "ibm,lmb-size", &len);
40 if (prop && len >= size_cells * sizeof(__be32))
41 memblock_size = of_read_number(prop, size_cells);
42 of_node_put(np);
43
44 } else if (machine_is(pseries)) {
45
46 unsigned int memzero_size = 0;
47
48 np = of_find_node_by_path("/memory@0");
49 if (np) {
50 if (!of_address_to_resource(np, 0, &r))
51 memzero_size = resource_size(&r);
52 of_node_put(np);
53 }
54
55 if (memzero_size) {
56
57
58
59 char buf[64];
60
61 sprintf(buf, "/memory@%x", memzero_size);
62 np = of_find_node_by_path(buf);
63 if (np) {
64 if (!of_address_to_resource(np, 0, &r))
65 memblock_size = resource_size(&r);
66 of_node_put(np);
67 }
68 }
69 }
70 return memblock_size;
71}
72
73static void dlpar_free_property(struct property *prop)
74{
75 kfree(prop->name);
76 kfree(prop->value);
77 kfree(prop);
78}
79
80static struct property *dlpar_clone_property(struct property *prop,
81 u32 prop_size)
82{
83 struct property *new_prop;
84
85 new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL);
86 if (!new_prop)
87 return NULL;
88
89 new_prop->name = kstrdup(prop->name, GFP_KERNEL);
90 new_prop->value = kzalloc(prop_size, GFP_KERNEL);
91 if (!new_prop->name || !new_prop->value) {
92 dlpar_free_property(new_prop);
93 return NULL;
94 }
95
96 memcpy(new_prop->value, prop->value, prop->length);
97 new_prop->length = prop_size;
98
99 of_property_set_flag(new_prop, OF_DYNAMIC);
100 return new_prop;
101}
102
103static bool find_aa_index(struct device_node *dr_node,
104 struct property *ala_prop,
105 const u32 *lmb_assoc, u32 *aa_index)
106{
107 u32 *assoc_arrays, new_prop_size;
108 struct property *new_prop;
109 int aa_arrays, aa_array_entries, aa_array_sz;
110 int i, index;
111
112
113
114
115
116
117
118 assoc_arrays = ala_prop->value;
119
120 aa_arrays = be32_to_cpu(assoc_arrays[0]);
121 aa_array_entries = be32_to_cpu(assoc_arrays[1]);
122 aa_array_sz = aa_array_entries * sizeof(u32);
123
124 for (i = 0; i < aa_arrays; i++) {
125 index = (i * aa_array_entries) + 2;
126
127 if (memcmp(&assoc_arrays[index], &lmb_assoc[1], aa_array_sz))
128 continue;
129
130 *aa_index = i;
131 return true;
132 }
133
134 new_prop_size = ala_prop->length + aa_array_sz;
135 new_prop = dlpar_clone_property(ala_prop, new_prop_size);
136 if (!new_prop)
137 return false;
138
139 assoc_arrays = new_prop->value;
140
141
142 assoc_arrays[0] = cpu_to_be32(aa_arrays + 1);
143
144
145 index = aa_arrays * aa_array_entries + 2;
146 memcpy(&assoc_arrays[index], &lmb_assoc[1], aa_array_sz);
147
148 of_update_property(dr_node, new_prop);
149
150
151
152
153
154
155 *aa_index = be32_to_cpu(assoc_arrays[0]) - 1;
156 return true;
157}
158
159static int update_lmb_associativity_index(struct drmem_lmb *lmb)
160{
161 struct device_node *parent, *lmb_node, *dr_node;
162 struct property *ala_prop;
163 const u32 *lmb_assoc;
164 u32 aa_index;
165 bool found;
166
167 parent = of_find_node_by_path("/");
168 if (!parent)
169 return -ENODEV;
170
171 lmb_node = dlpar_configure_connector(cpu_to_be32(lmb->drc_index),
172 parent);
173 of_node_put(parent);
174 if (!lmb_node)
175 return -EINVAL;
176
177 lmb_assoc = of_get_property(lmb_node, "ibm,associativity", NULL);
178 if (!lmb_assoc) {
179 dlpar_free_cc_nodes(lmb_node);
180 return -ENODEV;
181 }
182
183 dr_node = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
184 if (!dr_node) {
185 dlpar_free_cc_nodes(lmb_node);
186 return -ENODEV;
187 }
188
189 ala_prop = of_find_property(dr_node, "ibm,associativity-lookup-arrays",
190 NULL);
191 if (!ala_prop) {
192 of_node_put(dr_node);
193 dlpar_free_cc_nodes(lmb_node);
194 return -ENODEV;
195 }
196
197 found = find_aa_index(dr_node, ala_prop, lmb_assoc, &aa_index);
198
199 of_node_put(dr_node);
200 dlpar_free_cc_nodes(lmb_node);
201
202 if (!found) {
203 pr_err("Could not find LMB associativity\n");
204 return -1;
205 }
206
207 lmb->aa_index = aa_index;
208 return 0;
209}
210
211static struct memory_block *lmb_to_memblock(struct drmem_lmb *lmb)
212{
213 unsigned long section_nr;
214 struct mem_section *mem_sect;
215 struct memory_block *mem_block;
216
217 section_nr = pfn_to_section_nr(PFN_DOWN(lmb->base_addr));
218 mem_sect = __nr_to_section(section_nr);
219
220 mem_block = find_memory_block(mem_sect);
221 return mem_block;
222}
223
224static int get_lmb_range(u32 drc_index, int n_lmbs,
225 struct drmem_lmb **start_lmb,
226 struct drmem_lmb **end_lmb)
227{
228 struct drmem_lmb *lmb, *start, *end;
229 struct drmem_lmb *limit;
230
231 start = NULL;
232 for_each_drmem_lmb(lmb) {
233 if (lmb->drc_index == drc_index) {
234 start = lmb;
235 break;
236 }
237 }
238
239 if (!start)
240 return -EINVAL;
241
242 end = &start[n_lmbs];
243
244 limit = &drmem_info->lmbs[drmem_info->n_lmbs];
245 if (end > limit)
246 return -EINVAL;
247
248 *start_lmb = start;
249 *end_lmb = end;
250 return 0;
251}
252
253static int dlpar_change_lmb_state(struct drmem_lmb *lmb, bool online)
254{
255 struct memory_block *mem_block;
256 int rc;
257
258 mem_block = lmb_to_memblock(lmb);
259 if (!mem_block)
260 return -EINVAL;
261
262 if (online && mem_block->dev.offline)
263 rc = device_online(&mem_block->dev);
264 else if (!online && !mem_block->dev.offline)
265 rc = device_offline(&mem_block->dev);
266 else
267 rc = 0;
268
269 put_device(&mem_block->dev);
270
271 return rc;
272}
273
274static int dlpar_online_lmb(struct drmem_lmb *lmb)
275{
276 return dlpar_change_lmb_state(lmb, true);
277}
278
279#ifdef CONFIG_MEMORY_HOTREMOVE
280static int dlpar_offline_lmb(struct drmem_lmb *lmb)
281{
282 return dlpar_change_lmb_state(lmb, false);
283}
284
285static int pseries_remove_memblock(unsigned long base, unsigned long memblock_size)
286{
287 unsigned long block_sz, start_pfn;
288 int sections_per_block;
289 int i, nid;
290
291 start_pfn = base >> PAGE_SHIFT;
292
293 lock_device_hotplug();
294
295 if (!pfn_valid(start_pfn))
296 goto out;
297
298 block_sz = pseries_memory_block_size();
299 sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
300 nid = memory_add_physaddr_to_nid(base);
301
302 for (i = 0; i < sections_per_block; i++) {
303 __remove_memory(nid, base, MIN_MEMORY_BLOCK_SIZE);
304 base += MIN_MEMORY_BLOCK_SIZE;
305 }
306
307out:
308
309 memblock_remove(base, memblock_size);
310 unlock_device_hotplug();
311 return 0;
312}
313
314static int pseries_remove_mem_node(struct device_node *np)
315{
316 const __be32 *prop;
317 unsigned long base;
318 unsigned long lmb_size;
319 int ret = -EINVAL;
320 int addr_cells, size_cells;
321
322
323
324
325 if (!of_node_is_type(np, "memory"))
326 return 0;
327
328
329
330
331 prop = of_get_property(np, "reg", NULL);
332 if (!prop)
333 return ret;
334
335 addr_cells = of_n_addr_cells(np);
336 size_cells = of_n_size_cells(np);
337
338
339
340
341 base = of_read_number(prop, addr_cells);
342 prop += addr_cells;
343 lmb_size = of_read_number(prop, size_cells);
344
345 pseries_remove_memblock(base, lmb_size);
346 return 0;
347}
348
349static bool lmb_is_removable(struct drmem_lmb *lmb)
350{
351 if (!(lmb->flags & DRCONF_MEM_ASSIGNED))
352 return false;
353
354#ifdef CONFIG_FA_DUMP
355
356
357
358
359 if (is_fadump_memory_area(lmb->base_addr, memory_block_size_bytes()))
360 return false;
361#endif
362
363 return true;
364}
365
366static int dlpar_add_lmb(struct drmem_lmb *);
367
368static int dlpar_remove_lmb(struct drmem_lmb *lmb)
369{
370 struct memory_block *mem_block;
371 unsigned long block_sz;
372 int rc;
373
374 if (!lmb_is_removable(lmb))
375 return -EINVAL;
376
377 mem_block = lmb_to_memblock(lmb);
378 if (mem_block == NULL)
379 return -EINVAL;
380
381 rc = dlpar_offline_lmb(lmb);
382 if (rc) {
383 put_device(&mem_block->dev);
384 return rc;
385 }
386
387 block_sz = pseries_memory_block_size();
388
389 __remove_memory(mem_block->nid, lmb->base_addr, block_sz);
390 put_device(&mem_block->dev);
391
392
393 memblock_remove(lmb->base_addr, block_sz);
394
395 invalidate_lmb_associativity_index(lmb);
396 lmb->flags &= ~DRCONF_MEM_ASSIGNED;
397
398 return 0;
399}
400
401static int dlpar_memory_remove_by_count(u32 lmbs_to_remove)
402{
403 struct drmem_lmb *lmb;
404 int lmbs_removed = 0;
405 int lmbs_available = 0;
406 int rc;
407
408 pr_info("Attempting to hot-remove %d LMB(s)\n", lmbs_to_remove);
409
410 if (lmbs_to_remove == 0)
411 return -EINVAL;
412
413
414 for_each_drmem_lmb(lmb) {
415 if (lmb_is_removable(lmb))
416 lmbs_available++;
417
418 if (lmbs_available == lmbs_to_remove)
419 break;
420 }
421
422 if (lmbs_available < lmbs_to_remove) {
423 pr_info("Not enough LMBs available (%d of %d) to satisfy request\n",
424 lmbs_available, lmbs_to_remove);
425 return -EINVAL;
426 }
427
428 for_each_drmem_lmb(lmb) {
429 rc = dlpar_remove_lmb(lmb);
430 if (rc)
431 continue;
432
433
434
435
436 drmem_mark_lmb_reserved(lmb);
437
438 lmbs_removed++;
439 if (lmbs_removed == lmbs_to_remove)
440 break;
441 }
442
443 if (lmbs_removed != lmbs_to_remove) {
444 pr_err("Memory hot-remove failed, adding LMB's back\n");
445
446 for_each_drmem_lmb(lmb) {
447 if (!drmem_lmb_reserved(lmb))
448 continue;
449
450 rc = dlpar_add_lmb(lmb);
451 if (rc)
452 pr_err("Failed to add LMB back, drc index %x\n",
453 lmb->drc_index);
454
455 drmem_remove_lmb_reservation(lmb);
456 }
457
458 rc = -EINVAL;
459 } else {
460 for_each_drmem_lmb(lmb) {
461 if (!drmem_lmb_reserved(lmb))
462 continue;
463
464 dlpar_release_drc(lmb->drc_index);
465 pr_info("Memory at %llx was hot-removed\n",
466 lmb->base_addr);
467
468 drmem_remove_lmb_reservation(lmb);
469 }
470 rc = 0;
471 }
472
473 return rc;
474}
475
476static int dlpar_memory_remove_by_index(u32 drc_index)
477{
478 struct drmem_lmb *lmb;
479 int lmb_found;
480 int rc;
481
482 pr_debug("Attempting to hot-remove LMB, drc index %x\n", drc_index);
483
484 lmb_found = 0;
485 for_each_drmem_lmb(lmb) {
486 if (lmb->drc_index == drc_index) {
487 lmb_found = 1;
488 rc = dlpar_remove_lmb(lmb);
489 if (!rc)
490 dlpar_release_drc(lmb->drc_index);
491
492 break;
493 }
494 }
495
496 if (!lmb_found)
497 rc = -EINVAL;
498
499 if (rc)
500 pr_debug("Failed to hot-remove memory at %llx\n",
501 lmb->base_addr);
502 else
503 pr_debug("Memory at %llx was hot-removed\n", lmb->base_addr);
504
505 return rc;
506}
507
508static int dlpar_memory_remove_by_ic(u32 lmbs_to_remove, u32 drc_index)
509{
510 struct drmem_lmb *lmb, *start_lmb, *end_lmb;
511 int lmbs_available = 0;
512 int rc;
513
514 pr_info("Attempting to hot-remove %u LMB(s) at %x\n",
515 lmbs_to_remove, drc_index);
516
517 if (lmbs_to_remove == 0)
518 return -EINVAL;
519
520 rc = get_lmb_range(drc_index, lmbs_to_remove, &start_lmb, &end_lmb);
521 if (rc)
522 return -EINVAL;
523
524
525 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
526 if (lmb->flags & DRCONF_MEM_RESERVED)
527 break;
528
529 lmbs_available++;
530 }
531
532 if (lmbs_available < lmbs_to_remove)
533 return -EINVAL;
534
535 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
536 if (!(lmb->flags & DRCONF_MEM_ASSIGNED))
537 continue;
538
539 rc = dlpar_remove_lmb(lmb);
540 if (rc)
541 break;
542
543 drmem_mark_lmb_reserved(lmb);
544 }
545
546 if (rc) {
547 pr_err("Memory indexed-count-remove failed, adding any removed LMBs\n");
548
549
550 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
551 if (!drmem_lmb_reserved(lmb))
552 continue;
553
554 rc = dlpar_add_lmb(lmb);
555 if (rc)
556 pr_err("Failed to add LMB, drc index %x\n",
557 lmb->drc_index);
558
559 drmem_remove_lmb_reservation(lmb);
560 }
561 rc = -EINVAL;
562 } else {
563 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
564 if (!drmem_lmb_reserved(lmb))
565 continue;
566
567 dlpar_release_drc(lmb->drc_index);
568 pr_info("Memory at %llx (drc index %x) was hot-removed\n",
569 lmb->base_addr, lmb->drc_index);
570
571 drmem_remove_lmb_reservation(lmb);
572 }
573 }
574
575 return rc;
576}
577
578#else
579static inline int pseries_remove_memblock(unsigned long base,
580 unsigned long memblock_size)
581{
582 return -EOPNOTSUPP;
583}
584static inline int pseries_remove_mem_node(struct device_node *np)
585{
586 return 0;
587}
588static inline int dlpar_memory_remove(struct pseries_hp_errorlog *hp_elog)
589{
590 return -EOPNOTSUPP;
591}
592static int dlpar_remove_lmb(struct drmem_lmb *lmb)
593{
594 return -EOPNOTSUPP;
595}
596static int dlpar_memory_remove_by_count(u32 lmbs_to_remove)
597{
598 return -EOPNOTSUPP;
599}
600static int dlpar_memory_remove_by_index(u32 drc_index)
601{
602 return -EOPNOTSUPP;
603}
604
605static int dlpar_memory_remove_by_ic(u32 lmbs_to_remove, u32 drc_index)
606{
607 return -EOPNOTSUPP;
608}
609#endif
610
611static int dlpar_add_lmb(struct drmem_lmb *lmb)
612{
613 unsigned long block_sz;
614 int nid, rc;
615
616 if (lmb->flags & DRCONF_MEM_ASSIGNED)
617 return -EINVAL;
618
619 rc = update_lmb_associativity_index(lmb);
620 if (rc) {
621 dlpar_release_drc(lmb->drc_index);
622 return rc;
623 }
624
625 block_sz = memory_block_size_bytes();
626
627
628 nid = of_drconf_to_nid_single(lmb);
629 if (nid < 0 || !node_possible(nid))
630 nid = first_online_node;
631
632
633 rc = __add_memory(nid, lmb->base_addr, block_sz, MHP_NONE);
634 if (rc) {
635 invalidate_lmb_associativity_index(lmb);
636 return rc;
637 }
638
639 rc = dlpar_online_lmb(lmb);
640 if (rc) {
641 __remove_memory(nid, lmb->base_addr, block_sz);
642 invalidate_lmb_associativity_index(lmb);
643 } else {
644 lmb->flags |= DRCONF_MEM_ASSIGNED;
645 }
646
647 return rc;
648}
649
650static int dlpar_memory_add_by_count(u32 lmbs_to_add)
651{
652 struct drmem_lmb *lmb;
653 int lmbs_available = 0;
654 int lmbs_added = 0;
655 int rc;
656
657 pr_info("Attempting to hot-add %d LMB(s)\n", lmbs_to_add);
658
659 if (lmbs_to_add == 0)
660 return -EINVAL;
661
662
663 for_each_drmem_lmb(lmb) {
664 if (!(lmb->flags & DRCONF_MEM_ASSIGNED))
665 lmbs_available++;
666
667 if (lmbs_available == lmbs_to_add)
668 break;
669 }
670
671 if (lmbs_available < lmbs_to_add)
672 return -EINVAL;
673
674 for_each_drmem_lmb(lmb) {
675 if (lmb->flags & DRCONF_MEM_ASSIGNED)
676 continue;
677
678 rc = dlpar_acquire_drc(lmb->drc_index);
679 if (rc)
680 continue;
681
682 rc = dlpar_add_lmb(lmb);
683 if (rc) {
684 dlpar_release_drc(lmb->drc_index);
685 continue;
686 }
687
688
689
690
691 drmem_mark_lmb_reserved(lmb);
692
693 lmbs_added++;
694 if (lmbs_added == lmbs_to_add)
695 break;
696 }
697
698 if (lmbs_added != lmbs_to_add) {
699 pr_err("Memory hot-add failed, removing any added LMBs\n");
700
701 for_each_drmem_lmb(lmb) {
702 if (!drmem_lmb_reserved(lmb))
703 continue;
704
705 rc = dlpar_remove_lmb(lmb);
706 if (rc)
707 pr_err("Failed to remove LMB, drc index %x\n",
708 lmb->drc_index);
709 else
710 dlpar_release_drc(lmb->drc_index);
711
712 drmem_remove_lmb_reservation(lmb);
713 }
714 rc = -EINVAL;
715 } else {
716 for_each_drmem_lmb(lmb) {
717 if (!drmem_lmb_reserved(lmb))
718 continue;
719
720 pr_debug("Memory at %llx (drc index %x) was hot-added\n",
721 lmb->base_addr, lmb->drc_index);
722 drmem_remove_lmb_reservation(lmb);
723 }
724 rc = 0;
725 }
726
727 return rc;
728}
729
730static int dlpar_memory_add_by_index(u32 drc_index)
731{
732 struct drmem_lmb *lmb;
733 int rc, lmb_found;
734
735 pr_info("Attempting to hot-add LMB, drc index %x\n", drc_index);
736
737 lmb_found = 0;
738 for_each_drmem_lmb(lmb) {
739 if (lmb->drc_index == drc_index) {
740 lmb_found = 1;
741 rc = dlpar_acquire_drc(lmb->drc_index);
742 if (!rc) {
743 rc = dlpar_add_lmb(lmb);
744 if (rc)
745 dlpar_release_drc(lmb->drc_index);
746 }
747
748 break;
749 }
750 }
751
752 if (!lmb_found)
753 rc = -EINVAL;
754
755 if (rc)
756 pr_info("Failed to hot-add memory, drc index %x\n", drc_index);
757 else
758 pr_info("Memory at %llx (drc index %x) was hot-added\n",
759 lmb->base_addr, drc_index);
760
761 return rc;
762}
763
764static int dlpar_memory_add_by_ic(u32 lmbs_to_add, u32 drc_index)
765{
766 struct drmem_lmb *lmb, *start_lmb, *end_lmb;
767 int lmbs_available = 0;
768 int rc;
769
770 pr_info("Attempting to hot-add %u LMB(s) at index %x\n",
771 lmbs_to_add, drc_index);
772
773 if (lmbs_to_add == 0)
774 return -EINVAL;
775
776 rc = get_lmb_range(drc_index, lmbs_to_add, &start_lmb, &end_lmb);
777 if (rc)
778 return -EINVAL;
779
780
781 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
782 if (lmb->flags & DRCONF_MEM_RESERVED)
783 break;
784
785 lmbs_available++;
786 }
787
788 if (lmbs_available < lmbs_to_add)
789 return -EINVAL;
790
791 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
792 if (lmb->flags & DRCONF_MEM_ASSIGNED)
793 continue;
794
795 rc = dlpar_acquire_drc(lmb->drc_index);
796 if (rc)
797 break;
798
799 rc = dlpar_add_lmb(lmb);
800 if (rc) {
801 dlpar_release_drc(lmb->drc_index);
802 break;
803 }
804
805 drmem_mark_lmb_reserved(lmb);
806 }
807
808 if (rc) {
809 pr_err("Memory indexed-count-add failed, removing any added LMBs\n");
810
811 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
812 if (!drmem_lmb_reserved(lmb))
813 continue;
814
815 rc = dlpar_remove_lmb(lmb);
816 if (rc)
817 pr_err("Failed to remove LMB, drc index %x\n",
818 lmb->drc_index);
819 else
820 dlpar_release_drc(lmb->drc_index);
821
822 drmem_remove_lmb_reservation(lmb);
823 }
824 rc = -EINVAL;
825 } else {
826 for_each_drmem_lmb_in_range(lmb, start_lmb, end_lmb) {
827 if (!drmem_lmb_reserved(lmb))
828 continue;
829
830 pr_info("Memory at %llx (drc index %x) was hot-added\n",
831 lmb->base_addr, lmb->drc_index);
832 drmem_remove_lmb_reservation(lmb);
833 }
834 }
835
836 return rc;
837}
838
839int dlpar_memory(struct pseries_hp_errorlog *hp_elog)
840{
841 u32 count, drc_index;
842 int rc;
843
844 lock_device_hotplug();
845
846 switch (hp_elog->action) {
847 case PSERIES_HP_ELOG_ACTION_ADD:
848 switch (hp_elog->id_type) {
849 case PSERIES_HP_ELOG_ID_DRC_COUNT:
850 count = hp_elog->_drc_u.drc_count;
851 rc = dlpar_memory_add_by_count(count);
852 break;
853 case PSERIES_HP_ELOG_ID_DRC_INDEX:
854 drc_index = hp_elog->_drc_u.drc_index;
855 rc = dlpar_memory_add_by_index(drc_index);
856 break;
857 case PSERIES_HP_ELOG_ID_DRC_IC:
858 count = hp_elog->_drc_u.ic.count;
859 drc_index = hp_elog->_drc_u.ic.index;
860 rc = dlpar_memory_add_by_ic(count, drc_index);
861 break;
862 default:
863 rc = -EINVAL;
864 break;
865 }
866
867 break;
868 case PSERIES_HP_ELOG_ACTION_REMOVE:
869 switch (hp_elog->id_type) {
870 case PSERIES_HP_ELOG_ID_DRC_COUNT:
871 count = hp_elog->_drc_u.drc_count;
872 rc = dlpar_memory_remove_by_count(count);
873 break;
874 case PSERIES_HP_ELOG_ID_DRC_INDEX:
875 drc_index = hp_elog->_drc_u.drc_index;
876 rc = dlpar_memory_remove_by_index(drc_index);
877 break;
878 case PSERIES_HP_ELOG_ID_DRC_IC:
879 count = hp_elog->_drc_u.ic.count;
880 drc_index = hp_elog->_drc_u.ic.index;
881 rc = dlpar_memory_remove_by_ic(count, drc_index);
882 break;
883 default:
884 rc = -EINVAL;
885 break;
886 }
887
888 break;
889 default:
890 pr_err("Invalid action (%d) specified\n", hp_elog->action);
891 rc = -EINVAL;
892 break;
893 }
894
895 if (!rc)
896 rc = drmem_update_dt();
897
898 unlock_device_hotplug();
899 return rc;
900}
901
902static int pseries_add_mem_node(struct device_node *np)
903{
904 const __be32 *prop;
905 unsigned long base;
906 unsigned long lmb_size;
907 int ret = -EINVAL;
908 int addr_cells, size_cells;
909
910
911
912
913 if (!of_node_is_type(np, "memory"))
914 return 0;
915
916
917
918
919 prop = of_get_property(np, "reg", NULL);
920 if (!prop)
921 return ret;
922
923 addr_cells = of_n_addr_cells(np);
924 size_cells = of_n_size_cells(np);
925
926
927
928 base = of_read_number(prop, addr_cells);
929 prop += addr_cells;
930 lmb_size = of_read_number(prop, size_cells);
931
932
933
934
935 ret = memblock_add(base, lmb_size);
936 return (ret < 0) ? -EINVAL : 0;
937}
938
939static int pseries_memory_notifier(struct notifier_block *nb,
940 unsigned long action, void *data)
941{
942 struct of_reconfig_data *rd = data;
943 int err = 0;
944
945 switch (action) {
946 case OF_RECONFIG_ATTACH_NODE:
947 err = pseries_add_mem_node(rd->dn);
948 break;
949 case OF_RECONFIG_DETACH_NODE:
950 err = pseries_remove_mem_node(rd->dn);
951 break;
952 }
953 return notifier_from_errno(err);
954}
955
956static struct notifier_block pseries_mem_nb = {
957 .notifier_call = pseries_memory_notifier,
958};
959
960static int __init pseries_memory_hotplug_init(void)
961{
962 if (firmware_has_feature(FW_FEATURE_LPAR))
963 of_reconfig_notifier_register(&pseries_mem_nb);
964
965 return 0;
966}
967machine_device_initcall(pseries, pseries_memory_hotplug_init);
968