1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Mac80211 SDIO driver for ST-Ericsson CW1200 device
4  *
5  * Copyright (c) 2010, ST-Ericsson
6  * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
7  */
8 
9 #include <linux/module.h>
10 #include <linux/interrupt.h>
11 #include <linux/gpio.h>
12 #include <linux/delay.h>
13 #include <linux/mmc/host.h>
14 #include <linux/mmc/sdio_func.h>
15 #include <linux/mmc/card.h>
16 #include <linux/mmc/sdio.h>
17 #include <linux/mmc/sdio_ids.h>
18 #include <net/mac80211.h>
19 
20 #include "cw1200.h"
21 #include "hwbus.h"
22 #include <linux/platform_data/net-cw1200.h>
23 #include "hwio.h"
24 
25 MODULE_AUTHOR("Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>");
26 MODULE_DESCRIPTION("mac80211 ST-Ericsson CW1200 SDIO driver");
27 MODULE_LICENSE("GPL");
28 
29 #define SDIO_BLOCK_SIZE (512)
30 
31 /* Default platform data for Sagrad modules */
32 static struct cw1200_platform_data_sdio sagrad_109x_evk_platform_data = {
33 	.ref_clk = 38400,
34 	.have_5ghz = false,
35 	.sdd_file = "sdd_sagrad_1091_1098.bin",
36 };
37 
38 /* Allow platform data to be overridden */
39 static struct cw1200_platform_data_sdio *global_plat_data = &sagrad_109x_evk_platform_data;
40 
cw1200_sdio_set_platform_data(struct cw1200_platform_data_sdio * pdata)41 void __init cw1200_sdio_set_platform_data(struct cw1200_platform_data_sdio *pdata)
42 {
43 	global_plat_data = pdata;
44 }
45 
46 struct hwbus_priv {
47 	struct sdio_func	*func;
48 	struct cw1200_common	*core;
49 	const struct cw1200_platform_data_sdio *pdata;
50 };
51 
52 static const struct sdio_device_id cw1200_sdio_ids[] = {
53 	{ SDIO_DEVICE(SDIO_VENDOR_ID_STE, SDIO_DEVICE_ID_STE_CW1200) },
54 	{ /* end: all zeroes */			},
55 };
56 
57 /* hwbus_ops implemetation */
58 
cw1200_sdio_memcpy_fromio(struct hwbus_priv * self,unsigned int addr,void * dst,int count)59 static int cw1200_sdio_memcpy_fromio(struct hwbus_priv *self,
60 				     unsigned int addr,
61 				     void *dst, int count)
62 {
63 	return sdio_memcpy_fromio(self->func, dst, addr, count);
64 }
65 
cw1200_sdio_memcpy_toio(struct hwbus_priv * self,unsigned int addr,const void * src,int count)66 static int cw1200_sdio_memcpy_toio(struct hwbus_priv *self,
67 				   unsigned int addr,
68 				   const void *src, int count)
69 {
70 	return sdio_memcpy_toio(self->func, addr, (void *)src, count);
71 }
72 
cw1200_sdio_lock(struct hwbus_priv * self)73 static void cw1200_sdio_lock(struct hwbus_priv *self)
74 {
75 	sdio_claim_host(self->func);
76 }
77 
cw1200_sdio_unlock(struct hwbus_priv * self)78 static void cw1200_sdio_unlock(struct hwbus_priv *self)
79 {
80 	sdio_release_host(self->func);
81 }
82 
cw1200_sdio_irq_handler(struct sdio_func * func)83 static void cw1200_sdio_irq_handler(struct sdio_func *func)
84 {
85 	struct hwbus_priv *self = sdio_get_drvdata(func);
86 
87 	/* note:  sdio_host already claimed here. */
88 	if (self->core)
89 		cw1200_irq_handler(self->core);
90 }
91 
cw1200_gpio_hardirq(int irq,void * dev_id)92 static irqreturn_t cw1200_gpio_hardirq(int irq, void *dev_id)
93 {
94 	return IRQ_WAKE_THREAD;
95 }
96 
cw1200_gpio_irq(int irq,void * dev_id)97 static irqreturn_t cw1200_gpio_irq(int irq, void *dev_id)
98 {
99 	struct hwbus_priv *self = dev_id;
100 
101 	if (self->core) {
102 		cw1200_sdio_lock(self);
103 		cw1200_irq_handler(self->core);
104 		cw1200_sdio_unlock(self);
105 		return IRQ_HANDLED;
106 	} else {
107 		return IRQ_NONE;
108 	}
109 }
110 
cw1200_request_irq(struct hwbus_priv * self)111 static int cw1200_request_irq(struct hwbus_priv *self)
112 {
113 	int ret;
114 	u8 cccr;
115 
116 	cccr = sdio_f0_readb(self->func, SDIO_CCCR_IENx, &ret);
117 	if (WARN_ON(ret))
118 		goto err;
119 
120 	/* Master interrupt enable ... */
121 	cccr |= BIT(0);
122 
123 	/* ... for our function */
124 	cccr |= BIT(self->func->num);
125 
126 	sdio_f0_writeb(self->func, cccr, SDIO_CCCR_IENx, &ret);
127 	if (WARN_ON(ret))
128 		goto err;
129 
130 	ret = enable_irq_wake(self->pdata->irq);
131 	if (WARN_ON(ret))
132 		goto err;
133 
134 	/* Request the IRQ */
135 	ret =  request_threaded_irq(self->pdata->irq, cw1200_gpio_hardirq,
136 				    cw1200_gpio_irq,
137 				    IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
138 				    "cw1200_wlan_irq", self);
139 	if (WARN_ON(ret))
140 		goto err;
141 
142 	return 0;
143 
144 err:
145 	return ret;
146 }
147 
cw1200_sdio_irq_subscribe(struct hwbus_priv * self)148 static int cw1200_sdio_irq_subscribe(struct hwbus_priv *self)
149 {
150 	int ret = 0;
151 
152 	pr_debug("SW IRQ subscribe\n");
153 	sdio_claim_host(self->func);
154 	if (self->pdata->irq)
155 		ret = cw1200_request_irq(self);
156 	else
157 		ret = sdio_claim_irq(self->func, cw1200_sdio_irq_handler);
158 
159 	sdio_release_host(self->func);
160 	return ret;
161 }
162 
cw1200_sdio_irq_unsubscribe(struct hwbus_priv * self)163 static int cw1200_sdio_irq_unsubscribe(struct hwbus_priv *self)
164 {
165 	int ret = 0;
166 
167 	pr_debug("SW IRQ unsubscribe\n");
168 
169 	if (self->pdata->irq) {
170 		disable_irq_wake(self->pdata->irq);
171 		free_irq(self->pdata->irq, self);
172 	} else {
173 		sdio_claim_host(self->func);
174 		ret = sdio_release_irq(self->func);
175 		sdio_release_host(self->func);
176 	}
177 	return ret;
178 }
179 
cw1200_sdio_off(const struct cw1200_platform_data_sdio * pdata)180 static int cw1200_sdio_off(const struct cw1200_platform_data_sdio *pdata)
181 {
182 	if (pdata->reset) {
183 		gpio_set_value(pdata->reset, 0);
184 		msleep(30); /* Min is 2 * CLK32K cycles */
185 		gpio_free(pdata->reset);
186 	}
187 
188 	if (pdata->power_ctrl)
189 		pdata->power_ctrl(pdata, false);
190 	if (pdata->clk_ctrl)
191 		pdata->clk_ctrl(pdata, false);
192 
193 	return 0;
194 }
195 
cw1200_sdio_on(const struct cw1200_platform_data_sdio * pdata)196 static int cw1200_sdio_on(const struct cw1200_platform_data_sdio *pdata)
197 {
198 	/* Ensure I/Os are pulled low */
199 	if (pdata->reset) {
200 		gpio_request(pdata->reset, "cw1200_wlan_reset");
201 		gpio_direction_output(pdata->reset, 0);
202 	}
203 	if (pdata->powerup) {
204 		gpio_request(pdata->powerup, "cw1200_wlan_powerup");
205 		gpio_direction_output(pdata->powerup, 0);
206 	}
207 	if (pdata->reset || pdata->powerup)
208 		msleep(10); /* Settle time? */
209 
210 	/* Enable 3v3 and 1v8 to hardware */
211 	if (pdata->power_ctrl) {
212 		if (pdata->power_ctrl(pdata, true)) {
213 			pr_err("power_ctrl() failed!\n");
214 			return -1;
215 		}
216 	}
217 
218 	/* Enable CLK32K */
219 	if (pdata->clk_ctrl) {
220 		if (pdata->clk_ctrl(pdata, true)) {
221 			pr_err("clk_ctrl() failed!\n");
222 			return -1;
223 		}
224 		msleep(10); /* Delay until clock is stable for 2 cycles */
225 	}
226 
227 	/* Enable POWERUP signal */
228 	if (pdata->powerup) {
229 		gpio_set_value(pdata->powerup, 1);
230 		msleep(250); /* or more..? */
231 	}
232 	/* Enable RSTn signal */
233 	if (pdata->reset) {
234 		gpio_set_value(pdata->reset, 1);
235 		msleep(50); /* Or more..? */
236 	}
237 	return 0;
238 }
239 
cw1200_sdio_align_size(struct hwbus_priv * self,size_t size)240 static size_t cw1200_sdio_align_size(struct hwbus_priv *self, size_t size)
241 {
242 	if (self->pdata->no_nptb)
243 		size = round_up(size, SDIO_BLOCK_SIZE);
244 	else
245 		size = sdio_align_size(self->func, size);
246 
247 	return size;
248 }
249 
cw1200_sdio_pm(struct hwbus_priv * self,bool suspend)250 static int cw1200_sdio_pm(struct hwbus_priv *self, bool suspend)
251 {
252 	int ret = 0;
253 
254 	if (self->pdata->irq)
255 		ret = irq_set_irq_wake(self->pdata->irq, suspend);
256 	return ret;
257 }
258 
259 static const struct hwbus_ops cw1200_sdio_hwbus_ops = {
260 	.hwbus_memcpy_fromio	= cw1200_sdio_memcpy_fromio,
261 	.hwbus_memcpy_toio	= cw1200_sdio_memcpy_toio,
262 	.lock			= cw1200_sdio_lock,
263 	.unlock			= cw1200_sdio_unlock,
264 	.align_size		= cw1200_sdio_align_size,
265 	.power_mgmt		= cw1200_sdio_pm,
266 };
267 
268 /* Probe Function to be called by SDIO stack when device is discovered */
cw1200_sdio_probe(struct sdio_func * func,const struct sdio_device_id * id)269 static int cw1200_sdio_probe(struct sdio_func *func,
270 			     const struct sdio_device_id *id)
271 {
272 	struct hwbus_priv *self;
273 	int status;
274 
275 	pr_info("cw1200_wlan_sdio: Probe called\n");
276 
277 	/* We are only able to handle the wlan function */
278 	if (func->num != 0x01)
279 		return -ENODEV;
280 
281 	self = kzalloc(sizeof(*self), GFP_KERNEL);
282 	if (!self) {
283 		pr_err("Can't allocate SDIO hwbus_priv.\n");
284 		return -ENOMEM;
285 	}
286 
287 	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
288 
289 	self->pdata = global_plat_data; /* FIXME */
290 	self->func = func;
291 	sdio_set_drvdata(func, self);
292 	sdio_claim_host(func);
293 	sdio_enable_func(func);
294 	sdio_release_host(func);
295 
296 	status = cw1200_sdio_irq_subscribe(self);
297 
298 	status = cw1200_core_probe(&cw1200_sdio_hwbus_ops,
299 				   self, &func->dev, &self->core,
300 				   self->pdata->ref_clk,
301 				   self->pdata->macaddr,
302 				   self->pdata->sdd_file,
303 				   self->pdata->have_5ghz);
304 	if (status) {
305 		cw1200_sdio_irq_unsubscribe(self);
306 		sdio_claim_host(func);
307 		sdio_disable_func(func);
308 		sdio_release_host(func);
309 		sdio_set_drvdata(func, NULL);
310 		kfree(self);
311 	}
312 
313 	return status;
314 }
315 
316 /* Disconnect Function to be called by SDIO stack when
317  * device is disconnected
318  */
cw1200_sdio_disconnect(struct sdio_func * func)319 static void cw1200_sdio_disconnect(struct sdio_func *func)
320 {
321 	struct hwbus_priv *self = sdio_get_drvdata(func);
322 
323 	if (self) {
324 		cw1200_sdio_irq_unsubscribe(self);
325 		if (self->core) {
326 			cw1200_core_release(self->core);
327 			self->core = NULL;
328 		}
329 		sdio_claim_host(func);
330 		sdio_disable_func(func);
331 		sdio_release_host(func);
332 		sdio_set_drvdata(func, NULL);
333 		kfree(self);
334 	}
335 }
336 
337 #ifdef CONFIG_PM
cw1200_sdio_suspend(struct device * dev)338 static int cw1200_sdio_suspend(struct device *dev)
339 {
340 	int ret;
341 	struct sdio_func *func = dev_to_sdio_func(dev);
342 	struct hwbus_priv *self = sdio_get_drvdata(func);
343 
344 	if (!cw1200_can_suspend(self->core))
345 		return -EAGAIN;
346 
347 	/* Notify SDIO that CW1200 will remain powered during suspend */
348 	ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
349 	if (ret)
350 		pr_err("Error setting SDIO pm flags: %i\n", ret);
351 
352 	return ret;
353 }
354 
cw1200_sdio_resume(struct device * dev)355 static int cw1200_sdio_resume(struct device *dev)
356 {
357 	return 0;
358 }
359 
360 static const struct dev_pm_ops cw1200_pm_ops = {
361 	.suspend = cw1200_sdio_suspend,
362 	.resume = cw1200_sdio_resume,
363 };
364 #endif
365 
366 static struct sdio_driver sdio_driver = {
367 	.name		= "cw1200_wlan_sdio",
368 	.id_table	= cw1200_sdio_ids,
369 	.probe		= cw1200_sdio_probe,
370 	.remove		= cw1200_sdio_disconnect,
371 #ifdef CONFIG_PM
372 	.drv = {
373 		.pm = &cw1200_pm_ops,
374 	}
375 #endif
376 };
377 
378 /* Init Module function -> Called by insmod */
cw1200_sdio_init(void)379 static int __init cw1200_sdio_init(void)
380 {
381 	const struct cw1200_platform_data_sdio *pdata;
382 	int ret;
383 
384 	/* FIXME -- this won't support multiple devices */
385 	pdata = global_plat_data;
386 
387 	if (cw1200_sdio_on(pdata)) {
388 		ret = -1;
389 		goto err;
390 	}
391 
392 	ret = sdio_register_driver(&sdio_driver);
393 	if (ret)
394 		goto err;
395 
396 	return 0;
397 
398 err:
399 	cw1200_sdio_off(pdata);
400 	return ret;
401 }
402 
403 /* Called at Driver Unloading */
cw1200_sdio_exit(void)404 static void __exit cw1200_sdio_exit(void)
405 {
406 	const struct cw1200_platform_data_sdio *pdata;
407 
408 	/* FIXME -- this won't support multiple devices */
409 	pdata = global_plat_data;
410 	sdio_unregister_driver(&sdio_driver);
411 	cw1200_sdio_off(pdata);
412 }
413 
414 
415 module_init(cw1200_sdio_init);
416 module_exit(cw1200_sdio_exit);
417