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