Rev 6125 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5270 | serge | 1 | #ifndef __DRM_GEM_H__ |
2 | #define __DRM_GEM_H__ |
||
3 | |||
4 | /* |
||
5 | * GEM Graphics Execution Manager Driver Interfaces |
||
6 | * |
||
7 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
||
8 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
||
9 | * Copyright (c) 2009-2010, Code Aurora Forum. |
||
10 | * All rights reserved. |
||
11 | * Copyright © 2014 Intel Corporation |
||
12 | * Daniel Vetter |
||
13 | * |
||
14 | * Author: Rickard E. (Rik) Faith |
||
15 | * Author: Gareth Hughes |
||
16 | * |
||
17 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
18 | * copy of this software and associated documentation files (the "Software"), |
||
19 | * to deal in the Software without restriction, including without limitation |
||
20 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
21 | * and/or sell copies of the Software, and to permit persons to whom the |
||
22 | * Software is furnished to do so, subject to the following conditions: |
||
23 | * |
||
24 | * The above copyright notice and this permission notice (including the next |
||
25 | * paragraph) shall be included in all copies or substantial portions of the |
||
26 | * Software. |
||
27 | * |
||
28 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
29 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
30 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
31 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
||
32 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||
33 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
||
34 | * OTHER DEALINGS IN THE SOFTWARE. |
||
35 | */ |
||
36 | |||
37 | /** |
||
6936 | serge | 38 | * struct drm_gem_object - GEM buffer object |
39 | * |
||
40 | * This structure defines the generic parts for GEM buffer objects, which are |
||
41 | * mostly around handling mmap and userspace handles. |
||
42 | * |
||
43 | * Buffer objects are often abbreviated to BO. |
||
5270 | serge | 44 | */ |
45 | struct drm_gem_object { |
||
6936 | serge | 46 | /** |
47 | * @refcount: |
||
48 | * |
||
49 | * Reference count of this object |
||
50 | * |
||
51 | * Please use drm_gem_object_reference() to acquire and |
||
52 | * drm_gem_object_unreference() or drm_gem_object_unreference_unlocked() |
||
53 | * to release a reference to a GEM buffer object. |
||
54 | */ |
||
5270 | serge | 55 | struct kref refcount; |
56 | |||
57 | /** |
||
6936 | serge | 58 | * @handle_count: |
5270 | serge | 59 | * |
6936 | serge | 60 | * This is the GEM file_priv handle count of this object. |
61 | * |
||
5270 | serge | 62 | * Each handle also holds a reference. Note that when the handle_count |
63 | * drops to 0 any global names (e.g. the id in the flink namespace) will |
||
64 | * be cleared. |
||
65 | * |
||
66 | * Protected by dev->object_name_lock. |
||
6936 | serge | 67 | */ |
5270 | serge | 68 | unsigned handle_count; |
69 | |||
6936 | serge | 70 | /** |
71 | * @dev: DRM dev this object belongs to. |
||
72 | */ |
||
5270 | serge | 73 | struct drm_device *dev; |
74 | |||
6936 | serge | 75 | /** |
76 | * @filp: |
||
77 | * |
||
78 | * SHMEM file node used as backing storage for swappable buffer objects. |
||
79 | * GEM also supports driver private objects with driver-specific backing |
||
80 | * storage (contiguous CMA memory, special reserved blocks). In this |
||
81 | * case @filp is NULL. |
||
82 | */ |
||
5270 | serge | 83 | struct file *filp; |
84 | |||
6936 | serge | 85 | /** |
86 | * @vma_node: |
||
87 | * |
||
88 | * Mapping info for this object to support mmap. Drivers are supposed to |
||
89 | * allocate the mmap offset using drm_gem_create_mmap_offset(). The |
||
90 | * offset itself can be retrieved using drm_vma_node_offset_addr(). |
||
91 | * |
||
92 | * Memory mapping itself is handled by drm_gem_mmap(), which also checks |
||
93 | * that userspace is allowed to access the object. |
||
94 | */ |
||
5270 | serge | 95 | struct drm_vma_offset_node vma_node; |
96 | |||
97 | /** |
||
6936 | serge | 98 | * @size: |
99 | * |
||
5270 | serge | 100 | * Size of the object, in bytes. Immutable over the object's |
101 | * lifetime. |
||
102 | */ |
||
103 | size_t size; |
||
104 | |||
105 | /** |
||
6936 | serge | 106 | * @name: |
107 | * |
||
5270 | serge | 108 | * Global name for this object, starts at 1. 0 means unnamed. |
6936 | serge | 109 | * Access is covered by dev->object_name_lock. This is used by the GEM_FLINK |
110 | * and GEM_OPEN ioctls. |
||
5270 | serge | 111 | */ |
112 | int name; |
||
113 | |||
114 | /** |
||
6936 | serge | 115 | * @read_domains: |
116 | * |
||
117 | * Read memory domains. These monitor which caches contain read/write data |
||
5270 | serge | 118 | * related to the object. When transitioning from one set of domains |
119 | * to another, the driver is called to ensure that caches are suitably |
||
6936 | serge | 120 | * flushed and invalidated. |
5270 | serge | 121 | */ |
122 | uint32_t read_domains; |
||
6936 | serge | 123 | |
124 | /** |
||
125 | * @write_domain: Corresponding unique write memory domain. |
||
126 | */ |
||
5270 | serge | 127 | uint32_t write_domain; |
128 | |||
129 | /** |
||
6936 | serge | 130 | * @pending_read_domains: |
131 | * |
||
5270 | serge | 132 | * While validating an exec operation, the |
133 | * new read/write domain values are computed here. |
||
134 | * They will be transferred to the above values |
||
135 | * at the point that any cache flushing occurs |
||
136 | */ |
||
137 | uint32_t pending_read_domains; |
||
6936 | serge | 138 | |
139 | /** |
||
140 | * @pending_write_domain: Write domain similar to @pending_read_domains. |
||
141 | */ |
||
5270 | serge | 142 | uint32_t pending_write_domain; |
143 | |||
144 | /** |
||
6936 | serge | 145 | * @dma_buf: |
5270 | serge | 146 | * |
6936 | serge | 147 | * dma-buf associated with this GEM object. |
148 | * |
||
5270 | serge | 149 | * Pointer to the dma-buf associated with this gem object (either |
150 | * through importing or exporting). We break the resulting reference |
||
151 | * loop when the last gem handle for this object is released. |
||
152 | * |
||
6936 | serge | 153 | * Protected by obj->object_name_lock. |
5270 | serge | 154 | */ |
155 | struct dma_buf *dma_buf; |
||
156 | |||
157 | /** |
||
6936 | serge | 158 | * @import_attach: |
5270 | serge | 159 | * |
6936 | serge | 160 | * dma-buf attachment backing this object. |
161 | * |
||
5270 | serge | 162 | * Any foreign dma_buf imported as a gem object has this set to the |
163 | * attachment point for the device. This is invariant over the lifetime |
||
164 | * of a gem object. |
||
165 | * |
||
166 | * The driver's ->gem_free_object callback is responsible for cleaning |
||
167 | * up the dma_buf attachment and references acquired at import time. |
||
168 | * |
||
169 | * Note that the drm gem/prime core does not depend upon drivers setting |
||
170 | * this field any more. So for drivers where this doesn't make sense |
||
171 | * (e.g. virtual devices or a displaylink behind an usb bus) they can |
||
172 | * simply leave it as NULL. |
||
173 | */ |
||
174 | struct dma_buf_attachment *import_attach; |
||
175 | }; |
||
176 | |||
177 | void drm_gem_object_release(struct drm_gem_object *obj); |
||
178 | void drm_gem_object_free(struct kref *kref); |
||
179 | int drm_gem_object_init(struct drm_device *dev, |
||
180 | struct drm_gem_object *obj, size_t size); |
||
181 | void drm_gem_private_object_init(struct drm_device *dev, |
||
182 | struct drm_gem_object *obj, size_t size); |
||
183 | void drm_gem_vm_open(struct vm_area_struct *vma); |
||
184 | void drm_gem_vm_close(struct vm_area_struct *vma); |
||
185 | int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size, |
||
186 | struct vm_area_struct *vma); |
||
187 | int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); |
||
188 | |||
6936 | serge | 189 | /** |
190 | * drm_gem_object_reference - acquire a GEM BO reference |
||
191 | * @obj: GEM buffer object |
||
192 | * |
||
193 | * This acquires additional reference to @obj. It is illegal to call this |
||
194 | * without already holding a reference. No locks required. |
||
195 | */ |
||
5270 | serge | 196 | static inline void |
197 | drm_gem_object_reference(struct drm_gem_object *obj) |
||
198 | { |
||
199 | kref_get(&obj->refcount); |
||
200 | } |
||
201 | |||
6936 | serge | 202 | /** |
203 | * drm_gem_object_unreference - release a GEM BO reference |
||
204 | * @obj: GEM buffer object |
||
205 | * |
||
206 | * This releases a reference to @obj. Callers must hold the dev->struct_mutex |
||
207 | * lock when calling this function, even when the driver doesn't use |
||
208 | * dev->struct_mutex for anything. |
||
209 | * |
||
210 | * For drivers not encumbered with legacy locking use |
||
211 | * drm_gem_object_unreference_unlocked() instead. |
||
212 | */ |
||
5270 | serge | 213 | static inline void |
214 | drm_gem_object_unreference(struct drm_gem_object *obj) |
||
215 | { |
||
6102 | serge | 216 | if (obj != NULL) { |
217 | WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex)); |
||
218 | |||
5270 | serge | 219 | kref_put(&obj->refcount, drm_gem_object_free); |
6102 | serge | 220 | } |
5270 | serge | 221 | } |
222 | |||
6936 | serge | 223 | /** |
224 | * drm_gem_object_unreference_unlocked - release a GEM BO reference |
||
225 | * @obj: GEM buffer object |
||
226 | * |
||
227 | * This releases a reference to @obj. Callers must not hold the |
||
228 | * dev->struct_mutex lock when calling this function. |
||
229 | */ |
||
5270 | serge | 230 | static inline void |
231 | drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
||
232 | { |
||
6125 | serge | 233 | struct drm_device *dev; |
5270 | serge | 234 | |
6125 | serge | 235 | if (!obj) |
236 | return; |
||
237 | |||
238 | dev = obj->dev; |
||
239 | if (kref_put_mutex(&obj->refcount, drm_gem_object_free, &dev->struct_mutex)) |
||
5270 | serge | 240 | mutex_unlock(&dev->struct_mutex); |
6125 | serge | 241 | else |
242 | might_lock(&dev->struct_mutex); |
||
5270 | serge | 243 | } |
244 | |||
245 | int drm_gem_handle_create(struct drm_file *file_priv, |
||
246 | struct drm_gem_object *obj, |
||
247 | u32 *handlep); |
||
248 | int drm_gem_handle_delete(struct drm_file *filp, u32 handle); |
||
249 | |||
250 | |||
251 | void drm_gem_free_mmap_offset(struct drm_gem_object *obj); |
||
252 | int drm_gem_create_mmap_offset(struct drm_gem_object *obj); |
||
253 | int drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size); |
||
254 | |||
255 | struct page **drm_gem_get_pages(struct drm_gem_object *obj); |
||
256 | void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages, |
||
257 | bool dirty, bool accessed); |
||
258 | |||
259 | struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev, |
||
260 | struct drm_file *filp, |
||
261 | u32 handle); |
||
262 | int drm_gem_dumb_destroy(struct drm_file *file, |
||
263 | struct drm_device *dev, |
||
264 | uint32_t handle); |
||
265 | |||
266 | #endif /* __DRM_GEM_H__ */ |