/*-
 * Copyright (c) 2025, Samsung Electronics Co., Ltd.
 * Written by Jaeyoon Choi
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/sysctl.h>

#include "ufshci_private.h"
#include "ufshci_reg.h"

static int
ufshci_sysctl_timeout_period(SYSCTL_HANDLER_ARGS)
{
	uint32_t *ptr = arg1;
	uint32_t newval = *ptr;
	int error = sysctl_handle_int(oidp, &newval, 0, req);

	if (error || (req->newptr == NULL))
		return (error);

	if (newval > UFSHCI_MAX_TIMEOUT_PERIOD ||
	    newval < UFSHCI_MIN_TIMEOUT_PERIOD) {
		return (EINVAL);
	} else {
		*ptr = newval;
	}

	return (0);
}

static int
ufshci_sysctl_num_cmds(SYSCTL_HANDLER_ARGS)
{
	struct ufshci_controller *ctrlr = arg1;
	int64_t num_cmds = 0;
	int i;

	num_cmds = ctrlr->task_mgmt_req_queue.hwq[UFSHCI_SDB_Q].num_cmds;

	if (ctrlr->transfer_req_queue.hwq != NULL) {
		for (i = 0; i < ctrlr->num_io_queues; i++)
			num_cmds += ctrlr->transfer_req_queue.hwq[i].num_cmds;
	}

	return (sysctl_handle_64(oidp, &num_cmds, 0, req));
}

static int
ufshci_sysctl_num_intr_handler_calls(SYSCTL_HANDLER_ARGS)
{
	struct ufshci_controller *ctrlr = arg1;
	int64_t num_intr_handler_calls = 0;
	int i;

	num_intr_handler_calls =
	    ctrlr->task_mgmt_req_queue.hwq[UFSHCI_SDB_Q].num_intr_handler_calls;

	if (ctrlr->transfer_req_queue.hwq != NULL) {
		for (i = 0; i < ctrlr->num_io_queues; i++)
			num_intr_handler_calls += ctrlr->transfer_req_queue
						      .hwq[i]
						      .num_intr_handler_calls;
	}

	return (sysctl_handle_64(oidp, &num_intr_handler_calls, 0, req));
}

static int
ufshci_sysctl_num_retries(SYSCTL_HANDLER_ARGS)
{
	struct ufshci_controller *ctrlr = arg1;
	int64_t num_retries = 0;
	int i;

	num_retries = ctrlr->task_mgmt_req_queue.hwq[UFSHCI_SDB_Q].num_retries;

	if (ctrlr->transfer_req_queue.hwq != NULL) {
		for (i = 0; i < ctrlr->num_io_queues; i++)
			num_retries +=
			    ctrlr->transfer_req_queue.hwq[i].num_retries;
	}

	return (sysctl_handle_64(oidp, &num_retries, 0, req));
}

static int
ufshci_sysctl_num_failures(SYSCTL_HANDLER_ARGS)
{
	struct ufshci_controller *ctrlr = arg1;
	int64_t num_failures = 0;
	int i;

	num_failures =
	    ctrlr->task_mgmt_req_queue.hwq[UFSHCI_SDB_Q].num_failures;

	if (ctrlr->transfer_req_queue.hwq != NULL) {
		for (i = 0; i < ctrlr->num_io_queues; i++)
			num_failures +=
			    ctrlr->transfer_req_queue.hwq[i].num_failures;
	}

	return (sysctl_handle_64(oidp, &num_failures, 0, req));
}

static int
ufshci_sysctl_ahit(SYSCTL_HANDLER_ARGS)
{
	struct ufshci_controller *ctrlr = arg1;
	int64_t scale, timer;
	const int64_t scale_factor = 10;

	scale = UFSHCIV(UFSHCI_AHIT_REG_TS, ctrlr->ufs_dev.ahit);
	timer = UFSHCIV(UFSHCI_AHIT_REG_AH8ITV, ctrlr->ufs_dev.ahit);

	while (scale--)
		timer *= scale_factor;

	return (sysctl_handle_64(oidp, &timer, 0, req));
}

static void
ufshci_sysctl_initialize_queue(struct ufshci_hw_queue *hwq,
    struct sysctl_ctx_list *ctrlr_ctx, struct sysctl_oid *que_tree)
{
	struct sysctl_oid_list *que_list = SYSCTL_CHILDREN(que_tree);

	SYSCTL_ADD_UINT(ctrlr_ctx, que_list, OID_AUTO, "num_entries",
	    CTLFLAG_RD, &hwq->num_entries, 0,
	    "Number of entries in hardware queue");
	SYSCTL_ADD_UINT(ctrlr_ctx, que_list, OID_AUTO, "num_trackers",
	    CTLFLAG_RD, &hwq->num_trackers, 0,
	    "Number of trackers pre-allocated for this queue pair");
	SYSCTL_ADD_UINT(ctrlr_ctx, que_list, OID_AUTO, "sq_head", CTLFLAG_RD,
	    &hwq->sq_head, 0,
	    "Current head of submission queue (as observed by driver)");
	SYSCTL_ADD_UINT(ctrlr_ctx, que_list, OID_AUTO, "sq_tail", CTLFLAG_RD,
	    &hwq->sq_tail, 0,
	    "Current tail of submission queue (as observed by driver)");
	SYSCTL_ADD_UINT(ctrlr_ctx, que_list, OID_AUTO, "cq_head", CTLFLAG_RD,
	    &hwq->cq_head, 0,
	    "Current head of completion queue (as observed by driver)");

	SYSCTL_ADD_QUAD(ctrlr_ctx, que_list, OID_AUTO, "num_cmds", CTLFLAG_RD,
	    &hwq->num_cmds, "Number of commands submitted");
	SYSCTL_ADD_QUAD(ctrlr_ctx, que_list, OID_AUTO, "num_intr_handler_calls",
	    CTLFLAG_RD, &hwq->num_intr_handler_calls,
	    "Number of times interrupt handler was invoked (will typically be "
	    "less than number of actual interrupts generated due to "
	    "interrupt aggregation)");
	SYSCTL_ADD_QUAD(ctrlr_ctx, que_list, OID_AUTO, "num_retries",
	    CTLFLAG_RD, &hwq->num_retries, "Number of commands retried");
	SYSCTL_ADD_QUAD(ctrlr_ctx, que_list, OID_AUTO, "num_failures",
	    CTLFLAG_RD, &hwq->num_failures,
	    "Number of commands ending in failure after all retries");

	/* TODO: Implement num_ignored */
	/* TODO: Implement recovery state */
	/* TODO: Implement dump debug */
}

void
ufshci_sysctl_initialize_ctrlr(struct ufshci_controller *ctrlr)
{
	struct sysctl_ctx_list *ctrlr_ctx;
	struct sysctl_oid *ctrlr_tree, *que_tree, *ioq_tree;
	struct sysctl_oid_list *ctrlr_list, *ioq_list;
	struct ufshci_device *dev = &ctrlr->ufs_dev;
#define QUEUE_NAME_LENGTH 16
	char queue_name[QUEUE_NAME_LENGTH];
	int i;

	ctrlr_ctx = device_get_sysctl_ctx(ctrlr->dev);
	ctrlr_tree = device_get_sysctl_tree(ctrlr->dev);
	ctrlr_list = SYSCTL_CHILDREN(ctrlr_tree);

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "major_version",
	    CTLFLAG_RD, &ctrlr->major_version, 0, "UFS spec major version");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "minor_version",
	    CTLFLAG_RD, &ctrlr->minor_version, 0, "UFS spec minor version");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "io_queue_mode",
	    CTLFLAG_RD, &ctrlr->transfer_req_queue.queue_mode, 0,
	    "Active host-side queuing scheme "
	    "(Single-Doorbell or Multi-Circular-Queue)");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "num_io_queues",
	    CTLFLAG_RD, &ctrlr->num_io_queues, 0, "Number of I/O queue pairs");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "cap", CTLFLAG_RD,
	    &ctrlr->cap, 0, "Host controller capabilities register value");

	SYSCTL_ADD_BOOL(ctrlr_ctx, ctrlr_list, OID_AUTO, "wb_enabled",
	    CTLFLAG_RD, &dev->is_wb_enabled, 0, "WriteBooster enable/disable");

	SYSCTL_ADD_BOOL(ctrlr_ctx, ctrlr_list, OID_AUTO, "wb_flush_enabled",
	    CTLFLAG_RD, &dev->is_wb_flush_enabled, 0,
	    "WriteBooster flush enable/disable");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "wb_buffer_type",
	    CTLFLAG_RD, &dev->wb_buffer_type, 0, "WriteBooster type");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "wb_buffer_size_mb",
	    CTLFLAG_RD, &dev->wb_buffer_size_mb, 0,
	    "WriteBooster buffer size in MB");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO,
	    "wb_user_space_config_option", CTLFLAG_RD,
	    &dev->wb_user_space_config_option, 0,
	    "WriteBooster preserve user space mode");

	SYSCTL_ADD_BOOL(ctrlr_ctx, ctrlr_list, OID_AUTO,
	    "auto_hibernation_supported", CTLFLAG_RD,
	    &dev->auto_hibernation_supported, 0,
	    "Device auto hibernation support");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
	    "auto_hibernate_idle_timer_value",
	    CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE, ctrlr, 0,
	    ufshci_sysctl_ahit, "IU",
	    "Auto-Hibernate Idle Timer Value (in microseconds)");

	SYSCTL_ADD_BOOL(ctrlr_ctx, ctrlr_list, OID_AUTO, "power_mode_supported",
	    CTLFLAG_RD, &dev->power_mode_supported, 0,
	    "Device power mode support");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "power_mode",
	    CTLFLAG_RD, &dev->power_mode, 0, "Current device power mode");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "tx_rx_power_mode",
	    CTLFLAG_RD, &ctrlr->tx_rx_power_mode, 0,
	    "Current TX/RX PA_PWRMode value");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "max_tx_lanes",
	    CTLFLAG_RD, &ctrlr->max_tx_lanes, 0,
	    "Maximum available TX data lanes");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "max_rx_lanes",
	    CTLFLAG_RD, &ctrlr->max_rx_lanes, 0,
	    "Maximum available RX data lanes");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "tx_lanes", CTLFLAG_RD,
	    &ctrlr->tx_lanes, 0, "Active TX data lanes");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "rx_lanes", CTLFLAG_RD,
	    &ctrlr->rx_lanes, 0, "Active RX data lanes");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "max_rx_hs_gear",
	    CTLFLAG_RD, &ctrlr->max_rx_hs_gear, 0,
	    "Maximum available RX HS gear");

	SYSCTL_ADD_UINT(ctrlr_ctx, ctrlr_list, OID_AUTO, "hs_gear", CTLFLAG_RD,
	    &ctrlr->hs_gear, 0, "Active HS gear");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO, "timeout_period",
	    CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, &ctrlr->timeout_period,
	    0, ufshci_sysctl_timeout_period, "IU",
	    "Timeout period for I/O queues (in seconds)");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO, "num_cmds",
	    CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE, ctrlr, 0,
	    ufshci_sysctl_num_cmds, "IU", "Number of commands submitted");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
	    "num_intr_handler_calls", CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
	    ctrlr, 0, ufshci_sysctl_num_intr_handler_calls, "IU",
	    "Number of times interrupt handler was invoked (will "
	    "typically be less than number of actual interrupts "
	    "generated due to coalescing)");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO, "num_retries",
	    CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE, ctrlr, 0,
	    ufshci_sysctl_num_retries, "IU", "Number of commands retried");

	SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO, "num_failures",
	    CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE, ctrlr, 0,
	    ufshci_sysctl_num_failures, "IU",
	    "Number of commands ending in failure after all retries");

	que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO, "utmrq",
	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
	    "UTP Task Management Request Queue");

	ufshci_sysctl_initialize_queue(
	    &ctrlr->task_mgmt_req_queue.hwq[UFSHCI_SDB_Q], ctrlr_ctx, que_tree);

	/*
	 * Make sure that we've constructed the I/O queues before setting up the
	 * sysctls. Failed controllers won't allocate it, but we want the rest
	 * of the sysctls to diagnose things.
	 */
	if (ctrlr->transfer_req_queue.hwq != NULL) {
		ioq_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO,
		    "ioq", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
		    "UTP Transfer Request Queue (I/O Queue)");
		ioq_list = SYSCTL_CHILDREN(ioq_tree);

		for (i = 0; i < ctrlr->num_io_queues; i++) {
			snprintf(queue_name, QUEUE_NAME_LENGTH, "%d", i);
			que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ioq_list,
			    OID_AUTO, queue_name, CTLFLAG_RD | CTLFLAG_MPSAFE,
			    NULL, "IO Queue");
			ufshci_sysctl_initialize_queue(
			    &ctrlr->transfer_req_queue.hwq[i], ctrlr_ctx,
			    que_tree);
		}
	}
}