1 // SPDX-License-Identifier: GPL-2.0 2 /* Microchip LAN937X switch driver main logic 3 * Copyright (C) 2019-2022 Microchip Technology Inc. 4 */ 5 #include <linux/kernel.h> 6 #include <linux/module.h> 7 #include <linux/iopoll.h> 8 #include <linux/phy.h> 9 #include <linux/of_net.h> 10 #include <linux/of_mdio.h> 11 #include <linux/if_bridge.h> 12 #include <linux/if_vlan.h> 13 #include <linux/math.h> 14 #include <net/dsa.h> 15 #include <net/switchdev.h> 16 17 #include "lan937x_reg.h" 18 #include "ksz_common.h" 19 #include "lan937x.h" 20 21 static int lan937x_cfg(struct ksz_device *dev, u32 addr, u8 bits, bool set) 22 { 23 return regmap_update_bits(dev->regmap[0], addr, bits, set ? bits : 0); 24 } 25 26 static int lan937x_port_cfg(struct ksz_device *dev, int port, int offset, 27 u8 bits, bool set) 28 { 29 return regmap_update_bits(dev->regmap[0], PORT_CTRL_ADDR(port, offset), 30 bits, set ? bits : 0); 31 } 32 33 static int lan937x_enable_spi_indirect_access(struct ksz_device *dev) 34 { 35 u16 data16; 36 int ret; 37 38 /* Enable Phy access through SPI */ 39 ret = lan937x_cfg(dev, REG_GLOBAL_CTRL_0, SW_PHY_REG_BLOCK, false); 40 if (ret < 0) 41 return ret; 42 43 ret = ksz_read16(dev, REG_VPHY_SPECIAL_CTRL__2, &data16); 44 if (ret < 0) 45 return ret; 46 47 /* Allow SPI access */ 48 data16 |= VPHY_SPI_INDIRECT_ENABLE; 49 50 return ksz_write16(dev, REG_VPHY_SPECIAL_CTRL__2, data16); 51 } 52 53 static int lan937x_vphy_ind_addr_wr(struct ksz_device *dev, int addr, int reg) 54 { 55 u16 addr_base = REG_PORT_T1_PHY_CTRL_BASE; 56 u16 temp; 57 58 /* get register address based on the logical port */ 59 temp = PORT_CTRL_ADDR(addr, (addr_base + (reg << 2))); 60 61 return ksz_write16(dev, REG_VPHY_IND_ADDR__2, temp); 62 } 63 64 static int lan937x_internal_phy_write(struct ksz_device *dev, int addr, int reg, 65 u16 val) 66 { 67 unsigned int value; 68 int ret; 69 70 /* Check for internal phy port */ 71 if (!dev->info->internal_phy[addr]) 72 return -EOPNOTSUPP; 73 74 ret = lan937x_vphy_ind_addr_wr(dev, addr, reg); 75 if (ret < 0) 76 return ret; 77 78 /* Write the data to be written to the VPHY reg */ 79 ret = ksz_write16(dev, REG_VPHY_IND_DATA__2, val); 80 if (ret < 0) 81 return ret; 82 83 /* Write the Write En and Busy bit */ 84 ret = ksz_write16(dev, REG_VPHY_IND_CTRL__2, 85 (VPHY_IND_WRITE | VPHY_IND_BUSY)); 86 if (ret < 0) 87 return ret; 88 89 ret = regmap_read_poll_timeout(dev->regmap[1], REG_VPHY_IND_CTRL__2, 90 value, !(value & VPHY_IND_BUSY), 10, 91 1000); 92 if (ret < 0) { 93 dev_err(dev->dev, "Failed to write phy register\n"); 94 return ret; 95 } 96 97 return 0; 98 } 99 100 static int lan937x_internal_phy_read(struct ksz_device *dev, int addr, int reg, 101 u16 *val) 102 { 103 unsigned int value; 104 int ret; 105 106 /* Check for internal phy port, return 0xffff for non-existent phy */ 107 if (!dev->info->internal_phy[addr]) 108 return 0xffff; 109 110 ret = lan937x_vphy_ind_addr_wr(dev, addr, reg); 111 if (ret < 0) 112 return ret; 113 114 /* Write Read and Busy bit to start the transaction */ 115 ret = ksz_write16(dev, REG_VPHY_IND_CTRL__2, VPHY_IND_BUSY); 116 if (ret < 0) 117 return ret; 118 119 ret = regmap_read_poll_timeout(dev->regmap[1], REG_VPHY_IND_CTRL__2, 120 value, !(value & VPHY_IND_BUSY), 10, 121 1000); 122 if (ret < 0) { 123 dev_err(dev->dev, "Failed to read phy register\n"); 124 return ret; 125 } 126 127 /* Read the VPHY register which has the PHY data */ 128 return ksz_read16(dev, REG_VPHY_IND_DATA__2, val); 129 } 130 131 void lan937x_r_phy(struct ksz_device *dev, u16 addr, u16 reg, u16 *data) 132 { 133 lan937x_internal_phy_read(dev, addr, reg, data); 134 } 135 136 void lan937x_w_phy(struct ksz_device *dev, u16 addr, u16 reg, u16 val) 137 { 138 lan937x_internal_phy_write(dev, addr, reg, val); 139 } 140 141 static int lan937x_sw_mdio_read(struct mii_bus *bus, int addr, int regnum) 142 { 143 struct ksz_device *dev = bus->priv; 144 u16 val; 145 int ret; 146 147 if (regnum & MII_ADDR_C45) 148 return -EOPNOTSUPP; 149 150 ret = lan937x_internal_phy_read(dev, addr, regnum, &val); 151 if (ret < 0) 152 return ret; 153 154 return val; 155 } 156 157 static int lan937x_sw_mdio_write(struct mii_bus *bus, int addr, int regnum, 158 u16 val) 159 { 160 struct ksz_device *dev = bus->priv; 161 162 if (regnum & MII_ADDR_C45) 163 return -EOPNOTSUPP; 164 165 return lan937x_internal_phy_write(dev, addr, regnum, val); 166 } 167 168 static int lan937x_mdio_register(struct ksz_device *dev) 169 { 170 struct dsa_switch *ds = dev->ds; 171 struct device_node *mdio_np; 172 struct mii_bus *bus; 173 int ret; 174 175 mdio_np = of_get_child_by_name(dev->dev->of_node, "mdio"); 176 if (!mdio_np) { 177 dev_err(ds->dev, "no MDIO bus node\n"); 178 return -ENODEV; 179 } 180 181 bus = devm_mdiobus_alloc(ds->dev); 182 if (!bus) { 183 of_node_put(mdio_np); 184 return -ENOMEM; 185 } 186 187 bus->priv = dev; 188 bus->read = lan937x_sw_mdio_read; 189 bus->write = lan937x_sw_mdio_write; 190 bus->name = "lan937x slave smi"; 191 snprintf(bus->id, MII_BUS_ID_SIZE, "SMI-%d", ds->index); 192 bus->parent = ds->dev; 193 bus->phy_mask = ~ds->phys_mii_mask; 194 195 ds->slave_mii_bus = bus; 196 197 ret = devm_of_mdiobus_register(ds->dev, bus, mdio_np); 198 if (ret) { 199 dev_err(ds->dev, "unable to register MDIO bus %s\n", 200 bus->id); 201 } 202 203 of_node_put(mdio_np); 204 205 return ret; 206 } 207 208 int lan937x_reset_switch(struct ksz_device *dev) 209 { 210 u32 data32; 211 int ret; 212 213 /* reset switch */ 214 ret = lan937x_cfg(dev, REG_SW_OPERATION, SW_RESET, true); 215 if (ret < 0) 216 return ret; 217 218 /* Enable Auto Aging */ 219 ret = lan937x_cfg(dev, REG_SW_LUE_CTRL_1, SW_LINK_AUTO_AGING, true); 220 if (ret < 0) 221 return ret; 222 223 /* disable interrupts */ 224 ret = ksz_write32(dev, REG_SW_INT_MASK__4, SWITCH_INT_MASK); 225 if (ret < 0) 226 return ret; 227 228 ret = ksz_write32(dev, REG_SW_PORT_INT_MASK__4, 0xFF); 229 if (ret < 0) 230 return ret; 231 232 return ksz_read32(dev, REG_SW_PORT_INT_STATUS__4, &data32); 233 } 234 235 void lan937x_port_setup(struct ksz_device *dev, int port, bool cpu_port) 236 { 237 struct dsa_switch *ds = dev->ds; 238 u8 member; 239 240 /* enable tag tail for host port */ 241 if (cpu_port) 242 lan937x_port_cfg(dev, port, REG_PORT_CTRL_0, 243 PORT_TAIL_TAG_ENABLE, true); 244 245 /* disable frame check length field */ 246 lan937x_port_cfg(dev, port, REG_PORT_MAC_CTRL_0, PORT_CHECK_LENGTH, 247 false); 248 249 /* set back pressure for half duplex */ 250 lan937x_port_cfg(dev, port, REG_PORT_MAC_CTRL_1, PORT_BACK_PRESSURE, 251 true); 252 253 /* enable 802.1p priority */ 254 lan937x_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_PRIO_ENABLE, true); 255 256 if (!dev->info->internal_phy[port]) 257 lan937x_port_cfg(dev, port, REG_PORT_XMII_CTRL_0, 258 PORT_MII_TX_FLOW_CTRL | PORT_MII_RX_FLOW_CTRL, 259 true); 260 261 if (cpu_port) 262 member = dsa_user_ports(ds); 263 else 264 member = BIT(dsa_upstream_port(ds, port)); 265 266 dev->dev_ops->cfg_port_member(dev, port, member); 267 } 268 269 void lan937x_config_cpu_port(struct dsa_switch *ds) 270 { 271 struct ksz_device *dev = ds->priv; 272 struct dsa_port *dp; 273 274 dsa_switch_for_each_cpu_port(dp, ds) { 275 if (dev->info->cpu_ports & (1 << dp->index)) { 276 dev->cpu_port = dp->index; 277 278 /* enable cpu port */ 279 lan937x_port_setup(dev, dp->index, true); 280 } 281 } 282 283 dsa_switch_for_each_user_port(dp, ds) { 284 ksz_port_stp_state_set(ds, dp->index, BR_STATE_DISABLED); 285 } 286 } 287 288 int lan937x_change_mtu(struct ksz_device *dev, int port, int new_mtu) 289 { 290 struct dsa_switch *ds = dev->ds; 291 int ret; 292 293 new_mtu += VLAN_ETH_HLEN + ETH_FCS_LEN; 294 295 if (dsa_is_cpu_port(ds, port)) 296 new_mtu += LAN937X_TAG_LEN; 297 298 if (new_mtu >= FR_MIN_SIZE) 299 ret = lan937x_port_cfg(dev, port, REG_PORT_MAC_CTRL_0, 300 PORT_JUMBO_PACKET, true); 301 else 302 ret = lan937x_port_cfg(dev, port, REG_PORT_MAC_CTRL_0, 303 PORT_JUMBO_PACKET, false); 304 if (ret < 0) { 305 dev_err(ds->dev, "failed to enable jumbo\n"); 306 return ret; 307 } 308 309 /* Write the frame size in PORT_MAX_FR_SIZE register */ 310 ksz_pwrite16(dev, port, PORT_MAX_FR_SIZE, new_mtu); 311 312 return 0; 313 } 314 315 static void lan937x_config_gbit(struct ksz_device *dev, bool gbit, u8 *data) 316 { 317 if (gbit) 318 *data &= ~PORT_MII_NOT_1GBIT; 319 else 320 *data |= PORT_MII_NOT_1GBIT; 321 } 322 323 static void lan937x_mac_config(struct ksz_device *dev, int port, 324 phy_interface_t interface) 325 { 326 u8 data8; 327 328 ksz_pread8(dev, port, REG_PORT_XMII_CTRL_1, &data8); 329 330 /* clear MII selection & set it based on interface later */ 331 data8 &= ~PORT_MII_SEL_M; 332 333 /* configure MAC based on interface */ 334 switch (interface) { 335 case PHY_INTERFACE_MODE_MII: 336 lan937x_config_gbit(dev, false, &data8); 337 data8 |= PORT_MII_SEL; 338 break; 339 case PHY_INTERFACE_MODE_RMII: 340 lan937x_config_gbit(dev, false, &data8); 341 data8 |= PORT_RMII_SEL; 342 break; 343 default: 344 dev_err(dev->dev, "Unsupported interface '%s' for port %d\n", 345 phy_modes(interface), port); 346 return; 347 } 348 349 /* Write the updated value */ 350 ksz_pwrite8(dev, port, REG_PORT_XMII_CTRL_1, data8); 351 } 352 353 static void lan937x_config_interface(struct ksz_device *dev, int port, 354 int speed, int duplex, 355 bool tx_pause, bool rx_pause) 356 { 357 u8 xmii_ctrl0, xmii_ctrl1; 358 359 ksz_pread8(dev, port, REG_PORT_XMII_CTRL_0, &xmii_ctrl0); 360 ksz_pread8(dev, port, REG_PORT_XMII_CTRL_1, &xmii_ctrl1); 361 362 xmii_ctrl0 &= ~(PORT_MII_100MBIT | PORT_MII_FULL_DUPLEX | 363 PORT_MII_TX_FLOW_CTRL | PORT_MII_RX_FLOW_CTRL); 364 365 if (speed == SPEED_1000) 366 lan937x_config_gbit(dev, true, &xmii_ctrl1); 367 else 368 lan937x_config_gbit(dev, false, &xmii_ctrl1); 369 370 if (speed == SPEED_100) 371 xmii_ctrl0 |= PORT_MII_100MBIT; 372 373 if (duplex) 374 xmii_ctrl0 |= PORT_MII_FULL_DUPLEX; 375 376 if (tx_pause) 377 xmii_ctrl0 |= PORT_MII_TX_FLOW_CTRL; 378 379 if (rx_pause) 380 xmii_ctrl0 |= PORT_MII_RX_FLOW_CTRL; 381 382 ksz_pwrite8(dev, port, REG_PORT_XMII_CTRL_0, xmii_ctrl0); 383 ksz_pwrite8(dev, port, REG_PORT_XMII_CTRL_1, xmii_ctrl1); 384 } 385 386 void lan937x_phylink_get_caps(struct ksz_device *dev, int port, 387 struct phylink_config *config) 388 { 389 config->mac_capabilities = MAC_100FD; 390 391 if (dev->info->supports_rgmii[port]) { 392 /* MII/RMII/RGMII ports */ 393 config->mac_capabilities |= MAC_ASYM_PAUSE | MAC_SYM_PAUSE | 394 MAC_100HD | MAC_10 | MAC_1000FD; 395 } 396 } 397 398 void lan937x_phylink_mac_link_up(struct ksz_device *dev, int port, 399 unsigned int mode, phy_interface_t interface, 400 struct phy_device *phydev, int speed, 401 int duplex, bool tx_pause, bool rx_pause) 402 { 403 /* Internal PHYs */ 404 if (dev->info->internal_phy[port]) 405 return; 406 407 lan937x_config_interface(dev, port, speed, duplex, 408 tx_pause, rx_pause); 409 } 410 411 void lan937x_phylink_mac_config(struct ksz_device *dev, int port, 412 unsigned int mode, 413 const struct phylink_link_state *state) 414 { 415 /* Internal PHYs */ 416 if (dev->info->internal_phy[port]) 417 return; 418 419 if (phylink_autoneg_inband(mode)) { 420 dev_err(dev->dev, "In-band AN not supported!\n"); 421 return; 422 } 423 424 lan937x_mac_config(dev, port, state->interface); 425 } 426 427 int lan937x_setup(struct dsa_switch *ds) 428 { 429 struct ksz_device *dev = ds->priv; 430 int ret; 431 432 /* enable Indirect Access from SPI to the VPHY registers */ 433 ret = lan937x_enable_spi_indirect_access(dev); 434 if (ret < 0) { 435 dev_err(dev->dev, "failed to enable spi indirect access"); 436 return ret; 437 } 438 439 ret = lan937x_mdio_register(dev); 440 if (ret < 0) { 441 dev_err(dev->dev, "failed to register the mdio"); 442 return ret; 443 } 444 445 /* The VLAN aware is a global setting. Mixed vlan 446 * filterings are not supported. 447 */ 448 ds->vlan_filtering_is_global = true; 449 450 /* Enable aggressive back off for half duplex & UNH mode */ 451 lan937x_cfg(dev, REG_SW_MAC_CTRL_0, 452 (SW_PAUSE_UNH_MODE | SW_NEW_BACKOFF | SW_AGGR_BACKOFF), 453 true); 454 455 /* If NO_EXC_COLLISION_DROP bit is set, the switch will not drop 456 * packets when 16 or more collisions occur 457 */ 458 lan937x_cfg(dev, REG_SW_MAC_CTRL_1, NO_EXC_COLLISION_DROP, true); 459 460 /* enable global MIB counter freeze function */ 461 lan937x_cfg(dev, REG_SW_MAC_CTRL_6, SW_MIB_COUNTER_FREEZE, true); 462 463 /* disable CLK125 & CLK25, 1: disable, 0: enable */ 464 lan937x_cfg(dev, REG_SW_GLOBAL_OUTPUT_CTRL__1, 465 (SW_CLK125_ENB | SW_CLK25_ENB), true); 466 467 return 0; 468 } 469 470 int lan937x_switch_init(struct ksz_device *dev) 471 { 472 dev->port_mask = (1 << dev->info->port_cnt) - 1; 473 474 return 0; 475 } 476 477 void lan937x_switch_exit(struct ksz_device *dev) 478 { 479 lan937x_reset_switch(dev); 480 } 481 482 MODULE_AUTHOR("Arun Ramadoss <arun.ramadoss@microchip.com>"); 483 MODULE_DESCRIPTION("Microchip LAN937x Series Switch DSA Driver"); 484 MODULE_LICENSE("GPL"); 485