Google Git
Sign in
gfiber / kernel / mindspeed / d64e711731d88c94ad8d4b95043712d34d12fea0 / . / arch / arm / mach-comcerto / comcerto-2000.c
blob: 6e37bcd10f7cde61c599fabce9e5df56c5d1946c [file] [log] [blame]
/*
* linux/arch/arm/mach-comcerto/comcerto-2000.c
*
* Copyright (C) 2011 Mindspeed Technologies, Inc.
*
* 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 <linux/sched.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/memblock.h>
#include <linux/antirebootloop.h>
#include <asm/setup.h>
#include <asm/mach-types.h>
#include <asm/io.h>
#include <asm/sizes.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <mach/irqs.h>
#include <linux/delay.h>
#include <asm/pmu.h>
#include <mach/dma.h>
#include <linux/dma-mapping.h>
#include <linux/serial_8250.h>
#include <linux/serial_core.h>
#include <linux/serial_reg.h>
#include <linux/smp.h>
#include <linux/uio_driver.h>
#include <asm/mach-types.h>
#include <asm/smp_twd.h>
#include <asm/localtimer.h>
#include <asm/mach/time.h>
#include <asm/hardware/gic.h>
#include <mach/reset.h>
#include <mach/hardware.h>
#include <asm/hardware/cache-l2x0.h>
#include <mach/comcerto-2000.h>
#include <linux/ahci_platform.h>
#include <mach/serdes-c2000.h>
#include <linux/clockchips.h>
#include <linux/clk.h>
#include <mach/comcerto-2000/clock.h>
#include <mach/comcerto-2000/pm.h>
#include <mach/gpio.h>
struct c2k_gpio_pin_stat_info c2k_gpio_pin_stat =
{
.c2k_gpio_pins_0_31 = 0x0,
.c2k_gpio_pins_32_63 = 0x0,
};
#ifdef CONFIG_CACHE_L2X0
void __iomem *l2cache_base;
#endif
/***********************************************************
* Virtual address Mapping *
* *
***********************************************************/
static struct map_desc comcerto_io_desc[] __initdata =
{
#ifdef CONFIG_COMCERTO_MSP
{
.virtual = COMCERTO_MSP_VADDR,
.pfn = __phys_to_pfn(COMCERTO_MSP_DDR_BASE),
.length = COMCERTO_MSP_DDR_SIZE_CB,
.type = MT_MSP
},
{
.virtual = (COMCERTO_MSP_VADDR + COMCERTO_MSP_DDR_SIZE_CB),
.pfn = __phys_to_pfn(COMCERTO_MSP_DDR_BASE + COMCERTO_MSP_DDR_SIZE_CB),
.length = COMCERTO_MSP_DDR_SIZE_NCNB,
.type = MT_MSP_NCNB
},
{
.virtual = COMCERTO_PFE_VADDR,
.pfn = __phys_to_pfn(COMCERTO_PFE_DDR_BASE),
.length = COMCERTO_PFE_DDR_SIZE,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_PFE_AXI_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_PFE_BASE),
.length = COMCERTO_AXI_PFE_SIZE,
.type = MT_DEVICE
},
#endif /* CONFIG_COMCERTO_MSP */
#if defined(CONFIG_PCI)
{
.virtual = COMCERTO_AXI_PCIe0_VADDR_BASE,
.pfn = __phys_to_pfn(COMCERTO_AXI_PCIe0_BASE),
.length = SZ_16M,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_AXI_PCIe1_VADDR_BASE,
.pfn = __phys_to_pfn(COMCERTO_AXI_PCIe1_BASE),
.length = SZ_16M,
.type = MT_DEVICE
},
#endif
{
.virtual = COMCERTO_SCU_VADDR,
.pfn = __phys_to_pfn(COMCERTO_SCU_BASE),
.length = SZ_128K,
.type = MT_DEVICE
},
{
.virtual = IRAM_MEMORY_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_IRAM_BASE),
.length = IRAM_MEMORY_SIZE,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_APB_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_APB_BASE),
.length = COMCERTO_APB_SIZE,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_AXI_UART_SPI_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_UART_SPI_BASE),
.length = COMCERTO_AXI_UART_SPI_SIZE,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_DECT_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_DECT_BASE),
.length = 2 * SZ_1M,
.type = MT_DEVICE
},
{
.virtual = COMCERTO_SEMA_VADDR,
.pfn = __phys_to_pfn(COMCERTO_AXI_SEMA_BASE),
.length = SZ_16M,
.type = MT_DEVICE
},
};
#if defined(CONFIG_COMCERTO_64K_PAGES)
#define PFE_DMA_SIZE (4 * SZ_1M)
#else
#define PFE_DMA_SIZE (16 * SZ_1M)
#endif
#define DSPG_DECT_CSS_DMA_SIZE (10 * SZ_1M)
void __init device_map_io(void)
{
unsigned long size = PFE_DMA_SIZE;
#if defined(CONFIG_DSPG_DECT_CSS)
size += DSPG_DECT_CSS_DMA_SIZE;
#endif
iotable_init(comcerto_io_desc, ARRAY_SIZE(comcerto_io_desc));
/* Increase consistent DMA zone size */
init_consistent_dma_size(size);
}
void __init device_irq_init(void)
{
gic_init(0, SGI_IRQ(1), (void *)COMCERTO_GIC_DIST_VADDR, (void *)COMCERTO_GIC_CPU_VADDR);
}
/************************************************************************
* GPIO
************************************************************************/
static __init void gpio_init(void)
{
#if defined(CONFIG_COMCERTO_UART1_SUPPORT)
writel(readl(COMCERTO_GPIO_MISC_PIN_SELECT) & ~0x3, COMCERTO_GPIO_MISC_PIN_SELECT);
#endif
#if defined(CONFIG_COMCERTO_UART0_SUPPORT)
writel((readl(COMCERTO_GPIO_PIN_SELECT_REG) & ~UART0_GPIO) | UART0_BUS, COMCERTO_GPIO_PIN_SELECT_REG);
c2k_gpio_pin_stat.c2k_gpio_pins_0_31 |= UART0_GPIO_PIN; /* GPIOs 8 to 11 are used for UART0 */
#endif
/*
* Configure each GPIO to be Output or Input
* When Input, Configure to be Input, IRQ
* When Input IRQ, Configure to be IRQ Rising Edge or IRQ falling Edge
*/
/*[FIXME]: GPIO Output, others are input*/
__raw_writel(__raw_readl(COMCERTO_GPIO_OE_REG) | COMCERTO_OUTPUT_GPIO, COMCERTO_GPIO_OE_REG);
/*
* Default GPIO IRQ Configuration. Enable specific IRQs in the
* board-*.c file
*/
__raw_writel(0, COMCERTO_GPIO_INT_CFG_REG);
/* [FIXME]: Are pins GPIO or pins used by another block*/
//__raw_writel(COMCERTO_GPIO_PIN_USAGE, COMCERTO_GPIO_IOCTRL_REG);
}
/************************************************************************
* Expansion Bus
************************************************************************/
/*This variable is provided by the board file*/
extern int comcerto_exp_values[5][7];
static __init void exp_bus_init(void)
{
int cs;
u32 cs_enable;
unsigned int axi_clk, clk_div;
struct clk *clk_axi;
/*First, Reset the Expansion block*/
__raw_writel(0x1, COMCERTO_EXP_SW_RST_R);
while (readl(COMCERTO_EXP_SW_RST_R) & 0x1) ;
/* Clock divider configuration, get the AXI clock first
* AXI clock will be used for refernce count , as exp bus
* also have a dependancy with AXI.
*/
clk_axi = clk_get(NULL,"axi");
if (IS_ERR(clk_axi)) {
pr_err("comcerto_Device_init: Unable to obtain axi clock: %ld\n",PTR_ERR(clk_axi));
}
/*Enable the AXI clock */
if (clk_enable(clk_axi)){
pr_err("%s: Unable to enable axi clock:\n",__func__);
}
/* Get the AXI clock rate in HZ */
axi_clk = clk_get_rate(clk_axi);
/* Round divider up */
clk_div = (axi_clk + COMCERTO_EXPCLK - 1) / COMCERTO_EXPCLK;
__raw_writel(clk_div, COMCERTO_EXP_CLOCK_DIV_R);
cs_enable = 0;
for (cs = 0; cs < 5; cs++) {
/*configure only enabled CS */
{
if (comcerto_exp_values[cs][0] == 1)
cs_enable |= EXP_CSx_EN(cs);
/*mode configuration*/
__raw_writel(comcerto_exp_values[cs][3], COMCERTO_EXP_CSx_CFG_R(cs));
/*Chip select Base configuration (start of address space)*/
__raw_writel(comcerto_exp_values[cs][1], COMCERTO_EXP_CSx_BASE_R(cs));
/*Chip select Segment size configuration (end of address space)*/
__raw_writel(comcerto_exp_values[cs][2], COMCERTO_EXP_CSx_SEG_R(cs));
/*Chip select timing configuration*/
__raw_writel(comcerto_exp_values[cs][4], COMCERTO_EXP_CSx_TMG1_R(cs));
__raw_writel(comcerto_exp_values[cs][5], COMCERTO_EXP_CSx_TMG2_R(cs));
__raw_writel(comcerto_exp_values[cs][6], COMCERTO_EXP_CSx_TMG3_R(cs));
}
}
/*Chip Select activation*/
__raw_writel(EXP_CLK_EN | cs_enable, COMCERTO_EXP_CS_EN_R);
}
static u32 armv7_aux_ctrl_read(void)
{
u32 val;
asm volatile ("mrc p15, 0, %0, c1, c0, 1" : "=r"(val));
printk(KERN_INFO "ARMv7 AUX CTRL(%d): %#x\n", smp_processor_id(), val);
return val;
}
static void armv7_aux_ctrl_write(u32 val)
{
printk(KERN_INFO "ARMv7 AUX CTRL(%d): %#x\n", smp_processor_id(), val);
asm volatile ("mcr p15, 0, %0, c1, c0, 1" : : "r"(val));
}
static void armv7_aux_ctrl_setup(void *info)
{
u32 aux_ctrl;
unsigned long flags;
local_irq_save(flags);
aux_ctrl = armv7_aux_ctrl_read();
#ifdef CONFIG_PL310_FULL_LINE_OF_ZERO
aux_ctrl |= (1 << 3);
#endif
#ifdef CONFIG_PL310_EXCLUSIVE_CACHE
aux_ctrl |= (1 << 7);
#endif
armv7_aux_ctrl_write(aux_ctrl);
local_irq_restore(flags);
}
#ifdef CONFIG_CACHE_L2X0
void l2x0_latency(u32 tag_ram_setup_lat, u32 tag_ram_rd_lat, u32 tag_ram_wr_lat, u32 data_ram_setup_lat, u32 data_ram_rd_lat, u32 data_ram_wr_lat)
{
u32 val;
val = ((tag_ram_wr_lat - 1) << COMCERTO_L2CC_WR_LAT_SHIFT) | ((tag_ram_rd_lat - 1) << COMCERTO_L2CC_RD_LAT_SHIFT) | (tag_ram_setup_lat - 1);
writel(val, l2cache_base + L2X0_TAG_LATENCY_CTRL);
val = ((data_ram_wr_lat - 1) << COMCERTO_L2CC_WR_LAT_SHIFT) | ((data_ram_rd_lat - 1) << COMCERTO_L2CC_RD_LAT_SHIFT) | (data_ram_setup_lat - 1);
writel(val, l2cache_base + L2X0_DATA_LATENCY_CTRL);
}
void comcerto_l2cc_init(void)
{
unsigned int aux_val, aux_mask;
unsigned int associativity, waysize;
#ifdef CONFIG_L2X0_INSTRUCTION_ONLY
int i;
#endif
l2cache_base = (void *)COMCERTO_L310_VADDR;
BUG_ON(!l2cache_base);
/* Set Latency of L2CC to minimum (i.e. 1 cycle) */
l2x0_latency(1, 1, 1, 1, 1, 1);
/* Set L2 address filtering, use L2CC M1 port for DDR accesses */
writel(0x80000000, l2cache_base + L2X0_ADDR_FILTER_END);
writel(0x00000000 | L2X0_ADDR_FILTER_EN, l2cache_base + L2X0_ADDR_FILTER_START);
associativity = (COMCERTO_L2CC_ASSOCIATIVITY_8WAY << COMCERTO_L2CC_ASSOCIATIVITY_SHIFT) & COMCERTO_L2CC_ASSOCIATIVITY_MASK;
waysize = (COMCERTO_L2CC_ASSOCIATIVITY_32KB << COMCERTO_L2CC_WAYSIZE_SHIFT) & COMCERTO_L2CC_WAYSIZE_MASK;
aux_val = associativity | waysize;
aux_mask = (COMCERTO_L2CC_ASSOCIATIVITY_MASK | COMCERTO_L2CC_WAYSIZE_MASK);
/* Shareable attribute override enable */
/* This prevents the cache from changing "normal memory/non-cacheable" accesses to
"normal memory/cacheable/writethrough no read/write allocate"*/
aux_val |= (1 << 22);
aux_mask |= (1 << 22);
/* Write allocate override, no write allocate */
aux_val |= (1 << 23);
aux_mask |= (3 << 23);
#ifdef CONFIG_PL310_FULL_LINE_OF_ZERO
aux_val |= (1 << 0);
aux_mask |= (1 << 0);
#endif
#ifdef CONFIG_PL310_EARLY_WRITE_RESPONSE
aux_val |= (1 << 30);
aux_mask |= (1 << 30);
#endif
#ifdef CONFIG_PL310_STORE_BUFFER_DEVICE_LIMITATION
aux_val |= (1 << 11);
aux_mask |= (1 << 11);
#endif
#ifdef CONFIG_PL310_INSTRUCTION_PREFETCH
aux_val |= (1 << 29);
aux_mask |= (1 << 29);
#endif
#ifdef CONFIG_PL310_DATA_PREFETCH
aux_val |= (1 << 28);
aux_mask |= (1 << 28);
#endif
#ifdef CONFIG_PL310_EXCLUSIVE_CACHE
aux_val |= (1 << 12);
aux_mask |= (1 << 12);
#endif
/* L2 8-way associativity with 32KB way size */
l2x0_init(l2cache_base, aux_val, aux_mask);
#ifdef CONFIG_L2X0_INSTRUCTION_ONLY
for (i = 0; i < 8; i++)
writel_relaxed(0xffff, l2cache_base + L2X0_LOCKDOWN_WAY_D_BASE + i * L2X0_LOCKDOWN_STRIDE);
outer_flush_all();
#endif
armv7_aux_ctrl_setup(NULL);
smp_call_function(armv7_aux_ctrl_setup, NULL, 1);
}
#endif
#if defined(CONFIG_COMCERTO_SATA)
#define SERDES_PHY1 1
#define SERDES_PHY2 2
static int comcerto_ahci_init(struct device *dev, void __iomem *mmio)
{
struct serdes_regs_s *p_sata_phy_reg_file;
int serdes_regs_size;
u32 val;
int ref_clk_24;
/* Move SATA controller to DDRC2 port */
writel(readl(COMCERTO_GPIO_FABRIC_CTRL_REG) | 0x2, COMCERTO_GPIO_FABRIC_CTRL_REG);
val = readl(COMCERTO_GPIO_SYSTEM_CONFIG);
ref_clk_24 = val & (BIT_5_MSK|BIT_7_MSK);
if(ref_clk_24)
{
p_sata_phy_reg_file = &sata_phy_reg_file_24[0];
serdes_regs_size = sizeof(sata_phy_reg_file_24);
printk(KERN_INFO "SATA Serdes: 24Mhz ref clk\n");
}
else
{
p_sata_phy_reg_file = &sata_phy_reg_file_48[0];
serdes_regs_size = sizeof(sata_phy_reg_file_48);
printk(KERN_INFO "SATA Serdes: 48Mhz ref clk\n");
}
//Take SATA AXI domain out of reset
c2000_block_reset(COMPONENT_AXI_SATA,0);
//Bring SATA PMU and OOB out of reset
c2000_block_reset(COMPONENT_SATA_PMU,0);
c2000_block_reset(COMPONENT_SATA_OOB,0);
if ( (val & BOOT_SERDES1_CNF_SATA0) || (!(val & BOOT_SERDES2_CNF_SATA1)))
{
if (val & BOOT_SERDES1_CNF_SATA0)
{
//Bring Serdes1 out of reset
c2000_block_reset(COMPONENT_SERDES1,0);
//Bring SATA0 out of reset
c2000_block_reset(COMPONENT_SERDES_SATA0,0);
/* Serdes Initialization. */
if( serdes_phy_init(SERDES_PHY1, p_sata_phy_reg_file,
serdes_regs_size / sizeof(serdes_regs_t),
SD_DEV_TYPE_SATA) )
{
printk(KERN_ERR "%s: Failed to initialize serdes1 !!\n", __func__);
return -1;
}
}
if (!(val & BOOT_SERDES2_CNF_SATA1))
{
//Bring Serdes2 out of reset
c2000_block_reset(COMPONENT_SERDES2,0);
//Bring SATA1 out of reset
c2000_block_reset(COMPONENT_SERDES_SATA1,0);
/* Serdes Initialization. */
if( serdes_phy_init(SERDES_PHY2, p_sata_phy_reg_file,
serdes_regs_size / sizeof(serdes_regs_t),
SD_DEV_TYPE_SATA) )
{
printk(KERN_ERR "%s: Failed to initialize serdes2 !!\n", __func__);
return -1;
}
}
} else
return -1;
return 0;
}
#endif
#if defined(CONFIG_COMCERTO_UART0_SUPPORT) || defined(CONFIG_COMCERTO_UART1_SUPPORT)
#define UART_DWC_USR 0x1F
static int fastuart_handle_irq(struct uart_port *p)
{
unsigned int iir = p->serial_in(p, UART_IIR);
unsigned int dummy;
if (serial8250_handle_irq(p, iir)) {
return 1;
} else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
/* Clear the USR */
dummy = p->serial_in(p, UART_DWC_USR);
return 1;
}
return 0;
}
#endif
static struct resource comcerto_pmu_resources[] = {
{
.start = IRQ_A9_PMU0,
.end = IRQ_A9_PMU0,
.flags = IORESOURCE_IRQ,
},
{
.start = IRQ_A9_PMU1,
.end = IRQ_A9_PMU1,
.flags = IORESOURCE_IRQ,
},
};
static struct platform_device comcerto_pmu = {
.name = "arm-pmu",
.id = ARM_PMU_DEVICE_CPU,
.num_resources = ARRAY_SIZE(comcerto_pmu_resources),
.resource = comcerto_pmu_resources,
};
/* --------------------------------------------------------------------
* Serial interface
* -------------------------------------------------------------------- */
#if defined(CONFIG_COMCERTO_UART0_SUPPORT) || defined(CONFIG_COMCERTO_UART1_SUPPORT)
static struct plat_serial8250_port comcerto_uart_data[] = {
#ifdef CONFIG_COMCERTO_UART1_SUPPORT
{
.mapbase = COMCERTO_AXI_UART1_BASE,
.membase = (void *)COMCERTO_AXI_UART1_VADDR,
.irq = IRQ_UART1,
.handle_irq = fastuart_handle_irq,
.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_IOREMAP,
.iotype = UPIO_MEM,
.regshift = 2,
},
#endif
#ifdef CONFIG_COMCERTO_UART0_SUPPORT
{
.mapbase = COMCERTO_AXI_UART0_BASE,
.membase = (void *)COMCERTO_AXI_UART0_VADDR,
.irq = IRQ_UART0,
.handle_irq = fastuart_handle_irq,
.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_IOREMAP,
.iotype = UPIO_MEM,
.regshift = 2,
},
#endif
{
.flags = 0,
},
};
static struct platform_device comcerto_uart = {
.name = "serial8250",
.id = PLAT8250_DEV_PLATFORM,
.dev = {
.platform_data = comcerto_uart_data,
},
};
#endif
#ifdef CONFIG_COMCERTO_MSP
static struct resource comcerto_ved_resources[] = {
{
.name = "voip",
.start = COMCERTO_MSP_DDR_BASE,
.end = COMCERTO_MSP_DDR_BASE + COMCERTO_MSP_DDR_SIZE - 1,
.flags = IORESOURCE_MEM,
},
{
.name = "irq",
.start = IRQ_PTP0,
.flags = IORESOURCE_IRQ,
},
};
static struct platform_device comcerto_ved = {
.name = "ved",
.id = 0,
.num_resources = ARRAY_SIZE(comcerto_ved_resources),
.resource = comcerto_ved_resources,
};
#endif /* CONFIG_COMCERTO_MSP */
/* --------------------------------------------------------------------
* USB 3.0 Host
* -------------------------------------------------------------------- */
#if defined(CONFIG_COMCERTO_USB3_SUPPORT)
static struct resource comcerto_usb3_resource[] = {
[0] = {
.start = COMCERTO_AXI_USB3P0_BASE,
.end = COMCERTO_AXI_USB3P0_BASE + SZ_8M - 1,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = IRQ_USB3,
.end = IRQ_USB3,
.flags = IORESOURCE_IRQ,
},
};
static u64 comcerto_usb3_dmamask = 0xfffff000;
struct platform_device comcerto_device_usb3 = {
.name = "xhci-hcd",
.id = -1,
.resource = comcerto_usb3_resource,
.num_resources = ARRAY_SIZE(comcerto_usb3_resource),
.dev = {
.dma_mask = &comcerto_usb3_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
};
#endif
/* --------------------------------------------------------------------
* USB 2.0 Host
* -------------------------------------------------------------------- */
#if defined(CONFIG_COMCERTO_USB2_SUPPORT)
static u64 comcerto_dwc_otg_dmamask = 0xFFFFFFFF /*DMA_BIT_MASK(32)*/;
static struct resource comcerto_dwc_otg_resources[] = {
{
.start = COMCERTO_AXI_USB2P0_BASE,
.end = COMCERTO_AXI_USB2P0_BASE + 0xFFFFFF,
.flags = IORESOURCE_MEM,
}, {
.start = IRQ_USB2,
.end = IRQ_USB2,
.flags = IORESOURCE_IRQ,
},
};
static struct platform_device comcerto_dwc_otg_device = {
.name = "dwc_otg",
.resource = comcerto_dwc_otg_resources,
.num_resources = ARRAY_SIZE(comcerto_dwc_otg_resources),
.dev = {
.platform_data = NULL,
.dma_mask = &comcerto_dwc_otg_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
}
};
#endif
#if defined(CONFIG_COMCERTO_SATA)
static struct ahci_platform_data comcerto_ahci_pdata = {
.init = comcerto_ahci_init,
};
static struct resource comcerto_ahci_resource[] = {
[0] = {
.start = COMCERTO_AXI_SATA_BASE,
.end = COMCERTO_AXI_SATA_BASE + SZ_64K - 1,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = IRQ_SATA,
.end = IRQ_SATA,
.flags = IORESOURCE_IRQ,
},
};
static u64 comcerto_ahci_dmamask = DMA_BIT_MASK(32);
struct platform_device comcerto_device_ahci = {
.name = "ahci",
.id = -1,
.resource = comcerto_ahci_resource,
.num_resources = ARRAY_SIZE(comcerto_ahci_resource),
.dev = {
.platform_data = &comcerto_ahci_pdata,
.dma_mask = &comcerto_ahci_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
};
#endif
/* --------------------------------------------------------------------
* XOR Engine
* -------------------------------------------------------------------- */
static struct resource comcerto_xor_resource[] = {
{
.name = "xor base address",
.start = COMCERTO_APB_MDMA_BASE,
.end = COMCERTO_APB_MDMA_BASE + COMCERTO_APB_MDMA_SIZE - 1,
.flags = IORESOURCE_MEM,
},
{
.name = "IO2M IRQ",
.start = IRQ_MDMA_IO2M,
.flags = IORESOURCE_IRQ,
},
};
static u64 comcerto_xor_dma_mask = DMA_BIT_MASK(32);
static struct platform_device comcerto_xor_device = {
.name = "comcerto_xor",
.id = 0,
.dev = {
.dma_mask = &comcerto_xor_dma_mask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
.num_resources = ARRAY_SIZE(comcerto_xor_resource),
.resource = comcerto_xor_resource,
};
/* --------------------------------------------------------------------
* Basic C2K MDMA Engine
* -------------------------------------------------------------------- */
static struct resource comcerto_dma_resource[] = {
{
.name = "c2k mdma base address",
.start = COMCERTO_APB_MDMA_BASE,
.end = COMCERTO_APB_MDMA_BASE + COMCERTO_APB_MDMA_SIZE - 1,
.flags = IORESOURCE_MEM,
},
{
.name = "IO2M IRQ",
.start = IRQ_MDMA_IO2M,
.flags = IORESOURCE_IRQ,
},
};
static u64 comcerto_dma_dma_mask = DMA_BIT_MASK(32);
static struct platform_device comcerto_dma_device = {
.name = "comcerto_dma",
.id = 0,
.dev = {
.dma_mask = &comcerto_dma_dma_mask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
.num_resources = ARRAY_SIZE(comcerto_dma_resource),
.resource = comcerto_dma_resource,
};
#if defined(CONFIG_COMCERTO_EPAVIS)
static u64 comcerto_epavis_cie_dmamask = DMA_BIT_MASK(32);
struct platform_device comcerto_device_epavis_cie = {
.name = "lc_cie",
.id = -1,
.dev = {
.platform_data = NULL,
.dma_mask = &comcerto_epavis_cie_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
};
static u64 comcerto_epavis_decomp_dmamask = DMA_BIT_MASK(32);
struct platform_device comcerto_device_epavis_decomp = {
.name = "lc_decomp",
.id = -1,
.dev = {
.platform_data = NULL,
.dma_mask = &comcerto_epavis_decomp_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
};
#endif
#if defined(CONFIG_COMCERTO_CSYS_TPI_CLOCK)
struct platform_device comcerto_device_tpi_csys_clk = {
.name = "tpi_csys",
.id = -1,
.dev = {
.platform_data = NULL,
},
};
#endif
int usb3_clk_internal = 1;
static int __init get_usb3_clk_mode(char *str)
{
if (!strcmp(str, "no"))
usb3_clk_internal = 0;
return 1;
}
__setup("usb3_internal_clk=", get_usb3_clk_mode);
int is_mac_zero(u8 *buf)
{
unsigned long dm;
for (dm = 0; dm < 6; dm++){
if ((*(buf+dm)) != 0)
return 1;
}
return 0;
}
static int __init mac_addr_atoi(u8 mac_addr[], char *mac_addr_str)
{
int i, j, k;
int str_incr_cnt = 0;
if (*mac_addr_str == ',') {
*mac_addr_str++;
str_incr_cnt++;
return str_incr_cnt;
}
for (i = 0; i < 6; i++) {
j = hex_to_bin(*mac_addr_str++);
str_incr_cnt++;
if (j == -1)
return str_incr_cnt;
k = hex_to_bin(*mac_addr_str++);
str_incr_cnt++;
if (k == -1)
return str_incr_cnt;
mac_addr_str++;
str_incr_cnt++;
mac_addr[i] = (j << 4) + k;
}
return str_incr_cnt;
}
static u8 c2k_mac_addr[3][14];
static void __init mac_addr_setup(char *str)
{
int str_incr_cnt = 0;
if (*str++ != '=' || !*str) /* No mac addr specified */
return;
str_incr_cnt = mac_addr_atoi(c2k_mac_addr[0], str);
str += str_incr_cnt;
str_incr_cnt = mac_addr_atoi(c2k_mac_addr[1], str);
str += str_incr_cnt;
mac_addr_atoi(c2k_mac_addr[2], str);
}
__setup("mac_addr", mac_addr_setup);
void __init mac_addr_init(struct comcerto_pfe_platform_data * comcerto_pfe_data_ptr)
{
u8 gem_port_id;
for (gem_port_id = 0; gem_port_id < NUM_GEMAC_SUPPORT; gem_port_id++) {
if (is_mac_zero(c2k_mac_addr[gem_port_id])) /* If mac is non-zero */
comcerto_pfe_data_ptr->comcerto_eth_pdata[gem_port_id].mac_addr = c2k_mac_addr[gem_port_id];
}
}
static struct platform_device *comcerto_common_devices[] __initdata = {
#if defined(CONFIG_COMCERTO_UART0_SUPPORT) || defined(CONFIG_COMCERTO_UART1_SUPPORT)
&comcerto_uart,
#endif
#ifdef CONFIG_COMCERTO_MSP
&comcerto_ved,
#endif /* CONFIG_COMCERTO_MSP */
&comcerto_pmu,
#if defined(CONFIG_COMCERTO_USB3_SUPPORT)
&comcerto_device_usb3,
#endif
#if defined(CONFIG_COMCERTO_USB2_SUPPORT)
&comcerto_dwc_otg_device,
#endif
#if defined(CONFIG_COMCERTO_SATA)
&comcerto_device_ahci,
#endif
// &comcerto_xor_device,
&comcerto_dma_device,
#if defined(CONFIG_COMCERTO_EPAVIS)
&comcerto_device_epavis_cie,
&comcerto_device_epavis_decomp,
#endif
#if defined(CONFIG_COMCERTO_CSYS_TPI_CLOCK)
&comcerto_device_tpi_csys_clk,
#endif
};
void __init device_init(void)
{
/* Default value for the bit mask */
unsigned int default_host_utilpe_shared_bitmask = ~(USB2p0_IRQ|WOL_IRQ);
struct clk *axi_clk,*ddr_clk,*arm_clk,*l2cc_clk;
HAL_clk_div_backup_relocate_table ();
system_rev = (readl(COMCERTO_GPIO_DEVICE_ID_REG) >> 24) & 0xf;
/* Initialize the reset driver here */
reset_init();
/* Enable the AXI,DDR,A9 susbsystem clock
* this is just for s/w use count house keeping.
* These clocks will never be disabled from bootloader while
* booting. In fact we are keeping this because for these clocks ,
* we dont have any driver to do a clk_enable. so doing it here.
*/
/* Get the AXI clk structure */
axi_clk = clk_get(NULL,"axi");
if (IS_ERR(axi_clk)) {
pr_err("%s: Unable to obtain AXI clock: %ld\n",__func__,PTR_ERR(axi_clk));
/* System cannot proceed from here */
BUG();
}
/* Enable the AXI clk */
if (clk_enable(axi_clk)){
pr_err("%s: Unable to enable AXI clock:\n",__func__);
/* System cannot proceed from here */
BUG();
}
/* Get the DDR clock structure */
ddr_clk = clk_get(NULL,"ddr");
if (IS_ERR(ddr_clk)) {
pr_err("%s: Unable to obtain DDR clock: %ld\n",__func__,PTR_ERR(ddr_clk));
/* System cannot proceed from here */
BUG();
}
/* Enable the DDR clk */
if (clk_enable(ddr_clk)){
pr_err("%s: Unable to enable DDR clock:\n",__func__);
/* System cannot proceed from here */
BUG();
}
/* Get the CPU(A9) clock */
arm_clk = clk_get(NULL,"arm");
if (IS_ERR(arm_clk)) {
pr_err("%s: Unable to obtain A9(arm) clock: %ld\n",__func__,PTR_ERR(arm_clk));
/* System cannot proceed from here */
BUG();
}
/* Enable the ARM clk */
if (clk_enable(arm_clk)){
pr_err("%s: Unable to enable A9(arm) clock:\n",__func__);
/* System cannot proceed from here */
BUG();
}
/* Get the L2CC clock */
l2cc_clk = clk_get(NULL,"l2cc");
if (IS_ERR(l2cc_clk)) {
pr_err("%s: Unable to obtain L2CC clock: %ld\n",__func__,PTR_ERR(l2cc_clk));
/* L2CC initilization cannot proceed from here */
BUG();
}
/* Enable the L2CC clk */
if (clk_enable(l2cc_clk)){
pr_err("%s: Unable to enable L2CC clock:\n",__func__);
/* L2CC initilization cannot proceed from here */
BUG();
}
#ifdef CONFIG_CACHE_L2X0
comcerto_l2cc_init();
#endif
exp_bus_init();
gpio_init();
#ifdef CONFIG_COMCERTO_TDM_CLOCK
// [FIXME] Take TDM out of reset
//writel(readl(COMCERTO_BLOCK_RESET_REG) | TDM_RST, COMCERTO_BLOCK_RESET_REG);
#endif
/* Default bit mask is applied here , which will be passed to Util-Pe*/
c2k_pm_bitmask_store(default_host_utilpe_shared_bitmask);
platform_add_devices(comcerto_common_devices, ARRAY_SIZE(comcerto_common_devices));
}
void __init platform_reserve(void)
{
/* boot_secondary() in arch/arm/mach-comcerto/platsmp.c uses this range
* to store a jump instruction. The second CPU executes this
* instruction when it comes out of reset.*/
if (memblock_reserve(0, 0x24) < 0)
BUG();
if (memblock_reserve((phys_addr_t) get_antirebootloop_ptr(),
PAGE_SIZE) < 0)
BUG();
/* Allocate DDR block used by PFE/MSP, the base address is fixed so that util-pe code can
be linked at a fixed address */
if (memblock_reserve(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
BUG();
if (memblock_free(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
BUG();
if (memblock_remove(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
BUG();
}
phys_addr_t get_antirebootloop_ptr(void) {
return COMCERTO_AXI_DDR_BASE + (1 * PAGE_SIZE);
}