LXR linux/drivers/net/sfc/mtd.c

   1/****************************************************************************
   2 * Driver for Solarflare Solarstorm network controllers and boards
   3 * Copyright 2005-2006 Fen Systems Ltd.
   4 * Copyright 2006-2008 Solarflare Communications Inc.
   5 *
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms of the GNU General Public License version 2 as published
   8 * by the Free Software Foundation, incorporated herein by reference.
   9 */
  10
  11#include <linux/module.h>
  12#include <linux/mtd/mtd.h>
  13#include <linux/delay.h>
  14
  15#define EFX_DRIVER_NAME "sfc_mtd"
  16#include "net_driver.h"
  17#include "spi.h"
  18#include "efx.h"
  19
  20#define EFX_SPI_VERIFY_BUF_LEN 16
  21
  22struct efx_mtd {
  23        const struct efx_spi_device *spi;
  24        struct mtd_info mtd;
  25        char name[IFNAMSIZ + 20];
  26};
  27
  28/* SPI utilities */
  29
  30static int efx_spi_slow_wait(struct efx_mtd *efx_mtd, bool uninterruptible)
  31{
  32        const struct efx_spi_device *spi = efx_mtd->spi;
  33        struct efx_nic *efx = spi->efx;
  34        u8 status;
  35        int rc, i;
  36
  37        /* Wait up to 4s for flash/EEPROM to finish a slow operation. */
  38        for (i = 0; i < 40; i++) {
  39                __set_current_state(uninterruptible ?
  40                                    TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
  41                schedule_timeout(HZ / 10);
  42                rc = falcon_spi_cmd(spi, SPI_RDSR, -1, NULL,
  43                                    &status, sizeof(status));
  44                if (rc)
  45                        return rc;
  46                if (!(status & SPI_STATUS_NRDY))
  47                        return 0;
  48                if (signal_pending(current))
  49                        return -EINTR;
  50        }
  51        EFX_ERR(efx, "timed out waiting for %s\n", efx_mtd->name);
  52        return -ETIMEDOUT;
  53}
  54
  55static int efx_spi_unlock(const struct efx_spi_device *spi)
  56{
  57        const u8 unlock_mask = (SPI_STATUS_BP2 | SPI_STATUS_BP1 |
  58                                SPI_STATUS_BP0);
  59        u8 status;
  60        int rc;
  61
  62        rc = falcon_spi_cmd(spi, SPI_RDSR, -1, NULL, &status, sizeof(status));
  63        if (rc)
  64                return rc;
  65
  66        if (!(status & unlock_mask))
  67                return 0; /* already unlocked */
  68
  69        rc = falcon_spi_cmd(spi, SPI_WREN, -1, NULL, NULL, 0);
  70        if (rc)
  71                return rc;
  72        rc = falcon_spi_cmd(spi, SPI_SST_EWSR, -1, NULL, NULL, 0);
  73        if (rc)
  74                return rc;
  75
  76        status &= ~unlock_mask;
  77        rc = falcon_spi_cmd(spi, SPI_WRSR, -1, &status, NULL, sizeof(status));
  78        if (rc)
  79                return rc;
  80        rc = falcon_spi_wait_write(spi);
  81        if (rc)
  82                return rc;
  83
  84        return 0;
  85}
  86
  87static int efx_spi_erase(struct efx_mtd *efx_mtd, loff_t start, size_t len)
  88{
  89        const struct efx_spi_device *spi = efx_mtd->spi;
  90        unsigned pos, block_len;
  91        u8 empty[EFX_SPI_VERIFY_BUF_LEN];
  92        u8 buffer[EFX_SPI_VERIFY_BUF_LEN];
  93        int rc;
  94
  95        if (len != spi->erase_size)
  96                return -EINVAL;
  97
  98        if (spi->erase_command == 0)
  99                return -EOPNOTSUPP;
 100
 101        rc = efx_spi_unlock(spi);
 102        if (rc)
 103                return rc;
 104        rc = falcon_spi_cmd(spi, SPI_WREN, -1, NULL, NULL, 0);
 105        if (rc)
 106                return rc;
 107        rc = falcon_spi_cmd(spi, spi->erase_command, start, NULL, NULL, 0);
 108        if (rc)
 109                return rc;
 110        rc = efx_spi_slow_wait(efx_mtd, false);
 111
 112        /* Verify the entire region has been wiped */
 113        memset(empty, 0xff, sizeof(empty));
 114        for (pos = 0; pos < len; pos += block_len) {
 115                block_len = min(len - pos, sizeof(buffer));
 116                rc = falcon_spi_read(spi, start + pos, block_len, NULL, buffer);
 117                if (rc)
 118                        return rc;
 119                if (memcmp(empty, buffer, block_len))
 120                        return -EIO;
 121
 122                /* Avoid locking up the system */
 123                cond_resched();
 124                if (signal_pending(current))
 125                        return -EINTR;
 126        }
 127
 128        return rc;
 129}
 130
 131/* MTD interface */
 132
 133static int efx_mtd_read(struct mtd_info *mtd, loff_t start, size_t len,
 134                        size_t *retlen, u8 *buffer)
 135{
 136        struct efx_mtd *efx_mtd = mtd->priv;
 137        const struct efx_spi_device *spi = efx_mtd->spi;
 138        struct efx_nic *efx = spi->efx;
 139        int rc;
 140
 141        rc = mutex_lock_interruptible(&efx->spi_lock);
 142        if (rc)
 143                return rc;
 144        rc = falcon_spi_read(spi, FALCON_FLASH_BOOTCODE_START + start,
 145                             len, retlen, buffer);
 146        mutex_unlock(&efx->spi_lock);
 147        return rc;
 148}
 149
 150static int efx_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
 151{
 152        struct efx_mtd *efx_mtd = mtd->priv;
 153        struct efx_nic *efx = efx_mtd->spi->efx;
 154        int rc;
 155
 156        rc = mutex_lock_interruptible(&efx->spi_lock);
 157        if (rc)
 158                return rc;
 159        rc = efx_spi_erase(efx_mtd, FALCON_FLASH_BOOTCODE_START + erase->addr,
 160                           erase->len);
 161        mutex_unlock(&efx->spi_lock);
 162
 163        if (rc == 0) {
 164                erase->state = MTD_ERASE_DONE;
 165        } else {
 166                erase->state = MTD_ERASE_FAILED;
 167                erase->fail_addr = 0xffffffff;
 168        }
 169        mtd_erase_callback(erase);
 170        return rc;
 171}
 172
 173static int efx_mtd_write(struct mtd_info *mtd, loff_t start,
 174                         size_t len, size_t *retlen, const u8 *buffer)
 175{
 176        struct efx_mtd *efx_mtd = mtd->priv;
 177        const struct efx_spi_device *spi = efx_mtd->spi;
 178        struct efx_nic *efx = spi->efx;
 179        int rc;
 180
 181        rc = mutex_lock_interruptible(&efx->spi_lock);
 182        if (rc)
 183                return rc;
 184        rc = falcon_spi_write(spi, FALCON_FLASH_BOOTCODE_START + start,
 185                              len, retlen, buffer);
 186        mutex_unlock(&efx->spi_lock);
 187        return rc;
 188}
 189
 190static void efx_mtd_sync(struct mtd_info *mtd)
 191{
 192        struct efx_mtd *efx_mtd = mtd->priv;
 193        struct efx_nic *efx = efx_mtd->spi->efx;
 194        int rc;
 195
 196        mutex_lock(&efx->spi_lock);
 197        rc = efx_spi_slow_wait(efx_mtd, true);
 198        mutex_unlock(&efx->spi_lock);
 199
 200        if (rc)
 201                EFX_ERR(efx, "%s sync failed (%d)\n", efx_mtd->name, rc);
 202        return;
 203}
 204
 205void efx_mtd_remove(struct efx_nic *efx)
 206{
 207        if (efx->spi_flash && efx->spi_flash->mtd) {
 208                struct efx_mtd *efx_mtd = efx->spi_flash->mtd;
 209                int rc;
 210
 211                for (;;) {
 212                        rc = del_mtd_device(&efx_mtd->mtd);
 213                        if (rc != -EBUSY)
 214                                break;
 215                        ssleep(1);
 216                }
 217                WARN_ON(rc);
 218                kfree(efx_mtd);
 219        }
 220}
 221
 222void efx_mtd_rename(struct efx_nic *efx)
 223{
 224        if (efx->spi_flash && efx->spi_flash->mtd) {
 225                struct efx_mtd *efx_mtd = efx->spi_flash->mtd;
 226                snprintf(efx_mtd->name, sizeof(efx_mtd->name),
 227                         "%s sfc_flash_bootrom", efx->name);
 228        }
 229}
 230
 231int efx_mtd_probe(struct efx_nic *efx)
 232{
 233        struct efx_spi_device *spi = efx->spi_flash;
 234        struct efx_mtd *efx_mtd;
 235
 236        if (!spi || spi->size <= FALCON_FLASH_BOOTCODE_START)
 237                return -ENODEV;
 238
 239        efx_mtd = kzalloc(sizeof(*efx_mtd), GFP_KERNEL);
 240        if (!efx_mtd)
 241                return -ENOMEM;
 242
 243        efx_mtd->spi = spi;
 244        spi->mtd = efx_mtd;
 245
 246        efx_mtd->mtd.type = MTD_NORFLASH;
 247        efx_mtd->mtd.flags = MTD_CAP_NORFLASH;
 248        efx_mtd->mtd.size = spi->size - FALCON_FLASH_BOOTCODE_START;
 249        efx_mtd->mtd.erasesize = spi->erase_size;
 250        efx_mtd->mtd.writesize = 1;
 251        efx_mtd_rename(efx);
 252
 253        efx_mtd->mtd.owner = THIS_MODULE;
 254        efx_mtd->mtd.priv = efx_mtd;
 255        efx_mtd->mtd.name = efx_mtd->name;
 256        efx_mtd->mtd.erase = efx_mtd_erase;
 257        efx_mtd->mtd.read = efx_mtd_read;
 258        efx_mtd->mtd.write = efx_mtd_write;
 259        efx_mtd->mtd.sync = efx_mtd_sync;
 260
 261        if (add_mtd_device(&efx_mtd->mtd)) {
 262                kfree(efx_mtd);
 263                spi->mtd = NULL;
 264                /* add_mtd_device() returns 1 if the MTD table is full */
 265                return -ENOMEM;
 266        }
 267
 268        return 0;
 269}
 270