lpddr_cmds.c

Go to the documentation of this file.

/*
 * LPDDR flash memory device operations. This module provides read, write,
 * erase, lock/unlock support for LPDDR flash memories
 * (C) 2008 Korolev Alexey <[email protected]>
 * (C) 2008 Vasiliy Leonenko <[email protected]>
 * Many thanks to Roman Borisov for initial enabling
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 * TODO:
 * Implement VPP management
 * Implement XIP support
 * Implement OTP support
 */
#include <linux/mtd/pfow.h>
#include <linux/mtd/qinfo.h>
#include <linux/slab.h>
#include <linux/module.h>

static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
                    size_t *retlen, u_char *buf);
static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to,
                size_t len, size_t *retlen, const u_char *buf);
static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
                unsigned long count, loff_t to, size_t *retlen);
static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr);
static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
            size_t *retlen, void **mtdbuf, resource_size_t *phys);
static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len);
static int get_chip(struct map_info *map, struct flchip *chip, int mode);
static int chip_ready(struct map_info *map, struct flchip *chip, int mode);
static void put_chip(struct map_info *map, struct flchip *chip);

struct mtd_info *lpddr_cmdset(struct map_info *map)
{
    struct lpddr_private *lpddr = map->fldrv_priv;
    struct flchip_shared *shared;
    struct flchip *chip;
    struct mtd_info *mtd;
    int numchips;
    int i, j;

    mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
    if (!mtd) {
        printk(KERN_ERR "Failed to allocate memory for MTD device\n");
        return NULL;
    }
    mtd->priv = map;
    mtd->type = MTD_NORFLASH;

    /* Fill in the default mtd operations */
    mtd->_read = lpddr_read;
    mtd->type = MTD_NORFLASH;
    mtd->flags = MTD_CAP_NORFLASH;
    mtd->flags &= ~MTD_BIT_WRITEABLE;
    mtd->_erase = lpddr_erase;
    mtd->_write = lpddr_write_buffers;
    mtd->_writev = lpddr_writev;
    mtd->_lock = lpddr_lock;
    mtd->_unlock = lpddr_unlock;
    if (map_is_linear(map)) {
        mtd->_point = lpddr_point;
        mtd->_unpoint = lpddr_unpoint;
    }
    mtd->size = 1 << lpddr->qinfo->DevSizeShift;
    mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
    mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;

    shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips,
                        GFP_KERNEL);
    if (!shared) {
        kfree(lpddr);
        kfree(mtd);
        return NULL;
    }

    chip = &lpddr->chips[0];
    numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
    for (i = 0; i < numchips; i++) {
        shared[i].writing = shared[i].erasing = NULL;
        mutex_init(&shared[i].lock);
        for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
            *chip = lpddr->chips[i];
            chip->start += j << lpddr->chipshift;
            chip->oldstate = chip->state = FL_READY;
            chip->priv = &shared[i];
            /* those should be reset too since
               they create memory references. */
            init_waitqueue_head(&chip->wq);
            mutex_init(&chip->mutex);
            chip++;
        }
    }

    return mtd;
}
EXPORT_SYMBOL(lpddr_cmdset);

static int wait_for_ready(struct map_info *map, struct flchip *chip,
        unsigned int chip_op_time)
{
    unsigned int timeo, reset_timeo, sleep_time;
    unsigned int dsr;
    flstate_t chip_state = chip->state;
    int ret = 0;

    /* set our timeout to 8 times the expected delay */
    timeo = chip_op_time * 8;
    if (!timeo)
        timeo = 500000;
    reset_timeo = timeo;
    sleep_time = chip_op_time / 2;

    for (;;) {
        dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR));
        if (dsr & DSR_READY_STATUS)
            break;
        if (!timeo) {
            printk(KERN_ERR "%s: Flash timeout error state %d \n",
                            map->name, chip_state);
            ret = -ETIME;
            break;
        }

        /* OK Still waiting. Drop the lock, wait a while and retry. */
        mutex_unlock(&chip->mutex);
        if (sleep_time >= 1000000/HZ) {
            /*
             * Half of the normal delay still remaining
             * can be performed with a sleeping delay instead
             * of busy waiting.
             */
            msleep(sleep_time/1000);
            timeo -= sleep_time;
            sleep_time = 1000000/HZ;
        } else {
            udelay(1);
            cond_resched();
            timeo--;
        }
        mutex_lock(&chip->mutex);

        while (chip->state != chip_state) {
            /* Someone's suspended the operation: sleep */
            DECLARE_WAITQUEUE(wait, current);
            set_current_state(TASK_UNINTERRUPTIBLE);
            add_wait_queue(&chip->wq, &wait);
            mutex_unlock(&chip->mutex);
            schedule();
            remove_wait_queue(&chip->wq, &wait);
            mutex_lock(&chip->mutex);
        }
        if (chip->erase_suspended || chip->write_suspended)  {
            /* Suspend has occurred while sleep: reset timeout */
            timeo = reset_timeo;
            chip->erase_suspended = chip->write_suspended = 0;
        }
    }
    /* check status for errors */
    if (dsr & DSR_ERR) {
        /* Clear DSR*/
        map_write(map, CMD(~(DSR_ERR)), map->pfow_base + PFOW_DSR);
        printk(KERN_WARNING"%s: Bad status on wait: 0x%x \n",
                map->name, dsr);
        print_drs_error(dsr);
        ret = -EIO;
    }
    chip->state = FL_READY;
    return ret;
}

static int get_chip(struct map_info *map, struct flchip *chip, int mode)
{
    int ret;
    DECLARE_WAITQUEUE(wait, current);

 retry:
    if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
        && chip->state != FL_SYNCING) {
        /*
         * OK. We have possibility for contension on the write/erase
         * operations which are global to the real chip and not per
         * partition.  So let's fight it over in the partition which
         * currently has authority on the operation.
         *
         * The rules are as follows:
         *
         * - any write operation must own shared->writing.
         *
         * - any erase operation must own _both_ shared->writing and
         *   shared->erasing.
         *
         * - contension arbitration is handled in the owner's context.
         *
         * The 'shared' struct can be read and/or written only when
         * its lock is taken.
         */
        struct flchip_shared *shared = chip->priv;
        struct flchip *contender;
        mutex_lock(&shared->lock);
        contender = shared->writing;
        if (contender && contender != chip) {
            /*
             * The engine to perform desired operation on this
             * partition is already in use by someone else.
             * Let's fight over it in the context of the chip
             * currently using it.  If it is possible to suspend,
             * that other partition will do just that, otherwise
             * it'll happily send us to sleep.  In any case, when
             * get_chip returns success we're clear to go ahead.
             */
            ret = mutex_trylock(&contender->mutex);
            mutex_unlock(&shared->lock);
            if (!ret)
                goto retry;
            mutex_unlock(&chip->mutex);
            ret = chip_ready(map, contender, mode);
            mutex_lock(&chip->mutex);

            if (ret == -EAGAIN) {
                mutex_unlock(&contender->mutex);
                goto retry;
            }
            if (ret) {
                mutex_unlock(&contender->mutex);
                return ret;
            }
            mutex_lock(&shared->lock);

            /* We should not own chip if it is already in FL_SYNCING
             * state. Put contender and retry. */
            if (chip->state == FL_SYNCING) {
                put_chip(map, contender);
                mutex_unlock(&contender->mutex);
                goto retry;
            }
            mutex_unlock(&contender->mutex);
        }

        /* Check if we have suspended erase on this chip.
           Must sleep in such a case. */
        if (mode == FL_ERASING && shared->erasing
            && shared->erasing->oldstate == FL_ERASING) {
            mutex_unlock(&shared->lock);
            set_current_state(TASK_UNINTERRUPTIBLE);
            add_wait_queue(&chip->wq, &wait);
            mutex_unlock(&chip->mutex);
            schedule();
            remove_wait_queue(&chip->wq, &wait);
            mutex_lock(&chip->mutex);
            goto retry;
        }

        /* We now own it */
        shared->writing = chip;
        if (mode == FL_ERASING)
            shared->erasing = chip;
        mutex_unlock(&shared->lock);
    }

    ret = chip_ready(map, chip, mode);
    if (ret == -EAGAIN)
        goto retry;

    return ret;
}

static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
{
    struct lpddr_private *lpddr = map->fldrv_priv;
    int ret = 0;
    DECLARE_WAITQUEUE(wait, current);

    /* Prevent setting state FL_SYNCING for chip in suspended state. */
    if (FL_SYNCING == mode && FL_READY != chip->oldstate)
        goto sleep;

    switch (chip->state) {
    case FL_READY:
    case FL_JEDEC_QUERY:
        return 0;

    case FL_ERASING:
        if (!lpddr->qinfo->SuspEraseSupp ||
            !(mode == FL_READY || mode == FL_POINT))
            goto sleep;

        map_write(map, CMD(LPDDR_SUSPEND),
            map->pfow_base + PFOW_PROGRAM_ERASE_SUSPEND);
        chip->oldstate = FL_ERASING;
        chip->state = FL_ERASE_SUSPENDING;
        ret = wait_for_ready(map, chip, 0);
        if (ret) {
            /* Oops. something got wrong. */
            /* Resume and pretend we weren't here.  */
            put_chip(map, chip);
            printk(KERN_ERR "%s: suspend operation failed."
                    "State may be wrong \n", map->name);
            return -EIO;
        }
        chip->erase_suspended = 1;
        chip->state = FL_READY;
        return 0;
        /* Erase suspend */
    case FL_POINT:
        /* Only if there's no operation suspended... */
        if (mode == FL_READY && chip->oldstate == FL_READY)
            return 0;

    default:
sleep:
        set_current_state(TASK_UNINTERRUPTIBLE);
        add_wait_queue(&chip->wq, &wait);
        mutex_unlock(&chip->mutex);
        schedule();
        remove_wait_queue(&chip->wq, &wait);
        mutex_lock(&chip->mutex);
        return -EAGAIN;
    }
}

static void put_chip(struct map_info *map, struct flchip *chip)
{
    if (chip->priv) {
        struct flchip_shared *shared = chip->priv;
        mutex_lock(&shared->lock);
        if (shared->writing == chip && chip->oldstate == FL_READY) {
            /* We own the ability to write, but we're done */
            shared->writing = shared->erasing;
            if (shared->writing && shared->writing != chip) {
                /* give back the ownership */
                struct flchip *loaner = shared->writing;
                mutex_lock(&loaner->mutex);
                mutex_unlock(&shared->lock);
                mutex_unlock(&chip->mutex);
                put_chip(map, loaner);
                mutex_lock(&chip->mutex);
                mutex_unlock(&loaner->mutex);
                wake_up(&chip->wq);
                return;
            }
            shared->erasing = NULL;
            shared->writing = NULL;
        } else if (shared->erasing == chip && shared->writing != chip) {
            /*
             * We own the ability to erase without the ability
             * to write, which means the erase was suspended
             * and some other partition is currently writing.
             * Don't let the switch below mess things up since
             * we don't have ownership to resume anything.
             */
            mutex_unlock(&shared->lock);
            wake_up(&chip->wq);
            return;
        }
        mutex_unlock(&shared->lock);
    }

    switch (chip->oldstate) {
    case FL_ERASING:
        map_write(map, CMD(LPDDR_RESUME),
                map->pfow_base + PFOW_COMMAND_CODE);
        map_write(map, CMD(LPDDR_START_EXECUTION),
                map->pfow_base + PFOW_COMMAND_EXECUTE);
        chip->oldstate = FL_READY;
        chip->state = FL_ERASING;
        break;
    case FL_READY:
        break;
    default:
        printk(KERN_ERR "%s: put_chip() called with oldstate %d!\n",
                map->name, chip->oldstate);
    }
    wake_up(&chip->wq);
}

int do_write_buffer(struct map_info *map, struct flchip *chip,
            unsigned long adr, const struct kvec **pvec,
            unsigned long *pvec_seek, int len)
{
    struct lpddr_private *lpddr = map->fldrv_priv;
    map_word datum;
    int ret, wbufsize, word_gap, words;
    const struct kvec *vec;
    unsigned long vec_seek;
    unsigned long prog_buf_ofs;

    wbufsize = 1 << lpddr->qinfo->BufSizeShift;

    mutex_lock(&chip->mutex);
    ret = get_chip(map, chip, FL_WRITING);
    if (ret) {
        mutex_unlock(&chip->mutex);
        return ret;
    }
    /* Figure out the number of words to write */
    word_gap = (-adr & (map_bankwidth(map)-1));
    words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
    if (!word_gap) {
        words--;
    } else {
        word_gap = map_bankwidth(map) - word_gap;
        adr -= word_gap;
        datum = map_word_ff(map);
    }
    /* Write data */
    /* Get the program buffer offset from PFOW register data first*/
    prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
                map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
    vec = *pvec;
    vec_seek = *pvec_seek;
    do {
        int n = map_bankwidth(map) - word_gap;

        if (n > vec->iov_len - vec_seek)
            n = vec->iov_len - vec_seek;
        if (n > len)
            n = len;

        if (!word_gap && (len < map_bankwidth(map)))
            datum = map_word_ff(map);

        datum = map_word_load_partial(map, datum,
                vec->iov_base + vec_seek, word_gap, n);

        len -= n;
        word_gap += n;
        if (!len || word_gap == map_bankwidth(map)) {
            map_write(map, datum, prog_buf_ofs);
            prog_buf_ofs += map_bankwidth(map);
            word_gap = 0;
        }

        vec_seek += n;
        if (vec_seek == vec->iov_len) {
            vec++;
            vec_seek = 0;
        }
    } while (len);
    *pvec = vec;
    *pvec_seek = vec_seek;

    /* GO GO GO */
    send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
    chip->state = FL_WRITING;
    ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
    if (ret)    {
        printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
            map->name, ret, adr);
        goto out;
    }

 out:   put_chip(map, chip);
    mutex_unlock(&chip->mutex);
    return ret;
}

int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
{
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift;
    struct flchip *chip = &lpddr->chips[chipnum];
    int ret;

    mutex_lock(&chip->mutex);
    ret = get_chip(map, chip, FL_ERASING);
    if (ret) {
        mutex_unlock(&chip->mutex);
        return ret;
    }
    send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
    chip->state = FL_ERASING;
    ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
    if (ret) {
        printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
            map->name, ret, adr);
        goto out;
    }
 out:   put_chip(map, chip);
    mutex_unlock(&chip->mutex);
    return ret;
}

static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
            size_t *retlen, u_char *buf)
{
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift;
    struct flchip *chip = &lpddr->chips[chipnum];
    int ret = 0;

    mutex_lock(&chip->mutex);
    ret = get_chip(map, chip, FL_READY);
    if (ret) {
        mutex_unlock(&chip->mutex);
        return ret;
    }

    map_copy_from(map, buf, adr, len);
    *retlen = len;

    put_chip(map, chip);
    mutex_unlock(&chip->mutex);
    return ret;
}

static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
            size_t *retlen, void **mtdbuf, resource_size_t *phys)
{
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift;
    unsigned long ofs, last_end = 0;
    struct flchip *chip = &lpddr->chips[chipnum];
    int ret = 0;

    if (!map->virt)
        return -EINVAL;

    /* ofs: offset within the first chip that the first read should start */
    ofs = adr - (chipnum << lpddr->chipshift);
    *mtdbuf = (void *)map->virt + chip->start + ofs;

    while (len) {
        unsigned long thislen;

        if (chipnum >= lpddr->numchips)
            break;

        /* We cannot point across chips that are virtually disjoint */
        if (!last_end)
            last_end = chip->start;
        else if (chip->start != last_end)
            break;

        if ((len + ofs - 1) >> lpddr->chipshift)
            thislen = (1<<lpddr->chipshift) - ofs;
        else
            thislen = len;
        /* get the chip */
        mutex_lock(&chip->mutex);
        ret = get_chip(map, chip, FL_POINT);
        mutex_unlock(&chip->mutex);
        if (ret)
            break;

        chip->state = FL_POINT;
        chip->ref_point_counter++;
        *retlen += thislen;
        len -= thislen;

        ofs = 0;
        last_end += 1 << lpddr->chipshift;
        chipnum++;
        chip = &lpddr->chips[chipnum];
    }
    return 0;
}

static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
{
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift, err = 0;
    unsigned long ofs;

    /* ofs: offset within the first chip that the first read should start */
    ofs = adr - (chipnum << lpddr->chipshift);

    while (len) {
        unsigned long thislen;
        struct flchip *chip;

        chip = &lpddr->chips[chipnum];
        if (chipnum >= lpddr->numchips)
            break;

        if ((len + ofs - 1) >> lpddr->chipshift)
            thislen = (1<<lpddr->chipshift) - ofs;
        else
            thislen = len;

        mutex_lock(&chip->mutex);
        if (chip->state == FL_POINT) {
            chip->ref_point_counter--;
            if (chip->ref_point_counter == 0)
                chip->state = FL_READY;
        } else {
            printk(KERN_WARNING "%s: Warning: unpoint called on non"
                    "pointed region\n", map->name);
            err = -EINVAL;
        }

        put_chip(map, chip);
        mutex_unlock(&chip->mutex);

        len -= thislen;
        ofs = 0;
        chipnum++;
    }

    return err;
}

static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
                size_t *retlen, const u_char *buf)
{
    struct kvec vec;

    vec.iov_base = (void *) buf;
    vec.iov_len = len;

    return lpddr_writev(mtd, &vec, 1, to, retlen);
}


static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
                unsigned long count, loff_t to, size_t *retlen)
{
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int ret = 0;
    int chipnum;
    unsigned long ofs, vec_seek, i;
    int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
    size_t len = 0;

    for (i = 0; i < count; i++)
        len += vecs[i].iov_len;

    if (!len)
        return 0;

    chipnum = to >> lpddr->chipshift;

    ofs = to;
    vec_seek = 0;

    do {
        /* We must not cross write block boundaries */
        int size = wbufsize - (ofs & (wbufsize-1));

        if (size > len)
            size = len;

        ret = do_write_buffer(map, &lpddr->chips[chipnum],
                      ofs, &vecs, &vec_seek, size);
        if (ret)
            return ret;

        ofs += size;
        (*retlen) += size;
        len -= size;

        /* Be nice and reschedule with the chip in a usable
         * state for other processes */
        cond_resched();

    } while (len);

    return 0;
}

static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
{
    unsigned long ofs, len;
    int ret;
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int size = 1 << lpddr->qinfo->UniformBlockSizeShift;

    ofs = instr->addr;
    len = instr->len;

    while (len > 0) {
        ret = do_erase_oneblock(mtd, ofs);
        if (ret)
            return ret;
        ofs += size;
        len -= size;
    }
    instr->state = MTD_ERASE_DONE;
    mtd_erase_callback(instr);

    return 0;
}

#define DO_XXLOCK_LOCK      1
#define DO_XXLOCK_UNLOCK    2
int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
{
    int ret = 0;
    struct map_info *map = mtd->priv;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift;
    struct flchip *chip = &lpddr->chips[chipnum];

    mutex_lock(&chip->mutex);
    ret = get_chip(map, chip, FL_LOCKING);
    if (ret) {
        mutex_unlock(&chip->mutex);
        return ret;
    }

    if (thunk == DO_XXLOCK_LOCK) {
        send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
        chip->state = FL_LOCKING;
    } else if (thunk == DO_XXLOCK_UNLOCK) {
        send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
        chip->state = FL_UNLOCKING;
    } else
        BUG();

    ret = wait_for_ready(map, chip, 1);
    if (ret)    {
        printk(KERN_ERR "%s: block unlock error status %d \n",
                map->name, ret);
        goto out;
    }
out:    put_chip(map, chip);
    mutex_unlock(&chip->mutex);
    return ret;
}

static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
    return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
}

static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
    return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
}

int word_program(struct map_info *map, loff_t adr, uint32_t curval)
{
    int ret;
    struct lpddr_private *lpddr = map->fldrv_priv;
    int chipnum = adr >> lpddr->chipshift;
    struct flchip *chip = &lpddr->chips[chipnum];

    mutex_lock(&chip->mutex);
    ret = get_chip(map, chip, FL_WRITING);
    if (ret) {
        mutex_unlock(&chip->mutex);
        return ret;
    }

    send_pfow_command(map, LPDDR_WORD_PROGRAM, adr, 0x00, (map_word *)&curval);

    ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->SingleWordProgTime));
    if (ret)    {
        printk(KERN_WARNING"%s word_program error at: %llx; val: %x\n",
            map->name, adr, curval);
        goto out;
    }

out:    put_chip(map, chip);
    mutex_unlock(&chip->mutex);
    return ret;
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Alexey Korolev <[email protected]>");
MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");