1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip switch driver main logic 4 * 5 * Copyright (C) 2017-2019 Microchip Technology Inc. 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/export.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/platform_data/microchip-ksz.h> 14 #include <linux/phy.h> 15 #include <linux/etherdevice.h> 16 #include <linux/if_bridge.h> 17 #include <linux/of_net.h> 18 #include <net/dsa.h> 19 #include <net/switchdev.h> 20 21 #include "ksz_common.h" 22 23 void ksz_update_port_member(struct ksz_device *dev, int port) 24 { 25 struct ksz_port *p = &dev->ports[port]; 26 struct dsa_switch *ds = dev->ds; 27 u8 port_member = 0, cpu_port; 28 const struct dsa_port *dp; 29 int i, j; 30 31 if (!dsa_is_user_port(ds, port)) 32 return; 33 34 dp = dsa_to_port(ds, port); 35 cpu_port = BIT(dsa_upstream_port(ds, port)); 36 37 for (i = 0; i < ds->num_ports; i++) { 38 const struct dsa_port *other_dp = dsa_to_port(ds, i); 39 struct ksz_port *other_p = &dev->ports[i]; 40 u8 val = 0; 41 42 if (!dsa_is_user_port(ds, i)) 43 continue; 44 if (port == i) 45 continue; 46 if (!dsa_port_bridge_same(dp, other_dp)) 47 continue; 48 if (other_p->stp_state != BR_STATE_FORWARDING) 49 continue; 50 51 if (p->stp_state == BR_STATE_FORWARDING) { 52 val |= BIT(port); 53 port_member |= BIT(i); 54 } 55 56 /* Retain port [i]'s relationship to other ports than [port] */ 57 for (j = 0; j < ds->num_ports; j++) { 58 const struct dsa_port *third_dp; 59 struct ksz_port *third_p; 60 61 if (j == i) 62 continue; 63 if (j == port) 64 continue; 65 if (!dsa_is_user_port(ds, j)) 66 continue; 67 third_p = &dev->ports[j]; 68 if (third_p->stp_state != BR_STATE_FORWARDING) 69 continue; 70 third_dp = dsa_to_port(ds, j); 71 if (dsa_port_bridge_same(other_dp, third_dp)) 72 val |= BIT(j); 73 } 74 75 dev->dev_ops->cfg_port_member(dev, i, val | cpu_port); 76 } 77 78 dev->dev_ops->cfg_port_member(dev, port, port_member | cpu_port); 79 } 80 EXPORT_SYMBOL_GPL(ksz_update_port_member); 81 82 static void port_r_cnt(struct ksz_device *dev, int port) 83 { 84 struct ksz_port_mib *mib = &dev->ports[port].mib; 85 u64 *dropped; 86 87 /* Some ports may not have MIB counters before SWITCH_COUNTER_NUM. */ 88 while (mib->cnt_ptr < dev->reg_mib_cnt) { 89 dev->dev_ops->r_mib_cnt(dev, port, mib->cnt_ptr, 90 &mib->counters[mib->cnt_ptr]); 91 ++mib->cnt_ptr; 92 } 93 94 /* last one in storage */ 95 dropped = &mib->counters[dev->mib_cnt]; 96 97 /* Some ports may not have MIB counters after SWITCH_COUNTER_NUM. */ 98 while (mib->cnt_ptr < dev->mib_cnt) { 99 dev->dev_ops->r_mib_pkt(dev, port, mib->cnt_ptr, 100 dropped, &mib->counters[mib->cnt_ptr]); 101 ++mib->cnt_ptr; 102 } 103 mib->cnt_ptr = 0; 104 } 105 106 static void ksz_mib_read_work(struct work_struct *work) 107 { 108 struct ksz_device *dev = container_of(work, struct ksz_device, 109 mib_read.work); 110 struct ksz_port_mib *mib; 111 struct ksz_port *p; 112 int i; 113 114 for (i = 0; i < dev->port_cnt; i++) { 115 if (dsa_is_unused_port(dev->ds, i)) 116 continue; 117 118 p = &dev->ports[i]; 119 mib = &p->mib; 120 mutex_lock(&mib->cnt_mutex); 121 122 /* Only read MIB counters when the port is told to do. 123 * If not, read only dropped counters when link is not up. 124 */ 125 if (!p->read) { 126 const struct dsa_port *dp = dsa_to_port(dev->ds, i); 127 128 if (!netif_carrier_ok(dp->slave)) 129 mib->cnt_ptr = dev->reg_mib_cnt; 130 } 131 port_r_cnt(dev, i); 132 p->read = false; 133 134 if (dev->dev_ops->r_mib_stat64) 135 dev->dev_ops->r_mib_stat64(dev, i); 136 137 mutex_unlock(&mib->cnt_mutex); 138 } 139 140 schedule_delayed_work(&dev->mib_read, dev->mib_read_interval); 141 } 142 143 void ksz_init_mib_timer(struct ksz_device *dev) 144 { 145 int i; 146 147 INIT_DELAYED_WORK(&dev->mib_read, ksz_mib_read_work); 148 149 for (i = 0; i < dev->port_cnt; i++) 150 dev->dev_ops->port_init_cnt(dev, i); 151 } 152 EXPORT_SYMBOL_GPL(ksz_init_mib_timer); 153 154 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg) 155 { 156 struct ksz_device *dev = ds->priv; 157 u16 val = 0xffff; 158 159 dev->dev_ops->r_phy(dev, addr, reg, &val); 160 161 return val; 162 } 163 EXPORT_SYMBOL_GPL(ksz_phy_read16); 164 165 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val) 166 { 167 struct ksz_device *dev = ds->priv; 168 169 dev->dev_ops->w_phy(dev, addr, reg, val); 170 171 return 0; 172 } 173 EXPORT_SYMBOL_GPL(ksz_phy_write16); 174 175 void ksz_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode, 176 phy_interface_t interface) 177 { 178 struct ksz_device *dev = ds->priv; 179 struct ksz_port *p = &dev->ports[port]; 180 181 /* Read all MIB counters when the link is going down. */ 182 p->read = true; 183 /* timer started */ 184 if (dev->mib_read_interval) 185 schedule_delayed_work(&dev->mib_read, 0); 186 } 187 EXPORT_SYMBOL_GPL(ksz_mac_link_down); 188 189 int ksz_sset_count(struct dsa_switch *ds, int port, int sset) 190 { 191 struct ksz_device *dev = ds->priv; 192 193 if (sset != ETH_SS_STATS) 194 return 0; 195 196 return dev->mib_cnt; 197 } 198 EXPORT_SYMBOL_GPL(ksz_sset_count); 199 200 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf) 201 { 202 const struct dsa_port *dp = dsa_to_port(ds, port); 203 struct ksz_device *dev = ds->priv; 204 struct ksz_port_mib *mib; 205 206 mib = &dev->ports[port].mib; 207 mutex_lock(&mib->cnt_mutex); 208 209 /* Only read dropped counters if no link. */ 210 if (!netif_carrier_ok(dp->slave)) 211 mib->cnt_ptr = dev->reg_mib_cnt; 212 port_r_cnt(dev, port); 213 memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64)); 214 mutex_unlock(&mib->cnt_mutex); 215 } 216 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats); 217 218 int ksz_port_bridge_join(struct dsa_switch *ds, int port, 219 struct dsa_bridge bridge, 220 bool *tx_fwd_offload, 221 struct netlink_ext_ack *extack) 222 { 223 /* port_stp_state_set() will be called after to put the port in 224 * appropriate state so there is no need to do anything. 225 */ 226 227 return 0; 228 } 229 EXPORT_SYMBOL_GPL(ksz_port_bridge_join); 230 231 void ksz_port_bridge_leave(struct dsa_switch *ds, int port, 232 struct dsa_bridge bridge) 233 { 234 /* port_stp_state_set() will be called after to put the port in 235 * forwarding state so there is no need to do anything. 236 */ 237 } 238 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave); 239 240 void ksz_port_fast_age(struct dsa_switch *ds, int port) 241 { 242 struct ksz_device *dev = ds->priv; 243 244 dev->dev_ops->flush_dyn_mac_table(dev, port); 245 } 246 EXPORT_SYMBOL_GPL(ksz_port_fast_age); 247 248 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb, 249 void *data) 250 { 251 struct ksz_device *dev = ds->priv; 252 int ret = 0; 253 u16 i = 0; 254 u16 entries = 0; 255 u8 timestamp = 0; 256 u8 fid; 257 u8 member; 258 struct alu_struct alu; 259 260 do { 261 alu.is_static = false; 262 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid, 263 &member, ×tamp, 264 &entries); 265 if (!ret && (member & BIT(port))) { 266 ret = cb(alu.mac, alu.fid, alu.is_static, data); 267 if (ret) 268 break; 269 } 270 i++; 271 } while (i < entries); 272 if (i >= entries) 273 ret = 0; 274 275 return ret; 276 } 277 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump); 278 279 int ksz_port_mdb_add(struct dsa_switch *ds, int port, 280 const struct switchdev_obj_port_mdb *mdb, 281 struct dsa_db db) 282 { 283 struct ksz_device *dev = ds->priv; 284 struct alu_struct alu; 285 int index; 286 int empty = 0; 287 288 alu.port_forward = 0; 289 for (index = 0; index < dev->num_statics; index++) { 290 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) { 291 /* Found one already in static MAC table. */ 292 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) && 293 alu.fid == mdb->vid) 294 break; 295 /* Remember the first empty entry. */ 296 } else if (!empty) { 297 empty = index + 1; 298 } 299 } 300 301 /* no available entry */ 302 if (index == dev->num_statics && !empty) 303 return -ENOSPC; 304 305 /* add entry */ 306 if (index == dev->num_statics) { 307 index = empty - 1; 308 memset(&alu, 0, sizeof(alu)); 309 memcpy(alu.mac, mdb->addr, ETH_ALEN); 310 alu.is_static = true; 311 } 312 alu.port_forward |= BIT(port); 313 if (mdb->vid) { 314 alu.is_use_fid = true; 315 316 /* Need a way to map VID to FID. */ 317 alu.fid = mdb->vid; 318 } 319 dev->dev_ops->w_sta_mac_table(dev, index, &alu); 320 321 return 0; 322 } 323 EXPORT_SYMBOL_GPL(ksz_port_mdb_add); 324 325 int ksz_port_mdb_del(struct dsa_switch *ds, int port, 326 const struct switchdev_obj_port_mdb *mdb, 327 struct dsa_db db) 328 { 329 struct ksz_device *dev = ds->priv; 330 struct alu_struct alu; 331 int index; 332 333 for (index = 0; index < dev->num_statics; index++) { 334 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) { 335 /* Found one already in static MAC table. */ 336 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) && 337 alu.fid == mdb->vid) 338 break; 339 } 340 } 341 342 /* no available entry */ 343 if (index == dev->num_statics) 344 goto exit; 345 346 /* clear port */ 347 alu.port_forward &= ~BIT(port); 348 if (!alu.port_forward) 349 alu.is_static = false; 350 dev->dev_ops->w_sta_mac_table(dev, index, &alu); 351 352 exit: 353 return 0; 354 } 355 EXPORT_SYMBOL_GPL(ksz_port_mdb_del); 356 357 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy) 358 { 359 struct ksz_device *dev = ds->priv; 360 361 if (!dsa_is_user_port(ds, port)) 362 return 0; 363 364 /* setup slave port */ 365 dev->dev_ops->port_setup(dev, port, false); 366 367 /* port_stp_state_set() will be called after to enable the port so 368 * there is no need to do anything. 369 */ 370 371 return 0; 372 } 373 EXPORT_SYMBOL_GPL(ksz_enable_port); 374 375 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv) 376 { 377 struct dsa_switch *ds; 378 struct ksz_device *swdev; 379 380 ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL); 381 if (!ds) 382 return NULL; 383 384 ds->dev = base; 385 ds->num_ports = DSA_MAX_PORTS; 386 387 swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL); 388 if (!swdev) 389 return NULL; 390 391 ds->priv = swdev; 392 swdev->dev = base; 393 394 swdev->ds = ds; 395 swdev->priv = priv; 396 397 return swdev; 398 } 399 EXPORT_SYMBOL(ksz_switch_alloc); 400 401 int ksz_switch_register(struct ksz_device *dev, 402 const struct ksz_dev_ops *ops) 403 { 404 struct device_node *port, *ports; 405 phy_interface_t interface; 406 unsigned int port_num; 407 int ret; 408 409 if (dev->pdata) 410 dev->chip_id = dev->pdata->chip_id; 411 412 dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset", 413 GPIOD_OUT_LOW); 414 if (IS_ERR(dev->reset_gpio)) 415 return PTR_ERR(dev->reset_gpio); 416 417 if (dev->reset_gpio) { 418 gpiod_set_value_cansleep(dev->reset_gpio, 1); 419 usleep_range(10000, 12000); 420 gpiod_set_value_cansleep(dev->reset_gpio, 0); 421 msleep(100); 422 } 423 424 mutex_init(&dev->dev_mutex); 425 mutex_init(&dev->regmap_mutex); 426 mutex_init(&dev->alu_mutex); 427 mutex_init(&dev->vlan_mutex); 428 429 dev->dev_ops = ops; 430 431 if (dev->dev_ops->detect(dev)) 432 return -EINVAL; 433 434 ret = dev->dev_ops->init(dev); 435 if (ret) 436 return ret; 437 438 /* Host port interface will be self detected, or specifically set in 439 * device tree. 440 */ 441 for (port_num = 0; port_num < dev->port_cnt; ++port_num) 442 dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA; 443 if (dev->dev->of_node) { 444 ret = of_get_phy_mode(dev->dev->of_node, &interface); 445 if (ret == 0) 446 dev->compat_interface = interface; 447 ports = of_get_child_by_name(dev->dev->of_node, "ethernet-ports"); 448 if (!ports) 449 ports = of_get_child_by_name(dev->dev->of_node, "ports"); 450 if (ports) 451 for_each_available_child_of_node(ports, port) { 452 if (of_property_read_u32(port, "reg", 453 &port_num)) 454 continue; 455 if (!(dev->port_mask & BIT(port_num))) { 456 of_node_put(port); 457 return -EINVAL; 458 } 459 of_get_phy_mode(port, 460 &dev->ports[port_num].interface); 461 } 462 dev->synclko_125 = of_property_read_bool(dev->dev->of_node, 463 "microchip,synclko-125"); 464 dev->synclko_disable = of_property_read_bool(dev->dev->of_node, 465 "microchip,synclko-disable"); 466 if (dev->synclko_125 && dev->synclko_disable) { 467 dev_err(dev->dev, "inconsistent synclko settings\n"); 468 return -EINVAL; 469 } 470 } 471 472 ret = dsa_register_switch(dev->ds); 473 if (ret) { 474 dev->dev_ops->exit(dev); 475 return ret; 476 } 477 478 /* Read MIB counters every 30 seconds to avoid overflow. */ 479 dev->mib_read_interval = msecs_to_jiffies(5000); 480 481 /* Start the MIB timer. */ 482 schedule_delayed_work(&dev->mib_read, 0); 483 484 return 0; 485 } 486 EXPORT_SYMBOL(ksz_switch_register); 487 488 void ksz_switch_remove(struct ksz_device *dev) 489 { 490 /* timer started */ 491 if (dev->mib_read_interval) { 492 dev->mib_read_interval = 0; 493 cancel_delayed_work_sync(&dev->mib_read); 494 } 495 496 dev->dev_ops->exit(dev); 497 dsa_unregister_switch(dev->ds); 498 499 if (dev->reset_gpio) 500 gpiod_set_value_cansleep(dev->reset_gpio, 1); 501 502 } 503 EXPORT_SYMBOL(ksz_switch_remove); 504 505 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>"); 506 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver"); 507 MODULE_LICENSE("GPL"); 508