git.sur5r.net Git - u-boot/blob - board/samsung/universal_c210/universal.c

   1 /*
   2  *  Copyright (C) 2010 Samsung Electronics
   3  *  Minkyu Kang <mk7.kang@samsung.com>
   4  *  Kyungmin Park <kyungmin.park@samsung.com>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <spi.h>
  11 #include <lcd.h>
  12 #include <asm/io.h>
  13 #include <asm/gpio.h>
  14 #include <asm/arch/adc.h>
  15 #include <asm/arch/pinmux.h>
  16 #include <asm/arch/watchdog.h>
  17 #include <ld9040.h>
  18 #include <power/pmic.h>
  19 #include <usb.h>
  20 #include <usb/dwc2_udc.h>
  21 #include <asm/arch/cpu.h>
  22 #include <power/max8998_pmic.h>
  23 #include <libtizen.h>
  24 #include <samsung/misc.h>
  25 #include <usb_mass_storage.h>
  26
  27 DECLARE_GLOBAL_DATA_PTR;
  28
  29 unsigned int board_rev;
  30
  31 u32 get_board_rev(void)
  32 {
  33         return board_rev;
  34 }
  35
  36 static int get_hwrev(void)
  37 {
  38         return board_rev & 0xFF;
  39 }
  40
  41 int exynos_power_init(void)
  42 {
  43 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
  44         int ret;
  45
  46         /*
  47          * For PMIC the I2C bus is named as I2C5, but it is connected
  48          * to logical I2C adapter 0
  49          */
  50         ret = pmic_init(I2C_0);
  51         if (ret)
  52                 return ret;
  53
  54         init_pmic_lcd();
  55 #endif
  56         return 0;
  57 }
  58
  59 static unsigned short get_adc_value(int channel)
  60 {
  61         struct s5p_adc *adc = (struct s5p_adc *)samsung_get_base_adc();
  62         unsigned short ret = 0;
  63         unsigned int reg;
  64         unsigned int loop = 0;
  65
  66         writel(channel & 0xF, &adc->adcmux);
  67         writel((1 << 14) | (49 << 6), &adc->adccon);
  68         writel(1000 & 0xffff, &adc->adcdly);
  69         writel(readl(&adc->adccon) | (1 << 16), &adc->adccon); /* 12 bit */
  70         udelay(10);
  71         writel(readl(&adc->adccon) | (1 << 0), &adc->adccon); /* Enable */
  72         udelay(10);
  73
  74         do {
  75                 udelay(1);
  76                 reg = readl(&adc->adccon);
  77         } while (!(reg & (1 << 15)) && (loop++ < 1000));
  78
  79         ret = readl(&adc->adcdat0) & 0xFFF;
  80
  81         return ret;
  82 }
  83
  84 static int adc_power_control(int on)
  85 {
  86 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
  87         int ret;
  88         struct pmic *p = pmic_get("MAX8998_PMIC");
  89         if (!p)
  90                 return -ENODEV;
  91
  92         if (pmic_probe(p))
  93                 return -1;
  94
  95         ret = pmic_set_output(p,
  96                               MAX8998_REG_ONOFF1,
  97                               MAX8998_LDO4, !!on);
  98
  99         return ret;
 100 #else
 101         return 0;
 102 #endif
 103 }
 104
 105 static unsigned int get_hw_revision(void)
 106 {
 107         int hwrev, mode0, mode1;
 108
 109         adc_power_control(1);
 110
 111         mode0 = get_adc_value(1);               /* HWREV_MODE0 */
 112         mode1 = get_adc_value(2);               /* HWREV_MODE1 */
 113
 114         /*
 115          * XXX Always set the default hwrev as the latest board
 116          * ADC = (voltage) / 3.3 * 4096
 117          */
 118         hwrev = 3;
 119
 120 #define IS_RANGE(x, min, max)   ((x) > (min) && (x) < (max))
 121         if (IS_RANGE(mode0, 80, 200) && IS_RANGE(mode1, 80, 200))
 122                 hwrev = 0x0;            /* 0.01V        0.01V */
 123         if (IS_RANGE(mode0, 750, 1000) && IS_RANGE(mode1, 80, 200))
 124                 hwrev = 0x1;            /* 610mV        0.01V */
 125         if (IS_RANGE(mode0, 1300, 1700) && IS_RANGE(mode1, 80, 200))
 126                 hwrev = 0x2;            /* 1.16V        0.01V */
 127         if (IS_RANGE(mode0, 2000, 2400) && IS_RANGE(mode1, 80, 200))
 128                 hwrev = 0x3;            /* 1.79V        0.01V */
 129 #undef IS_RANGE
 130
 131         debug("mode0: %d, mode1: %d, hwrev 0x%x\n", mode0, mode1, hwrev);
 132
 133         adc_power_control(0);
 134
 135         return hwrev;
 136 }
 137
 138 static void check_hw_revision(void)
 139 {
 140         int hwrev;
 141
 142         hwrev = get_hw_revision();
 143
 144         board_rev |= hwrev;
 145 }
 146
 147 #ifdef CONFIG_USB_GADGET
 148 static int s5pc210_phy_control(int on)
 149 {
 150 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
 151         int ret = 0;
 152         struct pmic *p = pmic_get("MAX8998_PMIC");
 153         if (!p)
 154                 return -ENODEV;
 155
 156         if (pmic_probe(p))
 157                 return -1;
 158
 159         if (on) {
 160                 ret |= pmic_set_output(p,
 161                                        MAX8998_REG_BUCK_ACTIVE_DISCHARGE3,
 162                                        MAX8998_SAFEOUT1, LDO_ON);
 163                 ret |= pmic_set_output(p, MAX8998_REG_ONOFF1,
 164                                       MAX8998_LDO3, LDO_ON);
 165                 ret |= pmic_set_output(p, MAX8998_REG_ONOFF2,
 166                                       MAX8998_LDO8, LDO_ON);
 167
 168         } else {
 169                 ret |= pmic_set_output(p, MAX8998_REG_ONOFF2,
 170                                       MAX8998_LDO8, LDO_OFF);
 171                 ret |= pmic_set_output(p, MAX8998_REG_ONOFF1,
 172                                       MAX8998_LDO3, LDO_OFF);
 173                 ret |= pmic_set_output(p,
 174                                        MAX8998_REG_BUCK_ACTIVE_DISCHARGE3,
 175                                        MAX8998_SAFEOUT1, LDO_OFF);
 176         }
 177
 178         if (ret) {
 179                 puts("MAX8998 LDO setting error!\n");
 180                 return -1;
 181         }
 182 #endif
 183         return 0;
 184 }
 185
 186 struct dwc2_plat_otg_data s5pc210_otg_data = {
 187         .phy_control = s5pc210_phy_control,
 188         .regs_phy = EXYNOS4_USBPHY_BASE,
 189         .regs_otg = EXYNOS4_USBOTG_BASE,
 190         .usb_phy_ctrl = EXYNOS4_USBPHY_CONTROL,
 191         .usb_flags = PHY0_SLEEP,
 192 };
 193 #endif
 194
 195 int board_usb_init(int index, enum usb_init_type init)
 196 {
 197         debug("USB_udc_probe\n");
 198         return dwc2_udc_probe(&s5pc210_otg_data);
 199 }
 200
 201 int exynos_early_init_f(void)
 202 {
 203         wdt_stop();
 204
 205         return 0;
 206 }
 207
 208 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
 209 static void init_pmic_lcd(void)
 210 {
 211         unsigned char val;
 212         int ret = 0;
 213
 214         struct pmic *p = pmic_get("MAX8998_PMIC");
 215
 216         if (!p)
 217                 return;
 218
 219         if (pmic_probe(p))
 220                 return;
 221
 222         /* LDO7 1.8V */
 223         val = 0x02; /* (1800 - 1600) / 100; */
 224         ret |= pmic_reg_write(p,  MAX8998_REG_LDO7, val);
 225
 226         /* LDO17 3.0V */
 227         val = 0xe; /* (3000 - 1600) / 100; */
 228         ret |= pmic_reg_write(p,  MAX8998_REG_LDO17, val);
 229
 230         /* Disable unneeded regulators */
 231         /*
 232          * ONOFF1
 233          * Buck1 ON, Buck2 OFF, Buck3 ON, Buck4 ON
 234          * LDO2 ON, LDO3 OFF, LDO4 OFF, LDO5 ON
 235          */
 236         val = 0xB9;
 237         ret |= pmic_reg_write(p,  MAX8998_REG_ONOFF1, val);
 238
 239         /* ONOFF2
 240          * LDO6 OFF, LDO7 ON, LDO8 OFF, LDO9 ON,
 241          * LDO10 OFF, LDO11 OFF, LDO12 OFF, LDO13 OFF
 242          */
 243         val = 0x50;
 244         ret |= pmic_reg_write(p,  MAX8998_REG_ONOFF2, val);
 245
 246         /* ONOFF3
 247          * LDO14 OFF, LDO15 OFF, LGO16 OFF, LDO17 OFF
 248          * EPWRHOLD OFF, EBATTMON OFF, ELBCNFG2 OFF, ELBCNFG1 OFF
 249          */
 250         val = 0x00;
 251         ret |= pmic_reg_write(p,  MAX8998_REG_ONOFF3, val);
 252
 253         if (ret)
 254                 puts("LCD pmic initialisation error!\n");
 255 }
 256 #endif
 257
 258 void exynos_cfg_lcd_gpio(void)
 259 {
 260         unsigned int i, f3_end = 4;
 261
 262         for (i = 0; i < 8; i++) {
 263                 /* set GPF0,1,2[0:7] for RGB Interface and Data lines (32bit) */
 264                 gpio_cfg_pin(EXYNOS4_GPIO_F00 + i, S5P_GPIO_FUNC(2));
 265                 gpio_cfg_pin(EXYNOS4_GPIO_F10 + i, S5P_GPIO_FUNC(2));
 266                 gpio_cfg_pin(EXYNOS4_GPIO_F20 + i, S5P_GPIO_FUNC(2));
 267                 /* pull-up/down disable */
 268                 gpio_set_pull(EXYNOS4_GPIO_F00 + i, S5P_GPIO_PULL_NONE);
 269                 gpio_set_pull(EXYNOS4_GPIO_F10 + i, S5P_GPIO_PULL_NONE);
 270                 gpio_set_pull(EXYNOS4_GPIO_F20 + i, S5P_GPIO_PULL_NONE);
 271
 272                 /* drive strength to max (24bit) */
 273                 gpio_set_drv(EXYNOS4_GPIO_F00 + i, S5P_GPIO_DRV_4X);
 274                 gpio_set_rate(EXYNOS4_GPIO_F00 + i, S5P_GPIO_DRV_SLOW);
 275                 gpio_set_drv(EXYNOS4_GPIO_F10 + i, S5P_GPIO_DRV_4X);
 276                 gpio_set_rate(EXYNOS4_GPIO_F10 + i, S5P_GPIO_DRV_SLOW);
 277                 gpio_set_drv(EXYNOS4_GPIO_F20 + i, S5P_GPIO_DRV_4X);
 278                 gpio_set_rate(EXYNOS4_GPIO_F00 + i, S5P_GPIO_DRV_SLOW);
 279         }
 280
 281         for (i = EXYNOS4_GPIO_F30; i < (EXYNOS4_GPIO_F30 + f3_end); i++) {
 282                 /* set GPF3[0:3] for RGB Interface and Data lines (32bit) */
 283                 gpio_cfg_pin(i, S5P_GPIO_FUNC(2));
 284                 /* pull-up/down disable */
 285                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 286                 /* drive strength to max (24bit) */
 287                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 288                 gpio_set_rate(i, S5P_GPIO_DRV_SLOW);
 289         }
 290
 291         /* gpio pad configuration for LCD reset. */
 292         gpio_request(EXYNOS4_GPIO_Y45, "lcd_reset");
 293         gpio_cfg_pin(EXYNOS4_GPIO_Y45, S5P_GPIO_OUTPUT);
 294 }
 295
 296 int mipi_power(void)
 297 {
 298         return 0;
 299 }
 300
 301 void exynos_reset_lcd(void)
 302 {
 303         gpio_set_value(EXYNOS4_GPIO_Y45, 1);
 304         udelay(10000);
 305         gpio_set_value(EXYNOS4_GPIO_Y45, 0);
 306         udelay(10000);
 307         gpio_set_value(EXYNOS4_GPIO_Y45, 1);
 308         udelay(100);
 309 }
 310
 311 void exynos_lcd_power_on(void)
 312 {
 313 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
 314         struct pmic *p = pmic_get("MAX8998_PMIC");
 315
 316         if (!p)
 317                 return;
 318
 319         if (pmic_probe(p))
 320                 return;
 321
 322         pmic_set_output(p, MAX8998_REG_ONOFF3, MAX8998_LDO17, LDO_ON);
 323         pmic_set_output(p, MAX8998_REG_ONOFF2, MAX8998_LDO7, LDO_ON);
 324 #endif
 325 }
 326
 327 void exynos_cfg_ldo(void)
 328 {
 329         ld9040_cfg_ldo();
 330 }
 331
 332 void exynos_enable_ldo(unsigned int onoff)
 333 {
 334         ld9040_enable_ldo(onoff);
 335 }
 336
 337 int exynos_init(void)
 338 {
 339 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
 340         char buf[16];
 341 #endif
 342         gd->bd->bi_arch_number = MACH_TYPE_UNIVERSAL_C210;
 343
 344         switch (get_hwrev()) {
 345         case 0:
 346                 /*
 347                  * Set the low to enable LDO_EN
 348                  * But when you use the test board for eMMC booting
 349                  * you should set it HIGH since it removes the inverter
 350                  */
 351                 /* MASSMEMORY_EN: XMDMDATA_6: GPE3[6] */
 352                 gpio_request(EXYNOS4_GPIO_E36, "ldo_en");
 353                 gpio_direction_output(EXYNOS4_GPIO_E36, 0);
 354                 break;
 355         default:
 356                 /*
 357                  * Default reset state is High and there's no inverter
 358                  * But set it as HIGH to ensure
 359                  */
 360                 /* MASSMEMORY_EN: XMDMADDR_3: GPE1[3] */
 361                 gpio_request(EXYNOS4_GPIO_E13, "massmemory_en");
 362                 gpio_direction_output(EXYNOS4_GPIO_E13, 1);
 363                 break;
 364         }
 365
 366 #ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
 367         /* Request soft I2C gpios */
 368         strcpy(buf, "soft_i2c_scl");
 369         gpio_request(CONFIG_SOFT_I2C_GPIO_SCL, buf);
 370
 371         strcpy(buf, "soft_i2c_sda");
 372         gpio_request(CONFIG_SOFT_I2C_GPIO_SDA, buf);
 373 #endif
 374         check_hw_revision();
 375         printf("HW Revision:\t0x%x\n", board_rev);
 376
 377         return 0;
 378 }
 379
 380 #ifdef CONFIG_LCD
 381 void exynos_lcd_misc_init(vidinfo_t *vid)
 382 {
 383 #ifdef CONFIG_TIZEN
 384         get_tizen_logo_info(vid);
 385 #endif
 386
 387         /* for LD9040. */
 388         vid->pclk_name = 1;     /* MPLL */
 389         vid->sclk_div = 1;
 390
 391         setenv("lcdinfo", "lcd=ld9040");
 392 }
 393 #endif