/** * @brief Write a buffer (many blocks) in the SD card. * @note The amount of data to write should be a multiple of SD card BLOCK * size (512 Byte). * @param pBuffer : pointer to the buffer containing the data to be written on the SD. * @param WriteAddr : address to write on. * @param NumByteToWrite : number of data to write. * @retval SD Response: * - SD_RESPONSE_FAILURE: Sequence failed. * - SD_RESPONSE_NO_ERROR: Sequence succeed. */ uint8_t SD_WriteBuffer(uint8_t *pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite) { uint32_t i = 0, NbrOfBlock = 0, Offset = 0; uint8_t rvalue = SD_RESPONSE_FAILURE; /* Calculate number of blocks to write */ NbrOfBlock = NumByteToWrite / SD_BLOCK_SIZE; /* SD chip select low */ SD_CS_LOW(); /* Data transfer */ while (NbrOfBlock--) { /* Send CMD24 (SD_WRITE_BLOCK) to write blocks */ SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset, 0xFF); /* Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */ if (SD_GetResponse(SD_RESPONSE_NO_ERROR)) { return SD_RESPONSE_FAILURE; } /* Send dummy byte */ SD_WriteByte(SD_DUMMY_BYTE); /* Send the data token to signify the start of the data */ SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE); /* Write the block data to SD : write count data by block */ for (i = 0; i < SD_BLOCK_SIZE; i++) { /* Send the pointed byte */ SD_WriteByte(*pBuffer); /* Point to the next location where the byte read will be saved */ pBuffer++; } /* Set next write address */ Offset += 512; /* Put CRC bytes (not really needed by us, but required by SD) */ SD_ReadByte(); SD_ReadByte(); /* Read data response */ if (SD_GetDataResponse() == SD_DATA_OK) { /* Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } else { /* Set response value to failure */ rvalue = SD_RESPONSE_FAILURE; } } /* SD chip select high */ SD_CS_HIGH(); /* Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /* Returns the response */ return rvalue; }
/** * @brief Reads multiple block of data from the SD. * @param pBuffer: pointer to the buffer that receives the data read from the * SD. * @param ReadAddr: SD's internal address to read from. * @param BlockSize: the SD card Data block size. * @param NumberOfBlocks: number of blocks to be read. * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks) { uint32_t i = 0, Offset = 0; SD_Error rvalue = SD_RESPONSE_FAILURE; /*!< SD chip select low */ SD_CS_LOW(); /*!< Data transfer */ while (NumberOfBlocks--) { if(flag_SDHC == 1) { /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */ SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK,(ReadAddr + Offset)/512, 0xFF); } else { /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */ SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset, 0xFF); } /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */ if (SD_GetResponse(SD_RESPONSE_NO_ERROR)) { return SD_RESPONSE_FAILURE; } /*!< Now look for the data token to signify the start of the data */ if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ)) { /*!< Read the SD block data : read NumByteToRead data */ for (i = 0; i < BlockSize; i++) { /*!< Read the pointed data */ *pBuffer = SD_ReadByte(); /*!< Point to the next location where the byte read will be saved */ pBuffer++; } /*!< Set next read address*/ Offset += 512; /*!< get CRC bytes (not really needed by us, but required by SD) */ SD_ReadByte(); SD_ReadByte(); /*!< Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } else { /*!< Set response value to failure */ rvalue = SD_RESPONSE_FAILURE; } } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Returns the reponse */ return rvalue; }
/** * @brief Writes a block on the SD * @param pBuffer: pointer to the buffer containing the data to be written on * the SD. * @param WriteAddr: address to write on. * @param BlockSize: the SD card Data block size. * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ uint8_t SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize) { uint32_t i = 0; uint8_t rvalue = SD_RESPONSE_FAILURE; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */ SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr, 0xFF); /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */ if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) { /*!< Send a dummy byte */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Send the data token to signify the start of the data */ SD_WriteByte(0xFE); /*!< Write the block data to SD : write count data by block */ for (i = 0; i < BlockSize; i++) { /*!< Send the pointed byte */ SD_WriteByte(*pBuffer); /*!< Point to the next location where the byte read will be saved */ pBuffer++; } /* Send DUMMY bytes when the number of data to be written are lower than the SD card BLOCK size (512 Byte) */ for (; i != SD_BLOCK_SIZE; i++) { /* Send the pointed byte */ SD_WriteByte(SD_DUMMY_BYTE); } /*!< Put CRC bytes (not really needed by us, but required by SD) */ SD_ReadByte(); SD_ReadByte(); /*!< Read data response */ if (SD_GetDataResponse() == SD_DATA_OK) { rvalue = SD_RESPONSE_NO_ERROR; } } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Returns the response */ return rvalue; }
// Read a 512 bytes sector on the SD Card // uiSector : Sector number // pbyReadData : pointer to a 512 bytes buffer that will be filled with secotr data if successful // return : true if data read successully, false otherwise int SD_Read(UINT32 uiSector, UINT8* pbyReadData) { int bSuccess = 1; UINT32 uiAddress = uiSector * 512; SD_Ncc(); // Send single read command SD_SendCommand(17, uiAddress); UINT8 uiResponse = SD_GetR1Response(); if (uiResponse != 0) { printf("SD Card read data failed. Error code : %02X\n", uiResponse); return 0; } // Wait for data token UINT8 uiDataToken = 0; int iNbTry = 0; while (uiDataToken != 0xFE && iNbTry < 2000) { uiDataToken = SD_ReadByte(); iNbTry++; } if (uiDataToken != 0xFE) { printf("SD Card read data timeout. Error code : %02X\n", uiDataToken); return 0; } // Read sector int i; for (i = 0; i < 512; i++) { pbyReadData[i] = SD_ReadByte(); } // Dummy read CRC SD_ReadByte(); SD_ReadByte(); return bSuccess; }
/** * @brief Reads a block of data from the SD. * @param pBuffer: pointer to the buffer that receives the data read from the * SD. * @param ReadAddr: SD's internal address to read from. * @param BlockSize: the SD card Data block size. * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ uint8_t SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize) { uint32_t i = 0; uint8_t rvalue = SD_RESPONSE_FAILURE; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */ SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr, 0xFF); /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */ if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) { /*!< Now look for the data token to signify the start of the data */ if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ)) { /*!< Read the SD block data : read NumByteToRead data */ for (i = 0; i < BlockSize; i++) { /*!< Save the received data */ *pBuffer = SD_ReadByte(); /*!< Point to the next location where the byte read will be saved */ pBuffer++; } /*!< Get CRC bytes (not really needed by us, but required by SD) */ SD_ReadByte(); SD_ReadByte(); /*!< Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Returns the response */ return rvalue; }
/** * @brief Get SD card data response. * @param None * @retval The SD status: Read data response xxx0<status>1 * - status 010: Data accecpted * - status 101: Data rejected due to a crc error * - status 110: Data rejected due to a Write error. * - status 111: Data rejected due to other error. */ uint8_t SD_GetDataResponse(void) { uint32_t i = 0; uint8_t response, rvalue; while (i <= 64) { /*!< Read resonse */ response = SD_ReadByte(); /*!< Mask unused bits */ response &= 0x1F; switch (response) { case SD_DATA_OK: { rvalue = SD_DATA_OK; break; } case SD_DATA_CRC_ERROR: return SD_DATA_CRC_ERROR; case SD_DATA_WRITE_ERROR: return SD_DATA_WRITE_ERROR; default: { rvalue = SD_DATA_OTHER_ERROR; break; } } /*!< Exit loop in case of data ok */ if (rvalue == SD_DATA_OK) break; /*!< Increment loop counter */ i++; } /*!< Wait null data */ while (SD_ReadByte() == 0); /*!< Return response */ return response; }
/** * @brief Returns the SD status. * @param None * @retval The SD status. */ uint16_t SD_GetStatus(void) { uint16_t Status = 0; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD13 (SD_SEND_STATUS) to get SD status */ SD_SendCmd(SD_CMD_SEND_STATUS, 0, 0xFF); Status = SD_ReadByte(); Status |= (uint16_t)(SD_ReadByte() << 8); /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte 0xFF */ SD_WriteByte(SD_DUMMY_BYTE); return Status; }
// Get R1 response from command sent to SD Card // return : Response in R1 format UINT8 SD_GetR1Response() { UINT8 uiR1 = 0xff; int iNbTry = 0; while ((uiR1 & 0x80) && iNbTry < 8) { uiR1 = SD_ReadByte(); iNbTry++; } return uiR1; }
/** * @brief Returns the SD response. * @param None * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_GetResponse(uint8_t Response) { uint32_t Count = 0xFFF; /*!< Check if response is got or a timeout is happen */ while ((SD_ReadByte() != Response) && Count) { Count--; } if (Count == 0) { /*!< After time out */ return SD_RESPONSE_FAILURE; } else { /*!< Right response got */ return SD_RESPONSE_NO_ERROR; } }
/** * @brief Read the CID card register. * Reading the contents of the CID register in SPI mode is a simple * read-block transaction. * @param SD_cid: pointer on an CID register structure * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_GetCIDRegister(SD_CID* SD_cid) { uint32_t i = 0; SD_Error rvalue = SD_RESPONSE_FAILURE; uint8_t CID_Tab[16]; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD10 (CID register) */ SD_SendCmd(SD_CMD_SEND_CID, 0, 0xFF); /*!< Wait for response in the R1 format (0x00 is no errors) */ if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) { if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ)) { /*!< Store CID register value on CID_Tab */ for (i = 0; i < 16; i++) { CID_Tab[i] = SD_ReadByte(); } } /*!< Get CRC bytes (not really needed by us, but required by SD) */ SD_WriteByte(SD_DUMMY_BYTE); SD_WriteByte(SD_DUMMY_BYTE); /*!< Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Byte 0 */ SD_cid->ManufacturerID = CID_Tab[0]; /*!< Byte 1 */ SD_cid->OEM_AppliID = CID_Tab[1] << 8; /*!< Byte 2 */ SD_cid->OEM_AppliID |= CID_Tab[2]; /*!< Byte 3 */ SD_cid->ProdName1 = CID_Tab[3] << 24; /*!< Byte 4 */ SD_cid->ProdName1 |= CID_Tab[4] << 16; /*!< Byte 5 */ SD_cid->ProdName1 |= CID_Tab[5] << 8; /*!< Byte 6 */ SD_cid->ProdName1 |= CID_Tab[6]; /*!< Byte 7 */ SD_cid->ProdName2 = CID_Tab[7]; /*!< Byte 8 */ SD_cid->ProdRev = CID_Tab[8]; /*!< Byte 9 */ SD_cid->ProdSN = CID_Tab[9] << 24; /*!< Byte 10 */ SD_cid->ProdSN |= CID_Tab[10] << 16; /*!< Byte 11 */ SD_cid->ProdSN |= CID_Tab[11] << 8; /*!< Byte 12 */ SD_cid->ProdSN |= CID_Tab[12]; /*!< Byte 13 */ SD_cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4; SD_cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8; /*!< Byte 14 */ SD_cid->ManufactDate |= CID_Tab[14]; /*!< Byte 15 */ SD_cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1; SD_cid->Reserved2 = 1; /*!< Return the reponse */ return rvalue; }
/** * @brief Read the CSD card register. * Reading the contents of the CSD register in SPI mode is a simple * read-block transaction. * @param SD_csd: pointer on an SCD register structure * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_GetCSDRegister(SD_CSD* SD_csd) { uint32_t i = 0; SD_Error rvalue = SD_RESPONSE_FAILURE; uint8_t CSD_Tab[16]; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD9 (CSD register) or CMD10(CSD register) */ SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF); /*!< Wait for response in the R1 format (0x00 is no errors) */ if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) { if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ)) { for (i = 0; i < 16; i++) { /*!< Store CSD register value on CSD_Tab */ CSD_Tab[i] = SD_ReadByte(); } } /*!< Get CRC bytes (not really needed by us, but required by SD) */ SD_WriteByte(SD_DUMMY_BYTE); SD_WriteByte(SD_DUMMY_BYTE); /*!< Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Byte 0 */ SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6; SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2; SD_csd->Reserved1 = CSD_Tab[0] & 0x03; /*!< Byte 1 */ SD_csd->TAAC = CSD_Tab[1]; /*!< Byte 2 */ SD_csd->NSAC = CSD_Tab[2]; /*!< Byte 3 */ SD_csd->MaxBusClkFrec = CSD_Tab[3]; /*!< Byte 4 */ SD_csd->CardComdClasses = CSD_Tab[4] << 4; /*!< Byte 5 */ SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4; SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F; /*!< Byte 6 */ SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7; SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6; SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5; SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4; SD_csd->Reserved2 = 0; /*!< Reserved */ SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10; /*!< Byte 7 */ SD_csd->DeviceSize |= (CSD_Tab[7]) << 2; /*!< Byte 8 */ SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6; SD_csd->MaxRdCurrentVDDMin = (CSD_Tab[8] & 0x38) >> 3; SD_csd->MaxRdCurrentVDDMax = (CSD_Tab[8] & 0x07); /*!< Byte 9 */ SD_csd->MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5; SD_csd->MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2; SD_csd->DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1; /*!< Byte 10 */ SD_csd->DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7; SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6; SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1; /*!< Byte 11 */ SD_csd->EraseGrMul |= (CSD_Tab[11] & 0x80) >> 7; SD_csd->WrProtectGrSize = (CSD_Tab[11] & 0x7F); /*!< Byte 12 */ SD_csd->WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7; SD_csd->ManDeflECC = (CSD_Tab[12] & 0x60) >> 5; SD_csd->WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2; SD_csd->MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2; /*!< Byte 13 */ SD_csd->MaxWrBlockLen |= (CSD_Tab[13] & 0xC0) >> 6; SD_csd->WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5; SD_csd->Reserved3 = 0; SD_csd->ContentProtectAppli = (CSD_Tab[13] & 0x01); /*!< Byte 14 */ SD_csd->FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7; SD_csd->CopyFlag = (CSD_Tab[14] & 0x40) >> 6; SD_csd->PermWrProtect = (CSD_Tab[14] & 0x20) >> 5; SD_csd->TempWrProtect = (CSD_Tab[14] & 0x10) >> 4; SD_csd->FileFormat = (CSD_Tab[14] & 0x0C) >> 2; SD_csd->ECC = (CSD_Tab[14] & 0x03); /*!< Byte 15 */ SD_csd->CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1; SD_csd->Reserved4 = 1; /*!< Return the reponse */ return rvalue; }
/** * @brief Read the CSD card register. * Reading the contents of the CSD register in SPI mode is a simple * read-block transaction. * @param SD_csd: pointer on an SCD register structure * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_GetCSDRegister(SD_CSD* SD_csd) { uint32_t i = 0; SD_Error rvalue = SD_RESPONSE_FAILURE; uint8_t CSD_Tab[16]; uint32_t CardCapacity; static uint32_t times = 0; /*!< SD chip select low */ SD_CS_LOW(); /*!< Send CMD9 (CSD register) or CMD10(CSD register) */ SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF); /*!< Wait for response in the R1 format (0x00 is no errors) */ if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) { if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ)) { for (i = 0; i < 16; i++) { /*!< Store CSD register value on CSD_Tab */ CSD_Tab[i] = SD_ReadByte(); //if(0 == times) //{ // printf("\n\r CSD_Tab[%d] 0x%X", i, CSD_Tab[i]); //} } } /*!< Get CRC bytes (not really needed by us, but required by SD) */ SD_WriteByte(SD_DUMMY_BYTE); SD_WriteByte(SD_DUMMY_BYTE); /*!< Set response value to success */ rvalue = SD_RESPONSE_NO_ERROR; } else { return rvalue; } /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte: 8 Clock pulses of delay */ SD_WriteByte(SD_DUMMY_BYTE); /*!< Byte 0 */ SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6; SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2; SD_csd->Reserved1 = CSD_Tab[0] & 0x03; if(0 == times) { if(SD_csd->CSDStruct == 1) { //printf("\n\r SDHC CSD Version 2.0 Acess AS SD High Capacity."); flag_SDHC = 1; } else { //printf("\n\r SDSC CSD Version 1.0 Acess AS SD Standard Capacity."); flag_SDHC = 0; } } /*!< Byte 1 */ SD_csd->TAAC = CSD_Tab[1]; /*!< Byte 2 */ SD_csd->NSAC = CSD_Tab[2]; /*!< Byte 3 */ SD_csd->MaxBusClkFrec = CSD_Tab[3]; /*!< Byte 4 */ SD_csd->CardComdClasses = CSD_Tab[4] << 4; /*!< Byte 5 */ SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4; SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F; /*!< Byte 6 */ SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7; SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6; SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5; SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4; SD_csd->Reserved2 = 0; /*!< Reserved */ if(flag_SDHC == 0) { SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10; /*!< Byte 7 */ SD_csd->DeviceSize |= (CSD_Tab[7]) << 2; /*!< Byte 8 */ SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6; }