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 #define MAX8998_REG_ONOFF1      0x11
1174 #define MAX8998_REG_ONOFF2      0x12
1175 #define MAX8998_REG_ONOFF3      0x13
1176 #define MAX8998_LDO3            (1 << 2)
1177 #define MAX8998_LDO10           (1 << 3)
1178 #define MAX8998_LDO11           (1 << 2)
1179 #define MAX8998_LDO12           (1 << 1)
1180 #define MAX8998_LDO13           (1 << 0)
1181 #define MAX8998_LDO14           (1 << 7)
1182 #define MAX8998_LDO15           (1 << 6)
1183 #define MAX8998_LDO16           (1 << 5)
1184 #define MAX8998_LDO17           (1 << 4)
1185
1186 #ifdef ARIES
1187 #define MAX8998_REG_LDO7        0x21
1188 #define MAX8998_REG_LDO17       0x29
1189 #endif /* ARIES */
1190
1191 static void init_pmic(void)
1192 {
1193         unsigned char addr;
1194         unsigned char val[2];
1195 #ifdef ARIES
1196         unsigned char val2[2];
1197 #endif /* ARIES */
1198
1199         if (cpu_is_s5pc100())
1200                 return;
1201
1202         i2c_set_bus_num(I2C_PMIC);
1203
1204         addr = 0xCC >> 1;       /* max8998 */
1205         if (i2c_probe(addr)) {
1206                 printf("Can't found max8998\n");
1207                 return;
1208         }
1209
1210         /* ONOFF1 */
1211         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
1212         val[0] &= ~MAX8998_LDO3;
1213         i2c_write(addr, MAX8998_REG_ONOFF1, 1, val, 1);
1214
1215         /* ONOFF2 */
1216         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1217         /*
1218          * Disable LDO10(VPLL_1.1V), LDO11(CAM_IO_2.8V),
1219          * LDO12(CAM_ISP_1.2V), LDO13(CAM_A_2.8V)
1220          */
1221         val[0] &= ~(MAX8998_LDO10 | MAX8998_LDO11 |
1222                         MAX8998_LDO12 | MAX8998_LDO13);
1223 #ifndef ARIES
1224         val[0] |= (1 << 7);
1225 #else
1226         val[0] |= ((1 << 7)|(1 << 6));
1227         val2[0] = 0x2;
1228         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1229         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1230 #endif /* ARIES */
1231         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1232         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1233         /* ONOFF3 */
1234         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1235 #ifndef ARIES
1236         /*
1237          * Disable LDO14(CAM_CIF_1.8), LDO15(CAM_AF_3.3V),
1238          * LDO16(VMIPI_1.8V), LDO17(CAM_8M_1.8V)
1239          */
1240         val[0] &= ~(MAX8998_LDO14 | MAX8998_LDO15 |
1241                         MAX8998_LDO16 | MAX8998_LDO17);
1242 #else
1243
1244         /*
1245          * Disable LDO14(CAM_CIF_1.8), LDO15(CAM_AF_3.3V),
1246          * LDO16(VMIPI_1.8V), LDO17(CAM_8M_1.8V)
1247          */
1248         val[0] &= ~(MAX8998_LDO14 | MAX8998_LDO15 |
1249                         MAX8998_LDO16);
1250
1251         val[0] |= MAX8998_LDO17;
1252         val2[0] = 0xE;
1253         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1254         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1255 #endif /* ARIES */
1256         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1257         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1258 }
1259
1260 #define PDN_MASK(x)             (0x3 << ((x) << 1))
1261
1262 #define CON_INPUT(x)            (0x0 << ((x) << 2))
1263 #define CON_OUTPUT(x)           (0x1 << ((x) << 2))
1264 #define CON_IRQ(x)              (0xf << ((x) << 2))
1265
1266 #define DAT_SET(x)              (0x1 << (x))
1267 #define DAT_CLEAR(x)            (0x0 << (x))
1268
1269 #define OUTPUT0(x)              (0x0 << ((x) << 1))
1270 #define OUTPUT1(x)              (0x1 << ((x) << 1))
1271 #define INPUT(x)                (0x2 << ((x) << 1))
1272
1273 #define PULL_DIS(x)             (0x0 << ((x) << 1))
1274 #define PULL_DOWN(x)            (0x1 << ((x) << 1))
1275 #define PULL_UP(x)              (0x2 << ((x) << 1))
1276
1277 #define PREVIOUS(x)             (0x3 << ((x) << 1))
1278
1279 struct gpio_powermode {
1280         unsigned int    conpdn;
1281         unsigned int    pudpdn;
1282 };
1283
1284 struct gpio_external {
1285         unsigned int    con;
1286         unsigned int    dat;
1287         unsigned int    pud;
1288 };
1289
1290 static struct gpio_powermode powerdown_modes[] = {
1291         {       /* S5PC110_GPIO_A0_OFFSET */
1292                 INPUT(0) | OUTPUT0(1) | INPUT(2) | OUTPUT0(3) |
1293                 INPUT(4) | OUTPUT0(5) | INPUT(6) | OUTPUT0(7),
1294                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1295                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1296         }, {    /* S5PC110_GPIO_A1_OFFSET */
1297                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3),
1298                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1299         }, {    /* S5PC110_GPIO_B_OFFSET */
1300                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1301                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1302                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1303                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1304         }, {    /* S5PC110_GPIO_C0_OFFSET */
1305                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1306                 OUTPUT0(4),
1307                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1308                 PULL_DIS(4),
1309         }, {    /* S5PC110_GPIO_C1_OFFSET */
1310                 /* OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1311                 OUTPUT0(4), */
1312                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1313                 OUTPUT0(4),
1314                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1315                 PULL_DIS(4),
1316         }, {    /* S5PC110_GPIO_D0_OFFSET */
1317                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3),
1318                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1319         }, {    /* S5PC110_GPIO_D1_OFFSET */
1320                 INPUT(0) | INPUT(1) | INPUT(2) | INPUT(3) |
1321                 INPUT(4) | INPUT(5),
1322                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1323                 PULL_DIS(4) | PULL_DIS(5),
1324         }, {    /* S5PC110_GPIO_E0_OFFSET */
1325                 INPUT(0) | INPUT(1) | INPUT(2) | INPUT(3) |
1326                 INPUT(4) | INPUT(5) | INPUT(6) | INPUT(7),
1327                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DOWN(2) | PULL_DOWN(3) |
1328                 PULL_DOWN(4) | PULL_DOWN(5) | PULL_DOWN(6) | PULL_DOWN(7),
1329         }, {    /* S5PC110_GPIO_E1_OFFSET */
1330                 INPUT(0) | INPUT(1) | INPUT(2) | OUTPUT0(3) |
1331                 OUTPUT0(4),
1332                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DOWN(2) | PULL_DIS(3) |
1333                 PULL_DIS(4),
1334         }, {    /* S5PC110_GPIO_F0_OFFSET */
1335                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1336                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1337                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1338                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1339         }, {    /* S5PC110_GPIO_F1_OFFSET */
1340                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1341                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1342                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1343                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1344         }, {    /* S5PC110_GPIO_F2_OFFSET */
1345                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1346                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1347                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1348                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1349         }, {    /* S5PC110_GPIO_F3_OFFSET */
1350                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1351                 OUTPUT0(4) | OUTPUT0(5),
1352                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1353                 PULL_DIS(4) | PULL_DIS(5),
1354         }, {    /* S5PC110_GPIO_G0_OFFSET */
1355                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1356                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1357                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1358                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1359         }, {    /* S5PC110_GPIO_G1_OFFSET */
1360                 OUTPUT0(0) | INPUT(1) | OUTPUT0(2) | INPUT(3) |
1361                 INPUT(4) | INPUT(5) | INPUT(6),
1362                 PULL_DIS(0) | PULL_UP(1) | PULL_DIS(2) | PULL_UP(3) |
1363                 PULL_UP(4) | PULL_UP(5) | PULL_UP(6),
1364         }, {    /* S5PC110_GPIO_G2_OFFSET */
1365                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1366                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1367                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1368                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1369         }, {    /* S5PC110_GPIO_G3_OFFSET */
1370                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | INPUT(3) |
1371                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1372                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1373                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1374         }, {    /* S5PC110_GPIO_I_OFFSET */
1375                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1376                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6),
1377                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1378                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6),
1379         }, {    /* S5PC110_GPIO_J0_OFFSET */
1380                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3) |
1381                 INPUT(4) | INPUT(5) | OUTPUT0(6) | OUTPUT0(7),
1382                 PULL_DOWN(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1383                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1384         }, {    /* S5PC110_GPIO_J1_OFFSET */
1385                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1386                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1387                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1388                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1389         }, {    /* S5PC110_GPIO_J2_OFFSET */
1390                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1391                 INPUT(4) | OUTPUT0(5) | INPUT(6) | INPUT(7),
1392                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1393                 PULL_DIS(4) | PULL_DIS(5) | PULL_DOWN(6) | PULL_DOWN(7),
1394         }, {    /* S5PC110_GPIO_J3_OFFSET */
1395                 INPUT(0) | INPUT(1) | OUTPUT0(2) | OUTPUT0(3) |
1396                 OUTPUT1(4) | OUTPUT0(5) | INPUT(6) | INPUT(7),
1397                 PULL_DOWN(0) | PULL_DOWN(1) | PULL_DIS(2) | PULL_DIS(3) |
1398                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1399         }, {    /* S5PC110_GPIO_J4_OFFSET */
1400                 INPUT(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1401                 OUTPUT0(4),
1402                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1403                 PULL_DIS(4),
1404         }, {    /* S5PC110_MP0_1_OFFSET */
1405                 /* XM0CSN[4]: MP0_1[4] -> output high */
1406                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | OUTPUT0(3) |
1407                 OUTPUT1(4) | OUTPUT0(5) | OUTPUT1(6) | OUTPUT1(7),
1408                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1409                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1410         }, {    /* S5PC110_MP0_2_OFFSET */
1411                 OUTPUT0(0) | OUTPUT0(1) | INPUT(2) | OUTPUT0(3),
1412                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3),
1413         }, {    /* S5PC110_MP0_3_OFFSET */
1414                 /* XM0FWEN: MP0_3[2] -> output high */
1415                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT1(2) | OUTPUT0(3) |
1416                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1417                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1418                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1419         }, {    /* S5PC110_MP0_4_OFFSET */
1420                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | INPUT(3) |
1421                 INPUT(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1422                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DOWN(3) |
1423                 PULL_DOWN(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1424         }, {    /* S5PC110_MP0_5_OFFSET */
1425                 INPUT(0) | OUTPUT0(1) | INPUT(2) | INPUT(3) |
1426                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1427                 PULL_DOWN(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1428                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1429         }, {    /* S5PC110_MP0_6_OFFSET */
1430                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1431                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1432                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1433                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1434         }, {    /* S5PC110_MP0_7_OFFSET */
1435                 OUTPUT0(0) | OUTPUT0(1) | OUTPUT0(2) | OUTPUT0(3) |
1436                 OUTPUT0(4) | OUTPUT0(5) | OUTPUT0(6) | OUTPUT0(7),
1437                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1438                 PULL_DIS(4) | PULL_DIS(5) | PULL_DIS(6) | PULL_DIS(7),
1439         },
1440 };
1441
1442 static struct gpio_external external_powerdown_modes[] = {
1443         {       /* S5PC110_GPIO_H0_OFFSET */
1444                 CON_OUTPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_OUTPUT(3) |
1445                 CON_OUTPUT(4) | CON_OUTPUT(5) | CON_INPUT(6) | CON_INPUT(7),
1446                 DAT_SET(0) | DAT_CLEAR(2) | DAT_CLEAR(3) |
1447                 DAT_CLEAR(4) | DAT_CLEAR(5),
1448                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1449                 PULL_DIS(4) | PULL_DIS(5),
1450         }, {    /* S5PC110_GPIO_H1_OFFSET */
1451                 /* CON_INPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_IRQ(3) |
1452                 CON_IRQ(4) | CON_INPUT(5) | CON_INPUT(6) | CON_INPUT(7),
1453                 DAT_CLEAR(2),
1454                 PULL_DOWN(0) | PULL_DOWN(1) |
1455                 PULL_DOWN(6),           */
1456                 CON_INPUT(0) | CON_INPUT(1) | CON_OUTPUT(2) | CON_IRQ(3) |
1457                 CON_INPUT(4) | CON_INPUT(5) | CON_OUTPUT(6) | CON_INPUT(7),
1458                 DAT_SET(0),
1459                 PULL_DIS(0) | PULL_DIS(1) | PULL_DIS(2) | PULL_DIS(3) |
1460                 PULL_DOWN(4),
1461         }, {    /* S5PC110_GPIO_H2_OFFSET */
1462                 CON_OUTPUT(0) | CON_OUTPUT(1) | CON_OUTPUT(2) | CON_OUTPUT(3) |
1463                 CON_IRQ(4) | CON_IRQ(5) | CON_IRQ(6) | CON_IRQ(7),
1464                 DAT_CLEAR(0) | DAT_CLEAR(1) | DAT_CLEAR(2) | DAT_CLEAR(3),
1465                 0,
1466         }, {    /* S5PC110_GPIO_H3_OFFSET */
1467                 CON_IRQ(0) | CON_IRQ(1) | CON_IRQ(2) | CON_OUTPUT(3) |
1468                 CON_IRQ(4) | CON_INPUT(5) | CON_IRQ(6) | CON_OUTPUT(7),
1469                 DAT_CLEAR(3) | DAT_CLEAR(7),
1470                 0,
1471         },
1472 };
1473
1474 static void setup_power_down_mode_registers(void)
1475 {
1476         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *)S5PC110_GPIO_BASE;
1477         struct s5pc1xx_gpio_bank *bank;
1478         struct gpio_powermode *p;
1479         struct gpio_external *ge;
1480         int i;
1481
1482         if (cpu_is_s5pc100())
1483                 return;
1484
1485         if (!(machine_is_aquila() && board_is_limo_real()))
1486                 return;
1487
1488         bank = &gpio->gpio_a0;
1489         p = powerdown_modes;
1490
1491         for (i = 0; i < ARRAY_SIZE(powerdown_modes); i++, p++, bank++) {
1492                 writel(p->conpdn, &bank->pdn_con);
1493                 writel(p->pudpdn, &bank->pdn_pull);
1494         }
1495         /* M299 */
1496         writel(0xff0022b0, (unsigned int *)0xF0000000);
1497         writel(0xff0022b0, (unsigned int *)0xF1400000);
1498
1499
1500         bank = &gpio->gpio_h0;
1501         ge = external_powerdown_modes;
1502
1503         for (i = 0; i < ARRAY_SIZE(external_powerdown_modes); i++) {
1504                 writel(ge->con, &bank->con);
1505                 writel(ge->dat, &bank->dat);
1506                 writel(ge->pud, &bank->pull);
1507
1508                 bank++;
1509                 ge++;
1510         }
1511 }
1512
1513 #ifdef CONFIG_LCD
1514 struct s6e63m0_platform_data {
1515         struct s5pc1xx_gpio_bank *bank;
1516         unsigned int num;
1517 };
1518
1519 extern void s6e63m0_set_spi_interface(struct s6e63m0_platform_data *cs,
1520         struct s6e63m0_platform_data *clk, struct s6e63m0_platform_data *si,
1521         struct s6e63m0_platform_data *so);
1522
1523 struct s6e63m0_platform_data pd_cs, pd_clk, pd_si, pd_so;
1524 struct s5pc110_gpio *gpio_base = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1525
1526 void lcd_cfg_gpio(void)
1527 {
1528         unsigned int i, f3_end = 4;
1529
1530         for (i = 0; i < 8; i++) {
1531                 /* set GPF0,1,2[0:7] for RGB Interface and Data lines (32bit) */
1532                 gpio_cfg_pin(&gpio_base->gpio_f0, i, GPIO_FUNC(2));
1533                 gpio_cfg_pin(&gpio_base->gpio_f1, i, GPIO_FUNC(2));
1534                 gpio_cfg_pin(&gpio_base->gpio_f2, i, GPIO_FUNC(2));
1535                 /* pull-up/down disable */
1536                 gpio_set_pull(&gpio_base->gpio_f0, i, GPIO_PULL_NONE);
1537                 gpio_set_pull(&gpio_base->gpio_f1, i, GPIO_PULL_NONE);
1538                 gpio_set_pull(&gpio_base->gpio_f2, i, GPIO_PULL_NONE);
1539
1540                 /* drive strength to max (24bit) */
1541                 gpio_set_drv(&gpio_base->gpio_f0, i, GPIO_DRV_4x);
1542                 gpio_set_rate(&gpio_base->gpio_f0, i, GPIO_DRV_SLOW);
1543                 gpio_set_drv(&gpio_base->gpio_f1, i, GPIO_DRV_4x);
1544                 gpio_set_rate(&gpio_base->gpio_f1, i, GPIO_DRV_SLOW);
1545                 gpio_set_drv(&gpio_base->gpio_f2, i, GPIO_DRV_4x);
1546                 gpio_set_rate(&gpio_base->gpio_f2, i, GPIO_DRV_SLOW);
1547         }
1548
1549         /* set DISPLAY_DE_B pin for dual rgb mode. */
1550         if (board_is_media())
1551                 f3_end = 5;
1552
1553         for (i = 0; i < f3_end; i++) {
1554                 /* set GPF3[0:3] for RGB Interface and Data lines (32bit) */
1555                 gpio_cfg_pin(&gpio_base->gpio_f3, i, GPIO_PULL_UP);
1556                 /* pull-up/down disable */
1557                 gpio_set_pull(&gpio_base->gpio_f3, i, GPIO_PULL_NONE);
1558                 /* drive strength to max (24bit) */
1559                 gpio_set_drv(&gpio_base->gpio_f3, i, GPIO_DRV_4x);
1560                 gpio_set_rate(&gpio_base->gpio_f3, i, GPIO_DRV_SLOW);
1561         }
1562         /* display output path selection (only [1:0] valid) */
1563         writel(0x2, 0xE0107008);
1564
1565         /* gpio pad configuration for LCD reset. */
1566         gpio_cfg_pin(&gpio_base->gpio_mp0_5, 5, GPIO_OUTPUT);
1567
1568         /* gpio pad configuration for LCD ON. */
1569         gpio_cfg_pin(&gpio_base->gpio_j1, 3, GPIO_OUTPUT);
1570
1571         /* MLCD_ON2 */
1572         /*
1573         if (board_is_p2_real())
1574              gpio_cfg_pin(&gpio_base->gpio_j1, 4, GPIO_OUTPUT);
1575         */
1576
1577         /* LCD_BACKLIGHT_EN */
1578         if (machine_is_geminus())
1579                 gpio_cfg_pin(&gpio_base->gpio_mp0_5, 0, GPIO_OUTPUT);
1580
1581         /*
1582          * gpio pad configuration for
1583          * DISPLAY_CS, DISPLAY_CLK, DISPLAY_SO, DISPLAY_SI.
1584          */
1585         gpio_cfg_pin(&gpio_base->gpio_mp0_1, 1, GPIO_OUTPUT);
1586         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 1, GPIO_OUTPUT);
1587         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 2, GPIO_INPUT);
1588         gpio_cfg_pin(&gpio_base->gpio_mp0_4, 3, GPIO_OUTPUT);
1589
1590         if (machine_is_aquila()) {
1591                 pd_cs.bank = &gpio_base->gpio_mp0_1;
1592                 pd_cs.num = 1;
1593                 pd_clk.bank = &gpio_base->gpio_mp0_4;
1594                 pd_clk.num = 1;
1595                 pd_si.bank = &gpio_base->gpio_mp0_4;
1596                 pd_si.num = 3;
1597                 pd_so.bank = &gpio_base->gpio_mp0_4;
1598                 pd_so.num = 2;
1599
1600                 /* these data would be sent to s6e63m0 lcd panel driver. */
1601                 s6e63m0_set_spi_interface(&pd_cs, &pd_clk, &pd_si, &pd_so);
1602         }
1603
1604         if (machine_is_cypress()) {
1605 #if 0           /* universal cypress */
1606                 /* FLCD_CS */
1607                 gpio_cfg_pin(&gpio_base->gpio_mp0_1, 0, GPIO_OUTPUT);
1608 #endif
1609                 /* FLCD_CS_S */
1610                 gpio_cfg_pin(&gpio_base->gpio_mp0_5, 1, GPIO_OUTPUT);
1611                 /* FLCD_CLK */
1612                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 0, GPIO_OUTPUT);
1613                 /* FLCD_SDI */
1614                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 2, GPIO_OUTPUT);
1615                 /* FLCD_RST_S */
1616                 gpio_cfg_pin(&gpio_base->gpio_mp0_4, 5, GPIO_OUTPUT);
1617                 /* FLCD_ON_S */
1618                 gpio_cfg_pin(&gpio_base->gpio_g2, 2, GPIO_OUTPUT);
1619 #if 0           /* universal cypress */
1620                 pd_cs.bank = &gpio_base->gpio_mp0_1;
1621                 pd_cs.num = 0;
1622 #endif
1623                 pd_cs.bank = &gpio_base->gpio_mp0_5;
1624                 pd_cs.num = 1;
1625                 pd_clk.bank = &gpio_base->gpio_mp0_4;
1626                 pd_clk.num = 0;
1627                 pd_si.bank = &gpio_base->gpio_mp0_4;
1628                 pd_si.num = 2;
1629
1630                 /* these data would be sent to s6e63m0 lcd panel driver. */
1631                 s6e63m0_set_spi_interface(&pd_cs, &pd_clk, &pd_si, NULL);
1632         }
1633
1634         return;
1635 }
1636
1637 void backlight_on(unsigned int onoff)
1638 {
1639         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1640
1641         if (onoff) {
1642                 if (machine_is_geminus())
1643                         gpio_set_value(&gpio->gpio_mp0_5, 0, 1);
1644         } else {
1645                 if (machine_is_geminus())
1646                         gpio_set_value(&gpio->gpio_mp0_5, 0, 0);
1647         }
1648 }
1649
1650 void reset_lcd(void)
1651 {
1652         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1653
1654         if (machine_is_aquila() || machine_is_geminus())
1655                 gpio_set_value(&gpio->gpio_mp0_5, 5, 1);
1656         if (machine_is_cypress())
1657                 gpio_set_value(&gpio->gpio_mp0_4, 5, 1);
1658 }
1659
1660 void lcd_power_on(unsigned int onoff)
1661 {
1662         struct s5pc110_gpio *gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1663
1664         if (onoff) {
1665                 if (machine_is_aquila() || machine_is_geminus())
1666                         gpio_set_value(&gpio->gpio_j1, 3, 1);
1667
1668                 if (machine_is_cypress())
1669                         gpio_set_value(&gpio->gpio_g2, 2, 1);
1670
1671                 /*
1672                 if (board_is_p2_real())
1673                         gpio_set_value(&gpio->gpio_j1, 4, 1);
1674                 */
1675
1676 #ifdef ARIES
1677                 if (board_is_aries())
1678                 {
1679                         unsigned char addr;
1680                         unsigned char val[2];
1681                         unsigned char val2[2];
1682
1683                         i2c_set_bus_num(I2C_PMIC);
1684                         addr = 0xCC >> 1;       /* max8998 */
1685                         if (i2c_probe(addr)) {
1686                                 printf("Can't found max8998\n");
1687                                 return;
1688                         }
1689
1690                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1691                         val[0] |= (1 << 7);
1692                         val2[0] = 0x2;
1693                         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1694                         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1695                         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1696                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1697
1698                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1699                         val[0] |= MAX8998_LDO17;
1700                         val2[0] = 0xE;
1701                         i2c_write(addr, MAX8998_REG_LDO7, 1, val2, 1);
1702                         i2c_read(addr, MAX8998_REG_LDO7, 1, val2, 1);
1703                         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1704                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1705                 }
1706 #endif /* ARIES */
1707
1708
1709         } else {
1710                 if (machine_is_aquila() || machine_is_geminus())
1711                         gpio_set_value(&gpio->gpio_j1, 3, 0);
1712
1713                 if (machine_is_cypress())
1714                         gpio_set_value(&gpio->gpio_g2, 2, 0);
1715
1716                 /*
1717                 if (board_is_p2_real())
1718                      gpio_set_value(&gpio->gpio_j1, 4, 0);
1719                 */
1720
1721 #ifdef ARIES
1722                 if (board_is_aries())
1723                 {
1724                         unsigned char addr;
1725                         unsigned char val[2];
1726
1727                         i2c_set_bus_num(I2C_PMIC);
1728                         addr = 0xCC >> 1;       /* max8998 */
1729                         if (i2c_probe(addr)) {
1730                                 printf("Can't found max8998\n");
1731                                 return;
1732                         }
1733
1734                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1735                         val[0] &= ~(1 << 7);
1736                         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1737                         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
1738
1739                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1740                         val[0] &= ~MAX8998_LDO17;
1741                         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1742                         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
1743                 }
1744 #endif /* ARIES */
1745
1746         }
1747 }
1748
1749 extern void s6e63m0_cfg_ldo(void);
1750 extern void s6e63m0_enable_ldo(unsigned int onoff);
1751
1752 void init_panel_info(vidinfo_t *vid)
1753 {
1754         vid->cfg_gpio = NULL;
1755         vid->reset_lcd = NULL;
1756         vid->backlight_on = NULL;
1757         vid->lcd_power_on = NULL;
1758
1759         vid->cfg_ldo = NULL;
1760         vid->enable_ldo = NULL;
1761
1762         vid->init_delay = 0;
1763         vid->reset_delay = 0;
1764         vid->power_on_delay = 0;
1765
1766         vid->vl_freq    = 60;
1767         vid->vl_col     = 480;
1768         vid->vl_row     = 800;
1769         vid->vl_width   = 480;
1770         vid->vl_height  = 800;
1771
1772         vid->dual_lcd_enabled = 0;
1773
1774         if (board_is_media()) {
1775                 vid->vl_col     = 960;
1776                 vid->vl_row     = 800;
1777                 vid->vl_width   = 960;
1778                 vid->vl_height  = 800;
1779
1780                 /* enable dual lcd mode. */
1781                 vid->dual_lcd_enabled = 1;
1782         }
1783
1784         vid->vl_clkp    = CONFIG_SYS_HIGH;
1785         vid->vl_hsp     = CONFIG_SYS_LOW;
1786         vid->vl_vsp     = CONFIG_SYS_LOW;
1787         vid->vl_dp      = CONFIG_SYS_HIGH;
1788         vid->vl_bpix    = 32;
1789
1790         /* S6E63M0 LCD Panel */
1791         vid->vl_hspw    = 2;
1792         vid->vl_hbpd    = 16;
1793         vid->vl_hfpd    = 16;
1794
1795         vid->vl_vspw    = 2;
1796         vid->vl_vbpd    = 3;
1797         vid->vl_vfpd    = 28;
1798
1799         if (machine_is_aquila() || machine_is_cypress()) {
1800                 vid->cfg_gpio = lcd_cfg_gpio;
1801                 vid->reset_lcd = reset_lcd;
1802                 vid->backlight_on = backlight_on;
1803                 vid->lcd_power_on = lcd_power_on;
1804
1805                 vid->cfg_ldo = s6e63m0_cfg_ldo;
1806                 vid->enable_ldo = s6e63m0_enable_ldo;
1807
1808                 vid->init_delay = 25000;
1809                 vid->reset_delay = 120000;
1810         }
1811
1812         if (machine_is_geminus()) {
1813                 vid->vl_freq    = 60;
1814                 vid->vl_col     = 1024,
1815                 vid->vl_row     = 600,
1816                 vid->vl_width   = 1024,
1817                 vid->vl_height  = 600,
1818                 vid->vl_clkp    = CONFIG_SYS_LOW,
1819                 vid->vl_hsp     = CONFIG_SYS_HIGH,
1820                 vid->vl_vsp     = CONFIG_SYS_HIGH,
1821                 vid->vl_dp      = CONFIG_SYS_LOW,
1822                 vid->vl_bpix    = 32,
1823
1824                 vid->vl_hspw    = 32,
1825                 vid->vl_hfpd    = 48,
1826                 vid->vl_hbpd    = 80,
1827
1828                 vid->vl_vspw    = 1,
1829                 vid->vl_vfpd    = 3,
1830                 vid->vl_vbpd    = 4,
1831
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 #if 0
1838         vid->vl_freq    = 60;
1839         vid->vl_col     = 480,
1840         vid->vl_row     = 800,
1841         vid->vl_width   = 480,
1842         vid->vl_height  = 800,
1843         vid->vl_clkp    = CONFIG_SYS_HIGH,
1844         vid->vl_hsp     = CONFIG_SYS_LOW,
1845         vid->vl_vsp     = CONFIG_SYS_LOW,
1846         vid->vl_dp      = CONFIG_SYS_HIGH,
1847         vid->vl_bpix    = 32,
1848
1849         /* tl2796 panel. */
1850         vid->vl_hpw     = 4,
1851         vid->vl_blw     = 8,
1852         vid->vl_elw     = 8,
1853
1854         vid->vl_vpw     = 4,
1855         vid->vl_bfw     = 8,
1856         vid->vl_efw     = 8,
1857 #endif
1858 #if 0
1859         vid->vl_freq    = 60;
1860         vid->vl_col     = 1024,
1861         vid->vl_row     = 600,
1862         vid->vl_width   = 1024,
1863         vid->vl_height  = 600,
1864         vid->vl_clkp    = CONFIG_SYS_HIGH,
1865         vid->vl_hsp     = CONFIG_SYS_HIGH,
1866         vid->vl_vsp     = CONFIG_SYS_HIGH,
1867         vid->vl_dp      = CONFIG_SYS_LOW,
1868         vid->vl_bpix    = 32,
1869
1870         /* AMS701KA AMOLED Panel. */
1871         vid->vl_hpw     = 30,
1872         vid->vl_blw     = 114,
1873         vid->vl_elw     = 48,
1874
1875         vid->vl_vpw     = 2,
1876         vid->vl_bfw     = 6,
1877         vid->vl_efw     = 8,
1878 #endif
1879 }
1880 #endif
1881
1882 static void setup_meminfo(void)
1883 {
1884         char meminfo[64] = {0, };
1885         int count = 0, size, real;
1886
1887         size = gd->bd->bi_dram[0].size >> 20;
1888         count += sprintf(meminfo + count, "mem=%dM", size);
1889
1890         /* Each Chip Select can't exceed the 256MiB */
1891         size = gd->bd->bi_dram[1].size >> 20;
1892         real = min(size, 256);
1893         count += sprintf(meminfo + count, " mem=%dM@0x%x",
1894                 real, (unsigned int)gd->bd->bi_dram[1].start);
1895
1896         size -= real;
1897         if (size > 0) {
1898                 count += sprintf(meminfo + count, " mem=%dM@0x%x", size,
1899                         (unsigned int)gd->bd->bi_dram[1].start + (real << 20));
1900         }
1901
1902         setenv("meminfo", meminfo);
1903 }
1904
1905 int misc_init_r(void)
1906 {
1907 #ifdef CONFIG_LCD
1908         /* It should be located at first */
1909         lcd_is_enabled = 0;
1910
1911         if (board_is_limo_real() ||
1912                 board_is_limo_universal() ||
1913                 board_is_j1b2())
1914                 setenv("lcdinfo", "lcd=s6e63m0");
1915         /* it can't classify tl2796 with single-lcd and dual-lcd.
1916         else
1917                 setenv("lcdinfo", "lcd=tl2796-dual");
1918         */
1919
1920         /*
1921          * env values below should be added in case that lcd panel of geminus,
1922          * p1 and p2 are enabled at u-boot.
1923          * setenv means that lcd panel has been turned on at u-boot.
1924          */
1925         if (machine_is_geminus())
1926                 setenv("lcdinfo", "lcd=lms480jc01");
1927         if (board_is_media())
1928                 setenv("lcdinfo", "lcd=media");
1929         /*
1930         if (board_is_p2_real())
1931                 setenv("lcdinfo", "lcd=ams701");
1932         */
1933 #endif
1934         setup_meminfo();
1935
1936         show_hw_revision();
1937
1938         /* Set proper PMIC pins */
1939         pmic_pin_init();
1940
1941         /* Check auto burning */
1942         check_auto_burn();
1943
1944         /* To power up I2C2 */
1945         enable_ldos();
1946
1947         /* Enable T-Flash at Limo Real or Limo Universal */
1948         enable_t_flash();
1949
1950         /* Setup Limo Real board GPIOs */
1951         setup_limo_real_gpios();
1952
1953         /* Setup Media board GPIOs */
1954         setup_media_gpios();
1955
1956         /* Setup P1P2 board GPIOS */
1957         setup_p1p2_gpios();
1958
1959         /* To usbdown automatically */
1960         if (board_is_p2_real())
1961                 check_p2_keypad();
1962         else
1963                 check_keypad();
1964
1965         /* check max8998 */
1966         init_pmic();
1967
1968 #ifdef CONFIG_S5PC1XXFB
1969         display_device_info();
1970 #endif
1971
1972         setup_power_down_mode_registers();
1973
1974         /* check max17040 */
1975         check_battery();
1976
1977         /* check fsa9480 */
1978         check_micro_usb(0);
1979
1980         return 0;
1981 }
1982 #endif
1983
1984 int board_init(void)
1985 {
1986         /* Set Initial global variables */
1987         s5pc110_gpio = (struct s5pc110_gpio *) S5PC110_GPIO_BASE;
1988
1989         gd->bd->bi_arch_number = MACH_TYPE;
1990         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
1991
1992         /* Check H/W Revision */
1993         check_hw_revision();
1994
1995         return 0;
1996 }
1997
1998 int dram_init(void)
1999 {
2000         unsigned int base, memconfig0, size;
2001         unsigned int memconfig1, sz = 0;
2002
2003         if (cpu_is_s5pc100()) {
2004                 /* In mem setup, we swap the bank. So below size is correct */
2005                 gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
2006                 gd->bd->bi_dram[0].size = PHYS_SDRAM_2_SIZE;
2007                 gd->bd->bi_dram[1].start = S5PC100_PHYS_SDRAM_2;
2008                 size = 128;
2009         } else {
2010                 /* In S5PC110, we can't swap the DMC0/1 */
2011                 gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
2012                 gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
2013
2014                 base = S5PC110_DMC1_BASE;
2015                 /* DMC configuration */
2016                 memconfig0 = readl(base + MEMCONFIG0_OFFSET);
2017                 gd->bd->bi_dram[1].start = memconfig0 & 0xFF000000;
2018
2019                 size = (memconfig0 >> 16) & 0xFF;
2020                 size = ((unsigned char) ~size) + 1;
2021
2022                 /*
2023                  * (0x07 + 1) * 16 = 128 MiB
2024                  * (0x0f + 1) * 16 = 256 MiB
2025                  */
2026                 size = size << 4;
2027
2028                 /*
2029                  * Aquila Rev0.5 4G3G1G
2030                  * Aquila Rev0.8 4G3G1G
2031                  */
2032                 if (machine_is_aquila() && (hwrevision(5) || hwrevision(8))) {
2033                         memconfig1 = readl(base + MEMCONFIG1_OFFSET);
2034
2035                         sz = (memconfig1 >> 16) & 0xFF;
2036                         sz = ((unsigned char) ~sz) + 1;
2037                         sz = sz << 4;
2038                 }
2039
2040         }
2041         /*
2042          * bi_dram[1].size contains all DMC1 memory size
2043          */
2044         gd->bd->bi_dram[1].size = (size + sz) << 20;
2045
2046         return 0;
2047 }
2048
2049 /* Used for sleep test */
2050 static unsigned char saved_val[4][2];
2051 void board_sleep_init_late(void)
2052 {
2053         /* CODEC_LDO_EN: GPF3[4] */
2054         gpio_direction_output(&s5pc110_gpio->gpio_f3, 4, 0);
2055         /* CODEC_XTAL_EN: GPH3[2] */
2056         gpio_direction_output(&s5pc110_gpio->gpio_h3, 2, 0);
2057
2058         /* MMC T_FLASH off */
2059         gpio_direction_output(&s5pc110_gpio->gpio_mp0_5, 4, 0);
2060         /* MHL off */
2061         gpio_direction_output(&s5pc110_gpio->gpio_j2, 2, 0);
2062         gpio_direction_output(&s5pc110_gpio->gpio_mp0_4, 7, 0);
2063         gpio_direction_output(&s5pc110_gpio->gpio_j2, 3, 0); /* MHL_ON for REV02 or higher */
2064
2065
2066 }
2067 void board_sleep_init(void)
2068 {
2069         unsigned char addr;
2070         unsigned char val[2];
2071
2072         i2c_set_bus_num(I2C_PMIC);
2073         addr = 0xCC >> 1;
2074         if (i2c_probe(addr)) {
2075                 printf("Can't find max8998\n");
2076                 return;
2077         }
2078
2079         /* Set ONOFF1 */
2080         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2081         saved_val[0][0] = val[0];
2082         saved_val[0][1] = val[1];
2083         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 4) | (1 << 2) |
2084                         (1 << 1) | (1 << 0));
2085         i2c_write(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2086         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2087         /* Set ONOFF2 */
2088         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2089         saved_val[1][0] = val[0];
2090         saved_val[1][1] = val[1];
2091         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 3) |
2092                         (1 << 2) | (1 << 1) | (1 << 0));
2093         val[0] |= (1 << 7);
2094         i2c_write(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2095         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2096         /* Set ONOFF3 */
2097         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2098         saved_val[2][0] = val[0];
2099         saved_val[2][1] = val[1];
2100         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 4));
2101         i2c_write(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2102         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2103         /* Set ONOFF4 */
2104         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2105         saved_val[3][0] = val[0];
2106         saved_val[3][1] = val[1];
2107         val[0] &= ~((1 << 7) | (1 << 6) | (1 << 4));
2108         i2c_write(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2109         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2110         printf("Turned off regulators. Preparing to sleep. [%s:%d]\n",
2111                         __FILE__, __LINE__);
2112 }
2113
2114 void board_sleep_resume(void)
2115 {
2116         unsigned char addr;
2117         unsigned char val[2];
2118
2119         show_hw_revision();
2120
2121         i2c_set_bus_num(I2C_PMIC);
2122         addr = 0xCC >> 1;
2123         if (i2c_probe(addr)) {
2124                 printf("Can't find max8998\n");
2125                 return;
2126         }
2127
2128         /* Set ONOFF1 */
2129         i2c_write(addr, MAX8998_REG_ONOFF1, 1, saved_val[0], 1);
2130         i2c_read(addr, MAX8998_REG_ONOFF1, 1, val, 1);
2131         /* Set ONOFF2 */
2132         i2c_write(addr, MAX8998_REG_ONOFF2, 1, saved_val[1], 1);
2133         i2c_read(addr, MAX8998_REG_ONOFF2, 1, val, 1);
2134         /* Set ONOFF3 */
2135         i2c_write(addr, MAX8998_REG_ONOFF3, 1, saved_val[2], 1);
2136         i2c_read(addr, MAX8998_REG_ONOFF3, 1, val, 1);
2137         /* Set ONOFF4 */
2138         i2c_write(addr, MAX8998_REG_ONOFF3+1, 1, saved_val[3], 1);
2139         i2c_read(addr, MAX8998_REG_ONOFF3+1, 1, val, 1);
2140         printf("Waked up.\n");
2141
2142         /* check max17040 */
2143         check_battery();
2144
2145         /* check fsa9480 */
2146         check_micro_usb(1);
2147 }
2148
2149 #ifdef CONFIG_CMD_USBDOWN
2150 int usb_board_init(void)
2151 {
2152 #ifdef CONFIG_CMD_PMIC
2153         run_command("pmic ldo 3 on", 0);
2154 #endif
2155
2156         if (cpu_is_s5pc100()) {
2157 #ifdef CONFIG_HARD_I2C
2158                 uchar val[2] = {0,};
2159
2160                 /* PMIC */
2161                 if (i2c_read(0x66, 0, 1, val, 2)) {
2162                         printf("i2c_read error\n");
2163                         return 1;
2164                 }
2165
2166                 val[0] |= (1 << 3);
2167                 val[1] |= (1 << 5);
2168
2169                 if (i2c_write(0x66, 0, 1, val, 2)) {
2170                         printf("i2c_write error\n");
2171                         return 1;
2172                 }
2173                 i2c_read(0x66, 0, 1, val, 2);
2174 #endif
2175                 return 0;
2176         }
2177
2178         /* S5PC110 */
2179         if (board_is_limo_universal() ||
2180                 board_is_limo_real() ||
2181                 board_is_media()) {
2182                 /* check usb path */
2183                 if (board_is_limo_real() && !hwrevision(6))
2184                         check_mhl();
2185         }
2186
2187         if (machine_is_tickertape())
2188                 /* USB_SEL: XM0ADDR_0: MP04[0] output mode */
2189                 gpio_direction_output(&s5pc110_gpio->gpio_mp0_4, 0, 0);
2190
2191         return 0;
2192 }
2193 #endif
2194
2195 #ifdef CONFIG_GENERIC_MMC
2196 int board_mmc_init(bd_t *bis)
2197 {
2198         unsigned int reg;
2199         unsigned int clock;
2200         struct s5pc110_clock *clk = (struct s5pc110_clock *)S5PC1XX_CLOCK_BASE;
2201         int i;
2202
2203         /* MMC0 Clock source = SCLKMPLL */
2204         reg = readl(&clk->src4);
2205         reg &= ~0xf;
2206         reg |= 0x6;
2207         writel(reg, &clk->src4);
2208
2209         reg = readl(&clk->div4);
2210         reg &= ~0xf;
2211
2212         /* set div value near 50MHz */
2213         clock = get_pll_clk(MPLL) / 1000000;
2214         for (i = 0; i < 0xf; i++) {
2215                 if ((clock / (i + 1)) <= 50) {
2216                         reg |= i << 0;
2217                         break;
2218                 }
2219         }
2220
2221         writel(reg, &clk->div4);
2222
2223         /*
2224          * MMC0 GPIO
2225          * GPG0[0]      SD_0_CLK
2226          * GPG0[1]      SD_0_CMD
2227          * GPG0[2]      SD_0_CDn        -> Not used
2228          * GPG0[3:6]    SD_0_DATA[0:3]
2229          */
2230         for (i = 0; i < 7; i++) {
2231                 if (i == 2)
2232                         continue;
2233                 /* GPG0[0:6] special function 2 */
2234                 gpio_cfg_pin(&s5pc110_gpio->gpio_g0, i, 0x2);
2235                 /* GPG0[0:6] pull disable */
2236                 gpio_set_pull(&s5pc110_gpio->gpio_g0, i, GPIO_PULL_NONE);
2237                 /* GPG0[0:6] drv 4x */
2238                 gpio_set_drv(&s5pc110_gpio->gpio_g0, i, GPIO_DRV_4x);
2239         }
2240
2241         return s5pc1xx_mmc_init(0);
2242 }
2243 #endif
2244
2245 #ifdef CONFIG_CMD_PMIC
2246 static int pmic_status(void)
2247 {
2248         unsigned char addr, val[2];
2249         int reg, i;
2250
2251         i2c_set_bus_num(I2C_PMIC);
2252         addr = 0xCC >> 1;
2253         if (i2c_probe(addr)) {
2254                 printf("Can't found max8998\n");
2255                 return -1;
2256         }
2257
2258         reg = 0x11;
2259         i2c_read(addr, reg, 1, val, 1);
2260         for (i = 7; i >= 4; i--)
2261                 printf("BUCK%d %s\n", 7 - i + 1,
2262                         val[0] & (1 << i) ? "on" : "off");
2263         for (; i >= 0; i--)
2264                 printf("LDO%d %s\n", 5 - i,
2265                         val[0] & (1 << i) ? "on" : "off");
2266         reg = 0x12;
2267         i2c_read(addr, reg, 1, val, 1);
2268         for (i = 7; i >= 0; i--)
2269                 printf("LDO%d %s\n", 7 - i + 6,
2270                         val[0] & (1 << i) ? "on" : "off");
2271         reg = 0x13;
2272         i2c_read(addr, reg, 1, val, 1);
2273         for (i = 7; i >= 4; i--)
2274                 printf("LDO%d %s\n", 7 - i + 14,
2275                         val[0] & (1 << i) ? "on" : "off");
2276         return 0;
2277 }
2278
2279 static int pmic_ldo_control(int buck, int ldo, int on)
2280 {
2281         unsigned char addr, val[2];
2282         unsigned int reg, shift;
2283
2284         if (ldo) {
2285                 if (ldo < 2)
2286                         return -1;
2287                 if (ldo <= 5) {
2288                         reg = 0x11;
2289                         shift = 5 - ldo;
2290                 } else if (ldo <= 13) {
2291                         reg = 0x12;
2292                         shift = 13 - ldo;
2293                 } else if (ldo <= 17) {
2294                         reg = 0x13;
2295                         shift = 17 - ldo + 4;
2296                 } else
2297                         return -1;
2298         } else if (buck) {
2299                 if (buck > 4)
2300                         return -1;
2301                 reg = 0x11;
2302                 shift = 4 - buck + 4;
2303         } else
2304                 return -1;
2305
2306         i2c_set_bus_num(I2C_PMIC);
2307         addr = 0xCC >> 1;
2308         if (i2c_probe(addr)) {
2309                 printf("Can't found max8998\n");
2310                 return -1;
2311         }
2312
2313         i2c_read(addr, reg, 1, val, 1);
2314         if (on)
2315                 val[0] |= (1 << shift);
2316         else
2317                 val[0] &= ~(1 << shift);
2318         i2c_write(addr, reg, 1, val, 1);
2319         i2c_read(addr, reg, 1, val, 1);
2320         printf("%s %d value 0x%x, %s\n", buck ? "buck" : "ldo", buck ? : ldo,
2321                 val[0], val[0] & (1 << shift) ? "on" : "off");
2322
2323         return 0;
2324 }
2325
2326 static int do_pmic(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
2327 {
2328         int buck = 0, ldo = 0, on = -1;
2329
2330         switch (argc) {
2331         case 2:
2332                 if (strncmp(argv[1], "status", 6) == 0)
2333                         return pmic_status();
2334                 break;
2335         case 4:
2336                 if (strncmp(argv[1], "ldo", 3) == 0) {
2337                         ldo = simple_strtoul(argv[2], NULL, 10);
2338                         if (strncmp(argv[3], "on", 2) == 0)
2339                                 on = 1;
2340                         else if (strncmp(argv[3], "off", 3) == 0)
2341                                 on = 0;
2342                         else
2343                                 break;
2344                         return pmic_ldo_control(buck, ldo, on);
2345                 }
2346                 if (strncmp(argv[1], "buck", 4) == 0) {
2347                         buck = simple_strtoul(argv[2], NULL, 10);
2348                         if (strncmp(argv[3], "on", 2) == 0)
2349                                 on = 1;
2350                         else if (strncmp(argv[3], "off", 3) == 0)
2351                                 on = 0;
2352                         else
2353                                 break;
2354                         return pmic_ldo_control(buck, ldo, on);
2355                 }
2356
2357         default:
2358                 break;
2359         }
2360
2361         cmd_usage(cmdtp);
2362         return 1;
2363 }
2364
2365 U_BOOT_CMD(
2366         pmic,           CONFIG_SYS_MAXARGS,     1, do_pmic,
2367         "PMIC LDO & BUCK control",
2368         "status - Display PMIC LDO & BUCK status\n"
2369         "pmic ldo num on/off - Turn on/off the LDO\n"
2370         "pmic buck num on/off - Turn on/off the BUCK\n"
2371 );
2372 #endif
2373
2374 #ifdef CONFIG_CMD_DEVICE_POWER
2375
2376 enum {
2377         POWER_NONE,
2378         POWER_TOUCH,
2379         POWER_3_TOUCHKEY,
2380         POWER_LCD,
2381         POWER_HAPTIC,
2382         POWER_AUDIO_CODEC,
2383         POWER_FM_RADIO,
2384         POWER_BT_WIFI,
2385         POWER_HDMI,
2386 };
2387
2388 static void power_display_devices(void)
2389 {
2390         printf("devices:\n");
2391         printf("\t%d - touch\n", POWER_TOUCH);
2392         printf("\t%d - 3 touchkey\n", POWER_3_TOUCHKEY);
2393         printf("\t%d - LCD\n", POWER_LCD);
2394         printf("\t%d - Haptic\n", POWER_HAPTIC);
2395         printf("\t%d - Audio Codec\n", POWER_AUDIO_CODEC);
2396         printf("\t%d - FM Radio\n", POWER_FM_RADIO);
2397         printf("\t%d - BT/WiFi\n", POWER_BT_WIFI);
2398         printf("\t%d - HDMI\n", POWER_HDMI);
2399 }
2400
2401 static int power_hdmi(int on)
2402 {
2403         /* HDMI_EN1: GPJ2[2] */
2404         gpio_direction_output(&s5pc110_gpio->gpio_j2, 2, on);
2405         /* MHL_ON: GPJ2[3] */
2406         gpio_direction_output(&s5pc110_gpio->gpio_j2, 3, on);
2407         return 0;
2408 }
2409
2410 static int power_bt_wifi(int on)
2411 {
2412         /* WLAN_BT_EN: GPB[5] */
2413         gpio_direction_output(&s5pc110_gpio->gpio_b, 5, on);
2414         return 0;
2415 }
2416
2417 static int power_fm_radio(int on)
2418 {
2419         /* FM_BUS_nRST: GPJ2[5] */
2420         gpio_direction_output(&s5pc110_gpio->gpio_j2, 5, !on);
2421         return 0;
2422 }
2423
2424 static int power_audio_codec(int on)
2425 {
2426         /* CODEC_LDO_EN: GPF3[4] */
2427         gpio_direction_output(&s5pc110_gpio->gpio_f3, 4, on);
2428         /* CODEC_XTAL_EN: GPH3[2] */
2429         gpio_direction_output(&s5pc110_gpio->gpio_h3, 2, on);
2430         return 0;
2431 }
2432
2433 static int power_haptic(int on)
2434 {
2435         /* HAPTIC_ON: GPJ1[1] */
2436         gpio_direction_output(&s5pc110_gpio->gpio_j1, 1, on);
2437         return 0;
2438 }
2439
2440 static int power_lcd(int on)
2441 {
2442         /* MLCD_ON: GPJ1[3] */
2443         gpio_direction_output(&s5pc110_gpio->gpio_j1, 3, on);
2444         return 0;
2445 }
2446
2447 static int power_touch(int on)
2448 {
2449         /* TOUCH_EN: GPG3[6] */
2450         gpio_direction_output(&s5pc110_gpio->gpio_g3, 6, on);
2451         return 0;
2452 }
2453
2454 static int power_3_touchkey(int on)
2455 {
2456         if (on) {
2457                 /* 3_TOUCH_EN - GPJ3[0] : (J1B2) */
2458                 /* 3_TOUCH_EN - GPJ3[5] : (not J1B2) */
2459                 if (board_rev & J1_B2_BOARD)
2460                         gpio_direction_output(&s5pc110_gpio->gpio_j3, 0, on);
2461                 else
2462                         gpio_direction_output(&s5pc110_gpio->gpio_j3, 5, on);
2463
2464                 /* 3_TOUCH_CE - GPJ2[6] */
2465                 gpio_direction_output(&s5pc110_gpio->gpio_j2, 6, on);   /* TOUCH_CE */
2466         } else {
2467                 /* 3_TOUCH_CE - GPJ2[6] */
2468                 gpio_direction_output(&s5pc110_gpio->gpio_j2, 6, on);   /* TOUCH_CE */
2469         }
2470
2471         if (on) {
2472                 unsigned int reg;
2473                 unsigned char val[2];
2474                 unsigned char addr = 0x20;              /* mcs5000 3-touchkey */
2475
2476                 /* Require 100ms */
2477                 udelay(80 * 1000);
2478
2479                 /* 3 touchkey */
2480                 i2c_set_bus_num(I2C_GPIO6);
2481
2482                 /* Workaround to probe */
2483                 if (i2c_probe(addr)) {
2484                         if (i2c_probe(addr)) {
2485                                 printf("Can't found 3 touchkey\n");
2486                                 return -ENODEV;
2487                         }
2488                 }
2489
2490 #define MCS5000_TK_HW_VERSION  0x06
2491 #define MCS5000_TK_FW_VERSION  0x0A
2492 #define MCS5000_TK_MI_VERSION  0x0B
2493
2494                 reg = MCS5000_TK_MI_VERSION;
2495                 i2c_read(addr, reg, 1, val, 1);
2496                 printf("3-touchkey:\tM/I 0x%x, ", val[0]);
2497                 reg = MCS5000_TK_HW_VERSION;
2498                 i2c_read(addr, reg, 1, val, 1);
2499                 printf("H/W 0x%x, ", val[0]);
2500                 reg = MCS5000_TK_FW_VERSION;
2501                 i2c_read(addr, reg, 1, val, 1);
2502                 printf("F/W 0x%x\n", val[0]);
2503         }
2504         return 0;
2505 }
2506
2507 static int power_control(int device, int on)
2508 {
2509         switch (device) {
2510         case POWER_TOUCH:
2511                 return power_touch(on);
2512         case POWER_3_TOUCHKEY:
2513                 return power_3_touchkey(on);
2514         case POWER_LCD:
2515                 return power_lcd(on);
2516         case POWER_HAPTIC:
2517                 return power_haptic(on);
2518         case POWER_AUDIO_CODEC:
2519                 return power_audio_codec(on);
2520         case POWER_FM_RADIO:
2521                 return power_fm_radio(on);
2522         case POWER_BT_WIFI:
2523                 return power_bt_wifi(on);
2524         case POWER_HDMI:
2525                 return power_hdmi(on);
2526         default:
2527                 printf("I don't know device %d\n", device);
2528                 break;
2529         }
2530         return 0;
2531 }
2532
2533 static int power_on(int on)
2534 {
2535         power_touch(on);
2536         power_3_touchkey(on);
2537         power_lcd(on);
2538         power_haptic(on);
2539         power_audio_codec(on);
2540         power_fm_radio(on);
2541         power_bt_wifi(on);
2542         power_hdmi(on);
2543
2544         return 0;
2545 }
2546
2547 static int do_power(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
2548 {
2549         int device, on;
2550
2551         if (!machine_is_aquila())
2552                 goto out;
2553
2554         switch (argc) {
2555         case 2:
2556                 if (strncmp(argv[1], "on", 2) == 0)
2557                         return power_on(1);
2558                 if (strncmp(argv[1], "off", 3) == 0)
2559                         return power_on(0);
2560                 break;
2561         case 3:
2562                 device = simple_strtoul(argv[1], NULL, 10);
2563                 if (device < 0)
2564                         break;
2565
2566                 if (strncmp(argv[2], "on", 2) == 0)
2567                         on = 1;
2568                 else if (strncmp(argv[2], "off", 3) == 0)
2569                         on = 0;
2570                 else
2571                         break;
2572                 return power_control(device, on);
2573         default:
2574                 break;
2575         }
2576 out:
2577         cmd_usage(cmdtp);
2578         power_display_devices();
2579         return 1;
2580 }
2581
2582 U_BOOT_CMD(
2583         power,          CONFIG_SYS_MAXARGS,     1, do_power,
2584         "Device Power Management control",
2585         "device on/off - Turn on/off the device\n"
2586 );
2587 #endif