drivers/gpu/drm/drm_dumb_buffers.c

   1 /*
   2  * Copyright (c) 2006-2008 Intel Corporation
   3  * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
   4  * Copyright (c) 2008 Red Hat Inc.
   5  * Copyright (c) 2016 Intel Corporation
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and its
   8  * documentation for any purpose is hereby granted without fee, provided that
   9  * the above copyright notice appear in all copies and that both that copyright
  10  * notice and this permission notice appear in supporting documentation, and
  11  * that the name of the copyright holders not be used in advertising or
  12  * publicity pertaining to distribution of the software without specific,
  13  * written prior permission.  The copyright holders make no representations
  14  * about the suitability of this software for any purpose.  It is provided "as
  15  * is" without express or implied warranty.
  16  *
  17  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  18  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  19  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  22  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23  * OF THIS SOFTWARE.
  24  */
  25
  26 #include <drm/drmP.h>
  27
  28 #include "drm_crtc_internal.h"
  29
  30 /**
  31  * DOC: overview
  32  *
  33  * The KMS API doesn't standardize backing storage object creation and leaves it
  34  * to driver-specific ioctls. Furthermore actually creating a buffer object even
  35  * for GEM-based drivers is done through a driver-specific ioctl - GEM only has
  36  * a common userspace interface for sharing and destroying objects. While not an
  37  * issue for full-fledged graphics stacks that include device-specific userspace
  38  * components (in libdrm for instance), this limit makes DRM-based early boot
  39  * graphics unnecessarily complex.
  40  *
  41  * Dumb objects partly alleviate the problem by providing a standard API to
  42  * create dumb buffers suitable for scanout, which can then be used to create
  43  * KMS frame buffers.
  44  *
  45  * To support dumb objects drivers must implement the &drm_driver.dumb_create,
  46  * &drm_driver.dumb_destroy and &drm_driver.dumb_map_offset operations. See
  47  * there for further details.
  48  *
  49  * Note that dumb objects may not be used for gpu acceleration, as has been
  50  * attempted on some ARM embedded platforms. Such drivers really must have
  51  * a hardware-specific ioctl to allocate suitable buffer objects.
  52  */
  53
  54 int drm_mode_create_dumb_ioctl(struct drm_device *dev,
  55                                void *data, struct drm_file *file_priv)
  56 {
  57         struct drm_mode_create_dumb *args = data;
  58         u32 cpp, stride, size;
  59
  60         if (!dev->driver->dumb_create)
  61                 return -ENOSYS;
  62         if (!args->width || !args->height || !args->bpp)
  63                 return -EINVAL;
  64
  65         /* overflow checks for 32bit size calculations */
  66         /* NOTE: DIV_ROUND_UP() can overflow */
  67         cpp = DIV_ROUND_UP(args->bpp, 8);
  68         if (!cpp || cpp > 0xffffffffU / args->width)
  69                 return -EINVAL;
  70         stride = cpp * args->width;
  71         if (args->height > 0xffffffffU / stride)
  72                 return -EINVAL;
  73
  74         /* test for wrap-around */
  75         size = args->height * stride;
  76         if (PAGE_ALIGN(size) == 0)
  77                 return -EINVAL;
  78
  79         /*
  80          * handle, pitch and size are output parameters. Zero them out to
  81          * prevent drivers from accidentally using uninitialized data. Since
  82          * not all existing userspace is clearing these fields properly we
  83          * cannot reject IOCTL with garbage in them.
  84          */
  85         args->handle = 0;
  86         args->pitch = 0;
  87         args->size = 0;
  88
  89         return dev->driver->dumb_create(file_priv, dev, args);
  90 }
  91
  92 /**
  93  * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer
  94  * @dev: DRM device
  95  * @data: ioctl data
  96  * @file_priv: DRM file info
  97  *
  98  * Allocate an offset in the drm device node's address space to be able to
  99  * memory map a dumb buffer.
 100  *
 101  * Called by the user via ioctl.
 102  *
 103  * Returns:
 104  * Zero on success, negative errno on failure.
 105  */
 106 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
 107                              void *data, struct drm_file *file_priv)
 108 {
 109         struct drm_mode_map_dumb *args = data;
 110
 111         /* call driver ioctl to get mmap offset */
 112         if (!dev->driver->dumb_map_offset)
 113                 return -ENOSYS;
 114
 115         return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset);
 116 }
 117
 118 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
 119                                 void *data, struct drm_file *file_priv)
 120 {
 121         struct drm_mode_destroy_dumb *args = data;
 122
 123         if (!dev->driver->dumb_destroy)
 124                 return -ENOSYS;
 125
 126         return dev->driver->dumb_destroy(file_priv, dev, args->handle);
 127 }
 128