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 (br_vlan_enabled(dp->bridge_dev)) 271 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 272 273 return 0; 274 } 275 276 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 277 { 278 struct device_node *port_dn = dp->dn; 279 struct device_node *phy_dn; 280 struct dsa_switch *ds = dp->ds; 281 struct phy_device *phydev; 282 int port = dp->index; 283 int err = 0; 284 285 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0); 286 if (!phy_dn) 287 return 0; 288 289 phydev = of_phy_find_device(phy_dn); 290 if (!phydev) { 291 err = -EPROBE_DEFER; 292 goto err_put_of; 293 } 294 295 if (enable) { 296 err = genphy_config_init(phydev); 297 if (err < 0) 298 goto err_put_dev; 299 300 err = genphy_resume(phydev); 301 if (err < 0) 302 goto err_put_dev; 303 304 err = genphy_read_status(phydev); 305 if (err < 0) 306 goto err_put_dev; 307 } else { 308 err = genphy_suspend(phydev); 309 if (err < 0) 310 goto err_put_dev; 311 } 312 313 if (ds->ops->adjust_link) 314 ds->ops->adjust_link(ds, port, phydev); 315 316 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 317 318 err_put_dev: 319 put_device(&phydev->mdio.dev); 320 err_put_of: 321 of_node_put(phy_dn); 322 return err; 323 } 324 325 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 326 { 327 struct device_node *dn = dp->dn; 328 struct dsa_switch *ds = dp->ds; 329 struct phy_device *phydev; 330 int port = dp->index; 331 int mode; 332 int err; 333 334 err = of_phy_register_fixed_link(dn); 335 if (err) { 336 dev_err(ds->dev, 337 "failed to register the fixed PHY of port %d\n", 338 port); 339 return err; 340 } 341 342 phydev = of_phy_find_device(dn); 343 344 mode = of_get_phy_mode(dn); 345 if (mode < 0) 346 mode = PHY_INTERFACE_MODE_NA; 347 phydev->interface = mode; 348 349 genphy_config_init(phydev); 350 genphy_read_status(phydev); 351 352 if (ds->ops->adjust_link) 353 ds->ops->adjust_link(ds, port, phydev); 354 355 put_device(&phydev->mdio.dev); 356 357 return 0; 358 } 359 360 int dsa_port_link_register_of(struct dsa_port *dp) 361 { 362 if (of_phy_is_fixed_link(dp->dn)) 363 return dsa_port_fixed_link_register_of(dp); 364 else 365 return dsa_port_setup_phy_of(dp, true); 366 } 367 368 void dsa_port_link_unregister_of(struct dsa_port *dp) 369 { 370 if (of_phy_is_fixed_link(dp->dn)) 371 of_phy_deregister_fixed_link(dp->dn); 372 else 373 dsa_port_setup_phy_of(dp, false); 374 } 375