xref: /openbmc/linux/drivers/net/wireless/ti/wlcore/sdio.c (revision d2999e1b)
1 /*
2  * This file is part of wl1271
3  *
4  * Copyright (C) 2009-2010 Nokia Corporation
5  *
6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23 
24 #include <linux/irq.h>
25 #include <linux/module.h>
26 #include <linux/vmalloc.h>
27 #include <linux/platform_device.h>
28 #include <linux/mmc/sdio.h>
29 #include <linux/mmc/sdio_func.h>
30 #include <linux/mmc/sdio_ids.h>
31 #include <linux/mmc/card.h>
32 #include <linux/mmc/host.h>
33 #include <linux/gpio.h>
34 #include <linux/wl12xx.h>
35 #include <linux/pm_runtime.h>
36 #include <linux/printk.h>
37 
38 #include "wlcore.h"
39 #include "wl12xx_80211.h"
40 #include "io.h"
41 
42 #ifndef SDIO_VENDOR_ID_TI
43 #define SDIO_VENDOR_ID_TI		0x0097
44 #endif
45 
46 #ifndef SDIO_DEVICE_ID_TI_WL1271
47 #define SDIO_DEVICE_ID_TI_WL1271	0x4076
48 #endif
49 
50 static bool dump = false;
51 
52 struct wl12xx_sdio_glue {
53 	struct device *dev;
54 	struct platform_device *core;
55 };
56 
57 static const struct sdio_device_id wl1271_devices[] = {
58 	{ SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
59 	{}
60 };
61 MODULE_DEVICE_TABLE(sdio, wl1271_devices);
62 
63 static void wl1271_sdio_set_block_size(struct device *child,
64 				       unsigned int blksz)
65 {
66 	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
67 	struct sdio_func *func = dev_to_sdio_func(glue->dev);
68 
69 	sdio_claim_host(func);
70 	sdio_set_block_size(func, blksz);
71 	sdio_release_host(func);
72 }
73 
74 static int __must_check wl12xx_sdio_raw_read(struct device *child, int addr,
75 					     void *buf, size_t len, bool fixed)
76 {
77 	int ret;
78 	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
79 	struct sdio_func *func = dev_to_sdio_func(glue->dev);
80 
81 	sdio_claim_host(func);
82 
83 	if (unlikely(dump)) {
84 		printk(KERN_DEBUG "wlcore_sdio: READ from 0x%04x\n", addr);
85 		print_hex_dump(KERN_DEBUG, "wlcore_sdio: READ ",
86 				DUMP_PREFIX_OFFSET, 16, 1,
87 				buf, len, false);
88 	}
89 
90 	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) {
91 		((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
92 		dev_dbg(child->parent, "sdio read 52 addr 0x%x, byte 0x%02x\n",
93 			addr, ((u8 *)buf)[0]);
94 	} else {
95 		if (fixed)
96 			ret = sdio_readsb(func, buf, addr, len);
97 		else
98 			ret = sdio_memcpy_fromio(func, buf, addr, len);
99 
100 		dev_dbg(child->parent, "sdio read 53 addr 0x%x, %zu bytes\n",
101 			addr, len);
102 	}
103 
104 	sdio_release_host(func);
105 
106 	if (WARN_ON(ret))
107 		dev_err(child->parent, "sdio read failed (%d)\n", ret);
108 
109 	return ret;
110 }
111 
112 static int __must_check wl12xx_sdio_raw_write(struct device *child, int addr,
113 					      void *buf, size_t len, bool fixed)
114 {
115 	int ret;
116 	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
117 	struct sdio_func *func = dev_to_sdio_func(glue->dev);
118 
119 	sdio_claim_host(func);
120 
121 	if (unlikely(dump)) {
122 		printk(KERN_DEBUG "wlcore_sdio: WRITE to 0x%04x\n", addr);
123 		print_hex_dump(KERN_DEBUG, "wlcore_sdio: WRITE ",
124 				DUMP_PREFIX_OFFSET, 16, 1,
125 				buf, len, false);
126 	}
127 
128 	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) {
129 		sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
130 		dev_dbg(child->parent, "sdio write 52 addr 0x%x, byte 0x%02x\n",
131 			addr, ((u8 *)buf)[0]);
132 	} else {
133 		dev_dbg(child->parent, "sdio write 53 addr 0x%x, %zu bytes\n",
134 			addr, len);
135 
136 		if (fixed)
137 			ret = sdio_writesb(func, addr, buf, len);
138 		else
139 			ret = sdio_memcpy_toio(func, addr, buf, len);
140 	}
141 
142 	sdio_release_host(func);
143 
144 	if (WARN_ON(ret))
145 		dev_err(child->parent, "sdio write failed (%d)\n", ret);
146 
147 	return ret;
148 }
149 
150 static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue)
151 {
152 	int ret;
153 	struct sdio_func *func = dev_to_sdio_func(glue->dev);
154 	struct mmc_card *card = func->card;
155 
156 	ret = pm_runtime_get_sync(&card->dev);
157 	if (ret) {
158 		/*
159 		 * Runtime PM might be temporarily disabled, or the device
160 		 * might have a positive reference counter. Make sure it is
161 		 * really powered on.
162 		 */
163 		ret = mmc_power_restore_host(card->host);
164 		if (ret < 0) {
165 			pm_runtime_put_sync(&card->dev);
166 			goto out;
167 		}
168 	}
169 
170 	sdio_claim_host(func);
171 	sdio_enable_func(func);
172 	sdio_release_host(func);
173 
174 out:
175 	return ret;
176 }
177 
178 static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue)
179 {
180 	int ret;
181 	struct sdio_func *func = dev_to_sdio_func(glue->dev);
182 	struct mmc_card *card = func->card;
183 
184 	sdio_claim_host(func);
185 	sdio_disable_func(func);
186 	sdio_release_host(func);
187 
188 	/* Power off the card manually in case it wasn't powered off above */
189 	ret = mmc_power_save_host(card->host);
190 	if (ret < 0)
191 		goto out;
192 
193 	/* Let runtime PM know the card is powered off */
194 	pm_runtime_put_sync(&card->dev);
195 
196 out:
197 	return ret;
198 }
199 
200 static int wl12xx_sdio_set_power(struct device *child, bool enable)
201 {
202 	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
203 
204 	if (enable)
205 		return wl12xx_sdio_power_on(glue);
206 	else
207 		return wl12xx_sdio_power_off(glue);
208 }
209 
210 static struct wl1271_if_operations sdio_ops = {
211 	.read		= wl12xx_sdio_raw_read,
212 	.write		= wl12xx_sdio_raw_write,
213 	.power		= wl12xx_sdio_set_power,
214 	.set_block_size = wl1271_sdio_set_block_size,
215 };
216 
217 static int wl1271_probe(struct sdio_func *func,
218 				  const struct sdio_device_id *id)
219 {
220 	struct wlcore_platdev_data pdev_data;
221 	struct wl12xx_sdio_glue *glue;
222 	struct resource res[1];
223 	mmc_pm_flag_t mmcflags;
224 	int ret = -ENOMEM;
225 	const char *chip_family;
226 
227 	/* We are only able to handle the wlan function */
228 	if (func->num != 0x02)
229 		return -ENODEV;
230 
231 	memset(&pdev_data, 0x00, sizeof(pdev_data));
232 	pdev_data.if_ops = &sdio_ops;
233 
234 	glue = kzalloc(sizeof(*glue), GFP_KERNEL);
235 	if (!glue) {
236 		dev_err(&func->dev, "can't allocate glue\n");
237 		goto out;
238 	}
239 
240 	glue->dev = &func->dev;
241 
242 	/* Grab access to FN0 for ELP reg. */
243 	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
244 
245 	/* Use block mode for transferring over one block size of data */
246 	func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
247 
248 	pdev_data.pdata = wl12xx_get_platform_data();
249 	if (IS_ERR(pdev_data.pdata)) {
250 		ret = PTR_ERR(pdev_data.pdata);
251 		dev_err(glue->dev, "missing wlan platform data: %d\n", ret);
252 		goto out_free_glue;
253 	}
254 
255 	/* if sdio can keep power while host is suspended, enable wow */
256 	mmcflags = sdio_get_host_pm_caps(func);
257 	dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags);
258 
259 	if (mmcflags & MMC_PM_KEEP_POWER)
260 		pdev_data.pdata->pwr_in_suspend = true;
261 
262 	sdio_set_drvdata(func, glue);
263 
264 	/* Tell PM core that we don't need the card to be powered now */
265 	pm_runtime_put_noidle(&func->dev);
266 
267 	/*
268 	 * Due to a hardware bug, we can't differentiate wl18xx from
269 	 * wl12xx, because both report the same device ID.  The only
270 	 * way to differentiate is by checking the SDIO revision,
271 	 * which is 3.00 on the wl18xx chips.
272 	 */
273 	if (func->card->cccr.sdio_vsn == SDIO_SDIO_REV_3_00)
274 		chip_family = "wl18xx";
275 	else
276 		chip_family = "wl12xx";
277 
278 	glue->core = platform_device_alloc(chip_family, PLATFORM_DEVID_AUTO);
279 	if (!glue->core) {
280 		dev_err(glue->dev, "can't allocate platform_device");
281 		ret = -ENOMEM;
282 		goto out_free_glue;
283 	}
284 
285 	glue->core->dev.parent = &func->dev;
286 
287 	memset(res, 0x00, sizeof(res));
288 
289 	res[0].start = pdev_data.pdata->irq;
290 	res[0].flags = IORESOURCE_IRQ;
291 	res[0].name = "irq";
292 
293 	ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res));
294 	if (ret) {
295 		dev_err(glue->dev, "can't add resources\n");
296 		goto out_dev_put;
297 	}
298 
299 	ret = platform_device_add_data(glue->core, &pdev_data,
300 				       sizeof(pdev_data));
301 	if (ret) {
302 		dev_err(glue->dev, "can't add platform data\n");
303 		goto out_dev_put;
304 	}
305 
306 	ret = platform_device_add(glue->core);
307 	if (ret) {
308 		dev_err(glue->dev, "can't add platform device\n");
309 		goto out_dev_put;
310 	}
311 	return 0;
312 
313 out_dev_put:
314 	platform_device_put(glue->core);
315 
316 out_free_glue:
317 	kfree(glue);
318 
319 out:
320 	return ret;
321 }
322 
323 static void wl1271_remove(struct sdio_func *func)
324 {
325 	struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);
326 
327 	/* Undo decrement done above in wl1271_probe */
328 	pm_runtime_get_noresume(&func->dev);
329 
330 	platform_device_unregister(glue->core);
331 	kfree(glue);
332 }
333 
334 #ifdef CONFIG_PM
335 static int wl1271_suspend(struct device *dev)
336 {
337 	/* Tell MMC/SDIO core it's OK to power down the card
338 	 * (if it isn't already), but not to remove it completely */
339 	struct sdio_func *func = dev_to_sdio_func(dev);
340 	struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);
341 	struct wl1271 *wl = platform_get_drvdata(glue->core);
342 	mmc_pm_flag_t sdio_flags;
343 	int ret = 0;
344 
345 	dev_dbg(dev, "wl1271 suspend. wow_enabled: %d\n",
346 		wl->wow_enabled);
347 
348 	/* check whether sdio should keep power */
349 	if (wl->wow_enabled) {
350 		sdio_flags = sdio_get_host_pm_caps(func);
351 
352 		if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
353 			dev_err(dev, "can't keep power while host "
354 				     "is suspended\n");
355 			ret = -EINVAL;
356 			goto out;
357 		}
358 
359 		/* keep power while host suspended */
360 		ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
361 		if (ret) {
362 			dev_err(dev, "error while trying to keep power\n");
363 			goto out;
364 		}
365 	}
366 out:
367 	return ret;
368 }
369 
370 static int wl1271_resume(struct device *dev)
371 {
372 	dev_dbg(dev, "wl1271 resume\n");
373 
374 	return 0;
375 }
376 
377 static const struct dev_pm_ops wl1271_sdio_pm_ops = {
378 	.suspend	= wl1271_suspend,
379 	.resume		= wl1271_resume,
380 };
381 #endif
382 
383 static struct sdio_driver wl1271_sdio_driver = {
384 	.name		= "wl1271_sdio",
385 	.id_table	= wl1271_devices,
386 	.probe		= wl1271_probe,
387 	.remove		= wl1271_remove,
388 #ifdef CONFIG_PM
389 	.drv = {
390 		.pm = &wl1271_sdio_pm_ops,
391 	},
392 #endif
393 };
394 
395 static int __init wl1271_init(void)
396 {
397 	return sdio_register_driver(&wl1271_sdio_driver);
398 }
399 
400 static void __exit wl1271_exit(void)
401 {
402 	sdio_unregister_driver(&wl1271_sdio_driver);
403 }
404 
405 module_init(wl1271_init);
406 module_exit(wl1271_exit);
407 
408 module_param(dump, bool, S_IRUSR | S_IWUSR);
409 MODULE_PARM_DESC(dump, "Enable sdio read/write dumps.");
410 
411 MODULE_LICENSE("GPL");
412 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
413 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
414