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