rockfile 0.1.2

Rockchip specific file parsers
Documentation 
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

use bytes::Buf;

pub type RkTimeBytes = [u8; 7];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RkTime {
    year: u16,
    month: u8,
    day: u8,
    hour: u8,
    minute: u8,
    second: u8,
}

impl RkTime {
    pub fn from_bytes(bytes: &RkTimeBytes) -> RkTime {
        let mut bytes = &bytes[..];
        let year = bytes.get_u16_le();
        let month = bytes.get_u8();
        let day = bytes.get_u8();
        let hour = bytes.get_u8();
        let minute = bytes.get_u8();
        let second = bytes.get_u8();
        RkTime {
            year,
            month,
            day,
            hour,
            minute,
            second,
        }
    }
}

pub type RkBootHeaderEntryBytes = [u8; 6];
/// Entry in the boot header
///
/// Each boot header entry contains the count of [RkBootEntry]'s that are continous at the given
/// offset in the boot file.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RkBootHeaderEntry {
    pub count: u8,
    pub offset: u32,
    pub size: u8,
}
impl RkBootHeaderEntry {
    pub fn from_bytes(bytes: &RkBootHeaderEntryBytes) -> RkBootHeaderEntry {
        let mut bytes = &bytes[..];

        let count = bytes.get_u8();
        let offset = bytes.get_u32_le();
        let size = bytes.get_u8();

        RkBootHeaderEntry {
            count,
            offset,
            size,
        }
    }
}

pub type RkBootEntryBytes = [u8; 57];
/// Boot entry describing each data blob. data_offset and data_size define the range in the
/// boot file. After uploading the blob to SoC a delay of data_delay miliseconds should be
/// observed before uploading the next blob
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RkBootEntry {
    /// size of this entry
    pub size: u8,
    pub type_: u32,
    /// UTF-16 name
    pub name: [u16; 20],
    /// Offset of data in the boot file
    pub data_offset: u32,
    /// Size of data in the boot file
    pub data_size: u32,
    /// Delay to observe after uploading to SoC
    pub data_delay: u32,
}

impl RkBootEntry {
    pub fn from_bytes(bytes: &RkBootEntryBytes) -> RkBootEntry {
        let mut bytes = &bytes[..];

        let size = bytes.get_u8();
        let type_ = bytes.get_u32_le();
        let mut name = [0u16; 20];
        for n in &mut name {
            *n = bytes.get_u16_le()
        }
        let data_offset = bytes.get_u32_le();
        let data_size = bytes.get_u32_le();
        let data_delay = bytes.get_u32_le();

        RkBootEntry {
            size,
            type_,
            name,
            data_offset,
            data_size,
            data_delay,
        }
    }
}

pub type RkBootHeaderBytes = [u8; 102];
/// Boot header which can be found at the start of a boot file
///
/// The header contains three entry types; 0x471 which are the blobs that should be uploaded to the
/// bootrom sram initially to setup ddr memory; 0x472 the blobs that should be uploaded to the
/// bootrom ddr, typically implementing the complete usb protocol. And finally the loader entry
/// which are the blobs meant to be used for a normal boot
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RkBootHeader {
    pub tag: [u8; 4],
    pub size: u16,
    pub version: u32,
    pub merge_version: u32,
    pub release: RkTime,
    pub supported_chip: [u8; 4],
    pub entry_471: RkBootHeaderEntry,
    pub entry_472: RkBootHeaderEntry,
    pub entry_loader: RkBootHeaderEntry,
    pub sign_flag: u8,
    pub rc4_flag: u8,
}

impl RkBootHeader {
    pub fn from_bytes(bytes: &RkBootHeaderBytes) -> Option<RkBootHeader> {
        let mut bytes = &bytes[..];
        let mut tag = [0u8; 4];
        bytes.copy_to_slice(&mut tag);

        if &tag != b"BOOT" && &tag != b"LDR " {
            return None;
        }
        let size = bytes.get_u16_le();
        let version = bytes.get_u32_le();
        let merge_version = bytes.get_u32_le();

        let release = RkTime::from_bytes(bytes[0..7].try_into().unwrap());
        bytes.advance(7);

        let supported_chip = bytes.get_u32().to_le_bytes();
        let entry_471 = RkBootHeaderEntry::from_bytes(bytes[0..6].try_into().unwrap());
        bytes.advance(6);
        let entry_472 = RkBootHeaderEntry::from_bytes(bytes[0..6].try_into().unwrap());
        bytes.advance(6);
        let entry_loader = RkBootHeaderEntry::from_bytes(bytes[0..6].try_into().unwrap());
        bytes.advance(6);

        let sign_flag = bytes.get_u8();
        let rc4_flag = bytes.get_u8();

        Some(RkBootHeader {
            tag,
            size,
            version,
            merge_version,
            release,
            supported_chip,
            entry_471,
            entry_472,
            entry_loader,
            sign_flag,
            rc4_flag,
        })
    }
}