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
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
28static 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
62static int do_blkmap_map_mem(struct map_ctx *ctx, int argc, char *const argv[])
63{
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
84static struct map_handler map_handlers[] = {
85	{ .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));
235