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