dm: blk: Rename get_device() to blk_get_device_by_str()
[platform/kernel/u-boot.git] / cmd / usb_mass_storage.c
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 block_dev->block_read(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 block_dev->block_write(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 = 0;
48         ums_count = 0;
49 }
50
51 #define UMS_NAME_LEN 16
52
53 static int ums_init(const char *devtype, const char *devnums)
54 {
55         char *s, *t, *devnum, *name;
56         struct blk_desc *block_dev;
57         int ret;
58         struct ums *ums_new;
59
60         s = strdup(devnums);
61         if (!s)
62                 return -1;
63
64         t = s;
65         ums_count = 0;
66
67         for (;;) {
68                 devnum = strsep(&t, ",");
69                 if (!devnum)
70                         break;
71
72                 ret = blk_get_device_by_str(devtype, devnum, &block_dev);
73                 if (ret < 0)
74                         goto cleanup;
75
76                 /* f_mass_storage.c assumes SECTOR_SIZE sectors */
77                 if (block_dev->blksz != SECTOR_SIZE) {
78                         ret = -1;
79                         goto cleanup;
80                 }
81
82                 ums_new = realloc(ums, (ums_count + 1) * sizeof(*ums));
83                 if (!ums_new) {
84                         ret = -1;
85                         goto cleanup;
86                 }
87                 ums = ums_new;
88
89                 ums[ums_count].read_sector = ums_read_sector;
90                 ums[ums_count].write_sector = ums_write_sector;
91                 ums[ums_count].start_sector = 0;
92                 ums[ums_count].num_sectors = block_dev->lba;
93                 name = malloc(UMS_NAME_LEN);
94                 if (!name) {
95                         ret = -1;
96                         goto cleanup;
97                 }
98                 snprintf(name, UMS_NAME_LEN, "UMS disk %d", ums_count);
99                 ums[ums_count].name = name;
100                 ums[ums_count].block_dev = *block_dev;
101
102                 printf("UMS: LUN %d, dev %d, hwpart %d, sector %#x, count %#x\n",
103                        ums_count, ums[ums_count].block_dev.dev,
104                        ums[ums_count].block_dev.hwpart,
105                        ums[ums_count].start_sector,
106                        ums[ums_count].num_sectors);
107
108                 ums_count++;
109         }
110
111         if (!ums_count)
112                 ret = -1;
113         else
114                 ret = 0;
115
116 cleanup:
117         free(s);
118
119         if (ret < 0)
120                 ums_fini();
121
122         return ret;
123 }
124
125 int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
126                                int argc, char * const argv[])
127 {
128         const char *usb_controller;
129         const char *devtype;
130         const char *devnum;
131         unsigned int controller_index;
132         int rc;
133         int cable_ready_timeout __maybe_unused;
134
135         if (argc < 3)
136                 return CMD_RET_USAGE;
137
138         usb_controller = argv[1];
139         if (argc >= 4) {
140                 devtype = argv[2];
141                 devnum  = argv[3];
142         } else {
143                 devtype = "mmc";
144                 devnum  = argv[2];
145         }
146
147         rc = ums_init(devtype, devnum);
148         if (rc < 0)
149                 return CMD_RET_FAILURE;
150
151         controller_index = (unsigned int)(simple_strtoul(
152                                 usb_controller, NULL, 0));
153         if (board_usb_init(controller_index, USB_INIT_DEVICE)) {
154                 error("Couldn't init USB controller.");
155                 rc = CMD_RET_FAILURE;
156                 goto cleanup_ums_init;
157         }
158
159         rc = fsg_init(ums, ums_count);
160         if (rc) {
161                 error("fsg_init failed");
162                 rc = CMD_RET_FAILURE;
163                 goto cleanup_board;
164         }
165
166         rc = g_dnl_register("usb_dnl_ums");
167         if (rc) {
168                 error("g_dnl_register failed");
169                 rc = CMD_RET_FAILURE;
170                 goto cleanup_board;
171         }
172
173         /* Timeout unit: seconds */
174         cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
175
176         if (!g_dnl_board_usb_cable_connected()) {
177                 /*
178                  * Won't execute if we don't know whether the cable is
179                  * connected.
180                  */
181                 puts("Please connect USB cable.\n");
182
183                 while (!g_dnl_board_usb_cable_connected()) {
184                         if (ctrlc()) {
185                                 puts("\rCTRL+C - Operation aborted.\n");
186                                 rc = CMD_RET_SUCCESS;
187                                 goto cleanup_register;
188                         }
189                         if (!cable_ready_timeout) {
190                                 puts("\rUSB cable not detected.\n" \
191                                      "Command exit.\n");
192                                 rc = CMD_RET_SUCCESS;
193                                 goto cleanup_register;
194                         }
195
196                         printf("\rAuto exit in: %.2d s.", cable_ready_timeout);
197                         mdelay(1000);
198                         cable_ready_timeout--;
199                 }
200                 puts("\r\n");
201         }
202
203         while (1) {
204                 usb_gadget_handle_interrupts(controller_index);
205
206                 rc = fsg_main_thread(NULL);
207                 if (rc) {
208                         /* Check I/O error */
209                         if (rc == -EIO)
210                                 printf("\rCheck USB cable connection\n");
211
212                         /* Check CTRL+C */
213                         if (rc == -EPIPE)
214                                 printf("\rCTRL+C - Operation aborted\n");
215
216                         rc = CMD_RET_SUCCESS;
217                         goto cleanup_register;
218                 }
219         }
220
221 cleanup_register:
222         g_dnl_unregister();
223 cleanup_board:
224         board_usb_cleanup(controller_index, USB_INIT_DEVICE);
225 cleanup_ums_init:
226         ums_fini();
227
228         return rc;
229 }
230
231 U_BOOT_CMD(ums, 4, 1, do_usb_mass_storage,
232         "Use the UMS [USB Mass Storage]",
233         "<USB_controller> [<devtype>] <devnum>  e.g. ums 0 mmc 0\n"
234         "    devtype defaults to mmc"
235 );