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

Commit 98d83a7e authored by Tingwei Zhang's avatar Tingwei Zhang
Browse files

coresight: Add snapshot of Coresight byte counter driver 



Add snapshot for coresight byte counter driver from msm-4.19
commit d42a5b113e84 ("coresight: tmc: migrate byte counter to
new tmc framework").
Make necessary change to adopt coresight framework change.

Change-Id: I85a2f894a0ace3118624b5280b9bbd192ebcfff9
Signed-off-by: default avatarTingwei Zhang <tingwei@codeaurora.org>
parent df6898f6

drivers/hwtracing/coresight/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -5,7 +5,8 @@ 
obj-$(CONFIG_CORESIGHT) += coresight.o coresight-etm-perf.o coresight-platform.o

obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o \

					     coresight-tmc-etf.o \

					     coresight-tmc-etr.o

					     coresight-tmc-etr.o \

					     coresight-byte-cntr.o

obj-$(CONFIG_CORESIGHT_SINK_TPIU) += coresight-tpiu.o

obj-$(CONFIG_CORESIGHT_SINK_ETBV10) += coresight-etb10.o

obj-$(CONFIG_CORESIGHT_LINKS_AND_SINKS) += coresight-funnel.o \

drivers/hwtracing/coresight/coresight-byte-cntr.c

0 → 100644
+291 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.

 *

 * Description: CoreSight Trace Memory Controller driver

 */

#include <linux/interrupt.h>

#include <linux/dma-mapping.h>

#include <linux/fs.h>

#include <linux/of_irq.h>

#include <linux/moduleparam.h>

#include <linux/delay.h>

#include <linux/uaccess.h>



#include "coresight-byte-cntr.h"

#include "coresight-priv.h"

#include "coresight-tmc.h"



static struct tmc_drvdata *tmcdrvdata;



static void tmc_etr_read_bytes(struct byte_cntr *byte_cntr_data, loff_t *ppos,

			       size_t bytes, size_t *len, char **bufp)

{

	struct etr_buf *etr_buf = tmcdrvdata->etr_buf;

	size_t actual;



	if (*len >= bytes)

		*len = bytes;

	else if (((uint32_t)*ppos % bytes) + *len > bytes)

		*len = bytes - ((uint32_t)*ppos % bytes);



	actual = tmc_etr_buf_get_data(etr_buf, *ppos, *len, bufp);

	*len = actual;

	if (actual == bytes || (actual + (uint32_t)*ppos) % bytes == 0)

		atomic_dec(&byte_cntr_data->irq_cnt);

}





static irqreturn_t etr_handler(int irq, void *data)

{

	struct byte_cntr *byte_cntr_data = data;



	atomic_inc(&byte_cntr_data->irq_cnt);



	wake_up(&byte_cntr_data->wq);



	return IRQ_HANDLED;

}



static void tmc_etr_flush_bytes(loff_t *ppos, size_t bytes, size_t *len)

{

	uint32_t rwp = 0;

	dma_addr_t paddr = tmcdrvdata->etr_buf->hwaddr;



	rwp = readl_relaxed(tmcdrvdata->base + TMC_RWP);



	if (rwp >= (paddr + *ppos)) {

		if (bytes > (rwp - paddr - *ppos))

			*len = rwp - paddr - *ppos;

	}

}



static ssize_t tmc_etr_byte_cntr_read(struct file *fp, char __user *data,

			       size_t len, loff_t *ppos)

{

	struct byte_cntr *byte_cntr_data = fp->private_data;

	char *bufp;



	if (!data)

		return -EINVAL;



	mutex_lock(&byte_cntr_data->byte_cntr_lock);

	if (!byte_cntr_data->read_active)

		goto err0;



	if (byte_cntr_data->enable) {

		if (!atomic_read(&byte_cntr_data->irq_cnt)) {

			mutex_unlock(&byte_cntr_data->byte_cntr_lock);

			if (wait_event_interruptible(byte_cntr_data->wq,

				atomic_read(&byte_cntr_data->irq_cnt) > 0))

				return -ERESTARTSYS;

			mutex_lock(&byte_cntr_data->byte_cntr_lock);

			if (!byte_cntr_data->read_active)

				goto err0;

		}



		tmc_etr_read_bytes(byte_cntr_data, ppos,

				   byte_cntr_data->block_size, &len, &bufp);



	} else {

		if (!atomic_read(&byte_cntr_data->irq_cnt)) {

			tmc_etr_flush_bytes(ppos, byte_cntr_data->block_size,

						  &len);

			if (!len)

				goto err0;

		} else {

			tmc_etr_read_bytes(byte_cntr_data, ppos,

						   byte_cntr_data->block_size,

						   &len, &bufp);

		}

	}



	if (copy_to_user(data, bufp, len)) {

		mutex_unlock(&byte_cntr_data->byte_cntr_lock);

		dev_dbg(&tmcdrvdata->csdev->dev,

			"%s: copy_to_user failed\n", __func__);

		return -EFAULT;

	}



	if (*ppos + len >= tmcdrvdata->size)

		*ppos = 0;

	else

		*ppos += len;

err0:

	mutex_unlock(&byte_cntr_data->byte_cntr_lock);



	return len;

}



void tmc_etr_byte_cntr_start(struct byte_cntr *byte_cntr_data)

{

	if (!byte_cntr_data)

		return;



	mutex_lock(&byte_cntr_data->byte_cntr_lock);



	if (byte_cntr_data->block_size == 0) {

		mutex_unlock(&byte_cntr_data->byte_cntr_lock);

		return;

	}



	atomic_set(&byte_cntr_data->irq_cnt, 0);

	byte_cntr_data->enable = true;

	mutex_unlock(&byte_cntr_data->byte_cntr_lock);

}

EXPORT_SYMBOL(tmc_etr_byte_cntr_start);



void tmc_etr_byte_cntr_stop(struct byte_cntr *byte_cntr_data)

{

	if (!byte_cntr_data)

		return;



	mutex_lock(&byte_cntr_data->byte_cntr_lock);

	byte_cntr_data->enable = false;

	coresight_csr_set_byte_cntr(byte_cntr_data->csr, 0);

	mutex_unlock(&byte_cntr_data->byte_cntr_lock);



}

EXPORT_SYMBOL(tmc_etr_byte_cntr_stop);





static int tmc_etr_byte_cntr_release(struct inode *in, struct file *fp)

{

	struct byte_cntr *byte_cntr_data = fp->private_data;



	mutex_lock(&byte_cntr_data->byte_cntr_lock);

	byte_cntr_data->read_active = false;



	coresight_csr_set_byte_cntr(byte_cntr_data->csr, 0);

	mutex_unlock(&byte_cntr_data->byte_cntr_lock);



	return 0;

}



static int tmc_etr_byte_cntr_open(struct inode *in, struct file *fp)

{

	struct byte_cntr *byte_cntr_data =

			container_of(in->i_cdev, struct byte_cntr, dev);



	mutex_lock(&byte_cntr_data->byte_cntr_lock);



	if (!tmcdrvdata->enable || !byte_cntr_data->block_size) {

		mutex_unlock(&byte_cntr_data->byte_cntr_lock);

		return -EINVAL;

	}



	/* IRQ is a '8- byte' counter and to observe interrupt at

	 * 'block_size' bytes of data

	 */

	coresight_csr_set_byte_cntr(byte_cntr_data->csr,

				(byte_cntr_data->block_size) / 8);



	fp->private_data = byte_cntr_data;

	nonseekable_open(in, fp);

	byte_cntr_data->enable = true;

	byte_cntr_data->read_active = true;

	mutex_unlock(&byte_cntr_data->byte_cntr_lock);



	return 0;

}



static const struct file_operations byte_cntr_fops = {

	.owner		= THIS_MODULE,

	.open		= tmc_etr_byte_cntr_open,

	.read		= tmc_etr_byte_cntr_read,

	.release	= tmc_etr_byte_cntr_release,

	.llseek		= no_llseek,

};



static int byte_cntr_register_chardev(struct byte_cntr *byte_cntr_data)

{

	int ret;

	unsigned int baseminor = 0;

	unsigned int count = 1;

	struct device *device;

	dev_t dev;



	ret = alloc_chrdev_region(&dev, baseminor, count, "byte-cntr");

	if (ret < 0) {

		pr_err("alloc_chrdev_region failed %d\n", ret);

		return ret;

	}

	cdev_init(&byte_cntr_data->dev, &byte_cntr_fops);



	byte_cntr_data->dev.owner = THIS_MODULE;

	byte_cntr_data->dev.ops = &byte_cntr_fops;



	ret = cdev_add(&byte_cntr_data->dev, dev, 1);

	if (ret)

		goto exit_unreg_chrdev_region;



	byte_cntr_data->driver_class = class_create(THIS_MODULE,

						   "coresight-tmc-etr-stream");

	if (IS_ERR(byte_cntr_data->driver_class)) {

		ret = -ENOMEM;

		pr_err("class_create failed %d\n", ret);

		goto exit_unreg_chrdev_region;

	}



	device = device_create(byte_cntr_data->driver_class, NULL,

			       byte_cntr_data->dev.dev, byte_cntr_data,

			       "byte-cntr");



	if (IS_ERR(device)) {

		pr_err("class_device_create failed %d\n", ret);

		ret = -ENOMEM;

		goto exit_destroy_class;

	}



	return 0;



exit_destroy_class:

	class_destroy(byte_cntr_data->driver_class);

exit_unreg_chrdev_region:

	unregister_chrdev_region(byte_cntr_data->dev.dev, 1);

	return ret;

}



struct byte_cntr *byte_cntr_init(struct amba_device *adev,

				 struct tmc_drvdata *drvdata)

{

	struct device *dev = &adev->dev;

	struct device_node *np = adev->dev.of_node;

	int byte_cntr_irq;

	int ret;

	struct byte_cntr *byte_cntr_data;



	byte_cntr_irq = of_irq_get_byname(np, "byte-cntr-irq");

	if (byte_cntr_irq < 0)

		return NULL;



	byte_cntr_data = devm_kzalloc(dev, sizeof(*byte_cntr_data), GFP_KERNEL);

	if (!byte_cntr_data)

		return NULL;



	ret = devm_request_irq(dev, byte_cntr_irq, etr_handler,

			       IRQF_TRIGGER_RISING | IRQF_SHARED,

			       "tmc-etr", byte_cntr_data);

	if (ret) {

		devm_kfree(dev, byte_cntr_data);

		dev_err(dev, "Byte_cntr interrupt registration failed\n");

		return NULL;

	}



	ret = byte_cntr_register_chardev(byte_cntr_data);

	if (ret) {

		devm_free_irq(dev, byte_cntr_irq, byte_cntr_data);

		devm_kfree(dev, byte_cntr_data);

		dev_err(dev, "Byte_cntr char dev registration failed\n");

		return NULL;

	}



	tmcdrvdata = drvdata;

	byte_cntr_data->byte_cntr_irq = byte_cntr_irq;

	byte_cntr_data->csr = drvdata->csr;

	atomic_set(&byte_cntr_data->irq_cnt, 0);

	init_waitqueue_head(&byte_cntr_data->wq);

	mutex_init(&byte_cntr_data->byte_cntr_lock);



	return byte_cntr_data;

}

EXPORT_SYMBOL(byte_cntr_init);

drivers/hwtracing/coresight/coresight-byte-cntr.h

0 → 100644
+29 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2017, 2019 The Linux Foundation. All rights reserved.

 */

#ifndef _CORESIGHT_BYTE_CNTR_H

#define _CORESIGHT_BYTE_CNTR_H

#include <linux/cdev.h>

#include <linux/amba/bus.h>

#include <linux/wait.h>

#include <linux/mutex.h>



struct byte_cntr {

	struct cdev		dev;

	struct class		*driver_class;

	bool			enable;

	bool			read_active;

	uint32_t		byte_cntr_value;

	uint32_t		block_size;

	int			byte_cntr_irq;

	atomic_t		irq_cnt;

	wait_queue_head_t	wq;

	struct mutex		byte_cntr_lock;

	struct coresight_csr		*csr;

};



extern void tmc_etr_byte_cntr_start(struct byte_cntr *byte_cntr_data);

extern void tmc_etr_byte_cntr_stop(struct byte_cntr *byte_cntr_data);



#endif