blob: 55ba23075c90ed688ad2ee88c9608a1fefcda77a [file] [log] [blame]
Russell Kinga4e137a2005-08-18 10:06:59 +01001/*
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>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080018#include <linux/slab.h>
19#include <linux/string.h>
Russell Kinga4e137a2005-08-18 10:06:59 +010020
21#include <asm/dma.h>
22#include <asm/system.h>
23
24#include "mcp.h"
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
29static int mcp_bus_match(struct device *dev, struct device_driver *drv)
30{
31 return 1;
32}
33
34static 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
42static 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
51static 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
64static 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
77static struct bus_type mcp_bus_type = {
78 .name = "mcp",
79 .match = mcp_bus_match,
80 .suspend = mcp_bus_suspend,
81 .resume = mcp_bus_resume,
82};
83
84/**
85 * mcp_set_telecom_divisor - set the telecom divisor
86 * @mcp: MCP interface structure
87 * @div: SIB clock divisor
88 *
89 * Set the telecom divisor on the MCP interface. The resulting
90 * sample rate is SIBCLOCK/div.
91 */
92void mcp_set_telecom_divisor(struct mcp *mcp, unsigned int div)
93{
94 spin_lock_irq(&mcp->lock);
95 mcp->ops->set_telecom_divisor(mcp, div);
96 spin_unlock_irq(&mcp->lock);
97}
98EXPORT_SYMBOL(mcp_set_telecom_divisor);
99
100/**
101 * mcp_set_audio_divisor - set the audio divisor
102 * @mcp: MCP interface structure
103 * @div: SIB clock divisor
104 *
105 * Set the audio divisor on the MCP interface.
106 */
107void mcp_set_audio_divisor(struct mcp *mcp, unsigned int div)
108{
109 spin_lock_irq(&mcp->lock);
110 mcp->ops->set_audio_divisor(mcp, div);
111 spin_unlock_irq(&mcp->lock);
112}
113EXPORT_SYMBOL(mcp_set_audio_divisor);
114
115/**
116 * mcp_reg_write - write a device register
117 * @mcp: MCP interface structure
118 * @reg: 4-bit register index
119 * @val: 16-bit data value
120 *
121 * Write a device register. The MCP interface must be enabled
122 * to prevent this function hanging.
123 */
124void mcp_reg_write(struct mcp *mcp, unsigned int reg, unsigned int val)
125{
126 unsigned long flags;
127
128 spin_lock_irqsave(&mcp->lock, flags);
129 mcp->ops->reg_write(mcp, reg, val);
130 spin_unlock_irqrestore(&mcp->lock, flags);
131}
132EXPORT_SYMBOL(mcp_reg_write);
133
134/**
135 * mcp_reg_read - read a device register
136 * @mcp: MCP interface structure
137 * @reg: 4-bit register index
138 *
139 * Read a device register and return its value. The MCP interface
140 * must be enabled to prevent this function hanging.
141 */
142unsigned int mcp_reg_read(struct mcp *mcp, unsigned int reg)
143{
144 unsigned long flags;
145 unsigned int val;
146
147 spin_lock_irqsave(&mcp->lock, flags);
148 val = mcp->ops->reg_read(mcp, reg);
149 spin_unlock_irqrestore(&mcp->lock, flags);
150
151 return val;
152}
153EXPORT_SYMBOL(mcp_reg_read);
154
155/**
156 * mcp_enable - enable the MCP interface
157 * @mcp: MCP interface to enable
158 *
159 * Enable the MCP interface. Each call to mcp_enable will need
160 * a corresponding call to mcp_disable to disable the interface.
161 */
162void mcp_enable(struct mcp *mcp)
163{
164 spin_lock_irq(&mcp->lock);
165 if (mcp->use_count++ == 0)
166 mcp->ops->enable(mcp);
167 spin_unlock_irq(&mcp->lock);
168}
169EXPORT_SYMBOL(mcp_enable);
170
171/**
172 * mcp_disable - disable the MCP interface
173 * @mcp: MCP interface to disable
174 *
175 * Disable the MCP interface. The MCP interface will only be
176 * disabled once the number of calls to mcp_enable matches the
177 * number of calls to mcp_disable.
178 */
179void mcp_disable(struct mcp *mcp)
180{
181 unsigned long flags;
182
183 spin_lock_irqsave(&mcp->lock, flags);
184 if (--mcp->use_count == 0)
185 mcp->ops->disable(mcp);
186 spin_unlock_irqrestore(&mcp->lock, flags);
187}
188EXPORT_SYMBOL(mcp_disable);
189
190static void mcp_release(struct device *dev)
191{
192 struct mcp *mcp = container_of(dev, struct mcp, attached_device);
193
194 kfree(mcp);
195}
196
197struct mcp *mcp_host_alloc(struct device *parent, size_t size)
198{
199 struct mcp *mcp;
200
201 mcp = kmalloc(sizeof(struct mcp) + size, GFP_KERNEL);
202 if (mcp) {
203 memset(mcp, 0, sizeof(struct mcp) + size);
204 spin_lock_init(&mcp->lock);
205 mcp->attached_device.parent = parent;
206 mcp->attached_device.bus = &mcp_bus_type;
207 mcp->attached_device.dma_mask = parent->dma_mask;
208 mcp->attached_device.release = mcp_release;
209 }
210 return mcp;
211}
212EXPORT_SYMBOL(mcp_host_alloc);
213
214int mcp_host_register(struct mcp *mcp)
215{
216 strcpy(mcp->attached_device.bus_id, "mcp0");
217 return device_register(&mcp->attached_device);
218}
219EXPORT_SYMBOL(mcp_host_register);
220
221void mcp_host_unregister(struct mcp *mcp)
222{
223 device_unregister(&mcp->attached_device);
224}
225EXPORT_SYMBOL(mcp_host_unregister);
226
227int mcp_driver_register(struct mcp_driver *mcpdrv)
228{
229 mcpdrv->drv.bus = &mcp_bus_type;
230 mcpdrv->drv.probe = mcp_bus_probe;
231 mcpdrv->drv.remove = mcp_bus_remove;
232 return driver_register(&mcpdrv->drv);
233}
234EXPORT_SYMBOL(mcp_driver_register);
235
236void mcp_driver_unregister(struct mcp_driver *mcpdrv)
237{
238 driver_unregister(&mcpdrv->drv);
239}
240EXPORT_SYMBOL(mcp_driver_unregister);
241
242static int __init mcp_init(void)
243{
244 return bus_register(&mcp_bus_type);
245}
246
247static void __exit mcp_exit(void)
248{
249 bus_unregister(&mcp_bus_type);
250}
251
252module_init(mcp_init);
253module_exit(mcp_exit);
254
255MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
256MODULE_DESCRIPTION("Core multimedia communications port driver");
257MODULE_LICENSE("GPL");