forked from tinygo-org/drivers
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcsd.go
106 lines (100 loc) · 4.79 KB
/
csd.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
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
}