Merge tag 'drm-misc-fixes-2020-08-12' of git://anongit.freedesktop.org/drm/drm-misc...
[platform/kernel/linux-rpi.git] / lib / pldmfw / pldmfw_private.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (C) 2018-2019, Intel Corporation. */
3
4 #ifndef _PLDMFW_PRIVATE_H_
5 #define _PLDMFW_PRIVATE_H_
6
7 /* The following data structures define the layout of a firmware binary
8  * following the "PLDM For Firmware Update Specification", DMTF standard
9  * #DSP0267.
10  *
11  * pldmfw.c uses these structures to implement a simple engine that will parse
12  * a fw binary file in this format and perform a firmware update for a given
13  * device.
14  *
15  * Due to the variable sized data layout, alignment of fields within these
16  * structures is not guaranteed when reading. For this reason, all multi-byte
17  * field accesses should be done using the unaligned access macros.
18  * Additionally, the standard specifies that multi-byte fields are in
19  * LittleEndian format.
20  *
21  * The structure definitions are not made public, in order to keep direct
22  * accesses within code that is prepared to deal with the limitation of
23  * unaligned access.
24  */
25
26 /* UUID for PLDM firmware packages: f018878c-cb7d-4943-9800-a02f059aca02 */
27 static const uuid_t pldm_firmware_header_id =
28         UUID_INIT(0xf018878c, 0xcb7d, 0x4943,
29                   0x98, 0x00, 0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02);
30
31 /* Revision number of the PLDM header format this code supports */
32 #define PACKAGE_HEADER_FORMAT_REVISION 0x01
33
34 /* timestamp104 structure defined in PLDM Base specification */
35 #define PLDM_TIMESTAMP_SIZE 13
36 struct __pldm_timestamp {
37         u8 b[PLDM_TIMESTAMP_SIZE];
38 } __packed __aligned(1);
39
40 /* Package Header Information */
41 struct __pldm_header {
42         uuid_t id;                          /* PackageHeaderIdentifier */
43         u8 revision;                        /* PackageHeaderFormatRevision */
44         __le16 size;                        /* PackageHeaderSize */
45         struct __pldm_timestamp release_date; /* PackageReleaseDateTime */
46         __le16 component_bitmap_len;        /* ComponentBitmapBitLength */
47         u8 version_type;                    /* PackageVersionStringType */
48         u8 version_len;                     /* PackageVersionStringLength */
49
50         /*
51          * DSP0267 also includes the following variable length fields at the
52          * end of this structure:
53          *
54          * PackageVersionString, length is version_len.
55          *
56          * The total size of this section is
57          *   sizeof(pldm_header) + version_len;
58          */
59         u8 version_string[];            /* PackageVersionString */
60 } __packed __aligned(1);
61
62 /* Firmware Device ID Record */
63 struct __pldmfw_record_info {
64         __le16 record_len;              /* RecordLength */
65         u8 descriptor_count;            /* DescriptorCount */
66         __le32 device_update_flags;     /* DeviceUpdateOptionFlags */
67         u8 version_type;                /* ComponentImageSetVersionType */
68         u8 version_len;                 /* ComponentImageSetVersionLength */
69         __le16 package_data_len;        /* FirmwareDevicePackageDataLength */
70
71         /*
72          * DSP0267 also includes the following variable length fields at the
73          * end of this structure:
74          *
75          * ApplicableComponents, length is component_bitmap_len from header
76          * ComponentImageSetVersionString, length is version_len
77          * RecordDescriptors, a series of TLVs with 16bit type and length
78          * FirmwareDevicePackageData, length is package_data_len
79          *
80          * The total size of each record is
81          *   sizeof(pldmfw_record_info) +
82          *   component_bitmap_len (converted to bytes!) +
83          *   version_len +
84          *   <length of RecordDescriptors> +
85          *   package_data_len
86          */
87         u8 variable_record_data[];
88 } __packed __aligned(1);
89
90 /* Firmware Descriptor Definition */
91 struct __pldmfw_desc_tlv {
92         __le16 type;                    /* DescriptorType */
93         __le16 size;                    /* DescriptorSize */
94         u8 data[];                      /* DescriptorData */
95 } __aligned(1);
96
97 /* Firmware Device Identification Area */
98 struct __pldmfw_record_area {
99         u8 record_count;                /* DeviceIDRecordCount */
100         /* This is not a struct type because the size of each record varies */
101         u8 records[];
102 } __aligned(1);
103
104 /* Individual Component Image Information */
105 struct __pldmfw_component_info {
106         __le16 classification;          /* ComponentClassfication */
107         __le16 identifier;              /* ComponentIdentifier */
108         __le32 comparison_stamp;        /* ComponentComparisonStamp */
109         __le16 options;                 /* componentOptions */
110         __le16 activation_method;       /* RequestedComponentActivationMethod */
111         __le32 location_offset;         /* ComponentLocationOffset */
112         __le32 size;                    /* ComponentSize */
113         u8 version_type;                /* ComponentVersionStringType */
114         u8 version_len;         /* ComponentVersionStringLength */
115
116         /*
117          * DSP0267 also includes the following variable length fields at the
118          * end of this structure:
119          *
120          * ComponentVersionString, length is version_len
121          *
122          * The total size of this section is
123          *   sizeof(pldmfw_component_info) + version_len;
124          */
125         u8 version_string[];            /* ComponentVersionString */
126 } __packed __aligned(1);
127
128 /* Component Image Information Area */
129 struct __pldmfw_component_area {
130         __le16 component_image_count;
131         /* This is not a struct type because the component size varies */
132         u8 components[];
133 } __aligned(1);
134
135 /**
136  * pldm_first_desc_tlv
137  * @start: byte offset of the start of the descriptor TLVs
138  *
139  * Converts the starting offset of the descriptor TLVs into a pointer to the
140  * first descriptor.
141  */
142 #define pldm_first_desc_tlv(start)                                      \
143         ((const struct __pldmfw_desc_tlv *)(start))
144
145 /**
146  * pldm_next_desc_tlv
147  * @desc: pointer to a descriptor TLV
148  *
149  * Finds the pointer to the next descriptor following a given descriptor
150  */
151 #define pldm_next_desc_tlv(desc)                                                \
152         ((const struct __pldmfw_desc_tlv *)((desc)->data +                      \
153                                              get_unaligned_le16(&(desc)->size)))
154
155 /**
156  * pldm_for_each_desc_tlv
157  * @i: variable to store descriptor index
158  * @desc: variable to store descriptor pointer
159  * @start: byte offset of the start of the descriptors
160  * @count: the number of descriptors
161  *
162  * for loop macro to iterate over all of the descriptors of a given PLDM
163  * record.
164  */
165 #define pldm_for_each_desc_tlv(i, desc, start, count)                   \
166         for ((i) = 0, (desc) = pldm_first_desc_tlv(start);              \
167              (i) < (count);                                             \
168              (i)++, (desc) = pldm_next_desc_tlv(desc))
169
170 /**
171  * pldm_first_record
172  * @start: byte offset of the start of the PLDM records
173  *
174  * Converts a starting offset of the PLDM records into a pointer to the first
175  * record.
176  */
177 #define pldm_first_record(start)                                        \
178         ((const struct __pldmfw_record_info *)(start))
179
180 /**
181  * pldm_next_record
182  * @record: pointer to a PLDM record
183  *
184  * Finds a pointer to the next record following a given record
185  */
186 #define pldm_next_record(record)                                        \
187         ((const struct __pldmfw_record_info *)                          \
188          ((const u8 *)(record) + get_unaligned_le16(&(record)->record_len)))
189
190 /**
191  * pldm_for_each_record
192  * @i: variable to store record index
193  * @record: variable to store record pointer
194  * @start: byte offset of the start of the records
195  * @count: the number of records
196  *
197  * for loop macro to iterate over all of the records of a PLDM file.
198  */
199 #define pldm_for_each_record(i, record, start, count)                   \
200         for ((i) = 0, (record) = pldm_first_record(start);              \
201              (i) < (count);                                             \
202              (i)++, (record) = pldm_next_record(record))
203
204 /**
205  * pldm_first_component
206  * @start: byte offset of the start of the PLDM components
207  *
208  * Convert a starting offset of the PLDM components into a pointer to the
209  * first component
210  */
211 #define pldm_first_component(start)                                     \
212         ((const struct __pldmfw_component_info *)(start))
213
214 /**
215  * pldm_next_component
216  * @component: pointer to a PLDM component
217  *
218  * Finds a pointer to the next component following a given component
219  */
220 #define pldm_next_component(component)                                          \
221         ((const struct __pldmfw_component_info *)((component)->version_string + \
222                                                   (component)->version_len))
223
224 /**
225  * pldm_for_each_component
226  * @i: variable to store component index
227  * @component: variable to store component pointer
228  * @start: byte offset to the start of the first component
229  * @count: the number of components
230  *
231  * for loop macro to iterate over all of the components of a PLDM file.
232  */
233 #define pldm_for_each_component(i, component, start, count)             \
234         for ((i) = 0, (component) = pldm_first_component(start);        \
235              (i) < (count);                                             \
236              (i)++, (component) = pldm_next_component(component))
237
238 #endif