/* SPDX-License-Identifier: MIT */
/*
 * Copyright © 2022 Intel Corporation
 */

#ifndef _XE_FORCE_WAKE_TYPES_H_
#define _XE_FORCE_WAKE_TYPES_H_

#include <linux/mutex.h>
#include <linux/types.h>

#include "regs/xe_reg_defs.h"

enum xe_force_wake_domain_id {
        XE_FW_DOMAIN_ID_GT = 0,
        XE_FW_DOMAIN_ID_RENDER,
        XE_FW_DOMAIN_ID_MEDIA,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX0,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX1,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX2,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX3,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX4,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX5,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX6,
        XE_FW_DOMAIN_ID_MEDIA_VDBOX7,
        XE_FW_DOMAIN_ID_MEDIA_VEBOX0,
        XE_FW_DOMAIN_ID_MEDIA_VEBOX1,
        XE_FW_DOMAIN_ID_MEDIA_VEBOX2,
        XE_FW_DOMAIN_ID_MEDIA_VEBOX3,
        XE_FW_DOMAIN_ID_GSC,
        XE_FW_DOMAIN_ID_COUNT
};

enum xe_force_wake_domains {
        XE_FW_GT                = BIT(XE_FW_DOMAIN_ID_GT),
        XE_FW_RENDER            = BIT(XE_FW_DOMAIN_ID_RENDER),
        XE_FW_MEDIA             = BIT(XE_FW_DOMAIN_ID_MEDIA),
        XE_FW_MEDIA_VDBOX0      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX0),
        XE_FW_MEDIA_VDBOX1      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX1),
        XE_FW_MEDIA_VDBOX2      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX2),
        XE_FW_MEDIA_VDBOX3      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX3),
        XE_FW_MEDIA_VDBOX4      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX4),
        XE_FW_MEDIA_VDBOX5      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX5),
        XE_FW_MEDIA_VDBOX6      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX6),
        XE_FW_MEDIA_VDBOX7      = BIT(XE_FW_DOMAIN_ID_MEDIA_VDBOX7),
        XE_FW_MEDIA_VEBOX0      = BIT(XE_FW_DOMAIN_ID_MEDIA_VEBOX0),
        XE_FW_MEDIA_VEBOX1      = BIT(XE_FW_DOMAIN_ID_MEDIA_VEBOX1),
        XE_FW_MEDIA_VEBOX2      = BIT(XE_FW_DOMAIN_ID_MEDIA_VEBOX2),
        XE_FW_MEDIA_VEBOX3      = BIT(XE_FW_DOMAIN_ID_MEDIA_VEBOX3),
        XE_FW_GSC               = BIT(XE_FW_DOMAIN_ID_GSC),
        XE_FORCEWAKE_ALL        = BIT(XE_FW_DOMAIN_ID_COUNT)
};

/**
 * struct xe_force_wake_domain - Xe force wake power domain
 *
 * Represents an individual device-internal power domain.  The driver must
 * ensure the power domain is awake before accessing registers or other
 * hardware functionality that is part of the power domain.  Since different
 * driver threads may access hardware units simultaneously, a reference count
 * is used to ensure that the domain remains awake as long as any software
 * is using the part of the hardware covered by the power domain.
 *
 * Hardware provides a register interface to allow the driver to request
 * wake/sleep of power domains, although in most cases the actual action of
 * powering the hardware up/down is handled by firmware (and may be subject to
 * requirements and constraints outside of the driver's visibility) so the
 * driver needs to wait for an acknowledgment that a wake request has been
 * acted upon before accessing the parts of the hardware that reside within the
 * power domain.
 */
struct xe_force_wake_domain {
        /** @id: domain force wake id */
        enum xe_force_wake_domain_id id;
        /** @reg_ctl: domain wake control register address */
        struct xe_reg reg_ctl;
        /** @reg_ack: domain ack register address */
        struct xe_reg reg_ack;
        /** @val: domain wake write value */
        u32 val;
        /** @mask: domain mask */
        u32 mask;
        /** @ref: domain reference */
        u32 ref;
};

/**
 * struct xe_force_wake - Xe force wake collection
 *
 * Represents a collection of related power domains (struct
 * xe_force_wake_domain) associated with a subunit of the device.
 *
 * Currently only used for GT power domains (where the term "forcewake" is used
 * in the hardware documentation), although the interface could be extended to
 * power wells in other parts of the hardware in the future.
 */
struct xe_force_wake {
        /** @gt: back pointers to GT */
        struct xe_gt *gt;
        /** @lock: protects everything force wake struct */
        spinlock_t lock;
        /** @awake_domains: mask of all domains awake */
        unsigned int awake_domains;
        /** @initialized_domains: mask of all initialized domains */
        unsigned int initialized_domains;
        /** @domains: force wake domains */
        struct xe_force_wake_domain domains[XE_FW_DOMAIN_ID_COUNT];
};

#endif