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