1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2024, Intel Corporation. */ 3 #include "ice.h" 4 #include "ice_lib.h" 5 #include "ice_txrx.h" 6 #include "ice_fltr.h" 7 #include "ice_sf_eth.h" 8 #include "devlink/devlink_port.h" 9 #include "devlink/devlink.h" 10 11 static const struct net_device_ops ice_sf_netdev_ops = { 12 .ndo_open = ice_open, 13 .ndo_stop = ice_stop, 14 .ndo_start_xmit = ice_start_xmit, 15 .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid, 16 .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid, 17 .ndo_change_mtu = ice_change_mtu, 18 .ndo_get_stats64 = ice_get_stats64, 19 .ndo_tx_timeout = ice_tx_timeout, 20 .ndo_bpf = ice_xdp, 21 .ndo_xdp_xmit = ice_xdp_xmit, 22 .ndo_xsk_wakeup = ice_xsk_wakeup, 23 }; 24 25 /** 26 * ice_sf_cfg_netdev - Allocate, configure and register a netdev 27 * @dyn_port: subfunction associated with configured netdev 28 * @devlink_port: subfunction devlink port to be linked with netdev 29 * 30 * Return: 0 on success, negative value on failure 31 */ 32 static int ice_sf_cfg_netdev(struct ice_dynamic_port *dyn_port, 33 struct devlink_port *devlink_port) 34 { 35 struct ice_vsi *vsi = dyn_port->vsi; 36 struct ice_netdev_priv *np; 37 struct net_device *netdev; 38 int err; 39 40 netdev = alloc_etherdev_mqs(sizeof(*np), vsi->alloc_txq, 41 vsi->alloc_rxq); 42 if (!netdev) 43 return -ENOMEM; 44 45 SET_NETDEV_DEV(netdev, &vsi->back->pdev->dev); 46 set_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 47 vsi->netdev = netdev; 48 np = netdev_priv(netdev); 49 np->vsi = vsi; 50 51 ice_set_netdev_features(netdev); 52 53 netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 54 NETDEV_XDP_ACT_XSK_ZEROCOPY | 55 NETDEV_XDP_ACT_RX_SG; 56 netdev->xdp_zc_max_segs = ICE_MAX_BUF_TXD; 57 58 eth_hw_addr_set(netdev, dyn_port->hw_addr); 59 ether_addr_copy(netdev->perm_addr, dyn_port->hw_addr); 60 netdev->netdev_ops = &ice_sf_netdev_ops; 61 SET_NETDEV_DEVLINK_PORT(netdev, devlink_port); 62 63 err = register_netdev(netdev); 64 if (err) { 65 free_netdev(netdev); 66 vsi->netdev = NULL; 67 return -ENOMEM; 68 } 69 set_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 70 netif_carrier_off(netdev); 71 netif_tx_stop_all_queues(netdev); 72 73 return 0; 74 } 75 76 static void ice_sf_decfg_netdev(struct ice_vsi *vsi) 77 { 78 unregister_netdev(vsi->netdev); 79 clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 80 free_netdev(vsi->netdev); 81 vsi->netdev = NULL; 82 clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 83 } 84 85 /** 86 * ice_sf_dev_probe - subfunction driver probe function 87 * @adev: pointer to the auxiliary device 88 * @id: pointer to the auxiliary_device id 89 * 90 * Configure VSI and netdev resources for the subfunction device. 91 * 92 * Return: zero on success or an error code on failure. 93 */ 94 static int ice_sf_dev_probe(struct auxiliary_device *adev, 95 const struct auxiliary_device_id *id) 96 { 97 struct ice_sf_dev *sf_dev = ice_adev_to_sf_dev(adev); 98 struct ice_dynamic_port *dyn_port = sf_dev->dyn_port; 99 struct ice_vsi *vsi = dyn_port->vsi; 100 struct ice_pf *pf = dyn_port->pf; 101 struct device *dev = &adev->dev; 102 struct ice_sf_priv *priv; 103 struct devlink *devlink; 104 int err; 105 106 vsi->type = ICE_VSI_SF; 107 vsi->port_info = pf->hw.port_info; 108 vsi->flags = ICE_VSI_FLAG_INIT; 109 110 priv = ice_allocate_sf(&adev->dev, pf); 111 if (!priv) { 112 dev_err(dev, "Subfunction devlink alloc failed"); 113 return -ENOMEM; 114 } 115 116 priv->dev = sf_dev; 117 sf_dev->priv = priv; 118 devlink = priv_to_devlink(priv); 119 120 devl_lock(devlink); 121 122 err = ice_vsi_cfg(vsi); 123 if (err) { 124 dev_err(dev, "Subfunction vsi config failed"); 125 goto err_free_devlink; 126 } 127 vsi->sf = dyn_port; 128 129 ice_eswitch_update_repr(&dyn_port->repr_id, vsi); 130 131 err = ice_devlink_create_sf_dev_port(sf_dev); 132 if (err) { 133 dev_err(dev, "Cannot add ice virtual devlink port for subfunction"); 134 goto err_vsi_decfg; 135 } 136 137 err = ice_sf_cfg_netdev(dyn_port, &sf_dev->priv->devlink_port); 138 if (err) { 139 dev_err(dev, "Subfunction netdev config failed"); 140 goto err_devlink_destroy; 141 } 142 143 err = devl_port_fn_devlink_set(&dyn_port->devlink_port, devlink); 144 if (err) { 145 dev_err(dev, "Can't link devlink instance to SF devlink port"); 146 goto err_netdev_decfg; 147 } 148 149 ice_napi_add(vsi); 150 151 devl_register(devlink); 152 devl_unlock(devlink); 153 154 return 0; 155 156 err_netdev_decfg: 157 ice_sf_decfg_netdev(vsi); 158 err_devlink_destroy: 159 ice_devlink_destroy_sf_dev_port(sf_dev); 160 err_vsi_decfg: 161 ice_vsi_decfg(vsi); 162 err_free_devlink: 163 devl_unlock(devlink); 164 devlink_free(devlink); 165 return err; 166 } 167 168 /** 169 * ice_sf_dev_remove - subfunction driver remove function 170 * @adev: pointer to the auxiliary device 171 * 172 * Deinitalize VSI and netdev resources for the subfunction device. 173 */ 174 static void ice_sf_dev_remove(struct auxiliary_device *adev) 175 { 176 struct ice_sf_dev *sf_dev = ice_adev_to_sf_dev(adev); 177 struct ice_dynamic_port *dyn_port = sf_dev->dyn_port; 178 struct ice_vsi *vsi = dyn_port->vsi; 179 struct devlink *devlink; 180 181 devlink = priv_to_devlink(sf_dev->priv); 182 devl_lock(devlink); 183 184 ice_vsi_close(vsi); 185 186 ice_sf_decfg_netdev(vsi); 187 ice_devlink_destroy_sf_dev_port(sf_dev); 188 devl_unregister(devlink); 189 devl_unlock(devlink); 190 devlink_free(devlink); 191 ice_vsi_decfg(vsi); 192 } 193 194 static const struct auxiliary_device_id ice_sf_dev_id_table[] = { 195 { .name = "ice.sf", }, 196 { }, 197 }; 198 199 MODULE_DEVICE_TABLE(auxiliary, ice_sf_dev_id_table); 200 201 static struct auxiliary_driver ice_sf_driver = { 202 .name = "sf", 203 .probe = ice_sf_dev_probe, 204 .remove = ice_sf_dev_remove, 205 .id_table = ice_sf_dev_id_table 206 }; 207 208 /** 209 * ice_sf_driver_register - Register new auxiliary subfunction driver 210 * 211 * Return: zero on success or an error code on failure. 212 */ 213 int ice_sf_driver_register(void) 214 { 215 return auxiliary_driver_register(&ice_sf_driver); 216 } 217 218 /** 219 * ice_sf_driver_unregister - Unregister new auxiliary subfunction driver 220 * 221 */ 222 void ice_sf_driver_unregister(void) 223 { 224 auxiliary_driver_unregister(&ice_sf_driver); 225 } 226