Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
       4             :  * Author: Brian Starkey <brian.starkey@arm.com>
       5             :  *
       6             :  * This program is free software and is provided to you under the terms of the
       7             :  * GNU General Public License version 2 as published by the Free Software
       8             :  * Foundation, and any use by you of this program is subject to the terms
       9             :  * of such GNU licence.
      10             :  */
      11             : 
      12             : #ifndef __DRM_WRITEBACK_H__
      13             : #define __DRM_WRITEBACK_H__
      14             : #include <drm/drm_connector.h>
      15             : #include <drm/drm_encoder.h>
      16             : #include <linux/workqueue.h>
      17             : 
      18             : /**
      19             :  * struct drm_writeback_connector - DRM writeback connector
      20             :  */
      21             : struct drm_writeback_connector {
      22             :         /**
      23             :          * @base: base drm_connector object
      24             :          */
      25             :         struct drm_connector base;
      26             : 
      27             :         /**
      28             :          * @encoder: Internal encoder used by the connector to fulfill
      29             :          * the DRM framework requirements. The users of the
      30             :          * @drm_writeback_connector control the behaviour of the @encoder
      31             :          * by passing the @enc_funcs parameter to drm_writeback_connector_init()
      32             :          * function.
      33             :          * For users of drm_writeback_connector_init_with_encoder(), this field
      34             :          * is not valid as the encoder is managed within their drivers.
      35             :          */
      36             :         struct drm_encoder encoder;
      37             : 
      38             :         /**
      39             :          * @pixel_formats_blob_ptr:
      40             :          *
      41             :          * DRM blob property data for the pixel formats list on writeback
      42             :          * connectors
      43             :          * See also drm_writeback_connector_init()
      44             :          */
      45             :         struct drm_property_blob *pixel_formats_blob_ptr;
      46             : 
      47             :         /** @job_lock: Protects job_queue */
      48             :         spinlock_t job_lock;
      49             : 
      50             :         /**
      51             :          * @job_queue:
      52             :          *
      53             :          * Holds a list of a connector's writeback jobs; the last item is the
      54             :          * most recent. The first item may be either waiting for the hardware
      55             :          * to begin writing, or currently being written.
      56             :          *
      57             :          * See also: drm_writeback_queue_job() and
      58             :          * drm_writeback_signal_completion()
      59             :          */
      60             :         struct list_head job_queue;
      61             : 
      62             :         /**
      63             :          * @fence_context:
      64             :          *
      65             :          * timeline context used for fence operations.
      66             :          */
      67             :         unsigned int fence_context;
      68             :         /**
      69             :          * @fence_lock:
      70             :          *
      71             :          * spinlock to protect the fences in the fence_context.
      72             :          */
      73             :         spinlock_t fence_lock;
      74             :         /**
      75             :          * @fence_seqno:
      76             :          *
      77             :          * Seqno variable used as monotonic counter for the fences
      78             :          * created on the connector's timeline.
      79             :          */
      80             :         unsigned long fence_seqno;
      81             :         /**
      82             :          * @timeline_name:
      83             :          *
      84             :          * The name of the connector's fence timeline.
      85             :          */
      86             :         char timeline_name[32];
      87             : };
      88             : 
      89             : /**
      90             :  * struct drm_writeback_job - DRM writeback job
      91             :  */
      92             : struct drm_writeback_job {
      93             :         /**
      94             :          * @connector:
      95             :          *
      96             :          * Back-pointer to the writeback connector associated with the job
      97             :          */
      98             :         struct drm_writeback_connector *connector;
      99             : 
     100             :         /**
     101             :          * @prepared:
     102             :          *
     103             :          * Set when the job has been prepared with drm_writeback_prepare_job()
     104             :          */
     105             :         bool prepared;
     106             : 
     107             :         /**
     108             :          * @cleanup_work:
     109             :          *
     110             :          * Used to allow drm_writeback_signal_completion to defer dropping the
     111             :          * framebuffer reference to a workqueue
     112             :          */
     113             :         struct work_struct cleanup_work;
     114             : 
     115             :         /**
     116             :          * @list_entry:
     117             :          *
     118             :          * List item for the writeback connector's @job_queue
     119             :          */
     120             :         struct list_head list_entry;
     121             : 
     122             :         /**
     123             :          * @fb:
     124             :          *
     125             :          * Framebuffer to be written to by the writeback connector. Do not set
     126             :          * directly, use drm_writeback_set_fb()
     127             :          */
     128             :         struct drm_framebuffer *fb;
     129             : 
     130             :         /**
     131             :          * @out_fence:
     132             :          *
     133             :          * Fence which will signal once the writeback has completed
     134             :          */
     135             :         struct dma_fence *out_fence;
     136             : 
     137             :         /**
     138             :          * @priv:
     139             :          *
     140             :          * Driver-private data
     141             :          */
     142             :         void *priv;
     143             : };
     144             : 
     145             : static inline struct drm_writeback_connector *
     146             : drm_connector_to_writeback(struct drm_connector *connector)
     147             : {
     148           0 :         return container_of(connector, struct drm_writeback_connector, base);
     149             : }
     150             : 
     151             : int drm_writeback_connector_init(struct drm_device *dev,
     152             :                                  struct drm_writeback_connector *wb_connector,
     153             :                                  const struct drm_connector_funcs *con_funcs,
     154             :                                  const struct drm_encoder_helper_funcs *enc_helper_funcs,
     155             :                                  const u32 *formats, int n_formats,
     156             :                                  u32 possible_crtcs);
     157             : 
     158             : int drm_writeback_connector_init_with_encoder(struct drm_device *dev,
     159             :                                 struct drm_writeback_connector *wb_connector,
     160             :                                 struct drm_encoder *enc,
     161             :                                 const struct drm_connector_funcs *con_funcs, const u32 *formats,
     162             :                                 int n_formats);
     163             : 
     164             : int drm_writeback_set_fb(struct drm_connector_state *conn_state,
     165             :                          struct drm_framebuffer *fb);
     166             : 
     167             : int drm_writeback_prepare_job(struct drm_writeback_job *job);
     168             : 
     169             : void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector,
     170             :                              struct drm_connector_state *conn_state);
     171             : 
     172             : void drm_writeback_cleanup_job(struct drm_writeback_job *job);
     173             : 
     174             : void
     175             : drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector,
     176             :                                 int status);
     177             : 
     178             : struct dma_fence *
     179             : drm_writeback_get_out_fence(struct drm_writeback_connector *wb_connector);
     180             : #endif