blob: 23358c95d9d9c15920ed2eaf8ce13f462a8e8992 [file] [log] [blame]
Nico Huber454f6132012-12-10 13:34:10 +00001/*
2 * This file is part of the flashrom project.
3 *
4 * Copyright (C) 2012, 2016 secunet Security Networks AG
5 * (Written by Nico Huber <nico.huber@secunet.com> for secunet)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
Nico Huber454f6132012-12-10 13:34:10 +000016 */
17/**
18 * @mainpage
19 *
20 * Have a look at the Modules section for a function reference.
21 */
22
Nico Huber70461a92019-06-15 14:56:19 +020023#include <errno.h>
Nico Huber454f6132012-12-10 13:34:10 +000024#include <stdlib.h>
25#include <string.h>
26#include <stdarg.h>
27
28#include "flash.h"
Arthur Heymansc82900b2018-01-10 12:48:16 +010029#include "fmap.h"
Nico Huber454f6132012-12-10 13:34:10 +000030#include "programmer.h"
31#include "layout.h"
Nico Huber305f4172013-06-14 11:55:26 +020032#include "hwaccess.h"
33#include "ich_descriptors.h"
Nico Huber454f6132012-12-10 13:34:10 +000034#include "libflashrom.h"
35
36/**
37 * @defgroup flashrom-general General
38 * @{
39 */
40
41/** Pointer to log callback function. */
42static flashrom_log_callback *global_log_callback = NULL;
43
44/**
45 * @brief Initialize libflashrom.
46 *
47 * @param perform_selfcheck If not zero, perform a self check.
48 * @return 0 on success
49 */
50int flashrom_init(const int perform_selfcheck)
51{
52 if (perform_selfcheck && selfcheck())
53 return 1;
54 myusec_calibrate_delay();
55 return 0;
56}
57
58/**
59 * @brief Shut down libflashrom.
60 * @return 0 on success
61 */
62int flashrom_shutdown(void)
63{
64 return 0; /* TODO: nothing to do? */
65}
66
67/* TODO: flashrom_set_loglevel()? do we need it?
Angel Ponsf0ab83f2021-04-17 17:08:44 +020068 For now, let the user decide in their callback. */
Nico Huber454f6132012-12-10 13:34:10 +000069
70/**
71 * @brief Set the log callback function.
72 *
73 * Set a callback function which will be invoked whenever libflashrom wants
74 * to output messages. This allows frontends to do whatever they see fit with
75 * such messages, e.g. write them to syslog, or to file, or print them in a
76 * GUI window, etc.
77 *
78 * @param log_callback Pointer to the new log callback function.
79 */
80void flashrom_set_log_callback(flashrom_log_callback *const log_callback)
81{
82 global_log_callback = log_callback;
83}
84/** @private */
Nico Huberd152fb92017-06-19 12:57:10 +020085int print(const enum flashrom_log_level level, const char *const fmt, ...)
Nico Huber454f6132012-12-10 13:34:10 +000086{
87 if (global_log_callback) {
88 int ret;
89 va_list args;
90 va_start(args, fmt);
Nico Huberd152fb92017-06-19 12:57:10 +020091 ret = global_log_callback(level, fmt, args);
Nico Huber454f6132012-12-10 13:34:10 +000092 va_end(args);
93 return ret;
94 }
95 return 0;
96}
97
98/** @} */ /* end flashrom-general */
99
100
101
102/**
103 * @defgroup flashrom-query Querying
104 * @{
105 */
106
Artur Raglis71b706f2019-06-05 19:24:52 +0200107/**
108 * @brief Returns flashrom version
109 * @return flashrom version
110 */
111const char *flashrom_version_info(void)
112{
113 return flashrom_version;
114}
115
116/**
117 * @brief Returns list of supported programmers
118 * @return List of supported programmers, or NULL if an error occurred
119 */
120const char **flashrom_supported_programmers(void)
121{
122 enum programmer p = 0;
123 const char **supported_programmers = malloc((PROGRAMMER_INVALID + 1) * sizeof(char*));
124
125 if (supported_programmers != NULL) {
126 for (; p < PROGRAMMER_INVALID; ++p) {
127 supported_programmers[p] = programmer_table[p].name;
128 }
129 } else {
130 msg_gerr("Memory allocation error!\n");
131 }
132
133 return supported_programmers;
134}
135
136/**
137 * @brief Returns list of supported flash chips
138 * @return List of supported flash chips, or NULL if an error occurred
139 */
140struct flashrom_flashchip_info *flashrom_supported_flash_chips(void)
141{
Nico Huber961f4a12019-10-04 17:34:22 +0200142 unsigned int i = 0;
Artur Raglis71b706f2019-06-05 19:24:52 +0200143 struct flashrom_flashchip_info *supported_flashchips =
144 malloc(flashchips_size * sizeof(*supported_flashchips));
145
146 if (supported_flashchips != NULL) {
147 for (; i < flashchips_size; ++i) {
148 supported_flashchips[i].vendor = flashchips[i].vendor;
149 supported_flashchips[i].name = flashchips[i].name;
150 supported_flashchips[i].tested.erase =
151 (enum flashrom_test_state)flashchips[i].tested.erase;
152 supported_flashchips[i].tested.probe =
153 (enum flashrom_test_state)flashchips[i].tested.probe;
154 supported_flashchips[i].tested.read =
155 (enum flashrom_test_state)flashchips[i].tested.read;
156 supported_flashchips[i].tested.write =
157 (enum flashrom_test_state)flashchips[i].tested.write;
158 supported_flashchips[i].total_size = flashchips[i].total_size;
159 }
160 } else {
161 msg_gerr("Memory allocation error!\n");
162 }
163
164 return supported_flashchips;
165}
166
167/**
168 * @brief Returns list of supported mainboards
169 * @return List of supported mainboards, or NULL if an error occurred
170 */
171struct flashrom_board_info *flashrom_supported_boards(void)
172{
Jonathan Liu7f15de12019-10-06 16:22:04 +1100173#if CONFIG_INTERNAL == 1
Artur Raglis71b706f2019-06-05 19:24:52 +0200174 int boards_known_size = 0;
175 int i = 0;
176 const struct board_info *binfo = boards_known;
177
178 while ((binfo++)->vendor)
179 ++boards_known_size;
180 binfo = boards_known;
181 /* add place for {0} */
182 ++boards_known_size;
183
184 struct flashrom_board_info *supported_boards =
Angel Pons3ef0df02020-03-31 15:13:48 +0200185 malloc(boards_known_size * sizeof(struct flashrom_board_info));
Artur Raglis71b706f2019-06-05 19:24:52 +0200186
187 if (supported_boards != NULL) {
188 for (; i < boards_known_size; ++i) {
189 supported_boards[i].vendor = binfo[i].vendor;
190 supported_boards[i].name = binfo[i].name;
Angel Pons3a0c1962020-05-27 12:15:51 +0200191 supported_boards[i].working =
192 (enum flashrom_test_state) binfo[i].working;
Artur Raglis71b706f2019-06-05 19:24:52 +0200193 }
194 } else {
195 msg_gerr("Memory allocation error!\n");
196 }
197
198 return supported_boards;
Jonathan Liu7f15de12019-10-06 16:22:04 +1100199#else
200 return NULL;
201#endif
Artur Raglis71b706f2019-06-05 19:24:52 +0200202}
203
204/**
205 * @brief Returns list of supported chipsets
206 * @return List of supported chipsets, or NULL if an error occurred
207 */
208struct flashrom_chipset_info *flashrom_supported_chipsets(void)
209{
Jonathan Liu7f15de12019-10-06 16:22:04 +1100210#if CONFIG_INTERNAL == 1
Artur Raglis71b706f2019-06-05 19:24:52 +0200211 int chipset_enables_size = 0;
212 int i = 0;
213 const struct penable *chipset = chipset_enables;
214
215 while ((chipset++)->vendor_name)
216 ++chipset_enables_size;
217 chipset = chipset_enables;
218 /* add place for {0}*/
219 ++chipset_enables_size;
220
221 struct flashrom_chipset_info *supported_chipsets =
222 malloc(chipset_enables_size * sizeof(*supported_chipsets));
223
224 if (supported_chipsets != NULL) {
225 for (; i < chipset_enables_size; ++i) {
226 supported_chipsets[i].vendor = chipset[i].vendor_name;
227 supported_chipsets[i].chipset = chipset[i].device_name;
228 supported_chipsets[i].vendor_id = chipset[i].vendor_id;
229 supported_chipsets[i].chipset_id = chipset[i].device_id;
Angel Pons3a0c1962020-05-27 12:15:51 +0200230 supported_chipsets[i].status =
231 (enum flashrom_test_state) chipset[i].status;
Angel Pons6f793e42020-05-27 12:17:31 +0200232 }
Artur Raglis71b706f2019-06-05 19:24:52 +0200233 } else {
234 msg_gerr("Memory allocation error!\n");
235 }
236
237 return supported_chipsets;
Jonathan Liu7f15de12019-10-06 16:22:04 +1100238#else
239 return NULL;
240#endif
Artur Raglis71b706f2019-06-05 19:24:52 +0200241}
242
243/**
244 * @brief Frees memory allocated by libflashrom API
245 * @param Pointer to block of memory which should be freed
246 * @return 0 on success
247 */
248int flashrom_data_free(void *const p)
249{
250 free(p);
251 return 0;
252}
Nico Huber454f6132012-12-10 13:34:10 +0000253
254/** @} */ /* end flashrom-query */
255
256
257
258/**
259 * @defgroup flashrom-prog Programmers
260 * @{
261 */
262
263/**
264 * @brief Initialize the specified programmer.
265 *
266 * Currently, only one programmer may be initialized at a time.
267 *
268 * @param[out] flashprog Points to a pointer of type struct flashrom_programmer
269 * that will be set if programmer initialization succeeds.
270 * *flashprog has to be shutdown by the caller with @ref
271 * flashrom_programmer_shutdown.
272 * @param[in] prog_name Name of the programmer to initialize.
273 * @param[in] prog_param Pointer to programmer specific parameters.
274 * @return 0 on success
275 */
276int flashrom_programmer_init(struct flashrom_programmer **const flashprog,
277 const char *const prog_name, const char *const prog_param)
278{
279 unsigned prog;
280
281 for (prog = 0; prog < PROGRAMMER_INVALID; prog++) {
282 if (strcmp(prog_name, programmer_table[prog].name) == 0)
283 break;
284 }
285 if (prog >= PROGRAMMER_INVALID) {
286 msg_ginfo("Error: Unknown programmer \"%s\". Valid choices are:\n", prog_name);
287 list_programmers_linebreak(0, 80, 0);
288 return 1;
289 }
290 return programmer_init(prog, prog_param);
291}
292
293/**
294 * @brief Shut down the initialized programmer.
295 *
296 * @param flashprog The programmer to shut down.
297 * @return 0 on success
298 */
299int flashrom_programmer_shutdown(struct flashrom_programmer *const flashprog)
300{
301 return programmer_shutdown();
302}
303
304/* TODO: flashrom_programmer_capabilities()? */
305
306/** @} */ /* end flashrom-prog */
307
308
309
310/**
311 * @defgroup flashrom-flash Flash chips
312 * @{
313 */
314
315/**
316 * @brief Probe for a flash chip.
317 *
318 * Probes for a flash chip and returns a flash context, that can be used
319 * later with flash chip and @ref flashrom-ops "image operations", if
320 * exactly one matching chip is found.
321 *
322 * @param[out] flashctx Points to a pointer of type struct flashrom_flashctx
323 * that will be set if exactly one chip is found. *flashctx
324 * has to be freed by the caller with @ref flashrom_flash_release.
325 * @param[in] flashprog The flash programmer used to access the chip.
326 * @param[in] chip_name Name of a chip to probe for, or NULL to probe for
327 * all known chips.
328 * @return 0 on success,
329 * 3 if multiple chips were found,
330 * 2 if no chip was found,
331 * or 1 on any other error.
332 */
333int flashrom_flash_probe(struct flashrom_flashctx **const flashctx,
334 const struct flashrom_programmer *const flashprog,
335 const char *const chip_name)
336{
337 int i, ret = 2;
338 struct flashrom_flashctx second_flashctx = { 0, };
339
340 chip_to_probe = chip_name; /* chip_to_probe is global in flashrom.c */
341
342 *flashctx = malloc(sizeof(**flashctx));
343 if (!*flashctx)
344 return 1;
345 memset(*flashctx, 0, sizeof(**flashctx));
346
347 for (i = 0; i < registered_master_count; ++i) {
348 int flash_idx = -1;
349 if (!ret || (flash_idx = probe_flash(&registered_masters[i], 0, *flashctx, 0)) != -1) {
350 ret = 0;
351 /* We found one chip, now check that there is no second match. */
352 if (probe_flash(&registered_masters[i], flash_idx + 1, &second_flashctx, 0) != -1) {
353 ret = 3;
354 break;
355 }
356 }
357 }
358 if (ret) {
359 free(*flashctx);
360 *flashctx = NULL;
361 }
362 return ret;
363}
364
365/**
366 * @brief Returns the size of the specified flash chip in bytes.
367 *
368 * @param flashctx The queried flash context.
369 * @return Size of flash chip in bytes.
370 */
371size_t flashrom_flash_getsize(const struct flashrom_flashctx *const flashctx)
372{
373 return flashctx->chip->total_size * 1024;
374}
375
376/**
377 * @brief Free a flash context.
378 *
379 * @param flashctx Flash context to free.
380 */
381void flashrom_flash_release(struct flashrom_flashctx *const flashctx)
382{
383 free(flashctx);
384}
385
386/**
387 * @brief Set a flag in the given flash context.
388 *
389 * @param flashctx Flash context to alter.
390 * @param flag Flag that is to be set / cleared.
391 * @param value Value to set.
392 */
393void flashrom_flag_set(struct flashrom_flashctx *const flashctx,
394 const enum flashrom_flag flag, const bool value)
395{
396 switch (flag) {
397 case FLASHROM_FLAG_FORCE: flashctx->flags.force = value; break;
398 case FLASHROM_FLAG_FORCE_BOARDMISMATCH: flashctx->flags.force_boardmismatch = value; break;
399 case FLASHROM_FLAG_VERIFY_AFTER_WRITE: flashctx->flags.verify_after_write = value; break;
400 case FLASHROM_FLAG_VERIFY_WHOLE_CHIP: flashctx->flags.verify_whole_chip = value; break;
401 }
402}
403
404/**
405 * @brief Return the current value of a flag in the given flash context.
406 *
407 * @param flashctx Flash context to read from.
408 * @param flag Flag to be read.
409 * @return Current value of the flag.
410 */
411bool flashrom_flag_get(const struct flashrom_flashctx *const flashctx, const enum flashrom_flag flag)
412{
413 switch (flag) {
414 case FLASHROM_FLAG_FORCE: return flashctx->flags.force;
415 case FLASHROM_FLAG_FORCE_BOARDMISMATCH: return flashctx->flags.force_boardmismatch;
416 case FLASHROM_FLAG_VERIFY_AFTER_WRITE: return flashctx->flags.verify_after_write;
417 case FLASHROM_FLAG_VERIFY_WHOLE_CHIP: return flashctx->flags.verify_whole_chip;
418 default: return false;
419 }
420}
421
422/** @} */ /* end flashrom-flash */
423
424
425
426/**
427 * @defgroup flashrom-layout Layout handling
428 * @{
429 */
430
431/**
Nico Huber305f4172013-06-14 11:55:26 +0200432 * @brief Read a layout from the Intel ICH descriptor in the flash.
433 *
434 * Optionally verify that the layout matches the one in the given
435 * descriptor dump.
436 *
437 * @param[out] layout Points to a struct flashrom_layout pointer that
438 * gets set if the descriptor is read and parsed
439 * successfully.
440 * @param[in] flashctx Flash context to read the descriptor from flash.
441 * @param[in] dump The descriptor dump to compare to or NULL.
442 * @param[in] len The length of the descriptor dump.
443 *
444 * @return 0 on success,
445 * 6 if descriptor parsing isn't implemented for the host,
446 * 5 if the descriptors don't match,
447 * 4 if the descriptor dump couldn't be parsed,
448 * 3 if the descriptor on flash couldn't be parsed,
449 * 2 if the descriptor on flash couldn't be read,
450 * 1 on any other error.
451 */
452int flashrom_layout_read_from_ifd(struct flashrom_layout **const layout, struct flashctx *const flashctx,
453 const void *const dump, const size_t len)
454{
455#ifndef __FLASHROM_LITTLE_ENDIAN__
456 return 6;
457#else
458 struct ich_layout dump_layout;
459 int ret = 1;
460
461 void *const desc = malloc(0x1000);
462 struct ich_layout *const chip_layout = malloc(sizeof(*chip_layout));
463 if (!desc || !chip_layout) {
464 msg_gerr("Out of memory!\n");
465 goto _free_ret;
466 }
467
468 if (prepare_flash_access(flashctx, true, false, false, false))
469 goto _free_ret;
470
471 msg_cinfo("Reading ich descriptor... ");
472 if (flashctx->chip->read(flashctx, desc, 0, 0x1000)) {
473 msg_cerr("Read operation failed!\n");
474 msg_cinfo("FAILED.\n");
475 ret = 2;
476 goto _finalize_ret;
477 }
478 msg_cinfo("done.\n");
479
480 if (layout_from_ich_descriptors(chip_layout, desc, 0x1000)) {
Patrick Rudolph911b8d82019-06-06 11:23:55 +0200481 msg_cerr("Couldn't parse the descriptor!\n");
Nico Huber305f4172013-06-14 11:55:26 +0200482 ret = 3;
483 goto _finalize_ret;
484 }
485
486 if (dump) {
487 if (layout_from_ich_descriptors(&dump_layout, dump, len)) {
Patrick Rudolph911b8d82019-06-06 11:23:55 +0200488 msg_cerr("Couldn't parse the descriptor!\n");
Nico Huber305f4172013-06-14 11:55:26 +0200489 ret = 4;
490 goto _finalize_ret;
491 }
492
493 if (chip_layout->base.num_entries != dump_layout.base.num_entries ||
494 memcmp(chip_layout->entries, dump_layout.entries, sizeof(dump_layout.entries))) {
Patrick Rudolph911b8d82019-06-06 11:23:55 +0200495 msg_cerr("Descriptors don't match!\n");
Nico Huber305f4172013-06-14 11:55:26 +0200496 ret = 5;
497 goto _finalize_ret;
498 }
499 }
500
501 *layout = (struct flashrom_layout *)chip_layout;
502 ret = 0;
503
504_finalize_ret:
505 finalize_flash_access(flashctx);
506_free_ret:
507 if (ret)
508 free(chip_layout);
509 free(desc);
510 return ret;
511#endif
512}
513
Nico Huberee13d0c2019-06-07 17:47:40 +0200514#ifdef __FLASHROM_LITTLE_ENDIAN__
Arthur Heymansc82900b2018-01-10 12:48:16 +0100515static int flashrom_layout_parse_fmap(struct flashrom_layout **layout,
516 struct flashctx *const flashctx, const struct fmap *const fmap)
517{
518 int i;
519 struct flashrom_layout *l = get_global_layout();
520
521 if (!fmap || !l)
522 return 1;
523
524 if (l->num_entries + fmap->nareas > MAX_ROMLAYOUT) {
525 msg_gerr("Cannot add fmap entries to layout - Too many entries.\n");
526 return 1;
527 }
528
529 for (i = 0; i < fmap->nareas; i++) {
530 l->entries[l->num_entries].start = fmap->areas[i].offset;
531 l->entries[l->num_entries].end = fmap->areas[i].offset + fmap->areas[i].size - 1;
532 l->entries[l->num_entries].included = false;
Nico Huber70461a92019-06-15 14:56:19 +0200533 l->entries[l->num_entries].name =
534 strndup((const char *)fmap->areas[i].name, FMAP_STRLEN);
535 if (!l->entries[l->num_entries].name) {
536 msg_gerr("Error adding layout entry: %s\n", strerror(errno));
537 return 1;
538 }
Arthur Heymansc82900b2018-01-10 12:48:16 +0100539 msg_gdbg("fmap %08x - %08x named %s\n",
540 l->entries[l->num_entries].start,
541 l->entries[l->num_entries].end,
542 l->entries[l->num_entries].name);
543 l->num_entries++;
544 }
545
546 *layout = l;
547 return 0;
548}
Nico Huberee13d0c2019-06-07 17:47:40 +0200549#endif /* __FLASHROM_LITTLE_ENDIAN__ */
Arthur Heymansc82900b2018-01-10 12:48:16 +0100550
551/**
552 * @brief Read a layout by searching the flash chip for fmap.
553 *
554 * @param[out] layout Points to a struct flashrom_layout pointer that
555 * gets set if the fmap is read and parsed successfully.
556 * @param[in] flashctx Flash context
557 * @param[in] offset Offset to begin searching for fmap.
558 * @param[in] offset Length of address space to search.
559 *
560 * @return 0 on success,
561 * 3 if fmap parsing isn't implemented for the host,
562 * 2 if the fmap couldn't be read,
563 * 1 on any other error.
564 */
565int flashrom_layout_read_fmap_from_rom(struct flashrom_layout **const layout,
566 struct flashctx *const flashctx, off_t offset, size_t len)
567{
568#ifndef __FLASHROM_LITTLE_ENDIAN__
569 return 3;
570#else
571 struct fmap *fmap = NULL;
572 int ret = 0;
573
574 msg_gdbg("Attempting to read fmap from ROM content.\n");
575 if (fmap_read_from_rom(&fmap, flashctx, offset, len)) {
576 msg_gerr("Failed to read fmap from ROM.\n");
577 return 1;
578 }
579
580 msg_gdbg("Adding fmap layout to global layout.\n");
581 if (flashrom_layout_parse_fmap(layout, flashctx, fmap)) {
582 msg_gerr("Failed to add fmap regions to layout.\n");
583 ret = 1;
584 }
585
586 free(fmap);
587 return ret;
588#endif
589}
590
591/**
592 * @brief Read a layout by searching buffer for fmap.
593 *
594 * @param[out] layout Points to a struct flashrom_layout pointer that
595 * gets set if the fmap is read and parsed successfully.
596 * @param[in] flashctx Flash context
597 * @param[in] buffer Buffer to search in
598 * @param[in] size Size of buffer to search
599 *
600 * @return 0 on success,
601 * 3 if fmap parsing isn't implemented for the host,
602 * 2 if the fmap couldn't be read,
603 * 1 on any other error.
604 */
605int flashrom_layout_read_fmap_from_buffer(struct flashrom_layout **const layout,
606 struct flashctx *const flashctx, const uint8_t *const buf, size_t size)
607{
608#ifndef __FLASHROM_LITTLE_ENDIAN__
609 return 3;
610#else
611 struct fmap *fmap = NULL;
612 int ret = 1;
613
614 if (!buf || !size)
615 goto _ret;
616
617 msg_gdbg("Attempting to read fmap from buffer.\n");
618 if (fmap_read_from_buffer(&fmap, buf, size)) {
619 msg_gerr("Failed to read fmap from buffer.\n");
620 goto _ret;
621 }
622
623 msg_gdbg("Adding fmap layout to global layout.\n");
624 if (flashrom_layout_parse_fmap(layout, flashctx, fmap)) {
625 msg_gerr("Failed to add fmap regions to layout.\n");
626 goto _free_ret;
627 }
628
629 ret = 0;
630_free_ret:
631 free(fmap);
632_ret:
633 return ret;
634#endif
635}
636
Nico Huber305f4172013-06-14 11:55:26 +0200637/**
Nico Huber454f6132012-12-10 13:34:10 +0000638 * @brief Set the active layout for a flash context.
639 *
640 * Note: This just sets a pointer. The caller must not release the layout
641 * as long as he uses it through the given flash context.
642 *
643 * @param flashctx Flash context whose layout will be set.
644 * @param layout Layout to bet set.
645 */
646void flashrom_layout_set(struct flashrom_flashctx *const flashctx, const struct flashrom_layout *const layout)
647{
648 flashctx->layout = layout;
649}
650
651/** @} */ /* end flashrom-layout */