LXR linux/drivers/misc/xilinx-ai-engine/ai-engine-sysfs-status.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Xilinx AI Engine driver AIE device specific implementation
   4 *
   5 * Copyright (C) 2021 Xilinx, Inc.
   6 */
   7#include <linux/slab.h>
   8
   9#include "ai-engine-internal.h"
  10
  11/**
  12 * aie_part_read_cb_status() - exports status of cores, DMAs, errors, and locks
  13 *                             within a partition at a partition level node.
  14 *                             this node serves as a single access point to
  15 *                             query the status of a partition by a
  16 *                             script/tool. For a given tile location, core
  17 *                             status, DMAs, etc are separated by a ';' symbol.
  18 *                             Core status information is captured under 'cs'
  19 *                             label, DMA under 'ds', errors under 'es', and
  20 *                             lock status under 'ls'.
  21 * @kobj: kobject used to create sysfs node.
  22 * @buffer: export buffer.
  23 * @size: length of export buffer available.
  24 * @return: length of string copied to buffer.
  25 */
  26ssize_t aie_part_read_cb_status(struct kobject *kobj, char *buffer,
  27                                ssize_t size)
  28{
  29        struct device *dev = container_of(kobj, struct device, kobj);
  30        struct aie_partition *apart = dev_to_aiepart(dev);
  31        struct aie_tile *atile = apart->atiles;
  32        ssize_t len = 0;
  33        size_t temp_size = AIE_SYSFS_CORE_STS_SIZE + AIE_SYSFS_CHAN_STS_SIZE +
  34                           AIE_SYSFS_ERROR_CATEGORY_SIZE +
  35                           AIE_SYSFS_LOCK_STS_SIZE;
  36        char *cs_buf, *ds_buf, *es_buf, *ls_buf;
  37        u32 index;
  38
  39        if (mutex_lock_interruptible(&apart->mlock)) {
  40                dev_err(&apart->dev,
  41                        "Failed to acquire lock. Process was interrupted by fatal signals\n");
  42                return len;
  43        }
  44
  45        cs_buf = kmalloc(temp_size, GFP_KERNEL);
  46        if (!cs_buf) {
  47                mutex_unlock(&apart->mlock);
  48                return len;
  49        }
  50
  51        ds_buf = cs_buf + AIE_SYSFS_CORE_STS_SIZE;
  52        es_buf = ds_buf + AIE_SYSFS_CHAN_STS_SIZE;
  53        ls_buf = es_buf + AIE_SYSFS_ERROR_CATEGORY_SIZE;
  54
  55        for (index = 0; index < apart->range.size.col * apart->range.size.row;
  56             index++, atile++) {
  57                u32 cs = 0, ds = 0, es = 0, ls = 0;
  58
  59                cs = aie_sysfs_get_core_status(apart, &atile->loc, cs_buf,
  60                                               AIE_SYSFS_CORE_STS_SIZE);
  61                ds = aie_sysfs_get_dma_status(apart, &atile->loc, ds_buf,
  62                                              AIE_SYSFS_CHAN_STS_SIZE);
  63                es = aie_sysfs_get_errors(apart, &atile->loc, es_buf,
  64                                          AIE_SYSFS_ERROR_CATEGORY_SIZE);
  65                ls = aie_sysfs_get_lock_status(apart, &atile->loc, ls_buf,
  66                                               AIE_SYSFS_LOCK_STS_SIZE);
  67
  68                if (!(cs || ds || es || ls))
  69                        continue;
  70
  71                len += scnprintf(&buffer[len], max(0L, size - len), "%d_%d: ",
  72                                 atile->loc.col, atile->loc.row);
  73
  74                if (cs) {
  75                        len += scnprintf(&buffer[len], max(0L, size - len),
  76                                         "cs: %s", cs_buf);
  77                }
  78
  79                if (ds) {
  80                        len += scnprintf(&buffer[len], max(0L, size - len),
  81                                         "%sds: %s", cs ?
  82                                         DELIMITER_LEVEL2 : "", ds_buf);
  83                }
  84
  85                if (es) {
  86                        len += scnprintf(&buffer[len], max(0L, size - len),
  87                                         "%ses: %s", (cs || ds) ?
  88                                         DELIMITER_LEVEL2 : "", es_buf);
  89                }
  90
  91                if (ls) {
  92                        len += scnprintf(&buffer[len], max(0L, size - len),
  93                                         "%sls: %s", (cs || ds || es) ?
  94                                         DELIMITER_LEVEL2 : "", ls_buf);
  95                }
  96
  97                len += scnprintf(&buffer[len], max(0L, size - len), "\n");
  98        }
  99
 100        mutex_unlock(&apart->mlock);
 101        kfree(cs_buf);
 102        return len;
 103}
 104