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