mirror of
https://github.com/tinygo-org/drivers.git
synced 2026-07-26 10:38:41 +00:00
sago35
107 lines
4.8 KiB
Go
107 lines
4.8 KiB
Go
package sdcard
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
type CSD struct {
|
|
CSD_STRUCTURE byte // 2 R [127:126] 0x01 : CSD Structure
|
|
TAAC byte // 8 R [119:112] 0x0E : Data Read Access-Time-1
|
|
NSAC byte // 8 R [111:104] 0x00 : Data Read Access-Time-2 in CLK Cycles (NSAC*100)
|
|
TRAN_SPEED byte // 8 R [103:96] 0x5A : Max. Data Transfer Rate
|
|
CCC uint16 // 12 R [95:84] 0x5B5 : Card Command Classes
|
|
READ_BL_LEN byte // 4 R [83:80] 0x09 : Max. Read Data Block Length
|
|
READ_BL_PARTIAL byte // 1 R [79:79] 0x00 : Partial Blocks for Read Allowed
|
|
WRITE_BLK_MISALIGN byte // 1 R [78:78] 0x00 : Write Block Misalignment
|
|
READ_BLK_MISALIGN byte // 1 R [77:77] 0x00 : Read Block Misalignment
|
|
DSR_IMP byte // 1 R [76:76] 0x00 : DSR Implemented
|
|
C_SIZE uint32 // 22 R [69:48] 0xXXXXXX : Device Size
|
|
ERASE_BLK_EN byte // 1 R [46:46] 0x01 : Erase Single Block Enable
|
|
SECTOR_SIZE byte // 7 R [45:39] 0x7F : Erase Sector Size
|
|
WP_GRP_SIZE byte // 7 R [38:32] 0x00 : Write Protect Group Size
|
|
WP_GRP_ENABLE byte // 1 R [31:31] 0x00 : Write Protect Group Enable
|
|
R2W_FACTOR byte // 3 R [28:26] 0x02 : Write Speed Factor
|
|
WRITE_BL_LEN byte // 4 R [25:22] 0x09 : Max. Write data Block Length
|
|
WRITE_BL_PARTIAL byte // 1 R [21:21] 0x00 : Partial Blocks for Write Allowed
|
|
FILE_FORMAT_GRP byte // 1 R [15:15] 0x00 : File Format Group
|
|
COPY byte // 1 RW [14:14] 0x00 :Copy Flag
|
|
PERM_WRITE_PROTECT byte // 1 RW [13:13] 0x00 : Permanent Write Protection
|
|
TMP_WRITE_PROTECT byte // 1 RW [12:12] 0x00 : Temporary Write Protection
|
|
FILE_FORMAT byte // 2 R [11:10] 0x00 : File Format
|
|
CRC byte // 7 RW [7:1] 0xXX : CRC
|
|
}
|
|
|
|
func NewCSD(buf []byte) *CSD {
|
|
return &CSD{
|
|
CSD_STRUCTURE: (buf[0] & 0xC0) >> 6,
|
|
TAAC: buf[1],
|
|
NSAC: buf[2],
|
|
TRAN_SPEED: buf[3],
|
|
CCC: uint16(buf[4])<<4 | uint16(buf[5])>>4,
|
|
READ_BL_LEN: buf[5] & 0x0F,
|
|
READ_BL_PARTIAL: (buf[6] & 0x80) >> 7,
|
|
WRITE_BLK_MISALIGN: (buf[6] & 0x40) >> 6,
|
|
READ_BLK_MISALIGN: (buf[6] & 0x20) >> 5,
|
|
DSR_IMP: (buf[6] & 0x10) >> 4,
|
|
C_SIZE: uint32(buf[7]&0x3F)<<16 | uint32(buf[8])<<8 | uint32(buf[9]),
|
|
ERASE_BLK_EN: (buf[10] & 0x40) >> 6,
|
|
SECTOR_SIZE: (buf[10]&0x3F)<<1 | (buf[11]&0x80)>>7,
|
|
WP_GRP_SIZE: buf[11] & 0x7F,
|
|
WP_GRP_ENABLE: (buf[12] & 0x80) >> 7,
|
|
R2W_FACTOR: (buf[12] & 0x1C) >> 2,
|
|
WRITE_BL_LEN: (buf[12]&0x03)<<2 | (buf[13]&0xC0)>>6,
|
|
WRITE_BL_PARTIAL: (buf[13] & 0x20) >> 5,
|
|
FILE_FORMAT_GRP: (buf[14] & 0x80) >> 7,
|
|
COPY: (buf[14] & 0x40) >> 6,
|
|
PERM_WRITE_PROTECT: (buf[14] & 0x20) >> 5,
|
|
TMP_WRITE_PROTECT: (buf[14] & 0x10) >> 4,
|
|
FILE_FORMAT: (buf[14] & 0x0C) >> 2,
|
|
CRC: (buf[15] & 0xFE) >> 1,
|
|
}
|
|
}
|
|
|
|
func (c *CSD) Dump() {
|
|
fmt.Printf("CSD_STRUCTURE: %X\r\n", c.CSD_STRUCTURE)
|
|
fmt.Printf("TAAC: %X\r\n", c.TAAC)
|
|
fmt.Printf("NSAC: %X\r\n", c.NSAC)
|
|
fmt.Printf("TRAN_SPEED: %X\r\n", c.TRAN_SPEED)
|
|
fmt.Printf("CCC: %X\r\n", c.CCC)
|
|
fmt.Printf("READ_BL_LEN: %X\r\n", c.READ_BL_LEN)
|
|
fmt.Printf("READ_BL_PARTIAL: %X\r\n", c.READ_BL_PARTIAL)
|
|
fmt.Printf("WRITE_BLK_MISALIGN: %X\r\n", c.WRITE_BLK_MISALIGN)
|
|
fmt.Printf("READ_BLK_MISALIGN: %X\r\n", c.READ_BLK_MISALIGN)
|
|
fmt.Printf("DSR_IMP: %X\r\n", c.DSR_IMP)
|
|
fmt.Printf("C_SIZE: %X\r\n", c.C_SIZE)
|
|
fmt.Printf("ERASE_BLK_EN: %X\r\n", c.ERASE_BLK_EN)
|
|
fmt.Printf("SECTOR_SIZE: %X\r\n", c.SECTOR_SIZE)
|
|
fmt.Printf("WP_GRP_SIZE: %X\r\n", c.WP_GRP_SIZE)
|
|
fmt.Printf("WP_GRP_ENABLE: %X\r\n", c.WP_GRP_ENABLE)
|
|
fmt.Printf("R2W_FACTOR: %X\r\n", c.R2W_FACTOR)
|
|
fmt.Printf("WRITE_BL_LEN: %X\r\n", c.WRITE_BL_LEN)
|
|
fmt.Printf("WRITE_BL_PARTIAL: %X\r\n", c.WRITE_BL_PARTIAL)
|
|
fmt.Printf("FILE_FORMAT_GRP: %X\r\n", c.FILE_FORMAT_GRP)
|
|
fmt.Printf("COPY: %X\r\n", c.COPY)
|
|
fmt.Printf("PERM_WRITE_PROTECT: %X\r\n", c.PERM_WRITE_PROTECT)
|
|
fmt.Printf("TMP_WRITE_PROTECT: %X\r\n", c.TMP_WRITE_PROTECT)
|
|
fmt.Printf("FILE_FORMAT: %X\r\n", c.FILE_FORMAT)
|
|
fmt.Printf("CRC: %X\r\n", c.CRC)
|
|
}
|
|
|
|
func (c *CSD) Sectors() (int64, error) {
|
|
sectors := int64(0)
|
|
if c.CSD_STRUCTURE == 0x01 {
|
|
// CSD version 2.0
|
|
sectors = (int64(c.C_SIZE) + 1) * 1024
|
|
} else if c.CSD_STRUCTURE == 0x00 {
|
|
// CSD version 1.0 (old, <=2GB)
|
|
return 0, fmt.Errorf("CSD format version 1.0 is not supported")
|
|
} else {
|
|
return 0, fmt.Errorf("unknown CSD format")
|
|
}
|
|
return sectors, nil
|
|
}
|
|
|
|
func (c *CSD) Size() uint64 {
|
|
return uint64(c.C_SIZE) * 512 * 1024
|
|
}
|