qfw.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2015 Miao Yan <yanmiaobest@gmail.com>
  4. */
  5. #include <common.h>
  6. #include <command.h>
  7. #include <errno.h>
  8. #include <qfw.h>
  9. /*
  10. * This function prepares kernel for zboot. It loads kernel data
  11. * to 'load_addr', initrd to 'initrd_addr' and kernel command
  12. * line using qemu fw_cfg interface.
  13. */
  14. static int qemu_fwcfg_setup_kernel(void *load_addr, void *initrd_addr)
  15. {
  16. char *data_addr;
  17. uint32_t setup_size, kernel_size, cmdline_size, initrd_size;
  18. qemu_fwcfg_read_entry(FW_CFG_SETUP_SIZE, 4, &setup_size);
  19. qemu_fwcfg_read_entry(FW_CFG_KERNEL_SIZE, 4, &kernel_size);
  20. if (setup_size == 0 || kernel_size == 0) {
  21. printf("warning: no kernel available\n");
  22. return -1;
  23. }
  24. data_addr = load_addr;
  25. qemu_fwcfg_read_entry(FW_CFG_SETUP_DATA,
  26. le32_to_cpu(setup_size), data_addr);
  27. data_addr += le32_to_cpu(setup_size);
  28. qemu_fwcfg_read_entry(FW_CFG_KERNEL_DATA,
  29. le32_to_cpu(kernel_size), data_addr);
  30. data_addr += le32_to_cpu(kernel_size);
  31. data_addr = initrd_addr;
  32. qemu_fwcfg_read_entry(FW_CFG_INITRD_SIZE, 4, &initrd_size);
  33. if (initrd_size == 0) {
  34. printf("warning: no initrd available\n");
  35. } else {
  36. qemu_fwcfg_read_entry(FW_CFG_INITRD_DATA,
  37. le32_to_cpu(initrd_size), data_addr);
  38. data_addr += le32_to_cpu(initrd_size);
  39. }
  40. qemu_fwcfg_read_entry(FW_CFG_CMDLINE_SIZE, 4, &cmdline_size);
  41. if (cmdline_size) {
  42. qemu_fwcfg_read_entry(FW_CFG_CMDLINE_DATA,
  43. le32_to_cpu(cmdline_size), data_addr);
  44. /*
  45. * if kernel cmdline only contains '\0', (e.g. no -append
  46. * when invoking qemu), do not update bootargs
  47. */
  48. if (*data_addr != '\0') {
  49. if (env_set("bootargs", data_addr) < 0)
  50. printf("warning: unable to change bootargs\n");
  51. }
  52. }
  53. printf("loading kernel to address %p size %x", load_addr,
  54. le32_to_cpu(kernel_size));
  55. if (initrd_size)
  56. printf(" initrd %p size %x\n",
  57. initrd_addr,
  58. le32_to_cpu(initrd_size));
  59. else
  60. printf("\n");
  61. return 0;
  62. }
  63. static int qemu_fwcfg_list_firmware(void)
  64. {
  65. int ret;
  66. struct fw_cfg_file_iter iter;
  67. struct fw_file *file;
  68. /* make sure fw_list is loaded */
  69. ret = qemu_fwcfg_read_firmware_list();
  70. if (ret)
  71. return ret;
  72. for (file = qemu_fwcfg_file_iter_init(&iter);
  73. !qemu_fwcfg_file_iter_end(&iter);
  74. file = qemu_fwcfg_file_iter_next(&iter)) {
  75. printf("%-56s\n", file->cfg.name);
  76. }
  77. return 0;
  78. }
  79. static int qemu_fwcfg_do_list(cmd_tbl_t *cmdtp, int flag,
  80. int argc, char * const argv[])
  81. {
  82. if (qemu_fwcfg_list_firmware() < 0)
  83. return CMD_RET_FAILURE;
  84. return 0;
  85. }
  86. static int qemu_fwcfg_do_cpus(cmd_tbl_t *cmdtp, int flag,
  87. int argc, char * const argv[])
  88. {
  89. int ret = qemu_fwcfg_online_cpus();
  90. if (ret < 0) {
  91. printf("QEMU fw_cfg interface not found\n");
  92. return CMD_RET_FAILURE;
  93. }
  94. printf("%d cpu(s) online\n", qemu_fwcfg_online_cpus());
  95. return 0;
  96. }
  97. static int qemu_fwcfg_do_load(cmd_tbl_t *cmdtp, int flag,
  98. int argc, char * const argv[])
  99. {
  100. char *env;
  101. void *load_addr;
  102. void *initrd_addr;
  103. env = env_get("loadaddr");
  104. load_addr = env ?
  105. (void *)simple_strtoul(env, NULL, 16) :
  106. #ifdef CONFIG_LOADADDR
  107. (void *)CONFIG_LOADADDR;
  108. #else
  109. NULL;
  110. #endif
  111. env = env_get("ramdiskaddr");
  112. initrd_addr = env ?
  113. (void *)simple_strtoul(env, NULL, 16) :
  114. #ifdef CONFIG_RAMDISK_ADDR
  115. (void *)CONFIG_RAMDISK_ADDR;
  116. #else
  117. NULL;
  118. #endif
  119. if (argc == 2) {
  120. load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  121. initrd_addr = (void *)simple_strtoul(argv[1], NULL, 16);
  122. } else if (argc == 1) {
  123. load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  124. }
  125. if (!load_addr || !initrd_addr) {
  126. printf("missing load or initrd address\n");
  127. return CMD_RET_FAILURE;
  128. }
  129. return qemu_fwcfg_setup_kernel(load_addr, initrd_addr);
  130. }
  131. static cmd_tbl_t fwcfg_commands[] = {
  132. U_BOOT_CMD_MKENT(list, 0, 1, qemu_fwcfg_do_list, "", ""),
  133. U_BOOT_CMD_MKENT(cpus, 0, 1, qemu_fwcfg_do_cpus, "", ""),
  134. U_BOOT_CMD_MKENT(load, 2, 1, qemu_fwcfg_do_load, "", ""),
  135. };
  136. static int do_qemu_fw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  137. {
  138. int ret;
  139. cmd_tbl_t *fwcfg_cmd;
  140. if (!qemu_fwcfg_present()) {
  141. printf("QEMU fw_cfg interface not found\n");
  142. return CMD_RET_USAGE;
  143. }
  144. fwcfg_cmd = find_cmd_tbl(argv[1], fwcfg_commands,
  145. ARRAY_SIZE(fwcfg_commands));
  146. argc -= 2;
  147. argv += 2;
  148. if (!fwcfg_cmd || argc > fwcfg_cmd->maxargs)
  149. return CMD_RET_USAGE;
  150. ret = fwcfg_cmd->cmd(fwcfg_cmd, flag, argc, argv);
  151. return cmd_process_error(fwcfg_cmd, ret);
  152. }
  153. U_BOOT_CMD(
  154. qfw, 4, 1, do_qemu_fw,
  155. "QEMU firmware interface",
  156. "<command>\n"
  157. " - list : print firmware(s) currently loaded\n"
  158. " - cpus : print online cpu number\n"
  159. " - load <kernel addr> <initrd addr> : load kernel and initrd (if any), and setup for zboot\n"
  160. )