| /* |
| * Copyright (c) 2018 MediaTek Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files |
| * (the "Software"), to deal in the Software without restriction, |
| * including without limitation the rights to use, copy, modify, merge, |
| * publish, distribute, sublicense, and/or sell copies of the Software, |
| * and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include <env.h> |
| #include <errno.h> |
| #include <lib/bio.h> |
| #include <lib/mempool.h> |
| #include <malloc.h> |
| #include <printf.h> |
| #include <stdint.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #define ENV_PART "para" |
| |
| #define MODULE_NAME "LK_ENV" |
| env_t g_env; |
| static int env_valid; |
| static char *env_buffer; |
| static char env_get_char(int index); |
| static char *env_get_addr(int index); |
| static int envmatch(uchar *s1, int i2); |
| static int write_env_area(char *env_buf); |
| static int read_env_area(char *env_buf); |
| |
| #ifndef min |
| #define min(x, y) (x < y ? x : y) |
| #endif |
| |
| void env_init(void) |
| { |
| int ret, i; |
| env_buffer = (char *)mempool_alloc(CFG_ENV_SIZE, MEMPOOL_ANY); |
| memset(env_buffer, 0x00, CFG_ENV_SIZE); |
| g_env.env_data = env_buffer + CFG_ENV_DATA_OFFSET; |
| ret = read_env_area(env_buffer); |
| int checksum = 0; |
| if (ret < 0) { |
| printf("[%s]read_env_area fail, ret = %x\n", MODULE_NAME, ret); |
| env_valid = 0; |
| goto end; |
| } |
| |
| memcpy(g_env.sig, env_buffer, sizeof(g_env.sig)); |
| memcpy(g_env.sig_1, env_buffer + CFG_ENV_SIG_1_OFFSET, sizeof(g_env.sig_1)); |
| |
| if (!strcmp(g_env.sig, ENV_SIG) && !strcmp(g_env.sig_1, ENV_SIG)) { |
| g_env.checksum = *((int *)env_buffer + CFG_ENV_CHECKSUM_OFFSET / 4); |
| for (i = 0; i < (int)(CFG_ENV_DATA_SIZE); i++) { |
| checksum += g_env.env_data[i]; |
| } |
| if (checksum != g_env.checksum) { |
| printf("[%s]checksum mismatch s %d d %d!\n", MODULE_NAME, g_env.checksum, checksum); |
| env_valid = 0; |
| goto end; |
| } else { |
| printf("[%s]ENV initialize sucess\n", MODULE_NAME); |
| env_valid = 1; |
| } |
| |
| } else { |
| printf("[%s]ENV SIG Wrong\n", MODULE_NAME); |
| env_valid = 0; |
| goto end; |
| } |
| end: |
| if (!env_valid) { |
| memset(env_buffer, 0x00, CFG_ENV_SIZE); |
| } |
| |
| } |
| |
| char *get_env(char *name) |
| { |
| int i, nxt; |
| printf("[%s]get_env %s\n", MODULE_NAME, name); |
| if (!env_valid) |
| return NULL; |
| |
| for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) { |
| int val; |
| |
| for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) { |
| if (nxt >= CFG_ENV_SIZE) { |
| return (NULL); |
| } |
| } |
| if ((val = envmatch((uchar *) name, i)) < 0) |
| continue; |
| return ((char *)env_get_addr(val)); |
| } |
| |
| return (NULL); |
| } |
| |
| static char env_get_char(int index) |
| { |
| return *(g_env.env_data + index); |
| } |
| |
| static char *env_get_addr(int index) |
| { |
| return (g_env.env_data + index); |
| |
| } |
| |
| static int envmatch(uchar *s1, int i2) |
| { |
| |
| while (*s1 == env_get_char(i2++)) |
| if (*s1++ == '=') |
| return (i2); |
| if (*s1 == '\0' && env_get_char(i2 - 1) == '=') |
| return (i2); |
| return (-1); |
| } |
| |
| int set_env(char *name, char *value) |
| { |
| int len, oldval; |
| uchar *env, *nxt = NULL; |
| |
| int ret; |
| |
| uchar *env_data = (uchar *) g_env.env_data; |
| |
| printf("[%s]set_env %s %s\n", MODULE_NAME, name, value); |
| |
| oldval = -1; |
| |
| if (!env_valid) { |
| env = env_data; |
| goto add; |
| } |
| |
| for (env = env_data; *env; env = nxt + 1) { |
| for (nxt = env; *nxt; ++nxt); |
| if ((oldval = envmatch((uchar *) name, env - env_data)) >= 0) |
| break; |
| } |
| |
| if (oldval > 0) { |
| if (*++nxt == '\0') { |
| if (env > env_data) { |
| env--; |
| } else { |
| *env = '\0'; |
| } |
| } else { |
| for (;;) { |
| *env = *nxt++; |
| if ((*env == '\0') && (*nxt == '\0')) |
| break; |
| ++env; |
| } |
| } |
| *++env = '\0'; |
| } |
| |
| for (env = env_data; *env || *(env + 1); ++env); |
| if (env > env_data) |
| ++env; |
| |
| add: |
| /* |
| * Overflow when: |
| * "name" + "=" + "val" +"\0\0" > ENV_SIZE - (env-env_data) |
| */ |
| len = strlen(name) + 2; |
| /* add '=' for first arg, ' ' for all others */ |
| len += strlen(value) + 1; |
| |
| if (len > (&env_data[CFG_ENV_DATA_SIZE] - env)) { |
| printf("## Error: environment overflow, \"%s\" deleted\n", name); |
| return -1; |
| } |
| while ((*env = *name++) != '\0') |
| env++; |
| |
| *env = '='; |
| |
| while ((*++env = *value++) != '\0'); |
| |
| /* end is marked with double '\0' */ |
| *++env = '\0'; |
| memset(env, 0x00, CFG_ENV_DATA_SIZE - (env - env_data)); |
| ret = write_env_area(env_buffer); |
| if (ret < 0) { |
| printf("[%s]write env fail\n", MODULE_NAME); |
| memset(env_buffer, 0x00, CFG_ENV_SIZE); |
| return -1; |
| } |
| env_valid = 1; |
| return 0; |
| |
| } |
| |
| void print_env() |
| { |
| int i, nxt; |
| uchar *env = (uchar *) g_env.env_data; |
| if (!env_valid) { |
| printf("[%s]no valid env\n", MODULE_NAME); |
| return; |
| } |
| printf("[%s]env:\n", MODULE_NAME); |
| for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) { |
| for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) { |
| if (nxt >= (int)(CFG_ENV_DATA_SIZE)) { |
| return; |
| } |
| } |
| printf("%s\n", env + i); |
| } |
| } |
| |
| static int write_env_area(char *env_buf) |
| { |
| #if 0 //nelson |
| part_t *part; |
| part_dev_t *dev; |
| size_t count; |
| long len; |
| int i, checksum = 0; |
| unsigned long long start_addr; |
| |
| dev = mt_part_get_device(); |
| if (!dev) { |
| return -ENODEV; |
| } |
| |
| part = mt_part_get_partition(ENV_PART); |
| if (!part) { |
| return -ENOENT; |
| } |
| |
| start_addr = (u64) part->start_sect * dev->blkdev->blksz; |
| |
| count = min(sizeof(ENV_SIG), sizeof(g_env.sig)); |
| memcpy(env_buf, ENV_SIG, count); |
| memcpy(env_buf + CFG_ENV_SIG_1_OFFSET, ENV_SIG, count); |
| |
| for (i = 0; i < (int)CFG_ENV_DATA_SIZE; i++) { |
| checksum += *(env_buf + CFG_ENV_DATA_OFFSET + i); |
| } |
| printf("checksum %d\n", checksum); |
| |
| *((int *)env_buf + CFG_ENV_CHECKSUM_OFFSET / 4) = checksum; |
| |
| len = dev->write(dev, (uchar *) env_buf, start_addr + CFG_ENV_OFFSET, CFG_ENV_SIZE, part->part_id); |
| if (len < 0) { |
| return -EIO; |
| } |
| #else |
| size_t count; |
| long len; |
| int i, checksum = 0; |
| |
| bdev_t *bdev; |
| |
| bdev = bio_open_by_label(ENV_PART); |
| if (!bdev) { |
| return -ENODEV; |
| } |
| |
| count = min(sizeof(ENV_SIG), sizeof(g_env.sig)); |
| memcpy(env_buf, ENV_SIG, count); |
| memcpy(env_buf + CFG_ENV_SIG_1_OFFSET, ENV_SIG, count); |
| |
| for (i = 0; i < (int)CFG_ENV_DATA_SIZE; i++) { |
| checksum += *(env_buf + CFG_ENV_DATA_OFFSET + i); |
| } |
| dprintf(CRITICAL, "checksum %d\n", checksum); |
| |
| *((int *)env_buf + CFG_ENV_CHECKSUM_OFFSET / 4) = checksum; |
| len = bio_write(bdev, (uchar *) env_buf, CFG_ENV_OFFSET, CFG_ENV_SIZE); |
| if (len < 0) { |
| return -EIO; |
| } |
| |
| #endif |
| return 0; |
| |
| } |
| |
| static int read_env_area(char *env_buf) |
| { |
| #if 0 //nelson |
| part_t *part; |
| part_dev_t *dev; |
| long len; |
| unsigned long long start_addr; |
| |
| dev = mt_part_get_device(); |
| if (!dev) { |
| return -ENODEV; |
| } |
| |
| part = mt_part_get_partition(ENV_PART); |
| if (!part) { |
| return -ENOENT; |
| } |
| |
| start_addr = (u64) part->start_sect * dev->blkdev->blksz; |
| |
| len = dev->read(dev, start_addr + CFG_ENV_OFFSET, (uchar *) env_buf, CFG_ENV_SIZE, part->part_id); |
| if (len < 0) { |
| return -EIO; |
| } |
| #else |
| |
| long len; |
| bdev_t *bdev; |
| |
| bdev = bio_open_by_label(ENV_PART); |
| if (!bdev) { |
| return -ENODEV; |
| } |
| |
| len = bio_read(bdev, (uchar *) env_buf, CFG_ENV_OFFSET, CFG_ENV_SIZE); |
| if (len < 0) { |
| return -EIO; |
| } |
| |
| #endif |
| return 0; |
| } |