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

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