Subversion Repositories Kolibri OS

Rev

Rev 4110 | Rev 4292 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #ifndef _LINUX_KERNEL_H
  2. #define _LINUX_KERNEL_H
  3.  
  4. /*
  5.  * 'kernel.h' contains some often-used function prototypes etc
  6.  */
  7.  
  8. #ifdef __KERNEL__
  9.  
  10. #include <stdarg.h>
  11. #include <linux/stddef.h>
  12. #include <linux/types.h>
  13. #include <linux/compiler.h>
  14. #include <linux/bitops.h>
  15. #include <linux/errno.h>
  16. #include <linux/typecheck.h>
  17.  
  18. #define __init
  19.  
  20. #define USHRT_MAX       ((u16)(~0U))
  21. #define SHRT_MAX        ((s16)(USHRT_MAX>>1))
  22. #define SHRT_MIN        ((s16)(-SHRT_MAX - 1))
  23. #define INT_MAX     ((int)(~0U>>1))
  24. #define INT_MIN     (-INT_MAX - 1)
  25. #define UINT_MAX    (~0U)
  26. #define LONG_MAX    ((long)(~0UL>>1))
  27. #define LONG_MIN    (-LONG_MAX - 1)
  28. #define ULONG_MAX   (~0UL)
  29. #define LLONG_MAX   ((long long)(~0ULL>>1))
  30. #define LLONG_MIN   (-LLONG_MAX - 1)
  31. #define ULLONG_MAX  (~0ULL)
  32. #define SIZE_MAX        (~(size_t)0)
  33.  
  34. #define ALIGN(x,a)      __ALIGN_MASK(x,(typeof(x))(a)-1)
  35. #define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
  36. #define PTR_ALIGN(p, a)     ((typeof(p))ALIGN((unsigned long)(p), (a)))
  37. #define IS_ALIGNED(x, a)        (((x) & ((typeof(x))(a) - 1)) == 0)
  38.  
  39.  
  40. #define __round_mask(x, y) ((__typeof__(x))((y)-1))
  41. #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
  42.  
  43. /* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
  44. #define roundup(x, y) (                                 \
  45. {                                                       \
  46.         const typeof(y) __y = y;                        \
  47.         (((x) + (__y - 1)) / __y) * __y;                \
  48. }                                                       \
  49. )
  50.  
  51. #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
  52. #define DIV_ROUND_UP_ULL(ll,d) \
  53.         ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
  54. #define DIV_ROUND_CLOSEST(x, divisor)(                  \
  55. {                                                       \
  56.          typeof(divisor) __divisor = divisor;            \
  57.          (((x) + ((__divisor) / 2)) / (__divisor));      \
  58. }                                                       \
  59. )
  60.  
  61.  
  62. #define clamp_t(type, val, min, max) ({         \
  63.         type __val = (val);                     \
  64.         type __min = (min);                     \
  65.         type __max = (max);                     \
  66.         __val = __val < __min ? __min: __val;   \
  67.         __val > __max ? __max: __val; })
  68.  
  69.  
  70.  
  71. /**
  72.  * upper_32_bits - return bits 32-63 of a number
  73.  * @n: the number we're accessing
  74.  *
  75.  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
  76.  * the "right shift count >= width of type" warning when that quantity is
  77.  * 32-bits.
  78.  */
  79. #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
  80.  
  81. /**
  82.  * lower_32_bits - return bits 0-31 of a number
  83.  * @n: the number we're accessing
  84.  */
  85. #define lower_32_bits(n) ((u32)(n))
  86.  
  87. #define KERN_EMERG      "<0>"   /* system is unusable                   */
  88. #define KERN_ALERT      "<1>"   /* action must be taken immediately     */
  89. #define KERN_CRIT       "<2>"   /* critical conditions                  */
  90. #define KERN_ERR        "<3>"   /* error conditions                     */
  91. #define KERN_WARNING    "<4>"   /* warning conditions                   */
  92. #define KERN_NOTICE     "<5>"   /* normal but significant condition     */
  93. #define KERN_INFO       "<6>"   /* informational                        */
  94. #define KERN_DEBUG      "<7>"   /* debug-level messages                 */
  95. extern const char hex_asc[];
  96. #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
  97. #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
  98.  
  99. static inline char *pack_hex_byte(char *buf, u8 byte)
  100. {
  101.         *buf++ = hex_asc_hi(byte);
  102.         *buf++ = hex_asc_lo(byte);
  103.         return buf;
  104. }
  105.  
  106. enum {
  107.     DUMP_PREFIX_NONE,
  108.     DUMP_PREFIX_ADDRESS,
  109.     DUMP_PREFIX_OFFSET
  110. };
  111.  
  112. int hex_to_bin(char ch);
  113. int hex2bin(u8 *dst, const char *src, size_t count);
  114.  
  115.  
  116. //int printk(const char *fmt, ...);
  117.  
  118. #define printk(fmt, arg...)    dbgprintf(fmt , ##arg)
  119.  
  120.  
  121. /*
  122.  * min()/max()/clamp() macros that also do
  123.  * strict type-checking.. See the
  124.  * "unnecessary" pointer comparison.
  125.  */
  126. #define min(x, y) ({                \
  127.     typeof(x) _min1 = (x);          \
  128.     typeof(y) _min2 = (y);          \
  129.     (void) (&_min1 == &_min2);      \
  130.     _min1 < _min2 ? _min1 : _min2; })
  131.  
  132. #define max(x, y) ({                \
  133.     typeof(x) _max1 = (x);          \
  134.     typeof(y) _max2 = (y);          \
  135.     (void) (&_max1 == &_max2);      \
  136.     _max1 > _max2 ? _max1 : _max2; })
  137.  
  138. #define min3(x, y, z) ({                        \
  139.         typeof(x) _min1 = (x);                  \
  140.         typeof(y) _min2 = (y);                  \
  141.         typeof(z) _min3 = (z);                  \
  142.         (void) (&_min1 == &_min2);              \
  143.         (void) (&_min1 == &_min3);              \
  144.         _min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
  145.                 (_min2 < _min3 ? _min2 : _min3); })
  146.  
  147. #define max3(x, y, z) ({                        \
  148.         typeof(x) _max1 = (x);                  \
  149.         typeof(y) _max2 = (y);                  \
  150.         typeof(z) _max3 = (z);                  \
  151.         (void) (&_max1 == &_max2);              \
  152.         (void) (&_max1 == &_max3);              \
  153.         _max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
  154.                 (_max2 > _max3 ? _max2 : _max3); })
  155.  
  156. /**
  157.  * min_not_zero - return the minimum that is _not_ zero, unless both are zero
  158.  * @x: value1
  159.  * @y: value2
  160.  */
  161. #define min_not_zero(x, y) ({                   \
  162.         typeof(x) __x = (x);                    \
  163.         typeof(y) __y = (y);                    \
  164.         __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
  165.  
  166. /**
  167.  * clamp - return a value clamped to a given range with strict typechecking
  168.  * @val: current value
  169.  * @min: minimum allowable value
  170.  * @max: maximum allowable value
  171.  *
  172.  * This macro does strict typechecking of min/max to make sure they are of the
  173.  * same type as val.  See the unnecessary pointer comparisons.
  174.  */
  175. #define clamp(val, min, max) ({                 \
  176.         typeof(val) __val = (val);              \
  177.         typeof(min) __min = (min);              \
  178.         typeof(max) __max = (max);              \
  179.         (void) (&__val == &__min);              \
  180.         (void) (&__val == &__max);              \
  181.         __val = __val < __min ? __min: __val;   \
  182.         __val > __max ? __max: __val; })
  183.  
  184. /*
  185.  * ..and if you can't take the strict
  186.  * types, you can specify one yourself.
  187.  *
  188.  * Or not use min/max/clamp at all, of course.
  189.  */
  190. #define min_t(type, x, y) ({            \
  191.     type __min1 = (x);          \
  192.     type __min2 = (y);          \
  193.     __min1 < __min2 ? __min1: __min2; })
  194.  
  195. #define max_t(type, x, y) ({            \
  196.     type __max1 = (x);          \
  197.     type __max2 = (y);          \
  198.     __max1 > __max2 ? __max1: __max2; })
  199.  
  200. /**
  201.  * container_of - cast a member of a structure out to the containing structure
  202.  * @ptr:    the pointer to the member.
  203.  * @type:   the type of the container struct this is embedded in.
  204.  * @member: the name of the member within the struct.
  205.  *
  206.  */
  207. #define container_of(ptr, type, member) ({          \
  208.     const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  209.     (type *)( (char *)__mptr - offsetof(type,member) );})
  210.  
  211.  
  212. static inline void *kcalloc(size_t n, size_t size, uint32_t flags)
  213. {
  214.         if (n != 0 && size > ULONG_MAX / n)
  215.                 return NULL;
  216.         return kzalloc(n * size, 0);
  217. }
  218.  
  219.  
  220. void free (void *ptr);
  221.  
  222. #endif /* __KERNEL__ */
  223.  
  224. typedef unsigned long   pgprotval_t;
  225.  
  226. typedef struct pgprot { pgprotval_t pgprot; } pgprot_t;
  227.  
  228. struct file
  229. {
  230.     struct page  **pages;         /* physical memory backend */
  231.     unsigned int   count;
  232.     unsigned int   allocated;
  233.     void           *vma;
  234. };
  235.  
  236. struct vm_area_struct {};
  237. struct address_space {};
  238.  
  239. struct device
  240. {
  241.     struct device   *parent;
  242.     void            *driver_data;
  243. };
  244.  
  245. static inline void dev_set_drvdata(struct device *dev, void *data)
  246. {
  247.     dev->driver_data = data;
  248. }
  249.  
  250. static inline void *dev_get_drvdata(struct device *dev)
  251. {
  252.     return dev->driver_data;
  253. }
  254.  
  255. #define preempt_disable()       do { } while (0)
  256. #define preempt_enable_no_resched() do { } while (0)
  257. #define preempt_enable()        do { } while (0)
  258. #define preempt_check_resched()     do { } while (0)
  259.  
  260. #define preempt_disable_notrace()       do { } while (0)
  261. #define preempt_enable_no_resched_notrace() do { } while (0)
  262. #define preempt_enable_notrace()        do { } while (0)
  263.  
  264. #define in_dbg_master() (0)
  265.  
  266. #define HZ 100
  267.  
  268. struct tvec_base;
  269.  
  270. struct timer_list {
  271.          struct list_head entry;
  272.          unsigned long expires;
  273.  
  274.          void (*function)(unsigned long);
  275.          unsigned long data;
  276.          u32  handle;
  277. };
  278.  
  279. #define setup_timer(_timer, _fn, _data)                                 \
  280.         do {                                                            \
  281.                 (_timer)->function = (_fn);                             \
  282.                 (_timer)->data = (_data);                               \
  283.                 (_timer)->handle = 0;                                   \
  284.         } while (0)
  285.  
  286.  
  287. struct timespec {
  288.     long tv_sec;                 /* seconds */
  289.     long tv_nsec;                /* nanoseconds */
  290. };
  291.  
  292.  
  293. #define build_mmio_read(name, size, type, reg, barrier)     \
  294. static inline type name(const volatile void __iomem *addr)  \
  295. { type ret; asm volatile("mov" size " %1,%0":reg (ret)      \
  296. :"m" (*(volatile type __force *)addr) barrier); return ret; }
  297.  
  298. #define build_mmio_write(name, size, type, reg, barrier) \
  299. static inline void name(type val, volatile void __iomem *addr) \
  300. { asm volatile("mov" size " %0,%1": :reg (val), \
  301. "m" (*(volatile type __force *)addr) barrier); }
  302.  
  303. build_mmio_read(readb, "b", unsigned char, "=q", :"memory")
  304. build_mmio_read(readw, "w", unsigned short, "=r", :"memory")
  305. build_mmio_read(readl, "l", unsigned int, "=r", :"memory")
  306.  
  307. build_mmio_read(__readb, "b", unsigned char, "=q", )
  308. build_mmio_read(__readw, "w", unsigned short, "=r", )
  309. build_mmio_read(__readl, "l", unsigned int, "=r", )
  310.  
  311. build_mmio_write(writeb, "b", unsigned char, "q", :"memory")
  312. build_mmio_write(writew, "w", unsigned short, "r", :"memory")
  313. build_mmio_write(writel, "l", unsigned int, "r", :"memory")
  314.  
  315. build_mmio_write(__writeb, "b", unsigned char, "q", )
  316. build_mmio_write(__writew, "w", unsigned short, "r", )
  317. build_mmio_write(__writel, "l", unsigned int, "r", )
  318.  
  319. #define readb_relaxed(a) __readb(a)
  320. #define readw_relaxed(a) __readw(a)
  321. #define readl_relaxed(a) __readl(a)
  322. #define __raw_readb __readb
  323. #define __raw_readw __readw
  324. #define __raw_readl __readl
  325.  
  326. #define __raw_writeb __writeb
  327. #define __raw_writew __writew
  328. #define __raw_writel __writel
  329.  
  330. static inline __u64 readq(const volatile void __iomem *addr)
  331. {
  332.         const volatile u32 __iomem *p = addr;
  333.         u32 low, high;
  334.  
  335.         low = readl(p);
  336.         high = readl(p + 1);
  337.  
  338.         return low + ((u64)high << 32);
  339. }
  340.  
  341. static inline void writeq(__u64 val, volatile void __iomem *addr)
  342. {
  343.         writel(val, addr);
  344.         writel(val >> 32, addr+4);
  345. }
  346.  
  347. #define swap(a, b) \
  348.         do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
  349.  
  350.  
  351. #define mmiowb() barrier()
  352.  
  353. #define dev_err(dev, format, arg...)            \
  354.         printk("Error %s " format, __func__ , ## arg)
  355.  
  356. #define dev_warn(dev, format, arg...)            \
  357.         printk("Warning %s " format, __func__ , ## arg)
  358.  
  359. #define dev_info(dev, format, arg...)       \
  360.         printk("Info %s " format , __func__, ## arg)
  361.  
  362. //#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
  363. #define BUILD_BUG_ON(condition)
  364.  
  365. struct page
  366. {
  367.     unsigned int addr;
  368. };
  369.  
  370. #define page_to_phys(page)    ((dma_addr_t)(page))
  371.  
  372. struct vm_fault {
  373.     unsigned int flags;             /* FAULT_FLAG_xxx flags */
  374.     pgoff_t pgoff;                  /* Logical page offset based on vma */
  375.     void __user *virtual_address;   /* Faulting virtual address */
  376.  
  377.     struct page *page;              /* ->fault handlers should return a
  378.                                      * page here, unless VM_FAULT_NOPAGE
  379.                                      * is set (which is also implied by
  380.                                      * VM_FAULT_ERROR).
  381.                                      */
  382. };
  383.  
  384. struct pagelist {
  385.     dma_addr_t    *page;
  386.     unsigned int   nents;
  387. };
  388.  
  389. #define page_cache_release(page)        FreePage(page_to_phys(page))
  390.  
  391. #define alloc_page(gfp_mask) (struct page*)AllocPage()
  392.  
  393. #define __free_page(page) FreePage(page_to_phys(page))
  394.  
  395. #define get_page(a)
  396. #define put_page(a)
  397. #define set_pages_uc(a,b)
  398. #define set_pages_wb(a,b)
  399.  
  400. #define pci_map_page(dev, page, offset, size, direction) \
  401.         (dma_addr_t)( (offset)+page_to_phys(page))
  402.  
  403. #define pci_unmap_page(dev, dma_address, size, direction)
  404.  
  405. #define GFP_TEMPORARY  0
  406. #define __GFP_NOWARN   0
  407. #define __GFP_NORETRY  0
  408. #define GFP_NOWAIT     0
  409.  
  410. #define IS_ENABLED(a)  0
  411.  
  412.  
  413. #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
  414.  
  415. #define RCU_INIT_POINTER(p, v) \
  416.         do { \
  417.                 p = (typeof(*v) __force __rcu *)(v); \
  418.         } while (0)
  419.  
  420.  
  421. #define rcu_dereference_raw(p)  ({ \
  422.                                 typeof(p) _________p1 = ACCESS_ONCE(p); \
  423.                                 (_________p1); \
  424.                                 })
  425. #define rcu_assign_pointer(p, v) \
  426.         ({ \
  427.                 if (!__builtin_constant_p(v) || \
  428.                     ((v) != NULL)) \
  429.                 (p) = (v); \
  430.         })
  431.  
  432.  
  433. unsigned int hweight16(unsigned int w);
  434.  
  435. #define cpufreq_quick_get_max(x) GetCpuFreq()
  436.  
  437. extern unsigned int tsc_khz;
  438.  
  439. #define on_each_cpu(func,info,wait)             \
  440.         ({                                      \
  441.                 func(info);                     \
  442.                 0;                              \
  443.         })
  444.  
  445.  
  446. #endif
  447.  
  448.