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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This file is part of wl1251
   4  *
   5  * Copyright (C) 2008 Nokia Corporation
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/irq.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/swab.h>
  14 #include <linux/crc7.h>
  15 #include <linux/spi/spi.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/of.h>
  18 #include <linux/regulator/consumer.h>
  19
  20 #include "wl1251.h"
  21 #include "reg.h"
  22 #include "spi.h"
  23
  24 struct wl1251_spi {
  25         struct spi_device *spi;
  26         struct gpio_desc *power_gpio;
  27 };
  28
  29 static irqreturn_t wl1251_irq(int irq, void *cookie)
  30 {
  31         struct wl1251 *wl;
  32
  33         wl1251_debug(DEBUG_IRQ, "IRQ");
  34
  35         wl = cookie;
  36
  37         ieee80211_queue_work(wl->hw, &wl->irq_work);
  38
  39         return IRQ_HANDLED;
  40 }
  41
  42 static void wl1251_spi_reset(struct wl1251 *wl)
  43 {
  44         struct wl1251_spi *wl_spi = wl->if_priv;
  45         u8 *cmd;
  46         struct spi_transfer t;
  47         struct spi_message m;
  48
  49         cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
  50         if (!cmd) {
  51                 wl1251_error("could not allocate cmd for spi reset");
  52                 return;
  53         }
  54
  55         memset(&t, 0, sizeof(t));
  56         spi_message_init(&m);
  57
  58         memset(cmd, 0xff, WSPI_INIT_CMD_LEN);
  59
  60         t.tx_buf = cmd;
  61         t.len = WSPI_INIT_CMD_LEN;
  62         spi_message_add_tail(&t, &m);
  63
  64         spi_sync(wl_spi->spi, &m);
  65
  66         wl1251_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
  67
  68         kfree(cmd);
  69 }
  70
  71 static void wl1251_spi_wake(struct wl1251 *wl)
  72 {
  73         struct wl1251_spi *wl_spi = wl->if_priv;
  74         struct spi_transfer t;
  75         struct spi_message m;
  76         u8 *cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
  77
  78         if (!cmd) {
  79                 wl1251_error("could not allocate cmd for spi init");
  80                 return;
  81         }
  82
  83         memset(&t, 0, sizeof(t));
  84         spi_message_init(&m);
  85
  86         /* Set WSPI_INIT_COMMAND
  87          * the data is being send from the MSB to LSB
  88          */
  89         cmd[0] = 0xff;
  90         cmd[1] = 0xff;
  91         cmd[2] = WSPI_INIT_CMD_START | WSPI_INIT_CMD_TX;
  92         cmd[3] = 0;
  93         cmd[4] = 0;
  94         cmd[5] = HW_ACCESS_WSPI_INIT_CMD_MASK << 3;
  95         cmd[5] |= HW_ACCESS_WSPI_FIXED_BUSY_LEN & WSPI_INIT_CMD_FIXEDBUSY_LEN;
  96
  97         cmd[6] = WSPI_INIT_CMD_IOD | WSPI_INIT_CMD_IP | WSPI_INIT_CMD_CS
  98                 | WSPI_INIT_CMD_WSPI | WSPI_INIT_CMD_WS;
  99
 100         if (HW_ACCESS_WSPI_FIXED_BUSY_LEN == 0)
 101                 cmd[6] |= WSPI_INIT_CMD_DIS_FIXEDBUSY;
 102         else
 103                 cmd[6] |= WSPI_INIT_CMD_EN_FIXEDBUSY;
 104
 105         cmd[7] = crc7_be(0, cmd+2, WSPI_INIT_CMD_CRC_LEN) | WSPI_INIT_CMD_END;
 106         /*
 107          * The above is the logical order; it must actually be stored
 108          * in the buffer byte-swapped.
 109          */
 110         __swab32s((u32 *)cmd);
 111         __swab32s((u32 *)cmd+1);
 112
 113         t.tx_buf = cmd;
 114         t.len = WSPI_INIT_CMD_LEN;
 115         spi_message_add_tail(&t, &m);
 116
 117         spi_sync(wl_spi->spi, &m);
 118
 119         wl1251_dump(DEBUG_SPI, "spi init -> ", cmd, WSPI_INIT_CMD_LEN);
 120
 121         kfree(cmd);
 122 }
 123
 124 static void wl1251_spi_reset_wake(struct wl1251 *wl)
 125 {
 126         wl1251_spi_reset(wl);
 127         wl1251_spi_wake(wl);
 128 }
 129
 130 static void wl1251_spi_read(struct wl1251 *wl, int addr, void *buf,
 131                             size_t len)
 132 {
 133         struct wl1251_spi *wl_spi = wl->if_priv;
 134         struct spi_transfer t[3];
 135         struct spi_message m;
 136         u8 *busy_buf;
 137         u32 *cmd;
 138
 139         cmd = &wl->buffer_cmd;
 140         busy_buf = wl->buffer_busyword;
 141
 142         *cmd = 0;
 143         *cmd |= WSPI_CMD_READ;
 144         *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
 145         *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 146
 147         spi_message_init(&m);
 148         memset(t, 0, sizeof(t));
 149
 150         t[0].tx_buf = cmd;
 151         t[0].len = 4;
 152         spi_message_add_tail(&t[0], &m);
 153
 154         /* Busy and non busy words read */
 155         t[1].rx_buf = busy_buf;
 156         t[1].len = WL1251_BUSY_WORD_LEN;
 157         spi_message_add_tail(&t[1], &m);
 158
 159         t[2].rx_buf = buf;
 160         t[2].len = len;
 161         spi_message_add_tail(&t[2], &m);
 162
 163         spi_sync(wl_spi->spi, &m);
 164
 165         /* FIXME: check busy words */
 166
 167         wl1251_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
 168         wl1251_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
 169 }
 170
 171 static void wl1251_spi_write(struct wl1251 *wl, int addr, void *buf,
 172                              size_t len)
 173 {
 174         struct wl1251_spi *wl_spi = wl->if_priv;
 175         struct spi_transfer t[2];
 176         struct spi_message m;
 177         u32 *cmd;
 178
 179         cmd = &wl->buffer_cmd;
 180
 181         *cmd = 0;
 182         *cmd |= WSPI_CMD_WRITE;
 183         *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
 184         *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 185
 186         spi_message_init(&m);
 187         memset(t, 0, sizeof(t));
 188
 189         t[0].tx_buf = cmd;
 190         t[0].len = sizeof(*cmd);
 191         spi_message_add_tail(&t[0], &m);
 192
 193         t[1].tx_buf = buf;
 194         t[1].len = len;
 195         spi_message_add_tail(&t[1], &m);
 196
 197         spi_sync(wl_spi->spi, &m);
 198
 199         wl1251_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
 200         wl1251_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
 201 }
 202
 203 static void wl1251_spi_enable_irq(struct wl1251 *wl)
 204 {
 205         return enable_irq(wl->irq);
 206 }
 207
 208 static void wl1251_spi_disable_irq(struct wl1251 *wl)
 209 {
 210         return disable_irq(wl->irq);
 211 }
 212
 213 static int wl1251_spi_set_power(struct wl1251 *wl, bool enable)
 214 {
 215         struct wl1251_spi *wl_spi = wl->if_priv;
 216
 217         if (wl_spi->power_gpio)
 218                 gpiod_set_value_cansleep(wl_spi->power_gpio, enable);
 219
 220         return 0;
 221 }
 222
 223 static const struct wl1251_if_operations wl1251_spi_ops = {
 224         .read = wl1251_spi_read,
 225         .write = wl1251_spi_write,
 226         .reset = wl1251_spi_reset_wake,
 227         .enable_irq = wl1251_spi_enable_irq,
 228         .disable_irq = wl1251_spi_disable_irq,
 229         .power = wl1251_spi_set_power,
 230 };
 231
 232 static int wl1251_spi_probe(struct spi_device *spi)
 233 {
 234         struct device_node *np = spi->dev.of_node;
 235         struct ieee80211_hw *hw;
 236         struct wl1251_spi *wl_spi;
 237         struct wl1251 *wl;
 238         int ret;
 239
 240         if (!np)
 241                 return -ENODEV;
 242
 243         wl_spi = devm_kzalloc(&spi->dev, sizeof(*wl_spi), GFP_KERNEL);
 244         if (!wl_spi)
 245                 return -ENOMEM;
 246
 247         wl_spi->spi = spi;
 248
 249         hw = wl1251_alloc_hw();
 250         if (IS_ERR(hw))
 251                 return PTR_ERR(hw);
 252
 253         wl = hw->priv;
 254
 255         SET_IEEE80211_DEV(hw, &spi->dev);
 256         spi_set_drvdata(spi, wl);
 257         wl->if_priv = wl_spi;
 258         wl->if_ops = &wl1251_spi_ops;
 259
 260         /* This is the only SPI value that we need to set here, the rest
 261          * comes from the board-peripherals file
 262          */
 263         spi->bits_per_word = 32;
 264
 265         ret = spi_setup(spi);
 266         if (ret < 0) {
 267                 wl1251_error("spi_setup failed");
 268                 goto out_free;
 269         }
 270
 271         wl->use_eeprom = of_property_read_bool(np, "ti,wl1251-has-eeprom");
 272
 273         wl_spi->power_gpio = devm_gpiod_get_optional(&spi->dev, "ti,power",
 274                                                      GPIOD_OUT_LOW);
 275         ret = PTR_ERR_OR_ZERO(wl_spi->power_gpio);
 276         if (ret) {
 277                 if (ret != -EPROBE_DEFER)
 278                         wl1251_error("Failed to request gpio: %d\n", ret);
 279                 goto out_free;
 280         }
 281
 282         gpiod_set_consumer_name(wl_spi->power_gpio, "wl1251 power");
 283
 284         wl->irq = spi->irq;
 285         if (wl->irq < 0) {
 286                 wl1251_error("irq missing in platform data");
 287                 ret = -ENODEV;
 288                 goto out_free;
 289         }
 290
 291         irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
 292         ret = devm_request_irq(&spi->dev, wl->irq, wl1251_irq, 0,
 293                                                         DRIVER_NAME, wl);
 294         if (ret < 0) {
 295                 wl1251_error("request_irq() failed: %d", ret);
 296                 goto out_free;
 297         }
 298
 299         irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
 300
 301         wl->vio = devm_regulator_get(&spi->dev, "vio");
 302         if (IS_ERR(wl->vio)) {
 303                 ret = PTR_ERR(wl->vio);
 304                 wl1251_error("vio regulator missing: %d", ret);
 305                 goto out_free;
 306         }
 307
 308         ret = regulator_enable(wl->vio);
 309         if (ret)
 310                 goto out_free;
 311
 312         ret = wl1251_init_ieee80211(wl);
 313         if (ret)
 314                 goto disable_regulator;
 315
 316         return 0;
 317
 318 disable_regulator:
 319         regulator_disable(wl->vio);
 320 out_free:
 321         ieee80211_free_hw(hw);
 322
 323         return ret;
 324 }
 325
 326 static void wl1251_spi_remove(struct spi_device *spi)
 327 {
 328         struct wl1251 *wl = spi_get_drvdata(spi);
 329
 330         wl1251_free_hw(wl);
 331         regulator_disable(wl->vio);
 332 }
 333
 334 static struct spi_driver wl1251_spi_driver = {
 335         .driver = {
 336                 .name           = DRIVER_NAME,
 337         },
 338
 339         .probe          = wl1251_spi_probe,
 340         .remove         = wl1251_spi_remove,
 341 };
 342
 343 module_spi_driver(wl1251_spi_driver);
 344
 345 MODULE_LICENSE("GPL");
 346 MODULE_AUTHOR("Kalle Valo <[email protected]>");
 347 MODULE_ALIAS("spi:wl1251");