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