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