1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* Copyright(c) 2007-2022 Intel Corporation */ 3 /* $FreeBSD$ */ 4 #include "qat_freebsd.h" 5 #include "adf_cfg.h" 6 #include "adf_common_drv.h" 7 #include "adf_accel_devices.h" 8 #include "icp_qat_uclo.h" 9 #include "icp_qat_fw.h" 10 #include "icp_qat_fw_init_admin.h" 11 #include "adf_cfg_strings.h" 12 #include "adf_transport_access_macros.h" 13 #include "adf_transport_internal.h" 14 #include <sys/malloc.h> 15 #include <sys/sbuf.h> 16 #include <sys/sysctl.h> 17 #include <sys/systm.h> 18 19 static int adf_ring_show(SYSCTL_HANDLER_ARGS) 20 { 21 struct adf_etr_ring_data *ring = arg1; 22 struct adf_etr_bank_data *bank = ring->bank; 23 struct adf_hw_csr_ops *csr_ops = GET_CSR_OPS(bank->accel_dev); 24 struct resource *csr = ring->bank->csr_addr; 25 struct sbuf sb; 26 int error, word; 27 uint32_t *wp, *end; 28 29 sbuf_new_for_sysctl(&sb, NULL, 128, req); 30 { 31 int head, tail, empty; 32 33 head = csr_ops->read_csr_ring_head(csr, 34 bank->bank_number, 35 ring->ring_number); 36 tail = csr_ops->read_csr_ring_tail(csr, 37 bank->bank_number, 38 ring->ring_number); 39 empty = csr_ops->read_csr_e_stat(csr, bank->bank_number); 40 41 sbuf_cat(&sb, "\n------- Ring configuration -------\n"); 42 sbuf_printf(&sb, 43 "ring name: %s\n", 44 ring->ring_debug->ring_name); 45 sbuf_printf(&sb, 46 "ring num %d, bank num %d\n", 47 ring->ring_number, 48 ring->bank->bank_number); 49 sbuf_printf(&sb, 50 "head %x, tail %x, empty: %d\n", 51 head, 52 tail, 53 (empty & 1 << ring->ring_number) >> 54 ring->ring_number); 55 sbuf_printf(&sb, 56 "ring size %d, msg size %d\n", 57 ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size), 58 ADF_MSG_SIZE_TO_BYTES(ring->msg_size)); 59 sbuf_cat(&sb, "----------- Ring data ------------\n"); 60 } 61 wp = ring->base_addr; 62 end = (uint32_t *)((char *)ring->base_addr + 63 ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size)); 64 while (wp < end) { 65 sbuf_printf(&sb, "%p:", wp); 66 for (word = 0; word < 32 / 4; word++, wp++) 67 sbuf_printf(&sb, " %08x", *wp); 68 sbuf_printf(&sb, "\n"); 69 } 70 error = sbuf_finish(&sb); 71 sbuf_delete(&sb); 72 return (error); 73 } 74 75 int 76 adf_ring_debugfs_add(struct adf_etr_ring_data *ring, const char *name) 77 { 78 struct adf_etr_ring_debug_entry *ring_debug; 79 char entry_name[8]; 80 81 ring_debug = malloc(sizeof(*ring_debug), M_QAT, M_WAITOK | M_ZERO); 82 83 strlcpy(ring_debug->ring_name, name, sizeof(ring_debug->ring_name)); 84 snprintf(entry_name, 85 sizeof(entry_name), 86 "ring_%02d", 87 ring->ring_number); 88 89 ring_debug->debug = 90 SYSCTL_ADD_PROC(&ring->bank->accel_dev->sysctl_ctx, 91 SYSCTL_CHILDREN(ring->bank->bank_debug_dir), 92 OID_AUTO, 93 entry_name, 94 CTLFLAG_RD | CTLTYPE_STRING, 95 ring, 96 0, 97 adf_ring_show, 98 "A", 99 "Ring configuration"); 100 101 if (!ring_debug->debug) { 102 printf("QAT: Failed to create ring debug entry.\n"); 103 free(ring_debug, M_QAT); 104 return EFAULT; 105 } 106 ring->ring_debug = ring_debug; 107 return 0; 108 } 109 110 void 111 adf_ring_debugfs_rm(struct adf_etr_ring_data *ring) 112 { 113 if (ring->ring_debug) { 114 free(ring->ring_debug, M_QAT); 115 ring->ring_debug = NULL; 116 } 117 } 118 119 static int adf_bank_show(SYSCTL_HANDLER_ARGS) 120 { 121 struct adf_etr_bank_data *bank; 122 struct adf_accel_dev *accel_dev = NULL; 123 struct adf_hw_csr_ops *csr_ops = NULL; 124 struct adf_hw_device_data *hw_data = NULL; 125 u8 num_rings_per_bank = 0; 126 struct sbuf sb; 127 int error, ring_id; 128 129 sbuf_new_for_sysctl(&sb, NULL, 128, req); 130 bank = arg1; 131 accel_dev = bank->accel_dev; 132 csr_ops = GET_CSR_OPS(bank->accel_dev); 133 hw_data = accel_dev->hw_device; 134 num_rings_per_bank = hw_data->num_rings_per_bank; 135 sbuf_printf(&sb, 136 "\n------- Bank %d configuration -------\n", 137 bank->bank_number); 138 for (ring_id = 0; ring_id < num_rings_per_bank; ring_id++) { 139 struct adf_etr_ring_data *ring = &bank->rings[ring_id]; 140 struct resource *csr = bank->csr_addr; 141 int head, tail, empty; 142 143 if (!(bank->ring_mask & 1 << ring_id)) 144 continue; 145 146 head = csr_ops->read_csr_ring_head(csr, 147 bank->bank_number, 148 ring->ring_number); 149 tail = csr_ops->read_csr_ring_tail(csr, 150 bank->bank_number, 151 ring->ring_number); 152 empty = csr_ops->read_csr_e_stat(csr, bank->bank_number); 153 154 sbuf_printf(&sb, 155 "ring num %02d, head %04x, tail %04x, empty: %d\n", 156 ring->ring_number, 157 head, 158 tail, 159 (empty & 1 << ring->ring_number) >> 160 ring->ring_number); 161 } 162 error = sbuf_finish(&sb); 163 sbuf_delete(&sb); 164 return (error); 165 } 166 167 int 168 adf_bank_debugfs_add(struct adf_etr_bank_data *bank) 169 { 170 struct adf_accel_dev *accel_dev = bank->accel_dev; 171 struct sysctl_oid *parent = accel_dev->transport->debug; 172 char name[9]; 173 174 snprintf(name, sizeof(name), "bank_%03d", bank->bank_number); 175 176 bank->bank_debug_dir = SYSCTL_ADD_NODE(&accel_dev->sysctl_ctx, 177 SYSCTL_CHILDREN(parent), 178 OID_AUTO, 179 name, 180 CTLFLAG_RD | CTLFLAG_SKIP, 181 NULL, 182 ""); 183 184 if (!bank->bank_debug_dir) { 185 printf("QAT: Failed to create bank debug dir.\n"); 186 return EFAULT; 187 } 188 189 bank->bank_debug_cfg = 190 SYSCTL_ADD_PROC(&accel_dev->sysctl_ctx, 191 SYSCTL_CHILDREN(bank->bank_debug_dir), 192 OID_AUTO, 193 "config", 194 CTLFLAG_RD | CTLTYPE_STRING, 195 bank, 196 0, 197 adf_bank_show, 198 "A", 199 "Bank configuration"); 200 201 if (!bank->bank_debug_cfg) { 202 printf("QAT: Failed to create bank debug entry.\n"); 203 return EFAULT; 204 } 205 206 return 0; 207 } 208 209 void 210 adf_bank_debugfs_rm(struct adf_etr_bank_data *bank) 211 { 212 } 213