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