1 /* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2008-2009 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/interrupt.h> 25 #include <linux/irq.h> 26 #include <linux/module.h> 27 #include <linux/crc7.h> 28 #include <linux/spi/spi.h> 29 #include <linux/wl12xx.h> 30 #include <linux/platform_device.h> 31 #include <linux/slab.h> 32 33 #include "wlcore.h" 34 #include "wl12xx_80211.h" 35 #include "io.h" 36 37 #define WSPI_CMD_READ 0x40000000 38 #define WSPI_CMD_WRITE 0x00000000 39 #define WSPI_CMD_FIXED 0x20000000 40 #define WSPI_CMD_BYTE_LENGTH 0x1FFE0000 41 #define WSPI_CMD_BYTE_LENGTH_OFFSET 17 42 #define WSPI_CMD_BYTE_ADDR 0x0001FFFF 43 44 #define WSPI_INIT_CMD_CRC_LEN 5 45 46 #define WSPI_INIT_CMD_START 0x00 47 #define WSPI_INIT_CMD_TX 0x40 48 /* the extra bypass bit is sampled by the TNET as '1' */ 49 #define WSPI_INIT_CMD_BYPASS_BIT 0x80 50 #define WSPI_INIT_CMD_FIXEDBUSY_LEN 0x07 51 #define WSPI_INIT_CMD_EN_FIXEDBUSY 0x80 52 #define WSPI_INIT_CMD_DIS_FIXEDBUSY 0x00 53 #define WSPI_INIT_CMD_IOD 0x40 54 #define WSPI_INIT_CMD_IP 0x20 55 #define WSPI_INIT_CMD_CS 0x10 56 #define WSPI_INIT_CMD_WS 0x08 57 #define WSPI_INIT_CMD_WSPI 0x01 58 #define WSPI_INIT_CMD_END 0x01 59 60 #define WSPI_INIT_CMD_LEN 8 61 62 #define HW_ACCESS_WSPI_FIXED_BUSY_LEN \ 63 ((WL1271_BUSY_WORD_LEN - 4) / sizeof(u32)) 64 #define HW_ACCESS_WSPI_INIT_CMD_MASK 0 65 66 /* HW limitation: maximum possible chunk size is 4095 bytes */ 67 #define WSPI_MAX_CHUNK_SIZE 4092 68 69 #define WSPI_MAX_NUM_OF_CHUNKS (WL1271_AGGR_BUFFER_SIZE / WSPI_MAX_CHUNK_SIZE) 70 71 struct wl12xx_spi_glue { 72 struct device *dev; 73 struct platform_device *core; 74 }; 75 76 static void wl12xx_spi_reset(struct device *child) 77 { 78 struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); 79 u8 *cmd; 80 struct spi_transfer t; 81 struct spi_message m; 82 83 cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL); 84 if (!cmd) { 85 dev_err(child->parent, 86 "could not allocate cmd for spi reset\n"); 87 return; 88 } 89 90 memset(&t, 0, sizeof(t)); 91 spi_message_init(&m); 92 93 memset(cmd, 0xff, WSPI_INIT_CMD_LEN); 94 95 t.tx_buf = cmd; 96 t.len = WSPI_INIT_CMD_LEN; 97 spi_message_add_tail(&t, &m); 98 99 spi_sync(to_spi_device(glue->dev), &m); 100 101 kfree(cmd); 102 } 103 104 static void wl12xx_spi_init(struct device *child) 105 { 106 struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); 107 u8 crc[WSPI_INIT_CMD_CRC_LEN], *cmd; 108 struct spi_transfer t; 109 struct spi_message m; 110 111 cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL); 112 if (!cmd) { 113 dev_err(child->parent, 114 "could not allocate cmd for spi init\n"); 115 return; 116 } 117 118 memset(crc, 0, sizeof(crc)); 119 memset(&t, 0, sizeof(t)); 120 spi_message_init(&m); 121 122 /* 123 * Set WSPI_INIT_COMMAND 124 * the data is being send from the MSB to LSB 125 */ 126 cmd[2] = 0xff; 127 cmd[3] = 0xff; 128 cmd[1] = WSPI_INIT_CMD_START | WSPI_INIT_CMD_TX; 129 cmd[0] = 0; 130 cmd[7] = 0; 131 cmd[6] |= HW_ACCESS_WSPI_INIT_CMD_MASK << 3; 132 cmd[6] |= HW_ACCESS_WSPI_FIXED_BUSY_LEN & WSPI_INIT_CMD_FIXEDBUSY_LEN; 133 134 if (HW_ACCESS_WSPI_FIXED_BUSY_LEN == 0) 135 cmd[5] |= WSPI_INIT_CMD_DIS_FIXEDBUSY; 136 else 137 cmd[5] |= WSPI_INIT_CMD_EN_FIXEDBUSY; 138 139 cmd[5] |= WSPI_INIT_CMD_IOD | WSPI_INIT_CMD_IP | WSPI_INIT_CMD_CS 140 | WSPI_INIT_CMD_WSPI | WSPI_INIT_CMD_WS; 141 142 crc[0] = cmd[1]; 143 crc[1] = cmd[0]; 144 crc[2] = cmd[7]; 145 crc[3] = cmd[6]; 146 crc[4] = cmd[5]; 147 148 cmd[4] |= crc7(0, crc, WSPI_INIT_CMD_CRC_LEN) << 1; 149 cmd[4] |= WSPI_INIT_CMD_END; 150 151 t.tx_buf = cmd; 152 t.len = WSPI_INIT_CMD_LEN; 153 spi_message_add_tail(&t, &m); 154 155 spi_sync(to_spi_device(glue->dev), &m); 156 kfree(cmd); 157 } 158 159 #define WL1271_BUSY_WORD_TIMEOUT 1000 160 161 static int wl12xx_spi_read_busy(struct device *child) 162 { 163 struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); 164 struct wl1271 *wl = dev_get_drvdata(child); 165 struct spi_transfer t[1]; 166 struct spi_message m; 167 u32 *busy_buf; 168 int num_busy_bytes = 0; 169 170 /* 171 * Read further busy words from SPI until a non-busy word is 172 * encountered, then read the data itself into the buffer. 173 */ 174 175 num_busy_bytes = WL1271_BUSY_WORD_TIMEOUT; 176 busy_buf = wl->buffer_busyword; 177 while (num_busy_bytes) { 178 num_busy_bytes--; 179 spi_message_init(&m); 180 memset(t, 0, sizeof(t)); 181 t[0].rx_buf = busy_buf; 182 t[0].len = sizeof(u32); 183 t[0].cs_change = true; 184 spi_message_add_tail(&t[0], &m); 185 spi_sync(to_spi_device(glue->dev), &m); 186 187 if (*busy_buf & 0x1) 188 return 0; 189 } 190 191 /* The SPI bus is unresponsive, the read failed. */ 192 dev_err(child->parent, "SPI read busy-word timeout!\n"); 193 return -ETIMEDOUT; 194 } 195 196 static void wl12xx_spi_raw_read(struct device *child, int addr, void *buf, 197 size_t len, bool fixed) 198 { 199 struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); 200 struct wl1271 *wl = dev_get_drvdata(child); 201 struct spi_transfer t[2]; 202 struct spi_message m; 203 u32 *busy_buf; 204 u32 *cmd; 205 u32 chunk_len; 206 207 while (len > 0) { 208 chunk_len = min((size_t)WSPI_MAX_CHUNK_SIZE, len); 209 210 cmd = &wl->buffer_cmd; 211 busy_buf = wl->buffer_busyword; 212 213 *cmd = 0; 214 *cmd |= WSPI_CMD_READ; 215 *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) & 216 WSPI_CMD_BYTE_LENGTH; 217 *cmd |= addr & WSPI_CMD_BYTE_ADDR; 218 219 if (fixed) 220 *cmd |= WSPI_CMD_FIXED; 221 222 spi_message_init(&m); 223 memset(t, 0, sizeof(t)); 224 225 t[0].tx_buf = cmd; 226 t[0].len = 4; 227 t[0].cs_change = true; 228 spi_message_add_tail(&t[0], &m); 229 230 /* Busy and non busy words read */ 231 t[1].rx_buf = busy_buf; 232 t[1].len = WL1271_BUSY_WORD_LEN; 233 t[1].cs_change = true; 234 spi_message_add_tail(&t[1], &m); 235 236 spi_sync(to_spi_device(glue->dev), &m); 237 238 if (!(busy_buf[WL1271_BUSY_WORD_CNT - 1] & 0x1) && 239 wl12xx_spi_read_busy(child)) { 240 memset(buf, 0, chunk_len); 241 return; 242 } 243 244 spi_message_init(&m); 245 memset(t, 0, sizeof(t)); 246 247 t[0].rx_buf = buf; 248 t[0].len = chunk_len; 249 t[0].cs_change = true; 250 spi_message_add_tail(&t[0], &m); 251 252 spi_sync(to_spi_device(glue->dev), &m); 253 254 if (!fixed) 255 addr += chunk_len; 256 buf += chunk_len; 257 len -= chunk_len; 258 } 259 } 260 261 static void wl12xx_spi_raw_write(struct device *child, int addr, void *buf, 262 size_t len, bool fixed) 263 { 264 struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); 265 struct spi_transfer t[2 * WSPI_MAX_NUM_OF_CHUNKS]; 266 struct spi_message m; 267 u32 commands[WSPI_MAX_NUM_OF_CHUNKS]; 268 u32 *cmd; 269 u32 chunk_len; 270 int i; 271 272 WARN_ON(len > WL1271_AGGR_BUFFER_SIZE); 273 274 spi_message_init(&m); 275 memset(t, 0, sizeof(t)); 276 277 cmd = &commands[0]; 278 i = 0; 279 while (len > 0) { 280 chunk_len = min((size_t)WSPI_MAX_CHUNK_SIZE, len); 281 282 *cmd = 0; 283 *cmd |= WSPI_CMD_WRITE; 284 *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) & 285 WSPI_CMD_BYTE_LENGTH; 286 *cmd |= addr & WSPI_CMD_BYTE_ADDR; 287 288 if (fixed) 289 *cmd |= WSPI_CMD_FIXED; 290 291 t[i].tx_buf = cmd; 292 t[i].len = sizeof(*cmd); 293 spi_message_add_tail(&t[i++], &m); 294 295 t[i].tx_buf = buf; 296 t[i].len = chunk_len; 297 spi_message_add_tail(&t[i++], &m); 298 299 if (!fixed) 300 addr += chunk_len; 301 buf += chunk_len; 302 len -= chunk_len; 303 cmd++; 304 } 305 306 spi_sync(to_spi_device(glue->dev), &m); 307 } 308 309 static struct wl1271_if_operations spi_ops = { 310 .read = wl12xx_spi_raw_read, 311 .write = wl12xx_spi_raw_write, 312 .reset = wl12xx_spi_reset, 313 .init = wl12xx_spi_init, 314 .set_block_size = NULL, 315 }; 316 317 static int __devinit wl1271_probe(struct spi_device *spi) 318 { 319 struct wl12xx_spi_glue *glue; 320 struct wl12xx_platform_data *pdata; 321 struct resource res[1]; 322 int ret = -ENOMEM; 323 324 pdata = spi->dev.platform_data; 325 if (!pdata) { 326 dev_err(&spi->dev, "no platform data\n"); 327 return -ENODEV; 328 } 329 330 pdata->ops = &spi_ops; 331 332 glue = kzalloc(sizeof(*glue), GFP_KERNEL); 333 if (!glue) { 334 dev_err(&spi->dev, "can't allocate glue\n"); 335 goto out; 336 } 337 338 glue->dev = &spi->dev; 339 340 spi_set_drvdata(spi, glue); 341 342 /* This is the only SPI value that we need to set here, the rest 343 * comes from the board-peripherals file */ 344 spi->bits_per_word = 32; 345 346 ret = spi_setup(spi); 347 if (ret < 0) { 348 dev_err(glue->dev, "spi_setup failed\n"); 349 goto out_free_glue; 350 } 351 352 glue->core = platform_device_alloc("wl12xx", -1); 353 if (!glue->core) { 354 dev_err(glue->dev, "can't allocate platform_device\n"); 355 ret = -ENOMEM; 356 goto out_free_glue; 357 } 358 359 glue->core->dev.parent = &spi->dev; 360 361 memset(res, 0x00, sizeof(res)); 362 363 res[0].start = spi->irq; 364 res[0].flags = IORESOURCE_IRQ; 365 res[0].name = "irq"; 366 367 ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); 368 if (ret) { 369 dev_err(glue->dev, "can't add resources\n"); 370 goto out_dev_put; 371 } 372 373 ret = platform_device_add_data(glue->core, pdata, sizeof(*pdata)); 374 if (ret) { 375 dev_err(glue->dev, "can't add platform data\n"); 376 goto out_dev_put; 377 } 378 379 ret = platform_device_add(glue->core); 380 if (ret) { 381 dev_err(glue->dev, "can't register platform device\n"); 382 goto out_dev_put; 383 } 384 385 return 0; 386 387 out_dev_put: 388 platform_device_put(glue->core); 389 390 out_free_glue: 391 kfree(glue); 392 out: 393 return ret; 394 } 395 396 static int __devexit wl1271_remove(struct spi_device *spi) 397 { 398 struct wl12xx_spi_glue *glue = spi_get_drvdata(spi); 399 400 platform_device_del(glue->core); 401 platform_device_put(glue->core); 402 kfree(glue); 403 404 return 0; 405 } 406 407 408 static struct spi_driver wl1271_spi_driver = { 409 .driver = { 410 .name = "wl1271_spi", 411 .owner = THIS_MODULE, 412 }, 413 414 .probe = wl1271_probe, 415 .remove = __devexit_p(wl1271_remove), 416 }; 417 418 static int __init wl1271_init(void) 419 { 420 return spi_register_driver(&wl1271_spi_driver); 421 } 422 423 static void __exit wl1271_exit(void) 424 { 425 spi_unregister_driver(&wl1271_spi_driver); 426 } 427 428 module_init(wl1271_init); 429 module_exit(wl1271_exit); 430 431 MODULE_LICENSE("GPL"); 432 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); 433 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); 434 MODULE_FIRMWARE(WL127X_FW_NAME_SINGLE); 435 MODULE_FIRMWARE(WL127X_FW_NAME_MULTI); 436 MODULE_FIRMWARE(WL127X_PLT_FW_NAME); 437 MODULE_FIRMWARE(WL128X_FW_NAME_SINGLE); 438 MODULE_FIRMWARE(WL128X_FW_NAME_MULTI); 439 MODULE_FIRMWARE(WL128X_PLT_FW_NAME); 440 MODULE_ALIAS("spi:wl1271"); 441