1 /* 2 * Copyright (C) 2005 - 2016 Broadcom 3 * All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License version 2 7 * as published by the Free Software Foundation. The full GNU General 8 * Public License is included in this distribution in the file called COPYING. 9 * 10 * Contact Information: 11 * linux-drivers@emulex.com 12 * 13 * Emulex 14 * 3333 Susan Street 15 * Costa Mesa, CA 92626 16 */ 17 18 #include <linux/prefetch.h> 19 #include <linux/module.h> 20 #include "be.h" 21 #include "be_cmds.h" 22 #include <asm/div64.h> 23 #include <linux/aer.h> 24 #include <linux/if_bridge.h> 25 #include <net/busy_poll.h> 26 #include <net/vxlan.h> 27 28 MODULE_VERSION(DRV_VER); 29 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER); 30 MODULE_AUTHOR("Emulex Corporation"); 31 MODULE_LICENSE("GPL"); 32 33 /* num_vfs module param is obsolete. 34 * Use sysfs method to enable/disable VFs. 35 */ 36 static unsigned int num_vfs; 37 module_param(num_vfs, uint, S_IRUGO); 38 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize"); 39 40 static ushort rx_frag_size = 2048; 41 module_param(rx_frag_size, ushort, S_IRUGO); 42 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data."); 43 44 /* Per-module error detection/recovery workq shared across all functions. 45 * Each function schedules its own work request on this shared workq. 46 */ 47 static struct workqueue_struct *be_err_recovery_workq; 48 49 static const struct pci_device_id be_dev_ids[] = { 50 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) }, 51 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) }, 52 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) }, 53 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) }, 54 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)}, 55 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)}, 56 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)}, 57 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)}, 58 { 0 } 59 }; 60 MODULE_DEVICE_TABLE(pci, be_dev_ids); 61 62 /* Workqueue used by all functions for defering cmd calls to the adapter */ 63 static struct workqueue_struct *be_wq; 64 65 /* UE Status Low CSR */ 66 static const char * const ue_status_low_desc[] = { 67 "CEV", 68 "CTX", 69 "DBUF", 70 "ERX", 71 "Host", 72 "MPU", 73 "NDMA", 74 "PTC ", 75 "RDMA ", 76 "RXF ", 77 "RXIPS ", 78 "RXULP0 ", 79 "RXULP1 ", 80 "RXULP2 ", 81 "TIM ", 82 "TPOST ", 83 "TPRE ", 84 "TXIPS ", 85 "TXULP0 ", 86 "TXULP1 ", 87 "UC ", 88 "WDMA ", 89 "TXULP2 ", 90 "HOST1 ", 91 "P0_OB_LINK ", 92 "P1_OB_LINK ", 93 "HOST_GPIO ", 94 "MBOX ", 95 "ERX2 ", 96 "SPARE ", 97 "JTAG ", 98 "MPU_INTPEND " 99 }; 100 101 /* UE Status High CSR */ 102 static const char * const ue_status_hi_desc[] = { 103 "LPCMEMHOST", 104 "MGMT_MAC", 105 "PCS0ONLINE", 106 "MPU_IRAM", 107 "PCS1ONLINE", 108 "PCTL0", 109 "PCTL1", 110 "PMEM", 111 "RR", 112 "TXPB", 113 "RXPP", 114 "XAUI", 115 "TXP", 116 "ARM", 117 "IPC", 118 "HOST2", 119 "HOST3", 120 "HOST4", 121 "HOST5", 122 "HOST6", 123 "HOST7", 124 "ECRC", 125 "Poison TLP", 126 "NETC", 127 "PERIPH", 128 "LLTXULP", 129 "D2P", 130 "RCON", 131 "LDMA", 132 "LLTXP", 133 "LLTXPB", 134 "Unknown" 135 }; 136 137 #define BE_VF_IF_EN_FLAGS (BE_IF_FLAGS_UNTAGGED | \ 138 BE_IF_FLAGS_BROADCAST | \ 139 BE_IF_FLAGS_MULTICAST | \ 140 BE_IF_FLAGS_PASS_L3L4_ERRORS) 141 142 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q) 143 { 144 struct be_dma_mem *mem = &q->dma_mem; 145 146 if (mem->va) { 147 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va, 148 mem->dma); 149 mem->va = NULL; 150 } 151 } 152 153 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q, 154 u16 len, u16 entry_size) 155 { 156 struct be_dma_mem *mem = &q->dma_mem; 157 158 memset(q, 0, sizeof(*q)); 159 q->len = len; 160 q->entry_size = entry_size; 161 mem->size = len * entry_size; 162 mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma, 163 GFP_KERNEL); 164 if (!mem->va) 165 return -ENOMEM; 166 return 0; 167 } 168 169 static void be_reg_intr_set(struct be_adapter *adapter, bool enable) 170 { 171 u32 reg, enabled; 172 173 pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, 174 ®); 175 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK; 176 177 if (!enabled && enable) 178 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK; 179 else if (enabled && !enable) 180 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK; 181 else 182 return; 183 184 pci_write_config_dword(adapter->pdev, 185 PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg); 186 } 187 188 static void be_intr_set(struct be_adapter *adapter, bool enable) 189 { 190 int status = 0; 191 192 /* On lancer interrupts can't be controlled via this register */ 193 if (lancer_chip(adapter)) 194 return; 195 196 if (be_check_error(adapter, BE_ERROR_EEH)) 197 return; 198 199 status = be_cmd_intr_set(adapter, enable); 200 if (status) 201 be_reg_intr_set(adapter, enable); 202 } 203 204 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted) 205 { 206 u32 val = 0; 207 208 if (be_check_error(adapter, BE_ERROR_HW)) 209 return; 210 211 val |= qid & DB_RQ_RING_ID_MASK; 212 val |= posted << DB_RQ_NUM_POSTED_SHIFT; 213 214 wmb(); 215 iowrite32(val, adapter->db + DB_RQ_OFFSET); 216 } 217 218 static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo, 219 u16 posted) 220 { 221 u32 val = 0; 222 223 if (be_check_error(adapter, BE_ERROR_HW)) 224 return; 225 226 val |= txo->q.id & DB_TXULP_RING_ID_MASK; 227 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT; 228 229 wmb(); 230 iowrite32(val, adapter->db + txo->db_offset); 231 } 232 233 static void be_eq_notify(struct be_adapter *adapter, u16 qid, 234 bool arm, bool clear_int, u16 num_popped, 235 u32 eq_delay_mult_enc) 236 { 237 u32 val = 0; 238 239 val |= qid & DB_EQ_RING_ID_MASK; 240 val |= ((qid & DB_EQ_RING_ID_EXT_MASK) << DB_EQ_RING_ID_EXT_MASK_SHIFT); 241 242 if (be_check_error(adapter, BE_ERROR_HW)) 243 return; 244 245 if (arm) 246 val |= 1 << DB_EQ_REARM_SHIFT; 247 if (clear_int) 248 val |= 1 << DB_EQ_CLR_SHIFT; 249 val |= 1 << DB_EQ_EVNT_SHIFT; 250 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT; 251 val |= eq_delay_mult_enc << DB_EQ_R2I_DLY_SHIFT; 252 iowrite32(val, adapter->db + DB_EQ_OFFSET); 253 } 254 255 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped) 256 { 257 u32 val = 0; 258 259 val |= qid & DB_CQ_RING_ID_MASK; 260 val |= ((qid & DB_CQ_RING_ID_EXT_MASK) << 261 DB_CQ_RING_ID_EXT_MASK_SHIFT); 262 263 if (be_check_error(adapter, BE_ERROR_HW)) 264 return; 265 266 if (arm) 267 val |= 1 << DB_CQ_REARM_SHIFT; 268 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT; 269 iowrite32(val, adapter->db + DB_CQ_OFFSET); 270 } 271 272 static int be_dev_mac_add(struct be_adapter *adapter, u8 *mac) 273 { 274 int i; 275 276 /* Check if mac has already been added as part of uc-list */ 277 for (i = 0; i < adapter->uc_macs; i++) { 278 if (ether_addr_equal(adapter->uc_list[i].mac, mac)) { 279 /* mac already added, skip addition */ 280 adapter->pmac_id[0] = adapter->pmac_id[i + 1]; 281 return 0; 282 } 283 } 284 285 return be_cmd_pmac_add(adapter, mac, adapter->if_handle, 286 &adapter->pmac_id[0], 0); 287 } 288 289 static void be_dev_mac_del(struct be_adapter *adapter, int pmac_id) 290 { 291 int i; 292 293 /* Skip deletion if the programmed mac is 294 * being used in uc-list 295 */ 296 for (i = 0; i < adapter->uc_macs; i++) { 297 if (adapter->pmac_id[i + 1] == pmac_id) 298 return; 299 } 300 be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0); 301 } 302 303 static int be_mac_addr_set(struct net_device *netdev, void *p) 304 { 305 struct be_adapter *adapter = netdev_priv(netdev); 306 struct device *dev = &adapter->pdev->dev; 307 struct sockaddr *addr = p; 308 int status; 309 u8 mac[ETH_ALEN]; 310 u32 old_pmac_id = adapter->pmac_id[0]; 311 312 if (!is_valid_ether_addr(addr->sa_data)) 313 return -EADDRNOTAVAIL; 314 315 /* Proceed further only if, User provided MAC is different 316 * from active MAC 317 */ 318 if (ether_addr_equal(addr->sa_data, adapter->dev_mac)) 319 return 0; 320 321 /* BE3 VFs without FILTMGMT privilege are not allowed to set its MAC 322 * address 323 */ 324 if (BEx_chip(adapter) && be_virtfn(adapter) && 325 !check_privilege(adapter, BE_PRIV_FILTMGMT)) 326 return -EPERM; 327 328 /* if device is not running, copy MAC to netdev->dev_addr */ 329 if (!netif_running(netdev)) 330 goto done; 331 332 /* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT 333 * privilege or if PF did not provision the new MAC address. 334 * On BE3, this cmd will always fail if the VF doesn't have the 335 * FILTMGMT privilege. This failure is OK, only if the PF programmed 336 * the MAC for the VF. 337 */ 338 mutex_lock(&adapter->rx_filter_lock); 339 status = be_dev_mac_add(adapter, (u8 *)addr->sa_data); 340 if (!status) { 341 342 /* Delete the old programmed MAC. This call may fail if the 343 * old MAC was already deleted by the PF driver. 344 */ 345 if (adapter->pmac_id[0] != old_pmac_id) 346 be_dev_mac_del(adapter, old_pmac_id); 347 } 348 349 mutex_unlock(&adapter->rx_filter_lock); 350 /* Decide if the new MAC is successfully activated only after 351 * querying the FW 352 */ 353 status = be_cmd_get_active_mac(adapter, adapter->pmac_id[0], mac, 354 adapter->if_handle, true, 0); 355 if (status) 356 goto err; 357 358 /* The MAC change did not happen, either due to lack of privilege 359 * or PF didn't pre-provision. 360 */ 361 if (!ether_addr_equal(addr->sa_data, mac)) { 362 status = -EPERM; 363 goto err; 364 } 365 366 /* Remember currently programmed MAC */ 367 ether_addr_copy(adapter->dev_mac, addr->sa_data); 368 done: 369 ether_addr_copy(netdev->dev_addr, addr->sa_data); 370 dev_info(dev, "MAC address changed to %pM\n", addr->sa_data); 371 return 0; 372 err: 373 dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data); 374 return status; 375 } 376 377 /* BE2 supports only v0 cmd */ 378 static void *hw_stats_from_cmd(struct be_adapter *adapter) 379 { 380 if (BE2_chip(adapter)) { 381 struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va; 382 383 return &cmd->hw_stats; 384 } else if (BE3_chip(adapter)) { 385 struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va; 386 387 return &cmd->hw_stats; 388 } else { 389 struct be_cmd_resp_get_stats_v2 *cmd = adapter->stats_cmd.va; 390 391 return &cmd->hw_stats; 392 } 393 } 394 395 /* BE2 supports only v0 cmd */ 396 static void *be_erx_stats_from_cmd(struct be_adapter *adapter) 397 { 398 if (BE2_chip(adapter)) { 399 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter); 400 401 return &hw_stats->erx; 402 } else if (BE3_chip(adapter)) { 403 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter); 404 405 return &hw_stats->erx; 406 } else { 407 struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter); 408 409 return &hw_stats->erx; 410 } 411 } 412 413 static void populate_be_v0_stats(struct be_adapter *adapter) 414 { 415 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter); 416 struct be_pmem_stats *pmem_sts = &hw_stats->pmem; 417 struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf; 418 struct be_port_rxf_stats_v0 *port_stats = 419 &rxf_stats->port[adapter->port_num]; 420 struct be_drv_stats *drvs = &adapter->drv_stats; 421 422 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats)); 423 drvs->rx_pause_frames = port_stats->rx_pause_frames; 424 drvs->rx_crc_errors = port_stats->rx_crc_errors; 425 drvs->rx_control_frames = port_stats->rx_control_frames; 426 drvs->rx_in_range_errors = port_stats->rx_in_range_errors; 427 drvs->rx_frame_too_long = port_stats->rx_frame_too_long; 428 drvs->rx_dropped_runt = port_stats->rx_dropped_runt; 429 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 430 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 431 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 432 drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow; 433 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length; 434 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small; 435 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short; 436 drvs->rx_out_range_errors = port_stats->rx_out_range_errors; 437 drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow; 438 drvs->rx_dropped_header_too_small = 439 port_stats->rx_dropped_header_too_small; 440 drvs->rx_address_filtered = 441 port_stats->rx_address_filtered + 442 port_stats->rx_vlan_filtered; 443 drvs->rx_alignment_symbol_errors = 444 port_stats->rx_alignment_symbol_errors; 445 446 drvs->tx_pauseframes = port_stats->tx_pauseframes; 447 drvs->tx_controlframes = port_stats->tx_controlframes; 448 449 if (adapter->port_num) 450 drvs->jabber_events = rxf_stats->port1_jabber_events; 451 else 452 drvs->jabber_events = rxf_stats->port0_jabber_events; 453 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 454 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 455 drvs->forwarded_packets = rxf_stats->forwarded_packets; 456 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu; 457 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr; 458 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags; 459 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops; 460 } 461 462 static void populate_be_v1_stats(struct be_adapter *adapter) 463 { 464 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter); 465 struct be_pmem_stats *pmem_sts = &hw_stats->pmem; 466 struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf; 467 struct be_port_rxf_stats_v1 *port_stats = 468 &rxf_stats->port[adapter->port_num]; 469 struct be_drv_stats *drvs = &adapter->drv_stats; 470 471 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats)); 472 drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop; 473 drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames; 474 drvs->rx_pause_frames = port_stats->rx_pause_frames; 475 drvs->rx_crc_errors = port_stats->rx_crc_errors; 476 drvs->rx_control_frames = port_stats->rx_control_frames; 477 drvs->rx_in_range_errors = port_stats->rx_in_range_errors; 478 drvs->rx_frame_too_long = port_stats->rx_frame_too_long; 479 drvs->rx_dropped_runt = port_stats->rx_dropped_runt; 480 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 481 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 482 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 483 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length; 484 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small; 485 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short; 486 drvs->rx_out_range_errors = port_stats->rx_out_range_errors; 487 drvs->rx_dropped_header_too_small = 488 port_stats->rx_dropped_header_too_small; 489 drvs->rx_input_fifo_overflow_drop = 490 port_stats->rx_input_fifo_overflow_drop; 491 drvs->rx_address_filtered = port_stats->rx_address_filtered; 492 drvs->rx_alignment_symbol_errors = 493 port_stats->rx_alignment_symbol_errors; 494 drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop; 495 drvs->tx_pauseframes = port_stats->tx_pauseframes; 496 drvs->tx_controlframes = port_stats->tx_controlframes; 497 drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes; 498 drvs->jabber_events = port_stats->jabber_events; 499 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 500 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 501 drvs->forwarded_packets = rxf_stats->forwarded_packets; 502 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu; 503 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr; 504 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags; 505 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops; 506 } 507 508 static void populate_be_v2_stats(struct be_adapter *adapter) 509 { 510 struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter); 511 struct be_pmem_stats *pmem_sts = &hw_stats->pmem; 512 struct be_rxf_stats_v2 *rxf_stats = &hw_stats->rxf; 513 struct be_port_rxf_stats_v2 *port_stats = 514 &rxf_stats->port[adapter->port_num]; 515 struct be_drv_stats *drvs = &adapter->drv_stats; 516 517 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats)); 518 drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop; 519 drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames; 520 drvs->rx_pause_frames = port_stats->rx_pause_frames; 521 drvs->rx_crc_errors = port_stats->rx_crc_errors; 522 drvs->rx_control_frames = port_stats->rx_control_frames; 523 drvs->rx_in_range_errors = port_stats->rx_in_range_errors; 524 drvs->rx_frame_too_long = port_stats->rx_frame_too_long; 525 drvs->rx_dropped_runt = port_stats->rx_dropped_runt; 526 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 527 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 528 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 529 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length; 530 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small; 531 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short; 532 drvs->rx_out_range_errors = port_stats->rx_out_range_errors; 533 drvs->rx_dropped_header_too_small = 534 port_stats->rx_dropped_header_too_small; 535 drvs->rx_input_fifo_overflow_drop = 536 port_stats->rx_input_fifo_overflow_drop; 537 drvs->rx_address_filtered = port_stats->rx_address_filtered; 538 drvs->rx_alignment_symbol_errors = 539 port_stats->rx_alignment_symbol_errors; 540 drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop; 541 drvs->tx_pauseframes = port_stats->tx_pauseframes; 542 drvs->tx_controlframes = port_stats->tx_controlframes; 543 drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes; 544 drvs->jabber_events = port_stats->jabber_events; 545 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 546 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 547 drvs->forwarded_packets = rxf_stats->forwarded_packets; 548 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu; 549 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr; 550 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags; 551 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops; 552 if (be_roce_supported(adapter)) { 553 drvs->rx_roce_bytes_lsd = port_stats->roce_bytes_received_lsd; 554 drvs->rx_roce_bytes_msd = port_stats->roce_bytes_received_msd; 555 drvs->rx_roce_frames = port_stats->roce_frames_received; 556 drvs->roce_drops_crc = port_stats->roce_drops_crc; 557 drvs->roce_drops_payload_len = 558 port_stats->roce_drops_payload_len; 559 } 560 } 561 562 static void populate_lancer_stats(struct be_adapter *adapter) 563 { 564 struct be_drv_stats *drvs = &adapter->drv_stats; 565 struct lancer_pport_stats *pport_stats = pport_stats_from_cmd(adapter); 566 567 be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats)); 568 drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo; 569 drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo; 570 drvs->rx_control_frames = pport_stats->rx_control_frames_lo; 571 drvs->rx_in_range_errors = pport_stats->rx_in_range_errors; 572 drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo; 573 drvs->rx_dropped_runt = pport_stats->rx_dropped_runt; 574 drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors; 575 drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors; 576 drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors; 577 drvs->rx_dropped_tcp_length = 578 pport_stats->rx_dropped_invalid_tcp_length; 579 drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small; 580 drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short; 581 drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors; 582 drvs->rx_dropped_header_too_small = 583 pport_stats->rx_dropped_header_too_small; 584 drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow; 585 drvs->rx_address_filtered = 586 pport_stats->rx_address_filtered + 587 pport_stats->rx_vlan_filtered; 588 drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo; 589 drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow; 590 drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo; 591 drvs->tx_controlframes = pport_stats->tx_control_frames_lo; 592 drvs->jabber_events = pport_stats->rx_jabbers; 593 drvs->forwarded_packets = pport_stats->num_forwards_lo; 594 drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo; 595 drvs->rx_drops_too_many_frags = 596 pport_stats->rx_drops_too_many_frags_lo; 597 } 598 599 static void accumulate_16bit_val(u32 *acc, u16 val) 600 { 601 #define lo(x) (x & 0xFFFF) 602 #define hi(x) (x & 0xFFFF0000) 603 bool wrapped = val < lo(*acc); 604 u32 newacc = hi(*acc) + val; 605 606 if (wrapped) 607 newacc += 65536; 608 WRITE_ONCE(*acc, newacc); 609 } 610 611 static void populate_erx_stats(struct be_adapter *adapter, 612 struct be_rx_obj *rxo, u32 erx_stat) 613 { 614 if (!BEx_chip(adapter)) 615 rx_stats(rxo)->rx_drops_no_frags = erx_stat; 616 else 617 /* below erx HW counter can actually wrap around after 618 * 65535. Driver accumulates a 32-bit value 619 */ 620 accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags, 621 (u16)erx_stat); 622 } 623 624 void be_parse_stats(struct be_adapter *adapter) 625 { 626 struct be_erx_stats_v2 *erx = be_erx_stats_from_cmd(adapter); 627 struct be_rx_obj *rxo; 628 int i; 629 u32 erx_stat; 630 631 if (lancer_chip(adapter)) { 632 populate_lancer_stats(adapter); 633 } else { 634 if (BE2_chip(adapter)) 635 populate_be_v0_stats(adapter); 636 else if (BE3_chip(adapter)) 637 /* for BE3 */ 638 populate_be_v1_stats(adapter); 639 else 640 populate_be_v2_stats(adapter); 641 642 /* erx_v2 is longer than v0, v1. use v2 for v0, v1 access */ 643 for_all_rx_queues(adapter, rxo, i) { 644 erx_stat = erx->rx_drops_no_fragments[rxo->q.id]; 645 populate_erx_stats(adapter, rxo, erx_stat); 646 } 647 } 648 } 649 650 static void be_get_stats64(struct net_device *netdev, 651 struct rtnl_link_stats64 *stats) 652 { 653 struct be_adapter *adapter = netdev_priv(netdev); 654 struct be_drv_stats *drvs = &adapter->drv_stats; 655 struct be_rx_obj *rxo; 656 struct be_tx_obj *txo; 657 u64 pkts, bytes; 658 unsigned int start; 659 int i; 660 661 for_all_rx_queues(adapter, rxo, i) { 662 const struct be_rx_stats *rx_stats = rx_stats(rxo); 663 664 do { 665 start = u64_stats_fetch_begin_irq(&rx_stats->sync); 666 pkts = rx_stats(rxo)->rx_pkts; 667 bytes = rx_stats(rxo)->rx_bytes; 668 } while (u64_stats_fetch_retry_irq(&rx_stats->sync, start)); 669 stats->rx_packets += pkts; 670 stats->rx_bytes += bytes; 671 stats->multicast += rx_stats(rxo)->rx_mcast_pkts; 672 stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs + 673 rx_stats(rxo)->rx_drops_no_frags; 674 } 675 676 for_all_tx_queues(adapter, txo, i) { 677 const struct be_tx_stats *tx_stats = tx_stats(txo); 678 679 do { 680 start = u64_stats_fetch_begin_irq(&tx_stats->sync); 681 pkts = tx_stats(txo)->tx_pkts; 682 bytes = tx_stats(txo)->tx_bytes; 683 } while (u64_stats_fetch_retry_irq(&tx_stats->sync, start)); 684 stats->tx_packets += pkts; 685 stats->tx_bytes += bytes; 686 } 687 688 /* bad pkts received */ 689 stats->rx_errors = drvs->rx_crc_errors + 690 drvs->rx_alignment_symbol_errors + 691 drvs->rx_in_range_errors + 692 drvs->rx_out_range_errors + 693 drvs->rx_frame_too_long + 694 drvs->rx_dropped_too_small + 695 drvs->rx_dropped_too_short + 696 drvs->rx_dropped_header_too_small + 697 drvs->rx_dropped_tcp_length + 698 drvs->rx_dropped_runt; 699 700 /* detailed rx errors */ 701 stats->rx_length_errors = drvs->rx_in_range_errors + 702 drvs->rx_out_range_errors + 703 drvs->rx_frame_too_long; 704 705 stats->rx_crc_errors = drvs->rx_crc_errors; 706 707 /* frame alignment errors */ 708 stats->rx_frame_errors = drvs->rx_alignment_symbol_errors; 709 710 /* receiver fifo overrun */ 711 /* drops_no_pbuf is no per i/f, it's per BE card */ 712 stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop + 713 drvs->rx_input_fifo_overflow_drop + 714 drvs->rx_drops_no_pbuf; 715 } 716 717 void be_link_status_update(struct be_adapter *adapter, u8 link_status) 718 { 719 struct net_device *netdev = adapter->netdev; 720 721 if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) { 722 netif_carrier_off(netdev); 723 adapter->flags |= BE_FLAGS_LINK_STATUS_INIT; 724 } 725 726 if (link_status) 727 netif_carrier_on(netdev); 728 else 729 netif_carrier_off(netdev); 730 731 netdev_info(netdev, "Link is %s\n", link_status ? "Up" : "Down"); 732 } 733 734 static int be_gso_hdr_len(struct sk_buff *skb) 735 { 736 if (skb->encapsulation) 737 return skb_inner_transport_offset(skb) + 738 inner_tcp_hdrlen(skb); 739 return skb_transport_offset(skb) + tcp_hdrlen(skb); 740 } 741 742 static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb) 743 { 744 struct be_tx_stats *stats = tx_stats(txo); 745 u32 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1; 746 /* Account for headers which get duplicated in TSO pkt */ 747 u32 dup_hdr_len = tx_pkts > 1 ? be_gso_hdr_len(skb) * (tx_pkts - 1) : 0; 748 749 u64_stats_update_begin(&stats->sync); 750 stats->tx_reqs++; 751 stats->tx_bytes += skb->len + dup_hdr_len; 752 stats->tx_pkts += tx_pkts; 753 if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL) 754 stats->tx_vxlan_offload_pkts += tx_pkts; 755 u64_stats_update_end(&stats->sync); 756 } 757 758 /* Returns number of WRBs needed for the skb */ 759 static u32 skb_wrb_cnt(struct sk_buff *skb) 760 { 761 /* +1 for the header wrb */ 762 return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags; 763 } 764 765 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len) 766 { 767 wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr)); 768 wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr)); 769 wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK); 770 wrb->rsvd0 = 0; 771 } 772 773 /* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb 774 * to avoid the swap and shift/mask operations in wrb_fill(). 775 */ 776 static inline void wrb_fill_dummy(struct be_eth_wrb *wrb) 777 { 778 wrb->frag_pa_hi = 0; 779 wrb->frag_pa_lo = 0; 780 wrb->frag_len = 0; 781 wrb->rsvd0 = 0; 782 } 783 784 static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter, 785 struct sk_buff *skb) 786 { 787 u8 vlan_prio; 788 u16 vlan_tag; 789 790 vlan_tag = skb_vlan_tag_get(skb); 791 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT; 792 /* If vlan priority provided by OS is NOT in available bmap */ 793 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio))) 794 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) | 795 adapter->recommended_prio_bits; 796 797 return vlan_tag; 798 } 799 800 /* Used only for IP tunnel packets */ 801 static u16 skb_inner_ip_proto(struct sk_buff *skb) 802 { 803 return (inner_ip_hdr(skb)->version == 4) ? 804 inner_ip_hdr(skb)->protocol : inner_ipv6_hdr(skb)->nexthdr; 805 } 806 807 static u16 skb_ip_proto(struct sk_buff *skb) 808 { 809 return (ip_hdr(skb)->version == 4) ? 810 ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr; 811 } 812 813 static inline bool be_is_txq_full(struct be_tx_obj *txo) 814 { 815 return atomic_read(&txo->q.used) + BE_MAX_TX_FRAG_COUNT >= txo->q.len; 816 } 817 818 static inline bool be_can_txq_wake(struct be_tx_obj *txo) 819 { 820 return atomic_read(&txo->q.used) < txo->q.len / 2; 821 } 822 823 static inline bool be_is_tx_compl_pending(struct be_tx_obj *txo) 824 { 825 return atomic_read(&txo->q.used) > txo->pend_wrb_cnt; 826 } 827 828 static void be_get_wrb_params_from_skb(struct be_adapter *adapter, 829 struct sk_buff *skb, 830 struct be_wrb_params *wrb_params) 831 { 832 u16 proto; 833 834 if (skb_is_gso(skb)) { 835 BE_WRB_F_SET(wrb_params->features, LSO, 1); 836 wrb_params->lso_mss = skb_shinfo(skb)->gso_size; 837 if (skb_is_gso_v6(skb) && !lancer_chip(adapter)) 838 BE_WRB_F_SET(wrb_params->features, LSO6, 1); 839 } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 840 if (skb->encapsulation) { 841 BE_WRB_F_SET(wrb_params->features, IPCS, 1); 842 proto = skb_inner_ip_proto(skb); 843 } else { 844 proto = skb_ip_proto(skb); 845 } 846 if (proto == IPPROTO_TCP) 847 BE_WRB_F_SET(wrb_params->features, TCPCS, 1); 848 else if (proto == IPPROTO_UDP) 849 BE_WRB_F_SET(wrb_params->features, UDPCS, 1); 850 } 851 852 if (skb_vlan_tag_present(skb)) { 853 BE_WRB_F_SET(wrb_params->features, VLAN, 1); 854 wrb_params->vlan_tag = be_get_tx_vlan_tag(adapter, skb); 855 } 856 857 BE_WRB_F_SET(wrb_params->features, CRC, 1); 858 } 859 860 static void wrb_fill_hdr(struct be_adapter *adapter, 861 struct be_eth_hdr_wrb *hdr, 862 struct be_wrb_params *wrb_params, 863 struct sk_buff *skb) 864 { 865 memset(hdr, 0, sizeof(*hdr)); 866 867 SET_TX_WRB_HDR_BITS(crc, hdr, 868 BE_WRB_F_GET(wrb_params->features, CRC)); 869 SET_TX_WRB_HDR_BITS(ipcs, hdr, 870 BE_WRB_F_GET(wrb_params->features, IPCS)); 871 SET_TX_WRB_HDR_BITS(tcpcs, hdr, 872 BE_WRB_F_GET(wrb_params->features, TCPCS)); 873 SET_TX_WRB_HDR_BITS(udpcs, hdr, 874 BE_WRB_F_GET(wrb_params->features, UDPCS)); 875 876 SET_TX_WRB_HDR_BITS(lso, hdr, 877 BE_WRB_F_GET(wrb_params->features, LSO)); 878 SET_TX_WRB_HDR_BITS(lso6, hdr, 879 BE_WRB_F_GET(wrb_params->features, LSO6)); 880 SET_TX_WRB_HDR_BITS(lso_mss, hdr, wrb_params->lso_mss); 881 882 /* Hack to skip HW VLAN tagging needs evt = 1, compl = 0. When this 883 * hack is not needed, the evt bit is set while ringing DB. 884 */ 885 SET_TX_WRB_HDR_BITS(event, hdr, 886 BE_WRB_F_GET(wrb_params->features, VLAN_SKIP_HW)); 887 SET_TX_WRB_HDR_BITS(vlan, hdr, 888 BE_WRB_F_GET(wrb_params->features, VLAN)); 889 SET_TX_WRB_HDR_BITS(vlan_tag, hdr, wrb_params->vlan_tag); 890 891 SET_TX_WRB_HDR_BITS(num_wrb, hdr, skb_wrb_cnt(skb)); 892 SET_TX_WRB_HDR_BITS(len, hdr, skb->len); 893 SET_TX_WRB_HDR_BITS(mgmt, hdr, 894 BE_WRB_F_GET(wrb_params->features, OS2BMC)); 895 } 896 897 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb, 898 bool unmap_single) 899 { 900 dma_addr_t dma; 901 u32 frag_len = le32_to_cpu(wrb->frag_len); 902 903 904 dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 | 905 (u64)le32_to_cpu(wrb->frag_pa_lo); 906 if (frag_len) { 907 if (unmap_single) 908 dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE); 909 else 910 dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE); 911 } 912 } 913 914 /* Grab a WRB header for xmit */ 915 static u32 be_tx_get_wrb_hdr(struct be_tx_obj *txo) 916 { 917 u32 head = txo->q.head; 918 919 queue_head_inc(&txo->q); 920 return head; 921 } 922 923 /* Set up the WRB header for xmit */ 924 static void be_tx_setup_wrb_hdr(struct be_adapter *adapter, 925 struct be_tx_obj *txo, 926 struct be_wrb_params *wrb_params, 927 struct sk_buff *skb, u16 head) 928 { 929 u32 num_frags = skb_wrb_cnt(skb); 930 struct be_queue_info *txq = &txo->q; 931 struct be_eth_hdr_wrb *hdr = queue_index_node(txq, head); 932 933 wrb_fill_hdr(adapter, hdr, wrb_params, skb); 934 be_dws_cpu_to_le(hdr, sizeof(*hdr)); 935 936 BUG_ON(txo->sent_skb_list[head]); 937 txo->sent_skb_list[head] = skb; 938 txo->last_req_hdr = head; 939 atomic_add(num_frags, &txq->used); 940 txo->last_req_wrb_cnt = num_frags; 941 txo->pend_wrb_cnt += num_frags; 942 } 943 944 /* Setup a WRB fragment (buffer descriptor) for xmit */ 945 static void be_tx_setup_wrb_frag(struct be_tx_obj *txo, dma_addr_t busaddr, 946 int len) 947 { 948 struct be_eth_wrb *wrb; 949 struct be_queue_info *txq = &txo->q; 950 951 wrb = queue_head_node(txq); 952 wrb_fill(wrb, busaddr, len); 953 queue_head_inc(txq); 954 } 955 956 /* Bring the queue back to the state it was in before be_xmit_enqueue() routine 957 * was invoked. The producer index is restored to the previous packet and the 958 * WRBs of the current packet are unmapped. Invoked to handle tx setup errors. 959 */ 960 static void be_xmit_restore(struct be_adapter *adapter, 961 struct be_tx_obj *txo, u32 head, bool map_single, 962 u32 copied) 963 { 964 struct device *dev; 965 struct be_eth_wrb *wrb; 966 struct be_queue_info *txq = &txo->q; 967 968 dev = &adapter->pdev->dev; 969 txq->head = head; 970 971 /* skip the first wrb (hdr); it's not mapped */ 972 queue_head_inc(txq); 973 while (copied) { 974 wrb = queue_head_node(txq); 975 unmap_tx_frag(dev, wrb, map_single); 976 map_single = false; 977 copied -= le32_to_cpu(wrb->frag_len); 978 queue_head_inc(txq); 979 } 980 981 txq->head = head; 982 } 983 984 /* Enqueue the given packet for transmit. This routine allocates WRBs for the 985 * packet, dma maps the packet buffers and sets up the WRBs. Returns the number 986 * of WRBs used up by the packet. 987 */ 988 static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo, 989 struct sk_buff *skb, 990 struct be_wrb_params *wrb_params) 991 { 992 u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb); 993 struct device *dev = &adapter->pdev->dev; 994 bool map_single = false; 995 u32 head; 996 dma_addr_t busaddr; 997 int len; 998 999 head = be_tx_get_wrb_hdr(txo); 1000 1001 if (skb->len > skb->data_len) { 1002 len = skb_headlen(skb); 1003 1004 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE); 1005 if (dma_mapping_error(dev, busaddr)) 1006 goto dma_err; 1007 map_single = true; 1008 be_tx_setup_wrb_frag(txo, busaddr, len); 1009 copied += len; 1010 } 1011 1012 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 1013 const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i]; 1014 len = skb_frag_size(frag); 1015 1016 busaddr = skb_frag_dma_map(dev, frag, 0, len, DMA_TO_DEVICE); 1017 if (dma_mapping_error(dev, busaddr)) 1018 goto dma_err; 1019 be_tx_setup_wrb_frag(txo, busaddr, len); 1020 copied += len; 1021 } 1022 1023 be_tx_setup_wrb_hdr(adapter, txo, wrb_params, skb, head); 1024 1025 be_tx_stats_update(txo, skb); 1026 return wrb_cnt; 1027 1028 dma_err: 1029 adapter->drv_stats.dma_map_errors++; 1030 be_xmit_restore(adapter, txo, head, map_single, copied); 1031 return 0; 1032 } 1033 1034 static inline int qnq_async_evt_rcvd(struct be_adapter *adapter) 1035 { 1036 return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD; 1037 } 1038 1039 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter, 1040 struct sk_buff *skb, 1041 struct be_wrb_params 1042 *wrb_params) 1043 { 1044 u16 vlan_tag = 0; 1045 1046 skb = skb_share_check(skb, GFP_ATOMIC); 1047 if (unlikely(!skb)) 1048 return skb; 1049 1050 if (skb_vlan_tag_present(skb)) 1051 vlan_tag = be_get_tx_vlan_tag(adapter, skb); 1052 1053 if (qnq_async_evt_rcvd(adapter) && adapter->pvid) { 1054 if (!vlan_tag) 1055 vlan_tag = adapter->pvid; 1056 /* f/w workaround to set skip_hw_vlan = 1, informs the F/W to 1057 * skip VLAN insertion 1058 */ 1059 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1); 1060 } 1061 1062 if (vlan_tag) { 1063 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q), 1064 vlan_tag); 1065 if (unlikely(!skb)) 1066 return skb; 1067 skb->vlan_tci = 0; 1068 } 1069 1070 /* Insert the outer VLAN, if any */ 1071 if (adapter->qnq_vid) { 1072 vlan_tag = adapter->qnq_vid; 1073 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q), 1074 vlan_tag); 1075 if (unlikely(!skb)) 1076 return skb; 1077 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1); 1078 } 1079 1080 return skb; 1081 } 1082 1083 static bool be_ipv6_exthdr_check(struct sk_buff *skb) 1084 { 1085 struct ethhdr *eh = (struct ethhdr *)skb->data; 1086 u16 offset = ETH_HLEN; 1087 1088 if (eh->h_proto == htons(ETH_P_IPV6)) { 1089 struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset); 1090 1091 offset += sizeof(struct ipv6hdr); 1092 if (ip6h->nexthdr != NEXTHDR_TCP && 1093 ip6h->nexthdr != NEXTHDR_UDP) { 1094 struct ipv6_opt_hdr *ehdr = 1095 (struct ipv6_opt_hdr *)(skb->data + offset); 1096 1097 /* offending pkt: 2nd byte following IPv6 hdr is 0xff */ 1098 if (ehdr->hdrlen == 0xff) 1099 return true; 1100 } 1101 } 1102 return false; 1103 } 1104 1105 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb) 1106 { 1107 return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid; 1108 } 1109 1110 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb) 1111 { 1112 return BE3_chip(adapter) && be_ipv6_exthdr_check(skb); 1113 } 1114 1115 static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter, 1116 struct sk_buff *skb, 1117 struct be_wrb_params 1118 *wrb_params) 1119 { 1120 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data; 1121 unsigned int eth_hdr_len; 1122 struct iphdr *ip; 1123 1124 /* For padded packets, BE HW modifies tot_len field in IP header 1125 * incorrecly when VLAN tag is inserted by HW. 1126 * For padded packets, Lancer computes incorrect checksum. 1127 */ 1128 eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ? 1129 VLAN_ETH_HLEN : ETH_HLEN; 1130 if (skb->len <= 60 && 1131 (lancer_chip(adapter) || skb_vlan_tag_present(skb)) && 1132 is_ipv4_pkt(skb)) { 1133 ip = (struct iphdr *)ip_hdr(skb); 1134 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len)); 1135 } 1136 1137 /* If vlan tag is already inlined in the packet, skip HW VLAN 1138 * tagging in pvid-tagging mode 1139 */ 1140 if (be_pvid_tagging_enabled(adapter) && 1141 veh->h_vlan_proto == htons(ETH_P_8021Q)) 1142 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1); 1143 1144 /* HW has a bug wherein it will calculate CSUM for VLAN 1145 * pkts even though it is disabled. 1146 * Manually insert VLAN in pkt. 1147 */ 1148 if (skb->ip_summed != CHECKSUM_PARTIAL && 1149 skb_vlan_tag_present(skb)) { 1150 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params); 1151 if (unlikely(!skb)) 1152 goto err; 1153 } 1154 1155 /* HW may lockup when VLAN HW tagging is requested on 1156 * certain ipv6 packets. Drop such pkts if the HW workaround to 1157 * skip HW tagging is not enabled by FW. 1158 */ 1159 if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) && 1160 (adapter->pvid || adapter->qnq_vid) && 1161 !qnq_async_evt_rcvd(adapter))) 1162 goto tx_drop; 1163 1164 /* Manual VLAN tag insertion to prevent: 1165 * ASIC lockup when the ASIC inserts VLAN tag into 1166 * certain ipv6 packets. Insert VLAN tags in driver, 1167 * and set event, completion, vlan bits accordingly 1168 * in the Tx WRB. 1169 */ 1170 if (be_ipv6_tx_stall_chk(adapter, skb) && 1171 be_vlan_tag_tx_chk(adapter, skb)) { 1172 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params); 1173 if (unlikely(!skb)) 1174 goto err; 1175 } 1176 1177 return skb; 1178 tx_drop: 1179 dev_kfree_skb_any(skb); 1180 err: 1181 return NULL; 1182 } 1183 1184 static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter, 1185 struct sk_buff *skb, 1186 struct be_wrb_params *wrb_params) 1187 { 1188 int err; 1189 1190 /* Lancer, SH and BE3 in SRIOV mode have a bug wherein 1191 * packets that are 32b or less may cause a transmit stall 1192 * on that port. The workaround is to pad such packets 1193 * (len <= 32 bytes) to a minimum length of 36b. 1194 */ 1195 if (skb->len <= 32) { 1196 if (skb_put_padto(skb, 36)) 1197 return NULL; 1198 } 1199 1200 if (BEx_chip(adapter) || lancer_chip(adapter)) { 1201 skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params); 1202 if (!skb) 1203 return NULL; 1204 } 1205 1206 /* The stack can send us skbs with length greater than 1207 * what the HW can handle. Trim the extra bytes. 1208 */ 1209 WARN_ON_ONCE(skb->len > BE_MAX_GSO_SIZE); 1210 err = pskb_trim(skb, BE_MAX_GSO_SIZE); 1211 WARN_ON(err); 1212 1213 return skb; 1214 } 1215 1216 static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo) 1217 { 1218 struct be_queue_info *txq = &txo->q; 1219 struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr); 1220 1221 /* Mark the last request eventable if it hasn't been marked already */ 1222 if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT))) 1223 hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL); 1224 1225 /* compose a dummy wrb if there are odd set of wrbs to notify */ 1226 if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) { 1227 wrb_fill_dummy(queue_head_node(txq)); 1228 queue_head_inc(txq); 1229 atomic_inc(&txq->used); 1230 txo->pend_wrb_cnt++; 1231 hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK << 1232 TX_HDR_WRB_NUM_SHIFT); 1233 hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) << 1234 TX_HDR_WRB_NUM_SHIFT); 1235 } 1236 be_txq_notify(adapter, txo, txo->pend_wrb_cnt); 1237 txo->pend_wrb_cnt = 0; 1238 } 1239 1240 /* OS2BMC related */ 1241 1242 #define DHCP_CLIENT_PORT 68 1243 #define DHCP_SERVER_PORT 67 1244 #define NET_BIOS_PORT1 137 1245 #define NET_BIOS_PORT2 138 1246 #define DHCPV6_RAS_PORT 547 1247 1248 #define is_mc_allowed_on_bmc(adapter, eh) \ 1249 (!is_multicast_filt_enabled(adapter) && \ 1250 is_multicast_ether_addr(eh->h_dest) && \ 1251 !is_broadcast_ether_addr(eh->h_dest)) 1252 1253 #define is_bc_allowed_on_bmc(adapter, eh) \ 1254 (!is_broadcast_filt_enabled(adapter) && \ 1255 is_broadcast_ether_addr(eh->h_dest)) 1256 1257 #define is_arp_allowed_on_bmc(adapter, skb) \ 1258 (is_arp(skb) && is_arp_filt_enabled(adapter)) 1259 1260 #define is_broadcast_packet(eh, adapter) \ 1261 (is_multicast_ether_addr(eh->h_dest) && \ 1262 !compare_ether_addr(eh->h_dest, adapter->netdev->broadcast)) 1263 1264 #define is_arp(skb) (skb->protocol == htons(ETH_P_ARP)) 1265 1266 #define is_arp_filt_enabled(adapter) \ 1267 (adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP)) 1268 1269 #define is_dhcp_client_filt_enabled(adapter) \ 1270 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT) 1271 1272 #define is_dhcp_srvr_filt_enabled(adapter) \ 1273 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER) 1274 1275 #define is_nbios_filt_enabled(adapter) \ 1276 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS) 1277 1278 #define is_ipv6_na_filt_enabled(adapter) \ 1279 (adapter->bmc_filt_mask & \ 1280 BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER) 1281 1282 #define is_ipv6_ra_filt_enabled(adapter) \ 1283 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA) 1284 1285 #define is_ipv6_ras_filt_enabled(adapter) \ 1286 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS) 1287 1288 #define is_broadcast_filt_enabled(adapter) \ 1289 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST) 1290 1291 #define is_multicast_filt_enabled(adapter) \ 1292 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST) 1293 1294 static bool be_send_pkt_to_bmc(struct be_adapter *adapter, 1295 struct sk_buff **skb) 1296 { 1297 struct ethhdr *eh = (struct ethhdr *)(*skb)->data; 1298 bool os2bmc = false; 1299 1300 if (!be_is_os2bmc_enabled(adapter)) 1301 goto done; 1302 1303 if (!is_multicast_ether_addr(eh->h_dest)) 1304 goto done; 1305 1306 if (is_mc_allowed_on_bmc(adapter, eh) || 1307 is_bc_allowed_on_bmc(adapter, eh) || 1308 is_arp_allowed_on_bmc(adapter, (*skb))) { 1309 os2bmc = true; 1310 goto done; 1311 } 1312 1313 if ((*skb)->protocol == htons(ETH_P_IPV6)) { 1314 struct ipv6hdr *hdr = ipv6_hdr((*skb)); 1315 u8 nexthdr = hdr->nexthdr; 1316 1317 if (nexthdr == IPPROTO_ICMPV6) { 1318 struct icmp6hdr *icmp6 = icmp6_hdr((*skb)); 1319 1320 switch (icmp6->icmp6_type) { 1321 case NDISC_ROUTER_ADVERTISEMENT: 1322 os2bmc = is_ipv6_ra_filt_enabled(adapter); 1323 goto done; 1324 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1325 os2bmc = is_ipv6_na_filt_enabled(adapter); 1326 goto done; 1327 default: 1328 break; 1329 } 1330 } 1331 } 1332 1333 if (is_udp_pkt((*skb))) { 1334 struct udphdr *udp = udp_hdr((*skb)); 1335 1336 switch (ntohs(udp->dest)) { 1337 case DHCP_CLIENT_PORT: 1338 os2bmc = is_dhcp_client_filt_enabled(adapter); 1339 goto done; 1340 case DHCP_SERVER_PORT: 1341 os2bmc = is_dhcp_srvr_filt_enabled(adapter); 1342 goto done; 1343 case NET_BIOS_PORT1: 1344 case NET_BIOS_PORT2: 1345 os2bmc = is_nbios_filt_enabled(adapter); 1346 goto done; 1347 case DHCPV6_RAS_PORT: 1348 os2bmc = is_ipv6_ras_filt_enabled(adapter); 1349 goto done; 1350 default: 1351 break; 1352 } 1353 } 1354 done: 1355 /* For packets over a vlan, which are destined 1356 * to BMC, asic expects the vlan to be inline in the packet. 1357 */ 1358 if (os2bmc) 1359 *skb = be_insert_vlan_in_pkt(adapter, *skb, NULL); 1360 1361 return os2bmc; 1362 } 1363 1364 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev) 1365 { 1366 struct be_adapter *adapter = netdev_priv(netdev); 1367 u16 q_idx = skb_get_queue_mapping(skb); 1368 struct be_tx_obj *txo = &adapter->tx_obj[q_idx]; 1369 struct be_wrb_params wrb_params = { 0 }; 1370 bool flush = !skb->xmit_more; 1371 u16 wrb_cnt; 1372 1373 skb = be_xmit_workarounds(adapter, skb, &wrb_params); 1374 if (unlikely(!skb)) 1375 goto drop; 1376 1377 be_get_wrb_params_from_skb(adapter, skb, &wrb_params); 1378 1379 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params); 1380 if (unlikely(!wrb_cnt)) { 1381 dev_kfree_skb_any(skb); 1382 goto drop; 1383 } 1384 1385 /* if os2bmc is enabled and if the pkt is destined to bmc, 1386 * enqueue the pkt a 2nd time with mgmt bit set. 1387 */ 1388 if (be_send_pkt_to_bmc(adapter, &skb)) { 1389 BE_WRB_F_SET(wrb_params.features, OS2BMC, 1); 1390 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params); 1391 if (unlikely(!wrb_cnt)) 1392 goto drop; 1393 else 1394 skb_get(skb); 1395 } 1396 1397 if (be_is_txq_full(txo)) { 1398 netif_stop_subqueue(netdev, q_idx); 1399 tx_stats(txo)->tx_stops++; 1400 } 1401 1402 if (flush || __netif_subqueue_stopped(netdev, q_idx)) 1403 be_xmit_flush(adapter, txo); 1404 1405 return NETDEV_TX_OK; 1406 drop: 1407 tx_stats(txo)->tx_drv_drops++; 1408 /* Flush the already enqueued tx requests */ 1409 if (flush && txo->pend_wrb_cnt) 1410 be_xmit_flush(adapter, txo); 1411 1412 return NETDEV_TX_OK; 1413 } 1414 1415 static inline bool be_in_all_promisc(struct be_adapter *adapter) 1416 { 1417 return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) == 1418 BE_IF_FLAGS_ALL_PROMISCUOUS; 1419 } 1420 1421 static int be_set_vlan_promisc(struct be_adapter *adapter) 1422 { 1423 struct device *dev = &adapter->pdev->dev; 1424 int status; 1425 1426 if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) 1427 return 0; 1428 1429 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON); 1430 if (!status) { 1431 dev_info(dev, "Enabled VLAN promiscuous mode\n"); 1432 adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS; 1433 } else { 1434 dev_err(dev, "Failed to enable VLAN promiscuous mode\n"); 1435 } 1436 return status; 1437 } 1438 1439 static int be_clear_vlan_promisc(struct be_adapter *adapter) 1440 { 1441 struct device *dev = &adapter->pdev->dev; 1442 int status; 1443 1444 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF); 1445 if (!status) { 1446 dev_info(dev, "Disabling VLAN promiscuous mode\n"); 1447 adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS; 1448 } 1449 return status; 1450 } 1451 1452 /* 1453 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE. 1454 * If the user configures more, place BE in vlan promiscuous mode. 1455 */ 1456 static int be_vid_config(struct be_adapter *adapter) 1457 { 1458 struct device *dev = &adapter->pdev->dev; 1459 u16 vids[BE_NUM_VLANS_SUPPORTED]; 1460 u16 num = 0, i = 0; 1461 int status = 0; 1462 1463 /* No need to change the VLAN state if the I/F is in promiscuous */ 1464 if (adapter->netdev->flags & IFF_PROMISC) 1465 return 0; 1466 1467 if (adapter->vlans_added > be_max_vlans(adapter)) 1468 return be_set_vlan_promisc(adapter); 1469 1470 if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) { 1471 status = be_clear_vlan_promisc(adapter); 1472 if (status) 1473 return status; 1474 } 1475 /* Construct VLAN Table to give to HW */ 1476 for_each_set_bit(i, adapter->vids, VLAN_N_VID) 1477 vids[num++] = cpu_to_le16(i); 1478 1479 status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0); 1480 if (status) { 1481 dev_err(dev, "Setting HW VLAN filtering failed\n"); 1482 /* Set to VLAN promisc mode as setting VLAN filter failed */ 1483 if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS || 1484 addl_status(status) == 1485 MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES) 1486 return be_set_vlan_promisc(adapter); 1487 } 1488 return status; 1489 } 1490 1491 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid) 1492 { 1493 struct be_adapter *adapter = netdev_priv(netdev); 1494 int status = 0; 1495 1496 mutex_lock(&adapter->rx_filter_lock); 1497 1498 /* Packets with VID 0 are always received by Lancer by default */ 1499 if (lancer_chip(adapter) && vid == 0) 1500 goto done; 1501 1502 if (test_bit(vid, adapter->vids)) 1503 goto done; 1504 1505 set_bit(vid, adapter->vids); 1506 adapter->vlans_added++; 1507 1508 status = be_vid_config(adapter); 1509 done: 1510 mutex_unlock(&adapter->rx_filter_lock); 1511 return status; 1512 } 1513 1514 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid) 1515 { 1516 struct be_adapter *adapter = netdev_priv(netdev); 1517 int status = 0; 1518 1519 mutex_lock(&adapter->rx_filter_lock); 1520 1521 /* Packets with VID 0 are always received by Lancer by default */ 1522 if (lancer_chip(adapter) && vid == 0) 1523 goto done; 1524 1525 if (!test_bit(vid, adapter->vids)) 1526 goto done; 1527 1528 clear_bit(vid, adapter->vids); 1529 adapter->vlans_added--; 1530 1531 status = be_vid_config(adapter); 1532 done: 1533 mutex_unlock(&adapter->rx_filter_lock); 1534 return status; 1535 } 1536 1537 static void be_set_all_promisc(struct be_adapter *adapter) 1538 { 1539 be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON); 1540 adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS; 1541 } 1542 1543 static void be_set_mc_promisc(struct be_adapter *adapter) 1544 { 1545 int status; 1546 1547 if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS) 1548 return; 1549 1550 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON); 1551 if (!status) 1552 adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS; 1553 } 1554 1555 static void be_set_uc_promisc(struct be_adapter *adapter) 1556 { 1557 int status; 1558 1559 if (adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS) 1560 return; 1561 1562 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_PROMISCUOUS, ON); 1563 if (!status) 1564 adapter->if_flags |= BE_IF_FLAGS_PROMISCUOUS; 1565 } 1566 1567 static void be_clear_uc_promisc(struct be_adapter *adapter) 1568 { 1569 int status; 1570 1571 if (!(adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS)) 1572 return; 1573 1574 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_PROMISCUOUS, OFF); 1575 if (!status) 1576 adapter->if_flags &= ~BE_IF_FLAGS_PROMISCUOUS; 1577 } 1578 1579 /* The below 2 functions are the callback args for __dev_mc_sync/dev_uc_sync(). 1580 * We use a single callback function for both sync and unsync. We really don't 1581 * add/remove addresses through this callback. But, we use it to detect changes 1582 * to the uc/mc lists. The entire uc/mc list is programmed in be_set_rx_mode(). 1583 */ 1584 static int be_uc_list_update(struct net_device *netdev, 1585 const unsigned char *addr) 1586 { 1587 struct be_adapter *adapter = netdev_priv(netdev); 1588 1589 adapter->update_uc_list = true; 1590 return 0; 1591 } 1592 1593 static int be_mc_list_update(struct net_device *netdev, 1594 const unsigned char *addr) 1595 { 1596 struct be_adapter *adapter = netdev_priv(netdev); 1597 1598 adapter->update_mc_list = true; 1599 return 0; 1600 } 1601 1602 static void be_set_mc_list(struct be_adapter *adapter) 1603 { 1604 struct net_device *netdev = adapter->netdev; 1605 struct netdev_hw_addr *ha; 1606 bool mc_promisc = false; 1607 int status; 1608 1609 netif_addr_lock_bh(netdev); 1610 __dev_mc_sync(netdev, be_mc_list_update, be_mc_list_update); 1611 1612 if (netdev->flags & IFF_PROMISC) { 1613 adapter->update_mc_list = false; 1614 } else if (netdev->flags & IFF_ALLMULTI || 1615 netdev_mc_count(netdev) > be_max_mc(adapter)) { 1616 /* Enable multicast promisc if num configured exceeds 1617 * what we support 1618 */ 1619 mc_promisc = true; 1620 adapter->update_mc_list = false; 1621 } else if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS) { 1622 /* Update mc-list unconditionally if the iface was previously 1623 * in mc-promisc mode and now is out of that mode. 1624 */ 1625 adapter->update_mc_list = true; 1626 } 1627 1628 if (adapter->update_mc_list) { 1629 int i = 0; 1630 1631 /* cache the mc-list in adapter */ 1632 netdev_for_each_mc_addr(ha, netdev) { 1633 ether_addr_copy(adapter->mc_list[i].mac, ha->addr); 1634 i++; 1635 } 1636 adapter->mc_count = netdev_mc_count(netdev); 1637 } 1638 netif_addr_unlock_bh(netdev); 1639 1640 if (mc_promisc) { 1641 be_set_mc_promisc(adapter); 1642 } else if (adapter->update_mc_list) { 1643 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON); 1644 if (!status) 1645 adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS; 1646 else 1647 be_set_mc_promisc(adapter); 1648 1649 adapter->update_mc_list = false; 1650 } 1651 } 1652 1653 static void be_clear_mc_list(struct be_adapter *adapter) 1654 { 1655 struct net_device *netdev = adapter->netdev; 1656 1657 __dev_mc_unsync(netdev, NULL); 1658 be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, OFF); 1659 adapter->mc_count = 0; 1660 } 1661 1662 static int be_uc_mac_add(struct be_adapter *adapter, int uc_idx) 1663 { 1664 if (ether_addr_equal(adapter->uc_list[uc_idx].mac, adapter->dev_mac)) { 1665 adapter->pmac_id[uc_idx + 1] = adapter->pmac_id[0]; 1666 return 0; 1667 } 1668 1669 return be_cmd_pmac_add(adapter, adapter->uc_list[uc_idx].mac, 1670 adapter->if_handle, 1671 &adapter->pmac_id[uc_idx + 1], 0); 1672 } 1673 1674 static void be_uc_mac_del(struct be_adapter *adapter, int pmac_id) 1675 { 1676 if (pmac_id == adapter->pmac_id[0]) 1677 return; 1678 1679 be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0); 1680 } 1681 1682 static void be_set_uc_list(struct be_adapter *adapter) 1683 { 1684 struct net_device *netdev = adapter->netdev; 1685 struct netdev_hw_addr *ha; 1686 bool uc_promisc = false; 1687 int curr_uc_macs = 0, i; 1688 1689 netif_addr_lock_bh(netdev); 1690 __dev_uc_sync(netdev, be_uc_list_update, be_uc_list_update); 1691 1692 if (netdev->flags & IFF_PROMISC) { 1693 adapter->update_uc_list = false; 1694 } else if (netdev_uc_count(netdev) > (be_max_uc(adapter) - 1)) { 1695 uc_promisc = true; 1696 adapter->update_uc_list = false; 1697 } else if (adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS) { 1698 /* Update uc-list unconditionally if the iface was previously 1699 * in uc-promisc mode and now is out of that mode. 1700 */ 1701 adapter->update_uc_list = true; 1702 } 1703 1704 if (adapter->update_uc_list) { 1705 /* cache the uc-list in adapter array */ 1706 i = 0; 1707 netdev_for_each_uc_addr(ha, netdev) { 1708 ether_addr_copy(adapter->uc_list[i].mac, ha->addr); 1709 i++; 1710 } 1711 curr_uc_macs = netdev_uc_count(netdev); 1712 } 1713 netif_addr_unlock_bh(netdev); 1714 1715 if (uc_promisc) { 1716 be_set_uc_promisc(adapter); 1717 } else if (adapter->update_uc_list) { 1718 be_clear_uc_promisc(adapter); 1719 1720 for (i = 0; i < adapter->uc_macs; i++) 1721 be_uc_mac_del(adapter, adapter->pmac_id[i + 1]); 1722 1723 for (i = 0; i < curr_uc_macs; i++) 1724 be_uc_mac_add(adapter, i); 1725 adapter->uc_macs = curr_uc_macs; 1726 adapter->update_uc_list = false; 1727 } 1728 } 1729 1730 static void be_clear_uc_list(struct be_adapter *adapter) 1731 { 1732 struct net_device *netdev = adapter->netdev; 1733 int i; 1734 1735 __dev_uc_unsync(netdev, NULL); 1736 for (i = 0; i < adapter->uc_macs; i++) 1737 be_uc_mac_del(adapter, adapter->pmac_id[i + 1]); 1738 1739 adapter->uc_macs = 0; 1740 } 1741 1742 static void __be_set_rx_mode(struct be_adapter *adapter) 1743 { 1744 struct net_device *netdev = adapter->netdev; 1745 1746 mutex_lock(&adapter->rx_filter_lock); 1747 1748 if (netdev->flags & IFF_PROMISC) { 1749 if (!be_in_all_promisc(adapter)) 1750 be_set_all_promisc(adapter); 1751 } else if (be_in_all_promisc(adapter)) { 1752 /* We need to re-program the vlan-list or clear 1753 * vlan-promisc mode (if needed) when the interface 1754 * comes out of promisc mode. 1755 */ 1756 be_vid_config(adapter); 1757 } 1758 1759 be_set_uc_list(adapter); 1760 be_set_mc_list(adapter); 1761 1762 mutex_unlock(&adapter->rx_filter_lock); 1763 } 1764 1765 static void be_work_set_rx_mode(struct work_struct *work) 1766 { 1767 struct be_cmd_work *cmd_work = 1768 container_of(work, struct be_cmd_work, work); 1769 1770 __be_set_rx_mode(cmd_work->adapter); 1771 kfree(cmd_work); 1772 } 1773 1774 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1775 { 1776 struct be_adapter *adapter = netdev_priv(netdev); 1777 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1778 int status; 1779 1780 if (!sriov_enabled(adapter)) 1781 return -EPERM; 1782 1783 if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs) 1784 return -EINVAL; 1785 1786 /* Proceed further only if user provided MAC is different 1787 * from active MAC 1788 */ 1789 if (ether_addr_equal(mac, vf_cfg->mac_addr)) 1790 return 0; 1791 1792 if (BEx_chip(adapter)) { 1793 be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id, 1794 vf + 1); 1795 1796 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle, 1797 &vf_cfg->pmac_id, vf + 1); 1798 } else { 1799 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle, 1800 vf + 1); 1801 } 1802 1803 if (status) { 1804 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x", 1805 mac, vf, status); 1806 return be_cmd_status(status); 1807 } 1808 1809 ether_addr_copy(vf_cfg->mac_addr, mac); 1810 1811 return 0; 1812 } 1813 1814 static int be_get_vf_config(struct net_device *netdev, int vf, 1815 struct ifla_vf_info *vi) 1816 { 1817 struct be_adapter *adapter = netdev_priv(netdev); 1818 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1819 1820 if (!sriov_enabled(adapter)) 1821 return -EPERM; 1822 1823 if (vf >= adapter->num_vfs) 1824 return -EINVAL; 1825 1826 vi->vf = vf; 1827 vi->max_tx_rate = vf_cfg->tx_rate; 1828 vi->min_tx_rate = 0; 1829 vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK; 1830 vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT; 1831 memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN); 1832 vi->linkstate = adapter->vf_cfg[vf].plink_tracking; 1833 vi->spoofchk = adapter->vf_cfg[vf].spoofchk; 1834 1835 return 0; 1836 } 1837 1838 static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan) 1839 { 1840 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1841 u16 vids[BE_NUM_VLANS_SUPPORTED]; 1842 int vf_if_id = vf_cfg->if_handle; 1843 int status; 1844 1845 /* Enable Transparent VLAN Tagging */ 1846 status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0); 1847 if (status) 1848 return status; 1849 1850 /* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */ 1851 vids[0] = 0; 1852 status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1); 1853 if (!status) 1854 dev_info(&adapter->pdev->dev, 1855 "Cleared guest VLANs on VF%d", vf); 1856 1857 /* After TVT is enabled, disallow VFs to program VLAN filters */ 1858 if (vf_cfg->privileges & BE_PRIV_FILTMGMT) { 1859 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges & 1860 ~BE_PRIV_FILTMGMT, vf + 1); 1861 if (!status) 1862 vf_cfg->privileges &= ~BE_PRIV_FILTMGMT; 1863 } 1864 return 0; 1865 } 1866 1867 static int be_clear_vf_tvt(struct be_adapter *adapter, int vf) 1868 { 1869 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1870 struct device *dev = &adapter->pdev->dev; 1871 int status; 1872 1873 /* Reset Transparent VLAN Tagging. */ 1874 status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1, 1875 vf_cfg->if_handle, 0, 0); 1876 if (status) 1877 return status; 1878 1879 /* Allow VFs to program VLAN filtering */ 1880 if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) { 1881 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges | 1882 BE_PRIV_FILTMGMT, vf + 1); 1883 if (!status) { 1884 vf_cfg->privileges |= BE_PRIV_FILTMGMT; 1885 dev_info(dev, "VF%d: FILTMGMT priv enabled", vf); 1886 } 1887 } 1888 1889 dev_info(dev, 1890 "Disable/re-enable i/f in VM to clear Transparent VLAN tag"); 1891 return 0; 1892 } 1893 1894 static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos, 1895 __be16 vlan_proto) 1896 { 1897 struct be_adapter *adapter = netdev_priv(netdev); 1898 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1899 int status; 1900 1901 if (!sriov_enabled(adapter)) 1902 return -EPERM; 1903 1904 if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7) 1905 return -EINVAL; 1906 1907 if (vlan_proto != htons(ETH_P_8021Q)) 1908 return -EPROTONOSUPPORT; 1909 1910 if (vlan || qos) { 1911 vlan |= qos << VLAN_PRIO_SHIFT; 1912 status = be_set_vf_tvt(adapter, vf, vlan); 1913 } else { 1914 status = be_clear_vf_tvt(adapter, vf); 1915 } 1916 1917 if (status) { 1918 dev_err(&adapter->pdev->dev, 1919 "VLAN %d config on VF %d failed : %#x\n", vlan, vf, 1920 status); 1921 return be_cmd_status(status); 1922 } 1923 1924 vf_cfg->vlan_tag = vlan; 1925 return 0; 1926 } 1927 1928 static int be_set_vf_tx_rate(struct net_device *netdev, int vf, 1929 int min_tx_rate, int max_tx_rate) 1930 { 1931 struct be_adapter *adapter = netdev_priv(netdev); 1932 struct device *dev = &adapter->pdev->dev; 1933 int percent_rate, status = 0; 1934 u16 link_speed = 0; 1935 u8 link_status; 1936 1937 if (!sriov_enabled(adapter)) 1938 return -EPERM; 1939 1940 if (vf >= adapter->num_vfs) 1941 return -EINVAL; 1942 1943 if (min_tx_rate) 1944 return -EINVAL; 1945 1946 if (!max_tx_rate) 1947 goto config_qos; 1948 1949 status = be_cmd_link_status_query(adapter, &link_speed, 1950 &link_status, 0); 1951 if (status) 1952 goto err; 1953 1954 if (!link_status) { 1955 dev_err(dev, "TX-rate setting not allowed when link is down\n"); 1956 status = -ENETDOWN; 1957 goto err; 1958 } 1959 1960 if (max_tx_rate < 100 || max_tx_rate > link_speed) { 1961 dev_err(dev, "TX-rate must be between 100 and %d Mbps\n", 1962 link_speed); 1963 status = -EINVAL; 1964 goto err; 1965 } 1966 1967 /* On Skyhawk the QOS setting must be done only as a % value */ 1968 percent_rate = link_speed / 100; 1969 if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) { 1970 dev_err(dev, "TX-rate must be a multiple of %d Mbps\n", 1971 percent_rate); 1972 status = -EINVAL; 1973 goto err; 1974 } 1975 1976 config_qos: 1977 status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1); 1978 if (status) 1979 goto err; 1980 1981 adapter->vf_cfg[vf].tx_rate = max_tx_rate; 1982 return 0; 1983 1984 err: 1985 dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n", 1986 max_tx_rate, vf); 1987 return be_cmd_status(status); 1988 } 1989 1990 static int be_set_vf_link_state(struct net_device *netdev, int vf, 1991 int link_state) 1992 { 1993 struct be_adapter *adapter = netdev_priv(netdev); 1994 int status; 1995 1996 if (!sriov_enabled(adapter)) 1997 return -EPERM; 1998 1999 if (vf >= adapter->num_vfs) 2000 return -EINVAL; 2001 2002 status = be_cmd_set_logical_link_config(adapter, link_state, vf+1); 2003 if (status) { 2004 dev_err(&adapter->pdev->dev, 2005 "Link state change on VF %d failed: %#x\n", vf, status); 2006 return be_cmd_status(status); 2007 } 2008 2009 adapter->vf_cfg[vf].plink_tracking = link_state; 2010 2011 return 0; 2012 } 2013 2014 static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable) 2015 { 2016 struct be_adapter *adapter = netdev_priv(netdev); 2017 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 2018 u8 spoofchk; 2019 int status; 2020 2021 if (!sriov_enabled(adapter)) 2022 return -EPERM; 2023 2024 if (vf >= adapter->num_vfs) 2025 return -EINVAL; 2026 2027 if (BEx_chip(adapter)) 2028 return -EOPNOTSUPP; 2029 2030 if (enable == vf_cfg->spoofchk) 2031 return 0; 2032 2033 spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK; 2034 2035 status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle, 2036 0, spoofchk); 2037 if (status) { 2038 dev_err(&adapter->pdev->dev, 2039 "Spoofchk change on VF %d failed: %#x\n", vf, status); 2040 return be_cmd_status(status); 2041 } 2042 2043 vf_cfg->spoofchk = enable; 2044 return 0; 2045 } 2046 2047 static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts, 2048 ulong now) 2049 { 2050 aic->rx_pkts_prev = rx_pkts; 2051 aic->tx_reqs_prev = tx_pkts; 2052 aic->jiffies = now; 2053 } 2054 2055 static int be_get_new_eqd(struct be_eq_obj *eqo) 2056 { 2057 struct be_adapter *adapter = eqo->adapter; 2058 int eqd, start; 2059 struct be_aic_obj *aic; 2060 struct be_rx_obj *rxo; 2061 struct be_tx_obj *txo; 2062 u64 rx_pkts = 0, tx_pkts = 0; 2063 ulong now; 2064 u32 pps, delta; 2065 int i; 2066 2067 aic = &adapter->aic_obj[eqo->idx]; 2068 if (!aic->enable) { 2069 if (aic->jiffies) 2070 aic->jiffies = 0; 2071 eqd = aic->et_eqd; 2072 return eqd; 2073 } 2074 2075 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) { 2076 do { 2077 start = u64_stats_fetch_begin_irq(&rxo->stats.sync); 2078 rx_pkts += rxo->stats.rx_pkts; 2079 } while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start)); 2080 } 2081 2082 for_all_tx_queues_on_eq(adapter, eqo, txo, i) { 2083 do { 2084 start = u64_stats_fetch_begin_irq(&txo->stats.sync); 2085 tx_pkts += txo->stats.tx_reqs; 2086 } while (u64_stats_fetch_retry_irq(&txo->stats.sync, start)); 2087 } 2088 2089 /* Skip, if wrapped around or first calculation */ 2090 now = jiffies; 2091 if (!aic->jiffies || time_before(now, aic->jiffies) || 2092 rx_pkts < aic->rx_pkts_prev || 2093 tx_pkts < aic->tx_reqs_prev) { 2094 be_aic_update(aic, rx_pkts, tx_pkts, now); 2095 return aic->prev_eqd; 2096 } 2097 2098 delta = jiffies_to_msecs(now - aic->jiffies); 2099 if (delta == 0) 2100 return aic->prev_eqd; 2101 2102 pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) + 2103 (((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta); 2104 eqd = (pps / 15000) << 2; 2105 2106 if (eqd < 8) 2107 eqd = 0; 2108 eqd = min_t(u32, eqd, aic->max_eqd); 2109 eqd = max_t(u32, eqd, aic->min_eqd); 2110 2111 be_aic_update(aic, rx_pkts, tx_pkts, now); 2112 2113 return eqd; 2114 } 2115 2116 /* For Skyhawk-R only */ 2117 static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo) 2118 { 2119 struct be_adapter *adapter = eqo->adapter; 2120 struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx]; 2121 ulong now = jiffies; 2122 int eqd; 2123 u32 mult_enc; 2124 2125 if (!aic->enable) 2126 return 0; 2127 2128 if (jiffies_to_msecs(now - aic->jiffies) < 1) 2129 eqd = aic->prev_eqd; 2130 else 2131 eqd = be_get_new_eqd(eqo); 2132 2133 if (eqd > 100) 2134 mult_enc = R2I_DLY_ENC_1; 2135 else if (eqd > 60) 2136 mult_enc = R2I_DLY_ENC_2; 2137 else if (eqd > 20) 2138 mult_enc = R2I_DLY_ENC_3; 2139 else 2140 mult_enc = R2I_DLY_ENC_0; 2141 2142 aic->prev_eqd = eqd; 2143 2144 return mult_enc; 2145 } 2146 2147 void be_eqd_update(struct be_adapter *adapter, bool force_update) 2148 { 2149 struct be_set_eqd set_eqd[MAX_EVT_QS]; 2150 struct be_aic_obj *aic; 2151 struct be_eq_obj *eqo; 2152 int i, num = 0, eqd; 2153 2154 for_all_evt_queues(adapter, eqo, i) { 2155 aic = &adapter->aic_obj[eqo->idx]; 2156 eqd = be_get_new_eqd(eqo); 2157 if (force_update || eqd != aic->prev_eqd) { 2158 set_eqd[num].delay_multiplier = (eqd * 65)/100; 2159 set_eqd[num].eq_id = eqo->q.id; 2160 aic->prev_eqd = eqd; 2161 num++; 2162 } 2163 } 2164 2165 if (num) 2166 be_cmd_modify_eqd(adapter, set_eqd, num); 2167 } 2168 2169 static void be_rx_stats_update(struct be_rx_obj *rxo, 2170 struct be_rx_compl_info *rxcp) 2171 { 2172 struct be_rx_stats *stats = rx_stats(rxo); 2173 2174 u64_stats_update_begin(&stats->sync); 2175 stats->rx_compl++; 2176 stats->rx_bytes += rxcp->pkt_size; 2177 stats->rx_pkts++; 2178 if (rxcp->tunneled) 2179 stats->rx_vxlan_offload_pkts++; 2180 if (rxcp->pkt_type == BE_MULTICAST_PACKET) 2181 stats->rx_mcast_pkts++; 2182 if (rxcp->err) 2183 stats->rx_compl_err++; 2184 u64_stats_update_end(&stats->sync); 2185 } 2186 2187 static inline bool csum_passed(struct be_rx_compl_info *rxcp) 2188 { 2189 /* L4 checksum is not reliable for non TCP/UDP packets. 2190 * Also ignore ipcksm for ipv6 pkts 2191 */ 2192 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum && 2193 (rxcp->ip_csum || rxcp->ipv6) && !rxcp->err; 2194 } 2195 2196 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo) 2197 { 2198 struct be_adapter *adapter = rxo->adapter; 2199 struct be_rx_page_info *rx_page_info; 2200 struct be_queue_info *rxq = &rxo->q; 2201 u32 frag_idx = rxq->tail; 2202 2203 rx_page_info = &rxo->page_info_tbl[frag_idx]; 2204 BUG_ON(!rx_page_info->page); 2205 2206 if (rx_page_info->last_frag) { 2207 dma_unmap_page(&adapter->pdev->dev, 2208 dma_unmap_addr(rx_page_info, bus), 2209 adapter->big_page_size, DMA_FROM_DEVICE); 2210 rx_page_info->last_frag = false; 2211 } else { 2212 dma_sync_single_for_cpu(&adapter->pdev->dev, 2213 dma_unmap_addr(rx_page_info, bus), 2214 rx_frag_size, DMA_FROM_DEVICE); 2215 } 2216 2217 queue_tail_inc(rxq); 2218 atomic_dec(&rxq->used); 2219 return rx_page_info; 2220 } 2221 2222 /* Throwaway the data in the Rx completion */ 2223 static void be_rx_compl_discard(struct be_rx_obj *rxo, 2224 struct be_rx_compl_info *rxcp) 2225 { 2226 struct be_rx_page_info *page_info; 2227 u16 i, num_rcvd = rxcp->num_rcvd; 2228 2229 for (i = 0; i < num_rcvd; i++) { 2230 page_info = get_rx_page_info(rxo); 2231 put_page(page_info->page); 2232 memset(page_info, 0, sizeof(*page_info)); 2233 } 2234 } 2235 2236 /* 2237 * skb_fill_rx_data forms a complete skb for an ether frame 2238 * indicated by rxcp. 2239 */ 2240 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb, 2241 struct be_rx_compl_info *rxcp) 2242 { 2243 struct be_rx_page_info *page_info; 2244 u16 i, j; 2245 u16 hdr_len, curr_frag_len, remaining; 2246 u8 *start; 2247 2248 page_info = get_rx_page_info(rxo); 2249 start = page_address(page_info->page) + page_info->page_offset; 2250 prefetch(start); 2251 2252 /* Copy data in the first descriptor of this completion */ 2253 curr_frag_len = min(rxcp->pkt_size, rx_frag_size); 2254 2255 skb->len = curr_frag_len; 2256 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */ 2257 memcpy(skb->data, start, curr_frag_len); 2258 /* Complete packet has now been moved to data */ 2259 put_page(page_info->page); 2260 skb->data_len = 0; 2261 skb->tail += curr_frag_len; 2262 } else { 2263 hdr_len = ETH_HLEN; 2264 memcpy(skb->data, start, hdr_len); 2265 skb_shinfo(skb)->nr_frags = 1; 2266 skb_frag_set_page(skb, 0, page_info->page); 2267 skb_shinfo(skb)->frags[0].page_offset = 2268 page_info->page_offset + hdr_len; 2269 skb_frag_size_set(&skb_shinfo(skb)->frags[0], 2270 curr_frag_len - hdr_len); 2271 skb->data_len = curr_frag_len - hdr_len; 2272 skb->truesize += rx_frag_size; 2273 skb->tail += hdr_len; 2274 } 2275 page_info->page = NULL; 2276 2277 if (rxcp->pkt_size <= rx_frag_size) { 2278 BUG_ON(rxcp->num_rcvd != 1); 2279 return; 2280 } 2281 2282 /* More frags present for this completion */ 2283 remaining = rxcp->pkt_size - curr_frag_len; 2284 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) { 2285 page_info = get_rx_page_info(rxo); 2286 curr_frag_len = min(remaining, rx_frag_size); 2287 2288 /* Coalesce all frags from the same physical page in one slot */ 2289 if (page_info->page_offset == 0) { 2290 /* Fresh page */ 2291 j++; 2292 skb_frag_set_page(skb, j, page_info->page); 2293 skb_shinfo(skb)->frags[j].page_offset = 2294 page_info->page_offset; 2295 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0); 2296 skb_shinfo(skb)->nr_frags++; 2297 } else { 2298 put_page(page_info->page); 2299 } 2300 2301 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len); 2302 skb->len += curr_frag_len; 2303 skb->data_len += curr_frag_len; 2304 skb->truesize += rx_frag_size; 2305 remaining -= curr_frag_len; 2306 page_info->page = NULL; 2307 } 2308 BUG_ON(j > MAX_SKB_FRAGS); 2309 } 2310 2311 /* Process the RX completion indicated by rxcp when GRO is disabled */ 2312 static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi, 2313 struct be_rx_compl_info *rxcp) 2314 { 2315 struct be_adapter *adapter = rxo->adapter; 2316 struct net_device *netdev = adapter->netdev; 2317 struct sk_buff *skb; 2318 2319 skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE); 2320 if (unlikely(!skb)) { 2321 rx_stats(rxo)->rx_drops_no_skbs++; 2322 be_rx_compl_discard(rxo, rxcp); 2323 return; 2324 } 2325 2326 skb_fill_rx_data(rxo, skb, rxcp); 2327 2328 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp))) 2329 skb->ip_summed = CHECKSUM_UNNECESSARY; 2330 else 2331 skb_checksum_none_assert(skb); 2332 2333 skb->protocol = eth_type_trans(skb, netdev); 2334 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]); 2335 if (netdev->features & NETIF_F_RXHASH) 2336 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3); 2337 2338 skb->csum_level = rxcp->tunneled; 2339 skb_mark_napi_id(skb, napi); 2340 2341 if (rxcp->vlanf) 2342 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag); 2343 2344 netif_receive_skb(skb); 2345 } 2346 2347 /* Process the RX completion indicated by rxcp when GRO is enabled */ 2348 static void be_rx_compl_process_gro(struct be_rx_obj *rxo, 2349 struct napi_struct *napi, 2350 struct be_rx_compl_info *rxcp) 2351 { 2352 struct be_adapter *adapter = rxo->adapter; 2353 struct be_rx_page_info *page_info; 2354 struct sk_buff *skb = NULL; 2355 u16 remaining, curr_frag_len; 2356 u16 i, j; 2357 2358 skb = napi_get_frags(napi); 2359 if (!skb) { 2360 be_rx_compl_discard(rxo, rxcp); 2361 return; 2362 } 2363 2364 remaining = rxcp->pkt_size; 2365 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) { 2366 page_info = get_rx_page_info(rxo); 2367 2368 curr_frag_len = min(remaining, rx_frag_size); 2369 2370 /* Coalesce all frags from the same physical page in one slot */ 2371 if (i == 0 || page_info->page_offset == 0) { 2372 /* First frag or Fresh page */ 2373 j++; 2374 skb_frag_set_page(skb, j, page_info->page); 2375 skb_shinfo(skb)->frags[j].page_offset = 2376 page_info->page_offset; 2377 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0); 2378 } else { 2379 put_page(page_info->page); 2380 } 2381 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len); 2382 skb->truesize += rx_frag_size; 2383 remaining -= curr_frag_len; 2384 memset(page_info, 0, sizeof(*page_info)); 2385 } 2386 BUG_ON(j > MAX_SKB_FRAGS); 2387 2388 skb_shinfo(skb)->nr_frags = j + 1; 2389 skb->len = rxcp->pkt_size; 2390 skb->data_len = rxcp->pkt_size; 2391 skb->ip_summed = CHECKSUM_UNNECESSARY; 2392 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]); 2393 if (adapter->netdev->features & NETIF_F_RXHASH) 2394 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3); 2395 2396 skb->csum_level = rxcp->tunneled; 2397 2398 if (rxcp->vlanf) 2399 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag); 2400 2401 napi_gro_frags(napi); 2402 } 2403 2404 static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl, 2405 struct be_rx_compl_info *rxcp) 2406 { 2407 rxcp->pkt_size = GET_RX_COMPL_V1_BITS(pktsize, compl); 2408 rxcp->vlanf = GET_RX_COMPL_V1_BITS(vtp, compl); 2409 rxcp->err = GET_RX_COMPL_V1_BITS(err, compl); 2410 rxcp->tcpf = GET_RX_COMPL_V1_BITS(tcpf, compl); 2411 rxcp->udpf = GET_RX_COMPL_V1_BITS(udpf, compl); 2412 rxcp->ip_csum = GET_RX_COMPL_V1_BITS(ipcksm, compl); 2413 rxcp->l4_csum = GET_RX_COMPL_V1_BITS(l4_cksm, compl); 2414 rxcp->ipv6 = GET_RX_COMPL_V1_BITS(ip_version, compl); 2415 rxcp->num_rcvd = GET_RX_COMPL_V1_BITS(numfrags, compl); 2416 rxcp->pkt_type = GET_RX_COMPL_V1_BITS(cast_enc, compl); 2417 rxcp->rss_hash = GET_RX_COMPL_V1_BITS(rsshash, compl); 2418 if (rxcp->vlanf) { 2419 rxcp->qnq = GET_RX_COMPL_V1_BITS(qnq, compl); 2420 rxcp->vlan_tag = GET_RX_COMPL_V1_BITS(vlan_tag, compl); 2421 } 2422 rxcp->port = GET_RX_COMPL_V1_BITS(port, compl); 2423 rxcp->tunneled = 2424 GET_RX_COMPL_V1_BITS(tunneled, compl); 2425 } 2426 2427 static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl, 2428 struct be_rx_compl_info *rxcp) 2429 { 2430 rxcp->pkt_size = GET_RX_COMPL_V0_BITS(pktsize, compl); 2431 rxcp->vlanf = GET_RX_COMPL_V0_BITS(vtp, compl); 2432 rxcp->err = GET_RX_COMPL_V0_BITS(err, compl); 2433 rxcp->tcpf = GET_RX_COMPL_V0_BITS(tcpf, compl); 2434 rxcp->udpf = GET_RX_COMPL_V0_BITS(udpf, compl); 2435 rxcp->ip_csum = GET_RX_COMPL_V0_BITS(ipcksm, compl); 2436 rxcp->l4_csum = GET_RX_COMPL_V0_BITS(l4_cksm, compl); 2437 rxcp->ipv6 = GET_RX_COMPL_V0_BITS(ip_version, compl); 2438 rxcp->num_rcvd = GET_RX_COMPL_V0_BITS(numfrags, compl); 2439 rxcp->pkt_type = GET_RX_COMPL_V0_BITS(cast_enc, compl); 2440 rxcp->rss_hash = GET_RX_COMPL_V0_BITS(rsshash, compl); 2441 if (rxcp->vlanf) { 2442 rxcp->qnq = GET_RX_COMPL_V0_BITS(qnq, compl); 2443 rxcp->vlan_tag = GET_RX_COMPL_V0_BITS(vlan_tag, compl); 2444 } 2445 rxcp->port = GET_RX_COMPL_V0_BITS(port, compl); 2446 rxcp->ip_frag = GET_RX_COMPL_V0_BITS(ip_frag, compl); 2447 } 2448 2449 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo) 2450 { 2451 struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq); 2452 struct be_rx_compl_info *rxcp = &rxo->rxcp; 2453 struct be_adapter *adapter = rxo->adapter; 2454 2455 /* For checking the valid bit it is Ok to use either definition as the 2456 * valid bit is at the same position in both v0 and v1 Rx compl */ 2457 if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0) 2458 return NULL; 2459 2460 rmb(); 2461 be_dws_le_to_cpu(compl, sizeof(*compl)); 2462 2463 if (adapter->be3_native) 2464 be_parse_rx_compl_v1(compl, rxcp); 2465 else 2466 be_parse_rx_compl_v0(compl, rxcp); 2467 2468 if (rxcp->ip_frag) 2469 rxcp->l4_csum = 0; 2470 2471 if (rxcp->vlanf) { 2472 /* In QNQ modes, if qnq bit is not set, then the packet was 2473 * tagged only with the transparent outer vlan-tag and must 2474 * not be treated as a vlan packet by host 2475 */ 2476 if (be_is_qnq_mode(adapter) && !rxcp->qnq) 2477 rxcp->vlanf = 0; 2478 2479 if (!lancer_chip(adapter)) 2480 rxcp->vlan_tag = swab16(rxcp->vlan_tag); 2481 2482 if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) && 2483 !test_bit(rxcp->vlan_tag, adapter->vids)) 2484 rxcp->vlanf = 0; 2485 } 2486 2487 /* As the compl has been parsed, reset it; we wont touch it again */ 2488 compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0; 2489 2490 queue_tail_inc(&rxo->cq); 2491 return rxcp; 2492 } 2493 2494 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp) 2495 { 2496 u32 order = get_order(size); 2497 2498 if (order > 0) 2499 gfp |= __GFP_COMP; 2500 return alloc_pages(gfp, order); 2501 } 2502 2503 /* 2504 * Allocate a page, split it to fragments of size rx_frag_size and post as 2505 * receive buffers to BE 2506 */ 2507 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp, u32 frags_needed) 2508 { 2509 struct be_adapter *adapter = rxo->adapter; 2510 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL; 2511 struct be_queue_info *rxq = &rxo->q; 2512 struct page *pagep = NULL; 2513 struct device *dev = &adapter->pdev->dev; 2514 struct be_eth_rx_d *rxd; 2515 u64 page_dmaaddr = 0, frag_dmaaddr; 2516 u32 posted, page_offset = 0, notify = 0; 2517 2518 page_info = &rxo->page_info_tbl[rxq->head]; 2519 for (posted = 0; posted < frags_needed && !page_info->page; posted++) { 2520 if (!pagep) { 2521 pagep = be_alloc_pages(adapter->big_page_size, gfp); 2522 if (unlikely(!pagep)) { 2523 rx_stats(rxo)->rx_post_fail++; 2524 break; 2525 } 2526 page_dmaaddr = dma_map_page(dev, pagep, 0, 2527 adapter->big_page_size, 2528 DMA_FROM_DEVICE); 2529 if (dma_mapping_error(dev, page_dmaaddr)) { 2530 put_page(pagep); 2531 pagep = NULL; 2532 adapter->drv_stats.dma_map_errors++; 2533 break; 2534 } 2535 page_offset = 0; 2536 } else { 2537 get_page(pagep); 2538 page_offset += rx_frag_size; 2539 } 2540 page_info->page_offset = page_offset; 2541 page_info->page = pagep; 2542 2543 rxd = queue_head_node(rxq); 2544 frag_dmaaddr = page_dmaaddr + page_info->page_offset; 2545 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF); 2546 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr)); 2547 2548 /* Any space left in the current big page for another frag? */ 2549 if ((page_offset + rx_frag_size + rx_frag_size) > 2550 adapter->big_page_size) { 2551 pagep = NULL; 2552 page_info->last_frag = true; 2553 dma_unmap_addr_set(page_info, bus, page_dmaaddr); 2554 } else { 2555 dma_unmap_addr_set(page_info, bus, frag_dmaaddr); 2556 } 2557 2558 prev_page_info = page_info; 2559 queue_head_inc(rxq); 2560 page_info = &rxo->page_info_tbl[rxq->head]; 2561 } 2562 2563 /* Mark the last frag of a page when we break out of the above loop 2564 * with no more slots available in the RXQ 2565 */ 2566 if (pagep) { 2567 prev_page_info->last_frag = true; 2568 dma_unmap_addr_set(prev_page_info, bus, page_dmaaddr); 2569 } 2570 2571 if (posted) { 2572 atomic_add(posted, &rxq->used); 2573 if (rxo->rx_post_starved) 2574 rxo->rx_post_starved = false; 2575 do { 2576 notify = min(MAX_NUM_POST_ERX_DB, posted); 2577 be_rxq_notify(adapter, rxq->id, notify); 2578 posted -= notify; 2579 } while (posted); 2580 } else if (atomic_read(&rxq->used) == 0) { 2581 /* Let be_worker replenish when memory is available */ 2582 rxo->rx_post_starved = true; 2583 } 2584 } 2585 2586 static struct be_tx_compl_info *be_tx_compl_get(struct be_tx_obj *txo) 2587 { 2588 struct be_queue_info *tx_cq = &txo->cq; 2589 struct be_tx_compl_info *txcp = &txo->txcp; 2590 struct be_eth_tx_compl *compl = queue_tail_node(tx_cq); 2591 2592 if (compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0) 2593 return NULL; 2594 2595 /* Ensure load ordering of valid bit dword and other dwords below */ 2596 rmb(); 2597 be_dws_le_to_cpu(compl, sizeof(*compl)); 2598 2599 txcp->status = GET_TX_COMPL_BITS(status, compl); 2600 txcp->end_index = GET_TX_COMPL_BITS(wrb_index, compl); 2601 2602 compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0; 2603 queue_tail_inc(tx_cq); 2604 return txcp; 2605 } 2606 2607 static u16 be_tx_compl_process(struct be_adapter *adapter, 2608 struct be_tx_obj *txo, u16 last_index) 2609 { 2610 struct sk_buff **sent_skbs = txo->sent_skb_list; 2611 struct be_queue_info *txq = &txo->q; 2612 struct sk_buff *skb = NULL; 2613 bool unmap_skb_hdr = false; 2614 struct be_eth_wrb *wrb; 2615 u16 num_wrbs = 0; 2616 u32 frag_index; 2617 2618 do { 2619 if (sent_skbs[txq->tail]) { 2620 /* Free skb from prev req */ 2621 if (skb) 2622 dev_consume_skb_any(skb); 2623 skb = sent_skbs[txq->tail]; 2624 sent_skbs[txq->tail] = NULL; 2625 queue_tail_inc(txq); /* skip hdr wrb */ 2626 num_wrbs++; 2627 unmap_skb_hdr = true; 2628 } 2629 wrb = queue_tail_node(txq); 2630 frag_index = txq->tail; 2631 unmap_tx_frag(&adapter->pdev->dev, wrb, 2632 (unmap_skb_hdr && skb_headlen(skb))); 2633 unmap_skb_hdr = false; 2634 queue_tail_inc(txq); 2635 num_wrbs++; 2636 } while (frag_index != last_index); 2637 dev_consume_skb_any(skb); 2638 2639 return num_wrbs; 2640 } 2641 2642 /* Return the number of events in the event queue */ 2643 static inline int events_get(struct be_eq_obj *eqo) 2644 { 2645 struct be_eq_entry *eqe; 2646 int num = 0; 2647 2648 do { 2649 eqe = queue_tail_node(&eqo->q); 2650 if (eqe->evt == 0) 2651 break; 2652 2653 rmb(); 2654 eqe->evt = 0; 2655 num++; 2656 queue_tail_inc(&eqo->q); 2657 } while (true); 2658 2659 return num; 2660 } 2661 2662 /* Leaves the EQ is disarmed state */ 2663 static void be_eq_clean(struct be_eq_obj *eqo) 2664 { 2665 int num = events_get(eqo); 2666 2667 be_eq_notify(eqo->adapter, eqo->q.id, false, true, num, 0); 2668 } 2669 2670 /* Free posted rx buffers that were not used */ 2671 static void be_rxq_clean(struct be_rx_obj *rxo) 2672 { 2673 struct be_queue_info *rxq = &rxo->q; 2674 struct be_rx_page_info *page_info; 2675 2676 while (atomic_read(&rxq->used) > 0) { 2677 page_info = get_rx_page_info(rxo); 2678 put_page(page_info->page); 2679 memset(page_info, 0, sizeof(*page_info)); 2680 } 2681 BUG_ON(atomic_read(&rxq->used)); 2682 rxq->tail = 0; 2683 rxq->head = 0; 2684 } 2685 2686 static void be_rx_cq_clean(struct be_rx_obj *rxo) 2687 { 2688 struct be_queue_info *rx_cq = &rxo->cq; 2689 struct be_rx_compl_info *rxcp; 2690 struct be_adapter *adapter = rxo->adapter; 2691 int flush_wait = 0; 2692 2693 /* Consume pending rx completions. 2694 * Wait for the flush completion (identified by zero num_rcvd) 2695 * to arrive. Notify CQ even when there are no more CQ entries 2696 * for HW to flush partially coalesced CQ entries. 2697 * In Lancer, there is no need to wait for flush compl. 2698 */ 2699 for (;;) { 2700 rxcp = be_rx_compl_get(rxo); 2701 if (!rxcp) { 2702 if (lancer_chip(adapter)) 2703 break; 2704 2705 if (flush_wait++ > 50 || 2706 be_check_error(adapter, 2707 BE_ERROR_HW)) { 2708 dev_warn(&adapter->pdev->dev, 2709 "did not receive flush compl\n"); 2710 break; 2711 } 2712 be_cq_notify(adapter, rx_cq->id, true, 0); 2713 mdelay(1); 2714 } else { 2715 be_rx_compl_discard(rxo, rxcp); 2716 be_cq_notify(adapter, rx_cq->id, false, 1); 2717 if (rxcp->num_rcvd == 0) 2718 break; 2719 } 2720 } 2721 2722 /* After cleanup, leave the CQ in unarmed state */ 2723 be_cq_notify(adapter, rx_cq->id, false, 0); 2724 } 2725 2726 static void be_tx_compl_clean(struct be_adapter *adapter) 2727 { 2728 struct device *dev = &adapter->pdev->dev; 2729 u16 cmpl = 0, timeo = 0, num_wrbs = 0; 2730 struct be_tx_compl_info *txcp; 2731 struct be_queue_info *txq; 2732 u32 end_idx, notified_idx; 2733 struct be_tx_obj *txo; 2734 int i, pending_txqs; 2735 2736 /* Stop polling for compls when HW has been silent for 10ms */ 2737 do { 2738 pending_txqs = adapter->num_tx_qs; 2739 2740 for_all_tx_queues(adapter, txo, i) { 2741 cmpl = 0; 2742 num_wrbs = 0; 2743 txq = &txo->q; 2744 while ((txcp = be_tx_compl_get(txo))) { 2745 num_wrbs += 2746 be_tx_compl_process(adapter, txo, 2747 txcp->end_index); 2748 cmpl++; 2749 } 2750 if (cmpl) { 2751 be_cq_notify(adapter, txo->cq.id, false, cmpl); 2752 atomic_sub(num_wrbs, &txq->used); 2753 timeo = 0; 2754 } 2755 if (!be_is_tx_compl_pending(txo)) 2756 pending_txqs--; 2757 } 2758 2759 if (pending_txqs == 0 || ++timeo > 10 || 2760 be_check_error(adapter, BE_ERROR_HW)) 2761 break; 2762 2763 mdelay(1); 2764 } while (true); 2765 2766 /* Free enqueued TX that was never notified to HW */ 2767 for_all_tx_queues(adapter, txo, i) { 2768 txq = &txo->q; 2769 2770 if (atomic_read(&txq->used)) { 2771 dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n", 2772 i, atomic_read(&txq->used)); 2773 notified_idx = txq->tail; 2774 end_idx = txq->tail; 2775 index_adv(&end_idx, atomic_read(&txq->used) - 1, 2776 txq->len); 2777 /* Use the tx-compl process logic to handle requests 2778 * that were not sent to the HW. 2779 */ 2780 num_wrbs = be_tx_compl_process(adapter, txo, end_idx); 2781 atomic_sub(num_wrbs, &txq->used); 2782 BUG_ON(atomic_read(&txq->used)); 2783 txo->pend_wrb_cnt = 0; 2784 /* Since hw was never notified of these requests, 2785 * reset TXQ indices 2786 */ 2787 txq->head = notified_idx; 2788 txq->tail = notified_idx; 2789 } 2790 } 2791 } 2792 2793 static void be_evt_queues_destroy(struct be_adapter *adapter) 2794 { 2795 struct be_eq_obj *eqo; 2796 int i; 2797 2798 for_all_evt_queues(adapter, eqo, i) { 2799 if (eqo->q.created) { 2800 be_eq_clean(eqo); 2801 be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ); 2802 netif_napi_del(&eqo->napi); 2803 free_cpumask_var(eqo->affinity_mask); 2804 } 2805 be_queue_free(adapter, &eqo->q); 2806 } 2807 } 2808 2809 static int be_evt_queues_create(struct be_adapter *adapter) 2810 { 2811 struct be_queue_info *eq; 2812 struct be_eq_obj *eqo; 2813 struct be_aic_obj *aic; 2814 int i, rc; 2815 2816 /* need enough EQs to service both RX and TX queues */ 2817 adapter->num_evt_qs = min_t(u16, num_irqs(adapter), 2818 max(adapter->cfg_num_rx_irqs, 2819 adapter->cfg_num_tx_irqs)); 2820 2821 for_all_evt_queues(adapter, eqo, i) { 2822 int numa_node = dev_to_node(&adapter->pdev->dev); 2823 2824 aic = &adapter->aic_obj[i]; 2825 eqo->adapter = adapter; 2826 eqo->idx = i; 2827 aic->max_eqd = BE_MAX_EQD; 2828 aic->enable = true; 2829 2830 eq = &eqo->q; 2831 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN, 2832 sizeof(struct be_eq_entry)); 2833 if (rc) 2834 return rc; 2835 2836 rc = be_cmd_eq_create(adapter, eqo); 2837 if (rc) 2838 return rc; 2839 2840 if (!zalloc_cpumask_var(&eqo->affinity_mask, GFP_KERNEL)) 2841 return -ENOMEM; 2842 cpumask_set_cpu(cpumask_local_spread(i, numa_node), 2843 eqo->affinity_mask); 2844 netif_napi_add(adapter->netdev, &eqo->napi, be_poll, 2845 BE_NAPI_WEIGHT); 2846 } 2847 return 0; 2848 } 2849 2850 static void be_mcc_queues_destroy(struct be_adapter *adapter) 2851 { 2852 struct be_queue_info *q; 2853 2854 q = &adapter->mcc_obj.q; 2855 if (q->created) 2856 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ); 2857 be_queue_free(adapter, q); 2858 2859 q = &adapter->mcc_obj.cq; 2860 if (q->created) 2861 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2862 be_queue_free(adapter, q); 2863 } 2864 2865 /* Must be called only after TX qs are created as MCC shares TX EQ */ 2866 static int be_mcc_queues_create(struct be_adapter *adapter) 2867 { 2868 struct be_queue_info *q, *cq; 2869 2870 cq = &adapter->mcc_obj.cq; 2871 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN, 2872 sizeof(struct be_mcc_compl))) 2873 goto err; 2874 2875 /* Use the default EQ for MCC completions */ 2876 if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0)) 2877 goto mcc_cq_free; 2878 2879 q = &adapter->mcc_obj.q; 2880 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb))) 2881 goto mcc_cq_destroy; 2882 2883 if (be_cmd_mccq_create(adapter, q, cq)) 2884 goto mcc_q_free; 2885 2886 return 0; 2887 2888 mcc_q_free: 2889 be_queue_free(adapter, q); 2890 mcc_cq_destroy: 2891 be_cmd_q_destroy(adapter, cq, QTYPE_CQ); 2892 mcc_cq_free: 2893 be_queue_free(adapter, cq); 2894 err: 2895 return -1; 2896 } 2897 2898 static void be_tx_queues_destroy(struct be_adapter *adapter) 2899 { 2900 struct be_queue_info *q; 2901 struct be_tx_obj *txo; 2902 u8 i; 2903 2904 for_all_tx_queues(adapter, txo, i) { 2905 q = &txo->q; 2906 if (q->created) 2907 be_cmd_q_destroy(adapter, q, QTYPE_TXQ); 2908 be_queue_free(adapter, q); 2909 2910 q = &txo->cq; 2911 if (q->created) 2912 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2913 be_queue_free(adapter, q); 2914 } 2915 } 2916 2917 static int be_tx_qs_create(struct be_adapter *adapter) 2918 { 2919 struct be_queue_info *cq; 2920 struct be_tx_obj *txo; 2921 struct be_eq_obj *eqo; 2922 int status, i; 2923 2924 adapter->num_tx_qs = min(adapter->num_evt_qs, adapter->cfg_num_tx_irqs); 2925 2926 for_all_tx_queues(adapter, txo, i) { 2927 cq = &txo->cq; 2928 status = be_queue_alloc(adapter, cq, TX_CQ_LEN, 2929 sizeof(struct be_eth_tx_compl)); 2930 if (status) 2931 return status; 2932 2933 u64_stats_init(&txo->stats.sync); 2934 u64_stats_init(&txo->stats.sync_compl); 2935 2936 /* If num_evt_qs is less than num_tx_qs, then more than 2937 * one txq share an eq 2938 */ 2939 eqo = &adapter->eq_obj[i % adapter->num_evt_qs]; 2940 status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3); 2941 if (status) 2942 return status; 2943 2944 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN, 2945 sizeof(struct be_eth_wrb)); 2946 if (status) 2947 return status; 2948 2949 status = be_cmd_txq_create(adapter, txo); 2950 if (status) 2951 return status; 2952 2953 netif_set_xps_queue(adapter->netdev, eqo->affinity_mask, 2954 eqo->idx); 2955 } 2956 2957 dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n", 2958 adapter->num_tx_qs); 2959 return 0; 2960 } 2961 2962 static void be_rx_cqs_destroy(struct be_adapter *adapter) 2963 { 2964 struct be_queue_info *q; 2965 struct be_rx_obj *rxo; 2966 int i; 2967 2968 for_all_rx_queues(adapter, rxo, i) { 2969 q = &rxo->cq; 2970 if (q->created) 2971 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2972 be_queue_free(adapter, q); 2973 } 2974 } 2975 2976 static int be_rx_cqs_create(struct be_adapter *adapter) 2977 { 2978 struct be_queue_info *eq, *cq; 2979 struct be_rx_obj *rxo; 2980 int rc, i; 2981 2982 adapter->num_rss_qs = 2983 min(adapter->num_evt_qs, adapter->cfg_num_rx_irqs); 2984 2985 /* We'll use RSS only if atleast 2 RSS rings are supported. */ 2986 if (adapter->num_rss_qs < 2) 2987 adapter->num_rss_qs = 0; 2988 2989 adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq; 2990 2991 /* When the interface is not capable of RSS rings (and there is no 2992 * need to create a default RXQ) we'll still need one RXQ 2993 */ 2994 if (adapter->num_rx_qs == 0) 2995 adapter->num_rx_qs = 1; 2996 2997 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE; 2998 for_all_rx_queues(adapter, rxo, i) { 2999 rxo->adapter = adapter; 3000 cq = &rxo->cq; 3001 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN, 3002 sizeof(struct be_eth_rx_compl)); 3003 if (rc) 3004 return rc; 3005 3006 u64_stats_init(&rxo->stats.sync); 3007 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q; 3008 rc = be_cmd_cq_create(adapter, cq, eq, false, 3); 3009 if (rc) 3010 return rc; 3011 } 3012 3013 dev_info(&adapter->pdev->dev, 3014 "created %d RX queue(s)\n", adapter->num_rx_qs); 3015 return 0; 3016 } 3017 3018 static irqreturn_t be_intx(int irq, void *dev) 3019 { 3020 struct be_eq_obj *eqo = dev; 3021 struct be_adapter *adapter = eqo->adapter; 3022 int num_evts = 0; 3023 3024 /* IRQ is not expected when NAPI is scheduled as the EQ 3025 * will not be armed. 3026 * But, this can happen on Lancer INTx where it takes 3027 * a while to de-assert INTx or in BE2 where occasionaly 3028 * an interrupt may be raised even when EQ is unarmed. 3029 * If NAPI is already scheduled, then counting & notifying 3030 * events will orphan them. 3031 */ 3032 if (napi_schedule_prep(&eqo->napi)) { 3033 num_evts = events_get(eqo); 3034 __napi_schedule(&eqo->napi); 3035 if (num_evts) 3036 eqo->spurious_intr = 0; 3037 } 3038 be_eq_notify(adapter, eqo->q.id, false, true, num_evts, 0); 3039 3040 /* Return IRQ_HANDLED only for the the first spurious intr 3041 * after a valid intr to stop the kernel from branding 3042 * this irq as a bad one! 3043 */ 3044 if (num_evts || eqo->spurious_intr++ == 0) 3045 return IRQ_HANDLED; 3046 else 3047 return IRQ_NONE; 3048 } 3049 3050 static irqreturn_t be_msix(int irq, void *dev) 3051 { 3052 struct be_eq_obj *eqo = dev; 3053 3054 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0); 3055 napi_schedule(&eqo->napi); 3056 return IRQ_HANDLED; 3057 } 3058 3059 static inline bool do_gro(struct be_rx_compl_info *rxcp) 3060 { 3061 return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false; 3062 } 3063 3064 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi, 3065 int budget) 3066 { 3067 struct be_adapter *adapter = rxo->adapter; 3068 struct be_queue_info *rx_cq = &rxo->cq; 3069 struct be_rx_compl_info *rxcp; 3070 u32 work_done; 3071 u32 frags_consumed = 0; 3072 3073 for (work_done = 0; work_done < budget; work_done++) { 3074 rxcp = be_rx_compl_get(rxo); 3075 if (!rxcp) 3076 break; 3077 3078 /* Is it a flush compl that has no data */ 3079 if (unlikely(rxcp->num_rcvd == 0)) 3080 goto loop_continue; 3081 3082 /* Discard compl with partial DMA Lancer B0 */ 3083 if (unlikely(!rxcp->pkt_size)) { 3084 be_rx_compl_discard(rxo, rxcp); 3085 goto loop_continue; 3086 } 3087 3088 /* On BE drop pkts that arrive due to imperfect filtering in 3089 * promiscuous mode on some skews 3090 */ 3091 if (unlikely(rxcp->port != adapter->port_num && 3092 !lancer_chip(adapter))) { 3093 be_rx_compl_discard(rxo, rxcp); 3094 goto loop_continue; 3095 } 3096 3097 if (do_gro(rxcp)) 3098 be_rx_compl_process_gro(rxo, napi, rxcp); 3099 else 3100 be_rx_compl_process(rxo, napi, rxcp); 3101 3102 loop_continue: 3103 frags_consumed += rxcp->num_rcvd; 3104 be_rx_stats_update(rxo, rxcp); 3105 } 3106 3107 if (work_done) { 3108 be_cq_notify(adapter, rx_cq->id, true, work_done); 3109 3110 /* When an rx-obj gets into post_starved state, just 3111 * let be_worker do the posting. 3112 */ 3113 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM && 3114 !rxo->rx_post_starved) 3115 be_post_rx_frags(rxo, GFP_ATOMIC, 3116 max_t(u32, MAX_RX_POST, 3117 frags_consumed)); 3118 } 3119 3120 return work_done; 3121 } 3122 3123 static inline void be_update_tx_err(struct be_tx_obj *txo, u8 status) 3124 { 3125 switch (status) { 3126 case BE_TX_COMP_HDR_PARSE_ERR: 3127 tx_stats(txo)->tx_hdr_parse_err++; 3128 break; 3129 case BE_TX_COMP_NDMA_ERR: 3130 tx_stats(txo)->tx_dma_err++; 3131 break; 3132 case BE_TX_COMP_ACL_ERR: 3133 tx_stats(txo)->tx_spoof_check_err++; 3134 break; 3135 } 3136 } 3137 3138 static inline void lancer_update_tx_err(struct be_tx_obj *txo, u8 status) 3139 { 3140 switch (status) { 3141 case LANCER_TX_COMP_LSO_ERR: 3142 tx_stats(txo)->tx_tso_err++; 3143 break; 3144 case LANCER_TX_COMP_HSW_DROP_MAC_ERR: 3145 case LANCER_TX_COMP_HSW_DROP_VLAN_ERR: 3146 tx_stats(txo)->tx_spoof_check_err++; 3147 break; 3148 case LANCER_TX_COMP_QINQ_ERR: 3149 tx_stats(txo)->tx_qinq_err++; 3150 break; 3151 case LANCER_TX_COMP_PARITY_ERR: 3152 tx_stats(txo)->tx_internal_parity_err++; 3153 break; 3154 case LANCER_TX_COMP_DMA_ERR: 3155 tx_stats(txo)->tx_dma_err++; 3156 break; 3157 } 3158 } 3159 3160 static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo, 3161 int idx) 3162 { 3163 int num_wrbs = 0, work_done = 0; 3164 struct be_tx_compl_info *txcp; 3165 3166 while ((txcp = be_tx_compl_get(txo))) { 3167 num_wrbs += be_tx_compl_process(adapter, txo, txcp->end_index); 3168 work_done++; 3169 3170 if (txcp->status) { 3171 if (lancer_chip(adapter)) 3172 lancer_update_tx_err(txo, txcp->status); 3173 else 3174 be_update_tx_err(txo, txcp->status); 3175 } 3176 } 3177 3178 if (work_done) { 3179 be_cq_notify(adapter, txo->cq.id, true, work_done); 3180 atomic_sub(num_wrbs, &txo->q.used); 3181 3182 /* As Tx wrbs have been freed up, wake up netdev queue 3183 * if it was stopped due to lack of tx wrbs. */ 3184 if (__netif_subqueue_stopped(adapter->netdev, idx) && 3185 be_can_txq_wake(txo)) { 3186 netif_wake_subqueue(adapter->netdev, idx); 3187 } 3188 3189 u64_stats_update_begin(&tx_stats(txo)->sync_compl); 3190 tx_stats(txo)->tx_compl += work_done; 3191 u64_stats_update_end(&tx_stats(txo)->sync_compl); 3192 } 3193 } 3194 3195 int be_poll(struct napi_struct *napi, int budget) 3196 { 3197 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi); 3198 struct be_adapter *adapter = eqo->adapter; 3199 int max_work = 0, work, i, num_evts; 3200 struct be_rx_obj *rxo; 3201 struct be_tx_obj *txo; 3202 u32 mult_enc = 0; 3203 3204 num_evts = events_get(eqo); 3205 3206 for_all_tx_queues_on_eq(adapter, eqo, txo, i) 3207 be_process_tx(adapter, txo, i); 3208 3209 /* This loop will iterate twice for EQ0 in which 3210 * completions of the last RXQ (default one) are also processed 3211 * For other EQs the loop iterates only once 3212 */ 3213 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) { 3214 work = be_process_rx(rxo, napi, budget); 3215 max_work = max(work, max_work); 3216 } 3217 3218 if (is_mcc_eqo(eqo)) 3219 be_process_mcc(adapter); 3220 3221 if (max_work < budget) { 3222 napi_complete_done(napi, max_work); 3223 3224 /* Skyhawk EQ_DB has a provision to set the rearm to interrupt 3225 * delay via a delay multiplier encoding value 3226 */ 3227 if (skyhawk_chip(adapter)) 3228 mult_enc = be_get_eq_delay_mult_enc(eqo); 3229 3230 be_eq_notify(adapter, eqo->q.id, true, false, num_evts, 3231 mult_enc); 3232 } else { 3233 /* As we'll continue in polling mode, count and clear events */ 3234 be_eq_notify(adapter, eqo->q.id, false, false, num_evts, 0); 3235 } 3236 return max_work; 3237 } 3238 3239 void be_detect_error(struct be_adapter *adapter) 3240 { 3241 u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0; 3242 u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0; 3243 struct device *dev = &adapter->pdev->dev; 3244 u16 val; 3245 u32 i; 3246 3247 if (be_check_error(adapter, BE_ERROR_HW)) 3248 return; 3249 3250 if (lancer_chip(adapter)) { 3251 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET); 3252 if (sliport_status & SLIPORT_STATUS_ERR_MASK) { 3253 be_set_error(adapter, BE_ERROR_UE); 3254 sliport_err1 = ioread32(adapter->db + 3255 SLIPORT_ERROR1_OFFSET); 3256 sliport_err2 = ioread32(adapter->db + 3257 SLIPORT_ERROR2_OFFSET); 3258 /* Do not log error messages if its a FW reset */ 3259 if (sliport_err1 == SLIPORT_ERROR_FW_RESET1 && 3260 sliport_err2 == SLIPORT_ERROR_FW_RESET2) { 3261 dev_info(dev, "Firmware update in progress\n"); 3262 } else { 3263 dev_err(dev, "Error detected in the card\n"); 3264 dev_err(dev, "ERR: sliport status 0x%x\n", 3265 sliport_status); 3266 dev_err(dev, "ERR: sliport error1 0x%x\n", 3267 sliport_err1); 3268 dev_err(dev, "ERR: sliport error2 0x%x\n", 3269 sliport_err2); 3270 } 3271 } 3272 } else { 3273 ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW); 3274 ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH); 3275 ue_lo_mask = ioread32(adapter->pcicfg + 3276 PCICFG_UE_STATUS_LOW_MASK); 3277 ue_hi_mask = ioread32(adapter->pcicfg + 3278 PCICFG_UE_STATUS_HI_MASK); 3279 3280 ue_lo = (ue_lo & ~ue_lo_mask); 3281 ue_hi = (ue_hi & ~ue_hi_mask); 3282 3283 if (ue_lo || ue_hi) { 3284 /* On certain platforms BE3 hardware can indicate 3285 * spurious UEs. In case of a UE in the chip, 3286 * the POST register correctly reports either a 3287 * FAT_LOG_START state (FW is currently dumping 3288 * FAT log data) or a ARMFW_UE state. Check for the 3289 * above states to ascertain if the UE is valid or not. 3290 */ 3291 if (BE3_chip(adapter)) { 3292 val = be_POST_stage_get(adapter); 3293 if ((val & POST_STAGE_FAT_LOG_START) 3294 != POST_STAGE_FAT_LOG_START && 3295 (val & POST_STAGE_ARMFW_UE) 3296 != POST_STAGE_ARMFW_UE) 3297 return; 3298 } 3299 3300 dev_err(dev, "Error detected in the adapter"); 3301 be_set_error(adapter, BE_ERROR_UE); 3302 3303 for (i = 0; ue_lo; ue_lo >>= 1, i++) { 3304 if (ue_lo & 1) 3305 dev_err(dev, "UE: %s bit set\n", 3306 ue_status_low_desc[i]); 3307 } 3308 for (i = 0; ue_hi; ue_hi >>= 1, i++) { 3309 if (ue_hi & 1) 3310 dev_err(dev, "UE: %s bit set\n", 3311 ue_status_hi_desc[i]); 3312 } 3313 } 3314 } 3315 } 3316 3317 static void be_msix_disable(struct be_adapter *adapter) 3318 { 3319 if (msix_enabled(adapter)) { 3320 pci_disable_msix(adapter->pdev); 3321 adapter->num_msix_vec = 0; 3322 adapter->num_msix_roce_vec = 0; 3323 } 3324 } 3325 3326 static int be_msix_enable(struct be_adapter *adapter) 3327 { 3328 unsigned int i, max_roce_eqs; 3329 struct device *dev = &adapter->pdev->dev; 3330 int num_vec; 3331 3332 /* If RoCE is supported, program the max number of vectors that 3333 * could be used for NIC and RoCE, else, just program the number 3334 * we'll use initially. 3335 */ 3336 if (be_roce_supported(adapter)) { 3337 max_roce_eqs = 3338 be_max_func_eqs(adapter) - be_max_nic_eqs(adapter); 3339 max_roce_eqs = min(max_roce_eqs, num_online_cpus()); 3340 num_vec = be_max_any_irqs(adapter) + max_roce_eqs; 3341 } else { 3342 num_vec = max(adapter->cfg_num_rx_irqs, 3343 adapter->cfg_num_tx_irqs); 3344 } 3345 3346 for (i = 0; i < num_vec; i++) 3347 adapter->msix_entries[i].entry = i; 3348 3349 num_vec = pci_enable_msix_range(adapter->pdev, adapter->msix_entries, 3350 MIN_MSIX_VECTORS, num_vec); 3351 if (num_vec < 0) 3352 goto fail; 3353 3354 if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) { 3355 adapter->num_msix_roce_vec = num_vec / 2; 3356 dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n", 3357 adapter->num_msix_roce_vec); 3358 } 3359 3360 adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec; 3361 3362 dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n", 3363 adapter->num_msix_vec); 3364 return 0; 3365 3366 fail: 3367 dev_warn(dev, "MSIx enable failed\n"); 3368 3369 /* INTx is not supported in VFs, so fail probe if enable_msix fails */ 3370 if (be_virtfn(adapter)) 3371 return num_vec; 3372 return 0; 3373 } 3374 3375 static inline int be_msix_vec_get(struct be_adapter *adapter, 3376 struct be_eq_obj *eqo) 3377 { 3378 return adapter->msix_entries[eqo->msix_idx].vector; 3379 } 3380 3381 static int be_msix_register(struct be_adapter *adapter) 3382 { 3383 struct net_device *netdev = adapter->netdev; 3384 struct be_eq_obj *eqo; 3385 int status, i, vec; 3386 3387 for_all_evt_queues(adapter, eqo, i) { 3388 sprintf(eqo->desc, "%s-q%d", netdev->name, i); 3389 vec = be_msix_vec_get(adapter, eqo); 3390 status = request_irq(vec, be_msix, 0, eqo->desc, eqo); 3391 if (status) 3392 goto err_msix; 3393 3394 irq_set_affinity_hint(vec, eqo->affinity_mask); 3395 } 3396 3397 return 0; 3398 err_msix: 3399 for (i--; i >= 0; i--) { 3400 eqo = &adapter->eq_obj[i]; 3401 free_irq(be_msix_vec_get(adapter, eqo), eqo); 3402 } 3403 dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n", 3404 status); 3405 be_msix_disable(adapter); 3406 return status; 3407 } 3408 3409 static int be_irq_register(struct be_adapter *adapter) 3410 { 3411 struct net_device *netdev = adapter->netdev; 3412 int status; 3413 3414 if (msix_enabled(adapter)) { 3415 status = be_msix_register(adapter); 3416 if (status == 0) 3417 goto done; 3418 /* INTx is not supported for VF */ 3419 if (be_virtfn(adapter)) 3420 return status; 3421 } 3422 3423 /* INTx: only the first EQ is used */ 3424 netdev->irq = adapter->pdev->irq; 3425 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name, 3426 &adapter->eq_obj[0]); 3427 if (status) { 3428 dev_err(&adapter->pdev->dev, 3429 "INTx request IRQ failed - err %d\n", status); 3430 return status; 3431 } 3432 done: 3433 adapter->isr_registered = true; 3434 return 0; 3435 } 3436 3437 static void be_irq_unregister(struct be_adapter *adapter) 3438 { 3439 struct net_device *netdev = adapter->netdev; 3440 struct be_eq_obj *eqo; 3441 int i, vec; 3442 3443 if (!adapter->isr_registered) 3444 return; 3445 3446 /* INTx */ 3447 if (!msix_enabled(adapter)) { 3448 free_irq(netdev->irq, &adapter->eq_obj[0]); 3449 goto done; 3450 } 3451 3452 /* MSIx */ 3453 for_all_evt_queues(adapter, eqo, i) { 3454 vec = be_msix_vec_get(adapter, eqo); 3455 irq_set_affinity_hint(vec, NULL); 3456 free_irq(vec, eqo); 3457 } 3458 3459 done: 3460 adapter->isr_registered = false; 3461 } 3462 3463 static void be_rx_qs_destroy(struct be_adapter *adapter) 3464 { 3465 struct rss_info *rss = &adapter->rss_info; 3466 struct be_queue_info *q; 3467 struct be_rx_obj *rxo; 3468 int i; 3469 3470 for_all_rx_queues(adapter, rxo, i) { 3471 q = &rxo->q; 3472 if (q->created) { 3473 /* If RXQs are destroyed while in an "out of buffer" 3474 * state, there is a possibility of an HW stall on 3475 * Lancer. So, post 64 buffers to each queue to relieve 3476 * the "out of buffer" condition. 3477 * Make sure there's space in the RXQ before posting. 3478 */ 3479 if (lancer_chip(adapter)) { 3480 be_rx_cq_clean(rxo); 3481 if (atomic_read(&q->used) == 0) 3482 be_post_rx_frags(rxo, GFP_KERNEL, 3483 MAX_RX_POST); 3484 } 3485 3486 be_cmd_rxq_destroy(adapter, q); 3487 be_rx_cq_clean(rxo); 3488 be_rxq_clean(rxo); 3489 } 3490 be_queue_free(adapter, q); 3491 } 3492 3493 if (rss->rss_flags) { 3494 rss->rss_flags = RSS_ENABLE_NONE; 3495 be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags, 3496 128, rss->rss_hkey); 3497 } 3498 } 3499 3500 static void be_disable_if_filters(struct be_adapter *adapter) 3501 { 3502 /* Don't delete MAC on BE3 VFs without FILTMGMT privilege */ 3503 if (!BEx_chip(adapter) || !be_virtfn(adapter) || 3504 check_privilege(adapter, BE_PRIV_FILTMGMT)) { 3505 be_dev_mac_del(adapter, adapter->pmac_id[0]); 3506 eth_zero_addr(adapter->dev_mac); 3507 } 3508 3509 be_clear_uc_list(adapter); 3510 be_clear_mc_list(adapter); 3511 3512 /* The IFACE flags are enabled in the open path and cleared 3513 * in the close path. When a VF gets detached from the host and 3514 * assigned to a VM the following happens: 3515 * - VF's IFACE flags get cleared in the detach path 3516 * - IFACE create is issued by the VF in the attach path 3517 * Due to a bug in the BE3/Skyhawk-R FW 3518 * (Lancer FW doesn't have the bug), the IFACE capability flags 3519 * specified along with the IFACE create cmd issued by a VF are not 3520 * honoured by FW. As a consequence, if a *new* driver 3521 * (that enables/disables IFACE flags in open/close) 3522 * is loaded in the host and an *old* driver is * used by a VM/VF, 3523 * the IFACE gets created *without* the needed flags. 3524 * To avoid this, disable RX-filter flags only for Lancer. 3525 */ 3526 if (lancer_chip(adapter)) { 3527 be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF); 3528 adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS; 3529 } 3530 } 3531 3532 static int be_close(struct net_device *netdev) 3533 { 3534 struct be_adapter *adapter = netdev_priv(netdev); 3535 struct be_eq_obj *eqo; 3536 int i; 3537 3538 /* This protection is needed as be_close() may be called even when the 3539 * adapter is in cleared state (after eeh perm failure) 3540 */ 3541 if (!(adapter->flags & BE_FLAGS_SETUP_DONE)) 3542 return 0; 3543 3544 /* Before attempting cleanup ensure all the pending cmds in the 3545 * config_wq have finished execution 3546 */ 3547 flush_workqueue(be_wq); 3548 3549 be_disable_if_filters(adapter); 3550 3551 if (adapter->flags & BE_FLAGS_NAPI_ENABLED) { 3552 for_all_evt_queues(adapter, eqo, i) { 3553 napi_disable(&eqo->napi); 3554 } 3555 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED; 3556 } 3557 3558 be_async_mcc_disable(adapter); 3559 3560 /* Wait for all pending tx completions to arrive so that 3561 * all tx skbs are freed. 3562 */ 3563 netif_tx_disable(netdev); 3564 be_tx_compl_clean(adapter); 3565 3566 be_rx_qs_destroy(adapter); 3567 3568 for_all_evt_queues(adapter, eqo, i) { 3569 if (msix_enabled(adapter)) 3570 synchronize_irq(be_msix_vec_get(adapter, eqo)); 3571 else 3572 synchronize_irq(netdev->irq); 3573 be_eq_clean(eqo); 3574 } 3575 3576 be_irq_unregister(adapter); 3577 3578 return 0; 3579 } 3580 3581 static int be_rx_qs_create(struct be_adapter *adapter) 3582 { 3583 struct rss_info *rss = &adapter->rss_info; 3584 u8 rss_key[RSS_HASH_KEY_LEN]; 3585 struct be_rx_obj *rxo; 3586 int rc, i, j; 3587 3588 for_all_rx_queues(adapter, rxo, i) { 3589 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN, 3590 sizeof(struct be_eth_rx_d)); 3591 if (rc) 3592 return rc; 3593 } 3594 3595 if (adapter->need_def_rxq || !adapter->num_rss_qs) { 3596 rxo = default_rxo(adapter); 3597 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, 3598 rx_frag_size, adapter->if_handle, 3599 false, &rxo->rss_id); 3600 if (rc) 3601 return rc; 3602 } 3603 3604 for_all_rss_queues(adapter, rxo, i) { 3605 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, 3606 rx_frag_size, adapter->if_handle, 3607 true, &rxo->rss_id); 3608 if (rc) 3609 return rc; 3610 } 3611 3612 if (be_multi_rxq(adapter)) { 3613 for (j = 0; j < RSS_INDIR_TABLE_LEN; j += adapter->num_rss_qs) { 3614 for_all_rss_queues(adapter, rxo, i) { 3615 if ((j + i) >= RSS_INDIR_TABLE_LEN) 3616 break; 3617 rss->rsstable[j + i] = rxo->rss_id; 3618 rss->rss_queue[j + i] = i; 3619 } 3620 } 3621 rss->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 | 3622 RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6; 3623 3624 if (!BEx_chip(adapter)) 3625 rss->rss_flags |= RSS_ENABLE_UDP_IPV4 | 3626 RSS_ENABLE_UDP_IPV6; 3627 3628 netdev_rss_key_fill(rss_key, RSS_HASH_KEY_LEN); 3629 rc = be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags, 3630 RSS_INDIR_TABLE_LEN, rss_key); 3631 if (rc) { 3632 rss->rss_flags = RSS_ENABLE_NONE; 3633 return rc; 3634 } 3635 3636 memcpy(rss->rss_hkey, rss_key, RSS_HASH_KEY_LEN); 3637 } else { 3638 /* Disable RSS, if only default RX Q is created */ 3639 rss->rss_flags = RSS_ENABLE_NONE; 3640 } 3641 3642 3643 /* Post 1 less than RXQ-len to avoid head being equal to tail, 3644 * which is a queue empty condition 3645 */ 3646 for_all_rx_queues(adapter, rxo, i) 3647 be_post_rx_frags(rxo, GFP_KERNEL, RX_Q_LEN - 1); 3648 3649 return 0; 3650 } 3651 3652 static int be_enable_if_filters(struct be_adapter *adapter) 3653 { 3654 int status; 3655 3656 status = be_cmd_rx_filter(adapter, BE_IF_FILT_FLAGS_BASIC, ON); 3657 if (status) 3658 return status; 3659 3660 /* Normally this condition usually true as the ->dev_mac is zeroed. 3661 * But on BE3 VFs the initial MAC is pre-programmed by PF and 3662 * subsequent be_dev_mac_add() can fail (after fresh boot) 3663 */ 3664 if (!ether_addr_equal(adapter->dev_mac, adapter->netdev->dev_addr)) { 3665 int old_pmac_id = -1; 3666 3667 /* Remember old programmed MAC if any - can happen on BE3 VF */ 3668 if (!is_zero_ether_addr(adapter->dev_mac)) 3669 old_pmac_id = adapter->pmac_id[0]; 3670 3671 status = be_dev_mac_add(adapter, adapter->netdev->dev_addr); 3672 if (status) 3673 return status; 3674 3675 /* Delete the old programmed MAC as we successfully programmed 3676 * a new MAC 3677 */ 3678 if (old_pmac_id >= 0 && old_pmac_id != adapter->pmac_id[0]) 3679 be_dev_mac_del(adapter, old_pmac_id); 3680 3681 ether_addr_copy(adapter->dev_mac, adapter->netdev->dev_addr); 3682 } 3683 3684 if (adapter->vlans_added) 3685 be_vid_config(adapter); 3686 3687 __be_set_rx_mode(adapter); 3688 3689 return 0; 3690 } 3691 3692 static int be_open(struct net_device *netdev) 3693 { 3694 struct be_adapter *adapter = netdev_priv(netdev); 3695 struct be_eq_obj *eqo; 3696 struct be_rx_obj *rxo; 3697 struct be_tx_obj *txo; 3698 u8 link_status; 3699 int status, i; 3700 3701 status = be_rx_qs_create(adapter); 3702 if (status) 3703 goto err; 3704 3705 status = be_enable_if_filters(adapter); 3706 if (status) 3707 goto err; 3708 3709 status = be_irq_register(adapter); 3710 if (status) 3711 goto err; 3712 3713 for_all_rx_queues(adapter, rxo, i) 3714 be_cq_notify(adapter, rxo->cq.id, true, 0); 3715 3716 for_all_tx_queues(adapter, txo, i) 3717 be_cq_notify(adapter, txo->cq.id, true, 0); 3718 3719 be_async_mcc_enable(adapter); 3720 3721 for_all_evt_queues(adapter, eqo, i) { 3722 napi_enable(&eqo->napi); 3723 be_eq_notify(adapter, eqo->q.id, true, true, 0, 0); 3724 } 3725 adapter->flags |= BE_FLAGS_NAPI_ENABLED; 3726 3727 status = be_cmd_link_status_query(adapter, NULL, &link_status, 0); 3728 if (!status) 3729 be_link_status_update(adapter, link_status); 3730 3731 netif_tx_start_all_queues(netdev); 3732 if (skyhawk_chip(adapter)) 3733 udp_tunnel_get_rx_info(netdev); 3734 3735 return 0; 3736 err: 3737 be_close(adapter->netdev); 3738 return -EIO; 3739 } 3740 3741 static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac) 3742 { 3743 u32 addr; 3744 3745 addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0); 3746 3747 mac[5] = (u8)(addr & 0xFF); 3748 mac[4] = (u8)((addr >> 8) & 0xFF); 3749 mac[3] = (u8)((addr >> 16) & 0xFF); 3750 /* Use the OUI from the current MAC address */ 3751 memcpy(mac, adapter->netdev->dev_addr, 3); 3752 } 3753 3754 /* 3755 * Generate a seed MAC address from the PF MAC Address using jhash. 3756 * MAC Address for VFs are assigned incrementally starting from the seed. 3757 * These addresses are programmed in the ASIC by the PF and the VF driver 3758 * queries for the MAC address during its probe. 3759 */ 3760 static int be_vf_eth_addr_config(struct be_adapter *adapter) 3761 { 3762 u32 vf; 3763 int status = 0; 3764 u8 mac[ETH_ALEN]; 3765 struct be_vf_cfg *vf_cfg; 3766 3767 be_vf_eth_addr_generate(adapter, mac); 3768 3769 for_all_vfs(adapter, vf_cfg, vf) { 3770 if (BEx_chip(adapter)) 3771 status = be_cmd_pmac_add(adapter, mac, 3772 vf_cfg->if_handle, 3773 &vf_cfg->pmac_id, vf + 1); 3774 else 3775 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle, 3776 vf + 1); 3777 3778 if (status) 3779 dev_err(&adapter->pdev->dev, 3780 "Mac address assignment failed for VF %d\n", 3781 vf); 3782 else 3783 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN); 3784 3785 mac[5] += 1; 3786 } 3787 return status; 3788 } 3789 3790 static int be_vfs_mac_query(struct be_adapter *adapter) 3791 { 3792 int status, vf; 3793 u8 mac[ETH_ALEN]; 3794 struct be_vf_cfg *vf_cfg; 3795 3796 for_all_vfs(adapter, vf_cfg, vf) { 3797 status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id, 3798 mac, vf_cfg->if_handle, 3799 false, vf+1); 3800 if (status) 3801 return status; 3802 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN); 3803 } 3804 return 0; 3805 } 3806 3807 static void be_vf_clear(struct be_adapter *adapter) 3808 { 3809 struct be_vf_cfg *vf_cfg; 3810 u32 vf; 3811 3812 if (pci_vfs_assigned(adapter->pdev)) { 3813 dev_warn(&adapter->pdev->dev, 3814 "VFs are assigned to VMs: not disabling VFs\n"); 3815 goto done; 3816 } 3817 3818 pci_disable_sriov(adapter->pdev); 3819 3820 for_all_vfs(adapter, vf_cfg, vf) { 3821 if (BEx_chip(adapter)) 3822 be_cmd_pmac_del(adapter, vf_cfg->if_handle, 3823 vf_cfg->pmac_id, vf + 1); 3824 else 3825 be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle, 3826 vf + 1); 3827 3828 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1); 3829 } 3830 3831 if (BE3_chip(adapter)) 3832 be_cmd_set_hsw_config(adapter, 0, 0, 3833 adapter->if_handle, 3834 PORT_FWD_TYPE_PASSTHRU, 0); 3835 done: 3836 kfree(adapter->vf_cfg); 3837 adapter->num_vfs = 0; 3838 adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED; 3839 } 3840 3841 static void be_clear_queues(struct be_adapter *adapter) 3842 { 3843 be_mcc_queues_destroy(adapter); 3844 be_rx_cqs_destroy(adapter); 3845 be_tx_queues_destroy(adapter); 3846 be_evt_queues_destroy(adapter); 3847 } 3848 3849 static void be_cancel_worker(struct be_adapter *adapter) 3850 { 3851 if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) { 3852 cancel_delayed_work_sync(&adapter->work); 3853 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED; 3854 } 3855 } 3856 3857 static void be_cancel_err_detection(struct be_adapter *adapter) 3858 { 3859 struct be_error_recovery *err_rec = &adapter->error_recovery; 3860 3861 if (!be_err_recovery_workq) 3862 return; 3863 3864 if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) { 3865 cancel_delayed_work_sync(&err_rec->err_detection_work); 3866 adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED; 3867 } 3868 } 3869 3870 static int be_enable_vxlan_offloads(struct be_adapter *adapter) 3871 { 3872 struct net_device *netdev = adapter->netdev; 3873 struct device *dev = &adapter->pdev->dev; 3874 struct be_vxlan_port *vxlan_port; 3875 __be16 port; 3876 int status; 3877 3878 vxlan_port = list_first_entry(&adapter->vxlan_port_list, 3879 struct be_vxlan_port, list); 3880 port = vxlan_port->port; 3881 3882 status = be_cmd_manage_iface(adapter, adapter->if_handle, 3883 OP_CONVERT_NORMAL_TO_TUNNEL); 3884 if (status) { 3885 dev_warn(dev, "Failed to convert normal interface to tunnel\n"); 3886 return status; 3887 } 3888 adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS; 3889 3890 status = be_cmd_set_vxlan_port(adapter, port); 3891 if (status) { 3892 dev_warn(dev, "Failed to add VxLAN port\n"); 3893 return status; 3894 } 3895 adapter->vxlan_port = port; 3896 3897 netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 3898 NETIF_F_TSO | NETIF_F_TSO6 | 3899 NETIF_F_GSO_UDP_TUNNEL; 3900 netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL; 3901 netdev->features |= NETIF_F_GSO_UDP_TUNNEL; 3902 3903 dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n", 3904 be16_to_cpu(port)); 3905 return 0; 3906 } 3907 3908 static void be_disable_vxlan_offloads(struct be_adapter *adapter) 3909 { 3910 struct net_device *netdev = adapter->netdev; 3911 3912 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) 3913 be_cmd_manage_iface(adapter, adapter->if_handle, 3914 OP_CONVERT_TUNNEL_TO_NORMAL); 3915 3916 if (adapter->vxlan_port) 3917 be_cmd_set_vxlan_port(adapter, 0); 3918 3919 adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS; 3920 adapter->vxlan_port = 0; 3921 3922 netdev->hw_enc_features = 0; 3923 netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL); 3924 netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL); 3925 } 3926 3927 static void be_calculate_vf_res(struct be_adapter *adapter, u16 num_vfs, 3928 struct be_resources *vft_res) 3929 { 3930 struct be_resources res = adapter->pool_res; 3931 u32 vf_if_cap_flags = res.vf_if_cap_flags; 3932 struct be_resources res_mod = {0}; 3933 u16 num_vf_qs = 1; 3934 3935 /* Distribute the queue resources among the PF and it's VFs */ 3936 if (num_vfs) { 3937 /* Divide the rx queues evenly among the VFs and the PF, capped 3938 * at VF-EQ-count. Any remainder queues belong to the PF. 3939 */ 3940 num_vf_qs = min(SH_VF_MAX_NIC_EQS, 3941 res.max_rss_qs / (num_vfs + 1)); 3942 3943 /* Skyhawk-R chip supports only MAX_PORT_RSS_TABLES 3944 * RSS Tables per port. Provide RSS on VFs, only if number of 3945 * VFs requested is less than it's PF Pool's RSS Tables limit. 3946 */ 3947 if (num_vfs >= be_max_pf_pool_rss_tables(adapter)) 3948 num_vf_qs = 1; 3949 } 3950 3951 /* Resource with fields set to all '1's by GET_PROFILE_CONFIG cmd, 3952 * which are modifiable using SET_PROFILE_CONFIG cmd. 3953 */ 3954 be_cmd_get_profile_config(adapter, &res_mod, NULL, ACTIVE_PROFILE_TYPE, 3955 RESOURCE_MODIFIABLE, 0); 3956 3957 /* If RSS IFACE capability flags are modifiable for a VF, set the 3958 * capability flag as valid and set RSS and DEFQ_RSS IFACE flags if 3959 * more than 1 RSSQ is available for a VF. 3960 * Otherwise, provision only 1 queue pair for VF. 3961 */ 3962 if (res_mod.vf_if_cap_flags & BE_IF_FLAGS_RSS) { 3963 vft_res->flags |= BIT(IF_CAPS_FLAGS_VALID_SHIFT); 3964 if (num_vf_qs > 1) { 3965 vf_if_cap_flags |= BE_IF_FLAGS_RSS; 3966 if (res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS) 3967 vf_if_cap_flags |= BE_IF_FLAGS_DEFQ_RSS; 3968 } else { 3969 vf_if_cap_flags &= ~(BE_IF_FLAGS_RSS | 3970 BE_IF_FLAGS_DEFQ_RSS); 3971 } 3972 } else { 3973 num_vf_qs = 1; 3974 } 3975 3976 if (res_mod.vf_if_cap_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) { 3977 vft_res->flags |= BIT(IF_CAPS_FLAGS_VALID_SHIFT); 3978 vf_if_cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS; 3979 } 3980 3981 vft_res->vf_if_cap_flags = vf_if_cap_flags; 3982 vft_res->max_rx_qs = num_vf_qs; 3983 vft_res->max_rss_qs = num_vf_qs; 3984 vft_res->max_tx_qs = res.max_tx_qs / (num_vfs + 1); 3985 vft_res->max_cq_count = res.max_cq_count / (num_vfs + 1); 3986 3987 /* Distribute unicast MACs, VLANs, IFACE count and MCCQ count equally 3988 * among the PF and it's VFs, if the fields are changeable 3989 */ 3990 if (res_mod.max_uc_mac == FIELD_MODIFIABLE) 3991 vft_res->max_uc_mac = res.max_uc_mac / (num_vfs + 1); 3992 3993 if (res_mod.max_vlans == FIELD_MODIFIABLE) 3994 vft_res->max_vlans = res.max_vlans / (num_vfs + 1); 3995 3996 if (res_mod.max_iface_count == FIELD_MODIFIABLE) 3997 vft_res->max_iface_count = res.max_iface_count / (num_vfs + 1); 3998 3999 if (res_mod.max_mcc_count == FIELD_MODIFIABLE) 4000 vft_res->max_mcc_count = res.max_mcc_count / (num_vfs + 1); 4001 } 4002 4003 static void be_if_destroy(struct be_adapter *adapter) 4004 { 4005 be_cmd_if_destroy(adapter, adapter->if_handle, 0); 4006 4007 kfree(adapter->pmac_id); 4008 adapter->pmac_id = NULL; 4009 4010 kfree(adapter->mc_list); 4011 adapter->mc_list = NULL; 4012 4013 kfree(adapter->uc_list); 4014 adapter->uc_list = NULL; 4015 } 4016 4017 static int be_clear(struct be_adapter *adapter) 4018 { 4019 struct pci_dev *pdev = adapter->pdev; 4020 struct be_resources vft_res = {0}; 4021 4022 be_cancel_worker(adapter); 4023 4024 flush_workqueue(be_wq); 4025 4026 if (sriov_enabled(adapter)) 4027 be_vf_clear(adapter); 4028 4029 /* Re-configure FW to distribute resources evenly across max-supported 4030 * number of VFs, only when VFs are not already enabled. 4031 */ 4032 if (skyhawk_chip(adapter) && be_physfn(adapter) && 4033 !pci_vfs_assigned(pdev)) { 4034 be_calculate_vf_res(adapter, 4035 pci_sriov_get_totalvfs(pdev), 4036 &vft_res); 4037 be_cmd_set_sriov_config(adapter, adapter->pool_res, 4038 pci_sriov_get_totalvfs(pdev), 4039 &vft_res); 4040 } 4041 4042 be_disable_vxlan_offloads(adapter); 4043 4044 be_if_destroy(adapter); 4045 4046 be_clear_queues(adapter); 4047 4048 be_msix_disable(adapter); 4049 adapter->flags &= ~BE_FLAGS_SETUP_DONE; 4050 return 0; 4051 } 4052 4053 static int be_vfs_if_create(struct be_adapter *adapter) 4054 { 4055 struct be_resources res = {0}; 4056 u32 cap_flags, en_flags, vf; 4057 struct be_vf_cfg *vf_cfg; 4058 int status; 4059 4060 /* If a FW profile exists, then cap_flags are updated */ 4061 cap_flags = BE_VF_IF_EN_FLAGS; 4062 4063 for_all_vfs(adapter, vf_cfg, vf) { 4064 if (!BE3_chip(adapter)) { 4065 status = be_cmd_get_profile_config(adapter, &res, NULL, 4066 ACTIVE_PROFILE_TYPE, 4067 RESOURCE_LIMITS, 4068 vf + 1); 4069 if (!status) { 4070 cap_flags = res.if_cap_flags; 4071 /* Prevent VFs from enabling VLAN promiscuous 4072 * mode 4073 */ 4074 cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS; 4075 } 4076 } 4077 4078 /* PF should enable IF flags during proxy if_create call */ 4079 en_flags = cap_flags & BE_VF_IF_EN_FLAGS; 4080 status = be_cmd_if_create(adapter, cap_flags, en_flags, 4081 &vf_cfg->if_handle, vf + 1); 4082 if (status) 4083 return status; 4084 } 4085 4086 return 0; 4087 } 4088 4089 static int be_vf_setup_init(struct be_adapter *adapter) 4090 { 4091 struct be_vf_cfg *vf_cfg; 4092 int vf; 4093 4094 adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg), 4095 GFP_KERNEL); 4096 if (!adapter->vf_cfg) 4097 return -ENOMEM; 4098 4099 for_all_vfs(adapter, vf_cfg, vf) { 4100 vf_cfg->if_handle = -1; 4101 vf_cfg->pmac_id = -1; 4102 } 4103 return 0; 4104 } 4105 4106 static int be_vf_setup(struct be_adapter *adapter) 4107 { 4108 struct device *dev = &adapter->pdev->dev; 4109 struct be_vf_cfg *vf_cfg; 4110 int status, old_vfs, vf; 4111 bool spoofchk; 4112 4113 old_vfs = pci_num_vf(adapter->pdev); 4114 4115 status = be_vf_setup_init(adapter); 4116 if (status) 4117 goto err; 4118 4119 if (old_vfs) { 4120 for_all_vfs(adapter, vf_cfg, vf) { 4121 status = be_cmd_get_if_id(adapter, vf_cfg, vf); 4122 if (status) 4123 goto err; 4124 } 4125 4126 status = be_vfs_mac_query(adapter); 4127 if (status) 4128 goto err; 4129 } else { 4130 status = be_vfs_if_create(adapter); 4131 if (status) 4132 goto err; 4133 4134 status = be_vf_eth_addr_config(adapter); 4135 if (status) 4136 goto err; 4137 } 4138 4139 for_all_vfs(adapter, vf_cfg, vf) { 4140 /* Allow VFs to programs MAC/VLAN filters */ 4141 status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges, 4142 vf + 1); 4143 if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) { 4144 status = be_cmd_set_fn_privileges(adapter, 4145 vf_cfg->privileges | 4146 BE_PRIV_FILTMGMT, 4147 vf + 1); 4148 if (!status) { 4149 vf_cfg->privileges |= BE_PRIV_FILTMGMT; 4150 dev_info(dev, "VF%d has FILTMGMT privilege\n", 4151 vf); 4152 } 4153 } 4154 4155 /* Allow full available bandwidth */ 4156 if (!old_vfs) 4157 be_cmd_config_qos(adapter, 0, 0, vf + 1); 4158 4159 status = be_cmd_get_hsw_config(adapter, NULL, vf + 1, 4160 vf_cfg->if_handle, NULL, 4161 &spoofchk); 4162 if (!status) 4163 vf_cfg->spoofchk = spoofchk; 4164 4165 if (!old_vfs) { 4166 be_cmd_enable_vf(adapter, vf + 1); 4167 be_cmd_set_logical_link_config(adapter, 4168 IFLA_VF_LINK_STATE_AUTO, 4169 vf+1); 4170 } 4171 } 4172 4173 if (!old_vfs) { 4174 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs); 4175 if (status) { 4176 dev_err(dev, "SRIOV enable failed\n"); 4177 adapter->num_vfs = 0; 4178 goto err; 4179 } 4180 } 4181 4182 if (BE3_chip(adapter)) { 4183 /* On BE3, enable VEB only when SRIOV is enabled */ 4184 status = be_cmd_set_hsw_config(adapter, 0, 0, 4185 adapter->if_handle, 4186 PORT_FWD_TYPE_VEB, 0); 4187 if (status) 4188 goto err; 4189 } 4190 4191 adapter->flags |= BE_FLAGS_SRIOV_ENABLED; 4192 return 0; 4193 err: 4194 dev_err(dev, "VF setup failed\n"); 4195 be_vf_clear(adapter); 4196 return status; 4197 } 4198 4199 /* Converting function_mode bits on BE3 to SH mc_type enums */ 4200 4201 static u8 be_convert_mc_type(u32 function_mode) 4202 { 4203 if (function_mode & VNIC_MODE && function_mode & QNQ_MODE) 4204 return vNIC1; 4205 else if (function_mode & QNQ_MODE) 4206 return FLEX10; 4207 else if (function_mode & VNIC_MODE) 4208 return vNIC2; 4209 else if (function_mode & UMC_ENABLED) 4210 return UMC; 4211 else 4212 return MC_NONE; 4213 } 4214 4215 /* On BE2/BE3 FW does not suggest the supported limits */ 4216 static void BEx_get_resources(struct be_adapter *adapter, 4217 struct be_resources *res) 4218 { 4219 bool use_sriov = adapter->num_vfs ? 1 : 0; 4220 4221 if (be_physfn(adapter)) 4222 res->max_uc_mac = BE_UC_PMAC_COUNT; 4223 else 4224 res->max_uc_mac = BE_VF_UC_PMAC_COUNT; 4225 4226 adapter->mc_type = be_convert_mc_type(adapter->function_mode); 4227 4228 if (be_is_mc(adapter)) { 4229 /* Assuming that there are 4 channels per port, 4230 * when multi-channel is enabled 4231 */ 4232 if (be_is_qnq_mode(adapter)) 4233 res->max_vlans = BE_NUM_VLANS_SUPPORTED/8; 4234 else 4235 /* In a non-qnq multichannel mode, the pvid 4236 * takes up one vlan entry 4237 */ 4238 res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1; 4239 } else { 4240 res->max_vlans = BE_NUM_VLANS_SUPPORTED; 4241 } 4242 4243 res->max_mcast_mac = BE_MAX_MC; 4244 4245 /* 1) For BE3 1Gb ports, FW does not support multiple TXQs 4246 * 2) Create multiple TX rings on a BE3-R multi-channel interface 4247 * *only* if it is RSS-capable. 4248 */ 4249 if (BE2_chip(adapter) || use_sriov || (adapter->port_num > 1) || 4250 be_virtfn(adapter) || 4251 (be_is_mc(adapter) && 4252 !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) { 4253 res->max_tx_qs = 1; 4254 } else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) { 4255 struct be_resources super_nic_res = {0}; 4256 4257 /* On a SuperNIC profile, the driver needs to use the 4258 * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits 4259 */ 4260 be_cmd_get_profile_config(adapter, &super_nic_res, NULL, 4261 ACTIVE_PROFILE_TYPE, RESOURCE_LIMITS, 4262 0); 4263 /* Some old versions of BE3 FW don't report max_tx_qs value */ 4264 res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS; 4265 } else { 4266 res->max_tx_qs = BE3_MAX_TX_QS; 4267 } 4268 4269 if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) && 4270 !use_sriov && be_physfn(adapter)) 4271 res->max_rss_qs = (adapter->be3_native) ? 4272 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS; 4273 res->max_rx_qs = res->max_rss_qs + 1; 4274 4275 if (be_physfn(adapter)) 4276 res->max_evt_qs = (be_max_vfs(adapter) > 0) ? 4277 BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS; 4278 else 4279 res->max_evt_qs = 1; 4280 4281 res->if_cap_flags = BE_IF_CAP_FLAGS_WANT; 4282 res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS; 4283 if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS)) 4284 res->if_cap_flags &= ~BE_IF_FLAGS_RSS; 4285 } 4286 4287 static void be_setup_init(struct be_adapter *adapter) 4288 { 4289 adapter->vlan_prio_bmap = 0xff; 4290 adapter->phy.link_speed = -1; 4291 adapter->if_handle = -1; 4292 adapter->be3_native = false; 4293 adapter->if_flags = 0; 4294 adapter->phy_state = BE_UNKNOWN_PHY_STATE; 4295 if (be_physfn(adapter)) 4296 adapter->cmd_privileges = MAX_PRIVILEGES; 4297 else 4298 adapter->cmd_privileges = MIN_PRIVILEGES; 4299 } 4300 4301 /* HW supports only MAX_PORT_RSS_TABLES RSS Policy Tables per port. 4302 * However, this HW limitation is not exposed to the host via any SLI cmd. 4303 * As a result, in the case of SRIOV and in particular multi-partition configs 4304 * the driver needs to calcuate a proportional share of RSS Tables per PF-pool 4305 * for distribution between the VFs. This self-imposed limit will determine the 4306 * no: of VFs for which RSS can be enabled. 4307 */ 4308 static void be_calculate_pf_pool_rss_tables(struct be_adapter *adapter) 4309 { 4310 struct be_port_resources port_res = {0}; 4311 u8 rss_tables_on_port; 4312 u16 max_vfs = be_max_vfs(adapter); 4313 4314 be_cmd_get_profile_config(adapter, NULL, &port_res, SAVED_PROFILE_TYPE, 4315 RESOURCE_LIMITS, 0); 4316 4317 rss_tables_on_port = MAX_PORT_RSS_TABLES - port_res.nic_pfs; 4318 4319 /* Each PF Pool's RSS Tables limit = 4320 * PF's Max VFs / Total_Max_VFs on Port * RSS Tables on Port 4321 */ 4322 adapter->pool_res.max_rss_tables = 4323 max_vfs * rss_tables_on_port / port_res.max_vfs; 4324 } 4325 4326 static int be_get_sriov_config(struct be_adapter *adapter) 4327 { 4328 struct be_resources res = {0}; 4329 int max_vfs, old_vfs; 4330 4331 be_cmd_get_profile_config(adapter, &res, NULL, ACTIVE_PROFILE_TYPE, 4332 RESOURCE_LIMITS, 0); 4333 4334 /* Some old versions of BE3 FW don't report max_vfs value */ 4335 if (BE3_chip(adapter) && !res.max_vfs) { 4336 max_vfs = pci_sriov_get_totalvfs(adapter->pdev); 4337 res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0; 4338 } 4339 4340 adapter->pool_res = res; 4341 4342 /* If during previous unload of the driver, the VFs were not disabled, 4343 * then we cannot rely on the PF POOL limits for the TotalVFs value. 4344 * Instead use the TotalVFs value stored in the pci-dev struct. 4345 */ 4346 old_vfs = pci_num_vf(adapter->pdev); 4347 if (old_vfs) { 4348 dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n", 4349 old_vfs); 4350 4351 adapter->pool_res.max_vfs = 4352 pci_sriov_get_totalvfs(adapter->pdev); 4353 adapter->num_vfs = old_vfs; 4354 } 4355 4356 if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) { 4357 be_calculate_pf_pool_rss_tables(adapter); 4358 dev_info(&adapter->pdev->dev, 4359 "RSS can be enabled for all VFs if num_vfs <= %d\n", 4360 be_max_pf_pool_rss_tables(adapter)); 4361 } 4362 return 0; 4363 } 4364 4365 static void be_alloc_sriov_res(struct be_adapter *adapter) 4366 { 4367 int old_vfs = pci_num_vf(adapter->pdev); 4368 struct be_resources vft_res = {0}; 4369 int status; 4370 4371 be_get_sriov_config(adapter); 4372 4373 if (!old_vfs) 4374 pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter)); 4375 4376 /* When the HW is in SRIOV capable configuration, the PF-pool 4377 * resources are given to PF during driver load, if there are no 4378 * old VFs. This facility is not available in BE3 FW. 4379 * Also, this is done by FW in Lancer chip. 4380 */ 4381 if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) { 4382 be_calculate_vf_res(adapter, 0, &vft_res); 4383 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0, 4384 &vft_res); 4385 if (status) 4386 dev_err(&adapter->pdev->dev, 4387 "Failed to optimize SRIOV resources\n"); 4388 } 4389 } 4390 4391 static int be_get_resources(struct be_adapter *adapter) 4392 { 4393 struct device *dev = &adapter->pdev->dev; 4394 struct be_resources res = {0}; 4395 int status; 4396 4397 /* For Lancer, SH etc read per-function resource limits from FW. 4398 * GET_FUNC_CONFIG returns per function guaranteed limits. 4399 * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits 4400 */ 4401 if (BEx_chip(adapter)) { 4402 BEx_get_resources(adapter, &res); 4403 } else { 4404 status = be_cmd_get_func_config(adapter, &res); 4405 if (status) 4406 return status; 4407 4408 /* If a deafault RXQ must be created, we'll use up one RSSQ*/ 4409 if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs && 4410 !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS)) 4411 res.max_rss_qs -= 1; 4412 } 4413 4414 /* If RoCE is supported stash away half the EQs for RoCE */ 4415 res.max_nic_evt_qs = be_roce_supported(adapter) ? 4416 res.max_evt_qs / 2 : res.max_evt_qs; 4417 adapter->res = res; 4418 4419 /* If FW supports RSS default queue, then skip creating non-RSS 4420 * queue for non-IP traffic. 4421 */ 4422 adapter->need_def_rxq = (be_if_cap_flags(adapter) & 4423 BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1; 4424 4425 dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n", 4426 be_max_txqs(adapter), be_max_rxqs(adapter), 4427 be_max_rss(adapter), be_max_nic_eqs(adapter), 4428 be_max_vfs(adapter)); 4429 dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n", 4430 be_max_uc(adapter), be_max_mc(adapter), 4431 be_max_vlans(adapter)); 4432 4433 /* Ensure RX and TX queues are created in pairs at init time */ 4434 adapter->cfg_num_rx_irqs = 4435 min_t(u16, netif_get_num_default_rss_queues(), 4436 be_max_qp_irqs(adapter)); 4437 adapter->cfg_num_tx_irqs = adapter->cfg_num_rx_irqs; 4438 return 0; 4439 } 4440 4441 static int be_get_config(struct be_adapter *adapter) 4442 { 4443 int status, level; 4444 u16 profile_id; 4445 4446 status = be_cmd_get_cntl_attributes(adapter); 4447 if (status) 4448 return status; 4449 4450 status = be_cmd_query_fw_cfg(adapter); 4451 if (status) 4452 return status; 4453 4454 if (!lancer_chip(adapter) && be_physfn(adapter)) 4455 be_cmd_get_fat_dump_len(adapter, &adapter->fat_dump_len); 4456 4457 if (BEx_chip(adapter)) { 4458 level = be_cmd_get_fw_log_level(adapter); 4459 adapter->msg_enable = 4460 level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0; 4461 } 4462 4463 be_cmd_get_acpi_wol_cap(adapter); 4464 pci_enable_wake(adapter->pdev, PCI_D3hot, adapter->wol_en); 4465 pci_enable_wake(adapter->pdev, PCI_D3cold, adapter->wol_en); 4466 4467 be_cmd_query_port_name(adapter); 4468 4469 if (be_physfn(adapter)) { 4470 status = be_cmd_get_active_profile(adapter, &profile_id); 4471 if (!status) 4472 dev_info(&adapter->pdev->dev, 4473 "Using profile 0x%x\n", profile_id); 4474 } 4475 4476 return 0; 4477 } 4478 4479 static int be_mac_setup(struct be_adapter *adapter) 4480 { 4481 u8 mac[ETH_ALEN]; 4482 int status; 4483 4484 if (is_zero_ether_addr(adapter->netdev->dev_addr)) { 4485 status = be_cmd_get_perm_mac(adapter, mac); 4486 if (status) 4487 return status; 4488 4489 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN); 4490 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN); 4491 4492 /* Initial MAC for BE3 VFs is already programmed by PF */ 4493 if (BEx_chip(adapter) && be_virtfn(adapter)) 4494 memcpy(adapter->dev_mac, mac, ETH_ALEN); 4495 } 4496 4497 return 0; 4498 } 4499 4500 static void be_schedule_worker(struct be_adapter *adapter) 4501 { 4502 queue_delayed_work(be_wq, &adapter->work, msecs_to_jiffies(1000)); 4503 adapter->flags |= BE_FLAGS_WORKER_SCHEDULED; 4504 } 4505 4506 static void be_destroy_err_recovery_workq(void) 4507 { 4508 if (!be_err_recovery_workq) 4509 return; 4510 4511 flush_workqueue(be_err_recovery_workq); 4512 destroy_workqueue(be_err_recovery_workq); 4513 be_err_recovery_workq = NULL; 4514 } 4515 4516 static void be_schedule_err_detection(struct be_adapter *adapter, u32 delay) 4517 { 4518 struct be_error_recovery *err_rec = &adapter->error_recovery; 4519 4520 if (!be_err_recovery_workq) 4521 return; 4522 4523 queue_delayed_work(be_err_recovery_workq, &err_rec->err_detection_work, 4524 msecs_to_jiffies(delay)); 4525 adapter->flags |= BE_FLAGS_ERR_DETECTION_SCHEDULED; 4526 } 4527 4528 static int be_setup_queues(struct be_adapter *adapter) 4529 { 4530 struct net_device *netdev = adapter->netdev; 4531 int status; 4532 4533 status = be_evt_queues_create(adapter); 4534 if (status) 4535 goto err; 4536 4537 status = be_tx_qs_create(adapter); 4538 if (status) 4539 goto err; 4540 4541 status = be_rx_cqs_create(adapter); 4542 if (status) 4543 goto err; 4544 4545 status = be_mcc_queues_create(adapter); 4546 if (status) 4547 goto err; 4548 4549 status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs); 4550 if (status) 4551 goto err; 4552 4553 status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs); 4554 if (status) 4555 goto err; 4556 4557 return 0; 4558 err: 4559 dev_err(&adapter->pdev->dev, "queue_setup failed\n"); 4560 return status; 4561 } 4562 4563 static int be_if_create(struct be_adapter *adapter) 4564 { 4565 u32 en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS; 4566 u32 cap_flags = be_if_cap_flags(adapter); 4567 int status; 4568 4569 /* alloc required memory for other filtering fields */ 4570 adapter->pmac_id = kcalloc(be_max_uc(adapter), 4571 sizeof(*adapter->pmac_id), GFP_KERNEL); 4572 if (!adapter->pmac_id) 4573 return -ENOMEM; 4574 4575 adapter->mc_list = kcalloc(be_max_mc(adapter), 4576 sizeof(*adapter->mc_list), GFP_KERNEL); 4577 if (!adapter->mc_list) 4578 return -ENOMEM; 4579 4580 adapter->uc_list = kcalloc(be_max_uc(adapter), 4581 sizeof(*adapter->uc_list), GFP_KERNEL); 4582 if (!adapter->uc_list) 4583 return -ENOMEM; 4584 4585 if (adapter->cfg_num_rx_irqs == 1) 4586 cap_flags &= ~(BE_IF_FLAGS_DEFQ_RSS | BE_IF_FLAGS_RSS); 4587 4588 en_flags &= cap_flags; 4589 /* will enable all the needed filter flags in be_open() */ 4590 status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags, 4591 &adapter->if_handle, 0); 4592 4593 if (status) 4594 return status; 4595 4596 return 0; 4597 } 4598 4599 int be_update_queues(struct be_adapter *adapter) 4600 { 4601 struct net_device *netdev = adapter->netdev; 4602 int status; 4603 4604 if (netif_running(netdev)) 4605 be_close(netdev); 4606 4607 be_cancel_worker(adapter); 4608 4609 /* If any vectors have been shared with RoCE we cannot re-program 4610 * the MSIx table. 4611 */ 4612 if (!adapter->num_msix_roce_vec) 4613 be_msix_disable(adapter); 4614 4615 be_clear_queues(adapter); 4616 status = be_cmd_if_destroy(adapter, adapter->if_handle, 0); 4617 if (status) 4618 return status; 4619 4620 if (!msix_enabled(adapter)) { 4621 status = be_msix_enable(adapter); 4622 if (status) 4623 return status; 4624 } 4625 4626 status = be_if_create(adapter); 4627 if (status) 4628 return status; 4629 4630 status = be_setup_queues(adapter); 4631 if (status) 4632 return status; 4633 4634 be_schedule_worker(adapter); 4635 4636 /* The IF was destroyed and re-created. We need to clear 4637 * all promiscuous flags valid for the destroyed IF. 4638 * Without this promisc mode is not restored during 4639 * be_open() because the driver thinks that it is 4640 * already enabled in HW. 4641 */ 4642 adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS; 4643 4644 if (netif_running(netdev)) 4645 status = be_open(netdev); 4646 4647 return status; 4648 } 4649 4650 static inline int fw_major_num(const char *fw_ver) 4651 { 4652 int fw_major = 0, i; 4653 4654 i = sscanf(fw_ver, "%d.", &fw_major); 4655 if (i != 1) 4656 return 0; 4657 4658 return fw_major; 4659 } 4660 4661 /* If it is error recovery, FLR the PF 4662 * Else if any VFs are already enabled don't FLR the PF 4663 */ 4664 static bool be_reset_required(struct be_adapter *adapter) 4665 { 4666 if (be_error_recovering(adapter)) 4667 return true; 4668 else 4669 return pci_num_vf(adapter->pdev) == 0; 4670 } 4671 4672 /* Wait for the FW to be ready and perform the required initialization */ 4673 static int be_func_init(struct be_adapter *adapter) 4674 { 4675 int status; 4676 4677 status = be_fw_wait_ready(adapter); 4678 if (status) 4679 return status; 4680 4681 /* FW is now ready; clear errors to allow cmds/doorbell */ 4682 be_clear_error(adapter, BE_CLEAR_ALL); 4683 4684 if (be_reset_required(adapter)) { 4685 status = be_cmd_reset_function(adapter); 4686 if (status) 4687 return status; 4688 4689 /* Wait for interrupts to quiesce after an FLR */ 4690 msleep(100); 4691 } 4692 4693 /* Tell FW we're ready to fire cmds */ 4694 status = be_cmd_fw_init(adapter); 4695 if (status) 4696 return status; 4697 4698 /* Allow interrupts for other ULPs running on NIC function */ 4699 be_intr_set(adapter, true); 4700 4701 return 0; 4702 } 4703 4704 static int be_setup(struct be_adapter *adapter) 4705 { 4706 struct device *dev = &adapter->pdev->dev; 4707 int status; 4708 4709 status = be_func_init(adapter); 4710 if (status) 4711 return status; 4712 4713 be_setup_init(adapter); 4714 4715 if (!lancer_chip(adapter)) 4716 be_cmd_req_native_mode(adapter); 4717 4718 /* invoke this cmd first to get pf_num and vf_num which are needed 4719 * for issuing profile related cmds 4720 */ 4721 if (!BEx_chip(adapter)) { 4722 status = be_cmd_get_func_config(adapter, NULL); 4723 if (status) 4724 return status; 4725 } 4726 4727 status = be_get_config(adapter); 4728 if (status) 4729 goto err; 4730 4731 if (!BE2_chip(adapter) && be_physfn(adapter)) 4732 be_alloc_sriov_res(adapter); 4733 4734 status = be_get_resources(adapter); 4735 if (status) 4736 goto err; 4737 4738 status = be_msix_enable(adapter); 4739 if (status) 4740 goto err; 4741 4742 /* will enable all the needed filter flags in be_open() */ 4743 status = be_if_create(adapter); 4744 if (status) 4745 goto err; 4746 4747 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */ 4748 rtnl_lock(); 4749 status = be_setup_queues(adapter); 4750 rtnl_unlock(); 4751 if (status) 4752 goto err; 4753 4754 be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0); 4755 4756 status = be_mac_setup(adapter); 4757 if (status) 4758 goto err; 4759 4760 be_cmd_get_fw_ver(adapter); 4761 dev_info(dev, "FW version is %s\n", adapter->fw_ver); 4762 4763 if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) { 4764 dev_err(dev, "Firmware on card is old(%s), IRQs may not work", 4765 adapter->fw_ver); 4766 dev_err(dev, "Please upgrade firmware to version >= 4.0\n"); 4767 } 4768 4769 status = be_cmd_set_flow_control(adapter, adapter->tx_fc, 4770 adapter->rx_fc); 4771 if (status) 4772 be_cmd_get_flow_control(adapter, &adapter->tx_fc, 4773 &adapter->rx_fc); 4774 4775 dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n", 4776 adapter->tx_fc, adapter->rx_fc); 4777 4778 if (be_physfn(adapter)) 4779 be_cmd_set_logical_link_config(adapter, 4780 IFLA_VF_LINK_STATE_AUTO, 0); 4781 4782 /* BE3 EVB echoes broadcast/multicast packets back to PF's vport 4783 * confusing a linux bridge or OVS that it might be connected to. 4784 * Set the EVB to PASSTHRU mode which effectively disables the EVB 4785 * when SRIOV is not enabled. 4786 */ 4787 if (BE3_chip(adapter)) 4788 be_cmd_set_hsw_config(adapter, 0, 0, adapter->if_handle, 4789 PORT_FWD_TYPE_PASSTHRU, 0); 4790 4791 if (adapter->num_vfs) 4792 be_vf_setup(adapter); 4793 4794 status = be_cmd_get_phy_info(adapter); 4795 if (!status && be_pause_supported(adapter)) 4796 adapter->phy.fc_autoneg = 1; 4797 4798 if (be_physfn(adapter) && !lancer_chip(adapter)) 4799 be_cmd_set_features(adapter); 4800 4801 be_schedule_worker(adapter); 4802 adapter->flags |= BE_FLAGS_SETUP_DONE; 4803 return 0; 4804 err: 4805 be_clear(adapter); 4806 return status; 4807 } 4808 4809 #ifdef CONFIG_NET_POLL_CONTROLLER 4810 static void be_netpoll(struct net_device *netdev) 4811 { 4812 struct be_adapter *adapter = netdev_priv(netdev); 4813 struct be_eq_obj *eqo; 4814 int i; 4815 4816 for_all_evt_queues(adapter, eqo, i) { 4817 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0); 4818 napi_schedule(&eqo->napi); 4819 } 4820 } 4821 #endif 4822 4823 int be_load_fw(struct be_adapter *adapter, u8 *fw_file) 4824 { 4825 const struct firmware *fw; 4826 int status; 4827 4828 if (!netif_running(adapter->netdev)) { 4829 dev_err(&adapter->pdev->dev, 4830 "Firmware load not allowed (interface is down)\n"); 4831 return -ENETDOWN; 4832 } 4833 4834 status = request_firmware(&fw, fw_file, &adapter->pdev->dev); 4835 if (status) 4836 goto fw_exit; 4837 4838 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file); 4839 4840 if (lancer_chip(adapter)) 4841 status = lancer_fw_download(adapter, fw); 4842 else 4843 status = be_fw_download(adapter, fw); 4844 4845 if (!status) 4846 be_cmd_get_fw_ver(adapter); 4847 4848 fw_exit: 4849 release_firmware(fw); 4850 return status; 4851 } 4852 4853 static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 4854 u16 flags) 4855 { 4856 struct be_adapter *adapter = netdev_priv(dev); 4857 struct nlattr *attr, *br_spec; 4858 int rem; 4859 int status = 0; 4860 u16 mode = 0; 4861 4862 if (!sriov_enabled(adapter)) 4863 return -EOPNOTSUPP; 4864 4865 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 4866 if (!br_spec) 4867 return -EINVAL; 4868 4869 nla_for_each_nested(attr, br_spec, rem) { 4870 if (nla_type(attr) != IFLA_BRIDGE_MODE) 4871 continue; 4872 4873 if (nla_len(attr) < sizeof(mode)) 4874 return -EINVAL; 4875 4876 mode = nla_get_u16(attr); 4877 if (BE3_chip(adapter) && mode == BRIDGE_MODE_VEPA) 4878 return -EOPNOTSUPP; 4879 4880 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB) 4881 return -EINVAL; 4882 4883 status = be_cmd_set_hsw_config(adapter, 0, 0, 4884 adapter->if_handle, 4885 mode == BRIDGE_MODE_VEPA ? 4886 PORT_FWD_TYPE_VEPA : 4887 PORT_FWD_TYPE_VEB, 0); 4888 if (status) 4889 goto err; 4890 4891 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n", 4892 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB"); 4893 4894 return status; 4895 } 4896 err: 4897 dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n", 4898 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB"); 4899 4900 return status; 4901 } 4902 4903 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 4904 struct net_device *dev, u32 filter_mask, 4905 int nlflags) 4906 { 4907 struct be_adapter *adapter = netdev_priv(dev); 4908 int status = 0; 4909 u8 hsw_mode; 4910 4911 /* BE and Lancer chips support VEB mode only */ 4912 if (BEx_chip(adapter) || lancer_chip(adapter)) { 4913 /* VEB is disabled in non-SR-IOV profiles on BE3/Lancer */ 4914 if (!pci_sriov_get_totalvfs(adapter->pdev)) 4915 return 0; 4916 hsw_mode = PORT_FWD_TYPE_VEB; 4917 } else { 4918 status = be_cmd_get_hsw_config(adapter, NULL, 0, 4919 adapter->if_handle, &hsw_mode, 4920 NULL); 4921 if (status) 4922 return 0; 4923 4924 if (hsw_mode == PORT_FWD_TYPE_PASSTHRU) 4925 return 0; 4926 } 4927 4928 return ndo_dflt_bridge_getlink(skb, pid, seq, dev, 4929 hsw_mode == PORT_FWD_TYPE_VEPA ? 4930 BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB, 4931 0, 0, nlflags, filter_mask, NULL); 4932 } 4933 4934 static struct be_cmd_work *be_alloc_work(struct be_adapter *adapter, 4935 void (*func)(struct work_struct *)) 4936 { 4937 struct be_cmd_work *work; 4938 4939 work = kzalloc(sizeof(*work), GFP_ATOMIC); 4940 if (!work) { 4941 dev_err(&adapter->pdev->dev, 4942 "be_work memory allocation failed\n"); 4943 return NULL; 4944 } 4945 4946 INIT_WORK(&work->work, func); 4947 work->adapter = adapter; 4948 return work; 4949 } 4950 4951 /* VxLAN offload Notes: 4952 * 4953 * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't 4954 * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload 4955 * is expected to work across all types of IP tunnels once exported. Skyhawk 4956 * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN 4957 * offloads in hw_enc_features only when a VxLAN port is added. If other (non 4958 * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for 4959 * those other tunnels are unexported on the fly through ndo_features_check(). 4960 * 4961 * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack 4962 * adds more than one port, disable offloads and re-enable them again when 4963 * there's only one port left. We maintain a list of ports for this purpose. 4964 */ 4965 static void be_work_add_vxlan_port(struct work_struct *work) 4966 { 4967 struct be_cmd_work *cmd_work = 4968 container_of(work, struct be_cmd_work, work); 4969 struct be_adapter *adapter = cmd_work->adapter; 4970 struct device *dev = &adapter->pdev->dev; 4971 __be16 port = cmd_work->info.vxlan_port; 4972 struct be_vxlan_port *vxlan_port; 4973 int status; 4974 4975 /* Bump up the alias count if it is an existing port */ 4976 list_for_each_entry(vxlan_port, &adapter->vxlan_port_list, list) { 4977 if (vxlan_port->port == port) { 4978 vxlan_port->port_aliases++; 4979 goto done; 4980 } 4981 } 4982 4983 /* Add a new port to our list. We don't need a lock here since port 4984 * add/delete are done only in the context of a single-threaded work 4985 * queue (be_wq). 4986 */ 4987 vxlan_port = kzalloc(sizeof(*vxlan_port), GFP_KERNEL); 4988 if (!vxlan_port) 4989 goto done; 4990 4991 vxlan_port->port = port; 4992 INIT_LIST_HEAD(&vxlan_port->list); 4993 list_add_tail(&vxlan_port->list, &adapter->vxlan_port_list); 4994 adapter->vxlan_port_count++; 4995 4996 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) { 4997 dev_info(dev, 4998 "Only one UDP port supported for VxLAN offloads\n"); 4999 dev_info(dev, "Disabling VxLAN offloads\n"); 5000 goto err; 5001 } 5002 5003 if (adapter->vxlan_port_count > 1) 5004 goto done; 5005 5006 status = be_enable_vxlan_offloads(adapter); 5007 if (!status) 5008 goto done; 5009 5010 err: 5011 be_disable_vxlan_offloads(adapter); 5012 done: 5013 kfree(cmd_work); 5014 return; 5015 } 5016 5017 static void be_work_del_vxlan_port(struct work_struct *work) 5018 { 5019 struct be_cmd_work *cmd_work = 5020 container_of(work, struct be_cmd_work, work); 5021 struct be_adapter *adapter = cmd_work->adapter; 5022 __be16 port = cmd_work->info.vxlan_port; 5023 struct be_vxlan_port *vxlan_port; 5024 5025 /* Nothing to be done if a port alias is being deleted */ 5026 list_for_each_entry(vxlan_port, &adapter->vxlan_port_list, list) { 5027 if (vxlan_port->port == port) { 5028 if (vxlan_port->port_aliases) { 5029 vxlan_port->port_aliases--; 5030 goto done; 5031 } 5032 break; 5033 } 5034 } 5035 5036 /* No port aliases left; delete the port from the list */ 5037 list_del(&vxlan_port->list); 5038 adapter->vxlan_port_count--; 5039 5040 /* Disable VxLAN offload if this is the offloaded port */ 5041 if (adapter->vxlan_port == vxlan_port->port) { 5042 WARN_ON(adapter->vxlan_port_count); 5043 be_disable_vxlan_offloads(adapter); 5044 dev_info(&adapter->pdev->dev, 5045 "Disabled VxLAN offloads for UDP port %d\n", 5046 be16_to_cpu(port)); 5047 goto out; 5048 } 5049 5050 /* If only 1 port is left, re-enable VxLAN offload */ 5051 if (adapter->vxlan_port_count == 1) 5052 be_enable_vxlan_offloads(adapter); 5053 5054 out: 5055 kfree(vxlan_port); 5056 done: 5057 kfree(cmd_work); 5058 } 5059 5060 static void be_cfg_vxlan_port(struct net_device *netdev, 5061 struct udp_tunnel_info *ti, 5062 void (*func)(struct work_struct *)) 5063 { 5064 struct be_adapter *adapter = netdev_priv(netdev); 5065 struct be_cmd_work *cmd_work; 5066 5067 if (ti->type != UDP_TUNNEL_TYPE_VXLAN) 5068 return; 5069 5070 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter)) 5071 return; 5072 5073 cmd_work = be_alloc_work(adapter, func); 5074 if (cmd_work) { 5075 cmd_work->info.vxlan_port = ti->port; 5076 queue_work(be_wq, &cmd_work->work); 5077 } 5078 } 5079 5080 static void be_del_vxlan_port(struct net_device *netdev, 5081 struct udp_tunnel_info *ti) 5082 { 5083 be_cfg_vxlan_port(netdev, ti, be_work_del_vxlan_port); 5084 } 5085 5086 static void be_add_vxlan_port(struct net_device *netdev, 5087 struct udp_tunnel_info *ti) 5088 { 5089 be_cfg_vxlan_port(netdev, ti, be_work_add_vxlan_port); 5090 } 5091 5092 static netdev_features_t be_features_check(struct sk_buff *skb, 5093 struct net_device *dev, 5094 netdev_features_t features) 5095 { 5096 struct be_adapter *adapter = netdev_priv(dev); 5097 u8 l4_hdr = 0; 5098 5099 if (skb_is_gso(skb)) { 5100 /* IPv6 TSO requests with extension hdrs are a problem 5101 * to Lancer and BE3 HW. Disable TSO6 feature. 5102 */ 5103 if (!skyhawk_chip(adapter) && is_ipv6_ext_hdr(skb)) 5104 features &= ~NETIF_F_TSO6; 5105 5106 /* Lancer cannot handle the packet with MSS less than 256. 5107 * Disable the GSO support in such cases 5108 */ 5109 if (lancer_chip(adapter) && skb_shinfo(skb)->gso_size < 256) 5110 features &= ~NETIF_F_GSO_MASK; 5111 } 5112 5113 /* The code below restricts offload features for some tunneled and 5114 * Q-in-Q packets. 5115 * Offload features for normal (non tunnel) packets are unchanged. 5116 */ 5117 features = vlan_features_check(skb, features); 5118 if (!skb->encapsulation || 5119 !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)) 5120 return features; 5121 5122 /* It's an encapsulated packet and VxLAN offloads are enabled. We 5123 * should disable tunnel offload features if it's not a VxLAN packet, 5124 * as tunnel offloads have been enabled only for VxLAN. This is done to 5125 * allow other tunneled traffic like GRE work fine while VxLAN 5126 * offloads are configured in Skyhawk-R. 5127 */ 5128 switch (vlan_get_protocol(skb)) { 5129 case htons(ETH_P_IP): 5130 l4_hdr = ip_hdr(skb)->protocol; 5131 break; 5132 case htons(ETH_P_IPV6): 5133 l4_hdr = ipv6_hdr(skb)->nexthdr; 5134 break; 5135 default: 5136 return features; 5137 } 5138 5139 if (l4_hdr != IPPROTO_UDP || 5140 skb->inner_protocol_type != ENCAP_TYPE_ETHER || 5141 skb->inner_protocol != htons(ETH_P_TEB) || 5142 skb_inner_mac_header(skb) - skb_transport_header(skb) != 5143 sizeof(struct udphdr) + sizeof(struct vxlanhdr) || 5144 !adapter->vxlan_port || 5145 udp_hdr(skb)->dest != adapter->vxlan_port) 5146 return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 5147 5148 return features; 5149 } 5150 5151 static int be_get_phys_port_id(struct net_device *dev, 5152 struct netdev_phys_item_id *ppid) 5153 { 5154 int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1; 5155 struct be_adapter *adapter = netdev_priv(dev); 5156 u8 *id; 5157 5158 if (MAX_PHYS_ITEM_ID_LEN < id_len) 5159 return -ENOSPC; 5160 5161 ppid->id[0] = adapter->hba_port_num + 1; 5162 id = &ppid->id[1]; 5163 for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0; 5164 i--, id += CNTL_SERIAL_NUM_WORD_SZ) 5165 memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ); 5166 5167 ppid->id_len = id_len; 5168 5169 return 0; 5170 } 5171 5172 static void be_set_rx_mode(struct net_device *dev) 5173 { 5174 struct be_adapter *adapter = netdev_priv(dev); 5175 struct be_cmd_work *work; 5176 5177 work = be_alloc_work(adapter, be_work_set_rx_mode); 5178 if (work) 5179 queue_work(be_wq, &work->work); 5180 } 5181 5182 static const struct net_device_ops be_netdev_ops = { 5183 .ndo_open = be_open, 5184 .ndo_stop = be_close, 5185 .ndo_start_xmit = be_xmit, 5186 .ndo_set_rx_mode = be_set_rx_mode, 5187 .ndo_set_mac_address = be_mac_addr_set, 5188 .ndo_get_stats64 = be_get_stats64, 5189 .ndo_validate_addr = eth_validate_addr, 5190 .ndo_vlan_rx_add_vid = be_vlan_add_vid, 5191 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid, 5192 .ndo_set_vf_mac = be_set_vf_mac, 5193 .ndo_set_vf_vlan = be_set_vf_vlan, 5194 .ndo_set_vf_rate = be_set_vf_tx_rate, 5195 .ndo_get_vf_config = be_get_vf_config, 5196 .ndo_set_vf_link_state = be_set_vf_link_state, 5197 .ndo_set_vf_spoofchk = be_set_vf_spoofchk, 5198 #ifdef CONFIG_NET_POLL_CONTROLLER 5199 .ndo_poll_controller = be_netpoll, 5200 #endif 5201 .ndo_bridge_setlink = be_ndo_bridge_setlink, 5202 .ndo_bridge_getlink = be_ndo_bridge_getlink, 5203 .ndo_udp_tunnel_add = be_add_vxlan_port, 5204 .ndo_udp_tunnel_del = be_del_vxlan_port, 5205 .ndo_features_check = be_features_check, 5206 .ndo_get_phys_port_id = be_get_phys_port_id, 5207 }; 5208 5209 static void be_netdev_init(struct net_device *netdev) 5210 { 5211 struct be_adapter *adapter = netdev_priv(netdev); 5212 5213 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 | 5214 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM | 5215 NETIF_F_HW_VLAN_CTAG_TX; 5216 if ((be_if_cap_flags(adapter) & BE_IF_FLAGS_RSS)) 5217 netdev->hw_features |= NETIF_F_RXHASH; 5218 5219 netdev->features |= netdev->hw_features | 5220 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER; 5221 5222 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 | 5223 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 5224 5225 netdev->priv_flags |= IFF_UNICAST_FLT; 5226 5227 netdev->flags |= IFF_MULTICAST; 5228 5229 netif_set_gso_max_size(netdev, BE_MAX_GSO_SIZE - ETH_HLEN); 5230 5231 netdev->netdev_ops = &be_netdev_ops; 5232 5233 netdev->ethtool_ops = &be_ethtool_ops; 5234 5235 /* MTU range: 256 - 9000 */ 5236 netdev->min_mtu = BE_MIN_MTU; 5237 netdev->max_mtu = BE_MAX_MTU; 5238 } 5239 5240 static void be_cleanup(struct be_adapter *adapter) 5241 { 5242 struct net_device *netdev = adapter->netdev; 5243 5244 rtnl_lock(); 5245 netif_device_detach(netdev); 5246 if (netif_running(netdev)) 5247 be_close(netdev); 5248 rtnl_unlock(); 5249 5250 be_clear(adapter); 5251 } 5252 5253 static int be_resume(struct be_adapter *adapter) 5254 { 5255 struct net_device *netdev = adapter->netdev; 5256 int status; 5257 5258 status = be_setup(adapter); 5259 if (status) 5260 return status; 5261 5262 rtnl_lock(); 5263 if (netif_running(netdev)) 5264 status = be_open(netdev); 5265 rtnl_unlock(); 5266 5267 if (status) 5268 return status; 5269 5270 netif_device_attach(netdev); 5271 5272 return 0; 5273 } 5274 5275 static void be_soft_reset(struct be_adapter *adapter) 5276 { 5277 u32 val; 5278 5279 dev_info(&adapter->pdev->dev, "Initiating chip soft reset\n"); 5280 val = ioread32(adapter->pcicfg + SLIPORT_SOFTRESET_OFFSET); 5281 val |= SLIPORT_SOFTRESET_SR_MASK; 5282 iowrite32(val, adapter->pcicfg + SLIPORT_SOFTRESET_OFFSET); 5283 } 5284 5285 static bool be_err_is_recoverable(struct be_adapter *adapter) 5286 { 5287 struct be_error_recovery *err_rec = &adapter->error_recovery; 5288 unsigned long initial_idle_time = 5289 msecs_to_jiffies(ERR_RECOVERY_IDLE_TIME); 5290 unsigned long recovery_interval = 5291 msecs_to_jiffies(ERR_RECOVERY_INTERVAL); 5292 u16 ue_err_code; 5293 u32 val; 5294 5295 val = be_POST_stage_get(adapter); 5296 if ((val & POST_STAGE_RECOVERABLE_ERR) != POST_STAGE_RECOVERABLE_ERR) 5297 return false; 5298 ue_err_code = val & POST_ERR_RECOVERY_CODE_MASK; 5299 if (ue_err_code == 0) 5300 return false; 5301 5302 dev_err(&adapter->pdev->dev, "Recoverable HW error code: 0x%x\n", 5303 ue_err_code); 5304 5305 if (time_before_eq(jiffies - err_rec->probe_time, initial_idle_time)) { 5306 dev_err(&adapter->pdev->dev, 5307 "Cannot recover within %lu sec from driver load\n", 5308 jiffies_to_msecs(initial_idle_time) / MSEC_PER_SEC); 5309 return false; 5310 } 5311 5312 if (err_rec->last_recovery_time && time_before_eq( 5313 jiffies - err_rec->last_recovery_time, recovery_interval)) { 5314 dev_err(&adapter->pdev->dev, 5315 "Cannot recover within %lu sec from last recovery\n", 5316 jiffies_to_msecs(recovery_interval) / MSEC_PER_SEC); 5317 return false; 5318 } 5319 5320 if (ue_err_code == err_rec->last_err_code) { 5321 dev_err(&adapter->pdev->dev, 5322 "Cannot recover from a consecutive TPE error\n"); 5323 return false; 5324 } 5325 5326 err_rec->last_recovery_time = jiffies; 5327 err_rec->last_err_code = ue_err_code; 5328 return true; 5329 } 5330 5331 static int be_tpe_recover(struct be_adapter *adapter) 5332 { 5333 struct be_error_recovery *err_rec = &adapter->error_recovery; 5334 int status = -EAGAIN; 5335 u32 val; 5336 5337 switch (err_rec->recovery_state) { 5338 case ERR_RECOVERY_ST_NONE: 5339 err_rec->recovery_state = ERR_RECOVERY_ST_DETECT; 5340 err_rec->resched_delay = ERR_RECOVERY_UE_DETECT_DURATION; 5341 break; 5342 5343 case ERR_RECOVERY_ST_DETECT: 5344 val = be_POST_stage_get(adapter); 5345 if ((val & POST_STAGE_RECOVERABLE_ERR) != 5346 POST_STAGE_RECOVERABLE_ERR) { 5347 dev_err(&adapter->pdev->dev, 5348 "Unrecoverable HW error detected: 0x%x\n", val); 5349 status = -EINVAL; 5350 err_rec->resched_delay = 0; 5351 break; 5352 } 5353 5354 dev_err(&adapter->pdev->dev, "Recoverable HW error detected\n"); 5355 5356 /* Only PF0 initiates Chip Soft Reset. But PF0 must wait UE2SR 5357 * milliseconds before it checks for final error status in 5358 * SLIPORT_SEMAPHORE to determine if recovery criteria is met. 5359 * If it does, then PF0 initiates a Soft Reset. 5360 */ 5361 if (adapter->pf_num == 0) { 5362 err_rec->recovery_state = ERR_RECOVERY_ST_RESET; 5363 err_rec->resched_delay = err_rec->ue_to_reset_time - 5364 ERR_RECOVERY_UE_DETECT_DURATION; 5365 break; 5366 } 5367 5368 err_rec->recovery_state = ERR_RECOVERY_ST_PRE_POLL; 5369 err_rec->resched_delay = err_rec->ue_to_poll_time - 5370 ERR_RECOVERY_UE_DETECT_DURATION; 5371 break; 5372 5373 case ERR_RECOVERY_ST_RESET: 5374 if (!be_err_is_recoverable(adapter)) { 5375 dev_err(&adapter->pdev->dev, 5376 "Failed to meet recovery criteria\n"); 5377 status = -EIO; 5378 err_rec->resched_delay = 0; 5379 break; 5380 } 5381 be_soft_reset(adapter); 5382 err_rec->recovery_state = ERR_RECOVERY_ST_PRE_POLL; 5383 err_rec->resched_delay = err_rec->ue_to_poll_time - 5384 err_rec->ue_to_reset_time; 5385 break; 5386 5387 case ERR_RECOVERY_ST_PRE_POLL: 5388 err_rec->recovery_state = ERR_RECOVERY_ST_REINIT; 5389 err_rec->resched_delay = 0; 5390 status = 0; /* done */ 5391 break; 5392 5393 default: 5394 status = -EINVAL; 5395 err_rec->resched_delay = 0; 5396 break; 5397 } 5398 5399 return status; 5400 } 5401 5402 static int be_err_recover(struct be_adapter *adapter) 5403 { 5404 int status; 5405 5406 if (!lancer_chip(adapter)) { 5407 if (!adapter->error_recovery.recovery_supported || 5408 adapter->priv_flags & BE_DISABLE_TPE_RECOVERY) 5409 return -EIO; 5410 status = be_tpe_recover(adapter); 5411 if (status) 5412 goto err; 5413 } 5414 5415 /* Wait for adapter to reach quiescent state before 5416 * destroying queues 5417 */ 5418 status = be_fw_wait_ready(adapter); 5419 if (status) 5420 goto err; 5421 5422 adapter->flags |= BE_FLAGS_TRY_RECOVERY; 5423 5424 be_cleanup(adapter); 5425 5426 status = be_resume(adapter); 5427 if (status) 5428 goto err; 5429 5430 adapter->flags &= ~BE_FLAGS_TRY_RECOVERY; 5431 5432 err: 5433 return status; 5434 } 5435 5436 static void be_err_detection_task(struct work_struct *work) 5437 { 5438 struct be_error_recovery *err_rec = 5439 container_of(work, struct be_error_recovery, 5440 err_detection_work.work); 5441 struct be_adapter *adapter = 5442 container_of(err_rec, struct be_adapter, 5443 error_recovery); 5444 u32 resched_delay = ERR_RECOVERY_DETECTION_DELAY; 5445 struct device *dev = &adapter->pdev->dev; 5446 int recovery_status; 5447 5448 be_detect_error(adapter); 5449 if (!be_check_error(adapter, BE_ERROR_HW)) 5450 goto reschedule_task; 5451 5452 recovery_status = be_err_recover(adapter); 5453 if (!recovery_status) { 5454 err_rec->recovery_retries = 0; 5455 err_rec->recovery_state = ERR_RECOVERY_ST_NONE; 5456 dev_info(dev, "Adapter recovery successful\n"); 5457 goto reschedule_task; 5458 } else if (!lancer_chip(adapter) && err_rec->resched_delay) { 5459 /* BEx/SH recovery state machine */ 5460 if (adapter->pf_num == 0 && 5461 err_rec->recovery_state > ERR_RECOVERY_ST_DETECT) 5462 dev_err(&adapter->pdev->dev, 5463 "Adapter recovery in progress\n"); 5464 resched_delay = err_rec->resched_delay; 5465 goto reschedule_task; 5466 } else if (lancer_chip(adapter) && be_virtfn(adapter)) { 5467 /* For VFs, check if PF have allocated resources 5468 * every second. 5469 */ 5470 dev_err(dev, "Re-trying adapter recovery\n"); 5471 goto reschedule_task; 5472 } else if (lancer_chip(adapter) && err_rec->recovery_retries++ < 5473 ERR_RECOVERY_MAX_RETRY_COUNT) { 5474 /* In case of another error during recovery, it takes 30 sec 5475 * for adapter to come out of error. Retry error recovery after 5476 * this time interval. 5477 */ 5478 dev_err(&adapter->pdev->dev, "Re-trying adapter recovery\n"); 5479 resched_delay = ERR_RECOVERY_RETRY_DELAY; 5480 goto reschedule_task; 5481 } else { 5482 dev_err(dev, "Adapter recovery failed\n"); 5483 dev_err(dev, "Please reboot server to recover\n"); 5484 } 5485 5486 return; 5487 5488 reschedule_task: 5489 be_schedule_err_detection(adapter, resched_delay); 5490 } 5491 5492 static void be_log_sfp_info(struct be_adapter *adapter) 5493 { 5494 int status; 5495 5496 status = be_cmd_query_sfp_info(adapter); 5497 if (!status) { 5498 dev_err(&adapter->pdev->dev, 5499 "Port %c: %s Vendor: %s part no: %s", 5500 adapter->port_name, 5501 be_misconfig_evt_port_state[adapter->phy_state], 5502 adapter->phy.vendor_name, 5503 adapter->phy.vendor_pn); 5504 } 5505 adapter->flags &= ~BE_FLAGS_PHY_MISCONFIGURED; 5506 } 5507 5508 static void be_worker(struct work_struct *work) 5509 { 5510 struct be_adapter *adapter = 5511 container_of(work, struct be_adapter, work.work); 5512 struct be_rx_obj *rxo; 5513 int i; 5514 5515 if (be_physfn(adapter) && 5516 MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0) 5517 be_cmd_get_die_temperature(adapter); 5518 5519 /* when interrupts are not yet enabled, just reap any pending 5520 * mcc completions 5521 */ 5522 if (!netif_running(adapter->netdev)) { 5523 local_bh_disable(); 5524 be_process_mcc(adapter); 5525 local_bh_enable(); 5526 goto reschedule; 5527 } 5528 5529 if (!adapter->stats_cmd_sent) { 5530 if (lancer_chip(adapter)) 5531 lancer_cmd_get_pport_stats(adapter, 5532 &adapter->stats_cmd); 5533 else 5534 be_cmd_get_stats(adapter, &adapter->stats_cmd); 5535 } 5536 5537 for_all_rx_queues(adapter, rxo, i) { 5538 /* Replenish RX-queues starved due to memory 5539 * allocation failures. 5540 */ 5541 if (rxo->rx_post_starved) 5542 be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST); 5543 } 5544 5545 /* EQ-delay update for Skyhawk is done while notifying EQ */ 5546 if (!skyhawk_chip(adapter)) 5547 be_eqd_update(adapter, false); 5548 5549 if (adapter->flags & BE_FLAGS_PHY_MISCONFIGURED) 5550 be_log_sfp_info(adapter); 5551 5552 reschedule: 5553 adapter->work_counter++; 5554 queue_delayed_work(be_wq, &adapter->work, msecs_to_jiffies(1000)); 5555 } 5556 5557 static void be_unmap_pci_bars(struct be_adapter *adapter) 5558 { 5559 if (adapter->csr) 5560 pci_iounmap(adapter->pdev, adapter->csr); 5561 if (adapter->db) 5562 pci_iounmap(adapter->pdev, adapter->db); 5563 if (adapter->pcicfg && adapter->pcicfg_mapped) 5564 pci_iounmap(adapter->pdev, adapter->pcicfg); 5565 } 5566 5567 static int db_bar(struct be_adapter *adapter) 5568 { 5569 if (lancer_chip(adapter) || be_virtfn(adapter)) 5570 return 0; 5571 else 5572 return 4; 5573 } 5574 5575 static int be_roce_map_pci_bars(struct be_adapter *adapter) 5576 { 5577 if (skyhawk_chip(adapter)) { 5578 adapter->roce_db.size = 4096; 5579 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev, 5580 db_bar(adapter)); 5581 adapter->roce_db.total_size = pci_resource_len(adapter->pdev, 5582 db_bar(adapter)); 5583 } 5584 return 0; 5585 } 5586 5587 static int be_map_pci_bars(struct be_adapter *adapter) 5588 { 5589 struct pci_dev *pdev = adapter->pdev; 5590 u8 __iomem *addr; 5591 u32 sli_intf; 5592 5593 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf); 5594 adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >> 5595 SLI_INTF_FAMILY_SHIFT; 5596 adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0; 5597 5598 if (BEx_chip(adapter) && be_physfn(adapter)) { 5599 adapter->csr = pci_iomap(pdev, 2, 0); 5600 if (!adapter->csr) 5601 return -ENOMEM; 5602 } 5603 5604 addr = pci_iomap(pdev, db_bar(adapter), 0); 5605 if (!addr) 5606 goto pci_map_err; 5607 adapter->db = addr; 5608 5609 if (skyhawk_chip(adapter) || BEx_chip(adapter)) { 5610 if (be_physfn(adapter)) { 5611 /* PCICFG is the 2nd BAR in BE2 */ 5612 addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0); 5613 if (!addr) 5614 goto pci_map_err; 5615 adapter->pcicfg = addr; 5616 adapter->pcicfg_mapped = true; 5617 } else { 5618 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET; 5619 adapter->pcicfg_mapped = false; 5620 } 5621 } 5622 5623 be_roce_map_pci_bars(adapter); 5624 return 0; 5625 5626 pci_map_err: 5627 dev_err(&pdev->dev, "Error in mapping PCI BARs\n"); 5628 be_unmap_pci_bars(adapter); 5629 return -ENOMEM; 5630 } 5631 5632 static void be_drv_cleanup(struct be_adapter *adapter) 5633 { 5634 struct be_dma_mem *mem = &adapter->mbox_mem_alloced; 5635 struct device *dev = &adapter->pdev->dev; 5636 5637 if (mem->va) 5638 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5639 5640 mem = &adapter->rx_filter; 5641 if (mem->va) 5642 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5643 5644 mem = &adapter->stats_cmd; 5645 if (mem->va) 5646 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5647 } 5648 5649 /* Allocate and initialize various fields in be_adapter struct */ 5650 static int be_drv_init(struct be_adapter *adapter) 5651 { 5652 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced; 5653 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem; 5654 struct be_dma_mem *rx_filter = &adapter->rx_filter; 5655 struct be_dma_mem *stats_cmd = &adapter->stats_cmd; 5656 struct device *dev = &adapter->pdev->dev; 5657 int status = 0; 5658 5659 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16; 5660 mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size, 5661 &mbox_mem_alloc->dma, 5662 GFP_KERNEL); 5663 if (!mbox_mem_alloc->va) 5664 return -ENOMEM; 5665 5666 mbox_mem_align->size = sizeof(struct be_mcc_mailbox); 5667 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16); 5668 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16); 5669 5670 rx_filter->size = sizeof(struct be_cmd_req_rx_filter); 5671 rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size, 5672 &rx_filter->dma, GFP_KERNEL); 5673 if (!rx_filter->va) { 5674 status = -ENOMEM; 5675 goto free_mbox; 5676 } 5677 5678 if (lancer_chip(adapter)) 5679 stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats); 5680 else if (BE2_chip(adapter)) 5681 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0); 5682 else if (BE3_chip(adapter)) 5683 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1); 5684 else 5685 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2); 5686 stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size, 5687 &stats_cmd->dma, GFP_KERNEL); 5688 if (!stats_cmd->va) { 5689 status = -ENOMEM; 5690 goto free_rx_filter; 5691 } 5692 5693 mutex_init(&adapter->mbox_lock); 5694 mutex_init(&adapter->mcc_lock); 5695 mutex_init(&adapter->rx_filter_lock); 5696 spin_lock_init(&adapter->mcc_cq_lock); 5697 init_completion(&adapter->et_cmd_compl); 5698 5699 pci_save_state(adapter->pdev); 5700 5701 INIT_DELAYED_WORK(&adapter->work, be_worker); 5702 5703 adapter->error_recovery.recovery_state = ERR_RECOVERY_ST_NONE; 5704 adapter->error_recovery.resched_delay = 0; 5705 INIT_DELAYED_WORK(&adapter->error_recovery.err_detection_work, 5706 be_err_detection_task); 5707 5708 adapter->rx_fc = true; 5709 adapter->tx_fc = true; 5710 5711 /* Must be a power of 2 or else MODULO will BUG_ON */ 5712 adapter->be_get_temp_freq = 64; 5713 5714 INIT_LIST_HEAD(&adapter->vxlan_port_list); 5715 return 0; 5716 5717 free_rx_filter: 5718 dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma); 5719 free_mbox: 5720 dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va, 5721 mbox_mem_alloc->dma); 5722 return status; 5723 } 5724 5725 static void be_remove(struct pci_dev *pdev) 5726 { 5727 struct be_adapter *adapter = pci_get_drvdata(pdev); 5728 5729 if (!adapter) 5730 return; 5731 5732 be_roce_dev_remove(adapter); 5733 be_intr_set(adapter, false); 5734 5735 be_cancel_err_detection(adapter); 5736 5737 unregister_netdev(adapter->netdev); 5738 5739 be_clear(adapter); 5740 5741 if (!pci_vfs_assigned(adapter->pdev)) 5742 be_cmd_reset_function(adapter); 5743 5744 /* tell fw we're done with firing cmds */ 5745 be_cmd_fw_clean(adapter); 5746 5747 be_unmap_pci_bars(adapter); 5748 be_drv_cleanup(adapter); 5749 5750 pci_disable_pcie_error_reporting(pdev); 5751 5752 pci_release_regions(pdev); 5753 pci_disable_device(pdev); 5754 5755 free_netdev(adapter->netdev); 5756 } 5757 5758 static ssize_t be_hwmon_show_temp(struct device *dev, 5759 struct device_attribute *dev_attr, 5760 char *buf) 5761 { 5762 struct be_adapter *adapter = dev_get_drvdata(dev); 5763 5764 /* Unit: millidegree Celsius */ 5765 if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP) 5766 return -EIO; 5767 else 5768 return sprintf(buf, "%u\n", 5769 adapter->hwmon_info.be_on_die_temp * 1000); 5770 } 5771 5772 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, 5773 be_hwmon_show_temp, NULL, 1); 5774 5775 static struct attribute *be_hwmon_attrs[] = { 5776 &sensor_dev_attr_temp1_input.dev_attr.attr, 5777 NULL 5778 }; 5779 5780 ATTRIBUTE_GROUPS(be_hwmon); 5781 5782 static char *mc_name(struct be_adapter *adapter) 5783 { 5784 char *str = ""; /* default */ 5785 5786 switch (adapter->mc_type) { 5787 case UMC: 5788 str = "UMC"; 5789 break; 5790 case FLEX10: 5791 str = "FLEX10"; 5792 break; 5793 case vNIC1: 5794 str = "vNIC-1"; 5795 break; 5796 case nPAR: 5797 str = "nPAR"; 5798 break; 5799 case UFP: 5800 str = "UFP"; 5801 break; 5802 case vNIC2: 5803 str = "vNIC-2"; 5804 break; 5805 default: 5806 str = ""; 5807 } 5808 5809 return str; 5810 } 5811 5812 static inline char *func_name(struct be_adapter *adapter) 5813 { 5814 return be_physfn(adapter) ? "PF" : "VF"; 5815 } 5816 5817 static inline char *nic_name(struct pci_dev *pdev) 5818 { 5819 switch (pdev->device) { 5820 case OC_DEVICE_ID1: 5821 return OC_NAME; 5822 case OC_DEVICE_ID2: 5823 return OC_NAME_BE; 5824 case OC_DEVICE_ID3: 5825 case OC_DEVICE_ID4: 5826 return OC_NAME_LANCER; 5827 case BE_DEVICE_ID2: 5828 return BE3_NAME; 5829 case OC_DEVICE_ID5: 5830 case OC_DEVICE_ID6: 5831 return OC_NAME_SH; 5832 default: 5833 return BE_NAME; 5834 } 5835 } 5836 5837 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id) 5838 { 5839 struct be_adapter *adapter; 5840 struct net_device *netdev; 5841 int status = 0; 5842 5843 dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER); 5844 5845 status = pci_enable_device(pdev); 5846 if (status) 5847 goto do_none; 5848 5849 status = pci_request_regions(pdev, DRV_NAME); 5850 if (status) 5851 goto disable_dev; 5852 pci_set_master(pdev); 5853 5854 netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS); 5855 if (!netdev) { 5856 status = -ENOMEM; 5857 goto rel_reg; 5858 } 5859 adapter = netdev_priv(netdev); 5860 adapter->pdev = pdev; 5861 pci_set_drvdata(pdev, adapter); 5862 adapter->netdev = netdev; 5863 SET_NETDEV_DEV(netdev, &pdev->dev); 5864 5865 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 5866 if (!status) { 5867 netdev->features |= NETIF_F_HIGHDMA; 5868 } else { 5869 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 5870 if (status) { 5871 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n"); 5872 goto free_netdev; 5873 } 5874 } 5875 5876 status = pci_enable_pcie_error_reporting(pdev); 5877 if (!status) 5878 dev_info(&pdev->dev, "PCIe error reporting enabled\n"); 5879 5880 status = be_map_pci_bars(adapter); 5881 if (status) 5882 goto free_netdev; 5883 5884 status = be_drv_init(adapter); 5885 if (status) 5886 goto unmap_bars; 5887 5888 status = be_setup(adapter); 5889 if (status) 5890 goto drv_cleanup; 5891 5892 be_netdev_init(netdev); 5893 status = register_netdev(netdev); 5894 if (status != 0) 5895 goto unsetup; 5896 5897 be_roce_dev_add(adapter); 5898 5899 be_schedule_err_detection(adapter, ERR_DETECTION_DELAY); 5900 adapter->error_recovery.probe_time = jiffies; 5901 5902 /* On Die temperature not supported for VF. */ 5903 if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) { 5904 adapter->hwmon_info.hwmon_dev = 5905 devm_hwmon_device_register_with_groups(&pdev->dev, 5906 DRV_NAME, 5907 adapter, 5908 be_hwmon_groups); 5909 adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP; 5910 } 5911 5912 dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev), 5913 func_name(adapter), mc_name(adapter), adapter->port_name); 5914 5915 return 0; 5916 5917 unsetup: 5918 be_clear(adapter); 5919 drv_cleanup: 5920 be_drv_cleanup(adapter); 5921 unmap_bars: 5922 be_unmap_pci_bars(adapter); 5923 free_netdev: 5924 free_netdev(netdev); 5925 rel_reg: 5926 pci_release_regions(pdev); 5927 disable_dev: 5928 pci_disable_device(pdev); 5929 do_none: 5930 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev)); 5931 return status; 5932 } 5933 5934 static int be_suspend(struct pci_dev *pdev, pm_message_t state) 5935 { 5936 struct be_adapter *adapter = pci_get_drvdata(pdev); 5937 5938 be_intr_set(adapter, false); 5939 be_cancel_err_detection(adapter); 5940 5941 be_cleanup(adapter); 5942 5943 pci_save_state(pdev); 5944 pci_disable_device(pdev); 5945 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 5946 return 0; 5947 } 5948 5949 static int be_pci_resume(struct pci_dev *pdev) 5950 { 5951 struct be_adapter *adapter = pci_get_drvdata(pdev); 5952 int status = 0; 5953 5954 status = pci_enable_device(pdev); 5955 if (status) 5956 return status; 5957 5958 pci_restore_state(pdev); 5959 5960 status = be_resume(adapter); 5961 if (status) 5962 return status; 5963 5964 be_schedule_err_detection(adapter, ERR_DETECTION_DELAY); 5965 5966 return 0; 5967 } 5968 5969 /* 5970 * An FLR will stop BE from DMAing any data. 5971 */ 5972 static void be_shutdown(struct pci_dev *pdev) 5973 { 5974 struct be_adapter *adapter = pci_get_drvdata(pdev); 5975 5976 if (!adapter) 5977 return; 5978 5979 be_roce_dev_shutdown(adapter); 5980 cancel_delayed_work_sync(&adapter->work); 5981 be_cancel_err_detection(adapter); 5982 5983 netif_device_detach(adapter->netdev); 5984 5985 be_cmd_reset_function(adapter); 5986 5987 pci_disable_device(pdev); 5988 } 5989 5990 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev, 5991 pci_channel_state_t state) 5992 { 5993 struct be_adapter *adapter = pci_get_drvdata(pdev); 5994 5995 dev_err(&adapter->pdev->dev, "EEH error detected\n"); 5996 5997 be_roce_dev_remove(adapter); 5998 5999 if (!be_check_error(adapter, BE_ERROR_EEH)) { 6000 be_set_error(adapter, BE_ERROR_EEH); 6001 6002 be_cancel_err_detection(adapter); 6003 6004 be_cleanup(adapter); 6005 } 6006 6007 if (state == pci_channel_io_perm_failure) 6008 return PCI_ERS_RESULT_DISCONNECT; 6009 6010 pci_disable_device(pdev); 6011 6012 /* The error could cause the FW to trigger a flash debug dump. 6013 * Resetting the card while flash dump is in progress 6014 * can cause it not to recover; wait for it to finish. 6015 * Wait only for first function as it is needed only once per 6016 * adapter. 6017 */ 6018 if (pdev->devfn == 0) 6019 ssleep(30); 6020 6021 return PCI_ERS_RESULT_NEED_RESET; 6022 } 6023 6024 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev) 6025 { 6026 struct be_adapter *adapter = pci_get_drvdata(pdev); 6027 int status; 6028 6029 dev_info(&adapter->pdev->dev, "EEH reset\n"); 6030 6031 status = pci_enable_device(pdev); 6032 if (status) 6033 return PCI_ERS_RESULT_DISCONNECT; 6034 6035 pci_set_master(pdev); 6036 pci_restore_state(pdev); 6037 6038 /* Check if card is ok and fw is ready */ 6039 dev_info(&adapter->pdev->dev, 6040 "Waiting for FW to be ready after EEH reset\n"); 6041 status = be_fw_wait_ready(adapter); 6042 if (status) 6043 return PCI_ERS_RESULT_DISCONNECT; 6044 6045 pci_cleanup_aer_uncorrect_error_status(pdev); 6046 be_clear_error(adapter, BE_CLEAR_ALL); 6047 return PCI_ERS_RESULT_RECOVERED; 6048 } 6049 6050 static void be_eeh_resume(struct pci_dev *pdev) 6051 { 6052 int status = 0; 6053 struct be_adapter *adapter = pci_get_drvdata(pdev); 6054 6055 dev_info(&adapter->pdev->dev, "EEH resume\n"); 6056 6057 pci_save_state(pdev); 6058 6059 status = be_resume(adapter); 6060 if (status) 6061 goto err; 6062 6063 be_roce_dev_add(adapter); 6064 6065 be_schedule_err_detection(adapter, ERR_DETECTION_DELAY); 6066 return; 6067 err: 6068 dev_err(&adapter->pdev->dev, "EEH resume failed\n"); 6069 } 6070 6071 static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs) 6072 { 6073 struct be_adapter *adapter = pci_get_drvdata(pdev); 6074 struct be_resources vft_res = {0}; 6075 int status; 6076 6077 if (!num_vfs) 6078 be_vf_clear(adapter); 6079 6080 adapter->num_vfs = num_vfs; 6081 6082 if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) { 6083 dev_warn(&pdev->dev, 6084 "Cannot disable VFs while they are assigned\n"); 6085 return -EBUSY; 6086 } 6087 6088 /* When the HW is in SRIOV capable configuration, the PF-pool resources 6089 * are equally distributed across the max-number of VFs. The user may 6090 * request only a subset of the max-vfs to be enabled. 6091 * Based on num_vfs, redistribute the resources across num_vfs so that 6092 * each VF will have access to more number of resources. 6093 * This facility is not available in BE3 FW. 6094 * Also, this is done by FW in Lancer chip. 6095 */ 6096 if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) { 6097 be_calculate_vf_res(adapter, adapter->num_vfs, 6098 &vft_res); 6099 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 6100 adapter->num_vfs, &vft_res); 6101 if (status) 6102 dev_err(&pdev->dev, 6103 "Failed to optimize SR-IOV resources\n"); 6104 } 6105 6106 status = be_get_resources(adapter); 6107 if (status) 6108 return be_cmd_status(status); 6109 6110 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */ 6111 rtnl_lock(); 6112 status = be_update_queues(adapter); 6113 rtnl_unlock(); 6114 if (status) 6115 return be_cmd_status(status); 6116 6117 if (adapter->num_vfs) 6118 status = be_vf_setup(adapter); 6119 6120 if (!status) 6121 return adapter->num_vfs; 6122 6123 return 0; 6124 } 6125 6126 static const struct pci_error_handlers be_eeh_handlers = { 6127 .error_detected = be_eeh_err_detected, 6128 .slot_reset = be_eeh_reset, 6129 .resume = be_eeh_resume, 6130 }; 6131 6132 static struct pci_driver be_driver = { 6133 .name = DRV_NAME, 6134 .id_table = be_dev_ids, 6135 .probe = be_probe, 6136 .remove = be_remove, 6137 .suspend = be_suspend, 6138 .resume = be_pci_resume, 6139 .shutdown = be_shutdown, 6140 .sriov_configure = be_pci_sriov_configure, 6141 .err_handler = &be_eeh_handlers 6142 }; 6143 6144 static int __init be_init_module(void) 6145 { 6146 int status; 6147 6148 if (rx_frag_size != 8192 && rx_frag_size != 4096 && 6149 rx_frag_size != 2048) { 6150 printk(KERN_WARNING DRV_NAME 6151 " : Module param rx_frag_size must be 2048/4096/8192." 6152 " Using 2048\n"); 6153 rx_frag_size = 2048; 6154 } 6155 6156 if (num_vfs > 0) { 6157 pr_info(DRV_NAME " : Module param num_vfs is obsolete."); 6158 pr_info(DRV_NAME " : Use sysfs method to enable VFs\n"); 6159 } 6160 6161 be_wq = create_singlethread_workqueue("be_wq"); 6162 if (!be_wq) { 6163 pr_warn(DRV_NAME "workqueue creation failed\n"); 6164 return -1; 6165 } 6166 6167 be_err_recovery_workq = 6168 create_singlethread_workqueue("be_err_recover"); 6169 if (!be_err_recovery_workq) 6170 pr_warn(DRV_NAME "Could not create error recovery workqueue\n"); 6171 6172 status = pci_register_driver(&be_driver); 6173 if (status) { 6174 destroy_workqueue(be_wq); 6175 be_destroy_err_recovery_workq(); 6176 } 6177 return status; 6178 } 6179 module_init(be_init_module); 6180 6181 static void __exit be_exit_module(void) 6182 { 6183 pci_unregister_driver(&be_driver); 6184 6185 be_destroy_err_recovery_workq(); 6186 6187 if (be_wq) 6188 destroy_workqueue(be_wq); 6189 } 6190 module_exit(be_exit_module); 6191