1 /* 2 * aQuantia Corporation Network Driver 3 * Copyright (C) 2014-2017 aQuantia Corporation. All rights reserved 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 */ 9 10 /* File aq_nic.c: Definition of common code for NIC. */ 11 12 #include "aq_nic.h" 13 #include "aq_ring.h" 14 #include "aq_vec.h" 15 #include "aq_hw.h" 16 #include "aq_pci_func.h" 17 18 #include <linux/moduleparam.h> 19 #include <linux/netdevice.h> 20 #include <linux/etherdevice.h> 21 #include <linux/timer.h> 22 #include <linux/cpu.h> 23 #include <linux/ip.h> 24 #include <linux/tcp.h> 25 #include <net/ip.h> 26 27 static unsigned int aq_itr = AQ_CFG_INTERRUPT_MODERATION_AUTO; 28 module_param_named(aq_itr, aq_itr, uint, 0644); 29 MODULE_PARM_DESC(aq_itr, "Interrupt throttling mode"); 30 31 static unsigned int aq_itr_tx; 32 module_param_named(aq_itr_tx, aq_itr_tx, uint, 0644); 33 MODULE_PARM_DESC(aq_itr_tx, "TX interrupt throttle rate"); 34 35 static unsigned int aq_itr_rx; 36 module_param_named(aq_itr_rx, aq_itr_rx, uint, 0644); 37 MODULE_PARM_DESC(aq_itr_rx, "RX interrupt throttle rate"); 38 39 static void aq_nic_update_ndev_stats(struct aq_nic_s *self); 40 41 static void aq_nic_rss_init(struct aq_nic_s *self, unsigned int num_rss_queues) 42 { 43 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 44 struct aq_rss_parameters *rss_params = &cfg->aq_rss; 45 int i = 0; 46 47 static u8 rss_key[40] = { 48 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d, 49 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18, 50 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8, 51 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70, 52 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c 53 }; 54 55 rss_params->hash_secret_key_size = sizeof(rss_key); 56 memcpy(rss_params->hash_secret_key, rss_key, sizeof(rss_key)); 57 rss_params->indirection_table_size = AQ_CFG_RSS_INDIRECTION_TABLE_MAX; 58 59 for (i = rss_params->indirection_table_size; i--;) 60 rss_params->indirection_table[i] = i & (num_rss_queues - 1); 61 } 62 63 /* Checks hw_caps and 'corrects' aq_nic_cfg in runtime */ 64 void aq_nic_cfg_start(struct aq_nic_s *self) 65 { 66 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 67 68 cfg->tcs = AQ_CFG_TCS_DEF; 69 70 cfg->is_polling = AQ_CFG_IS_POLLING_DEF; 71 72 cfg->itr = aq_itr; 73 cfg->tx_itr = aq_itr_tx; 74 cfg->rx_itr = aq_itr_rx; 75 76 cfg->is_rss = AQ_CFG_IS_RSS_DEF; 77 cfg->num_rss_queues = AQ_CFG_NUM_RSS_QUEUES_DEF; 78 cfg->aq_rss.base_cpu_number = AQ_CFG_RSS_BASE_CPU_NUM_DEF; 79 cfg->flow_control = AQ_CFG_FC_MODE; 80 81 cfg->mtu = AQ_CFG_MTU_DEF; 82 cfg->link_speed_msk = AQ_CFG_SPEED_MSK; 83 cfg->is_autoneg = AQ_CFG_IS_AUTONEG_DEF; 84 85 cfg->is_lro = AQ_CFG_IS_LRO_DEF; 86 87 cfg->vlan_id = 0U; 88 89 aq_nic_rss_init(self, cfg->num_rss_queues); 90 91 /*descriptors */ 92 cfg->rxds = min(cfg->aq_hw_caps->rxds, AQ_CFG_RXDS_DEF); 93 cfg->txds = min(cfg->aq_hw_caps->txds, AQ_CFG_TXDS_DEF); 94 95 /*rss rings */ 96 cfg->vecs = min(cfg->aq_hw_caps->vecs, AQ_CFG_VECS_DEF); 97 cfg->vecs = min(cfg->vecs, num_online_cpus()); 98 /* cfg->vecs should be power of 2 for RSS */ 99 if (cfg->vecs >= 8U) 100 cfg->vecs = 8U; 101 else if (cfg->vecs >= 4U) 102 cfg->vecs = 4U; 103 else if (cfg->vecs >= 2U) 104 cfg->vecs = 2U; 105 else 106 cfg->vecs = 1U; 107 108 cfg->num_rss_queues = min(cfg->vecs, AQ_CFG_NUM_RSS_QUEUES_DEF); 109 110 cfg->irq_type = aq_pci_func_get_irq_type(self); 111 112 if ((cfg->irq_type == AQ_HW_IRQ_LEGACY) || 113 (cfg->aq_hw_caps->vecs == 1U) || 114 (cfg->vecs == 1U)) { 115 cfg->is_rss = 0U; 116 cfg->vecs = 1U; 117 } 118 119 cfg->link_speed_msk &= cfg->aq_hw_caps->link_speed_msk; 120 cfg->hw_features = cfg->aq_hw_caps->hw_features; 121 } 122 123 static int aq_nic_update_link_status(struct aq_nic_s *self) 124 { 125 int err = self->aq_fw_ops->update_link_status(self->aq_hw); 126 127 if (err) 128 return err; 129 130 if (self->link_status.mbps != self->aq_hw->aq_link_status.mbps) { 131 pr_info("%s: link change old %d new %d\n", 132 AQ_CFG_DRV_NAME, self->link_status.mbps, 133 self->aq_hw->aq_link_status.mbps); 134 aq_nic_update_interrupt_moderation_settings(self); 135 } 136 137 self->link_status = self->aq_hw->aq_link_status; 138 if (!netif_carrier_ok(self->ndev) && self->link_status.mbps) { 139 aq_utils_obj_set(&self->flags, 140 AQ_NIC_FLAG_STARTED); 141 aq_utils_obj_clear(&self->flags, 142 AQ_NIC_LINK_DOWN); 143 netif_carrier_on(self->ndev); 144 netif_tx_wake_all_queues(self->ndev); 145 } 146 if (netif_carrier_ok(self->ndev) && !self->link_status.mbps) { 147 netif_carrier_off(self->ndev); 148 netif_tx_disable(self->ndev); 149 aq_utils_obj_set(&self->flags, AQ_NIC_LINK_DOWN); 150 } 151 return 0; 152 } 153 154 static void aq_nic_service_timer_cb(struct timer_list *t) 155 { 156 struct aq_nic_s *self = from_timer(self, t, service_timer); 157 int ctimer = AQ_CFG_SERVICE_TIMER_INTERVAL; 158 int err = 0; 159 160 if (aq_utils_obj_test(&self->flags, AQ_NIC_FLAGS_IS_NOT_READY)) 161 goto err_exit; 162 163 err = aq_nic_update_link_status(self); 164 if (err) 165 goto err_exit; 166 167 if (self->aq_fw_ops->update_stats) 168 self->aq_fw_ops->update_stats(self->aq_hw); 169 170 aq_nic_update_ndev_stats(self); 171 172 /* If no link - use faster timer rate to detect link up asap */ 173 if (!netif_carrier_ok(self->ndev)) 174 ctimer = max(ctimer / 2, 1); 175 176 err_exit: 177 mod_timer(&self->service_timer, jiffies + ctimer); 178 } 179 180 static void aq_nic_polling_timer_cb(struct timer_list *t) 181 { 182 struct aq_nic_s *self = from_timer(self, t, polling_timer); 183 struct aq_vec_s *aq_vec = NULL; 184 unsigned int i = 0U; 185 186 for (i = 0U, aq_vec = self->aq_vec[0]; 187 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 188 aq_vec_isr(i, (void *)aq_vec); 189 190 mod_timer(&self->polling_timer, jiffies + 191 AQ_CFG_POLLING_TIMER_INTERVAL); 192 } 193 194 int aq_nic_ndev_register(struct aq_nic_s *self) 195 { 196 int err = 0; 197 198 if (!self->ndev) { 199 err = -EINVAL; 200 goto err_exit; 201 } 202 203 err = hw_atl_utils_initfw(self->aq_hw, &self->aq_fw_ops); 204 if (err) 205 goto err_exit; 206 207 err = self->aq_fw_ops->get_mac_permanent(self->aq_hw, 208 self->ndev->dev_addr); 209 if (err) 210 goto err_exit; 211 212 #if defined(AQ_CFG_MAC_ADDR_PERMANENT) 213 { 214 static u8 mac_addr_permanent[] = AQ_CFG_MAC_ADDR_PERMANENT; 215 216 ether_addr_copy(self->ndev->dev_addr, mac_addr_permanent); 217 } 218 #endif 219 220 for (self->aq_vecs = 0; self->aq_vecs < aq_nic_get_cfg(self)->vecs; 221 self->aq_vecs++) { 222 self->aq_vec[self->aq_vecs] = 223 aq_vec_alloc(self, self->aq_vecs, aq_nic_get_cfg(self)); 224 if (!self->aq_vec[self->aq_vecs]) { 225 err = -ENOMEM; 226 goto err_exit; 227 } 228 } 229 230 netif_carrier_off(self->ndev); 231 232 netif_tx_disable(self->ndev); 233 234 err = register_netdev(self->ndev); 235 if (err) 236 goto err_exit; 237 238 err_exit: 239 return err; 240 } 241 242 void aq_nic_ndev_init(struct aq_nic_s *self) 243 { 244 const struct aq_hw_caps_s *aq_hw_caps = self->aq_nic_cfg.aq_hw_caps; 245 struct aq_nic_cfg_s *aq_nic_cfg = &self->aq_nic_cfg; 246 247 self->ndev->hw_features |= aq_hw_caps->hw_features; 248 self->ndev->features = aq_hw_caps->hw_features; 249 self->ndev->priv_flags = aq_hw_caps->hw_priv_flags; 250 self->ndev->mtu = aq_nic_cfg->mtu - ETH_HLEN; 251 self->ndev->max_mtu = aq_hw_caps->mtu - ETH_FCS_LEN - ETH_HLEN; 252 253 } 254 255 void aq_nic_set_tx_ring(struct aq_nic_s *self, unsigned int idx, 256 struct aq_ring_s *ring) 257 { 258 self->aq_ring_tx[idx] = ring; 259 } 260 261 struct net_device *aq_nic_get_ndev(struct aq_nic_s *self) 262 { 263 return self->ndev; 264 } 265 266 int aq_nic_init(struct aq_nic_s *self) 267 { 268 struct aq_vec_s *aq_vec = NULL; 269 int err = 0; 270 unsigned int i = 0U; 271 272 self->power_state = AQ_HW_POWER_STATE_D0; 273 err = self->aq_hw_ops->hw_reset(self->aq_hw); 274 if (err < 0) 275 goto err_exit; 276 277 err = self->aq_hw_ops->hw_init(self->aq_hw, 278 aq_nic_get_ndev(self)->dev_addr); 279 if (err < 0) 280 goto err_exit; 281 282 for (i = 0U, aq_vec = self->aq_vec[0]; 283 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 284 aq_vec_init(aq_vec, self->aq_hw_ops, self->aq_hw); 285 286 netif_carrier_off(self->ndev); 287 288 err_exit: 289 return err; 290 } 291 292 int aq_nic_start(struct aq_nic_s *self) 293 { 294 struct aq_vec_s *aq_vec = NULL; 295 int err = 0; 296 unsigned int i = 0U; 297 298 err = self->aq_hw_ops->hw_multicast_list_set(self->aq_hw, 299 self->mc_list.ar, 300 self->mc_list.count); 301 if (err < 0) 302 goto err_exit; 303 304 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, 305 self->packet_filter); 306 if (err < 0) 307 goto err_exit; 308 309 for (i = 0U, aq_vec = self->aq_vec[0]; 310 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 311 err = aq_vec_start(aq_vec); 312 if (err < 0) 313 goto err_exit; 314 } 315 316 err = self->aq_hw_ops->hw_start(self->aq_hw); 317 if (err < 0) 318 goto err_exit; 319 320 err = aq_nic_update_interrupt_moderation_settings(self); 321 if (err) 322 goto err_exit; 323 timer_setup(&self->service_timer, aq_nic_service_timer_cb, 0); 324 mod_timer(&self->service_timer, jiffies + 325 AQ_CFG_SERVICE_TIMER_INTERVAL); 326 327 if (self->aq_nic_cfg.is_polling) { 328 timer_setup(&self->polling_timer, aq_nic_polling_timer_cb, 0); 329 mod_timer(&self->polling_timer, jiffies + 330 AQ_CFG_POLLING_TIMER_INTERVAL); 331 } else { 332 for (i = 0U, aq_vec = self->aq_vec[0]; 333 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 334 err = aq_pci_func_alloc_irq(self, i, 335 self->ndev->name, aq_vec, 336 aq_vec_get_affinity_mask(aq_vec)); 337 if (err < 0) 338 goto err_exit; 339 } 340 341 err = self->aq_hw_ops->hw_irq_enable(self->aq_hw, 342 AQ_CFG_IRQ_MASK); 343 if (err < 0) 344 goto err_exit; 345 } 346 347 err = netif_set_real_num_tx_queues(self->ndev, self->aq_vecs); 348 if (err < 0) 349 goto err_exit; 350 351 err = netif_set_real_num_rx_queues(self->ndev, self->aq_vecs); 352 if (err < 0) 353 goto err_exit; 354 355 netif_tx_start_all_queues(self->ndev); 356 357 err_exit: 358 return err; 359 } 360 361 static unsigned int aq_nic_map_skb(struct aq_nic_s *self, 362 struct sk_buff *skb, 363 struct aq_ring_s *ring) 364 { 365 unsigned int ret = 0U; 366 unsigned int nr_frags = skb_shinfo(skb)->nr_frags; 367 unsigned int frag_count = 0U; 368 unsigned int dx = ring->sw_tail; 369 struct aq_ring_buff_s *first = NULL; 370 struct aq_ring_buff_s *dx_buff = &ring->buff_ring[dx]; 371 372 if (unlikely(skb_is_gso(skb))) { 373 dx_buff->flags = 0U; 374 dx_buff->len_pkt = skb->len; 375 dx_buff->len_l2 = ETH_HLEN; 376 dx_buff->len_l3 = ip_hdrlen(skb); 377 dx_buff->len_l4 = tcp_hdrlen(skb); 378 dx_buff->mss = skb_shinfo(skb)->gso_size; 379 dx_buff->is_txc = 1U; 380 dx_buff->eop_index = 0xffffU; 381 382 dx_buff->is_ipv6 = 383 (ip_hdr(skb)->version == 6) ? 1U : 0U; 384 385 dx = aq_ring_next_dx(ring, dx); 386 dx_buff = &ring->buff_ring[dx]; 387 ++ret; 388 } 389 390 dx_buff->flags = 0U; 391 dx_buff->len = skb_headlen(skb); 392 dx_buff->pa = dma_map_single(aq_nic_get_dev(self), 393 skb->data, 394 dx_buff->len, 395 DMA_TO_DEVICE); 396 397 if (unlikely(dma_mapping_error(aq_nic_get_dev(self), dx_buff->pa))) 398 goto exit; 399 400 first = dx_buff; 401 dx_buff->len_pkt = skb->len; 402 dx_buff->is_sop = 1U; 403 dx_buff->is_mapped = 1U; 404 ++ret; 405 406 if (skb->ip_summed == CHECKSUM_PARTIAL) { 407 dx_buff->is_ip_cso = (htons(ETH_P_IP) == skb->protocol) ? 408 1U : 0U; 409 410 if (ip_hdr(skb)->version == 4) { 411 dx_buff->is_tcp_cso = 412 (ip_hdr(skb)->protocol == IPPROTO_TCP) ? 413 1U : 0U; 414 dx_buff->is_udp_cso = 415 (ip_hdr(skb)->protocol == IPPROTO_UDP) ? 416 1U : 0U; 417 } else if (ip_hdr(skb)->version == 6) { 418 dx_buff->is_tcp_cso = 419 (ipv6_hdr(skb)->nexthdr == NEXTHDR_TCP) ? 420 1U : 0U; 421 dx_buff->is_udp_cso = 422 (ipv6_hdr(skb)->nexthdr == NEXTHDR_UDP) ? 423 1U : 0U; 424 } 425 } 426 427 for (; nr_frags--; ++frag_count) { 428 unsigned int frag_len = 0U; 429 unsigned int buff_offset = 0U; 430 unsigned int buff_size = 0U; 431 dma_addr_t frag_pa; 432 skb_frag_t *frag = &skb_shinfo(skb)->frags[frag_count]; 433 434 frag_len = skb_frag_size(frag); 435 436 while (frag_len) { 437 if (frag_len > AQ_CFG_TX_FRAME_MAX) 438 buff_size = AQ_CFG_TX_FRAME_MAX; 439 else 440 buff_size = frag_len; 441 442 frag_pa = skb_frag_dma_map(aq_nic_get_dev(self), 443 frag, 444 buff_offset, 445 buff_size, 446 DMA_TO_DEVICE); 447 448 if (unlikely(dma_mapping_error(aq_nic_get_dev(self), 449 frag_pa))) 450 goto mapping_error; 451 452 dx = aq_ring_next_dx(ring, dx); 453 dx_buff = &ring->buff_ring[dx]; 454 455 dx_buff->flags = 0U; 456 dx_buff->len = buff_size; 457 dx_buff->pa = frag_pa; 458 dx_buff->is_mapped = 1U; 459 dx_buff->eop_index = 0xffffU; 460 461 frag_len -= buff_size; 462 buff_offset += buff_size; 463 464 ++ret; 465 } 466 } 467 468 first->eop_index = dx; 469 dx_buff->is_eop = 1U; 470 dx_buff->skb = skb; 471 goto exit; 472 473 mapping_error: 474 for (dx = ring->sw_tail; 475 ret > 0; 476 --ret, dx = aq_ring_next_dx(ring, dx)) { 477 dx_buff = &ring->buff_ring[dx]; 478 479 if (!dx_buff->is_txc && dx_buff->pa) { 480 if (unlikely(dx_buff->is_sop)) { 481 dma_unmap_single(aq_nic_get_dev(self), 482 dx_buff->pa, 483 dx_buff->len, 484 DMA_TO_DEVICE); 485 } else { 486 dma_unmap_page(aq_nic_get_dev(self), 487 dx_buff->pa, 488 dx_buff->len, 489 DMA_TO_DEVICE); 490 } 491 } 492 } 493 494 exit: 495 return ret; 496 } 497 498 int aq_nic_xmit(struct aq_nic_s *self, struct sk_buff *skb) 499 { 500 struct aq_ring_s *ring = NULL; 501 unsigned int frags = 0U; 502 unsigned int vec = skb->queue_mapping % self->aq_nic_cfg.vecs; 503 unsigned int tc = 0U; 504 int err = NETDEV_TX_OK; 505 506 frags = skb_shinfo(skb)->nr_frags + 1; 507 508 ring = self->aq_ring_tx[AQ_NIC_TCVEC2RING(self, tc, vec)]; 509 510 if (frags > AQ_CFG_SKB_FRAGS_MAX) { 511 dev_kfree_skb_any(skb); 512 goto err_exit; 513 } 514 515 aq_ring_update_queue_state(ring); 516 517 /* Above status update may stop the queue. Check this. */ 518 if (__netif_subqueue_stopped(self->ndev, ring->idx)) { 519 err = NETDEV_TX_BUSY; 520 goto err_exit; 521 } 522 523 frags = aq_nic_map_skb(self, skb, ring); 524 525 if (likely(frags)) { 526 err = self->aq_hw_ops->hw_ring_tx_xmit(self->aq_hw, 527 ring, frags); 528 if (err >= 0) { 529 ++ring->stats.tx.packets; 530 ring->stats.tx.bytes += skb->len; 531 } 532 } else { 533 err = NETDEV_TX_BUSY; 534 } 535 536 err_exit: 537 return err; 538 } 539 540 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s *self) 541 { 542 return self->aq_hw_ops->hw_interrupt_moderation_set(self->aq_hw); 543 } 544 545 int aq_nic_set_packet_filter(struct aq_nic_s *self, unsigned int flags) 546 { 547 int err = 0; 548 549 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, flags); 550 if (err < 0) 551 goto err_exit; 552 553 self->packet_filter = flags; 554 555 err_exit: 556 return err; 557 } 558 559 int aq_nic_set_multicast_list(struct aq_nic_s *self, struct net_device *ndev) 560 { 561 struct netdev_hw_addr *ha = NULL; 562 unsigned int i = 0U; 563 564 self->mc_list.count = 0U; 565 566 netdev_for_each_mc_addr(ha, ndev) { 567 ether_addr_copy(self->mc_list.ar[i++], ha->addr); 568 ++self->mc_list.count; 569 570 if (i >= AQ_CFG_MULTICAST_ADDRESS_MAX) 571 break; 572 } 573 574 if (i >= AQ_CFG_MULTICAST_ADDRESS_MAX) { 575 /* Number of filters is too big: atlantic does not support this. 576 * Force all multi filter to support this. 577 * With this we disable all UC filters and setup "all pass" 578 * multicast mask 579 */ 580 self->packet_filter |= IFF_ALLMULTI; 581 self->aq_nic_cfg.mc_list_count = 0; 582 return self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, 583 self->packet_filter); 584 } else { 585 return self->aq_hw_ops->hw_multicast_list_set(self->aq_hw, 586 self->mc_list.ar, 587 self->mc_list.count); 588 } 589 } 590 591 int aq_nic_set_mtu(struct aq_nic_s *self, int new_mtu) 592 { 593 self->aq_nic_cfg.mtu = new_mtu; 594 595 return 0; 596 } 597 598 int aq_nic_set_mac(struct aq_nic_s *self, struct net_device *ndev) 599 { 600 return self->aq_hw_ops->hw_set_mac_address(self->aq_hw, ndev->dev_addr); 601 } 602 603 unsigned int aq_nic_get_link_speed(struct aq_nic_s *self) 604 { 605 return self->link_status.mbps; 606 } 607 608 int aq_nic_get_regs(struct aq_nic_s *self, struct ethtool_regs *regs, void *p) 609 { 610 u32 *regs_buff = p; 611 int err = 0; 612 613 regs->version = 1; 614 615 err = self->aq_hw_ops->hw_get_regs(self->aq_hw, 616 self->aq_nic_cfg.aq_hw_caps, 617 regs_buff); 618 if (err < 0) 619 goto err_exit; 620 621 err_exit: 622 return err; 623 } 624 625 int aq_nic_get_regs_count(struct aq_nic_s *self) 626 { 627 return self->aq_nic_cfg.aq_hw_caps->mac_regs_count; 628 } 629 630 void aq_nic_get_stats(struct aq_nic_s *self, u64 *data) 631 { 632 unsigned int i = 0U; 633 unsigned int count = 0U; 634 struct aq_vec_s *aq_vec = NULL; 635 struct aq_stats_s *stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw); 636 637 if (!stats) 638 goto err_exit; 639 640 data[i] = stats->uprc + stats->mprc + stats->bprc; 641 data[++i] = stats->uprc; 642 data[++i] = stats->mprc; 643 data[++i] = stats->bprc; 644 data[++i] = stats->erpt; 645 data[++i] = stats->uptc + stats->mptc + stats->bptc; 646 data[++i] = stats->uptc; 647 data[++i] = stats->mptc; 648 data[++i] = stats->bptc; 649 data[++i] = stats->ubrc; 650 data[++i] = stats->ubtc; 651 data[++i] = stats->mbrc; 652 data[++i] = stats->mbtc; 653 data[++i] = stats->bbrc; 654 data[++i] = stats->bbtc; 655 data[++i] = stats->ubrc + stats->mbrc + stats->bbrc; 656 data[++i] = stats->ubtc + stats->mbtc + stats->bbtc; 657 data[++i] = stats->dma_pkt_rc; 658 data[++i] = stats->dma_pkt_tc; 659 data[++i] = stats->dma_oct_rc; 660 data[++i] = stats->dma_oct_tc; 661 data[++i] = stats->dpc; 662 663 i++; 664 665 data += i; 666 667 for (i = 0U, aq_vec = self->aq_vec[0]; 668 aq_vec && self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 669 data += count; 670 aq_vec_get_sw_stats(aq_vec, data, &count); 671 } 672 673 err_exit:; 674 } 675 676 static void aq_nic_update_ndev_stats(struct aq_nic_s *self) 677 { 678 struct net_device *ndev = self->ndev; 679 struct aq_stats_s *stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw); 680 681 ndev->stats.rx_packets = stats->uprc + stats->mprc + stats->bprc; 682 ndev->stats.rx_bytes = stats->ubrc + stats->mbrc + stats->bbrc; 683 ndev->stats.rx_errors = stats->erpr; 684 ndev->stats.tx_packets = stats->uptc + stats->mptc + stats->bptc; 685 ndev->stats.tx_bytes = stats->ubtc + stats->mbtc + stats->bbtc; 686 ndev->stats.tx_errors = stats->erpt; 687 ndev->stats.multicast = stats->mprc; 688 } 689 690 void aq_nic_get_link_ksettings(struct aq_nic_s *self, 691 struct ethtool_link_ksettings *cmd) 692 { 693 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 694 cmd->base.port = PORT_FIBRE; 695 else 696 cmd->base.port = PORT_TP; 697 /* This driver supports only 10G capable adapters, so DUPLEX_FULL */ 698 cmd->base.duplex = DUPLEX_FULL; 699 cmd->base.autoneg = self->aq_nic_cfg.is_autoneg; 700 701 ethtool_link_ksettings_zero_link_mode(cmd, supported); 702 703 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_10G) 704 ethtool_link_ksettings_add_link_mode(cmd, supported, 705 10000baseT_Full); 706 707 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_5G) 708 ethtool_link_ksettings_add_link_mode(cmd, supported, 709 5000baseT_Full); 710 711 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_2GS) 712 ethtool_link_ksettings_add_link_mode(cmd, supported, 713 2500baseT_Full); 714 715 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_1G) 716 ethtool_link_ksettings_add_link_mode(cmd, supported, 717 1000baseT_Full); 718 719 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_100M) 720 ethtool_link_ksettings_add_link_mode(cmd, supported, 721 100baseT_Full); 722 723 if (self->aq_nic_cfg.aq_hw_caps->flow_control) 724 ethtool_link_ksettings_add_link_mode(cmd, supported, 725 Pause); 726 727 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 728 729 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 730 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE); 731 else 732 ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 733 734 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 735 736 if (self->aq_nic_cfg.is_autoneg) 737 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg); 738 739 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_10G) 740 ethtool_link_ksettings_add_link_mode(cmd, advertising, 741 10000baseT_Full); 742 743 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_5G) 744 ethtool_link_ksettings_add_link_mode(cmd, advertising, 745 5000baseT_Full); 746 747 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_2GS) 748 ethtool_link_ksettings_add_link_mode(cmd, advertising, 749 2500baseT_Full); 750 751 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_1G) 752 ethtool_link_ksettings_add_link_mode(cmd, advertising, 753 1000baseT_Full); 754 755 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_100M) 756 ethtool_link_ksettings_add_link_mode(cmd, advertising, 757 100baseT_Full); 758 759 if (self->aq_nic_cfg.flow_control) 760 ethtool_link_ksettings_add_link_mode(cmd, advertising, 761 Pause); 762 763 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 764 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE); 765 else 766 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 767 } 768 769 int aq_nic_set_link_ksettings(struct aq_nic_s *self, 770 const struct ethtool_link_ksettings *cmd) 771 { 772 u32 speed = 0U; 773 u32 rate = 0U; 774 int err = 0; 775 776 if (cmd->base.autoneg == AUTONEG_ENABLE) { 777 rate = self->aq_nic_cfg.aq_hw_caps->link_speed_msk; 778 self->aq_nic_cfg.is_autoneg = true; 779 } else { 780 speed = cmd->base.speed; 781 782 switch (speed) { 783 case SPEED_100: 784 rate = AQ_NIC_RATE_100M; 785 break; 786 787 case SPEED_1000: 788 rate = AQ_NIC_RATE_1G; 789 break; 790 791 case SPEED_2500: 792 rate = AQ_NIC_RATE_2GS; 793 break; 794 795 case SPEED_5000: 796 rate = AQ_NIC_RATE_5G; 797 break; 798 799 case SPEED_10000: 800 rate = AQ_NIC_RATE_10G; 801 break; 802 803 default: 804 err = -1; 805 goto err_exit; 806 break; 807 } 808 if (!(self->aq_nic_cfg.aq_hw_caps->link_speed_msk & rate)) { 809 err = -1; 810 goto err_exit; 811 } 812 813 self->aq_nic_cfg.is_autoneg = false; 814 } 815 816 err = self->aq_fw_ops->set_link_speed(self->aq_hw, rate); 817 if (err < 0) 818 goto err_exit; 819 820 self->aq_nic_cfg.link_speed_msk = rate; 821 822 err_exit: 823 return err; 824 } 825 826 struct aq_nic_cfg_s *aq_nic_get_cfg(struct aq_nic_s *self) 827 { 828 return &self->aq_nic_cfg; 829 } 830 831 u32 aq_nic_get_fw_version(struct aq_nic_s *self) 832 { 833 u32 fw_version = 0U; 834 835 self->aq_hw_ops->hw_get_fw_version(self->aq_hw, &fw_version); 836 837 return fw_version; 838 } 839 840 int aq_nic_stop(struct aq_nic_s *self) 841 { 842 struct aq_vec_s *aq_vec = NULL; 843 unsigned int i = 0U; 844 845 netif_tx_disable(self->ndev); 846 netif_carrier_off(self->ndev); 847 848 del_timer_sync(&self->service_timer); 849 850 self->aq_hw_ops->hw_irq_disable(self->aq_hw, AQ_CFG_IRQ_MASK); 851 852 if (self->aq_nic_cfg.is_polling) 853 del_timer_sync(&self->polling_timer); 854 else 855 aq_pci_func_free_irqs(self); 856 857 for (i = 0U, aq_vec = self->aq_vec[0]; 858 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 859 aq_vec_stop(aq_vec); 860 861 return self->aq_hw_ops->hw_stop(self->aq_hw); 862 } 863 864 void aq_nic_deinit(struct aq_nic_s *self) 865 { 866 struct aq_vec_s *aq_vec = NULL; 867 unsigned int i = 0U; 868 869 if (!self) 870 goto err_exit; 871 872 for (i = 0U, aq_vec = self->aq_vec[0]; 873 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 874 aq_vec_deinit(aq_vec); 875 876 if (self->power_state == AQ_HW_POWER_STATE_D0) { 877 (void)self->aq_hw_ops->hw_deinit(self->aq_hw); 878 } else { 879 (void)self->aq_hw_ops->hw_set_power(self->aq_hw, 880 self->power_state); 881 } 882 883 err_exit:; 884 } 885 886 void aq_nic_free_vectors(struct aq_nic_s *self) 887 { 888 unsigned int i = 0U; 889 890 if (!self) 891 goto err_exit; 892 893 for (i = ARRAY_SIZE(self->aq_vec); i--;) { 894 if (self->aq_vec[i]) { 895 aq_vec_free(self->aq_vec[i]); 896 self->aq_vec[i] = NULL; 897 } 898 } 899 900 err_exit:; 901 } 902 903 int aq_nic_change_pm_state(struct aq_nic_s *self, pm_message_t *pm_msg) 904 { 905 int err = 0; 906 907 if (!netif_running(self->ndev)) { 908 err = 0; 909 goto out; 910 } 911 rtnl_lock(); 912 if (pm_msg->event & PM_EVENT_SLEEP || pm_msg->event & PM_EVENT_FREEZE) { 913 self->power_state = AQ_HW_POWER_STATE_D3; 914 netif_device_detach(self->ndev); 915 netif_tx_stop_all_queues(self->ndev); 916 917 err = aq_nic_stop(self); 918 if (err < 0) 919 goto err_exit; 920 921 aq_nic_deinit(self); 922 } else { 923 err = aq_nic_init(self); 924 if (err < 0) 925 goto err_exit; 926 927 err = aq_nic_start(self); 928 if (err < 0) 929 goto err_exit; 930 931 netif_device_attach(self->ndev); 932 netif_tx_start_all_queues(self->ndev); 933 } 934 935 err_exit: 936 rtnl_unlock(); 937 out: 938 return err; 939 } 940