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