qfw.c 4.6 KB

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