tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

qed: Change metadata needed for SPQ entries

Each configuration element send via ramrod requires a Slow Path Queue
entry. This slightly changes the way such an entry is configured, but
contains mostly semantic changes [where more parameters are gathered
in a sub-struct instead of being directly passed].

Signed-off-by: Yuval Mintz <Yuval.Mintz@qlogic.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Yuval Mintz and committed by
David S. Miller 06f56b81 0a0c5d3b

+95 -107
+64 -75
drivers/net/ethernet/qlogic/qed/qed_l2.c
··· 142 142 u8 drop_ttl0_flg, 143 143 u8 inner_vlan_removal_en_flg) 144 144 { 145 - struct qed_sp_init_request_params params; 146 145 struct vport_start_ramrod_data *p_ramrod = NULL; 147 146 struct qed_spq_entry *p_ent = NULL; 147 + struct qed_sp_init_data init_data; 148 148 int rc = -EINVAL; 149 149 u16 rx_mode = 0; 150 150 u8 abs_vport_id = 0; ··· 153 153 if (rc != 0) 154 154 return rc; 155 155 156 - memset(&params, 0, sizeof(params)); 157 - params.ramrod_data_size = sizeof(*p_ramrod); 158 - params.comp_mode = QED_SPQ_MODE_EBLOCK; 156 + memset(&init_data, 0, sizeof(init_data)); 157 + init_data.cid = qed_spq_get_cid(p_hwfn); 158 + init_data.opaque_fid = opaque_fid; 159 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 159 160 160 161 rc = qed_sp_init_request(p_hwfn, &p_ent, 161 - qed_spq_get_cid(p_hwfn), 162 - opaque_fid, 163 162 ETH_RAMROD_VPORT_START, 164 - PROTOCOLID_ETH, 165 - &params); 163 + PROTOCOLID_ETH, &init_data); 166 164 if (rc) 167 165 return rc; 168 166 ··· 360 362 { 361 363 struct qed_rss_params *p_rss_params = p_params->rss_params; 362 364 struct vport_update_ramrod_data_cmn *p_cmn; 363 - struct qed_sp_init_request_params sp_params; 365 + struct qed_sp_init_data init_data; 364 366 struct vport_update_ramrod_data *p_ramrod = NULL; 365 367 struct qed_spq_entry *p_ent = NULL; 366 368 u8 abs_vport_id = 0; ··· 370 372 if (rc != 0) 371 373 return rc; 372 374 373 - memset(&sp_params, 0, sizeof(sp_params)); 374 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 375 - sp_params.comp_mode = comp_mode; 376 - sp_params.p_comp_data = p_comp_data; 375 + memset(&init_data, 0, sizeof(init_data)); 376 + init_data.cid = qed_spq_get_cid(p_hwfn); 377 + init_data.opaque_fid = p_params->opaque_fid; 378 + init_data.comp_mode = comp_mode; 379 + init_data.p_comp_data = p_comp_data; 377 380 378 381 rc = qed_sp_init_request(p_hwfn, &p_ent, 379 - qed_spq_get_cid(p_hwfn), 380 - p_params->opaque_fid, 381 382 ETH_RAMROD_VPORT_UPDATE, 382 - PROTOCOLID_ETH, 383 - &sp_params); 383 + PROTOCOLID_ETH, &init_data); 384 384 if (rc) 385 385 return rc; 386 386 ··· 412 416 u16 opaque_fid, 413 417 u8 vport_id) 414 418 { 415 - struct qed_sp_init_request_params sp_params; 416 419 struct vport_stop_ramrod_data *p_ramrod; 420 + struct qed_sp_init_data init_data; 417 421 struct qed_spq_entry *p_ent; 418 422 u8 abs_vport_id = 0; 419 423 int rc; ··· 422 426 if (rc != 0) 423 427 return rc; 424 428 425 - memset(&sp_params, 0, sizeof(sp_params)); 426 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 427 - sp_params.comp_mode = QED_SPQ_MODE_EBLOCK; 429 + memset(&init_data, 0, sizeof(init_data)); 430 + init_data.cid = qed_spq_get_cid(p_hwfn); 431 + init_data.opaque_fid = opaque_fid; 432 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 428 433 429 434 rc = qed_sp_init_request(p_hwfn, &p_ent, 430 - qed_spq_get_cid(p_hwfn), 431 - opaque_fid, 432 435 ETH_RAMROD_VPORT_STOP, 433 - PROTOCOLID_ETH, 434 - &sp_params); 436 + PROTOCOLID_ETH, &init_data); 435 437 if (rc) 436 438 return rc; 437 439 ··· 508 514 u16 cqe_pbl_size) 509 515 { 510 516 struct rx_queue_start_ramrod_data *p_ramrod = NULL; 511 - struct qed_sp_init_request_params sp_params; 512 517 struct qed_spq_entry *p_ent = NULL; 518 + struct qed_sp_init_data init_data; 513 519 struct qed_hw_cid_data *p_rx_cid; 514 520 u16 abs_rx_q_id = 0; 515 521 u8 abs_vport_id = 0; ··· 534 540 opaque_fid, cid, params->queue_id, params->vport_id, 535 541 params->sb); 536 542 537 - memset(&sp_params, 0, sizeof(params)); 538 - sp_params.comp_mode = QED_SPQ_MODE_EBLOCK; 539 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 543 + /* Get SPQ entry */ 544 + memset(&init_data, 0, sizeof(init_data)); 545 + init_data.cid = cid; 546 + init_data.opaque_fid = opaque_fid; 547 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 540 548 541 549 rc = qed_sp_init_request(p_hwfn, &p_ent, 542 - cid, opaque_fid, 543 550 ETH_RAMROD_RX_QUEUE_START, 544 - PROTOCOLID_ETH, 545 - &sp_params); 551 + PROTOCOLID_ETH, &init_data); 546 552 if (rc) 547 553 return rc; 548 554 ··· 634 640 { 635 641 struct qed_hw_cid_data *p_rx_cid = &p_hwfn->p_rx_cids[rx_queue_id]; 636 642 struct rx_queue_stop_ramrod_data *p_ramrod = NULL; 637 - struct qed_sp_init_request_params sp_params; 638 643 struct qed_spq_entry *p_ent = NULL; 644 + struct qed_sp_init_data init_data; 639 645 u16 abs_rx_q_id = 0; 640 646 int rc = -EINVAL; 641 647 642 - memset(&sp_params, 0, sizeof(sp_params)); 643 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 644 - sp_params.comp_mode = QED_SPQ_MODE_EBLOCK; 648 + /* Get SPQ entry */ 649 + memset(&init_data, 0, sizeof(init_data)); 650 + init_data.cid = p_rx_cid->cid; 651 + init_data.opaque_fid = p_rx_cid->opaque_fid; 652 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 645 653 646 654 rc = qed_sp_init_request(p_hwfn, &p_ent, 647 - p_rx_cid->cid, 648 - p_rx_cid->opaque_fid, 649 655 ETH_RAMROD_RX_QUEUE_STOP, 650 - PROTOCOLID_ETH, 651 - &sp_params); 656 + PROTOCOLID_ETH, &init_data); 652 657 if (rc) 653 658 return rc; 654 659 ··· 685 692 union qed_qm_pq_params *p_pq_params) 686 693 { 687 694 struct tx_queue_start_ramrod_data *p_ramrod = NULL; 688 - struct qed_sp_init_request_params sp_params; 689 695 struct qed_spq_entry *p_ent = NULL; 696 + struct qed_sp_init_data init_data; 690 697 struct qed_hw_cid_data *p_tx_cid; 691 698 u8 abs_vport_id; 692 699 int rc = -EINVAL; ··· 701 708 if (rc) 702 709 return rc; 703 710 704 - memset(&sp_params, 0, sizeof(sp_params)); 705 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 706 - sp_params.comp_mode = QED_SPQ_MODE_EBLOCK; 711 + /* Get SPQ entry */ 712 + memset(&init_data, 0, sizeof(init_data)); 713 + init_data.cid = cid; 714 + init_data.opaque_fid = opaque_fid; 715 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 707 716 708 - rc = qed_sp_init_request(p_hwfn, &p_ent, cid, 709 - opaque_fid, 717 + rc = qed_sp_init_request(p_hwfn, &p_ent, 710 718 ETH_RAMROD_TX_QUEUE_START, 711 - PROTOCOLID_ETH, 712 - &sp_params); 719 + PROTOCOLID_ETH, &init_data); 713 720 if (rc) 714 721 return rc; 715 722 ··· 789 796 u16 tx_queue_id) 790 797 { 791 798 struct qed_hw_cid_data *p_tx_cid = &p_hwfn->p_tx_cids[tx_queue_id]; 792 - struct qed_sp_init_request_params sp_params; 793 799 struct qed_spq_entry *p_ent = NULL; 800 + struct qed_sp_init_data init_data; 794 801 int rc = -EINVAL; 795 802 796 - memset(&sp_params, 0, sizeof(sp_params)); 797 - sp_params.ramrod_data_size = sizeof(struct tx_queue_stop_ramrod_data); 798 - sp_params.comp_mode = QED_SPQ_MODE_EBLOCK; 803 + /* Get SPQ entry */ 804 + memset(&init_data, 0, sizeof(init_data)); 805 + init_data.cid = p_tx_cid->cid; 806 + init_data.opaque_fid = p_tx_cid->opaque_fid; 807 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 799 808 800 809 rc = qed_sp_init_request(p_hwfn, &p_ent, 801 - p_tx_cid->cid, 802 - p_tx_cid->opaque_fid, 803 810 ETH_RAMROD_TX_QUEUE_STOP, 804 - PROTOCOLID_ETH, 805 - &sp_params); 811 + PROTOCOLID_ETH, &init_data); 806 812 if (rc) 807 813 return rc; 808 814 ··· 858 866 { 859 867 u8 vport_to_add_to = 0, vport_to_remove_from = 0; 860 868 struct vport_filter_update_ramrod_data *p_ramrod; 861 - struct qed_sp_init_request_params sp_params; 862 869 struct eth_filter_cmd *p_first_filter; 863 870 struct eth_filter_cmd *p_second_filter; 871 + struct qed_sp_init_data init_data; 864 872 enum eth_filter_action action; 865 873 int rc; 866 874 ··· 874 882 if (rc) 875 883 return rc; 876 884 877 - memset(&sp_params, 0, sizeof(sp_params)); 878 - sp_params.ramrod_data_size = sizeof(**pp_ramrod); 879 - sp_params.comp_mode = comp_mode; 880 - sp_params.p_comp_data = p_comp_data; 885 + /* Get SPQ entry */ 886 + memset(&init_data, 0, sizeof(init_data)); 887 + init_data.cid = qed_spq_get_cid(p_hwfn); 888 + init_data.opaque_fid = opaque_fid; 889 + init_data.comp_mode = comp_mode; 890 + init_data.p_comp_data = p_comp_data; 881 891 882 892 rc = qed_sp_init_request(p_hwfn, pp_ent, 883 - qed_spq_get_cid(p_hwfn), 884 - opaque_fid, 885 893 ETH_RAMROD_FILTERS_UPDATE, 886 - PROTOCOLID_ETH, 887 - &sp_params); 894 + PROTOCOLID_ETH, &init_data); 888 895 if (rc) 889 896 return rc; 890 897 ··· 1107 1116 { 1108 1117 unsigned long bins[ETH_MULTICAST_MAC_BINS_IN_REGS]; 1109 1118 struct vport_update_ramrod_data *p_ramrod = NULL; 1110 - struct qed_sp_init_request_params sp_params; 1111 1119 struct qed_spq_entry *p_ent = NULL; 1120 + struct qed_sp_init_data init_data; 1112 1121 u8 abs_vport_id = 0; 1113 1122 int rc, i; 1114 1123 ··· 1124 1133 return rc; 1125 1134 } 1126 1135 1127 - memset(&sp_params, 0, sizeof(sp_params)); 1128 - sp_params.ramrod_data_size = sizeof(*p_ramrod); 1129 - sp_params.comp_mode = comp_mode; 1130 - sp_params.p_comp_data = p_comp_data; 1136 + /* Get SPQ entry */ 1137 + memset(&init_data, 0, sizeof(init_data)); 1138 + init_data.cid = qed_spq_get_cid(p_hwfn); 1139 + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; 1140 + init_data.comp_mode = comp_mode; 1141 + init_data.p_comp_data = p_comp_data; 1131 1142 1132 1143 rc = qed_sp_init_request(p_hwfn, &p_ent, 1133 - qed_spq_get_cid(p_hwfn), 1134 - p_hwfn->hw_info.opaque_fid, 1135 1144 ETH_RAMROD_VPORT_UPDATE, 1136 - PROTOCOLID_ETH, 1137 - &sp_params); 1138 - 1145 + PROTOCOLID_ETH, &init_data); 1139 1146 if (rc) { 1140 1147 DP_ERR(p_hwfn, "Multi-cast command failed %d\n", rc); 1141 1148 return rc;
+6 -5
drivers/net/ethernet/qlogic/qed/qed_sp.h
··· 311 311 #define QED_SP_EQ_COMPLETION 0x01 312 312 #define QED_SP_CQE_COMPLETION 0x02 313 313 314 - struct qed_sp_init_request_params { 315 - size_t ramrod_data_size; 314 + struct qed_sp_init_data { 315 + u32 cid; 316 + u16 opaque_fid; 317 + 318 + /* Information regarding operation upon sending & completion */ 316 319 enum spq_mode comp_mode; 317 320 struct qed_spq_comp_cb *p_comp_data; 318 321 }; 319 322 320 323 int qed_sp_init_request(struct qed_hwfn *p_hwfn, 321 324 struct qed_spq_entry **pp_ent, 322 - u32 cid, 323 - u16 opaque_fid, 324 325 u8 cmd, 325 326 u8 protocol, 326 - struct qed_sp_init_request_params *p_params); 327 + struct qed_sp_init_data *p_data); 327 328 328 329 /** 329 330 * @brief qed_sp_pf_start - PF Function Start Ramrod
+25 -27
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c
··· 23 23 24 24 int qed_sp_init_request(struct qed_hwfn *p_hwfn, 25 25 struct qed_spq_entry **pp_ent, 26 - u32 cid, 27 - u16 opaque_fid, 28 26 u8 cmd, 29 27 u8 protocol, 30 - struct qed_sp_init_request_params *p_params) 28 + struct qed_sp_init_data *p_data) 31 29 { 32 - int rc = -EINVAL; 30 + u32 opaque_cid = p_data->opaque_fid << 16 | p_data->cid; 33 31 struct qed_spq_entry *p_ent = NULL; 34 - u32 opaque_cid = opaque_fid << 16 | cid; 32 + int rc; 35 33 36 34 if (!pp_ent) 37 35 return -ENOMEM; ··· 46 48 p_ent->elem.hdr.protocol_id = protocol; 47 49 48 50 p_ent->priority = QED_SPQ_PRIORITY_NORMAL; 49 - p_ent->comp_mode = p_params->comp_mode; 51 + p_ent->comp_mode = p_data->comp_mode; 50 52 p_ent->comp_done.done = 0; 51 53 52 54 switch (p_ent->comp_mode) { ··· 55 57 break; 56 58 57 59 case QED_SPQ_MODE_BLOCK: 58 - if (!p_params->p_comp_data) 60 + if (!p_data->p_comp_data) 59 61 return -EINVAL; 60 62 61 - p_ent->comp_cb.cookie = p_params->p_comp_data->cookie; 63 + p_ent->comp_cb.cookie = p_data->p_comp_data->cookie; 62 64 break; 63 65 64 66 case QED_SPQ_MODE_CB: 65 - if (!p_params->p_comp_data) 67 + if (!p_data->p_comp_data) 66 68 p_ent->comp_cb.function = NULL; 67 69 else 68 - p_ent->comp_cb = *p_params->p_comp_data; 70 + p_ent->comp_cb = *p_data->p_comp_data; 69 71 break; 70 72 71 73 default: ··· 81 83 D_TRINE(p_ent->comp_mode, QED_SPQ_MODE_EBLOCK, 82 84 QED_SPQ_MODE_BLOCK, "MODE_EBLOCK", "MODE_BLOCK", 83 85 "MODE_CB")); 84 - if (p_params->ramrod_data_size) 85 - memset(&p_ent->ramrod, 0, p_params->ramrod_data_size); 86 + 87 + memset(&p_ent->ramrod, 0, sizeof(p_ent->ramrod)); 86 88 87 89 return 0; 88 90 } ··· 90 92 int qed_sp_pf_start(struct qed_hwfn *p_hwfn, 91 93 enum qed_mf_mode mode) 92 94 { 93 - struct qed_sp_init_request_params params; 94 95 struct pf_start_ramrod_data *p_ramrod = NULL; 95 96 u16 sb = qed_int_get_sp_sb_id(p_hwfn); 96 97 u8 sb_index = p_hwfn->p_eq->eq_sb_index; 97 98 struct qed_spq_entry *p_ent = NULL; 99 + struct qed_sp_init_data init_data; 98 100 int rc = -EINVAL; 99 101 100 102 /* update initial eq producer */ 101 103 qed_eq_prod_update(p_hwfn, 102 104 qed_chain_get_prod_idx(&p_hwfn->p_eq->chain)); 103 105 104 - memset(&params, 0, sizeof(params)); 105 - params.ramrod_data_size = sizeof(*p_ramrod); 106 - params.comp_mode = QED_SPQ_MODE_EBLOCK; 106 + memset(&init_data, 0, sizeof(init_data)); 107 + init_data.cid = qed_spq_get_cid(p_hwfn); 108 + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; 109 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 107 110 108 - rc = qed_sp_init_request(p_hwfn, 109 - &p_ent, 110 - qed_spq_get_cid(p_hwfn), 111 - p_hwfn->hw_info.opaque_fid, 111 + rc = qed_sp_init_request(p_hwfn, &p_ent, 112 112 COMMON_RAMROD_PF_START, 113 113 PROTOCOLID_COMMON, 114 - &params); 114 + &init_data); 115 115 if (rc) 116 116 return rc; 117 117 ··· 159 163 160 164 int qed_sp_pf_stop(struct qed_hwfn *p_hwfn) 161 165 { 162 - struct qed_sp_init_request_params params; 163 166 struct qed_spq_entry *p_ent = NULL; 167 + struct qed_sp_init_data init_data; 164 168 int rc = -EINVAL; 165 169 166 - memset(&params, 0, sizeof(params)); 167 - params.comp_mode = QED_SPQ_MODE_EBLOCK; 170 + /* Get SPQ entry */ 171 + memset(&init_data, 0, sizeof(init_data)); 172 + init_data.cid = qed_spq_get_cid(p_hwfn); 173 + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; 174 + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; 168 175 169 - rc = qed_sp_init_request(p_hwfn, &p_ent, qed_spq_get_cid(p_hwfn), 170 - p_hwfn->hw_info.opaque_fid, 176 + rc = qed_sp_init_request(p_hwfn, &p_ent, 171 177 COMMON_RAMROD_PF_STOP, PROTOCOLID_COMMON, 172 - &params); 178 + &init_data); 173 179 if (rc) 174 180 return rc; 175 181