drivers/net/wireless/ti/wlcore/spi.c

   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/slab.h>
  28 #include <linux/swab.h>
  29 #include <linux/crc7.h>
  30 #include <linux/spi/spi.h>
  31 #include <linux/wl12xx.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/of_irq.h>
  34 #include <linux/regulator/consumer.h>
  35
  36 #include "wlcore.h"
  37 #include "wl12xx_80211.h"
  38 #include "io.h"
  39
  40 #define WSPI_CMD_READ                 0x40000000
  41 #define WSPI_CMD_WRITE                0x00000000
  42 #define WSPI_CMD_FIXED                0x20000000
  43 #define WSPI_CMD_BYTE_LENGTH          0x1FFE0000
  44 #define WSPI_CMD_BYTE_LENGTH_OFFSET   17
  45 #define WSPI_CMD_BYTE_ADDR            0x0001FFFF
  46
  47 #define WSPI_INIT_CMD_CRC_LEN       5
  48
  49 #define WSPI_INIT_CMD_START         0x00
  50 #define WSPI_INIT_CMD_TX            0x40
  51 /* the extra bypass bit is sampled by the TNET as '1' */
  52 #define WSPI_INIT_CMD_BYPASS_BIT    0x80
  53 #define WSPI_INIT_CMD_FIXEDBUSY_LEN 0x07
  54 #define WSPI_INIT_CMD_EN_FIXEDBUSY  0x80
  55 #define WSPI_INIT_CMD_DIS_FIXEDBUSY 0x00
  56 #define WSPI_INIT_CMD_IOD           0x40
  57 #define WSPI_INIT_CMD_IP            0x20
  58 #define WSPI_INIT_CMD_CS            0x10
  59 #define WSPI_INIT_CMD_WS            0x08
  60 #define WSPI_INIT_CMD_WSPI          0x01
  61 #define WSPI_INIT_CMD_END           0x01
  62
  63 #define WSPI_INIT_CMD_LEN           8
  64
  65 #define HW_ACCESS_WSPI_FIXED_BUSY_LEN \
  66                 ((WL1271_BUSY_WORD_LEN - 4) / sizeof(u32))
  67 #define HW_ACCESS_WSPI_INIT_CMD_MASK  0
  68
  69 /* HW limitation: maximum possible chunk size is 4095 bytes */
  70 #define WSPI_MAX_CHUNK_SIZE    4092
  71
  72 /*
  73  * wl18xx driver aggregation buffer size is (13 * PAGE_SIZE) compared to
  74  * (4 * PAGE_SIZE) for wl12xx, so use the larger buffer needed for wl18xx
  75  */
  76 #define SPI_AGGR_BUFFER_SIZE (13 * PAGE_SIZE)
  77
  78 /* Maximum number of SPI write chunks */
  79 #define WSPI_MAX_NUM_OF_CHUNKS \
  80         ((SPI_AGGR_BUFFER_SIZE / WSPI_MAX_CHUNK_SIZE) + 1)
  81
  82
  83 struct wilink_familiy_data {
  84         char name[8];
  85 };
  86
  87 const struct wilink_familiy_data *wilink_data;
  88
  89 static const struct wilink_familiy_data wl18xx_data = {
  90         .name = "wl18xx",
  91 };
  92
  93 static const struct wilink_familiy_data wl12xx_data = {
  94         .name = "wl12xx",
  95 };
  96
  97 struct wl12xx_spi_glue {
  98         struct device *dev;
  99         struct platform_device *core;
 100         struct regulator *reg; /* Power regulator */
 101 };
 102
 103 static void wl12xx_spi_reset(struct device *child)
 104 {
 105         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 106         u8 *cmd;
 107         struct spi_transfer t;
 108         struct spi_message m;
 109
 110         cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
 111         if (!cmd) {
 112                 dev_err(child->parent,
 113                         "could not allocate cmd for spi reset\n");
 114                 return;
 115         }
 116
 117         memset(&t, 0, sizeof(t));
 118         spi_message_init(&m);
 119
 120         memset(cmd, 0xff, WSPI_INIT_CMD_LEN);
 121
 122         t.tx_buf = cmd;
 123         t.len = WSPI_INIT_CMD_LEN;
 124         spi_message_add_tail(&t, &m);
 125
 126         spi_sync(to_spi_device(glue->dev), &m);
 127
 128         kfree(cmd);
 129 }
 130
 131 static void wl12xx_spi_init(struct device *child)
 132 {
 133         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 134         struct spi_transfer t;
 135         struct spi_message m;
 136         struct spi_device *spi = to_spi_device(glue->dev);
 137         u8 *cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
 138
 139         if (!cmd) {
 140                 dev_err(child->parent,
 141                         "could not allocate cmd for spi init\n");
 142                 return;
 143         }
 144
 145         memset(&t, 0, sizeof(t));
 146         spi_message_init(&m);
 147
 148         /*
 149          * Set WSPI_INIT_COMMAND
 150          * the data is being send from the MSB to LSB
 151          */
 152         cmd[0] = 0xff;
 153         cmd[1] = 0xff;
 154         cmd[2] = WSPI_INIT_CMD_START | WSPI_INIT_CMD_TX;
 155         cmd[3] = 0;
 156         cmd[4] = 0;
 157         cmd[5] = HW_ACCESS_WSPI_INIT_CMD_MASK << 3;
 158         cmd[5] |= HW_ACCESS_WSPI_FIXED_BUSY_LEN & WSPI_INIT_CMD_FIXEDBUSY_LEN;
 159
 160         cmd[6] = WSPI_INIT_CMD_IOD | WSPI_INIT_CMD_IP | WSPI_INIT_CMD_CS
 161                 | WSPI_INIT_CMD_WSPI | WSPI_INIT_CMD_WS;
 162
 163         if (HW_ACCESS_WSPI_FIXED_BUSY_LEN == 0)
 164                 cmd[6] |= WSPI_INIT_CMD_DIS_FIXEDBUSY;
 165         else
 166                 cmd[6] |= WSPI_INIT_CMD_EN_FIXEDBUSY;
 167
 168         cmd[7] = crc7_be(0, cmd+2, WSPI_INIT_CMD_CRC_LEN) | WSPI_INIT_CMD_END;
 169
 170         /*
 171          * The above is the logical order; it must actually be stored
 172          * in the buffer byte-swapped.
 173          */
 174         __swab32s((u32 *)cmd);
 175         __swab32s((u32 *)cmd+1);
 176
 177         t.tx_buf = cmd;
 178         t.len = WSPI_INIT_CMD_LEN;
 179         spi_message_add_tail(&t, &m);
 180
 181         spi_sync(to_spi_device(glue->dev), &m);
 182
 183         /* Send extra clocks with inverted CS (high). this is required
 184          * by the wilink family in order to successfully enter WSPI mode.
 185          */
 186         spi->mode ^= SPI_CS_HIGH;
 187         memset(&m, 0, sizeof(m));
 188         spi_message_init(&m);
 189
 190         cmd[0] = 0xff;
 191         cmd[1] = 0xff;
 192         cmd[2] = 0xff;
 193         cmd[3] = 0xff;
 194         __swab32s((u32 *)cmd);
 195
 196         t.tx_buf = cmd;
 197         t.len = 4;
 198         spi_message_add_tail(&t, &m);
 199
 200         spi_sync(to_spi_device(glue->dev), &m);
 201
 202         /* Restore chip select configration to normal */
 203         spi->mode ^= SPI_CS_HIGH;
 204         kfree(cmd);
 205 }
 206
 207 #define WL1271_BUSY_WORD_TIMEOUT 1000
 208
 209 static int wl12xx_spi_read_busy(struct device *child)
 210 {
 211         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 212         struct wl1271 *wl = dev_get_drvdata(child);
 213         struct spi_transfer t[1];
 214         struct spi_message m;
 215         u32 *busy_buf;
 216         int num_busy_bytes = 0;
 217
 218         /*
 219          * Read further busy words from SPI until a non-busy word is
 220          * encountered, then read the data itself into the buffer.
 221          */
 222
 223         num_busy_bytes = WL1271_BUSY_WORD_TIMEOUT;
 224         busy_buf = wl->buffer_busyword;
 225         while (num_busy_bytes) {
 226                 num_busy_bytes--;
 227                 spi_message_init(&m);
 228                 memset(t, 0, sizeof(t));
 229                 t[0].rx_buf = busy_buf;
 230                 t[0].len = sizeof(u32);
 231                 t[0].cs_change = true;
 232                 spi_message_add_tail(&t[0], &m);
 233                 spi_sync(to_spi_device(glue->dev), &m);
 234
 235                 if (*busy_buf & 0x1)
 236                         return 0;
 237         }
 238
 239         /* The SPI bus is unresponsive, the read failed. */
 240         dev_err(child->parent, "SPI read busy-word timeout!\n");
 241         return -ETIMEDOUT;
 242 }
 243
 244 static int __must_check wl12xx_spi_raw_read(struct device *child, int addr,
 245                                             void *buf, size_t len, bool fixed)
 246 {
 247         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 248         struct wl1271 *wl = dev_get_drvdata(child);
 249         struct spi_transfer t[2];
 250         struct spi_message m;
 251         u32 *busy_buf;
 252         u32 *cmd;
 253         u32 chunk_len;
 254
 255         while (len > 0) {
 256                 chunk_len = min_t(size_t, WSPI_MAX_CHUNK_SIZE, len);
 257
 258                 cmd = &wl->buffer_cmd;
 259                 busy_buf = wl->buffer_busyword;
 260
 261                 *cmd = 0;
 262                 *cmd |= WSPI_CMD_READ;
 263                 *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) &
 264                         WSPI_CMD_BYTE_LENGTH;
 265                 *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 266
 267                 if (fixed)
 268                         *cmd |= WSPI_CMD_FIXED;
 269
 270                 spi_message_init(&m);
 271                 memset(t, 0, sizeof(t));
 272
 273                 t[0].tx_buf = cmd;
 274                 t[0].len = 4;
 275                 t[0].cs_change = true;
 276                 spi_message_add_tail(&t[0], &m);
 277
 278                 /* Busy and non busy words read */
 279                 t[1].rx_buf = busy_buf;
 280                 t[1].len = WL1271_BUSY_WORD_LEN;
 281                 t[1].cs_change = true;
 282                 spi_message_add_tail(&t[1], &m);
 283
 284                 spi_sync(to_spi_device(glue->dev), &m);
 285
 286                 if (!(busy_buf[WL1271_BUSY_WORD_CNT - 1] & 0x1) &&
 287                     wl12xx_spi_read_busy(child)) {
 288                         memset(buf, 0, chunk_len);
 289                         return 0;
 290                 }
 291
 292                 spi_message_init(&m);
 293                 memset(t, 0, sizeof(t));
 294
 295                 t[0].rx_buf = buf;
 296                 t[0].len = chunk_len;
 297                 t[0].cs_change = true;
 298                 spi_message_add_tail(&t[0], &m);
 299
 300                 spi_sync(to_spi_device(glue->dev), &m);
 301
 302                 if (!fixed)
 303                         addr += chunk_len;
 304                 buf += chunk_len;
 305                 len -= chunk_len;
 306         }
 307
 308         return 0;
 309 }
 310
 311 static int __wl12xx_spi_raw_write(struct device *child, int addr,
 312                                   void *buf, size_t len, bool fixed)
 313 {
 314         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 315         struct spi_transfer *t;
 316         struct spi_message m;
 317         u32 commands[WSPI_MAX_NUM_OF_CHUNKS]; /* 1 command per chunk */
 318         u32 *cmd;
 319         u32 chunk_len;
 320         int i;
 321
 322         /* SPI write buffers - 2 for each chunk */
 323         t = kzalloc(sizeof(*t) * 2 * WSPI_MAX_NUM_OF_CHUNKS, GFP_KERNEL);
 324         if (!t)
 325                 return -ENOMEM;
 326
 327         WARN_ON(len > SPI_AGGR_BUFFER_SIZE);
 328
 329         spi_message_init(&m);
 330
 331         cmd = &commands[0];
 332         i = 0;
 333         while (len > 0) {
 334                 chunk_len = min_t(size_t, WSPI_MAX_CHUNK_SIZE, len);
 335
 336                 *cmd = 0;
 337                 *cmd |= WSPI_CMD_WRITE;
 338                 *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) &
 339                         WSPI_CMD_BYTE_LENGTH;
 340                 *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 341
 342                 if (fixed)
 343                         *cmd |= WSPI_CMD_FIXED;
 344
 345                 t[i].tx_buf = cmd;
 346                 t[i].len = sizeof(*cmd);
 347                 spi_message_add_tail(&t[i++], &m);
 348
 349                 t[i].tx_buf = buf;
 350                 t[i].len = chunk_len;
 351                 spi_message_add_tail(&t[i++], &m);
 352
 353                 if (!fixed)
 354                         addr += chunk_len;
 355                 buf += chunk_len;
 356                 len -= chunk_len;
 357                 cmd++;
 358         }
 359
 360         spi_sync(to_spi_device(glue->dev), &m);
 361
 362         kfree(t);
 363         return 0;
 364 }
 365
 366 static int __must_check wl12xx_spi_raw_write(struct device *child, int addr,
 367                                              void *buf, size_t len, bool fixed)
 368 {
 369         int ret;
 370
 371         /* The ELP wakeup write may fail the first time due to internal
 372          * hardware latency. It is safer to send the wakeup command twice to
 373          * avoid unexpected failures.
 374          */
 375         if (addr == HW_ACCESS_ELP_CTRL_REG)
 376                 ret = __wl12xx_spi_raw_write(child, addr, buf, len, fixed);
 377         ret = __wl12xx_spi_raw_write(child, addr, buf, len, fixed);
 378
 379         return ret;
 380 }
 381
 382 /**
 383  * wl12xx_spi_set_power - power on/off the wl12xx unit
 384  * @child: wl12xx device handle.
 385  * @enable: true/false to power on/off the unit.
 386  *
 387  * use the WiFi enable regulator to enable/disable the WiFi unit.
 388  */
 389 static int wl12xx_spi_set_power(struct device *child, bool enable)
 390 {
 391         int ret = 0;
 392         struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);
 393
 394         WARN_ON(!glue->reg);
 395
 396         /* Update regulator state */
 397         if (enable) {
 398                 ret = regulator_enable(glue->reg);
 399                 if (ret)
 400                         dev_err(child, "Power enable failure\n");
 401         } else {
 402                 ret =  regulator_disable(glue->reg);
 403                 if (ret)
 404                         dev_err(child, "Power disable failure\n");
 405         }
 406
 407         return ret;
 408 }
 409
 410 /**
 411  * wl12xx_spi_set_block_size
 412  *
 413  * This function is not needed for spi mode, but need to be present.
 414  * Without it defined the wlcore fallback to use the wrong packet
 415  * allignment on tx.
 416  */
 417 static void wl12xx_spi_set_block_size(struct device *child,
 418                                       unsigned int blksz)
 419 {
 420 }
 421
 422 static struct wl1271_if_operations spi_ops = {
 423         .read           = wl12xx_spi_raw_read,
 424         .write          = wl12xx_spi_raw_write,
 425         .reset          = wl12xx_spi_reset,
 426         .init           = wl12xx_spi_init,
 427         .power          = wl12xx_spi_set_power,
 428         .set_block_size = wl12xx_spi_set_block_size,
 429 };
 430
 431 static const struct of_device_id wlcore_spi_of_match_table[] = {
 432         { .compatible = "ti,wl1271", .data = &wl12xx_data},
 433         { .compatible = "ti,wl1273", .data = &wl12xx_data},
 434         { .compatible = "ti,wl1281", .data = &wl12xx_data},
 435         { .compatible = "ti,wl1283", .data = &wl12xx_data},
 436         { .compatible = "ti,wl1801", .data = &wl18xx_data},
 437         { .compatible = "ti,wl1805", .data = &wl18xx_data},
 438         { .compatible = "ti,wl1807", .data = &wl18xx_data},
 439         { .compatible = "ti,wl1831", .data = &wl18xx_data},
 440         { .compatible = "ti,wl1835", .data = &wl18xx_data},
 441         { .compatible = "ti,wl1837", .data = &wl18xx_data},
 442         { }
 443 };
 444 MODULE_DEVICE_TABLE(of, wlcore_spi_of_match_table);
 445
 446 /**
 447  * wlcore_probe_of - DT node parsing.
 448  * @spi: SPI slave device parameters.
 449  * @res: resource parameters.
 450  * @glue: wl12xx SPI bus to slave device glue parameters.
 451  * @pdev_data: wlcore device parameters
 452  */
 453 static int wlcore_probe_of(struct spi_device *spi, struct wl12xx_spi_glue *glue,
 454                            struct wlcore_platdev_data *pdev_data)
 455 {
 456         struct device_node *dt_node = spi->dev.of_node;
 457         const struct of_device_id *of_id;
 458
 459         of_id = of_match_node(wlcore_spi_of_match_table, dt_node);
 460         if (!of_id)
 461                 return -ENODEV;
 462
 463         wilink_data = of_id->data;
 464         dev_info(&spi->dev, "selected chip familiy is %s\n",
 465                  wilink_data->name);
 466
 467         if (of_find_property(dt_node, "clock-xtal", NULL))
 468                 pdev_data->ref_clock_xtal = true;
 469
 470         /* optional clock frequency params */
 471         of_property_read_u32(dt_node, "ref-clock-frequency",
 472                              &pdev_data->ref_clock_freq);
 473         of_property_read_u32(dt_node, "tcxo-clock-frequency",
 474                              &pdev_data->tcxo_clock_freq);
 475
 476         return 0;
 477 }
 478
 479 static int wl1271_probe(struct spi_device *spi)
 480 {
 481         struct wl12xx_spi_glue *glue;
 482         struct wlcore_platdev_data pdev_data;
 483         struct resource res[1];
 484         int ret;
 485
 486         memset(&pdev_data, 0x00, sizeof(pdev_data));
 487
 488         pdev_data.if_ops = &spi_ops;
 489
 490         glue = devm_kzalloc(&spi->dev, sizeof(*glue), GFP_KERNEL);
 491         if (!glue) {
 492                 dev_err(&spi->dev, "can't allocate glue\n");
 493                 return -ENOMEM;
 494         }
 495
 496         glue->dev = &spi->dev;
 497
 498         spi_set_drvdata(spi, glue);
 499
 500         /* This is the only SPI value that we need to set here, the rest
 501          * comes from the board-peripherals file */
 502         spi->bits_per_word = 32;
 503
 504         glue->reg = devm_regulator_get(&spi->dev, "vwlan");
 505         if (PTR_ERR(glue->reg) == -EPROBE_DEFER)
 506                 return -EPROBE_DEFER;
 507         if (IS_ERR(glue->reg)) {
 508                 dev_err(glue->dev, "can't get regulator\n");
 509                 return PTR_ERR(glue->reg);
 510         }
 511
 512         ret = wlcore_probe_of(spi, glue, &pdev_data);
 513         if (ret) {
 514                 dev_err(glue->dev,
 515                         "can't get device tree parameters (%d)\n", ret);
 516                 return ret;
 517         }
 518
 519         ret = spi_setup(spi);
 520         if (ret < 0) {
 521                 dev_err(glue->dev, "spi_setup failed\n");
 522                 return ret;
 523         }
 524
 525         glue->core = platform_device_alloc(wilink_data->name,
 526                                            PLATFORM_DEVID_AUTO);
 527         if (!glue->core) {
 528                 dev_err(glue->dev, "can't allocate platform_device\n");
 529                 return -ENOMEM;
 530         }
 531
 532         glue->core->dev.parent = &spi->dev;
 533
 534         memset(res, 0x00, sizeof(res));
 535
 536         res[0].start = spi->irq;
 537         res[0].flags = IORESOURCE_IRQ | irq_get_trigger_type(spi->irq);
 538         res[0].name = "irq";
 539
 540         ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res));
 541         if (ret) {
 542                 dev_err(glue->dev, "can't add resources\n");
 543                 goto out_dev_put;
 544         }
 545
 546         ret = platform_device_add_data(glue->core, &pdev_data,
 547                                        sizeof(pdev_data));
 548         if (ret) {
 549                 dev_err(glue->dev, "can't add platform data\n");
 550                 goto out_dev_put;
 551         }
 552
 553         ret = platform_device_add(glue->core);
 554         if (ret) {
 555                 dev_err(glue->dev, "can't register platform device\n");
 556                 goto out_dev_put;
 557         }
 558
 559         return 0;
 560
 561 out_dev_put:
 562         platform_device_put(glue->core);
 563         return ret;
 564 }
 565
 566 static int wl1271_remove(struct spi_device *spi)
 567 {
 568         struct wl12xx_spi_glue *glue = spi_get_drvdata(spi);
 569
 570         platform_device_unregister(glue->core);
 571
 572         return 0;
 573 }
 574
 575 static struct spi_driver wl1271_spi_driver = {
 576         .driver = {
 577                 .name           = "wl1271_spi",
 578                 .of_match_table = of_match_ptr(wlcore_spi_of_match_table),
 579         },
 580
 581         .probe          = wl1271_probe,
 582         .remove         = wl1271_remove,
 583 };
 584
 585 module_spi_driver(wl1271_spi_driver);
 586 MODULE_LICENSE("GPL");
 587 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
 588 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
 589 MODULE_ALIAS("spi:wl1271");