1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * SPI interface.
4 *
5 * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
6 * Copyright (c) 2011, Sagrad Inc.
7 * Copyright (c) 2010, ST-Ericsson
8 */
9 #include <linux/module.h>
10 #include <linux/delay.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/spi/spi.h>
13 #include <linux/interrupt.h>
14 #include <linux/irq.h>
15 #include <linux/of.h>
16 #include <linux/pm.h>
17
18 #include "bus.h"
19 #include "wfx.h"
20 #include "hwio.h"
21 #include "main.h"
22 #include "bh.h"
23
24 #define SET_WRITE 0x7FFF /* usage: and operation */
25 #define SET_READ 0x8000 /* usage: or operation */
26
27 static const struct wfx_platform_data pdata_wf200 = {
28 .file_fw = "wfx/wfm_wf200",
29 .file_pds = "wfx/wf200.pds",
30 .use_rising_clk = true,
31 };
32
33 static const struct wfx_platform_data pdata_brd4001a = {
34 .file_fw = "wfx/wfm_wf200",
35 .file_pds = "wfx/brd4001a.pds",
36 .use_rising_clk = true,
37 };
38
39 static const struct wfx_platform_data pdata_brd8022a = {
40 .file_fw = "wfx/wfm_wf200",
41 .file_pds = "wfx/brd8022a.pds",
42 .use_rising_clk = true,
43 };
44
45 static const struct wfx_platform_data pdata_brd8023a = {
46 .file_fw = "wfx/wfm_wf200",
47 .file_pds = "wfx/brd8023a.pds",
48 .use_rising_clk = true,
49 };
50
51 struct wfx_spi_priv {
52 struct spi_device *func;
53 struct wfx_dev *core;
54 struct gpio_desc *gpio_reset;
55 bool need_swab;
56 };
57
58 /* The chip reads 16bits of data at time and place them directly into (little endian) CPU register.
59 * So, the chip expects bytes order to be "B1 B0 B3 B2" (while LE is "B0 B1 B2 B3" and BE is
60 * "B3 B2 B1 B0")
61 *
62 * A little endian host with bits_per_word == 16 should do the right job natively. The code below to
63 * support big endian host and commonly used SPI 8bits.
64 */
wfx_spi_copy_from_io(void * priv,unsigned int addr,void * dst,size_t count)65 static int wfx_spi_copy_from_io(void *priv, unsigned int addr, void *dst, size_t count)
66 {
67 struct wfx_spi_priv *bus = priv;
68 u16 regaddr = (addr << 12) | (count / 2) | SET_READ;
69 struct spi_message m;
70 struct spi_transfer t_addr = {
71 .tx_buf = ®addr,
72 .len = sizeof(regaddr),
73 };
74 struct spi_transfer t_msg = {
75 .rx_buf = dst,
76 .len = count,
77 };
78 u16 *dst16 = dst;
79 int ret, i;
80
81 WARN(count % 2, "buffer size must be a multiple of 2");
82
83 cpu_to_le16s(®addr);
84 if (bus->need_swab)
85 swab16s(®addr);
86
87 spi_message_init(&m);
88 spi_message_add_tail(&t_addr, &m);
89 spi_message_add_tail(&t_msg, &m);
90 ret = spi_sync(bus->func, &m);
91
92 if (bus->need_swab && addr == WFX_REG_CONFIG)
93 for (i = 0; i < count / 2; i++)
94 swab16s(&dst16[i]);
95 return ret;
96 }
97
wfx_spi_copy_to_io(void * priv,unsigned int addr,const void * src,size_t count)98 static int wfx_spi_copy_to_io(void *priv, unsigned int addr, const void *src, size_t count)
99 {
100 struct wfx_spi_priv *bus = priv;
101 u16 regaddr = (addr << 12) | (count / 2);
102 /* FIXME: use a bounce buffer */
103 u16 *src16 = (void *)src;
104 int ret, i;
105 struct spi_message m;
106 struct spi_transfer t_addr = {
107 .tx_buf = ®addr,
108 .len = sizeof(regaddr),
109 };
110 struct spi_transfer t_msg = {
111 .tx_buf = src,
112 .len = count,
113 };
114
115 WARN(count % 2, "buffer size must be a multiple of 2");
116 WARN(regaddr & SET_READ, "bad addr or size overflow");
117
118 cpu_to_le16s(®addr);
119
120 /* Register address and CONFIG content always use 16bit big endian
121 * ("BADC" order)
122 */
123 if (bus->need_swab)
124 swab16s(®addr);
125 if (bus->need_swab && addr == WFX_REG_CONFIG)
126 for (i = 0; i < count / 2; i++)
127 swab16s(&src16[i]);
128
129 spi_message_init(&m);
130 spi_message_add_tail(&t_addr, &m);
131 spi_message_add_tail(&t_msg, &m);
132 ret = spi_sync(bus->func, &m);
133
134 if (bus->need_swab && addr == WFX_REG_CONFIG)
135 for (i = 0; i < count / 2; i++)
136 swab16s(&src16[i]);
137 return ret;
138 }
139
wfx_spi_lock(void * priv)140 static void wfx_spi_lock(void *priv)
141 {
142 }
143
wfx_spi_unlock(void * priv)144 static void wfx_spi_unlock(void *priv)
145 {
146 }
147
wfx_spi_irq_handler(int irq,void * priv)148 static irqreturn_t wfx_spi_irq_handler(int irq, void *priv)
149 {
150 struct wfx_spi_priv *bus = priv;
151
152 wfx_bh_request_rx(bus->core);
153 return IRQ_HANDLED;
154 }
155
wfx_spi_irq_subscribe(void * priv)156 static int wfx_spi_irq_subscribe(void *priv)
157 {
158 struct wfx_spi_priv *bus = priv;
159 u32 flags;
160
161 flags = irq_get_trigger_type(bus->func->irq);
162 if (!flags)
163 flags = IRQF_TRIGGER_HIGH;
164 flags |= IRQF_ONESHOT;
165 return devm_request_threaded_irq(&bus->func->dev, bus->func->irq, NULL,
166 wfx_spi_irq_handler, flags, "wfx", bus);
167 }
168
wfx_spi_irq_unsubscribe(void * priv)169 static int wfx_spi_irq_unsubscribe(void *priv)
170 {
171 struct wfx_spi_priv *bus = priv;
172
173 devm_free_irq(&bus->func->dev, bus->func->irq, bus);
174 return 0;
175 }
176
wfx_spi_align_size(void * priv,size_t size)177 static size_t wfx_spi_align_size(void *priv, size_t size)
178 {
179 /* Most of SPI controllers avoid DMA if buffer size is not 32bit aligned */
180 return ALIGN(size, 4);
181 }
182
wfx_spi_set_wakeup(void * priv,bool enabled)183 static void wfx_spi_set_wakeup(void *priv, bool enabled)
184 {
185 struct wfx_spi_priv *bus = priv;
186
187 device_set_wakeup_enable(&bus->func->dev, enabled);
188 }
189
190 static const struct wfx_hwbus_ops wfx_spi_hwbus_ops = {
191 .copy_from_io = wfx_spi_copy_from_io,
192 .copy_to_io = wfx_spi_copy_to_io,
193 .irq_subscribe = wfx_spi_irq_subscribe,
194 .irq_unsubscribe = wfx_spi_irq_unsubscribe,
195 .lock = wfx_spi_lock,
196 .unlock = wfx_spi_unlock,
197 .align_size = wfx_spi_align_size,
198 .set_wakeup = wfx_spi_set_wakeup,
199 };
200
wfx_spi_suspend(struct device * dev)201 static int wfx_spi_suspend(struct device *dev)
202 {
203 struct spi_device *func = to_spi_device(dev);
204 struct wfx_spi_priv *bus = spi_get_drvdata(func);
205
206 if (!device_may_wakeup(dev))
207 return 0;
208 flush_work(&bus->core->hif.bh);
209 return enable_irq_wake(func->irq);
210 }
211
wfx_spi_resume(struct device * dev)212 static int wfx_spi_resume(struct device *dev)
213 {
214 struct spi_device *func = to_spi_device(dev);
215
216 if (!device_may_wakeup(dev))
217 return 0;
218 return disable_irq_wake(func->irq);
219 }
220
wfx_spi_probe(struct spi_device * func)221 static int wfx_spi_probe(struct spi_device *func)
222 {
223 struct wfx_platform_data *pdata;
224 struct wfx_spi_priv *bus;
225 int ret;
226
227 if (!func->bits_per_word)
228 func->bits_per_word = 16;
229 ret = spi_setup(func);
230 if (ret)
231 return ret;
232 pdata = (struct wfx_platform_data *)spi_get_device_id(func)->driver_data;
233 if (!pdata) {
234 dev_err(&func->dev, "unable to retrieve driver data (please report)\n");
235 return -ENODEV;
236 }
237
238 /* Trace below is also displayed by spi_setup() if compiled with DEBUG */
239 dev_dbg(&func->dev, "SPI params: CS=%d, mode=%d bits/word=%d speed=%d\n",
240 spi_get_chipselect(func, 0), func->mode, func->bits_per_word, func->max_speed_hz);
241 if (func->bits_per_word != 16 && func->bits_per_word != 8)
242 dev_warn(&func->dev, "unusual bits/word value: %d\n", func->bits_per_word);
243 if (func->max_speed_hz > 50000000)
244 dev_warn(&func->dev, "%dHz is a very high speed\n", func->max_speed_hz);
245
246 bus = devm_kzalloc(&func->dev, sizeof(*bus), GFP_KERNEL);
247 if (!bus)
248 return -ENOMEM;
249 bus->func = func;
250 if (func->bits_per_word == 8 || IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
251 bus->need_swab = true;
252 spi_set_drvdata(func, bus);
253
254 bus->gpio_reset = devm_gpiod_get_optional(&func->dev, "reset", GPIOD_OUT_LOW);
255 if (IS_ERR(bus->gpio_reset))
256 return PTR_ERR(bus->gpio_reset);
257 if (!bus->gpio_reset) {
258 dev_warn(&func->dev, "gpio reset is not defined, trying to load firmware anyway\n");
259 } else {
260 gpiod_set_consumer_name(bus->gpio_reset, "wfx reset");
261 gpiod_set_value_cansleep(bus->gpio_reset, 1);
262 usleep_range(100, 150);
263 gpiod_set_value_cansleep(bus->gpio_reset, 0);
264 usleep_range(2000, 2500);
265 }
266
267 bus->core = wfx_init_common(&func->dev, pdata, &wfx_spi_hwbus_ops, bus);
268 if (!bus->core)
269 return -EIO;
270
271 ret = wfx_probe(bus->core);
272 if (ret)
273 return ret;
274
275 device_set_wakeup_capable(&func->dev, true);
276 return 0;
277 }
278
wfx_spi_remove(struct spi_device * func)279 static void wfx_spi_remove(struct spi_device *func)
280 {
281 struct wfx_spi_priv *bus = spi_get_drvdata(func);
282
283 wfx_release(bus->core);
284 }
285
286 /* For dynamic driver binding, kernel does not use OF to match driver. It only
287 * use modalias and modalias is a copy of 'compatible' DT node with vendor
288 * stripped.
289 */
290 static const struct spi_device_id wfx_spi_id[] = {
291 { "wf200", (kernel_ulong_t)&pdata_wf200 },
292 { "brd4001a", (kernel_ulong_t)&pdata_brd4001a },
293 { "brd8022a", (kernel_ulong_t)&pdata_brd8022a },
294 { "brd8023a", (kernel_ulong_t)&pdata_brd8023a },
295 { },
296 };
297 MODULE_DEVICE_TABLE(spi, wfx_spi_id);
298
299 #ifdef CONFIG_OF
300 static const struct of_device_id wfx_spi_of_match[] = {
301 { .compatible = "silabs,wf200" },
302 { .compatible = "silabs,brd4001a" },
303 { .compatible = "silabs,brd8022a" },
304 { .compatible = "silabs,brd8023a" },
305 { },
306 };
307 MODULE_DEVICE_TABLE(of, wfx_spi_of_match);
308 #endif
309
310 static DEFINE_SIMPLE_DEV_PM_OPS(wfx_spi_pm_ops, wfx_spi_suspend, wfx_spi_resume);
311
312 struct spi_driver wfx_spi_driver = {
313 .id_table = wfx_spi_id,
314 .probe = wfx_spi_probe,
315 .remove = wfx_spi_remove,
316 .driver = {
317 .name = "wfx-spi",
318 .of_match_table = of_match_ptr(wfx_spi_of_match),
319 .pm = &wfx_spi_pm_ops,
320 },
321 };
322