enetc_vf.c

  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	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
 95static 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
103static 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 */
115static 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
128static 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
169static 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
174static 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
242err_reg_netdev:
243	enetc_free_msix(priv);
244err_config_si:
245err_alloc_msix:
246	enetc_free_si_resources(priv);
247err_alloc_si_res:
248	enetc_teardown_cbdr(&si->cbd_ring);
249err_setup_cbdr:
250	si->ndev = NULL;
251	free_netdev(ndev);
252err_alloc_netdev:
253	enetc_pci_remove(pdev);
254
255	return err;
256}
257
258static 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
276static 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};
280MODULE_DEVICE_TABLE(pci, enetc_vf_id_table);
281
282static 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};
288module_pci_driver(enetc_vf_driver);
289
290MODULE_DESCRIPTION(ENETC_DRV_NAME_STR);
291MODULE_LICENSE("Dual BSD/GPL");