1 /* 2 * Broadcom specific AMBA 3 * PCI Core 4 * 5 * Copyright 2005, 2011, Broadcom Corporation 6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 7 * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de> 8 * 9 * Licensed under the GNU/GPL. See COPYING for details. 10 */ 11 12 #include "bcma_private.h" 13 #include <linux/export.h> 14 #include <linux/bcma/bcma.h> 15 16 /************************************************** 17 * R/W ops. 18 **************************************************/ 19 20 u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address) 21 { 22 pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address); 23 pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR); 24 return pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_DATA); 25 } 26 27 static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data) 28 { 29 pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address); 30 pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR); 31 pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_DATA, data); 32 } 33 34 static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u16 phy) 35 { 36 u32 v; 37 int i; 38 39 v = BCMA_CORE_PCI_MDIODATA_START; 40 v |= BCMA_CORE_PCI_MDIODATA_WRITE; 41 v |= (BCMA_CORE_PCI_MDIODATA_DEV_ADDR << 42 BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF); 43 v |= (BCMA_CORE_PCI_MDIODATA_BLK_ADDR << 44 BCMA_CORE_PCI_MDIODATA_REGADDR_SHF); 45 v |= BCMA_CORE_PCI_MDIODATA_TA; 46 v |= (phy << 4); 47 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v); 48 49 udelay(10); 50 for (i = 0; i < 200; i++) { 51 v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL); 52 if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) 53 break; 54 usleep_range(1000, 2000); 55 } 56 } 57 58 static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u16 device, u8 address) 59 { 60 int max_retries = 10; 61 u16 ret = 0; 62 u32 v; 63 int i; 64 65 /* enable mdio access to SERDES */ 66 v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN; 67 v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL; 68 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v); 69 70 if (pc->core->id.rev >= 10) { 71 max_retries = 200; 72 bcma_pcie_mdio_set_phy(pc, device); 73 v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR << 74 BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF); 75 v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF); 76 } else { 77 v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD); 78 v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD); 79 } 80 81 v = BCMA_CORE_PCI_MDIODATA_START; 82 v |= BCMA_CORE_PCI_MDIODATA_READ; 83 v |= BCMA_CORE_PCI_MDIODATA_TA; 84 85 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v); 86 /* Wait for the device to complete the transaction */ 87 udelay(10); 88 for (i = 0; i < max_retries; i++) { 89 v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL); 90 if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) { 91 udelay(10); 92 ret = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_DATA); 93 break; 94 } 95 usleep_range(1000, 2000); 96 } 97 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0); 98 return ret; 99 } 100 101 static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u16 device, 102 u8 address, u16 data) 103 { 104 int max_retries = 10; 105 u32 v; 106 int i; 107 108 /* enable mdio access to SERDES */ 109 v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN; 110 v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL; 111 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v); 112 113 if (pc->core->id.rev >= 10) { 114 max_retries = 200; 115 bcma_pcie_mdio_set_phy(pc, device); 116 v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR << 117 BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF); 118 v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF); 119 } else { 120 v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD); 121 v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD); 122 } 123 124 v = BCMA_CORE_PCI_MDIODATA_START; 125 v |= BCMA_CORE_PCI_MDIODATA_WRITE; 126 v |= BCMA_CORE_PCI_MDIODATA_TA; 127 v |= data; 128 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v); 129 /* Wait for the device to complete the transaction */ 130 udelay(10); 131 for (i = 0; i < max_retries; i++) { 132 v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL); 133 if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) 134 break; 135 usleep_range(1000, 2000); 136 } 137 pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0); 138 } 139 140 static u16 bcma_pcie_mdio_writeread(struct bcma_drv_pci *pc, u16 device, 141 u8 address, u16 data) 142 { 143 bcma_pcie_mdio_write(pc, device, address, data); 144 return bcma_pcie_mdio_read(pc, device, address); 145 } 146 147 /************************************************** 148 * Workarounds. 149 **************************************************/ 150 151 static u8 bcma_pcicore_polarity_workaround(struct bcma_drv_pci *pc) 152 { 153 u32 tmp; 154 155 tmp = bcma_pcie_read(pc, BCMA_CORE_PCI_PLP_STATUSREG); 156 if (tmp & BCMA_CORE_PCI_PLP_POLARITYINV_STAT) 157 return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE | 158 BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY; 159 else 160 return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE; 161 } 162 163 static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc) 164 { 165 u16 tmp; 166 167 bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_RX, 168 BCMA_CORE_PCI_SERDES_RX_CTRL, 169 bcma_pcicore_polarity_workaround(pc)); 170 tmp = bcma_pcie_mdio_read(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL, 171 BCMA_CORE_PCI_SERDES_PLL_CTRL); 172 if (tmp & BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN) 173 bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL, 174 BCMA_CORE_PCI_SERDES_PLL_CTRL, 175 tmp & ~BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN); 176 } 177 178 static void bcma_core_pci_fixcfg(struct bcma_drv_pci *pc) 179 { 180 struct bcma_device *core = pc->core; 181 u16 val16, core_index; 182 uint regoff; 183 184 regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_PI_OFFSET); 185 core_index = (u16)core->core_index; 186 187 val16 = pcicore_read16(pc, regoff); 188 if (((val16 & BCMA_CORE_PCI_SPROM_PI_MASK) >> BCMA_CORE_PCI_SPROM_PI_SHIFT) 189 != core_index) { 190 val16 = (core_index << BCMA_CORE_PCI_SPROM_PI_SHIFT) | 191 (val16 & ~BCMA_CORE_PCI_SPROM_PI_MASK); 192 pcicore_write16(pc, regoff, val16); 193 } 194 } 195 196 /* Fix MISC config to allow coming out of L2/L3-Ready state w/o PRST */ 197 /* Needs to happen when coming out of 'standby'/'hibernate' */ 198 static void bcma_core_pci_config_fixup(struct bcma_drv_pci *pc) 199 { 200 u16 val16; 201 uint regoff; 202 203 regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_MISC_CONFIG); 204 205 val16 = pcicore_read16(pc, regoff); 206 207 if (!(val16 & BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST)) { 208 val16 |= BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST; 209 pcicore_write16(pc, regoff, val16); 210 } 211 } 212 213 /************************************************** 214 * Init. 215 **************************************************/ 216 217 static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc) 218 { 219 bcma_core_pci_fixcfg(pc); 220 bcma_pcicore_serdes_workaround(pc); 221 bcma_core_pci_config_fixup(pc); 222 } 223 224 void bcma_core_pci_init(struct bcma_drv_pci *pc) 225 { 226 if (pc->setup_done) 227 return; 228 229 #ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE 230 pc->hostmode = bcma_core_pci_is_in_hostmode(pc); 231 if (pc->hostmode) 232 bcma_core_pci_hostmode_init(pc); 233 #endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */ 234 235 if (!pc->hostmode) 236 bcma_core_pci_clientmode_init(pc); 237 } 238 239 void bcma_core_pci_power_save(struct bcma_bus *bus, bool up) 240 { 241 struct bcma_drv_pci *pc; 242 u16 data; 243 244 if (bus->hosttype != BCMA_HOSTTYPE_PCI) 245 return; 246 247 pc = &bus->drv_pci[0]; 248 249 if (pc->core->id.rev >= 15 && pc->core->id.rev <= 20) { 250 data = up ? 0x74 : 0x7C; 251 bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1, 252 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7F64); 253 bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1, 254 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data); 255 } else if (pc->core->id.rev >= 21 && pc->core->id.rev <= 22) { 256 data = up ? 0x75 : 0x7D; 257 bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1, 258 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7E65); 259 bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1, 260 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data); 261 } 262 } 263 EXPORT_SYMBOL_GPL(bcma_core_pci_power_save); 264 265 int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core, 266 bool enable) 267 { 268 struct pci_dev *pdev; 269 u32 coremask, tmp; 270 int err = 0; 271 272 if (!pc || core->bus->hosttype != BCMA_HOSTTYPE_PCI) { 273 /* This bcma device is not on a PCI host-bus. So the IRQs are 274 * not routed through the PCI core. 275 * So we must not enable routing through the PCI core. */ 276 goto out; 277 } 278 279 pdev = pc->core->bus->host_pci; 280 281 err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp); 282 if (err) 283 goto out; 284 285 coremask = BIT(core->core_index) << 8; 286 if (enable) 287 tmp |= coremask; 288 else 289 tmp &= ~coremask; 290 291 err = pci_write_config_dword(pdev, BCMA_PCI_IRQMASK, tmp); 292 293 out: 294 return err; 295 } 296 EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl); 297 298 static void bcma_core_pci_extend_L1timer(struct bcma_drv_pci *pc, bool extend) 299 { 300 u32 w; 301 302 w = bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG); 303 if (extend) 304 w |= BCMA_CORE_PCI_ASPMTIMER_EXTEND; 305 else 306 w &= ~BCMA_CORE_PCI_ASPMTIMER_EXTEND; 307 bcma_pcie_write(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG, w); 308 bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG); 309 } 310 311 void bcma_core_pci_up(struct bcma_bus *bus) 312 { 313 struct bcma_drv_pci *pc; 314 315 if (bus->hosttype != BCMA_HOSTTYPE_PCI) 316 return; 317 318 pc = &bus->drv_pci[0]; 319 320 bcma_core_pci_extend_L1timer(pc, true); 321 } 322 EXPORT_SYMBOL_GPL(bcma_core_pci_up); 323 324 void bcma_core_pci_down(struct bcma_bus *bus) 325 { 326 struct bcma_drv_pci *pc; 327 328 if (bus->hosttype != BCMA_HOSTTYPE_PCI) 329 return; 330 331 pc = &bus->drv_pci[0]; 332 333 bcma_core_pci_extend_L1timer(pc, false); 334 } 335 EXPORT_SYMBOL_GPL(bcma_core_pci_down); 336