1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Copyright (c) 2014-2015 Hisilicon Limited.
   4 */
   5
   6#include <linux/clk.h>
   7#include <linux/cpumask.h>
   8#include <linux/etherdevice.h>
   9#include <linux/if_vlan.h>
  10#include <linux/interrupt.h>
  11#include <linux/io.h>
  12#include <linux/ip.h>
  13#include <linux/ipv6.h>
  14#include <linux/irq.h>
  15#include <linux/module.h>
  16#include <linux/phy.h>
  17#include <linux/platform_device.h>
  18#include <linux/skbuff.h>
  19
  20#include "hnae.h"
  21#include "hns_enet.h"
  22#include "hns_dsaf_mac.h"
  23
  24#define NIC_MAX_Q_PER_VF 16
  25#define HNS_NIC_TX_TIMEOUT (5 * HZ)
  26
  27#define SERVICE_TIMER_HZ (1 * HZ)
  28
  29#define RCB_IRQ_NOT_INITED 0
  30#define RCB_IRQ_INITED 1
  31#define HNS_BUFFER_SIZE_2048 2048
  32
  33#define BD_MAX_SEND_SIZE 8191
 
 
  34
  35static void fill_v2_desc_hw(struct hnae_ring *ring, void *priv, int size,
  36			    int send_sz, dma_addr_t dma, int frag_end,
  37			    int buf_num, enum hns_desc_type type, int mtu)
  38{
  39	struct hnae_desc *desc = &ring->desc[ring->next_to_use];
  40	struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_use];
  41	struct iphdr *iphdr;
  42	struct ipv6hdr *ipv6hdr;
  43	struct sk_buff *skb;
  44	__be16 protocol;
  45	u8 bn_pid = 0;
  46	u8 rrcfv = 0;
  47	u8 ip_offset = 0;
  48	u8 tvsvsn = 0;
  49	u16 mss = 0;
  50	u8 l4_len = 0;
  51	u16 paylen = 0;
  52
  53	desc_cb->priv = priv;
  54	desc_cb->length = size;
  55	desc_cb->dma = dma;
  56	desc_cb->type = type;
  57
  58	desc->addr = cpu_to_le64(dma);
  59	desc->tx.send_size = cpu_to_le16((u16)send_sz);
  60
  61	/* config bd buffer end */
  62	hnae_set_bit(rrcfv, HNSV2_TXD_VLD_B, 1);
  63	hnae_set_field(bn_pid, HNSV2_TXD_BUFNUM_M, 0, buf_num - 1);
  64
  65	/* fill port_id in the tx bd for sending management pkts */
  66	hnae_set_field(bn_pid, HNSV2_TXD_PORTID_M,
  67		       HNSV2_TXD_PORTID_S, ring->q->handle->dport_id);
  68
  69	if (type == DESC_TYPE_SKB) {
  70		skb = (struct sk_buff *)priv;
  71
  72		if (skb->ip_summed == CHECKSUM_PARTIAL) {
  73			skb_reset_mac_len(skb);
  74			protocol = skb->protocol;
  75			ip_offset = ETH_HLEN;
  76
  77			if (protocol == htons(ETH_P_8021Q)) {
  78				ip_offset += VLAN_HLEN;
  79				protocol = vlan_get_protocol(skb);
  80				skb->protocol = protocol;
  81			}
  82
  83			if (skb->protocol == htons(ETH_P_IP)) {
  84				iphdr = ip_hdr(skb);
  85				hnae_set_bit(rrcfv, HNSV2_TXD_L3CS_B, 1);
  86				hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1);
  87
  88				/* check for tcp/udp header */
  89				if (iphdr->protocol == IPPROTO_TCP &&
  90				    skb_is_gso(skb)) {
  91					hnae_set_bit(tvsvsn,
  92						     HNSV2_TXD_TSE_B, 1);
  93					l4_len = tcp_hdrlen(skb);
  94					mss = skb_shinfo(skb)->gso_size;
  95					paylen = skb->len - skb_tcp_all_headers(skb);
  96				}
  97			} else if (skb->protocol == htons(ETH_P_IPV6)) {
  98				hnae_set_bit(tvsvsn, HNSV2_TXD_IPV6_B, 1);
  99				ipv6hdr = ipv6_hdr(skb);
 100				hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1);
 101
 102				/* check for tcp/udp header */
 103				if (ipv6hdr->nexthdr == IPPROTO_TCP &&
 104				    skb_is_gso(skb) && skb_is_gso_v6(skb)) {
 105					hnae_set_bit(tvsvsn,
 106						     HNSV2_TXD_TSE_B, 1);
 107					l4_len = tcp_hdrlen(skb);
 108					mss = skb_shinfo(skb)->gso_size;
 109					paylen = skb->len - skb_tcp_all_headers(skb);
 110				}
 111			}
 112			desc->tx.ip_offset = ip_offset;
 113			desc->tx.tse_vlan_snap_v6_sctp_nth = tvsvsn;
 114			desc->tx.mss = cpu_to_le16(mss);
 115			desc->tx.l4_len = l4_len;
 116			desc->tx.paylen = cpu_to_le16(paylen);
 117		}
 118	}
 119
 120	hnae_set_bit(rrcfv, HNSV2_TXD_FE_B, frag_end);
 121
 122	desc->tx.bn_pid = bn_pid;
 123	desc->tx.ra_ri_cs_fe_vld = rrcfv;
 124
 125	ring_ptr_move_fw(ring, next_to_use);
 126}
 127
 128static void fill_v2_desc(struct hnae_ring *ring, void *priv,
 129			 int size, dma_addr_t dma, int frag_end,
 130			 int buf_num, enum hns_desc_type type, int mtu)
 131{
 132	fill_v2_desc_hw(ring, priv, size, size, dma, frag_end,
 133			buf_num, type, mtu);
 134}
 135
 136static const struct acpi_device_id hns_enet_acpi_match[] = {
 137	{ "HISI00C1", 0 },
 138	{ "HISI00C2", 0 },
 139	{ },
 140};
 141MODULE_DEVICE_TABLE(acpi, hns_enet_acpi_match);
 142
 143static void fill_desc(struct hnae_ring *ring, void *priv,
 144		      int size, dma_addr_t dma, int frag_end,
 145		      int buf_num, enum hns_desc_type type, int mtu,
 146		      bool is_gso)
 147{
 148	struct hnae_desc *desc = &ring->desc[ring->next_to_use];
 149	struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_use];
 150	struct sk_buff *skb;
 151	__be16 protocol;
 152	u32 ip_offset;
 153	u32 asid_bufnum_pid = 0;
 154	u32 flag_ipoffset = 0;
 155
 156	desc_cb->priv = priv;
 157	desc_cb->length = size;
 158	desc_cb->dma = dma;
 159	desc_cb->type = type;
 160
 161	desc->addr = cpu_to_le64(dma);
 162	desc->tx.send_size = cpu_to_le16((u16)size);
 163
 164	/*config bd buffer end */
 165	flag_ipoffset |= 1 << HNS_TXD_VLD_B;
 166
 167	asid_bufnum_pid |= buf_num << HNS_TXD_BUFNUM_S;
 168
 169	if (type == DESC_TYPE_SKB) {
 170		skb = (struct sk_buff *)priv;
 171
 172		if (skb->ip_summed == CHECKSUM_PARTIAL) {
 173			protocol = skb->protocol;
 174			ip_offset = ETH_HLEN;
 175
 176			/*if it is a SW VLAN check the next protocol*/
 177			if (protocol == htons(ETH_P_8021Q)) {
 178				ip_offset += VLAN_HLEN;
 179				protocol = vlan_get_protocol(skb);
 180				skb->protocol = protocol;
 181			}
 182
 183			if (skb->protocol == htons(ETH_P_IP)) {
 184				flag_ipoffset |= 1 << HNS_TXD_L3CS_B;
 185				/* check for tcp/udp header */
 186				flag_ipoffset |= 1 << HNS_TXD_L4CS_B;
 187
 188			} else if (skb->protocol == htons(ETH_P_IPV6)) {
 189				/* ipv6 has not l3 cs, check for L4 header */
 190				flag_ipoffset |= 1 << HNS_TXD_L4CS_B;
 191			}
 192
 193			flag_ipoffset |= ip_offset << HNS_TXD_IPOFFSET_S;
 194		}
 195	}
 196
 197	flag_ipoffset |= frag_end << HNS_TXD_FE_B;
 198
 199	desc->tx.asid_bufnum_pid = cpu_to_le16(asid_bufnum_pid);
 200	desc->tx.flag_ipoffset = cpu_to_le32(flag_ipoffset);
 201
 202	ring_ptr_move_fw(ring, next_to_use);
 203}
 204
 205static void unfill_desc(struct hnae_ring *ring)
 206{
 207	ring_ptr_move_bw(ring, next_to_use);
 208}
 209
 210static int hns_nic_maybe_stop_tx(
 211	struct sk_buff **out_skb, int *bnum, struct hnae_ring *ring)
 212{
 213	struct sk_buff *skb = *out_skb;
 214	struct sk_buff *new_skb = NULL;
 215	int buf_num;
 216
 217	/* no. of segments (plus a header) */
 218	buf_num = skb_shinfo(skb)->nr_frags + 1;
 219
 220	if (unlikely(buf_num > ring->max_desc_num_per_pkt)) {
 221		if (ring_space(ring) < 1)
 222			return -EBUSY;
 223
 224		new_skb = skb_copy(skb, GFP_ATOMIC);
 225		if (!new_skb)
 226			return -ENOMEM;
 227
 228		dev_kfree_skb_any(skb);
 229		*out_skb = new_skb;
 230		buf_num = 1;
 231	} else if (buf_num > ring_space(ring)) {
 232		return -EBUSY;
 233	}
 234
 235	*bnum = buf_num;
 236	return 0;
 237}
 238
 239static int hns_nic_maybe_stop_tso(
 240	struct sk_buff **out_skb, int *bnum, struct hnae_ring *ring)
 241{
 242	int i;
 243	int size;
 244	int buf_num;
 245	int frag_num;
 246	struct sk_buff *skb = *out_skb;
 247	struct sk_buff *new_skb = NULL;
 248	skb_frag_t *frag;
 249
 250	size = skb_headlen(skb);
 251	buf_num = (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE;
 252
 253	frag_num = skb_shinfo(skb)->nr_frags;
 254	for (i = 0; i < frag_num; i++) {
 255		frag = &skb_shinfo(skb)->frags[i];
 256		size = skb_frag_size(frag);
 257		buf_num += (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE;
 258	}
 259
 260	if (unlikely(buf_num > ring->max_desc_num_per_pkt)) {
 261		buf_num = (skb->len + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE;
 262		if (ring_space(ring) < buf_num)
 263			return -EBUSY;
 264		/* manual split the send packet */
 265		new_skb = skb_copy(skb, GFP_ATOMIC);
 266		if (!new_skb)
 267			return -ENOMEM;
 268		dev_kfree_skb_any(skb);
 269		*out_skb = new_skb;
 270
 271	} else if (ring_space(ring) < buf_num) {
 272		return -EBUSY;
 273	}
 274
 275	*bnum = buf_num;
 276	return 0;
 277}
 278
 279static int hns_nic_maybe_stop_tx_v2(struct sk_buff **out_skb, int *bnum,
 280				    struct hnae_ring *ring)
 281{
 282	if (skb_is_gso(*out_skb))
 283		return hns_nic_maybe_stop_tso(out_skb, bnum, ring);
 284	else
 285		return hns_nic_maybe_stop_tx(out_skb, bnum, ring);
 286}
 287
 288static void fill_tso_desc(struct hnae_ring *ring, void *priv,
 289			  int size, dma_addr_t dma, int frag_end,
 290			  int buf_num, enum hns_desc_type type, int mtu)
 291{
 292	int frag_buf_num;
 293	int sizeoflast;
 294	int k;
 295
 296	frag_buf_num = (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE;
 297	sizeoflast = size % BD_MAX_SEND_SIZE;
 298	sizeoflast = sizeoflast ? sizeoflast : BD_MAX_SEND_SIZE;
 299
 300	/* when the frag size is bigger than hardware, split this frag */
 301	for (k = 0; k < frag_buf_num; k++)
 302		fill_v2_desc_hw(ring, priv, k == 0 ? size : 0,
 303				(k == frag_buf_num - 1) ?
 304					sizeoflast : BD_MAX_SEND_SIZE,
 305				dma + BD_MAX_SEND_SIZE * k,
 306				frag_end && (k == frag_buf_num - 1) ? 1 : 0,
 307				buf_num,
 308				(type == DESC_TYPE_SKB && !k) ?
 309					DESC_TYPE_SKB : DESC_TYPE_PAGE,
 310				mtu);
 311}
 312
 313static void fill_desc_v2(struct hnae_ring *ring, void *priv,
 314			 int size, dma_addr_t dma, int frag_end,
 315			 int buf_num, enum hns_desc_type type, int mtu,
 316			 bool is_gso)
 317{
 318	if (is_gso)
 319		fill_tso_desc(ring, priv, size, dma, frag_end, buf_num, type,
 320			      mtu);
 321	else
 322		fill_v2_desc(ring, priv, size, dma, frag_end, buf_num, type,
 323			     mtu);
 324}
 325
 326netdev_tx_t hns_nic_net_xmit_hw(struct net_device *ndev,
 327				struct sk_buff *skb,
 328				struct hns_nic_ring_data *ring_data)
 329{
 330	struct hns_nic_priv *priv = netdev_priv(ndev);
 331	struct hnae_ring *ring = ring_data->ring;
 332	struct device *dev = ring_to_dev(ring);
 333	struct netdev_queue *dev_queue;
 334	skb_frag_t *frag;
 335	int buf_num;
 336	int seg_num;
 337	dma_addr_t dma;
 338	int size, next_to_use;
 339	bool is_gso;
 340	int i;
 341
 342	switch (priv->ops.maybe_stop_tx(&skb, &buf_num, ring)) {
 343	case -EBUSY:
 344		ring->stats.tx_busy++;
 345		goto out_net_tx_busy;
 346	case -ENOMEM:
 347		ring->stats.sw_err_cnt++;
 348		netdev_err(ndev, "no memory to xmit!\n");
 349		goto out_err_tx_ok;
 350	default:
 351		break;
 352	}
 353
 354	/* no. of segments (plus a header) */
 355	seg_num = skb_shinfo(skb)->nr_frags + 1;
 356	next_to_use = ring->next_to_use;
 357
 358	/* fill the first part */
 359	size = skb_headlen(skb);
 360	dma = dma_map_single(dev, skb->data, size, DMA_TO_DEVICE);
 361	if (dma_mapping_error(dev, dma)) {
 362		netdev_err(ndev, "TX head DMA map failed\n");
 363		ring->stats.sw_err_cnt++;
 364		goto out_err_tx_ok;
 365	}
 366	is_gso = skb_is_gso(skb);
 367	priv->ops.fill_desc(ring, skb, size, dma, seg_num == 1 ? 1 : 0,
 368			    buf_num, DESC_TYPE_SKB, ndev->mtu, is_gso);
 369
 370	/* fill the fragments */
 371	for (i = 1; i < seg_num; i++) {
 372		frag = &skb_shinfo(skb)->frags[i - 1];
 373		size = skb_frag_size(frag);
 374		dma = skb_frag_dma_map(dev, frag, 0, size, DMA_TO_DEVICE);
 375		if (dma_mapping_error(dev, dma)) {
 376			netdev_err(ndev, "TX frag(%d) DMA map failed\n", i);
 377			ring->stats.sw_err_cnt++;
 378			goto out_map_frag_fail;
 379		}
 380		priv->ops.fill_desc(ring, skb_frag_page(frag), size, dma,
 381				    seg_num - 1 == i ? 1 : 0, buf_num,
 382				    DESC_TYPE_PAGE, ndev->mtu, is_gso);
 383	}
 384
 385	/*complete translate all packets*/
 386	dev_queue = netdev_get_tx_queue(ndev, skb->queue_mapping);
 387	netdev_tx_sent_queue(dev_queue, skb->len);
 388
 389	netif_trans_update(ndev);
 390	ndev->stats.tx_bytes += skb->len;
 391	ndev->stats.tx_packets++;
 392
 393	wmb(); /* commit all data before submit */
 394	assert(skb->queue_mapping < priv->ae_handle->q_num);
 395	hnae_queue_xmit(priv->ae_handle->qs[skb->queue_mapping], buf_num);
 396
 397	return NETDEV_TX_OK;
 398
 399out_map_frag_fail:
 400
 401	while (ring->next_to_use != next_to_use) {
 402		unfill_desc(ring);
 403		if (ring->next_to_use != next_to_use)
 404			dma_unmap_page(dev,
 405				       ring->desc_cb[ring->next_to_use].dma,
 406				       ring->desc_cb[ring->next_to_use].length,
 407				       DMA_TO_DEVICE);
 408		else
 409			dma_unmap_single(dev,
 410					 ring->desc_cb[next_to_use].dma,
 411					 ring->desc_cb[next_to_use].length,
 412					 DMA_TO_DEVICE);
 413	}
 414
 415out_err_tx_ok:
 416
 417	dev_kfree_skb_any(skb);
 418	return NETDEV_TX_OK;
 419
 420out_net_tx_busy:
 421
 422	netif_stop_subqueue(ndev, skb->queue_mapping);
 423
 424	/* Herbert's original patch had:
 425	 *  smp_mb__after_netif_stop_queue();
 426	 * but since that doesn't exist yet, just open code it.
 427	 */
 428	smp_mb();
 429	return NETDEV_TX_BUSY;
 430}
 431
 432static void hns_nic_reuse_page(struct sk_buff *skb, int i,
 433			       struct hnae_ring *ring, int pull_len,
 434			       struct hnae_desc_cb *desc_cb)
 435{
 436	struct hnae_desc *desc;
 437	u32 truesize;
 438	int size;
 439	int last_offset;
 440	bool twobufs;
 441
 442	twobufs = ((PAGE_SIZE < 8192) &&
 443		hnae_buf_size(ring) == HNS_BUFFER_SIZE_2048);
 444
 445	desc = &ring->desc[ring->next_to_clean];
 446	size = le16_to_cpu(desc->rx.size);
 447
 448	if (twobufs) {
 449		truesize = hnae_buf_size(ring);
 450	} else {
 451		truesize = ALIGN(size, L1_CACHE_BYTES);
 452		last_offset = hnae_page_size(ring) - hnae_buf_size(ring);
 453	}
 454
 455	skb_add_rx_frag(skb, i, desc_cb->priv, desc_cb->page_offset + pull_len,
 456			size - pull_len, truesize);
 457
 458	 /* avoid re-using remote pages,flag default unreuse */
 459	if (unlikely(page_to_nid(desc_cb->priv) != numa_node_id()))
 460		return;
 461
 462	if (twobufs) {
 463		/* if we are only owner of page we can reuse it */
 464		if (likely(page_count(desc_cb->priv) == 1)) {
 465			/* flip page offset to other buffer */
 466			desc_cb->page_offset ^= truesize;
 467
 468			desc_cb->reuse_flag = 1;
 469			/* bump ref count on page before it is given*/
 470			get_page(desc_cb->priv);
 471		}
 472		return;
 473	}
 474
 475	/* move offset up to the next cache line */
 476	desc_cb->page_offset += truesize;
 477
 478	if (desc_cb->page_offset <= last_offset) {
 479		desc_cb->reuse_flag = 1;
 480		/* bump ref count on page before it is given*/
 481		get_page(desc_cb->priv);
 482	}
 483}
 484
 485static void get_v2rx_desc_bnum(u32 bnum_flag, int *out_bnum)
 486{
 487	*out_bnum = hnae_get_field(bnum_flag,
 488				   HNS_RXD_BUFNUM_M, HNS_RXD_BUFNUM_S) + 1;
 489}
 490
 491static void get_rx_desc_bnum(u32 bnum_flag, int *out_bnum)
 492{
 493	*out_bnum = hnae_get_field(bnum_flag,
 494				   HNS_RXD_BUFNUM_M, HNS_RXD_BUFNUM_S);
 495}
 496
 497static void hns_nic_rx_checksum(struct hns_nic_ring_data *ring_data,
 498				struct sk_buff *skb, u32 flag)
 499{
 500	struct net_device *netdev = ring_data->napi.dev;
 501	u32 l3id;
 502	u32 l4id;
 503
 504	/* check if RX checksum offload is enabled */
 505	if (unlikely(!(netdev->features & NETIF_F_RXCSUM)))
 506		return;
 507
 508	/* In hardware, we only support checksum for the following protocols:
 509	 * 1) IPv4,
 510	 * 2) TCP(over IPv4 or IPv6),
 511	 * 3) UDP(over IPv4 or IPv6),
 512	 * 4) SCTP(over IPv4 or IPv6)
 513	 * but we support many L3(IPv4, IPv6, MPLS, PPPoE etc) and L4(TCP,
 514	 * UDP, GRE, SCTP, IGMP, ICMP etc.) protocols.
 515	 *
 516	 * Hardware limitation:
 517	 * Our present hardware RX Descriptor lacks L3/L4 checksum "Status &
 518	 * Error" bit (which usually can be used to indicate whether checksum
 519	 * was calculated by the hardware and if there was any error encountered
 520	 * during checksum calculation).
 521	 *
 522	 * Software workaround:
 523	 * We do get info within the RX descriptor about the kind of L3/L4
 524	 * protocol coming in the packet and the error status. These errors
 525	 * might not just be checksum errors but could be related to version,
 526	 * length of IPv4, UDP, TCP etc.
 527	 * Because there is no-way of knowing if it is a L3/L4 error due to bad
 528	 * checksum or any other L3/L4 error, we will not (cannot) convey
 529	 * checksum status for such cases to upper stack and will not maintain
 530	 * the RX L3/L4 checksum counters as well.
 531	 */
 532
 533	l3id = hnae_get_field(flag, HNS_RXD_L3ID_M, HNS_RXD_L3ID_S);
 534	l4id = hnae_get_field(flag, HNS_RXD_L4ID_M, HNS_RXD_L4ID_S);
 535
 536	/*  check L3 protocol for which checksum is supported */
 537	if ((l3id != HNS_RX_FLAG_L3ID_IPV4) && (l3id != HNS_RX_FLAG_L3ID_IPV6))
 538		return;
 539
 540	/* check for any(not just checksum)flagged L3 protocol errors */
 541	if (unlikely(hnae_get_bit(flag, HNS_RXD_L3E_B)))
 542		return;
 543
 544	/* we do not support checksum of fragmented packets */
 545	if (unlikely(hnae_get_bit(flag, HNS_RXD_FRAG_B)))
 546		return;
 547
 548	/*  check L4 protocol for which checksum is supported */
 549	if ((l4id != HNS_RX_FLAG_L4ID_TCP) &&
 550	    (l4id != HNS_RX_FLAG_L4ID_UDP) &&
 551	    (l4id != HNS_RX_FLAG_L4ID_SCTP))
 552		return;
 553
 554	/* check for any(not just checksum)flagged L4 protocol errors */
 555	if (unlikely(hnae_get_bit(flag, HNS_RXD_L4E_B)))
 556		return;
 557
 558	/* now, this has to be a packet with valid RX checksum */
 559	skb->ip_summed = CHECKSUM_UNNECESSARY;
 560}
 561
 562static int hns_nic_poll_rx_skb(struct hns_nic_ring_data *ring_data,
 563			       struct sk_buff **out_skb, int *out_bnum)
 564{
 565	struct hnae_ring *ring = ring_data->ring;
 566	struct net_device *ndev = ring_data->napi.dev;
 567	struct hns_nic_priv *priv = netdev_priv(ndev);
 568	struct sk_buff *skb;
 569	struct hnae_desc *desc;
 570	struct hnae_desc_cb *desc_cb;
 571	unsigned char *va;
 572	int bnum, length, i;
 573	int pull_len;
 574	u32 bnum_flag;
 575
 576	desc = &ring->desc[ring->next_to_clean];
 577	desc_cb = &ring->desc_cb[ring->next_to_clean];
 578
 579	prefetch(desc);
 580
 581	va = (unsigned char *)desc_cb->buf + desc_cb->page_offset;
 582
 583	/* prefetch first cache line of first page */
 584	net_prefetch(va);
 
 
 
 585
 586	skb = *out_skb = napi_alloc_skb(&ring_data->napi,
 587					HNS_RX_HEAD_SIZE);
 588	if (unlikely(!skb)) {
 589		ring->stats.sw_err_cnt++;
 590		return -ENOMEM;
 591	}
 592
 593	prefetchw(skb->data);
 594	length = le16_to_cpu(desc->rx.pkt_len);
 595	bnum_flag = le32_to_cpu(desc->rx.ipoff_bnum_pid_flag);
 596	priv->ops.get_rxd_bnum(bnum_flag, &bnum);
 597	*out_bnum = bnum;
 598
 599	if (length <= HNS_RX_HEAD_SIZE) {
 600		memcpy(__skb_put(skb, length), va, ALIGN(length, sizeof(long)));
 601
 602		/* we can reuse buffer as-is, just make sure it is local */
 603		if (likely(page_to_nid(desc_cb->priv) == numa_node_id()))
 604			desc_cb->reuse_flag = 1;
 605		else /* this page cannot be reused so discard it */
 606			put_page(desc_cb->priv);
 607
 608		ring_ptr_move_fw(ring, next_to_clean);
 609
 610		if (unlikely(bnum != 1)) { /* check err*/
 611			*out_bnum = 1;
 612			goto out_bnum_err;
 613		}
 614	} else {
 615		ring->stats.seg_pkt_cnt++;
 616
 617		pull_len = eth_get_headlen(ndev, va, HNS_RX_HEAD_SIZE);
 618		memcpy(__skb_put(skb, pull_len), va,
 619		       ALIGN(pull_len, sizeof(long)));
 620
 621		hns_nic_reuse_page(skb, 0, ring, pull_len, desc_cb);
 622		ring_ptr_move_fw(ring, next_to_clean);
 623
 624		if (unlikely(bnum >= (int)MAX_SKB_FRAGS)) { /* check err*/
 625			*out_bnum = 1;
 626			goto out_bnum_err;
 627		}
 628		for (i = 1; i < bnum; i++) {
 629			desc = &ring->desc[ring->next_to_clean];
 630			desc_cb = &ring->desc_cb[ring->next_to_clean];
 631
 632			hns_nic_reuse_page(skb, i, ring, 0, desc_cb);
 633			ring_ptr_move_fw(ring, next_to_clean);
 634		}
 635	}
 636
 637	/* check except process, free skb and jump the desc */
 638	if (unlikely((!bnum) || (bnum > ring->max_desc_num_per_pkt))) {
 639out_bnum_err:
 640		*out_bnum = *out_bnum ? *out_bnum : 1; /* ntc moved,cannot 0*/
 641		netdev_err(ndev, "invalid bnum(%d,%d,%d,%d),%016llx,%016llx\n",
 642			   bnum, ring->max_desc_num_per_pkt,
 643			   length, (int)MAX_SKB_FRAGS,
 644			   ((u64 *)desc)[0], ((u64 *)desc)[1]);
 645		ring->stats.err_bd_num++;
 646		dev_kfree_skb_any(skb);
 647		return -EDOM;
 648	}
 649
 650	bnum_flag = le32_to_cpu(desc->rx.ipoff_bnum_pid_flag);
 651
 652	if (unlikely(!hnae_get_bit(bnum_flag, HNS_RXD_VLD_B))) {
 653		netdev_err(ndev, "no valid bd,%016llx,%016llx\n",
 654			   ((u64 *)desc)[0], ((u64 *)desc)[1]);
 655		ring->stats.non_vld_descs++;
 656		dev_kfree_skb_any(skb);
 657		return -EINVAL;
 658	}
 659
 660	if (unlikely((!desc->rx.pkt_len) ||
 661		     hnae_get_bit(bnum_flag, HNS_RXD_DROP_B))) {
 662		ring->stats.err_pkt_len++;
 663		dev_kfree_skb_any(skb);
 664		return -EFAULT;
 665	}
 666
 667	if (unlikely(hnae_get_bit(bnum_flag, HNS_RXD_L2E_B))) {
 668		ring->stats.l2_err++;
 669		dev_kfree_skb_any(skb);
 670		return -EFAULT;
 671	}
 672
 673	ring->stats.rx_pkts++;
 674	ring->stats.rx_bytes += skb->len;
 675
 676	/* indicate to upper stack if our hardware has already calculated
 677	 * the RX checksum
 678	 */
 679	hns_nic_rx_checksum(ring_data, skb, bnum_flag);
 680
 681	return 0;
 682}
 683
 684static void
 685hns_nic_alloc_rx_buffers(struct hns_nic_ring_data *ring_data, int cleand_count)
 686{
 687	int i, ret;
 688	struct hnae_desc_cb res_cbs;
 689	struct hnae_desc_cb *desc_cb;
 690	struct hnae_ring *ring = ring_data->ring;
 691	struct net_device *ndev = ring_data->napi.dev;
 692
 693	for (i = 0; i < cleand_count; i++) {
 694		desc_cb = &ring->desc_cb[ring->next_to_use];
 695		if (desc_cb->reuse_flag) {
 696			ring->stats.reuse_pg_cnt++;
 697			hnae_reuse_buffer(ring, ring->next_to_use);
 698		} else {
 699			ret = hnae_reserve_buffer_map(ring, &res_cbs);
 700			if (ret) {
 701				ring->stats.sw_err_cnt++;
 702				netdev_err(ndev, "hnae reserve buffer map failed.\n");
 703				break;
 704			}
 705			hnae_replace_buffer(ring, ring->next_to_use, &res_cbs);
 706		}
 707
 708		ring_ptr_move_fw(ring, next_to_use);
 709	}
 710
 711	wmb(); /* make all data has been write before submit */
 712	writel_relaxed(i, ring->io_base + RCB_REG_HEAD);
 713}
 714
 715/* return error number for error or number of desc left to take
 716 */
 717static void hns_nic_rx_up_pro(struct hns_nic_ring_data *ring_data,
 718			      struct sk_buff *skb)
 719{
 720	struct net_device *ndev = ring_data->napi.dev;
 721
 722	skb->protocol = eth_type_trans(skb, ndev);
 723	napi_gro_receive(&ring_data->napi, skb);
 724}
 725
 726static int hns_desc_unused(struct hnae_ring *ring)
 727{
 728	int ntc = ring->next_to_clean;
 729	int ntu = ring->next_to_use;
 730
 731	return ((ntc >= ntu) ? 0 : ring->desc_num) + ntc - ntu;
 732}
 733
 734#define HNS_LOWEST_LATENCY_RATE		27	/* 27 MB/s */
 735#define HNS_LOW_LATENCY_RATE			80	/* 80 MB/s */
 736
 737#define HNS_COAL_BDNUM			3
 738
 739static u32 hns_coal_rx_bdnum(struct hnae_ring *ring)
 740{
 741	bool coal_enable = ring->q->handle->coal_adapt_en;
 742
 743	if (coal_enable &&
 744	    ring->coal_last_rx_bytes > HNS_LOWEST_LATENCY_RATE)
 745		return HNS_COAL_BDNUM;
 746	else
 747		return 0;
 748}
 749
 750static void hns_update_rx_rate(struct hnae_ring *ring)
 751{
 752	bool coal_enable = ring->q->handle->coal_adapt_en;
 753	u32 time_passed_ms;
 754	u64 total_bytes;
 755
 756	if (!coal_enable ||
 757	    time_before(jiffies, ring->coal_last_jiffies + (HZ >> 4)))
 758		return;
 759
 760	/* ring->stats.rx_bytes overflowed */
 761	if (ring->coal_last_rx_bytes > ring->stats.rx_bytes) {
 762		ring->coal_last_rx_bytes = ring->stats.rx_bytes;
 763		ring->coal_last_jiffies = jiffies;
 764		return;
 765	}
 766
 767	total_bytes = ring->stats.rx_bytes - ring->coal_last_rx_bytes;
 768	time_passed_ms = jiffies_to_msecs(jiffies - ring->coal_last_jiffies);
 769	do_div(total_bytes, time_passed_ms);
 770	ring->coal_rx_rate = total_bytes >> 10;
 771
 772	ring->coal_last_rx_bytes = ring->stats.rx_bytes;
 773	ring->coal_last_jiffies = jiffies;
 774}
 775
 776/**
 777 * smooth_alg - smoothing algrithm for adjusting coalesce parameter
 778 * @new_param: new value
 779 * @old_param: old value
 780 **/
 781static u32 smooth_alg(u32 new_param, u32 old_param)
 782{
 783	u32 gap = (new_param > old_param) ? new_param - old_param
 784					  : old_param - new_param;
 785
 786	if (gap > 8)
 787		gap >>= 3;
 788
 789	if (new_param > old_param)
 790		return old_param + gap;
 791	else
 792		return old_param - gap;
 793}
 794
 795/**
 796 * hns_nic_adpt_coalesce - self adapte coalesce according to rx rate
 797 * @ring_data: pointer to hns_nic_ring_data
 798 **/
 799static void hns_nic_adpt_coalesce(struct hns_nic_ring_data *ring_data)
 800{
 801	struct hnae_ring *ring = ring_data->ring;
 802	struct hnae_handle *handle = ring->q->handle;
 803	u32 new_coal_param, old_coal_param = ring->coal_param;
 804
 805	if (ring->coal_rx_rate < HNS_LOWEST_LATENCY_RATE)
 806		new_coal_param = HNAE_LOWEST_LATENCY_COAL_PARAM;
 807	else if (ring->coal_rx_rate < HNS_LOW_LATENCY_RATE)
 808		new_coal_param = HNAE_LOW_LATENCY_COAL_PARAM;
 809	else
 810		new_coal_param = HNAE_BULK_LATENCY_COAL_PARAM;
 811
 812	if (new_coal_param == old_coal_param &&
 813	    new_coal_param == handle->coal_param)
 814		return;
 815
 816	new_coal_param = smooth_alg(new_coal_param, old_coal_param);
 817	ring->coal_param = new_coal_param;
 818
 819	/**
 820	 * Because all ring in one port has one coalesce param, when one ring
 821	 * calculate its own coalesce param, it cannot write to hardware at
 822	 * once. There are three conditions as follows:
 823	 *       1. current ring's coalesce param is larger than the hardware.
 824	 *       2. or ring which adapt last time can change again.
 825	 *       3. timeout.
 826	 */
 827	if (new_coal_param == handle->coal_param) {
 828		handle->coal_last_jiffies = jiffies;
 829		handle->coal_ring_idx = ring_data->queue_index;
 830	} else if (new_coal_param > handle->coal_param ||
 831		   handle->coal_ring_idx == ring_data->queue_index ||
 832		   time_after(jiffies, handle->coal_last_jiffies + (HZ >> 4))) {
 833		handle->dev->ops->set_coalesce_usecs(handle,
 834					new_coal_param);
 835		handle->dev->ops->set_coalesce_frames(handle,
 836					1, new_coal_param);
 837		handle->coal_param = new_coal_param;
 838		handle->coal_ring_idx = ring_data->queue_index;
 839		handle->coal_last_jiffies = jiffies;
 840	}
 841}
 842
 843static int hns_nic_rx_poll_one(struct hns_nic_ring_data *ring_data,
 844			       int budget, void *v)
 845{
 846	struct hnae_ring *ring = ring_data->ring;
 847	struct sk_buff *skb;
 848	int num, bnum;
 849#define RCB_NOF_ALLOC_RX_BUFF_ONCE 16
 850	int recv_pkts, recv_bds, clean_count, err;
 851	int unused_count = hns_desc_unused(ring);
 852
 853	num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM);
 854	rmb(); /* make sure num taken effect before the other data is touched */
 855
 856	recv_pkts = 0, recv_bds = 0, clean_count = 0;
 857	num -= unused_count;
 858
 859	while (recv_pkts < budget && recv_bds < num) {
 860		/* reuse or realloc buffers */
 861		if (clean_count + unused_count >= RCB_NOF_ALLOC_RX_BUFF_ONCE) {
 862			hns_nic_alloc_rx_buffers(ring_data,
 863						 clean_count + unused_count);
 864			clean_count = 0;
 865			unused_count = hns_desc_unused(ring);
 866		}
 867
 868		/* poll one pkt */
 869		err = hns_nic_poll_rx_skb(ring_data, &skb, &bnum);
 870		if (unlikely(!skb)) /* this fault cannot be repaired */
 871			goto out;
 872
 873		recv_bds += bnum;
 874		clean_count += bnum;
 875		if (unlikely(err)) {  /* do jump the err */
 876			recv_pkts++;
 877			continue;
 878		}
 879
 880		/* do update ip stack process*/
 881		((void (*)(struct hns_nic_ring_data *, struct sk_buff *))v)(
 882							ring_data, skb);
 883		recv_pkts++;
 884	}
 885
 886out:
 887	/* make all data has been write before submit */
 888	if (clean_count + unused_count > 0)
 889		hns_nic_alloc_rx_buffers(ring_data,
 890					 clean_count + unused_count);
 891
 892	return recv_pkts;
 893}
 894
 895static bool hns_nic_rx_fini_pro(struct hns_nic_ring_data *ring_data)
 896{
 897	struct hnae_ring *ring = ring_data->ring;
 898	int num;
 899	bool rx_stopped;
 900
 901	hns_update_rx_rate(ring);
 902
 903	/* for hardware bug fixed */
 904	ring_data->ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
 905	num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM);
 906
 907	if (num <= hns_coal_rx_bdnum(ring)) {
 908		if (ring->q->handle->coal_adapt_en)
 909			hns_nic_adpt_coalesce(ring_data);
 910
 911		rx_stopped = true;
 912	} else {
 913		ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
 914			ring_data->ring, 1);
 915
 916		rx_stopped = false;
 917	}
 918
 919	return rx_stopped;
 920}
 921
 922static bool hns_nic_rx_fini_pro_v2(struct hns_nic_ring_data *ring_data)
 923{
 924	struct hnae_ring *ring = ring_data->ring;
 925	int num;
 926
 927	hns_update_rx_rate(ring);
 928	num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM);
 929
 930	if (num <= hns_coal_rx_bdnum(ring)) {
 931		if (ring->q->handle->coal_adapt_en)
 932			hns_nic_adpt_coalesce(ring_data);
 933
 934		return true;
 935	}
 936
 937	return false;
 938}
 939
 940static inline void hns_nic_reclaim_one_desc(struct hnae_ring *ring,
 941					    int *bytes, int *pkts)
 942{
 943	struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_clean];
 944
 945	(*pkts) += (desc_cb->type == DESC_TYPE_SKB);
 946	(*bytes) += desc_cb->length;
 947	/* desc_cb will be cleaned, after hnae_free_buffer_detach*/
 948	hnae_free_buffer_detach(ring, ring->next_to_clean);
 949
 950	ring_ptr_move_fw(ring, next_to_clean);
 951}
 952
 953static int is_valid_clean_head(struct hnae_ring *ring, int h)
 954{
 955	int u = ring->next_to_use;
 956	int c = ring->next_to_clean;
 957
 958	if (unlikely(h > ring->desc_num))
 959		return 0;
 960
 961	assert(u > 0 && u < ring->desc_num);
 962	assert(c > 0 && c < ring->desc_num);
 963	assert(u != c && h != c); /* must be checked before call this func */
 964
 965	return u > c ? (h > c && h <= u) : (h > c || h <= u);
 966}
 967
 968/* reclaim all desc in one budget
 969 * return error or number of desc left
 970 */
 971static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data,
 972			       int budget, void *v)
 973{
 974	struct hnae_ring *ring = ring_data->ring;
 975	struct net_device *ndev = ring_data->napi.dev;
 976	struct netdev_queue *dev_queue;
 977	struct hns_nic_priv *priv = netdev_priv(ndev);
 978	int head;
 979	int bytes, pkts;
 980
 981	head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
 982	rmb(); /* make sure head is ready before touch any data */
 983
 984	if (is_ring_empty(ring) || head == ring->next_to_clean)
 985		return 0; /* no data to poll */
 986
 987	if (!is_valid_clean_head(ring, head)) {
 988		netdev_err(ndev, "wrong head (%d, %d-%d)\n", head,
 989			   ring->next_to_use, ring->next_to_clean);
 990		ring->stats.io_err_cnt++;
 991		return -EIO;
 992	}
 993
 994	bytes = 0;
 995	pkts = 0;
 996	while (head != ring->next_to_clean) {
 997		hns_nic_reclaim_one_desc(ring, &bytes, &pkts);
 998		/* issue prefetch for next Tx descriptor */
 999		prefetch(&ring->desc_cb[ring->next_to_clean]);
1000	}
1001	/* update tx ring statistics. */
1002	ring->stats.tx_pkts += pkts;
1003	ring->stats.tx_bytes += bytes;
1004
1005	dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index);
1006	netdev_tx_completed_queue(dev_queue, pkts, bytes);
1007
1008	if (unlikely(priv->link && !netif_carrier_ok(ndev)))
1009		netif_carrier_on(ndev);
1010
1011	if (unlikely(pkts && netif_carrier_ok(ndev) &&
1012		     (ring_space(ring) >= ring->max_desc_num_per_pkt * 2))) {
1013		/* Make sure that anybody stopping the queue after this
1014		 * sees the new next_to_clean.
1015		 */
1016		smp_mb();
1017		if (netif_tx_queue_stopped(dev_queue) &&
1018		    !test_bit(NIC_STATE_DOWN, &priv->state)) {
1019			netif_tx_wake_queue(dev_queue);
1020			ring->stats.restart_queue++;
1021		}
1022	}
1023	return 0;
1024}
1025
1026static bool hns_nic_tx_fini_pro(struct hns_nic_ring_data *ring_data)
1027{
1028	struct hnae_ring *ring = ring_data->ring;
1029	int head;
1030
1031	ring_data->ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
1032
1033	head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
1034
1035	if (head != ring->next_to_clean) {
1036		ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
1037			ring_data->ring, 1);
1038
1039		return false;
1040	} else {
1041		return true;
1042	}
1043}
1044
1045static bool hns_nic_tx_fini_pro_v2(struct hns_nic_ring_data *ring_data)
1046{
1047	struct hnae_ring *ring = ring_data->ring;
1048	int head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
1049
1050	if (head == ring->next_to_clean)
1051		return true;
1052	else
1053		return false;
1054}
1055
1056static void hns_nic_tx_clr_all_bufs(struct hns_nic_ring_data *ring_data)
1057{
1058	struct hnae_ring *ring = ring_data->ring;
1059	struct net_device *ndev = ring_data->napi.dev;
1060	struct netdev_queue *dev_queue;
1061	int head;
1062	int bytes, pkts;
1063
1064	head = ring->next_to_use; /* ntu :soft setted ring position*/
1065	bytes = 0;
1066	pkts = 0;
1067	while (head != ring->next_to_clean)
1068		hns_nic_reclaim_one_desc(ring, &bytes, &pkts);
1069
1070	dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index);
1071	netdev_tx_reset_queue(dev_queue);
1072}
1073
1074static int hns_nic_common_poll(struct napi_struct *napi, int budget)
1075{
1076	int clean_complete = 0;
1077	struct hns_nic_ring_data *ring_data =
1078		container_of(napi, struct hns_nic_ring_data, napi);
1079	struct hnae_ring *ring = ring_data->ring;
1080
1081	clean_complete += ring_data->poll_one(
1082				ring_data, budget - clean_complete,
1083				ring_data->ex_process);
1084
1085	if (clean_complete < budget) {
1086		if (ring_data->fini_process(ring_data)) {
1087			napi_complete(napi);
1088			ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
1089		} else {
1090			return budget;
1091		}
1092	}
1093
1094	return clean_complete;
1095}
1096
1097static irqreturn_t hns_irq_handle(int irq, void *dev)
1098{
1099	struct hns_nic_ring_data *ring_data = (struct hns_nic_ring_data *)dev;
1100
1101	ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
1102		ring_data->ring, 1);
1103	napi_schedule(&ring_data->napi);
1104
1105	return IRQ_HANDLED;
1106}
1107
1108/**
1109 *hns_nic_adjust_link - adjust net work mode by the phy stat or new param
1110 *@ndev: net device
1111 */
1112static void hns_nic_adjust_link(struct net_device *ndev)
1113{
1114	struct hns_nic_priv *priv = netdev_priv(ndev);
1115	struct hnae_handle *h = priv->ae_handle;
1116	int state = 1;
1117
1118	/* If there is no phy, do not need adjust link */
1119	if (ndev->phydev) {
1120		/* When phy link down, do nothing */
1121		if (ndev->phydev->link == 0)
1122			return;
1123
1124		if (h->dev->ops->need_adjust_link(h, ndev->phydev->speed,
1125						  ndev->phydev->duplex)) {
1126			/* because Hi161X chip don't support to change gmac
1127			 * speed and duplex with traffic. Delay 200ms to
1128			 * make sure there is no more data in chip FIFO.
1129			 */
1130			netif_carrier_off(ndev);
1131			msleep(200);
1132			h->dev->ops->adjust_link(h, ndev->phydev->speed,
1133						 ndev->phydev->duplex);
1134			netif_carrier_on(ndev);
1135		}
1136	}
1137
1138	state = state && h->dev->ops->get_status(h);
1139
1140	if (state != priv->link) {
1141		if (state) {
1142			netif_carrier_on(ndev);
1143			netif_tx_wake_all_queues(ndev);
1144			netdev_info(ndev, "link up\n");
1145		} else {
1146			netif_carrier_off(ndev);
1147			netdev_info(ndev, "link down\n");
1148		}
1149		priv->link = state;
1150	}
1151}
1152
1153/**
1154 *hns_nic_init_phy - init phy
1155 *@ndev: net device
1156 *@h: ae handle
1157 * Return 0 on success, negative on failure
1158 */
1159int hns_nic_init_phy(struct net_device *ndev, struct hnae_handle *h)
1160{
1161	__ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = { 0, };
1162	struct phy_device *phy_dev = h->phy_dev;
1163	int ret;
1164
1165	if (!h->phy_dev)
1166		return 0;
1167
1168	ethtool_convert_legacy_u32_to_link_mode(supported, h->if_support);
1169	linkmode_and(phy_dev->supported, phy_dev->supported, supported);
1170	linkmode_copy(phy_dev->advertising, phy_dev->supported);
1171
1172	if (h->phy_if == PHY_INTERFACE_MODE_XGMII)
1173		phy_dev->autoneg = false;
1174
1175	if (h->phy_if != PHY_INTERFACE_MODE_XGMII) {
1176		phy_dev->dev_flags = 0;
1177
1178		ret = phy_connect_direct(ndev, phy_dev, hns_nic_adjust_link,
1179					 h->phy_if);
1180	} else {
1181		ret = phy_attach_direct(ndev, phy_dev, 0, h->phy_if);
1182	}
1183	if (unlikely(ret))
1184		return -ENODEV;
1185
1186	phy_attached_info(phy_dev);
1187
1188	return 0;
1189}
1190
1191static int hns_nic_ring_open(struct net_device *netdev, int idx)
1192{
1193	struct hns_nic_priv *priv = netdev_priv(netdev);
1194	struct hnae_handle *h = priv->ae_handle;
1195
1196	napi_enable(&priv->ring_data[idx].napi);
1197
1198	enable_irq(priv->ring_data[idx].ring->irq);
1199	h->dev->ops->toggle_ring_irq(priv->ring_data[idx].ring, 0);
1200
1201	return 0;
1202}
1203
1204static int hns_nic_net_set_mac_address(struct net_device *ndev, void *p)
1205{
1206	struct hns_nic_priv *priv = netdev_priv(ndev);
1207	struct hnae_handle *h = priv->ae_handle;
1208	struct sockaddr *mac_addr = p;
1209	int ret;
1210
1211	if (!mac_addr || !is_valid_ether_addr((const u8 *)mac_addr->sa_data))
1212		return -EADDRNOTAVAIL;
1213
1214	ret = h->dev->ops->set_mac_addr(h, mac_addr->sa_data);
1215	if (ret) {
1216		netdev_err(ndev, "set_mac_address fail, ret=%d!\n", ret);
1217		return ret;
1218	}
1219
1220	eth_hw_addr_set(ndev, mac_addr->sa_data);
1221
1222	return 0;
1223}
1224
1225static void hns_nic_update_stats(struct net_device *netdev)
1226{
1227	struct hns_nic_priv *priv = netdev_priv(netdev);
1228	struct hnae_handle *h = priv->ae_handle;
1229
1230	h->dev->ops->update_stats(h, &netdev->stats);
1231}
1232
1233/* set mac addr if it is configed. or leave it to the AE driver */
1234static void hns_init_mac_addr(struct net_device *ndev)
1235{
1236	struct hns_nic_priv *priv = netdev_priv(ndev);
1237
1238	if (device_get_ethdev_address(priv->dev, ndev)) {
1239		eth_hw_addr_random(ndev);
1240		dev_warn(priv->dev, "No valid mac, use random mac %pM",
1241			 ndev->dev_addr);
1242	}
1243}
1244
1245static void hns_nic_ring_close(struct net_device *netdev, int idx)
1246{
1247	struct hns_nic_priv *priv = netdev_priv(netdev);
1248	struct hnae_handle *h = priv->ae_handle;
1249
1250	h->dev->ops->toggle_ring_irq(priv->ring_data[idx].ring, 1);
1251	disable_irq(priv->ring_data[idx].ring->irq);
1252
1253	napi_disable(&priv->ring_data[idx].napi);
1254}
1255
1256static int hns_nic_init_affinity_mask(int q_num, int ring_idx,
1257				      struct hnae_ring *ring, cpumask_t *mask)
1258{
1259	int cpu;
1260
1261	/* Different irq balance between 16core and 32core.
1262	 * The cpu mask set by ring index according to the ring flag
1263	 * which indicate the ring is tx or rx.
1264	 */
1265	if (q_num == num_possible_cpus()) {
1266		if (is_tx_ring(ring))
1267			cpu = ring_idx;
1268		else
1269			cpu = ring_idx - q_num;
1270	} else {
1271		if (is_tx_ring(ring))
1272			cpu = ring_idx * 2;
1273		else
1274			cpu = (ring_idx - q_num) * 2 + 1;
1275	}
1276
1277	cpumask_clear(mask);
1278	cpumask_set_cpu(cpu, mask);
1279
1280	return cpu;
1281}
1282
1283static void hns_nic_free_irq(int q_num, struct hns_nic_priv *priv)
1284{
1285	int i;
1286
1287	for (i = 0; i < q_num * 2; i++) {
1288		if (priv->ring_data[i].ring->irq_init_flag == RCB_IRQ_INITED) {
1289			irq_set_affinity_hint(priv->ring_data[i].ring->irq,
1290					      NULL);
1291			free_irq(priv->ring_data[i].ring->irq,
1292				 &priv->ring_data[i]);
1293			priv->ring_data[i].ring->irq_init_flag =
1294				RCB_IRQ_NOT_INITED;
1295		}
1296	}
1297}
1298
1299static int hns_nic_init_irq(struct hns_nic_priv *priv)
1300{
1301	struct hnae_handle *h = priv->ae_handle;
1302	struct hns_nic_ring_data *rd;
1303	int i;
1304	int ret;
1305	int cpu;
1306
1307	for (i = 0; i < h->q_num * 2; i++) {
1308		rd = &priv->ring_data[i];
1309
1310		if (rd->ring->irq_init_flag == RCB_IRQ_INITED)
1311			break;
1312
1313		snprintf(rd->ring->ring_name, RCB_RING_NAME_LEN,
1314			 "%s-%s%d", priv->netdev->name,
1315			 (is_tx_ring(rd->ring) ? "tx" : "rx"), rd->queue_index);
1316
1317		rd->ring->ring_name[RCB_RING_NAME_LEN - 1] = '\0';
1318
1319		irq_set_status_flags(rd->ring->irq, IRQ_NOAUTOEN);
1320		ret = request_irq(rd->ring->irq,
1321				  hns_irq_handle, 0, rd->ring->ring_name, rd);
1322		if (ret) {
1323			netdev_err(priv->netdev, "request irq(%d) fail\n",
1324				   rd->ring->irq);
1325			goto out_free_irq;
1326		}
 
1327
1328		cpu = hns_nic_init_affinity_mask(h->q_num, i,
1329						 rd->ring, &rd->mask);
1330
1331		if (cpu_online(cpu))
1332			irq_set_affinity_hint(rd->ring->irq,
1333					      &rd->mask);
1334
1335		rd->ring->irq_init_flag = RCB_IRQ_INITED;
1336	}
1337
1338	return 0;
1339
1340out_free_irq:
1341	hns_nic_free_irq(h->q_num, priv);
1342	return ret;
1343}
1344
1345static int hns_nic_net_up(struct net_device *ndev)
1346{
1347	struct hns_nic_priv *priv = netdev_priv(ndev);
1348	struct hnae_handle *h = priv->ae_handle;
1349	int i, j;
1350	int ret;
1351
1352	if (!test_bit(NIC_STATE_DOWN, &priv->state))
1353		return 0;
1354
1355	ret = hns_nic_init_irq(priv);
1356	if (ret != 0) {
1357		netdev_err(ndev, "hns init irq failed! ret=%d\n", ret);
1358		return ret;
1359	}
1360
1361	for (i = 0; i < h->q_num * 2; i++) {
1362		ret = hns_nic_ring_open(ndev, i);
1363		if (ret)
1364			goto out_has_some_queues;
1365	}
1366
1367	ret = h->dev->ops->set_mac_addr(h, ndev->dev_addr);
1368	if (ret)
1369		goto out_set_mac_addr_err;
1370
1371	ret = h->dev->ops->start ? h->dev->ops->start(h) : 0;
1372	if (ret)
1373		goto out_start_err;
1374
1375	if (ndev->phydev)
1376		phy_start(ndev->phydev);
1377
1378	clear_bit(NIC_STATE_DOWN, &priv->state);
1379	(void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ);
1380
1381	return 0;
1382
1383out_start_err:
1384	netif_stop_queue(ndev);
1385out_set_mac_addr_err:
1386out_has_some_queues:
1387	for (j = i - 1; j >= 0; j--)
1388		hns_nic_ring_close(ndev, j);
1389
1390	hns_nic_free_irq(h->q_num, priv);
1391	set_bit(NIC_STATE_DOWN, &priv->state);
1392
1393	return ret;
1394}
1395
1396static void hns_nic_net_down(struct net_device *ndev)
1397{
1398	int i;
1399	struct hnae_ae_ops *ops;
1400	struct hns_nic_priv *priv = netdev_priv(ndev);
1401
1402	if (test_and_set_bit(NIC_STATE_DOWN, &priv->state))
1403		return;
1404
1405	(void)del_timer_sync(&priv->service_timer);
1406	netif_tx_stop_all_queues(ndev);
1407	netif_carrier_off(ndev);
1408	netif_tx_disable(ndev);
1409	priv->link = 0;
1410
1411	if (ndev->phydev)
1412		phy_stop(ndev->phydev);
1413
1414	ops = priv->ae_handle->dev->ops;
1415
1416	if (ops->stop)
1417		ops->stop(priv->ae_handle);
1418
1419	netif_tx_stop_all_queues(ndev);
1420
1421	for (i = priv->ae_handle->q_num - 1; i >= 0; i--) {
1422		hns_nic_ring_close(ndev, i);
1423		hns_nic_ring_close(ndev, i + priv->ae_handle->q_num);
1424
1425		/* clean tx buffers*/
1426		hns_nic_tx_clr_all_bufs(priv->ring_data + i);
1427	}
1428}
1429
1430void hns_nic_net_reset(struct net_device *ndev)
1431{
1432	struct hns_nic_priv *priv = netdev_priv(ndev);
1433	struct hnae_handle *handle = priv->ae_handle;
1434
1435	while (test_and_set_bit(NIC_STATE_RESETTING, &priv->state))
1436		usleep_range(1000, 2000);
1437
1438	(void)hnae_reinit_handle(handle);
1439
1440	clear_bit(NIC_STATE_RESETTING, &priv->state);
1441}
1442
1443void hns_nic_net_reinit(struct net_device *netdev)
1444{
1445	struct hns_nic_priv *priv = netdev_priv(netdev);
1446	enum hnae_port_type type = priv->ae_handle->port_type;
1447
1448	netif_trans_update(priv->netdev);
1449	while (test_and_set_bit(NIC_STATE_REINITING, &priv->state))
1450		usleep_range(1000, 2000);
1451
1452	hns_nic_net_down(netdev);
1453
1454	/* Only do hns_nic_net_reset in debug mode
1455	 * because of hardware limitation.
1456	 */
1457	if (type == HNAE_PORT_DEBUG)
1458		hns_nic_net_reset(netdev);
1459
1460	(void)hns_nic_net_up(netdev);
1461	clear_bit(NIC_STATE_REINITING, &priv->state);
1462}
1463
1464static int hns_nic_net_open(struct net_device *ndev)
1465{
1466	struct hns_nic_priv *priv = netdev_priv(ndev);
1467	struct hnae_handle *h = priv->ae_handle;
1468	int ret;
1469
1470	if (test_bit(NIC_STATE_TESTING, &priv->state))
1471		return -EBUSY;
1472
1473	priv->link = 0;
1474	netif_carrier_off(ndev);
1475
1476	ret = netif_set_real_num_tx_queues(ndev, h->q_num);
1477	if (ret < 0) {
1478		netdev_err(ndev, "netif_set_real_num_tx_queues fail, ret=%d!\n",
1479			   ret);
1480		return ret;
1481	}
1482
1483	ret = netif_set_real_num_rx_queues(ndev, h->q_num);
1484	if (ret < 0) {
1485		netdev_err(ndev,
1486			   "netif_set_real_num_rx_queues fail, ret=%d!\n", ret);
1487		return ret;
1488	}
1489
1490	ret = hns_nic_net_up(ndev);
1491	if (ret) {
1492		netdev_err(ndev,
1493			   "hns net up fail, ret=%d!\n", ret);
1494		return ret;
1495	}
1496
1497	return 0;
1498}
1499
1500static int hns_nic_net_stop(struct net_device *ndev)
1501{
1502	hns_nic_net_down(ndev);
1503
1504	return 0;
1505}
1506
1507static void hns_tx_timeout_reset(struct hns_nic_priv *priv);
1508#define HNS_TX_TIMEO_LIMIT (40 * HZ)
1509static void hns_nic_net_timeout(struct net_device *ndev, unsigned int txqueue)
1510{
1511	struct hns_nic_priv *priv = netdev_priv(ndev);
1512
1513	if (ndev->watchdog_timeo < HNS_TX_TIMEO_LIMIT) {
1514		ndev->watchdog_timeo *= 2;
1515		netdev_info(ndev, "watchdog_timo changed to %d.\n",
1516			    ndev->watchdog_timeo);
1517	} else {
1518		ndev->watchdog_timeo = HNS_NIC_TX_TIMEOUT;
1519		hns_tx_timeout_reset(priv);
1520	}
1521}
1522
1523static netdev_tx_t hns_nic_net_xmit(struct sk_buff *skb,
1524				    struct net_device *ndev)
1525{
1526	struct hns_nic_priv *priv = netdev_priv(ndev);
1527
1528	assert(skb->queue_mapping < priv->ae_handle->q_num);
1529
1530	return hns_nic_net_xmit_hw(ndev, skb,
1531				   &tx_ring_data(priv, skb->queue_mapping));
1532}
1533
1534static void hns_nic_drop_rx_fetch(struct hns_nic_ring_data *ring_data,
1535				  struct sk_buff *skb)
1536{
1537	dev_kfree_skb_any(skb);
1538}
1539
1540#define HNS_LB_TX_RING	0
1541static struct sk_buff *hns_assemble_skb(struct net_device *ndev)
1542{
1543	struct sk_buff *skb;
1544	struct ethhdr *ethhdr;
1545	int frame_len;
1546
1547	/* allocate test skb */
1548	skb = alloc_skb(64, GFP_KERNEL);
1549	if (!skb)
1550		return NULL;
1551
1552	skb_put(skb, 64);
1553	skb->dev = ndev;
1554	memset(skb->data, 0xFF, skb->len);
1555
1556	/* must be tcp/ip package */
1557	ethhdr = (struct ethhdr *)skb->data;
1558	ethhdr->h_proto = htons(ETH_P_IP);
1559
1560	frame_len = skb->len & (~1ul);
1561	memset(&skb->data[frame_len / 2], 0xAA,
1562	       frame_len / 2 - 1);
1563
1564	skb->queue_mapping = HNS_LB_TX_RING;
1565
1566	return skb;
1567}
1568
1569static int hns_enable_serdes_lb(struct net_device *ndev)
1570{
1571	struct hns_nic_priv *priv = netdev_priv(ndev);
1572	struct hnae_handle *h = priv->ae_handle;
1573	struct hnae_ae_ops *ops = h->dev->ops;
1574	int speed, duplex;
1575	int ret;
1576
1577	ret = ops->set_loopback(h, MAC_INTERNALLOOP_SERDES, 1);
1578	if (ret)
1579		return ret;
1580
1581	ret = ops->start ? ops->start(h) : 0;
1582	if (ret)
1583		return ret;
1584
1585	/* link adjust duplex*/
1586	if (h->phy_if != PHY_INTERFACE_MODE_XGMII)
1587		speed = 1000;
1588	else
1589		speed = 10000;
1590	duplex = 1;
1591
1592	ops->adjust_link(h, speed, duplex);
1593
1594	/* wait h/w ready */
1595	mdelay(300);
1596
1597	return 0;
1598}
1599
1600static void hns_disable_serdes_lb(struct net_device *ndev)
1601{
1602	struct hns_nic_priv *priv = netdev_priv(ndev);
1603	struct hnae_handle *h = priv->ae_handle;
1604	struct hnae_ae_ops *ops = h->dev->ops;
1605
1606	ops->stop(h);
1607	ops->set_loopback(h, MAC_INTERNALLOOP_SERDES, 0);
1608}
1609
1610/**
1611 *hns_nic_clear_all_rx_fetch - clear the chip fetched descriptions. The
1612 *function as follows:
1613 *    1. if one rx ring has found the page_offset is not equal 0 between head
1614 *       and tail, it means that the chip fetched the wrong descs for the ring
1615 *       which buffer size is 4096.
1616 *    2. we set the chip serdes loopback and set rss indirection to the ring.
1617 *    3. construct 64-bytes ip broadcast packages, wait the associated rx ring
1618 *       receiving all packages and it will fetch new descriptions.
1619 *    4. recover to the original state.
1620 *
1621 *@ndev: net device
1622 */
1623static int hns_nic_clear_all_rx_fetch(struct net_device *ndev)
1624{
1625	struct hns_nic_priv *priv = netdev_priv(ndev);
1626	struct hnae_handle *h = priv->ae_handle;
1627	struct hnae_ae_ops *ops = h->dev->ops;
1628	struct hns_nic_ring_data *rd;
1629	struct hnae_ring *ring;
1630	struct sk_buff *skb;
1631	u32 *org_indir;
1632	u32 *cur_indir;
1633	int indir_size;
1634	int head, tail;
1635	int fetch_num;
1636	int i, j;
1637	bool found;
1638	int retry_times;
1639	int ret = 0;
1640
1641	/* alloc indir memory */
1642	indir_size = ops->get_rss_indir_size(h) * sizeof(*org_indir);
1643	org_indir = kzalloc(indir_size, GFP_KERNEL);
1644	if (!org_indir)
1645		return -ENOMEM;
1646
1647	/* store the original indirection */
1648	ops->get_rss(h, org_indir, NULL, NULL);
1649
1650	cur_indir = kzalloc(indir_size, GFP_KERNEL);
1651	if (!cur_indir) {
1652		ret = -ENOMEM;
1653		goto cur_indir_alloc_err;
1654	}
1655
1656	/* set loopback */
1657	if (hns_enable_serdes_lb(ndev)) {
1658		ret = -EINVAL;
1659		goto enable_serdes_lb_err;
1660	}
1661
1662	/* foreach every rx ring to clear fetch desc */
1663	for (i = 0; i < h->q_num; i++) {
1664		ring = &h->qs[i]->rx_ring;
1665		head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
1666		tail = readl_relaxed(ring->io_base + RCB_REG_TAIL);
1667		found = false;
1668		fetch_num = ring_dist(ring, head, tail);
1669
1670		while (head != tail) {
1671			if (ring->desc_cb[head].page_offset != 0) {
1672				found = true;
1673				break;
1674			}
1675
1676			head++;
1677			if (head == ring->desc_num)
1678				head = 0;
1679		}
1680
1681		if (found) {
1682			for (j = 0; j < indir_size / sizeof(*org_indir); j++)
1683				cur_indir[j] = i;
1684			ops->set_rss(h, cur_indir, NULL, 0);
1685
1686			for (j = 0; j < fetch_num; j++) {
1687				/* alloc one skb and init */
1688				skb = hns_assemble_skb(ndev);
1689				if (!skb) {
1690					ret = -ENOMEM;
1691					goto out;
1692				}
1693				rd = &tx_ring_data(priv, skb->queue_mapping);
1694				hns_nic_net_xmit_hw(ndev, skb, rd);
1695
1696				retry_times = 0;
1697				while (retry_times++ < 10) {
1698					mdelay(10);
1699					/* clean rx */
1700					rd = &rx_ring_data(priv, i);
1701					if (rd->poll_one(rd, fetch_num,
1702							 hns_nic_drop_rx_fetch))
1703						break;
1704				}
1705
1706				retry_times = 0;
1707				while (retry_times++ < 10) {
1708					mdelay(10);
1709					/* clean tx ring 0 send package */
1710					rd = &tx_ring_data(priv,
1711							   HNS_LB_TX_RING);
1712					if (rd->poll_one(rd, fetch_num, NULL))
1713						break;
1714				}
1715			}
1716		}
1717	}
1718
1719out:
1720	/* restore everything */
1721	ops->set_rss(h, org_indir, NULL, 0);
1722	hns_disable_serdes_lb(ndev);
1723enable_serdes_lb_err:
1724	kfree(cur_indir);
1725cur_indir_alloc_err:
1726	kfree(org_indir);
1727
1728	return ret;
1729}
1730
1731static int hns_nic_change_mtu(struct net_device *ndev, int new_mtu)
1732{
1733	struct hns_nic_priv *priv = netdev_priv(ndev);
1734	struct hnae_handle *h = priv->ae_handle;
1735	bool if_running = netif_running(ndev);
1736	int ret;
1737
1738	/* MTU < 68 is an error and causes problems on some kernels */
1739	if (new_mtu < 68)
1740		return -EINVAL;
1741
1742	/* MTU no change */
1743	if (new_mtu == ndev->mtu)
1744		return 0;
1745
1746	if (!h->dev->ops->set_mtu)
1747		return -ENOTSUPP;
1748
1749	if (if_running) {
1750		(void)hns_nic_net_stop(ndev);
1751		msleep(100);
1752	}
1753
1754	if (priv->enet_ver != AE_VERSION_1 &&
1755	    ndev->mtu <= BD_SIZE_2048_MAX_MTU &&
1756	    new_mtu > BD_SIZE_2048_MAX_MTU) {
1757		/* update desc */
1758		hnae_reinit_all_ring_desc(h);
1759
1760		/* clear the package which the chip has fetched */
1761		ret = hns_nic_clear_all_rx_fetch(ndev);
1762
1763		/* the page offset must be consist with desc */
1764		hnae_reinit_all_ring_page_off(h);
1765
1766		if (ret) {
1767			netdev_err(ndev, "clear the fetched desc fail\n");
1768			goto out;
1769		}
1770	}
1771
1772	ret = h->dev->ops->set_mtu(h, new_mtu);
1773	if (ret) {
1774		netdev_err(ndev, "set mtu fail, return value %d\n",
1775			   ret);
1776		goto out;
1777	}
1778
1779	/* finally, set new mtu to netdevice */
1780	ndev->mtu = new_mtu;
1781
1782out:
1783	if (if_running) {
1784		if (hns_nic_net_open(ndev)) {
1785			netdev_err(ndev, "hns net open fail\n");
1786			ret = -EINVAL;
1787		}
1788	}
1789
1790	return ret;
1791}
1792
1793static int hns_nic_set_features(struct net_device *netdev,
1794				netdev_features_t features)
1795{
1796	struct hns_nic_priv *priv = netdev_priv(netdev);
1797
1798	switch (priv->enet_ver) {
1799	case AE_VERSION_1:
1800		if (features & (NETIF_F_TSO | NETIF_F_TSO6))
1801			netdev_info(netdev, "enet v1 do not support tso!\n");
1802		break;
1803	default:
 
 
 
 
 
 
 
 
 
1804		break;
1805	}
1806	netdev->features = features;
1807	return 0;
1808}
1809
1810static netdev_features_t hns_nic_fix_features(
1811		struct net_device *netdev, netdev_features_t features)
1812{
1813	struct hns_nic_priv *priv = netdev_priv(netdev);
1814
1815	switch (priv->enet_ver) {
1816	case AE_VERSION_1:
1817		features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
1818				NETIF_F_HW_VLAN_CTAG_FILTER);
1819		break;
1820	default:
1821		break;
1822	}
1823	return features;
1824}
1825
1826static int hns_nic_uc_sync(struct net_device *netdev, const unsigned char *addr)
1827{
1828	struct hns_nic_priv *priv = netdev_priv(netdev);
1829	struct hnae_handle *h = priv->ae_handle;
1830
1831	if (h->dev->ops->add_uc_addr)
1832		return h->dev->ops->add_uc_addr(h, addr);
1833
1834	return 0;
1835}
1836
1837static int hns_nic_uc_unsync(struct net_device *netdev,
1838			     const unsigned char *addr)
1839{
1840	struct hns_nic_priv *priv = netdev_priv(netdev);
1841	struct hnae_handle *h = priv->ae_handle;
1842
1843	if (h->dev->ops->rm_uc_addr)
1844		return h->dev->ops->rm_uc_addr(h, addr);
1845
1846	return 0;
1847}
1848
1849/**
1850 * hns_set_multicast_list - set mutl mac address
1851 * @ndev: net device
 
1852 *
1853 * return void
1854 */
1855static void hns_set_multicast_list(struct net_device *ndev)
1856{
1857	struct hns_nic_priv *priv = netdev_priv(ndev);
1858	struct hnae_handle *h = priv->ae_handle;
1859	struct netdev_hw_addr *ha = NULL;
1860
1861	if (!h)	{
1862		netdev_err(ndev, "hnae handle is null\n");
1863		return;
1864	}
1865
1866	if (h->dev->ops->clr_mc_addr)
1867		if (h->dev->ops->clr_mc_addr(h))
1868			netdev_err(ndev, "clear multicast address fail\n");
1869
1870	if (h->dev->ops->set_mc_addr) {
1871		netdev_for_each_mc_addr(ha, ndev)
1872			if (h->dev->ops->set_mc_addr(h, ha->addr))
1873				netdev_err(ndev, "set multicast fail\n");
1874	}
1875}
1876
1877static void hns_nic_set_rx_mode(struct net_device *ndev)
1878{
1879	struct hns_nic_priv *priv = netdev_priv(ndev);
1880	struct hnae_handle *h = priv->ae_handle;
1881
1882	if (h->dev->ops->set_promisc_mode) {
1883		if (ndev->flags & IFF_PROMISC)
1884			h->dev->ops->set_promisc_mode(h, 1);
1885		else
1886			h->dev->ops->set_promisc_mode(h, 0);
1887	}
1888
1889	hns_set_multicast_list(ndev);
1890
1891	if (__dev_uc_sync(ndev, hns_nic_uc_sync, hns_nic_uc_unsync))
1892		netdev_err(ndev, "sync uc address fail\n");
1893}
1894
1895static void hns_nic_get_stats64(struct net_device *ndev,
1896				struct rtnl_link_stats64 *stats)
1897{
1898	int idx;
1899	u64 tx_bytes = 0;
1900	u64 rx_bytes = 0;
1901	u64 tx_pkts = 0;
1902	u64 rx_pkts = 0;
1903	struct hns_nic_priv *priv = netdev_priv(ndev);
1904	struct hnae_handle *h = priv->ae_handle;
1905
1906	for (idx = 0; idx < h->q_num; idx++) {
1907		tx_bytes += h->qs[idx]->tx_ring.stats.tx_bytes;
1908		tx_pkts += h->qs[idx]->tx_ring.stats.tx_pkts;
1909		rx_bytes += h->qs[idx]->rx_ring.stats.rx_bytes;
1910		rx_pkts += h->qs[idx]->rx_ring.stats.rx_pkts;
1911	}
1912
1913	stats->tx_bytes = tx_bytes;
1914	stats->tx_packets = tx_pkts;
1915	stats->rx_bytes = rx_bytes;
1916	stats->rx_packets = rx_pkts;
1917
1918	stats->rx_errors = ndev->stats.rx_errors;
1919	stats->multicast = ndev->stats.multicast;
1920	stats->rx_length_errors = ndev->stats.rx_length_errors;
1921	stats->rx_crc_errors = ndev->stats.rx_crc_errors;
1922	stats->rx_missed_errors = ndev->stats.rx_missed_errors;
1923
1924	stats->tx_errors = ndev->stats.tx_errors;
1925	stats->rx_dropped = ndev->stats.rx_dropped;
1926	stats->tx_dropped = ndev->stats.tx_dropped;
1927	stats->collisions = ndev->stats.collisions;
1928	stats->rx_over_errors = ndev->stats.rx_over_errors;
1929	stats->rx_frame_errors = ndev->stats.rx_frame_errors;
1930	stats->rx_fifo_errors = ndev->stats.rx_fifo_errors;
1931	stats->tx_aborted_errors = ndev->stats.tx_aborted_errors;
1932	stats->tx_carrier_errors = ndev->stats.tx_carrier_errors;
1933	stats->tx_fifo_errors = ndev->stats.tx_fifo_errors;
1934	stats->tx_heartbeat_errors = ndev->stats.tx_heartbeat_errors;
1935	stats->tx_window_errors = ndev->stats.tx_window_errors;
1936	stats->rx_compressed = ndev->stats.rx_compressed;
1937	stats->tx_compressed = ndev->stats.tx_compressed;
1938}
1939
1940static u16
1941hns_nic_select_queue(struct net_device *ndev, struct sk_buff *skb,
1942		     struct net_device *sb_dev)
1943{
1944	struct ethhdr *eth_hdr = (struct ethhdr *)skb->data;
1945	struct hns_nic_priv *priv = netdev_priv(ndev);
1946
1947	/* fix hardware broadcast/multicast packets queue loopback */
1948	if (!AE_IS_VER1(priv->enet_ver) &&
1949	    is_multicast_ether_addr(eth_hdr->h_dest))
1950		return 0;
1951	else
1952		return netdev_pick_tx(ndev, skb, NULL);
1953}
1954
1955static const struct net_device_ops hns_nic_netdev_ops = {
1956	.ndo_open = hns_nic_net_open,
1957	.ndo_stop = hns_nic_net_stop,
1958	.ndo_start_xmit = hns_nic_net_xmit,
1959	.ndo_tx_timeout = hns_nic_net_timeout,
1960	.ndo_set_mac_address = hns_nic_net_set_mac_address,
1961	.ndo_change_mtu = hns_nic_change_mtu,
1962	.ndo_eth_ioctl = phy_do_ioctl_running,
1963	.ndo_set_features = hns_nic_set_features,
1964	.ndo_fix_features = hns_nic_fix_features,
1965	.ndo_get_stats64 = hns_nic_get_stats64,
1966	.ndo_set_rx_mode = hns_nic_set_rx_mode,
1967	.ndo_select_queue = hns_nic_select_queue,
1968};
1969
1970static void hns_nic_update_link_status(struct net_device *netdev)
1971{
1972	struct hns_nic_priv *priv = netdev_priv(netdev);
1973
1974	struct hnae_handle *h = priv->ae_handle;
1975
1976	if (h->phy_dev) {
1977		if (h->phy_if != PHY_INTERFACE_MODE_XGMII)
1978			return;
1979
1980		(void)genphy_read_status(h->phy_dev);
1981	}
1982	hns_nic_adjust_link(netdev);
1983}
1984
1985/* for dumping key regs*/
1986static void hns_nic_dump(struct hns_nic_priv *priv)
1987{
1988	struct hnae_handle *h = priv->ae_handle;
1989	struct hnae_ae_ops *ops = h->dev->ops;
1990	u32 *data, reg_num, i;
1991
1992	if (ops->get_regs_len && ops->get_regs) {
1993		reg_num = ops->get_regs_len(priv->ae_handle);
1994		reg_num = (reg_num + 3ul) & ~3ul;
1995		data = kcalloc(reg_num, sizeof(u32), GFP_KERNEL);
1996		if (data) {
1997			ops->get_regs(priv->ae_handle, data);
1998			for (i = 0; i < reg_num; i += 4)
1999				pr_info("0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
2000					i, data[i], data[i + 1],
2001					data[i + 2], data[i + 3]);
2002			kfree(data);
2003		}
2004	}
2005
2006	for (i = 0; i < h->q_num; i++) {
2007		pr_info("tx_queue%d_next_to_clean:%d\n",
2008			i, h->qs[i]->tx_ring.next_to_clean);
2009		pr_info("tx_queue%d_next_to_use:%d\n",
2010			i, h->qs[i]->tx_ring.next_to_use);
2011		pr_info("rx_queue%d_next_to_clean:%d\n",
2012			i, h->qs[i]->rx_ring.next_to_clean);
2013		pr_info("rx_queue%d_next_to_use:%d\n",
2014			i, h->qs[i]->rx_ring.next_to_use);
2015	}
2016}
2017
2018/* for resetting subtask */
2019static void hns_nic_reset_subtask(struct hns_nic_priv *priv)
2020{
2021	enum hnae_port_type type = priv->ae_handle->port_type;
2022
2023	if (!test_bit(NIC_STATE2_RESET_REQUESTED, &priv->state))
2024		return;
2025	clear_bit(NIC_STATE2_RESET_REQUESTED, &priv->state);
2026
2027	/* If we're already down, removing or resetting, just bail */
2028	if (test_bit(NIC_STATE_DOWN, &priv->state) ||
2029	    test_bit(NIC_STATE_REMOVING, &priv->state) ||
2030	    test_bit(NIC_STATE_RESETTING, &priv->state))
2031		return;
2032
2033	hns_nic_dump(priv);
2034	netdev_info(priv->netdev, "try to reset %s port!\n",
2035		    (type == HNAE_PORT_DEBUG ? "debug" : "service"));
2036
2037	rtnl_lock();
2038	/* put off any impending NetWatchDogTimeout */
2039	netif_trans_update(priv->netdev);
2040	hns_nic_net_reinit(priv->netdev);
2041
2042	rtnl_unlock();
2043}
2044
2045/* for doing service complete*/
2046static void hns_nic_service_event_complete(struct hns_nic_priv *priv)
2047{
2048	WARN_ON(!test_bit(NIC_STATE_SERVICE_SCHED, &priv->state));
2049	/* make sure to commit the things */
2050	smp_mb__before_atomic();
2051	clear_bit(NIC_STATE_SERVICE_SCHED, &priv->state);
2052}
2053
2054static void hns_nic_service_task(struct work_struct *work)
2055{
2056	struct hns_nic_priv *priv
2057		= container_of(work, struct hns_nic_priv, service_task);
2058	struct hnae_handle *h = priv->ae_handle;
2059
2060	hns_nic_reset_subtask(priv);
2061	hns_nic_update_link_status(priv->netdev);
2062	h->dev->ops->update_led_status(h);
2063	hns_nic_update_stats(priv->netdev);
2064
2065	hns_nic_service_event_complete(priv);
2066}
2067
2068static void hns_nic_task_schedule(struct hns_nic_priv *priv)
2069{
2070	if (!test_bit(NIC_STATE_DOWN, &priv->state) &&
2071	    !test_bit(NIC_STATE_REMOVING, &priv->state) &&
2072	    !test_and_set_bit(NIC_STATE_SERVICE_SCHED, &priv->state))
2073		(void)schedule_work(&priv->service_task);
2074}
2075
2076static void hns_nic_service_timer(struct timer_list *t)
2077{
2078	struct hns_nic_priv *priv = from_timer(priv, t, service_timer);
2079
2080	(void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ);
2081
2082	hns_nic_task_schedule(priv);
2083}
2084
2085/**
2086 * hns_tx_timeout_reset - initiate reset due to Tx timeout
2087 * @priv: driver private struct
2088 **/
2089static void hns_tx_timeout_reset(struct hns_nic_priv *priv)
2090{
2091	/* Do the reset outside of interrupt context */
2092	if (!test_bit(NIC_STATE_DOWN, &priv->state)) {
2093		set_bit(NIC_STATE2_RESET_REQUESTED, &priv->state);
2094		netdev_warn(priv->netdev,
2095			    "initiating reset due to tx timeout(%llu,0x%lx)\n",
2096			    priv->tx_timeout_count, priv->state);
2097		priv->tx_timeout_count++;
2098		hns_nic_task_schedule(priv);
2099	}
2100}
2101
2102static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
2103{
2104	struct hnae_handle *h = priv->ae_handle;
2105	struct hns_nic_ring_data *rd;
2106	bool is_ver1 = AE_IS_VER1(priv->enet_ver);
2107	int i;
2108
2109	if (h->q_num > NIC_MAX_Q_PER_VF) {
2110		netdev_err(priv->netdev, "too much queue (%d)\n", h->q_num);
2111		return -EINVAL;
2112	}
2113
2114	priv->ring_data = kzalloc(array3_size(h->q_num,
2115					      sizeof(*priv->ring_data), 2),
2116				  GFP_KERNEL);
2117	if (!priv->ring_data)
2118		return -ENOMEM;
2119
2120	for (i = 0; i < h->q_num; i++) {
2121		rd = &priv->ring_data[i];
2122		rd->queue_index = i;
2123		rd->ring = &h->qs[i]->tx_ring;
2124		rd->poll_one = hns_nic_tx_poll_one;
2125		rd->fini_process = is_ver1 ? hns_nic_tx_fini_pro :
2126			hns_nic_tx_fini_pro_v2;
2127
2128		netif_napi_add(priv->netdev, &rd->napi, hns_nic_common_poll);
 
2129		rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
2130	}
2131	for (i = h->q_num; i < h->q_num * 2; i++) {
2132		rd = &priv->ring_data[i];
2133		rd->queue_index = i - h->q_num;
2134		rd->ring = &h->qs[i - h->q_num]->rx_ring;
2135		rd->poll_one = hns_nic_rx_poll_one;
2136		rd->ex_process = hns_nic_rx_up_pro;
2137		rd->fini_process = is_ver1 ? hns_nic_rx_fini_pro :
2138			hns_nic_rx_fini_pro_v2;
2139
2140		netif_napi_add(priv->netdev, &rd->napi, hns_nic_common_poll);
 
2141		rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
2142	}
2143
2144	return 0;
2145}
2146
2147static void hns_nic_uninit_ring_data(struct hns_nic_priv *priv)
2148{
2149	struct hnae_handle *h = priv->ae_handle;
2150	int i;
2151
2152	for (i = 0; i < h->q_num * 2; i++) {
2153		netif_napi_del(&priv->ring_data[i].napi);
2154		if (priv->ring_data[i].ring->irq_init_flag == RCB_IRQ_INITED) {
2155			(void)irq_set_affinity_hint(
2156				priv->ring_data[i].ring->irq,
2157				NULL);
2158			free_irq(priv->ring_data[i].ring->irq,
2159				 &priv->ring_data[i]);
2160		}
2161
2162		priv->ring_data[i].ring->irq_init_flag = RCB_IRQ_NOT_INITED;
2163	}
2164	kfree(priv->ring_data);
2165}
2166
2167static void hns_nic_set_priv_ops(struct net_device *netdev)
2168{
2169	struct hns_nic_priv *priv = netdev_priv(netdev);
2170	struct hnae_handle *h = priv->ae_handle;
2171
2172	if (AE_IS_VER1(priv->enet_ver)) {
2173		priv->ops.fill_desc = fill_desc;
2174		priv->ops.get_rxd_bnum = get_rx_desc_bnum;
2175		priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tx;
2176	} else {
2177		priv->ops.get_rxd_bnum = get_v2rx_desc_bnum;
2178		priv->ops.fill_desc = fill_desc_v2;
2179		priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tx_v2;
2180		netif_set_tso_max_size(netdev, 7 * 4096);
 
 
 
 
 
 
 
2181		/* enable tso when init
2182		 * control tso on/off through TSE bit in bd
2183		 */
2184		h->dev->ops->set_tso_stats(h, 1);
2185	}
2186}
2187
2188static int hns_nic_try_get_ae(struct net_device *ndev)
2189{
2190	struct hns_nic_priv *priv = netdev_priv(ndev);
2191	struct hnae_handle *h;
2192	int ret;
2193
2194	h = hnae_get_handle(&priv->netdev->dev,
2195			    priv->fwnode, priv->port_id, NULL);
2196	if (IS_ERR_OR_NULL(h)) {
2197		ret = -ENODEV;
2198		dev_dbg(priv->dev, "has not handle, register notifier!\n");
2199		goto out;
2200	}
2201	priv->ae_handle = h;
2202
2203	ret = hns_nic_init_phy(ndev, h);
2204	if (ret) {
2205		dev_err(priv->dev, "probe phy device fail!\n");
2206		goto out_init_phy;
2207	}
2208
2209	ret = hns_nic_init_ring_data(priv);
2210	if (ret) {
2211		ret = -ENOMEM;
2212		goto out_init_ring_data;
2213	}
2214
2215	hns_nic_set_priv_ops(ndev);
2216
2217	ret = register_netdev(ndev);
2218	if (ret) {
2219		dev_err(priv->dev, "probe register netdev fail!\n");
2220		goto out_reg_ndev_fail;
2221	}
2222	return 0;
2223
2224out_reg_ndev_fail:
2225	hns_nic_uninit_ring_data(priv);
2226	priv->ring_data = NULL;
2227out_init_phy:
2228out_init_ring_data:
2229	hnae_put_handle(priv->ae_handle);
2230	priv->ae_handle = NULL;
2231out:
2232	return ret;
2233}
2234
2235static int hns_nic_notifier_action(struct notifier_block *nb,
2236				   unsigned long action, void *data)
2237{
2238	struct hns_nic_priv *priv =
2239		container_of(nb, struct hns_nic_priv, notifier_block);
2240
2241	assert(action == HNAE_AE_REGISTER);
2242
2243	if (!hns_nic_try_get_ae(priv->netdev)) {
2244		hnae_unregister_notifier(&priv->notifier_block);
2245		priv->notifier_block.notifier_call = NULL;
2246	}
2247	return 0;
2248}
2249
2250static int hns_nic_dev_probe(struct platform_device *pdev)
2251{
2252	struct device *dev = &pdev->dev;
2253	struct net_device *ndev;
2254	struct hns_nic_priv *priv;
2255	u32 port_id;
2256	int ret;
2257
2258	ndev = alloc_etherdev_mq(sizeof(struct hns_nic_priv), NIC_MAX_Q_PER_VF);
2259	if (!ndev)
2260		return -ENOMEM;
2261
2262	platform_set_drvdata(pdev, ndev);
2263
2264	priv = netdev_priv(ndev);
2265	priv->dev = dev;
2266	priv->netdev = ndev;
2267
2268	if (dev_of_node(dev)) {
2269		struct device_node *ae_node;
2270
2271		if (of_device_is_compatible(dev->of_node,
2272					    "hisilicon,hns-nic-v1"))
2273			priv->enet_ver = AE_VERSION_1;
2274		else
2275			priv->enet_ver = AE_VERSION_2;
2276
2277		ae_node = of_parse_phandle(dev->of_node, "ae-handle", 0);
2278		if (!ae_node) {
2279			ret = -ENODEV;
2280			dev_err(dev, "not find ae-handle\n");
2281			goto out_read_prop_fail;
2282		}
2283		priv->fwnode = &ae_node->fwnode;
2284	} else if (is_acpi_node(dev->fwnode)) {
2285		struct fwnode_reference_args args;
2286
2287		if (acpi_dev_found(hns_enet_acpi_match[0].id))
2288			priv->enet_ver = AE_VERSION_1;
2289		else if (acpi_dev_found(hns_enet_acpi_match[1].id))
2290			priv->enet_ver = AE_VERSION_2;
2291		else {
2292			ret = -ENXIO;
2293			goto out_read_prop_fail;
2294		}
2295
2296		/* try to find port-idx-in-ae first */
2297		ret = acpi_node_get_property_reference(dev->fwnode,
2298						       "ae-handle", 0, &args);
2299		if (ret) {
2300			dev_err(dev, "not find ae-handle\n");
2301			goto out_read_prop_fail;
2302		}
2303		if (!is_acpi_device_node(args.fwnode)) {
2304			ret = -EINVAL;
2305			goto out_read_prop_fail;
2306		}
2307		priv->fwnode = args.fwnode;
2308	} else {
2309		dev_err(dev, "cannot read cfg data from OF or acpi\n");
2310		ret = -ENXIO;
2311		goto out_read_prop_fail;
2312	}
2313
2314	ret = device_property_read_u32(dev, "port-idx-in-ae", &port_id);
2315	if (ret) {
2316		/* only for old code compatible */
2317		ret = device_property_read_u32(dev, "port-id", &port_id);
2318		if (ret)
2319			goto out_read_prop_fail;
2320		/* for old dts, we need to caculate the port offset */
2321		port_id = port_id < HNS_SRV_OFFSET ? port_id + HNS_DEBUG_OFFSET
2322			: port_id - HNS_SRV_OFFSET;
2323	}
2324	priv->port_id = port_id;
2325
2326	hns_init_mac_addr(ndev);
2327
2328	ndev->watchdog_timeo = HNS_NIC_TX_TIMEOUT;
2329	ndev->priv_flags |= IFF_UNICAST_FLT;
2330	ndev->netdev_ops = &hns_nic_netdev_ops;
2331	hns_ethtool_set_ops(ndev);
2332
2333	ndev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2334		NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO |
2335		NETIF_F_GRO;
2336	ndev->vlan_features |=
2337		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM;
2338	ndev->vlan_features |= NETIF_F_SG | NETIF_F_GSO | NETIF_F_GRO;
2339
2340	/* MTU range: 68 - 9578 (v1) or 9706 (v2) */
2341	ndev->min_mtu = MAC_MIN_MTU;
2342	switch (priv->enet_ver) {
2343	case AE_VERSION_2:
2344		ndev->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_NTUPLE;
2345		ndev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2346			NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO |
2347			NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6;
2348		ndev->vlan_features |= NETIF_F_TSO | NETIF_F_TSO6;
2349		ndev->max_mtu = MAC_MAX_MTU_V2 -
2350				(ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
2351		break;
2352	default:
2353		ndev->max_mtu = MAC_MAX_MTU -
2354				(ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
2355		break;
2356	}
2357
2358	SET_NETDEV_DEV(ndev, dev);
2359
2360	if (!dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)))
2361		dev_dbg(dev, "set mask to 64bit\n");
2362	else
2363		dev_err(dev, "set mask to 64bit fail!\n");
2364
2365	/* carrier off reporting is important to ethtool even BEFORE open */
2366	netif_carrier_off(ndev);
2367
2368	timer_setup(&priv->service_timer, hns_nic_service_timer, 0);
2369	INIT_WORK(&priv->service_task, hns_nic_service_task);
2370
2371	set_bit(NIC_STATE_SERVICE_INITED, &priv->state);
2372	clear_bit(NIC_STATE_SERVICE_SCHED, &priv->state);
2373	set_bit(NIC_STATE_DOWN, &priv->state);
2374
2375	if (hns_nic_try_get_ae(priv->netdev)) {
2376		priv->notifier_block.notifier_call = hns_nic_notifier_action;
2377		ret = hnae_register_notifier(&priv->notifier_block);
2378		if (ret) {
2379			dev_err(dev, "register notifier fail!\n");
2380			goto out_notify_fail;
2381		}
2382		dev_dbg(dev, "has not handle, register notifier!\n");
2383	}
2384
2385	return 0;
2386
2387out_notify_fail:
2388	(void)cancel_work_sync(&priv->service_task);
2389out_read_prop_fail:
2390	/* safe for ACPI FW */
2391	of_node_put(to_of_node(priv->fwnode));
2392	free_netdev(ndev);
2393	return ret;
2394}
2395
2396static void hns_nic_dev_remove(struct platform_device *pdev)
2397{
2398	struct net_device *ndev = platform_get_drvdata(pdev);
2399	struct hns_nic_priv *priv = netdev_priv(ndev);
2400
2401	if (ndev->reg_state != NETREG_UNINITIALIZED)
2402		unregister_netdev(ndev);
2403
2404	if (priv->ring_data)
2405		hns_nic_uninit_ring_data(priv);
2406	priv->ring_data = NULL;
2407
2408	if (ndev->phydev)
2409		phy_disconnect(ndev->phydev);
2410
2411	if (!IS_ERR_OR_NULL(priv->ae_handle))
2412		hnae_put_handle(priv->ae_handle);
2413	priv->ae_handle = NULL;
2414	if (priv->notifier_block.notifier_call)
2415		hnae_unregister_notifier(&priv->notifier_block);
2416	priv->notifier_block.notifier_call = NULL;
2417
2418	set_bit(NIC_STATE_REMOVING, &priv->state);
2419	(void)cancel_work_sync(&priv->service_task);
2420
2421	/* safe for ACPI FW */
2422	of_node_put(to_of_node(priv->fwnode));
2423
2424	free_netdev(ndev);
 
2425}
2426
2427static const struct of_device_id hns_enet_of_match[] = {
2428	{.compatible = "hisilicon,hns-nic-v1",},
2429	{.compatible = "hisilicon,hns-nic-v2",},
2430	{},
2431};
2432
2433MODULE_DEVICE_TABLE(of, hns_enet_of_match);
2434
2435static struct platform_driver hns_nic_dev_driver = {
2436	.driver = {
2437		.name = "hns-nic",
2438		.of_match_table = hns_enet_of_match,
2439		.acpi_match_table = ACPI_PTR(hns_enet_acpi_match),
2440	},
2441	.probe = hns_nic_dev_probe,
2442	.remove_new = hns_nic_dev_remove,
2443};
2444
2445module_platform_driver(hns_nic_dev_driver);
2446
2447MODULE_DESCRIPTION("HISILICON HNS Ethernet driver");
2448MODULE_AUTHOR("Hisilicon, Inc.");
2449MODULE_LICENSE("GPL");
2450MODULE_ALIAS("platform:hns-nic");