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