Module Name: src
Committed By: riastradh
Date: Wed Jul 24 02:18:42 UTC 2013
Modified Files:
src/sys/external/bsd/drm2/dist/include/drm [riastradh-drm2]: drmP.h
Added Files:
src/sys/external/bsd/drm2/drm [riastradh-drm2]: drm_drv.c
Log Message:
First draft of NetBSD drm(4) driver attachment goop.
- Attachments will look like: drm0 at i915drm0 at pci0. In the
future, we may have wsdisplay0 at (drmfb0 at) drm0 at pci0. The
intent is to avoid having vga0, radeonfb0, &c., attach at pci0, and
then having drm0 parasitically sucking their memory as we currently
do with old drm. The drm0 device exists only so that we can have a
unified /dev/drm device node exposed to userland (i.e., a single drm
device major).
- There are some OS-independent subroutines here that don't belong.
I wrote them by
. studying the Linux driver attachment goop in dist/drm/drm_drv.c,
drm_fops.c, and drm_stub.c;
. identifying what logic is about DRM rather than about Linux's
driver KPI; and
. writing NetBSD driver attachment goop based on that information,
with the logic that is about DRM and independent of driver KPI
separated out into separate subroutines (drm_open_file, &c.).
- Initialization of struct drm_device is missing. It's not clear yet
whether this should be done by i915drm_attach &c., perhaps using some
utility (say, drm_device_initialize) defined here, or whether this
should be done mostly by drm_attach.
- Poll and read are missing. I suspect they will have to be filled
in at some point, in spite of comments in the old drm code to the
effect that they exist only for legacy X servers -- it looks like
more recent libdrms rely on them.
- Compile-tested only so far; this code is far from running.
To generate a diff of this commit:
cvs rdiff -u -r1.1.1.1.2.22 -r1.1.1.1.2.23 \
src/sys/external/bsd/drm2/dist/include/drm/drmP.h
cvs rdiff -u -r0 -r1.1.2.1 src/sys/external/bsd/drm2/drm/drm_drv.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/external/bsd/drm2/dist/include/drm/drmP.h
diff -u src/sys/external/bsd/drm2/dist/include/drm/drmP.h:1.1.1.1.2.22 src/sys/external/bsd/drm2/dist/include/drm/drmP.h:1.1.1.1.2.23
--- src/sys/external/bsd/drm2/dist/include/drm/drmP.h:1.1.1.1.2.22 Wed Jul 24 02:17:14 2013
+++ src/sys/external/bsd/drm2/dist/include/drm/drmP.h Wed Jul 24 02:18:42 2013
@@ -454,8 +454,10 @@ struct drm_prime_file_private {
/** File private data */
struct drm_file {
int authenticated;
+#ifndef __NetBSD__
struct pid *pid;
kuid_t uid;
+#endif
drm_magic_t magic;
unsigned long ioctl_count;
struct list_head lhead;
@@ -1065,7 +1067,11 @@ struct drm_minor {
int index; /**< Minor device number */
int type; /**< Control or render */
dev_t device; /**< Device number for mknod */
+#ifdef __NetBSD__
+ device_t kdev; /* NetBSD device */
+#else
struct device kdev; /**< Linux device */
+#endif
struct drm_device *dev;
#ifndef __NetBSD__
Added files:
Index: src/sys/external/bsd/drm2/drm/drm_drv.c
diff -u /dev/null src/sys/external/bsd/drm2/drm/drm_drv.c:1.1.2.1
--- /dev/null Wed Jul 24 02:18:42 2013
+++ src/sys/external/bsd/drm2/drm/drm_drv.c Wed Jul 24 02:18:42 2013
@@ -0,0 +1,936 @@
+/* $NetBSD: drm_drv.c,v 1.1.2.1 2013/07/24 02:18:42 riastradh Exp $ */
+
+/*-
+ * Copyright (c) 2013 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Taylor R. Campbell.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD: drm_drv.c,v 1.1.2.1 2013/07/24 02:18:42 riastradh Exp $");
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/conf.h>
+#include <sys/device.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/ioccom.h>
+#include <sys/kauth.h>
+
+#include <drm/drmP.h>
+
+struct drm_softc {
+ struct drm_minor sc_minor;
+};
+
+static int drm_match(device_t, cfdata_t, void *);
+static void drm_attach(device_t, device_t, void *);
+#if 0 /* XXX */
+static int drm_detach(device_t, int);
+#endif
+
+static dev_type_open(drm_open);
+
+static int drm_open_file(struct drm_file *, struct file *,
+ struct drm_minor *);
+static int drm_open_file_master(struct drm_file *);
+
+static int drm_close_file(struct drm_file *);
+static void drm_master_release(struct drm_file *);
+static void drm_events_release(struct drm_file *);
+static void drm_close_file_contexts(struct drm_file *);
+static void drm_close_file_master(struct drm_file *);
+
+static void drm_lastclose(struct drm_device *);
+static void drm_lastclose_agp(struct drm_device *);
+static void drm_lastclose_vma(struct drm_device *);
+
+static int drm_close(struct file *);
+static int drm_read(struct file *, off_t *, struct uio *, kauth_cred_t,
+ int);
+#if 0 /* XXX */
+static int drm_dequeue_event(struct drm_file *, size_t);
+#endif
+static int drm_poll(struct file *, int);
+static int drm_stat(struct file *, struct stat *);
+static int drm_ioctl(struct file *, unsigned long, void *);
+static int drm_version_string(char *, size_t *, const char *);
+
+static drm_ioctl_t drm_version;
+
+#define DRM_IOCTL_DEF(IOCTL, FUNC, FLAGS) \
+ [DRM_IOCTL_NR(IOCTL)] = { \
+ .cmd = (IOCTL), \
+ .flags = (FLAGS), \
+ .func = (FUNC), \
+ .cmd_drv = 0, \
+ }
+
+/* Table copied verbatim from dist/drm/drm_drv.c. */
+static const struct drm_ioctl_desc drm_ioctls[] = {
+ DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_UNIQUE, drm_getunique, 0),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, 0),
+ DRM_IOCTL_DEF(DRM_IOCTL_IRQ_BUSID, drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_getmap, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_CLIENT, drm_getclient, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_STATS, drm_getstats, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_CAP, drm_getcap, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_SET_VERSION, drm_setversion, DRM_MASTER),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_SET_UNIQUE, drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_BLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_UNBLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_AUTH|DRM_MASTER),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_rmmap_ioctl, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_getsareactx, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_SET_MASTER, drm_setmaster_ioctl, DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_DROP_MASTER, drm_dropmaster_ioctl, DRM_ROOT_ONLY),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_addctx, DRM_AUTH|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_MOD_CTX, drm_modctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_GET_CTX, drm_getctx, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_IOCTL_SWITCH_CTX, drm_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_resctx, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_LOCK, drm_lock, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_unlock, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_FINISH, drm_noop, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_ADD_BUFS, drm_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_MARK_BUFS, drm_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_INFO_BUFS, drm_infobufs, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_IOCTL_MAP_BUFS, drm_mapbufs, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_IOCTL_FREE_BUFS, drm_freebufs, DRM_AUTH),
+ /* The DRM_IOCTL_DMA ioctl should be defined by the driver. */
+ DRM_IOCTL_DEF(DRM_IOCTL_DMA, NULL, DRM_AUTH),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+
+#if __OS_HAS_AGP
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_INFO, drm_agp_info_ioctl, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_ALLOC, drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_FREE, drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_BIND, drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+#endif
+
+ DRM_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_sg_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+ DRM_IOCTL_DEF(DRM_IOCTL_SG_FREE, drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_WAIT_VBLANK, drm_wait_vblank, DRM_UNLOCKED),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_MODESET_CTL, drm_modeset_ctl, 0),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE, drm_gem_close_ioctl, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_GEM_OPEN, drm_gem_open_ioctl, DRM_AUTH|DRM_UNLOCKED),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETRESOURCES, drm_mode_getresources, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_PRIME_HANDLE_TO_FD, drm_prime_handle_to_fd_ioctl, DRM_AUTH|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_PRIME_FD_TO_HANDLE, drm_prime_fd_to_handle_ioctl, DRM_AUTH|DRM_UNLOCKED),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCONNECTOR, drm_mode_getconnector, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATTACHMODE, drm_mode_attachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_DETACHMODE, drm_mode_detachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPERTY, drm_mode_getproperty_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPROPERTY, drm_mode_connector_property_set_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_PAGE_FLIP, drm_mode_page_flip_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_DIRTYFB, drm_mode_dirtyfb_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_CREATE_DUMB, drm_mode_create_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_MAP_DUMB, drm_mode_mmap_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_DESTROY_DUMB, drm_mode_destroy_dumb_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_GETPROPERTIES, drm_mode_obj_get_properties_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_SETPROPERTY, drm_mode_obj_set_property_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+};
+
+const struct cdevsw drm_cdevsw = {
+ .d_open = drm_open,
+ .d_close = noclose,
+ .d_read = noread,
+ .d_write = nowrite,
+ .d_ioctl = noioctl,
+ .d_stop = nostop,
+ .d_tty = notty,
+ .d_poll = nopoll,
+ .d_mmap = nommap,
+ .d_kqfilter = nokqfilter,
+ /* XXX was D_TTY | D_NEGOFFSAFE */
+ /* XXX Add D_MPSAFE some day... */
+ .d_flag = D_NEGOFFSAFE,
+};
+
+/* XXX Does this get declared automatically by config? */
+extern struct cfdriver drm_cd;
+
+static const struct fileops drm_fileops = {
+ .fo_read = drm_read,
+ .fo_write = fbadop_write,
+ .fo_ioctl = drm_ioctl,
+ .fo_fcntl = fnullop_fcntl,
+ .fo_poll = drm_poll,
+ .fo_stat = drm_stat,
+ .fo_close = drm_close,
+ .fo_kqfilter = fnullop_kqfilter,
+ .fo_restart = fnullop_restart,
+};
+
+CFATTACH_DECL_NEW(drm, sizeof(struct drm_minor),
+ drm_match, drm_attach, NULL /* XXX drm_detach */, NULL);
+
+static int
+drm_match(device_t parent __unused, cfdata_t match __unused,
+ void *aux __unused)
+{
+
+ return 1;
+}
+
+static void
+drm_attach(device_t parent, device_t self, void *aux)
+{
+ struct drm_softc *sc = device_private(self);
+ struct drm_device *dev = aux;
+
+ KASSERT(sc != NULL);
+ KASSERT(dev != NULL);
+ KASSERT(dev->driver != NULL);
+
+ sc->sc_minor.index = device_unit(self);
+ sc->sc_minor.type = (drm_core_check_feature(dev, DRIVER_MODESET)?
+ DRM_MINOR_CONTROL : DRM_MINOR_LEGACY);
+ sc->sc_minor.device = makedev(cdevsw_lookup_major(&drm_cdevsw),
+ device_unit(self));
+ sc->sc_minor.kdev = self;
+ sc->sc_minor.dev = dev;
+ sc->sc_minor.master = NULL;
+ INIT_LIST_HEAD(&sc->sc_minor.master_list);
+ (void)memset(&sc->sc_minor.mode_group, 0,
+ sizeof(sc->sc_minor.mode_group));
+
+#if 0
+ attach wsdisplay;
+#endif
+}
+
+#if 0 /* XXX */
+static int
+drm_detach(device_t self, int flags)
+{
+ struct drm_softc *const sc = device_private(self);
+ KASSERT(sc != NULL);
+ struct drm_device *const dev = sc->sc_minor.dev;
+ KASSERT(dev != NULL);
+
+ drm_sysctl_cleanup(dev);
+ drm_ctxbitmap_cleanup(dev);
+ clean up mtrr crap;
+ do the last close;
+ unload it all;
+ vblank clenaup;
+ kill hash tables;
+ and more;
+ in a different order;
+}
+#endif
+
+static int
+drm_open(dev_t d, int flags, int fmt, struct lwp *l)
+{
+ struct drm_softc *const sc = device_lookup_private(&drm_cd, minor(d));
+ int fd;
+ struct file *fp;
+ int error;
+
+ if (sc == NULL) {
+ error = ENXIO;
+ goto fail0;
+ }
+
+ if (flags & O_EXCL) {
+ error = EBUSY;
+ goto fail0;
+ }
+
+ if (sc->sc_minor.dev->switch_power_state != DRM_SWITCH_POWER_ON) {
+ error = EINVAL;
+ goto fail0;
+ }
+
+ error = fd_allocfile(&fp, &fd);
+ if (error)
+ goto fail0;
+
+ struct drm_file *const file = kmem_zalloc(sizeof(*file), KM_SLEEP);
+
+ /* XXX errno Linux->NetBSD */
+ error = -drm_open_file(file, fp, &sc->sc_minor);
+ if (error)
+ goto fail2;
+
+ error = fd_clone(fp, fd, flags, &drm_fileops, file);
+ KASSERT(error == EMOVEFD); /* XXX */
+
+ /* Success! (But error has to be EMOVEFD, not 0.) */
+ return error;
+
+fail2:
+ kmem_free(file, sizeof(*file));
+
+fail1: __unused
+ fd_abort(curproc, fp, fd);
+
+fail0:
+ return error;
+}
+
+/*
+ * XXX BEGIN MISPLACED OS-INDEPENDENT CODE
+ */
+
+static int
+drm_open_file(struct drm_file *file, struct file *fp, struct drm_minor *minor)
+{
+ struct drm_device *const dev = minor->dev;
+ int error;
+
+ atomic_inc(&dev->counts[_DRM_STAT_OPENS]);
+ if ((dev->open_count++ == 0) && (dev->driver->firstopen != NULL)) {
+ error = (*dev->driver->firstopen)(dev);
+ if (error)
+ goto fail0;
+ }
+
+ file->authenticated = DRM_SUSER(); /* XXX */
+ file->magic = 0;
+ file->ioctl_count = 0;
+ INIT_LIST_HEAD(&file->lhead);
+ file->minor = minor;
+ file->lock_count = 0;
+ /* file->object_idr is initialized by drm_gem_open. */
+ /* file->table_lock is initialized by drm_gem_open. */
+ file->filp = fp;
+ file->driver_priv = NULL;
+ file->is_master = 0;
+ file->master = NULL;
+ INIT_LIST_HEAD(&file->fbs);
+ DRM_INIT_WAITQUEUE(&file->event_wait, "drmevent");
+ INIT_LIST_HEAD(&file->event_list);
+ file->event_space = 0x1000; /* XXX cargo-culted from Linux */
+
+ if (drm_core_check_feature(dev, DRIVER_GEM))
+ drm_gem_open(dev, file);
+
+ if (drm_core_check_feature(dev, DRIVER_PRIME))
+ drm_prime_init_file_private(&file->prime);
+
+ if (dev->driver->open) {
+ error = (*dev->driver->open)(dev, file);
+ if (error)
+ goto fail1;
+ }
+
+ error = drm_open_file_master(file);
+ if (error)
+ goto fail2;
+
+ /* Success! */
+ return 0;
+
+fail2:
+ /*
+ * XXX This error branch needs scrutiny, but Linux's error
+ * branches are incomprehensible and look wronger.
+ */
+ if (dev->driver->preclose)
+ (*dev->driver->preclose)(dev, file);
+ if (dev->driver->postclose)
+ (*dev->driver->postclose)(dev, file);
+
+fail1:
+ if (drm_core_check_feature(dev, DRIVER_PRIME))
+ drm_prime_destroy_file_private(&file->prime);
+
+ if (drm_core_check_feature(dev, DRIVER_GEM))
+ drm_gem_release(dev, file);
+
+ if (--dev->open_count == 0)
+ drm_lastclose(dev);
+
+fail0:
+ return error;
+}
+
+static int
+drm_open_file_master(struct drm_file *file)
+{
+ struct drm_device *const dev = file->minor->dev;
+ int error;
+
+ mutex_lock(&dev->struct_mutex);
+
+ if (file->minor->master != NULL) {
+ file->master = drm_master_get(file->minor->master);
+ } else {
+ file->minor->master = drm_master_create(file->minor);
+ if (file->minor->master == NULL) {
+ error = -ENOMEM;
+ goto fail0;
+ }
+
+ file->is_master = 1;
+ file->master = drm_master_get(file->minor->master);
+ file->authenticated = 1;
+
+ if (dev->driver->master_create) {
+ mutex_unlock(&dev->struct_mutex);
+ error = (*dev->driver->master_create)(dev,
+ file->minor->master);
+ mutex_lock(&dev->struct_mutex);
+ if (error)
+ goto fail1;
+ }
+
+ if (dev->driver->master_set) {
+ error = (*dev->driver->master_set)(dev, file, true);
+ if (error)
+ goto fail1;
+ }
+ }
+ mutex_unlock(&dev->struct_mutex);
+
+ /* Success! */
+ return 0;
+
+fail1:
+ /* drm_master_put handles calling master_destroy for us. */
+ drm_master_put(&file->minor->master);
+ drm_master_put(&file->master);
+fail0:
+ mutex_unlock(&dev->struct_mutex);
+ return error;
+}
+
+static int
+drm_close_file(struct drm_file *file)
+{
+ struct drm_minor *const minor = file->minor;
+ struct drm_device *const dev = minor->dev;
+ int error;
+
+ mutex_lock(&drm_global_mutex);
+
+ /* XXX Not all users of ioctl_count take the global mutex! */
+ if ((dev->open_count == 1) && (atomic_read(&dev->ioctl_count) != 0)) {
+ error = -EBUSY;
+ goto out;
+ }
+
+ if (dev->driver->preclose)
+ (*dev->driver->preclose)(dev, file);
+
+ if (file->magic)
+ (void)drm_remove_magic(file->master, file->magic);
+
+ if (file->minor->master)
+ drm_master_release(file);
+
+ if (drm_core_check_feature(dev, DRIVER_HAVE_DMA))
+ drm_core_reclaim_buffers(dev, file);
+
+ drm_events_release(file);
+
+ if (drm_core_check_feature(dev, DRIVER_MODESET))
+ drm_fb_release(file);
+
+ if (drm_core_check_feature(dev, DRIVER_GEM))
+ drm_gem_release(dev, file);
+
+ drm_close_file_contexts(file);
+ drm_close_file_master(file);
+
+ mutex_lock(&dev->struct_mutex);
+ list_del(&file->lhead);
+ mutex_unlock(&dev->struct_mutex);
+
+ if (dev->driver->postclose)
+ (*dev->driver->postclose)(dev, file);
+
+ if (drm_core_check_feature(dev, DRIVER_PRIME))
+ drm_prime_destroy_file_private(&file->prime);
+
+ atomic_inc(&dev->counts[_DRM_STAT_CLOSES]);
+ if (--dev->open_count == 0) {
+ KASSERT(atomic_read(&dev->ioctl_count) == 0);
+ drm_lastclose(dev);
+ }
+
+ /* Success! */
+ error = 0;
+
+out:
+ mutex_unlock(&drm_global_mutex);
+ return error;
+}
+
+static void
+drm_master_release(struct drm_file *file)
+{
+
+ if (drm_i_have_hw_lock(file->minor->dev, file))
+ drm_lock_free(&file->master->lock,
+ _DRM_LOCKING_CONTEXT(file->master->lock.hw_lock->lock));
+}
+
+static void
+drm_events_release(struct drm_file *file)
+{
+ struct drm_device *const dev = file->minor->dev;
+ struct drm_pending_vblank_event *vblank, *vblank_next;
+ struct drm_pending_event *event, *event_next;
+ unsigned long flags;
+
+ spin_lock_irqsave(&dev->event_lock, flags);
+
+ list_for_each_entry_safe(vblank, vblank_next, &dev->vblank_event_list,
+ base.link) {
+ if (vblank->base.file_priv == file) {
+ list_del(&vblank->base.link);
+ drm_vblank_put(dev, vblank->pipe);
+ (*vblank->base.destroy)(&vblank->base);
+ }
+ }
+
+ list_for_each_entry_safe(event, event_next, &file->event_list, link) {
+ (*event->destroy)(event);
+ }
+
+ spin_unlock_irqrestore(&dev->event_lock, flags);
+}
+
+static void
+drm_close_file_contexts(struct drm_file *file)
+{
+ struct drm_device *const dev = file->minor->dev;
+
+ mutex_lock(&dev->ctxlist_mutex);
+ if (!list_empty(&dev->ctxlist)) {
+ struct drm_ctx_list *node, *next;
+
+ list_for_each_entry_safe(node, next, &dev->ctxlist, head) {
+ if (node->tag != file)
+ continue;
+
+ if (node->handle == DRM_KERNEL_CONTEXT)
+ continue;
+
+ if (dev->driver->context_dtor)
+ (*dev->driver->context_dtor)(dev,
+ node->handle);
+ drm_ctxbitmap_free(dev, node->handle);
+ list_del(&node->head);
+ kfree(node);
+ dev->ctx_count--;
+ }
+ }
+ mutex_unlock(&dev->ctxlist_mutex);
+}
+
+static void
+drm_close_file_master(struct drm_file *file)
+{
+ struct drm_device *const dev = file->minor->dev;
+
+ mutex_lock(&dev->struct_mutex);
+
+ if (file->is_master) {
+ struct drm_master *const master = file->master;
+ struct drm_file *other_file;
+
+ list_for_each_entry(other_file, &dev->filelist, lhead) {
+ if (other_file == file)
+ continue;
+
+ if (other_file->master != file->master)
+ continue;
+
+ other_file->authenticated = 0;
+ }
+
+ if (master->lock.hw_lock) {
+ if (dev->sigdata.lock == master->lock.hw_lock)
+ dev->sigdata.lock = NULL;
+ master->lock.hw_lock = NULL;
+ master->lock.file_priv = NULL;
+ DRM_WAKEUP_ALL(&master->lock.lock_queue,
+ &drm_global_mutex);
+ }
+
+ if (file->minor->master == file->master) {
+ if (dev->driver->master_drop)
+ (*dev->driver->master_drop)(dev, file, true);
+ drm_master_put(&file->minor->master);
+ }
+ }
+
+ /* XXX Need to close file->dev_mapping, whatever that means. */
+
+ drm_master_put(&file->master);
+ file->is_master = 0;
+ mutex_unlock(&dev->struct_mutex);
+}
+
+static void
+drm_lastclose(struct drm_device *dev)
+{
+
+ if (dev->driver->lastclose)
+ (*dev->driver->lastclose)(dev);
+
+ if (dev->irq_enabled && !drm_core_check_feature(dev, DRIVER_MODESET))
+ drm_irq_uninstall(dev);
+
+ mutex_lock(&dev->struct_mutex);
+
+ if (drm_core_has_AGP(dev) &&
+ dev->agp &&
+ !drm_core_check_feature(dev, DRIVER_MODESET))
+ drm_lastclose_agp(dev);
+
+ if (drm_core_check_feature(dev, DRIVER_SG) &&
+ dev->sg &&
+ !drm_core_check_feature(dev, DRIVER_MODESET)) {
+ drm_sg_cleanup(dev->sg);
+ dev->sg = NULL;
+ }
+
+ drm_lastclose_vma(dev);
+
+ if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
+ !drm_core_check_feature(dev, DRIVER_MODESET))
+ drm_dma_takedown(dev);
+
+ /* XXX clear the dev_mapping */
+ mutex_unlock(&dev->struct_mutex);
+}
+
+static void
+drm_lastclose_agp(struct drm_device *dev)
+{
+ struct drm_agp_mem *entry, *next;
+
+ list_for_each_entry_safe(entry, next, &dev->agp->memory, head) {
+ if (entry->bound)
+ drm_unbind_agp(entry->memory);
+ drm_free_agp(entry->memory, entry->pages);
+ kfree(entry);
+ }
+ INIT_LIST_HEAD(&dev->agp->memory); /* XXX seems kludgey */
+
+ if (dev->agp->acquired)
+ drm_agp_release(dev);
+
+ dev->agp->acquired = 0;
+ dev->agp->enabled = 0;
+}
+
+static void
+drm_lastclose_vma(struct drm_device *dev)
+{
+ struct drm_vma_entry *vma, *vma_next;
+
+ list_for_each_entry_safe(vma, vma_next, &dev->vmalist, head) {
+ list_del(&vma->head);
+ kfree(vma);
+ }
+}
+
+/*
+ * XXX END MISPLACED OS-INDEPENDENT CODE
+ */
+
+static int
+drm_close(struct file *fp)
+{
+
+ /* XXX errno Linux->NetBSD */
+ return -drm_close_file(fp->f_data);
+}
+
+/*
+ * XXX According to the old drm port, doing nothing but succeeding in
+ * drm_read and drm_poll is a kludge for compatibility with old X
+ * servers. However, it's not clear to me from the drm2 code that this
+ * is the right thing; in fact, it looks like a load of bollocks.
+ */
+
+static int
+drm_read(struct file *fp __unused, off_t *off __unused,
+ struct uio *uio __unused, kauth_cred_t cred __unused, int flags __unused)
+{
+#if 1 /* XXX */
+ return 0;
+#else
+ /* XXX How do flags figure into this? */
+ struct drm_file *const file = fp->f_data;
+ size_t transferred, limit;
+ struct drm_pending_event *event;
+ int error;
+
+ if (off != 0)
+ return EINVAL;
+
+ mutex_lock(&dev->event_lock);
+ DRM_WAIT_ON(error, &file->event_wait, &dev->event_lock,
+ !list_empty(&file->event_list));
+ if (error)
+ goto out;
+
+ while ((event = drm_dequeue_event(file, uio->uio_resid)) != NULL) {
+ error = uiomove(event->event, event->event->length, uio);
+ if (error)
+ goto out;
+ }
+
+out:
+ mutex_unlock(&drm_global_mutex);
+ return error;
+#endif
+}
+
+#if 0 /* XXX */
+static struct drm_pending_event *
+drm_dequeue_event(struct drm_file *file, size_t max_length)
+{
+
+ KASSERT(mutex_is_locked(&file->minor->dev->event_lock));
+
+ if (list_empty(&file->event_list))
+ return NULL;
+
+ struct drm_pending_event *const event =
+ list_first_entry(&file->event_list, struct drm_pending_event,
+ link);
+ if (event->event->length > max_length)
+ return NULL;
+
+ file->event_space += event->event->length;
+ list_del(&event->link);
+ return event;
+}
+#endif
+
+static int
+drm_poll(struct file *fp __unused, int events __unused)
+{
+#if 1 /* XXX */
+ /*
+ * XXX Let's worry about this later. Notifiers need to be
+ * modified to call selnotify.
+ */
+ return 0;
+#else
+ struct drm_file *const file = fp->f_data;
+ int revents = 0;
+
+ mutex_lock(&file->event_list);
+
+ if (events & (POLLIN | POLLRDNORM)) {
+ if (!list_empty(&file->event_list))
+ revents |= (events & (POLLIN | POLLRDNORM));
+ }
+
+ if (revents == 0) {
+ if (events & (POLLIN | POLLRDNORM))
+ selrecord(curlwp, &file->event_sel);
+ }
+
+ mutex_unlock(&file->event_list);
+
+ return revents;
+#endif
+}
+
+static int
+drm_stat(struct file *fp, struct stat *st)
+{
+ struct drm_file *const file = fp->f_data;
+
+ (void)memset(st, 0, sizeof(*st));
+
+ st->st_dev = file->minor->device;
+ st->st_ino = 0; /* XXX (dev,ino) uniqueness bleh */
+ st->st_uid = kauth_cred_geteuid(fp->f_cred);
+ st->st_gid = kauth_cred_getegid(fp->f_cred);
+ st->st_mode = S_IFCHR; /* XXX what? */
+ /* XXX what else? */
+
+ return 0;
+}
+
+static int
+drm_ioctl(struct file *fp, unsigned long cmd, void *data)
+{
+ struct drm_file *const file = fp->f_data;
+ const unsigned int nr = DRM_IOCTL_NR(cmd);
+ int error;
+
+ switch (cmd) {
+ case FIONBIO:
+ case FIOASYNC:
+ return 0;
+
+#if 0 /* XXX why? */
+ case SIOCSPGRP:
+ case TIOCSPGRP:
+ case FIOSETOWN:
+ return fsetown(&dev->buf_pgid, cmd, data);
+
+ case SIOCGPGRP:
+ case TIOCGPGRP:
+ case FIOGETOWN:
+ return fgetown(&dev->buf_pgid, cmd, data);
+#endif
+
+ default:
+ break;
+ }
+
+ if (IOCGROUP(cmd) != DRM_IOCTL_BASE)
+ return EINVAL;
+
+ KASSERT(file != NULL);
+ KASSERT(file->minor != NULL);
+ KASSERT(file->minor->dev != NULL);
+ struct drm_device *const dev = file->minor->dev;
+ const struct drm_ioctl_desc *ioctl;
+
+ if ((DRM_COMMAND_BASE <= nr) && (nr < DRM_COMMAND_END)) {
+ const unsigned int driver_nr = nr - DRM_COMMAND_BASE;
+ if (driver_nr >= dev->driver->num_ioctls)
+ return EINVAL;
+ ioctl = &dev->driver->ioctls[driver_nr];
+ } else if (nr < __arraycount(drm_ioctls)) {
+ ioctl = &drm_ioctls[nr];
+ } else {
+ ioctl = NULL;
+ }
+
+ if ((ioctl == NULL) || (ioctl->func == NULL))
+ return EINVAL;
+
+ if (ISSET(ioctl->flags, DRM_ROOT_ONLY) && !DRM_SUSER())
+ return EACCES;
+
+ if (ISSET(ioctl->flags, DRM_AUTH) && !file->authenticated)
+ return EACCES;
+
+ if (ISSET(ioctl->flags, DRM_MASTER) && (file->master == NULL))
+ return EACCES;
+
+ atomic_inc(&dev->ioctl_count);
+ if (!ISSET(ioctl->flags, DRM_UNLOCKED))
+ mutex_lock(&drm_global_mutex);
+
+ /* XXX errno Linux->NetBSD */
+ error = -(*ioctl->func)(dev, data, file);
+
+ if (!ISSET(ioctl->flags, DRM_UNLOCKED))
+ mutex_unlock(&drm_global_mutex);
+ atomic_dec(&dev->ioctl_count);
+
+ return error;
+}
+
+static int
+drm_version_string(char *target, size_t *lenp, const char *source)
+{
+ const size_t len = strlen(source);
+ const size_t trunc_len = MIN(len, *lenp);
+
+ *lenp = len;
+ if ((trunc_len > 0) && (target != NULL))
+ return copyoutstr(source, target, trunc_len, NULL);
+
+ return 0;
+}
+
+static int
+drm_version(struct drm_device *dev, void *data, struct drm_file *file)
+{
+ struct drm_version *v = data;
+ int error;
+
+ v->version_major = dev->driver->major;
+ v->version_minor = dev->driver->minor;
+ v->version_patchlevel = dev->driver->patchlevel;
+
+ error = drm_version_string(v->name, &v->name_len, dev->driver->name);
+ if (error)
+ goto out;
+
+ error = drm_version_string(v->date, &v->date_len, dev->driver->date);
+ if (error)
+ goto out;
+
+ error = drm_version_string(v->desc, &v->desc_len, dev->driver->desc);
+ if (error)
+ goto out;
+out:
+ return error;
+}
