Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3ce2d416 authored by Pratik Patel's avatar Pratik Patel Committed by Shashank Mittal
Browse files

coresight-etm4x: Controls pertaining to the VM ID functions 



Adding sysfs entries to access and configure specifics about the
virtual machine ID comparator functions.

Change-Id: Ic09857eb42dc9e2346607ef57638e7696fe5fd6b
Signed-off-by: default avatarPratik Patel <pratikp@codeaurora.org>
Signed-off-by: default avatarMathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Git-commit: 40d8ebf0715f86b0231927a80bbc068869cc5ef1
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git


Signed-off-by: default avatarShashank Mittal <mittals@codeaurora.org>
parent 5c29d6a5

Documentation/ABI/testing/sysfs-bus-coresight-devices-etm4x

+20 −0
Original line number Diff line number Diff line
@@ -261,3 +261,23 @@ KernelVersion: 4.01 
Contact:	Mathieu Poirier <mathieu.poirier@linaro.org>

Description:	(RW) Mask for all 8 context ID comparator value

		registers (if implemented).



What:		/sys/bus/coresight/devices/<memory_map>.etm/vmid_idx

Date:		April 2015

KernelVersion:	4.01

Contact:	Mathieu Poirier <mathieu.poirier@linaro.org>

Description:	(RW) Select which virtual machine ID comparator to work with.



What:		/sys/bus/coresight/devices/<memory_map>.etm/vmid_val

Date:		April 2015

KernelVersion:	4.01

Contact:	Mathieu Poirier <mathieu.poirier@linaro.org>

Description:	(RW) Get/Set the virtual machine ID comparator value to

		trigger on.



What:		/sys/bus/coresight/devices/<memory_map>.etm/vmid_masks

Date:		April 2015

KernelVersion:	4.01

Contact:	Mathieu Poirier <mathieu.poirier@linaro.org>

Description:	(RW) Mask for all 8 virtual machine ID comparator value

		registers (if implemented).

drivers/hwtracing/coresight/coresight-etm4x.c

+178 −0
Original line number Diff line number Diff line
@@ -1964,6 +1964,181 @@ static ssize_t ctxid_masks_store(struct device *dev, 
}

static DEVICE_ATTR_RW(ctxid_masks);



static ssize_t vmid_idx_show(struct device *dev,

			     struct device_attribute *attr,

			     char *buf)

{

	unsigned long val;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);



	val = drvdata->vmid_idx;

	return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);

}



static ssize_t vmid_idx_store(struct device *dev,

			      struct device_attribute *attr,

			      const char *buf, size_t size)

{

	unsigned long val;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);



	if (kstrtoul(buf, 16, &val))

		return -EINVAL;

	if (val >= drvdata->numvmidc)

		return -EINVAL;



	/*

	 * Use spinlock to ensure index doesn't change while it gets

	 * dereferenced multiple times within a spinlock block elsewhere.

	 */

	spin_lock(&drvdata->spinlock);

	drvdata->vmid_idx = val;

	spin_unlock(&drvdata->spinlock);

	return size;

}

static DEVICE_ATTR_RW(vmid_idx);



static ssize_t vmid_val_show(struct device *dev,

			     struct device_attribute *attr,

			     char *buf)

{

	unsigned long val;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);



	val = (unsigned long)drvdata->vmid_val[drvdata->vmid_idx];

	return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);

}



static ssize_t vmid_val_store(struct device *dev,

			      struct device_attribute *attr,

			      const char *buf, size_t size)

{

	unsigned long val;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);



	/*

	 * only implemented when vmid tracing is enabled, i.e. at least one

	 * vmid comparator is implemented and at least 8 bit vmid size

	 */

	if (!drvdata->vmid_size || !drvdata->numvmidc)

		return -EINVAL;

	if (kstrtoul(buf, 16, &val))

		return -EINVAL;



	spin_lock(&drvdata->spinlock);

	drvdata->vmid_val[drvdata->vmid_idx] = (u64)val;

	spin_unlock(&drvdata->spinlock);

	return size;

}

static DEVICE_ATTR_RW(vmid_val);



static ssize_t vmid_masks_show(struct device *dev,

			       struct device_attribute *attr, char *buf)

{

	unsigned long val1, val2;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);



	spin_lock(&drvdata->spinlock);

	val1 = drvdata->vmid_mask0;

	val2 = drvdata->vmid_mask1;

	spin_unlock(&drvdata->spinlock);

	return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);

}



static ssize_t vmid_masks_store(struct device *dev,

				struct device_attribute *attr,

				const char *buf, size_t size)

{

	u8 i, j, maskbyte;

	unsigned long val1, val2, mask;

	struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);

	/*

	 * only implemented when vmid tracing is enabled, i.e. at least one

	 * vmid comparator is implemented and at least 8 bit vmid size

	 */

	if (!drvdata->vmid_size || !drvdata->numvmidc)

		return -EINVAL;

	if (sscanf(buf, "%lx %lx", &val1, &val2) != 2)

		return -EINVAL;



	spin_lock(&drvdata->spinlock);



	/*

	 * each byte[0..3] controls mask value applied to vmid

	 * comparator[0..3]

	 */

	switch (drvdata->numvmidc) {

	case 0x1:

		/* COMP0, bits[7:0] */

		drvdata->vmid_mask0 = val1 & 0xFF;

		break;

	case 0x2:

		/* COMP1, bits[15:8] */

		drvdata->vmid_mask0 = val1 & 0xFFFF;

		break;

	case 0x3:

		/* COMP2, bits[23:16] */

		drvdata->vmid_mask0 = val1 & 0xFFFFFF;

		break;

	case 0x4:

		/* COMP3, bits[31:24] */

		drvdata->vmid_mask0 = val1;

		break;

	case 0x5:

		/* COMP4, bits[7:0] */

		drvdata->vmid_mask0 = val1;

		drvdata->vmid_mask1 = val2 & 0xFF;

		break;

	case 0x6:

		/* COMP5, bits[15:8] */

		drvdata->vmid_mask0 = val1;

		drvdata->vmid_mask1 = val2 & 0xFFFF;

		break;

	case 0x7:

		/* COMP6, bits[23:16] */

		drvdata->vmid_mask0 = val1;

		drvdata->vmid_mask1 = val2 & 0xFFFFFF;

		break;

	case 0x8:

		/* COMP7, bits[31:24] */

		drvdata->vmid_mask0 = val1;

		drvdata->vmid_mask1 = val2;

		break;

	default:

		break;

	}



	/*

	 * If software sets a mask bit to 1, it must program relevant byte

	 * of vmid comparator value 0x0, otherwise behavior is unpredictable.

	 * For example, if bit[3] of vmid_mask0 is 1, we must clear bits[31:24]

	 * of vmid comparator0 value (corresponding to byte 0) register.

	 */

	mask = drvdata->vmid_mask0;

	for (i = 0; i < drvdata->numvmidc; i++) {

		/* mask value of corresponding vmid comparator */

		maskbyte = mask & ETMv4_EVENT_MASK;

		/*

		 * each bit corresponds to a byte of respective vmid comparator

		 * value register

		 */

		for (j = 0; j < 8; j++) {

			if (maskbyte & 1)

				drvdata->vmid_val[i] &= ~(0xFF << (j * 8));

			maskbyte >>= 1;

		}

		/* Select the next vmid comparator mask value */

		if (i == 3)

			/* vmid comparators[4-7] */

			mask = drvdata->vmid_mask1;

		else

			mask >>= 0x8;

	}

	spin_unlock(&drvdata->spinlock);

	return size;

}

static DEVICE_ATTR_RW(vmid_masks);



static ssize_t cpu_show(struct device *dev,

			struct device_attribute *attr, char *buf)

{
@@ -2019,6 +2194,9 @@ static struct attribute *coresight_etmv4_attrs[] = { 
	&dev_attr_ctxid_idx.attr,

	&dev_attr_ctxid_val.attr,

	&dev_attr_ctxid_masks.attr,

	&dev_attr_vmid_idx.attr,

	&dev_attr_vmid_val.attr,

	&dev_attr_vmid_masks.attr,

	&dev_attr_cpu.attr,

	NULL,

};