void LcdBitBlt(uint8* buf,int scanlen,int x,int y,int w,int h,lcdEADog* lcd)
{
//copy an area of memory to lcd
vAHI_SpiConfigure( 2, /* number of slave select lines in use */
E_AHI_SPIM_MSB_FIRST, /* send data MSB first */
FALSE,
FALSE,
0,//16MHz
E_AHI_SPIM_INT_DISABLE, /* Disable SPI interrupt */
E_AHI_SPIM_AUTOSLAVE_DSABL); /* Disable auto slave select */
vAHI_SpiSelect(lcd->spicspin);
uint32* buf32=(uint32*)buf;
if(lcd->angle!=0)x+=4;
int xx,yy;
int ints=w>>2;
uint8 colhigh=0x10+(x>>4);
uint8 collow=0x00+(x&0x0f);
h=h>>3;
for(yy=0;yy<h;yy++)
{
vAHI_DioSetOutput(0,lcd->a0pin);
vAHI_SpiStartTransfer8(0xb0+yy);
vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(colhigh);
vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(collow);
vAHI_SpiWaitBusy();
vAHI_DioSetOutput(lcd->a0pin,0);
for(xx=0;xx< ints;xx++)
{
vAHI_SpiStartTransfer32(*buf32++);
#if (defined JN5148 || defined JN5168 )
vAHI_SpiWaitBusy();
#else
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
asm volatile("l.nop;");
#endif
}
}
vAHI_SpiStop();
}
/*---------------------------------------------------------------------------*/
static uint8_t *
get_response(int length)
{
int i;
int x;
static uint8_t r[R7];
for(i = 0; i < SD_READ_RESPONSE_ATTEMPTS; i++) {
vAHI_SpiStartTransfer8(0xff);
vAHI_SpiWaitBusy();
x = u8AHI_SpiReadTransfer8();
if((x & 0x80) == 0) {
/* A get_response byte is indicated by the MSB being 0. */
r[0] = x;
break;
}
}
if(i == SD_READ_RESPONSE_ATTEMPTS) {
PRINTF("get_response: timeout");
return NULL;
}
for(i = 1; i < length; i++) {
vAHI_SpiStartTransfer8(0xff);
vAHI_SpiWaitBusy();
r[i] = u8AHI_SpiReadTransfer8();
}
PRINTF("get_response %d", r[0]);
return r;
}
void sleepLcdEADog(lcdEADog* lcd)
{
vAHI_SpiConfigure( 2, /* number of slave select lines in use */
E_AHI_SPIM_MSB_FIRST, /* send data MSB first */
FALSE,
FALSE,
0,//16MHz
E_AHI_SPIM_INT_DISABLE, /* Disable SPI interrupt */
E_AHI_SPIM_AUTOSLAVE_DSABL); /* Disable auto slave select */
vAHI_DioSetOutput(0,lcd->a0pin);
vAHI_SpiSelect(lcd->spicspin);
vAHI_SpiStartTransfer8(0xae);
vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(0xa5);
vAHI_SpiWaitBusy();
vAHI_SpiStop();
//saves 0.1mA
vAHI_DioSetOutput(lcd->a0pin,0);
//vAHI_DioSetOutput(lcd->spicspin,0);
// vAHI_DioSetOutput(0,lcd->resetpin);
}
static int
send_command(uint8_t cmd, uint32_t argument)
{
uint8_t req[6], i;
req[0] = 0x40 | cmd;
req[1] = argument >> 24;
req[2] = argument >> 16;
req[3] = argument >> 8;
req[4] = argument;
/* The CRC hard-wired to 0x95 is only needed for the initial
GO_IDLE_STATE command. */
req[5] = 0x95;
vAHI_SpiWaitBusy(); vAHI_SpiStartTransfer8(SPI_IDLE);
for (i=0; i<sizeof(req); i++) {
vAHI_SpiWaitBusy(); vAHI_SpiStartTransfer8(req[i]);
}
vAHI_SpiWaitBusy(); vAHI_SpiStartTransfer8(SPI_IDLE);
PRINTF("send command: %d %d %d %d %d %d\n", req[0]-0x40,req[1],req[2],req[3],req[4],req[5]);
return 0;
}
void initLcdEADog(uint8 cs,int reset,int a0,int angle,lcdEADog* lcd)
{
lcd->spicspin=cs;
lcd->resetpin=reset;
lcd->a0pin=a0;
lcd->angle=angle;
uint8 config0deg[14]={0x40,0xa1,0xc0,0xa6,0xa2,0x2f,0xf8,0x00,0x27,0x81,0x16,0xac,0x00,0xaf};
uint8 config180deg[14]={0x40,0xa0,0xc8,0xa6,0xa2,0x2f,0xf8,0x00,0x27,0x81,0x16,0xac,0x00,0xaf};
vAHI_SpiConfigure( 2, /* number of slave select lines in use */
E_AHI_SPIM_MSB_FIRST, /* send data MSB first */
FALSE,
FALSE,
1,//8MHz
E_AHI_SPIM_INT_DISABLE, /* Disable SPI interrupt */
E_AHI_SPIM_AUTOSLAVE_DSABL); /* Disable auto slave select */
vAHI_DioSetDirection(0,lcd->resetpin);
vAHI_DioSetDirection(0,lcd->a0pin);
vAHI_DioSetOutput(0,lcd->resetpin);
cycleDelay(16*4000);
vAHI_DioSetOutput(lcd->resetpin,0);
vAHI_DioSetOutput(0,lcd->a0pin);
int i;
vAHI_SpiSelect(lcd->spicspin);
for(i=0;i<sizeof(config0deg);i++)
{
if(angle==180)vAHI_SpiStartTransfer8(config180deg[i]);
else vAHI_SpiStartTransfer8(config0deg[i]);
vAHI_SpiWaitBusy();
}
vAHI_SpiStop();
}
DRESULT disk_writep (
const BYTE* buff, /* Pointer to the data to be written, NULL:Initiate/Finalize write operation */
DWORD sc /* Sector number (LBA) or Number of bytes to send */
)
{
DRESULT res;
uint8_t* r, data_response, status_code;
uint16_t i;
static uint16_t d;
PRINTF("disk_writep(buff=0x%x, sc=%d)\n", buff, sc);
if (!buff) {
if (sc) { // initialize write process
for(i = 0; i < SD_TRANSACTION_ATTEMPTS; i++) {
if (write_state != IDLE) {
PRINTF("sd: initialize write, write transaction already in progress\n");
return RES_NOTRDY;
}
LOWER_CS();
send_command(WRITE_BLOCK, sc*rw_block_size);
r = get_response(R1);
if(r != NULL && r[0] == 0) {
PRINTF("write request OK\n");
break;
}
RAISE_CS();
}
if (r==0) {
PRINTF("no response to write request\n");
return RES_NOTRDY;
}
/* re-select card and wait to transmit data */
LOWER_CS();
vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(START_BLOCK_TOKEN);
vAHI_SpiWaitBusy();
write_state = TRANSMIT;
d=0;
return RES_OK;
} else { // finalize write process
if (write_state != TRANSMIT) {
PRINTF("sd: finalize error, write transaction not started\n");
return RES_NOTRDY;
}
PRINTF("finalizing write request after %d bytes",d);
for(i=0;i<SD_TRANSACTION_ATTEMPTS*10; i++) {
vAHI_SpiStartTransfer8(SPI_IDLE);
vAHI_SpiWaitBusy();
data_response = u8AHI_SpiReadTransfer8();
if((data_response & 0x11) == 1) {
/* Data response token received. */
status_code = (data_response >> 1) & 0x7;
if(status_code == DATA_ACCEPTED) {
PRINTF(" OK (%d tries)\n", i);
res = RES_OK;
break;
} else {
PRINTF(" ERROR (%d tries)\n", i);
res = RES_ERROR;
break;
}
}
}
/* wait until card is idle */
while (u8AHI_SpiReadTransfer8()!=SPI_IDLE) {
vAHI_SpiStartTransfer8(SPI_IDLE);
vAHI_SpiWaitBusy();
}
if (i==SD_TRANSACTION_ATTEMPTS)
PRINTF(" ERROR (timeout %d tries)\n", i);
RAISE_CS();
write_state = IDLE;
}
} else { // Send data to the disk
DRESULT
disk_readp2(
int read_cmd,
BYTE *dest,
DWORD sect,
DWORD offset,
WORD count)
{
unsigned char *r = NULL;
int retval = RES_ERROR, i, token;
if (write_state==TRANSMIT) {
PRINTF("sd: read failed, write transaction in progress\n");
return RES_NOTRDY;
}
PRINTF("disk_readp(%d,0x%x,%d,%d,%d)==",read_cmd, dest,sect,offset,count);
if (read_cmd==READ_SINGLE_BLOCK && offset+count > rw_block_size) {
PRINTF("attempting to read block (%d) bigger than rw_block_size (%d)!!"
,offset+count,rw_block_size);
return 0;
}
/* try and send the read command */
for(i = 0; i < SD_TRANSACTION_ATTEMPTS; i++) {
LOWER_CS();
send_command(read_cmd, sect*rw_block_size);
r = get_response(R1);
if(r != NULL && r[0]==0) {
break;
}
RAISE_CS();
}
if (r==NULL || r[0]!=0) {
PRINTF("error during read");
RAISE_CS();
return RES_ERROR;
}
/* We received an R1 response with no errors.
Get a token from the card now. */
for(i = 0; i < SD_TRANSACTION_ATTEMPTS; i++) {
vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(0xff);
vAHI_SpiWaitBusy();
token = u8AHI_SpiReadTransfer8();
if(token == START_BLOCK_TOKEN || (token > 0 && token <= 8))
break;
}
PRINTF("returned read token: %d (%d attemtps)\n", token, i);
if(token == START_BLOCK_TOKEN) {
/* consume the offset */
for(i=0; i<offset; i++) {
vAHI_SpiStartTransfer8(0x00);
vAHI_SpiWaitBusy();
u8AHI_SpiReadTransfer8();
}
/* A start block token has been received. Read the block now. */
for(i=0; i<count; i++) {
vAHI_SpiStartTransfer8(0x00);
vAHI_SpiWaitBusy();
dest[i] = u8AHI_SpiReadTransfer8();
}
/* consume what is left of the block
* XXX: might wanna send STOP_COND here instead of consuming whole block */
if (read_cmd==READ_SINGLE_BLOCK)
for (i=0; i<(rw_block_size-offset-count); i++) {
vAHI_SpiStartTransfer8(0x00);
vAHI_SpiWaitBusy();
}
/* Consume CRC. TODO: Validate the block. */
vAHI_SpiStartTransfer8(0x00); vAHI_SpiWaitBusy();
vAHI_SpiStartTransfer8(0x00); vAHI_SpiWaitBusy();
retval = RES_OK;
} else if(token > 0 && token <= 8) {
/* The card returned a data error token. */
retval = RES_ERROR;
if (retval & (1<<0))
PRINTF("General Error\n");
else if (retval & (1<<1))
PRINTF("Internal card controller error\n");
else if (retval & (1<<2))
PRINTF("Card ECC error\n");
else if (retval & (1<<3))
PRINTF("Out of Range\n");
} else {
/* The card never returned a token after our read attempts. */
retval = RES_NOTRDY;
PRINTF("no returned read token\n");
}
RAISE_CS();
return retval;
}
