arch/arm/mach-ixp4xx/omixp-setup.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * arch/arm/mach-ixp4xx/omixp-setup.c
   4  *
   5  * omicron ixp4xx board setup
   6  *      Copyright (C) 2009 OMICRON electronics GmbH
   7  *
   8  * based nslu2-setup.c, ixdp425-setup.c:
   9  *      Copyright (C) 2003-2004 MontaVista Software, Inc.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/serial.h>
  14 #include <linux/serial_8250.h>
  15 #include <linux/mtd/mtd.h>
  16 #include <linux/mtd/partitions.h>
  17 #include <linux/leds.h>
  18
  19 #include <asm/setup.h>
  20 #include <asm/memory.h>
  21 #include <asm/mach-types.h>
  22 #include <asm/mach/arch.h>
  23 #include <asm/mach/flash.h>
  24
  25 #include <mach/hardware.h>
  26
  27 #include "irqs.h"
  28
  29 static struct resource omixp_flash_resources[] = {
  30         {
  31                 .flags  = IORESOURCE_MEM,
  32         }, {
  33                 .flags  = IORESOURCE_MEM,
  34         },
  35 };
  36
  37 static struct mtd_partition omixp_partitions[] = {
  38         {
  39                 .name =         "Recovery Bootloader",
  40                 .size =         0x00020000,
  41                 .offset =       0,
  42         }, {
  43                 .name =         "Calibration Data",
  44                 .size =         0x00020000,
  45                 .offset =       0x00020000,
  46         }, {
  47                 .name =         "Recovery FPGA",
  48                 .size =         0x00020000,
  49                 .offset =       0x00040000,
  50         }, {
  51                 .name =         "Release Bootloader",
  52                 .size =         0x00020000,
  53                 .offset =       0x00060000,
  54         }, {
  55                 .name =         "Release FPGA",
  56                 .size =         0x00020000,
  57                 .offset =       0x00080000,
  58         }, {
  59                 .name =         "Kernel",
  60                 .size =         0x00160000,
  61                 .offset =       0x000a0000,
  62         }, {
  63                 .name =         "Filesystem",
  64                 .size =         0x00C00000,
  65                 .offset =       0x00200000,
  66         }, {
  67                 .name =         "Persistent Storage",
  68                 .size =         0x00200000,
  69                 .offset =       0x00E00000,
  70         },
  71 };
  72
  73 static struct flash_platform_data omixp_flash_data[] = {
  74         {
  75                 .map_name       = "cfi_probe",
  76                 .parts          = omixp_partitions,
  77                 .nr_parts       = ARRAY_SIZE(omixp_partitions),
  78         }, {
  79                 .map_name       = "cfi_probe",
  80                 .parts          = NULL,
  81                 .nr_parts       = 0,
  82         },
  83 };
  84
  85 static struct platform_device omixp_flash_device[] = {
  86         {
  87                 .name           = "IXP4XX-Flash",
  88                 .id             = 0,
  89                 .dev = {
  90                         .platform_data = &omixp_flash_data[0],
  91                 },
  92                 .resource = &omixp_flash_resources[0],
  93                 .num_resources = 1,
  94         }, {
  95                 .name           = "IXP4XX-Flash",
  96                 .id             = 1,
  97                 .dev = {
  98                         .platform_data = &omixp_flash_data[1],
  99                 },
 100                 .resource = &omixp_flash_resources[1],
 101                 .num_resources = 1,
 102         },
 103 };
 104
 105 /* Swap UART's - These boards have the console on UART2. The following
 106  * configuration is used:
 107  *      ttyS0 .. UART2
 108  *      ttyS1 .. UART1
 109  * This way standard images can be used with the kernel that expect
 110  * the console on ttyS0.
 111  */
 112 static struct resource omixp_uart_resources[] = {
 113         {
 114                 .start          = IXP4XX_UART2_BASE_PHYS,
 115                 .end            = IXP4XX_UART2_BASE_PHYS + 0x0fff,
 116                 .flags          = IORESOURCE_MEM,
 117         }, {
 118                 .start          = IXP4XX_UART1_BASE_PHYS,
 119                 .end            = IXP4XX_UART1_BASE_PHYS + 0x0fff,
 120                 .flags          = IORESOURCE_MEM,
 121         },
 122 };
 123
 124 static struct plat_serial8250_port omixp_uart_data[] = {
 125         {
 126                 .mapbase        = IXP4XX_UART2_BASE_PHYS,
 127                 .membase        = (char *)IXP4XX_UART2_BASE_VIRT + REG_OFFSET,
 128                 .irq            = IRQ_IXP4XX_UART2,
 129                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST,
 130                 .iotype         = UPIO_MEM,
 131                 .regshift       = 2,
 132                 .uartclk        = IXP4XX_UART_XTAL,
 133         }, {
 134                 .mapbase        = IXP4XX_UART1_BASE_PHYS,
 135                 .membase        = (char *)IXP4XX_UART1_BASE_VIRT + REG_OFFSET,
 136                 .irq            = IRQ_IXP4XX_UART1,
 137                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST,
 138                 .iotype         = UPIO_MEM,
 139                 .regshift       = 2,
 140                 .uartclk        = IXP4XX_UART_XTAL,
 141         }, {
 142                 /* list termination */
 143         }
 144 };
 145
 146 static struct platform_device omixp_uart = {
 147         .name                   = "serial8250",
 148         .id                     = PLAT8250_DEV_PLATFORM,
 149         .dev.platform_data      = omixp_uart_data,
 150         .num_resources          = 2,
 151         .resource               = omixp_uart_resources,
 152 };
 153
 154 static struct gpio_led mic256_led_pins[] = {
 155         {
 156                 .name           = "LED-A",
 157                 .gpio           = 7,
 158         },
 159 };
 160
 161 static struct gpio_led_platform_data mic256_led_data = {
 162         .num_leds               = ARRAY_SIZE(mic256_led_pins),
 163         .leds                   = mic256_led_pins,
 164 };
 165
 166 static struct platform_device mic256_leds = {
 167         .name                   = "leds-gpio",
 168         .id                     = -1,
 169         .dev.platform_data      = &mic256_led_data,
 170 };
 171
 172 /* Built-in 10/100 Ethernet MAC interfaces */
 173 static struct resource ixp425_npeb_resources[] = {
 174         {
 175                 .start          = IXP4XX_EthB_BASE_PHYS,
 176                 .end            = IXP4XX_EthB_BASE_PHYS + 0x0fff,
 177                 .flags          = IORESOURCE_MEM,
 178         },
 179 };
 180
 181 static struct resource ixp425_npec_resources[] = {
 182         {
 183                 .start          = IXP4XX_EthC_BASE_PHYS,
 184                 .end            = IXP4XX_EthC_BASE_PHYS + 0x0fff,
 185                 .flags          = IORESOURCE_MEM,
 186         },
 187 };
 188
 189 static struct eth_plat_info ixdp425_plat_eth[] = {
 190         {
 191                 .phy            = 0,
 192                 .rxq            = 3,
 193                 .txreadyq       = 20,
 194         }, {
 195                 .phy            = 1,
 196                 .rxq            = 4,
 197                 .txreadyq       = 21,
 198         },
 199 };
 200
 201 static struct platform_device ixdp425_eth[] = {
 202         {
 203                 .name                   = "ixp4xx_eth",
 204                 .id                     = IXP4XX_ETH_NPEB,
 205                 .dev.platform_data      = ixdp425_plat_eth,
 206                 .num_resources          = ARRAY_SIZE(ixp425_npeb_resources),
 207                 .resource               = ixp425_npeb_resources,
 208         }, {
 209                 .name                   = "ixp4xx_eth",
 210                 .id                     = IXP4XX_ETH_NPEC,
 211                 .dev.platform_data      = ixdp425_plat_eth + 1,
 212                 .num_resources          = ARRAY_SIZE(ixp425_npec_resources),
 213                 .resource               = ixp425_npec_resources,
 214         },
 215 };
 216
 217
 218 static struct platform_device *devixp_pldev[] __initdata = {
 219         &omixp_uart,
 220         &omixp_flash_device[0],
 221         &ixdp425_eth[0],
 222         &ixdp425_eth[1],
 223 };
 224
 225 static struct platform_device *mic256_pldev[] __initdata = {
 226         &omixp_uart,
 227         &omixp_flash_device[0],
 228         &mic256_leds,
 229         &ixdp425_eth[0],
 230         &ixdp425_eth[1],
 231 };
 232
 233 static struct platform_device *miccpt_pldev[] __initdata = {
 234         &omixp_uart,
 235         &omixp_flash_device[0],
 236         &omixp_flash_device[1],
 237         &ixdp425_eth[0],
 238         &ixdp425_eth[1],
 239 };
 240
 241 static void __init omixp_init(void)
 242 {
 243         ixp4xx_sys_init();
 244
 245         /* 16MiB Boot Flash */
 246         omixp_flash_resources[0].start = IXP4XX_EXP_BUS_BASE(0);
 247         omixp_flash_resources[0].end   = IXP4XX_EXP_BUS_END(0);
 248
 249         /* 32 MiB Data Flash */
 250         omixp_flash_resources[1].start = IXP4XX_EXP_BUS_BASE(2);
 251         omixp_flash_resources[1].end   = IXP4XX_EXP_BUS_END(2);
 252
 253         if (machine_is_devixp())
 254                 platform_add_devices(devixp_pldev, ARRAY_SIZE(devixp_pldev));
 255         else if (machine_is_miccpt())
 256                 platform_add_devices(miccpt_pldev, ARRAY_SIZE(miccpt_pldev));
 257         else if (machine_is_mic256())
 258                 platform_add_devices(mic256_pldev, ARRAY_SIZE(mic256_pldev));
 259 }
 260
 261 #ifdef CONFIG_MACH_DEVIXP
 262 MACHINE_START(DEVIXP, "Omicron DEVIXP")
 263         .atag_offset    = 0x100,
 264         .map_io         = ixp4xx_map_io,
 265         .init_early     = ixp4xx_init_early,
 266         .init_irq       = ixp4xx_init_irq,
 267         .init_time      = ixp4xx_timer_init,
 268         .init_machine   = omixp_init,
 269         .restart        = ixp4xx_restart,
 270 MACHINE_END
 271 #endif
 272
 273 #ifdef CONFIG_MACH_MICCPT
 274 MACHINE_START(MICCPT, "Omicron MICCPT")
 275         .atag_offset    = 0x100,
 276         .map_io         = ixp4xx_map_io,
 277         .init_early     = ixp4xx_init_early,
 278         .init_irq       = ixp4xx_init_irq,
 279         .init_time      = ixp4xx_timer_init,
 280         .init_machine   = omixp_init,
 281 #if defined(CONFIG_PCI)
 282         .dma_zone_size  = SZ_64M,
 283 #endif
 284         .restart        = ixp4xx_restart,
 285 MACHINE_END
 286 #endif
 287
 288 #ifdef CONFIG_MACH_MIC256
 289 MACHINE_START(MIC256, "Omicron MIC256")
 290         .atag_offset    = 0x100,
 291         .map_io         = ixp4xx_map_io,
 292         .init_early     = ixp4xx_init_early,
 293         .init_irq       = ixp4xx_init_irq,
 294         .init_time      = ixp4xx_timer_init,
 295         .init_machine   = omixp_init,
 296         .restart        = ixp4xx_restart,
 297 MACHINE_END
 298 #endif