board/karo/tx48/tx48.c

   1 /*
   2  * tx48.c
   3  * Copyright (C) 2012 Lothar Waßmann <LW@KARO-electronics.de>
   4  *
   5  * based on evm.c
   6  * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
   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 version 2.
  11  *
  12  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  13  * kind, whether express or implied; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <common.h>
  19 #include <errno.h>
  20 #include <miiphy.h>
  21 #include <netdev.h>
  22 #include <serial.h>
  23 #include <libfdt.h>
  24 #include <lcd.h>
  25 #include <fdt_support.h>
  26 #include <nand.h>
  27 #include <net.h>
  28 #include <linux/mtd/nand.h>
  29 #include <asm/gpio.h>
  30 #include <asm/cache.h>
  31 #include <asm/omap_common.h>
  32 #include <asm/io.h>
  33 #include <asm/arch/cpu.h>
  34 #include <asm/arch/hardware.h>
  35 #include <asm/arch/mmc_host_def.h>
  36 #include <asm/arch/sys_proto.h>
  37 #include <asm/arch/nand.h>
  38 #include <asm/arch/clock.h>
  39 #include <video_fb.h>
  40 #include <asm/arch/da8xx-fb.h>
  41
  42 #include "../common/karo.h"
  43
  44 DECLARE_GLOBAL_DATA_PTR;
  45
  46 #define TX48_LED_GPIO           AM33XX_GPIO_NR(1, 26)
  47 #define TX48_ETH_PHY_RST_GPIO   AM33XX_GPIO_NR(3, 8)
  48 #define TX48_LCD_RST_GPIO       AM33XX_GPIO_NR(1, 19)
  49 #define TX48_LCD_PWR_GPIO       AM33XX_GPIO_NR(1, 22)
  50 #define TX48_LCD_BACKLIGHT_GPIO AM33XX_GPIO_NR(3, 14)
  51
  52 #define GMII_SEL                (CTRL_BASE + 0x650)
  53
  54 /* UART Defines */
  55 #define UART_SYSCFG_OFFSET      0x54
  56 #define UART_SYSSTS_OFFSET      0x58
  57
  58 #define UART_RESET              (0x1 << 1)
  59 #define UART_CLK_RUNNING_MASK   0x1
  60 #define UART_SMART_IDLE_EN      (0x1 << 0x3)
  61
  62 /* Timer Defines */
  63 #define TSICR_REG               0x54
  64 #define TIOCP_CFG_REG           0x10
  65 #define TCLR_REG                0x38
  66
  67 /* RGMII mode define */
  68 #define RGMII_MODE_ENABLE       0xA
  69 #define RMII_MODE_ENABLE        0x5
  70 #define MII_MODE_ENABLE         0x0
  71
  72 #define NO_OF_MAC_ADDR          1
  73 #define ETH_ALEN                6
  74
  75 #define MUX_CFG(value, offset)  {                                       \
  76         __raw_writel(value, (CTRL_BASE + (offset)));                    \
  77         }
  78
  79 /* PAD Control Fields */
  80 #define SLEWCTRL        (0x1 << 6)
  81 #define RXACTIVE        (0x1 << 5)
  82 #define PULLUP_EN       (0x1 << 4) /* Pull UP Selection */
  83 #define PULLUDEN        (0x0 << 3) /* Pull up enabled */
  84 #define PULLUDDIS       (0x1 << 3) /* Pull up disabled */
  85 #define MODE(val)       (val)
  86
  87 /*
  88  * PAD CONTROL OFFSETS
  89  * Field names corresponds to the pad signal name
  90  */
  91 struct pad_signals {
  92         int gpmc_ad0;
  93         int gpmc_ad1;
  94         int gpmc_ad2;
  95         int gpmc_ad3;
  96         int gpmc_ad4;
  97         int gpmc_ad5;
  98         int gpmc_ad6;
  99         int gpmc_ad7;
 100         int gpmc_ad8;
 101         int gpmc_ad9;
 102         int gpmc_ad10;
 103         int gpmc_ad11;
 104         int gpmc_ad12;
 105         int gpmc_ad13;
 106         int gpmc_ad14;
 107         int gpmc_ad15;
 108         int gpmc_a0;
 109         int gpmc_a1;
 110         int gpmc_a2;
 111         int gpmc_a3;
 112         int gpmc_a4;
 113         int gpmc_a5;
 114         int gpmc_a6;
 115         int gpmc_a7;
 116         int gpmc_a8;
 117         int gpmc_a9;
 118         int gpmc_a10;
 119         int gpmc_a11;
 120         int gpmc_wait0;
 121         int gpmc_wpn;
 122         int gpmc_be1n;
 123         int gpmc_csn0;
 124         int gpmc_csn1;
 125         int gpmc_csn2;
 126         int gpmc_csn3;
 127         int gpmc_clk;
 128         int gpmc_advn_ale;
 129         int gpmc_oen_ren;
 130         int gpmc_wen;
 131         int gpmc_be0n_cle;
 132         int lcd_data0;
 133         int lcd_data1;
 134         int lcd_data2;
 135         int lcd_data3;
 136         int lcd_data4;
 137         int lcd_data5;
 138         int lcd_data6;
 139         int lcd_data7;
 140         int lcd_data8;
 141         int lcd_data9;
 142         int lcd_data10;
 143         int lcd_data11;
 144         int lcd_data12;
 145         int lcd_data13;
 146         int lcd_data14;
 147         int lcd_data15;
 148         int lcd_vsync;
 149         int lcd_hsync;
 150         int lcd_pclk;
 151         int lcd_ac_bias_en;
 152         int mmc0_dat3;
 153         int mmc0_dat2;
 154         int mmc0_dat1;
 155         int mmc0_dat0;
 156         int mmc0_clk;
 157         int mmc0_cmd;
 158         int mii1_col;
 159         int mii1_crs;
 160         int mii1_rxerr;
 161         int mii1_txen;
 162         int mii1_rxdv;
 163         int mii1_txd3;
 164         int mii1_txd2;
 165         int mii1_txd1;
 166         int mii1_txd0;
 167         int mii1_txclk;
 168         int mii1_rxclk;
 169         int mii1_rxd3;
 170         int mii1_rxd2;
 171         int mii1_rxd1;
 172         int mii1_rxd0;
 173         int rmii1_refclk;
 174         int mdio_data;
 175         int mdio_clk;
 176         int spi0_sclk;
 177         int spi0_d0;
 178         int spi0_d1;
 179         int spi0_cs0;
 180         int spi0_cs1;
 181         int ecap0_in_pwm0_out;
 182         int uart0_ctsn;
 183         int uart0_rtsn;
 184         int uart0_rxd;
 185         int uart0_txd;
 186         int uart1_ctsn;
 187         int uart1_rtsn;
 188         int uart1_rxd;
 189         int uart1_txd;
 190         int i2c0_sda;
 191         int i2c0_scl;
 192         int mcasp0_aclkx;
 193         int mcasp0_fsx;
 194         int mcasp0_axr0;
 195         int mcasp0_ahclkr;
 196         int mcasp0_aclkr;
 197         int mcasp0_fsr;
 198         int mcasp0_axr1;
 199         int mcasp0_ahclkx;
 200         int xdma_event_intr0;
 201         int xdma_event_intr1;
 202         int nresetin_out;
 203         int porz;
 204         int nnmi;
 205         int osc0_in;
 206         int osc0_out;
 207         int rsvd1;
 208         int tms;
 209         int tdi;
 210         int tdo;
 211         int tck;
 212         int ntrst;
 213         int emu0;
 214         int emu1;
 215         int osc1_in;
 216         int osc1_out;
 217         int pmic_power_en;
 218         int rtc_porz;
 219         int rsvd2;
 220         int ext_wakeup;
 221         int enz_kaldo_1p8v;
 222         int usb0_dm;
 223         int usb0_dp;
 224         int usb0_ce;
 225         int usb0_id;
 226         int usb0_vbus;
 227         int usb0_drvvbus;
 228         int usb1_dm;
 229         int usb1_dp;
 230         int usb1_ce;
 231         int usb1_id;
 232         int usb1_vbus;
 233         int usb1_drvvbus;
 234         int ddr_resetn;
 235         int ddr_csn0;
 236         int ddr_cke;
 237         int ddr_ck;
 238         int ddr_nck;
 239         int ddr_casn;
 240         int ddr_rasn;
 241         int ddr_wen;
 242         int ddr_ba0;
 243         int ddr_ba1;
 244         int ddr_ba2;
 245         int ddr_a0;
 246         int ddr_a1;
 247         int ddr_a2;
 248         int ddr_a3;
 249         int ddr_a4;
 250         int ddr_a5;
 251         int ddr_a6;
 252         int ddr_a7;
 253         int ddr_a8;
 254         int ddr_a9;
 255         int ddr_a10;
 256         int ddr_a11;
 257         int ddr_a12;
 258         int ddr_a13;
 259         int ddr_a14;
 260         int ddr_a15;
 261         int ddr_odt;
 262         int ddr_d0;
 263         int ddr_d1;
 264         int ddr_d2;
 265         int ddr_d3;
 266         int ddr_d4;
 267         int ddr_d5;
 268         int ddr_d6;
 269         int ddr_d7;
 270         int ddr_d8;
 271         int ddr_d9;
 272         int ddr_d10;
 273         int ddr_d11;
 274         int ddr_d12;
 275         int ddr_d13;
 276         int ddr_d14;
 277         int ddr_d15;
 278         int ddr_dqm0;
 279         int ddr_dqm1;
 280         int ddr_dqs0;
 281         int ddr_dqsn0;
 282         int ddr_dqs1;
 283         int ddr_dqsn1;
 284         int ddr_vref;
 285         int ddr_vtp;
 286         int ddr_strben0;
 287         int ddr_strben1;
 288         int ain7;
 289         int ain6;
 290         int ain5;
 291         int ain4;
 292         int ain3;
 293         int ain2;
 294         int ain1;
 295         int ain0;
 296         int vrefp;
 297         int vrefn;
 298 };
 299
 300 struct pin_mux {
 301         short reg_offset;
 302         uint8_t val;
 303 };
 304
 305 #define PAD_CTRL_BASE   0x800
 306 #define OFFSET(x)       (unsigned int) (&((struct pad_signals *) \
 307                                 (PAD_CTRL_BASE))->x)
 308
 309 /*
 310  * Configure the pin mux for the module
 311  */
 312 static inline void tx48_set_pin_mux(const struct pin_mux *pin_mux,
 313                         int num_pins)
 314 {
 315         int i;
 316
 317         for (i = 0; i < num_pins; i++)
 318                 MUX_CFG(pin_mux[i].val, pin_mux[i].reg_offset);
 319 }
 320
 321 #define PRM_RSTST_GLOBAL_COLD_RST       (1 << 0)
 322 #define PRM_RSTST_GLOBAL_WARM_SW_RST    (1 << 1)
 323 #define PRM_RSTST_WDT1_RST              (1 << 4)
 324 #define PRM_RSTST_EXTERNAL_WARM_RST     (1 << 5)
 325 #define PRM_RSTST_ICEPICK_RST           (1 << 9)
 326
 327 static u32 prm_rstst __attribute__((section(".data")));
 328
 329 /*
 330  * Basic board specific setup
 331  */
 332 static const struct pin_mux tx48_pads[] = {
 333         { OFFSET(i2c0_sda), MODE(0) | RXACTIVE | PULLUDEN | PULLUP_EN, },
 334         { OFFSET(i2c0_scl), MODE(0) | RXACTIVE | PULLUDEN | PULLUP_EN, },
 335         { OFFSET(emu1), MODE(7), }, /* ETH PHY Reset */
 336 };
 337
 338 static const struct gpio tx48_gpios[] = {
 339         { AM33XX_GPIO_NR(3, 8), GPIOF_OUTPUT_INIT_LOW, "ETH_PHY_RESET", },
 340 };
 341
 342 static const struct pin_mux stk5_pads[] = {
 343         /* heartbeat LED */
 344         { OFFSET(gpmc_a10), MODE(7) | PULLUDEN, },
 345         /* LCD RESET */
 346         { OFFSET(gpmc_a3), MODE(7) | PULLUDEN, },
 347         /* LCD POWER_ENABLE */
 348         { OFFSET(gpmc_a6), MODE(7) | PULLUDEN, },
 349         /* LCD Backlight (PWM) */
 350         { OFFSET(mcasp0_aclkx), MODE(7) | PULLUDEN, },
 351 };
 352
 353 static const struct pin_mux stk5_lcd_pads[] = {
 354         /* LCD data bus */
 355         { OFFSET(lcd_data0), MODE(0) | PULLUDEN, },
 356         { OFFSET(lcd_data1), MODE(0) | PULLUDEN, },
 357         { OFFSET(lcd_data2), MODE(0) | PULLUDEN, },
 358         { OFFSET(lcd_data3), MODE(0) | PULLUDEN, },
 359         { OFFSET(lcd_data4), MODE(0) | PULLUDEN, },
 360         { OFFSET(lcd_data5), MODE(0) | PULLUDEN, },
 361         { OFFSET(lcd_data6), MODE(0) | PULLUDEN, },
 362         { OFFSET(lcd_data7), MODE(0) | PULLUDEN, },
 363         { OFFSET(lcd_data8), MODE(0) | PULLUDEN, },
 364         { OFFSET(lcd_data9), MODE(0) | PULLUDEN, },
 365         { OFFSET(lcd_data10), MODE(0) | PULLUDEN, },
 366         { OFFSET(lcd_data11), MODE(0) | PULLUDEN, },
 367         { OFFSET(lcd_data12), MODE(0) | PULLUDEN, },
 368         { OFFSET(lcd_data13), MODE(0) | PULLUDEN, },
 369         { OFFSET(lcd_data14), MODE(0) | PULLUDEN, },
 370         { OFFSET(lcd_data15), MODE(0) | PULLUDEN, },
 371         /* LCD control signals */
 372         { OFFSET(lcd_hsync), MODE(0) | PULLUDEN, },
 373         { OFFSET(lcd_vsync), MODE(0) | PULLUDEN, },
 374         { OFFSET(lcd_pclk), MODE(0) | PULLUDEN, },
 375         { OFFSET(lcd_ac_bias_en), MODE(0) | PULLUDEN, },
 376 };
 377
 378 static const struct gpio stk5_gpios[] = {
 379         { AM33XX_GPIO_NR(1, 26), GPIOF_OUTPUT_INIT_LOW, "HEARTBEAT LED", },
 380 };
 381
 382 static const struct gpio stk5_lcd_gpios[] = {
 383         { AM33XX_GPIO_NR(1, 19), GPIOF_OUTPUT_INIT_LOW, "LCD RESET", },
 384         { AM33XX_GPIO_NR(1, 22), GPIOF_OUTPUT_INIT_LOW, "LCD POWER", },
 385         { AM33XX_GPIO_NR(3, 14), GPIOF_OUTPUT_INIT_HIGH, "LCD BACKLIGHT", },
 386 };
 387
 388 static const struct pin_mux stk5v5_pads[] = {
 389         /* CAN transceiver control */
 390         { OFFSET(gpmc_ad8), MODE(7) | PULLUDEN, },
 391 };
 392
 393 static const struct gpio stk5v5_gpios[] = {
 394         { AM33XX_GPIO_NR(0, 22), GPIOF_OUTPUT_INIT_HIGH, "CAN XCVR", },
 395 };
 396
 397 #ifdef CONFIG_LCD
 398 static u16 tx48_cmap[256];
 399 vidinfo_t panel_info = {
 400         /* set to max. size supported by SoC */
 401         .vl_col = 1366,
 402         .vl_row = 768,
 403
 404         .vl_bpix = LCD_COLOR24,    /* Bits per pixel, 0: 1bpp, 1: 2bpp, 2: 4bpp, 3: 8bpp ... */
 405         .cmap = tx48_cmap,
 406 };
 407
 408 static struct da8xx_panel tx48_lcd_panel = {
 409         .name = "640x480MR@60",
 410         .width = 640,
 411         .height = 480,
 412         .hfp = 12,
 413         .hbp = 144,
 414         .hsw = 30,
 415         .vfp = 10,
 416         .vbp = 35,
 417         .vsw = 3,
 418         .pxl_clk = 25000000,
 419         .invert_pxl_clk = 1,
 420 };
 421
 422 void *lcd_base;                 /* Start of framebuffer memory  */
 423 void *lcd_console_address;      /* Start of console buffer      */
 424
 425 int lcd_line_length;
 426 int lcd_color_fg;
 427 int lcd_color_bg;
 428
 429 short console_col;
 430 short console_row;
 431
 432 static int lcd_enabled = 1;
 433
 434 void lcd_initcolregs(void)
 435 {
 436 }
 437
 438 void lcd_setcolreg(ushort regno, ushort red, ushort green, ushort blue)
 439 {
 440 }
 441
 442 void lcd_enable(void)
 443 {
 444         /* HACK ALERT:
 445          * global variable from common/lcd.c
 446          * Set to 0 here to prevent messages from going to LCD
 447          * rather than serial console
 448          */
 449         lcd_is_enabled = 0;
 450
 451         if (lcd_enabled) {
 452                 karo_load_splashimage(1);
 453
 454                 gpio_set_value(TX48_LCD_PWR_GPIO, 1);
 455                 gpio_set_value(TX48_LCD_RST_GPIO, 1);
 456                 udelay(300000);
 457                 gpio_set_value(TX48_LCD_BACKLIGHT_GPIO, 0);
 458         }
 459 }
 460
 461 void lcd_disable(void)
 462 {
 463         if (lcd_enabled) {
 464                 da8xx_fb_disable();
 465                 lcd_enabled = 0;
 466         }
 467 }
 468
 469 void lcd_panel_disable(void)
 470 {
 471         if (lcd_enabled) {
 472                 gpio_set_value(TX48_LCD_BACKLIGHT_GPIO, 1);
 473                 gpio_set_value(TX48_LCD_PWR_GPIO, 0);
 474                 gpio_set_value(TX48_LCD_RST_GPIO, 0);
 475         }
 476 }
 477
 478 void lcd_ctrl_init(void *lcdbase)
 479 {
 480         int color_depth = 24;
 481         char *vm, *v;
 482         unsigned long val;
 483         struct da8xx_panel *p = &tx48_lcd_panel;
 484         int refresh = 60;
 485
 486         if (!lcd_enabled) {
 487                 printf("LCD disabled\n");
 488                 return;
 489         }
 490
 491         if (tstc() || (prm_rstst & PRM_RSTST_WDT1_RST)) {
 492                 lcd_enabled = 0;
 493                 return;
 494         }
 495
 496         vm = getenv("video_mode");
 497         if (vm == NULL) {
 498                 lcd_enabled = 0;
 499                 return;
 500         }
 501
 502         if ((v = strstr(vm, ":")))
 503                 vm = v + 1;
 504
 505         strncpy((char *)p->name, vm, sizeof(p->name));
 506
 507         val = simple_strtoul(vm, &vm, 10);
 508         if (val != 0) {
 509                 if (val > panel_info.vl_col)
 510                         val = panel_info.vl_col;
 511                 p->width = val;
 512                 panel_info.vl_col = val;
 513         }
 514         if (*vm == 'x') {
 515                 val = simple_strtoul(vm + 1, &vm, 10);
 516                 if (val > panel_info.vl_row)
 517                         val = panel_info.vl_row;
 518                 p->height = val;
 519                 panel_info.vl_row = val;
 520         }
 521         while (*vm != '\0') {
 522                 switch (*vm) {
 523                 case 'M':
 524                 case 'R':
 525                         vm++;
 526                         break;
 527
 528                 case '-':
 529                         color_depth = simple_strtoul(vm + 1, &vm, 10);
 530                         break;
 531
 532                 case '@':
 533                         refresh = simple_strtoul(vm + 1, &vm, 10);
 534                         break;
 535
 536                 default:
 537                         debug("Ignoring '%c'\n", *vm);
 538                         vm++;
 539                 }
 540         }
 541         switch (color_depth) {
 542         case 8:
 543                 panel_info.vl_bpix = 3;
 544                 break;
 545
 546         case 16:
 547                 panel_info.vl_bpix = 4;
 548                 break;
 549
 550         case 24:
 551                 panel_info.vl_bpix = 5;
 552                 break;
 553
 554         default:
 555                 printf("Invalid color_depth %u from video_mode '%s'; using default: %u\n",
 556                         color_depth, getenv("video_mode"), 24);
 557         }
 558         lcd_line_length = NBITS(panel_info.vl_bpix) / 8 * panel_info.vl_col;
 559         p->pxl_clk = refresh *
 560                 (p->width + p->hfp + p->hbp + p->hsw) *
 561                 (p->height + p->vfp + p->vbp + p->vsw);
 562         debug("Pixel clock set to %u.%03uMHz\n",
 563                 p->pxl_clk / 1000000, p->pxl_clk / 1000 % 1000);
 564
 565         gpio_request_array(stk5_lcd_gpios, ARRAY_SIZE(stk5_lcd_gpios));
 566         tx48_set_pin_mux(stk5_lcd_pads, ARRAY_SIZE(stk5_lcd_pads));
 567         debug("Initializing FB driver\n");
 568         da8xx_video_init(&tx48_lcd_panel, color_depth);
 569
 570         if (karo_load_splashimage(0) == 0) {
 571                 debug("Initializing LCD controller\n");
 572                 video_hw_init();
 573         } else {
 574                 debug("Skipping initialization of LCD controller\n");
 575         }
 576 }
 577 #else
 578 #define lcd_enabled 0
 579 #endif /* CONFIG_LCD */
 580
 581 static void stk5_board_init(void)
 582 {
 583         tx48_set_pin_mux(stk5_pads, ARRAY_SIZE(stk5_pads));
 584 }
 585
 586 static void stk5v3_board_init(void)
 587 {
 588         stk5_board_init();
 589 }
 590
 591 static void stk5v5_board_init(void)
 592 {
 593         stk5_board_init();
 594         tx48_set_pin_mux(stk5v5_pads, ARRAY_SIZE(stk5v5_pads));
 595         gpio_request_array(stk5v5_gpios, ARRAY_SIZE(stk5v5_gpios));
 596 }
 597
 598 /* called with default environment! */
 599 int board_init(void)
 600 {
 601         gpio_request_array(tx48_gpios, ARRAY_SIZE(tx48_gpios));
 602         tx48_set_pin_mux(tx48_pads, ARRAY_SIZE(tx48_pads));
 603
 604         /* mach type passed to kernel */
 605 #ifdef CONFIG_OF_LIBFDT
 606         gd->bd->bi_arch_number = -1;
 607 #endif
 608         /* address of boot parameters */
 609         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
 610
 611         if (ctrlc())
 612                 printf("CTRL-C detected\n");
 613
 614         return 0;
 615 }
 616
 617 static void show_reset_cause(u32 prm_rstst)
 618 {
 619         const char *dlm = "";
 620
 621         printf("RESET cause: ");
 622         if (prm_rstst & PRM_RSTST_GLOBAL_COLD_RST) {
 623                 printf("%sPOR", dlm);
 624                 dlm = " | ";
 625         }
 626         if (prm_rstst & PRM_RSTST_GLOBAL_WARM_SW_RST) {
 627                 printf("%sSW", dlm);
 628                 dlm = " | ";
 629         }
 630         if (prm_rstst & PRM_RSTST_WDT1_RST) {
 631                 printf("%sWATCHDOG", dlm);
 632                 dlm = " | ";
 633         }
 634         if (prm_rstst & PRM_RSTST_EXTERNAL_WARM_RST) {
 635                 printf("%sWARM", dlm);
 636                 dlm = " | ";
 637         }
 638         if (prm_rstst & PRM_RSTST_ICEPICK_RST) {
 639                 printf("%sJTAG", dlm);
 640                 dlm = " | ";
 641         }
 642         if (*dlm == '\0')
 643                 printf("unknown");
 644
 645         printf(" RESET\n");
 646 }
 647
 648 /* called with default environment! */
 649 int checkboard(void)
 650 {
 651         prm_rstst = readl(PRM_RSTST);
 652         show_reset_cause(prm_rstst);
 653
 654 #ifdef CONFIG_OF_LIBFDT
 655         printf("Board: Ka-Ro TX48-7020 with FDT support\n");
 656 #else
 657         printf("Board: Ka-Ro TX48-7020\n");
 658 #endif
 659         timer_init();
 660         return 0;
 661 }
 662
 663 static void tx48_set_cpu_clock(void)
 664 {
 665         unsigned long cpu_clk = getenv_ulong("cpu_clk", 10, 0);
 666
 667         if (tstc() || (prm_rstst & PRM_RSTST_WDT1_RST))
 668                 return;
 669
 670         if (cpu_clk == 0 || cpu_clk == mpu_clk_rate() / 1000000)
 671                 return;
 672
 673         mpu_pll_config(cpu_clk);
 674
 675         printf("CPU clock set to %lu.%03lu MHz\n",
 676                 mpu_clk_rate() / 1000000,
 677                 mpu_clk_rate() / 1000 % 1000);
 678 }
 679
 680 /* called with environment from NAND or MMC */
 681 int board_late_init(void)
 682 {
 683         const char *baseboard;
 684
 685         tx48_set_cpu_clock();
 686 #ifdef CONFIG_OF_BOARD_SETUP
 687         karo_fdt_move_fdt();
 688 #endif
 689         baseboard = getenv("baseboard");
 690         if (!baseboard)
 691                 return 0;
 692
 693         if (strncmp(baseboard, "stk5", 4) == 0) {
 694                 printf("Baseboard: %s\n", baseboard);
 695                 if ((strlen(baseboard) == 4) ||
 696                         strcmp(baseboard, "stk5-v3") == 0) {
 697                         stk5v3_board_init();
 698                 } else if (strcmp(baseboard, "stk5-v5") == 0) {
 699                         stk5v5_board_init();
 700                 } else {
 701                         printf("WARNING: Unsupported STK5 board rev.: %s\n",
 702                                 baseboard + 4);
 703                 }
 704         } else {
 705                 printf("WARNING: Unsupported baseboard: '%s'\n",
 706                         baseboard);
 707                 return -EINVAL;
 708         }
 709
 710         return 0;
 711 }
 712
 713 #ifdef CONFIG_DRIVER_TI_CPSW
 714 static void tx48_phy_init(void)
 715 {
 716         debug("%s: Resetting ethernet PHY\n", __func__);
 717
 718         gpio_direction_output(TX48_ETH_PHY_RST_GPIO, 0);
 719
 720         udelay(100);
 721
 722         /* Release nRST */
 723         gpio_set_value(TX48_ETH_PHY_RST_GPIO, 1);
 724
 725         /* Wait for PHY internal POR signal to deassert */
 726         udelay(25000);
 727 }
 728
 729 static void cpsw_control(int enabled)
 730 {
 731         /* nothing for now */
 732         /* TODO : VTP was here before */
 733 }
 734
 735 static struct cpsw_slave_data cpsw_slaves[] = {
 736         {
 737                 .slave_reg_ofs  = 0x208,
 738                 .sliver_reg_ofs = 0xd80,
 739                 .phy_id         = 0,
 740                 .phy_if         = PHY_INTERFACE_MODE_RMII,
 741         },
 742 };
 743
 744 void s_init(void)
 745 {
 746         /* Nothing to be done here */
 747 }
 748
 749 static struct cpsw_platform_data cpsw_data = {
 750         .mdio_base              = AM335X_CPSW_MDIO_BASE,
 751         .cpsw_base              = AM335X_CPSW_BASE,
 752         .mdio_div               = 0xff,
 753         .channels               = 8,
 754         .cpdma_reg_ofs          = 0x800,
 755         .slaves                 = ARRAY_SIZE(cpsw_slaves),
 756         .slave_data             = cpsw_slaves,
 757         .ale_reg_ofs            = 0xd00,
 758         .ale_entries            = 1024,
 759         .host_port_reg_ofs      = 0x108,
 760         .hw_stats_reg_ofs       = 0x900,
 761         .mac_control            = (1 << 5) /* MIIEN */,
 762         .control                = cpsw_control,
 763         .gigabit_en             = 0,
 764         .host_port_num          = 0,
 765         .version                = CPSW_CTRL_VERSION_2,
 766 };
 767
 768 int board_eth_init(bd_t *bis)
 769 {
 770         uint8_t mac_addr[ETH_ALEN];
 771         uint32_t mac_hi, mac_lo;
 772
 773         /* try reading mac address from efuse */
 774         mac_lo = __raw_readl(MAC_ID0_LO);
 775         mac_hi = __raw_readl(MAC_ID0_HI);
 776
 777         mac_addr[0] = mac_hi & 0xFF;
 778         mac_addr[1] = (mac_hi & 0xFF00) >> 8;
 779         mac_addr[2] = (mac_hi & 0xFF0000) >> 16;
 780         mac_addr[3] = (mac_hi & 0xFF000000) >> 24;
 781         mac_addr[4] = mac_lo & 0xFF;
 782         mac_addr[5] = (mac_lo & 0xFF00) >> 8;
 783
 784         if (is_valid_ether_addr(mac_addr)) {
 785                 debug("MAC addr set to: %pM\n", mac_addr);
 786                 eth_setenv_enetaddr("ethaddr", mac_addr);
 787         } else {
 788                 printf("ERROR: Did not find a valid mac address in e-fuse\n");
 789         }
 790
 791         __raw_writel(RMII_MODE_ENABLE, MAC_MII_SEL);
 792         __raw_writel(0x5D, GMII_SEL);
 793         tx48_phy_init();
 794         return cpsw_register(&cpsw_data);
 795 }
 796 #endif /* CONFIG_DRIVER_TI_CPSW */
 797
 798 void tx48_disable_watchdog(void)
 799 {
 800         struct wd_timer *wdtimer = (struct wd_timer *)WDT_BASE;
 801
 802         while (readl(&wdtimer->wdtwwps) & (1 << 4))
 803                 ;
 804         writel(0xaaaa, &wdtimer->wdtwspr);
 805         while (readl(&wdtimer->wdtwwps) & (1 << 4))
 806                 ;
 807         writel(0x5555, &wdtimer->wdtwspr);
 808 }
 809
 810 #if defined(CONFIG_NAND_AM33XX) && defined(CONFIG_CMD_SWITCH_ECC)
 811 /******************************************************************************
 812  * Command to switch between NAND HW and SW ecc
 813  *****************************************************************************/
 814 static int do_switch_ecc(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 815 {
 816         int type = 0;
 817
 818         if (argc < 2)
 819                 goto usage;
 820
 821         if (strncmp(argv[1], "hw", 2) == 0) {
 822                 if (argc == 3)
 823                         type = simple_strtoul(argv[2], NULL, 10);
 824                 am33xx_nand_switch_ecc(NAND_ECC_HW, type);
 825         }
 826         else if (strncmp(argv[1], "sw", 2) == 0)
 827                 am33xx_nand_switch_ecc(NAND_ECC_SOFT, 0);
 828         else
 829                 goto usage;
 830
 831         return 0;
 832
 833 usage:
 834         printf("Usage: nandecc %s\n", cmdtp->usage);
 835         return 1;
 836 }
 837
 838 U_BOOT_CMD(
 839         nandecc, 3, 1,  do_switch_ecc,
 840         "Switch NAND ECC calculation algorithm b/w hardware and software",
 841         "[sw|hw <hw_type>] \n"
 842         "   [sw|hw]- Switch b/w hardware(hw) & software(sw) ecc algorithm\n"
 843         "   hw_type- 0 for Hamming code\n"
 844         "            1 for bch4\n"
 845         "            2 for bch8\n"
 846         "            3 for bch16\n"
 847 );
 848 #endif /* CONFIG_NAND_AM33XX && CONFIG_CMD_SWITCH_ECC */
 849
 850 enum {
 851         LED_STATE_INIT = -1,
 852         LED_STATE_OFF,
 853         LED_STATE_ON,
 854 };
 855
 856 void show_activity(int arg)
 857 {
 858         static int led_state = LED_STATE_INIT;
 859         static ulong last;
 860
 861         if (led_state == LED_STATE_INIT) {
 862                 last = get_timer(0);
 863                 gpio_set_value(TX48_LED_GPIO, 1);
 864                 led_state = LED_STATE_ON;
 865         } else {
 866                 if (get_timer(last) > CONFIG_SYS_HZ) {
 867                         last = get_timer(0);
 868                         if (led_state == LED_STATE_ON) {
 869                                 gpio_set_value(TX48_LED_GPIO, 0);
 870                         } else {
 871                                 gpio_set_value(TX48_LED_GPIO, 1);
 872                         }
 873                         led_state = 1 - led_state;
 874                 }
 875         }
 876 }
 877
 878 #ifdef CONFIG_OF_BOARD_SETUP
 879 #ifdef CONFIG_FDT_FIXUP_PARTITIONS
 880 #include <jffs2/jffs2.h>
 881 #include <mtd_node.h>
 882 struct node_info nodes[] = {
 883         { "ti,omap2-nand", MTD_DEV_TYPE_NAND, },
 884 };
 885
 886 #else
 887 #define fdt_fixup_mtdparts(b,n,c) do { } while (0)
 888 #endif /* CONFIG_FDT_FIXUP_PARTITIONS */
 889
 890 static void tx48_fixup_flexcan(void *blob)
 891 {
 892         const char *baseboard = getenv("baseboard");
 893
 894         if (baseboard && strcmp(baseboard, "stk5-v5") == 0)
 895                 return;
 896
 897         karo_fdt_del_prop(blob, "ti,dcan", 0x481cc000, "can-xcvr-enable");
 898         karo_fdt_del_prop(blob, "ti,dcan", 0x481d0000, "can-xcvr-enable");
 899 }
 900
 901 void ft_board_setup(void *blob, bd_t *bd)
 902 {
 903         fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
 904         fdt_fixup_ethernet(blob);
 905
 906         karo_fdt_fixup_touchpanel(blob);
 907         tx48_fixup_flexcan(blob);
 908
 909         tx48_disable_watchdog();
 910 }
 911 #endif /* CONFIG_OF_BOARD_SETUP */