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