/* Copyright (C) 2007-2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** 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.
*/
#include "qemu_file.h"
#include "goldfish_nand_reg.h"
#include "goldfish_nand.h"
#include "android/utils/tempfile.h"
#include "qemu_debug.h"
#include "android/android.h"
#define DEBUG 1
#if DEBUG
# define D(...) VERBOSE_PRINT(init,__VA_ARGS__)
# define D_ACTIVE VERBOSE_CHECK(init)
# define T(...) VERBOSE_PRINT(nand_limits,__VA_ARGS__)
# define T_ACTIVE VERBOSE_CHECK(nand_limits)
#else
# define D(...) ((void)0)
# define D_ACTIVE 0
# define T(...) ((void)0)
# define T_ACTIVE 0
#endif
/* lseek uses 64-bit offsets on Darwin. */
/* prefer lseek64 on Linux */
#ifdef __APPLE__
# define llseek lseek
#elif defined(__linux__)
# define llseek lseek64
#endif
#define XLOG xlog
static void
xlog( const char* format, ... )
{
va_list args;
va_start(args, format);
fprintf(stderr, "NAND: ");
vfprintf(stderr, format, args);
va_end(args);
}
typedef struct {
char* devname;
size_t devname_len;
char* data;
int fd;
uint32_t flags;
uint32_t page_size;
uint32_t extra_size;
uint32_t erase_size;
uint64_t size;
} nand_dev;
nand_threshold android_nand_write_threshold;
nand_threshold android_nand_read_threshold;
#ifdef CONFIG_NAND_THRESHOLD
/* update a threshold, return 1 if limit is hit, 0 otherwise */
static void
nand_threshold_update( nand_threshold* t, uint32_t len )
{
if (t->counter < t->limit) {
uint64_t avail = t->limit - t->counter;
if (avail > len)
avail = len;
if (t->counter == 0) {
T("%s: starting threshold counting to %lld",
__FUNCTION__, t->limit);
}
t->counter += avail;
if (t->counter >= t->limit) {
/* threshold reach, send a signal to an external process */
T( "%s: sending signal %d to pid %d !",
__FUNCTION__, t->signal, t->pid );
kill( t->pid, t->signal );
}
}
return;
}
#define NAND_UPDATE_READ_THRESHOLD(len) \
nand_threshold_update( &android_nand_read_threshold, (uint32_t)(len) )
#define NAND_UPDATE_WRITE_THRESHOLD(len) \
nand_threshold_update( &android_nand_write_threshold, (uint32_t)(len) )
#else /* !NAND_THRESHOLD */
#define NAND_UPDATE_READ_THRESHOLD(len) \
do {} while (0)
#define NAND_UPDATE_WRITE_THRESHOLD(len) \
do {} while (0)
#endif /* !NAND_THRESHOLD */
static nand_dev *nand_devs = NULL;
static uint32_t nand_dev_count = 0;
typedef struct {
uint32_t base;
// register state
uint32_t dev;
uint32_t addr_low;
uint32_t addr_high;
uint32_t transfer_size;
uint32_t data;
uint32_t result;
} nand_dev_state;
/* update this everytime you change the nand_dev_state structure */
#define NAND_DEV_STATE_SAVE_VERSION 1
#define QFIELD_STRUCT nand_dev_state
QFIELD_BEGIN(nand_dev_state_fields)
QFIELD_INT32(dev),
QFIELD_INT32(addr_low),
QFIELD_INT32(addr_high),
QFIELD_INT32(transfer_size),
QFIELD_INT32(data),
QFIELD_INT32(result),
QFIELD_END
static void nand_dev_state_save(QEMUFile* f, void* opaque)
{
nand_dev_state* s = opaque;
qemu_put_struct(f, nand_dev_state_fields, s);
}
static int nand_dev_state_load(QEMUFile* f, void* opaque, int version_id)
{
nand_dev_state* s = opaque;
if (version_id != NAND_DEV_STATE_SAVE_VERSION)
return -1;
return qemu_get_struct(f, nand_dev_state_fields, s);
}
static int do_read(int fd, void* buf, size_t size)
{
int ret;
do {
ret = read(fd, buf, size);
} while (ret < 0 && errno == EINTR);
return ret;
}
static int do_write(int fd, const void* buf, size_t size)
{
int ret;
do {
ret = write(fd, buf, size);
} while (ret < 0 && errno == EINTR);
return ret;
}
static uint32_t nand_dev_read_file(nand_dev *dev, uint32_t data, uint64_t addr, uint32_t total_len)
{
uint32_t len = total_len;
size_t read_len = dev->erase_size;
int eof = 0;
NAND_UPDATE_READ_THRESHOLD(total_len);
lseek(dev->fd, addr, SEEK_SET);
while(len > 0) {
if(read_len < dev->erase_size) {
memset(dev->data, 0xff, dev->erase_size);
read_len = dev->erase_size;
eof = 1;
}
if(len < read_len)
read_len = len;
if(!eof) {
read_len = do_read(dev->fd, dev->data, read_len);
}
cpu_memory_rw_debug(cpu_single_env, data, dev->data, read_len, 1);
data += read_len;
len -= read_len;
}
return total_len;
}
static uint32_t nand_dev_write_file(nand_dev *dev, uint32_t data, uint64_t addr, uint32_t total_len)
{
uint32_t len = total_len;
size_t write_len = dev->erase_size;
int ret;
NAND_UPDATE_WRITE_THRESHOLD(total_len);
lseek(dev->fd, addr, SEEK_SET);
while(len > 0) {
if(len < write_len)
write_len = len;
cpu_memory_rw_debug(cpu_single_env, data, dev->data, write_len, 0);
ret = do_write(dev->fd, dev->data, write_len);
if(ret < write_len) {
XLOG("nand_dev_write_file, write failed: %s\n", strerror(errno));
break;
}
data += write_len;
len -= write_len;
}
return total_len - len;
}
static uint32_t nand_dev_erase_file(nand_dev *dev, uint64_t addr, uint32_t total_len)
{
uint32_t len = total_len;
size_t write_len = dev->erase_size;
int ret;
lseek(dev->fd, addr, SEEK_SET);
memset(dev->data, 0xff, dev->erase_size);
while(len > 0) {
if(len < write_len)
write_len = len;
ret = do_write(dev->fd, dev->data, write_len);
if(ret < write_len) {
XLOG( "nand_dev_write_file, write failed: %s\n", strerror(errno));
break;
}
len -= write_len;
}
return total_len - len;
}
/* this is a huge hack required to make the PowerPC emulator binary usable
* on Mac OS X. If you define this function as 'static', the emulated kernel
* will panic when attempting to mount the /data partition.
*
* worse, if you do *not* define the function as static on Linux-x86, the
* emulated kernel will also panic !?
*
* I still wonder if this is a compiler bug, or due to some nasty thing the
* emulator does with CPU registers during execution of the translated code.
*/
#if !(defined __APPLE__ && defined __powerpc__)
static
#endif
uint32_t nand_dev_do_cmd(nand_dev_state *s, uint32_t cmd)
{
uint32_t size;
uint64_t addr;
nand_dev *dev;
addr = s->addr_low | ((uint64_t)s->addr_high << 32);
size = s->transfer_size;
if(s->dev >= nand_dev_count)
return 0;
dev = nand_devs + s->dev;
switch(cmd) {
case NAND_CMD_GET_DEV_NAME:
if(size > dev->devname_len)
size = dev->devname_len;
cpu_memory_rw_debug(cpu_single_env, s->data, dev->devname, size, 1);
return size;
case NAND_CMD_READ:
if(addr >= dev->size)
return 0;
if(size + addr > dev->size)
size = dev->size - addr;
if(dev->fd >= 0)
return nand_dev_read_file(dev, s->data, addr, size);
cpu_memory_rw_debug(cpu_single_env,s->data, &dev->data[addr], size, 1);
return size;
case NAND_CMD_WRITE:
if(dev->flags & NAND_DEV_FLAG_READ_ONLY)
return 0;
if(addr >= dev->size)
return 0;
if(size + addr > dev->size)
size = dev->size - addr;
if(dev->fd >= 0)
return nand_dev_write_file(dev, s->data, addr, size);
cpu_memory_rw_debug(cpu_single_env,s->data, &dev->data[addr], size, 0);
return size;
case NAND_CMD_ERASE:
if(dev->flags & NAND_DEV_FLAG_READ_ONLY)
return 0;
if(addr >= dev->size)
return 0;
if(size + addr > dev->size)
size = dev->size - addr;
if(dev->fd >= 0)
return nand_dev_erase_file(dev, addr, size);
memset(&dev->data[addr], 0xff, size);
return size;
case NAND_CMD_BLOCK_BAD_GET: // no bad block support
return 0;
case NAND_CMD_BLOCK_BAD_SET:
if(dev->flags & NAND_DEV_FLAG_READ_ONLY)
return 0;
return 0;
default:
cpu_abort(cpu_single_env, "nand_dev_do_cmd: Bad command %x\n", cmd);
return 0;
}
}
/* I/O write */
static void nand_dev_write(void *opaque, target_phys_addr_t offset, uint32_t value)
{
nand_dev_state *s = (nand_dev_state *)opaque;
switch (offset) {
case NAND_DEV:
s->dev = value;
if(s->dev >= nand_dev_count) {
cpu_abort(cpu_single_env, "nand_dev_write: Bad dev %x\n", value);
}
break;
case NAND_ADDR_HIGH:
s->addr_high = value;
break;
case NAND_ADDR_LOW:
s->addr_low = value;
break;
case NAND_TRANSFER_SIZE:
s->transfer_size = value;
break;
case NAND_DATA:
s->data = value;
break;
case NAND_COMMAND:
s->result = nand_dev_do_cmd(s, value);
break;
default:
cpu_abort(cpu_single_env, "nand_dev_write: Bad offset %x\n", offset);
break;
}
}
/* I/O read */
static uint32_t nand_dev_read(void *opaque, target_phys_addr_t offset)
{
nand_dev_state *s = (nand_dev_state *)opaque;
nand_dev *dev;
switch (offset) {
case NAND_VERSION:
return NAND_VERSION_CURRENT;
case NAND_NUM_DEV:
return nand_dev_count;
case NAND_RESULT:
return s->result;
}
if(s->dev >= nand_dev_count)
return 0;
dev = nand_devs + s->dev;
switch (offset) {
case NAND_DEV_FLAGS:
return dev->flags;
case NAND_DEV_NAME_LEN:
return dev->devname_len;
case NAND_DEV_PAGE_SIZE:
return dev->page_size;
case NAND_DEV_EXTRA_SIZE:
return dev->extra_size;
case NAND_DEV_ERASE_SIZE:
return dev->erase_size;
case NAND_DEV_SIZE_LOW:
return (uint32_t)dev->size;
case NAND_DEV_SIZE_HIGH:
return (uint32_t)(dev->size >> 32);
default:
cpu_abort(cpu_single_env, "nand_dev_read: Bad offset %x\n", offset);
return 0;
}
}
static CPUReadMemoryFunc *nand_dev_readfn[] = {
nand_dev_read,
nand_dev_read,
nand_dev_read
};
static CPUWriteMemoryFunc *nand_dev_writefn[] = {
nand_dev_write,
nand_dev_write,
nand_dev_write
};
/* initialize the QFB device */
void nand_dev_init(uint32_t base)
{
int iomemtype;
static int instance_id = 0;
nand_dev_state *s;
s = (nand_dev_state *)qemu_mallocz(sizeof(nand_dev_state));
iomemtype = cpu_register_io_memory(nand_dev_readfn, nand_dev_writefn, s);
cpu_register_physical_memory(base, 0x00000fff, iomemtype);
s->base = base;
register_savevm( "nand_dev", instance_id++, NAND_DEV_STATE_SAVE_VERSION,
nand_dev_state_save, nand_dev_state_load, s);
}
static int arg_match(const char *a, const char *b, size_t b_len)
{
while(*a && b_len--) {
if(*a++ != *b++)
return 0;
}
return b_len == 0;
}
void nand_add_dev(const char *arg)
{
uint64_t dev_size = 0;
const char *next_arg;
const char *value;
size_t arg_len, value_len;
nand_dev *new_devs, *dev;
char *devname = NULL;
size_t devname_len = 0;
char *initfilename = NULL;
char *rwfilename = NULL;
int initfd = -1;
int rwfd = -1;
int read_only = 0;
int pad;
ssize_t read_size;
uint32_t page_size = 2048;
uint32_t extra_size = 64;
uint32_t erase_pages = 64;
while(arg) {
next_arg = strchr(arg, ',');
value = strchr(arg, '=');
if(next_arg != NULL) {
arg_len = next_arg - arg;
next_arg++;
if(value >= next_arg)
value = NULL;
}
else
arg_len = strlen(arg);
if(value != NULL) {
size_t new_arg_len = value - arg;
value_len = arg_len - new_arg_len - 1;
arg_len = new_arg_len;
value++;
}
else
value_len = 0;
if(devname == NULL) {
if(value != NULL)
goto bad_arg_and_value;
devname_len = arg_len;
devname = malloc(arg_len);
if(devname == NULL)
goto out_of_memory;
memcpy(devname, arg, arg_len);
}
else if(value == NULL) {
if(arg_match("readonly", arg, arg_len)) {
read_only = 1;
}
else {
XLOG("bad arg: %.*s\n", arg_len, arg);
exit(1);
}
}
else {
if(arg_match("size", arg, arg_len)) {
char *ep;
dev_size = strtoull(value, &ep, 0);
if(ep != value + value_len)
goto bad_arg_and_value;
}
else if(arg_match("pagesize", arg, arg_len)) {
char *ep;
page_size = strtoul(value, &ep, 0);
if(ep != value + value_len)
goto bad_arg_and_value;
}
else if(arg_match("extrasize", arg, arg_len)) {
char *ep;
extra_size = strtoul(value, &ep, 0);
if(ep != value + value_len)
goto bad_arg_and_value;
}
else if(arg_match("erasepages", arg, arg_len)) {
char *ep;
erase_pages = strtoul(value, &ep, 0);
if(ep != value + value_len)
goto bad_arg_and_value;
}
else if(arg_match("initfile", arg, arg_len)) {
initfilename = malloc(value_len + 1);
if(initfilename == NULL)
goto out_of_memory;
memcpy(initfilename, value, value_len);
initfilename[value_len] = '\0';
}
else if(arg_match("file", arg, arg_len)) {
rwfilename = malloc(value_len + 1);
if(rwfilename == NULL)
goto out_of_memory;
memcpy(rwfilename, value, value_len);
rwfilename[value_len] = '\0';
}
else {
goto bad_arg_and_value;
}
}
arg = next_arg;
}
if (rwfilename == NULL) {
/* we create a temporary file to store everything */
TempFile* tmp = tempfile_create();
if (tmp == NULL) {
XLOG("could not create temp file for %.*s NAND disk image: %s",
devname_len, devname, strerror(errno));
exit(1);
}
rwfilename = (char*) tempfile_path(tmp);
if (VERBOSE_CHECK(init))
dprint( "mapping '%.*s' NAND image to %s", devname_len, devname, rwfilename);
}
if(rwfilename) {
rwfd = open(rwfilename, O_BINARY | (read_only ? O_RDONLY : O_RDWR));
if(rwfd < 0 && read_only) {
XLOG("could not open file %s, %s\n", rwfilename, strerror(errno));
exit(1);
}
/* this could be a writable temporary file. use atexit_close_fd to ensure
* that it is properly cleaned up at exit on Win32
*/
if (!read_only)
atexit_close_fd(rwfd);
}
if(initfilename) {
initfd = open(initfilename, O_BINARY | O_RDONLY);
if(initfd < 0) {
XLOG("could not open file %s, %s\n", initfilename, strerror(errno));
exit(1);
}
if(dev_size == 0) {
dev_size = lseek(initfd, 0, SEEK_END);
lseek(initfd, 0, SEEK_SET);
}
}
new_devs = realloc(nand_devs, sizeof(nand_devs[0]) * (nand_dev_count + 1));
if(new_devs == NULL)
goto out_of_memory;
nand_devs = new_devs;
dev = &new_devs[nand_dev_count];
dev->page_size = page_size;
dev->extra_size = extra_size;
dev->erase_size = erase_pages * (page_size + extra_size);
pad = dev_size % dev->erase_size;
if (pad != 0) {
dev_size += (dev->erase_size - pad);
D("rounding devsize up to a full eraseunit, now %llx\n", dev_size);
}
dev->devname = devname;
dev->devname_len = devname_len;
dev->size = dev_size;
dev->data = malloc(dev->erase_size);
if(dev->data == NULL)
goto out_of_memory;
dev->flags = read_only ? NAND_DEV_FLAG_READ_ONLY : 0;
if (initfd >= 0) {
do {
read_size = do_read(initfd, dev->data, dev->erase_size);
if(read_size < 0) {
XLOG("could not read file %s, %s\n", initfilename, strerror(errno));
exit(1);
}
if(do_write(rwfd, dev->data, read_size) != read_size) {
XLOG("could not write file %s, %s\n", initfilename, strerror(errno));
exit(1);
}
} while(read_size == dev->erase_size);
close(initfd);
}
dev->fd = rwfd;
nand_dev_count++;
return;
out_of_memory:
XLOG("out of memory\n");
exit(1);
bad_arg_and_value:
XLOG("bad arg: %.*s=%.*s\n", arg_len, arg, value_len, value);
exit(1);
}