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