Changeset 42491


Ignore:
Timestamp:
2014-09-12T08:52:00+02:00 (3 years ago)
Author:
blogic
Message:

atheros: ar2315-spiflash: use mutex inplace of spinlock

Use mutex inplace of spinlock to make code simple, also call
mutex_{lock,unlock} explicitly to avoid sparse warning about context
imbalance.

Signed-off-by: Sergey Ryazanov <ryazanov.s.a@…>

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/atheros/patches-3.14/120-spiflash.patch

    r42490 r42491  
    2424--- /dev/null 
    2525+++ b/drivers/mtd/devices/ar2315.c 
    26 @@ -0,0 +1,507 @@ 
     26@@ -0,0 +1,461 @@ 
    2727+ 
    2828+/* 
     
    5454+#include <linux/delay.h> 
    5555+#include <linux/io.h> 
     56+#include <linux/mutex.h> 
    5657+ 
    5758+#include "ar2315_spiflash.h" 
     
    6162+#define busy_wait(_priv, _condition, _wait) do { \ 
    6263+       while (_condition) { \ 
    63 +               spin_unlock_bh(&_priv->lock); \ 
    6464+               if (_wait > 1) \ 
    6565+                       msleep(_wait); \ 
     
    6868+               else \ 
    6969+                       udelay(1); \ 
    70 +               spin_lock_bh(&_priv->lock); \ 
    7170+       } \ 
    7271+} while (0) 
     
    142141+       void __iomem *readaddr; /* memory mapped data for read  */ 
    143142+       void __iomem *mmraddr;  /* memory mapped register space */ 
    144 +       wait_queue_head_t wq; 
    145 +       spinlock_t lock; 
    146 +       int state; 
     143+       struct mutex lock;      /* serialize registers access */ 
    147144+}; 
    148145+ 
     
    220217+       return reg; 
    221218+} 
    222 + 
    223219+ 
    224220+/* 
     
    230226+spiflash_probe_chip(struct platform_device *pdev, struct spiflash_priv *priv) 
    231227+{ 
    232 +       u32 sig; 
     228+       u32 sig = spiflash_sendcmd(priv, SPI_RD_SIG, 0); 
    233229+       int flash_size; 
    234 + 
    235 +       /* Read the signature on the flash device */ 
    236 +       spin_lock_bh(&priv->lock); 
    237 +       sig = spiflash_sendcmd(priv, SPI_RD_SIG, 0); 
    238 +       spin_unlock_bh(&priv->lock); 
    239230+ 
    240231+       switch (sig) { 
     
    262253+} 
    263254+ 
    264 + 
    265 +/* wait until the flash chip is ready and grab a lock */ 
    266 +static int spiflash_wait_ready(struct spiflash_priv *priv, int state) 
    267 +{ 
    268 +       DECLARE_WAITQUEUE(wait, current); 
    269 + 
    270 +retry: 
    271 +       spin_lock_bh(&priv->lock); 
    272 +       if (priv->state != FL_READY) { 
    273 +               set_current_state(TASK_UNINTERRUPTIBLE); 
    274 +               add_wait_queue(&priv->wq, &wait); 
    275 +               spin_unlock_bh(&priv->lock); 
    276 +               schedule(); 
    277 +               remove_wait_queue(&priv->wq, &wait); 
    278 + 
    279 +               if (signal_pending(current)) 
    280 +                       return 0; 
    281 + 
    282 +               goto retry; 
    283 +       } 
    284 +       priv->state = state; 
    285 + 
    286 +       return 1; 
    287 +} 
    288 + 
    289 +static inline void spiflash_done(struct spiflash_priv *priv) 
    290 +{ 
    291 +       priv->state = FL_READY; 
    292 +       spin_unlock_bh(&priv->lock); 
    293 +       wake_up(&priv->wq); 
    294 +} 
    295 + 
    296255+static void 
    297256+spiflash_wait_complete(struct spiflash_priv *priv, unsigned int timeout) 
     
    299258+       busy_wait(priv, spiflash_sendcmd(priv, SPI_RD_STATUS, 0) & 
    300259+               SPI_STATUS_WIP, timeout); 
    301 +       spiflash_done(priv); 
    302 +} 
    303 + 
    304 + 
     260+} 
    305261+ 
    306262+static int 
     
    314270+               return -EINVAL; 
    315271+ 
    316 +       if (!spiflash_wait_ready(priv, FL_ERASING)) 
    317 +               return -EINTR; 
     272+       mutex_lock(&priv->lock); 
    318273+ 
    319274+       spiflash_sendcmd(priv, SPI_WRITE_ENABLE, 0); 
     
    330285+       spiflash_wait_complete(priv, 20); 
    331286+ 
     287+       mutex_unlock(&priv->lock); 
     288+ 
    332289+       instr->state = MTD_ERASE_DONE; 
    333290+       mtd_erase_callback(instr); 
     
    350307+       *retlen = len; 
    351308+ 
    352 +       if (!spiflash_wait_ready(priv, FL_READING)) 
    353 +               return -EINTR; 
     309+       mutex_lock(&priv->lock); 
    354310+ 
    355311+       memcpy_fromio(buf, priv->readaddr + from, len); 
    356 +       spiflash_done(priv); 
     312+ 
     313+       mutex_unlock(&priv->lock); 
    357314+ 
    358315+       return 0; 
     
    392349+                       read_len -= (page_offset - STM_PAGE_SIZE); 
    393350+ 
    394 +               if (!spiflash_wait_ready(priv, FL_WRITING)) 
    395 +                       return -EINTR; 
     351+               mutex_lock(&priv->lock); 
    396352+ 
    397353+               spiflash_sendcmd(priv, SPI_WRITE_ENABLE, 0); 
     
    426382+               spiflash_wait_complete(priv, 1); 
    427383+ 
     384+               mutex_unlock(&priv->lock); 
     385+ 
    428386+               bytes_left -= read_len; 
    429387+               to += read_len; 
     
    436394+} 
    437395+ 
    438 + 
    439396+#if defined CONFIG_MTD_REDBOOT_PARTS || CONFIG_MTD_MYLOADER_PARTS 
    440397+static const char * const part_probe_types[] = { 
     
    442399+}; 
    443400+#endif 
    444 + 
    445401+ 
    446402+static int 
     
    457413+               return -ENOMEM; 
    458414+ 
    459 +       spin_lock_init(&priv->lock); 
    460 +       init_waitqueue_head(&priv->wq); 
    461 +       priv->state = FL_READY; 
     415+       mutex_init(&priv->lock); 
    462416+       mtd = &priv->mtd; 
    463417+ 
Note: See TracChangeset for help on using the changeset viewer.