Memória RAM externa no LPC2478

[Sergio38br]

Styg , vc ajustou a taxa de reflesh da memoria?, se sim qual o valor que tu deixastes???

[ ]'s
Sergio

[styg]

po que estranho, nem vi a resposta de voces, e tava todo ansioso esperando alguem responder.. .


bom, agora dei uma mexida aqui e fiz novos testes.
na verdade a mesma coisa de antes, escreve e depois le.
só que fiz com ponteiro p/ 8, 16 e 32bits:

char_wr_ptr = (unsigned char *)SDRAM_BASE_ADDR;
for (i=0; i<5; i++)
{ *char_wr_ptr++ = 0x00; *char_wr_ptr++ = 0x11;
*char_wr_ptr++ = 0x22; *char_wr_ptr++ = 0x33; }

char_wr_ptr = (unsigned char *)SDRAM_BASE_ADDR;
for ( i= 0; i < 20; i++ )
{ char_wr_ptr++; }

short_wr_ptr = (unsigned short *)SDRAM_BASE_ADDR;
for (i=0; i<5; i++)
{ *short_wr_ptr++ = 0x0123; *short_wr_ptr++ = 0x4567;
*short_wr_ptr++ = 0x89AB; *short_wr_ptr++ = 0xCDEF; }

short_wr_ptr = (unsigned short *)SDRAM_BASE_ADDR;
for ( i= 0; i < 20; i++ )
{ short_wr_ptr++; }

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
for (i=0; i<5; i++)
{ *wr_ptr++ = 0x02468ACE; *wr_ptr++ = 0x13579BDF;
*wr_ptr++ = 0x02468ACE; *wr_ptr++ = 0x13579BDF; }

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
for ( i= 0; i < 20; i++ )
{ wr_ptr++; }

o que percebi é que esse pau soh da em 32 bits.
em 8 e 16 bits ele escreveu todos as 20 vezes corretamente!
resta saber o porque.

guest, fiz esse teu teste, e o resultado foi o seguinte, nessa rotina:

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
for (i=0; i<20; i++)
{ *wr_ptr++ = i; }

resultados:

End: 0xA000 0000 Valor: 0x0000 0000
End: 0xA000 0004 Valor: 0x0000 0001
End: 0xA000 0008 Valor: 0x0000 0000 // deu pau
End: 0xA000 000C Valor: 0x1004 0000 // deu pau
End: 0xA000 0010 Valor: 0x0000 0004
End: 0xA000 0014 Valor: 0x0000 0005
End: 0xA000 0018 Valor: 0x0000 0000 // deu pau
End: 0xA000 001C Valor: 0x1004 0000 // deu pau
End: 0xA000 0020 Valor: 0x0000 0008
End: 0xA000 0024 Valor: 0x0000 0009


Sergio, cara, são tantos refreshs que nem sei qual tu quer saber hehehe.

mas os refreshs são os seguintes:

/* Auto refresh period 5cclk */
EMC_DYN_RFC = 4;
/* Set refresh period 1120cclks */
EMC_DYN_RFSH = 0x46;

[styg]

dando um up.

pra caso o guest ou o sergio nao terem visto

[MarcusPonce]

Oi Styg,

Você poderia repetir o teste do Guest acrescentando um linha ?:

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
wr_ptr += 8;
for (i=0; i<20; i++)
{ *wr_ptr++ = i; }

Vamos ver o que acontece.

[Sergio38br]

alguem ainda se lembra por que o 12???



deem uma olhada..

Código: Selecionar todos

/*
SHIFT_HIGH_PERFORMANCE = COL + TBW + BANK, where
COL=# of column bits (here: 9)
TBW=total bus width, 1=16 bits, 2=32 bits (here: 1)
BANK=# of bank select bits (here: 2)

Just for completeness: For "low-power" SDRAM leave out the BANK term:
SHIFT_LOW_POWER = COL + TBW
*/
#define SHIFT_HIGH_PERFORMANCE (9+1+2)

// Burst 8, Sequential, CAS-2
volatile unsigned short int Dummy = *(volatile unsigned short *)
(((Int32U)&SDRAM_BASE_ADDR) | (0x33<<(SHIFT_HIGH_PERFORMANCE)));


end. do forum correspondente

http://www.embeddedrelated.com/groups/l ... /36502.php


P.S. puxa se vc não desse esta ajustada não tinha visto... agora vc quer que fucione em bus de 32 acho que tem de alterar legal , por que esta memoria tem o arranjo logico de no maximo 4 x 16


[ ]'s
Sergio

[MarcusPonce]

Mas parece que para esta memória deveria ser 11 ou 9, pois tem só 8 bits para coluna.

[styg]

sergio, nao alterei o bus nao. continua sendo de 16bits. o que quero é gravar dados de 32bits, coisa que o controlador deveria se virar pra fazer.

marcus, eu acho que tem que ser 11 mesmo, 8 do numero de colunas, 1 por ser 16bits e 2 pro numero de bancos que sao 4.

[styg]

marcus, teste com a linha a mais que sugerisse, mas não entendi o porque.

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
wr_ptr += 8;
for (i=0; i<40; i++)
{ *wr_ptr++ = i; }
wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
for ( i= 0; i < 40; i++ )
{ wr_ptr++; }

resultados foram parecidos:

End: 0xA000 0000 Valor: 0x0000 0000 // não importa
End: 0xA000 0004 Valor: 0x0000 0000 // não importa
... //
End: 0xA000 0020 Valor: 0x0000 0000 // -->começa aqui - ok
End: 0xA000 0024 Valor: 0x0000 0001 // ok
End: 0xA000 0028 Valor: 0x0000 0000 // nada
End: 0xA000 002C Valor: 0x1004 0000 // deu pau
End: 0xA000 0030 Valor: 0x0000 0004 // ok
End: 0xA000 0034 Valor: 0x0000 0005 // ok
End: 0xA000 0038 Valor: 0x0000 0000 // nada
End: 0xA000 003C Valor: 0x1004 0000 // deu pau
End: 0xA000 0040 Valor: 0x0000 0008 // ok
End: 0xA000 0044 Valor: 0x0000 0009 // ok
End: 0xA000 0048 Valor: 0x0000 0000 // nada
End: 0xA000 004C Valor: 0x1004 0000 // deu pau
End: 0xA000 0050 Valor: 0x0000 000C // ok
End: 0xA000 0054 Valor: 0x0000 000D // ok

[MarcusPonce]

Styg, obrigado.
O objetivo é testar se o problema das words que ficam com dados errados depende somente do hardware ou se depende da ordem em que a memória e o buffer do controlador são acessados.

Infelizmente preciso pedir o favor de que você refaça o teste, pois me enganei e escrevi:
wr_ptr += 8;
quando na verdade precisava pular 8 bytes e não 8 words. Portanto o certo é:
wr_ptr += 2;

[styg]

é Marcus, quando vi essa sugestão achei que fosse algo pra testar o alinhamento da memória, mas como vi que pulava 8 words dai num entendi.

bom, refazendo o testte:

código:

wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
wr_ptr += 2;
for (i=0; i<40; i++)
{ *wr_ptr++ = i; }//*wr_ptr++ = 0x02468ACE; *wr_ptr++ = 0x13579BDF; }
wr_ptr = (unsigned int *)SDRAM_BASE_ADDR;
for ( i= 0; i < 40; i++ )
{ wr_ptr++; }

resultados:

End: 0xA000 0000 Valor: 0x0000 0000 // não importa
End: 0xA000 0004 Valor: 0x0000 0000 // não importa
End: 0xA000 0008 Valor: 0x0000 0000 // -->começa aqui
End: 0xA000 000C Valor: 0x1004 0000 // deu pau
End: 0xA000 0010 Valor: 0x0000 0002 // ok
End: 0xA000 0014 Valor: 0x0000 0003 // ok
End: 0xA000 0018 Valor: 0x0000 0000 // nada
End: 0xA000 001C Valor: 0x1004 0000 // deu pau
End: 0xA000 0020 Valor: 0x0000 0006 // ok
End: 0xA000 0024 Valor: 0x0000 0007 // ok
End: 0xA000 0028 Valor: 0x0000 0000 // nada
End: 0xA000 002C Valor: 0x1004 0000 // deu pau
End: 0xA000 0030 Valor: 0x0000 000A // ok
End: 0xA000 0034 Valor: 0x0000 000B // ok
End: 0xA000 0038 Valor: 0x0000 0000 // nada
End: 0xA000 003C Valor: 0x1004 0000 // deu pau
End: 0xA000 0040 Valor: 0x0000 000E // ok
End: 0xA000 0044 Valor: 0x0000 000F // ok
End: 0xA000 0048 Valor: 0x0000 0000 // nada
End: 0xA000 004C Valor: 0x1004 0000 // deu pau
End: 0xA000 0050 Valor: 0x0000 0012 // ok
End: 0xA000 0054 Valor: 0x0000 0013 // ok

bom, parece que mesmo comecando no 0x08 em vez de 0x00, sempre da erro nas posiçoes terminadas em 0x08 e 0x0C

[MarcusPonce]

Valeu o teste.
Nestes testes com ponteiros de 32bits dá a impressão que o A2 está em curto com um sinal de controle da SDRAM: quando ele vai para "1" perturba o funcionamento.

Mas então teria que dar problema com ponteiros de 8 bits e 16bits também. Quando você testou com esses ponteiros de 8 bits e 16 bits e o teste foi OK: você gravou e leu uma constante ou gravou contando 1, 2, 3... e depois leu ?

[styg]

marcus, eu tinha feito os teste com 8 e 16bits, escrevendo valores constantes.
mas acabei de refazer esses teste escrevendo numeros incrementando, e mesmo assim funcionou certinho.

po, to pensando, será que o controlador consegue mesmo acessar como 32bits uma memoria de 16bits?

[Sergio38br]

qual o clock mesmo do bixim ( acho que esta fala é do fabim).

[ ]`s
Sergio

[styg]

e olha que interessante esse outro teste com long.

código:

long_ptr = (unsigned long long *)SDRAM_BASE_ADDR;
for (i=0; i<10; i++)
{ *long_ptr++ = i*0x1010101010101010; }
long_ptr = (unsigned long long *)SDRAM_BASE_ADDR;
for ( i= 0; i<10; i++ )
{ long_ptr++; }

resultados:

End: 0xA000 0000 Valor: 0x0000 0000 0000 0000 // ok
End: 0xA000 0008 Valor: 0x1004 0000 0000 0000 // pau
End: 0xA000 0010 Valor: 0x2020 2020 2020 2020 // ok
End: 0xA000 0018 Valor: 0x2020 2020 2020 2020 // pau
End: 0xA000 0020 Valor: 0x4040 4040 4040 4040 // ok
End: 0xA000 0028 Valor: 0x5040 4040 4040 4040 // pau
End: 0xA000 0030 Valor: 0x6060 6060 6060 6060 // ok
End: 0xA000 0038 Valor: 0x6060 6060 6060 6060 // pau
End: 0xA000 0040 Valor: 0x8080 8080 8080 8080 // ok
End: 0xA000 0048 Valor: 0x9084 8080 8080 8080 // pau

[msamsoniuk]

pois eh, o problema ocorre na escrita ou na leitura?

minha sugestao seria fazer um teste para descobrir se o problema eh na escrita ou na leitura de 32 bits... se as operacoes de 8 bits nao dao pau, preencha a memoria com valores incrementais de 8 bits e depois leia com 16 e 32 bits:

Código: Selecionar todos

unsigned char *bptr = (unsigned char *) SDRAM_BASE_ADDR;
unsigned short *wptr = (unsigned short *) SDRAM_BASE_ADDR;
unsigned long *lptr  = (unsigned long *) SDRAM_BASE_ADDR;
int i;

for(i=0;i!=256;i++)
{
  *bptr++ = i; // preenchimento
}

for(i=0;i!=128;i++)
{
  *wptr++; // leitura
}

for(i=0;i!=64;i++)
{
  *lptr++; // leitura
}


isso testa se suas operacoes de 8 e 16 bits estao consistentes e, supostamente, vc vai ler tudo que escreveu corretamente. como a memoria jah esta escrita corretamente, a leitura de 32 bits vai dar um bom diagnostico e poderemos cercar melhor o problema.