1fe56b9e6SYuval Mintz /* QLogic qed NIC Driver 2e8f1cb50SMintz, Yuval * Copyright (c) 2015-2017 QLogic Corporation 3fe56b9e6SYuval Mintz * 4e8f1cb50SMintz, Yuval * This software is available to you under a choice of one of two 5e8f1cb50SMintz, Yuval * licenses. You may choose to be licensed under the terms of the GNU 6e8f1cb50SMintz, Yuval * General Public License (GPL) Version 2, available from the file 7e8f1cb50SMintz, Yuval * COPYING in the main directory of this source tree, or the 8e8f1cb50SMintz, Yuval * OpenIB.org BSD license below: 9e8f1cb50SMintz, Yuval * 10e8f1cb50SMintz, Yuval * Redistribution and use in source and binary forms, with or 11e8f1cb50SMintz, Yuval * without modification, are permitted provided that the following 12e8f1cb50SMintz, Yuval * conditions are met: 13e8f1cb50SMintz, Yuval * 14e8f1cb50SMintz, Yuval * - Redistributions of source code must retain the above 15e8f1cb50SMintz, Yuval * copyright notice, this list of conditions and the following 16e8f1cb50SMintz, Yuval * disclaimer. 17e8f1cb50SMintz, Yuval * 18e8f1cb50SMintz, Yuval * - Redistributions in binary form must reproduce the above 19e8f1cb50SMintz, Yuval * copyright notice, this list of conditions and the following 20e8f1cb50SMintz, Yuval * disclaimer in the documentation and /or other materials 21e8f1cb50SMintz, Yuval * provided with the distribution. 22e8f1cb50SMintz, Yuval * 23e8f1cb50SMintz, Yuval * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24e8f1cb50SMintz, Yuval * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25e8f1cb50SMintz, Yuval * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26e8f1cb50SMintz, Yuval * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27e8f1cb50SMintz, Yuval * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28e8f1cb50SMintz, Yuval * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29e8f1cb50SMintz, Yuval * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30e8f1cb50SMintz, Yuval * SOFTWARE. 31fe56b9e6SYuval Mintz */ 32fe56b9e6SYuval Mintz 33fe56b9e6SYuval Mintz #include <linux/types.h> 34fe56b9e6SYuval Mintz #include <linux/bitops.h> 35fe56b9e6SYuval Mintz #include <linux/dma-mapping.h> 36fe56b9e6SYuval Mintz #include <linux/errno.h> 37fe56b9e6SYuval Mintz #include <linux/kernel.h> 38fe56b9e6SYuval Mintz #include <linux/list.h> 39fe56b9e6SYuval Mintz #include <linux/log2.h> 40fe56b9e6SYuval Mintz #include <linux/pci.h> 41fe56b9e6SYuval Mintz #include <linux/slab.h> 42fe56b9e6SYuval Mintz #include <linux/string.h> 43fe56b9e6SYuval Mintz #include <linux/bitops.h> 44fe56b9e6SYuval Mintz #include "qed.h" 45fe56b9e6SYuval Mintz #include "qed_cxt.h" 46fe56b9e6SYuval Mintz #include "qed_dev_api.h" 47fe56b9e6SYuval Mintz #include "qed_hsi.h" 48fe56b9e6SYuval Mintz #include "qed_hw.h" 49fe56b9e6SYuval Mintz #include "qed_init_ops.h" 50fe56b9e6SYuval Mintz #include "qed_reg_addr.h" 511408cc1fSYuval Mintz #include "qed_sriov.h" 52fe56b9e6SYuval Mintz 53fe56b9e6SYuval Mintz /* Max number of connection types in HW (DQ/CDU etc.) */ 54fe56b9e6SYuval Mintz #define MAX_CONN_TYPES PROTOCOLID_COMMON 55fe56b9e6SYuval Mintz #define NUM_TASK_TYPES 2 56fe56b9e6SYuval Mintz #define NUM_TASK_PF_SEGMENTS 4 571408cc1fSYuval Mintz #define NUM_TASK_VF_SEGMENTS 1 58fe56b9e6SYuval Mintz 59fe56b9e6SYuval Mintz /* QM constants */ 60fe56b9e6SYuval Mintz #define QM_PQ_ELEMENT_SIZE 4 /* in bytes */ 61fe56b9e6SYuval Mintz 62fe56b9e6SYuval Mintz /* Doorbell-Queue constants */ 63fe56b9e6SYuval Mintz #define DQ_RANGE_SHIFT 4 64fe56b9e6SYuval Mintz #define DQ_RANGE_ALIGN BIT(DQ_RANGE_SHIFT) 65fe56b9e6SYuval Mintz 66dbb799c3SYuval Mintz /* Searcher constants */ 67dbb799c3SYuval Mintz #define SRC_MIN_NUM_ELEMS 256 68dbb799c3SYuval Mintz 69dbb799c3SYuval Mintz /* Timers constants */ 70dbb799c3SYuval Mintz #define TM_SHIFT 7 71dbb799c3SYuval Mintz #define TM_ALIGN BIT(TM_SHIFT) 72dbb799c3SYuval Mintz #define TM_ELEM_SIZE 4 73dbb799c3SYuval Mintz 7451ff1725SRam Amrani /* For RoCE we configure to 64K to cover for RoCE max tasks 256K purpose. */ 750189efb8SYuval Mintz #define ILT_DEFAULT_HW_P_SIZE (IS_ENABLED(CONFIG_QED_RDMA) ? 4 : 3) 7651ff1725SRam Amrani 77fe56b9e6SYuval Mintz #define ILT_PAGE_IN_BYTES(hw_p_size) (1U << ((hw_p_size) + 12)) 78fe56b9e6SYuval Mintz #define ILT_CFG_REG(cli, reg) PSWRQ2_REG_ ## cli ## _ ## reg ## _RT_OFFSET 79fe56b9e6SYuval Mintz 80fe56b9e6SYuval Mintz /* ILT entry structure */ 81fe56b9e6SYuval Mintz #define ILT_ENTRY_PHY_ADDR_MASK 0x000FFFFFFFFFFFULL 82fe56b9e6SYuval Mintz #define ILT_ENTRY_PHY_ADDR_SHIFT 0 83fe56b9e6SYuval Mintz #define ILT_ENTRY_VALID_MASK 0x1ULL 84fe56b9e6SYuval Mintz #define ILT_ENTRY_VALID_SHIFT 52 85fe56b9e6SYuval Mintz #define ILT_ENTRY_IN_REGS 2 86fe56b9e6SYuval Mintz #define ILT_REG_SIZE_IN_BYTES 4 87fe56b9e6SYuval Mintz 88fe56b9e6SYuval Mintz /* connection context union */ 89fe56b9e6SYuval Mintz union conn_context { 90fe56b9e6SYuval Mintz struct core_conn_context core_ctx; 91fe56b9e6SYuval Mintz struct eth_conn_context eth_ctx; 92dbb799c3SYuval Mintz struct iscsi_conn_context iscsi_ctx; 931e128c81SArun Easi struct fcoe_conn_context fcoe_ctx; 94dbb799c3SYuval Mintz struct roce_conn_context roce_ctx; 95fe56b9e6SYuval Mintz }; 96fe56b9e6SYuval Mintz 971e128c81SArun Easi /* TYPE-0 task context - iSCSI, FCOE */ 98dbb799c3SYuval Mintz union type0_task_context { 99dbb799c3SYuval Mintz struct iscsi_task_context iscsi_ctx; 1001e128c81SArun Easi struct fcoe_task_context fcoe_ctx; 101dbb799c3SYuval Mintz }; 102dbb799c3SYuval Mintz 103dbb799c3SYuval Mintz /* TYPE-1 task context - ROCE */ 104dbb799c3SYuval Mintz union type1_task_context { 105dbb799c3SYuval Mintz struct rdma_task_context roce_ctx; 106dbb799c3SYuval Mintz }; 107dbb799c3SYuval Mintz 108dbb799c3SYuval Mintz struct src_ent { 109dbb799c3SYuval Mintz u8 opaque[56]; 110dbb799c3SYuval Mintz u64 next; 111dbb799c3SYuval Mintz }; 112dbb799c3SYuval Mintz 113dbb799c3SYuval Mintz #define CDUT_SEG_ALIGNMET 3 /* in 4k chunks */ 114dbb799c3SYuval Mintz #define CDUT_SEG_ALIGNMET_IN_BYTES (1 << (CDUT_SEG_ALIGNMET + 12)) 115dbb799c3SYuval Mintz 116fe56b9e6SYuval Mintz #define CONN_CXT_SIZE(p_hwfn) \ 117fe56b9e6SYuval Mintz ALIGNED_TYPE_SIZE(union conn_context, p_hwfn) 118fe56b9e6SYuval Mintz 119dbb799c3SYuval Mintz #define SRQ_CXT_SIZE (sizeof(struct rdma_srq_context)) 120dbb799c3SYuval Mintz 121dbb799c3SYuval Mintz #define TYPE0_TASK_CXT_SIZE(p_hwfn) \ 122dbb799c3SYuval Mintz ALIGNED_TYPE_SIZE(union type0_task_context, p_hwfn) 123dbb799c3SYuval Mintz 124dbb799c3SYuval Mintz /* Alignment is inherent to the type1_task_context structure */ 125dbb799c3SYuval Mintz #define TYPE1_TASK_CXT_SIZE(p_hwfn) sizeof(union type1_task_context) 126dbb799c3SYuval Mintz 127fe56b9e6SYuval Mintz /* PF per protocl configuration object */ 128dbb799c3SYuval Mintz #define TASK_SEGMENTS (NUM_TASK_PF_SEGMENTS + NUM_TASK_VF_SEGMENTS) 129dbb799c3SYuval Mintz #define TASK_SEGMENT_VF (NUM_TASK_PF_SEGMENTS) 130dbb799c3SYuval Mintz 131dbb799c3SYuval Mintz struct qed_tid_seg { 132dbb799c3SYuval Mintz u32 count; 133dbb799c3SYuval Mintz u8 type; 134dbb799c3SYuval Mintz bool has_fl_mem; 135dbb799c3SYuval Mintz }; 136dbb799c3SYuval Mintz 137fe56b9e6SYuval Mintz struct qed_conn_type_cfg { 138fe56b9e6SYuval Mintz u32 cid_count; 139fe56b9e6SYuval Mintz u32 cid_start; 1401408cc1fSYuval Mintz u32 cids_per_vf; 141dbb799c3SYuval Mintz struct qed_tid_seg tid_seg[TASK_SEGMENTS]; 142fe56b9e6SYuval Mintz }; 143fe56b9e6SYuval Mintz 144fe56b9e6SYuval Mintz /* ILT Client configuration, Per connection type (protocol) resources. */ 145fe56b9e6SYuval Mintz #define ILT_CLI_PF_BLOCKS (1 + NUM_TASK_PF_SEGMENTS * 2) 1461408cc1fSYuval Mintz #define ILT_CLI_VF_BLOCKS (1 + NUM_TASK_VF_SEGMENTS * 2) 147fe56b9e6SYuval Mintz #define CDUC_BLK (0) 148dbb799c3SYuval Mintz #define SRQ_BLK (0) 149dbb799c3SYuval Mintz #define CDUT_SEG_BLK(n) (1 + (u8)(n)) 150dbb799c3SYuval Mintz #define CDUT_FL_SEG_BLK(n, X) (1 + (n) + NUM_TASK_ ## X ## _SEGMENTS) 151fe56b9e6SYuval Mintz 152fe56b9e6SYuval Mintz enum ilt_clients { 153fe56b9e6SYuval Mintz ILT_CLI_CDUC, 154dbb799c3SYuval Mintz ILT_CLI_CDUT, 155fe56b9e6SYuval Mintz ILT_CLI_QM, 156dbb799c3SYuval Mintz ILT_CLI_TM, 157dbb799c3SYuval Mintz ILT_CLI_SRC, 158dbb799c3SYuval Mintz ILT_CLI_TSDM, 159fe56b9e6SYuval Mintz ILT_CLI_MAX 160fe56b9e6SYuval Mintz }; 161fe56b9e6SYuval Mintz 162fe56b9e6SYuval Mintz struct ilt_cfg_pair { 163fe56b9e6SYuval Mintz u32 reg; 164fe56b9e6SYuval Mintz u32 val; 165fe56b9e6SYuval Mintz }; 166fe56b9e6SYuval Mintz 167fe56b9e6SYuval Mintz struct qed_ilt_cli_blk { 168fe56b9e6SYuval Mintz u32 total_size; /* 0 means not active */ 169fe56b9e6SYuval Mintz u32 real_size_in_page; 170fe56b9e6SYuval Mintz u32 start_line; 171dbb799c3SYuval Mintz u32 dynamic_line_cnt; 172fe56b9e6SYuval Mintz }; 173fe56b9e6SYuval Mintz 174fe56b9e6SYuval Mintz struct qed_ilt_client_cfg { 175fe56b9e6SYuval Mintz bool active; 176fe56b9e6SYuval Mintz 177fe56b9e6SYuval Mintz /* ILT boundaries */ 178fe56b9e6SYuval Mintz struct ilt_cfg_pair first; 179fe56b9e6SYuval Mintz struct ilt_cfg_pair last; 180fe56b9e6SYuval Mintz struct ilt_cfg_pair p_size; 181fe56b9e6SYuval Mintz 182fe56b9e6SYuval Mintz /* ILT client blocks for PF */ 183fe56b9e6SYuval Mintz struct qed_ilt_cli_blk pf_blks[ILT_CLI_PF_BLOCKS]; 184fe56b9e6SYuval Mintz u32 pf_total_lines; 1851408cc1fSYuval Mintz 1861408cc1fSYuval Mintz /* ILT client blocks for VFs */ 1871408cc1fSYuval Mintz struct qed_ilt_cli_blk vf_blks[ILT_CLI_VF_BLOCKS]; 1881408cc1fSYuval Mintz u32 vf_total_lines; 189fe56b9e6SYuval Mintz }; 190fe56b9e6SYuval Mintz 191fe56b9e6SYuval Mintz /* Per Path - 192fe56b9e6SYuval Mintz * ILT shadow table 193fe56b9e6SYuval Mintz * Protocol acquired CID lists 194fe56b9e6SYuval Mintz * PF start line in ILT 195fe56b9e6SYuval Mintz */ 196fe56b9e6SYuval Mintz struct qed_dma_mem { 197fe56b9e6SYuval Mintz dma_addr_t p_phys; 198fe56b9e6SYuval Mintz void *p_virt; 199fe56b9e6SYuval Mintz size_t size; 200fe56b9e6SYuval Mintz }; 201fe56b9e6SYuval Mintz 202fe56b9e6SYuval Mintz struct qed_cid_acquired_map { 203fe56b9e6SYuval Mintz u32 start_cid; 204fe56b9e6SYuval Mintz u32 max_count; 205fe56b9e6SYuval Mintz unsigned long *cid_map; 206fe56b9e6SYuval Mintz }; 207fe56b9e6SYuval Mintz 208fe56b9e6SYuval Mintz struct qed_cxt_mngr { 209fe56b9e6SYuval Mintz /* Per protocl configuration */ 210fe56b9e6SYuval Mintz struct qed_conn_type_cfg conn_cfg[MAX_CONN_TYPES]; 211fe56b9e6SYuval Mintz 212fe56b9e6SYuval Mintz /* computed ILT structure */ 213fe56b9e6SYuval Mintz struct qed_ilt_client_cfg clients[ILT_CLI_MAX]; 214fe56b9e6SYuval Mintz 215dbb799c3SYuval Mintz /* Task type sizes */ 216dbb799c3SYuval Mintz u32 task_type_size[NUM_TASK_TYPES]; 217dbb799c3SYuval Mintz 2181408cc1fSYuval Mintz /* total number of VFs for this hwfn - 2191408cc1fSYuval Mintz * ALL VFs are symmetric in terms of HW resources 2201408cc1fSYuval Mintz */ 2211408cc1fSYuval Mintz u32 vf_count; 2221408cc1fSYuval Mintz 223dbb799c3SYuval Mintz /* total number of SRQ's for this hwfn */ 224dbb799c3SYuval Mintz u32 srq_count; 225dbb799c3SYuval Mintz 226fe56b9e6SYuval Mintz /* Acquired CIDs */ 227fe56b9e6SYuval Mintz struct qed_cid_acquired_map acquired[MAX_CONN_TYPES]; 228fe56b9e6SYuval Mintz 229fe56b9e6SYuval Mintz /* ILT shadow table */ 230fe56b9e6SYuval Mintz struct qed_dma_mem *ilt_shadow; 231fe56b9e6SYuval Mintz u32 pf_start_line; 232dbb799c3SYuval Mintz 233dbb799c3SYuval Mintz /* Mutex for a dynamic ILT allocation */ 234dbb799c3SYuval Mintz struct mutex mutex; 235dbb799c3SYuval Mintz 236dbb799c3SYuval Mintz /* SRC T2 */ 237dbb799c3SYuval Mintz struct qed_dma_mem *t2; 238dbb799c3SYuval Mintz u32 t2_num_pages; 239dbb799c3SYuval Mintz u64 first_free; 240dbb799c3SYuval Mintz u64 last_free; 241fe56b9e6SYuval Mintz }; 242dbb799c3SYuval Mintz static bool src_proto(enum protocol_type type) 243dbb799c3SYuval Mintz { 244dbb799c3SYuval Mintz return type == PROTOCOLID_ISCSI || 2451e128c81SArun Easi type == PROTOCOLID_FCOE || 246dbb799c3SYuval Mintz type == PROTOCOLID_ROCE; 247dbb799c3SYuval Mintz } 248dbb799c3SYuval Mintz 249dbb799c3SYuval Mintz static bool tm_cid_proto(enum protocol_type type) 250dbb799c3SYuval Mintz { 251dbb799c3SYuval Mintz return type == PROTOCOLID_ISCSI || 2521e128c81SArun Easi type == PROTOCOLID_FCOE || 253dbb799c3SYuval Mintz type == PROTOCOLID_ROCE; 254dbb799c3SYuval Mintz } 255fe56b9e6SYuval Mintz 2561e128c81SArun Easi static bool tm_tid_proto(enum protocol_type type) 2571e128c81SArun Easi { 2581e128c81SArun Easi return type == PROTOCOLID_FCOE; 2591e128c81SArun Easi } 2601e128c81SArun Easi 2611408cc1fSYuval Mintz /* counts the iids for the CDU/CDUC ILT client configuration */ 2621408cc1fSYuval Mintz struct qed_cdu_iids { 2631408cc1fSYuval Mintz u32 pf_cids; 2641408cc1fSYuval Mintz u32 per_vf_cids; 2651408cc1fSYuval Mintz }; 2661408cc1fSYuval Mintz 2671408cc1fSYuval Mintz static void qed_cxt_cdu_iids(struct qed_cxt_mngr *p_mngr, 2681408cc1fSYuval Mintz struct qed_cdu_iids *iids) 269fe56b9e6SYuval Mintz { 2701408cc1fSYuval Mintz u32 type; 271fe56b9e6SYuval Mintz 2721408cc1fSYuval Mintz for (type = 0; type < MAX_CONN_TYPES; type++) { 2731408cc1fSYuval Mintz iids->pf_cids += p_mngr->conn_cfg[type].cid_count; 2741408cc1fSYuval Mintz iids->per_vf_cids += p_mngr->conn_cfg[type].cids_per_vf; 2751408cc1fSYuval Mintz } 276fe56b9e6SYuval Mintz } 277fe56b9e6SYuval Mintz 278dbb799c3SYuval Mintz /* counts the iids for the Searcher block configuration */ 279dbb799c3SYuval Mintz struct qed_src_iids { 280dbb799c3SYuval Mintz u32 pf_cids; 281dbb799c3SYuval Mintz u32 per_vf_cids; 282dbb799c3SYuval Mintz }; 283dbb799c3SYuval Mintz 284dbb799c3SYuval Mintz static void qed_cxt_src_iids(struct qed_cxt_mngr *p_mngr, 285dbb799c3SYuval Mintz struct qed_src_iids *iids) 286dbb799c3SYuval Mintz { 287dbb799c3SYuval Mintz u32 i; 288dbb799c3SYuval Mintz 289dbb799c3SYuval Mintz for (i = 0; i < MAX_CONN_TYPES; i++) { 290dbb799c3SYuval Mintz if (!src_proto(i)) 291dbb799c3SYuval Mintz continue; 292dbb799c3SYuval Mintz 293dbb799c3SYuval Mintz iids->pf_cids += p_mngr->conn_cfg[i].cid_count; 294dbb799c3SYuval Mintz iids->per_vf_cids += p_mngr->conn_cfg[i].cids_per_vf; 295dbb799c3SYuval Mintz } 296dbb799c3SYuval Mintz } 297dbb799c3SYuval Mintz 298dbb799c3SYuval Mintz /* counts the iids for the Timers block configuration */ 299dbb799c3SYuval Mintz struct qed_tm_iids { 300dbb799c3SYuval Mintz u32 pf_cids; 301dbb799c3SYuval Mintz u32 pf_tids[NUM_TASK_PF_SEGMENTS]; /* per segment */ 302dbb799c3SYuval Mintz u32 pf_tids_total; 303dbb799c3SYuval Mintz u32 per_vf_cids; 304dbb799c3SYuval Mintz u32 per_vf_tids; 305dbb799c3SYuval Mintz }; 306dbb799c3SYuval Mintz 307dbb799c3SYuval Mintz static void qed_cxt_tm_iids(struct qed_cxt_mngr *p_mngr, 308dbb799c3SYuval Mintz struct qed_tm_iids *iids) 309dbb799c3SYuval Mintz { 310dbb799c3SYuval Mintz u32 i, j; 311dbb799c3SYuval Mintz 312dbb799c3SYuval Mintz for (i = 0; i < MAX_CONN_TYPES; i++) { 313dbb799c3SYuval Mintz struct qed_conn_type_cfg *p_cfg = &p_mngr->conn_cfg[i]; 314dbb799c3SYuval Mintz 315dbb799c3SYuval Mintz if (tm_cid_proto(i)) { 316dbb799c3SYuval Mintz iids->pf_cids += p_cfg->cid_count; 317dbb799c3SYuval Mintz iids->per_vf_cids += p_cfg->cids_per_vf; 318dbb799c3SYuval Mintz } 3191e128c81SArun Easi 3201e128c81SArun Easi if (tm_tid_proto(i)) { 3211e128c81SArun Easi struct qed_tid_seg *segs = p_cfg->tid_seg; 3221e128c81SArun Easi 3231e128c81SArun Easi /* for each segment there is at most one 3241e128c81SArun Easi * protocol for which count is not 0. 3251e128c81SArun Easi */ 3261e128c81SArun Easi for (j = 0; j < NUM_TASK_PF_SEGMENTS; j++) 3271e128c81SArun Easi iids->pf_tids[j] += segs[j].count; 3281e128c81SArun Easi 3291e128c81SArun Easi /* The last array elelment is for the VFs. As for PF 3301e128c81SArun Easi * segments there can be only one protocol for 3311e128c81SArun Easi * which this value is not 0. 3321e128c81SArun Easi */ 3331e128c81SArun Easi iids->per_vf_tids += segs[NUM_TASK_PF_SEGMENTS].count; 3341e128c81SArun Easi } 335dbb799c3SYuval Mintz } 336dbb799c3SYuval Mintz 337dbb799c3SYuval Mintz iids->pf_cids = roundup(iids->pf_cids, TM_ALIGN); 338dbb799c3SYuval Mintz iids->per_vf_cids = roundup(iids->per_vf_cids, TM_ALIGN); 339dbb799c3SYuval Mintz iids->per_vf_tids = roundup(iids->per_vf_tids, TM_ALIGN); 340dbb799c3SYuval Mintz 341dbb799c3SYuval Mintz for (iids->pf_tids_total = 0, j = 0; j < NUM_TASK_PF_SEGMENTS; j++) { 342dbb799c3SYuval Mintz iids->pf_tids[j] = roundup(iids->pf_tids[j], TM_ALIGN); 343dbb799c3SYuval Mintz iids->pf_tids_total += iids->pf_tids[j]; 344dbb799c3SYuval Mintz } 345dbb799c3SYuval Mintz } 346dbb799c3SYuval Mintz 347fe56b9e6SYuval Mintz static void qed_cxt_qm_iids(struct qed_hwfn *p_hwfn, 348fe56b9e6SYuval Mintz struct qed_qm_iids *iids) 349fe56b9e6SYuval Mintz { 350fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 351dbb799c3SYuval Mintz struct qed_tid_seg *segs; 352dbb799c3SYuval Mintz u32 vf_cids = 0, type, j; 353dbb799c3SYuval Mintz u32 vf_tids = 0; 354fe56b9e6SYuval Mintz 3551408cc1fSYuval Mintz for (type = 0; type < MAX_CONN_TYPES; type++) { 356fe56b9e6SYuval Mintz iids->cids += p_mngr->conn_cfg[type].cid_count; 3571408cc1fSYuval Mintz vf_cids += p_mngr->conn_cfg[type].cids_per_vf; 358dbb799c3SYuval Mintz 359dbb799c3SYuval Mintz segs = p_mngr->conn_cfg[type].tid_seg; 360dbb799c3SYuval Mintz /* for each segment there is at most one 361dbb799c3SYuval Mintz * protocol for which count is not 0. 362dbb799c3SYuval Mintz */ 363dbb799c3SYuval Mintz for (j = 0; j < NUM_TASK_PF_SEGMENTS; j++) 364dbb799c3SYuval Mintz iids->tids += segs[j].count; 365dbb799c3SYuval Mintz 366dbb799c3SYuval Mintz /* The last array elelment is for the VFs. As for PF 367dbb799c3SYuval Mintz * segments there can be only one protocol for 368dbb799c3SYuval Mintz * which this value is not 0. 369dbb799c3SYuval Mintz */ 370dbb799c3SYuval Mintz vf_tids += segs[NUM_TASK_PF_SEGMENTS].count; 3711408cc1fSYuval Mintz } 372fe56b9e6SYuval Mintz 3731408cc1fSYuval Mintz iids->vf_cids += vf_cids * p_mngr->vf_count; 374dbb799c3SYuval Mintz iids->tids += vf_tids * p_mngr->vf_count; 375dbb799c3SYuval Mintz 3761408cc1fSYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 377dbb799c3SYuval Mintz "iids: CIDS %08x vf_cids %08x tids %08x vf_tids %08x\n", 378dbb799c3SYuval Mintz iids->cids, iids->vf_cids, iids->tids, vf_tids); 379dbb799c3SYuval Mintz } 380dbb799c3SYuval Mintz 381dbb799c3SYuval Mintz static struct qed_tid_seg *qed_cxt_tid_seg_info(struct qed_hwfn *p_hwfn, 382dbb799c3SYuval Mintz u32 seg) 383dbb799c3SYuval Mintz { 384dbb799c3SYuval Mintz struct qed_cxt_mngr *p_cfg = p_hwfn->p_cxt_mngr; 385dbb799c3SYuval Mintz u32 i; 386dbb799c3SYuval Mintz 387dbb799c3SYuval Mintz /* Find the protocol with tid count > 0 for this segment. 388dbb799c3SYuval Mintz * Note: there can only be one and this is already validated. 389dbb799c3SYuval Mintz */ 390dbb799c3SYuval Mintz for (i = 0; i < MAX_CONN_TYPES; i++) 391dbb799c3SYuval Mintz if (p_cfg->conn_cfg[i].tid_seg[seg].count) 392dbb799c3SYuval Mintz return &p_cfg->conn_cfg[i].tid_seg[seg]; 393dbb799c3SYuval Mintz return NULL; 394dbb799c3SYuval Mintz } 395dbb799c3SYuval Mintz 3968c93beafSYuval Mintz static void qed_cxt_set_srq_count(struct qed_hwfn *p_hwfn, u32 num_srqs) 397dbb799c3SYuval Mintz { 398dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mgr = p_hwfn->p_cxt_mngr; 399dbb799c3SYuval Mintz 400dbb799c3SYuval Mintz p_mgr->srq_count = num_srqs; 401dbb799c3SYuval Mintz } 402dbb799c3SYuval Mintz 4038c93beafSYuval Mintz static u32 qed_cxt_get_srq_count(struct qed_hwfn *p_hwfn) 404dbb799c3SYuval Mintz { 405dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mgr = p_hwfn->p_cxt_mngr; 406dbb799c3SYuval Mintz 407dbb799c3SYuval Mintz return p_mgr->srq_count; 408fe56b9e6SYuval Mintz } 409fe56b9e6SYuval Mintz 410fe56b9e6SYuval Mintz /* set the iids count per protocol */ 411fe56b9e6SYuval Mintz static void qed_cxt_set_proto_cid_count(struct qed_hwfn *p_hwfn, 412fe56b9e6SYuval Mintz enum protocol_type type, 4131408cc1fSYuval Mintz u32 cid_count, u32 vf_cid_cnt) 414fe56b9e6SYuval Mintz { 415fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mgr = p_hwfn->p_cxt_mngr; 416fe56b9e6SYuval Mintz struct qed_conn_type_cfg *p_conn = &p_mgr->conn_cfg[type]; 417fe56b9e6SYuval Mintz 418fe56b9e6SYuval Mintz p_conn->cid_count = roundup(cid_count, DQ_RANGE_ALIGN); 4191408cc1fSYuval Mintz p_conn->cids_per_vf = roundup(vf_cid_cnt, DQ_RANGE_ALIGN); 420dbb799c3SYuval Mintz 421dbb799c3SYuval Mintz if (type == PROTOCOLID_ROCE) { 422dbb799c3SYuval Mintz u32 page_sz = p_mgr->clients[ILT_CLI_CDUC].p_size.val; 423dbb799c3SYuval Mintz u32 cxt_size = CONN_CXT_SIZE(p_hwfn); 424dbb799c3SYuval Mintz u32 elems_per_page = ILT_PAGE_IN_BYTES(page_sz) / cxt_size; 425f3e48119SRam Amrani u32 align = elems_per_page * DQ_RANGE_ALIGN; 426dbb799c3SYuval Mintz 427f3e48119SRam Amrani p_conn->cid_count = roundup(p_conn->cid_count, align); 428dbb799c3SYuval Mintz } 4291408cc1fSYuval Mintz } 4301408cc1fSYuval Mintz 4311408cc1fSYuval Mintz u32 qed_cxt_get_proto_cid_count(struct qed_hwfn *p_hwfn, 4321a635e48SYuval Mintz enum protocol_type type, u32 *vf_cid) 4331408cc1fSYuval Mintz { 4341408cc1fSYuval Mintz if (vf_cid) 4351408cc1fSYuval Mintz *vf_cid = p_hwfn->p_cxt_mngr->conn_cfg[type].cids_per_vf; 4361408cc1fSYuval Mintz 4371408cc1fSYuval Mintz return p_hwfn->p_cxt_mngr->conn_cfg[type].cid_count; 438fe56b9e6SYuval Mintz } 439fe56b9e6SYuval Mintz 440dbb799c3SYuval Mintz u32 qed_cxt_get_proto_cid_start(struct qed_hwfn *p_hwfn, 441dbb799c3SYuval Mintz enum protocol_type type) 442dbb799c3SYuval Mintz { 443dbb799c3SYuval Mintz return p_hwfn->p_cxt_mngr->acquired[type].start_cid; 444dbb799c3SYuval Mintz } 445dbb799c3SYuval Mintz 446dbb799c3SYuval Mintz u32 qed_cxt_get_proto_tid_count(struct qed_hwfn *p_hwfn, 447dbb799c3SYuval Mintz enum protocol_type type) 448dbb799c3SYuval Mintz { 449dbb799c3SYuval Mintz u32 cnt = 0; 450dbb799c3SYuval Mintz int i; 451dbb799c3SYuval Mintz 452dbb799c3SYuval Mintz for (i = 0; i < TASK_SEGMENTS; i++) 453dbb799c3SYuval Mintz cnt += p_hwfn->p_cxt_mngr->conn_cfg[type].tid_seg[i].count; 454dbb799c3SYuval Mintz 455dbb799c3SYuval Mintz return cnt; 456dbb799c3SYuval Mintz } 457dbb799c3SYuval Mintz 4581a635e48SYuval Mintz static void qed_cxt_set_proto_tid_count(struct qed_hwfn *p_hwfn, 459dbb799c3SYuval Mintz enum protocol_type proto, 4601a635e48SYuval Mintz u8 seg, 4611a635e48SYuval Mintz u8 seg_type, u32 count, bool has_fl) 462dbb799c3SYuval Mintz { 463dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 464dbb799c3SYuval Mintz struct qed_tid_seg *p_seg = &p_mngr->conn_cfg[proto].tid_seg[seg]; 465dbb799c3SYuval Mintz 466dbb799c3SYuval Mintz p_seg->count = count; 467dbb799c3SYuval Mintz p_seg->has_fl_mem = has_fl; 468dbb799c3SYuval Mintz p_seg->type = seg_type; 469dbb799c3SYuval Mintz } 470dbb799c3SYuval Mintz 471fe56b9e6SYuval Mintz static void qed_ilt_cli_blk_fill(struct qed_ilt_client_cfg *p_cli, 472fe56b9e6SYuval Mintz struct qed_ilt_cli_blk *p_blk, 4731a635e48SYuval Mintz u32 start_line, u32 total_size, u32 elem_size) 474fe56b9e6SYuval Mintz { 475fe56b9e6SYuval Mintz u32 ilt_size = ILT_PAGE_IN_BYTES(p_cli->p_size.val); 476fe56b9e6SYuval Mintz 477fe56b9e6SYuval Mintz /* verify thatits called only once for each block */ 478fe56b9e6SYuval Mintz if (p_blk->total_size) 479fe56b9e6SYuval Mintz return; 480fe56b9e6SYuval Mintz 481fe56b9e6SYuval Mintz p_blk->total_size = total_size; 482fe56b9e6SYuval Mintz p_blk->real_size_in_page = 0; 483fe56b9e6SYuval Mintz if (elem_size) 484fe56b9e6SYuval Mintz p_blk->real_size_in_page = (ilt_size / elem_size) * elem_size; 485fe56b9e6SYuval Mintz p_blk->start_line = start_line; 486fe56b9e6SYuval Mintz } 487fe56b9e6SYuval Mintz 488fe56b9e6SYuval Mintz static void qed_ilt_cli_adv_line(struct qed_hwfn *p_hwfn, 489fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *p_cli, 490fe56b9e6SYuval Mintz struct qed_ilt_cli_blk *p_blk, 491fe56b9e6SYuval Mintz u32 *p_line, enum ilt_clients client_id) 492fe56b9e6SYuval Mintz { 493fe56b9e6SYuval Mintz if (!p_blk->total_size) 494fe56b9e6SYuval Mintz return; 495fe56b9e6SYuval Mintz 496fe56b9e6SYuval Mintz if (!p_cli->active) 497fe56b9e6SYuval Mintz p_cli->first.val = *p_line; 498fe56b9e6SYuval Mintz 499fe56b9e6SYuval Mintz p_cli->active = true; 5001a635e48SYuval Mintz *p_line += DIV_ROUND_UP(p_blk->total_size, p_blk->real_size_in_page); 501fe56b9e6SYuval Mintz p_cli->last.val = *p_line - 1; 502fe56b9e6SYuval Mintz 503fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 504fe56b9e6SYuval Mintz "ILT[Client %d] - Lines: [%08x - %08x]. Block - Size %08x [Real %08x] Start line %d\n", 505fe56b9e6SYuval Mintz client_id, p_cli->first.val, 506fe56b9e6SYuval Mintz p_cli->last.val, p_blk->total_size, 507fe56b9e6SYuval Mintz p_blk->real_size_in_page, p_blk->start_line); 508fe56b9e6SYuval Mintz } 509fe56b9e6SYuval Mintz 510dbb799c3SYuval Mintz static u32 qed_ilt_get_dynamic_line_cnt(struct qed_hwfn *p_hwfn, 511dbb799c3SYuval Mintz enum ilt_clients ilt_client) 512dbb799c3SYuval Mintz { 513dbb799c3SYuval Mintz u32 cid_count = p_hwfn->p_cxt_mngr->conn_cfg[PROTOCOLID_ROCE].cid_count; 514dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 515dbb799c3SYuval Mintz u32 lines_to_skip = 0; 516dbb799c3SYuval Mintz u32 cxts_per_p; 517dbb799c3SYuval Mintz 518dbb799c3SYuval Mintz if (ilt_client == ILT_CLI_CDUC) { 519dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC]; 520dbb799c3SYuval Mintz 521dbb799c3SYuval Mintz cxts_per_p = ILT_PAGE_IN_BYTES(p_cli->p_size.val) / 522dbb799c3SYuval Mintz (u32) CONN_CXT_SIZE(p_hwfn); 523dbb799c3SYuval Mintz 524dbb799c3SYuval Mintz lines_to_skip = cid_count / cxts_per_p; 525dbb799c3SYuval Mintz } 526dbb799c3SYuval Mintz 527dbb799c3SYuval Mintz return lines_to_skip; 528dbb799c3SYuval Mintz } 529dbb799c3SYuval Mintz 530fe56b9e6SYuval Mintz int qed_cxt_cfg_ilt_compute(struct qed_hwfn *p_hwfn) 531fe56b9e6SYuval Mintz { 532fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 533dbb799c3SYuval Mintz u32 curr_line, total, i, task_size, line; 534fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *p_cli; 535fe56b9e6SYuval Mintz struct qed_ilt_cli_blk *p_blk; 5361408cc1fSYuval Mintz struct qed_cdu_iids cdu_iids; 537dbb799c3SYuval Mintz struct qed_src_iids src_iids; 538fe56b9e6SYuval Mintz struct qed_qm_iids qm_iids; 539dbb799c3SYuval Mintz struct qed_tm_iids tm_iids; 540dbb799c3SYuval Mintz struct qed_tid_seg *p_seg; 541fe56b9e6SYuval Mintz 542fe56b9e6SYuval Mintz memset(&qm_iids, 0, sizeof(qm_iids)); 5431408cc1fSYuval Mintz memset(&cdu_iids, 0, sizeof(cdu_iids)); 544dbb799c3SYuval Mintz memset(&src_iids, 0, sizeof(src_iids)); 545dbb799c3SYuval Mintz memset(&tm_iids, 0, sizeof(tm_iids)); 546fe56b9e6SYuval Mintz 547fe56b9e6SYuval Mintz p_mngr->pf_start_line = RESC_START(p_hwfn, QED_ILT); 548fe56b9e6SYuval Mintz 549fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 550fe56b9e6SYuval Mintz "hwfn [%d] - Set context manager starting line to be 0x%08x\n", 551fe56b9e6SYuval Mintz p_hwfn->my_id, p_hwfn->p_cxt_mngr->pf_start_line); 552fe56b9e6SYuval Mintz 553fe56b9e6SYuval Mintz /* CDUC */ 554fe56b9e6SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_CDUC]; 555fe56b9e6SYuval Mintz curr_line = p_mngr->pf_start_line; 5561408cc1fSYuval Mintz 5571408cc1fSYuval Mintz /* CDUC PF */ 558fe56b9e6SYuval Mintz p_cli->pf_total_lines = 0; 559fe56b9e6SYuval Mintz 560fe56b9e6SYuval Mintz /* get the counters for the CDUC and QM clients */ 5611408cc1fSYuval Mintz qed_cxt_cdu_iids(p_mngr, &cdu_iids); 562fe56b9e6SYuval Mintz 563fe56b9e6SYuval Mintz p_blk = &p_cli->pf_blks[CDUC_BLK]; 564fe56b9e6SYuval Mintz 5651408cc1fSYuval Mintz total = cdu_iids.pf_cids * CONN_CXT_SIZE(p_hwfn); 566fe56b9e6SYuval Mintz 567fe56b9e6SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 568fe56b9e6SYuval Mintz total, CONN_CXT_SIZE(p_hwfn)); 569fe56b9e6SYuval Mintz 570fe56b9e6SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, ILT_CLI_CDUC); 571fe56b9e6SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 572fe56b9e6SYuval Mintz 573dbb799c3SYuval Mintz p_blk->dynamic_line_cnt = qed_ilt_get_dynamic_line_cnt(p_hwfn, 574dbb799c3SYuval Mintz ILT_CLI_CDUC); 575dbb799c3SYuval Mintz 5761408cc1fSYuval Mintz /* CDUC VF */ 5771408cc1fSYuval Mintz p_blk = &p_cli->vf_blks[CDUC_BLK]; 5781408cc1fSYuval Mintz total = cdu_iids.per_vf_cids * CONN_CXT_SIZE(p_hwfn); 5791408cc1fSYuval Mintz 5801408cc1fSYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 5811408cc1fSYuval Mintz total, CONN_CXT_SIZE(p_hwfn)); 5821408cc1fSYuval Mintz 5831408cc1fSYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, ILT_CLI_CDUC); 5841408cc1fSYuval Mintz p_cli->vf_total_lines = curr_line - p_blk->start_line; 5851408cc1fSYuval Mintz 5861408cc1fSYuval Mintz for (i = 1; i < p_mngr->vf_count; i++) 5871408cc1fSYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 5881408cc1fSYuval Mintz ILT_CLI_CDUC); 5891408cc1fSYuval Mintz 590dbb799c3SYuval Mintz /* CDUT PF */ 591dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_CDUT]; 592dbb799c3SYuval Mintz p_cli->first.val = curr_line; 593dbb799c3SYuval Mintz 594dbb799c3SYuval Mintz /* first the 'working' task memory */ 595dbb799c3SYuval Mintz for (i = 0; i < NUM_TASK_PF_SEGMENTS; i++) { 596dbb799c3SYuval Mintz p_seg = qed_cxt_tid_seg_info(p_hwfn, i); 597dbb799c3SYuval Mintz if (!p_seg || p_seg->count == 0) 598dbb799c3SYuval Mintz continue; 599dbb799c3SYuval Mintz 600dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUT_SEG_BLK(i)]; 601dbb799c3SYuval Mintz total = p_seg->count * p_mngr->task_type_size[p_seg->type]; 602dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, total, 603dbb799c3SYuval Mintz p_mngr->task_type_size[p_seg->type]); 604dbb799c3SYuval Mintz 605dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 606dbb799c3SYuval Mintz ILT_CLI_CDUT); 607dbb799c3SYuval Mintz } 608dbb799c3SYuval Mintz 609dbb799c3SYuval Mintz /* next the 'init' task memory (forced load memory) */ 610dbb799c3SYuval Mintz for (i = 0; i < NUM_TASK_PF_SEGMENTS; i++) { 611dbb799c3SYuval Mintz p_seg = qed_cxt_tid_seg_info(p_hwfn, i); 612dbb799c3SYuval Mintz if (!p_seg || p_seg->count == 0) 613dbb799c3SYuval Mintz continue; 614dbb799c3SYuval Mintz 615dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUT_FL_SEG_BLK(i, PF)]; 616dbb799c3SYuval Mintz 617dbb799c3SYuval Mintz if (!p_seg->has_fl_mem) { 618dbb799c3SYuval Mintz /* The segment is active (total size pf 'working' 619dbb799c3SYuval Mintz * memory is > 0) but has no FL (forced-load, Init) 620dbb799c3SYuval Mintz * memory. Thus: 621dbb799c3SYuval Mintz * 622dbb799c3SYuval Mintz * 1. The total-size in the corrsponding FL block of 623dbb799c3SYuval Mintz * the ILT client is set to 0 - No ILT line are 624dbb799c3SYuval Mintz * provisioned and no ILT memory allocated. 625dbb799c3SYuval Mintz * 626dbb799c3SYuval Mintz * 2. The start-line of said block is set to the 627dbb799c3SYuval Mintz * start line of the matching working memory 628dbb799c3SYuval Mintz * block in the ILT client. This is later used to 629dbb799c3SYuval Mintz * configure the CDU segment offset registers and 630dbb799c3SYuval Mintz * results in an FL command for TIDs of this 631dbb799c3SYuval Mintz * segement behaves as regular load commands 632dbb799c3SYuval Mintz * (loading TIDs from the working memory). 633dbb799c3SYuval Mintz */ 634dbb799c3SYuval Mintz line = p_cli->pf_blks[CDUT_SEG_BLK(i)].start_line; 635dbb799c3SYuval Mintz 636dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, line, 0, 0); 637dbb799c3SYuval Mintz continue; 638dbb799c3SYuval Mintz } 639dbb799c3SYuval Mintz total = p_seg->count * p_mngr->task_type_size[p_seg->type]; 640dbb799c3SYuval Mintz 641dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, 642dbb799c3SYuval Mintz curr_line, total, 643dbb799c3SYuval Mintz p_mngr->task_type_size[p_seg->type]); 644dbb799c3SYuval Mintz 645dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 646dbb799c3SYuval Mintz ILT_CLI_CDUT); 647dbb799c3SYuval Mintz } 648dbb799c3SYuval Mintz p_cli->pf_total_lines = curr_line - p_cli->pf_blks[0].start_line; 649dbb799c3SYuval Mintz 650dbb799c3SYuval Mintz /* CDUT VF */ 651dbb799c3SYuval Mintz p_seg = qed_cxt_tid_seg_info(p_hwfn, TASK_SEGMENT_VF); 652dbb799c3SYuval Mintz if (p_seg && p_seg->count) { 653dbb799c3SYuval Mintz /* Stricly speaking we need to iterate over all VF 654dbb799c3SYuval Mintz * task segment types, but a VF has only 1 segment 655dbb799c3SYuval Mintz */ 656dbb799c3SYuval Mintz 657dbb799c3SYuval Mintz /* 'working' memory */ 658dbb799c3SYuval Mintz total = p_seg->count * p_mngr->task_type_size[p_seg->type]; 659dbb799c3SYuval Mintz 660dbb799c3SYuval Mintz p_blk = &p_cli->vf_blks[CDUT_SEG_BLK(0)]; 661dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, 662dbb799c3SYuval Mintz curr_line, total, 663dbb799c3SYuval Mintz p_mngr->task_type_size[p_seg->type]); 664dbb799c3SYuval Mintz 665dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 666dbb799c3SYuval Mintz ILT_CLI_CDUT); 667dbb799c3SYuval Mintz 668dbb799c3SYuval Mintz /* 'init' memory */ 669dbb799c3SYuval Mintz p_blk = &p_cli->vf_blks[CDUT_FL_SEG_BLK(0, VF)]; 670dbb799c3SYuval Mintz if (!p_seg->has_fl_mem) { 671dbb799c3SYuval Mintz /* see comment above */ 672dbb799c3SYuval Mintz line = p_cli->vf_blks[CDUT_SEG_BLK(0)].start_line; 673dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, line, 0, 0); 674dbb799c3SYuval Mintz } else { 675dbb799c3SYuval Mintz task_size = p_mngr->task_type_size[p_seg->type]; 676dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, 677dbb799c3SYuval Mintz curr_line, total, task_size); 678dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 679dbb799c3SYuval Mintz ILT_CLI_CDUT); 680dbb799c3SYuval Mintz } 681dbb799c3SYuval Mintz p_cli->vf_total_lines = curr_line - 682dbb799c3SYuval Mintz p_cli->vf_blks[0].start_line; 683dbb799c3SYuval Mintz 684dbb799c3SYuval Mintz /* Now for the rest of the VFs */ 685dbb799c3SYuval Mintz for (i = 1; i < p_mngr->vf_count; i++) { 686dbb799c3SYuval Mintz p_blk = &p_cli->vf_blks[CDUT_SEG_BLK(0)]; 687dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 688dbb799c3SYuval Mintz ILT_CLI_CDUT); 689dbb799c3SYuval Mintz 690dbb799c3SYuval Mintz p_blk = &p_cli->vf_blks[CDUT_FL_SEG_BLK(0, VF)]; 691dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 692dbb799c3SYuval Mintz ILT_CLI_CDUT); 693dbb799c3SYuval Mintz } 694dbb799c3SYuval Mintz } 695dbb799c3SYuval Mintz 696fe56b9e6SYuval Mintz /* QM */ 697fe56b9e6SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_QM]; 698fe56b9e6SYuval Mintz p_blk = &p_cli->pf_blks[0]; 699fe56b9e6SYuval Mintz 700fe56b9e6SYuval Mintz qed_cxt_qm_iids(p_hwfn, &qm_iids); 7011408cc1fSYuval Mintz total = qed_qm_pf_mem_size(p_hwfn->rel_pf_id, qm_iids.cids, 702dbb799c3SYuval Mintz qm_iids.vf_cids, qm_iids.tids, 7031408cc1fSYuval Mintz p_hwfn->qm_info.num_pqs, 7041408cc1fSYuval Mintz p_hwfn->qm_info.num_vf_pqs); 705fe56b9e6SYuval Mintz 7061408cc1fSYuval Mintz DP_VERBOSE(p_hwfn, 7071408cc1fSYuval Mintz QED_MSG_ILT, 708dbb799c3SYuval Mintz "QM ILT Info, (cids=%d, vf_cids=%d, tids=%d, num_pqs=%d, num_vf_pqs=%d, memory_size=%d)\n", 7091408cc1fSYuval Mintz qm_iids.cids, 7101408cc1fSYuval Mintz qm_iids.vf_cids, 711dbb799c3SYuval Mintz qm_iids.tids, 7121408cc1fSYuval Mintz p_hwfn->qm_info.num_pqs, p_hwfn->qm_info.num_vf_pqs, total); 713fe56b9e6SYuval Mintz 714fe56b9e6SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, 715fe56b9e6SYuval Mintz curr_line, total * 0x1000, 716fe56b9e6SYuval Mintz QM_PQ_ELEMENT_SIZE); 717fe56b9e6SYuval Mintz 718fe56b9e6SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, ILT_CLI_QM); 719fe56b9e6SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 720fe56b9e6SYuval Mintz 721dbb799c3SYuval Mintz /* SRC */ 722dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_SRC]; 723dbb799c3SYuval Mintz qed_cxt_src_iids(p_mngr, &src_iids); 724dbb799c3SYuval Mintz 725dbb799c3SYuval Mintz /* Both the PF and VFs searcher connections are stored in the per PF 726dbb799c3SYuval Mintz * database. Thus sum the PF searcher cids and all the VFs searcher 727dbb799c3SYuval Mintz * cids. 728dbb799c3SYuval Mintz */ 729dbb799c3SYuval Mintz total = src_iids.pf_cids + src_iids.per_vf_cids * p_mngr->vf_count; 730dbb799c3SYuval Mintz if (total) { 731dbb799c3SYuval Mintz u32 local_max = max_t(u32, total, 732dbb799c3SYuval Mintz SRC_MIN_NUM_ELEMS); 733dbb799c3SYuval Mintz 734dbb799c3SYuval Mintz total = roundup_pow_of_two(local_max); 735dbb799c3SYuval Mintz 736dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[0]; 737dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 738dbb799c3SYuval Mintz total * sizeof(struct src_ent), 739dbb799c3SYuval Mintz sizeof(struct src_ent)); 740dbb799c3SYuval Mintz 741dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 742dbb799c3SYuval Mintz ILT_CLI_SRC); 743dbb799c3SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 744dbb799c3SYuval Mintz } 745dbb799c3SYuval Mintz 746dbb799c3SYuval Mintz /* TM PF */ 747dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_TM]; 748dbb799c3SYuval Mintz qed_cxt_tm_iids(p_mngr, &tm_iids); 749dbb799c3SYuval Mintz total = tm_iids.pf_cids + tm_iids.pf_tids_total; 750dbb799c3SYuval Mintz if (total) { 751dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[0]; 752dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 753dbb799c3SYuval Mintz total * TM_ELEM_SIZE, TM_ELEM_SIZE); 754dbb799c3SYuval Mintz 755dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 756dbb799c3SYuval Mintz ILT_CLI_TM); 757dbb799c3SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 758dbb799c3SYuval Mintz } 759dbb799c3SYuval Mintz 760dbb799c3SYuval Mintz /* TM VF */ 761dbb799c3SYuval Mintz total = tm_iids.per_vf_cids + tm_iids.per_vf_tids; 762dbb799c3SYuval Mintz if (total) { 763dbb799c3SYuval Mintz p_blk = &p_cli->vf_blks[0]; 764dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 765dbb799c3SYuval Mintz total * TM_ELEM_SIZE, TM_ELEM_SIZE); 766dbb799c3SYuval Mintz 767dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 768dbb799c3SYuval Mintz ILT_CLI_TM); 769dbb799c3SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 770dbb799c3SYuval Mintz 771dbb799c3SYuval Mintz for (i = 1; i < p_mngr->vf_count; i++) 772dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 773dbb799c3SYuval Mintz ILT_CLI_TM); 774dbb799c3SYuval Mintz } 775dbb799c3SYuval Mintz 776dbb799c3SYuval Mintz /* TSDM (SRQ CONTEXT) */ 777dbb799c3SYuval Mintz total = qed_cxt_get_srq_count(p_hwfn); 778dbb799c3SYuval Mintz 779dbb799c3SYuval Mintz if (total) { 780dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_TSDM]; 781dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[SRQ_BLK]; 782dbb799c3SYuval Mintz qed_ilt_cli_blk_fill(p_cli, p_blk, curr_line, 783dbb799c3SYuval Mintz total * SRQ_CXT_SIZE, SRQ_CXT_SIZE); 784dbb799c3SYuval Mintz 785dbb799c3SYuval Mintz qed_ilt_cli_adv_line(p_hwfn, p_cli, p_blk, &curr_line, 786dbb799c3SYuval Mintz ILT_CLI_TSDM); 787dbb799c3SYuval Mintz p_cli->pf_total_lines = curr_line - p_blk->start_line; 788dbb799c3SYuval Mintz } 789dbb799c3SYuval Mintz 790fe56b9e6SYuval Mintz if (curr_line - p_hwfn->p_cxt_mngr->pf_start_line > 791fe56b9e6SYuval Mintz RESC_NUM(p_hwfn, QED_ILT)) { 792fe56b9e6SYuval Mintz DP_ERR(p_hwfn, "too many ilt lines...#lines=%d\n", 793fe56b9e6SYuval Mintz curr_line - p_hwfn->p_cxt_mngr->pf_start_line); 794fe56b9e6SYuval Mintz return -EINVAL; 795fe56b9e6SYuval Mintz } 796fe56b9e6SYuval Mintz 797fe56b9e6SYuval Mintz return 0; 798fe56b9e6SYuval Mintz } 799fe56b9e6SYuval Mintz 800dbb799c3SYuval Mintz static void qed_cxt_src_t2_free(struct qed_hwfn *p_hwfn) 801dbb799c3SYuval Mintz { 802dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 803dbb799c3SYuval Mintz u32 i; 804dbb799c3SYuval Mintz 805dbb799c3SYuval Mintz if (!p_mngr->t2) 806dbb799c3SYuval Mintz return; 807dbb799c3SYuval Mintz 808dbb799c3SYuval Mintz for (i = 0; i < p_mngr->t2_num_pages; i++) 809dbb799c3SYuval Mintz if (p_mngr->t2[i].p_virt) 810dbb799c3SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev, 811dbb799c3SYuval Mintz p_mngr->t2[i].size, 812dbb799c3SYuval Mintz p_mngr->t2[i].p_virt, 813dbb799c3SYuval Mintz p_mngr->t2[i].p_phys); 814dbb799c3SYuval Mintz 815dbb799c3SYuval Mintz kfree(p_mngr->t2); 816dbb799c3SYuval Mintz p_mngr->t2 = NULL; 817dbb799c3SYuval Mintz } 818dbb799c3SYuval Mintz 819dbb799c3SYuval Mintz static int qed_cxt_src_t2_alloc(struct qed_hwfn *p_hwfn) 820dbb799c3SYuval Mintz { 821dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 822dbb799c3SYuval Mintz u32 conn_num, total_size, ent_per_page, psz, i; 823dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_src; 824dbb799c3SYuval Mintz struct qed_src_iids src_iids; 825dbb799c3SYuval Mintz struct qed_dma_mem *p_t2; 826dbb799c3SYuval Mintz int rc; 827dbb799c3SYuval Mintz 828dbb799c3SYuval Mintz memset(&src_iids, 0, sizeof(src_iids)); 829dbb799c3SYuval Mintz 830dbb799c3SYuval Mintz /* if the SRC ILT client is inactive - there are no connection 831dbb799c3SYuval Mintz * requiring the searcer, leave. 832dbb799c3SYuval Mintz */ 833dbb799c3SYuval Mintz p_src = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_SRC]; 834dbb799c3SYuval Mintz if (!p_src->active) 835dbb799c3SYuval Mintz return 0; 836dbb799c3SYuval Mintz 837dbb799c3SYuval Mintz qed_cxt_src_iids(p_mngr, &src_iids); 838dbb799c3SYuval Mintz conn_num = src_iids.pf_cids + src_iids.per_vf_cids * p_mngr->vf_count; 839dbb799c3SYuval Mintz total_size = conn_num * sizeof(struct src_ent); 840dbb799c3SYuval Mintz 841dbb799c3SYuval Mintz /* use the same page size as the SRC ILT client */ 842dbb799c3SYuval Mintz psz = ILT_PAGE_IN_BYTES(p_src->p_size.val); 843dbb799c3SYuval Mintz p_mngr->t2_num_pages = DIV_ROUND_UP(total_size, psz); 844dbb799c3SYuval Mintz 845dbb799c3SYuval Mintz /* allocate t2 */ 8462591c280SJoe Perches p_mngr->t2 = kcalloc(p_mngr->t2_num_pages, sizeof(struct qed_dma_mem), 847dbb799c3SYuval Mintz GFP_KERNEL); 848dbb799c3SYuval Mintz if (!p_mngr->t2) { 849dbb799c3SYuval Mintz rc = -ENOMEM; 850dbb799c3SYuval Mintz goto t2_fail; 851dbb799c3SYuval Mintz } 852dbb799c3SYuval Mintz 853dbb799c3SYuval Mintz /* allocate t2 pages */ 854dbb799c3SYuval Mintz for (i = 0; i < p_mngr->t2_num_pages; i++) { 855dbb799c3SYuval Mintz u32 size = min_t(u32, total_size, psz); 856dbb799c3SYuval Mintz void **p_virt = &p_mngr->t2[i].p_virt; 857dbb799c3SYuval Mintz 858dbb799c3SYuval Mintz *p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 859dbb799c3SYuval Mintz size, 860dbb799c3SYuval Mintz &p_mngr->t2[i].p_phys, GFP_KERNEL); 861dbb799c3SYuval Mintz if (!p_mngr->t2[i].p_virt) { 862dbb799c3SYuval Mintz rc = -ENOMEM; 863dbb799c3SYuval Mintz goto t2_fail; 864dbb799c3SYuval Mintz } 865dbb799c3SYuval Mintz memset(*p_virt, 0, size); 866dbb799c3SYuval Mintz p_mngr->t2[i].size = size; 867dbb799c3SYuval Mintz total_size -= size; 868dbb799c3SYuval Mintz } 869dbb799c3SYuval Mintz 870dbb799c3SYuval Mintz /* Set the t2 pointers */ 871dbb799c3SYuval Mintz 872dbb799c3SYuval Mintz /* entries per page - must be a power of two */ 873dbb799c3SYuval Mintz ent_per_page = psz / sizeof(struct src_ent); 874dbb799c3SYuval Mintz 875dbb799c3SYuval Mintz p_mngr->first_free = (u64) p_mngr->t2[0].p_phys; 876dbb799c3SYuval Mintz 877dbb799c3SYuval Mintz p_t2 = &p_mngr->t2[(conn_num - 1) / ent_per_page]; 878dbb799c3SYuval Mintz p_mngr->last_free = (u64) p_t2->p_phys + 879dbb799c3SYuval Mintz ((conn_num - 1) & (ent_per_page - 1)) * sizeof(struct src_ent); 880dbb799c3SYuval Mintz 881dbb799c3SYuval Mintz for (i = 0; i < p_mngr->t2_num_pages; i++) { 882dbb799c3SYuval Mintz u32 ent_num = min_t(u32, 883dbb799c3SYuval Mintz ent_per_page, 884dbb799c3SYuval Mintz conn_num); 885dbb799c3SYuval Mintz struct src_ent *entries = p_mngr->t2[i].p_virt; 886dbb799c3SYuval Mintz u64 p_ent_phys = (u64) p_mngr->t2[i].p_phys, val; 887dbb799c3SYuval Mintz u32 j; 888dbb799c3SYuval Mintz 889dbb799c3SYuval Mintz for (j = 0; j < ent_num - 1; j++) { 890dbb799c3SYuval Mintz val = p_ent_phys + (j + 1) * sizeof(struct src_ent); 891dbb799c3SYuval Mintz entries[j].next = cpu_to_be64(val); 892dbb799c3SYuval Mintz } 893dbb799c3SYuval Mintz 894dbb799c3SYuval Mintz if (i < p_mngr->t2_num_pages - 1) 895dbb799c3SYuval Mintz val = (u64) p_mngr->t2[i + 1].p_phys; 896dbb799c3SYuval Mintz else 897dbb799c3SYuval Mintz val = 0; 898dbb799c3SYuval Mintz entries[j].next = cpu_to_be64(val); 899dbb799c3SYuval Mintz 90001e517f1SDan Carpenter conn_num -= ent_num; 901dbb799c3SYuval Mintz } 902dbb799c3SYuval Mintz 903dbb799c3SYuval Mintz return 0; 904dbb799c3SYuval Mintz 905dbb799c3SYuval Mintz t2_fail: 906dbb799c3SYuval Mintz qed_cxt_src_t2_free(p_hwfn); 907dbb799c3SYuval Mintz return rc; 908dbb799c3SYuval Mintz } 909dbb799c3SYuval Mintz 910fe56b9e6SYuval Mintz #define for_each_ilt_valid_client(pos, clients) \ 911dbb799c3SYuval Mintz for (pos = 0; pos < ILT_CLI_MAX; pos++) \ 912dbb799c3SYuval Mintz if (!clients[pos].active) { \ 913dbb799c3SYuval Mintz continue; \ 914dbb799c3SYuval Mintz } else \ 915fe56b9e6SYuval Mintz 916fe56b9e6SYuval Mintz /* Total number of ILT lines used by this PF */ 917fe56b9e6SYuval Mintz static u32 qed_cxt_ilt_shadow_size(struct qed_ilt_client_cfg *ilt_clients) 918fe56b9e6SYuval Mintz { 919fe56b9e6SYuval Mintz u32 size = 0; 920fe56b9e6SYuval Mintz u32 i; 921fe56b9e6SYuval Mintz 922dbb799c3SYuval Mintz for_each_ilt_valid_client(i, ilt_clients) 923dbb799c3SYuval Mintz size += (ilt_clients[i].last.val - ilt_clients[i].first.val + 1); 924fe56b9e6SYuval Mintz 925fe56b9e6SYuval Mintz return size; 926fe56b9e6SYuval Mintz } 927fe56b9e6SYuval Mintz 928fe56b9e6SYuval Mintz static void qed_ilt_shadow_free(struct qed_hwfn *p_hwfn) 929fe56b9e6SYuval Mintz { 930fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *p_cli = p_hwfn->p_cxt_mngr->clients; 931fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 932fe56b9e6SYuval Mintz u32 ilt_size, i; 933fe56b9e6SYuval Mintz 934fe56b9e6SYuval Mintz ilt_size = qed_cxt_ilt_shadow_size(p_cli); 935fe56b9e6SYuval Mintz 936fe56b9e6SYuval Mintz for (i = 0; p_mngr->ilt_shadow && i < ilt_size; i++) { 937fe56b9e6SYuval Mintz struct qed_dma_mem *p_dma = &p_mngr->ilt_shadow[i]; 938fe56b9e6SYuval Mintz 939fe56b9e6SYuval Mintz if (p_dma->p_virt) 940fe56b9e6SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev, 941fe56b9e6SYuval Mintz p_dma->size, p_dma->p_virt, 942fe56b9e6SYuval Mintz p_dma->p_phys); 943fe56b9e6SYuval Mintz p_dma->p_virt = NULL; 944fe56b9e6SYuval Mintz } 945fe56b9e6SYuval Mintz kfree(p_mngr->ilt_shadow); 946fe56b9e6SYuval Mintz } 947fe56b9e6SYuval Mintz 948fe56b9e6SYuval Mintz static int qed_ilt_blk_alloc(struct qed_hwfn *p_hwfn, 949fe56b9e6SYuval Mintz struct qed_ilt_cli_blk *p_blk, 950fe56b9e6SYuval Mintz enum ilt_clients ilt_client, 951fe56b9e6SYuval Mintz u32 start_line_offset) 952fe56b9e6SYuval Mintz { 953fe56b9e6SYuval Mintz struct qed_dma_mem *ilt_shadow = p_hwfn->p_cxt_mngr->ilt_shadow; 954dbb799c3SYuval Mintz u32 lines, line, sz_left, lines_to_skip = 0; 955dbb799c3SYuval Mintz 956dbb799c3SYuval Mintz /* Special handling for RoCE that supports dynamic allocation */ 957dbb799c3SYuval Mintz if ((p_hwfn->hw_info.personality == QED_PCI_ETH_ROCE) && 958dbb799c3SYuval Mintz ((ilt_client == ILT_CLI_CDUT) || ilt_client == ILT_CLI_TSDM)) 959dbb799c3SYuval Mintz return 0; 960dbb799c3SYuval Mintz 961dbb799c3SYuval Mintz lines_to_skip = p_blk->dynamic_line_cnt; 962fe56b9e6SYuval Mintz 963fe56b9e6SYuval Mintz if (!p_blk->total_size) 964fe56b9e6SYuval Mintz return 0; 965fe56b9e6SYuval Mintz 966fe56b9e6SYuval Mintz sz_left = p_blk->total_size; 967dbb799c3SYuval Mintz lines = DIV_ROUND_UP(sz_left, p_blk->real_size_in_page) - lines_to_skip; 968fe56b9e6SYuval Mintz line = p_blk->start_line + start_line_offset - 969dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->pf_start_line + lines_to_skip; 970fe56b9e6SYuval Mintz 971fe56b9e6SYuval Mintz for (; lines; lines--) { 972fe56b9e6SYuval Mintz dma_addr_t p_phys; 973fe56b9e6SYuval Mintz void *p_virt; 974fe56b9e6SYuval Mintz u32 size; 975fe56b9e6SYuval Mintz 9761a635e48SYuval Mintz size = min_t(u32, sz_left, p_blk->real_size_in_page); 977fe56b9e6SYuval Mintz p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 9781a635e48SYuval Mintz size, &p_phys, GFP_KERNEL); 979fe56b9e6SYuval Mintz if (!p_virt) 980fe56b9e6SYuval Mintz return -ENOMEM; 981fe56b9e6SYuval Mintz memset(p_virt, 0, size); 982fe56b9e6SYuval Mintz 983fe56b9e6SYuval Mintz ilt_shadow[line].p_phys = p_phys; 984fe56b9e6SYuval Mintz ilt_shadow[line].p_virt = p_virt; 985fe56b9e6SYuval Mintz ilt_shadow[line].size = size; 986fe56b9e6SYuval Mintz 987fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 988fe56b9e6SYuval Mintz "ILT shadow: Line [%d] Physical 0x%llx Virtual %p Size %d\n", 989fe56b9e6SYuval Mintz line, (u64)p_phys, p_virt, size); 990fe56b9e6SYuval Mintz 991fe56b9e6SYuval Mintz sz_left -= size; 992fe56b9e6SYuval Mintz line++; 993fe56b9e6SYuval Mintz } 994fe56b9e6SYuval Mintz 995fe56b9e6SYuval Mintz return 0; 996fe56b9e6SYuval Mintz } 997fe56b9e6SYuval Mintz 998fe56b9e6SYuval Mintz static int qed_ilt_shadow_alloc(struct qed_hwfn *p_hwfn) 999fe56b9e6SYuval Mintz { 1000fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1001fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *clients = p_mngr->clients; 1002fe56b9e6SYuval Mintz struct qed_ilt_cli_blk *p_blk; 10031408cc1fSYuval Mintz u32 size, i, j, k; 1004fe56b9e6SYuval Mintz int rc; 1005fe56b9e6SYuval Mintz 1006fe56b9e6SYuval Mintz size = qed_cxt_ilt_shadow_size(clients); 1007fe56b9e6SYuval Mintz p_mngr->ilt_shadow = kcalloc(size, sizeof(struct qed_dma_mem), 1008fe56b9e6SYuval Mintz GFP_KERNEL); 1009fe56b9e6SYuval Mintz if (!p_mngr->ilt_shadow) { 1010fe56b9e6SYuval Mintz rc = -ENOMEM; 1011fe56b9e6SYuval Mintz goto ilt_shadow_fail; 1012fe56b9e6SYuval Mintz } 1013fe56b9e6SYuval Mintz 1014fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 1015fe56b9e6SYuval Mintz "Allocated 0x%x bytes for ilt shadow\n", 1016fe56b9e6SYuval Mintz (u32)(size * sizeof(struct qed_dma_mem))); 1017fe56b9e6SYuval Mintz 1018fe56b9e6SYuval Mintz for_each_ilt_valid_client(i, clients) { 1019fe56b9e6SYuval Mintz for (j = 0; j < ILT_CLI_PF_BLOCKS; j++) { 1020fe56b9e6SYuval Mintz p_blk = &clients[i].pf_blks[j]; 1021fe56b9e6SYuval Mintz rc = qed_ilt_blk_alloc(p_hwfn, p_blk, i, 0); 10221a635e48SYuval Mintz if (rc) 1023fe56b9e6SYuval Mintz goto ilt_shadow_fail; 1024fe56b9e6SYuval Mintz } 10251408cc1fSYuval Mintz for (k = 0; k < p_mngr->vf_count; k++) { 10261408cc1fSYuval Mintz for (j = 0; j < ILT_CLI_VF_BLOCKS; j++) { 10271408cc1fSYuval Mintz u32 lines = clients[i].vf_total_lines * k; 10281408cc1fSYuval Mintz 10291408cc1fSYuval Mintz p_blk = &clients[i].vf_blks[j]; 10301408cc1fSYuval Mintz rc = qed_ilt_blk_alloc(p_hwfn, p_blk, i, lines); 10311a635e48SYuval Mintz if (rc) 10321408cc1fSYuval Mintz goto ilt_shadow_fail; 10331408cc1fSYuval Mintz } 10341408cc1fSYuval Mintz } 1035fe56b9e6SYuval Mintz } 1036fe56b9e6SYuval Mintz 1037fe56b9e6SYuval Mintz return 0; 1038fe56b9e6SYuval Mintz 1039fe56b9e6SYuval Mintz ilt_shadow_fail: 1040fe56b9e6SYuval Mintz qed_ilt_shadow_free(p_hwfn); 1041fe56b9e6SYuval Mintz return rc; 1042fe56b9e6SYuval Mintz } 1043fe56b9e6SYuval Mintz 1044fe56b9e6SYuval Mintz static void qed_cid_map_free(struct qed_hwfn *p_hwfn) 1045fe56b9e6SYuval Mintz { 1046fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1047fe56b9e6SYuval Mintz u32 type; 1048fe56b9e6SYuval Mintz 1049fe56b9e6SYuval Mintz for (type = 0; type < MAX_CONN_TYPES; type++) { 1050fe56b9e6SYuval Mintz kfree(p_mngr->acquired[type].cid_map); 1051fe56b9e6SYuval Mintz p_mngr->acquired[type].max_count = 0; 1052fe56b9e6SYuval Mintz p_mngr->acquired[type].start_cid = 0; 1053fe56b9e6SYuval Mintz } 1054fe56b9e6SYuval Mintz } 1055fe56b9e6SYuval Mintz 1056fe56b9e6SYuval Mintz static int qed_cid_map_alloc(struct qed_hwfn *p_hwfn) 1057fe56b9e6SYuval Mintz { 1058fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1059fe56b9e6SYuval Mintz u32 start_cid = 0; 1060fe56b9e6SYuval Mintz u32 type; 1061fe56b9e6SYuval Mintz 1062fe56b9e6SYuval Mintz for (type = 0; type < MAX_CONN_TYPES; type++) { 1063fe56b9e6SYuval Mintz u32 cid_cnt = p_hwfn->p_cxt_mngr->conn_cfg[type].cid_count; 1064fe56b9e6SYuval Mintz u32 size; 1065fe56b9e6SYuval Mintz 1066fe56b9e6SYuval Mintz if (cid_cnt == 0) 1067fe56b9e6SYuval Mintz continue; 1068fe56b9e6SYuval Mintz 1069fe56b9e6SYuval Mintz size = DIV_ROUND_UP(cid_cnt, 1070fe56b9e6SYuval Mintz sizeof(unsigned long) * BITS_PER_BYTE) * 1071fe56b9e6SYuval Mintz sizeof(unsigned long); 1072fe56b9e6SYuval Mintz p_mngr->acquired[type].cid_map = kzalloc(size, GFP_KERNEL); 1073fe56b9e6SYuval Mintz if (!p_mngr->acquired[type].cid_map) 1074fe56b9e6SYuval Mintz goto cid_map_fail; 1075fe56b9e6SYuval Mintz 1076fe56b9e6SYuval Mintz p_mngr->acquired[type].max_count = cid_cnt; 1077fe56b9e6SYuval Mintz p_mngr->acquired[type].start_cid = start_cid; 1078fe56b9e6SYuval Mintz 1079fe56b9e6SYuval Mintz p_hwfn->p_cxt_mngr->conn_cfg[type].cid_start = start_cid; 1080fe56b9e6SYuval Mintz 1081fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_CXT, 1082fe56b9e6SYuval Mintz "Type %08x start: %08x count %08x\n", 1083fe56b9e6SYuval Mintz type, p_mngr->acquired[type].start_cid, 1084fe56b9e6SYuval Mintz p_mngr->acquired[type].max_count); 1085fe56b9e6SYuval Mintz start_cid += cid_cnt; 1086fe56b9e6SYuval Mintz } 1087fe56b9e6SYuval Mintz 1088fe56b9e6SYuval Mintz return 0; 1089fe56b9e6SYuval Mintz 1090fe56b9e6SYuval Mintz cid_map_fail: 1091fe56b9e6SYuval Mintz qed_cid_map_free(p_hwfn); 1092fe56b9e6SYuval Mintz return -ENOMEM; 1093fe56b9e6SYuval Mintz } 1094fe56b9e6SYuval Mintz 1095fe56b9e6SYuval Mintz int qed_cxt_mngr_alloc(struct qed_hwfn *p_hwfn) 1096fe56b9e6SYuval Mintz { 1097dbb799c3SYuval Mintz struct qed_ilt_client_cfg *clients; 1098fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr; 1099fe56b9e6SYuval Mintz u32 i; 1100fe56b9e6SYuval Mintz 110160fffb3bSYuval Mintz p_mngr = kzalloc(sizeof(*p_mngr), GFP_KERNEL); 11022591c280SJoe Perches if (!p_mngr) 1103fe56b9e6SYuval Mintz return -ENOMEM; 1104fe56b9e6SYuval Mintz 1105fe56b9e6SYuval Mintz /* Initialize ILT client registers */ 1106dbb799c3SYuval Mintz clients = p_mngr->clients; 1107dbb799c3SYuval Mintz clients[ILT_CLI_CDUC].first.reg = ILT_CFG_REG(CDUC, FIRST_ILT); 1108dbb799c3SYuval Mintz clients[ILT_CLI_CDUC].last.reg = ILT_CFG_REG(CDUC, LAST_ILT); 1109dbb799c3SYuval Mintz clients[ILT_CLI_CDUC].p_size.reg = ILT_CFG_REG(CDUC, P_SIZE); 1110fe56b9e6SYuval Mintz 1111dbb799c3SYuval Mintz clients[ILT_CLI_QM].first.reg = ILT_CFG_REG(QM, FIRST_ILT); 1112dbb799c3SYuval Mintz clients[ILT_CLI_QM].last.reg = ILT_CFG_REG(QM, LAST_ILT); 1113dbb799c3SYuval Mintz clients[ILT_CLI_QM].p_size.reg = ILT_CFG_REG(QM, P_SIZE); 1114fe56b9e6SYuval Mintz 1115dbb799c3SYuval Mintz clients[ILT_CLI_TM].first.reg = ILT_CFG_REG(TM, FIRST_ILT); 1116dbb799c3SYuval Mintz clients[ILT_CLI_TM].last.reg = ILT_CFG_REG(TM, LAST_ILT); 1117dbb799c3SYuval Mintz clients[ILT_CLI_TM].p_size.reg = ILT_CFG_REG(TM, P_SIZE); 1118dbb799c3SYuval Mintz 1119dbb799c3SYuval Mintz clients[ILT_CLI_SRC].first.reg = ILT_CFG_REG(SRC, FIRST_ILT); 1120dbb799c3SYuval Mintz clients[ILT_CLI_SRC].last.reg = ILT_CFG_REG(SRC, LAST_ILT); 1121dbb799c3SYuval Mintz clients[ILT_CLI_SRC].p_size.reg = ILT_CFG_REG(SRC, P_SIZE); 1122dbb799c3SYuval Mintz 1123dbb799c3SYuval Mintz clients[ILT_CLI_CDUT].first.reg = ILT_CFG_REG(CDUT, FIRST_ILT); 1124dbb799c3SYuval Mintz clients[ILT_CLI_CDUT].last.reg = ILT_CFG_REG(CDUT, LAST_ILT); 1125dbb799c3SYuval Mintz clients[ILT_CLI_CDUT].p_size.reg = ILT_CFG_REG(CDUT, P_SIZE); 1126dbb799c3SYuval Mintz 1127dbb799c3SYuval Mintz clients[ILT_CLI_TSDM].first.reg = ILT_CFG_REG(TSDM, FIRST_ILT); 1128dbb799c3SYuval Mintz clients[ILT_CLI_TSDM].last.reg = ILT_CFG_REG(TSDM, LAST_ILT); 1129dbb799c3SYuval Mintz clients[ILT_CLI_TSDM].p_size.reg = ILT_CFG_REG(TSDM, P_SIZE); 1130fe56b9e6SYuval Mintz /* default ILT page size for all clients is 32K */ 1131fe56b9e6SYuval Mintz for (i = 0; i < ILT_CLI_MAX; i++) 1132fe56b9e6SYuval Mintz p_mngr->clients[i].p_size.val = ILT_DEFAULT_HW_P_SIZE; 1133fe56b9e6SYuval Mintz 1134dbb799c3SYuval Mintz /* Initialize task sizes */ 1135dbb799c3SYuval Mintz p_mngr->task_type_size[0] = TYPE0_TASK_CXT_SIZE(p_hwfn); 1136dbb799c3SYuval Mintz p_mngr->task_type_size[1] = TYPE1_TASK_CXT_SIZE(p_hwfn); 1137dbb799c3SYuval Mintz 11381408cc1fSYuval Mintz if (p_hwfn->cdev->p_iov_info) 11391408cc1fSYuval Mintz p_mngr->vf_count = p_hwfn->cdev->p_iov_info->total_vfs; 1140dbb799c3SYuval Mintz /* Initialize the dynamic ILT allocation mutex */ 1141dbb799c3SYuval Mintz mutex_init(&p_mngr->mutex); 11421408cc1fSYuval Mintz 1143fe56b9e6SYuval Mintz /* Set the cxt mangr pointer priori to further allocations */ 1144fe56b9e6SYuval Mintz p_hwfn->p_cxt_mngr = p_mngr; 1145fe56b9e6SYuval Mintz 1146fe56b9e6SYuval Mintz return 0; 1147fe56b9e6SYuval Mintz } 1148fe56b9e6SYuval Mintz 1149fe56b9e6SYuval Mintz int qed_cxt_tables_alloc(struct qed_hwfn *p_hwfn) 1150fe56b9e6SYuval Mintz { 1151fe56b9e6SYuval Mintz int rc; 1152fe56b9e6SYuval Mintz 1153fe56b9e6SYuval Mintz /* Allocate the ILT shadow table */ 1154fe56b9e6SYuval Mintz rc = qed_ilt_shadow_alloc(p_hwfn); 11552591c280SJoe Perches if (rc) 1156fe56b9e6SYuval Mintz goto tables_alloc_fail; 1157fe56b9e6SYuval Mintz 1158dbb799c3SYuval Mintz /* Allocate the T2 table */ 1159dbb799c3SYuval Mintz rc = qed_cxt_src_t2_alloc(p_hwfn); 11602591c280SJoe Perches if (rc) 1161dbb799c3SYuval Mintz goto tables_alloc_fail; 1162dbb799c3SYuval Mintz 1163fe56b9e6SYuval Mintz /* Allocate and initialize the acquired cids bitmaps */ 1164fe56b9e6SYuval Mintz rc = qed_cid_map_alloc(p_hwfn); 11652591c280SJoe Perches if (rc) 1166fe56b9e6SYuval Mintz goto tables_alloc_fail; 1167fe56b9e6SYuval Mintz 1168fe56b9e6SYuval Mintz return 0; 1169fe56b9e6SYuval Mintz 1170fe56b9e6SYuval Mintz tables_alloc_fail: 1171fe56b9e6SYuval Mintz qed_cxt_mngr_free(p_hwfn); 1172fe56b9e6SYuval Mintz return rc; 1173fe56b9e6SYuval Mintz } 1174fe56b9e6SYuval Mintz 1175fe56b9e6SYuval Mintz void qed_cxt_mngr_free(struct qed_hwfn *p_hwfn) 1176fe56b9e6SYuval Mintz { 1177fe56b9e6SYuval Mintz if (!p_hwfn->p_cxt_mngr) 1178fe56b9e6SYuval Mintz return; 1179fe56b9e6SYuval Mintz 1180fe56b9e6SYuval Mintz qed_cid_map_free(p_hwfn); 1181dbb799c3SYuval Mintz qed_cxt_src_t2_free(p_hwfn); 1182fe56b9e6SYuval Mintz qed_ilt_shadow_free(p_hwfn); 1183fe56b9e6SYuval Mintz kfree(p_hwfn->p_cxt_mngr); 1184fe56b9e6SYuval Mintz 1185fe56b9e6SYuval Mintz p_hwfn->p_cxt_mngr = NULL; 1186fe56b9e6SYuval Mintz } 1187fe56b9e6SYuval Mintz 1188fe56b9e6SYuval Mintz void qed_cxt_mngr_setup(struct qed_hwfn *p_hwfn) 1189fe56b9e6SYuval Mintz { 1190fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1191fe56b9e6SYuval Mintz int type; 1192fe56b9e6SYuval Mintz 1193fe56b9e6SYuval Mintz /* Reset acquired cids */ 1194fe56b9e6SYuval Mintz for (type = 0; type < MAX_CONN_TYPES; type++) { 1195fe56b9e6SYuval Mintz u32 cid_cnt = p_hwfn->p_cxt_mngr->conn_cfg[type].cid_count; 1196fe56b9e6SYuval Mintz 1197fe56b9e6SYuval Mintz if (cid_cnt == 0) 1198fe56b9e6SYuval Mintz continue; 1199fe56b9e6SYuval Mintz 1200fe56b9e6SYuval Mintz memset(p_mngr->acquired[type].cid_map, 0, 1201fe56b9e6SYuval Mintz DIV_ROUND_UP(cid_cnt, 1202fe56b9e6SYuval Mintz sizeof(unsigned long) * BITS_PER_BYTE) * 1203fe56b9e6SYuval Mintz sizeof(unsigned long)); 1204fe56b9e6SYuval Mintz } 1205fe56b9e6SYuval Mintz } 1206fe56b9e6SYuval Mintz 1207fe56b9e6SYuval Mintz /* CDU Common */ 1208fe56b9e6SYuval Mintz #define CDUC_CXT_SIZE_SHIFT \ 1209fe56b9e6SYuval Mintz CDU_REG_CID_ADDR_PARAMS_CONTEXT_SIZE_SHIFT 1210fe56b9e6SYuval Mintz 1211fe56b9e6SYuval Mintz #define CDUC_CXT_SIZE_MASK \ 1212fe56b9e6SYuval Mintz (CDU_REG_CID_ADDR_PARAMS_CONTEXT_SIZE >> CDUC_CXT_SIZE_SHIFT) 1213fe56b9e6SYuval Mintz 1214fe56b9e6SYuval Mintz #define CDUC_BLOCK_WASTE_SHIFT \ 1215fe56b9e6SYuval Mintz CDU_REG_CID_ADDR_PARAMS_BLOCK_WASTE_SHIFT 1216fe56b9e6SYuval Mintz 1217fe56b9e6SYuval Mintz #define CDUC_BLOCK_WASTE_MASK \ 1218fe56b9e6SYuval Mintz (CDU_REG_CID_ADDR_PARAMS_BLOCK_WASTE >> CDUC_BLOCK_WASTE_SHIFT) 1219fe56b9e6SYuval Mintz 1220fe56b9e6SYuval Mintz #define CDUC_NCIB_SHIFT \ 1221fe56b9e6SYuval Mintz CDU_REG_CID_ADDR_PARAMS_NCIB_SHIFT 1222fe56b9e6SYuval Mintz 1223fe56b9e6SYuval Mintz #define CDUC_NCIB_MASK \ 1224fe56b9e6SYuval Mintz (CDU_REG_CID_ADDR_PARAMS_NCIB >> CDUC_NCIB_SHIFT) 1225fe56b9e6SYuval Mintz 1226dbb799c3SYuval Mintz #define CDUT_TYPE0_CXT_SIZE_SHIFT \ 1227dbb799c3SYuval Mintz CDU_REG_SEGMENT0_PARAMS_T0_TID_SIZE_SHIFT 1228dbb799c3SYuval Mintz 1229dbb799c3SYuval Mintz #define CDUT_TYPE0_CXT_SIZE_MASK \ 1230dbb799c3SYuval Mintz (CDU_REG_SEGMENT0_PARAMS_T0_TID_SIZE >> \ 1231dbb799c3SYuval Mintz CDUT_TYPE0_CXT_SIZE_SHIFT) 1232dbb799c3SYuval Mintz 1233dbb799c3SYuval Mintz #define CDUT_TYPE0_BLOCK_WASTE_SHIFT \ 1234dbb799c3SYuval Mintz CDU_REG_SEGMENT0_PARAMS_T0_TID_BLOCK_WASTE_SHIFT 1235dbb799c3SYuval Mintz 1236dbb799c3SYuval Mintz #define CDUT_TYPE0_BLOCK_WASTE_MASK \ 1237dbb799c3SYuval Mintz (CDU_REG_SEGMENT0_PARAMS_T0_TID_BLOCK_WASTE >> \ 1238dbb799c3SYuval Mintz CDUT_TYPE0_BLOCK_WASTE_SHIFT) 1239dbb799c3SYuval Mintz 1240dbb799c3SYuval Mintz #define CDUT_TYPE0_NCIB_SHIFT \ 1241dbb799c3SYuval Mintz CDU_REG_SEGMENT0_PARAMS_T0_NUM_TIDS_IN_BLOCK_SHIFT 1242dbb799c3SYuval Mintz 1243dbb799c3SYuval Mintz #define CDUT_TYPE0_NCIB_MASK \ 1244dbb799c3SYuval Mintz (CDU_REG_SEGMENT0_PARAMS_T0_NUM_TIDS_IN_BLOCK >> \ 1245dbb799c3SYuval Mintz CDUT_TYPE0_NCIB_SHIFT) 1246dbb799c3SYuval Mintz 1247dbb799c3SYuval Mintz #define CDUT_TYPE1_CXT_SIZE_SHIFT \ 1248dbb799c3SYuval Mintz CDU_REG_SEGMENT1_PARAMS_T1_TID_SIZE_SHIFT 1249dbb799c3SYuval Mintz 1250dbb799c3SYuval Mintz #define CDUT_TYPE1_CXT_SIZE_MASK \ 1251dbb799c3SYuval Mintz (CDU_REG_SEGMENT1_PARAMS_T1_TID_SIZE >> \ 1252dbb799c3SYuval Mintz CDUT_TYPE1_CXT_SIZE_SHIFT) 1253dbb799c3SYuval Mintz 1254dbb799c3SYuval Mintz #define CDUT_TYPE1_BLOCK_WASTE_SHIFT \ 1255dbb799c3SYuval Mintz CDU_REG_SEGMENT1_PARAMS_T1_TID_BLOCK_WASTE_SHIFT 1256dbb799c3SYuval Mintz 1257dbb799c3SYuval Mintz #define CDUT_TYPE1_BLOCK_WASTE_MASK \ 1258dbb799c3SYuval Mintz (CDU_REG_SEGMENT1_PARAMS_T1_TID_BLOCK_WASTE >> \ 1259dbb799c3SYuval Mintz CDUT_TYPE1_BLOCK_WASTE_SHIFT) 1260dbb799c3SYuval Mintz 1261dbb799c3SYuval Mintz #define CDUT_TYPE1_NCIB_SHIFT \ 1262dbb799c3SYuval Mintz CDU_REG_SEGMENT1_PARAMS_T1_NUM_TIDS_IN_BLOCK_SHIFT 1263dbb799c3SYuval Mintz 1264dbb799c3SYuval Mintz #define CDUT_TYPE1_NCIB_MASK \ 1265dbb799c3SYuval Mintz (CDU_REG_SEGMENT1_PARAMS_T1_NUM_TIDS_IN_BLOCK >> \ 1266dbb799c3SYuval Mintz CDUT_TYPE1_NCIB_SHIFT) 1267dbb799c3SYuval Mintz 1268fe56b9e6SYuval Mintz static void qed_cdu_init_common(struct qed_hwfn *p_hwfn) 1269fe56b9e6SYuval Mintz { 1270fe56b9e6SYuval Mintz u32 page_sz, elems_per_page, block_waste, cxt_size, cdu_params = 0; 1271fe56b9e6SYuval Mintz 1272fe56b9e6SYuval Mintz /* CDUC - connection configuration */ 1273fe56b9e6SYuval Mintz page_sz = p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC].p_size.val; 1274fe56b9e6SYuval Mintz cxt_size = CONN_CXT_SIZE(p_hwfn); 1275fe56b9e6SYuval Mintz elems_per_page = ILT_PAGE_IN_BYTES(page_sz) / cxt_size; 1276fe56b9e6SYuval Mintz block_waste = ILT_PAGE_IN_BYTES(page_sz) - elems_per_page * cxt_size; 1277fe56b9e6SYuval Mintz 1278fe56b9e6SYuval Mintz SET_FIELD(cdu_params, CDUC_CXT_SIZE, cxt_size); 1279fe56b9e6SYuval Mintz SET_FIELD(cdu_params, CDUC_BLOCK_WASTE, block_waste); 1280fe56b9e6SYuval Mintz SET_FIELD(cdu_params, CDUC_NCIB, elems_per_page); 1281fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, CDU_REG_CID_ADDR_PARAMS_RT_OFFSET, cdu_params); 1282dbb799c3SYuval Mintz 1283dbb799c3SYuval Mintz /* CDUT - type-0 tasks configuration */ 1284dbb799c3SYuval Mintz page_sz = p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUT].p_size.val; 1285dbb799c3SYuval Mintz cxt_size = p_hwfn->p_cxt_mngr->task_type_size[0]; 1286dbb799c3SYuval Mintz elems_per_page = ILT_PAGE_IN_BYTES(page_sz) / cxt_size; 1287dbb799c3SYuval Mintz block_waste = ILT_PAGE_IN_BYTES(page_sz) - elems_per_page * cxt_size; 1288dbb799c3SYuval Mintz 1289dbb799c3SYuval Mintz /* cxt size and block-waste are multipes of 8 */ 1290dbb799c3SYuval Mintz cdu_params = 0; 1291dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE0_CXT_SIZE, (cxt_size >> 3)); 1292dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE0_BLOCK_WASTE, (block_waste >> 3)); 1293dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE0_NCIB, elems_per_page); 1294dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, CDU_REG_SEGMENT0_PARAMS_RT_OFFSET, cdu_params); 1295dbb799c3SYuval Mintz 1296dbb799c3SYuval Mintz /* CDUT - type-1 tasks configuration */ 1297dbb799c3SYuval Mintz cxt_size = p_hwfn->p_cxt_mngr->task_type_size[1]; 1298dbb799c3SYuval Mintz elems_per_page = ILT_PAGE_IN_BYTES(page_sz) / cxt_size; 1299dbb799c3SYuval Mintz block_waste = ILT_PAGE_IN_BYTES(page_sz) - elems_per_page * cxt_size; 1300dbb799c3SYuval Mintz 1301dbb799c3SYuval Mintz /* cxt size and block-waste are multipes of 8 */ 1302dbb799c3SYuval Mintz cdu_params = 0; 1303dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE1_CXT_SIZE, (cxt_size >> 3)); 1304dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE1_BLOCK_WASTE, (block_waste >> 3)); 1305dbb799c3SYuval Mintz SET_FIELD(cdu_params, CDUT_TYPE1_NCIB, elems_per_page); 1306dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, CDU_REG_SEGMENT1_PARAMS_RT_OFFSET, cdu_params); 1307dbb799c3SYuval Mintz } 1308dbb799c3SYuval Mintz 1309dbb799c3SYuval Mintz /* CDU PF */ 1310dbb799c3SYuval Mintz #define CDU_SEG_REG_TYPE_SHIFT CDU_SEG_TYPE_OFFSET_REG_TYPE_SHIFT 1311dbb799c3SYuval Mintz #define CDU_SEG_REG_TYPE_MASK 0x1 1312dbb799c3SYuval Mintz #define CDU_SEG_REG_OFFSET_SHIFT 0 1313dbb799c3SYuval Mintz #define CDU_SEG_REG_OFFSET_MASK CDU_SEG_TYPE_OFFSET_REG_OFFSET_MASK 1314dbb799c3SYuval Mintz 1315dbb799c3SYuval Mintz static void qed_cdu_init_pf(struct qed_hwfn *p_hwfn) 1316dbb799c3SYuval Mintz { 1317dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 1318dbb799c3SYuval Mintz struct qed_tid_seg *p_seg; 1319dbb799c3SYuval Mintz u32 cdu_seg_params, offset; 1320dbb799c3SYuval Mintz int i; 1321dbb799c3SYuval Mintz 1322dbb799c3SYuval Mintz static const u32 rt_type_offset_arr[] = { 1323dbb799c3SYuval Mintz CDU_REG_PF_SEG0_TYPE_OFFSET_RT_OFFSET, 1324dbb799c3SYuval Mintz CDU_REG_PF_SEG1_TYPE_OFFSET_RT_OFFSET, 1325dbb799c3SYuval Mintz CDU_REG_PF_SEG2_TYPE_OFFSET_RT_OFFSET, 1326dbb799c3SYuval Mintz CDU_REG_PF_SEG3_TYPE_OFFSET_RT_OFFSET 1327dbb799c3SYuval Mintz }; 1328dbb799c3SYuval Mintz 1329dbb799c3SYuval Mintz static const u32 rt_type_offset_fl_arr[] = { 1330dbb799c3SYuval Mintz CDU_REG_PF_FL_SEG0_TYPE_OFFSET_RT_OFFSET, 1331dbb799c3SYuval Mintz CDU_REG_PF_FL_SEG1_TYPE_OFFSET_RT_OFFSET, 1332dbb799c3SYuval Mintz CDU_REG_PF_FL_SEG2_TYPE_OFFSET_RT_OFFSET, 1333dbb799c3SYuval Mintz CDU_REG_PF_FL_SEG3_TYPE_OFFSET_RT_OFFSET 1334dbb799c3SYuval Mintz }; 1335dbb799c3SYuval Mintz 1336dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUT]; 1337dbb799c3SYuval Mintz 1338dbb799c3SYuval Mintz /* There are initializations only for CDUT during pf Phase */ 1339dbb799c3SYuval Mintz for (i = 0; i < NUM_TASK_PF_SEGMENTS; i++) { 1340dbb799c3SYuval Mintz /* Segment 0 */ 1341dbb799c3SYuval Mintz p_seg = qed_cxt_tid_seg_info(p_hwfn, i); 1342dbb799c3SYuval Mintz if (!p_seg) 1343dbb799c3SYuval Mintz continue; 1344dbb799c3SYuval Mintz 1345dbb799c3SYuval Mintz /* Note: start_line is already adjusted for the CDU 1346dbb799c3SYuval Mintz * segment register granularity, so we just need to 1347dbb799c3SYuval Mintz * divide. Adjustment is implicit as we assume ILT 1348dbb799c3SYuval Mintz * Page size is larger than 32K! 1349dbb799c3SYuval Mintz */ 1350dbb799c3SYuval Mintz offset = (ILT_PAGE_IN_BYTES(p_cli->p_size.val) * 1351dbb799c3SYuval Mintz (p_cli->pf_blks[CDUT_SEG_BLK(i)].start_line - 1352dbb799c3SYuval Mintz p_cli->first.val)) / CDUT_SEG_ALIGNMET_IN_BYTES; 1353dbb799c3SYuval Mintz 1354dbb799c3SYuval Mintz cdu_seg_params = 0; 1355dbb799c3SYuval Mintz SET_FIELD(cdu_seg_params, CDU_SEG_REG_TYPE, p_seg->type); 1356dbb799c3SYuval Mintz SET_FIELD(cdu_seg_params, CDU_SEG_REG_OFFSET, offset); 1357dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, rt_type_offset_arr[i], cdu_seg_params); 1358dbb799c3SYuval Mintz 1359dbb799c3SYuval Mintz offset = (ILT_PAGE_IN_BYTES(p_cli->p_size.val) * 1360dbb799c3SYuval Mintz (p_cli->pf_blks[CDUT_FL_SEG_BLK(i, PF)].start_line - 1361dbb799c3SYuval Mintz p_cli->first.val)) / CDUT_SEG_ALIGNMET_IN_BYTES; 1362dbb799c3SYuval Mintz 1363dbb799c3SYuval Mintz cdu_seg_params = 0; 1364dbb799c3SYuval Mintz SET_FIELD(cdu_seg_params, CDU_SEG_REG_TYPE, p_seg->type); 1365dbb799c3SYuval Mintz SET_FIELD(cdu_seg_params, CDU_SEG_REG_OFFSET, offset); 1366dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, rt_type_offset_fl_arr[i], cdu_seg_params); 1367dbb799c3SYuval Mintz } 1368fe56b9e6SYuval Mintz } 1369fe56b9e6SYuval Mintz 1370fe56b9e6SYuval Mintz void qed_qm_init_pf(struct qed_hwfn *p_hwfn) 1371fe56b9e6SYuval Mintz { 1372fe56b9e6SYuval Mintz struct qed_qm_pf_rt_init_params params; 1373fe56b9e6SYuval Mintz struct qed_qm_info *qm_info = &p_hwfn->qm_info; 1374fe56b9e6SYuval Mintz struct qed_qm_iids iids; 1375fe56b9e6SYuval Mintz 1376fe56b9e6SYuval Mintz memset(&iids, 0, sizeof(iids)); 1377fe56b9e6SYuval Mintz qed_cxt_qm_iids(p_hwfn, &iids); 1378fe56b9e6SYuval Mintz 1379fe56b9e6SYuval Mintz memset(¶ms, 0, sizeof(params)); 1380fe56b9e6SYuval Mintz params.port_id = p_hwfn->port_id; 1381fe56b9e6SYuval Mintz params.pf_id = p_hwfn->rel_pf_id; 1382fe56b9e6SYuval Mintz params.max_phys_tcs_per_port = qm_info->max_phys_tcs_per_port; 1383fe56b9e6SYuval Mintz params.is_first_pf = p_hwfn->first_on_engine; 1384fe56b9e6SYuval Mintz params.num_pf_cids = iids.cids; 13851408cc1fSYuval Mintz params.num_vf_cids = iids.vf_cids; 1386fe56b9e6SYuval Mintz params.start_pq = qm_info->start_pq; 13871408cc1fSYuval Mintz params.num_pf_pqs = qm_info->num_pqs - qm_info->num_vf_pqs; 13881408cc1fSYuval Mintz params.num_vf_pqs = qm_info->num_vf_pqs; 1389fc48b7a6SYuval Mintz params.start_vport = qm_info->start_vport; 1390fc48b7a6SYuval Mintz params.num_vports = qm_info->num_vports; 1391fe56b9e6SYuval Mintz params.pf_wfq = qm_info->pf_wfq; 1392fe56b9e6SYuval Mintz params.pf_rl = qm_info->pf_rl; 1393fe56b9e6SYuval Mintz params.pq_params = qm_info->qm_pq_params; 1394fe56b9e6SYuval Mintz params.vport_params = qm_info->qm_vport_params; 1395fe56b9e6SYuval Mintz 1396fe56b9e6SYuval Mintz qed_qm_pf_rt_init(p_hwfn, p_hwfn->p_main_ptt, ¶ms); 1397fe56b9e6SYuval Mintz } 1398fe56b9e6SYuval Mintz 1399fe56b9e6SYuval Mintz /* CM PF */ 1400fe56b9e6SYuval Mintz static int qed_cm_init_pf(struct qed_hwfn *p_hwfn) 1401fe56b9e6SYuval Mintz { 1402fe56b9e6SYuval Mintz union qed_qm_pq_params pq_params; 1403fe56b9e6SYuval Mintz u16 pq; 1404fe56b9e6SYuval Mintz 1405fe56b9e6SYuval Mintz /* XCM pure-LB queue */ 1406fe56b9e6SYuval Mintz memset(&pq_params, 0, sizeof(pq_params)); 1407fe56b9e6SYuval Mintz pq_params.core.tc = LB_TC; 1408fe56b9e6SYuval Mintz pq = qed_get_qm_pq(p_hwfn, PROTOCOLID_CORE, &pq_params); 1409fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, XCM_REG_CON_PHY_Q3_RT_OFFSET, pq); 1410fe56b9e6SYuval Mintz 1411fe56b9e6SYuval Mintz return 0; 1412fe56b9e6SYuval Mintz } 1413fe56b9e6SYuval Mintz 1414fe56b9e6SYuval Mintz /* DQ PF */ 1415fe56b9e6SYuval Mintz static void qed_dq_init_pf(struct qed_hwfn *p_hwfn) 1416fe56b9e6SYuval Mintz { 1417fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 14181408cc1fSYuval Mintz u32 dq_pf_max_cid = 0, dq_vf_max_cid = 0; 1419fe56b9e6SYuval Mintz 1420fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[0].cid_count >> DQ_RANGE_SHIFT); 1421fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_0_RT_OFFSET, dq_pf_max_cid); 1422fe56b9e6SYuval Mintz 14231408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[0].cids_per_vf >> DQ_RANGE_SHIFT); 14241408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_0_RT_OFFSET, dq_vf_max_cid); 14251408cc1fSYuval Mintz 1426fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[1].cid_count >> DQ_RANGE_SHIFT); 1427fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_1_RT_OFFSET, dq_pf_max_cid); 1428fe56b9e6SYuval Mintz 14291408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[1].cids_per_vf >> DQ_RANGE_SHIFT); 14301408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_1_RT_OFFSET, dq_vf_max_cid); 14311408cc1fSYuval Mintz 1432fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[2].cid_count >> DQ_RANGE_SHIFT); 1433fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_2_RT_OFFSET, dq_pf_max_cid); 1434fe56b9e6SYuval Mintz 14351408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[2].cids_per_vf >> DQ_RANGE_SHIFT); 14361408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_2_RT_OFFSET, dq_vf_max_cid); 14371408cc1fSYuval Mintz 1438fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[3].cid_count >> DQ_RANGE_SHIFT); 1439fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_3_RT_OFFSET, dq_pf_max_cid); 1440fe56b9e6SYuval Mintz 14411408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[3].cids_per_vf >> DQ_RANGE_SHIFT); 14421408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_3_RT_OFFSET, dq_vf_max_cid); 14431408cc1fSYuval Mintz 1444fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[4].cid_count >> DQ_RANGE_SHIFT); 1445fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_4_RT_OFFSET, dq_pf_max_cid); 1446fe56b9e6SYuval Mintz 14471408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[4].cids_per_vf >> DQ_RANGE_SHIFT); 14481408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_4_RT_OFFSET, dq_vf_max_cid); 14491408cc1fSYuval Mintz 1450fe56b9e6SYuval Mintz dq_pf_max_cid += (p_mngr->conn_cfg[5].cid_count >> DQ_RANGE_SHIFT); 1451fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_5_RT_OFFSET, dq_pf_max_cid); 14521408cc1fSYuval Mintz 14531408cc1fSYuval Mintz dq_vf_max_cid += (p_mngr->conn_cfg[5].cids_per_vf >> DQ_RANGE_SHIFT); 14541408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_5_RT_OFFSET, dq_vf_max_cid); 14551408cc1fSYuval Mintz 14561408cc1fSYuval Mintz /* Connection types 6 & 7 are not in use, yet they must be configured 14571408cc1fSYuval Mintz * as the highest possible connection. Not configuring them means the 14581408cc1fSYuval Mintz * defaults will be used, and with a large number of cids a bug may 14591408cc1fSYuval Mintz * occur, if the defaults will be smaller than dq_pf_max_cid / 14601408cc1fSYuval Mintz * dq_vf_max_cid. 14611408cc1fSYuval Mintz */ 14621408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_6_RT_OFFSET, dq_pf_max_cid); 14631408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_6_RT_OFFSET, dq_vf_max_cid); 14641408cc1fSYuval Mintz 14651408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_PF_MAX_ICID_7_RT_OFFSET, dq_pf_max_cid); 14661408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, DORQ_REG_VF_MAX_ICID_7_RT_OFFSET, dq_vf_max_cid); 1467fe56b9e6SYuval Mintz } 1468fe56b9e6SYuval Mintz 1469fe56b9e6SYuval Mintz static void qed_ilt_bounds_init(struct qed_hwfn *p_hwfn) 1470fe56b9e6SYuval Mintz { 1471fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *ilt_clients; 1472fe56b9e6SYuval Mintz int i; 1473fe56b9e6SYuval Mintz 1474fe56b9e6SYuval Mintz ilt_clients = p_hwfn->p_cxt_mngr->clients; 1475fe56b9e6SYuval Mintz for_each_ilt_valid_client(i, ilt_clients) { 1476fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, 1477fe56b9e6SYuval Mintz ilt_clients[i].first.reg, 1478fe56b9e6SYuval Mintz ilt_clients[i].first.val); 1479fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, 1480dbb799c3SYuval Mintz ilt_clients[i].last.reg, ilt_clients[i].last.val); 1481fe56b9e6SYuval Mintz STORE_RT_REG(p_hwfn, 1482fe56b9e6SYuval Mintz ilt_clients[i].p_size.reg, 1483fe56b9e6SYuval Mintz ilt_clients[i].p_size.val); 1484fe56b9e6SYuval Mintz } 1485fe56b9e6SYuval Mintz } 1486fe56b9e6SYuval Mintz 14871408cc1fSYuval Mintz static void qed_ilt_vf_bounds_init(struct qed_hwfn *p_hwfn) 14881408cc1fSYuval Mintz { 14891408cc1fSYuval Mintz struct qed_ilt_client_cfg *p_cli; 14901408cc1fSYuval Mintz u32 blk_factor; 14911408cc1fSYuval Mintz 14921408cc1fSYuval Mintz /* For simplicty we set the 'block' to be an ILT page */ 14931408cc1fSYuval Mintz if (p_hwfn->cdev->p_iov_info) { 14941408cc1fSYuval Mintz struct qed_hw_sriov_info *p_iov = p_hwfn->cdev->p_iov_info; 14951408cc1fSYuval Mintz 14961408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, 14971408cc1fSYuval Mintz PSWRQ2_REG_VF_BASE_RT_OFFSET, 14981408cc1fSYuval Mintz p_iov->first_vf_in_pf); 14991408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, 15001408cc1fSYuval Mintz PSWRQ2_REG_VF_LAST_ILT_RT_OFFSET, 15011408cc1fSYuval Mintz p_iov->first_vf_in_pf + p_iov->total_vfs); 15021408cc1fSYuval Mintz } 15031408cc1fSYuval Mintz 15041408cc1fSYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC]; 15051408cc1fSYuval Mintz blk_factor = ilog2(ILT_PAGE_IN_BYTES(p_cli->p_size.val) >> 10); 15061408cc1fSYuval Mintz if (p_cli->active) { 15071408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, 15081408cc1fSYuval Mintz PSWRQ2_REG_CDUC_BLOCKS_FACTOR_RT_OFFSET, 15091408cc1fSYuval Mintz blk_factor); 15101408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, 15111408cc1fSYuval Mintz PSWRQ2_REG_CDUC_NUMBER_OF_PF_BLOCKS_RT_OFFSET, 15121408cc1fSYuval Mintz p_cli->pf_total_lines); 15131408cc1fSYuval Mintz STORE_RT_REG(p_hwfn, 15141408cc1fSYuval Mintz PSWRQ2_REG_CDUC_VF_BLOCKS_RT_OFFSET, 15151408cc1fSYuval Mintz p_cli->vf_total_lines); 15161408cc1fSYuval Mintz } 1517dbb799c3SYuval Mintz 1518dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUT]; 1519dbb799c3SYuval Mintz blk_factor = ilog2(ILT_PAGE_IN_BYTES(p_cli->p_size.val) >> 10); 1520dbb799c3SYuval Mintz if (p_cli->active) { 1521dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1522dbb799c3SYuval Mintz PSWRQ2_REG_CDUT_BLOCKS_FACTOR_RT_OFFSET, 1523dbb799c3SYuval Mintz blk_factor); 1524dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1525dbb799c3SYuval Mintz PSWRQ2_REG_CDUT_NUMBER_OF_PF_BLOCKS_RT_OFFSET, 1526dbb799c3SYuval Mintz p_cli->pf_total_lines); 1527dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1528dbb799c3SYuval Mintz PSWRQ2_REG_CDUT_VF_BLOCKS_RT_OFFSET, 1529dbb799c3SYuval Mintz p_cli->vf_total_lines); 1530dbb799c3SYuval Mintz } 1531dbb799c3SYuval Mintz 1532dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_TM]; 1533dbb799c3SYuval Mintz blk_factor = ilog2(ILT_PAGE_IN_BYTES(p_cli->p_size.val) >> 10); 1534dbb799c3SYuval Mintz if (p_cli->active) { 1535dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1536dbb799c3SYuval Mintz PSWRQ2_REG_TM_BLOCKS_FACTOR_RT_OFFSET, blk_factor); 1537dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1538dbb799c3SYuval Mintz PSWRQ2_REG_TM_NUMBER_OF_PF_BLOCKS_RT_OFFSET, 1539dbb799c3SYuval Mintz p_cli->pf_total_lines); 1540dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, 1541dbb799c3SYuval Mintz PSWRQ2_REG_TM_VF_BLOCKS_RT_OFFSET, 1542dbb799c3SYuval Mintz p_cli->vf_total_lines); 1543dbb799c3SYuval Mintz } 15441408cc1fSYuval Mintz } 15451408cc1fSYuval Mintz 1546fe56b9e6SYuval Mintz /* ILT (PSWRQ2) PF */ 1547fe56b9e6SYuval Mintz static void qed_ilt_init_pf(struct qed_hwfn *p_hwfn) 1548fe56b9e6SYuval Mintz { 1549fe56b9e6SYuval Mintz struct qed_ilt_client_cfg *clients; 1550fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr; 1551fe56b9e6SYuval Mintz struct qed_dma_mem *p_shdw; 1552fe56b9e6SYuval Mintz u32 line, rt_offst, i; 1553fe56b9e6SYuval Mintz 1554fe56b9e6SYuval Mintz qed_ilt_bounds_init(p_hwfn); 15551408cc1fSYuval Mintz qed_ilt_vf_bounds_init(p_hwfn); 1556fe56b9e6SYuval Mintz 1557fe56b9e6SYuval Mintz p_mngr = p_hwfn->p_cxt_mngr; 1558fe56b9e6SYuval Mintz p_shdw = p_mngr->ilt_shadow; 1559fe56b9e6SYuval Mintz clients = p_hwfn->p_cxt_mngr->clients; 1560fe56b9e6SYuval Mintz 1561fe56b9e6SYuval Mintz for_each_ilt_valid_client(i, clients) { 1562fe56b9e6SYuval Mintz /** Client's 1st val and RT array are absolute, ILT shadows' 1563fe56b9e6SYuval Mintz * lines are relative. 1564fe56b9e6SYuval Mintz */ 1565fe56b9e6SYuval Mintz line = clients[i].first.val - p_mngr->pf_start_line; 1566fe56b9e6SYuval Mintz rt_offst = PSWRQ2_REG_ILT_MEMORY_RT_OFFSET + 1567fe56b9e6SYuval Mintz clients[i].first.val * ILT_ENTRY_IN_REGS; 1568fe56b9e6SYuval Mintz 1569fe56b9e6SYuval Mintz for (; line <= clients[i].last.val - p_mngr->pf_start_line; 1570fe56b9e6SYuval Mintz line++, rt_offst += ILT_ENTRY_IN_REGS) { 1571fe56b9e6SYuval Mintz u64 ilt_hw_entry = 0; 1572fe56b9e6SYuval Mintz 1573fe56b9e6SYuval Mintz /** p_virt could be NULL incase of dynamic 1574fe56b9e6SYuval Mintz * allocation 1575fe56b9e6SYuval Mintz */ 1576fe56b9e6SYuval Mintz if (p_shdw[line].p_virt) { 1577fe56b9e6SYuval Mintz SET_FIELD(ilt_hw_entry, ILT_ENTRY_VALID, 1ULL); 1578fe56b9e6SYuval Mintz SET_FIELD(ilt_hw_entry, ILT_ENTRY_PHY_ADDR, 1579fe56b9e6SYuval Mintz (p_shdw[line].p_phys >> 12)); 1580fe56b9e6SYuval Mintz 1581fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_ILT, 1582fe56b9e6SYuval Mintz "Setting RT[0x%08x] from ILT[0x%08x] [Client is %d] to Physical addr: 0x%llx\n", 1583fe56b9e6SYuval Mintz rt_offst, line, i, 1584fe56b9e6SYuval Mintz (u64)(p_shdw[line].p_phys >> 12)); 1585fe56b9e6SYuval Mintz } 1586fe56b9e6SYuval Mintz 1587fe56b9e6SYuval Mintz STORE_RT_REG_AGG(p_hwfn, rt_offst, ilt_hw_entry); 1588fe56b9e6SYuval Mintz } 1589fe56b9e6SYuval Mintz } 1590fe56b9e6SYuval Mintz } 1591fe56b9e6SYuval Mintz 1592dbb799c3SYuval Mintz /* SRC (Searcher) PF */ 1593dbb799c3SYuval Mintz static void qed_src_init_pf(struct qed_hwfn *p_hwfn) 1594dbb799c3SYuval Mintz { 1595dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1596dbb799c3SYuval Mintz u32 rounded_conn_num, conn_num, conn_max; 1597dbb799c3SYuval Mintz struct qed_src_iids src_iids; 1598dbb799c3SYuval Mintz 1599dbb799c3SYuval Mintz memset(&src_iids, 0, sizeof(src_iids)); 1600dbb799c3SYuval Mintz qed_cxt_src_iids(p_mngr, &src_iids); 1601dbb799c3SYuval Mintz conn_num = src_iids.pf_cids + src_iids.per_vf_cids * p_mngr->vf_count; 1602dbb799c3SYuval Mintz if (!conn_num) 1603dbb799c3SYuval Mintz return; 1604dbb799c3SYuval Mintz 1605dbb799c3SYuval Mintz conn_max = max_t(u32, conn_num, SRC_MIN_NUM_ELEMS); 1606dbb799c3SYuval Mintz rounded_conn_num = roundup_pow_of_two(conn_max); 1607dbb799c3SYuval Mintz 1608dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, SRC_REG_COUNTFREE_RT_OFFSET, conn_num); 1609dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, SRC_REG_NUMBER_HASH_BITS_RT_OFFSET, 1610dbb799c3SYuval Mintz ilog2(rounded_conn_num)); 1611dbb799c3SYuval Mintz 1612dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, SRC_REG_FIRSTFREE_RT_OFFSET, 1613dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->first_free); 1614dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, SRC_REG_LASTFREE_RT_OFFSET, 1615dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->last_free); 1616dbb799c3SYuval Mintz } 1617dbb799c3SYuval Mintz 1618dbb799c3SYuval Mintz /* Timers PF */ 1619dbb799c3SYuval Mintz #define TM_CFG_NUM_IDS_SHIFT 0 1620dbb799c3SYuval Mintz #define TM_CFG_NUM_IDS_MASK 0xFFFFULL 1621dbb799c3SYuval Mintz #define TM_CFG_PRE_SCAN_OFFSET_SHIFT 16 1622dbb799c3SYuval Mintz #define TM_CFG_PRE_SCAN_OFFSET_MASK 0x1FFULL 1623dbb799c3SYuval Mintz #define TM_CFG_PARENT_PF_SHIFT 25 1624dbb799c3SYuval Mintz #define TM_CFG_PARENT_PF_MASK 0x7ULL 1625dbb799c3SYuval Mintz 1626dbb799c3SYuval Mintz #define TM_CFG_CID_PRE_SCAN_ROWS_SHIFT 30 1627dbb799c3SYuval Mintz #define TM_CFG_CID_PRE_SCAN_ROWS_MASK 0x1FFULL 1628dbb799c3SYuval Mintz 1629dbb799c3SYuval Mintz #define TM_CFG_TID_OFFSET_SHIFT 30 1630dbb799c3SYuval Mintz #define TM_CFG_TID_OFFSET_MASK 0x7FFFFULL 1631dbb799c3SYuval Mintz #define TM_CFG_TID_PRE_SCAN_ROWS_SHIFT 49 1632dbb799c3SYuval Mintz #define TM_CFG_TID_PRE_SCAN_ROWS_MASK 0x1FFULL 1633dbb799c3SYuval Mintz 1634dbb799c3SYuval Mintz static void qed_tm_init_pf(struct qed_hwfn *p_hwfn) 1635dbb799c3SYuval Mintz { 1636dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1637dbb799c3SYuval Mintz u32 active_seg_mask = 0, tm_offset, rt_reg; 1638dbb799c3SYuval Mintz struct qed_tm_iids tm_iids; 1639dbb799c3SYuval Mintz u64 cfg_word; 1640dbb799c3SYuval Mintz u8 i; 1641dbb799c3SYuval Mintz 1642dbb799c3SYuval Mintz memset(&tm_iids, 0, sizeof(tm_iids)); 1643dbb799c3SYuval Mintz qed_cxt_tm_iids(p_mngr, &tm_iids); 1644dbb799c3SYuval Mintz 1645dbb799c3SYuval Mintz /* @@@TBD No pre-scan for now */ 1646dbb799c3SYuval Mintz 1647dbb799c3SYuval Mintz /* Note: We assume consecutive VFs for a PF */ 1648dbb799c3SYuval Mintz for (i = 0; i < p_mngr->vf_count; i++) { 1649dbb799c3SYuval Mintz cfg_word = 0; 1650dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_NUM_IDS, tm_iids.per_vf_cids); 1651dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PRE_SCAN_OFFSET, 0); 1652dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PARENT_PF, p_hwfn->rel_pf_id); 1653dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_CID_PRE_SCAN_ROWS, 0); 1654dbb799c3SYuval Mintz rt_reg = TM_REG_CONFIG_CONN_MEM_RT_OFFSET + 1655dbb799c3SYuval Mintz (sizeof(cfg_word) / sizeof(u32)) * 1656dbb799c3SYuval Mintz (p_hwfn->cdev->p_iov_info->first_vf_in_pf + i); 1657dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, rt_reg, cfg_word); 1658dbb799c3SYuval Mintz } 1659dbb799c3SYuval Mintz 1660dbb799c3SYuval Mintz cfg_word = 0; 1661dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_NUM_IDS, tm_iids.pf_cids); 1662dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PRE_SCAN_OFFSET, 0); 1663dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PARENT_PF, 0); /* n/a for PF */ 1664dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_CID_PRE_SCAN_ROWS, 0); /* scan all */ 1665dbb799c3SYuval Mintz 1666dbb799c3SYuval Mintz rt_reg = TM_REG_CONFIG_CONN_MEM_RT_OFFSET + 1667dbb799c3SYuval Mintz (sizeof(cfg_word) / sizeof(u32)) * 1668dbb799c3SYuval Mintz (NUM_OF_VFS(p_hwfn->cdev) + p_hwfn->rel_pf_id); 1669dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, rt_reg, cfg_word); 1670dbb799c3SYuval Mintz 1671dbb799c3SYuval Mintz /* enale scan */ 1672dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, TM_REG_PF_ENABLE_CONN_RT_OFFSET, 1673dbb799c3SYuval Mintz tm_iids.pf_cids ? 0x1 : 0x0); 1674dbb799c3SYuval Mintz 1675dbb799c3SYuval Mintz /* @@@TBD how to enable the scan for the VFs */ 1676dbb799c3SYuval Mintz 1677dbb799c3SYuval Mintz tm_offset = tm_iids.per_vf_cids; 1678dbb799c3SYuval Mintz 1679dbb799c3SYuval Mintz /* Note: We assume consecutive VFs for a PF */ 1680dbb799c3SYuval Mintz for (i = 0; i < p_mngr->vf_count; i++) { 1681dbb799c3SYuval Mintz cfg_word = 0; 1682dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_NUM_IDS, tm_iids.per_vf_tids); 1683dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PRE_SCAN_OFFSET, 0); 1684dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PARENT_PF, p_hwfn->rel_pf_id); 1685dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_TID_OFFSET, tm_offset); 1686dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_TID_PRE_SCAN_ROWS, (u64) 0); 1687dbb799c3SYuval Mintz 1688dbb799c3SYuval Mintz rt_reg = TM_REG_CONFIG_TASK_MEM_RT_OFFSET + 1689dbb799c3SYuval Mintz (sizeof(cfg_word) / sizeof(u32)) * 1690dbb799c3SYuval Mintz (p_hwfn->cdev->p_iov_info->first_vf_in_pf + i); 1691dbb799c3SYuval Mintz 1692dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, rt_reg, cfg_word); 1693dbb799c3SYuval Mintz } 1694dbb799c3SYuval Mintz 1695dbb799c3SYuval Mintz tm_offset = tm_iids.pf_cids; 1696dbb799c3SYuval Mintz for (i = 0; i < NUM_TASK_PF_SEGMENTS; i++) { 1697dbb799c3SYuval Mintz cfg_word = 0; 1698dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_NUM_IDS, tm_iids.pf_tids[i]); 1699dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PRE_SCAN_OFFSET, 0); 1700dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_PARENT_PF, 0); 1701dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_TID_OFFSET, tm_offset); 1702dbb799c3SYuval Mintz SET_FIELD(cfg_word, TM_CFG_TID_PRE_SCAN_ROWS, (u64) 0); 1703dbb799c3SYuval Mintz 1704dbb799c3SYuval Mintz rt_reg = TM_REG_CONFIG_TASK_MEM_RT_OFFSET + 1705dbb799c3SYuval Mintz (sizeof(cfg_word) / sizeof(u32)) * 1706dbb799c3SYuval Mintz (NUM_OF_VFS(p_hwfn->cdev) + 1707dbb799c3SYuval Mintz p_hwfn->rel_pf_id * NUM_TASK_PF_SEGMENTS + i); 1708dbb799c3SYuval Mintz 1709dbb799c3SYuval Mintz STORE_RT_REG_AGG(p_hwfn, rt_reg, cfg_word); 17101a635e48SYuval Mintz active_seg_mask |= (tm_iids.pf_tids[i] ? BIT(i) : 0); 1711dbb799c3SYuval Mintz 1712dbb799c3SYuval Mintz tm_offset += tm_iids.pf_tids[i]; 1713dbb799c3SYuval Mintz } 1714dbb799c3SYuval Mintz 1715dbb799c3SYuval Mintz if (p_hwfn->hw_info.personality == QED_PCI_ETH_ROCE) 1716dbb799c3SYuval Mintz active_seg_mask = 0; 1717dbb799c3SYuval Mintz 1718dbb799c3SYuval Mintz STORE_RT_REG(p_hwfn, TM_REG_PF_ENABLE_TASK_RT_OFFSET, active_seg_mask); 1719dbb799c3SYuval Mintz 1720dbb799c3SYuval Mintz /* @@@TBD how to enable the scan for the VFs */ 1721dbb799c3SYuval Mintz } 1722dbb799c3SYuval Mintz 17231e128c81SArun Easi static void qed_prs_init_common(struct qed_hwfn *p_hwfn) 17241e128c81SArun Easi { 17251e128c81SArun Easi if ((p_hwfn->hw_info.personality == QED_PCI_FCOE) && 17261e128c81SArun Easi p_hwfn->pf_params.fcoe_pf_params.is_target) 17271e128c81SArun Easi STORE_RT_REG(p_hwfn, 17281e128c81SArun Easi PRS_REG_SEARCH_RESP_INITIATOR_TYPE_RT_OFFSET, 0); 17291e128c81SArun Easi } 17301e128c81SArun Easi 17311e128c81SArun Easi static void qed_prs_init_pf(struct qed_hwfn *p_hwfn) 17321e128c81SArun Easi { 17331e128c81SArun Easi struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 17341e128c81SArun Easi struct qed_conn_type_cfg *p_fcoe; 17351e128c81SArun Easi struct qed_tid_seg *p_tid; 17361e128c81SArun Easi 17371e128c81SArun Easi p_fcoe = &p_mngr->conn_cfg[PROTOCOLID_FCOE]; 17381e128c81SArun Easi 17391e128c81SArun Easi /* If FCoE is active set the MAX OX_ID (tid) in the Parser */ 17401e128c81SArun Easi if (!p_fcoe->cid_count) 17411e128c81SArun Easi return; 17421e128c81SArun Easi 17431e128c81SArun Easi p_tid = &p_fcoe->tid_seg[QED_CXT_FCOE_TID_SEG]; 17441e128c81SArun Easi if (p_hwfn->pf_params.fcoe_pf_params.is_target) { 17451e128c81SArun Easi STORE_RT_REG_AGG(p_hwfn, 17461e128c81SArun Easi PRS_REG_TASK_ID_MAX_TARGET_PF_RT_OFFSET, 17471e128c81SArun Easi p_tid->count); 17481e128c81SArun Easi } else { 17491e128c81SArun Easi STORE_RT_REG_AGG(p_hwfn, 17501e128c81SArun Easi PRS_REG_TASK_ID_MAX_INITIATOR_PF_RT_OFFSET, 17511e128c81SArun Easi p_tid->count); 17521e128c81SArun Easi } 17531e128c81SArun Easi } 17541e128c81SArun Easi 1755fe56b9e6SYuval Mintz void qed_cxt_hw_init_common(struct qed_hwfn *p_hwfn) 1756fe56b9e6SYuval Mintz { 1757fe56b9e6SYuval Mintz qed_cdu_init_common(p_hwfn); 17581e128c81SArun Easi qed_prs_init_common(p_hwfn); 1759fe56b9e6SYuval Mintz } 1760fe56b9e6SYuval Mintz 1761fe56b9e6SYuval Mintz void qed_cxt_hw_init_pf(struct qed_hwfn *p_hwfn) 1762fe56b9e6SYuval Mintz { 1763fe56b9e6SYuval Mintz qed_qm_init_pf(p_hwfn); 1764fe56b9e6SYuval Mintz qed_cm_init_pf(p_hwfn); 1765fe56b9e6SYuval Mintz qed_dq_init_pf(p_hwfn); 1766dbb799c3SYuval Mintz qed_cdu_init_pf(p_hwfn); 1767fe56b9e6SYuval Mintz qed_ilt_init_pf(p_hwfn); 1768dbb799c3SYuval Mintz qed_src_init_pf(p_hwfn); 1769dbb799c3SYuval Mintz qed_tm_init_pf(p_hwfn); 17701e128c81SArun Easi qed_prs_init_pf(p_hwfn); 1771fe56b9e6SYuval Mintz } 1772fe56b9e6SYuval Mintz 1773fe56b9e6SYuval Mintz int qed_cxt_acquire_cid(struct qed_hwfn *p_hwfn, 17741a635e48SYuval Mintz enum protocol_type type, u32 *p_cid) 1775fe56b9e6SYuval Mintz { 1776fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1777fe56b9e6SYuval Mintz u32 rel_cid; 1778fe56b9e6SYuval Mintz 1779fe56b9e6SYuval Mintz if (type >= MAX_CONN_TYPES || !p_mngr->acquired[type].cid_map) { 1780fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Invalid protocol type %d", type); 1781fe56b9e6SYuval Mintz return -EINVAL; 1782fe56b9e6SYuval Mintz } 1783fe56b9e6SYuval Mintz 1784fe56b9e6SYuval Mintz rel_cid = find_first_zero_bit(p_mngr->acquired[type].cid_map, 1785fe56b9e6SYuval Mintz p_mngr->acquired[type].max_count); 1786fe56b9e6SYuval Mintz 1787fe56b9e6SYuval Mintz if (rel_cid >= p_mngr->acquired[type].max_count) { 17881a635e48SYuval Mintz DP_NOTICE(p_hwfn, "no CID available for protocol %d\n", type); 1789fe56b9e6SYuval Mintz return -EINVAL; 1790fe56b9e6SYuval Mintz } 1791fe56b9e6SYuval Mintz 1792fe56b9e6SYuval Mintz __set_bit(rel_cid, p_mngr->acquired[type].cid_map); 1793fe56b9e6SYuval Mintz 1794fe56b9e6SYuval Mintz *p_cid = rel_cid + p_mngr->acquired[type].start_cid; 1795fe56b9e6SYuval Mintz 1796fe56b9e6SYuval Mintz return 0; 1797fe56b9e6SYuval Mintz } 1798fe56b9e6SYuval Mintz 1799fe56b9e6SYuval Mintz static bool qed_cxt_test_cid_acquired(struct qed_hwfn *p_hwfn, 18001a635e48SYuval Mintz u32 cid, enum protocol_type *p_type) 1801fe56b9e6SYuval Mintz { 1802fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1803fe56b9e6SYuval Mintz struct qed_cid_acquired_map *p_map; 1804fe56b9e6SYuval Mintz enum protocol_type p; 1805fe56b9e6SYuval Mintz u32 rel_cid; 1806fe56b9e6SYuval Mintz 1807fe56b9e6SYuval Mintz /* Iterate over protocols and find matching cid range */ 1808fe56b9e6SYuval Mintz for (p = 0; p < MAX_CONN_TYPES; p++) { 1809fe56b9e6SYuval Mintz p_map = &p_mngr->acquired[p]; 1810fe56b9e6SYuval Mintz 1811fe56b9e6SYuval Mintz if (!p_map->cid_map) 1812fe56b9e6SYuval Mintz continue; 1813fe56b9e6SYuval Mintz if (cid >= p_map->start_cid && 1814fe56b9e6SYuval Mintz cid < p_map->start_cid + p_map->max_count) 1815fe56b9e6SYuval Mintz break; 1816fe56b9e6SYuval Mintz } 1817fe56b9e6SYuval Mintz *p_type = p; 1818fe56b9e6SYuval Mintz 1819fe56b9e6SYuval Mintz if (p == MAX_CONN_TYPES) { 1820fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Invalid CID %d", cid); 1821fe56b9e6SYuval Mintz return false; 1822fe56b9e6SYuval Mintz } 1823fe56b9e6SYuval Mintz 1824fe56b9e6SYuval Mintz rel_cid = cid - p_map->start_cid; 1825fe56b9e6SYuval Mintz if (!test_bit(rel_cid, p_map->cid_map)) { 1826fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "CID %d not acquired", cid); 1827fe56b9e6SYuval Mintz return false; 1828fe56b9e6SYuval Mintz } 1829fe56b9e6SYuval Mintz return true; 1830fe56b9e6SYuval Mintz } 1831fe56b9e6SYuval Mintz 18321a635e48SYuval Mintz void qed_cxt_release_cid(struct qed_hwfn *p_hwfn, u32 cid) 1833fe56b9e6SYuval Mintz { 1834fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1835fe56b9e6SYuval Mintz enum protocol_type type; 1836fe56b9e6SYuval Mintz bool b_acquired; 1837fe56b9e6SYuval Mintz u32 rel_cid; 1838fe56b9e6SYuval Mintz 1839fe56b9e6SYuval Mintz /* Test acquired and find matching per-protocol map */ 1840fe56b9e6SYuval Mintz b_acquired = qed_cxt_test_cid_acquired(p_hwfn, cid, &type); 1841fe56b9e6SYuval Mintz 1842fe56b9e6SYuval Mintz if (!b_acquired) 1843fe56b9e6SYuval Mintz return; 1844fe56b9e6SYuval Mintz 1845fe56b9e6SYuval Mintz rel_cid = cid - p_mngr->acquired[type].start_cid; 1846fe56b9e6SYuval Mintz __clear_bit(rel_cid, p_mngr->acquired[type].cid_map); 1847fe56b9e6SYuval Mintz } 1848fe56b9e6SYuval Mintz 18491a635e48SYuval Mintz int qed_cxt_get_cid_info(struct qed_hwfn *p_hwfn, struct qed_cxt_info *p_info) 1850fe56b9e6SYuval Mintz { 1851fe56b9e6SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 1852fe56b9e6SYuval Mintz u32 conn_cxt_size, hw_p_size, cxts_per_p, line; 1853fe56b9e6SYuval Mintz enum protocol_type type; 1854fe56b9e6SYuval Mintz bool b_acquired; 1855fe56b9e6SYuval Mintz 1856fe56b9e6SYuval Mintz /* Test acquired and find matching per-protocol map */ 1857fe56b9e6SYuval Mintz b_acquired = qed_cxt_test_cid_acquired(p_hwfn, p_info->iid, &type); 1858fe56b9e6SYuval Mintz 1859fe56b9e6SYuval Mintz if (!b_acquired) 1860fe56b9e6SYuval Mintz return -EINVAL; 1861fe56b9e6SYuval Mintz 1862fe56b9e6SYuval Mintz /* set the protocl type */ 1863fe56b9e6SYuval Mintz p_info->type = type; 1864fe56b9e6SYuval Mintz 1865fe56b9e6SYuval Mintz /* compute context virtual pointer */ 1866fe56b9e6SYuval Mintz hw_p_size = p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC].p_size.val; 1867fe56b9e6SYuval Mintz 1868fe56b9e6SYuval Mintz conn_cxt_size = CONN_CXT_SIZE(p_hwfn); 1869fe56b9e6SYuval Mintz cxts_per_p = ILT_PAGE_IN_BYTES(hw_p_size) / conn_cxt_size; 1870fe56b9e6SYuval Mintz line = p_info->iid / cxts_per_p; 1871fe56b9e6SYuval Mintz 1872fe56b9e6SYuval Mintz /* Make sure context is allocated (dynamic allocation) */ 1873fe56b9e6SYuval Mintz if (!p_mngr->ilt_shadow[line].p_virt) 1874fe56b9e6SYuval Mintz return -EINVAL; 1875fe56b9e6SYuval Mintz 1876fe56b9e6SYuval Mintz p_info->p_cxt = p_mngr->ilt_shadow[line].p_virt + 1877fe56b9e6SYuval Mintz p_info->iid % cxts_per_p * conn_cxt_size; 1878fe56b9e6SYuval Mintz 1879fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, (QED_MSG_ILT | QED_MSG_CXT), 1880fe56b9e6SYuval Mintz "Accessing ILT shadow[%d]: CXT pointer is at %p (for iid %d)\n", 1881fe56b9e6SYuval Mintz p_info->iid / cxts_per_p, p_info->p_cxt, p_info->iid); 1882fe56b9e6SYuval Mintz 1883fe56b9e6SYuval Mintz return 0; 1884fe56b9e6SYuval Mintz } 1885fe56b9e6SYuval Mintz 18868c93beafSYuval Mintz static void qed_rdma_set_pf_params(struct qed_hwfn *p_hwfn, 1887dbb799c3SYuval Mintz struct qed_rdma_pf_params *p_params) 1888dbb799c3SYuval Mintz { 1889dbb799c3SYuval Mintz u32 num_cons, num_tasks, num_qps, num_mrs, num_srqs; 1890dbb799c3SYuval Mintz enum protocol_type proto; 1891dbb799c3SYuval Mintz 1892dbb799c3SYuval Mintz num_mrs = min_t(u32, RDMA_MAX_TIDS, p_params->num_mrs); 1893dbb799c3SYuval Mintz num_tasks = num_mrs; /* each mr uses a single task id */ 1894dbb799c3SYuval Mintz num_srqs = min_t(u32, 32 * 1024, p_params->num_srqs); 1895dbb799c3SYuval Mintz 1896dbb799c3SYuval Mintz switch (p_hwfn->hw_info.personality) { 1897dbb799c3SYuval Mintz case QED_PCI_ETH_ROCE: 1898dbb799c3SYuval Mintz num_qps = min_t(u32, ROCE_MAX_QPS, p_params->num_qps); 1899dbb799c3SYuval Mintz num_cons = num_qps * 2; /* each QP requires two connections */ 1900dbb799c3SYuval Mintz proto = PROTOCOLID_ROCE; 1901dbb799c3SYuval Mintz break; 1902dbb799c3SYuval Mintz default: 1903dbb799c3SYuval Mintz return; 1904dbb799c3SYuval Mintz } 1905dbb799c3SYuval Mintz 1906dbb799c3SYuval Mintz if (num_cons && num_tasks) { 1907dbb799c3SYuval Mintz qed_cxt_set_proto_cid_count(p_hwfn, proto, num_cons, 0); 1908dbb799c3SYuval Mintz 1909dbb799c3SYuval Mintz /* Deliberatly passing ROCE for tasks id. This is because 1910dbb799c3SYuval Mintz * iWARP / RoCE share the task id. 1911dbb799c3SYuval Mintz */ 1912dbb799c3SYuval Mintz qed_cxt_set_proto_tid_count(p_hwfn, PROTOCOLID_ROCE, 1913dbb799c3SYuval Mintz QED_CXT_ROCE_TID_SEG, 1, 1914dbb799c3SYuval Mintz num_tasks, false); 1915dbb799c3SYuval Mintz qed_cxt_set_srq_count(p_hwfn, num_srqs); 1916dbb799c3SYuval Mintz } else { 1917dbb799c3SYuval Mintz DP_INFO(p_hwfn->cdev, 1918dbb799c3SYuval Mintz "RDMA personality used without setting params!\n"); 1919dbb799c3SYuval Mintz } 1920dbb799c3SYuval Mintz } 1921dbb799c3SYuval Mintz 1922fe56b9e6SYuval Mintz int qed_cxt_set_pf_params(struct qed_hwfn *p_hwfn) 1923fe56b9e6SYuval Mintz { 1924fe56b9e6SYuval Mintz /* Set the number of required CORE connections */ 1925fe56b9e6SYuval Mintz u32 core_cids = 1; /* SPQ */ 1926fe56b9e6SYuval Mintz 19270a7fb11cSYuval Mintz if (p_hwfn->using_ll2) 19280a7fb11cSYuval Mintz core_cids += 4; 19291408cc1fSYuval Mintz qed_cxt_set_proto_cid_count(p_hwfn, PROTOCOLID_CORE, core_cids, 0); 1930fe56b9e6SYuval Mintz 1931dbb799c3SYuval Mintz switch (p_hwfn->hw_info.personality) { 1932dbb799c3SYuval Mintz case QED_PCI_ETH_ROCE: 1933dbb799c3SYuval Mintz { 1934dbb799c3SYuval Mintz qed_rdma_set_pf_params(p_hwfn, 1935dbb799c3SYuval Mintz &p_hwfn-> 1936dbb799c3SYuval Mintz pf_params.rdma_pf_params); 1937dbb799c3SYuval Mintz /* no need for break since RoCE coexist with Ethernet */ 1938dbb799c3SYuval Mintz } 1939dbb799c3SYuval Mintz case QED_PCI_ETH: 1940dbb799c3SYuval Mintz { 1941dbb799c3SYuval Mintz struct qed_eth_pf_params *p_params = 1942dbb799c3SYuval Mintz &p_hwfn->pf_params.eth_pf_params; 1943dbb799c3SYuval Mintz 1944fe56b9e6SYuval Mintz qed_cxt_set_proto_cid_count(p_hwfn, PROTOCOLID_ETH, 19451408cc1fSYuval Mintz p_params->num_cons, 1); 1946dbb799c3SYuval Mintz break; 1947dbb799c3SYuval Mintz } 19481e128c81SArun Easi case QED_PCI_FCOE: 19491e128c81SArun Easi { 19501e128c81SArun Easi struct qed_fcoe_pf_params *p_params; 19511e128c81SArun Easi 19521e128c81SArun Easi p_params = &p_hwfn->pf_params.fcoe_pf_params; 19531e128c81SArun Easi 19541e128c81SArun Easi if (p_params->num_cons && p_params->num_tasks) { 19551e128c81SArun Easi qed_cxt_set_proto_cid_count(p_hwfn, 19561e128c81SArun Easi PROTOCOLID_FCOE, 19571e128c81SArun Easi p_params->num_cons, 19581e128c81SArun Easi 0); 19591e128c81SArun Easi 19601e128c81SArun Easi qed_cxt_set_proto_tid_count(p_hwfn, PROTOCOLID_FCOE, 19611e128c81SArun Easi QED_CXT_FCOE_TID_SEG, 0, 19621e128c81SArun Easi p_params->num_tasks, true); 19631e128c81SArun Easi } else { 19641e128c81SArun Easi DP_INFO(p_hwfn->cdev, 19651e128c81SArun Easi "Fcoe personality used without setting params!\n"); 19661e128c81SArun Easi } 19671e128c81SArun Easi break; 19681e128c81SArun Easi } 1969dbb799c3SYuval Mintz case QED_PCI_ISCSI: 1970dbb799c3SYuval Mintz { 1971dbb799c3SYuval Mintz struct qed_iscsi_pf_params *p_params; 1972dbb799c3SYuval Mintz 1973dbb799c3SYuval Mintz p_params = &p_hwfn->pf_params.iscsi_pf_params; 1974dbb799c3SYuval Mintz 1975dbb799c3SYuval Mintz if (p_params->num_cons && p_params->num_tasks) { 1976dbb799c3SYuval Mintz qed_cxt_set_proto_cid_count(p_hwfn, 1977dbb799c3SYuval Mintz PROTOCOLID_ISCSI, 1978dbb799c3SYuval Mintz p_params->num_cons, 1979dbb799c3SYuval Mintz 0); 1980dbb799c3SYuval Mintz 1981dbb799c3SYuval Mintz qed_cxt_set_proto_tid_count(p_hwfn, 1982dbb799c3SYuval Mintz PROTOCOLID_ISCSI, 1983dbb799c3SYuval Mintz QED_CXT_ISCSI_TID_SEG, 1984dbb799c3SYuval Mintz 0, 1985dbb799c3SYuval Mintz p_params->num_tasks, 1986dbb799c3SYuval Mintz true); 1987dbb799c3SYuval Mintz } else { 1988dbb799c3SYuval Mintz DP_INFO(p_hwfn->cdev, 1989dbb799c3SYuval Mintz "Iscsi personality used without setting params!\n"); 1990dbb799c3SYuval Mintz } 1991dbb799c3SYuval Mintz break; 1992dbb799c3SYuval Mintz } 1993dbb799c3SYuval Mintz default: 1994dbb799c3SYuval Mintz return -EINVAL; 1995dbb799c3SYuval Mintz } 1996dbb799c3SYuval Mintz 1997dbb799c3SYuval Mintz return 0; 1998dbb799c3SYuval Mintz } 1999dbb799c3SYuval Mintz 2000dbb799c3SYuval Mintz int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, 2001dbb799c3SYuval Mintz struct qed_tid_mem *p_info) 2002dbb799c3SYuval Mintz { 2003dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 2004dbb799c3SYuval Mintz u32 proto, seg, total_lines, i, shadow_line; 2005dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 2006dbb799c3SYuval Mintz struct qed_ilt_cli_blk *p_fl_seg; 2007dbb799c3SYuval Mintz struct qed_tid_seg *p_seg_info; 2008dbb799c3SYuval Mintz 2009dbb799c3SYuval Mintz /* Verify the personality */ 2010dbb799c3SYuval Mintz switch (p_hwfn->hw_info.personality) { 20111e128c81SArun Easi case QED_PCI_FCOE: 20121e128c81SArun Easi proto = PROTOCOLID_FCOE; 20131e128c81SArun Easi seg = QED_CXT_FCOE_TID_SEG; 20141e128c81SArun Easi break; 2015dbb799c3SYuval Mintz case QED_PCI_ISCSI: 2016dbb799c3SYuval Mintz proto = PROTOCOLID_ISCSI; 2017dbb799c3SYuval Mintz seg = QED_CXT_ISCSI_TID_SEG; 2018dbb799c3SYuval Mintz break; 2019dbb799c3SYuval Mintz default: 2020dbb799c3SYuval Mintz return -EINVAL; 2021dbb799c3SYuval Mintz } 2022dbb799c3SYuval Mintz 2023dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_CDUT]; 2024dbb799c3SYuval Mintz if (!p_cli->active) 2025dbb799c3SYuval Mintz return -EINVAL; 2026dbb799c3SYuval Mintz 2027dbb799c3SYuval Mintz p_seg_info = &p_mngr->conn_cfg[proto].tid_seg[seg]; 2028dbb799c3SYuval Mintz if (!p_seg_info->has_fl_mem) 2029dbb799c3SYuval Mintz return -EINVAL; 2030dbb799c3SYuval Mintz 2031dbb799c3SYuval Mintz p_fl_seg = &p_cli->pf_blks[CDUT_FL_SEG_BLK(seg, PF)]; 2032dbb799c3SYuval Mintz total_lines = DIV_ROUND_UP(p_fl_seg->total_size, 2033dbb799c3SYuval Mintz p_fl_seg->real_size_in_page); 2034dbb799c3SYuval Mintz 2035dbb799c3SYuval Mintz for (i = 0; i < total_lines; i++) { 2036dbb799c3SYuval Mintz shadow_line = i + p_fl_seg->start_line - 2037dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->pf_start_line; 2038dbb799c3SYuval Mintz p_info->blocks[i] = p_mngr->ilt_shadow[shadow_line].p_virt; 2039dbb799c3SYuval Mintz } 2040dbb799c3SYuval Mintz p_info->waste = ILT_PAGE_IN_BYTES(p_cli->p_size.val) - 2041dbb799c3SYuval Mintz p_fl_seg->real_size_in_page; 2042dbb799c3SYuval Mintz p_info->tid_size = p_mngr->task_type_size[p_seg_info->type]; 2043dbb799c3SYuval Mintz p_info->num_tids_per_block = p_fl_seg->real_size_in_page / 2044dbb799c3SYuval Mintz p_info->tid_size; 2045dbb799c3SYuval Mintz 2046dbb799c3SYuval Mintz return 0; 2047dbb799c3SYuval Mintz } 2048dbb799c3SYuval Mintz 2049dbb799c3SYuval Mintz /* This function is very RoCE oriented, if another protocol in the future 2050dbb799c3SYuval Mintz * will want this feature we'll need to modify the function to be more generic 2051dbb799c3SYuval Mintz */ 2052dbb799c3SYuval Mintz int 2053dbb799c3SYuval Mintz qed_cxt_dynamic_ilt_alloc(struct qed_hwfn *p_hwfn, 2054dbb799c3SYuval Mintz enum qed_cxt_elem_type elem_type, u32 iid) 2055dbb799c3SYuval Mintz { 2056dbb799c3SYuval Mintz u32 reg_offset, shadow_line, elem_size, hw_p_size, elems_per_p, line; 2057dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 2058dbb799c3SYuval Mintz struct qed_ilt_cli_blk *p_blk; 2059dbb799c3SYuval Mintz struct qed_ptt *p_ptt; 2060dbb799c3SYuval Mintz dma_addr_t p_phys; 2061dbb799c3SYuval Mintz u64 ilt_hw_entry; 2062dbb799c3SYuval Mintz void *p_virt; 2063dbb799c3SYuval Mintz int rc = 0; 2064dbb799c3SYuval Mintz 2065dbb799c3SYuval Mintz switch (elem_type) { 2066dbb799c3SYuval Mintz case QED_ELEM_CXT: 2067dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC]; 2068dbb799c3SYuval Mintz elem_size = CONN_CXT_SIZE(p_hwfn); 2069dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUC_BLK]; 2070dbb799c3SYuval Mintz break; 2071dbb799c3SYuval Mintz case QED_ELEM_SRQ: 2072dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_TSDM]; 2073dbb799c3SYuval Mintz elem_size = SRQ_CXT_SIZE; 2074dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[SRQ_BLK]; 2075dbb799c3SYuval Mintz break; 2076dbb799c3SYuval Mintz case QED_ELEM_TASK: 2077dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUT]; 2078dbb799c3SYuval Mintz elem_size = TYPE1_TASK_CXT_SIZE(p_hwfn); 2079dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUT_SEG_BLK(QED_CXT_ROCE_TID_SEG)]; 2080dbb799c3SYuval Mintz break; 2081dbb799c3SYuval Mintz default: 2082dbb799c3SYuval Mintz DP_NOTICE(p_hwfn, "-EINVALID elem type = %d", elem_type); 2083dbb799c3SYuval Mintz return -EINVAL; 2084dbb799c3SYuval Mintz } 2085dbb799c3SYuval Mintz 2086dbb799c3SYuval Mintz /* Calculate line in ilt */ 2087dbb799c3SYuval Mintz hw_p_size = p_cli->p_size.val; 2088dbb799c3SYuval Mintz elems_per_p = ILT_PAGE_IN_BYTES(hw_p_size) / elem_size; 2089dbb799c3SYuval Mintz line = p_blk->start_line + (iid / elems_per_p); 2090dbb799c3SYuval Mintz shadow_line = line - p_hwfn->p_cxt_mngr->pf_start_line; 2091dbb799c3SYuval Mintz 2092dbb799c3SYuval Mintz /* If line is already allocated, do nothing, otherwise allocate it and 2093dbb799c3SYuval Mintz * write it to the PSWRQ2 registers. 2094dbb799c3SYuval Mintz * This section can be run in parallel from different contexts and thus 2095dbb799c3SYuval Mintz * a mutex protection is needed. 2096dbb799c3SYuval Mintz */ 2097dbb799c3SYuval Mintz 2098dbb799c3SYuval Mintz mutex_lock(&p_hwfn->p_cxt_mngr->mutex); 2099dbb799c3SYuval Mintz 2100dbb799c3SYuval Mintz if (p_hwfn->p_cxt_mngr->ilt_shadow[shadow_line].p_virt) 2101dbb799c3SYuval Mintz goto out0; 2102dbb799c3SYuval Mintz 2103dbb799c3SYuval Mintz p_ptt = qed_ptt_acquire(p_hwfn); 2104dbb799c3SYuval Mintz if (!p_ptt) { 2105dbb799c3SYuval Mintz DP_NOTICE(p_hwfn, 2106dbb799c3SYuval Mintz "QED_TIME_OUT on ptt acquire - dynamic allocation"); 2107dbb799c3SYuval Mintz rc = -EBUSY; 2108dbb799c3SYuval Mintz goto out0; 2109dbb799c3SYuval Mintz } 2110dbb799c3SYuval Mintz 2111dbb799c3SYuval Mintz p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 2112dbb799c3SYuval Mintz p_blk->real_size_in_page, 2113dbb799c3SYuval Mintz &p_phys, GFP_KERNEL); 2114dbb799c3SYuval Mintz if (!p_virt) { 2115dbb799c3SYuval Mintz rc = -ENOMEM; 2116dbb799c3SYuval Mintz goto out1; 2117dbb799c3SYuval Mintz } 2118dbb799c3SYuval Mintz memset(p_virt, 0, p_blk->real_size_in_page); 2119dbb799c3SYuval Mintz 2120dbb799c3SYuval Mintz /* configuration of refTagMask to 0xF is required for RoCE DIF MR only, 2121dbb799c3SYuval Mintz * to compensate for a HW bug, but it is configured even if DIF is not 2122dbb799c3SYuval Mintz * enabled. This is harmless and allows us to avoid a dedicated API. We 2123dbb799c3SYuval Mintz * configure the field for all of the contexts on the newly allocated 2124dbb799c3SYuval Mintz * page. 2125dbb799c3SYuval Mintz */ 2126dbb799c3SYuval Mintz if (elem_type == QED_ELEM_TASK) { 2127dbb799c3SYuval Mintz u32 elem_i; 2128dbb799c3SYuval Mintz u8 *elem_start = (u8 *)p_virt; 2129dbb799c3SYuval Mintz union type1_task_context *elem; 2130dbb799c3SYuval Mintz 2131dbb799c3SYuval Mintz for (elem_i = 0; elem_i < elems_per_p; elem_i++) { 2132dbb799c3SYuval Mintz elem = (union type1_task_context *)elem_start; 2133dbb799c3SYuval Mintz SET_FIELD(elem->roce_ctx.tdif_context.flags1, 2134dbb799c3SYuval Mintz TDIF_TASK_CONTEXT_REFTAGMASK, 0xf); 2135dbb799c3SYuval Mintz elem_start += TYPE1_TASK_CXT_SIZE(p_hwfn); 2136dbb799c3SYuval Mintz } 2137dbb799c3SYuval Mintz } 2138dbb799c3SYuval Mintz 2139dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[shadow_line].p_virt = p_virt; 2140dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[shadow_line].p_phys = p_phys; 2141dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[shadow_line].size = 2142dbb799c3SYuval Mintz p_blk->real_size_in_page; 2143dbb799c3SYuval Mintz 2144dbb799c3SYuval Mintz /* compute absolute offset */ 2145dbb799c3SYuval Mintz reg_offset = PSWRQ2_REG_ILT_MEMORY + 2146dbb799c3SYuval Mintz (line * ILT_REG_SIZE_IN_BYTES * ILT_ENTRY_IN_REGS); 2147dbb799c3SYuval Mintz 2148dbb799c3SYuval Mintz ilt_hw_entry = 0; 2149dbb799c3SYuval Mintz SET_FIELD(ilt_hw_entry, ILT_ENTRY_VALID, 1ULL); 2150dbb799c3SYuval Mintz SET_FIELD(ilt_hw_entry, 2151dbb799c3SYuval Mintz ILT_ENTRY_PHY_ADDR, 2152dbb799c3SYuval Mintz (p_hwfn->p_cxt_mngr->ilt_shadow[shadow_line].p_phys >> 12)); 2153dbb799c3SYuval Mintz 2154dbb799c3SYuval Mintz /* Write via DMAE since the PSWRQ2_REG_ILT_MEMORY line is a wide-bus */ 2155dbb799c3SYuval Mintz qed_dmae_host2grc(p_hwfn, p_ptt, (u64) (uintptr_t)&ilt_hw_entry, 2156dbb799c3SYuval Mintz reg_offset, sizeof(ilt_hw_entry) / sizeof(u32), 0); 2157dbb799c3SYuval Mintz 2158dbb799c3SYuval Mintz if (elem_type == QED_ELEM_CXT) { 2159dbb799c3SYuval Mintz u32 last_cid_allocated = (1 + (iid / elems_per_p)) * 2160dbb799c3SYuval Mintz elems_per_p; 2161dbb799c3SYuval Mintz 2162dbb799c3SYuval Mintz /* Update the relevant register in the parser */ 2163dbb799c3SYuval Mintz qed_wr(p_hwfn, p_ptt, PRS_REG_ROCE_DEST_QP_MAX_PF, 2164dbb799c3SYuval Mintz last_cid_allocated - 1); 2165dbb799c3SYuval Mintz 2166dbb799c3SYuval Mintz if (!p_hwfn->b_rdma_enabled_in_prs) { 2167dbb799c3SYuval Mintz /* Enable RoCE search */ 2168dbb799c3SYuval Mintz qed_wr(p_hwfn, p_ptt, p_hwfn->rdma_prs_search_reg, 1); 2169dbb799c3SYuval Mintz p_hwfn->b_rdma_enabled_in_prs = true; 2170dbb799c3SYuval Mintz } 2171dbb799c3SYuval Mintz } 2172dbb799c3SYuval Mintz 2173dbb799c3SYuval Mintz out1: 2174dbb799c3SYuval Mintz qed_ptt_release(p_hwfn, p_ptt); 2175dbb799c3SYuval Mintz out0: 2176dbb799c3SYuval Mintz mutex_unlock(&p_hwfn->p_cxt_mngr->mutex); 2177dbb799c3SYuval Mintz 2178dbb799c3SYuval Mintz return rc; 2179dbb799c3SYuval Mintz } 2180dbb799c3SYuval Mintz 2181dbb799c3SYuval Mintz /* This function is very RoCE oriented, if another protocol in the future 2182dbb799c3SYuval Mintz * will want this feature we'll need to modify the function to be more generic 2183dbb799c3SYuval Mintz */ 2184dbb799c3SYuval Mintz static int 2185dbb799c3SYuval Mintz qed_cxt_free_ilt_range(struct qed_hwfn *p_hwfn, 2186dbb799c3SYuval Mintz enum qed_cxt_elem_type elem_type, 2187dbb799c3SYuval Mintz u32 start_iid, u32 count) 2188dbb799c3SYuval Mintz { 2189dbb799c3SYuval Mintz u32 start_line, end_line, shadow_start_line, shadow_end_line; 2190dbb799c3SYuval Mintz u32 reg_offset, elem_size, hw_p_size, elems_per_p; 2191dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 2192dbb799c3SYuval Mintz struct qed_ilt_cli_blk *p_blk; 2193dbb799c3SYuval Mintz u32 end_iid = start_iid + count; 2194dbb799c3SYuval Mintz struct qed_ptt *p_ptt; 2195dbb799c3SYuval Mintz u64 ilt_hw_entry = 0; 2196dbb799c3SYuval Mintz u32 i; 2197dbb799c3SYuval Mintz 2198dbb799c3SYuval Mintz switch (elem_type) { 2199dbb799c3SYuval Mintz case QED_ELEM_CXT: 2200dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUC]; 2201dbb799c3SYuval Mintz elem_size = CONN_CXT_SIZE(p_hwfn); 2202dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUC_BLK]; 2203dbb799c3SYuval Mintz break; 2204dbb799c3SYuval Mintz case QED_ELEM_SRQ: 2205dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_TSDM]; 2206dbb799c3SYuval Mintz elem_size = SRQ_CXT_SIZE; 2207dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[SRQ_BLK]; 2208dbb799c3SYuval Mintz break; 2209dbb799c3SYuval Mintz case QED_ELEM_TASK: 2210dbb799c3SYuval Mintz p_cli = &p_hwfn->p_cxt_mngr->clients[ILT_CLI_CDUT]; 2211dbb799c3SYuval Mintz elem_size = TYPE1_TASK_CXT_SIZE(p_hwfn); 2212dbb799c3SYuval Mintz p_blk = &p_cli->pf_blks[CDUT_SEG_BLK(QED_CXT_ROCE_TID_SEG)]; 2213dbb799c3SYuval Mintz break; 2214dbb799c3SYuval Mintz default: 2215dbb799c3SYuval Mintz DP_NOTICE(p_hwfn, "-EINVALID elem type = %d", elem_type); 2216dbb799c3SYuval Mintz return -EINVAL; 2217dbb799c3SYuval Mintz } 2218dbb799c3SYuval Mintz 2219dbb799c3SYuval Mintz /* Calculate line in ilt */ 2220dbb799c3SYuval Mintz hw_p_size = p_cli->p_size.val; 2221dbb799c3SYuval Mintz elems_per_p = ILT_PAGE_IN_BYTES(hw_p_size) / elem_size; 2222dbb799c3SYuval Mintz start_line = p_blk->start_line + (start_iid / elems_per_p); 2223dbb799c3SYuval Mintz end_line = p_blk->start_line + (end_iid / elems_per_p); 2224dbb799c3SYuval Mintz if (((end_iid + 1) / elems_per_p) != (end_iid / elems_per_p)) 2225dbb799c3SYuval Mintz end_line--; 2226dbb799c3SYuval Mintz 2227dbb799c3SYuval Mintz shadow_start_line = start_line - p_hwfn->p_cxt_mngr->pf_start_line; 2228dbb799c3SYuval Mintz shadow_end_line = end_line - p_hwfn->p_cxt_mngr->pf_start_line; 2229dbb799c3SYuval Mintz 2230dbb799c3SYuval Mintz p_ptt = qed_ptt_acquire(p_hwfn); 2231dbb799c3SYuval Mintz if (!p_ptt) { 2232dbb799c3SYuval Mintz DP_NOTICE(p_hwfn, 2233dbb799c3SYuval Mintz "QED_TIME_OUT on ptt acquire - dynamic allocation"); 2234dbb799c3SYuval Mintz return -EBUSY; 2235dbb799c3SYuval Mintz } 2236dbb799c3SYuval Mintz 2237dbb799c3SYuval Mintz for (i = shadow_start_line; i < shadow_end_line; i++) { 2238dbb799c3SYuval Mintz if (!p_hwfn->p_cxt_mngr->ilt_shadow[i].p_virt) 2239dbb799c3SYuval Mintz continue; 2240dbb799c3SYuval Mintz 2241dbb799c3SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev, 2242dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].size, 2243dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].p_virt, 2244dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].p_phys); 2245dbb799c3SYuval Mintz 2246dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].p_virt = NULL; 2247dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].p_phys = 0; 2248dbb799c3SYuval Mintz p_hwfn->p_cxt_mngr->ilt_shadow[i].size = 0; 2249dbb799c3SYuval Mintz 2250dbb799c3SYuval Mintz /* compute absolute offset */ 2251dbb799c3SYuval Mintz reg_offset = PSWRQ2_REG_ILT_MEMORY + 2252dbb799c3SYuval Mintz ((start_line++) * ILT_REG_SIZE_IN_BYTES * 2253dbb799c3SYuval Mintz ILT_ENTRY_IN_REGS); 2254dbb799c3SYuval Mintz 2255dbb799c3SYuval Mintz /* Write via DMAE since the PSWRQ2_REG_ILT_MEMORY line is a 2256dbb799c3SYuval Mintz * wide-bus. 2257dbb799c3SYuval Mintz */ 2258dbb799c3SYuval Mintz qed_dmae_host2grc(p_hwfn, p_ptt, 2259dbb799c3SYuval Mintz (u64) (uintptr_t) &ilt_hw_entry, 2260dbb799c3SYuval Mintz reg_offset, 2261dbb799c3SYuval Mintz sizeof(ilt_hw_entry) / sizeof(u32), 2262dbb799c3SYuval Mintz 0); 2263dbb799c3SYuval Mintz } 2264dbb799c3SYuval Mintz 2265dbb799c3SYuval Mintz qed_ptt_release(p_hwfn, p_ptt); 2266dbb799c3SYuval Mintz 2267dbb799c3SYuval Mintz return 0; 2268dbb799c3SYuval Mintz } 2269dbb799c3SYuval Mintz 2270dbb799c3SYuval Mintz int qed_cxt_free_proto_ilt(struct qed_hwfn *p_hwfn, enum protocol_type proto) 2271dbb799c3SYuval Mintz { 2272dbb799c3SYuval Mintz int rc; 2273dbb799c3SYuval Mintz u32 cid; 2274dbb799c3SYuval Mintz 2275dbb799c3SYuval Mintz /* Free Connection CXT */ 2276dbb799c3SYuval Mintz rc = qed_cxt_free_ilt_range(p_hwfn, QED_ELEM_CXT, 2277dbb799c3SYuval Mintz qed_cxt_get_proto_cid_start(p_hwfn, 2278dbb799c3SYuval Mintz proto), 2279dbb799c3SYuval Mintz qed_cxt_get_proto_cid_count(p_hwfn, 2280dbb799c3SYuval Mintz proto, &cid)); 2281dbb799c3SYuval Mintz 2282dbb799c3SYuval Mintz if (rc) 2283dbb799c3SYuval Mintz return rc; 2284dbb799c3SYuval Mintz 2285dbb799c3SYuval Mintz /* Free Task CXT */ 2286dbb799c3SYuval Mintz rc = qed_cxt_free_ilt_range(p_hwfn, QED_ELEM_TASK, 0, 2287dbb799c3SYuval Mintz qed_cxt_get_proto_tid_count(p_hwfn, proto)); 2288dbb799c3SYuval Mintz if (rc) 2289dbb799c3SYuval Mintz return rc; 2290dbb799c3SYuval Mintz 2291dbb799c3SYuval Mintz /* Free TSDM CXT */ 2292dbb799c3SYuval Mintz rc = qed_cxt_free_ilt_range(p_hwfn, QED_ELEM_SRQ, 0, 2293dbb799c3SYuval Mintz qed_cxt_get_srq_count(p_hwfn)); 2294dbb799c3SYuval Mintz 2295dbb799c3SYuval Mintz return rc; 2296dbb799c3SYuval Mintz } 2297dbb799c3SYuval Mintz 2298dbb799c3SYuval Mintz int qed_cxt_get_task_ctx(struct qed_hwfn *p_hwfn, 2299dbb799c3SYuval Mintz u32 tid, u8 ctx_type, void **pp_task_ctx) 2300dbb799c3SYuval Mintz { 2301dbb799c3SYuval Mintz struct qed_cxt_mngr *p_mngr = p_hwfn->p_cxt_mngr; 2302dbb799c3SYuval Mintz struct qed_ilt_client_cfg *p_cli; 2303dbb799c3SYuval Mintz struct qed_tid_seg *p_seg_info; 23041e128c81SArun Easi struct qed_ilt_cli_blk *p_seg; 2305dbb799c3SYuval Mintz u32 num_tids_per_block; 23061e128c81SArun Easi u32 tid_size, ilt_idx; 23071e128c81SArun Easi u32 total_lines; 23081e128c81SArun Easi u32 proto, seg; 2309dbb799c3SYuval Mintz 2310dbb799c3SYuval Mintz /* Verify the personality */ 2311dbb799c3SYuval Mintz switch (p_hwfn->hw_info.personality) { 23121e128c81SArun Easi case QED_PCI_FCOE: 23131e128c81SArun Easi proto = PROTOCOLID_FCOE; 23141e128c81SArun Easi seg = QED_CXT_FCOE_TID_SEG; 23151e128c81SArun Easi break; 2316dbb799c3SYuval Mintz case QED_PCI_ISCSI: 2317dbb799c3SYuval Mintz proto = PROTOCOLID_ISCSI; 2318dbb799c3SYuval Mintz seg = QED_CXT_ISCSI_TID_SEG; 2319dbb799c3SYuval Mintz break; 2320dbb799c3SYuval Mintz default: 2321dbb799c3SYuval Mintz return -EINVAL; 2322dbb799c3SYuval Mintz } 2323dbb799c3SYuval Mintz 2324dbb799c3SYuval Mintz p_cli = &p_mngr->clients[ILT_CLI_CDUT]; 2325dbb799c3SYuval Mintz if (!p_cli->active) 2326dbb799c3SYuval Mintz return -EINVAL; 2327dbb799c3SYuval Mintz 2328dbb799c3SYuval Mintz p_seg_info = &p_mngr->conn_cfg[proto].tid_seg[seg]; 2329dbb799c3SYuval Mintz 2330dbb799c3SYuval Mintz if (ctx_type == QED_CTX_WORKING_MEM) { 2331dbb799c3SYuval Mintz p_seg = &p_cli->pf_blks[CDUT_SEG_BLK(seg)]; 2332dbb799c3SYuval Mintz } else if (ctx_type == QED_CTX_FL_MEM) { 2333dbb799c3SYuval Mintz if (!p_seg_info->has_fl_mem) 2334dbb799c3SYuval Mintz return -EINVAL; 2335dbb799c3SYuval Mintz p_seg = &p_cli->pf_blks[CDUT_FL_SEG_BLK(seg, PF)]; 2336dbb799c3SYuval Mintz } else { 2337dbb799c3SYuval Mintz return -EINVAL; 2338dbb799c3SYuval Mintz } 2339dbb799c3SYuval Mintz total_lines = DIV_ROUND_UP(p_seg->total_size, p_seg->real_size_in_page); 2340dbb799c3SYuval Mintz tid_size = p_mngr->task_type_size[p_seg_info->type]; 2341dbb799c3SYuval Mintz num_tids_per_block = p_seg->real_size_in_page / tid_size; 2342dbb799c3SYuval Mintz 2343dbb799c3SYuval Mintz if (total_lines < tid / num_tids_per_block) 2344dbb799c3SYuval Mintz return -EINVAL; 2345dbb799c3SYuval Mintz 2346dbb799c3SYuval Mintz ilt_idx = tid / num_tids_per_block + p_seg->start_line - 2347dbb799c3SYuval Mintz p_mngr->pf_start_line; 2348dbb799c3SYuval Mintz *pp_task_ctx = (u8 *)p_mngr->ilt_shadow[ilt_idx].p_virt + 2349dbb799c3SYuval Mintz (tid % num_tids_per_block) * tid_size; 2350fe56b9e6SYuval Mintz 2351fe56b9e6SYuval Mintz return 0; 2352fe56b9e6SYuval Mintz } 2353