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 * 4K) compared to
  74  * (4 * 4K) for wl12xx, so use the larger buffer needed for wl18xx
  75  */
  76 #define SPI_AGGR_BUFFER_SIZE (13 * SZ_4K)
  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 static const struct wilink_family_data wl127x_data = {
  83         .name = "wl127x",
  84         .nvs_name = "/*(DEBLOBBED)*/",
  85 };
  86
  87 static const struct wilink_family_data wl128x_data = {
  88         .name = "wl128x",
  89         .nvs_name = "/*(DEBLOBBED)*/",
  90 };
  91
  92 static const struct wilink_family_data wl18xx_data = {
  93         .name = "wl18xx",
  94         .cfg_name = "/*(DEBLOBBED)*/",
  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 = &wl127x_data},
 433         { .compatible = "ti,wl1273", .data = &wl127x_data},
 434         { .compatible = "ti,wl1281", .data = &wl128x_data},
 435         { .compatible = "ti,wl1283", .data = &wl128x_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         pdev_data->family = of_id->data;
 464         dev_info(&spi->dev, "selected chip family is %s\n",
 465                  pdev_data->family->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         pdev_data = devm_kzalloc(&spi->dev, sizeof(*pdev_data), GFP_KERNEL);
 487         if (!pdev_data)
 488                 return -ENOMEM;
 489
 490         pdev_data->if_ops = &spi_ops;
 491
 492         glue = devm_kzalloc(&spi->dev, sizeof(*glue), GFP_KERNEL);
 493         if (!glue) {
 494                 dev_err(&spi->dev, "can't allocate glue\n");
 495                 return -ENOMEM;
 496         }
 497
 498         glue->dev = &spi->dev;
 499
 500         spi_set_drvdata(spi, glue);
 501
 502         /* This is the only SPI value that we need to set here, the rest
 503          * comes from the board-peripherals file */
 504         spi->bits_per_word = 32;
 505
 506         glue->reg = devm_regulator_get(&spi->dev, "vwlan");
 507         if (PTR_ERR(glue->reg) == -EPROBE_DEFER)
 508                 return -EPROBE_DEFER;
 509         if (IS_ERR(glue->reg)) {
 510                 dev_err(glue->dev, "can't get regulator\n");
 511                 return PTR_ERR(glue->reg);
 512         }
 513
 514         ret = wlcore_probe_of(spi, glue, pdev_data);
 515         if (ret) {
 516                 dev_err(glue->dev,
 517                         "can't get device tree parameters (%d)\n", ret);
 518                 return ret;
 519         }
 520
 521         ret = spi_setup(spi);
 522         if (ret < 0) {
 523                 dev_err(glue->dev, "spi_setup failed\n");
 524                 return ret;
 525         }
 526
 527         glue->core = platform_device_alloc(pdev_data->family->name,
 528                                            PLATFORM_DEVID_AUTO);
 529         if (!glue->core) {
 530                 dev_err(glue->dev, "can't allocate platform_device\n");
 531                 return -ENOMEM;
 532         }
 533
 534         glue->core->dev.parent = &spi->dev;
 535
 536         memset(res, 0x00, sizeof(res));
 537
 538         res[0].start = spi->irq;
 539         res[0].flags = IORESOURCE_IRQ | irq_get_trigger_type(spi->irq);
 540         res[0].name = "irq";
 541
 542         ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res));
 543         if (ret) {
 544                 dev_err(glue->dev, "can't add resources\n");
 545                 goto out_dev_put;
 546         }
 547
 548         ret = platform_device_add_data(glue->core, pdev_data,
 549                                        sizeof(*pdev_data));
 550         if (ret) {
 551                 dev_err(glue->dev, "can't add platform data\n");
 552                 goto out_dev_put;
 553         }
 554
 555         ret = platform_device_add(glue->core);
 556         if (ret) {
 557                 dev_err(glue->dev, "can't register platform device\n");
 558                 goto out_dev_put;
 559         }
 560
 561         return 0;
 562
 563 out_dev_put:
 564         platform_device_put(glue->core);
 565         return ret;
 566 }
 567
 568 static int wl1271_remove(struct spi_device *spi)
 569 {
 570         struct wl12xx_spi_glue *glue = spi_get_drvdata(spi);
 571
 572         platform_device_unregister(glue->core);
 573
 574         return 0;
 575 }
 576
 577 static struct spi_driver wl1271_spi_driver = {
 578         .driver = {
 579                 .name           = "wl1271_spi",
 580                 .of_match_table = of_match_ptr(wlcore_spi_of_match_table),
 581         },
 582
 583         .probe          = wl1271_probe,
 584         .remove         = wl1271_remove,
 585 };
 586
 587 module_spi_driver(wl1271_spi_driver);
 588 MODULE_LICENSE("GPL");
 589 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
 590 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
 591 MODULE_ALIAS("spi:wl1271");