rk3568 中loader模式的usb驱动是如何调用的呢

一：loader模式

进入lodaer模式需要长按recover按键并重启板子，进入loader模式下载固件，此时需要usb的驱动是正常的

从uboot的启动流程和配置可以知道的board目录的头文件和源文件是适配了很多芯片产商的板卡配置，比如：u-boot\board\rockchip\evb_rk3568，里面就是针对rk3568做的适配。查看源码我们可以看到：

        board_usb_init ：u-boot\board\rockchip\evb_rk3568\evb_rk3568.c

        配置了usb初始化，每一个板卡芯片都有这个

/*
 * SPDX-License-Identifier:     GPL-2.0+
 *
 * (C) Copyright 2020 Rockchip Electronics Co., Ltd
 */

#include <common.h>
#include <dwc3-uboot.h>
#include <usb.h>

DECLARE_GLOBAL_DATA_PTR;

#ifdef CONFIG_USB_DWC3
static struct dwc3_device dwc3_device_data = {
  .maximum_speed = USB_SPEED_HIGH,
  .base = 0xfcc00000,
  .dr_mode = USB_DR_MODE_PERIPHERAL,
  .index = 0,
  .dis_u2_susphy_quirk = 1,
  .usb2_phyif_utmi_width = 16,
};

int usb_gadget_handle_interrupts(void)
{
  dwc3_uboot_handle_interrupt(0);
  return 0;
}

int board_usb_init(int index, enum usb_init_type init)  //操作usb初始化，主要是升级？
{
  return dwc3_uboot_init(&dwc3_device_data);  //u-boot\drivers\usb\dwc3\core.c
}
#endif

全局搜索board_usb_init这个接口在usb2.0和3.0中的驱动程序中调用到：3.0:

xhci_hcd_init : u-boot\drivers\usb\host\xhci-omap.c //但这个是主机模式，升级的时候，板卡应该是设备模式，所以其调用应该在usb_gadget_initialize

int xhci_hcd_init(int index, struct xhci_hccr **hccr, struct xhci_hcor **hcor)
{
  struct omap_xhci *ctx = &omap;
  int ret = 0;

  ctx->hcd = (struct xhci_hccr *)OMAP_XHCI_BASE;
  ctx->dwc3_reg = (struct dwc3 *)((char *)(ctx->hcd) + DWC3_REG_OFFSET);
  ctx->usb3_phy = (struct omap_usb3_phy *)OMAP_OCP1_SCP_BASE;
  ctx->otg_wrapper = (struct omap_dwc_wrapper *)OMAP_OTG_WRAPPER_BASE;

  ret = board_usb_init(index, USB_INIT_HOST);  //初始化主机模式
  if (ret != 0) { 
    puts("Failed to initialize board for USB\n");
    return ret;
  }

  ret = omap_xhci_core_init(ctx);
  if (ret < 0) {
    puts("Failed to initialize xhci\n");
    return ret;
  }

  *hccr = (struct xhci_hccr *)(OMAP_XHCI_BASE);
  *hcor = (struct xhci_hcor *)((uint32_t) *hccr
        + HC_LENGTH(xhci_readl(&(*hccr)->cr_capbase)));

  debug("omap-xhci: init hccr %x and hcor %x hc_length %d\n",
        (uint32_t)*hccr, (uint32_t)*hcor,
        (uint32_t)HC_LENGTH(xhci_readl(&(*hccr)->cr_capbase)));

  return ret;
}

usb_gadget_initialize ：u-boot\include\linux\usb\gadget.h

#if CONFIG_IS_ENABLED(DM_USB_GADGET)
int usb_gadget_initialize(int index);
int usb_gadget_release(int index);
int dm_usb_gadget_handle_interrupts(struct udevice *dev);
#else
#include <usb.h>
static inline int usb_gadget_initialize(int index)
{
  return board_usb_init(index, USB_INIT_DEVICE);  //调用了rk3568。c
}

static inline int usb_gadget_release(int index)
{
  return board_usb_cleanup(index, USB_INIT_DEVICE);
}
#endif

在getgad多个设备函数中调用：

从搜索的结果看，我们不清楚最后调用的接口：可能使用了do_rkusb 这个接口/还是fastboot，调用到的board_usb_init呢?

但是从uboot升级log看，升级走的接口是rk_usb

由此知道流程：

通过按键重启进入升级模式，调用这个setup_download_mode→rkusb

通过run_command("download",0) 会去命令列表中根据字符串“download"查找。U_BOOT_CMD_ALWAYS注册进去的命令

u-boot\cmd\download.c
static int do_download(cmd_tbl_t *cmdtp, int flag,
           int argc, char * const argv[])
{
  disable_ctrlc(1); //升级过程中关闭ctrl_c

  /* Allow board specific download, maybe noreturn */
  do_board_download();

  /* Generic download */
#ifdef CONFIG_CMD_ROCKUSB
//$devtype $devnum" 由U_BOOT_CMD_ALWAYS参数传递进来
  run_command("rockusb 0 $devtype $devnum", 0);
  //执行到rkusb命令去，进入rkusb驱动调用do_rkusb，升级成功后也会自动重启
#endif
  printf("Enter rockusb failed, fallback to bootrom...\n");
  flushc(); //没作用
  run_command("rbrom", 0); //升级失败，进入rom重启

  return 0;
}

U_BOOT_CMD_ALWAYS(  //run_command("download",0)向命令注册回调函数和参数
  download, 1, 1, do_download,
  "enter rockusb/bootrom download mode", ""
);

重启命令：
static int do_reboot_brom(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
  writel(BOOT_BROM_DOWNLOAD, CONFIG_ROCKCHIP_BOOT_MODE_REG); 
//设置寄存器数值：0xfdc20200
  do_reset(NULL, 0, 0, NULL);

  return 0;
}

U_BOOT_CMD_ALWAYS(
  rbrom, 1, 0,  do_reboot_brom,
  "Perform RESET of the CPU",
  ""
);

run_common接口在u-boot\common\cli.c实现，里面是针对命令解析的操作→u-boot\common\cli_hush.c

二 u-boot\cmd\rockusb.c源码：

/*
 * Copyright 2017 Rockchip Electronics Co., Ltd
 * Frank Wang <frank.wang@rock-chips.com>
 *
 * SPDX-License-Identifier:  GPL-2.0+
 */

#include <errno.h>
#include <common.h>
#include <command.h>
#include <console.h>
#include <g_dnl.h>
#include <part.h>
#include <usb.h>
#include <usb_mass_storage.h>
#include <rockusb.h>

static struct rockusb rkusb;
static struct rockusb *g_rkusb;

static int rkusb_read_sector(struct ums *ums_dev,
           ulong start, lbaint_t blkcnt, void *buf)
{
  struct blk_desc *block_dev = &ums_dev->block_dev;
  lbaint_t blkstart = start + ums_dev->start_sector;
  int ret;

  if ((blkstart + blkcnt) > RKUSB_READ_LIMIT_ADDR) {
    memset(buf, 0xcc, blkcnt * SECTOR_SIZE);
    return blkcnt;
  } else {
    ret = blk_dread(block_dev, blkstart, blkcnt, buf);
    if (!ret)
      ret = -EIO;
    return ret;
  }
}

static int rkusb_write_sector(struct ums *ums_dev,
            ulong start, lbaint_t blkcnt, const void *buf)
{
  struct blk_desc *block_dev = &ums_dev->block_dev;
  lbaint_t blkstart = start + ums_dev->start_sector;
  int ret;

  if (block_dev->if_type == IF_TYPE_MTD)
    block_dev->op_flag |= BLK_MTD_CONT_WRITE;

  ret = blk_dwrite(block_dev, blkstart, blkcnt, buf);
  if (!ret)
    ret = -EIO;

  if (block_dev->if_type == IF_TYPE_MTD)
    block_dev->op_flag &= ~(BLK_MTD_CONT_WRITE);
  return ret;
}

static int rkusb_erase_sector(struct ums *ums_dev,
            ulong start, lbaint_t blkcnt)
{
  struct blk_desc *block_dev = &ums_dev->block_dev;
  lbaint_t blkstart = start + ums_dev->start_sector;

  return blk_derase(block_dev, blkstart, blkcnt);
}

static void rkusb_fini(void)
{
  int i;

  for (i = 0; i < g_rkusb->ums_cnt; i++)
    free((void *)g_rkusb->ums[i].name);
  free(g_rkusb->ums);
  g_rkusb->ums = NULL;
  g_rkusb->ums_cnt = 0;
  g_rkusb = NULL;
}

#define RKUSB_NAME_LEN 16

static int rkusb_init(const char *devtype, const char *devnums_part_str)
{
  char *s, *t, *devnum_part_str, *name;
  struct blk_desc *block_dev;
  disk_partition_t info;
  int partnum, cnt;
  int ret = -1;
  struct ums *ums_new;

  s = strdup(devnums_part_str);
  if (!s)
    return -1;

  t = s;
  g_rkusb->ums_cnt = 0;

  for (;;) {
    devnum_part_str = strsep(&t, ",");
    if (!devnum_part_str)
      break;

    partnum = blk_get_device_part_str(devtype, devnum_part_str,
          &block_dev, &info, 1);
    if (partnum < 0)
      goto cleanup;

    /* f_mass_storage.c assumes SECTOR_SIZE sectors */
    if (block_dev->blksz != SECTOR_SIZE)
      goto cleanup;

    ums_new = realloc(g_rkusb->ums, (g_rkusb->ums_cnt + 1) *
          sizeof(*g_rkusb->ums));
    if (!ums_new)
      goto cleanup;
    g_rkusb->ums = ums_new;
    cnt = g_rkusb->ums_cnt;

    /* Expose all partitions for rockusb command */
    g_rkusb->ums[cnt].start_sector = 0;
    g_rkusb->ums[cnt].num_sectors = block_dev->lba;

    g_rkusb->ums[cnt].read_sector = rkusb_read_sector; //给接口注册回调
    g_rkusb->ums[cnt].write_sector = rkusb_write_sector;
    g_rkusb->ums[cnt].erase_sector = rkusb_erase_sector;

    name = malloc(RKUSB_NAME_LEN);
    if (!name)
      goto cleanup;
    snprintf(name, RKUSB_NAME_LEN, "rkusb disk %d", cnt);
    g_rkusb->ums[cnt].name = name;
    g_rkusb->ums[cnt].block_dev = *block_dev;

    printf("RKUSB: LUN %d, dev %d, hwpart %d, sector %#x, count %#x\n",
           g_rkusb->ums_cnt,
           g_rkusb->ums[cnt].block_dev.devnum,
           g_rkusb->ums[cnt].block_dev.hwpart,
           g_rkusb->ums[cnt].start_sector,
           g_rkusb->ums[cnt].num_sectors);

    g_rkusb->ums_cnt++;
  }

  if (g_rkusb->ums_cnt)
    ret = 0;

cleanup:
  free(s);
  if (ret < 0)
    rkusb_fini();

  return ret;
}

static int do_rkusb(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;
  const char *s;

  if (argc != 4)
    return CMD_RET_USAGE;

  usb_controller = argv[1]; //0
  devtype = argv[2]; //这个参数跟上述U_BOOT_CMD_ALWAYS传递的参数一致，应该是1
  devnum  = argv[3]; //也是1
  //解析控制器和操作的mmc节点
  

  if (!strcmp(devtype, "mmc") && !strcmp(devnum, "1")) {
    pr_err("Forbid to flash mmc 1(sdcard)\n");
    return CMD_RET_FAILURE;
  } else if (!strcmp(devtype, "nvme") && !strcmp(devnum, "0")) {
    /*
     * Add partnum ":0" to active 'allow_whole_dev' partition
     * search mechanism on multi storage, where there maybe not
     * valid partition table.
     */
    devnum = "0:0";
  }

  g_rkusb = &rkusb;
  rc = rkusb_init(devtype, devnum);  //注册sector操作
  if (rc < 0)
    return CMD_RET_FAILURE;

  if (g_rkusb->ums[0].block_dev.if_type == IF_TYPE_MTD &&
      g_rkusb->ums[0].block_dev.devnum == BLK_MTD_NAND) {
#ifdef CONFIG_CMD_GO
    pr_err("Enter bootrom rockusb...\n");
    flushc();
    run_command("rbrom", 0);
#else
    pr_err("rockusb: count not support loader upgrade!\n");
#endif
  }

  controller_index = (unsigned int)(simple_strtoul(
        usb_controller,  NULL, 0));
  rc = usb_gadget_initialize(controller_index);  //初始化usb gadget设备，调用到
  //\board\rockchip\evb_rk3568\evb_rk3568.c   的board_usb_init接口，初始化dwc3驱动
  if (rc) {
    pr_err("Couldn't init USB controller.");
    rc = CMD_RET_FAILURE;
    goto cleanup_rkusb;
  }

  rc = fsg_init(g_rkusb->ums, g_rkusb->ums_cnt);
 //初始化大容量操作接口u-boot\drivers\usb\gadget\f_mass_storage.c，并将回调函数通过句柄传递进去
  //从这个接口看，应该是将板卡配置成大容量设备
  if (rc) {
    pr_err("fsg_init failed");
    rc = CMD_RET_FAILURE;
    goto cleanup_board;
  }

  s = env_get("serial#");
  if (s) {
    char *sn = (char *)calloc(strlen(s) + 1, sizeof(char));
    char *sn_p = sn;

    if (!sn)
      goto cleanup_board;

    memcpy(sn, s, strlen(s));
    while (*sn_p) {
      if (*sn_p == '\\' || *sn_p == '/')
        *sn_p = '_';
      sn_p++;
    }

    g_dnl_set_serialnumber(sn);
    free(sn);
  }

  rc = g_dnl_register("rkusb_ums_dnl");
  if (rc) {
    pr_err("g_dnl_register failed");
    rc = CMD_RET_FAILURE;
    goto cleanup_board;
  }

  /* Timeout unit: seconds */
  cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;

  if (!g_dnl_board_usb_cable_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.\nCommand 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);  
    //\board\rockchip\evb_rk3568\evb_rk3568.c里面的
    //usb_gadget_handle_interrupts

    rc = fsg_main_thread(NULL);  
    //执行升级数据，调用到u-boot\drivers\usb\gadget\f_mass_storage.c
    //开启升级线程？
    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:
  usb_gadget_release(controller_index);
cleanup_rkusb:
  rkusb_fini();

  return rc;
}

U_BOOT_CMD_ALWAYS(rockusb, 4, 1, do_rkusb,
      "Use the rockusb Protocol",
      "<USB_controller> <devtype> <dev[:part]>  e.g. rockusb 0 mmc 0\n"
);