plan 9 kernel history: overview | file list | diff list

2001/0605/bitsy/devflash.c (diff list | history)

bitsy/devflash.c on 2000/1031
2000/1031    
#include	"u.h" 
#include	"../port/lib.h" 
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
#include	"io.h" 
#include	"../port/error.h"
2000/1107    
/* 
 *  on the bitsy, all 32 bit accesses to flash are mapped to two 16 bit 
 *  accesses, one to the low half of the chip and the other to the high 
 *  half.  Therefore for all command accesses, ushort indices in the 
 *  manuals turn into ulong indices in our code.  Also, by copying all 
 *  16 bit commands to both halves of a 32 bit command, we erase 2 
 *  sectors for each request erase request. 
 */
2000/1117    
#define mirror(x) (((x)<<16)|(x)) 
 
/* this defines a contiguous set of erase blocks of one size */ 
typedef struct FlashRegion FlashRegion; 
struct FlashRegion
2000/1107    
{
2000/1117    
	ulong	addr;		/* start of region */ 
	ulong	end;		/* end of region + 1 */ 
	ulong	n;		/* number of blocks */ 
	ulong	size;		/* size of each block */
2000/1107    
};
2000/1117    
/* this defines a particular access algorithm */ 
typedef struct FlashAlg FlashAlg; 
struct FlashAlg
2000/1107    
{
2000/1117    
	int	id; 
	char	*name; 
	void	(*identify)(void);	/* identify device */ 
	void	(*erase)(ulong);	/* erase a region */ 
	void	(*write)(void*, long, ulong);	/* write a region */
2000/1107    
};
2000/1117    
static void	ise_id(void); 
static void	ise_erase(ulong); 
static void	ise_write(void*, long, ulong); 
 
static void	afs_id(void); 
static void	afs_erase(ulong); 
static void	afs_write(void*, long, ulong);
2000/1207    
static ulong	blockstart(ulong); 
static ulong	blockend(ulong);
2000/1117    
FlashAlg falg[] =
2000/1107    
{
2000/1117    
	{ 1,	"Intel/Sharp Extended",	ise_id, ise_erase, ise_write	}, 
	{ 2,	"AMD/Fujitsu Standard",	afs_id, afs_erase, afs_write	},
2000/1111    
};
2000/1117    
struct 
{ 
	RWlock; 
	ulong		*p; 
	ushort		algid;		/* access algorithm */ 
	FlashAlg	*alg; 
	ushort		manid;		/* manufacturer id */ 
	ushort		devid;		/* device id */ 
	ulong		size;		/* size in bytes */ 
	int		wbsize;		/* size of write buffer */  
	ulong		nr;		/* number of regions */ 
	uchar		bootprotect; 
	FlashRegion	r[32]; 
} flash;
2000/1111    
2000/1209    
enum 
{ 
	Maxwchunk=	1024,	/* maximum chunk written by one call to falg->write */ 
};
2000/1117    
/* 
 *  common flash interface 
 */ 
static uchar 
cfigetc(int off)
2000/1111    
{
2000/1117    
	uchar rv;
2000/1111    
2000/1117    
	flash.p[0x55] = mirror(0x98); 
	rv = flash.p[off]; 
	flash.p[0x55] = mirror(0xFF); 
	return rv;
2000/1111    
}
2000/1117    
static ushort 
cfigets(int off)
2000/1111    
{
2000/1117    
	return (cfigetc(off+1)<<8)|cfigetc(off);
2000/1111    
}
2000/1117    
static ulong 
cfigetl(int off) 
{ 
	return (cfigetc(off+3)<<24)|(cfigetc(off+2)<<16)| 
		(cfigetc(off+1)<<8)|cfigetc(off); 
} 
 
static void 
cfiquery(void) 
{ 
	uchar q, r, y; 
	ulong x, addr; 
 
	q = cfigetc(0x10); 
	r = cfigetc(0x11); 
	y = cfigetc(0x12); 
	if(q != 'Q' || r != 'R' || y != 'Y'){ 
		print("cfi query failed: %ux %ux %ux\n", q, r, y); 
		return; 
	} 
	flash.algid = cfigetc(0x13); 
	flash.size = 1<<(cfigetc(0x27)+1); 
	flash.wbsize = 1<<(cfigetc(0x2a)+1); 
	flash.nr = cfigetc(0x2c); 
	if(flash.nr > nelem(flash.r)){ 
		print("cfi reports > %d regions\n", nelem(flash.r)); 
		flash.nr = nelem(flash.r); 
	} 
	addr = 0; 
	for(q = 0; q < flash.nr; q++){ 
		x = cfigetl(q+0x2d); 
		flash.r[q].size = 2*256*(x>>16); 
		flash.r[q].n = (x&0xffff)+1; 
		flash.r[q].addr = addr; 
		addr += flash.r[q].size*flash.r[q].n; 
		flash.r[q].end = addr; 
	} 
}
2000/1111    
/* 
 *  flash device interface 
 */ 
 
enum 
{
2000/1207    
	Qtopdir, 
	Q2nddir, 
	Qfctl,
2000/1213    
	Qfdata,
2000/1207    
 
	Maxpart= 8,
2000/1111    
};
2000/1207    
 
typedef struct FPart FPart; 
struct FPart 
{
2001/0529    
	char	*name;
2000/1207    
	ulong	start; 
	ulong	end;
2000/1111    
};
2000/1207    
static FPart	part[Maxpart];
2000/1111    
2000/1207    
#define FQID(p,q)	((p)<<8|(q)) 
#define FTYPE(q)	((q) & 0xff) 
#define FPART(q)	(&part[(q) >>8]) 
 
static int
2001/0529    
gen(Chan *c, char*, Dirtab*, int, int i, Dir *dp)
2000/1207    
{ 
	Qid q;
2001/0529    
	char buf[KNAMELEN];
2000/1207    
	FPart *fp; 
 
	q.vers = 0; 
 
	/* top level directory contains the name of the network */
2001/0529    
	if(c->qid.path == Qtopdir){
2000/1207    
		switch(i){ 
		case DEVDOTDOT:
2001/0529    
			q.path = Qtopdir; 
			q.type = QTDIR; 
			devdir(c, q, "#F", 0, eve, DMDIR|0555, dp);
2000/1207    
			break; 
		case 0:
2001/0529    
			q.path = Q2nddir; 
			q.type = QTDIR; 
			devdir(c, q, "flash", 0, eve, DMDIR|0555, dp);
2000/1207    
			break; 
		default: 
			return -1; 
		} 
		return 1; 
	}
2000/1213    
	/* second level contains all partitions and their control files */
2000/1207    
	switch(i) { 
	case DEVDOTDOT:
2001/0529    
		q.path = Qtopdir; 
		q.type = QTDIR; 
		devdir(c, q, "#F", 0, eve, DMDIR|0555, dp);
2000/1207    
		break; 
	default:
2000/1213    
		if(i >= 2*Maxpart)
2000/1207    
			return -1;
2000/1213    
		fp = &part[i>>1];
2001/0529    
		if(fp->name == nil)
2000/1207    
			return 0;
2000/1213    
		if(i & 1){ 
			q.path = FQID(i>>1, Qfdata);
2001/0529    
			q.type = QTFILE;
2000/1213    
			devdir(c, q, fp->name, fp->end-fp->start, eve, 0660, dp); 
		} else { 
			snprint(buf, sizeof(buf), "%sctl", fp->name); 
			q.path = FQID(i>>1, Qfctl);
2001/0529    
			q.type = QTFILE;
2000/1213    
			devdir(c, q, buf, 0, eve, 0660, dp); 
		}
2000/1207    
		break; 
	} 
	return 1; 
} 
 
static FPart* 
findpart(char *name) 
{ 
	int i; 
 
	for(i = 0; i < Maxpart; i++)
2001/0605    
		if(part[i].name != nil && strcmp(name, part[i].name) == 0)
2000/1207    
			break; 
	if(i >= Maxpart) 
		return nil; 
	return &part[i]; 
} 
 
static void
2000/1213    
addpart(FPart *fp, char *name, ulong start, ulong end)
2000/1207    
{ 
	int i;
2000/1213    
	if(fp == nil){ 
		if(start >= flash.size || end > flash.size) 
			error(Ebadarg); 
	} else { 
		start += fp->start; 
		end += fp->start; 
		if(start >= fp->end || end > fp->end) 
			error(Ebadarg); 
	}
2000/1207    
	if(blockstart(start) != start) 
		error("must start on erase boundary"); 
	if(blockstart(end) != end && end != flash.size) 
		error("must end on erase boundary");
2000/1213    
2000/1207    
	fp = findpart(name); 
	if(fp != nil) 
		error(Eexist); 
	for(i = 0; i < Maxpart; i++)
2001/0605    
		if(part[i].name == nil)
2000/1207    
			break; 
	if(i == Maxpart) 
		error("no more partitions"); 
	fp = &part[i];
2001/0529    
	kstrdup(&fp->name, name);
2000/1207    
	fp->start = start; 
	fp->end = end; 
} 
 
static void
2000/1213    
rempart(FPart *fp)
2000/1207    
{
2001/0529    
	char *p; 
 
	p = fp->name; 
	fp->name = nil; 
	free(p);
2000/1207    
}
2000/1111    
void 
flashinit(void) 
{
2000/1117    
	int i; 
 
	flash.p = (ulong*)FLASHZERO;
2000/1111    
	cfiquery();
2000/1117    
	for(i = 0; i < nelem(falg); i++) 
		if(flash.algid == falg[i].id){ 
			flash.alg = &falg[i]; 
			(*flash.alg->identify)(); 
			break; 
		} 
	flash.bootprotect = 1;
2000/1207    
2000/1213    
	addpart(nil, "flash", 0, flash.size);
2000/1111    
} 
 
static Chan* 
flashattach(char* spec) 
{
2000/1117    
	return devattach('F', spec);
2000/1111    
}
2001/0529    
static Walkqid* 
flashwalk(Chan *c, Chan *nc, char **name, int nname)
2000/1111    
{
2001/0529    
	return devwalk(c, nc, name, nname, nil, 0, gen);
2000/1111    
}
2001/0529    
static int	  
flashstat(Chan *c, uchar *db, int n)
2000/1111    
{
2001/0529    
	return devstat(c, db, n, nil, 0, gen);
2000/1111    
} 
 
static Chan* 
flashopen(Chan* c, int omode) 
{ 
	omode = openmode(omode); 
	if(strcmp(up->user, eve)!=0) 
		error(Eperm);
2000/1207    
	return devopen(c, omode, nil, 0, gen);
2000/1111    
} 
 
static void	  
flashclose(Chan*) 
{ 
}
2000/1213    
static long 
flashctlread(FPart *fp, void* a, long n, vlong off)
2000/1111    
{
2000/1117    
	char *buf, *p, *e; 
	int i;
2000/1213    
	ulong addr, end;
2000/1117    
2000/1213    
	buf = smalloc(1024); 
	e = buf + 1024; 
	p = seprint(buf, e, "0x%-9lux 0x%-9lux 0x%-9lux 0x%-9lux\n", fp->end-fp->start, 
		flash.wbsize, flash.manid, flash.devid); 
	addr = fp->start; 
	for(i = 0; i < flash.nr && addr < fp->end; i++) 
		if(flash.r[i].addr <= addr && flash.r[i].end > addr){ 
			if(fp->end <= flash.r[i].end) 
				end = fp->end; 
			else 
				end = flash.r[i].end; 
			p = seprint(p, e, "0x%-9lux 0x%-9lux 0x%-9lux\n", addr, 
				(end-addr)/flash.r[i].size, flash.r[i].size); 
			addr = end; 
		} 
	n = readstr(off, a, n, buf); 
	free(buf); 
	return n; 
} 
 
static long 
flashdataread(FPart *fp, void* a, long n, vlong off) 
{ 
	rlock(&flash); 
	if(waserror()){ 
		runlock(&flash); 
		nexterror(); 
	}
2001/0529    
	if(fp->name == nil)
2000/1213    
		error("partition vanished"); 
	if(!iseve()) 
		error(Eperm); 
	off += fp->start; 
	if(off >= fp->end) 
		n = 0; 
	if(off+n >= fp->end) 
		n = fp->end - off; 
	if(n > 0) 
		memmove(a, ((uchar*)FLASHZERO)+off, n); 
	runlock(&flash); 
	poperror(); 
 
	return n; 
} 
 
static long	  
flashread(Chan* c, void* a, long n, vlong off) 
{
2001/0529    
	int t; 
 
	if(c->qid.type == QTDIR)
2000/1207    
		return devdirread(c, a, n, nil, 0, gen);
2001/0529    
	t = FTYPE(c->qid.path); 
	switch(t){
2000/1117    
	default: 
		error(Eperm); 
	case Qfctl:
2000/1213    
		n = flashctlread(FPART(c->qid.path), a, n, off);
2000/1117    
		break;
2000/1213    
	case Qfdata: 
		n = flashdataread(FPART(c->qid.path), a, n, off);
2000/1117    
		break; 
	}
2000/1111    
	return n; 
}
2000/1117    
static void 
bootprotect(ulong addr) 
{ 
	FlashRegion *r; 
 
	if(flash.bootprotect == 0) 
		return; 
	if(flash.nr == 0) 
		error("writing over boot loader disallowed"); 
	r = flash.r; 
	if(addr >= r->addr && addr < r->addr + r->size) 
		error("writing over boot loader disallowed"); 
}
2000/1207    
static ulong
2000/1117    
blockstart(ulong addr) 
{ 
	FlashRegion *r, *e; 
	ulong x; 
 
	r = flash.r; 
	for(e = &flash.r[flash.nr]; r < e; r++) 
		if(addr >= r->addr && addr < r->end){ 
			x = addr - r->addr; 
			x /= r->size; 
			return r->addr + x*r->size; 
		} 
			 
	return (ulong)-1; 
}
2000/1207    
static ulong
2000/1117    
blockend(ulong addr) 
{ 
	FlashRegion *r, *e; 
	ulong x; 
 
	r = flash.r; 
	for(e = &flash.r[flash.nr]; r < e; r++) 
		if(addr >= r->addr && addr < r->end){ 
			x = addr - r->addr; 
			x /= r->size; 
			return r->addr + (x+1)*r->size; 
		} 
			 
	return (ulong)-1; 
} 
 
static long
2000/1213    
flashctlwrite(FPart *fp, char *p, long n)
2000/1117    
{ 
	Cmdbuf *cmd;
2000/1207    
	ulong off;
2000/1117    
2000/1213    
	if(fp == nil) 
		panic("flashctlwrite");
2000/1117    
	cmd = parsecmd(p, n); 
	wlock(&flash); 
	if(waserror()){ 
		wunlock(&flash); 
		nexterror(); 
	} 
	if(strcmp(cmd->f[0], "erase") == 0){
2000/1207    
		switch(cmd->nf){
2000/1213    
		case 2: 
			/* erase a single block in the partition */ 
			off = atoi(cmd->f[1]);
2000/1207    
			off += fp->start; 
			if(off >= fp->end) 
				error("region not in partition"); 
			if(off != blockstart(off)) 
				error("erase must be a block boundary"); 
			bootprotect(off); 
			(*flash.alg->erase)(off); 
			break;
2000/1213    
		case 1:
2000/1207    
			/* erase the whole partition */ 
			bootprotect(fp->start); 
			for(off = fp->start; off < fp->end; off = blockend(off)) 
				(*flash.alg->erase)(off); 
			break; 
		default: 
			error(Ebadarg); 
		} 
	} else if(strcmp(cmd->f[0], "add") == 0){ 
		if(cmd->nf != 4) 
			error(Ebadarg);
2000/1213    
		addpart(fp, cmd->f[1], strtoul(cmd->f[2], nil, 0), strtoul(cmd->f[3], nil, 0));
2000/1207    
	} else if(strcmp(cmd->f[0], "remove") == 0){
2000/1213    
		rempart(fp);
2000/1117    
	} else if(strcmp(cmd->f[0], "protectboot") == 0){ 
		if(cmd->nf == 0 || strcmp(cmd->f[1], "off") != 0) 
			flash.bootprotect = 1; 
		else 
			flash.bootprotect = 0; 
	} else 
		error(Ebadarg); 
	poperror(); 
	wunlock(&flash); 
	free(cmd); 
 
	return n; 
} 
 
static long
2000/1213    
flashdatawrite(FPart *fp, uchar *p, long n, long off)
2000/1117    
{ 
	uchar *end; 
	int m;
2000/1213    
	int on;
2000/1207    
	long ooff;
2000/1213    
	uchar *buf;
2000/1117    
2000/1213    
	if(fp == nil) 
		panic("flashctlwrite");
2000/1117    
2000/1213    
	buf = nil;
2000/1117    
	wlock(&flash); 
	if(waserror()){ 
		wunlock(&flash);
2000/1213    
		if(buf != nil) 
			free(buf);
2000/1117    
		nexterror(); 
	}
2001/0529    
	if(fp->name == nil)
2000/1207    
		error("partition vanished"); 
	if(!iseve()) 
		error(Eperm);
2000/1213    
	/* can't cross partition boundaries */
2000/1207    
	off += fp->start; 
	if(off >= fp->end || off+n > fp->end || n <= 0) 
		error(Ebadarg);
2000/1117    
	/* make sure we're not writing the boot sector */ 
	bootprotect(off);
2000/1213    
	on = n; 
 
	/* 
	 *  get the data into kernel memory to avoid faults during writing. 
	 *  if write is not on a quad boundary or not a multiple of 4 bytes, 
	 *  extend with data already in flash. 
	 */ 
	buf = smalloc(n+8); 
	m = off & 3; 
	if(m){ 
		*(ulong*)buf = flash.p[(off)>>2]; 
		n += m; 
		off -= m; 
	} 
	if(n & 3){ 
		n -= n & 3; 
		*(ulong*)(&buf[n]) = flash.p[(off+n)>>2]; 
		n += 4; 
	} 
	memmove(&buf[m], p, on);
2000/1117    
	/* (*flash.alg->write) can't cross blocks */
2000/1207    
	ooff = off;
2000/1213    
	p = buf;
2000/1117    
	for(end = p + n; p < end; p += m){ 
		m = blockend(off) - off; 
		if(m > end - p) 
			m = end - p;
2000/1209    
		if(m > Maxwchunk) 
			m = Maxwchunk;
2000/1213    
		(*flash.alg->write)(p, m, off);
2000/1117    
		off += m; 
	} 
 
	/* make sure write succeeded */
2000/1213    
	if(memcmp(buf, &flash.p[ooff>>2], n) != 0)
2000/1117    
		error("written bytes don't match"); 
 
	wunlock(&flash);
2000/1213    
	free(buf);
2000/1117    
	poperror();
2000/1213    
	return on;
2000/1117    
}
2000/1111    
static long
2000/1117    
flashwrite(Chan* c, void* a, long n, vlong off)
2000/1111    
{
2001/0529    
	int t; 
 
	if(c->qid.type == QTDIR)
2000/1117    
		error(Eperm); 
 
	if(!iseve()) 
		error(Eperm);
2001/0529    
	t = FTYPE(c->qid.path); 
	switch(t){
2000/1117    
	default: 
		panic("flashwrite"); 
	case Qfctl:
2000/1213    
		n = flashctlwrite(FPART(c->qid.path), a, n); 
		break; 
	case Qfdata: 
		n = flashdatawrite(FPART(c->qid.path), a, n, off); 
		break;
2000/1117    
	}
2000/1111    
	return n; 
} 
 
Dev flashdevtab = { 
	'F', 
	"flash", 
 
	devreset, 
	flashinit, 
	flashattach, 
	flashwalk, 
	flashstat, 
	flashopen, 
	devcreate, 
	flashclose, 
	flashread, 
	devbread, 
	flashwrite, 
	devbwrite, 
	devremove, 
	devwstat,
2000/1107    
};
2000/1117    
2000/1209    
enum 
{ 
	/* status register */ 
	ISEs_lockerr=		1<<1, 
	ISEs_powererr=		1<<3, 
	ISEs_progerr=		1<<4, 
	ISEs_eraseerr=		1<<5, 
	ISEs_ready=		1<<7, 
	ISEs_err= (ISEs_lockerr|ISEs_powererr|ISEs_progerr|ISEs_eraseerr),
2000/1117    
2000/1209    
	/* extended status register */ 
	ISExs_bufavail=		1<<7, 
};
2000/1117    
/* intel/sharp extended command set */ 
static void 
ise_reset(void) 
{ 
	flash.p[0x55] = mirror(0xff);	/* reset */ 
} 
static void 
ise_id(void) 
{ 
	ise_reset(); 
	flash.p[0x555] = mirror(0x90);	/* uncover vendor info */ 
	flash.manid = flash.p[00]; 
	flash.devid = flash.p[01]; 
	ise_reset(); 
} 
static void 
ise_clearerror(void) 
{ 
	flash.p[0x100] = mirror(0x50); 
 
} 
static void 
ise_error(int bank, ulong status) 
{
2001/0529    
	char err[64];
2000/1117    
2000/1209    
	if(status & (ISEs_lockerr)){ 
		sprint(err, "flash%d: block locked %lux", bank, status);
2000/1117    
		error(err); 
	}
2000/1209    
	if(status & (ISEs_powererr)){ 
		sprint(err, "flash%d: low prog voltage %lux", bank, status);
2000/1117    
		error(err); 
	}
2000/1209    
	if(status & (ISEs_progerr|ISEs_eraseerr)){ 
		sprint(err, "flash%d: i/o error %lux", bank, status);
2000/1117    
		error(err); 
	} 
} 
static void 
ise_erase(ulong addr) 
{ 
	ulong start; 
	ulong x; 
 
	addr >>= 2;	/* convert to ulong offset */ 
 
	flashprogpower(1); 
	flash.p[addr] = mirror(0x20); 
	flash.p[addr] = mirror(0xd0); 
	start = m->ticks; 
	do { 
		x = flash.p[addr];
2000/1209    
		if((x & mirror(ISEs_ready)) == mirror(ISEs_ready))
2000/1117    
			break; 
	} while(TK2MS(m->ticks-start) < 1500); 
	flashprogpower(0); 
 
	ise_clearerror(); 
	ise_error(0, x); 
	ise_error(1, x>>16); 
 
	ise_reset(); 
} 
/*
2000/1209    
 *  the flash spec claimes writing goes faster if we use
2000/1117    
 *  the write buffer.  We fill the write buffer and then 
 *  issue the write request.  After the write request,
2000/1211    
 *  subsequent reads will yield the status register.
2000/1117    
 *
2000/1211    
 *  returns the status, even on timeouts.
2000/1209    
 *
2000/1211    
 *  NOTE: I tried starting back to back buffered writes 
 *	without reading the status in between, as the 
 *	flowchart in the intel data sheet suggests. 
 *	However, it always responded with an illegal 
 *	command sequence, so I must be missing something. 
 *	If someone learns better, please email me, though 
 *	I doubt it will be much faster. -  presotto@bell-labs.com
2000/1117    
 */
2000/1209    
static ulong 
ise_wbwrite(ulong *p, int n, ulong off, ulong baddr, ulong *status)
2000/1117    
{
2000/1209    
	ulong x, start;
2000/1117    
	int i;
2000/1209    
	int s;
2000/1117    
 
	/* put flash into write buffer mode */ 
	start = m->ticks; 
	for(;;) {
2000/1209    
		s = splhi();
2000/1117    
		/* request write buffer mode */
2000/1209    
		flash.p[baddr] = mirror(0xe8);
2000/1117    
 
		/* look at extended status reg for status */
2000/1209    
		if((flash.p[baddr] & mirror(1<<7)) == mirror(1<<7))
2000/1117    
			break;
2000/1209    
		splx(s);
2000/1117    
 
		/* didn't work, keep trying for 2 secs */ 
		if(TK2MS(m->ticks-start) > 2000){ 
			/* set up to read status */
2000/1209    
			flash.p[baddr] = mirror(0x70); 
			*status = flash.p[baddr]; 
			pprint("write buffered cmd timed out\n");
2000/1117    
			return -1; 
		} 
	} 
 
	/* fill write buffer */
2000/1209    
	flash.p[baddr] = mirror(n-1);
2000/1117    
	for(i = 0; i < n; i++) 
		flash.p[off+i] = *p++; 
 
	/* program from buffer */
2000/1209    
	flash.p[baddr] = mirror(0xd0); 
	splx(s);
2000/1117    
2000/1209    
	/* wait till the programming is done */ 
	start = m->ticks; 
	for(;;) { 
		x = *status = flash.p[baddr];	/* read status register */ 
		if((x & mirror(ISEs_ready)) == mirror(ISEs_ready)) 
			break; 
		if(TK2MS(m->ticks-start) > 2000){ 
			pprint("read status timed out\n"); 
			return -1; 
		} 
	} 
	if(x & mirror(ISEs_err)) 
		return -1;
2000/1117    
 
	return n; 
} 
static void 
ise_write(void *a, long n, ulong off) 
{ 
	ulong *p, *end; 
	int i, wbsize;
2000/1209    
	ulong x, baddr;
2000/1117    
 
	/* everything in terms of ulongs */ 
	wbsize = flash.wbsize>>2;
2000/1209    
	baddr = blockstart(off);
2000/1117    
	off >>= 2; 
	n >>= 2; 
	p = a;
2000/1209    
	baddr >>= 2;
2000/1117    
 
	/* first see if write will succeed */ 
	for(i = 0; i < n; i++) 
		if((p[i] & flash.p[off+i]) != p[i]) 
			error("flash needs erase"); 
 
	if(waserror()){ 
		ise_reset(); 
		flashprogpower(0); 
		nexterror(); 
	} 
	flashprogpower(1); 
 
	/* 
	 *  use the first write to reach 
 	 *  a write buffer boundary.  the intel maunal 
	 *  says writes startng at wb boundaries 
	 *  maximize speed. 
	 */ 
	i = wbsize - (off & (wbsize-1)); 
	for(end = p + n; p < end;){ 
		if(i > end - p) 
			i = end - p;
2000/1209    
		if(ise_wbwrite(p, i, off, baddr, &x) < 0)
2000/1117    
			break; 
 
		off += i; 
		p += i; 
		i = wbsize; 
	} 
 
	ise_clearerror(); 
	ise_error(0, x); 
	ise_error(1, x>>16); 
 
	ise_reset(); 
	flashprogpower(0); 
	poperror(); 
} 
 
/* amd/fujitsu standard command set 
 *	I don't have an amd chipset to work with 
 *	so I'm loathe to write this yet.  If someone 
 *	else does, please send it to me and I'll 
 *	incorporate it -- presotto@bell-labs.com 
 */ 
static void 
afs_reset(void) 
{ 
	flash.p[0x55] = mirror(0xf0);	/* reset */ 
} 
static void 
afs_id(void) 
{ 
	afs_reset(); 
	flash.p[0x55] = mirror(0xf0);	/* reset */ 
	flash.p[0x555] = mirror(0xaa);	/* query vendor block */ 
	flash.p[0x2aa] = mirror(0x55); 
	flash.p[0x555] = mirror(0x90); 
	flash.manid = flash.p[00]; 
	afs_reset(); 
	flash.p[0x555] = mirror(0xaa);	/* query vendor block */ 
	flash.p[0x2aa] = mirror(0x55); 
	flash.p[0x555] = mirror(0x90); 
	flash.devid = flash.p[01]; 
	afs_reset(); 
} 
static void 
afs_erase(ulong) 
{ 
	error("amd/fujistsu erase not implemented"); 
} 
static void 
afs_write(void*, long, ulong) 
{ 
	error("amd/fujistsu write not implemented"); 
}


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)