board/samtec/vining_2000/vining_2000.c

   1 /*
   2  * Copyright (C) 2016 samtec automotive software & electronics gmbh
   3  *
   4  * Author: Christoph Fritz <chf.fritz@googlemail.com>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <asm/arch/clock.h>
  10 #include <asm/arch/crm_regs.h>
  11 #include <asm/arch/iomux.h>
  12 #include <asm/arch/imx-regs.h>
  13 #include <asm/arch/mx6-pins.h>
  14 #include <asm/arch/sys_proto.h>
  15 #include <asm/gpio.h>
  16 #include <asm/imx-common/iomux-v3.h>
  17 #include <asm/io.h>
  18 #include <asm/imx-common/mxc_i2c.h>
  19 #include <linux/sizes.h>
  20 #include <common.h>
  21 #include <fsl_esdhc.h>
  22 #include <mmc.h>
  23 #include <i2c.h>
  24 #include <miiphy.h>
  25 #include <netdev.h>
  26 #include <power/pmic.h>
  27 #include <power/pfuze100_pmic.h>
  28 #include <usb.h>
  29 #include <usb/ehci-ci.h>
  30 #include <pwm.h>
  31 #include <wait_bit.h>
  32
  33 DECLARE_GLOBAL_DATA_PTR;
  34
  35 #define UART_PAD_CTRL  (PAD_CTL_HYS | PAD_CTL_PUS_100K_UP |     \
  36         PAD_CTL_PKE | PAD_CTL_SPEED_MED | PAD_CTL_DSE_40ohm |   \
  37         PAD_CTL_SRE_FAST)
  38
  39 #define ENET_PAD_CTRL  (PAD_CTL_PUS_100K_UP | PAD_CTL_PKE |     \
  40         PAD_CTL_SPEED_HIGH | PAD_CTL_DSE_48ohm |                \
  41         PAD_CTL_SRE_FAST)
  42
  43 #define ENET_CLK_PAD_CTRL  PAD_CTL_DSE_34ohm
  44
  45 #define ENET_RX_PAD_CTRL  (PAD_CTL_PKE |                        \
  46         PAD_CTL_PUS_100K_DOWN | PAD_CTL_SPEED_HIGH |            \
  47         PAD_CTL_SRE_FAST)
  48
  49 #define I2C_PAD_CTRL  (PAD_CTL_HYS | PAD_CTL_PUS_100K_UP |      \
  50         PAD_CTL_PKE | PAD_CTL_ODE | PAD_CTL_SPEED_MED |         \
  51         PAD_CTL_DSE_40ohm)
  52
  53 #define USDHC_CLK_PAD_CTRL  (PAD_CTL_HYS | PAD_CTL_SPEED_MED |  \
  54         PAD_CTL_DSE_80ohm | PAD_CTL_SRE_FAST)
  55
  56 #define USDHC_PAD_CTRL  (PAD_CTL_HYS | PAD_CTL_PUS_47K_UP |     \
  57         PAD_CTL_PKE |  PAD_CTL_SPEED_MED | PAD_CTL_DSE_80ohm |  \
  58         PAD_CTL_SRE_FAST)
  59
  60 #define GPIO_PAD_CTRL  (PAD_CTL_HYS | PAD_CTL_PUS_100K_UP |     \
  61         PAD_CTL_PKE)
  62
  63 int dram_init(void)
  64 {
  65         gd->ram_size = imx_ddr_size();
  66
  67         return 0;
  68 }
  69
  70 static iomux_v3_cfg_t const uart1_pads[] = {
  71         MX6_PAD_GPIO1_IO04__UART1_TX | MUX_PAD_CTRL(UART_PAD_CTRL),
  72         MX6_PAD_GPIO1_IO05__UART1_RX | MUX_PAD_CTRL(UART_PAD_CTRL),
  73 };
  74
  75 static iomux_v3_cfg_t const usdhc2_pads[] = {
  76         MX6_PAD_SD2_CLK__USDHC2_CLK | MUX_PAD_CTRL(USDHC_CLK_PAD_CTRL),
  77         MX6_PAD_SD2_CMD__USDHC2_CMD | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  78         MX6_PAD_SD2_DATA0__USDHC2_DATA0 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  79         MX6_PAD_SD2_DATA1__USDHC2_DATA1 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  80         MX6_PAD_SD2_DATA2__USDHC2_DATA2 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  81         MX6_PAD_SD2_DATA3__USDHC2_DATA3 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  82         MX6_PAD_LCD1_VSYNC__GPIO3_IO_28 | MUX_PAD_CTRL(GPIO_PAD_CTRL),
  83 };
  84
  85 static iomux_v3_cfg_t const usdhc4_pads[] = {
  86         MX6_PAD_SD4_CLK__USDHC4_CLK | MUX_PAD_CTRL(USDHC_CLK_PAD_CTRL),
  87         MX6_PAD_SD4_CMD__USDHC4_CMD | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  88         MX6_PAD_SD4_DATA0__USDHC4_DATA0 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  89         MX6_PAD_SD4_DATA1__USDHC4_DATA1 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  90         MX6_PAD_SD4_DATA2__USDHC4_DATA2 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  91         MX6_PAD_SD4_DATA3__USDHC4_DATA3 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  92         MX6_PAD_SD4_DATA4__USDHC4_DATA4 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  93         MX6_PAD_SD4_DATA5__USDHC4_DATA5 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  94         MX6_PAD_SD4_DATA6__USDHC4_DATA6 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  95         MX6_PAD_SD4_DATA7__USDHC4_DATA7 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
  96 };
  97
  98 static iomux_v3_cfg_t const fec1_pads[] = {
  99         MX6_PAD_ENET1_MDC__ENET1_MDC | MUX_PAD_CTRL(ENET_PAD_CTRL),
 100         MX6_PAD_ENET1_MDIO__ENET1_MDIO | MUX_PAD_CTRL(ENET_PAD_CTRL),
 101         MX6_PAD_RGMII1_RD0__ENET1_RX_DATA_0 | MUX_PAD_CTRL(ENET_RX_PAD_CTRL),
 102         MX6_PAD_RGMII1_RD1__ENET1_RX_DATA_1 | MUX_PAD_CTRL(ENET_RX_PAD_CTRL),
 103         MX6_PAD_RGMII1_TD0__ENET1_TX_DATA_0 | MUX_PAD_CTRL(ENET_PAD_CTRL),
 104         MX6_PAD_RGMII1_TD1__ENET1_TX_DATA_1 | MUX_PAD_CTRL(ENET_PAD_CTRL),
 105         MX6_PAD_RGMII1_RX_CTL__ENET1_RX_EN | MUX_PAD_CTRL(ENET_RX_PAD_CTRL),
 106         MX6_PAD_RGMII1_TX_CTL__ENET1_TX_EN | MUX_PAD_CTRL(ENET_PAD_CTRL),
 107         MX6_PAD_ENET1_TX_CLK__ENET1_REF_CLK1 | MUX_PAD_CTRL(ENET_CLK_PAD_CTRL) |
 108                 MUX_MODE_SION,
 109         /* LAN8720 PHY Reset */
 110         MX6_PAD_RGMII1_TD3__GPIO5_IO_9 | MUX_PAD_CTRL(NO_PAD_CTRL),
 111 };
 112
 113 static iomux_v3_cfg_t const pwm_led_pads[] = {
 114         MX6_PAD_RGMII2_RD2__PWM2_OUT | MUX_PAD_CTRL(NO_PAD_CTRL), /* green */
 115         MX6_PAD_RGMII2_TD2__PWM6_OUT | MUX_PAD_CTRL(NO_PAD_CTRL), /* red */
 116         MX6_PAD_RGMII2_RD3__PWM1_OUT | MUX_PAD_CTRL(NO_PAD_CTRL), /* blue */
 117 };
 118
 119 static void setup_iomux_uart(void)
 120 {
 121         imx_iomux_v3_setup_multiple_pads(uart1_pads, ARRAY_SIZE(uart1_pads));
 122 }
 123
 124 #define PHY_RESET IMX_GPIO_NR(5, 9)
 125
 126 int board_eth_init(bd_t *bis)
 127 {
 128         struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR;
 129         int ret;
 130         unsigned char eth1addr[6];
 131
 132         /* just to get secound mac address */
 133         imx_get_mac_from_fuse(1, eth1addr);
 134         if (!getenv("eth1addr") && is_valid_ethaddr(eth1addr))
 135                 eth_setenv_enetaddr("eth1addr", eth1addr);
 136
 137         imx_iomux_v3_setup_multiple_pads(fec1_pads, ARRAY_SIZE(fec1_pads));
 138
 139         /*
 140          * Generate phy reference clock via pin IOMUX ENET_REF_CLK1/2 by erasing
 141          * ENET1/2_TX_CLK_DIR gpr1[14:13], so that reference clock is driven by
 142          * ref_enetpll0/1 and enable ENET1/2_TX_CLK output driver.
 143          */
 144         clrsetbits_le32(&iomuxc_regs->gpr[1],
 145                         IOMUX_GPR1_FEC1_CLOCK_MUX2_SEL_MASK |
 146                         IOMUX_GPR1_FEC2_CLOCK_MUX2_SEL_MASK,
 147                         IOMUX_GPR1_FEC1_CLOCK_MUX1_SEL_MASK |
 148                         IOMUX_GPR1_FEC2_CLOCK_MUX1_SEL_MASK);
 149
 150         ret = enable_fec_anatop_clock(0, ENET_50MHZ);
 151         if (ret)
 152                 goto eth_fail;
 153
 154         /* reset phy */
 155         gpio_direction_output(PHY_RESET, 0);
 156         mdelay(16);
 157         gpio_set_value(PHY_RESET, 1);
 158         mdelay(1);
 159
 160         ret = fecmxc_initialize_multi(bis, 0, CONFIG_FEC_MXC_PHYADDR,
 161                                         IMX_FEC_BASE);
 162         if (ret)
 163                 goto eth_fail;
 164
 165         return ret;
 166
 167 eth_fail:
 168         printf("FEC MXC: %s:failed (%i)\n", __func__, ret);
 169         gpio_set_value(PHY_RESET, 0);
 170         return ret;
 171 }
 172
 173 #define PC MUX_PAD_CTRL(I2C_PAD_CTRL)
 174 /* I2C1 for PMIC */
 175 static struct i2c_pads_info i2c_pad_info1 = {
 176         .scl = {
 177                 .i2c_mode = MX6_PAD_GPIO1_IO00__I2C1_SCL | PC,
 178                 .gpio_mode = MX6_PAD_GPIO1_IO00__GPIO1_IO_0 | PC,
 179                 .gp = IMX_GPIO_NR(1, 0),
 180         },
 181         .sda = {
 182                 .i2c_mode = MX6_PAD_GPIO1_IO01__I2C1_SDA | PC,
 183                 .gpio_mode = MX6_PAD_GPIO1_IO01__GPIO1_IO_1 | PC,
 184                 .gp = IMX_GPIO_NR(1, 1),
 185         },
 186 };
 187
 188 static struct pmic *pfuze_init(unsigned char i2cbus)
 189 {
 190         struct pmic *p;
 191         int ret;
 192         u32 reg;
 193
 194         ret = power_pfuze100_init(i2cbus);
 195         if (ret)
 196                 return NULL;
 197
 198         p = pmic_get("PFUZE100");
 199         ret = pmic_probe(p);
 200         if (ret)
 201                 return NULL;
 202
 203         pmic_reg_read(p, PFUZE100_DEVICEID, &reg);
 204         printf("PMIC:  PFUZE100 ID=0x%02x\n", reg);
 205
 206         /* Set SW1AB stanby volage to 0.975V */
 207         pmic_reg_read(p, PFUZE100_SW1ABSTBY, &reg);
 208         reg &= ~SW1x_STBY_MASK;
 209         reg |= SW1x_0_975V;
 210         pmic_reg_write(p, PFUZE100_SW1ABSTBY, reg);
 211
 212         /* Set SW1AB/VDDARM step ramp up time from 16us to 4us/25mV */
 213         pmic_reg_read(p, PFUZE100_SW1ABCONF, &reg);
 214         reg &= ~SW1xCONF_DVSSPEED_MASK;
 215         reg |= SW1xCONF_DVSSPEED_4US;
 216         pmic_reg_write(p, PFUZE100_SW1ABCONF, reg);
 217
 218         /* Set SW1C standby voltage to 0.975V */
 219         pmic_reg_read(p, PFUZE100_SW1CSTBY, &reg);
 220         reg &= ~SW1x_STBY_MASK;
 221         reg |= SW1x_0_975V;
 222         pmic_reg_write(p, PFUZE100_SW1CSTBY, reg);
 223
 224         /* Set SW1C/VDDSOC step ramp up time from 16us to 4us/25mV */
 225         pmic_reg_read(p, PFUZE100_SW1CCONF, &reg);
 226         reg &= ~SW1xCONF_DVSSPEED_MASK;
 227         reg |= SW1xCONF_DVSSPEED_4US;
 228         pmic_reg_write(p, PFUZE100_SW1CCONF, reg);
 229
 230         return p;
 231 }
 232
 233 static int pfuze_mode_init(struct pmic *p, u32 mode)
 234 {
 235         unsigned char offset, i, switch_num;
 236         u32 id;
 237         int ret;
 238
 239         pmic_reg_read(p, PFUZE100_DEVICEID, &id);
 240         id = id & 0xf;
 241
 242         if (id == 0) {
 243                 switch_num = 6;
 244                 offset = PFUZE100_SW1CMODE;
 245         } else if (id == 1) {
 246                 switch_num = 4;
 247                 offset = PFUZE100_SW2MODE;
 248         } else {
 249                 printf("Not supported, id=%d\n", id);
 250                 return -EINVAL;
 251         }
 252
 253         ret = pmic_reg_write(p, PFUZE100_SW1ABMODE, mode);
 254         if (ret < 0) {
 255                 printf("Set SW1AB mode error!\n");
 256                 return ret;
 257         }
 258
 259         for (i = 0; i < switch_num - 1; i++) {
 260                 ret = pmic_reg_write(p, offset + i * SWITCH_SIZE, mode);
 261                 if (ret < 0) {
 262                         printf("Set switch 0x%x mode error!\n",
 263                                offset + i * SWITCH_SIZE);
 264                         return ret;
 265                 }
 266         }
 267
 268         return ret;
 269 }
 270
 271 int power_init_board(void)
 272 {
 273         struct pmic *p;
 274         int ret;
 275
 276         p = pfuze_init(I2C_PMIC);
 277         if (!p)
 278                 return -ENODEV;
 279
 280         ret = pfuze_mode_init(p, APS_PFM);
 281         if (ret < 0)
 282                 return ret;
 283
 284         return 0;
 285 }
 286
 287 #ifdef CONFIG_USB_EHCI_MX6
 288 static iomux_v3_cfg_t const usb_otg_pads[] = {
 289         /* OGT1 */
 290         MX6_PAD_GPIO1_IO09__USB_OTG1_PWR | MUX_PAD_CTRL(NO_PAD_CTRL),
 291         MX6_PAD_GPIO1_IO10__ANATOP_OTG1_ID | MUX_PAD_CTRL(NO_PAD_CTRL),
 292         /* OTG2 */
 293         MX6_PAD_GPIO1_IO12__USB_OTG2_PWR | MUX_PAD_CTRL(NO_PAD_CTRL)
 294 };
 295
 296 static void setup_iomux_usb(void)
 297 {
 298         imx_iomux_v3_setup_multiple_pads(usb_otg_pads,
 299                                          ARRAY_SIZE(usb_otg_pads));
 300 }
 301
 302 int board_usb_phy_mode(int port)
 303 {
 304         if (port == 1)
 305                 return USB_INIT_HOST;
 306         else
 307                 return usb_phy_mode(port);
 308 }
 309 #endif
 310
 311 #ifdef CONFIG_PWM_IMX
 312 static int set_pwm_leds(void)
 313 {
 314         int ret;
 315
 316         imx_iomux_v3_setup_multiple_pads(pwm_led_pads,
 317                                          ARRAY_SIZE(pwm_led_pads));
 318         /* enable backlight PWM 2, green LED */
 319         ret = pwm_init(1, 0, 0);
 320         if (ret)
 321                 goto error;
 322         /* duty cycle 200ns, period: 8000ns */
 323         ret = pwm_config(1, 200, 8000);
 324         if (ret)
 325                 goto error;
 326         ret = pwm_enable(1);
 327         if (ret)
 328                 goto error;
 329
 330         /* enable backlight PWM 1, blue LED */
 331         ret = pwm_init(0, 0, 0);
 332         if (ret)
 333                 goto error;
 334         /* duty cycle 200ns, period: 8000ns */
 335         ret = pwm_config(0, 200, 8000);
 336         if (ret)
 337                 goto error;
 338         ret = pwm_enable(0);
 339         if (ret)
 340                 goto error;
 341
 342         /* enable backlight PWM 6, red LED */
 343         ret = pwm_init(5, 0, 0);
 344         if (ret)
 345                 goto error;
 346         /* duty cycle 200ns, period: 8000ns */
 347         ret = pwm_config(5, 200, 8000);
 348         if (ret)
 349                 goto error;
 350         ret = pwm_enable(5);
 351
 352 error:
 353         return ret;
 354 }
 355 #else
 356 static int set_pwm_leds(void)
 357 {
 358         return 0;
 359 }
 360 #endif
 361
 362 #define ADCx_HC0        0x00
 363 #define ADCx_HS         0x08
 364 #define ADCx_HS_C0      BIT(0)
 365 #define ADCx_R0         0x0c
 366 #define ADCx_CFG        0x14
 367 #define ADCx_CFG_SWMODE 0x308
 368 #define ADCx_GC         0x18
 369 #define ADCx_GC_CAL     BIT(7)
 370
 371 static int read_adc(u32 *val)
 372 {
 373         int ret;
 374         void __iomem *b = map_physmem(ADC1_BASE_ADDR, 0x100, MAP_NOCACHE);
 375
 376         /* use software mode */
 377         writel(ADCx_CFG_SWMODE, b + ADCx_CFG);
 378
 379         /* start auto calibration */
 380         setbits_le32(b + ADCx_GC, ADCx_GC_CAL);
 381         ret = wait_for_bit("ADC", b + ADCx_GC, ADCx_GC_CAL, ADCx_GC_CAL, 10, 0);
 382         if (ret)
 383                 goto adc_exit;
 384
 385         /* start conversion */
 386         writel(0, b + ADCx_HC0);
 387
 388         /* wait for conversion */
 389         ret = wait_for_bit("ADC", b + ADCx_HS, ADCx_HS_C0, ADCx_HS_C0, 10, 0);
 390         if (ret)
 391                 goto adc_exit;
 392
 393         /* read result */
 394         *val = readl(b + ADCx_R0);
 395
 396 adc_exit:
 397         if (ret)
 398                 printf("ADC failure (ret=%i)\n", ret);
 399         unmap_physmem(b, MAP_NOCACHE);
 400         return ret;
 401 }
 402
 403 #define VAL_UPPER       2498
 404 #define VAL_LOWER       1550
 405
 406 static int set_pin_state(void)
 407 {
 408         u32 val;
 409         int ret;
 410
 411         ret = read_adc(&val);
 412         if (ret)
 413                 return ret;
 414
 415         if (val >= VAL_UPPER)
 416                 setenv("pin_state", "connected");
 417         else if (val < VAL_UPPER && val > VAL_LOWER)
 418                 setenv("pin_state", "open");
 419         else
 420                 setenv("pin_state", "button");
 421
 422         return ret;
 423 }
 424
 425 int board_late_init(void)
 426 {
 427         int ret;
 428
 429         ret = set_pwm_leds();
 430         if (ret)
 431                 return ret;
 432
 433         ret = set_pin_state();
 434
 435         return ret;
 436 }
 437
 438 int board_early_init_f(void)
 439 {
 440         setup_iomux_uart();
 441
 442         setup_iomux_usb();
 443
 444         return 0;
 445 }
 446
 447 static struct fsl_esdhc_cfg usdhc_cfg[2] = {
 448         {USDHC4_BASE_ADDR, 0, 8},
 449         {USDHC2_BASE_ADDR, 0, 4},
 450 };
 451
 452 #define USDHC2_CD_GPIO IMX_GPIO_NR(3, 28)
 453
 454 int board_mmc_getcd(struct mmc *mmc)
 455 {
 456         struct fsl_esdhc_cfg *cfg = (struct fsl_esdhc_cfg *)mmc->priv;
 457
 458         if (cfg->esdhc_base == USDHC4_BASE_ADDR)
 459                 return 1;
 460         if (cfg->esdhc_base == USDHC2_BASE_ADDR)
 461                 return !gpio_get_value(USDHC2_CD_GPIO);
 462
 463         return -EINVAL;
 464 }
 465
 466 int board_mmc_init(bd_t *bis)
 467 {
 468         int ret;
 469
 470         /*
 471          * According to the board_mmc_init() the following map is done:
 472          * (U-Boot device node)    (Physical Port)
 473          * mmc0                    USDHC4
 474          * mmc1                    USDHC2
 475          */
 476         imx_iomux_v3_setup_multiple_pads(
 477                 usdhc4_pads, ARRAY_SIZE(usdhc4_pads));
 478         usdhc_cfg[0].sdhc_clk = mxc_get_clock(MXC_ESDHC4_CLK);
 479
 480         imx_iomux_v3_setup_multiple_pads(
 481                 usdhc2_pads, ARRAY_SIZE(usdhc2_pads));
 482         gpio_direction_input(USDHC2_CD_GPIO);
 483         usdhc_cfg[1].sdhc_clk = mxc_get_clock(MXC_ESDHC2_CLK);
 484
 485         ret = fsl_esdhc_initialize(bis, &usdhc_cfg[0]);
 486         if (ret) {
 487                 printf("Warning: failed to initialize USDHC4\n");
 488                 return ret;
 489         }
 490
 491         ret = fsl_esdhc_initialize(bis, &usdhc_cfg[1]);
 492         if (ret) {
 493                 printf("Warning: failed to initialize USDHC2\n");
 494                 return ret;
 495         }
 496
 497         return 0;
 498 }
 499
 500 int board_init(void)
 501 {
 502         /* Address of boot parameters */
 503         gd->bd->bi_boot_params = PHYS_SDRAM + 0x100;
 504
 505 #ifdef CONFIG_SYS_I2C_MXC
 506         setup_i2c(0, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info1);
 507 #endif
 508
 509         return 0;
 510 }
 511
 512 int checkboard(void)
 513 {
 514         puts("Board: VIN|ING 2000\n");
 515
 516         return 0;
 517 }