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"); 372