Diff: SST25DeviceImpl.cpp

Revision:

2:6f8ab876b516

Parent:

1:385965a14c7c

--- a/SST25DeviceImpl.cpp	Wed Mar 02 00:28:03 2011 +0000
+++ b/SST25DeviceImpl.cpp	Wed Mar 02 16:09:09 2011 +0000
@@ -1,12 +1,12 @@
-#include "ISPI.h"
+#include "ISPICommand.h"
 #include <string.h>
 #include "SST25DeviceImpl.h"
 
-const SST25DeviceImpl::DeviceProperty* SST25DeviceImpl::findMatchDevice(ISPI* pSPI)
+const SST25DeviceImpl::DeviceProperty* SST25DeviceImpl::findMatchDevice(ISPICommand* pSPICommand)
 {
     int manufacturersId;
     int deviceId;
-    readId(pSPI, manufacturersId, deviceId);
+    readId(pSPICommand, manufacturersId, deviceId);
 
     struct SupportedDevice
     {
@@ -56,7 +56,7 @@
               0xe3,
               1,
               &SST25DeviceImpl::writeAAIWord,
-              46000000
+              50000000
             },
         },
         //SST25xF080B 8MBit (1MByte)
@@ -67,7 +67,7 @@
               0xe3,
               1,
               &SST25DeviceImpl::writeAAIWord,
-              46000000
+              50000000
             },
         },
         //SST25xF016B 16MBit (2MByte)
@@ -78,7 +78,7 @@
               0xe3,
               1,
               &SST25DeviceImpl::writeAAIWord,
-              46000000
+              50000000
             },
         },
         //SST25xF032B 32MBit (4MByte)
@@ -89,7 +89,7 @@
               0xc3,
               1,
               &SST25DeviceImpl::writeAAIWord,
-              46000000
+              50000000
             },
         },
         //SST25xF064C 64MBit (8MByte)
@@ -100,7 +100,7 @@
               0xc3,              
               256,
               &SST25DeviceImpl::writePage,
-              46000000
+              50000000
             },
         }
     };
@@ -116,27 +116,26 @@
     return NULL;
 }
 
-bool SST25DeviceImpl::IsSupported(ISPI* pSPI)
+bool SST25DeviceImpl::IsSupported(ISPICommand* pSPICommand)
 {
-    return findMatchDevice(pSPI) != NULL;
+    return findMatchDevice(pSPICommand) != NULL;
 }
 
-SST25DeviceImpl* SST25DeviceImpl::Create(ISPI* pSPI)
+SST25DeviceImpl* SST25DeviceImpl::Create(ISPICommand* pSPICommand)
 {
-    const DeviceProperty* property = findMatchDevice(pSPI);
+    const DeviceProperty* property = findMatchDevice(pSPICommand);
     if (property == NULL)
     {
         return NULL;
     }
-    return new SST25DeviceImpl(pSPI, *property);
+    return new SST25DeviceImpl(pSPICommand, *property);
 }
 
-SST25DeviceImpl::SST25DeviceImpl(ISPI* pSPI, const DeviceProperty& property)
- : _pSPI(pSPI)
+SST25DeviceImpl::SST25DeviceImpl(ISPICommand* pSPICommand, const DeviceProperty& property)
+ : _pSPICommand(pSPICommand)
  , _property(property)
 {
-    _pSPI->ChangeCS(ISPI::High);
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 }
 
 SST25DeviceImpl::~SST25DeviceImpl(void)
@@ -144,40 +143,32 @@
 
 }
 
-void SST25DeviceImpl::readId(ISPI* pSPI, int& manufacturersId, int& deviceId)
+void SST25DeviceImpl::readId(ISPICommand* pSPICommand, int& manufacturersId, int& deviceId)
 {
     const static int DefaultOperationFrequency = 20000000;
-    pSPI->SetFrequency(DefaultOperationFrequency);
+    pSPICommand->SetMaxFrequency(DefaultOperationFrequency);
 
-    pSPI->ChangeCS(ISPI::Low);
-    pSPI->Write(0x90);
-    pSPI->Write(0x00);
-    pSPI->Write(0x00);
-    pSPI->Write(0x00);
-    manufacturersId = pSPI->Read();
-    deviceId = pSPI->Read();
-    pSPI->ChangeCS(ISPI::High);
+    unsigned char read[2];
+    char param[3];
+    fillAddress(param, 0x000000);
+    pSPICommand->Read(0x90, param, sizeof(param), read, sizeof(read));
+    manufacturersId = read[0];
+    deviceId = read[1];
 }
 
 int SST25DeviceImpl::readStatusRegister(void)
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x05);
-    int result = _pSPI->Read();
-    _pSPI->ChangeCS(ISPI::High);
-    return result;
+    unsigned char read;
+    _pSPICommand->Read(0x05, &read, 1);
+    return read;
 }
 
 void SST25DeviceImpl::writeStatusRegister(int value)
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x50);
-    _pSPI->ChangeCS(ISPI::High);
+    _pSPICommand->Write(0x50);
 
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x01);
-    _pSPI->Write(value);
-    _pSPI->ChangeCS(ISPI::High);
+    char vb = static_cast<char>(value);
+    _pSPICommand->Write(0x01, &vb, sizeof(vb));
 }
 
 void SST25DeviceImpl::writeEnable()
@@ -185,17 +176,12 @@
     int status = readStatusRegister();
     status &= _property.blockProtectionMask;
     writeStatusRegister(status);
-
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x06);
-    _pSPI->ChangeCS(ISPI::High);
+    _pSPICommand->Write(0x06);
 }
 
 void SST25DeviceImpl::writeDisable()
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x04);
-    _pSPI->ChangeCS(ISPI::High);
+    _pSPICommand->Write(0x04);
 }
 
 void SST25DeviceImpl::waitForReady()
@@ -229,14 +215,11 @@
         return 0;
     }
 
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x0b);
-    writeAddress(address);
-    _pSPI->Write(0xff);
-    _pSPI->Read(buffer, length);
-    _pSPI->ChangeCS(ISPI::High);
+    char param[] = { 0, 0, 0, 0xff };
+    fillAddress(param, address);
+    _pSPICommand->Read(0x0b, param, sizeof(param), buffer, length);
     return length;
 }
 
@@ -260,104 +243,89 @@
 
 void SST25DeviceImpl::ChipErase()
 {
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
     writeEnable();
-
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x60);
-    _pSPI->ChangeCS(ISPI::High);
+    _pSPICommand->Write(0x60);
     waitForReady();
 }
 
 void SST25DeviceImpl::byteProgram(int address, int value)
 {
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
     writeEnable();
 
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x02);
-    writeAddress(address);
-    _pSPI->Write(value);
-    _pSPI->ChangeCS(ISPI::High);
+    char param[] = { 0, 0, 0, value };
+    fillAddress(param, address);
+    _pSPICommand->Write(0x02, param, sizeof(param));
+
     waitForReady();
 }
 
 void SST25DeviceImpl::beginAAIProgram(int address, int data)
 {
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
     writeEnable();
+    
+    char param[] = { 0, 0, 0, data };
+    fillAddress(param, address);
+    _pSPICommand->Write(0xaf, param, sizeof(param));
 
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0xaf);
-    writeAddress(address);
-    _pSPI->Write(data);
-    _pSPI->ChangeCS(ISPI::High);
     waitForReady();
 }
 
 void SST25DeviceImpl::nextAAIProgram(int data)
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0xaf);
-    _pSPI->Write(data);
-    _pSPI->ChangeCS(ISPI::High);
+    char param = static_cast<char>(data);
+    _pSPICommand->Write(0xaf, &param, 1);
+
     waitForReady();
 }
 
 void SST25DeviceImpl::endAAIProgram(void)
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x04);
-    _pSPI->ChangeCS(ISPI::High);
+    _pSPICommand->Write(0x04);
     waitForReady();
 }
 
 void SST25DeviceImpl::beginAAIWordProgram(int address, int data)
 {
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
     writeEnable();
-
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0xad);
-    writeAddress(address);
-    _pSPI->Write((data & 0xff00) >> 8);
-    _pSPI->Write(data & 0xff);
-    _pSPI->ChangeCS(ISPI::High);
+    char param[] = { 0, 0, 0, (data & 0xff00) >> 8, data & 0xff };
+    fillAddress(param, address);
+    _pSPICommand->Write(0xad, param, sizeof(param));
     waitForReady();
 }
 
 void SST25DeviceImpl::nextAAIWordProgram(int data)
 {
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0xad);
-    _pSPI->Write((data & 0xff00) >> 8);
-    _pSPI->Write(data & 0xff);
-    _pSPI->ChangeCS(ISPI::High);
+    char param[] = { (data & 0xff00) >> 8, data & 0xff };
+    _pSPICommand->Write(0xad, param, sizeof(param));
     waitForReady();
 }
 
-void SST25DeviceImpl::writeAddress(int address)
+void SST25DeviceImpl::fillAddress(char* pBuffer, int address)
 {
-    _pSPI->Write((address & 0xff0000) >> 16);
-    _pSPI->Write((address & 0xff00) >> 8);
-    _pSPI->Write(address & 0xff);
+    *(pBuffer + 0) = (address & 0xff0000) >> 16;
+    *(pBuffer + 1) = (address & 0x00ff00) >> 8;
+    *(pBuffer + 2) = (address & 0x0000ff);
 }
 
 void SST25DeviceImpl::pageProgram(int address, const void* buffer)
 {
-    _pSPI->SetFrequency(_property.operationClkHz);
+    _pSPICommand->SetMaxFrequency(_property.operationClkHz);
 
     writeEnable();
 
-    _pSPI->ChangeCS(ISPI::Low);
-    _pSPI->Write(0x02);
-    writeAddress(address);
-    _pSPI->Write(buffer, 256);
-    _pSPI->ChangeCS(ISPI::High);
+    char param[256 + 3];
+    fillAddress(param, address);
+    memcpy(param + 3, buffer, 256);
+    _pSPICommand->Write(0x02, param, sizeof(param));    
+
     waitForReady();
 }