static void kw_clkevt_mode(enum clock_event_mode mode, struct clock_event_device *dev) { unsigned long flags; local_irq_save(flags); if (mode == CLOCK_EVT_MODE_PERIODIC) { /* * Setup latch cycles in timer and enable reload interrupt. */ MV_REG_WRITE(CNTMR_RELOAD_REG(CLOCKEVENT), ((mvBoardTclkGet() + HZ/2) / HZ)); MV_REG_WRITE(CNTMR_VAL_REG(CLOCKEVENT), ((mvBoardTclkGet() + HZ/2) / HZ)); MV_REG_BIT_SET(BRIDGE_INT_MASK_REG, BRIDGE_INT_TIMER(CLOCKEVENT)); MV_REG_BIT_SET(CNTMR_CTRL_REG, TIMER_RELOAD_EN(CLOCKEVENT) | TIMER_EN(CLOCKEVENT)); } else { /* * Disable timer and interrupt */ MV_REG_BIT_RESET(BRIDGE_INT_MASK_REG, BRIDGE_INT_TIMER(CLOCKEVENT)); MV_REG_WRITE(BRIDGE_INT_CAUSE_REG, ~BRIDGE_INT_TIMER(CLOCKEVENT)); MV_REG_BIT_RESET(CNTMR_CTRL_REG, TIMER_RELOAD_EN(CLOCKEVENT) | TIMER_EN(CLOCKEVENT)); } local_irq_restore(flags); }
/* SPDIF Recording Related*/ MV_STATUS mvSPDIFRecordTclockSet(int unit) { MV_U32 tclock = mvBoardTclkGet(); MV_U32 reg = MV_REG_READ(MV_AUDIO_SPDIF_REC_GEN_REG(unit)); reg &= ~ASRGR_CORE_CLK_FREQ_MASK; switch (tclock) { case MV_BOARD_TCLK_133MHZ: reg |= ASRGR_CORE_CLK_FREQ_133MHZ; break; case MV_BOARD_TCLK_150MHZ: reg |= ASRGR_CORE_CLK_FREQ_150MHZ; break; case MV_BOARD_TCLK_166MHZ: reg |= ASRGR_CORE_CLK_FREQ_166MHZ; break; case MV_BOARD_TCLK_200MHZ: reg |= ASRGR_CORE_CLK_FREQ_200MHZ; break; default: mvOsPrintf("mvSPDIFRecordTclockSet: Not supported core clock %d\n",tclock); return MV_NOT_SUPPORTED; } MV_REG_WRITE(MV_AUDIO_SPDIF_REC_GEN_REG(unit), reg); return MV_OK; }
/******************************************************************************* * mvSysSpiInit - Initialize the SPI subsystem * * DESCRIPTION: * * INPUT: * None * OUTPUT: * None * RETURN: * None * *******************************************************************************/ MV_STATUS mvSysSpiInit(MV_U8 spiId, MV_U32 serialBaudRate) { MV_SPI_HAL_DATA halData; halData.ctrlModel = mvCtrlModelGet(); halData.tclk = mvBoardTclkGet(); return mvSpiInit(spiId, serialBaudRate, &halData); }
static void mv_init_timer(void) { /* * Setup clocksource free running timer (no interrupt on reload) */ MV_REG_WRITE(CNTMR_VAL_REG(CLOCKSOURCE), 0xffffffff); MV_REG_WRITE(CNTMR_RELOAD_REG(CLOCKSOURCE), 0xffffffff); MV_REG_BIT_RESET(BRIDGE_INT_MASK_REG, BRIDGE_INT_TIMER(CLOCKSOURCE)); MV_REG_BIT_SET(CNTMR_CTRL_REG, TIMER_RELOAD_EN(CLOCKSOURCE) | TIMER_EN(CLOCKSOURCE)); kw_clkevt.cpumask = cpumask_of(0); /* * Register clocksource */ kw_clksrc.mult = clocksource_hz2mult(mvBoardTclkGet(), kw_clksrc.shift); clocksource_register(&kw_clksrc); /* * Connect and enable tick handler */ setup_irq(IRQ_BRIDGE, &kw_timer_irq); /* * Register clockevent */ kw_clkevt.mult = div_sc(mvBoardTclkGet(), NSEC_PER_SEC, kw_clkevt.shift); kw_clkevt.max_delta_ns = clockevent_delta2ns(0xfffffffe, &kw_clkevt); kw_clkevt.min_delta_ns = clockevent_delta2ns(1, &kw_clkevt); /* * Setup clockevent timer (interrupt-driven.) */ clockevents_register_device(&kw_clkevt); }
/******************************************************************************* * mvSysAudioInit - Initialize the Audio subsystem * * DESCRIPTION: * * INPUT: * None * OUTPUT: * None * RETURN: * None * *******************************************************************************/ MV_VOID mvSysAudioInit(MV_U8 unit) { MV_AUDIO_HAL_DATA halData; MV_UNIT_WIN_INFO addrWinMap[MAX_TARGETS + 1]; MV_STATUS status = MV_OK; #if 0 status = mvCtrlAddrWinMapBuild(addrWinMap, MAX_TARGETS + 1); if(status == MV_OK) status = mvAudioWinInit(unit, addrWinMap); #endif if(status == MV_OK) { halData.tclk = mvBoardTclkGet(); mvAudioHalInit(unit,&halData); } return; }
/******************************************************************************* * mvSysEthInit - Initialize the Eth subsystem * * DESCRIPTION: * * INPUT: * None * OUTPUT: * None * RETURN: * None * *******************************************************************************/ MV_VOID mvSysEthInit(MV_VOID) { MV_ETH_HAL_DATA halData; MV_U32 port; MV_UNIT_WIN_INFO addrWinMap[MAX_TARGETS + 1]; MV_STATUS status; int i; status = mvCtrlAddrWinMapBuild(addrWinMap, MAX_TARGETS + 1); if (status != MV_OK) return; for (i = 0; i < MAX_TARGETS; i++) { if (addrWinMap[i].enable == MV_FALSE) continue; } halData.maxPortNum = mvCtrlEthMaxPortGet(); halData.cpuPclk = mvCpuPclkGet(); halData.tclk = mvBoardTclkGet(); #ifdef ETH_DESCR_IN_SRAM halData.sramSize = mvCtrlSramSizeGet(); #endif for (port = 0; port < halData.maxPortNum; port++) { if (MV_FALSE == mvBoardIsGbEPortConnected(port)) continue; if (mvCtrlPwrClckGet(ETH_GIG_UNIT_ID, port) == MV_FALSE) { halData.portData[port].powerOn = MV_FALSE; continue; } status = mvEthWinInit(port, addrWinMap); if (status == MV_OK) { halData.portData[port].powerOn = MV_TRUE; halData.portData[port].phyAddr = mvBoardPhyAddrGet(port); halData.portData[port].isSgmii = mvBoardIsPortInSgmii(port); halData.portData[port].macSpeed = mvBoardMacSpeedGet(port); } } mvEthHalInit(&halData); return; }
static void __init mv_init(void) { /* init the Board environment */ mvBoardEnvInit(); /* init the controller environment */ if (mvCtrlEnvInit() ) { printk( "Controller env initialization failed.\n" ); return; } /* Init the CPU windows setting and the access protection windows. */ if (mvCpuIfInit(mv_sys_map())) { printk( "Cpu Interface initialization failed.\n" ); return; } #if defined (CONFIG_MV78XX0_Z0) mvCpuIfBridgeReorderWAInit(); #endif /* Init Tclk & SysClk */ mvTclk = mvBoardTclkGet(); mvSysclk = mvBoardSysClkGet(); support_wait_for_interrupt = 1; #ifdef CONFIG_JTAG_DEBUG support_wait_for_interrupt = 0; /* for Lauterbach */ #endif mv_vfp_init(); elf_hwcap &= ~HWCAP_JAVA; serial_initialize(); /* At this point, the CPU windows are configured according to default definitions in mvSysHwConfig.h */ /* and cpuAddrWinMap table in mvCpuIf.c. Now it's time to change defaults for each platform. */ mvCpuIfAddrDecShow(whoAmI()); print_board_info(); }
/***************************************************************************** * UART ****************************************************************************/ static struct resource mv_uart_resources[] = { { .start = PORT0_BASE, .end = PORT0_BASE + 0xff, .flags = IORESOURCE_MEM, }, { .start = IRQ_UART0, .end = IRQ_UART0, .flags = IORESOURCE_IRQ, }, { .start = PORT1_BASE, .end = PORT1_BASE + 0xff, .flags = IORESOURCE_MEM, }, { .start = IRQ_UART1, .end = IRQ_UART1, .flags = IORESOURCE_IRQ, }, }; static struct plat_serial8250_port mv_uart_data[] = { { .mapbase = PORT0_BASE, .membase = (char *)PORT0_BASE, .irq = IRQ_UART0, .flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF, .iotype = UPIO_MEM, .regshift = 2, }, { .mapbase = PORT1_BASE, .membase = (char *)PORT1_BASE, .irq = IRQ_UART1, .flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF, .iotype = UPIO_MEM, .regshift = 2, }, { }, }; static struct platform_device mv_uart = { .name = "serial8250", .id = PLAT8250_DEV_PLATFORM, .dev = { .platform_data = mv_uart_data, }, .num_resources = ARRAY_SIZE(mv_uart_resources), .resource = mv_uart_resources, }; static void serial_initialize(void) { mv_uart_data[0].uartclk = mv_uart_data[1].uartclk = mvTclk; platform_device_register(&mv_uart); } static void __init mv_vfp_init(void) { #if defined CONFIG_VFP_FASTVFP printk("VFP initialized to Run Fast Mode.\n"); #endif } #if defined(MV_88F6183) #ifdef CONFIG_MV_INCLUDE_AUDIO typedef struct { unsigned int base; unsigned int size; } _audio_mem_info; typedef struct { u32 spdif_rec; u32 spdif_play; u32 i2s_rec; u32 i2s_play; _audio_mem_info mem_array[MV_DRAM_MAX_CS + 1]; } _audio_info; _audio_info audio_info = {1, 1, 1, 1}; static struct resource mv_snd_resources[] = { [0] = { .start = INTER_REGS_BASE + AUDIO_REG_BASE, .end = INTER_REGS_BASE + AUDIO_REG_BASE + SZ_16K -1, .flags = IORESOURCE_MEM, }, [1] = { .start = IRQ_AUDIO_INT, .end = IRQ_AUDIO_INT, .flags = IORESOURCE_IRQ, }, [2] = { .start = NR_IRQS, /* should obtained from board information*/ .end = NR_IRQS, /* should obtained from board information */ .flags = IORESOURCE_IRQ, } }; static u64 mv_snd_dmamask = 0xFFFFFFFFUL; static struct platform_device mv_snd_device = { .name = "mv88fx_snd", .id = -1, .dev = { .dma_mask = &mv_snd_dmamask, .coherent_dma_mask = 0xFFFFFFFF, .platform_data = &audio_info, }, .num_resources = ARRAY_SIZE(mv_snd_resources), .resource = mv_snd_resources, }; #endif /* #ifdef CONFIG_MV_INCLUDE_AUDIO */ #ifdef CONFIG_MV_INCLUDE_SDIO static struct resource mvsdmmc_resources[] = { [0] = { .start = INTER_REGS_BASE + 0x80000, .end = INTER_REGS_BASE + 0x80000 + SZ_1K -1, .flags = IORESOURCE_MEM, }, [1] = { .start = SDIO_IRQ_NUM, .end = SDIO_IRQ_NUM, .flags = IORESOURCE_IRQ, }, [2] = { .start = NR_IRQS, /* should obtained from board information*/ .end = NR_IRQS, /* should obtained from board information */ .flags = IORESOURCE_IRQ, } }; static u64 mvsdmmc_dmamask = 0xffffffffUL; static struct platform_device mvsdmmc_device = { .name = "mvsdmmc", .id = -1, .dev = { .dma_mask = &mvsdmmc_dmamask, .coherent_dma_mask = 0xffffffff, }, .num_resources = ARRAY_SIZE(mvsdmmc_resources), .resource = mvsdmmc_resources, }; #endif /* CONFIG_MV_INCLUDE_SDIO */ static struct platform_device *devices[] __initdata = { #ifdef CONFIG_MV_INCLUDE_AUDIO &mv_snd_device, #endif #ifdef CONFIG_MV_INCLUDE_SDIO &mvsdmmc_device, #endif NULL }; #endif /* #if defined(MV_88F6183) */ static void __init mv_init(void) { unsigned int temp; /* init the Board environment */ if (mvBoardIdGet() != RD_88F6082_MICRO_DAS_NAS) /* excluded for HDD power problem - to be fixed */ mvBoardEnvInit(); /* init the controller environment */ if( mvCtrlEnvInit() ) { printk( "Controller env initialization failed.\n" ); return; } if(mvBoardIdGet() == RD_88F5181_POS_NAS) { temp = MV_REG_READ(GPP_DATA_OUT_REG(0)); temp &= ~(1 << 0x5); /* for host mode should be set to 0 */ if(!mvIsUsbHost) { temp |= (1 << 0x5); } MV_REG_WRITE(GPP_DATA_OUT_REG(0), temp); } /* Init the CPU windows setting and the access protection windows. */ if( mvCpuIfInit(mv_sys_map()) ) { printk( "Cpu Interface initialization failed.\n" ); return; } /* Init Tclk & SysClk */ mvTclk = mvBoardTclkGet(); mvSysclk = mvBoardSysClkGet(); printk("Sys Clk = %d, Tclk = %d\n",mvSysclk ,mvTclk ); if ((mvCtrlModelGet() == MV_5281_DEV_ID) || (mvCtrlModelGet() == MV_1281_DEV_ID) || (mvCtrlModelGet() == MV_6183_DEV_ID)) mv_orion_ver = MV_ORION2; /* Orion II */ else mv_orion_ver = MV_ORION1; /* Orion I */ /* Implement workaround for FEr# CPU-C16: Wait for interrupt command */ /* is not processed properly, the workaround is not to use this command */ /* the erratum is relevant for 5281 devices with revision less than C0 */ if((mvCtrlModelGet() == MV_5281_DEV_ID) && (mvCtrlRevGet() < MV_5281_C0_REV)) { support_wait_for_interrupt = 0; } #ifdef CONFIG_JTAG_DEBUG support_wait_for_interrupt = 0; /* for Lauterbach */ #endif mv_vfp_init(); elf_hwcap &= ~HWCAP_JAVA; serial_initialize(); /* At this point, the CPU windows are configured according to default definitions in mvSysHwConfig.h */ /* and cpuAddrWinMap table in mvCpuIf.c. Now it's time to change defaults for each platform. */ mvCpuIfAddDecShow(); #if defined(CONFIG_MTD_PHYSMAP) mv_mtd_initialize(); #endif print_board_info(); #ifdef CONFIG_MV_INCLUDE_IDMA mvDmaInit(); #endif #if defined(MV_88F6183) #ifdef CONFIG_MV_INCLUDE_SDIO mvsdmmc_resources[2].end = mvBoardSDIOGpioPinGet() + IRQ_GPP_START; mvsdmmc_resources[2].start = mvBoardSDIOGpioPinGet() + IRQ_GPP_START; irq_int_type[mvBoardSDIOGpioPinGet()] = GPP_IRQ_TYPE_CHANGE_LEVEL; #endif /* CONFIG_MV_INCLUDE_SDIO */ #ifdef CONFIG_MV_INCLUDE_AUDIO for (temp=0 ; temp< MV_DRAM_MAX_CS; temp++) { MV_DRAM_DEC_WIN win; audio_info.mem_array[temp].base = 0; audio_info.mem_array[temp].size = 0; mvDramIfWinGet(SDRAM_CS0 + temp, &win); if (win.enable) { audio_info.mem_array[temp].base = win.addrWin.baseLow; audio_info.mem_array[temp].size = win.addrWin.size; } } #endif /* CONFIG_MV_INCLUDE_AUDIO */ if ((temp = ARRAY_SIZE(devices) - 1)) platform_add_devices(devices, temp); #endif /* MV_88F6183 */ return; }
/******************************************************************************* * mvCtrlHighSpeedSerdesPhyConfig * * DESCRIPTION: This is the main function which configure the * PU sequence of the ser-des * * INPUT: * None. * * OUTPUT: * None. * * RETURN: * MV_OK - success * MV_ERROR - failure *******************************************************************************/ MV_STATUS mvCtrlHighSpeedSerdesPhyConfig(MV_VOID) { MV_U32 serdesLaneNum, pexUnit; MV_U32 uiReg; MV_BIN_SERDES_UNIT_INDX serdesLaneCfg; MV_U32 regAddr[16][11], regVal[16][11]; /* addr/value for each line @ every setup step */ MV_U8 maxSerdesLanes; MV_U32 tmp; MV_U32 tempReg, tempPexReg; MV_U32 pexIf=0; MV_U32 first_busno, next_busno; MV_U32 addr; MV_TWSI_ADDR slave; MV_U32 boardId = mvBoardIdIndexGet(mvBoardIdGet()); maxSerdesLanes = mvCtrlSerdesMaxLanesGet(); if (maxSerdesLanes == 0) return MV_OK; /*Set MPP1 for twsi access */ uiReg = (MV_REG_READ(MPP_CONTROL_REG(1)) & 0x00FFFFFF) | 0x22000000; MV_REG_WRITE(MPP_CONTROL_REG(1), uiReg); /* TWSI init */ slave.type = ADDR7_BIT; slave.address = 0; mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0); mvUartInit(); /* update board configuration (serdes lane topology and speed), if needed */ mvBoardUpdateBoardTopologyConfig(boardId); /* Initialize board configuration database */ boardLaneConfig[0] = SERDES_UNIT_PEX; /* SerDes 0 is alwyas PCIe0*/ boardLaneConfig[1] = boardTopologyConfig[boardId].serdesTopology.lane1; boardLaneConfig[2] = boardTopologyConfig[boardId].serdesTopology.lane2; boardLaneConfig[3] = boardTopologyConfig[boardId].serdesTopology.lane3; memset(regAddr, 0, sizeof(regAddr)); memset(regVal, 0, sizeof(regVal)); /* Check if DRAM is already initialized */ if (MV_REG_READ(REG_BOOTROM_ROUTINE_ADDR) & (1 << REG_BOOTROM_ROUTINE_DRAM_INIT_OFFS)) { DEBUG_INIT_S("High speed PHY - Version: "); DEBUG_INIT_S(SERDES_VERION); DEBUG_INIT_S(" - 2nd boot - Skip \n"); return MV_OK; } DEBUG_INIT_S("High speed PHY - Version: "); DEBUG_INIT_S(SERDES_VERION); DEBUG_INIT_S(" (COM-PHY-V20) \n"); DEBUG_INIT_FULL_C("SERDES 0=",boardLaneConfig[0],2); DEBUG_INIT_FULL_C("SERDES 1=",boardLaneConfig[1],2); DEBUG_INIT_FULL_C("SERDES 2=",boardLaneConfig[2],2); DEBUG_INIT_FULL_C("SERDES 3=",boardLaneConfig[3],2); /*------------------------------------------*/ /* STEP - 1.5 Power Down PLL, RX, TX all phys */ /*------------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { uiReg=MV_REG_READ(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum)); uiReg &= ~PIN_TX_IDLE_MASK; uiReg &= ~(PHY_POWER_UP_PLL_MASK | PHY_POWER_UP_RX_MASK | PHY_POWER_UP_TX_MASK); MV_REG_WRITE(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum),uiReg); } mvOsUDelay(10000); /*--------------------------------------------------------*/ /* STEP - 2 Reset PHY and PIPE (Zx: Un-reset, Ax: Reset)*/ /*--------------------------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { #ifndef CONFIG_ALP_A375_ZX_REV resetPhyAndPipe(serdesLaneNum, MV_TRUE); #else resetPhyAndPipe(serdesLaneNum, MV_FALSE); #endif } /*--------------------------------*/ /* STEP - 2 Common PHYs Selectors */ /*--------------------------------*/ MV_REG_WRITE(COMMON_PHY_SELECTOR_REG, GetLaneSelectorConfig()); /*--------------------------------*/ /* STEP - 3 Configuration 1 */ /*--------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { serdesLaneCfg = mvGetSerdesLaneCfg(serdesLaneNum); if(serdesLaneCfg >= SERDES_LAST_UNIT){ return MV_ERROR; } uiReg = MV_REG_READ(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum)); switch(serdesLaneCfg){ case SERDES_UNIT_USB3: #ifndef CONFIG_ALP_A375_ZX_REV A375_A0_COMMON_PHY_CONFIG(uiReg); #endif uiReg |= PHY_MODE_MASK; /* PHY Mode = USB */ uiReg |= PIPE_SELECT_MASK ; /* Select USB3_PEX */ break; case SERDES_UNIT_PEX: uiReg |= PIPE_SELECT_MASK ; /* Select USB3_PEX */ #ifndef CONFIG_ALP_A375_ZX_REV uiReg &= ~(PHY_MODE_MASK); /* PHY Mode = PEX */ A375_A0_COMMON_PHY_CONFIG(uiReg); #endif break; case SERDES_UNIT_SGMII: case SERDES_UNIT_SATA: #ifndef CONFIG_ALP_A375_ZX_REV A375_A0_COMMON_PHY_CONFIG(uiReg); #endif uiReg &= ~(PIPE_SELECT_MASK); /* Select SATA_SGMII */ uiReg |= POWER_UP_IVREF_MASK; /* Power UP IVREF = Power Up */ break; case SERDES_UNIT_UNCONNECTED: default: break; } /* Serdes speed config */ tmp = getSerdesSpeedConfig(boardId, serdesLaneCfg); uiReg &= ~(GEN_RX_MASK); /* SERDES RX Speed config */ uiReg |= tmp<<GEN_RX_OFFS; uiReg &= ~(GEN_TX_MASK); /* SERDES TX Speed config */ uiReg |= tmp<<GEN_TX_OFFS; MV_REG_WRITE(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum),uiReg); } #ifndef CONFIG_ALP_A375_ZX_REV /*------------------------------------------*/ /* STEP - 3.5 Unreset PHY and PIPE(only Ax)*/ /*------------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { resetPhyAndPipe(serdesLaneNum, MV_FALSE); } #endif /*----------------------------------------*/ /* STEP - 4 COMPHY register configuration */ /*----------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { serdesLaneCfg = mvGetSerdesLaneCfg(serdesLaneNum); if(serdesLaneCfg >= SERDES_LAST_UNIT){ return MV_ERROR; } switch(serdesLaneCfg){ case SERDES_UNIT_PEX: MV_REG_WRITE(RESET_AND_CLOCK_CONTROL_REG(serdesLaneNum),0x25); /* Enable soft_reset*/ MV_REG_WRITE(POWER_AND_PLL_CONTROL_REG(serdesLaneNum),0xFC60); /* PHY Mode = PEX */ #ifndef CONFIG_ALP_A375_ZX_REV MV_REG_WRITE(MISCELLANEOUS_CONTROL0_REG(serdesLaneNum),0x6017); /* REFCLK SEL =0x0 (100Mhz) */ MV_REG_WRITE(INTERFACE_REG1_REG(serdesLaneNum),0x1400); /* PHY_Gen_Max = 5G */ MV_REG_WRITE(DIGITAL_LOOPBACK_ENABLE_REG(serdesLaneNum),0x400); /* SEL_Bits = 20-Bit */ A375_A0_RESET_DFE_SEQUENCE(serdesLaneNum); #else MV_REG_WRITE(KVCO_CALOBRATION_CONTROL_REG(serdesLaneNum),0x40); /* use_max_pll_rate=0x0, ext_force_cal_done=0x0 */ #endif MV_REG_WRITE(RESET_AND_CLOCK_CONTROL_REG(serdesLaneNum),0x24); /* Release soft_reset */ break; case SERDES_UNIT_USB3: MV_REG_WRITE(RESET_AND_CLOCK_CONTROL_REG(serdesLaneNum),0x21); /* Enable soft_reset*/ MV_REG_WRITE(POWER_AND_PLL_CONTROL_REG(serdesLaneNum),0xFCA0); /* PHY Mode = USB3 */ #ifndef CONFIG_ALP_A375_ZX_REV MV_REG_WRITE(LANE_CONFIGURATION_4_REG(serdesLaneNum),0x13); /* Ref_Clk =100Mhz */ MV_REG_WRITE(MISCELLANEOUS_CONTROL0_REG(serdesLaneNum),0x6017); /* REFCLK SEL =0x0 (100Mhz) */ MV_REG_WRITE(INTERFACE_REG1_REG(serdesLaneNum),0x1400); /* PHY_Gen_Max = 5G */ MV_REG_WRITE(DIGITAL_LOOPBACK_ENABLE_REG(serdesLaneNum),0x400); /* SEL_Bits = 20-Bit */ A375_A0_RESET_DFE_SEQUENCE(serdesLaneNum); #else MV_REG_WRITE(KVCO_CALOBRATION_CONTROL_REG(serdesLaneNum),0x40); /* use_max_pll_rate=0x0, ext_force_cal_done=0x0 */ MV_REG_WRITE(GENERETION_2_SETTINGS_1_REG(serdesLaneNum),0x149); /* Mulitiple frequency setup */ #endif MV_REG_WRITE(RESET_AND_CLOCK_CONTROL_REG(serdesLaneNum),0x20); /* Release soft_reset */ break; case SERDES_UNIT_SATA: MV_REG_WRITE(POWER_AND_PLL_CONTROL_REG(serdesLaneNum),0xFC01); /* PHY Mode = SATA */ MV_REG_WRITE(MISCELLANEOUS_CONTROL0_REG(serdesLaneNum),0x6417); /* REFCLK SEL =0x1 (25Mhz) */ #ifndef CONFIG_ALP_A375_ZX_REV MV_REG_WRITE(INTERFACE_REG1_REG(serdesLaneNum),0x1400); /* PHY_Gen_Max = 5G */ MV_REG_WRITE(DIGITAL_LOOPBACK_ENABLE_REG(serdesLaneNum),0x400); /* SEL_Bits = 20-Bit */ MV_REG_WRITE(DIGITAL_RESERVED0_REG(serdesLaneNum),0xE); /* Reg_sq_de_glitch_en */ A375_A0_RESET_DFE_SEQUENCE(serdesLaneNum); #else MV_REG_WRITE(RESERVED_46_REG(serdesLaneNum),0xFF00); #endif break; case SERDES_UNIT_SGMII: MV_REG_WRITE(POWER_AND_PLL_CONTROL_REG(serdesLaneNum),0xFC81); /* PHY Mode = SGMII */ /*moti need to change offset*/ MV_REG_WRITE(DIGITAL_LOOPBACK_ENABLE_REG(serdesLaneNum),0x0); /* SEL_BITS = 0x0 (10-bits mode) */ MV_REG_WRITE(MISCELLANEOUS_CONTROL0_REG(serdesLaneNum),0x6417); /* REFCLK SEL =0x1 (25Mhz) */ #ifndef CONFIG_ALP_A375_ZX_REV MV_REG_WRITE(DIGITAL_RESERVED0_REG(serdesLaneNum),0xE); /* Reg_sq_de_glitch_en */ A375_A0_RESET_DFE_SEQUENCE(serdesLaneNum); #else MV_REG_WRITE(RESERVED_46_REG(serdesLaneNum),0xFF00); /* Enable soft_reset*/ #endif MV_REG_WRITE(PHY_ISOLATION_MODE_CONTROL_REG(serdesLaneNum),0x166); /* Set PHY_GEN_TX/RX to 1.25Gbps */ break; case SERDES_UNIT_UNCONNECTED: default: break; } } /*------------------------------------------*/ /* STEP - 4.5 Power up PLL, RX, TX all phys */ /*------------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { uiReg=MV_REG_READ(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum)); uiReg |= (PHY_POWER_UP_PLL_MASK | PHY_POWER_UP_RX_MASK | PHY_POWER_UP_TX_MASK); MV_REG_WRITE(COMMON_PHY_CONFIGURATION1_REG(serdesLaneNum),uiReg); } #ifndef CONFIG_ALP_A375_ZX_REV mvOsUDelay(5000); /*--------------------------------------------------------------------*/ /* STEP - 4.6 (Only SGMII/SATA): WAIT for PHY Power up sequence to finish */ /*--------------------------------------------------------------------*/ for (serdesLaneNum = 0; serdesLaneNum < maxSerdesLanes; serdesLaneNum++) { serdesLaneCfg = mvGetSerdesLaneCfg(serdesLaneNum); if(serdesLaneCfg >= SERDES_LAST_UNIT){ return MV_ERROR; } switch(serdesLaneCfg){ case SERDES_UNIT_SATA: case SERDES_UNIT_SGMII: uiReg = MV_REG_READ(COMMON_PHY_STATUS1_REG(serdesLaneNum)); if ((uiReg & 0x6) != 0x6) { DEBUG_INIT_S("Phy Power up did't finished\n"); return MV_ERROR; } case SERDES_UNIT_UNCONNECTED: default: break; } } #endif /*----------------------------------------*/ /* STEP - 5 PEX Only */ /*----------------------------------------*/ for (pexUnit = 0; pexUnit < 4; pexUnit++) { if (boardLaneConfig[pexUnit] != SERDES_UNIT_PEX) continue; tmp = MV_REG_READ(PEX_CAPABILITIES_REG(pexUnit)); DEBUG_RD_REG(PEX_CAPABILITIES_REG(pexUnit), tmp ); tmp &= ~(0xf<<20); tmp |= (0x4<<20); MV_REG_WRITE(PEX_CAPABILITIES_REG(pexUnit),tmp); DEBUG_WR_REG(PEX_CAPABILITIES_REG(pexUnit),tmp); } tmp = MV_REG_READ(SOC_CTRL_REG); DEBUG_RD_REG(SOC_CTRL_REG, tmp); tmp &= ~(0x03); tmp |= 0x1<<PCIE0_ENABLE_OFFS; if (boardLaneConfig[1] == SERDES_UNIT_PEX) tmp |= 0x1<<PCIE1_ENABLE_OFFS; MV_REG_WRITE(SOC_CTRL_REG, tmp); DEBUG_WR_REG(SOC_CTRL_REG, tmp); /*----------------------------------------*/ /* STEP - 6 PEX Only - support gen1/gen2 */ /*----------------------------------------*/ next_busno = 0; mvOsDelay(150); for (pexIf = 0; pexIf < 2; pexIf++) // only pexIf 0 on { if (boardLaneConfig[pexIf] != SERDES_UNIT_PEX) continue; tmp = MV_REG_READ(PEX_DBG_STATUS_REG(pexIf)); DEBUG_RD_REG(PEX_DBG_STATUS_REG(pexIf), tmp); first_busno = next_busno; if ((tmp & 0x7f) == 0x7E) { next_busno++; tempPexReg = MV_REG_READ((PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CAPABILITY_REG))); DEBUG_RD_REG((PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CAPABILITY_REG)),tempPexReg ); tempPexReg &= (0xF); if (tempPexReg == 0x2) { tempReg = (MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CTRL_STAT_REG)) & 0xF0000) >> 16; DEBUG_RD_REG(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CTRL_STAT_REG),tempReg ); /* check if the link established is GEN1 */ if (tempReg == 0x1) { mvPexLocalBusNumSet(pexIf, first_busno); mvPexLocalDevNumSet(pexIf, 1); DEBUG_INIT_FULL_S("PEX: pexIf "); DEBUG_INIT_FULL_D(pexIf, 1); DEBUG_INIT_FULL_S(", link is Gen1, checking the EP capability \n"); /* link is Gen1, check the EP capability */ addr = mvPexConfigRead(pexIf, first_busno, 0, 0, 0x34) & 0xFF; DEBUG_INIT_FULL_C("mvPexConfigRead: return addr=0x%x", addr,4); if (addr == 0xff) { DEBUG_INIT_FULL_C("mvPexConfigRead: return 0xff -->PEX (%d): Detected No Link.", pexIf,1); continue; } while ((mvPexConfigRead(pexIf, first_busno, 0, 0, addr) & 0xFF) != 0x10) { addr = (mvPexConfigRead(pexIf, first_busno, 0, 0, addr) & 0xFF00) >> 8; } if ((mvPexConfigRead(pexIf, first_busno, 0, 0, addr + 0xC) & 0xF) >= 0x2) { tmp = MV_REG_READ(PEX_LINK_CTRL_STATUS2_REG(pexIf)); DEBUG_RD_REG(PEX_LINK_CTRL_STATUS2_REG(pexIf),tmp ); tmp &=~(BIT0 | BIT1); tmp |= BIT1; MV_REG_WRITE(PEX_LINK_CTRL_STATUS2_REG(pexIf),tmp); DEBUG_WR_REG(PEX_LINK_CTRL_STATUS2_REG(pexIf),tmp); tmp = MV_REG_READ(PEX_CTRL_REG(pexIf)); DEBUG_RD_REG(PEX_CTRL_REG(pexIf), tmp ); tmp |= BIT10; MV_REG_WRITE(PEX_CTRL_REG(pexIf),tmp); DEBUG_WR_REG(PEX_CTRL_REG(pexIf),tmp); mvOsUDelay(10000);/* We need to wait 10ms before reading the PEX_DBG_STATUS_REG in order not to read the status of the former state*/ DEBUG_INIT_FULL_S("PEX: pexIf "); DEBUG_INIT_FULL_D(pexIf, 1); DEBUG_INIT_FULL_S(", Link upgraded to Gen2 based on client cpabilities \n"); } else { DEBUG_INIT_FULL_S("PEX: pexIf "); DEBUG_INIT_FULL_D(pexIf, 1); DEBUG_INIT_FULL_S(", remains Gen1\n"); } } }
/******************************************************************************* * boardEepromGet - Get board identification from the EEPROM * * DESCRIPTION: * * INPUT: * * OUTPUT: * None. * * RETURN: * *******************************************************************************/ MV_STATUS boardEepromGet(BOARD_DATA *boardData) { MV_TWSI_SLAVE twsiSlave; MV_TWSI_ADDR slave; MV_U32 tclk; tclk = mvBoardTclkGet(); /* Init TWSI first */ slave.type = ADDR7_BIT; slave.address = 0x0; mvTwsiInit(100000, tclk, &slave, 0); twsiSlave.slaveAddr.address = MV_BOARD_ID_EEPROM; twsiSlave.slaveAddr.type = ADDR7_BIT; twsiSlave.validOffset = MV_TRUE; twsiSlave.offset = MV_BOARD_ID_EEPROM_OFFSET0; twsiSlave.moreThen256 = MV_FALSE; if(MV_OK != mvTwsiRead (&twsiSlave, (MV_U8*)boardData, sizeof(BOARD_DATA))) { /*mvOsOutput("Fail to read Board EEPROM from offset0");*/ return MV_FAIL; } #if defined(MV_CPU_LE) boardData->magic = MV_BYTE_SWAP_32BIT(boardData->magic); boardData->boardId = MV_BYTE_SWAP_16BIT(boardData->boardId); boardData->reserved1 = MV_BYTE_SWAP_32BIT(boardData->reserved1); boardData->reserved2 = MV_BYTE_SWAP_32BIT(boardData->reserved2); #endif if(boardData->magic == MV_BOARD_I2C_MAGIC) { return MV_OK; } twsiSlave.offset = MV_BOARD_ID_EEPROM_OFFSET1; twsiSlave.moreThen256 = MV_TRUE; if(MV_OK != mvTwsiRead (&twsiSlave, (MV_U8*)boardData, sizeof(BOARD_DATA))) { /*mvOsOutput("Fail to read Board EEPROM from offset1");*/ return MV_FAIL; } #if defined(MV_CPU_LE) boardData->magic = MV_BYTE_SWAP_32BIT(boardData->magic); boardData->boardId = MV_BYTE_SWAP_16BIT(boardData->boardId); boardData->reserved1 = MV_BYTE_SWAP_32BIT(boardData->reserved1); boardData->reserved2 = MV_BYTE_SWAP_32BIT(boardData->reserved2); #endif if(boardData->magic == MV_BOARD_I2C_MAGIC) { return MV_OK; } return MV_FAIL; }