MFD: mcp-core: fix complaints from the genirq layer
[linux-2.6.git] / drivers / mfd / mcp-core.c
1 /*
2  *  linux/drivers/mfd/mcp-core.c
3  *
4  *  Copyright (C) 2001 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License.
9  *
10  *  Generic MCP (Multimedia Communications Port) layer.  All MCP locking
11  *  is solely held within this file.
12  */
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/errno.h>
16 #include <linux/smp.h>
17 #include <linux/device.h>
18 #include <linux/slab.h>
19 #include <linux/string.h>
20 #include <linux/mfd/mcp.h>
21
22 #include <mach/dma.h>
23 #include <asm/system.h>
24
25
26 #define to_mcp(d)               container_of(d, struct mcp, attached_device)
27 #define to_mcp_driver(d)        container_of(d, struct mcp_driver, drv)
28
29 static int mcp_bus_match(struct device *dev, struct device_driver *drv)
30 {
31         return 1;
32 }
33
34 static int mcp_bus_probe(struct device *dev)
35 {
36         struct mcp *mcp = to_mcp(dev);
37         struct mcp_driver *drv = to_mcp_driver(dev->driver);
38
39         return drv->probe(mcp);
40 }
41
42 static int mcp_bus_remove(struct device *dev)
43 {
44         struct mcp *mcp = to_mcp(dev);
45         struct mcp_driver *drv = to_mcp_driver(dev->driver);
46
47         drv->remove(mcp);
48         return 0;
49 }
50
51 static int mcp_bus_suspend(struct device *dev, pm_message_t state)
52 {
53         struct mcp *mcp = to_mcp(dev);
54         int ret = 0;
55
56         if (dev->driver) {
57                 struct mcp_driver *drv = to_mcp_driver(dev->driver);
58
59                 ret = drv->suspend(mcp, state);
60         }
61         return ret;
62 }
63
64 static int mcp_bus_resume(struct device *dev)
65 {
66         struct mcp *mcp = to_mcp(dev);
67         int ret = 0;
68
69         if (dev->driver) {
70                 struct mcp_driver *drv = to_mcp_driver(dev->driver);
71
72                 ret = drv->resume(mcp);
73         }
74         return ret;
75 }
76
77 static struct bus_type mcp_bus_type = {
78         .name           = "mcp",
79         .match          = mcp_bus_match,
80         .probe          = mcp_bus_probe,
81         .remove         = mcp_bus_remove,
82         .suspend        = mcp_bus_suspend,
83         .resume         = mcp_bus_resume,
84 };
85
86 /**
87  *      mcp_set_telecom_divisor - set the telecom divisor
88  *      @mcp: MCP interface structure
89  *      @div: SIB clock divisor
90  *
91  *      Set the telecom divisor on the MCP interface.  The resulting
92  *      sample rate is SIBCLOCK/div.
93  */
94 void mcp_set_telecom_divisor(struct mcp *mcp, unsigned int div)
95 {
96         unsigned long flags;
97
98         spin_lock_irqsave(&mcp->lock, flags);
99         mcp->ops->set_telecom_divisor(mcp, div);
100         spin_unlock_irqrestore(&mcp->lock, flags);
101 }
102 EXPORT_SYMBOL(mcp_set_telecom_divisor);
103
104 /**
105  *      mcp_set_audio_divisor - set the audio divisor
106  *      @mcp: MCP interface structure
107  *      @div: SIB clock divisor
108  *
109  *      Set the audio divisor on the MCP interface.
110  */
111 void mcp_set_audio_divisor(struct mcp *mcp, unsigned int div)
112 {
113         unsigned long flags;
114
115         spin_lock_irqsave(&mcp->lock, flags);
116         mcp->ops->set_audio_divisor(mcp, div);
117         spin_unlock_irqrestore(&mcp->lock, flags);
118 }
119 EXPORT_SYMBOL(mcp_set_audio_divisor);
120
121 /**
122  *      mcp_reg_write - write a device register
123  *      @mcp: MCP interface structure
124  *      @reg: 4-bit register index
125  *      @val: 16-bit data value
126  *
127  *      Write a device register.  The MCP interface must be enabled
128  *      to prevent this function hanging.
129  */
130 void mcp_reg_write(struct mcp *mcp, unsigned int reg, unsigned int val)
131 {
132         unsigned long flags;
133
134         spin_lock_irqsave(&mcp->lock, flags);
135         mcp->ops->reg_write(mcp, reg, val);
136         spin_unlock_irqrestore(&mcp->lock, flags);
137 }
138 EXPORT_SYMBOL(mcp_reg_write);
139
140 /**
141  *      mcp_reg_read - read a device register
142  *      @mcp: MCP interface structure
143  *      @reg: 4-bit register index
144  *
145  *      Read a device register and return its value.  The MCP interface
146  *      must be enabled to prevent this function hanging.
147  */
148 unsigned int mcp_reg_read(struct mcp *mcp, unsigned int reg)
149 {
150         unsigned long flags;
151         unsigned int val;
152
153         spin_lock_irqsave(&mcp->lock, flags);
154         val = mcp->ops->reg_read(mcp, reg);
155         spin_unlock_irqrestore(&mcp->lock, flags);
156
157         return val;
158 }
159 EXPORT_SYMBOL(mcp_reg_read);
160
161 /**
162  *      mcp_enable - enable the MCP interface
163  *      @mcp: MCP interface to enable
164  *
165  *      Enable the MCP interface.  Each call to mcp_enable will need
166  *      a corresponding call to mcp_disable to disable the interface.
167  */
168 void mcp_enable(struct mcp *mcp)
169 {
170         unsigned long flags;
171         spin_lock_irqsave(&mcp->lock, flags);
172         if (mcp->use_count++ == 0)
173                 mcp->ops->enable(mcp);
174         spin_unlock_irqrestore(&mcp->lock, flags);
175 }
176 EXPORT_SYMBOL(mcp_enable);
177
178 /**
179  *      mcp_disable - disable the MCP interface
180  *      @mcp: MCP interface to disable
181  *
182  *      Disable the MCP interface.  The MCP interface will only be
183  *      disabled once the number of calls to mcp_enable matches the
184  *      number of calls to mcp_disable.
185  */
186 void mcp_disable(struct mcp *mcp)
187 {
188         unsigned long flags;
189
190         spin_lock_irqsave(&mcp->lock, flags);
191         if (--mcp->use_count == 0)
192                 mcp->ops->disable(mcp);
193         spin_unlock_irqrestore(&mcp->lock, flags);
194 }
195 EXPORT_SYMBOL(mcp_disable);
196
197 static void mcp_release(struct device *dev)
198 {
199         struct mcp *mcp = container_of(dev, struct mcp, attached_device);
200
201         kfree(mcp);
202 }
203
204 struct mcp *mcp_host_alloc(struct device *parent, size_t size)
205 {
206         struct mcp *mcp;
207
208         mcp = kzalloc(sizeof(struct mcp) + size, GFP_KERNEL);
209         if (mcp) {
210                 spin_lock_init(&mcp->lock);
211                 mcp->attached_device.parent = parent;
212                 mcp->attached_device.bus = &mcp_bus_type;
213                 mcp->attached_device.dma_mask = parent->dma_mask;
214                 mcp->attached_device.release = mcp_release;
215         }
216         return mcp;
217 }
218 EXPORT_SYMBOL(mcp_host_alloc);
219
220 int mcp_host_register(struct mcp *mcp)
221 {
222         dev_set_name(&mcp->attached_device, "mcp0");
223         return device_register(&mcp->attached_device);
224 }
225 EXPORT_SYMBOL(mcp_host_register);
226
227 void mcp_host_unregister(struct mcp *mcp)
228 {
229         device_unregister(&mcp->attached_device);
230 }
231 EXPORT_SYMBOL(mcp_host_unregister);
232
233 int mcp_driver_register(struct mcp_driver *mcpdrv)
234 {
235         mcpdrv->drv.bus = &mcp_bus_type;
236         return driver_register(&mcpdrv->drv);
237 }
238 EXPORT_SYMBOL(mcp_driver_register);
239
240 void mcp_driver_unregister(struct mcp_driver *mcpdrv)
241 {
242         driver_unregister(&mcpdrv->drv);
243 }
244 EXPORT_SYMBOL(mcp_driver_unregister);
245
246 static int __init mcp_init(void)
247 {
248         return bus_register(&mcp_bus_type);
249 }
250
251 static void __exit mcp_exit(void)
252 {
253         bus_unregister(&mcp_bus_type);
254 }
255
256 module_init(mcp_init);
257 module_exit(mcp_exit);
258
259 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
260 MODULE_DESCRIPTION("Core multimedia communications port driver");
261 MODULE_LICENSE("GPL");