1 /** 2 * \file drm_os_freebsd.h 3 * OS abstraction macros. 4 */ 5 6 #include <sys/cdefs.h> 7 #ifndef _DRM_OS_FREEBSD_H_ 8 #define _DRM_OS_FREEBSD_H_ 9 10 #include <sys/fbio.h> 11 #include <sys/smp.h> 12 13 #if _BYTE_ORDER == _BIG_ENDIAN 14 #define __BIG_ENDIAN 4321 15 #else 16 #define __LITTLE_ENDIAN 1234 17 #endif 18 19 #ifdef __LP64__ 20 #define BITS_PER_LONG 64 21 #else 22 #define BITS_PER_LONG 32 23 #endif 24 25 #ifndef __user 26 #define __user 27 #endif 28 #ifndef __iomem 29 #define __iomem 30 #endif 31 #ifndef __always_unused 32 #define __always_unused 33 #endif 34 #ifndef __must_check 35 #define __must_check 36 #endif 37 #ifndef __force 38 #define __force 39 #endif 40 #ifndef uninitialized_var 41 #define uninitialized_var(x) x 42 #endif 43 44 #define cpu_to_le16(x) htole16(x) 45 #define le16_to_cpu(x) le16toh(x) 46 #define cpu_to_le32(x) htole32(x) 47 #define le32_to_cpu(x) le32toh(x) 48 49 #define cpu_to_be16(x) htobe16(x) 50 #define be16_to_cpu(x) be16toh(x) 51 #define cpu_to_be32(x) htobe32(x) 52 #define be32_to_cpu(x) be32toh(x) 53 #define be32_to_cpup(x) be32toh(*x) 54 55 typedef vm_paddr_t dma_addr_t; 56 typedef vm_paddr_t resource_size_t; 57 #define wait_queue_head_t atomic_t 58 59 typedef uint64_t u64; 60 typedef uint32_t u32; 61 typedef uint16_t u16; 62 typedef uint8_t u8; 63 typedef int64_t s64; 64 typedef int32_t s32; 65 typedef int16_t s16; 66 typedef int8_t s8; 67 typedef uint16_t __le16; 68 typedef uint32_t __le32; 69 typedef uint64_t __le64; 70 typedef uint16_t __be16; 71 typedef uint32_t __be32; 72 typedef uint64_t __be64; 73 74 #define DRM_IRQ_ARGS void *arg 75 typedef void irqreturn_t; 76 #define IRQ_HANDLED /* nothing */ 77 #define IRQ_NONE /* nothing */ 78 79 #define __init 80 #define __exit 81 82 #define BUILD_BUG_ON(x) CTASSERT(!(x)) 83 #define BUILD_BUG_ON_NOT_POWER_OF_2(x) 84 85 #ifndef WARN 86 #define WARN(condition, format, ...) ({ \ 87 int __ret_warn_on = !!(condition); \ 88 if (unlikely(__ret_warn_on)) \ 89 DRM_ERROR(format, ##__VA_ARGS__); \ 90 unlikely(__ret_warn_on); \ 91 }) 92 #endif 93 #define WARN_ONCE(condition, format, ...) \ 94 WARN(condition, format, ##__VA_ARGS__) 95 #define WARN_ON(cond) WARN(cond, "WARN ON: " #cond) 96 #define WARN_ON_SMP(cond) WARN_ON(cond) 97 #define BUG() panic("BUG") 98 #define BUG_ON(cond) KASSERT(!(cond), ("BUG ON: " #cond " -> 0x%jx", (uintmax_t)(cond))) 99 #define unlikely(x) __builtin_expect(!!(x), 0) 100 #define likely(x) __builtin_expect(!!(x), 1) 101 #define container_of(ptr, type, member) ({ \ 102 __typeof( ((type *)0)->member ) *__mptr = (ptr); \ 103 (type *)( (char *)__mptr - offsetof(type,member) );}) 104 105 #define KHZ2PICOS(a) (1000000000UL/(a)) 106 107 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 108 109 #define HZ hz 110 #define DRM_HZ hz 111 #define DRM_CURRENTPID curthread->td_proc->p_pid 112 #define DRM_SUSER(p) (priv_check(p, PRIV_DRIVER) == 0) 113 #define udelay(usecs) DELAY(usecs) 114 #define mdelay(msecs) do { int loops = (msecs); \ 115 while (loops--) DELAY(1000); \ 116 } while (0) 117 #define DRM_UDELAY(udelay) DELAY(udelay) 118 #define drm_msleep(x, msg) pause((msg), ((int64_t)(x)) * hz / 1000) 119 #define DRM_MSLEEP(msecs) drm_msleep((msecs), "drm_msleep") 120 #define get_seconds() time_second 121 122 #define ioread8(addr) *(volatile uint8_t *)((char *)addr) 123 #define ioread16(addr) *(volatile uint16_t *)((char *)addr) 124 #define ioread32(addr) *(volatile uint32_t *)((char *)addr) 125 126 #define iowrite8(data, addr) *(volatile uint8_t *)((char *)addr) = data; 127 #define iowrite16(data, addr) *(volatile uint16_t *)((char *)addr) = data; 128 #define iowrite32(data, addr) *(volatile uint32_t *)((char *)addr) = data; 129 130 #define DRM_READ8(map, offset) \ 131 *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) + \ 132 (vm_offset_t)(offset)) 133 #define DRM_READ16(map, offset) \ 134 le16toh(*(volatile u_int16_t *)(((vm_offset_t)(map)->handle) + \ 135 (vm_offset_t)(offset))) 136 #define DRM_READ32(map, offset) \ 137 le32toh(*(volatile u_int32_t *)(((vm_offset_t)(map)->handle) + \ 138 (vm_offset_t)(offset))) 139 #define DRM_READ64(map, offset) \ 140 le64toh(*(volatile u_int64_t *)(((vm_offset_t)(map)->handle) + \ 141 (vm_offset_t)(offset))) 142 #define DRM_WRITE8(map, offset, val) \ 143 *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) + \ 144 (vm_offset_t)(offset)) = val 145 #define DRM_WRITE16(map, offset, val) \ 146 *(volatile u_int16_t *)(((vm_offset_t)(map)->handle) + \ 147 (vm_offset_t)(offset)) = htole16(val) 148 #define DRM_WRITE32(map, offset, val) \ 149 *(volatile u_int32_t *)(((vm_offset_t)(map)->handle) + \ 150 (vm_offset_t)(offset)) = htole32(val) 151 #define DRM_WRITE64(map, offset, val) \ 152 *(volatile u_int64_t *)(((vm_offset_t)(map)->handle) + \ 153 (vm_offset_t)(offset)) = htole64(val) 154 155 #if !defined(__arm__) 156 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__) || defined(__aarch64__) 157 #define DRM_MSG "This code is deprecated. Install the graphics/drm-kmod pkg\n" 158 #else 159 #define DRM_MSG "This code is deprecated." 160 #endif 161 162 #define DRM_OBSOLETE(dev) \ 163 do { \ 164 device_printf(dev, "=======================================================\n"); \ 165 device_printf(dev, DRM_MSG); \ 166 device_printf(dev, "=======================================================\n"); \ 167 gone_in_dev(dev, 13, "drm2 drivers"); \ 168 } while (0) 169 #endif /* __arm__ */ 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_ */ 719