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