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