qfw.c 4.7 KB

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