2 * arch/arm/mach-ixp4xx/common.c
4 * Generic code shared across all IXP4XX platforms
6 * Maintainer: Deepak Saxena <dsaxena@plexity.net>
8 * Copyright 2002 (c) Intel Corporation
9 * Copyright 2003-2004 (c) MontaVista, Software, Inc.
11 * This file is licensed under the terms of the GNU General Public
12 * License version 2. This program is licensed "as is" without any
13 * warranty of any kind, whether express or implied.
16 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/serial.h>
20 #include <linux/tty.h>
21 #include <linux/platform_device.h>
22 #include <linux/serial_core.h>
23 #include <linux/interrupt.h>
24 #include <linux/bitops.h>
26 #include <linux/export.h>
27 #include <linux/cpu.h>
28 #include <linux/pci.h>
29 #include <linux/sched_clock.h>
30 #include <linux/bitops.h>
31 #include <linux/irqchip/irq-ixp4xx.h>
32 #include <linux/platform_data/timer-ixp4xx.h>
34 #include <mach/hardware.h>
36 #include <linux/uaccess.h>
37 #include <asm/pgtable.h>
39 #include <asm/exception.h>
41 #include <asm/system_misc.h>
42 #include <asm/mach/map.h>
43 #include <asm/mach/irq.h>
44 #include <asm/mach/time.h>
48 #define IXP4XX_TIMER_FREQ 66666000
50 /*************************************************************************
51 * IXP4xx chipset I/O mapping
52 *************************************************************************/
53 static struct map_desc ixp4xx_io_desc[] __initdata = {
54 { /* UART, Interrupt ctrl, GPIO, timers, NPEs, MACs, USB .... */
55 .virtual = (unsigned long)IXP4XX_PERIPHERAL_BASE_VIRT,
56 .pfn = __phys_to_pfn(IXP4XX_PERIPHERAL_BASE_PHYS),
57 .length = IXP4XX_PERIPHERAL_REGION_SIZE,
59 }, { /* Expansion Bus Config Registers */
60 .virtual = (unsigned long)IXP4XX_EXP_CFG_BASE_VIRT,
61 .pfn = __phys_to_pfn(IXP4XX_EXP_CFG_BASE_PHYS),
62 .length = IXP4XX_EXP_CFG_REGION_SIZE,
64 }, { /* PCI Registers */
65 .virtual = (unsigned long)IXP4XX_PCI_CFG_BASE_VIRT,
66 .pfn = __phys_to_pfn(IXP4XX_PCI_CFG_BASE_PHYS),
67 .length = IXP4XX_PCI_CFG_REGION_SIZE,
72 void __init ixp4xx_map_io(void)
74 iotable_init(ixp4xx_io_desc, ARRAY_SIZE(ixp4xx_io_desc));
77 void __init ixp4xx_init_irq(void)
80 * ixp4xx does not implement the XScale PWRMODE register
81 * so it must not call cpu_do_idle().
83 cpu_idle_poll_ctrl(true);
85 ixp4xx_irq_init(IXP4XX_INTC_BASE_PHYS,
86 (cpu_is_ixp46x() || cpu_is_ixp43x()));
89 void __init ixp4xx_timer_init(void)
91 return ixp4xx_timer_setup(IXP4XX_TIMER_BASE_PHYS,
96 static struct pxa2xx_udc_mach_info ixp4xx_udc_info;
98 void __init ixp4xx_set_udc_info(struct pxa2xx_udc_mach_info *info)
100 memcpy(&ixp4xx_udc_info, info, sizeof *info);
103 static struct resource ixp4xx_udc_resources[] = {
107 .flags = IORESOURCE_MEM,
110 .start = IRQ_IXP4XX_USB,
111 .end = IRQ_IXP4XX_USB,
112 .flags = IORESOURCE_IRQ,
116 static struct resource ixp4xx_gpio_resource[] = {
118 .start = IXP4XX_GPIO_BASE_PHYS,
119 .end = IXP4XX_GPIO_BASE_PHYS + 0xfff,
120 .flags = IORESOURCE_MEM,
124 static struct platform_device ixp4xx_gpio_device = {
125 .name = "ixp4xx-gpio",
128 .coherent_dma_mask = DMA_BIT_MASK(32),
130 .resource = ixp4xx_gpio_resource,
131 .num_resources = ARRAY_SIZE(ixp4xx_gpio_resource),
135 * USB device controller. The IXP4xx uses the same controller as PXA25X,
136 * so we just use the same device.
138 static struct platform_device ixp4xx_udc_device = {
139 .name = "pxa25x-udc",
142 .resource = ixp4xx_udc_resources,
144 .platform_data = &ixp4xx_udc_info,
148 static struct resource ixp4xx_npe_resources[] = {
150 .start = IXP4XX_NPEA_BASE_PHYS,
151 .end = IXP4XX_NPEA_BASE_PHYS + 0xfff,
152 .flags = IORESOURCE_MEM,
155 .start = IXP4XX_NPEB_BASE_PHYS,
156 .end = IXP4XX_NPEB_BASE_PHYS + 0xfff,
157 .flags = IORESOURCE_MEM,
160 .start = IXP4XX_NPEC_BASE_PHYS,
161 .end = IXP4XX_NPEC_BASE_PHYS + 0xfff,
162 .flags = IORESOURCE_MEM,
167 static struct platform_device ixp4xx_npe_device = {
168 .name = "ixp4xx-npe",
170 .num_resources = ARRAY_SIZE(ixp4xx_npe_resources),
171 .resource = ixp4xx_npe_resources,
174 static struct resource ixp4xx_qmgr_resources[] = {
176 .start = IXP4XX_QMGR_BASE_PHYS,
177 .end = IXP4XX_QMGR_BASE_PHYS + 0x3fff,
178 .flags = IORESOURCE_MEM,
181 .start = IRQ_IXP4XX_QM1,
182 .end = IRQ_IXP4XX_QM1,
183 .flags = IORESOURCE_IRQ,
186 .start = IRQ_IXP4XX_QM2,
187 .end = IRQ_IXP4XX_QM2,
188 .flags = IORESOURCE_IRQ,
192 static struct platform_device ixp4xx_qmgr_device = {
193 .name = "ixp4xx-qmgr",
195 .num_resources = ARRAY_SIZE(ixp4xx_qmgr_resources),
196 .resource = ixp4xx_qmgr_resources,
199 static struct platform_device *ixp4xx_devices[] __initdata = {
206 static struct resource ixp46x_i2c_resources[] = {
210 .flags = IORESOURCE_MEM,
213 .start = IRQ_IXP4XX_I2C,
214 .end = IRQ_IXP4XX_I2C,
215 .flags = IORESOURCE_IRQ
220 * I2C controller. The IXP46x uses the same block as the IOP3xx, so
221 * we just use the same device name.
223 static struct platform_device ixp46x_i2c_controller = {
224 .name = "IOP3xx-I2C",
227 .resource = ixp46x_i2c_resources
230 static struct platform_device *ixp46x_devices[] __initdata = {
231 &ixp46x_i2c_controller
234 unsigned long ixp4xx_exp_bus_size;
235 EXPORT_SYMBOL(ixp4xx_exp_bus_size);
237 void __init ixp4xx_sys_init(void)
239 ixp4xx_exp_bus_size = SZ_16M;
241 platform_add_devices(ixp4xx_devices, ARRAY_SIZE(ixp4xx_devices));
243 if (cpu_is_ixp46x()) {
246 platform_add_devices(ixp46x_devices,
247 ARRAY_SIZE(ixp46x_devices));
249 for (region = 0; region < 7; region++) {
250 if((*(IXP4XX_EXP_REG(0x4 * region)) & 0x200)) {
251 ixp4xx_exp_bus_size = SZ_32M;
257 printk("IXP4xx: Using %luMiB expansion bus window size\n",
258 ixp4xx_exp_bus_size >> 20);
261 unsigned long ixp4xx_timer_freq = IXP4XX_TIMER_FREQ;
262 EXPORT_SYMBOL(ixp4xx_timer_freq);
264 void ixp4xx_restart(enum reboot_mode mode, const char *cmd)
266 if (mode == REBOOT_SOFT) {
267 /* Jump into ROM at address 0 */
270 /* Use on-chip reset capability */
272 /* set the "key" register to enable access to
273 * "timer" and "enable" registers
275 *IXP4XX_OSWK = IXP4XX_WDT_KEY;
277 /* write 0 to the timer register for an immediate reset */
280 *IXP4XX_OSWE = IXP4XX_WDT_RESET_ENABLE | IXP4XX_WDT_COUNT_ENABLE;
285 static int ixp4xx_needs_bounce(struct device *dev, dma_addr_t dma_addr, size_t size)
287 return (dma_addr + size) > SZ_64M;
290 static int ixp4xx_platform_notify_remove(struct device *dev)
293 dmabounce_unregister_dev(dev);
300 * Setup DMA mask to 64MB on PCI devices and 4 GB on all other things.
302 static int ixp4xx_platform_notify(struct device *dev)
304 dev->dma_mask = &dev->coherent_dma_mask;
307 if (dev_is_pci(dev)) {
308 dev->coherent_dma_mask = DMA_BIT_MASK(28); /* 64 MB */
309 dmabounce_register_dev(dev, 2048, 4096, ixp4xx_needs_bounce);
314 dev->coherent_dma_mask = DMA_BIT_MASK(32);
318 int dma_set_coherent_mask(struct device *dev, u64 mask)
321 mask &= DMA_BIT_MASK(28); /* 64 MB */
323 if ((mask & DMA_BIT_MASK(28)) == DMA_BIT_MASK(28)) {
324 dev->coherent_dma_mask = mask;
328 return -EIO; /* device wanted sub-64MB mask */
330 EXPORT_SYMBOL(dma_set_coherent_mask);
332 #ifdef CONFIG_IXP4XX_INDIRECT_PCI
334 * In the case of using indirect PCI, we simply return the actual PCI
335 * address and our read/write implementation use that to drive the
336 * access registers. If something outside of PCI is ioremap'd, we
337 * fallback to the default.
340 static void __iomem *ixp4xx_ioremap_caller(phys_addr_t addr, size_t size,
341 unsigned int mtype, void *caller)
343 if (!is_pci_memory(addr))
344 return __arm_ioremap_caller(addr, size, mtype, caller);
346 return (void __iomem *)addr;
349 static void ixp4xx_iounmap(volatile void __iomem *addr)
351 if (!is_pci_memory((__force u32)addr))
356 void __init ixp4xx_init_early(void)
358 platform_notify = ixp4xx_platform_notify;
360 platform_notify_remove = ixp4xx_platform_notify_remove;
362 #ifdef CONFIG_IXP4XX_INDIRECT_PCI
363 arch_ioremap_caller = ixp4xx_ioremap_caller;
364 arch_iounmap = ixp4xx_iounmap;