sst25l.c

Go to the documentation of this file.

/*
 * sst25l.c
 *
 * Driver for SST25L SPI Flash chips
 *
 * Copyright © 2009 Bluewater Systems Ltd
 * Author: Andre Renaud <[email protected]>
 * Author: Ryan Mallon
 *
 * Based on m25p80.c
 *
 * This code is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/sched.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>

#include <linux/spi/spi.h>
#include <linux/spi/flash.h>

/* Erases can take up to 3 seconds! */
#define MAX_READY_WAIT_JIFFIES  msecs_to_jiffies(3000)

#define SST25L_CMD_WRSR     0x01    /* Write status register */
#define SST25L_CMD_WRDI     0x04    /* Write disable */
#define SST25L_CMD_RDSR     0x05    /* Read status register */
#define SST25L_CMD_WREN     0x06    /* Write enable */
#define SST25L_CMD_READ     0x03    /* High speed read */

#define SST25L_CMD_EWSR     0x50    /* Enable write status register */
#define SST25L_CMD_SECTOR_ERASE 0x20    /* Erase sector */
#define SST25L_CMD_READ_ID  0x90    /* Read device ID */
#define SST25L_CMD_AAI_PROGRAM  0xaf    /* Auto address increment */

#define SST25L_STATUS_BUSY  (1 << 0)    /* Chip is busy */
#define SST25L_STATUS_WREN  (1 << 1)    /* Write enabled */
#define SST25L_STATUS_BP0   (1 << 2)    /* Block protection 0 */
#define SST25L_STATUS_BP1   (1 << 3)    /* Block protection 1 */

struct sst25l_flash {
    struct spi_device   *spi;
    struct mutex        lock;
    struct mtd_info     mtd;
};

struct flash_info {
    const char      *name;
    uint16_t        device_id;
    unsigned        page_size;
    unsigned        nr_pages;
    unsigned        erase_size;
};

#define to_sst25l_flash(x) container_of(x, struct sst25l_flash, mtd)

static struct flash_info __devinitdata sst25l_flash_info[] = {
    {"sst25lf020a", 0xbf43, 256, 1024, 4096},
    {"sst25lf040a", 0xbf44, 256, 2048, 4096},
};

static int sst25l_status(struct sst25l_flash *flash, int *status)
{
    struct spi_message m;
    struct spi_transfer t;
    unsigned char cmd_resp[2];
    int err;

    spi_message_init(&m);
    memset(&t, 0, sizeof(struct spi_transfer));

    cmd_resp[0] = SST25L_CMD_RDSR;
    cmd_resp[1] = 0xff;
    t.tx_buf = cmd_resp;
    t.rx_buf = cmd_resp;
    t.len = sizeof(cmd_resp);
    spi_message_add_tail(&t, &m);
    err = spi_sync(flash->spi, &m);
    if (err < 0)
        return err;

    *status = cmd_resp[1];
    return 0;
}

static int sst25l_write_enable(struct sst25l_flash *flash, int enable)
{
    unsigned char command[2];
    int status, err;

    command[0] = enable ? SST25L_CMD_WREN : SST25L_CMD_WRDI;
    err = spi_write(flash->spi, command, 1);
    if (err)
        return err;

    command[0] = SST25L_CMD_EWSR;
    err = spi_write(flash->spi, command, 1);
    if (err)
        return err;

    command[0] = SST25L_CMD_WRSR;
    command[1] = enable ? 0 : SST25L_STATUS_BP0 | SST25L_STATUS_BP1;
    err = spi_write(flash->spi, command, 2);
    if (err)
        return err;

    if (enable) {
        err = sst25l_status(flash, &status);
        if (err)
            return err;
        if (!(status & SST25L_STATUS_WREN))
            return -EROFS;
    }

    return 0;
}

static int sst25l_wait_till_ready(struct sst25l_flash *flash)
{
    unsigned long deadline;
    int status, err;

    deadline = jiffies + MAX_READY_WAIT_JIFFIES;
    do {
        err = sst25l_status(flash, &status);
        if (err)
            return err;
        if (!(status & SST25L_STATUS_BUSY))
            return 0;

        cond_resched();
    } while (!time_after_eq(jiffies, deadline));

    return -ETIMEDOUT;
}

static int sst25l_erase_sector(struct sst25l_flash *flash, uint32_t offset)
{
    unsigned char command[4];
    int err;

    err = sst25l_write_enable(flash, 1);
    if (err)
        return err;

    command[0] = SST25L_CMD_SECTOR_ERASE;
    command[1] = offset >> 16;
    command[2] = offset >> 8;
    command[3] = offset;
    err = spi_write(flash->spi, command, 4);
    if (err)
        return err;

    err = sst25l_wait_till_ready(flash);
    if (err)
        return err;

    return sst25l_write_enable(flash, 0);
}

static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr)
{
    struct sst25l_flash *flash = to_sst25l_flash(mtd);
    uint32_t addr, end;
    int err;

    /* Sanity checks */
    if ((uint32_t)instr->len % mtd->erasesize)
        return -EINVAL;

    if ((uint32_t)instr->addr % mtd->erasesize)
        return -EINVAL;

    addr = instr->addr;
    end = addr + instr->len;

    mutex_lock(&flash->lock);

    err = sst25l_wait_till_ready(flash);
    if (err) {
        mutex_unlock(&flash->lock);
        return err;
    }

    while (addr < end) {
        err = sst25l_erase_sector(flash, addr);
        if (err) {
            mutex_unlock(&flash->lock);
            instr->state = MTD_ERASE_FAILED;
            dev_err(&flash->spi->dev, "Erase failed\n");
            return err;
        }

        addr += mtd->erasesize;
    }

    mutex_unlock(&flash->lock);

    instr->state = MTD_ERASE_DONE;
    mtd_erase_callback(instr);
    return 0;
}

static int sst25l_read(struct mtd_info *mtd, loff_t from, size_t len,
               size_t *retlen, unsigned char *buf)
{
    struct sst25l_flash *flash = to_sst25l_flash(mtd);
    struct spi_transfer transfer[2];
    struct spi_message message;
    unsigned char command[4];
    int ret;

    spi_message_init(&message);
    memset(&transfer, 0, sizeof(transfer));

    command[0] = SST25L_CMD_READ;
    command[1] = from >> 16;
    command[2] = from >> 8;
    command[3] = from;

    transfer[0].tx_buf = command;
    transfer[0].len = sizeof(command);
    spi_message_add_tail(&transfer[0], &message);

    transfer[1].rx_buf = buf;
    transfer[1].len = len;
    spi_message_add_tail(&transfer[1], &message);

    mutex_lock(&flash->lock);

    /* Wait for previous write/erase to complete */
    ret = sst25l_wait_till_ready(flash);
    if (ret) {
        mutex_unlock(&flash->lock);
        return ret;
    }

    spi_sync(flash->spi, &message);

    if (retlen && message.actual_length > sizeof(command))
        *retlen += message.actual_length - sizeof(command);

    mutex_unlock(&flash->lock);
    return 0;
}

static int sst25l_write(struct mtd_info *mtd, loff_t to, size_t len,
            size_t *retlen, const unsigned char *buf)
{
    struct sst25l_flash *flash = to_sst25l_flash(mtd);
    int i, j, ret, bytes, copied = 0;
    unsigned char command[5];

    if ((uint32_t)to % mtd->writesize)
        return -EINVAL;

    mutex_lock(&flash->lock);

    ret = sst25l_write_enable(flash, 1);
    if (ret)
        goto out;

    for (i = 0; i < len; i += mtd->writesize) {
        ret = sst25l_wait_till_ready(flash);
        if (ret)
            goto out;

        /* Write the first byte of the page */
        command[0] = SST25L_CMD_AAI_PROGRAM;
        command[1] = (to + i) >> 16;
        command[2] = (to + i) >> 8;
        command[3] = (to + i);
        command[4] = buf[i];
        ret = spi_write(flash->spi, command, 5);
        if (ret < 0)
            goto out;
        copied++;

        /*
         * Write the remaining bytes using auto address
         * increment mode
         */
        bytes = min_t(uint32_t, mtd->writesize, len - i);
        for (j = 1; j < bytes; j++, copied++) {
            ret = sst25l_wait_till_ready(flash);
            if (ret)
                goto out;

            command[1] = buf[i + j];
            ret = spi_write(flash->spi, command, 2);
            if (ret)
                goto out;
        }
    }

out:
    ret = sst25l_write_enable(flash, 0);

    if (retlen)
        *retlen = copied;

    mutex_unlock(&flash->lock);
    return ret;
}

static struct flash_info *__devinit sst25l_match_device(struct spi_device *spi)
{
    struct flash_info *flash_info = NULL;
    struct spi_message m;
    struct spi_transfer t;
    unsigned char cmd_resp[6];
    int i, err;
    uint16_t id;

    spi_message_init(&m);
    memset(&t, 0, sizeof(struct spi_transfer));

    cmd_resp[0] = SST25L_CMD_READ_ID;
    cmd_resp[1] = 0;
    cmd_resp[2] = 0;
    cmd_resp[3] = 0;
    cmd_resp[4] = 0xff;
    cmd_resp[5] = 0xff;
    t.tx_buf = cmd_resp;
    t.rx_buf = cmd_resp;
    t.len = sizeof(cmd_resp);
    spi_message_add_tail(&t, &m);
    err = spi_sync(spi, &m);
    if (err < 0) {
        dev_err(&spi->dev, "error reading device id\n");
        return NULL;
    }

    id = (cmd_resp[4] << 8) | cmd_resp[5];

    for (i = 0; i < ARRAY_SIZE(sst25l_flash_info); i++)
        if (sst25l_flash_info[i].device_id == id)
            flash_info = &sst25l_flash_info[i];

    if (!flash_info)
        dev_err(&spi->dev, "unknown id %.4x\n", id);

    return flash_info;
}

static int __devinit sst25l_probe(struct spi_device *spi)
{
    struct flash_info *flash_info;
    struct sst25l_flash *flash;
    struct flash_platform_data *data;
    int ret;

    flash_info = sst25l_match_device(spi);
    if (!flash_info)
        return -ENODEV;

    flash = kzalloc(sizeof(struct sst25l_flash), GFP_KERNEL);
    if (!flash)
        return -ENOMEM;

    flash->spi = spi;
    mutex_init(&flash->lock);
    dev_set_drvdata(&spi->dev, flash);

    data = spi->dev.platform_data;
    if (data && data->name)
        flash->mtd.name = data->name;
    else
        flash->mtd.name = dev_name(&spi->dev);

    flash->mtd.type     = MTD_NORFLASH;
    flash->mtd.flags    = MTD_CAP_NORFLASH;
    flash->mtd.erasesize    = flash_info->erase_size;
    flash->mtd.writesize    = flash_info->page_size;
    flash->mtd.writebufsize = flash_info->page_size;
    flash->mtd.size     = flash_info->page_size * flash_info->nr_pages;
    flash->mtd._erase   = sst25l_erase;
    flash->mtd._read        = sst25l_read;
    flash->mtd._write   = sst25l_write;

    dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name,
         (long long)flash->mtd.size >> 10);

    pr_debug("mtd .name = %s, .size = 0x%llx (%lldMiB) "
          ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
          flash->mtd.name,
          (long long)flash->mtd.size, (long long)(flash->mtd.size >> 20),
          flash->mtd.erasesize, flash->mtd.erasesize / 1024,
          flash->mtd.numeraseregions);


    ret = mtd_device_parse_register(&flash->mtd, NULL, NULL,
                    data ? data->parts : NULL,
                    data ? data->nr_parts : 0);
    if (ret) {
        kfree(flash);
        dev_set_drvdata(&spi->dev, NULL);
        return -ENODEV;
    }

    return 0;
}

static int __devexit sst25l_remove(struct spi_device *spi)
{
    struct sst25l_flash *flash = dev_get_drvdata(&spi->dev);
    int ret;

    ret = mtd_device_unregister(&flash->mtd);
    if (ret == 0)
        kfree(flash);
    return ret;
}

static struct spi_driver sst25l_driver = {
    .driver = {
        .name   = "sst25l",
        .owner  = THIS_MODULE,
    },
    .probe      = sst25l_probe,
    .remove     = __devexit_p(sst25l_remove),
};

module_spi_driver(sst25l_driver);

MODULE_DESCRIPTION("MTD SPI driver for SST25L Flash chips");
MODULE_AUTHOR("Andre Renaud <[email protected]>, "
          "Ryan Mallon");
MODULE_LICENSE("GPL");