packages/hal/arm/mx53/karo/v1_0/src/tx53_misc.c

   1 //==========================================================================
   2 //
   3 //      tx53_misc.c
   4 //
   5 //      HAL misc board support code for the tx53
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //========================================================================*/
  41
  42 #include <stdlib.h>
  43 #include <redboot.h>
  44 #include <string.h>
  45 #include <pkgconf/hal.h>
  46 #include <pkgconf/system.h>
  47 #include CYGBLD_HAL_PLATFORM_H
  48
  49 #include <cyg/infra/cyg_type.h>         // base types
  50 #include <cyg/infra/cyg_trac.h>         // tracing macros
  51 #include <cyg/infra/cyg_ass.h>          // assertion macros
  52
  53 #include <cyg/hal/hal_io.h>                     // IO macros
  54 #include <cyg/hal/hal_arch.h>           // Register state info
  55 #include <cyg/hal/hal_diag.h>
  56 #include <cyg/hal/hal_intr.h>           // Interrupt names
  57 #include <cyg/hal/hal_cache.h>
  58 #include <cyg/hal/hal_soc.h>            // Hardware definitions
  59 #include CYGBLD_HAL_PLF_DEFS_H          // Platform specifics
  60
  61 #include <cyg/infra/diag.h>                     // diag_printf
  62
  63 // All the MM table layout is here:
  64 #include <cyg/hal/hal_mm.h>
  65
  66 /* MMU table definitions */
  67 #define SD_P0           (RAM_BANK0_BASE >> 20)                  /* physical RAM bank 0 address */
  68 #define SD_C0           SD_P0                                                   /* virtual address for cached 1:1 mapping */
  69 #define SD_S0           (RAM_BANK0_SIZE >> 20)                  /* RAM bank 0 size */
  70 #define SD_U0           (UNCACHED_RAM_BASE_VIRT >> 20)
  71 #ifdef RAM_BANK1_SIZE
  72 #define SD_P1           (RAM_BANK1_BASE >> 20)                  /* physical RAM bank 1 address */
  73 #define SD_C1           (SD_P0 + SD_S0)
  74 #define SD_S1           (RAM_BANK1_SIZE >> 20)                  /* RAM bank 1 size */
  75 #define SD_U1           (SD_U0 + SD_S0)
  76 #define SD_HI           (SD_P1 + (SD_S1 - 1))
  77 #endif
  78
  79 static unsigned long ttb_base = RAM_BANK0_BASE + 0x4000;
  80
  81 void hal_mmu_init(void)
  82 {
  83         unsigned long i;
  84         /*
  85          * Set the TTB register
  86          */
  87         asm volatile ("mcr  p15,0,%0,c2,c0,0" : : "r"(ttb_base));
  88
  89         /*
  90          * Set the Domain Access Control Register
  91          */
  92         i = ARM_ACCESS_DACR_DEFAULT;
  93         asm volatile ("mcr  p15,0,%0,c3,c0,0" : : "r"(i) /*:*/);
  94
  95         /*
  96          * First clear all TT entries - ie Set them to Faulting
  97          */
  98         memset((void *)ttb_base, 0, ARM_FIRST_LEVEL_PAGE_TABLE_SIZE);
  99
 100         /*                 Physical      Virtual         Size                   Attributes                                access permissions            Function */
 101         /*                 Base  Base     MB                     cached?           buffered?                                                                                     */
 102         /*                 xxx00000      xxx00000                                                                                */
 103         X_ARM_MMU_SECTION(0x000, 0x200, 0x001, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* Boot Rom */
 104 //      X_ARM_MMU_SECTION(0x1FF, 0x1FF, 0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* IRAM */
 105         X_ARM_MMU_SECTION(0x180, 0x180, 0x080, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* IPUv3D */
 106         X_ARM_MMU_SECTION(0x500, 0x500, 0x200, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Internal Registers */
 107         X_ARM_MMU_SECTION(SD_P0, 0x000, SD_S0, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 108         X_ARM_MMU_SECTION(SD_P0, SD_C0, SD_S0, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 109         X_ARM_MMU_SECTION(SD_P0, SD_U0, SD_S0, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* SDRAM (uncached) */
 110 #ifdef RAM_BANK1_SIZE
 111         X_ARM_MMU_SECTION(SD_P1, SD_S0, SD_S1, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 112         X_ARM_MMU_SECTION(SD_P1, SD_C1, SD_S1, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 113         X_ARM_MMU_SECTION(SD_P1, SD_U1, SD_S1, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 114         /* make sure the last MiB in the upper bank of SDRAM (where RedBoot resides)
 115          * has a unity mapping (required when switching MMU on) */
 116         X_ARM_MMU_SECTION(SD_HI, SD_HI, 0x001, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RO_RO); /* SDRAM bank1 identity mapping */
 117 #endif
 118         X_ARM_MMU_SECTION(0xF40, 0xF40, 0x040, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* CS1 EIM control & NFC buffer */
 119 }
 120
 121 static inline void set_reg(CYG_ADDRESS addr, CYG_WORD32 set, CYG_WORD32 clr)
 122 {
 123         CYG_WORD32 val;
 124
 125         HAL_READ_UINT32(addr, val);
 126         val = (val & ~clr) | set;
 127         HAL_WRITE_UINT32(addr, val);
 128 }
 129
 130 static inline void setup_gpio(int grp, int bit)
 131 {
 132         CYG_ADDRESS base = MX53_GPIO_ADDR(grp);
 133
 134         if (base == 0)
 135                 return;
 136         set_reg(base + GPIO_DR, 0, 1 << bit);
 137         set_reg(base + GPIO_GDIR, 1 << bit, 0);
 138 }
 139
 140 //
 141 // Platform specific initialization
 142 //
 143 #define PAD_CTL_UART_OUT                MUX_PAD_CTRL(PAD_CTL_PKE | PAD_CTL_PUE | \
 144                                                         PAD_CTL_PUS_100K_DOWN | PAD_CTL_DSE_HIGH | \
 145                                                         PAD_CTL_SRE_FAST)
 146 #define PAD_CTL_UART_IN         (MUX_PAD_CTRL(PAD_CTL_HYS) | PAD_CTL_UART_OUT)
 147
 148 static iomux_v3_cfg_t tx53_uart_pads[] = {
 149         MX53_PAD_PATA_DIOW__UART1_TXD_MUX | PAD_CTL_UART_OUT,
 150         MX53_PAD_PATA_DMACK__UART1_RXD_MUX | PAD_CTL_UART_IN,
 151
 152         MX53_PAD_PATA_DMARQ__UART2_TXD_MUX | PAD_CTL_UART_OUT,
 153         MX53_PAD_PATA_BUFFER_EN__UART2_RXD_MUX | PAD_CTL_UART_IN,
 154
 155         MX53_PAD_PATA_CS_0__UART3_TXD_MUX | PAD_CTL_UART_OUT,
 156         MX53_PAD_PATA_CS_1__UART3_RXD_MUX | PAD_CTL_UART_IN,
 157 };
 158
 159 static void uart_gpio_init(void)
 160 {
 161         mx53_iomux_setup_pads(tx53_uart_pads, CYG_NELEM(tx53_uart_pads));
 162 }
 163
 164 /* GPIOs to set up for TX53/Starterkit-5:
 165    Function  FCT  GPIO        Pad    IOMUXC SW_PAD  SW_INP mode
 166                                      OFFSET  CTRL    SEL
 167 FEC_REF_CLK   0   1,23 FEC_REF_CLK   0x24c   0x5c8
 168 FEC_MDC       0   1,31 FEC_MDC       0x26c   0x5e8
 169 FEC_MDIO      0   1,22 FEC_MDIO      0x248   0x5c4  0x804  1
 170 FEC_RXD0      0   1,27 FEC_RXD0      0x25c   0x5d8
 171 FEC_RXD1      0   1,26 FEC_RXD1      0x258   0x5d4
 172 FEC_RX_ER     0   1,24 FEC_RX_ER     0x250   0x5cc
 173 FEC_TX_EN     0   1,28 FEC_TX_EN     0x260   0x5dc
 174 FEC_TXD0      0   1,30 FEC_TXD0      0x268   0x5e4
 175 FEC_TXD1      0   1,29 FEC_TXD1      0x264   0x5e0
 176 FEC_CRS_DV    0   1,25 FEC_CRS_DV    0x254   0x5d0
 177
 178 FEC_RESET#    1   7,6  PATA_DA_0     0x290   0x610
 179 FEC_ENABLE    1   3,20 EIM_D20       0x128   0x470
 180 */
 181 static iomux_v3_cfg_t tx53_fec_pads[] = {
 182         /* setup FEC PHY pins for GPIO function (with SION set) */
 183         MX53_PAD_FEC_REF_CLK__GPIO_1_23 | IOMUX_CONFIG_SION,
 184         MX53_PAD_FEC_MDC__GPIO_1_31 | IOMUX_CONFIG_SION,
 185         MX53_PAD_FEC_MDIO__GPIO_1_22 | IOMUX_CONFIG_SION,
 186         MX53_PAD_FEC_RXD0__GPIO_1_27 | IOMUX_CONFIG_SION,
 187         MX53_PAD_FEC_RXD1__GPIO_1_26 | IOMUX_CONFIG_SION,
 188         MX53_PAD_FEC_RX_ER__GPIO_1_24 | IOMUX_CONFIG_SION,
 189         MX53_PAD_FEC_TX_EN__GPIO_1_28 | IOMUX_CONFIG_SION,
 190         MX53_PAD_FEC_TXD0__GPIO_1_30 | IOMUX_CONFIG_SION,
 191         MX53_PAD_FEC_TXD1__GPIO_1_29 | IOMUX_CONFIG_SION,
 192         MX53_PAD_FEC_CRS_DV__GPIO_1_25 | IOMUX_CONFIG_SION,
 193
 194         /* PHY reset */
 195         MX53_PAD_PATA_DA_0__GPIO_7_6 | IOMUX_CONFIG_SION,
 196         /* PHY power */
 197         MX53_PAD_EIM_D20__GPIO_3_20 | IOMUX_CONFIG_SION,
 198 };
 199
 200 static iomux_v3_cfg_t tx53_i2c_pads[] = {
 201         MX53_PAD_EIM_D21__I2C1_SCL | MUX_PAD_CTRL(PAD_CTL_DSE_HIGH |
 202                                                                                         PAD_CTL_HYS |
 203                                                                                         PAD_CTL_ODE) |
 204                                                                 IOMUX_CONFIG_SION,
 205         MX53_PAD_EIM_D28__I2C1_SDA | MUX_PAD_CTRL(PAD_CTL_DSE_HIGH |
 206                                                                                         PAD_CTL_HYS |
 207                                                                                         PAD_CTL_ODE) |
 208                                                                 IOMUX_CONFIG_SION,
 209 };
 210
 211 static void fec_gpio_init(void)
 212 {
 213         /* setup GPIO data register to 0 and DDIR output for FEC PHY pins */
 214         setup_gpio(1, 23);
 215         setup_gpio(1, 31);
 216         setup_gpio(1, 22);
 217         setup_gpio(1, 25);
 218         setup_gpio(1, 27);
 219         setup_gpio(1, 26);
 220         setup_gpio(1, 24);
 221         setup_gpio(1, 28);
 222         setup_gpio(1, 30);
 223         setup_gpio(1, 29);
 224
 225         setup_gpio(7, 6);
 226         setup_gpio(3, 20);
 227
 228         /* setup input mux for FEC pins */
 229         mx53_iomux_setup_pads(tx53_fec_pads, CYG_NELEM(tx53_fec_pads));
 230         mx53_iomux_setup_pads(tx53_i2c_pads, CYG_NELEM(tx53_i2c_pads));
 231 }
 232
 233 #ifdef CYGHWR_MX53_LCD_LOGO
 234 static iomux_v3_cfg_t tx53_lcd_pads[] = {
 235 #define PAD_CTL_LCD             MUX_PAD_CTRL(PAD_CTL_DSE_HIGH | PAD_CTL_DSE_HIGH)
 236         MX53_PAD_DISP0_DAT0__IPU_DISP0_DAT_0 | PAD_CTL_LCD,
 237         MX53_PAD_DISP0_DAT1, | PAD_CTL_LCD,
 238         MX53_PAD_DISP0_DAT2, | PAD_CTL_LCD,
 239         MX53_PAD_DISP0_DAT3, | PAD_CTL_LCD,
 240         MX53_PAD_DISP0_DAT4, | PAD_CTL_LCD,
 241         MX53_PAD_DISP0_DAT5, | PAD_CTL_LCD,
 242         MX53_PAD_DISP0_DAT6, | PAD_CTL_LCD,
 243         MX53_PAD_DISP0_DAT7, | PAD_CTL_LCD,
 244         MX53_PAD_DISP0_DAT8, | PAD_CTL_LCD,
 245         MX53_PAD_DISP0_DAT9, | PAD_CTL_LCD,
 246         MX53_PAD_DISP0_DAT10, | PAD_CTL_LCD,
 247         MX53_PAD_DISP0_DAT12, | PAD_CTL_LCD,
 248         MX53_PAD_DISP0_DAT13, | PAD_CTL_LCD,
 249         MX53_PAD_DISP0_DAT14, | PAD_CTL_LCD,
 250         MX53_PAD_DISP0_DAT15, | PAD_CTL_LCD,
 251         MX53_PAD_DISP0_DAT16, | PAD_CTL_LCD,
 252         MX53_PAD_DISP0_DAT17, | PAD_CTL_LCD,
 253
 254         /* HSYNC, VSYNC */
 255         MX53_PAD_DI0_PIN2__IPU_DI0_PIN2 | PAD_CTL_LCD,
 256         MX53_PAD_DI0_PIN3__IPU_DI0_PIN3 | PAD_CTL_LCD,
 257         /* OE_ACD */
 258         MX53_PAD_DI0_PIN15__IPU_DI0_PIN15 | MUX_PAD_CRTL(PAD_CTL_LCD | PAD_CTL_PKE),
 259         MX53_PAD_DI0_DISP_CLK__IPU_DI0_DISP_CLK | MUX_PAD_CTRL(PAD_CTL_LCD),
 260
 261         /* LCD Power Enable */
 262         MX53_PAD_EIM_EB3__GPIO_2_31,
 263         /* LCD Reset */
 264         MX53_PAD_EIM_D29__GPIO_3_29,
 265         /* LCD backlight */
 266         MX53_PAD_GPIO_1__GPIO_1_1,
 267 };
 268
 269 void mxc_ipu_iomux_config(void)
 270 {
 271         /* LCD Power Enable GPIO_2_31 (active High) */
 272         gpio_clr_bit(2, 31);
 273
 274         /* LCD Reset GPIO_3_29 (active Low) */
 275         gpio_clr_bit(3, 29);
 276
 277         /* LCD Backlight GPIO_1_1 (PWM 0: full brightness 1: off) */
 278         gpio_set_bit(1, 1);
 279
 280         mx53_iomux_setup_pads(tx53_lcd_pads, CYG_NELEM(tx53_lcd_pads));
 281 }
 282 RedBoot_init(mxc_ipu_iomux_config, RedBoot_INIT_SECOND);
 283 #endif
 284
 285 //
 286 // Platform specific initialization
 287 //
 288
 289 void plf_hardware_init(void)
 290 {
 291 #ifdef RAM_BANK1_SIZE
 292         /* destroy mapping for high area in SDRAM */
 293         X_ARM_MMU_SECTION(SD_HI, 0, 0, 0, 0, ARM_ACCESS_PERM_NONE_NONE);
 294 #endif
 295         uart_gpio_init();
 296         fec_gpio_init();
 297
 298         /* NFC setup */
 299         writel(readl(NFC_FLASH_CONFIG3_REG) |
 300                         (1 << 15) | /* assert RBB_MODE  (see Errata: ENGcm09970) */
 301                         (1 << 20) | /* assert NO_SDMA */
 302                         (1 << 3), /* set bus width to 8bit */
 303                         NFC_FLASH_CONFIG3_REG);
 304 }
 305
 306 #define SOC_I2C1_BASE           UL(0x63fc8000)
 307
 308 /* Address offsets of the I2C registers */
 309 #define MXC_IADR                                0x00    /* Address Register */
 310 #define MXC_IFDR                                0x04    /* Freq div register */
 311 #define MXC_I2CR                                0x08    /* Control regsiter */
 312 #define MXC_I2SR                                0x0C    /* Status register */
 313 #define MXC_I2DR                                0x10    /* Data I/O register */
 314
 315 /* Bit definitions of I2CR */
 316 #define MXC_I2CR_IEN                    0x0080
 317 #define MXC_I2CR_IIEN                   0x0040
 318 #define MXC_I2CR_MSTA                   0x0020
 319 #define MXC_I2CR_MTX                    0x0010
 320 #define MXC_I2CR_TXAK                   0x0008
 321 #define MXC_I2CR_RSTA                   0x0004
 322
 323 /* Bit definitions of I2SR */
 324 #define MXC_I2SR_ICF                    0x0080
 325 #define MXC_I2SR_IAAS                   0x0040
 326 #define MXC_I2SR_IBB                    0x0020
 327 #define MXC_I2SR_IAL                    0x0010
 328 #define MXC_I2SR_SRW                    0x0004
 329 #define MXC_I2SR_IIF                    0x0002
 330 #define MXC_I2SR_RXAK                   0x0001
 331
 332 #define LP3972_SLAVE_ADDR       0x34
 333
 334 static inline cyg_uint8 i2c_addr(cyg_uint8 addr, int rw)
 335 {
 336         return (addr << 1) | !!rw;
 337 }
 338
 339 static inline cyg_uint8 tx53_i2c_read(cyg_uint8 reg)
 340 {
 341         cyg_uint16 val;
 342         HAL_READ_UINT16(SOC_I2C1_BASE + reg, val);
 343         return val;
 344 }
 345
 346 static inline void tx53_i2c_write(cyg_uint8 reg, cyg_uint8 val)
 347 {
 348         HAL_WRITE_UINT16(SOC_I2C1_BASE + reg, val);
 349 }
 350
 351 static inline void tx53_i2c_set_reg(cyg_uint8 reg, cyg_uint8 set, cyg_uint8 clr)
 352 {
 353         cyg_uint8 val = tx53_i2c_read(reg);
 354         val = (val & ~clr) | set;
 355         tx53_i2c_write(reg, val);
 356 }
 357
 358 static void tx53_i2c_disable(void)
 359 {
 360         /* disable I2C controller */
 361         tx53_i2c_set_reg(MXC_I2CR, 0, MXC_I2CR_IEN);
 362         /* disable I2C clock */
 363         set_reg(CCM_BASE_ADDR + CLKCTL_CGPR, 0, (1 << 4));
 364 }
 365
 366 static int tx53_i2c_init(void)
 367 {
 368         int ret;
 369
 370         /* enable I2C clock */
 371         set_reg(CCM_BASE_ADDR + CLKCTL_CGPR, (1 << 4), 0);
 372
 373         /* setup I2C clock divider */
 374         tx53_i2c_write(MXC_IFDR, 0x2c);
 375         tx53_i2c_write(MXC_I2SR, 0);
 376
 377         /* enable I2C controller in master mode */
 378         tx53_i2c_write(MXC_I2CR, MXC_I2CR_IEN);
 379
 380         ret = tx53_i2c_read(MXC_I2SR);
 381         if (ret & MXC_I2SR_IBB) {
 382                 diag_printf("I2C bus busy\n");
 383                 tx53_i2c_disable();
 384                 return -EIO;
 385         }
 386         return 0;
 387 }
 388
 389 static int tx53_i2c_wait_busy(int set)
 390 {
 391         int ret;
 392         const int max_loops = 100;
 393         int retries = max_loops;
 394
 395         cyg_uint8 mask = set ? MXC_I2SR_IBB : 0;
 396
 397         while ((ret = mask ^ (tx53_i2c_read(MXC_I2SR) & MXC_I2SR_IBB)) && --retries > 0) {
 398                 HAL_DELAY_US(3);
 399         }
 400         if (ret != 0) {
 401                 diag_printf("i2c: Waiting for IBB to %s timed out\n", set ? "set" : "clear");
 402                 return -ETIMEDOUT;
 403         }
 404         return ret;
 405 }
 406
 407 static int tx53_i2c_wait_tc(void)
 408 {
 409         int ret;
 410         const int max_loops = 1000;
 411         int retries = max_loops;
 412
 413         while (!((ret = tx53_i2c_read(MXC_I2SR)) & MXC_I2SR_IIF) && --retries > 0) {
 414                 HAL_DELAY_US(3);
 415         }
 416         tx53_i2c_write(MXC_I2SR, 0);
 417         if (!(ret & MXC_I2SR_IIF)) {
 418                 diag_printf("i2c: Wait for transfer completion timed out\n");
 419                 return -ETIMEDOUT;
 420         }
 421         if (ret & MXC_I2SR_ICF) {
 422                 if (tx53_i2c_read(MXC_I2CR) & MXC_I2CR_MTX) {
 423                         if (!(ret & MXC_I2SR_RXAK)) {
 424                                 ret = 0;
 425                         } else {
 426                                 diag_printf("i2c: No ACK received after writing data\n");
 427                                 return -ENXIO;
 428                         }
 429                 }
 430         }
 431         return ret;
 432 }
 433
 434 static int tx53_i2c_stop(void)
 435 {
 436         int ret;
 437
 438         tx53_i2c_set_reg(MXC_I2CR, 0, MXC_I2CR_MSTA | MXC_I2CR_MTX);
 439         ret = tx53_i2c_wait_busy(0);
 440         return ret;
 441 }
 442
 443 static int tx53_i2c_start(cyg_uint8 addr, int rw)
 444 {
 445         int ret;
 446
 447         ret = tx53_i2c_init();
 448         if (ret < 0) {
 449                 diag_printf("I2C bus init failed; cannot switch fuse programming voltage\n");
 450                 return ret;
 451         }
 452         tx53_i2c_set_reg(MXC_I2CR, MXC_I2CR_MSTA, 0);
 453         ret = tx53_i2c_wait_busy(1);
 454         if (ret == 0) {
 455                 tx53_i2c_set_reg(MXC_I2CR, MXC_I2CR_MTX, 0);
 456                 tx53_i2c_write(MXC_I2DR, i2c_addr(addr, rw));
 457                 ret = tx53_i2c_wait_tc();
 458                 if (ret < 0) {
 459                         tx53_i2c_stop();
 460                 }
 461         }
 462         return ret;
 463 }
 464
 465 static int tx53_i2c_repeat_start(cyg_uint8 addr, int rw)
 466 {
 467         int ret;
 468
 469         tx53_i2c_set_reg(MXC_I2CR, MXC_I2CR_RSTA, 0);
 470         HAL_DELAY_US(3);
 471         tx53_i2c_write(MXC_I2DR, i2c_addr(addr, rw));
 472         ret = tx53_i2c_wait_tc();
 473         if (ret < 0) {
 474                 tx53_i2c_stop();
 475         }
 476         return ret;
 477 }
 478
 479 static int tx53_i2c_read_byte(void)
 480 {
 481         int ret;
 482
 483         tx53_i2c_set_reg(MXC_I2CR, MXC_I2CR_TXAK, MXC_I2CR_MTX);
 484         (void)tx53_i2c_read(MXC_I2DR); /* dummy read after address cycle */
 485         ret = tx53_i2c_wait_tc();
 486         tx53_i2c_stop();
 487         if (ret < 0) {
 488                 return ret;
 489         }
 490         ret = tx53_i2c_read(MXC_I2DR);
 491         return ret;
 492 }
 493
 494 static int tx53_i2c_write_byte(cyg_uint8 data, int last)
 495 {
 496         int ret;
 497
 498         tx53_i2c_set_reg(MXC_I2CR, MXC_I2CR_MTX, 0);
 499         tx53_i2c_write(MXC_I2DR, data);
 500         if ((ret = tx53_i2c_wait_tc()) < 0 || last) {
 501                 tx53_i2c_stop();
 502         }
 503         return ret;
 504 }
 505
 506 static int tx53_i2c_reg_read(cyg_uint8 slave_addr, cyg_uint8 reg)
 507 {
 508         int ret;
 509
 510         ret = tx53_i2c_start(slave_addr, 0);
 511         if (ret < 0) {
 512                 return ret;
 513         }
 514         ret = tx53_i2c_write_byte(reg, 0);
 515         if (ret < 0) {
 516                 return ret;
 517         }
 518         ret = tx53_i2c_repeat_start(slave_addr, 1);
 519         if (ret < 0) {
 520                 return ret;
 521         }
 522         ret = tx53_i2c_read_byte();
 523         tx53_i2c_disable();
 524         return ret;
 525 }
 526
 527 static int tx53_i2c_reg_write(cyg_uint8 slave_addr, cyg_uint8 reg, cyg_uint8 val)
 528 {
 529         int ret;
 530
 531         ret = tx53_i2c_start(slave_addr, 0);
 532         if (ret < 0) {
 533                 return ret;
 534         }
 535         ret = tx53_i2c_write_byte(reg, 0);
 536         if (ret < 0) {
 537                 return ret;
 538         }
 539         ret = tx53_i2c_write_byte(val, 1);
 540         tx53_i2c_disable();
 541         return ret;
 542 }
 543
 544 int tx53_mac_addr_program(unsigned char mac_addr[ETHER_ADDR_LEN])
 545 {
 546         int ret = 0;
 547         int i;
 548
 549         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 550                 unsigned char fuse = readl(SOC_FEC_MAC_BASE + (i << 2));
 551
 552                 if ((fuse | mac_addr[i]) != mac_addr[i]) {
 553                         diag_printf("MAC address fuse cannot be programmed: fuse[%d]=0x%02x -> 0x%02x\n",
 554                                                 i, fuse, mac_addr[i]);
 555                         return -1;
 556                 }
 557                 if (fuse != mac_addr[i]) {
 558                         ret = 1;
 559                 }
 560         }
 561         if (ret == 0) {
 562                 return ret;
 563         }
 564
 565         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 566                 unsigned char fuse = readl(SOC_FEC_MAC_BASE + (i << 2));
 567                 int row = SOC_MAC_ADDR_FUSE + i;
 568
 569                 if (fuse == mac_addr[i]) {
 570                         continue;
 571                 }
 572                 fuse_blow_row(SOC_MAC_ADDR_FUSE_BANK, row, mac_addr[i]);
 573                 ret = sense_fuse(SOC_MAC_ADDR_FUSE_BANK, row, 0);
 574                 if (ret != mac_addr[i]) {
 575                         diag_printf("Failed to verify fuse bank %d row %d; expected %02x got %02x\n",
 576                                                 SOC_MAC_ADDR_FUSE_BANK, row, mac_addr[i], ret);
 577                         goto out;
 578                 }
 579         }
 580 #ifdef SOC_MAC_ADDR_LOCK_BIT
 581         fuse_blow_row(SOC_MAC_ADDR_FUSE_BANK, SOC_MAC_ADDR_LOCK_FUSE,
 582                                 (1 << SOC_MAC_ADDR_LOCK_BIT));
 583 #endif
 584 out:
 585         return ret;
 586 }
 587
 588 #include CYGHWR_MEMORY_LAYOUT_H
 589
 590 typedef void code_fun(void);
 591
 592 void tx53_program_new_stack(void *func)
 593 {
 594         register CYG_ADDRESS stack_ptr asm("sp");
 595         register CYG_ADDRESS old_stack asm("r4");
 596         register code_fun *new_func asm("r0");
 597
 598         old_stack = stack_ptr;
 599         stack_ptr = CYGMEM_REGION_ram + CYGMEM_REGION_ram_SIZE - sizeof(CYG_ADDRESS);
 600         new_func = (code_fun*)func;
 601         new_func();
 602         stack_ptr = old_stack;
 603 }
 604
 605 #if CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2
 606 #define PMIC_NAME                       "LP3972"
 607 #elif CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 3
 608 #define PMIC_NAME                       "LT3598"
 609 #else
 610 #error Bad CYGNUM_HAL_ARM_TX53_SDRAM_TYPE
 611 #endif
 612
 613 static int pmic_reg_read(cyg_uint8 reg)
 614 {
 615         int ret;
 616
 617         ret = tx53_i2c_reg_read(LP3972_SLAVE_ADDR, reg);
 618         if (ret < 0)
 619                 diag_printf("Failed to read %s reg 0x%02x %d\n", PMIC_NAME,
 620                                         reg, ret);
 621         return ret;
 622 }
 623
 624 static int pmic_reg_write(cyg_uint8 reg, cyg_uint8 val)
 625 {
 626         int ret;
 627
 628         ret = tx53_i2c_reg_write(LP3972_SLAVE_ADDR, reg, val);
 629         if (ret)
 630                 diag_printf("Failed to write 0x%02x to %s reg 0x%02x: %d\n",
 631                                         val, PMIC_NAME, reg, ret);
 632         return ret;
 633 }
 634
 635 #if CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2
 636 int tx53_fuse_voltage(int on)
 637 {
 638         int ret;
 639
 640         ret = pmic_reg_read(0x81);
 641         if (ret < 0)
 642                 return ret;
 643
 644         /* Try to enable FUSE_VDD by asserting LP3972 GPIO1 */
 645         ret = (ret & ~0x3) | (on ? 1 : 3);
 646         ret = pmic_reg_write(0x81, ret);
 647         if (ret) {
 648                 return ret;
 649         }
 650         ret = pmic_reg_read(0x81);
 651         if ((ret & 0x3) != (on ? 0x1 : 0x3)) {
 652                 return -EIO;
 653         }
 654         return 0;
 655 }
 656
 657 #define CORE_VOLTAGE_HIGH               0x1b
 658 #define CORE_VOLTAGE_LOW                0x03
 659 #if CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ_512M
 660 #define SDRAM_SIZE_STR                  '0'
 661 #else
 662 #if CYGNUM_HAL_ARM_TX53_CPU_CLK == 1000
 663 #define SDRAM_SIZE_STR                  '2'
 664 #else
 665 #define SDRAM_SIZE_STR                  '1'
 666 #endif /* CYGNUM_HAL_ARM_TX53_CPU_CLK == 1000 */
 667 #endif /* CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ512M */
 668
 669 #elif CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 3
 670 int tx53_fuse_voltage(int on)
 671 {
 672         int ret;
 673
 674         if (on) {
 675                 ret = pmic_reg_read(0x33);
 676                 if (ret < 0)
 677                         return ret;
 678                 if ((ret & 0xe0) != 0xe0) {
 679                         ret = pmic_reg_write(0x33, ret | 0xe0);
 680                         if (ret)
 681                                 return ret;
 682
 683                         ret = pmic_reg_read(0x33);
 684                         if (ret < 0)
 685                                 return ret;
 686
 687                         if ((ret & 0xe0) != 0xe0) {
 688                                 diag_printf("Could not adjust LT3589 LDO4 output voltage\n");
 689                                 return -EIO;
 690                         }
 691                 }
 692
 693                 ret = pmic_reg_read(0x12);
 694                 if (ret < 0)
 695                         return ret;
 696
 697                 if (!(ret & (1 << 6))) {
 698                         ret |= 1 << 6; /* LDO4 Startup: don't wait for output < 300mV */
 699                         ret = pmic_reg_write(0x12, ret);
 700                         if (ret)
 701                                 return -EIO;
 702                         ret = pmic_reg_read(0x12);
 703                         if (!(ret & (1 << 6))) {
 704                                 diag_printf("Could not set LT3589 LDO4 Startup control\n");
 705                                 return -EIO;
 706                         }
 707                 }
 708         }
 709         /* enable SW regulator control and all regulators (except LDO4, if !on) */
 710         ret = pmic_reg_write(0x10, 0xbf | (!!on << 6));
 711         if (ret)
 712                 return ret;
 713
 714         ret = pmic_reg_read(0x10);
 715         if (ret < 0)
 716                 return ret;
 717
 718         if (!(ret & (1 << 6)) ^ !on) {
 719                 diag_printf("Could not enable LT3589 LDO4 output\n");
 720                 return -EIO;
 721         }
 722         return 0;
 723 }
 724
 725 #define CORE_VOLTAGE_HIGH               0x1c
 726 #define CORE_VOLTAGE_LOW                0x17
 727 #if CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ_512M
 728 #define SDRAM_SIZE_STR                  '0'
 729 #else
 730 #define SDRAM_SIZE_STR                  '1'
 731 #endif
 732 #endif
 733
 734 void increase_core_voltage(bool high)
 735 {
 736         int ret;
 737         const int volt = high ? CORE_VOLTAGE_HIGH : CORE_VOLTAGE_LOW;
 738
 739         ret = pmic_reg_read(0x23);
 740         if (ret < 0) {
 741                 diag_printf("Failed to read core voltage: %d\n", ret);
 742                 return;
 743         }
 744
 745         ret = pmic_reg_write(0x23, volt);
 746         if (ret < 0) {
 747                 diag_printf("Failed to write core voltage: %d\n", ret);
 748         }
 749 }
 750
 751 static void display_board_type(void)
 752 {
 753         char cpu_freq;
 754         const char *ddr_type = _stringify(CYGNUM_HAL_ARM_TX53_SDRAM_TYPE);
 755
 756         switch (CYGNUM_HAL_ARM_TX53_CPU_CLK) {
 757         case 800:
 758                 cpu_freq = '8';
 759                 break;
 760
 761         case 1000:
 762                 cpu_freq = '1';
 763                 break;
 764
 765         default:
 766                 cpu_freq = '?';
 767         }
 768
 769         diag_printf("\nBoard Type: Ka-Ro TX53-%c%c%s%c\n",
 770                                 cpu_freq, CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2 ? '0' : 'x',
 771                                 ddr_type, SDRAM_SIZE_STR);
 772 }
 773
 774 static void display_board_info(void)
 775 {
 776         display_board_type();
 777 }
 778 RedBoot_init(display_board_info, RedBoot_INIT_LAST);
 779
 780 void mxc_i2c_init(unsigned int module_base)
 781 {
 782         switch (module_base) {
 783         case I2C1_BASE_ADDR:
 784                 writel(0x15, IOMUXC_BASE_ADDR + 0x12c);
 785                 writel(0x10c, IOMUXC_BASE_ADDR + 0x474);
 786                 writel(0x1, IOMUXC_BASE_ADDR + 0x814);
 787
 788                 writel(0x15, IOMUXC_BASE_ADDR + 0x14c);
 789                 writel(0x10c, IOMUXC_BASE_ADDR + 0x494);
 790                 writel(0x1, IOMUXC_BASE_ADDR + 0x818);
 791                 break;
 792
 793         case I2C3_BASE_ADDR:
 794                 writel(0x11, IOMUXC_BASE_ADDR + 0x120);
 795                 writel(0x1fc, IOMUXC_BASE_ADDR + 0x468);
 796
 797                 writel(0x11, IOMUXC_BASE_ADDR + 0x118);
 798                 writel(0x1fc, IOMUXC_BASE_ADDR + 0x460);
 799                 break;
 800
 801         default:
 802                 diag_printf("Invalid I2C base: 0x%x\n", module_base);
 803         }
 804 }