avr/env.c

   1 #include "common.h"
   2 #include <string.h>
   3 #include <stdlib.h>
   4
   5 #include <avr/eeprom.h>
   6
   7 #include "config.h"
   8 #include "debug.h"
   9 #include "xmalloc.h"
  10 #include "crc.h"
  11 #include "command.h"
  12
  13 #include "env.h"
  14
  15
  16 #define ENV_SIZE        (CONFIG_ENV_SIZE - sizeof(uint16_t) -1)
  17 #define ACTIVE_FLAG     1
  18 #define OBSOLETE_FLAG   0
  19 #define ENV_GET_VAL     (1<<0)
  20
  21
  22 /*
  23  * Default Environment
  24  */
  25
  26 #define DELIM           "\0"
  27
  28 const FLASH char default_env[] = {
  29         "bootdelay="    "3"             DELIM
  30         "bootcmd="      "reset; loadf; go $(startaddr)" DELIM
  31         "baudrate="     "115200"        DELIM
  32         "startaddr="    "0"             DELIM
  33         DELIM
  34 };
  35
  36 /* EEPROM storage */
  37 typedef struct environment_s {
  38         uint16_t        crc;            /* CRC16 over data bytes        */
  39         uint8_t         flags;          /* active/obsolete flags        */
  40         char            data[ENV_SIZE]; /* Environment data             */
  41 } env_t;
  42
  43
  44 /* */
  45 typedef struct env_item_s {
  46 #define EF_N_EEP        (1<<7)          /* Variable name is in EEPROM */
  47 #define EF_V_EEP        (1<<6)          /* Variable value is in EEPROM */
  48 #define EF_DIRTY        (1<<0)          /* Variable is new or value changed */
  49         uint8_t flags;
  50         union {
  51                 uint16_t eep;
  52                 char     *ram;
  53         } name;
  54         union {
  55                 uint16_t eep;
  56                 char     *ram;
  57         } val;
  58 } env_item_t;
  59
  60
  61 static uint8_t env_valid;
  62 static env_item_t env_list[CONFIG_ENVVAR_MAX];
  63 static int entrycount;
  64
  65
  66 static
  67 char env_get_char(uint16_t index)
  68 {
  69         unsigned int off = CONFIG_ENV_OFFSET;
  70
  71         if (env_valid == 2)
  72                 off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
  73
  74         return (char) eeprom_read_byte((const uint8_t *)off + index +
  75                                 offsetof(env_t, data));
  76 }
  77
  78
  79 static
  80 uint16_t varname_get(char *buf, env_item_t *ep)
  81 {
  82         int i = 0;
  83         char c;
  84
  85         if (ep->flags & EF_N_EEP) {
  86
  87                 while ((c = env_get_char(ep->name.eep + i)) != '=' &&
  88                                 c != '\0' && i < CONFIG_SYS_ENV_NAMELEN) {
  89
  90                         buf[i] = c;
  91                         i++;
  92                 }
  93                 if (i > 0 && c != '=') {
  94                         debug("** ee_name: '%s' not '=' terminated!\n", buf);
  95                 }
  96         } else {
  97                 strncpy(buf, ep->name.ram, CONFIG_SYS_ENV_NAMELEN);
  98                 i = strnlen(buf, CONFIG_SYS_ENV_NAMELEN);
  99         }
 100         buf[i] = '\0';
 101         return i;
 102 }
 103
 104
 105 static
 106 uint16_t varval_getlen(uint16_t index)
 107 {
 108         int i = 0;
 109         char c;
 110
 111         while ((c = env_get_char (index + i)) != '\0') {
 112                 i++;
 113         };
 114
 115         return i;
 116 }
 117
 118 static
 119 uint16_t varval_get(char *buf, uint16_t index, int len)
 120 {
 121         int i = 0;
 122         char c;
 123
 124         while ((c = env_get_char (index + i)) != '\0' && i < len) {
 125                 buf[i] = c;
 126                 i++;
 127         };
 128
 129         buf[i] = '\0';
 130
 131         /* TODO: len check */
 132
 133         return i;
 134 }
 135
 136 static
 137 int comp_env_key_item(const void *key, const void *item)
 138 {
 139         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 140         env_item_t *ep = (env_item_t *) item;
 141
 142         varname_get(buf, ep);
 143
 144         return strcmp((char *) key, buf);
 145 }
 146
 147 static
 148 int comp_env_items(const void *m1, const void *m2)
 149 {
 150         char b1[CONFIG_SYS_ENV_NAMELEN+1];
 151         char b2[CONFIG_SYS_ENV_NAMELEN+1];
 152
 153         env_item_t *ep1 = (env_item_t *) m1;
 154         env_item_t *ep2 = (env_item_t *) m2;
 155
 156         varname_get(b1, ep1);
 157         varname_get(b2, ep2);
 158
 159         return strcmp(b1, b2);
 160 }
 161
 162
 163 static
 164 int envlist_import(void)
 165 {
 166         char name[CONFIG_SYS_ENV_NAMELEN+1];
 167         uint16_t idx = 0;
 168         int nlen;
 169         env_item_t e;
 170
 171         e.flags = EF_N_EEP | EF_V_EEP;
 172         e.name.eep = idx;
 173         while ((nlen = varname_get(name, &e)) != 0 && idx < ENV_SIZE) {
 174
 175                 if (entrycount <= CONFIG_ENVVAR_MAX) {
 176                         e.val.eep = idx + nlen + 1;
 177
 178                         env_list[entrycount++] = e;
 179
 180                         idx += nlen + 1;
 181                         while (env_get_char(idx++) != 0 && idx < ENV_SIZE)
 182                                 ;
 183                         e.name.eep = idx;
 184                 } else {
 185                         debug("** Too many environment variables!\n");
 186                         break;
 187                 }
 188         }
 189         qsort(env_list, entrycount, sizeof(env_item_t), comp_env_items);
 190
 191         return 0;
 192 }
 193
 194
 195 static
 196 int set_default_env(void)
 197 {
 198         char buf[56];
 199         uint16_t eep = CONFIG_ENV_OFFSET + offsetof(env_t, data);
 200         unsigned int len = ENV_SIZE;
 201         unsigned int i, src = 0;
 202         char c = 0xff, c0 = c;
 203
 204         if (env_valid == 1) {
 205                 eep = CONFIG_ENV_OFFSET + offsetof(env_t, data) + CONFIG_ENV_SIZE;
 206         }
 207
 208         while (len)  {
 209                 memcpy_P(buf, default_env+src, sizeof(buf));
 210                 for (i=0; i < (len < sizeof(buf) ? len : sizeof(buf)) &&
 211                                 !(c == 0 && c0 == 0);
 212                                 i++) {
 213                         c0 = c; c = buf[i];
 214                 }
 215                 eeprom_update_block(buf, (char *) eep, i);
 216                 if (c == 0 && c0 == 0)
 217                         len = 0;
 218                 if (len > sizeof(buf))
 219                         len -= sizeof(buf);
 220                 src += sizeof(buf);
 221                 eep += sizeof(buf);
 222         }
 223
 224         return 0;
 225 }
 226
 227
 228 static
 229 uint16_t env_crc(uint16_t data_offset)
 230 {
 231         uint16_t crc;
 232         uint16_t i;
 233         char c, c0;
 234
 235         crc = 0xffff;
 236         c = 0xff;
 237         for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
 238         {
 239                 c0 = c;
 240                 c = eeprom_read_byte((const uint8_t *) data_offset + i);
 241                 crc = crc16(crc, c);
 242         }
 243         return crc ;
 244 }
 245
 246
 247 /**
 248  * return valid env
 249  */
 250 static
 251 int env_check_valid(void)
 252 {
 253         const uint16_t offset[2] = {CONFIG_ENV_OFFSET,
 254                                     CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE};
 255         uint_fast8_t flags[2], crc_ok[2];
 256         int rc;
 257
 258         /* read FLAGS */
 259         flags[0] = eeprom_read_byte ((uint8_t *) offset[0] +
 260                                 offsetof(env_t, flags));
 261         flags[1] = eeprom_read_byte ((uint8_t *) offset[1] +
 262                                 offsetof(env_t, flags));
 263
 264         /* check CRC */
 265         crc_ok[0] = (
 266                 eeprom_read_word((uint16_t *) offset[0] +
 267                                 offsetof(env_t, crc))
 268                 == env_crc(offset[0] + offsetof(env_t, data))
 269         );
 270         crc_ok[1] = (
 271                 eeprom_read_word((uint16_t *) offset[1] +
 272                                 offsetof(env_t, crc))
 273                 == env_crc(offset[1] + offsetof(env_t, data))
 274         );
 275
 276         if (!crc_ok[0] && !crc_ok[1]) {
 277                 rc = 0;
 278
 279         } else if (crc_ok[0] && !crc_ok[1]) {
 280                 rc = 1;
 281         } else if (!crc_ok[0] && crc_ok[1]) {
 282                 rc = 2;
 283         } else {
 284                 /* both ok - check serial */
 285 #if 1
 286                 if      (flags[1] == ACTIVE_FLAG && flags[0] != ACTIVE_FLAG)
 287                         rc = 2;
 288                 else if (flags[1] == OBSOLETE_FLAG && flags[0] == 0xFF)
 289                         rc = 2;
 290                 else
 291                         rc = 1;
 292 #else
 293                 if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
 294                         rc = 1;
 295                 else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
 296                         rc = 2;
 297                 else if (flags[0] == 0xFF && flags[1] == 0)
 298                         rc = 2;
 299                 else if (flags[1] == 0xFF && flags[0] == 0)
 300                         rc = 1;
 301                 else /* flags are equal - almost impossible */
 302                         rc = 1;
 303 #endif
 304         }
 305
 306         return rc;
 307 }
 308
 309
 310 int env_init(void)
 311 {
 312         env_valid = env_check_valid();
 313         if (env_valid == 0) {
 314                 printf_P(PSTR("*** Warning - bad CRC, "
 315                                 "using default environment\n\n"));
 316                 set_default_env();
 317         }
 318         entrycount = 0;
 319         envlist_import();
 320         return 0;
 321 }
 322
 323
 324 static
 325 env_item_t *envlist_search(const char *name)
 326 {
 327         return bsearch(name, env_list, entrycount,
 328                                 sizeof(env_item_t), comp_env_key_item);
 329 }
 330
 331
 332 static
 333 env_item_t *envlist_enter(env_item_t *e)
 334 {
 335         char *key = e->name.ram;
 336         const size_t size = sizeof(env_item_t);
 337         env_item_t *ep;
 338
 339         ep = bsearch(key, env_list, entrycount,
 340                         size, comp_env_key_item);
 341
 342         if (ep == NULL) {
 343                 if (entrycount < CONFIG_ENVVAR_MAX) {
 344
 345                         env_list[entrycount++] = *e;
 346                         qsort(env_list, entrycount, size, comp_env_items);
 347                         ep = bsearch(key, env_list, entrycount,
 348                                                 size, comp_env_key_item);
 349                 }
 350         } else {
 351                 if ((ep->flags & EF_V_EEP) == 0) {
 352                         free(ep->val.ram);
 353                 }
 354                 ep->val.ram = e->val.ram;
 355         }
 356
 357         if (ep != NULL) {
 358                 ep->flags |= EF_DIRTY;
 359                 ep->flags &= ~EF_V_EEP;
 360
 361                 if ((ep->flags & EF_N_EEP) == 0) {
 362                         int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
 363                         char *name = xmalloc(nlen + 1);
 364                         if (name == NULL) {
 365                                 printf_P(PSTR("## Can't malloc %d bytes\n"),
 366                                         nlen + 1);
 367                                 return NULL;
 368                         }
 369                         strcpy(name, key);
 370                         name[nlen] = '\0';
 371                         ep->name.ram = name;
 372                 }
 373         }
 374
 375         return ep;
 376 }
 377
 378
 379 static
 380 int env_item_delete(env_item_t *ep)
 381 {
 382         if (entrycount == 0)
 383                 return -1;
 384         if ((ep->flags & EF_V_EEP) == 0)
 385                 free(ep->val.ram);
 386         if ((ep->flags & EF_N_EEP) == 0)
 387                 free(ep->name.ram);
 388
 389         entrycount--;
 390         size_t size = sizeof(env_item_t);
 391         memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);
 392
 393         return 0;
 394 }
 395
 396 static
 397 int envlist_delete(const char *name)
 398 {
 399         env_item_t *ep = bsearch(name, env_list, entrycount,
 400                                 sizeof(env_item_t), comp_env_key_item);
 401
 402         if (ep != NULL)
 403                 return env_item_delete(ep);
 404
 405         return 1;
 406 }
 407
 408
 409 static
 410 env_item_t *envlist_get(const char *name, uint_fast8_t flag)
 411 {
 412         env_item_t *ep;
 413
 414         ep = envlist_search(name);
 415
 416         if (ep != NULL && (flag & ENV_GET_VAL)) {
 417                 if (ep->flags & EF_V_EEP) {
 418                         char *vp;
 419                         int len;
 420                         len = varval_getlen(ep->val.eep);
 421                         if (len > CONFIG_SYS_CBSIZE)
 422                                 len = CONFIG_SYS_CBSIZE;
 423                         vp = xmalloc(len + 1);
 424                         if (vp) {
 425                                 varval_get(vp, ep->val.eep, len + 1);
 426                                 ep->val.ram = vp;
 427                                 ep->flags &= ~EF_V_EEP;
 428                         } else
 429                                 printf_P(PSTR("Out of memory!\n"));
 430                 }
 431         }
 432
 433         return ep;
 434 }
 435
 436
 437 char *getenv(const char *name)
 438 {
 439         env_item_t *ep;
 440         char *ret = NULL;
 441
 442         ep = envlist_get(name, ENV_GET_VAL);
 443         if (ep != NULL)
 444                 ret = ep->val.ram;
 445         return ret;
 446 }
 447
 448 static
 449 int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
 450 {
 451         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 452         int len;
 453         env_item_t e = *ep;
 454
 455         len = varname_get(buf, ep);
 456         if (len == 0)
 457                 return 0;
 458         buf[len++] = '=';
 459         space_left -= len;
 460
 461         if (space_left <= 0)
 462                 return 0;
 463
 464         eeprom_update_block(buf, (uint8_t *) offset, len);
 465         offset += len;
 466
 467         if (e.val.ram != NULL) {
 468                 char c;
 469                 do {
 470                         if (e.flags & EF_V_EEP)
 471                                 c = env_get_char(e.val.eep++);
 472                         else
 473                                 c = *e.val.ram++;
 474
 475                         eeprom_update_byte((uint8_t *) offset, c);
 476                         offset++;
 477                         space_left--;
 478                         len++;
 479                 } while ((c != '\0') && space_left );
 480         }
 481         return len;
 482 }
 483
 484
 485 static
 486 int saveenv(void)
 487 {
 488         unsigned int off     = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 489         unsigned int off_red = CONFIG_ENV_OFFSET;
 490         unsigned int pos;
 491         int len, left;
 492         uint16_t crc;
 493         int rc = 0;
 494
 495         if (env_valid == 2) {
 496                 off     = CONFIG_ENV_OFFSET;
 497                 off_red = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 498         }
 499
 500         eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff);
 501
 502         pos = off + offsetof(env_t, data);
 503         left = ENV_SIZE - 1;
 504         for (int i = 0 ; i < entrycount; i++) {
 505                 len = env_item_save(&env_list[i], pos, left);
 506                 if (len == 0) {
 507                         return 1;
 508                 }
 509                 pos += len;
 510                 left -= len;
 511         }
 512         /* terminate list */
 513         eeprom_update_byte((uint8_t *) pos, 0);
 514         crc = env_crc(off + offsetof(env_t, data));
 515         eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
 516         eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags),
 517                                         ACTIVE_FLAG);
 518
 519         if (rc == 0) {
 520                 while (entrycount != 0) {
 521                         env_item_delete(&env_list[entrycount-1]);
 522                 }
 523                 eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
 524                                         OBSOLETE_FLAG);
 525                 env_valid = (env_valid == 2) ? 1 : 2;
 526
 527                 envlist_import();
 528         }
 529
 530         return rc;
 531 }
 532
 533
 534 static
 535 int env_item_print(env_item_t *ep)
 536 {
 537         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 538         int len;
 539         env_item_t e = *ep;
 540
 541         varname_get(buf, ep);
 542         len = printf_P(PSTR("%s="), buf);
 543
 544         if (e.val.ram != NULL) {
 545                 while (1) {
 546                         char c;
 547                         if (e.flags & EF_V_EEP)
 548                                 c = env_get_char(e.val.eep++);
 549                         else
 550                                 c = *e.val.ram++;
 551
 552                         if (c != '\0') {
 553                                 putchar(c);
 554                                 len++;
 555                         } else
 556                                 break;
 557                 }
 558         }
 559         putchar('\n');
 560         len ++;
 561
 562         return len;
 563 }
 564
 565
 566 /*
 567  * Command interface: print one or all environment variables
 568  *
 569  * Returns -1 in case of error, or length of printed string
 570  */
 571 static
 572 int env_print(char *name)
 573 {
 574         int len = -1;
 575
 576         if (name) {             /* print a single name */
 577
 578                 env_item_t *ep = envlist_search(name);
 579                 if (ep != NULL)
 580                         len = env_item_print(ep);
 581
 582         } else {                /* print whole list */
 583                 len = 0;
 584                 for (int i = 0 ; i < entrycount; i++) {
 585                         len += env_item_print(&env_list[i]);
 586                 }
 587         }
 588         return len;
 589 }
 590
 591 static
 592 int env_print_ramsize(void)
 593 {
 594         int size = 0;
 595         uint8_t name_cnt = 0;
 596         uint8_t val_cnt = 0;
 597
 598         for (int i = 0 ; i < entrycount; i++) {
 599                 if ((env_list[i].flags & EF_N_EEP) == 0 &&
 600                                 (env_list[i].name.ram != NULL)) {
 601                         name_cnt++;
 602                         size += strlen(env_list[i].name.ram) + 3;
 603                 }
 604                 if ((env_list[i].flags & EF_V_EEP) == 0 &&
 605                                 (env_list[i].val.ram != NULL)) {
 606                         val_cnt++;
 607                         size += strlen(env_list[i].val.ram) + 3;
 608                 }
 609         }
 610         printf_P(PSTR("%d bytes RAM used for %u names and %u values\n"),
 611                         size, name_cnt, val_cnt);
 612         return size;
 613 }
 614
 615
 616 command_ret_t do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 617 {
 618         command_ret_t rc = CMD_RET_SUCCESS;
 619
 620         (void) cmdtp; (void) flag;
 621
 622         if (argc == 1) {
 623                 /* print all env vars */
 624                 int size = env_print(NULL);
 625                 if (size < 0)
 626                         return CMD_RET_FAILURE;
 627                 printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
 628                         size, ENV_SIZE);
 629                 env_print_ramsize();
 630                 return CMD_RET_SUCCESS;
 631         }
 632
 633         /* print selected env vars */
 634         for (int i = 1; i < argc; ++i) {
 635                 int rc = env_print(argv[i]);
 636                 if (rc < 0) {
 637                         printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
 638                         rc = CMD_RET_FAILURE;
 639                 }
 640         }
 641
 642         return rc;
 643 }
 644
 645
 646 /**
 647  * Set or delete environment variable
 648  *
 649  * Set a new environment variable,
 650  * or replace or delete an existing one.
 651  *
 652  * @param flag          (not used)
 653  * @param argc
 654  * @param argv[1]       Environment variable to set or delete
 655  *                      if no more args
 656  * @param argv[2] ...   Value to set it to
 657  *
 658  * @return 0 if ok, 1 on error
 659  */
 660 static
 661 command_ret_t _do_env_set(int flag, int argc, char * const argv[])
 662 {
 663         int i, len;
 664         char *name, *value, *s;
 665         env_item_t e, *ep;
 666
 667         (void) flag;
 668         debug("Initial value for argc=%d\n", argc);
 669
 670         name = argv[1];
 671         value = argv[2];
 672
 673         if (strchr(name, '=')) {
 674                 printf_P(PSTR("## Error: illegal character '='"
 675                        "in variable name \"%s\"\n"), name);
 676                 return CMD_RET_FAILURE;
 677         }
 678         if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
 679                 printf_P(PSTR("## Error: Variable name \"%s\" too long. "
 680                        "(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
 681                 return CMD_RET_FAILURE;
 682         }
 683 /*
 684         env_id++;
 685 */
 686         /* Delete only ? */
 687         if (argc < 3 || argv[2] == NULL) {
 688                 int rc = envlist_delete(name);
 689                 return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 690         }
 691
 692         /*
 693          * Insert / replace new value
 694          */
 695         for (i = 2, len = 0; i < argc; ++i)
 696                 len += strlen(argv[i]) + 1;
 697
 698         value = xmalloc(len);
 699         if (value == NULL) {
 700                 printf_P(PSTR("## Can't malloc %d bytes\n"), len);
 701                 return CMD_RET_FAILURE;
 702         }
 703         for (i = 2, s = value; i < argc; ++i) {
 704                 char *v = argv[i];
 705
 706                 while ((*s++ = *v++) != '\0')
 707                         ;
 708                 *(s - 1) = ' ';
 709         }
 710         if (s != value)
 711                 *--s = '\0';
 712
 713         e.flags = EF_DIRTY;
 714         e.name.ram = name;
 715         e.val.ram = value;
 716         ep = envlist_enter(&e);
 717         if (!ep) {
 718                 printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
 719                         name);
 720                 return CMD_RET_FAILURE;
 721         }
 722
 723         return CMD_RET_SUCCESS;
 724 }
 725
 726 /**
 727  * Set an environment variable
 728  *
 729  * @param varname       Environment variable to set
 730  * @param varvalue      Value to set it to
 731  * @return 0 if ok, 1 on error
 732  */
 733 static
 734 int setenv(const char *varname, const char *varvalue)
 735 {
 736         const char * const argv[3] = { NULL, varname, varvalue };
 737         int argc = 3;
 738
 739         if (varvalue == NULL || varvalue[0] == '\0')
 740                 --argc;
 741
 742         return (int) _do_env_set(0, argc, (char * const *)argv);
 743 }
 744
 745 #if 0
 746 /**
 747  * Set an environment variable to an integer value
 748  *
 749  * @param varname       Environment variable to set
 750  * @param value         Value to set it to
 751  * @return 0 if ok, 1 on error
 752  */
 753 int setenv_ulong(const char *varname, unsigned long value)
 754 {
 755         /* TODO: this should be unsigned */
 756         char *str = simple_itoa(value);
 757
 758         return setenv(varname, str);
 759 }
 760 #endif
 761
 762
 763 /**
 764  * Set an environment variable to an value in hex
 765  *
 766  * @param varname       Environment variable to set
 767  * @param value         Value to set it to
 768  * @return 0 if ok, 1 on error
 769  */
 770 int setenv_hex(const char *varname, unsigned long value)
 771 {
 772         char str[sizeof(unsigned long) *2 + 1];
 773
 774         sprintf_P(str, PSTR("%lx"), value);
 775         return setenv(varname, str);
 776 }
 777
 778 /**
 779  * Get an environment variable as a hex value
 780  *
 781  * @param varname       Environment variable to get
 782  * @param default_val   Return this, if variable does not exist
 783  * @return hex value of variable or default_val
 784  */
 785 unsigned long getenv_hex(const char *varname, unsigned long default_val)
 786 {
 787         const char *s;
 788         unsigned long value;
 789         char *endp;
 790
 791         s = getenv(varname);
 792         if (s)
 793                 value = strtoul(s, &endp, 16);
 794         if (!s || endp == s)
 795                 return default_val;
 796
 797         return value;
 798 }
 799
 800 command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 801 {
 802         (void) cmdtp;
 803
 804         if (argc < 2)
 805                 return CMD_RET_USAGE;
 806
 807         return _do_env_set(flag, argc, argv);
 808 }
 809
 810
 811 command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 812 {
 813         (void) cmdtp; (void) flag; (void) argc; (void) argv;
 814
 815         printf_P(PSTR("Saving Environment ...\n"));
 816         return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 817 }
 818
 819 #if defined(CONFIG_AUTO_COMPLETE)
 820 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
 821 {
 822         ENTRY *match;
 823         int found, idx;
 824
 825         idx = 0;
 826         found = 0;
 827         cmdv[0] = NULL;
 828
 829         while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
 830                 int vallen = strlen(match->key) + 1;
 831
 832                 if (found >= maxv - 2 || bufsz < vallen)
 833                         break;
 834
 835                 cmdv[found++] = buf;
 836                 memcpy(buf, match->key, vallen);
 837                 buf += vallen;
 838                 bufsz -= vallen;
 839         }
 840
 841         qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
 842
 843         if (idx)
 844                 cmdv[found++] = "...";
 845
 846         cmdv[found] = NULL;
 847         return found;
 848 }
 849 #endif