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
roundup_pow_of_two(unsigned long x)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
ror32(uint32_t word,unsigned int shift)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
__get_unaligned_cpu32(const void * p)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
get_unaligned_le32(const void * p)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
__get_unaligned_le32(const u8 * p)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
get_unaligned_le32(const void * p)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
ilog2(unsigned long x)301 ilog2(unsigned long x)
302 {
303
304 return (flsl(x) - 1);
305 }
306
307 static inline int64_t
abs64(int64_t x)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
__copy_to_user(void __user * to,const void * from,unsigned long n)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
__put_user(size_t size,void * ptr,void * x)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
__copy_from_user(void * to,const void __user * from,unsigned long n)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
__get_user(size_t size,const void * ptr,void * x)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
__copy_to_user_inatomic(void __user * to,const void * from,unsigned n)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
__copy_from_user_inatomic(void * to,const void __user * from,unsigned long n)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
fault_in_multipages_readable(const char __user * uaddr,int size)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
fault_in_multipages_writeable(char __user * uaddr,int size)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
capable(enum __drm_capabilities cap)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
init_completion(struct completion * c)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
free_completion(struct completion * c)501 free_completion(struct completion *c)
502 {
503
504 mtx_destroy(&c->lock);
505 }
506
507 static inline void
complete_all(struct completion * c)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
wait_for_completion_interruptible_timeout(struct completion * c,unsigned long timeout)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
pci_read_config_byte(device_t kdev,int where,u8 * val)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
pci_write_config_byte(device_t kdev,int where,u8 val)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
pci_read_config_word(device_t kdev,int where,uint16_t * val)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
pci_write_config_word(device_t kdev,int where,uint16_t val)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
pci_read_config_dword(device_t kdev,int where,uint32_t * val)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
pci_write_config_dword(device_t kdev,int where,uint32_t val)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
on_each_cpu(void callback (void * data),void * data,int wait)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