LXR uboot/board/gardena/smart-gateway-mt7688/board.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2018 Stefan Roese <sr@denx.de>
   4 */
   5
   6#include <common.h>
   7#include <environment.h>
   8#include <led.h>
   9#include <net.h>
  10#include <spi.h>
  11#include <spi_flash.h>
  12#include <uuid.h>
  13#include <linux/ctype.h>
  14#include <linux/io.h>
  15
  16#define MT76XX_AGPIO_CFG        0x1000003c
  17
  18#define FACTORY_DATA_OFFS       0xc0000
  19#define FACTORY_DATA_SECT_SIZE  0x10000
  20#if ((CONFIG_ENV_OFFSET_REDUND + CONFIG_ENV_SIZE_REDUND) > FACTORY_DATA_OFFS)
  21#error "U-Boot image with environment too big (overlapping with factory-data)!"
  22#endif
  23#define FACTORY_DATA_USER_OFFS  0x140
  24#define FACTORY_DATA_SIZE       0x1f0
  25#define FACTORY_DATA_CRC_LEN    (FACTORY_DATA_SIZE -                    \
  26                                 FACTORY_DATA_USER_OFFS - sizeof(u32))
  27
  28#define FACTORY_DATA_MAGIC      0xCAFEBABE
  29
  30struct factory_data_values {
  31        u8 pad_1[4];
  32        u8 wifi_mac[6];         /* offs: 0x004: binary value */
  33        u8 pad_2[30];
  34        u8 eth_mac[6];          /* offs: 0x028: binary value */
  35        u8 pad_3[FACTORY_DATA_USER_OFFS - 4 - 6 - 30 - 6];
  36        /* User values start here at offset 0x140 */
  37        u32 crc;
  38        u32 magic;
  39        u32 version;
  40        char ipr_id[UUID_STR_LEN];      /* UUID as string w/o ending \0 */
  41        char hqv_id[UUID_STR_LEN];      /* UUID as string w/o ending \0 */
  42        char unielec_id[UUID_STR_LEN];  /* UUID as string w/o ending \0 */
  43};
  44
  45int board_early_init_f(void)
  46{
  47        void __iomem *gpio_mode;
  48
  49        /* Configure digital vs analog GPIOs */
  50        gpio_mode = ioremap_nocache(MT76XX_AGPIO_CFG, 0x100);
  51        iowrite32(0x00fe01ff, gpio_mode);
  52
  53        return 0;
  54}
  55
  56static bool prepare_uuid_var(const char *fd_ptr, const char *env_var_name,
  57                             char errorchar)
  58{
  59        char str[UUID_STR_LEN + 1] = { 0 };     /* Enough for UUID stuff */
  60        bool env_updated = false;
  61        char *env;
  62        int i;
  63
  64        memcpy(str, fd_ptr, UUID_STR_LEN);
  65
  66        /* Convert non-ascii character to 'X' */
  67        for (i = 0; i < UUID_STR_LEN; i++) {
  68                if (!(isascii(str[i]) && isprint(str[i])))
  69                        str[i] = errorchar;
  70        }
  71
  72        env = env_get(env_var_name);
  73        if (strcmp(env, str)) {
  74                env_set(env_var_name, str);
  75                env_updated = true;
  76        }
  77
  78        return env_updated;
  79}
  80
  81static void factory_data_env_config(void)
  82{
  83        struct factory_data_values *fd;
  84        struct spi_flash *sf;
  85        int env_updated = 0;
  86        char str[UUID_STR_LEN + 1];     /* Enough for UUID stuff */
  87        char *env;
  88        u8 *buf;
  89        u32 crc;
  90        int ret;
  91        u8 *ptr;
  92
  93        buf = malloc(FACTORY_DATA_SIZE);
  94        if (!buf) {
  95                printf("F-Data:Unable to allocate buffer\n");
  96                return;
  97        }
  98
  99        /*
 100         * Get values from factory-data area in SPI NOR
 101         */
 102        sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
 103                             CONFIG_SF_DEFAULT_CS,
 104                             CONFIG_SF_DEFAULT_SPEED,
 105                             CONFIG_SF_DEFAULT_MODE);
 106        if (!sf) {
 107                printf("F-Data:Unable to access SPI NOR flash\n");
 108                goto err_free;
 109        }
 110
 111        ret = spi_flash_read(sf, FACTORY_DATA_OFFS, FACTORY_DATA_SIZE,
 112                             (void *)buf);
 113        if (ret) {
 114                printf("F-Data:Unable to read factory-data from SPI NOR\n");
 115                goto err_spi_flash;
 116        }
 117
 118        fd = (struct factory_data_values *)buf;
 119
 120        if (fd->magic != FACTORY_DATA_MAGIC)
 121                printf("F-Data:Magic value not correct\n");
 122
 123        crc = crc32(0, (u8 *)&fd->magic, FACTORY_DATA_CRC_LEN);
 124        if (crc != fd->crc)
 125                printf("F-Data:CRC not correct\n");
 126        else
 127                printf("F-Data:factory-data version %x detected\n",
 128                       fd->version);
 129
 130        /* Handle wifi_mac env variable */
 131        ptr = fd->wifi_mac;
 132        sprintf(str, "%pM", ptr);
 133        if (!is_valid_ethaddr(ptr))
 134                printf("F-Data:Invalid MAC addr: wifi_mac %s\n", str);
 135
 136        env = env_get("wifiaddr");
 137        if (strcmp(env, str)) {
 138                env_set("wifiaddr", str);
 139                env_updated = 1;
 140        }
 141
 142        /* Handle eth_mac env variable */
 143        ptr = fd->eth_mac;
 144        sprintf(str, "%pM", ptr);
 145        if (!is_valid_ethaddr(ptr))
 146                printf("F-Data:Invalid MAC addr: eth_mac %s\n", str);
 147
 148        env = env_get("ethaddr");
 149        if (strcmp(env, str)) {
 150                env_set("ethaddr", str);
 151                env_updated = 1;
 152        }
 153
 154        /* Handle UUID env variables */
 155        env_updated |= prepare_uuid_var(fd->ipr_id, "linuxmoduleid", 'X');
 156        env_updated |= prepare_uuid_var(fd->hqv_id, "linuxmodulehqvid", '\0');
 157        env_updated |= prepare_uuid_var(fd->unielec_id,
 158                                        "linuxmoduleunielecid", '\0');
 159
 160        /* Check if the environment was updated and needs to get stored */
 161        if (env_updated != 0) {
 162                printf("F-Data:Values don't match env values -> saving\n");
 163                env_save();
 164        } else {
 165                debug("F-Data:Values match current env values\n");
 166        }
 167
 168err_spi_flash:
 169        spi_flash_free(sf);
 170
 171err_free:
 172        free(buf);
 173}
 174
 175int board_late_init(void)
 176{
 177        if (IS_ENABLED(CONFIG_LED))
 178                led_default_state();
 179
 180        factory_data_env_config();
 181
 182        return 0;
 183}
 184
 185static void copy_or_generate_uuid(char *fd_ptr, const char *env_var_name)
 186{
 187        char str[UUID_STR_LEN + 1] = { 0 };     /* Enough for UUID stuff */
 188        char *env;
 189
 190        /* Don't use the UUID dest place, as the \0 char won't fit */
 191        env = env_get(env_var_name);
 192        if (env)
 193                strncpy(str, env, UUID_STR_LEN);
 194        else
 195                gen_rand_uuid_str(str, UUID_STR_FORMAT_STD);
 196
 197        memcpy(fd_ptr, str, UUID_STR_LEN);
 198}
 199
 200/*
 201 * Helper function to provide some sane factory-data values for testing
 202 * purpose, when these values are not programmed correctly
 203 */
 204int do_fd_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 205{
 206        struct factory_data_values *fd;
 207        struct spi_flash *sf;
 208        u8 *buf;
 209        int ret = CMD_RET_FAILURE;
 210
 211        buf = malloc(FACTORY_DATA_SECT_SIZE);
 212        if (!buf) {
 213                printf("F-Data:Unable to allocate buffer\n");
 214                return CMD_RET_FAILURE;
 215        }
 216
 217        sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
 218                             CONFIG_SF_DEFAULT_CS,
 219                             CONFIG_SF_DEFAULT_SPEED,
 220                             CONFIG_SF_DEFAULT_MODE);
 221        if (!sf) {
 222                printf("F-Data:Unable to access SPI NOR flash\n");
 223                goto err_free;
 224        }
 225
 226        /* Generate the factory-data struct */
 227
 228        /* Fist read complete sector into buffer */
 229        ret = spi_flash_read(sf, FACTORY_DATA_OFFS, FACTORY_DATA_SECT_SIZE,
 230                             (void *)buf);
 231        if (ret) {
 232                printf("F-Data:spi_flash_read failed (%d)\n", ret);
 233                goto err_spi_flash;
 234        }
 235
 236        fd = (struct factory_data_values *)buf;
 237        fd->magic = FACTORY_DATA_MAGIC;
 238        fd->version = 0x1;
 239
 240        /* Use existing MAC and UUID values or generate some random ones */
 241        if (!eth_env_get_enetaddr("wifiaddr", fd->wifi_mac)) {
 242                net_random_ethaddr(fd->wifi_mac);
 243                /* to get a different seed value for the MAC address */
 244                mdelay(10);
 245        }
 246
 247        if (!eth_env_get_enetaddr("ethaddr", fd->eth_mac))
 248                net_random_ethaddr(fd->eth_mac);
 249
 250        copy_or_generate_uuid(fd->ipr_id, "linuxmoduleid");
 251        copy_or_generate_uuid(fd->hqv_id, "linuxmodulehqvid");
 252        copy_or_generate_uuid(fd->unielec_id, "linuxmoduleunielecid");
 253
 254        printf("New factory-data values:\n");
 255        printf("wifiaddr=%pM\n", fd->wifi_mac);
 256        printf("ethaddr=%pM\n", fd->eth_mac);
 257
 258        /*
 259         * We don't have the \0 char at the end, so we need to specify the
 260         * length in the printf format instead
 261         */
 262        printf("linuxmoduleid=%." __stringify(UUID_STR_LEN) "s\n", fd->ipr_id);
 263        printf("linuxmodulehqvid=%." __stringify(UUID_STR_LEN) "s\n",
 264               fd->hqv_id);
 265        printf("linuxmoduleunielecid=%." __stringify(UUID_STR_LEN) "s\n",
 266               fd->unielec_id);
 267
 268        fd->crc = crc32(0, (u8 *)&fd->magic, FACTORY_DATA_CRC_LEN);
 269
 270        ret = spi_flash_erase(sf, FACTORY_DATA_OFFS, FACTORY_DATA_SECT_SIZE);
 271        if (ret) {
 272                printf("F-Data:spi_flash_erase failed (%d)\n", ret);
 273                goto err_spi_flash;
 274        }
 275
 276        ret = spi_flash_write(sf, FACTORY_DATA_OFFS, FACTORY_DATA_SECT_SIZE,
 277                              buf);
 278        if (ret) {
 279                printf("F-Data:spi_flash_write failed (%d)\n", ret);
 280                goto err_spi_flash;
 281        }
 282
 283        printf("F-Data:factory-data values written to SPI NOR flash\n");
 284
 285err_spi_flash:
 286        spi_flash_free(sf);
 287
 288err_free:
 289        free(buf);
 290
 291        return ret;
 292}
 293
 294U_BOOT_CMD(
 295        fd_write,       1,      0,      do_fd_write,
 296        "Write test factory-data values to SPI NOR",
 297        "\n"
 298);
 299