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 mutex_unlock(&mib->cnt_mutex); 134 } 135 136 schedule_delayed_work(&dev->mib_read, dev->mib_read_interval); 137 } 138 139 void ksz_init_mib_timer(struct ksz_device *dev) 140 { 141 int i; 142 143 INIT_DELAYED_WORK(&dev->mib_read, ksz_mib_read_work); 144 145 for (i = 0; i < dev->port_cnt; i++) 146 dev->dev_ops->port_init_cnt(dev, i); 147 } 148 EXPORT_SYMBOL_GPL(ksz_init_mib_timer); 149 150 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg) 151 { 152 struct ksz_device *dev = ds->priv; 153 u16 val = 0xffff; 154 155 dev->dev_ops->r_phy(dev, addr, reg, &val); 156 157 return val; 158 } 159 EXPORT_SYMBOL_GPL(ksz_phy_read16); 160 161 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val) 162 { 163 struct ksz_device *dev = ds->priv; 164 165 dev->dev_ops->w_phy(dev, addr, reg, val); 166 167 return 0; 168 } 169 EXPORT_SYMBOL_GPL(ksz_phy_write16); 170 171 void ksz_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode, 172 phy_interface_t interface) 173 { 174 struct ksz_device *dev = ds->priv; 175 struct ksz_port *p = &dev->ports[port]; 176 177 /* Read all MIB counters when the link is going down. */ 178 p->read = true; 179 /* timer started */ 180 if (dev->mib_read_interval) 181 schedule_delayed_work(&dev->mib_read, 0); 182 } 183 EXPORT_SYMBOL_GPL(ksz_mac_link_down); 184 185 int ksz_sset_count(struct dsa_switch *ds, int port, int sset) 186 { 187 struct ksz_device *dev = ds->priv; 188 189 if (sset != ETH_SS_STATS) 190 return 0; 191 192 return dev->mib_cnt; 193 } 194 EXPORT_SYMBOL_GPL(ksz_sset_count); 195 196 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf) 197 { 198 const struct dsa_port *dp = dsa_to_port(ds, port); 199 struct ksz_device *dev = ds->priv; 200 struct ksz_port_mib *mib; 201 202 mib = &dev->ports[port].mib; 203 mutex_lock(&mib->cnt_mutex); 204 205 /* Only read dropped counters if no link. */ 206 if (!netif_carrier_ok(dp->slave)) 207 mib->cnt_ptr = dev->reg_mib_cnt; 208 port_r_cnt(dev, port); 209 memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64)); 210 mutex_unlock(&mib->cnt_mutex); 211 } 212 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats); 213 214 int ksz_port_bridge_join(struct dsa_switch *ds, int port, 215 struct dsa_bridge bridge, 216 bool *tx_fwd_offload) 217 { 218 /* port_stp_state_set() will be called after to put the port in 219 * appropriate state so there is no need to do anything. 220 */ 221 222 return 0; 223 } 224 EXPORT_SYMBOL_GPL(ksz_port_bridge_join); 225 226 void ksz_port_bridge_leave(struct dsa_switch *ds, int port, 227 struct dsa_bridge bridge) 228 { 229 /* port_stp_state_set() will be called after to put the port in 230 * forwarding state so there is no need to do anything. 231 */ 232 } 233 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave); 234 235 void ksz_port_fast_age(struct dsa_switch *ds, int port) 236 { 237 struct ksz_device *dev = ds->priv; 238 239 dev->dev_ops->flush_dyn_mac_table(dev, port); 240 } 241 EXPORT_SYMBOL_GPL(ksz_port_fast_age); 242 243 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb, 244 void *data) 245 { 246 struct ksz_device *dev = ds->priv; 247 int ret = 0; 248 u16 i = 0; 249 u16 entries = 0; 250 u8 timestamp = 0; 251 u8 fid; 252 u8 member; 253 struct alu_struct alu; 254 255 do { 256 alu.is_static = false; 257 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid, 258 &member, ×tamp, 259 &entries); 260 if (!ret && (member & BIT(port))) { 261 ret = cb(alu.mac, alu.fid, alu.is_static, data); 262 if (ret) 263 break; 264 } 265 i++; 266 } while (i < entries); 267 if (i >= entries) 268 ret = 0; 269 270 return ret; 271 } 272 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump); 273 274 int ksz_port_mdb_add(struct dsa_switch *ds, int port, 275 const struct switchdev_obj_port_mdb *mdb) 276 { 277 struct ksz_device *dev = ds->priv; 278 struct alu_struct alu; 279 int index; 280 int empty = 0; 281 282 alu.port_forward = 0; 283 for (index = 0; index < dev->num_statics; index++) { 284 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) { 285 /* Found one already in static MAC table. */ 286 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) && 287 alu.fid == mdb->vid) 288 break; 289 /* Remember the first empty entry. */ 290 } else if (!empty) { 291 empty = index + 1; 292 } 293 } 294 295 /* no available entry */ 296 if (index == dev->num_statics && !empty) 297 return -ENOSPC; 298 299 /* add entry */ 300 if (index == dev->num_statics) { 301 index = empty - 1; 302 memset(&alu, 0, sizeof(alu)); 303 memcpy(alu.mac, mdb->addr, ETH_ALEN); 304 alu.is_static = true; 305 } 306 alu.port_forward |= BIT(port); 307 if (mdb->vid) { 308 alu.is_use_fid = true; 309 310 /* Need a way to map VID to FID. */ 311 alu.fid = mdb->vid; 312 } 313 dev->dev_ops->w_sta_mac_table(dev, index, &alu); 314 315 return 0; 316 } 317 EXPORT_SYMBOL_GPL(ksz_port_mdb_add); 318 319 int ksz_port_mdb_del(struct dsa_switch *ds, int port, 320 const struct switchdev_obj_port_mdb *mdb) 321 { 322 struct ksz_device *dev = ds->priv; 323 struct alu_struct alu; 324 int index; 325 326 for (index = 0; index < dev->num_statics; index++) { 327 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) { 328 /* Found one already in static MAC table. */ 329 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) && 330 alu.fid == mdb->vid) 331 break; 332 } 333 } 334 335 /* no available entry */ 336 if (index == dev->num_statics) 337 goto exit; 338 339 /* clear port */ 340 alu.port_forward &= ~BIT(port); 341 if (!alu.port_forward) 342 alu.is_static = false; 343 dev->dev_ops->w_sta_mac_table(dev, index, &alu); 344 345 exit: 346 return 0; 347 } 348 EXPORT_SYMBOL_GPL(ksz_port_mdb_del); 349 350 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy) 351 { 352 struct ksz_device *dev = ds->priv; 353 354 if (!dsa_is_user_port(ds, port)) 355 return 0; 356 357 /* setup slave port */ 358 dev->dev_ops->port_setup(dev, port, false); 359 360 /* port_stp_state_set() will be called after to enable the port so 361 * there is no need to do anything. 362 */ 363 364 return 0; 365 } 366 EXPORT_SYMBOL_GPL(ksz_enable_port); 367 368 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv) 369 { 370 struct dsa_switch *ds; 371 struct ksz_device *swdev; 372 373 ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL); 374 if (!ds) 375 return NULL; 376 377 ds->dev = base; 378 ds->num_ports = DSA_MAX_PORTS; 379 380 swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL); 381 if (!swdev) 382 return NULL; 383 384 ds->priv = swdev; 385 swdev->dev = base; 386 387 swdev->ds = ds; 388 swdev->priv = priv; 389 390 return swdev; 391 } 392 EXPORT_SYMBOL(ksz_switch_alloc); 393 394 int ksz_switch_register(struct ksz_device *dev, 395 const struct ksz_dev_ops *ops) 396 { 397 struct device_node *port, *ports; 398 phy_interface_t interface; 399 unsigned int port_num; 400 int ret; 401 402 if (dev->pdata) 403 dev->chip_id = dev->pdata->chip_id; 404 405 dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset", 406 GPIOD_OUT_LOW); 407 if (IS_ERR(dev->reset_gpio)) 408 return PTR_ERR(dev->reset_gpio); 409 410 if (dev->reset_gpio) { 411 gpiod_set_value_cansleep(dev->reset_gpio, 1); 412 usleep_range(10000, 12000); 413 gpiod_set_value_cansleep(dev->reset_gpio, 0); 414 msleep(100); 415 } 416 417 mutex_init(&dev->dev_mutex); 418 mutex_init(&dev->regmap_mutex); 419 mutex_init(&dev->alu_mutex); 420 mutex_init(&dev->vlan_mutex); 421 422 dev->dev_ops = ops; 423 424 if (dev->dev_ops->detect(dev)) 425 return -EINVAL; 426 427 ret = dev->dev_ops->init(dev); 428 if (ret) 429 return ret; 430 431 /* Host port interface will be self detected, or specifically set in 432 * device tree. 433 */ 434 for (port_num = 0; port_num < dev->port_cnt; ++port_num) 435 dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA; 436 if (dev->dev->of_node) { 437 ret = of_get_phy_mode(dev->dev->of_node, &interface); 438 if (ret == 0) 439 dev->compat_interface = interface; 440 ports = of_get_child_by_name(dev->dev->of_node, "ethernet-ports"); 441 if (!ports) 442 ports = of_get_child_by_name(dev->dev->of_node, "ports"); 443 if (ports) 444 for_each_available_child_of_node(ports, port) { 445 if (of_property_read_u32(port, "reg", 446 &port_num)) 447 continue; 448 if (!(dev->port_mask & BIT(port_num))) { 449 of_node_put(port); 450 return -EINVAL; 451 } 452 of_get_phy_mode(port, 453 &dev->ports[port_num].interface); 454 } 455 dev->synclko_125 = of_property_read_bool(dev->dev->of_node, 456 "microchip,synclko-125"); 457 } 458 459 ret = dsa_register_switch(dev->ds); 460 if (ret) { 461 dev->dev_ops->exit(dev); 462 return ret; 463 } 464 465 /* Read MIB counters every 30 seconds to avoid overflow. */ 466 dev->mib_read_interval = msecs_to_jiffies(30000); 467 468 /* Start the MIB timer. */ 469 schedule_delayed_work(&dev->mib_read, 0); 470 471 return 0; 472 } 473 EXPORT_SYMBOL(ksz_switch_register); 474 475 void ksz_switch_remove(struct ksz_device *dev) 476 { 477 /* timer started */ 478 if (dev->mib_read_interval) { 479 dev->mib_read_interval = 0; 480 cancel_delayed_work_sync(&dev->mib_read); 481 } 482 483 dev->dev_ops->exit(dev); 484 dsa_unregister_switch(dev->ds); 485 486 if (dev->reset_gpio) 487 gpiod_set_value_cansleep(dev->reset_gpio, 1); 488 489 } 490 EXPORT_SYMBOL(ksz_switch_remove); 491 492 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>"); 493 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver"); 494 MODULE_LICENSE("GPL"); 495