static __inline void send_ctrl_cmd(unsigned int cmd)
{
unsigned char high_8bit = (cmd>>8)&0x00FF;
unsigned char low_8bit = cmd&0x00FF;
spi_send_data(0x2000|high_8bit);
spi_send_data(0x0000|low_8bit);
}
void spi_poll(void)
{ /* INTERRUPT CONTEXT CALL*/
if (!poll_started){
spi_send_data(POLL_DATA0.data, POLL_DATA0.length, spi_ch0);
spi_send_data(POLL_DATA1.data, POLL_DATA1.length, spi_ch1);
spi_send_data(POLL_DATA2.data, POLL_DATA2.length, spi_ch2);
}
}
static __inline void send_data_cmd(unsigned int data)
{
dbg_print("===> [ILI9481_DPI] <%s %s> %s:%d %s(): : data:0x%x \n", __DATE__, __TIME__, __FILE__, __LINE__, __func__, data);
unsigned int out = (data & 0xFF)| 0x100;
spi_send_data(out);
}
static __inline void send_ctrl_cmd(unsigned int cmd)
{
dbg_print("===> [ILI9481_DPI] <%s %s> %s:%d %s(): cmd:0x%x \n", __DATE__, __TIME__, __FILE__, __LINE__, __func__,cmd);
unsigned int out = (cmd & 0xFF);
spi_send_data(out);
}
static __inline void send_data_cmd(unsigned int data)
{
SET_LSCE_HIGH;
SET_LSDA_HIGH;
SET_LSCK_HIGH;
SET_LSCE_LOW;
UDELAY(1);
SET_LSCK_LOW;
SET_LSDA_HIGH;
UDELAY(1);
SET_LSCK_HIGH;
UDELAY(1);
spi_send_data(data);
SET_LSCK_HIGH;
SET_LSDA_HIGH;
SET_LSCE_HIGH;
UDELAY(1);
}
static __inline void send_ctrl_cmd(unsigned int cmd)
{
SET_LSCE_HIGH;
SET_LSDA_HIGH;
SET_LSCK_HIGH;
SET_LSCE_LOW;
UDELAY(1);
SET_LSCK_LOW;
SET_LSDA_LOW;
UDELAY(1);
SET_LSCK_HIGH;
UDELAY(1);
spi_send_data(cmd);
SET_LSCK_HIGH;
SET_LSDA_HIGH;
SET_LSCE_HIGH;
UDELAY(1);
}
static int write_data (
uint8 *buff, /* 512 byte data block to be transmitted */
uint8 token /* Data/Stop token */
)
{
uint8 resp;
uint16 crc;
int old;
if (wait_ready() != 0xFF)
return -1;
spi_send_byte(token); /* Xmit data token */
if (token != 0xFD) { /* Is data token */
dcache_pref_range((uint32)buff, 512);
crc = net_crc16ccitt(buff, 512, 0);
old = irq_disable();
spi_send_data(buff, 512);
spi_send_byte((uint8)(crc >> 8));
spi_send_byte((uint8)crc);
irq_restore(old);
resp = spi_rec_byte(); /* Reсeive data response */
if ((resp & 0x1F) != 0x05) { /* If not accepted, return with error */
#ifdef SD_DEBUG
dbglog(DBG_DEBUG, "%s: not accepted: %02x\n", __func__, resp);
#endif
errno = EIO;
return -1;
}
}
static __inline void send_data_cmd(unsigned int data)
{
unsigned int out = (DATA_ID | (data & 0xFF));
spi_send_data(out);
}
static __inline void send_ctrl_cmd(unsigned int cmd)
{
unsigned int out = (CTRL_ID | (cmd & 0xFF));
spi_send_data(out);
}
static void send_data_cmd(unsigned int data)
{
unsigned int out = (DEVIE_ID | (0x2 << 16) | data );
spi_send_data(out);
}
void send_ctrl_cmd(unsigned int cmd)
{
unsigned int out = (DEVIE_ID | cmd );
spi_send_data(out);
}
static __inline void Write_register(unsigned int data)
{
unsigned int out = ((HX_WR_REGISTER<<16) |(data & 0xFFFF));
spi_send_data(out);
}
static __inline void Write_com(unsigned int cmd)
{
unsigned int out = ((HX_WR_COM<<16) | (cmd & 0xFFFF));
spi_send_data(out);
}
static __inline void send_data_cmd(unsigned int data)
{
unsigned char high_8bit = (data>>8)&0x00FF;
unsigned char low_8bit = data&0x00FF;
spi_send_data(0x4000|low_8bit);
}
/**
* \ingroup sd_raw
* Writes raw data to the card.
*
* \note If write buffering is enabled, you might have to
* call sd_raw_sync() before disconnecting the card
* to ensure all remaining data has been written.
*
* \param[in] offset The offset where to start writing.
* \param[in] buffer The buffer containing the data to be written.
* \param[in] length The number of bytes to write.
* \returns 0 on failure, 1 on success.
* \see sd_raw_write_interval, sd_raw_read, sd_raw_read_interval
*/
uint8_t sd_raw_write(uint32_t offset, const uint8_t* buffer, uint16_t length)
{
#if SD_RAW_WRITE_SUPPORT
if(get_pin_locked())
return 0;
uint32_t block_address;
uint16_t block_offset;
uint16_t write_length;
while(length > 0)
{
/* determine byte count to write at once */
block_address = offset & 0xfffffe00;
block_offset = offset & 0x01ff;
write_length = 512 - block_offset; /* write up to block border */
if(write_length > length)
write_length = length;
/* Merge the data to write with the content of the block.
* Use the cached block if available.
*/
if(block_address != raw_block_address)
{
#if SD_RAW_WRITE_BUFFERING
if(!sd_raw_sync())
return 0;
#endif
if(block_offset || write_length < 512)
{
if(!sd_raw_read(block_address, raw_block, sizeof(raw_block)))
return 0;
}
raw_block_address = block_address;
}
if(buffer != raw_block)
{
memcpy(raw_block + block_offset, buffer, write_length);
#if SD_RAW_WRITE_BUFFERING
raw_block_written = 0;
if(length == write_length)
return 1;
#endif
}
/* address card */
select_card();
/* send single block request */
if(sd_raw_send_command_r1(CMD_WRITE_SINGLE_BLOCK, block_address))
{
unselect_card();
spi_rec_byte();
return 0;
}
/* send start byte */
spi_send_byte(0xfe);
/* write byte block */
spi_send_data(raw_block, 512);
/* write dummy crc16 */
spi_send_byte(0xff);
spi_send_byte(0xff);
/* wait while card is busy */
/*
uint16_t i;
for(i = 0; i < 0x7fff; ++i)
{
if(spi_rec_byte() == 0xff)
break;
}
if(i >= 0x7fff)
{
unselect_card();
spi_rec_byte();
return 0;
}
*/
// obiger code reicht bei langsamen Karten nicht aus!
// daher nachfolgende alte Version mit endlos Warteschleife
// Wil.
while(spi_rec_byte() != 0xff);
spi_rec_byte();
/* deaddress card */
unselect_card();
buffer += write_length;
offset += write_length;
length -= write_length;
#if SD_RAW_WRITE_BUFFERING
raw_block_written = 1;
#endif
}
return 1;
#else
return 0;
#endif
}
static int init_lcd_panel(struct spi_device *spi)
{
//rm68040
//IOVCC=VCC=2.8V
spi_send_cmd(spi, 0x11);
mdelay(20);
spi_send_cmd(spi, 0xB4);
spi_send_data(spi, 0x10);
spi_send_cmd(spi, 0xD0);
spi_send_data(spi, 0x07);//02
spi_send_data(spi, 0x41);
spi_send_data(spi, 0x1D);//13
spi_send_cmd(spi, 0xD1);
spi_send_data(spi, 0x00);//00
spi_send_data(spi, 0x0e);//0X28
spi_send_data(spi, 0x0e);//19
spi_send_cmd(spi, 0xD2);
spi_send_data(spi, 0x01);
spi_send_data(spi, 0x11);
spi_send_cmd(spi, 0xC0);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x3B);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x02);//12
spi_send_data(spi, 0x11);//01
spi_send_cmd(spi, 0xC1);
spi_send_data(spi, 0x10);
//spi_send_data(spi, 0x11);
spi_send_data(spi, 0x13);
spi_send_data(spi, 0x88);
spi_send_cmd(spi, 0xC5);
spi_send_data(spi, 0x02);
//spi_send_data(spi, 0x07);
spi_send_cmd(spi, 0xC6);
spi_send_data(spi, 0x03);
spi_send_cmd(spi, 0xC8);
spi_send_data(spi, 0x02);
spi_send_data(spi, 0x46);
spi_send_data(spi, 0x14);
spi_send_data(spi, 0x31);
spi_send_data(spi, 0x0A);
spi_send_data(spi, 0x04);
spi_send_data(spi, 0x37);
spi_send_data(spi, 0x24);
spi_send_data(spi, 0x57);
spi_send_data(spi, 0x13);
spi_send_data(spi, 0x06);
spi_send_data(spi, 0x0C);
spi_send_cmd(spi, 0xF3);
spi_send_data(spi, 0x24);
spi_send_data(spi, 0x1A);
spi_send_cmd(spi, 0xF6);
spi_send_data(spi, 0x80);
spi_send_cmd(spi, 0xF7);
spi_send_data(spi, 0x80);
spi_send_cmd(spi, 0x36);
spi_send_data(spi, 0x0A);
//spi_send_data(spi, 0x08);
spi_send_cmd(spi, 0x3A);
spi_send_data(spi, 0x66);
spi_send_cmd(spi, 0x2A);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x01);
spi_send_data(spi, 0x3F);
spi_send_cmd(spi, 0x2B);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x00);
spi_send_data(spi, 0x01);
spi_send_data(spi, 0xDF);
mdelay(120);
spi_send_cmd(spi, 0x29);
//udelay(120000);
//spi_send_cmd(spi, 0x2C);
return 0;
}