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 (br_vlan_enabled(dp->bridge_dev)) 256 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); 257 258 return 0; 259 } 260 261 int dsa_port_vlan_del(struct dsa_port *dp, 262 const struct switchdev_obj_port_vlan *vlan) 263 { 264 struct dsa_notifier_vlan_info info = { 265 .sw_index = dp->ds->index, 266 .port = dp->index, 267 .vlan = vlan, 268 }; 269 270 if (netif_is_bridge_master(vlan->obj.orig_dev)) 271 return -EOPNOTSUPP; 272 273 if (br_vlan_enabled(dp->bridge_dev)) 274 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 275 276 return 0; 277 } 278 279 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) 280 { 281 struct device_node *phy_dn; 282 struct phy_device *phydev; 283 284 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); 285 if (!phy_dn) 286 return NULL; 287 288 phydev = of_phy_find_device(phy_dn); 289 if (!phydev) { 290 of_node_put(phy_dn); 291 return ERR_PTR(-EPROBE_DEFER); 292 } 293 294 return phydev; 295 } 296 297 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 298 { 299 struct dsa_switch *ds = dp->ds; 300 struct phy_device *phydev; 301 int port = dp->index; 302 int err = 0; 303 304 phydev = dsa_port_get_phy_device(dp); 305 if (!phydev) 306 return 0; 307 308 if (IS_ERR(phydev)) 309 return PTR_ERR(phydev); 310 311 if (enable) { 312 err = genphy_config_init(phydev); 313 if (err < 0) 314 goto err_put_dev; 315 316 err = genphy_resume(phydev); 317 if (err < 0) 318 goto err_put_dev; 319 320 err = genphy_read_status(phydev); 321 if (err < 0) 322 goto err_put_dev; 323 } else { 324 err = genphy_suspend(phydev); 325 if (err < 0) 326 goto err_put_dev; 327 } 328 329 if (ds->ops->adjust_link) 330 ds->ops->adjust_link(ds, port, phydev); 331 332 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 333 334 err_put_dev: 335 put_device(&phydev->mdio.dev); 336 return err; 337 } 338 339 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 340 { 341 struct device_node *dn = dp->dn; 342 struct dsa_switch *ds = dp->ds; 343 struct phy_device *phydev; 344 int port = dp->index; 345 int mode; 346 int err; 347 348 err = of_phy_register_fixed_link(dn); 349 if (err) { 350 dev_err(ds->dev, 351 "failed to register the fixed PHY of port %d\n", 352 port); 353 return err; 354 } 355 356 phydev = of_phy_find_device(dn); 357 358 mode = of_get_phy_mode(dn); 359 if (mode < 0) 360 mode = PHY_INTERFACE_MODE_NA; 361 phydev->interface = mode; 362 363 genphy_config_init(phydev); 364 genphy_read_status(phydev); 365 366 if (ds->ops->adjust_link) 367 ds->ops->adjust_link(ds, port, phydev); 368 369 put_device(&phydev->mdio.dev); 370 371 return 0; 372 } 373 374 int dsa_port_link_register_of(struct dsa_port *dp) 375 { 376 if (of_phy_is_fixed_link(dp->dn)) 377 return dsa_port_fixed_link_register_of(dp); 378 else 379 return dsa_port_setup_phy_of(dp, true); 380 } 381 382 void dsa_port_link_unregister_of(struct dsa_port *dp) 383 { 384 if (of_phy_is_fixed_link(dp->dn)) 385 of_phy_deregister_fixed_link(dp->dn); 386 else 387 dsa_port_setup_phy_of(dp, false); 388 } 389 390 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) 391 { 392 struct phy_device *phydev; 393 int ret = -EOPNOTSUPP; 394 395 if (of_phy_is_fixed_link(dp->dn)) 396 return ret; 397 398 phydev = dsa_port_get_phy_device(dp); 399 if (IS_ERR_OR_NULL(phydev)) 400 return ret; 401 402 ret = phy_ethtool_get_strings(phydev, data); 403 put_device(&phydev->mdio.dev); 404 405 return ret; 406 } 407 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); 408 409 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) 410 { 411 struct phy_device *phydev; 412 int ret = -EOPNOTSUPP; 413 414 if (of_phy_is_fixed_link(dp->dn)) 415 return ret; 416 417 phydev = dsa_port_get_phy_device(dp); 418 if (IS_ERR_OR_NULL(phydev)) 419 return ret; 420 421 ret = phy_ethtool_get_stats(phydev, NULL, data); 422 put_device(&phydev->mdio.dev); 423 424 return ret; 425 } 426 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); 427 428 int dsa_port_get_phy_sset_count(struct dsa_port *dp) 429 { 430 struct phy_device *phydev; 431 int ret = -EOPNOTSUPP; 432 433 if (of_phy_is_fixed_link(dp->dn)) 434 return ret; 435 436 phydev = dsa_port_get_phy_device(dp); 437 if (IS_ERR_OR_NULL(phydev)) 438 return ret; 439 440 ret = phy_ethtool_get_sset_count(phydev); 441 put_device(&phydev->mdio.dev); 442 443 return ret; 444 } 445 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count); 446