RCS730.cpp

00001 /** FeliCa Link(RC-S730) Library
00002  *
00003  * @file    RCS730.cpp
00004  * @author  hiro99ma
00005  * @version 1.00
00006  */
00007 
00008 #include "RCS730.h"
00009 
00010 
00011 namespace {
00012     const int I2C_SLV_ADDR = 0x80;      //Default Slave Address(8bit)
00013     const int RETRY_NUM = 5;            //max I2C Retry count
00014 
00015 
00016     inline int set_tag_rf_send_enable(RCS730 *pRcs)
00017     {
00018         uint32_t val = 0x00000001;
00019         return pRcs->pageWrite(RCS730::REG_TAG_TX_CTRL, reinterpret_cast<const uint8_t*>(&val), sizeof(val));
00020     }
00021 
00022     int read_rf_buf(RCS730 *pRcs, uint8_t *pData)
00023     {
00024         const int LEN_FIRST = 16;
00025         int len = 0;
00026         int ret;
00027 
00028         //read from LEN
00029         ret = pRcs->sequentialRead(RCS730::BUF_RF_COMM, pData, LEN_FIRST);
00030         if (ret == 0) {
00031             len = pData[0];
00032         }
00033         if ((ret == 0) && (pData[0] > LEN_FIRST)) {
00034             ret = pRcs->sequentialRead(RCS730::BUF_RF_COMM + LEN_FIRST, pData + LEN_FIRST, pData[0] - LEN_FIRST);
00035             if (ret != 0) {
00036                 len = 0;
00037             }
00038         }
00039 
00040         return len;
00041     }
00042 }
00043 
00044 
00045 RCS730::RCS730(I2C &I2c)
00046     : _i2c(I2c), _slvAddr(I2C_SLV_ADDR)
00047 {
00048     _cbTable.pUserData = 0;
00049     _cbTable.pCbRxHTRDone = 0;
00050     _cbTable.pCbRxHTWDone = 0;
00051 }
00052 
00053 
00054 RCS730::~RCS730()
00055 {
00056 }
00057 
00058 
00059 void RCS730::setCallbackTable(const callbacktable_t *pInitTable)
00060 {
00061     _cbTable = *pInitTable;
00062 }
00063 
00064 
00065 int RCS730::byteWrite(uint16_t MemAddr, uint8_t Data)
00066 {
00067     int ret;
00068     int retry = RETRY_NUM;
00069     char buf[3];
00070 
00071     buf[0] = (char)(MemAddr >> 8);
00072     buf[1] = (char)(MemAddr & 0xff);
00073     buf[2] = (char)Data;
00074 
00075     do {
00076         ret = _i2c.write(_slvAddr, buf, (int)sizeof(buf));
00077     } while ((ret != 0) && (retry--));
00078 
00079     return ret;
00080 }
00081 
00082 
00083 int RCS730::pageWrite(uint16_t MemAddr, const uint8_t *pData, int Length)
00084 {
00085     int ret;
00086     int retry = RETRY_NUM;
00087     char buf[2];
00088 
00089     buf[0] = (char)(MemAddr >> 8);
00090     buf[1] = (char)(MemAddr & 0xff);
00091 
00092     do {
00093         ret = _i2c.write(_slvAddr, buf, (int)sizeof(buf), true);
00094     } while ((ret != 0) && (retry--));
00095     if (ret == 0) {
00096         for (int i = 0; i < Length; i++) {
00097             ret = !_i2c.write(pData[i]);        //I2C::write(b) return 1 if success.
00098             if (ret != 0) {
00099                 break;
00100             }
00101         }
00102     }
00103     _i2c.stop();
00104 
00105     return ret;
00106 }
00107 
00108 
00109 int RCS730::randomRead(uint16_t MemAddr, uint8_t *pData)
00110 {
00111     return sequentialRead(MemAddr, pData, 1);
00112 }
00113 
00114 
00115 int RCS730::sequentialRead(uint16_t MemAddr, uint8_t *pData, int Length)
00116 {
00117     int ret;
00118     int retry = RETRY_NUM;
00119     char buf[2];
00120 
00121     buf[0] = (char)(MemAddr >> 8);
00122     buf[1] = (char)(MemAddr & 0xff);
00123 
00124     do {
00125         ret = _i2c.write(_slvAddr, buf, (int)sizeof(buf), true);
00126     } while ((ret != 0) && (retry--));
00127     if (ret == 0) {
00128         ret = _i2c.read(_slvAddr | 1, reinterpret_cast<char*>(pData), Length);
00129     }
00130 
00131     return ret;
00132 }
00133 
00134 
00135 int RCS730::currentAddrRead(uint8_t *pData)
00136 {
00137     int ret;
00138     int retry = RETRY_NUM;
00139 
00140     do {
00141         ret = _i2c.read((int)(_slvAddr | 1), reinterpret_cast<char*>(pData), 1);
00142     } while ((ret != 0) && (retry--));
00143 
00144     return ret;
00145 }
00146 
00147 
00148 inline int RCS730::readRegister(uint16_t Reg, uint32_t* pData)
00149 {
00150     return sequentialRead(Reg, reinterpret_cast<uint8_t*>(pData), sizeof(uint32_t));
00151 }
00152 
00153 
00154 inline int RCS730::writeRegisterForce(uint16_t Reg, uint32_t Data)
00155 {
00156     return pageWrite(Reg, reinterpret_cast<const uint8_t*>(&Data), sizeof(Data));
00157 }
00158 
00159 
00160 int RCS730::writeRegister(uint16_t Reg, uint32_t Data, uint32_t Mask/*=0xffffffff*/)
00161 {
00162     int ret;
00163     uint32_t cur;   //current register value
00164 
00165     ret = readRegister(Reg, &cur);
00166     if (ret == 0) {
00167         if ((cur & Mask) != Data) {
00168             // change value
00169             Data |= cur & ~Mask;
00170             ret = writeRegisterForce(Reg, Data);
00171         }
00172     }
00173 
00174     return ret;
00175 }
00176 
00177 
00178 int RCS730::setRegOpMode(OpMode Mode)
00179 {
00180     return writeRegister(REG_OPMODE, static_cast<uint32_t>(Mode));
00181 }
00182 
00183 
00184 int RCS730::setRegSlaveAddr(int SAddr)
00185 {
00186     int ret;
00187 
00188     ret = writeRegister(REG_I2C_SLAVE_ADDR, static_cast<uint32_t>(SAddr));
00189 
00190     if (ret == 0) {
00191         _slvAddr = SAddr << 1;
00192     }
00193 
00194     return ret;
00195 }
00196 
00197 
00198 int RCS730::setRegInterruptMask(uint32_t Mask, uint32_t Value)
00199 {
00200     return writeRegister(REG_INT_MASK, Value, Mask);
00201 }
00202 
00203 
00204 int RCS730::setRegPlugSysCode(PlugSysCode SysCode)
00205 {
00206     return writeRegister(REG_PLUG_CONF1, static_cast<uint32_t>(SysCode), 0x00000002);
00207 }
00208 
00209 
00210 int RCS730::goToInitializeStatus()
00211 {
00212     return writeRegisterForce(REG_INIT_CTRL, 0x0000004a);
00213 }
00214 
00215 
00216 int RCS730::initFTMode(OpMode Mode)
00217 {
00218     int ret;
00219 
00220     if (OPMODE_PLUG < Mode) {
00221         return -1;
00222     }
00223 
00224     ret = setRegOpMode(Mode);
00225     if (ret == 0) {
00226         ret = setRegInterruptMask(MSK_INT_TAG_RW_RX_DONE2, 0);
00227     }
00228 
00229     return ret;
00230 }
00231 
00232 
00233 #if 0
00234 int RCS730::initNfcDepMode()
00235 {
00236     int ret;
00237 
00238     ret = setRegOpMode(OPMODE_NFCDEP);
00239     if (ret == 0) {
00240         ret = setRegInterruptMask(MSK_INT_TAG_NFC_DEP_RX_DONE, 0);
00241     }
00242 
00243     return ret;
00244 }
00245 #endif
00246 
00247 
00248 void RCS730::isrIrq()
00249 {
00250     int ret;
00251     bool b_send = false;
00252     uint32_t intstat;
00253     uint8_t rf_buf[256];
00254 
00255     ret = readRegister(REG_INT_STATUS, &intstat);
00256     if (ret == 0) {
00257 
00258         if (intstat & MSK_INT_TAG_RW_RX_DONE2) {
00259             //Read or Write w/o Enc Rx done for HT block
00260             int len = read_rf_buf(this, rf_buf);
00261             if (len > 0) {
00262                 switch (rf_buf[1]) {
00263                     case 0x06:  //Read w/o Enc
00264                         if (_cbTable.pCbRxHTRDone) {
00265                             b_send = (*_cbTable.pCbRxHTRDone)(_cbTable.pUserData, rf_buf, len);
00266                         }
00267                         break;
00268                     case 0x08:  //Write w/o Enc;
00269                         if (_cbTable.pCbRxHTWDone) {
00270                             b_send = (*_cbTable.pCbRxHTWDone)(_cbTable.pUserData, rf_buf, len);
00271                         }
00272                         break;
00273                     default:
00274                         break;
00275                 }
00276             }
00277         }
00278 #if 0
00279         if (_cbTable.pCbRxDepDone && (intstat & MSK_INT_TAG_NFC_DEP_RX_DONE)) {
00280             //DEP command Rx done
00281             int len = read_rf_buf(this, rf_buf);
00282             (*_cbTable.pCbRxDepDone)(_cbTable.pUserData, rf_buf, len);
00283         }
00284         if (_cbTable.pCbTxDone && (intstat & MSK_INT_TAG_TX_DONE)) {
00285             //Tx Done
00286             int len = read_rf_buf(this, rf_buf);
00287             (*_cbTable.pCbTxDone)(_cbTable.pUserData, rf_buf, len);
00288         }
00289 
00290         uint32_t intother = intstat & ~(MSK_INT_TAG_TX_DONE | MSK_INT_TAG_NFC_DEP_RX_DONE | MSK_INT_TAG_RW_RX_DONE2);
00291         if (_cbTable.pCbOther && intother) {
00292             (*_cbTable.mCbOther)(_cbTable.pUserData, 0, intother);
00293         }
00294 #endif
00295 
00296         //response
00297         if (b_send) {
00298             ret = pageWrite(BUF_RF_COMM, rf_buf, rf_buf[0]);
00299             if (ret == 0) {
00300                 set_tag_rf_send_enable(this);
00301             }
00302         }
00303 
00304         writeRegisterForce(REG_INT_CLEAR, intstat);
00305     }
00306 }