sys/dev/drm2/drm_os_freebsd.h

   1 /**
   2  * \file drm_os_freebsd.h
   3  * OS abstraction macros.
   4  */
   5
   6 #include <sys/cdefs.h>
   7 __FBSDID("$FreeBSD$");
   8
   9 #ifndef _DRM_OS_FREEBSD_H_
  10 #define _DRM_OS_FREEBSD_H_
  11
  12 #include <sys/fbio.h>
  13 #include <sys/smp.h>
  14
  15 #if _BYTE_ORDER == _BIG_ENDIAN
  16 #define __BIG_ENDIAN 4321
  17 #else
  18 #define __LITTLE_ENDIAN 1234
  19 #endif
  20
  21 #ifdef __LP64__
  22 #define BITS_PER_LONG   64
  23 #else
  24 #define BITS_PER_LONG   32
  25 #endif
  26
  27 #ifndef __user
  28 #define __user
  29 #endif
  30 #ifndef __iomem
  31 #define __iomem
  32 #endif
  33 #ifndef __always_unused
  34 #define __always_unused
  35 #endif
  36 #ifndef __must_check
  37 #define __must_check
  38 #endif
  39 #ifndef __force
  40 #define __force
  41 #endif
  42 #ifndef uninitialized_var
  43 #define uninitialized_var(x) x
  44 #endif
  45
  46 #define cpu_to_le16(x)  htole16(x)
  47 #define le16_to_cpu(x)  le16toh(x)
  48 #define cpu_to_le32(x)  htole32(x)
  49 #define le32_to_cpu(x)  le32toh(x)
  50
  51 #define cpu_to_be16(x)  htobe16(x)
  52 #define be16_to_cpu(x)  be16toh(x)
  53 #define cpu_to_be32(x)  htobe32(x)
  54 #define be32_to_cpu(x)  be32toh(x)
  55 #define be32_to_cpup(x) be32toh(*x)
  56
  57 typedef vm_paddr_t dma_addr_t;
  58 typedef vm_paddr_t resource_size_t;
  59 #define wait_queue_head_t atomic_t
  60
  61 typedef uint64_t u64;
  62 typedef uint32_t u32;
  63 typedef uint16_t u16;
  64 typedef uint8_t  u8;
  65 typedef int64_t s64;
  66 typedef int32_t s32;
  67 typedef int16_t s16;
  68 typedef int8_t  s8;
  69 typedef uint16_t __le16;
  70 typedef uint32_t __le32;
  71 typedef uint64_t __le64;
  72 typedef uint16_t __be16;
  73 typedef uint32_t __be32;
  74 typedef uint64_t __be64;
  75
  76 #define DRM_IRQ_ARGS            void *arg
  77 typedef void                    irqreturn_t;
  78 #define IRQ_HANDLED             /* nothing */
  79 #define IRQ_NONE                /* nothing */
  80
  81 #define __init
  82 #define __exit
  83
  84 #define BUILD_BUG_ON(x)         CTASSERT(!(x))
  85 #define BUILD_BUG_ON_NOT_POWER_OF_2(x)
  86
  87 #ifndef WARN
  88 #define WARN(condition, format, ...) ({                         \
  89         int __ret_warn_on = !!(condition);                      \
  90         if (unlikely(__ret_warn_on))                            \
  91         DRM_ERROR(format, ##__VA_ARGS__);                       \
  92         unlikely(__ret_warn_on);                                \
  93 })
  94 #endif
  95 #define WARN_ONCE(condition, format, ...)                       \
  96         WARN(condition, format, ##__VA_ARGS__)
  97 #define WARN_ON(cond)           WARN(cond, "WARN ON: " #cond)
  98 #define WARN_ON_SMP(cond)       WARN_ON(cond)
  99 #define BUG()                   panic("BUG")
 100 #define BUG_ON(cond)            KASSERT(!(cond), ("BUG ON: " #cond " -> 0x%jx", (uintmax_t)(cond)))
 101 #define unlikely(x)            __builtin_expect(!!(x), 0)
 102 #define likely(x)              __builtin_expect(!!(x), 1)
 103 #define container_of(ptr, type, member) ({                      \
 104         __typeof( ((type *)0)->member ) *__mptr = (ptr);        \
 105         (type *)( (char *)__mptr - offsetof(type,member) );})
 106
 107 #define KHZ2PICOS(a)    (1000000000UL/(a))
 108
 109 #define ARRAY_SIZE(x)           (sizeof(x)/sizeof(x[0]))
 110
 111 #define HZ                      hz
 112 #define DRM_HZ                  hz
 113 #define DRM_CURRENTPID          curthread->td_proc->p_pid
 114 #define DRM_SUSER(p)            (priv_check(p, PRIV_DRIVER) == 0)
 115 #define udelay(usecs)           DELAY(usecs)
 116 #define mdelay(msecs)           do { int loops = (msecs);               \
 117                                   while (loops--) DELAY(1000);          \
 118                                 } while (0)
 119 #define DRM_UDELAY(udelay)      DELAY(udelay)
 120 #define drm_msleep(x, msg)      pause((msg), ((int64_t)(x)) * hz / 1000)
 121 #define DRM_MSLEEP(msecs)       drm_msleep((msecs), "drm_msleep")
 122 #define get_seconds()           time_second
 123
 124 #define ioread8(addr)           *(volatile uint8_t *)((char *)addr)
 125 #define ioread16(addr)          *(volatile uint16_t *)((char *)addr)
 126 #define ioread32(addr)          *(volatile uint32_t *)((char *)addr)
 127
 128 #define iowrite8(data, addr)    *(volatile uint8_t *)((char *)addr) = data;
 129 #define iowrite16(data, addr)   *(volatile uint16_t *)((char *)addr) = data;
 130 #define iowrite32(data, addr)   *(volatile uint32_t *)((char *)addr) = data;
 131
 132 #define DRM_READ8(map, offset)                                          \
 133         *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) +           \
 134             (vm_offset_t)(offset))
 135 #define DRM_READ16(map, offset)                                         \
 136         le16toh(*(volatile u_int16_t *)(((vm_offset_t)(map)->handle) +  \
 137             (vm_offset_t)(offset)))
 138 #define DRM_READ32(map, offset)                                         \
 139         le32toh(*(volatile u_int32_t *)(((vm_offset_t)(map)->handle) +  \
 140             (vm_offset_t)(offset)))
 141 #define DRM_READ64(map, offset)                                         \
 142         le64toh(*(volatile u_int64_t *)(((vm_offset_t)(map)->handle) +  \
 143             (vm_offset_t)(offset)))
 144 #define DRM_WRITE8(map, offset, val)                                    \
 145         *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) +           \
 146             (vm_offset_t)(offset)) = val
 147 #define DRM_WRITE16(map, offset, val)                                   \
 148         *(volatile u_int16_t *)(((vm_offset_t)(map)->handle) +          \
 149             (vm_offset_t)(offset)) = htole16(val)
 150 #define DRM_WRITE32(map, offset, val)                                   \
 151         *(volatile u_int32_t *)(((vm_offset_t)(map)->handle) +          \
 152             (vm_offset_t)(offset)) = htole32(val)
 153 #define DRM_WRITE64(map, offset, val)                                   \
 154         *(volatile u_int64_t *)(((vm_offset_t)(map)->handle) +          \
 155             (vm_offset_t)(offset)) = htole64(val)
 156
 157 #ifdef amd64
 158 #define DRM_PORT "graphics/drm-kmod"
 159 #else
 160 #define DRM_PORT "graphics/drm-legacy-kmod"
 161 #endif
 162
 163 #define DRM_OBSOLETE(dev)                                                       \
 164     do {                                                                        \
 165         device_printf(dev, "=======================================================\n"); \
 166         device_printf(dev, "This code is obsolete abandonware. Install the " DRM_PORT " pkg\n"); \
 167         device_printf(dev, "=======================================================\n"); \
 168         gone_in_dev(dev, 13, "drm2 drivers");                                   \
 169     } while (0)
 170
 171 /* DRM_READMEMORYBARRIER() prevents reordering of reads.
 172  * DRM_WRITEMEMORYBARRIER() prevents reordering of writes.
 173  * DRM_MEMORYBARRIER() prevents reordering of reads and writes.
 174  */
 175 #define DRM_READMEMORYBARRIER()         rmb()
 176 #define DRM_WRITEMEMORYBARRIER()        wmb()
 177 #define DRM_MEMORYBARRIER()             mb()
 178 #define smp_rmb()                       rmb()
 179 #define smp_wmb()                       wmb()
 180 #define smp_mb__before_atomic_inc()     mb()
 181 #define smp_mb__after_atomic_inc()      mb()
 182 #define barrier()                       __compiler_membar()
 183
 184 #define do_div(a, b)            ((a) /= (b))
 185 #define div64_u64(a, b)         ((a) / (b))
 186 #define lower_32_bits(n)        ((u32)(n))
 187 #define upper_32_bits(n)        ((u32)(((n) >> 16) >> 16))
 188
 189 #define __set_bit(n, s)         set_bit((n), (s))
 190 #define __clear_bit(n, s)       clear_bit((n), (s))
 191
 192 #define min_t(type, x, y) ({                    \
 193         type __min1 = (x);                      \
 194         type __min2 = (y);                      \
 195         __min1 < __min2 ? __min1 : __min2; })
 196
 197 #define max_t(type, x, y) ({                    \
 198         type __max1 = (x);                      \
 199         type __max2 = (y);                      \
 200         __max1 > __max2 ? __max1 : __max2; })
 201
 202 #define memset_io(a, b, c)      memset((a), (b), (c))
 203 #define memcpy_fromio(a, b, c)  memcpy((a), (b), (c))
 204 #define memcpy_toio(a, b, c)    memcpy((a), (b), (c))
 205
 206 #define VERIFY_READ     VM_PROT_READ
 207 #define VERIFY_WRITE    VM_PROT_WRITE
 208 #define access_ok(prot, p, l)   useracc((p), (l), (prot))
 209
 210 /* XXXKIB what is the right code for the FreeBSD ? */
 211 /* kib@ used ENXIO here -- dumbbell@ */
 212 #define EREMOTEIO       EIO
 213 #define ERESTARTSYS     512 /* Same value as Linux. */
 214
 215 #define KTR_DRM         KTR_DEV
 216 #define KTR_DRM_REG     KTR_SPARE3
 217
 218 #define DRM_AGP_KERN    struct agp_info
 219 #define DRM_AGP_MEM     void
 220
 221 #define PCI_VENDOR_ID_APPLE             0x106b
 222 #define PCI_VENDOR_ID_ASUSTEK           0x1043
 223 #define PCI_VENDOR_ID_ATI               0x1002
 224 #define PCI_VENDOR_ID_DELL              0x1028
 225 #define PCI_VENDOR_ID_HP                0x103c
 226 #define PCI_VENDOR_ID_IBM               0x1014
 227 #define PCI_VENDOR_ID_INTEL             0x8086
 228 #define PCI_VENDOR_ID_SERVERWORKS       0x1166
 229 #define PCI_VENDOR_ID_SONY              0x104d
 230 #define PCI_VENDOR_ID_VIA               0x1106
 231
 232 #define DIV_ROUND_UP(n,d)       (((n) + (d) - 1) / (d))
 233 #define DIV_ROUND_CLOSEST(n,d)  (((n) + (d) / 2) / (d))
 234 #define div_u64(n, d)           ((n) / (d))
 235 #define hweight32(i)            bitcount32(i)
 236
 237 static inline unsigned long
 238 roundup_pow_of_two(unsigned long x)
 239 {
 240
 241         return (1UL << flsl(x - 1));
 242 }
 243
 244 /**
 245  * ror32 - rotate a 32-bit value right
 246  * @word: value to rotate
 247  * @shift: bits to roll
 248  *
 249  * Source: include/linux/bitops.h
 250  */
 251 static inline uint32_t
 252 ror32(uint32_t word, unsigned int shift)
 253 {
 254
 255         return (word >> shift) | (word << (32 - shift));
 256 }
 257
 258 #define IS_ALIGNED(x, y)        (((x) & ((y) - 1)) == 0)
 259 #define round_down(x, y)        rounddown2((x), (y))
 260 #define round_up(x, y)          roundup2((x), (y))
 261 #define get_unaligned(ptr)                                              \
 262         ({ __typeof__(*(ptr)) __tmp;                                    \
 263           memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
 264
 265 #if _BYTE_ORDER == _LITTLE_ENDIAN
 266 /* Taken from linux/include/linux/unaligned/le_struct.h. */
 267 struct __una_u32 { u32 x; } __packed;
 268
 269 static inline u32
 270 __get_unaligned_cpu32(const void *p)
 271 {
 272         const struct __una_u32 *ptr = (const struct __una_u32 *)p;
 273
 274         return (ptr->x);
 275 }
 276
 277 static inline u32
 278 get_unaligned_le32(const void *p)
 279 {
 280
 281         return (__get_unaligned_cpu32((const u8 *)p));
 282 }
 283 #else
 284 /* Taken from linux/include/linux/unaligned/le_byteshift.h. */
 285 static inline u32
 286 __get_unaligned_le32(const u8 *p)
 287 {
 288
 289         return (p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24);
 290 }
 291
 292 static inline u32
 293 get_unaligned_le32(const void *p)
 294 {
 295
 296         return (__get_unaligned_le32((const u8 *)p));
 297 }
 298 #endif
 299
 300 static inline unsigned long
 301 ilog2(unsigned long x)
 302 {
 303
 304         return (flsl(x) - 1);
 305 }
 306
 307 static inline int64_t
 308 abs64(int64_t x)
 309 {
 310
 311         return (x < 0 ? -x : x);
 312 }
 313
 314 int64_t         timeval_to_ns(const struct timeval *tv);
 315 struct timeval  ns_to_timeval(const int64_t nsec);
 316
 317 #define PAGE_ALIGN(addr) round_page(addr)
 318 #define page_to_phys(x) VM_PAGE_TO_PHYS(x)
 319 #define offset_in_page(x) ((x) & PAGE_MASK)
 320
 321 #define drm_get_device_from_kdev(_kdev) (((struct drm_minor *)(_kdev)->si_drv1)->dev)
 322
 323 #define DRM_IOC_VOID            IOC_VOID
 324 #define DRM_IOC_READ            IOC_OUT
 325 #define DRM_IOC_WRITE           IOC_IN
 326 #define DRM_IOC_READWRITE       IOC_INOUT
 327 #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
 328
 329 static inline long
 330 __copy_to_user(void __user *to, const void *from, unsigned long n)
 331 {
 332         return (copyout(from, to, n) != 0 ? n : 0);
 333 }
 334 #define copy_to_user(to, from, n) __copy_to_user((to), (from), (n))
 335
 336 static inline int
 337 __put_user(size_t size, void *ptr, void *x)
 338 {
 339
 340         size = copy_to_user(ptr, x, size);
 341
 342         return (size ? -EFAULT : size);
 343 }
 344 #define put_user(x, ptr) __put_user(sizeof(*ptr), (ptr), &(x))
 345
 346 static inline unsigned long
 347 __copy_from_user(void *to, const void __user *from, unsigned long n)
 348 {
 349         return ((copyin(__DECONST(void *, from), to, n) != 0 ? n : 0));
 350 }
 351 #define copy_from_user(to, from, n) __copy_from_user((to), (from), (n))
 352
 353 static inline int
 354 __get_user(size_t size, const void *ptr, void *x)
 355 {
 356
 357         size = copy_from_user(x, ptr, size);
 358
 359         return (size ? -EFAULT : size);
 360 }
 361 #define get_user(x, ptr) __get_user(sizeof(*ptr), (ptr), &(x))
 362
 363 static inline int
 364 __copy_to_user_inatomic(void __user *to, const void *from, unsigned n)
 365 {
 366
 367         return (copyout_nofault(from, to, n) != 0 ? n : 0);
 368 }
 369 #define __copy_to_user_inatomic_nocache(to, from, n) \
 370     __copy_to_user_inatomic((to), (from), (n))
 371
 372 static inline unsigned long
 373 __copy_from_user_inatomic(void *to, const void __user *from,
 374     unsigned long n)
 375 {
 376
 377         /*
 378          * XXXKIB.  Equivalent Linux function is implemented using
 379          * MOVNTI for aligned moves.  For unaligned head and tail,
 380          * normal move is performed.  As such, it is not incorrect, if
 381          * only somewhat slower, to use normal copyin.  All uses
 382          * except shmem_pwrite_fast() have the destination mapped WC.
 383          */
 384         return ((copyin_nofault(__DECONST(void *, from), to, n) != 0 ? n : 0));
 385 }
 386 #define __copy_from_user_inatomic_nocache(to, from, n) \
 387     __copy_from_user_inatomic((to), (from), (n))
 388
 389 static inline int
 390 fault_in_multipages_readable(const char __user *uaddr, int size)
 391 {
 392         char c;
 393         int ret = 0;
 394         const char __user *end = uaddr + size - 1;
 395
 396         if (unlikely(size == 0))
 397                 return ret;
 398
 399         while (uaddr <= end) {
 400                 ret = -copyin(uaddr, &c, 1);
 401                 if (ret != 0)
 402                         return -EFAULT;
 403                 uaddr += PAGE_SIZE;
 404         }
 405
 406         /* Check whether the range spilled into the next page. */
 407         if (((unsigned long)uaddr & ~PAGE_MASK) ==
 408                         ((unsigned long)end & ~PAGE_MASK)) {
 409                 ret = -copyin(end, &c, 1);
 410         }
 411
 412         return ret;
 413 }
 414
 415 static inline int
 416 fault_in_multipages_writeable(char __user *uaddr, int size)
 417 {
 418         int ret = 0;
 419         char __user *end = uaddr + size - 1;
 420
 421         if (unlikely(size == 0))
 422                 return ret;
 423
 424         /*
 425          * Writing zeroes into userspace here is OK, because we know that if
 426          * the zero gets there, we'll be overwriting it.
 427          */
 428         while (uaddr <= end) {
 429                 ret = subyte(uaddr, 0);
 430                 if (ret != 0)
 431                         return -EFAULT;
 432                 uaddr += PAGE_SIZE;
 433         }
 434
 435         /* Check whether the range spilled into the next page. */
 436         if (((unsigned long)uaddr & ~PAGE_MASK) ==
 437                         ((unsigned long)end & ~PAGE_MASK))
 438                 ret = subyte(end, 0);
 439
 440         return ret;
 441 }
 442
 443 enum __drm_capabilities {
 444         CAP_SYS_ADMIN
 445 };
 446
 447 static inline bool
 448 capable(enum __drm_capabilities cap)
 449 {
 450
 451         switch (cap) {
 452         case CAP_SYS_ADMIN:
 453                 return DRM_SUSER(curthread);
 454         default:
 455                 panic("%s: unhandled capability: %0x", __func__, cap);
 456                 return (false);
 457         }
 458 }
 459
 460 #define to_user_ptr(x)          ((void *)(uintptr_t)(x))
 461 #define sigemptyset(set)        SIGEMPTYSET(set)
 462 #define sigaddset(set, sig)     SIGADDSET(set, sig)
 463
 464 #define DRM_LOCK(dev)           sx_xlock(&(dev)->dev_struct_lock)
 465 #define DRM_UNLOCK(dev)         sx_xunlock(&(dev)->dev_struct_lock)
 466
 467 extern unsigned long drm_linux_timer_hz_mask;
 468 #define jiffies                 ticks
 469 #define jiffies_to_msecs(x)     (((int64_t)(x)) * 1000 / hz)
 470 #define msecs_to_jiffies(x)     (((int64_t)(x)) * hz / 1000)
 471 #define timespec_to_jiffies(x)  (((x)->tv_sec * 1000000 + (x)->tv_nsec) * hz / 1000000)
 472 #define time_after(a,b)         ((long)(b) - (long)(a) < 0)
 473 #define time_after_eq(a,b)      ((long)(b) - (long)(a) <= 0)
 474 #define round_jiffies(j)        ((unsigned long)(((j) + drm_linux_timer_hz_mask) & ~drm_linux_timer_hz_mask))
 475 #define round_jiffies_up(j)             round_jiffies(j) /* TODO */
 476 #define round_jiffies_up_relative(j)    round_jiffies_up(j) /* TODO */
 477
 478 #define getrawmonotonic(ts)     getnanouptime(ts)
 479
 480 #define wake_up(queue)                          wakeup_one((void *)queue)
 481 #define wake_up_interruptible(queue)            wakeup_one((void *)queue)
 482 #define wake_up_all(queue)                      wakeup((void *)queue)
 483 #define wake_up_interruptible_all(queue)        wakeup((void *)queue)
 484
 485 struct completion {
 486         unsigned int done;
 487         struct mtx lock;
 488 };
 489
 490 #define INIT_COMPLETION(c) ((c).done = 0);
 491
 492 static inline void
 493 init_completion(struct completion *c)
 494 {
 495
 496         mtx_init(&c->lock, "drmcompl", NULL, MTX_DEF);
 497         c->done = 0;
 498 }
 499
 500 static inline void
 501 free_completion(struct completion *c)
 502 {
 503
 504         mtx_destroy(&c->lock);
 505 }
 506
 507 static inline void
 508 complete_all(struct completion *c)
 509 {
 510
 511         mtx_lock(&c->lock);
 512         c->done++;
 513         mtx_unlock(&c->lock);
 514         wakeup(c);
 515 }
 516
 517 static inline long
 518 wait_for_completion_interruptible_timeout(struct completion *c,
 519     unsigned long timeout)
 520 {
 521         unsigned long start_jiffies, elapsed_jiffies;
 522         bool timeout_expired = false, awakened = false;
 523         long ret = timeout;
 524
 525         start_jiffies = ticks;
 526
 527         mtx_lock(&c->lock);
 528         while (c->done == 0 && !timeout_expired) {
 529                 ret = -msleep(c, &c->lock, PCATCH, "drmwco", timeout);
 530                 switch(ret) {
 531                 case -EWOULDBLOCK:
 532                         timeout_expired = true;
 533                         ret = 0;
 534                         break;
 535                 case -EINTR:
 536                 case -ERESTART:
 537                         ret = -ERESTARTSYS;
 538                         break;
 539                 case 0:
 540                         awakened = true;
 541                         break;
 542                 }
 543         }
 544         mtx_unlock(&c->lock);
 545
 546         if (awakened) {
 547                 elapsed_jiffies = ticks - start_jiffies;
 548                 ret = timeout > elapsed_jiffies ? timeout - elapsed_jiffies : 1;
 549         }
 550
 551         return (ret);
 552 }
 553
 554 MALLOC_DECLARE(DRM_MEM_DMA);
 555 MALLOC_DECLARE(DRM_MEM_SAREA);
 556 MALLOC_DECLARE(DRM_MEM_DRIVER);
 557 MALLOC_DECLARE(DRM_MEM_MAGIC);
 558 MALLOC_DECLARE(DRM_MEM_MINOR);
 559 MALLOC_DECLARE(DRM_MEM_IOCTLS);
 560 MALLOC_DECLARE(DRM_MEM_MAPS);
 561 MALLOC_DECLARE(DRM_MEM_BUFS);
 562 MALLOC_DECLARE(DRM_MEM_SEGS);
 563 MALLOC_DECLARE(DRM_MEM_PAGES);
 564 MALLOC_DECLARE(DRM_MEM_FILES);
 565 MALLOC_DECLARE(DRM_MEM_QUEUES);
 566 MALLOC_DECLARE(DRM_MEM_CMDS);
 567 MALLOC_DECLARE(DRM_MEM_MAPPINGS);
 568 MALLOC_DECLARE(DRM_MEM_BUFLISTS);
 569 MALLOC_DECLARE(DRM_MEM_AGPLISTS);
 570 MALLOC_DECLARE(DRM_MEM_CTXBITMAP);
 571 MALLOC_DECLARE(DRM_MEM_SGLISTS);
 572 MALLOC_DECLARE(DRM_MEM_MM);
 573 MALLOC_DECLARE(DRM_MEM_HASHTAB);
 574 MALLOC_DECLARE(DRM_MEM_KMS);
 575 MALLOC_DECLARE(DRM_MEM_VBLANK);
 576
 577 #define simple_strtol(a, b, c)                  strtol((a), (b), (c))
 578
 579 typedef struct drm_pci_id_list
 580 {
 581         int vendor;
 582         int device;
 583         long driver_private;
 584         char *name;
 585 } drm_pci_id_list_t;
 586
 587 #ifdef __i386__
 588 #define CONFIG_X86      1
 589 #endif
 590 #ifdef __amd64__
 591 #define CONFIG_X86      1
 592 #define CONFIG_X86_64   1
 593 #endif
 594 #ifdef __ia64__
 595 #define CONFIG_IA64     1
 596 #endif
 597
 598 #if defined(__i386__) || defined(__amd64__)
 599 #define CONFIG_ACPI
 600 #define CONFIG_DRM_I915_KMS
 601 #undef  CONFIG_INTEL_IOMMU
 602 #endif
 603
 604 #ifdef COMPAT_FREEBSD32
 605 #define CONFIG_COMPAT
 606 #endif
 607
 608 #ifndef __arm__
 609 #define CONFIG_AGP      1
 610 #define CONFIG_MTRR     1
 611 #endif
 612
 613 #define CONFIG_FB       1
 614 extern const char *fb_mode_option;
 615
 616 #undef  CONFIG_DEBUG_FS
 617 #undef  CONFIG_VGA_CONSOLE
 618
 619 #define EXPORT_SYMBOL(x)
 620 #define EXPORT_SYMBOL_GPL(x)
 621 #define MODULE_AUTHOR(author)
 622 #define MODULE_DESCRIPTION(desc)
 623 #define MODULE_LICENSE(license)
 624 #define MODULE_PARM_DESC(name, desc)
 625 #define MODULE_DEVICE_TABLE(name, list)
 626 #define module_param_named(name, var, type, perm)
 627
 628 #define printk          printf
 629 #define pr_err          DRM_ERROR
 630 #define pr_warn         DRM_WARNING
 631 #define pr_warn_once    DRM_WARNING
 632 #define KERN_DEBUG      ""
 633
 634 /* I2C compatibility. */
 635 #define I2C_M_RD        IIC_M_RD
 636 #define I2C_M_WR        IIC_M_WR
 637 #define I2C_M_NOSTART   IIC_M_NOSTART
 638
 639 struct fb_info *        framebuffer_alloc(void);
 640 void                    framebuffer_release(struct fb_info *info);
 641
 642 #define console_lock()
 643 #define console_unlock()
 644 #define console_trylock()       true
 645
 646 #define PM_EVENT_SUSPEND        0x0002
 647 #define PM_EVENT_QUIESCE        0x0008
 648 #define PM_EVENT_PRETHAW        PM_EVENT_QUIESCE
 649
 650 typedef struct pm_message {
 651         int event;
 652 } pm_message_t;
 653
 654 static inline int
 655 pci_read_config_byte(device_t kdev, int where, u8 *val)
 656 {
 657
 658         *val = (u8)pci_read_config(kdev, where, 1);
 659         return (0);
 660 }
 661
 662 static inline int
 663 pci_write_config_byte(device_t kdev, int where, u8 val)
 664 {
 665
 666         pci_write_config(kdev, where, val, 1);
 667         return (0);
 668 }
 669
 670 static inline int
 671 pci_read_config_word(device_t kdev, int where, uint16_t *val)
 672 {
 673
 674         *val = (uint16_t)pci_read_config(kdev, where, 2);
 675         return (0);
 676 }
 677
 678 static inline int
 679 pci_write_config_word(device_t kdev, int where, uint16_t val)
 680 {
 681
 682         pci_write_config(kdev, where, val, 2);
 683         return (0);
 684 }
 685
 686 static inline int
 687 pci_read_config_dword(device_t kdev, int where, uint32_t *val)
 688 {
 689
 690         *val = (uint32_t)pci_read_config(kdev, where, 4);
 691         return (0);
 692 }
 693
 694 static inline int
 695 pci_write_config_dword(device_t kdev, int where, uint32_t val)
 696 {
 697
 698         pci_write_config(kdev, where, val, 4);
 699         return (0);
 700 }
 701
 702 static inline void
 703 on_each_cpu(void callback(void *data), void *data, int wait)
 704 {
 705
 706         smp_rendezvous(NULL, callback, NULL, data);
 707 }
 708
 709 void    hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
 710             int groupsize, char *linebuf, size_t linebuflen, bool ascii);
 711
 712 #define KIB_NOTYET()                                                    \
 713 do {                                                                    \
 714         if (drm_debug && drm_notyet)                                    \
 715                 printf("NOTYET: %s at %s:%d\n", __func__, __FILE__, __LINE__); \
 716 } while (0)
 717
 718 #endif /* _DRM_OS_FREEBSD_H_ */