dataflash.c

/*************************************************************************************
*
*  Äðàéâåð Atmel DataFlash
*
*  Ñîâìåñòèìî ñ Strict ANSI C, MISRA-C 2004
*
*  by:      BSVi
*  version: 1.00
*
*************************************************************************************/
#include "dataflash.h"

//#define DF_MISO_PB   BIT6
//#define DF_MOSI_PB   BIT5
//#define DF_SCK_PB    BIT7
//#define DF_SS_PB     BIT3
//#define DF_RESET_PB  BIT4

#define SIMO_BIT    BIT1
#define SOMI_BIT    BIT2
#define CLK_BIT     BIT3
#define CS_BIT      BIT0
#define _CS(n){if(n) P4OUT |= CS_BIT; else P4OUT &= ~CS_BIT;}

#define SELECT()  P4OUT &= ~CS_BIT;//PORTB &= ~DF_SS_PB;  // Íîæêà SS
#define DESELECT() P4OUT |= CS_BIT;//PORTB |= DF_SS_PB;


#define E_ERR   (0)
#define S_OK    (0)
//------------------------------------------------------------------------------------
//  Îïðåäåëåíèå òèïà dataflash
//------------------------------------------------------------------------------------
#ifdef DF_AUTODETECT_FEATURES


df_Info_t df_Info;

 const df_Info_t df_table [] =
{
   { 512,  264,  9,  (0x3<<2) }, // 1M  AT45DB011
   { 1024, 264,  9,  (0x5<<2) }, // 2M  AT45DB021
   { 2048, 264,  9,  (0x7<<2) }, // 4M  AT45DB041
   { 4096, 264,  9,  (0x9<<2) }, // 8M  AT45DB081
   { 4096, 528,  10, (0xB<<2) }, // 16M AT45DB161
   { 8192, 528,  10, (0xD<<2) }, // 32M AT45DB321
   { 8192, 1056, 11, (0xF<<2) }, // 64M AT45DB642
};

#else // DF_AUTODETECT_FEATURES

#error "Àâòîîïðåäåëåíèå çàïðåùåíî."

// Ñêîïèðóéòå ñþäà ñîîòâåòñòâóþùóþ ñòðî÷êó èç òàáëèöû âûøå è
// çàêîììåíèòèðóéòå ñîîáùåíèå îá îøèáêå
static const df_Info_t DfInfo = { 8192, 1056, 11, (0xF<<2) };

#endif // DF_AUTODETECT_FEATURES


//------------------------------------------------------------------------------------
//  Êîäû êîììàíä äëÿ âíóòðåííåãî èñïîëüçîâàíèÿ
//------------------------------------------------------------------------------------
#define FlashPageRead			0x52	// Main memory page read
#define ContArrayRead			0xe8	// Continuous Array Read (Note : Only A/B/D-parts supported)
#define StatusReg			0xd7	// Status register
#define Buf1Read			0x54	// Buffer 1 read
#define Buf2Read			0x56	// Buffer 2 read
#define Buf1Write			0x84	// Buffer 1 write
#define Buf2Write			0x87	// Buffer 2 write

#define DF_STATUS_READY 0x80


//------------------------------------------------------------------------------------
//  Âíóòðåííèå ôóíêöèè
//------------------------------------------------------------------------------------
uint8 df_DetectParams();


//------------------------------------------------------------------------------------
//  Èíèöèàëèçèðóåò SPI äëÿ ðàáîòû ñ dataflash
//------------------------------------------------------------------------------------
unsigned char df_Init()
{
//   SPCR = 0; // Îòêëþ÷àåì SPI ÷òîáû ñêîíôèãóðèðîâàòü íàïðàâëåíèå íîæåê
//   DESELECT();
//
//   DDRB &= ~(DF_MISO_PB);
//
//   DDRB |= DF_MOSI_PB + DF_SCK_PB + DF_RESET_PB + DF_SS_PB;    /* MOSI, SS, RESET, SCK - âûõîäû */
//
//   PORTB &= ~DF_RESET_PB;  // ñáðàñûâàåì dataflsah
//   _delay_us(10);          // RESET Pulse Width = 10us
//   PORTB |= DF_RESET_PB;
//   _delay_us(1);           // RESET Recovery Time = 1us
//
//   // ìàêñèìàëüíàÿ ÷àñòîòà dataflash 15ÌÃö, çíà÷èòåëüíî áîëüøå ÷åì ìîæåò âûäàòü êîíòðîëëåð
//   SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPHA) | (1<<CPOL);	// Enable SPI in Master mode, mode 3
//   SPSR = (1<<SPI2X);
  P4DIR |= (SIMO_BIT | CLK_BIT);                                          // it is not yet in SPI mode
  P4SEL |= (SOMI_BIT | SIMO_BIT | CLK_BIT);                       // P3.3,4 option select
  P4DIR |= (CS_BIT);                            // P2.7 option select
  _CS(1); 
  UCB1CTL1 |=  UCSWRST;                      // **Put state machine in reset**
  UCB1CTL1 |= (UCSSEL0 | UCSSEL1);
  UCB1CTL0 |= (UCMST | UCSYNC |  UCCKPH | UCMSB);          
  UCB1BR0 = 2;                                            
  UCB1CTL1 &= ~UCSWRST;   
   return df_DetectParams();
}


//------------------------------------------------------------------------------------
//  Ïåðåäàåò ïàðàìåòåð è âîçâðàùàåò ïðèíÿòûé áàéò
//------------------------------------------------------------------------------------
#define SPI_SEND_BYTE(n) { UCB1TXBUF = n; while ((UCB1STAT&UCBUSY));   } 
uint8 DF_SPI_RW( uint8 tx )
{
   uint8 rx;
   UCB1TXBUF = tx; 
   while ((UCB1STAT&UCBUSY));
//   SPDR = tx;
//   while(!(SPSR & 0x80));
   rx = UCB1RXBUF;
   return rx;
}		

//------------------------------------------------------------------------------------
//  Ïðîâåðÿåò, ãîòîâà ëè ïàìÿòü
//------------------------------------------------------------------------------------
uint8 df_isReady()
{
   return df_GetStatus() &  DF_STATUS_READY;
}


//------------------------------------------------------------------------------------
//  ×èòàåò áàéò ñîñòîÿíèÿ Dataflash. Î ñîäåðæèìîì ýòîãî áàéòà ìîæíî óçíàòü â
//  ðàçäåëå STATUS REGISTER READ.
//------------------------------------------------------------------------------------
uint8 df_GetStatus()
{
   uint8 status;

   SELECT();
   status = DF_SPI_RW(StatusReg);
   status = DF_SPI_RW(0x00);
   DESELECT();

   return status;
}

//------------------------------------------------------------------------------------
//  Îáíàðóæèâàåò òèï dataflash
//------------------------------------------------------------------------------------
uint8 df_DetectParams()
{
#ifdef DF_AUTODETECT_FEATURES
   uint8 chip_id;
   chip_id = df_GetStatus() & 0x3C;

   for (uint8 i=0; i<sizeof(df_table); i++)
   {
      if ( df_table[i].chip_id == chip_id )
      {
         df_Info = df_table[i];
         return S_OK;
      }
   }
   return E_ERR;
#else // DF_AUTODETECT_FEATURES
   return S_OK;
#endif // DF_AUTODETECT_FEATURES
}


//------------------------------------------------------------------------------------
//  ×èòàåò îäèí áàéò èç SRAM-áóôôåðà dataflash
//	Ïàðàìåòðû: BufferNo -> Íîìåð áóôôåðà (1 èëè 2)
//                  Addr  -> Àäðåñ â áóôôåðå
//------------------------------------------------------------------------------------
uint8 df_GetChar(uint8 BufferNo, uint16 Addr )
{
   uint8 data;

   SELECT();

   if ( BufferNo == 1 )	{ DF_SPI_RW(Buf1Read); }       // áóôôåð 1
   else	if ( BufferNo == 2 ) { DF_SPI_RW(Buf2Read); }  // áóôôåð 2
   else { DESELECT(); return 0; }                      // îøèáëèñü ñ íîìåðîì áóôôåðà

   DF_SPI_RW(0x00);              // öèêë ÷òåíèÿ îïèñàí â äàòàøèòå
   DF_SPI_RW((uint8)(Addr>>8));
   DF_SPI_RW((uint8)(Addr));
   DF_SPI_RW(0x00);
   data = DF_SPI_RW(0x00);

   DESELECT();

   return data;
}



//------------------------------------------------------------------------------------
//  ×èòàåò áëîê äàííûõ èç SRAM-áóôôåðà dataflash
//	Ïàðàìåòðû: BufferNo   -> Íîìåð áóôôåðà (1 èëè 2)
//                  Addr       -> Àäðåñ â áóôôåðå ñ êîòîðîãî íà÷èíàòü ÷òåíèå
//                  Count      -> Êîëè÷åñòâî áàéò, êîòîðîå íåîáõîäèìî ïðî÷èòàòü
//  		   *BufferPtr -> Àäðåñ áóôôåðà â êîòîðûé çàíîñèòü äàííûå
//------------------------------------------------------------------------------------
void df_GetStr( uint8 BufferNo, uint16 Addr, uint16 Count, uint8 *BufferPtr )
{
   SELECT();

   if ( BufferNo == 1 )	{ DF_SPI_RW(Buf1Read); }       // áóôôåð 1
   else	if ( BufferNo == 2 ) { DF_SPI_RW(Buf2Read); }  // áóôôåð 2
   else { DESELECT(); return; }                        // îøèáëèñü ñ íîìåðîì áóôôåðà

   DF_SPI_RW(0x00);
   DF_SPI_RW((unsigned char)(Addr>>8));
   DF_SPI_RW((unsigned char)(Addr));
   DF_SPI_RW(0x00);

   for( uint16 i=0; i<Count; i++)
   {
      *(BufferPtr) = DF_SPI_RW(0x00);
      BufferPtr++;
   }

   DESELECT();
}


//------------------------------------------------------------------------------------
//  Çàïèñûâàåò áàéò â SRAM-áóôôåð dataflash
//	Ïàðàìåòðû: BufferNo   -> Íîìåð áóôôåðà (1 èëè 2)
//                  Addr       -> Àäðåñ â áóôôåðå ñ êîòîðîãî íà÷èíàòü ÷òåíèå
//                  Data       -> Áàéò êîòîðûé íóæíî çàïèñàòü
//------------------------------------------------------------------------------------
void df_WriteByte( uint8 BufferNo, uint16 Addr, uint8 Data )
{
   SELECT();

   if ( BufferNo == 1 )	{ DF_SPI_RW(Buf1Write); }       // áóôôåð 1
   else	if ( BufferNo == 2 ) { DF_SPI_RW(Buf2Write); }  // áóôôåð 2
   else { DESELECT(); return; }                         // îøèáëèñü ñ íîìåðîì áóôôåðà

   DF_SPI_RW(0x00);
   DF_SPI_RW((unsigned char)(Addr>>8));
   DF_SPI_RW((unsigned char)(Addr));
   DF_SPI_RW(Data);

   DESELECT();
}


//------------------------------------------------------------------------------------
//  Çàïèñûâàåò áëîê äàííûõ â SRAM-áóôôåð dataflash
//	Ïàðàìåòðû: BufferNo   -> Íîìåð áóôôåðà (1 èëè 2)
//                  Addr       -> Àäðåñ â áóôôåðå ñ êîòîðîãî íà÷èíàòü ÷òåíèå
//                  Count      -> Êîëè÷åñòâî áàéò, êîòîðîå íåîáõîäèìî çàïèñàòü
//  		   *BufferPtr -> Áóôôåð, äàííûå èç êîòîðîãî íóæíî çàïèñàòü
//------------------------------------------------------------------------------------
void df_WriteStr( uint8 BufferNo, uint16 Addr, uint16 Count, uint8 *BufferPtr )
{
   SELECT();

   if ( BufferNo == 1 )	{ DF_SPI_RW(Buf1Write); }       // áóôôåð 1
   else	if ( BufferNo == 2 ) { DF_SPI_RW(Buf2Write); }  // áóôôåð 2
   else { DESELECT(); return; }                         // îøèáëèñü ñ íîìåðîì áóôôåðà

   DF_SPI_RW(0x00);
   DF_SPI_RW((unsigned char)(Addr>>8));
   DF_SPI_RW((unsigned char)(Addr));
   for( uint16 i=0; i<Count; i++)
   {
      DF_SPI_RW(*(BufferPtr));
      BufferPtr++;
   }


   DESELECT();
}


//------------------------------------------------------------------------------------
//  Ìàíèïóëÿöèè ñî ñòðàíèöàìè
//	Ïàðàìåòðû: PageÑmd  -> Êîìàíäà
//                  PageAdr  -> Íîìåð ñòðàíèöû
//------------------------------------------------------------------------------------
void df_PageFunc( uint8 PageCmd, uint16 PageAdr )
{
   SELECT();

   DF_SPI_RW(PageCmd);
   DF_SPI_RW((uint8)(PageAdr >> (16 - df_Info.page_bit)));
   DF_SPI_RW((uint8)(PageAdr << (df_Info.page_bit - 8)));
   DF_SPI_RW(0x00);

   DESELECT();

   while(!( df_GetStatus() & DF_STATUS_READY ))__no_operation(); // Îæèäàåì çàâåðøåíèÿ îïåðàöèè
}

//------------------------------------------------------------------------------------
//  Ïðî÷èòàòü áëîê äàííûõ íåïîñðåäñòâåííî èç Flash - ïàìÿòè
//	Ïàðàìåòðû: PageAdr    -> Íîìåð ñòðàíèöû, ñ êîòîðîé íà÷èíàòü ÷òåíèå
//                  Addr       -> Àäðåñ â ñòðàíèöå, ñ êîòîðîãî íà÷èíàòü ÷òåíèå
//                  Count      -> Êîëè÷åñòâî áàéò, êîòîðîå íåîáõîäèìî ïðî÷èòàòü
//  		   *BufferPtr -> Àäðåñ áóôôåðà â êîòîðûé çàíîñèòü äàííûå
//------------------------------------------------------------------------------------
void df_FlashRead( uint16 PageAdr, uint16 Addr, uint16 Count, uint8 *BufferPtr )
{
   SELECT();

   DF_SPI_RW(ContArrayRead);
   DF_SPI_RW((unsigned char)(PageAdr >> (16 - df_Info.page_bit)));
   DF_SPI_RW((unsigned char)((PageAdr << (df_Info.page_bit - 8))+ (Addr>>8)));
   DF_SPI_RW((unsigned char)(Addr));
   DF_SPI_RW(0x00);
   DF_SPI_RW(0x00);
   DF_SPI_RW(0x00);
   DF_SPI_RW(0x00);

   for( uint16 i=0; i < Count; i++ )
   {
      *(BufferPtr) = DF_SPI_RW(0x00);
      BufferPtr++;
   }

   DESELECT();
}

///*****************************************************************************/
///*****************************************************************************/
///*             Íàäñòðîéêà äëÿ óäîáíîãî ÷òåíèÿ è çàïèñè èíôîðìàöèè            */
///*****************************************************************************/
///*****************************************************************************/
//#ifdef DF_ENABLE_LINEAR_SPACE
//uint16 df_LinearSpace::page_in_buffer1 = 0xffff;
//
////------------------------------------------------------------------------------------
////  Ïåðåâîäèò óêàçàòåëè íà íà÷àëî ïàìÿòè
////------------------------------------------------------------------------------------
//void df_LinearSpace::GoToZero()
//{
//   page = 0;
//   address = 0;
//}
//
////------------------------------------------------------------------------------------
////  Ýòà ôóíêöèÿ âîçâðàùàåò êîëè÷åñòâî áàéò äî êîíöà dataflash.
////  Îñòàëüíûå ôóíêöèè íå ïðîèçâîäÿò ïðîâåðêó íà ïåðåñå÷åíèå ãðàíèöû ïàìÿòè.
////  Ïðîãðàììà ïîëüçîâàòåëÿ äîëæíà ïðîèçâîäèòü òàêóþ ïðîâåðêó.
////------------------------------------------------------------------------------------
//uint32 df_LinearSpace::SpaceToEnd()
//{
//   return (uint32)df_Info.page_size*(df_Info.pages - page) - (uint32)address;
//}
//
////------------------------------------------------------------------------------------
////  Ñ÷èòàòü äàííûå
////	Ïàðàìåòðû: count      -> Êîëè÷åñòâî áàéò, êîòîðîå íåîáõîäèìî ïðî÷èòàòü
////  		   *buffer    -> Àäðåñ áóôôåðà â êîòîðûé çàíîñèòü äàííûå
////------------------------------------------------------------------------------------
//void df_LinearSpace::Read( uint8 *buffer, uint16 count )
//{
//   df_FlashRead( page, address, count, buffer );
//   address += count;
//
//   while( address >= df_Info.page_size )
//   {
//      address -= df_Info.page_size;
//      page++;
//   }
//}
//
////------------------------------------------------------------------------------------
////  Çàïèñàòü äàííûå
////	Ïàðàìåòðû: count     -> Êîëè÷åñòâî áàéò, êîòîðîå íåîáõîäèìî çàïèñàòü
////  		   *buffer    -> Àäðåñ áóôôåðà â êîòîðîì íàçîäÿòñÿ èñõîäíûå äàííûå
////------------------------------------------------------------------------------------
//void df_LinearSpace::UnsafeWrite( uint8 *buffer, uint16 count )
//{
//   uint16 page_space_left = df_Info.page_size - address;
//
//   // çàãðóæàåì äàííûå â áóôôåð, åñëè îíè åùå íå òàì.
//   if ( page != page_in_buffer1 )
//   {
//      df_PageFunc(DF_FLASH_TO_BUF1, page);
//      page_in_buffer1 = page;
//   }
//
//   while (count)
//   {
//      page_space_left = df_Info.page_size - address;
//
//      if ( count > page_space_left )   // íóæíî çàïèñàòü áîëüøå äàííûõ ÷åì îñòàëîñü ìåñòà íà ñòðàíèöå ïàìÿòè.
//      {
//         // Çàïèñûâàåì âñþ ñòðàíöó äî êîíöà â áóôôåðå
//         df_WriteStr(1, address, page_space_left, buffer);
//         count -= page_space_left;
//         buffer += page_space_left;
//
//         // ïåðåìåùàåì áóôôåð âî ôëýø
//         df_PageFunc(DF_BUF1_TO_FLASH_WITH_ERASE, page);
//         address = 0;
//         page++;
//
//         // çàãðóæàåì ñëåäóþùóþ ñòðàíèöó
//         df_PageFunc(DF_FLASH_TO_BUF1, page);
//         page_in_buffer1 = page;
//
//      }
//      else
//      {
//         df_WriteStr(1, address, count, buffer);
//         address += count;
//         count = 0;
//      }
//   }
//}
//
////------------------------------------------------------------------------------------
////  Ñîõðàíèòü áóôôåð çàïèñè â ôèçè÷åñêîé ïàìÿòè.
////------------------------------------------------------------------------------------
//void df_LinearSpace::Finalize()
//{
//   df_PageFunc(DF_BUF1_TO_FLASH_WITH_ERASE, page);
//}
//
////------------------------------------------------------------------------------------
////  Ïåðåìåñòèòü óêàçàòåëü ñ÷èòûâàíèÿ âïåðåä
////	Ïàðàìåòðû: displacement -> Ñìåùåíèå
////------------------------------------------------------------------------------------
//void df_LinearSpace::SeekForward( uint32 displacement )
//{
//   page += (displacement / df_Info.page_size);
//   address += (displacement % df_Info.page_size);
//}
//
////------------------------------------------------------------------------------------
////  Ïåðåìåñòèòü óêàçàòåëü ñ÷èòûâàíèÿ íàçàä
////	Ïàðàìåòðû: displacement -> Ñìåùåíèå
////------------------------------------------------------------------------------------
//void df_LinearSpace::SeekBackward( uint32 displacement )
//{
//   page -= (displacement / df_Info.page_size);
//   address -= (displacement % df_Info.page_size);
//}
//
//
////------------------------------------------------------------------------------------
////  Ïåðåìåñòèòü óêàçàòåëü â çàäàííóþ òî÷êó
////------------------------------------------------------------------------------------
//void df_LinearSpace::GoTo( uint32 location )
//{
//   page = (location / df_Info.page_size);
//   address = (location % df_Info.page_size);
//}
//
//#endif /* DF_ENABLE_LINEAR_SPACE */