blob: bb2264cc410bd7d4cbfa7f0ce6ba7d13b3ee8aee [file] [log] [blame]
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +01001/*
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 Ortiz91feded2010-02-19 11:07:59 +010016#include <linux/acpi.h>
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010017#include <linux/mfd/core.h>
Mark Brown4c90aa92010-11-26 17:19:34 +000018#include <linux/pm_runtime.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010020
Andres Salomon1e29af62011-02-17 19:07:34 -080021int mfd_shared_cell_enable(struct platform_device *pdev)
22{
23 const struct mfd_cell *cell = mfd_get_cell(pdev);
24 int err = 0;
25
26 /* only call enable hook if the cell wasn't previously enabled */
27 if (atomic_inc_return(cell->usage_count) == 1)
28 err = cell->enable(pdev);
29
30 /* if the enable hook failed, decrement counter to allow retries */
31 if (err)
32 atomic_dec(cell->usage_count);
33
34 return err;
35}
36EXPORT_SYMBOL(mfd_shared_cell_enable);
37
38int mfd_shared_cell_disable(struct platform_device *pdev)
39{
40 const struct mfd_cell *cell = mfd_get_cell(pdev);
41 int err = 0;
42
43 /* only disable if no other clients are using it */
44 if (atomic_dec_return(cell->usage_count) == 0)
45 err = cell->disable(pdev);
46
47 /* if the disable hook failed, increment to allow retries */
48 if (err)
49 atomic_inc(cell->usage_count);
50
51 /* sanity check; did someone call disable too many times? */
52 WARN_ON(atomic_read(cell->usage_count) < 0);
53
54 return err;
55}
56EXPORT_SYMBOL(mfd_shared_cell_disable);
57
Dmitry Baryshkov424f5252008-07-29 01:30:26 +020058static int mfd_add_device(struct device *parent, int id,
Ben Dooks7f71ac92008-07-28 18:29:09 +020059 const struct mfd_cell *cell,
60 struct resource *mem_base,
61 int irq_base)
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010062{
Ian Moltona87903f2008-07-25 22:59:29 +010063 struct resource *res;
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010064 struct platform_device *pdev;
65 int ret = -ENOMEM;
66 int r;
67
Mark Brown3bed6e42009-07-27 14:45:51 +010068 pdev = platform_device_alloc(cell->name, id + cell->id);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010069 if (!pdev)
70 goto fail_alloc;
71
Ian Moltona87903f2008-07-25 22:59:29 +010072 res = kzalloc(sizeof(*res) * cell->num_resources, GFP_KERNEL);
73 if (!res)
74 goto fail_device;
75
Dmitry Baryshkov424f5252008-07-29 01:30:26 +020076 pdev->dev.parent = parent;
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010077
Andres Salomonfe891a02011-02-17 19:07:09 -080078 ret = platform_device_add_data(pdev, cell, sizeof(*cell));
79 if (ret)
80 goto fail_res;
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010081
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010082 for (r = 0; r < cell->num_resources; r++) {
83 res[r].name = cell->resources[r].name;
84 res[r].flags = cell->resources[r].flags;
85
86 /* Find out base to use */
Samuel Ortizf03cfcb2010-03-26 01:09:04 +010087 if ((cell->resources[r].flags & IORESOURCE_MEM) && mem_base) {
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +010088 res[r].parent = mem_base;
89 res[r].start = mem_base->start +
90 cell->resources[r].start;
91 res[r].end = mem_base->start +
92 cell->resources[r].end;
93 } else if (cell->resources[r].flags & IORESOURCE_IRQ) {
94 res[r].start = irq_base +
95 cell->resources[r].start;
96 res[r].end = irq_base +
97 cell->resources[r].end;
98 } else {
99 res[r].parent = cell->resources[r].parent;
100 res[r].start = cell->resources[r].start;
101 res[r].end = cell->resources[r].end;
102 }
Samuel Ortiz91feded2010-02-19 11:07:59 +0100103
Daniel Drake5f2545f2010-09-30 21:55:36 +0100104 if (!cell->ignore_resource_conflicts) {
105 ret = acpi_check_resource_conflict(res);
106 if (ret)
107 goto fail_res;
108 }
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100109 }
110
Axel Lin8af5fe32010-05-31 17:30:55 +0800111 ret = platform_device_add_resources(pdev, res, cell->num_resources);
112 if (ret)
113 goto fail_res;
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100114
115 ret = platform_device_add(pdev);
116 if (ret)
Ian Moltona87903f2008-07-25 22:59:29 +0100117 goto fail_res;
118
Mark Brown4c90aa92010-11-26 17:19:34 +0000119 if (cell->pm_runtime_no_callbacks)
120 pm_runtime_no_callbacks(&pdev->dev);
121
Ian Moltona87903f2008-07-25 22:59:29 +0100122 kfree(res);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100123
124 return 0;
125
126/* platform_device_del(pdev); */
Ian Moltona87903f2008-07-25 22:59:29 +0100127fail_res:
128 kfree(res);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100129fail_device:
130 platform_device_put(pdev);
131fail_alloc:
132 return ret;
133}
134
Dmitry Baryshkov424f5252008-07-29 01:30:26 +0200135int mfd_add_devices(struct device *parent, int id,
Andres Salomon1e29af62011-02-17 19:07:34 -0800136 struct mfd_cell *cells, int n_devs,
Ben Dooks7f71ac92008-07-28 18:29:09 +0200137 struct resource *mem_base,
138 int irq_base)
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100139{
140 int i;
141 int ret = 0;
Andres Salomon1e29af62011-02-17 19:07:34 -0800142 atomic_t *cnts;
143
144 /* initialize reference counting for all cells */
145 cnts = kcalloc(sizeof(*cnts), n_devs, GFP_KERNEL);
146 if (!cnts)
147 return -ENOMEM;
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100148
149 for (i = 0; i < n_devs; i++) {
Andres Salomon1e29af62011-02-17 19:07:34 -0800150 atomic_set(&cnts[i], 0);
151 cells[i].usage_count = &cnts[i];
Dmitry Baryshkov424f5252008-07-29 01:30:26 +0200152 ret = mfd_add_device(parent, id, cells + i, mem_base, irq_base);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100153 if (ret)
154 break;
155 }
156
157 if (ret)
158 mfd_remove_devices(parent);
159
160 return ret;
161}
162EXPORT_SYMBOL(mfd_add_devices);
163
Andres Salomon1e29af62011-02-17 19:07:34 -0800164static int mfd_remove_devices_fn(struct device *dev, void *c)
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100165{
Andres Salomon1e29af62011-02-17 19:07:34 -0800166 struct platform_device *pdev = to_platform_device(dev);
167 const struct mfd_cell *cell = mfd_get_cell(pdev);
168 atomic_t **usage_count = c;
169
170 /* find the base address of usage_count pointers (for freeing) */
171 if (!*usage_count || (cell->usage_count < *usage_count))
172 *usage_count = cell->usage_count;
173
174 platform_device_unregister(pdev);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100175 return 0;
176}
177
Dmitry Baryshkov424f5252008-07-29 01:30:26 +0200178void mfd_remove_devices(struct device *parent)
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100179{
Andres Salomon1e29af62011-02-17 19:07:34 -0800180 atomic_t *cnts = NULL;
181
182 device_for_each_child(parent, &cnts, mfd_remove_devices_fn);
183 kfree(cnts);
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100184}
185EXPORT_SYMBOL(mfd_remove_devices);
186
Andres Salomona9bbba92011-02-17 19:07:35 -0800187static int add_shared_platform_device(const char *cell, const char *name)
188{
189 struct mfd_cell cell_entry;
190 struct device *dev;
191 struct platform_device *pdev;
192 int err;
193
194 /* check if we've already registered a device (don't fail if we have) */
195 if (bus_find_device_by_name(&platform_bus_type, NULL, name))
196 return 0;
197
198 /* fetch the parent cell's device (should already be registered!) */
199 dev = bus_find_device_by_name(&platform_bus_type, NULL, cell);
200 if (!dev) {
201 printk(KERN_ERR "failed to find device for cell %s\n", cell);
202 return -ENODEV;
203 }
204 pdev = to_platform_device(dev);
205 memcpy(&cell_entry, mfd_get_cell(pdev), sizeof(cell_entry));
206
207 WARN_ON(!cell_entry.enable);
208
209 cell_entry.name = name;
210 err = mfd_add_device(pdev->dev.parent, -1, &cell_entry, NULL, 0);
211 if (err)
212 dev_err(dev, "MFD add devices failed: %d\n", err);
213 return err;
214}
215
216int mfd_shared_platform_driver_register(struct platform_driver *drv,
217 const char *cellname)
218{
219 int err;
220
221 err = add_shared_platform_device(cellname, drv->driver.name);
222 if (err)
223 printk(KERN_ERR "failed to add platform device %s\n",
224 drv->driver.name);
225
226 err = platform_driver_register(drv);
227 if (err)
228 printk(KERN_ERR "failed to add platform driver %s\n",
229 drv->driver.name);
230
231 return err;
232}
233EXPORT_SYMBOL(mfd_shared_platform_driver_register);
234
235void mfd_shared_platform_driver_unregister(struct platform_driver *drv)
236{
237 struct device *dev;
238
239 dev = bus_find_device_by_name(&platform_bus_type, NULL,
240 drv->driver.name);
241 if (dev)
242 platform_device_unregister(to_platform_device(dev));
243
244 platform_driver_unregister(drv);
245}
246EXPORT_SYMBOL(mfd_shared_platform_driver_unregister);
247
Dmitry Baryshkovaa613de2008-06-27 10:37:19 +0100248MODULE_LICENSE("GPL");
249MODULE_AUTHOR("Ian Molton, Dmitry Baryshkov");