linux/drivers/net/ethernet/freescale/enetc/enetc_vf.c
<<
>>
Prefs
   1// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2/* Copyright 2017-2019 NXP */
   3
   4#include <linux/module.h>
   5#include "enetc.h"
   6
   7#define ENETC_DRV_NAME_STR "ENETC VF driver"
   8
   9/* Messaging */
  10static void enetc_msg_vsi_write_msg(struct enetc_hw *hw,
  11                                    struct enetc_msg_swbd *msg)
  12{
  13        u32 val;
  14
  15        val = enetc_vsi_set_msize(msg->size) | lower_32_bits(msg->dma);
  16        enetc_wr(hw, ENETC_VSIMSGSNDAR1, upper_32_bits(msg->dma));
  17        enetc_wr(hw, ENETC_VSIMSGSNDAR0, val);
  18}
  19
  20static int enetc_msg_vsi_send(struct enetc_si *si, struct enetc_msg_swbd *msg)
  21{
  22        int timeout = 100;
  23        u32 vsimsgsr;
  24
  25        enetc_msg_vsi_write_msg(&si->hw, msg);
  26
  27        do {
  28                vsimsgsr = enetc_rd(&si->hw, ENETC_VSIMSGSR);
  29                if (!(vsimsgsr & ENETC_VSIMSGSR_MB))
  30                        break;
  31
  32                usleep_range(1000, 2000);
  33        } while (--timeout);
  34
  35        if (!timeout)
  36                return -ETIMEDOUT;
  37
  38        /* check for message delivery error */
  39        if (vsimsgsr & ENETC_VSIMSGSR_MS) {
  40                dev_err(&si->pdev->dev, "VSI command execute error: %d\n",
  41                        ENETC_SIMSGSR_GET_MC(vsimsgsr));
  42                return -EIO;
  43        }
  44
  45        return 0;
  46}
  47
  48static int enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv *priv,
  49                                              struct sockaddr *saddr)
  50{
  51        struct enetc_msg_cmd_set_primary_mac *cmd;
  52        struct enetc_msg_swbd msg;
  53        int err;
  54
  55        msg.size = ALIGN(sizeof(struct enetc_msg_cmd_set_primary_mac), 64);
  56        msg.vaddr = dma_alloc_coherent(priv->dev, msg.size, &msg.dma,
  57                                       GFP_KERNEL);
  58        if (!msg.vaddr) {
  59                dev_err(priv->dev, "Failed to alloc Tx msg (size: %d)\n",
  60                        msg.size);
  61                return -ENOMEM;
  62        }
  63
  64        cmd = (struct enetc_msg_cmd_set_primary_mac *)msg.vaddr;
  65        cmd->header.type = ENETC_MSG_CMD_MNG_MAC;
  66        cmd->header.id = ENETC_MSG_CMD_MNG_ADD;
  67        memcpy(&cmd->mac, saddr, sizeof(struct sockaddr));
  68
  69        /* send the command and wait */
  70        err = enetc_msg_vsi_send(priv->si, &msg);
  71
  72        dma_free_coherent(priv->dev, msg.size, msg.vaddr, msg.dma);
  73
  74        return err;
  75}
  76
  77static int enetc_vf_set_mac_addr(struct net_device *ndev, void *addr)
  78{
  79        struct enetc_ndev_priv *priv = netdev_priv(ndev);
  80        struct sockaddr *saddr = addr;
  81
  82        if (!is_valid_ether_addr(saddr->sa_data))
  83                return -EADDRNOTAVAIL;
  84
  85        return enetc_msg_vsi_set_primary_mac_addr(priv, saddr);
  86}
  87
  88static int enetc_vf_set_features(struct net_device *ndev,
  89                                 netdev_features_t features)
  90{
  91        return enetc_set_features(ndev, features);
  92}
  93
  94/* Probing/ Init */
  95static const struct net_device_ops enetc_ndev_ops = {
  96        .ndo_open               = enetc_open,
  97        .ndo_stop               = enetc_close,
  98        .ndo_start_xmit         = enetc_xmit,
  99        .ndo_get_stats          = enetc_get_stats,
 100        .ndo_set_mac_address    = enetc_vf_set_mac_addr,
 101        .ndo_set_features       = enetc_vf_set_features,
 102        .ndo_eth_ioctl          = enetc_ioctl,
 103        .ndo_setup_tc           = enetc_setup_tc,
 104};
 105
 106static void enetc_vf_netdev_setup(struct enetc_si *si, struct net_device *ndev,
 107                                  const struct net_device_ops *ndev_ops)
 108{
 109        struct enetc_ndev_priv *priv = netdev_priv(ndev);
 110
 111        SET_NETDEV_DEV(ndev, &si->pdev->dev);
 112        priv->ndev = ndev;
 113        priv->si = si;
 114        priv->dev = &si->pdev->dev;
 115        si->ndev = ndev;
 116
 117        priv->msg_enable = (NETIF_MSG_IFUP << 1) - 1;
 118        ndev->netdev_ops = ndev_ops;
 119        enetc_set_ethtool_ops(ndev);
 120        ndev->watchdog_timeo = 5 * HZ;
 121        ndev->max_mtu = ENETC_MAX_MTU;
 122
 123        ndev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM |
 124                            NETIF_F_HW_VLAN_CTAG_TX |
 125                            NETIF_F_HW_VLAN_CTAG_RX |
 126                            NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6;
 127        ndev->features = NETIF_F_HIGHDMA | NETIF_F_SG | NETIF_F_RXCSUM |
 128                         NETIF_F_HW_VLAN_CTAG_TX |
 129                         NETIF_F_HW_VLAN_CTAG_RX |
 130                         NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6;
 131        ndev->vlan_features = NETIF_F_SG | NETIF_F_HW_CSUM |
 132                              NETIF_F_TSO | NETIF_F_TSO6;
 133
 134        if (si->num_rss)
 135                ndev->hw_features |= NETIF_F_RXHASH;
 136
 137        /* pick up primary MAC address from SI */
 138        enetc_load_primary_mac_addr(&si->hw, ndev);
 139}
 140
 141static int enetc_vf_probe(struct pci_dev *pdev,
 142                          const struct pci_device_id *ent)
 143{
 144        struct enetc_ndev_priv *priv;
 145        struct net_device *ndev;
 146        struct enetc_si *si;
 147        int err;
 148
 149        err = enetc_pci_probe(pdev, KBUILD_MODNAME, 0);
 150        if (err)
 151                return dev_err_probe(&pdev->dev, err, "PCI probing failed\n");
 152
 153        si = pci_get_drvdata(pdev);
 154
 155        enetc_get_si_caps(si);
 156
 157        ndev = alloc_etherdev_mq(sizeof(*priv), ENETC_MAX_NUM_TXQS);
 158        if (!ndev) {
 159                err = -ENOMEM;
 160                dev_err(&pdev->dev, "netdev creation failed\n");
 161                goto err_alloc_netdev;
 162        }
 163
 164        enetc_vf_netdev_setup(si, ndev, &enetc_ndev_ops);
 165
 166        priv = netdev_priv(ndev);
 167
 168        enetc_init_si_rings_params(priv);
 169
 170        err = enetc_setup_cbdr(priv->dev, &si->hw, ENETC_CBDR_DEFAULT_SIZE,
 171                               &si->cbd_ring);
 172        if (err)
 173                goto err_setup_cbdr;
 174
 175        err = enetc_alloc_si_resources(priv);
 176        if (err) {
 177                dev_err(&pdev->dev, "SI resource alloc failed\n");
 178                goto err_alloc_si_res;
 179        }
 180
 181        err = enetc_configure_si(priv);
 182        if (err) {
 183                dev_err(&pdev->dev, "Failed to configure SI\n");
 184                goto err_config_si;
 185        }
 186
 187        err = enetc_alloc_msix(priv);
 188        if (err) {
 189                dev_err(&pdev->dev, "MSIX alloc failed\n");
 190                goto err_alloc_msix;
 191        }
 192
 193        err = register_netdev(ndev);
 194        if (err)
 195                goto err_reg_netdev;
 196
 197        netif_carrier_off(ndev);
 198
 199        return 0;
 200
 201err_reg_netdev:
 202        enetc_free_msix(priv);
 203err_config_si:
 204err_alloc_msix:
 205        enetc_free_si_resources(priv);
 206err_alloc_si_res:
 207        enetc_teardown_cbdr(&si->cbd_ring);
 208err_setup_cbdr:
 209        si->ndev = NULL;
 210        free_netdev(ndev);
 211err_alloc_netdev:
 212        enetc_pci_remove(pdev);
 213
 214        return err;
 215}
 216
 217static void enetc_vf_remove(struct pci_dev *pdev)
 218{
 219        struct enetc_si *si = pci_get_drvdata(pdev);
 220        struct enetc_ndev_priv *priv;
 221
 222        priv = netdev_priv(si->ndev);
 223        unregister_netdev(si->ndev);
 224
 225        enetc_free_msix(priv);
 226
 227        enetc_free_si_resources(priv);
 228        enetc_teardown_cbdr(&si->cbd_ring);
 229
 230        free_netdev(si->ndev);
 231
 232        enetc_pci_remove(pdev);
 233}
 234
 235static const struct pci_device_id enetc_vf_id_table[] = {
 236        { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, ENETC_DEV_ID_VF) },
 237        { 0, } /* End of table. */
 238};
 239MODULE_DEVICE_TABLE(pci, enetc_vf_id_table);
 240
 241static struct pci_driver enetc_vf_driver = {
 242        .name = KBUILD_MODNAME,
 243        .id_table = enetc_vf_id_table,
 244        .probe = enetc_vf_probe,
 245        .remove = enetc_vf_remove,
 246};
 247module_pci_driver(enetc_vf_driver);
 248
 249MODULE_DESCRIPTION(ENETC_DRV_NAME_STR);
 250MODULE_LICENSE("Dual BSD/GPL");
 251