1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * aQuantia Corporation Network Driver 4 * Copyright (C) 2014-2019 aQuantia Corporation. All rights reserved 5 */ 6 7 /* File aq_nic.c: Definition of common code for NIC. */ 8 9 #include "aq_nic.h" 10 #include "aq_ring.h" 11 #include "aq_vec.h" 12 #include "aq_hw.h" 13 #include "aq_pci_func.h" 14 #include "aq_macsec.h" 15 #include "aq_main.h" 16 #include "aq_phy.h" 17 #include "aq_ptp.h" 18 #include "aq_filters.h" 19 20 #include <linux/moduleparam.h> 21 #include <linux/netdevice.h> 22 #include <linux/etherdevice.h> 23 #include <linux/timer.h> 24 #include <linux/cpu.h> 25 #include <linux/ip.h> 26 #include <linux/tcp.h> 27 #include <net/ip.h> 28 29 static unsigned int aq_itr = AQ_CFG_INTERRUPT_MODERATION_AUTO; 30 module_param_named(aq_itr, aq_itr, uint, 0644); 31 MODULE_PARM_DESC(aq_itr, "Interrupt throttling mode"); 32 33 static unsigned int aq_itr_tx; 34 module_param_named(aq_itr_tx, aq_itr_tx, uint, 0644); 35 MODULE_PARM_DESC(aq_itr_tx, "TX interrupt throttle rate"); 36 37 static unsigned int aq_itr_rx; 38 module_param_named(aq_itr_rx, aq_itr_rx, uint, 0644); 39 MODULE_PARM_DESC(aq_itr_rx, "RX interrupt throttle rate"); 40 41 static void aq_nic_update_ndev_stats(struct aq_nic_s *self); 42 43 static void aq_nic_rss_init(struct aq_nic_s *self, unsigned int num_rss_queues) 44 { 45 static u8 rss_key[AQ_CFG_RSS_HASHKEY_SIZE] = { 46 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d, 47 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18, 48 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8, 49 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70, 50 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c 51 }; 52 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 53 struct aq_rss_parameters *rss_params; 54 int i = 0; 55 56 rss_params = &cfg->aq_rss; 57 58 rss_params->hash_secret_key_size = sizeof(rss_key); 59 memcpy(rss_params->hash_secret_key, rss_key, sizeof(rss_key)); 60 rss_params->indirection_table_size = AQ_CFG_RSS_INDIRECTION_TABLE_MAX; 61 62 for (i = rss_params->indirection_table_size; i--;) 63 rss_params->indirection_table[i] = i & (num_rss_queues - 1); 64 } 65 66 /* Checks hw_caps and 'corrects' aq_nic_cfg in runtime */ 67 void aq_nic_cfg_start(struct aq_nic_s *self) 68 { 69 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 70 71 cfg->tcs = AQ_CFG_TCS_DEF; 72 73 cfg->is_polling = AQ_CFG_IS_POLLING_DEF; 74 75 cfg->itr = aq_itr; 76 cfg->tx_itr = aq_itr_tx; 77 cfg->rx_itr = aq_itr_rx; 78 79 cfg->rxpageorder = AQ_CFG_RX_PAGEORDER; 80 cfg->is_rss = AQ_CFG_IS_RSS_DEF; 81 cfg->num_rss_queues = AQ_CFG_NUM_RSS_QUEUES_DEF; 82 cfg->aq_rss.base_cpu_number = AQ_CFG_RSS_BASE_CPU_NUM_DEF; 83 cfg->fc.req = AQ_CFG_FC_MODE; 84 cfg->wol = AQ_CFG_WOL_MODES; 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 /*descriptors */ 93 cfg->rxds = min(cfg->aq_hw_caps->rxds_max, AQ_CFG_RXDS_DEF); 94 cfg->txds = min(cfg->aq_hw_caps->txds_max, AQ_CFG_TXDS_DEF); 95 96 /*rss rings */ 97 cfg->vecs = min(cfg->aq_hw_caps->vecs, AQ_CFG_VECS_DEF); 98 cfg->vecs = min(cfg->vecs, num_online_cpus()); 99 if (self->irqvecs > AQ_HW_SERVICE_IRQS) 100 cfg->vecs = min(cfg->vecs, self->irqvecs - AQ_HW_SERVICE_IRQS); 101 /* cfg->vecs should be power of 2 for RSS */ 102 if (cfg->vecs >= 8U) 103 cfg->vecs = 8U; 104 else if (cfg->vecs >= 4U) 105 cfg->vecs = 4U; 106 else if (cfg->vecs >= 2U) 107 cfg->vecs = 2U; 108 else 109 cfg->vecs = 1U; 110 111 cfg->num_rss_queues = min(cfg->vecs, AQ_CFG_NUM_RSS_QUEUES_DEF); 112 113 aq_nic_rss_init(self, cfg->num_rss_queues); 114 115 cfg->irq_type = aq_pci_func_get_irq_type(self); 116 117 if ((cfg->irq_type == AQ_HW_IRQ_LEGACY) || 118 (cfg->aq_hw_caps->vecs == 1U) || 119 (cfg->vecs == 1U)) { 120 cfg->is_rss = 0U; 121 cfg->vecs = 1U; 122 } 123 124 /* Check if we have enough vectors allocated for 125 * link status IRQ. If no - we'll know link state from 126 * slower service task. 127 */ 128 if (AQ_HW_SERVICE_IRQS > 0 && cfg->vecs + 1 <= self->irqvecs) 129 cfg->link_irq_vec = cfg->vecs; 130 else 131 cfg->link_irq_vec = 0; 132 133 cfg->link_speed_msk &= cfg->aq_hw_caps->link_speed_msk; 134 cfg->features = cfg->aq_hw_caps->hw_features; 135 cfg->is_vlan_rx_strip = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_RX); 136 cfg->is_vlan_tx_insert = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_TX); 137 cfg->is_vlan_force_promisc = true; 138 } 139 140 static int aq_nic_update_link_status(struct aq_nic_s *self) 141 { 142 int err = self->aq_fw_ops->update_link_status(self->aq_hw); 143 u32 fc = 0; 144 145 if (err) 146 return err; 147 148 if (self->aq_fw_ops->get_flow_control) 149 self->aq_fw_ops->get_flow_control(self->aq_hw, &fc); 150 self->aq_nic_cfg.fc.cur = fc; 151 152 if (self->link_status.mbps != self->aq_hw->aq_link_status.mbps) { 153 netdev_info(self->ndev, "%s: link change old %d new %d\n", 154 AQ_CFG_DRV_NAME, self->link_status.mbps, 155 self->aq_hw->aq_link_status.mbps); 156 aq_nic_update_interrupt_moderation_settings(self); 157 158 if (self->aq_ptp) { 159 aq_ptp_clock_init(self); 160 aq_ptp_tm_offset_set(self, 161 self->aq_hw->aq_link_status.mbps); 162 aq_ptp_link_change(self); 163 } 164 165 /* Driver has to update flow control settings on RX block 166 * on any link event. 167 * We should query FW whether it negotiated FC. 168 */ 169 if (self->aq_hw_ops->hw_set_fc) 170 self->aq_hw_ops->hw_set_fc(self->aq_hw, fc, 0); 171 } 172 173 self->link_status = self->aq_hw->aq_link_status; 174 if (!netif_carrier_ok(self->ndev) && self->link_status.mbps) { 175 aq_utils_obj_set(&self->flags, 176 AQ_NIC_FLAG_STARTED); 177 aq_utils_obj_clear(&self->flags, 178 AQ_NIC_LINK_DOWN); 179 netif_carrier_on(self->ndev); 180 #if IS_ENABLED(CONFIG_MACSEC) 181 aq_macsec_enable(self); 182 #endif 183 netif_tx_wake_all_queues(self->ndev); 184 } 185 if (netif_carrier_ok(self->ndev) && !self->link_status.mbps) { 186 netif_carrier_off(self->ndev); 187 netif_tx_disable(self->ndev); 188 aq_utils_obj_set(&self->flags, AQ_NIC_LINK_DOWN); 189 } 190 191 return 0; 192 } 193 194 static irqreturn_t aq_linkstate_threaded_isr(int irq, void *private) 195 { 196 struct aq_nic_s *self = private; 197 198 if (!self) 199 return IRQ_NONE; 200 201 aq_nic_update_link_status(self); 202 203 self->aq_hw_ops->hw_irq_enable(self->aq_hw, 204 BIT(self->aq_nic_cfg.link_irq_vec)); 205 206 return IRQ_HANDLED; 207 } 208 209 static void aq_nic_service_task(struct work_struct *work) 210 { 211 struct aq_nic_s *self = container_of(work, struct aq_nic_s, 212 service_task); 213 int err; 214 215 aq_ptp_service_task(self); 216 217 if (aq_utils_obj_test(&self->flags, AQ_NIC_FLAGS_IS_NOT_READY)) 218 return; 219 220 err = aq_nic_update_link_status(self); 221 if (err) 222 return; 223 224 #if IS_ENABLED(CONFIG_MACSEC) 225 aq_macsec_work(self); 226 #endif 227 228 mutex_lock(&self->fwreq_mutex); 229 if (self->aq_fw_ops->update_stats) 230 self->aq_fw_ops->update_stats(self->aq_hw); 231 mutex_unlock(&self->fwreq_mutex); 232 233 aq_nic_update_ndev_stats(self); 234 } 235 236 static void aq_nic_service_timer_cb(struct timer_list *t) 237 { 238 struct aq_nic_s *self = from_timer(self, t, service_timer); 239 240 mod_timer(&self->service_timer, 241 jiffies + AQ_CFG_SERVICE_TIMER_INTERVAL); 242 243 aq_ndev_schedule_work(&self->service_task); 244 } 245 246 static void aq_nic_polling_timer_cb(struct timer_list *t) 247 { 248 struct aq_nic_s *self = from_timer(self, t, polling_timer); 249 struct aq_vec_s *aq_vec = NULL; 250 unsigned int i = 0U; 251 252 for (i = 0U, aq_vec = self->aq_vec[0]; 253 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 254 aq_vec_isr(i, (void *)aq_vec); 255 256 mod_timer(&self->polling_timer, jiffies + 257 AQ_CFG_POLLING_TIMER_INTERVAL); 258 } 259 260 static int aq_nic_hw_prepare(struct aq_nic_s *self) 261 { 262 int err = 0; 263 264 err = self->aq_hw_ops->hw_soft_reset(self->aq_hw); 265 if (err) 266 goto exit; 267 268 err = self->aq_hw_ops->hw_prepare(self->aq_hw, &self->aq_fw_ops); 269 270 exit: 271 return err; 272 } 273 274 int aq_nic_ndev_register(struct aq_nic_s *self) 275 { 276 int err = 0; 277 278 if (!self->ndev) { 279 err = -EINVAL; 280 goto err_exit; 281 } 282 283 err = aq_nic_hw_prepare(self); 284 if (err) 285 goto err_exit; 286 287 #if IS_ENABLED(CONFIG_MACSEC) 288 aq_macsec_init(self); 289 #endif 290 291 mutex_lock(&self->fwreq_mutex); 292 err = self->aq_fw_ops->get_mac_permanent(self->aq_hw, 293 self->ndev->dev_addr); 294 mutex_unlock(&self->fwreq_mutex); 295 if (err) 296 goto err_exit; 297 298 #if defined(AQ_CFG_MAC_ADDR_PERMANENT) 299 { 300 static u8 mac_addr_permanent[] = AQ_CFG_MAC_ADDR_PERMANENT; 301 302 ether_addr_copy(self->ndev->dev_addr, mac_addr_permanent); 303 } 304 #endif 305 306 for (self->aq_vecs = 0; self->aq_vecs < aq_nic_get_cfg(self)->vecs; 307 self->aq_vecs++) { 308 self->aq_vec[self->aq_vecs] = 309 aq_vec_alloc(self, self->aq_vecs, aq_nic_get_cfg(self)); 310 if (!self->aq_vec[self->aq_vecs]) { 311 err = -ENOMEM; 312 goto err_exit; 313 } 314 } 315 316 netif_carrier_off(self->ndev); 317 318 netif_tx_disable(self->ndev); 319 320 err = register_netdev(self->ndev); 321 if (err) 322 goto err_exit; 323 324 err_exit: 325 #if IS_ENABLED(CONFIG_MACSEC) 326 if (err) 327 aq_macsec_free(self); 328 #endif 329 return err; 330 } 331 332 void aq_nic_ndev_init(struct aq_nic_s *self) 333 { 334 const struct aq_hw_caps_s *aq_hw_caps = self->aq_nic_cfg.aq_hw_caps; 335 struct aq_nic_cfg_s *aq_nic_cfg = &self->aq_nic_cfg; 336 337 self->ndev->hw_features |= aq_hw_caps->hw_features; 338 self->ndev->features = aq_hw_caps->hw_features; 339 self->ndev->vlan_features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM | 340 NETIF_F_RXHASH | NETIF_F_SG | 341 NETIF_F_LRO | NETIF_F_TSO; 342 self->ndev->gso_partial_features = NETIF_F_GSO_UDP_L4; 343 self->ndev->priv_flags = aq_hw_caps->hw_priv_flags; 344 self->ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 345 346 self->msg_enable = NETIF_MSG_DRV | NETIF_MSG_LINK; 347 self->ndev->mtu = aq_nic_cfg->mtu - ETH_HLEN; 348 self->ndev->max_mtu = aq_hw_caps->mtu - ETH_FCS_LEN - ETH_HLEN; 349 350 } 351 352 void aq_nic_set_tx_ring(struct aq_nic_s *self, unsigned int idx, 353 struct aq_ring_s *ring) 354 { 355 self->aq_ring_tx[idx] = ring; 356 } 357 358 struct net_device *aq_nic_get_ndev(struct aq_nic_s *self) 359 { 360 return self->ndev; 361 } 362 363 int aq_nic_init(struct aq_nic_s *self) 364 { 365 struct aq_vec_s *aq_vec = NULL; 366 unsigned int i = 0U; 367 int err = 0; 368 369 self->power_state = AQ_HW_POWER_STATE_D0; 370 mutex_lock(&self->fwreq_mutex); 371 err = self->aq_hw_ops->hw_reset(self->aq_hw); 372 mutex_unlock(&self->fwreq_mutex); 373 if (err < 0) 374 goto err_exit; 375 376 err = self->aq_hw_ops->hw_init(self->aq_hw, 377 aq_nic_get_ndev(self)->dev_addr); 378 if (err < 0) 379 goto err_exit; 380 381 if (ATL_HW_IS_CHIP_FEATURE(self->aq_hw, ATLANTIC) && 382 self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_TP) { 383 self->aq_hw->phy_id = HW_ATL_PHY_ID_MAX; 384 err = aq_phy_init(self->aq_hw); 385 } 386 387 for (i = 0U, aq_vec = self->aq_vec[0]; 388 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 389 aq_vec_init(aq_vec, self->aq_hw_ops, self->aq_hw); 390 391 err = aq_ptp_init(self, self->irqvecs - 1); 392 if (err < 0) 393 goto err_exit; 394 395 err = aq_ptp_ring_alloc(self); 396 if (err < 0) 397 goto err_exit; 398 399 err = aq_ptp_ring_init(self); 400 if (err < 0) 401 goto err_exit; 402 403 netif_carrier_off(self->ndev); 404 405 err_exit: 406 return err; 407 } 408 409 int aq_nic_start(struct aq_nic_s *self) 410 { 411 struct aq_vec_s *aq_vec = NULL; 412 unsigned int i = 0U; 413 int err = 0; 414 415 err = self->aq_hw_ops->hw_multicast_list_set(self->aq_hw, 416 self->mc_list.ar, 417 self->mc_list.count); 418 if (err < 0) 419 goto err_exit; 420 421 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, 422 self->packet_filter); 423 if (err < 0) 424 goto err_exit; 425 426 for (i = 0U, aq_vec = self->aq_vec[0]; 427 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 428 err = aq_vec_start(aq_vec); 429 if (err < 0) 430 goto err_exit; 431 } 432 433 err = aq_ptp_ring_start(self); 434 if (err < 0) 435 goto err_exit; 436 437 aq_nic_set_loopback(self); 438 439 err = self->aq_hw_ops->hw_start(self->aq_hw); 440 if (err < 0) 441 goto err_exit; 442 443 err = aq_nic_update_interrupt_moderation_settings(self); 444 if (err) 445 goto err_exit; 446 447 INIT_WORK(&self->service_task, aq_nic_service_task); 448 449 timer_setup(&self->service_timer, aq_nic_service_timer_cb, 0); 450 aq_nic_service_timer_cb(&self->service_timer); 451 452 if (self->aq_nic_cfg.is_polling) { 453 timer_setup(&self->polling_timer, aq_nic_polling_timer_cb, 0); 454 mod_timer(&self->polling_timer, jiffies + 455 AQ_CFG_POLLING_TIMER_INTERVAL); 456 } else { 457 for (i = 0U, aq_vec = self->aq_vec[0]; 458 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 459 err = aq_pci_func_alloc_irq(self, i, self->ndev->name, 460 aq_vec_isr, aq_vec, 461 aq_vec_get_affinity_mask(aq_vec)); 462 if (err < 0) 463 goto err_exit; 464 } 465 466 err = aq_ptp_irq_alloc(self); 467 if (err < 0) 468 goto err_exit; 469 470 if (self->aq_nic_cfg.link_irq_vec) { 471 int irqvec = pci_irq_vector(self->pdev, 472 self->aq_nic_cfg.link_irq_vec); 473 err = request_threaded_irq(irqvec, NULL, 474 aq_linkstate_threaded_isr, 475 IRQF_SHARED | IRQF_ONESHOT, 476 self->ndev->name, self); 477 if (err < 0) 478 goto err_exit; 479 self->msix_entry_mask |= (1 << self->aq_nic_cfg.link_irq_vec); 480 } 481 482 err = self->aq_hw_ops->hw_irq_enable(self->aq_hw, 483 AQ_CFG_IRQ_MASK); 484 if (err < 0) 485 goto err_exit; 486 } 487 488 err = netif_set_real_num_tx_queues(self->ndev, self->aq_vecs); 489 if (err < 0) 490 goto err_exit; 491 492 err = netif_set_real_num_rx_queues(self->ndev, self->aq_vecs); 493 if (err < 0) 494 goto err_exit; 495 496 netif_tx_start_all_queues(self->ndev); 497 498 err_exit: 499 return err; 500 } 501 502 unsigned int aq_nic_map_skb(struct aq_nic_s *self, struct sk_buff *skb, 503 struct aq_ring_s *ring) 504 { 505 unsigned int nr_frags = skb_shinfo(skb)->nr_frags; 506 struct aq_ring_buff_s *first = NULL; 507 u8 ipver = ip_hdr(skb)->version; 508 struct aq_ring_buff_s *dx_buff; 509 bool need_context_tag = false; 510 unsigned int frag_count = 0U; 511 unsigned int ret = 0U; 512 unsigned int dx; 513 u8 l4proto = 0; 514 515 if (ipver == 4) 516 l4proto = ip_hdr(skb)->protocol; 517 else if (ipver == 6) 518 l4proto = ipv6_hdr(skb)->nexthdr; 519 520 dx = ring->sw_tail; 521 dx_buff = &ring->buff_ring[dx]; 522 dx_buff->flags = 0U; 523 524 if (unlikely(skb_is_gso(skb))) { 525 dx_buff->mss = skb_shinfo(skb)->gso_size; 526 if (l4proto == IPPROTO_TCP) { 527 dx_buff->is_gso_tcp = 1U; 528 dx_buff->len_l4 = tcp_hdrlen(skb); 529 } else if (l4proto == IPPROTO_UDP) { 530 dx_buff->is_gso_udp = 1U; 531 dx_buff->len_l4 = sizeof(struct udphdr); 532 /* UDP GSO Hardware does not replace packet length. */ 533 udp_hdr(skb)->len = htons(dx_buff->mss + 534 dx_buff->len_l4); 535 } else { 536 WARN_ONCE(true, "Bad GSO mode"); 537 goto exit; 538 } 539 dx_buff->len_pkt = skb->len; 540 dx_buff->len_l2 = ETH_HLEN; 541 dx_buff->len_l3 = skb_network_header_len(skb); 542 dx_buff->eop_index = 0xffffU; 543 dx_buff->is_ipv6 = (ipver == 6); 544 need_context_tag = true; 545 } 546 547 if (self->aq_nic_cfg.is_vlan_tx_insert && skb_vlan_tag_present(skb)) { 548 dx_buff->vlan_tx_tag = skb_vlan_tag_get(skb); 549 dx_buff->len_pkt = skb->len; 550 dx_buff->is_vlan = 1U; 551 need_context_tag = true; 552 } 553 554 if (need_context_tag) { 555 dx = aq_ring_next_dx(ring, dx); 556 dx_buff = &ring->buff_ring[dx]; 557 dx_buff->flags = 0U; 558 ++ret; 559 } 560 561 dx_buff->len = skb_headlen(skb); 562 dx_buff->pa = dma_map_single(aq_nic_get_dev(self), 563 skb->data, 564 dx_buff->len, 565 DMA_TO_DEVICE); 566 567 if (unlikely(dma_mapping_error(aq_nic_get_dev(self), dx_buff->pa))) { 568 ret = 0; 569 goto exit; 570 } 571 572 first = dx_buff; 573 dx_buff->len_pkt = skb->len; 574 dx_buff->is_sop = 1U; 575 dx_buff->is_mapped = 1U; 576 ++ret; 577 578 if (skb->ip_summed == CHECKSUM_PARTIAL) { 579 dx_buff->is_ip_cso = (htons(ETH_P_IP) == skb->protocol); 580 dx_buff->is_tcp_cso = (l4proto == IPPROTO_TCP); 581 dx_buff->is_udp_cso = (l4proto == IPPROTO_UDP); 582 } 583 584 for (; nr_frags--; ++frag_count) { 585 unsigned int frag_len = 0U; 586 unsigned int buff_offset = 0U; 587 unsigned int buff_size = 0U; 588 dma_addr_t frag_pa; 589 skb_frag_t *frag = &skb_shinfo(skb)->frags[frag_count]; 590 591 frag_len = skb_frag_size(frag); 592 593 while (frag_len) { 594 if (frag_len > AQ_CFG_TX_FRAME_MAX) 595 buff_size = AQ_CFG_TX_FRAME_MAX; 596 else 597 buff_size = frag_len; 598 599 frag_pa = skb_frag_dma_map(aq_nic_get_dev(self), 600 frag, 601 buff_offset, 602 buff_size, 603 DMA_TO_DEVICE); 604 605 if (unlikely(dma_mapping_error(aq_nic_get_dev(self), 606 frag_pa))) 607 goto mapping_error; 608 609 dx = aq_ring_next_dx(ring, dx); 610 dx_buff = &ring->buff_ring[dx]; 611 612 dx_buff->flags = 0U; 613 dx_buff->len = buff_size; 614 dx_buff->pa = frag_pa; 615 dx_buff->is_mapped = 1U; 616 dx_buff->eop_index = 0xffffU; 617 618 frag_len -= buff_size; 619 buff_offset += buff_size; 620 621 ++ret; 622 } 623 } 624 625 first->eop_index = dx; 626 dx_buff->is_eop = 1U; 627 dx_buff->skb = skb; 628 goto exit; 629 630 mapping_error: 631 for (dx = ring->sw_tail; 632 ret > 0; 633 --ret, dx = aq_ring_next_dx(ring, dx)) { 634 dx_buff = &ring->buff_ring[dx]; 635 636 if (!(dx_buff->is_gso_tcp || dx_buff->is_gso_udp) && 637 !dx_buff->is_vlan && dx_buff->pa) { 638 if (unlikely(dx_buff->is_sop)) { 639 dma_unmap_single(aq_nic_get_dev(self), 640 dx_buff->pa, 641 dx_buff->len, 642 DMA_TO_DEVICE); 643 } else { 644 dma_unmap_page(aq_nic_get_dev(self), 645 dx_buff->pa, 646 dx_buff->len, 647 DMA_TO_DEVICE); 648 } 649 } 650 } 651 652 exit: 653 return ret; 654 } 655 656 int aq_nic_xmit(struct aq_nic_s *self, struct sk_buff *skb) 657 { 658 unsigned int vec = skb->queue_mapping % self->aq_nic_cfg.vecs; 659 struct aq_ring_s *ring = NULL; 660 unsigned int frags = 0U; 661 int err = NETDEV_TX_OK; 662 unsigned int tc = 0U; 663 664 frags = skb_shinfo(skb)->nr_frags + 1; 665 666 ring = self->aq_ring_tx[AQ_NIC_TCVEC2RING(self, tc, vec)]; 667 668 if (frags > AQ_CFG_SKB_FRAGS_MAX) { 669 dev_kfree_skb_any(skb); 670 goto err_exit; 671 } 672 673 aq_ring_update_queue_state(ring); 674 675 if (self->aq_nic_cfg.priv_flags & BIT(AQ_HW_LOOPBACK_DMA_NET)) { 676 err = NETDEV_TX_BUSY; 677 goto err_exit; 678 } 679 680 /* Above status update may stop the queue. Check this. */ 681 if (__netif_subqueue_stopped(self->ndev, ring->idx)) { 682 err = NETDEV_TX_BUSY; 683 goto err_exit; 684 } 685 686 frags = aq_nic_map_skb(self, skb, ring); 687 688 if (likely(frags)) { 689 err = self->aq_hw_ops->hw_ring_tx_xmit(self->aq_hw, 690 ring, frags); 691 } else { 692 err = NETDEV_TX_BUSY; 693 } 694 695 err_exit: 696 return err; 697 } 698 699 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s *self) 700 { 701 return self->aq_hw_ops->hw_interrupt_moderation_set(self->aq_hw); 702 } 703 704 int aq_nic_set_packet_filter(struct aq_nic_s *self, unsigned int flags) 705 { 706 int err = 0; 707 708 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, flags); 709 if (err < 0) 710 goto err_exit; 711 712 self->packet_filter = flags; 713 714 err_exit: 715 return err; 716 } 717 718 int aq_nic_set_multicast_list(struct aq_nic_s *self, struct net_device *ndev) 719 { 720 const struct aq_hw_ops *hw_ops = self->aq_hw_ops; 721 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 722 unsigned int packet_filter = ndev->flags; 723 struct netdev_hw_addr *ha = NULL; 724 unsigned int i = 0U; 725 int err = 0; 726 727 self->mc_list.count = 0; 728 if (netdev_uc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) { 729 packet_filter |= IFF_PROMISC; 730 } else { 731 netdev_for_each_uc_addr(ha, ndev) { 732 ether_addr_copy(self->mc_list.ar[i++], ha->addr); 733 } 734 } 735 736 cfg->is_mc_list_enabled = !!(packet_filter & IFF_MULTICAST); 737 if (cfg->is_mc_list_enabled) { 738 if (i + netdev_mc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) { 739 packet_filter |= IFF_ALLMULTI; 740 } else { 741 netdev_for_each_mc_addr(ha, ndev) { 742 ether_addr_copy(self->mc_list.ar[i++], 743 ha->addr); 744 } 745 } 746 } 747 748 if (i > 0 && i <= AQ_HW_MULTICAST_ADDRESS_MAX) { 749 self->mc_list.count = i; 750 err = hw_ops->hw_multicast_list_set(self->aq_hw, 751 self->mc_list.ar, 752 self->mc_list.count); 753 if (err < 0) 754 return err; 755 } 756 757 return aq_nic_set_packet_filter(self, packet_filter); 758 } 759 760 int aq_nic_set_mtu(struct aq_nic_s *self, int new_mtu) 761 { 762 self->aq_nic_cfg.mtu = new_mtu; 763 764 return 0; 765 } 766 767 int aq_nic_set_mac(struct aq_nic_s *self, struct net_device *ndev) 768 { 769 return self->aq_hw_ops->hw_set_mac_address(self->aq_hw, ndev->dev_addr); 770 } 771 772 unsigned int aq_nic_get_link_speed(struct aq_nic_s *self) 773 { 774 return self->link_status.mbps; 775 } 776 777 int aq_nic_get_regs(struct aq_nic_s *self, struct ethtool_regs *regs, void *p) 778 { 779 u32 *regs_buff = p; 780 int err = 0; 781 782 if (unlikely(!self->aq_hw_ops->hw_get_regs)) 783 return -EOPNOTSUPP; 784 785 regs->version = 1; 786 787 err = self->aq_hw_ops->hw_get_regs(self->aq_hw, 788 self->aq_nic_cfg.aq_hw_caps, 789 regs_buff); 790 if (err < 0) 791 goto err_exit; 792 793 err_exit: 794 return err; 795 } 796 797 int aq_nic_get_regs_count(struct aq_nic_s *self) 798 { 799 if (unlikely(!self->aq_hw_ops->hw_get_regs)) 800 return 0; 801 802 return self->aq_nic_cfg.aq_hw_caps->mac_regs_count; 803 } 804 805 u64 *aq_nic_get_stats(struct aq_nic_s *self, u64 *data) 806 { 807 struct aq_vec_s *aq_vec = NULL; 808 struct aq_stats_s *stats; 809 unsigned int count = 0U; 810 unsigned int i = 0U; 811 812 if (self->aq_fw_ops->update_stats) { 813 mutex_lock(&self->fwreq_mutex); 814 self->aq_fw_ops->update_stats(self->aq_hw); 815 mutex_unlock(&self->fwreq_mutex); 816 } 817 stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw); 818 819 if (!stats) 820 goto err_exit; 821 822 data[i] = stats->uprc + stats->mprc + stats->bprc; 823 data[++i] = stats->uprc; 824 data[++i] = stats->mprc; 825 data[++i] = stats->bprc; 826 data[++i] = stats->erpt; 827 data[++i] = stats->uptc + stats->mptc + stats->bptc; 828 data[++i] = stats->uptc; 829 data[++i] = stats->mptc; 830 data[++i] = stats->bptc; 831 data[++i] = stats->ubrc; 832 data[++i] = stats->ubtc; 833 data[++i] = stats->mbrc; 834 data[++i] = stats->mbtc; 835 data[++i] = stats->bbrc; 836 data[++i] = stats->bbtc; 837 data[++i] = stats->ubrc + stats->mbrc + stats->bbrc; 838 data[++i] = stats->ubtc + stats->mbtc + stats->bbtc; 839 data[++i] = stats->dma_pkt_rc; 840 data[++i] = stats->dma_pkt_tc; 841 data[++i] = stats->dma_oct_rc; 842 data[++i] = stats->dma_oct_tc; 843 data[++i] = stats->dpc; 844 845 i++; 846 847 data += i; 848 849 for (i = 0U, aq_vec = self->aq_vec[0]; 850 aq_vec && self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) { 851 data += count; 852 aq_vec_get_sw_stats(aq_vec, data, &count); 853 } 854 855 data += count; 856 857 err_exit:; 858 return data; 859 } 860 861 static void aq_nic_update_ndev_stats(struct aq_nic_s *self) 862 { 863 struct aq_stats_s *stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw); 864 struct net_device *ndev = self->ndev; 865 866 ndev->stats.rx_packets = stats->dma_pkt_rc; 867 ndev->stats.rx_bytes = stats->dma_oct_rc; 868 ndev->stats.rx_errors = stats->erpr; 869 ndev->stats.rx_dropped = stats->dpc; 870 ndev->stats.tx_packets = stats->dma_pkt_tc; 871 ndev->stats.tx_bytes = stats->dma_oct_tc; 872 ndev->stats.tx_errors = stats->erpt; 873 ndev->stats.multicast = stats->mprc; 874 } 875 876 void aq_nic_get_link_ksettings(struct aq_nic_s *self, 877 struct ethtool_link_ksettings *cmd) 878 { 879 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 880 cmd->base.port = PORT_FIBRE; 881 else 882 cmd->base.port = PORT_TP; 883 /* This driver supports only 10G capable adapters, so DUPLEX_FULL */ 884 cmd->base.duplex = DUPLEX_FULL; 885 cmd->base.autoneg = self->aq_nic_cfg.is_autoneg; 886 887 ethtool_link_ksettings_zero_link_mode(cmd, supported); 888 889 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_10G) 890 ethtool_link_ksettings_add_link_mode(cmd, supported, 891 10000baseT_Full); 892 893 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_5G) 894 ethtool_link_ksettings_add_link_mode(cmd, supported, 895 5000baseT_Full); 896 897 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_2GS) 898 ethtool_link_ksettings_add_link_mode(cmd, supported, 899 2500baseT_Full); 900 901 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_1G) 902 ethtool_link_ksettings_add_link_mode(cmd, supported, 903 1000baseT_Full); 904 905 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_100M) 906 ethtool_link_ksettings_add_link_mode(cmd, supported, 907 100baseT_Full); 908 909 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_10M) 910 ethtool_link_ksettings_add_link_mode(cmd, supported, 911 10baseT_Full); 912 913 if (self->aq_nic_cfg.aq_hw_caps->flow_control) { 914 ethtool_link_ksettings_add_link_mode(cmd, supported, 915 Pause); 916 ethtool_link_ksettings_add_link_mode(cmd, supported, 917 Asym_Pause); 918 } 919 920 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 921 922 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 923 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE); 924 else 925 ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 926 927 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 928 929 if (self->aq_nic_cfg.is_autoneg) 930 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg); 931 932 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_10G) 933 ethtool_link_ksettings_add_link_mode(cmd, advertising, 934 10000baseT_Full); 935 936 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_5G) 937 ethtool_link_ksettings_add_link_mode(cmd, advertising, 938 5000baseT_Full); 939 940 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_2GS) 941 ethtool_link_ksettings_add_link_mode(cmd, advertising, 942 2500baseT_Full); 943 944 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_1G) 945 ethtool_link_ksettings_add_link_mode(cmd, advertising, 946 1000baseT_Full); 947 948 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_100M) 949 ethtool_link_ksettings_add_link_mode(cmd, advertising, 950 100baseT_Full); 951 952 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_10M) 953 ethtool_link_ksettings_add_link_mode(cmd, advertising, 954 10baseT_Full); 955 956 if (self->aq_nic_cfg.fc.cur & AQ_NIC_FC_RX) 957 ethtool_link_ksettings_add_link_mode(cmd, advertising, 958 Pause); 959 960 /* Asym is when either RX or TX, but not both */ 961 if (!!(self->aq_nic_cfg.fc.cur & AQ_NIC_FC_TX) ^ 962 !!(self->aq_nic_cfg.fc.cur & AQ_NIC_FC_RX)) 963 ethtool_link_ksettings_add_link_mode(cmd, advertising, 964 Asym_Pause); 965 966 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE) 967 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE); 968 else 969 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 970 } 971 972 int aq_nic_set_link_ksettings(struct aq_nic_s *self, 973 const struct ethtool_link_ksettings *cmd) 974 { 975 u32 speed = 0U; 976 u32 rate = 0U; 977 int err = 0; 978 979 if (cmd->base.autoneg == AUTONEG_ENABLE) { 980 rate = self->aq_nic_cfg.aq_hw_caps->link_speed_msk; 981 self->aq_nic_cfg.is_autoneg = true; 982 } else { 983 speed = cmd->base.speed; 984 985 switch (speed) { 986 case SPEED_10: 987 rate = AQ_NIC_RATE_10M; 988 break; 989 990 case SPEED_100: 991 rate = AQ_NIC_RATE_100M; 992 break; 993 994 case SPEED_1000: 995 rate = AQ_NIC_RATE_1G; 996 break; 997 998 case SPEED_2500: 999 rate = AQ_NIC_RATE_2GS; 1000 break; 1001 1002 case SPEED_5000: 1003 rate = AQ_NIC_RATE_5G; 1004 break; 1005 1006 case SPEED_10000: 1007 rate = AQ_NIC_RATE_10G; 1008 break; 1009 1010 default: 1011 err = -1; 1012 goto err_exit; 1013 break; 1014 } 1015 if (!(self->aq_nic_cfg.aq_hw_caps->link_speed_msk & rate)) { 1016 err = -1; 1017 goto err_exit; 1018 } 1019 1020 self->aq_nic_cfg.is_autoneg = false; 1021 } 1022 1023 mutex_lock(&self->fwreq_mutex); 1024 err = self->aq_fw_ops->set_link_speed(self->aq_hw, rate); 1025 mutex_unlock(&self->fwreq_mutex); 1026 if (err < 0) 1027 goto err_exit; 1028 1029 self->aq_nic_cfg.link_speed_msk = rate; 1030 1031 err_exit: 1032 return err; 1033 } 1034 1035 struct aq_nic_cfg_s *aq_nic_get_cfg(struct aq_nic_s *self) 1036 { 1037 return &self->aq_nic_cfg; 1038 } 1039 1040 u32 aq_nic_get_fw_version(struct aq_nic_s *self) 1041 { 1042 return self->aq_hw_ops->hw_get_fw_version(self->aq_hw); 1043 } 1044 1045 int aq_nic_set_loopback(struct aq_nic_s *self) 1046 { 1047 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg; 1048 1049 if (!self->aq_hw_ops->hw_set_loopback || 1050 !self->aq_fw_ops->set_phyloopback) 1051 return -ENOTSUPP; 1052 1053 mutex_lock(&self->fwreq_mutex); 1054 self->aq_hw_ops->hw_set_loopback(self->aq_hw, 1055 AQ_HW_LOOPBACK_DMA_SYS, 1056 !!(cfg->priv_flags & 1057 BIT(AQ_HW_LOOPBACK_DMA_SYS))); 1058 1059 self->aq_hw_ops->hw_set_loopback(self->aq_hw, 1060 AQ_HW_LOOPBACK_PKT_SYS, 1061 !!(cfg->priv_flags & 1062 BIT(AQ_HW_LOOPBACK_PKT_SYS))); 1063 1064 self->aq_hw_ops->hw_set_loopback(self->aq_hw, 1065 AQ_HW_LOOPBACK_DMA_NET, 1066 !!(cfg->priv_flags & 1067 BIT(AQ_HW_LOOPBACK_DMA_NET))); 1068 1069 self->aq_fw_ops->set_phyloopback(self->aq_hw, 1070 AQ_HW_LOOPBACK_PHYINT_SYS, 1071 !!(cfg->priv_flags & 1072 BIT(AQ_HW_LOOPBACK_PHYINT_SYS))); 1073 1074 self->aq_fw_ops->set_phyloopback(self->aq_hw, 1075 AQ_HW_LOOPBACK_PHYEXT_SYS, 1076 !!(cfg->priv_flags & 1077 BIT(AQ_HW_LOOPBACK_PHYEXT_SYS))); 1078 mutex_unlock(&self->fwreq_mutex); 1079 1080 return 0; 1081 } 1082 1083 int aq_nic_stop(struct aq_nic_s *self) 1084 { 1085 struct aq_vec_s *aq_vec = NULL; 1086 unsigned int i = 0U; 1087 1088 netif_tx_disable(self->ndev); 1089 netif_carrier_off(self->ndev); 1090 1091 del_timer_sync(&self->service_timer); 1092 cancel_work_sync(&self->service_task); 1093 1094 self->aq_hw_ops->hw_irq_disable(self->aq_hw, AQ_CFG_IRQ_MASK); 1095 1096 if (self->aq_nic_cfg.is_polling) 1097 del_timer_sync(&self->polling_timer); 1098 else 1099 aq_pci_func_free_irqs(self); 1100 1101 aq_ptp_irq_free(self); 1102 1103 for (i = 0U, aq_vec = self->aq_vec[0]; 1104 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 1105 aq_vec_stop(aq_vec); 1106 1107 aq_ptp_ring_stop(self); 1108 1109 return self->aq_hw_ops->hw_stop(self->aq_hw); 1110 } 1111 1112 void aq_nic_set_power(struct aq_nic_s *self) 1113 { 1114 if (self->power_state != AQ_HW_POWER_STATE_D0 || 1115 self->aq_hw->aq_nic_cfg->wol) 1116 if (likely(self->aq_fw_ops->set_power)) { 1117 mutex_lock(&self->fwreq_mutex); 1118 self->aq_fw_ops->set_power(self->aq_hw, 1119 self->power_state, 1120 self->ndev->dev_addr); 1121 mutex_unlock(&self->fwreq_mutex); 1122 } 1123 } 1124 1125 void aq_nic_deinit(struct aq_nic_s *self, bool link_down) 1126 { 1127 struct aq_vec_s *aq_vec = NULL; 1128 unsigned int i = 0U; 1129 1130 if (!self) 1131 goto err_exit; 1132 1133 for (i = 0U, aq_vec = self->aq_vec[0]; 1134 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) 1135 aq_vec_deinit(aq_vec); 1136 1137 aq_ptp_unregister(self); 1138 aq_ptp_ring_deinit(self); 1139 aq_ptp_ring_free(self); 1140 aq_ptp_free(self); 1141 1142 if (likely(self->aq_fw_ops->deinit) && link_down) { 1143 mutex_lock(&self->fwreq_mutex); 1144 self->aq_fw_ops->deinit(self->aq_hw); 1145 mutex_unlock(&self->fwreq_mutex); 1146 } 1147 1148 err_exit:; 1149 } 1150 1151 void aq_nic_free_vectors(struct aq_nic_s *self) 1152 { 1153 unsigned int i = 0U; 1154 1155 if (!self) 1156 goto err_exit; 1157 1158 for (i = ARRAY_SIZE(self->aq_vec); i--;) { 1159 if (self->aq_vec[i]) { 1160 aq_vec_free(self->aq_vec[i]); 1161 self->aq_vec[i] = NULL; 1162 } 1163 } 1164 1165 err_exit:; 1166 } 1167 1168 void aq_nic_shutdown(struct aq_nic_s *self) 1169 { 1170 int err = 0; 1171 1172 if (!self->ndev) 1173 return; 1174 1175 rtnl_lock(); 1176 1177 netif_device_detach(self->ndev); 1178 1179 if (netif_running(self->ndev)) { 1180 err = aq_nic_stop(self); 1181 if (err < 0) 1182 goto err_exit; 1183 } 1184 aq_nic_deinit(self, !self->aq_hw->aq_nic_cfg->wol); 1185 aq_nic_set_power(self); 1186 1187 err_exit: 1188 rtnl_unlock(); 1189 } 1190 1191 u8 aq_nic_reserve_filter(struct aq_nic_s *self, enum aq_rx_filter_type type) 1192 { 1193 u8 location = 0xFF; 1194 u32 fltr_cnt; 1195 u32 n_bit; 1196 1197 switch (type) { 1198 case aq_rx_filter_ethertype: 1199 location = AQ_RX_LAST_LOC_FETHERT - AQ_RX_FIRST_LOC_FETHERT - 1200 self->aq_hw_rx_fltrs.fet_reserved_count; 1201 self->aq_hw_rx_fltrs.fet_reserved_count++; 1202 break; 1203 case aq_rx_filter_l3l4: 1204 fltr_cnt = AQ_RX_LAST_LOC_FL3L4 - AQ_RX_FIRST_LOC_FL3L4; 1205 n_bit = fltr_cnt - self->aq_hw_rx_fltrs.fl3l4.reserved_count; 1206 1207 self->aq_hw_rx_fltrs.fl3l4.active_ipv4 |= BIT(n_bit); 1208 self->aq_hw_rx_fltrs.fl3l4.reserved_count++; 1209 location = n_bit; 1210 break; 1211 default: 1212 break; 1213 } 1214 1215 return location; 1216 } 1217 1218 void aq_nic_release_filter(struct aq_nic_s *self, enum aq_rx_filter_type type, 1219 u32 location) 1220 { 1221 switch (type) { 1222 case aq_rx_filter_ethertype: 1223 self->aq_hw_rx_fltrs.fet_reserved_count--; 1224 break; 1225 case aq_rx_filter_l3l4: 1226 self->aq_hw_rx_fltrs.fl3l4.reserved_count--; 1227 self->aq_hw_rx_fltrs.fl3l4.active_ipv4 &= ~BIT(location); 1228 break; 1229 default: 1230 break; 1231 } 1232 } 1233