1 /* 2 * Copyright (c) 2014-2015 Hisilicon Limited. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 */ 9 10 #include <linux/clk.h> 11 #include <linux/cpumask.h> 12 #include <linux/etherdevice.h> 13 #include <linux/if_vlan.h> 14 #include <linux/interrupt.h> 15 #include <linux/io.h> 16 #include <linux/ip.h> 17 #include <linux/ipv6.h> 18 #include <linux/module.h> 19 #include <linux/phy.h> 20 #include <linux/platform_device.h> 21 #include <linux/skbuff.h> 22 23 #include "hnae.h" 24 #include "hns_enet.h" 25 26 #define NIC_MAX_Q_PER_VF 16 27 #define HNS_NIC_TX_TIMEOUT (5 * HZ) 28 29 #define SERVICE_TIMER_HZ (1 * HZ) 30 31 #define NIC_TX_CLEAN_MAX_NUM 256 32 #define NIC_RX_CLEAN_MAX_NUM 64 33 34 #define RCB_IRQ_NOT_INITED 0 35 #define RCB_IRQ_INITED 1 36 #define HNS_BUFFER_SIZE_2048 2048 37 38 #define BD_MAX_SEND_SIZE 8191 39 #define SKB_TMP_LEN(SKB) \ 40 (((SKB)->transport_header - (SKB)->mac_header) + tcp_hdrlen(SKB)) 41 42 static void fill_v2_desc(struct hnae_ring *ring, void *priv, 43 int size, dma_addr_t dma, int frag_end, 44 int buf_num, enum hns_desc_type type, int mtu) 45 { 46 struct hnae_desc *desc = &ring->desc[ring->next_to_use]; 47 struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_use]; 48 struct iphdr *iphdr; 49 struct ipv6hdr *ipv6hdr; 50 struct sk_buff *skb; 51 __be16 protocol; 52 u8 bn_pid = 0; 53 u8 rrcfv = 0; 54 u8 ip_offset = 0; 55 u8 tvsvsn = 0; 56 u16 mss = 0; 57 u8 l4_len = 0; 58 u16 paylen = 0; 59 60 desc_cb->priv = priv; 61 desc_cb->length = size; 62 desc_cb->dma = dma; 63 desc_cb->type = type; 64 65 desc->addr = cpu_to_le64(dma); 66 desc->tx.send_size = cpu_to_le16((u16)size); 67 68 /* config bd buffer end */ 69 hnae_set_bit(rrcfv, HNSV2_TXD_VLD_B, 1); 70 hnae_set_field(bn_pid, HNSV2_TXD_BUFNUM_M, 0, buf_num - 1); 71 72 /* fill port_id in the tx bd for sending management pkts */ 73 hnae_set_field(bn_pid, HNSV2_TXD_PORTID_M, 74 HNSV2_TXD_PORTID_S, ring->q->handle->dport_id); 75 76 if (type == DESC_TYPE_SKB) { 77 skb = (struct sk_buff *)priv; 78 79 if (skb->ip_summed == CHECKSUM_PARTIAL) { 80 skb_reset_mac_len(skb); 81 protocol = skb->protocol; 82 ip_offset = ETH_HLEN; 83 84 if (protocol == htons(ETH_P_8021Q)) { 85 ip_offset += VLAN_HLEN; 86 protocol = vlan_get_protocol(skb); 87 skb->protocol = protocol; 88 } 89 90 if (skb->protocol == htons(ETH_P_IP)) { 91 iphdr = ip_hdr(skb); 92 hnae_set_bit(rrcfv, HNSV2_TXD_L3CS_B, 1); 93 hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1); 94 95 /* check for tcp/udp header */ 96 if (iphdr->protocol == IPPROTO_TCP && 97 skb_is_gso(skb)) { 98 hnae_set_bit(tvsvsn, 99 HNSV2_TXD_TSE_B, 1); 100 l4_len = tcp_hdrlen(skb); 101 mss = skb_shinfo(skb)->gso_size; 102 paylen = skb->len - SKB_TMP_LEN(skb); 103 } 104 } else if (skb->protocol == htons(ETH_P_IPV6)) { 105 hnae_set_bit(tvsvsn, HNSV2_TXD_IPV6_B, 1); 106 ipv6hdr = ipv6_hdr(skb); 107 hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1); 108 109 /* check for tcp/udp header */ 110 if (ipv6hdr->nexthdr == IPPROTO_TCP && 111 skb_is_gso(skb) && skb_is_gso_v6(skb)) { 112 hnae_set_bit(tvsvsn, 113 HNSV2_TXD_TSE_B, 1); 114 l4_len = tcp_hdrlen(skb); 115 mss = skb_shinfo(skb)->gso_size; 116 paylen = skb->len - SKB_TMP_LEN(skb); 117 } 118 } 119 desc->tx.ip_offset = ip_offset; 120 desc->tx.tse_vlan_snap_v6_sctp_nth = tvsvsn; 121 desc->tx.mss = cpu_to_le16(mss); 122 desc->tx.l4_len = l4_len; 123 desc->tx.paylen = cpu_to_le16(paylen); 124 } 125 } 126 127 hnae_set_bit(rrcfv, HNSV2_TXD_FE_B, frag_end); 128 129 desc->tx.bn_pid = bn_pid; 130 desc->tx.ra_ri_cs_fe_vld = rrcfv; 131 132 ring_ptr_move_fw(ring, next_to_use); 133 } 134 135 static void fill_desc(struct hnae_ring *ring, void *priv, 136 int size, dma_addr_t dma, int frag_end, 137 int buf_num, enum hns_desc_type type, int mtu) 138 { 139 struct hnae_desc *desc = &ring->desc[ring->next_to_use]; 140 struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_use]; 141 struct sk_buff *skb; 142 __be16 protocol; 143 u32 ip_offset; 144 u32 asid_bufnum_pid = 0; 145 u32 flag_ipoffset = 0; 146 147 desc_cb->priv = priv; 148 desc_cb->length = size; 149 desc_cb->dma = dma; 150 desc_cb->type = type; 151 152 desc->addr = cpu_to_le64(dma); 153 desc->tx.send_size = cpu_to_le16((u16)size); 154 155 /*config bd buffer end */ 156 flag_ipoffset |= 1 << HNS_TXD_VLD_B; 157 158 asid_bufnum_pid |= buf_num << HNS_TXD_BUFNUM_S; 159 160 if (type == DESC_TYPE_SKB) { 161 skb = (struct sk_buff *)priv; 162 163 if (skb->ip_summed == CHECKSUM_PARTIAL) { 164 protocol = skb->protocol; 165 ip_offset = ETH_HLEN; 166 167 /*if it is a SW VLAN check the next protocol*/ 168 if (protocol == htons(ETH_P_8021Q)) { 169 ip_offset += VLAN_HLEN; 170 protocol = vlan_get_protocol(skb); 171 skb->protocol = protocol; 172 } 173 174 if (skb->protocol == htons(ETH_P_IP)) { 175 flag_ipoffset |= 1 << HNS_TXD_L3CS_B; 176 /* check for tcp/udp header */ 177 flag_ipoffset |= 1 << HNS_TXD_L4CS_B; 178 179 } else if (skb->protocol == htons(ETH_P_IPV6)) { 180 /* ipv6 has not l3 cs, check for L4 header */ 181 flag_ipoffset |= 1 << HNS_TXD_L4CS_B; 182 } 183 184 flag_ipoffset |= ip_offset << HNS_TXD_IPOFFSET_S; 185 } 186 } 187 188 flag_ipoffset |= frag_end << HNS_TXD_FE_B; 189 190 desc->tx.asid_bufnum_pid = cpu_to_le16(asid_bufnum_pid); 191 desc->tx.flag_ipoffset = cpu_to_le32(flag_ipoffset); 192 193 ring_ptr_move_fw(ring, next_to_use); 194 } 195 196 static void unfill_desc(struct hnae_ring *ring) 197 { 198 ring_ptr_move_bw(ring, next_to_use); 199 } 200 201 static int hns_nic_maybe_stop_tx( 202 struct sk_buff **out_skb, int *bnum, struct hnae_ring *ring) 203 { 204 struct sk_buff *skb = *out_skb; 205 struct sk_buff *new_skb = NULL; 206 int buf_num; 207 208 /* no. of segments (plus a header) */ 209 buf_num = skb_shinfo(skb)->nr_frags + 1; 210 211 if (unlikely(buf_num > ring->max_desc_num_per_pkt)) { 212 if (ring_space(ring) < 1) 213 return -EBUSY; 214 215 new_skb = skb_copy(skb, GFP_ATOMIC); 216 if (!new_skb) 217 return -ENOMEM; 218 219 dev_kfree_skb_any(skb); 220 *out_skb = new_skb; 221 buf_num = 1; 222 } else if (buf_num > ring_space(ring)) { 223 return -EBUSY; 224 } 225 226 *bnum = buf_num; 227 return 0; 228 } 229 230 static int hns_nic_maybe_stop_tso( 231 struct sk_buff **out_skb, int *bnum, struct hnae_ring *ring) 232 { 233 int i; 234 int size; 235 int buf_num; 236 int frag_num; 237 struct sk_buff *skb = *out_skb; 238 struct sk_buff *new_skb = NULL; 239 struct skb_frag_struct *frag; 240 241 size = skb_headlen(skb); 242 buf_num = (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE; 243 244 frag_num = skb_shinfo(skb)->nr_frags; 245 for (i = 0; i < frag_num; i++) { 246 frag = &skb_shinfo(skb)->frags[i]; 247 size = skb_frag_size(frag); 248 buf_num += (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE; 249 } 250 251 if (unlikely(buf_num > ring->max_desc_num_per_pkt)) { 252 buf_num = (skb->len + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE; 253 if (ring_space(ring) < buf_num) 254 return -EBUSY; 255 /* manual split the send packet */ 256 new_skb = skb_copy(skb, GFP_ATOMIC); 257 if (!new_skb) 258 return -ENOMEM; 259 dev_kfree_skb_any(skb); 260 *out_skb = new_skb; 261 262 } else if (ring_space(ring) < buf_num) { 263 return -EBUSY; 264 } 265 266 *bnum = buf_num; 267 return 0; 268 } 269 270 static void fill_tso_desc(struct hnae_ring *ring, void *priv, 271 int size, dma_addr_t dma, int frag_end, 272 int buf_num, enum hns_desc_type type, int mtu) 273 { 274 int frag_buf_num; 275 int sizeoflast; 276 int k; 277 278 frag_buf_num = (size + BD_MAX_SEND_SIZE - 1) / BD_MAX_SEND_SIZE; 279 sizeoflast = size % BD_MAX_SEND_SIZE; 280 sizeoflast = sizeoflast ? sizeoflast : BD_MAX_SEND_SIZE; 281 282 /* when the frag size is bigger than hardware, split this frag */ 283 for (k = 0; k < frag_buf_num; k++) 284 fill_v2_desc(ring, priv, 285 (k == frag_buf_num - 1) ? 286 sizeoflast : BD_MAX_SEND_SIZE, 287 dma + BD_MAX_SEND_SIZE * k, 288 frag_end && (k == frag_buf_num - 1) ? 1 : 0, 289 buf_num, 290 (type == DESC_TYPE_SKB && !k) ? 291 DESC_TYPE_SKB : DESC_TYPE_PAGE, 292 mtu); 293 } 294 295 int hns_nic_net_xmit_hw(struct net_device *ndev, 296 struct sk_buff *skb, 297 struct hns_nic_ring_data *ring_data) 298 { 299 struct hns_nic_priv *priv = netdev_priv(ndev); 300 struct device *dev = priv->dev; 301 struct hnae_ring *ring = ring_data->ring; 302 struct netdev_queue *dev_queue; 303 struct skb_frag_struct *frag; 304 int buf_num; 305 int seg_num; 306 dma_addr_t dma; 307 int size, next_to_use; 308 int i; 309 310 switch (priv->ops.maybe_stop_tx(&skb, &buf_num, ring)) { 311 case -EBUSY: 312 ring->stats.tx_busy++; 313 goto out_net_tx_busy; 314 case -ENOMEM: 315 ring->stats.sw_err_cnt++; 316 netdev_err(ndev, "no memory to xmit!\n"); 317 goto out_err_tx_ok; 318 default: 319 break; 320 } 321 322 /* no. of segments (plus a header) */ 323 seg_num = skb_shinfo(skb)->nr_frags + 1; 324 next_to_use = ring->next_to_use; 325 326 /* fill the first part */ 327 size = skb_headlen(skb); 328 dma = dma_map_single(dev, skb->data, size, DMA_TO_DEVICE); 329 if (dma_mapping_error(dev, dma)) { 330 netdev_err(ndev, "TX head DMA map failed\n"); 331 ring->stats.sw_err_cnt++; 332 goto out_err_tx_ok; 333 } 334 priv->ops.fill_desc(ring, skb, size, dma, seg_num == 1 ? 1 : 0, 335 buf_num, DESC_TYPE_SKB, ndev->mtu); 336 337 /* fill the fragments */ 338 for (i = 1; i < seg_num; i++) { 339 frag = &skb_shinfo(skb)->frags[i - 1]; 340 size = skb_frag_size(frag); 341 dma = skb_frag_dma_map(dev, frag, 0, size, DMA_TO_DEVICE); 342 if (dma_mapping_error(dev, dma)) { 343 netdev_err(ndev, "TX frag(%d) DMA map failed\n", i); 344 ring->stats.sw_err_cnt++; 345 goto out_map_frag_fail; 346 } 347 priv->ops.fill_desc(ring, skb_frag_page(frag), size, dma, 348 seg_num - 1 == i ? 1 : 0, buf_num, 349 DESC_TYPE_PAGE, ndev->mtu); 350 } 351 352 /*complete translate all packets*/ 353 dev_queue = netdev_get_tx_queue(ndev, skb->queue_mapping); 354 netdev_tx_sent_queue(dev_queue, skb->len); 355 356 wmb(); /* commit all data before submit */ 357 assert(skb->queue_mapping < priv->ae_handle->q_num); 358 hnae_queue_xmit(priv->ae_handle->qs[skb->queue_mapping], buf_num); 359 ring->stats.tx_pkts++; 360 ring->stats.tx_bytes += skb->len; 361 362 return NETDEV_TX_OK; 363 364 out_map_frag_fail: 365 366 while (ring->next_to_use != next_to_use) { 367 unfill_desc(ring); 368 if (ring->next_to_use != next_to_use) 369 dma_unmap_page(dev, 370 ring->desc_cb[ring->next_to_use].dma, 371 ring->desc_cb[ring->next_to_use].length, 372 DMA_TO_DEVICE); 373 else 374 dma_unmap_single(dev, 375 ring->desc_cb[next_to_use].dma, 376 ring->desc_cb[next_to_use].length, 377 DMA_TO_DEVICE); 378 } 379 380 out_err_tx_ok: 381 382 dev_kfree_skb_any(skb); 383 return NETDEV_TX_OK; 384 385 out_net_tx_busy: 386 387 netif_stop_subqueue(ndev, skb->queue_mapping); 388 389 /* Herbert's original patch had: 390 * smp_mb__after_netif_stop_queue(); 391 * but since that doesn't exist yet, just open code it. 392 */ 393 smp_mb(); 394 return NETDEV_TX_BUSY; 395 } 396 397 /** 398 * hns_nic_get_headlen - determine size of header for RSC/LRO/GRO/FCOE 399 * @data: pointer to the start of the headers 400 * @max: total length of section to find headers in 401 * 402 * This function is meant to determine the length of headers that will 403 * be recognized by hardware for LRO, GRO, and RSC offloads. The main 404 * motivation of doing this is to only perform one pull for IPv4 TCP 405 * packets so that we can do basic things like calculating the gso_size 406 * based on the average data per packet. 407 **/ 408 static unsigned int hns_nic_get_headlen(unsigned char *data, u32 flag, 409 unsigned int max_size) 410 { 411 unsigned char *network; 412 u8 hlen; 413 414 /* this should never happen, but better safe than sorry */ 415 if (max_size < ETH_HLEN) 416 return max_size; 417 418 /* initialize network frame pointer */ 419 network = data; 420 421 /* set first protocol and move network header forward */ 422 network += ETH_HLEN; 423 424 /* handle any vlan tag if present */ 425 if (hnae_get_field(flag, HNS_RXD_VLAN_M, HNS_RXD_VLAN_S) 426 == HNS_RX_FLAG_VLAN_PRESENT) { 427 if ((typeof(max_size))(network - data) > (max_size - VLAN_HLEN)) 428 return max_size; 429 430 network += VLAN_HLEN; 431 } 432 433 /* handle L3 protocols */ 434 if (hnae_get_field(flag, HNS_RXD_L3ID_M, HNS_RXD_L3ID_S) 435 == HNS_RX_FLAG_L3ID_IPV4) { 436 if ((typeof(max_size))(network - data) > 437 (max_size - sizeof(struct iphdr))) 438 return max_size; 439 440 /* access ihl as a u8 to avoid unaligned access on ia64 */ 441 hlen = (network[0] & 0x0F) << 2; 442 443 /* verify hlen meets minimum size requirements */ 444 if (hlen < sizeof(struct iphdr)) 445 return network - data; 446 447 /* record next protocol if header is present */ 448 } else if (hnae_get_field(flag, HNS_RXD_L3ID_M, HNS_RXD_L3ID_S) 449 == HNS_RX_FLAG_L3ID_IPV6) { 450 if ((typeof(max_size))(network - data) > 451 (max_size - sizeof(struct ipv6hdr))) 452 return max_size; 453 454 /* record next protocol */ 455 hlen = sizeof(struct ipv6hdr); 456 } else { 457 return network - data; 458 } 459 460 /* relocate pointer to start of L4 header */ 461 network += hlen; 462 463 /* finally sort out TCP/UDP */ 464 if (hnae_get_field(flag, HNS_RXD_L4ID_M, HNS_RXD_L4ID_S) 465 == HNS_RX_FLAG_L4ID_TCP) { 466 if ((typeof(max_size))(network - data) > 467 (max_size - sizeof(struct tcphdr))) 468 return max_size; 469 470 /* access doff as a u8 to avoid unaligned access on ia64 */ 471 hlen = (network[12] & 0xF0) >> 2; 472 473 /* verify hlen meets minimum size requirements */ 474 if (hlen < sizeof(struct tcphdr)) 475 return network - data; 476 477 network += hlen; 478 } else if (hnae_get_field(flag, HNS_RXD_L4ID_M, HNS_RXD_L4ID_S) 479 == HNS_RX_FLAG_L4ID_UDP) { 480 if ((typeof(max_size))(network - data) > 481 (max_size - sizeof(struct udphdr))) 482 return max_size; 483 484 network += sizeof(struct udphdr); 485 } 486 487 /* If everything has gone correctly network should be the 488 * data section of the packet and will be the end of the header. 489 * If not then it probably represents the end of the last recognized 490 * header. 491 */ 492 if ((typeof(max_size))(network - data) < max_size) 493 return network - data; 494 else 495 return max_size; 496 } 497 498 static void hns_nic_reuse_page(struct sk_buff *skb, int i, 499 struct hnae_ring *ring, int pull_len, 500 struct hnae_desc_cb *desc_cb) 501 { 502 struct hnae_desc *desc; 503 int truesize, size; 504 int last_offset; 505 bool twobufs; 506 507 twobufs = ((PAGE_SIZE < 8192) && hnae_buf_size(ring) == HNS_BUFFER_SIZE_2048); 508 509 desc = &ring->desc[ring->next_to_clean]; 510 size = le16_to_cpu(desc->rx.size); 511 512 if (twobufs) { 513 truesize = hnae_buf_size(ring); 514 } else { 515 truesize = ALIGN(size, L1_CACHE_BYTES); 516 last_offset = hnae_page_size(ring) - hnae_buf_size(ring); 517 } 518 519 skb_add_rx_frag(skb, i, desc_cb->priv, desc_cb->page_offset + pull_len, 520 size - pull_len, truesize - pull_len); 521 522 /* avoid re-using remote pages,flag default unreuse */ 523 if (unlikely(page_to_nid(desc_cb->priv) != numa_node_id())) 524 return; 525 526 if (twobufs) { 527 /* if we are only owner of page we can reuse it */ 528 if (likely(page_count(desc_cb->priv) == 1)) { 529 /* flip page offset to other buffer */ 530 desc_cb->page_offset ^= truesize; 531 532 desc_cb->reuse_flag = 1; 533 /* bump ref count on page before it is given*/ 534 get_page(desc_cb->priv); 535 } 536 return; 537 } 538 539 /* move offset up to the next cache line */ 540 desc_cb->page_offset += truesize; 541 542 if (desc_cb->page_offset <= last_offset) { 543 desc_cb->reuse_flag = 1; 544 /* bump ref count on page before it is given*/ 545 get_page(desc_cb->priv); 546 } 547 } 548 549 static void get_v2rx_desc_bnum(u32 bnum_flag, int *out_bnum) 550 { 551 *out_bnum = hnae_get_field(bnum_flag, 552 HNS_RXD_BUFNUM_M, HNS_RXD_BUFNUM_S) + 1; 553 } 554 555 static void get_rx_desc_bnum(u32 bnum_flag, int *out_bnum) 556 { 557 *out_bnum = hnae_get_field(bnum_flag, 558 HNS_RXD_BUFNUM_M, HNS_RXD_BUFNUM_S); 559 } 560 561 static int hns_nic_poll_rx_skb(struct hns_nic_ring_data *ring_data, 562 struct sk_buff **out_skb, int *out_bnum) 563 { 564 struct hnae_ring *ring = ring_data->ring; 565 struct net_device *ndev = ring_data->napi.dev; 566 struct hns_nic_priv *priv = netdev_priv(ndev); 567 struct sk_buff *skb; 568 struct hnae_desc *desc; 569 struct hnae_desc_cb *desc_cb; 570 struct ethhdr *eh; 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 prefetch(va); 585 #if L1_CACHE_BYTES < 128 586 prefetch(va + L1_CACHE_BYTES); 587 #endif 588 589 skb = *out_skb = napi_alloc_skb(&ring_data->napi, 590 HNS_RX_HEAD_SIZE); 591 if (unlikely(!skb)) { 592 netdev_err(ndev, "alloc rx skb fail\n"); 593 ring->stats.sw_err_cnt++; 594 return -ENOMEM; 595 } 596 597 prefetchw(skb->data); 598 length = le16_to_cpu(desc->rx.pkt_len); 599 bnum_flag = le32_to_cpu(desc->rx.ipoff_bnum_pid_flag); 600 priv->ops.get_rxd_bnum(bnum_flag, &bnum); 601 *out_bnum = bnum; 602 603 if (length <= HNS_RX_HEAD_SIZE) { 604 memcpy(__skb_put(skb, length), va, ALIGN(length, sizeof(long))); 605 606 /* we can reuse buffer as-is, just make sure it is local */ 607 if (likely(page_to_nid(desc_cb->priv) == numa_node_id())) 608 desc_cb->reuse_flag = 1; 609 else /* this page cannot be reused so discard it */ 610 put_page(desc_cb->priv); 611 612 ring_ptr_move_fw(ring, next_to_clean); 613 614 if (unlikely(bnum != 1)) { /* check err*/ 615 *out_bnum = 1; 616 goto out_bnum_err; 617 } 618 } else { 619 ring->stats.seg_pkt_cnt++; 620 621 pull_len = hns_nic_get_headlen(va, bnum_flag, HNS_RX_HEAD_SIZE); 622 memcpy(__skb_put(skb, pull_len), va, 623 ALIGN(pull_len, sizeof(long))); 624 625 hns_nic_reuse_page(skb, 0, ring, pull_len, desc_cb); 626 ring_ptr_move_fw(ring, next_to_clean); 627 628 if (unlikely(bnum >= (int)MAX_SKB_FRAGS)) { /* check err*/ 629 *out_bnum = 1; 630 goto out_bnum_err; 631 } 632 for (i = 1; i < bnum; i++) { 633 desc = &ring->desc[ring->next_to_clean]; 634 desc_cb = &ring->desc_cb[ring->next_to_clean]; 635 636 hns_nic_reuse_page(skb, i, ring, 0, desc_cb); 637 ring_ptr_move_fw(ring, next_to_clean); 638 } 639 } 640 641 /* check except process, free skb and jump the desc */ 642 if (unlikely((!bnum) || (bnum > ring->max_desc_num_per_pkt))) { 643 out_bnum_err: 644 *out_bnum = *out_bnum ? *out_bnum : 1; /* ntc moved,cannot 0*/ 645 netdev_err(ndev, "invalid bnum(%d,%d,%d,%d),%016llx,%016llx\n", 646 bnum, ring->max_desc_num_per_pkt, 647 length, (int)MAX_SKB_FRAGS, 648 ((u64 *)desc)[0], ((u64 *)desc)[1]); 649 ring->stats.err_bd_num++; 650 dev_kfree_skb_any(skb); 651 return -EDOM; 652 } 653 654 bnum_flag = le32_to_cpu(desc->rx.ipoff_bnum_pid_flag); 655 656 if (unlikely(!hnae_get_bit(bnum_flag, HNS_RXD_VLD_B))) { 657 netdev_err(ndev, "no valid bd,%016llx,%016llx\n", 658 ((u64 *)desc)[0], ((u64 *)desc)[1]); 659 ring->stats.non_vld_descs++; 660 dev_kfree_skb_any(skb); 661 return -EINVAL; 662 } 663 664 if (unlikely((!desc->rx.pkt_len) || 665 hnae_get_bit(bnum_flag, HNS_RXD_DROP_B))) { 666 ring->stats.err_pkt_len++; 667 dev_kfree_skb_any(skb); 668 return -EFAULT; 669 } 670 671 if (unlikely(hnae_get_bit(bnum_flag, HNS_RXD_L2E_B))) { 672 ring->stats.l2_err++; 673 dev_kfree_skb_any(skb); 674 return -EFAULT; 675 } 676 677 /* filter out multicast pkt with the same src mac as this port */ 678 eh = eth_hdr(skb); 679 if (unlikely(is_multicast_ether_addr(eh->h_dest) && 680 ether_addr_equal(ndev->dev_addr, eh->h_source))) { 681 dev_kfree_skb_any(skb); 682 return -EFAULT; 683 } 684 685 ring->stats.rx_pkts++; 686 ring->stats.rx_bytes += skb->len; 687 688 if (unlikely(hnae_get_bit(bnum_flag, HNS_RXD_L3E_B) || 689 hnae_get_bit(bnum_flag, HNS_RXD_L4E_B))) { 690 ring->stats.l3l4_csum_err++; 691 return 0; 692 } 693 694 skb->ip_summed = CHECKSUM_UNNECESSARY; 695 696 return 0; 697 } 698 699 static void 700 hns_nic_alloc_rx_buffers(struct hns_nic_ring_data *ring_data, int cleand_count) 701 { 702 int i, ret; 703 struct hnae_desc_cb res_cbs; 704 struct hnae_desc_cb *desc_cb; 705 struct hnae_ring *ring = ring_data->ring; 706 struct net_device *ndev = ring_data->napi.dev; 707 708 for (i = 0; i < cleand_count; i++) { 709 desc_cb = &ring->desc_cb[ring->next_to_use]; 710 if (desc_cb->reuse_flag) { 711 ring->stats.reuse_pg_cnt++; 712 hnae_reuse_buffer(ring, ring->next_to_use); 713 } else { 714 ret = hnae_reserve_buffer_map(ring, &res_cbs); 715 if (ret) { 716 ring->stats.sw_err_cnt++; 717 netdev_err(ndev, "hnae reserve buffer map failed.\n"); 718 break; 719 } 720 hnae_replace_buffer(ring, ring->next_to_use, &res_cbs); 721 } 722 723 ring_ptr_move_fw(ring, next_to_use); 724 } 725 726 wmb(); /* make all data has been write before submit */ 727 writel_relaxed(i, ring->io_base + RCB_REG_HEAD); 728 } 729 730 /* return error number for error or number of desc left to take 731 */ 732 static void hns_nic_rx_up_pro(struct hns_nic_ring_data *ring_data, 733 struct sk_buff *skb) 734 { 735 struct net_device *ndev = ring_data->napi.dev; 736 737 skb->protocol = eth_type_trans(skb, ndev); 738 (void)napi_gro_receive(&ring_data->napi, skb); 739 ndev->last_rx = jiffies; 740 } 741 742 static int hns_nic_rx_poll_one(struct hns_nic_ring_data *ring_data, 743 int budget, void *v) 744 { 745 struct hnae_ring *ring = ring_data->ring; 746 struct sk_buff *skb; 747 int num, bnum, ex_num; 748 #define RCB_NOF_ALLOC_RX_BUFF_ONCE 16 749 int recv_pkts, recv_bds, clean_count, err; 750 751 num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM); 752 rmb(); /* make sure num taken effect before the other data is touched */ 753 754 recv_pkts = 0, recv_bds = 0, clean_count = 0; 755 recv: 756 while (recv_pkts < budget && recv_bds < num) { 757 /* reuse or realloc buffers*/ 758 if (clean_count >= RCB_NOF_ALLOC_RX_BUFF_ONCE) { 759 hns_nic_alloc_rx_buffers(ring_data, clean_count); 760 clean_count = 0; 761 } 762 763 /* poll one pkg*/ 764 err = hns_nic_poll_rx_skb(ring_data, &skb, &bnum); 765 if (unlikely(!skb)) /* this fault cannot be repaired */ 766 break; 767 768 recv_bds += bnum; 769 clean_count += bnum; 770 if (unlikely(err)) { /* do jump the err */ 771 recv_pkts++; 772 continue; 773 } 774 775 /* do update ip stack process*/ 776 ((void (*)(struct hns_nic_ring_data *, struct sk_buff *))v)( 777 ring_data, skb); 778 recv_pkts++; 779 } 780 781 /* make all data has been write before submit */ 782 if (recv_pkts < budget) { 783 ex_num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM); 784 785 if (ex_num > clean_count) { 786 num += ex_num - clean_count; 787 rmb(); /*complete read rx ring bd number*/ 788 goto recv; 789 } 790 } 791 792 /* make all data has been write before submit */ 793 if (clean_count > 0) 794 hns_nic_alloc_rx_buffers(ring_data, clean_count); 795 796 return recv_pkts; 797 } 798 799 static void hns_nic_rx_fini_pro(struct hns_nic_ring_data *ring_data) 800 { 801 struct hnae_ring *ring = ring_data->ring; 802 int num = 0; 803 804 /* for hardware bug fixed */ 805 num = readl_relaxed(ring->io_base + RCB_REG_FBDNUM); 806 807 if (num > 0) { 808 ring_data->ring->q->handle->dev->ops->toggle_ring_irq( 809 ring_data->ring, 1); 810 811 napi_schedule(&ring_data->napi); 812 } 813 } 814 815 static inline void hns_nic_reclaim_one_desc(struct hnae_ring *ring, 816 int *bytes, int *pkts) 817 { 818 struct hnae_desc_cb *desc_cb = &ring->desc_cb[ring->next_to_clean]; 819 820 (*pkts) += (desc_cb->type == DESC_TYPE_SKB); 821 (*bytes) += desc_cb->length; 822 /* desc_cb will be cleaned, after hnae_free_buffer_detach*/ 823 hnae_free_buffer_detach(ring, ring->next_to_clean); 824 825 ring_ptr_move_fw(ring, next_to_clean); 826 } 827 828 static int is_valid_clean_head(struct hnae_ring *ring, int h) 829 { 830 int u = ring->next_to_use; 831 int c = ring->next_to_clean; 832 833 if (unlikely(h > ring->desc_num)) 834 return 0; 835 836 assert(u > 0 && u < ring->desc_num); 837 assert(c > 0 && c < ring->desc_num); 838 assert(u != c && h != c); /* must be checked before call this func */ 839 840 return u > c ? (h > c && h <= u) : (h > c || h <= u); 841 } 842 843 /* netif_tx_lock will turn down the performance, set only when necessary */ 844 #ifdef CONFIG_NET_POLL_CONTROLLER 845 #define NETIF_TX_LOCK(ndev) netif_tx_lock(ndev) 846 #define NETIF_TX_UNLOCK(ndev) netif_tx_unlock(ndev) 847 #else 848 #define NETIF_TX_LOCK(ndev) 849 #define NETIF_TX_UNLOCK(ndev) 850 #endif 851 /* reclaim all desc in one budget 852 * return error or number of desc left 853 */ 854 static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data, 855 int budget, void *v) 856 { 857 struct hnae_ring *ring = ring_data->ring; 858 struct net_device *ndev = ring_data->napi.dev; 859 struct netdev_queue *dev_queue; 860 struct hns_nic_priv *priv = netdev_priv(ndev); 861 int head; 862 int bytes, pkts; 863 864 NETIF_TX_LOCK(ndev); 865 866 head = readl_relaxed(ring->io_base + RCB_REG_HEAD); 867 rmb(); /* make sure head is ready before touch any data */ 868 869 if (is_ring_empty(ring) || head == ring->next_to_clean) { 870 NETIF_TX_UNLOCK(ndev); 871 return 0; /* no data to poll */ 872 } 873 874 if (!is_valid_clean_head(ring, head)) { 875 netdev_err(ndev, "wrong head (%d, %d-%d)\n", head, 876 ring->next_to_use, ring->next_to_clean); 877 ring->stats.io_err_cnt++; 878 NETIF_TX_UNLOCK(ndev); 879 return -EIO; 880 } 881 882 bytes = 0; 883 pkts = 0; 884 while (head != ring->next_to_clean) { 885 hns_nic_reclaim_one_desc(ring, &bytes, &pkts); 886 /* issue prefetch for next Tx descriptor */ 887 prefetch(&ring->desc_cb[ring->next_to_clean]); 888 } 889 890 NETIF_TX_UNLOCK(ndev); 891 892 dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index); 893 netdev_tx_completed_queue(dev_queue, pkts, bytes); 894 895 if (unlikely(priv->link && !netif_carrier_ok(ndev))) 896 netif_carrier_on(ndev); 897 898 if (unlikely(pkts && netif_carrier_ok(ndev) && 899 (ring_space(ring) >= ring->max_desc_num_per_pkt * 2))) { 900 /* Make sure that anybody stopping the queue after this 901 * sees the new next_to_clean. 902 */ 903 smp_mb(); 904 if (netif_tx_queue_stopped(dev_queue) && 905 !test_bit(NIC_STATE_DOWN, &priv->state)) { 906 netif_tx_wake_queue(dev_queue); 907 ring->stats.restart_queue++; 908 } 909 } 910 return 0; 911 } 912 913 static void hns_nic_tx_fini_pro(struct hns_nic_ring_data *ring_data) 914 { 915 struct hnae_ring *ring = ring_data->ring; 916 int head = ring->next_to_clean; 917 918 /* for hardware bug fixed */ 919 head = readl_relaxed(ring->io_base + RCB_REG_HEAD); 920 921 if (head != ring->next_to_clean) { 922 ring_data->ring->q->handle->dev->ops->toggle_ring_irq( 923 ring_data->ring, 1); 924 925 napi_schedule(&ring_data->napi); 926 } 927 } 928 929 static void hns_nic_tx_clr_all_bufs(struct hns_nic_ring_data *ring_data) 930 { 931 struct hnae_ring *ring = ring_data->ring; 932 struct net_device *ndev = ring_data->napi.dev; 933 struct netdev_queue *dev_queue; 934 int head; 935 int bytes, pkts; 936 937 NETIF_TX_LOCK(ndev); 938 939 head = ring->next_to_use; /* ntu :soft setted ring position*/ 940 bytes = 0; 941 pkts = 0; 942 while (head != ring->next_to_clean) 943 hns_nic_reclaim_one_desc(ring, &bytes, &pkts); 944 945 NETIF_TX_UNLOCK(ndev); 946 947 dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index); 948 netdev_tx_reset_queue(dev_queue); 949 } 950 951 static int hns_nic_common_poll(struct napi_struct *napi, int budget) 952 { 953 struct hns_nic_ring_data *ring_data = 954 container_of(napi, struct hns_nic_ring_data, napi); 955 int clean_complete = ring_data->poll_one( 956 ring_data, budget, ring_data->ex_process); 957 958 if (clean_complete >= 0 && clean_complete < budget) { 959 napi_complete(napi); 960 ring_data->ring->q->handle->dev->ops->toggle_ring_irq( 961 ring_data->ring, 0); 962 963 ring_data->fini_process(ring_data); 964 return 0; 965 } 966 967 return clean_complete; 968 } 969 970 static irqreturn_t hns_irq_handle(int irq, void *dev) 971 { 972 struct hns_nic_ring_data *ring_data = (struct hns_nic_ring_data *)dev; 973 974 ring_data->ring->q->handle->dev->ops->toggle_ring_irq( 975 ring_data->ring, 1); 976 napi_schedule(&ring_data->napi); 977 978 return IRQ_HANDLED; 979 } 980 981 /** 982 *hns_nic_adjust_link - adjust net work mode by the phy stat or new param 983 *@ndev: net device 984 */ 985 static void hns_nic_adjust_link(struct net_device *ndev) 986 { 987 struct hns_nic_priv *priv = netdev_priv(ndev); 988 struct hnae_handle *h = priv->ae_handle; 989 990 h->dev->ops->adjust_link(h, ndev->phydev->speed, ndev->phydev->duplex); 991 } 992 993 /** 994 *hns_nic_init_phy - init phy 995 *@ndev: net device 996 *@h: ae handle 997 * Return 0 on success, negative on failure 998 */ 999 int hns_nic_init_phy(struct net_device *ndev, struct hnae_handle *h) 1000 { 1001 struct hns_nic_priv *priv = netdev_priv(ndev); 1002 struct phy_device *phy_dev = NULL; 1003 1004 if (!h->phy_node) 1005 return 0; 1006 1007 if (h->phy_if != PHY_INTERFACE_MODE_XGMII) 1008 phy_dev = of_phy_connect(ndev, h->phy_node, 1009 hns_nic_adjust_link, 0, h->phy_if); 1010 else 1011 phy_dev = of_phy_attach(ndev, h->phy_node, 0, h->phy_if); 1012 1013 if (unlikely(!phy_dev) || IS_ERR(phy_dev)) 1014 return !phy_dev ? -ENODEV : PTR_ERR(phy_dev); 1015 1016 phy_dev->supported &= h->if_support; 1017 phy_dev->advertising = phy_dev->supported; 1018 1019 if (h->phy_if == PHY_INTERFACE_MODE_XGMII) 1020 phy_dev->autoneg = false; 1021 1022 priv->phy = phy_dev; 1023 1024 return 0; 1025 } 1026 1027 static int hns_nic_ring_open(struct net_device *netdev, int idx) 1028 { 1029 struct hns_nic_priv *priv = netdev_priv(netdev); 1030 struct hnae_handle *h = priv->ae_handle; 1031 1032 napi_enable(&priv->ring_data[idx].napi); 1033 1034 enable_irq(priv->ring_data[idx].ring->irq); 1035 h->dev->ops->toggle_ring_irq(priv->ring_data[idx].ring, 0); 1036 1037 return 0; 1038 } 1039 1040 static int hns_nic_net_set_mac_address(struct net_device *ndev, void *p) 1041 { 1042 struct hns_nic_priv *priv = netdev_priv(ndev); 1043 struct hnae_handle *h = priv->ae_handle; 1044 struct sockaddr *mac_addr = p; 1045 int ret; 1046 1047 if (!mac_addr || !is_valid_ether_addr((const u8 *)mac_addr->sa_data)) 1048 return -EADDRNOTAVAIL; 1049 1050 ret = h->dev->ops->set_mac_addr(h, mac_addr->sa_data); 1051 if (ret) { 1052 netdev_err(ndev, "set_mac_address fail, ret=%d!\n", ret); 1053 return ret; 1054 } 1055 1056 memcpy(ndev->dev_addr, mac_addr->sa_data, ndev->addr_len); 1057 1058 return 0; 1059 } 1060 1061 void hns_nic_update_stats(struct net_device *netdev) 1062 { 1063 struct hns_nic_priv *priv = netdev_priv(netdev); 1064 struct hnae_handle *h = priv->ae_handle; 1065 1066 h->dev->ops->update_stats(h, &netdev->stats); 1067 } 1068 1069 /* set mac addr if it is configed. or leave it to the AE driver */ 1070 static void hns_init_mac_addr(struct net_device *ndev) 1071 { 1072 struct hns_nic_priv *priv = netdev_priv(ndev); 1073 struct device_node *node = priv->dev->of_node; 1074 const void *mac_addr_temp; 1075 1076 mac_addr_temp = of_get_mac_address(node); 1077 if (mac_addr_temp && is_valid_ether_addr(mac_addr_temp)) { 1078 memcpy(ndev->dev_addr, mac_addr_temp, ndev->addr_len); 1079 } else { 1080 eth_hw_addr_random(ndev); 1081 dev_warn(priv->dev, "No valid mac, use random mac %pM", 1082 ndev->dev_addr); 1083 } 1084 } 1085 1086 static void hns_nic_ring_close(struct net_device *netdev, int idx) 1087 { 1088 struct hns_nic_priv *priv = netdev_priv(netdev); 1089 struct hnae_handle *h = priv->ae_handle; 1090 1091 h->dev->ops->toggle_ring_irq(priv->ring_data[idx].ring, 1); 1092 disable_irq(priv->ring_data[idx].ring->irq); 1093 1094 napi_disable(&priv->ring_data[idx].napi); 1095 } 1096 1097 static void hns_set_irq_affinity(struct hns_nic_priv *priv) 1098 { 1099 struct hnae_handle *h = priv->ae_handle; 1100 struct hns_nic_ring_data *rd; 1101 int i; 1102 int cpu; 1103 cpumask_t mask; 1104 1105 /*diffrent irq banlance for 16core and 32core*/ 1106 if (h->q_num == num_possible_cpus()) { 1107 for (i = 0; i < h->q_num * 2; i++) { 1108 rd = &priv->ring_data[i]; 1109 if (cpu_online(rd->queue_index)) { 1110 cpumask_clear(&mask); 1111 cpu = rd->queue_index; 1112 cpumask_set_cpu(cpu, &mask); 1113 (void)irq_set_affinity_hint(rd->ring->irq, 1114 &mask); 1115 } 1116 } 1117 } else { 1118 for (i = 0; i < h->q_num; i++) { 1119 rd = &priv->ring_data[i]; 1120 if (cpu_online(rd->queue_index * 2)) { 1121 cpumask_clear(&mask); 1122 cpu = rd->queue_index * 2; 1123 cpumask_set_cpu(cpu, &mask); 1124 (void)irq_set_affinity_hint(rd->ring->irq, 1125 &mask); 1126 } 1127 } 1128 1129 for (i = h->q_num; i < h->q_num * 2; i++) { 1130 rd = &priv->ring_data[i]; 1131 if (cpu_online(rd->queue_index * 2 + 1)) { 1132 cpumask_clear(&mask); 1133 cpu = rd->queue_index * 2 + 1; 1134 cpumask_set_cpu(cpu, &mask); 1135 (void)irq_set_affinity_hint(rd->ring->irq, 1136 &mask); 1137 } 1138 } 1139 } 1140 } 1141 1142 static int hns_nic_init_irq(struct hns_nic_priv *priv) 1143 { 1144 struct hnae_handle *h = priv->ae_handle; 1145 struct hns_nic_ring_data *rd; 1146 int i; 1147 int ret; 1148 1149 for (i = 0; i < h->q_num * 2; i++) { 1150 rd = &priv->ring_data[i]; 1151 1152 if (rd->ring->irq_init_flag == RCB_IRQ_INITED) 1153 break; 1154 1155 snprintf(rd->ring->ring_name, RCB_RING_NAME_LEN, 1156 "%s-%s%d", priv->netdev->name, 1157 (i < h->q_num ? "tx" : "rx"), rd->queue_index); 1158 1159 rd->ring->ring_name[RCB_RING_NAME_LEN - 1] = '\0'; 1160 1161 ret = request_irq(rd->ring->irq, 1162 hns_irq_handle, 0, rd->ring->ring_name, rd); 1163 if (ret) { 1164 netdev_err(priv->netdev, "request irq(%d) fail\n", 1165 rd->ring->irq); 1166 return ret; 1167 } 1168 disable_irq(rd->ring->irq); 1169 rd->ring->irq_init_flag = RCB_IRQ_INITED; 1170 } 1171 1172 /*set cpu affinity*/ 1173 hns_set_irq_affinity(priv); 1174 1175 return 0; 1176 } 1177 1178 static int hns_nic_net_up(struct net_device *ndev) 1179 { 1180 struct hns_nic_priv *priv = netdev_priv(ndev); 1181 struct hnae_handle *h = priv->ae_handle; 1182 int i, j, k; 1183 int ret; 1184 1185 ret = hns_nic_init_irq(priv); 1186 if (ret != 0) { 1187 netdev_err(ndev, "hns init irq failed! ret=%d\n", ret); 1188 return ret; 1189 } 1190 1191 for (i = 0; i < h->q_num * 2; i++) { 1192 ret = hns_nic_ring_open(ndev, i); 1193 if (ret) 1194 goto out_has_some_queues; 1195 } 1196 1197 for (k = 0; k < h->q_num; k++) 1198 h->dev->ops->toggle_queue_status(h->qs[k], 1); 1199 1200 ret = h->dev->ops->set_mac_addr(h, ndev->dev_addr); 1201 if (ret) 1202 goto out_set_mac_addr_err; 1203 1204 ret = h->dev->ops->start ? h->dev->ops->start(h) : 0; 1205 if (ret) 1206 goto out_start_err; 1207 1208 if (priv->phy) 1209 phy_start(priv->phy); 1210 1211 clear_bit(NIC_STATE_DOWN, &priv->state); 1212 (void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ); 1213 1214 return 0; 1215 1216 out_start_err: 1217 netif_stop_queue(ndev); 1218 out_set_mac_addr_err: 1219 for (k = 0; k < h->q_num; k++) 1220 h->dev->ops->toggle_queue_status(h->qs[k], 0); 1221 out_has_some_queues: 1222 for (j = i - 1; j >= 0; j--) 1223 hns_nic_ring_close(ndev, j); 1224 1225 set_bit(NIC_STATE_DOWN, &priv->state); 1226 1227 return ret; 1228 } 1229 1230 static void hns_nic_net_down(struct net_device *ndev) 1231 { 1232 int i; 1233 struct hnae_ae_ops *ops; 1234 struct hns_nic_priv *priv = netdev_priv(ndev); 1235 1236 if (test_and_set_bit(NIC_STATE_DOWN, &priv->state)) 1237 return; 1238 1239 (void)del_timer_sync(&priv->service_timer); 1240 netif_tx_stop_all_queues(ndev); 1241 netif_carrier_off(ndev); 1242 netif_tx_disable(ndev); 1243 priv->link = 0; 1244 1245 if (priv->phy) 1246 phy_stop(priv->phy); 1247 1248 ops = priv->ae_handle->dev->ops; 1249 1250 if (ops->stop) 1251 ops->stop(priv->ae_handle); 1252 1253 netif_tx_stop_all_queues(ndev); 1254 1255 for (i = priv->ae_handle->q_num - 1; i >= 0; i--) { 1256 hns_nic_ring_close(ndev, i); 1257 hns_nic_ring_close(ndev, i + priv->ae_handle->q_num); 1258 1259 /* clean tx buffers*/ 1260 hns_nic_tx_clr_all_bufs(priv->ring_data + i); 1261 } 1262 } 1263 1264 void hns_nic_net_reset(struct net_device *ndev) 1265 { 1266 struct hns_nic_priv *priv = netdev_priv(ndev); 1267 struct hnae_handle *handle = priv->ae_handle; 1268 1269 while (test_and_set_bit(NIC_STATE_RESETTING, &priv->state)) 1270 usleep_range(1000, 2000); 1271 1272 (void)hnae_reinit_handle(handle); 1273 1274 clear_bit(NIC_STATE_RESETTING, &priv->state); 1275 } 1276 1277 void hns_nic_net_reinit(struct net_device *netdev) 1278 { 1279 struct hns_nic_priv *priv = netdev_priv(netdev); 1280 1281 priv->netdev->trans_start = jiffies; 1282 while (test_and_set_bit(NIC_STATE_REINITING, &priv->state)) 1283 usleep_range(1000, 2000); 1284 1285 hns_nic_net_down(netdev); 1286 hns_nic_net_reset(netdev); 1287 (void)hns_nic_net_up(netdev); 1288 clear_bit(NIC_STATE_REINITING, &priv->state); 1289 } 1290 1291 static int hns_nic_net_open(struct net_device *ndev) 1292 { 1293 struct hns_nic_priv *priv = netdev_priv(ndev); 1294 struct hnae_handle *h = priv->ae_handle; 1295 int ret; 1296 1297 if (test_bit(NIC_STATE_TESTING, &priv->state)) 1298 return -EBUSY; 1299 1300 priv->link = 0; 1301 netif_carrier_off(ndev); 1302 1303 ret = netif_set_real_num_tx_queues(ndev, h->q_num); 1304 if (ret < 0) { 1305 netdev_err(ndev, "netif_set_real_num_tx_queues fail, ret=%d!\n", 1306 ret); 1307 return ret; 1308 } 1309 1310 ret = netif_set_real_num_rx_queues(ndev, h->q_num); 1311 if (ret < 0) { 1312 netdev_err(ndev, 1313 "netif_set_real_num_rx_queues fail, ret=%d!\n", ret); 1314 return ret; 1315 } 1316 1317 ret = hns_nic_net_up(ndev); 1318 if (ret) { 1319 netdev_err(ndev, 1320 "hns net up fail, ret=%d!\n", ret); 1321 return ret; 1322 } 1323 1324 return 0; 1325 } 1326 1327 static int hns_nic_net_stop(struct net_device *ndev) 1328 { 1329 hns_nic_net_down(ndev); 1330 1331 return 0; 1332 } 1333 1334 static void hns_tx_timeout_reset(struct hns_nic_priv *priv); 1335 static void hns_nic_net_timeout(struct net_device *ndev) 1336 { 1337 struct hns_nic_priv *priv = netdev_priv(ndev); 1338 1339 hns_tx_timeout_reset(priv); 1340 } 1341 1342 static int hns_nic_do_ioctl(struct net_device *netdev, struct ifreq *ifr, 1343 int cmd) 1344 { 1345 struct hns_nic_priv *priv = netdev_priv(netdev); 1346 struct phy_device *phy_dev = priv->phy; 1347 1348 if (!netif_running(netdev)) 1349 return -EINVAL; 1350 1351 if (!phy_dev) 1352 return -ENOTSUPP; 1353 1354 return phy_mii_ioctl(phy_dev, ifr, cmd); 1355 } 1356 1357 /* use only for netconsole to poll with the device without interrupt */ 1358 #ifdef CONFIG_NET_POLL_CONTROLLER 1359 void hns_nic_poll_controller(struct net_device *ndev) 1360 { 1361 struct hns_nic_priv *priv = netdev_priv(ndev); 1362 unsigned long flags; 1363 int i; 1364 1365 local_irq_save(flags); 1366 for (i = 0; i < priv->ae_handle->q_num * 2; i++) 1367 napi_schedule(&priv->ring_data[i].napi); 1368 local_irq_restore(flags); 1369 } 1370 #endif 1371 1372 static netdev_tx_t hns_nic_net_xmit(struct sk_buff *skb, 1373 struct net_device *ndev) 1374 { 1375 struct hns_nic_priv *priv = netdev_priv(ndev); 1376 int ret; 1377 1378 assert(skb->queue_mapping < ndev->ae_handle->q_num); 1379 ret = hns_nic_net_xmit_hw(ndev, skb, 1380 &tx_ring_data(priv, skb->queue_mapping)); 1381 if (ret == NETDEV_TX_OK) { 1382 ndev->trans_start = jiffies; 1383 ndev->stats.tx_bytes += skb->len; 1384 ndev->stats.tx_packets++; 1385 } 1386 return (netdev_tx_t)ret; 1387 } 1388 1389 static int hns_nic_change_mtu(struct net_device *ndev, int new_mtu) 1390 { 1391 struct hns_nic_priv *priv = netdev_priv(ndev); 1392 struct hnae_handle *h = priv->ae_handle; 1393 int ret; 1394 1395 /* MTU < 68 is an error and causes problems on some kernels */ 1396 if (new_mtu < 68) 1397 return -EINVAL; 1398 1399 if (!h->dev->ops->set_mtu) 1400 return -ENOTSUPP; 1401 1402 if (netif_running(ndev)) { 1403 (void)hns_nic_net_stop(ndev); 1404 msleep(100); 1405 1406 ret = h->dev->ops->set_mtu(h, new_mtu); 1407 if (ret) 1408 netdev_err(ndev, "set mtu fail, return value %d\n", 1409 ret); 1410 1411 if (hns_nic_net_open(ndev)) 1412 netdev_err(ndev, "hns net open fail\n"); 1413 } else { 1414 ret = h->dev->ops->set_mtu(h, new_mtu); 1415 } 1416 1417 if (!ret) 1418 ndev->mtu = new_mtu; 1419 1420 return ret; 1421 } 1422 1423 static int hns_nic_set_features(struct net_device *netdev, 1424 netdev_features_t features) 1425 { 1426 struct hns_nic_priv *priv = netdev_priv(netdev); 1427 struct hnae_handle *h = priv->ae_handle; 1428 1429 switch (priv->enet_ver) { 1430 case AE_VERSION_1: 1431 if (features & (NETIF_F_TSO | NETIF_F_TSO6)) 1432 netdev_info(netdev, "enet v1 do not support tso!\n"); 1433 break; 1434 default: 1435 if (features & (NETIF_F_TSO | NETIF_F_TSO6)) { 1436 priv->ops.fill_desc = fill_tso_desc; 1437 priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tso; 1438 /* The chip only support 7*4096 */ 1439 netif_set_gso_max_size(netdev, 7 * 4096); 1440 h->dev->ops->set_tso_stats(h, 1); 1441 } else { 1442 priv->ops.fill_desc = fill_v2_desc; 1443 priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tx; 1444 h->dev->ops->set_tso_stats(h, 0); 1445 } 1446 break; 1447 } 1448 netdev->features = features; 1449 return 0; 1450 } 1451 1452 static netdev_features_t hns_nic_fix_features( 1453 struct net_device *netdev, netdev_features_t features) 1454 { 1455 struct hns_nic_priv *priv = netdev_priv(netdev); 1456 1457 switch (priv->enet_ver) { 1458 case AE_VERSION_1: 1459 features &= ~(NETIF_F_TSO | NETIF_F_TSO6 | 1460 NETIF_F_HW_VLAN_CTAG_FILTER); 1461 break; 1462 default: 1463 break; 1464 } 1465 return features; 1466 } 1467 1468 /** 1469 * nic_set_multicast_list - set mutl mac address 1470 * @netdev: net device 1471 * @p: mac address 1472 * 1473 * return void 1474 */ 1475 void hns_set_multicast_list(struct net_device *ndev) 1476 { 1477 struct hns_nic_priv *priv = netdev_priv(ndev); 1478 struct hnae_handle *h = priv->ae_handle; 1479 struct netdev_hw_addr *ha = NULL; 1480 1481 if (!h) { 1482 netdev_err(ndev, "hnae handle is null\n"); 1483 return; 1484 } 1485 1486 if (h->dev->ops->set_mc_addr) { 1487 netdev_for_each_mc_addr(ha, ndev) 1488 if (h->dev->ops->set_mc_addr(h, ha->addr)) 1489 netdev_err(ndev, "set multicast fail\n"); 1490 } 1491 } 1492 1493 void hns_nic_set_rx_mode(struct net_device *ndev) 1494 { 1495 struct hns_nic_priv *priv = netdev_priv(ndev); 1496 struct hnae_handle *h = priv->ae_handle; 1497 1498 if (h->dev->ops->set_promisc_mode) { 1499 if (ndev->flags & IFF_PROMISC) 1500 h->dev->ops->set_promisc_mode(h, 1); 1501 else 1502 h->dev->ops->set_promisc_mode(h, 0); 1503 } 1504 1505 hns_set_multicast_list(ndev); 1506 } 1507 1508 struct rtnl_link_stats64 *hns_nic_get_stats64(struct net_device *ndev, 1509 struct rtnl_link_stats64 *stats) 1510 { 1511 int idx = 0; 1512 u64 tx_bytes = 0; 1513 u64 rx_bytes = 0; 1514 u64 tx_pkts = 0; 1515 u64 rx_pkts = 0; 1516 struct hns_nic_priv *priv = netdev_priv(ndev); 1517 struct hnae_handle *h = priv->ae_handle; 1518 1519 for (idx = 0; idx < h->q_num; idx++) { 1520 tx_bytes += h->qs[idx]->tx_ring.stats.tx_bytes; 1521 tx_pkts += h->qs[idx]->tx_ring.stats.tx_pkts; 1522 rx_bytes += h->qs[idx]->rx_ring.stats.rx_bytes; 1523 rx_pkts += h->qs[idx]->rx_ring.stats.rx_pkts; 1524 } 1525 1526 stats->tx_bytes = tx_bytes; 1527 stats->tx_packets = tx_pkts; 1528 stats->rx_bytes = rx_bytes; 1529 stats->rx_packets = rx_pkts; 1530 1531 stats->rx_errors = ndev->stats.rx_errors; 1532 stats->multicast = ndev->stats.multicast; 1533 stats->rx_length_errors = ndev->stats.rx_length_errors; 1534 stats->rx_crc_errors = ndev->stats.rx_crc_errors; 1535 stats->rx_missed_errors = ndev->stats.rx_missed_errors; 1536 1537 stats->tx_errors = ndev->stats.tx_errors; 1538 stats->rx_dropped = ndev->stats.rx_dropped; 1539 stats->tx_dropped = ndev->stats.tx_dropped; 1540 stats->collisions = ndev->stats.collisions; 1541 stats->rx_over_errors = ndev->stats.rx_over_errors; 1542 stats->rx_frame_errors = ndev->stats.rx_frame_errors; 1543 stats->rx_fifo_errors = ndev->stats.rx_fifo_errors; 1544 stats->tx_aborted_errors = ndev->stats.tx_aborted_errors; 1545 stats->tx_carrier_errors = ndev->stats.tx_carrier_errors; 1546 stats->tx_fifo_errors = ndev->stats.tx_fifo_errors; 1547 stats->tx_heartbeat_errors = ndev->stats.tx_heartbeat_errors; 1548 stats->tx_window_errors = ndev->stats.tx_window_errors; 1549 stats->rx_compressed = ndev->stats.rx_compressed; 1550 stats->tx_compressed = ndev->stats.tx_compressed; 1551 1552 return stats; 1553 } 1554 1555 static const struct net_device_ops hns_nic_netdev_ops = { 1556 .ndo_open = hns_nic_net_open, 1557 .ndo_stop = hns_nic_net_stop, 1558 .ndo_start_xmit = hns_nic_net_xmit, 1559 .ndo_tx_timeout = hns_nic_net_timeout, 1560 .ndo_set_mac_address = hns_nic_net_set_mac_address, 1561 .ndo_change_mtu = hns_nic_change_mtu, 1562 .ndo_do_ioctl = hns_nic_do_ioctl, 1563 .ndo_set_features = hns_nic_set_features, 1564 .ndo_fix_features = hns_nic_fix_features, 1565 .ndo_get_stats64 = hns_nic_get_stats64, 1566 #ifdef CONFIG_NET_POLL_CONTROLLER 1567 .ndo_poll_controller = hns_nic_poll_controller, 1568 #endif 1569 .ndo_set_rx_mode = hns_nic_set_rx_mode, 1570 }; 1571 1572 static void hns_nic_update_link_status(struct net_device *netdev) 1573 { 1574 struct hns_nic_priv *priv = netdev_priv(netdev); 1575 1576 struct hnae_handle *h = priv->ae_handle; 1577 int state = 1; 1578 1579 if (priv->phy) { 1580 if (!genphy_update_link(priv->phy)) 1581 state = priv->phy->link; 1582 else 1583 state = 0; 1584 } 1585 state = state && h->dev->ops->get_status(h); 1586 1587 if (state != priv->link) { 1588 if (state) { 1589 netif_carrier_on(netdev); 1590 netif_tx_wake_all_queues(netdev); 1591 netdev_info(netdev, "link up\n"); 1592 } else { 1593 netif_carrier_off(netdev); 1594 netdev_info(netdev, "link down\n"); 1595 } 1596 priv->link = state; 1597 } 1598 } 1599 1600 /* for dumping key regs*/ 1601 static void hns_nic_dump(struct hns_nic_priv *priv) 1602 { 1603 struct hnae_handle *h = priv->ae_handle; 1604 struct hnae_ae_ops *ops = h->dev->ops; 1605 u32 *data, reg_num, i; 1606 1607 if (ops->get_regs_len && ops->get_regs) { 1608 reg_num = ops->get_regs_len(priv->ae_handle); 1609 reg_num = (reg_num + 3ul) & ~3ul; 1610 data = kcalloc(reg_num, sizeof(u32), GFP_KERNEL); 1611 if (data) { 1612 ops->get_regs(priv->ae_handle, data); 1613 for (i = 0; i < reg_num; i += 4) 1614 pr_info("0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n", 1615 i, data[i], data[i + 1], 1616 data[i + 2], data[i + 3]); 1617 kfree(data); 1618 } 1619 } 1620 1621 for (i = 0; i < h->q_num; i++) { 1622 pr_info("tx_queue%d_next_to_clean:%d\n", 1623 i, h->qs[i]->tx_ring.next_to_clean); 1624 pr_info("tx_queue%d_next_to_use:%d\n", 1625 i, h->qs[i]->tx_ring.next_to_use); 1626 pr_info("rx_queue%d_next_to_clean:%d\n", 1627 i, h->qs[i]->rx_ring.next_to_clean); 1628 pr_info("rx_queue%d_next_to_use:%d\n", 1629 i, h->qs[i]->rx_ring.next_to_use); 1630 } 1631 } 1632 1633 /* for resetting suntask*/ 1634 static void hns_nic_reset_subtask(struct hns_nic_priv *priv) 1635 { 1636 enum hnae_port_type type = priv->ae_handle->port_type; 1637 1638 if (!test_bit(NIC_STATE2_RESET_REQUESTED, &priv->state)) 1639 return; 1640 clear_bit(NIC_STATE2_RESET_REQUESTED, &priv->state); 1641 1642 /* If we're already down, removing or resetting, just bail */ 1643 if (test_bit(NIC_STATE_DOWN, &priv->state) || 1644 test_bit(NIC_STATE_REMOVING, &priv->state) || 1645 test_bit(NIC_STATE_RESETTING, &priv->state)) 1646 return; 1647 1648 hns_nic_dump(priv); 1649 netdev_info(priv->netdev, "try to reset %s port!\n", 1650 (type == HNAE_PORT_DEBUG ? "debug" : "service")); 1651 1652 rtnl_lock(); 1653 /* put off any impending NetWatchDogTimeout */ 1654 priv->netdev->trans_start = jiffies; 1655 1656 if (type == HNAE_PORT_DEBUG) { 1657 hns_nic_net_reinit(priv->netdev); 1658 } else { 1659 netif_carrier_off(priv->netdev); 1660 netif_tx_disable(priv->netdev); 1661 } 1662 rtnl_unlock(); 1663 } 1664 1665 /* for doing service complete*/ 1666 static void hns_nic_service_event_complete(struct hns_nic_priv *priv) 1667 { 1668 WARN_ON(!test_bit(NIC_STATE_SERVICE_SCHED, &priv->state)); 1669 1670 smp_mb__before_atomic(); 1671 clear_bit(NIC_STATE_SERVICE_SCHED, &priv->state); 1672 } 1673 1674 static void hns_nic_service_task(struct work_struct *work) 1675 { 1676 struct hns_nic_priv *priv 1677 = container_of(work, struct hns_nic_priv, service_task); 1678 struct hnae_handle *h = priv->ae_handle; 1679 1680 hns_nic_update_link_status(priv->netdev); 1681 h->dev->ops->update_led_status(h); 1682 hns_nic_update_stats(priv->netdev); 1683 1684 hns_nic_reset_subtask(priv); 1685 hns_nic_service_event_complete(priv); 1686 } 1687 1688 static void hns_nic_task_schedule(struct hns_nic_priv *priv) 1689 { 1690 if (!test_bit(NIC_STATE_DOWN, &priv->state) && 1691 !test_bit(NIC_STATE_REMOVING, &priv->state) && 1692 !test_and_set_bit(NIC_STATE_SERVICE_SCHED, &priv->state)) 1693 (void)schedule_work(&priv->service_task); 1694 } 1695 1696 static void hns_nic_service_timer(unsigned long data) 1697 { 1698 struct hns_nic_priv *priv = (struct hns_nic_priv *)data; 1699 1700 (void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ); 1701 1702 hns_nic_task_schedule(priv); 1703 } 1704 1705 /** 1706 * hns_tx_timeout_reset - initiate reset due to Tx timeout 1707 * @priv: driver private struct 1708 **/ 1709 static void hns_tx_timeout_reset(struct hns_nic_priv *priv) 1710 { 1711 /* Do the reset outside of interrupt context */ 1712 if (!test_bit(NIC_STATE_DOWN, &priv->state)) { 1713 set_bit(NIC_STATE2_RESET_REQUESTED, &priv->state); 1714 netdev_warn(priv->netdev, 1715 "initiating reset due to tx timeout(%llu,0x%lx)\n", 1716 priv->tx_timeout_count, priv->state); 1717 priv->tx_timeout_count++; 1718 hns_nic_task_schedule(priv); 1719 } 1720 } 1721 1722 static int hns_nic_init_ring_data(struct hns_nic_priv *priv) 1723 { 1724 struct hnae_handle *h = priv->ae_handle; 1725 struct hns_nic_ring_data *rd; 1726 int i; 1727 1728 if (h->q_num > NIC_MAX_Q_PER_VF) { 1729 netdev_err(priv->netdev, "too much queue (%d)\n", h->q_num); 1730 return -EINVAL; 1731 } 1732 1733 priv->ring_data = kzalloc(h->q_num * sizeof(*priv->ring_data) * 2, 1734 GFP_KERNEL); 1735 if (!priv->ring_data) 1736 return -ENOMEM; 1737 1738 for (i = 0; i < h->q_num; i++) { 1739 rd = &priv->ring_data[i]; 1740 rd->queue_index = i; 1741 rd->ring = &h->qs[i]->tx_ring; 1742 rd->poll_one = hns_nic_tx_poll_one; 1743 rd->fini_process = hns_nic_tx_fini_pro; 1744 1745 netif_napi_add(priv->netdev, &rd->napi, 1746 hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM); 1747 rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; 1748 } 1749 for (i = h->q_num; i < h->q_num * 2; i++) { 1750 rd = &priv->ring_data[i]; 1751 rd->queue_index = i - h->q_num; 1752 rd->ring = &h->qs[i - h->q_num]->rx_ring; 1753 rd->poll_one = hns_nic_rx_poll_one; 1754 rd->ex_process = hns_nic_rx_up_pro; 1755 rd->fini_process = hns_nic_rx_fini_pro; 1756 1757 netif_napi_add(priv->netdev, &rd->napi, 1758 hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM); 1759 rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; 1760 } 1761 1762 return 0; 1763 } 1764 1765 static void hns_nic_uninit_ring_data(struct hns_nic_priv *priv) 1766 { 1767 struct hnae_handle *h = priv->ae_handle; 1768 int i; 1769 1770 for (i = 0; i < h->q_num * 2; i++) { 1771 netif_napi_del(&priv->ring_data[i].napi); 1772 if (priv->ring_data[i].ring->irq_init_flag == RCB_IRQ_INITED) { 1773 (void)irq_set_affinity_hint( 1774 priv->ring_data[i].ring->irq, 1775 NULL); 1776 free_irq(priv->ring_data[i].ring->irq, 1777 &priv->ring_data[i]); 1778 } 1779 1780 priv->ring_data[i].ring->irq_init_flag = RCB_IRQ_NOT_INITED; 1781 } 1782 kfree(priv->ring_data); 1783 } 1784 1785 static void hns_nic_set_priv_ops(struct net_device *netdev) 1786 { 1787 struct hns_nic_priv *priv = netdev_priv(netdev); 1788 struct hnae_handle *h = priv->ae_handle; 1789 1790 if (AE_IS_VER1(priv->enet_ver)) { 1791 priv->ops.fill_desc = fill_desc; 1792 priv->ops.get_rxd_bnum = get_rx_desc_bnum; 1793 priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tx; 1794 } else { 1795 priv->ops.get_rxd_bnum = get_v2rx_desc_bnum; 1796 if ((netdev->features & NETIF_F_TSO) || 1797 (netdev->features & NETIF_F_TSO6)) { 1798 priv->ops.fill_desc = fill_tso_desc; 1799 priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tso; 1800 /* This chip only support 7*4096 */ 1801 netif_set_gso_max_size(netdev, 7 * 4096); 1802 h->dev->ops->set_tso_stats(h, 1); 1803 } else { 1804 priv->ops.fill_desc = fill_v2_desc; 1805 priv->ops.maybe_stop_tx = hns_nic_maybe_stop_tx; 1806 } 1807 } 1808 } 1809 1810 static int hns_nic_try_get_ae(struct net_device *ndev) 1811 { 1812 struct hns_nic_priv *priv = netdev_priv(ndev); 1813 struct hnae_handle *h; 1814 int ret; 1815 1816 h = hnae_get_handle(&priv->netdev->dev, 1817 priv->ae_node, priv->port_id, NULL); 1818 if (IS_ERR_OR_NULL(h)) { 1819 ret = PTR_ERR(h); 1820 dev_dbg(priv->dev, "has not handle, register notifier!\n"); 1821 goto out; 1822 } 1823 priv->ae_handle = h; 1824 1825 ret = hns_nic_init_phy(ndev, h); 1826 if (ret) { 1827 dev_err(priv->dev, "probe phy device fail!\n"); 1828 goto out_init_phy; 1829 } 1830 1831 ret = hns_nic_init_ring_data(priv); 1832 if (ret) { 1833 ret = -ENOMEM; 1834 goto out_init_ring_data; 1835 } 1836 1837 hns_nic_set_priv_ops(ndev); 1838 1839 ret = register_netdev(ndev); 1840 if (ret) { 1841 dev_err(priv->dev, "probe register netdev fail!\n"); 1842 goto out_reg_ndev_fail; 1843 } 1844 return 0; 1845 1846 out_reg_ndev_fail: 1847 hns_nic_uninit_ring_data(priv); 1848 priv->ring_data = NULL; 1849 out_init_phy: 1850 out_init_ring_data: 1851 hnae_put_handle(priv->ae_handle); 1852 priv->ae_handle = NULL; 1853 out: 1854 return ret; 1855 } 1856 1857 static int hns_nic_notifier_action(struct notifier_block *nb, 1858 unsigned long action, void *data) 1859 { 1860 struct hns_nic_priv *priv = 1861 container_of(nb, struct hns_nic_priv, notifier_block); 1862 1863 assert(action == HNAE_AE_REGISTER); 1864 1865 if (!hns_nic_try_get_ae(priv->netdev)) { 1866 hnae_unregister_notifier(&priv->notifier_block); 1867 priv->notifier_block.notifier_call = NULL; 1868 } 1869 return 0; 1870 } 1871 1872 static int hns_nic_dev_probe(struct platform_device *pdev) 1873 { 1874 struct device *dev = &pdev->dev; 1875 struct net_device *ndev; 1876 struct hns_nic_priv *priv; 1877 struct device_node *node = dev->of_node; 1878 int ret; 1879 1880 ndev = alloc_etherdev_mq(sizeof(struct hns_nic_priv), NIC_MAX_Q_PER_VF); 1881 if (!ndev) 1882 return -ENOMEM; 1883 1884 platform_set_drvdata(pdev, ndev); 1885 1886 priv = netdev_priv(ndev); 1887 priv->dev = dev; 1888 priv->netdev = ndev; 1889 1890 if (of_device_is_compatible(node, "hisilicon,hns-nic-v1")) 1891 priv->enet_ver = AE_VERSION_1; 1892 else 1893 priv->enet_ver = AE_VERSION_2; 1894 1895 priv->ae_node = (void *)of_parse_phandle(node, "ae-handle", 0); 1896 if (IS_ERR_OR_NULL(priv->ae_node)) { 1897 ret = PTR_ERR(priv->ae_node); 1898 dev_err(dev, "not find ae-handle\n"); 1899 goto out_read_prop_fail; 1900 } 1901 1902 ret = of_property_read_u32(node, "port-id", &priv->port_id); 1903 if (ret) 1904 goto out_read_prop_fail; 1905 1906 hns_init_mac_addr(ndev); 1907 1908 ndev->watchdog_timeo = HNS_NIC_TX_TIMEOUT; 1909 ndev->priv_flags |= IFF_UNICAST_FLT; 1910 ndev->netdev_ops = &hns_nic_netdev_ops; 1911 hns_ethtool_set_ops(ndev); 1912 1913 ndev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 1914 NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO | 1915 NETIF_F_GRO; 1916 ndev->vlan_features |= 1917 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM; 1918 ndev->vlan_features |= NETIF_F_SG | NETIF_F_GSO | NETIF_F_GRO; 1919 1920 switch (priv->enet_ver) { 1921 case AE_VERSION_2: 1922 ndev->features |= NETIF_F_TSO | NETIF_F_TSO6; 1923 ndev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 1924 NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO | 1925 NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6; 1926 break; 1927 default: 1928 break; 1929 } 1930 1931 SET_NETDEV_DEV(ndev, dev); 1932 1933 if (!dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64))) 1934 dev_dbg(dev, "set mask to 64bit\n"); 1935 else 1936 dev_err(dev, "set mask to 32bit fail!\n"); 1937 1938 /* carrier off reporting is important to ethtool even BEFORE open */ 1939 netif_carrier_off(ndev); 1940 1941 setup_timer(&priv->service_timer, hns_nic_service_timer, 1942 (unsigned long)priv); 1943 INIT_WORK(&priv->service_task, hns_nic_service_task); 1944 1945 set_bit(NIC_STATE_SERVICE_INITED, &priv->state); 1946 clear_bit(NIC_STATE_SERVICE_SCHED, &priv->state); 1947 set_bit(NIC_STATE_DOWN, &priv->state); 1948 1949 if (hns_nic_try_get_ae(priv->netdev)) { 1950 priv->notifier_block.notifier_call = hns_nic_notifier_action; 1951 ret = hnae_register_notifier(&priv->notifier_block); 1952 if (ret) { 1953 dev_err(dev, "register notifier fail!\n"); 1954 goto out_notify_fail; 1955 } 1956 dev_dbg(dev, "has not handle, register notifier!\n"); 1957 } 1958 1959 return 0; 1960 1961 out_notify_fail: 1962 (void)cancel_work_sync(&priv->service_task); 1963 out_read_prop_fail: 1964 free_netdev(ndev); 1965 return ret; 1966 } 1967 1968 static int hns_nic_dev_remove(struct platform_device *pdev) 1969 { 1970 struct net_device *ndev = platform_get_drvdata(pdev); 1971 struct hns_nic_priv *priv = netdev_priv(ndev); 1972 1973 if (ndev->reg_state != NETREG_UNINITIALIZED) 1974 unregister_netdev(ndev); 1975 1976 if (priv->ring_data) 1977 hns_nic_uninit_ring_data(priv); 1978 priv->ring_data = NULL; 1979 1980 if (priv->phy) 1981 phy_disconnect(priv->phy); 1982 priv->phy = NULL; 1983 1984 if (!IS_ERR_OR_NULL(priv->ae_handle)) 1985 hnae_put_handle(priv->ae_handle); 1986 priv->ae_handle = NULL; 1987 if (priv->notifier_block.notifier_call) 1988 hnae_unregister_notifier(&priv->notifier_block); 1989 priv->notifier_block.notifier_call = NULL; 1990 1991 set_bit(NIC_STATE_REMOVING, &priv->state); 1992 (void)cancel_work_sync(&priv->service_task); 1993 1994 free_netdev(ndev); 1995 return 0; 1996 } 1997 1998 static const struct of_device_id hns_enet_of_match[] = { 1999 {.compatible = "hisilicon,hns-nic-v1",}, 2000 {.compatible = "hisilicon,hns-nic-v2",}, 2001 {}, 2002 }; 2003 2004 MODULE_DEVICE_TABLE(of, hns_enet_of_match); 2005 2006 static struct platform_driver hns_nic_dev_driver = { 2007 .driver = { 2008 .name = "hns-nic", 2009 .of_match_table = hns_enet_of_match, 2010 }, 2011 .probe = hns_nic_dev_probe, 2012 .remove = hns_nic_dev_remove, 2013 }; 2014 2015 module_platform_driver(hns_nic_dev_driver); 2016 2017 MODULE_DESCRIPTION("HISILICON HNS Ethernet driver"); 2018 MODULE_AUTHOR("Hisilicon, Inc."); 2019 MODULE_LICENSE("GPL"); 2020 MODULE_ALIAS("platform:hns-nic"); 2021