cmd/fpga.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000, 2001
   4  * Rich Ireland, Enterasys Networks, rireland@enterasys.com.
   5  */
   6
   7 /*
   8  *  FPGA support
   9  */
  10 #include <common.h>
  11 #include <command.h>
  12 #include <fpga.h>
  13 #include <fs.h>
  14 #include <malloc.h>
  15
  16 /* Local defines */
  17 enum {
  18         FPGA_NONE = -1,
  19         FPGA_INFO,
  20         FPGA_LOAD,
  21         FPGA_LOADB,
  22         FPGA_DUMP,
  23         FPGA_LOADMK,
  24         FPGA_LOADP,
  25         FPGA_LOADBP,
  26         FPGA_LOADFS,
  27         FPGA_LOADS,
  28 };
  29
  30 /*
  31  * Map op to supported operations.  We don't use a table since we
  32  * would just have to relocate it from flash anyway.
  33  */
  34 static int fpga_get_op(char *opstr)
  35 {
  36         int op = FPGA_NONE;
  37
  38         if (!strcmp("info", opstr))
  39                 op = FPGA_INFO;
  40         else if (!strcmp("loadb", opstr))
  41                 op = FPGA_LOADB;
  42         else if (!strcmp("load", opstr))
  43                 op = FPGA_LOAD;
  44 #if defined(CONFIG_CMD_FPGA_LOADP)
  45         else if (!strcmp("loadp", opstr))
  46                 op = FPGA_LOADP;
  47 #endif
  48 #if defined(CONFIG_CMD_FPGA_LOADBP)
  49         else if (!strcmp("loadbp", opstr))
  50                 op = FPGA_LOADBP;
  51 #endif
  52 #if defined(CONFIG_CMD_FPGA_LOADFS)
  53         else if (!strcmp("loadfs", opstr))
  54                 op = FPGA_LOADFS;
  55 #endif
  56 #if defined(CONFIG_CMD_FPGA_LOADMK)
  57         else if (!strcmp("loadmk", opstr))
  58                 op = FPGA_LOADMK;
  59 #endif
  60         else if (!strcmp("dump", opstr))
  61                 op = FPGA_DUMP;
  62 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
  63         else if (!strcmp("loads", opstr))
  64                 op = FPGA_LOADS;
  65 #endif
  66
  67         return op;
  68 }
  69
  70 /* ------------------------------------------------------------------------- */
  71 /* command form:
  72  *   fpga <op> <device number> <data addr> <datasize>
  73  * where op is 'load', 'dump', or 'info'
  74  * If there is no device number field, the fpga environment variable is used.
  75  * If there is no data addr field, the fpgadata environment variable is used.
  76  * The info command requires no data address field.
  77  */
  78 int do_fpga(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
  79 {
  80         int op, dev = FPGA_INVALID_DEVICE;
  81         size_t data_size = 0;
  82         void *fpga_data = NULL;
  83         char *devstr = env_get("fpga");
  84         char *datastr = env_get("fpgadata");
  85         int rc = FPGA_FAIL;
  86 #if defined(CONFIG_FIT)
  87         const char *fit_uname = NULL;
  88         ulong fit_addr;
  89 #endif
  90 #if defined(CONFIG_CMD_FPGA_LOADFS)
  91         fpga_fs_info fpga_fsinfo;
  92         fpga_fsinfo.fstype = FS_TYPE_ANY;
  93 #endif
  94 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
  95         struct fpga_secure_info fpga_sec_info;
  96
  97         memset(&fpga_sec_info, 0, sizeof(fpga_sec_info));
  98 #endif
  99
 100         if (devstr)
 101                 dev = (int) simple_strtoul(devstr, NULL, 16);
 102         if (datastr)
 103                 fpga_data = (void *)simple_strtoul(datastr, NULL, 16);
 104
 105         if (argc > 9 || argc < 2) {
 106                 debug("%s: Too many or too few args (%d)\n", __func__, argc);
 107                 return CMD_RET_USAGE;
 108         }
 109
 110         op = fpga_get_op(argv[1]);
 111
 112         switch (op) {
 113         case FPGA_NONE:
 114                 printf("Unknown fpga operation \"%s\"\n", argv[1]);
 115                 return CMD_RET_USAGE;
 116 #if defined(CONFIG_CMD_FPGA_LOADFS)
 117         case FPGA_LOADFS:
 118                 if (argc < 9)
 119                         return CMD_RET_USAGE;
 120                 fpga_fsinfo.blocksize = (unsigned int)
 121                                         simple_strtoul(argv[5], NULL, 16);
 122                 fpga_fsinfo.interface = argv[6];
 123                 fpga_fsinfo.dev_part = argv[7];
 124                 fpga_fsinfo.filename = argv[8];
 125
 126                 argc = 5;
 127                 break;
 128 #endif
 129 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
 130         case FPGA_LOADS:
 131                 if (argc < 7)
 132                         return CMD_RET_USAGE;
 133                 if (argc == 8)
 134                         fpga_sec_info.userkey_addr = (u8 *)(uintptr_t)
 135                                                      simple_strtoull(argv[7],
 136                                                                      NULL, 16);
 137                 fpga_sec_info.encflag = (u8)simple_strtoul(argv[6], NULL, 16);
 138                 fpga_sec_info.authflag = (u8)simple_strtoul(argv[5], NULL, 16);
 139
 140                 if (fpga_sec_info.authflag >= FPGA_NO_ENC_OR_NO_AUTH &&
 141                     fpga_sec_info.encflag >= FPGA_NO_ENC_OR_NO_AUTH) {
 142                         puts("ERR: Use <fpga load> for NonSecure bitstream\n");
 143                         return CMD_RET_USAGE;
 144                 }
 145
 146                 if (fpga_sec_info.encflag == FPGA_ENC_USR_KEY &&
 147                     !fpga_sec_info.userkey_addr) {
 148                         puts("ERR: User key not provided\n");
 149                         return CMD_RET_USAGE;
 150                 }
 151
 152                 argc = 5;
 153                 break;
 154 #endif
 155         default:
 156                 break;
 157         }
 158
 159         switch (argc) {
 160         case 5:         /* fpga <op> <dev> <data> <datasize> */
 161                 data_size = simple_strtoul(argv[4], NULL, 16);
 162                 if (!data_size) {
 163                         puts("Zero data_size\n");
 164                         return CMD_RET_USAGE;
 165                 }
 166         case 4:         /* fpga <op> <dev> <data> */
 167 #if defined(CONFIG_FIT)
 168                 if (fit_parse_subimage(argv[3], (ulong)fpga_data,
 169                                        &fit_addr, &fit_uname)) {
 170                         fpga_data = (void *)fit_addr;
 171                         debug("*  fpga: subimage '%s' from FIT image ",
 172                               fit_uname);
 173                         debug("at 0x%08lx\n", fit_addr);
 174                 } else
 175 #endif
 176                 {
 177                         fpga_data = (void *)simple_strtoul(argv[3], NULL, 16);
 178                         debug("*  fpga: cmdline image address = 0x%08lx\n",
 179                               (ulong)fpga_data);
 180                 }
 181                 debug("%s: fpga_data = 0x%lx\n", __func__, (ulong)fpga_data);
 182                 if (!fpga_data) {
 183                         puts("Zero fpga_data address\n");
 184                         return CMD_RET_USAGE;
 185                 }
 186         case 3:         /* fpga <op> <dev | data addr> */
 187                 dev = (int)simple_strtoul(argv[2], NULL, 16);
 188                 debug("%s: device = %d\n", __func__, dev);
 189         }
 190
 191         if (dev == FPGA_INVALID_DEVICE) {
 192                 puts("FPGA device not specified\n");
 193                 return CMD_RET_USAGE;
 194         }
 195
 196         switch (op) {
 197         case FPGA_INFO:
 198                 rc = fpga_info(dev);
 199                 break;
 200
 201         case FPGA_LOAD:
 202                 rc = fpga_load(dev, fpga_data, data_size, BIT_FULL);
 203                 break;
 204
 205 #if defined(CONFIG_CMD_FPGA_LOADP)
 206         case FPGA_LOADP:
 207                 rc = fpga_load(dev, fpga_data, data_size, BIT_PARTIAL);
 208                 break;
 209 #endif
 210
 211         case FPGA_LOADB:
 212                 rc = fpga_loadbitstream(dev, fpga_data, data_size, BIT_FULL);
 213                 break;
 214
 215 #if defined(CONFIG_CMD_FPGA_LOADBP)
 216         case FPGA_LOADBP:
 217                 rc = fpga_loadbitstream(dev, fpga_data, data_size, BIT_PARTIAL);
 218                 break;
 219 #endif
 220
 221 #if defined(CONFIG_CMD_FPGA_LOADFS)
 222         case FPGA_LOADFS:
 223                 rc = fpga_fsload(dev, fpga_data, data_size, &fpga_fsinfo);
 224                 break;
 225 #endif
 226
 227 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
 228         case FPGA_LOADS:
 229                 rc = fpga_loads(dev, fpga_data, data_size, &fpga_sec_info);
 230                 break;
 231 #endif
 232
 233 #if defined(CONFIG_CMD_FPGA_LOADMK)
 234         case FPGA_LOADMK:
 235                 switch (genimg_get_format(fpga_data)) {
 236 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
 237                 case IMAGE_FORMAT_LEGACY:
 238                         {
 239                                 image_header_t *hdr =
 240                                                 (image_header_t *)fpga_data;
 241                                 ulong data;
 242                                 uint8_t comp;
 243
 244                                 comp = image_get_comp(hdr);
 245                                 if (comp == IH_COMP_GZIP) {
 246 #if defined(CONFIG_GZIP)
 247                                         ulong image_buf = image_get_data(hdr);
 248                                         data = image_get_load(hdr);
 249                                         ulong image_size = ~0UL;
 250
 251                                         if (gunzip((void *)data, ~0UL,
 252                                                    (void *)image_buf,
 253                                                    &image_size) != 0) {
 254                                                 puts("GUNZIP: error\n");
 255                                                 return 1;
 256                                         }
 257                                         data_size = image_size;
 258 #else
 259                                         puts("Gunzip image is not supported\n");
 260                                         return 1;
 261 #endif
 262                                 } else {
 263                                         data = (ulong)image_get_data(hdr);
 264                                         data_size = image_get_data_size(hdr);
 265                                 }
 266                                 rc = fpga_load(dev, (void *)data, data_size,
 267                                                BIT_FULL);
 268                         }
 269                         break;
 270 #endif
 271 #if defined(CONFIG_FIT)
 272                 case IMAGE_FORMAT_FIT:
 273                         {
 274                                 const void *fit_hdr = (const void *)fpga_data;
 275                                 int noffset;
 276                                 const void *fit_data;
 277
 278                                 if (fit_uname == NULL) {
 279                                         puts("No FIT subimage unit name\n");
 280                                         return 1;
 281                                 }
 282
 283                                 if (!fit_check_format(fit_hdr)) {
 284                                         puts("Bad FIT image format\n");
 285                                         return 1;
 286                                 }
 287
 288                                 /* get fpga component image node offset */
 289                                 noffset = fit_image_get_node(fit_hdr,
 290                                                              fit_uname);
 291                                 if (noffset < 0) {
 292                                         printf("Can't find '%s' FIT subimage\n",
 293                                                fit_uname);
 294                                         return 1;
 295                                 }
 296
 297                                 /* verify integrity */
 298                                 if (!fit_image_verify(fit_hdr, noffset)) {
 299                                         puts ("Bad Data Hash\n");
 300                                         return 1;
 301                                 }
 302
 303                                 /* get fpga subimage data address and length */
 304                                 if (fit_image_get_data(fit_hdr, noffset,
 305                                                        &fit_data, &data_size)) {
 306                                         puts("Fpga subimage data not found\n");
 307                                         return 1;
 308                                 }
 309
 310                                 rc = fpga_load(dev, fit_data, data_size,
 311                                                BIT_FULL);
 312                         }
 313                         break;
 314 #endif
 315                 default:
 316                         puts("** Unknown image type\n");
 317                         rc = FPGA_FAIL;
 318                         break;
 319                 }
 320                 break;
 321 #endif
 322
 323         case FPGA_DUMP:
 324                 rc = fpga_dump(dev, fpga_data, data_size);
 325                 break;
 326
 327         default:
 328                 printf("Unknown operation\n");
 329                 return CMD_RET_USAGE;
 330         }
 331         return rc;
 332 }
 333
 334 static cmd_tbl_t fpga_commands[] = {
 335 };
 336
 337 static int do_fpga_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
 338                            char *const argv[])
 339 {
 340         cmd_tbl_t *fpga_cmd;
 341         int ret;
 342
 343         if (argc < 2)
 344                 return CMD_RET_USAGE;
 345
 346         fpga_cmd = find_cmd_tbl(argv[1], fpga_commands,
 347                                 ARRAY_SIZE(fpga_commands));
 348
 349         /* This should be removed when all functions are converted */
 350         if (!fpga_cmd)
 351                 return do_fpga(cmdtp, flag, argc, argv);
 352
 353         /* FIXME This can't be reached till all functions are converted */
 354         if (!fpga_cmd) {
 355                 debug("fpga: non existing command\n");
 356                 return CMD_RET_USAGE;
 357         }
 358
 359         argc -= 2;
 360         argv += 2;
 361
 362         if (argc > fpga_cmd->maxargs) {
 363                 debug("fpga: more parameters passed\n");
 364                 return CMD_RET_USAGE;
 365         }
 366
 367         ret = fpga_cmd->cmd(fpga_cmd, flag, argc, argv);
 368
 369         return cmd_process_error(fpga_cmd, ret);
 370 }
 371
 372 #if defined(CONFIG_CMD_FPGA_LOADFS) || defined(CONFIG_CMD_FPGA_LOAD_SECURE)
 373 U_BOOT_CMD(fpga, 9, 1, do_fpga_wrapper,
 374 #else
 375 U_BOOT_CMD(fpga, 6, 1, do_fpga_wrapper,
 376 #endif
 377            "loadable FPGA image support",
 378            "[operation type] [device number] [image address] [image size]\n"
 379            "fpga operations:\n"
 380            "  dump\t[dev] [address] [size]\tLoad device to memory buffer\n"
 381            "  info\t[dev]\t\t\tlist known device information\n"
 382            "  load\t[dev] [address] [size]\tLoad device from memory buffer\n"
 383 #if defined(CONFIG_CMD_FPGA_LOADP)
 384            "  loadp\t[dev] [address] [size]\t"
 385            "Load device from memory buffer with partial bitstream\n"
 386 #endif
 387            "  loadb\t[dev] [address] [size]\t"
 388            "Load device from bitstream buffer (Xilinx only)\n"
 389 #if defined(CONFIG_CMD_FPGA_LOADBP)
 390            "  loadbp\t[dev] [address] [size]\t"
 391            "Load device from bitstream buffer with partial bitstream"
 392            "(Xilinx only)\n"
 393 #endif
 394 #if defined(CONFIG_CMD_FPGA_LOADFS)
 395            "Load device from filesystem (FAT by default) (Xilinx only)\n"
 396            "  loadfs [dev] [address] [image size] [blocksize] <interface>\n"
 397            "        [<dev[:part]>] <filename>\n"
 398 #endif
 399 #if defined(CONFIG_CMD_FPGA_LOADMK)
 400            "  loadmk [dev] [address]\tLoad device generated with mkimage"
 401 #if defined(CONFIG_FIT)
 402            "\n"
 403            "\tFor loadmk operating on FIT format uImage address must include\n"
 404            "\tsubimage unit name in the form of addr:<subimg_uname>"
 405 #endif
 406 #endif
 407 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
 408            "Load encrypted bitstream (Xilinx only)\n"
 409            "  loads [dev] [address] [size] [auth-OCM-0/DDR-1/noauth-2]\n"
 410            "        [enc-devkey(0)/userkey(1)/nenc(2) [Userkey address]\n"
 411            "Loads the secure bistreams(authenticated/encrypted/both\n"
 412            "authenticated and encrypted) of [size] from [address].\n"
 413            "The auth-OCM/DDR flag specifies to perform authentication\n"
 414            "in OCM or in DDR. 0 for OCM, 1 for DDR, 2 for no authentication.\n"
 415            "The enc flag specifies which key to be used for decryption\n"
 416            "0-device key, 1-user key, 2-no encryption.\n"
 417            "The optional Userkey address specifies from which address key\n"
 418            "has to be used for decryption if user key is selected.\n"
 419            "NOTE: the sceure bitstream has to be created using xilinx\n"
 420            "bootgen tool only.\n"
 421 #endif
 422 );