kgsl_regmap.c - kernel/msm-modules/graphics - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
  * Copyright (c) 2022-2023, Qualcomm Innovation Center, Inc. All rights reserved.
  */

 #include <linux/io.h>
 #include <linux/platform_device.h>

 #include "kgsl_regmap.h"
 #include "kgsl_trace.h"

 #define region_addr(region, _offset) \
 	((region)->virt + (((_offset) - (region)->offset) << 2))

 static int kgsl_regmap_init_region(struct kgsl_regmap *regmap,
 		struct platform_device *pdev,
 		struct kgsl_regmap_region *region,
 		struct resource *res, const struct kgsl_regmap_ops *ops,
 		void *priv)
 {
 	void __iomem *ptr;

 	ptr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 	if (!ptr)
 		return -ENOMEM;

 	region->virt = ptr;
 	region->offset = (res->start - regmap->base->start) >> 2;
 	region->size = resource_size(res) >> 2;
 	region->ops = ops;
 	region->priv = priv;

 	return 0;
 }

 /* Initialize the regmap with the base region.  All added regions will be offset
  * from this base
  */
 int kgsl_regmap_init(struct platform_device *pdev, struct kgsl_regmap *regmap,
 		const char *name, const struct kgsl_regmap_ops *ops,
 		void *priv)
 {
 	struct kgsl_regmap_region *region;
 	struct resource *res;
 	int ret;

 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
 	if (!res)
 		return -ENODEV;

 	regmap->base = res;

 	region = &regmap->region[0];
 	ret = kgsl_regmap_init_region(regmap, pdev, region, res, ops, priv);

 	if (!ret)
 		regmap->count = 1;

 	return ret;
 }

 /* Add a new region to the regmap */
 int kgsl_regmap_add_region(struct kgsl_regmap *regmap, struct platform_device *pdev,
 		const char *name, const struct kgsl_regmap_ops *ops, void *priv)
 {
 	struct kgsl_regmap_region *region;
 	struct resource *res;
 	int ret;

 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
 	if (!res)
 		return -ENODEV;

 	if (WARN_ON(regmap->count >= ARRAY_SIZE(regmap->region)))
 		return -ENODEV;

 	region = &regmap->region[regmap->count];

 	ret = kgsl_regmap_init_region(regmap, pdev, region, res, ops, priv);
 	if (!ret)
 		regmap->count++;

 	return ret;
 }

 #define in_range(a, base, len) \
 	(((a) >= (base)) && ((a) < ((base) + (len))))

 struct kgsl_regmap_region *kgsl_regmap_get_region(struct kgsl_regmap *regmap,
 		u32 offset)
 {
 	int i;

 	for (i = 0; i < regmap->count; i++) {
 		struct kgsl_regmap_region *region = &regmap->region[i];

 		if (in_range(offset, region->offset, region->size))
 			return region;
 	}

 	return NULL;
 }

 bool kgsl_regmap_valid_offset(struct kgsl_regmap *regmap, u32 offset)
 {
 	if (kgsl_regmap_get_region(regmap, offset))
 		return true;

 	return false;
 }

 u32 kgsl_regmap_read(struct kgsl_regmap *regmap, u32 offset)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);
 	u32 val;

 	if (WARN(!region, "Out of bounds register read offset: 0x%x\n", offset))
 		return 0;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	val = readl_relaxed(region_addr(region, offset));
 	/* Allow previous read to post before returning the value */
 	rmb();

 	return val;
 }

 void kgsl_regmap_write(struct kgsl_regmap *regmap, u32 value, u32 offset)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

 	if (WARN(!region, "Out of bounds register write offset: 0x%x\n", offset))
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	/* Make sure all pending writes have posted first */
 	wmb();
 	writel_relaxed(value, region_addr(region, offset));

 	trace_kgsl_regwrite(offset, value);
 }

 void kgsl_regmap_multi_write(struct kgsl_regmap *regmap,
 		const struct kgsl_regmap_list *list, int count)
 {
 	struct kgsl_regmap_region *region, *prev = NULL;
 	int i;

 	/*
 	 * do one write barrier to ensure all previous writes are done before
 	 * starting the list
 	 */
 	wmb();

 	for (i = 0; i < count; i++) {
 		region = kgsl_regmap_get_region(regmap, list[i].offset);

 		if (WARN(!region, "Out of bounds register write offset: 0x%x\n",
 			list[i].offset))
 			continue;

 		/*
 		 * The registers might be in different regions. If a region has
 		 * a preaccess function we need to call it at least once before
 		 * writing registers but we don't want to call it every time if
 		 * we can avoid it. "cache" the current region and don't call
 		 * pre-access if it is the same region from the previous access.
 		 * This isn't perfect but it should cut down on some unneeded
 		 * cpu cycles
 		 */

 		if (region != prev && region->ops && region->ops->preaccess)
 			region->ops->preaccess(region);

 		prev = region;

 		writel_relaxed(list[i].val, region_addr(region, list[i].offset));
 		trace_kgsl_regwrite(list[i].val, list[i].offset);
 	}
 }

 void kgsl_regmap_rmw(struct kgsl_regmap *regmap, u32 offset, u32 mask,
 		u32 or)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);
 	u32 val;

 	if (WARN(!region, "Out of bounds register read-modify-write offset: 0x%x\n",
 		offset))
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	val = readl_relaxed(region_addr(region, offset));
 	/* Make sure the read posted and all pending writes are done */
 	mb();
 	writel_relaxed((val & ~mask) | or, region_addr(region, offset));

 	trace_kgsl_regwrite(offset, (val & ~mask) | or);
 }

 void kgsl_regmap_bulk_write(struct kgsl_regmap *regmap, u32 offset,
 		const void *data, int dwords)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

 	if (WARN(!region, "Out of bounds register bulk write offset: 0x%x\n", offset))
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	/*
 	 * A bulk write operation can only be in one region - it cannot
 	 * cross boundaries
 	 */
 	if (WARN((offset - region->offset) + dwords > region->size,
 		"OUt of bounds bulk write size: 0x%x\n", offset + dwords))
 		return;

 	/* Make sure all pending write are done first */
 	wmb();
 	memcpy_toio(region_addr(region, offset), data, dwords << 2);
 }

 void kgsl_regmap_bulk_read(struct kgsl_regmap *regmap, u32 offset,
 		const void *data, int dwords)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

 	if (WARN(!region, "Out of bounds register bulk read offset: 0x%x\n", offset))
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	/*
 	 * A bulk read operation can only be in one region - it cannot
 	 * cross boundaries
 	 */
 	if (WARN((offset - region->offset) + dwords > region->size,
 		"Out of bounds bulk read size: 0x%x\n", offset + dwords))
 		return;

 	memcpy_fromio(region_addr(region, offset), data, dwords << 2);

 	/* Make sure the copy is finished before moving on */
 	rmb();
 }

 void __iomem *kgsl_regmap_virt(struct kgsl_regmap *regmap, u32 offset)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

 	if (region)
 		return region_addr(region, offset);

 	return NULL;
 }

 void kgsl_regmap_read_indexed(struct kgsl_regmap *regmap, u32 addr,
 		u32 data, u32 *dest, int count)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, addr);
 	int i;

 	if (!region)
 		return;

 	/* Make sure the offset is in the same region */
 	if (kgsl_regmap_get_region(regmap, data) != region)
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	/* Write the address register */
 	writel_relaxed(0, region_addr(region, addr));

 	/* Make sure the write finishes */
 	wmb();

 	for (i = 0; i < count; i++)
 		dest[i] = readl_relaxed(region_addr(region, data));

 	/* Do one barrier at the end to make sure all the data is posted */
 	rmb();
 }

 void kgsl_regmap_read_indexed_interleaved(struct kgsl_regmap *regmap, u32 addr,
 		u32 data, u32 *dest, u32 start, int count)
 {
 	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, addr);
 	int i;

 	if (!region)
 		return;

 	/* Make sure the offset is in the same region */
 	if (kgsl_regmap_get_region(regmap, data) != region)
 		return;

 	if (region->ops && region->ops->preaccess)
 		region->ops->preaccess(region);

 	for (i = 0; i < count; i++) {
 		/* Write the address register */
 		writel_relaxed(start + i, region_addr(region, addr));
 		/* Make sure the write finishes */
 		wmb();

 		dest[i] = readl_relaxed(region_addr(region, data));
 		/* Make sure the read finishes */
 		rmb();
 	}
 }

 /* A special helper function to work with read_poll_timeout */
 int kgsl_regmap_poll_read(struct kgsl_regmap_region *region, u32 offset,
 		u32 *val)
 {
 	/* FIXME: WARN on !region? */
 	if (WARN(!region, "Out of bounds poll read: 0x%x\n", offset))
 		return -ENODEV;

 	*val = readl_relaxed(region_addr(region, offset));
 	/* Make sure the read is finished before moving on */
 	rmb();

 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
	* Copyright (c) 2022-2023, Qualcomm Innovation Center, Inc. All rights reserved.
	*/

	#include <linux/io.h>
	#include <linux/platform_device.h>

	#include "kgsl_regmap.h"
	#include "kgsl_trace.h"

	#define region_addr(region, _offset) \
	((region)->virt + (((_offset) - (region)->offset) << 2))

	static int kgsl_regmap_init_region(struct kgsl_regmap *regmap,
	struct platform_device *pdev,
	struct kgsl_regmap_region *region,
	struct resource res, const struct kgsl_regmap_ops ops,
	void *priv)
	{
	void __iomem *ptr;

	ptr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
	if (!ptr)
	return -ENOMEM;

	region->virt = ptr;
	region->offset = (res->start - regmap->base->start) >> 2;
	region->size = resource_size(res) >> 2;
	region->ops = ops;
	region->priv = priv;

	return 0;
	}

	/* Initialize the regmap with the base region. All added regions will be offset
	* from this base
	*/
	int kgsl_regmap_init(struct platform_device pdev, struct kgsl_regmap regmap,
	const char name, const struct kgsl_regmap_ops ops,
	void *priv)
	{
	struct kgsl_regmap_region *region;
	struct resource *res;
	int ret;

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	if (!res)
	return -ENODEV;

	regmap->base = res;

	region = &regmap->region[0];
	ret = kgsl_regmap_init_region(regmap, pdev, region, res, ops, priv);

	if (!ret)
	regmap->count = 1;

	return ret;
	}

	/* Add a new region to the regmap */
	int kgsl_regmap_add_region(struct kgsl_regmap regmap, struct platform_device pdev,
	const char name, const struct kgsl_regmap_ops ops, void *priv)
	{
	struct kgsl_regmap_region *region;
	struct resource *res;
	int ret;

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	if (!res)
	return -ENODEV;

	if (WARN_ON(regmap->count >= ARRAY_SIZE(regmap->region)))
	return -ENODEV;

	region = &regmap->region[regmap->count];

	ret = kgsl_regmap_init_region(regmap, pdev, region, res, ops, priv);
	if (!ret)
	regmap->count++;

	return ret;
	}

	#define in_range(a, base, len) \
	(((a) >= (base)) && ((a) < ((base) + (len))))

	struct kgsl_regmap_region kgsl_regmap_get_region(struct kgsl_regmap regmap,
	u32 offset)
	{
	int i;

	for (i = 0; i < regmap->count; i++) {
	struct kgsl_regmap_region *region = &regmap->region[i];

	if (in_range(offset, region->offset, region->size))
	return region;
	}

	return NULL;
	}

	bool kgsl_regmap_valid_offset(struct kgsl_regmap *regmap, u32 offset)
	{
	if (kgsl_regmap_get_region(regmap, offset))
	return true;

	return false;
	}

	u32 kgsl_regmap_read(struct kgsl_regmap *regmap, u32 offset)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);
	u32 val;

	if (WARN(!region, "Out of bounds register read offset: 0x%x\n", offset))
	return 0;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	val = readl_relaxed(region_addr(region, offset));
	/* Allow previous read to post before returning the value */
	rmb();

	return val;
	}

	void kgsl_regmap_write(struct kgsl_regmap *regmap, u32 value, u32 offset)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

	if (WARN(!region, "Out of bounds register write offset: 0x%x\n", offset))
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	/* Make sure all pending writes have posted first */
	wmb();
	writel_relaxed(value, region_addr(region, offset));

	trace_kgsl_regwrite(offset, value);
	}

	void kgsl_regmap_multi_write(struct kgsl_regmap *regmap,
	const struct kgsl_regmap_list *list, int count)
	{
	struct kgsl_regmap_region region, prev = NULL;
	int i;

	/*
	* do one write barrier to ensure all previous writes are done before
	* starting the list
	*/
	wmb();

	for (i = 0; i < count; i++) {
	region = kgsl_regmap_get_region(regmap, list[i].offset);

	if (WARN(!region, "Out of bounds register write offset: 0x%x\n",
	list[i].offset))
	continue;

	/*
	* The registers might be in different regions. If a region has
	* a preaccess function we need to call it at least once before
	* writing registers but we don't want to call it every time if
	* we can avoid it. "cache" the current region and don't call
	* pre-access if it is the same region from the previous access.
	* This isn't perfect but it should cut down on some unneeded
	* cpu cycles
	*/

	if (region != prev && region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	prev = region;

	writel_relaxed(list[i].val, region_addr(region, list[i].offset));
	trace_kgsl_regwrite(list[i].val, list[i].offset);
	}
	}

	void kgsl_regmap_rmw(struct kgsl_regmap *regmap, u32 offset, u32 mask,
	u32 or)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);
	u32 val;

	if (WARN(!region, "Out of bounds register read-modify-write offset: 0x%x\n",
	offset))
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	val = readl_relaxed(region_addr(region, offset));
	/* Make sure the read posted and all pending writes are done */
	mb();
	writel_relaxed((val & ~mask) \| or, region_addr(region, offset));

	trace_kgsl_regwrite(offset, (val & ~mask) \| or);
	}

	void kgsl_regmap_bulk_write(struct kgsl_regmap *regmap, u32 offset,
	const void *data, int dwords)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

	if (WARN(!region, "Out of bounds register bulk write offset: 0x%x\n", offset))
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	/*
	* A bulk write operation can only be in one region - it cannot
	* cross boundaries
	*/
	if (WARN((offset - region->offset) + dwords > region->size,
	"OUt of bounds bulk write size: 0x%x\n", offset + dwords))
	return;

	/* Make sure all pending write are done first */
	wmb();
	memcpy_toio(region_addr(region, offset), data, dwords << 2);
	}

	void kgsl_regmap_bulk_read(struct kgsl_regmap *regmap, u32 offset,
	const void *data, int dwords)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

	if (WARN(!region, "Out of bounds register bulk read offset: 0x%x\n", offset))
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	/*
	* A bulk read operation can only be in one region - it cannot
	* cross boundaries
	*/
	if (WARN((offset - region->offset) + dwords > region->size,
	"Out of bounds bulk read size: 0x%x\n", offset + dwords))
	return;

	memcpy_fromio(region_addr(region, offset), data, dwords << 2);

	/* Make sure the copy is finished before moving on */
	rmb();
	}

	void __iomem kgsl_regmap_virt(struct kgsl_regmap regmap, u32 offset)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, offset);

	if (region)
	return region_addr(region, offset);

	return NULL;
	}

	void kgsl_regmap_read_indexed(struct kgsl_regmap *regmap, u32 addr,
	u32 data, u32 *dest, int count)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, addr);
	int i;

	if (!region)
	return;

	/* Make sure the offset is in the same region */
	if (kgsl_regmap_get_region(regmap, data) != region)
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	/* Write the address register */
	writel_relaxed(0, region_addr(region, addr));

	/* Make sure the write finishes */
	wmb();

	for (i = 0; i < count; i++)
	dest[i] = readl_relaxed(region_addr(region, data));

	/* Do one barrier at the end to make sure all the data is posted */
	rmb();
	}

	void kgsl_regmap_read_indexed_interleaved(struct kgsl_regmap *regmap, u32 addr,
	u32 data, u32 *dest, u32 start, int count)
	{
	struct kgsl_regmap_region *region = kgsl_regmap_get_region(regmap, addr);
	int i;

	if (!region)
	return;

	/* Make sure the offset is in the same region */
	if (kgsl_regmap_get_region(regmap, data) != region)
	return;

	if (region->ops && region->ops->preaccess)
	region->ops->preaccess(region);

	for (i = 0; i < count; i++) {
	/* Write the address register */
	writel_relaxed(start + i, region_addr(region, addr));
	/* Make sure the write finishes */
	wmb();

	dest[i] = readl_relaxed(region_addr(region, data));
	/* Make sure the read finishes */
	rmb();
	}
	}

	/* A special helper function to work with read_poll_timeout */
	int kgsl_regmap_poll_read(struct kgsl_regmap_region *region, u32 offset,
	u32 *val)
	{
	/* FIXME: WARN on !region? */
	if (WARN(!region, "Out of bounds poll read: 0x%x\n", offset))
	return -ENODEV;

	*val = readl_relaxed(region_addr(region, offset));
	/* Make sure the read is finished before moving on */
	rmb();

	return 0;
	}