cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

tve200_drv.c (6834B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
      4 * Parts of this file were based on sources as follows:
      5 *
      6 * Copyright (C) 2006-2008 Intel Corporation
      7 * Copyright (C) 2007 Amos Lee <amos_lee@storlinksemi.com>
      8 * Copyright (C) 2007 Dave Airlie <airlied@linux.ie>
      9 * Copyright (C) 2011 Texas Instruments
     10 * Copyright (C) 2017 Eric Anholt
     11 */
     12
     13/**
     14 * DOC: Faraday TV Encoder TVE200 DRM Driver
     15 *
     16 * The Faraday TV Encoder TVE200 is also known as the Gemini TV Interface
     17 * Controller (TVC) and is found in the Gemini Chipset from Storlink
     18 * Semiconductor (later Storm Semiconductor, later Cortina Systems)
     19 * but also in the Grain Media GM8180 chipset. On the Gemini the module
     20 * is connected to 8 data lines and a single clock line, comprising an
     21 * 8-bit BT.656 interface.
     22 *
     23 * This is a very basic YUV display driver. The datasheet specifies that
     24 * it supports the ITU BT.656 standard. It requires a 27 MHz clock which is
     25 * the hallmark of any TV encoder supporting both PAL and NTSC.
     26 *
     27 * This driver exposes a standard KMS interface for this TV encoder.
     28 */
     29
     30#include <linux/clk.h>
     31#include <linux/dma-buf.h>
     32#include <linux/irq.h>
     33#include <linux/io.h>
     34#include <linux/module.h>
     35#include <linux/platform_device.h>
     36#include <linux/shmem_fs.h>
     37#include <linux/slab.h>
     38
     39#include <drm/drm_atomic_helper.h>
     40#include <drm/drm_bridge.h>
     41#include <drm/drm_drv.h>
     42#include <drm/drm_fb_cma_helper.h>
     43#include <drm/drm_fb_helper.h>
     44#include <drm/drm_gem_cma_helper.h>
     45#include <drm/drm_gem_framebuffer_helper.h>
     46#include <drm/drm_module.h>
     47#include <drm/drm_of.h>
     48#include <drm/drm_panel.h>
     49#include <drm/drm_probe_helper.h>
     50#include <drm/drm_vblank.h>
     51
     52#include "tve200_drm.h"
     53
     54#define DRIVER_DESC      "DRM module for Faraday TVE200"
     55
     56static const struct drm_mode_config_funcs mode_config_funcs = {
     57	.fb_create = drm_gem_fb_create,
     58	.atomic_check = drm_atomic_helper_check,
     59	.atomic_commit = drm_atomic_helper_commit,
     60};
     61
     62static int tve200_modeset_init(struct drm_device *dev)
     63{
     64	struct drm_mode_config *mode_config;
     65	struct tve200_drm_dev_private *priv = dev->dev_private;
     66	struct drm_panel *panel;
     67	struct drm_bridge *bridge;
     68	int ret = 0;
     69
     70	drm_mode_config_init(dev);
     71	mode_config = &dev->mode_config;
     72	mode_config->funcs = &mode_config_funcs;
     73	mode_config->min_width = 352;
     74	mode_config->max_width = 720;
     75	mode_config->min_height = 240;
     76	mode_config->max_height = 576;
     77
     78	ret = drm_of_find_panel_or_bridge(dev->dev->of_node,
     79					  0, 0, &panel, &bridge);
     80	if (ret && ret != -ENODEV)
     81		return ret;
     82	if (panel) {
     83		bridge = drm_panel_bridge_add_typed(panel,
     84						    DRM_MODE_CONNECTOR_Unknown);
     85		if (IS_ERR(bridge)) {
     86			ret = PTR_ERR(bridge);
     87			goto out_bridge;
     88		}
     89	} else {
     90		/*
     91		 * TODO: when we are using a different bridge than a panel
     92		 * (such as a dumb VGA connector) we need to devise a different
     93		 * method to get the connector out of the bridge.
     94		 */
     95		dev_err(dev->dev, "the bridge is not a panel\n");
     96		goto out_bridge;
     97	}
     98
     99	ret = tve200_display_init(dev);
    100	if (ret) {
    101		dev_err(dev->dev, "failed to init display\n");
    102		goto out_bridge;
    103	}
    104
    105	ret = drm_simple_display_pipe_attach_bridge(&priv->pipe,
    106						    bridge);
    107	if (ret) {
    108		dev_err(dev->dev, "failed to attach bridge\n");
    109		goto out_bridge;
    110	}
    111
    112	priv->panel = panel;
    113	priv->connector = drm_panel_bridge_connector(bridge);
    114	priv->bridge = bridge;
    115
    116	dev_info(dev->dev, "attached to panel %s\n",
    117		 dev_name(panel->dev));
    118
    119	ret = drm_vblank_init(dev, 1);
    120	if (ret) {
    121		dev_err(dev->dev, "failed to init vblank\n");
    122		goto out_bridge;
    123	}
    124
    125	drm_mode_config_reset(dev);
    126	drm_kms_helper_poll_init(dev);
    127
    128	goto finish;
    129
    130out_bridge:
    131	if (panel)
    132		drm_panel_bridge_remove(bridge);
    133	drm_mode_config_cleanup(dev);
    134finish:
    135	return ret;
    136}
    137
    138DEFINE_DRM_GEM_CMA_FOPS(drm_fops);
    139
    140static const struct drm_driver tve200_drm_driver = {
    141	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
    142	.ioctls = NULL,
    143	.fops = &drm_fops,
    144	.name = "tve200",
    145	.desc = DRIVER_DESC,
    146	.date = "20170703",
    147	.major = 1,
    148	.minor = 0,
    149	.patchlevel = 0,
    150	DRM_GEM_CMA_DRIVER_OPS,
    151};
    152
    153static int tve200_probe(struct platform_device *pdev)
    154{
    155	struct device *dev = &pdev->dev;
    156	struct tve200_drm_dev_private *priv;
    157	struct drm_device *drm;
    158	struct resource *res;
    159	int irq;
    160	int ret;
    161
    162	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
    163	if (!priv)
    164		return -ENOMEM;
    165
    166	drm = drm_dev_alloc(&tve200_drm_driver, dev);
    167	if (IS_ERR(drm))
    168		return PTR_ERR(drm);
    169	platform_set_drvdata(pdev, drm);
    170	priv->drm = drm;
    171	drm->dev_private = priv;
    172
    173	/* Clock the silicon so we can access the registers */
    174	priv->pclk = devm_clk_get(dev, "PCLK");
    175	if (IS_ERR(priv->pclk)) {
    176		dev_err(dev, "unable to get PCLK\n");
    177		ret = PTR_ERR(priv->pclk);
    178		goto dev_unref;
    179	}
    180	ret = clk_prepare_enable(priv->pclk);
    181	if (ret) {
    182		dev_err(dev, "failed to enable PCLK\n");
    183		goto dev_unref;
    184	}
    185
    186	/* This clock is for the pixels (27MHz) */
    187	priv->clk = devm_clk_get(dev, "TVE");
    188	if (IS_ERR(priv->clk)) {
    189		dev_err(dev, "unable to get TVE clock\n");
    190		ret = PTR_ERR(priv->clk);
    191		goto clk_disable;
    192	}
    193
    194	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    195	priv->regs = devm_ioremap_resource(dev, res);
    196	if (IS_ERR(priv->regs)) {
    197		dev_err(dev, "%s failed mmio\n", __func__);
    198		ret = -EINVAL;
    199		goto clk_disable;
    200	}
    201
    202	irq = platform_get_irq(pdev, 0);
    203	if (irq < 0) {
    204		ret = irq;
    205		goto clk_disable;
    206	}
    207
    208	/* turn off interrupts before requesting the irq */
    209	writel(0, priv->regs + TVE200_INT_EN);
    210
    211	ret = devm_request_irq(dev, irq, tve200_irq, 0, "tve200", priv);
    212	if (ret) {
    213		dev_err(dev, "failed to request irq %d\n", ret);
    214		goto clk_disable;
    215	}
    216
    217	ret = tve200_modeset_init(drm);
    218	if (ret)
    219		goto clk_disable;
    220
    221	ret = drm_dev_register(drm, 0);
    222	if (ret < 0)
    223		goto clk_disable;
    224
    225	/*
    226	 * Passing in 16 here will make the RGB565 mode the default
    227	 * Passing in 32 will use XRGB8888 mode
    228	 */
    229	drm_fbdev_generic_setup(drm, 16);
    230
    231	return 0;
    232
    233clk_disable:
    234	clk_disable_unprepare(priv->pclk);
    235dev_unref:
    236	drm_dev_put(drm);
    237	return ret;
    238}
    239
    240static int tve200_remove(struct platform_device *pdev)
    241{
    242	struct drm_device *drm = platform_get_drvdata(pdev);
    243	struct tve200_drm_dev_private *priv = drm->dev_private;
    244
    245	drm_dev_unregister(drm);
    246	if (priv->panel)
    247		drm_panel_bridge_remove(priv->bridge);
    248	drm_mode_config_cleanup(drm);
    249	clk_disable_unprepare(priv->pclk);
    250	drm_dev_put(drm);
    251
    252	return 0;
    253}
    254
    255static const struct of_device_id tve200_of_match[] = {
    256	{
    257		.compatible = "faraday,tve200",
    258	},
    259	{},
    260};
    261
    262static struct platform_driver tve200_driver = {
    263	.driver = {
    264		.name           = "tve200",
    265		.of_match_table = of_match_ptr(tve200_of_match),
    266	},
    267	.probe = tve200_probe,
    268	.remove = tve200_remove,
    269};
    270drm_module_platform_driver(tve200_driver);
    271
    272MODULE_DESCRIPTION(DRIVER_DESC);
    273MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
    274MODULE_LICENSE("GPL");