/*
* Undo any effects of the aborted instruction that need to be undone
* in order for us to restart it. This is just a case of spotting
* aborted LDMs and STMs and reversing any base writeback. This code
* is derived loosely from the arm32 late-abort fixup.
*/
static void
data_abort_fixup(struct trapframe *tf)
{
register_t insn;
int rn, count, loop;
getreg(15) = tf->tf_r15;
/* Get the faulting instruction */
insn = *(register_t *)(tf->tf_r15 & R15_PC);
if ((insn & 0x0e000000) == 0x08000000 &&
(insn & 1 << 21)) {
/* LDM/STM with writeback*/
rn = (insn >> 16) & 0x0f;
if (rn == 15)
return; /* No writeback on R15 */
/* Count registers transferred */
count = 0;
for (loop = 0; loop < 16; ++loop) {
if (insn & (1<<loop))
++count;
}
if (insn & (1 << 23)) /* up/down bit -- we reverse it. */
getreg(rn) -= count * 4;
else
getreg(rn) += count * 4;
}
HookData *__asm __saveds L_GetEditHook(
register __d0 ULONG type,
register __d1 ULONG flags,
register __a0 struct TagItem *tags)
{
HookData *hook;
// Allocate hook
if (hook=AllocVec(sizeof(HookData),MEMF_CLEAR))
{
// Fill out hook
hook->hook.h_Entry=(ULONG (*)())string_edit_hook;
hook->a4=getreg(REG_A4);
hook->a6=getreg(REG_A6);
hook->type=type;
hook->flags=flags;
// Get data from tags
hook->history=(Att_List *)GetTagData(GTCustom_History,0,tags);
hook->change_task=(struct Task *)GetTagData(GTCustom_ChangeSigTask,0,tags);
hook->change_bit=GetTagData(GTCustom_ChangeSigBit,0,tags);
}
return hook;
}
// Read a word from PHY
static cyg_uint16 phy_read(struct dm9000 *p, int offset)
{
putreg(p, DM_EPAR, 0x40 + offset);
putreg(p, DM_EPCR, EPCR_EPOS | EPCR_ERPRR);
CYGACC_CALL_IF_DELAY_US(200);
putreg(p, DM_EPCR, 0);
return getreg(p, DM_EPDRL) | (getreg(p, DM_EPDRH) << 8);
}
/*
* pop -- pop a word off the given stack
*
* sp -- stack pointer register to use. Can be any of the eight
* general purpose registers.
* return value -- the word popped off the stack
*/
static size_t pop(size_t sp)
{
size_t word;
word = getmem(getreg(sp));
setreg(sp, getreg(sp)-1);
return(word);
}
/*
mov r0, #33
.-- select 3 bit opcode mode
| .---- op|ode number (mov)
v v .- BYTEMODE (wtf)
0 000 0 1 000 00 11 (32bits)
reg ---^ | | ^--- 32bit integer
regnum ---' `------- inmediate mark
opcode encoding
===============
0>=
arg encoding
============
reg 1 x3
memr 01 0 x3
memi 01 11 11 x32
memri 01 10 r3 11 x32
imm 0011 x32
*/
static int assemble_arg(Bitbuf *b, char *a) {
printf ("A = (%s)\n", a);
int r = getreg (a);
if (r != -1) {
bitadd (b, 1, 1);
bitadd (b, r, 3);
return 1;
} else
if (*a == '[') {
char *sign = strchr (++a, '+');
if (!sign) sign = strchr (a, '-');
bitadd (b, 0, 1);
bitadd (b, 1, 1);
if (sign) {
// XXX: atm only basereg + idx
int n, r = getreg (a);
n = strtoul (sign+1, NULL, 0);
bitadd (b, 1, 1);
bitadd (b, 0, 1);
bitadd (b, r, 3);
bitadd (b, 3, 2);
if (*sign == '-')
n = -n;
bitadd (b, n, 32);
} else {
// XXX only reg or num
bitadd (b, 0, 1);
if (*a == '#') a++; // XXX
r = getreg (a);
if (r!=-1) {
bitadd (b, 0, 1);
bitadd (b, r, 3);
} else {
unsigned int n;
if (*a=='#') a++;
n = strtoul (a, NULL, 0);
bitadd (b, 1, 1);
bitadd (b, 1, 1);
bitadd (b, 3, 2);
bitadd (b, n, 32);
}
}
return 1;
} else {
unsigned int n = strtoul (a+1, NULL, 0);
// inmediate
printf ("n=%d (%s)\n", n, a);
bitadd (b, 0, 2);
// 0 = 4 bit
// 1 = 8/12 bit (???
// 2 = 16 bit
// 3 = 32 bit
bitadd (b, 3, 2);
bitadd (b, n, 32);
return 1;
}
return 0;
}
/*---------------------------------------------------------------------------*/
int
cc2420_init(void)
{
uint16_t reg;
{
int s = splhigh();
cc2420_arch_init(); /* Initalize ports and SPI. */
DISABLE_FIFOP_INT();
FIFOP_INT_INIT();
splx(s);
}
/* Turn on voltage regulator and reset. */
SET_VREG_ACTIVE();
//clock_delay(250); OK
SET_RESET_ACTIVE();
clock_delay(127);
SET_RESET_INACTIVE();
//clock_delay(125); OK
/* Turn on the crystal oscillator. */
strobe(CC2420_SXOSCON);
/* Turn on/off automatic packet acknowledgment and address decoding. */
reg = getreg(CC2420_MDMCTRL0);
reg |= 0x40; /* XXX CCA mode 1 */
#if CC2420_CONF_AUTOACK
reg |= AUTOACK | ADR_DECODE;
#else
reg &= ~(AUTOACK | ADR_DECODE);
#endif /* CC2420_CONF_AUTOACK */
setreg(CC2420_MDMCTRL0, reg);
/* Change default values as recomended in the data sheet, */
/* correlation threshold = 20, RX bandpass filter = 1.3uA. */
setreg(CC2420_MDMCTRL1, CORR_THR(20));
reg = getreg(CC2420_RXCTRL1);
reg |= RXBPF_LOCUR;
setreg(CC2420_RXCTRL1, reg);
/* Set the FIFOP threshold to maximum. */
setreg(CC2420_IOCFG0, FIFOP_THR(127));
/* Turn off "Security enable" (page 32). */
reg = getreg(CC2420_SECCTRL0);
reg &= ~RXFIFO_PROTECTION;
setreg(CC2420_SECCTRL0, reg);
cc2420_set_pan_addr(0xffff, 0x0000, NULL);
cc2420_set_channel(26);
process_start(&cc2420_process, NULL);
return 1;
}
// Read a word from EEPROM
static cyg_uint16 eeprom_read(struct dm9000 *p, int offset)
{
putreg(p, DM_EPAR, offset);
putreg(p, DM_EPCR, EPCR_ERPRR);
while (getreg(p, DM_EPCR) & EPCR_ERRE)
;
CYGACC_CALL_IF_DELAY_US(200);
putreg(p, DM_EPCR, 0);
return getreg(p, DM_EPDRL) | (getreg(p, DM_EPDRH) << 8);
}
long gethostid(void)
{
long hostid = 0;
const char * const *subKey;
size_t i;
MD5_CTX context;
unsigned char digest[MD5_DIGEST_LENGTH];
MD5_Init(&context);
for (subKey = keys; *subKey != NULL; subKey++) {
const char * const *valueName;
for (valueName = values; *valueName != NULL; valueName++) {
int ret = -13, type = -42;
size_t size = 0;
unsigned char *buffer;
char * key = mcopystr(*subKey);
key = mputstr(key, *valueName);
ret = getreg(key, &type, 0, &size); /* query the size; ret always -1 */
if (size > 0) {
buffer = Malloc(size);
ret = getreg(key, &type, buffer, &size);
if (ret == 0) {
switch (type) {
case WIN_REG_SZ:
case WIN_REG_EXPAND_SZ:
case WIN_REG_MULTI_SZ: {
/* getreg gave use _wide_ strings. Make them narrow.
FIXME this assumes everybody is american and uses US-ASCII.
It would be more correct to use iconv()
but we don't know which codepage to convert to.
*/
const unsigned char *from = buffer, *end = buffer + size;
unsigned char *to = buffer;
for (; from < end; ++from) { /* Yes, from is incremented twice */
*to++ = *from++;
}
size /= 2;
break; }
default:
break;
}
MD5_Update(&context, buffer, size);
}
Free(buffer);
}
Free(key);
}
}
MD5_Final(digest, &context);
for (i = 0; i < sizeof(hostid); i++) hostid |= digest[i] << (i * 8);
return hostid;
}
int
__UserLibInit( void )
{
WinamiBase = (WinamiBASE *)getreg( REG_A6 );
if ( (DOSBase = (struct DosLibrary *)
OpenLibrary("dos.library", 0)) == NULL)
{
Abort(AG_OpenLib | AO_DOSLib);
}
if ( (IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library", INTUITION_VERSION)) == NULL)
{
Abort(AG_OpenLib | AO_Intuition);
}
if ( (GfxBase = (struct GfxBase *)
OpenLibrary("graphics.library", GRAPHICS_VERSION)) == NULL)
{
Abort(AG_OpenLib | AO_GraphicsLib);
}
#ifdef VIEWWINDOW
if ( (LayersBase = (struct Library *)
OpenLibrary("layers.library", 0)) == NULL)
{
Abort(AG_OpenLib | AO_LayersLib);
}
#endif
return( 0 );
}
struct bt *arch_debug_get_bt(void)
{
struct bt *bt = NULL;
#if defined(__SASC) && defined(DEBUG_RESTRACK)
struct Process *this;
/* Note that we assume that SimpleMail consists only of one hunk */
ULONG *stackptr = (ULONG*)getreg(REG_A7);
int cnt = 0;
if (!(bt = (struct bt*)malloc(sizeof(*bt))))
return NULL;
this = (struct Process*)FindTask(NULL);
while ((void*)stackptr < this->pr_Task.tc_SPUpper && cnt < MAX_ADDR)
{
ULONG addr = *stackptr;
if (addr >= ((ULONG)__code_base) && addr < ((ULONG)__code_base) + __code_size)
{
bt->addr[cnt] = addr;
cnt++;
}
stackptr++;
}
bt->addr_used = cnt;
#endif
return bt;
}
int
findreg(int idx)
{
unsigned long t, count = 0;
if(!fpga_read)
return idx;
if(sig)
return -1;
while(!sig) {
picoread(CORE_OFF | (idx << 6) | 0x3c, &t, 4);
if(t != 0xDEADD00D) {
if((t == 0xCAFEBABE) && fpga_read) {
getreg(idx);
break;
}
if(!fpga[idx].set)
break;
} else
count++;
usleep(100);
}
return idx;
}
/*
* print the registers
*/
void
printregs(int c)
{
Reglist *rp;
int i;
uvlong v;
for (i = 1, rp = mach->reglist; rp->rname; rp++, i++) {
if ((rp->rflags & RFLT)) {
if (c != 'R')
continue;
if (rp->rformat == '8' || rp->rformat == '3')
continue;
}
v = getreg(cormap, rp);
if(rp->rformat == 'Y')
dprint("%-8s %-20#llux", rp->rname, v);
else
dprint("%-8s %-12#lux", rp->rname, (ulong)v);
if ((i % 3) == 0) {
dprint("\n");
i = 0;
}
}
if (i != 1)
dprint("\n");
dprint ("%s\n", machdata->excep(cormap, rget));
printpc();
}
/*---------------------------------------------------------------------------*/
int
cc2520_rssi(void)
{
int rssi;
int radio_was_off = 0;
if(locked) {
return 0;
}
GET_LOCK();
if(!receive_on) {
radio_was_off = 1;
cc2520_on();
}
BUSYWAIT_UNTIL(status() & BV(CC2520_RSSI_VALID), RTIMER_SECOND / 100);
rssi = (int)((signed char)getreg(CC2520_RSSI));
if(radio_was_off) {
cc2520_off();
}
RELEASE_LOCK();
return rssi;
}
/* Generate code for arithmetic expression, return a register number */
int genarith(TOKEN code)
{ int num, reg;
if (DEBUGGEN)
{ printf("genarith\n");
dbugprinttok(code);
};
switch ( code->tokentype )
{ case NUMBERTOK:
switch (code->datatype)
{ case INTEGER:
num = code->intval;
reg = getreg(WORD);
if ( num >= MINIMMEDIATE && num <= MAXIMMEDIATE )
asmimmed(MOVL, num, reg);
break;
case REAL:
/* ***** fix this ***** */
break;
}
break;
case IDENTIFIERTOK:
/* ***** fix this ***** */
break;
case OPERATOR:
/* ***** fix this ***** */
break;
};
return reg;
}
// Reload info from EEPROM
static void eeprom_reload(struct dm9000 *p)
{
putreg(p, DM_EPCR, EPCR_REEP);
while (getreg(p, DM_EPCR) & EPCR_ERRE)
;
CYGACC_CALL_IF_DELAY_US(200);
putreg(p, DM_EPCR, 0);
}
int main()
{
int file;
int adapter_nr = 0;
char filename[20];
snprintf(filename, 19, "/dev/i2c-%d", adapter_nr);
file = open(filename, O_RDWR);
if (file < 0)
{
printf("cannot open filen\n");
exit(1);
}
printf("file opened\n");
int addr = 0x20;
if(ioctl(file, I2C_SLAVE, addr) < 0)
{
printf("cannot find slave device address 0x%x\n", addr);
exit(1);
}
setreg(file, 3,0xF0);
setreg(file, 2,0x00);
int i;
__u8 val = 1;
while(1)
{
setreg(file, 1,(~val)&0xFF);
sleep(1);
val<<=1;
if(val==0x10)
val = 1;
int k = getreg(file,0);
if((k&0x10) == 0)
break;
}
printf("reg%d=0x%x\n", 0, getreg(file, 0));
close(file);
}
int roach_late_iic_xfer(int iic_addr, int rd_w_n, unsigned char* data, int size)
{
int xfer_size = size - 1; /* controller starts at 1 */
int i;
int ret=0;
if (xfer_size > 3)
xfer_size = 3;
if (xfer_size <= 0)
xfer_size = 0;
for (i=0; i < 4; i++){
getreg(IIC0_MDBUF);
}
setreg(IIC0_STS, 0);
setreg(IIC0_EXSTS, 0xf);
if (!rd_w_n) {
for (i=0; i <= xfer_size; i++){
setreg(IIC0_MDBUF, data[i]);
}
}
setreg(IIC0_HMADDR, 0);
setreg(IIC0_LMADDR, (iic_addr & 0x7f) << 1);
setreg(IIC0_CNTRL, ((xfer_size & 0x3) << 4) | IIC_START | (rd_w_n ? IIC_RD : IIC_WR));
for (i=0; i < 1000000; i++){
if (!(getreg(IIC0_STS) & IIC_DONE))
break;
}
if (i == 1000000){
ret = -1;
}
if (rd_w_n){
for (i=0; i <= xfer_size; i++){
data[i] = getreg(IIC0_MDBUF);
}
}
return ret;
}
/*---------------------------------------------------------------------------*/
int
cc2520_get_txpower(void)
{
uint8_t power;
GET_LOCK();
power = getreg(CC2520_TXPOWER);
RELEASE_LOCK();
return power;
}
/*---------------------------------------------------------------------------*/
int
cc2420_get_txpower(void)
{
int power;
GET_LOCK();
power = (int)(getreg(CC2420_TXCTRL) & 0x001f);
RELEASE_LOCK();
return power;
}
/*---------------------------------------------------------------------------*/
static void
set_txpower(uint8_t power)
{
uint16_t reg;
reg = getreg(CC2420_TXCTRL);
reg = (reg & 0xffe0) | (power & 0x1f);
setreg(CC2420_TXCTRL, reg);
}
static void
configure(void)
{
uint16_t reg;
BUSYWAIT_UNTIL(status() & (BV(CC2420_XOSC16M_STABLE)), RTIMER_SECOND / 100);
/* Turn on/off automatic packet acknowledgment and address decoding. */
reg = getreg(CC2420_MDMCTRL0);
#if CC2420_CONF_AUTOACK
reg |= AUTOACK | ADR_DECODE;
#else
reg &= ~(AUTOACK | ADR_DECODE);
#endif /* CC2420_CONF_AUTOACK */
setreg(CC2420_MDMCTRL0, reg);
/* Set transmission turnaround time to the lower setting (8 symbols
= 0.128 ms) instead of the default (12 symbols = 0.192 ms). */
/* reg = getreg(CC2420_TXCTRL);
reg &= ~(1 << 13);
setreg(CC2420_TXCTRL, reg);*/
/* Change default values as recomended in the data sheet, */
/* correlation threshold = 20, RX bandpass filter = 1.3uA. */
setreg(CC2420_MDMCTRL1, CORR_THR(20));
reg = getreg(CC2420_RXCTRL1);
reg |= RXBPF_LOCUR;
setreg(CC2420_RXCTRL1, reg);
/* Set the FIFOP threshold to maximum. */
setreg(CC2420_IOCFG0, FIFOP_THR(127));
/* Turn off "Security enable" (page 32). */
reg = getreg(CC2420_SECCTRL0);
reg &= ~RXFIFO_PROTECTION;
setreg(CC2420_SECCTRL0, reg);
cc2420_set_pan_addr(pan, addr, NULL);
cc2420_set_channel(channel);
flushrx();
}
uvlong
rget(Map *map, char *name)
{
Reglist *rp;
rp = rname(name);
if (!rp)
error("invalid register name");
return getreg(map, rp);
}
static ut32 getshift(const char *str) {
char type[128];
char arg[128];
char *space;
ut32 i=0, shift=0;
const char *shifts[] = {
"LSL", "LSR", "ASR", "ROR",
0, "RRX" // alias for ROR #0
};
strncpy (type, str, sizeof (type)-1);
// handle RRX alias case
if (!strcasecmp (type, shifts[5])) {
shift = 6;
}
// all other shift types
else {
// split the string into type and arg
space = strchr (type, ' ');
if (!space)
return 0;
*space = 0;
strncpy (arg, ++space, sizeof(arg)-1);
for (i=0; shifts[i]; i++) {
if (!strcasecmp (type, shifts[i])) {
shift = 1;
break;
}
}
if (!shift)
return 0;
shift = (i*2);
if ((i = getreg (arg)) != -1) {
shift |= 1;
i = i<<4;
}
else {
i = getnum (arg);
// ensure only the bottom 5 bits are used
i &= 0x1f;
if (!i)
i = 32;
i = (i*8);
}
}
i += shift;
i = i << 4;
r_mem_copyendian ((ut8*)&shift, (const ut8*)&i, sizeof (ut32), 0);
return shift;
}
// Open a progress window
ProgressWindow *__asm __saveds L_OpenProgressWindow(
register __a0 struct TagItem *tags,
register __a6 struct MyLibrary *lib)
{
ProgressWindow *prog;
char *ptr;
// Allocate control structure
if (!(prog=AllocVec(sizeof(ProgressWindow),MEMF_CLEAR)))
return 0;
// Fill out control parameters
prog->pw_Screen=(struct Screen *)GetTagData(PW_Screen,0,tags);
prog->pw_OwnerWindow=(struct Window *)GetTagData(PW_Window,0,tags);
if (ptr=(char *)GetTagData(PW_Title,0,tags)) stccpy(prog->pw_Title,ptr,39);
if (ptr=(char *)GetTagData(PW_Info,0,tags)) stccpy(prog->pw_Information,ptr,79);
if (ptr=(char *)GetTagData(PW_Info2,0,tags)) stccpy(prog->pw_Information2,ptr,79);
if (ptr=(char *)GetTagData(PW_Info3,0,tags)) stccpy(prog->pw_Information3,ptr,79);
prog->pw_SigTask=(struct Task *)GetTagData(PW_SigTask,0,tags);
prog->pw_SigBit=GetTagData(PW_SigBit,0,tags);
prog->pw_Flags=GetTagData(PW_Flags,0,tags);
prog->pw_FileCount=GetTagData(PW_FileCount,0,tags);
prog->pw_FileSize=GetTagData(PW_FileSize,0,tags);
if (ptr=(char *)GetTagData(PW_FileName,0,tags)) stccpy(prog->pw_FileName,ptr,79);
// If we have both size and the bar set, we swap them around
if (prog->pw_Flags&PWF_FILESIZE && prog->pw_Flags&PWF_GRAPH)
prog->pw_Flags|=PWF_SWAP;
// Save A4 and library pointer
prog->pw_A4=getreg(REG_A4);
prog->pw_Lib=lib;
// Initialise task name
strcpy(prog->pw_TaskName,"dopus_progressbar");
// Launch progress task
L_IPC_Launch(
0,&prog->pw_IPC,
prog->pw_TaskName,
(ULONG)progress_task,
STACK_DEFAULT,
(ULONG)prog,
(struct Library *)DOSBase,lib);
// Failed?
if (!prog->pw_IPC)
{
FreeVec(prog);
return 0;
}
// Return pointer
return prog;
}
/* Generate code for arithmetic expression, return a register number */
int genarith(TOKEN code) {
if (DEBUGGEN) {
printf("In genarith()\n");
dbugprinttok(code);
}
int num, reg_num, lhs_reg, rhs_reg;
if (code->tokentype == NUMBERTOK) {
if (code->datatype == INTEGER) {
num = code->intval;
reg_num = getreg(INTEGER);
if (num >= MINIMMEDIATE && num <= MAXIMMEDIATE) {
asmimmed(MOVL, num, reg_num);
}
else {
/* Generate literal for the value of the constant, then
load the literal into a register. */
}
}
else {
/* Generate literal for the value of the constant, then
load the literal into a register. */
num = code->intval;
reg_num = getreg(REAL);
}
}
else if (code->tokentype == IDENTIFIERTOK) {
}
else if (code->tokentype == OPERATOR) {
reg_num = lhs_reg;
}
return reg_num;
}
static BT_ERROR gpio_set(BT_HANDLE hGPIO, BT_u32 ulGPIO, BT_BOOL bValue) {
BT_ERROR Error;
BT_u8 reg = getreg(ulGPIO);
BT_u8 bit = ulGPIO % 8;
BT_u8 val = gpio_write_register(hGPIO, reg, &Error);
return BT_ERR_NONE;
}
static ut32 getshift(const char *str) {
char type[128];
char arg[128];
char *space;
ut32 i=0, shift=0;
const char *shifts[] = {
"LSL", "LSR", "ASR", "ROR",
0, "RRX" // alias for ROR #0
};
strncpy (type, str, sizeof (type)-1);
// XXX strcaecmp is probably unportable
if (!strcasecmp (type, shifts[5])) {
// handle RRX alias case
shift = 6;
} else { // all other shift types
space = strchr (type, ' ');
if (!space)
return 0;
*space = 0;
strncpy (arg, ++space, sizeof(arg)-1);
for (i=0; shifts[i]; i++) {
if (!strcasecmp (type, shifts[i])) {
shift = 1;
break;
}
}
if (!shift)
return 0;
shift = (i*2);
if ((i = getreg (arg)) != -1) {
i<<=8; // set reg
// i|=1; // use reg
i |= (1<<4); // bitshift
i|=shift<<4; // set shift mode
if (shift == 6) i|=(1<<20);
} else {
i = getnum (arg);
// ensure only the bottom 5 bits are used
i &= 0x1f;
if (!i) i = 32;
i = (i*8);
i |= shift; // lsl, ror, ...
i = i << 4;
}
}
r_mem_copyendian ((ut8*)&shift, (const ut8*)&i, sizeof (ut32), 0);
return shift;
}
/*---------------------------------------------------------------------------*/
void
cc2420_set_txpower(uint8_t power)
{
uint16_t reg;
GET_LOCK();
reg = getreg(CC2420_TXCTRL);
reg = (reg & 0xffe0) | (power & 0x1f);
setreg(CC2420_TXCTRL, reg);
RELEASE_LOCK();
}
// Write a word to EEPROM
static void eeprom_write(struct dm9000 *p, int offset, cyg_uint16 val)
{
putreg(p, DM_EPAR, offset);
putreg(p, DM_EPDRH, val >> 8);
putreg(p, DM_EPDRL, val);
putreg(p, DM_EPCR, EPCR_WEP | EPCR_ERPRW);
while (getreg(p, DM_EPCR) & EPCR_ERRE)
;
CYGACC_CALL_IF_DELAY_US(200);
putreg(p, DM_EPCR, 0);
}
static BT_GPIO_DIRECTION gpio_get_direction(BT_HANDLE hGPIO, BT_u32 ulGPIO, BT_ERROR *pError) {
BT_u8 reg = getreg(ulGPIO);
BT_u8 bit = ulGPIO % 8;
BT_u8 val = gpio_read_register(hGPIO, reg, pError);
if(val & (1 << bit)) {
return BT_GPIO_DIR_INPUT;
}
return BT_GPIO_DIR_OUTPUT;
}
