mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-19 00:18:51 +09:00
![Patrick Delaunay](/assets/img/avatar_default.png)
Change debug and pr_ macro to log macro. Signed-off-by: Patrick Delaunay <patrick.delaunay@st.com> Reviewed-by: Patrice Chotard <patrice.chotard@st.com>
233 lines
5.1 KiB
C
233 lines
5.1 KiB
C
// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
|
|
/*
|
|
* Copyright (C) 2020, STMicroelectronics - All Rights Reserved
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <dfu.h>
|
|
#include <g_dnl.h>
|
|
#include <usb.h>
|
|
#include <asm/arch/stm32prog.h>
|
|
#include <asm/arch/sys_proto.h>
|
|
#include "stm32prog.h"
|
|
|
|
static int stm32prog_set_phase(struct stm32prog_data *data, u8 phase,
|
|
u32 offset)
|
|
{
|
|
struct stm32prog_part_t *part;
|
|
int i;
|
|
|
|
if (phase == data->phase) {
|
|
data->offset = offset;
|
|
data->dfu_seq = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* found partition for phase */
|
|
for (i = 0; i < data->part_nb; i++) {
|
|
part = &data->part_array[i];
|
|
if (part->id == phase) {
|
|
data->cur_part = part;
|
|
data->phase = phase;
|
|
data->offset = offset;
|
|
data->dfu_seq = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int stm32prog_cmd_write(u64 offset, void *buf, long *len)
|
|
{
|
|
u8 phase;
|
|
u32 address;
|
|
u8 *pt = buf;
|
|
void (*entry)(void);
|
|
int ret;
|
|
|
|
if (*len < 5) {
|
|
log_err("size not allowed\n");
|
|
return -EINVAL;
|
|
}
|
|
if (offset) {
|
|
log_err("invalid offset\n");
|
|
return -EINVAL;
|
|
}
|
|
phase = pt[0];
|
|
address = (pt[1] << 24) | (pt[2] << 16) | (pt[3] << 8) | pt[4];
|
|
if (phase == PHASE_RESET) {
|
|
entry = (void *)address;
|
|
printf("## Starting application at 0x%x ...\n", address);
|
|
(*entry)();
|
|
printf("## Application terminated\n");
|
|
return 0;
|
|
}
|
|
/* set phase and offset */
|
|
ret = stm32prog_set_phase(stm32prog_data, phase, address);
|
|
if (ret)
|
|
log_err("failed: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
#define PHASE_MIN_SIZE 9
|
|
static int stm32prog_cmd_read(u64 offset, void *buf, long *len)
|
|
{
|
|
u32 destination = DEFAULT_ADDRESS; /* destination address */
|
|
u32 dfu_offset;
|
|
u8 *pt_buf = buf;
|
|
int phase;
|
|
char *err_msg;
|
|
int length;
|
|
|
|
if (*len < PHASE_MIN_SIZE) {
|
|
log_err("request exceeds allowed area\n");
|
|
return -EINVAL;
|
|
}
|
|
if (offset) {
|
|
*len = 0; /* EOF for second request */
|
|
return 0;
|
|
}
|
|
phase = stm32prog_data->phase;
|
|
if (phase == PHASE_FLASHLAYOUT)
|
|
destination = STM32_DDR_BASE;
|
|
dfu_offset = stm32prog_data->offset;
|
|
|
|
/* mandatory header, size = PHASE_MIN_SIZE */
|
|
*pt_buf++ = (u8)(phase & 0xFF);
|
|
*pt_buf++ = (u8)(destination);
|
|
*pt_buf++ = (u8)(destination >> 8);
|
|
*pt_buf++ = (u8)(destination >> 16);
|
|
*pt_buf++ = (u8)(destination >> 24);
|
|
*pt_buf++ = (u8)(dfu_offset);
|
|
*pt_buf++ = (u8)(dfu_offset >> 8);
|
|
*pt_buf++ = (u8)(dfu_offset >> 16);
|
|
*pt_buf++ = (u8)(dfu_offset >> 24);
|
|
|
|
if (phase == PHASE_RESET || phase == PHASE_DO_RESET) {
|
|
err_msg = stm32prog_get_error(stm32prog_data);
|
|
length = strlen(err_msg);
|
|
if (length + PHASE_MIN_SIZE > *len)
|
|
length = *len - PHASE_MIN_SIZE;
|
|
|
|
memcpy(pt_buf, err_msg, length);
|
|
*len = PHASE_MIN_SIZE + length;
|
|
stm32prog_do_reset(stm32prog_data);
|
|
} else if (phase == PHASE_FLASHLAYOUT) {
|
|
*pt_buf++ = stm32prog_data->part_nb ? 1 : 0;
|
|
*len = PHASE_MIN_SIZE + 1;
|
|
} else {
|
|
*len = PHASE_MIN_SIZE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int stm32prog_write_medium_virt(struct dfu_entity *dfu, u64 offset,
|
|
void *buf, long *len)
|
|
{
|
|
if (dfu->dev_type != DFU_DEV_VIRT)
|
|
return -EINVAL;
|
|
|
|
switch (dfu->data.virt.dev_num) {
|
|
case PHASE_CMD:
|
|
return stm32prog_cmd_write(offset, buf, len);
|
|
|
|
case PHASE_OTP:
|
|
return stm32prog_otp_write(stm32prog_data, (u32)offset,
|
|
buf, len);
|
|
|
|
case PHASE_PMIC:
|
|
return stm32prog_pmic_write(stm32prog_data, (u32)offset,
|
|
buf, len);
|
|
}
|
|
*len = 0;
|
|
return 0;
|
|
}
|
|
|
|
int stm32prog_read_medium_virt(struct dfu_entity *dfu, u64 offset,
|
|
void *buf, long *len)
|
|
{
|
|
if (dfu->dev_type != DFU_DEV_VIRT)
|
|
return -EINVAL;
|
|
|
|
switch (dfu->data.virt.dev_num) {
|
|
case PHASE_CMD:
|
|
return stm32prog_cmd_read(offset, buf, len);
|
|
|
|
case PHASE_OTP:
|
|
return stm32prog_otp_read(stm32prog_data, (u32)offset,
|
|
buf, len);
|
|
|
|
case PHASE_PMIC:
|
|
return stm32prog_pmic_read(stm32prog_data, (u32)offset,
|
|
buf, len);
|
|
}
|
|
*len = 0;
|
|
return 0;
|
|
}
|
|
|
|
int stm32prog_get_medium_size_virt(struct dfu_entity *dfu, u64 *size)
|
|
{
|
|
if (dfu->dev_type != DFU_DEV_VIRT) {
|
|
*size = 0;
|
|
log_debug("%s, invalid dev_type = %d\n",
|
|
__func__, dfu->dev_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
switch (dfu->data.virt.dev_num) {
|
|
case PHASE_CMD:
|
|
*size = 512;
|
|
break;
|
|
case PHASE_OTP:
|
|
*size = OTP_SIZE;
|
|
break;
|
|
case PHASE_PMIC:
|
|
*size = PMIC_SIZE;
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool stm32prog_usb_loop(struct stm32prog_data *data, int dev)
|
|
{
|
|
int ret;
|
|
bool result;
|
|
/* USB download gadget for STM32 Programmer */
|
|
char product[128];
|
|
char name[SOC_NAME_SIZE];
|
|
|
|
get_soc_name(name);
|
|
snprintf(product, sizeof(product),
|
|
"USB download gadget@Device ID /0x%03X, @Revision ID /0x%04X, @Name /%s,",
|
|
get_cpu_dev(), get_cpu_rev(), name);
|
|
g_dnl_set_product(product);
|
|
|
|
if (stm32prog_data->phase == PHASE_FLASHLAYOUT) {
|
|
ret = run_usb_dnl_gadget(dev, "usb_dnl_dfu");
|
|
if (ret || stm32prog_data->phase == PHASE_DO_RESET)
|
|
return ret;
|
|
/* prepare the second enumeration with the FlashLayout */
|
|
if (stm32prog_data->phase == PHASE_FLASHLAYOUT)
|
|
stm32prog_dfu_init(data);
|
|
/* found next selected partition */
|
|
stm32prog_next_phase(data);
|
|
}
|
|
|
|
ret = run_usb_dnl_gadget(dev, "usb_dnl_dfu");
|
|
|
|
result = !!(ret) || (stm32prog_data->phase == PHASE_DO_RESET);
|
|
|
|
g_dnl_set_product(NULL);
|
|
|
|
return result;
|
|
}
|
|
|
|
int g_dnl_get_board_bcd_device_number(int gcnum)
|
|
{
|
|
log_debug("%s\n", __func__);
|
|
return 0x200;
|
|
}
|