1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2023 Addiva Elektronik
4 * Author: Tobias Waldekranz <tobias@waldekranz.com>
5 */
6
7 #include <blk.h>
8 #include <blkmap.h>
9 #include <command.h>
10 #include <env.h>
11 #include <malloc.h>
12 #include <dm/device.h>
13
14 static int blkmap_curr_dev;
15
16 struct map_ctx {
17 struct udevice *dev;
18 lbaint_t blknr, blkcnt;
19 };
20
21 typedef int (*map_parser_fn)(struct map_ctx *ctx, int argc, char *const argv[]);
22
23 struct map_handler {
24 const char *name;
25 map_parser_fn fn;
26 };
27
do_blkmap_map_linear(struct map_ctx * ctx,int argc,char * const argv[])28 static int do_blkmap_map_linear(struct map_ctx *ctx, int argc,
29 char *const argv[])
30 {
31 struct blk_desc *lbd;
32 int err, ldevnum;
33 lbaint_t lblknr;
34
35 if (argc < 4)
36 return CMD_RET_USAGE;
37
38 ldevnum = dectoul(argv[2], NULL);
39 lblknr = dectoul(argv[3], NULL);
40
41 lbd = blk_get_devnum_by_uclass_idname(argv[1], ldevnum);
42 if (!lbd) {
43 printf("Found no device matching \"%s %d\"\n",
44 argv[1], ldevnum);
45 return CMD_RET_FAILURE;
46 }
47
48 err = blkmap_map_linear(ctx->dev, ctx->blknr, ctx->blkcnt,
49 lbd->bdev, lblknr);
50 if (err) {
51 printf("Unable to map \"%s %d\" at block 0x" LBAF ": %d\n",
52 argv[1], ldevnum, ctx->blknr, err);
53
54 return CMD_RET_FAILURE;
55 }
56
57 printf("Block 0x" LBAF "+0x" LBAF " mapped to block 0x" LBAF " of \"%s %d\"\n",
58 ctx->blknr, ctx->blkcnt, lblknr, argv[1], ldevnum);
59 return CMD_RET_SUCCESS;
60 }
61
do_blkmap_map_mem(struct map_ctx * ctx,int argc,char * const argv[])62 static int do_blkmap_map_mem(struct map_ctx *ctx, int argc, char *const argv[])
63 {
64 phys_addr_t addr;
65 int err;
66 bool preserve = false;
67
68 if (argc < 2)
69 return CMD_RET_USAGE;
70
71 addr = hextoul(argv[1], NULL);
72
73 if (argc == 3 && !strcmp(argv[2], "preserve"))
74 preserve = true;
75
76 err = blkmap_map_pmem(ctx->dev, ctx->blknr, ctx->blkcnt, addr,
77 preserve);
78 if (err) {
79 printf("Unable to map %#llx at block 0x" LBAF ": %d\n",
80 (unsigned long long)addr, ctx->blknr, err);
81 return CMD_RET_FAILURE;
82 }
83
84 printf("Block 0x" LBAF "+0x" LBAF " mapped to %#llx\n",
85 ctx->blknr, ctx->blkcnt, (unsigned long long)addr);
86 return CMD_RET_SUCCESS;
87 }
88
89 static struct map_handler map_handlers[] = {
90 { .name = "linear", .fn = do_blkmap_map_linear },
91 { .name = "mem", .fn = do_blkmap_map_mem },
92
93 { .name = NULL }
94 };
95
do_blkmap_map(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])96 static int do_blkmap_map(struct cmd_tbl *cmdtp, int flag,
97 int argc, char *const argv[])
98 {
99 struct map_handler *handler;
100 struct map_ctx ctx;
101
102 if (argc < 5)
103 return CMD_RET_USAGE;
104
105 ctx.dev = blkmap_from_label(argv[1]);
106 if (!ctx.dev) {
107 printf("\"%s\" is not the name of any known blkmap\n", argv[1]);
108 return CMD_RET_FAILURE;
109 }
110
111 ctx.blknr = hextoul(argv[2], NULL);
112 ctx.blkcnt = hextoul(argv[3], NULL);
113 argc -= 4;
114 argv += 4;
115
116 for (handler = map_handlers; handler->name; handler++) {
117 if (!strcmp(handler->name, argv[0]))
118 return handler->fn(&ctx, argc, argv);
119 }
120
121 printf("Unknown map type \"%s\"\n", argv[0]);
122 return CMD_RET_USAGE;
123 }
124
do_blkmap_create(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])125 static int do_blkmap_create(struct cmd_tbl *cmdtp, int flag,
126 int argc, char *const argv[])
127 {
128 const char *label;
129 int err;
130
131 if (argc != 2)
132 return CMD_RET_USAGE;
133
134 label = argv[1];
135
136 err = blkmap_create(label, NULL);
137 if (err) {
138 printf("Unable to create \"%s\": %d\n", label, err);
139 return CMD_RET_FAILURE;
140 }
141
142 printf("Created \"%s\"\n", label);
143 return CMD_RET_SUCCESS;
144 }
145
do_blkmap_destroy(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])146 static int do_blkmap_destroy(struct cmd_tbl *cmdtp, int flag,
147 int argc, char *const argv[])
148 {
149 struct udevice *dev;
150 const char *label;
151 int err;
152
153 if (argc != 2)
154 return CMD_RET_USAGE;
155
156 label = argv[1];
157
158 dev = blkmap_from_label(label);
159 if (!dev) {
160 printf("\"%s\" is not the name of any known blkmap\n", label);
161 return CMD_RET_FAILURE;
162 }
163
164 err = blkmap_destroy(dev);
165 if (err) {
166 printf("Unable to destroy \"%s\": %d\n", label, err);
167 return CMD_RET_FAILURE;
168 }
169
170 printf("Destroyed \"%s\"\n", label);
171 return CMD_RET_SUCCESS;
172 }
173
do_blkmap_get(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])174 static int do_blkmap_get(struct cmd_tbl *cmdtp, int flag,
175 int argc, char *const argv[])
176 {
177 struct udevice *dev;
178 const char *label;
179 int err;
180
181 if (argc < 3)
182 return CMD_RET_USAGE;
183
184 label = argv[1];
185
186 dev = blkmap_from_label(label);
187 if (!dev) {
188 printf("\"%s\" is not the name of any known blkmap\n", label);
189 return CMD_RET_FAILURE;
190 }
191
192 if (!strcmp(argv[2], "dev")) {
193 if (argc == 3) {
194 printf("%d\n", dev_seq(dev));
195 } else {
196 err = env_set_hex(argv[3], dev_seq(dev));
197 if (err)
198 return CMD_RET_FAILURE;
199 }
200 } else {
201 return CMD_RET_USAGE;
202 }
203
204 return CMD_RET_SUCCESS;
205 }
206
do_blkmap_common(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])207 static int do_blkmap_common(struct cmd_tbl *cmdtp, int flag,
208 int argc, char *const argv[])
209 {
210 /* The subcommand parsing pops the original argv[0] ("blkmap")
211 * which blk_common_cmd expects. Push it back again.
212 */
213 argc++;
214 argv--;
215
216 return blk_common_cmd(argc, argv, UCLASS_BLKMAP, &blkmap_curr_dev);
217 }
218
219 U_BOOT_CMD_WITH_SUBCMDS(
220 blkmap, "Composeable virtual block devices",
221 "info - list configured devices\n"
222 "blkmap part - list available partitions on current blkmap device\n"
223 "blkmap dev [<dev>] - show or set current blkmap device\n"
224 "blkmap read <addr> <blk#> <cnt>\n"
225 "blkmap write <addr> <blk#> <cnt>\n"
226 "blkmap get <label> dev [<var>] - store device number in variable\n"
227 "blkmap create <label> - create device\n"
228 "blkmap destroy <label> - destroy device\n"
229 "blkmap map <label> <blk#> <cnt> linear <interface> <dev> <blk#> - device mapping\n"
230 "blkmap map <label> <blk#> <cnt> mem <addr> [preserve] - memory mapping\n",
231 U_BOOT_SUBCMD_MKENT(info, 2, 1, do_blkmap_common),
232 U_BOOT_SUBCMD_MKENT(part, 2, 1, do_blkmap_common),
233 U_BOOT_SUBCMD_MKENT(dev, 4, 1, do_blkmap_common),
234 U_BOOT_SUBCMD_MKENT(read, 5, 1, do_blkmap_common),
235 U_BOOT_SUBCMD_MKENT(write, 5, 1, do_blkmap_common),
236 U_BOOT_SUBCMD_MKENT(get, 5, 1, do_blkmap_get),
237 U_BOOT_SUBCMD_MKENT(create, 2, 1, do_blkmap_create),
238 U_BOOT_SUBCMD_MKENT(destroy, 2, 1, do_blkmap_destroy),
239 U_BOOT_SUBCMD_MKENT(map, 32, 1, do_blkmap_map));
240