drivers/crypto/qat/qat_common/adf_transport_debug.c

   1 /*
   2   This file is provided under a dual BSD/GPLv2 license.  When using or
   3   redistributing this file, you may do so under either license.
   4
   5   GPL LICENSE SUMMARY
   6   Copyright(c) 2014 Intel Corporation.
   7   This program is free software; you can redistribute it and/or modify
   8   it under the terms of version 2 of the GNU General Public License as
   9   published by the Free Software Foundation.
  10
  11   This program is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   General Public License for more details.
  15
  16   Contact Information:
  17   qat-linux@intel.com
  18
  19   BSD LICENSE
  20   Copyright(c) 2014 Intel Corporation.
  21   Redistribution and use in source and binary forms, with or without
  22   modification, are permitted provided that the following conditions
  23   are met:
  24
  25     * Redistributions of source code must retain the above copyright
  26       notice, this list of conditions and the following disclaimer.
  27     * Redistributions in binary form must reproduce the above copyright
  28       notice, this list of conditions and the following disclaimer in
  29       the documentation and/or other materials provided with the
  30       distribution.
  31     * Neither the name of Intel Corporation nor the names of its
  32       contributors may be used to endorse or promote products derived
  33       from this software without specific prior written permission.
  34
  35   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  36   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  38   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  39   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  42   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  43   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  44   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  45   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46 */
  47 #include <linux/mutex.h>
  48 #include <linux/slab.h>
  49 #include <linux/seq_file.h>
  50 #include "adf_accel_devices.h"
  51 #include "adf_transport_internal.h"
  52 #include "adf_transport_access_macros.h"
  53
  54 static DEFINE_MUTEX(ring_read_lock);
  55 static DEFINE_MUTEX(bank_read_lock);
  56
  57 static void *adf_ring_start(struct seq_file *sfile, loff_t *pos)
  58 {
  59         struct adf_etr_ring_data *ring = sfile->private;
  60
  61         mutex_lock(&ring_read_lock);
  62         if (*pos == 0)
  63                 return SEQ_START_TOKEN;
  64
  65         if (*pos >= (ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size) /
  66                      ADF_MSG_SIZE_TO_BYTES(ring->msg_size)))
  67                 return NULL;
  68
  69         return ring->base_addr +
  70                 (ADF_MSG_SIZE_TO_BYTES(ring->msg_size) * (*pos)++);
  71 }
  72
  73 static void *adf_ring_next(struct seq_file *sfile, void *v, loff_t *pos)
  74 {
  75         struct adf_etr_ring_data *ring = sfile->private;
  76
  77         if (*pos >= (ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size) /
  78                      ADF_MSG_SIZE_TO_BYTES(ring->msg_size)))
  79                 return NULL;
  80
  81         return ring->base_addr +
  82                 (ADF_MSG_SIZE_TO_BYTES(ring->msg_size) * (*pos)++);
  83 }
  84
  85 static int adf_ring_show(struct seq_file *sfile, void *v)
  86 {
  87         struct adf_etr_ring_data *ring = sfile->private;
  88         struct adf_etr_bank_data *bank = ring->bank;
  89         uint32_t *msg = v;
  90         void __iomem *csr = ring->bank->csr_addr;
  91         int i, x;
  92
  93         if (v == SEQ_START_TOKEN) {
  94                 int head, tail, empty;
  95
  96                 head = READ_CSR_RING_HEAD(csr, bank->bank_number,
  97                                           ring->ring_number);
  98                 tail = READ_CSR_RING_TAIL(csr, bank->bank_number,
  99                                           ring->ring_number);
 100                 empty = READ_CSR_E_STAT(csr, bank->bank_number);
 101
 102                 seq_puts(sfile, "------- Ring configuration -------\n");
 103                 seq_printf(sfile, "ring num %d, bank num %d\n",
 104                            ring->ring_number, ring->bank->bank_number);
 105                 seq_printf(sfile, "head %x, tail %x, empty: %d\n",
 106                            head, tail, (empty & 1 << ring->ring_number)
 107                            >> ring->ring_number);
 108                 seq_printf(sfile, "ring size %d, msg size %d\n",
 109                            ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size),
 110                            ADF_MSG_SIZE_TO_BYTES(ring->msg_size));
 111                 seq_puts(sfile, "----------- Ring data ------------\n");
 112                 return 0;
 113         }
 114         seq_printf(sfile, "%p:", msg);
 115         x = 0;
 116         i = 0;
 117         for (; i < (ADF_MSG_SIZE_TO_BYTES(ring->msg_size) >> 2); i++) {
 118                 seq_printf(sfile, " %08X", *(msg + i));
 119                 if ((ADF_MSG_SIZE_TO_BYTES(ring->msg_size) >> 2) != i + 1 &&
 120                     (++x == 8)) {
 121                         seq_printf(sfile, "\n%p:", msg + i + 1);
 122                         x = 0;
 123                 }
 124         }
 125         seq_puts(sfile, "\n");
 126         return 0;
 127 }
 128
 129 static void adf_ring_stop(struct seq_file *sfile, void *v)
 130 {
 131         mutex_unlock(&ring_read_lock);
 132 }
 133
 134 static const struct seq_operations adf_ring_sops = {
 135         .start = adf_ring_start,
 136         .next = adf_ring_next,
 137         .stop = adf_ring_stop,
 138         .show = adf_ring_show
 139 };
 140
 141 static int adf_ring_open(struct inode *inode, struct file *file)
 142 {
 143         int ret = seq_open(file, &adf_ring_sops);
 144
 145         if (!ret) {
 146                 struct seq_file *seq_f = file->private_data;
 147
 148                 seq_f->private = inode->i_private;
 149         }
 150         return ret;
 151 }
 152
 153 static const struct file_operations adf_ring_debug_fops = {
 154         .open = adf_ring_open,
 155         .read = seq_read,
 156         .llseek = seq_lseek,
 157         .release = seq_release
 158 };
 159
 160 int adf_ring_debugfs_add(struct adf_etr_ring_data *ring, const char *name)
 161 {
 162         struct adf_etr_ring_debug_entry *ring_debug;
 163         char entry_name[8];
 164
 165         ring_debug = kzalloc(sizeof(*ring_debug), GFP_KERNEL);
 166         if (!ring_debug)
 167                 return -ENOMEM;
 168
 169         strlcpy(ring_debug->ring_name, name, sizeof(ring_debug->ring_name));
 170         snprintf(entry_name, sizeof(entry_name), "ring_%02d",
 171                  ring->ring_number);
 172
 173         ring_debug->debug = debugfs_create_file(entry_name, S_IRUSR,
 174                                                 ring->bank->bank_debug_dir,
 175                                                 ring, &adf_ring_debug_fops);
 176         if (!ring_debug->debug) {
 177                 pr_err("QAT: Failed to create ring debug entry.\n");
 178                 kfree(ring_debug);
 179                 return -EFAULT;
 180         }
 181         ring->ring_debug = ring_debug;
 182         return 0;
 183 }
 184
 185 void adf_ring_debugfs_rm(struct adf_etr_ring_data *ring)
 186 {
 187         if (ring->ring_debug) {
 188                 debugfs_remove(ring->ring_debug->debug);
 189                 kfree(ring->ring_debug);
 190                 ring->ring_debug = NULL;
 191         }
 192 }
 193
 194 static void *adf_bank_start(struct seq_file *sfile, loff_t *pos)
 195 {
 196         mutex_lock(&bank_read_lock);
 197         if (*pos == 0)
 198                 return SEQ_START_TOKEN;
 199
 200         if (*pos >= ADF_ETR_MAX_RINGS_PER_BANK)
 201                 return NULL;
 202
 203         return pos;
 204 }
 205
 206 static void *adf_bank_next(struct seq_file *sfile, void *v, loff_t *pos)
 207 {
 208         if (++(*pos) >= ADF_ETR_MAX_RINGS_PER_BANK)
 209                 return NULL;
 210
 211         return pos;
 212 }
 213
 214 static int adf_bank_show(struct seq_file *sfile, void *v)
 215 {
 216         struct adf_etr_bank_data *bank = sfile->private;
 217
 218         if (v == SEQ_START_TOKEN) {
 219                 seq_printf(sfile, "------- Bank %d configuration -------\n",
 220                            bank->bank_number);
 221         } else {
 222                 int ring_id = *((int *)v) - 1;
 223                 struct adf_etr_ring_data *ring = &bank->rings[ring_id];
 224                 void __iomem *csr = bank->csr_addr;
 225                 int head, tail, empty;
 226
 227                 if (!(bank->ring_mask & 1 << ring_id))
 228                         return 0;
 229
 230                 head = READ_CSR_RING_HEAD(csr, bank->bank_number,
 231                                           ring->ring_number);
 232                 tail = READ_CSR_RING_TAIL(csr, bank->bank_number,
 233                                           ring->ring_number);
 234                 empty = READ_CSR_E_STAT(csr, bank->bank_number);
 235
 236                 seq_printf(sfile,
 237                            "ring num %02d, head %04x, tail %04x, empty: %d\n",
 238                            ring->ring_number, head, tail,
 239                            (empty & 1 << ring->ring_number) >>
 240                            ring->ring_number);
 241         }
 242         return 0;
 243 }
 244
 245 static void adf_bank_stop(struct seq_file *sfile, void *v)
 246 {
 247         mutex_unlock(&bank_read_lock);
 248 }
 249
 250 static const struct seq_operations adf_bank_sops = {
 251         .start = adf_bank_start,
 252         .next = adf_bank_next,
 253         .stop = adf_bank_stop,
 254         .show = adf_bank_show
 255 };
 256
 257 static int adf_bank_open(struct inode *inode, struct file *file)
 258 {
 259         int ret = seq_open(file, &adf_bank_sops);
 260
 261         if (!ret) {
 262                 struct seq_file *seq_f = file->private_data;
 263
 264                 seq_f->private = inode->i_private;
 265         }
 266         return ret;
 267 }
 268
 269 static const struct file_operations adf_bank_debug_fops = {
 270         .open = adf_bank_open,
 271         .read = seq_read,
 272         .llseek = seq_lseek,
 273         .release = seq_release
 274 };
 275
 276 int adf_bank_debugfs_add(struct adf_etr_bank_data *bank)
 277 {
 278         struct adf_accel_dev *accel_dev = bank->accel_dev;
 279         struct dentry *parent = accel_dev->transport->debug;
 280         char name[8];
 281
 282         snprintf(name, sizeof(name), "bank_%02d", bank->bank_number);
 283         bank->bank_debug_dir = debugfs_create_dir(name, parent);
 284         if (!bank->bank_debug_dir) {
 285                 pr_err("QAT: Failed to create bank debug dir.\n");
 286                 return -EFAULT;
 287         }
 288
 289         bank->bank_debug_cfg = debugfs_create_file("config", S_IRUSR,
 290                                                    bank->bank_debug_dir, bank,
 291                                                    &adf_bank_debug_fops);
 292         if (!bank->bank_debug_cfg) {
 293                 pr_err("QAT: Failed to create bank debug entry.\n");
 294                 debugfs_remove(bank->bank_debug_dir);
 295                 return -EFAULT;
 296         }
 297         return 0;
 298 }
 299
 300 void adf_bank_debugfs_rm(struct adf_etr_bank_data *bank)
 301 {
 302         debugfs_remove(bank->bank_debug_cfg);
 303         debugfs_remove(bank->bank_debug_dir);
 304 }