arch/arm/mach-stm32mp/cmd_stm32prog/stm32prog_usb.c

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