1 /* 2 * Handling of a master device, switching frames via its switch fabric CPU 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 "dsa_priv.h" 14 15 static void dsa_master_get_ethtool_stats(struct net_device *dev, 16 struct ethtool_stats *stats, 17 uint64_t *data) 18 { 19 struct dsa_port *cpu_dp = dev->dsa_ptr; 20 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; 21 struct dsa_switch *ds = cpu_dp->ds; 22 int port = cpu_dp->index; 23 int count = 0; 24 25 if (ops->get_sset_count && ops->get_ethtool_stats) { 26 count = ops->get_sset_count(dev, ETH_SS_STATS); 27 ops->get_ethtool_stats(dev, stats, data); 28 } 29 30 if (ds->ops->get_ethtool_stats) 31 ds->ops->get_ethtool_stats(ds, port, data + count); 32 } 33 34 static void dsa_master_get_ethtool_phy_stats(struct net_device *dev, 35 struct ethtool_stats *stats, 36 uint64_t *data) 37 { 38 struct dsa_port *cpu_dp = dev->dsa_ptr; 39 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; 40 struct dsa_switch *ds = cpu_dp->ds; 41 int port = cpu_dp->index; 42 int count = 0; 43 44 if (dev->phydev && !ops->get_ethtool_phy_stats) { 45 count = phy_ethtool_get_sset_count(dev->phydev); 46 if (count >= 0) 47 phy_ethtool_get_stats(dev->phydev, stats, data); 48 } else if (ops->get_sset_count && ops->get_ethtool_phy_stats) { 49 count = ops->get_sset_count(dev, ETH_SS_PHY_STATS); 50 ops->get_ethtool_phy_stats(dev, stats, data); 51 } 52 53 if (count < 0) 54 count = 0; 55 56 if (ds->ops->get_ethtool_phy_stats) 57 ds->ops->get_ethtool_phy_stats(ds, port, data + count); 58 } 59 60 static int dsa_master_get_sset_count(struct net_device *dev, int sset) 61 { 62 struct dsa_port *cpu_dp = dev->dsa_ptr; 63 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; 64 struct dsa_switch *ds = cpu_dp->ds; 65 int count = 0; 66 67 if (sset == ETH_SS_PHY_STATS && dev->phydev && 68 !ops->get_ethtool_phy_stats) 69 count = phy_ethtool_get_sset_count(dev->phydev); 70 else if (ops->get_sset_count) 71 count = ops->get_sset_count(dev, sset); 72 73 if (count < 0) 74 count = 0; 75 76 if (ds->ops->get_sset_count) 77 count += ds->ops->get_sset_count(ds, cpu_dp->index, sset); 78 79 return count; 80 } 81 82 static void dsa_master_get_strings(struct net_device *dev, uint32_t stringset, 83 uint8_t *data) 84 { 85 struct dsa_port *cpu_dp = dev->dsa_ptr; 86 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops; 87 struct dsa_switch *ds = cpu_dp->ds; 88 int port = cpu_dp->index; 89 int len = ETH_GSTRING_LEN; 90 int mcount = 0, count; 91 unsigned int i; 92 uint8_t pfx[4]; 93 uint8_t *ndata; 94 95 snprintf(pfx, sizeof(pfx), "p%.2d", port); 96 /* We do not want to be NULL-terminated, since this is a prefix */ 97 pfx[sizeof(pfx) - 1] = '_'; 98 99 if (stringset == ETH_SS_PHY_STATS && dev->phydev && 100 !ops->get_ethtool_phy_stats) { 101 mcount = phy_ethtool_get_sset_count(dev->phydev); 102 if (mcount < 0) 103 mcount = 0; 104 else 105 phy_ethtool_get_strings(dev->phydev, data); 106 } else if (ops->get_sset_count && ops->get_strings) { 107 mcount = ops->get_sset_count(dev, stringset); 108 if (mcount < 0) 109 mcount = 0; 110 ops->get_strings(dev, stringset, data); 111 } 112 113 if (ds->ops->get_strings) { 114 ndata = data + mcount * len; 115 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle 116 * the output after to prepend our CPU port prefix we 117 * constructed earlier 118 */ 119 ds->ops->get_strings(ds, port, stringset, ndata); 120 count = ds->ops->get_sset_count(ds, port, stringset); 121 for (i = 0; i < count; i++) { 122 memmove(ndata + (i * len + sizeof(pfx)), 123 ndata + i * len, len - sizeof(pfx)); 124 memcpy(ndata + i * len, pfx, sizeof(pfx)); 125 } 126 } 127 } 128 129 static int dsa_master_ethtool_setup(struct net_device *dev) 130 { 131 struct dsa_port *cpu_dp = dev->dsa_ptr; 132 struct dsa_switch *ds = cpu_dp->ds; 133 struct ethtool_ops *ops; 134 135 ops = devm_kzalloc(ds->dev, sizeof(*ops), GFP_KERNEL); 136 if (!ops) 137 return -ENOMEM; 138 139 cpu_dp->orig_ethtool_ops = dev->ethtool_ops; 140 if (cpu_dp->orig_ethtool_ops) 141 memcpy(ops, cpu_dp->orig_ethtool_ops, sizeof(*ops)); 142 143 ops->get_sset_count = dsa_master_get_sset_count; 144 ops->get_ethtool_stats = dsa_master_get_ethtool_stats; 145 ops->get_strings = dsa_master_get_strings; 146 ops->get_ethtool_phy_stats = dsa_master_get_ethtool_phy_stats; 147 148 dev->ethtool_ops = ops; 149 150 return 0; 151 } 152 153 static void dsa_master_ethtool_teardown(struct net_device *dev) 154 { 155 struct dsa_port *cpu_dp = dev->dsa_ptr; 156 157 dev->ethtool_ops = cpu_dp->orig_ethtool_ops; 158 cpu_dp->orig_ethtool_ops = NULL; 159 } 160 161 static ssize_t tagging_show(struct device *d, struct device_attribute *attr, 162 char *buf) 163 { 164 struct net_device *dev = to_net_dev(d); 165 struct dsa_port *cpu_dp = dev->dsa_ptr; 166 167 return sprintf(buf, "%s\n", 168 dsa_tag_protocol_to_str(cpu_dp->tag_ops)); 169 } 170 static DEVICE_ATTR_RO(tagging); 171 172 static struct attribute *dsa_slave_attrs[] = { 173 &dev_attr_tagging.attr, 174 NULL 175 }; 176 177 static const struct attribute_group dsa_group = { 178 .name = "dsa", 179 .attrs = dsa_slave_attrs, 180 }; 181 182 static void dsa_master_set_mtu(struct net_device *dev, struct dsa_port *cpu_dp) 183 { 184 unsigned int mtu = ETH_DATA_LEN + cpu_dp->tag_ops->overhead; 185 int err; 186 187 rtnl_lock(); 188 if (mtu <= dev->max_mtu) { 189 err = dev_set_mtu(dev, mtu); 190 if (err) 191 netdev_dbg(dev, "Unable to set MTU to include for DSA overheads\n"); 192 } 193 rtnl_unlock(); 194 } 195 196 static void dsa_master_reset_mtu(struct net_device *dev) 197 { 198 int err; 199 200 rtnl_lock(); 201 err = dev_set_mtu(dev, ETH_DATA_LEN); 202 if (err) 203 netdev_dbg(dev, 204 "Unable to reset MTU to exclude DSA overheads\n"); 205 rtnl_unlock(); 206 } 207 208 int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp) 209 { 210 int ret; 211 212 dsa_master_set_mtu(dev, cpu_dp); 213 214 /* If we use a tagging format that doesn't have an ethertype 215 * field, make sure that all packets from this point on get 216 * sent to the tag format's receive function. 217 */ 218 wmb(); 219 220 dev->dsa_ptr = cpu_dp; 221 222 ret = dsa_master_ethtool_setup(dev); 223 if (ret) 224 return ret; 225 226 ret = sysfs_create_group(&dev->dev.kobj, &dsa_group); 227 if (ret) 228 dsa_master_ethtool_teardown(dev); 229 230 return ret; 231 } 232 233 void dsa_master_teardown(struct net_device *dev) 234 { 235 sysfs_remove_group(&dev->dev.kobj, &dsa_group); 236 dsa_master_ethtool_teardown(dev); 237 dsa_master_reset_mtu(dev); 238 239 dev->dsa_ptr = NULL; 240 241 /* If we used a tagging format that doesn't have an ethertype 242 * field, make sure that all packets from this point get sent 243 * without the tag and go through the regular receive path. 244 */ 245 wmb(); 246 } 247