1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2012 Gary Mills 24 * 25 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 26 */ 27 /* 28 * Copyright (c) 2008, Pyun YongHyeon <yongari@FreeBSD.org> 29 * All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 1. Redistributions of source code must retain the above copyright 35 * notice unmodified, this list of conditions, and the following 36 * disclaimer. 37 * 2. Redistributions in binary form must reproduce the above copyright 38 * notice, this list of conditions and the following disclaimer in the 39 * documentation and/or other materials provided with the distribution. 40 * 41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 */ 53 54 #include <sys/mii.h> 55 #include <sys/miiregs.h> 56 57 #include "atge.h" 58 #include "atge_cmn_reg.h" 59 #include "atge_l1c_reg.h" 60 #include "atge_l1e_reg.h" 61 #include "atge_l1_reg.h" 62 63 uint16_t 64 atge_mii_read(void *arg, uint8_t phy, uint8_t reg) 65 { 66 atge_t *atgep = arg; 67 uint32_t v; 68 int i; 69 70 mutex_enter(&atgep->atge_mii_lock); 71 72 OUTL(atgep, ATGE_MDIO, MDIO_OP_EXECUTE | MDIO_OP_READ | 73 MDIO_SUP_PREAMBLE | MDIO_CLK_25_4 | MDIO_REG_ADDR(reg)); 74 75 for (i = PHY_TIMEOUT; i > 0; i--) { 76 drv_usecwait(5); 77 v = INL(atgep, ATGE_MDIO); 78 if ((v & (MDIO_OP_EXECUTE | MDIO_OP_BUSY)) == 0) 79 break; 80 } 81 82 mutex_exit(&atgep->atge_mii_lock); 83 84 if (i == 0) { 85 atge_error(atgep->atge_dip, "PHY (%d) read timeout : %d", 86 phy, reg); 87 88 return (0xffff); 89 } 90 91 /* 92 * Some fast ethernet chips may not be able to auto-nego with 93 * switches even though they have 1000T based PHY. Hence we mask 94 * 1000T based capabilities. 95 */ 96 if (atgep->atge_flags & ATGE_FLAG_FASTETHER) { 97 if (reg == MII_STATUS) 98 v &= ~MII_STATUS_EXTSTAT; 99 else if (reg == MII_EXTSTATUS) 100 v = 0; 101 } 102 103 return ((v & MDIO_DATA_MASK) >> MDIO_DATA_SHIFT); 104 } 105 106 void 107 atge_mii_write(void *arg, uint8_t phy, uint8_t reg, uint16_t val) 108 { 109 atge_t *atgep = arg; 110 uint32_t v; 111 int i; 112 113 mutex_enter(&atgep->atge_mii_lock); 114 115 OUTL(atgep, ATGE_MDIO, MDIO_OP_EXECUTE | MDIO_OP_WRITE | 116 (val & MDIO_DATA_MASK) << MDIO_DATA_SHIFT | 117 MDIO_SUP_PREAMBLE | MDIO_CLK_25_4 | MDIO_REG_ADDR(reg)); 118 119 for (i = PHY_TIMEOUT; i > 0; i--) { 120 drv_usecwait(5); 121 v = INL(atgep, ATGE_MDIO); 122 if ((v & (MDIO_OP_EXECUTE | MDIO_OP_BUSY)) == 0) 123 break; 124 } 125 126 mutex_exit(&atgep->atge_mii_lock); 127 128 if (i == 0) { 129 atge_error(atgep->atge_dip, "PHY (%d) write timeout:reg %d," 130 " val :%d", phy, reg, val); 131 } 132 } 133 134 void 135 atge_l1e_mii_reset(void *arg) 136 { 137 atge_t *atgep = arg; 138 int phyaddr; 139 140 phyaddr = mii_get_addr(atgep->atge_mii); 141 142 OUTW(atgep, ATGE_GPHY_CTRL, 143 GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE | GPHY_CTRL_SEL_ANA_RESET | 144 GPHY_CTRL_PHY_PLL_ON); 145 drv_usecwait(1000); 146 147 OUTW(atgep, ATGE_GPHY_CTRL, 148 GPHY_CTRL_EXT_RESET | GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE | 149 GPHY_CTRL_SEL_ANA_RESET | GPHY_CTRL_PHY_PLL_ON); 150 drv_usecwait(1000); 151 152 /* 153 * Some fast ethernet chips may not be able to auto-nego with 154 * switches even though they have 1000T based PHY. Hence we need 155 * to write 0 to MII_MSCONTROL control register. 156 */ 157 if (atgep->atge_flags & ATGE_FLAG_FASTETHER) 158 atge_mii_write(atgep, phyaddr, MII_MSCONTROL, 0x0); 159 160 /* Enable hibernation mode. */ 161 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x0B); 162 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0xBC00); 163 164 /* Set Class A/B for all modes. */ 165 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x00); 166 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x02EF); 167 168 /* Enable 10BT power saving. */ 169 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x12); 170 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x4C04); 171 172 /* Adjust 1000T power. */ 173 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x04); 174 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x8BBB); 175 176 /* 10BT center tap voltage. */ 177 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x05); 178 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x2C46); 179 drv_usecwait(1000); 180 } 181 182 void 183 atge_l1_mii_reset(void *arg) 184 { 185 atge_t *atgep = arg; 186 int linkup, i; 187 uint16_t reg, pn; 188 int phyaddr; 189 190 phyaddr = mii_get_addr(atgep->atge_mii); 191 192 OUTL(atgep, ATGE_GPHY_CTRL, GPHY_CTRL_RST); 193 drv_usecwait(1000); 194 195 OUTL(atgep, ATGE_GPHY_CTRL, GPHY_CTRL_CLR); 196 drv_usecwait(1000); 197 198 atge_mii_write(atgep, phyaddr, MII_CONTROL, MII_CONTROL_RESET); 199 200 for (linkup = 0, pn = 0; pn < 4; pn++) { 201 atge_mii_write(atgep, phyaddr, ATPHY_CDTC, 202 (pn << PHY_CDTC_POFF) | PHY_CDTC_ENB); 203 204 for (i = 200; i > 0; i--) { 205 drv_usecwait(1000); 206 207 reg = atge_mii_read(atgep, phyaddr, ATPHY_CDTC); 208 209 if ((reg & PHY_CDTC_ENB) == 0) 210 break; 211 } 212 213 drv_usecwait(1000); 214 215 reg = atge_mii_read(atgep, phyaddr, ATPHY_CDTS); 216 217 if ((reg & PHY_CDTS_STAT_MASK) != PHY_CDTS_STAT_OPEN) { 218 linkup++; 219 break; 220 } 221 } 222 223 atge_mii_write(atgep, phyaddr, MII_CONTROL, 224 MII_CONTROL_RESET | MII_CONTROL_ANE | MII_CONTROL_RSAN); 225 226 if (linkup == 0) { 227 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0); 228 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x124E); 229 230 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 1); 231 reg = atge_mii_read(atgep, phyaddr, ATPHY_DBG_DATA); 232 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, reg | 0x03); 233 234 drv_usecwait(1500 * 1000); 235 236 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0); 237 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x024E); 238 } 239 } 240 241 void 242 atge_l1c_mii_reset(void *arg) 243 { 244 atge_t *atgep = arg; 245 uint16_t data; 246 int phyaddr; 247 248 phyaddr = mii_get_addr(atgep->atge_mii); 249 250 /* Reset magic from Linux, via Freebsd */ 251 OUTW(atgep, ATGE_GPHY_CTRL, 252 GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE | GPHY_CTRL_SEL_ANA_RESET); 253 (void) INW(atgep, ATGE_GPHY_CTRL); 254 drv_usecwait(10 * 1000); 255 256 OUTW(atgep, ATGE_GPHY_CTRL, 257 GPHY_CTRL_EXT_RESET | GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE | 258 GPHY_CTRL_SEL_ANA_RESET); 259 (void) INW(atgep, ATGE_GPHY_CTRL); 260 drv_usecwait(10 * 1000); 261 262 /* 263 * Some fast ethernet chips may not be able to auto-nego with 264 * switches even though they have 1000T based PHY. Hence we need 265 * to write 0 to MII_MSCONTROL control register. 266 */ 267 if (atgep->atge_flags & ATGE_FLAG_FASTETHER) 268 atge_mii_write(atgep, phyaddr, MII_MSCONTROL, 0x0); 269 270 /* DSP fixup, Vendor magic. */ 271 switch (ATGE_DID(atgep)) { 272 uint16_t reg; 273 274 case ATGE_CHIP_AR8152V1_DEV_ID: 275 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x000A); 276 reg = atge_mii_read(atgep, phyaddr, ATPHY_DBG_DATA); 277 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, reg & 0xDFFF); 278 /* FALLTHROUGH */ 279 case ATGE_CHIP_AR8151V2_DEV_ID: 280 case ATGE_CHIP_AR8151V1_DEV_ID: 281 case ATGE_CHIP_AR8152V2_DEV_ID: 282 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x003B); 283 reg = atge_mii_read(atgep, phyaddr, ATPHY_DBG_DATA); 284 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, reg & 0xFFF7); 285 drv_usecwait(20 * 1000); 286 break; 287 } 288 289 switch (ATGE_DID(atgep)) { 290 case ATGE_CHIP_AR8151V1_DEV_ID: 291 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x0029); 292 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0x929D); 293 break; 294 case ATGE_CHIP_AR8151V2_DEV_ID: 295 case ATGE_CHIP_AR8152V2_DEV_ID: 296 case ATGE_CHIP_L1CG_DEV_ID: 297 case ATGE_CHIP_L1CF_DEV_ID: 298 atge_mii_write(atgep, phyaddr, ATPHY_DBG_ADDR, 0x0029); 299 atge_mii_write(atgep, phyaddr, ATPHY_DBG_DATA, 0xB6DD); 300 break; 301 } 302 303 /* Load DSP codes, vendor magic. */ 304 data = ANA_LOOP_SEL_10BT | ANA_EN_MASK_TB | ANA_EN_10BT_IDLE | 305 ((1 << ANA_INTERVAL_SEL_TIMER_SHIFT) & 306 ANA_INTERVAL_SEL_TIMER_MASK); 307 atge_mii_write(atgep, phyaddr, 308 ATPHY_DBG_ADDR, MII_ANA_CFG18); 309 atge_mii_write(atgep, phyaddr, 310 ATPHY_DBG_DATA, data); 311 312 data = ((2 << ANA_SERDES_CDR_BW_SHIFT) & ANA_SERDES_CDR_BW_MASK) | 313 ANA_MS_PAD_DBG | ANA_SERDES_EN_DEEM | ANA_SERDES_SEL_HSP | 314 ANA_SERDES_EN_PLL | ANA_SERDES_EN_LCKDT; 315 atge_mii_write(atgep, phyaddr, 316 ATPHY_DBG_ADDR, MII_ANA_CFG5); 317 atge_mii_write(atgep, phyaddr, 318 ATPHY_DBG_DATA, data); 319 320 data = ((44 << ANA_LONG_CABLE_TH_100_SHIFT) & 321 ANA_LONG_CABLE_TH_100_MASK) | 322 ((33 << ANA_SHORT_CABLE_TH_100_SHIFT) & 323 ANA_SHORT_CABLE_TH_100_SHIFT) | 324 ANA_BP_BAD_LINK_ACCUM | ANA_BP_SMALL_BW; 325 atge_mii_write(atgep, phyaddr, 326 ATPHY_DBG_ADDR, MII_ANA_CFG54); 327 atge_mii_write(atgep, phyaddr, 328 ATPHY_DBG_DATA, data); 329 330 data = ((11 << ANA_IECHO_ADJ_3_SHIFT) & ANA_IECHO_ADJ_3_MASK) | 331 ((11 << ANA_IECHO_ADJ_2_SHIFT) & ANA_IECHO_ADJ_2_MASK) | 332 ((8 << ANA_IECHO_ADJ_1_SHIFT) & ANA_IECHO_ADJ_1_MASK) | 333 ((8 << ANA_IECHO_ADJ_0_SHIFT) & ANA_IECHO_ADJ_0_MASK); 334 atge_mii_write(atgep, phyaddr, 335 ATPHY_DBG_ADDR, MII_ANA_CFG4); 336 atge_mii_write(atgep, phyaddr, 337 ATPHY_DBG_DATA, data); 338 339 data = ((7 & ANA_MANUL_SWICH_ON_SHIFT) & ANA_MANUL_SWICH_ON_MASK) | 340 ANA_RESTART_CAL | ANA_MAN_ENABLE | ANA_SEL_HSP | ANA_EN_HB | 341 ANA_OEN_125M; 342 atge_mii_write(atgep, phyaddr, 343 ATPHY_DBG_ADDR, MII_ANA_CFG0); 344 atge_mii_write(atgep, phyaddr, 345 ATPHY_DBG_DATA, data); 346 drv_usecwait(1000); 347 } 348 349 uint16_t 350 atge_l1c_mii_read(void *arg, uint8_t phy, uint8_t reg) 351 { 352 353 if (phy != 0) { 354 /* avoid PHY address alias */ 355 return (0xffffU); 356 } 357 358 return (atge_mii_read(arg, phy, reg)); 359 } 360 361 void 362 atge_l1c_mii_write(void *arg, uint8_t phy, uint8_t reg, uint16_t val) 363 { 364 365 if (phy != 0) { 366 /* avoid PHY address alias */ 367 return; 368 } 369 370 if (reg == MII_CONTROL) { 371 /* 372 * Don't issue a reset if MII_CONTROL_RESET is set. 373 * Otherwise it occasionally 374 * advertises incorrect capability. 375 */ 376 if ((val & MII_CONTROL_RESET) == 0) { 377 /* RESET bit is required to set mode */ 378 atge_mii_write(arg, phy, reg, val | MII_CONTROL_RESET); 379 } 380 } else { 381 atge_mii_write(arg, phy, reg, val); 382 } 383 } 384