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#include "qemu/osdep.h"
28#include "hw/nvram/xlnx-efuse.h"
29
30#include "qemu/error-report.h"
31#include "qemu/log.h"
32#include "qapi/error.h"
33#include "sysemu/blockdev.h"
34#include "hw/qdev-properties.h"
35#include "hw/qdev-properties-system.h"
36
37#define TBIT0_OFFSET 28
38#define TBIT1_OFFSET 29
39#define TBIT2_OFFSET 30
40#define TBIT3_OFFSET 31
41#define TBITS_PATTERN (0x0AU << TBIT0_OFFSET)
42#define TBITS_MASK (0x0FU << TBIT0_OFFSET)
43
44bool xlnx_efuse_get_bit(XlnxEFuse *s, unsigned int bit)
45{
46 bool b = s->fuse32[bit / 32] & (1 << (bit % 32));
47 return b;
48}
49
50static int efuse_bytes(XlnxEFuse *s)
51{
52 return ROUND_UP((s->efuse_nr * s->efuse_size) / 8, 4);
53}
54
55static int efuse_bdrv_read(XlnxEFuse *s, Error **errp)
56{
57 uint32_t *ram = s->fuse32;
58 int nr = efuse_bytes(s);
59
60 if (!s->blk) {
61 return 0;
62 }
63
64 s->blk_ro = !blk_supports_write_perm(s->blk);
65 if (!s->blk_ro) {
66 int rc;
67
68 rc = blk_set_perm(s->blk,
69 (BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE),
70 BLK_PERM_ALL, NULL);
71 if (rc) {
72 s->blk_ro = true;
73 }
74 }
75 if (s->blk_ro) {
76 warn_report("%s: Skip saving updates to read-only eFUSE backstore.",
77 blk_name(s->blk));
78 }
79
80 if (blk_pread(s->blk, 0, nr, ram, 0) < 0) {
81 error_setg(errp, "%s: Failed to read %u bytes from eFUSE backstore.",
82 blk_name(s->blk), nr);
83 return -1;
84 }
85
86
87 nr /= 4;
88 while (nr--) {
89 ram[nr] = le32_to_cpu(ram[nr]);
90 }
91
92 return 0;
93}
94
95static void efuse_bdrv_sync(XlnxEFuse *s, unsigned int bit)
96{
97 unsigned int row_offset;
98 uint32_t le32;
99
100 if (!s->blk || s->blk_ro) {
101 return;
102 }
103
104
105 le32 = cpu_to_le32(xlnx_efuse_get_row(s, bit));
106
107 row_offset = (bit / 32) * 4;
108 if (blk_pwrite(s->blk, row_offset, 4, &le32, 0) < 0) {
109 error_report("%s: Failed to write offset %u of eFUSE backstore.",
110 blk_name(s->blk), row_offset);
111 }
112}
113
114static int efuse_ro_bits_cmp(const void *a, const void *b)
115{
116 uint32_t i = *(const uint32_t *)a;
117 uint32_t j = *(const uint32_t *)b;
118
119 return (i > j) - (i < j);
120}
121
122static void efuse_ro_bits_sort(XlnxEFuse *s)
123{
124 uint32_t *ary = s->ro_bits;
125 const uint32_t cnt = s->ro_bits_cnt;
126
127 if (ary && cnt > 1) {
128 qsort(ary, cnt, sizeof(ary[0]), efuse_ro_bits_cmp);
129 }
130}
131
132static bool efuse_ro_bits_find(XlnxEFuse *s, uint32_t k)
133{
134 const uint32_t *ary = s->ro_bits;
135 const uint32_t cnt = s->ro_bits_cnt;
136
137 if (!ary || !cnt) {
138 return false;
139 }
140
141 return bsearch(&k, ary, cnt, sizeof(ary[0]), efuse_ro_bits_cmp) != NULL;
142}
143
144bool xlnx_efuse_set_bit(XlnxEFuse *s, unsigned int bit)
145{
146 uint32_t set, *row;
147
148 if (efuse_ro_bits_find(s, bit)) {
149 g_autofree char *path = object_get_canonical_path(OBJECT(s));
150
151 qemu_log_mask(LOG_GUEST_ERROR, "%s: WARN: "
152 "Ignored setting of readonly efuse bit<%u,%u>!\n",
153 path, (bit / 32), (bit % 32));
154 return false;
155 }
156
157
158 row = &s->fuse32[bit / 32];
159 set = 1 << (bit % 32);
160 if (!(set & *row)) {
161 *row |= set;
162 efuse_bdrv_sync(s, bit);
163 }
164 return true;
165}
166
167bool xlnx_efuse_k256_check(XlnxEFuse *s, uint32_t crc, unsigned start)
168{
169 uint32_t calc;
170
171
172 assert((start % 32) == 0);
173
174 calc = xlnx_efuse_calc_crc(&s->fuse32[start / 32], (256 / 32), 0);
175 return calc == crc;
176}
177
178uint32_t xlnx_efuse_tbits_check(XlnxEFuse *s)
179{
180 int nr;
181 uint32_t check = 0;
182
183 for (nr = s->efuse_nr; nr-- > 0; ) {
184 int efuse_start_row_num = (s->efuse_size * nr) / 32;
185 uint32_t data = s->fuse32[efuse_start_row_num];
186
187
188
189
190
191
192 if ((data & TBITS_MASK) == 0 && s->init_tbits) {
193 data |= TBITS_PATTERN;
194
195 s->fuse32[efuse_start_row_num] = data;
196 efuse_bdrv_sync(s, (efuse_start_row_num * 32 + TBIT0_OFFSET));
197 }
198
199 check = (check << 1) | ((data & TBITS_MASK) == TBITS_PATTERN);
200 }
201
202 return check;
203}
204
205static void efuse_realize(DeviceState *dev, Error **errp)
206{
207 XlnxEFuse *s = XLNX_EFUSE(dev);
208
209
210 efuse_ro_bits_sort(s);
211
212 if ((s->efuse_size % 32) != 0) {
213 g_autofree char *path = object_get_canonical_path(OBJECT(s));
214
215 error_setg(errp,
216 "%s.efuse-size: %u: property value not multiple of 32.",
217 path, s->efuse_size);
218 return;
219 }
220
221 s->fuse32 = g_malloc0(efuse_bytes(s));
222 if (efuse_bdrv_read(s, errp)) {
223 g_free(s->fuse32);
224 }
225}
226
227static void efuse_prop_set_drive(Object *obj, Visitor *v, const char *name,
228 void *opaque, Error **errp)
229{
230 DeviceState *dev = DEVICE(obj);
231
232 qdev_prop_drive.set(obj, v, name, opaque, errp);
233
234
235 if (dev->realized) {
236 efuse_bdrv_read(XLNX_EFUSE(obj), errp);
237 }
238}
239
240static void efuse_prop_get_drive(Object *obj, Visitor *v, const char *name,
241 void *opaque, Error **errp)
242{
243 qdev_prop_drive.get(obj, v, name, opaque, errp);
244}
245
246static void efuse_prop_release_drive(Object *obj, const char *name,
247 void *opaque)
248{
249 qdev_prop_drive.release(obj, name, opaque);
250}
251
252static const PropertyInfo efuse_prop_drive = {
253 .name = "str",
254 .description = "Node name or ID of a block device to use as eFUSE backend",
255 .realized_set_allowed = true,
256 .get = efuse_prop_get_drive,
257 .set = efuse_prop_set_drive,
258 .release = efuse_prop_release_drive,
259};
260
261static Property efuse_properties[] = {
262 DEFINE_PROP("drive", XlnxEFuse, blk, efuse_prop_drive, BlockBackend *),
263 DEFINE_PROP_UINT8("efuse-nr", XlnxEFuse, efuse_nr, 3),
264 DEFINE_PROP_UINT32("efuse-size", XlnxEFuse, efuse_size, 64 * 32),
265 DEFINE_PROP_BOOL("init-factory-tbits", XlnxEFuse, init_tbits, true),
266 DEFINE_PROP_ARRAY("read-only", XlnxEFuse, ro_bits_cnt, ro_bits,
267 qdev_prop_uint32, uint32_t),
268 DEFINE_PROP_END_OF_LIST(),
269};
270
271static void efuse_class_init(ObjectClass *klass, void *data)
272{
273 DeviceClass *dc = DEVICE_CLASS(klass);
274
275 dc->realize = efuse_realize;
276 device_class_set_props(dc, efuse_properties);
277}
278
279static const TypeInfo efuse_info = {
280 .name = TYPE_XLNX_EFUSE,
281 .parent = TYPE_DEVICE,
282 .instance_size = sizeof(XlnxEFuse),
283 .class_init = efuse_class_init,
284};
285
286static void efuse_register_types(void)
287{
288 type_register_static(&efuse_info);
289}
290type_init(efuse_register_types)
291