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