Functions for accessing M24SR device.
Dependents: Nucleo_NFC_Example I2C_NFC_Master Print_Entire_Nucleo_NFC01A1_Memory
Fork of lib_M24SR by
Warning: Deprecated!
Supported drivers and applications can be found at this link.
m24sr.c@0:ffc2448b65ef, 2014-12-15 (annotated)
- Committer:
- EnricoG
- Date:
- Mon Dec 15 19:41:52 2014 +0000
- Revision:
- 0:ffc2448b65ef
Initial commit
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
EnricoG | 0:ffc2448b65ef | 1 | /** |
EnricoG | 0:ffc2448b65ef | 2 | ****************************************************************************** |
EnricoG | 0:ffc2448b65ef | 3 | * @file drv_M24SR.c |
EnricoG | 0:ffc2448b65ef | 4 | * @author MMY Application Team |
EnricoG | 0:ffc2448b65ef | 5 | * @version V1.1.0 |
EnricoG | 0:ffc2448b65ef | 6 | * @date 20-October-2014 |
EnricoG | 0:ffc2448b65ef | 7 | * @brief This file provides a set of functions to interface with the M24SR |
EnricoG | 0:ffc2448b65ef | 8 | * device. |
EnricoG | 0:ffc2448b65ef | 9 | ****************************************************************************** |
EnricoG | 0:ffc2448b65ef | 10 | * @attention |
EnricoG | 0:ffc2448b65ef | 11 | * |
EnricoG | 0:ffc2448b65ef | 12 | * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> |
EnricoG | 0:ffc2448b65ef | 13 | * |
EnricoG | 0:ffc2448b65ef | 14 | * Redistribution and use in source and binary forms, with or without modification, |
EnricoG | 0:ffc2448b65ef | 15 | * are permitted provided that the following conditions are met: |
EnricoG | 0:ffc2448b65ef | 16 | * 1. Redistributions of source code must retain the above copyright notice, |
EnricoG | 0:ffc2448b65ef | 17 | * this list of conditions and the following disclaimer. |
EnricoG | 0:ffc2448b65ef | 18 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
EnricoG | 0:ffc2448b65ef | 19 | * this list of conditions and the following disclaimer in the documentation |
EnricoG | 0:ffc2448b65ef | 20 | * and/or other materials provided with the distribution. |
EnricoG | 0:ffc2448b65ef | 21 | * 3. Neither the name of STMicroelectronics nor the names of its contributors |
EnricoG | 0:ffc2448b65ef | 22 | * may be used to endorse or promote products derived from this software |
EnricoG | 0:ffc2448b65ef | 23 | * without specific prior written permission. |
EnricoG | 0:ffc2448b65ef | 24 | * |
EnricoG | 0:ffc2448b65ef | 25 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
EnricoG | 0:ffc2448b65ef | 26 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
EnricoG | 0:ffc2448b65ef | 27 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
EnricoG | 0:ffc2448b65ef | 28 | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
EnricoG | 0:ffc2448b65ef | 29 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
EnricoG | 0:ffc2448b65ef | 30 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
EnricoG | 0:ffc2448b65ef | 31 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
EnricoG | 0:ffc2448b65ef | 32 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
EnricoG | 0:ffc2448b65ef | 33 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
EnricoG | 0:ffc2448b65ef | 34 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
EnricoG | 0:ffc2448b65ef | 35 | * |
EnricoG | 0:ffc2448b65ef | 36 | ****************************************************************************** |
EnricoG | 0:ffc2448b65ef | 37 | */ |
EnricoG | 0:ffc2448b65ef | 38 | |
EnricoG | 0:ffc2448b65ef | 39 | /* Includes ------------------------------------------------------------------*/ |
EnricoG | 0:ffc2448b65ef | 40 | #include "m24sr.h" |
EnricoG | 0:ffc2448b65ef | 41 | |
EnricoG | 0:ffc2448b65ef | 42 | /** @addtogroup M24SR_Driver |
EnricoG | 0:ffc2448b65ef | 43 | * @{ |
EnricoG | 0:ffc2448b65ef | 44 | * @brief <b>This folder contains the driver layer of M24SR family (M24SR64, M24SR16, M24SR04, M24SR02)</b> |
EnricoG | 0:ffc2448b65ef | 45 | */ |
EnricoG | 0:ffc2448b65ef | 46 | |
EnricoG | 0:ffc2448b65ef | 47 | |
EnricoG | 0:ffc2448b65ef | 48 | /** @addtogroup drv_M24SR |
EnricoG | 0:ffc2448b65ef | 49 | * @{ |
EnricoG | 0:ffc2448b65ef | 50 | * @brief This file contains the driver which implements all the M24SR commands. |
EnricoG | 0:ffc2448b65ef | 51 | */ |
EnricoG | 0:ffc2448b65ef | 52 | |
EnricoG | 0:ffc2448b65ef | 53 | static C_APDU Command; |
EnricoG | 0:ffc2448b65ef | 54 | //static R_APDU Response; |
EnricoG | 0:ffc2448b65ef | 55 | static uint8_t DataBuffer[0xFF]; |
EnricoG | 0:ffc2448b65ef | 56 | uint8_t uM24SRbuffer [0xFF]; |
EnricoG | 0:ffc2448b65ef | 57 | static uint8_t uDIDbyte =0x00; |
EnricoG | 0:ffc2448b65ef | 58 | |
EnricoG | 0:ffc2448b65ef | 59 | |
EnricoG | 0:ffc2448b65ef | 60 | static uint16_t M24SR_UpdateCrc ( uint8_t ch, uint16_t *lpwCrc); |
EnricoG | 0:ffc2448b65ef | 61 | static uint16_t M24SR_ComputeCrc ( uc8 *Data, uint8_t Length); |
EnricoG | 0:ffc2448b65ef | 62 | static uint16_t M24SR_IsCorrectCRC16Residue ( uc8 *DataIn,uc8 Length); |
EnricoG | 0:ffc2448b65ef | 63 | static void M24SR_InitStructure ( void ); |
EnricoG | 0:ffc2448b65ef | 64 | static void M24SR_BuildIBlockCommand ( uc16 CommandStructure, C_APDU Command, uint16_t *NbByte , uint8_t *pCommand); |
EnricoG | 0:ffc2448b65ef | 65 | static int8_t IsSBlock (uc8 *pBuffer); |
EnricoG | 0:ffc2448b65ef | 66 | #if 0 |
EnricoG | 0:ffc2448b65ef | 67 | static int8_t IsRBlock (uc8 *pBuffer); |
EnricoG | 0:ffc2448b65ef | 68 | static int8_t IsIBlock (uc8 *pBuffer); |
EnricoG | 0:ffc2448b65ef | 69 | #endif |
EnricoG | 0:ffc2448b65ef | 70 | static uint16_t M24SR_FWTExtension ( uint8_t FWTbyte ); |
EnricoG | 0:ffc2448b65ef | 71 | |
EnricoG | 0:ffc2448b65ef | 72 | /** @defgroup drvM24SR_Private_Functions |
EnricoG | 0:ffc2448b65ef | 73 | * @{ |
EnricoG | 0:ffc2448b65ef | 74 | */ |
EnricoG | 0:ffc2448b65ef | 75 | |
EnricoG | 0:ffc2448b65ef | 76 | /** |
EnricoG | 0:ffc2448b65ef | 77 | * @brief This function updates the CRC |
EnricoG | 0:ffc2448b65ef | 78 | * @param None |
EnricoG | 0:ffc2448b65ef | 79 | * @retval None |
EnricoG | 0:ffc2448b65ef | 80 | */ |
EnricoG | 0:ffc2448b65ef | 81 | static uint16_t M24SR_UpdateCrc (uint8_t ch, uint16_t *lpwCrc) |
EnricoG | 0:ffc2448b65ef | 82 | { |
EnricoG | 0:ffc2448b65ef | 83 | ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF)); |
EnricoG | 0:ffc2448b65ef | 84 | ch = (ch^(ch<<4)); |
EnricoG | 0:ffc2448b65ef | 85 | *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^((uint16_t)ch<<3)^((uint16_t)ch>>4); |
EnricoG | 0:ffc2448b65ef | 86 | |
EnricoG | 0:ffc2448b65ef | 87 | return(*lpwCrc); |
EnricoG | 0:ffc2448b65ef | 88 | } |
EnricoG | 0:ffc2448b65ef | 89 | |
EnricoG | 0:ffc2448b65ef | 90 | /** |
EnricoG | 0:ffc2448b65ef | 91 | * @brief This function returns the CRC 16 |
EnricoG | 0:ffc2448b65ef | 92 | * @param Data : pointer on the data used to compute the CRC16 |
EnricoG | 0:ffc2448b65ef | 93 | * @param Length : number of byte of the data |
EnricoG | 0:ffc2448b65ef | 94 | * @retval CRC16 |
EnricoG | 0:ffc2448b65ef | 95 | */ |
EnricoG | 0:ffc2448b65ef | 96 | static uint16_t M24SR_ComputeCrc(uc8 *Data, uint8_t Length) |
EnricoG | 0:ffc2448b65ef | 97 | { |
EnricoG | 0:ffc2448b65ef | 98 | uint8_t chBlock; |
EnricoG | 0:ffc2448b65ef | 99 | uint16_t wCrc; |
EnricoG | 0:ffc2448b65ef | 100 | |
EnricoG | 0:ffc2448b65ef | 101 | wCrc = 0x6363; // ITU-V.41 |
EnricoG | 0:ffc2448b65ef | 102 | |
EnricoG | 0:ffc2448b65ef | 103 | do { |
EnricoG | 0:ffc2448b65ef | 104 | chBlock = *Data++; |
EnricoG | 0:ffc2448b65ef | 105 | M24SR_UpdateCrc(chBlock, &wCrc); |
EnricoG | 0:ffc2448b65ef | 106 | } while (--Length); |
EnricoG | 0:ffc2448b65ef | 107 | |
EnricoG | 0:ffc2448b65ef | 108 | return wCrc ; |
EnricoG | 0:ffc2448b65ef | 109 | } |
EnricoG | 0:ffc2448b65ef | 110 | |
EnricoG | 0:ffc2448b65ef | 111 | |
EnricoG | 0:ffc2448b65ef | 112 | /** |
EnricoG | 0:ffc2448b65ef | 113 | * @brief This function computes the CRC16 residue as defined by CRC ISO/IEC 13239 |
EnricoG | 0:ffc2448b65ef | 114 | * @param DataIn : input to data |
EnricoG | 0:ffc2448b65ef | 115 | * @param Length : Number of bits of DataIn |
EnricoG | 0:ffc2448b65ef | 116 | * @retval Status (SW1&SW2) : CRC16 residue is correct |
EnricoG | 0:ffc2448b65ef | 117 | * @retval M24SR_ERROR_CRC : CRC16 residue is false |
EnricoG | 0:ffc2448b65ef | 118 | */ |
EnricoG | 0:ffc2448b65ef | 119 | static uint16_t M24SR_IsCorrectCRC16Residue (uc8 *DataIn,uc8 Length) |
EnricoG | 0:ffc2448b65ef | 120 | { |
EnricoG | 0:ffc2448b65ef | 121 | uint16_t ResCRC=0; |
EnricoG | 0:ffc2448b65ef | 122 | |
EnricoG | 0:ffc2448b65ef | 123 | /* check the CRC16 Residue */ |
EnricoG | 0:ffc2448b65ef | 124 | if (Length !=0) |
EnricoG | 0:ffc2448b65ef | 125 | ResCRC= M24SR_ComputeCrc (DataIn, Length); |
EnricoG | 0:ffc2448b65ef | 126 | |
EnricoG | 0:ffc2448b65ef | 127 | if ( ResCRC == 0x0000) |
EnricoG | 0:ffc2448b65ef | 128 | { |
EnricoG | 0:ffc2448b65ef | 129 | /* Good CRC, but error status from M24SR */ |
EnricoG | 0:ffc2448b65ef | 130 | return( ((DataIn[Length-UB_STATUS_OFFSET]<<8) & 0xFF00) | (DataIn[Length-LB_STATUS_OFFSET] & 0x00FF) ); |
EnricoG | 0:ffc2448b65ef | 131 | } |
EnricoG | 0:ffc2448b65ef | 132 | else |
EnricoG | 0:ffc2448b65ef | 133 | { |
EnricoG | 0:ffc2448b65ef | 134 | ResCRC=0; |
EnricoG | 0:ffc2448b65ef | 135 | ResCRC= M24SR_ComputeCrc (DataIn, 5); |
EnricoG | 0:ffc2448b65ef | 136 | if ( ResCRC != 0x0000) |
EnricoG | 0:ffc2448b65ef | 137 | { |
EnricoG | 0:ffc2448b65ef | 138 | /* Bad CRC */ |
EnricoG | 0:ffc2448b65ef | 139 | return M24SR_ERROR_CRC; |
EnricoG | 0:ffc2448b65ef | 140 | } |
EnricoG | 0:ffc2448b65ef | 141 | else |
EnricoG | 0:ffc2448b65ef | 142 | { |
EnricoG | 0:ffc2448b65ef | 143 | /* Good CRC, but error status from M24SR */ |
EnricoG | 0:ffc2448b65ef | 144 | return( ((DataIn[1]<<8) & 0xFF00) | (DataIn[2] & 0x00FF) ); |
EnricoG | 0:ffc2448b65ef | 145 | } |
EnricoG | 0:ffc2448b65ef | 146 | } |
EnricoG | 0:ffc2448b65ef | 147 | } |
EnricoG | 0:ffc2448b65ef | 148 | |
EnricoG | 0:ffc2448b65ef | 149 | /** |
EnricoG | 0:ffc2448b65ef | 150 | * @brief Initialize the command and response structure |
EnricoG | 0:ffc2448b65ef | 151 | * @param None |
EnricoG | 0:ffc2448b65ef | 152 | * @retval None |
EnricoG | 0:ffc2448b65ef | 153 | */ |
EnricoG | 0:ffc2448b65ef | 154 | static void M24SR_InitStructure ( void ) |
EnricoG | 0:ffc2448b65ef | 155 | { |
EnricoG | 0:ffc2448b65ef | 156 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 157 | Command.Header.CLA = 0x00; |
EnricoG | 0:ffc2448b65ef | 158 | Command.Header.INS = 0x00; |
EnricoG | 0:ffc2448b65ef | 159 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 160 | Command.Header.P1 = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 161 | Command.Header.P2 = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 162 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 163 | Command.Body.LC = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 164 | /* copy the number of byte to read */ |
EnricoG | 0:ffc2448b65ef | 165 | Command.Body.LE = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 166 | Command.Body.pData = DataBuffer; |
EnricoG | 0:ffc2448b65ef | 167 | |
EnricoG | 0:ffc2448b65ef | 168 | // /* initializes the response structure*/ |
EnricoG | 0:ffc2448b65ef | 169 | // Response.pData = DataBuffer; |
EnricoG | 0:ffc2448b65ef | 170 | // Response.SW1 = 0x00; |
EnricoG | 0:ffc2448b65ef | 171 | // Response.SW2 = 0x00; |
EnricoG | 0:ffc2448b65ef | 172 | } |
EnricoG | 0:ffc2448b65ef | 173 | |
EnricoG | 0:ffc2448b65ef | 174 | /** |
EnricoG | 0:ffc2448b65ef | 175 | * @brief This functions creates an I block command according to the structures CommandStructure and Command. |
EnricoG | 0:ffc2448b65ef | 176 | * @param Command : structue which contains the field of the different parameter |
EnricoG | 0:ffc2448b65ef | 177 | * @param CommandStructure : structure that contain the structure of the command (if the different field are presnet or not |
EnricoG | 0:ffc2448b65ef | 178 | * @param NbByte : number of byte of the command |
EnricoG | 0:ffc2448b65ef | 179 | * @param pCommand : pointer of the command created |
EnricoG | 0:ffc2448b65ef | 180 | */ |
EnricoG | 0:ffc2448b65ef | 181 | static void M24SR_BuildIBlockCommand ( uc16 CommandStructure, C_APDU Command, uint16_t *NbByte , uint8_t *pCommand) |
EnricoG | 0:ffc2448b65ef | 182 | { |
EnricoG | 0:ffc2448b65ef | 183 | uint16_t uCRC16; |
EnricoG | 0:ffc2448b65ef | 184 | static uint8_t BlockNumber = 0x01; |
EnricoG | 0:ffc2448b65ef | 185 | |
EnricoG | 0:ffc2448b65ef | 186 | (*NbByte) = 0; |
EnricoG | 0:ffc2448b65ef | 187 | |
EnricoG | 0:ffc2448b65ef | 188 | /* add the PCD byte */ |
EnricoG | 0:ffc2448b65ef | 189 | if ((CommandStructure & M24SR_PCB_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 190 | { |
EnricoG | 0:ffc2448b65ef | 191 | /* toggle the block number */ |
EnricoG | 0:ffc2448b65ef | 192 | BlockNumber = TOGGLE ( BlockNumber ); |
EnricoG | 0:ffc2448b65ef | 193 | /* Add the I block byte */ |
EnricoG | 0:ffc2448b65ef | 194 | pCommand[(*NbByte)++] = 0x02 | BlockNumber; |
EnricoG | 0:ffc2448b65ef | 195 | } |
EnricoG | 0:ffc2448b65ef | 196 | |
EnricoG | 0:ffc2448b65ef | 197 | /* add the DID byte */ |
EnricoG | 0:ffc2448b65ef | 198 | if ((BlockNumber & M24SR_DID_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 199 | { |
EnricoG | 0:ffc2448b65ef | 200 | /* Add the I block byte */ |
EnricoG | 0:ffc2448b65ef | 201 | pCommand[(*NbByte)++] = uDIDbyte; |
EnricoG | 0:ffc2448b65ef | 202 | } |
EnricoG | 0:ffc2448b65ef | 203 | |
EnricoG | 0:ffc2448b65ef | 204 | /* add the Class byte */ |
EnricoG | 0:ffc2448b65ef | 205 | if ((CommandStructure & M24SR_CLA_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 206 | { |
EnricoG | 0:ffc2448b65ef | 207 | pCommand[(*NbByte)++] = Command.Header.CLA ; |
EnricoG | 0:ffc2448b65ef | 208 | } |
EnricoG | 0:ffc2448b65ef | 209 | /* add the instruction byte byte */ |
EnricoG | 0:ffc2448b65ef | 210 | if ( (CommandStructure & M24SR_INS_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 211 | { |
EnricoG | 0:ffc2448b65ef | 212 | pCommand[(*NbByte)++] = Command.Header.INS ; |
EnricoG | 0:ffc2448b65ef | 213 | } |
EnricoG | 0:ffc2448b65ef | 214 | /* add the Selection Mode byte */ |
EnricoG | 0:ffc2448b65ef | 215 | if ((CommandStructure & M24SR_P1_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 216 | { |
EnricoG | 0:ffc2448b65ef | 217 | pCommand[(*NbByte)++] = Command.Header.P1 ; |
EnricoG | 0:ffc2448b65ef | 218 | } |
EnricoG | 0:ffc2448b65ef | 219 | /* add the Selection Mode byte */ |
EnricoG | 0:ffc2448b65ef | 220 | if ((CommandStructure & M24SR_P2_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 221 | { |
EnricoG | 0:ffc2448b65ef | 222 | pCommand[(*NbByte)++] = Command.Header.P2 ; |
EnricoG | 0:ffc2448b65ef | 223 | } |
EnricoG | 0:ffc2448b65ef | 224 | /* add Data field lengthbyte */ |
EnricoG | 0:ffc2448b65ef | 225 | if ((CommandStructure & M24SR_LC_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 226 | { |
EnricoG | 0:ffc2448b65ef | 227 | pCommand[(*NbByte)++] = Command.Body.LC ; |
EnricoG | 0:ffc2448b65ef | 228 | } |
EnricoG | 0:ffc2448b65ef | 229 | /* add Data field */ |
EnricoG | 0:ffc2448b65ef | 230 | if ((CommandStructure & M24SR_DATA_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 231 | { |
EnricoG | 0:ffc2448b65ef | 232 | memcpy(&(pCommand[(*NbByte)]) ,Command.Body.pData,Command.Body.LC ) ; |
EnricoG | 0:ffc2448b65ef | 233 | (*NbByte) += Command.Body.LC ; |
EnricoG | 0:ffc2448b65ef | 234 | } |
EnricoG | 0:ffc2448b65ef | 235 | /* add Le field */ |
EnricoG | 0:ffc2448b65ef | 236 | if ((CommandStructure & M24SR_LE_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 237 | { |
EnricoG | 0:ffc2448b65ef | 238 | pCommand[(*NbByte)++] = Command.Body.LE ; |
EnricoG | 0:ffc2448b65ef | 239 | } |
EnricoG | 0:ffc2448b65ef | 240 | /* add CRC field */ |
EnricoG | 0:ffc2448b65ef | 241 | if ((CommandStructure & M24SR_CRC_NEEDED) !=0) |
EnricoG | 0:ffc2448b65ef | 242 | { |
EnricoG | 0:ffc2448b65ef | 243 | uCRC16 = M24SR_ComputeCrc (pCommand,(uint8_t) (*NbByte)); |
EnricoG | 0:ffc2448b65ef | 244 | /* append the CRC16 */ |
EnricoG | 0:ffc2448b65ef | 245 | pCommand [(*NbByte)++] = GETLSB (uCRC16 ) ; |
EnricoG | 0:ffc2448b65ef | 246 | pCommand [(*NbByte)++] = GETMSB (uCRC16 ) ; |
EnricoG | 0:ffc2448b65ef | 247 | } |
EnricoG | 0:ffc2448b65ef | 248 | |
EnricoG | 0:ffc2448b65ef | 249 | } |
EnricoG | 0:ffc2448b65ef | 250 | |
EnricoG | 0:ffc2448b65ef | 251 | #if 0 |
EnricoG | 0:ffc2448b65ef | 252 | /** |
EnricoG | 0:ffc2448b65ef | 253 | * @brief This function return M24SR_STATUS_SUCCESS if the pBuffer is an I-block |
EnricoG | 0:ffc2448b65ef | 254 | * @param pBuffer : pointer of the data |
EnricoG | 0:ffc2448b65ef | 255 | * @retval M24SR_STATUS_SUCCESS : the data is a I-Block |
EnricoG | 0:ffc2448b65ef | 256 | * @retval M24SR_ERROR_DEFAULT : the data is not a I-Block |
EnricoG | 0:ffc2448b65ef | 257 | */ |
EnricoG | 0:ffc2448b65ef | 258 | static int8_t IsIBlock (uc8 *pBuffer) |
EnricoG | 0:ffc2448b65ef | 259 | { |
EnricoG | 0:ffc2448b65ef | 260 | |
EnricoG | 0:ffc2448b65ef | 261 | if ((pBuffer[M24SR_OFFSET_PCB] & M24SR_MASK_BLOCK) == M24SR_MASK_IBLOCK) |
EnricoG | 0:ffc2448b65ef | 262 | { |
EnricoG | 0:ffc2448b65ef | 263 | return M24SR_STATUS_SUCCESS; |
EnricoG | 0:ffc2448b65ef | 264 | } |
EnricoG | 0:ffc2448b65ef | 265 | else |
EnricoG | 0:ffc2448b65ef | 266 | { |
EnricoG | 0:ffc2448b65ef | 267 | return M24SR_ERROR_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 268 | } |
EnricoG | 0:ffc2448b65ef | 269 | |
EnricoG | 0:ffc2448b65ef | 270 | } |
EnricoG | 0:ffc2448b65ef | 271 | |
EnricoG | 0:ffc2448b65ef | 272 | /** |
EnricoG | 0:ffc2448b65ef | 273 | * @brief This function return M24SR_STATUS_SUCCESS if the pBuffer is an R-block |
EnricoG | 0:ffc2448b65ef | 274 | * @param pBuffer : pointer of the data |
EnricoG | 0:ffc2448b65ef | 275 | * @retval M24SR_STATUS_SUCCESS : the data is a R-Block |
EnricoG | 0:ffc2448b65ef | 276 | * @retval M24SR_ERROR_DEFAULT : the data is not a R-Block |
EnricoG | 0:ffc2448b65ef | 277 | */ |
EnricoG | 0:ffc2448b65ef | 278 | static int8_t IsRBlock (uc8 *pBuffer) |
EnricoG | 0:ffc2448b65ef | 279 | { |
EnricoG | 0:ffc2448b65ef | 280 | |
EnricoG | 0:ffc2448b65ef | 281 | if ((pBuffer[M24SR_OFFSET_PCB] & M24SR_MASK_BLOCK) == M24SR_MASK_RBLOCK) |
EnricoG | 0:ffc2448b65ef | 282 | { |
EnricoG | 0:ffc2448b65ef | 283 | return M24SR_STATUS_SUCCESS; |
EnricoG | 0:ffc2448b65ef | 284 | } |
EnricoG | 0:ffc2448b65ef | 285 | else |
EnricoG | 0:ffc2448b65ef | 286 | { |
EnricoG | 0:ffc2448b65ef | 287 | return M24SR_ERROR_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 288 | } |
EnricoG | 0:ffc2448b65ef | 289 | |
EnricoG | 0:ffc2448b65ef | 290 | } |
EnricoG | 0:ffc2448b65ef | 291 | #endif |
EnricoG | 0:ffc2448b65ef | 292 | |
EnricoG | 0:ffc2448b65ef | 293 | /** |
EnricoG | 0:ffc2448b65ef | 294 | * @brief This function return M24SR_STATUS_SUCCESS if the pBuffer is an s-block |
EnricoG | 0:ffc2448b65ef | 295 | * @param pBuffer : pointer of the data |
EnricoG | 0:ffc2448b65ef | 296 | * @retval M24SR_STATUS_SUCCESS : the data is a S-Block |
EnricoG | 0:ffc2448b65ef | 297 | * @retval M24SR_ERROR_DEFAULT : the data is not a S-Block |
EnricoG | 0:ffc2448b65ef | 298 | */ |
EnricoG | 0:ffc2448b65ef | 299 | static int8_t IsSBlock (uc8 *pBuffer) |
EnricoG | 0:ffc2448b65ef | 300 | { |
EnricoG | 0:ffc2448b65ef | 301 | |
EnricoG | 0:ffc2448b65ef | 302 | if ((pBuffer[M24SR_OFFSET_PCB] & M24SR_MASK_BLOCK) == M24SR_MASK_SBLOCK) |
EnricoG | 0:ffc2448b65ef | 303 | { |
EnricoG | 0:ffc2448b65ef | 304 | return M24SR_STATUS_SUCCESS; |
EnricoG | 0:ffc2448b65ef | 305 | } |
EnricoG | 0:ffc2448b65ef | 306 | else |
EnricoG | 0:ffc2448b65ef | 307 | { |
EnricoG | 0:ffc2448b65ef | 308 | return M24SR_ERROR_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 309 | } |
EnricoG | 0:ffc2448b65ef | 310 | |
EnricoG | 0:ffc2448b65ef | 311 | } |
EnricoG | 0:ffc2448b65ef | 312 | |
EnricoG | 0:ffc2448b65ef | 313 | /** |
EnricoG | 0:ffc2448b65ef | 314 | * @brief This function sends the FWT extension command (S-Block format) |
EnricoG | 0:ffc2448b65ef | 315 | * @param FWTbyte : FWT value |
EnricoG | 0:ffc2448b65ef | 316 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 317 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 318 | */ |
EnricoG | 0:ffc2448b65ef | 319 | static uint16_t M24SR_FWTExtension ( uint8_t FWTbyte ) |
EnricoG | 0:ffc2448b65ef | 320 | { |
EnricoG | 0:ffc2448b65ef | 321 | uint8_t pBuffer[M24SR_STATUSRESPONSE_NBBYTE]; |
EnricoG | 0:ffc2448b65ef | 322 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 323 | uint16_t NthByte = 0, |
EnricoG | 0:ffc2448b65ef | 324 | uCRC16; |
EnricoG | 0:ffc2448b65ef | 325 | |
EnricoG | 0:ffc2448b65ef | 326 | /* create the response */ |
EnricoG | 0:ffc2448b65ef | 327 | pBuffer[NthByte++] = 0xF2 ; |
EnricoG | 0:ffc2448b65ef | 328 | pBuffer[NthByte++] = FWTbyte ; |
EnricoG | 0:ffc2448b65ef | 329 | /* compute the CRC */ |
EnricoG | 0:ffc2448b65ef | 330 | uCRC16 = M24SR_ComputeCrc (pBuffer,0x02); |
EnricoG | 0:ffc2448b65ef | 331 | /* append the CRC16 */ |
EnricoG | 0:ffc2448b65ef | 332 | pBuffer [NthByte++] = GETLSB (uCRC16 ) ; |
EnricoG | 0:ffc2448b65ef | 333 | pBuffer [NthByte++]= GETMSB (uCRC16 ) ; |
EnricoG | 0:ffc2448b65ef | 334 | |
EnricoG | 0:ffc2448b65ef | 335 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 336 | errchk( M24SR_SendI2Ccommand ( NthByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 337 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 338 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 339 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 340 | |
EnricoG | 0:ffc2448b65ef | 341 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 342 | return status; |
EnricoG | 0:ffc2448b65ef | 343 | |
EnricoG | 0:ffc2448b65ef | 344 | Error : |
EnricoG | 0:ffc2448b65ef | 345 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 346 | } |
EnricoG | 0:ffc2448b65ef | 347 | |
EnricoG | 0:ffc2448b65ef | 348 | /** |
EnricoG | 0:ffc2448b65ef | 349 | * @} |
EnricoG | 0:ffc2448b65ef | 350 | */ |
EnricoG | 0:ffc2448b65ef | 351 | |
EnricoG | 0:ffc2448b65ef | 352 | |
EnricoG | 0:ffc2448b65ef | 353 | /** @defgroup drvM24SR_Public_Functions |
EnricoG | 0:ffc2448b65ef | 354 | * @{ |
EnricoG | 0:ffc2448b65ef | 355 | */ |
EnricoG | 0:ffc2448b65ef | 356 | |
EnricoG | 0:ffc2448b65ef | 357 | /** |
EnricoG | 0:ffc2448b65ef | 358 | * @brief This function initialize the M24SR device |
EnricoG | 0:ffc2448b65ef | 359 | * @retval None |
EnricoG | 0:ffc2448b65ef | 360 | */ |
EnricoG | 0:ffc2448b65ef | 361 | void M24SR_Init( void ) |
EnricoG | 0:ffc2448b65ef | 362 | { |
EnricoG | 0:ffc2448b65ef | 363 | M24SR_I2CInit(); |
EnricoG | 0:ffc2448b65ef | 364 | // M24SR_GPOInit(); // Empty function |
EnricoG | 0:ffc2448b65ef | 365 | |
EnricoG | 0:ffc2448b65ef | 366 | M24SR_InitStructure(); |
EnricoG | 0:ffc2448b65ef | 367 | |
EnricoG | 0:ffc2448b65ef | 368 | #if defined (I2C_GPO_SYNCHRO_ALLOWED) || defined (I2C_GPO_INTERRUPT_ALLOWED) |
EnricoG | 0:ffc2448b65ef | 369 | if( M24SR_KillSession() == M24SR_ACTION_COMPLETED) |
EnricoG | 0:ffc2448b65ef | 370 | { |
EnricoG | 0:ffc2448b65ef | 371 | M24SR_ManageI2CGPO(I2C_ANSWER_READY); |
EnricoG | 0:ffc2448b65ef | 372 | M24SR_Deselect (); |
EnricoG | 0:ffc2448b65ef | 373 | } |
EnricoG | 0:ffc2448b65ef | 374 | #endif /* I2C_GPO_SYNCHRO_ALLOWED */ |
EnricoG | 0:ffc2448b65ef | 375 | } |
EnricoG | 0:ffc2448b65ef | 376 | |
EnricoG | 0:ffc2448b65ef | 377 | /** |
EnricoG | 0:ffc2448b65ef | 378 | * @brief This function sends the GetSession command to the M24SR device |
EnricoG | 0:ffc2448b65ef | 379 | * @retval M24SR_ACTION_COMPLETED : the function is succesful. |
EnricoG | 0:ffc2448b65ef | 380 | * @retval Status (SW1&SW2) : if operation does not complete. |
EnricoG | 0:ffc2448b65ef | 381 | */ |
EnricoG | 0:ffc2448b65ef | 382 | uint16_t M24SR_GetSession ( void ) |
EnricoG | 0:ffc2448b65ef | 383 | { |
EnricoG | 0:ffc2448b65ef | 384 | uint8_t Buffer = M24SR_OPENSESSION; |
EnricoG | 0:ffc2448b65ef | 385 | int16_t status; |
EnricoG | 0:ffc2448b65ef | 386 | |
EnricoG | 0:ffc2448b65ef | 387 | errchk(M24SR_SendI2Ccommand ( 0x01 , &Buffer )); |
EnricoG | 0:ffc2448b65ef | 388 | |
EnricoG | 0:ffc2448b65ef | 389 | /* Insure no access will be done just after open session */ |
EnricoG | 0:ffc2448b65ef | 390 | /* The only way here is to poll I2C to know when M24SR is ready */ |
EnricoG | 0:ffc2448b65ef | 391 | /* GPO can not be use with GetSession command */ |
EnricoG | 0:ffc2448b65ef | 392 | errchk(M24SR_PollI2C ( )); |
EnricoG | 0:ffc2448b65ef | 393 | |
EnricoG | 0:ffc2448b65ef | 394 | return M24SR_ACTION_COMPLETED; |
EnricoG | 0:ffc2448b65ef | 395 | Error : |
EnricoG | 0:ffc2448b65ef | 396 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 397 | } |
EnricoG | 0:ffc2448b65ef | 398 | |
EnricoG | 0:ffc2448b65ef | 399 | |
EnricoG | 0:ffc2448b65ef | 400 | |
EnricoG | 0:ffc2448b65ef | 401 | /** |
EnricoG | 0:ffc2448b65ef | 402 | * @brief This function sends the KillSession command to the M24SR device |
EnricoG | 0:ffc2448b65ef | 403 | * @param None |
EnricoG | 0:ffc2448b65ef | 404 | * @retval M24SR_ACTION_COMPLETED : the function is succesful. |
EnricoG | 0:ffc2448b65ef | 405 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 406 | */ |
EnricoG | 0:ffc2448b65ef | 407 | uint16_t M24SR_KillSession ( void ) |
EnricoG | 0:ffc2448b65ef | 408 | { |
EnricoG | 0:ffc2448b65ef | 409 | uint8_t pBuffer[] = {M24SR_KILLSESSION}; |
EnricoG | 0:ffc2448b65ef | 410 | int8_t status; |
EnricoG | 0:ffc2448b65ef | 411 | |
EnricoG | 0:ffc2448b65ef | 412 | errchk(M24SR_SendI2Ccommand ( 0x01 , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 413 | |
EnricoG | 0:ffc2448b65ef | 414 | /* Insure no access will be done just after open session */ |
EnricoG | 0:ffc2448b65ef | 415 | /* The only way here is to poll I2C to know when M24SR is ready */ |
EnricoG | 0:ffc2448b65ef | 416 | /* GPO can not be use with KillSession command */ |
EnricoG | 0:ffc2448b65ef | 417 | errchk(M24SR_PollI2C ( )); |
EnricoG | 0:ffc2448b65ef | 418 | |
EnricoG | 0:ffc2448b65ef | 419 | return M24SR_ACTION_COMPLETED; |
EnricoG | 0:ffc2448b65ef | 420 | Error : |
EnricoG | 0:ffc2448b65ef | 421 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 422 | } |
EnricoG | 0:ffc2448b65ef | 423 | |
EnricoG | 0:ffc2448b65ef | 424 | |
EnricoG | 0:ffc2448b65ef | 425 | /** |
EnricoG | 0:ffc2448b65ef | 426 | * @brief This function sends the Deselect command (S-Block format) |
EnricoG | 0:ffc2448b65ef | 427 | * @retval M24SR_ACTION_COMPLETED : the function is succesful. |
EnricoG | 0:ffc2448b65ef | 428 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 429 | */ |
EnricoG | 0:ffc2448b65ef | 430 | uint16_t M24SR_Deselect ( void ) |
EnricoG | 0:ffc2448b65ef | 431 | { |
EnricoG | 0:ffc2448b65ef | 432 | uint8_t pBuffer[] = {0xC2,0xE0,0xB4} ; |
EnricoG | 0:ffc2448b65ef | 433 | int8_t status ; |
EnricoG | 0:ffc2448b65ef | 434 | |
EnricoG | 0:ffc2448b65ef | 435 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 436 | errchk( M24SR_SendI2Ccommand ( M24SR_DESELECTREQUEST_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 437 | |
EnricoG | 0:ffc2448b65ef | 438 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 439 | /* flush the M24SR buffer */ |
EnricoG | 0:ffc2448b65ef | 440 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_DESELECTREQUEST_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 441 | |
EnricoG | 0:ffc2448b65ef | 442 | return M24SR_ACTION_COMPLETED; |
EnricoG | 0:ffc2448b65ef | 443 | |
EnricoG | 0:ffc2448b65ef | 444 | Error : |
EnricoG | 0:ffc2448b65ef | 445 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 446 | } |
EnricoG | 0:ffc2448b65ef | 447 | |
EnricoG | 0:ffc2448b65ef | 448 | |
EnricoG | 0:ffc2448b65ef | 449 | |
EnricoG | 0:ffc2448b65ef | 450 | |
EnricoG | 0:ffc2448b65ef | 451 | /** |
EnricoG | 0:ffc2448b65ef | 452 | * @brief This function sends the SelectApplication command |
EnricoG | 0:ffc2448b65ef | 453 | * @retval M24SR_ACTION_COMPLETED : the function is succesful. |
EnricoG | 0:ffc2448b65ef | 454 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 455 | */ |
EnricoG | 0:ffc2448b65ef | 456 | uint16_t M24SR_SelectApplication ( void ) |
EnricoG | 0:ffc2448b65ef | 457 | { |
EnricoG | 0:ffc2448b65ef | 458 | uint8_t *pBuffer = uM24SRbuffer , |
EnricoG | 0:ffc2448b65ef | 459 | NbByteToRead = M24SR_STATUSRESPONSE_NBBYTE; |
EnricoG | 0:ffc2448b65ef | 460 | uint8_t uLc = 0x07, |
EnricoG | 0:ffc2448b65ef | 461 | pData[] = {0xD2,0x76,0x00,0x00,0x85,0x01,0x01}, |
EnricoG | 0:ffc2448b65ef | 462 | uLe = 0x00; |
EnricoG | 0:ffc2448b65ef | 463 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 464 | uint16_t uP1P2 =0x0400, |
EnricoG | 0:ffc2448b65ef | 465 | NbByte; |
EnricoG | 0:ffc2448b65ef | 466 | |
EnricoG | 0:ffc2448b65ef | 467 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 468 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 469 | Command.Header.INS = C_APDU_SELECT_FILE; |
EnricoG | 0:ffc2448b65ef | 470 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 471 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 472 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 473 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 474 | Command.Body.LC = uLc ; |
EnricoG | 0:ffc2448b65ef | 475 | /* copy the data */ |
EnricoG | 0:ffc2448b65ef | 476 | memcpy(Command.Body.pData, pData, uLc); |
EnricoG | 0:ffc2448b65ef | 477 | /* copy the number of byte to read */ |
EnricoG | 0:ffc2448b65ef | 478 | Command.Body.LE = uLe ; |
EnricoG | 0:ffc2448b65ef | 479 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 480 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_SELECTAPPLICATION, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 481 | |
EnricoG | 0:ffc2448b65ef | 482 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 483 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 484 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 485 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 486 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 487 | |
EnricoG | 0:ffc2448b65ef | 488 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 489 | return status; |
EnricoG | 0:ffc2448b65ef | 490 | |
EnricoG | 0:ffc2448b65ef | 491 | Error : |
EnricoG | 0:ffc2448b65ef | 492 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 493 | } |
EnricoG | 0:ffc2448b65ef | 494 | |
EnricoG | 0:ffc2448b65ef | 495 | /** |
EnricoG | 0:ffc2448b65ef | 496 | * @brief This function sends the SelectCCFile command |
EnricoG | 0:ffc2448b65ef | 497 | * @retval M24SR_ACTION_COMPLETED : the function is succesful. |
EnricoG | 0:ffc2448b65ef | 498 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 499 | * @retval Status (SW1&SW2) : if operation does not complete for another reason. |
EnricoG | 0:ffc2448b65ef | 500 | */ |
EnricoG | 0:ffc2448b65ef | 501 | uint16_t M24SR_SelectCCfile ( void ) |
EnricoG | 0:ffc2448b65ef | 502 | { |
EnricoG | 0:ffc2448b65ef | 503 | uint8_t *pBuffer = uM24SRbuffer , |
EnricoG | 0:ffc2448b65ef | 504 | NbByteToRead = M24SR_STATUSRESPONSE_NBBYTE; |
EnricoG | 0:ffc2448b65ef | 505 | uint8_t uLc = 0x02; |
EnricoG | 0:ffc2448b65ef | 506 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 507 | uint16_t uP1P2 =0x000C, |
EnricoG | 0:ffc2448b65ef | 508 | uNbFileId =CC_FILE_ID, |
EnricoG | 0:ffc2448b65ef | 509 | NbByte; |
EnricoG | 0:ffc2448b65ef | 510 | |
EnricoG | 0:ffc2448b65ef | 511 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 512 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 513 | Command.Header.INS = C_APDU_SELECT_FILE; |
EnricoG | 0:ffc2448b65ef | 514 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 515 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 516 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 517 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 518 | Command.Body.LC = uLc ; |
EnricoG | 0:ffc2448b65ef | 519 | /* copy the File Id */ |
EnricoG | 0:ffc2448b65ef | 520 | Command.Body.pData[0] = GETMSB (uNbFileId ) ; |
EnricoG | 0:ffc2448b65ef | 521 | Command.Body.pData[1] = GETLSB (uNbFileId ) ; |
EnricoG | 0:ffc2448b65ef | 522 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 523 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_SELECTCCFILE, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 524 | |
EnricoG | 0:ffc2448b65ef | 525 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 526 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 527 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 528 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 529 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 530 | |
EnricoG | 0:ffc2448b65ef | 531 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 532 | return status; |
EnricoG | 0:ffc2448b65ef | 533 | |
EnricoG | 0:ffc2448b65ef | 534 | Error : |
EnricoG | 0:ffc2448b65ef | 535 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 536 | } |
EnricoG | 0:ffc2448b65ef | 537 | |
EnricoG | 0:ffc2448b65ef | 538 | |
EnricoG | 0:ffc2448b65ef | 539 | /** |
EnricoG | 0:ffc2448b65ef | 540 | * @brief This function sends the SelectSystemFile command |
EnricoG | 0:ffc2448b65ef | 541 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 542 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 543 | */ |
EnricoG | 0:ffc2448b65ef | 544 | uint16_t M24SR_SelectSystemfile ( void ) |
EnricoG | 0:ffc2448b65ef | 545 | { |
EnricoG | 0:ffc2448b65ef | 546 | uint8_t *pBuffer = uM24SRbuffer , |
EnricoG | 0:ffc2448b65ef | 547 | NbByteToRead = M24SR_STATUSRESPONSE_NBBYTE; |
EnricoG | 0:ffc2448b65ef | 548 | uint8_t uLc = 0x02; |
EnricoG | 0:ffc2448b65ef | 549 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 550 | uint16_t uP1P2 =0x000C, |
EnricoG | 0:ffc2448b65ef | 551 | uNbFileId =SYSTEM_FILE_ID, |
EnricoG | 0:ffc2448b65ef | 552 | NbByte; |
EnricoG | 0:ffc2448b65ef | 553 | |
EnricoG | 0:ffc2448b65ef | 554 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 555 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 556 | Command.Header.INS = C_APDU_SELECT_FILE; |
EnricoG | 0:ffc2448b65ef | 557 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 558 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 559 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 560 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 561 | Command.Body.LC = uLc ; |
EnricoG | 0:ffc2448b65ef | 562 | /* copy the File Id */ |
EnricoG | 0:ffc2448b65ef | 563 | Command.Body.pData[0] = GETMSB (uNbFileId ) ; |
EnricoG | 0:ffc2448b65ef | 564 | Command.Body.pData[1] = GETLSB (uNbFileId ) ; |
EnricoG | 0:ffc2448b65ef | 565 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 566 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_SELECTCCFILE, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 567 | |
EnricoG | 0:ffc2448b65ef | 568 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 569 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 570 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 571 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 572 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 573 | |
EnricoG | 0:ffc2448b65ef | 574 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 575 | return status; |
EnricoG | 0:ffc2448b65ef | 576 | |
EnricoG | 0:ffc2448b65ef | 577 | Error : |
EnricoG | 0:ffc2448b65ef | 578 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 579 | } |
EnricoG | 0:ffc2448b65ef | 580 | |
EnricoG | 0:ffc2448b65ef | 581 | /** |
EnricoG | 0:ffc2448b65ef | 582 | * @brief This function sends the SelectNDEFfile command |
EnricoG | 0:ffc2448b65ef | 583 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 584 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 585 | */ |
EnricoG | 0:ffc2448b65ef | 586 | uint16_t M24SR_SelectNDEFfile ( uc16 NDEFfileId ) |
EnricoG | 0:ffc2448b65ef | 587 | { |
EnricoG | 0:ffc2448b65ef | 588 | uint8_t *pBuffer = uM24SRbuffer , |
EnricoG | 0:ffc2448b65ef | 589 | NbByteToRead = M24SR_STATUSRESPONSE_NBBYTE; |
EnricoG | 0:ffc2448b65ef | 590 | uint8_t uLc = 0x02; |
EnricoG | 0:ffc2448b65ef | 591 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 592 | uint16_t uP1P2 =0x000C, |
EnricoG | 0:ffc2448b65ef | 593 | NbByte; |
EnricoG | 0:ffc2448b65ef | 594 | |
EnricoG | 0:ffc2448b65ef | 595 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 596 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 597 | Command.Header.INS = C_APDU_SELECT_FILE; |
EnricoG | 0:ffc2448b65ef | 598 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 599 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 600 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 601 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 602 | Command.Body.LC = uLc ; |
EnricoG | 0:ffc2448b65ef | 603 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 604 | Command.Body.pData[0] = GETMSB (NDEFfileId ) ; |
EnricoG | 0:ffc2448b65ef | 605 | Command.Body.pData[1] = GETLSB (NDEFfileId ) ; |
EnricoG | 0:ffc2448b65ef | 606 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 607 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_SELECTNDEFFILE, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 608 | |
EnricoG | 0:ffc2448b65ef | 609 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 610 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 611 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 612 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 613 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 614 | |
EnricoG | 0:ffc2448b65ef | 615 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 616 | return status; |
EnricoG | 0:ffc2448b65ef | 617 | |
EnricoG | 0:ffc2448b65ef | 618 | Error : |
EnricoG | 0:ffc2448b65ef | 619 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 620 | |
EnricoG | 0:ffc2448b65ef | 621 | } |
EnricoG | 0:ffc2448b65ef | 622 | |
EnricoG | 0:ffc2448b65ef | 623 | /** |
EnricoG | 0:ffc2448b65ef | 624 | * @brief This function sends a read binary command |
EnricoG | 0:ffc2448b65ef | 625 | * @param Offset : first byte to read |
EnricoG | 0:ffc2448b65ef | 626 | * @param NbByteToRead : number of byte to read |
EnricoG | 0:ffc2448b65ef | 627 | * @param pBufferRead : pointer of the buffer read from the M24SR device |
EnricoG | 0:ffc2448b65ef | 628 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 629 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 630 | */ |
EnricoG | 0:ffc2448b65ef | 631 | uint16_t M24SR_ReadBinary ( uc16 Offset ,uc8 NbByteToRead , uint8_t *pBufferRead ) |
EnricoG | 0:ffc2448b65ef | 632 | { |
EnricoG | 0:ffc2448b65ef | 633 | uint8_t *pBuffer = uM24SRbuffer ; |
EnricoG | 0:ffc2448b65ef | 634 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 635 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 636 | |
EnricoG | 0:ffc2448b65ef | 637 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 638 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 639 | Command.Header.INS = C_APDU_READ_BINARY; |
EnricoG | 0:ffc2448b65ef | 640 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 641 | Command.Header.P1 = GETMSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 642 | Command.Header.P2 = GETLSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 643 | /* copy the number of byte to read */ |
EnricoG | 0:ffc2448b65ef | 644 | Command.Body.LE = NbByteToRead ; |
EnricoG | 0:ffc2448b65ef | 645 | |
EnricoG | 0:ffc2448b65ef | 646 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_READBINARY, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 647 | |
EnricoG | 0:ffc2448b65ef | 648 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 649 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 650 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead + M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 651 | |
EnricoG | 0:ffc2448b65ef | 652 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead+ M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 653 | /* retrieve the data without SW1 & SW2 as provided as return value of the function */ |
EnricoG | 0:ffc2448b65ef | 654 | memcpy(pBufferRead ,&pBuffer[1],NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 655 | return status; |
EnricoG | 0:ffc2448b65ef | 656 | |
EnricoG | 0:ffc2448b65ef | 657 | Error : |
EnricoG | 0:ffc2448b65ef | 658 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 659 | |
EnricoG | 0:ffc2448b65ef | 660 | } |
EnricoG | 0:ffc2448b65ef | 661 | |
EnricoG | 0:ffc2448b65ef | 662 | |
EnricoG | 0:ffc2448b65ef | 663 | |
EnricoG | 0:ffc2448b65ef | 664 | /** |
EnricoG | 0:ffc2448b65ef | 665 | * @brief This function sends a ST read binary command (no error if access is not inside NDEF file) |
EnricoG | 0:ffc2448b65ef | 666 | * @param Offset : first byte to read |
EnricoG | 0:ffc2448b65ef | 667 | * @param NbByteToRead : number of byte to read |
EnricoG | 0:ffc2448b65ef | 668 | * @param pBufferRead : pointer of the buffer read from the M24SR device |
EnricoG | 0:ffc2448b65ef | 669 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 670 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 671 | */ |
EnricoG | 0:ffc2448b65ef | 672 | uint16_t M24SR_STReadBinary ( uc16 Offset, uc8 NbByteToRead, uint8_t *pBufferRead ) |
EnricoG | 0:ffc2448b65ef | 673 | { |
EnricoG | 0:ffc2448b65ef | 674 | uint8_t *pBuffer = uM24SRbuffer ; |
EnricoG | 0:ffc2448b65ef | 675 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 676 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 677 | |
EnricoG | 0:ffc2448b65ef | 678 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 679 | Command.Header.CLA = C_APDU_CLA_ST; |
EnricoG | 0:ffc2448b65ef | 680 | Command.Header.INS = C_APDU_READ_BINARY; |
EnricoG | 0:ffc2448b65ef | 681 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 682 | Command.Header.P1 = GETMSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 683 | Command.Header.P2 = GETLSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 684 | /* copy the number of byte to read */ |
EnricoG | 0:ffc2448b65ef | 685 | Command.Body.LE = NbByteToRead ; |
EnricoG | 0:ffc2448b65ef | 686 | |
EnricoG | 0:ffc2448b65ef | 687 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_READBINARY, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 688 | |
EnricoG | 0:ffc2448b65ef | 689 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 690 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 691 | errchk( M24SR_ReceiveI2Cresponse ( NbByteToRead + M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 692 | |
EnricoG | 0:ffc2448b65ef | 693 | status = M24SR_IsCorrectCRC16Residue (pBuffer,NbByteToRead+ M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 694 | /* retrieve the data without SW1 & SW2 as provided as return value of the function */ |
EnricoG | 0:ffc2448b65ef | 695 | memcpy(pBufferRead ,&pBuffer[1],NbByteToRead); |
EnricoG | 0:ffc2448b65ef | 696 | return status; |
EnricoG | 0:ffc2448b65ef | 697 | |
EnricoG | 0:ffc2448b65ef | 698 | Error : |
EnricoG | 0:ffc2448b65ef | 699 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 700 | |
EnricoG | 0:ffc2448b65ef | 701 | } |
EnricoG | 0:ffc2448b65ef | 702 | |
EnricoG | 0:ffc2448b65ef | 703 | /** |
EnricoG | 0:ffc2448b65ef | 704 | * @brief This function sends a Update binary command |
EnricoG | 0:ffc2448b65ef | 705 | * @param Offset : first byte to read |
EnricoG | 0:ffc2448b65ef | 706 | * @param NbByteToWrite : number of byte to write |
EnricoG | 0:ffc2448b65ef | 707 | * @param pBufferRead : pointer of the buffer read from the M24SR device |
EnricoG | 0:ffc2448b65ef | 708 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 709 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 710 | */ |
EnricoG | 0:ffc2448b65ef | 711 | uint16_t M24SR_UpdateBinary ( uc16 Offset ,uc8 NbByteToWrite,uc8 *pDataToWrite ) |
EnricoG | 0:ffc2448b65ef | 712 | { |
EnricoG | 0:ffc2448b65ef | 713 | uint8_t *pBuffer = uM24SRbuffer ; |
EnricoG | 0:ffc2448b65ef | 714 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 715 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 716 | |
EnricoG | 0:ffc2448b65ef | 717 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 718 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 719 | Command.Header.INS = C_APDU_UPDATE_BINARY; |
EnricoG | 0:ffc2448b65ef | 720 | /* copy the offset */ |
EnricoG | 0:ffc2448b65ef | 721 | Command.Header.P1 = GETMSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 722 | Command.Header.P2 = GETLSB (Offset ) ; |
EnricoG | 0:ffc2448b65ef | 723 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 724 | Command.Body.LC = NbByteToWrite ; |
EnricoG | 0:ffc2448b65ef | 725 | /* copy the File Id */ |
EnricoG | 0:ffc2448b65ef | 726 | memcpy(Command.Body.pData ,pDataToWrite, NbByteToWrite ); |
EnricoG | 0:ffc2448b65ef | 727 | |
EnricoG | 0:ffc2448b65ef | 728 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_UPDATEBINARY, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 729 | |
EnricoG | 0:ffc2448b65ef | 730 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 731 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 732 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 733 | /* if the response is a Watiting frame extenstion request */ |
EnricoG | 0:ffc2448b65ef | 734 | if (IsSBlock (pBuffer) == M24SR_STATUS_SUCCESS) |
EnricoG | 0:ffc2448b65ef | 735 | { |
EnricoG | 0:ffc2448b65ef | 736 | /*check the CRC */ |
EnricoG | 0:ffc2448b65ef | 737 | if (M24SR_IsCorrectCRC16Residue (pBuffer , M24SR_WATINGTIMEEXTRESPONSE_NBBYTE) != M24SR_ERROR_CRC) |
EnricoG | 0:ffc2448b65ef | 738 | { |
EnricoG | 0:ffc2448b65ef | 739 | /* send the FrameExension response*/ |
EnricoG | 0:ffc2448b65ef | 740 | status = M24SR_FWTExtension ( pBuffer [M24SR_OFFSET_PCB+1] ); |
EnricoG | 0:ffc2448b65ef | 741 | } |
EnricoG | 0:ffc2448b65ef | 742 | } |
EnricoG | 0:ffc2448b65ef | 743 | else |
EnricoG | 0:ffc2448b65ef | 744 | { |
EnricoG | 0:ffc2448b65ef | 745 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 746 | } |
EnricoG | 0:ffc2448b65ef | 747 | |
EnricoG | 0:ffc2448b65ef | 748 | return status; |
EnricoG | 0:ffc2448b65ef | 749 | |
EnricoG | 0:ffc2448b65ef | 750 | |
EnricoG | 0:ffc2448b65ef | 751 | Error : |
EnricoG | 0:ffc2448b65ef | 752 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 753 | } |
EnricoG | 0:ffc2448b65ef | 754 | |
EnricoG | 0:ffc2448b65ef | 755 | |
EnricoG | 0:ffc2448b65ef | 756 | /** |
EnricoG | 0:ffc2448b65ef | 757 | * @brief This function sends the Verify command |
EnricoG | 0:ffc2448b65ef | 758 | * @param uPwdId : PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd) |
EnricoG | 0:ffc2448b65ef | 759 | * @param NbPwdByte : Number of byte ( 0x00 or 0x10) |
EnricoG | 0:ffc2448b65ef | 760 | * @param pPwd : pointer on the passwaord |
EnricoG | 0:ffc2448b65ef | 761 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 762 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 763 | */ |
EnricoG | 0:ffc2448b65ef | 764 | uint16_t M24SR_Verify ( uc16 uPwdId,uc8 NbPwdByte ,uc8 *pPwd ) |
EnricoG | 0:ffc2448b65ef | 765 | { |
EnricoG | 0:ffc2448b65ef | 766 | uint8_t *pBuffer = uM24SRbuffer ; |
EnricoG | 0:ffc2448b65ef | 767 | uint16_t status = 0x0000 ; |
EnricoG | 0:ffc2448b65ef | 768 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 769 | |
EnricoG | 0:ffc2448b65ef | 770 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 771 | if (uPwdId > 0x0003) |
EnricoG | 0:ffc2448b65ef | 772 | { |
EnricoG | 0:ffc2448b65ef | 773 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 774 | } |
EnricoG | 0:ffc2448b65ef | 775 | if ( (NbPwdByte != 0x00) && (NbPwdByte != 0x10)) |
EnricoG | 0:ffc2448b65ef | 776 | { |
EnricoG | 0:ffc2448b65ef | 777 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 778 | } |
EnricoG | 0:ffc2448b65ef | 779 | |
EnricoG | 0:ffc2448b65ef | 780 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 781 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 782 | Command.Header.INS = C_APDU_VERIFY; |
EnricoG | 0:ffc2448b65ef | 783 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 784 | Command.Header.P1 = GETMSB (uPwdId ) ; |
EnricoG | 0:ffc2448b65ef | 785 | Command.Header.P2 = GETLSB (uPwdId ) ; |
EnricoG | 0:ffc2448b65ef | 786 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 787 | Command.Body.LC = NbPwdByte ; |
EnricoG | 0:ffc2448b65ef | 788 | |
EnricoG | 0:ffc2448b65ef | 789 | if (NbPwdByte == 0x10) |
EnricoG | 0:ffc2448b65ef | 790 | { |
EnricoG | 0:ffc2448b65ef | 791 | /* copy the password */ |
EnricoG | 0:ffc2448b65ef | 792 | memcpy(Command.Body.pData, pPwd, NbPwdByte); |
EnricoG | 0:ffc2448b65ef | 793 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 794 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_VERIFYBINARYWITHPWD, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 795 | } |
EnricoG | 0:ffc2448b65ef | 796 | else |
EnricoG | 0:ffc2448b65ef | 797 | { |
EnricoG | 0:ffc2448b65ef | 798 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 799 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_VERIFYBINARYWOPWD, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 800 | } |
EnricoG | 0:ffc2448b65ef | 801 | |
EnricoG | 0:ffc2448b65ef | 802 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 803 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 804 | /* wait for answer ready */ |
EnricoG | 0:ffc2448b65ef | 805 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 806 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 807 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 808 | |
EnricoG | 0:ffc2448b65ef | 809 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 810 | return status; |
EnricoG | 0:ffc2448b65ef | 811 | |
EnricoG | 0:ffc2448b65ef | 812 | Error : |
EnricoG | 0:ffc2448b65ef | 813 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 814 | } |
EnricoG | 0:ffc2448b65ef | 815 | |
EnricoG | 0:ffc2448b65ef | 816 | |
EnricoG | 0:ffc2448b65ef | 817 | /** |
EnricoG | 0:ffc2448b65ef | 818 | * @brief This function sends the ChangeReferenceData command |
EnricoG | 0:ffc2448b65ef | 819 | * @param uPwdId : PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd) |
EnricoG | 0:ffc2448b65ef | 820 | * @param pPwd : pointer on the passwaord |
EnricoG | 0:ffc2448b65ef | 821 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 822 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 823 | */ |
EnricoG | 0:ffc2448b65ef | 824 | uint16_t M24SR_ChangeReferenceData ( uc16 uPwdId,uc8 *pPwd ) |
EnricoG | 0:ffc2448b65ef | 825 | { |
EnricoG | 0:ffc2448b65ef | 826 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 827 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 828 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 829 | |
EnricoG | 0:ffc2448b65ef | 830 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 831 | if (uPwdId > 0x0003) |
EnricoG | 0:ffc2448b65ef | 832 | { |
EnricoG | 0:ffc2448b65ef | 833 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 834 | } |
EnricoG | 0:ffc2448b65ef | 835 | |
EnricoG | 0:ffc2448b65ef | 836 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 837 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 838 | Command.Header.INS = C_APDU_CHANGE; |
EnricoG | 0:ffc2448b65ef | 839 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 840 | Command.Header.P1 = GETMSB (uPwdId ) ; |
EnricoG | 0:ffc2448b65ef | 841 | Command.Header.P2 = GETLSB (uPwdId ) ; |
EnricoG | 0:ffc2448b65ef | 842 | /* copy the number of byte of the data field */ |
EnricoG | 0:ffc2448b65ef | 843 | Command.Body.LC = M24SR_PASSWORD_NBBYTE ; |
EnricoG | 0:ffc2448b65ef | 844 | /* copy the password */ |
EnricoG | 0:ffc2448b65ef | 845 | memcpy(Command.Body.pData, pPwd, M24SR_PASSWORD_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 846 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 847 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_CHANGEREFDATA, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 848 | |
EnricoG | 0:ffc2448b65ef | 849 | |
EnricoG | 0:ffc2448b65ef | 850 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 851 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 852 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 853 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 854 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 855 | |
EnricoG | 0:ffc2448b65ef | 856 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 857 | return status; |
EnricoG | 0:ffc2448b65ef | 858 | |
EnricoG | 0:ffc2448b65ef | 859 | Error : |
EnricoG | 0:ffc2448b65ef | 860 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 861 | } |
EnricoG | 0:ffc2448b65ef | 862 | |
EnricoG | 0:ffc2448b65ef | 863 | |
EnricoG | 0:ffc2448b65ef | 864 | /** |
EnricoG | 0:ffc2448b65ef | 865 | * @brief This function sends the EnableVerificationRequirement command |
EnricoG | 0:ffc2448b65ef | 866 | * @param uReadOrWrite : enable the read or write protection ( 0x0001 : Read or 0x0002 : Write ) |
EnricoG | 0:ffc2448b65ef | 867 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 868 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 869 | */ |
EnricoG | 0:ffc2448b65ef | 870 | uint16_t M24SR_EnableVerificationRequirement ( uc16 uReadOrWrite ) |
EnricoG | 0:ffc2448b65ef | 871 | { |
EnricoG | 0:ffc2448b65ef | 872 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 873 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 874 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 875 | |
EnricoG | 0:ffc2448b65ef | 876 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 877 | if ( (uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) |
EnricoG | 0:ffc2448b65ef | 878 | { |
EnricoG | 0:ffc2448b65ef | 879 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 880 | } |
EnricoG | 0:ffc2448b65ef | 881 | |
EnricoG | 0:ffc2448b65ef | 882 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 883 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 884 | Command.Header.INS = C_APDU_ENABLE; |
EnricoG | 0:ffc2448b65ef | 885 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 886 | Command.Header.P1 = GETMSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 887 | Command.Header.P2 = GETLSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 888 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 889 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_ENABLEVERIFREQ, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 890 | |
EnricoG | 0:ffc2448b65ef | 891 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 892 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 893 | /* The right access to be updated in EEPROM need at least 6ms */ |
EnricoG | 0:ffc2448b65ef | 894 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 895 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 896 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 897 | |
EnricoG | 0:ffc2448b65ef | 898 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 899 | return status; |
EnricoG | 0:ffc2448b65ef | 900 | |
EnricoG | 0:ffc2448b65ef | 901 | Error : |
EnricoG | 0:ffc2448b65ef | 902 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 903 | } |
EnricoG | 0:ffc2448b65ef | 904 | |
EnricoG | 0:ffc2448b65ef | 905 | /** |
EnricoG | 0:ffc2448b65ef | 906 | * @brief This function sends the DisableVerificationRequirement command |
EnricoG | 0:ffc2448b65ef | 907 | * @param uReadOrWrite : enable the read or write protection ( 0x0001 : Read or 0x0002 : Write ) |
EnricoG | 0:ffc2448b65ef | 908 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 909 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 910 | */ |
EnricoG | 0:ffc2448b65ef | 911 | uint16_t M24SR_DisableVerificationRequirement ( uc16 uReadOrWrite ) |
EnricoG | 0:ffc2448b65ef | 912 | { |
EnricoG | 0:ffc2448b65ef | 913 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 914 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 915 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 916 | |
EnricoG | 0:ffc2448b65ef | 917 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 918 | if ( (uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) |
EnricoG | 0:ffc2448b65ef | 919 | { |
EnricoG | 0:ffc2448b65ef | 920 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 921 | } |
EnricoG | 0:ffc2448b65ef | 922 | |
EnricoG | 0:ffc2448b65ef | 923 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 924 | Command.Header.CLA = C_APDU_CLA_DEFAULT; |
EnricoG | 0:ffc2448b65ef | 925 | Command.Header.INS = C_APDU_DISABLE; |
EnricoG | 0:ffc2448b65ef | 926 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 927 | Command.Header.P1 = GETMSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 928 | Command.Header.P2 = GETLSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 929 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 930 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_DISABLEVERIFREQ, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 931 | |
EnricoG | 0:ffc2448b65ef | 932 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 933 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 934 | /* The right access to be updated in EEPROM need at least 6ms */ |
EnricoG | 0:ffc2448b65ef | 935 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 936 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 937 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 938 | |
EnricoG | 0:ffc2448b65ef | 939 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 940 | return status; |
EnricoG | 0:ffc2448b65ef | 941 | |
EnricoG | 0:ffc2448b65ef | 942 | Error : |
EnricoG | 0:ffc2448b65ef | 943 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 944 | } |
EnricoG | 0:ffc2448b65ef | 945 | |
EnricoG | 0:ffc2448b65ef | 946 | /** |
EnricoG | 0:ffc2448b65ef | 947 | * @brief This function sends the EnablePermananentState command |
EnricoG | 0:ffc2448b65ef | 948 | * @param uReadOrWrite : enable the read or write protection ( 0x0001 : Read or 0x0002 : Write ) |
EnricoG | 0:ffc2448b65ef | 949 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 950 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 951 | */ |
EnricoG | 0:ffc2448b65ef | 952 | uint16_t M24SR_EnablePermanentState ( uc16 uReadOrWrite ) |
EnricoG | 0:ffc2448b65ef | 953 | { |
EnricoG | 0:ffc2448b65ef | 954 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 955 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 956 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 957 | |
EnricoG | 0:ffc2448b65ef | 958 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 959 | if ( (uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) |
EnricoG | 0:ffc2448b65ef | 960 | { |
EnricoG | 0:ffc2448b65ef | 961 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 962 | } |
EnricoG | 0:ffc2448b65ef | 963 | |
EnricoG | 0:ffc2448b65ef | 964 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 965 | Command.Header.CLA = C_APDU_CLA_ST; |
EnricoG | 0:ffc2448b65ef | 966 | Command.Header.INS = C_APDU_ENABLE; |
EnricoG | 0:ffc2448b65ef | 967 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 968 | Command.Header.P1 = GETMSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 969 | Command.Header.P2 = GETLSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 970 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 971 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_ENABLEVERIFREQ, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 972 | |
EnricoG | 0:ffc2448b65ef | 973 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 974 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 975 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 976 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 977 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 978 | |
EnricoG | 0:ffc2448b65ef | 979 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 980 | return status; |
EnricoG | 0:ffc2448b65ef | 981 | |
EnricoG | 0:ffc2448b65ef | 982 | Error : |
EnricoG | 0:ffc2448b65ef | 983 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 984 | } |
EnricoG | 0:ffc2448b65ef | 985 | |
EnricoG | 0:ffc2448b65ef | 986 | /** |
EnricoG | 0:ffc2448b65ef | 987 | * @brief This function sends the DisablePermanentState command |
EnricoG | 0:ffc2448b65ef | 988 | * @param uReadOrWrite : enable the read or write protection ( 0x0001 : Read or 0x0002 : Write ) |
EnricoG | 0:ffc2448b65ef | 989 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 990 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 991 | */ |
EnricoG | 0:ffc2448b65ef | 992 | uint16_t M24SR_DisablePermanentState ( uc16 uReadOrWrite ) |
EnricoG | 0:ffc2448b65ef | 993 | { |
EnricoG | 0:ffc2448b65ef | 994 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 995 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 996 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 997 | |
EnricoG | 0:ffc2448b65ef | 998 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 999 | if ( (uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) |
EnricoG | 0:ffc2448b65ef | 1000 | { |
EnricoG | 0:ffc2448b65ef | 1001 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 1002 | } |
EnricoG | 0:ffc2448b65ef | 1003 | |
EnricoG | 0:ffc2448b65ef | 1004 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 1005 | Command.Header.CLA = C_APDU_CLA_ST; |
EnricoG | 0:ffc2448b65ef | 1006 | Command.Header.INS = C_APDU_DISABLE; |
EnricoG | 0:ffc2448b65ef | 1007 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 1008 | Command.Header.P1 = GETMSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 1009 | Command.Header.P2 = GETLSB (uReadOrWrite ) ; |
EnricoG | 0:ffc2448b65ef | 1010 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 1011 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_DISABLEVERIFREQ, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 1012 | |
EnricoG | 0:ffc2448b65ef | 1013 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 1014 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1015 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 1016 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 1017 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1018 | |
EnricoG | 0:ffc2448b65ef | 1019 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 1020 | return status; |
EnricoG | 0:ffc2448b65ef | 1021 | |
EnricoG | 0:ffc2448b65ef | 1022 | Error : |
EnricoG | 0:ffc2448b65ef | 1023 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 1024 | } |
EnricoG | 0:ffc2448b65ef | 1025 | |
EnricoG | 0:ffc2448b65ef | 1026 | /** |
EnricoG | 0:ffc2448b65ef | 1027 | * @brief This function generates a interrupt on GPO pin |
EnricoG | 0:ffc2448b65ef | 1028 | * @param None |
EnricoG | 0:ffc2448b65ef | 1029 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 1030 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 1031 | */ |
EnricoG | 0:ffc2448b65ef | 1032 | uint16_t M24SR_SendInterrupt ( void ) |
EnricoG | 0:ffc2448b65ef | 1033 | { |
EnricoG | 0:ffc2448b65ef | 1034 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 1035 | uint16_t uP1P2 =0x001E; |
EnricoG | 0:ffc2448b65ef | 1036 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 1037 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 1038 | |
EnricoG | 0:ffc2448b65ef | 1039 | status = M24SR_ManageI2CGPO( INTERRUPT); |
EnricoG | 0:ffc2448b65ef | 1040 | |
EnricoG | 0:ffc2448b65ef | 1041 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 1042 | Command.Header.CLA = C_APDU_CLA_ST; |
EnricoG | 0:ffc2448b65ef | 1043 | Command.Header.INS = C_APDU_INTERRUPT; |
EnricoG | 0:ffc2448b65ef | 1044 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 1045 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 1046 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 1047 | Command.Body.LC = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 1048 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 1049 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_SENDINTERRUPT, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 1050 | |
EnricoG | 0:ffc2448b65ef | 1051 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 1052 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1053 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 1054 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 1055 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1056 | |
EnricoG | 0:ffc2448b65ef | 1057 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 1058 | return status; |
EnricoG | 0:ffc2448b65ef | 1059 | |
EnricoG | 0:ffc2448b65ef | 1060 | Error : |
EnricoG | 0:ffc2448b65ef | 1061 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 1062 | } |
EnricoG | 0:ffc2448b65ef | 1063 | |
EnricoG | 0:ffc2448b65ef | 1064 | /** |
EnricoG | 0:ffc2448b65ef | 1065 | * @brief This function force GPO pin to low state or high Z |
EnricoG | 0:ffc2448b65ef | 1066 | * @param uSetOrReset : select if GPO must be low (reset) or HiZ |
EnricoG | 0:ffc2448b65ef | 1067 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 1068 | * @retval M24SR_ERROR_I2CTIMEOUT : The I2C timeout occured. |
EnricoG | 0:ffc2448b65ef | 1069 | */ |
EnricoG | 0:ffc2448b65ef | 1070 | uint16_t M24SR_StateControl ( uc8 uSetOrReset ) |
EnricoG | 0:ffc2448b65ef | 1071 | { |
EnricoG | 0:ffc2448b65ef | 1072 | uint8_t *pBuffer = uM24SRbuffer; |
EnricoG | 0:ffc2448b65ef | 1073 | uint16_t uP1P2 =0x001F; |
EnricoG | 0:ffc2448b65ef | 1074 | uint16_t status ; |
EnricoG | 0:ffc2448b65ef | 1075 | uint16_t NbByte; |
EnricoG | 0:ffc2448b65ef | 1076 | |
EnricoG | 0:ffc2448b65ef | 1077 | /*check the parameters */ |
EnricoG | 0:ffc2448b65ef | 1078 | if ( (uSetOrReset != 0x01) && (uSetOrReset != 0x00)) |
EnricoG | 0:ffc2448b65ef | 1079 | { |
EnricoG | 0:ffc2448b65ef | 1080 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 1081 | } |
EnricoG | 0:ffc2448b65ef | 1082 | |
EnricoG | 0:ffc2448b65ef | 1083 | status = M24SR_ManageI2CGPO( STATE_CONTROL); |
EnricoG | 0:ffc2448b65ef | 1084 | |
EnricoG | 0:ffc2448b65ef | 1085 | /* build the command */ |
EnricoG | 0:ffc2448b65ef | 1086 | Command.Header.CLA = C_APDU_CLA_ST; |
EnricoG | 0:ffc2448b65ef | 1087 | Command.Header.INS = C_APDU_INTERRUPT; |
EnricoG | 0:ffc2448b65ef | 1088 | /* copy the Password Id */ |
EnricoG | 0:ffc2448b65ef | 1089 | Command.Header.P1 = GETMSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 1090 | Command.Header.P2 = GETLSB (uP1P2 ) ; |
EnricoG | 0:ffc2448b65ef | 1091 | Command.Body.LC = 0x01 ; |
EnricoG | 0:ffc2448b65ef | 1092 | /* copy the data */ |
EnricoG | 0:ffc2448b65ef | 1093 | memcpy(Command.Body.pData , &uSetOrReset, 0x01 ); |
EnricoG | 0:ffc2448b65ef | 1094 | //Command.Body.LE = 0x00 ; |
EnricoG | 0:ffc2448b65ef | 1095 | /* build the IC command */ |
EnricoG | 0:ffc2448b65ef | 1096 | M24SR_BuildIBlockCommand ( M24SR_CMDSTRUCT_GPOSTATE, Command, &NbByte , pBuffer); |
EnricoG | 0:ffc2448b65ef | 1097 | |
EnricoG | 0:ffc2448b65ef | 1098 | /* send the request */ |
EnricoG | 0:ffc2448b65ef | 1099 | errchk( M24SR_SendI2Ccommand ( NbByte , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1100 | errchk( M24SR_IsAnswerReady ( )); |
EnricoG | 0:ffc2448b65ef | 1101 | /* read the response */ |
EnricoG | 0:ffc2448b65ef | 1102 | errchk( M24SR_ReceiveI2Cresponse ( M24SR_STATUSRESPONSE_NBBYTE , pBuffer )); |
EnricoG | 0:ffc2448b65ef | 1103 | |
EnricoG | 0:ffc2448b65ef | 1104 | status = M24SR_IsCorrectCRC16Residue (pBuffer, M24SR_STATUSRESPONSE_NBBYTE); |
EnricoG | 0:ffc2448b65ef | 1105 | return status; |
EnricoG | 0:ffc2448b65ef | 1106 | |
EnricoG | 0:ffc2448b65ef | 1107 | Error : |
EnricoG | 0:ffc2448b65ef | 1108 | return M24SR_ERROR_I2CTIMEOUT; |
EnricoG | 0:ffc2448b65ef | 1109 | } |
EnricoG | 0:ffc2448b65ef | 1110 | |
EnricoG | 0:ffc2448b65ef | 1111 | /** |
EnricoG | 0:ffc2448b65ef | 1112 | * @brief This function configure GPO purpose for I2C session |
EnricoG | 0:ffc2448b65ef | 1113 | * @param GPO_I2Cconfig: GPO configuration to set |
EnricoG | 0:ffc2448b65ef | 1114 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 1115 | */ |
EnricoG | 0:ffc2448b65ef | 1116 | uint16_t M24SR_ManageI2CGPO( uc8 GPO_I2Cconfig) |
EnricoG | 0:ffc2448b65ef | 1117 | { |
EnricoG | 0:ffc2448b65ef | 1118 | uint16_t status; |
EnricoG | 0:ffc2448b65ef | 1119 | uint8_t GPO_config; |
EnricoG | 0:ffc2448b65ef | 1120 | uint8_t DefaultPassword[16]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
EnricoG | 0:ffc2448b65ef | 1121 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
EnricoG | 0:ffc2448b65ef | 1122 | |
EnricoG | 0:ffc2448b65ef | 1123 | if( GPO_I2Cconfig > STATE_CONTROL) |
EnricoG | 0:ffc2448b65ef | 1124 | { |
EnricoG | 0:ffc2448b65ef | 1125 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 1126 | } |
EnricoG | 0:ffc2448b65ef | 1127 | |
EnricoG | 0:ffc2448b65ef | 1128 | /* we must not be in interrupt mode for I2C synchro as we will change GPO purpose */ |
EnricoG | 0:ffc2448b65ef | 1129 | M24SR_SetI2CSynchroMode(M24SR_WAITINGTIME_POLLING); |
EnricoG | 0:ffc2448b65ef | 1130 | |
EnricoG | 0:ffc2448b65ef | 1131 | M24SR_SelectApplication(); |
EnricoG | 0:ffc2448b65ef | 1132 | M24SR_SelectSystemfile(); |
EnricoG | 0:ffc2448b65ef | 1133 | M24SR_ReadBinary ( 0x0004 , 0x01 , &GPO_config ); |
EnricoG | 0:ffc2448b65ef | 1134 | |
EnricoG | 0:ffc2448b65ef | 1135 | /* Update only GPO purpose for I2C */ |
EnricoG | 0:ffc2448b65ef | 1136 | GPO_config = (GPO_config & 0xF0) | GPO_I2Cconfig; |
EnricoG | 0:ffc2448b65ef | 1137 | M24SR_SelectSystemfile(); |
EnricoG | 0:ffc2448b65ef | 1138 | M24SR_Verify( I2C_PWD ,0x10 ,DefaultPassword ); |
EnricoG | 0:ffc2448b65ef | 1139 | status = M24SR_UpdateBinary ( 0x0004 ,0x01, &(GPO_config) ); |
EnricoG | 0:ffc2448b65ef | 1140 | |
EnricoG | 0:ffc2448b65ef | 1141 | /* if we have set interrupt mode for I2C synchro we can enable interrupt mode */ |
EnricoG | 0:ffc2448b65ef | 1142 | if ( GPO_I2Cconfig == I2C_ANSWER_READY && status == M24SR_ACTION_COMPLETED) |
EnricoG | 0:ffc2448b65ef | 1143 | #ifdef I2C_GPO_SYNCHRO_ALLOWED |
EnricoG | 0:ffc2448b65ef | 1144 | M24SR_SetI2CSynchroMode(M24SR_WAITINGTIME_GPO); |
EnricoG | 0:ffc2448b65ef | 1145 | #else |
EnricoG | 0:ffc2448b65ef | 1146 | M24SR_SetI2CSynchroMode(M24SR_INTERRUPT_GPO); |
EnricoG | 0:ffc2448b65ef | 1147 | #endif |
EnricoG | 0:ffc2448b65ef | 1148 | |
EnricoG | 0:ffc2448b65ef | 1149 | return status; |
EnricoG | 0:ffc2448b65ef | 1150 | } |
EnricoG | 0:ffc2448b65ef | 1151 | |
EnricoG | 0:ffc2448b65ef | 1152 | /** |
EnricoG | 0:ffc2448b65ef | 1153 | * @brief This function configure GPO purpose for RF session |
EnricoG | 0:ffc2448b65ef | 1154 | * @param GPO_RFconfig: GPO configuration to set |
EnricoG | 0:ffc2448b65ef | 1155 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 1156 | */ |
EnricoG | 0:ffc2448b65ef | 1157 | uint16_t M24SR_ManageRFGPO( uc8 GPO_RFconfig) |
EnricoG | 0:ffc2448b65ef | 1158 | { |
EnricoG | 0:ffc2448b65ef | 1159 | uint16_t status; |
EnricoG | 0:ffc2448b65ef | 1160 | uint8_t GPO_config; |
EnricoG | 0:ffc2448b65ef | 1161 | uint8_t DefaultPassword[16]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
EnricoG | 0:ffc2448b65ef | 1162 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
EnricoG | 0:ffc2448b65ef | 1163 | |
EnricoG | 0:ffc2448b65ef | 1164 | if( GPO_RFconfig > STATE_CONTROL) |
EnricoG | 0:ffc2448b65ef | 1165 | { |
EnricoG | 0:ffc2448b65ef | 1166 | return M24SR_ERROR_PARAMETER; |
EnricoG | 0:ffc2448b65ef | 1167 | } |
EnricoG | 0:ffc2448b65ef | 1168 | |
EnricoG | 0:ffc2448b65ef | 1169 | M24SR_SelectApplication(); |
EnricoG | 0:ffc2448b65ef | 1170 | M24SR_SelectSystemfile(); |
EnricoG | 0:ffc2448b65ef | 1171 | M24SR_ReadBinary ( 0x0004 , 0x01 , &GPO_config ); |
EnricoG | 0:ffc2448b65ef | 1172 | |
EnricoG | 0:ffc2448b65ef | 1173 | /* Update only GPO purpose for I2C */ |
EnricoG | 0:ffc2448b65ef | 1174 | GPO_config = (GPO_config & 0x0F) | (GPO_RFconfig<<4); |
EnricoG | 0:ffc2448b65ef | 1175 | M24SR_SelectSystemfile(); |
EnricoG | 0:ffc2448b65ef | 1176 | M24SR_Verify( I2C_PWD ,0x10 ,DefaultPassword ); |
EnricoG | 0:ffc2448b65ef | 1177 | status = M24SR_UpdateBinary ( 0x0004 ,0x01, &(GPO_config) ); |
EnricoG | 0:ffc2448b65ef | 1178 | |
EnricoG | 0:ffc2448b65ef | 1179 | return status; |
EnricoG | 0:ffc2448b65ef | 1180 | } |
EnricoG | 0:ffc2448b65ef | 1181 | |
EnricoG | 0:ffc2448b65ef | 1182 | |
EnricoG | 0:ffc2448b65ef | 1183 | /** |
EnricoG | 0:ffc2448b65ef | 1184 | * @brief This function enable or disable RF communication |
EnricoG | 0:ffc2448b65ef | 1185 | * @param OnOffChoice: GPO configuration to set |
EnricoG | 0:ffc2448b65ef | 1186 | * @retval Status (SW1&SW2) : Status of the operation to complete. |
EnricoG | 0:ffc2448b65ef | 1187 | */ |
EnricoG | 0:ffc2448b65ef | 1188 | void M24SR_RFConfig( uc8 OnOffChoice) |
EnricoG | 0:ffc2448b65ef | 1189 | { |
EnricoG | 0:ffc2448b65ef | 1190 | M24SR_RFConfig_Hard(OnOffChoice); |
EnricoG | 0:ffc2448b65ef | 1191 | } |
EnricoG | 0:ffc2448b65ef | 1192 | |
EnricoG | 0:ffc2448b65ef | 1193 | /** |
EnricoG | 0:ffc2448b65ef | 1194 | * @} |
EnricoG | 0:ffc2448b65ef | 1195 | */ |
EnricoG | 0:ffc2448b65ef | 1196 | |
EnricoG | 0:ffc2448b65ef | 1197 | /** |
EnricoG | 0:ffc2448b65ef | 1198 | * @} |
EnricoG | 0:ffc2448b65ef | 1199 | */ |
EnricoG | 0:ffc2448b65ef | 1200 | |
EnricoG | 0:ffc2448b65ef | 1201 | /** |
EnricoG | 0:ffc2448b65ef | 1202 | * @} |
EnricoG | 0:ffc2448b65ef | 1203 | */ |
EnricoG | 0:ffc2448b65ef | 1204 | |
EnricoG | 0:ffc2448b65ef | 1205 | /******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/ |