drivers/net/ethernet/aquantia/atlantic/aq_main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Atlantic Network Driver
   3  *
   4  * Copyright (C) 2014-2019 aQuantia Corporation
   5  * Copyright (C) 2019-2020 Marvell International Ltd.
   6  */
   7
   8 /* File aq_main.c: Main file for aQuantia Linux driver. */
   9
  10 #include "aq_main.h"
  11 #include "aq_nic.h"
  12 #include "aq_pci_func.h"
  13 #include "aq_ethtool.h"
  14 #include "aq_ptp.h"
  15 #include "aq_filters.h"
  16 #include "aq_hw_utils.h"
  17
  18 #include <linux/netdevice.h>
  19 #include <linux/module.h>
  20 #include <linux/ip.h>
  21 #include <linux/udp.h>
  22 #include <net/pkt_cls.h>
  23
  24 MODULE_LICENSE("GPL v2");
  25 MODULE_AUTHOR(AQ_CFG_DRV_AUTHOR);
  26 MODULE_DESCRIPTION(AQ_CFG_DRV_DESC);
  27
  28 static const char aq_ndev_driver_name[] = AQ_CFG_DRV_NAME;
  29
  30 static const struct net_device_ops aq_ndev_ops;
  31
  32 static struct workqueue_struct *aq_ndev_wq;
  33
  34 void aq_ndev_schedule_work(struct work_struct *work)
  35 {
  36         queue_work(aq_ndev_wq, work);
  37 }
  38
  39 struct net_device *aq_ndev_alloc(void)
  40 {
  41         struct net_device *ndev = NULL;
  42         struct aq_nic_s *aq_nic = NULL;
  43
  44         ndev = alloc_etherdev_mq(sizeof(struct aq_nic_s), AQ_HW_QUEUES_MAX);
  45         if (!ndev)
  46                 return NULL;
  47
  48         aq_nic = netdev_priv(ndev);
  49         aq_nic->ndev = ndev;
  50         ndev->netdev_ops = &aq_ndev_ops;
  51         ndev->ethtool_ops = &aq_ethtool_ops;
  52
  53         return ndev;
  54 }
  55
  56 static int aq_ndev_open(struct net_device *ndev)
  57 {
  58         struct aq_nic_s *aq_nic = netdev_priv(ndev);
  59         int err = 0;
  60
  61         err = aq_nic_init(aq_nic);
  62         if (err < 0)
  63                 goto err_exit;
  64
  65         err = aq_reapply_rxnfc_all_rules(aq_nic);
  66         if (err < 0)
  67                 goto err_exit;
  68
  69         err = aq_filters_vlans_update(aq_nic);
  70         if (err < 0)
  71                 goto err_exit;
  72
  73         err = aq_nic_start(aq_nic);
  74         if (err < 0) {
  75                 aq_nic_stop(aq_nic);
  76                 goto err_exit;
  77         }
  78
  79 err_exit:
  80         if (err < 0)
  81                 aq_nic_deinit(aq_nic, true);
  82
  83         return err;
  84 }
  85
  86 static int aq_ndev_close(struct net_device *ndev)
  87 {
  88         struct aq_nic_s *aq_nic = netdev_priv(ndev);
  89         int err = 0;
  90
  91         err = aq_nic_stop(aq_nic);
  92         if (err < 0)
  93                 goto err_exit;
  94         aq_nic_deinit(aq_nic, true);
  95
  96 err_exit:
  97         return err;
  98 }
  99
 100 static netdev_tx_t aq_ndev_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 101 {
 102         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 103
 104 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 105         if (unlikely(aq_utils_obj_test(&aq_nic->flags, AQ_NIC_PTP_DPATH_UP))) {
 106                 /* Hardware adds the Timestamp for PTPv2 802.AS1
 107                  * and PTPv2 IPv4 UDP.
 108                  * We have to push even general 320 port messages to the ptp
 109                  * queue explicitly. This is a limitation of current firmware
 110                  * and hardware PTP design of the chip. Otherwise ptp stream
 111                  * will fail to sync
 112                  */
 113                 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) ||
 114                     unlikely((ip_hdr(skb)->version == 4) &&
 115                              (ip_hdr(skb)->protocol == IPPROTO_UDP) &&
 116                              ((udp_hdr(skb)->dest == htons(319)) ||
 117                               (udp_hdr(skb)->dest == htons(320)))) ||
 118                     unlikely(eth_hdr(skb)->h_proto == htons(ETH_P_1588)))
 119                         return aq_ptp_xmit(aq_nic, skb);
 120         }
 121 #endif
 122
 123         skb_tx_timestamp(skb);
 124         return aq_nic_xmit(aq_nic, skb);
 125 }
 126
 127 static int aq_ndev_change_mtu(struct net_device *ndev, int new_mtu)
 128 {
 129         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 130         int err;
 131
 132         err = aq_nic_set_mtu(aq_nic, new_mtu + ETH_HLEN);
 133
 134         if (err < 0)
 135                 goto err_exit;
 136         ndev->mtu = new_mtu;
 137
 138 err_exit:
 139         return err;
 140 }
 141
 142 static int aq_ndev_set_features(struct net_device *ndev,
 143                                 netdev_features_t features)
 144 {
 145         bool is_vlan_tx_insert = !!(features & NETIF_F_HW_VLAN_CTAG_TX);
 146         bool is_vlan_rx_strip = !!(features & NETIF_F_HW_VLAN_CTAG_RX);
 147         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 148         bool need_ndev_restart = false;
 149         struct aq_nic_cfg_s *aq_cfg;
 150         bool is_lro = false;
 151         int err = 0;
 152
 153         aq_cfg = aq_nic_get_cfg(aq_nic);
 154
 155         if (!(features & NETIF_F_NTUPLE)) {
 156                 if (aq_nic->ndev->features & NETIF_F_NTUPLE) {
 157                         err = aq_clear_rxnfc_all_rules(aq_nic);
 158                         if (unlikely(err))
 159                                 goto err_exit;
 160                 }
 161         }
 162         if (!(features & NETIF_F_HW_VLAN_CTAG_FILTER)) {
 163                 if (aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
 164                         err = aq_filters_vlan_offload_off(aq_nic);
 165                         if (unlikely(err))
 166                                 goto err_exit;
 167                 }
 168         }
 169
 170         aq_cfg->features = features;
 171
 172         if (aq_cfg->aq_hw_caps->hw_features & NETIF_F_LRO) {
 173                 is_lro = features & NETIF_F_LRO;
 174
 175                 if (aq_cfg->is_lro != is_lro) {
 176                         aq_cfg->is_lro = is_lro;
 177                         need_ndev_restart = true;
 178                 }
 179         }
 180
 181         if ((aq_nic->ndev->features ^ features) & NETIF_F_RXCSUM) {
 182                 err = aq_nic->aq_hw_ops->hw_set_offload(aq_nic->aq_hw,
 183                                                         aq_cfg);
 184
 185                 if (unlikely(err))
 186                         goto err_exit;
 187         }
 188
 189         if (aq_cfg->is_vlan_rx_strip != is_vlan_rx_strip) {
 190                 aq_cfg->is_vlan_rx_strip = is_vlan_rx_strip;
 191                 need_ndev_restart = true;
 192         }
 193         if (aq_cfg->is_vlan_tx_insert != is_vlan_tx_insert) {
 194                 aq_cfg->is_vlan_tx_insert = is_vlan_tx_insert;
 195                 need_ndev_restart = true;
 196         }
 197
 198         if (need_ndev_restart && netif_running(ndev)) {
 199                 aq_ndev_close(ndev);
 200                 aq_ndev_open(ndev);
 201         }
 202
 203 err_exit:
 204         return err;
 205 }
 206
 207 static int aq_ndev_set_mac_address(struct net_device *ndev, void *addr)
 208 {
 209         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 210         int err = 0;
 211
 212         err = eth_mac_addr(ndev, addr);
 213         if (err < 0)
 214                 goto err_exit;
 215         err = aq_nic_set_mac(aq_nic, ndev);
 216         if (err < 0)
 217                 goto err_exit;
 218
 219 err_exit:
 220         return err;
 221 }
 222
 223 static void aq_ndev_set_multicast_settings(struct net_device *ndev)
 224 {
 225         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 226
 227         (void)aq_nic_set_multicast_list(aq_nic, ndev);
 228 }
 229
 230 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 231 static int aq_ndev_config_hwtstamp(struct aq_nic_s *aq_nic,
 232                                    struct hwtstamp_config *config)
 233 {
 234         if (config->flags)
 235                 return -EINVAL;
 236
 237         switch (config->tx_type) {
 238         case HWTSTAMP_TX_OFF:
 239         case HWTSTAMP_TX_ON:
 240                 break;
 241         default:
 242                 return -ERANGE;
 243         }
 244
 245         switch (config->rx_filter) {
 246         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
 247         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
 248         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
 249         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
 250         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
 251         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
 252         case HWTSTAMP_FILTER_PTP_V2_SYNC:
 253         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
 254                 config->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
 255                 break;
 256         case HWTSTAMP_FILTER_PTP_V2_EVENT:
 257         case HWTSTAMP_FILTER_NONE:
 258                 break;
 259         default:
 260                 return -ERANGE;
 261         }
 262
 263         return aq_ptp_hwtstamp_config_set(aq_nic->aq_ptp, config);
 264 }
 265 #endif
 266
 267 static int aq_ndev_hwtstamp_set(struct aq_nic_s *aq_nic, struct ifreq *ifr)
 268 {
 269         struct hwtstamp_config config;
 270 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 271         int ret_val;
 272 #endif
 273
 274         if (!aq_nic->aq_ptp)
 275                 return -EOPNOTSUPP;
 276
 277         if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
 278                 return -EFAULT;
 279 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 280         ret_val = aq_ndev_config_hwtstamp(aq_nic, &config);
 281         if (ret_val)
 282                 return ret_val;
 283 #endif
 284
 285         return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
 286                -EFAULT : 0;
 287 }
 288
 289 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 290 static int aq_ndev_hwtstamp_get(struct aq_nic_s *aq_nic, struct ifreq *ifr)
 291 {
 292         struct hwtstamp_config config;
 293
 294         if (!aq_nic->aq_ptp)
 295                 return -EOPNOTSUPP;
 296
 297         aq_ptp_hwtstamp_config_get(aq_nic->aq_ptp, &config);
 298         return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
 299                -EFAULT : 0;
 300 }
 301 #endif
 302
 303 static int aq_ndev_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 304 {
 305         struct aq_nic_s *aq_nic = netdev_priv(netdev);
 306
 307         switch (cmd) {
 308         case SIOCSHWTSTAMP:
 309                 return aq_ndev_hwtstamp_set(aq_nic, ifr);
 310
 311 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
 312         case SIOCGHWTSTAMP:
 313                 return aq_ndev_hwtstamp_get(aq_nic, ifr);
 314 #endif
 315         }
 316
 317         return -EOPNOTSUPP;
 318 }
 319
 320 static int aq_ndo_vlan_rx_add_vid(struct net_device *ndev, __be16 proto,
 321                                   u16 vid)
 322 {
 323         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 324
 325         if (!aq_nic->aq_hw_ops->hw_filter_vlan_set)
 326                 return -EOPNOTSUPP;
 327
 328         set_bit(vid, aq_nic->active_vlans);
 329
 330         return aq_filters_vlans_update(aq_nic);
 331 }
 332
 333 static int aq_ndo_vlan_rx_kill_vid(struct net_device *ndev, __be16 proto,
 334                                    u16 vid)
 335 {
 336         struct aq_nic_s *aq_nic = netdev_priv(ndev);
 337
 338         if (!aq_nic->aq_hw_ops->hw_filter_vlan_set)
 339                 return -EOPNOTSUPP;
 340
 341         clear_bit(vid, aq_nic->active_vlans);
 342
 343         if (-ENOENT == aq_del_fvlan_by_vlan(aq_nic, vid))
 344                 return aq_filters_vlans_update(aq_nic);
 345
 346         return 0;
 347 }
 348
 349 static int aq_validate_mqprio_opt(struct aq_nic_s *self,
 350                                   struct tc_mqprio_qopt_offload *mqprio,
 351                                   const unsigned int num_tc)
 352 {
 353         const bool has_min_rate = !!(mqprio->flags & TC_MQPRIO_F_MIN_RATE);
 354         struct aq_nic_cfg_s *aq_nic_cfg = aq_nic_get_cfg(self);
 355         const unsigned int tcs_max = min_t(u8, aq_nic_cfg->aq_hw_caps->tcs_max,
 356                                            AQ_CFG_TCS_MAX);
 357
 358         if (num_tc > tcs_max) {
 359                 netdev_err(self->ndev, "Too many TCs requested\n");
 360                 return -EOPNOTSUPP;
 361         }
 362
 363         if (num_tc != 0 && !is_power_of_2(num_tc)) {
 364                 netdev_err(self->ndev, "TC count should be power of 2\n");
 365                 return -EOPNOTSUPP;
 366         }
 367
 368         if (has_min_rate && !ATL_HW_IS_CHIP_FEATURE(self->aq_hw, ANTIGUA)) {
 369                 netdev_err(self->ndev, "Min tx rate is not supported\n");
 370                 return -EOPNOTSUPP;
 371         }
 372
 373         return 0;
 374 }
 375
 376 static int aq_ndo_setup_tc(struct net_device *dev, enum tc_setup_type type,
 377                            void *type_data)
 378 {
 379         struct tc_mqprio_qopt_offload *mqprio = type_data;
 380         struct aq_nic_s *aq_nic = netdev_priv(dev);
 381         bool has_min_rate;
 382         bool has_max_rate;
 383         int err;
 384         int i;
 385
 386         if (type != TC_SETUP_QDISC_MQPRIO)
 387                 return -EOPNOTSUPP;
 388
 389         has_min_rate = !!(mqprio->flags & TC_MQPRIO_F_MIN_RATE);
 390         has_max_rate = !!(mqprio->flags & TC_MQPRIO_F_MAX_RATE);
 391
 392         err = aq_validate_mqprio_opt(aq_nic, mqprio, mqprio->qopt.num_tc);
 393         if (err)
 394                 return err;
 395
 396         for (i = 0; i < mqprio->qopt.num_tc; i++) {
 397                 if (has_max_rate) {
 398                         u64 max_rate = mqprio->max_rate[i];
 399
 400                         do_div(max_rate, AQ_MBPS_DIVISOR);
 401                         aq_nic_setup_tc_max_rate(aq_nic, i, (u32)max_rate);
 402                 }
 403
 404                 if (has_min_rate) {
 405                         u64 min_rate = mqprio->min_rate[i];
 406
 407                         do_div(min_rate, AQ_MBPS_DIVISOR);
 408                         aq_nic_setup_tc_min_rate(aq_nic, i, (u32)min_rate);
 409                 }
 410         }
 411
 412         return aq_nic_setup_tc_mqprio(aq_nic, mqprio->qopt.num_tc,
 413                                       mqprio->qopt.prio_tc_map);
 414 }
 415
 416 static const struct net_device_ops aq_ndev_ops = {
 417         .ndo_open = aq_ndev_open,
 418         .ndo_stop = aq_ndev_close,
 419         .ndo_start_xmit = aq_ndev_start_xmit,
 420         .ndo_set_rx_mode = aq_ndev_set_multicast_settings,
 421         .ndo_change_mtu = aq_ndev_change_mtu,
 422         .ndo_set_mac_address = aq_ndev_set_mac_address,
 423         .ndo_set_features = aq_ndev_set_features,
 424         .ndo_eth_ioctl = aq_ndev_ioctl,
 425         .ndo_vlan_rx_add_vid = aq_ndo_vlan_rx_add_vid,
 426         .ndo_vlan_rx_kill_vid = aq_ndo_vlan_rx_kill_vid,
 427         .ndo_setup_tc = aq_ndo_setup_tc,
 428 };
 429
 430 static int __init aq_ndev_init_module(void)
 431 {
 432         int ret;
 433
 434         aq_ndev_wq = create_singlethread_workqueue(aq_ndev_driver_name);
 435         if (!aq_ndev_wq) {
 436                 pr_err("Failed to create workqueue\n");
 437                 return -ENOMEM;
 438         }
 439
 440         ret = aq_pci_func_register_driver();
 441         if (ret) {
 442                 destroy_workqueue(aq_ndev_wq);
 443                 return ret;
 444         }
 445
 446         return 0;
 447 }
 448
 449 static void __exit aq_ndev_exit_module(void)
 450 {
 451         aq_pci_func_unregister_driver();
 452
 453         if (aq_ndev_wq) {
 454                 destroy_workqueue(aq_ndev_wq);
 455                 aq_ndev_wq = NULL;
 456         }
 457 }
 458
 459 module_init(aq_ndev_init_module);
 460 module_exit(aq_ndev_exit_module);