void at45_read(uint16_t addr, uint8_t pagemode) {
at45_busywait();
spi_select(CS_AT45);
spi_txrx(AT45_CMD_AREAD);
spi_txrx(addr>>7);
spi_txrx(addr<<1);
spi_txrx(0);
spi_txrx(0);
spi_txrx(0);
spi_txrx(0);
spi_txrx(0);
if(!pagemode)
return;
for(addr=0; addr < 264; addr++)
answer[addr] = spi_txrx(0);
spi_select(0);
}
/* TODO: timeout */
void at45_busywait(void) {
uint8_t status;
do {
spi_select(CS_AT45);
spi_txrx(AT45_CMD_STATUS);
status = spi_txrx(0);
spi_select(0);
} while (!(status & AT45_STATE_READY));
}
void sx1276_cfg_write_data(sx1276_cfg_reg_t r, uint8_t *d, uint8_t s)
{
spi_select(ENABLE);
spi_send(r | 0x80);
while(s)
{
spi_send(*d);
d++; s--;
}
spi_select(DISABLE);
}
void sx1276_cfg_read_data(sx1276_cfg_reg_t r, uint8_t *d, uint8_t s)
{
spi_select(ENABLE);
spi_send(r & 0x7F);
while(s)
{
*d = spi_send(0x00);
d++; s--;
}
spi_select(DISABLE);
}
void eeprom_page_write(unsigned long addr, unsigned char* buf, unsigned char len)
{
spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN);
_delay_us(10);
spi_write(EEPROM_WRITE); // byte write
// wyœlij adres 24-bitowy
spi_write( (addr >> 16) & 0xff);
spi_write( (addr >> 8) & 0xff);
spi_write( addr & 0xff);
// wyœlij bajty do zapisania
for (unsigned char i=0; i < len; i++)
spi_write(buf[i]);
spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN);
//_delay_ms(2);_delay_ms(2);_delay_ms(2);_delay_ms(2); // Twc = 6ms
// czekaj na zakoñczenie operacji zapisu (Twc=6ms)
while ( (eeprom_status() & 0x01) ) // Write In Progress (WIP)
_delay_ms(1);
return;
}
static void cfi_send_command(
struct cfi *cfi, char cmd, int *addr, char *buf, int len, int write)
{
int spi = cfi->spi;
int i;
cfi_led(1);
spi_select(spi);
spi_transfer(spi, cmd);
if (addr) {
spi_transfer(spi, *addr >> 16);
spi_transfer(spi, *addr >> 8);
spi_transfer(spi, *addr);
}
if (buf) {
for(i=0;i < len; i++) {
if (write) {
spi_transfer(spi, *buf++);
} else {
*buf++ = spi_transfer(spi, 0x00);
}
}
}
spi_deselect(spi);
cfi_led(0);
}
static inline uint32_t ms5611_convert_pressure(void)
{
uint32_t data;
spi_select();
spi_write(0x48); //highest resolution option
spi_deselect();
//delay_ms(10);
delay_ms(10);
spi_select();
spi_write(0x00);
data = ((uint32_t)spi_read())<<16;
data+= ((uint32_t)spi_read())<<8;
data+= ((uint32_t)spi_read());
spi_deselect();
delay_ms(1);
return data;
}
void mcp2515_request_to_send(int reg)
{
spi_select();
spi_transmit(reg);
spi_deselect();
}
void reset_sequence_ms5611 (void)
{
spi_select(); //selects the MS5611
MS5611_SPI.DATA = MS5611_RESET;
while(!(MS5611_SPI.STATUS>>7));
spi_deselect();
delay_ms(1);
}
void at45_write(uint16_t addr, uint8_t *data) {
at45_busywait();
spi_select(CS_AT45);
spi_txrx(AT45_CMD_APROG);
spi_txrx(addr>>7);
spi_txrx(addr<<1);
spi_txrx(0);
for(addr=0; addr < 264; addr++)
spi_txrx(data[addr]);
spi_select(0);
}
void mcp2515_reset()
{
spi_select();
spi_transmit(MCP_RESET);
spi_deselect();
}
uint8_t flash_read_status(){
uint8_t status;
spi_select();
spi_out_byte(FLASH_READ_STATUS);
status = spi_in_byte();
spi_deselect();
return status;
}
void eeprom_enable_write(unsigned char enable)
{
spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN);
_delay_us(10);
spi_write( (enable == 1 ? EEPROM_WREN : EEPROM_WRDI) ); // enable / disable write
spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN);
}
void platform_spi_select( spi_userdata *spi, int is_select ) {
spi_set_speed(spi->spi, spi->speed);
spi_clr_and_set(spi->spi, spi->mode);
if (is_select) {
spi_select(spi->spi);
} else {
spi_deselect(spi->spi);
}
}
void flash_erase_chip(){
flash_unprotect();
spi_select();
spi_out_byte(FLASH_ERASE_CHIP);
spi_deselect();
flash_wait_complete();
flash_protect();
}
void flash_erase_sector(int sector){
flash_unprotect(sector);
spi_select();
spi_out_byte(FLASH_ERASE_SECTOR);
flash_send_address((sector * PAGE_SIZE) + 1);
spi_deselect();
flash_wait_complete();
flash_protect(sector);
}
void flash_read(uint8_t* buf, uint32_t addr, size_t size){
spi_select();
spi_out_byte(FLASH_READ);
flash_send_address(addr);
int i;
for(i = 0; i < size; i++){
buf[i] = spi_in_byte();
}
spi_deselect();
}
void mcp2515_write(char addr, char data)
{
spi_select();
spi_transmit(MCP_WRITE);
spi_transmit(addr);
spi_transmit(data);
spi_deselect();
}
char mcp2515_read_status()
{
char output;
spi_select();
spi_transmit(MCP_READ);
spi_transmit(MCP_CANSTAT);
output = spi_receive();
spi_deselect();
return output;
}
void mcp2515_bit_modify(char addr, char mask_byte, char data)
{
spi_select();
spi_transmit(MCP_BITMOD);
spi_transmit(addr);
spi_transmit(mask_byte);
spi_transmit(data);
spi_deselect();
}
void flash_write_page(uint8_t* buf, int page){
flash_unprotect();
spi_select();
spi_out_byte(FLASH_PROG_PAGE);
flash_send_address(page * PAGE_SIZE);
int i;
for(i = 0; i < PAGE_SIZE; i++){
spi_out_byte(buf[i]);
}
spi_deselect();
flash_wait_complete();
}
void eeprom_93c06_enable_write(int en)
{
unsigned char trash;
unsigned char op = (en ? SPI_OP_93C06_EWEN_MASK : SPI_OP_93C06_EWDS_MASK);
spi_select();
eeprom_93c06_start_bit();
spi_transmit(op, &trash);
spi_deselect();
}
char mcp2515_read (char addr){
char result;
spi_select();
spi_transmit(MCP_READ);
spi_transmit(addr);
result = spi_receive();
spi_deselect();
return result;
}
void ms5611_prom_read (void)
{
for( int i = 0; i < 6; i++ ){
delay_ms(1);
spi_select();
spi_write(0xA2 + (i*2) );
coeff[i] = ((uint16_t)spi_read())<<8;
coeff[i]+= ((uint16_t)spi_read());
spi_deselect();
delay_ms(1);
//printf("C%d:\t%u\n", i, coeff[i]);
}
}
void flash_init(){
spi_init();
spi_select();
spi_out_byte(FLASH_READ_ID);
flash_id = spi_in_byte() << 16;
flash_id |= spi_in_byte() << 8;
flash_id |= spi_in_byte();
flash_size = 1 << (flash_id & 0xFF);
printf("JEDEC ID: %06X, size: %u bytes\n", (unsigned int)flash_id, flash_size);
spi_deselect();
}
unsigned char eeprom_status()
{
spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN);
_delay_us(10);
spi_write(EEPROM_RDSR); // read status register
// wyœlij bajt do zapisania
unsigned char status = spi_read();
spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN);
return status;
}
static uint8_t flash_read_status_register()
{
uint8_t status, out = SPI_FLASH_READ_STATUS;
// if we fail to get the bus, then fake a Write-In-Progress
if (!spi_select(SPI_DEVICE_P5Q))
{
return P5Q_WIP;
}
spi_write(&out, 1);
spi_read(&status, 1);
spi_release();
// shell_printf("st %x", status);
return status;
}
void eeprom_93c06_write_short(unsigned char addr, unsigned short data)
{
unsigned char trash;
spi_select();
eeprom_93c06_start_bit();
spi_transmit(SPI_OP_93C06_WRITE_MASK | SPI_93C06_ADDR_MASK(addr), &trash);
spi_transmit(SPI_93C06_WRITE_DATA_BYTE1(data), &trash);
spi_transmit(SPI_93C06_WRITE_DATA_BYTE2(data), &trash);
spi_deselect();
/* Operation takes 2ms to be guaranteed. */
msleep(2);
}
void eeprom_chip_erase()
{
eeprom_enable_write(1);
spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN);
_delay_us(10);
spi_write(EEPROM_CE); // chip erase
spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN);
// czekaj na zakoñczenie operacji kasowania
while ( (eeprom_status() & 0x01) ) // Write In Progress (WIP)
_delay_ms(1);
eeprom_enable_write(1);
}
// Set each LEDs on or off state from a 16-bit value.
//
// LED d1 = bit 1
// LED d2 = bit 2
//
// etc, in the pattern:
//
// 1 2 3 4
// 5 6 7 8
// 9 10 11 12
// 13 14 15 16
//
void led_set_state(uint16_t new_state)
{
// If no lights have changed, transmit nothing. This saves bandwidth on
// the SPI bus for more important things.
if (g_led_state == new_state) return;
spi_select(SPI_SLAVE_LED); // Pull LAT low
// Transmit Most Significant Byte first.
spi_transmit(new_state >> 8);
spi_transmit(new_state & 0xff);
// Latch the result to the LEDs by pulsing high.
//PORTB |= LED_LATCH;
//PORTB &= ~LED_LATCH;
spi_select_none(); // Pull LAT high
// record the state.
g_led_state = new_state;
}
