Merge "coresight: tmc: add scatter-gather support for tmc etr" into msm-4.14 (52f6e1ff) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/hwtracing/coresight/coresight-tmc-etr.c

+456 −28

Original line number	Diff line number	Diff line
		@@ -21,12 +21,408 @@
		#include "coresight-priv.h"
		#include "coresight-tmc.h"

		static void tmc_etr_sg_tbl_free(uint32_t *vaddr, uint32_t size, uint32_t ents)
		{
		uint32_t i = 0, pte_n = 0, last_pte;
		uint32_t virt_st_tbl, virt_pte;
		void *virt_blk;
		phys_addr_t phys_pte;
		int total_ents = DIV_ROUND_UP(size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		virt_st_tbl = vaddr;

		while (i < total_ents) {
		last_pte = ((i + ents_per_blk) > total_ents) ?
		total_ents : (i + ents_per_blk);
		while (i < last_pte) {
		virt_pte = virt_st_tbl + pte_n;

		/* Do not go beyond number of entries allocated */
		if (i == ents) {
		free_page((unsigned long)virt_st_tbl);
		return;
		}

		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);
		virt_blk = phys_to_virt(phys_pte);

		if ((last_pte - i) > 1) {
		free_page((unsigned long)virt_blk);
		pte_n++;
		} else if (last_pte == total_ents) {
		free_page((unsigned long)virt_blk);
		free_page((unsigned long)virt_st_tbl);
		} else {
		free_page((unsigned long)virt_st_tbl);
		virt_st_tbl = (uint32_t *)virt_blk;
		pte_n = 0;
		break;
		}
		i++;
		}
		}
		}

		static void tmc_etr_sg_tbl_flush(uint32_t *vaddr, uint32_t size)
		{
		uint32_t i = 0, pte_n = 0, last_pte;
		uint32_t virt_st_tbl, virt_pte;
		void *virt_blk;
		phys_addr_t phys_pte;
		int total_ents = DIV_ROUND_UP(size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		virt_st_tbl = vaddr;
		dmac_flush_range((void )virt_st_tbl, (void )virt_st_tbl + PAGE_SIZE);

		while (i < total_ents) {
		last_pte = ((i + ents_per_blk) > total_ents) ?
		total_ents : (i + ents_per_blk);
		while (i < last_pte) {
		virt_pte = virt_st_tbl + pte_n;
		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);
		virt_blk = phys_to_virt(phys_pte);

		dmac_flush_range(virt_blk, virt_blk + PAGE_SIZE);

		if ((last_pte - i) > 1) {
		pte_n++;
		} else if (last_pte != total_ents) {
		virt_st_tbl = (uint32_t *)virt_blk;
		pte_n = 0;
		break;
		}
		i++;
		}
		}
		}

		/*
		* Scatter gather table layout in memory:
		* 1. Table contains 32-bit entries
		* 2. Each entry in the table points to 4K block of memory
		* 3. Last entry in the table points to next table
		* 4. (*) Based on mem_size requested, if there is no need for next level of
		* table, last entry in the table points directly to 4K block of memory.
		*
		* sg_tbl_num=0
		* \|---------------\|<-- drvdata->vaddr
		* \| blk_num=0 \|
		* \|---------------\|
		* \| blk_num=1 \|
		* \|---------------\|
		* \| blk_num=2 \|
		* \|---------------\| sg_tbl_num=1
		* \|(*)Nxt Tbl Addr\|------>\|---------------\|
		* \|---------------\| \| blk_num=3 \|
		* \|---------------\|
		* \| blk_num=4 \|
		* \|---------------\|
		* \| blk_num=5 \|
		* \|---------------\| sg_tbl_num=2
		* \|(*)Nxt Tbl Addr\|------>\|---------------\|
		* \|---------------\| \| blk_num=6 \|
		* \|---------------\|
		* \| blk_num=7 \|
		* \|---------------\|
		* \| blk_num=8 \|
		* \|---------------\|
		* \| \|End of
		* \|---------------\|-----
		* Table
		* For simplicity above diagram assumes following:
		* a. mem_size = 36KB --> total_ents = 9
		* b. ents_per_blk = 4
		*/

		static int tmc_etr_sg_tbl_alloc(struct tmc_drvdata *drvdata)
		{
		int ret;
		uint32_t i = 0, last_pte;
		uint32_t virt_pgdir, virt_st_tbl;
		void *virt_pte;
		int total_ents = DIV_ROUND_UP(drvdata->size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		virt_pgdir = (uint32_t *)get_zeroed_page(GFP_KERNEL);
		if (!virt_pgdir)
		return -ENOMEM;

		virt_st_tbl = virt_pgdir;

		while (i < total_ents) {
		last_pte = ((i + ents_per_blk) > total_ents) ?
		total_ents : (i + ents_per_blk);
		while (i < last_pte) {
		virt_pte = (void *)get_zeroed_page(GFP_KERNEL);
		if (!virt_pte) {
		ret = -ENOMEM;
		goto err;
		}

		if ((last_pte - i) > 1) {
		*virt_st_tbl =
		TMC_ETR_SG_ENT(virt_to_phys(virt_pte));
		virt_st_tbl++;
		} else if (last_pte == total_ents) {
		*virt_st_tbl =
		TMC_ETR_SG_LST_ENT(virt_to_phys(virt_pte));
		} else {
		*virt_st_tbl =
		TMC_ETR_SG_NXT_TBL(virt_to_phys(virt_pte));
		virt_st_tbl = (uint32_t *)virt_pte;
		break;
		}
		i++;
		}
		}

		drvdata->vaddr = virt_pgdir;
		drvdata->paddr = virt_to_phys(virt_pgdir);

		/* Flush the dcache before proceeding */
		tmc_etr_sg_tbl_flush((uint32_t *)drvdata->vaddr, drvdata->size);

		dev_dbg(drvdata->dev, "%s: table starts at %#lx, total entries %d\n",
		__func__, (unsigned long)drvdata->paddr, total_ents);

		return 0;
		err:
		tmc_etr_sg_tbl_free(virt_pgdir, drvdata->size, i);
		return ret;
		}

		/*
		* TMC read logic when scatter gather feature is enabled:
		*
		* sg_tbl_num=0
		* \|---------------\|<-- drvdata->vaddr
		* \| blk_num=0 \|
		* \| blk_num_rel=5 \|
		* \|---------------\|
		* \| blk_num=1 \|
		* \| blk_num_rel=6 \|
		* \|---------------\|
		* \| blk_num=2 \|
		* \| blk_num_rel=7 \|
		* \|---------------\| sg_tbl_num=1
		* \| Next Table \|------>\|---------------\|
		* \| Addr \| \| blk_num=3 \|
		* \|---------------\| \| blk_num_rel=8 \|
		* \|---------------\|
		* 4k Block Addr \| blk_num=4 \|
		* \|--------------\| blk_num_rel=0 \|
		* \| \|---------------\|
		* \| \| blk_num=5 \|
		* \| \| blk_num_rel=1 \|
		* \| \|---------------\| sg_tbl_num=2
		* \|---------------\| \| Next Table \|------>\|---------------\|
		* \| \| \| Addr \| \| blk_num=6 \|
		* \| \| \|---------------\| \| blk_num_rel=2 \|
		* \| read_off \| \|---------------\|
		* \| \| \| blk_num=7 \|
		* \| \| ppos \| blk_num_rel=3 \|
		* \|---------------\|----- \|---------------\|
		* \| \| \| blk_num=8 \|
		* \| delta_up \| \| blk_num_rel=4 \|
		* \| \| RWP/drvdata->buf \|---------------\|
		* \|---------------\|----------------- \| \|
		* \| \| \| \| \|End of
		* \| \| \| \|---------------\|-----
		* \| \| drvdata->delta_bottom Table
		* \| \| \|
		* \|_______________\| _\|_
		* 4K Block
		*
		* For simplicity above diagram assumes following:
		* a. mem_size = 36KB --> total_ents = 9
		* b. ents_per_blk = 4
		* c. RWP is on 5th block (blk_num = 5); so we have to start reading from RWP
		* position
		*/

		void tmc_etr_sg_compute_read(struct tmc_drvdata drvdata, loff_t ppos,
		char *bufpp, size_t len)
		{
		uint32_t i = 0, blk_num_rel = 0, read_len = 0;
		uint32_t blk_num, sg_tbl_num, blk_num_loc, read_off;
		uint32_t virt_pte, virt_st_tbl;
		void *virt_blk;
		phys_addr_t phys_pte = 0;
		int total_ents = DIV_ROUND_UP(drvdata->size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		/*
		* Find relative block number from ppos and reading offset
		* within block and find actual block number based on relative
		* block number
		*/
		if (drvdata->buf == drvdata->vaddr) {
		blk_num = *ppos / PAGE_SIZE;
		read_off = *ppos % PAGE_SIZE;
		} else {
		if (*ppos < drvdata->delta_bottom) {
		read_off = PAGE_SIZE - drvdata->delta_bottom;
		} else {
		blk_num_rel = (*ppos / PAGE_SIZE) + 1;
		read_off = (*ppos - drvdata->delta_bottom) % PAGE_SIZE;
		}

		blk_num = (drvdata->sg_blk_num + blk_num_rel) % total_ents;
		}

		virt_st_tbl = (uint32_t *)drvdata->vaddr;

		/* Compute table index and block entry index within that table */
		if (blk_num && (blk_num == (total_ents - 1)) &&
		!(blk_num % (ents_per_blk - 1))) {
		sg_tbl_num = blk_num / ents_per_blk;
		blk_num_loc = ents_per_blk - 1;
		} else {
		sg_tbl_num = blk_num / (ents_per_blk - 1);
		blk_num_loc = blk_num % (ents_per_blk - 1);
		}

		for (i = 0; i < sg_tbl_num; i++) {
		virt_pte = virt_st_tbl + (ents_per_blk - 1);
		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);
		virt_st_tbl = (uint32_t *)phys_to_virt(phys_pte);
		}

		virt_pte = virt_st_tbl + blk_num_loc;
		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);
		virt_blk = phys_to_virt(phys_pte);

		*bufpp = virt_blk + read_off;

		if (*len > (PAGE_SIZE - read_off))
		*len = PAGE_SIZE - read_off;

		/*
		* When buffer is wrapped around and trying to read last relative
		* block (i.e. delta_up), compute len differently
		*/
		if (blk_num_rel && (blk_num == drvdata->sg_blk_num)) {
		read_len = PAGE_SIZE - drvdata->delta_bottom - read_off;
		if (*len > read_len)
		*len = read_len;
		}

		dev_dbg_ratelimited(drvdata->dev,
		"%s: read at %p, phys %pa len %zu blk %d, rel blk %d RWP blk %d\n",
		__func__, bufpp, &phys_pte, len, blk_num, blk_num_rel,
		drvdata->sg_blk_num);
		}

		static void tmc_etr_sg_mem_reset(uint32_t *vaddr, uint32_t size)
		{
		uint32_t i = 0, pte_n = 0, last_pte;
		uint32_t virt_st_tbl, virt_pte;
		void *virt_blk;
		phys_addr_t phys_pte;
		int total_ents = DIV_ROUND_UP(size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		virt_st_tbl = vaddr;

		while (i < total_ents) {
		last_pte = ((i + ents_per_blk) > total_ents) ?
		total_ents : (i + ents_per_blk);
		while (i < last_pte) {
		virt_pte = virt_st_tbl + pte_n;
		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);
		virt_blk = phys_to_virt(phys_pte);

		if ((last_pte - i) > 1) {
		memset(virt_blk, 0, PAGE_SIZE);
		pte_n++;
		} else if (last_pte == total_ents) {
		memset(virt_blk, 0, PAGE_SIZE);
		} else {
		virt_st_tbl = (uint32_t *)virt_blk;
		pte_n = 0;
		break;
		}
		i++;
		}
		}

		/* Flush the dcache before proceeding */
		tmc_etr_sg_tbl_flush(vaddr, size);
		}

		void tmc_etr_sg_rwp_pos(struct tmc_drvdata *drvdata, uint32_t rwp)
		{
		uint32_t i = 0, pte_n = 0, last_pte;
		uint32_t virt_st_tbl, virt_pte;
		void *virt_blk;
		bool found = false;
		phys_addr_t phys_pte;
		int total_ents = DIV_ROUND_UP(drvdata->size, PAGE_SIZE);
		int ents_per_blk = PAGE_SIZE/sizeof(uint32_t);

		virt_st_tbl = drvdata->vaddr;

		while (i < total_ents) {
		last_pte = ((i + ents_per_blk) > total_ents) ?
		total_ents : (i + ents_per_blk);
		while (i < last_pte) {
		virt_pte = virt_st_tbl + pte_n;
		phys_pte = TMC_ETR_SG_ENT_TO_BLK(*virt_pte);

		/*
		* When the trace buffer is full; RWP could be on any
		* 4K block from scatter gather table. Compute below -
		* 1. Block number where RWP is currently residing
		* 2. RWP position in that 4K block
		* 3. Delta offset from current RWP position to end of
		* block.
		*/
		if (phys_pte <= rwp && rwp < (phys_pte + PAGE_SIZE)) {
		virt_blk = phys_to_virt(phys_pte);
		drvdata->sg_blk_num = i;
		drvdata->buf = virt_blk + rwp - phys_pte;
		drvdata->delta_bottom =
		phys_pte + PAGE_SIZE - rwp;
		found = true;
		break;
		}

		if ((last_pte - i) > 1) {
		pte_n++;
		} else if (i < (total_ents - 1)) {
		virt_blk = phys_to_virt(phys_pte);
		virt_st_tbl = (uint32_t *)virt_blk;
		pte_n = 0;
		break;
		}

		i++;
		}
		if (found)
		break;
		}
		}
		EXPORT_SYMBOL(tmc_etr_sg_rwp_pos);

		static void tmc_etr_mem_reset(struct tmc_drvdata *drvdata)
		{
		if (drvdata->vaddr) {
		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG)
		memset(drvdata->vaddr, 0, drvdata->size);
		else
		tmc_etr_sg_mem_reset((uint32_t *)drvdata->vaddr,
		drvdata->size);
		}
		}

		void tmc_etr_enable_hw(struct tmc_drvdata *drvdata)
		{
		u32 axictl, sts;

		/* Zero out the memory to help with debug */
		memset(drvdata->vaddr, 0, drvdata->size);
		tmc_etr_mem_reset(drvdata);

		CS_UNLOCK(drvdata->base);

		@@ -37,6 +433,11 @@ void tmc_etr_enable_hw(struct tmc_drvdata *drvdata)
		writel_relaxed(TMC_MODE_CIRCULAR_BUFFER, drvdata->base + TMC_MODE);

		axictl = readl_relaxed(drvdata->base + TMC_AXICTL);
		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG)
		axictl &= ~TMC_AXICTL_SCT_GAT_MODE;
		else
		axictl \|= TMC_AXICTL_SCT_GAT_MODE;
		writel_relaxed(axictl, drvdata->base + TMC_AXICTL);
		axictl &= ~TMC_AXICTL_CLEAR_MASK;
		axictl \|= (TMC_AXICTL_PROT_CTL_B1 \| TMC_AXICTL_WR_BURST_16);
		axictl \|= TMC_AXICTL_AXCACHE_OS;
		@@ -87,6 +488,7 @@ static void tmc_etr_dump_hw(struct tmc_drvdata *drvdata)
		rwp = tmc_read_rwp(drvdata);
		val = readl_relaxed(drvdata->base + TMC_STS);

		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG) {
		/*
		* Adjust the buffer to point to the beginning of the trace data
		* and update the available trace data.
		@@ -108,6 +510,20 @@ static void tmc_etr_dump_hw(struct tmc_drvdata *drvdata)
		drvdata->buf = drvdata->vaddr;
		drvdata->len = rwp - drvdata->paddr;
		}
		} else {
		/*
		* Reset these variables before computing since we
		* rely on their values during tmc read
		*/
		drvdata->sg_blk_num = 0;
		drvdata->delta_bottom = 0;
		drvdata->len = drvdata->size;

		if (val & TMC_STS_FULL)
		tmc_etr_sg_rwp_pos(drvdata, rwp);
		else
		drvdata->buf = drvdata->vaddr;
		}
		}

		void tmc_etr_disable_hw(struct tmc_drvdata *drvdata)
		@@ -131,6 +547,7 @@ static int tmc_etr_alloc_mem(struct tmc_drvdata *drvdata)
		int ret;

		if (!drvdata->vaddr) {
		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG) {
		drvdata->vaddr = dma_zalloc_coherent(drvdata->dev,
		drvdata->size,
		&drvdata->paddr,
		@@ -139,6 +556,11 @@ static int tmc_etr_alloc_mem(struct tmc_drvdata *drvdata)
		ret = -ENOMEM;
		goto err;
		}
		} else {
		ret = tmc_etr_sg_tbl_alloc(drvdata);
		if (ret)
		goto err;
		}
		}
		/*
		* Need to reinitialize buf for each tmc enable session since it is
		@@ -154,8 +576,13 @@ static int tmc_etr_alloc_mem(struct tmc_drvdata *drvdata)
		static void tmc_etr_free_mem(struct tmc_drvdata *drvdata)
		{
		if (drvdata->vaddr) {
		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG)
		dma_free_coherent(drvdata->dev, drvdata->size,
		drvdata->vaddr, drvdata->paddr);
		else
		tmc_etr_sg_tbl_free((uint32_t *)drvdata->vaddr,
		drvdata->size,
		DIV_ROUND_UP(drvdata->size, PAGE_SIZE));
		drvdata->vaddr = 0;
		drvdata->paddr = 0;
		}
		@@ -393,6 +820,7 @@ static int tmc_enable_etr_sink_sysfs(struct coresight_device *csdev)
		if (drvdata->size != drvdata->mem_size) {
		tmc_etr_free_mem(drvdata);
		drvdata->size = drvdata->mem_size;
		drvdata->memtype = drvdata->mem_type;
		}

		ret = tmc_etr_alloc_mem(drvdata);
		@@ -451,7 +879,7 @@ static int tmc_enable_etr_sink_sysfs(struct coresight_device *csdev)

		/* Free memory outside the spinlock if need be */
		if (!used && vaddr)
		dma_free_coherent(drvdata->dev, drvdata->size, vaddr, paddr);
		tmc_etr_free_mem(drvdata);

		if (drvdata->out_mode == TMC_ETR_OUT_MODE_MEM)
		tmc_etr_byte_cntr_start(drvdata->byte_cntr);
		@@ -660,7 +1088,7 @@ int tmc_read_unprepare_etr(struct tmc_drvdata *drvdata)

		/* Free allocated memory out side of the spinlock */
		if (vaddr)
		dma_free_coherent(drvdata->dev, drvdata->size, vaddr, paddr);
		tmc_etr_free_mem(drvdata);


		mutex_unlock(&drvdata->mem_lock);

drivers/hwtracing/coresight/coresight-tmc.c

+56 −6

Original line number	Diff line number	Diff line
		@@ -153,12 +153,19 @@ static ssize_t tmc_read(struct file file, char __user data, size_t len,
		len = drvdata->len - *ppos;

		if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) {
		if (drvdata->memtype == TMC_ETR_MEM_TYPE_CONTIG) {
		if (bufp == (char *)(drvdata->vaddr + drvdata->size))
		bufp = drvdata->vaddr;
		else if (bufp > (char *)(drvdata->vaddr + drvdata->size))
		else if (bufp > (char *)(drvdata->vaddr +
		drvdata->size))
		bufp -= drvdata->size;
		if ((bufp + len) > (char *)(drvdata->vaddr + drvdata->size))
		len = (char *)(drvdata->vaddr + drvdata->size) - bufp;
		if ((bufp + len) > (char *)(drvdata->vaddr +
		drvdata->size))
		len = (char *)(drvdata->vaddr + drvdata->size) -
		bufp;
		} else {
		tmc_etr_sg_compute_read(drvdata, ppos, &bufp, &len);
		}
		}

		if (copy_to_user(data, bufp, len)) {
		@@ -422,6 +429,43 @@ static ssize_t available_out_modes_show(struct device *dev,
		}
		static DEVICE_ATTR_RO(available_out_modes);

		static ssize_t mem_type_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct tmc_drvdata *drvdata = dev_get_drvdata(dev->parent);

		return scnprintf(buf, PAGE_SIZE, "%s\n",
		str_tmc_etr_mem_type[drvdata->mem_type]);
		}

		static ssize_t mem_type_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf,
		size_t size)
		{
		struct tmc_drvdata *drvdata = dev_get_drvdata(dev->parent);
		char str[10] = "";

		if (strlen(buf) >= 10)
		return -EINVAL;
		if (sscanf(buf, "%10s", str) != 1)
		return -EINVAL;

		mutex_lock(&drvdata->mem_lock);
		if (!strcmp(str, str_tmc_etr_mem_type[TMC_ETR_MEM_TYPE_CONTIG]))
		drvdata->mem_type = TMC_ETR_MEM_TYPE_CONTIG;
		else if (!strcmp(str, str_tmc_etr_mem_type[TMC_ETR_MEM_TYPE_SG]))
		drvdata->mem_type = TMC_ETR_MEM_TYPE_SG;
		else
		size = -EINVAL;

		mutex_unlock(&drvdata->mem_lock);

		return size;
		}
		static DEVICE_ATTR_RW(mem_type);

		static ssize_t block_size_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		@@ -517,6 +561,7 @@ static struct attribute *coresight_tmc_etf_attrs[] = {

		static struct attribute *coresight_tmc_etr_attrs[] = {
		&dev_attr_mem_size.attr,
		&dev_attr_mem_type.attr,
		&dev_attr_trigger_cntr.attr,
		&dev_attr_out_mode.attr,
		&dev_attr_available_out_modes.attr,
		@@ -635,7 +680,12 @@ static int tmc_probe(struct amba_device adev, const struct amba_id id)
		if (ret)
		drvdata->size = SZ_1M;

		if (of_property_read_bool(np, "arm,sg-enable"))
		drvdata->memtype = TMC_ETR_MEM_TYPE_SG;
		else
		drvdata->memtype = TMC_ETR_MEM_TYPE_CONTIG;
		drvdata->mem_size = drvdata->size;
		drvdata->mem_type = drvdata->memtype;
		drvdata->out_mode = TMC_ETR_OUT_MODE_MEM;
		} else {
		drvdata->size = readl_relaxed(drvdata->base + TMC_RSZ) * 4;

drivers/hwtracing/coresight/coresight-tmc.h

+20 −0

Original line number	Diff line number	Diff line
		@@ -101,6 +101,11 @@
		#define TMC_FFCR_TRIGON_TRIGIN BIT(8)
		#define TMC_FFCR_STOP_ON_FLUSH BIT(12)

		#define TMC_ETR_SG_ENT_TO_BLK(phys_pte) (((phys_addr_t)phys_pte >> 4) \
		<< PAGE_SHIFT)
		#define TMC_ETR_SG_ENT(phys_pte) (((phys_pte >> PAGE_SHIFT) << 4) \| 0x2)
		#define TMC_ETR_SG_NXT_TBL(phys_pte) (((phys_pte >> PAGE_SHIFT) << 4) \| 0x3)
		#define TMC_ETR_SG_LST_ENT(phys_pte) (((phys_pte >> PAGE_SHIFT) << 4) \| 0x1)

		#define TMC_DEVID_NOSCAT BIT(24)

		@@ -147,6 +152,15 @@ enum tmc_mem_intf_width {
		#define CORESIGHT_SOC_600_ETR_CAPS \
		(TMC_ETR_SAVE_RESTORE \| TMC_ETR_AXI_ARCACHE)

		enum tmc_etr_mem_type {
		TMC_ETR_MEM_TYPE_CONTIG,
		TMC_ETR_MEM_TYPE_SG,
		};

		static const char * const str_tmc_etr_mem_type[] = {
		[TMC_ETR_MEM_TYPE_CONTIG] = "contig",
		[TMC_ETR_MEM_TYPE_SG] = "sg",
		};
		enum tmc_etr_out_mode {
		TMC_ETR_OUT_MODE_NONE,
		TMC_ETR_OUT_MODE_MEM,
		@@ -210,8 +224,11 @@ struct tmc_drvdata {
		struct mutex mem_lock;
		u32 mem_size;
		u32 trigger_cntr;
		enum tmc_etr_mem_type mem_type;
		enum tmc_etr_mem_type memtype;
		u32 etr_caps;
		u32 delta_bottom;
		int sg_blk_num;
		enum tmc_etr_out_mode out_mode;
		struct usb_qdss_ch *usbch;
		struct tmc_etr_bam_data *bamdata;
		@@ -238,6 +255,8 @@ extern const struct coresight_ops tmc_etb_cs_ops;
		extern const struct coresight_ops tmc_etf_cs_ops;

		/* ETR functions */
		void tmc_etr_sg_compute_read(struct tmc_drvdata drvdata, loff_t ppos,
		char *bufpp, size_t len);
		int tmc_read_prepare_etr(struct tmc_drvdata *drvdata);
		int tmc_read_unprepare_etr(struct tmc_drvdata *drvdata);
		void __tmc_etr_disable_to_bam(struct tmc_drvdata *drvdata);
		@@ -251,6 +270,7 @@ int tmc_etr_bam_init(struct amba_device *adev,
		extern struct byte_cntr byte_cntr_init(struct amba_device adev,
		struct tmc_drvdata *drvdata);
		extern const struct coresight_ops tmc_etr_cs_ops;
		extern void tmc_etr_sg_rwp_pos(struct tmc_drvdata *drvdata, uint32_t rwp);


		#define TMC_REG_PAIR(name, lo_off, hi_off) \