The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/drm2/drm_drv.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /**
    2  * \file drm_drv.c
    3  * Generic driver template
    4  *
    5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
    6  * \author Gareth Hughes <gareth@valinux.com>
    7  *
    8  * To use this template, you must at least define the following (samples
    9  * given for the MGA driver):
   10  *
   11  * \code
   12  * #define DRIVER_AUTHOR        "VA Linux Systems, Inc."
   13  *
   14  * #define DRIVER_NAME          "mga"
   15  * #define DRIVER_DESC          "Matrox G200/G400"
   16  * #define DRIVER_DATE          "20001127"
   17  *
   18  * #define drm_x                mga_##x
   19  * \endcode
   20  */
   21 
   22 /*
   23  * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
   24  *
   25  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
   26  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
   27  * All Rights Reserved.
   28  *
   29  * Permission is hereby granted, free of charge, to any person obtaining a
   30  * copy of this software and associated documentation files (the "Software"),
   31  * to deal in the Software without restriction, including without limitation
   32  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   33  * and/or sell copies of the Software, and to permit persons to whom the
   34  * Software is furnished to do so, subject to the following conditions:
   35  *
   36  * The above copyright notice and this permission notice (including the next
   37  * paragraph) shall be included in all copies or substantial portions of the
   38  * Software.
   39  *
   40  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   41  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   42  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   43  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
   44  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
   45  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
   46  * OTHER DEALINGS IN THE SOFTWARE.
   47  */
   48 
   49 #include <sys/cdefs.h>
   50 __FBSDID("$FreeBSD$");
   51 
   52 #include <sys/sysent.h>
   53 
   54 #include <dev/drm2/drmP.h>
   55 #include <dev/drm2/drm_core.h>
   56 #include <dev/drm2/drm_global.h>
   57 
   58 struct sx drm_global_mutex;
   59 
   60 /** Ioctl table */
   61 static struct drm_ioctl_desc drm_ioctls[] = {
   62         DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version, DRM_UNLOCKED),
   63         DRM_IOCTL_DEF(DRM_IOCTL_GET_UNIQUE, drm_getunique, 0),
   64         DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, 0),
   65         DRM_IOCTL_DEF(DRM_IOCTL_IRQ_BUSID, drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY),
   66         DRM_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_getmap, DRM_UNLOCKED),
   67         DRM_IOCTL_DEF(DRM_IOCTL_GET_CLIENT, drm_getclient, DRM_UNLOCKED),
   68         DRM_IOCTL_DEF(DRM_IOCTL_GET_STATS, drm_getstats, DRM_UNLOCKED),
   69         DRM_IOCTL_DEF(DRM_IOCTL_GET_CAP, drm_getcap, DRM_UNLOCKED),
   70         DRM_IOCTL_DEF(DRM_IOCTL_SET_VERSION, drm_setversion, DRM_MASTER),
   71 
   72         DRM_IOCTL_DEF(DRM_IOCTL_SET_UNIQUE, drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   73         DRM_IOCTL_DEF(DRM_IOCTL_BLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   74         DRM_IOCTL_DEF(DRM_IOCTL_UNBLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   75         DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_AUTH|DRM_MASTER),
   76 
   77         DRM_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   78         DRM_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_rmmap_ioctl, DRM_AUTH),
   79 
   80         DRM_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   81         DRM_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_getsareactx, DRM_AUTH),
   82 
   83         DRM_IOCTL_DEF(DRM_IOCTL_SET_MASTER, drm_setmaster_ioctl, DRM_ROOT_ONLY),
   84         DRM_IOCTL_DEF(DRM_IOCTL_DROP_MASTER, drm_dropmaster_ioctl, DRM_ROOT_ONLY),
   85 
   86         DRM_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_addctx, DRM_AUTH|DRM_ROOT_ONLY),
   87         DRM_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   88         DRM_IOCTL_DEF(DRM_IOCTL_MOD_CTX, drm_modctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   89         DRM_IOCTL_DEF(DRM_IOCTL_GET_CTX, drm_getctx, DRM_AUTH),
   90         DRM_IOCTL_DEF(DRM_IOCTL_SWITCH_CTX, drm_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   91         DRM_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   92         DRM_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_resctx, DRM_AUTH),
   93 
   94         DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   95         DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
   96 
   97         DRM_IOCTL_DEF(DRM_IOCTL_LOCK, drm_lock, DRM_AUTH),
   98         DRM_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_unlock, DRM_AUTH),
   99 
  100         DRM_IOCTL_DEF(DRM_IOCTL_FINISH, drm_noop, DRM_AUTH),
  101 
  102         DRM_IOCTL_DEF(DRM_IOCTL_ADD_BUFS, drm_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  103         DRM_IOCTL_DEF(DRM_IOCTL_MARK_BUFS, drm_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  104         DRM_IOCTL_DEF(DRM_IOCTL_INFO_BUFS, drm_infobufs, DRM_AUTH),
  105         DRM_IOCTL_DEF(DRM_IOCTL_MAP_BUFS, drm_mapbufs, DRM_AUTH),
  106         DRM_IOCTL_DEF(DRM_IOCTL_FREE_BUFS, drm_freebufs, DRM_AUTH),
  107         /* The DRM_IOCTL_DMA ioctl should be defined by the driver. */
  108         DRM_IOCTL_DEF(DRM_IOCTL_DMA, NULL, DRM_AUTH),
  109 
  110         DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  111 
  112 #if __OS_HAS_AGP
  113         DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  114         DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  115         DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  116         DRM_IOCTL_DEF(DRM_IOCTL_AGP_INFO, drm_agp_info_ioctl, DRM_AUTH),
  117         DRM_IOCTL_DEF(DRM_IOCTL_AGP_ALLOC, drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  118         DRM_IOCTL_DEF(DRM_IOCTL_AGP_FREE, drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  119         DRM_IOCTL_DEF(DRM_IOCTL_AGP_BIND, drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  120         DRM_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  121 #endif
  122 
  123         DRM_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_sg_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  124         DRM_IOCTL_DEF(DRM_IOCTL_SG_FREE, drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  125 
  126         DRM_IOCTL_DEF(DRM_IOCTL_WAIT_VBLANK, drm_wait_vblank, DRM_UNLOCKED),
  127 
  128         DRM_IOCTL_DEF(DRM_IOCTL_MODESET_CTL, drm_modeset_ctl, 0),
  129 
  130         DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
  131 
  132         DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE, drm_gem_close_ioctl, DRM_UNLOCKED),
  133         DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH|DRM_UNLOCKED),
  134         DRM_IOCTL_DEF(DRM_IOCTL_GEM_OPEN, drm_gem_open_ioctl, DRM_AUTH|DRM_UNLOCKED),
  135 
  136         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETRESOURCES, drm_mode_getresources, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  137 
  138 #ifdef FREEBSD_NOTYET
  139         DRM_IOCTL_DEF(DRM_IOCTL_PRIME_HANDLE_TO_FD, drm_prime_handle_to_fd_ioctl, DRM_AUTH|DRM_UNLOCKED),
  140         DRM_IOCTL_DEF(DRM_IOCTL_PRIME_FD_TO_HANDLE, drm_prime_fd_to_handle_ioctl, DRM_AUTH|DRM_UNLOCKED),
  141 #endif /* FREEBSD_NOTYET */
  142 
  143         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  144         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  145         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  146         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  147         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  148         DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  149         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_UNLOCKED),
  150         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED),
  151         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  152         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCONNECTOR, drm_mode_getconnector, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  153         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATTACHMODE, drm_mode_attachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  154         DRM_IOCTL_DEF(DRM_IOCTL_MODE_DETACHMODE, drm_mode_detachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  155         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPERTY, drm_mode_getproperty_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  156         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPROPERTY, drm_mode_connector_property_set_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  157         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  158         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  159         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  160         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  161         DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  162         DRM_IOCTL_DEF(DRM_IOCTL_MODE_PAGE_FLIP, drm_mode_page_flip_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  163         DRM_IOCTL_DEF(DRM_IOCTL_MODE_DIRTYFB, drm_mode_dirtyfb_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  164         DRM_IOCTL_DEF(DRM_IOCTL_MODE_CREATE_DUMB, drm_mode_create_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  165         DRM_IOCTL_DEF(DRM_IOCTL_MODE_MAP_DUMB, drm_mode_mmap_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  166         DRM_IOCTL_DEF(DRM_IOCTL_MODE_DESTROY_DUMB, drm_mode_destroy_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  167         DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_GETPROPERTIES, drm_mode_obj_get_properties_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  168         DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_SETPROPERTY, drm_mode_obj_set_property_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
  169 };
  170 
  171 #ifdef COMPAT_FREEBSD32
  172 extern struct drm_ioctl_desc drm_compat_ioctls[];
  173 #endif
  174 
  175 #define DRM_CORE_IOCTL_COUNT    ARRAY_SIZE( drm_ioctls )
  176 
  177 /**
  178  * Take down the DRM device.
  179  *
  180  * \param dev DRM device structure.
  181  *
  182  * Frees every resource in \p dev.
  183  *
  184  * \sa drm_device
  185  */
  186 int drm_lastclose(struct drm_device * dev)
  187 {
  188 #ifdef __linux__
  189         struct drm_vma_entry *vma, *vma_temp;
  190 #endif
  191 
  192         DRM_DEBUG("\n");
  193 
  194         if (dev->driver->lastclose)
  195                 dev->driver->lastclose(dev);
  196         DRM_DEBUG("driver lastclose completed\n");
  197 
  198         if (dev->irq_enabled && !drm_core_check_feature(dev, DRIVER_MODESET))
  199                 drm_irq_uninstall(dev);
  200 
  201         DRM_LOCK(dev);
  202 
  203         /* Clear AGP information */
  204         if (drm_core_has_AGP(dev) && dev->agp &&
  205                         !drm_core_check_feature(dev, DRIVER_MODESET)) {
  206                 struct drm_agp_mem *entry, *tempe;
  207 
  208                 /* Remove AGP resources, but leave dev->agp
  209                    intact until drv_cleanup is called. */
  210                 list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
  211                         if (entry->bound)
  212                                 drm_unbind_agp(entry->memory);
  213                         drm_free_agp(entry->memory, entry->pages);
  214                         free(entry, DRM_MEM_AGPLISTS);
  215                 }
  216                 INIT_LIST_HEAD(&dev->agp->memory);
  217 
  218                 if (dev->agp->acquired)
  219                         drm_agp_release(dev);
  220 
  221                 dev->agp->acquired = 0;
  222                 dev->agp->enabled = 0;
  223         }
  224         if (drm_core_check_feature(dev, DRIVER_SG) && dev->sg &&
  225             !drm_core_check_feature(dev, DRIVER_MODESET)) {
  226                 drm_sg_cleanup(dev->sg);
  227                 dev->sg = NULL;
  228         }
  229 
  230 #ifdef __linux__
  231         /* Clear vma list (only built for debugging) */
  232         list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {
  233                 list_del(&vma->head);
  234                 kfree(vma);
  235         }
  236 #endif
  237 
  238         if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
  239             !drm_core_check_feature(dev, DRIVER_MODESET))
  240                 drm_dma_takedown(dev);
  241 
  242         DRM_UNLOCK(dev);
  243 
  244         DRM_DEBUG("lastclose completed\n");
  245         return 0;
  246 }
  247 
  248 #ifdef __linux__
  249 /** File operations structure */
  250 static const struct file_operations drm_stub_fops = {
  251         .owner = THIS_MODULE,
  252         .open = drm_stub_open,
  253         .llseek = noop_llseek,
  254 };
  255 #endif
  256 
  257 static int __init drm_core_init(void)
  258 {
  259 
  260         sx_init(&drm_global_mutex, "drm_global_mutex");
  261 
  262         drm_global_init();
  263 
  264 #if DRM_LINUX
  265         linux_ioctl_register_handler(&drm_handler);
  266 #endif /* DRM_LINUX */
  267 
  268         DRM_INFO("Initialized %s %d.%d.%d %s\n",
  269                  CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
  270         return 0;
  271 }
  272 
  273 static void __exit drm_core_exit(void)
  274 {
  275 
  276 #if DRM_LINUX
  277         linux_ioctl_unregister_handler(&drm_handler);
  278 #endif /* DRM_LINUX */
  279 
  280         drm_global_release();
  281 
  282         sx_destroy(&drm_global_mutex);
  283 }
  284 
  285 SYSINIT(drm_register, SI_SUB_KLD, SI_ORDER_MIDDLE,
  286     drm_core_init, NULL);
  287 SYSUNINIT(drm_unregister, SI_SUB_KLD, SI_ORDER_MIDDLE,
  288     drm_core_exit, NULL);
  289 
  290 /**
  291  * Copy and IOCTL return string to user space
  292  */
  293 static int drm_copy_field(char *buf, size_t *buf_len, const char *value)
  294 {
  295         int len;
  296 
  297         /* don't overflow userbuf */
  298         len = strlen(value);
  299         if (len > *buf_len)
  300                 len = *buf_len;
  301 
  302         /* let userspace know exact length of driver value (which could be
  303          * larger than the userspace-supplied buffer) */
  304         *buf_len = strlen(value);
  305 
  306         /* finally, try filling in the userbuf */
  307         if (len && buf)
  308                 if (copy_to_user(buf, value, len))
  309                         return -EFAULT;
  310         return 0;
  311 }
  312 
  313 /**
  314  * Get version information
  315  *
  316  * \param inode device inode.
  317  * \param filp file pointer.
  318  * \param cmd command.
  319  * \param arg user argument, pointing to a drm_version structure.
  320  * \return zero on success or negative number on failure.
  321  *
  322  * Fills in the version information in \p arg.
  323  */
  324 int drm_version(struct drm_device *dev, void *data,
  325                        struct drm_file *file_priv)
  326 {
  327         struct drm_version *version = data;
  328         int err;
  329 
  330         version->version_major = dev->driver->major;
  331         version->version_minor = dev->driver->minor;
  332         version->version_patchlevel = dev->driver->patchlevel;
  333         err = drm_copy_field(version->name, &version->name_len,
  334                         dev->driver->name);
  335         if (!err)
  336                 err = drm_copy_field(version->date, &version->date_len,
  337                                 dev->driver->date);
  338         if (!err)
  339                 err = drm_copy_field(version->desc, &version->desc_len,
  340                                 dev->driver->desc);
  341 
  342         return err;
  343 }
  344 
  345 /**
  346  * Called whenever a process performs an ioctl on /dev/drm.
  347  *
  348  * \param inode device inode.
  349  * \param file_priv DRM file private.
  350  * \param cmd command.
  351  * \param arg user argument.
  352  * \return zero on success or negative number on failure.
  353  *
  354  * Looks up the ioctl function in the ::ioctls table, checking for root
  355  * previleges if so required, and dispatches to the respective function.
  356  */
  357 int drm_ioctl(struct cdev *kdev, u_long cmd, caddr_t data, int flags,
  358     DRM_STRUCTPROC *p)
  359 {
  360         struct drm_file *file_priv;
  361         struct drm_device *dev;
  362         struct drm_ioctl_desc *ioctl;
  363         drm_ioctl_t *func;
  364         unsigned int nr = DRM_IOCTL_NR(cmd);
  365         int retcode;
  366 
  367         dev = drm_get_device_from_kdev(kdev);
  368 
  369         retcode = devfs_get_cdevpriv((void **)&file_priv);
  370         if (retcode != 0) {
  371                 DRM_ERROR("can't find authenticator\n");
  372                 return EINVAL;
  373         }
  374 
  375         retcode = -EINVAL;
  376 
  377         atomic_inc(&dev->ioctl_count);
  378         atomic_inc(&dev->counts[_DRM_STAT_IOCTLS]);
  379         ++file_priv->ioctl_count;
  380 
  381         DRM_DEBUG("pid=%d, cmd=0x%02lx, nr=0x%02x, dev 0x%lx, auth=%d\n",
  382                   DRM_CURRENTPID, cmd, nr,
  383                   (long)file_priv->minor->device,
  384                   file_priv->authenticated);
  385 
  386         switch (cmd) {
  387         case FIONBIO:
  388         case FIOASYNC:
  389                 atomic_dec(&dev->ioctl_count);
  390                 return 0;
  391 
  392         case FIOSETOWN:
  393                 atomic_dec(&dev->ioctl_count);
  394                 return fsetown(*(int *)data, &file_priv->minor->buf_sigio);
  395 
  396         case FIOGETOWN:
  397                 atomic_dec(&dev->ioctl_count);
  398                 *(int *) data = fgetown(&file_priv->minor->buf_sigio);
  399                 return 0;
  400         }
  401 
  402         if (IOCGROUP(cmd) != DRM_IOCTL_BASE) {
  403                 atomic_dec(&dev->ioctl_count);
  404                 DRM_DEBUG("Bad ioctl group 0x%x\n", (int)IOCGROUP(cmd));
  405                 return EINVAL;
  406         }
  407 
  408         if ((nr >= DRM_CORE_IOCTL_COUNT) &&
  409             ((nr < DRM_COMMAND_BASE) || (nr >= DRM_COMMAND_END)))
  410                 goto err_i1;
  411 #ifdef COMPAT_FREEBSD32
  412         if (SV_CURPROC_FLAG(SV_ILP32) &&
  413             (nr >= DRM_COMMAND_BASE) && (nr < DRM_COMMAND_END) &&
  414             (nr < DRM_COMMAND_BASE + *dev->driver->num_compat_ioctls) &&
  415             (dev->driver->compat_ioctls[nr - DRM_COMMAND_BASE].func != NULL)) {
  416                 ioctl = &dev->driver->compat_ioctls[nr - DRM_COMMAND_BASE];
  417         } else
  418 #endif
  419         if ((nr >= DRM_COMMAND_BASE) && (nr < DRM_COMMAND_END) &&
  420             (nr < DRM_COMMAND_BASE + dev->driver->num_ioctls)) {
  421                 ioctl = &dev->driver->ioctls[nr - DRM_COMMAND_BASE];
  422         }
  423         else if ((nr >= DRM_COMMAND_END) || (nr < DRM_COMMAND_BASE)) {
  424 #ifdef COMPAT_FREEBSD32
  425                 /*
  426                  * Called whenever a 32-bit process running under a 64-bit
  427                  * kernel performs an ioctl on /dev/drm.
  428                  */
  429                 if (SV_CURPROC_FLAG(SV_ILP32) && drm_compat_ioctls[nr].func != NULL)
  430                         /*
  431                          * Assume that ioctls without an explicit compat
  432                          * routine will just work.  This may not always be a
  433                          * good assumption, but it's better than always
  434                          * failing.
  435                          */
  436                         ioctl = &drm_compat_ioctls[nr];
  437                 else
  438 #endif
  439                         ioctl = &drm_ioctls[nr];
  440         } else
  441                 goto err_i1;
  442 
  443         /* Do not trust userspace, use our own definition */
  444         func = ioctl->func;
  445         /* is there a local override? */
  446 #ifdef FREEBSD_NOTYET
  447 #ifdef COMPAT_FREEBSD32
  448         if (SV_CURPROC_FLAG(SV_ILP32) &&
  449             (nr == DRM_IOCTL_NR(DRM_IOCTL_DMA)) && dev->driver->dma_compat_ioctl)
  450                 func = dev->driver->dma_compat_ioctl;
  451         else
  452 #endif
  453 #endif /* FREEBSD_NOTYET */
  454         if ((nr == DRM_IOCTL_NR(DRM_IOCTL_DMA)) && dev->driver->dma_ioctl)
  455                 func = dev->driver->dma_ioctl;
  456 
  457         if (!func) {
  458                 DRM_DEBUG("no function\n");
  459                 retcode = -EINVAL;
  460         } else if (((ioctl->flags & DRM_ROOT_ONLY) && !DRM_SUSER(p)) ||
  461                    ((ioctl->flags & DRM_AUTH) && !file_priv->authenticated) ||
  462                    ((ioctl->flags & DRM_MASTER) && !file_priv->is_master) ||
  463                    (!(ioctl->flags & DRM_CONTROL_ALLOW) && (file_priv->minor->type == DRM_MINOR_CONTROL))) {
  464                 retcode = -EACCES;
  465         } else {
  466                 if (ioctl->flags & DRM_UNLOCKED)
  467                         retcode = func(dev, data, file_priv);
  468                 else {
  469                         sx_xlock(&drm_global_mutex);
  470                         retcode = func(dev, data, file_priv);
  471                         sx_xunlock(&drm_global_mutex);
  472                 }
  473         }
  474 
  475       err_i1:
  476         atomic_dec(&dev->ioctl_count);
  477         if (retcode == -ERESTARTSYS) {
  478                 /*
  479                  * FIXME: Find where in i915 ERESTARTSYS should be
  480                  * converted to EINTR.
  481                  */
  482                 DRM_DEBUG("ret = %d -> %d\n", retcode, -EINTR);
  483                 retcode = -EINTR;
  484         }
  485         if (retcode)
  486                 DRM_DEBUG("ret = %d\n", retcode);
  487         if (retcode != 0 &&
  488             (drm_debug & DRM_DEBUGBITS_FAILED_IOCTL) != 0) {
  489                 printf(
  490 "pid %d, cmd 0x%02lx, nr 0x%02x, dev 0x%lx, auth %d, res %d\n",
  491                     DRM_CURRENTPID, cmd, nr, (long)file_priv->minor->device,
  492                     file_priv->authenticated, -retcode);
  493         }
  494 
  495         return -retcode;
  496 }
  497 EXPORT_SYMBOL(drm_ioctl);
  498 
  499 struct drm_local_map *drm_getsarea(struct drm_device *dev)
  500 {
  501         struct drm_map_list *entry;
  502 
  503         list_for_each_entry(entry, &dev->maplist, head) {
  504                 if (entry->map && entry->map->type == _DRM_SHM &&
  505                     (entry->map->flags & _DRM_CONTAINS_LOCK)) {
  506                         return entry->map;
  507                 }
  508         }
  509         return NULL;
  510 }
  511 EXPORT_SYMBOL(drm_getsarea);

Cache object: 9398c6e298cc1a5d32c3cdf1ed1ef661


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.