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 */
 21struct 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 */
 92struct 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
145static inline struct drm_writeback_connector *
146drm_connector_to_writeback(struct drm_connector *connector)
147{
148	return container_of(connector, struct drm_writeback_connector, base);
149}
150
151int 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
158int 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
164int drm_writeback_set_fb(struct drm_connector_state *conn_state,
165			 struct drm_framebuffer *fb);
166
167int drm_writeback_prepare_job(struct drm_writeback_job *job);
168
169void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector,
170			     struct drm_connector_state *conn_state);
171
172void drm_writeback_cleanup_job(struct drm_writeback_job *job);
173
174void
175drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector,
176				int status);
177
178struct dma_fence *
179drm_writeback_get_out_fence(struct drm_writeback_connector *wb_connector);
180#endif

  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
 
 
 
 18struct drm_writeback_connector {
 
 
 
 19	struct drm_connector base;
 20
 21	/**
 22	 * @encoder: Internal encoder used by the connector to fulfill
 23	 * the DRM framework requirements. The users of the
 24	 * @drm_writeback_connector control the behaviour of the @encoder
 25	 * by passing the @enc_funcs parameter to drm_writeback_connector_init()
 26	 * function.
 
 
 27	 */
 28	struct drm_encoder encoder;
 29
 30	/**
 31	 * @pixel_formats_blob_ptr:
 32	 *
 33	 * DRM blob property data for the pixel formats list on writeback
 34	 * connectors
 35	 * See also drm_writeback_connector_init()
 36	 */
 37	struct drm_property_blob *pixel_formats_blob_ptr;
 38
 39	/** @job_lock: Protects job_queue */
 40	spinlock_t job_lock;
 41
 42	/**
 43	 * @job_queue:
 44	 *
 45	 * Holds a list of a connector's writeback jobs; the last item is the
 46	 * most recent. The first item may be either waiting for the hardware
 47	 * to begin writing, or currently being written.
 48	 *
 49	 * See also: drm_writeback_queue_job() and
 50	 * drm_writeback_signal_completion()
 51	 */
 52	struct list_head job_queue;
 53
 54	/**
 55	 * @fence_context:
 56	 *
 57	 * timeline context used for fence operations.
 58	 */
 59	unsigned int fence_context;
 60	/**
 61	 * @fence_lock:
 62	 *
 63	 * spinlock to protect the fences in the fence_context.
 64	 */
 65	spinlock_t fence_lock;
 66	/**
 67	 * @fence_seqno:
 68	 *
 69	 * Seqno variable used as monotonic counter for the fences
 70	 * created on the connector's timeline.
 71	 */
 72	unsigned long fence_seqno;
 73	/**
 74	 * @timeline_name:
 75	 *
 76	 * The name of the connector's fence timeline.
 77	 */
 78	char timeline_name[32];
 79};
 80
 
 
 
 81struct drm_writeback_job {
 82	/**
 83	 * @connector:
 84	 *
 85	 * Back-pointer to the writeback connector associated with the job
 86	 */
 87	struct drm_writeback_connector *connector;
 88
 89	/**
 90	 * @prepared:
 91	 *
 92	 * Set when the job has been prepared with drm_writeback_prepare_job()
 93	 */
 94	bool prepared;
 95
 96	/**
 97	 * @cleanup_work:
 98	 *
 99	 * Used to allow drm_writeback_signal_completion to defer dropping the
100	 * framebuffer reference to a workqueue
101	 */
102	struct work_struct cleanup_work;
103
104	/**
105	 * @list_entry:
106	 *
107	 * List item for the writeback connector's @job_queue
108	 */
109	struct list_head list_entry;
110
111	/**
112	 * @fb:
113	 *
114	 * Framebuffer to be written to by the writeback connector. Do not set
115	 * directly, use drm_writeback_set_fb()
116	 */
117	struct drm_framebuffer *fb;
118
119	/**
120	 * @out_fence:
121	 *
122	 * Fence which will signal once the writeback has completed
123	 */
124	struct dma_fence *out_fence;
125
126	/**
127	 * @priv:
128	 *
129	 * Driver-private data
130	 */
131	void *priv;
132};
133
134static inline struct drm_writeback_connector *
135drm_connector_to_writeback(struct drm_connector *connector)
136{
137	return container_of(connector, struct drm_writeback_connector, base);
138}
139
140int drm_writeback_connector_init(struct drm_device *dev,
141				 struct drm_writeback_connector *wb_connector,
142				 const struct drm_connector_funcs *con_funcs,
143				 const struct drm_encoder_helper_funcs *enc_helper_funcs,
144				 const u32 *formats, int n_formats);
 
 
 
 
 
 
 
145
146int drm_writeback_set_fb(struct drm_connector_state *conn_state,
147			 struct drm_framebuffer *fb);
148
149int drm_writeback_prepare_job(struct drm_writeback_job *job);
150
151void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector,
152			     struct drm_connector_state *conn_state);
153
154void drm_writeback_cleanup_job(struct drm_writeback_job *job);
155
156void
157drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector,
158				int status);
159
160struct dma_fence *
161drm_writeback_get_out_fence(struct drm_writeback_connector *wb_connector);
162#endif