arch/arm/mach-vexpress/v2m.c

   1 /*
   2  * Versatile Express V2M Motherboard Support
   3  */
   4 #include <linux/clocksource.h>
   5 #include <linux/device.h>
   6 #include <linux/amba/bus.h>
   7 #include <linux/amba/mmci.h>
   8 #include <linux/io.h>
   9 #include <linux/clocksource.h>
  10 #include <linux/smp.h>
  11 #include <linux/init.h>
  12 #include <linux/of_address.h>
  13 #include <linux/of_fdt.h>
  14 #include <linux/of_irq.h>
  15 #include <linux/of_platform.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/ata_platform.h>
  18 #include <linux/smsc911x.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/usb/isp1760.h>
  21 #include <linux/mtd/physmap.h>
  22 #include <linux/regulator/fixed.h>
  23 #include <linux/regulator/machine.h>
  24 #include <linux/vexpress.h>
  25 #include <linux/clk-provider.h>
  26 #include <linux/clkdev.h>
  27
  28 #include <asm/mach-types.h>
  29 #include <asm/sizes.h>
  30 #include <asm/mach/arch.h>
  31 #include <asm/mach/map.h>
  32 #include <asm/mach/time.h>
  33 #include <asm/hardware/arm_timer.h>
  34 #include <asm/hardware/cache-l2x0.h>
  35 #include <asm/hardware/timer-sp.h>
  36
  37 #include <mach/ct-ca9x4.h>
  38 #include <mach/motherboard.h>
  39
  40 #include <plat/sched_clock.h>
  41 #include <plat/platsmp.h>
  42
  43 #include "core.h"
  44
  45 #define V2M_PA_CS0      0x40000000
  46 #define V2M_PA_CS1      0x44000000
  47 #define V2M_PA_CS2      0x48000000
  48 #define V2M_PA_CS3      0x4c000000
  49 #define V2M_PA_CS7      0x10000000
  50
  51 static struct map_desc v2m_io_desc[] __initdata = {
  52         {
  53                 .virtual        = V2M_PERIPH,
  54                 .pfn            = __phys_to_pfn(V2M_PA_CS7),
  55                 .length         = SZ_128K,
  56                 .type           = MT_DEVICE,
  57         },
  58 };
  59
  60 static void __init v2m_sp804_init(void __iomem *base, unsigned int irq)
  61 {
  62         if (WARN_ON(!base || irq == NO_IRQ))
  63                 return;
  64
  65         sp804_clocksource_init(base + TIMER_2_BASE, "v2m-timer1");
  66         sp804_clockevents_init(base + TIMER_1_BASE, irq, "v2m-timer0");
  67 }
  68
  69
  70 static struct resource v2m_pcie_i2c_resource = {
  71         .start  = V2M_SERIAL_BUS_PCI,
  72         .end    = V2M_SERIAL_BUS_PCI + SZ_4K - 1,
  73         .flags  = IORESOURCE_MEM,
  74 };
  75
  76 static struct platform_device v2m_pcie_i2c_device = {
  77         .name           = "versatile-i2c",
  78         .id             = 0,
  79         .num_resources  = 1,
  80         .resource       = &v2m_pcie_i2c_resource,
  81 };
  82
  83 static struct resource v2m_ddc_i2c_resource = {
  84         .start  = V2M_SERIAL_BUS_DVI,
  85         .end    = V2M_SERIAL_BUS_DVI + SZ_4K - 1,
  86         .flags  = IORESOURCE_MEM,
  87 };
  88
  89 static struct platform_device v2m_ddc_i2c_device = {
  90         .name           = "versatile-i2c",
  91         .id             = 1,
  92         .num_resources  = 1,
  93         .resource       = &v2m_ddc_i2c_resource,
  94 };
  95
  96 static struct resource v2m_eth_resources[] = {
  97         {
  98                 .start  = V2M_LAN9118,
  99                 .end    = V2M_LAN9118 + SZ_64K - 1,
 100                 .flags  = IORESOURCE_MEM,
 101         }, {
 102                 .start  = IRQ_V2M_LAN9118,
 103                 .end    = IRQ_V2M_LAN9118,
 104                 .flags  = IORESOURCE_IRQ,
 105         },
 106 };
 107
 108 static struct smsc911x_platform_config v2m_eth_config = {
 109         .flags          = SMSC911X_USE_32BIT,
 110         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_HIGH,
 111         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
 112         .phy_interface  = PHY_INTERFACE_MODE_MII,
 113 };
 114
 115 static struct platform_device v2m_eth_device = {
 116         .name           = "smsc911x",
 117         .id             = -1,
 118         .resource       = v2m_eth_resources,
 119         .num_resources  = ARRAY_SIZE(v2m_eth_resources),
 120         .dev.platform_data = &v2m_eth_config,
 121 };
 122
 123 static struct regulator_consumer_supply v2m_eth_supplies[] = {
 124         REGULATOR_SUPPLY("vddvario", "smsc911x"),
 125         REGULATOR_SUPPLY("vdd33a", "smsc911x"),
 126 };
 127
 128 static struct resource v2m_usb_resources[] = {
 129         {
 130                 .start  = V2M_ISP1761,
 131                 .end    = V2M_ISP1761 + SZ_128K - 1,
 132                 .flags  = IORESOURCE_MEM,
 133         }, {
 134                 .start  = IRQ_V2M_ISP1761,
 135                 .end    = IRQ_V2M_ISP1761,
 136                 .flags  = IORESOURCE_IRQ,
 137         },
 138 };
 139
 140 static struct isp1760_platform_data v2m_usb_config = {
 141         .is_isp1761             = true,
 142         .bus_width_16           = false,
 143         .port1_otg              = true,
 144         .analog_oc              = false,
 145         .dack_polarity_high     = false,
 146         .dreq_polarity_high     = false,
 147 };
 148
 149 static struct platform_device v2m_usb_device = {
 150         .name           = "isp1760",
 151         .id             = -1,
 152         .resource       = v2m_usb_resources,
 153         .num_resources  = ARRAY_SIZE(v2m_usb_resources),
 154         .dev.platform_data = &v2m_usb_config,
 155 };
 156
 157 static struct physmap_flash_data v2m_flash_data = {
 158         .width          = 4,
 159 };
 160
 161 static struct resource v2m_flash_resources[] = {
 162         {
 163                 .start  = V2M_NOR0,
 164                 .end    = V2M_NOR0 + SZ_64M - 1,
 165                 .flags  = IORESOURCE_MEM,
 166         }, {
 167                 .start  = V2M_NOR1,
 168                 .end    = V2M_NOR1 + SZ_64M - 1,
 169                 .flags  = IORESOURCE_MEM,
 170         },
 171 };
 172
 173 static struct platform_device v2m_flash_device = {
 174         .name           = "physmap-flash",
 175         .id             = -1,
 176         .resource       = v2m_flash_resources,
 177         .num_resources  = ARRAY_SIZE(v2m_flash_resources),
 178         .dev.platform_data = &v2m_flash_data,
 179 };
 180
 181 static struct pata_platform_info v2m_pata_data = {
 182         .ioport_shift   = 2,
 183 };
 184
 185 static struct resource v2m_pata_resources[] = {
 186         {
 187                 .start  = V2M_CF,
 188                 .end    = V2M_CF + 0xff,
 189                 .flags  = IORESOURCE_MEM,
 190         }, {
 191                 .start  = V2M_CF + 0x100,
 192                 .end    = V2M_CF + SZ_4K - 1,
 193                 .flags  = IORESOURCE_MEM,
 194         },
 195 };
 196
 197 static struct platform_device v2m_cf_device = {
 198         .name           = "pata_platform",
 199         .id             = -1,
 200         .resource       = v2m_pata_resources,
 201         .num_resources  = ARRAY_SIZE(v2m_pata_resources),
 202         .dev.platform_data = &v2m_pata_data,
 203 };
 204
 205 static struct mmci_platform_data v2m_mmci_data = {
 206         .ocr_mask       = MMC_VDD_32_33|MMC_VDD_33_34,
 207         .gpio_wp        = VEXPRESS_GPIO_MMC_WPROT,
 208         .gpio_cd        = VEXPRESS_GPIO_MMC_CARDIN,
 209 };
 210
 211 static struct resource v2m_sysreg_resources[] = {
 212         {
 213                 .start  = V2M_SYSREGS,
 214                 .end    = V2M_SYSREGS + 0xfff,
 215                 .flags  = IORESOURCE_MEM,
 216         },
 217 };
 218
 219 static struct platform_device v2m_sysreg_device = {
 220         .name           = "vexpress-sysreg",
 221         .id             = -1,
 222         .resource       = v2m_sysreg_resources,
 223         .num_resources  = ARRAY_SIZE(v2m_sysreg_resources),
 224 };
 225
 226 static struct platform_device v2m_muxfpga_device = {
 227         .name           = "vexpress-muxfpga",
 228         .id             = 0,
 229         .num_resources  = 1,
 230         .resource       = (struct resource []) {
 231                 VEXPRESS_RES_FUNC(0, 7),
 232         }
 233 };
 234
 235 static struct platform_device v2m_shutdown_device = {
 236         .name           = "vexpress-shutdown",
 237         .id             = 0,
 238         .num_resources  = 1,
 239         .resource       = (struct resource []) {
 240                 VEXPRESS_RES_FUNC(0, 8),
 241         }
 242 };
 243
 244 static struct platform_device v2m_reboot_device = {
 245         .name           = "vexpress-reboot",
 246         .id             = 0,
 247         .num_resources  = 1,
 248         .resource       = (struct resource []) {
 249                 VEXPRESS_RES_FUNC(0, 9),
 250         }
 251 };
 252
 253 static struct platform_device v2m_dvimode_device = {
 254         .name           = "vexpress-dvimode",
 255         .id             = 0,
 256         .num_resources  = 1,
 257         .resource       = (struct resource []) {
 258                 VEXPRESS_RES_FUNC(0, 11),
 259         }
 260 };
 261
 262 static AMBA_APB_DEVICE(aaci,  "mb:aaci",  0, V2M_AACI, IRQ_V2M_AACI, NULL);
 263 static AMBA_APB_DEVICE(mmci,  "mb:mmci",  0, V2M_MMCI, IRQ_V2M_MMCI, &v2m_mmci_data);
 264 static AMBA_APB_DEVICE(kmi0,  "mb:kmi0",  0, V2M_KMI0, IRQ_V2M_KMI0, NULL);
 265 static AMBA_APB_DEVICE(kmi1,  "mb:kmi1",  0, V2M_KMI1, IRQ_V2M_KMI1, NULL);
 266 static AMBA_APB_DEVICE(uart0, "mb:uart0", 0, V2M_UART0, IRQ_V2M_UART0, NULL);
 267 static AMBA_APB_DEVICE(uart1, "mb:uart1", 0, V2M_UART1, IRQ_V2M_UART1, NULL);
 268 static AMBA_APB_DEVICE(uart2, "mb:uart2", 0, V2M_UART2, IRQ_V2M_UART2, NULL);
 269 static AMBA_APB_DEVICE(uart3, "mb:uart3", 0, V2M_UART3, IRQ_V2M_UART3, NULL);
 270 static AMBA_APB_DEVICE(wdt,   "mb:wdt",   0, V2M_WDT, IRQ_V2M_WDT, NULL);
 271 static AMBA_APB_DEVICE(rtc,   "mb:rtc",   0, V2M_RTC, IRQ_V2M_RTC, NULL);
 272
 273 static struct amba_device *v2m_amba_devs[] __initdata = {
 274         &aaci_device,
 275         &mmci_device,
 276         &kmi0_device,
 277         &kmi1_device,
 278         &uart0_device,
 279         &uart1_device,
 280         &uart2_device,
 281         &uart3_device,
 282         &wdt_device,
 283         &rtc_device,
 284 };
 285
 286 static void __init v2m_timer_init(void)
 287 {
 288         vexpress_clk_init(ioremap(V2M_SYSCTL, SZ_4K));
 289         v2m_sp804_init(ioremap(V2M_TIMER01, SZ_4K), IRQ_V2M_TIMER0);
 290 }
 291
 292 static void __init v2m_init_early(void)
 293 {
 294         if (ct_desc->init_early)
 295                 ct_desc->init_early();
 296         versatile_sched_clock_init(vexpress_get_24mhz_clock_base(), 24000000);
 297 }
 298
 299 struct ct_desc *ct_desc;
 300
 301 static struct ct_desc *ct_descs[] __initdata = {
 302 #ifdef CONFIG_ARCH_VEXPRESS_CA9X4
 303         &ct_ca9x4_desc,
 304 #endif
 305 };
 306
 307 static void __init v2m_populate_ct_desc(void)
 308 {
 309         int i;
 310         u32 current_tile_id;
 311
 312         ct_desc = NULL;
 313         current_tile_id = vexpress_get_procid(VEXPRESS_SITE_MASTER)
 314                                 & V2M_CT_ID_MASK;
 315
 316         for (i = 0; i < ARRAY_SIZE(ct_descs) && !ct_desc; ++i)
 317                 if (ct_descs[i]->id == current_tile_id)
 318                         ct_desc = ct_descs[i];
 319
 320         if (!ct_desc)
 321                 panic("vexpress: this kernel does not support core tile ID 0x%08x when booting via ATAGs.\n"
 322                       "You may need a device tree blob or a different kernel to boot on this board.\n",
 323                       current_tile_id);
 324 }
 325
 326 static void __init v2m_map_io(void)
 327 {
 328         iotable_init(v2m_io_desc, ARRAY_SIZE(v2m_io_desc));
 329         vexpress_sysreg_early_init(ioremap(V2M_SYSREGS, SZ_4K));
 330         v2m_populate_ct_desc();
 331         ct_desc->map_io();
 332 }
 333
 334 static void __init v2m_init_irq(void)
 335 {
 336         ct_desc->init_irq();
 337 }
 338
 339 static void __init v2m_init(void)
 340 {
 341         int i;
 342
 343         regulator_register_fixed(0, v2m_eth_supplies,
 344                         ARRAY_SIZE(v2m_eth_supplies));
 345
 346         platform_device_register(&v2m_muxfpga_device);
 347         platform_device_register(&v2m_shutdown_device);
 348         platform_device_register(&v2m_reboot_device);
 349         platform_device_register(&v2m_dvimode_device);
 350
 351         platform_device_register(&v2m_sysreg_device);
 352         platform_device_register(&v2m_pcie_i2c_device);
 353         platform_device_register(&v2m_ddc_i2c_device);
 354         platform_device_register(&v2m_flash_device);
 355         platform_device_register(&v2m_cf_device);
 356         platform_device_register(&v2m_eth_device);
 357         platform_device_register(&v2m_usb_device);
 358
 359         for (i = 0; i < ARRAY_SIZE(v2m_amba_devs); i++)
 360                 amba_device_register(v2m_amba_devs[i], &iomem_resource);
 361
 362         ct_desc->init_tile();
 363 }
 364
 365 MACHINE_START(VEXPRESS, "ARM-Versatile Express")
 366         .atag_offset    = 0x100,
 367         .smp            = smp_ops(vexpress_smp_ops),
 368         .map_io         = v2m_map_io,
 369         .init_early     = v2m_init_early,
 370         .init_irq       = v2m_init_irq,
 371         .init_time      = v2m_timer_init,
 372         .init_machine   = v2m_init,
 373 MACHINE_END
 374
 375 static struct map_desc v2m_rs1_io_desc __initdata = {
 376         .virtual        = V2M_PERIPH,
 377         .pfn            = __phys_to_pfn(0x1c000000),
 378         .length         = SZ_2M,
 379         .type           = MT_DEVICE,
 380 };
 381
 382 static int __init v2m_dt_scan_memory_map(unsigned long node, const char *uname,
 383                 int depth, void *data)
 384 {
 385         const char **map = data;
 386
 387         if (strcmp(uname, "motherboard") != 0)
 388                 return 0;
 389
 390         *map = of_get_flat_dt_prop(node, "arm,v2m-memory-map", NULL);
 391
 392         return 1;
 393 }
 394
 395 void __init v2m_dt_map_io(void)
 396 {
 397         const char *map = NULL;
 398
 399         of_scan_flat_dt(v2m_dt_scan_memory_map, &map);
 400
 401         if (map && strcmp(map, "rs1") == 0)
 402                 iotable_init(&v2m_rs1_io_desc, 1);
 403         else
 404                 iotable_init(v2m_io_desc, ARRAY_SIZE(v2m_io_desc));
 405
 406 #if defined(CONFIG_SMP)
 407         vexpress_dt_smp_map_io();
 408 #endif
 409 }
 410
 411 void __init v2m_dt_init_early(void)
 412 {
 413         u32 dt_hbi;
 414
 415         vexpress_sysreg_of_early_init();
 416
 417         /* Confirm board type against DT property, if available */
 418         if (of_property_read_u32(of_allnodes, "arm,hbi", &dt_hbi) == 0) {
 419                 u32 hbi = vexpress_get_hbi(VEXPRESS_SITE_MASTER);
 420
 421                 if (WARN_ON(dt_hbi != hbi))
 422                         pr_warning("vexpress: DT HBI (%x) is not matching "
 423                                         "hardware (%x)!\n", dt_hbi, hbi);
 424         }
 425 }
 426
 427 static void __init v2m_dt_timer_init(void)
 428 {
 429         of_clk_init(NULL);
 430
 431         clocksource_of_init();
 432
 433         versatile_sched_clock_init(vexpress_get_24mhz_clock_base(),
 434                                 24000000);
 435 }
 436
 437 static const struct of_device_id v2m_dt_bus_match[] __initconst = {
 438         { .compatible = "simple-bus", },
 439         { .compatible = "arm,amba-bus", },
 440         { .compatible = "arm,vexpress,config-bus", },
 441         {}
 442 };
 443
 444 static void __init v2m_dt_init(void)
 445 {
 446         l2x0_of_init(0x00400000, 0xfe0fffff);
 447         of_platform_populate(NULL, v2m_dt_bus_match, NULL, NULL);
 448 }
 449
 450 static const char * const v2m_dt_match[] __initconst = {
 451         "arm,vexpress",
 452         NULL,
 453 };
 454
 455 DT_MACHINE_START(VEXPRESS_DT, "ARM-Versatile Express")
 456         .dt_compat      = v2m_dt_match,
 457         .smp            = smp_ops(vexpress_smp_ops),
 458         .smp_init       = smp_init_ops(vexpress_smp_init_ops),
 459         .map_io         = v2m_dt_map_io,
 460         .init_early     = v2m_dt_init_early,
 461         .init_time      = v2m_dt_timer_init,
 462         .init_machine   = v2m_dt_init,
 463 MACHINE_END