board/CZ.NIC/turris_omnia/turris_omnia.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Marek Behun <marek.behun@nic.cz>
   4  * Copyright (C) 2016 Tomas Hlavacek <tomas.hlavacek@nic.cz>
   5  *
   6  * Derived from the code for
   7  *   Marvell/db-88f6820-gp by Stefan Roese <sr@denx.de>
   8  */
   9
  10 #include <common.h>
  11 #include <env.h>
  12 #include <i2c.h>
  13 #include <init.h>
  14 #include <log.h>
  15 #include <miiphy.h>
  16 #include <net.h>
  17 #include <netdev.h>
  18 #include <asm/global_data.h>
  19 #include <asm/io.h>
  20 #include <asm/arch/cpu.h>
  21 #include <asm/arch/soc.h>
  22 #include <dm/uclass.h>
  23 #include <fdt_support.h>
  24 #include <time.h>
  25 #include <linux/bitops.h>
  26 #include <u-boot/crc.h>
  27 # include <atsha204a-i2c.h>
  28
  29 #include "../drivers/ddr/marvell/a38x/ddr3_init.h"
  30 #include <../serdes/a38x/high_speed_env_spec.h>
  31
  32 DECLARE_GLOBAL_DATA_PTR;
  33
  34 #define OMNIA_I2C_BUS_NAME              "i2c@11000->i2cmux@70->i2c@0"
  35
  36 #define OMNIA_I2C_MCU_CHIP_ADDR         0x2a
  37 #define OMNIA_I2C_MCU_CHIP_LEN          1
  38
  39 #define OMNIA_I2C_EEPROM_CHIP_ADDR      0x54
  40 #define OMNIA_I2C_EEPROM_CHIP_LEN       2
  41 #define OMNIA_I2C_EEPROM_MAGIC          0x0341a034
  42
  43 enum mcu_commands {
  44         CMD_GET_STATUS_WORD     = 0x01,
  45         CMD_GET_RESET           = 0x09,
  46         CMD_WATCHDOG_STATE      = 0x0b,
  47 };
  48
  49 enum status_word_bits {
  50         CARD_DET_STSBIT         = 0x0010,
  51         MSATA_IND_STSBIT        = 0x0020,
  52 };
  53
  54 #define OMNIA_ATSHA204_OTP_VERSION      0
  55 #define OMNIA_ATSHA204_OTP_SERIAL       1
  56 #define OMNIA_ATSHA204_OTP_MAC0         3
  57 #define OMNIA_ATSHA204_OTP_MAC1         4
  58
  59 /*
  60  * Those values and defines are taken from the Marvell U-Boot version
  61  * "u-boot-2013.01-2014_T3.0"
  62  */
  63 #define OMNIA_GPP_OUT_ENA_LOW                                   \
  64         (~(BIT(1)  | BIT(4)  | BIT(6)  | BIT(7)  | BIT(8)  | BIT(9)  |  \
  65            BIT(10) | BIT(11) | BIT(19) | BIT(22) | BIT(23) | BIT(25) |  \
  66            BIT(26) | BIT(27) | BIT(29) | BIT(30) | BIT(31)))
  67 #define OMNIA_GPP_OUT_ENA_MID                                   \
  68         (~(BIT(0) | BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(15) |       \
  69            BIT(16) | BIT(17) | BIT(18)))
  70
  71 #define OMNIA_GPP_OUT_VAL_LOW   0x0
  72 #define OMNIA_GPP_OUT_VAL_MID   0x0
  73 #define OMNIA_GPP_POL_LOW       0x0
  74 #define OMNIA_GPP_POL_MID       0x0
  75
  76 static struct serdes_map board_serdes_map_pex[] = {
  77         {PEX0, SERDES_SPEED_5_GBPS, PEX_ROOT_COMPLEX_X1, 0, 0},
  78         {USB3_HOST0, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
  79         {PEX1, SERDES_SPEED_5_GBPS, PEX_ROOT_COMPLEX_X1, 0, 0},
  80         {USB3_HOST1, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
  81         {PEX2, SERDES_SPEED_5_GBPS, PEX_ROOT_COMPLEX_X1, 0, 0},
  82         {SGMII2, SERDES_SPEED_1_25_GBPS, SERDES_DEFAULT_MODE, 0, 0}
  83 };
  84
  85 static struct serdes_map board_serdes_map_sata[] = {
  86         {SATA0, SERDES_SPEED_6_GBPS, SERDES_DEFAULT_MODE, 0, 0},
  87         {USB3_HOST0, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
  88         {PEX1, SERDES_SPEED_5_GBPS, PEX_ROOT_COMPLEX_X1, 0, 0},
  89         {USB3_HOST1, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
  90         {PEX2, SERDES_SPEED_5_GBPS, PEX_ROOT_COMPLEX_X1, 0, 0},
  91         {SGMII2, SERDES_SPEED_1_25_GBPS, SERDES_DEFAULT_MODE, 0, 0}
  92 };
  93
  94 static struct udevice *omnia_get_i2c_chip(const char *name, uint addr,
  95                                           uint offset_len)
  96 {
  97         struct udevice *bus, *dev;
  98         int ret;
  99
 100         ret = uclass_get_device_by_name(UCLASS_I2C, OMNIA_I2C_BUS_NAME, &bus);
 101         if (ret) {
 102                 printf("Cannot get I2C bus %s: uclass_get_device_by_name failed: %i\n",
 103                        OMNIA_I2C_BUS_NAME, ret);
 104                 return NULL;
 105         }
 106
 107         ret = i2c_get_chip(bus, addr, offset_len, &dev);
 108         if (ret) {
 109                 printf("Cannot get %s I2C chip: i2c_get_chip failed: %i\n",
 110                        name, ret);
 111                 return NULL;
 112         }
 113
 114         return dev;
 115 }
 116
 117 static int omnia_mcu_read(u8 cmd, void *buf, int len)
 118 {
 119         struct udevice *chip;
 120
 121         chip = omnia_get_i2c_chip("MCU", OMNIA_I2C_MCU_CHIP_ADDR,
 122                                   OMNIA_I2C_MCU_CHIP_LEN);
 123         if (!chip)
 124                 return -ENODEV;
 125
 126         return dm_i2c_read(chip, cmd, buf, len);
 127 }
 128
 129 #ifndef CONFIG_SPL_BUILD
 130 static int omnia_mcu_write(u8 cmd, const void *buf, int len)
 131 {
 132         struct udevice *chip;
 133
 134         chip = omnia_get_i2c_chip("MCU", OMNIA_I2C_MCU_CHIP_ADDR,
 135                                   OMNIA_I2C_MCU_CHIP_LEN);
 136         if (!chip)
 137                 return -ENODEV;
 138
 139         return dm_i2c_write(chip, cmd, buf, len);
 140 }
 141
 142 static bool disable_mcu_watchdog(void)
 143 {
 144         int ret;
 145
 146         puts("Disabling MCU watchdog... ");
 147
 148         ret = omnia_mcu_write(CMD_WATCHDOG_STATE, "\x00", 1);
 149         if (ret) {
 150                 printf("omnia_mcu_write failed: %i\n", ret);
 151                 return false;
 152         }
 153
 154         puts("disabled\n");
 155
 156         return true;
 157 }
 158 #endif
 159
 160 static bool omnia_detect_sata(void)
 161 {
 162         int ret;
 163         u16 stsword;
 164
 165         puts("MiniPCIe/mSATA card detection... ");
 166
 167         ret = omnia_mcu_read(CMD_GET_STATUS_WORD, &stsword, sizeof(stsword));
 168         if (ret) {
 169                 printf("omnia_mcu_read failed: %i, defaulting to MiniPCIe card\n",
 170                        ret);
 171                 return false;
 172         }
 173
 174         if (!(stsword & CARD_DET_STSBIT)) {
 175                 puts("none\n");
 176                 return false;
 177         }
 178
 179         if (stsword & MSATA_IND_STSBIT)
 180                 puts("mSATA\n");
 181         else
 182                 puts("MiniPCIe\n");
 183
 184         return stsword & MSATA_IND_STSBIT ? true : false;
 185 }
 186
 187 int hws_board_topology_load(struct serdes_map **serdes_map_array, u8 *count)
 188 {
 189         if (omnia_detect_sata()) {
 190                 *serdes_map_array = board_serdes_map_sata;
 191                 *count = ARRAY_SIZE(board_serdes_map_sata);
 192         } else {
 193                 *serdes_map_array = board_serdes_map_pex;
 194                 *count = ARRAY_SIZE(board_serdes_map_pex);
 195         }
 196
 197         return 0;
 198 }
 199
 200 struct omnia_eeprom {
 201         u32 magic;
 202         u32 ramsize;
 203         char region[4];
 204         u32 crc;
 205 };
 206
 207 static bool omnia_read_eeprom(struct omnia_eeprom *oep)
 208 {
 209         struct udevice *chip;
 210         u32 crc;
 211         int ret;
 212
 213         chip = omnia_get_i2c_chip("EEPROM", OMNIA_I2C_EEPROM_CHIP_ADDR,
 214                                   OMNIA_I2C_EEPROM_CHIP_LEN);
 215
 216         if (!chip)
 217                 return false;
 218
 219         ret = dm_i2c_read(chip, 0, (void *)oep, sizeof(*oep));
 220         if (ret) {
 221                 printf("dm_i2c_read failed: %i, cannot read EEPROM\n", ret);
 222                 return false;
 223         }
 224
 225         if (oep->magic != OMNIA_I2C_EEPROM_MAGIC) {
 226                 printf("bad EEPROM magic number (%08x, should be %08x)\n",
 227                        oep->magic, OMNIA_I2C_EEPROM_MAGIC);
 228                 return false;
 229         }
 230
 231         crc = crc32(0, (void *)oep, sizeof(*oep) - 4);
 232         if (crc != oep->crc) {
 233                 printf("bad EEPROM CRC (stored %08x, computed %08x)\n",
 234                        oep->crc, crc);
 235                 return false;
 236         }
 237
 238         return true;
 239 }
 240
 241 static int omnia_get_ram_size_gb(void)
 242 {
 243         static int ram_size;
 244         struct omnia_eeprom oep;
 245
 246         if (!ram_size) {
 247                 /* Get the board config from EEPROM */
 248                 if (omnia_read_eeprom(&oep)) {
 249                         debug("Memory config in EEPROM: 0x%02x\n", oep.ramsize);
 250
 251                         if (oep.ramsize == 0x2)
 252                                 ram_size = 2;
 253                         else
 254                                 ram_size = 1;
 255                 } else {
 256                         /* Hardcoded fallback */
 257                         puts("Memory config from EEPROM read failed!\n");
 258                         puts("Falling back to default 1 GiB!\n");
 259                         ram_size = 1;
 260                 }
 261         }
 262
 263         return ram_size;
 264 }
 265
 266 /*
 267  * Define the DDR layout / topology here in the board file. This will
 268  * be used by the DDR3 init code in the SPL U-Boot version to configure
 269  * the DDR3 controller.
 270  */
 271 static struct mv_ddr_topology_map board_topology_map_1g = {
 272         DEBUG_LEVEL_ERROR,
 273         0x1, /* active interfaces */
 274         /* cs_mask, mirror, dqs_swap, ck_swap X PUPs */
 275         { { { {0x1, 0, 0, 0},
 276               {0x1, 0, 0, 0},
 277               {0x1, 0, 0, 0},
 278               {0x1, 0, 0, 0},
 279               {0x1, 0, 0, 0} },
 280             SPEED_BIN_DDR_1600K,        /* speed_bin */
 281             MV_DDR_DEV_WIDTH_16BIT,     /* memory_width */
 282             MV_DDR_DIE_CAP_4GBIT,                       /* mem_size */
 283             MV_DDR_FREQ_800,            /* frequency */
 284             0, 0,                       /* cas_wl cas_l */
 285             MV_DDR_TEMP_NORMAL,         /* temperature */
 286             MV_DDR_TIM_2T} },           /* timing */
 287         BUS_MASK_32BIT,                 /* Busses mask */
 288         MV_DDR_CFG_DEFAULT,             /* ddr configuration data source */
 289         NOT_COMBINED,                   /* ddr twin-die combined */
 290         { {0} },                        /* raw spd data */
 291         {0}                             /* timing parameters */
 292 };
 293
 294 static struct mv_ddr_topology_map board_topology_map_2g = {
 295         DEBUG_LEVEL_ERROR,
 296         0x1, /* active interfaces */
 297         /* cs_mask, mirror, dqs_swap, ck_swap X PUPs */
 298         { { { {0x1, 0, 0, 0},
 299               {0x1, 0, 0, 0},
 300               {0x1, 0, 0, 0},
 301               {0x1, 0, 0, 0},
 302               {0x1, 0, 0, 0} },
 303             SPEED_BIN_DDR_1600K,        /* speed_bin */
 304             MV_DDR_DEV_WIDTH_16BIT,     /* memory_width */
 305             MV_DDR_DIE_CAP_8GBIT,                       /* mem_size */
 306             MV_DDR_FREQ_800,            /* frequency */
 307             0, 0,                       /* cas_wl cas_l */
 308             MV_DDR_TEMP_NORMAL,         /* temperature */
 309             MV_DDR_TIM_2T} },           /* timing */
 310         BUS_MASK_32BIT,                 /* Busses mask */
 311         MV_DDR_CFG_DEFAULT,             /* ddr configuration data source */
 312         NOT_COMBINED,                   /* ddr twin-die combined */
 313         { {0} },                        /* raw spd data */
 314         {0}                             /* timing parameters */
 315 };
 316
 317 struct mv_ddr_topology_map *mv_ddr_topology_map_get(void)
 318 {
 319         if (omnia_get_ram_size_gb() == 2)
 320                 return &board_topology_map_2g;
 321         else
 322                 return &board_topology_map_1g;
 323 }
 324
 325 #ifndef CONFIG_SPL_BUILD
 326 static int set_regdomain(void)
 327 {
 328         struct omnia_eeprom oep;
 329         char rd[3] = {' ', ' ', 0};
 330
 331         if (omnia_read_eeprom(&oep))
 332                 memcpy(rd, &oep.region, 2);
 333         else
 334                 puts("EEPROM regdomain read failed.\n");
 335
 336         printf("Regdomain set to %s\n", rd);
 337         return env_set("regdomain", rd);
 338 }
 339
 340 static void handle_reset_button(void)
 341 {
 342         const char * const vars[1] = { "bootcmd_rescue", };
 343         int ret;
 344         u8 reset_status;
 345
 346         /*
 347          * Ensure that bootcmd_rescue has always stock value, so that running
 348          *   run bootcmd_rescue
 349          * always works correctly.
 350          */
 351         env_set_default_vars(1, (char * const *)vars, 0);
 352
 353         ret = omnia_mcu_read(CMD_GET_RESET, &reset_status, 1);
 354         if (ret) {
 355                 printf("omnia_mcu_read failed: %i, reset status unknown!\n",
 356                        ret);
 357                 return;
 358         }
 359
 360         env_set_ulong("omnia_reset", reset_status);
 361
 362         if (reset_status) {
 363                 const char * const vars[2] = {
 364                         "bootcmd",
 365                         "distro_bootcmd",
 366                 };
 367
 368                 /*
 369                  * Set the above envs to their default values, in case the user
 370                  * managed to break them.
 371                  */
 372                 env_set_default_vars(2, (char * const *)vars, 0);
 373
 374                 /* Ensure bootcmd_rescue is used by distroboot */
 375                 env_set("boot_targets", "rescue");
 376
 377                 printf("RESET button was pressed, overwriting bootcmd!\n");
 378         } else {
 379                 /*
 380                  * In case the user somehow managed to save environment with
 381                  * boot_targets=rescue, reset boot_targets to default value.
 382                  * This could happen in subsequent commands if bootcmd_rescue
 383                  * failed.
 384                  */
 385                 if (!strcmp(env_get("boot_targets"), "rescue")) {
 386                         const char * const vars[1] = {
 387                                 "boot_targets",
 388                         };
 389
 390                         env_set_default_vars(1, (char * const *)vars, 0);
 391                 }
 392         }
 393 }
 394 #endif
 395
 396 int board_early_init_f(void)
 397 {
 398         /* Configure MPP */
 399         writel(0x11111111, MVEBU_MPP_BASE + 0x00);
 400         writel(0x11111111, MVEBU_MPP_BASE + 0x04);
 401         writel(0x11244011, MVEBU_MPP_BASE + 0x08);
 402         writel(0x22222111, MVEBU_MPP_BASE + 0x0c);
 403         writel(0x22200002, MVEBU_MPP_BASE + 0x10);
 404         writel(0x30042022, MVEBU_MPP_BASE + 0x14);
 405         writel(0x55550555, MVEBU_MPP_BASE + 0x18);
 406         writel(0x00005550, MVEBU_MPP_BASE + 0x1c);
 407
 408         /* Set GPP Out value */
 409         writel(OMNIA_GPP_OUT_VAL_LOW, MVEBU_GPIO0_BASE + 0x00);
 410         writel(OMNIA_GPP_OUT_VAL_MID, MVEBU_GPIO1_BASE + 0x00);
 411
 412         /* Set GPP Polarity */
 413         writel(OMNIA_GPP_POL_LOW, MVEBU_GPIO0_BASE + 0x0c);
 414         writel(OMNIA_GPP_POL_MID, MVEBU_GPIO1_BASE + 0x0c);
 415
 416         /* Set GPP Out Enable */
 417         writel(OMNIA_GPP_OUT_ENA_LOW, MVEBU_GPIO0_BASE + 0x04);
 418         writel(OMNIA_GPP_OUT_ENA_MID, MVEBU_GPIO1_BASE + 0x04);
 419
 420         return 0;
 421 }
 422
 423 int board_init(void)
 424 {
 425         /* address of boot parameters */
 426         gd->bd->bi_boot_params = mvebu_sdram_bar(0) + 0x100;
 427
 428 #ifndef CONFIG_SPL_BUILD
 429         disable_mcu_watchdog();
 430 #endif
 431
 432         return 0;
 433 }
 434
 435 int board_late_init(void)
 436 {
 437 #ifndef CONFIG_SPL_BUILD
 438         set_regdomain();
 439         handle_reset_button();
 440 #endif
 441         pci_init();
 442
 443         return 0;
 444 }
 445
 446 static struct udevice *get_atsha204a_dev(void)
 447 {
 448         static struct udevice *dev;
 449
 450         if (dev)
 451                 return dev;
 452
 453         if (uclass_get_device_by_name(UCLASS_MISC, "atsha204a@64", &dev)) {
 454                 puts("Cannot find ATSHA204A on I2C bus!\n");
 455                 dev = NULL;
 456         }
 457
 458         return dev;
 459 }
 460
 461 int checkboard(void)
 462 {
 463         u32 version_num, serial_num;
 464         int err = 1;
 465
 466         struct udevice *dev = get_atsha204a_dev();
 467
 468         if (dev) {
 469                 err = atsha204a_wakeup(dev);
 470                 if (err)
 471                         goto out;
 472
 473                 err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false,
 474                                      OMNIA_ATSHA204_OTP_VERSION,
 475                                      (u8 *)&version_num);
 476                 if (err)
 477                         goto out;
 478
 479                 err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false,
 480                                      OMNIA_ATSHA204_OTP_SERIAL,
 481                                      (u8 *)&serial_num);
 482                 if (err)
 483                         goto out;
 484
 485                 atsha204a_sleep(dev);
 486         }
 487
 488 out:
 489         printf("Turris Omnia:\n");
 490         printf("  RAM size: %i MiB\n", omnia_get_ram_size_gb() * 1024);
 491         if (err)
 492                 printf("  Serial Number: unknown\n");
 493         else
 494                 printf("  Serial Number: %08X%08X\n", be32_to_cpu(version_num),
 495                        be32_to_cpu(serial_num));
 496
 497         return 0;
 498 }
 499
 500 static void increment_mac(u8 *mac)
 501 {
 502         int i;
 503
 504         for (i = 5; i >= 3; i--) {
 505                 mac[i] += 1;
 506                 if (mac[i])
 507                         break;
 508         }
 509 }
 510
 511 int misc_init_r(void)
 512 {
 513         int err;
 514         struct udevice *dev = get_atsha204a_dev();
 515         u8 mac0[4], mac1[4], mac[6];
 516
 517         if (!dev)
 518                 goto out;
 519
 520         err = atsha204a_wakeup(dev);
 521         if (err)
 522                 goto out;
 523
 524         err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false,
 525                              OMNIA_ATSHA204_OTP_MAC0, mac0);
 526         if (err)
 527                 goto out;
 528
 529         err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false,
 530                              OMNIA_ATSHA204_OTP_MAC1, mac1);
 531         if (err)
 532                 goto out;
 533
 534         atsha204a_sleep(dev);
 535
 536         mac[0] = mac0[1];
 537         mac[1] = mac0[2];
 538         mac[2] = mac0[3];
 539         mac[3] = mac1[1];
 540         mac[4] = mac1[2];
 541         mac[5] = mac1[3];
 542
 543         if (is_valid_ethaddr(mac))
 544                 eth_env_set_enetaddr("eth1addr", mac);
 545
 546         increment_mac(mac);
 547
 548         if (is_valid_ethaddr(mac))
 549                 eth_env_set_enetaddr("eth2addr", mac);
 550
 551         increment_mac(mac);
 552
 553         if (is_valid_ethaddr(mac))
 554                 eth_env_set_enetaddr("ethaddr", mac);
 555
 556 out:
 557         return 0;
 558 }
 559