Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'dt-reserved-mem-cleanups' into dma-mapping-for-next
Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
+297
-223
+10
-9
drivers/memory/tegra/tegra210-emc-table.c
+10
-9
drivers/memory/tegra/tegra210-emc-table.c
···
70
70
memunmap(timings);
71
71
}
72
72
73
-
static const struct reserved_mem_ops tegra210_emc_table_ops = {
74
-
.device_init = tegra210_emc_table_device_init,
75
-
.device_release = tegra210_emc_table_device_release,
76
-
};
77
-
78
-
static int tegra210_emc_table_init(struct reserved_mem *rmem)
73
+
static int tegra210_emc_table_init(unsigned long node,
74
+
struct reserved_mem *rmem)
79
75
{
80
76
pr_debug("Tegra210 EMC table at %pa, size %lu bytes\n", &rmem->base,
81
77
(unsigned long)rmem->size);
82
78
83
-
rmem->ops = &tegra210_emc_table_ops;
84
-
85
79
return 0;
86
80
}
81
+
82
+
static const struct reserved_mem_ops tegra210_emc_table_ops = {
83
+
.node_init = tegra210_emc_table_init,
84
+
.device_init = tegra210_emc_table_device_init,
85
+
.device_release = tegra210_emc_table_device_release,
86
+
};
87
+
87
88
RESERVEDMEM_OF_DECLARE(tegra210_emc_table, "nvidia,tegra210-emc-table",
88
-
tegra210_emc_table_init);
89
+
&tegra210_emc_table_ops);
+1
-1
drivers/of/fdt.c
+1
-1
drivers/of/fdt.c
···
1274
1274
void *fdt = initial_boot_params;
1275
1275
1276
1276
/* Save the statically-placed regions in the reserved_mem array */
1277
-
fdt_scan_reserved_mem_reg_nodes();
1277
+
fdt_scan_reserved_mem_late();
1278
1278
1279
1279
/* Populate an empty root node when bootloader doesn't provide one */
1280
1280
if (!fdt) {
+1
-1
drivers/of/of_private.h
+1
-1
drivers/of/of_private.h
+197
-143
drivers/of/of_reserved_mem.c
+197
-143
drivers/of/of_reserved_mem.c
···
24
24
#include <linux/slab.h>
25
25
#include <linux/memblock.h>
26
26
#include <linux/kmemleak.h>
27
-
#include <linux/cma.h>
28
-
#include <linux/dma-map-ops.h>
29
27
30
28
#include "of_private.h"
31
29
···
102
104
reserved_mem = new_array;
103
105
}
104
106
105
-
static void __init fdt_init_reserved_mem_node(struct reserved_mem *rmem);
106
-
/*
107
-
* fdt_reserved_mem_save_node() - save fdt node for second pass initialization
108
-
*/
109
-
static void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname,
110
-
phys_addr_t base, phys_addr_t size)
111
-
{
112
-
struct reserved_mem *rmem = &reserved_mem[reserved_mem_count];
113
-
114
-
if (reserved_mem_count == total_reserved_mem_cnt) {
115
-
pr_err("not enough space for all defined regions.\n");
116
-
return;
117
-
}
118
-
119
-
rmem->fdt_node = node;
120
-
rmem->name = uname;
121
-
rmem->base = base;
122
-
rmem->size = size;
123
-
124
-
/* Call the region specific initialization function */
125
-
fdt_init_reserved_mem_node(rmem);
126
-
127
-
reserved_mem_count++;
128
-
}
107
+
static void fdt_init_reserved_mem_node(unsigned long node, const char *uname,
108
+
phys_addr_t base, phys_addr_t size);
109
+
static int fdt_validate_reserved_mem_node(unsigned long node,
110
+
phys_addr_t *align);
111
+
static int fdt_fixup_reserved_mem_node(unsigned long node,
112
+
phys_addr_t base, phys_addr_t size);
129
113
130
114
static int __init early_init_dt_reserve_memory(phys_addr_t base,
131
115
phys_addr_t size, bool nomap)
···
134
154
const char *uname)
135
155
{
136
156
phys_addr_t base, size;
137
-
int i, len;
157
+
int i, len, err;
138
158
const __be32 *prop;
139
-
bool nomap, default_cma;
159
+
bool nomap;
140
160
141
161
prop = of_flat_dt_get_addr_size_prop(node, "reg", &len);
142
162
if (!prop)
143
163
return -ENOENT;
144
164
145
165
nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
146
-
default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
147
166
148
-
if (default_cma && cma_skip_dt_default_reserved_mem()) {
149
-
pr_err("Skipping dt linux,cma-default for \"cma=\" kernel param.\n");
150
-
return -EINVAL;
151
-
}
167
+
err = fdt_validate_reserved_mem_node(node, NULL);
168
+
if (err && err != -ENODEV)
169
+
return err;
152
170
153
171
for (i = 0; i < len; i++) {
154
172
u64 b, s;
···
157
179
size = s;
158
180
159
181
if (size && early_init_dt_reserve_memory(base, size, nomap) == 0) {
160
-
/* Architecture specific contiguous memory fixup. */
161
-
if (of_flat_dt_is_compatible(node, "shared-dma-pool") &&
162
-
of_get_flat_dt_prop(node, "reusable", NULL))
163
-
dma_contiguous_early_fixup(base, size);
182
+
fdt_fixup_reserved_mem_node(node, base, size);
164
183
pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %lu MiB\n",
165
184
uname, &base, (unsigned long)(size / SZ_1M));
166
185
} else {
···
191
216
return 0;
192
217
}
193
218
194
-
static void __init __rmem_check_for_overlap(void);
219
+
static int __init __rmem_cmp(const void *a, const void *b)
220
+
{
221
+
const struct reserved_mem *ra = a, *rb = b;
222
+
223
+
if (ra->base < rb->base)
224
+
return -1;
225
+
226
+
if (ra->base > rb->base)
227
+
return 1;
228
+
229
+
/*
230
+
* Put the dynamic allocations (address == 0, size == 0) before static
231
+
* allocations at address 0x0 so that overlap detection works
232
+
* correctly.
233
+
*/
234
+
if (ra->size < rb->size)
235
+
return -1;
236
+
if (ra->size > rb->size)
237
+
return 1;
238
+
239
+
return 0;
240
+
}
241
+
242
+
static void __init __rmem_check_for_overlap(void)
243
+
{
244
+
int i;
245
+
246
+
if (reserved_mem_count < 2)
247
+
return;
248
+
249
+
sort(reserved_mem, reserved_mem_count, sizeof(reserved_mem[0]),
250
+
__rmem_cmp, NULL);
251
+
for (i = 0; i < reserved_mem_count - 1; i++) {
252
+
struct reserved_mem *this, *next;
253
+
254
+
this = &reserved_mem[i];
255
+
next = &reserved_mem[i + 1];
256
+
257
+
if (this->base + this->size > next->base) {
258
+
phys_addr_t this_end, next_end;
259
+
260
+
this_end = this->base + this->size;
261
+
next_end = next->base + next->size;
262
+
pr_err("OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n",
263
+
this->name, &this->base, &this_end,
264
+
next->name, &next->base, &next_end);
265
+
}
266
+
}
267
+
}
195
268
196
269
/**
197
-
* fdt_scan_reserved_mem_reg_nodes() - Store info for the "reg" defined
198
-
* reserved memory regions.
270
+
* fdt_scan_reserved_mem_late() - Scan FDT and initialize remaining reserved
271
+
* memory regions.
199
272
*
200
-
* This function is used to scan through the DT and store the
201
-
* information for the reserved memory regions that are defined using
202
-
* the "reg" property. The region node number, name, base address, and
203
-
* size are all stored in the reserved_mem array by calling the
204
-
* fdt_reserved_mem_save_node() function.
273
+
* This function is used to scan again through the DT and initialize the
274
+
* "static" reserved memory regions, that are defined using the "reg"
275
+
* property. Each such region is then initialized with its specific init
276
+
* function and stored in the global reserved_mem array.
205
277
*/
206
-
void __init fdt_scan_reserved_mem_reg_nodes(void)
278
+
void __init fdt_scan_reserved_mem_late(void)
207
279
{
208
280
const void *fdt = initial_boot_params;
209
281
phys_addr_t base, size;
···
275
253
276
254
fdt_for_each_subnode(child, fdt, node) {
277
255
const char *uname;
278
-
bool default_cma = of_get_flat_dt_prop(child, "linux,cma-default", NULL);
279
256
u64 b, s;
257
+
int ret;
280
258
281
259
if (!of_fdt_device_is_available(fdt, child))
282
260
continue;
283
-
if (default_cma && cma_skip_dt_default_reserved_mem())
284
-
continue;
285
261
286
262
if (!of_flat_dt_get_addr_size(child, "reg", &b, &s))
263
+
continue;
264
+
265
+
ret = fdt_validate_reserved_mem_node(child, NULL);
266
+
if (ret && ret != -ENODEV)
287
267
continue;
288
268
289
269
base = b;
···
293
269
294
270
if (size) {
295
271
uname = fdt_get_name(fdt, child, NULL);
296
-
fdt_reserved_mem_save_node(child, uname, base, size);
272
+
fdt_init_reserved_mem_node(child, uname, base, size);
297
273
}
298
274
}
299
275
···
304
280
static int __init __reserved_mem_alloc_size(unsigned long node, const char *uname);
305
281
306
282
/*
307
-
* fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
283
+
* fdt_scan_reserved_mem() - reserve and allocate memory occupied by
284
+
* reserved memory regions.
285
+
*
286
+
* This function is used to scan through the FDT and mark memory occupied
287
+
* by all static (defined by the "reg" property) reserved memory regions.
288
+
* Then memory for all dynamic regions (defined by size & alignment) is
289
+
* allocated, a region specific init function is called and region information
290
+
* is stored in the reserved_mem array.
308
291
*/
309
292
int __init fdt_scan_reserved_mem(void)
310
293
{
···
428
397
phys_addr_t base = 0, align = 0, size;
429
398
int i, len;
430
399
const __be32 *prop;
431
-
bool nomap, default_cma;
400
+
bool nomap;
432
401
int ret;
433
402
434
403
prop = of_get_flat_dt_prop(node, "size", &len);
···
452
421
}
453
422
454
423
nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
455
-
default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
456
424
457
-
if (default_cma && cma_skip_dt_default_reserved_mem()) {
458
-
pr_err("Skipping dt linux,cma-default for \"cma=\" kernel param.\n");
459
-
return -EINVAL;
460
-
}
461
-
462
-
/* Need adjust the alignment to satisfy the CMA requirement */
463
-
if (IS_ENABLED(CONFIG_CMA)
464
-
&& of_flat_dt_is_compatible(node, "shared-dma-pool")
465
-
&& of_get_flat_dt_prop(node, "reusable", NULL)
466
-
&& !nomap)
467
-
align = max_t(phys_addr_t, align, CMA_MIN_ALIGNMENT_BYTES);
425
+
ret = fdt_validate_reserved_mem_node(node, &align);
426
+
if (ret && ret != -ENODEV)
427
+
return ret;
468
428
469
429
prop = of_flat_dt_get_addr_size_prop(node, "alloc-ranges", &len);
470
430
if (prop) {
···
490
468
uname, (unsigned long)(size / SZ_1M));
491
469
return -ENOMEM;
492
470
}
493
-
/* Architecture specific contiguous memory fixup. */
494
-
if (of_flat_dt_is_compatible(node, "shared-dma-pool") &&
495
-
of_get_flat_dt_prop(node, "reusable", NULL))
496
-
dma_contiguous_early_fixup(base, size);
497
-
/* Save region in the reserved_mem array */
498
-
fdt_reserved_mem_save_node(node, uname, base, size);
471
+
472
+
fdt_fixup_reserved_mem_node(node, base, size);
473
+
fdt_init_reserved_mem_node(node, uname, base, size);
474
+
499
475
return 0;
500
476
}
501
477
478
+
extern const struct of_device_id __reservedmem_of_table[];
502
479
static const struct of_device_id __rmem_of_table_sentinel
503
480
__used __section("__reservedmem_of_table_end");
504
481
505
-
/*
506
-
* __reserved_mem_init_node() - call region specific reserved memory init code
482
+
/**
483
+
* fdt_fixup_reserved_mem_node() - call fixup function for a reserved memory node
484
+
* @node: FDT node to fixup
485
+
* @base: base address of the reserved memory region
486
+
* @size: size of the reserved memory region
487
+
*
488
+
* This function iterates through the reserved memory drivers and calls
489
+
* the node_fixup callback for the compatible entry matching the node.
490
+
*
491
+
* Return: 0 on success, -ENODEV if no compatible match found
507
492
*/
508
-
static int __init __reserved_mem_init_node(struct reserved_mem *rmem)
493
+
static int __init fdt_fixup_reserved_mem_node(unsigned long node,
494
+
phys_addr_t base, phys_addr_t size)
509
495
{
510
-
extern const struct of_device_id __reservedmem_of_table[];
511
496
const struct of_device_id *i;
512
-
int ret = -ENOENT;
497
+
int ret = -ENODEV;
513
498
514
-
for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) {
515
-
reservedmem_of_init_fn initfn = i->data;
516
-
const char *compat = i->compatible;
499
+
for (i = __reservedmem_of_table; ret == -ENODEV &&
500
+
i < &__rmem_of_table_sentinel; i++) {
501
+
const struct reserved_mem_ops *ops = i->data;
517
502
518
-
if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
503
+
if (!of_flat_dt_is_compatible(node, i->compatible))
519
504
continue;
520
505
521
-
ret = initfn(rmem);
506
+
if (ops->node_fixup)
507
+
ret = ops->node_fixup(node, base, size);
508
+
}
509
+
return ret;
510
+
}
511
+
512
+
/**
513
+
* fdt_validate_reserved_mem_node() - validate a reserved memory node
514
+
* @node: FDT node to validate
515
+
* @align: pointer to store the validated alignment (may be modified by callback)
516
+
*
517
+
* This function iterates through the reserved memory drivers and calls
518
+
* the node_validate callback for the compatible entry matching the node.
519
+
*
520
+
* Return: 0 on success, -ENODEV if no compatible match found
521
+
*/
522
+
static int __init fdt_validate_reserved_mem_node(unsigned long node, phys_addr_t *align)
523
+
{
524
+
const struct of_device_id *i;
525
+
int ret = -ENODEV;
526
+
527
+
for (i = __reservedmem_of_table; ret == -ENODEV &&
528
+
i < &__rmem_of_table_sentinel; i++) {
529
+
const struct reserved_mem_ops *ops = i->data;
530
+
531
+
if (!of_flat_dt_is_compatible(node, i->compatible))
532
+
continue;
533
+
534
+
if (ops->node_validate)
535
+
ret = ops->node_validate(node, align);
536
+
}
537
+
return ret;
538
+
}
539
+
540
+
/**
541
+
* __reserved_mem_init_node() - initialize a reserved memory region
542
+
* @rmem: reserved_mem structure to initialize
543
+
* @node: FDT node describing the reserved memory region
544
+
*
545
+
* This function iterates through the reserved memory drivers and calls the
546
+
* node_init callback for the compatible entry matching the node. On success,
547
+
* the operations pointer is stored in the reserved_mem structure.
548
+
*
549
+
* Return: 0 on success, -ENODEV if no compatible match found
550
+
*/
551
+
static int __init __reserved_mem_init_node(struct reserved_mem *rmem,
552
+
unsigned long node)
553
+
{
554
+
const struct of_device_id *i;
555
+
int ret = -ENODEV;
556
+
557
+
for (i = __reservedmem_of_table; ret == -ENODEV &&
558
+
i < &__rmem_of_table_sentinel; i++) {
559
+
const struct reserved_mem_ops *ops = i->data;
560
+
const char *compat = i->compatible;
561
+
562
+
if (!of_flat_dt_is_compatible(node, compat))
563
+
continue;
564
+
565
+
ret = ops->node_init(node, rmem);
522
566
if (ret == 0) {
567
+
rmem->ops = ops;
523
568
pr_info("initialized node %s, compatible id %s\n",
524
569
rmem->name, compat);
525
-
break;
570
+
return ret;
526
571
}
527
572
}
528
573
return ret;
529
574
}
530
575
531
-
static int __init __rmem_cmp(const void *a, const void *b)
532
-
{
533
-
const struct reserved_mem *ra = a, *rb = b;
534
-
535
-
if (ra->base < rb->base)
536
-
return -1;
537
-
538
-
if (ra->base > rb->base)
539
-
return 1;
540
-
541
-
/*
542
-
* Put the dynamic allocations (address == 0, size == 0) before static
543
-
* allocations at address 0x0 so that overlap detection works
544
-
* correctly.
545
-
*/
546
-
if (ra->size < rb->size)
547
-
return -1;
548
-
if (ra->size > rb->size)
549
-
return 1;
550
-
551
-
if (ra->fdt_node < rb->fdt_node)
552
-
return -1;
553
-
if (ra->fdt_node > rb->fdt_node)
554
-
return 1;
555
-
556
-
return 0;
557
-
}
558
-
559
-
static void __init __rmem_check_for_overlap(void)
560
-
{
561
-
int i;
562
-
563
-
if (reserved_mem_count < 2)
564
-
return;
565
-
566
-
sort(reserved_mem, reserved_mem_count, sizeof(reserved_mem[0]),
567
-
__rmem_cmp, NULL);
568
-
for (i = 0; i < reserved_mem_count - 1; i++) {
569
-
struct reserved_mem *this, *next;
570
-
571
-
this = &reserved_mem[i];
572
-
next = &reserved_mem[i + 1];
573
-
574
-
if (this->base + this->size > next->base) {
575
-
phys_addr_t this_end, next_end;
576
-
577
-
this_end = this->base + this->size;
578
-
next_end = next->base + next->size;
579
-
pr_err("OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n",
580
-
this->name, &this->base, &this_end,
581
-
next->name, &next->base, &next_end);
582
-
}
583
-
}
584
-
}
585
-
586
576
/**
587
577
* fdt_init_reserved_mem_node() - Initialize a reserved memory region
588
-
* @rmem: reserved_mem struct of the memory region to be initialized.
578
+
* @node: fdt node of the initialized region
579
+
* @uname: name of the reserved memory node
580
+
* @base: base address of the reserved memory region
581
+
* @size: size of the reserved memory region
589
582
*
590
-
* This function is used to call the region specific initialization
591
-
* function for a reserved memory region.
583
+
* This function calls the region-specific initialization function for a
584
+
* reserved memory region and saves all region-specific data to the
585
+
* reserved_mem array to allow of_reserved_mem_lookup() to find it.
592
586
*/
593
-
static void __init fdt_init_reserved_mem_node(struct reserved_mem *rmem)
587
+
static void __init fdt_init_reserved_mem_node(unsigned long node, const char *uname,
588
+
phys_addr_t base, phys_addr_t size)
594
589
{
595
-
unsigned long node = rmem->fdt_node;
596
590
int err = 0;
597
591
bool nomap;
598
592
593
+
struct reserved_mem *rmem = &reserved_mem[reserved_mem_count];
594
+
595
+
if (reserved_mem_count == total_reserved_mem_cnt) {
596
+
pr_err("not enough space for all defined regions.\n");
597
+
return;
598
+
}
599
+
600
+
rmem->name = uname;
601
+
rmem->base = base;
602
+
rmem->size = size;
603
+
599
604
nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
600
605
601
-
err = __reserved_mem_init_node(rmem);
602
-
if (err != 0 && err != -ENOENT) {
606
+
err = __reserved_mem_init_node(rmem, node);
607
+
if (err != 0 && err != -ENODEV) {
603
608
pr_info("node %s compatible matching fail\n", rmem->name);
609
+
rmem->name = NULL;
610
+
604
611
if (nomap)
605
612
memblock_clear_nomap(rmem->base, rmem->size);
606
613
else
607
614
memblock_phys_free(rmem->base, rmem->size);
615
+
return;
608
616
} else {
609
617
phys_addr_t end = rmem->base + rmem->size - 1;
610
618
bool reusable =
···
646
594
reusable ? "reusable" : "non-reusable",
647
595
rmem->name ? rmem->name : "unknown");
648
596
}
597
+
598
+
reserved_mem_count++;
649
599
}
650
600
651
601
struct rmem_assigned_device {
-10
include/linux/cma.h
-10
include/linux/cma.h
···
61
61
extern bool cma_intersects(struct cma *cma, unsigned long start, unsigned long end);
62
62
63
63
extern void cma_reserve_pages_on_error(struct cma *cma);
64
-
65
-
#ifdef CONFIG_DMA_CMA
66
-
extern bool cma_skip_dt_default_reserved_mem(void);
67
-
#else
68
-
static inline bool cma_skip_dt_default_reserved_mem(void)
69
-
{
70
-
return false;
71
-
}
72
-
#endif
73
-
74
64
#endif
-3
include/linux/dma-map-ops.h
-3
include/linux/dma-map-ops.h
+9
-7
include/linux/of_reserved_mem.h
+9
-7
include/linux/of_reserved_mem.h
···
11
11
12
12
struct reserved_mem {
13
13
const char *name;
14
-
unsigned long fdt_node;
15
14
const struct reserved_mem_ops *ops;
16
15
phys_addr_t base;
17
16
phys_addr_t size;
···
18
19
};
19
20
20
21
struct reserved_mem_ops {
22
+
int (*node_validate)(unsigned long fdt_node, phys_addr_t *align);
23
+
int (*node_fixup)(unsigned long fdt_node, phys_addr_t base,
24
+
phys_addr_t size);
25
+
int (*node_init)(unsigned long fdt_node, struct reserved_mem *rmem);
21
26
int (*device_init)(struct reserved_mem *rmem,
22
27
struct device *dev);
23
28
void (*device_release)(struct reserved_mem *rmem,
24
29
struct device *dev);
25
30
};
26
31
27
-
typedef int (*reservedmem_of_init_fn)(struct reserved_mem *rmem);
28
-
29
32
#ifdef CONFIG_OF_RESERVED_MEM
30
33
31
-
#define RESERVEDMEM_OF_DECLARE(name, compat, init) \
32
-
_OF_DECLARE(reservedmem, name, compat, init, reservedmem_of_init_fn)
34
+
#define RESERVEDMEM_OF_DECLARE(name, compat, ops) \
35
+
_OF_DECLARE(reservedmem, name, compat, ops, struct reserved_mem_ops *)
33
36
34
37
int of_reserved_mem_device_init_by_idx(struct device *dev,
35
38
struct device_node *np, int idx);
···
49
48
50
49
#else
51
50
52
-
#define RESERVEDMEM_OF_DECLARE(name, compat, init) \
53
-
_OF_DECLARE_STUB(reservedmem, name, compat, init, reservedmem_of_init_fn)
51
+
#define RESERVEDMEM_OF_DECLARE(name, compat, ops) \
52
+
_OF_DECLARE_STUB(reservedmem, name, compat, ops, \
53
+
struct reserved_mem_ops *)
54
54
55
55
static inline int of_reserved_mem_device_init_by_idx(struct device *dev,
56
56
struct device_node *np, int idx)
+9
-10
kernel/dma/coherent.c
+9
-10
kernel/dma/coherent.c
···
362
362
dev->dma_mem = NULL;
363
363
}
364
364
365
-
static const struct reserved_mem_ops rmem_dma_ops = {
366
-
.device_init = rmem_dma_device_init,
367
-
.device_release = rmem_dma_device_release,
368
-
};
369
365
370
-
static int __init rmem_dma_setup(struct reserved_mem *rmem)
366
+
static int __init rmem_dma_setup(unsigned long node, struct reserved_mem *rmem)
371
367
{
372
-
unsigned long node = rmem->fdt_node;
373
-
374
368
if (of_get_flat_dt_prop(node, "reusable", NULL))
375
-
return -EINVAL;
369
+
return -ENODEV;
376
370
377
371
#ifdef CONFIG_ARM
378
372
if (!of_get_flat_dt_prop(node, "no-map", NULL)) {
···
384
390
}
385
391
#endif
386
392
387
-
rmem->ops = &rmem_dma_ops;
388
393
pr_info("Reserved memory: created DMA memory pool at %pa, size %ld MiB\n",
389
394
&rmem->base, (unsigned long)rmem->size / SZ_1M);
390
395
return 0;
···
400
407
core_initcall(dma_init_reserved_memory);
401
408
#endif /* CONFIG_DMA_GLOBAL_POOL */
402
409
403
-
RESERVEDMEM_OF_DECLARE(dma, "shared-dma-pool", rmem_dma_setup);
410
+
static const struct reserved_mem_ops rmem_dma_ops = {
411
+
.node_init = rmem_dma_setup,
412
+
.device_init = rmem_dma_device_init,
413
+
.device_release = rmem_dma_device_release,
414
+
};
415
+
416
+
RESERVEDMEM_OF_DECLARE(dma, "shared-dma-pool", &rmem_dma_ops);
404
417
#endif
+61
-29
kernel/dma/contiguous.c
+61
-29
kernel/dma/contiguous.c
···
91
91
}
92
92
early_param("cma", early_cma);
93
93
94
-
/*
95
-
* cma_skip_dt_default_reserved_mem - This is called from the
96
-
* reserved_mem framework to detect if the default cma region is being
97
-
* set by the "cma=" kernel parameter.
98
-
*/
99
-
bool __init cma_skip_dt_default_reserved_mem(void)
100
-
{
101
-
return size_cmdline != -1;
102
-
}
103
-
104
94
#ifdef CONFIG_DMA_NUMA_CMA
105
95
106
96
static struct cma *dma_contiguous_numa_area[MAX_NUMNODES];
···
460
470
dev->cma_area = NULL;
461
471
}
462
472
463
-
static const struct reserved_mem_ops rmem_cma_ops = {
464
-
.device_init = rmem_cma_device_init,
465
-
.device_release = rmem_cma_device_release,
466
-
};
467
-
468
-
static int __init rmem_cma_setup(struct reserved_mem *rmem)
473
+
static int __init __rmem_cma_verify_node(unsigned long node)
469
474
{
470
-
unsigned long node = rmem->fdt_node;
471
-
bool default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
472
-
struct cma *cma;
473
-
int err;
474
-
475
475
if (!of_get_flat_dt_prop(node, "reusable", NULL) ||
476
476
of_get_flat_dt_prop(node, "no-map", NULL))
477
-
return -EINVAL;
477
+
return -ENODEV;
478
+
479
+
if (size_cmdline != -1 &&
480
+
of_get_flat_dt_prop(node, "linux,cma-default", NULL)) {
481
+
pr_err("Skipping dt linux,cma-default node in favor for \"cma=\" kernel param.\n");
482
+
return -EBUSY;
483
+
}
484
+
return 0;
485
+
}
486
+
487
+
static int __init rmem_cma_validate(unsigned long node, phys_addr_t *align)
488
+
{
489
+
int ret = __rmem_cma_verify_node(node);
490
+
491
+
if (ret)
492
+
return ret;
493
+
494
+
if (align)
495
+
*align = max_t(phys_addr_t, *align, CMA_MIN_ALIGNMENT_BYTES);
496
+
497
+
return 0;
498
+
}
499
+
500
+
static int __init rmem_cma_fixup(unsigned long node, phys_addr_t base,
501
+
phys_addr_t size)
502
+
{
503
+
int ret = __rmem_cma_verify_node(node);
504
+
505
+
if (ret)
506
+
return ret;
507
+
508
+
/* Architecture specific contiguous memory fixup. */
509
+
dma_contiguous_early_fixup(base, size);
510
+
return 0;
511
+
}
512
+
513
+
static int __init rmem_cma_setup(unsigned long node, struct reserved_mem *rmem)
514
+
{
515
+
bool default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
516
+
struct cma *cma;
517
+
int ret;
518
+
519
+
ret = __rmem_cma_verify_node(node);
520
+
if (ret)
521
+
return ret;
478
522
479
523
if (!IS_ALIGNED(rmem->base | rmem->size, CMA_MIN_ALIGNMENT_BYTES)) {
480
524
pr_err("Reserved memory: incorrect alignment of CMA region\n");
481
525
return -EINVAL;
482
526
}
483
527
484
-
err = cma_init_reserved_mem(rmem->base, rmem->size, 0, rmem->name, &cma);
485
-
if (err) {
528
+
ret = cma_init_reserved_mem(rmem->base, rmem->size, 0, rmem->name, &cma);
529
+
if (ret) {
486
530
pr_err("Reserved memory: unable to setup CMA region\n");
487
-
return err;
531
+
return ret;
488
532
}
489
533
490
534
if (default_cma)
491
535
dma_contiguous_default_area = cma;
492
536
493
-
rmem->ops = &rmem_cma_ops;
494
537
rmem->priv = cma;
495
538
496
539
pr_info("Reserved memory: created CMA memory pool at %pa, size %ld MiB\n",
497
540
&rmem->base, (unsigned long)rmem->size / SZ_1M);
498
541
499
-
err = dma_heap_cma_register_heap(cma);
500
-
if (err)
542
+
ret = dma_heap_cma_register_heap(cma);
543
+
if (ret)
501
544
pr_warn("Couldn't register CMA heap.");
502
545
503
546
return 0;
504
547
}
505
-
RESERVEDMEM_OF_DECLARE(cma, "shared-dma-pool", rmem_cma_setup);
548
+
549
+
static const struct reserved_mem_ops rmem_cma_ops = {
550
+
.node_validate = rmem_cma_validate,
551
+
.node_fixup = rmem_cma_fixup,
552
+
.node_init = rmem_cma_setup,
553
+
.device_init = rmem_cma_device_init,
554
+
.device_release = rmem_cma_device_release,
555
+
};
556
+
557
+
RESERVEDMEM_OF_DECLARE(cma, "shared-dma-pool", &rmem_cma_ops);
506
558
#endif
+9
-10
kernel/dma/swiotlb.c
+9
-10
kernel/dma/swiotlb.c
···
1877
1877
dev->dma_io_tlb_mem = &io_tlb_default_mem;
1878
1878
}
1879
1879
1880
-
static const struct reserved_mem_ops rmem_swiotlb_ops = {
1881
-
.device_init = rmem_swiotlb_device_init,
1882
-
.device_release = rmem_swiotlb_device_release,
1883
-
};
1884
-
1885
-
static int __init rmem_swiotlb_setup(struct reserved_mem *rmem)
1880
+
static int __init rmem_swiotlb_setup(unsigned long node,
1881
+
struct reserved_mem *rmem)
1886
1882
{
1887
-
unsigned long node = rmem->fdt_node;
1888
-
1889
1883
if (of_get_flat_dt_prop(node, "reusable", NULL) ||
1890
1884
of_get_flat_dt_prop(node, "linux,cma-default", NULL) ||
1891
1885
of_get_flat_dt_prop(node, "linux,dma-default", NULL) ||
1892
1886
of_get_flat_dt_prop(node, "no-map", NULL))
1893
1887
return -EINVAL;
1894
1888
1895
-
rmem->ops = &rmem_swiotlb_ops;
1896
1889
pr_info("Reserved memory: created restricted DMA pool at %pa, size %ld MiB\n",
1897
1890
&rmem->base, (unsigned long)rmem->size / SZ_1M);
1898
1891
return 0;
1899
1892
}
1900
1893
1901
-
RESERVEDMEM_OF_DECLARE(dma, "restricted-dma-pool", rmem_swiotlb_setup);
1894
+
static const struct reserved_mem_ops rmem_swiotlb_ops = {
1895
+
.node_init = rmem_swiotlb_setup,
1896
+
.device_init = rmem_swiotlb_device_init,
1897
+
.device_release = rmem_swiotlb_device_release,
1898
+
};
1899
+
1900
+
RESERVEDMEM_OF_DECLARE(dma, "restricted-dma-pool", &rmem_swiotlb_ops);
1902
1901
#endif /* CONFIG_DMA_RESTRICTED_POOL */