board/samsung/universal/universal.c

   1 /*
   2  * Copyright (C) 2009 Samsung Electronics
   3  * Kyungmin Park <kyungmin.park@samsung.com>
   4  * Minkyu Kang <mk7.kang@samsung.com>
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  22  * MA 02111-1307 USA
  23  */
  24
  25 #include <common.h>
  26 #include <i2c.h>
  27 #include <asm/io.h>
  28 #include <asm/arch/clk.h>
  29 #include <asm/arch/clock.h>
  30 #include <asm/arch/gpio.h>
  31 #include <asm/arch/keypad.h>
  32 #include <asm/arch/mmc.h>
  33 #include <asm/arch/power.h>
  34 #include <asm/arch/mem.h>
  35 #include <asm/errno.h>
  36 #include <fbutils.h>
  37 #include <lcd.h>
  38 #include <bmp_layout.h>
  39
  40 #include "animation_frames.h"
  41
  42 DECLARE_GLOBAL_DATA_PTR;
  43
  44 //#define ARIES 1
  45
  46 #define C100_MACH_START                 3000
  47 #define C110_MACH_START                 3100
  48
  49 static unsigned int board_rev;
  50 static unsigned int battery_soc;
  51 static struct s5pc110_gpio *s5pc110_gpio;
  52
  53 enum {
  54         I2C_2,
  55         I2C_GPIO3,
  56         I2C_PMIC,
  57         I2C_GPIO5,
  58         I2C_GPIO6,
  59         I2C_GPIO7,
  60 };
  61
  62 /*
  63  * i2c 2
  64  * SDA: GPD1[4]
  65  * SCL: GPD1[5]
  66  */
  67 static struct i2c_gpio_bus_data i2c_2 = {
  68         .sda_pin        = 4,
  69         .scl_pin        = 5,
  70 };
  71
  72 /*
  73  * i2c gpio3
  74  * SDA: GPJ3[6]
  75  * SCL: GPJ3[7]
  76  */
  77 static struct i2c_gpio_bus_data i2c_gpio3 = {
  78         .sda_pin        = 6,
  79         .scl_pin        = 7,
  80 };
  81
  82 /*
  83  * i2c pmic
  84  * SDA: GPJ4[0]
  85  * SCL: GPJ4[3]
  86  */
  87 static struct i2c_gpio_bus_data i2c_pmic = {
  88         .sda_pin        = 0,
  89         .scl_pin        = 3,
  90 };
  91
  92 /*
  93  * i2c gpio5
  94  * SDA: MP05[3]
  95  * SCL: MP05[2]
  96  */
  97 static struct i2c_gpio_bus_data i2c_gpio5 = {
  98         .sda_pin        = 3,
  99         .scl_pin        = 2,
 100 };
 101
 102 /*
 103  * i2c gpio6
 104  * SDA: GPJ3[0]
 105  * SCL: GPJ3[1]
 106  */
 107 static struct i2c_gpio_bus_data i2c_gpio6 = {
 108         .sda_pin        = 0,
 109         .scl_pin        = 1,
 110 };
 111
 112 /*
 113  * i2c gpio6 - cypress
 114  * SDA: GPJ3[4]
 115  * SCL: GPJ3[5]
 116  */
 117 static struct i2c_gpio_bus_data i2c_cypress_gpio6 = {
 118         .sda_pin        = 4,
 119         .scl_pin        = 5,
 120 };
 121
 122 /*
 123  * i2c gpio7 - cypress
 124  * SDA: MP05[6]
 125  * SCL: MP05[4]
 126  */
 127 static struct i2c_gpio_bus_data i2c_cypress_gpio7 = {
 128         .sda_pin        = 6,
 129         .scl_pin        = 4,
 130 };
 131
 132 /*
 133  * i2c gpio7 - kessler rev 09
 134  * SDA: MP05[1]
 135  * SCL: MP05[0]
 136  */
 137 static struct i2c_gpio_bus_data i2c_aries_gpio7 = {
 138         .sda_pin        = 1,
 139         .scl_pin        = 0,
 140 };
 141
 142
 143 static struct i2c_gpio_bus i2c_gpio[] = {
 144         {
 145                 .bus    = &i2c_2,
 146         }, {
 147                 .bus    = &i2c_gpio3,
 148         }, {
 149                 .bus    = &i2c_pmic,
 150         }, {
 151                 .bus    = &i2c_gpio5,
 152         }, {
 153                 .bus    = &i2c_gpio6,
 154         }, {
 155                 .bus    = NULL,
 156         }
 157 };
 158
 159 u32 get_board_rev(void)
 160 {
 161         return board_rev;
 162 }
 163
 164 static int hwrevision(int rev)
 165 {
 166         return (board_rev & 0xf) == rev;
 167 }
 168
 169 enum {
 170         MACH_UNIVERSAL,
 171         MACH_TICKERTAPE,
 172         MACH_AQUILA,
 173         MACH_P1P2,
 174         MACH_GEMINUS,
 175         MACH_CYPRESS,
 176 };
 177
 178 #define SPLIT_SCREEN_FEATURE    0x100
 179
 180 /* board is MACH_AQUILA and board is like below. */
 181 #define J1_B2_BOARD             0x200
 182 #define LIMO_UNIVERSAL_BOARD    0x400
 183 #define LIMO_REAL_BOARD         0x800
 184 #define MEDIA_BOARD             0x1000
 185 #define BAMBOO_BOARD            0x2000
 186
 187 #ifdef ARIES
 188 #define ARIES_BOARD     0x4000
 189 #endif /* ARIES */
 190
 191 /* board is MACH_P1P2 and board is like below. */
 192 #define P1_REAL_BOARD           0x200
 193 #define P2_REAL_BOARD           0x400
 194
 195 #define BOARD_MASK              0xF00
 196
 197 static int c110_machine_id(void)
 198 {
 199         return gd->bd->bi_arch_number - C110_MACH_START;
 200 }
 201
 202 static int machine_is_aquila(void)
 203 {
 204         return c110_machine_id() == MACH_AQUILA;
 205 }
 206
 207 static int machine_is_p1p2(void)
 208 {
 209         return c110_machine_id() == MACH_P1P2;
 210 }
 211
 212 static int machine_is_tickertape(void)
 213 {
 214         return c110_machine_id() == MACH_TICKERTAPE;
 215 }
 216
 217 static int machine_is_geminus(void)
 218 {
 219         return c110_machine_id() == MACH_GEMINUS;
 220 }
 221
 222 static int machine_is_cypress(void)
 223 {
 224         return c110_machine_id() == MACH_CYPRESS;
 225 }
 226
 227 static int board_is_limo_universal(void)
 228 {
 229         return machine_is_aquila() && (board_rev & LIMO_UNIVERSAL_BOARD);
 230 }
 231
 232 static int board_is_limo_real(void)
 233 {
 234         return machine_is_aquila() && (board_rev & LIMO_REAL_BOARD);
 235 }
 236
 237 static int board_is_media(void)
 238 {
 239         return machine_is_aquila() && (board_rev & MEDIA_BOARD);
 240 }
 241
 242 static int board_is_bamboo(void)
 243 {
 244         return machine_is_aquila() && (board_rev & BAMBOO_BOARD);
 245 }
 246
 247 static int board_is_j1b2(void)
 248 {
 249         return machine_is_aquila() && (board_rev & J1_B2_BOARD);
 250 }
 251
 252 #ifdef ARIES
 253 static int board_is_aries(void)
 254 {
 255         return machine_is_aquila() && (board_rev & ARIES_BOARD);
 256 }
 257 #endif
 258
 259 static int board_is_p2_real(void)
 260 {
 261         return machine_is_p1p2() && (board_rev & P2_REAL_BOARD);
 262 }
 263
 264 static void enable_battery(void);
 265
 266 void i2c_init_board(void)
 267 {
 268         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *)S5PC110_GPIO_BASE;
 269         int num_bus;
 270
 271         if (cpu_is_s5pc100())
 272                 return;
 273
 274         num_bus = ARRAY_SIZE(i2c_gpio);
 275
 276         if (machine_is_cypress()) {
 277                 i2c_gpio[I2C_GPIO6].bus = &i2c_cypress_gpio6;
 278                 i2c_gpio[I2C_GPIO7].bus = &i2c_cypress_gpio7;
 279                 i2c_gpio[I2C_GPIO7].bus->gpio_base =
 280                         (unsigned int)&gpio->gpio_mp0_5;
 281         }
 282 #ifdef ARIES
 283         else if (board_is_aries()) {
 284                 i2c_gpio[I2C_GPIO6].bus = &i2c_cypress_gpio6;
 285                 i2c_gpio[I2C_GPIO7].bus = &i2c_aries_gpio7;
 286                 i2c_gpio[I2C_GPIO7].bus->gpio_base =
 287                         (unsigned int)&gpio->gpio_mp0_5;
 288         }
 289 #endif /* ARIES */
 290         else {
 291                 num_bus--;
 292         }
 293
 294         i2c_gpio[I2C_2].bus->gpio_base = (unsigned int)&gpio->gpio_d1;
 295         i2c_gpio[I2C_GPIO3].bus->gpio_base = (unsigned int)&gpio->gpio_j3;
 296         i2c_gpio[I2C_PMIC].bus->gpio_base = (unsigned int)&gpio->gpio_j4;
 297         i2c_gpio[I2C_GPIO5].bus->gpio_base = (unsigned int)&gpio->gpio_mp0_5;
 298         i2c_gpio[I2C_GPIO6].bus->gpio_base = (unsigned int)&gpio->gpio_j3;
 299
 300         i2c_gpio_init(i2c_gpio, num_bus, I2C_PMIC);
 301
 302         /* Reset on max17040 early */
 303         if (battery_soc == 0)
 304                 enable_battery();
 305 }
 306
 307 #ifdef CONFIG_MISC_INIT_R
 308 #define DEV_INFO_LEN            512
 309 static char device_info[DEV_INFO_LEN];
 310 static int display_info;
 311
 312 static void dprintf(const char *fmt, ...)
 313 {
 314         va_list args;
 315         uint i;
 316         char buf[128];
 317
 318         va_start(args, fmt);
 319         i = vsprintf(buf, fmt, args);
 320         va_end(args);
 321
 322         buf[127] = 0;
 323
 324         if ((strlen(device_info) + strlen(buf)) > (DEV_INFO_LEN - 1)) {
 325                 puts("Flushing device info...\n");
 326                 puts(device_info);
 327                 device_info[0] = 0;
 328         }
 329         strcat(device_info, buf);
 330         puts(buf);
 331 }
 332
 333 #ifdef CONFIG_S5PC1XXFB
 334 static void display_device_info(void)
 335 {
 336         if (!display_info)
 337                 return;
 338
 339         init_font();
 340         set_font_xy(0, 450);
 341         set_font_color(FONT_WHITE);
 342         fb_printf(device_info);
 343         exit_font();
 344
 345         memset(device_info, 0x0, DEV_INFO_LEN);
 346
 347         udelay(5 * 1000 * 1000);
 348 }
 349 #endif
 350
 351 static const char *board_name[] = {
 352         "Universal",
 353         "TickerTape",
 354         "Aquila",
 355         "P1P2",
 356         "Geminus",
 357         "Cypress",
 358 };
 359
 360 enum {
 361         MEM_4G1G1G,
 362         MEM_4G2G1G,
 363         MEM_4G3G1G,
 364         MEM_4G4G1G,
 365 };
 366
 367 static char feature_buffer[32];
 368
 369 static char *display_features(int board, int board_rev)
 370 {
 371         int count = 0;
 372         char *buf = feature_buffer;
 373
 374         if (board == MACH_AQUILA) {
 375                 if (board_rev & SPLIT_SCREEN_FEATURE)
 376                         count += sprintf(buf + count, " - SplitScreen");
 377                 if (board_rev & J1_B2_BOARD)
 378                         count += sprintf(buf + count, " - J1 B2 board");
 379                 /* Limo Real or Universal */
 380                 if (board_rev & LIMO_REAL_BOARD)
 381                         count += sprintf(buf + count, " - Limo Real");
 382                 else if (board_rev & LIMO_UNIVERSAL_BOARD)
 383                         count += sprintf(buf + count, " - Limo Universal");
 384                 if (board_rev & MEDIA_BOARD)
 385                         count += sprintf(buf + count, " - Media");
 386                 if (board_rev & BAMBOO_BOARD)
 387                         count += sprintf(buf + count, " - Bamboo");
 388 #ifdef ARIES
 389                 if (board_rev & ARIES_BOARD)
 390                         count += sprintf(buf + count, " - Aries");
 391 #endif /* ARIES */
 392         } else if (board == MACH_P1P2) {
 393                 /* P1P2 */
 394                 if (board_rev & P1_REAL_BOARD)
 395                         count += sprintf(buf + count, " - P1 Real");
 396                 else if (board_rev & P2_REAL_BOARD)
 397                         count += sprintf(buf + count, " - P2 Real");
 398                 else
 399                         count += sprintf(buf + count, " - Universal");
 400         }
 401
 402         return buf;
 403 }
 404
 405 static void check_board_revision(int board, int rev)
 406 {
 407         switch (board) {
 408         case MACH_AQUILA:
 409                 /* Limo Real or Universal */
 410                 if (rev & LIMO_UNIVERSAL_BOARD)
 411                         board_rev &= ~J1_B2_BOARD;
 412                 if (rev & LIMO_REAL_BOARD) {
 413                         board_rev &= ~(J1_B2_BOARD |
 414                                         LIMO_UNIVERSAL_BOARD);
 415                 }
 416 #ifdef ARIES
 417                 if (rev & ARIES_BOARD)
 418                         board_rev &= ~(J1_B2_BOARD);
 419 #endif /* ARIES */
 420                 if (rev & MEDIA_BOARD)
 421                         board_rev &= ~(J1_B2_BOARD |
 422                                         LIMO_UNIVERSAL_BOARD);
 423                 if (rev & BAMBOO_BOARD)
 424                         board_rev &= ~(J1_B2_BOARD |
 425                                         LIMO_UNIVERSAL_BOARD |
 426                                         LIMO_REAL_BOARD |
 427                                         MEDIA_BOARD);
 428                 break;
 429         case MACH_P1P2:
 430                 break;
 431         case MACH_CYPRESS:
 432                 /* There's no HWREV_MODE3 */
 433                 board_rev &= ~(1 << 3);
 434                 /* Fall through */
 435         case MACH_TICKERTAPE:
 436         case MACH_GEMINUS:
 437                 board_rev &= ~BOARD_MASK;
 438                 break;
 439         default:
 440                 break;
 441         }
 442 }
 443
 444 static unsigned int get_hw_revision(struct s5pc1xx_gpio_bank *bank)
 445 {
 446         unsigned int rev;
 447 #ifdef ARIES
 448         gpio_direction_input(bank, 2);
 449         gpio_direction_input(bank, 3);
 450         gpio_direction_input(bank, 4);
 451         gpio_direction_input(bank, 7);
 452
 453         gpio_set_pull(bank, 2, GPIO_PULL_NONE);         /* HWREV_MODE0 */
 454         gpio_set_pull(bank, 3, GPIO_PULL_NONE);         /* HWREV_MODE1 */
 455         gpio_set_pull(bank, 4, GPIO_PULL_NONE);         /* HWREV_MODE2 */
 456         gpio_set_pull(bank, 7, GPIO_PULL_NONE);         /* HWREV_MODE3 */
 457
 458         rev = gpio_get_value(bank, 2);
 459         rev |= (gpio_get_value(bank, 3) << 1);
 460         rev |= (gpio_get_value(bank, 4) << 2);
 461         rev |= (gpio_get_value(bank, 7) << 3);
 462         /* test */
 463         rev = 9;
 464 #else
 465         gpio_direction_input(bank, 1);
 466         gpio_direction_input(bank, 2);
 467         gpio_direction_input(bank, 3);
 468         gpio_direction_input(bank, 4);
 469
 470         gpio_set_pull(bank, 1, GPIO_PULL_NONE);         /* HWREV_MODE3 */
 471         gpio_set_pull(bank, 2, GPIO_PULL_NONE);         /* HWREV_MODE0 */
 472         gpio_set_pull(bank, 3, GPIO_PULL_NONE);         /* HWREV_MODE1 */
 473         gpio_set_pull(bank, 4, GPIO_PULL_NONE);         /* HWREV_MODE2 */
 474
 475         rev = gpio_get_value(bank, 2);
 476         rev |= (gpio_get_value(bank, 3) << 1);
 477         rev |= (gpio_get_value(bank, 4) << 2);
 478         rev |= (gpio_get_value(bank, 1) << 3);
 479 #endif /* ARIES */
 480
 481         return rev;
 482 }
 483
 484 static void check_hw_revision(void)
 485 {
 486         unsigned int board = MACH_UNIVERSAL;    /* Default is Universal */
 487
 488         if (cpu_is_s5pc100()) {
 489                 struct s5pc100_gpio *gpio =
 490                         (struct s5pc100_gpio *)S5PC100_GPIO_BASE;
 491
 492                 board_rev = get_hw_revision(&gpio->gpio_j0);
 493
 494                 /* C100 TickerTape */
 495                 if (board_rev == 3)
 496                         board = MACH_TICKERTAPE;
 497         } else {
 498                 struct s5pc110_gpio *gpio =
 499                         (struct s5pc110_gpio *)S5PC110_GPIO_BASE;
 500
 501                 board_rev = get_hw_revision(&gpio->gpio_j0);
 502
 503                 /*
 504                  * Note Check 'Aquila' board first
 505                  *
 506                  * TT: TickerTape
 507                  * SS: SplitScreen
 508                  * LRA: Limo Real Aquila
 509                  * LUA: Limo Universal Aquila
 510                  * OA: Old Aquila
 511                  * P1P2: Smart Book
 512                  * CYP: Cypress
 513                  * BB: Bamboo
 514                  *
 515                  * ADDR = 0xE0200000 + OFF
 516                  *
 517                  *       OFF    Universal BB   LRA  LUA  OA   TT   SS       P1P2 CYP
 518                  *   J1: 0x0264 0x10      0x10 0x00 0x00 0x00 0x00 0x00     0x00
 519                  *   J2: 0x0284           0x01 0x10 0x00
 520                  *   H1: 0x0C24    W           0x28 0xA8 0x1C               0x18 0x0F
 521                  *   H3: 0x0C64                0x03 0x07 0x0F               0xff
 522                  *   D1: 0x00C4 0x0F           0x3F 0x3F 0x0F 0xXC 0x3F
 523                  *    I: 0x0224                          0x02 0x00 0x08
 524                  * MP03: 0x0324                          0x9x      0xbx 0x9x
 525                  * MP05: 0x0364                          0x80      0x88
 526                  */
 527
 528                 /* C110 Aquila */
 529                 if (gpio_get_value(&gpio->gpio_j1, 4) == 0) {
 530                         board = MACH_AQUILA;
 531                         board_rev |= J1_B2_BOARD;
 532
 533                         gpio_set_pull(&gpio->gpio_j2, 6, GPIO_PULL_NONE);
 534                         gpio_direction_input(&gpio->gpio_j2, 6);
 535
 536                         /* Check board */
 537 #ifndef ARIES
 538                         if (gpio_get_value(&gpio->gpio_h1, 2) == 0)
 539                                 board_rev |= LIMO_UNIVERSAL_BOARD;
 540 #else
 541                         if (gpio_get_value(&gpio->gpio_h1, 2) == 0)
 542                                 board_rev |= ARIES_BOARD;
 543 #endif /* ARIES */
 544
 545                         if (gpio_get_value(&gpio->gpio_h3, 2) == 0)
 546                                 board_rev |= LIMO_REAL_BOARD;
 547
 548                         if (gpio_get_value(&gpio->gpio_j2, 6) == 1)
 549                                 board_rev |= MEDIA_BOARD;
 550
 551                         /* set gpio to default value. */
 552                         gpio_set_pull(&gpio->gpio_j2, 6, GPIO_PULL_DOWN);
 553                         gpio_direction_output(&gpio->gpio_j2, 6, 0);
 554                 }
 555                 /* Workaround: C110 Aquila Rev0.6 */
 556                 if (board_rev == 6) {
 557                         board = MACH_AQUILA;
 558                         board_rev |= LIMO_REAL_BOARD;
 559                 }
 560                 /* C110 Aquila Bamboo */
 561                 if (gpio_get_value(&gpio->gpio_j2, 0) == 1) {
 562                         board = MACH_AQUILA;
 563                         board_rev |= BAMBOO_BOARD;
 564                 }
 565
 566                 /* C110 TickerTape */
 567                 if (gpio_get_value(&gpio->gpio_d1, 0) == 0 &&
 568                                 gpio_get_value(&gpio->gpio_d1, 1) == 0)
 569                         board = MACH_TICKERTAPE;
 570
 571                 /* C110 Cypress: Do first this than P1P2 */
 572                 gpio_set_pull(&gpio->gpio_j2, 2, GPIO_PULL_NONE);
 573                 gpio_direction_input(&gpio->gpio_j2, 2);
 574                 if (gpio_get_value(&gpio->gpio_j2, 2) == 1)
 575                         board = MACH_CYPRESS;
 576                 gpio_set_pull(&gpio->gpio_j2, 2, GPIO_PULL_DOWN);
 577
 578                 /* C110 P1P2 */
 579                 if (gpio_get_value(&gpio->gpio_h3, 7) == 1) {
 580                         board = MACH_P1P2;
 581                         board_rev &= ~BOARD_MASK;
 582                 }
 583
 584                 /* set gpio configuration for P1P2. */
 585                 gpio_direction_input(&gpio->gpio_j0, 6);
 586                 gpio_direction_input(&gpio->gpio_j0, 7);
 587
 588                 /*
 589                  * do not change order below
 590                  * because it needs delay to get gpio value.
 591                  */
 592                 /* HWREV_MODE4 */
 593                 gpio_set_pull(&gpio->gpio_j0, 7, GPIO_PULL_NONE);
 594                 /* HWREV_MODE5 */
 595                 gpio_set_pull(&gpio->gpio_j0, 6, GPIO_PULL_NONE);
 596
 597                 if (gpio_get_value(&gpio->gpio_j0, 7) == 1) {
 598                         board = MACH_P1P2;
 599                         board_rev &= ~BOARD_MASK;
 600                         if (gpio_get_value(&gpio->gpio_j0, 6) == 1)
 601                                 board_rev |= P1_REAL_BOARD;
 602                         if (gpio_get_value(&gpio->gpio_j0, 6) == 0)
 603                                 board_rev |= P2_REAL_BOARD;
 604                 }
 605
 606                 /* set gpio to default value. */
 607                 /* HWREV_MODE4 */
 608                 gpio_set_pull(&gpio->gpio_j0, 6, GPIO_PULL_DOWN);
 609                 /* HWREV_MODE5 */
 610                 gpio_set_pull(&gpio->gpio_j0, 7, GPIO_PULL_DOWN);
 611
 612                 /* C110 Geminus for rev0.0 */
 613                 gpio_set_pull(&gpio->gpio_j1, 2, GPIO_PULL_NONE);
 614                 gpio_direction_input(&gpio->gpio_j1, 2);
 615                 if (gpio_get_value(&gpio->gpio_j1, 2) == 1) {
 616                         board = MACH_GEMINUS;
 617                         if ((board_rev & ~BOARD_MASK) == 3)
 618                                 board_rev &= ~0xff;
 619                 }
 620                 gpio_set_pull(&gpio->gpio_j1, 2, GPIO_PULL_DOWN);
 621                 gpio_direction_output(&gpio->gpio_j1, 2, 0);
 622
 623                 /* C110 Geminus for rev0.1 ~ */
 624                 gpio_set_pull(&gpio->gpio_j0, 6, GPIO_PULL_NONE);
 625                 gpio_direction_input(&gpio->gpio_j0, 6);
 626                 if (gpio_get_value(&gpio->gpio_j0, 6) == 1)
 627                         board = MACH_GEMINUS;
 628                 gpio_set_pull(&gpio->gpio_j0, 6, GPIO_PULL_DOWN);
 629         }
 630
 631         /* Set machine id */
 632         if (cpu_is_s5pc110())
 633                 gd->bd->bi_arch_number = C110_MACH_START + board;
 634         else
 635                 gd->bd->bi_arch_number = C100_MACH_START + board;
 636
 637         /* Architecture Common settings */
 638         if (cpu_is_s5pc110()) {
 639                 setenv("mtdparts", MTDPARTS_DEFAULT_4KB);
 640         } else {
 641                 setenv("bootk", "onenand read 0x30007FC0 0x60000 0x300000; "
 642                                 "bootm 0x30007FC0");
 643                 setenv("updatek", "onenand erase 0x60000 0x300000; "
 644                                   "onenand write 0x31008000 0x60000 0x300000");
 645         }
 646 }
 647
 648 static void show_hw_revision(void)
 649 {
 650         int board;
 651
 652         /*
 653          * Workaround for Rev 0.3 + CP Ver ES 3.1
 654          * it's Rev 0.4
 655          */
 656         if (board_is_limo_real()) {
 657                 if (hwrevision(0)) {
 658                         /* default is Rev 0.4 */
 659                         board_rev &= ~0xf;
 660                         board_rev |= 0x4;
 661                 }
 662         }
 663
 664         if (cpu_is_s5pc110())
 665                 board = gd->bd->bi_arch_number - C110_MACH_START;
 666         else
 667                 board = gd->bd->bi_arch_number - C100_MACH_START;
 668
 669         check_board_revision(board, board_rev);
 670
 671         /* Set CPU Revision */
 672         if (board_is_limo_real()) {
 673                 if ((board_rev & 0xf) < 8)
 674                         s5pc1xx_set_cpu_rev(0);
 675         } else {
 676                 s5pc1xx_set_cpu_rev(0);
 677         }
 678
 679         dprintf("HW Revision:\t%x (%s%s)\n", board_rev, board_name[board],
 680                 display_features(board, board_rev));
 681 }
 682
 683 static void check_auto_burn(void)
 684 {
 685         unsigned long magic_base = CONFIG_SYS_SDRAM_BASE + 0x02000000;
 686         unsigned int count = 0;
 687         char buf[64];
 688
 689         if (readl(magic_base) == 0x426f6f74) {  /* ASICC: Boot */
 690                 printf("Auto burning bootloader\n");
 691                 count += sprintf(buf + count, "run updateb; ");
 692         }
 693         if (readl(magic_base + 0x04) == 0x4b65726e) {   /* ASICC: Kern */
 694                 printf("Auto burning kernel\n");
 695                 count += sprintf(buf + count, "run updatek; ");
 696         }
 697
 698         if (count) {
 699                 count += sprintf(buf + count, "reset");
 700                 setenv("bootcmd", buf);
 701         }
 702
 703         /* Clear the magic value */
 704         writel(0xa5a55a5a, magic_base);
 705         writel(0xa5a55a5a, magic_base + 0x4);
 706 }
 707
 708 static void pmic_pin_init(void)
 709 {
 710         unsigned int reg, value;
 711
 712         if (cpu_is_s5pc100())
 713                 return;
 714
 715         /* AP_PS_HOLD: XEINT_0: GPH0[0]
 716          * Note: Don't use GPIO PS_HOLD it doesn't work
 717          */
 718         reg = S5PC110_PS_HOLD_CONTROL;
 719         value = readl(reg);
 720         value |= S5PC110_PS_HOLD_DIR_OUTPUT |
 721                 S5PC110_PS_HOLD_DATA_HIGH |
 722                 S5PC110_PS_HOLD_OUT_EN;
 723         writel(value, reg);
 724
 725         /* nPOWER: XEINT_22: GPH2[6] interrupt mode */
 726         gpio_cfg_pin(&s5pc110_gpio->gpio_h2, 6, GPIO_IRQ);
 727         gpio_set_pull(&s5pc110_gpio->gpio_h2, 6, GPIO_PULL_UP);
 728 }
 729
 730 static void enable_ldos(void)
 731 {
 732         if (cpu_is_s5pc100())
 733                 return;
 734
 735         if (machine_is_p1p2())
 736                 return;
 737
 738         /* TOUCH_EN: XMMC3DATA_3: GPG3[6] output high */
 739         gpio_direction_output(&s5pc110_gpio->gpio_g3, 6, 1);
 740 }
 741
 742 static void enable_t_flash(void)
 743 {
 744         if (!(board_is_limo_universal() || board_is_limo_real()))
 745                 return;
 746
 747         /* T_FLASH_EN : XM0ADDR_13: MP0_5[4] output high */
 748         gpio_direction_output(&s5pc110_gpio->gpio_mp0_5, 4, 1);
 749 }
 750
 751 static void setup_limo_real_gpios(void)
 752 {
 753         if (!board_is_limo_real())
 754                 return;
 755
 756         /*
 757          * Note: Please write GPIO alphabet order
 758          */
 759         /* CODEC_LDO_EN: XVVSYNC_LDI: GPF3[4] output high */
 760         gpio_direction_output(&s5pc110_gpio->gpio_f3, 4, 1);
 761
 762         if (hwrevision(0))
 763                 /* RESET_REQ_N: XM0BEN_1: MP0_2[1] output high */
 764                 gpio_direction_output(&s5pc110_gpio->gpio_mp0_2, 1, 1);
 765         else
 766                 /* RESET_REQ_N: XM0CSn_2: MP0_1[2] output high */
 767                 gpio_direction_output(&s5pc110_gpio->gpio_mp0_1, 2, 1);
 768
 769         /* T_FLASH_DETECT: EINT28: GPH3[4] interrupt mode */
 770         gpio_cfg_pin(&s5pc110_gpio->gpio_h3, 4, GPIO_IRQ);
 771         gpio_set_pull(&s5pc110_gpio->gpio_h3, 4, GPIO_PULL_UP);
 772 }
 773
 774 static void setup_media_gpios(void)
 775 {
 776         if (!board_is_media())
 777                 return;
 778
 779         /*
 780          * Note: Please write GPIO alphabet order
 781          */
 782         /* RESET_REQ_N: XM0CSn_2: MP0_1[2] output high */
 783         gpio_direction_output(&s5pc110_gpio->gpio_mp0_1, 2, 1);
 784
 785         /* T_FLASH_DETECT: EINT28: GPH3[4] interrupt mode */
 786         gpio_cfg_pin(&s5pc110_gpio->gpio_h3, 4, GPIO_IRQ);
 787         gpio_set_pull(&s5pc110_gpio->gpio_h3, 4, GPIO_PULL_UP);
 788 }
 789
 790 static void setup_p1p2_gpios(void)
 791 {
 792         if (!machine_is_p1p2())
 793                 return;
 794
 795         /*
 796          * Note: Please write GPIO alphabet order
 797          */
 798         /* RESET_REQ_N: XM0FRnB[1]: MP0_3[5] output high */
 799         gpio_direction_output(&s5pc110_gpio->gpio_mp0_3, 5, 1);
 800         /* CODEC_LDO_EN: XM0FRnB[2]: MP0_3[6] output high */
 801         gpio_direction_output(&s5pc110_gpio->gpio_mp0_3, 6, 1);
 802 }
 803
 804 #define KBR3            (1 << 3)
 805 #define KBR2            (1 << 2)
 806 #define KBR1            (1 << 1)
 807 #define KBR0            (1 << 0)
 808
 809 static void check_p2_keypad(void)
 810 {
 811         unsigned int auto_download = 0;
 812         unsigned char addr = 0x34, val[2];      /* adp5587 key controller */
 813         int i, ret;
 814         i2c_set_bus_num(I2C_2);
 815
 816         if (i2c_probe(addr)) {
 817                 printf("Can't found adp5587 key controller\n");
 818                 return;
 819         }
 820         /* Row 8, Column 10 */
 821         val[0] = 0xf;
 822         ret = i2c_write(addr, 0x1D, 1, val, 1);         /* Set KP_GPIO1 */
 823         val[0] = 0xf;
 824         ret |= i2c_write(addr, 0x1E, 1, val, 1);        /* Set KP_GPIO2 */
 825         val[0] = 0x3;
 826         ret |= i2c_write(addr, 0x1F, 1, val, 1);        /* Set KP_GPIO3 */
 827         val[0] = 0x3f;          /* CMP2_INT | CMP1_INT | OVR_FLOW_INT |
 828                                    K_LCK_INT | GPI_INT | KE_INT */
 829         ret |= i2c_write(addr, 0x02, 1, val, 1);        /* Status is W1C */
 830         val[0] = 0x19;          /* INT_CFG | OVR_FLOW_IEN | KE_IEN */
 831         ret |= i2c_write(addr, 0x01, 1, val, 1);
 832         for (i = 0; i < 10; i++) {
 833                 udelay(1000);           /* FIXME */
 834                 i2c_read(addr, 0x04 + i, 1, val, 1);
 835                 if (val[0] == 0x94)
 836                         auto_download = 1;
 837         }
 838
 839         if (auto_download == 1)
 840                 setenv("bootcmd", "usbdown");
 841 }
 842
 843 static void check_keypad(void)
 844 {
 845         unsigned int reg, value;
 846         unsigned int col_mask, row_mask;
 847         unsigned int auto_download = 0;
 848         unsigned int col_value[4], i;
 849
 850         if (cpu_is_s5pc100()) {
 851                 struct s5pc100_gpio *gpio =
 852                         (struct s5pc100_gpio *)S5PC100_GPIO_BASE;
 853
 854                 /* Set GPH2[2:0] to KP_COL[2:0] */
 855                 gpio_cfg_pin(&gpio->gpio_h2, 0, 0x3);
 856                 gpio_cfg_pin(&gpio->gpio_h2, 1, 0x3);
 857                 gpio_cfg_pin(&gpio->gpio_h2, 2, 0x3);
 858
 859                 /* Set GPH3[2:0] to KP_ROW[2:0] */
 860                 gpio_cfg_pin(&gpio->gpio_h3, 0, 0x3);
 861                 gpio_cfg_pin(&gpio->gpio_h3, 1, 0x3);
 862                 gpio_cfg_pin(&gpio->gpio_h3, 2, 0x3);
 863
 864                 reg = S5PC100_KEYPAD_BASE;
 865         } else {
 866                 if (board_is_limo_real() || board_is_limo_universal()) {
 867                         row_mask = 0x00FF;
 868                         col_mask = 0x0FFF;
 869                 } else {
 870                         row_mask = 0xFFFF;
 871                         col_mask = 0xFFFF;
 872                 }
 873
 874                 for (i = 0; i < 4; i++) {
 875                         /* Set GPH3[3:0] to KP_ROW[3:0] */
 876                         if (row_mask & (0xF << (i << 2))) {
 877                                 gpio_cfg_pin(&s5pc110_gpio->gpio_h3, i, 0x3);
 878                                 if (!machine_is_p1p2())
 879                                         gpio_set_pull(&s5pc110_gpio->gpio_h3,
 880                                                         i, GPIO_PULL_UP);
 881                         }
 882
 883                         /* Set GPH2[3:0] to KP_COL[3:0] */
 884                         if (col_mask & (0xF << (i << 2)))
 885                                 gpio_cfg_pin(&s5pc110_gpio->gpio_h2, i, 0x3);
 886                         if (machine_is_p1p2())
 887                                 gpio_set_pull(&s5pc110_gpio->gpio_h2, i, GPIO_PULL_UP);
 888                 }
 889
 890                 reg = S5PC110_KEYPAD_BASE;
 891         }
 892         /* init col */
 893         value = 0x00;
 894         writel(value, reg + S5PC1XX_KEYIFCOL_OFFSET);
 895         value = readl(reg + S5PC1XX_KEYIFROW_OFFSET);
 896         /* VOLUMEDOWN and CAM(Half shot) Button */
 897         if ((value & KBR1) == 0) {
 898                 i = 0;
 899                 while (i < 4) {
 900                         value = readl(reg + S5PC1XX_KEYIFCOL_OFFSET);
 901                         value |= 0xff;
 902                         value &= ~(1 << i);
 903                         writel(value, reg + S5PC1XX_KEYIFCOL_OFFSET);
 904                         udelay(10*1000);
 905                         col_value[i++] = readl(reg + S5PC1XX_KEYIFROW_OFFSET);
 906                 }
 907                 writel(0x00, reg + S5PC1XX_KEYIFCOL_OFFSET);
 908
 909                 /* expected value is row_value[0] = 0x00 row_value[1] = 0x01 */
 910                 /* workaround */
 911                 if ((col_value[0] & 0x3) == 0x3 && (col_value[1] & 0x3) == 0x3)
 912                         auto_download = 1;
 913
 914                 if ((col_value[0] & 0x3) == 0x3 && (col_value[1] & 0x3) != 0x3)
 915                         display_info = 1;
 916                 if (machine_is_p1p2()) {
 917                         if ((col_value[0] & 0xd) == 0xd)
 918                                 auto_download = 1;
 919                 }
 920         }
 921
 922         if (auto_download)
 923                 setenv("bootcmd", "usbdown");
 924 }
 925
 926 static void enable_battery(void)
 927 {
 928         unsigned char val[2];
 929         unsigned char addr = 0x36;      /* max17040 fuel gauge */
 930
 931         if (machine_is_aquila()) {
 932                 if (board_is_j1b2())
 933                         return;
 934         }
 935
 936         if (machine_is_tickertape())
 937                 return;
 938
 939         if (machine_is_cypress())
 940                 i2c_set_bus_num(I2C_GPIO7);
 941         else
 942                 i2c_set_bus_num(I2C_GPIO3);
 943
 944         if (i2c_probe(addr)) {
 945                 printf("Can't found max17040 fuel gauge\n");
 946                 return;
 947         }
 948
 949         val[0] = 0x54;
 950         val[1] = 0x00;
 951         i2c_write(addr, 0xfe, 1, val, 2);
 952 }
 953
 954 static void check_battery(void)
 955 {
 956         unsigned char val[2];
 957         unsigned char addr = 0x36;      /* max17040 fuel gauge */
 958
 959         if (machine_is_aquila()) {
 960                 if (board_is_j1b2())
 961                         return;
 962         }
 963
 964         if (machine_is_tickertape())
 965                 return;
 966
 967         if (machine_is_cypress())
 968                 i2c_set_bus_num(I2C_GPIO7);
 969         else
 970                 i2c_set_bus_num(I2C_GPIO3);
 971
 972         if (i2c_probe(addr)) {
 973                 printf("Can't found max17040 fuel gauge\n");
 974                 return;
 975         }
 976
 977         i2c_read(addr, 0x04, 1, val, 1);
 978
 979         dprintf("battery:\t%d%%\n", val[0]);
 980
 981         battery_soc = val[0];
 982 }
 983
 984 static void check_mhl(void)
 985 {
 986         unsigned char val[2];
 987         unsigned char addr = 0x39;      /* SIL9230 */
 988
 989         /* MHL Power enable */
 990         /* HDMI_EN : GPJ2[2] XMSMDATA_2 output mode */
 991         gpio_direction_output(&s5pc110_gpio->gpio_j2, 2, 1);
 992
 993         /* MHL_RST : MP0_4[7] XM0ADDR_7 output mode */
 994         gpio_direction_output(&s5pc110_gpio->gpio_mp0_4, 7, 0);
 995
 996         /* 10ms required after reset */
 997         udelay(10000);
 998
 999         /* output enable */
1000         gpio_set_value(&s5pc110_gpio->gpio_mp0_4, 7, 1);
1001
1002         i2c_set_bus_num(I2C_GPIO5);
1003
1004         /* set usb path */
1005         if (i2c_probe(addr)) {
1006                 printf("Can't found MHL Chip\n");
1007                 return;
1008         }
1009
1010         /*
1011          * System Control #1
1012          * set to Normal operation
1013          */
1014         val[0] = 0x35;
1015         i2c_write((0x72 >> 1), 0x08, 1, val, 1);
1016         i2c_read((0x72 >> 1), 0x08, 1, val, 1);
1017
1018         /*
1019          * MHL TX Control #1
1020          * TERM_MODE [7:6]
1021          * 00 = MHL termination ON
1022          * 11 = MHL termination OFF
1023          */
1024         val[0] = 0xd0;
1025         i2c_write((0x72 >> 1), 0xa0, 1, val, 1);
1026         i2c_read((0x72 >> 1), 0xa0, 1, val, 1);
1027 }
1028
1029 #define CHARGER_ANIMATION_FRAME         6
1030 static int max8998_power_key(void)
1031 {
1032         unsigned char addr, val[2];
1033         i2c_set_bus_num(I2C_PMIC);
1034         addr = 0xCC >> 1;
1035         if (i2c_probe(addr)) {
1036                 printf("Can't found max8998\n");
1037                 return 0;
1038         }
1039
1040         /* Accessing IRQ1 register */
1041         i2c_read(addr, 0x00, 1, val, 1);
1042         printf("MAX8998 IRQ1 = 0x%x\n", val[0]);
1043         if (val[0] & (1 << 6))
1044                 return 1;
1045 }
1046 static void into_charge_mode(void)
1047 {
1048         unsigned char addr = 0xCC >> 1; /* max8998 */;
1049         unsigned char val[2];
1050         unsigned int level;
1051         int i, j;
1052         bmp_image_t *bmp[CHARGER_ANIMATION_FRAME];
1053         unsigned long len[CHARGER_ANIMATION_FRAME];
1054         ulong bmp_addr[CHARGER_ANIMATION_FRAME];
1055
1056         i2c_set_bus_num(I2C_PMIC);
1057
1058         if (i2c_probe(addr)) {
1059                 printf("Can't found max8998\n");
1060                 return;
1061         }
1062
1063         printf("Charge Mode\n");
1064
1065         i2c_read(addr, 0x0C, 1, val, 1);
1066         val[0] &= ~(0x7 << 0);
1067         val[0] |= 5;            /* 600mA */
1068         i2c_write(addr, 0x0C, 1, val, 1);
1069
1070 #ifdef CONFIG_S5PC1XXFB
1071         init_font();
1072
1073         /* TODO: write the image-text for the charger */
1074
1075         level = battery_soc * CHARGER_ANIMATION_FRAME / 100;
1076         if (level >= CHARGER_ANIMATION_FRAME)
1077                 level = CHARGER_ANIMATION_FRAME - 1;
1078
1079         for (i = 0; i < CHARGER_ANIMATION_FRAME; i++)
1080                 bmp_addr[i] = battery_charging_animation[i];
1081
1082         lcd_display_clear();
1083         for (i = 0; i < 3; i++) {
1084                 for (j = level; j < CHARGER_ANIMATION_FRAME; j++) {
1085                         int k;
1086
1087                         bmp[j] = gunzip_bmp(bmp_addr[j], &len[j]);
1088                         lcd_display_bitmap((ulong) bmp[j], 140, 202);
1089                         free(bmp[j]);
1090
1091                         for (k = 0; k < 10; k++)
1092                                 if (max8998_power_key())
1093                                         return;
1094                                 else
1095                                         udelay(100 * 1000);
1096                         if (max8998_power_key())
1097                                 return;
1098                 }
1099         }
1100         exit_font();
1101 #endif
1102
1103         /* EVT0: sleep 1, EVT1: sleep */
1104         if (s5pc1xx_get_cpu_rev() == 0) {
1105                 run_command("sleep 1", 0);
1106                 return;
1107         }
1108
1109         run_command("sleep", 0);
1110 }
1111
1112 static void check_micro_usb(int intr)
1113 {
1114         unsigned char addr;
1115         unsigned char val[2];
1116         static int started_charging_once = 0;
1117
1118         if (cpu_is_s5pc100())
1119                 return;
1120
1121         if (board_is_limo_real()) {
1122                 if (hwrevision(0) || hwrevision(1))
1123                         return;
1124         }
1125
1126         if (machine_is_cypress())
1127                 i2c_set_bus_num(I2C_GPIO6);
1128 #ifdef ARIES
1129         if (board_is_aries())
1130                 i2c_set_bus_num(I2C_GPIO6);
1131 #endif /* ARIES */
1132         else
1133                 i2c_set_bus_num(I2C_PMIC);
1134
1135         addr = 0x25;            /* fsa9480 */
1136         if (i2c_probe(addr)) {
1137                 printf("Can't found fsa9480\n");
1138                 return;
1139         }
1140
1141         /* Clear Interrupt */
1142         if (intr) {
1143                 i2c_read(addr, 0x03, 1, val, 2);
1144                 udelay(500 * 1000);
1145         }
1146
1147         /* Read Device Type 1 */
1148         i2c_read(addr, 0x0a, 1, val, 1);
1149
1150 #define FSA_DEDICATED_CHARGER   (1 << 6)
1151 #define FSA_UART                (1 << 3)
1152 #define FSA_USB                 (1 << 2)
1153
1154         /*
1155          * If USB, use default 475mA
1156          * If Charger, use 600mA and go to charge mode
1157          */
1158         if ((val[0] & FSA_DEDICATED_CHARGER) && !started_charging_once) {
1159                 started_charging_once = 1;
1160                 into_charge_mode();
1161         }
1162
1163         /* If Factory Mode is Boot ON-USB, go to download mode */
1164         i2c_read(addr, 0x07, 1, val, 1);
1165
1166 #define FSA_ADC_FAC_USB         0x19
1167 #define FSA_ADC_FAC_UART        0x1d
1168
1169         if (val[0] == FSA_ADC_FAC_USB)
1170                 setenv("bootcmd", "usbdown");
1171 }
1172
1173 static void micro_usb_switch(int path)
1174 {
1175         unsigned char addr;
1176         unsigned char val[2];
1177
1178         if (machine_is_cypress())
1179                 i2c_set_bus_num(I2C_GPIO6);
1180 #ifdef ARIES
1181         if (board_is_aries())
1182                 i2c_set_bus_num(I2C_GPIO6);
1183 #endif /* ARIES */
1184         else
1185                 i2c_set_bus_num(I2C_PMIC);
1186
1187         addr = 0x25;            /* fsa9480 */
1188         if (i2c_probe(addr)) {
1189                 printf("Can't found fsa9480\n");
1190                 return;
1191         }
1192
1193         if (path)
1194                 val[0] = 0x90;  /* VAUDIO */
1195         else
1196                 val[0] = 0x24;  /* DHOST */
1197
1198         i2c_write(addr, 0x13, 1, val, 1);       /* MANSW1 */
1199
1200         i2c_read(addr, 0x2, 1, val, 1);
1201         val[0] &= ~(1 << 2);
1202         i2c_write(addr, 0x2, 1, val, 1);
1203 }
1204
1205 #define MAX8998_REG_ONOFF1      0x11
1206 #define MAX8998_REG_ONOFF2      0x12
1207 #define MAX8998_REG_ONOFF3      0x13
1208 #define MAX8998_LDO3            (1 << 2)
1209 #define MAX8998_LDO10           (1 << 3)
1210 #define MAX8998_LDO11           (1 << 2)
1211 #define MAX8998_LDO12           (1 << 1)
1212 #define MAX8998_LDO13           (1 << 0)
1213 #define MAX8998_LDO14           (1 << 7)
1214 #define MAX8998_LDO15           (1 << 6)
1215 #define MAX8998_LDO16           (1 << 5)
1216 #define MAX8998_LDO17           (1 << 4)
1217
1218 #ifdef ARIES
1219 #define MAX8998_REG_LDO7        0x21
1220 #define MAX8998_REG_LDO17       0x29
1221 #endif /* ARIES */
1222
1223 static void init_pmic(void)
1224 {
1225         unsigned char addr;
1226         unsigned char val[2];
1227 #ifdef ARIES
1228         unsigned char val2[2];
1229 #endif /* ARIES */
1230
1231         if (cpu_is_s5pc100())
1232                 return;
1233
1234         i2c_set_bus_num(I2C_PMIC);
1235
1236         addr = 0xCC >> 1;       /* max8998 */
1237         if (i2c_probe(addr)) {
1238                 printf("Can't found max8998\n");
1239                 return;
1240         }
1241
1242         /* ONOFF1 */
1243         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
1244         val[0] &= ~MAX8998_LDO3;
1245         i2c_write(addr, MAX8998_REG_ONOFF1, 1, val, 1);
1246
1247         /* ONOFF2 */
1248         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1249         /*
1250          * Disable LDO10(VPLL_1.1V), LDO11(CAM_IO_2.8V),
1251          * LDO12(CAM_ISP_1.2V), LDO13(CAM_A_2.8V)
1252          */
1253         val[0] &= ~(MAX8998_LDO10 | MAX8998_LDO11 |
1254                         MAX8998_LDO12 | MAX8998_LDO13);
1255 #ifndef ARIES
1256         val[0] |= (1 << 7);
1257 #else
1258         val[0] |= ((1 << 7)|(1 << 6));
1259         val2[0] = 0x2;
1260         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1261         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1262 #endif /* ARIES */
1263         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1264         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1265         /* ONOFF3 */
1266         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1267 #ifndef ARIES
1268         /*
1269          * Disable LDO14(CAM_CIF_1.8), LDO15(CAM_AF_3.3V),
1270          * LDO16(VMIPI_1.8V), LDO17(CAM_8M_1.8V)
1271          */
1272         val[0] &= ~(MAX8998_LDO14 | MAX8998_LDO15 |
1273                         MAX8998_LDO16 | MAX8998_LDO17);
1274 #else
1275
1276         /*
1277          * Disable LDO14(CAM_CIF_1.8), LDO15(CAM_AF_3.3V),
1278          * LDO16(VMIPI_1.8V), LDO17(CAM_8M_1.8V)
1279          */
1280         val[0] &= ~(MAX8998_LDO14 | MAX8998_LDO15 |
1281                         MAX8998_LDO16);
1282
1283         val[0] |= MAX8998_LDO17;
1284         val2[0] = 0xE;
1285         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1286         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1287 #endif /* ARIES */
1288         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1289         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1290 }
1291
1292 #define PDN_MASK(x)             (0x3 << ((x) << 1))
1293
1294 #define CON_INPUT(x)            (0x0 << ((x) << 2))
1295 #define CON_OUTPUT(x)           (0x1 << ((x) << 2))
1296 #define CON_IRQ(x)              (0xf << ((x) << 2))
1297
1298 #define DAT_SET(x)              (0x1 << (x))
1299 #define DAT_CLEAR(x)            (0x0 << (x))
1300
1301 #define OUTPUT0(x)              (0x0 << ((x) << 1))
1302 #define OUTPUT1(x)              (0x1 << ((x) << 1))
1303 #define INPUT(x)                (0x2 << ((x) << 1))
1304
1305 #define PULL_DIS(x)             (0x0 << ((x) << 1))
1306 #define PULL_DOWN(x)            (0x1 << ((x) << 1))
1307 #define PULL_UP(x)              (0x2 << ((x) << 1))
1308
1309 #define PREVIOUS(x)             (0x3 << ((x) << 1))
1310
1311 struct gpio_powermode {
1312         unsigned int    conpdn;
1313         unsigned int    pudpdn;
1314 };
1315
1316 struct gpio_external {
1317         unsigned int    con;
1318         unsigned int    dat;
1319         unsigned int    pud;
1320 };
1321
1322 static struct gpio_powermode powerdown_modes[] = {
1323         {       /* S5PC110_GPIO_A0_OFFSET */
1324                 INPUT(0) | OUTPUT0(1) | INPUT(2) | OUTPUT0(3) |
1325                 INPUT(4) | OUTPUT0(5) | INPUT(6) | OUTPUT0(7),
1326                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1327                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1328         }, {    /* S5PC110_GPIO_A1_OFFSET */
1329                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3),
1330                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1331         }, {    /* S5PC110_GPIO_B_OFFSET */
1332                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1333                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1334                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1335                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1336         }, {    /* S5PC110_GPIO_C0_OFFSET */
1337                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1338                 OUTPUT0(4),
1339                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1340                 PULL_DIS(4),
1341         }, {    /* S5PC110_GPIO_C1_OFFSET */
1342                 /* OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1343                 OUTPUT0(4), */
1344                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1345                 OUTPUT0(4),
1346                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1347                 PULL_DIS(4),
1348         }, {    /* S5PC110_GPIO_D0_OFFSET */
1349                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3),
1350                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1351         }, {    /* S5PC110_GPIO_D1_OFFSET */
1352                 INPUT(0) | INPUT(1) | INPUT(2) | INPUT(3) |
1353                 INPUT(4) | INPUT(5),
1354                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1355                 PULL_DIS(4) | PULL_DIS(5),
1356         }, {    /* S5PC110_GPIO_E0_OFFSET */
1357                 INPUT(0) | INPUT(1) | INPUT(2) | INPUT(3) |
1358                 INPUT(4) | INPUT(5) | INPUT(6) | INPUT(7),
1359                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DOWN(2) | PULL_DOWN(3) |
1360                 PULL_DOWN(4) | PULL_DOWN(5) | PULL_DOWN(6) | PULL_DOWN(7),
1361         }, {    /* S5PC110_GPIO_E1_OFFSET */
1362                 INPUT(0) | INPUT(1) | INPUT(2) | OUTPUT0(3) |
1363                 OUTPUT0(4),
1364                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DOWN(2) | PULL_DIS(3) |
1365                 PULL_DIS(4),
1366         }, {    /* S5PC110_GPIO_F0_OFFSET */
1367                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1368                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1369                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1370                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1371         }, {    /* S5PC110_GPIO_F1_OFFSET */
1372                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1373                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1374                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1375                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1376         }, {    /* S5PC110_GPIO_F2_OFFSET */
1377                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1378                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1379                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1380                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1381         }, {    /* S5PC110_GPIO_F3_OFFSET */
1382                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1383                 OUTPUT0(4) | OUTPUT0(5),
1384                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1385                 PULL_DIS(4) | PULL_DIS(5),
1386         }, {    /* S5PC110_GPIO_G0_OFFSET */
1387                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1388                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1389                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1390                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1391         }, {    /* S5PC110_GPIO_G1_OFFSET */
1392                 OUTPUT0(0) | INPUT(1) | OUTPUT0(2) | INPUT(3) |
1393                 INPUT(4) | INPUT(5) | INPUT(6),
1394                 PULL_DIS(0) | PULL_UP(1) | PULL_DIS(2) | PULL_UP(3) |
1395                 PULL_UP(4) | PULL_UP(5) | PULL_UP(6),
1396         }, {    /* S5PC110_GPIO_G2_OFFSET */
1397                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1398                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1399                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1400                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1401         }, {    /* S5PC110_GPIO_G3_OFFSET */
1402                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | INPUT(3) |
1403                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1404                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1405                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1406         }, {    /* S5PC110_GPIO_I_OFFSET */
1407                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1408                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1409                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1410                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1411         }, {    /* S5PC110_GPIO_J0_OFFSET */
1412                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3) |
1413                 INPUT(4) | INPUT(5) | OUTPUT0(6) | OUTPUT0(7),
1414                 PULL_DOWN(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1415                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1416         }, {    /* S5PC110_GPIO_J1_OFFSET */
1417                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1418                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1419                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1420                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1421         }, {    /* S5PC110_GPIO_J2_OFFSET */
1422                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1423                 INPUT(4) | OUTPUT0(5) | INPUT(6) | INPUT(7),
1424                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1425                 PULL_DIS(4) | PULL_DIS(5) | PULL_DOWN(6) | PULL_DOWN(7),
1426         }, {    /* S5PC110_GPIO_J3_OFFSET */
1427                 INPUT(0) | INPUT(1) | OUTPUT0(2) | OUTPUT0(3) |
1428                 OUTPUT1(4) | OUTPUT0(5) | INPUT(6) | INPUT(7),
1429                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DIS(2) | PULL_DIS(3) |
1430                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1431         }, {    /* S5PC110_GPIO_J4_OFFSET */
1432                 INPUT(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1433                 OUTPUT0(4),
1434                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1435                 PULL_DIS(4),
1436         }, {    /* S5PC110_MP0_1_OFFSET */
1437                 /* XM0CSN[4]: MP0_1[4] -> output high */
1438                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | OUTPUT0(3) |
1439                 OUTPUT1(4) | OUTPUT0(5) | OUTPUT1(6) | OUTPUT1(7),
1440                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1441                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1442         }, {    /* S5PC110_MP0_2_OFFSET */
1443                 OUTPUT0(0) | OUTPUT0(1) | INPUT(2) | OUTPUT0(3),
1444                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1445         }, {    /* S5PC110_MP0_3_OFFSET */
1446                 /* XM0FWEN: MP0_3[2] -> output high */
1447                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | OUTPUT0(3) |
1448                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1449                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1450                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1451         }, {    /* S5PC110_MP0_4_OFFSET */
1452                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1453                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1454                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DOWN(3) |
1455                 PULL_DOWN(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1456         }, {    /* S5PC110_MP0_5_OFFSET */
1457                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3) |
1458                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1459                 PULL_DOWN(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1460                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1461         }, {    /* S5PC110_MP0_6_OFFSET */
1462                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1463                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1464                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1465                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1466         }, {    /* S5PC110_MP0_7_OFFSET */
1467                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1468                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1469                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1470                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1471         },
1472 };
1473
1474 static struct gpio_external external_powerdown_modes[] = {
1475         {       /* S5PC110_GPIO_H0_OFFSET */
1476                 CON_OUTPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_OUTPUT(3) |
1477                 CON_OUTPUT(4) | CON_OUTPUT(5) | CON_INPUT(6) | CON_INPUT(7),
1478                 DAT_SET(0) | DAT_CLEAR(2) | DAT_CLEAR(3) |
1479                 DAT_CLEAR(4) | DAT_CLEAR(5),
1480                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1481                 PULL_DIS(4) | PULL_DIS(5),
1482         }, {    /* S5PC110_GPIO_H1_OFFSET */
1483                 /* CON_INPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_IRQ(3) |
1484                 CON_IRQ(4) | CON_INPUT(5) | CON_INPUT(6) | CON_INPUT(7),
1485                 DAT_CLEAR(2),
1486                 PULL_DOWN(0) | PULL_DOWN(1) |
1487                 PULL_DOWN(6),           */
1488                 CON_INPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_IRQ(3) |
1489                 CON_INPUT(4) | CON_INPUT(5) | CON_OUTPUT(6) | CON_INPUT(7),
1490                 DAT_SET(0),
1491                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1492                 PULL_DOWN(4),
1493         }, {    /* S5PC110_GPIO_H2_OFFSET */
1494                 CON_OUTPUT(0) | CON_OUTPUT(1) | CON_OUTPUT(2) | CON_OUTPUT(3) |
1495                 CON_IRQ(4) | CON_IRQ(5) | CON_IRQ(6) | CON_IRQ(7),
1496                 DAT_CLEAR(0) | DAT_CLEAR(1) | DAT_CLEAR(2) | DAT_CLEAR(3),
1497                 0,
1498         }, {    /* S5PC110_GPIO_H3_OFFSET */
1499                 CON_IRQ(0) | CON_IRQ(1) | CON_IRQ(2) | CON_OUTPUT(3) |
1500                 CON_IRQ(4) | CON_INPUT(5) | CON_IRQ(6) | CON_OUTPUT(7),
1501                 DAT_CLEAR(3) | DAT_CLEAR(7),
1502                 0,
1503         },
1504 };
1505
1506 static void setup_power_down_mode_registers(void)
1507 {
1508         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *)S5PC110_GPIO_BASE;
1509         struct s5pc1xx_gpio_bank *bank;
1510         struct gpio_powermode *p;
1511         struct gpio_external *ge;
1512         int i;
1513
1514         if (cpu_is_s5pc100())
1515                 return;
1516
1517         if (!(machine_is_aquila() && board_is_limo_real()))
1518                 return;
1519
1520         bank = &gpio->gpio_a0;
1521         p = powerdown_modes;
1522
1523         for (i = 0; i < ARRAY_SIZE(powerdown_modes); i++, p++, bank++) {
1524                 writel(p->conpdn, &bank->pdn_con);
1525                 writel(p->pudpdn, &bank->pdn_pull);
1526         }
1527         /* M299 */
1528         writel(0xff0022b0, (unsigned int *)0xF0000000);
1529         writel(0xff0022b0, (unsigned int *)0xF1400000);
1530
1531
1532         bank = &gpio->gpio_h0;
1533         ge = external_powerdown_modes;
1534
1535         for (i = 0; i < ARRAY_SIZE(external_powerdown_modes); i++) {
1536                 writel(ge->con, &bank->con);
1537                 writel(ge->dat, &bank->dat);
1538                 writel(ge->pud, &bank->pull);
1539
1540                 bank++;
1541                 ge++;
1542         }
1543 }
1544
1545 #ifdef CONFIG_LCD
1546 struct s6e63m0_platform_data {
1547         struct s5pc1xx_gpio_bank *bank;
1548         unsigned int num;
1549 };
1550
1551 extern void s6e63m0_set_spi_interface(struct s6e63m0_platform_data *cs,
1552         struct s6e63m0_platform_data *clk, struct s6e63m0_platform_data *si,
1553         struct s6e63m0_platform_data *so);
1554
1555 struct s6e63m0_platform_data pd_cs, pd_clk, pd_si, pd_so;
1556 struct s5pc110_gpio *gpio_base = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1557
1558 void lcd_cfg_gpio(void)
1559 {
1560         unsigned int i, f3_end = 4;
1561
1562         for (i = 0; i < 8; i++) {
1563                 /* set GPF0,1,2[0:7] for RGB Interface and Data lines (32bit) */
1564                 gpio_cfg_pin(&gpio_base->gpio_f0, i, GPIO_FUNC(2));
1565                 gpio_cfg_pin(&gpio_base->gpio_f1, i, GPIO_FUNC(2));
1566                 gpio_cfg_pin(&gpio_base->gpio_f2, i, GPIO_FUNC(2));
1567                 /* pull-up/down disable */
1568                 gpio_set_pull(&gpio_base->gpio_f0, i, GPIO_PULL_NONE);
1569                 gpio_set_pull(&gpio_base->gpio_f1, i, GPIO_PULL_NONE);
1570                 gpio_set_pull(&gpio_base->gpio_f2, i, GPIO_PULL_NONE);
1571
1572                 /* drive strength to max (24bit) */
1573                 gpio_set_drv(&gpio_base->gpio_f0, i, GPIO_DRV_4x);
1574                 gpio_set_rate(&gpio_base->gpio_f0, i, GPIO_DRV_SLOW);
1575                 gpio_set_drv(&gpio_base->gpio_f1, i, GPIO_DRV_4x);
1576                 gpio_set_rate(&gpio_base->gpio_f1, i, GPIO_DRV_SLOW);
1577                 gpio_set_drv(&gpio_base->gpio_f2, i, GPIO_DRV_4x);
1578                 gpio_set_rate(&gpio_base->gpio_f2, i, GPIO_DRV_SLOW);
1579         }
1580
1581         /* set DISPLAY_DE_B pin for dual rgb mode. */
1582         if (board_is_media())
1583                 f3_end = 5;
1584
1585         for (i = 0; i < f3_end; i++) {
1586                 /* set GPF3[0:3] for RGB Interface and Data lines (32bit) */
1587                 gpio_cfg_pin(&gpio_base->gpio_f3, i, GPIO_PULL_UP);
1588                 /* pull-up/down disable */
1589                 gpio_set_pull(&gpio_base->gpio_f3, i, GPIO_PULL_NONE);
1590                 /* drive strength to max (24bit) */
1591                 gpio_set_drv(&gpio_base->gpio_f3, i, GPIO_DRV_4x);
1592                 gpio_set_rate(&gpio_base->gpio_f3, i, GPIO_DRV_SLOW);
1593         }
1594         /* display output path selection (only [1:0] valid) */
1595         writel(0x2, 0xE0107008);
1596
1597         /* gpio pad configuration for LCD reset. */
1598         gpio_cfg_pin(&gpio_base->gpio_mp0_5, 5, GPIO_OUTPUT);
1599
1600         /* gpio pad configuration for LCD ON. */
1601         gpio_cfg_pin(&gpio_base->gpio_j1, 3, GPIO_OUTPUT);
1602
1603         /* MLCD_ON2 */
1604         /*
1605         if (board_is_p2_real())
1606              gpio_cfg_pin(&gpio_base->gpio_j1, 4, GPIO_OUTPUT);
1607         */
1608
1609         /* LCD_BACKLIGHT_EN */
1610         if (machine_is_geminus())
1611                 gpio_cfg_pin(&gpio_base->gpio_mp0_5, 0, GPIO_OUTPUT);
1612
1613         /*
1614          * gpio pad configuration for
1615          * DISPLAY_CS, DISPLAY_CLK, DISPLAY_SO, DISPLAY_SI.
1616          */
1617         gpio_cfg_pin(&gpio_base->gpio_mp0_1, 1, GPIO_OUTPUT);
1618         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 1, GPIO_OUTPUT);
1619         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 2, GPIO_INPUT);
1620         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 3, GPIO_OUTPUT);
1621
1622         if (machine_is_aquila()) {
1623                 pd_cs.bank = &gpio_base->gpio_mp0_1;
1624                 pd_cs.num = 1;
1625                 pd_clk.bank = &gpio_base->gpio_mp0_4;
1626                 pd_clk.num = 1;
1627                 pd_si.bank = &gpio_base->gpio_mp0_4;
1628                 pd_si.num = 3;
1629                 pd_so.bank = &gpio_base->gpio_mp0_4;
1630                 pd_so.num = 2;
1631
1632                 /* these data would be sent to s6e63m0 lcd panel driver. */
1633                 s6e63m0_set_spi_interface(&pd_cs, &pd_clk, &pd_si, &pd_so);
1634         }
1635
1636         if (machine_is_cypress()) {
1637 #if 0           /* universal cypress */
1638                 /* FLCD_CS */
1639                 gpio_cfg_pin(&gpio_base->gpio_mp0_1, 0, GPIO_OUTPUT);
1640 #endif
1641                 /* FLCD_CS_S */
1642                 gpio_cfg_pin(&gpio_base->gpio_mp0_5, 1, GPIO_OUTPUT);
1643                 /* FLCD_CLK */
1644                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 0, GPIO_OUTPUT);
1645                 /* FLCD_SDI */
1646                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 2, GPIO_OUTPUT);
1647                 /* FLCD_RST_S */
1648                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 5, GPIO_OUTPUT);
1649                 /* FLCD_ON_S */
1650                 gpio_cfg_pin(&gpio_base->gpio_g2, 2, GPIO_OUTPUT);
1651 #if 0           /* universal cypress */
1652                 pd_cs.bank = &gpio_base->gpio_mp0_1;
1653                 pd_cs.num = 0;
1654 #endif
1655                 pd_cs.bank = &gpio_base->gpio_mp0_5;
1656                 pd_cs.num = 1;
1657                 pd_clk.bank = &gpio_base->gpio_mp0_4;
1658                 pd_clk.num = 0;
1659                 pd_si.bank = &gpio_base->gpio_mp0_4;
1660                 pd_si.num = 2;
1661
1662                 /* these data would be sent to s6e63m0 lcd panel driver. */
1663                 s6e63m0_set_spi_interface(&pd_cs, &pd_clk, &pd_si, NULL);
1664         }
1665
1666         return;
1667 }
1668
1669 void backlight_on(unsigned int onoff)
1670 {
1671         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1672
1673         if (onoff) {
1674                 if (machine_is_geminus())
1675                         gpio_set_value(&gpio->gpio_mp0_5, 0, 1);
1676         } else {
1677                 if (machine_is_geminus())
1678                         gpio_set_value(&gpio->gpio_mp0_5, 0, 0);
1679         }
1680 }
1681
1682 void reset_lcd(void)
1683 {
1684         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1685
1686         if (machine_is_aquila() || machine_is_geminus())
1687                 gpio_set_value(&gpio->gpio_mp0_5, 5, 1);
1688         if (machine_is_cypress())
1689                 gpio_set_value(&gpio->gpio_mp0_4, 5, 1);
1690 }
1691
1692 void lcd_power_on(unsigned int onoff)
1693 {
1694         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1695
1696         if (onoff) {
1697                 if (machine_is_aquila() || machine_is_geminus())
1698                         gpio_set_value(&gpio->gpio_j1, 3, 1);
1699
1700                 if (machine_is_cypress())
1701                         gpio_set_value(&gpio->gpio_g2, 2, 1);
1702
1703                 /*
1704                 if (board_is_p2_real())
1705                         gpio_set_value(&gpio->gpio_j1, 4, 1);
1706                 */
1707
1708 #ifdef ARIES
1709                 if (board_is_aries())
1710                 {
1711                         unsigned char addr;
1712                         unsigned char val[2];
1713                         unsigned char val2[2];
1714
1715                         i2c_set_bus_num(I2C_PMIC);
1716                         addr = 0xCC >> 1;       /* max8998 */
1717                         if (i2c_probe(addr)) {
1718                                 printf("Can't found max8998\n");
1719                                 return;
1720                         }
1721
1722                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1723                         val[0] |= (1 << 7);
1724                         val2[0] = 0x2;
1725                         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1726                         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1727                         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1728                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1729
1730                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1731                         val[0] |= MAX8998_LDO17;
1732                         val2[0] = 0xE;
1733                         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1734                         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1735                         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1736                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1737                 }
1738 #endif /* ARIES */
1739
1740
1741         } else {
1742                 if (machine_is_aquila() || machine_is_geminus())
1743                         gpio_set_value(&gpio->gpio_j1, 3, 0);
1744
1745                 if (machine_is_cypress())
1746                         gpio_set_value(&gpio->gpio_g2, 2, 0);
1747
1748                 /*
1749                 if (board_is_p2_real())
1750                      gpio_set_value(&gpio->gpio_j1, 4, 0);
1751                 */
1752
1753 #ifdef ARIES
1754                 if (board_is_aries())
1755                 {
1756                         unsigned char addr;
1757                         unsigned char val[2];
1758
1759                         i2c_set_bus_num(I2C_PMIC);
1760                         addr = 0xCC >> 1;       /* max8998 */
1761                         if (i2c_probe(addr)) {
1762                                 printf("Can't found max8998\n");
1763                                 return;
1764                         }
1765
1766                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1767                         val[0] &= ~(1 << 7);
1768                         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1769                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1770
1771                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1772                         val[0] &= ~MAX8998_LDO17;
1773                         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1774                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1775                 }
1776 #endif /* ARIES */
1777
1778         }
1779 }
1780
1781 extern void s6e63m0_cfg_ldo(void);
1782 extern void s6e63m0_enable_ldo(unsigned int onoff);
1783
1784 void init_panel_info(vidinfo_t *vid)
1785 {
1786         vid->cfg_gpio = NULL;
1787         vid->reset_lcd = NULL;
1788         vid->backlight_on = NULL;
1789         vid->lcd_power_on = NULL;
1790
1791         vid->cfg_ldo = NULL;
1792         vid->enable_ldo = NULL;
1793
1794         vid->init_delay = 0;
1795         vid->reset_delay = 0;
1796         vid->power_on_delay = 0;
1797
1798         vid->vl_freq    = 60;
1799         vid->vl_col     = 480;
1800         vid->vl_row     = 800;
1801         vid->vl_width   = 480;
1802         vid->vl_height  = 800;
1803
1804         vid->dual_lcd_enabled = 0;
1805
1806         if (board_is_media()) {
1807                 vid->vl_col     = 960;
1808                 vid->vl_row     = 800;
1809                 vid->vl_width   = 960;
1810                 vid->vl_height  = 800;
1811
1812                 /* enable dual lcd mode. */
1813                 vid->dual_lcd_enabled = 1;
1814         }
1815
1816         vid->vl_clkp    = CONFIG_SYS_HIGH;
1817         vid->vl_hsp     = CONFIG_SYS_LOW;
1818         vid->vl_vsp     = CONFIG_SYS_LOW;
1819         vid->vl_dp      = CONFIG_SYS_HIGH;
1820         vid->vl_bpix    = 32;
1821
1822         /* S6E63M0 LCD Panel */
1823         vid->vl_hspw    = 2;
1824         vid->vl_hbpd    = 16;
1825         vid->vl_hfpd    = 16;
1826
1827         vid->vl_vspw    = 2;
1828         vid->vl_vbpd    = 3;
1829         vid->vl_vfpd    = 28;
1830
1831         if (machine_is_aquila() || machine_is_cypress()) {
1832                 vid->cfg_gpio = lcd_cfg_gpio;
1833                 vid->reset_lcd = reset_lcd;
1834                 vid->backlight_on = backlight_on;
1835                 vid->lcd_power_on = lcd_power_on;
1836
1837                 vid->cfg_ldo = s6e63m0_cfg_ldo;
1838                 vid->enable_ldo = s6e63m0_enable_ldo;
1839
1840                 vid->init_delay = 25000;
1841                 vid->reset_delay = 120000;
1842         }
1843
1844         if (machine_is_geminus()) {
1845                 vid->vl_freq    = 60;
1846                 vid->vl_col     = 1024,
1847                 vid->vl_row     = 600,
1848                 vid->vl_width   = 1024,
1849                 vid->vl_height  = 600,
1850                 vid->vl_clkp    = CONFIG_SYS_LOW,
1851                 vid->vl_hsp     = CONFIG_SYS_HIGH,
1852                 vid->vl_vsp     = CONFIG_SYS_HIGH,
1853                 vid->vl_dp      = CONFIG_SYS_LOW,
1854                 vid->vl_bpix    = 32,
1855
1856                 vid->vl_hspw    = 32,
1857                 vid->vl_hfpd    = 48,
1858                 vid->vl_hbpd    = 80,
1859
1860                 vid->vl_vspw    = 1,
1861                 vid->vl_vfpd    = 3,
1862                 vid->vl_vbpd    = 4,
1863
1864                 vid->cfg_gpio = lcd_cfg_gpio;
1865                 vid->reset_lcd = reset_lcd;
1866                 vid->backlight_on = backlight_on;
1867                 vid->lcd_power_on = lcd_power_on;
1868         }
1869 #if 0
1870         vid->vl_freq    = 60;
1871         vid->vl_col     = 480,
1872         vid->vl_row     = 800,
1873         vid->vl_width   = 480,
1874         vid->vl_height  = 800,
1875         vid->vl_clkp    = CONFIG_SYS_HIGH,
1876         vid->vl_hsp     = CONFIG_SYS_LOW,
1877         vid->vl_vsp     = CONFIG_SYS_LOW,
1878         vid->vl_dp      = CONFIG_SYS_HIGH,
1879         vid->vl_bpix    = 32,
1880
1881         /* tl2796 panel. */
1882         vid->vl_hpw     = 4,
1883         vid->vl_blw     = 8,
1884         vid->vl_elw     = 8,
1885
1886         vid->vl_vpw     = 4,
1887         vid->vl_bfw     = 8,
1888         vid->vl_efw     = 8,
1889 #endif
1890 #if 0
1891         vid->vl_freq    = 60;
1892         vid->vl_col     = 1024,
1893         vid->vl_row     = 600,
1894         vid->vl_width   = 1024,
1895         vid->vl_height  = 600,
1896         vid->vl_clkp    = CONFIG_SYS_HIGH,
1897         vid->vl_hsp     = CONFIG_SYS_HIGH,
1898         vid->vl_vsp     = CONFIG_SYS_HIGH,
1899         vid->vl_dp      = CONFIG_SYS_LOW,
1900         vid->vl_bpix    = 32,
1901
1902         /* AMS701KA AMOLED Panel. */
1903         vid->vl_hpw     = 30,
1904         vid->vl_blw     = 114,
1905         vid->vl_elw     = 48,
1906
1907         vid->vl_vpw     = 2,
1908         vid->vl_bfw     = 6,
1909         vid->vl_efw     = 8,
1910 #endif
1911 }
1912 #endif
1913
1914 static void setup_meminfo(void)
1915 {
1916         char meminfo[64] = {0, };
1917         int count = 0, size, real;
1918
1919         size = gd->bd->bi_dram[0].size >> 20;
1920         count += sprintf(meminfo + count, "mem=%dM", size);
1921
1922         /* Each Chip Select can't exceed the 256MiB */
1923         size = gd->bd->bi_dram[1].size >> 20;
1924         real = min(size, 256);
1925         count += sprintf(meminfo + count, " mem=%dM@0x%x",
1926                 real, (unsigned int)gd->bd->bi_dram[1].start);
1927
1928         size -= real;
1929         if (size > 0) {
1930                 count += sprintf(meminfo + count, " mem=%dM@0x%x", size,
1931                         (unsigned int)gd->bd->bi_dram[1].start + (real << 20));
1932         }
1933
1934         setenv("meminfo", meminfo);
1935 }
1936
1937 int misc_init_r(void)
1938 {
1939 #ifdef CONFIG_LCD
1940         /* It should be located at first */
1941         lcd_is_enabled = 0;
1942
1943         if (board_is_limo_real() ||
1944                 board_is_limo_universal() ||
1945                 board_is_j1b2())
1946                 setenv("lcdinfo", "lcd=s6e63m0");
1947         /* it can't classify tl2796 with single-lcd and dual-lcd.
1948         else
1949                 setenv("lcdinfo", "lcd=tl2796-dual");
1950         */
1951
1952         /*
1953          * env values below should be added in case that lcd panel of geminus,
1954          * p1 and p2 are enabled at u-boot.
1955          * setenv means that lcd panel has been turned on at u-boot.
1956          */
1957         if (machine_is_geminus())
1958                 setenv("lcdinfo", "lcd=lms480jc01");
1959         if (board_is_media())
1960                 setenv("lcdinfo", "lcd=media");
1961         /*
1962         if (board_is_p2_real())
1963                 setenv("lcdinfo", "lcd=ams701");
1964         */
1965 #endif
1966         setup_meminfo();
1967
1968         show_hw_revision();
1969
1970         /* Set proper PMIC pins */
1971         pmic_pin_init();
1972
1973         /* Check auto burning */
1974         check_auto_burn();
1975
1976         /* To power up I2C2 */
1977         enable_ldos();
1978
1979         /* Enable T-Flash at Limo Real or Limo Universal */
1980         enable_t_flash();
1981
1982         /* Setup Limo Real board GPIOs */
1983         setup_limo_real_gpios();
1984
1985         /* Setup Media board GPIOs */
1986         setup_media_gpios();
1987
1988         /* Setup P1P2 board GPIOS */
1989         setup_p1p2_gpios();
1990
1991         /* To usbdown automatically */
1992         if (board_is_p2_real())
1993                 check_p2_keypad();
1994         else
1995                 check_keypad();
1996
1997         /* check max8998 */
1998         init_pmic();
1999
2000 #ifdef CONFIG_S5PC1XXFB
2001         display_device_info();
2002 #endif
2003
2004         setup_power_down_mode_registers();
2005
2006         /* check max17040 */
2007         check_battery();
2008
2009         /* check fsa9480 */
2010         check_micro_usb(0);
2011
2012         return 0;
2013 }
2014 #endif
2015
2016 int board_init(void)
2017 {
2018         /* Set Initial global variables */
2019         s5pc110_gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
2020
2021         gd->bd->bi_arch_number = MACH_TYPE;
2022         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
2023
2024         /* Check H/W Revision */
2025         check_hw_revision();
2026
2027         return 0;
2028 }
2029
2030 int dram_init(void)
2031 {
2032         unsigned int base, memconfig0, size;
2033         unsigned int memconfig1, sz = 0;
2034
2035         if (cpu_is_s5pc100()) {
2036                 /* In mem setup, we swap the bank. So below size is correct */
2037                 gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
2038                 gd->bd->bi_dram[0].size = PHYS_SDRAM_2_SIZE;
2039                 gd->bd->bi_dram[1].start = S5PC100_PHYS_SDRAM_2;
2040                 size = 128;
2041         } else {
2042                 /* In S5PC110, we can't swap the DMC0/1 */
2043                 gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
2044                 gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
2045
2046                 base = S5PC110_DMC1_BASE;
2047                 /* DMC configuration */
2048                 memconfig0 = readl(base + MEMCONFIG0_OFFSET);
2049                 gd->bd->bi_dram[1].start = memconfig0 & 0xFF000000;
2050
2051                 size = (memconfig0 >> 16) & 0xFF;
2052                 size = ((unsigned char) ~size) + 1;
2053
2054                 /*
2055                  * (0x07 + 1) * 16 = 128 MiB
2056                  * (0x0f + 1) * 16 = 256 MiB
2057                  */
2058                 size = size << 4;
2059
2060                 /*
2061                  * Aquila Rev0.5 4G3G1G
2062                  * Aquila Rev0.8 4G3G1G
2063                  */
2064                 if (machine_is_aquila() && (hwrevision(5) || hwrevision(8))) {
2065                         memconfig1 = readl(base + MEMCONFIG1_OFFSET);
2066
2067                         sz = (memconfig1 >> 16) & 0xFF;
2068                         sz = ((unsigned char) ~sz) + 1;
2069                         sz = sz << 4;
2070                 }
2071
2072         }
2073         /*
2074          * bi_dram[1].size contains all DMC1 memory size
2075          */
2076         gd->bd->bi_dram[1].size = (size + sz) << 20;
2077
2078         return 0;
2079 }
2080
2081 /* Used for sleep test */
2082 static unsigned char saved_val[4][2];
2083 void board_sleep_init_late(void)
2084 {
2085         /* CODEC_LDO_EN: GPF3[4] */
2086         gpio_direction_output(&s5pc110_gpio->gpio_f3, 4, 0);
2087         /* CODEC_XTAL_EN: GPH3[2] */
2088         gpio_direction_output(&s5pc110_gpio->gpio_h3, 2, 0);
2089
2090         /* MMC T_FLASH off */
2091         gpio_direction_output(&s5pc110_gpio->gpio_mp0_5, 4, 0);
2092         /* MHL off */
2093         gpio_direction_output(&s5pc110_gpio->gpio_j2, 2, 0);
2094         gpio_direction_output(&s5pc110_gpio->gpio_mp0_4, 7, 0);
2095         gpio_direction_output(&s5pc110_gpio->gpio_j2, 3, 0); /* MHL_ON for REV02 or higher */
2096
2097
2098 }
2099 void board_sleep_init(void)
2100 {
2101         unsigned char addr;
2102         unsigned char val[2];
2103
2104         i2c_set_bus_num(I2C_PMIC);
2105         addr = 0xCC >> 1;
2106         if (i2c_probe(addr)) {
2107                 printf("Can't find max8998\n");
2108                 return;
2109         }
2110
2111         /* Set ONOFF1 */
2112         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2113         saved_val[0][0] = val[0];
2114         saved_val[0][1] = val[1];
2115         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 4) | (1 << 2) |
2116                         (1 << 1) | (1 << 0));
2117         i2c_write(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2118         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2119         /* Set ONOFF2 */
2120         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2121         saved_val[1][0] = val[0];
2122         saved_val[1][1] = val[1];
2123         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 3) |
2124                         (1 << 2) | (1 << 1) | (1 << 0));
2125         val[0] |= (1 << 7);
2126         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2127         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2128         /* Set ONOFF3 */
2129         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2130         saved_val[2][0] = val[0];
2131         saved_val[2][1] = val[1];
2132         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 4));
2133         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2134         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2135         /* Set ONOFF4 */
2136         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2137         saved_val[3][0] = val[0];
2138         saved_val[3][1] = val[1];
2139         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 4));
2140         i2c_write(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2141         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2142         printf("Turned off regulators. Preparing to sleep. [%s:%d]\n",
2143                         __FILE__, __LINE__);
2144 }
2145
2146 void board_sleep_resume(void)
2147 {
2148         unsigned char addr;
2149         unsigned char val[2];
2150
2151         show_hw_revision();
2152
2153         i2c_set_bus_num(I2C_PMIC);
2154         addr = 0xCC >> 1;
2155         if (i2c_probe(addr)) {
2156                 printf("Can't find max8998\n");
2157                 return;
2158         }
2159
2160         /* Set ONOFF1 */
2161         i2c_write(addr, MAX8998_REG_ONOFF1, 1, saved_val[0], 1);
2162         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2163         /* Set ONOFF2 */
2164         i2c_write(addr, MAX8998_REG_ONOFF2, 1, saved_val[1], 1);
2165         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2166         /* Set ONOFF3 */
2167         i2c_write(addr, MAX8998_REG_ONOFF3, 1, saved_val[2], 1);
2168         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2169         /* Set ONOFF4 */
2170         i2c_write(addr, MAX8998_REG_ONOFF3+1, 1, saved_val[3], 1);
2171         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2172         printf("Waked up.\n");
2173
2174         /* check max17040 */
2175         check_battery();
2176
2177         /* check fsa9480 */
2178         check_micro_usb(1);
2179 }
2180
2181 #ifdef CONFIG_CMD_USBDOWN
2182 int usb_board_init(void)
2183 {
2184 #ifdef CONFIG_CMD_PMIC
2185         run_command("pmic ldo 3 on", 0);
2186 #endif
2187
2188         if (cpu_is_s5pc100()) {
2189 #ifdef CONFIG_HARD_I2C
2190                 uchar val[2] = {0,};
2191
2192                 /* PMIC */
2193                 if (i2c_read(0x66, 0, 1, val, 2)) {
2194                         printf("i2c_read error\n");
2195                         return 1;
2196                 }
2197
2198                 val[0] |= (1 << 3);
2199                 val[1] |= (1 << 5);
2200
2201                 if (i2c_write(0x66, 0, 1, val, 2)) {
2202                         printf("i2c_write error\n");
2203                         return 1;
2204                 }
2205                 i2c_read(0x66, 0, 1, val, 2);
2206 #endif
2207                 return 0;
2208         }
2209
2210         /* S5PC110 */
2211         if (board_is_limo_universal() ||
2212                 board_is_limo_real() ||
2213                 board_is_media()) {
2214                 /* check usb path */
2215                 if (board_is_limo_real() && !hwrevision(6))
2216                         check_mhl();
2217         }
2218
2219         if (machine_is_tickertape())
2220                 /* USB_SEL: XM0ADDR_0: MP04[0] output mode */
2221                 gpio_direction_output(&s5pc110_gpio->gpio_mp0_4, 0, 0);
2222
2223         return 0;
2224 }
2225 #endif
2226
2227 #ifdef CONFIG_GENERIC_MMC
2228 int board_mmc_init(bd_t *bis)
2229 {
2230         unsigned int reg;
2231         unsigned int clock;
2232         struct s5pc110_clock *clk = (struct s5pc110_clock *)S5PC1XX_CLOCK_BASE;
2233         int i;
2234
2235         /* MMC0 Clock source = SCLKMPLL */
2236         reg = readl(&clk->src4);
2237         reg &= ~0xf;
2238         reg |= 0x6;
2239         writel(reg, &clk->src4);
2240
2241         reg = readl(&clk->div4);
2242         reg &= ~0xf;
2243
2244         /* set div value near 50MHz */
2245         clock = get_pll_clk(MPLL) / 1000000;
2246         for (i = 0; i < 0xf; i++) {
2247                 if ((clock / (i + 1)) <= 50) {
2248                         reg |= i << 0;
2249                         break;
2250                 }
2251         }
2252
2253         writel(reg, &clk->div4);
2254
2255         /*
2256          * MMC0 GPIO
2257          * GPG0[0]      SD_0_CLK
2258          * GPG0[1]      SD_0_CMD
2259          * GPG0[2]      SD_0_CDn        -> Not used
2260          * GPG0[3:6]    SD_0_DATA[0:3]
2261          */
2262         for (i = 0; i < 7; i++) {
2263                 if (i == 2)
2264                         continue;
2265                 /* GPG0[0:6] special function 2 */
2266                 gpio_cfg_pin(&s5pc110_gpio->gpio_g0, i, 0x2);
2267                 /* GPG0[0:6] pull disable */
2268                 gpio_set_pull(&s5pc110_gpio->gpio_g0, i, GPIO_PULL_NONE);
2269                 /* GPG0[0:6] drv 4x */
2270                 gpio_set_drv(&s5pc110_gpio->gpio_g0, i, GPIO_DRV_4x);
2271         }
2272
2273         return s5pc1xx_mmc_init(0);
2274 }
2275 #endif
2276
2277 #ifdef CONFIG_CMD_PMIC
2278 static int pmic_status(void)
2279 {
2280         unsigned char addr, val[2];
2281         int reg, i;
2282
2283         i2c_set_bus_num(I2C_PMIC);
2284         addr = 0xCC >> 1;
2285         if (i2c_probe(addr)) {
2286                 printf("Can't found max8998\n");
2287                 return -1;
2288         }
2289
2290         reg = 0x11;
2291         i2c_read(addr, reg, 1, val, 1);
2292         for (i = 7; i >= 4; i--)
2293                 printf("BUCK%d %s\n", 7 - i + 1,
2294                         val[0] & (1 << i) ? "on" : "off");
2295         for (; i >= 0; i--)
2296                 printf("LDO%d %s\n", 5 - i,
2297                         val[0] & (1 << i) ? "on" : "off");
2298         reg = 0x12;
2299         i2c_read(addr, reg, 1, val, 1);
2300         for (i = 7; i >= 0; i--)
2301                 printf("LDO%d %s\n", 7 - i + 6,
2302                         val[0] & (1 << i) ? "on" : "off");
2303         reg = 0x13;
2304         i2c_read(addr, reg, 1, val, 1);
2305         for (i = 7; i >= 4; i--)
2306                 printf("LDO%d %s\n", 7 - i + 14,
2307                         val[0] & (1 << i) ? "on" : "off");
2308
2309         reg = 0xd;
2310         i2c_read(addr, reg, 1, val, 1);
2311         for (i = 7; i >= 6; i--)
2312                 printf("SAFEOUT%d %s\n", 7 - i + 1,
2313                         val[0] & (1 << i) ? "on" : "off");
2314         return 0;
2315 }
2316
2317 static int pmic_ldo_control(int buck, int ldo, int safeout, int on)
2318 {
2319         unsigned char addr, val[2];
2320         unsigned int reg, shift;
2321
2322         if (ldo) {
2323                 if (ldo < 2)
2324                         return -1;
2325                 if (ldo <= 5) {
2326                         reg = 0x11;
2327                         shift = 5 - ldo;
2328                 } else if (ldo <= 13) {
2329                         reg = 0x12;
2330                         shift = 13 - ldo;
2331                 } else if (ldo <= 17) {
2332                         reg = 0x13;
2333                         shift = 17 - ldo + 4;
2334                 } else
2335                         return -1;
2336         } else if (buck) {
2337                 if (buck > 4)
2338                         return -1;
2339                 reg = 0x11;
2340                 shift = 4 - buck + 4;
2341         } else if (safeout) {
2342                 if (safeout > 3)
2343                         return -1;
2344                 reg = 0xd;
2345                 shift = 8 - safeout;
2346         } else
2347                 return -1;
2348
2349         i2c_set_bus_num(I2C_PMIC);
2350         addr = 0xCC >> 1;
2351         if (i2c_probe(addr)) {
2352                 printf("Can't found max8998\n");
2353                 return -1;
2354         }
2355
2356         i2c_read(addr, reg, 1, val, 1);
2357         if (on)
2358                 val[0] |= (1 << shift);
2359         else
2360                 val[0] &= ~(1 << shift);
2361         i2c_write(addr, reg, 1, val, 1);
2362         i2c_read(addr, reg, 1, val, 1);
2363
2364         if (ldo)
2365                 printf("ldo %d value 0x%x, %s\n", ldo, val[0],
2366                         val[0] & (1 << shift) ? "on" : "off");
2367         else if (buck)
2368                 printf("buck %d value 0x%x, %s\n", buck, val[0],
2369                         val[0] & (1 << shift) ? "on" : "off");
2370         else if (safeout)
2371                 printf("safeout %d value 0x%x, %s\n", safeout, val[0],
2372                         val[0] & (1 << shift) ? "on" : "off");
2373
2374         return 0;
2375 }
2376
2377 static int do_pmic(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
2378 {
2379         int buck = 0, ldo = 0, safeout = 0, on = -1;
2380
2381         switch (argc) {
2382         case 2:
2383                 if (strncmp(argv[1], "status", 6) == 0)
2384                         return pmic_status();
2385                 break;
2386         case 4:
2387                 if (strncmp(argv[1], "ldo", 3) == 0)
2388                         ldo = simple_strtoul(argv[2], NULL, 10);
2389                 else if (strncmp(argv[1], "buck", 4) == 0)
2390                         buck = simple_strtoul(argv[2], NULL, 10);
2391                 else if (strncmp(argv[1], "safeout", 7) == 0)
2392                         safeout = simple_strtoul(argv[2], NULL, 10);
2393                 else
2394                         break;
2395
2396                 if (strncmp(argv[3], "on", 2) == 0)
2397                         on = 1;
2398                 else if (strncmp(argv[3], "off", 3) == 0)
2399                         on = 0;
2400                 else
2401                         break;
2402
2403                 return pmic_ldo_control(buck, ldo, safeout, on);
2404
2405         default:
2406                 break;
2407         }
2408
2409         cmd_usage(cmdtp);
2410         return 1;
2411 }
2412
2413 U_BOOT_CMD(
2414         pmic,           CONFIG_SYS_MAXARGS,     1, do_pmic,
2415         "PMIC LDO & BUCK control",
2416         "status - Display PMIC LDO & BUCK status\n"
2417         "pmic ldo num on/off - Turn on/off the LDO\n"
2418         "pmic buck num on/off - Turn on/off the BUCK\n"
2419         "pmic safeout num on/off - Turn on/off the SAFEOUT\n"
2420 );
2421 #endif
2422
2423 #ifdef CONFIG_CMD_DEVICE_POWER
2424
2425 enum {
2426         POWER_NONE,
2427         POWER_TOUCH,
2428         POWER_3_TOUCHKEY,
2429         POWER_LCD,
2430         POWER_HAPTIC,
2431         POWER_AUDIO_CODEC,
2432         POWER_FM_RADIO,
2433         POWER_BT_WIFI,
2434         POWER_HDMI,
2435 };
2436
2437 static void power_display_devices(void)
2438 {
2439         printf("devices:\n");
2440         printf("\t%d - touch\n", POWER_TOUCH);
2441         printf("\t%d - 3 touchkey\n", POWER_3_TOUCHKEY);
2442         printf("\t%d - LCD\n", POWER_LCD);
2443         printf("\t%d - Haptic\n", POWER_HAPTIC);
2444         printf("\t%d - Audio Codec\n", POWER_AUDIO_CODEC);
2445         printf("\t%d - FM Radio\n", POWER_FM_RADIO);
2446         printf("\t%d - BT/WiFi\n", POWER_BT_WIFI);
2447         printf("\t%d - HDMI\n", POWER_HDMI);
2448 }
2449
2450 static int power_hdmi(int on)
2451 {
2452         /* HDMI_EN1: GPJ2[2] */
2453         gpio_direction_output(&s5pc110_gpio->gpio_j2, 2, on);
2454         /* MHL_ON: GPJ2[3] */
2455         gpio_direction_output(&s5pc110_gpio->gpio_j2, 3, on);
2456         return 0;
2457 }
2458
2459 static int power_bt_wifi(int on)
2460 {
2461         /* WLAN_BT_EN: GPB[5] */
2462         gpio_direction_output(&s5pc110_gpio->gpio_b, 5, on);
2463         return 0;
2464 }
2465
2466 static int power_fm_radio(int on)
2467 {
2468         /* FM_BUS_nRST: GPJ2[5] */
2469         gpio_direction_output(&s5pc110_gpio->gpio_j2, 5, !on);
2470         return 0;
2471 }
2472
2473 static int power_audio_codec(int on)
2474 {
2475         /* CODEC_LDO_EN: GPF3[4] */
2476         gpio_direction_output(&s5pc110_gpio->gpio_f3, 4, on);
2477         /* CODEC_XTAL_EN: GPH3[2] */
2478         gpio_direction_output(&s5pc110_gpio->gpio_h3, 2, on);
2479         return 0;
2480 }
2481
2482 static int power_haptic(int on)
2483 {
2484         /* HAPTIC_ON: GPJ1[1] */
2485         gpio_direction_output(&s5pc110_gpio->gpio_j1, 1, on);
2486         return 0;
2487 }
2488
2489 static int power_lcd(int on)
2490 {
2491         /* MLCD_ON: GPJ1[3] */
2492         gpio_direction_output(&s5pc110_gpio->gpio_j1, 3, on);
2493         return 0;
2494 }
2495
2496 static int power_touch(int on)
2497 {
2498         /* TOUCH_EN: GPG3[6] */
2499         gpio_direction_output(&s5pc110_gpio->gpio_g3, 6, on);
2500         return 0;
2501 }
2502
2503 static int power_3_touchkey(int on)
2504 {
2505         if (on) {
2506                 /* 3_TOUCH_EN - GPJ3[0] : (J1B2) */
2507                 /* 3_TOUCH_EN - GPJ3[5] : (not J1B2) */
2508                 if (board_rev & J1_B2_BOARD)
2509                         gpio_direction_output(&s5pc110_gpio->gpio_j3, 0, on);
2510                 else
2511                         gpio_direction_output(&s5pc110_gpio->gpio_j3, 5, on);
2512
2513                 /* 3_TOUCH_CE - GPJ2[6] */
2514                 gpio_direction_output(&s5pc110_gpio->gpio_j2, 6, on);   /* TOUCH_CE */
2515         } else {
2516                 /* 3_TOUCH_CE - GPJ2[6] */
2517                 gpio_direction_output(&s5pc110_gpio->gpio_j2, 6, on);   /* TOUCH_CE */
2518         }
2519
2520         if (on) {
2521                 unsigned int reg;
2522                 unsigned char val[2];
2523                 unsigned char addr = 0x20;              /* mcs5000 3-touchkey */
2524
2525                 /* Require 100ms */
2526                 udelay(80 * 1000);
2527
2528                 /* 3 touchkey */
2529                 i2c_set_bus_num(I2C_GPIO6);
2530
2531                 /* Workaround to probe */
2532                 if (i2c_probe(addr)) {
2533                         if (i2c_probe(addr)) {
2534                                 printf("Can't found 3 touchkey\n");
2535                                 return -ENODEV;
2536                         }
2537                 }
2538
2539 #define MCS5000_TK_HW_VERSION  0x06
2540 #define MCS5000_TK_FW_VERSION  0x0A
2541 #define MCS5000_TK_MI_VERSION  0x0B
2542
2543                 reg = MCS5000_TK_MI_VERSION;
2544                 i2c_read(addr, reg, 1, val, 1);
2545                 printf("3-touchkey:\tM/I 0x%x, ", val[0]);
2546                 reg = MCS5000_TK_HW_VERSION;
2547                 i2c_read(addr, reg, 1, val, 1);
2548                 printf("H/W 0x%x, ", val[0]);
2549                 reg = MCS5000_TK_FW_VERSION;
2550                 i2c_read(addr, reg, 1, val, 1);
2551                 printf("F/W 0x%x\n", val[0]);
2552         }
2553         return 0;
2554 }
2555
2556 static int power_control(int device, int on)
2557 {
2558         switch (device) {
2559         case POWER_TOUCH:
2560                 return power_touch(on);
2561         case POWER_3_TOUCHKEY:
2562                 return power_3_touchkey(on);
2563         case POWER_LCD:
2564                 return power_lcd(on);
2565         case POWER_HAPTIC:
2566                 return power_haptic(on);
2567         case POWER_AUDIO_CODEC:
2568                 return power_audio_codec(on);
2569         case POWER_FM_RADIO:
2570                 return power_fm_radio(on);
2571         case POWER_BT_WIFI:
2572                 return power_bt_wifi(on);
2573         case POWER_HDMI:
2574                 return power_hdmi(on);
2575         default:
2576                 printf("I don't know device %d\n", device);
2577                 break;
2578         }
2579         return 0;
2580 }
2581
2582 static int power_on(int on)
2583 {
2584         power_touch(on);
2585         power_3_touchkey(on);
2586         power_lcd(on);
2587         power_haptic(on);
2588         power_audio_codec(on);
2589         power_fm_radio(on);
2590         power_bt_wifi(on);
2591         power_hdmi(on);
2592
2593         return 0;
2594 }
2595
2596 static int do_power(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
2597 {
2598         int device, on;
2599
2600         if (!machine_is_aquila())
2601                 goto out;
2602
2603         switch (argc) {
2604         case 2:
2605                 if (strncmp(argv[1], "on", 2) == 0)
2606                         return power_on(1);
2607                 if (strncmp(argv[1], "off", 3) == 0)
2608                         return power_on(0);
2609                 break;
2610         case 3:
2611                 device = simple_strtoul(argv[1], NULL, 10);
2612                 if (device < 0)
2613                         break;
2614
2615                 if (strncmp(argv[2], "on", 2) == 0)
2616                         on = 1;
2617                 else if (strncmp(argv[2], "off", 3) == 0)
2618                         on = 0;
2619                 else
2620                         break;
2621                 return power_control(device, on);
2622         default:
2623                 break;
2624         }
2625 out:
2626         cmd_usage(cmdtp);
2627         power_display_devices();
2628         return 1;
2629 }
2630
2631 U_BOOT_CMD(
2632         power,          CONFIG_SYS_MAXARGS,     1, do_power,
2633         "Device Power Management control",
2634         "device on/off - Turn on/off the device\n"
2635 );
2636
2637 static int do_microusb(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
2638 {
2639         switch (argc) {
2640         case 2:
2641                 if (strncmp(argv[1], "cp", 2) == 0) {
2642                         micro_usb_switch(1);
2643                         pmic_ldo_control(0, 0, 2, 1);
2644                         return 0;
2645                 } else if (strncmp(argv[1], "ap", 2) == 0) {
2646                         micro_usb_switch(0);
2647                         pmic_ldo_control(0, 0, 2, 0);
2648                         return 0;
2649                 }
2650                 break;
2651         default:
2652                 break;
2653         }
2654
2655         cmd_usage(cmdtp);
2656         return 1;
2657 }
2658
2659 U_BOOT_CMD(
2660         microusb,               CONFIG_SYS_MAXARGS,     1, do_microusb,
2661         "Micro USB Switch",
2662         "cp - switch to CP\n"
2663         "microusb ap - switch to AP\n"
2664 );
2665 #endif