Commit 1c2097bb authored by Riana Tauro's avatar Riana Tauro Committed by Rodrigo Vivi
Browse files

drm/xe: add a new sysfs directory for gtidle properties 



1) Add a new sysfs directory under devices/gt#/ called gtidle
   to contain idle properties of GT such as name, idle_status,
   idle_residency_ms

2) Remove forcewake calls for residency counter

v2:
    - abstract using function pointers (Anshuman)
    - remove forcewake calls for residency counter
    - use device_attr (Badal)
    - move rc functions to guc_pc
    - change name to gt_idle (Rodrigo)

v3:
    - return error for drmm_add_action_or_reset
    - replace file and functions with gt_idle prefix
      to gt_idle_sysfs (Himal)
    - use enum for gt idle state
    - move multiplier to gt idle and initialize (Anshuman)
    - correct doc annotation (Rodrigo)
    - remove return variable
    - use kobj_gt instead of new gtidle kobj
    - move residency_ms to gtidle file
    - retain xe_guc_pc prefix for functions in guc_rc file (Michal)

v4:
    - fix doc errors in xe_guc_pc file
    - change u64 to u32 for reading residency counter
    - keep gtidle states generic GT_IDLE_C[0/6] (Anshuman)

v5:
    - update commit message to include removal of
      forcewake calls (Anshuman)
    - return void from sysfs initialization function and add warnings
      (Andi)

v6:
    - remove extra lines (Anshuman)

Signed-off-by: default avatarRiana Tauro <riana.tauro@intel.com>
Acked-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
Reviewed-by: default avatarAnshuman Gupta <anshuman.gupta@intel.com>
Reviewed-by: default avatarAndi Shyti <andi.shyti@linux.intel.com>
Signed-off-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
parent 513e8262

drivers/gpu/drm/xe/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -62,6 +62,7 @@ xe-y += xe_bb.o \ 
	xe_gt.o \

	xe_gt_clock.o \

	xe_gt_debugfs.o \

	xe_gt_idle_sysfs.o \

	xe_gt_mcr.o \

	xe_gt_pagefault.o \

	xe_gt_sysfs.o \

drivers/gpu/drm/xe/xe_gt.c

+3 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include "xe_force_wake.h"

#include "xe_ggtt.h"

#include "xe_gt_clock.h"

#include "xe_gt_idle_sysfs.h"

#include "xe_gt_mcr.h"

#include "xe_gt_pagefault.h"

#include "xe_gt_printk.h"
@@ -306,6 +307,8 @@ static int gt_fw_domain_init(struct xe_gt *gt) 
	if (err)

		goto err_force_wake;



	xe_gt_idle_sysfs_init(&gt->gtidle);



	/* XXX: Fake that we pull the engine mask from hwconfig blob */

	gt->info.engine_mask = gt->info.__engine_mask;

drivers/gpu/drm/xe/xe_gt_idle_sysfs.c

0 → 100644
+162 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: MIT

/*

 * Copyright © 2023 Intel Corporation

 */



#include <drm/drm_managed.h>



#include "xe_device.h"

#include "xe_gt.h"

#include "xe_gt_idle_sysfs.h"

#include "xe_gt_sysfs.h"

#include "xe_guc_pc.h"



/**

 * DOC: Xe GT Idle

 *

 * Provides sysfs entries for idle properties of GT

 *

 * device/gt#/gtidle/name - name of the state

 * device/gt#/gtidle/idle_residency_ms - Provides residency of the idle state in ms

 * device/gt#/gtidle/idle_status - Provides current idle state

 */



static struct xe_gt_idle *dev_to_gtidle(struct device *dev)

{

	struct kobject *kobj = &dev->kobj;



	return &kobj_to_gt(kobj->parent)->gtidle;

}



static struct xe_gt *gtidle_to_gt(struct xe_gt_idle *gtidle)

{

	return container_of(gtidle, struct xe_gt, gtidle);

}



static struct xe_guc_pc *gtidle_to_pc(struct xe_gt_idle *gtidle)

{

	return &gtidle_to_gt(gtidle)->uc.guc.pc;

}



static const char *gt_idle_state_to_string(enum xe_gt_idle_state state)

{

	switch (state) {

	case GT_IDLE_C0:

		return "gt-c0";

	case GT_IDLE_C6:

		return "gt-c6";

	default:

		return "unknown";

	}

}



static u64 get_residency_ms(struct xe_gt_idle *gtidle, u64 cur_residency)

{

	u64 delta, overflow_residency, prev_residency;



	overflow_residency = BIT_ULL(32);



	/*

	 * Counter wrap handling

	 * Store previous hw counter values for counter wrap-around handling

	 * Relying on sufficient frequency of queries otherwise counters can still wrap.

	 */

	prev_residency = gtidle->prev_residency;

	gtidle->prev_residency = cur_residency;



	/* delta */

	if (cur_residency >= prev_residency)

		delta = cur_residency - prev_residency;

	else

		delta = cur_residency + (overflow_residency - prev_residency);



	/* Add delta to extended raw driver copy of idle residency */

	cur_residency = gtidle->cur_residency + delta;

	gtidle->cur_residency = cur_residency;



	/* residency multiplier in ns, convert to ms */

	cur_residency = mul_u64_u32_div(cur_residency, gtidle->residency_multiplier, 1e6);



	return cur_residency;

}



static ssize_t name_show(struct device *dev,

			 struct device_attribute *attr, char *buff)

{

	struct xe_gt_idle *gtidle = dev_to_gtidle(dev);



	return sysfs_emit(buff, gtidle->name);

}

static DEVICE_ATTR_RO(name);



static ssize_t idle_status_show(struct device *dev,

				struct device_attribute *attr, char *buff)

{

	struct xe_gt_idle *gtidle = dev_to_gtidle(dev);

	struct xe_guc_pc *pc = gtidle_to_pc(gtidle);

	enum xe_gt_idle_state state;



	state = gtidle->idle_status(pc);



	return sysfs_emit(buff, "%s\n", gt_idle_state_to_string(state));

}

static DEVICE_ATTR_RO(idle_status);



static ssize_t idle_residency_ms_show(struct device *dev,

				      struct device_attribute *attr, char *buff)

{

	struct xe_gt_idle *gtidle = dev_to_gtidle(dev);

	struct xe_guc_pc *pc = gtidle_to_pc(gtidle);

	u64 residency;



	residency = gtidle->idle_residency(pc);

	return sysfs_emit(buff, "%llu\n", get_residency_ms(gtidle, residency));

}

static DEVICE_ATTR_RO(idle_residency_ms);



static const struct attribute *gt_idle_attrs[] = {

	&dev_attr_name.attr,

	&dev_attr_idle_status.attr,

	&dev_attr_idle_residency_ms.attr,

	NULL,

};



static void gt_idle_sysfs_fini(struct drm_device *drm, void *arg)

{

	struct kobject *kobj = arg;



	sysfs_remove_files(kobj, gt_idle_attrs);

	kobject_put(kobj);

}



void xe_gt_idle_sysfs_init(struct xe_gt_idle *gtidle)

{

	struct xe_gt *gt = gtidle_to_gt(gtidle);

	struct xe_device *xe = gt_to_xe(gt);

	struct kobject *kobj;

	int err;



	kobj = kobject_create_and_add("gtidle", gt->sysfs);

	if (!kobj) {

		drm_warn(&xe->drm, "%s failed, err: %d\n", __func__, -ENOMEM);

		return;

	}



	sprintf(gtidle->name, "gt%d-rc\n", gt->info.id);

	/* Multiplier for  RC6 Residency counter in units of 1.28us */

	gtidle->residency_multiplier = 1280;

	gtidle->idle_residency = xe_guc_pc_rc6_residency;

	gtidle->idle_status = xe_guc_pc_rc_status;



	err = sysfs_create_files(kobj, gt_idle_attrs);

	if (err) {

		kobject_put(kobj);

		drm_warn(&xe->drm, "failed to register gtidle sysfs, err: %d\n", err);

		return;

	}



	err = drmm_add_action_or_reset(&xe->drm, gt_idle_sysfs_fini, kobj);

	if (err)

		drm_warn(&xe->drm, "%s: drmm_add_action_or_reset failed, err: %d\n",

			 __func__, err);

}

drivers/gpu/drm/xe/xe_gt_idle_sysfs.h

0 → 100644
+13 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: MIT */

/*

 * Copyright © 2023 Intel Corporation

 */



#ifndef _XE_GT_IDLE_SYSFS_H_

#define _XE_GT_IDLE_SYSFS_H_



#include "xe_gt_idle_sysfs_types.h"



void xe_gt_idle_sysfs_init(struct xe_gt_idle *gtidle);



#endif /* _XE_GT_IDLE_SYSFS_H_ */

drivers/gpu/drm/xe/xe_gt_idle_sysfs_types.h

0 → 100644
+38 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: MIT */

/*

 * Copyright © 2023 Intel Corporation

 */



#ifndef _XE_GT_IDLE_SYSFS_TYPES_H_

#define _XE_GT_IDLE_SYSFS_TYPES_H_



#include <linux/types.h>



struct xe_guc_pc;



/* States of GT Idle */

enum xe_gt_idle_state {

	GT_IDLE_C0,

	GT_IDLE_C6,

	GT_IDLE_UNKNOWN,

};



/**

 * struct xe_gt_idle - A struct that contains idle properties based of gt

 */

struct xe_gt_idle {

	/** @name: name */

	char name[16];

	/** @residency_multiplier: residency multiplier in ns */

	u32 residency_multiplier;

	/** @cur_residency: raw driver copy of idle residency */

	u64 cur_residency;

	/** @prev_residency: previous residency counter */

	u64 prev_residency;

	/** @idle_status: get the current idle state */

	enum xe_gt_idle_state (*idle_status)(struct xe_guc_pc *pc);

	/** @idle_residency: get idle residency counter */

	u64 (*idle_residency)(struct xe_guc_pc *pc);

};



#endif /* _XE_GT_IDLE_SYSFS_TYPES_H_ */