enable docker ppp

hc

2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87

 kernel/arch/powerpc/mm/drmem.c
..
..
@@ -1,12 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * Dynamic reconfiguration memory support
3
4
  *
4
5
  * Copyright 2017 IBM Corporation
5
- *
6
- * This program is free software; you can redistribute it and/or
7
- * modify it under the terms of the GNU General Public License
8
- * as published by the Free Software Foundation; either version
9
- * 2 of the License, or (at your option) any later version.
10
6
  */
11
7
 
12
8
 #define pr_fmt(fmt) "drmem: " fmt
..
..
@@ -17,6 +13,8 @@
17
13
 #include <linux/memblock.h>
18
14
 #include <asm/prom.h>
19
15
 #include <asm/drmem.h>
16
+
17
+static int n_root_addr_cells, n_root_size_cells;
20
18
 
21
19
 static struct drmem_lmb_info __drmem_info;
22
20
 struct drmem_lmb_info *drmem_info = &__drmem_info;
..
..
@@ -193,12 +191,13 @@
193
191
 	return rc;
194
192
 }
195
193
 
196
-static void __init read_drconf_v1_cell(struct drmem_lmb *lmb,
194
+static void read_drconf_v1_cell(struct drmem_lmb *lmb,
197
195
 				       const __be32 **prop)
198
196
 {
199
197
 	const __be32 *p = *prop;
200
198
 
201
-	lmb->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
199
+	lmb->base_addr = of_read_number(p, n_root_addr_cells);
200
+	p += n_root_addr_cells;
202
201
 	lmb->drc_index = of_read_number(p++, 1);
203
202
 
204
203
 	p++; /* skip reserved field */
..
..
@@ -209,29 +208,33 @@
209
208
 	*prop = p;
210
209
 }
211
210
 
212
-static void __init __walk_drmem_v1_lmbs(const __be32 *prop, const __be32 *usm,
213
-			void (*func)(struct drmem_lmb *, const __be32 **))
211
+static int
212
+__walk_drmem_v1_lmbs(const __be32 *prop, const __be32 *usm, void *data,
213
+		     int (*func)(struct drmem_lmb *, const __be32 **, void *))
214
214
 {
215
215
 	struct drmem_lmb lmb;
216
216
 	u32 i, n_lmbs;
217
+	int ret = 0;
217
218
 
218
219
 	n_lmbs = of_read_number(prop++, 1);
219
-	if (n_lmbs == 0)
220
-		return;
221
-
222
220
 	for (i = 0; i < n_lmbs; i++) {
223
221
 		read_drconf_v1_cell(&lmb, &prop);
224
-		func(&lmb, &usm);
222
+		ret = func(&lmb, &usm, data);
223
+		if (ret)
224
+			break;
225
225
 	}
226
+
227
+	return ret;
226
228
 }
227
229
 
228
-static void __init read_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
230
+static void read_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
229
231
 				       const __be32 **prop)
230
232
 {
231
233
 	const __be32 *p = *prop;
232
234
 
233
235
 	dr_cell->seq_lmbs = of_read_number(p++, 1);
234
-	dr_cell->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
236
+	dr_cell->base_addr = of_read_number(p, n_root_addr_cells);
237
+	p += n_root_addr_cells;
235
238
 	dr_cell->drc_index = of_read_number(p++, 1);
236
239
 	dr_cell->aa_index = of_read_number(p++, 1);
237
240
 	dr_cell->flags = of_read_number(p++, 1);
..
..
@@ -239,17 +242,16 @@
239
242
 	*prop = p;
240
243
 }
241
244
 
242
-static void __init __walk_drmem_v2_lmbs(const __be32 *prop, const __be32 *usm,
243
-			void (*func)(struct drmem_lmb *, const __be32 **))
245
+static int
246
+__walk_drmem_v2_lmbs(const __be32 *prop, const __be32 *usm, void *data,
247
+		     int (*func)(struct drmem_lmb *, const __be32 **, void *))
244
248
 {
245
249
 	struct of_drconf_cell_v2 dr_cell;
246
250
 	struct drmem_lmb lmb;
247
251
 	u32 i, j, lmb_sets;
252
+	int ret = 0;
248
253
 
249
254
 	lmb_sets = of_read_number(prop++, 1);
250
-	if (lmb_sets == 0)
251
-		return;
252
-
253
255
 	for (i = 0; i < lmb_sets; i++) {
254
256
 		read_drconf_v2_cell(&dr_cell, &prop);
255
257
 
..
..
@@ -263,21 +265,29 @@
263
265
 			lmb.aa_index = dr_cell.aa_index;
264
266
 			lmb.flags = dr_cell.flags;
265
267
 
266
-			func(&lmb, &usm);
268
+			ret = func(&lmb, &usm, data);
269
+			if (ret)
270
+				break;
267
271
 		}
268
272
 	}
273
+
274
+	return ret;
269
275
 }
270
276
 
271
277
 #ifdef CONFIG_PPC_PSERIES
272
-void __init walk_drmem_lmbs_early(unsigned long node,
273
-			void (*func)(struct drmem_lmb *, const __be32 **))
278
+int __init walk_drmem_lmbs_early(unsigned long node, void *data,
279
+		int (*func)(struct drmem_lmb *, const __be32 **, void *))
274
280
 {
275
281
 	const __be32 *prop, *usm;
276
-	int len;
282
+	int len, ret = -ENODEV;
277
283
 
278
284
 	prop = of_get_flat_dt_prop(node, "ibm,lmb-size", &len);
279
285
 	if (!prop || len < dt_root_size_cells * sizeof(__be32))
280
-		return;
286
+		return ret;
287
+
288
+	/* Get the address & size cells */
289
+	n_root_addr_cells = dt_root_addr_cells;
290
+	n_root_size_cells = dt_root_size_cells;
281
291
 
282
292
 	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);
283
293
 
..
..
@@ -285,20 +295,21 @@
285
295
 
286
296
 	prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &len);
287
297
 	if (prop) {
288
-		__walk_drmem_v1_lmbs(prop, usm, func);
298
+		ret = __walk_drmem_v1_lmbs(prop, usm, data, func);
289
299
 	} else {
290
300
 		prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory-v2",
291
301
 					   &len);
292
302
 		if (prop)
293
-			__walk_drmem_v2_lmbs(prop, usm, func);
303
+			ret = __walk_drmem_v2_lmbs(prop, usm, data, func);
294
304
 	}
295
305
 
296
306
 	memblock_dump_all();
307
+	return ret;
297
308
 }
298
309
 
299
310
 #endif
300
311
 
301
-static int __init init_drmem_lmb_size(struct device_node *dn)
312
+static int init_drmem_lmb_size(struct device_node *dn)
302
313
 {
303
314
 	const __be32 *prop;
304
315
 	int len;
..
..
@@ -307,12 +318,12 @@
307
318
 		return 0;
308
319
 
309
320
 	prop = of_get_property(dn, "ibm,lmb-size", &len);
310
-	if (!prop || len < dt_root_size_cells * sizeof(__be32)) {
321
+	if (!prop || len < n_root_size_cells * sizeof(__be32)) {
311
322
 		pr_info("Could not determine LMB size\n");
312
323
 		return -1;
313
324
 	}
314
325
 
315
-	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);
326
+	drmem_info->lmb_size = of_read_number(prop, n_root_size_cells);
316
327
 	return 0;
317
328
 }
318
329
 
..
..
@@ -333,24 +344,36 @@
333
344
 	return prop;
334
345
 }
335
346
 
336
-void __init walk_drmem_lmbs(struct device_node *dn,
337
-			    void (*func)(struct drmem_lmb *, const __be32 **))
347
+int walk_drmem_lmbs(struct device_node *dn, void *data,
348
+		    int (*func)(struct drmem_lmb *, const __be32 **, void *))
338
349
 {
339
350
 	const __be32 *prop, *usm;
351
+	int ret = -ENODEV;
352
+
353
+	if (!of_root)
354
+		return ret;
355
+
356
+	/* Get the address & size cells */
357
+	of_node_get(of_root);
358
+	n_root_addr_cells = of_n_addr_cells(of_root);
359
+	n_root_size_cells = of_n_size_cells(of_root);
360
+	of_node_put(of_root);
340
361
 
341
362
 	if (init_drmem_lmb_size(dn))
342
-		return;
363
+		return ret;
343
364
 
344
365
 	usm = of_get_usable_memory(dn);
345
366
 
346
367
 	prop = of_get_property(dn, "ibm,dynamic-memory", NULL);
347
368
 	if (prop) {
348
-		__walk_drmem_v1_lmbs(prop, usm, func);
369
+		ret = __walk_drmem_v1_lmbs(prop, usm, data, func);
349
370
 	} else {
350
371
 		prop = of_get_property(dn, "ibm,dynamic-memory-v2", NULL);
351
372
 		if (prop)
352
-			__walk_drmem_v2_lmbs(prop, usm, func);
373
+			ret = __walk_drmem_v2_lmbs(prop, usm, data, func);
353
374
 	}
375
+
376
+	return ret;
354
377
 }
355
378
 
356
379
 static void __init init_drmem_v1_lmbs(const __be32 *prop)