cw1200: Prevent a lock-related hang in the cw1200_spi driver
[opensuse:kernel.git] / drivers / net / wireless / cw1200 / cw1200_spi.c
1 /*
2  * Mac80211 SPI driver for ST-Ericsson CW1200 device
3  *
4  * Copyright (c) 2011, Sagrad Inc.
5  * Author:  Solomon Peachy <speachy@sagrad.com>
6  *
7  * Based on cw1200_sdio.c
8  * Copyright (c) 2010, ST-Ericsson
9  * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
10  *
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.
14  */
15
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>
22
23 #include <linux/spi/spi.h>
24 #include <linux/device.h>
25
26 #include "cw1200.h"
27 #include "hwbus.h"
28 #include <linux/platform_data/net-cw1200.h>
29 #include "hwio.h"
30
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");
35
36 /* #define SPI_DEBUG */
37
38 struct hwbus_priv {
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 */
43         wait_queue_head_t       wq;
44         int claimed;
45 };
46
47 #define SDIO_TO_SPI_ADDR(addr) ((addr & 0x1f)>>2)
48 #define SET_WRITE 0x7FFF /* usage: and operation */
49 #define SET_READ 0x8000  /* usage: or operation */
50
51 /* Notes on byte ordering:
52    LE:  B0 B1 B2 B3
53    BE:  B3 B2 B1 B0
54
55    Hardware expects 32-bit data to be written as 16-bit BE words:
56
57    B1 B0 B3 B2
58 */
59
60 static int cw1200_spi_memcpy_fromio(struct hwbus_priv *self,
61                                      unsigned int addr,
62                                      void *dst, int count)
63 {
64         int ret, i;
65         u16 regaddr;
66         struct spi_message      m;
67
68         struct spi_transfer     t_addr = {
69                 .tx_buf         = &regaddr,
70                 .len            = sizeof(regaddr),
71         };
72         struct spi_transfer     t_msg = {
73                 .rx_buf         = dst,
74                 .len            = count,
75         };
76
77         regaddr = (SDIO_TO_SPI_ADDR(addr))<<12;
78         regaddr |= SET_READ;
79         regaddr |= (count>>1);
80
81 #ifdef SPI_DEBUG
82         pr_info("READ : %04d from 0x%02x (%04x)\n", count, addr, regaddr);
83 #endif
84
85         /* Header is LE16 */
86         regaddr = cpu_to_le16(regaddr);
87
88         /* We have to byteswap if the SPI bus is limited to 8b operation
89            or we are running on a Big Endian system
90         */
91 #if defined(__LITTLE_ENDIAN)
92         if (self->func->bits_per_word == 8)
93 #endif
94                 regaddr = swab16(regaddr);
95
96         spi_message_init(&m);
97         spi_message_add_tail(&t_addr, &m);
98         spi_message_add_tail(&t_msg, &m);
99         ret = spi_sync(self->func, &m);
100
101 #ifdef SPI_DEBUG
102         pr_info("READ : ");
103         for (i = 0; i < t_addr.len; i++)
104                 printk("%02x ", ((u8 *)t_addr.tx_buf)[i]);
105         printk(" : ");
106         for (i = 0; i < t_msg.len; i++)
107                 printk("%02x ", ((u8 *)t_msg.rx_buf)[i]);
108         printk("\n");
109 #endif
110
111         /* We have to byteswap if the SPI bus is limited to 8b operation
112            or we are running on a Big Endian system
113         */
114 #if defined(__LITTLE_ENDIAN)
115         if (self->func->bits_per_word == 8)
116 #endif
117         {
118                 uint16_t *buf = (uint16_t *)dst;
119                 for (i = 0; i < ((count + 1) >> 1); i++)
120                         buf[i] = swab16(buf[i]);
121         }
122
123         return ret;
124 }
125
126 static int cw1200_spi_memcpy_toio(struct hwbus_priv *self,
127                                    unsigned int addr,
128                                    const void *src, int count)
129 {
130         int rval, i;
131         u16 regaddr;
132         struct spi_transfer     t_addr = {
133                 .tx_buf         = &regaddr,
134                 .len            = sizeof(regaddr),
135         };
136         struct spi_transfer     t_msg = {
137                 .tx_buf         = src,
138                 .len            = count,
139         };
140         struct spi_message      m;
141
142         regaddr = (SDIO_TO_SPI_ADDR(addr))<<12;
143         regaddr &= SET_WRITE;
144         regaddr |= (count>>1);
145
146 #ifdef SPI_DEBUG
147         pr_info("WRITE: %04d  to  0x%02x (%04x)\n", count, addr, regaddr);
148 #endif
149
150         /* Header is LE16 */
151         regaddr = cpu_to_le16(regaddr);
152
153         /* We have to byteswap if the SPI bus is limited to 8b operation
154            or we are running on a Big Endian system
155         */
156 #if defined(__LITTLE_ENDIAN)
157         if (self->func->bits_per_word == 8)
158 #endif
159         {
160                 uint16_t *buf = (uint16_t *)src;
161                 regaddr = swab16(regaddr);
162                 for (i = 0; i < ((count + 1) >> 1); i++)
163                         buf[i] = swab16(buf[i]);
164         }
165
166 #ifdef SPI_DEBUG
167         pr_info("WRITE: ");
168         for (i = 0; i < t_addr.len; i++)
169                 printk("%02x ", ((u8 *)t_addr.tx_buf)[i]);
170         printk(" : ");
171         for (i = 0; i < t_msg.len; i++)
172                 printk("%02x ", ((u8 *)t_msg.tx_buf)[i]);
173         printk("\n");
174 #endif
175
176         spi_message_init(&m);
177         spi_message_add_tail(&t_addr, &m);
178         spi_message_add_tail(&t_msg, &m);
179         rval = spi_sync(self->func, &m);
180
181 #ifdef SPI_DEBUG
182         pr_info("WROTE: %d\n", m.actual_length);
183 #endif
184
185 #if defined(__LITTLE_ENDIAN)
186         /* We have to byteswap if the SPI bus is limited to 8b operation */
187         if (self->func->bits_per_word == 8)
188 #endif
189         {
190                 uint16_t *buf = (uint16_t *)src;
191                 for (i = 0; i < ((count + 1) >> 1); i++)
192                         buf[i] = swab16(buf[i]);
193         }
194         return rval;
195 }
196
197 static void cw1200_spi_lock(struct hwbus_priv *self)
198 {
199         unsigned long flags;
200
201         DECLARE_WAITQUEUE(wait, current);
202
203         might_sleep();
204
205         add_wait_queue(&self->wq, &wait);
206         spin_lock_irqsave(&self->lock, flags);
207         while (1) {
208                 set_current_state(TASK_UNINTERRUPTIBLE);
209                 if (!self->claimed)
210                         break;
211                 spin_unlock_irqrestore(&self->lock, flags);
212                 schedule();
213                 spin_lock_irqsave(&self->lock, flags);
214         }
215         set_current_state(TASK_RUNNING);
216         self->claimed = 1;
217         spin_unlock_irqrestore(&self->lock, flags);
218         remove_wait_queue(&self->wq, &wait);
219
220         return;
221 }
222
223 static void cw1200_spi_unlock(struct hwbus_priv *self)
224 {
225         unsigned long flags;
226
227         spin_lock_irqsave(&self->lock, flags);
228         self->claimed = 0;
229         spin_unlock_irqrestore(&self->lock, flags);
230         wake_up(&self->wq);
231
232         return;
233 }
234
235 static irqreturn_t cw1200_spi_irq_handler(int irq, void *dev_id)
236 {
237         struct hwbus_priv *self = dev_id;
238
239         if (self->core) {
240                 cw1200_irq_handler(self->core);
241                 return IRQ_HANDLED;
242         } else {
243                 return IRQ_NONE;
244         }
245 }
246
247 static int cw1200_spi_irq_subscribe(struct hwbus_priv *self)
248 {
249         int ret;
250
251         pr_debug("SW IRQ subscribe\n");
252
253         ret = request_any_context_irq(self->func->irq, cw1200_spi_irq_handler,
254                                       IRQF_TRIGGER_HIGH,
255                                       "cw1200_wlan_irq", self);
256         if (WARN_ON(ret < 0))
257                 goto exit;
258
259         ret = enable_irq_wake(self->func->irq);
260         if (WARN_ON(ret))
261                 goto free_irq;
262
263         return 0;
264
265 free_irq:
266         free_irq(self->func->irq, self);
267 exit:
268         return ret;
269 }
270
271 static int cw1200_spi_irq_unsubscribe(struct hwbus_priv *self)
272 {
273         int ret = 0;
274
275         pr_debug("SW IRQ unsubscribe\n");
276         disable_irq_wake(self->func->irq);
277         free_irq(self->func->irq, self);
278
279         return ret;
280 }
281
282 static int cw1200_spi_off(const struct cw1200_platform_data_spi *pdata)
283 {
284         if (pdata->reset) {
285                 gpio_set_value(pdata->reset, 0);
286                 msleep(30); /* Min is 2 * CLK32K cycles */
287                 gpio_free(pdata->reset);
288         }
289
290         if (pdata->power_ctrl)
291                 pdata->power_ctrl(pdata, false);
292         if (pdata->clk_ctrl)
293                 pdata->clk_ctrl(pdata, false);
294
295         return 0;
296 }
297
298 static int cw1200_spi_on(const struct cw1200_platform_data_spi *pdata)
299 {
300         /* Ensure I/Os are pulled low */
301         if (pdata->reset) {
302                 gpio_request(pdata->reset, "cw1200_wlan_reset");
303                 gpio_direction_output(pdata->reset, 0);
304         }
305         if (pdata->powerup) {
306                 gpio_request(pdata->powerup, "cw1200_wlan_powerup");
307                 gpio_direction_output(pdata->powerup, 0);
308         }
309         if (pdata->reset || pdata->powerup)
310                 msleep(10); /* Settle time? */
311
312         /* Enable 3v3 and 1v8 to hardware */
313         if (pdata->power_ctrl) {
314                 if (pdata->power_ctrl(pdata, true)) {
315                         pr_err("power_ctrl() failed!\n");
316                         return -1;
317                 }
318         }
319
320         /* Enable CLK32K */
321         if (pdata->clk_ctrl) {
322                 if (pdata->clk_ctrl(pdata, true)) {
323                         pr_err("clk_ctrl() failed!\n");
324                         return -1;
325                 }
326                 msleep(10); /* Delay until clock is stable for 2 cycles */
327         }
328
329         /* Enable POWERUP signal */
330         if (pdata->powerup) {
331                 gpio_set_value(pdata->powerup, 1);
332                 msleep(250); /* or more..? */
333         }
334         /* Enable RSTn signal */
335         if (pdata->reset) {
336                 gpio_set_value(pdata->reset, 1);
337                 msleep(50); /* Or more..? */
338         }
339         return 0;
340 }
341
342 static size_t cw1200_spi_align_size(struct hwbus_priv *self, size_t size)
343 {
344         return size & 1 ? size + 1 : size;
345 }
346
347 static int cw1200_spi_pm(struct hwbus_priv *self, bool suspend)
348 {
349         return irq_set_irq_wake(self->func->irq, suspend);
350 }
351
352 static struct hwbus_ops cw1200_spi_hwbus_ops = {
353         .hwbus_memcpy_fromio    = cw1200_spi_memcpy_fromio,
354         .hwbus_memcpy_toio      = cw1200_spi_memcpy_toio,
355         .lock                   = cw1200_spi_lock,
356         .unlock                 = cw1200_spi_unlock,
357         .align_size             = cw1200_spi_align_size,
358         .power_mgmt             = cw1200_spi_pm,
359 };
360
361 /* Probe Function to be called by SPI stack when device is discovered */
362 static int cw1200_spi_probe(struct spi_device *func)
363 {
364         const struct cw1200_platform_data_spi *plat_data =
365                 func->dev.platform_data;
366         struct hwbus_priv *self;
367         int status;
368
369         /* Sanity check speed */
370         if (func->max_speed_hz > 52000000)
371                 func->max_speed_hz = 52000000;
372         if (func->max_speed_hz < 1000000)
373                 func->max_speed_hz = 1000000;
374
375         /* Fix up transfer size */
376         if (plat_data->spi_bits_per_word)
377                 func->bits_per_word = plat_data->spi_bits_per_word;
378         if (!func->bits_per_word)
379                 func->bits_per_word = 16;
380
381         /* And finally.. */
382         func->mode = SPI_MODE_0;
383
384         pr_info("cw1200_wlan_spi: Probe called (CS %d M %d BPW %d CLK %d)\n",
385                 func->chip_select, func->mode, func->bits_per_word,
386                 func->max_speed_hz);
387
388         if (cw1200_spi_on(plat_data)) {
389                 pr_err("spi_on() failed!\n");
390                 return -1;
391         }
392
393         if (spi_setup(func)) {
394                 pr_err("spi_setup() failed!\n");
395                 return -1;
396         }
397
398         self = kzalloc(sizeof(*self), GFP_KERNEL);
399         if (!self) {
400                 pr_err("Can't allocate SPI hwbus_priv.");
401                 return -ENOMEM;
402         }
403
404         self->pdata = plat_data;
405         self->func = func;
406         spin_lock_init(&self->lock);
407
408         spi_set_drvdata(func, self);
409
410         init_waitqueue_head(&self->wq);
411
412         status = cw1200_spi_irq_subscribe(self);
413
414         status = cw1200_core_probe(&cw1200_spi_hwbus_ops,
415                                    self, &func->dev, &self->core,
416                                    self->pdata->ref_clk,
417                                    self->pdata->macaddr,
418                                    self->pdata->sdd_file,
419                                    self->pdata->have_5ghz);
420
421         if (status) {
422                 cw1200_spi_irq_unsubscribe(self);
423                 cw1200_spi_off(plat_data);
424                 kfree(self);
425         }
426
427         return status;
428 }
429
430 /* Disconnect Function to be called by SPI stack when device is disconnected */
431 static int cw1200_spi_disconnect(struct spi_device *func)
432 {
433         struct hwbus_priv *self = spi_get_drvdata(func);
434
435         if (self) {
436                 cw1200_spi_irq_unsubscribe(self);
437                 if (self->core) {
438                         cw1200_core_release(self->core);
439                         self->core = NULL;
440                 }
441                 kfree(self);
442         }
443         cw1200_spi_off(func->dev.platform_data);
444
445         return 0;
446 }
447
448 #ifdef CONFIG_PM
449 static int cw1200_spi_suspend(struct device *dev, pm_message_t state)
450 {
451         struct hwbus_priv *self = spi_get_drvdata(to_spi_device(dev));
452
453         if (!cw1200_can_suspend(self->core))
454                 return -EAGAIN;
455
456         /* XXX notify host that we have to keep CW1200 powered on? */
457         return 0;
458 }
459
460 static int cw1200_spi_resume(struct device *dev)
461 {
462         return 0;
463 }
464 #endif
465
466 static struct spi_driver spi_driver = {
467         .probe          = cw1200_spi_probe,
468         .remove         = cw1200_spi_disconnect,
469         .driver = {
470                 .name           = "cw1200_wlan_spi",
471                 .bus            = &spi_bus_type,
472                 .owner          = THIS_MODULE,
473 #ifdef CONFIG_PM
474                 .suspend        = cw1200_spi_suspend,
475                 .resume         = cw1200_spi_resume,
476 #endif
477         },
478 };
479
480 module_spi_driver(spi_driver);