upstream u-boot with additional patches for our devices/boards:
https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ;
Gbit ethernet patch for some LIME2 revisions ;
with SPI flash support
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
448 lines
8.7 KiB
448 lines
8.7 KiB
/*
|
|
* Copyright (C) 2006 Atmel Corporation
|
|
*
|
|
* See file CREDITS for list of people who contributed to this
|
|
* project.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*/
|
|
#include <common.h>
|
|
|
|
#include <asm/arch/memory-map.h>
|
|
#include <asm/arch/platform.h>
|
|
|
|
#include "../sm.h"
|
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
const struct clock_domain chip_clock[] = {
|
|
[CLOCK_CPU] = {
|
|
.reg = SM_PM_CPU_MASK,
|
|
.id = CLOCK_CPU,
|
|
.bridge = NO_DEVICE,
|
|
},
|
|
[CLOCK_HSB] = {
|
|
.reg = SM_PM_HSB_MASK,
|
|
.id = CLOCK_HSB,
|
|
.bridge = NO_DEVICE,
|
|
},
|
|
[CLOCK_PBA] = {
|
|
.reg = SM_PM_PBA_MASK,
|
|
.id = CLOCK_PBA,
|
|
.bridge = DEVICE_PBA_BRIDGE,
|
|
},
|
|
[CLOCK_PBB] = {
|
|
.reg = SM_PM_PBB_MASK,
|
|
.id = CLOCK_PBB,
|
|
.bridge = DEVICE_PBB_BRIDGE,
|
|
},
|
|
};
|
|
|
|
static const struct resource hebi_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 0 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 13 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 14 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 27, DEVICE_PIOE, GPIO_FUNC_A, 0 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource pba_bridge_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 1 },
|
|
}
|
|
}, {
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
/* HSB-HSB Bridge */
|
|
.clock = { CLOCK_HSB, 4 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource pbb_bridge_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 2 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource hramc_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 3 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource pioa_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 10 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource piob_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 11 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource pioc_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 12 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource piod_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 13 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource pioe_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 14 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource sm_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 0 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource intc_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 1 },
|
|
},
|
|
},
|
|
};
|
|
static const struct resource hmatrix_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 2 },
|
|
},
|
|
},
|
|
};
|
|
#if defined(CFG_HPDC)
|
|
static const struct resource hpdc_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 16 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_MACB0)
|
|
static const struct resource macb0_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 8 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 6 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 19, DEVICE_PIOC, GPIO_FUNC_A, 0 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_MACB1)
|
|
static const struct resource macb1_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 9 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 7 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 12, DEVICE_PIOC, GPIO_FUNC_B, 19 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 14, DEVICE_PIOD, GPIO_FUNC_B, 2 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_LCDC)
|
|
static const struct resource lcdc_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 7 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_USART0)
|
|
static const struct resource usart0_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 3 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 2, DEVICE_PIOA, GPIO_FUNC_B, 8 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_USART1)
|
|
static const struct resource usart1_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 4 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 2, DEVICE_PIOA, GPIO_FUNC_A, 17 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_USART2)
|
|
static const struct resource usart2_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 5 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 2, DEVICE_PIOB, GPIO_FUNC_B, 26 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_USART3)
|
|
static const struct resource usart3_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBA, 6 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 2, DEVICE_PIOB, GPIO_FUNC_B, 17 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_MMCI)
|
|
static const struct resource mmci_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_PBB, 9 },
|
|
},
|
|
}, {
|
|
.type = RESOURCE_GPIO,
|
|
.u = {
|
|
.gpio = { 6, DEVICE_PIOA, GPIO_FUNC_A, 10 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
#if defined(CFG_DMAC)
|
|
static const struct resource dmac_resource[] = {
|
|
{
|
|
.type = RESOURCE_CLOCK,
|
|
.u = {
|
|
.clock = { CLOCK_HSB, 10 },
|
|
},
|
|
},
|
|
};
|
|
#endif
|
|
|
|
const struct device chip_device[] = {
|
|
[DEVICE_HEBI] = {
|
|
.regs = (void *)HSMC_BASE,
|
|
.nr_resources = ARRAY_SIZE(hebi_resource),
|
|
.resource = hebi_resource,
|
|
},
|
|
[DEVICE_PBA_BRIDGE] = {
|
|
.nr_resources = ARRAY_SIZE(pba_bridge_resource),
|
|
.resource = pba_bridge_resource,
|
|
},
|
|
[DEVICE_PBB_BRIDGE] = {
|
|
.nr_resources = ARRAY_SIZE(pbb_bridge_resource),
|
|
.resource = pbb_bridge_resource,
|
|
},
|
|
[DEVICE_HRAMC] = {
|
|
.nr_resources = ARRAY_SIZE(hramc_resource),
|
|
.resource = hramc_resource,
|
|
},
|
|
[DEVICE_PIOA] = {
|
|
.regs = (void *)PIOA_BASE,
|
|
.nr_resources = ARRAY_SIZE(pioa_resource),
|
|
.resource = pioa_resource,
|
|
},
|
|
[DEVICE_PIOB] = {
|
|
.regs = (void *)PIOB_BASE,
|
|
.nr_resources = ARRAY_SIZE(piob_resource),
|
|
.resource = piob_resource,
|
|
},
|
|
[DEVICE_PIOC] = {
|
|
.regs = (void *)PIOC_BASE,
|
|
.nr_resources = ARRAY_SIZE(pioc_resource),
|
|
.resource = pioc_resource,
|
|
},
|
|
[DEVICE_PIOD] = {
|
|
.regs = (void *)PIOD_BASE,
|
|
.nr_resources = ARRAY_SIZE(piod_resource),
|
|
.resource = piod_resource,
|
|
},
|
|
[DEVICE_PIOE] = {
|
|
.regs = (void *)PIOE_BASE,
|
|
.nr_resources = ARRAY_SIZE(pioe_resource),
|
|
.resource = pioe_resource,
|
|
},
|
|
[DEVICE_SM] = {
|
|
.regs = (void *)SM_BASE,
|
|
.nr_resources = ARRAY_SIZE(sm_resource),
|
|
.resource = sm_resource,
|
|
},
|
|
[DEVICE_INTC] = {
|
|
.regs = (void *)INTC_BASE,
|
|
.nr_resources = ARRAY_SIZE(intc_resource),
|
|
.resource = intc_resource,
|
|
},
|
|
[DEVICE_HMATRIX] = {
|
|
.regs = (void *)HMATRIX_BASE,
|
|
.nr_resources = ARRAY_SIZE(hmatrix_resource),
|
|
.resource = hmatrix_resource,
|
|
},
|
|
#if defined(CFG_HPDC)
|
|
[DEVICE_HPDC] = {
|
|
.nr_resources = ARRAY_SIZE(hpdc_resource),
|
|
.resource = hpdc_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_MACB0)
|
|
[DEVICE_MACB0] = {
|
|
.regs = (void *)MACB0_BASE,
|
|
.nr_resources = ARRAY_SIZE(macb0_resource),
|
|
.resource = macb0_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_MACB1)
|
|
[DEVICE_MACB1] = {
|
|
.regs = (void *)MACB1_BASE,
|
|
.nr_resources = ARRAY_SIZE(macb1_resource),
|
|
.resource = macb1_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_LCDC)
|
|
[DEVICE_LCDC] = {
|
|
.nr_resources = ARRAY_SIZE(lcdc_resource),
|
|
.resource = lcdc_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_USART0)
|
|
[DEVICE_USART0] = {
|
|
.regs = (void *)USART0_BASE,
|
|
.nr_resources = ARRAY_SIZE(usart0_resource),
|
|
.resource = usart0_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_USART1)
|
|
[DEVICE_USART1] = {
|
|
.regs = (void *)USART1_BASE,
|
|
.nr_resources = ARRAY_SIZE(usart1_resource),
|
|
.resource = usart1_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_USART2)
|
|
[DEVICE_USART2] = {
|
|
.regs = (void *)USART2_BASE,
|
|
.nr_resources = ARRAY_SIZE(usart2_resource),
|
|
.resource = usart2_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_USART3)
|
|
[DEVICE_USART3] = {
|
|
.regs = (void *)USART3_BASE,
|
|
.nr_resources = ARRAY_SIZE(usart3_resource),
|
|
.resource = usart3_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_MMCI)
|
|
[DEVICE_MMCI] = {
|
|
.regs = (void *)MMCI_BASE,
|
|
.nr_resources = ARRAY_SIZE(mmci_resource),
|
|
.resource = mmci_resource,
|
|
},
|
|
#endif
|
|
#if defined(CFG_DMAC)
|
|
[DEVICE_DMAC] = {
|
|
.regs = (void *)DMAC_BASE,
|
|
.nr_resources = ARRAY_SIZE(dmac_resource),
|
|
.resource = dmac_resource,
|
|
},
|
|
#endif
|
|
};
|
|
|