drivers/gpu/drm/sun4i/sun4i_crtc.c

   1 /*
   2  * Copyright (C) 2015 Free Electrons
   3  * Copyright (C) 2015 NextThing Co
   4  *
   5  * Maxime Ripard <maxime.ripard@free-electrons.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  */
  12
  13 #include <drm/drmP.h>
  14 #include <drm/drm_atomic_helper.h>
  15 #include <drm/drm_crtc.h>
  16 #include <drm/drm_crtc_helper.h>
  17 #include <drm/drm_modes.h>
  18
  19 #include <linux/clk-provider.h>
  20 #include <linux/ioport.h>
  21 #include <linux/of_address.h>
  22 #include <linux/of_graph.h>
  23 #include <linux/of_irq.h>
  24 #include <linux/regmap.h>
  25
  26 #include <video/videomode.h>
  27
  28 #include "sun4i_backend.h"
  29 #include "sun4i_crtc.h"
  30 #include "sun4i_drv.h"
  31 #include "sun4i_layer.h"
  32 #include "sun4i_tcon.h"
  33
  34 static void sun4i_crtc_atomic_begin(struct drm_crtc *crtc,
  35                                     struct drm_crtc_state *old_state)
  36 {
  37         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
  38         struct drm_device *dev = crtc->dev;
  39         unsigned long flags;
  40
  41         if (crtc->state->event) {
  42                 WARN_ON(drm_crtc_vblank_get(crtc) != 0);
  43
  44                 spin_lock_irqsave(&dev->event_lock, flags);
  45                 scrtc->event = crtc->state->event;
  46                 spin_unlock_irqrestore(&dev->event_lock, flags);
  47                 crtc->state->event = NULL;
  48          }
  49 }
  50
  51 static void sun4i_crtc_atomic_flush(struct drm_crtc *crtc,
  52                                     struct drm_crtc_state *old_state)
  53 {
  54         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
  55         struct drm_pending_vblank_event *event = crtc->state->event;
  56
  57         DRM_DEBUG_DRIVER("Committing plane changes\n");
  58
  59         sun4i_backend_commit(scrtc->backend);
  60
  61         if (event) {
  62                 crtc->state->event = NULL;
  63
  64                 spin_lock_irq(&crtc->dev->event_lock);
  65                 if (drm_crtc_vblank_get(crtc) == 0)
  66                         drm_crtc_arm_vblank_event(crtc, event);
  67                 else
  68                         drm_crtc_send_vblank_event(crtc, event);
  69                 spin_unlock_irq(&crtc->dev->event_lock);
  70         }
  71 }
  72
  73 static void sun4i_crtc_disable(struct drm_crtc *crtc)
  74 {
  75         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
  76
  77         DRM_DEBUG_DRIVER("Disabling the CRTC\n");
  78
  79         sun4i_tcon_disable(scrtc->tcon);
  80
  81         if (crtc->state->event && !crtc->state->active) {
  82                 spin_lock_irq(&crtc->dev->event_lock);
  83                 drm_crtc_send_vblank_event(crtc, crtc->state->event);
  84                 spin_unlock_irq(&crtc->dev->event_lock);
  85
  86                 crtc->state->event = NULL;
  87         }
  88 }
  89
  90 static void sun4i_crtc_enable(struct drm_crtc *crtc)
  91 {
  92         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
  93
  94         DRM_DEBUG_DRIVER("Enabling the CRTC\n");
  95
  96         sun4i_tcon_enable(scrtc->tcon);
  97 }
  98
  99 static const struct drm_crtc_helper_funcs sun4i_crtc_helper_funcs = {
 100         .atomic_begin   = sun4i_crtc_atomic_begin,
 101         .atomic_flush   = sun4i_crtc_atomic_flush,
 102         .disable        = sun4i_crtc_disable,
 103         .enable         = sun4i_crtc_enable,
 104 };
 105
 106 static int sun4i_crtc_enable_vblank(struct drm_crtc *crtc)
 107 {
 108         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 109
 110         DRM_DEBUG_DRIVER("Enabling VBLANK on crtc %p\n", crtc);
 111
 112         sun4i_tcon_enable_vblank(scrtc->tcon, true);
 113
 114         return 0;
 115 }
 116
 117 static void sun4i_crtc_disable_vblank(struct drm_crtc *crtc)
 118 {
 119         struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 120
 121         DRM_DEBUG_DRIVER("Disabling VBLANK on crtc %p\n", crtc);
 122
 123         sun4i_tcon_enable_vblank(scrtc->tcon, false);
 124 }
 125
 126 static const struct drm_crtc_funcs sun4i_crtc_funcs = {
 127         .atomic_destroy_state   = drm_atomic_helper_crtc_destroy_state,
 128         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 129         .destroy                = drm_crtc_cleanup,
 130         .page_flip              = drm_atomic_helper_page_flip,
 131         .reset                  = drm_atomic_helper_crtc_reset,
 132         .set_config             = drm_atomic_helper_set_config,
 133         .enable_vblank          = sun4i_crtc_enable_vblank,
 134         .disable_vblank         = sun4i_crtc_disable_vblank,
 135 };
 136
 137 struct sun4i_crtc *sun4i_crtc_init(struct drm_device *drm,
 138                                    struct sun4i_backend *backend,
 139                                    struct sun4i_tcon *tcon)
 140 {
 141         struct sun4i_crtc *scrtc;
 142         struct drm_plane *primary = NULL, *cursor = NULL;
 143         int ret, i;
 144
 145         scrtc = devm_kzalloc(drm->dev, sizeof(*scrtc), GFP_KERNEL);
 146         if (!scrtc)
 147                 return ERR_PTR(-ENOMEM);
 148         scrtc->backend = backend;
 149         scrtc->tcon = tcon;
 150
 151         /* Create our layers */
 152         scrtc->layers = sun4i_layers_init(drm, scrtc->backend);
 153         if (IS_ERR(scrtc->layers)) {
 154                 dev_err(drm->dev, "Couldn't create the planes\n");
 155                 return NULL;
 156         }
 157
 158         /* find primary and cursor planes for drm_crtc_init_with_planes */
 159         for (i = 0; scrtc->layers[i]; i++) {
 160                 struct sun4i_layer *layer = scrtc->layers[i];
 161
 162                 switch (layer->plane.type) {
 163                 case DRM_PLANE_TYPE_PRIMARY:
 164                         primary = &layer->plane;
 165                         break;
 166                 case DRM_PLANE_TYPE_CURSOR:
 167                         cursor = &layer->plane;
 168                         break;
 169                 default:
 170                         break;
 171                 }
 172         }
 173
 174         ret = drm_crtc_init_with_planes(drm, &scrtc->crtc,
 175                                         primary,
 176                                         cursor,
 177                                         &sun4i_crtc_funcs,
 178                                         NULL);
 179         if (ret) {
 180                 dev_err(drm->dev, "Couldn't init DRM CRTC\n");
 181                 return ERR_PTR(ret);
 182         }
 183
 184         drm_crtc_helper_add(&scrtc->crtc, &sun4i_crtc_helper_funcs);
 185
 186         /* Set crtc.port to output port node of the tcon */
 187         scrtc->crtc.port = of_graph_get_port_by_id(scrtc->tcon->dev->of_node,
 188                                                    1);
 189
 190         /* Set possible_crtcs to this crtc for overlay planes */
 191         for (i = 0; scrtc->layers[i]; i++) {
 192                 uint32_t possible_crtcs = BIT(drm_crtc_index(&scrtc->crtc));
 193                 struct sun4i_layer *layer = scrtc->layers[i];
 194
 195                 if (layer->plane.type == DRM_PLANE_TYPE_OVERLAY)
 196                         layer->plane.possible_crtcs = possible_crtcs;
 197         }
 198
 199         return scrtc;
 200 }