1 /* 2 * Handling of a single switch port 3 * 4 * Copyright (c) 2017 Savoir-faire Linux Inc. 5 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 13 #include <linux/if_bridge.h> 14 #include <linux/notifier.h> 15 #include <linux/of_mdio.h> 16 #include <linux/of_net.h> 17 18 #include "dsa_priv.h" 19 20 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v) 21 { 22 struct raw_notifier_head *nh = &dp->ds->dst->nh; 23 int err; 24 25 err = raw_notifier_call_chain(nh, e, v); 26 27 return notifier_to_errno(err); 28 } 29 30 int dsa_port_set_state(struct dsa_port *dp, u8 state, 31 struct switchdev_trans *trans) 32 { 33 struct dsa_switch *ds = dp->ds; 34 int port = dp->index; 35 36 if (switchdev_trans_ph_prepare(trans)) 37 return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP; 38 39 if (ds->ops->port_stp_state_set) 40 ds->ops->port_stp_state_set(ds, port, state); 41 42 if (ds->ops->port_fast_age) { 43 /* Fast age FDB entries or flush appropriate forwarding database 44 * for the given port, if we are moving it from Learning or 45 * Forwarding state, to Disabled or Blocking or Listening state. 46 */ 47 48 if ((dp->stp_state == BR_STATE_LEARNING || 49 dp->stp_state == BR_STATE_FORWARDING) && 50 (state == BR_STATE_DISABLED || 51 state == BR_STATE_BLOCKING || 52 state == BR_STATE_LISTENING)) 53 ds->ops->port_fast_age(ds, port); 54 } 55 56 dp->stp_state = state; 57 58 return 0; 59 } 60 61 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state) 62 { 63 int err; 64 65 err = dsa_port_set_state(dp, state, NULL); 66 if (err) 67 pr_err("DSA: failed to set STP state %u (%d)\n", state, err); 68 } 69 70 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy) 71 { 72 u8 stp_state = dp->bridge_dev ? BR_STATE_BLOCKING : BR_STATE_FORWARDING; 73 struct dsa_switch *ds = dp->ds; 74 int port = dp->index; 75 int err; 76 77 if (ds->ops->port_enable) { 78 err = ds->ops->port_enable(ds, port, phy); 79 if (err) 80 return err; 81 } 82 83 dsa_port_set_state_now(dp, stp_state); 84 85 return 0; 86 } 87 88 void dsa_port_disable(struct dsa_port *dp, struct phy_device *phy) 89 { 90 struct dsa_switch *ds = dp->ds; 91 int port = dp->index; 92 93 dsa_port_set_state_now(dp, BR_STATE_DISABLED); 94 95 if (ds->ops->port_disable) 96 ds->ops->port_disable(ds, port, phy); 97 } 98 99 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br) 100 { 101 struct dsa_notifier_bridge_info info = { 102 .sw_index = dp->ds->index, 103 .port = dp->index, 104 .br = br, 105 }; 106 int err; 107 108 /* Here the port is already bridged. Reflect the current configuration 109 * so that drivers can program their chips accordingly. 110 */ 111 dp->bridge_dev = br; 112 113 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info); 114 115 /* The bridging is rolled back on error */ 116 if (err) 117 dp->bridge_dev = NULL; 118 119 return err; 120 } 121 122 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br) 123 { 124 struct dsa_notifier_bridge_info info = { 125 .sw_index = dp->ds->index, 126 .port = dp->index, 127 .br = br, 128 }; 129 int err; 130 131 /* Here the port is already unbridged. Reflect the current configuration 132 * so that drivers can program their chips accordingly. 133 */ 134 dp->bridge_dev = NULL; 135 136 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info); 137 if (err) 138 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n"); 139 140 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer, 141 * so allow it to be in BR_STATE_FORWARDING to be kept functional 142 */ 143 dsa_port_set_state_now(dp, BR_STATE_FORWARDING); 144 } 145 146 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering, 147 struct switchdev_trans *trans) 148 { 149 struct dsa_switch *ds = dp->ds; 150 151 /* bridge skips -EOPNOTSUPP, so skip the prepare phase */ 152 if (switchdev_trans_ph_prepare(trans)) 153 return 0; 154 155 if (ds->ops->port_vlan_filtering) 156 return ds->ops->port_vlan_filtering(ds, dp->index, 157 vlan_filtering); 158 159 return 0; 160 } 161 162 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock, 163 struct switchdev_trans *trans) 164 { 165 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock); 166 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies); 167 struct dsa_notifier_ageing_time_info info = { 168 .ageing_time = ageing_time, 169 .trans = trans, 170 }; 171 172 if (switchdev_trans_ph_prepare(trans)) 173 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 174 175 dp->ageing_time = ageing_time; 176 177 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 178 } 179 180 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr, 181 u16 vid) 182 { 183 struct dsa_notifier_fdb_info info = { 184 .sw_index = dp->ds->index, 185 .port = dp->index, 186 .addr = addr, 187 .vid = vid, 188 }; 189 190 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info); 191 } 192 193 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr, 194 u16 vid) 195 { 196 struct dsa_notifier_fdb_info info = { 197 .sw_index = dp->ds->index, 198 .port = dp->index, 199 .addr = addr, 200 .vid = vid, 201 202 }; 203 204 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info); 205 } 206 207 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data) 208 { 209 struct dsa_switch *ds = dp->ds; 210 int port = dp->index; 211 212 if (!ds->ops->port_fdb_dump) 213 return -EOPNOTSUPP; 214 215 return ds->ops->port_fdb_dump(ds, port, cb, data); 216 } 217 218 int dsa_port_mdb_add(const struct dsa_port *dp, 219 const struct switchdev_obj_port_mdb *mdb, 220 struct switchdev_trans *trans) 221 { 222 struct dsa_notifier_mdb_info info = { 223 .sw_index = dp->ds->index, 224 .port = dp->index, 225 .trans = trans, 226 .mdb = mdb, 227 }; 228 229 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info); 230 } 231 232 int dsa_port_mdb_del(const struct dsa_port *dp, 233 const struct switchdev_obj_port_mdb *mdb) 234 { 235 struct dsa_notifier_mdb_info info = { 236 .sw_index = dp->ds->index, 237 .port = dp->index, 238 .mdb = mdb, 239 }; 240 241 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info); 242 } 243 244 int dsa_port_vlan_add(struct dsa_port *dp, 245 const struct switchdev_obj_port_vlan *vlan, 246 struct switchdev_trans *trans) 247 { 248 struct dsa_notifier_vlan_info info = { 249 .sw_index = dp->ds->index, 250 .port = dp->index, 251 .trans = trans, 252 .vlan = vlan, 253 }; 254 255 if (netif_is_bridge_master(vlan->obj.orig_dev)) 256 return -EOPNOTSUPP; 257 258 if (br_vlan_enabled(dp->bridge_dev)) 259 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); 260 261 return 0; 262 } 263 264 int dsa_port_vlan_del(struct dsa_port *dp, 265 const struct switchdev_obj_port_vlan *vlan) 266 { 267 struct dsa_notifier_vlan_info info = { 268 .sw_index = dp->ds->index, 269 .port = dp->index, 270 .vlan = vlan, 271 }; 272 273 if (netif_is_bridge_master(vlan->obj.orig_dev)) 274 return -EOPNOTSUPP; 275 276 if (br_vlan_enabled(dp->bridge_dev)) 277 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 278 279 return 0; 280 } 281 282 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) 283 { 284 struct device_node *phy_dn; 285 struct phy_device *phydev; 286 287 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); 288 if (!phy_dn) 289 return NULL; 290 291 phydev = of_phy_find_device(phy_dn); 292 if (!phydev) { 293 of_node_put(phy_dn); 294 return ERR_PTR(-EPROBE_DEFER); 295 } 296 297 return phydev; 298 } 299 300 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 301 { 302 struct dsa_switch *ds = dp->ds; 303 struct phy_device *phydev; 304 int port = dp->index; 305 int err = 0; 306 307 phydev = dsa_port_get_phy_device(dp); 308 if (!phydev) 309 return 0; 310 311 if (IS_ERR(phydev)) 312 return PTR_ERR(phydev); 313 314 if (enable) { 315 err = genphy_config_init(phydev); 316 if (err < 0) 317 goto err_put_dev; 318 319 err = genphy_resume(phydev); 320 if (err < 0) 321 goto err_put_dev; 322 323 err = genphy_read_status(phydev); 324 if (err < 0) 325 goto err_put_dev; 326 } else { 327 err = genphy_suspend(phydev); 328 if (err < 0) 329 goto err_put_dev; 330 } 331 332 if (ds->ops->adjust_link) 333 ds->ops->adjust_link(ds, port, phydev); 334 335 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 336 337 err_put_dev: 338 put_device(&phydev->mdio.dev); 339 return err; 340 } 341 342 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 343 { 344 struct device_node *dn = dp->dn; 345 struct dsa_switch *ds = dp->ds; 346 struct phy_device *phydev; 347 int port = dp->index; 348 int mode; 349 int err; 350 351 err = of_phy_register_fixed_link(dn); 352 if (err) { 353 dev_err(ds->dev, 354 "failed to register the fixed PHY of port %d\n", 355 port); 356 return err; 357 } 358 359 phydev = of_phy_find_device(dn); 360 361 mode = of_get_phy_mode(dn); 362 if (mode < 0) 363 mode = PHY_INTERFACE_MODE_NA; 364 phydev->interface = mode; 365 366 genphy_config_init(phydev); 367 genphy_read_status(phydev); 368 369 if (ds->ops->adjust_link) 370 ds->ops->adjust_link(ds, port, phydev); 371 372 put_device(&phydev->mdio.dev); 373 374 return 0; 375 } 376 377 int dsa_port_link_register_of(struct dsa_port *dp) 378 { 379 if (of_phy_is_fixed_link(dp->dn)) 380 return dsa_port_fixed_link_register_of(dp); 381 else 382 return dsa_port_setup_phy_of(dp, true); 383 } 384 385 void dsa_port_link_unregister_of(struct dsa_port *dp) 386 { 387 if (of_phy_is_fixed_link(dp->dn)) 388 of_phy_deregister_fixed_link(dp->dn); 389 else 390 dsa_port_setup_phy_of(dp, false); 391 } 392 393 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) 394 { 395 struct phy_device *phydev; 396 int ret = -EOPNOTSUPP; 397 398 if (of_phy_is_fixed_link(dp->dn)) 399 return ret; 400 401 phydev = dsa_port_get_phy_device(dp); 402 if (IS_ERR_OR_NULL(phydev)) 403 return ret; 404 405 ret = phy_ethtool_get_strings(phydev, data); 406 put_device(&phydev->mdio.dev); 407 408 return ret; 409 } 410 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); 411 412 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) 413 { 414 struct phy_device *phydev; 415 int ret = -EOPNOTSUPP; 416 417 if (of_phy_is_fixed_link(dp->dn)) 418 return ret; 419 420 phydev = dsa_port_get_phy_device(dp); 421 if (IS_ERR_OR_NULL(phydev)) 422 return ret; 423 424 ret = phy_ethtool_get_stats(phydev, NULL, data); 425 put_device(&phydev->mdio.dev); 426 427 return ret; 428 } 429 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); 430 431 int dsa_port_get_phy_sset_count(struct dsa_port *dp) 432 { 433 struct phy_device *phydev; 434 int ret = -EOPNOTSUPP; 435 436 if (of_phy_is_fixed_link(dp->dn)) 437 return ret; 438 439 phydev = dsa_port_get_phy_device(dp); 440 if (IS_ERR_OR_NULL(phydev)) 441 return ret; 442 443 ret = phy_ethtool_get_sset_count(phydev); 444 put_device(&phydev->mdio.dev); 445 446 return ret; 447 } 448 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count); 449