cmd/usb_mass_storage.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2011 Samsung Electronics
   4  * Lukasz Majewski <l.majewski@samsung.com>
   5  *
   6  * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved.
   7  */
   8
   9 #include <errno.h>
  10 #include <common.h>
  11 #include <command.h>
  12 #include <console.h>
  13 #include <g_dnl.h>
  14 #include <malloc.h>
  15 #include <part.h>
  16 #include <usb.h>
  17 #include <usb_mass_storage.h>
  18 #include <watchdog.h>
  19
  20 static int ums_read_sector(struct ums *ums_dev,
  21                            ulong start, lbaint_t blkcnt, void *buf)
  22 {
  23         struct blk_desc *block_dev = &ums_dev->block_dev;
  24         lbaint_t blkstart = start + ums_dev->start_sector;
  25
  26         return blk_dread(block_dev, blkstart, blkcnt, buf);
  27 }
  28
  29 static int ums_write_sector(struct ums *ums_dev,
  30                             ulong start, lbaint_t blkcnt, const void *buf)
  31 {
  32         struct blk_desc *block_dev = &ums_dev->block_dev;
  33         lbaint_t blkstart = start + ums_dev->start_sector;
  34
  35         return blk_dwrite(block_dev, blkstart, blkcnt, buf);
  36 }
  37
  38 static struct ums *ums;
  39 static int ums_count;
  40
  41 static void ums_fini(void)
  42 {
  43         int i;
  44
  45         for (i = 0; i < ums_count; i++)
  46                 free((void *)ums[i].name);
  47         free(ums);
  48         ums = NULL;
  49         ums_count = 0;
  50 }
  51
  52 #define UMS_NAME_LEN 16
  53
  54 static int ums_init(const char *devtype, const char *devnums_part_str)
  55 {
  56         char *s, *t, *devnum_part_str, *name;
  57         struct blk_desc *block_dev;
  58         disk_partition_t info;
  59         int partnum;
  60         int ret = -1;
  61         struct ums *ums_new;
  62
  63         s = strdup(devnums_part_str);
  64         if (!s)
  65                 return -1;
  66
  67         t = s;
  68         ums_count = 0;
  69
  70         for (;;) {
  71                 devnum_part_str = strsep(&t, ",");
  72                 if (!devnum_part_str)
  73                         break;
  74
  75                 partnum = blk_get_device_part_str(devtype, devnum_part_str,
  76                                         &block_dev, &info, 1);
  77
  78                 if (partnum < 0)
  79                         goto cleanup;
  80
  81                 /* Check if the argument is in legacy format. If yes,
  82                  * expose all partitions by setting the partnum = 0
  83                  * e.g. ums 0 mmc 0
  84                  */
  85                 if (!strchr(devnum_part_str, ':'))
  86                         partnum = 0;
  87
  88                 /* f_mass_storage.c assumes SECTOR_SIZE sectors */
  89                 if (block_dev->blksz != SECTOR_SIZE)
  90                         goto cleanup;
  91
  92                 ums_new = realloc(ums, (ums_count + 1) * sizeof(*ums));
  93                 if (!ums_new)
  94                         goto cleanup;
  95                 ums = ums_new;
  96
  97                 /* if partnum = 0, expose all partitions */
  98                 if (partnum == 0) {
  99                         ums[ums_count].start_sector = 0;
 100                         ums[ums_count].num_sectors = block_dev->lba;
 101                 } else {
 102                         ums[ums_count].start_sector = info.start;
 103                         ums[ums_count].num_sectors = info.size;
 104                 }
 105
 106                 ums[ums_count].read_sector = ums_read_sector;
 107                 ums[ums_count].write_sector = ums_write_sector;
 108
 109                 name = malloc(UMS_NAME_LEN);
 110                 if (!name)
 111                         goto cleanup;
 112                 snprintf(name, UMS_NAME_LEN, "UMS disk %d", ums_count);
 113                 ums[ums_count].name = name;
 114                 ums[ums_count].block_dev = *block_dev;
 115
 116                 printf("UMS: LUN %d, dev %d, hwpart %d, sector %#x, count %#x\n",
 117                        ums_count, ums[ums_count].block_dev.devnum,
 118                        ums[ums_count].block_dev.hwpart,
 119                        ums[ums_count].start_sector,
 120                        ums[ums_count].num_sectors);
 121
 122                 ums_count++;
 123         }
 124
 125         if (ums_count)
 126                 ret = 0;
 127
 128 cleanup:
 129         free(s);
 130
 131         if (ret < 0)
 132                 ums_fini();
 133
 134         return ret;
 135 }
 136
 137 static int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
 138                                int argc, char * const argv[])
 139 {
 140         const char *usb_controller;
 141         const char *devtype;
 142         const char *devnum;
 143         unsigned int controller_index;
 144         int rc;
 145         int cable_ready_timeout __maybe_unused;
 146
 147         if (argc < 3)
 148                 return CMD_RET_USAGE;
 149
 150         usb_controller = argv[1];
 151         if (argc >= 4) {
 152                 devtype = argv[2];
 153                 devnum  = argv[3];
 154         } else {
 155                 devtype = "mmc";
 156                 devnum  = argv[2];
 157         }
 158
 159         rc = ums_init(devtype, devnum);
 160         if (rc < 0)
 161                 return CMD_RET_FAILURE;
 162
 163         controller_index = (unsigned int)(simple_strtoul(
 164                                 usb_controller, NULL, 0));
 165         if (usb_gadget_initialize(controller_index)) {
 166                 pr_err("Couldn't init USB controller.\n");
 167                 rc = CMD_RET_FAILURE;
 168                 goto cleanup_ums_init;
 169         }
 170
 171         rc = fsg_init(ums, ums_count);
 172         if (rc) {
 173                 pr_err("fsg_init failed\n");
 174                 rc = CMD_RET_FAILURE;
 175                 goto cleanup_board;
 176         }
 177
 178         rc = g_dnl_register("usb_dnl_ums");
 179         if (rc) {
 180                 pr_err("g_dnl_register failed\n");
 181                 rc = CMD_RET_FAILURE;
 182                 goto cleanup_board;
 183         }
 184
 185         /* Timeout unit: seconds */
 186         cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
 187
 188         if (!g_dnl_board_usb_cable_connected()) {
 189                 /*
 190                  * Won't execute if we don't know whether the cable is
 191                  * connected.
 192                  */
 193                 puts("Please connect USB cable.\n");
 194
 195                 while (!g_dnl_board_usb_cable_connected()) {
 196                         if (ctrlc()) {
 197                                 puts("\rCTRL+C - Operation aborted.\n");
 198                                 rc = CMD_RET_SUCCESS;
 199                                 goto cleanup_register;
 200                         }
 201                         if (!cable_ready_timeout) {
 202                                 puts("\rUSB cable not detected.\n" \
 203                                      "Command exit.\n");
 204                                 rc = CMD_RET_SUCCESS;
 205                                 goto cleanup_register;
 206                         }
 207
 208                         printf("\rAuto exit in: %.2d s.", cable_ready_timeout);
 209                         mdelay(1000);
 210                         cable_ready_timeout--;
 211                 }
 212                 puts("\r\n");
 213         }
 214
 215         while (1) {
 216                 usb_gadget_handle_interrupts(controller_index);
 217
 218                 rc = fsg_main_thread(NULL);
 219                 if (rc) {
 220                         /* Check I/O error */
 221                         if (rc == -EIO)
 222                                 printf("\rCheck USB cable connection\n");
 223
 224                         /* Check CTRL+C */
 225                         if (rc == -EPIPE)
 226                                 printf("\rCTRL+C - Operation aborted\n");
 227
 228                         rc = CMD_RET_SUCCESS;
 229                         goto cleanup_register;
 230                 }
 231
 232                 WATCHDOG_RESET();
 233         }
 234
 235 cleanup_register:
 236         g_dnl_unregister();
 237 cleanup_board:
 238         usb_gadget_release(controller_index);
 239 cleanup_ums_init:
 240         ums_fini();
 241
 242         return rc;
 243 }
 244
 245 U_BOOT_CMD(ums, 4, 1, do_usb_mass_storage,
 246         "Use the UMS [USB Mass Storage]",
 247         "<USB_controller> [<devtype>] <dev[:part]>  e.g. ums 0 mmc 0\n"
 248         "    devtype defaults to mmc"
 249 );