static u8 scc_dma_sff_read_status(ide_hwif_t *hwif) { return (u8)in_be32((void *)(hwif->dma_base + 4)); }
static inline void io_be_clrbit(u32 __iomem *addr, int bitno) { out_be32(addr, in_be32(addr) & ~(1 << bitno)); }
void pci_init_board(void) { volatile immap_t *immap = (immap_t *) CONFIG_SYS_CCSRBAR; volatile ccsr_gur_t *gur = &immap->im_gur; struct fsl_pci_info pci_info[3]; u32 devdisr, pordevsr, io_sel; int first_free_busno = 0; int num = 0; int pci_agent, pcie_ep, pcie_configured; devdisr = in_be32(&gur->devdisr); pordevsr = in_be32(&gur->pordevsr); io_sel = (pordevsr & MPC8610_PORDEVSR_IO_SEL) >> MPC8610_PORDEVSR_IO_SEL_SHIFT; debug (" pci_init_board: devdisr=%x, io_sel=%x\n", devdisr, io_sel); #ifdef CONFIG_PCIE1 pcie_configured = is_fsl_pci_cfg(LAW_TRGT_IF_PCIE_1, io_sel); if (pcie_configured && !(devdisr & MPC86xx_DEVDISR_PCIE1)){ SET_STD_PCIE_INFO(pci_info[num], 1); pcie_ep = fsl_setup_hose(&pcie1_hose, pci_info[num].regs); printf (" PCIE1 connected to ULI as %s (base addr %lx)\n", pcie_ep ? "Endpoint" : "Root Complex", pci_info[num].regs); first_free_busno = fsl_pci_init_port(&pci_info[num++], &pcie1_hose, first_free_busno); } else { printf (" PCIE1: disabled\n"); } puts("\n"); #else setbits_be32(&gur->devdisr, MPC86xx_DEVDISR_PCIE1); /* disable */ #endif #ifdef CONFIG_PCIE2 pcie_configured = is_fsl_pci_cfg(LAW_TRGT_IF_PCIE_2, io_sel); if (pcie_configured && !(devdisr & MPC86xx_DEVDISR_PCIE2)){ SET_STD_PCIE_INFO(pci_info[num], 2); pcie_ep = fsl_setup_hose(&pcie2_hose, pci_info[num].regs); printf (" PCIE2 connected to Slot as %s (base addr %lx)\n", pcie_ep ? "Endpoint" : "Root Complex", pci_info[num].regs); first_free_busno = fsl_pci_init_port(&pci_info[num++], &pcie2_hose, first_free_busno); } else { printf (" PCIE2: disabled\n"); } puts("\n"); #else setbits_be32(&gur->devdisr, MPC86xx_DEVDISR_PCIE2); /* disable */ #endif #ifdef CONFIG_PCI1 if (!(devdisr & MPC86xx_DEVDISR_PCI1)) { SET_STD_PCI_INFO(pci_info[num], 1); pci_agent = fsl_setup_hose(&pci1_hose, pci_info[num].regs); printf(" PCI connected to PCI slots as %s" \ " (base address %lx)\n", pci_agent ? "Agent" : "Host", pci_info[num].regs); first_free_busno = fsl_pci_init_port(&pci_info[num++], &pci1_hose, first_free_busno); } else { printf (" PCI: disabled\n"); } puts("\n"); #else setbits_be32(&gur->devdisr, MPC86xx_DEVDISR_PCI1); /* disable */ #endif }
static int ppchameleonevb_device_ready(struct mtd_info *minfo) { if (in_be32((volatile unsigned*)GPIO0_IR) & NAND_EVB_RB_GPIO_PIN) return 1; return 0; }
u32 hcu_led_get(void) { return (~(in_be32((u32 *)GPIO0_OR)) >> 23) & 0xff; }
void board_ft_fman_fixup_port(void *fdt, char *compat, phys_addr_t addr, enum fm_port port, int offset) { int phy; char alias[20]; char lane_mode[2][20] = {"1000BASE-KX", "10GBASE-KR"}; char buf[32] = "serdes-1,"; struct fixed_link f_link; int media_type = 0; int off; ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); #ifdef CONFIG_T2080QDS serdes_corenet_t *srds_regs = (void *)CONFIG_SYS_FSL_CORENET_SERDES_ADDR; u32 srds1_pccr1 = in_be32(&srds_regs->srdspccr1); #endif u32 srds_s1 = in_be32(&gur->rcwsr[4]) & FSL_CORENET2_RCWSR4_SRDS1_PRTCL; srds_s1 >>= FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT; if (fm_info_get_enet_if(port) == PHY_INTERFACE_MODE_SGMII) { phy = fm_info_get_phy_address(port); switch (port) { #if defined(CONFIG_T2080QDS) case FM1_DTSEC1: if (hwconfig_sub("fsl_1gkx", "fm1_1g1")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx1"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio1"); sprintf(buf, "%s%s%s", buf, "lane-c,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIIH_KX_MASK); break; } case FM1_DTSEC2: if (hwconfig_sub("fsl_1gkx", "fm1_1g2")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx2"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio2"); sprintf(buf, "%s%s%s", buf, "lane-d,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIIG_KX_MASK); break; } case FM1_DTSEC9: if (hwconfig_sub("fsl_1gkx", "fm1_1g9")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx9"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio9"); sprintf(buf, "%s%s%s", buf, "lane-a,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIIE_KX_MASK); break; } case FM1_DTSEC10: if (hwconfig_sub("fsl_1gkx", "fm1_1g10")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx10"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio10"); sprintf(buf, "%s%s%s", buf, "lane-b,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIIF_KX_MASK); break; } if (mdio_mux[port] == EMI1_SLOT2) { sprintf(alias, "phy_sgmii_s2_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot2"); } else if (mdio_mux[port] == EMI1_SLOT3) { sprintf(alias, "phy_sgmii_s3_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot3"); } break; case FM1_DTSEC5: if (hwconfig_sub("fsl_1gkx", "fm1_1g5")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx5"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio5"); sprintf(buf, "%s%s%s", buf, "lane-g,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIIC_KX_MASK); break; } case FM1_DTSEC6: if (hwconfig_sub("fsl_1gkx", "fm1_1g6")) { media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_1gkx6"); fdt_status_okay_by_alias(fdt, "1gkx_pcs_mdio6"); sprintf(buf, "%s%s%s", buf, "lane-h,", (char *)lane_mode[0]); out_be32(&srds_regs->srdspccr1, srds1_pccr1 | PCCR1_SGMIID_KX_MASK); break; } if (mdio_mux[port] == EMI1_SLOT1) { sprintf(alias, "phy_sgmii_s1_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot1"); } else if (mdio_mux[port] == EMI1_SLOT2) { sprintf(alias, "phy_sgmii_s2_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot2"); } break; #elif defined(CONFIG_T2081QDS) case FM1_DTSEC1: case FM1_DTSEC2: case FM1_DTSEC5: case FM1_DTSEC6: case FM1_DTSEC9: case FM1_DTSEC10: if (mdio_mux[port] == EMI1_SLOT2) { sprintf(alias, "phy_sgmii_s2_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot2"); } else if (mdio_mux[port] == EMI1_SLOT3) { sprintf(alias, "phy_sgmii_s3_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot3"); } else if (mdio_mux[port] == EMI1_SLOT5) { sprintf(alias, "phy_sgmii_s5_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot5"); } else if (mdio_mux[port] == EMI1_SLOT6) { sprintf(alias, "phy_sgmii_s6_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot6"); } else if (mdio_mux[port] == EMI1_SLOT7) { sprintf(alias, "phy_sgmii_s7_%x", phy); fdt_set_phy_handle(fdt, compat, addr, alias); fdt_status_okay_by_alias(fdt, "emi1_slot7"); } break; #endif default: break; } if (media_type) { /* set property for 1000BASE-KX in dtb */ off = fdt_node_offset_by_compat_reg(fdt, "fsl,fman-memac-mdio", addr + 0x1000); fdt_setprop_string(fdt, off, "lane-instance", buf); } } else if (fm_info_get_enet_if(port) == PHY_INTERFACE_MODE_XGMII) { switch (srds_s1) { case 0x66: /* XFI interface */ case 0x6b: case 0x6c: case 0x6d: case 0x71: /* * if the 10G is XFI, check hwconfig to see what is the * media type, there are two types, fiber or copper, * fix the dtb accordingly. */ switch (port) { case FM1_10GEC1: if (hwconfig_sub("fsl_10gkr_copper", "fm1_10g1")) { /* it's MAC9 */ media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_xfi9"); fdt_status_okay_by_alias(fdt, "xfi_pcs_mdio9"); sprintf(buf, "%s%s%s", buf, "lane-a,", (char *)lane_mode[1]); } break; case FM1_10GEC2: if (hwconfig_sub("fsl_10gkr_copper", "fm1_10g2")) { /* it's MAC10 */ media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_xfi10"); fdt_status_okay_by_alias(fdt, "xfi_pcs_mdio10"); sprintf(buf, "%s%s%s", buf, "lane-b,", (char *)lane_mode[1]); } break; case FM1_10GEC3: if (hwconfig_sub("fsl_10gkr_copper", "fm1_10g3")) { /* it's MAC1 */ media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_xfi1"); fdt_status_okay_by_alias(fdt, "xfi_pcs_mdio1"); sprintf(buf, "%s%s%s", buf, "lane-c,", (char *)lane_mode[1]); } break; case FM1_10GEC4: if (hwconfig_sub("fsl_10gkr_copper", "fm1_10g4")) { /* it's MAC2 */ media_type = 1; fdt_set_phy_handle(fdt, compat, addr, "phy_xfi2"); fdt_status_okay_by_alias(fdt, "xfi_pcs_mdio2"); sprintf(buf, "%s%s%s", buf, "lane-d,", (char *)lane_mode[1]); } break; default: return; } if (!media_type) { /* fixed-link is used for XFI fiber cable */ f_link.phy_id = port; f_link.duplex = 1; f_link.link_speed = 10000; f_link.pause = 0; f_link.asym_pause = 0; fdt_delprop(fdt, offset, "phy-handle"); fdt_setprop(fdt, offset, "fixed-link", &f_link, sizeof(f_link)); } else { /* set property for copper cable */ off = fdt_node_offset_by_compat_reg(fdt, "fsl,fman-memac-mdio", addr + 0x1000); fdt_setprop_string(fdt, off, "lane-instance", buf); } break; default: break; } } }
int board_eth_init(bd_t *bis) { #if defined(CONFIG_FMAN_ENET) int i, idx, lane, slot, interface; struct memac_mdio_info dtsec_mdio_info; struct memac_mdio_info tgec_mdio_info; ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); u32 rcwsr13 = in_be32(&gur->rcwsr[13]); u32 srds_s1; srds_s1 = in_be32(&gur->rcwsr[4]) & FSL_CORENET2_RCWSR4_SRDS1_PRTCL; srds_s1 >>= FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT; initialize_lane_to_slot(); /* Initialize the mdio_mux array so we can recognize empty elements */ for (i = 0; i < NUM_FM_PORTS; i++) mdio_mux[i] = EMI_NONE; dtsec_mdio_info.regs = (struct memac_mdio_controller *)CONFIG_SYS_FM1_DTSEC_MDIO_ADDR; dtsec_mdio_info.name = DEFAULT_FM_MDIO_NAME; /* Register the 1G MDIO bus */ fm_memac_mdio_init(bis, &dtsec_mdio_info); tgec_mdio_info.regs = (struct memac_mdio_controller *)CONFIG_SYS_FM1_TGEC_MDIO_ADDR; tgec_mdio_info.name = DEFAULT_FM_TGEC_MDIO_NAME; /* Register the 10G MDIO bus */ fm_memac_mdio_init(bis, &tgec_mdio_info); /* Register the muxing front-ends to the MDIO buses */ t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII1); t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_RGMII2); t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT1); t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT2); t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT3); #if defined(CONFIG_T2080QDS) t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT4); #endif t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT5); #if defined(CONFIG_T2081QDS) t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT6); t208xqds_mdio_init(DEFAULT_FM_MDIO_NAME, EMI1_SLOT7); #endif t208xqds_mdio_init(DEFAULT_FM_TGEC_MDIO_NAME, EMI2); /* Set the two on-board RGMII PHY address */ fm_info_set_phy_address(FM1_DTSEC3, RGMII_PHY1_ADDR); if ((rcwsr13 & FSL_CORENET_RCWSR13_EC2) == FSL_CORENET_RCWSR13_EC2_DTSEC4_RGMII) fm_info_set_phy_address(FM1_DTSEC4, RGMII_PHY2_ADDR); else fm_info_set_phy_address(FM1_DTSEC10, RGMII_PHY2_ADDR); switch (srds_s1) { case 0x1b: case 0x1c: case 0x95: case 0xa2: case 0x94: /* T2080QDS: SGMII in Slot3; T2081QDS: SGMII in Slot2 */ fm_info_set_phy_address(FM1_DTSEC9, SGMII_CARD_PORT1_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT2_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); /* T2080QDS: SGMII in Slot2; T2081QDS: SGMII in Slot1 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT4_PHY_ADDR); break; case 0x50: case 0x51: case 0x5e: case 0x5f: case 0x64: case 0x65: /* T2080QDS: XAUI/HiGig in Slot3; T2081QDS: in Slot2 */ fm_info_set_phy_address(FM1_10GEC1, FM1_10GEC1_PHY_ADDR); /* T2080QDS: SGMII in Slot2; T2081QDS: in Slot3 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT4_PHY_ADDR); break; case 0x66: case 0x67: /* * XFI does not need a PHY to work, but to avoid U-boot use * default PHY address which is zero to a MAC when it found * a MAC has no PHY address, we give a PHY address to XFI * MAC, and should not use a real XAUI PHY address, since * MDIO can access it successfully, and then MDIO thinks * the XAUI card is used for the XFI MAC, which will cause * error. */ fm_info_set_phy_address(FM1_10GEC1, 4); fm_info_set_phy_address(FM1_10GEC2, 5); fm_info_set_phy_address(FM1_10GEC3, 6); fm_info_set_phy_address(FM1_10GEC4, 7); break; case 0x6a: case 0x6b: fm_info_set_phy_address(FM1_10GEC1, 4); fm_info_set_phy_address(FM1_10GEC2, 5); fm_info_set_phy_address(FM1_10GEC3, 6); fm_info_set_phy_address(FM1_10GEC4, 7); /* T2080QDS: SGMII in Slot2; T2081QDS: in Slot3 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT2_PHY_ADDR); break; case 0x6c: case 0x6d: fm_info_set_phy_address(FM1_10GEC1, 4); fm_info_set_phy_address(FM1_10GEC2, 5); /* T2080QDS: SGMII in Slot3; T2081QDS: in Slot2 */ fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); break; case 0x70: case 0x71: /* SGMII in Slot3 */ fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); /* SGMII in Slot2 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT2_PHY_ADDR); break; case 0xa6: case 0x8e: case 0x8f: case 0x82: case 0x83: /* SGMII in Slot3 */ fm_info_set_phy_address(FM1_DTSEC9, SGMII_CARD_PORT1_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT2_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); /* SGMII in Slot2 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT2_PHY_ADDR); break; case 0xa4: case 0x96: case 0x8a: /* SGMII in Slot3 */ fm_info_set_phy_address(FM1_DTSEC9, SGMII_CARD_PORT1_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT2_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); break; #if defined(CONFIG_T2080QDS) case 0xd9: case 0xd3: case 0xcb: /* SGMII in Slot3 */ fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT2_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT4_PHY_ADDR); /* SGMII in Slot2 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT2_PHY_ADDR); break; #elif defined(CONFIG_T2081QDS) case 0xca: case 0xcb: /* SGMII in Slot3 */ fm_info_set_phy_address(FM1_DTSEC5, SGMII_CARD_PORT1_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT2_PHY_ADDR); /* SGMII in Slot5 */ fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT1_PHY_ADDR); /* SGMII in Slot6 */ fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT1_PHY_ADDR); /* SGMII in Slot7 */ fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT3_PHY_ADDR); break; #endif case 0xf2: /* T2080QDS: SGMII in Slot3; T2081QDS: SGMII in Slot7 */ fm_info_set_phy_address(FM1_DTSEC1, SGMII_CARD_PORT1_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC2, SGMII_CARD_PORT2_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC10, SGMII_CARD_PORT3_PHY_ADDR); fm_info_set_phy_address(FM1_DTSEC6, SGMII_CARD_PORT4_PHY_ADDR); break; default: break; } for (i = FM1_DTSEC1; i < FM1_DTSEC1 + CONFIG_SYS_NUM_FM1_DTSEC; i++) { idx = i - FM1_DTSEC1; interface = fm_info_get_enet_if(i); switch (interface) { case PHY_INTERFACE_MODE_SGMII: lane = serdes_get_first_lane(FSL_SRDS_1, SGMII_FM1_DTSEC1 + idx); if (lane < 0) break; slot = lane_to_slot[lane]; debug("FM1@DTSEC%u expects SGMII in slot %u\n", idx + 1, slot); if (QIXIS_READ(present2) & (1 << (slot - 1))) fm_disable_port(i); switch (slot) { case 1: mdio_mux[i] = EMI1_SLOT1; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; case 2: mdio_mux[i] = EMI1_SLOT2; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; case 3: mdio_mux[i] = EMI1_SLOT3; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; #if defined(CONFIG_T2081QDS) case 5: mdio_mux[i] = EMI1_SLOT5; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; case 6: mdio_mux[i] = EMI1_SLOT6; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; case 7: mdio_mux[i] = EMI1_SLOT7; fm_info_set_mdio(i, mii_dev_for_muxval( mdio_mux[i])); break; #endif } break; case PHY_INTERFACE_MODE_RGMII: if (i == FM1_DTSEC3) mdio_mux[i] = EMI1_RGMII1; else if (i == FM1_DTSEC4 || FM1_DTSEC10) mdio_mux[i] = EMI1_RGMII2; fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); break; default: break; } } for (i = FM1_10GEC1; i < FM1_10GEC1 + CONFIG_SYS_NUM_FM1_10GEC; i++) { idx = i - FM1_10GEC1; switch (fm_info_get_enet_if(i)) { case PHY_INTERFACE_MODE_XGMII: if (srds_s1 == 0x51) { lane = serdes_get_first_lane(FSL_SRDS_1, XAUI_FM1_MAC9 + idx); } else if ((srds_s1 == 0x5f) || (srds_s1 == 0x65)) { lane = serdes_get_first_lane(FSL_SRDS_1, HIGIG_FM1_MAC9 + idx); } else { if (i == FM1_10GEC1 || i == FM1_10GEC2) lane = serdes_get_first_lane(FSL_SRDS_1, XFI_FM1_MAC9 + idx); else lane = serdes_get_first_lane(FSL_SRDS_1, XFI_FM1_MAC1 + idx); } if (lane < 0) break; mdio_mux[i] = EMI2; fm_info_set_mdio(i, mii_dev_for_muxval(mdio_mux[i])); if ((srds_s1 == 0x66) || (srds_s1 == 0x6b) || (srds_s1 == 0x6a) || (srds_s1 == 0x70) || (srds_s1 == 0x6c) || (srds_s1 == 0x6d) || (srds_s1 == 0x71)) { /* As XFI is in cage intead of a slot, so * ensure doesn't disable the corresponding port */ break; } slot = lane_to_slot[lane]; if (QIXIS_READ(present2) & (1 << (slot - 1))) fm_disable_port(i); break; default: break; } } cpu_eth_init(bis); #endif /* CONFIG_FMAN_ENET */ return pci_eth_init(bis); }
static void fdt_fsl_fixup_of_pfe(void *blob) { int i = 0; struct pfe_prop_val prop_val; void *l_blob = blob; struct ccsr_gur __iomem *gur = (void *)CONFIG_SYS_FSL_GUTS_ADDR; unsigned int srds_s1 = in_be32(&gur->rcwsr[4]) & FSL_CHASSIS2_RCWSR4_SRDS1_PRTCL_MASK; srds_s1 >>= FSL_CHASSIS2_RCWSR4_SRDS1_PRTCL_SHIFT; for (i = 0; i < NUM_ETH_NODE; i++) { switch (srds_s1) { case SERDES_1_G_PROTOCOL: if (i == 0) { prop_val.busid = cpu_to_fdt32( ETH_1_1G_BUS_ID); prop_val.phyid = cpu_to_fdt32( ETH_1_1G_PHY_ID); prop_val.mux_val = cpu_to_fdt32( ETH_1_1G_MDIO_MUX); prop_val.phy_mask = cpu_to_fdt32( ETH_1G_MDIO_PHY_MASK); prop_val.phy_mode = "sgmii"; pfe_set_properties(l_blob, prop_val, ETH_1_PATH, ETH_1_MDIO); } else { prop_val.busid = cpu_to_fdt32( ETH_2_1G_BUS_ID); prop_val.phyid = cpu_to_fdt32( ETH_2_1G_PHY_ID); prop_val.mux_val = cpu_to_fdt32( ETH_2_1G_MDIO_MUX); prop_val.phy_mask = cpu_to_fdt32( ETH_1G_MDIO_PHY_MASK); prop_val.phy_mode = "rgmii"; pfe_set_properties(l_blob, prop_val, ETH_2_PATH, ETH_2_MDIO); } break; case SERDES_2_5_G_PROTOCOL: if (i == 0) { prop_val.busid = cpu_to_fdt32( ETH_1_2_5G_BUS_ID); prop_val.phyid = cpu_to_fdt32( ETH_1_2_5G_PHY_ID); prop_val.mux_val = cpu_to_fdt32( ETH_1_2_5G_MDIO_MUX); prop_val.phy_mask = cpu_to_fdt32( ETH_2_5G_MDIO_PHY_MASK); prop_val.phy_mode = "sgmii-2500"; pfe_set_properties(l_blob, prop_val, ETH_1_PATH, ETH_1_MDIO); } else { prop_val.busid = cpu_to_fdt32( ETH_2_2_5G_BUS_ID); prop_val.phyid = cpu_to_fdt32( ETH_2_2_5G_PHY_ID); prop_val.mux_val = cpu_to_fdt32( ETH_2_2_5G_MDIO_MUX); prop_val.phy_mask = cpu_to_fdt32( ETH_2_5G_MDIO_PHY_MASK); prop_val.phy_mode = "sgmii-2500"; pfe_set_properties(l_blob, prop_val, ETH_2_PATH, ETH_2_MDIO); } break; default: printf("serdes:[%d]\n", srds_s1); } } }
static inline int sw_reset_pressed(void) { return !(in_be32((void *)GPIO0_IR) & GPIO_VAL(CONFIG_SYS_GPIO_SW_RESET)); }
static void emac_mac_dump(int idx, struct ocp_enet_private *dev) { struct emac_regs __iomem *p = dev->emacp; printk("** EMAC%d registers **\n" "MR0 = 0x%08x MR1 = 0x%08x TMR0 = 0x%08x TMR1 = 0x%08x\n" "RMR = 0x%08x ISR = 0x%08x ISER = 0x%08x\n" "IAR = %04x%08x VTPID = 0x%04x VTCI = 0x%04x\n" "IAHT: 0x%04x 0x%04x 0x%04x 0x%04x " "GAHT: 0x%04x 0x%04x 0x%04x 0x%04x\n" "LSA = %04x%08x IPGVR = 0x%04x\n" "STACR = 0x%08x TRTR = 0x%08x RWMR = 0x%08x\n" "OCTX = 0x%08x OCRX = 0x%08x IPCR = 0x%08x\n", idx, in_be32(&p->mr0), in_be32(&p->mr1), in_be32(&p->tmr0), in_be32(&p->tmr1), in_be32(&p->rmr), in_be32(&p->isr), in_be32(&p->iser), in_be32(&p->iahr), in_be32(&p->ialr), in_be32(&p->vtpid), in_be32(&p->vtci), in_be32(&p->iaht1), in_be32(&p->iaht2), in_be32(&p->iaht3), in_be32(&p->iaht4), in_be32(&p->gaht1), in_be32(&p->gaht2), in_be32(&p->gaht3), in_be32(&p->gaht4), in_be32(&p->lsah), in_be32(&p->lsal), in_be32(&p->ipgvr), in_be32(&p->stacr), in_be32(&p->trtr), in_be32(&p->rwmr), in_be32(&p->octx), in_be32(&p->ocrx), in_be32(&p->ipcr) ); emac_desc_dump(idx, dev); }
static void __init pnv_pci_init_p5ioc2_phb(struct device_node *np, u64 hub_id, void *tce_mem, u64 tce_size) { struct pnv_phb *phb; const __be64 *prop64; u64 phb_id; int64_t rc; static int primary = 1; pr_info(" Initializing p5ioc2 PHB %s\n", np->full_name); prop64 = of_get_property(np, "ibm,opal-phbid", NULL); if (!prop64) { pr_err(" Missing \"ibm,opal-phbid\" property !\n"); return; } phb_id = be64_to_cpup(prop64); pr_devel(" PHB-ID : 0x%016llx\n", phb_id); pr_devel(" TCE AT : 0x%016lx\n", __pa(tce_mem)); pr_devel(" TCE SZ : 0x%016llx\n", tce_size); rc = opal_pci_set_phb_tce_memory(phb_id, __pa(tce_mem), tce_size); if (rc != OPAL_SUCCESS) { pr_err(" Failed to set TCE memory, OPAL error %lld\n", rc); return; } phb = alloc_bootmem(sizeof(struct pnv_phb)); if (phb) { memset(phb, 0, sizeof(struct pnv_phb)); phb->hose = pcibios_alloc_controller(np); } if (!phb || !phb->hose) { pr_err(" Failed to allocate PCI controller\n"); return; } spin_lock_init(&phb->lock); phb->hose->first_busno = 0; phb->hose->last_busno = 0xff; phb->hose->private_data = phb; phb->hub_id = hub_id; phb->opal_id = phb_id; phb->type = PNV_PHB_P5IOC2; phb->model = PNV_PHB_MODEL_P5IOC2; phb->regs = of_iomap(np, 0); if (phb->regs == NULL) pr_err(" Failed to map registers !\n"); else { pr_devel(" P_BUID = 0x%08x\n", in_be32(phb->regs + 0x100)); pr_devel(" P_IOSZ = 0x%08x\n", in_be32(phb->regs + 0x1b0)); pr_devel(" P_IO_ST = 0x%08x\n", in_be32(phb->regs + 0x1e0)); pr_devel(" P_MEM1_H = 0x%08x\n", in_be32(phb->regs + 0x1a0)); pr_devel(" P_MEM1_L = 0x%08x\n", in_be32(phb->regs + 0x190)); pr_devel(" P_MSZ1_L = 0x%08x\n", in_be32(phb->regs + 0x1c0)); pr_devel(" P_MEM_ST = 0x%08x\n", in_be32(phb->regs + 0x1d0)); pr_devel(" P_MEM2_H = 0x%08x\n", in_be32(phb->regs + 0x2c0)); pr_devel(" P_MEM2_L = 0x%08x\n", in_be32(phb->regs + 0x2b0)); pr_devel(" P_MSZ2_H = 0x%08x\n", in_be32(phb->regs + 0x2d0)); pr_devel(" P_MSZ2_L = 0x%08x\n", in_be32(phb->regs + 0x2e0)); } /* Interpret the "ranges" property */ /* This also maps the I/O region and sets isa_io/mem_base */ pci_process_bridge_OF_ranges(phb->hose, np, primary); primary = 0; phb->hose->ops = &pnv_pci_ops; /* Setup MSI support */ pnv_pci_init_p5ioc2_msis(phb); /* Setup TCEs */ phb->dma_dev_setup = pnv_pci_p5ioc2_dma_dev_setup; pnv_pci_setup_iommu_table(&phb->p5ioc2.iommu_table, tce_mem, tce_size, 0); }
static int __init zmii_init(struct ocp_device *ocpdev, int input, int *mode) { struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev); struct zmii_regs __iomem *p; ZMII_DBG("%d: init(%d, %d)" NL, ocpdev->def->index, input, *mode); if (!dev) { dev = kzalloc(sizeof(struct ibm_ocp_zmii), GFP_KERNEL); if (!dev) { printk(KERN_ERR "zmii%d: couldn't allocate device structure!\n", ocpdev->def->index); return -ENOMEM; } dev->mode = PHY_MODE_NA; p = ioremap(ocpdev->def->paddr, sizeof(struct zmii_regs)); if (!p) { printk(KERN_ERR "zmii%d: could not ioremap device registers!\n", ocpdev->def->index); kfree(dev); return -ENOMEM; } dev->base = p; ocp_set_drvdata(ocpdev, dev); /* We may need FER value for autodetection later */ dev->fer_save = in_be32(&p->fer); /* Disable all inputs by default */ out_be32(&p->fer, 0); } else p = dev->base; if (!zmii_valid_mode(*mode)) { /* Probably an EMAC connected to RGMII, * but it still may need ZMII for MDIO */ goto out; } /* Autodetect ZMII mode if not specified. * This is only for backward compatibility with the old driver. * Please, always specify PHY mode in your board port to avoid * any surprises. */ if (dev->mode == PHY_MODE_NA) { if (*mode == PHY_MODE_NA) { u32 r = dev->fer_save; ZMII_DBG("%d: autodetecting mode, FER = 0x%08x" NL, ocpdev->def->index, r); if (r & (ZMII_FER_MII(0) | ZMII_FER_MII(1))) dev->mode = PHY_MODE_MII; else if (r & (ZMII_FER_RMII(0) | ZMII_FER_RMII(1))) dev->mode = PHY_MODE_RMII; else dev->mode = PHY_MODE_SMII; } else dev->mode = *mode; printk(KERN_NOTICE "zmii%d: bridge in %s mode\n", ocpdev->def->index, zmii_mode_name(dev->mode)); } else { /* All inputs must use the same mode */ if (*mode != PHY_MODE_NA && *mode != dev->mode) { printk(KERN_ERR "zmii%d: invalid mode %d specified for input %d\n", ocpdev->def->index, *mode, input); return -EINVAL; } } /* Report back correct PHY mode, * it may be used during PHY initialization. */ *mode = dev->mode; /* Enable this input */ out_be32(&p->fer, in_be32(&p->fer) | zmii_mode_mask(dev->mode, input)); out: ++dev->users; return 0; }
void init_laws(void) { int i; #if FSL_HW_NUM_LAWS < 32 gd->used_laws = ~((1 << FSL_HW_NUM_LAWS) - 1); #elif FSL_HW_NUM_LAWS == 32 gd->used_laws = 0; #else #error FSL_HW_NUM_LAWS can not be greater than 32 w/o code changes #endif /* * Any LAWs that were set up before we booted assume they are meant to * be around and mark them used. */ for (i = 0; i < FSL_HW_NUM_LAWS; i++) { u32 lawar = in_be32(LAWAR_ADDR(i)); if (lawar & LAW_EN) gd->used_laws |= (1 << i); } #if defined(CONFIG_NAND_U_BOOT) && !defined(CONFIG_NAND_SPL) /* * in NAND boot we've already parsed the law_table and setup those LAWs * so don't do it again. */ return; #endif for (i = 0; i < num_law_entries; i++) { if (law_table[i].index == -1) set_next_law(law_table[i].addr, law_table[i].size, law_table[i].trgt_id); else set_law(law_table[i].index, law_table[i].addr, law_table[i].size, law_table[i].trgt_id); } #ifdef CONFIG_SRIO_PCIE_BOOT_SLAVE /* check RCW to get which port is used for boot */ ccsr_gur_t *gur = (void *)CONFIG_SYS_MPC85xx_GUTS_ADDR; u32 bootloc = in_be32(&gur->rcwsr[6]); /* * in SRIO or PCIE boot we need to set specail LAWs for * SRIO or PCIE interfaces. */ switch ((bootloc & FSL_CORENET_RCWSR6_BOOT_LOC) >> 23) { case 0x0: /* boot from PCIE1 */ set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_SLAVE_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_1); set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_UCODE_ENV_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_1); break; case 0x1: /* boot from PCIE2 */ set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_SLAVE_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_2); set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_UCODE_ENV_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_2); break; case 0x2: /* boot from PCIE3 */ set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_SLAVE_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_3); set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_UCODE_ENV_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_PCIE_3); break; case 0x8: /* boot from SRIO1 */ set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_SLAVE_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_RIO_1); set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_UCODE_ENV_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_RIO_1); break; case 0x9: /* boot from SRIO2 */ set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_SLAVE_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_RIO_2); set_next_law(CONFIG_SYS_SRIO_PCIE_BOOT_UCODE_ENV_ADDR_PHYS, LAW_SIZE_1M, LAW_TRGT_IF_RIO_2); break; default: break; } #endif return ; }
static int scc_dma_end(ide_drive_t *drive) { ide_hwif_t *hwif = drive->hwif; void __iomem *dma_base = (void __iomem *)hwif->dma_base; unsigned long intsts_port = hwif->dma_base + 0x014; u32 reg; int dma_stat, data_loss = 0; static int retry = 0; /* errata A308 workaround: Step5 (check data loss) */ /* We don't check non ide_disk because it is limited to UDMA4 */ if (!(in_be32((void __iomem *)hwif->io_ports.ctl_addr) & ATA_ERR) && drive->media == ide_disk && drive->current_speed > XFER_UDMA_4) { reg = in_be32((void __iomem *)intsts_port); if (!(reg & INTSTS_ACTEINT)) { printk(KERN_WARNING "%s: operation failed (transfer data loss)\n", drive->name); data_loss = 1; if (retry++) { struct request *rq = hwif->rq; ide_drive_t *drive; int i; /* ERROR_RESET and drive->crc_count are needed * to reduce DMA transfer mode in retry process. */ if (rq) rq->errors |= ERROR_RESET; ide_port_for_each_dev(i, drive, hwif) drive->crc_count++; } } } while (1) { reg = in_be32((void __iomem *)intsts_port); if (reg & INTSTS_SERROR) { printk(KERN_WARNING "%s: SERROR\n", SCC_PATA_NAME); out_be32((void __iomem *)intsts_port, INTSTS_SERROR|INTSTS_BMSINT); out_be32(dma_base, in_be32(dma_base) & ~QCHCD_IOS_SS); continue; } if (reg & INTSTS_PRERR) { u32 maea0, maec0; unsigned long ctl_base = hwif->config_data; maea0 = in_be32((void __iomem *)(ctl_base + 0xF50)); maec0 = in_be32((void __iomem *)(ctl_base + 0xF54)); printk(KERN_WARNING "%s: PRERR [addr:%x cmd:%x]\n", SCC_PATA_NAME, maea0, maec0); out_be32((void __iomem *)intsts_port, INTSTS_PRERR|INTSTS_BMSINT); out_be32(dma_base, in_be32(dma_base) & ~QCHCD_IOS_SS); continue; } if (reg & INTSTS_RERR) { printk(KERN_WARNING "%s: Response Error\n", SCC_PATA_NAME); out_be32((void __iomem *)intsts_port, INTSTS_RERR|INTSTS_BMSINT); out_be32(dma_base, in_be32(dma_base) & ~QCHCD_IOS_SS); continue; } if (reg & INTSTS_ICERR) { out_be32(dma_base, in_be32(dma_base) & ~QCHCD_IOS_SS); printk(KERN_WARNING "%s: Illegal Configuration\n", SCC_PATA_NAME); out_be32((void __iomem *)intsts_port, INTSTS_ICERR|INTSTS_BMSINT); continue; } if (reg & INTSTS_BMSINT) { printk(KERN_WARNING "%s: Internal Bus Error\n", SCC_PATA_NAME); out_be32((void __iomem *)intsts_port, INTSTS_BMSINT); ide_do_reset(drive); continue; } if (reg & INTSTS_BMHE) { out_be32((void __iomem *)intsts_port, INTSTS_BMHE); continue; } if (reg & INTSTS_ACTEINT) { out_be32((void __iomem *)intsts_port, INTSTS_ACTEINT); continue; } if (reg & INTSTS_IOIRQS) { out_be32((void __iomem *)intsts_port, INTSTS_IOIRQS); continue; } break; } dma_stat = __scc_dma_end(drive); if (data_loss) dma_stat |= 2; /* emulate DMA error (to retry command) */ return dma_stat; }
/** * temac_dma_in32 - Memory mapped DMA read, this function expects a * register input that is based on DCR word addresses which * are then converted to memory mapped byte addresses */ static u32 temac_dma_in32(struct temac_local *lp, int reg) { return in_be32((u32 *)(lp->sdma_regs + (reg << 2))); }
int misc_init_r(void) { u32 pbcr; int size_val = 0; u32 post_magic; u32 post_val; post_magic = in_be32((void *)CONFIG_SYS_POST_MAGIC); post_val = in_be32((void *)CONFIG_SYS_POST_VAL); if ((post_magic == REBOOT_MAGIC) && (post_val == REBOOT_DO_POST)) { /* * Set special bootline bootparameter to pass this POST boot * mode to Linux to reset the username/password */ setenv("addmisc", "setenv bootargs \\${bootargs} factory_reset=yes"); /* * Normally don't run POST tests, only when enabled * via the sw-reset button. So disable further tests * upon next bootup here. */ out_be32((void *)CONFIG_SYS_POST_VAL, REBOOT_NOP); } else { /* * Only run POST when initiated via the sw-reset button mechanism */ post_word_store(0); } /* * Get current time */ start_time = get_timer(0); /* * FLASH stuff... */ /* Re-do sizing to get full correct info */ /* adjust flash start and offset */ mfebc(PB0CR, pbcr); switch (gd->bd->bi_flashsize) { case 1 << 20: size_val = 0; break; case 2 << 20: size_val = 1; break; case 4 << 20: size_val = 2; break; case 8 << 20: size_val = 3; break; case 16 << 20: size_val = 4; break; case 32 << 20: size_val = 5; break; case 64 << 20: size_val = 6; break; case 128 << 20: size_val = 7; break; } pbcr = (pbcr & 0x0001ffff) | gd->bd->bi_flashstart | (size_val << 17); mtebc(PB0CR, pbcr); /* * Re-check to get correct base address */ flash_get_size(gd->bd->bi_flashstart, 0); /* Monitor protection ON by default */ (void)flash_protect(FLAG_PROTECT_SET, -CONFIG_SYS_MONITOR_LEN, 0xffffffff, &flash_info[0]); /* Env protection ON by default */ (void)flash_protect(FLAG_PROTECT_SET, CONFIG_ENV_ADDR_REDUND, CONFIG_ENV_ADDR_REDUND + 2*CONFIG_ENV_SECT_SIZE - 1, &flash_info[0]); return 0; }
u32 temac_ior(struct temac_local *lp, int offset) { return in_be32((u32 *)(lp->regs + offset)); }
int do_caddy(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { unsigned long base_addr; uint32_t ptr; struct caddy_cmd *caddy_cmd; uint32_t result[5]; uint16_t data16; uint8_t data8; uint32_t status; pci_dev_t dev; void *pci_ptr; if (argc < 2) { puts("Missing parameter\n"); return 1; } base_addr = simple_strtoul(argv[1], NULL, 16); caddy_interface = (struct caddy_interface *) base_addr; memset((void *)caddy_interface, 0, sizeof(struct caddy_interface)); memcpy((void *)&caddy_interface->magic[0], &CADDY_MAGIC, 16); while (ctrlc() == 0) { if (caddy_interface->cmd_in != caddy_interface->cmd_out) { memset(result, 0, 5 * sizeof(result[0])); status = 0; caddy_cmd = &caddy_interface->cmd[caddy_interface->cmd_out]; pci_ptr = (void *)CONFIG_SYS_PCI1_IO_PHYS + (caddy_cmd->addr & 0x001fffff); switch (caddy_cmd->cmd) { case CADDY_CMD_IO_READ_8: result[0] = in_8(pci_ptr); break; case CADDY_CMD_IO_READ_16: result[0] = in_be16(pci_ptr); break; case CADDY_CMD_IO_READ_32: result[0] = in_be32(pci_ptr); break; case CADDY_CMD_IO_WRITE_8: data8 = caddy_cmd->par[0] & 0x000000ff; out_8(pci_ptr, data8); break; case CADDY_CMD_IO_WRITE_16: data16 = caddy_cmd->par[0] & 0x0000ffff; out_be16(pci_ptr, data16); break; case CADDY_CMD_IO_WRITE_32: out_be32(pci_ptr, caddy_cmd->par[0]); break; case CADDY_CMD_CONFIG_READ_8: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); status = pci_read_config_byte(dev, caddy_cmd->addr, &data8); result[0] = data8; break; case CADDY_CMD_CONFIG_READ_16: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); status = pci_read_config_word(dev, caddy_cmd->addr, &data16); result[0] = data16; break; case CADDY_CMD_CONFIG_READ_32: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); status = pci_read_config_dword(dev, caddy_cmd->addr, &result[0]); break; case CADDY_CMD_CONFIG_WRITE_8: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); data8 = caddy_cmd->par[3] & 0x000000ff; status = pci_write_config_byte(dev, caddy_cmd->addr, data8); break; case CADDY_CMD_CONFIG_WRITE_16: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); data16 = caddy_cmd->par[3] & 0x0000ffff; status = pci_write_config_word(dev, caddy_cmd->addr, data16); break; case CADDY_CMD_CONFIG_WRITE_32: dev = PCI_BDF(caddy_cmd->par[0], caddy_cmd->par[1], caddy_cmd->par[2]); status = pci_write_config_dword(dev, caddy_cmd->addr, caddy_cmd->par[3]); break; default: status = 0xffffffff; break; } generate_answer(caddy_cmd, status, &result[0]); ptr = caddy_interface->cmd_out + 1; ptr = ptr & (CMD_SIZE - 1); caddy_interface->cmd_out = ptr; } caddy_interface->heartbeat++; } return 0; }
/* * This function reads RCW to check if Serdes1{A:H} is configured * to slot 1/2/3/4/5/6/7 and update the lane_to_slot[] array accordingly */ static void initialize_lane_to_slot(void) { ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); u32 srds_s1 = in_be32(&gur->rcwsr[4]) & FSL_CORENET2_RCWSR4_SRDS1_PRTCL; srds_s1 >>= FSL_CORENET2_RCWSR4_SRDS1_PRTCL_SHIFT; switch (srds_s1) { #if defined(CONFIG_T2080QDS) case 0x51: case 0x5f: case 0x65: case 0x6b: case 0x71: lane_to_slot[5] = 2; lane_to_slot[6] = 2; lane_to_slot[7] = 2; break; case 0xa6: case 0x8e: case 0x8f: case 0x82: case 0x83: case 0xd3: case 0xd9: case 0xcb: lane_to_slot[6] = 2; lane_to_slot[7] = 2; break; case 0xda: lane_to_slot[4] = 3; lane_to_slot[5] = 3; lane_to_slot[6] = 3; lane_to_slot[7] = 3; break; #elif defined(CONFIG_T2081QDS) case 0x6b: lane_to_slot[4] = 1; lane_to_slot[5] = 3; lane_to_slot[6] = 3; lane_to_slot[7] = 3; break; case 0xca: case 0xcb: lane_to_slot[1] = 7; lane_to_slot[2] = 6; lane_to_slot[3] = 5; lane_to_slot[5] = 3; lane_to_slot[6] = 3; lane_to_slot[7] = 3; break; case 0xf2: lane_to_slot[1] = 7; lane_to_slot[2] = 7; lane_to_slot[3] = 7; lane_to_slot[5] = 4; lane_to_slot[6] = 3; lane_to_slot[7] = 7; break; #endif default: break; } }
static inline void bb_set(u32 __iomem *p, u32 m) { out_be32(p, in_be32(p) | m); }
/** * p1022ds_set_monitor_port: switch the output to a different monitor port */ static void p1022ds_set_monitor_port(enum fsl_diu_monitor_port port) { struct device_node *guts_node; struct device_node *lbc_node = NULL; struct device_node *law_node = NULL; struct ccsr_guts __iomem *guts; struct fsl_lbc_regs *lbc = NULL; void *ecm = NULL; u8 __iomem *lbc_lcs0_ba = NULL; u8 __iomem *lbc_lcs1_ba = NULL; phys_addr_t cs0_addr, cs1_addr; u32 br0, or0, br1, or1; const __be32 *iprop; unsigned int num_laws; u8 b; /* Map the global utilities registers. */ guts_node = of_find_compatible_node(NULL, NULL, "fsl,p1022-guts"); if (!guts_node) { pr_err("p1022ds: missing global utilities device node\n"); return; } guts = of_iomap(guts_node, 0); if (!guts) { pr_err("p1022ds: could not map global utilities device\n"); goto exit; } lbc_node = of_find_compatible_node(NULL, NULL, "fsl,p1022-elbc"); if (!lbc_node) { pr_err("p1022ds: missing localbus node\n"); goto exit; } lbc = of_iomap(lbc_node, 0); if (!lbc) { pr_err("p1022ds: could not map localbus node\n"); goto exit; } law_node = of_find_compatible_node(NULL, NULL, "fsl,ecm-law"); if (!law_node) { pr_err("p1022ds: missing local access window node\n"); goto exit; } ecm = of_iomap(law_node, 0); if (!ecm) { pr_err("p1022ds: could not map local access window node\n"); goto exit; } iprop = of_get_property(law_node, "fsl,num-laws", NULL); if (!iprop) { pr_err("p1022ds: LAW node is missing fsl,num-laws property\n"); goto exit; } num_laws = be32_to_cpup(iprop); /* * Indirect mode requires both BR0 and BR1 to be set to "GPCM", * otherwise writes to these addresses won't actually appear on the * local bus, and so the PIXIS won't see them. * * In FCM mode, writes go to the NAND controller, which does not pass * them to the localbus directly. So we force BR0 and BR1 into GPCM * mode, since we don't care about what's behind the localbus any * more. */ br0 = in_be32(&lbc->bank[0].br); br1 = in_be32(&lbc->bank[1].br); or0 = in_be32(&lbc->bank[0].or); or1 = in_be32(&lbc->bank[1].or); /* Make sure CS0 and CS1 are programmed */ if (!(br0 & BR_V) || !(br1 & BR_V)) { pr_err("p1022ds: CS0 and/or CS1 is not programmed\n"); goto exit; } /* * Use the existing BRx/ORx values if it's already GPCM. Otherwise, * force the values to simple 32KB GPCM windows with the most * conservative timing. */ if ((br0 & BR_MSEL) != BR_MS_GPCM) { br0 = (br0 & BR_BA) | BR_V; or0 = 0xFFFF8000 | 0xFF7; out_be32(&lbc->bank[0].br, br0); out_be32(&lbc->bank[0].or, or0); } if ((br1 & BR_MSEL) != BR_MS_GPCM) { br1 = (br1 & BR_BA) | BR_V; or1 = 0xFFFF8000 | 0xFF7; out_be32(&lbc->bank[1].br, br1); out_be32(&lbc->bank[1].or, or1); } cs0_addr = lbc_br_to_phys(ecm, num_laws, br0); if (!cs0_addr) { pr_err("p1022ds: could not determine physical address for CS0" " (BR0=%08x)\n", br0); goto exit; } cs1_addr = lbc_br_to_phys(ecm, num_laws, br1); if (!cs1_addr) { pr_err("p1022ds: could not determine physical address for CS1" " (BR1=%08x)\n", br1); goto exit; } lbc_lcs0_ba = ioremap(cs0_addr, 1); if (!lbc_lcs0_ba) { pr_err("p1022ds: could not ioremap CS0 address %llx\n", (unsigned long long)cs0_addr); goto exit; } lbc_lcs1_ba = ioremap(cs1_addr, 1); if (!lbc_lcs1_ba) { pr_err("p1022ds: could not ioremap CS1 address %llx\n", (unsigned long long)cs1_addr); goto exit; } /* Make sure we're in indirect mode first. */ if ((in_be32(&guts->pmuxcr) & PMUXCR_ELBCDIU_MASK) != PMUXCR_ELBCDIU_DIU) { struct device_node *pixis_node; void __iomem *pixis; pixis_node = of_find_compatible_node(NULL, NULL, "fsl,p1022ds-fpga"); if (!pixis_node) { pr_err("p1022ds: missing pixis node\n"); goto exit; } pixis = of_iomap(pixis_node, 0); of_node_put(pixis_node); if (!pixis) { pr_err("p1022ds: could not map pixis registers\n"); goto exit; } /* Enable indirect PIXIS mode. */ setbits8(pixis + PX_CTL, PX_CTL_ALTACC); iounmap(pixis); /* Switch the board mux to the DIU */ out_8(lbc_lcs0_ba, PX_BRDCFG0); /* BRDCFG0 */ b = in_8(lbc_lcs1_ba); b |= PX_BRDCFG0_ELBC_DIU; out_8(lbc_lcs1_ba, b); /* Set the chip mux to DIU mode. */ clrsetbits_be32(&guts->pmuxcr, PMUXCR_ELBCDIU_MASK, PMUXCR_ELBCDIU_DIU); in_be32(&guts->pmuxcr); } switch (port) { case FSL_DIU_PORT_DVI: /* Enable the DVI port, disable the DFP and the backlight */ out_8(lbc_lcs0_ba, PX_BRDCFG1); b = in_8(lbc_lcs1_ba); b &= ~(PX_BRDCFG1_DFPEN | PX_BRDCFG1_BACKLIGHT); b |= PX_BRDCFG1_DVIEN; out_8(lbc_lcs1_ba, b); break; case FSL_DIU_PORT_LVDS: /* * LVDS also needs backlight enabled, otherwise the display * will be blank. */ /* Enable the DFP port, disable the DVI and the backlight */ out_8(lbc_lcs0_ba, PX_BRDCFG1); b = in_8(lbc_lcs1_ba); b &= ~PX_BRDCFG1_DVIEN; b |= PX_BRDCFG1_DFPEN | PX_BRDCFG1_BACKLIGHT; out_8(lbc_lcs1_ba, b); break; default: pr_err("p1022ds: unsupported monitor port %i\n", port); } exit: if (lbc_lcs1_ba) iounmap(lbc_lcs1_ba); if (lbc_lcs0_ba) iounmap(lbc_lcs0_ba); if (lbc) iounmap(lbc); if (ecm) iounmap(ecm); if (guts) iounmap(guts); of_node_put(law_node); of_node_put(lbc_node); of_node_put(guts_node); }
static inline void bb_clr(u32 __iomem *p, u32 m) { out_be32(p, in_be32(p) & ~m); }
/* * Main initialization routine */ static int __init ppchameleonevb_init (void) { struct nand_chip *this; const char *part_type = 0; int mtd_parts_nb = 0; struct mtd_partition *mtd_parts = 0; void __iomem *ppchameleon_fio_base; void __iomem *ppchameleonevb_fio_base; /********************************* * Processor module NAND (if any) * *********************************/ /* Allocate memory for MTD device structure and private data */ ppchameleon_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL); if (!ppchameleon_mtd) { printk("Unable to allocate PPChameleon NAND MTD device structure.\n"); return -ENOMEM; } /* map physical address */ ppchameleon_fio_base = ioremap(ppchameleon_fio_pbase, SZ_4M); if(!ppchameleon_fio_base) { printk("ioremap PPChameleon NAND flash failed\n"); kfree(ppchameleon_mtd); return -EIO; } /* Get pointer to private data */ this = (struct nand_chip *) (&ppchameleon_mtd[1]); /* Initialize structures */ memset((char *) ppchameleon_mtd, 0, sizeof(struct mtd_info)); memset((char *) this, 0, sizeof(struct nand_chip)); /* Link the private data with the MTD structure */ ppchameleon_mtd->priv = this; /* Initialize GPIOs */ /* Pin mapping for NAND chip */ /* CE GPIO_01 CLE GPIO_02 ALE GPIO_03 R/B GPIO_04 */ /* output select */ out_be32((volatile unsigned*)GPIO0_OSRH, in_be32((volatile unsigned*)GPIO0_OSRH) & 0xC0FFFFFF); /* three-state select */ out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xC0FFFFFF); /* enable output driver */ out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) | NAND_nCE_GPIO_PIN | NAND_CLE_GPIO_PIN | NAND_ALE_GPIO_PIN); #ifdef USE_READY_BUSY_PIN /* three-state select */ out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xFF3FFFFF); /* high-impedecence */ out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) & (~NAND_RB_GPIO_PIN)); /* input select */ out_be32((volatile unsigned*)GPIO0_ISR1H, (in_be32((volatile unsigned*)GPIO0_ISR1H) & 0xFF3FFFFF) | 0x00400000); #endif /* insert callbacks */ this->IO_ADDR_R = ppchameleon_fio_base; this->IO_ADDR_W = ppchameleon_fio_base; this->hwcontrol = ppchameleon_hwcontrol; #ifdef USE_READY_BUSY_PIN this->dev_ready = ppchameleon_device_ready; #endif this->chip_delay = NAND_BIG_DELAY_US; /* ECC mode */ this->eccmode = NAND_ECC_SOFT; /* Scan to find existence of the device (it could not be mounted) */ if (nand_scan (ppchameleon_mtd, 1)) { iounmap((void *)ppchameleon_fio_base); kfree (ppchameleon_mtd); goto nand_evb_init; } #ifndef USE_READY_BUSY_PIN /* Adjust delay if necessary */ if (ppchameleon_mtd->size == NAND_SMALL_SIZE) this->chip_delay = NAND_SMALL_DELAY_US; #endif #ifdef CONFIG_MTD_PARTITIONS ppchameleon_mtd->name = "ppchameleon-nand"; mtd_parts_nb = parse_mtd_partitions(ppchameleon_mtd, part_probes, &mtd_parts, 0); if (mtd_parts_nb > 0) part_type = "command line"; else mtd_parts_nb = 0; #endif if (mtd_parts_nb == 0) { if (ppchameleon_mtd->size == NAND_SMALL_SIZE) mtd_parts = partition_info_me; else mtd_parts = partition_info_hi; mtd_parts_nb = NUM_PARTITIONS; part_type = "static"; } /* Register the partitions */ printk(KERN_NOTICE "Using %s partition definition\n", part_type); add_mtd_partitions(ppchameleon_mtd, mtd_parts, mtd_parts_nb); nand_evb_init: /**************************** * EVB NAND (always present) * ****************************/ /* Allocate memory for MTD device structure and private data */ ppchameleonevb_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL); if (!ppchameleonevb_mtd) { printk("Unable to allocate PPChameleonEVB NAND MTD device structure.\n"); return -ENOMEM; } /* map physical address */ ppchameleonevb_fio_base = ioremap(ppchameleonevb_fio_pbase, SZ_4M); if(!ppchameleonevb_fio_base) { printk("ioremap PPChameleonEVB NAND flash failed\n"); kfree(ppchameleonevb_mtd); return -EIO; } /* Get pointer to private data */ this = (struct nand_chip *) (&ppchameleonevb_mtd[1]); /* Initialize structures */ memset((char *) ppchameleonevb_mtd, 0, sizeof(struct mtd_info)); memset((char *) this, 0, sizeof(struct nand_chip)); /* Link the private data with the MTD structure */ ppchameleonevb_mtd->priv = this; /* Initialize GPIOs */ /* Pin mapping for NAND chip */ /* CE GPIO_14 CLE GPIO_15 ALE GPIO_16 R/B GPIO_31 */ /* output select */ out_be32((volatile unsigned*)GPIO0_OSRH, in_be32((volatile unsigned*)GPIO0_OSRH) & 0xFFFFFFF0); out_be32((volatile unsigned*)GPIO0_OSRL, in_be32((volatile unsigned*)GPIO0_OSRL) & 0x3FFFFFFF); /* three-state select */ out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xFFFFFFF0); out_be32((volatile unsigned*)GPIO0_TSRL, in_be32((volatile unsigned*)GPIO0_TSRL) & 0x3FFFFFFF); /* enable output driver */ out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) | NAND_EVB_nCE_GPIO_PIN | NAND_EVB_CLE_GPIO_PIN | NAND_EVB_ALE_GPIO_PIN); #ifdef USE_READY_BUSY_PIN /* three-state select */ out_be32((volatile unsigned*)GPIO0_TSRL, in_be32((volatile unsigned*)GPIO0_TSRL) & 0xFFFFFFFC); /* high-impedecence */ out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) & (~NAND_EVB_RB_GPIO_PIN)); /* input select */ out_be32((volatile unsigned*)GPIO0_ISR1L, (in_be32((volatile unsigned*)GPIO0_ISR1L) & 0xFFFFFFFC) | 0x00000001); #endif /* insert callbacks */ this->IO_ADDR_R = ppchameleonevb_fio_base; this->IO_ADDR_W = ppchameleonevb_fio_base; this->hwcontrol = ppchameleonevb_hwcontrol; #ifdef USE_READY_BUSY_PIN this->dev_ready = ppchameleonevb_device_ready; #endif this->chip_delay = NAND_SMALL_DELAY_US; /* ECC mode */ this->eccmode = NAND_ECC_SOFT; /* Scan to find existence of the device */ if (nand_scan (ppchameleonevb_mtd, 1)) { iounmap((void *)ppchameleonevb_fio_base); kfree (ppchameleonevb_mtd); return -ENXIO; } #ifdef CONFIG_MTD_PARTITIONS ppchameleonevb_mtd->name = NAND_EVB_MTD_NAME; mtd_parts_nb = parse_mtd_partitions(ppchameleonevb_mtd, part_probes_evb, &mtd_parts, 0); if (mtd_parts_nb > 0) part_type = "command line"; else mtd_parts_nb = 0; #endif if (mtd_parts_nb == 0) { mtd_parts = partition_info_evb; mtd_parts_nb = NUM_PARTITIONS; part_type = "static"; } /* Register the partitions */ printk(KERN_NOTICE "Using %s partition definition\n", part_type); add_mtd_partitions(ppchameleonevb_mtd, mtd_parts, mtd_parts_nb); /* Return happy */ return 0; }
static inline int bb_read(u32 __iomem *p, u32 m) { return (in_be32(p) & m) != 0; }
static void mpc83xx_suspend_save_regs(void) { saved_regs.sicrl = in_be32(&syscr_regs->sicrl); saved_regs.sicrh = in_be32(&syscr_regs->sicrh); saved_regs.sccr = in_be32(&clock_regs->sccr); }
static int __init pikawdt_init(void) { struct device_node *np; void __iomem *fpga; static u32 post1; int ret; np = of_find_compatible_node(NULL, NULL, "pika,fpga"); if (np == NULL) { printk(KERN_ERR PFX "Unable to find fpga.\n"); return -ENOENT; } pikawdt_private.fpga = of_iomap(np, 0); of_node_put(np); if (pikawdt_private.fpga == NULL) { printk(KERN_ERR PFX "Unable to map fpga.\n"); return -ENOMEM; } ident.firmware_version = in_be32(pikawdt_private.fpga + 0x1c) & 0xffff; /* POST information is in the sd area. */ np = of_find_compatible_node(NULL, NULL, "pika,fpga-sd"); if (np == NULL) { printk(KERN_ERR PFX "Unable to find fpga-sd.\n"); ret = -ENOENT; goto out; } fpga = of_iomap(np, 0); of_node_put(np); if (fpga == NULL) { printk(KERN_ERR PFX "Unable to map fpga-sd.\n"); ret = -ENOMEM; goto out; } /* -- FPGA: POST Test Results Register 1 (32bit R/W) (Offset: 0x4040) -- * Bit 31, WDOG: Set to 1 when the last reset was caused by a watchdog * timeout. */ post1 = in_be32(fpga + 0x40); if (post1 & 0x80000000) pikawdt_private.bootstatus = WDIOF_CARDRESET; iounmap(fpga); setup_timer(&pikawdt_private.timer, pikawdt_ping, 0); ret = misc_register(&pikawdt_miscdev); if (ret) { printk(KERN_ERR PFX "Unable to register miscdev.\n"); goto out; } printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n", heartbeat, nowayout); return 0; out: iounmap(pikawdt_private.fpga); return ret; }
u32 bm_pool_free_buffers(u32 bpid) { return in_be32(bman_ccsr_map + BMAN_POOL_CONTENT(bpid)); }
static uint dspi_read32(uint flags, uint *addr) { return flags & DSPI_FLAG_REGMAP_ENDIAN_BIG ? in_be32(addr) : in_le32(addr); }
static int __devinit rgmii_probe(struct platform_device *ofdev) { struct device_node *np = ofdev->dev.of_node; struct rgmii_instance *dev; struct resource regs; int rc; rc = -ENOMEM; dev = kzalloc(sizeof(struct rgmii_instance), GFP_KERNEL); if (dev == NULL) { printk(KERN_ERR "%s: could not allocate RGMII device!\n", np->full_name); goto err_gone; } mutex_init(&dev->lock); dev->ofdev = ofdev; rc = -ENXIO; if (of_address_to_resource(np, 0, ®s)) { printk(KERN_ERR "%s: Can't get registers address\n", np->full_name); goto err_free; } rc = -ENOMEM; dev->base = (struct rgmii_regs __iomem *)ioremap(regs.start, sizeof(struct rgmii_regs)); if (dev->base == NULL) { printk(KERN_ERR "%s: Can't map device registers!\n", np->full_name); goto err_free; } /* Check for RGMII flags */ if (of_get_property(ofdev->dev.of_node, "has-mdio", NULL)) dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO; /* CAB lacks the right properties, fix this up */ if (of_device_is_compatible(ofdev->dev.of_node, "ibm,rgmii-axon")) dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO; DBG2(dev, " Boot FER = 0x%08x, SSR = 0x%08x\n", in_be32(&dev->base->fer), in_be32(&dev->base->ssr)); /* Disable all inputs by default */ out_be32(&dev->base->fer, 0); printk(KERN_INFO "RGMII %s initialized with%s MDIO support\n", ofdev->dev.of_node->full_name, (dev->flags & EMAC_RGMII_FLAG_HAS_MDIO) ? "" : "out"); wmb(); dev_set_drvdata(&ofdev->dev, dev); return 0; err_free: kfree(dev); err_gone: return rc; }
static u8 scc_read_altstatus(ide_hwif_t *hwif) { return (u8)in_be32((void *)hwif->io_ports.ctl_addr); }