drivers/mtd/lpddr/lpddr_cmds.c - kernel/msm-5.4 - Gitiles

 /*
  * LPDDR flash memory device operations. This module provides read, write,
  * erase, lock/unlock support for LPDDR flash memories
  * (C) 2008 Korolev Alexey <akorolev@infradead.org>
  * (C) 2008 Vasiliy Leonenko <vasiliy.leonenko@gmail.com>
  * 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)
 		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_array(lpddr->numchips, sizeof(struct flchip_shared),
 						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;
 		/* fall through */

 	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);
 }

 static 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;
 }

 static 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;
 	}

 	return 0;
 }

 #define DO_XXLOCK_LOCK		1
 #define DO_XXLOCK_UNLOCK	2
 static 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);
 }

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
 MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");
	/*
	* LPDDR flash memory device operations. This module provides read, write,
	* erase, lock/unlock support for LPDDR flash memories
	* (C) 2008 Korolev Alexey <akorolev@infradead.org>
	* (C) 2008 Vasiliy Leonenko <vasiliy.leonenko@gmail.com>
	* 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)
	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_array(lpddr->numchips, sizeof(struct flchip_shared),
	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;
	/* fall through */

	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);
	}

	static 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;
	}

	static 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;
	}

	return 0;
	}

	#define DO_XXLOCK_LOCK 1
	#define DO_XXLOCK_UNLOCK 2
	static 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);
	}

	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
	MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");