mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-12 05:24:12 +08:00
54f5a57e26
The site-specific OOM messages are unnecessary, because they duplicate the MM subsystem generic OOM message. Signed-off-by: Jingoo Han <jg1.han@samsung.com> Signed-off-by: Brian Norris <computersforpeace@gmail.com>
752 lines
19 KiB
C
752 lines
19 KiB
C
/*
|
|
* 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(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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
instr->state = MTD_ERASE_DONE;
|
|
mtd_erase_callback(instr);
|
|
|
|
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");
|