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
 325 env_item_t *envlist_search(const MEMX char *name)
 326 {
 327         char *p = (char *) name;
 328
 329 #ifdef __MEMX
 330         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 331
 332         if (__builtin_avr_flash_segment(name) != -1) {
 333                 p = buf;
 334                 while ((*p++ = *name++) != '\0')
 335                         ;
 336                 p = buf;
 337         }
 338 #endif /* __MEMX */
 339
 340         return bsearch(p, env_list, entrycount,
 341                                 sizeof(env_item_t), comp_env_key_item);
 342 }
 343
 344
 345 static
 346 env_item_t *envlist_enter(env_item_t *e)
 347 {
 348         char *key = e->name.ram;
 349         const size_t size = sizeof(env_item_t);
 350         env_item_t *ep;
 351
 352         ep = bsearch(key, env_list, entrycount,
 353                         size, comp_env_key_item);
 354
 355         if (ep == NULL) {
 356                 if (entrycount < CONFIG_ENVVAR_MAX) {
 357
 358                         env_list[entrycount++] = *e;
 359                         qsort(env_list, entrycount, size, comp_env_items);
 360                         ep = bsearch(key, env_list, entrycount,
 361                                                 size, comp_env_key_item);
 362                 }
 363         } else {
 364                 if ((ep->flags & EF_V_EEP) == 0) {
 365                         free(ep->val.ram);
 366                 }
 367                 ep->val.ram = e->val.ram;
 368         }
 369
 370         if (ep != NULL) {
 371                 ep->flags |= EF_DIRTY;
 372                 ep->flags &= ~EF_V_EEP;
 373
 374                 if ((ep->flags & EF_N_EEP) == 0) {
 375                         int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
 376                         char *name = xmalloc(nlen + 1);
 377                         if (name == NULL) {
 378                                 printf_P(PSTR("## Can't malloc %d bytes\n"),
 379                                         nlen + 1);
 380                                 return NULL;
 381                         }
 382                         strcpy(name, key);
 383                         name[nlen] = '\0';
 384                         ep->name.ram = name;
 385                 }
 386         }
 387
 388         return ep;
 389 }
 390
 391
 392 static
 393 int env_item_delete(env_item_t *ep)
 394 {
 395         if (entrycount == 0)
 396                 return -1;
 397         if ((ep->flags & EF_V_EEP) == 0)
 398                 free(ep->val.ram);
 399         if ((ep->flags & EF_N_EEP) == 0)
 400                 free(ep->name.ram);
 401
 402         entrycount--;
 403         size_t size = sizeof(env_item_t);
 404         memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);
 405
 406         return 0;
 407 }
 408
 409 static
 410 int envlist_delete(const char *name)
 411 {
 412         env_item_t *ep = bsearch(name, env_list, entrycount,
 413                                 sizeof(env_item_t), comp_env_key_item);
 414
 415         if (ep != NULL)
 416                 return env_item_delete(ep);
 417
 418         return 1;
 419 }
 420
 421
 422 static
 423 env_item_t *envlist_get(const MEMX char *name, uint_fast8_t flag)
 424 {
 425         env_item_t *ep;
 426
 427         ep = envlist_search(name);
 428
 429         if (ep != NULL && (flag & ENV_GET_VAL)) {
 430                 if (ep->flags & EF_V_EEP) {
 431                         char *vp;
 432                         int len;
 433                         len = varval_getlen(ep->val.eep);
 434                         if (len > CONFIG_SYS_CBSIZE)
 435                                 len = CONFIG_SYS_CBSIZE;
 436                         vp = xmalloc(len + 1);
 437                         if (vp) {
 438                                 varval_get(vp, ep->val.eep, len + 1);
 439                                 ep->val.ram = vp;
 440                                 ep->flags &= ~EF_V_EEP;
 441                         } else
 442                                 printf_P(PSTR("Out of memory!\n"));
 443                 }
 444         }
 445
 446         return ep;
 447 }
 448
 449
 450 char *getenv(const MEMX char *name)
 451 {
 452         env_item_t *ep;
 453         char *ret = NULL;
 454
 455         ep = envlist_get(name, ENV_GET_VAL);
 456         if (ep != NULL)
 457                 ret = ep->val.ram;
 458         return ret;
 459 }
 460
 461 static
 462 int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
 463 {
 464         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 465         int len;
 466         env_item_t e = *ep;
 467
 468         len = varname_get(buf, ep);
 469         if (len == 0)
 470                 return 0;
 471         buf[len++] = '=';
 472         space_left -= len;
 473
 474         if (space_left <= 0)
 475                 return 0;
 476
 477         eeprom_update_block(buf, (uint8_t *) offset, len);
 478         offset += len;
 479
 480         if (e.val.ram != NULL) {
 481                 char c;
 482                 do {
 483                         if (e.flags & EF_V_EEP)
 484                                 c = env_get_char(e.val.eep++);
 485                         else
 486                                 c = *e.val.ram++;
 487
 488                         eeprom_update_byte((uint8_t *) offset, c);
 489                         offset++;
 490                         space_left--;
 491                         len++;
 492                 } while ((c != '\0') && space_left );
 493         }
 494         return len;
 495 }
 496
 497
 498 static
 499 int saveenv(void)
 500 {
 501         unsigned int off     = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 502         unsigned int off_red = CONFIG_ENV_OFFSET;
 503         unsigned int pos;
 504         int len, left;
 505         uint16_t crc;
 506         int rc = 0;
 507
 508         if (env_valid == 2) {
 509                 off     = CONFIG_ENV_OFFSET;
 510                 off_red = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 511         }
 512
 513         eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff);
 514
 515         pos = off + offsetof(env_t, data);
 516         left = ENV_SIZE - 1;
 517         for (int i = 0 ; i < entrycount; i++) {
 518                 len = env_item_save(&env_list[i], pos, left);
 519                 if (len == 0) {
 520                         return 1;
 521                 }
 522                 pos += len;
 523                 left -= len;
 524         }
 525         /* terminate list */
 526         eeprom_update_byte((uint8_t *) pos, 0);
 527         crc = env_crc(off + offsetof(env_t, data));
 528         eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
 529         eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags),
 530                                         ACTIVE_FLAG);
 531
 532         if (rc == 0) {
 533                 while (entrycount != 0) {
 534                         env_item_delete(&env_list[entrycount-1]);
 535                 }
 536                 eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
 537                                         OBSOLETE_FLAG);
 538                 env_valid = (env_valid == 2) ? 1 : 2;
 539
 540                 envlist_import();
 541         }
 542
 543         return rc;
 544 }
 545
 546
 547 static
 548 int env_item_print(env_item_t *ep)
 549 {
 550         char buf[CONFIG_SYS_ENV_NAMELEN+1];
 551         int len;
 552         env_item_t e = *ep;
 553
 554         varname_get(buf, ep);
 555         len = printf_P(PSTR("%s="), buf);
 556
 557         if (e.val.ram != NULL) {
 558                 while (1) {
 559                         char c;
 560                         if (e.flags & EF_V_EEP)
 561                                 c = env_get_char(e.val.eep++);
 562                         else
 563                                 c = *e.val.ram++;
 564
 565                         if (c != '\0') {
 566                                 putchar(c);
 567                                 len++;
 568                         } else
 569                                 break;
 570                 }
 571         }
 572         putchar('\n');
 573         len ++;
 574
 575         return len;
 576 }
 577
 578
 579 /*
 580  * Command interface: print one or all environment variables
 581  *
 582  * Returns -1 in case of error, or length of printed string
 583  */
 584 static
 585 int env_print(const MEMX char *name)
 586 {
 587         int len = -1;
 588
 589         if (name) {             /* print a single name */
 590
 591                 env_item_t *ep = envlist_search(name);
 592                 if (ep != NULL)
 593                         len = env_item_print(ep);
 594
 595         } else {                /* print whole list */
 596                 len = 0;
 597                 for (int i = 0 ; i < entrycount; i++) {
 598                         len += env_item_print(&env_list[i]);
 599                 }
 600         }
 601         return len;
 602 }
 603
 604 static
 605 int env_print_ramsize(void)
 606 {
 607         int size = 0;
 608         uint8_t name_cnt = 0;
 609         uint8_t val_cnt = 0;
 610
 611         for (int i = 0 ; i < entrycount; i++) {
 612                 if ((env_list[i].flags & EF_N_EEP) == 0 &&
 613                                 (env_list[i].name.ram != NULL)) {
 614                         name_cnt++;
 615                         size += strlen(env_list[i].name.ram) + 3;
 616                 }
 617                 if ((env_list[i].flags & EF_V_EEP) == 0 &&
 618                                 (env_list[i].val.ram != NULL)) {
 619                         val_cnt++;
 620                         size += strlen(env_list[i].val.ram) + 3;
 621                 }
 622         }
 623         printf_P(PSTR("%d bytes RAM used for %u names and %u values\n"),
 624                         size, name_cnt, val_cnt);
 625         return size;
 626 }
 627
 628
 629 command_ret_t do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 630 {
 631         command_ret_t rc = CMD_RET_SUCCESS;
 632
 633         (void) cmdtp; (void) flag;
 634
 635         if (argc == 1) {
 636                 /* print all env vars */
 637                 int size = env_print(NULL);
 638                 if (size < 0)
 639                         return CMD_RET_FAILURE;
 640                 printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
 641                         size, ENV_SIZE);
 642                 env_print_ramsize();
 643                 return CMD_RET_SUCCESS;
 644         }
 645
 646         /* print selected env vars */
 647         for (int i = 1; i < argc; ++i) {
 648                 int rc = env_print(argv[i]);
 649                 if (rc < 0) {
 650                         printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
 651                         rc = CMD_RET_FAILURE;
 652                 }
 653         }
 654
 655         return rc;
 656 }
 657
 658
 659 /**
 660  * Set or delete environment variable
 661  *
 662  * Set a new environment variable,
 663  * or replace or delete an existing one.
 664  *
 665  * @param flag          (not used)
 666  * @param argc
 667  * @param argv[1]       Environment variable to set or delete
 668  *                      if no more args
 669  * @param argv[2] ...   Value to set it to
 670  *
 671  * @return 0 if ok, 1 on error
 672  */
 673 static
 674 command_ret_t _do_env_set(int flag, int argc, char * const argv[])
 675 {
 676         int i, len;
 677         char *name, *value, *s;
 678         env_item_t e, *ep;
 679
 680         (void) flag;
 681         debug("Initial value for argc=%d\n", argc);
 682
 683         name = argv[1];
 684         value = argv[2];
 685
 686         if (strchr(name, '=')) {
 687                 printf_P(PSTR("## Error: illegal character '='"
 688                        "in variable name \"%s\"\n"), name);
 689                 return CMD_RET_FAILURE;
 690         }
 691         if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
 692                 printf_P(PSTR("## Error: Variable name \"%s\" too long. "
 693                        "(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
 694                 return CMD_RET_FAILURE;
 695         }
 696 /*
 697         env_id++;
 698 */
 699         /* Delete only ? */
 700         if (argc < 3 || argv[2] == NULL) {
 701                 int rc = envlist_delete(name);
 702                 return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 703         }
 704
 705         /*
 706          * Insert / replace new value
 707          */
 708         for (i = 2, len = 0; i < argc; ++i)
 709                 len += strlen(argv[i]) + 1;
 710
 711         value = xmalloc(len);
 712         if (value == NULL) {
 713                 printf_P(PSTR("## Can't malloc %d bytes\n"), len);
 714                 return CMD_RET_FAILURE;
 715         }
 716         for (i = 2, s = value; i < argc; ++i) {
 717                 char *v = argv[i];
 718
 719                 while ((*s++ = *v++) != '\0')
 720                         ;
 721                 *(s - 1) = ' ';
 722         }
 723         if (s != value)
 724                 *--s = '\0';
 725
 726         e.flags = EF_DIRTY;
 727         e.name.ram = name;
 728         e.val.ram = value;
 729         ep = envlist_enter(&e);
 730         if (!ep) {
 731                 printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
 732                         name);
 733                 return CMD_RET_FAILURE;
 734         }
 735
 736         return CMD_RET_SUCCESS;
 737 }
 738
 739 /**
 740  * Set an environment variable
 741  *
 742  * @param varname       Environment variable to set
 743  * @param varvalue      Value to set it to
 744  * @return 0 if ok, 1 on error
 745  */
 746 static
 747 int setenv(const char *varname, const char *varvalue)
 748 {
 749         const char * const argv[3] = { NULL, varname, varvalue };
 750         int argc = 3;
 751
 752         if (varvalue == NULL || varvalue[0] == '\0')
 753                 --argc;
 754
 755         return (int) _do_env_set(0, argc, (char * const *)argv);
 756 }
 757
 758 #if 0
 759 /**
 760  * Set an environment variable to an integer value
 761  *
 762  * @param varname       Environment variable to set
 763  * @param value         Value to set it to
 764  * @return 0 if ok, 1 on error
 765  */
 766 int setenv_ulong(const char *varname, unsigned long value)
 767 {
 768         /* TODO: this should be unsigned */
 769         char *str = simple_itoa(value);
 770
 771         return setenv(varname, str);
 772 }
 773 #endif
 774
 775
 776 /**
 777  * Set an environment variable to an value in hex
 778  *
 779  * @param varname       Environment variable to set
 780  * @param value         Value to set it to
 781  * @return 0 if ok, 1 on error
 782  */
 783 int setenv_hex(const MEMX char *varname, unsigned long value)
 784 {
 785         char str[sizeof(unsigned long) *2 + 1];
 786
 787         sprintf_P(str, PSTR("%lx"), value);
 788         return setenv(varname, str);
 789 }
 790
 791
 792 /**
 793  * Decode the integer value of an environment variable and return it.
 794  *
 795  * @param name          Name of environemnt variable
 796  * @param base          Number base to use (normally 10, or 16 for hex)
 797  * @param default_val   Default value to return if the variable is not
 798  *                      found
 799  * @return the decoded value, or default_val if not found
 800  */
 801 unsigned long getenv_ulong(const MEMX char *name, int base, unsigned long default_val)
 802 {
 803         char buf[16];
 804         unsigned long value;
 805         char *vp, *endp;
 806
 807         env_item_t *ep = envlist_search(name);
 808
 809         if (ep != NULL ) {
 810                 if (ep->flags & EF_V_EEP) {
 811                         varval_get(buf, ep->val.eep, sizeof(buf));
 812                         vp = buf;
 813                 } else
 814                         vp = ep->val.ram;
 815                 if (vp != NULL) {
 816                         value = strtoul(vp, &endp, base);
 817                         if (endp != vp)
 818                                 return value;
 819                 }
 820         }
 821
 822         return default_val;
 823 }
 824
 825
 826 command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 827 {
 828         (void) cmdtp;
 829
 830         if (argc < 2)
 831                 return CMD_RET_USAGE;
 832
 833         return _do_env_set(flag, argc, argv);
 834 }
 835
 836
 837 command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 838 {
 839         (void) cmdtp; (void) flag; (void) argc; (void) argv;
 840
 841         printf_P(PSTR("Saving Environment ...\n"));
 842         return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 843 }
 844
 845 #if defined(CONFIG_AUTO_COMPLETE)
 846 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
 847 {
 848         ENTRY *match;
 849         int found, idx;
 850
 851         idx = 0;
 852         found = 0;
 853         cmdv[0] = NULL;
 854
 855         while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
 856                 int vallen = strlen(match->key) + 1;
 857
 858                 if (found >= maxv - 2 || bufsz < vallen)
 859                         break;
 860
 861                 cmdv[found++] = buf;
 862                 memcpy(buf, match->key, vallen);
 863                 buf += vallen;
 864                 bufsz -= vallen;
 865         }
 866
 867         qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
 868
 869         if (idx)
 870                 cmdv[found++] = "...";
 871
 872         cmdv[found] = NULL;
 873         return found;
 874 }
 875 #endif