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