usb_mass_storage.c 4.8 KB

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