2 * linux/arch/arm/mach-integrator/integrator_ap.c
4 * Copyright (C) 2000-2003 Deep Blue Solutions Ltd
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/types.h>
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/list.h>
24 #include <linux/platform_device.h>
25 #include <linux/slab.h>
26 #include <linux/string.h>
27 #include <linux/syscore_ops.h>
28 #include <linux/amba/bus.h>
29 #include <linux/amba/kmi.h>
30 #include <linux/clocksource.h>
31 #include <linux/clockchips.h>
32 #include <linux/interrupt.h>
34 #include <linux/irqchip/versatile-fpga.h>
35 #include <linux/mtd/physmap.h>
36 #include <linux/clk.h>
37 #include <linux/platform_data/clk-integrator.h>
38 #include <linux/of_irq.h>
39 #include <linux/of_address.h>
40 #include <linux/of_platform.h>
41 #include <linux/stat.h>
42 #include <linux/sys_soc.h>
43 #include <linux/termios.h>
44 #include <linux/sched_clock.h>
45 #include <linux/clk-provider.h>
47 #include <asm/hardware/arm_timer.h>
48 #include <asm/setup.h>
49 #include <asm/param.h> /* HZ */
50 #include <asm/mach-types.h>
52 #include <asm/mach/arch.h>
53 #include <asm/mach/irq.h>
54 #include <asm/mach/map.h>
55 #include <asm/mach/time.h>
63 /* Base address to the AP system controller */
64 void __iomem
*ap_syscon_base
;
65 /* Base address to the external bus interface */
66 static void __iomem
*ebi_base
;
70 * All IO addresses are mapped onto VA 0xFFFx.xxxx, where x.xxxx
73 * Setup a VA for the Integrator interrupt controller (for header #0,
76 #define VA_IC_BASE __io_address(INTEGRATOR_IC_BASE)
80 * ef000000 Cache flush
81 * f1100000 11000000 System controller registers
82 * f1300000 13000000 Counter/Timer
83 * f1400000 14000000 Interrupt controller
84 * f1600000 16000000 UART 0
85 * f1700000 17000000 UART 1
86 * f1a00000 1a000000 Debug LEDs
87 * f1b00000 1b000000 GPIO
90 static struct map_desc ap_io_desc
[] __initdata __maybe_unused
= {
92 .virtual = IO_ADDRESS(INTEGRATOR_CT_BASE
),
93 .pfn
= __phys_to_pfn(INTEGRATOR_CT_BASE
),
97 .virtual = IO_ADDRESS(INTEGRATOR_IC_BASE
),
98 .pfn
= __phys_to_pfn(INTEGRATOR_IC_BASE
),
102 .virtual = IO_ADDRESS(INTEGRATOR_UART0_BASE
),
103 .pfn
= __phys_to_pfn(INTEGRATOR_UART0_BASE
),
107 .virtual = IO_ADDRESS(INTEGRATOR_DBG_BASE
),
108 .pfn
= __phys_to_pfn(INTEGRATOR_DBG_BASE
),
112 .virtual = IO_ADDRESS(INTEGRATOR_AP_GPIO_BASE
),
113 .pfn
= __phys_to_pfn(INTEGRATOR_AP_GPIO_BASE
),
119 static void __init
ap_map_io(void)
121 iotable_init(ap_io_desc
, ARRAY_SIZE(ap_io_desc
));
126 static unsigned long ic_irq_enable
;
128 static int irq_suspend(void)
130 ic_irq_enable
= readl(VA_IC_BASE
+ IRQ_ENABLE
);
134 static void irq_resume(void)
136 /* disable all irq sources */
138 writel(-1, VA_IC_BASE
+ IRQ_ENABLE_CLEAR
);
139 writel(-1, VA_IC_BASE
+ FIQ_ENABLE_CLEAR
);
141 writel(ic_irq_enable
, VA_IC_BASE
+ IRQ_ENABLE_SET
);
144 #define irq_suspend NULL
145 #define irq_resume NULL
148 static struct syscore_ops irq_syscore_ops
= {
149 .suspend
= irq_suspend
,
150 .resume
= irq_resume
,
153 static int __init
irq_syscore_init(void)
155 register_syscore_ops(&irq_syscore_ops
);
160 device_initcall(irq_syscore_init
);
165 static int ap_flash_init(struct platform_device
*dev
)
169 writel(INTEGRATOR_SC_CTRL_nFLVPPEN
| INTEGRATOR_SC_CTRL_nFLWP
,
170 ap_syscon_base
+ INTEGRATOR_SC_CTRLC_OFFSET
);
172 tmp
= readl(ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
) |
173 INTEGRATOR_EBI_WRITE_ENABLE
;
174 writel(tmp
, ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
);
176 if (!(readl(ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
)
177 & INTEGRATOR_EBI_WRITE_ENABLE
)) {
178 writel(0xa05f, ebi_base
+ INTEGRATOR_EBI_LOCK_OFFSET
);
179 writel(tmp
, ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
);
180 writel(0, ebi_base
+ INTEGRATOR_EBI_LOCK_OFFSET
);
185 static void ap_flash_exit(struct platform_device
*dev
)
189 writel(INTEGRATOR_SC_CTRL_nFLVPPEN
| INTEGRATOR_SC_CTRL_nFLWP
,
190 ap_syscon_base
+ INTEGRATOR_SC_CTRLC_OFFSET
);
192 tmp
= readl(ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
) &
193 ~INTEGRATOR_EBI_WRITE_ENABLE
;
194 writel(tmp
, ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
);
196 if (readl(ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
) &
197 INTEGRATOR_EBI_WRITE_ENABLE
) {
198 writel(0xa05f, ebi_base
+ INTEGRATOR_EBI_LOCK_OFFSET
);
199 writel(tmp
, ebi_base
+ INTEGRATOR_EBI_CSR1_OFFSET
);
200 writel(0, ebi_base
+ INTEGRATOR_EBI_LOCK_OFFSET
);
204 static void ap_flash_set_vpp(struct platform_device
*pdev
, int on
)
207 writel(INTEGRATOR_SC_CTRL_nFLVPPEN
,
208 ap_syscon_base
+ INTEGRATOR_SC_CTRLS_OFFSET
);
210 writel(INTEGRATOR_SC_CTRL_nFLVPPEN
,
211 ap_syscon_base
+ INTEGRATOR_SC_CTRLC_OFFSET
);
214 static struct physmap_flash_data ap_flash_data
= {
216 .init
= ap_flash_init
,
217 .exit
= ap_flash_exit
,
218 .set_vpp
= ap_flash_set_vpp
,
222 * For the PL010 found in the Integrator/AP some of the UART control is
223 * implemented in the system controller and accessed using a callback
226 static void integrator_uart_set_mctrl(struct amba_device
*dev
,
227 void __iomem
*base
, unsigned int mctrl
)
229 unsigned int ctrls
= 0, ctrlc
= 0, rts_mask
, dtr_mask
;
230 u32 phybase
= dev
->res
.start
;
232 if (phybase
== INTEGRATOR_UART0_BASE
) {
242 if (mctrl
& TIOCM_RTS
)
247 if (mctrl
& TIOCM_DTR
)
252 __raw_writel(ctrls
, ap_syscon_base
+ INTEGRATOR_SC_CTRLS_OFFSET
);
253 __raw_writel(ctrlc
, ap_syscon_base
+ INTEGRATOR_SC_CTRLC_OFFSET
);
256 struct amba_pl010_data ap_uart_data
= {
257 .set_mctrl
= integrator_uart_set_mctrl
,
261 * Where is the timer (VA)?
263 #define TIMER0_VA_BASE __io_address(INTEGRATOR_TIMER0_BASE)
264 #define TIMER1_VA_BASE __io_address(INTEGRATOR_TIMER1_BASE)
265 #define TIMER2_VA_BASE __io_address(INTEGRATOR_TIMER2_BASE)
267 static unsigned long timer_reload
;
269 static u64 notrace
integrator_read_sched_clock(void)
271 return -readl((void __iomem
*) TIMER2_VA_BASE
+ TIMER_VALUE
);
274 static void integrator_clocksource_init(unsigned long inrate
,
277 u32 ctrl
= TIMER_CTRL_ENABLE
| TIMER_CTRL_PERIODIC
;
278 unsigned long rate
= inrate
;
280 if (rate
>= 1500000) {
282 ctrl
|= TIMER_CTRL_DIV16
;
285 writel(0xffff, base
+ TIMER_LOAD
);
286 writel(ctrl
, base
+ TIMER_CTRL
);
288 clocksource_mmio_init(base
+ TIMER_VALUE
, "timer2",
289 rate
, 200, 16, clocksource_mmio_readl_down
);
290 sched_clock_register(integrator_read_sched_clock
, 16, rate
);
293 static void __iomem
* clkevt_base
;
296 * IRQ handler for the timer
298 static irqreturn_t
integrator_timer_interrupt(int irq
, void *dev_id
)
300 struct clock_event_device
*evt
= dev_id
;
302 /* clear the interrupt */
303 writel(1, clkevt_base
+ TIMER_INTCLR
);
305 evt
->event_handler(evt
);
310 static void clkevt_set_mode(enum clock_event_mode mode
, struct clock_event_device
*evt
)
312 u32 ctrl
= readl(clkevt_base
+ TIMER_CTRL
) & ~TIMER_CTRL_ENABLE
;
315 writel(ctrl
, clkevt_base
+ TIMER_CTRL
);
318 case CLOCK_EVT_MODE_PERIODIC
:
319 /* Enable the timer and start the periodic tick */
320 writel(timer_reload
, clkevt_base
+ TIMER_LOAD
);
321 ctrl
|= TIMER_CTRL_PERIODIC
| TIMER_CTRL_ENABLE
;
322 writel(ctrl
, clkevt_base
+ TIMER_CTRL
);
324 case CLOCK_EVT_MODE_ONESHOT
:
325 /* Leave the timer disabled, .set_next_event will enable it */
326 ctrl
&= ~TIMER_CTRL_PERIODIC
;
327 writel(ctrl
, clkevt_base
+ TIMER_CTRL
);
329 case CLOCK_EVT_MODE_UNUSED
:
330 case CLOCK_EVT_MODE_SHUTDOWN
:
331 case CLOCK_EVT_MODE_RESUME
:
333 /* Just leave in disabled state */
339 static int clkevt_set_next_event(unsigned long next
, struct clock_event_device
*evt
)
341 unsigned long ctrl
= readl(clkevt_base
+ TIMER_CTRL
);
343 writel(ctrl
& ~TIMER_CTRL_ENABLE
, clkevt_base
+ TIMER_CTRL
);
344 writel(next
, clkevt_base
+ TIMER_LOAD
);
345 writel(ctrl
| TIMER_CTRL_ENABLE
, clkevt_base
+ TIMER_CTRL
);
350 static struct clock_event_device integrator_clockevent
= {
352 .features
= CLOCK_EVT_FEAT_PERIODIC
| CLOCK_EVT_FEAT_ONESHOT
,
353 .set_mode
= clkevt_set_mode
,
354 .set_next_event
= clkevt_set_next_event
,
358 static struct irqaction integrator_timer_irq
= {
360 .flags
= IRQF_TIMER
| IRQF_IRQPOLL
,
361 .handler
= integrator_timer_interrupt
,
362 .dev_id
= &integrator_clockevent
,
365 static void integrator_clockevent_init(unsigned long inrate
,
366 void __iomem
*base
, int irq
)
368 unsigned long rate
= inrate
;
369 unsigned int ctrl
= 0;
372 /* Calculate and program a divisor */
373 if (rate
> 0x100000 * HZ
) {
375 ctrl
|= TIMER_CTRL_DIV256
;
376 } else if (rate
> 0x10000 * HZ
) {
378 ctrl
|= TIMER_CTRL_DIV16
;
380 timer_reload
= rate
/ HZ
;
381 writel(ctrl
, clkevt_base
+ TIMER_CTRL
);
383 setup_irq(irq
, &integrator_timer_irq
);
384 clockevents_config_and_register(&integrator_clockevent
,
390 void __init
ap_init_early(void)
394 static void __init
ap_of_timer_init(void)
396 struct device_node
*node
;
406 err
= of_property_read_string(of_aliases
,
407 "arm,timer-primary", &path
);
410 node
= of_find_node_by_path(path
);
411 base
= of_iomap(node
, 0);
415 clk
= of_clk_get(node
, 0);
417 clk_prepare_enable(clk
);
418 rate
= clk_get_rate(clk
);
420 writel(0, base
+ TIMER_CTRL
);
421 integrator_clocksource_init(rate
, base
);
423 err
= of_property_read_string(of_aliases
,
424 "arm,timer-secondary", &path
);
427 node
= of_find_node_by_path(path
);
428 base
= of_iomap(node
, 0);
431 irq
= irq_of_parse_and_map(node
, 0);
433 clk
= of_clk_get(node
, 0);
435 clk_prepare_enable(clk
);
436 rate
= clk_get_rate(clk
);
438 writel(0, base
+ TIMER_CTRL
);
439 integrator_clockevent_init(rate
, base
, irq
);
442 static const struct of_device_id fpga_irq_of_match
[] __initconst
= {
443 { .compatible
= "arm,versatile-fpga-irq", .data
= fpga_irq_of_init
, },
447 static void __init
ap_init_irq_of(void)
450 of_irq_init(fpga_irq_of_match
);
453 /* For the Device Tree, add in the UART callbacks as AUXDATA */
454 static struct of_dev_auxdata ap_auxdata_lookup
[] __initdata
= {
455 OF_DEV_AUXDATA("arm,primecell", INTEGRATOR_RTC_BASE
,
457 OF_DEV_AUXDATA("arm,primecell", INTEGRATOR_UART0_BASE
,
458 "uart0", &ap_uart_data
),
459 OF_DEV_AUXDATA("arm,primecell", INTEGRATOR_UART1_BASE
,
460 "uart1", &ap_uart_data
),
461 OF_DEV_AUXDATA("arm,primecell", KMI0_BASE
,
463 OF_DEV_AUXDATA("arm,primecell", KMI1_BASE
,
465 OF_DEV_AUXDATA("cfi-flash", INTEGRATOR_FLASH_BASE
,
466 "physmap-flash", &ap_flash_data
),
470 static const struct of_device_id ap_syscon_match
[] = {
471 { .compatible
= "arm,integrator-ap-syscon"},
475 static const struct of_device_id ebi_match
[] = {
476 { .compatible
= "arm,external-bus-interface"},
480 static void __init
ap_init_of(void)
482 unsigned long sc_dec
;
483 struct device_node
*root
;
484 struct device_node
*syscon
;
485 struct device_node
*ebi
;
486 struct device
*parent
;
487 struct soc_device
*soc_dev
;
488 struct soc_device_attribute
*soc_dev_attr
;
493 /* Here we create an SoC device for the root node */
494 root
= of_find_node_by_path("/");
498 syscon
= of_find_matching_node(root
, ap_syscon_match
);
501 ebi
= of_find_matching_node(root
, ebi_match
);
505 ap_syscon_base
= of_iomap(syscon
, 0);
508 ebi_base
= of_iomap(ebi
, 0);
512 ap_sc_id
= readl(ap_syscon_base
);
514 soc_dev_attr
= kzalloc(sizeof(*soc_dev_attr
), GFP_KERNEL
);
518 err
= of_property_read_string(root
, "compatible",
519 &soc_dev_attr
->soc_id
);
522 err
= of_property_read_string(root
, "model", &soc_dev_attr
->machine
);
525 soc_dev_attr
->family
= "Integrator";
526 soc_dev_attr
->revision
= kasprintf(GFP_KERNEL
, "%c",
527 'A' + (ap_sc_id
& 0x0f));
529 soc_dev
= soc_device_register(soc_dev_attr
);
530 if (IS_ERR(soc_dev
)) {
531 kfree(soc_dev_attr
->revision
);
536 parent
= soc_device_to_device(soc_dev
);
537 integrator_init_sysfs(parent
, ap_sc_id
);
539 of_platform_populate(root
, of_default_bus_match_table
,
540 ap_auxdata_lookup
, parent
);
542 sc_dec
= readl(ap_syscon_base
+ INTEGRATOR_SC_DEC_OFFSET
);
543 for (i
= 0; i
< 4; i
++) {
544 struct lm_device
*lmdev
;
546 if ((sc_dec
& (16 << i
)) == 0)
549 lmdev
= kzalloc(sizeof(struct lm_device
), GFP_KERNEL
);
553 lmdev
->resource
.start
= 0xc0000000 + 0x10000000 * i
;
554 lmdev
->resource
.end
= lmdev
->resource
.start
+ 0x0fffffff;
555 lmdev
->resource
.flags
= IORESOURCE_MEM
;
556 lmdev
->irq
= irq_of_parse_and_map(syscon
, i
);
559 lm_device_register(lmdev
);
563 static const char * ap_dt_board_compat
[] = {
568 DT_MACHINE_START(INTEGRATOR_AP_DT
, "ARM Integrator/AP (Device Tree)")
569 .reserve
= integrator_reserve
,
571 .init_early
= ap_init_early
,
572 .init_irq
= ap_init_irq_of
,
573 .handle_irq
= fpga_handle_irq
,
574 .init_time
= ap_of_timer_init
,
575 .init_machine
= ap_init_of
,
576 .restart
= integrator_restart
,
577 .dt_compat
= ap_dt_board_compat
,