int __init arch_board_final_init(void)
{
int rc;
struct vmm_devtree_node *node;
/* All VMM API's are available here */
/* We can register a Board specific resource here */
/* Initialize timer misc APIs */
rc = aw_timer_misc_init();
if (rc) {
return rc;
}
/* Find simple-bus node */
node = vmm_devtree_find_compatible(NULL, NULL, "simple-bus");
if (!node) {
return VMM_ENODEV;
}
/* Do probing using device driver framework */
rc = vmm_devdrv_probe(node);
if (rc) {
return rc;
}
return VMM_OK;
}
int __init epit_clocksource_init(void)
{
int rc = VMM_ENODEV;
u32 clock;
struct vmm_devtree_node *node;
struct epit_clocksource *ecs;
/* find a epit compatible node */
node = vmm_devtree_find_compatible(NULL, NULL, "freescale,epit-timer");
if (!node) {
goto fail;
}
/* Read clock frequency from node */
rc = vmm_devtree_clock_frequency(node, &clock);
if (rc) {
goto fail;
}
/* allocate our struct */
ecs = vmm_zalloc(sizeof(struct epit_clocksource));
if (!ecs) {
rc = VMM_ENOMEM;
goto fail;
}
/* Map timer registers */
rc = vmm_devtree_regmap(node, &ecs->base, 0);
if (rc) {
goto regmap_fail;
}
/* Setup clocksource */
ecs->clksrc.name = node->name;
ecs->clksrc.rating = 300;
ecs->clksrc.read = epit_clksrc_read;
ecs->clksrc.mask = VMM_CLOCKSOURCE_MASK(32);
vmm_clocks_calc_mult_shift(&ecs->clksrc.mult,
&ecs->clksrc.shift,
clock, VMM_NSEC_PER_SEC, 10);
ecs->clksrc.priv = ecs;
/* Register clocksource */
rc = vmm_clocksource_register(&ecs->clksrc);
if (rc) {
goto register_fail;
}
return VMM_OK;
register_fail:
vmm_devtree_regunmap(node, ecs->base, 0);
regmap_fail:
vmm_free(ecs);
fail:
return rc;
}
static int __init versatile_early_init(struct vmm_devtree_node *node)
{
int rc;
/* Host aspace, Heap, Device tree, and Host IRQ available.
*
* Do necessary early stuff like:
* iomapping devices,
* SOC clocking init,
* Setting-up system data in device tree nodes,
* ....
*/
/* Map sysreg */
node = vmm_devtree_find_compatible(NULL, NULL, "arm,versatile-sysreg");
if (!node) {
return VMM_ENODEV;
}
rc = vmm_devtree_regmap(node, &versatile_sys_base, 0);
if (rc) {
return rc;
}
/* Register reset & shutdown callbacks */
vmm_register_system_reset(versatile_reset);
vmm_register_system_shutdown(versatile_shutdown);
/* Initialize versatile clocking */
versatile_clk_init((void *)versatile_sys_base);
/* Setup CLCD (before probing) */
node = vmm_devtree_find_compatible(NULL, NULL, "arm,pl110,versatile");
if (node) {
node->system_data = &clcd_system_data;
}
return 0;
}
static int __init realview_early_init(struct vmm_devtree_node *node)
{
/* Initialize sysreg */
realview_sysreg_of_early_init();
/* Intialize realview clocking */
realview_clk_init((void *)realview_system_base(), FALSE);
/* Setup CLCD (before probing) */
node = vmm_devtree_find_compatible(NULL, NULL, "arm,pl111");
if (node) {
node->system_data = &clcd_system_data;
}
vmm_devtree_dref_node(node);
return VMM_OK;
}
static int __init bcm2836_early_init(struct vmm_devtree_node *node)
{
int rc = VMM_OK;
void *base;
u32 prescaler, cntfreq;
virtual_addr_t base_va;
struct vmm_devtree_node *np;
np = vmm_devtree_find_compatible(NULL, NULL, "brcm,bcm2836-l1-intc");
if (!np) {
return VMM_ENODEV;
}
rc = vmm_devtree_regmap(np, &base_va, 0);
if (rc) {
goto done;
}
base = (void *)base_va;
cntfreq = generic_timer_reg_read(GENERIC_TIMER_REG_FREQ);
switch (cntfreq) {
case 19200000:
prescaler = 0x80000000;
case 1000000:
prescaler = 0x06AAAAAB;
default:
prescaler = (u32)udiv64((u64)0x80000000 * (u64)cntfreq,
(u64)19200000);
break;
};
if (!prescaler) {
rc = VMM_EINVALID;
goto done_unmap;
}
vmm_writel(prescaler, base + LOCAL_TIMER_PRESCALER);
done_unmap:
vmm_devtree_regunmap(node, base_va, 0);
done:
vmm_devtree_dref_node(np);
return rc;
}
int __cpuinit arch_host_irq_init(void)
{
int rc;
physical_addr_t intc_pa;
struct vmm_devtree_node *node;
node = vmm_devtree_find_compatible(NULL, NULL, "ti,omap2-intc");
if (!node) {
return VMM_ENODEV;
}
rc = vmm_devtree_regaddr(node, &intc_pa, 0);
if (rc) {
return rc;
}
return intc_init(intc_pa, OMAP3_MPU_INTC_NRIRQ);
}
int __init bcm2835_pm_init(void)
{
int rc;
struct vmm_devtree_node *node;
node = vmm_devtree_find_compatible(NULL, NULL,
"brcm,bcm2835-pm-wdt");
if (!node) {
return VMM_ENODEV;
}
rc = vmm_devtree_regmap(node, &pm_base_va, 0);
if (rc) {
return rc;
}
return VMM_OK;
}
int __init arch_board_final_init(void)
{
int rc;
struct vmm_devtree_node *node;
#if defined(CONFIG_VTEMU)
struct fb_info *info;
#endif
/* All VMM API's are available here */
/* We can register a Board specific resource here */
/* Find simple-bus node */
node = vmm_devtree_find_compatible(NULL, NULL, "simple-bus");
if (!node) {
return VMM_ENODEV;
}
/* Do platform device probing using device driver framework */
rc = vmm_platform_probe(node);
vmm_devtree_dref_node(node);
if (rc) {
return rc;
}
/* Create VTEMU instace if available */
#if defined(CONFIG_VTEMU)
info = fb_find("fb0");
if (info) {
generic_vt = vtemu_create(info->name, info, NULL);
}
#endif
/* Final init of generic boards with
* matching nodeid table enteries.
*/
if (generic_board_matches) {
vmm_devtree_iterate_matching(NULL,
generic_board_matches,
generic_board_final,
NULL);
}
return VMM_OK;
}
void __init realview_sysreg_of_early_init(void)
{
int err;
virtual_addr_t base_va;
struct vmm_devtree_node *node;
if (realview_sysreg_base)
return;
node = vmm_devtree_find_compatible(NULL, NULL, "arm,realview-sysreg");
if (node) {
err = vmm_devtree_regmap(node, &base_va, 0);
if (err) {
vmm_printf("%s: Faild to map registers (err %d)\n",
__func__, err);
return;
}
realview_sysreg_base = (void *)base_va;
}
}
int __init arch_board_final_init(void)
{
int rc;
struct vmm_devtree_node *node;
/* All VMM API's are available here */
/* We can register a Board specific resource here */
/* Find simple-bus node */
node = vmm_devtree_find_compatible(NULL, NULL, "simple-bus");
if (!node) {
vmm_printf("vmm_devtree_find_compatible for simple-bus...FAIL\n");
return VMM_ENODEV;
}
/* Do probing using device driver framework */
rc = vmm_devdrv_probe(node);
if (rc) {
vmm_printf("vmm_devdrv_probe...FAIL\n");
return rc;
}
return VMM_OK;
}
int __cpuinit epit_clockchip_init(void)
{
int rc = VMM_ENODEV;
u32 clock, hirq, timer_num, *val;
struct vmm_devtree_node *node;
struct epit_clockchip *ecc;
/* find the first epit compatible node */
node = vmm_devtree_find_compatible(NULL, NULL, "freescale,epit-timer");
if (!node) {
goto fail;
}
/* Read clock frequency */
rc = vmm_devtree_clock_frequency(node, &clock);
if (rc) {
goto fail;
}
/* Read timer_num attribute */
val = vmm_devtree_attrval(node, "timer_num");
if (!val) {
rc = VMM_ENOTAVAIL;
goto fail;
}
timer_num = *val;
/* Read irq attribute */
rc = vmm_devtree_irq_get(node, &hirq, 0);
if (rc) {
goto fail;
}
/* allocate our struct */
ecc = vmm_zalloc(sizeof(struct epit_clockchip));
if (!ecc) {
rc = VMM_ENOMEM;
goto fail;
}
/* Map timer registers */
rc = vmm_devtree_regmap(node, &ecc->base, 0);
if (rc) {
goto regmap_fail;
}
ecc->match_mask = 1 << timer_num;
ecc->timer_num = timer_num;
/* Setup clockchip */
ecc->clkchip.name = node->name;
ecc->clkchip.hirq = hirq;
ecc->clkchip.rating = 300;
ecc->clkchip.cpumask = vmm_cpumask_of(0);
ecc->clkchip.features = VMM_CLOCKCHIP_FEAT_ONESHOT;
vmm_clocks_calc_mult_shift(&ecc->clkchip.mult,
&ecc->clkchip.shift,
VMM_NSEC_PER_SEC, clock, 10);
ecc->clkchip.min_delta_ns = vmm_clockchip_delta2ns(MIN_REG_COMPARE,
&ecc->clkchip);
ecc->clkchip.max_delta_ns = vmm_clockchip_delta2ns(MAX_REG_COMPARE,
&ecc->clkchip);
ecc->clkchip.set_mode = epit_set_mode;
ecc->clkchip.set_next_event = epit_set_next_event;
ecc->clkchip.priv = ecc;
/*
* Initialise to a known state (all timers off, and timing reset)
*/
vmm_writel(0x0, (void *)(ecc->base + EPITCR));
/*
* Initialize the load register to the max value to decrement.
*/
vmm_writel(0xffffffff, (void *)(ecc->base + EPITLR));
/*
* enable the timer, set it to the high reference clock,
* allow the timer to work in WAIT mode.
*/
vmm_writel(EPITCR_EN | EPITCR_CLKSRC_REF_HIGH | EPITCR_WAITEN,
(void *)(ecc->base + EPITCR));
/* Register interrupt handler */
rc = vmm_host_irq_register(hirq, ecc->clkchip.name,
&epit_timer_interrupt, ecc);
if (rc) {
goto irq_fail;
}
/* Register clockchip */
rc = vmm_clockchip_register(&ecc->clkchip);
if (rc) {
goto register_fail;
}
return VMM_OK;
register_fail:
vmm_host_irq_unregister(hirq, ecc);
irq_fail:
vmm_devtree_regunmap(node, ecc->base, 0);
regmap_fail:
vmm_free(ecc);
fail:
return rc;
}
