board/trab/trab.c

   1 /*
   2  * (C) Copyright 2002
   3  * Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /* #define DEBUG */
  25
  26 #include <common.h>
  27 #include <netdev.h>
  28 #include <malloc.h>
  29 #include <s3c2400.h>
  30 #include <command.h>
  31
  32 DECLARE_GLOBAL_DATA_PTR;
  33
  34 #ifdef CONFIG_SYS_BRIGHTNESS
  35 static void spi_init(void);
  36 static void wait_transmit_done(void);
  37 static void tsc2000_write(unsigned int page, unsigned int reg,
  38                                                   unsigned int data);
  39 static void tsc2000_set_brightness(void);
  40 #endif
  41 #ifdef CONFIG_MODEM_SUPPORT
  42 static int key_pressed(void);
  43 extern void disable_putc(void);
  44 extern int do_mdm_init; /* defined in common/main.c */
  45
  46 /*
  47  * We need a delay of at least 500 us after turning on the VFD clock
  48  * before we can read any useful information for the CPLD controlling
  49  * the keyboard switches. Let's play safe and wait 5 ms. The problem
  50  * is that timers are not available yet, so we use a manually timed
  51  * loop.
  52  */
  53 #define KBD_MDELAY      5000
  54 static void udelay_no_timer (int usec)
  55 {
  56         int i;
  57         int delay = usec * 3;
  58
  59         for (i = 0; i < delay; i ++) gd->bd->bi_arch_number = MACH_TYPE_TRAB;
  60 }
  61 #endif /* CONFIG_MODEM_SUPPORT */
  62
  63 /*
  64  * Miscellaneous platform dependent initialisations
  65  */
  66
  67 int board_init ()
  68 {
  69 #if defined(CONFIG_VFD)
  70         extern int vfd_init_clocks(void);
  71 #endif
  72         S3C24X0_CLOCK_POWER * const clk_power = S3C24X0_GetBase_CLOCK_POWER();
  73         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
  74
  75         /* memory and cpu-speed are setup before relocation */
  76 #ifdef CONFIG_TRAB_50MHZ
  77         /* change the clock to be 50 MHz 1:1:1 */
  78         /* MDIV:0x5c PDIV:4 SDIV:2 */
  79         clk_power->MPLLCON = 0x5c042;
  80         clk_power->CLKDIVN = 0;
  81 #else
  82         /* change the clock to be 133 MHz 1:2:4 */
  83         /* MDIV:0x7d PDIV:4 SDIV:1 */
  84         clk_power->MPLLCON = 0x7d041;
  85         clk_power->CLKDIVN = 3;
  86 #endif
  87
  88         /* set up the I/O ports */
  89         gpio->PACON = 0x3ffff;
  90         gpio->PBCON = 0xaaaaaaaa;
  91         gpio->PBUP  = 0xffff;
  92         /* INPUT nCTS0 nRTS0 TXD[1] TXD[0] RXD[1] RXD[0]        */
  93         /*  00,    10,      10,      10,      10,      10,      10      */
  94         gpio->PFCON = (2<<0) | (2<<2) | (2<<4) | (2<<6) | (2<<8) | (2<<10);
  95 #ifdef CONFIG_HWFLOW
  96         /* do not pull up RXD0, RXD1, TXD0, TXD1, CTS0, RTS0 */
  97         gpio->PFUP  = (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5);
  98 #else
  99         /* do not pull up RXD0, RXD1, TXD0, TXD1 */
 100         gpio->PFUP  = (1<<0) | (1<<1) | (1<<2) | (1<<3);
 101 #endif
 102         gpio->PGCON = 0x0;
 103         gpio->PGUP  = 0x0;
 104         gpio->OPENCR= 0x0;
 105
 106         /* suppress flicker of the VFDs */
 107         gpio->MISCCR = 0x40;
 108         gpio->PFCON |= (2<<12);
 109
 110         gd->bd->bi_arch_number = MACH_TYPE_TRAB;
 111
 112         /* adress of boot parameters */
 113         gd->bd->bi_boot_params = 0x0c000100;
 114
 115         /* Make sure both buzzers are turned off */
 116         gpio->PDCON |= 0x5400;
 117         gpio->PDDAT &= ~0xE0;
 118
 119 #ifdef CONFIG_VFD
 120         vfd_init_clocks();
 121 #endif /* CONFIG_VFD */
 122
 123 #ifdef CONFIG_MODEM_SUPPORT
 124         udelay_no_timer (KBD_MDELAY);
 125
 126         if (key_pressed()) {
 127                 disable_putc(); /* modem doesn't understand banner etc */
 128                 do_mdm_init = 1;
 129         }
 130 #endif  /* CONFIG_MODEM_SUPPORT */
 131
 132 #ifdef CONFIG_DRIVER_S3C24X0_I2C
 133         /* Configure I/O ports PG5 und PG6 for I2C */
 134         gpio->PGCON = (gpio->PGCON & 0x003c00) | 0x003c00;
 135 #endif /* CONFIG_DRIVER_S3C24X0_I2C */
 136
 137         return 0;
 138 }
 139
 140 int dram_init (void)
 141 {
 142         gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
 143         gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
 144         return 0;
 145 }
 146
 147 /*-----------------------------------------------------------------------
 148  * Keyboard Controller
 149  */
 150
 151 /* Maximum key number */
 152 #define KEYBD_KEY_NUM           4
 153
 154 #define KBD_DATA        (((*(volatile ulong *)0x04020000) >> 16) & 0xF)
 155
 156 static char *key_match (ulong);
 157
 158 int misc_init_r (void)
 159 {
 160         ulong kbd_data = KBD_DATA;
 161         char *str;
 162         char keybd_env[KEYBD_KEY_NUM + 1];
 163         int i;
 164
 165 #ifdef CONFIG_VERSION_VARIABLE
 166         {
 167                 /* Set version variable. Please note, that this variable is
 168                  * also set in main_loop() later in the boot process. The
 169                  * version variable has to be set this early, because so it
 170                  * could be used in script files on an usb stick, which
 171                  * might be called during do_auto_update() */
 172                 extern char version_string[];
 173
 174                 setenv ("ver", version_string);
 175         }
 176 #endif /* CONFIG_VERSION_VARIABLE */
 177
 178 #ifdef CONFIG_AUTO_UPDATE
 179         {
 180                 extern int do_auto_update(void);
 181                 /* this has priority over all else */
 182                 do_auto_update();
 183         }
 184 #endif
 185
 186         for (i = 0; i < KEYBD_KEY_NUM; ++i) {
 187                 keybd_env[i] = '0' + ((kbd_data >> i) & 1);
 188         }
 189         keybd_env[i] = '\0';
 190         debug ("** Setting keybd=\"%s\"\n", keybd_env);
 191         setenv ("keybd", keybd_env);
 192
 193         str = strdup (key_match (kbd_data));    /* decode keys */
 194
 195 #ifdef CONFIG_PREBOOT   /* automatically configure "preboot" command on key match */
 196         debug ("** Setting preboot=\"%s\"\n", str);
 197         setenv ("preboot", str);        /* set or delete definition */
 198 #endif /* CONFIG_PREBOOT */
 199         if (str != NULL) {
 200                 free (str);
 201         }
 202
 203 #ifdef CONFIG_SYS_BRIGHTNESS
 204         tsc2000_set_brightness();
 205 #endif
 206         return (0);
 207 }
 208
 209 #ifdef CONFIG_PREBOOT
 210
 211 static uchar kbd_magic_prefix[] = "key_magic";
 212 static uchar kbd_command_prefix[] = "key_cmd";
 213
 214 static int compare_magic (ulong kbd_data, char *str)
 215 {
 216         uchar key_mask;
 217
 218         debug ("compare_magic: kbd: %04lx  str: \"%s\"\n",kbd_data,str);
 219         for (; *str; str++)
 220         {
 221                 uchar c = *str - '1';
 222
 223                 if (c >= KEYBD_KEY_NUM)         /* bad key number */
 224                         return -1;
 225
 226                 key_mask = 1 << c;
 227
 228                 if (!(kbd_data & key_mask)) {   /* key not pressed */
 229                         debug ( "compare_magic: "
 230                                 "kbd: %04lx mask: %04lx - key not pressed\n",
 231                                 kbd_data, key_mask );
 232                         return -1;
 233                 }
 234
 235                 kbd_data &= ~key_mask;
 236         }
 237
 238         if (kbd_data) {                         /* key(s) not released */
 239                 debug ( "compare_magic: "
 240                         "kbd: %04lx - key(s) not released\n", kbd_data);
 241                 return -1;
 242         }
 243
 244         return 0;
 245 }
 246
 247 /*-----------------------------------------------------------------------
 248  * Check if pressed key(s) match magic sequence,
 249  * and return the command string associated with that key(s).
 250  *
 251  * If no key press was decoded, NULL is returned.
 252  *
 253  * Note: the first character of the argument will be overwritten with
 254  * the "magic charcter code" of the decoded key(s), or '\0'.
 255  *
 256  *
 257  * Note: the string points to static environment data and must be
 258  * saved before you call any function that modifies the environment.
 259  */
 260 static char *key_match (ulong kbd_data)
 261 {
 262         char magic[sizeof (kbd_magic_prefix) + 1];
 263         char cmd_name[sizeof (kbd_command_prefix) + 1];
 264         char *suffix;
 265         char *kbd_magic_keys;
 266
 267         /*
 268          * The following string defines the characters that can pe appended
 269          * to "key_magic" to form the names of environment variables that
 270          * hold "magic" key codes, i. e. such key codes that can cause
 271          * pre-boot actions. If the string is empty (""), then only
 272          * "key_magic" is checked (old behaviour); the string "125" causes
 273          * checks for "key_magic1", "key_magic2" and "key_magic5", etc.
 274          */
 275         if ((kbd_magic_keys = getenv ("magic_keys")) == NULL)
 276                 kbd_magic_keys = "";
 277
 278         debug ("key_match: magic_keys=\"%s\"\n", kbd_magic_keys);
 279
 280         /* loop over all magic keys;
 281          * use '\0' suffix in case of empty string
 282          */
 283         for (suffix=kbd_magic_keys; *suffix || suffix==kbd_magic_keys; ++suffix)
 284         {
 285                 sprintf (magic, "%s%c", kbd_magic_prefix, *suffix);
 286
 287                 debug ("key_match: magic=\"%s\"\n",
 288                         getenv(magic) ? getenv(magic) : "<UNDEFINED>");
 289
 290                 if (compare_magic(kbd_data, getenv(magic)) == 0)
 291                 {
 292                         sprintf (cmd_name, "%s%c", kbd_command_prefix, *suffix);
 293                         debug ("key_match: cmdname %s=\"%s\"\n",
 294                                 cmd_name,
 295                                 getenv (cmd_name) ?
 296                                         getenv (cmd_name) :
 297                                         "<UNDEFINED>");
 298                         return (getenv (cmd_name));
 299                 }
 300         }
 301         debug ("key_match: no match\n");
 302         return (NULL);
 303 }
 304 #endif                                                  /* CONFIG_PREBOOT */
 305
 306 /* Read Keyboard status */
 307 int do_kbd (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 308 {
 309         ulong kbd_data = KBD_DATA;
 310         char keybd_env[KEYBD_KEY_NUM + 1];
 311         int i;
 312
 313         puts ("Keys:");
 314         for (i = 0; i < KEYBD_KEY_NUM; ++i) {
 315                 keybd_env[i] = '0' + ((kbd_data >> i) & 1);
 316                 printf (" %c", keybd_env[i]);
 317         }
 318         keybd_env[i] = '\0';
 319         putc ('\n');
 320         setenv ("keybd", keybd_env);
 321         return 0;
 322 }
 323
 324 U_BOOT_CMD(
 325         kbd,    1,      1,      do_kbd,
 326         "read keyboard status",
 327         ""
 328 );
 329
 330 #ifdef CONFIG_MODEM_SUPPORT
 331 static int key_pressed(void)
 332 {
 333         return (compare_magic(KBD_DATA, CONFIG_MODEM_KEY_MAGIC) == 0);
 334 }
 335 #endif  /* CONFIG_MODEM_SUPPORT */
 336
 337 #ifdef CONFIG_SYS_BRIGHTNESS
 338
 339 static inline void SET_CS_TOUCH(void)
 340 {
 341         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
 342
 343         gpio->PDDAT &= 0x5FF;
 344 }
 345
 346 static inline void CLR_CS_TOUCH(void)
 347 {
 348         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
 349
 350         gpio->PDDAT |= 0x200;
 351 }
 352
 353 static void spi_init(void)
 354 {
 355         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
 356         S3C24X0_SPI * const spi = S3C24X0_GetBase_SPI();
 357         int i;
 358
 359         /* Configure I/O ports. */
 360         gpio->PDCON = (gpio->PDCON & 0xF3FFFF) | 0x040000;
 361         gpio->PGCON = (gpio->PGCON & 0x0F3FFF) | 0x008000;
 362         gpio->PGCON = (gpio->PGCON & 0x0CFFFF) | 0x020000;
 363         gpio->PGCON = (gpio->PGCON & 0x03FFFF) | 0x080000;
 364
 365         CLR_CS_TOUCH();
 366
 367         spi->ch[0].SPPRE = 0x1F; /* Baudrate ca. 514kHz */
 368         spi->ch[0].SPPIN = 0x01;  /* SPI-MOSI holds Level after last bit */
 369         spi->ch[0].SPCON = 0x1A;  /* Polling, Prescaler, Master, CPOL=0, CPHA=1 */
 370
 371         /* Dummy byte ensures clock to be low. */
 372         for (i = 0; i < 10; i++) {
 373                 spi->ch[0].SPTDAT = 0xFF;
 374         }
 375         wait_transmit_done();
 376 }
 377
 378 static void wait_transmit_done(void)
 379 {
 380         S3C24X0_SPI * const spi = S3C24X0_GetBase_SPI();
 381
 382         while (!(spi->ch[0].SPSTA & 0x01)); /* wait until transfer is done */
 383 }
 384
 385 static void tsc2000_write(unsigned int page, unsigned int reg,
 386                                                   unsigned int data)
 387 {
 388         S3C24X0_SPI * const spi = S3C24X0_GetBase_SPI();
 389         unsigned int command;
 390
 391         SET_CS_TOUCH();
 392         command = 0x0000;
 393         command |= (page << 11);
 394         command |= (reg << 5);
 395
 396         spi->ch[0].SPTDAT = (command & 0xFF00) >> 8;
 397         wait_transmit_done();
 398         spi->ch[0].SPTDAT = (command & 0x00FF);
 399         wait_transmit_done();
 400         spi->ch[0].SPTDAT = (data & 0xFF00) >> 8;
 401         wait_transmit_done();
 402         spi->ch[0].SPTDAT = (data & 0x00FF);
 403         wait_transmit_done();
 404
 405         CLR_CS_TOUCH();
 406 }
 407
 408 static void tsc2000_set_brightness(void)
 409 {
 410         char tmp[10];
 411         int i, br;
 412
 413         spi_init();
 414         tsc2000_write(1, 2, 0x0); /* Power up DAC */
 415
 416         i = getenv_r("brightness", tmp, sizeof(tmp));
 417         br = (i > 0)
 418                 ? (int) simple_strtoul (tmp, NULL, 10)
 419                 : CONFIG_SYS_BRIGHTNESS;
 420
 421         tsc2000_write(0, 0xb, br & 0xff);
 422 }
 423 #endif
 424
 425 #ifdef CONFIG_CMD_NET
 426 int board_eth_init(bd_t *bis)
 427 {
 428         int rc = 0;
 429 #ifdef CONFIG_CS8900
 430         rc = cs8900_initialize(0, CONFIG_CS8900_BASE);
 431 #endif
 432         return rc;
 433 }
 434 #endif