1 /* 2 * Copyright(c) 2013-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/device.h> 14 #include <linux/sizes.h> 15 #include <linux/slab.h> 16 #include <linux/mm.h> 17 #include "nd-core.h" 18 #include "pfn.h" 19 #include "nd.h" 20 21 static void nd_dax_release(struct device *dev) 22 { 23 struct nd_region *nd_region = to_nd_region(dev->parent); 24 struct nd_dax *nd_dax = to_nd_dax(dev); 25 struct nd_pfn *nd_pfn = &nd_dax->nd_pfn; 26 27 dev_dbg(dev, "%s\n", __func__); 28 nd_detach_ndns(dev, &nd_pfn->ndns); 29 ida_simple_remove(&nd_region->dax_ida, nd_pfn->id); 30 kfree(nd_pfn->uuid); 31 kfree(nd_dax); 32 } 33 34 static struct device_type nd_dax_device_type = { 35 .name = "nd_dax", 36 .release = nd_dax_release, 37 }; 38 39 bool is_nd_dax(struct device *dev) 40 { 41 return dev ? dev->type == &nd_dax_device_type : false; 42 } 43 EXPORT_SYMBOL(is_nd_dax); 44 45 struct nd_dax *to_nd_dax(struct device *dev) 46 { 47 struct nd_dax *nd_dax = container_of(dev, struct nd_dax, nd_pfn.dev); 48 49 WARN_ON(!is_nd_dax(dev)); 50 return nd_dax; 51 } 52 EXPORT_SYMBOL(to_nd_dax); 53 54 static const struct attribute_group *nd_dax_attribute_groups[] = { 55 &nd_pfn_attribute_group, 56 &nd_device_attribute_group, 57 &nd_numa_attribute_group, 58 NULL, 59 }; 60 61 static struct nd_dax *nd_dax_alloc(struct nd_region *nd_region) 62 { 63 struct nd_pfn *nd_pfn; 64 struct nd_dax *nd_dax; 65 struct device *dev; 66 67 nd_dax = kzalloc(sizeof(*nd_dax), GFP_KERNEL); 68 if (!nd_dax) 69 return NULL; 70 71 nd_pfn = &nd_dax->nd_pfn; 72 nd_pfn->id = ida_simple_get(&nd_region->dax_ida, 0, 0, GFP_KERNEL); 73 if (nd_pfn->id < 0) { 74 kfree(nd_dax); 75 return NULL; 76 } 77 78 dev = &nd_pfn->dev; 79 dev_set_name(dev, "dax%d.%d", nd_region->id, nd_pfn->id); 80 dev->groups = nd_dax_attribute_groups; 81 dev->type = &nd_dax_device_type; 82 dev->parent = &nd_region->dev; 83 84 return nd_dax; 85 } 86 87 struct device *nd_dax_create(struct nd_region *nd_region) 88 { 89 struct device *dev = NULL; 90 struct nd_dax *nd_dax; 91 92 if (!is_memory(&nd_region->dev)) 93 return NULL; 94 95 nd_dax = nd_dax_alloc(nd_region); 96 if (nd_dax) 97 dev = nd_pfn_devinit(&nd_dax->nd_pfn, NULL); 98 __nd_device_register(dev); 99 return dev; 100 } 101 102 int nd_dax_probe(struct device *dev, struct nd_namespace_common *ndns) 103 { 104 int rc; 105 struct nd_dax *nd_dax; 106 struct device *dax_dev; 107 struct nd_pfn *nd_pfn; 108 struct nd_pfn_sb *pfn_sb; 109 struct nd_region *nd_region = to_nd_region(ndns->dev.parent); 110 111 if (ndns->force_raw) 112 return -ENODEV; 113 114 switch (ndns->claim_class) { 115 case NVDIMM_CCLASS_NONE: 116 case NVDIMM_CCLASS_DAX: 117 break; 118 default: 119 return -ENODEV; 120 } 121 122 nvdimm_bus_lock(&ndns->dev); 123 nd_dax = nd_dax_alloc(nd_region); 124 nd_pfn = &nd_dax->nd_pfn; 125 dax_dev = nd_pfn_devinit(nd_pfn, ndns); 126 nvdimm_bus_unlock(&ndns->dev); 127 if (!dax_dev) 128 return -ENOMEM; 129 pfn_sb = devm_kzalloc(dev, sizeof(*pfn_sb), GFP_KERNEL); 130 nd_pfn->pfn_sb = pfn_sb; 131 rc = nd_pfn_validate(nd_pfn, DAX_SIG); 132 dev_dbg(dev, "%s: dax: %s\n", __func__, 133 rc == 0 ? dev_name(dax_dev) : "<none>"); 134 if (rc < 0) { 135 nd_detach_ndns(dax_dev, &nd_pfn->ndns); 136 put_device(dax_dev); 137 } else 138 __nd_device_register(dax_dev); 139 140 return rc; 141 } 142 EXPORT_SYMBOL(nd_dax_probe); 143