// SPDX-License-Identifier: GPL-2.0-only/* * Copyright (C) 2012 Avionic Design GmbH * Copyright (C) 2012-2016 NVIDIA CORPORATION.  All rights reserved. */ #include <linux/aperture.h>#include <linux/bitops.h>#include <linux/host1x.h>#include <linux/idr.h>#include <linux/iommu.h>#include <linux/module.h>#include <linux/platform_device.h>#include <linux/pm_runtime.h> #include <drm/clients/drm_client_setup.h>#include <drm/drm_atomic.h>#include <drm/drm_atomic_helper.h>#include <drm/drm_debugfs.h>#include <drm/drm_drv.h>#include <drm/drm_fourcc.h>#include <drm/drm_framebuffer.h>#include <drm/drm_ioctl.h>#include <drm/drm_prime.h>#include <drm/drm_print.h>#include <drm/drm_vblank.h> #if IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU)#include <asm/dma-iommu.h>#endif #include "dc.h"#include "drm.h"#include "gem.h"#include "uapi.h" #define DRIVER_NAME "tegra"#define DRIVER_DESC "NVIDIA Tegra graphics"#define DRIVER_MAJOR 1#define DRIVER_MINOR 0#define DRIVER_PATCHLEVEL 0 #define CARVEOUT_SZ SZ_64M#define CDMA_GATHER_FETCHES_MAX_NB 16383 static int tegra_atomic_check(struct drm_device *drm,			      struct drm_atomic_commit *state){	int err; 	err = drm_atomic_helper_check(drm, state);	if (err < 0)		return err; 	return tegra_display_hub_atomic_check(drm, state);} static const struct drm_mode_config_funcs tegra_drm_mode_config_funcs = {	.fb_create = tegra_fb_create,	.atomic_check = tegra_atomic_check,	.atomic_commit = drm_atomic_helper_commit,}; static void tegra_atomic_post_commit(struct drm_device *drm,				     struct drm_atomic_commit *old_state){	struct drm_crtc_state *old_crtc_state __maybe_unused;	struct drm_crtc *crtc;	unsigned int i; 	for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i)		tegra_crtc_atomic_post_commit(crtc, old_state);} static void tegra_atomic_commit_tail(struct drm_atomic_commit *old_state){	struct drm_device *drm = old_state->dev;	struct tegra_drm *tegra = drm->dev_private; 	if (tegra->hub) {		bool fence_cookie = dma_fence_begin_signalling(); 		drm_atomic_helper_commit_modeset_disables(drm, old_state);		tegra_display_hub_atomic_commit(drm, old_state);		drm_atomic_helper_commit_planes(drm, old_state, 0);		drm_atomic_helper_commit_modeset_enables(drm, old_state);		drm_atomic_helper_commit_hw_done(old_state);		dma_fence_end_signalling(fence_cookie);		drm_atomic_helper_wait_for_vblanks(drm, old_state);		drm_atomic_helper_cleanup_planes(drm, old_state);	} else {		drm_atomic_helper_commit_tail_rpm(old_state);	} 	tegra_atomic_post_commit(drm, old_state);} static const struct drm_mode_config_helper_funcstegra_drm_mode_config_helpers = {	.atomic_commit_tail = tegra_atomic_commit_tail,}; static int tegra_drm_open(struct drm_device *drm, struct drm_file *filp){	struct tegra_drm_file *fpriv; 	fpriv = kzalloc_obj(*fpriv);	if (!fpriv)		return -ENOMEM; 	idr_init_base(&fpriv->legacy_contexts, 1);	xa_init_flags(&fpriv->contexts, XA_FLAGS_ALLOC1);	xa_init(&fpriv->syncpoints);	mutex_init(&fpriv->lock);	filp->driver_priv = fpriv; 	return 0;} static void tegra_drm_context_free(struct tegra_drm_context *context){	context->client->ops->close_channel(context);	pm_runtime_put(context->client->base.dev);	kfree(context);} static int host1x_reloc_copy_from_user(struct host1x_reloc *dest,				       struct drm_tegra_reloc __user *src,				       struct drm_device *drm,				       struct drm_file *file){	u32 cmdbuf, target;	int err; 	err = get_user(cmdbuf, &src->cmdbuf.handle);	if (err < 0)		return err; 	err = get_user(dest->cmdbuf.offset, &src->cmdbuf.offset);	if (err < 0)		return err; 	err = get_user(target, &src->target.handle);	if (err < 0)		return err; 	err = get_user(dest->target.offset, &src->target.offset);	if (err < 0)		return err; 	err = get_user(dest->shift, &src->shift);	if (err < 0)		return err; 	dest->flags = HOST1X_RELOC_READ | HOST1X_RELOC_WRITE; 	dest->cmdbuf.bo = tegra_gem_lookup(file, cmdbuf);	if (!dest->cmdbuf.bo)		return -ENOENT; 	dest->target.bo = tegra_gem_lookup(file, target);	if (!dest->target.bo)		return -ENOENT; 	return 0;} int tegra_drm_submit(struct tegra_drm_context *context,		     struct drm_tegra_submit *args, struct drm_device *drm,		     struct drm_file *file){	struct host1x_client *client = &context->client->base;	unsigned int num_cmdbufs = args->num_cmdbufs;	unsigned int num_relocs = args->num_relocs;	struct drm_tegra_cmdbuf __user *user_cmdbufs;	struct drm_tegra_reloc __user *user_relocs;	struct drm_tegra_syncpt __user *user_syncpt;	struct drm_tegra_syncpt syncpt;	struct host1x *host1x = dev_get_drvdata(drm->dev->parent);	struct drm_gem_object **refs;	struct host1x_syncpt *sp = NULL;	struct host1x_job *job;	unsigned int num_refs;	int err; 	user_cmdbufs = u64_to_user_ptr(args->cmdbufs);	user_relocs = u64_to_user_ptr(args->relocs);	user_syncpt = u64_to_user_ptr(args->syncpts); 	/* We don't yet support other than one syncpt_incr struct per submit */	if (args->num_syncpts != 1)		return -EINVAL; 	/* We don't yet support waitchks */	if (args->num_waitchks != 0)		return -EINVAL; 	job = host1x_job_alloc(context->channel, args->num_cmdbufs,			       args->num_relocs, false);	if (!job)		return -ENOMEM; 	job->num_relocs = args->num_relocs;	job->client = client;	job->class = client->class;	job->serialize = true;	job->syncpt_recovery = true; 	/*	 * Track referenced BOs so that they can be unreferenced after the	 * submission is complete.	 */	num_refs = num_cmdbufs + num_relocs * 2; 	refs = kmalloc_objs(*refs, num_refs);	if (!refs) {		err = -ENOMEM;		goto put;	} 	/* reuse as an iterator later */	num_refs = 0; 	while (num_cmdbufs) {		struct drm_tegra_cmdbuf cmdbuf;		struct host1x_bo *bo;		struct tegra_bo *obj;		u64 offset; 		if (copy_from_user(&cmdbuf, user_cmdbufs, sizeof(cmdbuf))) {			err = -EFAULT;			goto fail;		} 		/*		 * The maximum number of CDMA gather fetches is 16383, a higher		 * value means the words count is malformed.		 */		if (cmdbuf.words > CDMA_GATHER_FETCHES_MAX_NB) {			err = -EINVAL;			goto fail;		} 		bo = tegra_gem_lookup(file, cmdbuf.handle);		if (!bo) {			err = -ENOENT;			goto fail;		} 		offset = (u64)cmdbuf.offset + (u64)cmdbuf.words * sizeof(u32);		obj = host1x_to_tegra_bo(bo);		refs[num_refs++] = &obj->gem; 		/*		 * Gather buffer base address must be 4-bytes aligned,		 * unaligned offset is malformed and cause commands stream		 * corruption on the buffer address relocation.		 */		if (offset & 3 || offset > obj->gem.size) {			err = -EINVAL;			goto fail;		} 		host1x_job_add_gather(job, bo, cmdbuf.words, cmdbuf.offset);		num_cmdbufs--;		user_cmdbufs++;	} 	/* copy and resolve relocations from submit */	while (num_relocs--) {		struct host1x_reloc *reloc;		struct tegra_bo *obj; 		err = host1x_reloc_copy_from_user(&job->relocs[num_relocs],						  &user_relocs[num_relocs], drm,						  file);		if (err < 0)			goto fail; 		reloc = &job->relocs[num_relocs];		obj = host1x_to_tegra_bo(reloc->cmdbuf.bo);		refs[num_refs++] = &obj->gem; 		/*		 * The unaligned cmdbuf offset will cause an unaligned write		 * during of the relocations patching, corrupting the commands		 * stream.		 */		if (reloc->cmdbuf.offset & 3 ||		    reloc->cmdbuf.offset >= obj->gem.size) {			err = -EINVAL;			goto fail;		} 		obj = host1x_to_tegra_bo(reloc->target.bo);		refs[num_refs++] = &obj->gem; 		if (reloc->target.offset >= obj->gem.size) {			err = -EINVAL;			goto fail;		}	} 	if (copy_from_user(&syncpt, user_syncpt, sizeof(syncpt))) {		err = -EFAULT;		goto fail;	} 	/* Syncpoint ref will be dropped on job release. */	sp = host1x_syncpt_get_by_id(host1x, syncpt.id);	if (!sp) {		err = -ENOENT;		goto fail;	} 	job->is_addr_reg = context->client->ops->is_addr_reg;	job->is_valid_class = context->client->ops->is_valid_class;	job->syncpt_incrs = syncpt.incrs;	job->syncpt = sp;	job->timeout = 10000; 	if (args->timeout && args->timeout < 10000)		job->timeout = args->timeout; 	err = host1x_job_pin(job, context->client->base.dev);	if (err)		goto fail; 	err = host1x_job_submit(job);	if (err) {		host1x_job_unpin(job);		goto fail;	} 	args->fence = job->syncpt_end; fail:	while (num_refs--)		drm_gem_object_put(refs[num_refs]); 	kfree(refs); put:	host1x_job_put(job);	return err;}  #ifdef CONFIG_DRM_TEGRA_STAGINGstatic int tegra_gem_create(struct drm_device *drm, void *data,			    struct drm_file *file){	struct drm_tegra_gem_create *args = data;	struct tegra_bo *bo; 	bo = tegra_bo_create_with_handle(file, drm, args->size, args->flags,					 &args->handle);	if (IS_ERR(bo))		return PTR_ERR(bo); 	return 0;} static int tegra_gem_mmap(struct drm_device *drm, void *data,			  struct drm_file *file){	struct drm_tegra_gem_mmap *args = data;	struct drm_gem_object *gem;	struct tegra_bo *bo; 	gem = drm_gem_object_lookup(file, args->handle);	if (!gem)		return -EINVAL; 	bo = to_tegra_bo(gem); 	args->offset = drm_vma_node_offset_addr(&bo->gem.vma_node); 	drm_gem_object_put(gem); 	return 0;} static int tegra_syncpt_read(struct drm_device *drm, void *data,			     struct drm_file *file){	struct host1x *host = dev_get_drvdata(drm->dev->parent);	struct drm_tegra_syncpt_read *args = data;	struct host1x_syncpt *sp; 	sp = host1x_syncpt_get_by_id_noref(host, args->id);	if (!sp)		return -EINVAL; 	args->value = host1x_syncpt_read_min(sp);	return 0;} static int tegra_syncpt_incr(struct drm_device *drm, void *data,			     struct drm_file *file){	struct host1x *host1x = dev_get_drvdata(drm->dev->parent);	struct drm_tegra_syncpt_incr *args = data;	struct host1x_syncpt *sp; 	sp = host1x_syncpt_get_by_id_noref(host1x, args->id);	if (!sp)		return -EINVAL; 	return host1x_syncpt_incr(sp);} static int tegra_syncpt_wait(struct drm_device *drm, void *data,			     struct drm_file *file){	struct host1x *host1x = dev_get_drvdata(drm->dev->parent);	struct drm_tegra_syncpt_wait *args = data;	struct host1x_syncpt *sp; 	sp = host1x_syncpt_get_by_id_noref(host1x, args->id);	if (!sp)		return -EINVAL; 	return host1x_syncpt_wait(sp, args->thresh,				  msecs_to_jiffies(args->timeout),				  &args->value);} static int tegra_client_open(struct tegra_drm_file *fpriv,			     struct tegra_drm_client *client,			     struct tegra_drm_context *context){	int err; 	err = pm_runtime_resume_and_get(client->base.dev);	if (err)		return err; 	err = client->ops->open_channel(client, context);	if (err < 0) {		pm_runtime_put(client->base.dev);		return err;	} 	err = idr_alloc(&fpriv->legacy_contexts, context, 1, 0, GFP_KERNEL);	if (err < 0) {		client->ops->close_channel(context);		pm_runtime_put(client->base.dev);		return err;	} 	context->client = client;	context->id = err; 	return 0;} static int tegra_open_channel(struct drm_device *drm, void *data,			      struct drm_file *file){	struct tegra_drm_file *fpriv = file->driver_priv;	struct tegra_drm *tegra = drm->dev_private;	struct drm_tegra_open_channel *args = data;	struct tegra_drm_context *context;	struct tegra_drm_client *client;	int err = -ENODEV; 	context = kzalloc_obj(*context);	if (!context)		return -ENOMEM; 	mutex_lock(&fpriv->lock); 	list_for_each_entry(client, &tegra->clients, list)		if (client->base.class == args->client) {			err = tegra_client_open(fpriv, client, context);			if (err < 0)				break; 			args->context = context->id;			break;		} 	if (err < 0)		kfree(context); 	mutex_unlock(&fpriv->lock);	return err;} static int tegra_close_channel(struct drm_device *drm, void *data,			       struct drm_file *file){	struct tegra_drm_file *fpriv = file->driver_priv;	struct drm_tegra_close_channel *args = data;	struct tegra_drm_context *context;	int err = 0; 	mutex_lock(&fpriv->lock); 

Lines 1–500 of 1462. Load more