1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) 2 /* Copyright 2017-2019 NXP */ 3 4 #include <linux/iopoll.h> 5 #include <linux/module.h> 6 #include "enetc.h" 7 8 #define ENETC_DRV_NAME_STR "ENETC VF driver" 9 10 /* Note: This function should be called after filling the message body, 11 * because the CRC16 needs to be calculated after all the data has been 12 * filled. 13 */ 14 static void enetc_msg_fill_common_hdr(struct enetc_msg_swbd *msg_swbd, 15 u8 class_id, u8 cmd_id, u8 proto_ver, 16 u8 cookie) 17 { 18 struct enetc_msg_header *hdr = msg_swbd->vaddr; 19 u8 *data_buf = ((u8 *)msg_swbd->vaddr) + 2; /* skip crc16 field */ 20 u32 data_size = msg_swbd->size - 2; 21 u16 crc16; 22 23 hdr->class_id = class_id; 24 hdr->cmd_id = cmd_id; 25 hdr->len = ENETC_MSG_EXT_BODY_LEN(msg_swbd->size); 26 hdr->proto_ver = proto_ver; 27 hdr->cookie = FIELD_PREP(ENETC_VF_MSG_COOKIE, cookie); 28 29 crc16 = crc_itu_t(ENETC_CRC_INIT, data_buf, data_size); 30 hdr->crc16 = htons(crc16); 31 } 32 33 static void enetc_msg_vsi_write_msg(struct enetc_hw *hw, 34 struct enetc_msg_swbd *msg) 35 { 36 u32 val; 37 38 val = enetc_vsi_set_msize(msg->size) | lower_32_bits(msg->dma); 39 enetc_wr(hw, ENETC_VSIMSGSNDAR1, upper_32_bits(msg->dma)); 40 enetc_wr(hw, ENETC_VSIMSGSNDAR0, val); 41 } 42 43 static void enetc_msg_dma_free(struct device *dev, struct enetc_msg_swbd *msg) 44 { 45 if (msg->vaddr) { 46 dma_free_coherent(dev, msg->size, msg->vaddr, msg->dma); 47 msg->vaddr = NULL; 48 } 49 } 50 51 static int enetc_msg_vsi_send(struct enetc_si *si, struct enetc_msg_swbd *msg) 52 { 53 struct device *dev = &si->pdev->dev; 54 u32 vsimsgsr; 55 u16 pf_msg; 56 int err; 57 58 /* The VSI mailbox may be busy if last message was not yet processed 59 * by PSI. So need to check the mailbox status before sending. 60 */ 61 vsimsgsr = enetc_rd(&si->hw, ENETC_VSIMSGSR); 62 if (vsimsgsr & ENETC_VSIMSGSR_MB) { 63 /* It is safe to free the DMA buffer here, the caller does 64 * not access the DMA buffer if enetc_msg_vsi_send() fails. 65 */ 66 enetc_msg_dma_free(dev, msg); 67 dev_err(dev, "VSI mailbox is busy\n"); 68 return -EIO; 69 } 70 71 /* Free the DMA buffer of the last message */ 72 enetc_msg_dma_free(dev, &si->msg); 73 si->msg = *msg; 74 enetc_msg_vsi_write_msg(&si->hw, msg); 75 err = read_poll_timeout(enetc_rd, vsimsgsr, 76 !(vsimsgsr & ENETC_VSIMSGSR_MB), 77 1000, 200000, false, &si->hw, ENETC_VSIMSGSR); 78 if (err) { 79 dev_err(dev, "VSI mailbox timeout\n"); 80 81 return err; 82 } 83 84 /* check for message delivery error */ 85 if (vsimsgsr & ENETC_VSIMSGSR_MS) { 86 dev_err(dev, "Transfer error when copying the data\n"); 87 return -EIO; 88 } 89 90 pf_msg = ENETC_SIMSGSR_GET_MC(vsimsgsr); 91 /* Check the user-defined completion status. */ 92 if (FIELD_GET(ENETC_PF_MSG_CLASS_ID, pf_msg) != 93 ENETC_MSG_CLASS_ID_CMD_SUCCESS) { 94 switch (FIELD_GET(ENETC_PF_MSG_CLASS_ID, pf_msg)) { 95 case ENETC_MSG_CLASS_ID_PERMISSION_DENY: 96 /* Intentionally returning early to prevent excessive 97 * error logs due to permission issues. 98 */ 99 return -EACCES; 100 case ENETC_MSG_CLASS_ID_CMD_NOT_SUPPORT: 101 case ENETC_MSG_CLASS_ID_PROTO_NOT_SUPPORT: 102 err = -EOPNOTSUPP; 103 break; 104 case ENETC_MSG_CLASS_ID_PSI_BUSY: 105 err = -EBUSY; 106 break; 107 case ENETC_MSG_CLASS_ID_CMD_TIMEOUT: 108 err = -ETIME; 109 break; 110 case ENETC_MSG_CLASS_ID_INVALID_MSG_LEN: 111 case ENETC_MSG_CLASS_ID_MAC_FILTER: 112 err = -EINVAL; 113 break; 114 case ENETC_MSG_CLASS_ID_CMD_NOT_PERMITTED: 115 err = -EPERM; 116 break; 117 case ENETC_MSG_CLASS_ID_IP_REVISION: 118 err = FIELD_GET(ENETC_PF_MSG_CLASS_CODE_U8, pf_msg); 119 break; 120 case ENETC_MSG_CLASS_ID_CMD_FAIL: 121 case ENETC_MSG_CLASS_ID_CRC_ERROR: 122 case ENETC_MSG_CLASS_ID_CMD_DEFERRED: 123 default: 124 err = -EIO; 125 } 126 } 127 128 if (err < 0) 129 dev_err(dev, "Return error code from PSI: 0x%04x\n", pf_msg); 130 131 return err; 132 } 133 134 static int enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv *priv, 135 struct sockaddr *saddr) 136 { 137 struct enetc_msg_mac_exact_filter *msg; 138 struct enetc_msg_swbd msg_swbd; 139 u32 msg_size; 140 141 msg_size = struct_size(msg, mac, 1); 142 msg_swbd.size = ALIGN(msg_size, ENETC_MSG_ALIGN); 143 msg_swbd.vaddr = dma_alloc_coherent(priv->dev, msg_swbd.size, 144 &msg_swbd.dma, GFP_KERNEL); 145 if (!msg_swbd.vaddr) 146 return -ENOMEM; 147 148 msg = (struct enetc_msg_mac_exact_filter *)msg_swbd.vaddr; 149 memcpy(&msg->mac[0].addr, saddr->sa_data, ETH_ALEN); 150 enetc_msg_fill_common_hdr(&msg_swbd, ENETC_MSG_CLASS_ID_MAC_FILTER, 151 ENETC_MSG_SET_PRIMARY_MAC, 0, 0); 152 153 /* send the command and wait */ 154 return enetc_msg_vsi_send(priv->si, &msg_swbd); 155 } 156 157 static int enetc_vf_get_ip_minor_revision(struct enetc_si *si) 158 { 159 struct device *dev = &si->pdev->dev; 160 struct enetc_msg_swbd msg_swbd; 161 162 msg_swbd.size = ALIGN(sizeof(struct enetc_msg_generic), 163 ENETC_MSG_ALIGN); 164 msg_swbd.vaddr = dma_alloc_coherent(dev, msg_swbd.size, 165 &msg_swbd.dma, GFP_KERNEL); 166 if (!msg_swbd.vaddr) 167 return -ENOMEM; 168 169 enetc_msg_fill_common_hdr(&msg_swbd, ENETC_MSG_CLASS_ID_IP_REVISION, 170 ENETC_MSG_GET_IP_MN, 0, 0); 171 172 return enetc_msg_vsi_send(si, &msg_swbd); 173 } 174 175 static int enetc_vf_set_mac_addr(struct net_device *ndev, void *addr) 176 { 177 struct enetc_ndev_priv *priv = netdev_priv(ndev); 178 struct sockaddr *saddr = addr; 179 int err; 180 181 if (!is_valid_ether_addr(saddr->sa_data)) 182 return -EADDRNOTAVAIL; 183 184 err = enetc_msg_vsi_set_primary_mac_addr(priv, saddr); 185 if (err) 186 return err; 187 188 eth_hw_addr_set(ndev, saddr->sa_data); 189 190 return 0; 191 } 192 193 static int enetc_vf_set_features(struct net_device *ndev, 194 netdev_features_t features) 195 { 196 enetc_set_features(ndev, features); 197 198 return 0; 199 } 200 201 static int enetc_vf_setup_tc(struct net_device *ndev, enum tc_setup_type type, 202 void *type_data) 203 { 204 switch (type) { 205 case TC_SETUP_QDISC_MQPRIO: 206 return enetc_setup_tc_mqprio(ndev, type_data); 207 default: 208 return -EOPNOTSUPP; 209 } 210 } 211 212 /* Probing/ Init */ 213 static const struct net_device_ops enetc_ndev_ops = { 214 .ndo_open = enetc_open, 215 .ndo_stop = enetc_close, 216 .ndo_start_xmit = enetc_xmit, 217 .ndo_get_stats = enetc_get_stats, 218 .ndo_set_mac_address = enetc_vf_set_mac_addr, 219 .ndo_set_features = enetc_vf_set_features, 220 .ndo_eth_ioctl = enetc_ioctl, 221 .ndo_setup_tc = enetc_vf_setup_tc, 222 .ndo_hwtstamp_get = enetc_hwtstamp_get, 223 .ndo_hwtstamp_set = enetc_hwtstamp_set, 224 }; 225 226 static void enetc_vf_get_revision(struct enetc_si *si) 227 { 228 int ip_mn; 229 230 if (is_enetc_rev1(si)) { 231 si->revision = ENETC_REV_1_0; 232 return; 233 } 234 235 ip_mn = enetc_vf_get_ip_minor_revision(si); 236 if (ip_mn >= 0) { 237 si->revision = (si->pdev->revision << 8) | ip_mn; 238 return; 239 } 240 241 si->revision = ENETC_REV_4_1; 242 dev_info(&si->pdev->dev, 243 "Failed to get revision, use compatible revision: 0x%04x\n", 244 si->revision); 245 } 246 247 static void enetc_vf_netdev_setup(struct enetc_si *si, struct net_device *ndev, 248 const struct net_device_ops *ndev_ops) 249 { 250 struct enetc_ndev_priv *priv = netdev_priv(ndev); 251 252 SET_NETDEV_DEV(ndev, &si->pdev->dev); 253 priv->ndev = ndev; 254 priv->si = si; 255 priv->dev = &si->pdev->dev; 256 si->ndev = ndev; 257 258 priv->msg_enable = (NETIF_MSG_IFUP << 1) - 1; 259 priv->sysclk_freq = si->drvdata->sysclk_freq; 260 priv->max_frags = si->drvdata->max_frags; 261 ndev->netdev_ops = ndev_ops; 262 enetc_set_ethtool_ops(ndev); 263 ndev->watchdog_timeo = 5 * HZ; 264 ndev->max_mtu = ENETC_MAX_MTU; 265 266 ndev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM | 267 NETIF_F_HW_VLAN_CTAG_TX | 268 NETIF_F_HW_VLAN_CTAG_RX | 269 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 | 270 NETIF_F_GSO_UDP_L4; 271 ndev->features = NETIF_F_HIGHDMA | NETIF_F_SG | NETIF_F_RXCSUM | 272 NETIF_F_HW_VLAN_CTAG_TX | 273 NETIF_F_HW_VLAN_CTAG_RX | 274 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 | 275 NETIF_F_GSO_UDP_L4; 276 ndev->vlan_features = NETIF_F_SG | NETIF_F_HW_CSUM | 277 NETIF_F_TSO | NETIF_F_TSO6; 278 279 if (si->num_rss) { 280 ndev->hw_features |= NETIF_F_RXHASH; 281 ndev->features |= NETIF_F_RXHASH; 282 } 283 284 /* pick up primary MAC address from SI */ 285 enetc_load_primary_mac_addr(&si->hw, ndev); 286 } 287 288 static const struct enetc_si_ops enetc_vsi_ops = { 289 .get_rss_table = enetc_get_rss_table, 290 .set_rss_table = enetc_set_rss_table, 291 .setup_cbdr = enetc_setup_cbdr, 292 .teardown_cbdr = enetc_teardown_cbdr, 293 }; 294 295 static int enetc_vf_probe(struct pci_dev *pdev, 296 const struct pci_device_id *ent) 297 { 298 struct enetc_ndev_priv *priv; 299 struct enetc_msg_swbd msg; 300 struct net_device *ndev; 301 struct enetc_si *si; 302 int err; 303 304 err = enetc_pci_probe(pdev, KBUILD_MODNAME, 0); 305 if (err) 306 return dev_err_probe(&pdev->dev, err, "PCI probing failed\n"); 307 308 si = pci_get_drvdata(pdev); 309 enetc_vf_get_revision(si); 310 si->ops = &enetc_vsi_ops; 311 err = enetc_get_driver_data(si); 312 if (err) { 313 dev_err_probe(&pdev->dev, err, 314 "Could not get VF driver data\n"); 315 goto err_get_driver_data; 316 } 317 318 enetc_get_si_caps(si); 319 320 ndev = alloc_etherdev_mq(sizeof(*priv), ENETC_MAX_NUM_TXQS); 321 if (!ndev) { 322 err = -ENOMEM; 323 dev_err(&pdev->dev, "netdev creation failed\n"); 324 goto err_alloc_netdev; 325 } 326 327 enetc_vf_netdev_setup(si, ndev, &enetc_ndev_ops); 328 329 priv = netdev_priv(ndev); 330 331 enetc_init_si_rings_params(priv); 332 333 err = si->ops->setup_cbdr(si); 334 if (err) 335 goto err_setup_cbdr; 336 337 err = enetc_alloc_si_resources(priv); 338 if (err) { 339 dev_err(&pdev->dev, "SI resource alloc failed\n"); 340 goto err_alloc_si_res; 341 } 342 343 err = enetc_configure_si(priv); 344 if (err) { 345 dev_err(&pdev->dev, "Failed to configure SI\n"); 346 goto err_config_si; 347 } 348 349 err = enetc_alloc_msix(priv); 350 if (err) { 351 dev_err(&pdev->dev, "MSIX alloc failed\n"); 352 goto err_alloc_msix; 353 } 354 355 err = register_netdev(ndev); 356 if (err) 357 goto err_reg_netdev; 358 359 netif_carrier_off(ndev); 360 361 return 0; 362 363 err_reg_netdev: 364 enetc_free_msix(priv); 365 err_config_si: 366 err_alloc_msix: 367 enetc_free_si_resources(priv); 368 err_alloc_si_res: 369 si->ops->teardown_cbdr(si); 370 err_setup_cbdr: 371 si->ndev = NULL; 372 free_netdev(ndev); 373 err_alloc_netdev: 374 err_get_driver_data: 375 msg = si->msg; 376 enetc_pci_remove(pdev); 377 enetc_msg_dma_free(&pdev->dev, &msg); 378 379 return err; 380 } 381 382 static void enetc_vf_remove(struct pci_dev *pdev) 383 { 384 struct enetc_si *si = pci_get_drvdata(pdev); 385 struct enetc_ndev_priv *priv; 386 struct enetc_msg_swbd msg; 387 388 priv = netdev_priv(si->ndev); 389 unregister_netdev(si->ndev); 390 391 enetc_free_msix(priv); 392 393 enetc_free_si_resources(priv); 394 si->ops->teardown_cbdr(si); 395 396 free_netdev(si->ndev); 397 398 msg = si->msg; 399 enetc_pci_remove(pdev); 400 enetc_msg_dma_free(&pdev->dev, &msg); 401 } 402 403 static const struct pci_device_id enetc_vf_id_table[] = { 404 { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, ENETC_DEV_ID_VF) }, 405 { 0, } /* End of table. */ 406 }; 407 MODULE_DEVICE_TABLE(pci, enetc_vf_id_table); 408 409 static struct pci_driver enetc_vf_driver = { 410 .name = KBUILD_MODNAME, 411 .id_table = enetc_vf_id_table, 412 .probe = enetc_vf_probe, 413 .remove = enetc_vf_remove, 414 }; 415 module_pci_driver(enetc_vf_driver); 416 417 MODULE_DESCRIPTION(ENETC_DRV_NAME_STR); 418 MODULE_LICENSE("Dual BSD/GPL"); 419