adf_freebsd_transport_debug.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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 }

Cache object: 74a5de0e2d641ecc784af1ba904f7e15

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/qat/qat_common/adf_freebsd_transport_debug.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/qat/qat_common/adf_freebsd_transport_debug.c