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 /* DRM_READMEMORYBARRIER() prevents reordering of reads.
 158  * DRM_WRITEMEMORYBARRIER() prevents reordering of writes.
 159  * DRM_MEMORYBARRIER() prevents reordering of reads and writes.
 160  */
 161 #define DRM_READMEMORYBARRIER()         rmb()
 162 #define DRM_WRITEMEMORYBARRIER()        wmb()
 163 #define DRM_MEMORYBARRIER()             mb()
 164 #define smp_rmb()                       rmb()
 165 #define smp_wmb()                       wmb()
 166 #define smp_mb__before_atomic_inc()     mb()
 167 #define smp_mb__after_atomic_inc()      mb()
 168 #define barrier()                       __compiler_membar()
 169
 170 #define do_div(a, b)            ((a) /= (b))
 171 #define div64_u64(a, b)         ((a) / (b))
 172 #define lower_32_bits(n)        ((u32)(n))
 173 #define upper_32_bits(n)        ((u32)(((n) >> 16) >> 16))
 174
 175 #define __set_bit(n, s)         set_bit((n), (s))
 176 #define __clear_bit(n, s)       clear_bit((n), (s))
 177
 178 #define min_t(type, x, y) ({                    \
 179         type __min1 = (x);                      \
 180         type __min2 = (y);                      \
 181         __min1 < __min2 ? __min1 : __min2; })
 182
 183 #define max_t(type, x, y) ({                    \
 184         type __max1 = (x);                      \
 185         type __max2 = (y);                      \
 186         __max1 > __max2 ? __max1 : __max2; })
 187
 188 #define memset_io(a, b, c)      memset((a), (b), (c))
 189 #define memcpy_fromio(a, b, c)  memcpy((a), (b), (c))
 190 #define memcpy_toio(a, b, c)    memcpy((a), (b), (c))
 191
 192 #define VERIFY_READ     VM_PROT_READ
 193 #define VERIFY_WRITE    VM_PROT_WRITE
 194 #define access_ok(prot, p, l)   useracc((p), (l), (prot))
 195
 196 /* XXXKIB what is the right code for the FreeBSD ? */
 197 /* kib@ used ENXIO here -- dumbbell@ */
 198 #define EREMOTEIO       EIO
 199 #define ERESTARTSYS     512 /* Same value as Linux. */
 200
 201 #define KTR_DRM         KTR_DEV
 202 #define KTR_DRM_REG     KTR_SPARE3
 203
 204 #define DRM_AGP_KERN    struct agp_info
 205 #define DRM_AGP_MEM     void
 206
 207 #define PCI_VENDOR_ID_APPLE             0x106b
 208 #define PCI_VENDOR_ID_ASUSTEK           0x1043
 209 #define PCI_VENDOR_ID_ATI               0x1002
 210 #define PCI_VENDOR_ID_DELL              0x1028
 211 #define PCI_VENDOR_ID_HP                0x103c
 212 #define PCI_VENDOR_ID_IBM               0x1014
 213 #define PCI_VENDOR_ID_INTEL             0x8086
 214 #define PCI_VENDOR_ID_SERVERWORKS       0x1166
 215 #define PCI_VENDOR_ID_SONY              0x104d
 216 #define PCI_VENDOR_ID_VIA               0x1106
 217
 218 #define DIV_ROUND_UP(n,d)       (((n) + (d) - 1) / (d))
 219 #define DIV_ROUND_CLOSEST(n,d)  (((n) + (d) / 2) / (d))
 220 #define div_u64(n, d)           ((n) / (d))
 221 #define hweight32(i)            bitcount32(i)
 222
 223 static inline unsigned long
 224 roundup_pow_of_two(unsigned long x)
 225 {
 226
 227         return (1UL << flsl(x - 1));
 228 }
 229
 230 /**
 231  * ror32 - rotate a 32-bit value right
 232  * @word: value to rotate
 233  * @shift: bits to roll
 234  *
 235  * Source: include/linux/bitops.h
 236  */
 237 static inline uint32_t
 238 ror32(uint32_t word, unsigned int shift)
 239 {
 240
 241         return (word >> shift) | (word << (32 - shift));
 242 }
 243
 244 #define IS_ALIGNED(x, y)        (((x) & ((y) - 1)) == 0)
 245 #define round_down(x, y)        rounddown2((x), (y))
 246 #define round_up(x, y)          roundup2((x), (y))
 247 #define get_unaligned(ptr)                                              \
 248         ({ __typeof__(*(ptr)) __tmp;                                    \
 249           memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
 250
 251 #if _BYTE_ORDER == _LITTLE_ENDIAN
 252 /* Taken from linux/include/linux/unaligned/le_struct.h. */
 253 struct __una_u32 { u32 x; } __packed;
 254
 255 static inline u32
 256 __get_unaligned_cpu32(const void *p)
 257 {
 258         const struct __una_u32 *ptr = (const struct __una_u32 *)p;
 259
 260         return (ptr->x);
 261 }
 262
 263 static inline u32
 264 get_unaligned_le32(const void *p)
 265 {
 266
 267         return (__get_unaligned_cpu32((const u8 *)p));
 268 }
 269 #else
 270 /* Taken from linux/include/linux/unaligned/le_byteshift.h. */
 271 static inline u32
 272 __get_unaligned_le32(const u8 *p)
 273 {
 274
 275         return (p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24);
 276 }
 277
 278 static inline u32
 279 get_unaligned_le32(const void *p)
 280 {
 281
 282         return (__get_unaligned_le32((const u8 *)p));
 283 }
 284 #endif
 285
 286 static inline unsigned long
 287 ilog2(unsigned long x)
 288 {
 289
 290         return (flsl(x) - 1);
 291 }
 292
 293 static inline int64_t
 294 abs64(int64_t x)
 295 {
 296
 297         return (x < 0 ? -x : x);
 298 }
 299
 300 int64_t         timeval_to_ns(const struct timeval *tv);
 301 struct timeval  ns_to_timeval(const int64_t nsec);
 302
 303 #define PAGE_ALIGN(addr) round_page(addr)
 304 #define page_to_phys(x) VM_PAGE_TO_PHYS(x)
 305 #define offset_in_page(x) ((x) & PAGE_MASK)
 306
 307 #define drm_get_device_from_kdev(_kdev) (((struct drm_minor *)(_kdev)->si_drv1)->dev)
 308
 309 #define DRM_IOC_VOID            IOC_VOID
 310 #define DRM_IOC_READ            IOC_OUT
 311 #define DRM_IOC_WRITE           IOC_IN
 312 #define DRM_IOC_READWRITE       IOC_INOUT
 313 #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
 314
 315 static inline long
 316 __copy_to_user(void __user *to, const void *from, unsigned long n)
 317 {
 318         return (copyout(from, to, n) != 0 ? n : 0);
 319 }
 320 #define copy_to_user(to, from, n) __copy_to_user((to), (from), (n))
 321
 322 static inline int
 323 __put_user(size_t size, void *ptr, void *x)
 324 {
 325
 326         size = copy_to_user(ptr, x, size);
 327
 328         return (size ? -EFAULT : size);
 329 }
 330 #define put_user(x, ptr) __put_user(sizeof(*ptr), (ptr), &(x))
 331
 332 static inline unsigned long
 333 __copy_from_user(void *to, const void __user *from, unsigned long n)
 334 {
 335         return ((copyin(__DECONST(void *, from), to, n) != 0 ? n : 0));
 336 }
 337 #define copy_from_user(to, from, n) __copy_from_user((to), (from), (n))
 338
 339 static inline int
 340 __get_user(size_t size, const void *ptr, void *x)
 341 {
 342
 343         size = copy_from_user(x, ptr, size);
 344
 345         return (size ? -EFAULT : size);
 346 }
 347 #define get_user(x, ptr) __get_user(sizeof(*ptr), (ptr), &(x))
 348
 349 static inline int
 350 __copy_to_user_inatomic(void __user *to, const void *from, unsigned n)
 351 {
 352
 353         return (copyout_nofault(from, to, n) != 0 ? n : 0);
 354 }
 355 #define __copy_to_user_inatomic_nocache(to, from, n) \
 356     __copy_to_user_inatomic((to), (from), (n))
 357
 358 static inline unsigned long
 359 __copy_from_user_inatomic(void *to, const void __user *from,
 360     unsigned long n)
 361 {
 362
 363         /*
 364          * XXXKIB.  Equivalent Linux function is implemented using
 365          * MOVNTI for aligned moves.  For unaligned head and tail,
 366          * normal move is performed.  As such, it is not incorrect, if
 367          * only somewhat slower, to use normal copyin.  All uses
 368          * except shmem_pwrite_fast() have the destination mapped WC.
 369          */
 370         return ((copyin_nofault(__DECONST(void *, from), to, n) != 0 ? n : 0));
 371 }
 372 #define __copy_from_user_inatomic_nocache(to, from, n) \
 373     __copy_from_user_inatomic((to), (from), (n))
 374
 375 static inline int
 376 fault_in_multipages_readable(const char __user *uaddr, int size)
 377 {
 378         char c;
 379         int ret = 0;
 380         const char __user *end = uaddr + size - 1;
 381
 382         if (unlikely(size == 0))
 383                 return ret;
 384
 385         while (uaddr <= end) {
 386                 ret = -copyin(uaddr, &c, 1);
 387                 if (ret != 0)
 388                         return -EFAULT;
 389                 uaddr += PAGE_SIZE;
 390         }
 391
 392         /* Check whether the range spilled into the next page. */
 393         if (((unsigned long)uaddr & ~PAGE_MASK) ==
 394                         ((unsigned long)end & ~PAGE_MASK)) {
 395                 ret = -copyin(end, &c, 1);
 396         }
 397
 398         return ret;
 399 }
 400
 401 static inline int
 402 fault_in_multipages_writeable(char __user *uaddr, int size)
 403 {
 404         int ret = 0;
 405         char __user *end = uaddr + size - 1;
 406
 407         if (unlikely(size == 0))
 408                 return ret;
 409
 410         /*
 411          * Writing zeroes into userspace here is OK, because we know that if
 412          * the zero gets there, we'll be overwriting it.
 413          */
 414         while (uaddr <= end) {
 415                 ret = subyte(uaddr, 0);
 416                 if (ret != 0)
 417                         return -EFAULT;
 418                 uaddr += PAGE_SIZE;
 419         }
 420
 421         /* Check whether the range spilled into the next page. */
 422         if (((unsigned long)uaddr & ~PAGE_MASK) ==
 423                         ((unsigned long)end & ~PAGE_MASK))
 424                 ret = subyte(end, 0);
 425
 426         return ret;
 427 }
 428
 429 enum __drm_capabilities {
 430         CAP_SYS_ADMIN
 431 };
 432
 433 static inline bool
 434 capable(enum __drm_capabilities cap)
 435 {
 436
 437         switch (cap) {
 438         case CAP_SYS_ADMIN:
 439                 return DRM_SUSER(curthread);
 440         default:
 441                 panic("%s: unhandled capability: %0x", __func__, cap);
 442                 return (false);
 443         }
 444 }
 445
 446 #define to_user_ptr(x)          ((void *)(uintptr_t)(x))
 447 #define sigemptyset(set)        SIGEMPTYSET(set)
 448 #define sigaddset(set, sig)     SIGADDSET(set, sig)
 449
 450 #define DRM_LOCK(dev)           sx_xlock(&(dev)->dev_struct_lock)
 451 #define DRM_UNLOCK(dev)         sx_xunlock(&(dev)->dev_struct_lock)
 452
 453 extern unsigned long drm_linux_timer_hz_mask;
 454 #define jiffies                 ticks
 455 #define jiffies_to_msecs(x)     (((int64_t)(x)) * 1000 / hz)
 456 #define msecs_to_jiffies(x)     (((int64_t)(x)) * hz / 1000)
 457 #define timespec_to_jiffies(x)  (((x)->tv_sec * 1000000 + (x)->tv_nsec) * hz / 1000000)
 458 #define time_after(a,b)         ((long)(b) - (long)(a) < 0)
 459 #define time_after_eq(a,b)      ((long)(b) - (long)(a) <= 0)
 460 #define round_jiffies(j)        ((unsigned long)(((j) + drm_linux_timer_hz_mask) & ~drm_linux_timer_hz_mask))
 461 #define round_jiffies_up(j)             round_jiffies(j) /* TODO */
 462 #define round_jiffies_up_relative(j)    round_jiffies_up(j) /* TODO */
 463
 464 #define getrawmonotonic(ts)     getnanouptime(ts)
 465
 466 #define wake_up(queue)                          wakeup_one((void *)queue)
 467 #define wake_up_interruptible(queue)            wakeup_one((void *)queue)
 468 #define wake_up_all(queue)                      wakeup((void *)queue)
 469 #define wake_up_interruptible_all(queue)        wakeup((void *)queue)
 470
 471 struct completion {
 472         unsigned int done;
 473         struct mtx lock;
 474 };
 475
 476 #define INIT_COMPLETION(c) ((c).done = 0);
 477
 478 static inline void
 479 init_completion(struct completion *c)
 480 {
 481
 482         mtx_init(&c->lock, "drmcompl", NULL, MTX_DEF);
 483         c->done = 0;
 484 }
 485
 486 static inline void
 487 free_completion(struct completion *c)
 488 {
 489
 490         mtx_destroy(&c->lock);
 491 }
 492
 493 static inline void
 494 complete_all(struct completion *c)
 495 {
 496
 497         mtx_lock(&c->lock);
 498         c->done++;
 499         mtx_unlock(&c->lock);
 500         wakeup(c);
 501 }
 502
 503 static inline long
 504 wait_for_completion_interruptible_timeout(struct completion *c,
 505     unsigned long timeout)
 506 {
 507         unsigned long start_jiffies, elapsed_jiffies;
 508         bool timeout_expired = false, awakened = false;
 509         long ret = timeout;
 510
 511         start_jiffies = ticks;
 512
 513         mtx_lock(&c->lock);
 514         while (c->done == 0 && !timeout_expired) {
 515                 ret = -msleep(c, &c->lock, PCATCH, "drmwco", timeout);
 516                 switch(ret) {
 517                 case -EWOULDBLOCK:
 518                         timeout_expired = true;
 519                         ret = 0;
 520                         break;
 521                 case -EINTR:
 522                 case -ERESTART:
 523                         ret = -ERESTARTSYS;
 524                         break;
 525                 case 0:
 526                         awakened = true;
 527                         break;
 528                 }
 529         }
 530         mtx_unlock(&c->lock);
 531
 532         if (awakened) {
 533                 elapsed_jiffies = ticks - start_jiffies;
 534                 ret = timeout > elapsed_jiffies ? timeout - elapsed_jiffies : 1;
 535         }
 536
 537         return (ret);
 538 }
 539
 540 MALLOC_DECLARE(DRM_MEM_DMA);
 541 MALLOC_DECLARE(DRM_MEM_SAREA);
 542 MALLOC_DECLARE(DRM_MEM_DRIVER);
 543 MALLOC_DECLARE(DRM_MEM_MAGIC);
 544 MALLOC_DECLARE(DRM_MEM_MINOR);
 545 MALLOC_DECLARE(DRM_MEM_IOCTLS);
 546 MALLOC_DECLARE(DRM_MEM_MAPS);
 547 MALLOC_DECLARE(DRM_MEM_BUFS);
 548 MALLOC_DECLARE(DRM_MEM_SEGS);
 549 MALLOC_DECLARE(DRM_MEM_PAGES);
 550 MALLOC_DECLARE(DRM_MEM_FILES);
 551 MALLOC_DECLARE(DRM_MEM_QUEUES);
 552 MALLOC_DECLARE(DRM_MEM_CMDS);
 553 MALLOC_DECLARE(DRM_MEM_MAPPINGS);
 554 MALLOC_DECLARE(DRM_MEM_BUFLISTS);
 555 MALLOC_DECLARE(DRM_MEM_AGPLISTS);
 556 MALLOC_DECLARE(DRM_MEM_CTXBITMAP);
 557 MALLOC_DECLARE(DRM_MEM_SGLISTS);
 558 MALLOC_DECLARE(DRM_MEM_MM);
 559 MALLOC_DECLARE(DRM_MEM_HASHTAB);
 560 MALLOC_DECLARE(DRM_MEM_KMS);
 561 MALLOC_DECLARE(DRM_MEM_VBLANK);
 562
 563 #define simple_strtol(a, b, c)                  strtol((a), (b), (c))
 564
 565 typedef struct drm_pci_id_list
 566 {
 567         int vendor;
 568         int device;
 569         long driver_private;
 570         char *name;
 571 } drm_pci_id_list_t;
 572
 573 #ifdef __i386__
 574 #define CONFIG_X86      1
 575 #endif
 576 #ifdef __amd64__
 577 #define CONFIG_X86      1
 578 #define CONFIG_X86_64   1
 579 #endif
 580 #ifdef __ia64__
 581 #define CONFIG_IA64     1
 582 #endif
 583
 584 #if defined(__i386__) || defined(__amd64__)
 585 #define CONFIG_ACPI
 586 #define CONFIG_DRM_I915_KMS
 587 #undef  CONFIG_INTEL_IOMMU
 588 #endif
 589
 590 #ifdef COMPAT_FREEBSD32
 591 #define CONFIG_COMPAT
 592 #endif
 593
 594 #ifndef __arm__
 595 #define CONFIG_AGP      1
 596 #define CONFIG_MTRR     1
 597 #endif
 598
 599 #define CONFIG_FB       1
 600 extern const char *fb_mode_option;
 601
 602 #undef  CONFIG_DEBUG_FS
 603 #undef  CONFIG_VGA_CONSOLE
 604
 605 #define EXPORT_SYMBOL(x)
 606 #define EXPORT_SYMBOL_GPL(x)
 607 #define MODULE_AUTHOR(author)
 608 #define MODULE_DESCRIPTION(desc)
 609 #define MODULE_LICENSE(license)
 610 #define MODULE_PARM_DESC(name, desc)
 611 #define MODULE_DEVICE_TABLE(name, list)
 612 #define module_param_named(name, var, type, perm)
 613
 614 #define printk          printf
 615 #define pr_err          DRM_ERROR
 616 #define pr_warn         DRM_WARNING
 617 #define pr_warn_once    DRM_WARNING
 618 #define KERN_DEBUG      ""
 619
 620 /* I2C compatibility. */
 621 #define I2C_M_RD        IIC_M_RD
 622 #define I2C_M_WR        IIC_M_WR
 623 #define I2C_M_NOSTART   IIC_M_NOSTART
 624
 625 struct fb_info *        framebuffer_alloc(void);
 626 void                    framebuffer_release(struct fb_info *info);
 627
 628 #define console_lock()
 629 #define console_unlock()
 630 #define console_trylock()       true
 631
 632 #define PM_EVENT_SUSPEND        0x0002
 633 #define PM_EVENT_QUIESCE        0x0008
 634 #define PM_EVENT_PRETHAW        PM_EVENT_QUIESCE
 635
 636 typedef struct pm_message {
 637         int event;
 638 } pm_message_t;
 639
 640 static inline int
 641 pci_read_config_byte(device_t kdev, int where, u8 *val)
 642 {
 643
 644         *val = (u8)pci_read_config(kdev, where, 1);
 645         return (0);
 646 }
 647
 648 static inline int
 649 pci_write_config_byte(device_t kdev, int where, u8 val)
 650 {
 651
 652         pci_write_config(kdev, where, val, 1);
 653         return (0);
 654 }
 655
 656 static inline int
 657 pci_read_config_word(device_t kdev, int where, uint16_t *val)
 658 {
 659
 660         *val = (uint16_t)pci_read_config(kdev, where, 2);
 661         return (0);
 662 }
 663
 664 static inline int
 665 pci_write_config_word(device_t kdev, int where, uint16_t val)
 666 {
 667
 668         pci_write_config(kdev, where, val, 2);
 669         return (0);
 670 }
 671
 672 static inline int
 673 pci_read_config_dword(device_t kdev, int where, uint32_t *val)
 674 {
 675
 676         *val = (uint32_t)pci_read_config(kdev, where, 4);
 677         return (0);
 678 }
 679
 680 static inline int
 681 pci_write_config_dword(device_t kdev, int where, uint32_t val)
 682 {
 683
 684         pci_write_config(kdev, where, val, 4);
 685         return (0);
 686 }
 687
 688 static inline void
 689 on_each_cpu(void callback(void *data), void *data, int wait)
 690 {
 691
 692         smp_rendezvous(NULL, callback, NULL, data);
 693 }
 694
 695 void    hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
 696             int groupsize, char *linebuf, size_t linebuflen, bool ascii);
 697
 698 #define KIB_NOTYET()                                                    \
 699 do {                                                                    \
 700         if (drm_debug && drm_notyet)                                    \
 701                 printf("NOTYET: %s at %s:%d\n", __func__, __FILE__, __LINE__); \
 702 } while (0)
 703
 704 #endif /* _DRM_OS_FREEBSD_H_ */