Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 1 | /* |
| 2 | * net/dsa/dsa.c - Hardware switch handling |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 3 | * Copyright (c) 2008-2009 Marvell Semiconductor |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 4 | * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org> |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | */ |
| 11 | |
Guenter Roeck | 51579c3 | 2014-10-29 10:44:58 -0700 | [diff] [blame] | 12 | #include <linux/device.h> |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 13 | #include <linux/list.h> |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 14 | #include <linux/platform_device.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Paul Gortmaker | 3a9a231 | 2011-05-27 09:12:25 -0400 | [diff] [blame] | 16 | #include <linux/module.h> |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 17 | #include <net/dsa.h> |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 18 | #include <linux/of.h> |
| 19 | #include <linux/of_mdio.h> |
| 20 | #include <linux/of_platform.h> |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 21 | #include <linux/of_net.h> |
Andrew Lunn | cc30c16 | 2015-11-20 03:56:23 +0100 | [diff] [blame] | 22 | #include <linux/of_gpio.h> |
Guenter Roeck | 51579c3 | 2014-10-29 10:44:58 -0700 | [diff] [blame] | 23 | #include <linux/sysfs.h> |
Neil Armstrong | cbc5d90 | 2015-10-06 15:40:32 +0100 | [diff] [blame] | 24 | #include <linux/phy_fixed.h> |
Arnd Bergmann | 85beabf | 2015-11-24 12:34:49 +0100 | [diff] [blame] | 25 | #include <linux/gpio/consumer.h> |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 26 | #include "dsa_priv.h" |
| 27 | |
Andrew Lunn | 39a7f2a | 2016-06-04 21:17:03 +0200 | [diff] [blame] | 28 | static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb, |
| 29 | struct net_device *dev) |
| 30 | { |
| 31 | /* Just return the original SKB */ |
| 32 | return skb; |
| 33 | } |
| 34 | |
| 35 | static const struct dsa_device_ops none_ops = { |
| 36 | .xmit = dsa_slave_notag_xmit, |
| 37 | .rcv = NULL, |
| 38 | }; |
| 39 | |
| 40 | const struct dsa_device_ops *dsa_device_ops[DSA_TAG_LAST] = { |
| 41 | #ifdef CONFIG_NET_DSA_TAG_DSA |
| 42 | [DSA_TAG_PROTO_DSA] = &dsa_netdev_ops, |
| 43 | #endif |
| 44 | #ifdef CONFIG_NET_DSA_TAG_EDSA |
| 45 | [DSA_TAG_PROTO_EDSA] = &edsa_netdev_ops, |
| 46 | #endif |
| 47 | #ifdef CONFIG_NET_DSA_TAG_TRAILER |
| 48 | [DSA_TAG_PROTO_TRAILER] = &trailer_netdev_ops, |
| 49 | #endif |
| 50 | #ifdef CONFIG_NET_DSA_TAG_BRCM |
| 51 | [DSA_TAG_PROTO_BRCM] = &brcm_netdev_ops, |
| 52 | #endif |
John Crispin | cafdc45 | 2016-09-15 16:26:40 +0200 | [diff] [blame] | 53 | #ifdef CONFIG_NET_DSA_TAG_QCA |
| 54 | [DSA_TAG_PROTO_QCA] = &qca_netdev_ops, |
| 55 | #endif |
Andrew Lunn | 39a7f2a | 2016-06-04 21:17:03 +0200 | [diff] [blame] | 56 | [DSA_TAG_PROTO_NONE] = &none_ops, |
| 57 | }; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 58 | |
| 59 | /* switch driver registration ***********************************************/ |
| 60 | static DEFINE_MUTEX(dsa_switch_drivers_mutex); |
| 61 | static LIST_HEAD(dsa_switch_drivers); |
| 62 | |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 63 | void register_switch_driver(struct dsa_switch_driver *drv) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 64 | { |
| 65 | mutex_lock(&dsa_switch_drivers_mutex); |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 66 | list_add_tail(&drv->list, &dsa_switch_drivers); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 67 | mutex_unlock(&dsa_switch_drivers_mutex); |
| 68 | } |
Ben Hutchings | ad293b8 | 2011-11-25 14:34:07 +0000 | [diff] [blame] | 69 | EXPORT_SYMBOL_GPL(register_switch_driver); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 70 | |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 71 | void unregister_switch_driver(struct dsa_switch_driver *drv) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 72 | { |
| 73 | mutex_lock(&dsa_switch_drivers_mutex); |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 74 | list_del_init(&drv->list); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 75 | mutex_unlock(&dsa_switch_drivers_mutex); |
| 76 | } |
Ben Hutchings | ad293b8 | 2011-11-25 14:34:07 +0000 | [diff] [blame] | 77 | EXPORT_SYMBOL_GPL(unregister_switch_driver); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 78 | |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 79 | static const struct dsa_switch_ops * |
Andrew Lunn | bbb8d79 | 2016-04-13 02:40:39 +0200 | [diff] [blame] | 80 | dsa_switch_probe(struct device *parent, struct device *host_dev, int sw_addr, |
Vivien Didelot | 0209d14 | 2016-04-17 13:23:55 -0400 | [diff] [blame] | 81 | const char **_name, void **priv) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 82 | { |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 83 | const struct dsa_switch_ops *ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 84 | struct list_head *list; |
Vivien Didelot | 0209d14 | 2016-04-17 13:23:55 -0400 | [diff] [blame] | 85 | const char *name; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 86 | |
| 87 | ret = NULL; |
| 88 | name = NULL; |
| 89 | |
| 90 | mutex_lock(&dsa_switch_drivers_mutex); |
| 91 | list_for_each(list, &dsa_switch_drivers) { |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 92 | const struct dsa_switch_ops *ops; |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 93 | struct dsa_switch_driver *drv; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 94 | |
Florian Fainelli | ab3d408 | 2017-01-08 14:52:07 -0800 | [diff] [blame] | 95 | drv = list_entry(list, struct dsa_switch_driver, list); |
| 96 | ops = drv->ops; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 97 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 98 | name = ops->probe(parent, host_dev, sw_addr, priv); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 99 | if (name != NULL) { |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 100 | ret = ops; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 101 | break; |
| 102 | } |
| 103 | } |
| 104 | mutex_unlock(&dsa_switch_drivers_mutex); |
| 105 | |
| 106 | *_name = name; |
| 107 | |
| 108 | return ret; |
| 109 | } |
| 110 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 111 | /* basic switch operations **************************************************/ |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 112 | int dsa_cpu_dsa_setup(struct dsa_switch *ds, struct device *dev, |
| 113 | struct device_node *port_dn, int port) |
| 114 | { |
| 115 | struct phy_device *phydev; |
| 116 | int ret, mode; |
| 117 | |
| 118 | if (of_phy_is_fixed_link(port_dn)) { |
| 119 | ret = of_phy_register_fixed_link(port_dn); |
| 120 | if (ret) { |
| 121 | dev_err(dev, "failed to register fixed PHY\n"); |
| 122 | return ret; |
| 123 | } |
| 124 | phydev = of_phy_find_device(port_dn); |
| 125 | |
| 126 | mode = of_get_phy_mode(port_dn); |
| 127 | if (mode < 0) |
| 128 | mode = PHY_INTERFACE_MODE_NA; |
| 129 | phydev->interface = mode; |
| 130 | |
| 131 | genphy_config_init(phydev); |
| 132 | genphy_read_status(phydev); |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 133 | if (ds->ops->adjust_link) |
| 134 | ds->ops->adjust_link(ds, port, phydev); |
Johan Hovold | fd05d7b | 2016-11-24 19:21:27 +0100 | [diff] [blame] | 135 | |
| 136 | put_device(&phydev->mdio.dev); |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | return 0; |
| 140 | } |
| 141 | |
| 142 | static int dsa_cpu_dsa_setups(struct dsa_switch *ds, struct device *dev) |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 143 | { |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 144 | struct device_node *port_dn; |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 145 | int ret, port; |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 146 | |
| 147 | for (port = 0; port < DSA_MAX_PORTS; port++) { |
| 148 | if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) |
| 149 | continue; |
| 150 | |
Andrew Lunn | 189b0d9 | 2016-06-04 21:16:58 +0200 | [diff] [blame] | 151 | port_dn = ds->ports[port].dn; |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 152 | ret = dsa_cpu_dsa_setup(ds, dev, port_dn, port); |
| 153 | if (ret) |
| 154 | return ret; |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 155 | } |
| 156 | return 0; |
| 157 | } |
| 158 | |
Andrew Lunn | 39a7f2a | 2016-06-04 21:17:03 +0200 | [diff] [blame] | 159 | const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol) |
| 160 | { |
| 161 | const struct dsa_device_ops *ops; |
| 162 | |
| 163 | if (tag_protocol >= DSA_TAG_LAST) |
| 164 | return ERR_PTR(-EINVAL); |
| 165 | ops = dsa_device_ops[tag_protocol]; |
| 166 | |
| 167 | if (!ops) |
| 168 | return ERR_PTR(-ENOPROTOOPT); |
| 169 | |
| 170 | return ops; |
| 171 | } |
| 172 | |
Florian Fainelli | 0c73c52 | 2016-06-07 16:32:42 -0700 | [diff] [blame] | 173 | int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds) |
| 174 | { |
| 175 | struct net_device *master; |
| 176 | struct ethtool_ops *cpu_ops; |
| 177 | |
| 178 | master = ds->dst->master_netdev; |
| 179 | if (ds->master_netdev) |
| 180 | master = ds->master_netdev; |
| 181 | |
| 182 | cpu_ops = devm_kzalloc(ds->dev, sizeof(*cpu_ops), GFP_KERNEL); |
| 183 | if (!cpu_ops) |
| 184 | return -ENOMEM; |
| 185 | |
| 186 | memcpy(&ds->dst->master_ethtool_ops, master->ethtool_ops, |
| 187 | sizeof(struct ethtool_ops)); |
| 188 | ds->dst->master_orig_ethtool_ops = master->ethtool_ops; |
| 189 | memcpy(cpu_ops, &ds->dst->master_ethtool_ops, |
| 190 | sizeof(struct ethtool_ops)); |
| 191 | dsa_cpu_port_ethtool_init(cpu_ops); |
| 192 | master->ethtool_ops = cpu_ops; |
| 193 | |
| 194 | return 0; |
| 195 | } |
| 196 | |
| 197 | void dsa_cpu_port_ethtool_restore(struct dsa_switch *ds) |
| 198 | { |
| 199 | struct net_device *master; |
| 200 | |
| 201 | master = ds->dst->master_netdev; |
| 202 | if (ds->master_netdev) |
| 203 | master = ds->master_netdev; |
| 204 | |
| 205 | master->ethtool_ops = ds->dst->master_orig_ethtool_ops; |
| 206 | } |
| 207 | |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 208 | static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 209 | { |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 210 | const struct dsa_switch_ops *ops = ds->ops; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 211 | struct dsa_switch_tree *dst = ds->dst; |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 212 | struct dsa_chip_data *cd = ds->cd; |
Florian Fainelli | f9bf5a2 | 2013-01-21 09:58:51 +0000 | [diff] [blame] | 213 | bool valid_name_found = false; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 214 | int index = ds->index; |
| 215 | int i, ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 216 | |
| 217 | /* |
| 218 | * Validate supplied switch configuration. |
| 219 | */ |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 220 | for (i = 0; i < DSA_MAX_PORTS; i++) { |
| 221 | char *name; |
| 222 | |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 223 | name = cd->port_names[i]; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 224 | if (name == NULL) |
| 225 | continue; |
| 226 | |
| 227 | if (!strcmp(name, "cpu")) { |
Vivien Didelot | b22de49 | 2017-01-17 20:41:38 -0500 | [diff] [blame] | 228 | if (!dst->cpu_switch) { |
Joe Perches | a2ae600 | 2014-11-09 16:32:46 -0800 | [diff] [blame] | 229 | netdev_err(dst->master_netdev, |
| 230 | "multiple cpu ports?!\n"); |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 231 | return -EINVAL; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 232 | } |
Vivien Didelot | b22de49 | 2017-01-17 20:41:38 -0500 | [diff] [blame] | 233 | dst->cpu_switch = ds; |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 234 | dst->cpu_port = i; |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 235 | ds->cpu_port_mask |= 1 << i; |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 236 | } else if (!strcmp(name, "dsa")) { |
| 237 | ds->dsa_port_mask |= 1 << i; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 238 | } else { |
Andrew Lunn | 74c3e2a | 2016-04-13 02:40:44 +0200 | [diff] [blame] | 239 | ds->enabled_port_mask |= 1 << i; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 240 | } |
Florian Fainelli | f9bf5a2 | 2013-01-21 09:58:51 +0000 | [diff] [blame] | 241 | valid_name_found = true; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 242 | } |
| 243 | |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 244 | if (!valid_name_found && i == DSA_MAX_PORTS) |
| 245 | return -EINVAL; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 246 | |
Florian Fainelli | 0d8bcdd | 2014-08-27 17:04:51 -0700 | [diff] [blame] | 247 | /* Make the built-in MII bus mask match the number of ports, |
| 248 | * switch drivers can override this later |
| 249 | */ |
Andrew Lunn | 74c3e2a | 2016-04-13 02:40:44 +0200 | [diff] [blame] | 250 | ds->phys_mii_mask = ds->enabled_port_mask; |
Florian Fainelli | 0d8bcdd | 2014-08-27 17:04:51 -0700 | [diff] [blame] | 251 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 252 | /* |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 253 | * If the CPU connects to this switch, set the switch tree |
| 254 | * tagging protocol to the preferred tagging format of this |
| 255 | * switch. |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 256 | */ |
Vivien Didelot | b22de49 | 2017-01-17 20:41:38 -0500 | [diff] [blame] | 257 | if (dst->cpu_switch == ds) { |
Andrew Lunn | 7b31436 | 2016-08-22 16:01:01 +0200 | [diff] [blame] | 258 | enum dsa_tag_protocol tag_protocol; |
| 259 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 260 | tag_protocol = ops->get_tag_protocol(ds); |
Andrew Lunn | 7b31436 | 2016-08-22 16:01:01 +0200 | [diff] [blame] | 261 | dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol); |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 262 | if (IS_ERR(dst->tag_ops)) |
| 263 | return PTR_ERR(dst->tag_ops); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 264 | |
Andrew Lunn | 39a7f2a | 2016-06-04 21:17:03 +0200 | [diff] [blame] | 265 | dst->rcv = dst->tag_ops->rcv; |
Alexander Duyck | 5075314 | 2014-09-15 13:00:19 -0400 | [diff] [blame] | 266 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 267 | |
Andrew Lunn | 66472fc | 2016-06-04 21:17:00 +0200 | [diff] [blame] | 268 | memcpy(ds->rtable, cd->rtable, sizeof(ds->rtable)); |
| 269 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 270 | /* |
| 271 | * Do basic register setup. |
| 272 | */ |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 273 | ret = ops->setup(ds); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 274 | if (ret < 0) |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 275 | return ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 276 | |
John Crispin | 092183d | 2016-09-19 15:28:01 +0200 | [diff] [blame] | 277 | if (ops->set_addr) { |
| 278 | ret = ops->set_addr(ds, dst->master_netdev->dev_addr); |
| 279 | if (ret < 0) |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 280 | return ret; |
John Crispin | 092183d | 2016-09-19 15:28:01 +0200 | [diff] [blame] | 281 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 282 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 283 | if (!ds->slave_mii_bus && ops->phy_read) { |
Andrew Lunn | e755e49 | 2016-06-04 21:17:04 +0200 | [diff] [blame] | 284 | ds->slave_mii_bus = devm_mdiobus_alloc(parent); |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 285 | if (!ds->slave_mii_bus) |
| 286 | return -ENOMEM; |
Andrew Lunn | e755e49 | 2016-06-04 21:17:04 +0200 | [diff] [blame] | 287 | dsa_slave_mii_bus_init(ds); |
| 288 | |
| 289 | ret = mdiobus_register(ds->slave_mii_bus); |
| 290 | if (ret < 0) |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 291 | return ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 292 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 293 | |
| 294 | /* |
| 295 | * Create network devices for physical switch ports. |
| 296 | */ |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 297 | for (i = 0; i < DSA_MAX_PORTS; i++) { |
Andrew Lunn | 189b0d9 | 2016-06-04 21:16:58 +0200 | [diff] [blame] | 298 | ds->ports[i].dn = cd->port_dn[i]; |
| 299 | |
Andrew Lunn | 74c3e2a | 2016-04-13 02:40:44 +0200 | [diff] [blame] | 300 | if (!(ds->enabled_port_mask & (1 << i))) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 301 | continue; |
| 302 | |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 303 | ret = dsa_slave_create(ds, parent, i, cd->port_names[i]); |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 304 | if (ret < 0) |
Russell King | d25b8e7 | 2015-10-03 18:09:07 +0100 | [diff] [blame] | 305 | netdev_err(dst->master_netdev, "[%d]: can't create dsa slave device for port %d(%s): %d\n", |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 306 | index, i, cd->port_names[i], ret); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 307 | } |
| 308 | |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 309 | /* Perform configuration of the CPU and DSA ports */ |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 310 | ret = dsa_cpu_dsa_setups(ds, parent); |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 311 | if (ret < 0) |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 312 | netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n", |
| 313 | index); |
Andrew Lunn | 39b0c70 | 2015-08-31 15:56:49 +0200 | [diff] [blame] | 314 | |
Florian Fainelli | 0c73c52 | 2016-06-07 16:32:42 -0700 | [diff] [blame] | 315 | ret = dsa_cpu_port_ethtool_setup(ds); |
| 316 | if (ret) |
| 317 | return ret; |
| 318 | |
Vivien Didelot | 111427f | 2017-01-06 16:42:00 -0500 | [diff] [blame] | 319 | dsa_hwmon_register(ds); |
Guenter Roeck | 51579c3 | 2014-10-29 10:44:58 -0700 | [diff] [blame] | 320 | |
Vivien Didelot | a896eee | 2017-01-03 14:31:49 -0500 | [diff] [blame] | 321 | return 0; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | static struct dsa_switch * |
| 325 | dsa_switch_setup(struct dsa_switch_tree *dst, int index, |
| 326 | struct device *parent, struct device *host_dev) |
| 327 | { |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 328 | struct dsa_chip_data *cd = dst->pd->chip + index; |
Florian Fainelli | a82f67a | 2017-01-08 14:52:08 -0800 | [diff] [blame] | 329 | const struct dsa_switch_ops *ops; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 330 | struct dsa_switch *ds; |
| 331 | int ret; |
Vivien Didelot | 0209d14 | 2016-04-17 13:23:55 -0400 | [diff] [blame] | 332 | const char *name; |
Andrew Lunn | 7543a6d | 2016-04-13 02:40:40 +0200 | [diff] [blame] | 333 | void *priv; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 334 | |
| 335 | /* |
| 336 | * Probe for switch model. |
| 337 | */ |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 338 | ops = dsa_switch_probe(parent, host_dev, cd->sw_addr, &name, &priv); |
| 339 | if (!ops) { |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 340 | netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n", |
| 341 | index); |
| 342 | return ERR_PTR(-EINVAL); |
| 343 | } |
| 344 | netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n", |
| 345 | index, name); |
| 346 | |
| 347 | |
| 348 | /* |
| 349 | * Allocate and initialise switch state. |
| 350 | */ |
Andrew Lunn | 5feebd0 | 2016-04-13 02:40:41 +0200 | [diff] [blame] | 351 | ds = devm_kzalloc(parent, sizeof(*ds), GFP_KERNEL); |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 352 | if (ds == NULL) |
Florian Fainelli | 2459534 | 2015-05-29 10:29:46 -0700 | [diff] [blame] | 353 | return ERR_PTR(-ENOMEM); |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 354 | |
| 355 | ds->dst = dst; |
| 356 | ds->index = index; |
Andrew Lunn | ff04955 | 2016-05-10 23:27:24 +0200 | [diff] [blame] | 357 | ds->cd = cd; |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 358 | ds->ops = ops; |
Andrew Lunn | 7543a6d | 2016-04-13 02:40:40 +0200 | [diff] [blame] | 359 | ds->priv = priv; |
Andrew Lunn | c33063d | 2016-05-10 23:27:23 +0200 | [diff] [blame] | 360 | ds->dev = parent; |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 361 | |
| 362 | ret = dsa_switch_setup_one(ds, parent); |
| 363 | if (ret) |
Florian Fainelli | 2459534 | 2015-05-29 10:29:46 -0700 | [diff] [blame] | 364 | return ERR_PTR(ret); |
Florian Fainelli | df19719 | 2015-03-05 12:35:06 -0800 | [diff] [blame] | 365 | |
| 366 | return ds; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 367 | } |
| 368 | |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 369 | void dsa_cpu_dsa_destroy(struct device_node *port_dn) |
| 370 | { |
Johan Hovold | 3f65047 | 2016-11-28 19:24:55 +0100 | [diff] [blame] | 371 | if (of_phy_is_fixed_link(port_dn)) |
| 372 | of_phy_deregister_fixed_link(port_dn); |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 373 | } |
| 374 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 375 | static void dsa_switch_destroy(struct dsa_switch *ds) |
| 376 | { |
Neil Armstrong | cbc5d90 | 2015-10-06 15:40:32 +0100 | [diff] [blame] | 377 | int port; |
| 378 | |
Vivien Didelot | 111427f | 2017-01-06 16:42:00 -0500 | [diff] [blame] | 379 | dsa_hwmon_unregister(ds); |
Neil Armstrong | cbc5d90 | 2015-10-06 15:40:32 +0100 | [diff] [blame] | 380 | |
Andrew Lunn | 3a44514 | 2016-03-12 00:01:38 +0100 | [diff] [blame] | 381 | /* Destroy network devices for physical switch ports. */ |
| 382 | for (port = 0; port < DSA_MAX_PORTS; port++) { |
Andrew Lunn | 74c3e2a | 2016-04-13 02:40:44 +0200 | [diff] [blame] | 383 | if (!(ds->enabled_port_mask & (1 << port))) |
Andrew Lunn | 3a44514 | 2016-03-12 00:01:38 +0100 | [diff] [blame] | 384 | continue; |
| 385 | |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 386 | if (!ds->ports[port].netdev) |
Andrew Lunn | 3a44514 | 2016-03-12 00:01:38 +0100 | [diff] [blame] | 387 | continue; |
| 388 | |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 389 | dsa_slave_destroy(ds->ports[port].netdev); |
Andrew Lunn | 3a44514 | 2016-03-12 00:01:38 +0100 | [diff] [blame] | 390 | } |
| 391 | |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 392 | /* Disable configuration of the CPU and DSA ports */ |
Neil Armstrong | cbc5d90 | 2015-10-06 15:40:32 +0100 | [diff] [blame] | 393 | for (port = 0; port < DSA_MAX_PORTS; port++) { |
Andrew Lunn | 9b8e895 | 2016-06-04 21:17:01 +0200 | [diff] [blame] | 394 | if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) |
| 395 | continue; |
| 396 | dsa_cpu_dsa_destroy(ds->ports[port].dn); |
Andrew Lunn | 83c0afa | 2016-06-04 21:17:07 +0200 | [diff] [blame] | 397 | |
| 398 | /* Clearing a bit which is not set does no harm */ |
| 399 | ds->cpu_port_mask |= ~(1 << port); |
| 400 | ds->dsa_port_mask |= ~(1 << port); |
Neil Armstrong | cbc5d90 | 2015-10-06 15:40:32 +0100 | [diff] [blame] | 401 | } |
| 402 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 403 | if (ds->slave_mii_bus && ds->ops->phy_read) |
Andrew Lunn | e755e49 | 2016-06-04 21:17:04 +0200 | [diff] [blame] | 404 | mdiobus_unregister(ds->slave_mii_bus); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 405 | } |
| 406 | |
Thierry Reding | e506d40 | 2014-10-01 13:59:00 +0200 | [diff] [blame] | 407 | #ifdef CONFIG_PM_SLEEP |
Florian Fainelli | ea825e7 | 2016-08-18 15:30:12 -0700 | [diff] [blame] | 408 | int dsa_switch_suspend(struct dsa_switch *ds) |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 409 | { |
| 410 | int i, ret = 0; |
| 411 | |
| 412 | /* Suspend slave network devices */ |
| 413 | for (i = 0; i < DSA_MAX_PORTS; i++) { |
Guenter Roeck | d79d210 | 2015-02-24 23:02:02 -0800 | [diff] [blame] | 414 | if (!dsa_is_port_initialized(ds, i)) |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 415 | continue; |
| 416 | |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 417 | ret = dsa_slave_suspend(ds->ports[i].netdev); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 418 | if (ret) |
| 419 | return ret; |
| 420 | } |
| 421 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 422 | if (ds->ops->suspend) |
| 423 | ret = ds->ops->suspend(ds); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 424 | |
| 425 | return ret; |
| 426 | } |
Florian Fainelli | ea825e7 | 2016-08-18 15:30:12 -0700 | [diff] [blame] | 427 | EXPORT_SYMBOL_GPL(dsa_switch_suspend); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 428 | |
Florian Fainelli | ea825e7 | 2016-08-18 15:30:12 -0700 | [diff] [blame] | 429 | int dsa_switch_resume(struct dsa_switch *ds) |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 430 | { |
| 431 | int i, ret = 0; |
| 432 | |
Vivien Didelot | 9d490b4 | 2016-08-23 12:38:56 -0400 | [diff] [blame] | 433 | if (ds->ops->resume) |
| 434 | ret = ds->ops->resume(ds); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 435 | |
| 436 | if (ret) |
| 437 | return ret; |
| 438 | |
| 439 | /* Resume slave network devices */ |
| 440 | for (i = 0; i < DSA_MAX_PORTS; i++) { |
Guenter Roeck | d79d210 | 2015-02-24 23:02:02 -0800 | [diff] [blame] | 441 | if (!dsa_is_port_initialized(ds, i)) |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 442 | continue; |
| 443 | |
Andrew Lunn | c8b0980 | 2016-06-04 21:16:57 +0200 | [diff] [blame] | 444 | ret = dsa_slave_resume(ds->ports[i].netdev); |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 445 | if (ret) |
| 446 | return ret; |
| 447 | } |
| 448 | |
| 449 | return 0; |
| 450 | } |
Florian Fainelli | ea825e7 | 2016-08-18 15:30:12 -0700 | [diff] [blame] | 451 | EXPORT_SYMBOL_GPL(dsa_switch_resume); |
Thierry Reding | e506d40 | 2014-10-01 13:59:00 +0200 | [diff] [blame] | 452 | #endif |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 453 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 454 | /* platform driver init and cleanup *****************************************/ |
| 455 | static int dev_is_class(struct device *dev, void *class) |
| 456 | { |
| 457 | if (dev->class != NULL && !strcmp(dev->class->name, class)) |
| 458 | return 1; |
| 459 | |
| 460 | return 0; |
| 461 | } |
| 462 | |
| 463 | static struct device *dev_find_class(struct device *parent, char *class) |
| 464 | { |
| 465 | if (dev_is_class(parent, class)) { |
| 466 | get_device(parent); |
| 467 | return parent; |
| 468 | } |
| 469 | |
| 470 | return device_find_child(parent, class, dev_is_class); |
| 471 | } |
| 472 | |
Alexander Duyck | b4d2394 | 2014-09-15 13:00:27 -0400 | [diff] [blame] | 473 | struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 474 | { |
| 475 | struct device *d; |
| 476 | |
| 477 | d = dev_find_class(dev, "mdio_bus"); |
| 478 | if (d != NULL) { |
| 479 | struct mii_bus *bus; |
| 480 | |
| 481 | bus = to_mii_bus(d); |
| 482 | put_device(d); |
| 483 | |
| 484 | return bus; |
| 485 | } |
| 486 | |
| 487 | return NULL; |
| 488 | } |
Alexander Duyck | b4d2394 | 2014-09-15 13:00:27 -0400 | [diff] [blame] | 489 | EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 490 | |
| 491 | static struct net_device *dev_to_net_device(struct device *dev) |
| 492 | { |
| 493 | struct device *d; |
| 494 | |
| 495 | d = dev_find_class(dev, "net"); |
| 496 | if (d != NULL) { |
| 497 | struct net_device *nd; |
| 498 | |
| 499 | nd = to_net_dev(d); |
| 500 | dev_hold(nd); |
| 501 | put_device(d); |
| 502 | |
| 503 | return nd; |
| 504 | } |
| 505 | |
| 506 | return NULL; |
| 507 | } |
| 508 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 509 | #ifdef CONFIG_OF |
| 510 | static int dsa_of_setup_routing_table(struct dsa_platform_data *pd, |
| 511 | struct dsa_chip_data *cd, |
Pavel Nakonechny | 3030381 | 2015-04-05 00:46:21 +0300 | [diff] [blame] | 512 | int chip_index, int port_index, |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 513 | struct device_node *link) |
| 514 | { |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 515 | const __be32 *reg; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 516 | int link_sw_addr; |
| 517 | struct device_node *parent_sw; |
| 518 | int len; |
| 519 | |
| 520 | parent_sw = of_get_parent(link); |
| 521 | if (!parent_sw) |
| 522 | return -EINVAL; |
| 523 | |
| 524 | reg = of_get_property(parent_sw, "reg", &len); |
| 525 | if (!reg || (len != sizeof(*reg) * 2)) |
| 526 | return -EINVAL; |
| 527 | |
Pavel Nakonechny | 3030381 | 2015-04-05 00:46:21 +0300 | [diff] [blame] | 528 | /* |
| 529 | * Get the destination switch number from the second field of its 'reg' |
| 530 | * property, i.e. for "reg = <0x19 1>" sw_addr is '1'. |
| 531 | */ |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 532 | link_sw_addr = be32_to_cpup(reg + 1); |
| 533 | |
| 534 | if (link_sw_addr >= pd->nr_chips) |
| 535 | return -EINVAL; |
| 536 | |
Pavel Nakonechny | 3030381 | 2015-04-05 00:46:21 +0300 | [diff] [blame] | 537 | cd->rtable[link_sw_addr] = port_index; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 538 | |
| 539 | return 0; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 540 | } |
| 541 | |
Andrew Lunn | 1e72e6f | 2015-08-17 23:52:50 +0200 | [diff] [blame] | 542 | static int dsa_of_probe_links(struct dsa_platform_data *pd, |
| 543 | struct dsa_chip_data *cd, |
| 544 | int chip_index, int port_index, |
| 545 | struct device_node *port, |
| 546 | const char *port_name) |
| 547 | { |
| 548 | struct device_node *link; |
| 549 | int link_index; |
| 550 | int ret; |
| 551 | |
| 552 | for (link_index = 0;; link_index++) { |
| 553 | link = of_parse_phandle(port, "link", link_index); |
| 554 | if (!link) |
| 555 | break; |
| 556 | |
| 557 | if (!strcmp(port_name, "dsa") && pd->nr_chips > 1) { |
| 558 | ret = dsa_of_setup_routing_table(pd, cd, chip_index, |
| 559 | port_index, link); |
| 560 | if (ret) |
| 561 | return ret; |
| 562 | } |
| 563 | } |
| 564 | return 0; |
| 565 | } |
| 566 | |
Florian Fainelli | 2116824 | 2013-03-25 05:03:39 +0000 | [diff] [blame] | 567 | static void dsa_of_free_platform_data(struct dsa_platform_data *pd) |
| 568 | { |
| 569 | int i; |
| 570 | int port_index; |
| 571 | |
| 572 | for (i = 0; i < pd->nr_chips; i++) { |
| 573 | port_index = 0; |
Florian Fainelli | 5f64a7d | 2013-03-25 05:03:40 +0000 | [diff] [blame] | 574 | while (port_index < DSA_MAX_PORTS) { |
Fabian Frederick | 1f74714 | 2014-06-23 19:32:47 +0200 | [diff] [blame] | 575 | kfree(pd->chip[i].port_names[port_index]); |
Florian Fainelli | 5f64a7d | 2013-03-25 05:03:40 +0000 | [diff] [blame] | 576 | port_index++; |
| 577 | } |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 578 | |
| 579 | /* Drop our reference to the MDIO bus device */ |
| 580 | if (pd->chip[i].host_dev) |
| 581 | put_device(pd->chip[i].host_dev); |
Florian Fainelli | 2116824 | 2013-03-25 05:03:39 +0000 | [diff] [blame] | 582 | } |
| 583 | kfree(pd->chip); |
| 584 | } |
| 585 | |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 586 | static int dsa_of_probe(struct device *dev) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 587 | { |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 588 | struct device_node *np = dev->of_node; |
Andrew Lunn | 1e72e6f | 2015-08-17 23:52:50 +0200 | [diff] [blame] | 589 | struct device_node *child, *mdio, *ethernet, *port; |
Andrew Lunn | 6bc6d0a | 2015-08-08 17:09:14 +0200 | [diff] [blame] | 590 | struct mii_bus *mdio_bus, *mdio_bus_switch; |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 591 | struct net_device *ethernet_dev; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 592 | struct dsa_platform_data *pd; |
| 593 | struct dsa_chip_data *cd; |
| 594 | const char *port_name; |
| 595 | int chip_index, port_index; |
| 596 | const unsigned int *sw_addr, *port_reg; |
Guenter Roeck | 6793abb | 2014-10-29 10:45:01 -0700 | [diff] [blame] | 597 | u32 eeprom_len; |
Florian Fainelli | 2116824 | 2013-03-25 05:03:39 +0000 | [diff] [blame] | 598 | int ret; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 599 | |
| 600 | mdio = of_parse_phandle(np, "dsa,mii-bus", 0); |
| 601 | if (!mdio) |
| 602 | return -EINVAL; |
| 603 | |
| 604 | mdio_bus = of_mdio_find_bus(mdio); |
| 605 | if (!mdio_bus) |
Florian Fainelli | b324c07 | 2015-03-05 12:35:05 -0800 | [diff] [blame] | 606 | return -EPROBE_DEFER; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 607 | |
| 608 | ethernet = of_parse_phandle(np, "dsa,ethernet", 0); |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 609 | if (!ethernet) { |
| 610 | ret = -EINVAL; |
| 611 | goto out_put_mdio; |
| 612 | } |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 613 | |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 614 | ethernet_dev = of_find_net_device_by_node(ethernet); |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 615 | if (!ethernet_dev) { |
| 616 | ret = -EPROBE_DEFER; |
| 617 | goto out_put_mdio; |
| 618 | } |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 619 | |
| 620 | pd = kzalloc(sizeof(*pd), GFP_KERNEL); |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 621 | if (!pd) { |
| 622 | ret = -ENOMEM; |
Russell King | 9861f72 | 2015-09-24 20:36:33 +0100 | [diff] [blame] | 623 | goto out_put_ethernet; |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 624 | } |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 625 | |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 626 | dev->platform_data = pd; |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 627 | pd->of_netdev = ethernet_dev; |
Tobias Waldekranz | e04449f | 2015-02-05 14:54:09 +0100 | [diff] [blame] | 628 | pd->nr_chips = of_get_available_child_count(np); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 629 | if (pd->nr_chips > DSA_MAX_SWITCHES) |
| 630 | pd->nr_chips = DSA_MAX_SWITCHES; |
| 631 | |
Fabian Frederick | 6f2aed6 | 2014-11-14 19:38:23 +0100 | [diff] [blame] | 632 | pd->chip = kcalloc(pd->nr_chips, sizeof(struct dsa_chip_data), |
| 633 | GFP_KERNEL); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 634 | if (!pd->chip) { |
| 635 | ret = -ENOMEM; |
| 636 | goto out_free; |
| 637 | } |
| 638 | |
Fabian Godehardt | d1c0b47 | 2014-05-16 06:21:44 +0200 | [diff] [blame] | 639 | chip_index = -1; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 640 | for_each_available_child_of_node(np, child) { |
Vivien Didelot | d390238 | 2016-07-06 20:03:54 -0400 | [diff] [blame] | 641 | int i; |
| 642 | |
Fabian Godehardt | d1c0b47 | 2014-05-16 06:21:44 +0200 | [diff] [blame] | 643 | chip_index++; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 644 | cd = &pd->chip[chip_index]; |
| 645 | |
Florian Fainelli | fa981d9 | 2014-08-27 17:04:49 -0700 | [diff] [blame] | 646 | cd->of_node = child; |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 647 | |
Vivien Didelot | d390238 | 2016-07-06 20:03:54 -0400 | [diff] [blame] | 648 | /* Initialize the routing table */ |
| 649 | for (i = 0; i < DSA_MAX_SWITCHES; ++i) |
| 650 | cd->rtable[i] = DSA_RTABLE_NONE; |
| 651 | |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 652 | /* When assigning the host device, increment its refcount */ |
| 653 | cd->host_dev = get_device(&mdio_bus->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 654 | |
| 655 | sw_addr = of_get_property(child, "reg", NULL); |
| 656 | if (!sw_addr) |
| 657 | continue; |
| 658 | |
| 659 | cd->sw_addr = be32_to_cpup(sw_addr); |
Florian Fainelli | c8cf89f | 2015-07-11 18:02:11 -0700 | [diff] [blame] | 660 | if (cd->sw_addr >= PHY_MAX_ADDR) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 661 | continue; |
| 662 | |
Guenter Roeck | 50d4964 | 2015-04-29 10:56:15 -0700 | [diff] [blame] | 663 | if (!of_property_read_u32(child, "eeprom-length", &eeprom_len)) |
Guenter Roeck | 6793abb | 2014-10-29 10:45:01 -0700 | [diff] [blame] | 664 | cd->eeprom_len = eeprom_len; |
| 665 | |
Andrew Lunn | 6bc6d0a | 2015-08-08 17:09:14 +0200 | [diff] [blame] | 666 | mdio = of_parse_phandle(child, "mii-bus", 0); |
| 667 | if (mdio) { |
| 668 | mdio_bus_switch = of_mdio_find_bus(mdio); |
| 669 | if (!mdio_bus_switch) { |
| 670 | ret = -EPROBE_DEFER; |
| 671 | goto out_free_chip; |
| 672 | } |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 673 | |
| 674 | /* Drop the mdio_bus device ref, replacing the host |
| 675 | * device with the mdio_bus_switch device, keeping |
| 676 | * the refcount from of_mdio_find_bus() above. |
| 677 | */ |
| 678 | put_device(cd->host_dev); |
Andrew Lunn | 6bc6d0a | 2015-08-08 17:09:14 +0200 | [diff] [blame] | 679 | cd->host_dev = &mdio_bus_switch->dev; |
| 680 | } |
| 681 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 682 | for_each_available_child_of_node(child, port) { |
| 683 | port_reg = of_get_property(port, "reg", NULL); |
| 684 | if (!port_reg) |
| 685 | continue; |
| 686 | |
| 687 | port_index = be32_to_cpup(port_reg); |
Florian Fainelli | 8f5063e | 2015-07-11 18:02:10 -0700 | [diff] [blame] | 688 | if (port_index >= DSA_MAX_PORTS) |
| 689 | break; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 690 | |
| 691 | port_name = of_get_property(port, "label", NULL); |
| 692 | if (!port_name) |
| 693 | continue; |
| 694 | |
Florian Fainelli | bd47497 | 2014-08-27 17:04:50 -0700 | [diff] [blame] | 695 | cd->port_dn[port_index] = port; |
| 696 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 697 | cd->port_names[port_index] = kstrdup(port_name, |
| 698 | GFP_KERNEL); |
| 699 | if (!cd->port_names[port_index]) { |
| 700 | ret = -ENOMEM; |
| 701 | goto out_free_chip; |
| 702 | } |
| 703 | |
Andrew Lunn | 1e72e6f | 2015-08-17 23:52:50 +0200 | [diff] [blame] | 704 | ret = dsa_of_probe_links(pd, cd, chip_index, |
| 705 | port_index, port, port_name); |
| 706 | if (ret) |
| 707 | goto out_free_chip; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 708 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 709 | } |
| 710 | } |
| 711 | |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 712 | /* The individual chips hold their own refcount on the mdio bus, |
| 713 | * so drop ours */ |
| 714 | put_device(&mdio_bus->dev); |
| 715 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 716 | return 0; |
| 717 | |
| 718 | out_free_chip: |
Florian Fainelli | 2116824 | 2013-03-25 05:03:39 +0000 | [diff] [blame] | 719 | dsa_of_free_platform_data(pd); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 720 | out_free: |
| 721 | kfree(pd); |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 722 | dev->platform_data = NULL; |
Russell King | 9861f72 | 2015-09-24 20:36:33 +0100 | [diff] [blame] | 723 | out_put_ethernet: |
| 724 | put_device(ðernet_dev->dev); |
Russell King | e496ae6 | 2015-09-24 20:35:57 +0100 | [diff] [blame] | 725 | out_put_mdio: |
| 726 | put_device(&mdio_bus->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 727 | return ret; |
| 728 | } |
| 729 | |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 730 | static void dsa_of_remove(struct device *dev) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 731 | { |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 732 | struct dsa_platform_data *pd = dev->platform_data; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 733 | |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 734 | if (!dev->of_node) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 735 | return; |
| 736 | |
Florian Fainelli | 2116824 | 2013-03-25 05:03:39 +0000 | [diff] [blame] | 737 | dsa_of_free_platform_data(pd); |
Russell King | 9861f72 | 2015-09-24 20:36:33 +0100 | [diff] [blame] | 738 | put_device(&pd->of_netdev->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 739 | kfree(pd); |
| 740 | } |
| 741 | #else |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 742 | static inline int dsa_of_probe(struct device *dev) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 743 | { |
| 744 | return 0; |
| 745 | } |
| 746 | |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 747 | static inline void dsa_of_remove(struct device *dev) |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 748 | { |
| 749 | } |
| 750 | #endif |
| 751 | |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 752 | static int dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev, |
| 753 | struct device *parent, struct dsa_platform_data *pd) |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 754 | { |
| 755 | int i; |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 756 | unsigned configured = 0; |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 757 | |
| 758 | dst->pd = pd; |
| 759 | dst->master_netdev = dev; |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 760 | dst->cpu_port = -1; |
| 761 | |
| 762 | for (i = 0; i < pd->nr_chips; i++) { |
| 763 | struct dsa_switch *ds; |
| 764 | |
| 765 | ds = dsa_switch_setup(dst, i, parent, pd->chip[i].host_dev); |
| 766 | if (IS_ERR(ds)) { |
| 767 | netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n", |
| 768 | i, PTR_ERR(ds)); |
| 769 | continue; |
| 770 | } |
| 771 | |
| 772 | dst->ds[i] = ds; |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 773 | |
| 774 | ++configured; |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 775 | } |
| 776 | |
| 777 | /* |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 778 | * If no switch was found, exit cleanly |
| 779 | */ |
| 780 | if (!configured) |
| 781 | return -EPROBE_DEFER; |
| 782 | |
| 783 | /* |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 784 | * If we use a tagging format that doesn't have an ethertype |
| 785 | * field, make sure that all packets from this point on get |
| 786 | * sent to the tag format's receive function. |
| 787 | */ |
| 788 | wmb(); |
| 789 | dev->dsa_ptr = (void *)dst; |
| 790 | |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 791 | return 0; |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 792 | } |
| 793 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 794 | static int dsa_probe(struct platform_device *pdev) |
| 795 | { |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 796 | struct dsa_platform_data *pd = pdev->dev.platform_data; |
| 797 | struct net_device *dev; |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 798 | struct dsa_switch_tree *dst; |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 799 | int ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 800 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 801 | if (pdev->dev.of_node) { |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 802 | ret = dsa_of_probe(&pdev->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 803 | if (ret) |
| 804 | return ret; |
| 805 | |
| 806 | pd = pdev->dev.platform_data; |
| 807 | } |
| 808 | |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 809 | if (pd == NULL || (pd->netdev == NULL && pd->of_netdev == NULL)) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 810 | return -EINVAL; |
| 811 | |
Florian Fainelli | 769a020 | 2015-03-09 14:31:21 -0700 | [diff] [blame] | 812 | if (pd->of_netdev) { |
| 813 | dev = pd->of_netdev; |
| 814 | dev_hold(dev); |
| 815 | } else { |
| 816 | dev = dev_to_net_device(pd->netdev); |
| 817 | } |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 818 | if (dev == NULL) { |
Florian Fainelli | b324c07 | 2015-03-05 12:35:05 -0800 | [diff] [blame] | 819 | ret = -EPROBE_DEFER; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 820 | goto out; |
| 821 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 822 | |
| 823 | if (dev->dsa_ptr != NULL) { |
| 824 | dev_put(dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 825 | ret = -EEXIST; |
| 826 | goto out; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 827 | } |
| 828 | |
Neil Armstrong | d4ac35d | 2015-10-06 15:40:37 +0100 | [diff] [blame] | 829 | dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL); |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 830 | if (dst == NULL) { |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 831 | dev_put(dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 832 | ret = -ENOMEM; |
| 833 | goto out; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 834 | } |
| 835 | |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 836 | platform_set_drvdata(pdev, dst); |
| 837 | |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 838 | ret = dsa_setup_dst(dst, dev, &pdev->dev, pd); |
Neil Armstrong | 679fb46 | 2015-12-07 13:57:34 +0100 | [diff] [blame] | 839 | if (ret) { |
| 840 | dev_put(dev); |
Neil Armstrong | 4d7f3e7 | 2015-10-06 15:40:43 +0100 | [diff] [blame] | 841 | goto out; |
Neil Armstrong | 679fb46 | 2015-12-07 13:57:34 +0100 | [diff] [blame] | 842 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 843 | |
| 844 | return 0; |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 845 | |
| 846 | out: |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 847 | dsa_of_remove(&pdev->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 848 | |
| 849 | return ret; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 850 | } |
| 851 | |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 852 | static void dsa_remove_dst(struct dsa_switch_tree *dst) |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 853 | { |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 854 | int i; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 855 | |
Neil Armstrong | 0476189 | 2016-03-08 10:36:20 +0100 | [diff] [blame] | 856 | dst->master_netdev->dsa_ptr = NULL; |
| 857 | |
| 858 | /* If we used a tagging format that doesn't have an ethertype |
| 859 | * field, make sure that all packets from this point get sent |
| 860 | * without the tag and go through the regular receive path. |
| 861 | */ |
| 862 | wmb(); |
| 863 | |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 864 | for (i = 0; i < dst->pd->nr_chips; i++) { |
| 865 | struct dsa_switch *ds = dst->ds[i]; |
| 866 | |
Neil Armstrong | d4ac35d | 2015-10-06 15:40:37 +0100 | [diff] [blame] | 867 | if (ds) |
Lennert Buytenhek | e84665c | 2009-03-20 09:52:09 +0000 | [diff] [blame] | 868 | dsa_switch_destroy(ds); |
| 869 | } |
Neil Armstrong | 679fb46 | 2015-12-07 13:57:34 +0100 | [diff] [blame] | 870 | |
Vivien Didelot | 9520ed8 | 2017-01-17 20:41:39 -0500 | [diff] [blame^] | 871 | dsa_cpu_port_ethtool_restore(dst->cpu_switch); |
Florian Fainelli | 0c73c52 | 2016-06-07 16:32:42 -0700 | [diff] [blame] | 872 | |
Neil Armstrong | 679fb46 | 2015-12-07 13:57:34 +0100 | [diff] [blame] | 873 | dev_put(dst->master_netdev); |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 874 | } |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 875 | |
Florian Fainelli | c86e59b | 2015-03-05 12:35:08 -0800 | [diff] [blame] | 876 | static int dsa_remove(struct platform_device *pdev) |
| 877 | { |
| 878 | struct dsa_switch_tree *dst = platform_get_drvdata(pdev); |
| 879 | |
| 880 | dsa_remove_dst(dst); |
Florian Fainelli | f1a26a0 | 2015-03-05 12:35:04 -0800 | [diff] [blame] | 881 | dsa_of_remove(&pdev->dev); |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 882 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 883 | return 0; |
| 884 | } |
| 885 | |
| 886 | static void dsa_shutdown(struct platform_device *pdev) |
| 887 | { |
| 888 | } |
| 889 | |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 890 | static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev, |
| 891 | struct packet_type *pt, struct net_device *orig_dev) |
| 892 | { |
| 893 | struct dsa_switch_tree *dst = dev->dsa_ptr; |
| 894 | |
| 895 | if (unlikely(dst == NULL)) { |
| 896 | kfree_skb(skb); |
| 897 | return 0; |
| 898 | } |
| 899 | |
Alexander Duyck | 5075314 | 2014-09-15 13:00:19 -0400 | [diff] [blame] | 900 | return dst->rcv(skb, dev, pt, orig_dev); |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 901 | } |
| 902 | |
Florian Fainelli | 61b7363 | 2014-08-29 12:42:07 -0700 | [diff] [blame] | 903 | static struct packet_type dsa_pack_type __read_mostly = { |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 904 | .type = cpu_to_be16(ETH_P_XDSA), |
| 905 | .func = dsa_switch_rcv, |
| 906 | }; |
| 907 | |
Florian Fainelli | b73adef | 2015-02-24 13:15:33 -0800 | [diff] [blame] | 908 | static struct notifier_block dsa_netdevice_nb __read_mostly = { |
| 909 | .notifier_call = dsa_slave_netdevice_event, |
| 910 | }; |
| 911 | |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 912 | #ifdef CONFIG_PM_SLEEP |
| 913 | static int dsa_suspend(struct device *d) |
| 914 | { |
| 915 | struct platform_device *pdev = to_platform_device(d); |
| 916 | struct dsa_switch_tree *dst = platform_get_drvdata(pdev); |
| 917 | int i, ret = 0; |
| 918 | |
| 919 | for (i = 0; i < dst->pd->nr_chips; i++) { |
| 920 | struct dsa_switch *ds = dst->ds[i]; |
| 921 | |
| 922 | if (ds != NULL) |
| 923 | ret = dsa_switch_suspend(ds); |
| 924 | } |
| 925 | |
| 926 | return ret; |
| 927 | } |
| 928 | |
| 929 | static int dsa_resume(struct device *d) |
| 930 | { |
| 931 | struct platform_device *pdev = to_platform_device(d); |
| 932 | struct dsa_switch_tree *dst = platform_get_drvdata(pdev); |
| 933 | int i, ret = 0; |
| 934 | |
| 935 | for (i = 0; i < dst->pd->nr_chips; i++) { |
| 936 | struct dsa_switch *ds = dst->ds[i]; |
| 937 | |
| 938 | if (ds != NULL) |
| 939 | ret = dsa_switch_resume(ds); |
| 940 | } |
| 941 | |
| 942 | return ret; |
| 943 | } |
| 944 | #endif |
| 945 | |
| 946 | static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume); |
| 947 | |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 948 | static const struct of_device_id dsa_of_match_table[] = { |
| 949 | { .compatible = "marvell,dsa", }, |
| 950 | {} |
| 951 | }; |
| 952 | MODULE_DEVICE_TABLE(of, dsa_of_match_table); |
| 953 | |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 954 | static struct platform_driver dsa_driver = { |
| 955 | .probe = dsa_probe, |
| 956 | .remove = dsa_remove, |
| 957 | .shutdown = dsa_shutdown, |
| 958 | .driver = { |
| 959 | .name = "dsa", |
Florian Fainelli | 5e95329b | 2013-03-22 10:50:50 +0000 | [diff] [blame] | 960 | .of_match_table = dsa_of_match_table, |
Florian Fainelli | 2446254 | 2014-09-18 17:31:22 -0700 | [diff] [blame] | 961 | .pm = &dsa_pm_ops, |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 962 | }, |
| 963 | }; |
| 964 | |
| 965 | static int __init dsa_init_module(void) |
| 966 | { |
Ben Hutchings | 7df899c | 2011-11-25 14:35:02 +0000 | [diff] [blame] | 967 | int rc; |
| 968 | |
Florian Fainelli | b73adef | 2015-02-24 13:15:33 -0800 | [diff] [blame] | 969 | register_netdevice_notifier(&dsa_netdevice_nb); |
| 970 | |
Ben Hutchings | 7df899c | 2011-11-25 14:35:02 +0000 | [diff] [blame] | 971 | rc = platform_driver_register(&dsa_driver); |
| 972 | if (rc) |
| 973 | return rc; |
| 974 | |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 975 | dev_add_pack(&dsa_pack_type); |
| 976 | |
Ben Hutchings | 7df899c | 2011-11-25 14:35:02 +0000 | [diff] [blame] | 977 | return 0; |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 978 | } |
| 979 | module_init(dsa_init_module); |
| 980 | |
| 981 | static void __exit dsa_cleanup_module(void) |
| 982 | { |
Florian Fainelli | b73adef | 2015-02-24 13:15:33 -0800 | [diff] [blame] | 983 | unregister_netdevice_notifier(&dsa_netdevice_nb); |
Florian Fainelli | 3e8a72d | 2014-08-27 17:04:46 -0700 | [diff] [blame] | 984 | dev_remove_pack(&dsa_pack_type); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 985 | platform_driver_unregister(&dsa_driver); |
| 986 | } |
| 987 | module_exit(dsa_cleanup_module); |
| 988 | |
Rusty Russell | 577d6a7 | 2011-01-24 14:32:52 -0600 | [diff] [blame] | 989 | MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); |
Lennert Buytenhek | 91da11f | 2008-10-07 13:44:02 +0000 | [diff] [blame] | 990 | MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); |
| 991 | MODULE_LICENSE("GPL"); |
| 992 | MODULE_ALIAS("platform:dsa"); |