Line data Source code
1 : /*
2 : * Copyright (c) 2016 Intel Corporation
3 : *
4 : * Permission to use, copy, modify, distribute, and sell this software and its
5 : * documentation for any purpose is hereby granted without fee, provided that
6 : * the above copyright notice appear in all copies and that both that copyright
7 : * notice and this permission notice appear in supporting documentation, and
8 : * that the name of the copyright holders not be used in advertising or
9 : * publicity pertaining to distribution of the software without specific,
10 : * written prior permission. The copyright holders make no representations
11 : * about the suitability of this software for any purpose. It is provided "as
12 : * is" without express or implied warranty.
13 : *
14 : * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 : * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 : * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 : * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 : * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 : * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 : * OF THIS SOFTWARE.
21 : */
22 :
23 : #include <linux/export.h>
24 : #include <linux/uaccess.h>
25 :
26 : #include <drm/drm_atomic.h>
27 : #include <drm/drm_atomic_uapi.h>
28 : #include <drm/drm_auth.h>
29 : #include <drm/drm_debugfs.h>
30 : #include <drm/drm_drv.h>
31 : #include <drm/drm_file.h>
32 : #include <drm/drm_fourcc.h>
33 : #include <drm/drm_framebuffer.h>
34 : #include <drm/drm_gem.h>
35 : #include <drm/drm_print.h>
36 : #include <drm/drm_util.h>
37 :
38 : #include "drm_crtc_internal.h"
39 : #include "drm_internal.h"
40 :
41 : /**
42 : * DOC: overview
43 : *
44 : * Frame buffers are abstract memory objects that provide a source of pixels to
45 : * scanout to a CRTC. Applications explicitly request the creation of frame
46 : * buffers through the DRM_IOCTL_MODE_ADDFB(2) ioctls and receive an opaque
47 : * handle that can be passed to the KMS CRTC control, plane configuration and
48 : * page flip functions.
49 : *
50 : * Frame buffers rely on the underlying memory manager for allocating backing
51 : * storage. When creating a frame buffer applications pass a memory handle
52 : * (or a list of memory handles for multi-planar formats) through the
53 : * &struct drm_mode_fb_cmd2 argument. For drivers using GEM as their userspace
54 : * buffer management interface this would be a GEM handle. Drivers are however
55 : * free to use their own backing storage object handles, e.g. vmwgfx directly
56 : * exposes special TTM handles to userspace and so expects TTM handles in the
57 : * create ioctl and not GEM handles.
58 : *
59 : * Framebuffers are tracked with &struct drm_framebuffer. They are published
60 : * using drm_framebuffer_init() - after calling that function userspace can use
61 : * and access the framebuffer object. The helper function
62 : * drm_helper_mode_fill_fb_struct() can be used to pre-fill the required
63 : * metadata fields.
64 : *
65 : * The lifetime of a drm framebuffer is controlled with a reference count,
66 : * drivers can grab additional references with drm_framebuffer_get() and drop
67 : * them again with drm_framebuffer_put(). For driver-private framebuffers for
68 : * which the last reference is never dropped (e.g. for the fbdev framebuffer
69 : * when the struct &struct drm_framebuffer is embedded into the fbdev helper
70 : * struct) drivers can manually clean up a framebuffer at module unload time
71 : * with drm_framebuffer_unregister_private(). But doing this is not
72 : * recommended, and it's better to have a normal free-standing &struct
73 : * drm_framebuffer.
74 : */
75 :
76 0 : int drm_framebuffer_check_src_coords(uint32_t src_x, uint32_t src_y,
77 : uint32_t src_w, uint32_t src_h,
78 : const struct drm_framebuffer *fb)
79 : {
80 : unsigned int fb_width, fb_height;
81 :
82 0 : fb_width = fb->width << 16;
83 0 : fb_height = fb->height << 16;
84 :
85 : /* Make sure source coordinates are inside the fb. */
86 0 : if (src_w > fb_width ||
87 0 : src_x > fb_width - src_w ||
88 0 : src_h > fb_height ||
89 0 : src_y > fb_height - src_h) {
90 0 : drm_dbg_kms(fb->dev, "Invalid source coordinates "
91 : "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n",
92 : src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
93 : src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
94 : src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
95 : src_y >> 16, ((src_y & 0xffff) * 15625) >> 10,
96 : fb->width, fb->height);
97 0 : return -ENOSPC;
98 : }
99 :
100 : return 0;
101 : }
102 :
103 : /**
104 : * drm_mode_addfb - add an FB to the graphics configuration
105 : * @dev: drm device for the ioctl
106 : * @or: pointer to request structure
107 : * @file_priv: drm file
108 : *
109 : * Add a new FB to the specified CRTC, given a user request. This is the
110 : * original addfb ioctl which only supported RGB formats.
111 : *
112 : * Called by the user via ioctl, or by an in-kernel client.
113 : *
114 : * Returns:
115 : * Zero on success, negative errno on failure.
116 : */
117 0 : int drm_mode_addfb(struct drm_device *dev, struct drm_mode_fb_cmd *or,
118 : struct drm_file *file_priv)
119 : {
120 0 : struct drm_mode_fb_cmd2 r = {};
121 : int ret;
122 :
123 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
124 : return -EOPNOTSUPP;
125 :
126 0 : r.pixel_format = drm_driver_legacy_fb_format(dev, or->bpp, or->depth);
127 0 : if (r.pixel_format == DRM_FORMAT_INVALID) {
128 0 : drm_dbg_kms(dev, "bad {bpp:%d, depth:%d}\n", or->bpp, or->depth);
129 0 : return -EINVAL;
130 : }
131 :
132 : /* convert to new format and call new ioctl */
133 0 : r.fb_id = or->fb_id;
134 0 : r.width = or->width;
135 0 : r.height = or->height;
136 0 : r.pitches[0] = or->pitch;
137 0 : r.handles[0] = or->handle;
138 :
139 0 : ret = drm_mode_addfb2(dev, &r, file_priv);
140 0 : if (ret)
141 : return ret;
142 :
143 0 : or->fb_id = r.fb_id;
144 :
145 0 : return 0;
146 : }
147 :
148 0 : int drm_mode_addfb_ioctl(struct drm_device *dev,
149 : void *data, struct drm_file *file_priv)
150 : {
151 0 : return drm_mode_addfb(dev, data, file_priv);
152 : }
153 :
154 : static int fb_plane_width(int width,
155 : const struct drm_format_info *format, int plane)
156 : {
157 69 : if (plane == 0)
158 : return width;
159 :
160 26 : return DIV_ROUND_UP(width, format->hsub);
161 : }
162 :
163 : static int fb_plane_height(int height,
164 : const struct drm_format_info *format, int plane)
165 : {
166 69 : if (plane == 0)
167 : return height;
168 :
169 26 : return DIV_ROUND_UP(height, format->vsub);
170 : }
171 :
172 44 : static int framebuffer_check(struct drm_device *dev,
173 : const struct drm_mode_fb_cmd2 *r)
174 : {
175 : const struct drm_format_info *info;
176 : int i;
177 :
178 : /* check if the format is supported at all */
179 44 : if (!__drm_format_info(r->pixel_format)) {
180 1 : drm_dbg_kms(dev, "bad framebuffer format %p4cc\n",
181 : &r->pixel_format);
182 1 : return -EINVAL;
183 : }
184 :
185 43 : if (r->width == 0) {
186 0 : drm_dbg_kms(dev, "bad framebuffer width %u\n", r->width);
187 0 : return -EINVAL;
188 : }
189 :
190 43 : if (r->height == 0) {
191 0 : drm_dbg_kms(dev, "bad framebuffer height %u\n", r->height);
192 0 : return -EINVAL;
193 : }
194 :
195 : /* now let the driver pick its own format info */
196 43 : info = drm_get_format_info(dev, r);
197 :
198 97 : for (i = 0; i < info->num_planes; i++) {
199 138 : unsigned int width = fb_plane_width(r->width, info, i);
200 138 : unsigned int height = fb_plane_height(r->height, info, i);
201 69 : unsigned int block_size = info->char_per_block[i];
202 69 : u64 min_pitch = drm_format_info_min_pitch(info, i, width);
203 :
204 69 : if (!block_size && (r->modifier[i] == DRM_FORMAT_MOD_LINEAR)) {
205 0 : drm_dbg_kms(dev, "Format requires non-linear modifier for plane %d\n", i);
206 0 : return -EINVAL;
207 : }
208 :
209 69 : if (!r->handles[i]) {
210 1 : drm_dbg_kms(dev, "no buffer object handle for plane %d\n", i);
211 1 : return -EINVAL;
212 : }
213 :
214 68 : if (min_pitch > UINT_MAX)
215 : return -ERANGE;
216 :
217 68 : if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX)
218 : return -ERANGE;
219 :
220 67 : if (block_size && r->pitches[i] < min_pitch) {
221 4 : drm_dbg_kms(dev, "bad pitch %u for plane %d\n", r->pitches[i], i);
222 4 : return -EINVAL;
223 : }
224 :
225 63 : if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) {
226 5 : drm_dbg_kms(dev, "bad fb modifier %llu for plane %d\n",
227 : r->modifier[i], i);
228 5 : return -EINVAL;
229 : }
230 :
231 87 : if (r->flags & DRM_MODE_FB_MODIFIERS &&
232 29 : r->modifier[i] != r->modifier[0]) {
233 3 : drm_dbg_kms(dev, "bad fb modifier %llu for plane %d\n",
234 : r->modifier[i], i);
235 3 : return -EINVAL;
236 : }
237 :
238 : /* modifier specific checks: */
239 55 : switch (r->modifier[i]) {
240 : case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
241 : /* NOTE: the pitch restriction may be lifted later if it turns
242 : * out that no hw has this restriction:
243 : */
244 11 : if (r->pixel_format != DRM_FORMAT_NV12 ||
245 15 : width % 128 || height % 32 ||
246 5 : r->pitches[i] % 128) {
247 1 : drm_dbg_kms(dev, "bad modifier data for plane %d\n", i);
248 1 : return -EINVAL;
249 : }
250 : break;
251 :
252 : default:
253 : break;
254 : }
255 : }
256 :
257 50 : for (i = info->num_planes; i < 4; i++) {
258 56 : if (r->modifier[i]) {
259 3 : drm_dbg_kms(dev, "non-zero modifier for unused plane %d\n", i);
260 3 : return -EINVAL;
261 : }
262 :
263 : /* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */
264 53 : if (!(r->flags & DRM_MODE_FB_MODIFIERS))
265 37 : continue;
266 :
267 16 : if (r->handles[i]) {
268 2 : drm_dbg_kms(dev, "buffer object handle for unused plane %d\n", i);
269 2 : return -EINVAL;
270 : }
271 :
272 14 : if (r->pitches[i]) {
273 1 : drm_dbg_kms(dev, "non-zero pitch for unused plane %d\n", i);
274 1 : return -EINVAL;
275 : }
276 :
277 13 : if (r->offsets[i]) {
278 0 : drm_dbg_kms(dev, "non-zero offset for unused plane %d\n", i);
279 0 : return -EINVAL;
280 : }
281 : }
282 :
283 : return 0;
284 : }
285 :
286 : struct drm_framebuffer *
287 47 : drm_internal_framebuffer_create(struct drm_device *dev,
288 : const struct drm_mode_fb_cmd2 *r,
289 : struct drm_file *file_priv)
290 : {
291 47 : struct drm_mode_config *config = &dev->mode_config;
292 : struct drm_framebuffer *fb;
293 : int ret;
294 :
295 47 : if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) {
296 0 : drm_dbg_kms(dev, "bad framebuffer flags 0x%08x\n", r->flags);
297 0 : return ERR_PTR(-EINVAL);
298 : }
299 :
300 47 : if ((config->min_width > r->width) || (r->width > config->max_width)) {
301 2 : drm_dbg_kms(dev, "bad framebuffer width %d, should be >= %d && <= %d\n",
302 : r->width, config->min_width, config->max_width);
303 2 : return ERR_PTR(-EINVAL);
304 : }
305 45 : if ((config->min_height > r->height) || (r->height > config->max_height)) {
306 1 : drm_dbg_kms(dev, "bad framebuffer height %d, should be >= %d && <= %d\n",
307 : r->height, config->min_height, config->max_height);
308 1 : return ERR_PTR(-EINVAL);
309 : }
310 :
311 60 : if (r->flags & DRM_MODE_FB_MODIFIERS &&
312 16 : dev->mode_config.fb_modifiers_not_supported) {
313 0 : drm_dbg_kms(dev, "driver does not support fb modifiers\n");
314 0 : return ERR_PTR(-EINVAL);
315 : }
316 :
317 44 : ret = framebuffer_check(dev, r);
318 44 : if (ret)
319 44 : return ERR_PTR(ret);
320 :
321 22 : fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
322 22 : if (IS_ERR(fb)) {
323 22 : drm_dbg_kms(dev, "could not create framebuffer\n");
324 22 : return fb;
325 : }
326 :
327 : return fb;
328 : }
329 : EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_internal_framebuffer_create);
330 :
331 : /**
332 : * drm_mode_addfb2 - add an FB to the graphics configuration
333 : * @dev: drm device for the ioctl
334 : * @data: data pointer for the ioctl
335 : * @file_priv: drm file for the ioctl call
336 : *
337 : * Add a new FB to the specified CRTC, given a user request with format. This is
338 : * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
339 : * and uses fourcc codes as pixel format specifiers.
340 : *
341 : * Called by the user via ioctl.
342 : *
343 : * Returns:
344 : * Zero on success, negative errno on failure.
345 : */
346 0 : int drm_mode_addfb2(struct drm_device *dev,
347 : void *data, struct drm_file *file_priv)
348 : {
349 0 : struct drm_mode_fb_cmd2 *r = data;
350 : struct drm_framebuffer *fb;
351 :
352 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
353 : return -EOPNOTSUPP;
354 :
355 0 : fb = drm_internal_framebuffer_create(dev, r, file_priv);
356 0 : if (IS_ERR(fb))
357 0 : return PTR_ERR(fb);
358 :
359 0 : drm_dbg_kms(dev, "[FB:%d]\n", fb->base.id);
360 0 : r->fb_id = fb->base.id;
361 :
362 : /* Transfer ownership to the filp for reaping on close */
363 0 : mutex_lock(&file_priv->fbs_lock);
364 0 : list_add(&fb->filp_head, &file_priv->fbs);
365 0 : mutex_unlock(&file_priv->fbs_lock);
366 :
367 0 : return 0;
368 : }
369 :
370 0 : int drm_mode_addfb2_ioctl(struct drm_device *dev,
371 : void *data, struct drm_file *file_priv)
372 : {
373 : #ifdef __BIG_ENDIAN
374 : if (!dev->mode_config.quirk_addfb_prefer_host_byte_order) {
375 : /*
376 : * Drivers must set the
377 : * quirk_addfb_prefer_host_byte_order quirk to make
378 : * the drm_mode_addfb() compat code work correctly on
379 : * bigendian machines.
380 : *
381 : * If they don't they interpret pixel_format values
382 : * incorrectly for bug compatibility, which in turn
383 : * implies the ADDFB2 ioctl does not work correctly
384 : * then. So block it to make userspace fallback to
385 : * ADDFB.
386 : */
387 : drm_dbg_kms(dev, "addfb2 broken on bigendian");
388 : return -EOPNOTSUPP;
389 : }
390 : #endif
391 0 : return drm_mode_addfb2(dev, data, file_priv);
392 : }
393 :
394 : struct drm_mode_rmfb_work {
395 : struct work_struct work;
396 : struct list_head fbs;
397 : };
398 :
399 0 : static void drm_mode_rmfb_work_fn(struct work_struct *w)
400 : {
401 0 : struct drm_mode_rmfb_work *arg = container_of(w, typeof(*arg), work);
402 :
403 0 : while (!list_empty(&arg->fbs)) {
404 0 : struct drm_framebuffer *fb =
405 0 : list_first_entry(&arg->fbs, typeof(*fb), filp_head);
406 :
407 0 : drm_dbg_kms(fb->dev,
408 : "Removing [FB:%d] from all active usage due to RMFB ioctl\n",
409 : fb->base.id);
410 0 : list_del_init(&fb->filp_head);
411 0 : drm_framebuffer_remove(fb);
412 : }
413 0 : }
414 :
415 : /**
416 : * drm_mode_rmfb - remove an FB from the configuration
417 : * @dev: drm device
418 : * @fb_id: id of framebuffer to remove
419 : * @file_priv: drm file
420 : *
421 : * Remove the specified FB.
422 : *
423 : * Called by the user via ioctl, or by an in-kernel client.
424 : *
425 : * Returns:
426 : * Zero on success, negative errno on failure.
427 : */
428 0 : int drm_mode_rmfb(struct drm_device *dev, u32 fb_id,
429 : struct drm_file *file_priv)
430 : {
431 0 : struct drm_framebuffer *fb = NULL;
432 0 : struct drm_framebuffer *fbl = NULL;
433 0 : int found = 0;
434 :
435 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
436 : return -EOPNOTSUPP;
437 :
438 0 : fb = drm_framebuffer_lookup(dev, file_priv, fb_id);
439 0 : if (!fb)
440 : return -ENOENT;
441 :
442 0 : mutex_lock(&file_priv->fbs_lock);
443 0 : list_for_each_entry(fbl, &file_priv->fbs, filp_head)
444 0 : if (fb == fbl)
445 0 : found = 1;
446 0 : if (!found) {
447 0 : mutex_unlock(&file_priv->fbs_lock);
448 : goto fail_unref;
449 : }
450 :
451 0 : list_del_init(&fb->filp_head);
452 0 : mutex_unlock(&file_priv->fbs_lock);
453 :
454 : /* drop the reference we picked up in framebuffer lookup */
455 0 : drm_framebuffer_put(fb);
456 :
457 : /*
458 : * we now own the reference that was stored in the fbs list
459 : *
460 : * drm_framebuffer_remove may fail with -EINTR on pending signals,
461 : * so run this in a separate stack as there's no way to correctly
462 : * handle this after the fb is already removed from the lookup table.
463 : */
464 0 : if (drm_framebuffer_read_refcount(fb) > 1) {
465 : struct drm_mode_rmfb_work arg;
466 :
467 0 : INIT_WORK_ONSTACK(&arg.work, drm_mode_rmfb_work_fn);
468 0 : INIT_LIST_HEAD(&arg.fbs);
469 0 : list_add_tail(&fb->filp_head, &arg.fbs);
470 :
471 0 : schedule_work(&arg.work);
472 0 : flush_work(&arg.work);
473 0 : destroy_work_on_stack(&arg.work);
474 : } else
475 : drm_framebuffer_put(fb);
476 :
477 : return 0;
478 :
479 : fail_unref:
480 0 : drm_framebuffer_put(fb);
481 0 : return -ENOENT;
482 : }
483 :
484 0 : int drm_mode_rmfb_ioctl(struct drm_device *dev,
485 : void *data, struct drm_file *file_priv)
486 : {
487 0 : uint32_t *fb_id = data;
488 :
489 0 : return drm_mode_rmfb(dev, *fb_id, file_priv);
490 : }
491 :
492 : /**
493 : * drm_mode_getfb - get FB info
494 : * @dev: drm device for the ioctl
495 : * @data: data pointer for the ioctl
496 : * @file_priv: drm file for the ioctl call
497 : *
498 : * Lookup the FB given its ID and return info about it.
499 : *
500 : * Called by the user via ioctl.
501 : *
502 : * Returns:
503 : * Zero on success, negative errno on failure.
504 : */
505 0 : int drm_mode_getfb(struct drm_device *dev,
506 : void *data, struct drm_file *file_priv)
507 : {
508 0 : struct drm_mode_fb_cmd *r = data;
509 : struct drm_framebuffer *fb;
510 : int ret;
511 :
512 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
513 : return -EOPNOTSUPP;
514 :
515 0 : fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
516 0 : if (!fb)
517 : return -ENOENT;
518 :
519 : /* Multi-planar framebuffers need getfb2. */
520 0 : if (fb->format->num_planes > 1) {
521 : ret = -EINVAL;
522 : goto out;
523 : }
524 :
525 0 : if (!fb->funcs->create_handle) {
526 : ret = -ENODEV;
527 : goto out;
528 : }
529 :
530 0 : r->height = fb->height;
531 0 : r->width = fb->width;
532 0 : r->depth = fb->format->depth;
533 0 : r->bpp = drm_format_info_bpp(fb->format, 0);
534 0 : r->pitch = fb->pitches[0];
535 :
536 : /* GET_FB() is an unprivileged ioctl so we must not return a
537 : * buffer-handle to non-master processes! For
538 : * backwards-compatibility reasons, we cannot make GET_FB() privileged,
539 : * so just return an invalid handle for non-masters.
540 : */
541 0 : if (!drm_is_current_master(file_priv) && !capable(CAP_SYS_ADMIN)) {
542 0 : r->handle = 0;
543 0 : ret = 0;
544 0 : goto out;
545 : }
546 :
547 0 : ret = fb->funcs->create_handle(fb, file_priv, &r->handle);
548 :
549 : out:
550 0 : drm_framebuffer_put(fb);
551 0 : return ret;
552 : }
553 :
554 : /**
555 : * drm_mode_getfb2_ioctl - get extended FB info
556 : * @dev: drm device for the ioctl
557 : * @data: data pointer for the ioctl
558 : * @file_priv: drm file for the ioctl call
559 : *
560 : * Lookup the FB given its ID and return info about it.
561 : *
562 : * Called by the user via ioctl.
563 : *
564 : * Returns:
565 : * Zero on success, negative errno on failure.
566 : */
567 0 : int drm_mode_getfb2_ioctl(struct drm_device *dev,
568 : void *data, struct drm_file *file_priv)
569 : {
570 0 : struct drm_mode_fb_cmd2 *r = data;
571 : struct drm_framebuffer *fb;
572 : unsigned int i;
573 : int ret;
574 :
575 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
576 : return -EINVAL;
577 :
578 0 : fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
579 0 : if (!fb)
580 : return -ENOENT;
581 :
582 : /* For multi-plane framebuffers, we require the driver to place the
583 : * GEM objects directly in the drm_framebuffer. For single-plane
584 : * framebuffers, we can fall back to create_handle.
585 : */
586 0 : if (!fb->obj[0] &&
587 0 : (fb->format->num_planes > 1 || !fb->funcs->create_handle)) {
588 : ret = -ENODEV;
589 : goto out;
590 : }
591 :
592 0 : r->height = fb->height;
593 0 : r->width = fb->width;
594 0 : r->pixel_format = fb->format->format;
595 :
596 0 : r->flags = 0;
597 0 : if (!dev->mode_config.fb_modifiers_not_supported)
598 0 : r->flags |= DRM_MODE_FB_MODIFIERS;
599 :
600 0 : for (i = 0; i < ARRAY_SIZE(r->handles); i++) {
601 0 : r->handles[i] = 0;
602 0 : r->pitches[i] = 0;
603 0 : r->offsets[i] = 0;
604 0 : r->modifier[i] = 0;
605 : }
606 :
607 0 : for (i = 0; i < fb->format->num_planes; i++) {
608 0 : r->pitches[i] = fb->pitches[i];
609 0 : r->offsets[i] = fb->offsets[i];
610 0 : if (!dev->mode_config.fb_modifiers_not_supported)
611 0 : r->modifier[i] = fb->modifier;
612 : }
613 :
614 : /* GET_FB2() is an unprivileged ioctl so we must not return a
615 : * buffer-handle to non master/root processes! To match GET_FB()
616 : * just return invalid handles (0) for non masters/root
617 : * rather than making GET_FB2() privileged.
618 : */
619 0 : if (!drm_is_current_master(file_priv) && !capable(CAP_SYS_ADMIN)) {
620 : ret = 0;
621 : goto out;
622 : }
623 :
624 0 : for (i = 0; i < fb->format->num_planes; i++) {
625 : int j;
626 :
627 : /* If we reuse the same object for multiple planes, also
628 : * return the same handle.
629 : */
630 0 : for (j = 0; j < i; j++) {
631 0 : if (fb->obj[i] == fb->obj[j]) {
632 0 : r->handles[i] = r->handles[j];
633 0 : break;
634 : }
635 : }
636 :
637 0 : if (r->handles[i])
638 0 : continue;
639 :
640 0 : if (fb->obj[i]) {
641 0 : ret = drm_gem_handle_create(file_priv, fb->obj[i],
642 0 : &r->handles[i]);
643 : } else {
644 0 : WARN_ON(i > 0);
645 0 : ret = fb->funcs->create_handle(fb, file_priv,
646 0 : &r->handles[i]);
647 : }
648 :
649 0 : if (ret != 0)
650 : goto out;
651 : }
652 :
653 : out:
654 0 : if (ret != 0) {
655 : /* Delete any previously-created handles on failure. */
656 0 : for (i = 0; i < ARRAY_SIZE(r->handles); i++) {
657 : int j;
658 :
659 0 : if (r->handles[i])
660 0 : drm_gem_handle_delete(file_priv, r->handles[i]);
661 :
662 : /* Zero out any handles identical to the one we just
663 : * deleted.
664 : */
665 0 : for (j = i + 1; j < ARRAY_SIZE(r->handles); j++) {
666 0 : if (r->handles[j] == r->handles[i])
667 0 : r->handles[j] = 0;
668 : }
669 : }
670 : }
671 :
672 0 : drm_framebuffer_put(fb);
673 0 : return ret;
674 : }
675 :
676 : /**
677 : * drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
678 : * @dev: drm device for the ioctl
679 : * @data: data pointer for the ioctl
680 : * @file_priv: drm file for the ioctl call
681 : *
682 : * Lookup the FB and flush out the damaged area supplied by userspace as a clip
683 : * rectangle list. Generic userspace which does frontbuffer rendering must call
684 : * this ioctl to flush out the changes on manual-update display outputs, e.g.
685 : * usb display-link, mipi manual update panels or edp panel self refresh modes.
686 : *
687 : * Modesetting drivers which always update the frontbuffer do not need to
688 : * implement the corresponding &drm_framebuffer_funcs.dirty callback.
689 : *
690 : * Called by the user via ioctl.
691 : *
692 : * Returns:
693 : * Zero on success, negative errno on failure.
694 : */
695 0 : int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
696 : void *data, struct drm_file *file_priv)
697 : {
698 : struct drm_clip_rect __user *clips_ptr;
699 0 : struct drm_clip_rect *clips = NULL;
700 0 : struct drm_mode_fb_dirty_cmd *r = data;
701 : struct drm_framebuffer *fb;
702 : unsigned flags;
703 : int num_clips;
704 : int ret;
705 :
706 0 : if (!drm_core_check_feature(dev, DRIVER_MODESET))
707 : return -EOPNOTSUPP;
708 :
709 0 : fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
710 0 : if (!fb)
711 : return -ENOENT;
712 :
713 0 : num_clips = r->num_clips;
714 0 : clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
715 :
716 0 : if (!num_clips != !clips_ptr) {
717 : ret = -EINVAL;
718 : goto out_err1;
719 : }
720 :
721 0 : flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;
722 :
723 : /* If userspace annotates copy, clips must come in pairs */
724 0 : if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
725 : ret = -EINVAL;
726 : goto out_err1;
727 : }
728 :
729 0 : if (num_clips && clips_ptr) {
730 0 : if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
731 : ret = -EINVAL;
732 : goto out_err1;
733 : }
734 0 : clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
735 0 : if (!clips) {
736 : ret = -ENOMEM;
737 : goto out_err1;
738 : }
739 :
740 0 : ret = copy_from_user(clips, clips_ptr,
741 : num_clips * sizeof(*clips));
742 0 : if (ret) {
743 : ret = -EFAULT;
744 : goto out_err2;
745 : }
746 : }
747 :
748 0 : if (fb->funcs->dirty) {
749 0 : ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
750 : clips, num_clips);
751 : } else {
752 : ret = -ENOSYS;
753 : }
754 :
755 : out_err2:
756 0 : kfree(clips);
757 : out_err1:
758 0 : drm_framebuffer_put(fb);
759 :
760 0 : return ret;
761 : }
762 :
763 : /**
764 : * drm_fb_release - remove and free the FBs on this file
765 : * @priv: drm file for the ioctl
766 : *
767 : * Destroy all the FBs associated with @filp.
768 : *
769 : * Called by the user via ioctl.
770 : *
771 : * Returns:
772 : * Zero on success, negative errno on failure.
773 : */
774 0 : void drm_fb_release(struct drm_file *priv)
775 : {
776 : struct drm_framebuffer *fb, *tfb;
777 : struct drm_mode_rmfb_work arg;
778 :
779 0 : INIT_LIST_HEAD(&arg.fbs);
780 :
781 : /*
782 : * When the file gets released that means no one else can access the fb
783 : * list any more, so no need to grab fpriv->fbs_lock. And we need to
784 : * avoid upsetting lockdep since the universal cursor code adds a
785 : * framebuffer while holding mutex locks.
786 : *
787 : * Note that a real deadlock between fpriv->fbs_lock and the modeset
788 : * locks is impossible here since no one else but this function can get
789 : * at it any more.
790 : */
791 0 : list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
792 0 : if (drm_framebuffer_read_refcount(fb) > 1) {
793 0 : list_move_tail(&fb->filp_head, &arg.fbs);
794 : } else {
795 0 : list_del_init(&fb->filp_head);
796 :
797 : /* This drops the fpriv->fbs reference. */
798 : drm_framebuffer_put(fb);
799 : }
800 : }
801 :
802 0 : if (!list_empty(&arg.fbs)) {
803 0 : INIT_WORK_ONSTACK(&arg.work, drm_mode_rmfb_work_fn);
804 :
805 0 : schedule_work(&arg.work);
806 0 : flush_work(&arg.work);
807 0 : destroy_work_on_stack(&arg.work);
808 : }
809 0 : }
810 :
811 0 : void drm_framebuffer_free(struct kref *kref)
812 : {
813 0 : struct drm_framebuffer *fb =
814 0 : container_of(kref, struct drm_framebuffer, base.refcount);
815 0 : struct drm_device *dev = fb->dev;
816 :
817 : /*
818 : * The lookup idr holds a weak reference, which has not necessarily been
819 : * removed at this point. Check for that.
820 : */
821 0 : drm_mode_object_unregister(dev, &fb->base);
822 :
823 0 : fb->funcs->destroy(fb);
824 0 : }
825 :
826 : /**
827 : * drm_framebuffer_init - initialize a framebuffer
828 : * @dev: DRM device
829 : * @fb: framebuffer to be initialized
830 : * @funcs: ... with these functions
831 : *
832 : * Allocates an ID for the framebuffer's parent mode object, sets its mode
833 : * functions & device file and adds it to the master fd list.
834 : *
835 : * IMPORTANT:
836 : * This functions publishes the fb and makes it available for concurrent access
837 : * by other users. Which means by this point the fb _must_ be fully set up -
838 : * since all the fb attributes are invariant over its lifetime, no further
839 : * locking but only correct reference counting is required.
840 : *
841 : * Returns:
842 : * Zero on success, error code on failure.
843 : */
844 0 : int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
845 : const struct drm_framebuffer_funcs *funcs)
846 : {
847 : int ret;
848 :
849 0 : if (WARN_ON_ONCE(fb->dev != dev || !fb->format))
850 : return -EINVAL;
851 :
852 0 : INIT_LIST_HEAD(&fb->filp_head);
853 :
854 0 : fb->funcs = funcs;
855 0 : strcpy(fb->comm, current->comm);
856 :
857 0 : ret = __drm_mode_object_add(dev, &fb->base, DRM_MODE_OBJECT_FB,
858 : false, drm_framebuffer_free);
859 0 : if (ret)
860 : goto out;
861 :
862 0 : mutex_lock(&dev->mode_config.fb_lock);
863 0 : dev->mode_config.num_fb++;
864 0 : list_add(&fb->head, &dev->mode_config.fb_list);
865 0 : mutex_unlock(&dev->mode_config.fb_lock);
866 :
867 0 : drm_mode_object_register(dev, &fb->base);
868 : out:
869 : return ret;
870 : }
871 : EXPORT_SYMBOL(drm_framebuffer_init);
872 :
873 : /**
874 : * drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
875 : * @dev: drm device
876 : * @file_priv: drm file to check for lease against.
877 : * @id: id of the fb object
878 : *
879 : * If successful, this grabs an additional reference to the framebuffer -
880 : * callers need to make sure to eventually unreference the returned framebuffer
881 : * again, using drm_framebuffer_put().
882 : */
883 0 : struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
884 : struct drm_file *file_priv,
885 : uint32_t id)
886 : {
887 : struct drm_mode_object *obj;
888 0 : struct drm_framebuffer *fb = NULL;
889 :
890 0 : obj = __drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_FB);
891 0 : if (obj)
892 0 : fb = obj_to_fb(obj);
893 0 : return fb;
894 : }
895 : EXPORT_SYMBOL(drm_framebuffer_lookup);
896 :
897 : /**
898 : * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
899 : * @fb: fb to unregister
900 : *
901 : * Drivers need to call this when cleaning up driver-private framebuffers, e.g.
902 : * those used for fbdev. Note that the caller must hold a reference of its own,
903 : * i.e. the object may not be destroyed through this call (since it'll lead to a
904 : * locking inversion).
905 : *
906 : * NOTE: This function is deprecated. For driver-private framebuffers it is not
907 : * recommended to embed a framebuffer struct info fbdev struct, instead, a
908 : * framebuffer pointer is preferred and drm_framebuffer_put() should be called
909 : * when the framebuffer is to be cleaned up.
910 : */
911 0 : void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
912 : {
913 : struct drm_device *dev;
914 :
915 0 : if (!fb)
916 : return;
917 :
918 0 : dev = fb->dev;
919 :
920 : /* Mark fb as reaped and drop idr ref. */
921 0 : drm_mode_object_unregister(dev, &fb->base);
922 : }
923 : EXPORT_SYMBOL(drm_framebuffer_unregister_private);
924 :
925 : /**
926 : * drm_framebuffer_cleanup - remove a framebuffer object
927 : * @fb: framebuffer to remove
928 : *
929 : * Cleanup framebuffer. This function is intended to be used from the drivers
930 : * &drm_framebuffer_funcs.destroy callback. It can also be used to clean up
931 : * driver private framebuffers embedded into a larger structure.
932 : *
933 : * Note that this function does not remove the fb from active usage - if it is
934 : * still used anywhere, hilarity can ensue since userspace could call getfb on
935 : * the id and get back -EINVAL. Obviously no concern at driver unload time.
936 : *
937 : * Also, the framebuffer will not be removed from the lookup idr - for
938 : * user-created framebuffers this will happen in the rmfb ioctl. For
939 : * driver-private objects (e.g. for fbdev) drivers need to explicitly call
940 : * drm_framebuffer_unregister_private.
941 : */
942 0 : void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
943 : {
944 0 : struct drm_device *dev = fb->dev;
945 :
946 0 : mutex_lock(&dev->mode_config.fb_lock);
947 0 : list_del(&fb->head);
948 0 : dev->mode_config.num_fb--;
949 0 : mutex_unlock(&dev->mode_config.fb_lock);
950 0 : }
951 : EXPORT_SYMBOL(drm_framebuffer_cleanup);
952 :
953 0 : static int atomic_remove_fb(struct drm_framebuffer *fb)
954 : {
955 : struct drm_modeset_acquire_ctx ctx;
956 0 : struct drm_device *dev = fb->dev;
957 : struct drm_atomic_state *state;
958 : struct drm_plane *plane;
959 : struct drm_connector *conn __maybe_unused;
960 : struct drm_connector_state *conn_state;
961 : int i, ret;
962 : unsigned plane_mask;
963 0 : bool disable_crtcs = false;
964 :
965 : retry_disable:
966 0 : drm_modeset_acquire_init(&ctx, 0);
967 :
968 0 : state = drm_atomic_state_alloc(dev);
969 0 : if (!state) {
970 : ret = -ENOMEM;
971 : goto out;
972 : }
973 0 : state->acquire_ctx = &ctx;
974 :
975 : retry:
976 0 : plane_mask = 0;
977 0 : ret = drm_modeset_lock_all_ctx(dev, &ctx);
978 0 : if (ret)
979 : goto unlock;
980 :
981 0 : drm_for_each_plane(plane, dev) {
982 : struct drm_plane_state *plane_state;
983 :
984 0 : if (plane->state->fb != fb)
985 0 : continue;
986 :
987 0 : drm_dbg_kms(dev,
988 : "Disabling [PLANE:%d:%s] because [FB:%d] is removed\n",
989 : plane->base.id, plane->name, fb->base.id);
990 :
991 0 : plane_state = drm_atomic_get_plane_state(state, plane);
992 0 : if (IS_ERR(plane_state)) {
993 0 : ret = PTR_ERR(plane_state);
994 0 : goto unlock;
995 : }
996 :
997 0 : if (disable_crtcs && plane_state->crtc->primary == plane) {
998 : struct drm_crtc_state *crtc_state;
999 :
1000 0 : drm_dbg_kms(dev,
1001 : "Disabling [CRTC:%d:%s] because [FB:%d] is removed\n",
1002 : plane_state->crtc->base.id,
1003 : plane_state->crtc->name, fb->base.id);
1004 :
1005 0 : crtc_state = drm_atomic_get_existing_crtc_state(state, plane_state->crtc);
1006 :
1007 0 : ret = drm_atomic_add_affected_connectors(state, plane_state->crtc);
1008 0 : if (ret)
1009 : goto unlock;
1010 :
1011 0 : crtc_state->active = false;
1012 0 : ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1013 0 : if (ret)
1014 : goto unlock;
1015 : }
1016 :
1017 0 : drm_atomic_set_fb_for_plane(plane_state, NULL);
1018 0 : ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1019 0 : if (ret)
1020 : goto unlock;
1021 :
1022 0 : plane_mask |= drm_plane_mask(plane);
1023 : }
1024 :
1025 : /* This list is only filled when disable_crtcs is set. */
1026 0 : for_each_new_connector_in_state(state, conn, conn_state, i) {
1027 0 : ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
1028 :
1029 0 : if (ret)
1030 : goto unlock;
1031 : }
1032 :
1033 0 : if (plane_mask)
1034 0 : ret = drm_atomic_commit(state);
1035 :
1036 : unlock:
1037 0 : if (ret == -EDEADLK) {
1038 0 : drm_atomic_state_clear(state);
1039 0 : drm_modeset_backoff(&ctx);
1040 0 : goto retry;
1041 : }
1042 :
1043 : drm_atomic_state_put(state);
1044 :
1045 : out:
1046 0 : drm_modeset_drop_locks(&ctx);
1047 0 : drm_modeset_acquire_fini(&ctx);
1048 :
1049 0 : if (ret == -EINVAL && !disable_crtcs) {
1050 : disable_crtcs = true;
1051 : goto retry_disable;
1052 : }
1053 :
1054 0 : return ret;
1055 : }
1056 :
1057 0 : static void legacy_remove_fb(struct drm_framebuffer *fb)
1058 : {
1059 0 : struct drm_device *dev = fb->dev;
1060 : struct drm_crtc *crtc;
1061 : struct drm_plane *plane;
1062 :
1063 0 : drm_modeset_lock_all(dev);
1064 : /* remove from any CRTC */
1065 0 : drm_for_each_crtc(crtc, dev) {
1066 0 : if (crtc->primary->fb == fb) {
1067 0 : drm_dbg_kms(dev,
1068 : "Disabling [CRTC:%d:%s] because [FB:%d] is removed\n",
1069 : crtc->base.id, crtc->name, fb->base.id);
1070 :
1071 : /* should turn off the crtc */
1072 0 : if (drm_crtc_force_disable(crtc))
1073 0 : DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
1074 : }
1075 : }
1076 :
1077 0 : drm_for_each_plane(plane, dev) {
1078 0 : if (plane->fb == fb) {
1079 0 : drm_dbg_kms(dev,
1080 : "Disabling [PLANE:%d:%s] because [FB:%d] is removed\n",
1081 : plane->base.id, plane->name, fb->base.id);
1082 0 : drm_plane_force_disable(plane);
1083 : }
1084 : }
1085 0 : drm_modeset_unlock_all(dev);
1086 0 : }
1087 :
1088 : /**
1089 : * drm_framebuffer_remove - remove and unreference a framebuffer object
1090 : * @fb: framebuffer to remove
1091 : *
1092 : * Scans all the CRTCs and planes in @dev's mode_config. If they're
1093 : * using @fb, removes it, setting it to NULL. Then drops the reference to the
1094 : * passed-in framebuffer. Might take the modeset locks.
1095 : *
1096 : * Note that this function optimizes the cleanup away if the caller holds the
1097 : * last reference to the framebuffer. It is also guaranteed to not take the
1098 : * modeset locks in this case.
1099 : */
1100 0 : void drm_framebuffer_remove(struct drm_framebuffer *fb)
1101 : {
1102 : struct drm_device *dev;
1103 :
1104 0 : if (!fb)
1105 : return;
1106 :
1107 0 : dev = fb->dev;
1108 :
1109 0 : WARN_ON(!list_empty(&fb->filp_head));
1110 :
1111 : /*
1112 : * drm ABI mandates that we remove any deleted framebuffers from active
1113 : * usage. But since most sane clients only remove framebuffers they no
1114 : * longer need, try to optimize this away.
1115 : *
1116 : * Since we're holding a reference ourselves, observing a refcount of 1
1117 : * means that we're the last holder and can skip it. Also, the refcount
1118 : * can never increase from 1 again, so we don't need any barriers or
1119 : * locks.
1120 : *
1121 : * Note that userspace could try to race with use and instate a new
1122 : * usage _after_ we've cleared all current ones. End result will be an
1123 : * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
1124 : * in this manner.
1125 : */
1126 0 : if (drm_framebuffer_read_refcount(fb) > 1) {
1127 0 : if (drm_drv_uses_atomic_modeset(dev)) {
1128 0 : int ret = atomic_remove_fb(fb);
1129 :
1130 0 : WARN(ret, "atomic remove_fb failed with %i\n", ret);
1131 : } else
1132 0 : legacy_remove_fb(fb);
1133 : }
1134 :
1135 : drm_framebuffer_put(fb);
1136 : }
1137 : EXPORT_SYMBOL(drm_framebuffer_remove);
1138 :
1139 : /**
1140 : * drm_framebuffer_plane_width - width of the plane given the first plane
1141 : * @width: width of the first plane
1142 : * @fb: the framebuffer
1143 : * @plane: plane index
1144 : *
1145 : * Returns:
1146 : * The width of @plane, given that the width of the first plane is @width.
1147 : */
1148 0 : int drm_framebuffer_plane_width(int width,
1149 : const struct drm_framebuffer *fb, int plane)
1150 : {
1151 0 : if (plane >= fb->format->num_planes)
1152 : return 0;
1153 :
1154 0 : return fb_plane_width(width, fb->format, plane);
1155 : }
1156 : EXPORT_SYMBOL(drm_framebuffer_plane_width);
1157 :
1158 : /**
1159 : * drm_framebuffer_plane_height - height of the plane given the first plane
1160 : * @height: height of the first plane
1161 : * @fb: the framebuffer
1162 : * @plane: plane index
1163 : *
1164 : * Returns:
1165 : * The height of @plane, given that the height of the first plane is @height.
1166 : */
1167 0 : int drm_framebuffer_plane_height(int height,
1168 : const struct drm_framebuffer *fb, int plane)
1169 : {
1170 0 : if (plane >= fb->format->num_planes)
1171 : return 0;
1172 :
1173 0 : return fb_plane_height(height, fb->format, plane);
1174 : }
1175 : EXPORT_SYMBOL(drm_framebuffer_plane_height);
1176 :
1177 0 : void drm_framebuffer_print_info(struct drm_printer *p, unsigned int indent,
1178 : const struct drm_framebuffer *fb)
1179 : {
1180 : unsigned int i;
1181 :
1182 0 : drm_printf_indent(p, indent, "allocated by = %s\n", fb->comm);
1183 0 : drm_printf_indent(p, indent, "refcount=%u\n",
1184 : drm_framebuffer_read_refcount(fb));
1185 0 : drm_printf_indent(p, indent, "format=%p4cc\n", &fb->format->format);
1186 0 : drm_printf_indent(p, indent, "modifier=0x%llx\n", fb->modifier);
1187 0 : drm_printf_indent(p, indent, "size=%ux%u\n", fb->width, fb->height);
1188 0 : drm_printf_indent(p, indent, "layers:\n");
1189 :
1190 0 : for (i = 0; i < fb->format->num_planes; i++) {
1191 0 : drm_printf_indent(p, indent + 1, "size[%u]=%dx%d\n", i,
1192 : drm_framebuffer_plane_width(fb->width, fb, i),
1193 : drm_framebuffer_plane_height(fb->height, fb, i));
1194 0 : drm_printf_indent(p, indent + 1, "pitch[%u]=%u\n", i, fb->pitches[i]);
1195 0 : drm_printf_indent(p, indent + 1, "offset[%u]=%u\n", i, fb->offsets[i]);
1196 0 : drm_printf_indent(p, indent + 1, "obj[%u]:%s\n", i,
1197 : fb->obj[i] ? "" : "(null)");
1198 0 : if (fb->obj[i])
1199 0 : drm_gem_print_info(p, indent + 2, fb->obj[i]);
1200 : }
1201 0 : }
1202 :
1203 : #ifdef CONFIG_DEBUG_FS
1204 : static int drm_framebuffer_info(struct seq_file *m, void *data)
1205 : {
1206 : struct drm_debugfs_entry *entry = m->private;
1207 : struct drm_device *dev = entry->dev;
1208 : struct drm_printer p = drm_seq_file_printer(m);
1209 : struct drm_framebuffer *fb;
1210 :
1211 : mutex_lock(&dev->mode_config.fb_lock);
1212 : drm_for_each_fb(fb, dev) {
1213 : drm_printf(&p, "framebuffer[%u]:\n", fb->base.id);
1214 : drm_framebuffer_print_info(&p, 1, fb);
1215 : }
1216 : mutex_unlock(&dev->mode_config.fb_lock);
1217 :
1218 : return 0;
1219 : }
1220 :
1221 : static const struct drm_debugfs_info drm_framebuffer_debugfs_list[] = {
1222 : { "framebuffer", drm_framebuffer_info, 0 },
1223 : };
1224 :
1225 : void drm_framebuffer_debugfs_init(struct drm_minor *minor)
1226 : {
1227 : drm_debugfs_add_files(minor->dev, drm_framebuffer_debugfs_list,
1228 : ARRAY_SIZE(drm_framebuffer_debugfs_list));
1229 : }
1230 : #endif
|
