1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This file is part of wl1251
4 *
5 * Copyright (C) 2008 Nokia Corporation
6 */
7
8#include <linux/interrupt.h>
9#include <linux/irq.h>
10#include <linux/module.h>
11#include <linux/slab.h>
12#include <linux/swab.h>
13#include <linux/crc7.h>
14#include <linux/spi/spi.h>
15#include <linux/wl12xx.h>
16#include <linux/gpio.h>
17#include <linux/of.h>
18#include <linux/of_gpio.h>
19#include <linux/regulator/consumer.h>
20
21#include "wl1251.h"
22#include "reg.h"
23#include "spi.h"
24
25static irqreturn_t wl1251_irq(int irq, void *cookie)
26{
27	struct wl1251 *wl;
28
29	wl1251_debug(DEBUG_IRQ, "IRQ");
30
31	wl = cookie;
32
33	ieee80211_queue_work(wl->hw, &wl->irq_work);
34
35	return IRQ_HANDLED;
36}
37
38static struct spi_device *wl_to_spi(struct wl1251 *wl)
39{
40	return wl->if_priv;
41}
42
43static void wl1251_spi_reset(struct wl1251 *wl)
44{
45	u8 *cmd;
46	struct spi_transfer t;
47	struct spi_message m;
48
49	cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
50	if (!cmd) {
51		wl1251_error("could not allocate cmd for spi reset");
52		return;
53	}
54
55	memset(&t, 0, sizeof(t));
56	spi_message_init(&m);
57
58	memset(cmd, 0xff, WSPI_INIT_CMD_LEN);
59
60	t.tx_buf = cmd;
61	t.len = WSPI_INIT_CMD_LEN;
62	spi_message_add_tail(&t, &m);
63
64	spi_sync(wl_to_spi(wl), &m);
65
66	wl1251_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
67
68	kfree(cmd);
69}
70
71static void wl1251_spi_wake(struct wl1251 *wl)
72{
73	struct spi_transfer t;
74	struct spi_message m;
75	u8 *cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
76
77	if (!cmd) {
78		wl1251_error("could not allocate cmd for spi init");
79		return;
80	}
81
82	memset(&t, 0, sizeof(t));
83	spi_message_init(&m);
84
85	/* Set WSPI_INIT_COMMAND
86	 * the data is being send from the MSB to LSB
87	 */
88	cmd[0] = 0xff;
89	cmd[1] = 0xff;
90	cmd[2] = WSPI_INIT_CMD_START | WSPI_INIT_CMD_TX;
91	cmd[3] = 0;
92	cmd[4] = 0;
93	cmd[5] = HW_ACCESS_WSPI_INIT_CMD_MASK << 3;
94	cmd[5] |= HW_ACCESS_WSPI_FIXED_BUSY_LEN & WSPI_INIT_CMD_FIXEDBUSY_LEN;
95
96	cmd[6] = WSPI_INIT_CMD_IOD | WSPI_INIT_CMD_IP | WSPI_INIT_CMD_CS
97		| WSPI_INIT_CMD_WSPI | WSPI_INIT_CMD_WS;
98
99	if (HW_ACCESS_WSPI_FIXED_BUSY_LEN == 0)
100		cmd[6] |= WSPI_INIT_CMD_DIS_FIXEDBUSY;
101	else
102		cmd[6] |= WSPI_INIT_CMD_EN_FIXEDBUSY;
103
104	cmd[7] = crc7_be(0, cmd+2, WSPI_INIT_CMD_CRC_LEN) | WSPI_INIT_CMD_END;
105	/*
106	 * The above is the logical order; it must actually be stored
107	 * in the buffer byte-swapped.
108	 */
109	__swab32s((u32 *)cmd);
110	__swab32s((u32 *)cmd+1);
111
112	t.tx_buf = cmd;
113	t.len = WSPI_INIT_CMD_LEN;
114	spi_message_add_tail(&t, &m);
115
116	spi_sync(wl_to_spi(wl), &m);
117
118	wl1251_dump(DEBUG_SPI, "spi init -> ", cmd, WSPI_INIT_CMD_LEN);
119
120	kfree(cmd);
121}
122
123static void wl1251_spi_reset_wake(struct wl1251 *wl)
124{
125	wl1251_spi_reset(wl);
126	wl1251_spi_wake(wl);
127}
128
129static void wl1251_spi_read(struct wl1251 *wl, int addr, void *buf,
130			    size_t len)
131{
132	struct spi_transfer t[3];
133	struct spi_message m;
134	u8 *busy_buf;
135	u32 *cmd;
136
137	cmd = &wl->buffer_cmd;
138	busy_buf = wl->buffer_busyword;
139
140	*cmd = 0;
141	*cmd |= WSPI_CMD_READ;
142	*cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
143	*cmd |= addr & WSPI_CMD_BYTE_ADDR;
144
145	spi_message_init(&m);
146	memset(t, 0, sizeof(t));
147
148	t[0].tx_buf = cmd;
149	t[0].len = 4;
150	spi_message_add_tail(&t[0], &m);
151
152	/* Busy and non busy words read */
153	t[1].rx_buf = busy_buf;
154	t[1].len = WL1251_BUSY_WORD_LEN;
155	spi_message_add_tail(&t[1], &m);
156
157	t[2].rx_buf = buf;
158	t[2].len = len;
159	spi_message_add_tail(&t[2], &m);
160
161	spi_sync(wl_to_spi(wl), &m);
162
163	/* FIXME: check busy words */
164
165	wl1251_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
166	wl1251_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
167}
168
169static void wl1251_spi_write(struct wl1251 *wl, int addr, void *buf,
170			     size_t len)
171{
172	struct spi_transfer t[2];
173	struct spi_message m;
174	u32 *cmd;
175
176	cmd = &wl->buffer_cmd;
177
178	*cmd = 0;
179	*cmd |= WSPI_CMD_WRITE;
180	*cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
181	*cmd |= addr & WSPI_CMD_BYTE_ADDR;
182
183	spi_message_init(&m);
184	memset(t, 0, sizeof(t));
185
186	t[0].tx_buf = cmd;
187	t[0].len = sizeof(*cmd);
188	spi_message_add_tail(&t[0], &m);
189
190	t[1].tx_buf = buf;
191	t[1].len = len;
192	spi_message_add_tail(&t[1], &m);
193
194	spi_sync(wl_to_spi(wl), &m);
195
196	wl1251_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
197	wl1251_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
198}
199
200static void wl1251_spi_enable_irq(struct wl1251 *wl)
201{
202	return enable_irq(wl->irq);
203}
204
205static void wl1251_spi_disable_irq(struct wl1251 *wl)
206{
207	return disable_irq(wl->irq);
208}
209
210static int wl1251_spi_set_power(struct wl1251 *wl, bool enable)
211{
212	if (gpio_is_valid(wl->power_gpio))
213		gpio_set_value(wl->power_gpio, enable);
214
215	return 0;
216}
217
218static const struct wl1251_if_operations wl1251_spi_ops = {
219	.read = wl1251_spi_read,
220	.write = wl1251_spi_write,
221	.reset = wl1251_spi_reset_wake,
222	.enable_irq = wl1251_spi_enable_irq,
223	.disable_irq = wl1251_spi_disable_irq,
224	.power = wl1251_spi_set_power,
225};
226
227static int wl1251_spi_probe(struct spi_device *spi)
228{
229	struct wl1251_platform_data *pdata = dev_get_platdata(&spi->dev);
230	struct device_node *np = spi->dev.of_node;
231	struct ieee80211_hw *hw;
232	struct wl1251 *wl;
233	int ret;
234
235	if (!np && !pdata) {
236		wl1251_error("no platform data");
237		return -ENODEV;
238	}
239
240	hw = wl1251_alloc_hw();
241	if (IS_ERR(hw))
242		return PTR_ERR(hw);
243
244	wl = hw->priv;
245
246	SET_IEEE80211_DEV(hw, &spi->dev);
247	spi_set_drvdata(spi, wl);
248	wl->if_priv = spi;
249	wl->if_ops = &wl1251_spi_ops;
250
251	/* This is the only SPI value that we need to set here, the rest
252	 * comes from the board-peripherals file
253	 */
254	spi->bits_per_word = 32;
255
256	ret = spi_setup(spi);
257	if (ret < 0) {
258		wl1251_error("spi_setup failed");
259		goto out_free;
260	}
261
262	if (np) {
263		wl->use_eeprom = of_property_read_bool(np, "ti,wl1251-has-eeprom");
264		wl->power_gpio = of_get_named_gpio(np, "ti,power-gpio", 0);
265	} else if (pdata) {
266		wl->power_gpio = pdata->power_gpio;
267		wl->use_eeprom = pdata->use_eeprom;
268	}
269
270	if (wl->power_gpio == -EPROBE_DEFER) {
271		ret = -EPROBE_DEFER;
272		goto out_free;
273	}
274
275	if (gpio_is_valid(wl->power_gpio)) {
276		ret = devm_gpio_request_one(&spi->dev, wl->power_gpio,
277					GPIOF_OUT_INIT_LOW, "wl1251 power");
278		if (ret) {
279			wl1251_error("Failed to request gpio: %d\n", ret);
280			goto out_free;
281		}
282	} else {
283		wl1251_error("set power gpio missing in platform data");
284		ret = -ENODEV;
285		goto out_free;
286	}
287
288	wl->irq = spi->irq;
289	if (wl->irq < 0) {
290		wl1251_error("irq missing in platform data");
291		ret = -ENODEV;
292		goto out_free;
293	}
294
295	irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
296	ret = devm_request_irq(&spi->dev, wl->irq, wl1251_irq, 0,
297							DRIVER_NAME, wl);
298	if (ret < 0) {
299		wl1251_error("request_irq() failed: %d", ret);
300		goto out_free;
301	}
302
303	irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
304
305	wl->vio = devm_regulator_get(&spi->dev, "vio");
306	if (IS_ERR(wl->vio)) {
307		ret = PTR_ERR(wl->vio);
308		wl1251_error("vio regulator missing: %d", ret);
309		goto out_free;
310	}
311
312	ret = regulator_enable(wl->vio);
313	if (ret)
314		goto out_free;
315
316	ret = wl1251_init_ieee80211(wl);
317	if (ret)
318		goto disable_regulator;
319
320	return 0;
321
322disable_regulator:
323	regulator_disable(wl->vio);
324out_free:
325	ieee80211_free_hw(hw);
326
327	return ret;
328}
329
330static int wl1251_spi_remove(struct spi_device *spi)
331{
332	struct wl1251 *wl = spi_get_drvdata(spi);
333
334	wl1251_free_hw(wl);
335	regulator_disable(wl->vio);
336
337	return 0;
338}
339
340static struct spi_driver wl1251_spi_driver = {
341	.driver = {
342		.name		= DRIVER_NAME,
343	},
344
345	.probe		= wl1251_spi_probe,
346	.remove		= wl1251_spi_remove,
347};
348
349module_spi_driver(wl1251_spi_driver);
350
351MODULE_LICENSE("GPL");
352MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>");
353MODULE_ALIAS("spi:wl1251");
354