Loading...
1/*
2 * wm831x-spi.c -- SPI access for Wolfson WM831x PMICs
3 *
4 * Copyright 2009,2010 Wolfson Microelectronics PLC.
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/pm.h>
18#include <linux/spi/spi.h>
19
20#include <linux/mfd/wm831x/core.h>
21
22static int wm831x_spi_read_device(struct wm831x *wm831x, unsigned short reg,
23 int bytes, void *dest)
24{
25 u16 tx_val;
26 u16 *d = dest;
27 int r, ret;
28
29 /* Go register at a time */
30 for (r = reg; r < reg + (bytes / 2); r++) {
31 tx_val = r | 0x8000;
32
33 ret = spi_write_then_read(wm831x->control_data,
34 (u8 *)&tx_val, 2, (u8 *)d, 2);
35 if (ret != 0)
36 return ret;
37
38 *d = be16_to_cpu(*d);
39
40 d++;
41 }
42
43 return 0;
44}
45
46static int wm831x_spi_write_device(struct wm831x *wm831x, unsigned short reg,
47 int bytes, void *src)
48{
49 struct spi_device *spi = wm831x->control_data;
50 u16 *s = src;
51 u16 data[2];
52 int ret, r;
53
54 /* Go register at a time */
55 for (r = reg; r < reg + (bytes / 2); r++) {
56 data[0] = r;
57 data[1] = *s++;
58
59 ret = spi_write(spi, (char *)&data, sizeof(data));
60 if (ret != 0)
61 return ret;
62 }
63
64 return 0;
65}
66
67static int __devinit wm831x_spi_probe(struct spi_device *spi)
68{
69 struct wm831x *wm831x;
70 enum wm831x_parent type;
71
72 /* Currently SPI support for ID tables is unmerged, we're faking it */
73 if (strcmp(spi->modalias, "wm8310") == 0)
74 type = WM8310;
75 else if (strcmp(spi->modalias, "wm8311") == 0)
76 type = WM8311;
77 else if (strcmp(spi->modalias, "wm8312") == 0)
78 type = WM8312;
79 else if (strcmp(spi->modalias, "wm8320") == 0)
80 type = WM8320;
81 else if (strcmp(spi->modalias, "wm8321") == 0)
82 type = WM8321;
83 else if (strcmp(spi->modalias, "wm8325") == 0)
84 type = WM8325;
85 else if (strcmp(spi->modalias, "wm8326") == 0)
86 type = WM8326;
87 else {
88 dev_err(&spi->dev, "Unknown device type\n");
89 return -EINVAL;
90 }
91
92 wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
93 if (wm831x == NULL)
94 return -ENOMEM;
95
96 spi->bits_per_word = 16;
97 spi->mode = SPI_MODE_0;
98
99 dev_set_drvdata(&spi->dev, wm831x);
100 wm831x->dev = &spi->dev;
101 wm831x->control_data = spi;
102 wm831x->read_dev = wm831x_spi_read_device;
103 wm831x->write_dev = wm831x_spi_write_device;
104
105 return wm831x_device_init(wm831x, type, spi->irq);
106}
107
108static int __devexit wm831x_spi_remove(struct spi_device *spi)
109{
110 struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
111
112 wm831x_device_exit(wm831x);
113
114 return 0;
115}
116
117static int wm831x_spi_suspend(struct device *dev)
118{
119 struct wm831x *wm831x = dev_get_drvdata(dev);
120
121 return wm831x_device_suspend(wm831x);
122}
123
124static const struct dev_pm_ops wm831x_spi_pm = {
125 .freeze = wm831x_spi_suspend,
126 .suspend = wm831x_spi_suspend,
127};
128
129static struct spi_driver wm8310_spi_driver = {
130 .driver = {
131 .name = "wm8310",
132 .bus = &spi_bus_type,
133 .owner = THIS_MODULE,
134 .pm = &wm831x_spi_pm,
135 },
136 .probe = wm831x_spi_probe,
137 .remove = __devexit_p(wm831x_spi_remove),
138};
139
140static struct spi_driver wm8311_spi_driver = {
141 .driver = {
142 .name = "wm8311",
143 .bus = &spi_bus_type,
144 .owner = THIS_MODULE,
145 .pm = &wm831x_spi_pm,
146 },
147 .probe = wm831x_spi_probe,
148 .remove = __devexit_p(wm831x_spi_remove),
149};
150
151static struct spi_driver wm8312_spi_driver = {
152 .driver = {
153 .name = "wm8312",
154 .bus = &spi_bus_type,
155 .owner = THIS_MODULE,
156 .pm = &wm831x_spi_pm,
157 },
158 .probe = wm831x_spi_probe,
159 .remove = __devexit_p(wm831x_spi_remove),
160};
161
162static struct spi_driver wm8320_spi_driver = {
163 .driver = {
164 .name = "wm8320",
165 .bus = &spi_bus_type,
166 .owner = THIS_MODULE,
167 .pm = &wm831x_spi_pm,
168 },
169 .probe = wm831x_spi_probe,
170 .remove = __devexit_p(wm831x_spi_remove),
171};
172
173static struct spi_driver wm8321_spi_driver = {
174 .driver = {
175 .name = "wm8321",
176 .bus = &spi_bus_type,
177 .owner = THIS_MODULE,
178 .pm = &wm831x_spi_pm,
179 },
180 .probe = wm831x_spi_probe,
181 .remove = __devexit_p(wm831x_spi_remove),
182};
183
184static struct spi_driver wm8325_spi_driver = {
185 .driver = {
186 .name = "wm8325",
187 .bus = &spi_bus_type,
188 .owner = THIS_MODULE,
189 .pm = &wm831x_spi_pm,
190 },
191 .probe = wm831x_spi_probe,
192 .remove = __devexit_p(wm831x_spi_remove),
193};
194
195static struct spi_driver wm8326_spi_driver = {
196 .driver = {
197 .name = "wm8326",
198 .bus = &spi_bus_type,
199 .owner = THIS_MODULE,
200 .pm = &wm831x_spi_pm,
201 },
202 .probe = wm831x_spi_probe,
203 .remove = __devexit_p(wm831x_spi_remove),
204};
205
206static int __init wm831x_spi_init(void)
207{
208 int ret;
209
210 ret = spi_register_driver(&wm8310_spi_driver);
211 if (ret != 0)
212 pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
213
214 ret = spi_register_driver(&wm8311_spi_driver);
215 if (ret != 0)
216 pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
217
218 ret = spi_register_driver(&wm8312_spi_driver);
219 if (ret != 0)
220 pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
221
222 ret = spi_register_driver(&wm8320_spi_driver);
223 if (ret != 0)
224 pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
225
226 ret = spi_register_driver(&wm8321_spi_driver);
227 if (ret != 0)
228 pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
229
230 ret = spi_register_driver(&wm8325_spi_driver);
231 if (ret != 0)
232 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
233
234 ret = spi_register_driver(&wm8326_spi_driver);
235 if (ret != 0)
236 pr_err("Failed to register WM8326 SPI driver: %d\n", ret);
237
238 return 0;
239}
240subsys_initcall(wm831x_spi_init);
241
242static void __exit wm831x_spi_exit(void)
243{
244 spi_unregister_driver(&wm8326_spi_driver);
245 spi_unregister_driver(&wm8325_spi_driver);
246 spi_unregister_driver(&wm8321_spi_driver);
247 spi_unregister_driver(&wm8320_spi_driver);
248 spi_unregister_driver(&wm8312_spi_driver);
249 spi_unregister_driver(&wm8311_spi_driver);
250 spi_unregister_driver(&wm8310_spi_driver);
251}
252module_exit(wm831x_spi_exit);
253
254MODULE_DESCRIPTION("SPI support for WM831x/2x AudioPlus PMICs");
255MODULE_LICENSE("GPL");
256MODULE_AUTHOR("Mark Brown");
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * wm831x-spi.c -- SPI access for Wolfson WM831x PMICs
4 *
5 * Copyright 2009,2010 Wolfson Microelectronics PLC.
6 *
7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 */
9
10#include <linux/kernel.h>
11#include <linux/init.h>
12#include <linux/of.h>
13#include <linux/pm.h>
14#include <linux/spi/spi.h>
15#include <linux/regmap.h>
16#include <linux/err.h>
17
18#include <linux/mfd/wm831x/core.h>
19
20static int wm831x_spi_probe(struct spi_device *spi)
21{
22 struct wm831x_pdata *pdata = dev_get_platdata(&spi->dev);
23 struct wm831x *wm831x;
24 enum wm831x_parent type;
25 int ret;
26
27 type = (uintptr_t)spi_get_device_match_data(spi);
28 if (!type) {
29 dev_err(&spi->dev, "Failed to match device\n");
30 return -ENODEV;
31 }
32
33 wm831x = devm_kzalloc(&spi->dev, sizeof(struct wm831x), GFP_KERNEL);
34 if (wm831x == NULL)
35 return -ENOMEM;
36
37 spi->mode = SPI_MODE_0;
38
39 spi_set_drvdata(spi, wm831x);
40 wm831x->dev = &spi->dev;
41 wm831x->type = type;
42
43 wm831x->regmap = devm_regmap_init_spi(spi, &wm831x_regmap_config);
44 if (IS_ERR(wm831x->regmap)) {
45 ret = PTR_ERR(wm831x->regmap);
46 dev_err(wm831x->dev, "Failed to allocate register map: %d\n",
47 ret);
48 return ret;
49 }
50
51 if (pdata)
52 memcpy(&wm831x->pdata, pdata, sizeof(*pdata));
53
54 return wm831x_device_init(wm831x, spi->irq);
55}
56
57static int wm831x_spi_suspend(struct device *dev)
58{
59 struct wm831x *wm831x = dev_get_drvdata(dev);
60
61 return wm831x_device_suspend(wm831x);
62}
63
64static int wm831x_spi_poweroff(struct device *dev)
65{
66 struct wm831x *wm831x = dev_get_drvdata(dev);
67
68 wm831x_device_shutdown(wm831x);
69
70 return 0;
71}
72
73static const struct dev_pm_ops wm831x_spi_pm = {
74 .freeze = wm831x_spi_suspend,
75 .suspend = wm831x_spi_suspend,
76 .poweroff = wm831x_spi_poweroff,
77};
78
79static const struct spi_device_id wm831x_spi_ids[] = {
80 { "wm8310", WM8310 },
81 { "wm8311", WM8311 },
82 { "wm8312", WM8312 },
83 { "wm8320", WM8320 },
84 { "wm8321", WM8321 },
85 { "wm8325", WM8325 },
86 { "wm8326", WM8326 },
87 { },
88};
89
90static struct spi_driver wm831x_spi_driver = {
91 .driver = {
92 .name = "wm831x",
93 .pm = &wm831x_spi_pm,
94 .of_match_table = of_match_ptr(wm831x_of_match),
95 .suppress_bind_attrs = true,
96 },
97 .id_table = wm831x_spi_ids,
98 .probe = wm831x_spi_probe,
99};
100
101static int __init wm831x_spi_init(void)
102{
103 int ret;
104
105 ret = spi_register_driver(&wm831x_spi_driver);
106 if (ret != 0)
107 pr_err("Failed to register WM831x SPI driver: %d\n", ret);
108
109 return 0;
110}
111subsys_initcall(wm831x_spi_init);