2 * \file drm_os_freebsd.h
3 * OS abstraction macros.
9 #ifndef _DRM_OS_FREEBSD_H_
10 #define _DRM_OS_FREEBSD_H_
15 #if _BYTE_ORDER == _BIG_ENDIAN
16 #define __BIG_ENDIAN 4321
18 #define __LITTLE_ENDIAN 1234
22 #define BITS_PER_LONG 64
24 #define BITS_PER_LONG 32
33 #ifndef __always_unused
34 #define __always_unused
42 #ifndef uninitialized_var
43 #define uninitialized_var(x) x
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)
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)
57 typedef vm_paddr_t dma_addr_t;
58 typedef vm_paddr_t resource_size_t;
59 #define wait_queue_head_t atomic_t
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;
76 #define DRM_IRQ_ARGS void *arg
77 typedef void irqreturn_t;
78 #define IRQ_HANDLED /* nothing */
79 #define IRQ_NONE /* nothing */
84 #define BUILD_BUG_ON(x) CTASSERT(!(x))
85 #define BUILD_BUG_ON_NOT_POWER_OF_2(x)
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); \
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) );})
107 #define KHZ2PICOS(a) (1000000000UL/(a))
109 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
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); \
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
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)
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;
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)
157 /* DRM_READMEMORYBARRIER() prevents reordering of reads.
158 * DRM_WRITEMEMORYBARRIER() prevents reordering of writes.
159 * DRM_MEMORYBARRIER() prevents reordering of reads and writes.
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()
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))
175 #define __set_bit(n, s) set_bit((n), (s))
176 #define __clear_bit(n, s) clear_bit((n), (s))
178 #define min_t(type, x, y) ({ \
181 __min1 < __min2 ? __min1 : __min2; })
183 #define max_t(type, x, y) ({ \
186 __max1 > __max2 ? __max1 : __max2; })
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))
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))
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. */
201 #define KTR_DRM KTR_DEV
202 #define KTR_DRM_REG KTR_SPARE3
204 #define DRM_AGP_KERN struct agp_info
205 #define DRM_AGP_MEM void
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
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)
223 static inline unsigned long
224 roundup_pow_of_two(unsigned long x)
227 return (1UL << flsl(x - 1));
231 * ror32 - rotate a 32-bit value right
232 * @word: value to rotate
233 * @shift: bits to roll
235 * Source: include/linux/bitops.h
237 static inline uint32_t
238 ror32(uint32_t word, unsigned int shift)
241 return (word >> shift) | (word << (32 - shift));
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; })
251 #if _BYTE_ORDER == _LITTLE_ENDIAN
252 /* Taken from linux/include/linux/unaligned/le_struct.h. */
253 struct __una_u32 { u32 x; } __packed;
256 __get_unaligned_cpu32(const void *p)
258 const struct __una_u32 *ptr = (const struct __una_u32 *)p;
264 get_unaligned_le32(const void *p)
267 return (__get_unaligned_cpu32((const u8 *)p));
270 /* Taken from linux/include/linux/unaligned/le_byteshift.h. */
272 __get_unaligned_le32(const u8 *p)
275 return (p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24);
279 get_unaligned_le32(const void *p)
282 return (__get_unaligned_le32((const u8 *)p));
286 static inline unsigned long
287 ilog2(unsigned long x)
290 return (flsl(x) - 1);
293 static inline int64_t
297 return (x < 0 ? -x : x);
300 int64_t timeval_to_ns(const struct timeval *tv);
301 struct timeval ns_to_timeval(const int64_t nsec);
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)
307 #define drm_get_device_from_kdev(_kdev) (((struct drm_minor *)(_kdev)->si_drv1)->dev)
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)
316 __copy_to_user(void __user *to, const void *from, unsigned long n)
318 return (copyout(from, to, n) != 0 ? n : 0);
320 #define copy_to_user(to, from, n) __copy_to_user((to), (from), (n))
323 __put_user(size_t size, void *ptr, void *x)
326 size = copy_to_user(ptr, x, size);
328 return (size ? -EFAULT : size);
330 #define put_user(x, ptr) __put_user(sizeof(*ptr), (ptr), &(x))
332 static inline unsigned long
333 __copy_from_user(void *to, const void __user *from, unsigned long n)
335 return ((copyin(__DECONST(void *, from), to, n) != 0 ? n : 0));
337 #define copy_from_user(to, from, n) __copy_from_user((to), (from), (n))
340 __get_user(size_t size, const void *ptr, void *x)
343 size = copy_from_user(x, ptr, size);
345 return (size ? -EFAULT : size);
347 #define get_user(x, ptr) __get_user(sizeof(*ptr), (ptr), &(x))
350 __copy_to_user_inatomic(void __user *to, const void *from, unsigned n)
353 return (copyout_nofault(from, to, n) != 0 ? n : 0);
355 #define __copy_to_user_inatomic_nocache(to, from, n) \
356 __copy_to_user_inatomic((to), (from), (n))
358 static inline unsigned long
359 __copy_from_user_inatomic(void *to, const void __user *from,
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.
370 return ((copyin_nofault(__DECONST(void *, from), to, n) != 0 ? n : 0));
372 #define __copy_from_user_inatomic_nocache(to, from, n) \
373 __copy_from_user_inatomic((to), (from), (n))
376 fault_in_multipages_readable(const char __user *uaddr, int size)
380 const char __user *end = uaddr + size - 1;
382 if (unlikely(size == 0))
385 while (uaddr <= end) {
386 ret = -copyin(uaddr, &c, 1);
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);
402 fault_in_multipages_writeable(char __user *uaddr, int size)
405 char __user *end = uaddr + size - 1;
407 if (unlikely(size == 0))
411 * Writing zeroes into userspace here is OK, because we know that if
412 * the zero gets there, we'll be overwriting it.
414 while (uaddr <= end) {
415 ret = subyte(uaddr, 0);
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);
429 enum __drm_capabilities {
434 capable(enum __drm_capabilities cap)
439 return DRM_SUSER(curthread);
441 panic("%s: unhandled capability: %0x", __func__, cap);
446 #define to_user_ptr(x) ((void *)(uintptr_t)(x))
447 #define sigemptyset(set) SIGEMPTYSET(set)
448 #define sigaddset(set, sig) SIGADDSET(set, sig)
450 #define DRM_LOCK(dev) sx_xlock(&(dev)->dev_struct_lock)
451 #define DRM_UNLOCK(dev) sx_xunlock(&(dev)->dev_struct_lock)
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 */
464 #define getrawmonotonic(ts) getnanouptime(ts)
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)
476 #define INIT_COMPLETION(c) ((c).done = 0);
479 init_completion(struct completion *c)
482 mtx_init(&c->lock, "drmcompl", NULL, MTX_DEF);
487 free_completion(struct completion *c)
490 mtx_destroy(&c->lock);
494 complete_all(struct completion *c)
499 mtx_unlock(&c->lock);
504 wait_for_completion_interruptible_timeout(struct completion *c,
505 unsigned long timeout)
507 unsigned long start_jiffies, elapsed_jiffies;
508 bool timeout_expired = false, awakened = false;
511 start_jiffies = ticks;
514 while (c->done == 0 && !timeout_expired) {
515 ret = -msleep(c, &c->lock, PCATCH, "drmwco", timeout);
518 timeout_expired = true;
530 mtx_unlock(&c->lock);
533 elapsed_jiffies = ticks - start_jiffies;
534 ret = timeout > elapsed_jiffies ? timeout - elapsed_jiffies : 1;
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);
563 #define simple_strtol(a, b, c) strtol((a), (b), (c))
565 typedef struct drm_pci_id_list
578 #define CONFIG_X86_64 1
581 #define CONFIG_IA64 1
584 #if defined(__i386__) || defined(__amd64__)
586 #define CONFIG_DRM_I915_KMS
587 #undef CONFIG_INTEL_IOMMU
590 #ifdef COMPAT_FREEBSD32
591 #define CONFIG_COMPAT
596 #define CONFIG_MTRR 1
600 extern const char *fb_mode_option;
602 #undef CONFIG_DEBUG_FS
603 #undef CONFIG_VGA_CONSOLE
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)
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 ""
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
625 struct fb_info * framebuffer_alloc(void);
626 void framebuffer_release(struct fb_info *info);
628 #define console_lock()
629 #define console_unlock()
630 #define console_trylock() true
632 #define PM_EVENT_SUSPEND 0x0002
633 #define PM_EVENT_QUIESCE 0x0008
634 #define PM_EVENT_PRETHAW PM_EVENT_QUIESCE
636 typedef struct pm_message {
641 pci_read_config_byte(device_t kdev, int where, u8 *val)
644 *val = (u8)pci_read_config(kdev, where, 1);
649 pci_write_config_byte(device_t kdev, int where, u8 val)
652 pci_write_config(kdev, where, val, 1);
657 pci_read_config_word(device_t kdev, int where, uint16_t *val)
660 *val = (uint16_t)pci_read_config(kdev, where, 2);
665 pci_write_config_word(device_t kdev, int where, uint16_t val)
668 pci_write_config(kdev, where, val, 2);
673 pci_read_config_dword(device_t kdev, int where, uint32_t *val)
676 *val = (uint32_t)pci_read_config(kdev, where, 4);
681 pci_write_config_dword(device_t kdev, int where, uint32_t val)
684 pci_write_config(kdev, where, val, 4);
689 on_each_cpu(void callback(void *data), void *data, int wait)
692 smp_rendezvous(NULL, callback, NULL, data);
695 void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
696 int groupsize, char *linebuf, size_t linebuflen, bool ascii);
698 #define KIB_NOTYET() \
700 if (drm_debug && drm_notyet) \
701 printf("NOTYET: %s at %s:%d\n", __func__, __FILE__, __LINE__); \
704 #endif /* _DRM_OS_FREEBSD_H_ */