 @@ -1,1097 +1,1098 @@
-/*	$NetBSD: drmP.h,v 1.14 2018/08/27 04:58:37 riastradh Exp $	*/
+/*	$NetBSD: drmP.h,v 1.15 2018/08/27 06:17:30 riastradh Exp $	*/
 /*
  * Internal Header for the Direct Rendering Manager
+ *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  * Copyright (c) 2009-2010, Code Aurora Forum.
  * All rights reserved.
+ *
  * Author: Rickard E. (Rik) Faith <faith@valinux.com>
  * Author: Gareth Hughes <gareth@valinux.com>
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 #ifndef _DRM_P_H_
 #define _DRM_P_H_
 #include <linux/agp_backend.h>
 #include <linux/atomic.h>
 #include <linux/cdev.h>
 #include <linux/dma-mapping.h>
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/highmem.h>
 #include <linux/idr.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/kref.h>
 #include <linux/ktime.h>
 #include <linux/miscdevice.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 #include <linux/poll.h>
 #include <linux/ratelimit.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
 #include <linux/types.h>
 #include <linux/uidgid.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
 #include <asm/barrier.h>
 #include <asm/mman.h>
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h>
 #include <uapi/drm/drm.h>
 #include <uapi/drm/drm_mode.h>
 #include <drm/drm.h>
 #include <drm/drm_agpsupport.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_global.h>
 #include <drm/drm_hashtab.h>
 #include <drm/drm_mem_util.h>
 #include <drm/drm_mm.h>
 #ifdef __NetBSD__
 #include <drm/drm_os_netbsd.h>
 #else
 #include <drm/drm_os_linux.h>
 #endif
 #include <drm/drm_sarea.h>
 #include <drm/drm_vma_manager.h>
 struct module;
 struct drm_file;
 struct drm_device;
 struct drm_agp_head;
 struct drm_local_map;
 struct drm_device_dma;
 struct drm_dma_handle;
 struct drm_gem_object;
 struct drm_bus_irq_cookie;
 struct device_node;
 struct videomode;
 struct reservation_object;
 struct dma_buf_attachment;
 /*
  * 4 debug categories are defined:
+ *
  * CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, drm_memory.c, ...
  *	 This is the category used by the DRM_DEBUG() macro.
+ *
  * DRIVER: Used in the vendor specific part of the driver: i915, radeon, ...
  *	   This is the category used by the DRM_DEBUG_DRIVER() macro.
+ *
  * KMS: used in the modesetting code.
  *	This is the category used by the DRM_DEBUG_KMS() macro.
+ *
  * PRIME: used in the prime code.
  *	  This is the category used by the DRM_DEBUG_PRIME() macro.
+ *
  * ATOMIC: used in the atomic code.
  *	  This is the category used by the DRM_DEBUG_ATOMIC() macro.
+ *
  * VBL: used for verbose debug message in the vblank code
  *	  This is the category used by the DRM_DEBUG_VBL() macro.
+ *
  * Enabling verbose debug messages is done through the drm.debug parameter,
  * each category being enabled by a bit.
+ *
  * drm.debug=0x1 will enable CORE messages
  * drm.debug=0x2 will enable DRIVER messages
  * drm.debug=0x3 will enable CORE and DRIVER messages
  * ...
  * drm.debug=0x3f will enable all messages
+ *
  * An interesting feature is that it's possible to enable verbose logging at
  * run-time by echoing the debug value in its sysfs node:
  *   # echo 0xf > /sys/module/drm/parameters/debug
  */
 #define DRM_UT_CORE 		0x01
 #define DRM_UT_DRIVER		0x02
 #define DRM_UT_KMS		0x04
 #define DRM_UT_PRIME		0x08
 #define DRM_UT_ATOMIC		0x10
 #define DRM_UT_VBL		0x20
 extern __printf(2, 3)
 void drm_ut_debug_printk(const char *function_name,
 			 const char *format, ...);
 extern __printf(1, 2)
 void drm_err(const char *format, ...);
 /***********************************************************************/
 /** \name DRM template customization defaults */
 /*@{*/
 /* driver capabilities and requirements mask */
 #define DRIVER_USE_AGP			0x1
 #define DRIVER_PCI_DMA			0x8
 #define DRIVER_SG			0x10
 #define DRIVER_HAVE_DMA			0x20
 #define DRIVER_HAVE_IRQ			0x40
 #define DRIVER_IRQ_SHARED		0x80
 #define DRIVER_GEM			0x1000
 #define DRIVER_MODESET			0x2000
 #define DRIVER_PRIME			0x4000
 #define DRIVER_RENDER			0x8000
 #define DRIVER_ATOMIC			0x10000
 #define DRIVER_KMS_LEGACY_CONTEXT	0x20000
 /***********************************************************************/
 /** \name Macros to make printk easier */
 /*@{*/
 #define _DRM_PRINTK(once, level, fmt, ...)				\
 	do {								\
 		printk##once(KERN_##level "[" DRM_NAME "] " fmt,	\
 			     ##__VA_ARGS__);				\
 	} while (0)
 #define DRM_INFO(fmt, ...)						\
 	_DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
 #define DRM_NOTE(fmt, ...)						\
 	_DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
 #define DRM_WARN(fmt, ...)						\
 	_DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)
 #define DRM_INFO_ONCE(fmt, ...)						\
 	_DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
 #define DRM_NOTE_ONCE(fmt, ...)						\
 	_DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
 #define DRM_WARN_ONCE(fmt, ...)						\
 	_DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)
 /**
  * Error output.
+ *
  * \param fmt printf() like format string.
  * \param arg arguments
  */
 #define DRM_ERROR(fmt, ...)				\
 	drm_err(fmt, ##__VA_ARGS__)
 /**
  * Rate limited error output.  Like DRM_ERROR() but won't flood the log.
+ *
  * \param fmt printf() like format string.
  * \param arg arguments
  */
 #define DRM_ERROR_RATELIMITED(fmt, ...)				\
 ({									\
 	static DEFINE_RATELIMIT_STATE(_rs,				\
 				      DEFAULT_RATELIMIT_INTERVAL,	\
 				      DEFAULT_RATELIMIT_BURST);		\
+									\
 	if (__ratelimit(&_rs))						\
 		drm_err(fmt, ##__VA_ARGS__);				\
 })
 /**
  * Debug output.
+ *
  * \param fmt printf() like format string.
  * \param arg arguments
  */
 #define DRM_DEBUG(fmt, args...)						\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_CORE))			\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 #define DRM_DEBUG_DRIVER(fmt, args...)					\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_DRIVER))		\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 #define DRM_DEBUG_KMS(fmt, args...)					\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_KMS))			\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 #define DRM_DEBUG_PRIME(fmt, args...)					\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_PRIME))			\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 #define DRM_DEBUG_ATOMIC(fmt, args...)					\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_ATOMIC))		\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 #define DRM_DEBUG_VBL(fmt, args...)					\
 	do {								\
 		if (unlikely(drm_debug & DRM_UT_VBL))			\
 			drm_ut_debug_printk(__func__, fmt, ##args);	\
 	} while (0)
 /*@}*/
 /***********************************************************************/
 /** \name Internal types and structures */
 /*@{*/
 #define DRM_IF_VERSION(maj, min) (maj << 16 | min)
 /**
  * Ioctl function type.
+ *
  * \param inode device inode.
  * \param file_priv DRM file private pointer.
  * \param cmd command.
  * \param arg argument.
  */
 typedef int drm_ioctl_t(struct drm_device *dev, void *data,
 			struct drm_file *file_priv);
 typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
 			       unsigned long arg);
 #ifdef __NetBSD__
 /* XXX Kludge...is there a better way to do this?  */
 #define	DRM_IOCTL_NR(n)							\
 	(IOCBASECMD(n) &~ (IOC_DIRMASK | (IOCGROUP(n) << IOCGROUP_SHIFT)))
 #define	DRM_MAJOR	cdevsw_lookup_major(&drm_cdevsw)
 #else
 #define DRM_IOCTL_NR(n)                _IOC_NR(n)
 #define DRM_MAJOR       226
 #endif
 #define DRM_AUTH	0x1
 #define	DRM_MASTER	0x2
 #define DRM_ROOT_ONLY	0x4
 #define DRM_CONTROL_ALLOW 0x8
 #define DRM_UNLOCKED	0x10
 #define DRM_RENDER_ALLOW 0x20
 struct drm_ioctl_desc {
 	unsigned int cmd;
 	int flags;
 	drm_ioctl_t *func;
 	const char *name;
 };
 /**
  * Creates a driver or general drm_ioctl_desc array entry for the given
  * ioctl, for use by drm_ioctl().
  */
 #define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags)				\
 	[DRM_IOCTL_NR(DRM_IOCTL_##ioctl) - DRM_COMMAND_BASE] = {	\
 		.cmd = DRM_IOCTL_##ioctl,				\
 		.func = _func,						\
 		.flags = _flags,					\
 		.name = #ioctl						\
+	 }
 /* Event queued up for userspace to read */
 struct drm_pending_event {
 	struct drm_event *event;
 	struct list_head link;
 	struct drm_file *file_priv;
 	pid_t pid; /* pid of requester, no guarantee it's valid by the time
 		      we deliver the event, for tracing only */
 	void (*destroy)(struct drm_pending_event *event);
 };
 /* initial implementaton using a linked list - todo hashtab */
 struct drm_prime_file_private {
 	struct list_head head;
 	struct mutex lock;
 };
 /** File private data */
 struct drm_file {
 	unsigned authenticated :1;
 	/* Whether we're master for a minor. Protected by master_mutex */
 	unsigned is_master :1;
 	/* true when the client has asked us to expose stereo 3D mode flags */
 	unsigned stereo_allowed :1;
 	/*
 	 * true if client understands CRTC primary planes and cursor planes
 	 * in the plane list
 	 */
 	unsigned universal_planes:1;
 	/* true if client understands atomic properties */
 	unsigned atomic:1;
 	/*
 	 * This client is allowed to gain master privileges for @master.
 	 * Protected by struct drm_device::master_mutex.
 	 */
 	unsigned allowed_master:1;
 #ifndef __NetBSD__
 	struct pid *pid;
 	kuid_t uid;
 #endif
 	drm_magic_t magic;
 	struct list_head lhead;
 	struct drm_minor *minor;
 	unsigned long lock_count;
 	/** Mapping of mm object handles to object pointers. */
 	struct idr object_idr;
 	/** Lock for synchronization of access to object_idr. */
 	spinlock_t table_lock;
 	struct file *filp;
 	void *driver_priv;
 	struct drm_master *master; /* master this node is currently associated with
 				      N.B. not always minor->master */
 	/**
 	 * fbs - List of framebuffers associated with this file.
+	 *
 	 * Protected by fbs_lock. Note that the fbs list holds a reference on
 	 * the fb object to prevent it from untimely disappearing.
 	 */
 	struct list_head fbs;
 	struct mutex fbs_lock;
 	/** User-created blob properties; this retains a reference on the
 	 *  property. */
 	struct list_head blobs;
 #ifdef __NetBSD__
 	drm_waitqueue_t event_wait;
 	struct selinfo event_selq;
 #else
 	wait_queue_head_t event_wait;
 #endif
 	struct list_head event_list;
 	int event_space;
 	struct drm_prime_file_private prime;
 };
 /**
  * Lock data.
  */
 struct drm_lock_data {
 	struct drm_hw_lock *hw_lock;	/**< Hardware lock */
 	/** Private of lock holder's file (NULL=kernel) */
 	struct drm_file *file_priv;
 #ifdef __NetBSD__
 	drm_waitqueue_t lock_queue;	/**< Queue of blocked processes */
 #else
 	wait_queue_head_t lock_queue;	/**< Queue of blocked processes */
 #endif
 	unsigned long lock_time;	/**< Time of last lock in jiffies */
 	spinlock_t spinlock;
 	uint32_t kernel_waiters;
 	uint32_t user_waiters;
 	int idle_has_lock;
 };
 /**
  * struct drm_master - drm master structure
+ *
  * @refcount: Refcount for this master object.
  * @minor: Link back to minor char device we are master for. Immutable.
  * @unique: Unique identifier: e.g. busid. Protected by drm_global_mutex.
  * @unique_len: Length of unique field. Protected by drm_global_mutex.
  * @magic_map: Map of used authentication tokens. Protected by struct_mutex.
  * @lock: DRI lock information.
  * @driver_priv: Pointer to driver-private information.
  */
 struct drm_master {
 	struct kref refcount;
 	struct drm_minor *minor;
 	char *unique;
 	int unique_len;
 	struct idr magic_map;
 	struct drm_lock_data lock;
 	void *driver_priv;
 };
 /* Size of ringbuffer for vblank timestamps. Just double-buffer
  * in initial implementation.
  */
 #define DRM_VBLANKTIME_RBSIZE 2
 /* Flags and return codes for get_vblank_timestamp() driver function. */
 #define DRM_CALLED_FROM_VBLIRQ 1
 #define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
 #define DRM_VBLANKTIME_IN_VBLANK         (1 << 1)
 /* get_scanout_position() return flags */
 #define DRM_SCANOUTPOS_VALID        (1 << 0)
 #define DRM_SCANOUTPOS_IN_VBLANK    (1 << 1)
 #define DRM_SCANOUTPOS_ACCURATE     (1 << 2)
 /**
  * DRM driver structure. This structure represent the common code for
  * a family of cards. There will one drm_device for each card present
  * in this family
  */
 struct drm_driver {
 	int (*load) (struct drm_device *, unsigned long flags);
 	int (*firstopen) (struct drm_device *);
 	int (*open) (struct drm_device *, struct drm_file *);
 	void (*preclose) (struct drm_device *, struct drm_file *file_priv);
 	void (*postclose) (struct drm_device *, struct drm_file *);
 	void (*lastclose) (struct drm_device *);
 	int (*unload) (struct drm_device *);
 	int (*suspend) (struct drm_device *, pm_message_t state);
 	int (*resume) (struct drm_device *);
 	int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
 	int (*dma_quiescent) (struct drm_device *);
 	int (*context_dtor) (struct drm_device *dev, int context);
 	int (*set_busid)(struct drm_device *dev, struct drm_master *master);
 	/**
 	 * get_vblank_counter - get raw hardware vblank counter
 	 * @dev: DRM device
 	 * @pipe: counter to fetch
+	 *
 	 * Driver callback for fetching a raw hardware vblank counter for @crtc.
 	 * If a device doesn't have a hardware counter, the driver can simply
 	 * return the value of drm_vblank_count. The DRM core will account for
 	 * missed vblank events while interrupts where disabled based on system
 	 * timestamps.
+	 *
 	 * Wraparound handling and loss of events due to modesetting is dealt
 	 * with in the DRM core code.
+	 *
 	 * RETURNS
 	 * Raw vblank counter value.
 	 */
 	u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe);
 	/**
 	 * enable_vblank - enable vblank interrupt events
 	 * @dev: DRM device
 	 * @pipe: which irq to enable
+	 *
 	 * Enable vblank interrupts for @crtc.  If the device doesn't have
 	 * a hardware vblank counter, this routine should be a no-op, since
 	 * interrupts will have to stay on to keep the count accurate.
+	 *
 	 * RETURNS
 	 * Zero on success, appropriate errno if the given @crtc's vblank
 	 * interrupt cannot be enabled.
 	 */
 	int (*enable_vblank) (struct drm_device *dev, unsigned int pipe);
 	/**
 	 * disable_vblank - disable vblank interrupt events
 	 * @dev: DRM device
 	 * @pipe: which irq to enable
+	 *
 	 * Disable vblank interrupts for @crtc.  If the device doesn't have
 	 * a hardware vblank counter, this routine should be a no-op, since
 	 * interrupts will have to stay on to keep the count accurate.
 	 */
 	void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);
 	/**
 	 * Called by \c drm_device_is_agp.  Typically used to determine if a
 	 * card is really attached to AGP or not.
+	 *
 	 * \param dev  DRM device handle
+	 *
 	 * \returns
 	 * One of three values is returned depending on whether or not the
 	 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
 	 * (return of 1), or may or may not be AGP (return of 2).
 	 */
 	int (*device_is_agp) (struct drm_device *dev);
 	/**
 	 * Called by vblank timestamping code.
+	 *
 	 * Return the current display scanout position from a crtc, and an
 	 * optional accurate ktime_get timestamp of when position was measured.
+	 *
 	 * \param dev  DRM device.
 	 * \param pipe Id of the crtc to query.
 	 * \param flags Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
 	 * \param *vpos Target location for current vertical scanout position.
 	 * \param *hpos Target location for current horizontal scanout position.
 	 * \param *stime Target location for timestamp taken immediately before
 	 *               scanout position query. Can be NULL to skip timestamp.
 	 * \param *etime Target location for timestamp taken immediately after
 	 *               scanout position query. Can be NULL to skip timestamp.
 	 * \param mode Current display timings.
+	 *
 	 * Returns vpos as a positive number while in active scanout area.
 	 * Returns vpos as a negative number inside vblank, counting the number
 	 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
 	 * until start of active scanout / end of vblank."
+	 *
 	 * \return Flags, or'ed together as follows:
+	 *
 	 * DRM_SCANOUTPOS_VALID = Query successful.
 	 * DRM_SCANOUTPOS_INVBL = Inside vblank.
 	 * DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of
 	 * this flag means that returned position may be offset by a constant
 	 * but unknown small number of scanlines wrt. real scanout position.
+	 *
 	 */
 	int (*get_scanout_position) (struct drm_device *dev, unsigned int pipe,
 				     unsigned int flags, int *vpos, int *hpos,
 				     ktime_t *stime, ktime_t *etime,
 				     const struct drm_display_mode *mode);
 	/**
 	 * Called by \c drm_get_last_vbltimestamp. Should return a precise
 	 * timestamp when the most recent VBLANK interval ended or will end.
+	 *
 	 * Specifically, the timestamp in @vblank_time should correspond as
 	 * closely as possible to the time when the first video scanline of
 	 * the video frame after the end of VBLANK will start scanning out,
 	 * the time immediately after end of the VBLANK interval. If the
 	 * @crtc is currently inside VBLANK, this will be a time in the future.
 	 * If the @crtc is currently scanning out a frame, this will be the
 	 * past start time of the current scanout. This is meant to adhere
 	 * to the OpenML OML_sync_control extension specification.
+	 *
 	 * \param dev dev DRM device handle.
 	 * \param pipe crtc for which timestamp should be returned.
 	 * \param *max_error Maximum allowable timestamp error in nanoseconds.
 	 *                   Implementation should strive to provide timestamp
 	 *                   with an error of at most *max_error nanoseconds.
 	 *                   Returns true upper bound on error for timestamp.
 	 * \param *vblank_time Target location for returned vblank timestamp.
 	 * \param flags 0 = Defaults, no special treatment needed.
 	 * \param       DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
 	 *	        irq handler. Some drivers need to apply some workarounds
 	 *              for gpu-specific vblank irq quirks if flag is set.
+	 *
 	 * \returns
 	 * Zero if timestamping isn't supported in current display mode or a
 	 * negative number on failure. A positive status code on success,
 	 * which describes how the vblank_time timestamp was computed.
 	 */
 	int (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe,
 				     int *max_error,
 				     struct timeval *vblank_time,
 				     unsigned flags);
 	/* these have to be filled in */
 	irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
 	void (*irq_preinstall) (struct drm_device *dev);
 	int (*irq_postinstall) (struct drm_device *dev);
 	void (*irq_uninstall) (struct drm_device *dev);
 	/* Master routines */
 	int (*master_create)(struct drm_device *dev, struct drm_master *master);
 	void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
 	/**
 	 * master_set is called whenever the minor master is set.
 	 * master_drop is called whenever the minor master is dropped.
 	 */
 	int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
 			  bool from_open);
 	void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
 			    bool from_release);
 	int (*debugfs_init)(struct drm_minor *minor);
 	void (*debugfs_cleanup)(struct drm_minor *minor);
 	/**
 	 * Driver-specific constructor for drm_gem_objects, to set up
 	 * obj->driver_private.
+	 *
 	 * Returns 0 on success.
 	 */
 	void (*gem_free_object) (struct drm_gem_object *obj);
 	int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
 	void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
 	/* prime: */
 	/* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
 	int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
 				uint32_t handle, uint32_t flags, int *prime_fd);
 	/* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
 	int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
 				int prime_fd, uint32_t *handle);
 	/* export GEM -> dmabuf */
 	struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
 				struct drm_gem_object *obj, int flags);
 	/* import dmabuf -> GEM */
 	struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
 				struct dma_buf *dma_buf);
 	/* low-level interface used by drm_gem_prime_{import,export} */
 	int (*gem_prime_pin)(struct drm_gem_object *obj);
 	void (*gem_prime_unpin)(struct drm_gem_object *obj);
 	struct reservation_object * (*gem_prime_res_obj)(
 				struct drm_gem_object *obj);
 	struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
 	struct drm_gem_object *(*gem_prime_import_sg_table)(
 				struct drm_device *dev,
 				struct dma_buf_attachment *attach,
 				struct sg_table *sgt);
 	void *(*gem_prime_vmap)(struct drm_gem_object *obj);
 	void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
 	int (*gem_prime_mmap)(struct drm_gem_object *obj,
 				struct vm_area_struct *vma);
 	/* vga arb irq handler */
 	void (*vgaarb_irq)(struct drm_device *dev, bool state);
 	/* dumb alloc support */
 	int (*dumb_create)(struct drm_file *file_priv,
 			   struct drm_device *dev,
 			   struct drm_mode_create_dumb *args);
 	int (*dumb_map_offset)(struct drm_file *file_priv,
 			       struct drm_device *dev, uint32_t handle,
 			       uint64_t *offset);
 	int (*dumb_destroy)(struct drm_file *file_priv,
 			    struct drm_device *dev,
 			    uint32_t handle);
 	/* Driver private ops for this object */
 #ifdef __NetBSD__
 	int (*mmap_object)(struct drm_device *, off_t, size_t, int,
 	    struct uvm_object **, voff_t *, struct file *);
 	const struct uvm_pagerops *gem_uvm_ops;
 #else
 	const struct vm_operations_struct *gem_vm_ops;
 #endif
 	int major;
 	int minor;
 	int patchlevel;
 	const char *name;
 	const char *desc;
 	const char *date;
 	u32 driver_features;
 	int dev_priv_size;
 	const struct drm_ioctl_desc *ioctls;
 	int num_ioctls;
 	const struct file_operations *fops;
 	/* List of devices hanging off this driver with stealth attach. */
 	struct list_head legacy_dev_list;
 };
 enum drm_minor_type {
 	DRM_MINOR_LEGACY,
 	DRM_MINOR_CONTROL,
 	DRM_MINOR_RENDER,
 	DRM_MINOR_CNT,
 };
 #ifdef __NetBSD__		/* XXX debugfs */
 struct seq_file;
 #endif
 /**
  * Info file list entry. This structure represents a debugfs or proc file to
  * be created by the drm core
  */
 struct drm_info_list {
 	const char *name; /** file name */
 	int (*show)(struct seq_file*, void*); /** show callback */
 	u32 driver_features; /**< Required driver features for this entry */
 	void *data;
 };
 /**
  * debugfs node structure. This structure represents a debugfs file.
  */
 struct drm_info_node {
 	struct list_head list;
 	struct drm_minor *minor;
 	const struct drm_info_list *info_ent;
 	struct dentry *dent;
 };
 /**
  * DRM minor structure. This structure represents a drm minor number.
  */
 struct drm_minor {
 	int index;			/**< Minor device number */
 	int type;                       /**< Control or render */
 	struct device *kdev;		/**< Linux device */
 	struct drm_device *dev;
 #ifndef __NetBSD__		/* XXX debugfs */
 	struct dentry *debugfs_root;
 	struct list_head debugfs_list;
 	struct mutex debugfs_lock; /* Protects debugfs_list. */
 #endif
 	/* currently active master for this node. Protected by master_mutex */
 	struct drm_master *master;
 };
 struct drm_pending_vblank_event {
 	struct drm_pending_event base;
 	unsigned int pipe;
 	struct drm_event_vblank event;
 };
 struct drm_vblank_crtc {
 	struct drm_device *dev;		/* pointer to the drm_device */
 #ifdef __NetBSD__
 	drm_waitqueue_t queue;
 #else
 	wait_queue_head_t queue;	/**< VBLANK wait queue */
 #endif
 	struct timer_list disable_timer;		/* delayed disable timer */
 	/* vblank counter, protected by dev->vblank_time_lock for writes */
 	u32 count;
 	/* vblank timestamps, protected by dev->vblank_time_lock for writes */
 	struct timeval time[DRM_VBLANKTIME_RBSIZE];
 	atomic_t refcount;		/* number of users of vblank interruptsper crtc */
 	u32 last;			/* protected by dev->vbl_lock, used */
 					/* for wraparound handling */
 	u32 last_wait;			/* Last vblank seqno waited per CRTC */
 	unsigned int inmodeset;		/* Display driver is setting mode */
 	unsigned int pipe;		/* crtc index */
 	int framedur_ns;		/* frame/field duration in ns */
 	int linedur_ns;			/* line duration in ns */
 	bool enabled;			/* so we don't call enable more than
 					   once per disable */
 };
 /**
  * DRM device structure. This structure represent a complete card that
  * may contain multiple heads.
  */
 struct drm_device {
 	struct list_head legacy_dev_list;/**< list of devices per driver for stealth attach cleanup */
 	int if_version;			/**< Highest interface version set */
 	/** \name Lifetime Management */
 	/*@{ */
 	struct kref ref;		/**< Object ref-count */
 	struct device *dev;		/**< Device structure of bus-device */
 	struct drm_driver *driver;	/**< DRM driver managing the device */
 	void *dev_private;		/**< DRM driver private data */
 	struct drm_minor *control;		/**< Control node */
 	struct drm_minor *primary;		/**< Primary node */
 	struct drm_minor *render;		/**< Render node */
 	atomic_t unplugged;			/**< Flag whether dev is dead */
 	struct inode *anon_inode;		/**< inode for private address-space */
 	char *unique;				/**< unique name of the device */
 	/*@} */
 	/** \name Locks */
 	/*@{ */
 	struct mutex struct_mutex;	/**< For others */
 	struct mutex master_mutex;      /**< For drm_minor::master and drm_file::is_master */
 	/*@} */
 	/** \name Usage Counters */
 	/*@{ */
 	int open_count;			/**< Outstanding files open, protected by drm_global_mutex. */
 	spinlock_t buf_lock;		/**< For drm_device::buf_use and a few other things. */
 	int buf_use;			/**< Buffers in use -- cannot alloc */
 	atomic_t buf_alloc;		/**< Buffer allocation in progress */
 	/*@} */
 	struct list_head filelist;
 	/** \name Memory management */
 	/*@{ */
 	struct list_head maplist;	/**< Linked list of regions */
 	struct drm_open_hash map_hash;	/**< User token hash table for maps */
 	/** \name Context handle management */
 	/*@{ */
 	struct list_head ctxlist;	/**< Linked list of context handles */
 	struct mutex ctxlist_mutex;	/**< For ctxlist */
 	struct idr ctx_idr;
 	struct list_head vmalist;	/**< List of vmas (for debugging) */
 	/*@} */
 	/** \name DMA support */
 	/*@{ */
 	struct drm_device_dma *dma;		/**< Optional pointer for DMA support */
 	/*@} */
 	/** \name Context support */
 	/*@{ */
 	__volatile__ long context_flag;	/**< Context swapping flag */
 	int last_context;		/**< Last current context */
 	/*@} */
 	/** \name VBLANK IRQ support */
 	/*@{ */
 	bool irq_enabled;
 	int irq;
 #ifdef __NetBSD__
 	struct drm_bus_irq_cookie *irq_cookie;
 #endif
 	/*
 	 * At load time, disabling the vblank interrupt won't be allowed since
 	 * old clients may not call the modeset ioctl and therefore misbehave.
 	 * Once the modeset ioctl *has* been called though, we can safely
 	 * disable them when unused.
 	 */
 	bool vblank_disable_allowed;
 	/*
 	 * If true, vblank interrupt will be disabled immediately when the
 	 * refcount drops to zero, as opposed to via the vblank disable
 	 * timer.
 	 * This can be set to true it the hardware has a working vblank
 	 * counter and the driver uses drm_vblank_on() and drm_vblank_off()
 	 * appropriately.
 	 */
 	bool vblank_disable_immediate;
 	/* array of size num_crtcs */
 	struct drm_vblank_crtc *vblank;
 	spinlock_t vblank_time_lock;    /**< Protects vblank count and time updates during vblank enable/disable */
 	spinlock_t vbl_lock;
 	u32 max_vblank_count;           /**< size of vblank counter register */
 	/**
 	 * List of events
 	 */
 	struct list_head vblank_event_list;
 	spinlock_t event_lock;
 	/*@} */
 	struct drm_agp_head *agp;	/**< AGP data */
 	struct pci_dev *pdev;		/**< PCI device structure */
 #ifdef __alpha__
 	struct pci_controller *hose;
 #endif
 	struct platform_device *platformdev; /**< Platform device struture */
 	struct virtio_device *virtdev;
 #ifdef __NetBSD__
 	bus_space_tag_t bst;
 	struct drm_bus_map *bus_maps;
 	unsigned bus_nmaps;
 	bus_dma_tag_t bus_dmat;
 	bus_dma_tag_t dmat;
 	bool dmat_subregion_p;
 	bus_addr_t dmat_subregion_min;
 	bus_addr_t dmat_subregion_max;
 #endif
 	struct drm_sg_mem *sg;	/**< Scatter gather memory */
 	unsigned int num_crtcs;                  /**< Number of CRTCs on this device */
 	struct {
 		int context;
 		struct drm_hw_lock *lock;
 	} sigdata;
 	struct drm_local_map *agp_buffer_map;
 	unsigned int agp_buffer_token;
 	struct drm_mode_config mode_config;	/**< Current mode config */
 	/** \name GEM information */
 	/*@{ */
 	struct mutex object_name_lock;
 	struct idr object_name_idr;
 	struct drm_vma_offset_manager *vma_offset_manager;
 	/*@} */
 	int switch_power_state;
 };
 #define DRM_SWITCH_POWER_ON 0
 #define DRM_SWITCH_POWER_OFF 1
 #define DRM_SWITCH_POWER_CHANGING 2
 #define DRM_SWITCH_POWER_DYNAMIC_OFF 3
 static __inline__ int drm_core_check_feature(struct drm_device *dev,
 					     int feature)
+{
 	return ((dev->driver->driver_features & feature) ? 1 : 0);
+}
 static inline void drm_device_set_unplugged(struct drm_device *dev)
+{
 	smp_wmb();
 	atomic_set(&dev->unplugged, 1);
+}
 static inline int drm_device_is_unplugged(struct drm_device *dev)
+{
 	int ret = atomic_read(&dev->unplugged);
 	smp_rmb();
 	return ret;
+}
 static inline bool drm_is_render_client(const struct drm_file *file_priv)
+{
 	return file_priv->minor->type == DRM_MINOR_RENDER;
+}
 static inline bool drm_is_control_client(const struct drm_file *file_priv)
+{
 	return file_priv->minor->type == DRM_MINOR_CONTROL;
+}
 static inline bool drm_is_primary_client(const struct drm_file *file_priv)
+{
 	return file_priv->minor->type == DRM_MINOR_LEGACY;
+}
 /******************************************************************/
 /** \name Internal function definitions */
 /*@{*/
 				/* Driver support (drm_drv.h) */
 #ifndef __NetBSD__
 extern int drm_ioctl_permit(u32 flags, struct drm_file *file_priv);
 extern long drm_ioctl(struct file *filp,
 		      unsigned int cmd, unsigned long arg);
 extern long drm_compat_ioctl(struct file *filp,
 			     unsigned int cmd, unsigned long arg);
 extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags);
 #endif
 				/* Device support (drm_fops.h) */
 #ifdef __NetBSD__
 extern int drm_open_file(struct drm_file *, void *, struct drm_minor *);
 extern void drm_close_file(struct drm_file *);
 #else
 extern int drm_open(struct inode *inode, struct file *filp);
 extern ssize_t drm_read(struct file *filp, char __user *buffer,
 			size_t count, loff_t *offset);
 extern int drm_release(struct inode *inode, struct file *filp);
 #endif
 extern int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv);
 				/* Mapping support (drm_vm.h) */
 #ifndef __NetBSD__
 extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
 #endif
 /* Misc. IOCTL support (drm_ioctl.c) */
 int drm_noop(struct drm_device *dev, void *data,
 	     struct drm_file *file_priv);
 int drm_invalid_op(struct drm_device *dev, void *data,
 		   struct drm_file *file_priv);
 /* Cache management (drm_cache.c) */
 void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
 #ifdef __NetBSD__		/* XXX drm clflush */
 void drm_clflush_pglist(struct pglist *);
 void drm_clflush_page(struct page *);
 void drm_clflush_virt_range(const void *, size_t);
 #else
 void drm_clflush_sg(struct sg_table *st);
 void drm_clflush_virt_range(void *addr, unsigned long length);
 #endif
 /*
  * These are exported to drivers so that they can implement fencing using
  * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
  */
 				/* IRQ support (drm_irq.h) */
 extern int drm_irq_install(struct drm_device *dev, int irq);
 extern int drm_irq_uninstall(struct drm_device *dev);
 extern int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs);
 extern int drm_wait_vblank(struct drm_device *dev, void *data,
 			   struct drm_file *filp);
 extern u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe);
 extern u32 drm_crtc_vblank_count(struct drm_crtc *crtc);
 extern u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
 				     struct timeval *vblanktime);
 extern u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
 					  struct timeval *vblanktime);
 extern void drm_send_vblank_event(struct drm_device *dev, unsigned int pipe,
 				  struct drm_pending_vblank_event *e);
 extern void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
 				       struct drm_pending_vblank_event *e);
 extern void drm_arm_vblank_event(struct drm_device *dev, unsigned int pipe,
 				 struct drm_pending_vblank_event *e);
 extern void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
 				      struct drm_pending_vblank_event *e);
 extern bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe);
 extern bool drm_crtc_handle_vblank(struct drm_crtc *crtc);
 extern int drm_vblank_get(struct drm_device *dev, unsigned int pipe);
 extern void drm_vblank_put(struct drm_device *dev, unsigned int pipe);
 extern int drm_crtc_vblank_get(struct drm_crtc *crtc);
 extern void drm_crtc_vblank_put(struct drm_crtc *crtc);
 extern void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe);
 extern void drm_crtc_wait_one_vblank(struct drm_crtc *crtc);
 extern void drm_vblank_off(struct drm_device *dev, unsigned int pipe);
 extern void drm_vblank_on(struct drm_device *dev, unsigned int pipe);
 extern void drm_crtc_vblank_off(struct drm_crtc *crtc);
 extern void drm_crtc_vblank_reset(struct drm_crtc *crtc);
 extern void drm_crtc_vblank_on(struct drm_crtc *crtc);
 extern void drm_vblank_cleanup(struct drm_device *dev);
 extern u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe);
 extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
 						 unsigned int pipe, int *max_error,
 						 struct timeval *vblank_time,
 						 unsigned flags,
 						 const struct drm_display_mode *mode);
 extern void drm_calc_timestamping_constants(struct drm_crtc *crtc,
 					    const struct drm_display_mode *mode);
 /**
  * drm_crtc_vblank_waitqueue - get vblank waitqueue for the CRTC
  * @crtc: which CRTC's vblank waitqueue to retrieve
+ *
  * This function returns a pointer to the vblank waitqueue for the CRTC.
  * Drivers can use this to implement vblank waits using wait_event() & co.
  */
 static inline wait_queue_head_t *drm_crtc_vblank_waitqueue(struct drm_crtc *crtc)
+{
 	return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;
+}
 /* Modesetting support */
 extern void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe);
 extern void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe);
 #ifdef __NetBSD__
 struct drm_agp_hooks {
 	drm_ioctl_t	*agph_acquire_ioctl;
 	drm_ioctl_t	*agph_release_ioctl;
 	drm_ioctl_t	*agph_enable_ioctl;
 	drm_ioctl_t	*agph_info_ioctl;
 	drm_ioctl_t	*agph_alloc_ioctl;
 	drm_ioctl_t	*agph_free_ioctl;

 @@ -1,46 +1,48 @@
-/*	$NetBSD: dma-mapping.h,v 1.3 2014/08/06 13:50:53 riastradh Exp $	*/
+/*	$NetBSD: dma-mapping.h,v 1.4 2018/08/27 06:17:30 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.
  */
 #ifndef _LINUX_DMA_MAPPING_H_
 #define _LINUX_DMA_MAPPING_H_
 #include <sys/bus.h>
 #include <linux/bug.h>
 typedef bus_addr_t dma_addr_t;
 static inline uintmax_t
 DMA_BIT_MASK(unsigned nbits)
+{
 	return ~(~(uintmax_t)0 << nbits);
+}
 #endif  /* _LINUX_DMA_MAPPING_H_ */

	@@ -1,121 +1,122 @@		@@ -1,121 +1,122 @@
1	/* $NetBSD: mutex.h,v 1.8 2018/08/27 06:06:41 riastradh Exp $ */	1	/* $NetBSD: mutex.h,v 1.9 2018/08/27 06:17:30 riastradh Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 2013 The NetBSD Foundation, Inc.	4	* Copyright (c) 2013 The NetBSD Foundation, Inc.
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* This code is derived from software contributed to The NetBSD Foundation	7	* This code is derived from software contributed to The NetBSD Foundation
8	* by Taylor R. Campbell.	8	* by Taylor R. Campbell.
9	*	9	*
10	* Redistribution and use in source and binary forms, with or without	10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions	11	* modification, are permitted provided that the following conditions
12	* are met:	12	* are met:
13	* 1. Redistributions of source code must retain the above copyright	13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.	14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright	15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the	16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.	17	* documentation and/or other materials provided with the distribution.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS	19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED	20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR	21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS	22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29	* POSSIBILITY OF SUCH DAMAGE.	29	* POSSIBILITY OF SUCH DAMAGE.
30	*/	30	*/
31		31
32	#ifndef _LINUX_MUTEX_H_	32	#ifndef _LINUX_MUTEX_H_
33	#define _LINUX_MUTEX_H_	33	#define _LINUX_MUTEX_H_
34		34
35	#include <sys/mutex.h>	35	#include <sys/mutex.h>
36		36
37	#include <lib/libkern/libkern.h> /* KASSERT */	37	#include <lib/libkern/libkern.h> /* KASSERT */
38	#include <linux/list.h>	38	#include <linux/list.h>
39		39
40	#define __acquires(lock) /* XXX lockdep stuff */	40	#define __acquires(lock) /* XXX lockdep stuff */
41	#define __releases(lock) /* XXX lockdep stuff */	41	#define __releases(lock) /* XXX lockdep stuff */
		42	#define might_lock(lock) do {} while(0) /* XXX lockdep stuff */
42		43
43	struct mutex {	44	struct mutex {
44	kmutex_t mtx_lock;	45	kmutex_t mtx_lock;
45	};	46	};
46		47
47	struct lock_class_key {	48	struct lock_class_key {
48	};	49	};
49		50
50	/* Name collision. Pooh. */	51	/* Name collision. Pooh. */
51	static inline void	52	static inline void
52	linux_mutex_init(struct mutex *mutex)	53	linux_mutex_init(struct mutex *mutex)
53	{	54	{
54	mutex_init(&mutex->mtx_lock, MUTEX_DEFAULT, IPL_NONE);	55	mutex_init(&mutex->mtx_lock, MUTEX_DEFAULT, IPL_NONE);
55	}	56	}
56		57
57	/* Lockdep stuff. */	58	/* Lockdep stuff. */
58	static inline void	59	static inline void
59	__mutex_init(struct mutex mutex, const char name __unused,	60	__mutex_init(struct mutex mutex, const char name __unused,
60	struct lock_class_key *key __unused)	61	struct lock_class_key *key __unused)
61	{	62	{
62	linux_mutex_init(mutex);	63	linux_mutex_init(mutex);
63	}	64	}
64		65
65	/* Another name collision. */	66	/* Another name collision. */
66	static inline void	67	static inline void
67	linux_mutex_destroy(struct mutex *mutex)	68	linux_mutex_destroy(struct mutex *mutex)
68	{	69	{
69	mutex_destroy(&mutex->mtx_lock);	70	mutex_destroy(&mutex->mtx_lock);
70	}	71	}
71		72
72	static inline void	73	static inline void
73	mutex_lock(struct mutex *mutex)	74	mutex_lock(struct mutex *mutex)
74	{	75	{
75	mutex_enter(&mutex->mtx_lock);	76	mutex_enter(&mutex->mtx_lock);
76	}	77	}
77		78
78	static inline int	79	static inline int
79	mutex_lock_interruptible(struct mutex *mutex)	80	mutex_lock_interruptible(struct mutex *mutex)
80	{	81	{
81	mutex_enter(&mutex->mtx_lock); /* XXX */	82	mutex_enter(&mutex->mtx_lock); /* XXX */
82	return 0;	83	return 0;
83	}	84	}
84		85
85	static inline int	86	static inline int
86	mutex_trylock(struct mutex *mutex)	87	mutex_trylock(struct mutex *mutex)
87	{	88	{
88	return mutex_tryenter(&mutex->mtx_lock);	89	return mutex_tryenter(&mutex->mtx_lock);
89	}	90	}
90		91
91	static inline void	92	static inline void
92	mutex_unlock(struct mutex *mutex)	93	mutex_unlock(struct mutex *mutex)
93	{	94	{
94	mutex_exit(&mutex->mtx_lock);	95	mutex_exit(&mutex->mtx_lock);
95	}	96	}
96		97
97	static inline bool	98	static inline bool
98	mutex_is_locked(struct mutex *mutex)	99	mutex_is_locked(struct mutex *mutex)
99	{	100	{
100	return mutex_owned(&mutex->mtx_lock);	101	return mutex_owned(&mutex->mtx_lock);
101	}	102	}
102		103
103	static inline void	104	static inline void
104	mutex_lock_nest_lock(struct mutex mutex, struct mutex already)	105	mutex_lock_nest_lock(struct mutex mutex, struct mutex already)
105	{	106	{
106		107
107	KASSERT(mutex_is_locked(already));	108	KASSERT(mutex_is_locked(already));
108	mutex_lock(mutex);	109	mutex_lock(mutex);
109	}	110	}
110		111
111	#define lockdep_assert_held(m) do {} while (0)	112	#define lockdep_assert_held(m) do {} while (0)
112		113
113	#define SINGLE_DEPTH_NESTING 0	114	#define SINGLE_DEPTH_NESTING 0
114		115
115	static inline void	116	static inline void
116	mutex_lock_nested(struct mutex *mutex, unsigned subclass __unused)	117	mutex_lock_nested(struct mutex *mutex, unsigned subclass __unused)
117	{	118	{
118	mutex_lock(mutex);	119	mutex_lock(mutex);
119	}	120	}
120		121
121	#endif /* _LINUX_MUTEX_H_ */	122	#endif /* _LINUX_MUTEX_H_ */

 @@ -1,72 +1,73 @@
-/*	$NetBSD: sched.h,v 1.6 2018/08/27 06:07:32 riastradh Exp $	*/
+/*	$NetBSD: sched.h,v 1.7 2018/08/27 06:17:30 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.
  */
 #ifndef _LINUX_SCHED_H_
 #define _LINUX_SCHED_H_
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <asm/param.h>
 #include <asm/barrier.h>
 #include <linux/errno.h>
 #define	TASK_COMM_LEN	MAXCOMLEN
 #define	current	curproc
 static inline pid_t
 task_pid_nr(struct proc *p)
+{
 	return p->p_pid;
+}
 static inline long
 schedule_timeout_uninterruptible(long timeout)
+{
 	long remain;
 	int start, end;
 	if (cold) {
 		DELAY(timeout);
 		return 0;
+	}
 	start = hardclock_ticks;
 	/* XXX Integer truncation...not likely to matter here.  */
 	(void)kpause("loonix", false /*!intr*/, timeout, NULL);
 	end = hardclock_ticks;
 	remain = timeout - (end - start);
 	return remain > 0 ? remain : 0;
+}
 #endif  /* _LINUX_SCHED_H_ */

	@@ -1,180 +1,182 @@		@@ -1,180 +1,182 @@
1	/* $NetBSD: spinlock.h,v 1.7 2016/04/13 08:43:56 riastradh Exp $ */	1	/* $NetBSD: spinlock.h,v 1.8 2018/08/27 06:17:30 riastradh Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 2013 The NetBSD Foundation, Inc.	4	* Copyright (c) 2013 The NetBSD Foundation, Inc.
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* This code is derived from software contributed to The NetBSD Foundation	7	* This code is derived from software contributed to The NetBSD Foundation
8	* by Taylor R. Campbell.	8	* by Taylor R. Campbell.
9	*	9	*
10	* Redistribution and use in source and binary forms, with or without	10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions	11	* modification, are permitted provided that the following conditions
12	* are met:	12	* are met:
13	* 1. Redistributions of source code must retain the above copyright	13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.	14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright	15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the	16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.	17	* documentation and/or other materials provided with the distribution.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS	19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED	20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR	21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS	22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29	* POSSIBILITY OF SUCH DAMAGE.	29	* POSSIBILITY OF SUCH DAMAGE.
30	*/	30	*/
31		31
32	#ifndef _LINUX_SPINLOCK_H_	32	#ifndef _LINUX_SPINLOCK_H_
33	#define _LINUX_SPINLOCK_H_	33	#define _LINUX_SPINLOCK_H_
34		34
35	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
36	#include <sys/mutex.h>	36	#include <sys/mutex.h>
37		37
38	#include <machine/limits.h>	38	#include <machine/limits.h>
		39	#include <linux/irqflags.h>
		40	#include <linux/preempt.h>
39		41
40	#define __acquires(lock) /* XXX lockdep stuff */	42	#define __acquires(lock) /* XXX lockdep stuff */
41	#define __releases(lock) /* XXX lockdep stuff */	43	#define __releases(lock) /* XXX lockdep stuff */
42		44
43	typedef struct spinlock {	45	typedef struct spinlock {
44	kmutex_t sl_lock;	46	kmutex_t sl_lock;
45	} spinlock_t;	47	} spinlock_t;
46		48
47	static inline int	49	static inline int
48	spin_is_locked(spinlock_t *spinlock)	50	spin_is_locked(spinlock_t *spinlock)
49	{	51	{
50	return mutex_owned(&spinlock->sl_lock);	52	return mutex_owned(&spinlock->sl_lock);
51	}	53	}
52		54
53	static inline void	55	static inline void
54	spin_lock(spinlock_t *spinlock)	56	spin_lock(spinlock_t *spinlock)
55	{	57	{
56	mutex_enter(&spinlock->sl_lock);	58	mutex_enter(&spinlock->sl_lock);
57	}	59	}
58		60
59	static inline void	61	static inline void
60	spin_unlock(spinlock_t *spinlock)	62	spin_unlock(spinlock_t *spinlock)
61	{	63	{
62	mutex_exit(&spinlock->sl_lock);	64	mutex_exit(&spinlock->sl_lock);
63	}	65	}
64		66
65	static inline void	67	static inline void
66	spin_lock_irq(spinlock_t *spinlock)	68	spin_lock_irq(spinlock_t *spinlock)
67	{	69	{
68	spin_lock(spinlock);	70	spin_lock(spinlock);
69	}	71	}
70		72
71	static inline void	73	static inline void
72	spin_unlock_irq(spinlock_t *spinlock)	74	spin_unlock_irq(spinlock_t *spinlock)
73	{	75	{
74	spin_unlock(spinlock);	76	spin_unlock(spinlock);
75	}	77	}
76		78
77	/* Must be a macro because the second argument is to be assigned. */	79	/* Must be a macro because the second argument is to be assigned. */
78	#define spin_lock_irqsave(SPINLOCK, FLAGS) \	80	#define spin_lock_irqsave(SPINLOCK, FLAGS) \
79	do { \	81	do { \
80	(FLAGS) = 0; \	82	(FLAGS) = 0; \
81	mutex_enter(&((spinlock_t *)(SPINLOCK))->sl_lock); \	83	mutex_enter(&((spinlock_t *)(SPINLOCK))->sl_lock); \
82	} while (0)	84	} while (0)
83		85
84	static inline void	86	static inline void
85	spin_unlock_irqrestore(spinlock_t *spinlock, unsigned long __unused flags)	87	spin_unlock_irqrestore(spinlock_t *spinlock, unsigned long __unused flags)
86	{	88	{
87	mutex_exit(&spinlock->sl_lock);	89	mutex_exit(&spinlock->sl_lock);
88	}	90	}
89		91
90	static inline void	92	static inline void
91	spin_lock_init(spinlock_t *spinlock)	93	spin_lock_init(spinlock_t *spinlock)
92	{	94	{
93	/* XXX What's the right IPL? IPL_DRM...? */	95	/* XXX What's the right IPL? IPL_DRM...? */
94	mutex_init(&spinlock->sl_lock, MUTEX_DEFAULT, IPL_VM);	96	mutex_init(&spinlock->sl_lock, MUTEX_DEFAULT, IPL_VM);
95	}	97	}
96		98
97	/*	99	/*
98	* XXX Linux doesn't ever destroy spin locks, it seems. We'll have to	100	* XXX Linux doesn't ever destroy spin locks, it seems. We'll have to
99	* kludge it up.	101	* kludge it up.
100	*/	102	*/
101		103
102	static inline void	104	static inline void
103	spin_lock_destroy(spinlock_t *spinlock)	105	spin_lock_destroy(spinlock_t *spinlock)
104	{	106	{
105	mutex_destroy(&spinlock->sl_lock);	107	mutex_destroy(&spinlock->sl_lock);
106	}	108	}
107		109
108	/* This is a macro to make the panic message clearer. */	110	/* This is a macro to make the panic message clearer. */
109	#define assert_spin_locked(spinlock) \	111	#define assert_spin_locked(spinlock) \
110	KASSERT(mutex_owned(&(spinlock)->sl_lock))	112	KASSERT(mutex_owned(&(spinlock)->sl_lock))
111		113
112	/*	114	/*
113	* Stupid reader/writer spin locks. No attempt to avoid writer	115	* Stupid reader/writer spin locks. No attempt to avoid writer
114	* starvation. Must allow recursive readers. We use mutex and state	116	* starvation. Must allow recursive readers. We use mutex and state
115	* instead of compare-and-swap for expedience and LOCKDEBUG support.	117	* instead of compare-and-swap for expedience and LOCKDEBUG support.
116	*/	118	*/
117		119
118	typedef struct linux_rwlock {	120	typedef struct linux_rwlock {
119	kmutex_t rw_lock;	121	kmutex_t rw_lock;
120	unsigned rw_nreaders;	122	unsigned rw_nreaders;
121	} rwlock_t;	123	} rwlock_t;
122		124
123	static inline void	125	static inline void
124	rwlock_init(rwlock_t *rw)	126	rwlock_init(rwlock_t *rw)
125	{	127	{
126		128
127	mutex_init(&rw->rw_lock, MUTEX_DEFAULT, IPL_VM);	129	mutex_init(&rw->rw_lock, MUTEX_DEFAULT, IPL_VM);
128	rw->rw_nreaders = 0;	130	rw->rw_nreaders = 0;
129	}	131	}
130		132
131	static inline void	133	static inline void
132	rwlock_destroy(rwlock_t *rw)	134	rwlock_destroy(rwlock_t *rw)
133	{	135	{
134		136
135	KASSERTMSG(rw->rw_nreaders == 0,	137	KASSERTMSG(rw->rw_nreaders == 0,
136	"rwlock still held by %u readers", rw->rw_nreaders);	138	"rwlock still held by %u readers", rw->rw_nreaders);
137	mutex_destroy(&rw->rw_lock);	139	mutex_destroy(&rw->rw_lock);
138	}	140	}
139		141
140	static inline void	142	static inline void
141	write_lock_irq(rwlock_t *rw)	143	write_lock_irq(rwlock_t *rw)
142	{	144	{
143		145
144	for (;;) {	146	for (;;) {
145	mutex_spin_enter(&rw->rw_lock);	147	mutex_spin_enter(&rw->rw_lock);
146	if (rw->rw_nreaders == 0)	148	if (rw->rw_nreaders == 0)
147	break;	149	break;
148	mutex_spin_exit(&rw->rw_lock);	150	mutex_spin_exit(&rw->rw_lock);
149	}	151	}
150	}	152	}
151		153
152	static inline void	154	static inline void
153	write_unlock_irq(rwlock_t *rw)	155	write_unlock_irq(rwlock_t *rw)
154	{	156	{
155		157
156	KASSERT(rw->rw_nreaders == 0);	158	KASSERT(rw->rw_nreaders == 0);
157	mutex_spin_exit(&rw->rw_lock);	159	mutex_spin_exit(&rw->rw_lock);
158	}	160	}
159		161
160	static inline void	162	static inline void
161	read_lock(rwlock_t *rw)	163	read_lock(rwlock_t *rw)
162	{	164	{
163		165
164	mutex_spin_enter(&rw->rw_lock);	166	mutex_spin_enter(&rw->rw_lock);
165	KASSERT(rw->rw_nreaders < UINT_MAX);	167	KASSERT(rw->rw_nreaders < UINT_MAX);
166	rw->rw_nreaders++;	168	rw->rw_nreaders++;
167	mutex_spin_exit(&rw->rw_lock);	169	mutex_spin_exit(&rw->rw_lock);
168	}	170	}
169		171
170	static inline void	172	static inline void
171	read_unlock(rwlock_t *rw)	173	read_unlock(rwlock_t *rw)
172	{	174	{
173		175
174	mutex_spin_enter(&rw->rw_lock);	176	mutex_spin_enter(&rw->rw_lock);
175	KASSERT(0 < rw->rw_nreaders);	177	KASSERT(0 < rw->rw_nreaders);
176	rw->rw_nreaders--;	178	rw->rw_nreaders--;
177	mutex_spin_exit(&rw->rw_lock);	179	mutex_spin_exit(&rw->rw_lock);
178	}	180	}
179		181
180	#endif /* _LINUX_SPINLOCK_H_ */	182	#endif /* _LINUX_SPINLOCK_H_ */