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