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