stm32prog_usb.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232
  1. // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
  2. /*
  3. * Copyright (C) 2020, STMicroelectronics - All Rights Reserved
  4. */
  5. #include <common.h>
  6. #include <dfu.h>
  7. #include <g_dnl.h>
  8. #include <usb.h>
  9. #include <asm/arch/stm32prog.h>
  10. #include <asm/arch/sys_proto.h>
  11. #include "stm32prog.h"
  12. static int stm32prog_set_phase(struct stm32prog_data *data, u8 phase,
  13. u32 offset)
  14. {
  15. struct stm32prog_part_t *part;
  16. int i;
  17. if (phase == data->phase) {
  18. data->offset = offset;
  19. data->dfu_seq = 0;
  20. return 0;
  21. }
  22. /* found partition for phase */
  23. for (i = 0; i < data->part_nb; i++) {
  24. part = &data->part_array[i];
  25. if (part->id == phase) {
  26. data->cur_part = part;
  27. data->phase = phase;
  28. data->offset = offset;
  29. data->dfu_seq = 0;
  30. return 0;
  31. }
  32. }
  33. return -EINVAL;
  34. }
  35. static int stm32prog_cmd_write(u64 offset, void *buf, long *len)
  36. {
  37. u8 phase;
  38. u32 address;
  39. u8 *pt = buf;
  40. void (*entry)(void);
  41. int ret;
  42. if (*len < 5) {
  43. pr_err("size not allowed\n");
  44. return -EINVAL;
  45. }
  46. if (offset) {
  47. pr_err("invalid offset\n");
  48. return -EINVAL;
  49. }
  50. phase = pt[0];
  51. address = (pt[1] << 24) | (pt[2] << 16) | (pt[3] << 8) | pt[4];
  52. if (phase == PHASE_RESET) {
  53. entry = (void *)address;
  54. printf("## Starting application at 0x%x ...\n", address);
  55. (*entry)();
  56. printf("## Application terminated\n");
  57. return 0;
  58. }
  59. /* set phase and offset */
  60. ret = stm32prog_set_phase(stm32prog_data, phase, address);
  61. if (ret)
  62. pr_err("failed: %d\n", ret);
  63. return ret;
  64. }
  65. #define PHASE_MIN_SIZE 9
  66. static int stm32prog_cmd_read(u64 offset, void *buf, long *len)
  67. {
  68. u32 destination = DEFAULT_ADDRESS; /* destination address */
  69. u32 dfu_offset;
  70. u8 *pt_buf = buf;
  71. int phase;
  72. char *err_msg;
  73. int length;
  74. if (*len < PHASE_MIN_SIZE) {
  75. pr_err("request exceeds allowed area\n");
  76. return -EINVAL;
  77. }
  78. if (offset) {
  79. *len = 0; /* EOF for second request */
  80. return 0;
  81. }
  82. phase = stm32prog_data->phase;
  83. if (phase == PHASE_FLASHLAYOUT)
  84. destination = STM32_DDR_BASE;
  85. dfu_offset = stm32prog_data->offset;
  86. /* mandatory header, size = PHASE_MIN_SIZE */
  87. *pt_buf++ = (u8)(phase & 0xFF);
  88. *pt_buf++ = (u8)(destination);
  89. *pt_buf++ = (u8)(destination >> 8);
  90. *pt_buf++ = (u8)(destination >> 16);
  91. *pt_buf++ = (u8)(destination >> 24);
  92. *pt_buf++ = (u8)(dfu_offset);
  93. *pt_buf++ = (u8)(dfu_offset >> 8);
  94. *pt_buf++ = (u8)(dfu_offset >> 16);
  95. *pt_buf++ = (u8)(dfu_offset >> 24);
  96. if (phase == PHASE_RESET || phase == PHASE_DO_RESET) {
  97. err_msg = stm32prog_get_error(stm32prog_data);
  98. length = strlen(err_msg);
  99. if (length + PHASE_MIN_SIZE > *len)
  100. length = *len - PHASE_MIN_SIZE;
  101. memcpy(pt_buf, err_msg, length);
  102. *len = PHASE_MIN_SIZE + length;
  103. stm32prog_do_reset(stm32prog_data);
  104. } else if (phase == PHASE_FLASHLAYOUT) {
  105. *pt_buf++ = stm32prog_data->part_nb ? 1 : 0;
  106. *len = PHASE_MIN_SIZE + 1;
  107. } else {
  108. *len = PHASE_MIN_SIZE;
  109. }
  110. return 0;
  111. }
  112. int stm32prog_write_medium_virt(struct dfu_entity *dfu, u64 offset,
  113. void *buf, long *len)
  114. {
  115. if (dfu->dev_type != DFU_DEV_VIRT)
  116. return -EINVAL;
  117. switch (dfu->data.virt.dev_num) {
  118. case PHASE_CMD:
  119. return stm32prog_cmd_write(offset, buf, len);
  120. case PHASE_OTP:
  121. return stm32prog_otp_write(stm32prog_data, (u32)offset,
  122. buf, len);
  123. case PHASE_PMIC:
  124. return stm32prog_pmic_write(stm32prog_data, (u32)offset,
  125. buf, len);
  126. }
  127. *len = 0;
  128. return 0;
  129. }
  130. int stm32prog_read_medium_virt(struct dfu_entity *dfu, u64 offset,
  131. void *buf, long *len)
  132. {
  133. if (dfu->dev_type != DFU_DEV_VIRT)
  134. return -EINVAL;
  135. switch (dfu->data.virt.dev_num) {
  136. case PHASE_CMD:
  137. return stm32prog_cmd_read(offset, buf, len);
  138. case PHASE_OTP:
  139. return stm32prog_otp_read(stm32prog_data, (u32)offset,
  140. buf, len);
  141. case PHASE_PMIC:
  142. return stm32prog_pmic_read(stm32prog_data, (u32)offset,
  143. buf, len);
  144. }
  145. *len = 0;
  146. return 0;
  147. }
  148. int stm32prog_get_medium_size_virt(struct dfu_entity *dfu, u64 *size)
  149. {
  150. if (dfu->dev_type != DFU_DEV_VIRT) {
  151. *size = 0;
  152. pr_debug("%s, invalid dev_type = %d\n",
  153. __func__, dfu->dev_type);
  154. return -EINVAL;
  155. }
  156. switch (dfu->data.virt.dev_num) {
  157. case PHASE_CMD:
  158. *size = 512;
  159. break;
  160. case PHASE_OTP:
  161. *size = OTP_SIZE;
  162. break;
  163. case PHASE_PMIC:
  164. *size = PMIC_SIZE;
  165. break;
  166. }
  167. return 0;
  168. }
  169. bool stm32prog_usb_loop(struct stm32prog_data *data, int dev)
  170. {
  171. int ret;
  172. bool result;
  173. /* USB download gadget for STM32 Programmer */
  174. char product[128];
  175. char name[SOC_NAME_SIZE];
  176. get_soc_name(name);
  177. snprintf(product, sizeof(product),
  178. "USB download gadget@Device ID /0x%03X, @Revision ID /0x%04X, @Name /%s,",
  179. get_cpu_dev(), get_cpu_rev(), name);
  180. g_dnl_set_product(product);
  181. if (stm32prog_data->phase == PHASE_FLASHLAYOUT) {
  182. ret = run_usb_dnl_gadget(dev, "usb_dnl_dfu");
  183. if (ret || stm32prog_data->phase == PHASE_DO_RESET)
  184. return ret;
  185. /* prepare the second enumeration with the FlashLayout */
  186. if (stm32prog_data->phase == PHASE_FLASHLAYOUT)
  187. stm32prog_dfu_init(data);
  188. /* found next selected partition */
  189. stm32prog_next_phase(data);
  190. }
  191. ret = run_usb_dnl_gadget(dev, "usb_dnl_dfu");
  192. result = !!(ret) || (stm32prog_data->phase == PHASE_DO_RESET);
  193. g_dnl_set_product(NULL);
  194. return result;
  195. }
  196. int g_dnl_get_board_bcd_device_number(int gcnum)
  197. {
  198. pr_debug("%s\n", __func__);
  199. return 0x200;
  200. }