SPI: EA DOGS102 verträgt sich nicht mit EEPROM 25C080

[Martin S. (maklin)]

Hallo allerseits!

Es geht um die im Bild dargestellte Schaltung, wobei ich nur den Teil 
darstelle, der meiner Meinung nach relevant ist.
Der Mikrocontroller (Atmega8L) soll über SPI sowohl mit einem EEPROM als 
auch mit dem Display EA DOGS102 kommunizieren. Dazu wird das jeweilige 
Bauteil per CS-Leitung aktiviert. Solange ich nur mit dem Display 
"spreche", funkioniert das ganze auch problemlos. Kommt allerdings ein 
einzelner Zugriff auf das EEPROM hinzu, dann werden keine Informationen 
mehr auf dem Display dargestellt.
Nun der Reihe nach:

int main(void)
{
  spi_init();
  EEPROM_INIT();
  EEPROM_READ_DATA(0);
  LCD_Init();
  zeile=7;
  spalte=16;
  LCD_Clear();
  write_zeichen8('T');
  write_zeichen8('e');
  write_zeichen8('s');
  write_zeichen8('t');
  while(1) asm volatile("nop");
}

Ich mache es mal ganz ausführlich. Zunächst wird das SPI initialisiert:

void spi_init(void)
{
  //SPI Data Direction Register
  DDR_SPI |= (1<<MOSI);
  DDR_SPI |= (1<<SCK);
  DDR_SPI &=~(1<<MISO);

  //SPI Control Register
  SPCR |= (1<<SPE);
  SPCR |= (1<<MSTR);
  SPCR |= (1<<CPOL); 
  SPCR |= (1<<CPHA);
  SPCR &=~ (1<<DORD);
  SPCR &=~ (1<<SPR1);
  SPCR &=~ (1<<SPR0);

  //SPI Status Register
  SPSR |= (1<<SPI2X); 
}

Nachfolgend kann das EEPROM initialisiert (lediglich deselektiert) 
werden (man kann die Funktion mit der SPI-Init tauschen, das macht 
keinen Unterschied):

void EEPROM_INIT(void)
{
  DDR_EEPROM |= (1<<CS_EEPROM); //Ausgang
  PORT_EEPROM |= (1<<CS_EEPROM); //deselect
}

Nun soll ein Zugriff darauf erfolgen, dies geschieht mit den folgenden 
Funktionen:

uint8_t EEPROM_READ_DATA(uint16_t adresse)
{
  EEPROM_check_busy();
  
  PORT_EEPROM &=~ (1<<CS_EEPROM); //select
  EEPROM_RW(READ);
  EEPROM_RW((uint8_t)(adresse>>8));
  EEPROM_RW((uint8_t)(adresse&0b0000000011111111));
  uint8_t ret_val=EEPROM_RW(0);
  PORT_EEPROM |= (1<<CS_EEPROM); //deselect
  return ret_val;
}

void EEPROM_check_busy(void)
{
  while (READ_SREG()&0b00000001) _delay_ms(1);
}

uint8_t EEPROM_RW(uint8_t data)
{
  SPI_SCK_IDLE_LOW();
  asm volatile("nop");
  uint8_t ret_val=spi_send_and_receive(data);
  asm volatile("nop");  
  return ret_val;
}

uint8_t READ_SREG(void)
{
  PORT_EEPROM &=~ (1<<CS_EEPROM); //select
  EEPROM_RW(RDSR);
  uint8_t ret_val=EEPROM_RW(0);
  PORT_EEPROM |= (1<<CS_EEPROM); //deselect
  return ret_val;
}

inline void SPI_SCK_IDLE_LOW(void)
{
  SPCR &=~ ((1<<CPOL)|(1<<CPHA));
}

char spi_send_and_receive (char data)
{
  SPDR = data;
  while (!(SPSR & (1<<SPIF)));
  data = SPDR;
  return data;
}

Jetzt folgt der Zugriff auf das Display. Hierzu wird es zuerst 
initialisiert:

void LCD_Init(void)
{
  EA_DDR|=(1<<EA_CS)|(1<<EA_CD)|(1<<EA_RST);
  EA_PORT|=(1<<EA_CS); 
  //Reset
  EA_PORT&=~(1<<EA_RST);
  _delay_ms(1);
  EA_PORT|=(1<<EA_RST);
  _delay_ms(5);

  //LCD-Init
  write_command(0b01000000); //Display start Line 0
  write_command(0b10100001); //SEG
  write_command(0b11000000); //COM0-63
  write_command(0b10100100); //Set all Pixels to on
  write_command(0b10100110); //Display normal/inverse off
  write_command(0b10100010); //1/9 (1/65)
  write_command(0b00101111); //Booster
  write_command(0b00100111); //Set VLCD Resistor Ratio
  write_command(0b10000001); //Contrast
  write_command(0b00010000); //Contrast
  write_command(0b11111010); //Temperatur Compensation
  write_command(0b10010000); //Temperatur Compensation
  write_command(0b10101111); //Display on
  //Ende Init.
}

void write_command(uint8_t cmd)
{
  SPI_SCK_IDLE_HIGH();
  EA_PORT&=~(1<<EA_CS);
  EA_PORT&=~(1<<EA_CD); //Command
  spi_send_and_receive(cmd);
  EA_PORT|=(1<<EA_CS);
}

Ich erspare mir an dieser Stelle die genauen Funktionen zum designen der 
Schrift. Letztendlich läuft es auch dort auf diese Funktion hinaus:

void write_data(uint8_t data)
{
  SPI_SCK_IDLE_HIGH();
  EA_PORT&=~(1<<EA_CS);
  EA_PORT|=(1<<EA_CD); //Data
  spi_send_and_receive(data);
  EA_PORT|=(1<<EA_CS);
}

Wie gesagt, lässt man den Zugriff auf das EEPROM sein, so funktioniert 
die ganze Sache sehr gut. Dazu braucht man nur

EEPROM_READ_DATA(0);

auskommentieren.
Ich will natürlich den Zugriff auf das EEPROM ermöglichen. Ich komme 
jedoch in der Fehlersuche nicht mehr weiter. Ich kann am Oszi keine 
Überschneidung des CS-Signals erkennen (wäre ja denkbar). Ebenfall 
scheint das Programm sich nicht in der EEPROM-Funktion aufzhängen, es 
erscheinen erwartungsgemäß 6 SPI-Zugriffe und dann nach ca. 6 ms die 
Zugriffe auf das Display.
Interessanterweise kommt es zu einem zweiten Reset der Schaltung nach 
etwa 150 ms, wenn man den Programmierstecker dran lässt und einen 
elektrischen Reset durchführt (auch in der funktionstüchtigen 
Programmvariante).
Vielleicht hat jemand von euch ja mal eine ähnliche Schaltung aufgebaut 
und auch das Problem gehabt und gelöst, bzw kann mir anderweitig helfen?

Ich bedanke mich schon mal für konstruktive Antworten!