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

Commit 4444316c authored by Satyajit Desai's avatar Satyajit Desai Committed by Gerrit - the friendly Code Review server
Browse files

coresight: byte-cntr: Add snapshot of Byte cntr driver 



This is a snapshot of the coresight-cti driver as of msm-4.14
commit '7d42028b99d32ad6ec82aa429378fba0280a1c4a'.(byte-cntr: Read 64bit
rwp TMC RWP has two 32bit registers which combine to one 64bit register.
Read correct RWP register in byte counter driver).Add support for a
streaming interface for TMC ETR to allow for continuous log collection to
secondary storage. An interrupt based mechanism is used to stream out the
data from the device. The streaming interface cannot be used in
conjunction with the traditional ETR read operation.

Change-Id: I9a78107273f295ecb219f89ec728aa7b9eea27e0
Signed-off-by: default avatarSatyajit Desai <sadesai@codeaurora.org>
Signed-off-by: default avatarRama Aparna Mallavarapu <aparnam@codeaurora.org>
Signed-off-by: default avatarMulu He <muluhe@codeaurora.org>
parent c67cc907

drivers/hwtracing/coresight/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -6,7 +6,8 @@ obj-$(CONFIG_CORESIGHT) += coresight.o coresight-etm-perf.o 
obj-$(CONFIG_OF) += of_coresight.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
+296 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2017, 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_flat_buf *flat_buf = tmcdrvdata->etr_buf->private;



	if (*bufp >= (char *)(flat_buf->vaddr + tmcdrvdata->size))

		*bufp = flat_buf->vaddr;



	if (*len >= bytes)

		*len = bytes;

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

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



	if ((*bufp + *len) > (char *)(flat_buf->vaddr +

		tmcdrvdata->size))

		*len = (char *)(flat_buf->vaddr + tmcdrvdata->size) -

			*bufp;

	if (*len == bytes || (*len + (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;



	bufp = (char *)(tmcdrvdata->buf + *ppos);



	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->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 */

/*

 * Copyright (c) 2017, 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