1 #include <linux/string.h> 2 #include <linux/kernel.h> 3 #include <linux/of.h> 4 #include <linux/of_device.h> 5 #include <linux/of_address.h> 6 #include <linux/of_iommu.h> 7 #include <linux/dma-mapping.h> 8 #include <linux/init.h> 9 #include <linux/module.h> 10 #include <linux/mod_devicetable.h> 11 #include <linux/slab.h> 12 #include <linux/pci.h> 13 #include <linux/platform_device.h> 14 #include <linux/amba/bus.h> 15 16 #include <asm/errno.h> 17 #include "of_private.h" 18 19 /** 20 * of_match_device - Tell if a struct device matches an of_device_id list 21 * @ids: array of of device match structures to search in 22 * @dev: the of device structure to match against 23 * 24 * Used by a driver to check whether an platform_device present in the 25 * system is in its list of supported devices. 26 */ 27 const struct of_device_id *of_match_device(const struct of_device_id *matches, 28 const struct device *dev) 29 { 30 if ((!matches) || (!dev->of_node)) 31 return NULL; 32 return of_match_node(matches, dev->of_node); 33 } 34 EXPORT_SYMBOL(of_match_device); 35 36 struct platform_device *of_dev_get(struct platform_device *dev) 37 { 38 struct device *tmp; 39 40 if (!dev) 41 return NULL; 42 tmp = get_device(&dev->dev); 43 if (tmp) 44 return to_platform_device(tmp); 45 else 46 return NULL; 47 } 48 EXPORT_SYMBOL(of_dev_get); 49 50 void of_dev_put(struct platform_device *dev) 51 { 52 if (dev) 53 put_device(&dev->dev); 54 } 55 EXPORT_SYMBOL(of_dev_put); 56 57 int of_device_add(struct platform_device *ofdev) 58 { 59 BUG_ON(ofdev->dev.of_node == NULL); 60 61 /* name and id have to be set so that the platform bus doesn't get 62 * confused on matching */ 63 ofdev->name = dev_name(&ofdev->dev); 64 ofdev->id = PLATFORM_DEVID_NONE; 65 66 /* 67 * If this device has not binding numa node in devicetree, that is 68 * of_node_to_nid returns NUMA_NO_NODE. device_add will assume that this 69 * device is on the same node as the parent. 70 */ 71 set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node)); 72 73 return device_add(&ofdev->dev); 74 } 75 76 /** 77 * of_dma_configure - Setup DMA configuration 78 * @dev: Device to apply DMA configuration 79 * @np: Pointer to OF node having DMA configuration 80 * 81 * Try to get devices's DMA configuration from DT and update it 82 * accordingly. 83 * 84 * If platform code needs to use its own special DMA configuration, it 85 * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events 86 * to fix up DMA configuration. 87 */ 88 int of_dma_configure(struct device *dev, struct device_node *np) 89 { 90 u64 dma_addr, paddr, size = 0; 91 int ret; 92 bool coherent; 93 unsigned long offset; 94 const struct iommu_ops *iommu; 95 u64 mask; 96 97 ret = of_dma_get_range(np, &dma_addr, &paddr, &size); 98 if (ret < 0) { 99 /* 100 * For legacy reasons, we have to assume some devices need 101 * DMA configuration regardless of whether "dma-ranges" is 102 * correctly specified or not. 103 */ 104 if (!dev_is_pci(dev) && 105 #ifdef CONFIG_ARM_AMBA 106 dev->bus != &amba_bustype && 107 #endif 108 dev->bus != &platform_bus_type) 109 return ret == -ENODEV ? 0 : ret; 110 111 dma_addr = offset = 0; 112 } else { 113 offset = PFN_DOWN(paddr - dma_addr); 114 115 /* 116 * Add a work around to treat the size as mask + 1 in case 117 * it is defined in DT as a mask. 118 */ 119 if (size & 1) { 120 dev_warn(dev, "Invalid size 0x%llx for dma-range\n", 121 size); 122 size = size + 1; 123 } 124 125 if (!size) { 126 dev_err(dev, "Adjusted size 0x%llx invalid\n", size); 127 return -EINVAL; 128 } 129 dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", offset); 130 } 131 132 /* 133 * Set default coherent_dma_mask to 32 bit. Drivers are expected to 134 * setup the correct supported mask. 135 */ 136 if (!dev->coherent_dma_mask) 137 dev->coherent_dma_mask = DMA_BIT_MASK(32); 138 /* 139 * Set it to coherent_dma_mask by default if the architecture 140 * code has not set it. 141 */ 142 if (!dev->dma_mask) 143 dev->dma_mask = &dev->coherent_dma_mask; 144 145 if (!size) 146 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1); 147 148 dev->dma_pfn_offset = offset; 149 150 /* 151 * Limit coherent and dma mask based on size and default mask 152 * set by the driver. 153 */ 154 mask = DMA_BIT_MASK(ilog2(dma_addr + size - 1) + 1); 155 dev->coherent_dma_mask &= mask; 156 *dev->dma_mask &= mask; 157 158 coherent = of_dma_is_coherent(np); 159 dev_dbg(dev, "device is%sdma coherent\n", 160 coherent ? " " : " not "); 161 162 iommu = of_iommu_configure(dev, np); 163 if (IS_ERR(iommu) && PTR_ERR(iommu) == -EPROBE_DEFER) 164 return -EPROBE_DEFER; 165 166 dev_dbg(dev, "device is%sbehind an iommu\n", 167 iommu ? " " : " not "); 168 169 arch_setup_dma_ops(dev, dma_addr, size, iommu, coherent); 170 171 return 0; 172 } 173 EXPORT_SYMBOL_GPL(of_dma_configure); 174 175 /** 176 * of_dma_deconfigure - Clean up DMA configuration 177 * @dev: Device for which to clean up DMA configuration 178 * 179 * Clean up all configuration performed by of_dma_configure_ops() and free all 180 * resources that have been allocated. 181 */ 182 void of_dma_deconfigure(struct device *dev) 183 { 184 arch_teardown_dma_ops(dev); 185 } 186 187 int of_device_register(struct platform_device *pdev) 188 { 189 device_initialize(&pdev->dev); 190 return of_device_add(pdev); 191 } 192 EXPORT_SYMBOL(of_device_register); 193 194 void of_device_unregister(struct platform_device *ofdev) 195 { 196 device_unregister(&ofdev->dev); 197 } 198 EXPORT_SYMBOL(of_device_unregister); 199 200 const void *of_device_get_match_data(const struct device *dev) 201 { 202 const struct of_device_id *match; 203 204 match = of_match_device(dev->driver->of_match_table, dev); 205 if (!match) 206 return NULL; 207 208 return match->data; 209 } 210 EXPORT_SYMBOL(of_device_get_match_data); 211 212 static ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len) 213 { 214 const char *compat; 215 char *c; 216 struct property *p; 217 ssize_t csize; 218 ssize_t tsize; 219 220 if ((!dev) || (!dev->of_node)) 221 return -ENODEV; 222 223 /* Name & Type */ 224 csize = snprintf(str, len, "of:N%sT%s", dev->of_node->name, 225 dev->of_node->type); 226 tsize = csize; 227 len -= csize; 228 if (str) 229 str += csize; 230 231 of_property_for_each_string(dev->of_node, "compatible", p, compat) { 232 csize = strlen(compat) + 1; 233 tsize += csize; 234 if (csize > len) 235 continue; 236 237 csize = snprintf(str, len, "C%s", compat); 238 for (c = str; c; ) { 239 c = strchr(c, ' '); 240 if (c) 241 *c++ = '_'; 242 } 243 len -= csize; 244 str += csize; 245 } 246 247 return tsize; 248 } 249 250 int of_device_request_module(struct device *dev) 251 { 252 char *str; 253 ssize_t size; 254 int ret; 255 256 size = of_device_get_modalias(dev, NULL, 0); 257 if (size < 0) 258 return size; 259 260 str = kmalloc(size + 1, GFP_KERNEL); 261 if (!str) 262 return -ENOMEM; 263 264 of_device_get_modalias(dev, str, size); 265 str[size] = '\0'; 266 ret = request_module(str); 267 kfree(str); 268 269 return ret; 270 } 271 EXPORT_SYMBOL_GPL(of_device_request_module); 272 273 /** 274 * of_device_modalias - Fill buffer with newline terminated modalias string 275 */ 276 ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len) 277 { 278 ssize_t sl = of_device_get_modalias(dev, str, len - 2); 279 if (sl < 0) 280 return sl; 281 if (sl > len - 2) 282 return -ENOMEM; 283 284 str[sl++] = '\n'; 285 str[sl] = 0; 286 return sl; 287 } 288 EXPORT_SYMBOL_GPL(of_device_modalias); 289 290 /** 291 * of_device_uevent - Display OF related uevent information 292 */ 293 void of_device_uevent(struct device *dev, struct kobj_uevent_env *env) 294 { 295 const char *compat; 296 struct alias_prop *app; 297 struct property *p; 298 int seen = 0; 299 300 if ((!dev) || (!dev->of_node)) 301 return; 302 303 add_uevent_var(env, "OF_NAME=%s", dev->of_node->name); 304 add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node); 305 if (dev->of_node->type && strcmp("<NULL>", dev->of_node->type) != 0) 306 add_uevent_var(env, "OF_TYPE=%s", dev->of_node->type); 307 308 /* Since the compatible field can contain pretty much anything 309 * it's not really legal to split it out with commas. We split it 310 * up using a number of environment variables instead. */ 311 of_property_for_each_string(dev->of_node, "compatible", p, compat) { 312 add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat); 313 seen++; 314 } 315 add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen); 316 317 seen = 0; 318 mutex_lock(&of_mutex); 319 list_for_each_entry(app, &aliases_lookup, link) { 320 if (dev->of_node == app->np) { 321 add_uevent_var(env, "OF_ALIAS_%d=%s", seen, 322 app->alias); 323 seen++; 324 } 325 } 326 mutex_unlock(&of_mutex); 327 } 328 329 int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env) 330 { 331 int sl; 332 333 if ((!dev) || (!dev->of_node)) 334 return -ENODEV; 335 336 /* Devicetree modalias is tricky, we add it in 2 steps */ 337 if (add_uevent_var(env, "MODALIAS=")) 338 return -ENOMEM; 339 340 sl = of_device_get_modalias(dev, &env->buf[env->buflen-1], 341 sizeof(env->buf) - env->buflen); 342 if (sl >= (sizeof(env->buf) - env->buflen)) 343 return -ENOMEM; 344 env->buflen += sl; 345 346 return 0; 347 } 348 EXPORT_SYMBOL_GPL(of_device_uevent_modalias); 349