board/CZ.NIC/turris_mox/turris_mox.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2018 Marek Behun <marek.behun@nic.cz>
   4  */
   5
   6 #include <common.h>
   7 #include <asm/gpio.h>
   8 #include <asm/io.h>
   9 #include <dm.h>
  10 #include <clk.h>
  11 #include <spi.h>
  12 #include <mvebu/comphy.h>
  13 #include <miiphy.h>
  14 #include <linux/string.h>
  15 #include <linux/libfdt.h>
  16 #include <fdt_support.h>
  17 #include <environment.h>
  18
  19 #ifdef CONFIG_WDT_ARMADA_37XX
  20 #include <wdt.h>
  21 #endif
  22
  23 #include "mox_sp.h"
  24
  25 #define MAX_MOX_MODULES         10
  26
  27 #define MOX_MODULE_SFP          0x1
  28 #define MOX_MODULE_PCI          0x2
  29 #define MOX_MODULE_TOPAZ        0x3
  30 #define MOX_MODULE_PERIDOT      0x4
  31 #define MOX_MODULE_USB3         0x5
  32 #define MOX_MODULE_PASSPCI      0x6
  33
  34 #define ARMADA_37XX_NB_GPIO_SEL 0xd0013830
  35 #define ARMADA_37XX_SPI_CTRL    0xd0010600
  36 #define ARMADA_37XX_SPI_CFG     0xd0010604
  37 #define ARMADA_37XX_SPI_DOUT    0xd0010608
  38 #define ARMADA_37XX_SPI_DIN     0xd001060c
  39
  40 #define PCIE_PATH       "/soc/pcie@d0070000"
  41
  42 DECLARE_GLOBAL_DATA_PTR;
  43
  44 int dram_init(void)
  45 {
  46         gd->ram_base = 0;
  47         gd->ram_size = (phys_size_t)get_ram_size(0, 0x40000000);
  48
  49         return 0;
  50 }
  51
  52 int dram_init_banksize(void)
  53 {
  54         gd->bd->bi_dram[0].start = (phys_addr_t)0;
  55         gd->bd->bi_dram[0].size = gd->ram_size;
  56
  57         return 0;
  58 }
  59
  60 #if defined(CONFIG_OF_BOARD_FIXUP)
  61 int board_fix_fdt(void *blob)
  62 {
  63         u8 topology[MAX_MOX_MODULES];
  64         int i, size, node;
  65         bool enable;
  66
  67         /*
  68          * SPI driver is not loaded in driver model yet, but we have to find out
  69          * if pcie should be enabled in U-Boot's device tree. Therefore we have
  70          * to read SPI by reading/writing SPI registers directly
  71          */
  72
  73         writel(0x563fa, ARMADA_37XX_NB_GPIO_SEL);
  74         writel(0x10df, ARMADA_37XX_SPI_CFG);
  75         writel(0x2005b, ARMADA_37XX_SPI_CTRL);
  76
  77         while (!(readl(ARMADA_37XX_SPI_CTRL) & 0x2))
  78                 udelay(1);
  79
  80         for (i = 0; i < MAX_MOX_MODULES; ++i) {
  81                 writel(0x0, ARMADA_37XX_SPI_DOUT);
  82
  83                 while (!(readl(ARMADA_37XX_SPI_CTRL) & 0x2))
  84                         udelay(1);
  85
  86                 topology[i] = readl(ARMADA_37XX_SPI_DIN) & 0xff;
  87                 if (topology[i] == 0xff)
  88                         break;
  89
  90                 topology[i] &= 0xf;
  91         }
  92
  93         size = i;
  94
  95         writel(0x5b, ARMADA_37XX_SPI_CTRL);
  96
  97         if (size > 1 && (topology[1] == MOX_MODULE_PCI ||
  98                          topology[1] == MOX_MODULE_USB3 ||
  99                          topology[1] == MOX_MODULE_PASSPCI))
 100                 enable = true;
 101         else
 102                 enable = false;
 103
 104         node = fdt_path_offset(blob, PCIE_PATH);
 105
 106         if (node < 0) {
 107                 printf("Cannot find PCIe node in U-Boot's device tree!\n");
 108                 return 0;
 109         }
 110
 111         if (fdt_setprop_string(blob, node, "status",
 112                                enable ? "okay" : "disabled") < 0) {
 113                 printf("Cannot %s PCIe in U-Boot's device tree!\n",
 114                        enable ? "enable" : "disable");
 115                 return 0;
 116         }
 117
 118         return 0;
 119 }
 120 #endif
 121
 122 #ifdef CONFIG_WDT_ARMADA_37XX
 123 static struct udevice *watchdog_dev __attribute__((section(".data"))) = NULL;
 124
 125 void watchdog_reset(void)
 126 {
 127         static ulong next_reset;
 128         ulong now;
 129
 130         if (!watchdog_dev)
 131                 return;
 132
 133         now = timer_get_us();
 134
 135         /* Do not reset the watchdog too often */
 136         if (now > next_reset) {
 137                 wdt_reset(watchdog_dev);
 138                 next_reset = now + 100000;
 139         }
 140 }
 141 #endif
 142
 143 int board_init(void)
 144 {
 145         /* address of boot parameters */
 146         gd->bd->bi_boot_params = CONFIG_SYS_SDRAM_BASE + 0x100;
 147
 148 #ifdef CONFIG_WDT_ARMADA_37XX
 149         if (uclass_get_device(UCLASS_WDT, 0, &watchdog_dev)) {
 150                 printf("Cannot find Armada 3720 watchdog!\n");
 151         } else {
 152                 printf("Enabling Armada 3720 watchdog (3 minutes timeout).\n");
 153                 wdt_start(watchdog_dev, 180000, 0);
 154         }
 155 #endif
 156
 157         return 0;
 158 }
 159
 160 static int mox_do_spi(u8 *in, u8 *out, size_t size)
 161 {
 162         struct spi_slave *slave;
 163         struct udevice *dev;
 164         int ret;
 165
 166         ret = spi_get_bus_and_cs(0, 1, 1000000, SPI_CPHA | SPI_CPOL,
 167                                  "spi_generic_drv", "moxtet@1", &dev,
 168                                  &slave);
 169         if (ret)
 170                 goto fail;
 171
 172         ret = spi_claim_bus(slave);
 173         if (ret)
 174                 goto fail_free;
 175
 176         ret = spi_xfer(slave, size * 8, out, in, SPI_XFER_ONCE);
 177
 178         spi_release_bus(slave);
 179 fail_free:
 180         spi_free_slave(slave);
 181 fail:
 182         return ret;
 183 }
 184
 185 static int mox_get_topology(const u8 **ptopology, int *psize, int *pis_sd)
 186 {
 187         static int is_sd;
 188         static u8 topology[MAX_MOX_MODULES - 1];
 189         static int size;
 190         u8 din[MAX_MOX_MODULES], dout[MAX_MOX_MODULES];
 191         int ret, i;
 192
 193         if (size) {
 194                 if (ptopology)
 195                         *ptopology = topology;
 196                 if (psize)
 197                         *psize = size;
 198                 if (pis_sd)
 199                         *pis_sd = is_sd;
 200                 return 0;
 201         }
 202
 203         memset(din, 0, MAX_MOX_MODULES);
 204         memset(dout, 0, MAX_MOX_MODULES);
 205
 206         ret = mox_do_spi(din, dout, MAX_MOX_MODULES);
 207         if (ret)
 208                 return ret;
 209
 210         if (din[0] == 0x10)
 211                 is_sd = 1;
 212         else if (din[0] == 0x00)
 213                 is_sd = 0;
 214         else
 215                 return -ENODEV;
 216
 217         for (i = 1; i < MAX_MOX_MODULES && din[i] != 0xff; ++i)
 218                 topology[i - 1] = din[i] & 0xf;
 219         size = i - 1;
 220
 221         if (ptopology)
 222                 *ptopology = topology;
 223         if (psize)
 224                 *psize = size;
 225         if (pis_sd)
 226                 *pis_sd = is_sd;
 227
 228         return 0;
 229 }
 230
 231 int comphy_update_map(struct comphy_map *serdes_map, int count)
 232 {
 233         int ret, i, size, sfpindex = -1, swindex = -1;
 234         const u8 *topology;
 235
 236         ret = mox_get_topology(&topology, &size, NULL);
 237         if (ret)
 238                 return ret;
 239
 240         for (i = 0; i < size; ++i) {
 241                 if (topology[i] == MOX_MODULE_SFP && sfpindex == -1)
 242                         sfpindex = i;
 243                 else if ((topology[i] == MOX_MODULE_TOPAZ ||
 244                           topology[i] == MOX_MODULE_PERIDOT) &&
 245                          swindex == -1)
 246                         swindex = i;
 247         }
 248
 249         if (sfpindex >= 0 && swindex >= 0) {
 250                 if (sfpindex < swindex)
 251                         serdes_map[0].speed = PHY_SPEED_1_25G;
 252                 else
 253                         serdes_map[0].speed = PHY_SPEED_3_125G;
 254         } else if (sfpindex >= 0) {
 255                 serdes_map[0].speed = PHY_SPEED_1_25G;
 256         } else if (swindex >= 0) {
 257                 serdes_map[0].speed = PHY_SPEED_3_125G;
 258         }
 259
 260         return 0;
 261 }
 262
 263 #define SW_SMI_CMD_R(d, r)      (0x9800 | (((d) & 0x1f) << 5) | ((r) & 0x1f))
 264 #define SW_SMI_CMD_W(d, r)      (0x9400 | (((d) & 0x1f) << 5) | ((r) & 0x1f))
 265
 266 static int sw_multi_read(struct mii_dev *bus, int sw, int dev, int reg)
 267 {
 268         bus->write(bus, sw, 0, 0, SW_SMI_CMD_R(dev, reg));
 269         mdelay(5);
 270         return bus->read(bus, sw, 0, 1);
 271 }
 272
 273 static void sw_multi_write(struct mii_dev *bus, int sw, int dev, int reg,
 274                            u16 val)
 275 {
 276         bus->write(bus, sw, 0, 1, val);
 277         bus->write(bus, sw, 0, 0, SW_SMI_CMD_W(dev, reg));
 278         mdelay(5);
 279 }
 280
 281 static int sw_scratch_read(struct mii_dev *bus, int sw, int reg)
 282 {
 283         sw_multi_write(bus, sw, 0x1c, 0x1a, (reg & 0x7f) << 8);
 284         return sw_multi_read(bus, sw, 0x1c, 0x1a) & 0xff;
 285 }
 286
 287 static void sw_led_write(struct mii_dev *bus, int sw, int port, int reg,
 288                          u16 val)
 289 {
 290         sw_multi_write(bus, sw, port, 0x16, 0x8000 | ((reg & 7) << 12)
 291                                             | (val & 0x7ff));
 292 }
 293
 294 static void sw_blink_leds(struct mii_dev *bus, int peridot, int topaz)
 295 {
 296         int i, p;
 297         struct {
 298                 int port;
 299                 u16 val;
 300                 int wait;
 301         } regs[] = {
 302                 { 2, 0xef, 1 }, { 2, 0xfe, 1 }, { 2, 0x33, 0 },
 303                 { 4, 0xef, 1 }, { 4, 0xfe, 1 }, { 4, 0x33, 0 },
 304                 { 3, 0xfe, 1 }, { 3, 0xef, 1 }, { 3, 0x33, 0 },
 305                 { 1, 0xfe, 1 }, { 1, 0xef, 1 }, { 1, 0x33, 0 }
 306         };
 307
 308         for (i = 0; i < 12; ++i) {
 309                 for (p = 0; p < peridot; ++p) {
 310                         sw_led_write(bus, 0x10 + p, regs[i].port, 0,
 311                                      regs[i].val);
 312                         sw_led_write(bus, 0x10 + p, regs[i].port + 4, 0,
 313                                      regs[i].val);
 314                 }
 315                 if (topaz) {
 316                         sw_led_write(bus, 0x2, 0x10 + regs[i].port, 0,
 317                                      regs[i].val);
 318                 }
 319
 320                 if (regs[i].wait)
 321                         mdelay(75);
 322         }
 323 }
 324
 325 static void check_switch_address(struct mii_dev *bus, int addr)
 326 {
 327         if (sw_scratch_read(bus, addr, 0x70) >> 3 != addr)
 328                 printf("Check of switch MDIO address failed for 0x%02x\n",
 329                        addr);
 330 }
 331
 332 static int sfp, pci, topaz, peridot, usb, passpci;
 333 static int sfp_pos, peridot_pos[3];
 334 static int module_count;
 335
 336 static int configure_peridots(struct gpio_desc *reset_gpio)
 337 {
 338         int i, ret;
 339         u8 dout[MAX_MOX_MODULES];
 340
 341         memset(dout, 0, MAX_MOX_MODULES);
 342
 343         /* set addresses of Peridot modules */
 344         for (i = 0; i < peridot; ++i)
 345                 dout[module_count - peridot_pos[i]] = (~i) & 3;
 346
 347         /*
 348          * if there is a SFP module connected to the last Peridot module, set
 349          * the P10_SMODE to 1 for the Peridot module
 350          */
 351         if (sfp)
 352                 dout[module_count - peridot_pos[i - 1]] |= 1 << 3;
 353
 354         dm_gpio_set_value(reset_gpio, 1);
 355         mdelay(10);
 356
 357         ret = mox_do_spi(NULL, dout, module_count + 1);
 358
 359         mdelay(10);
 360         dm_gpio_set_value(reset_gpio, 0);
 361
 362         mdelay(50);
 363
 364         return ret;
 365 }
 366
 367 static int get_reset_gpio(struct gpio_desc *reset_gpio)
 368 {
 369         int node;
 370
 371         node = fdt_node_offset_by_compatible(gd->fdt_blob, 0, "cznic,moxtet");
 372         if (node < 0) {
 373                 printf("Cannot find Moxtet bus device node!\n");
 374                 return -1;
 375         }
 376
 377         gpio_request_by_name_nodev(offset_to_ofnode(node), "reset-gpios", 0,
 378                                    reset_gpio, GPIOD_IS_OUT);
 379
 380         if (!dm_gpio_is_valid(reset_gpio)) {
 381                 printf("Cannot find reset GPIO for Moxtet bus!\n");
 382                 return -1;
 383         }
 384
 385         return 0;
 386 }
 387
 388 int misc_init_r(void)
 389 {
 390         int ret;
 391         u8 mac1[6], mac2[6];
 392
 393         ret = mbox_sp_get_board_info(NULL, mac1, mac2, NULL, NULL);
 394         if (ret < 0) {
 395                 printf("Cannot read data from OTP!\n");
 396                 return 0;
 397         }
 398
 399         if (is_valid_ethaddr(mac1) && !env_get("ethaddr"))
 400                 eth_env_set_enetaddr("ethaddr", mac1);
 401
 402         if (is_valid_ethaddr(mac2) && !env_get("eth1addr"))
 403                 eth_env_set_enetaddr("eth1addr", mac2);
 404
 405         return 0;
 406 }
 407
 408 static void mox_print_info(void)
 409 {
 410         int ret, board_version, ram_size;
 411         u64 serial_number;
 412         const char *pub_key;
 413
 414         ret = mbox_sp_get_board_info(&serial_number, NULL, NULL, &board_version,
 415                                      &ram_size);
 416         if (ret < 0)
 417                 return;
 418
 419         printf("Turris Mox:\n");
 420         printf("  Board version: %i\n", board_version);
 421         printf("  RAM size: %i MiB\n", ram_size);
 422         printf("  Serial Number: %016llX\n", serial_number);
 423
 424         pub_key = mox_sp_get_ecdsa_public_key();
 425         if (pub_key)
 426                 printf("  ECDSA Public Key: %s\n", pub_key);
 427         else
 428                 printf("Cannot read ECDSA Public Key\n");
 429 }
 430
 431 int last_stage_init(void)
 432 {
 433         int ret, i;
 434         const u8 *topology;
 435         int is_sd;
 436         struct mii_dev *bus;
 437         struct gpio_desc reset_gpio = {};
 438
 439         mox_print_info();
 440
 441         ret = mox_get_topology(&topology, &module_count, &is_sd);
 442         if (ret) {
 443                 printf("Cannot read module topology!\n");
 444                 return 0;
 445         }
 446
 447         printf("  SD/eMMC version: %s\n", is_sd ? "SD" : "eMMC");
 448
 449         if (module_count)
 450                 printf("Module Topology:\n");
 451
 452         for (i = 0; i < module_count; ++i) {
 453                 switch (topology[i]) {
 454                 case MOX_MODULE_SFP:
 455                         printf("% 4i: SFP Module\n", i + 1);
 456                         break;
 457                 case MOX_MODULE_PCI:
 458                         printf("% 4i: Mini-PCIe Module\n", i + 1);
 459                         break;
 460                 case MOX_MODULE_TOPAZ:
 461                         printf("% 4i: Topaz Switch Module (4-port)\n", i + 1);
 462                         break;
 463                 case MOX_MODULE_PERIDOT:
 464                         printf("% 4i: Peridot Switch Module (8-port)\n", i + 1);
 465                         break;
 466                 case MOX_MODULE_USB3:
 467                         printf("% 4i: USB 3.0 Module (4 ports)\n", i + 1);
 468                         break;
 469                 case MOX_MODULE_PASSPCI:
 470                         printf("% 4i: Passthrough Mini-PCIe Module\n", i + 1);
 471                         break;
 472                 default:
 473                         printf("% 4i: unknown (ID %i)\n", i + 1, topology[i]);
 474                 }
 475         }
 476
 477         /* now check if modules are connected in supported mode */
 478
 479         for (i = 0; i < module_count; ++i) {
 480                 switch (topology[i]) {
 481                 case MOX_MODULE_SFP:
 482                         if (sfp) {
 483                                 printf("Error: Only one SFP module is supported!\n");
 484                         } else if (topaz) {
 485                                 printf("Error: SFP module cannot be connected after Topaz Switch module!\n");
 486                         } else {
 487                                 sfp_pos = i;
 488                                 ++sfp;
 489                         }
 490                         break;
 491                 case MOX_MODULE_PCI:
 492                         if (pci) {
 493                                 printf("Error: Only one Mini-PCIe module is supported!\n");
 494                         } else if (usb) {
 495                                 printf("Error: Mini-PCIe module cannot come after USB 3.0 module!\n");
 496                         } else if (i && (i != 1 || !passpci)) {
 497                                 printf("Error: Mini-PCIe module should be the first connected module or come right after Passthrough Mini-PCIe module!\n");
 498                         } else {
 499                                 ++pci;
 500                         }
 501                         break;
 502                 case MOX_MODULE_TOPAZ:
 503                         if (topaz) {
 504                                 printf("Error: Only one Topaz module is supported!\n");
 505                         } else if (peridot >= 3) {
 506                                 printf("Error: At most two Peridot modules can come before Topaz module!\n");
 507                         } else {
 508                                 ++topaz;
 509                         }
 510                         break;
 511                 case MOX_MODULE_PERIDOT:
 512                         if (sfp || topaz) {
 513                                 printf("Error: Peridot module must come before SFP or Topaz module!\n");
 514                         } else if (peridot >= 3) {
 515                                 printf("Error: At most three Peridot modules are supported!\n");
 516                         } else {
 517                                 peridot_pos[peridot] = i;
 518                                 ++peridot;
 519                         }
 520                         break;
 521                 case MOX_MODULE_USB3:
 522                         if (pci) {
 523                                 printf("Error: USB 3.0 module cannot come after Mini-PCIe module!\n");
 524                         } else if (usb) {
 525                                 printf("Error: Only one USB 3.0 module is supported!\n");
 526                         } else if (i && (i != 1 || !passpci)) {
 527                                 printf("Error: USB 3.0 module should be the first connected module or come right after Passthrough Mini-PCIe module!\n");
 528                         } else {
 529                                 ++usb;
 530                         }
 531                         break;
 532                 case MOX_MODULE_PASSPCI:
 533                         if (passpci) {
 534                                 printf("Error: Only one Passthrough Mini-PCIe module is supported!\n");
 535                         } else if (i != 0) {
 536                                 printf("Error: Passthrough Mini-PCIe module should be the first connected module!\n");
 537                         } else {
 538                                 ++passpci;
 539                         }
 540                 }
 541         }
 542
 543         /* now configure modules */
 544
 545         if (get_reset_gpio(&reset_gpio) < 0)
 546                 return 0;
 547
 548         if (peridot > 0) {
 549                 if (configure_peridots(&reset_gpio) < 0) {
 550                         printf("Cannot configure Peridot modules!\n");
 551                         peridot = 0;
 552                 }
 553         } else {
 554                 dm_gpio_set_value(&reset_gpio, 1);
 555                 mdelay(50);
 556                 dm_gpio_set_value(&reset_gpio, 0);
 557                 mdelay(50);
 558         }
 559
 560         if (peridot || topaz) {
 561                 /*
 562                  * now check if the addresses are set by reading Scratch & Misc
 563                  * register 0x70 of Peridot (and potentially Topaz) modules
 564                  */
 565
 566                 bus = miiphy_get_dev_by_name("neta@30000");
 567                 if (!bus) {
 568                         printf("Cannot get MDIO bus device!\n");
 569                 } else {
 570                         for (i = 0; i < peridot; ++i)
 571                                 check_switch_address(bus, 0x10 + i);
 572
 573                         if (topaz)
 574                                 check_switch_address(bus, 0x2);
 575
 576                         sw_blink_leds(bus, peridot, topaz);
 577                 }
 578         }
 579
 580         printf("\n");
 581
 582         return 0;
 583 }