board/keymile/common/common.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2008
   4  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
   5  *
   6  * (C) Copyright 2011
   7  * Holger Brunck, Keymile GmbH Hannover, holger.brunck@keymile.com
   8  */
   9
  10 #include <common.h>
  11 #include <env.h>
  12 #include <ioports.h>
  13 #include <command.h>
  14 #include <malloc.h>
  15 #include <cli_hush.h>
  16 #include <net.h>
  17 #include <netdev.h>
  18 #include <asm/io.h>
  19 #include <linux/ctype.h>
  20 #include <linux/delay.h>
  21
  22 #if defined(CONFIG_POST)
  23 #include "post.h"
  24 #endif
  25 #include "common.h"
  26 #include <i2c.h>
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 /*
  31  * Set Keymile specific environment variables
  32  * Currently only some memory layout variables are calculated here
  33  * ... ------------------------------------------------
  34  * ... |@rootfsaddr |@pnvramaddr |@varaddr |@reserved |@END_OF_RAM
  35  * ... |<------------------- pram ------------------->|
  36  * ... ------------------------------------------------
  37  * @END_OF_RAM: denotes the RAM size
  38  * @pnvramaddr: Startadress of pseudo non volatile RAM in hex
  39  * @pram      : preserved ram size in k
  40  * @varaddr   : startadress for /var mounted into RAM
  41  */
  42 int set_km_env(void)
  43 {
  44         uchar buf[32];
  45         unsigned int pnvramaddr;
  46         unsigned int pram;
  47         unsigned int varaddr;
  48         unsigned int kernelmem;
  49         char *p;
  50         unsigned long rootfssize = 0;
  51
  52         pnvramaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM
  53                         - CONFIG_KM_PNVRAM;
  54         sprintf((char *)buf, "0x%x", pnvramaddr);
  55         env_set("pnvramaddr", (char *)buf);
  56
  57         /* try to read rootfssize (ram image) from environment */
  58         p = env_get("rootfssize");
  59         if (p != NULL)
  60                 strict_strtoul(p, 16, &rootfssize);
  61         pram = (rootfssize + CONFIG_KM_RESERVED_PRAM + CONFIG_KM_PHRAM +
  62                 CONFIG_KM_PNVRAM) / 0x400;
  63         sprintf((char *)buf, "0x%x", pram);
  64         env_set("pram", (char *)buf);
  65
  66         varaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM;
  67         sprintf((char *)buf, "0x%x", varaddr);
  68         env_set("varaddr", (char *)buf);
  69
  70         kernelmem = gd->ram_size - 0x400 * pram;
  71         sprintf((char *)buf, "0x%x", kernelmem);
  72         env_set("kernelmem", (char *)buf);
  73
  74         return 0;
  75 }
  76
  77 #if defined(CONFIG_SYS_I2C_INIT_BOARD)
  78 static void i2c_write_start_seq(void)
  79 {
  80         set_sda(1);
  81         udelay(DELAY_HALF_PERIOD);
  82         set_scl(1);
  83         udelay(DELAY_HALF_PERIOD);
  84         set_sda(0);
  85         udelay(DELAY_HALF_PERIOD);
  86         set_scl(0);
  87         udelay(DELAY_HALF_PERIOD);
  88 }
  89
  90 /*
  91  * I2C is a synchronous protocol and resets of the processor in the middle
  92  * of an access can block the I2C Bus until a powerdown of the full unit is
  93  * done. This function toggles the SCL until the SCL and SCA line are
  94  * released, but max. 16 times, after this a I2C start-sequence is sent.
  95  * This I2C Deblocking mechanism was developed by Keymile in association
  96  * with Anatech and Atmel in 1998.
  97  */
  98 int i2c_make_abort(void)
  99 {
 100         int     scl_state = 0;
 101         int     sda_state = 0;
 102         int     i = 0;
 103         int     ret = 0;
 104
 105         if (!get_sda()) {
 106                 ret = -1;
 107                 while (i < 16) {
 108                         i++;
 109                         set_scl(0);
 110                         udelay(DELAY_ABORT_SEQ);
 111                         set_scl(1);
 112                         udelay(DELAY_ABORT_SEQ);
 113                         scl_state = get_scl();
 114                         sda_state = get_sda();
 115                         if (scl_state && sda_state) {
 116                                 ret = 0;
 117                                 break;
 118                         }
 119                 }
 120         }
 121         if (ret == 0)
 122                 for (i = 0; i < 5; i++)
 123                         i2c_write_start_seq();
 124
 125         /* respect stop setup time */
 126         udelay(DELAY_ABORT_SEQ);
 127         set_scl(1);
 128         udelay(DELAY_ABORT_SEQ);
 129         set_sda(1);
 130         get_sda();
 131
 132         return ret;
 133 }
 134
 135 /**
 136  * i2c_init_board - reset i2c bus. When the board is powercycled during a
 137  * bus transfer it might hang; for details see doc/I2C_Edge_Conditions.
 138  */
 139 void i2c_init_board(void)
 140 {
 141         /* Now run the AbortSequence() */
 142         i2c_make_abort();
 143 }
 144 #endif
 145
 146 #if defined(CONFIG_KM_COMMON_ETH_INIT)
 147 int board_eth_init(bd_t *bis)
 148 {
 149         if (ethernet_present())
 150                 return cpu_eth_init(bis);
 151
 152         return -1;
 153 }
 154 #endif
 155
 156 /*
 157  * do_setboardid command
 158  * read out the board id and the hw key from the intventory EEPROM and set
 159  * this values as environment variables.
 160  */
 161 static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,
 162                          char *const argv[])
 163 {
 164         unsigned char buf[32];
 165         char *p;
 166
 167         p = get_local_var("IVM_BoardId");
 168         if (p == NULL) {
 169                 printf("can't get the IVM_Boardid\n");
 170                 return 1;
 171         }
 172         strcpy((char *)buf, p);
 173         env_set("boardid", (char *)buf);
 174         printf("set boardid=%s\n", buf);
 175
 176         p = get_local_var("IVM_HWKey");
 177         if (p == NULL) {
 178                 printf("can't get the IVM_HWKey\n");
 179                 return 1;
 180         }
 181         strcpy((char *)buf, p);
 182         env_set("hwkey", (char *)buf);
 183         printf("set hwkey=%s\n", buf);
 184         printf("Execute manually saveenv for persistent storage.\n");
 185
 186         return 0;
 187 }
 188
 189 U_BOOT_CMD(km_setboardid, 1, 0, do_setboardid, "setboardid", "read out bid and "
 190                                  "hwkey from IVM and set in environment");
 191
 192 /*
 193  * command km_checkbidhwk
 194  *      if "boardid" and "hwkey" are not already set in the environment, do:
 195  *              if a "boardIdListHex" exists in the environment:
 196  *                      - read ivm data for boardid and hwkey
 197  *                      - compare each entry of the boardIdListHex with the
 198  *                              IVM data:
 199  *                      if match:
 200  *                              set environment variables boardid, boardId,
 201  *                              hwkey, hwKey to the found values
 202  *                              both (boardid and boardId) are set because
 203  *                              they might be used differently in the
 204  *                              application and in the init scripts (?)
 205  *      return 0 in case of match, 1 if not match or error
 206  */
 207 static int do_checkboardidhwk(struct cmd_tbl *cmdtp, int flag, int argc,
 208                               char *const argv[])
 209 {
 210         unsigned long ivmbid = 0, ivmhwkey = 0;
 211         unsigned long envbid = 0, envhwkey = 0;
 212         char *p;
 213         int verbose = argc > 1 && *argv[1] == 'v';
 214         int rc = 0;
 215
 216         /*
 217          * first read out the real inventory values, these values are
 218          * already stored in the local hush variables
 219          */
 220         p = get_local_var("IVM_BoardId");
 221         if (p == NULL) {
 222                 printf("can't get the IVM_Boardid\n");
 223                 return 1;
 224         }
 225         rc = strict_strtoul(p, 16, &ivmbid);
 226
 227         p = get_local_var("IVM_HWKey");
 228         if (p == NULL) {
 229                 printf("can't get the IVM_HWKey\n");
 230                 return 1;
 231         }
 232         rc = strict_strtoul(p, 16, &ivmhwkey);
 233
 234         if (!ivmbid || !ivmhwkey) {
 235                 printf("Error: IVM_BoardId and/or IVM_HWKey not set!\n");
 236                 return rc;
 237         }
 238
 239         /* now try to read values from environment if available */
 240         p = env_get("boardid");
 241         if (p != NULL)
 242                 rc = strict_strtoul(p, 16, &envbid);
 243         p = env_get("hwkey");
 244         if (p != NULL)
 245                 rc = strict_strtoul(p, 16, &envhwkey);
 246
 247         if (rc != 0) {
 248                 printf("strict_strtoul returns error: %d", rc);
 249                 return rc;
 250         }
 251
 252         if (!envbid || !envhwkey) {
 253                 /*
 254                  * BoardId/HWkey not available in the environment, so try the
 255                  * environment variable for BoardId/HWkey list
 256                  */
 257                 char *bidhwklist = env_get("boardIdListHex");
 258
 259                 if (bidhwklist) {
 260                         int found = 0;
 261                         char *rest = bidhwklist;
 262                         char *endp;
 263
 264                         if (verbose) {
 265                                 printf("IVM_BoardId: %ld, IVM_HWKey=%ld\n",
 266                                         ivmbid, ivmhwkey);
 267                                 printf("boardIdHwKeyList: %s\n",
 268                                         bidhwklist);
 269                         }
 270                         while (!found) {
 271                                 /* loop over each bid/hwkey pair in the list */
 272                                 unsigned long bid   = 0;
 273                                 unsigned long hwkey = 0;
 274
 275                                 while (*rest && !isxdigit(*rest))
 276                                         rest++;
 277                                 /*
 278                                  * use simple_strtoul because we need &end and
 279                                  * we know we got non numeric char at the end
 280                                  */
 281                                 bid = simple_strtoul(rest, &endp, 16);
 282                                 /* BoardId and HWkey are separated with a "_" */
 283                                 if (*endp == '_') {
 284                                         rest  = endp + 1;
 285                                         /*
 286                                          * use simple_strtoul because we need
 287                                          * &end
 288                                          */
 289                                         hwkey = simple_strtoul(rest, &endp, 16);
 290                                         rest  = endp;
 291                                         while (*rest && !isxdigit(*rest))
 292                                                 rest++;
 293                                 }
 294                                 if ((!bid) || (!hwkey)) {
 295                                         /* end of list */
 296                                         break;
 297                                 }
 298                                 if (verbose) {
 299                                         printf("trying bid=0x%lX, hwkey=%ld\n",
 300                                                 bid, hwkey);
 301                                 }
 302                                 /*
 303                                  * Compare the values of the found entry in the
 304                                  * list with the valid values which are stored
 305                                  * in the inventory eeprom. If they are equal
 306                                  * set the values in environment variables.
 307                                  */
 308                                 if ((bid == ivmbid) && (hwkey == ivmhwkey)) {
 309                                         char buf[10];
 310
 311                                         found = 1;
 312                                         envbid   = bid;
 313                                         envhwkey = hwkey;
 314                                         sprintf(buf, "%lx", bid);
 315                                         env_set("boardid", buf);
 316                                         sprintf(buf, "%lx", hwkey);
 317                                         env_set("hwkey", buf);
 318                                 }
 319                         } /* end while( ! found ) */
 320                 }
 321         }
 322
 323         /* compare now the values */
 324         if ((ivmbid == envbid) && (ivmhwkey == envhwkey)) {
 325                 printf("boardid=0x%3lX, hwkey=%ld\n", envbid, envhwkey);
 326                 rc = 0; /* match */
 327         } else {
 328                 printf("Error: env boardid=0x%3lX, hwkey=%ld\n", envbid,
 329                         envhwkey);
 330                 printf("       IVM bId=0x%3lX, hwKey=%ld\n", ivmbid, ivmhwkey);
 331                 rc = 1; /* don't match */
 332         }
 333         return rc;
 334 }
 335
 336 U_BOOT_CMD(km_checkbidhwk, 2, 0, do_checkboardidhwk,
 337                 "check boardid and hwkey",
 338                 "[v]\n  - check environment parameter "\
 339                 "\"boardIdListHex\" against stored boardid and hwkey "\
 340                 "from the IVM\n    v: verbose output"
 341 );
 342
 343 /*
 344  * command km_checktestboot
 345  *  if the testpin of the board is asserted, return 1
 346  *  *   else return 0
 347  */
 348 static int do_checktestboot(struct cmd_tbl *cmdtp, int flag, int argc,
 349                             char *const argv[])
 350 {
 351         int testpin = 0;
 352         char *s = NULL;
 353         int testboot = 0;
 354         int verbose = argc > 1 && *argv[1] == 'v';
 355
 356 #if defined(CONFIG_POST)
 357         testpin = post_hotkeys_pressed();
 358 #endif
 359         s = env_get("test_bank");
 360         /* when test_bank is not set, act as if testpin is not asserted */
 361         testboot = (testpin != 0) && (s);
 362         if (verbose) {
 363                 printf("testpin   = %d\n", testpin);
 364                 /* cppcheck-suppress nullPointer */
 365                 printf("test_bank = %s\n", s ? s : "not set");
 366                 printf("boot test app : %s\n", (testboot) ? "yes" : "no");
 367         }
 368         /* return 0 means: testboot, therefore we need the inversion */
 369         return !testboot;
 370 }
 371
 372 U_BOOT_CMD(km_checktestboot, 2, 0, do_checktestboot,
 373                 "check if testpin is asserted",
 374                 "[v]\n  v - verbose output"
 375 );