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; | |
e8d51348 | 24 | struct dev_pagemap pgmap; |
ab68f262 DW |
25 | struct completion cmp; |
26 | }; | |
27 | ||
ccdb07f6 | 28 | static struct dax_pmem *to_dax_pmem(struct percpu_ref *ref) |
ab68f262 DW |
29 | { |
30 | return container_of(ref, struct dax_pmem, ref); | |
31 | } | |
32 | ||
33 | static void dax_pmem_percpu_release(struct percpu_ref *ref) | |
34 | { | |
35 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
36 | ||
6daaca52 | 37 | dev_dbg(dax_pmem->dev, "trace\n"); |
ab68f262 DW |
38 | complete(&dax_pmem->cmp); |
39 | } | |
40 | ||
41 | static void dax_pmem_percpu_exit(void *data) | |
42 | { | |
43 | struct percpu_ref *ref = data; | |
44 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
45 | ||
6daaca52 | 46 | dev_dbg(dax_pmem->dev, "trace\n"); |
71389703 | 47 | wait_for_completion(&dax_pmem->cmp); |
ab68f262 | 48 | percpu_ref_exit(ref); |
ab68f262 DW |
49 | } |
50 | ||
51 | static void dax_pmem_percpu_kill(void *data) | |
52 | { | |
53 | struct percpu_ref *ref = data; | |
54 | struct dax_pmem *dax_pmem = to_dax_pmem(ref); | |
55 | ||
6daaca52 | 56 | dev_dbg(dax_pmem->dev, "trace\n"); |
ab68f262 DW |
57 | percpu_ref_kill(ref); |
58 | } | |
59 | ||
60 | static int dax_pmem_probe(struct device *dev) | |
61 | { | |
ab68f262 DW |
62 | void *addr; |
63 | struct resource res; | |
bbb3be17 | 64 | int rc, id, region_id; |
ab68f262 | 65 | struct nd_pfn_sb *pfn_sb; |
5f0694b3 | 66 | struct dev_dax *dev_dax; |
ab68f262 | 67 | struct dax_pmem *dax_pmem; |
ab68f262 DW |
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; | |
ab68f262 DW |
73 | |
74 | ndns = nvdimm_namespace_common_probe(dev); | |
75 | if (IS_ERR(ndns)) | |
76 | return PTR_ERR(ndns); | |
77 | nsio = to_nd_namespace_io(&ndns->dev); | |
78 | ||
e8d51348 CH |
79 | dax_pmem = devm_kzalloc(dev, sizeof(*dax_pmem), GFP_KERNEL); |
80 | if (!dax_pmem) | |
81 | return -ENOMEM; | |
82 | ||
ab68f262 | 83 | /* parse the 'pfn' info block via ->rw_bytes */ |
6a84fb4b DW |
84 | rc = devm_nsio_enable(dev, nsio); |
85 | if (rc) | |
86 | return rc; | |
e8d51348 CH |
87 | rc = nvdimm_setup_pfn(nd_pfn, &dax_pmem->pgmap); |
88 | if (rc) | |
89 | return rc; | |
ab68f262 DW |
90 | devm_nsio_disable(dev, nsio); |
91 | ||
92 | pfn_sb = nd_pfn->pfn_sb; | |
93 | ||
94 | if (!devm_request_mem_region(dev, nsio->res.start, | |
450c6633 DW |
95 | resource_size(&nsio->res), |
96 | dev_name(&ndns->dev))) { | |
ab68f262 DW |
97 | dev_warn(dev, "could not reserve region %pR\n", &nsio->res); |
98 | return -EBUSY; | |
99 | } | |
100 | ||
ab68f262 DW |
101 | dax_pmem->dev = dev; |
102 | init_completion(&dax_pmem->cmp); | |
103 | rc = percpu_ref_init(&dax_pmem->ref, dax_pmem_percpu_release, 0, | |
104 | GFP_KERNEL); | |
105 | if (rc) | |
106 | return rc; | |
107 | ||
d1c8e0c5 SV |
108 | rc = devm_add_action_or_reset(dev, dax_pmem_percpu_exit, |
109 | &dax_pmem->ref); | |
110 | if (rc) | |
ab68f262 | 111 | return rc; |
ab68f262 | 112 | |
e8d51348 CH |
113 | dax_pmem->pgmap.ref = &dax_pmem->ref; |
114 | addr = devm_memremap_pages(dev, &dax_pmem->pgmap); | |
ab68f262 DW |
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 | 123 | /* adjust the dax_region resource to the start of data */ |
e8d51348 | 124 | memcpy(&res, &dax_pmem->pgmap.res, sizeof(res)); |
d0e58455 DW |
125 | res.start += le64_to_cpu(pfn_sb->dataoff); |
126 | ||
bbb3be17 DW |
127 | rc = sscanf(dev_name(&ndns->dev), "namespace%d.%d", ®ion_id, &id); |
128 | if (rc != 2) | |
129 | return -EINVAL; | |
130 | ||
131 | dax_region = alloc_dax_region(dev, region_id, &res, | |
ab68f262 DW |
132 | le32_to_cpu(pfn_sb->align), addr, PFN_DEV|PFN_MAP); |
133 | if (!dax_region) | |
134 | return -ENOMEM; | |
135 | ||
136 | /* TODO: support for subdividing a dax region... */ | |
bbb3be17 | 137 | dev_dax = devm_create_dev_dax(dax_region, id, &res, 1); |
ab68f262 | 138 | |
5f0694b3 | 139 | /* child dev_dax instances now own the lifetime of the dax_region */ |
ab68f262 DW |
140 | dax_region_put(dax_region); |
141 | ||
5f0694b3 | 142 | return PTR_ERR_OR_ZERO(dev_dax); |
ab68f262 DW |
143 | } |
144 | ||
145 | static struct nd_device_driver dax_pmem_driver = { | |
146 | .probe = dax_pmem_probe, | |
147 | .drv = { | |
148 | .name = "dax_pmem", | |
149 | }, | |
150 | .type = ND_DRIVER_DAX_PMEM, | |
151 | }; | |
152 | ||
d812b0d5 | 153 | module_nd_driver(dax_pmem_driver); |
ab68f262 DW |
154 | |
155 | MODULE_LICENSE("GPL v2"); | |
156 | MODULE_AUTHOR("Intel Corporation"); | |
157 | MODULE_ALIAS_ND_DEVICE(ND_DEVICE_DAX_PMEM); |