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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2009 Nokia Corporation
 * Author: Tomi Valkeinen <[email protected]>
 *
 * Some code and ideas taken from drivers/video/omap/ driver
 * by Imre Deak.
 */

#define DSS_SUBSYS_NAME …

#include <linux/debugfs.h>
#include <linux/dma-mapping.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/export.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/seq_file.h>
#include <linux/clk.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>
#include <linux/gfp.h>
#include <linux/sizes.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/of_graph.h>
#include <linux/regulator/consumer.h>
#include <linux/suspend.h>
#include <linux/component.h>
#include <linux/sys_soc.h>

#include "omapdss.h"
#include "dss.h"

struct dss_reg { … };

#define DSS_REG(idx) …

#define DSS_REVISION …
#define DSS_SYSCONFIG …
#define DSS_SYSSTATUS …
#define DSS_CONTROL …
#define DSS_SDI_CONTROL …
#define DSS_PLL_CONTROL …
#define DSS_SDI_STATUS …

#define REG_GET(dss, idx, start, end) …

#define REG_FLD_MOD(dss, idx, val, start, end) …

struct dss_ops { … };

struct dss_features { … };

static const char * const dss_generic_clk_source_names[] = …;

static inline void dss_write_reg(struct dss_device *dss,
				 const struct dss_reg idx, u32 val)
{ … }

static inline u32 dss_read_reg(struct dss_device *dss, const struct dss_reg idx)
{ … }

#define SR …
#define RR …

static void dss_save_context(struct dss_device *dss)
{ … }

static void dss_restore_context(struct dss_device *dss)
{ … }

#undef SR
#undef RR

void dss_ctrl_pll_enable(struct dss_pll *pll, bool enable)
{ … }

static int dss_ctrl_pll_set_control_mux(struct dss_device *dss,
					enum dss_clk_source clk_src,
					enum omap_channel channel)
{ … }

void dss_sdi_init(struct dss_device *dss, int datapairs)
{ … }

int dss_sdi_enable(struct dss_device *dss)
{ … }

void dss_sdi_disable(struct dss_device *dss)
{ … }

const char *dss_get_clk_source_name(enum dss_clk_source clk_src)
{ … }

static void dss_dump_clocks(struct dss_device *dss, struct seq_file *s)
{ … }

static int dss_dump_regs(struct seq_file *s, void *p)
{ … }

static int dss_debug_dump_clocks(struct seq_file *s, void *p)
{ … }

static int dss_get_channel_index(enum omap_channel channel)
{ … }

static void dss_select_dispc_clk_source(struct dss_device *dss,
					enum dss_clk_source clk_src)
{ … }

void dss_select_dsi_clk_source(struct dss_device *dss, int dsi_module,
			       enum dss_clk_source clk_src)
{ … }

static int dss_lcd_clk_mux_dra7(struct dss_device *dss,
				enum omap_channel channel,
				enum dss_clk_source clk_src)
{ … }

static int dss_lcd_clk_mux_omap5(struct dss_device *dss,
				 enum omap_channel channel,
				 enum dss_clk_source clk_src)
{ … }

static int dss_lcd_clk_mux_omap4(struct dss_device *dss,
				 enum omap_channel channel,
				 enum dss_clk_source clk_src)
{ … }

void dss_select_lcd_clk_source(struct dss_device *dss,
			       enum omap_channel channel,
			       enum dss_clk_source clk_src)
{ … }

enum dss_clk_source dss_get_dispc_clk_source(struct dss_device *dss)
{ … }

enum dss_clk_source dss_get_dsi_clk_source(struct dss_device *dss,
					   int dsi_module)
{ … }

enum dss_clk_source dss_get_lcd_clk_source(struct dss_device *dss,
					   enum omap_channel channel)
{ … }

bool dss_div_calc(struct dss_device *dss, unsigned long pck,
		  unsigned long fck_min, dss_div_calc_func func, void *data)
{ … }

int dss_set_fck_rate(struct dss_device *dss, unsigned long rate)
{ … }

unsigned long dss_get_dispc_clk_rate(struct dss_device *dss)
{ … }

unsigned long dss_get_max_fck_rate(struct dss_device *dss)
{ … }

static int dss_setup_default_clock(struct dss_device *dss)
{ … }

void dss_set_venc_output(struct dss_device *dss, enum omap_dss_venc_type type)
{ … }

void dss_set_dac_pwrdn_bgz(struct dss_device *dss, bool enable)
{ … }

void dss_select_hdmi_venc_clk_source(struct dss_device *dss,
				     enum dss_hdmi_venc_clk_source_select src)
{ … }

static int dss_dpi_select_source_omap2_omap3(struct dss_device *dss, int port,
					     enum omap_channel channel)
{ … }

static int dss_dpi_select_source_omap4(struct dss_device *dss, int port,
				       enum omap_channel channel)
{ … }

static int dss_dpi_select_source_omap5(struct dss_device *dss, int port,
				       enum omap_channel channel)
{ … }

static int dss_dpi_select_source_dra7xx(struct dss_device *dss, int port,
					enum omap_channel channel)
{ … }

int dss_dpi_select_source(struct dss_device *dss, int port,
			  enum omap_channel channel)
{ … }

static int dss_get_clocks(struct dss_device *dss)
{ … }

static void dss_put_clocks(struct dss_device *dss)
{ … }

int dss_runtime_get(struct dss_device *dss)
{ … }

void dss_runtime_put(struct dss_device *dss)
{ … }

struct dss_device *dss_get_device(struct device *dev)
{ … }

/* DEBUGFS */
#if defined(CONFIG_OMAP2_DSS_DEBUGFS)
static int dss_initialize_debugfs(struct dss_device *dss)
{ … }

static void dss_uninitialize_debugfs(struct dss_device *dss)
{ … }

struct dss_debugfs_entry { … };

static int dss_debug_open(struct inode *inode, struct file *file)
{ … }

static const struct file_operations dss_debug_fops = …;

struct dss_debugfs_entry *
dss_debugfs_create_file(struct dss_device *dss, const char *name,
			int (*show_fn)(struct seq_file *s, void *data),
			void *data)
{ … }

void dss_debugfs_remove_file(struct dss_debugfs_entry *entry)
{ … }

#else /* CONFIG_OMAP2_DSS_DEBUGFS */
static inline int dss_initialize_debugfs(struct dss_device *dss)
{
	return 0;
}
static inline void dss_uninitialize_debugfs(struct dss_device *dss)
{
}
#endif /* CONFIG_OMAP2_DSS_DEBUGFS */

static const struct dss_ops dss_ops_omap2_omap3 = …;

static const struct dss_ops dss_ops_omap4 = …;

static const struct dss_ops dss_ops_omap5 = …;

static const struct dss_ops dss_ops_dra7 = …;

static const enum omap_display_type omap2plus_ports[] = …;

static const enum omap_display_type omap34xx_ports[] = …;

static const enum omap_display_type dra7xx_ports[] = …;

static const enum omap_dss_output_id omap2_dss_supported_outputs[] = …;

static const enum omap_dss_output_id omap3430_dss_supported_outputs[] = …;

static const enum omap_dss_output_id omap3630_dss_supported_outputs[] = …;

static const enum omap_dss_output_id am43xx_dss_supported_outputs[] = …;

static const enum omap_dss_output_id omap4_dss_supported_outputs[] = …;

static const enum omap_dss_output_id omap5_dss_supported_outputs[] = …;

static const struct dss_features omap24xx_dss_feats = …;

static const struct dss_features omap34xx_dss_feats = …;

static const struct dss_features omap3630_dss_feats = …;

static const struct dss_features omap44xx_dss_feats = …;

static const struct dss_features omap54xx_dss_feats = …;

static const struct dss_features am43xx_dss_feats = …;

static const struct dss_features dra7xx_dss_feats = …;

static void __dss_uninit_ports(struct dss_device *dss, unsigned int num_ports)
{ … }

static int dss_init_ports(struct dss_device *dss)
{ … }

static void dss_uninit_ports(struct dss_device *dss)
{ … }

static int dss_video_pll_probe(struct dss_device *dss)
{ … }

/* DSS HW IP initialisation */
static const struct of_device_id dss_of_match[] = …;
MODULE_DEVICE_TABLE(of, dss_of_match);

static const struct soc_device_attribute dss_soc_devices[] = …;

static int dss_bind(struct device *dev)
{ … }

static void dss_unbind(struct device *dev)
{ … }

static const struct component_master_ops dss_component_ops = …;

struct dss_component_match_data { … };

static int dss_add_child_component(struct device *dev, void *data)
{ … }

static int dss_probe_hardware(struct dss_device *dss)
{ … }

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

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

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

static __maybe_unused int dss_runtime_suspend(struct device *dev)
{ … }

static __maybe_unused int dss_runtime_resume(struct device *dev)
{ … }

static const struct dev_pm_ops dss_pm_ops = …;

struct platform_driver omap_dsshw_driver = …;

/* INIT */
static struct platform_driver * const omap_dss_drivers[] = …;

int __init omap_dss_init(void)
{ … }

void omap_dss_exit(void)
{ … }