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 eth_plat_info ixdp425_plat_eth[] = {
 174         {
 175                 .phy            = 0,
 176                 .rxq            = 3,
 177                 .txreadyq       = 20,
 178         }, {
 179                 .phy            = 1,
 180                 .rxq            = 4,
 181                 .txreadyq       = 21,
 182         },
 183 };
 184
 185 static struct platform_device ixdp425_eth[] = {
 186         {
 187                 .name                   = "ixp4xx_eth",
 188                 .id                     = IXP4XX_ETH_NPEB,
 189                 .dev.platform_data      = ixdp425_plat_eth,
 190         }, {
 191                 .name                   = "ixp4xx_eth",
 192                 .id                     = IXP4XX_ETH_NPEC,
 193                 .dev.platform_data      = ixdp425_plat_eth + 1,
 194         },
 195 };
 196
 197
 198 static struct platform_device *devixp_pldev[] __initdata = {
 199         &omixp_uart,
 200         &omixp_flash_device[0],
 201         &ixdp425_eth[0],
 202         &ixdp425_eth[1],
 203 };
 204
 205 static struct platform_device *mic256_pldev[] __initdata = {
 206         &omixp_uart,
 207         &omixp_flash_device[0],
 208         &mic256_leds,
 209         &ixdp425_eth[0],
 210         &ixdp425_eth[1],
 211 };
 212
 213 static struct platform_device *miccpt_pldev[] __initdata = {
 214         &omixp_uart,
 215         &omixp_flash_device[0],
 216         &omixp_flash_device[1],
 217         &ixdp425_eth[0],
 218         &ixdp425_eth[1],
 219 };
 220
 221 static void __init omixp_init(void)
 222 {
 223         ixp4xx_sys_init();
 224
 225         /* 16MiB Boot Flash */
 226         omixp_flash_resources[0].start = IXP4XX_EXP_BUS_BASE(0);
 227         omixp_flash_resources[0].end   = IXP4XX_EXP_BUS_END(0);
 228
 229         /* 32 MiB Data Flash */
 230         omixp_flash_resources[1].start = IXP4XX_EXP_BUS_BASE(2);
 231         omixp_flash_resources[1].end   = IXP4XX_EXP_BUS_END(2);
 232
 233         if (machine_is_devixp())
 234                 platform_add_devices(devixp_pldev, ARRAY_SIZE(devixp_pldev));
 235         else if (machine_is_miccpt())
 236                 platform_add_devices(miccpt_pldev, ARRAY_SIZE(miccpt_pldev));
 237         else if (machine_is_mic256())
 238                 platform_add_devices(mic256_pldev, ARRAY_SIZE(mic256_pldev));
 239 }
 240
 241 #ifdef CONFIG_MACH_DEVIXP
 242 MACHINE_START(DEVIXP, "Omicron DEVIXP")
 243         .atag_offset    = 0x100,
 244         .map_io         = ixp4xx_map_io,
 245         .init_early     = ixp4xx_init_early,
 246         .init_irq       = ixp4xx_init_irq,
 247         .init_time      = ixp4xx_timer_init,
 248         .init_machine   = omixp_init,
 249         .restart        = ixp4xx_restart,
 250 MACHINE_END
 251 #endif
 252
 253 #ifdef CONFIG_MACH_MICCPT
 254 MACHINE_START(MICCPT, "Omicron MICCPT")
 255         .atag_offset    = 0x100,
 256         .map_io         = ixp4xx_map_io,
 257         .init_early     = ixp4xx_init_early,
 258         .init_irq       = ixp4xx_init_irq,
 259         .init_time      = ixp4xx_timer_init,
 260         .init_machine   = omixp_init,
 261 #if defined(CONFIG_PCI)
 262         .dma_zone_size  = SZ_64M,
 263 #endif
 264         .restart        = ixp4xx_restart,
 265 MACHINE_END
 266 #endif
 267
 268 #ifdef CONFIG_MACH_MIC256
 269 MACHINE_START(MIC256, "Omicron MIC256")
 270         .atag_offset    = 0x100,
 271         .map_io         = ixp4xx_map_io,
 272         .init_early     = ixp4xx_init_early,
 273         .init_irq       = ixp4xx_init_irq,
 274         .init_time      = ixp4xx_timer_init,
 275         .init_machine   = omixp_init,
 276         .restart        = ixp4xx_restart,
 277 MACHINE_END
 278 #endif