static int process_rqt_cmd(const struct rqt_box *rqt)
{
ALLOC_CACHE_ALIGN_BUFFER(struct rsp_box, rsp, sizeof(struct rsp_box));
memset(rsp, 0, sizeof(struct rsp_box));
rsp->rsp = rqt->rqt;
rsp->rsp_data = rqt->rqt_data;
switch (rqt->rqt_data) {
case RQT_CMD_REBOOT:
debug("TARGET RESET\n");
send_rsp(rsp);
g_dnl_unregister();
dfu_free_entities();
#ifdef CONFIG_THOR_RESET_OFF
return RESET_DONE;
#endif
run_command("reset", 0);
break;
case RQT_CMD_POWEROFF:
case RQT_CMD_EFSCLEAR:
send_rsp(rsp);
default:
printf("Command not supported -> cmd: %d\n", rqt->rqt_data);
return -EINVAL;
}
return true;
}
static int do_fastboot_usb(int argc, char *const argv[],
uintptr_t buf_addr, size_t buf_size)
{
#if CONFIG_IS_ENABLED(USB_FUNCTION_FASTBOOT)
int controller_index;
char *usb_controller;
char *endp;
int ret;
if (argc < 2)
return CMD_RET_USAGE;
usb_controller = argv[1];
controller_index = simple_strtoul(usb_controller, &endp, 0);
if (*endp != '\0') {
pr_err("Error: Wrong USB controller index format\n");
return CMD_RET_FAILURE;
}
ret = usb_gadget_initialize(controller_index);
if (ret) {
pr_err("USB init failed: %d\n", ret);
return CMD_RET_FAILURE;
}
g_dnl_clear_detach();
ret = g_dnl_register("usb_dnl_fastboot");
if (ret)
return ret;
if (!g_dnl_board_usb_cable_connected()) {
puts("\rUSB cable not detected.\n" \
"Command exit.\n");
ret = CMD_RET_FAILURE;
goto exit;
}
while (1) {
if (g_dnl_detach())
break;
if (ctrlc())
break;
WATCHDOG_RESET();
usb_gadget_handle_interrupts(controller_index);
}
ret = CMD_RET_SUCCESS;
exit:
g_dnl_unregister();
g_dnl_clear_detach();
usb_gadget_release(controller_index);
return ret;
#else
pr_err("Fastboot USB not enabled\n");
return CMD_RET_FAILURE;
#endif
}
static int do_rockusb(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
int controller_index, dev_index;
char *usb_controller;
char *devtype;
char *devnum;
int ret;
if (argc < 2)
return CMD_RET_USAGE;
usb_controller = argv[1];
controller_index = simple_strtoul(usb_controller, NULL, 0);
if (argc >= 4) {
devtype = argv[2];
devnum = argv[3];
} else {
return CMD_RET_USAGE;
}
dev_index = simple_strtoul(devnum, NULL, 0);
rockusb_dev_init(devtype, dev_index);
ret = usb_gadget_initialize(controller_index);
if (ret) {
printf("USB init failed: %d\n", ret);
return CMD_RET_FAILURE;
}
g_dnl_clear_detach();
ret = g_dnl_register("usb_dnl_rockusb");
if (ret)
return CMD_RET_FAILURE;
if (!g_dnl_board_usb_cable_connected()) {
puts("\rUSB cable not detected, Command exit.\n");
ret = CMD_RET_FAILURE;
goto exit;
}
while (1) {
if (g_dnl_detach())
break;
if (ctrlc())
break;
usb_gadget_handle_interrupts(controller_index);
}
ret = CMD_RET_SUCCESS;
exit:
g_dnl_unregister();
g_dnl_clear_detach();
usb_gadget_release(controller_index);
return ret;
}
int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
{
char *ep;
unsigned int dev_num = 0, offset = 0, part_size = 0;
int rc;
struct ums_board_info *ums_info;
static char *s = "ums";
if (argc < 2) {
printf("usage: ums <dev> - e.g. ums 0\n");
return 0;
}
dev_num = (int)simple_strtoul(argv[1], &ep, 16);
if (dev_num) {
puts("\nSet eMMC device to 0! - e.g. ums 0\n");
goto fail;
}
board_usb_init();
ums_info = board_ums_init(dev_num, offset, part_size);
if (!ums_info) {
printf("MMC: %d -> NOT available\n", dev_num);
goto fail;
}
rc = fsg_init(ums_info);
if (rc) {
printf("cmd ums: fsg_init failed\n");
goto fail;
}
g_dnl_register(s);
while (1) {
/* Handle control-c and timeouts */
if (ctrlc()) {
printf("The remote end did not respond in time.\n");
goto exit;
}
usb_gadget_handle_interrupts();
/* Check if USB cable has been detached */
if (fsg_main_thread(NULL) == EIO)
goto exit;
}
exit:
g_dnl_unregister();
return 0;
fail:
return -1;
}
static int do_dfu(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 4)
return CMD_RET_USAGE;
char *usb_controller = argv[1];
char *interface = argv[2];
char *devstring = argv[3];
int ret, i = 0;
ret = dfu_init_env_entities(interface, simple_strtoul(devstring,
NULL, 10));
if (ret)
goto done;
ret = CMD_RET_SUCCESS;
if (argc > 4 && strcmp(argv[4], "list") == 0) {
dfu_show_entities();
goto done;
}
int controller_index = simple_strtoul(usb_controller, NULL, 0);
board_usb_init(controller_index, USB_INIT_DEVICE);
g_dnl_register("usb_dnl_dfu");
while (1) {
if (dfu_reset())
/*
* This extra number of usb_gadget_handle_interrupts()
* calls is necessary to assure correct transmission
* completion with dfu-util
*/
if (++i == 10)
goto exit;
if (ctrlc())
goto exit;
usb_gadget_handle_interrupts();
}
exit:
g_dnl_unregister();
done:
dfu_free_entities();
if (dfu_reset())
run_command("reset", 0);
return ret;
}
int do_thor_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 4)
return CMD_RET_USAGE;
char *usb_controller = argv[1];
char *interface = argv[2];
char *devstring = argv[3];
int ret;
puts("TIZEN \"THOR\" Downloader\n");
ret = dfu_init_env_entities(interface, devstring);
if (ret)
goto done;
int controller_index = simple_strtoul(usb_controller, NULL, 0);
ret = board_usb_init(controller_index, USB_INIT_DEVICE);
if (ret) {
pr_err("USB init failed: %d\n", ret);
ret = CMD_RET_FAILURE;
goto exit;
}
g_dnl_register("usb_dnl_thor");
ret = thor_init();
if (ret) {
pr_err("THOR DOWNLOAD failed: %d\n", ret);
ret = CMD_RET_FAILURE;
goto exit;
}
ret = thor_handle();
if (ret) {
pr_err("THOR failed: %d\n", ret);
ret = CMD_RET_FAILURE;
goto exit;
}
exit:
g_dnl_unregister();
board_usb_cleanup(controller_index, USB_INIT_DEVICE);
done:
dfu_free_entities();
return ret;
}
static int do_dfu(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
const char *str_env;
char s[] = "dfu";
char *env_bkp;
int ret;
if (argc < 3)
return CMD_RET_USAGE;
str_env = getenv("dfu_alt_info");
if (str_env == NULL) {
printf("%s: \"dfu_alt_info\" env variable not defined!\n",
__func__);
return CMD_RET_FAILURE;
}
env_bkp = strdup(str_env);
ret = dfu_config_entities(env_bkp, argv[1],
(int)simple_strtoul(argv[2], NULL, 10));
if (ret)
return CMD_RET_FAILURE;
if (argc > 3 && strcmp(argv[3], "list") == 0) {
dfu_show_entities();
goto done;
}
#ifdef CONFIG_TRATS
board_usb_init();
#endif
g_dnl_register(s);
while (1) {
if (ctrlc())
goto exit;
usb_gadget_handle_interrupts();
}
exit:
g_dnl_unregister();
done:
dfu_free_entities();
free(env_bkp);
return CMD_RET_SUCCESS;
}
static int do_fastboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
ret = g_dnl_register("usb_dnl_fastboot");
if (ret)
return ret;
while (1) {
if (ctrlc())
break;
usb_gadget_handle_interrupts();
}
g_dnl_unregister();
return CMD_RET_SUCCESS;
}
int run_usb_dnl_gadget(int usbctrl_index, char *usb_dnl_gadget)
{
bool dfu_reset = false;
int ret, i = 0;
ret = board_usb_init(usbctrl_index, USB_INIT_DEVICE);
if (ret) {
pr_err("board usb init failed\n");
return CMD_RET_FAILURE;
}
g_dnl_clear_detach();
ret = g_dnl_register(usb_dnl_gadget);
if (ret) {
pr_err("g_dnl_register failed");
return CMD_RET_FAILURE;
}
while (1) {
if (g_dnl_detach()) {
/*
* Check if USB bus reset is performed after detach,
* which indicates that -R switch has been passed to
* dfu-util. In this case reboot the device
*/
if (dfu_usb_get_reset()) {
dfu_reset = true;
goto exit;
}
/*
* This extra number of usb_gadget_handle_interrupts()
* calls is necessary to assure correct transmission
* completion with dfu-util
*/
if (++i == 10000)
goto exit;
}
if (ctrlc())
goto exit;
if (dfu_get_defer_flush()) {
/*
* Call to usb_gadget_handle_interrupts() is necessary
* to act on ZLP OUT transaction from HOST PC after
* transmitting the whole file.
*
* If this ZLP OUT packet is NAK'ed, the HOST libusb
* function fails after timeout (by default it is set to
* 5 seconds). In such situation the dfu-util program
* exits with error message.
*/
usb_gadget_handle_interrupts(usbctrl_index);
ret = dfu_flush(dfu_get_defer_flush(), NULL, 0, 0);
dfu_set_defer_flush(NULL);
if (ret) {
pr_err("Deferred dfu_flush() failed!");
goto exit;
}
}
WATCHDOG_RESET();
usb_gadget_handle_interrupts(usbctrl_index);
}
exit:
g_dnl_unregister();
board_usb_cleanup(usbctrl_index, USB_INIT_DEVICE);
if (dfu_reset)
do_reset(NULL, 0, 0, NULL);
g_dnl_clear_detach();
return ret;
}
static int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
{
const char *usb_controller;
const char *devtype;
const char *devnum;
unsigned int controller_index;
int rc;
int cable_ready_timeout __maybe_unused;
if (argc < 3)
return CMD_RET_USAGE;
usb_controller = argv[1];
if (argc >= 4) {
devtype = argv[2];
devnum = argv[3];
} else {
devtype = "mmc";
devnum = argv[2];
}
rc = ums_init(devtype, devnum);
if (rc < 0)
return CMD_RET_FAILURE;
controller_index = (unsigned int)(simple_strtoul(
usb_controller, NULL, 0));
if (board_usb_init(controller_index, USB_INIT_DEVICE)) {
pr_err("Couldn't init USB controller.\n");
rc = CMD_RET_FAILURE;
goto cleanup_ums_init;
}
rc = fsg_init(ums, ums_count);
if (rc) {
pr_err("fsg_init failed\n");
rc = CMD_RET_FAILURE;
goto cleanup_board;
}
rc = g_dnl_register("usb_dnl_ums");
if (rc) {
pr_err("g_dnl_register failed\n");
rc = CMD_RET_FAILURE;
goto cleanup_board;
}
/* Timeout unit: seconds */
cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
if (!g_dnl_board_usb_cable_connected()) {
/*
* Won't execute if we don't know whether the cable is
* connected.
*/
puts("Please connect USB cable.\n");
while (!g_dnl_board_usb_cable_connected()) {
if (ctrlc()) {
puts("\rCTRL+C - Operation aborted.\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
if (!cable_ready_timeout) {
puts("\rUSB cable not detected.\n" \
"Command exit.\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
printf("\rAuto exit in: %.2d s.", cable_ready_timeout);
mdelay(1000);
cable_ready_timeout--;
}
puts("\r\n");
}
while (1) {
usb_gadget_handle_interrupts(controller_index);
rc = fsg_main_thread(NULL);
if (rc) {
/* Check I/O error */
if (rc == -EIO)
printf("\rCheck USB cable connection\n");
/* Check CTRL+C */
if (rc == -EPIPE)
printf("\rCTRL+C - Operation aborted\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
}
cleanup_register:
g_dnl_unregister();
cleanup_board:
board_usb_cleanup(controller_index, USB_INIT_DEVICE);
cleanup_ums_init:
ums_fini();
return rc;
}
static int do_dfu(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
bool dfu_reset = false;
if (argc < 4)
return CMD_RET_USAGE;
char *usb_controller = argv[1];
char *interface = argv[2];
char *devstring = argv[3];
int ret, i = 0;
ret = dfu_init_env_entities(interface, devstring);
if (ret)
goto done;
ret = CMD_RET_SUCCESS;
if (argc > 4 && strcmp(argv[4], "list") == 0) {
dfu_show_entities();
goto done;
}
int controller_index = simple_strtoul(usb_controller, NULL, 0);
board_usb_init(controller_index, USB_INIT_DEVICE);
g_dnl_clear_detach();
g_dnl_register("usb_dnl_dfu");
while (1) {
if (g_dnl_detach()) {
/*
* Check if USB bus reset is performed after detach,
* which indicates that -R switch has been passed to
* dfu-util. In this case reboot the device
*/
if (dfu_usb_get_reset()) {
dfu_reset = true;
goto exit;
}
/*
* This extra number of usb_gadget_handle_interrupts()
* calls is necessary to assure correct transmission
* completion with dfu-util
*/
if (++i == 10000)
goto exit;
}
if (ctrlc())
goto exit;
WATCHDOG_RESET();
usb_gadget_handle_interrupts(controller_index);
}
exit:
g_dnl_unregister();
board_usb_cleanup(controller_index, USB_INIT_DEVICE);
done:
dfu_free_entities();
if (dfu_reset)
run_command("reset", 0);
g_dnl_clear_detach();
return ret;
}
