1 /* 2 * Copyright (C) 2013 Google, Inc. 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 */ 14 15 #ifndef _UAPI_VIDEO_ADF_H_ 16 #define _UAPI_VIDEO_ADF_H_ 17 18 #include <linux/ioctl.h> 19 #include <linux/types.h> 20 21 #include <drm/drm_fourcc.h> 22 #include <drm/drm_mode.h> 23 24 #define ADF_NAME_LEN 32 25 #define ADF_MAX_CUSTOM_DATA_SIZE 4096 26 27 enum adf_interface_type { 28 ADF_INTF_DSI = 0, 29 ADF_INTF_eDP = 1, 30 ADF_INTF_DPI = 2, 31 ADF_INTF_VGA = 3, 32 ADF_INTF_DVI = 4, 33 ADF_INTF_HDMI = 5, 34 ADF_INTF_MEMORY = 6, 35 ADF_INTF_TYPE_DEVICE_CUSTOM = 128, 36 ADF_INTF_TYPE_MAX = (~(__u32)0), 37 }; 38 39 #define ADF_INTF_FLAG_PRIMARY (1 << 0) 40 #define ADF_INTF_FLAG_EXTERNAL (1 << 1) 41 42 enum adf_event_type { 43 ADF_EVENT_VSYNC = 0, 44 ADF_EVENT_HOTPLUG = 1, 45 ADF_EVENT_DEVICE_CUSTOM = 128, 46 ADF_EVENT_TYPE_MAX = 255, 47 }; 48 49 /** 50 * struct adf_set_event - start or stop subscribing to ADF events 51 * 52 * @type: the type of event to (un)subscribe 53 * @enabled: subscribe or unsubscribe 54 * 55 * After subscribing to an event, userspace may poll() the ADF object's fd 56 * to wait for events or read() to consume the event's data. 57 * 58 * ADF reserves event types 0 to %ADF_EVENT_DEVICE_CUSTOM-1 for its own events. 59 * Devices may use event types %ADF_EVENT_DEVICE_CUSTOM to %ADF_EVENT_TYPE_MAX-1 60 * for driver-private events. 61 */ 62 struct adf_set_event { 63 __u8 type; 64 __u8 enabled; 65 }; 66 67 /** 68 * struct adf_event - common header for ADF event data 69 * 70 * @type: event type 71 * @length: total size of event data, header inclusive 72 */ 73 struct adf_event { 74 __u8 type; 75 __u32 length; 76 }; 77 78 /** 79 * struct adf_vsync_event - ADF vsync event 80 * 81 * @base: event header (see &struct adf_event) 82 * @timestamp: time of vsync event, in nanoseconds 83 */ 84 struct adf_vsync_event { 85 struct adf_event base; 86 __aligned_u64 timestamp; 87 }; 88 89 /** 90 * struct adf_vsync_event - ADF display hotplug event 91 * 92 * @base: event header (see &struct adf_event) 93 * @connected: whether a display is now connected to the interface 94 */ 95 struct adf_hotplug_event { 96 struct adf_event base; 97 __u8 connected; 98 }; 99 100 #define ADF_MAX_PLANES 4 101 /** 102 * struct adf_buffer_config - description of buffer displayed by adf_post_config 103 * 104 * @overlay_engine: id of the target overlay engine 105 * @w: width of display region in pixels 106 * @h: height of display region in pixels 107 * @format: DRM-style fourcc, see drm_fourcc.h for standard formats 108 * @fd: dma_buf fd for each plane 109 * @offset: location of first pixel to scan out, in bytes 110 * @pitch: stride (i.e. length of a scanline including padding) in bytes 111 * @n_planes: number of planes in buffer 112 * @acquire_fence: sync_fence fd which will clear when the buffer is 113 * ready for display, or <0 if the buffer is already ready 114 */ 115 struct adf_buffer_config { 116 __u32 overlay_engine; 117 118 __u32 w; 119 __u32 h; 120 __u32 format; 121 122 __s32 fd[ADF_MAX_PLANES]; 123 __u32 offset[ADF_MAX_PLANES]; 124 __u32 pitch[ADF_MAX_PLANES]; 125 __u8 n_planes; 126 127 __s32 acquire_fence; 128 }; 129 #define ADF_MAX_BUFFERS (4096 / sizeof(struct adf_buffer_config)) 130 131 /** 132 * struct adf_post_config - request to flip to a new set of buffers 133 * 134 * @n_interfaces: number of interfaces targeted by the flip (input) 135 * @interfaces: ids of interfaces targeted by the flip (input) 136 * @n_bufs: number of buffers displayed (input) 137 * @bufs: description of buffers displayed (input) 138 * @custom_data_size: size of driver-private data (input) 139 * @custom_data: driver-private data (input) 140 * @complete_fence: sync_fence fd which will clear when this 141 * configuration has left the screen (output) 142 */ 143 struct adf_post_config { 144 size_t n_interfaces; 145 __u32 __user *interfaces; 146 147 size_t n_bufs; 148 struct adf_buffer_config __user *bufs; 149 150 size_t custom_data_size; 151 void __user *custom_data; 152 153 __s32 complete_fence; 154 }; 155 #define ADF_MAX_INTERFACES (4096 / sizeof(__u32)) 156 157 /** 158 * struct adf_simple_buffer_allocate - request to allocate a "simple" buffer 159 * 160 * @w: width of buffer in pixels (input) 161 * @h: height of buffer in pixels (input) 162 * @format: DRM-style fourcc (input) 163 * 164 * @fd: dma_buf fd (output) 165 * @offset: location of first pixel, in bytes (output) 166 * @pitch: length of a scanline including padding, in bytes (output) 167 * 168 * Simple buffers are analogous to DRM's "dumb" buffers. They have a single 169 * plane of linear RGB data which can be allocated and scanned out without 170 * any driver-private ioctls or data. 171 * 172 * @format must be a standard RGB format defined in drm_fourcc.h. 173 * 174 * ADF clients must NOT assume that an interface can scan out a simple buffer 175 * allocated by a different ADF interface, even if the two interfaces belong to 176 * the same ADF device. 177 */ 178 struct adf_simple_buffer_alloc { 179 __u16 w; 180 __u16 h; 181 __u32 format; 182 183 __s32 fd; 184 __u32 offset; 185 __u32 pitch; 186 }; 187 188 /** 189 * struct adf_simple_post_config - request to flip to a single buffer without 190 * driver-private data 191 * 192 * @buf: description of buffer displayed (input) 193 * @complete_fence: sync_fence fd which will clear when this buffer has left the 194 * screen (output) 195 */ 196 struct adf_simple_post_config { 197 struct adf_buffer_config buf; 198 __s32 complete_fence; 199 }; 200 201 /** 202 * struct adf_attachment_config - description of attachment between an overlay 203 * engine and an interface 204 * 205 * @overlay_engine: id of the overlay engine 206 * @interface: id of the interface 207 */ 208 struct adf_attachment_config { 209 __u32 overlay_engine; 210 __u32 interface; 211 }; 212 213 /** 214 * struct adf_device_data - describes a display device 215 * 216 * @name: display device's name 217 * @n_attachments: the number of current attachments 218 * @attachments: list of current attachments 219 * @n_allowed_attachments: the number of allowed attachments 220 * @allowed_attachments: list of allowed attachments 221 * @custom_data_size: size of driver-private data 222 * @custom_data: driver-private data 223 */ 224 struct adf_device_data { 225 char name[ADF_NAME_LEN]; 226 227 size_t n_attachments; 228 struct adf_attachment_config __user *attachments; 229 230 size_t n_allowed_attachments; 231 struct adf_attachment_config __user *allowed_attachments; 232 233 size_t custom_data_size; 234 void __user *custom_data; 235 }; 236 #define ADF_MAX_ATTACHMENTS (4096 / sizeof(struct adf_attachment_config)) 237 238 /** 239 * struct adf_device_data - describes a display interface 240 * 241 * @name: display interface's name 242 * @type: interface type (see enum @adf_interface_type) 243 * @id: which interface of type @type; 244 * e.g. interface DSI.1 -> @type=@ADF_INTF_TYPE_DSI, @id=1 245 * @flags: informational flags (bitmask of %ADF_INTF_FLAG_* values) 246 * @dpms_state: DPMS state (one of @DRM_MODE_DPMS_* defined in drm_mode.h) 247 * @hotplug_detect: whether a display is plugged in 248 * @width_mm: screen width in millimeters, or 0 if unknown 249 * @height_mm: screen height in millimeters, or 0 if unknown 250 * @current_mode: current display mode 251 * @n_available_modes: the number of hardware display modes 252 * @available_modes: list of hardware display modes 253 * @custom_data_size: size of driver-private data 254 * @custom_data: driver-private data 255 */ 256 struct adf_interface_data { 257 char name[ADF_NAME_LEN]; 258 259 __u32 type; 260 __u32 id; 261 /* e.g. type=ADF_INTF_TYPE_DSI, id=1 => DSI.1 */ 262 __u32 flags; 263 264 __u8 dpms_state; 265 __u8 hotplug_detect; 266 __u16 width_mm; 267 __u16 height_mm; 268 269 struct drm_mode_modeinfo current_mode; 270 size_t n_available_modes; 271 struct drm_mode_modeinfo __user *available_modes; 272 273 size_t custom_data_size; 274 void __user *custom_data; 275 }; 276 #define ADF_MAX_MODES (4096 / sizeof(struct drm_mode_modeinfo)) 277 278 /** 279 * struct adf_overlay_engine_data - describes an overlay engine 280 * 281 * @name: overlay engine's name 282 * @n_supported_formats: number of supported formats 283 * @supported_formats: list of supported formats 284 * @custom_data_size: size of driver-private data 285 * @custom_data: driver-private data 286 */ 287 struct adf_overlay_engine_data { 288 char name[ADF_NAME_LEN]; 289 290 size_t n_supported_formats; 291 __u32 __user *supported_formats; 292 293 size_t custom_data_size; 294 void __user *custom_data; 295 }; 296 #define ADF_MAX_SUPPORTED_FORMATS (4096 / sizeof(__u32)) 297 298 #define ADF_IOCTL_TYPE 'D' 299 #define ADF_IOCTL_NR_CUSTOM 128 300 301 #define ADF_SET_EVENT _IOW(ADF_IOCTL_TYPE, 0, struct adf_set_event) 302 #define ADF_BLANK _IOW(ADF_IOCTL_TYPE, 1, __u8) 303 #define ADF_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 2, struct adf_post_config) 304 #define ADF_SET_MODE _IOW(ADF_IOCTL_TYPE, 3, \ 305 struct drm_mode_modeinfo) 306 #define ADF_GET_DEVICE_DATA _IOR(ADF_IOCTL_TYPE, 4, struct adf_device_data) 307 #define ADF_GET_INTERFACE_DATA _IOR(ADF_IOCTL_TYPE, 5, \ 308 struct adf_interface_data) 309 #define ADF_GET_OVERLAY_ENGINE_DATA \ 310 _IOR(ADF_IOCTL_TYPE, 6, \ 311 struct adf_overlay_engine_data) 312 #define ADF_SIMPLE_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 7, \ 313 struct adf_simple_post_config) 314 #define ADF_SIMPLE_BUFFER_ALLOC _IOW(ADF_IOCTL_TYPE, 8, \ 315 struct adf_simple_buffer_alloc) 316 #define ADF_ATTACH _IOW(ADF_IOCTL_TYPE, 9, \ 317 struct adf_attachment_config) 318 #define ADF_DETACH _IOW(ADF_IOCTL_TYPE, 10, \ 319 struct adf_attachment_config) 320 321 #endif /* _UAPI_VIDEO_ADF_H_ */ 322