Commit 21de54b3 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge tag 'drm-vc4-next-2015-12-11' of http://github.com/anholt/linux into drm-next 

This pull request brings in 3D acceleration support for the VC4 GPU.
While there is still performance work to be done (particularly
surrounding RCL generation), the CL submit ABI should be settled and
done now.

* tag 'drm-vc4-next-2015-12-11' of http://github.com/anholt/linux:
  drm/vc4: Add an interface for capturing the GPU state after a hang.
  drm/vc4: Add support for async pageflips.
  drm/vc4: Add support for drawing 3D frames.
  drm/vc4: Bind and initialize the V3D engine.
  drm/vc4: Fix a typo in a V3D debug register.
  drm/vc4: Add an API for creating GPU shaders in GEM BOs.
  drm/vc4: Add create and map BO ioctls.
  drm/vc4: Add a BO cache.
  drm: Create a driver hook for allocating GEM object structs.
parents 870a1718 21461365

drivers/gpu/drm/drm_gem_cma_helper.c

+6 −4
Original line number Diff line number Diff line
@@ -59,11 +59,13 @@ __drm_gem_cma_create(struct drm_device *drm, size_t size) 
	struct drm_gem_object *gem_obj;

	int ret;



	cma_obj = kzalloc(sizeof(*cma_obj), GFP_KERNEL);

	if (!cma_obj)

	if (drm->driver->gem_create_object)

		gem_obj = drm->driver->gem_create_object(drm, size);

	else

		gem_obj = kzalloc(sizeof(*cma_obj), GFP_KERNEL);

	if (!gem_obj)

		return ERR_PTR(-ENOMEM);



	gem_obj = &cma_obj->base;

	cma_obj = container_of(gem_obj, struct drm_gem_cma_object, base);



	ret = drm_gem_object_init(drm, gem_obj, size);

	if (ret)

drivers/gpu/drm/vc4/Makefile

+10 −1
Original line number Diff line number Diff line
@@ -8,10 +8,19 @@ vc4-y := \ 
	vc4_crtc.o \

	vc4_drv.o \

	vc4_kms.o \

	vc4_gem.o \

	vc4_hdmi.o \

	vc4_hvs.o \

	vc4_plane.o

	vc4_irq.o \

	vc4_plane.o \

	vc4_render_cl.o \

	vc4_trace_points.o \

	vc4_v3d.o \

	vc4_validate.o \

	vc4_validate_shaders.o



vc4-$(CONFIG_DEBUG_FS) += vc4_debugfs.o



obj-$(CONFIG_DRM_VC4)  += vc4.o



CFLAGS_vc4_trace_points.o := -I$(src)

drivers/gpu/drm/vc4/vc4_bo.c

+511 −6
Original line number Diff line number Diff line
@@ -12,18 +12,235 @@ 
 * access to system memory with no MMU in between.  To support it, we

 * use the GEM CMA helper functions to allocate contiguous ranges of

 * physical memory for our BOs.

 *

 * Since the CMA allocator is very slow, we keep a cache of recently

 * freed BOs around so that the kernel's allocation of objects for 3D

 * rendering can return quickly.

 */



#include "vc4_drv.h"

#include "uapi/drm/vc4_drm.h"



static void vc4_bo_stats_dump(struct vc4_dev *vc4)

{

	DRM_INFO("num bos allocated: %d\n",

		 vc4->bo_stats.num_allocated);

	DRM_INFO("size bos allocated: %dkb\n",

		 vc4->bo_stats.size_allocated / 1024);

	DRM_INFO("num bos used: %d\n",

		 vc4->bo_stats.num_allocated - vc4->bo_stats.num_cached);

	DRM_INFO("size bos used: %dkb\n",

		 (vc4->bo_stats.size_allocated -

		  vc4->bo_stats.size_cached) / 1024);

	DRM_INFO("num bos cached: %d\n",

		 vc4->bo_stats.num_cached);

	DRM_INFO("size bos cached: %dkb\n",

		 vc4->bo_stats.size_cached / 1024);

}



#ifdef CONFIG_DEBUG_FS

int vc4_bo_stats_debugfs(struct seq_file *m, void *unused)

{

	struct drm_info_node *node = (struct drm_info_node *)m->private;

	struct drm_device *dev = node->minor->dev;

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct vc4_bo_stats stats;



	/* Take a snapshot of the current stats with the lock held. */

	mutex_lock(&vc4->bo_lock);

	stats = vc4->bo_stats;

	mutex_unlock(&vc4->bo_lock);



	seq_printf(m, "num bos allocated: %d\n",

		   stats.num_allocated);

	seq_printf(m, "size bos allocated: %dkb\n",

		   stats.size_allocated / 1024);

	seq_printf(m, "num bos used: %d\n",

		   stats.num_allocated - stats.num_cached);

	seq_printf(m, "size bos used: %dkb\n",

		   (stats.size_allocated - stats.size_cached) / 1024);

	seq_printf(m, "num bos cached: %d\n",

		   stats.num_cached);

	seq_printf(m, "size bos cached: %dkb\n",

		   stats.size_cached / 1024);



	return 0;

}

#endif



static uint32_t bo_page_index(size_t size)

{

	return (size / PAGE_SIZE) - 1;

}



/* Must be called with bo_lock held. */

static void vc4_bo_destroy(struct vc4_bo *bo)

{

	struct drm_gem_object *obj = &bo->base.base;

	struct vc4_dev *vc4 = to_vc4_dev(obj->dev);



	if (bo->validated_shader) {

		kfree(bo->validated_shader->texture_samples);

		kfree(bo->validated_shader);

		bo->validated_shader = NULL;

	}



	vc4->bo_stats.num_allocated--;

	vc4->bo_stats.size_allocated -= obj->size;

	drm_gem_cma_free_object(obj);

}



/* Must be called with bo_lock held. */

static void vc4_bo_remove_from_cache(struct vc4_bo *bo)

{

	struct drm_gem_object *obj = &bo->base.base;

	struct vc4_dev *vc4 = to_vc4_dev(obj->dev);



	vc4->bo_stats.num_cached--;

	vc4->bo_stats.size_cached -= obj->size;



	list_del(&bo->unref_head);

	list_del(&bo->size_head);

}



static struct list_head *vc4_get_cache_list_for_size(struct drm_device *dev,

						     size_t size)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	uint32_t page_index = bo_page_index(size);



	if (vc4->bo_cache.size_list_size <= page_index) {

		uint32_t new_size = max(vc4->bo_cache.size_list_size * 2,

					page_index + 1);

		struct list_head *new_list;

		uint32_t i;



		new_list = kmalloc_array(new_size, sizeof(struct list_head),

					 GFP_KERNEL);

		if (!new_list)

			return NULL;



		/* Rebase the old cached BO lists to their new list

		 * head locations.

		 */

		for (i = 0; i < vc4->bo_cache.size_list_size; i++) {

			struct list_head *old_list =

				&vc4->bo_cache.size_list[i];



			if (list_empty(old_list))

				INIT_LIST_HEAD(&new_list[i]);

			else

				list_replace(old_list, &new_list[i]);

		}

		/* And initialize the brand new BO list heads. */

		for (i = vc4->bo_cache.size_list_size; i < new_size; i++)

			INIT_LIST_HEAD(&new_list[i]);



		kfree(vc4->bo_cache.size_list);

		vc4->bo_cache.size_list = new_list;

		vc4->bo_cache.size_list_size = new_size;

	}



	return &vc4->bo_cache.size_list[page_index];

}



void vc4_bo_cache_purge(struct drm_device *dev)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);



	mutex_lock(&vc4->bo_lock);

	while (!list_empty(&vc4->bo_cache.time_list)) {

		struct vc4_bo *bo = list_last_entry(&vc4->bo_cache.time_list,

						    struct vc4_bo, unref_head);

		vc4_bo_remove_from_cache(bo);

		vc4_bo_destroy(bo);

	}

	mutex_unlock(&vc4->bo_lock);

}



static struct vc4_bo *vc4_bo_get_from_cache(struct drm_device *dev,

					    uint32_t size)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	uint32_t page_index = bo_page_index(size);

	struct vc4_bo *bo = NULL;



	size = roundup(size, PAGE_SIZE);



	mutex_lock(&vc4->bo_lock);

	if (page_index >= vc4->bo_cache.size_list_size)

		goto out;



	if (list_empty(&vc4->bo_cache.size_list[page_index]))

		goto out;



	bo = list_first_entry(&vc4->bo_cache.size_list[page_index],

			      struct vc4_bo, size_head);

	vc4_bo_remove_from_cache(bo);

	kref_init(&bo->base.base.refcount);



struct vc4_bo *vc4_bo_create(struct drm_device *dev, size_t size)

out:

	mutex_unlock(&vc4->bo_lock);

	return bo;

}



/**

 * vc4_gem_create_object - Implementation of driver->gem_create_object.

 *

 * This lets the CMA helpers allocate object structs for us, and keep

 * our BO stats correct.

 */

struct drm_gem_object *vc4_create_object(struct drm_device *dev, size_t size)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct vc4_bo *bo;



	bo = kzalloc(sizeof(*bo), GFP_KERNEL);

	if (!bo)

		return ERR_PTR(-ENOMEM);



	mutex_lock(&vc4->bo_lock);

	vc4->bo_stats.num_allocated++;

	vc4->bo_stats.size_allocated += size;

	mutex_unlock(&vc4->bo_lock);



	return &bo->base.base;

}



struct vc4_bo *vc4_bo_create(struct drm_device *dev, size_t unaligned_size,

			     bool from_cache)

{

	size_t size = roundup(unaligned_size, PAGE_SIZE);

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct drm_gem_cma_object *cma_obj;



	if (size == 0)

		return NULL;



	/* First, try to get a vc4_bo from the kernel BO cache. */

	if (from_cache) {

		struct vc4_bo *bo = vc4_bo_get_from_cache(dev, size);



		if (bo)

			return bo;

	}



	cma_obj = drm_gem_cma_create(dev, size);

	if (IS_ERR(cma_obj)) {

		/*

		 * If we've run out of CMA memory, kill the cache of

		 * CMA allocations we've got laying around and try again.

		 */

		vc4_bo_cache_purge(dev);



		cma_obj = drm_gem_cma_create(dev, size);

	if (IS_ERR(cma_obj))

		if (IS_ERR(cma_obj)) {

			DRM_ERROR("Failed to allocate from CMA:\n");

			vc4_bo_stats_dump(vc4);

			return NULL;

	else

		}

	}



	return to_vc4_bo(&cma_obj->base);

}
@@ -41,12 +258,300 @@ int vc4_dumb_create(struct drm_file *file_priv, 
	if (args->size < args->pitch * args->height)

		args->size = args->pitch * args->height;



	bo = vc4_bo_create(dev, roundup(args->size, PAGE_SIZE));

	bo = vc4_bo_create(dev, args->size, false);

	if (!bo)

		return -ENOMEM;



	ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);

	drm_gem_object_unreference_unlocked(&bo->base.base);



	return ret;

}



/* Must be called with bo_lock held. */

static void vc4_bo_cache_free_old(struct drm_device *dev)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	unsigned long expire_time = jiffies - msecs_to_jiffies(1000);



	while (!list_empty(&vc4->bo_cache.time_list)) {

		struct vc4_bo *bo = list_last_entry(&vc4->bo_cache.time_list,

						    struct vc4_bo, unref_head);

		if (time_before(expire_time, bo->free_time)) {

			mod_timer(&vc4->bo_cache.time_timer,

				  round_jiffies_up(jiffies +

						   msecs_to_jiffies(1000)));

			return;

		}



		vc4_bo_remove_from_cache(bo);

		vc4_bo_destroy(bo);

	}

}



/* Called on the last userspace/kernel unreference of the BO.  Returns

 * it to the BO cache if possible, otherwise frees it.

 *

 * Note that this is called with the struct_mutex held.

 */

void vc4_free_object(struct drm_gem_object *gem_bo)

{

	struct drm_device *dev = gem_bo->dev;

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct vc4_bo *bo = to_vc4_bo(gem_bo);

	struct list_head *cache_list;



	mutex_lock(&vc4->bo_lock);

	/* If the object references someone else's memory, we can't cache it.

	 */

	if (gem_bo->import_attach) {

		vc4_bo_destroy(bo);

		goto out;

	}



	/* Don't cache if it was publicly named. */

	if (gem_bo->name) {

		vc4_bo_destroy(bo);

		goto out;

	}



	cache_list = vc4_get_cache_list_for_size(dev, gem_bo->size);

	if (!cache_list) {

		vc4_bo_destroy(bo);

		goto out;

	}



	if (bo->validated_shader) {

		kfree(bo->validated_shader->texture_samples);

		kfree(bo->validated_shader);

		bo->validated_shader = NULL;

	}



	bo->free_time = jiffies;

	list_add(&bo->size_head, cache_list);

	list_add(&bo->unref_head, &vc4->bo_cache.time_list);



	vc4->bo_stats.num_cached++;

	vc4->bo_stats.size_cached += gem_bo->size;



	vc4_bo_cache_free_old(dev);



out:

	mutex_unlock(&vc4->bo_lock);

}



static void vc4_bo_cache_time_work(struct work_struct *work)

{

	struct vc4_dev *vc4 =

		container_of(work, struct vc4_dev, bo_cache.time_work);

	struct drm_device *dev = vc4->dev;



	mutex_lock(&vc4->bo_lock);

	vc4_bo_cache_free_old(dev);

	mutex_unlock(&vc4->bo_lock);

}



static void vc4_bo_cache_time_timer(unsigned long data)

{

	struct drm_device *dev = (struct drm_device *)data;

	struct vc4_dev *vc4 = to_vc4_dev(dev);



	schedule_work(&vc4->bo_cache.time_work);

}



struct dma_buf *

vc4_prime_export(struct drm_device *dev, struct drm_gem_object *obj, int flags)

{

	struct vc4_bo *bo = to_vc4_bo(obj);



	if (bo->validated_shader) {

		DRM_ERROR("Attempting to export shader BO\n");

		return ERR_PTR(-EINVAL);

	}



	return drm_gem_prime_export(dev, obj, flags);

}



int vc4_mmap(struct file *filp, struct vm_area_struct *vma)

{

	struct drm_gem_object *gem_obj;

	struct vc4_bo *bo;

	int ret;



	ret = drm_gem_mmap(filp, vma);

	if (ret)

		return ret;



	gem_obj = vma->vm_private_data;

	bo = to_vc4_bo(gem_obj);



	if (bo->validated_shader && (vma->vm_flags & VM_WRITE)) {

		DRM_ERROR("mmaping of shader BOs for writing not allowed.\n");

		return -EINVAL;

	}



	/*

	 * Clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the

	 * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map

	 * the whole buffer.

	 */

	vma->vm_flags &= ~VM_PFNMAP;

	vma->vm_pgoff = 0;



	ret = dma_mmap_writecombine(bo->base.base.dev->dev, vma,

				    bo->base.vaddr, bo->base.paddr,

				    vma->vm_end - vma->vm_start);

	if (ret)

		drm_gem_vm_close(vma);



	return ret;

}



int vc4_prime_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)

{

	struct vc4_bo *bo = to_vc4_bo(obj);



	if (bo->validated_shader && (vma->vm_flags & VM_WRITE)) {

		DRM_ERROR("mmaping of shader BOs for writing not allowed.\n");

		return -EINVAL;

	}



	return drm_gem_cma_prime_mmap(obj, vma);

}



void *vc4_prime_vmap(struct drm_gem_object *obj)

{

	struct vc4_bo *bo = to_vc4_bo(obj);



	if (bo->validated_shader) {

		DRM_ERROR("mmaping of shader BOs not allowed.\n");

		return ERR_PTR(-EINVAL);

	}



	return drm_gem_cma_prime_vmap(obj);

}



int vc4_create_bo_ioctl(struct drm_device *dev, void *data,

			struct drm_file *file_priv)

{

	struct drm_vc4_create_bo *args = data;

	struct vc4_bo *bo = NULL;

	int ret;



	/*

	 * We can't allocate from the BO cache, because the BOs don't

	 * get zeroed, and that might leak data between users.

	 */

	bo = vc4_bo_create(dev, args->size, false);

	if (!bo)

		return -ENOMEM;



	ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);

	drm_gem_object_unreference_unlocked(&bo->base.base);



	return ret;

}



int vc4_mmap_bo_ioctl(struct drm_device *dev, void *data,

		      struct drm_file *file_priv)

{

	struct drm_vc4_mmap_bo *args = data;

	struct drm_gem_object *gem_obj;



	gem_obj = drm_gem_object_lookup(dev, file_priv, args->handle);

	if (!gem_obj) {

		DRM_ERROR("Failed to look up GEM BO %d\n", args->handle);

		return -EINVAL;

	}



	/* The mmap offset was set up at BO allocation time. */

	args->offset = drm_vma_node_offset_addr(&gem_obj->vma_node);



	drm_gem_object_unreference_unlocked(gem_obj);

	return 0;

}



int

vc4_create_shader_bo_ioctl(struct drm_device *dev, void *data,

			   struct drm_file *file_priv)

{

	struct drm_vc4_create_shader_bo *args = data;

	struct vc4_bo *bo = NULL;

	int ret;



	if (args->size == 0)

		return -EINVAL;



	if (args->size % sizeof(u64) != 0)

		return -EINVAL;



	if (args->flags != 0) {

		DRM_INFO("Unknown flags set: 0x%08x\n", args->flags);

		return -EINVAL;

	}



	if (args->pad != 0) {

		DRM_INFO("Pad set: 0x%08x\n", args->pad);

		return -EINVAL;

	}



	bo = vc4_bo_create(dev, args->size, true);

	if (!bo)

		return -ENOMEM;



	ret = copy_from_user(bo->base.vaddr,

			     (void __user *)(uintptr_t)args->data,

			     args->size);

	if (ret != 0)

		goto fail;

	/* Clear the rest of the memory from allocating from the BO

	 * cache.

	 */

	memset(bo->base.vaddr + args->size, 0,

	       bo->base.base.size - args->size);



	bo->validated_shader = vc4_validate_shader(&bo->base);

	if (!bo->validated_shader) {

		ret = -EINVAL;

		goto fail;

	}



	/* We have to create the handle after validation, to avoid

	 * races for users to do doing things like mmap the shader BO.

	 */

	ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);



 fail:

	drm_gem_object_unreference_unlocked(&bo->base.base);



	return ret;

}



void vc4_bo_cache_init(struct drm_device *dev)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);



	mutex_init(&vc4->bo_lock);



	INIT_LIST_HEAD(&vc4->bo_cache.time_list);



	INIT_WORK(&vc4->bo_cache.time_work, vc4_bo_cache_time_work);

	setup_timer(&vc4->bo_cache.time_timer,

		    vc4_bo_cache_time_timer,

		    (unsigned long)dev);

}



void vc4_bo_cache_destroy(struct drm_device *dev)

{

	struct vc4_dev *vc4 = to_vc4_dev(dev);



	del_timer(&vc4->bo_cache.time_timer);

	cancel_work_sync(&vc4->bo_cache.time_work);



	vc4_bo_cache_purge(dev);



	if (vc4->bo_stats.num_allocated) {

		DRM_ERROR("Destroying BO cache while BOs still allocated:\n");

		vc4_bo_stats_dump(vc4);

	}

}

drivers/gpu/drm/vc4/vc4_crtc.c

+98 −1
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include "drm_atomic_helper.h"

#include "drm_crtc_helper.h"

#include "linux/clk.h"

#include "drm_fb_cma_helper.h"

#include "linux/component.h"

#include "linux/of_device.h"

#include "vc4_drv.h"
@@ -476,10 +477,106 @@ static irqreturn_t vc4_crtc_irq_handler(int irq, void *data) 
	return ret;

}



struct vc4_async_flip_state {

	struct drm_crtc *crtc;

	struct drm_framebuffer *fb;

	struct drm_pending_vblank_event *event;



	struct vc4_seqno_cb cb;

};



/* Called when the V3D execution for the BO being flipped to is done, so that

 * we can actually update the plane's address to point to it.

 */

static void

vc4_async_page_flip_complete(struct vc4_seqno_cb *cb)

{

	struct vc4_async_flip_state *flip_state =

		container_of(cb, struct vc4_async_flip_state, cb);

	struct drm_crtc *crtc = flip_state->crtc;

	struct drm_device *dev = crtc->dev;

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct drm_plane *plane = crtc->primary;



	vc4_plane_async_set_fb(plane, flip_state->fb);

	if (flip_state->event) {

		unsigned long flags;



		spin_lock_irqsave(&dev->event_lock, flags);

		drm_crtc_send_vblank_event(crtc, flip_state->event);

		spin_unlock_irqrestore(&dev->event_lock, flags);

	}



	drm_framebuffer_unreference(flip_state->fb);

	kfree(flip_state);



	up(&vc4->async_modeset);

}



/* Implements async (non-vblank-synced) page flips.

 *

 * The page flip ioctl needs to return immediately, so we grab the

 * modeset semaphore on the pipe, and queue the address update for

 * when V3D is done with the BO being flipped to.

 */

static int vc4_async_page_flip(struct drm_crtc *crtc,

			       struct drm_framebuffer *fb,

			       struct drm_pending_vblank_event *event,

			       uint32_t flags)

{

	struct drm_device *dev = crtc->dev;

	struct vc4_dev *vc4 = to_vc4_dev(dev);

	struct drm_plane *plane = crtc->primary;

	int ret = 0;

	struct vc4_async_flip_state *flip_state;

	struct drm_gem_cma_object *cma_bo = drm_fb_cma_get_gem_obj(fb, 0);

	struct vc4_bo *bo = to_vc4_bo(&cma_bo->base);



	flip_state = kzalloc(sizeof(*flip_state), GFP_KERNEL);

	if (!flip_state)

		return -ENOMEM;



	drm_framebuffer_reference(fb);

	flip_state->fb = fb;

	flip_state->crtc = crtc;

	flip_state->event = event;



	/* Make sure all other async modesetes have landed. */

	ret = down_interruptible(&vc4->async_modeset);

	if (ret) {

		kfree(flip_state);

		return ret;

	}



	/* Immediately update the plane's legacy fb pointer, so that later

	 * modeset prep sees the state that will be present when the semaphore

	 * is released.

	 */

	drm_atomic_set_fb_for_plane(plane->state, fb);

	plane->fb = fb;



	vc4_queue_seqno_cb(dev, &flip_state->cb, bo->seqno,

			   vc4_async_page_flip_complete);



	/* Driver takes ownership of state on successful async commit. */

	return 0;

}



static int vc4_page_flip(struct drm_crtc *crtc,

			 struct drm_framebuffer *fb,

			 struct drm_pending_vblank_event *event,

			 uint32_t flags)

{

	if (flags & DRM_MODE_PAGE_FLIP_ASYNC)

		return vc4_async_page_flip(crtc, fb, event, flags);

	else

		return drm_atomic_helper_page_flip(crtc, fb, event, flags);

}



static const struct drm_crtc_funcs vc4_crtc_funcs = {

	.set_config = drm_atomic_helper_set_config,

	.destroy = vc4_crtc_destroy,

	.page_flip = drm_atomic_helper_page_flip,

	.page_flip = vc4_page_flip,

	.set_property = NULL,

	.cursor_set = NULL, /* handled by drm_mode_cursor_universal */

	.cursor_move = NULL, /* handled by drm_mode_cursor_universal */

drivers/gpu/drm/vc4/vc4_debugfs.c

+3 −0
Original line number Diff line number Diff line
@@ -16,11 +16,14 @@ 
#include "vc4_regs.h"



static const struct drm_info_list vc4_debugfs_list[] = {

	{"bo_stats", vc4_bo_stats_debugfs, 0},

	{"hdmi_regs", vc4_hdmi_debugfs_regs, 0},

	{"hvs_regs", vc4_hvs_debugfs_regs, 0},

	{"crtc0_regs", vc4_crtc_debugfs_regs, 0, (void *)(uintptr_t)0},

	{"crtc1_regs", vc4_crtc_debugfs_regs, 0, (void *)(uintptr_t)1},

	{"crtc2_regs", vc4_crtc_debugfs_regs, 0, (void *)(uintptr_t)2},

	{"v3d_ident", vc4_v3d_debugfs_ident, 0},

	{"v3d_regs", vc4_v3d_debugfs_regs, 0},

};



#define VC4_DEBUGFS_ENTRIES ARRAY_SIZE(vc4_debugfs_list)

CRA Git | Maintained and supported by SUSTech CRA and CCSE