linux/drivers/net/ethernet/aquantia/atlantic/aq_main.c
<<
>>
Prefs
   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
  24MODULE_LICENSE("GPL v2");
  25MODULE_AUTHOR(AQ_CFG_DRV_AUTHOR);
  26MODULE_DESCRIPTION(AQ_CFG_DRV_DESC);
  27
  28static const char aq_ndev_driver_name[] = AQ_CFG_DRV_NAME;
  29
  30static const struct net_device_ops aq_ndev_ops;
  31
  32static struct workqueue_struct *aq_ndev_wq;
  33
  34void aq_ndev_schedule_work(struct work_struct *work)
  35{
  36        queue_work(aq_ndev_wq, work);
  37}
  38
  39struct 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
  56static 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
  79err_exit:
  80        if (err < 0)
  81                aq_nic_deinit(aq_nic, true);
  82
  83        return err;
  84}
  85
  86static 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
  96err_exit:
  97        return err;
  98}
  99
 100static 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
 127static 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
 138err_exit:
 139        return err;
 140}
 141
 142static 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
 203err_exit:
 204        return err;
 205}
 206
 207static 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
 219err_exit:
 220        return err;
 221}
 222
 223static 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)
 231static 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
 267static 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)
 290static 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
 303static 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
 320static 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
 333static 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
 349static 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
 376static 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
 416static 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_do_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
 430static 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
 449static 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
 459module_init(aq_ndev_init_module);
 460module_exit(aq_ndev_exit_module);
 461