// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2024-2026 Intel Corporation
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/pm_runtime.h>
#include <linux/units.h>

#include "ivpu_drv.h"
#include "ivpu_gem.h"
#include "ivpu_fw.h"
#include "ivpu_hw.h"
#include "ivpu_sysfs.h"

/**
 * DOC: npu_busy_time_us
 *
 * npu_busy_time_us is the time that the device spent executing jobs.
 * The time is counted when and only when there are jobs submitted to firmware.
 *
 * This time can be used to measure the utilization of NPU, either by calculating
 * npu_busy_time_us difference between two timepoints (i.e. measuring the time
 * that the NPU was active during some workload) or monitoring utilization percentage
 * by reading npu_busy_time_us periodically.
 *
 * When reading the value periodically, it shouldn't be read too often as it may have
 * an impact on job submission performance. Recommended period is 1 second.
 */
static ssize_t
npu_busy_time_us_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        ktime_t total, now = 0;

        mutex_lock(&vdev->submitted_jobs_lock);

        total = vdev->busy_time;
        if (!xa_empty(&vdev->submitted_jobs_xa))
                now = ktime_sub(ktime_get(), vdev->busy_start_ts);
        mutex_unlock(&vdev->submitted_jobs_lock);

        return sysfs_emit(buf, "%lld\n", ktime_to_us(ktime_add(total, now)));
}

static DEVICE_ATTR_RO(npu_busy_time_us);

/**
 * DOC: npu_memory_utilization
 *
 * The npu_memory_utilization is used to report in bytes a current NPU memory utilization.
 *
 */
static ssize_t
npu_memory_utilization_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        struct ivpu_bo *bo;
        u64 total_npu_memory = 0;

        mutex_lock(&vdev->bo_list_lock);
        list_for_each_entry(bo, &vdev->bo_list, bo_list_node)
                if (ivpu_bo_is_resident(bo))
                        total_npu_memory += ivpu_bo_size(bo);
        mutex_unlock(&vdev->bo_list_lock);

        return sysfs_emit(buf, "%lld\n", total_npu_memory);
}

static DEVICE_ATTR_RO(npu_memory_utilization);

/**
 * DOC: sched_mode
 *
 * The sched_mode is used to report current NPU scheduling mode.
 *
 * It returns following strings:
 * - "HW"               - Hardware Scheduler mode
 * - "OS"               - Operating System Scheduler mode
 *
 */
static ssize_t sched_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);

        return sysfs_emit(buf, "%s\n", vdev->fw->sched_mode ? "HW" : "OS");
}

static DEVICE_ATTR_RO(sched_mode);

/**
 * DOC: NPU frequency control and information
 *
 * Hardware frequency capabilities:
 * freq/hw_min_freq - Minimum frequency supported by the NPU hardware.
 * freq/hw_max_freq - Maximum frequency supported by the NPU hardware.
 * freq/hw_efficient_freq - Most efficient operating frequency for the NPU.
 *
 * Configurable frequency limits (50XX devices and newer):
 * freq/set_min_freq - Configured minimum operating frequency.
 * freq/set_max_freq - Configured maximum operating frequency.
 *
 * Clamping behavior: Values written to set_min_freq and set_max_freq are
 * clamped to hardware limits. If set_min_freq exceeds set_max_freq, the driver
 * clamps set_min_freq to set_max_freq when selecting the operating frequency.
 *
 * Current operating frequency:
 * freq/current_freq - Current frequency in MHz. Valid only when the device is
 * active; returns 0 when idle. May be lower than the requested range due to
 * power or thermal constraints.
 *
 * Legacy attributes (backward compatibility):
 * npu_max_frequency_mhz - Alias for freq/hw_max_freq.
 * npu_current_frequency_mhz - Alias for freq/current_freq.
 */

static ssize_t hw_min_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = ivpu_hw_btrs_pll_ratio_to_mhz(vdev, vdev->hw->pll.min_ratio);

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static DEVICE_ATTR_RO(hw_min_freq);

static ssize_t hw_efficient_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = ivpu_hw_btrs_pll_ratio_to_mhz(vdev, vdev->hw->pll.pn_ratio);

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static DEVICE_ATTR_RO(hw_efficient_freq);

static ssize_t hw_max_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = ivpu_hw_btrs_pll_ratio_to_mhz(vdev, vdev->hw->pll.max_ratio);

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static DEVICE_ATTR_RO(hw_max_freq);

static ssize_t set_min_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = ivpu_hw_btrs_pll_ratio_to_mhz(vdev, vdev->hw->pll.cfg_min_ratio);

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static ssize_t
set_min_freq_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz;
        int ret;

        ret = kstrtou32(buf, 10, &freq_mhz);
        if (ret)
                return ret;

        ret = ivpu_hw_btrs_cfg_min_freq_set(vdev, freq_mhz);
        if (ret)
                return ret;

        return count;
}

static DEVICE_ATTR_RW(set_min_freq);

static ssize_t set_max_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = ivpu_hw_btrs_pll_ratio_to_mhz(vdev, vdev->hw->pll.cfg_max_ratio);

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static ssize_t
set_max_freq_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz;
        int ret;

        ret = kstrtou32(buf, 10, &freq_mhz);
        if (ret)
                return ret;

        /* Convert MHz to Hz and set max frequency */
        ret = ivpu_hw_btrs_cfg_max_freq_set(vdev, freq_mhz);
        if (ret)
                return ret;

        return count;
}

static DEVICE_ATTR_RW(set_max_freq);

static ssize_t current_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct drm_device *drm = dev_get_drvdata(dev);
        struct ivpu_device *vdev = to_ivpu_device(drm);
        u32 freq_mhz = 0;

        /* Read frequency only if device is active, otherwise frequency is 0 */
        if (pm_runtime_get_if_active(vdev->drm.dev) > 0) {
                freq_mhz = ivpu_hw_btrs_current_freq_get(vdev);

                pm_runtime_put_autosuspend(vdev->drm.dev);
        }

        return sysfs_emit(buf, "%u\n", freq_mhz);
}

static DEVICE_ATTR_RO(current_freq);

/* Alias to current_freq for legacy compat */
static struct device_attribute dev_attr_npu_max_frequency_mhz =
        __ATTR(npu_max_frequency_mhz, 0444, hw_max_freq_show, NULL);

static struct device_attribute dev_attr_npu_current_frequency_mhz =
        __ATTR(npu_current_frequency_mhz, 0444, current_freq_show, NULL);

static struct attribute *ivpu_freq_attrs[] = {
        &dev_attr_hw_min_freq.attr,
        &dev_attr_hw_efficient_freq.attr,
        &dev_attr_hw_max_freq.attr,
        &dev_attr_current_freq.attr,
        NULL,
};

static struct attribute_group ivpu_freq_attr_group = {
        .name = "freq",
        .attrs = ivpu_freq_attrs,
};

static struct attribute *ivpu_dev_attrs[] = {
        &dev_attr_npu_busy_time_us.attr,
        &dev_attr_npu_memory_utilization.attr,
        &dev_attr_sched_mode.attr,
        &dev_attr_npu_max_frequency_mhz.attr,
        &dev_attr_npu_current_frequency_mhz.attr,
        NULL,
};

static struct attribute_group ivpu_dev_attr_group = {
        .attrs = ivpu_dev_attrs,
};

void ivpu_sysfs_init(struct ivpu_device *vdev)
{
        int ret;

        ret = devm_device_add_group(vdev->drm.dev, &ivpu_dev_attr_group);
        if (ret) {
                ivpu_warn(vdev, "Failed to add sysfs group to device, ret %d", ret);
                return;
        }

        ret = devm_device_add_group(vdev->drm.dev, &ivpu_freq_attr_group);
        if (ret) {
                ivpu_warn(vdev, "Failed to add sysfs freq group, ret %d", ret);
                return;
        }

        if (ivpu_hw_ip_gen(vdev) >= IVPU_HW_IP_50XX) {
                ret = sysfs_add_file_to_group(&vdev->drm.dev->kobj,
                                              &dev_attr_set_min_freq.attr,
                                              "freq");
                if (ret) {
                        ivpu_warn(vdev, "Failed to add sysfs set_min_freq to device, ret %d", ret);
                        return;
                }

                ret = sysfs_add_file_to_group(&vdev->drm.dev->kobj,
                                              &dev_attr_set_max_freq.attr,
                                              "freq");
                if (ret) {
                        ivpu_warn(vdev, "Failed to add sysfs set_max_freq to device, ret %d", ret);
                        return;
                }
        }
}