2 * Mac80211 SPI driver for ST-Ericsson CW1200 device
4 * Copyright (c) 2011, Sagrad Inc.
5 * Author: Solomon Peachy <speachy@sagrad.com>
7 * Based on cw1200_sdio.c
8 * Copyright (c) 2010, ST-Ericsson
9 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include <linux/module.h>
17 #include <linux/gpio.h>
18 #include <linux/delay.h>
19 #include <linux/spinlock.h>
20 #include <linux/interrupt.h>
21 #include <net/mac80211.h>
23 #include <linux/spi/spi.h>
24 #include <linux/device.h>
28 #include <linux/platform_data/net-cw1200.h>
31 MODULE_AUTHOR("Solomon Peachy <speachy@sagrad.com>");
32 MODULE_DESCRIPTION("mac80211 ST-Ericsson CW1200 SPI driver");
33 MODULE_LICENSE("GPL");
34 MODULE_ALIAS("spi:cw1200_wlan_spi");
36 /* #define SPI_DEBUG */
39 struct spi_device *func;
40 struct cw1200_common *core;
41 const struct cw1200_platform_data_spi *pdata;
42 spinlock_t lock; /* Serialize all bus operations */
46 #define SDIO_TO_SPI_ADDR(addr) ((addr & 0x1f)>>2)
47 #define SET_WRITE 0x7FFF /* usage: and operation */
48 #define SET_READ 0x8000 /* usage: or operation */
50 /* Notes on byte ordering:
54 Hardware expects 32-bit data to be written as 16-bit BE words:
59 static int cw1200_spi_memcpy_fromio(struct hwbus_priv *self,
67 struct spi_transfer t_addr = {
69 .len = sizeof(regaddr),
71 struct spi_transfer t_msg = {
76 regaddr = (SDIO_TO_SPI_ADDR(addr))<<12;
78 regaddr |= (count>>1);
81 pr_info("READ : %04d from 0x%02x (%04x)\n", count, addr, regaddr);
85 regaddr = cpu_to_le16(regaddr);
87 /* We have to byteswap if the SPI bus is limited to 8b operation
88 or we are running on a Big Endian system
90 #if defined(__LITTLE_ENDIAN)
91 if (self->func->bits_per_word == 8)
93 regaddr = swab16(regaddr);
96 spi_message_add_tail(&t_addr, &m);
97 spi_message_add_tail(&t_msg, &m);
98 ret = spi_sync(self->func, &m);
102 for (i = 0; i < t_addr.len; i++)
103 printk("%02x ", ((u8 *)t_addr.tx_buf)[i]);
105 for (i = 0; i < t_msg.len; i++)
106 printk("%02x ", ((u8 *)t_msg.rx_buf)[i]);
110 /* We have to byteswap if the SPI bus is limited to 8b operation
111 or we are running on a Big Endian system
113 #if defined(__LITTLE_ENDIAN)
114 if (self->func->bits_per_word == 8)
117 uint16_t *buf = (uint16_t *)dst;
118 for (i = 0; i < ((count + 1) >> 1); i++)
119 buf[i] = swab16(buf[i]);
125 static int cw1200_spi_memcpy_toio(struct hwbus_priv *self,
127 const void *src, int count)
131 struct spi_transfer t_addr = {
133 .len = sizeof(regaddr),
135 struct spi_transfer t_msg = {
139 struct spi_message m;
141 regaddr = (SDIO_TO_SPI_ADDR(addr))<<12;
142 regaddr &= SET_WRITE;
143 regaddr |= (count>>1);
146 pr_info("WRITE: %04d to 0x%02x (%04x)\n", count, addr, regaddr);
150 regaddr = cpu_to_le16(regaddr);
152 /* We have to byteswap if the SPI bus is limited to 8b operation
153 or we are running on a Big Endian system
155 #if defined(__LITTLE_ENDIAN)
156 if (self->func->bits_per_word == 8)
159 uint16_t *buf = (uint16_t *)src;
160 regaddr = swab16(regaddr);
161 for (i = 0; i < ((count + 1) >> 1); i++)
162 buf[i] = swab16(buf[i]);
167 for (i = 0; i < t_addr.len; i++)
168 printk("%02x ", ((u8 *)t_addr.tx_buf)[i]);
170 for (i = 0; i < t_msg.len; i++)
171 printk("%02x ", ((u8 *)t_msg.tx_buf)[i]);
175 spi_message_init(&m);
176 spi_message_add_tail(&t_addr, &m);
177 spi_message_add_tail(&t_msg, &m);
178 rval = spi_sync(self->func, &m);
181 pr_info("WROTE: %d\n", m.actual_length);
184 #if defined(__LITTLE_ENDIAN)
185 /* We have to byteswap if the SPI bus is limited to 8b operation */
186 if (self->func->bits_per_word == 8)
189 uint16_t *buf = (uint16_t *)src;
190 for (i = 0; i < ((count + 1) >> 1); i++)
191 buf[i] = swab16(buf[i]);
196 static void cw1200_spi_lock(struct hwbus_priv *self)
202 spin_lock_irqsave(&self->lock, flags);
204 set_current_state(TASK_UNINTERRUPTIBLE);
207 spin_unlock_irqrestore(&self->lock, flags);
209 spin_lock_irqsave(&self->lock, flags);
211 set_current_state(TASK_RUNNING);
213 spin_unlock_irqrestore(&self->lock, flags);
218 static void cw1200_spi_unlock(struct hwbus_priv *self)
222 spin_lock_irqsave(&self->lock, flags);
224 spin_unlock_irqrestore(&self->lock, flags);
228 static irqreturn_t cw1200_spi_irq_handler(int irq, void *dev_id)
230 struct hwbus_priv *self = dev_id;
233 cw1200_irq_handler(self->core);
240 static int cw1200_spi_irq_subscribe(struct hwbus_priv *self)
244 pr_debug("SW IRQ subscribe\n");
246 ret = request_any_context_irq(self->func->irq, cw1200_spi_irq_handler,
248 "cw1200_wlan_irq", self);
249 if (WARN_ON(ret < 0))
252 ret = enable_irq_wake(self->func->irq);
259 free_irq(self->func->irq, self);
264 static int cw1200_spi_irq_unsubscribe(struct hwbus_priv *self)
268 pr_debug("SW IRQ unsubscribe\n");
269 disable_irq_wake(self->func->irq);
270 free_irq(self->func->irq, self);
275 static int cw1200_spi_off(const struct cw1200_platform_data_spi *pdata)
278 gpio_set_value(pdata->reset, 0);
279 msleep(30); /* Min is 2 * CLK32K cycles */
280 gpio_free(pdata->reset);
283 if (pdata->power_ctrl)
284 pdata->power_ctrl(pdata, false);
286 pdata->clk_ctrl(pdata, false);
291 static int cw1200_spi_on(const struct cw1200_platform_data_spi *pdata)
293 /* Ensure I/Os are pulled low */
295 gpio_request(pdata->reset, "cw1200_wlan_reset");
296 gpio_direction_output(pdata->reset, 0);
298 if (pdata->powerup) {
299 gpio_request(pdata->powerup, "cw1200_wlan_powerup");
300 gpio_direction_output(pdata->powerup, 0);
302 if (pdata->reset || pdata->powerup)
303 msleep(10); /* Settle time? */
305 /* Enable 3v3 and 1v8 to hardware */
306 if (pdata->power_ctrl) {
307 if (pdata->power_ctrl(pdata, true)) {
308 pr_err("power_ctrl() failed!\n");
314 if (pdata->clk_ctrl) {
315 if (pdata->clk_ctrl(pdata, true)) {
316 pr_err("clk_ctrl() failed!\n");
319 msleep(10); /* Delay until clock is stable for 2 cycles */
322 /* Enable POWERUP signal */
323 if (pdata->powerup) {
324 gpio_set_value(pdata->powerup, 1);
325 msleep(250); /* or more..? */
327 /* Enable RSTn signal */
329 gpio_set_value(pdata->reset, 1);
330 msleep(50); /* Or more..? */
335 static size_t cw1200_spi_align_size(struct hwbus_priv *self, size_t size)
337 return size & 1 ? size + 1 : size;
340 static int cw1200_spi_pm(struct hwbus_priv *self, bool suspend)
342 return irq_set_irq_wake(self->func->irq, suspend);
345 static struct hwbus_ops cw1200_spi_hwbus_ops = {
346 .hwbus_memcpy_fromio = cw1200_spi_memcpy_fromio,
347 .hwbus_memcpy_toio = cw1200_spi_memcpy_toio,
348 .lock = cw1200_spi_lock,
349 .unlock = cw1200_spi_unlock,
350 .align_size = cw1200_spi_align_size,
351 .power_mgmt = cw1200_spi_pm,
354 /* Probe Function to be called by SPI stack when device is discovered */
355 static int cw1200_spi_probe(struct spi_device *func)
357 const struct cw1200_platform_data_spi *plat_data =
358 func->dev.platform_data;
359 struct hwbus_priv *self;
362 /* Sanity check speed */
363 if (func->max_speed_hz > 52000000)
364 func->max_speed_hz = 52000000;
365 if (func->max_speed_hz < 1000000)
366 func->max_speed_hz = 1000000;
368 /* Fix up transfer size */
369 if (plat_data->spi_bits_per_word)
370 func->bits_per_word = plat_data->spi_bits_per_word;
371 if (!func->bits_per_word)
372 func->bits_per_word = 16;
375 func->mode = SPI_MODE_0;
377 pr_info("cw1200_wlan_spi: Probe called (CS %d M %d BPW %d CLK %d)\n",
378 func->chip_select, func->mode, func->bits_per_word,
381 if (cw1200_spi_on(plat_data)) {
382 pr_err("spi_on() failed!\n");
386 if (spi_setup(func)) {
387 pr_err("spi_setup() failed!\n");
391 self = kzalloc(sizeof(*self), GFP_KERNEL);
393 pr_err("Can't allocate SPI hwbus_priv.");
397 self->pdata = plat_data;
399 spin_lock_init(&self->lock);
401 spi_set_drvdata(func, self);
403 status = cw1200_spi_irq_subscribe(self);
405 status = cw1200_core_probe(&cw1200_spi_hwbus_ops,
406 self, &func->dev, &self->core,
407 self->pdata->ref_clk,
408 self->pdata->macaddr,
409 self->pdata->sdd_file,
410 self->pdata->have_5ghz);
413 cw1200_spi_irq_unsubscribe(self);
414 cw1200_spi_off(plat_data);
421 /* Disconnect Function to be called by SPI stack when device is disconnected */
422 static int cw1200_spi_disconnect(struct spi_device *func)
424 struct hwbus_priv *self = spi_get_drvdata(func);
427 cw1200_spi_irq_unsubscribe(self);
429 cw1200_core_release(self->core);
434 cw1200_spi_off(func->dev.platform_data);
440 static int cw1200_spi_suspend(struct device *dev, pm_message_t state)
442 struct hwbus_priv *self = spi_get_drvdata(to_spi_device(dev));
444 if (!cw1200_can_suspend(self->core))
447 /* XXX notify host that we have to keep CW1200 powered on? */
451 static int cw1200_spi_resume(struct device *dev)
457 static struct spi_driver spi_driver = {
458 .probe = cw1200_spi_probe,
459 .remove = cw1200_spi_disconnect,
461 .name = "cw1200_wlan_spi",
462 .bus = &spi_bus_type,
463 .owner = THIS_MODULE,
465 .suspend = cw1200_spi_suspend,
466 .resume = cw1200_spi_resume,
471 module_spi_driver(spi_driver);