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; 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-R ASICs have a bug wherein Packets that are 32 bytes or 1127 * less may cause a transmit stall on that port. So the work-around is 1128 * to pad short packets (<= 32 bytes) to a 36-byte length. 1129 */ 1130 if (unlikely(!BEx_chip(adapter) && skb->len <= 32)) { 1131 if (skb_put_padto(skb, 36)) 1132 return NULL; 1133 } 1134 1135 if (BEx_chip(adapter) || lancer_chip(adapter)) { 1136 skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params); 1137 if (!skb) 1138 return NULL; 1139 } 1140 1141 return skb; 1142 } 1143 1144 static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo) 1145 { 1146 struct be_queue_info *txq = &txo->q; 1147 struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr); 1148 1149 /* Mark the last request eventable if it hasn't been marked already */ 1150 if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT))) 1151 hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL); 1152 1153 /* compose a dummy wrb if there are odd set of wrbs to notify */ 1154 if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) { 1155 wrb_fill_dummy(queue_head_node(txq)); 1156 queue_head_inc(txq); 1157 atomic_inc(&txq->used); 1158 txo->pend_wrb_cnt++; 1159 hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK << 1160 TX_HDR_WRB_NUM_SHIFT); 1161 hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) << 1162 TX_HDR_WRB_NUM_SHIFT); 1163 } 1164 be_txq_notify(adapter, txo, txo->pend_wrb_cnt); 1165 txo->pend_wrb_cnt = 0; 1166 } 1167 1168 /* OS2BMC related */ 1169 1170 #define DHCP_CLIENT_PORT 68 1171 #define DHCP_SERVER_PORT 67 1172 #define NET_BIOS_PORT1 137 1173 #define NET_BIOS_PORT2 138 1174 #define DHCPV6_RAS_PORT 547 1175 1176 #define is_mc_allowed_on_bmc(adapter, eh) \ 1177 (!is_multicast_filt_enabled(adapter) && \ 1178 is_multicast_ether_addr(eh->h_dest) && \ 1179 !is_broadcast_ether_addr(eh->h_dest)) 1180 1181 #define is_bc_allowed_on_bmc(adapter, eh) \ 1182 (!is_broadcast_filt_enabled(adapter) && \ 1183 is_broadcast_ether_addr(eh->h_dest)) 1184 1185 #define is_arp_allowed_on_bmc(adapter, skb) \ 1186 (is_arp(skb) && is_arp_filt_enabled(adapter)) 1187 1188 #define is_broadcast_packet(eh, adapter) \ 1189 (is_multicast_ether_addr(eh->h_dest) && \ 1190 !compare_ether_addr(eh->h_dest, adapter->netdev->broadcast)) 1191 1192 #define is_arp(skb) (skb->protocol == htons(ETH_P_ARP)) 1193 1194 #define is_arp_filt_enabled(adapter) \ 1195 (adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP)) 1196 1197 #define is_dhcp_client_filt_enabled(adapter) \ 1198 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT) 1199 1200 #define is_dhcp_srvr_filt_enabled(adapter) \ 1201 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER) 1202 1203 #define is_nbios_filt_enabled(adapter) \ 1204 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS) 1205 1206 #define is_ipv6_na_filt_enabled(adapter) \ 1207 (adapter->bmc_filt_mask & \ 1208 BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER) 1209 1210 #define is_ipv6_ra_filt_enabled(adapter) \ 1211 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA) 1212 1213 #define is_ipv6_ras_filt_enabled(adapter) \ 1214 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS) 1215 1216 #define is_broadcast_filt_enabled(adapter) \ 1217 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST) 1218 1219 #define is_multicast_filt_enabled(adapter) \ 1220 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST) 1221 1222 static bool be_send_pkt_to_bmc(struct be_adapter *adapter, 1223 struct sk_buff **skb) 1224 { 1225 struct ethhdr *eh = (struct ethhdr *)(*skb)->data; 1226 bool os2bmc = false; 1227 1228 if (!be_is_os2bmc_enabled(adapter)) 1229 goto done; 1230 1231 if (!is_multicast_ether_addr(eh->h_dest)) 1232 goto done; 1233 1234 if (is_mc_allowed_on_bmc(adapter, eh) || 1235 is_bc_allowed_on_bmc(adapter, eh) || 1236 is_arp_allowed_on_bmc(adapter, (*skb))) { 1237 os2bmc = true; 1238 goto done; 1239 } 1240 1241 if ((*skb)->protocol == htons(ETH_P_IPV6)) { 1242 struct ipv6hdr *hdr = ipv6_hdr((*skb)); 1243 u8 nexthdr = hdr->nexthdr; 1244 1245 if (nexthdr == IPPROTO_ICMPV6) { 1246 struct icmp6hdr *icmp6 = icmp6_hdr((*skb)); 1247 1248 switch (icmp6->icmp6_type) { 1249 case NDISC_ROUTER_ADVERTISEMENT: 1250 os2bmc = is_ipv6_ra_filt_enabled(adapter); 1251 goto done; 1252 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1253 os2bmc = is_ipv6_na_filt_enabled(adapter); 1254 goto done; 1255 default: 1256 break; 1257 } 1258 } 1259 } 1260 1261 if (is_udp_pkt((*skb))) { 1262 struct udphdr *udp = udp_hdr((*skb)); 1263 1264 switch (ntohs(udp->dest)) { 1265 case DHCP_CLIENT_PORT: 1266 os2bmc = is_dhcp_client_filt_enabled(adapter); 1267 goto done; 1268 case DHCP_SERVER_PORT: 1269 os2bmc = is_dhcp_srvr_filt_enabled(adapter); 1270 goto done; 1271 case NET_BIOS_PORT1: 1272 case NET_BIOS_PORT2: 1273 os2bmc = is_nbios_filt_enabled(adapter); 1274 goto done; 1275 case DHCPV6_RAS_PORT: 1276 os2bmc = is_ipv6_ras_filt_enabled(adapter); 1277 goto done; 1278 default: 1279 break; 1280 } 1281 } 1282 done: 1283 /* For packets over a vlan, which are destined 1284 * to BMC, asic expects the vlan to be inline in the packet. 1285 */ 1286 if (os2bmc) 1287 *skb = be_insert_vlan_in_pkt(adapter, *skb, NULL); 1288 1289 return os2bmc; 1290 } 1291 1292 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev) 1293 { 1294 struct be_adapter *adapter = netdev_priv(netdev); 1295 u16 q_idx = skb_get_queue_mapping(skb); 1296 struct be_tx_obj *txo = &adapter->tx_obj[q_idx]; 1297 struct be_wrb_params wrb_params = { 0 }; 1298 bool flush = !skb->xmit_more; 1299 u16 wrb_cnt; 1300 1301 skb = be_xmit_workarounds(adapter, skb, &wrb_params); 1302 if (unlikely(!skb)) 1303 goto drop; 1304 1305 be_get_wrb_params_from_skb(adapter, skb, &wrb_params); 1306 1307 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params); 1308 if (unlikely(!wrb_cnt)) { 1309 dev_kfree_skb_any(skb); 1310 goto drop; 1311 } 1312 1313 /* if os2bmc is enabled and if the pkt is destined to bmc, 1314 * enqueue the pkt a 2nd time with mgmt bit set. 1315 */ 1316 if (be_send_pkt_to_bmc(adapter, &skb)) { 1317 BE_WRB_F_SET(wrb_params.features, OS2BMC, 1); 1318 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params); 1319 if (unlikely(!wrb_cnt)) 1320 goto drop; 1321 else 1322 skb_get(skb); 1323 } 1324 1325 if (be_is_txq_full(txo)) { 1326 netif_stop_subqueue(netdev, q_idx); 1327 tx_stats(txo)->tx_stops++; 1328 } 1329 1330 if (flush || __netif_subqueue_stopped(netdev, q_idx)) 1331 be_xmit_flush(adapter, txo); 1332 1333 return NETDEV_TX_OK; 1334 drop: 1335 tx_stats(txo)->tx_drv_drops++; 1336 /* Flush the already enqueued tx requests */ 1337 if (flush && txo->pend_wrb_cnt) 1338 be_xmit_flush(adapter, txo); 1339 1340 return NETDEV_TX_OK; 1341 } 1342 1343 static int be_change_mtu(struct net_device *netdev, int new_mtu) 1344 { 1345 struct be_adapter *adapter = netdev_priv(netdev); 1346 struct device *dev = &adapter->pdev->dev; 1347 1348 if (new_mtu < BE_MIN_MTU || new_mtu > BE_MAX_MTU) { 1349 dev_info(dev, "MTU must be between %d and %d bytes\n", 1350 BE_MIN_MTU, BE_MAX_MTU); 1351 return -EINVAL; 1352 } 1353 1354 dev_info(dev, "MTU changed from %d to %d bytes\n", 1355 netdev->mtu, new_mtu); 1356 netdev->mtu = new_mtu; 1357 return 0; 1358 } 1359 1360 static inline bool be_in_all_promisc(struct be_adapter *adapter) 1361 { 1362 return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) == 1363 BE_IF_FLAGS_ALL_PROMISCUOUS; 1364 } 1365 1366 static int be_set_vlan_promisc(struct be_adapter *adapter) 1367 { 1368 struct device *dev = &adapter->pdev->dev; 1369 int status; 1370 1371 if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) 1372 return 0; 1373 1374 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON); 1375 if (!status) { 1376 dev_info(dev, "Enabled VLAN promiscuous mode\n"); 1377 adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS; 1378 } else { 1379 dev_err(dev, "Failed to enable VLAN promiscuous mode\n"); 1380 } 1381 return status; 1382 } 1383 1384 static int be_clear_vlan_promisc(struct be_adapter *adapter) 1385 { 1386 struct device *dev = &adapter->pdev->dev; 1387 int status; 1388 1389 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF); 1390 if (!status) { 1391 dev_info(dev, "Disabling VLAN promiscuous mode\n"); 1392 adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS; 1393 } 1394 return status; 1395 } 1396 1397 /* 1398 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE. 1399 * If the user configures more, place BE in vlan promiscuous mode. 1400 */ 1401 static int be_vid_config(struct be_adapter *adapter) 1402 { 1403 struct device *dev = &adapter->pdev->dev; 1404 u16 vids[BE_NUM_VLANS_SUPPORTED]; 1405 u16 num = 0, i = 0; 1406 int status = 0; 1407 1408 /* No need to further configure vids if in promiscuous mode */ 1409 if (be_in_all_promisc(adapter)) 1410 return 0; 1411 1412 if (adapter->vlans_added > be_max_vlans(adapter)) 1413 return be_set_vlan_promisc(adapter); 1414 1415 /* Construct VLAN Table to give to HW */ 1416 for_each_set_bit(i, adapter->vids, VLAN_N_VID) 1417 vids[num++] = cpu_to_le16(i); 1418 1419 status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0); 1420 if (status) { 1421 dev_err(dev, "Setting HW VLAN filtering failed\n"); 1422 /* Set to VLAN promisc mode as setting VLAN filter failed */ 1423 if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS || 1424 addl_status(status) == 1425 MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES) 1426 return be_set_vlan_promisc(adapter); 1427 } else if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) { 1428 status = be_clear_vlan_promisc(adapter); 1429 } 1430 return status; 1431 } 1432 1433 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid) 1434 { 1435 struct be_adapter *adapter = netdev_priv(netdev); 1436 int status = 0; 1437 1438 /* Packets with VID 0 are always received by Lancer by default */ 1439 if (lancer_chip(adapter) && vid == 0) 1440 return status; 1441 1442 if (test_bit(vid, adapter->vids)) 1443 return status; 1444 1445 set_bit(vid, adapter->vids); 1446 adapter->vlans_added++; 1447 1448 status = be_vid_config(adapter); 1449 if (status) { 1450 adapter->vlans_added--; 1451 clear_bit(vid, adapter->vids); 1452 } 1453 1454 return status; 1455 } 1456 1457 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid) 1458 { 1459 struct be_adapter *adapter = netdev_priv(netdev); 1460 1461 /* Packets with VID 0 are always received by Lancer by default */ 1462 if (lancer_chip(adapter) && vid == 0) 1463 return 0; 1464 1465 clear_bit(vid, adapter->vids); 1466 adapter->vlans_added--; 1467 1468 return be_vid_config(adapter); 1469 } 1470 1471 static void be_clear_all_promisc(struct be_adapter *adapter) 1472 { 1473 be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, OFF); 1474 adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS; 1475 } 1476 1477 static void be_set_all_promisc(struct be_adapter *adapter) 1478 { 1479 be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON); 1480 adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS; 1481 } 1482 1483 static void be_set_mc_promisc(struct be_adapter *adapter) 1484 { 1485 int status; 1486 1487 if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS) 1488 return; 1489 1490 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON); 1491 if (!status) 1492 adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS; 1493 } 1494 1495 static void be_set_mc_list(struct be_adapter *adapter) 1496 { 1497 int status; 1498 1499 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON); 1500 if (!status) 1501 adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS; 1502 else 1503 be_set_mc_promisc(adapter); 1504 } 1505 1506 static void be_set_uc_list(struct be_adapter *adapter) 1507 { 1508 struct netdev_hw_addr *ha; 1509 int i = 1; /* First slot is claimed by the Primary MAC */ 1510 1511 for (; adapter->uc_macs > 0; adapter->uc_macs--, i++) 1512 be_cmd_pmac_del(adapter, adapter->if_handle, 1513 adapter->pmac_id[i], 0); 1514 1515 if (netdev_uc_count(adapter->netdev) > be_max_uc(adapter)) { 1516 be_set_all_promisc(adapter); 1517 return; 1518 } 1519 1520 netdev_for_each_uc_addr(ha, adapter->netdev) { 1521 adapter->uc_macs++; /* First slot is for Primary MAC */ 1522 be_cmd_pmac_add(adapter, (u8 *)ha->addr, adapter->if_handle, 1523 &adapter->pmac_id[adapter->uc_macs], 0); 1524 } 1525 } 1526 1527 static void be_clear_uc_list(struct be_adapter *adapter) 1528 { 1529 int i; 1530 1531 for (i = 1; i < (adapter->uc_macs + 1); i++) 1532 be_cmd_pmac_del(adapter, adapter->if_handle, 1533 adapter->pmac_id[i], 0); 1534 adapter->uc_macs = 0; 1535 } 1536 1537 static void be_set_rx_mode(struct net_device *netdev) 1538 { 1539 struct be_adapter *adapter = netdev_priv(netdev); 1540 1541 if (netdev->flags & IFF_PROMISC) { 1542 be_set_all_promisc(adapter); 1543 return; 1544 } 1545 1546 /* Interface was previously in promiscuous mode; disable it */ 1547 if (be_in_all_promisc(adapter)) { 1548 be_clear_all_promisc(adapter); 1549 if (adapter->vlans_added) 1550 be_vid_config(adapter); 1551 } 1552 1553 /* Enable multicast promisc if num configured exceeds what we support */ 1554 if (netdev->flags & IFF_ALLMULTI || 1555 netdev_mc_count(netdev) > be_max_mc(adapter)) { 1556 be_set_mc_promisc(adapter); 1557 return; 1558 } 1559 1560 if (netdev_uc_count(netdev) != adapter->uc_macs) 1561 be_set_uc_list(adapter); 1562 1563 be_set_mc_list(adapter); 1564 } 1565 1566 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1567 { 1568 struct be_adapter *adapter = netdev_priv(netdev); 1569 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1570 int status; 1571 1572 if (!sriov_enabled(adapter)) 1573 return -EPERM; 1574 1575 if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs) 1576 return -EINVAL; 1577 1578 /* Proceed further only if user provided MAC is different 1579 * from active MAC 1580 */ 1581 if (ether_addr_equal(mac, vf_cfg->mac_addr)) 1582 return 0; 1583 1584 if (BEx_chip(adapter)) { 1585 be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id, 1586 vf + 1); 1587 1588 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle, 1589 &vf_cfg->pmac_id, vf + 1); 1590 } else { 1591 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle, 1592 vf + 1); 1593 } 1594 1595 if (status) { 1596 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x", 1597 mac, vf, status); 1598 return be_cmd_status(status); 1599 } 1600 1601 ether_addr_copy(vf_cfg->mac_addr, mac); 1602 1603 return 0; 1604 } 1605 1606 static int be_get_vf_config(struct net_device *netdev, int vf, 1607 struct ifla_vf_info *vi) 1608 { 1609 struct be_adapter *adapter = netdev_priv(netdev); 1610 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1611 1612 if (!sriov_enabled(adapter)) 1613 return -EPERM; 1614 1615 if (vf >= adapter->num_vfs) 1616 return -EINVAL; 1617 1618 vi->vf = vf; 1619 vi->max_tx_rate = vf_cfg->tx_rate; 1620 vi->min_tx_rate = 0; 1621 vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK; 1622 vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT; 1623 memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN); 1624 vi->linkstate = adapter->vf_cfg[vf].plink_tracking; 1625 vi->spoofchk = adapter->vf_cfg[vf].spoofchk; 1626 1627 return 0; 1628 } 1629 1630 static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan) 1631 { 1632 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1633 u16 vids[BE_NUM_VLANS_SUPPORTED]; 1634 int vf_if_id = vf_cfg->if_handle; 1635 int status; 1636 1637 /* Enable Transparent VLAN Tagging */ 1638 status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0); 1639 if (status) 1640 return status; 1641 1642 /* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */ 1643 vids[0] = 0; 1644 status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1); 1645 if (!status) 1646 dev_info(&adapter->pdev->dev, 1647 "Cleared guest VLANs on VF%d", vf); 1648 1649 /* After TVT is enabled, disallow VFs to program VLAN filters */ 1650 if (vf_cfg->privileges & BE_PRIV_FILTMGMT) { 1651 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges & 1652 ~BE_PRIV_FILTMGMT, vf + 1); 1653 if (!status) 1654 vf_cfg->privileges &= ~BE_PRIV_FILTMGMT; 1655 } 1656 return 0; 1657 } 1658 1659 static int be_clear_vf_tvt(struct be_adapter *adapter, int vf) 1660 { 1661 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1662 struct device *dev = &adapter->pdev->dev; 1663 int status; 1664 1665 /* Reset Transparent VLAN Tagging. */ 1666 status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1, 1667 vf_cfg->if_handle, 0, 0); 1668 if (status) 1669 return status; 1670 1671 /* Allow VFs to program VLAN filtering */ 1672 if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) { 1673 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges | 1674 BE_PRIV_FILTMGMT, vf + 1); 1675 if (!status) { 1676 vf_cfg->privileges |= BE_PRIV_FILTMGMT; 1677 dev_info(dev, "VF%d: FILTMGMT priv enabled", vf); 1678 } 1679 } 1680 1681 dev_info(dev, 1682 "Disable/re-enable i/f in VM to clear Transparent VLAN tag"); 1683 return 0; 1684 } 1685 1686 static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos) 1687 { 1688 struct be_adapter *adapter = netdev_priv(netdev); 1689 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1690 int status; 1691 1692 if (!sriov_enabled(adapter)) 1693 return -EPERM; 1694 1695 if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7) 1696 return -EINVAL; 1697 1698 if (vlan || qos) { 1699 vlan |= qos << VLAN_PRIO_SHIFT; 1700 status = be_set_vf_tvt(adapter, vf, vlan); 1701 } else { 1702 status = be_clear_vf_tvt(adapter, vf); 1703 } 1704 1705 if (status) { 1706 dev_err(&adapter->pdev->dev, 1707 "VLAN %d config on VF %d failed : %#x\n", vlan, vf, 1708 status); 1709 return be_cmd_status(status); 1710 } 1711 1712 vf_cfg->vlan_tag = vlan; 1713 return 0; 1714 } 1715 1716 static int be_set_vf_tx_rate(struct net_device *netdev, int vf, 1717 int min_tx_rate, int max_tx_rate) 1718 { 1719 struct be_adapter *adapter = netdev_priv(netdev); 1720 struct device *dev = &adapter->pdev->dev; 1721 int percent_rate, status = 0; 1722 u16 link_speed = 0; 1723 u8 link_status; 1724 1725 if (!sriov_enabled(adapter)) 1726 return -EPERM; 1727 1728 if (vf >= adapter->num_vfs) 1729 return -EINVAL; 1730 1731 if (min_tx_rate) 1732 return -EINVAL; 1733 1734 if (!max_tx_rate) 1735 goto config_qos; 1736 1737 status = be_cmd_link_status_query(adapter, &link_speed, 1738 &link_status, 0); 1739 if (status) 1740 goto err; 1741 1742 if (!link_status) { 1743 dev_err(dev, "TX-rate setting not allowed when link is down\n"); 1744 status = -ENETDOWN; 1745 goto err; 1746 } 1747 1748 if (max_tx_rate < 100 || max_tx_rate > link_speed) { 1749 dev_err(dev, "TX-rate must be between 100 and %d Mbps\n", 1750 link_speed); 1751 status = -EINVAL; 1752 goto err; 1753 } 1754 1755 /* On Skyhawk the QOS setting must be done only as a % value */ 1756 percent_rate = link_speed / 100; 1757 if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) { 1758 dev_err(dev, "TX-rate must be a multiple of %d Mbps\n", 1759 percent_rate); 1760 status = -EINVAL; 1761 goto err; 1762 } 1763 1764 config_qos: 1765 status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1); 1766 if (status) 1767 goto err; 1768 1769 adapter->vf_cfg[vf].tx_rate = max_tx_rate; 1770 return 0; 1771 1772 err: 1773 dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n", 1774 max_tx_rate, vf); 1775 return be_cmd_status(status); 1776 } 1777 1778 static int be_set_vf_link_state(struct net_device *netdev, int vf, 1779 int link_state) 1780 { 1781 struct be_adapter *adapter = netdev_priv(netdev); 1782 int status; 1783 1784 if (!sriov_enabled(adapter)) 1785 return -EPERM; 1786 1787 if (vf >= adapter->num_vfs) 1788 return -EINVAL; 1789 1790 status = be_cmd_set_logical_link_config(adapter, link_state, vf+1); 1791 if (status) { 1792 dev_err(&adapter->pdev->dev, 1793 "Link state change on VF %d failed: %#x\n", vf, status); 1794 return be_cmd_status(status); 1795 } 1796 1797 adapter->vf_cfg[vf].plink_tracking = link_state; 1798 1799 return 0; 1800 } 1801 1802 static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable) 1803 { 1804 struct be_adapter *adapter = netdev_priv(netdev); 1805 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf]; 1806 u8 spoofchk; 1807 int status; 1808 1809 if (!sriov_enabled(adapter)) 1810 return -EPERM; 1811 1812 if (vf >= adapter->num_vfs) 1813 return -EINVAL; 1814 1815 if (BEx_chip(adapter)) 1816 return -EOPNOTSUPP; 1817 1818 if (enable == vf_cfg->spoofchk) 1819 return 0; 1820 1821 spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK; 1822 1823 status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle, 1824 0, spoofchk); 1825 if (status) { 1826 dev_err(&adapter->pdev->dev, 1827 "Spoofchk change on VF %d failed: %#x\n", vf, status); 1828 return be_cmd_status(status); 1829 } 1830 1831 vf_cfg->spoofchk = enable; 1832 return 0; 1833 } 1834 1835 static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts, 1836 ulong now) 1837 { 1838 aic->rx_pkts_prev = rx_pkts; 1839 aic->tx_reqs_prev = tx_pkts; 1840 aic->jiffies = now; 1841 } 1842 1843 static int be_get_new_eqd(struct be_eq_obj *eqo) 1844 { 1845 struct be_adapter *adapter = eqo->adapter; 1846 int eqd, start; 1847 struct be_aic_obj *aic; 1848 struct be_rx_obj *rxo; 1849 struct be_tx_obj *txo; 1850 u64 rx_pkts = 0, tx_pkts = 0; 1851 ulong now; 1852 u32 pps, delta; 1853 int i; 1854 1855 aic = &adapter->aic_obj[eqo->idx]; 1856 if (!aic->enable) { 1857 if (aic->jiffies) 1858 aic->jiffies = 0; 1859 eqd = aic->et_eqd; 1860 return eqd; 1861 } 1862 1863 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) { 1864 do { 1865 start = u64_stats_fetch_begin_irq(&rxo->stats.sync); 1866 rx_pkts += rxo->stats.rx_pkts; 1867 } while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start)); 1868 } 1869 1870 for_all_tx_queues_on_eq(adapter, eqo, txo, i) { 1871 do { 1872 start = u64_stats_fetch_begin_irq(&txo->stats.sync); 1873 tx_pkts += txo->stats.tx_reqs; 1874 } while (u64_stats_fetch_retry_irq(&txo->stats.sync, start)); 1875 } 1876 1877 /* Skip, if wrapped around or first calculation */ 1878 now = jiffies; 1879 if (!aic->jiffies || time_before(now, aic->jiffies) || 1880 rx_pkts < aic->rx_pkts_prev || 1881 tx_pkts < aic->tx_reqs_prev) { 1882 be_aic_update(aic, rx_pkts, tx_pkts, now); 1883 return aic->prev_eqd; 1884 } 1885 1886 delta = jiffies_to_msecs(now - aic->jiffies); 1887 if (delta == 0) 1888 return aic->prev_eqd; 1889 1890 pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) + 1891 (((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta); 1892 eqd = (pps / 15000) << 2; 1893 1894 if (eqd < 8) 1895 eqd = 0; 1896 eqd = min_t(u32, eqd, aic->max_eqd); 1897 eqd = max_t(u32, eqd, aic->min_eqd); 1898 1899 be_aic_update(aic, rx_pkts, tx_pkts, now); 1900 1901 return eqd; 1902 } 1903 1904 /* For Skyhawk-R only */ 1905 static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo) 1906 { 1907 struct be_adapter *adapter = eqo->adapter; 1908 struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx]; 1909 ulong now = jiffies; 1910 int eqd; 1911 u32 mult_enc; 1912 1913 if (!aic->enable) 1914 return 0; 1915 1916 if (time_before_eq(now, aic->jiffies) || 1917 jiffies_to_msecs(now - aic->jiffies) < 1) 1918 eqd = aic->prev_eqd; 1919 else 1920 eqd = be_get_new_eqd(eqo); 1921 1922 if (eqd > 100) 1923 mult_enc = R2I_DLY_ENC_1; 1924 else if (eqd > 60) 1925 mult_enc = R2I_DLY_ENC_2; 1926 else if (eqd > 20) 1927 mult_enc = R2I_DLY_ENC_3; 1928 else 1929 mult_enc = R2I_DLY_ENC_0; 1930 1931 aic->prev_eqd = eqd; 1932 1933 return mult_enc; 1934 } 1935 1936 void be_eqd_update(struct be_adapter *adapter, bool force_update) 1937 { 1938 struct be_set_eqd set_eqd[MAX_EVT_QS]; 1939 struct be_aic_obj *aic; 1940 struct be_eq_obj *eqo; 1941 int i, num = 0, eqd; 1942 1943 for_all_evt_queues(adapter, eqo, i) { 1944 aic = &adapter->aic_obj[eqo->idx]; 1945 eqd = be_get_new_eqd(eqo); 1946 if (force_update || eqd != aic->prev_eqd) { 1947 set_eqd[num].delay_multiplier = (eqd * 65)/100; 1948 set_eqd[num].eq_id = eqo->q.id; 1949 aic->prev_eqd = eqd; 1950 num++; 1951 } 1952 } 1953 1954 if (num) 1955 be_cmd_modify_eqd(adapter, set_eqd, num); 1956 } 1957 1958 static void be_rx_stats_update(struct be_rx_obj *rxo, 1959 struct be_rx_compl_info *rxcp) 1960 { 1961 struct be_rx_stats *stats = rx_stats(rxo); 1962 1963 u64_stats_update_begin(&stats->sync); 1964 stats->rx_compl++; 1965 stats->rx_bytes += rxcp->pkt_size; 1966 stats->rx_pkts++; 1967 if (rxcp->tunneled) 1968 stats->rx_vxlan_offload_pkts++; 1969 if (rxcp->pkt_type == BE_MULTICAST_PACKET) 1970 stats->rx_mcast_pkts++; 1971 if (rxcp->err) 1972 stats->rx_compl_err++; 1973 u64_stats_update_end(&stats->sync); 1974 } 1975 1976 static inline bool csum_passed(struct be_rx_compl_info *rxcp) 1977 { 1978 /* L4 checksum is not reliable for non TCP/UDP packets. 1979 * Also ignore ipcksm for ipv6 pkts 1980 */ 1981 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum && 1982 (rxcp->ip_csum || rxcp->ipv6) && !rxcp->err; 1983 } 1984 1985 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo) 1986 { 1987 struct be_adapter *adapter = rxo->adapter; 1988 struct be_rx_page_info *rx_page_info; 1989 struct be_queue_info *rxq = &rxo->q; 1990 u16 frag_idx = rxq->tail; 1991 1992 rx_page_info = &rxo->page_info_tbl[frag_idx]; 1993 BUG_ON(!rx_page_info->page); 1994 1995 if (rx_page_info->last_frag) { 1996 dma_unmap_page(&adapter->pdev->dev, 1997 dma_unmap_addr(rx_page_info, bus), 1998 adapter->big_page_size, DMA_FROM_DEVICE); 1999 rx_page_info->last_frag = false; 2000 } else { 2001 dma_sync_single_for_cpu(&adapter->pdev->dev, 2002 dma_unmap_addr(rx_page_info, bus), 2003 rx_frag_size, DMA_FROM_DEVICE); 2004 } 2005 2006 queue_tail_inc(rxq); 2007 atomic_dec(&rxq->used); 2008 return rx_page_info; 2009 } 2010 2011 /* Throwaway the data in the Rx completion */ 2012 static void be_rx_compl_discard(struct be_rx_obj *rxo, 2013 struct be_rx_compl_info *rxcp) 2014 { 2015 struct be_rx_page_info *page_info; 2016 u16 i, num_rcvd = rxcp->num_rcvd; 2017 2018 for (i = 0; i < num_rcvd; i++) { 2019 page_info = get_rx_page_info(rxo); 2020 put_page(page_info->page); 2021 memset(page_info, 0, sizeof(*page_info)); 2022 } 2023 } 2024 2025 /* 2026 * skb_fill_rx_data forms a complete skb for an ether frame 2027 * indicated by rxcp. 2028 */ 2029 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb, 2030 struct be_rx_compl_info *rxcp) 2031 { 2032 struct be_rx_page_info *page_info; 2033 u16 i, j; 2034 u16 hdr_len, curr_frag_len, remaining; 2035 u8 *start; 2036 2037 page_info = get_rx_page_info(rxo); 2038 start = page_address(page_info->page) + page_info->page_offset; 2039 prefetch(start); 2040 2041 /* Copy data in the first descriptor of this completion */ 2042 curr_frag_len = min(rxcp->pkt_size, rx_frag_size); 2043 2044 skb->len = curr_frag_len; 2045 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */ 2046 memcpy(skb->data, start, curr_frag_len); 2047 /* Complete packet has now been moved to data */ 2048 put_page(page_info->page); 2049 skb->data_len = 0; 2050 skb->tail += curr_frag_len; 2051 } else { 2052 hdr_len = ETH_HLEN; 2053 memcpy(skb->data, start, hdr_len); 2054 skb_shinfo(skb)->nr_frags = 1; 2055 skb_frag_set_page(skb, 0, page_info->page); 2056 skb_shinfo(skb)->frags[0].page_offset = 2057 page_info->page_offset + hdr_len; 2058 skb_frag_size_set(&skb_shinfo(skb)->frags[0], 2059 curr_frag_len - hdr_len); 2060 skb->data_len = curr_frag_len - hdr_len; 2061 skb->truesize += rx_frag_size; 2062 skb->tail += hdr_len; 2063 } 2064 page_info->page = NULL; 2065 2066 if (rxcp->pkt_size <= rx_frag_size) { 2067 BUG_ON(rxcp->num_rcvd != 1); 2068 return; 2069 } 2070 2071 /* More frags present for this completion */ 2072 remaining = rxcp->pkt_size - curr_frag_len; 2073 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) { 2074 page_info = get_rx_page_info(rxo); 2075 curr_frag_len = min(remaining, rx_frag_size); 2076 2077 /* Coalesce all frags from the same physical page in one slot */ 2078 if (page_info->page_offset == 0) { 2079 /* Fresh page */ 2080 j++; 2081 skb_frag_set_page(skb, j, page_info->page); 2082 skb_shinfo(skb)->frags[j].page_offset = 2083 page_info->page_offset; 2084 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0); 2085 skb_shinfo(skb)->nr_frags++; 2086 } else { 2087 put_page(page_info->page); 2088 } 2089 2090 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len); 2091 skb->len += curr_frag_len; 2092 skb->data_len += curr_frag_len; 2093 skb->truesize += rx_frag_size; 2094 remaining -= curr_frag_len; 2095 page_info->page = NULL; 2096 } 2097 BUG_ON(j > MAX_SKB_FRAGS); 2098 } 2099 2100 /* Process the RX completion indicated by rxcp when GRO is disabled */ 2101 static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi, 2102 struct be_rx_compl_info *rxcp) 2103 { 2104 struct be_adapter *adapter = rxo->adapter; 2105 struct net_device *netdev = adapter->netdev; 2106 struct sk_buff *skb; 2107 2108 skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE); 2109 if (unlikely(!skb)) { 2110 rx_stats(rxo)->rx_drops_no_skbs++; 2111 be_rx_compl_discard(rxo, rxcp); 2112 return; 2113 } 2114 2115 skb_fill_rx_data(rxo, skb, rxcp); 2116 2117 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp))) 2118 skb->ip_summed = CHECKSUM_UNNECESSARY; 2119 else 2120 skb_checksum_none_assert(skb); 2121 2122 skb->protocol = eth_type_trans(skb, netdev); 2123 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]); 2124 if (netdev->features & NETIF_F_RXHASH) 2125 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3); 2126 2127 skb->csum_level = rxcp->tunneled; 2128 skb_mark_napi_id(skb, napi); 2129 2130 if (rxcp->vlanf) 2131 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag); 2132 2133 netif_receive_skb(skb); 2134 } 2135 2136 /* Process the RX completion indicated by rxcp when GRO is enabled */ 2137 static void be_rx_compl_process_gro(struct be_rx_obj *rxo, 2138 struct napi_struct *napi, 2139 struct be_rx_compl_info *rxcp) 2140 { 2141 struct be_adapter *adapter = rxo->adapter; 2142 struct be_rx_page_info *page_info; 2143 struct sk_buff *skb = NULL; 2144 u16 remaining, curr_frag_len; 2145 u16 i, j; 2146 2147 skb = napi_get_frags(napi); 2148 if (!skb) { 2149 be_rx_compl_discard(rxo, rxcp); 2150 return; 2151 } 2152 2153 remaining = rxcp->pkt_size; 2154 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) { 2155 page_info = get_rx_page_info(rxo); 2156 2157 curr_frag_len = min(remaining, rx_frag_size); 2158 2159 /* Coalesce all frags from the same physical page in one slot */ 2160 if (i == 0 || page_info->page_offset == 0) { 2161 /* First frag or Fresh page */ 2162 j++; 2163 skb_frag_set_page(skb, j, page_info->page); 2164 skb_shinfo(skb)->frags[j].page_offset = 2165 page_info->page_offset; 2166 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0); 2167 } else { 2168 put_page(page_info->page); 2169 } 2170 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len); 2171 skb->truesize += rx_frag_size; 2172 remaining -= curr_frag_len; 2173 memset(page_info, 0, sizeof(*page_info)); 2174 } 2175 BUG_ON(j > MAX_SKB_FRAGS); 2176 2177 skb_shinfo(skb)->nr_frags = j + 1; 2178 skb->len = rxcp->pkt_size; 2179 skb->data_len = rxcp->pkt_size; 2180 skb->ip_summed = CHECKSUM_UNNECESSARY; 2181 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]); 2182 if (adapter->netdev->features & NETIF_F_RXHASH) 2183 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3); 2184 2185 skb->csum_level = rxcp->tunneled; 2186 skb_mark_napi_id(skb, napi); 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 napi_hash_add(&eqo->napi); 2634 } 2635 return 0; 2636 } 2637 2638 static void be_mcc_queues_destroy(struct be_adapter *adapter) 2639 { 2640 struct be_queue_info *q; 2641 2642 q = &adapter->mcc_obj.q; 2643 if (q->created) 2644 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ); 2645 be_queue_free(adapter, q); 2646 2647 q = &adapter->mcc_obj.cq; 2648 if (q->created) 2649 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2650 be_queue_free(adapter, q); 2651 } 2652 2653 /* Must be called only after TX qs are created as MCC shares TX EQ */ 2654 static int be_mcc_queues_create(struct be_adapter *adapter) 2655 { 2656 struct be_queue_info *q, *cq; 2657 2658 cq = &adapter->mcc_obj.cq; 2659 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN, 2660 sizeof(struct be_mcc_compl))) 2661 goto err; 2662 2663 /* Use the default EQ for MCC completions */ 2664 if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0)) 2665 goto mcc_cq_free; 2666 2667 q = &adapter->mcc_obj.q; 2668 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb))) 2669 goto mcc_cq_destroy; 2670 2671 if (be_cmd_mccq_create(adapter, q, cq)) 2672 goto mcc_q_free; 2673 2674 return 0; 2675 2676 mcc_q_free: 2677 be_queue_free(adapter, q); 2678 mcc_cq_destroy: 2679 be_cmd_q_destroy(adapter, cq, QTYPE_CQ); 2680 mcc_cq_free: 2681 be_queue_free(adapter, cq); 2682 err: 2683 return -1; 2684 } 2685 2686 static void be_tx_queues_destroy(struct be_adapter *adapter) 2687 { 2688 struct be_queue_info *q; 2689 struct be_tx_obj *txo; 2690 u8 i; 2691 2692 for_all_tx_queues(adapter, txo, i) { 2693 q = &txo->q; 2694 if (q->created) 2695 be_cmd_q_destroy(adapter, q, QTYPE_TXQ); 2696 be_queue_free(adapter, q); 2697 2698 q = &txo->cq; 2699 if (q->created) 2700 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2701 be_queue_free(adapter, q); 2702 } 2703 } 2704 2705 static int be_tx_qs_create(struct be_adapter *adapter) 2706 { 2707 struct be_queue_info *cq; 2708 struct be_tx_obj *txo; 2709 struct be_eq_obj *eqo; 2710 int status, i; 2711 2712 adapter->num_tx_qs = min(adapter->num_evt_qs, be_max_txqs(adapter)); 2713 2714 for_all_tx_queues(adapter, txo, i) { 2715 cq = &txo->cq; 2716 status = be_queue_alloc(adapter, cq, TX_CQ_LEN, 2717 sizeof(struct be_eth_tx_compl)); 2718 if (status) 2719 return status; 2720 2721 u64_stats_init(&txo->stats.sync); 2722 u64_stats_init(&txo->stats.sync_compl); 2723 2724 /* If num_evt_qs is less than num_tx_qs, then more than 2725 * one txq share an eq 2726 */ 2727 eqo = &adapter->eq_obj[i % adapter->num_evt_qs]; 2728 status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3); 2729 if (status) 2730 return status; 2731 2732 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN, 2733 sizeof(struct be_eth_wrb)); 2734 if (status) 2735 return status; 2736 2737 status = be_cmd_txq_create(adapter, txo); 2738 if (status) 2739 return status; 2740 2741 netif_set_xps_queue(adapter->netdev, eqo->affinity_mask, 2742 eqo->idx); 2743 } 2744 2745 dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n", 2746 adapter->num_tx_qs); 2747 return 0; 2748 } 2749 2750 static void be_rx_cqs_destroy(struct be_adapter *adapter) 2751 { 2752 struct be_queue_info *q; 2753 struct be_rx_obj *rxo; 2754 int i; 2755 2756 for_all_rx_queues(adapter, rxo, i) { 2757 q = &rxo->cq; 2758 if (q->created) 2759 be_cmd_q_destroy(adapter, q, QTYPE_CQ); 2760 be_queue_free(adapter, q); 2761 } 2762 } 2763 2764 static int be_rx_cqs_create(struct be_adapter *adapter) 2765 { 2766 struct be_queue_info *eq, *cq; 2767 struct be_rx_obj *rxo; 2768 int rc, i; 2769 2770 /* We can create as many RSS rings as there are EQs. */ 2771 adapter->num_rss_qs = adapter->num_evt_qs; 2772 2773 /* We'll use RSS only if atleast 2 RSS rings are supported. */ 2774 if (adapter->num_rss_qs <= 1) 2775 adapter->num_rss_qs = 0; 2776 2777 adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq; 2778 2779 /* When the interface is not capable of RSS rings (and there is no 2780 * need to create a default RXQ) we'll still need one RXQ 2781 */ 2782 if (adapter->num_rx_qs == 0) 2783 adapter->num_rx_qs = 1; 2784 2785 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE; 2786 for_all_rx_queues(adapter, rxo, i) { 2787 rxo->adapter = adapter; 2788 cq = &rxo->cq; 2789 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN, 2790 sizeof(struct be_eth_rx_compl)); 2791 if (rc) 2792 return rc; 2793 2794 u64_stats_init(&rxo->stats.sync); 2795 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q; 2796 rc = be_cmd_cq_create(adapter, cq, eq, false, 3); 2797 if (rc) 2798 return rc; 2799 } 2800 2801 dev_info(&adapter->pdev->dev, 2802 "created %d RX queue(s)\n", adapter->num_rx_qs); 2803 return 0; 2804 } 2805 2806 static irqreturn_t be_intx(int irq, void *dev) 2807 { 2808 struct be_eq_obj *eqo = dev; 2809 struct be_adapter *adapter = eqo->adapter; 2810 int num_evts = 0; 2811 2812 /* IRQ is not expected when NAPI is scheduled as the EQ 2813 * will not be armed. 2814 * But, this can happen on Lancer INTx where it takes 2815 * a while to de-assert INTx or in BE2 where occasionaly 2816 * an interrupt may be raised even when EQ is unarmed. 2817 * If NAPI is already scheduled, then counting & notifying 2818 * events will orphan them. 2819 */ 2820 if (napi_schedule_prep(&eqo->napi)) { 2821 num_evts = events_get(eqo); 2822 __napi_schedule(&eqo->napi); 2823 if (num_evts) 2824 eqo->spurious_intr = 0; 2825 } 2826 be_eq_notify(adapter, eqo->q.id, false, true, num_evts, 0); 2827 2828 /* Return IRQ_HANDLED only for the the first spurious intr 2829 * after a valid intr to stop the kernel from branding 2830 * this irq as a bad one! 2831 */ 2832 if (num_evts || eqo->spurious_intr++ == 0) 2833 return IRQ_HANDLED; 2834 else 2835 return IRQ_NONE; 2836 } 2837 2838 static irqreturn_t be_msix(int irq, void *dev) 2839 { 2840 struct be_eq_obj *eqo = dev; 2841 2842 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0); 2843 napi_schedule(&eqo->napi); 2844 return IRQ_HANDLED; 2845 } 2846 2847 static inline bool do_gro(struct be_rx_compl_info *rxcp) 2848 { 2849 return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false; 2850 } 2851 2852 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi, 2853 int budget, int polling) 2854 { 2855 struct be_adapter *adapter = rxo->adapter; 2856 struct be_queue_info *rx_cq = &rxo->cq; 2857 struct be_rx_compl_info *rxcp; 2858 u32 work_done; 2859 u32 frags_consumed = 0; 2860 2861 for (work_done = 0; work_done < budget; work_done++) { 2862 rxcp = be_rx_compl_get(rxo); 2863 if (!rxcp) 2864 break; 2865 2866 /* Is it a flush compl that has no data */ 2867 if (unlikely(rxcp->num_rcvd == 0)) 2868 goto loop_continue; 2869 2870 /* Discard compl with partial DMA Lancer B0 */ 2871 if (unlikely(!rxcp->pkt_size)) { 2872 be_rx_compl_discard(rxo, rxcp); 2873 goto loop_continue; 2874 } 2875 2876 /* On BE drop pkts that arrive due to imperfect filtering in 2877 * promiscuous mode on some skews 2878 */ 2879 if (unlikely(rxcp->port != adapter->port_num && 2880 !lancer_chip(adapter))) { 2881 be_rx_compl_discard(rxo, rxcp); 2882 goto loop_continue; 2883 } 2884 2885 /* Don't do gro when we're busy_polling */ 2886 if (do_gro(rxcp) && polling != BUSY_POLLING) 2887 be_rx_compl_process_gro(rxo, napi, rxcp); 2888 else 2889 be_rx_compl_process(rxo, napi, rxcp); 2890 2891 loop_continue: 2892 frags_consumed += rxcp->num_rcvd; 2893 be_rx_stats_update(rxo, rxcp); 2894 } 2895 2896 if (work_done) { 2897 be_cq_notify(adapter, rx_cq->id, true, work_done); 2898 2899 /* When an rx-obj gets into post_starved state, just 2900 * let be_worker do the posting. 2901 */ 2902 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM && 2903 !rxo->rx_post_starved) 2904 be_post_rx_frags(rxo, GFP_ATOMIC, 2905 max_t(u32, MAX_RX_POST, 2906 frags_consumed)); 2907 } 2908 2909 return work_done; 2910 } 2911 2912 static inline void be_update_tx_err(struct be_tx_obj *txo, u8 status) 2913 { 2914 switch (status) { 2915 case BE_TX_COMP_HDR_PARSE_ERR: 2916 tx_stats(txo)->tx_hdr_parse_err++; 2917 break; 2918 case BE_TX_COMP_NDMA_ERR: 2919 tx_stats(txo)->tx_dma_err++; 2920 break; 2921 case BE_TX_COMP_ACL_ERR: 2922 tx_stats(txo)->tx_spoof_check_err++; 2923 break; 2924 } 2925 } 2926 2927 static inline void lancer_update_tx_err(struct be_tx_obj *txo, u8 status) 2928 { 2929 switch (status) { 2930 case LANCER_TX_COMP_LSO_ERR: 2931 tx_stats(txo)->tx_tso_err++; 2932 break; 2933 case LANCER_TX_COMP_HSW_DROP_MAC_ERR: 2934 case LANCER_TX_COMP_HSW_DROP_VLAN_ERR: 2935 tx_stats(txo)->tx_spoof_check_err++; 2936 break; 2937 case LANCER_TX_COMP_QINQ_ERR: 2938 tx_stats(txo)->tx_qinq_err++; 2939 break; 2940 case LANCER_TX_COMP_PARITY_ERR: 2941 tx_stats(txo)->tx_internal_parity_err++; 2942 break; 2943 case LANCER_TX_COMP_DMA_ERR: 2944 tx_stats(txo)->tx_dma_err++; 2945 break; 2946 } 2947 } 2948 2949 static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo, 2950 int idx) 2951 { 2952 int num_wrbs = 0, work_done = 0; 2953 struct be_tx_compl_info *txcp; 2954 2955 while ((txcp = be_tx_compl_get(txo))) { 2956 num_wrbs += be_tx_compl_process(adapter, txo, txcp->end_index); 2957 work_done++; 2958 2959 if (txcp->status) { 2960 if (lancer_chip(adapter)) 2961 lancer_update_tx_err(txo, txcp->status); 2962 else 2963 be_update_tx_err(txo, txcp->status); 2964 } 2965 } 2966 2967 if (work_done) { 2968 be_cq_notify(adapter, txo->cq.id, true, work_done); 2969 atomic_sub(num_wrbs, &txo->q.used); 2970 2971 /* As Tx wrbs have been freed up, wake up netdev queue 2972 * if it was stopped due to lack of tx wrbs. */ 2973 if (__netif_subqueue_stopped(adapter->netdev, idx) && 2974 be_can_txq_wake(txo)) { 2975 netif_wake_subqueue(adapter->netdev, idx); 2976 } 2977 2978 u64_stats_update_begin(&tx_stats(txo)->sync_compl); 2979 tx_stats(txo)->tx_compl += work_done; 2980 u64_stats_update_end(&tx_stats(txo)->sync_compl); 2981 } 2982 } 2983 2984 #ifdef CONFIG_NET_RX_BUSY_POLL 2985 static inline bool be_lock_napi(struct be_eq_obj *eqo) 2986 { 2987 bool status = true; 2988 2989 spin_lock(&eqo->lock); /* BH is already disabled */ 2990 if (eqo->state & BE_EQ_LOCKED) { 2991 WARN_ON(eqo->state & BE_EQ_NAPI); 2992 eqo->state |= BE_EQ_NAPI_YIELD; 2993 status = false; 2994 } else { 2995 eqo->state = BE_EQ_NAPI; 2996 } 2997 spin_unlock(&eqo->lock); 2998 return status; 2999 } 3000 3001 static inline void be_unlock_napi(struct be_eq_obj *eqo) 3002 { 3003 spin_lock(&eqo->lock); /* BH is already disabled */ 3004 3005 WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD)); 3006 eqo->state = BE_EQ_IDLE; 3007 3008 spin_unlock(&eqo->lock); 3009 } 3010 3011 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo) 3012 { 3013 bool status = true; 3014 3015 spin_lock_bh(&eqo->lock); 3016 if (eqo->state & BE_EQ_LOCKED) { 3017 eqo->state |= BE_EQ_POLL_YIELD; 3018 status = false; 3019 } else { 3020 eqo->state |= BE_EQ_POLL; 3021 } 3022 spin_unlock_bh(&eqo->lock); 3023 return status; 3024 } 3025 3026 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo) 3027 { 3028 spin_lock_bh(&eqo->lock); 3029 3030 WARN_ON(eqo->state & (BE_EQ_NAPI)); 3031 eqo->state = BE_EQ_IDLE; 3032 3033 spin_unlock_bh(&eqo->lock); 3034 } 3035 3036 static inline void be_enable_busy_poll(struct be_eq_obj *eqo) 3037 { 3038 spin_lock_init(&eqo->lock); 3039 eqo->state = BE_EQ_IDLE; 3040 } 3041 3042 static inline void be_disable_busy_poll(struct be_eq_obj *eqo) 3043 { 3044 local_bh_disable(); 3045 3046 /* It's enough to just acquire napi lock on the eqo to stop 3047 * be_busy_poll() from processing any queueus. 3048 */ 3049 while (!be_lock_napi(eqo)) 3050 mdelay(1); 3051 3052 local_bh_enable(); 3053 } 3054 3055 #else /* CONFIG_NET_RX_BUSY_POLL */ 3056 3057 static inline bool be_lock_napi(struct be_eq_obj *eqo) 3058 { 3059 return true; 3060 } 3061 3062 static inline void be_unlock_napi(struct be_eq_obj *eqo) 3063 { 3064 } 3065 3066 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo) 3067 { 3068 return false; 3069 } 3070 3071 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo) 3072 { 3073 } 3074 3075 static inline void be_enable_busy_poll(struct be_eq_obj *eqo) 3076 { 3077 } 3078 3079 static inline void be_disable_busy_poll(struct be_eq_obj *eqo) 3080 { 3081 } 3082 #endif /* CONFIG_NET_RX_BUSY_POLL */ 3083 3084 int be_poll(struct napi_struct *napi, int budget) 3085 { 3086 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi); 3087 struct be_adapter *adapter = eqo->adapter; 3088 int max_work = 0, work, i, num_evts; 3089 struct be_rx_obj *rxo; 3090 struct be_tx_obj *txo; 3091 u32 mult_enc = 0; 3092 3093 num_evts = events_get(eqo); 3094 3095 for_all_tx_queues_on_eq(adapter, eqo, txo, i) 3096 be_process_tx(adapter, txo, i); 3097 3098 if (be_lock_napi(eqo)) { 3099 /* This loop will iterate twice for EQ0 in which 3100 * completions of the last RXQ (default one) are also processed 3101 * For other EQs the loop iterates only once 3102 */ 3103 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) { 3104 work = be_process_rx(rxo, napi, budget, NAPI_POLLING); 3105 max_work = max(work, max_work); 3106 } 3107 be_unlock_napi(eqo); 3108 } else { 3109 max_work = budget; 3110 } 3111 3112 if (is_mcc_eqo(eqo)) 3113 be_process_mcc(adapter); 3114 3115 if (max_work < budget) { 3116 napi_complete(napi); 3117 3118 /* Skyhawk EQ_DB has a provision to set the rearm to interrupt 3119 * delay via a delay multiplier encoding value 3120 */ 3121 if (skyhawk_chip(adapter)) 3122 mult_enc = be_get_eq_delay_mult_enc(eqo); 3123 3124 be_eq_notify(adapter, eqo->q.id, true, false, num_evts, 3125 mult_enc); 3126 } else { 3127 /* As we'll continue in polling mode, count and clear events */ 3128 be_eq_notify(adapter, eqo->q.id, false, false, num_evts, 0); 3129 } 3130 return max_work; 3131 } 3132 3133 #ifdef CONFIG_NET_RX_BUSY_POLL 3134 static int be_busy_poll(struct napi_struct *napi) 3135 { 3136 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi); 3137 struct be_adapter *adapter = eqo->adapter; 3138 struct be_rx_obj *rxo; 3139 int i, work = 0; 3140 3141 if (!be_lock_busy_poll(eqo)) 3142 return LL_FLUSH_BUSY; 3143 3144 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) { 3145 work = be_process_rx(rxo, napi, 4, BUSY_POLLING); 3146 if (work) 3147 break; 3148 } 3149 3150 be_unlock_busy_poll(eqo); 3151 return work; 3152 } 3153 #endif 3154 3155 void be_detect_error(struct be_adapter *adapter) 3156 { 3157 u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0; 3158 u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0; 3159 u32 i; 3160 struct device *dev = &adapter->pdev->dev; 3161 3162 if (be_check_error(adapter, BE_ERROR_HW)) 3163 return; 3164 3165 if (lancer_chip(adapter)) { 3166 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET); 3167 if (sliport_status & SLIPORT_STATUS_ERR_MASK) { 3168 be_set_error(adapter, BE_ERROR_UE); 3169 sliport_err1 = ioread32(adapter->db + 3170 SLIPORT_ERROR1_OFFSET); 3171 sliport_err2 = ioread32(adapter->db + 3172 SLIPORT_ERROR2_OFFSET); 3173 /* Do not log error messages if its a FW reset */ 3174 if (sliport_err1 == SLIPORT_ERROR_FW_RESET1 && 3175 sliport_err2 == SLIPORT_ERROR_FW_RESET2) { 3176 dev_info(dev, "Firmware update in progress\n"); 3177 } else { 3178 dev_err(dev, "Error detected in the card\n"); 3179 dev_err(dev, "ERR: sliport status 0x%x\n", 3180 sliport_status); 3181 dev_err(dev, "ERR: sliport error1 0x%x\n", 3182 sliport_err1); 3183 dev_err(dev, "ERR: sliport error2 0x%x\n", 3184 sliport_err2); 3185 } 3186 } 3187 } else { 3188 ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW); 3189 ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH); 3190 ue_lo_mask = ioread32(adapter->pcicfg + 3191 PCICFG_UE_STATUS_LOW_MASK); 3192 ue_hi_mask = ioread32(adapter->pcicfg + 3193 PCICFG_UE_STATUS_HI_MASK); 3194 3195 ue_lo = (ue_lo & ~ue_lo_mask); 3196 ue_hi = (ue_hi & ~ue_hi_mask); 3197 3198 /* On certain platforms BE hardware can indicate spurious UEs. 3199 * Allow HW to stop working completely in case of a real UE. 3200 * Hence not setting the hw_error for UE detection. 3201 */ 3202 3203 if (ue_lo || ue_hi) { 3204 dev_err(dev, 3205 "Unrecoverable Error detected in the adapter"); 3206 dev_err(dev, "Please reboot server to recover"); 3207 if (skyhawk_chip(adapter)) 3208 be_set_error(adapter, BE_ERROR_UE); 3209 3210 for (i = 0; ue_lo; ue_lo >>= 1, i++) { 3211 if (ue_lo & 1) 3212 dev_err(dev, "UE: %s bit set\n", 3213 ue_status_low_desc[i]); 3214 } 3215 for (i = 0; ue_hi; ue_hi >>= 1, i++) { 3216 if (ue_hi & 1) 3217 dev_err(dev, "UE: %s bit set\n", 3218 ue_status_hi_desc[i]); 3219 } 3220 } 3221 } 3222 } 3223 3224 static void be_msix_disable(struct be_adapter *adapter) 3225 { 3226 if (msix_enabled(adapter)) { 3227 pci_disable_msix(adapter->pdev); 3228 adapter->num_msix_vec = 0; 3229 adapter->num_msix_roce_vec = 0; 3230 } 3231 } 3232 3233 static int be_msix_enable(struct be_adapter *adapter) 3234 { 3235 int i, num_vec; 3236 struct device *dev = &adapter->pdev->dev; 3237 3238 /* If RoCE is supported, program the max number of NIC vectors that 3239 * may be configured via set-channels, along with vectors needed for 3240 * RoCe. Else, just program the number we'll use initially. 3241 */ 3242 if (be_roce_supported(adapter)) 3243 num_vec = min_t(int, 2 * be_max_eqs(adapter), 3244 2 * num_online_cpus()); 3245 else 3246 num_vec = adapter->cfg_num_qs; 3247 3248 for (i = 0; i < num_vec; i++) 3249 adapter->msix_entries[i].entry = i; 3250 3251 num_vec = pci_enable_msix_range(adapter->pdev, adapter->msix_entries, 3252 MIN_MSIX_VECTORS, num_vec); 3253 if (num_vec < 0) 3254 goto fail; 3255 3256 if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) { 3257 adapter->num_msix_roce_vec = num_vec / 2; 3258 dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n", 3259 adapter->num_msix_roce_vec); 3260 } 3261 3262 adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec; 3263 3264 dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n", 3265 adapter->num_msix_vec); 3266 return 0; 3267 3268 fail: 3269 dev_warn(dev, "MSIx enable failed\n"); 3270 3271 /* INTx is not supported in VFs, so fail probe if enable_msix fails */ 3272 if (be_virtfn(adapter)) 3273 return num_vec; 3274 return 0; 3275 } 3276 3277 static inline int be_msix_vec_get(struct be_adapter *adapter, 3278 struct be_eq_obj *eqo) 3279 { 3280 return adapter->msix_entries[eqo->msix_idx].vector; 3281 } 3282 3283 static int be_msix_register(struct be_adapter *adapter) 3284 { 3285 struct net_device *netdev = adapter->netdev; 3286 struct be_eq_obj *eqo; 3287 int status, i, vec; 3288 3289 for_all_evt_queues(adapter, eqo, i) { 3290 sprintf(eqo->desc, "%s-q%d", netdev->name, i); 3291 vec = be_msix_vec_get(adapter, eqo); 3292 status = request_irq(vec, be_msix, 0, eqo->desc, eqo); 3293 if (status) 3294 goto err_msix; 3295 3296 irq_set_affinity_hint(vec, eqo->affinity_mask); 3297 } 3298 3299 return 0; 3300 err_msix: 3301 for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--) 3302 free_irq(be_msix_vec_get(adapter, eqo), eqo); 3303 dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n", 3304 status); 3305 be_msix_disable(adapter); 3306 return status; 3307 } 3308 3309 static int be_irq_register(struct be_adapter *adapter) 3310 { 3311 struct net_device *netdev = adapter->netdev; 3312 int status; 3313 3314 if (msix_enabled(adapter)) { 3315 status = be_msix_register(adapter); 3316 if (status == 0) 3317 goto done; 3318 /* INTx is not supported for VF */ 3319 if (be_virtfn(adapter)) 3320 return status; 3321 } 3322 3323 /* INTx: only the first EQ is used */ 3324 netdev->irq = adapter->pdev->irq; 3325 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name, 3326 &adapter->eq_obj[0]); 3327 if (status) { 3328 dev_err(&adapter->pdev->dev, 3329 "INTx request IRQ failed - err %d\n", status); 3330 return status; 3331 } 3332 done: 3333 adapter->isr_registered = true; 3334 return 0; 3335 } 3336 3337 static void be_irq_unregister(struct be_adapter *adapter) 3338 { 3339 struct net_device *netdev = adapter->netdev; 3340 struct be_eq_obj *eqo; 3341 int i, vec; 3342 3343 if (!adapter->isr_registered) 3344 return; 3345 3346 /* INTx */ 3347 if (!msix_enabled(adapter)) { 3348 free_irq(netdev->irq, &adapter->eq_obj[0]); 3349 goto done; 3350 } 3351 3352 /* MSIx */ 3353 for_all_evt_queues(adapter, eqo, i) { 3354 vec = be_msix_vec_get(adapter, eqo); 3355 irq_set_affinity_hint(vec, NULL); 3356 free_irq(vec, eqo); 3357 } 3358 3359 done: 3360 adapter->isr_registered = false; 3361 } 3362 3363 static void be_rx_qs_destroy(struct be_adapter *adapter) 3364 { 3365 struct be_queue_info *q; 3366 struct be_rx_obj *rxo; 3367 int i; 3368 3369 for_all_rx_queues(adapter, rxo, i) { 3370 q = &rxo->q; 3371 if (q->created) { 3372 /* If RXQs are destroyed while in an "out of buffer" 3373 * state, there is a possibility of an HW stall on 3374 * Lancer. So, post 64 buffers to each queue to relieve 3375 * the "out of buffer" condition. 3376 * Make sure there's space in the RXQ before posting. 3377 */ 3378 if (lancer_chip(adapter)) { 3379 be_rx_cq_clean(rxo); 3380 if (atomic_read(&q->used) == 0) 3381 be_post_rx_frags(rxo, GFP_KERNEL, 3382 MAX_RX_POST); 3383 } 3384 3385 be_cmd_rxq_destroy(adapter, q); 3386 be_rx_cq_clean(rxo); 3387 be_rxq_clean(rxo); 3388 } 3389 be_queue_free(adapter, q); 3390 } 3391 } 3392 3393 static void be_disable_if_filters(struct be_adapter *adapter) 3394 { 3395 be_cmd_pmac_del(adapter, adapter->if_handle, 3396 adapter->pmac_id[0], 0); 3397 3398 be_clear_uc_list(adapter); 3399 3400 /* The IFACE flags are enabled in the open path and cleared 3401 * in the close path. When a VF gets detached from the host and 3402 * assigned to a VM the following happens: 3403 * - VF's IFACE flags get cleared in the detach path 3404 * - IFACE create is issued by the VF in the attach path 3405 * Due to a bug in the BE3/Skyhawk-R FW 3406 * (Lancer FW doesn't have the bug), the IFACE capability flags 3407 * specified along with the IFACE create cmd issued by a VF are not 3408 * honoured by FW. As a consequence, if a *new* driver 3409 * (that enables/disables IFACE flags in open/close) 3410 * is loaded in the host and an *old* driver is * used by a VM/VF, 3411 * the IFACE gets created *without* the needed flags. 3412 * To avoid this, disable RX-filter flags only for Lancer. 3413 */ 3414 if (lancer_chip(adapter)) { 3415 be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF); 3416 adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS; 3417 } 3418 } 3419 3420 static int be_close(struct net_device *netdev) 3421 { 3422 struct be_adapter *adapter = netdev_priv(netdev); 3423 struct be_eq_obj *eqo; 3424 int i; 3425 3426 /* This protection is needed as be_close() may be called even when the 3427 * adapter is in cleared state (after eeh perm failure) 3428 */ 3429 if (!(adapter->flags & BE_FLAGS_SETUP_DONE)) 3430 return 0; 3431 3432 be_disable_if_filters(adapter); 3433 3434 be_roce_dev_close(adapter); 3435 3436 if (adapter->flags & BE_FLAGS_NAPI_ENABLED) { 3437 for_all_evt_queues(adapter, eqo, i) { 3438 napi_disable(&eqo->napi); 3439 be_disable_busy_poll(eqo); 3440 } 3441 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED; 3442 } 3443 3444 be_async_mcc_disable(adapter); 3445 3446 /* Wait for all pending tx completions to arrive so that 3447 * all tx skbs are freed. 3448 */ 3449 netif_tx_disable(netdev); 3450 be_tx_compl_clean(adapter); 3451 3452 be_rx_qs_destroy(adapter); 3453 3454 for_all_evt_queues(adapter, eqo, i) { 3455 if (msix_enabled(adapter)) 3456 synchronize_irq(be_msix_vec_get(adapter, eqo)); 3457 else 3458 synchronize_irq(netdev->irq); 3459 be_eq_clean(eqo); 3460 } 3461 3462 be_irq_unregister(adapter); 3463 3464 return 0; 3465 } 3466 3467 static int be_rx_qs_create(struct be_adapter *adapter) 3468 { 3469 struct rss_info *rss = &adapter->rss_info; 3470 u8 rss_key[RSS_HASH_KEY_LEN]; 3471 struct be_rx_obj *rxo; 3472 int rc, i, j; 3473 3474 for_all_rx_queues(adapter, rxo, i) { 3475 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN, 3476 sizeof(struct be_eth_rx_d)); 3477 if (rc) 3478 return rc; 3479 } 3480 3481 if (adapter->need_def_rxq || !adapter->num_rss_qs) { 3482 rxo = default_rxo(adapter); 3483 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, 3484 rx_frag_size, adapter->if_handle, 3485 false, &rxo->rss_id); 3486 if (rc) 3487 return rc; 3488 } 3489 3490 for_all_rss_queues(adapter, rxo, i) { 3491 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, 3492 rx_frag_size, adapter->if_handle, 3493 true, &rxo->rss_id); 3494 if (rc) 3495 return rc; 3496 } 3497 3498 if (be_multi_rxq(adapter)) { 3499 for (j = 0; j < RSS_INDIR_TABLE_LEN; j += adapter->num_rss_qs) { 3500 for_all_rss_queues(adapter, rxo, i) { 3501 if ((j + i) >= RSS_INDIR_TABLE_LEN) 3502 break; 3503 rss->rsstable[j + i] = rxo->rss_id; 3504 rss->rss_queue[j + i] = i; 3505 } 3506 } 3507 rss->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 | 3508 RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6; 3509 3510 if (!BEx_chip(adapter)) 3511 rss->rss_flags |= RSS_ENABLE_UDP_IPV4 | 3512 RSS_ENABLE_UDP_IPV6; 3513 } else { 3514 /* Disable RSS, if only default RX Q is created */ 3515 rss->rss_flags = RSS_ENABLE_NONE; 3516 } 3517 3518 netdev_rss_key_fill(rss_key, RSS_HASH_KEY_LEN); 3519 rc = be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags, 3520 128, rss_key); 3521 if (rc) { 3522 rss->rss_flags = RSS_ENABLE_NONE; 3523 return rc; 3524 } 3525 3526 memcpy(rss->rss_hkey, rss_key, RSS_HASH_KEY_LEN); 3527 3528 /* Post 1 less than RXQ-len to avoid head being equal to tail, 3529 * which is a queue empty condition 3530 */ 3531 for_all_rx_queues(adapter, rxo, i) 3532 be_post_rx_frags(rxo, GFP_KERNEL, RX_Q_LEN - 1); 3533 3534 return 0; 3535 } 3536 3537 static int be_enable_if_filters(struct be_adapter *adapter) 3538 { 3539 int status; 3540 3541 status = be_cmd_rx_filter(adapter, BE_IF_EN_FLAGS, ON); 3542 if (status) 3543 return status; 3544 3545 /* For BE3 VFs, the PF programs the initial MAC address */ 3546 if (!(BEx_chip(adapter) && be_virtfn(adapter))) { 3547 status = be_cmd_pmac_add(adapter, adapter->netdev->dev_addr, 3548 adapter->if_handle, 3549 &adapter->pmac_id[0], 0); 3550 if (status) 3551 return status; 3552 } 3553 3554 if (adapter->vlans_added) 3555 be_vid_config(adapter); 3556 3557 be_set_rx_mode(adapter->netdev); 3558 3559 return 0; 3560 } 3561 3562 static int be_open(struct net_device *netdev) 3563 { 3564 struct be_adapter *adapter = netdev_priv(netdev); 3565 struct be_eq_obj *eqo; 3566 struct be_rx_obj *rxo; 3567 struct be_tx_obj *txo; 3568 u8 link_status; 3569 int status, i; 3570 3571 status = be_rx_qs_create(adapter); 3572 if (status) 3573 goto err; 3574 3575 status = be_enable_if_filters(adapter); 3576 if (status) 3577 goto err; 3578 3579 status = be_irq_register(adapter); 3580 if (status) 3581 goto err; 3582 3583 for_all_rx_queues(adapter, rxo, i) 3584 be_cq_notify(adapter, rxo->cq.id, true, 0); 3585 3586 for_all_tx_queues(adapter, txo, i) 3587 be_cq_notify(adapter, txo->cq.id, true, 0); 3588 3589 be_async_mcc_enable(adapter); 3590 3591 for_all_evt_queues(adapter, eqo, i) { 3592 napi_enable(&eqo->napi); 3593 be_enable_busy_poll(eqo); 3594 be_eq_notify(adapter, eqo->q.id, true, true, 0, 0); 3595 } 3596 adapter->flags |= BE_FLAGS_NAPI_ENABLED; 3597 3598 status = be_cmd_link_status_query(adapter, NULL, &link_status, 0); 3599 if (!status) 3600 be_link_status_update(adapter, link_status); 3601 3602 netif_tx_start_all_queues(netdev); 3603 be_roce_dev_open(adapter); 3604 3605 #ifdef CONFIG_BE2NET_VXLAN 3606 if (skyhawk_chip(adapter)) 3607 vxlan_get_rx_port(netdev); 3608 #endif 3609 3610 return 0; 3611 err: 3612 be_close(adapter->netdev); 3613 return -EIO; 3614 } 3615 3616 static int be_setup_wol(struct be_adapter *adapter, bool enable) 3617 { 3618 struct device *dev = &adapter->pdev->dev; 3619 struct be_dma_mem cmd; 3620 u8 mac[ETH_ALEN]; 3621 int status; 3622 3623 eth_zero_addr(mac); 3624 3625 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config); 3626 cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL); 3627 if (!cmd.va) 3628 return -ENOMEM; 3629 3630 if (enable) { 3631 status = pci_write_config_dword(adapter->pdev, 3632 PCICFG_PM_CONTROL_OFFSET, 3633 PCICFG_PM_CONTROL_MASK); 3634 if (status) { 3635 dev_err(dev, "Could not enable Wake-on-lan\n"); 3636 goto err; 3637 } 3638 } else { 3639 ether_addr_copy(mac, adapter->netdev->dev_addr); 3640 } 3641 3642 status = be_cmd_enable_magic_wol(adapter, mac, &cmd); 3643 pci_enable_wake(adapter->pdev, PCI_D3hot, enable); 3644 pci_enable_wake(adapter->pdev, PCI_D3cold, enable); 3645 err: 3646 dma_free_coherent(dev, cmd.size, cmd.va, cmd.dma); 3647 return status; 3648 } 3649 3650 static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac) 3651 { 3652 u32 addr; 3653 3654 addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0); 3655 3656 mac[5] = (u8)(addr & 0xFF); 3657 mac[4] = (u8)((addr >> 8) & 0xFF); 3658 mac[3] = (u8)((addr >> 16) & 0xFF); 3659 /* Use the OUI from the current MAC address */ 3660 memcpy(mac, adapter->netdev->dev_addr, 3); 3661 } 3662 3663 /* 3664 * Generate a seed MAC address from the PF MAC Address using jhash. 3665 * MAC Address for VFs are assigned incrementally starting from the seed. 3666 * These addresses are programmed in the ASIC by the PF and the VF driver 3667 * queries for the MAC address during its probe. 3668 */ 3669 static int be_vf_eth_addr_config(struct be_adapter *adapter) 3670 { 3671 u32 vf; 3672 int status = 0; 3673 u8 mac[ETH_ALEN]; 3674 struct be_vf_cfg *vf_cfg; 3675 3676 be_vf_eth_addr_generate(adapter, mac); 3677 3678 for_all_vfs(adapter, vf_cfg, vf) { 3679 if (BEx_chip(adapter)) 3680 status = be_cmd_pmac_add(adapter, mac, 3681 vf_cfg->if_handle, 3682 &vf_cfg->pmac_id, vf + 1); 3683 else 3684 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle, 3685 vf + 1); 3686 3687 if (status) 3688 dev_err(&adapter->pdev->dev, 3689 "Mac address assignment failed for VF %d\n", 3690 vf); 3691 else 3692 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN); 3693 3694 mac[5] += 1; 3695 } 3696 return status; 3697 } 3698 3699 static int be_vfs_mac_query(struct be_adapter *adapter) 3700 { 3701 int status, vf; 3702 u8 mac[ETH_ALEN]; 3703 struct be_vf_cfg *vf_cfg; 3704 3705 for_all_vfs(adapter, vf_cfg, vf) { 3706 status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id, 3707 mac, vf_cfg->if_handle, 3708 false, vf+1); 3709 if (status) 3710 return status; 3711 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN); 3712 } 3713 return 0; 3714 } 3715 3716 static void be_vf_clear(struct be_adapter *adapter) 3717 { 3718 struct be_vf_cfg *vf_cfg; 3719 u32 vf; 3720 3721 if (pci_vfs_assigned(adapter->pdev)) { 3722 dev_warn(&adapter->pdev->dev, 3723 "VFs are assigned to VMs: not disabling VFs\n"); 3724 goto done; 3725 } 3726 3727 pci_disable_sriov(adapter->pdev); 3728 3729 for_all_vfs(adapter, vf_cfg, vf) { 3730 if (BEx_chip(adapter)) 3731 be_cmd_pmac_del(adapter, vf_cfg->if_handle, 3732 vf_cfg->pmac_id, vf + 1); 3733 else 3734 be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle, 3735 vf + 1); 3736 3737 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1); 3738 } 3739 done: 3740 kfree(adapter->vf_cfg); 3741 adapter->num_vfs = 0; 3742 adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED; 3743 } 3744 3745 static void be_clear_queues(struct be_adapter *adapter) 3746 { 3747 be_mcc_queues_destroy(adapter); 3748 be_rx_cqs_destroy(adapter); 3749 be_tx_queues_destroy(adapter); 3750 be_evt_queues_destroy(adapter); 3751 } 3752 3753 static void be_cancel_worker(struct be_adapter *adapter) 3754 { 3755 if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) { 3756 cancel_delayed_work_sync(&adapter->work); 3757 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED; 3758 } 3759 } 3760 3761 static void be_cancel_err_detection(struct be_adapter *adapter) 3762 { 3763 if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) { 3764 cancel_delayed_work_sync(&adapter->be_err_detection_work); 3765 adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED; 3766 } 3767 } 3768 3769 #ifdef CONFIG_BE2NET_VXLAN 3770 static void be_disable_vxlan_offloads(struct be_adapter *adapter) 3771 { 3772 struct net_device *netdev = adapter->netdev; 3773 3774 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) 3775 be_cmd_manage_iface(adapter, adapter->if_handle, 3776 OP_CONVERT_TUNNEL_TO_NORMAL); 3777 3778 if (adapter->vxlan_port) 3779 be_cmd_set_vxlan_port(adapter, 0); 3780 3781 adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS; 3782 adapter->vxlan_port = 0; 3783 3784 netdev->hw_enc_features = 0; 3785 netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL); 3786 netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL); 3787 } 3788 #endif 3789 3790 static u16 be_calculate_vf_qs(struct be_adapter *adapter, u16 num_vfs) 3791 { 3792 struct be_resources res = adapter->pool_res; 3793 u16 num_vf_qs = 1; 3794 3795 /* Distribute the queue resources equally among the PF and it's VFs 3796 * Do not distribute queue resources in multi-channel configuration. 3797 */ 3798 if (num_vfs && !be_is_mc(adapter)) { 3799 /* If number of VFs requested is 8 less than max supported, 3800 * assign 8 queue pairs to the PF and divide the remaining 3801 * resources evenly among the VFs 3802 */ 3803 if (num_vfs < (be_max_vfs(adapter) - 8)) 3804 num_vf_qs = (res.max_rss_qs - 8) / num_vfs; 3805 else 3806 num_vf_qs = res.max_rss_qs / num_vfs; 3807 3808 /* Skyhawk-R chip supports only MAX_RSS_IFACES RSS capable 3809 * interfaces per port. Provide RSS on VFs, only if number 3810 * of VFs requested is less than MAX_RSS_IFACES limit. 3811 */ 3812 if (num_vfs >= MAX_RSS_IFACES) 3813 num_vf_qs = 1; 3814 } 3815 return num_vf_qs; 3816 } 3817 3818 static int be_clear(struct be_adapter *adapter) 3819 { 3820 struct pci_dev *pdev = adapter->pdev; 3821 u16 num_vf_qs; 3822 3823 be_cancel_worker(adapter); 3824 3825 if (sriov_enabled(adapter)) 3826 be_vf_clear(adapter); 3827 3828 /* Re-configure FW to distribute resources evenly across max-supported 3829 * number of VFs, only when VFs are not already enabled. 3830 */ 3831 if (skyhawk_chip(adapter) && be_physfn(adapter) && 3832 !pci_vfs_assigned(pdev)) { 3833 num_vf_qs = be_calculate_vf_qs(adapter, 3834 pci_sriov_get_totalvfs(pdev)); 3835 be_cmd_set_sriov_config(adapter, adapter->pool_res, 3836 pci_sriov_get_totalvfs(pdev), 3837 num_vf_qs); 3838 } 3839 3840 #ifdef CONFIG_BE2NET_VXLAN 3841 be_disable_vxlan_offloads(adapter); 3842 #endif 3843 kfree(adapter->pmac_id); 3844 adapter->pmac_id = NULL; 3845 3846 be_cmd_if_destroy(adapter, adapter->if_handle, 0); 3847 3848 be_clear_queues(adapter); 3849 3850 be_msix_disable(adapter); 3851 adapter->flags &= ~BE_FLAGS_SETUP_DONE; 3852 return 0; 3853 } 3854 3855 static int be_vfs_if_create(struct be_adapter *adapter) 3856 { 3857 struct be_resources res = {0}; 3858 u32 cap_flags, en_flags, vf; 3859 struct be_vf_cfg *vf_cfg; 3860 int status; 3861 3862 /* If a FW profile exists, then cap_flags are updated */ 3863 cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST | 3864 BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS; 3865 3866 for_all_vfs(adapter, vf_cfg, vf) { 3867 if (!BE3_chip(adapter)) { 3868 status = be_cmd_get_profile_config(adapter, &res, 3869 RESOURCE_LIMITS, 3870 vf + 1); 3871 if (!status) { 3872 cap_flags = res.if_cap_flags; 3873 /* Prevent VFs from enabling VLAN promiscuous 3874 * mode 3875 */ 3876 cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS; 3877 } 3878 } 3879 3880 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED | 3881 BE_IF_FLAGS_BROADCAST | 3882 BE_IF_FLAGS_MULTICAST | 3883 BE_IF_FLAGS_PASS_L3L4_ERRORS); 3884 status = be_cmd_if_create(adapter, cap_flags, en_flags, 3885 &vf_cfg->if_handle, vf + 1); 3886 if (status) 3887 return status; 3888 } 3889 3890 return 0; 3891 } 3892 3893 static int be_vf_setup_init(struct be_adapter *adapter) 3894 { 3895 struct be_vf_cfg *vf_cfg; 3896 int vf; 3897 3898 adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg), 3899 GFP_KERNEL); 3900 if (!adapter->vf_cfg) 3901 return -ENOMEM; 3902 3903 for_all_vfs(adapter, vf_cfg, vf) { 3904 vf_cfg->if_handle = -1; 3905 vf_cfg->pmac_id = -1; 3906 } 3907 return 0; 3908 } 3909 3910 static int be_vf_setup(struct be_adapter *adapter) 3911 { 3912 struct device *dev = &adapter->pdev->dev; 3913 struct be_vf_cfg *vf_cfg; 3914 int status, old_vfs, vf; 3915 bool spoofchk; 3916 3917 old_vfs = pci_num_vf(adapter->pdev); 3918 3919 status = be_vf_setup_init(adapter); 3920 if (status) 3921 goto err; 3922 3923 if (old_vfs) { 3924 for_all_vfs(adapter, vf_cfg, vf) { 3925 status = be_cmd_get_if_id(adapter, vf_cfg, vf); 3926 if (status) 3927 goto err; 3928 } 3929 3930 status = be_vfs_mac_query(adapter); 3931 if (status) 3932 goto err; 3933 } else { 3934 status = be_vfs_if_create(adapter); 3935 if (status) 3936 goto err; 3937 3938 status = be_vf_eth_addr_config(adapter); 3939 if (status) 3940 goto err; 3941 } 3942 3943 for_all_vfs(adapter, vf_cfg, vf) { 3944 /* Allow VFs to programs MAC/VLAN filters */ 3945 status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges, 3946 vf + 1); 3947 if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) { 3948 status = be_cmd_set_fn_privileges(adapter, 3949 vf_cfg->privileges | 3950 BE_PRIV_FILTMGMT, 3951 vf + 1); 3952 if (!status) { 3953 vf_cfg->privileges |= BE_PRIV_FILTMGMT; 3954 dev_info(dev, "VF%d has FILTMGMT privilege\n", 3955 vf); 3956 } 3957 } 3958 3959 /* Allow full available bandwidth */ 3960 if (!old_vfs) 3961 be_cmd_config_qos(adapter, 0, 0, vf + 1); 3962 3963 status = be_cmd_get_hsw_config(adapter, NULL, vf + 1, 3964 vf_cfg->if_handle, NULL, 3965 &spoofchk); 3966 if (!status) 3967 vf_cfg->spoofchk = spoofchk; 3968 3969 if (!old_vfs) { 3970 be_cmd_enable_vf(adapter, vf + 1); 3971 be_cmd_set_logical_link_config(adapter, 3972 IFLA_VF_LINK_STATE_AUTO, 3973 vf+1); 3974 } 3975 } 3976 3977 if (!old_vfs) { 3978 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs); 3979 if (status) { 3980 dev_err(dev, "SRIOV enable failed\n"); 3981 adapter->num_vfs = 0; 3982 goto err; 3983 } 3984 } 3985 3986 adapter->flags |= BE_FLAGS_SRIOV_ENABLED; 3987 return 0; 3988 err: 3989 dev_err(dev, "VF setup failed\n"); 3990 be_vf_clear(adapter); 3991 return status; 3992 } 3993 3994 /* Converting function_mode bits on BE3 to SH mc_type enums */ 3995 3996 static u8 be_convert_mc_type(u32 function_mode) 3997 { 3998 if (function_mode & VNIC_MODE && function_mode & QNQ_MODE) 3999 return vNIC1; 4000 else if (function_mode & QNQ_MODE) 4001 return FLEX10; 4002 else if (function_mode & VNIC_MODE) 4003 return vNIC2; 4004 else if (function_mode & UMC_ENABLED) 4005 return UMC; 4006 else 4007 return MC_NONE; 4008 } 4009 4010 /* On BE2/BE3 FW does not suggest the supported limits */ 4011 static void BEx_get_resources(struct be_adapter *adapter, 4012 struct be_resources *res) 4013 { 4014 bool use_sriov = adapter->num_vfs ? 1 : 0; 4015 4016 if (be_physfn(adapter)) 4017 res->max_uc_mac = BE_UC_PMAC_COUNT; 4018 else 4019 res->max_uc_mac = BE_VF_UC_PMAC_COUNT; 4020 4021 adapter->mc_type = be_convert_mc_type(adapter->function_mode); 4022 4023 if (be_is_mc(adapter)) { 4024 /* Assuming that there are 4 channels per port, 4025 * when multi-channel is enabled 4026 */ 4027 if (be_is_qnq_mode(adapter)) 4028 res->max_vlans = BE_NUM_VLANS_SUPPORTED/8; 4029 else 4030 /* In a non-qnq multichannel mode, the pvid 4031 * takes up one vlan entry 4032 */ 4033 res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1; 4034 } else { 4035 res->max_vlans = BE_NUM_VLANS_SUPPORTED; 4036 } 4037 4038 res->max_mcast_mac = BE_MAX_MC; 4039 4040 /* 1) For BE3 1Gb ports, FW does not support multiple TXQs 4041 * 2) Create multiple TX rings on a BE3-R multi-channel interface 4042 * *only* if it is RSS-capable. 4043 */ 4044 if (BE2_chip(adapter) || use_sriov || (adapter->port_num > 1) || 4045 be_virtfn(adapter) || 4046 (be_is_mc(adapter) && 4047 !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) { 4048 res->max_tx_qs = 1; 4049 } else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) { 4050 struct be_resources super_nic_res = {0}; 4051 4052 /* On a SuperNIC profile, the driver needs to use the 4053 * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits 4054 */ 4055 be_cmd_get_profile_config(adapter, &super_nic_res, 4056 RESOURCE_LIMITS, 0); 4057 /* Some old versions of BE3 FW don't report max_tx_qs value */ 4058 res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS; 4059 } else { 4060 res->max_tx_qs = BE3_MAX_TX_QS; 4061 } 4062 4063 if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) && 4064 !use_sriov && be_physfn(adapter)) 4065 res->max_rss_qs = (adapter->be3_native) ? 4066 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS; 4067 res->max_rx_qs = res->max_rss_qs + 1; 4068 4069 if (be_physfn(adapter)) 4070 res->max_evt_qs = (be_max_vfs(adapter) > 0) ? 4071 BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS; 4072 else 4073 res->max_evt_qs = 1; 4074 4075 res->if_cap_flags = BE_IF_CAP_FLAGS_WANT; 4076 res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS; 4077 if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS)) 4078 res->if_cap_flags &= ~BE_IF_FLAGS_RSS; 4079 } 4080 4081 static void be_setup_init(struct be_adapter *adapter) 4082 { 4083 adapter->vlan_prio_bmap = 0xff; 4084 adapter->phy.link_speed = -1; 4085 adapter->if_handle = -1; 4086 adapter->be3_native = false; 4087 adapter->if_flags = 0; 4088 if (be_physfn(adapter)) 4089 adapter->cmd_privileges = MAX_PRIVILEGES; 4090 else 4091 adapter->cmd_privileges = MIN_PRIVILEGES; 4092 } 4093 4094 static int be_get_sriov_config(struct be_adapter *adapter) 4095 { 4096 struct be_resources res = {0}; 4097 int max_vfs, old_vfs; 4098 4099 be_cmd_get_profile_config(adapter, &res, RESOURCE_LIMITS, 0); 4100 4101 /* Some old versions of BE3 FW don't report max_vfs value */ 4102 if (BE3_chip(adapter) && !res.max_vfs) { 4103 max_vfs = pci_sriov_get_totalvfs(adapter->pdev); 4104 res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0; 4105 } 4106 4107 adapter->pool_res = res; 4108 4109 /* If during previous unload of the driver, the VFs were not disabled, 4110 * then we cannot rely on the PF POOL limits for the TotalVFs value. 4111 * Instead use the TotalVFs value stored in the pci-dev struct. 4112 */ 4113 old_vfs = pci_num_vf(adapter->pdev); 4114 if (old_vfs) { 4115 dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n", 4116 old_vfs); 4117 4118 adapter->pool_res.max_vfs = 4119 pci_sriov_get_totalvfs(adapter->pdev); 4120 adapter->num_vfs = old_vfs; 4121 } 4122 4123 return 0; 4124 } 4125 4126 static void be_alloc_sriov_res(struct be_adapter *adapter) 4127 { 4128 int old_vfs = pci_num_vf(adapter->pdev); 4129 u16 num_vf_qs; 4130 int status; 4131 4132 be_get_sriov_config(adapter); 4133 4134 if (!old_vfs) 4135 pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter)); 4136 4137 /* When the HW is in SRIOV capable configuration, the PF-pool 4138 * resources are given to PF during driver load, if there are no 4139 * old VFs. This facility is not available in BE3 FW. 4140 * Also, this is done by FW in Lancer chip. 4141 */ 4142 if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) { 4143 num_vf_qs = be_calculate_vf_qs(adapter, 0); 4144 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0, 4145 num_vf_qs); 4146 if (status) 4147 dev_err(&adapter->pdev->dev, 4148 "Failed to optimize SRIOV resources\n"); 4149 } 4150 } 4151 4152 static int be_get_resources(struct be_adapter *adapter) 4153 { 4154 struct device *dev = &adapter->pdev->dev; 4155 struct be_resources res = {0}; 4156 int status; 4157 4158 if (BEx_chip(adapter)) { 4159 BEx_get_resources(adapter, &res); 4160 adapter->res = res; 4161 } 4162 4163 /* For Lancer, SH etc read per-function resource limits from FW. 4164 * GET_FUNC_CONFIG returns per function guaranteed limits. 4165 * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits 4166 */ 4167 if (!BEx_chip(adapter)) { 4168 status = be_cmd_get_func_config(adapter, &res); 4169 if (status) 4170 return status; 4171 4172 /* If a deafault RXQ must be created, we'll use up one RSSQ*/ 4173 if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs && 4174 !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS)) 4175 res.max_rss_qs -= 1; 4176 4177 /* If RoCE may be enabled stash away half the EQs for RoCE */ 4178 if (be_roce_supported(adapter)) 4179 res.max_evt_qs /= 2; 4180 adapter->res = res; 4181 } 4182 4183 /* If FW supports RSS default queue, then skip creating non-RSS 4184 * queue for non-IP traffic. 4185 */ 4186 adapter->need_def_rxq = (be_if_cap_flags(adapter) & 4187 BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1; 4188 4189 dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n", 4190 be_max_txqs(adapter), be_max_rxqs(adapter), 4191 be_max_rss(adapter), be_max_eqs(adapter), 4192 be_max_vfs(adapter)); 4193 dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n", 4194 be_max_uc(adapter), be_max_mc(adapter), 4195 be_max_vlans(adapter)); 4196 4197 /* Sanitize cfg_num_qs based on HW and platform limits */ 4198 adapter->cfg_num_qs = min_t(u16, netif_get_num_default_rss_queues(), 4199 be_max_qs(adapter)); 4200 return 0; 4201 } 4202 4203 static int be_get_config(struct be_adapter *adapter) 4204 { 4205 int status, level; 4206 u16 profile_id; 4207 4208 status = be_cmd_get_cntl_attributes(adapter); 4209 if (status) 4210 return status; 4211 4212 status = be_cmd_query_fw_cfg(adapter); 4213 if (status) 4214 return status; 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 if (!BE2_chip(adapter) && be_physfn(adapter)) 4411 be_alloc_sriov_res(adapter); 4412 4413 status = be_get_config(adapter); 4414 if (status) 4415 goto err; 4416 4417 status = be_msix_enable(adapter); 4418 if (status) 4419 goto err; 4420 4421 /* will enable all the needed filter flags in be_open() */ 4422 en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS; 4423 en_flags = en_flags & be_if_cap_flags(adapter); 4424 status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags, 4425 &adapter->if_handle, 0); 4426 if (status) 4427 goto err; 4428 4429 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */ 4430 rtnl_lock(); 4431 status = be_setup_queues(adapter); 4432 rtnl_unlock(); 4433 if (status) 4434 goto err; 4435 4436 be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0); 4437 4438 status = be_mac_setup(adapter); 4439 if (status) 4440 goto err; 4441 4442 be_cmd_get_fw_ver(adapter); 4443 dev_info(dev, "FW version is %s\n", adapter->fw_ver); 4444 4445 if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) { 4446 dev_err(dev, "Firmware on card is old(%s), IRQs may not work", 4447 adapter->fw_ver); 4448 dev_err(dev, "Please upgrade firmware to version >= 4.0\n"); 4449 } 4450 4451 status = be_cmd_set_flow_control(adapter, adapter->tx_fc, 4452 adapter->rx_fc); 4453 if (status) 4454 be_cmd_get_flow_control(adapter, &adapter->tx_fc, 4455 &adapter->rx_fc); 4456 4457 dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n", 4458 adapter->tx_fc, adapter->rx_fc); 4459 4460 if (be_physfn(adapter)) 4461 be_cmd_set_logical_link_config(adapter, 4462 IFLA_VF_LINK_STATE_AUTO, 0); 4463 4464 if (adapter->num_vfs) 4465 be_vf_setup(adapter); 4466 4467 status = be_cmd_get_phy_info(adapter); 4468 if (!status && be_pause_supported(adapter)) 4469 adapter->phy.fc_autoneg = 1; 4470 4471 be_schedule_worker(adapter); 4472 adapter->flags |= BE_FLAGS_SETUP_DONE; 4473 return 0; 4474 err: 4475 be_clear(adapter); 4476 return status; 4477 } 4478 4479 #ifdef CONFIG_NET_POLL_CONTROLLER 4480 static void be_netpoll(struct net_device *netdev) 4481 { 4482 struct be_adapter *adapter = netdev_priv(netdev); 4483 struct be_eq_obj *eqo; 4484 int i; 4485 4486 for_all_evt_queues(adapter, eqo, i) { 4487 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0); 4488 napi_schedule(&eqo->napi); 4489 } 4490 } 4491 #endif 4492 4493 static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "}; 4494 4495 static bool phy_flashing_required(struct be_adapter *adapter) 4496 { 4497 return (adapter->phy.phy_type == PHY_TYPE_TN_8022 && 4498 adapter->phy.interface_type == PHY_TYPE_BASET_10GB); 4499 } 4500 4501 static bool is_comp_in_ufi(struct be_adapter *adapter, 4502 struct flash_section_info *fsec, int type) 4503 { 4504 int i = 0, img_type = 0; 4505 struct flash_section_info_g2 *fsec_g2 = NULL; 4506 4507 if (BE2_chip(adapter)) 4508 fsec_g2 = (struct flash_section_info_g2 *)fsec; 4509 4510 for (i = 0; i < MAX_FLASH_COMP; i++) { 4511 if (fsec_g2) 4512 img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type); 4513 else 4514 img_type = le32_to_cpu(fsec->fsec_entry[i].type); 4515 4516 if (img_type == type) 4517 return true; 4518 } 4519 return false; 4520 4521 } 4522 4523 static struct flash_section_info *get_fsec_info(struct be_adapter *adapter, 4524 int header_size, 4525 const struct firmware *fw) 4526 { 4527 struct flash_section_info *fsec = NULL; 4528 const u8 *p = fw->data; 4529 4530 p += header_size; 4531 while (p < (fw->data + fw->size)) { 4532 fsec = (struct flash_section_info *)p; 4533 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie))) 4534 return fsec; 4535 p += 32; 4536 } 4537 return NULL; 4538 } 4539 4540 static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p, 4541 u32 img_offset, u32 img_size, int hdr_size, 4542 u16 img_optype, bool *crc_match) 4543 { 4544 u32 crc_offset; 4545 int status; 4546 u8 crc[4]; 4547 4548 status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset, 4549 img_size - 4); 4550 if (status) 4551 return status; 4552 4553 crc_offset = hdr_size + img_offset + img_size - 4; 4554 4555 /* Skip flashing, if crc of flashed region matches */ 4556 if (!memcmp(crc, p + crc_offset, 4)) 4557 *crc_match = true; 4558 else 4559 *crc_match = false; 4560 4561 return status; 4562 } 4563 4564 static int be_flash(struct be_adapter *adapter, const u8 *img, 4565 struct be_dma_mem *flash_cmd, int optype, int img_size, 4566 u32 img_offset) 4567 { 4568 u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0; 4569 struct be_cmd_write_flashrom *req = flash_cmd->va; 4570 int status; 4571 4572 while (total_bytes) { 4573 num_bytes = min_t(u32, 32*1024, total_bytes); 4574 4575 total_bytes -= num_bytes; 4576 4577 if (!total_bytes) { 4578 if (optype == OPTYPE_PHY_FW) 4579 flash_op = FLASHROM_OPER_PHY_FLASH; 4580 else 4581 flash_op = FLASHROM_OPER_FLASH; 4582 } else { 4583 if (optype == OPTYPE_PHY_FW) 4584 flash_op = FLASHROM_OPER_PHY_SAVE; 4585 else 4586 flash_op = FLASHROM_OPER_SAVE; 4587 } 4588 4589 memcpy(req->data_buf, img, num_bytes); 4590 img += num_bytes; 4591 status = be_cmd_write_flashrom(adapter, flash_cmd, optype, 4592 flash_op, img_offset + 4593 bytes_sent, num_bytes); 4594 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST && 4595 optype == OPTYPE_PHY_FW) 4596 break; 4597 else if (status) 4598 return status; 4599 4600 bytes_sent += num_bytes; 4601 } 4602 return 0; 4603 } 4604 4605 /* For BE2, BE3 and BE3-R */ 4606 static int be_flash_BEx(struct be_adapter *adapter, 4607 const struct firmware *fw, 4608 struct be_dma_mem *flash_cmd, int num_of_images) 4609 { 4610 int img_hdrs_size = (num_of_images * sizeof(struct image_hdr)); 4611 struct device *dev = &adapter->pdev->dev; 4612 struct flash_section_info *fsec = NULL; 4613 int status, i, filehdr_size, num_comp; 4614 const struct flash_comp *pflashcomp; 4615 bool crc_match; 4616 const u8 *p; 4617 4618 struct flash_comp gen3_flash_types[] = { 4619 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE, 4620 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI}, 4621 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT, 4622 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE}, 4623 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS, 4624 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI}, 4625 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS, 4626 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE}, 4627 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS, 4628 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE}, 4629 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP, 4630 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI}, 4631 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE, 4632 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE}, 4633 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP, 4634 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE}, 4635 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW, 4636 FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI}, 4637 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW, 4638 FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY} 4639 }; 4640 4641 struct flash_comp gen2_flash_types[] = { 4642 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE, 4643 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI}, 4644 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT, 4645 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE}, 4646 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS, 4647 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI}, 4648 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS, 4649 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE}, 4650 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS, 4651 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE}, 4652 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP, 4653 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI}, 4654 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE, 4655 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE}, 4656 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP, 4657 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE} 4658 }; 4659 4660 if (BE3_chip(adapter)) { 4661 pflashcomp = gen3_flash_types; 4662 filehdr_size = sizeof(struct flash_file_hdr_g3); 4663 num_comp = ARRAY_SIZE(gen3_flash_types); 4664 } else { 4665 pflashcomp = gen2_flash_types; 4666 filehdr_size = sizeof(struct flash_file_hdr_g2); 4667 num_comp = ARRAY_SIZE(gen2_flash_types); 4668 img_hdrs_size = 0; 4669 } 4670 4671 /* Get flash section info*/ 4672 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw); 4673 if (!fsec) { 4674 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n"); 4675 return -1; 4676 } 4677 for (i = 0; i < num_comp; i++) { 4678 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type)) 4679 continue; 4680 4681 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) && 4682 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0) 4683 continue; 4684 4685 if (pflashcomp[i].optype == OPTYPE_PHY_FW && 4686 !phy_flashing_required(adapter)) 4687 continue; 4688 4689 if (pflashcomp[i].optype == OPTYPE_REDBOOT) { 4690 status = be_check_flash_crc(adapter, fw->data, 4691 pflashcomp[i].offset, 4692 pflashcomp[i].size, 4693 filehdr_size + 4694 img_hdrs_size, 4695 OPTYPE_REDBOOT, &crc_match); 4696 if (status) { 4697 dev_err(dev, 4698 "Could not get CRC for 0x%x region\n", 4699 pflashcomp[i].optype); 4700 continue; 4701 } 4702 4703 if (crc_match) 4704 continue; 4705 } 4706 4707 p = fw->data + filehdr_size + pflashcomp[i].offset + 4708 img_hdrs_size; 4709 if (p + pflashcomp[i].size > fw->data + fw->size) 4710 return -1; 4711 4712 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype, 4713 pflashcomp[i].size, 0); 4714 if (status) { 4715 dev_err(dev, "Flashing section type 0x%x failed\n", 4716 pflashcomp[i].img_type); 4717 return status; 4718 } 4719 } 4720 return 0; 4721 } 4722 4723 static u16 be_get_img_optype(struct flash_section_entry fsec_entry) 4724 { 4725 u32 img_type = le32_to_cpu(fsec_entry.type); 4726 u16 img_optype = le16_to_cpu(fsec_entry.optype); 4727 4728 if (img_optype != 0xFFFF) 4729 return img_optype; 4730 4731 switch (img_type) { 4732 case IMAGE_FIRMWARE_iSCSI: 4733 img_optype = OPTYPE_ISCSI_ACTIVE; 4734 break; 4735 case IMAGE_BOOT_CODE: 4736 img_optype = OPTYPE_REDBOOT; 4737 break; 4738 case IMAGE_OPTION_ROM_ISCSI: 4739 img_optype = OPTYPE_BIOS; 4740 break; 4741 case IMAGE_OPTION_ROM_PXE: 4742 img_optype = OPTYPE_PXE_BIOS; 4743 break; 4744 case IMAGE_OPTION_ROM_FCoE: 4745 img_optype = OPTYPE_FCOE_BIOS; 4746 break; 4747 case IMAGE_FIRMWARE_BACKUP_iSCSI: 4748 img_optype = OPTYPE_ISCSI_BACKUP; 4749 break; 4750 case IMAGE_NCSI: 4751 img_optype = OPTYPE_NCSI_FW; 4752 break; 4753 case IMAGE_FLASHISM_JUMPVECTOR: 4754 img_optype = OPTYPE_FLASHISM_JUMPVECTOR; 4755 break; 4756 case IMAGE_FIRMWARE_PHY: 4757 img_optype = OPTYPE_SH_PHY_FW; 4758 break; 4759 case IMAGE_REDBOOT_DIR: 4760 img_optype = OPTYPE_REDBOOT_DIR; 4761 break; 4762 case IMAGE_REDBOOT_CONFIG: 4763 img_optype = OPTYPE_REDBOOT_CONFIG; 4764 break; 4765 case IMAGE_UFI_DIR: 4766 img_optype = OPTYPE_UFI_DIR; 4767 break; 4768 default: 4769 break; 4770 } 4771 4772 return img_optype; 4773 } 4774 4775 static int be_flash_skyhawk(struct be_adapter *adapter, 4776 const struct firmware *fw, 4777 struct be_dma_mem *flash_cmd, int num_of_images) 4778 { 4779 int img_hdrs_size = num_of_images * sizeof(struct image_hdr); 4780 bool crc_match, old_fw_img, flash_offset_support = true; 4781 struct device *dev = &adapter->pdev->dev; 4782 struct flash_section_info *fsec = NULL; 4783 u32 img_offset, img_size, img_type; 4784 u16 img_optype, flash_optype; 4785 int status, i, filehdr_size; 4786 const u8 *p; 4787 4788 filehdr_size = sizeof(struct flash_file_hdr_g3); 4789 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw); 4790 if (!fsec) { 4791 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n"); 4792 return -EINVAL; 4793 } 4794 4795 retry_flash: 4796 for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) { 4797 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset); 4798 img_size = le32_to_cpu(fsec->fsec_entry[i].pad_size); 4799 img_type = le32_to_cpu(fsec->fsec_entry[i].type); 4800 img_optype = be_get_img_optype(fsec->fsec_entry[i]); 4801 old_fw_img = fsec->fsec_entry[i].optype == 0xFFFF; 4802 4803 if (img_optype == 0xFFFF) 4804 continue; 4805 4806 if (flash_offset_support) 4807 flash_optype = OPTYPE_OFFSET_SPECIFIED; 4808 else 4809 flash_optype = img_optype; 4810 4811 /* Don't bother verifying CRC if an old FW image is being 4812 * flashed 4813 */ 4814 if (old_fw_img) 4815 goto flash; 4816 4817 status = be_check_flash_crc(adapter, fw->data, img_offset, 4818 img_size, filehdr_size + 4819 img_hdrs_size, flash_optype, 4820 &crc_match); 4821 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST || 4822 base_status(status) == MCC_STATUS_ILLEGAL_FIELD) { 4823 /* The current FW image on the card does not support 4824 * OFFSET based flashing. Retry using older mechanism 4825 * of OPTYPE based flashing 4826 */ 4827 if (flash_optype == OPTYPE_OFFSET_SPECIFIED) { 4828 flash_offset_support = false; 4829 goto retry_flash; 4830 } 4831 4832 /* The current FW image on the card does not recognize 4833 * the new FLASH op_type. The FW download is partially 4834 * complete. Reboot the server now to enable FW image 4835 * to recognize the new FLASH op_type. To complete the 4836 * remaining process, download the same FW again after 4837 * the reboot. 4838 */ 4839 dev_err(dev, "Flash incomplete. Reset the server\n"); 4840 dev_err(dev, "Download FW image again after reset\n"); 4841 return -EAGAIN; 4842 } else if (status) { 4843 dev_err(dev, "Could not get CRC for 0x%x region\n", 4844 img_optype); 4845 return -EFAULT; 4846 } 4847 4848 if (crc_match) 4849 continue; 4850 4851 flash: 4852 p = fw->data + filehdr_size + img_offset + img_hdrs_size; 4853 if (p + img_size > fw->data + fw->size) 4854 return -1; 4855 4856 status = be_flash(adapter, p, flash_cmd, flash_optype, img_size, 4857 img_offset); 4858 4859 /* The current FW image on the card does not support OFFSET 4860 * based flashing. Retry using older mechanism of OPTYPE based 4861 * flashing 4862 */ 4863 if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD && 4864 flash_optype == OPTYPE_OFFSET_SPECIFIED) { 4865 flash_offset_support = false; 4866 goto retry_flash; 4867 } 4868 4869 /* For old FW images ignore ILLEGAL_FIELD error or errors on 4870 * UFI_DIR region 4871 */ 4872 if (old_fw_img && 4873 (base_status(status) == MCC_STATUS_ILLEGAL_FIELD || 4874 (img_optype == OPTYPE_UFI_DIR && 4875 base_status(status) == MCC_STATUS_FAILED))) { 4876 continue; 4877 } else if (status) { 4878 dev_err(dev, "Flashing section type 0x%x failed\n", 4879 img_type); 4880 return -EFAULT; 4881 } 4882 } 4883 return 0; 4884 } 4885 4886 static int lancer_fw_download(struct be_adapter *adapter, 4887 const struct firmware *fw) 4888 { 4889 #define LANCER_FW_DOWNLOAD_CHUNK (32 * 1024) 4890 #define LANCER_FW_DOWNLOAD_LOCATION "/prg" 4891 struct device *dev = &adapter->pdev->dev; 4892 struct be_dma_mem flash_cmd; 4893 const u8 *data_ptr = NULL; 4894 u8 *dest_image_ptr = NULL; 4895 size_t image_size = 0; 4896 u32 chunk_size = 0; 4897 u32 data_written = 0; 4898 u32 offset = 0; 4899 int status = 0; 4900 u8 add_status = 0; 4901 u8 change_status; 4902 4903 if (!IS_ALIGNED(fw->size, sizeof(u32))) { 4904 dev_err(dev, "FW image size should be multiple of 4\n"); 4905 return -EINVAL; 4906 } 4907 4908 flash_cmd.size = sizeof(struct lancer_cmd_req_write_object) 4909 + LANCER_FW_DOWNLOAD_CHUNK; 4910 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, 4911 &flash_cmd.dma, GFP_KERNEL); 4912 if (!flash_cmd.va) 4913 return -ENOMEM; 4914 4915 dest_image_ptr = flash_cmd.va + 4916 sizeof(struct lancer_cmd_req_write_object); 4917 image_size = fw->size; 4918 data_ptr = fw->data; 4919 4920 while (image_size) { 4921 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK); 4922 4923 /* Copy the image chunk content. */ 4924 memcpy(dest_image_ptr, data_ptr, chunk_size); 4925 4926 status = lancer_cmd_write_object(adapter, &flash_cmd, 4927 chunk_size, offset, 4928 LANCER_FW_DOWNLOAD_LOCATION, 4929 &data_written, &change_status, 4930 &add_status); 4931 if (status) 4932 break; 4933 4934 offset += data_written; 4935 data_ptr += data_written; 4936 image_size -= data_written; 4937 } 4938 4939 if (!status) { 4940 /* Commit the FW written */ 4941 status = lancer_cmd_write_object(adapter, &flash_cmd, 4942 0, offset, 4943 LANCER_FW_DOWNLOAD_LOCATION, 4944 &data_written, &change_status, 4945 &add_status); 4946 } 4947 4948 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma); 4949 if (status) { 4950 dev_err(dev, "Firmware load error\n"); 4951 return be_cmd_status(status); 4952 } 4953 4954 dev_info(dev, "Firmware flashed successfully\n"); 4955 4956 if (change_status == LANCER_FW_RESET_NEEDED) { 4957 dev_info(dev, "Resetting adapter to activate new FW\n"); 4958 status = lancer_physdev_ctrl(adapter, 4959 PHYSDEV_CONTROL_FW_RESET_MASK); 4960 if (status) { 4961 dev_err(dev, "Adapter busy, could not reset FW\n"); 4962 dev_err(dev, "Reboot server to activate new FW\n"); 4963 } 4964 } else if (change_status != LANCER_NO_RESET_NEEDED) { 4965 dev_info(dev, "Reboot server to activate new FW\n"); 4966 } 4967 4968 return 0; 4969 } 4970 4971 /* Check if the flash image file is compatible with the adapter that 4972 * is being flashed. 4973 */ 4974 static bool be_check_ufi_compatibility(struct be_adapter *adapter, 4975 struct flash_file_hdr_g3 *fhdr) 4976 { 4977 if (!fhdr) { 4978 dev_err(&adapter->pdev->dev, "Invalid FW UFI file"); 4979 return false; 4980 } 4981 4982 /* First letter of the build version is used to identify 4983 * which chip this image file is meant for. 4984 */ 4985 switch (fhdr->build[0]) { 4986 case BLD_STR_UFI_TYPE_SH: 4987 if (!skyhawk_chip(adapter)) 4988 return false; 4989 break; 4990 case BLD_STR_UFI_TYPE_BE3: 4991 if (!BE3_chip(adapter)) 4992 return false; 4993 break; 4994 case BLD_STR_UFI_TYPE_BE2: 4995 if (!BE2_chip(adapter)) 4996 return false; 4997 break; 4998 default: 4999 return false; 5000 } 5001 5002 return (fhdr->asic_type_rev >= adapter->asic_rev); 5003 } 5004 5005 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw) 5006 { 5007 struct device *dev = &adapter->pdev->dev; 5008 struct flash_file_hdr_g3 *fhdr3; 5009 struct image_hdr *img_hdr_ptr; 5010 int status = 0, i, num_imgs; 5011 struct be_dma_mem flash_cmd; 5012 5013 fhdr3 = (struct flash_file_hdr_g3 *)fw->data; 5014 if (!be_check_ufi_compatibility(adapter, fhdr3)) { 5015 dev_err(dev, "Flash image is not compatible with adapter\n"); 5016 return -EINVAL; 5017 } 5018 5019 flash_cmd.size = sizeof(struct be_cmd_write_flashrom); 5020 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma, 5021 GFP_KERNEL); 5022 if (!flash_cmd.va) 5023 return -ENOMEM; 5024 5025 num_imgs = le32_to_cpu(fhdr3->num_imgs); 5026 for (i = 0; i < num_imgs; i++) { 5027 img_hdr_ptr = (struct image_hdr *)(fw->data + 5028 (sizeof(struct flash_file_hdr_g3) + 5029 i * sizeof(struct image_hdr))); 5030 if (!BE2_chip(adapter) && 5031 le32_to_cpu(img_hdr_ptr->imageid) != 1) 5032 continue; 5033 5034 if (skyhawk_chip(adapter)) 5035 status = be_flash_skyhawk(adapter, fw, &flash_cmd, 5036 num_imgs); 5037 else 5038 status = be_flash_BEx(adapter, fw, &flash_cmd, 5039 num_imgs); 5040 } 5041 5042 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma); 5043 if (!status) 5044 dev_info(dev, "Firmware flashed successfully\n"); 5045 5046 return status; 5047 } 5048 5049 int be_load_fw(struct be_adapter *adapter, u8 *fw_file) 5050 { 5051 const struct firmware *fw; 5052 int status; 5053 5054 if (!netif_running(adapter->netdev)) { 5055 dev_err(&adapter->pdev->dev, 5056 "Firmware load not allowed (interface is down)\n"); 5057 return -ENETDOWN; 5058 } 5059 5060 status = request_firmware(&fw, fw_file, &adapter->pdev->dev); 5061 if (status) 5062 goto fw_exit; 5063 5064 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file); 5065 5066 if (lancer_chip(adapter)) 5067 status = lancer_fw_download(adapter, fw); 5068 else 5069 status = be_fw_download(adapter, fw); 5070 5071 if (!status) 5072 be_cmd_get_fw_ver(adapter); 5073 5074 fw_exit: 5075 release_firmware(fw); 5076 return status; 5077 } 5078 5079 static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 5080 u16 flags) 5081 { 5082 struct be_adapter *adapter = netdev_priv(dev); 5083 struct nlattr *attr, *br_spec; 5084 int rem; 5085 int status = 0; 5086 u16 mode = 0; 5087 5088 if (!sriov_enabled(adapter)) 5089 return -EOPNOTSUPP; 5090 5091 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 5092 if (!br_spec) 5093 return -EINVAL; 5094 5095 nla_for_each_nested(attr, br_spec, rem) { 5096 if (nla_type(attr) != IFLA_BRIDGE_MODE) 5097 continue; 5098 5099 if (nla_len(attr) < sizeof(mode)) 5100 return -EINVAL; 5101 5102 mode = nla_get_u16(attr); 5103 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB) 5104 return -EINVAL; 5105 5106 status = be_cmd_set_hsw_config(adapter, 0, 0, 5107 adapter->if_handle, 5108 mode == BRIDGE_MODE_VEPA ? 5109 PORT_FWD_TYPE_VEPA : 5110 PORT_FWD_TYPE_VEB, 0); 5111 if (status) 5112 goto err; 5113 5114 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n", 5115 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB"); 5116 5117 return status; 5118 } 5119 err: 5120 dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n", 5121 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB"); 5122 5123 return status; 5124 } 5125 5126 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 5127 struct net_device *dev, u32 filter_mask, 5128 int nlflags) 5129 { 5130 struct be_adapter *adapter = netdev_priv(dev); 5131 int status = 0; 5132 u8 hsw_mode; 5133 5134 /* BE and Lancer chips support VEB mode only */ 5135 if (BEx_chip(adapter) || lancer_chip(adapter)) { 5136 hsw_mode = PORT_FWD_TYPE_VEB; 5137 } else { 5138 status = be_cmd_get_hsw_config(adapter, NULL, 0, 5139 adapter->if_handle, &hsw_mode, 5140 NULL); 5141 if (status) 5142 return 0; 5143 5144 if (hsw_mode == PORT_FWD_TYPE_PASSTHRU) 5145 return 0; 5146 } 5147 5148 return ndo_dflt_bridge_getlink(skb, pid, seq, dev, 5149 hsw_mode == PORT_FWD_TYPE_VEPA ? 5150 BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB, 5151 0, 0, nlflags, filter_mask, NULL); 5152 } 5153 5154 #ifdef CONFIG_BE2NET_VXLAN 5155 /* VxLAN offload Notes: 5156 * 5157 * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't 5158 * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload 5159 * is expected to work across all types of IP tunnels once exported. Skyhawk 5160 * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN 5161 * offloads in hw_enc_features only when a VxLAN port is added. If other (non 5162 * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for 5163 * those other tunnels are unexported on the fly through ndo_features_check(). 5164 * 5165 * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack 5166 * adds more than one port, disable offloads and don't re-enable them again 5167 * until after all the tunnels are removed. 5168 */ 5169 static void be_add_vxlan_port(struct net_device *netdev, sa_family_t sa_family, 5170 __be16 port) 5171 { 5172 struct be_adapter *adapter = netdev_priv(netdev); 5173 struct device *dev = &adapter->pdev->dev; 5174 int status; 5175 5176 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter)) 5177 return; 5178 5179 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) { 5180 dev_info(dev, 5181 "Only one UDP port supported for VxLAN offloads\n"); 5182 dev_info(dev, "Disabling VxLAN offloads\n"); 5183 adapter->vxlan_port_count++; 5184 goto err; 5185 } 5186 5187 if (adapter->vxlan_port_count++ >= 1) 5188 return; 5189 5190 status = be_cmd_manage_iface(adapter, adapter->if_handle, 5191 OP_CONVERT_NORMAL_TO_TUNNEL); 5192 if (status) { 5193 dev_warn(dev, "Failed to convert normal interface to tunnel\n"); 5194 goto err; 5195 } 5196 5197 status = be_cmd_set_vxlan_port(adapter, port); 5198 if (status) { 5199 dev_warn(dev, "Failed to add VxLAN port\n"); 5200 goto err; 5201 } 5202 adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS; 5203 adapter->vxlan_port = port; 5204 5205 netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 5206 NETIF_F_TSO | NETIF_F_TSO6 | 5207 NETIF_F_GSO_UDP_TUNNEL; 5208 netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL; 5209 netdev->features |= NETIF_F_GSO_UDP_TUNNEL; 5210 5211 dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n", 5212 be16_to_cpu(port)); 5213 return; 5214 err: 5215 be_disable_vxlan_offloads(adapter); 5216 } 5217 5218 static void be_del_vxlan_port(struct net_device *netdev, sa_family_t sa_family, 5219 __be16 port) 5220 { 5221 struct be_adapter *adapter = netdev_priv(netdev); 5222 5223 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter)) 5224 return; 5225 5226 if (adapter->vxlan_port != port) 5227 goto done; 5228 5229 be_disable_vxlan_offloads(adapter); 5230 5231 dev_info(&adapter->pdev->dev, 5232 "Disabled VxLAN offloads for UDP port %d\n", 5233 be16_to_cpu(port)); 5234 done: 5235 adapter->vxlan_port_count--; 5236 } 5237 5238 static netdev_features_t be_features_check(struct sk_buff *skb, 5239 struct net_device *dev, 5240 netdev_features_t features) 5241 { 5242 struct be_adapter *adapter = netdev_priv(dev); 5243 u8 l4_hdr = 0; 5244 5245 /* The code below restricts offload features for some tunneled packets. 5246 * Offload features for normal (non tunnel) packets are unchanged. 5247 */ 5248 if (!skb->encapsulation || 5249 !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)) 5250 return features; 5251 5252 /* It's an encapsulated packet and VxLAN offloads are enabled. We 5253 * should disable tunnel offload features if it's not a VxLAN packet, 5254 * as tunnel offloads have been enabled only for VxLAN. This is done to 5255 * allow other tunneled traffic like GRE work fine while VxLAN 5256 * offloads are configured in Skyhawk-R. 5257 */ 5258 switch (vlan_get_protocol(skb)) { 5259 case htons(ETH_P_IP): 5260 l4_hdr = ip_hdr(skb)->protocol; 5261 break; 5262 case htons(ETH_P_IPV6): 5263 l4_hdr = ipv6_hdr(skb)->nexthdr; 5264 break; 5265 default: 5266 return features; 5267 } 5268 5269 if (l4_hdr != IPPROTO_UDP || 5270 skb->inner_protocol_type != ENCAP_TYPE_ETHER || 5271 skb->inner_protocol != htons(ETH_P_TEB) || 5272 skb_inner_mac_header(skb) - skb_transport_header(skb) != 5273 sizeof(struct udphdr) + sizeof(struct vxlanhdr)) 5274 return features & ~(NETIF_F_ALL_CSUM | NETIF_F_GSO_MASK); 5275 5276 return features; 5277 } 5278 #endif 5279 5280 static int be_get_phys_port_id(struct net_device *dev, 5281 struct netdev_phys_item_id *ppid) 5282 { 5283 int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1; 5284 struct be_adapter *adapter = netdev_priv(dev); 5285 u8 *id; 5286 5287 if (MAX_PHYS_ITEM_ID_LEN < id_len) 5288 return -ENOSPC; 5289 5290 ppid->id[0] = adapter->hba_port_num + 1; 5291 id = &ppid->id[1]; 5292 for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0; 5293 i--, id += CNTL_SERIAL_NUM_WORD_SZ) 5294 memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ); 5295 5296 ppid->id_len = id_len; 5297 5298 return 0; 5299 } 5300 5301 static const struct net_device_ops be_netdev_ops = { 5302 .ndo_open = be_open, 5303 .ndo_stop = be_close, 5304 .ndo_start_xmit = be_xmit, 5305 .ndo_set_rx_mode = be_set_rx_mode, 5306 .ndo_set_mac_address = be_mac_addr_set, 5307 .ndo_change_mtu = be_change_mtu, 5308 .ndo_get_stats64 = be_get_stats64, 5309 .ndo_validate_addr = eth_validate_addr, 5310 .ndo_vlan_rx_add_vid = be_vlan_add_vid, 5311 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid, 5312 .ndo_set_vf_mac = be_set_vf_mac, 5313 .ndo_set_vf_vlan = be_set_vf_vlan, 5314 .ndo_set_vf_rate = be_set_vf_tx_rate, 5315 .ndo_get_vf_config = be_get_vf_config, 5316 .ndo_set_vf_link_state = be_set_vf_link_state, 5317 .ndo_set_vf_spoofchk = be_set_vf_spoofchk, 5318 #ifdef CONFIG_NET_POLL_CONTROLLER 5319 .ndo_poll_controller = be_netpoll, 5320 #endif 5321 .ndo_bridge_setlink = be_ndo_bridge_setlink, 5322 .ndo_bridge_getlink = be_ndo_bridge_getlink, 5323 #ifdef CONFIG_NET_RX_BUSY_POLL 5324 .ndo_busy_poll = be_busy_poll, 5325 #endif 5326 #ifdef CONFIG_BE2NET_VXLAN 5327 .ndo_add_vxlan_port = be_add_vxlan_port, 5328 .ndo_del_vxlan_port = be_del_vxlan_port, 5329 .ndo_features_check = be_features_check, 5330 #endif 5331 .ndo_get_phys_port_id = be_get_phys_port_id, 5332 }; 5333 5334 static void be_netdev_init(struct net_device *netdev) 5335 { 5336 struct be_adapter *adapter = netdev_priv(netdev); 5337 5338 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 | 5339 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM | 5340 NETIF_F_HW_VLAN_CTAG_TX; 5341 if (be_multi_rxq(adapter)) 5342 netdev->hw_features |= NETIF_F_RXHASH; 5343 5344 netdev->features |= netdev->hw_features | 5345 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER; 5346 5347 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 | 5348 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 5349 5350 netdev->priv_flags |= IFF_UNICAST_FLT; 5351 5352 netdev->flags |= IFF_MULTICAST; 5353 5354 netif_set_gso_max_size(netdev, 65535 - ETH_HLEN); 5355 5356 netdev->netdev_ops = &be_netdev_ops; 5357 5358 netdev->ethtool_ops = &be_ethtool_ops; 5359 } 5360 5361 static void be_cleanup(struct be_adapter *adapter) 5362 { 5363 struct net_device *netdev = adapter->netdev; 5364 5365 rtnl_lock(); 5366 netif_device_detach(netdev); 5367 if (netif_running(netdev)) 5368 be_close(netdev); 5369 rtnl_unlock(); 5370 5371 be_clear(adapter); 5372 } 5373 5374 static int be_resume(struct be_adapter *adapter) 5375 { 5376 struct net_device *netdev = adapter->netdev; 5377 int status; 5378 5379 status = be_setup(adapter); 5380 if (status) 5381 return status; 5382 5383 if (netif_running(netdev)) { 5384 status = be_open(netdev); 5385 if (status) 5386 return status; 5387 } 5388 5389 netif_device_attach(netdev); 5390 5391 return 0; 5392 } 5393 5394 static int be_err_recover(struct be_adapter *adapter) 5395 { 5396 struct device *dev = &adapter->pdev->dev; 5397 int status; 5398 5399 status = be_resume(adapter); 5400 if (status) 5401 goto err; 5402 5403 dev_info(dev, "Adapter recovery successful\n"); 5404 return 0; 5405 err: 5406 if (be_physfn(adapter)) 5407 dev_err(dev, "Adapter recovery failed\n"); 5408 else 5409 dev_err(dev, "Re-trying adapter recovery\n"); 5410 5411 return status; 5412 } 5413 5414 static void be_err_detection_task(struct work_struct *work) 5415 { 5416 struct be_adapter *adapter = 5417 container_of(work, struct be_adapter, 5418 be_err_detection_work.work); 5419 int status = 0; 5420 5421 be_detect_error(adapter); 5422 5423 if (be_check_error(adapter, BE_ERROR_HW)) { 5424 be_cleanup(adapter); 5425 5426 /* As of now error recovery support is in Lancer only */ 5427 if (lancer_chip(adapter)) 5428 status = be_err_recover(adapter); 5429 } 5430 5431 /* Always attempt recovery on VFs */ 5432 if (!status || be_virtfn(adapter)) 5433 be_schedule_err_detection(adapter); 5434 } 5435 5436 static void be_log_sfp_info(struct be_adapter *adapter) 5437 { 5438 int status; 5439 5440 status = be_cmd_query_sfp_info(adapter); 5441 if (!status) { 5442 dev_err(&adapter->pdev->dev, 5443 "Unqualified SFP+ detected on %c from %s part no: %s", 5444 adapter->port_name, adapter->phy.vendor_name, 5445 adapter->phy.vendor_pn); 5446 } 5447 adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP; 5448 } 5449 5450 static void be_worker(struct work_struct *work) 5451 { 5452 struct be_adapter *adapter = 5453 container_of(work, struct be_adapter, work.work); 5454 struct be_rx_obj *rxo; 5455 int i; 5456 5457 /* when interrupts are not yet enabled, just reap any pending 5458 * mcc completions 5459 */ 5460 if (!netif_running(adapter->netdev)) { 5461 local_bh_disable(); 5462 be_process_mcc(adapter); 5463 local_bh_enable(); 5464 goto reschedule; 5465 } 5466 5467 if (!adapter->stats_cmd_sent) { 5468 if (lancer_chip(adapter)) 5469 lancer_cmd_get_pport_stats(adapter, 5470 &adapter->stats_cmd); 5471 else 5472 be_cmd_get_stats(adapter, &adapter->stats_cmd); 5473 } 5474 5475 if (be_physfn(adapter) && 5476 MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0) 5477 be_cmd_get_die_temperature(adapter); 5478 5479 for_all_rx_queues(adapter, rxo, i) { 5480 /* Replenish RX-queues starved due to memory 5481 * allocation failures. 5482 */ 5483 if (rxo->rx_post_starved) 5484 be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST); 5485 } 5486 5487 /* EQ-delay update for Skyhawk is done while notifying EQ */ 5488 if (!skyhawk_chip(adapter)) 5489 be_eqd_update(adapter, false); 5490 5491 if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP) 5492 be_log_sfp_info(adapter); 5493 5494 reschedule: 5495 adapter->work_counter++; 5496 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000)); 5497 } 5498 5499 static void be_unmap_pci_bars(struct be_adapter *adapter) 5500 { 5501 if (adapter->csr) 5502 pci_iounmap(adapter->pdev, adapter->csr); 5503 if (adapter->db) 5504 pci_iounmap(adapter->pdev, adapter->db); 5505 } 5506 5507 static int db_bar(struct be_adapter *adapter) 5508 { 5509 if (lancer_chip(adapter) || be_virtfn(adapter)) 5510 return 0; 5511 else 5512 return 4; 5513 } 5514 5515 static int be_roce_map_pci_bars(struct be_adapter *adapter) 5516 { 5517 if (skyhawk_chip(adapter)) { 5518 adapter->roce_db.size = 4096; 5519 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev, 5520 db_bar(adapter)); 5521 adapter->roce_db.total_size = pci_resource_len(adapter->pdev, 5522 db_bar(adapter)); 5523 } 5524 return 0; 5525 } 5526 5527 static int be_map_pci_bars(struct be_adapter *adapter) 5528 { 5529 struct pci_dev *pdev = adapter->pdev; 5530 u8 __iomem *addr; 5531 u32 sli_intf; 5532 5533 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf); 5534 adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >> 5535 SLI_INTF_FAMILY_SHIFT; 5536 adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0; 5537 5538 if (BEx_chip(adapter) && be_physfn(adapter)) { 5539 adapter->csr = pci_iomap(pdev, 2, 0); 5540 if (!adapter->csr) 5541 return -ENOMEM; 5542 } 5543 5544 addr = pci_iomap(pdev, db_bar(adapter), 0); 5545 if (!addr) 5546 goto pci_map_err; 5547 adapter->db = addr; 5548 5549 if (skyhawk_chip(adapter) || BEx_chip(adapter)) { 5550 if (be_physfn(adapter)) { 5551 /* PCICFG is the 2nd BAR in BE2 */ 5552 addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0); 5553 if (!addr) 5554 goto pci_map_err; 5555 adapter->pcicfg = addr; 5556 } else { 5557 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET; 5558 } 5559 } 5560 5561 be_roce_map_pci_bars(adapter); 5562 return 0; 5563 5564 pci_map_err: 5565 dev_err(&pdev->dev, "Error in mapping PCI BARs\n"); 5566 be_unmap_pci_bars(adapter); 5567 return -ENOMEM; 5568 } 5569 5570 static void be_drv_cleanup(struct be_adapter *adapter) 5571 { 5572 struct be_dma_mem *mem = &adapter->mbox_mem_alloced; 5573 struct device *dev = &adapter->pdev->dev; 5574 5575 if (mem->va) 5576 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5577 5578 mem = &adapter->rx_filter; 5579 if (mem->va) 5580 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5581 5582 mem = &adapter->stats_cmd; 5583 if (mem->va) 5584 dma_free_coherent(dev, mem->size, mem->va, mem->dma); 5585 } 5586 5587 /* Allocate and initialize various fields in be_adapter struct */ 5588 static int be_drv_init(struct be_adapter *adapter) 5589 { 5590 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced; 5591 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem; 5592 struct be_dma_mem *rx_filter = &adapter->rx_filter; 5593 struct be_dma_mem *stats_cmd = &adapter->stats_cmd; 5594 struct device *dev = &adapter->pdev->dev; 5595 int status = 0; 5596 5597 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16; 5598 mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size, 5599 &mbox_mem_alloc->dma, 5600 GFP_KERNEL); 5601 if (!mbox_mem_alloc->va) 5602 return -ENOMEM; 5603 5604 mbox_mem_align->size = sizeof(struct be_mcc_mailbox); 5605 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16); 5606 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16); 5607 5608 rx_filter->size = sizeof(struct be_cmd_req_rx_filter); 5609 rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size, 5610 &rx_filter->dma, GFP_KERNEL); 5611 if (!rx_filter->va) { 5612 status = -ENOMEM; 5613 goto free_mbox; 5614 } 5615 5616 if (lancer_chip(adapter)) 5617 stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats); 5618 else if (BE2_chip(adapter)) 5619 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0); 5620 else if (BE3_chip(adapter)) 5621 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1); 5622 else 5623 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2); 5624 stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size, 5625 &stats_cmd->dma, GFP_KERNEL); 5626 if (!stats_cmd->va) { 5627 status = -ENOMEM; 5628 goto free_rx_filter; 5629 } 5630 5631 mutex_init(&adapter->mbox_lock); 5632 spin_lock_init(&adapter->mcc_lock); 5633 spin_lock_init(&adapter->mcc_cq_lock); 5634 init_completion(&adapter->et_cmd_compl); 5635 5636 pci_save_state(adapter->pdev); 5637 5638 INIT_DELAYED_WORK(&adapter->work, be_worker); 5639 INIT_DELAYED_WORK(&adapter->be_err_detection_work, 5640 be_err_detection_task); 5641 5642 adapter->rx_fc = true; 5643 adapter->tx_fc = true; 5644 5645 /* Must be a power of 2 or else MODULO will BUG_ON */ 5646 adapter->be_get_temp_freq = 64; 5647 5648 return 0; 5649 5650 free_rx_filter: 5651 dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma); 5652 free_mbox: 5653 dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va, 5654 mbox_mem_alloc->dma); 5655 return status; 5656 } 5657 5658 static void be_remove(struct pci_dev *pdev) 5659 { 5660 struct be_adapter *adapter = pci_get_drvdata(pdev); 5661 5662 if (!adapter) 5663 return; 5664 5665 be_roce_dev_remove(adapter); 5666 be_intr_set(adapter, false); 5667 5668 be_cancel_err_detection(adapter); 5669 5670 unregister_netdev(adapter->netdev); 5671 5672 be_clear(adapter); 5673 5674 /* tell fw we're done with firing cmds */ 5675 be_cmd_fw_clean(adapter); 5676 5677 be_unmap_pci_bars(adapter); 5678 be_drv_cleanup(adapter); 5679 5680 pci_disable_pcie_error_reporting(pdev); 5681 5682 pci_release_regions(pdev); 5683 pci_disable_device(pdev); 5684 5685 free_netdev(adapter->netdev); 5686 } 5687 5688 static ssize_t be_hwmon_show_temp(struct device *dev, 5689 struct device_attribute *dev_attr, 5690 char *buf) 5691 { 5692 struct be_adapter *adapter = dev_get_drvdata(dev); 5693 5694 /* Unit: millidegree Celsius */ 5695 if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP) 5696 return -EIO; 5697 else 5698 return sprintf(buf, "%u\n", 5699 adapter->hwmon_info.be_on_die_temp * 1000); 5700 } 5701 5702 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, 5703 be_hwmon_show_temp, NULL, 1); 5704 5705 static struct attribute *be_hwmon_attrs[] = { 5706 &sensor_dev_attr_temp1_input.dev_attr.attr, 5707 NULL 5708 }; 5709 5710 ATTRIBUTE_GROUPS(be_hwmon); 5711 5712 static char *mc_name(struct be_adapter *adapter) 5713 { 5714 char *str = ""; /* default */ 5715 5716 switch (adapter->mc_type) { 5717 case UMC: 5718 str = "UMC"; 5719 break; 5720 case FLEX10: 5721 str = "FLEX10"; 5722 break; 5723 case vNIC1: 5724 str = "vNIC-1"; 5725 break; 5726 case nPAR: 5727 str = "nPAR"; 5728 break; 5729 case UFP: 5730 str = "UFP"; 5731 break; 5732 case vNIC2: 5733 str = "vNIC-2"; 5734 break; 5735 default: 5736 str = ""; 5737 } 5738 5739 return str; 5740 } 5741 5742 static inline char *func_name(struct be_adapter *adapter) 5743 { 5744 return be_physfn(adapter) ? "PF" : "VF"; 5745 } 5746 5747 static inline char *nic_name(struct pci_dev *pdev) 5748 { 5749 switch (pdev->device) { 5750 case OC_DEVICE_ID1: 5751 return OC_NAME; 5752 case OC_DEVICE_ID2: 5753 return OC_NAME_BE; 5754 case OC_DEVICE_ID3: 5755 case OC_DEVICE_ID4: 5756 return OC_NAME_LANCER; 5757 case BE_DEVICE_ID2: 5758 return BE3_NAME; 5759 case OC_DEVICE_ID5: 5760 case OC_DEVICE_ID6: 5761 return OC_NAME_SH; 5762 default: 5763 return BE_NAME; 5764 } 5765 } 5766 5767 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id) 5768 { 5769 struct be_adapter *adapter; 5770 struct net_device *netdev; 5771 int status = 0; 5772 5773 dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER); 5774 5775 status = pci_enable_device(pdev); 5776 if (status) 5777 goto do_none; 5778 5779 status = pci_request_regions(pdev, DRV_NAME); 5780 if (status) 5781 goto disable_dev; 5782 pci_set_master(pdev); 5783 5784 netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS); 5785 if (!netdev) { 5786 status = -ENOMEM; 5787 goto rel_reg; 5788 } 5789 adapter = netdev_priv(netdev); 5790 adapter->pdev = pdev; 5791 pci_set_drvdata(pdev, adapter); 5792 adapter->netdev = netdev; 5793 SET_NETDEV_DEV(netdev, &pdev->dev); 5794 5795 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 5796 if (!status) { 5797 netdev->features |= NETIF_F_HIGHDMA; 5798 } else { 5799 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 5800 if (status) { 5801 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n"); 5802 goto free_netdev; 5803 } 5804 } 5805 5806 status = pci_enable_pcie_error_reporting(pdev); 5807 if (!status) 5808 dev_info(&pdev->dev, "PCIe error reporting enabled\n"); 5809 5810 status = be_map_pci_bars(adapter); 5811 if (status) 5812 goto free_netdev; 5813 5814 status = be_drv_init(adapter); 5815 if (status) 5816 goto unmap_bars; 5817 5818 status = be_setup(adapter); 5819 if (status) 5820 goto drv_cleanup; 5821 5822 be_netdev_init(netdev); 5823 status = register_netdev(netdev); 5824 if (status != 0) 5825 goto unsetup; 5826 5827 be_roce_dev_add(adapter); 5828 5829 be_schedule_err_detection(adapter); 5830 5831 /* On Die temperature not supported for VF. */ 5832 if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) { 5833 adapter->hwmon_info.hwmon_dev = 5834 devm_hwmon_device_register_with_groups(&pdev->dev, 5835 DRV_NAME, 5836 adapter, 5837 be_hwmon_groups); 5838 adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP; 5839 } 5840 5841 dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev), 5842 func_name(adapter), mc_name(adapter), adapter->port_name); 5843 5844 return 0; 5845 5846 unsetup: 5847 be_clear(adapter); 5848 drv_cleanup: 5849 be_drv_cleanup(adapter); 5850 unmap_bars: 5851 be_unmap_pci_bars(adapter); 5852 free_netdev: 5853 free_netdev(netdev); 5854 rel_reg: 5855 pci_release_regions(pdev); 5856 disable_dev: 5857 pci_disable_device(pdev); 5858 do_none: 5859 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev)); 5860 return status; 5861 } 5862 5863 static int be_suspend(struct pci_dev *pdev, pm_message_t state) 5864 { 5865 struct be_adapter *adapter = pci_get_drvdata(pdev); 5866 5867 if (adapter->wol_en) 5868 be_setup_wol(adapter, true); 5869 5870 be_intr_set(adapter, false); 5871 be_cancel_err_detection(adapter); 5872 5873 be_cleanup(adapter); 5874 5875 pci_save_state(pdev); 5876 pci_disable_device(pdev); 5877 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 5878 return 0; 5879 } 5880 5881 static int be_pci_resume(struct pci_dev *pdev) 5882 { 5883 struct be_adapter *adapter = pci_get_drvdata(pdev); 5884 int status = 0; 5885 5886 status = pci_enable_device(pdev); 5887 if (status) 5888 return status; 5889 5890 pci_restore_state(pdev); 5891 5892 status = be_resume(adapter); 5893 if (status) 5894 return status; 5895 5896 be_schedule_err_detection(adapter); 5897 5898 if (adapter->wol_en) 5899 be_setup_wol(adapter, false); 5900 5901 return 0; 5902 } 5903 5904 /* 5905 * An FLR will stop BE from DMAing any data. 5906 */ 5907 static void be_shutdown(struct pci_dev *pdev) 5908 { 5909 struct be_adapter *adapter = pci_get_drvdata(pdev); 5910 5911 if (!adapter) 5912 return; 5913 5914 be_roce_dev_shutdown(adapter); 5915 cancel_delayed_work_sync(&adapter->work); 5916 be_cancel_err_detection(adapter); 5917 5918 netif_device_detach(adapter->netdev); 5919 5920 be_cmd_reset_function(adapter); 5921 5922 pci_disable_device(pdev); 5923 } 5924 5925 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev, 5926 pci_channel_state_t state) 5927 { 5928 struct be_adapter *adapter = pci_get_drvdata(pdev); 5929 5930 dev_err(&adapter->pdev->dev, "EEH error detected\n"); 5931 5932 if (!be_check_error(adapter, BE_ERROR_EEH)) { 5933 be_set_error(adapter, BE_ERROR_EEH); 5934 5935 be_cancel_err_detection(adapter); 5936 5937 be_cleanup(adapter); 5938 } 5939 5940 if (state == pci_channel_io_perm_failure) 5941 return PCI_ERS_RESULT_DISCONNECT; 5942 5943 pci_disable_device(pdev); 5944 5945 /* The error could cause the FW to trigger a flash debug dump. 5946 * Resetting the card while flash dump is in progress 5947 * can cause it not to recover; wait for it to finish. 5948 * Wait only for first function as it is needed only once per 5949 * adapter. 5950 */ 5951 if (pdev->devfn == 0) 5952 ssleep(30); 5953 5954 return PCI_ERS_RESULT_NEED_RESET; 5955 } 5956 5957 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev) 5958 { 5959 struct be_adapter *adapter = pci_get_drvdata(pdev); 5960 int status; 5961 5962 dev_info(&adapter->pdev->dev, "EEH reset\n"); 5963 5964 status = pci_enable_device(pdev); 5965 if (status) 5966 return PCI_ERS_RESULT_DISCONNECT; 5967 5968 pci_set_master(pdev); 5969 pci_restore_state(pdev); 5970 5971 /* Check if card is ok and fw is ready */ 5972 dev_info(&adapter->pdev->dev, 5973 "Waiting for FW to be ready after EEH reset\n"); 5974 status = be_fw_wait_ready(adapter); 5975 if (status) 5976 return PCI_ERS_RESULT_DISCONNECT; 5977 5978 pci_cleanup_aer_uncorrect_error_status(pdev); 5979 be_clear_error(adapter, BE_CLEAR_ALL); 5980 return PCI_ERS_RESULT_RECOVERED; 5981 } 5982 5983 static void be_eeh_resume(struct pci_dev *pdev) 5984 { 5985 int status = 0; 5986 struct be_adapter *adapter = pci_get_drvdata(pdev); 5987 5988 dev_info(&adapter->pdev->dev, "EEH resume\n"); 5989 5990 pci_save_state(pdev); 5991 5992 status = be_resume(adapter); 5993 if (status) 5994 goto err; 5995 5996 be_schedule_err_detection(adapter); 5997 return; 5998 err: 5999 dev_err(&adapter->pdev->dev, "EEH resume failed\n"); 6000 } 6001 6002 static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs) 6003 { 6004 struct be_adapter *adapter = pci_get_drvdata(pdev); 6005 u16 num_vf_qs; 6006 int status; 6007 6008 if (!num_vfs) 6009 be_vf_clear(adapter); 6010 6011 adapter->num_vfs = num_vfs; 6012 6013 if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) { 6014 dev_warn(&pdev->dev, 6015 "Cannot disable VFs while they are assigned\n"); 6016 return -EBUSY; 6017 } 6018 6019 /* When the HW is in SRIOV capable configuration, the PF-pool resources 6020 * are equally distributed across the max-number of VFs. The user may 6021 * request only a subset of the max-vfs to be enabled. 6022 * Based on num_vfs, redistribute the resources across num_vfs so that 6023 * each VF will have access to more number of resources. 6024 * This facility is not available in BE3 FW. 6025 * Also, this is done by FW in Lancer chip. 6026 */ 6027 if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) { 6028 num_vf_qs = be_calculate_vf_qs(adapter, adapter->num_vfs); 6029 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 6030 adapter->num_vfs, num_vf_qs); 6031 if (status) 6032 dev_err(&pdev->dev, 6033 "Failed to optimize SR-IOV resources\n"); 6034 } 6035 6036 status = be_get_resources(adapter); 6037 if (status) 6038 return be_cmd_status(status); 6039 6040 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */ 6041 rtnl_lock(); 6042 status = be_update_queues(adapter); 6043 rtnl_unlock(); 6044 if (status) 6045 return be_cmd_status(status); 6046 6047 if (adapter->num_vfs) 6048 status = be_vf_setup(adapter); 6049 6050 if (!status) 6051 return adapter->num_vfs; 6052 6053 return 0; 6054 } 6055 6056 static const struct pci_error_handlers be_eeh_handlers = { 6057 .error_detected = be_eeh_err_detected, 6058 .slot_reset = be_eeh_reset, 6059 .resume = be_eeh_resume, 6060 }; 6061 6062 static struct pci_driver be_driver = { 6063 .name = DRV_NAME, 6064 .id_table = be_dev_ids, 6065 .probe = be_probe, 6066 .remove = be_remove, 6067 .suspend = be_suspend, 6068 .resume = be_pci_resume, 6069 .shutdown = be_shutdown, 6070 .sriov_configure = be_pci_sriov_configure, 6071 .err_handler = &be_eeh_handlers 6072 }; 6073 6074 static int __init be_init_module(void) 6075 { 6076 if (rx_frag_size != 8192 && rx_frag_size != 4096 && 6077 rx_frag_size != 2048) { 6078 printk(KERN_WARNING DRV_NAME 6079 " : Module param rx_frag_size must be 2048/4096/8192." 6080 " Using 2048\n"); 6081 rx_frag_size = 2048; 6082 } 6083 6084 if (num_vfs > 0) { 6085 pr_info(DRV_NAME " : Module param num_vfs is obsolete."); 6086 pr_info(DRV_NAME " : Use sysfs method to enable VFs\n"); 6087 } 6088 6089 return pci_register_driver(&be_driver); 6090 } 6091 module_init(be_init_module); 6092 6093 static void __exit be_exit_module(void) 6094 { 6095 pci_unregister_driver(&be_driver); 6096 } 6097 module_exit(be_exit_module); 6098