1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * NVMEM layout bus handling 4 * 5 * Copyright (C) 2023 Bootlin 6 * Author: Miquel Raynal <miquel.raynal@bootlin.com 7 */ 8 9 #include <linux/device.h> 10 #include <linux/dma-mapping.h> 11 #include <linux/nvmem-consumer.h> 12 #include <linux/nvmem-provider.h> 13 #include <linux/of.h> 14 #include <linux/of_device.h> 15 #include <linux/of_irq.h> 16 17 #include "internals.h" 18 19 #define to_nvmem_layout_driver(drv) \ 20 (container_of_const((drv), struct nvmem_layout_driver, driver)) 21 #define to_nvmem_layout_device(_dev) \ 22 container_of((_dev), struct nvmem_layout, dev) 23 24 static int nvmem_layout_bus_match(struct device *dev, const struct device_driver *drv) 25 { 26 return of_driver_match_device(dev, drv); 27 } 28 29 static int nvmem_layout_bus_probe(struct device *dev) 30 { 31 struct nvmem_layout_driver *drv = to_nvmem_layout_driver(dev->driver); 32 struct nvmem_layout *layout = to_nvmem_layout_device(dev); 33 34 if (!drv->probe || !drv->remove) 35 return -EINVAL; 36 37 return drv->probe(layout); 38 } 39 40 static void nvmem_layout_bus_remove(struct device *dev) 41 { 42 struct nvmem_layout_driver *drv = to_nvmem_layout_driver(dev->driver); 43 struct nvmem_layout *layout = to_nvmem_layout_device(dev); 44 45 return drv->remove(layout); 46 } 47 48 static int nvmem_layout_bus_uevent(const struct device *dev, 49 struct kobj_uevent_env *env) 50 { 51 int ret; 52 53 ret = of_device_uevent_modalias(dev, env); 54 if (ret != ENODEV) 55 return ret; 56 57 return 0; 58 } 59 60 static const struct bus_type nvmem_layout_bus_type = { 61 .name = "nvmem-layout", 62 .match = nvmem_layout_bus_match, 63 .probe = nvmem_layout_bus_probe, 64 .remove = nvmem_layout_bus_remove, 65 .uevent = nvmem_layout_bus_uevent, 66 }; 67 68 int __nvmem_layout_driver_register(struct nvmem_layout_driver *drv, 69 struct module *owner) 70 { 71 drv->driver.bus = &nvmem_layout_bus_type; 72 drv->driver.owner = owner; 73 74 return driver_register(&drv->driver); 75 } 76 EXPORT_SYMBOL_GPL(__nvmem_layout_driver_register); 77 78 void nvmem_layout_driver_unregister(struct nvmem_layout_driver *drv) 79 { 80 driver_unregister(&drv->driver); 81 } 82 EXPORT_SYMBOL_GPL(nvmem_layout_driver_unregister); 83 84 static void nvmem_layout_release_device(struct device *dev) 85 { 86 struct nvmem_layout *layout = to_nvmem_layout_device(dev); 87 88 of_node_put(layout->dev.of_node); 89 kfree(layout); 90 } 91 92 static int nvmem_layout_create_device(struct nvmem_device *nvmem, 93 struct device_node *np) 94 { 95 struct nvmem_layout *layout; 96 struct device *dev; 97 int ret; 98 99 layout = kzalloc(sizeof(*layout), GFP_KERNEL); 100 if (!layout) 101 return -ENOMEM; 102 103 /* Create a bidirectional link */ 104 layout->nvmem = nvmem; 105 nvmem->layout = layout; 106 107 /* Device model registration */ 108 dev = &layout->dev; 109 device_initialize(dev); 110 dev->parent = &nvmem->dev; 111 dev->bus = &nvmem_layout_bus_type; 112 dev->release = nvmem_layout_release_device; 113 dev->coherent_dma_mask = DMA_BIT_MASK(32); 114 dev->dma_mask = &dev->coherent_dma_mask; 115 device_set_node(dev, of_fwnode_handle(of_node_get(np))); 116 of_device_make_bus_id(dev); 117 of_msi_configure(dev, dev->of_node); 118 119 ret = device_add(dev); 120 if (ret) { 121 put_device(dev); 122 return ret; 123 } 124 125 return 0; 126 } 127 128 static const struct of_device_id of_nvmem_layout_skip_table[] = { 129 { .compatible = "fixed-layout", }, 130 {} 131 }; 132 133 static int nvmem_layout_bus_populate(struct nvmem_device *nvmem, 134 struct device_node *layout_dn) 135 { 136 int ret; 137 138 /* Make sure it has a compatible property */ 139 if (!of_property_present(layout_dn, "compatible")) { 140 pr_debug("%s() - skipping %pOF, no compatible prop\n", 141 __func__, layout_dn); 142 return 0; 143 } 144 145 /* Fixed layouts are parsed manually somewhere else for now */ 146 if (of_match_node(of_nvmem_layout_skip_table, layout_dn)) { 147 pr_debug("%s() - skipping %pOF node\n", __func__, layout_dn); 148 return 0; 149 } 150 151 if (of_node_check_flag(layout_dn, OF_POPULATED_BUS)) { 152 pr_debug("%s() - skipping %pOF, already populated\n", 153 __func__, layout_dn); 154 155 return 0; 156 } 157 158 /* NVMEM layout buses expect only a single device representing the layout */ 159 ret = nvmem_layout_create_device(nvmem, layout_dn); 160 if (ret) 161 return ret; 162 163 of_node_set_flag(layout_dn, OF_POPULATED_BUS); 164 165 return 0; 166 } 167 168 struct device_node *of_nvmem_layout_get_container(struct nvmem_device *nvmem) 169 { 170 return of_get_child_by_name(nvmem->dev.of_node, "nvmem-layout"); 171 } 172 EXPORT_SYMBOL_GPL(of_nvmem_layout_get_container); 173 174 /* 175 * Returns the number of devices populated, 0 if the operation was not relevant 176 * for this nvmem device, an error code otherwise. 177 */ 178 int nvmem_populate_layout(struct nvmem_device *nvmem) 179 { 180 struct device_node *layout_dn; 181 int ret; 182 183 layout_dn = of_nvmem_layout_get_container(nvmem); 184 if (!layout_dn) 185 return 0; 186 187 /* Populate the layout device */ 188 device_links_supplier_sync_state_pause(); 189 ret = nvmem_layout_bus_populate(nvmem, layout_dn); 190 device_links_supplier_sync_state_resume(); 191 192 of_node_put(layout_dn); 193 return ret; 194 } 195 196 void nvmem_destroy_layout(struct nvmem_device *nvmem) 197 { 198 struct device *dev; 199 200 if (!nvmem->layout) 201 return; 202 203 dev = &nvmem->layout->dev; 204 of_node_clear_flag(dev->of_node, OF_POPULATED_BUS); 205 device_unregister(dev); 206 } 207 208 int nvmem_layout_bus_register(void) 209 { 210 return bus_register(&nvmem_layout_bus_type); 211 } 212 213 void nvmem_layout_bus_unregister(void) 214 { 215 bus_unregister(&nvmem_layout_bus_type); 216 } 217