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