Commit | Line | Data |
---|---|---|
ab68f262 DW |
1 | /* |
2 | * Copyright(c) 2016 Intel Corporation. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of version 2 of the GNU General Public License as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, but | |
9 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License for more details. | |
12 | */ | |
13 | #include <linux/percpu-refcount.h> | |
14 | #include <linux/memremap.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/pfn_t.h> | |
17 | #include "../nvdimm/pfn.h" | |
18 | #include "../nvdimm/nd.h" | |
7b6be844 | 19 | #include "device-dax.h" |
ab68f262 DW |
20 | |
21 | struct dax_pmem { | |
22 | struct device *dev; | |
23 | struct percpu_ref ref; | |
24 | struct completion cmp; | |
25 | }; | |
26 | ||
ccdb07f6 | 27 | static struct dax_pmem *to_dax_pmem(struct percpu_ref *ref) |
ab68f262 DW |
28 | { |
29 | return container_of(ref, struct dax_pmem, ref); | |
30 | } | |
31 | ||
32 | static void dax_pmem_percpu_release(struct percpu_ref *ref) | |
33 | { | |
34 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
35 | ||
36 | dev_dbg(dax_pmem->dev, "%s\n", __func__); | |
37 | complete(&dax_pmem->cmp); | |
38 | } | |
39 | ||
40 | static void dax_pmem_percpu_exit(void *data) | |
41 | { | |
42 | struct percpu_ref *ref = data; | |
43 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
44 | ||
45 | dev_dbg(dax_pmem->dev, "%s\n", __func__); | |
71389703 | 46 | wait_for_completion(&dax_pmem->cmp); |
ab68f262 | 47 | percpu_ref_exit(ref); |
ab68f262 DW |
48 | } |
49 | ||
50 | static void dax_pmem_percpu_kill(void *data) | |
51 | { | |
52 | struct percpu_ref *ref = data; | |
53 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
54 | ||
55 | dev_dbg(dax_pmem->dev, "%s\n", __func__); | |
56 | percpu_ref_kill(ref); | |
57 | } | |
58 | ||
59 | static int dax_pmem_probe(struct device *dev) | |
60 | { | |
61 | int rc; | |
62 | void *addr; | |
63 | struct resource res; | |
64 | struct nd_pfn_sb *pfn_sb; | |
5f0694b3 | 65 | struct dev_dax *dev_dax; |
ab68f262 DW |
66 | struct dax_pmem *dax_pmem; |
67 | struct nd_region *nd_region; | |
68 | struct nd_namespace_io *nsio; | |
69 | struct dax_region *dax_region; | |
70 | struct nd_namespace_common *ndns; | |
71 | struct nd_dax *nd_dax = to_nd_dax(dev); | |
72 | struct nd_pfn *nd_pfn = &nd_dax->nd_pfn; | |
73 | struct vmem_altmap __altmap, *altmap = NULL; | |
74 | ||
75 | ndns = nvdimm_namespace_common_probe(dev); | |
76 | if (IS_ERR(ndns)) | |
77 | return PTR_ERR(ndns); | |
78 | nsio = to_nd_namespace_io(&ndns->dev); | |
79 | ||
80 | /* parse the 'pfn' info block via ->rw_bytes */ | |
6a84fb4b DW |
81 | rc = devm_nsio_enable(dev, nsio); |
82 | if (rc) | |
83 | return rc; | |
ab68f262 DW |
84 | altmap = nvdimm_setup_pfn(nd_pfn, &res, &__altmap); |
85 | if (IS_ERR(altmap)) | |
86 | return PTR_ERR(altmap); | |
87 | devm_nsio_disable(dev, nsio); | |
88 | ||
89 | pfn_sb = nd_pfn->pfn_sb; | |
90 | ||
91 | if (!devm_request_mem_region(dev, nsio->res.start, | |
450c6633 DW |
92 | resource_size(&nsio->res), |
93 | dev_name(&ndns->dev))) { | |
ab68f262 DW |
94 | dev_warn(dev, "could not reserve region %pR\n", &nsio->res); |
95 | return -EBUSY; | |
96 | } | |
97 | ||
98 | dax_pmem = devm_kzalloc(dev, sizeof(*dax_pmem), GFP_KERNEL); | |
99 | if (!dax_pmem) | |
100 | return -ENOMEM; | |
101 | ||
102 | dax_pmem->dev = dev; | |
103 | init_completion(&dax_pmem->cmp); | |
104 | rc = percpu_ref_init(&dax_pmem->ref, dax_pmem_percpu_release, 0, | |
105 | GFP_KERNEL); | |
106 | if (rc) | |
107 | return rc; | |
108 | ||
d1c8e0c5 SV |
109 | rc = devm_add_action_or_reset(dev, dax_pmem_percpu_exit, |
110 | &dax_pmem->ref); | |
111 | if (rc) | |
ab68f262 | 112 | return rc; |
ab68f262 DW |
113 | |
114 | addr = devm_memremap_pages(dev, &res, &dax_pmem->ref, altmap); | |
115 | if (IS_ERR(addr)) | |
116 | return PTR_ERR(addr); | |
117 | ||
d1c8e0c5 SV |
118 | rc = devm_add_action_or_reset(dev, dax_pmem_percpu_kill, |
119 | &dax_pmem->ref); | |
120 | if (rc) | |
ab68f262 | 121 | return rc; |
ab68f262 | 122 | |
d0e58455 DW |
123 | /* adjust the dax_region resource to the start of data */ |
124 | res.start += le64_to_cpu(pfn_sb->dataoff); | |
125 | ||
ab68f262 DW |
126 | nd_region = to_nd_region(dev->parent); |
127 | dax_region = alloc_dax_region(dev, nd_region->id, &res, | |
128 | le32_to_cpu(pfn_sb->align), addr, PFN_DEV|PFN_MAP); | |
129 | if (!dax_region) | |
130 | return -ENOMEM; | |
131 | ||
132 | /* TODO: support for subdividing a dax region... */ | |
5f0694b3 | 133 | dev_dax = devm_create_dev_dax(dax_region, &res, 1); |
ab68f262 | 134 | |
5f0694b3 | 135 | /* child dev_dax instances now own the lifetime of the dax_region */ |
ab68f262 DW |
136 | dax_region_put(dax_region); |
137 | ||
5f0694b3 | 138 | return PTR_ERR_OR_ZERO(dev_dax); |
ab68f262 DW |
139 | } |
140 | ||
141 | static struct nd_device_driver dax_pmem_driver = { | |
142 | .probe = dax_pmem_probe, | |
143 | .drv = { | |
144 | .name = "dax_pmem", | |
145 | }, | |
146 | .type = ND_DRIVER_DAX_PMEM, | |
147 | }; | |
148 | ||
149 | static int __init dax_pmem_init(void) | |
150 | { | |
151 | return nd_driver_register(&dax_pmem_driver); | |
152 | } | |
153 | module_init(dax_pmem_init); | |
154 | ||
155 | static void __exit dax_pmem_exit(void) | |
156 | { | |
157 | driver_unregister(&dax_pmem_driver.drv); | |
158 | } | |
159 | module_exit(dax_pmem_exit); | |
160 | ||
161 | MODULE_LICENSE("GPL v2"); | |
162 | MODULE_AUTHOR("Intel Corporation"); | |
163 | MODULE_ALIAS_ND_DEVICE(ND_DEVICE_DAX_PMEM); |