/*
 * flash memory
 */

#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"../port/error.h"

#include "../port/flashif.h"

typedef struct Flashtype Flashtype;
struct Flashtype {
	char*	name;
	int	(*reset)(Flash*);
	Flashtype* next;
};

enum {
	Nbanks = 2,
};

static struct
{
	Flash*	card[Nbanks];	/* actual card type, reset for access */
	Flashtype* types;	/* possible card types */
}flash;

enum{
	Qtopdir,
	Qflashdir,
	Qdata,
	Qctl,
};

#define	TYPE(q)	((ulong)(q) & 0xFF)
#define	PART(q)	((ulong)(q)>>8)
#define	QID(p,t)	(((p)<<8) | (t))

static	Flashregion*	flashregion(Flash*, ulong);
static	char*	flashnewpart(Flash*, char*, ulong, ulong);
static	ulong	flashaddr(Flash*, Flashpart*, char*);
static	void	protect(Flash*, ulong);
static	void	eraseflash(Flash*, Flashregion*, ulong);
static	long	readflash(Flash*, void*, long, int);
static	long	writeflash(Flash*, long, void*,int);

static char Eprotect[] = "flash region protected";

static int
flash2gen(Chan *c, ulong p, Dir *dp)
{
	Flashpart *fp;
	Flash *f;
	Qid q;
	int mode;

	f = flash.card[c->dev];
	fp = &f->part[PART(p)];
	if(fp->name == nil)
		return 0;
	mkqid(&q, p, 0, QTFILE);
	switch(TYPE(p)){
	case Qdata:
		mode = 0660;
		if(f->write == nil)
			mode = 0440;
		devdir(c, q, fp->name, fp->end-fp->start, eve, mode, dp);
		return 1;
	case Qctl:
		snprint(up->genbuf, sizeof(up->genbuf), "%sctl", fp->name);
		/* no harm in letting everybody read the ctl files */
		devdir(c, q, up->genbuf, 0, eve, 0664, dp);
		return 1;
	default:
		return -1;
	}
}

static int
flashgen(Chan *c, char*, Dirtab*, int, int s, Dir *dp)
{
	Qid q;
	char *n;

	if(s == DEVDOTDOT){
		mkqid(&q, QID(0, Qtopdir), 0, QTDIR);
		n = "#F";
		if(c->dev != 0){
			snprint(up->genbuf, sizeof up->genbuf, "#F%ld", c->dev);
			n = up->genbuf;
		}
		devdir(c, q, n, 0, eve, 0555, dp);
		return 1;
	}
	switch(TYPE(c->qid.path)){
	case Qtopdir:
		if(s != 0)
			break;
		mkqid(&q, QID(0, Qflashdir), 0, QTDIR);
		n = "flash";
		if(c->dev != 0){
			snprint(up->genbuf, sizeof up->genbuf, "flash%ld",
				c->dev);
			n = up->genbuf;
		}
		devdir(c, q, n, 0, eve, 0555, dp);
		return 1;
	case Qflashdir:
		if(s >= 2*nelem(flash.card[c->dev]->part))
			return -1;
		return flash2gen(c, QID(s>>1, s&1?Qctl:Qdata), dp);
	case Qctl:
	case Qdata:
		return flash2gen(c, (ulong)c->qid.path, dp);
	}
	return -1;
}
		
static void
flashreset(void)
{
	Flash *f;
	Flashtype *t;
	char *e;
	int bank;

	for(bank = 0; bank < Nbanks; bank++){
		f = malloc(sizeof(*f));
		if(f == nil){
			print("#F%d: can't allocate Flash data\n", bank);
			return;
		}
		f->cmask = ~(ulong)0;
		if(archflashreset(bank, f) < 0 || f->type == nil ||
		    f->addr == nil){
			free(f);
			return;
		}
		for(t = flash.types; t != nil; t = t->next)
			if(strcmp(f->type, t->name) == 0)
				break;
		if(t == nil){
			iprint("#F%d: no flash driver for type %s (addr %p)\n",
				bank, f->type, f->addr);
			free(f);
			return;
		}
		f->reset = t->reset;
		f->protect = 1;
		if(f->reset(f) == 0){
			flash.card[bank] = f;
			iprint("#F%d: %s addr %#p len %lud width %d interleave %d\n",
//				bank, f->type, PADDR(f->addr), f->size,
				bank, f->type, f->addr, f->size,
				f->width, f->interleave);
			e = flashnewpart(f, "flash", 0, f->size);
			if(e != nil)
				panic("#F%d: couldn't init table: %s", bank, e);
		}else
			iprint("#F%d: %#p: reset failed (%s)\n",
				bank, f->addr, f->type);
	}
}

static Chan*
flashattach(char *spec)
{
	Flash *f;
	int bank;
	Chan *c;

	bank = strtol(spec, nil, 0);
	if(bank < 0 || bank >= Nbanks ||
	   (f = flash.card[bank]) == nil ||
	   f->attach != nil && f->attach(f) < 0)
		error(Enodev);
	c = devattach('F', spec);
	c->dev = bank;
	return c;
}

static Walkqid*
flashwalk(Chan *c, Chan *nc, char **name, int nname)
{
	return devwalk(c, nc, name, nname, nil, 0, flashgen);
}

static int
flashstat(Chan *c, uchar *dp, int n)
{
	return devstat(c, dp, n, nil, 0, flashgen);
}

static Chan*
flashopen(Chan *c, int omode)
{
	omode = openmode(omode);
	switch(TYPE(c->qid.path)){
	case Qdata:
	case Qctl:
		if(flash.card[c->dev] == nil)
			error(Enodev);
		break;
	}
	return devopen(c, omode, nil, 0, flashgen);
}

static void	 
flashclose(Chan*)
{
}

static long	 
flashread(Chan *c, void *buf, long n, vlong offset)
{
	Flash *f;
	Flashpart *fp;
	Flashregion *r;
	int i;
	ulong start, end;
	char *s, *o;

	if(c->qid.type & QTDIR)
		return devdirread(c, buf, n, nil, 0, flashgen);

	f = flash.card[c->dev];
	fp = &f->part[PART(c->qid.path)];
	if(fp->name == nil)
		error(Egreg);
	switch(TYPE(c->qid.path)){
	case Qdata:
		offset += fp->start;
		if(offset >= fp->end)
			return 0;
		if(offset+n > fp->end)
			n = fp->end - offset;
		n = readflash(f, buf, offset, n);
		if(n < 0)
			error(Eio);
		return n;
	case Qctl:
		s = malloc(READSTR);
		if(s == nil)
			error(Enomem);
		if(waserror()){
			free(s);
			nexterror();
		}
		o = seprint(s, s+READSTR, "%#2.2ux %#4.4ux %d %q\n",
			f->id, f->devid, f->width, f->sort!=nil? f->sort: "nor");
		for(i=0; i<f->nr; i++){
			r = &f->regions[i];
			if(r->start < fp->end && fp->start < r->end){
				start = r->start;
				if(fp->start > start)
					start = fp->start;
				end = r->end;
				if(fp->end < end)
					end = fp->end;
				o = seprint(o, s+READSTR, "%#8.8lux %#8.8lux %#8.8lux",
					start, end, r->erasesize);
				if(r->pagesize)
					o = seprint(o, s+READSTR, " %#8.8lux",
						r->pagesize);
				o = seprint(o, s+READSTR, "\n");
			}
		}
		n = readstr(offset, buf, n, s);
		poperror();
		free(s);
		return n;
	}
	error(Egreg);
	return 0;		/* not reached */
}

enum {
	CMerase,
	CMadd,
	CMremove,
	CMsync,
	CMprotectboot,
};

static Cmdtab flashcmds[] = {
	{CMerase,	"erase",	2},
	{CMadd,		"add",		0},
	{CMremove,	"remove",	2},
	{CMsync,	"sync",		0},
	{CMprotectboot,	"protectboot",	0},
};

static long	 
flashwrite(Chan *c, void *buf, long n, vlong offset)
{
	Cmdbuf *cb;
	Cmdtab *ct;
	ulong addr, start, end;
	char *e;
	Flashpart *fp;
	Flashregion *r;
	Flash *f;

	f = flash.card[c->dev];
	fp = &f->part[PART(c->qid.path)];
	if(fp->name == nil)
		error(Egreg);
	switch(TYPE(c->qid.path)){
	case Qdata:
		if(f->write == nil)
			error(Eperm);
		offset += fp->start;
		if(offset >= fp->end)
			return 0;
		if(offset+n > fp->end)
			n = fp->end - offset;
		n = writeflash(f, offset, buf, n);
		if(n < 0)
			error(Eio);
		return n;
	case Qctl:
		cb = parsecmd(buf, n);
		if(waserror()){
			free(cb);
			nexterror();
		}
		ct = lookupcmd(cb, flashcmds, nelem(flashcmds));
		switch(ct->index){
		case CMerase:
			if(strcmp(cb->f[1], "all") != 0){
				addr = flashaddr(f, fp, cb->f[1]);
				r = flashregion(f, addr);
				if(r == nil)
					error("nonexistent flash region");
				if(addr%r->erasesize != 0)
					error("invalid erase block address");
				eraseflash(f, r, addr);
			}else if(fp->start == 0 && fp->end == f->size &&
			    f->eraseall != nil){
				eraseflash(f, nil, 0);
			}else{
				for(addr = fp->start; addr < fp->end;
				    addr += r->erasesize){
					r = flashregion(f, addr);
					if(r == nil)
						error("nonexistent flash region");
					if(addr%r->erasesize != 0)
						error("invalid erase block address");
					eraseflash(f, r, addr);
				}
			}
			break;
		case CMadd:
			if(cb->nf < 3)
				error(Ebadarg);
			start = flashaddr(f, fp, cb->f[2]);
			if(cb->nf > 3 && strcmp(cb->f[3], "end") != 0)
				end = flashaddr(f, fp, cb->f[3]);
			else
				end = fp->end;
			if(start > end || start >= fp->end || end > fp->end)
				error(Ebadarg);
			e = flashnewpart(f, cb->f[1], start, end);
			if(e != nil)
				error(e);
			break;
		case CMremove:
			/* TO DO */
			break;
		case CMprotectboot:
			if(cb->nf > 1 && strcmp(cb->f[1], "off") == 0)
				f->protect = 0;
			else
				f->protect = 1;
			break;
		case CMsync:
			/* TO DO? */
			break;
		default:
			error(Ebadarg);
		}
		poperror();
		free(cb);
		return n;
	}
	error(Egreg);
	return 0;		/* not reached */
}

static char*
flashnewpart(Flash *f, char *name, ulong start, ulong end)
{
	Flashpart *fp, *empty;
	int i;

	empty = nil;
	for(i = 0; i < nelem(f->part); i++){
		fp = &f->part[i];
		if(fp->name == nil){
			if(empty == nil)
				empty = fp;
		}else if(strcmp(fp->name, name) == 0)
			return Eexist;
	}
	if((fp = empty) == nil)
		return "partition table full";
//	fp->name = nil;
	kstrdup(&fp->name, name);
	if(fp->name == nil)
		return Enomem;
	fp->start = start;
	fp->end = end;
	return nil;
}

static ulong
flashaddr(Flash *f, Flashpart *fp, char *s)
{
	Flashregion *r;
	ulong addr;

	addr = strtoul(s, &s, 0);
	if(*s)
		error(Ebadarg);
	if(fp->name == nil)
		error("partition removed");
	addr += fp->start;
	r = flashregion(f, addr);
	if(r != nil && addr%r->erasesize != 0)
		error("invalid erase unit address");
	if(addr < fp->start || addr > fp->end || addr > f->size)
		error(Ebadarg);
	return addr;
}

static Flashregion*
flashregion(Flash *f, ulong a)
{
	int i;
	Flashregion *r;

	for(i=0; i<f->nr; i++){
		r = &f->regions[i];
		if(r->start <= a && a < r->end)
			return r;
	}
	return nil;
}

Dev flashdevtab = {
	'F',
	"flash",

	flashreset,
	devinit,
	devshutdown,
	flashattach,
	flashwalk,
	flashstat,
	flashopen,
	devcreate,
	flashclose,
	flashread,
	devbread,
	flashwrite,
	devbwrite,
	devremove,
	devwstat,
};

/*
 * called by flash card types named in link section (eg, flashamd.c)
 */
void
addflashcard(char *name, int (*reset)(Flash*))
{
	Flashtype *f, **l;

	f = (Flashtype*)malloc(sizeof(*f));
	if(f == nil)
		error(Enomem);
	f->name = name;
	f->reset = reset;
	f->next = nil;
	for(l = &flash.types; *l != nil; l = &(*l)->next)
		;
	*l = f;
}

static long
readflash(Flash *f, void *buf, long offset, int n)
{
	int r, width, wmask;
	uchar tmp[16];
	uchar *p;
	ulong o;

	if(offset < 0 || offset+n > f->size)
		error(Ebadarg);
	qlock(f);
	if(waserror()){
		qunlock(f);
		nexterror();
	}
	if(f->read != nil){
		width = f->width;
		wmask = width-1;
		p = buf;
		if(offset & wmask) {
			o = offset & ~wmask;
			if(f->read(f, o, (ulong*)tmp, width) < 0)
				error(Eio);
			memmove(tmp, (uchar*)f->addr + o, width);
			for(; n > 0 && offset & wmask; n--)
				*p++ = tmp[offset++ & wmask];
		}
		r = n & wmask;
		n &= ~wmask;
		if(n){
			if(f->read(f, offset, (ulong*)p, n) < 0)
				error(Eio);
			offset += n;
			p += n;
		}
		if(r){
			if(f->read(f, offset, (ulong*)tmp, width))
				error(Eio);
			memmove(p, tmp, r);
		}
	}else
		/* assumes hardware supports byte access */
		memmove(buf, (uchar*)f->addr+offset, n);
	poperror();
	qunlock(f);
	return n;
}

static long
writeflash(Flash *f, long offset, void *buf, int n)
{
	uchar tmp[16];
	uchar *p;
	ulong o;
	int r, width, wmask;
	Flashregion *rg;

	if(f->write == nil || offset < 0 || offset+n > f->size)
		error(Ebadarg);
	rg = flashregion(f, offset);
	if(f->protect && rg != nil && rg->start == 0 && offset < rg->erasesize)
		error(Eprotect);
	width = f->width;
	wmask = width-1;
	qlock(f);
	archflashwp(f, 0);
	if(waserror()){
		archflashwp(f, 1);
		qunlock(f);
		nexterror();
	}
	p = buf;
	if(offset&wmask){
		o = offset & ~wmask;
		if(f->read != nil){
			if(f->read(f, o, tmp, width) < 0)
				error(Eio);
		}else
			memmove(tmp, (uchar*)f->addr+o, width);
		for(; n > 0 && offset&wmask; n--)
			tmp[offset++&wmask] = *p++;
		if(f->write(f, o, tmp, width) < 0)
			error(Eio);
	}
	r = n&wmask;
	n &= ~wmask;
	if(n){
		if(f->write(f, offset, p, n) < 0)
			error(Eio);
		offset += n;
		p += n;
	}
	if(r){
		if(f->read != nil){
			if(f->read(f, offset, tmp, width) < 0)
				error(Eio);
		}else
			memmove(tmp, (uchar*)f->addr+offset, width);
		memmove(tmp, p, r);
		if(f->write(f, offset, tmp, width) < 0)
			error(Eio);
	}
	poperror();
	archflashwp(f, 1);
	qunlock(f);
	return n;
}

static void
eraseflash(Flash *f, Flashregion *r, ulong addr)
{
	int rv;

	if(f->protect && r != nil && r->start == 0 && addr < r->erasesize)
		error(Eprotect);
	qlock(f);
	archflashwp(f, 0);
	if(waserror()){
		archflashwp(f, 1);
		qunlock(f);
		nexterror();
	}
	if(r == nil){
		if(f->eraseall != nil)
			rv = f->eraseall(f);
		else
			rv = -1;
	}else
		rv = f->erasezone(f, r, addr);
	if(rv < 0)
		error(Eio);
	poperror();
	archflashwp(f, 1);
	qunlock(f);
}

/*
 * flash access taking width and interleave into account
 */
int
flashget(Flash *f, ulong a)
{
	switch(f->width){
	default:
		return ((uchar*)f->addr)[a<<f->bshift];
	case 2:
		return ((ushort*)f->addr)[a];
	case 4:
		return ((ulong*)f->addr)[a];
	}
}

void
flashput(Flash *f, ulong a, int v)
{
	switch(f->width){
	default:
		((uchar*)f->addr)[a<<f->bshift] = v;
		break;
	case 2:
		((ushort*)f->addr)[a] = v;
		break;
	case 4:
		((ulong*)f->addr)[a] = v;
		break;
	}
	coherence();
}