Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 1 | /* |
| 2 | * drivers/mfd/mfd-core.c |
| 3 | * |
| 4 | * core MFD support |
| 5 | * Copyright (c) 2006 Ian Molton |
| 6 | * Copyright (c) 2007,2008 Dmitry Baryshkov |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | * |
| 12 | */ |
| 13 | |
| 14 | #include <linux/kernel.h> |
| 15 | #include <linux/platform_device.h> |
Samuel Ortiz | 91feded | 2010-02-19 11:07:59 +0100 | [diff] [blame] | 16 | #include <linux/acpi.h> |
Andy Shevchenko | 4d215ca | 2015-11-30 17:11:40 +0200 | [diff] [blame] | 17 | #include <linux/property.h> |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 18 | #include <linux/mfd/core.h> |
Mark Brown | 4c90aa9 | 2010-11-26 17:19:34 +0000 | [diff] [blame] | 19 | #include <linux/pm_runtime.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 20 | #include <linux/slab.h> |
Paul Gortmaker | 4e36dd3 | 2011-07-03 15:13:27 -0400 | [diff] [blame] | 21 | #include <linux/module.h> |
Lee Jones | c94bb23 | 2012-06-29 19:01:03 +0200 | [diff] [blame] | 22 | #include <linux/irqdomain.h> |
| 23 | #include <linux/of.h> |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 24 | #include <linux/regulator/consumer.h> |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 25 | |
Charles Keepax | b9fbb62 | 2012-11-09 16:15:28 +0000 | [diff] [blame] | 26 | static struct device_type mfd_dev_type = { |
| 27 | .name = "mfd_device", |
| 28 | }; |
| 29 | |
Andres Salomon | f77289a | 2011-03-03 09:51:58 -0800 | [diff] [blame] | 30 | int mfd_cell_enable(struct platform_device *pdev) |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 31 | { |
| 32 | const struct mfd_cell *cell = mfd_get_cell(pdev); |
| 33 | int err = 0; |
| 34 | |
| 35 | /* only call enable hook if the cell wasn't previously enabled */ |
| 36 | if (atomic_inc_return(cell->usage_count) == 1) |
| 37 | err = cell->enable(pdev); |
| 38 | |
| 39 | /* if the enable hook failed, decrement counter to allow retries */ |
| 40 | if (err) |
| 41 | atomic_dec(cell->usage_count); |
| 42 | |
| 43 | return err; |
| 44 | } |
Andres Salomon | f77289a | 2011-03-03 09:51:58 -0800 | [diff] [blame] | 45 | EXPORT_SYMBOL(mfd_cell_enable); |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 46 | |
Andres Salomon | f77289a | 2011-03-03 09:51:58 -0800 | [diff] [blame] | 47 | int mfd_cell_disable(struct platform_device *pdev) |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 48 | { |
| 49 | const struct mfd_cell *cell = mfd_get_cell(pdev); |
| 50 | int err = 0; |
| 51 | |
| 52 | /* only disable if no other clients are using it */ |
| 53 | if (atomic_dec_return(cell->usage_count) == 0) |
| 54 | err = cell->disable(pdev); |
| 55 | |
| 56 | /* if the disable hook failed, increment to allow retries */ |
| 57 | if (err) |
| 58 | atomic_inc(cell->usage_count); |
| 59 | |
| 60 | /* sanity check; did someone call disable too many times? */ |
| 61 | WARN_ON(atomic_read(cell->usage_count) < 0); |
| 62 | |
| 63 | return err; |
| 64 | } |
Andres Salomon | f77289a | 2011-03-03 09:51:58 -0800 | [diff] [blame] | 65 | EXPORT_SYMBOL(mfd_cell_disable); |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 66 | |
Samuel Ortiz | e710d7d | 2011-04-08 00:43:01 +0200 | [diff] [blame] | 67 | static int mfd_platform_add_cell(struct platform_device *pdev, |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 68 | const struct mfd_cell *cell, |
| 69 | atomic_t *usage_count) |
Samuel Ortiz | e710d7d | 2011-04-08 00:43:01 +0200 | [diff] [blame] | 70 | { |
| 71 | if (!cell) |
| 72 | return 0; |
| 73 | |
| 74 | pdev->mfd_cell = kmemdup(cell, sizeof(*cell), GFP_KERNEL); |
| 75 | if (!pdev->mfd_cell) |
| 76 | return -ENOMEM; |
| 77 | |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 78 | pdev->mfd_cell->usage_count = usage_count; |
Samuel Ortiz | e710d7d | 2011-04-08 00:43:01 +0200 | [diff] [blame] | 79 | return 0; |
| 80 | } |
| 81 | |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 82 | #if IS_ENABLED(CONFIG_ACPI) |
| 83 | static void mfd_acpi_add_device(const struct mfd_cell *cell, |
| 84 | struct platform_device *pdev) |
| 85 | { |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 86 | const struct mfd_cell_acpi_match *match = cell->acpi_match; |
| 87 | struct acpi_device *parent, *child; |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 88 | struct acpi_device *adev; |
| 89 | |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 90 | parent = ACPI_COMPANION(pdev->dev.parent); |
| 91 | if (!parent) |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 92 | return; |
| 93 | |
| 94 | /* |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 95 | * MFD child device gets its ACPI handle either from the ACPI device |
| 96 | * directly under the parent that matches the either _HID or _CID, or |
| 97 | * _ADR or it will use the parent handle if is no ID is given. |
| 98 | * |
| 99 | * Note that use of _ADR is a grey area in the ACPI specification, |
| 100 | * though Intel Galileo Gen2 is using it to distinguish the children |
| 101 | * devices. |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 102 | */ |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 103 | adev = parent; |
| 104 | if (match) { |
| 105 | if (match->pnpid) { |
| 106 | struct acpi_device_id ids[2] = {}; |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 107 | |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 108 | strlcpy(ids[0].id, match->pnpid, sizeof(ids[0].id)); |
| 109 | list_for_each_entry(child, &parent->children, node) { |
Irina Tirdea | ee414de | 2016-03-13 03:02:58 +0200 | [diff] [blame] | 110 | if (!acpi_match_device_ids(child, ids)) { |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 111 | adev = child; |
| 112 | break; |
| 113 | } |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 114 | } |
Andy Shevchenko | 98a3be4 | 2015-10-23 12:16:41 +0300 | [diff] [blame] | 115 | } else { |
| 116 | unsigned long long adr; |
| 117 | acpi_status status; |
| 118 | |
| 119 | list_for_each_entry(child, &parent->children, node) { |
| 120 | status = acpi_evaluate_integer(child->handle, |
| 121 | "_ADR", NULL, |
| 122 | &adr); |
| 123 | if (ACPI_SUCCESS(status) && match->adr == adr) { |
| 124 | adev = child; |
| 125 | break; |
| 126 | } |
| 127 | } |
| 128 | } |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | ACPI_COMPANION_SET(&pdev->dev, adev); |
| 132 | } |
| 133 | #else |
| 134 | static inline void mfd_acpi_add_device(const struct mfd_cell *cell, |
| 135 | struct platform_device *pdev) |
| 136 | { |
| 137 | } |
| 138 | #endif |
| 139 | |
Dmitry Baryshkov | 424f525 | 2008-07-29 01:30:26 +0200 | [diff] [blame] | 140 | static int mfd_add_device(struct device *parent, int id, |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 141 | const struct mfd_cell *cell, atomic_t *usage_count, |
Ben Dooks | 7f71ac9 | 2008-07-28 18:29:09 +0200 | [diff] [blame] | 142 | struct resource *mem_base, |
Mark Brown | 0848c94 | 2012-09-11 15:16:36 +0800 | [diff] [blame] | 143 | int irq_base, struct irq_domain *domain) |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 144 | { |
Ian Molton | a87903f | 2008-07-25 22:59:29 +0100 | [diff] [blame] | 145 | struct resource *res; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 146 | struct platform_device *pdev; |
Lee Jones | c94bb23 | 2012-06-29 19:01:03 +0200 | [diff] [blame] | 147 | struct device_node *np = NULL; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 148 | int ret = -ENOMEM; |
Johan Hovold | 6e3f62f | 2014-09-26 12:55:33 +0200 | [diff] [blame] | 149 | int platform_id; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 150 | int r; |
| 151 | |
Johan Hovold | a77c50b | 2015-03-25 12:07:05 +0100 | [diff] [blame] | 152 | if (id == PLATFORM_DEVID_AUTO) |
Johan Hovold | 6e3f62f | 2014-09-26 12:55:33 +0200 | [diff] [blame] | 153 | platform_id = id; |
| 154 | else |
| 155 | platform_id = id + cell->id; |
| 156 | |
| 157 | pdev = platform_device_alloc(cell->name, platform_id); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 158 | if (!pdev) |
| 159 | goto fail_alloc; |
| 160 | |
Ian Molton | a87903f | 2008-07-25 22:59:29 +0100 | [diff] [blame] | 161 | res = kzalloc(sizeof(*res) * cell->num_resources, GFP_KERNEL); |
| 162 | if (!res) |
| 163 | goto fail_device; |
| 164 | |
Dmitry Baryshkov | 424f525 | 2008-07-29 01:30:26 +0200 | [diff] [blame] | 165 | pdev->dev.parent = parent; |
Charles Keepax | b9fbb62 | 2012-11-09 16:15:28 +0000 | [diff] [blame] | 166 | pdev->dev.type = &mfd_dev_type; |
Benedikt Spranger | b018e13 | 2013-08-13 11:08:38 +0200 | [diff] [blame] | 167 | pdev->dev.dma_mask = parent->dma_mask; |
| 168 | pdev->dev.dma_parms = parent->dma_parms; |
Boris BREZILLON | 4f08df1 | 2014-09-22 21:37:55 +0200 | [diff] [blame] | 169 | pdev->dev.coherent_dma_mask = parent->coherent_dma_mask; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 170 | |
Charles Keepax | d137be0 | 2014-04-24 18:27:25 +0100 | [diff] [blame] | 171 | ret = regulator_bulk_register_supply_alias( |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 172 | &pdev->dev, cell->parent_supplies, |
| 173 | parent, cell->parent_supplies, |
| 174 | cell->num_parent_supplies); |
| 175 | if (ret < 0) |
| 176 | goto fail_res; |
| 177 | |
Lee Jones | c94bb23 | 2012-06-29 19:01:03 +0200 | [diff] [blame] | 178 | if (parent->of_node && cell->of_compatible) { |
| 179 | for_each_child_of_node(parent->of_node, np) { |
| 180 | if (of_device_is_compatible(np, cell->of_compatible)) { |
| 181 | pdev->dev.of_node = np; |
Lee Jones | c94bb23 | 2012-06-29 19:01:03 +0200 | [diff] [blame] | 182 | break; |
| 183 | } |
| 184 | } |
| 185 | } |
| 186 | |
Mika Westerberg | 6ab3430 | 2014-09-16 14:52:36 +0300 | [diff] [blame] | 187 | mfd_acpi_add_device(cell, pdev); |
| 188 | |
Samuel Ortiz | eb89560 | 2011-04-06 16:52:52 +0200 | [diff] [blame] | 189 | if (cell->pdata_size) { |
| 190 | ret = platform_device_add_data(pdev, |
| 191 | cell->platform_data, cell->pdata_size); |
| 192 | if (ret) |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 193 | goto fail_alias; |
Samuel Ortiz | eb89560 | 2011-04-06 16:52:52 +0200 | [diff] [blame] | 194 | } |
| 195 | |
Heikki Krogerus | f4d0526 | 2016-03-29 14:52:23 +0300 | [diff] [blame] | 196 | if (cell->properties) { |
| 197 | ret = platform_device_add_properties(pdev, cell->properties); |
Andy Shevchenko | 4d215ca | 2015-11-30 17:11:40 +0200 | [diff] [blame] | 198 | if (ret) |
| 199 | goto fail_alias; |
| 200 | } |
| 201 | |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 202 | ret = mfd_platform_add_cell(pdev, cell, usage_count); |
Andres Salomon | fe891a0 | 2011-02-17 19:07:09 -0800 | [diff] [blame] | 203 | if (ret) |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 204 | goto fail_alias; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 205 | |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 206 | for (r = 0; r < cell->num_resources; r++) { |
| 207 | res[r].name = cell->resources[r].name; |
| 208 | res[r].flags = cell->resources[r].flags; |
| 209 | |
| 210 | /* Find out base to use */ |
Samuel Ortiz | f03cfcb | 2010-03-26 01:09:04 +0100 | [diff] [blame] | 211 | if ((cell->resources[r].flags & IORESOURCE_MEM) && mem_base) { |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 212 | res[r].parent = mem_base; |
| 213 | res[r].start = mem_base->start + |
| 214 | cell->resources[r].start; |
| 215 | res[r].end = mem_base->start + |
| 216 | cell->resources[r].end; |
| 217 | } else if (cell->resources[r].flags & IORESOURCE_IRQ) { |
Lee Jones | c94bb23 | 2012-06-29 19:01:03 +0200 | [diff] [blame] | 218 | if (domain) { |
| 219 | /* Unable to create mappings for IRQ ranges. */ |
| 220 | WARN_ON(cell->resources[r].start != |
| 221 | cell->resources[r].end); |
| 222 | res[r].start = res[r].end = irq_create_mapping( |
| 223 | domain, cell->resources[r].start); |
| 224 | } else { |
| 225 | res[r].start = irq_base + |
| 226 | cell->resources[r].start; |
| 227 | res[r].end = irq_base + |
| 228 | cell->resources[r].end; |
| 229 | } |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 230 | } else { |
| 231 | res[r].parent = cell->resources[r].parent; |
| 232 | res[r].start = cell->resources[r].start; |
| 233 | res[r].end = cell->resources[r].end; |
| 234 | } |
Samuel Ortiz | 91feded | 2010-02-19 11:07:59 +0100 | [diff] [blame] | 235 | |
Daniel Drake | 5f2545f | 2010-09-30 21:55:36 +0100 | [diff] [blame] | 236 | if (!cell->ignore_resource_conflicts) { |
Lorenzo Pieralisi | ec40c60 | 2015-05-01 10:41:10 +0100 | [diff] [blame] | 237 | if (has_acpi_companion(&pdev->dev)) { |
| 238 | ret = acpi_check_resource_conflict(&res[r]); |
| 239 | if (ret) |
| 240 | goto fail_alias; |
| 241 | } |
Daniel Drake | 5f2545f | 2010-09-30 21:55:36 +0100 | [diff] [blame] | 242 | } |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 243 | } |
| 244 | |
Axel Lin | 8af5fe3 | 2010-05-31 17:30:55 +0800 | [diff] [blame] | 245 | ret = platform_device_add_resources(pdev, res, cell->num_resources); |
| 246 | if (ret) |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 247 | goto fail_alias; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 248 | |
| 249 | ret = platform_device_add(pdev); |
| 250 | if (ret) |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 251 | goto fail_alias; |
Ian Molton | a87903f | 2008-07-25 22:59:29 +0100 | [diff] [blame] | 252 | |
Mark Brown | 4c90aa9 | 2010-11-26 17:19:34 +0000 | [diff] [blame] | 253 | if (cell->pm_runtime_no_callbacks) |
| 254 | pm_runtime_no_callbacks(&pdev->dev); |
| 255 | |
Ian Molton | a87903f | 2008-07-25 22:59:29 +0100 | [diff] [blame] | 256 | kfree(res); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 257 | |
| 258 | return 0; |
| 259 | |
Charles Keepax | 7fcd427 | 2013-10-15 20:14:21 +0100 | [diff] [blame] | 260 | fail_alias: |
Charles Keepax | d137be0 | 2014-04-24 18:27:25 +0100 | [diff] [blame] | 261 | regulator_bulk_unregister_supply_alias(&pdev->dev, |
| 262 | cell->parent_supplies, |
| 263 | cell->num_parent_supplies); |
Ian Molton | a87903f | 2008-07-25 22:59:29 +0100 | [diff] [blame] | 264 | fail_res: |
| 265 | kfree(res); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 266 | fail_device: |
| 267 | platform_device_put(pdev); |
| 268 | fail_alloc: |
| 269 | return ret; |
| 270 | } |
| 271 | |
Dmitry Baryshkov | 424f525 | 2008-07-29 01:30:26 +0200 | [diff] [blame] | 272 | int mfd_add_devices(struct device *parent, int id, |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 273 | const struct mfd_cell *cells, int n_devs, |
Ben Dooks | 7f71ac9 | 2008-07-28 18:29:09 +0200 | [diff] [blame] | 274 | struct resource *mem_base, |
Mark Brown | 0848c94 | 2012-09-11 15:16:36 +0800 | [diff] [blame] | 275 | int irq_base, struct irq_domain *domain) |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 276 | { |
| 277 | int i; |
Geert Uytterhoeven | 0b208e4 | 2013-10-29 15:47:22 +0100 | [diff] [blame] | 278 | int ret; |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 279 | atomic_t *cnts; |
| 280 | |
| 281 | /* initialize reference counting for all cells */ |
Axel Lin | d1b5c5e | 2012-02-12 17:43:22 +0800 | [diff] [blame] | 282 | cnts = kcalloc(n_devs, sizeof(*cnts), GFP_KERNEL); |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 283 | if (!cnts) |
| 284 | return -ENOMEM; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 285 | |
| 286 | for (i = 0; i < n_devs; i++) { |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 287 | atomic_set(&cnts[i], 0); |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 288 | ret = mfd_add_device(parent, id, cells + i, cnts + i, mem_base, |
Mark Brown | 0848c94 | 2012-09-11 15:16:36 +0800 | [diff] [blame] | 289 | irq_base, domain); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 290 | if (ret) |
Geert Uytterhoeven | 0b208e4 | 2013-10-29 15:47:22 +0100 | [diff] [blame] | 291 | goto fail; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 292 | } |
| 293 | |
Geert Uytterhoeven | 0b208e4 | 2013-10-29 15:47:22 +0100 | [diff] [blame] | 294 | return 0; |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 295 | |
Geert Uytterhoeven | 0b208e4 | 2013-10-29 15:47:22 +0100 | [diff] [blame] | 296 | fail: |
| 297 | if (i) |
| 298 | mfd_remove_devices(parent); |
| 299 | else |
| 300 | kfree(cnts); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 301 | return ret; |
| 302 | } |
| 303 | EXPORT_SYMBOL(mfd_add_devices); |
| 304 | |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 305 | static int mfd_remove_devices_fn(struct device *dev, void *c) |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 306 | { |
Charles Keepax | b9fbb62 | 2012-11-09 16:15:28 +0000 | [diff] [blame] | 307 | struct platform_device *pdev; |
| 308 | const struct mfd_cell *cell; |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 309 | atomic_t **usage_count = c; |
| 310 | |
Charles Keepax | b9fbb62 | 2012-11-09 16:15:28 +0000 | [diff] [blame] | 311 | if (dev->type != &mfd_dev_type) |
| 312 | return 0; |
| 313 | |
| 314 | pdev = to_platform_device(dev); |
| 315 | cell = mfd_get_cell(pdev); |
| 316 | |
Charles Keepax | d137be0 | 2014-04-24 18:27:25 +0100 | [diff] [blame] | 317 | regulator_bulk_unregister_supply_alias(dev, cell->parent_supplies, |
| 318 | cell->num_parent_supplies); |
| 319 | |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 320 | /* find the base address of usage_count pointers (for freeing) */ |
| 321 | if (!*usage_count || (cell->usage_count < *usage_count)) |
| 322 | *usage_count = cell->usage_count; |
| 323 | |
| 324 | platform_device_unregister(pdev); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 325 | return 0; |
| 326 | } |
| 327 | |
Dmitry Baryshkov | 424f525 | 2008-07-29 01:30:26 +0200 | [diff] [blame] | 328 | void mfd_remove_devices(struct device *parent) |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 329 | { |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 330 | atomic_t *cnts = NULL; |
| 331 | |
Andy Shevchenko | b9a8a27 | 2015-07-27 18:04:01 +0300 | [diff] [blame] | 332 | device_for_each_child_reverse(parent, &cnts, mfd_remove_devices_fn); |
Andres Salomon | 1e29af6 | 2011-02-17 19:07:34 -0800 | [diff] [blame] | 333 | kfree(cnts); |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 334 | } |
| 335 | EXPORT_SYMBOL(mfd_remove_devices); |
| 336 | |
Laxman Dewangan | a8f447be | 2016-04-08 00:12:55 +0530 | [diff] [blame] | 337 | static void devm_mfd_dev_release(struct device *dev, void *res) |
| 338 | { |
| 339 | mfd_remove_devices(dev); |
| 340 | } |
| 341 | |
| 342 | /** |
| 343 | * devm_mfd_add_devices - Resource managed version of mfd_add_devices() |
| 344 | * |
| 345 | * Returns 0 on success or an appropriate negative error number on failure. |
| 346 | * All child-devices of the MFD will automatically be removed when it gets |
| 347 | * unbinded. |
| 348 | */ |
| 349 | int devm_mfd_add_devices(struct device *dev, int id, |
| 350 | const struct mfd_cell *cells, int n_devs, |
| 351 | struct resource *mem_base, |
| 352 | int irq_base, struct irq_domain *domain) |
| 353 | { |
| 354 | struct device **ptr; |
| 355 | int ret; |
| 356 | |
| 357 | ptr = devres_alloc(devm_mfd_dev_release, sizeof(*ptr), GFP_KERNEL); |
| 358 | if (!ptr) |
| 359 | return -ENOMEM; |
| 360 | |
| 361 | ret = mfd_add_devices(dev, id, cells, n_devs, mem_base, |
| 362 | irq_base, domain); |
| 363 | if (ret < 0) { |
| 364 | devres_free(ptr); |
| 365 | return ret; |
| 366 | } |
| 367 | |
| 368 | *ptr = dev; |
| 369 | devres_add(dev, ptr); |
| 370 | |
| 371 | return ret; |
| 372 | } |
| 373 | EXPORT_SYMBOL(devm_mfd_add_devices); |
| 374 | |
Andres Salomon | fa1df69 | 2011-03-21 19:19:35 -0700 | [diff] [blame] | 375 | int mfd_clone_cell(const char *cell, const char **clones, size_t n_clones) |
Andres Salomon | a9bbba9 | 2011-02-17 19:07:35 -0800 | [diff] [blame] | 376 | { |
| 377 | struct mfd_cell cell_entry; |
| 378 | struct device *dev; |
| 379 | struct platform_device *pdev; |
Andres Salomon | fa1df69 | 2011-03-21 19:19:35 -0700 | [diff] [blame] | 380 | int i; |
Andres Salomon | a9bbba9 | 2011-02-17 19:07:35 -0800 | [diff] [blame] | 381 | |
| 382 | /* fetch the parent cell's device (should already be registered!) */ |
| 383 | dev = bus_find_device_by_name(&platform_bus_type, NULL, cell); |
| 384 | if (!dev) { |
| 385 | printk(KERN_ERR "failed to find device for cell %s\n", cell); |
| 386 | return -ENODEV; |
| 387 | } |
| 388 | pdev = to_platform_device(dev); |
| 389 | memcpy(&cell_entry, mfd_get_cell(pdev), sizeof(cell_entry)); |
| 390 | |
| 391 | WARN_ON(!cell_entry.enable); |
| 392 | |
Andres Salomon | fa1df69 | 2011-03-21 19:19:35 -0700 | [diff] [blame] | 393 | for (i = 0; i < n_clones; i++) { |
| 394 | cell_entry.name = clones[i]; |
| 395 | /* don't give up if a single call fails; just report error */ |
Geert Uytterhoeven | 03e361b | 2013-10-29 10:03:04 +0100 | [diff] [blame] | 396 | if (mfd_add_device(pdev->dev.parent, -1, &cell_entry, |
| 397 | cell_entry.usage_count, NULL, 0, NULL)) |
Andres Salomon | fa1df69 | 2011-03-21 19:19:35 -0700 | [diff] [blame] | 398 | dev_err(dev, "failed to create platform device '%s'\n", |
| 399 | clones[i]); |
| 400 | } |
| 401 | |
| 402 | return 0; |
Andres Salomon | a9bbba9 | 2011-02-17 19:07:35 -0800 | [diff] [blame] | 403 | } |
Andres Salomon | fa1df69 | 2011-03-21 19:19:35 -0700 | [diff] [blame] | 404 | EXPORT_SYMBOL(mfd_clone_cell); |
Andres Salomon | a9bbba9 | 2011-02-17 19:07:35 -0800 | [diff] [blame] | 405 | |
Dmitry Baryshkov | aa613de | 2008-06-27 10:37:19 +0100 | [diff] [blame] | 406 | MODULE_LICENSE("GPL"); |
| 407 | MODULE_AUTHOR("Ian Molton, Dmitry Baryshkov"); |