blob: 04a7f31301f8fda61ab05cf42a3bea5c28431178 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/**
Dave Airlieb5e89ed2005-09-25 14:28:13 +10002 * \file drmP.h
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Private header for Direct Rendering Manager
Dave Airlieb5e89ed2005-09-25 14:28:13 +10004 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8
9/*
10 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
11 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
Jordan Crousedcdb1672010-05-27 13:40:25 -060012 * Copyright (c) 2009-2010, Code Aurora Forum.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * All rights reserved.
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining a
16 * copy of this software and associated documentation files (the "Software"),
17 * to deal in the Software without restriction, including without limitation
18 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
19 * and/or sell copies of the Software, and to permit persons to whom the
20 * Software is furnished to do so, subject to the following conditions:
21 *
22 * The above copyright notice and this permission notice (including the next
23 * paragraph) shall be included in all copies or substantial portions of the
24 * Software.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
30 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
31 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
32 * OTHER DEALINGS IN THE SOFTWARE.
33 */
34
35#ifndef _DRM_P_H_
36#define _DRM_P_H_
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#ifdef __KERNEL__
39#ifdef __alpha__
40/* add include of current.h so that "current" is defined
41 * before static inline funcs in wait.h. Doing this so we
42 * can build the DRM (part of PI DRI). 4/21/2000 S + B */
43#include <asm/current.h>
Dave Airlieb5e89ed2005-09-25 14:28:13 +100044#endif /* __alpha__ */
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/kernel.h>
46#include <linux/miscdevice.h>
47#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/init.h>
49#include <linux/file.h>
Jordan Crousedcdb1672010-05-27 13:40:25 -060050#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/jiffies.h>
Dave Airlieb05c2382008-03-17 10:24:24 +100053#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <linux/mm.h>
55#include <linux/cdev.h>
Dave Airlie30e2fb12006-02-02 19:37:46 +110056#include <linux/mutex.h>
Andy Lutomirski03dae7c2013-05-13 23:58:47 +000057#include <linux/io.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090058#include <linux/slab.h>
Rob Clark5d13d422013-11-21 14:29:51 -050059#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#if defined(__alpha__) || defined(__powerpc__)
Dave Airlieb5e89ed2005-09-25 14:28:13 +100061#include <asm/pgtable.h> /* For pte_wrprotect */
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#include <asm/mman.h>
64#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#include <linux/types.h>
66#include <linux/agp_backend.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/workqueue.h>
68#include <linux/poll.h>
69#include <asm/pgalloc.h>
David Howells19218e42012-10-02 18:01:03 +010070#include <drm/drm.h>
71#include <drm/drm_sarea.h>
David Herrmann0de23972013-07-24 21:07:52 +020072#include <drm/drm_vma_manager.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Dave Airlie62968142007-07-17 10:46:52 +100074#include <linux/idr.h>
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Paul Gortmakerde477252011-05-26 13:46:22 -040078struct module;
79
Eric Anholtc153f452007-09-03 12:06:45 +100080struct drm_file;
81struct drm_device;
82
Steffen Trumtraredb37a92012-10-28 18:28:06 +010083struct device_node;
Steffen Trumtrarebc64e42012-11-14 11:22:52 +010084struct videomode;
85
David Howellsa1ce3922012-10-02 18:01:25 +010086#include <drm/drm_os_linux.h>
87#include <drm/drm_hashtab.h>
88#include <drm/drm_mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
yakui_zhao4fefcb22009-06-02 14:09:47 +080090#define DRM_UT_CORE 0x01
91#define DRM_UT_DRIVER 0x02
92#define DRM_UT_KMS 0x04
Dave Airlie32488772011-11-25 15:21:02 +000093#define DRM_UT_PRIME 0x08
Zhao Yakui87fdff82009-07-20 13:48:06 +080094/*
95 * Three debug levels are defined.
96 * drm_core, drm_driver, drm_kms
97 * drm_core level can be used in the generic drm code. For example:
98 * drm_ioctl, drm_mm, drm_memory
Lucas De Marchi25985ed2011-03-30 22:57:33 -030099 * The macro definition of DRM_DEBUG is used.
Zhao Yakui87fdff82009-07-20 13:48:06 +0800100 * DRM_DEBUG(fmt, args...)
101 * The debug info by using the DRM_DEBUG can be obtained by adding
102 * the boot option of "drm.debug=1".
103 *
104 * drm_driver level can be used in the specific drm driver. It is used
105 * to add the debug info related with the drm driver. For example:
106 * i915_drv, i915_dma, i915_gem, radeon_drv,
107 * The macro definition of DRM_DEBUG_DRIVER can be used.
108 * DRM_DEBUG_DRIVER(fmt, args...)
109 * The debug info by using the DRM_DEBUG_DRIVER can be obtained by
110 * adding the boot option of "drm.debug=0x02"
111 *
112 * drm_kms level can be used in the KMS code related with specific drm driver.
113 * It is used to add the debug info related with KMS mode. For example:
114 * the connector/crtc ,
115 * The macro definition of DRM_DEBUG_KMS can be used.
116 * DRM_DEBUG_KMS(fmt, args...)
117 * The debug info by using the DRM_DEBUG_KMS can be obtained by
118 * adding the boot option of "drm.debug=0x04"
119 *
120 * If we add the boot option of "drm.debug=0x06", we can get the debug info by
121 * using the DRM_DEBUG_KMS and DRM_DEBUG_DRIVER.
122 * If we add the boot option of "drm.debug=0x05", we can get the debug info by
123 * using the DRM_DEBUG_KMS and DRM_DEBUG.
124 */
yakui_zhao4fefcb22009-06-02 14:09:47 +0800125
Joe Perchesb9075fa2011-10-31 17:11:33 -0700126extern __printf(4, 5)
Joe Perchesbbb0aef2011-04-17 20:35:52 -0700127void drm_ut_debug_printk(unsigned int request_level,
Joe Perchesb9075fa2011-10-31 17:11:33 -0700128 const char *prefix,
129 const char *function_name,
130 const char *format, ...);
131extern __printf(2, 3)
Joe Perches5ad3d882011-04-17 20:35:51 -0700132int drm_err(const char *func, const char *format, ...);
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134/***********************************************************************/
135/** \name DRM template customization defaults */
136/*@{*/
137
138/* driver capabilities and requirements mask */
139#define DRIVER_USE_AGP 0x1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140#define DRIVER_PCI_DMA 0x8
141#define DRIVER_SG 0x10
142#define DRIVER_HAVE_DMA 0x20
143#define DRIVER_HAVE_IRQ 0x40
144#define DRIVER_IRQ_SHARED 0x80
Eric Anholt673a3942008-07-30 12:06:12 -0700145#define DRIVER_GEM 0x1000
Dave Airlief453ba02008-11-07 14:05:41 -0800146#define DRIVER_MODESET 0x2000
Dave Airlie32488772011-11-25 15:21:02 +0000147#define DRIVER_PRIME 0x4000
David Herrmann17931262013-08-25 18:29:00 +0200148#define DRIVER_RENDER 0x8000
Dave Airlie8410ea32010-12-15 03:16:38 +1000149
150#define DRIVER_BUS_PCI 0x1
151#define DRIVER_BUS_PLATFORM 0x2
152#define DRIVER_BUS_USB 0x3
Thierry Reding776dc382013-10-14 14:43:22 +0200153#define DRIVER_BUS_HOST1X 0x4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155/***********************************************************************/
156/** \name Begin the DRM... */
157/*@{*/
158
159#define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then
160 also include looping detection. */
161
Thomas Hellstrom8669cbc2006-08-07 22:22:10 +1000162#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163#define DRM_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */
164#define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000166#define DRM_MAP_HASH_OFFSET 0x10000000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000168/*@}*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170/***********************************************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171/** \name Macros to make printk easier */
172/*@{*/
173
174/**
175 * Error output.
176 *
177 * \param fmt printf() like format string.
178 * \param arg arguments
179 */
Joe Perches5ad3d882011-04-17 20:35:51 -0700180#define DRM_ERROR(fmt, ...) \
181 drm_err(__func__, fmt, ##__VA_ARGS__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Rob Clark5d13d422013-11-21 14:29:51 -0500183/**
184 * Rate limited error output. Like DRM_ERROR() but won't flood the log.
185 *
186 * \param fmt printf() like format string.
187 * \param arg arguments
188 */
189#define DRM_ERROR_RATELIMITED(fmt, ...) \
190({ \
191 static DEFINE_RATELIMIT_STATE(_rs, \
192 DEFAULT_RATELIMIT_INTERVAL, \
193 DEFAULT_RATELIMIT_BURST); \
194 \
195 if (__ratelimit(&_rs)) \
196 drm_err(__func__, fmt, ##__VA_ARGS__); \
197})
198
Joe Perches5ad3d882011-04-17 20:35:51 -0700199#define DRM_INFO(fmt, ...) \
200 printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Jani Nikula48b8f632014-01-31 15:49:07 +0200202#define DRM_INFO_ONCE(fmt, ...) \
203 printk_once(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205/**
206 * Debug output.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000207 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 * \param fmt printf() like format string.
209 * \param arg arguments
210 */
211#if DRM_DEBUG_CODE
yakui_zhao4fefcb22009-06-02 14:09:47 +0800212#define DRM_DEBUG(fmt, args...) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 do { \
yakui_zhao4fefcb22009-06-02 14:09:47 +0800214 drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME, \
215 __func__, fmt, ##args); \
216 } while (0)
217
Zhao Yakui8a4c47f2009-07-20 13:48:04 +0800218#define DRM_DEBUG_DRIVER(fmt, args...) \
yakui_zhao4fefcb22009-06-02 14:09:47 +0800219 do { \
Zhao Yakui8a4c47f2009-07-20 13:48:04 +0800220 drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME, \
yakui_zhao4fefcb22009-06-02 14:09:47 +0800221 __func__, fmt, ##args); \
222 } while (0)
Zhao Yakui8a4c47f2009-07-20 13:48:04 +0800223#define DRM_DEBUG_KMS(fmt, args...) \
yakui_zhao4fefcb22009-06-02 14:09:47 +0800224 do { \
Zhao Yakui8a4c47f2009-07-20 13:48:04 +0800225 drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME, \
yakui_zhao4fefcb22009-06-02 14:09:47 +0800226 __func__, fmt, ##args); \
227 } while (0)
Dave Airlie32488772011-11-25 15:21:02 +0000228#define DRM_DEBUG_PRIME(fmt, args...) \
229 do { \
230 drm_ut_debug_printk(DRM_UT_PRIME, DRM_NAME, \
231 __func__, fmt, ##args); \
232 } while (0)
yakui_zhao4fefcb22009-06-02 14:09:47 +0800233#define DRM_LOG(fmt, args...) \
234 do { \
235 drm_ut_debug_printk(DRM_UT_CORE, NULL, \
236 NULL, fmt, ##args); \
237 } while (0)
238#define DRM_LOG_KMS(fmt, args...) \
239 do { \
240 drm_ut_debug_printk(DRM_UT_KMS, NULL, \
241 NULL, fmt, ##args); \
242 } while (0)
243#define DRM_LOG_MODE(fmt, args...) \
244 do { \
245 drm_ut_debug_printk(DRM_UT_MODE, NULL, \
246 NULL, fmt, ##args); \
247 } while (0)
248#define DRM_LOG_DRIVER(fmt, args...) \
249 do { \
250 drm_ut_debug_printk(DRM_UT_DRIVER, NULL, \
251 NULL, fmt, ##args); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 } while (0)
253#else
Zhao Yakui8a4c47f2009-07-20 13:48:04 +0800254#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
255#define DRM_DEBUG_KMS(fmt, args...) do { } while (0)
Dave Airlie32488772011-11-25 15:21:02 +0000256#define DRM_DEBUG_PRIME(fmt, args...) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257#define DRM_DEBUG(fmt, arg...) do { } while (0)
yakui_zhao4fefcb22009-06-02 14:09:47 +0800258#define DRM_LOG(fmt, arg...) do { } while (0)
259#define DRM_LOG_KMS(fmt, args...) do { } while (0)
260#define DRM_LOG_MODE(fmt, arg...) do { } while (0)
261#define DRM_LOG_DRIVER(fmt, arg...) do { } while (0)
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263#endif
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*@}*/
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267/***********************************************************************/
268/** \name Internal types and structures */
269/*@{*/
270
Dave Airlie99a26572005-09-25 13:25:41 +1000271#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275/**
276 * Test that the hardware lock is held by the caller, returning otherwise.
277 *
278 * \param dev DRM device.
279 * \param filp file pointer of the caller.
280 */
Roel Kluindcae3622009-06-10 12:43:48 -0700281#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
282do { \
283 if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
284 _file_priv->master->lock.file_priv != _file_priv) { \
Eric Anholtc153f452007-09-03 12:06:45 +1000285 DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
Roel Kluindcae3622009-06-10 12:43:48 -0700286 __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
287 _file_priv->master->lock.file_priv, _file_priv); \
288 return -EINVAL; \
289 } \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290} while (0)
291
292/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 * Ioctl function type.
294 *
295 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +1000296 * \param file_priv DRM file private pointer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 * \param cmd command.
298 * \param arg argument.
299 */
Eric Anholtc153f452007-09-03 12:06:45 +1000300typedef int drm_ioctl_t(struct drm_device *dev, void *data,
301 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Dave Airlie9a186642005-06-23 21:29:18 +1000303typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
304 unsigned long arg);
305
Kristian Høgsberg1a959162009-12-02 12:13:48 -0500306#define DRM_IOCTL_NR(n) _IOC_NR(n)
307#define DRM_MAJOR 226
308
Dave Airliea7a2cc32006-01-02 13:54:04 +1100309#define DRM_AUTH 0x1
310#define DRM_MASTER 0x2
311#define DRM_ROOT_ONLY 0x4
Dave Airlief453ba02008-11-07 14:05:41 -0800312#define DRM_CONTROL_ALLOW 0x8
Arnd Bergmanned8b6702009-12-16 22:17:09 +0000313#define DRM_UNLOCKED 0x10
David Herrmann17931262013-08-25 18:29:00 +0200314#define DRM_RENDER_ALLOW 0x20
Dave Airliea7a2cc32006-01-02 13:54:04 +1100315
Eric Anholtc153f452007-09-03 12:06:45 +1000316struct drm_ioctl_desc {
317 unsigned int cmd;
Dave Airliea7a2cc32006-01-02 13:54:04 +1100318 int flags;
Richard Kennedyc972d752009-03-18 17:26:44 +0000319 drm_ioctl_t *func;
Dave Airlie1b2f1482010-08-14 20:20:34 +1000320 unsigned int cmd_drv;
Chris Cumminsb9434d02013-05-09 14:20:40 +0100321 const char *name;
Eric Anholtc153f452007-09-03 12:06:45 +1000322};
323
324/**
325 * Creates a driver or general drm_ioctl_desc array entry for the given
326 * ioctl, for use by drm_ioctl().
327 */
Dave Airlie1b2f1482010-08-14 20:20:34 +1000328
329#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
Chris Cumminsb9434d02013-05-09 14:20:40 +0100330 [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl, .name = #ioctl}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000332struct drm_magic_entry {
Thomas Hellstrom8669cbc2006-08-07 22:22:10 +1000333 struct list_head head;
Dave Airliee0be4282007-07-12 10:26:44 +1000334 struct drm_hash_item hash_item;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000335 struct drm_file *priv;
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000336};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000338struct drm_vma_entry {
Dave Airliebd1b3312007-05-26 05:01:51 +1000339 struct list_head head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct vm_area_struct *vma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000341 pid_t pid;
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000342};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344/**
345 * DMA buffer.
346 */
Dave Airlie056219e2007-07-11 16:17:42 +1000347struct drm_buf {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000348 int idx; /**< Index into master buflist */
349 int total; /**< Buffer size */
350 int order; /**< log-base-2(total) */
351 int used; /**< Amount of buffer in use (for DMA) */
352 unsigned long offset; /**< Byte offset (used internally) */
353 void *address; /**< Address of buffer */
354 unsigned long bus_address; /**< Bus address of buffer */
355 struct drm_buf *next; /**< Kernel-only: used for free list */
356 __volatile__ int waiting; /**< On kernel DMA queue */
357 __volatile__ int pending; /**< On hardware DMA queue */
Eric Anholt6c340ea2007-08-25 20:23:09 +1000358 struct drm_file *file_priv; /**< Private of holding file descr */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000359 int context; /**< Kernel queue for this buffer */
360 int while_locked; /**< Dispatch this buffer while locked */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 enum {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000362 DRM_LIST_NONE = 0,
363 DRM_LIST_FREE = 1,
364 DRM_LIST_WAIT = 2,
365 DRM_LIST_PEND = 3,
366 DRM_LIST_PRIO = 4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 DRM_LIST_RECLAIM = 5
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000368 } list; /**< Which list we're on */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000370 int dev_priv_size; /**< Size of buffer private storage */
371 void *dev_private; /**< Per-buffer private storage */
Dave Airlie056219e2007-07-11 16:17:42 +1000372};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374/** bufs is one longer than it has to be */
Dave Airliecdd55a22007-07-11 16:32:08 +1000375struct drm_waitlist {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000376 int count; /**< Number of possible buffers */
Dave Airlie056219e2007-07-11 16:17:42 +1000377 struct drm_buf **bufs; /**< List of pointers to buffers */
378 struct drm_buf **rp; /**< Read pointer */
379 struct drm_buf **wp; /**< Write pointer */
380 struct drm_buf **end; /**< End pointer */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000381 spinlock_t read_lock;
382 spinlock_t write_lock;
Dave Airliecdd55a22007-07-11 16:32:08 +1000383};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Dave Airliecdd55a22007-07-11 16:32:08 +1000385struct drm_freelist {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000386 int initialized; /**< Freelist in use */
387 atomic_t count; /**< Number of free buffers */
Dave Airlie056219e2007-07-11 16:17:42 +1000388 struct drm_buf *next; /**< End pointer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 wait_queue_head_t waiting; /**< Processes waiting on free bufs */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000391 int low_mark; /**< Low water mark */
392 int high_mark; /**< High water mark */
393 atomic_t wfh; /**< If waiting for high mark */
394 spinlock_t lock;
Dave Airliecdd55a22007-07-11 16:32:08 +1000395};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Dave Airlieddf19b92006-03-19 18:56:12 +1100397typedef struct drm_dma_handle {
398 dma_addr_t busaddr;
399 void *vaddr;
400 size_t size;
401} drm_dma_handle_t;
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403/**
404 * Buffer entry. There is one of this for each buffer size order.
405 */
Dave Airliecdd55a22007-07-11 16:32:08 +1000406struct drm_buf_entry {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000407 int buf_size; /**< size */
408 int buf_count; /**< number of buffers */
Dave Airlie056219e2007-07-11 16:17:42 +1000409 struct drm_buf *buflist; /**< buffer list */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000410 int seg_count;
411 int page_order;
Dave Airliecdd55a22007-07-11 16:32:08 +1000412 struct drm_dma_handle **seglist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Dave Airliecdd55a22007-07-11 16:32:08 +1000414 struct drm_freelist freelist;
415};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +1000417/* Event queued up for userspace to read */
418struct drm_pending_event {
419 struct drm_event *event;
420 struct list_head link;
421 struct drm_file *file_priv;
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -0700422 pid_t pid; /* pid of requester, no guarantee it's valid by the time
423 we deliver the event, for tracing only */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +1000424 void (*destroy)(struct drm_pending_event *event);
425};
426
Dave Airlie32488772011-11-25 15:21:02 +0000427/* initial implementaton using a linked list - todo hashtab */
428struct drm_prime_file_private {
429 struct list_head head;
430 struct mutex lock;
431};
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433/** File private data */
Dave Airlie84b1fd12007-07-11 15:53:27 +1000434struct drm_file {
Chris Wilson39868bd2013-10-29 08:55:58 +0000435 unsigned always_authenticated :1;
436 unsigned authenticated :1;
437 unsigned is_master :1; /* this file private is a master for a minor */
438 /* true when the client has asked us to expose stereo 3D mode flags */
439 unsigned stereo_allowed :1;
440
Eric W. Biederman5fce5e02012-02-07 16:47:26 -0800441 struct pid *pid;
442 kuid_t uid;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000443 drm_magic_t magic;
Dave Airliebd1b3312007-05-26 05:01:51 +1000444 struct list_head lhead;
Dave Airlie2c14f282008-04-21 16:47:32 +1000445 struct drm_minor *minor;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000446 unsigned long lock_count;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000447
Eric Anholt673a3942008-07-30 12:06:12 -0700448 /** Mapping of mm object handles to object pointers. */
449 struct idr object_idr;
450 /** Lock for synchronization of access to object_idr. */
451 spinlock_t table_lock;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000452
Eric Anholt6c340ea2007-08-25 20:23:09 +1000453 struct file *filp;
Dave Airlie8562b3f2007-11-05 12:37:41 +1000454 void *driver_priv;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000455
Dave Airlie7c1c2872008-11-28 14:22:24 +1000456 struct drm_master *master; /* master this node is currently associated with
457 N.B. not always minor->master */
Daniel Vetter4b096ac2012-12-10 21:19:18 +0100458 /**
459 * fbs - List of framebuffers associated with this file.
460 *
461 * Protected by fbs_lock. Note that the fbs list holds a reference on
462 * the fb object to prevent it from untimely disappearing.
463 */
Dave Airlief453ba02008-11-07 14:05:41 -0800464 struct list_head fbs;
Daniel Vetter4b096ac2012-12-10 21:19:18 +0100465 struct mutex fbs_lock;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +1000466
467 wait_queue_head_t event_wait;
468 struct list_head event_list;
469 int event_space;
Dave Airlie32488772011-11-25 15:21:02 +0000470
471 struct drm_prime_file_private prime;
Dave Airlie84b1fd12007-07-11 15:53:27 +1000472};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474/** Wait queue */
Dave Airliecdd55a22007-07-11 16:32:08 +1000475struct drm_queue {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000476 atomic_t use_count; /**< Outstanding uses (+1) */
477 atomic_t finalization; /**< Finalization in progress */
478 atomic_t block_count; /**< Count of processes waiting */
479 atomic_t block_read; /**< Queue blocked for reads */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 wait_queue_head_t read_queue; /**< Processes waiting on block_read */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000481 atomic_t block_write; /**< Queue blocked for writes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 wait_queue_head_t write_queue; /**< Processes waiting on block_write */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000483 atomic_t total_queued; /**< Total queued statistic */
484 atomic_t total_flushed; /**< Total flushes statistic */
485 atomic_t total_locks; /**< Total locks statistics */
Dave Airliec60ce622007-07-11 15:27:12 +1000486 enum drm_ctx_flags flags; /**< Context preserving and 2D-only */
Dave Airliecdd55a22007-07-11 16:32:08 +1000487 struct drm_waitlist waitlist; /**< Pending buffers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 wait_queue_head_t flush_queue; /**< Processes waiting until flush */
Dave Airliecdd55a22007-07-11 16:32:08 +1000489};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
491/**
492 * Lock data.
493 */
Dave Airlie55910512007-07-11 16:53:40 +1000494struct drm_lock_data {
Dave Airliec60ce622007-07-11 15:27:12 +1000495 struct drm_hw_lock *hw_lock; /**< Hardware lock */
Dave Airlie8562b3f2007-11-05 12:37:41 +1000496 /** Private of lock holder's file (NULL=kernel) */
497 struct drm_file *file_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 wait_queue_head_t lock_queue; /**< Queue of blocked processes */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000499 unsigned long lock_time; /**< Time of last lock in jiffies */
Thomas Hellstrom040ac322007-03-23 13:28:33 +1100500 spinlock_t spinlock;
501 uint32_t kernel_waiters;
502 uint32_t user_waiters;
503 int idle_has_lock;
Dave Airlie55910512007-07-11 16:53:40 +1000504};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506/**
507 * DMA data.
508 */
Dave Airliecdd55a22007-07-11 16:32:08 +1000509struct drm_device_dma {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Dave Airliecdd55a22007-07-11 16:32:08 +1000511 struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000512 int buf_count; /**< total number of buffers */
Dave Airlie056219e2007-07-11 16:17:42 +1000513 struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000514 int seg_count;
515 int page_count; /**< number of pages */
516 unsigned long *pagelist; /**< page list */
517 unsigned long byte_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 enum {
519 _DRM_DMA_USE_AGP = 0x01,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000520 _DRM_DMA_USE_SG = 0x02,
George Sapountzis3417f332006-10-24 12:03:04 -0700521 _DRM_DMA_USE_FB = 0x04,
522 _DRM_DMA_USE_PCI_RO = 0x08
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 } flags;
524
Dave Airliecdd55a22007-07-11 16:32:08 +1000525};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000527/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 * AGP memory entry. Stored as a doubly linked list.
529 */
Dave Airlie55910512007-07-11 16:53:40 +1000530struct drm_agp_mem {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000531 unsigned long handle; /**< handle */
Daniel Vetterd2e546b2013-12-11 11:34:40 +0100532 struct agp_memory *memory;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000533 unsigned long bound; /**< address */
534 int pages;
Dave Airliebd1b3312007-05-26 05:01:51 +1000535 struct list_head head;
Dave Airlie55910512007-07-11 16:53:40 +1000536};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
538/**
539 * AGP data.
540 *
541 * \sa drm_agp_init() and drm_device::agp.
542 */
Dave Airlie55910512007-07-11 16:53:40 +1000543struct drm_agp_head {
Daniel Vetterd2e546b2013-12-11 11:34:40 +0100544 struct agp_kern_info agp_info; /**< AGP device information */
Dave Airliebd1b3312007-05-26 05:01:51 +1000545 struct list_head memory;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000546 unsigned long mode; /**< AGP mode */
547 struct agp_bridge_data *bridge;
548 int enabled; /**< whether the AGP bus as been enabled */
549 int acquired; /**< whether the AGP device has been acquired */
550 unsigned long base;
551 int agp_mtrr;
552 int cant_use_aperture;
553 unsigned long page_mask;
Dave Airlie55910512007-07-11 16:53:40 +1000554};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556/**
557 * Scatter-gather memory.
558 */
Dave Airlie55910512007-07-11 16:53:40 +1000559struct drm_sg_mem {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000560 unsigned long handle;
561 void *virtual;
562 int pages;
563 struct page **pagelist;
564 dma_addr_t *busaddr;
Dave Airlie55910512007-07-11 16:53:40 +1000565};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Dave Airlie55910512007-07-11 16:53:40 +1000567struct drm_sigdata {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000568 int context;
Dave Airliec60ce622007-07-11 15:27:12 +1000569 struct drm_hw_lock *lock;
Dave Airlie55910512007-07-11 16:53:40 +1000570};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Dave Airlie8562b3f2007-11-05 12:37:41 +1000572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573/**
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100574 * Kernel side of a mapping
575 */
576struct drm_local_map {
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100577 resource_size_t offset; /**< Requested physical address (0 for SAREA)*/
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100578 unsigned long size; /**< Requested physical size (bytes) */
579 enum drm_map_type type; /**< Type of memory to map */
580 enum drm_map_flags flags; /**< Flags */
581 void *handle; /**< User-space: "Handle" to pass to mmap() */
582 /**< Kernel-space: kernel-virtual address */
583 int mtrr; /**< MTRR slot used */
584};
585
586typedef struct drm_local_map drm_local_map_t;
587
588/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 * Mappings list
590 */
Dave Airlie55910512007-07-11 16:53:40 +1000591struct drm_map_list {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000592 struct list_head head; /**< list head */
Dave Airliee0be4282007-07-12 10:26:44 +1000593 struct drm_hash_item hash;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100594 struct drm_local_map *map; /**< mapping */
Dave Airlie8562b3f2007-11-05 12:37:41 +1000595 uint64_t user_token;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000596 struct drm_master *master;
Dave Airlie55910512007-07-11 16:53:40 +1000597};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599/**
600 * Context handle list
601 */
Dave Airlie55910512007-07-11 16:53:40 +1000602struct drm_ctx_list {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000603 struct list_head head; /**< list head */
604 drm_context_t handle; /**< context handle */
Dave Airlie84b1fd12007-07-11 15:53:27 +1000605 struct drm_file *tag; /**< associated fd private data */
Dave Airlie55910512007-07-11 16:53:40 +1000606};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Dave Airlieea98a922005-09-11 20:28:11 +1000608/* location of GART table */
609#define DRM_ATI_GART_MAIN 1
610#define DRM_ATI_GART_FB 2
611
Dave Airlief2b04cd2007-05-08 15:19:23 +1000612#define DRM_ATI_GART_PCI 1
613#define DRM_ATI_GART_PCIE 2
614#define DRM_ATI_GART_IGP 3
615
Dave Airlie55910512007-07-11 16:53:40 +1000616struct drm_ati_pcigart_info {
Dave Airlieea98a922005-09-11 20:28:11 +1000617 int gart_table_location;
Dave Airlief2b04cd2007-05-08 15:19:23 +1000618 int gart_reg_if;
Dave Airlief26c4732006-01-02 17:18:39 +1100619 void *addr;
Dave Airlieea98a922005-09-11 20:28:11 +1000620 dma_addr_t bus_addr;
Dave Airlieb05c2382008-03-17 10:24:24 +1000621 dma_addr_t table_mask;
622 struct drm_dma_handle *table_handle;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100623 struct drm_local_map mapping;
Dave Airlief2b04cd2007-05-08 15:19:23 +1000624 int table_size;
Dave Airlie55910512007-07-11 16:53:40 +1000625};
Dave Airlieea98a922005-09-11 20:28:11 +1000626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627/**
Eric Anholt673a3942008-07-30 12:06:12 -0700628 * This structure defines the drm_mm memory object, which will be used by the
629 * DRM for its buffer objects.
630 */
631struct drm_gem_object {
632 /** Reference count of this object */
633 struct kref refcount;
634
Daniel Vettera8e11d12013-08-15 00:02:37 +0200635 /**
636 * handle_count - gem file_priv handle count of this object
637 *
638 * Each handle also holds a reference. Note that when the handle_count
639 * drops to 0 any global names (e.g. the id in the flink namespace) will
640 * be cleared.
641 *
642 * Protected by dev->object_name_lock.
643 * */
644 unsigned handle_count;
Eric Anholt673a3942008-07-30 12:06:12 -0700645
646 /** Related drm device */
647 struct drm_device *dev;
648
649 /** File representing the shmem storage */
650 struct file *filp;
651
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800652 /* Mapping info for this object */
David Herrmann0de23972013-07-24 21:07:52 +0200653 struct drm_vma_offset_node vma_node;
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800654
Eric Anholt673a3942008-07-30 12:06:12 -0700655 /**
656 * Size of the object, in bytes. Immutable over the object's
657 * lifetime.
658 */
659 size_t size;
660
661 /**
662 * Global name for this object, starts at 1. 0 means unnamed.
663 * Access is covered by the object_name_lock in the related drm_device
664 */
665 int name;
666
667 /**
668 * Memory domains. These monitor which caches contain read/write data
669 * related to the object. When transitioning from one set of domains
670 * to another, the driver is called to ensure that caches are suitably
671 * flushed and invalidated
672 */
673 uint32_t read_domains;
674 uint32_t write_domain;
675
676 /**
677 * While validating an exec operation, the
678 * new read/write domain values are computed here.
679 * They will be transferred to the above values
680 * at the point that any cache flushing occurs
681 */
682 uint32_t pending_read_domains;
683 uint32_t pending_write_domain;
684
Daniel Vetter319c9332013-08-15 00:02:46 +0200685 /**
686 * dma_buf - dma buf associated with this GEM object
687 *
688 * Pointer to the dma-buf associated with this gem object (either
689 * through importing or exporting). We break the resulting reference
690 * loop when the last gem handle for this object is released.
691 *
692 * Protected by obj->object_name_lock
693 */
694 struct dma_buf *dma_buf;
Dave Airlie32488772011-11-25 15:21:02 +0000695
Daniel Vetter7106bf92013-08-15 00:02:33 +0200696 /**
697 * import_attach - dma buf attachment backing this object
698 *
699 * Any foreign dma_buf imported as a gem object has this set to the
700 * attachment point for the device. This is invariant over the lifetime
701 * of a gem object.
702 *
703 * The driver's ->gem_free_object callback is responsible for cleaning
704 * up the dma_buf attachment and references acquired at import time.
Daniel Vetter838cd442013-08-15 00:02:47 +0200705 *
706 * Note that the drm gem/prime core does not depend upon drivers setting
707 * this field any more. So for drivers where this doesn't make sense
708 * (e.g. virtual devices or a displaylink behind an usb bus) they can
709 * simply leave it as NULL.
Daniel Vetter7106bf92013-08-15 00:02:33 +0200710 */
Dave Airlie32488772011-11-25 15:21:02 +0000711 struct dma_buf_attachment *import_attach;
Eric Anholt673a3942008-07-30 12:06:12 -0700712};
713
David Howellsa1ce3922012-10-02 18:01:25 +0100714#include <drm/drm_crtc.h>
Dave Airlief453ba02008-11-07 14:05:41 -0800715
Dave Airlie7c1c2872008-11-28 14:22:24 +1000716/* per-master structure */
717struct drm_master {
718
719 struct kref refcount; /* refcount for this master */
720
721 struct list_head head; /**< each minor contains a list of masters */
722 struct drm_minor *minor; /**< link back to minor we are a master for */
723
724 char *unique; /**< Unique identifier: e.g., busid */
725 int unique_len; /**< Length of unique field */
Vegard Nossum1147c9c2008-12-02 13:38:47 +1000726 int unique_size; /**< amount allocated */
Dave Airlie7c1c2872008-11-28 14:22:24 +1000727
728 int blocked; /**< Blocked due to VC switch? */
729
730 /** \name Authentication */
731 /*@{ */
732 struct drm_open_hash magiclist;
733 struct list_head magicfree;
734 /*@} */
735
736 struct drm_lock_data lock; /**< Information on hardware lock */
737
738 void *driver_priv; /**< Private structure for driver to use */
739};
740
Mario Kleiner27641c32010-10-23 04:20:23 +0200741/* Size of ringbuffer for vblank timestamps. Just double-buffer
742 * in initial implementation.
743 */
744#define DRM_VBLANKTIME_RBSIZE 2
745
746/* Flags and return codes for get_vblank_timestamp() driver function. */
747#define DRM_CALLED_FROM_VBLIRQ 1
748#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
749#define DRM_VBLANKTIME_INVBL (1 << 1)
750
751/* get_scanout_position() return flags */
752#define DRM_SCANOUTPOS_VALID (1 << 0)
753#define DRM_SCANOUTPOS_INVBL (1 << 1)
754#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
755
Dave Airlie8410ea32010-12-15 03:16:38 +1000756struct drm_bus {
757 int bus_type;
758 int (*get_irq)(struct drm_device *dev);
759 const char *(*get_name)(struct drm_device *dev);
760 int (*set_busid)(struct drm_device *dev, struct drm_master *master);
761 int (*set_unique)(struct drm_device *dev, struct drm_master *master,
762 struct drm_unique *unique);
763 int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p);
Dave Airlie8410ea32010-12-15 03:16:38 +1000764};
765
Eric Anholt673a3942008-07-30 12:06:12 -0700766/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 * DRM driver structure. This structure represent the common code for
768 * a family of cards. There will one drm_device for each card present
769 * in this family
770 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771struct drm_driver {
Dave Airlie22eae942005-11-10 22:16:34 +1100772 int (*load) (struct drm_device *, unsigned long flags);
773 int (*firstopen) (struct drm_device *);
Dave Airlie84b1fd12007-07-11 15:53:27 +1000774 int (*open) (struct drm_device *, struct drm_file *);
Eric Anholt6c340ea2007-08-25 20:23:09 +1000775 void (*preclose) (struct drm_device *, struct drm_file *file_priv);
Dave Airlie84b1fd12007-07-11 15:53:27 +1000776 void (*postclose) (struct drm_device *, struct drm_file *);
Dave Airlie22eae942005-11-10 22:16:34 +1100777 void (*lastclose) (struct drm_device *);
778 int (*unload) (struct drm_device *);
Dave Airlieb932ccb2008-02-20 10:02:20 +1000779 int (*suspend) (struct drm_device *, pm_message_t state);
Jesse Barnese8b962b2007-11-22 14:02:38 +1000780 int (*resume) (struct drm_device *);
Eric Anholtc153f452007-09-03 12:06:45 +1000781 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000782 int (*dma_quiescent) (struct drm_device *);
Dave Airlie84b1fd12007-07-11 15:53:27 +1000783 int (*context_dtor) (struct drm_device *dev, int context);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000784
Dave Airliecda17382005-07-10 17:31:26 +1000785 /**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700786 * get_vblank_counter - get raw hardware vblank counter
787 * @dev: DRM device
788 * @crtc: counter to fetch
789 *
Laurent Pinchart3b02ab82012-05-17 13:27:20 +0200790 * Driver callback for fetching a raw hardware vblank counter for @crtc.
791 * If a device doesn't have a hardware counter, the driver can simply
792 * return the value of drm_vblank_count. The DRM core will account for
793 * missed vblank events while interrupts where disabled based on system
794 * timestamps.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700795 *
796 * Wraparound handling and loss of events due to modesetting is dealt
797 * with in the DRM core code.
798 *
799 * RETURNS
800 * Raw vblank counter value.
801 */
802 u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
803
804 /**
805 * enable_vblank - enable vblank interrupt events
806 * @dev: DRM device
807 * @crtc: which irq to enable
808 *
809 * Enable vblank interrupts for @crtc. If the device doesn't have
810 * a hardware vblank counter, this routine should be a no-op, since
811 * interrupts will have to stay on to keep the count accurate.
812 *
813 * RETURNS
814 * Zero on success, appropriate errno if the given @crtc's vblank
815 * interrupt cannot be enabled.
816 */
817 int (*enable_vblank) (struct drm_device *dev, int crtc);
818
819 /**
820 * disable_vblank - disable vblank interrupt events
821 * @dev: DRM device
822 * @crtc: which irq to enable
823 *
824 * Disable vblank interrupts for @crtc. If the device doesn't have
825 * a hardware vblank counter, this routine should be a no-op, since
826 * interrupts will have to stay on to keep the count accurate.
827 */
828 void (*disable_vblank) (struct drm_device *dev, int crtc);
829
830 /**
Dave Airliecda17382005-07-10 17:31:26 +1000831 * Called by \c drm_device_is_agp. Typically used to determine if a
832 * card is really attached to AGP or not.
833 *
834 * \param dev DRM device handle
835 *
836 * \returns
837 * One of three values is returned depending on whether or not the
838 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
839 * (return of 1), or may or may not be AGP (return of 2).
840 */
Dave Airlie84b1fd12007-07-11 15:53:27 +1000841 int (*device_is_agp) (struct drm_device *dev);
Dave Airliecda17382005-07-10 17:31:26 +1000842
Mario Kleiner27641c32010-10-23 04:20:23 +0200843 /**
844 * Called by vblank timestamping code.
845 *
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100846 * Return the current display scanout position from a crtc, and an
847 * optional accurate ktime_get timestamp of when position was measured.
Mario Kleiner27641c32010-10-23 04:20:23 +0200848 *
849 * \param dev DRM device.
850 * \param crtc Id of the crtc to query.
Ville Syrjäläabca9e42013-10-28 20:50:48 +0200851 * \param flags Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
Mario Kleiner27641c32010-10-23 04:20:23 +0200852 * \param *vpos Target location for current vertical scanout position.
853 * \param *hpos Target location for current horizontal scanout position.
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100854 * \param *stime Target location for timestamp taken immediately before
855 * scanout position query. Can be NULL to skip timestamp.
856 * \param *etime Target location for timestamp taken immediately after
857 * scanout position query. Can be NULL to skip timestamp.
Mario Kleiner27641c32010-10-23 04:20:23 +0200858 *
859 * Returns vpos as a positive number while in active scanout area.
860 * Returns vpos as a negative number inside vblank, counting the number
861 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
862 * until start of active scanout / end of vblank."
863 *
864 * \return Flags, or'ed together as follows:
865 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300866 * DRM_SCANOUTPOS_VALID = Query successful.
Mario Kleiner27641c32010-10-23 04:20:23 +0200867 * DRM_SCANOUTPOS_INVBL = Inside vblank.
868 * DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of
869 * this flag means that returned position may be offset by a constant
870 * but unknown small number of scanlines wrt. real scanout position.
871 *
872 */
873 int (*get_scanout_position) (struct drm_device *dev, int crtc,
Ville Syrjäläabca9e42013-10-28 20:50:48 +0200874 unsigned int flags,
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100875 int *vpos, int *hpos, ktime_t *stime,
876 ktime_t *etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200877
878 /**
879 * Called by \c drm_get_last_vbltimestamp. Should return a precise
880 * timestamp when the most recent VBLANK interval ended or will end.
881 *
882 * Specifically, the timestamp in @vblank_time should correspond as
883 * closely as possible to the time when the first video scanline of
884 * the video frame after the end of VBLANK will start scanning out,
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800885 * the time immediately after end of the VBLANK interval. If the
Mario Kleiner27641c32010-10-23 04:20:23 +0200886 * @crtc is currently inside VBLANK, this will be a time in the future.
887 * If the @crtc is currently scanning out a frame, this will be the
888 * past start time of the current scanout. This is meant to adhere
889 * to the OpenML OML_sync_control extension specification.
890 *
891 * \param dev dev DRM device handle.
892 * \param crtc crtc for which timestamp should be returned.
893 * \param *max_error Maximum allowable timestamp error in nanoseconds.
894 * Implementation should strive to provide timestamp
895 * with an error of at most *max_error nanoseconds.
896 * Returns true upper bound on error for timestamp.
897 * \param *vblank_time Target location for returned vblank timestamp.
898 * \param flags 0 = Defaults, no special treatment needed.
899 * \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
900 * irq handler. Some drivers need to apply some workarounds
901 * for gpu-specific vblank irq quirks if flag is set.
902 *
903 * \returns
904 * Zero if timestamping isn't supported in current display mode or a
905 * negative number on failure. A positive status code on success,
906 * which describes how the vblank_time timestamp was computed.
907 */
908 int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
909 int *max_error,
910 struct timeval *vblank_time,
911 unsigned flags);
912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 /* these have to be filled in */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000914
Daniel Vettere9f0d762013-12-11 11:34:42 +0100915 irqreturn_t(*irq_handler) (int irq, void *arg);
Dave Airlie84b1fd12007-07-11 15:53:27 +1000916 void (*irq_preinstall) (struct drm_device *dev);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700917 int (*irq_postinstall) (struct drm_device *dev);
Dave Airlie84b1fd12007-07-11 15:53:27 +1000918 void (*irq_uninstall) (struct drm_device *dev);
Dave Airlie22eae942005-11-10 22:16:34 +1100919
Dave Airlie7c1c2872008-11-28 14:22:24 +1000920 /* Master routines */
921 int (*master_create)(struct drm_device *dev, struct drm_master *master);
922 void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
Thomas Hellstrom862302f2009-12-02 18:15:25 +0000923 /**
924 * master_set is called whenever the minor master is set.
925 * master_drop is called whenever the minor master is dropped.
926 */
927
928 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
929 bool from_open);
930 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
931 bool from_release);
Dave Airlie7c1c2872008-11-28 14:22:24 +1000932
Ben Gamari955b12d2009-02-17 20:08:49 -0500933 int (*debugfs_init)(struct drm_minor *minor);
934 void (*debugfs_cleanup)(struct drm_minor *minor);
Eric Anholt673a3942008-07-30 12:06:12 -0700935
936 /**
937 * Driver-specific constructor for drm_gem_objects, to set up
938 * obj->driver_private.
939 *
940 * Returns 0 on success.
941 */
Eric Anholt673a3942008-07-30 12:06:12 -0700942 void (*gem_free_object) (struct drm_gem_object *obj);
Ben Skeggs304eda32011-06-09 00:24:59 +0000943 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
944 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
Eric Anholt673a3942008-07-30 12:06:12 -0700945
Dave Airlie32488772011-11-25 15:21:02 +0000946 /* prime: */
947 /* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
948 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
949 uint32_t handle, uint32_t flags, int *prime_fd);
950 /* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
951 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
952 int prime_fd, uint32_t *handle);
953 /* export GEM -> dmabuf */
954 struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
955 struct drm_gem_object *obj, int flags);
956 /* import dmabuf -> GEM */
957 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
958 struct dma_buf *dma_buf);
Aaron Plattner89177642013-01-15 20:47:42 +0000959 /* low-level interface used by drm_gem_prime_{import,export} */
960 int (*gem_prime_pin)(struct drm_gem_object *obj);
Maarten Lankhorst102d6db2013-04-09 09:18:44 +0200961 void (*gem_prime_unpin)(struct drm_gem_object *obj);
Aaron Plattner89177642013-01-15 20:47:42 +0000962 struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
963 struct drm_gem_object *(*gem_prime_import_sg_table)(
964 struct drm_device *dev, size_t size,
965 struct sg_table *sgt);
966 void *(*gem_prime_vmap)(struct drm_gem_object *obj);
967 void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
Joonyoung Shim7c397cd2013-06-28 14:24:53 +0900968 int (*gem_prime_mmap)(struct drm_gem_object *obj,
969 struct vm_area_struct *vma);
Dave Airlie32488772011-11-25 15:21:02 +0000970
Dave Airlie28d52042009-09-21 14:33:58 +1000971 /* vga arb irq handler */
972 void (*vgaarb_irq)(struct drm_device *dev, bool state);
973
Dave Airlieff72145b2011-02-07 12:16:14 +1000974 /* dumb alloc support */
975 int (*dumb_create)(struct drm_file *file_priv,
976 struct drm_device *dev,
977 struct drm_mode_create_dumb *args);
978 int (*dumb_map_offset)(struct drm_file *file_priv,
979 struct drm_device *dev, uint32_t handle,
980 uint64_t *offset);
981 int (*dumb_destroy)(struct drm_file *file_priv,
982 struct drm_device *dev,
983 uint32_t handle);
984
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800985 /* Driver private ops for this object */
Laurent Pinchart78b68552012-05-17 13:27:22 +0200986 const struct vm_operations_struct *gem_vm_ops;
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800987
Dave Airlie22eae942005-11-10 22:16:34 +1100988 int major;
989 int minor;
990 int patchlevel;
991 char *name;
992 char *desc;
993 char *date;
994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 u32 driver_features;
996 int dev_priv_size;
Rob Clarkbaa70942013-08-02 13:27:49 -0400997 const struct drm_ioctl_desc *ioctls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 int num_ioctls;
Arjan van de Vene08e96d2011-10-31 07:28:57 -0700999 const struct file_operations *fops;
Dave Airlie8410ea32010-12-15 03:16:38 +10001000 union {
1001 struct pci_driver *pci;
1002 struct platform_device *platform_device;
Dave Airliea250b9f2010-12-15 07:13:55 +10001003 struct usb_driver *usb;
Dave Airlie8410ea32010-12-15 03:16:38 +10001004 } kdriver;
1005 struct drm_bus *bus;
1006
Daniel Vetterb3f23332013-12-11 11:34:31 +01001007 /* List of devices hanging off this driver with stealth attach. */
1008 struct list_head legacy_dev_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009};
1010
Dave Airlie2c14f282008-04-21 16:47:32 +10001011#define DRM_MINOR_UNASSIGNED 0
1012#define DRM_MINOR_LEGACY 1
Dave Airlief453ba02008-11-07 14:05:41 -08001013#define DRM_MINOR_CONTROL 2
1014#define DRM_MINOR_RENDER 3
Dave Airlie2c14f282008-04-21 16:47:32 +10001015
Ben Gamari955b12d2009-02-17 20:08:49 -05001016/**
1017 * Info file list entry. This structure represents a debugfs or proc file to
1018 * be created by the drm core
1019 */
1020struct drm_info_list {
1021 const char *name; /** file name */
1022 int (*show)(struct seq_file*, void*); /** show callback */
1023 u32 driver_features; /**< Required driver features for this entry */
1024 void *data;
1025};
1026
1027/**
1028 * debugfs node structure. This structure represents a debugfs file.
1029 */
1030struct drm_info_node {
1031 struct list_head list;
1032 struct drm_minor *minor;
David Howellsce089b52013-04-12 15:23:25 +01001033 const struct drm_info_list *info_ent;
Ben Gamari955b12d2009-02-17 20:08:49 -05001034 struct dentry *dent;
1035};
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037/**
Dave Airlie2c14f282008-04-21 16:47:32 +10001038 * DRM minor structure. This structure represents a drm minor number.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 */
Dave Airlie2c14f282008-04-21 16:47:32 +10001040struct drm_minor {
1041 int index; /**< Minor device number */
1042 int type; /**< Control or render */
1043 dev_t device; /**< Device number for mknod */
Dave Airlie5bdebb12013-10-11 14:07:25 +10001044 struct device *kdev; /**< Linux device */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 struct drm_device *dev;
Ben Gamari955b12d2009-02-17 20:08:49 -05001046
Ben Gamari955b12d2009-02-17 20:08:49 -05001047 struct dentry *debugfs_root;
Marcin Slusarzb3e067c2011-11-09 22:20:35 +01001048
1049 struct list_head debugfs_list;
1050 struct mutex debugfs_lock; /* Protects debugfs_list. */
Ben Gamari955b12d2009-02-17 20:08:49 -05001051
Dave Airlie7c1c2872008-11-28 14:22:24 +10001052 struct drm_master *master; /* currently active master for this node */
1053 struct list_head master_list;
Dave Airlief453ba02008-11-07 14:05:41 -08001054 struct drm_mode_group mode_group;
Dave Airlie84b1fd12007-07-11 15:53:27 +10001055};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
Chris Wilson1794d252011-04-17 07:43:32 +01001057/* mode specified on the command line */
1058struct drm_cmdline_mode {
1059 bool specified;
1060 bool refresh_specified;
1061 bool bpp_specified;
1062 int xres, yres;
1063 int bpp;
1064 int refresh;
1065 bool rb;
1066 bool interlace;
1067 bool cvt;
1068 bool margins;
1069 enum drm_connector_force force;
1070};
1071
1072
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001073struct drm_pending_vblank_event {
1074 struct drm_pending_event base;
1075 int pipe;
1076 struct drm_event_vblank event;
1077};
1078
Ville Syrjälä5380e922013-10-04 14:53:36 +03001079struct drm_vblank_crtc {
1080 wait_queue_head_t queue; /**< VBLANK wait queue */
1081 struct timeval time[DRM_VBLANKTIME_RBSIZE]; /**< timestamp of current count */
1082 atomic_t count; /**< number of VBLANK interrupts */
1083 atomic_t refcount; /* number of users of vblank interruptsper crtc */
1084 u32 last; /* protected by dev->vbl_lock, used */
1085 /* for wraparound handling */
1086 u32 last_wait; /* Last vblank seqno waited per CRTC */
1087 unsigned int inmodeset; /* Display driver is setting mode */
1088 bool enabled; /* so we don't call enable more than
1089 once per disable */
1090};
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092/**
1093 * DRM device structure. This structure represent a complete card that
1094 * may contain multiple heads.
1095 */
Dave Airlie84b1fd12007-07-11 15:53:27 +10001096struct drm_device {
Daniel Vetterb3f23332013-12-11 11:34:31 +01001097 struct list_head legacy_dev_list;/**< list of devices per driver for stealth attach cleanup */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001098 char *devname; /**< For /proc/interrupts */
1099 int if_version; /**< Highest interface version set */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 /** \name Locks */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001102 /*@{ */
1103 spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */
Dave Airlie30e2fb12006-02-02 19:37:46 +11001104 struct mutex struct_mutex; /**< For others */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001105 /*@} */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107 /** \name Usage Counters */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001108 /*@{ */
1109 int open_count; /**< Outstanding files open */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001110 int buf_use; /**< Buffers in use -- cannot alloc */
1111 atomic_t buf_alloc; /**< Buffer allocation in progress */
1112 /*@} */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Dave Airliebd1b3312007-05-26 05:01:51 +10001114 struct list_head filelist;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 /** \name Memory management */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001117 /*@{ */
Dave Airliebd1b3312007-05-26 05:01:51 +10001118 struct list_head maplist; /**< Linked list of regions */
Dave Airliee0be4282007-07-12 10:26:44 +10001119 struct drm_open_hash map_hash; /**< User token hash table for maps */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 /** \name Context handle management */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001122 /*@{ */
Dave Airliebd1b3312007-05-26 05:01:51 +10001123 struct list_head ctxlist; /**< Linked list of context handles */
Dave Airlie30e2fb12006-02-02 19:37:46 +11001124 struct mutex ctxlist_mutex; /**< For ctxlist */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
Dave Airlie62968142007-07-17 10:46:52 +10001126 struct idr ctx_idr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
Dave Airliebd1b3312007-05-26 05:01:51 +10001128 struct list_head vmalist; /**< List of vmas (for debugging) */
Dave Airlief453ba02008-11-07 14:05:41 -08001129
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001130 /*@} */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Daniel Vettera344a7e2011-10-26 00:54:41 +02001132 /** \name DMA support */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001133 /*@{ */
Dave Airliecdd55a22007-07-11 16:32:08 +10001134 struct drm_device_dma *dma; /**< Optional pointer for DMA support */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001135 /*@} */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 /** \name Context support */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001138 /*@{ */
Ville Syrjälä44238432013-10-04 14:53:37 +03001139 bool irq_enabled; /**< True if irq handler is enabled */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 __volatile__ long context_flag; /**< Context swapping flag */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001141 int last_context; /**< Last current context */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001142 /*@} */
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 /** \name VBLANK IRQ support */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001145 /*@{ */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001147 /*
1148 * At load time, disabling the vblank interrupt won't be allowed since
1149 * old clients may not call the modeset ioctl and therefore misbehave.
1150 * Once the modeset ioctl *has* been called though, we can safely
1151 * disable them when unused.
1152 */
Ville Syrjäläba0bf122013-10-04 14:53:33 +03001153 bool vblank_disable_allowed;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001154
Ville Syrjälä5380e922013-10-04 14:53:36 +03001155 /* array of size num_crtcs */
1156 struct drm_vblank_crtc *vblank;
1157
Mario Kleiner27641c32010-10-23 04:20:23 +02001158 spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001159 spinlock_t vbl_lock;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001160 struct timer_list vblank_disable_timer;
1161
1162 u32 max_vblank_count; /**< size of vblank counter register */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001164 /**
1165 * List of events
1166 */
1167 struct list_head vblank_event_list;
1168 spinlock_t event_lock;
1169
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001170 /*@} */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
Dave Airlie55910512007-07-11 16:53:40 +10001172 struct drm_agp_head *agp; /**< AGP data */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Jordan Crousedcdb1672010-05-27 13:40:25 -06001174 struct device *dev; /**< Device structure */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001175 struct pci_dev *pdev; /**< PCI device structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176#ifdef __alpha__
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 struct pci_controller *hose;
1178#endif
Jordan Crousedcdb1672010-05-27 13:40:25 -06001179
1180 struct platform_device *platformdev; /**< Platform device struture */
Dave Airliea250b9f2010-12-15 07:13:55 +10001181 struct usb_device *usbdev;
Jordan Crousedcdb1672010-05-27 13:40:25 -06001182
Dave Airlie55910512007-07-11 16:53:40 +10001183 struct drm_sg_mem *sg; /**< Scatter gather memory */
Dave Airlie19227562011-02-24 08:35:06 +10001184 unsigned int num_crtcs; /**< Number of CRTCs on this device */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001185 void *dev_private; /**< device private data */
Jesse Barnesa2c0a972008-11-05 10:31:53 -08001186 struct address_space *dev_mapping;
Dave Airlie55910512007-07-11 16:53:40 +10001187 struct drm_sigdata sigdata; /**< For block_all_signals */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001188 sigset_t sigmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001190 struct drm_driver *driver;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001191 struct drm_local_map *agp_buffer_map;
Dave Airlied1f2b552005-08-05 22:11:22 +10001192 unsigned int agp_buffer_token;
Dave Airlief453ba02008-11-07 14:05:41 -08001193 struct drm_minor *control; /**< Control node for card */
Dave Airlie2c14f282008-04-21 16:47:32 +10001194 struct drm_minor *primary; /**< render type primary screen head */
David Herrmann17931262013-08-25 18:29:00 +02001195 struct drm_minor *render; /**< render node for card */
=?utf-8?q?Michel_D=C3=A4nzer?=bea56792006-10-24 23:04:19 +10001196
Dave Airlief453ba02008-11-07 14:05:41 -08001197 struct drm_mode_config mode_config; /**< Current mode config */
1198
Eric Anholt673a3942008-07-30 12:06:12 -07001199 /** \name GEM information */
1200 /*@{ */
Daniel Vettercd4f0132013-08-15 00:02:44 +02001201 struct mutex object_name_lock;
Eric Anholt673a3942008-07-30 12:06:12 -07001202 struct idr object_name_idr;
Daniel Vetterb04a5902013-12-11 14:24:46 +01001203 struct drm_vma_offset_manager *vma_offset_manager;
Eric Anholt673a3942008-07-30 12:06:12 -07001204 /*@} */
Dave Airlie5bcf7192010-12-07 09:20:40 +10001205 int switch_power_state;
Dave Airlie2c07a212012-02-20 14:18:07 +00001206
1207 atomic_t unplugged; /* device has been unplugged or gone away */
Dave Airlie84b1fd12007-07-11 15:53:27 +10001208};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Dave Airlie5bcf7192010-12-07 09:20:40 +10001210#define DRM_SWITCH_POWER_ON 0
1211#define DRM_SWITCH_POWER_OFF 1
1212#define DRM_SWITCH_POWER_CHANGING 2
Dave Airlie13bb9cc2012-09-12 15:55:05 +10001213#define DRM_SWITCH_POWER_DYNAMIC_OFF 3
Dave Airlie5bcf7192010-12-07 09:20:40 +10001214
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001215static __inline__ int drm_core_check_feature(struct drm_device *dev,
1216 int feature)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217{
1218 return ((dev->driver->driver_features & feature) ? 1 : 0);
1219}
1220
Jordan Crousedcdb1672010-05-27 13:40:25 -06001221static inline int drm_dev_to_irq(struct drm_device *dev)
1222{
Dave Airlie8410ea32010-12-15 03:16:38 +10001223 return dev->driver->bus->get_irq(dev);
Jordan Crousedcdb1672010-05-27 13:40:25 -06001224}
1225
Dave Airlie2c07a212012-02-20 14:18:07 +00001226static inline void drm_device_set_unplugged(struct drm_device *dev)
1227{
1228 smp_wmb();
1229 atomic_set(&dev->unplugged, 1);
1230}
1231
1232static inline int drm_device_is_unplugged(struct drm_device *dev)
1233{
1234 int ret = atomic_read(&dev->unplugged);
1235 smp_rmb();
1236 return ret;
1237}
1238
Daniel Vetter8faf6b12012-12-01 23:43:11 +01001239static inline bool drm_modeset_is_locked(struct drm_device *dev)
1240{
1241 return mutex_is_locked(&dev->mode_config.mutex);
1242}
1243
David Herrmann17931262013-08-25 18:29:00 +02001244static inline bool drm_is_render_client(struct drm_file *file_priv)
1245{
1246 return file_priv->minor->type == DRM_MINOR_RENDER;
1247}
1248
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249/******************************************************************/
1250/** \name Internal function definitions */
1251/*@{*/
1252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 /* Driver support (drm_drv.h) */
Arnd Bergmanned8b6702009-12-16 22:17:09 +00001254extern long drm_ioctl(struct file *filp,
1255 unsigned int cmd, unsigned long arg);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001256extern long drm_compat_ioctl(struct file *filp,
1257 unsigned int cmd, unsigned long arg);
Dave Airlie84b1fd12007-07-11 15:53:27 +10001258extern int drm_lastclose(struct drm_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
1260 /* Device support (drm_fops.h) */
Arnd Bergmann58374712010-07-10 23:51:39 +02001261extern struct mutex drm_global_mutex;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001262extern int drm_open(struct inode *inode, struct file *filp);
1263extern int drm_stub_open(struct inode *inode, struct file *filp);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001264extern ssize_t drm_read(struct file *filp, char __user *buffer,
1265 size_t count, loff_t *offset);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001266extern int drm_release(struct inode *inode, struct file *filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
1268 /* Mapping support (drm_vm.h) */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001269extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
Jesse Barnesa2c0a972008-11-05 10:31:53 -08001270extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
Rob Clarkb06d66b2012-05-01 11:04:51 -05001271extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma);
1272extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001273extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 /* Memory management support (drm_memory.h) */
David Howellsa1ce3922012-10-02 18:01:25 +01001276#include <drm/drm_memory.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Daniel Vetterd2e546b2013-12-11 11:34:40 +01001278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 /* Misc. IOCTL support (drm_ioctl.h) */
Eric Anholtc153f452007-09-03 12:06:45 +10001280extern int drm_irq_by_busid(struct drm_device *dev, void *data,
1281 struct drm_file *file_priv);
1282extern int drm_getunique(struct drm_device *dev, void *data,
1283 struct drm_file *file_priv);
1284extern int drm_setunique(struct drm_device *dev, void *data,
1285 struct drm_file *file_priv);
1286extern int drm_getmap(struct drm_device *dev, void *data,
1287 struct drm_file *file_priv);
1288extern int drm_getclient(struct drm_device *dev, void *data,
1289 struct drm_file *file_priv);
1290extern int drm_getstats(struct drm_device *dev, void *data,
1291 struct drm_file *file_priv);
Ben Skeggs9f354212011-02-21 11:17:35 +10001292extern int drm_getcap(struct drm_device *dev, void *data,
1293 struct drm_file *file_priv);
Damien Lespiau1c0814f2013-09-25 16:45:20 +01001294extern int drm_setclientcap(struct drm_device *dev, void *data,
1295 struct drm_file *file_priv);
Eric Anholtc153f452007-09-03 12:06:45 +10001296extern int drm_setversion(struct drm_device *dev, void *data,
1297 struct drm_file *file_priv);
1298extern int drm_noop(struct drm_device *dev, void *data,
1299 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301 /* Context IOCTL support (drm_context.h) */
Eric Anholtc153f452007-09-03 12:06:45 +10001302extern int drm_resctx(struct drm_device *dev, void *data,
1303 struct drm_file *file_priv);
1304extern int drm_addctx(struct drm_device *dev, void *data,
1305 struct drm_file *file_priv);
Eric Anholtc153f452007-09-03 12:06:45 +10001306extern int drm_getctx(struct drm_device *dev, void *data,
1307 struct drm_file *file_priv);
1308extern int drm_switchctx(struct drm_device *dev, void *data,
1309 struct drm_file *file_priv);
1310extern int drm_newctx(struct drm_device *dev, void *data,
1311 struct drm_file *file_priv);
1312extern int drm_rmctx(struct drm_device *dev, void *data,
1313 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
Dave Airliec21eb212013-09-20 08:32:59 +10001315extern int drm_ctxbitmap_init(struct drm_device *dev);
1316extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
1317extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Eric Anholtc153f452007-09-03 12:06:45 +10001319extern int drm_setsareactx(struct drm_device *dev, void *data,
1320 struct drm_file *file_priv);
1321extern int drm_getsareactx(struct drm_device *dev, void *data,
1322 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 /* Authentication IOCTL support (drm_auth.h) */
Eric Anholtc153f452007-09-03 12:06:45 +10001325extern int drm_getmagic(struct drm_device *dev, void *data,
1326 struct drm_file *file_priv);
1327extern int drm_authmagic(struct drm_device *dev, void *data,
1328 struct drm_file *file_priv);
Thomas Hellstrom598781d2012-01-24 18:54:21 +01001329extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Eric Anholt673a3942008-07-30 12:06:12 -07001331/* Cache management (drm_cache.c) */
1332void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
Chris Wilson9da3da62012-06-01 15:20:22 +01001333void drm_clflush_sg(struct sg_table *st);
Daniel Vetter6d5cd9c2012-03-25 19:47:30 +02001334void drm_clflush_virt_range(char *addr, unsigned long length);
Eric Anholt673a3942008-07-30 12:06:12 -07001335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 /* Locking IOCTL support (drm_lock.h) */
Eric Anholtc153f452007-09-03 12:06:45 +10001337extern int drm_lock(struct drm_device *dev, void *data,
1338 struct drm_file *file_priv);
1339extern int drm_unlock(struct drm_device *dev, void *data,
1340 struct drm_file *file_priv);
Dave Airlie55910512007-07-11 16:53:40 +10001341extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
1342extern void drm_idlelock_take(struct drm_lock_data *lock_data);
1343extern void drm_idlelock_release(struct drm_lock_data *lock_data);
Thomas Hellstrom040ac322007-03-23 13:28:33 +11001344
1345/*
1346 * These are exported to drivers so that they can implement fencing using
1347 * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
1348 */
1349
Eric Anholtc153f452007-09-03 12:06:45 +10001350extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352 /* Buffer management support (drm_bufs.h) */
Dave Airlie84b1fd12007-07-11 15:53:27 +10001353extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
1354extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +11001355extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
Dave Airliec60ce622007-07-11 15:27:12 +10001356 unsigned int size, enum drm_map_type type,
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001357 enum drm_map_flags flags, struct drm_local_map **map_ptr);
Eric Anholtc153f452007-09-03 12:06:45 +10001358extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
1359 struct drm_file *file_priv);
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001360extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
1361extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
Eric Anholtc153f452007-09-03 12:06:45 +10001362extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
1363 struct drm_file *file_priv);
1364extern int drm_addbufs(struct drm_device *dev, void *data,
1365 struct drm_file *file_priv);
1366extern int drm_infobufs(struct drm_device *dev, void *data,
1367 struct drm_file *file_priv);
1368extern int drm_markbufs(struct drm_device *dev, void *data,
1369 struct drm_file *file_priv);
1370extern int drm_freebufs(struct drm_device *dev, void *data,
1371 struct drm_file *file_priv);
1372extern int drm_mapbufs(struct drm_device *dev, void *data,
1373 struct drm_file *file_priv);
Daniel Vetter6eb92782013-08-08 15:41:29 +02001374extern int drm_dma_ioctl(struct drm_device *dev, void *data,
1375 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 /* DMA support (drm_dma.h) */
Daniel Vettere2e99a82013-08-08 15:41:19 +02001378extern int drm_legacy_dma_setup(struct drm_device *dev);
1379extern void drm_legacy_dma_takedown(struct drm_device *dev);
Dave Airlie056219e2007-07-11 16:17:42 +10001380extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
Eric Anholt6c340ea2007-08-25 20:23:09 +10001381extern void drm_core_reclaim_buffers(struct drm_device *dev,
1382 struct drm_file *filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
1384 /* IRQ support (drm_irq.h) */
Eric Anholtc153f452007-09-03 12:06:45 +10001385extern int drm_control(struct drm_device *dev, void *data,
1386 struct drm_file *file_priv);
Kristian Høgsbergdbb19d32008-08-20 11:04:27 -04001387extern int drm_irq_install(struct drm_device *dev);
Dave Airlie84b1fd12007-07-11 15:53:27 +10001388extern int drm_irq_uninstall(struct drm_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001390extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
Dave Airlieaf6061a2008-05-07 12:15:39 +10001391extern int drm_wait_vblank(struct drm_device *dev, void *data,
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001392 struct drm_file *filp);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001393extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +02001394extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
1395 struct timeval *vblanktime);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001396extern void drm_send_vblank_event(struct drm_device *dev, int crtc,
1397 struct drm_pending_vblank_event *e);
Chris Wilson78c6e172011-01-31 10:48:04 +00001398extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001399extern int drm_vblank_get(struct drm_device *dev, int crtc);
1400extern void drm_vblank_put(struct drm_device *dev, int crtc);
Li Peng778c9022009-11-09 12:51:22 +08001401extern void drm_vblank_off(struct drm_device *dev, int crtc);
Keith Packard52440212008-11-18 09:30:25 -08001402extern void drm_vblank_cleanup(struct drm_device *dev);
Mario Kleiner27641c32010-10-23 04:20:23 +02001403extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
1404 struct timeval *tvblank, unsigned flags);
1405extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
1406 int crtc, int *max_error,
1407 struct timeval *vblank_time,
1408 unsigned flags,
Ville Syrjälä7da903e2013-10-26 17:57:31 +03001409 const struct drm_crtc *refcrtc,
1410 const struct drm_display_mode *mode);
Ville Syrjälä545cdd52013-10-26 17:16:30 +03001411extern void drm_calc_timestamping_constants(struct drm_crtc *crtc,
1412 const struct drm_display_mode *mode);
Mario Kleiner27641c32010-10-23 04:20:23 +02001413
Chris Wilson1794d252011-04-17 07:43:32 +01001414extern bool
1415drm_mode_parse_command_line_for_connector(const char *mode_option,
1416 struct drm_connector *connector,
1417 struct drm_cmdline_mode *mode);
1418
1419extern struct drm_display_mode *
1420drm_mode_create_from_cmdline_mode(struct drm_device *dev,
1421 struct drm_cmdline_mode *cmd);
1422
Steffen Trumtrarebc64e42012-11-14 11:22:52 +01001423extern int drm_display_mode_from_videomode(const struct videomode *vm,
1424 struct drm_display_mode *dmode);
Steffen Trumtraredb37a92012-10-28 18:28:06 +01001425extern int of_get_drm_display_mode(struct device_node *np,
1426 struct drm_display_mode *dmode,
1427 int index);
Steffen Trumtrarebc64e42012-11-14 11:22:52 +01001428
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001429/* Modesetting support */
Dave Airlief453ba02008-11-07 14:05:41 -08001430extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
1431extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001432extern int drm_modeset_ctl(struct drm_device *dev, void *data,
1433 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
1435 /* AGP/GART support (drm_agpsupport.h) */
David Herrmann00fd78e2013-08-08 22:19:12 +02001436
1437#include <drm/drm_agpsupport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 /* Stub support (drm_stub.h) */
Dave Airlie7c1c2872008-11-28 14:22:24 +10001440extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
1441 struct drm_file *file_priv);
1442extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
1443 struct drm_file *file_priv);
1444struct drm_master *drm_master_create(struct drm_minor *minor);
1445extern struct drm_master *drm_master_get(struct drm_master *master);
1446extern void drm_master_put(struct drm_master **master);
Dave Airlie8410ea32010-12-15 03:16:38 +10001447
Kristian Høgsberg112b7152009-01-04 16:55:33 -05001448extern void drm_put_dev(struct drm_device *dev);
Dave Airlie2c07a212012-02-20 14:18:07 +00001449extern void drm_unplug_dev(struct drm_device *dev);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001450extern unsigned int drm_debug;
David Herrmann17931262013-08-25 18:29:00 +02001451extern unsigned int drm_rnodes;
Dave Airlie2c14f282008-04-21 16:47:32 +10001452
Mario Kleiner27641c32010-10-23 04:20:23 +02001453extern unsigned int drm_vblank_offdelay;
1454extern unsigned int drm_timestamp_precision;
Imre Deakc61eef72012-10-23 18:53:26 +00001455extern unsigned int drm_timestamp_monotonic;
Mario Kleiner27641c32010-10-23 04:20:23 +02001456
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -08001457extern struct class *drm_class;
Ben Gamari955b12d2009-02-17 20:08:49 -05001458extern struct dentry *drm_debugfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
Dave Airlie2c14f282008-04-21 16:47:32 +10001460extern struct idr drm_minors_idr;
1461
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001462extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
Dave Airlieda509d72007-05-26 05:04:51 +10001463
Ben Gamari955b12d2009-02-17 20:08:49 -05001464 /* Debugfs support */
1465#if defined(CONFIG_DEBUG_FS)
1466extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
1467 struct dentry *root);
Lespiau, Damien7d747952013-10-17 19:09:53 +01001468extern int drm_debugfs_create_files(const struct drm_info_list *files,
1469 int count, struct dentry *root,
1470 struct drm_minor *minor);
1471extern int drm_debugfs_remove_files(const struct drm_info_list *files,
1472 int count, struct drm_minor *minor);
Ben Gamari955b12d2009-02-17 20:08:49 -05001473extern int drm_debugfs_cleanup(struct drm_minor *minor);
Thierry Reding66ee52e2013-12-12 15:44:04 +01001474#else
1475static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id,
1476 struct dentry *root)
1477{
1478 return 0;
1479}
1480
1481static inline int drm_debugfs_create_files(const struct drm_info_list *files,
1482 int count, struct dentry *root,
1483 struct drm_minor *minor)
1484{
1485 return 0;
1486}
1487
1488static inline int drm_debugfs_remove_files(const struct drm_info_list *files,
1489 int count, struct drm_minor *minor)
1490{
1491 return 0;
1492}
1493
1494static inline int drm_debugfs_cleanup(struct drm_minor *minor)
1495{
1496 return 0;
1497}
Ben Gamari955b12d2009-02-17 20:08:49 -05001498#endif
1499
1500 /* Info file support */
1501extern int drm_name_info(struct seq_file *m, void *data);
1502extern int drm_vm_info(struct seq_file *m, void *data);
Ben Gamari955b12d2009-02-17 20:08:49 -05001503extern int drm_bufs_info(struct seq_file *m, void *data);
1504extern int drm_vblank_info(struct seq_file *m, void *data);
1505extern int drm_clients_info(struct seq_file *m, void* data);
1506extern int drm_gem_name_info(struct seq_file *m, void *data);
Ben Gamari955b12d2009-02-17 20:08:49 -05001507
Dave Airlie32488772011-11-25 15:21:02 +00001508
Aaron Plattner89177642013-01-15 20:47:42 +00001509extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
1510 struct drm_gem_object *obj, int flags);
Dave Airlie32488772011-11-25 15:21:02 +00001511extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
1512 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
1513 int *prime_fd);
Aaron Plattner89177642013-01-15 20:47:42 +00001514extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
1515 struct dma_buf *dma_buf);
Dave Airlie32488772011-11-25 15:21:02 +00001516extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
1517 struct drm_file *file_priv, int prime_fd, uint32_t *handle);
Daniel Vetterc1d67982013-08-15 00:02:30 +02001518extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf);
Dave Airlie32488772011-11-25 15:21:02 +00001519
1520extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
1521 struct drm_file *file_priv);
1522extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
1523 struct drm_file *file_priv);
1524
Dave Airlie51ab7ba2012-05-18 15:40:33 +01001525extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
1526 dma_addr_t *addrs, int max_pages);
Dave Airlie32488772011-11-25 15:21:02 +00001527extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, int nr_pages);
1528extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
1529
Daniel Vetter43387b32013-07-16 09:12:04 +02001530int drm_gem_dumb_destroy(struct drm_file *file,
1531 struct drm_device *dev,
1532 uint32_t handle);
Dave Airlie32488772011-11-25 15:21:02 +00001533
1534void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
1535void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
Daniel Vetterd0b2c532013-08-15 00:02:49 +02001536void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
Dave Airlie32488772011-11-25 15:21:02 +00001537
Ben Gamari955b12d2009-02-17 20:08:49 -05001538#if DRM_DEBUG_CODE
1539extern int drm_vma_info(struct seq_file *m, void *data);
1540#endif
1541
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 /* Scatter Gather Support (drm_scatter.h) */
Daniel Vetter3d914e82013-08-08 15:41:17 +02001543extern void drm_legacy_sg_cleanup(struct drm_device *dev);
Daniel Vetter1d8d29c2013-07-10 14:11:50 +02001544extern int drm_sg_alloc(struct drm_device *dev, void *data,
Eric Anholtc153f452007-09-03 12:06:45 +10001545 struct drm_file *file_priv);
Eric Anholtc153f452007-09-03 12:06:45 +10001546extern int drm_sg_free(struct drm_device *dev, void *data,
1547 struct drm_file *file_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001549 /* ATI PCIGART support (ati_pcigart.h) */
Dave Airlie84b1fd12007-07-11 15:53:27 +10001550extern int drm_ati_pcigart_init(struct drm_device *dev,
Dave Airlie55910512007-07-11 16:53:40 +10001551 struct drm_ati_pcigart_info * gart_info);
Dave Airlie84b1fd12007-07-11 15:53:27 +10001552extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
Dave Airlie55910512007-07-11 16:53:40 +10001553 struct drm_ati_pcigart_info * gart_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
Dave Airlie84b1fd12007-07-11 15:53:27 +10001555extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
Zhenyu Wange6be8d92010-01-05 11:25:05 +08001556 size_t align);
Dave Airlie84b1fd12007-07-11 15:53:27 +10001557extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1558extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
1560 /* sysfs support (drm_sysfs.c) */
Jesse Barnese8b962b2007-11-22 14:02:38 +10001561struct drm_sysfs_class;
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -08001562extern struct class *drm_sysfs_create(struct module *owner, char *name);
Jesse Barnese8b962b2007-11-22 14:02:38 +10001563extern void drm_sysfs_destroy(void);
Dave Airlie2c14f282008-04-21 16:47:32 +10001564extern int drm_sysfs_device_add(struct drm_minor *minor);
Dave Airlief453ba02008-11-07 14:05:41 -08001565extern void drm_sysfs_hotplug_event(struct drm_device *dev);
Dave Airlie2c14f282008-04-21 16:47:32 +10001566extern void drm_sysfs_device_remove(struct drm_minor *minor);
Dave Airlief453ba02008-11-07 14:05:41 -08001567extern int drm_sysfs_connector_add(struct drm_connector *connector);
1568extern void drm_sysfs_connector_remove(struct drm_connector *connector);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
Eric Anholt673a3942008-07-30 12:06:12 -07001570/* Graphics Execution Manager library functions (drm_gem.c) */
1571int drm_gem_init(struct drm_device *dev);
Jesse Barnesa2c0a972008-11-05 10:31:53 -08001572void drm_gem_destroy(struct drm_device *dev);
Daniel Vetterfd632aa2010-04-09 19:05:05 +00001573void drm_gem_object_release(struct drm_gem_object *obj);
Eric Anholt673a3942008-07-30 12:06:12 -07001574void drm_gem_object_free(struct kref *kref);
Daniel Vetter1d397042010-04-09 19:05:04 +00001575int drm_gem_object_init(struct drm_device *dev,
1576 struct drm_gem_object *obj, size_t size);
David Herrmann89c82332013-07-11 11:56:32 +02001577void drm_gem_private_object_init(struct drm_device *dev,
1578 struct drm_gem_object *obj, size_t size);
Jesse Barnesab00b3e2009-02-11 14:01:46 -08001579void drm_gem_vm_open(struct vm_area_struct *vma);
1580void drm_gem_vm_close(struct vm_area_struct *vma);
Laurent Pinchart1c5aafa2013-04-16 14:14:52 +02001581int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
1582 struct vm_area_struct *vma);
Jesse Barnesa2c0a972008-11-05 10:31:53 -08001583int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
Eric Anholt673a3942008-07-30 12:06:12 -07001584
David Howellsa1ce3922012-10-02 18:01:25 +01001585#include <drm/drm_global.h>
Dave Airlieba4420c2010-03-09 10:56:52 +10001586
Eric Anholt673a3942008-07-30 12:06:12 -07001587static inline void
1588drm_gem_object_reference(struct drm_gem_object *obj)
1589{
1590 kref_get(&obj->refcount);
1591}
1592
1593static inline void
1594drm_gem_object_unreference(struct drm_gem_object *obj)
1595{
Luca Barbieric3ae90c2010-02-09 05:49:11 +00001596 if (obj != NULL)
1597 kref_put(&obj->refcount, drm_gem_object_free);
1598}
Eric Anholt673a3942008-07-30 12:06:12 -07001599
Luca Barbieric3ae90c2010-02-09 05:49:11 +00001600static inline void
1601drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
1602{
Chris Wilson7fc65eb2013-08-06 09:59:46 +01001603 if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) {
Chris Wilson39b4d072010-09-30 09:10:26 +01001604 struct drm_device *dev = obj->dev;
Chris Wilson7fc65eb2013-08-06 09:59:46 +01001605
Chris Wilson39b4d072010-09-30 09:10:26 +01001606 mutex_lock(&dev->struct_mutex);
Chris Wilson7fc65eb2013-08-06 09:59:46 +01001607 if (likely(atomic_dec_and_test(&obj->refcount.refcount)))
1608 drm_gem_object_free(&obj->refcount);
Chris Wilson39b4d072010-09-30 09:10:26 +01001609 mutex_unlock(&dev->struct_mutex);
1610 }
Eric Anholt673a3942008-07-30 12:06:12 -07001611}
1612
Daniel Vetter20228c42013-08-15 00:02:45 +02001613int drm_gem_handle_create_tail(struct drm_file *file_priv,
1614 struct drm_gem_object *obj,
1615 u32 *handlep);
Eric Anholt673a3942008-07-30 12:06:12 -07001616int drm_gem_handle_create(struct drm_file *file_priv,
1617 struct drm_gem_object *obj,
Pekka Paalanena1a2d1d2009-08-23 12:40:55 +03001618 u32 *handlep);
Dave Airlieff72145b2011-02-07 12:16:14 +10001619int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
Eric Anholt673a3942008-07-30 12:06:12 -07001620
Luca Barbieric3ae90c2010-02-09 05:49:11 +00001621
Rob Clark75ef8b32011-08-10 08:09:07 -05001622void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
1623int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
Rob Clark367bbd42013-08-07 13:41:23 -04001624int drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size);
Rob Clark75ef8b32011-08-10 08:09:07 -05001625
Rob Clarkbcc5c9d2013-08-07 13:41:24 -04001626struct page **drm_gem_get_pages(struct drm_gem_object *obj, gfp_t gfpmask);
1627void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
1628 bool dirty, bool accessed);
1629
Eric Anholt673a3942008-07-30 12:06:12 -07001630struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
1631 struct drm_file *filp,
Pekka Paalanena1a2d1d2009-08-23 12:40:55 +03001632 u32 handle);
Eric Anholt673a3942008-07-30 12:06:12 -07001633int drm_gem_close_ioctl(struct drm_device *dev, void *data,
1634 struct drm_file *file_priv);
1635int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
1636 struct drm_file *file_priv);
1637int drm_gem_open_ioctl(struct drm_device *dev, void *data,
1638 struct drm_file *file_priv);
1639void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
1640void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
1641
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001642extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
1643extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
1644extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001646static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
1647 unsigned int token)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
Dave Airlie55910512007-07-11 16:53:40 +10001649 struct drm_map_list *_entry;
Dave Airliebd1b3312007-05-26 05:01:51 +10001650 list_for_each_entry(_entry, &dev->maplist, head)
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001651 if (_entry->user_token == token)
1652 return _entry->map;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 return NULL;
1654}
1655
Dave Airlie8410ea32010-12-15 03:16:38 +10001656static __inline__ void drm_core_dropmap(struct drm_local_map *map)
Dave Airliecda17382005-07-10 17:31:26 +10001657{
Dave Airlie8410ea32010-12-15 03:16:38 +10001658}
Jordan Crousedcdb1672010-05-27 13:40:25 -06001659
David Howellsa1ce3922012-10-02 18:01:25 +01001660#include <drm/drm_mem_util.h>
Dave Airlie8410ea32010-12-15 03:16:38 +10001661
David Herrmann1bb72532013-10-02 11:23:34 +02001662struct drm_device *drm_dev_alloc(struct drm_driver *driver,
1663 struct device *parent);
David Herrmann0dc8fe52013-10-02 11:23:37 +02001664void drm_dev_free(struct drm_device *dev);
David Herrmannc22f0ac2013-10-02 11:23:35 +02001665int drm_dev_register(struct drm_device *dev, unsigned long flags);
David Herrmannc3a49732013-10-02 11:23:38 +02001666void drm_dev_unregister(struct drm_device *dev);
Dave Airlie8410ea32010-12-15 03:16:38 +10001667/*@}*/
1668
1669/* PCI section */
1670static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
1671{
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001672 if (dev->driver->device_is_agp != NULL) {
1673 int err = (*dev->driver->device_is_agp) (dev);
1674
Dave Airliecda17382005-07-10 17:31:26 +10001675 if (err != 2) {
1676 return err;
1677 }
1678 }
1679
1680 return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
1681}
Daniel Vetter4efafeb2013-12-11 11:34:38 +01001682void drm_pci_agp_destroy(struct drm_device *dev);
Dave Airliecda17382005-07-10 17:31:26 +10001683
Dave Airlie8410ea32010-12-15 03:16:38 +10001684extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
1685extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
1686extern int drm_get_pci_dev(struct pci_dev *pdev,
Jordan Crousedcdb1672010-05-27 13:40:25 -06001687 const struct pci_device_id *ent,
1688 struct drm_driver *driver);
Dave Airlie8410ea32010-12-15 03:16:38 +10001689
Dave Airlief4297782012-06-27 08:35:53 +01001690#define DRM_PCIE_SPEED_25 1
1691#define DRM_PCIE_SPEED_50 2
1692#define DRM_PCIE_SPEED_80 4
1693
1694extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
Dave Airlie8410ea32010-12-15 03:16:38 +10001695
1696/* platform section */
1697extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device);
Dave Airlie8410ea32010-12-15 03:16:38 +10001698
Dave Airliecc1f7192012-01-05 09:55:22 +00001699/* returns true if currently okay to sleep */
1700static __inline__ bool drm_can_sleep(void)
1701{
1702 if (in_atomic() || in_dbg_master() || irqs_disabled())
1703 return false;
1704 return true;
1705}
1706
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001707#endif /* __KERNEL__ */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708#endif