linux/drivers/media/platform/samsung/exynos-gsc/gsc-core.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2011 - 2012 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Samsung EXYNOS5 SoC series G-Scaler driver
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/bug.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/of.h>
#include <media/v4l2-ioctl.h>

#include "gsc-core.h"

static const struct gsc_fmt gsc_formats[] =;

const struct gsc_fmt *get_format(int index)
{}

const struct gsc_fmt *find_fmt(u32 *pixelformat, u32 *mbus_code, u32 index)
{}

void gsc_set_frame_size(struct gsc_frame *frame, int width, int height)
{}

int gsc_cal_prescaler_ratio(struct gsc_variant *var, u32 src, u32 dst,
								u32 *ratio)
{}

void gsc_get_prescaler_shfactor(u32 hratio, u32 vratio, u32 *sh)
{}

void gsc_check_src_scale_info(struct gsc_variant *var,
				struct gsc_frame *s_frame, u32 *wratio,
				 u32 tx, u32 ty, u32 *hratio)
{}

int gsc_enum_fmt(struct v4l2_fmtdesc *f)
{}

static int get_plane_info(struct gsc_frame *frm, u32 addr, u32 *index, u32 *ret_addr)
{}

void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm)
{}

int gsc_try_fmt_mplane(struct gsc_ctx *ctx, struct v4l2_format *f)
{}

int gsc_g_fmt_mplane(struct gsc_ctx *ctx, struct v4l2_format *f)
{}

void gsc_check_crop_change(u32 tmp_w, u32 tmp_h, u32 *w, u32 *h)
{}

int gsc_try_selection(struct gsc_ctx *ctx, struct v4l2_selection *s)
{}

int gsc_check_scaler_ratio(struct gsc_variant *var, int sw, int sh, int dw,
			   int dh, int rot, int out_path)
{}

int gsc_set_scaler_info(struct gsc_ctx *ctx)
{}

static int __gsc_s_ctrl(struct gsc_ctx *ctx, struct v4l2_ctrl *ctrl)
{}

static int gsc_s_ctrl(struct v4l2_ctrl *ctrl)
{}

static const struct v4l2_ctrl_ops gsc_ctrl_ops =;

int gsc_ctrls_create(struct gsc_ctx *ctx)
{}

void gsc_ctrls_delete(struct gsc_ctx *ctx)
{}

/* The color format (num_comp, num_planes) must be already configured. */
int gsc_prepare_addr(struct gsc_ctx *ctx, struct vb2_buffer *vb,
			struct gsc_frame *frame, struct gsc_addr *addr)
{}

static irqreturn_t gsc_irq_handler(int irq, void *priv)
{}

static struct gsc_pix_max gsc_v_100_max =;

static struct gsc_pix_max gsc_v_5250_max =;

static struct gsc_pix_max gsc_v_5420_max =;

static struct gsc_pix_max gsc_v_5433_max =;

static struct gsc_pix_min gsc_v_100_min =;

static struct gsc_pix_align gsc_v_100_align =;

static struct gsc_variant gsc_v_100_variant =;

static struct gsc_variant gsc_v_5250_variant =;

static struct gsc_variant gsc_v_5420_variant =;

static struct gsc_variant gsc_v_5433_variant =;

static struct gsc_driverdata gsc_v_100_drvdata =;

static struct gsc_driverdata gsc_v_5250_drvdata =;

static struct gsc_driverdata gsc_v_5420_drvdata =;

static struct gsc_driverdata gsc_5433_drvdata =;

static const struct of_device_id exynos_gsc_match[] =;
MODULE_DEVICE_TABLE(of, exynos_gsc_match);

static int gsc_probe(struct platform_device *pdev)
{}

static void gsc_remove(struct platform_device *pdev)
{}

#ifdef CONFIG_PM
static int gsc_m2m_suspend(struct gsc_dev *gsc)
{}

static void gsc_m2m_resume(struct gsc_dev *gsc)
{}

static int gsc_runtime_resume(struct device *dev)
{}

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

static const struct dev_pm_ops gsc_pm_ops =;

static struct platform_driver gsc_driver =;

module_platform_driver();

MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_LICENSE();