linux/drivers/gpu/drm/omapdrm/omap_drv.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/
 * Author: Rob Clark <[email protected]>
 */

#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/sort.h>
#include <linux/sys_soc.h>

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_bridge.h>
#include <drm/drm_bridge_connector.h>
#include <drm/drm_drv.h>
#include <drm/drm_file.h>
#include <drm/drm_ioctl.h>
#include <drm/drm_panel.h>
#include <drm/drm_prime.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_vblank.h>

#include "omap_dmm_tiler.h"
#include "omap_drv.h"
#include "omap_fbdev.h"

#define DRIVER_NAME …
#define DRIVER_DESC …
#define DRIVER_DATE …
#define DRIVER_MAJOR …
#define DRIVER_MINOR …
#define DRIVER_PATCHLEVEL …

/*
 * mode config funcs
 */

/* Notes about mapping DSS and DRM entities:
 *    CRTC:        overlay
 *    encoder:     manager.. with some extension to allow one primary CRTC
 *                 and zero or more video CRTC's to be mapped to one encoder?
 *    connector:   dssdev.. manager can be attached/detached from different
 *                 devices
 */

static void omap_atomic_wait_for_completion(struct drm_device *dev,
					    struct drm_atomic_state *old_state)
{ … }

static void omap_atomic_commit_tail(struct drm_atomic_state *old_state)
{ … }

static int drm_atomic_state_normalized_zpos_cmp(const void *a, const void *b)
{ … }

/*
 * This replaces the drm_atomic_normalize_zpos to handle the dual overlay case.
 *
 * Since both halves need to be 'appear' side by side the zpos is
 * recalculated when dealing with dual overlay cases so that the other
 * planes zpos is consistent.
 */
static int omap_atomic_update_normalize_zpos(struct drm_device *dev,
					     struct drm_atomic_state *state)
{ … }

static int omap_atomic_check(struct drm_device *dev,
			     struct drm_atomic_state *state)
{ … }

static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs = …;

static const struct drm_mode_config_funcs omap_mode_config_funcs = …;

/* Global/shared object state funcs */

/*
 * This is a helper that returns the private state currently in operation.
 * Note that this would return the "old_state" if called in the atomic check
 * path, and the "new_state" after the atomic swap has been done.
 */
struct omap_global_state *
omap_get_existing_global_state(struct omap_drm_private *priv)
{ … }

/*
 * This acquires the modeset lock set aside for global state, creates
 * a new duplicated private object state.
 */
struct omap_global_state *__must_check
omap_get_global_state(struct drm_atomic_state *s)
{ … }

static struct drm_private_state *
omap_global_duplicate_state(struct drm_private_obj *obj)
{ … }

static void omap_global_destroy_state(struct drm_private_obj *obj,
				      struct drm_private_state *state)
{ … }

static const struct drm_private_state_funcs omap_global_state_funcs = …;

static int omap_global_obj_init(struct drm_device *dev)
{ … }

static void omap_global_obj_fini(struct omap_drm_private *priv)
{ … }

static void omap_disconnect_pipelines(struct drm_device *ddev)
{ … }

static int omap_connect_pipelines(struct drm_device *ddev)
{ … }

static int omap_compare_pipelines(const void *a, const void *b)
{ … }

static int omap_modeset_init_properties(struct drm_device *dev)
{ … }

static int omap_display_id(struct omap_dss_device *output)
{ … }

static int omap_modeset_init(struct drm_device *dev)
{ … }

static void omap_modeset_fini(struct drm_device *ddev)
{ … }

/*
 * drm ioctl funcs
 */


static int ioctl_get_param(struct drm_device *dev, void *data,
		struct drm_file *file_priv)
{ … }

#define OMAP_BO_USER_MASK …

static int ioctl_gem_new(struct drm_device *dev, void *data,
		struct drm_file *file_priv)
{ … }

static int ioctl_gem_info(struct drm_device *dev, void *data,
		struct drm_file *file_priv)
{ … }

static const struct drm_ioctl_desc ioctls[DRM_COMMAND_END - DRM_COMMAND_BASE] = …;

/*
 * drm driver funcs
 */

static int dev_open(struct drm_device *dev, struct drm_file *file)
{ … }

DEFINE_DRM_GEM_FOPS(omapdriver_fops);

static const struct drm_driver omap_drm_driver = …;

static const struct soc_device_attribute omapdrm_soc_devices[] = …;

static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
{ … }

static void omapdrm_cleanup(struct omap_drm_private *priv)
{ … }

static int pdev_probe(struct platform_device *pdev)
{ … }

static void pdev_remove(struct platform_device *pdev)
{ … }

static void pdev_shutdown(struct platform_device *pdev)
{ … }

#ifdef CONFIG_PM_SLEEP
static int omap_drm_suspend(struct device *dev)
{ … }

static int omap_drm_resume(struct device *dev)
{ … }
#endif

static SIMPLE_DEV_PM_OPS(omapdrm_pm_ops, omap_drm_suspend, omap_drm_resume);

static struct platform_driver pdev = …;

static struct platform_driver * const drivers[] = …;

static int __init omap_drm_init(void)
{ … }

static void __exit omap_drm_fini(void)
{ … }

module_init(…) …;
module_exit(omap_drm_fini);

MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_ALIAS(…) …;
MODULE_LICENSE(…) …;