Loading...
Note: File does not exist in v5.4.
1/*
2 * SDIO testing driver for wl12xx
3 *
4 * Copyright (C) 2010 Nokia Corporation
5 *
6 * Contact: Roger Quadros <roger.quadros@nokia.com>
7 *
8 * wl12xx read/write routines taken from the main module
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2 as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 * 02110-1301 USA
23 *
24 */
25
26#include <linux/irq.h>
27#include <linux/module.h>
28#include <linux/crc7.h>
29#include <linux/vmalloc.h>
30#include <linux/mmc/sdio_func.h>
31#include <linux/mmc/sdio_ids.h>
32#include <linux/mmc/card.h>
33#include <linux/gpio.h>
34#include <linux/wl12xx.h>
35#include <linux/kthread.h>
36#include <linux/firmware.h>
37#include <linux/pm_runtime.h>
38
39#include "wl12xx.h"
40#include "io.h"
41#include "boot.h"
42
43#ifndef SDIO_VENDOR_ID_TI
44#define SDIO_VENDOR_ID_TI 0x0097
45#endif
46
47#ifndef SDIO_DEVICE_ID_TI_WL1271
48#define SDIO_DEVICE_ID_TI_WL1271 0x4076
49#endif
50
51static bool rx, tx;
52
53module_param(rx, bool, S_IRUGO | S_IWUSR);
54MODULE_PARM_DESC(rx, "Perform rx test. Default (0). "
55 "This test continuously reads data from the SDIO device.\n");
56
57module_param(tx, bool, S_IRUGO | S_IWUSR);
58MODULE_PARM_DESC(tx, "Perform tx test. Default (0). "
59 "This test continuously writes data to the SDIO device.\n");
60
61struct wl1271_test {
62 struct wl1271 wl;
63 struct task_struct *test_task;
64};
65
66static const struct sdio_device_id wl1271_devices[] = {
67 { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
68 {}
69};
70
71static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
72{
73 return wl->if_priv;
74}
75
76static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
77{
78 return &(wl_to_func(wl)->dev);
79}
80
81static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
82 size_t len, bool fixed)
83{
84 int ret = 0;
85 struct sdio_func *func = wl_to_func(wl);
86
87 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
88 ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
89 wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
90 addr, ((u8 *)buf)[0]);
91 } else {
92 if (fixed)
93 ret = sdio_readsb(func, buf, addr, len);
94 else
95 ret = sdio_memcpy_fromio(func, buf, addr, len);
96
97 wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
98 addr, len);
99 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
100 }
101
102 if (ret)
103 wl1271_error("sdio read failed (%d)", ret);
104}
105
106static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
107 size_t len, bool fixed)
108{
109 int ret = 0;
110 struct sdio_func *func = wl_to_func(wl);
111
112 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
113 sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
114 wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
115 addr, ((u8 *)buf)[0]);
116 } else {
117 wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
118 addr, len);
119 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
120
121 if (fixed)
122 ret = sdio_writesb(func, addr, buf, len);
123 else
124 ret = sdio_memcpy_toio(func, addr, buf, len);
125 }
126 if (ret)
127 wl1271_error("sdio write failed (%d)", ret);
128
129}
130
131static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
132{
133 struct sdio_func *func = wl_to_func(wl);
134 int ret;
135
136 /* Let the SDIO stack handle wlan_enable control, so we
137 * keep host claimed while wlan is in use to keep wl1271
138 * alive.
139 */
140 if (enable) {
141 /* Power up the card */
142 ret = pm_runtime_get_sync(&func->dev);
143 if (ret < 0)
144 goto out;
145 sdio_claim_host(func);
146 sdio_enable_func(func);
147 sdio_release_host(func);
148 } else {
149 sdio_claim_host(func);
150 sdio_disable_func(func);
151 sdio_release_host(func);
152
153 /* Power down the card */
154 ret = pm_runtime_put_sync(&func->dev);
155 }
156
157out:
158 return ret;
159}
160
161static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
162{
163}
164
165static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
166{
167}
168
169
170static struct wl1271_if_operations sdio_ops = {
171 .read = wl1271_sdio_raw_read,
172 .write = wl1271_sdio_raw_write,
173 .power = wl1271_sdio_set_power,
174 .dev = wl1271_sdio_wl_to_dev,
175 .enable_irq = wl1271_sdio_enable_interrupts,
176 .disable_irq = wl1271_sdio_disable_interrupts,
177};
178
179static void wl1271_fw_wakeup(struct wl1271 *wl)
180{
181 u32 elp_reg;
182
183 elp_reg = ELPCTRL_WAKE_UP;
184 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
185}
186
187static int wl1271_fetch_firmware(struct wl1271 *wl)
188{
189 const struct firmware *fw;
190 int ret;
191
192 if (wl->chip.id == CHIP_ID_1283_PG20)
193 ret = request_firmware(&fw, WL128X_FW_NAME,
194 wl1271_wl_to_dev(wl));
195 else
196 ret = request_firmware(&fw, WL1271_FW_NAME,
197 wl1271_wl_to_dev(wl));
198
199 if (ret < 0) {
200 wl1271_error("could not get firmware: %d", ret);
201 return ret;
202 }
203
204 if (fw->size % 4) {
205 wl1271_error("firmware size is not multiple of 32 bits: %zu",
206 fw->size);
207 ret = -EILSEQ;
208 goto out;
209 }
210
211 wl->fw_len = fw->size;
212 wl->fw = vmalloc(wl->fw_len);
213
214 if (!wl->fw) {
215 wl1271_error("could not allocate memory for the firmware");
216 ret = -ENOMEM;
217 goto out;
218 }
219
220 memcpy(wl->fw, fw->data, wl->fw_len);
221
222 ret = 0;
223
224out:
225 release_firmware(fw);
226
227 return ret;
228}
229
230static int wl1271_fetch_nvs(struct wl1271 *wl)
231{
232 const struct firmware *fw;
233 int ret;
234
235 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
236
237 if (ret < 0) {
238 wl1271_error("could not get nvs file: %d", ret);
239 return ret;
240 }
241
242 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
243
244 if (!wl->nvs) {
245 wl1271_error("could not allocate memory for the nvs file");
246 ret = -ENOMEM;
247 goto out;
248 }
249
250 wl->nvs_len = fw->size;
251
252out:
253 release_firmware(fw);
254
255 return ret;
256}
257
258static int wl1271_chip_wakeup(struct wl1271 *wl)
259{
260 struct wl1271_partition_set partition;
261 int ret;
262
263 msleep(WL1271_PRE_POWER_ON_SLEEP);
264 ret = wl1271_power_on(wl);
265 if (ret)
266 return ret;
267
268 msleep(WL1271_POWER_ON_SLEEP);
269
270 /* We don't need a real memory partition here, because we only want
271 * to use the registers at this point. */
272 memset(&partition, 0, sizeof(partition));
273 partition.reg.start = REGISTERS_BASE;
274 partition.reg.size = REGISTERS_DOWN_SIZE;
275 wl1271_set_partition(wl, &partition);
276
277 /* ELP module wake up */
278 wl1271_fw_wakeup(wl);
279
280 /* whal_FwCtrl_BootSm() */
281
282 /* 0. read chip id from CHIP_ID */
283 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
284
285 /* 1. check if chip id is valid */
286
287 switch (wl->chip.id) {
288 case CHIP_ID_1271_PG10:
289 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
290 wl->chip.id);
291 break;
292 case CHIP_ID_1271_PG20:
293 wl1271_notice("chip id 0x%x (1271 PG20)",
294 wl->chip.id);
295 break;
296 case CHIP_ID_1283_PG20:
297 wl1271_notice("chip id 0x%x (1283 PG20)",
298 wl->chip.id);
299 break;
300 case CHIP_ID_1283_PG10:
301 default:
302 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
303 return -ENODEV;
304 }
305
306 return ret;
307}
308
309static struct wl1271_partition_set part_down = {
310 .mem = {
311 .start = 0x00000000,
312 .size = 0x000177c0
313 },
314 .reg = {
315 .start = REGISTERS_BASE,
316 .size = 0x00008800
317 },
318 .mem2 = {
319 .start = 0x00000000,
320 .size = 0x00000000
321 },
322 .mem3 = {
323 .start = 0x00000000,
324 .size = 0x00000000
325 },
326};
327
328static int tester(void *data)
329{
330 struct wl1271 *wl = data;
331 struct sdio_func *func = wl_to_func(wl);
332 struct device *pdev = &func->dev;
333 int ret = 0;
334 bool rx_started = 0;
335 bool tx_started = 0;
336 uint8_t *tx_buf, *rx_buf;
337 int test_size = PAGE_SIZE;
338 u32 addr = 0;
339 struct wl1271_partition_set partition;
340
341 /* We assume chip is powered up and firmware fetched */
342
343 memcpy(&partition, &part_down, sizeof(partition));
344 partition.mem.start = addr;
345 wl1271_set_partition(wl, &partition);
346
347 tx_buf = kmalloc(test_size, GFP_KERNEL);
348 rx_buf = kmalloc(test_size, GFP_KERNEL);
349 if (!tx_buf || !rx_buf) {
350 dev_err(pdev,
351 "Could not allocate memory. Test will not run.\n");
352 ret = -ENOMEM;
353 goto free;
354 }
355
356 memset(tx_buf, 0x5a, test_size);
357
358 /* write something in data area so we can read it back */
359 wl1271_write(wl, addr, tx_buf, test_size, false);
360
361 while (!kthread_should_stop()) {
362 if (rx && !rx_started) {
363 dev_info(pdev, "starting rx test\n");
364 rx_started = 1;
365 } else if (!rx && rx_started) {
366 dev_info(pdev, "stopping rx test\n");
367 rx_started = 0;
368 }
369
370 if (tx && !tx_started) {
371 dev_info(pdev, "starting tx test\n");
372 tx_started = 1;
373 } else if (!tx && tx_started) {
374 dev_info(pdev, "stopping tx test\n");
375 tx_started = 0;
376 }
377
378 if (rx_started)
379 wl1271_read(wl, addr, rx_buf, test_size, false);
380
381 if (tx_started)
382 wl1271_write(wl, addr, tx_buf, test_size, false);
383
384 if (!rx_started && !tx_started)
385 msleep(100);
386 }
387
388free:
389 kfree(tx_buf);
390 kfree(rx_buf);
391 return ret;
392}
393
394static int __devinit wl1271_probe(struct sdio_func *func,
395 const struct sdio_device_id *id)
396{
397 const struct wl12xx_platform_data *wlan_data;
398 struct wl1271 *wl;
399 struct wl1271_test *wl_test;
400 int ret = 0;
401
402 /* wl1271 has 2 sdio functions we handle just the wlan part */
403 if (func->num != 0x02)
404 return -ENODEV;
405
406 wl_test = kzalloc(sizeof(struct wl1271_test), GFP_KERNEL);
407 if (!wl_test) {
408 dev_err(&func->dev, "Could not allocate memory\n");
409 return -ENOMEM;
410 }
411
412 wl = &wl_test->wl;
413
414 wl->if_priv = func;
415 wl->if_ops = &sdio_ops;
416
417 /* Grab access to FN0 for ELP reg. */
418 func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
419
420 /* Use block mode for transferring over one block size of data */
421 func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
422
423 wlan_data = wl12xx_get_platform_data();
424 if (IS_ERR(wlan_data)) {
425 ret = PTR_ERR(wlan_data);
426 dev_err(&func->dev, "missing wlan platform data: %d\n", ret);
427 goto out_free;
428 }
429
430 wl->irq = wlan_data->irq;
431 wl->ref_clock = wlan_data->board_ref_clock;
432 wl->tcxo_clock = wlan_data->board_tcxo_clock;
433
434 sdio_set_drvdata(func, wl_test);
435
436
437 /* power up the device */
438 ret = wl1271_chip_wakeup(wl);
439 if (ret) {
440 dev_err(&func->dev, "could not wake up chip\n");
441 goto out_free;
442 }
443
444 if (wl->fw == NULL) {
445 ret = wl1271_fetch_firmware(wl);
446 if (ret < 0) {
447 dev_err(&func->dev, "firmware fetch error\n");
448 goto out_off;
449 }
450 }
451
452 /* fetch NVS */
453 if (wl->nvs == NULL) {
454 ret = wl1271_fetch_nvs(wl);
455 if (ret < 0) {
456 dev_err(&func->dev, "NVS fetch error\n");
457 goto out_off;
458 }
459 }
460
461 ret = wl1271_load_firmware(wl);
462 if (ret < 0) {
463 dev_err(&func->dev, "firmware load error: %d\n", ret);
464 goto out_free;
465 }
466
467 dev_info(&func->dev, "initialized\n");
468
469 /* I/O testing will be done in the tester thread */
470
471 wl_test->test_task = kthread_run(tester, wl, "sdio_tester");
472 if (IS_ERR(wl_test->test_task)) {
473 dev_err(&func->dev, "unable to create kernel thread\n");
474 ret = PTR_ERR(wl_test->test_task);
475 goto out_free;
476 }
477
478 return 0;
479
480out_off:
481 /* power off the chip */
482 wl1271_power_off(wl);
483
484out_free:
485 kfree(wl_test);
486 return ret;
487}
488
489static void __devexit wl1271_remove(struct sdio_func *func)
490{
491 struct wl1271_test *wl_test = sdio_get_drvdata(func);
492
493 /* stop the I/O test thread */
494 kthread_stop(wl_test->test_task);
495
496 /* power off the chip */
497 wl1271_power_off(&wl_test->wl);
498
499 vfree(wl_test->wl.fw);
500 wl_test->wl.fw = NULL;
501 kfree(wl_test->wl.nvs);
502 wl_test->wl.nvs = NULL;
503
504 kfree(wl_test);
505}
506
507static struct sdio_driver wl1271_sdio_driver = {
508 .name = "wl12xx_sdio_test",
509 .id_table = wl1271_devices,
510 .probe = wl1271_probe,
511 .remove = __devexit_p(wl1271_remove),
512};
513
514static int __init wl1271_init(void)
515{
516 int ret;
517
518 ret = sdio_register_driver(&wl1271_sdio_driver);
519 if (ret < 0)
520 pr_err("failed to register sdio driver: %d\n", ret);
521
522 return ret;
523}
524module_init(wl1271_init);
525
526static void __exit wl1271_exit(void)
527{
528 sdio_unregister_driver(&wl1271_sdio_driver);
529}
530module_exit(wl1271_exit);
531
532MODULE_LICENSE("GPL");
533MODULE_AUTHOR("Roger Quadros <roger.quadros@nokia.com>");
534