display/komeda/komeda_kms.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
0004  * Author: James.Qian.Wang <james.qian.wang@arm.com>
0005  *
0006  */
0007 #include <linux/component.h>
0008 #include <linux/interrupt.h>
0009
0010 #include <drm/drm_atomic.h>
0011 #include <drm/drm_atomic_helper.h>
0012 #include <drm/drm_drv.h>
0013 #include <drm/drm_fb_helper.h>
0014 #include <drm/drm_gem_cma_helper.h>
0015 #include <drm/drm_gem_framebuffer_helper.h>
0016 #include <drm/drm_managed.h>
0017 #include <drm/drm_probe_helper.h>
0018 #include <drm/drm_vblank.h>
0019
0020 #include "komeda_dev.h"
0021 #include "komeda_framebuffer.h"
0022 #include "komeda_kms.h"
0023
0024 DEFINE_DRM_GEM_CMA_FOPS(komeda_cma_fops);
0025
0026 static int komeda_gem_cma_dumb_create(struct drm_file *file,
0027                       struct drm_device *dev,
0028                       struct drm_mode_create_dumb *args)
0029 {
0030     struct komeda_dev *mdev = dev->dev_private;
0031     u32 pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
0032
0033     args->pitch = ALIGN(pitch, mdev->chip.bus_width);
0034
0035     return drm_gem_cma_dumb_create_internal(file, dev, args);
0036 }
0037
0038 static irqreturn_t komeda_kms_irq_handler(int irq, void *data)
0039 {
0040     struct drm_device *drm = data;
0041     struct komeda_dev *mdev = drm->dev_private;
0042     struct komeda_kms_dev *kms = to_kdev(drm);
0043     struct komeda_events evts;
0044     irqreturn_t status;
0045     u32 i;
0046
0047     /* Call into the CHIP to recognize events */
0048     memset(&evts, 0, sizeof(evts));
0049     status = mdev->funcs->irq_handler(mdev, &evts);
0050
0051     komeda_print_events(&evts, drm);
0052
0053     /* Notify the crtc to handle the events */
0054     for (i = 0; i < kms->n_crtcs; i++)
0055         komeda_crtc_handle_event(&kms->crtcs[i], &evts);
0056
0057     return status;
0058 }
0059
0060 static const struct drm_driver komeda_kms_driver = {
0061     .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
0062     .lastclose          = drm_fb_helper_lastclose,
0063     DRM_GEM_CMA_DRIVER_OPS_WITH_DUMB_CREATE(komeda_gem_cma_dumb_create),
0064     .fops = &komeda_cma_fops,
0065     .name = "komeda",
0066     .desc = "Arm Komeda Display Processor driver",
0067     .date = "20181101",
0068     .major = 0,
0069     .minor = 1,
0070 };
0071
0072 static void komeda_kms_commit_tail(struct drm_atomic_state *old_state)
0073 {
0074     struct drm_device *dev = old_state->dev;
0075     bool fence_cookie = dma_fence_begin_signalling();
0076
0077     drm_atomic_helper_commit_modeset_disables(dev, old_state);
0078
0079     drm_atomic_helper_commit_planes(dev, old_state,
0080                     DRM_PLANE_COMMIT_ACTIVE_ONLY);
0081
0082     drm_atomic_helper_commit_modeset_enables(dev, old_state);
0083
0084     drm_atomic_helper_commit_hw_done(old_state);
0085
0086     drm_atomic_helper_wait_for_flip_done(dev, old_state);
0087
0088     dma_fence_end_signalling(fence_cookie);
0089
0090     drm_atomic_helper_cleanup_planes(dev, old_state);
0091 }
0092
0093 static const struct drm_mode_config_helper_funcs komeda_mode_config_helpers = {
0094     .atomic_commit_tail = komeda_kms_commit_tail,
0095 };
0096
0097 static int komeda_plane_state_list_add(struct drm_plane_state *plane_st,
0098                        struct list_head *zorder_list)
0099 {
0100     struct komeda_plane_state *new = to_kplane_st(plane_st);
0101     struct komeda_plane_state *node, *last;
0102
0103     last = list_empty(zorder_list) ?
0104            NULL : list_last_entry(zorder_list, typeof(*last), zlist_node);
0105
0106     /* Considering the list sequence is zpos increasing, so if list is empty
0107      * or the zpos of new node bigger than the last node in list, no need
0108      * loop and just insert the new one to the tail of the list.
0109      */
0110     if (!last || (new->base.zpos > last->base.zpos)) {
0111         list_add_tail(&new->zlist_node, zorder_list);
0112         return 0;
0113     }
0114
0115     /* Build the list by zpos increasing */
0116     list_for_each_entry(node, zorder_list, zlist_node) {
0117         if (new->base.zpos < node->base.zpos) {
0118             list_add_tail(&new->zlist_node, &node->zlist_node);
0119             break;
0120         } else if (node->base.zpos == new->base.zpos) {
0121             struct drm_plane *a = node->base.plane;
0122             struct drm_plane *b = new->base.plane;
0123
0124             /* Komeda doesn't support setting a same zpos for
0125              * different planes.
0126              */
0127             DRM_DEBUG_ATOMIC("PLANE: %s and PLANE: %s are configured same zpos: %d.\n",
0128                      a->name, b->name, node->base.zpos);
0129             return -EINVAL;
0130         }
0131     }
0132
0133     return 0;
0134 }
0135
0136 static int komeda_crtc_normalize_zpos(struct drm_crtc *crtc,
0137                       struct drm_crtc_state *crtc_st)
0138 {
0139     struct drm_atomic_state *state = crtc_st->state;
0140     struct komeda_crtc *kcrtc = to_kcrtc(crtc);
0141     struct komeda_crtc_state *kcrtc_st = to_kcrtc_st(crtc_st);
0142     struct komeda_plane_state *kplane_st;
0143     struct drm_plane_state *plane_st;
0144     struct drm_plane *plane;
0145     struct list_head zorder_list;
0146     int order = 0, err;
0147
0148     DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
0149              crtc->base.id, crtc->name);
0150
0151     INIT_LIST_HEAD(&zorder_list);
0152
0153     /* This loop also added all effected planes into the new state */
0154     drm_for_each_plane_mask(plane, crtc->dev, crtc_st->plane_mask) {
0155         plane_st = drm_atomic_get_plane_state(state, plane);
0156         if (IS_ERR(plane_st))
0157             return PTR_ERR(plane_st);
0158
0159         /* Build a list by zpos increasing */
0160         err = komeda_plane_state_list_add(plane_st, &zorder_list);
0161         if (err)
0162             return err;
0163     }
0164
0165     kcrtc_st->max_slave_zorder = 0;
0166
0167     list_for_each_entry(kplane_st, &zorder_list, zlist_node) {
0168         plane_st = &kplane_st->base;
0169         plane = plane_st->plane;
0170
0171         plane_st->normalized_zpos = order++;
0172         /* When layer_split has been enabled, one plane will be handled
0173          * by two separated komeda layers (left/right), which may needs
0174          * two zorders.
0175          * - zorder: for left_layer for left display part.
0176          * - zorder + 1: will be reserved for right layer.
0177          */
0178         if (to_kplane_st(plane_st)->layer_split)
0179             order++;
0180
0181         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] zpos:%d, normalized zpos: %d\n",
0182                  plane->base.id, plane->name,
0183                  plane_st->zpos, plane_st->normalized_zpos);
0184
0185         /* calculate max slave zorder */
0186         if (has_bit(drm_plane_index(plane), kcrtc->slave_planes))
0187             kcrtc_st->max_slave_zorder =
0188                 max(plane_st->normalized_zpos,
0189                     kcrtc_st->max_slave_zorder);
0190     }
0191
0192     crtc_st->zpos_changed = true;
0193
0194     return 0;
0195 }
0196
0197 static int komeda_kms_check(struct drm_device *dev,
0198                 struct drm_atomic_state *state)
0199 {
0200     struct drm_crtc *crtc;
0201     struct drm_crtc_state *new_crtc_st;
0202     int i, err;
0203
0204     err = drm_atomic_helper_check_modeset(dev, state);
0205     if (err)
0206         return err;
0207
0208     /* Komeda need to re-calculate resource assumption in every commit
0209      * so need to add all affected_planes (even unchanged) to
0210      * drm_atomic_state.
0211      */
0212     for_each_new_crtc_in_state(state, crtc, new_crtc_st, i) {
0213         err = drm_atomic_add_affected_planes(state, crtc);
0214         if (err)
0215             return err;
0216
0217         err = komeda_crtc_normalize_zpos(crtc, new_crtc_st);
0218         if (err)
0219             return err;
0220     }
0221
0222     err = drm_atomic_helper_check_planes(dev, state);
0223     if (err)
0224         return err;
0225
0226     return 0;
0227 }
0228
0229 static const struct drm_mode_config_funcs komeda_mode_config_funcs = {
0230     .fb_create      = komeda_fb_create,
0231     .atomic_check       = komeda_kms_check,
0232     .atomic_commit      = drm_atomic_helper_commit,
0233 };
0234
0235 static void komeda_kms_mode_config_init(struct komeda_kms_dev *kms,
0236                     struct komeda_dev *mdev)
0237 {
0238     struct drm_mode_config *config = &kms->base.mode_config;
0239
0240     drm_mode_config_init(&kms->base);
0241
0242     komeda_kms_setup_crtcs(kms, mdev);
0243
0244     /* Get value from dev */
0245     config->min_width   = 0;
0246     config->min_height  = 0;
0247     config->max_width   = 4096;
0248     config->max_height  = 4096;
0249
0250     config->funcs = &komeda_mode_config_funcs;
0251     config->helper_private = &komeda_mode_config_helpers;
0252 }
0253
0254 struct komeda_kms_dev *komeda_kms_attach(struct komeda_dev *mdev)
0255 {
0256     struct komeda_kms_dev *kms;
0257     struct drm_device *drm;
0258     int err;
0259
0260     kms = devm_drm_dev_alloc(mdev->dev, &komeda_kms_driver,
0261                  struct komeda_kms_dev, base);
0262     if (IS_ERR(kms))
0263         return kms;
0264
0265     drm = &kms->base;
0266
0267     drm->dev_private = mdev;
0268
0269     komeda_kms_mode_config_init(kms, mdev);
0270
0271     err = komeda_kms_add_private_objs(kms, mdev);
0272     if (err)
0273         goto cleanup_mode_config;
0274
0275     err = komeda_kms_add_planes(kms, mdev);
0276     if (err)
0277         goto cleanup_mode_config;
0278
0279     err = drm_vblank_init(drm, kms->n_crtcs);
0280     if (err)
0281         goto cleanup_mode_config;
0282
0283     err = komeda_kms_add_crtcs(kms, mdev);
0284     if (err)
0285         goto cleanup_mode_config;
0286
0287     err = komeda_kms_add_wb_connectors(kms, mdev);
0288     if (err)
0289         goto cleanup_mode_config;
0290
0291     err = component_bind_all(mdev->dev, kms);
0292     if (err)
0293         goto cleanup_mode_config;
0294
0295     drm_mode_config_reset(drm);
0296
0297     err = devm_request_irq(drm->dev, mdev->irq,
0298                    komeda_kms_irq_handler, IRQF_SHARED,
0299                    drm->driver->name, drm);
0300     if (err)
0301         goto free_component_binding;
0302
0303     drm_kms_helper_poll_init(drm);
0304
0305     err = drm_dev_register(drm, 0);
0306     if (err)
0307         goto free_interrupts;
0308
0309     return kms;
0310
0311 free_interrupts:
0312     drm_kms_helper_poll_fini(drm);
0313 free_component_binding:
0314     component_unbind_all(mdev->dev, drm);
0315 cleanup_mode_config:
0316     drm_mode_config_cleanup(drm);
0317     komeda_kms_cleanup_private_objs(kms);
0318     drm->dev_private = NULL;
0319     return ERR_PTR(err);
0320 }
0321
0322 void komeda_kms_detach(struct komeda_kms_dev *kms)
0323 {
0324     struct drm_device *drm = &kms->base;
0325     struct komeda_dev *mdev = drm->dev_private;
0326
0327     drm_dev_unregister(drm);
0328     drm_kms_helper_poll_fini(drm);
0329     drm_atomic_helper_shutdown(drm);
0330     component_unbind_all(mdev->dev, drm);
0331     drm_mode_config_cleanup(drm);
0332     komeda_kms_cleanup_private_objs(kms);
0333     drm->dev_private = NULL;
0334 }