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 */ 10 static 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 20 static 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 48 static 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 77 static 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 int err; 82 83 if (!is_valid_ether_addr(saddr->sa_data)) 84 return -EADDRNOTAVAIL; 85 86 err = enetc_msg_vsi_set_primary_mac_addr(priv, saddr); 87 if (err) 88 return err; 89 90 eth_hw_addr_set(ndev, saddr->sa_data); 91 92 return 0; 93 } 94 95 static int enetc_vf_set_features(struct net_device *ndev, 96 netdev_features_t features) 97 { 98 enetc_set_features(ndev, features); 99 100 return 0; 101 } 102 103 static int enetc_vf_setup_tc(struct net_device *ndev, enum tc_setup_type type, 104 void *type_data) 105 { 106 switch (type) { 107 case TC_SETUP_QDISC_MQPRIO: 108 return enetc_setup_tc_mqprio(ndev, type_data); 109 default: 110 return -EOPNOTSUPP; 111 } 112 } 113 114 /* Probing/ Init */ 115 static const struct net_device_ops enetc_ndev_ops = { 116 .ndo_open = enetc_open, 117 .ndo_stop = enetc_close, 118 .ndo_start_xmit = enetc_xmit, 119 .ndo_get_stats = enetc_get_stats, 120 .ndo_set_mac_address = enetc_vf_set_mac_addr, 121 .ndo_set_features = enetc_vf_set_features, 122 .ndo_eth_ioctl = enetc_ioctl, 123 .ndo_setup_tc = enetc_vf_setup_tc, 124 .ndo_hwtstamp_get = enetc_hwtstamp_get, 125 .ndo_hwtstamp_set = enetc_hwtstamp_set, 126 }; 127 128 static void enetc_vf_netdev_setup(struct enetc_si *si, struct net_device *ndev, 129 const struct net_device_ops *ndev_ops) 130 { 131 struct enetc_ndev_priv *priv = netdev_priv(ndev); 132 133 SET_NETDEV_DEV(ndev, &si->pdev->dev); 134 priv->ndev = ndev; 135 priv->si = si; 136 priv->dev = &si->pdev->dev; 137 si->ndev = ndev; 138 139 priv->msg_enable = (NETIF_MSG_IFUP << 1) - 1; 140 priv->sysclk_freq = si->drvdata->sysclk_freq; 141 priv->max_frags = si->drvdata->max_frags; 142 ndev->netdev_ops = ndev_ops; 143 enetc_set_ethtool_ops(ndev); 144 ndev->watchdog_timeo = 5 * HZ; 145 ndev->max_mtu = ENETC_MAX_MTU; 146 147 ndev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM | 148 NETIF_F_HW_VLAN_CTAG_TX | 149 NETIF_F_HW_VLAN_CTAG_RX | 150 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 | 151 NETIF_F_GSO_UDP_L4; 152 ndev->features = NETIF_F_HIGHDMA | NETIF_F_SG | NETIF_F_RXCSUM | 153 NETIF_F_HW_VLAN_CTAG_TX | 154 NETIF_F_HW_VLAN_CTAG_RX | 155 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 | 156 NETIF_F_GSO_UDP_L4; 157 ndev->vlan_features = NETIF_F_SG | NETIF_F_HW_CSUM | 158 NETIF_F_TSO | NETIF_F_TSO6; 159 160 if (si->num_rss) { 161 ndev->hw_features |= NETIF_F_RXHASH; 162 ndev->features |= NETIF_F_RXHASH; 163 } 164 165 /* pick up primary MAC address from SI */ 166 enetc_load_primary_mac_addr(&si->hw, ndev); 167 } 168 169 static const struct enetc_si_ops enetc_vsi_ops = { 170 .get_rss_table = enetc_get_rss_table, 171 .set_rss_table = enetc_set_rss_table, 172 }; 173 174 static int enetc_vf_probe(struct pci_dev *pdev, 175 const struct pci_device_id *ent) 176 { 177 struct enetc_ndev_priv *priv; 178 struct net_device *ndev; 179 struct enetc_si *si; 180 int err; 181 182 err = enetc_pci_probe(pdev, KBUILD_MODNAME, 0); 183 if (err) 184 return dev_err_probe(&pdev->dev, err, "PCI probing failed\n"); 185 186 si = pci_get_drvdata(pdev); 187 si->revision = ENETC_REV_1_0; 188 si->ops = &enetc_vsi_ops; 189 err = enetc_get_driver_data(si); 190 if (err) { 191 dev_err_probe(&pdev->dev, err, 192 "Could not get VF driver data\n"); 193 goto err_alloc_netdev; 194 } 195 196 enetc_get_si_caps(si); 197 198 ndev = alloc_etherdev_mq(sizeof(*priv), ENETC_MAX_NUM_TXQS); 199 if (!ndev) { 200 err = -ENOMEM; 201 dev_err(&pdev->dev, "netdev creation failed\n"); 202 goto err_alloc_netdev; 203 } 204 205 enetc_vf_netdev_setup(si, ndev, &enetc_ndev_ops); 206 207 priv = netdev_priv(ndev); 208 209 enetc_init_si_rings_params(priv); 210 211 err = enetc_setup_cbdr(priv->dev, &si->hw, ENETC_CBDR_DEFAULT_SIZE, 212 &si->cbd_ring); 213 if (err) 214 goto err_setup_cbdr; 215 216 err = enetc_alloc_si_resources(priv); 217 if (err) { 218 dev_err(&pdev->dev, "SI resource alloc failed\n"); 219 goto err_alloc_si_res; 220 } 221 222 err = enetc_configure_si(priv); 223 if (err) { 224 dev_err(&pdev->dev, "Failed to configure SI\n"); 225 goto err_config_si; 226 } 227 228 err = enetc_alloc_msix(priv); 229 if (err) { 230 dev_err(&pdev->dev, "MSIX alloc failed\n"); 231 goto err_alloc_msix; 232 } 233 234 err = register_netdev(ndev); 235 if (err) 236 goto err_reg_netdev; 237 238 netif_carrier_off(ndev); 239 240 return 0; 241 242 err_reg_netdev: 243 enetc_free_msix(priv); 244 err_config_si: 245 err_alloc_msix: 246 enetc_free_si_resources(priv); 247 err_alloc_si_res: 248 enetc_teardown_cbdr(&si->cbd_ring); 249 err_setup_cbdr: 250 si->ndev = NULL; 251 free_netdev(ndev); 252 err_alloc_netdev: 253 enetc_pci_remove(pdev); 254 255 return err; 256 } 257 258 static void enetc_vf_remove(struct pci_dev *pdev) 259 { 260 struct enetc_si *si = pci_get_drvdata(pdev); 261 struct enetc_ndev_priv *priv; 262 263 priv = netdev_priv(si->ndev); 264 unregister_netdev(si->ndev); 265 266 enetc_free_msix(priv); 267 268 enetc_free_si_resources(priv); 269 enetc_teardown_cbdr(&si->cbd_ring); 270 271 free_netdev(si->ndev); 272 273 enetc_pci_remove(pdev); 274 } 275 276 static const struct pci_device_id enetc_vf_id_table[] = { 277 { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, ENETC_DEV_ID_VF) }, 278 { 0, } /* End of table. */ 279 }; 280 MODULE_DEVICE_TABLE(pci, enetc_vf_id_table); 281 282 static struct pci_driver enetc_vf_driver = { 283 .name = KBUILD_MODNAME, 284 .id_table = enetc_vf_id_table, 285 .probe = enetc_vf_probe, 286 .remove = enetc_vf_remove, 287 }; 288 module_pci_driver(enetc_vf_driver); 289 290 MODULE_DESCRIPTION(ENETC_DRV_NAME_STR); 291 MODULE_LICENSE("Dual BSD/GPL"); 292