arch/arm/mach-omap/common.c

   1 /*
   2  * linux/arch/arm/mach-omap/common.c
   3  *
   4  * Code common to all OMAP machines.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10 #include <linux/config.h>
  11 #include <linux/module.h>
  12 #include <linux/kernel.h>
  13 #include <linux/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/pm.h>
  16 #include <linux/console.h>
  17 #include <linux/serial.h>
  18 #include <linux/tty.h>
  19 #include <linux/serial_8250.h>
  20 #include <linux/serial_reg.h>
  21
  22 #include <asm/hardware.h>
  23 #include <asm/system.h>
  24 #include <asm/pgtable.h>
  25 #include <asm/mach/map.h>
  26 #include <asm/hardware/clock.h>
  27 #include <asm/io.h>
  28 #include <asm/mach-types.h>
  29
  30 #include <asm/arch/board.h>
  31 #include <asm/arch/mux.h>
  32 #include <asm/arch/fpga.h>
  33 #include <asm/arch/serial.h>
  34
  35
  36 #include "clock.h"
  37
  38 #define DEBUG 1
  39
  40 struct omap_id {
  41         u16     jtag_id;        /* Used to determine OMAP type */
  42         u8      die_rev;        /* Processor revision */
  43         u32     omap_id;        /* OMAP revision */
  44         u32     type;           /* Cpu id bits [31:08], cpu class bits [07:00] */
  45 };
  46
  47 /* Register values to detect the OMAP version */
  48 static struct omap_id omap_ids[] __initdata = {
  49         { .jtag_id = 0x355f, .die_rev = 0x0, .omap_id = 0x03320000, .type = 0x07300100},
  50         { .jtag_id = 0xb55f, .die_rev = 0x0, .omap_id = 0x03320000, .type = 0x07300300},
  51         { .jtag_id = 0xb470, .die_rev = 0x0, .omap_id = 0x03310100, .type = 0x15100000},
  52         { .jtag_id = 0xb576, .die_rev = 0x0, .omap_id = 0x03320000, .type = 0x16100000},
  53         { .jtag_id = 0xb576, .die_rev = 0x2, .omap_id = 0x03320100, .type = 0x16110000},
  54         { .jtag_id = 0xb576, .die_rev = 0x3, .omap_id = 0x03320100, .type = 0x16100c00},
  55         { .jtag_id = 0xb576, .die_rev = 0x0, .omap_id = 0x03320200, .type = 0x16100d00},
  56         { .jtag_id = 0xb613, .die_rev = 0x0, .omap_id = 0x03320300, .type = 0x1610ef00},
  57         { .jtag_id = 0xb613, .die_rev = 0x0, .omap_id = 0x03320300, .type = 0x1610ef00},
  58         { .jtag_id = 0xb576, .die_rev = 0x1, .omap_id = 0x03320100, .type = 0x16110000},
  59         { .jtag_id = 0xb58c, .die_rev = 0x2, .omap_id = 0x03320200, .type = 0x16110b00},
  60         { .jtag_id = 0xb58c, .die_rev = 0x3, .omap_id = 0x03320200, .type = 0x16110c00},
  61         { .jtag_id = 0xb65f, .die_rev = 0x0, .omap_id = 0x03320400, .type = 0x16212300},
  62         { .jtag_id = 0xb65f, .die_rev = 0x1, .omap_id = 0x03320400, .type = 0x16212300},
  63         { .jtag_id = 0xb65f, .die_rev = 0x1, .omap_id = 0x03320500, .type = 0x16212300},
  64         { .jtag_id = 0xb5f7, .die_rev = 0x0, .omap_id = 0x03330000, .type = 0x17100000},
  65         { .jtag_id = 0xb5f7, .die_rev = 0x1, .omap_id = 0x03330100, .type = 0x17100000},
  66         { .jtag_id = 0xb5f7, .die_rev = 0x2, .omap_id = 0x03330100, .type = 0x17100000},
  67 };
  68
  69 /*
  70  * Get OMAP type from PROD_ID.
  71  * 1710 has the PROD_ID in bits 15:00, not in 16:01 as documented in TRM.
  72  * 1510 PROD_ID is empty, and 1610 PROD_ID does not make sense.
  73  * Undocumented register in TEST BLOCK is used as fallback; This seems to
  74  * work on 1510, 1610 & 1710. The official way hopefully will work in future
  75  * processors.
  76  */
  77 static u16 __init omap_get_jtag_id(void)
  78 {
  79         u32 prod_id, omap_id;
  80
  81         prod_id = omap_readl(OMAP_PRODUCTION_ID_1);
  82         omap_id = omap_readl(OMAP32_ID_1);
  83
  84         /* Check for unusable OMAP_PRODUCTION_ID_1 on 1611B/5912 and 730 */
  85         if (((prod_id >> 20) == 0) || (prod_id == omap_id))
  86                 prod_id = 0;
  87         else
  88                 prod_id &= 0xffff;
  89
  90         if (prod_id)
  91                 return prod_id;
  92
  93         /* Use OMAP32_ID_1 as fallback */
  94         prod_id = ((omap_id >> 12) & 0xffff);
  95
  96         return prod_id;
  97 }
  98
  99 /*
 100  * Get OMAP revision from DIE_REV.
 101  * Early 1710 processors may have broken OMAP_DIE_ID, it contains PROD_ID.
 102  * Undocumented register in the TEST BLOCK is used as fallback.
 103  * REVISIT: This does not seem to work on 1510
 104  */
 105 static u8 __init omap_get_die_rev(void)
 106 {
 107         u32 die_rev;
 108
 109         die_rev = omap_readl(OMAP_DIE_ID_1);
 110
 111         /* Check for broken OMAP_DIE_ID on early 1710 */
 112         if (((die_rev >> 12) & 0xffff) == omap_get_jtag_id())
 113                 die_rev = 0;
 114
 115         die_rev = (die_rev >> 17) & 0xf;
 116         if (die_rev)
 117                 return die_rev;
 118
 119         die_rev = (omap_readl(OMAP32_ID_1) >> 28) & 0xf;
 120
 121         return die_rev;
 122 }
 123
 124 static void __init omap_check_revision(void)
 125 {
 126         int i;
 127         u16 jtag_id;
 128         u8 die_rev;
 129         u32 omap_id;
 130         u8 cpu_type;
 131
 132         jtag_id = omap_get_jtag_id();
 133         die_rev = omap_get_die_rev();
 134         omap_id = omap_readl(OMAP32_ID_0);
 135
 136 #ifdef DEBUG
 137         printk("OMAP_DIE_ID_0: 0x%08x\n", omap_readl(OMAP_DIE_ID_0));
 138         printk("OMAP_DIE_ID_1: 0x%08x DIE_REV: %i\n",
 139                 omap_readl(OMAP_DIE_ID_1),
 140                (omap_readl(OMAP_DIE_ID_1) >> 17) & 0xf);
 141         printk("OMAP_PRODUCTION_ID_0: 0x%08x\n", omap_readl(OMAP_PRODUCTION_ID_0));
 142         printk("OMAP_PRODUCTION_ID_1: 0x%08x JTAG_ID: 0x%04x\n",
 143                 omap_readl(OMAP_PRODUCTION_ID_1),
 144                 omap_readl(OMAP_PRODUCTION_ID_1) & 0xffff);
 145         printk("OMAP32_ID_0: 0x%08x\n", omap_readl(OMAP32_ID_0));
 146         printk("OMAP32_ID_1: 0x%08x\n", omap_readl(OMAP32_ID_1));
 147         printk("JTAG_ID: 0x%04x DIE_REV: %i\n", jtag_id, die_rev);
 148 #endif
 149
 150         system_serial_high = omap_readl(OMAP_DIE_ID_0);
 151         system_serial_low = omap_readl(OMAP_DIE_ID_1);
 152
 153         /* First check only the major version in a safe way */
 154         for (i = 0; i < ARRAY_SIZE(omap_ids); i++) {
 155                 if (jtag_id == (omap_ids[i].jtag_id)) {
 156                         system_rev = omap_ids[i].type;
 157                         break;
 158                 }
 159         }
 160
 161         /* Check if we can find the die revision */
 162         for (i = 0; i < ARRAY_SIZE(omap_ids); i++) {
 163                 if (jtag_id == omap_ids[i].jtag_id && die_rev == omap_ids[i].die_rev) {
 164                         system_rev = omap_ids[i].type;
 165                         break;
 166                 }
 167         }
 168
 169         /* Finally check also the omap_id */
 170         for (i = 0; i < ARRAY_SIZE(omap_ids); i++) {
 171                 if (jtag_id == omap_ids[i].jtag_id
 172                     && die_rev == omap_ids[i].die_rev
 173                     && omap_id == omap_ids[i].omap_id) {
 174                         system_rev = omap_ids[i].type;
 175                         break;
 176                 }
 177         }
 178
 179         /* Add the cpu class info (7xx, 15xx, 16xx, 24xx) */
 180         cpu_type = system_rev >> 24;
 181
 182         switch (cpu_type) {
 183         case 0x07:
 184                 system_rev |= 0x07;
 185                 break;
 186         case 0x15:
 187                 system_rev |= 0x15;
 188                 break;
 189         case 0x16:
 190         case 0x17:
 191                 system_rev |= 0x16;
 192                 break;
 193         case 0x24:
 194                 system_rev |= 0x24;
 195                 break;
 196         default:
 197                 printk("Unknown OMAP cpu type: 0x%02x\n", cpu_type);
 198         }
 199
 200         printk("OMAP%04x", system_rev >> 16);
 201         if ((system_rev >> 8) & 0xff)
 202                 printk("%x", (system_rev >> 8) & 0xff);
 203         printk(" revision %i handled as %02xxx id: %08x%08x\n",
 204                die_rev, system_rev & 0xff, system_serial_low,
 205                system_serial_high);
 206 }
 207
 208 /*
 209  * ----------------------------------------------------------------------------
 210  * OMAP I/O mapping
 211  *
 212  * The machine specific code may provide the extra mapping besides the
 213  * default mapping provided here.
 214  * ----------------------------------------------------------------------------
 215  */
 216
 217 static struct map_desc omap_io_desc[] __initdata = {
 218  { IO_VIRT,             IO_PHYS,             IO_SIZE,              MT_DEVICE },
 219 };
 220
 221 #ifdef CONFIG_ARCH_OMAP730
 222 static struct map_desc omap730_io_desc[] __initdata = {
 223  { OMAP730_DSP_BASE,    OMAP730_DSP_START,    OMAP730_DSP_SIZE,    MT_DEVICE },
 224  { OMAP730_DSPREG_BASE, OMAP730_DSPREG_START, OMAP730_DSPREG_SIZE, MT_DEVICE },
 225  { OMAP730_SRAM_BASE,   OMAP730_SRAM_START,   OMAP730_SRAM_SIZE,   MT_DEVICE }
 226 };
 227 #endif
 228
 229 #ifdef CONFIG_ARCH_OMAP1510
 230 static struct map_desc omap1510_io_desc[] __initdata = {
 231  { OMAP1510_DSP_BASE,    OMAP1510_DSP_START,    OMAP1510_DSP_SIZE,    MT_DEVICE },
 232  { OMAP1510_DSPREG_BASE, OMAP1510_DSPREG_START, OMAP1510_DSPREG_SIZE, MT_DEVICE },
 233  { OMAP1510_SRAM_BASE,   OMAP1510_SRAM_START,   OMAP1510_SRAM_SIZE,   MT_DEVICE }
 234 };
 235 #endif
 236
 237 #if defined(CONFIG_ARCH_OMAP16XX)
 238 static struct map_desc omap1610_io_desc[] __initdata = {
 239  { OMAP16XX_DSP_BASE,    OMAP16XX_DSP_START,    OMAP16XX_DSP_SIZE,    MT_DEVICE },
 240  { OMAP16XX_DSPREG_BASE, OMAP16XX_DSPREG_START, OMAP16XX_DSPREG_SIZE, MT_DEVICE },
 241  { OMAP16XX_SRAM_BASE,   OMAP16XX_SRAM_START,   OMAP1610_SRAM_SIZE,   MT_DEVICE }
 242 };
 243
 244 static struct map_desc omap5912_io_desc[] __initdata = {
 245  { OMAP16XX_DSP_BASE,    OMAP16XX_DSP_START,    OMAP16XX_DSP_SIZE,    MT_DEVICE },
 246  { OMAP16XX_DSPREG_BASE, OMAP16XX_DSPREG_START, OMAP16XX_DSPREG_SIZE, MT_DEVICE },
 247 /*
 248  * The OMAP5912 has 250kByte internal SRAM. Because the mapping is baseed on page
 249  * size (4kByte), it seems that the last 2kByte (=0x800) of the 250kByte are not mapped.
 250  * Add additional 2kByte (0x800) so that the last page is mapped and the last 2kByte
 251  * can be used.
 252  */
 253  { OMAP16XX_SRAM_BASE,   OMAP16XX_SRAM_START,   OMAP5912_SRAM_SIZE + 0x800,   MT_DEVICE }
 254 };
 255 #endif
 256
 257 static int initialized = 0;
 258
 259 static void __init _omap_map_io(void)
 260 {
 261         initialized = 1;
 262
 263         /* We have to initialize the IO space mapping before we can run
 264          * cpu_is_omapxxx() macros. */
 265         iotable_init(omap_io_desc, ARRAY_SIZE(omap_io_desc));
 266         omap_check_revision();
 267
 268         /* clear BM to canonicalize CS0 (not CS3) at 0000:0000 */
 269         omap_writel(omap_readl(EMIFS_CONFIG) & 0x0d, EMIFS_CONFIG);
 270
 271 #ifdef CONFIG_ARCH_OMAP730
 272         if (cpu_is_omap730()) {
 273                 iotable_init(omap730_io_desc, ARRAY_SIZE(omap730_io_desc));
 274         }
 275 #endif
 276 #ifdef CONFIG_ARCH_OMAP1510
 277         if (cpu_is_omap1510()) {
 278                 iotable_init(omap1510_io_desc, ARRAY_SIZE(omap1510_io_desc));
 279         }
 280 #endif
 281 #if defined(CONFIG_ARCH_OMAP16XX)
 282         if (cpu_is_omap1610() || cpu_is_omap1710()) {
 283                 iotable_init(omap1610_io_desc, ARRAY_SIZE(omap1610_io_desc));
 284         }
 285         if (cpu_is_omap5912()) {
 286                 iotable_init(omap5912_io_desc, ARRAY_SIZE(omap5912_io_desc));
 287         }
 288 #endif
 289
 290         /* REVISIT: Refer to OMAP5910 Errata, Advisory SYS_1: "Timeout Abort
 291          * on a Posted Write in the TIPB Bridge".
 292          */
 293         omap_writew(0x0, MPU_PUBLIC_TIPB_CNTL);
 294         omap_writew(0x0, MPU_PRIVATE_TIPB_CNTL);
 295
 296         /* Must init clocks early to assure that timer interrupt works
 297          */
 298         clk_init();
 299 }
 300
 301 /*
 302  * This should only get called from board specific init
 303  */
 304 void omap_map_io(void)
 305 {
 306         if (!initialized)
 307                 _omap_map_io();
 308 }
 309
 310 static inline unsigned int omap_serial_in(struct plat_serial8250_port *up,
 311                                           int offset)
 312 {
 313         offset <<= up->regshift;
 314         return (unsigned int)__raw_readb(up->membase + offset);
 315 }
 316
 317 static inline void omap_serial_outp(struct plat_serial8250_port *p, int offset,
 318                                     int value)
 319 {
 320         offset <<= p->regshift;
 321         __raw_writeb(value, p->membase + offset);
 322 }
 323
 324 /*
 325  * Internal UARTs need to be initialized for the 8250 autoconfig to work
 326  * properly.
 327  */
 328 static void __init omap_serial_reset(struct plat_serial8250_port *p)
 329 {
 330         omap_serial_outp(p, UART_OMAP_MDR1, 0x07); /* disable UART */
 331         omap_serial_outp(p, UART_OMAP_MDR1, 0x00); /* enable UART */
 332
 333         if (!cpu_is_omap1510()) {
 334                 omap_serial_outp(p, UART_OMAP_SYSC, 0x01);
 335                 while (!(omap_serial_in(p, UART_OMAP_SYSC) & 0x01));
 336         }
 337 }
 338
 339 static struct plat_serial8250_port serial_platform_data[] = {
 340         {
 341                 .membase        = (char*)IO_ADDRESS(OMAP_UART1_BASE),
 342                 .mapbase        = (unsigned long)OMAP_UART1_BASE,
 343                 .irq            = INT_UART1,
 344                 .flags          = UPF_BOOT_AUTOCONF,
 345                 .iotype         = UPIO_MEM,
 346                 .regshift       = 2,
 347                 .uartclk        = OMAP16XX_BASE_BAUD * 16,
 348         },
 349         {
 350                 .membase        = (char*)IO_ADDRESS(OMAP_UART2_BASE),
 351                 .mapbase        = (unsigned long)OMAP_UART2_BASE,
 352                 .irq            = INT_UART2,
 353                 .flags          = UPF_BOOT_AUTOCONF,
 354                 .iotype         = UPIO_MEM,
 355                 .regshift       = 2,
 356                 .uartclk        = OMAP16XX_BASE_BAUD * 16,
 357         },
 358         {
 359                 .membase        = (char*)IO_ADDRESS(OMAP_UART3_BASE),
 360                 .mapbase        = (unsigned long)OMAP_UART3_BASE,
 361                 .irq            = INT_UART3,
 362                 .flags          = UPF_BOOT_AUTOCONF,
 363                 .iotype         = UPIO_MEM,
 364                 .regshift       = 2,
 365                 .uartclk        = OMAP16XX_BASE_BAUD * 16,
 366         },
 367         { },
 368 };
 369
 370 static struct platform_device serial_device = {
 371         .name                   = "serial8250",
 372         .id                     = 0,
 373         .dev                    = {
 374                 .platform_data  = serial_platform_data,
 375         },
 376 };
 377
 378 /*
 379  * Note that on Innovator-1510 UART2 pins conflict with USB2.
 380  * By default UART2 does not work on Innovator-1510 if you have
 381  * USB OHCI enabled. To use UART2, you must disable USB2 first.
 382  */
 383 void __init omap_serial_init(int ports[OMAP_MAX_NR_PORTS])
 384 {
 385         int i;
 386
 387         if (cpu_is_omap730()) {
 388                 serial_platform_data[0].regshift = 0;
 389                 serial_platform_data[1].regshift = 0;
 390                 serial_platform_data[0].irq = INT_730_UART_MODEM_1;
 391                 serial_platform_data[1].irq = INT_730_UART_MODEM_IRDA_2;
 392         }
 393
 394         if (cpu_is_omap1510()) {
 395                 serial_platform_data[0].uartclk = OMAP1510_BASE_BAUD * 16;
 396                 serial_platform_data[1].uartclk = OMAP1510_BASE_BAUD * 16;
 397                 serial_platform_data[2].uartclk = OMAP1510_BASE_BAUD * 16;
 398         }
 399
 400         for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
 401                 unsigned char reg;
 402
 403                 if (ports[i] == 0) {
 404                         serial_platform_data[i].membase = 0;
 405                         serial_platform_data[i].mapbase = 0;
 406                         continue;
 407                 }
 408
 409                 switch (i) {
 410                 case 0:
 411                         if (cpu_is_omap1510()) {
 412                                 omap_cfg_reg(UART1_TX);
 413                                 omap_cfg_reg(UART1_RTS);
 414                                 if (machine_is_omap_innovator()) {
 415                                         reg = fpga_read(OMAP1510_FPGA_POWER);
 416                                         reg |= OMAP1510_FPGA_PCR_COM1_EN;
 417                                         fpga_write(reg, OMAP1510_FPGA_POWER);
 418                                         udelay(10);
 419                                 }
 420                         }
 421                         break;
 422                 case 1:
 423                         if (cpu_is_omap1510()) {
 424                                 omap_cfg_reg(UART2_TX);
 425                                 omap_cfg_reg(UART2_RTS);
 426                                 if (machine_is_omap_innovator()) {
 427                                         reg = fpga_read(OMAP1510_FPGA_POWER);
 428                                         reg |= OMAP1510_FPGA_PCR_COM2_EN;
 429                                         fpga_write(reg, OMAP1510_FPGA_POWER);
 430                                         udelay(10);
 431                                 }
 432                         }
 433                         break;
 434                 case 2:
 435                         if (cpu_is_omap1510()) {
 436                                 omap_cfg_reg(UART3_TX);
 437                                 omap_cfg_reg(UART3_RX);
 438                         }
 439                         break;
 440                 }
 441                 omap_serial_reset(&serial_platform_data[i]);
 442         }
 443 }
 444
 445 static int __init omap_init(void)
 446 {
 447         return platform_device_register(&serial_device);
 448 }
 449 arch_initcall(omap_init);
 450
 451 #define NO_LENGTH_CHECK 0xffffffff
 452
 453 extern int omap_bootloader_tag_len;
 454 extern u8 omap_bootloader_tag[];
 455
 456 struct omap_board_config_kernel *omap_board_config;
 457 int omap_board_config_size = 0;
 458
 459 static const void *get_config(u16 tag, size_t len, int skip, size_t *len_out)
 460 {
 461         struct omap_board_config_kernel *kinfo = NULL;
 462         int i;
 463
 464 #ifdef CONFIG_OMAP_BOOT_TAG
 465         struct omap_board_config_entry *info = NULL;
 466
 467         if (omap_bootloader_tag_len > 4)
 468                 info = (struct omap_board_config_entry *) omap_bootloader_tag;
 469         while (info != NULL) {
 470                 u8 *next;
 471
 472                 if (info->tag == tag) {
 473                         if (skip == 0)
 474                                 break;
 475                         skip--;
 476                 }
 477
 478                 next = (u8 *) info + sizeof(*info) + info->len;
 479                 if (next >= omap_bootloader_tag + omap_bootloader_tag_len)
 480                         info = NULL;
 481                 else
 482                         info = (struct omap_board_config_entry *) next;
 483         }
 484         if (info != NULL) {
 485                 /* Check the length as a lame attempt to check for
 486                  * binary inconsistancy. */
 487                 if (len != NO_LENGTH_CHECK && info->len != len) {
 488                         printk(KERN_ERR "OMAP peripheral config: Length mismatch with tag %x (want %d, got %d)\n",
 489                                tag, len, info->len);
 490                         return NULL;
 491                 }
 492                 if (len_out != NULL)
 493                         *len_out = info->len;
 494                 return info->data;
 495         }
 496 #endif
 497         /* Try to find the config from the board-specific structures
 498          * in the kernel. */
 499         for (i = 0; i < omap_board_config_size; i++) {
 500                 if (omap_board_config[i].tag == tag) {
 501                         kinfo = &omap_board_config[i];
 502                         break;
 503                 }
 504         }
 505         if (kinfo == NULL)
 506                 return NULL;
 507         return kinfo->data;
 508 }
 509
 510 const void *__omap_get_config(u16 tag, size_t len, int nr)
 511 {
 512         return get_config(tag, len, nr, NULL);
 513 }
 514 EXPORT_SYMBOL(__omap_get_config);
 515
 516 const void *omap_get_var_config(u16 tag, size_t *len)
 517 {
 518         return get_config(tag, NO_LENGTH_CHECK, 0, len);
 519 }
 520 EXPORT_SYMBOL(omap_get_var_config);
 521
 522 static int __init omap_add_serial_console(void)
 523 {
 524         const struct omap_uart_config *info;
 525
 526         info = omap_get_config(OMAP_TAG_UART, struct omap_uart_config);
 527         if (info != NULL && info->console_uart) {
 528                 static char speed[11], *opt = NULL;
 529
 530                 if (info->console_speed) {
 531                         snprintf(speed, sizeof(speed), "%u", info->console_speed);
 532                         opt = speed;
 533                 }
 534                 return add_preferred_console("ttyS", info->console_uart - 1, opt);
 535         }
 536         return 0;
 537 }
 538 console_initcall(omap_add_serial_console);