Subversion Repositories Kolibri OS

Rev

Rev 4125 | Rev 4559 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1408 serge 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 
11
#include 
12
#include 
13
#include 
1970 serge 14
#include 
4110 Serge 15
#include 
2967 Serge 16
#include 
17
 
18
#define __init
19
 
1964 serge 20
#define USHRT_MAX	((u16)(~0U))
21
#define SHRT_MAX	((s16)(USHRT_MAX>>1))
22
#define SHRT_MIN	((s16)(-SHRT_MAX - 1))
1408 serge 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)
3031 serge 32
#define SIZE_MAX	(~(size_t)0)
1408 serge 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
 
3747 Serge 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
 
3039 serge 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
)
2967 Serge 50
 
51
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
4103 Serge 52
#define DIV_ROUND_UP_ULL(ll,d) \
53
        ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
2967 Serge 54
#define DIV_ROUND_CLOSEST(x, divisor)(                  \
55
{                                                       \
56
         typeof(divisor) __divisor = divisor;            \
57
         (((x) + ((__divisor) / 2)) / (__divisor));      \
58
}                                                       \
59
)
60
 
4103 Serge 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
 
1408 serge 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                 */
1970 serge 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]
1408 serge 98
 
1970 serge 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
 
3480 Serge 106
enum {
107
    DUMP_PREFIX_NONE,
108
    DUMP_PREFIX_ADDRESS,
109
    DUMP_PREFIX_OFFSET
110
};
1970 serge 111
 
3480 Serge 112
int hex_to_bin(char ch);
113
int hex2bin(u8 *dst, const char *src, size_t count);
1970 serge 114
 
3480 Serge 115
 
1408 serge 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
 
1970 serge 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
 
1408 serge 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
 
1968 serge 219
 
1412 serge 220
void free (void *ptr);
221
 
1408 serge 222
#endif /* __KERNEL__ */
223
 
224
typedef unsigned long   pgprotval_t;
225
 
226
typedef struct pgprot { pgprotval_t pgprot; } pgprot_t;
227
 
3262 Serge 228
struct file
229
{
230
    struct page  **pages;         /* physical memory backend */
231
    unsigned int   count;
232
    unsigned int   allocated;
233
    void           *vma;
234
};
235
 
1408 serge 236
struct vm_area_struct {};
237
struct address_space {};
238
 
1430 serge 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
 
1408 serge 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
 
1964 serge 264
#define in_dbg_master() (0)
1408 serge 265
 
2005 serge 266
#define HZ 100
267
 
2967 Serge 268
struct tvec_base;
2005 serge 269
 
2967 Serge 270
struct timer_list {
271
         struct list_head entry;
272
         unsigned long expires;
273
 
274
         void (*function)(unsigned long);
275
         unsigned long data;
4125 Serge 276
         u32  handle;
2967 Serge 277
};
278
 
4125 Serge 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
 
4292 Serge 286
int del_timer(struct timer_list *timer);
4125 Serge 287
 
4292 Serge 288
# define del_timer_sync(t)              del_timer(t)
289
 
2967 Serge 290
struct timespec {
291
    long tv_sec;                 /* seconds */
292
    long tv_nsec;                /* nanoseconds */
293
};
294
 
295
 
4292 Serge 296
#define mb()    asm volatile("mfence" : : : "memory")
297
#define rmb()   asm volatile("lfence" : : : "memory")
298
#define wmb()   asm volatile("sfence" : : : "memory")
299
 
300
 
2967 Serge 301
#define build_mmio_read(name, size, type, reg, barrier)     \
302
static inline type name(const volatile void __iomem *addr)  \
303
{ type ret; asm volatile("mov" size " %1,%0":reg (ret)      \
304
:"m" (*(volatile type __force *)addr) barrier); return ret; }
305
 
306
#define build_mmio_write(name, size, type, reg, barrier) \
307
static inline void name(type val, volatile void __iomem *addr) \
308
{ asm volatile("mov" size " %0,%1": :reg (val), \
309
"m" (*(volatile type __force *)addr) barrier); }
310
 
311
build_mmio_read(readb, "b", unsigned char, "=q", :"memory")
312
build_mmio_read(readw, "w", unsigned short, "=r", :"memory")
313
build_mmio_read(readl, "l", unsigned int, "=r", :"memory")
314
 
315
build_mmio_read(__readb, "b", unsigned char, "=q", )
316
build_mmio_read(__readw, "w", unsigned short, "=r", )
317
build_mmio_read(__readl, "l", unsigned int, "=r", )
318
 
319
build_mmio_write(writeb, "b", unsigned char, "q", :"memory")
320
build_mmio_write(writew, "w", unsigned short, "r", :"memory")
321
build_mmio_write(writel, "l", unsigned int, "r", :"memory")
322
 
323
build_mmio_write(__writeb, "b", unsigned char, "q", )
324
build_mmio_write(__writew, "w", unsigned short, "r", )
325
build_mmio_write(__writel, "l", unsigned int, "r", )
326
 
327
#define readb_relaxed(a) __readb(a)
328
#define readw_relaxed(a) __readw(a)
329
#define readl_relaxed(a) __readl(a)
330
#define __raw_readb __readb
331
#define __raw_readw __readw
332
#define __raw_readl __readl
333
 
334
#define __raw_writeb __writeb
335
#define __raw_writew __writew
336
#define __raw_writel __writel
337
 
338
static inline __u64 readq(const volatile void __iomem *addr)
339
{
340
        const volatile u32 __iomem *p = addr;
341
        u32 low, high;
342
 
343
        low = readl(p);
344
        high = readl(p + 1);
345
 
346
        return low + ((u64)high << 32);
347
}
348
 
349
static inline void writeq(__u64 val, volatile void __iomem *addr)
350
{
351
        writel(val, addr);
352
        writel(val >> 32, addr+4);
353
}
354
 
3031 serge 355
#define swap(a, b) \
356
        do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
2967 Serge 357
 
3031 serge 358
 
2967 Serge 359
#define mmiowb() barrier()
360
 
361
#define dev_err(dev, format, arg...)            \
362
        printk("Error %s " format, __func__ , ## arg)
363
 
364
#define dev_warn(dev, format, arg...)            \
365
        printk("Warning %s " format, __func__ , ## arg)
366
 
367
#define dev_info(dev, format, arg...)       \
368
        printk("Info %s " format , __func__, ## arg)
369
 
3480 Serge 370
//#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
371
#define BUILD_BUG_ON(condition)
2967 Serge 372
 
373
struct page
374
{
375
    unsigned int addr;
376
};
377
 
3243 Serge 378
#define page_to_phys(page)    ((dma_addr_t)(page))
2967 Serge 379
 
380
struct vm_fault {
381
    unsigned int flags;             /* FAULT_FLAG_xxx flags */
382
    pgoff_t pgoff;                  /* Logical page offset based on vma */
383
    void __user *virtual_address;   /* Faulting virtual address */
384
 
385
    struct page *page;              /* ->fault handlers should return a
386
                                     * page here, unless VM_FAULT_NOPAGE
387
                                     * is set (which is also implied by
388
                                     * VM_FAULT_ERROR).
389
                                     */
390
};
391
 
3031 serge 392
struct pagelist {
393
    dma_addr_t    *page;
394
    unsigned int   nents;
395
};
2967 Serge 396
 
3391 Serge 397
#define page_cache_release(page)        FreePage(page_to_phys(page))
3243 Serge 398
 
399
#define alloc_page(gfp_mask) (struct page*)AllocPage()
400
 
3391 Serge 401
#define __free_page(page) FreePage(page_to_phys(page))
402
 
403
#define get_page(a)
404
#define put_page(a)
405
#define set_pages_uc(a,b)
406
#define set_pages_wb(a,b)
407
 
408
#define pci_map_page(dev, page, offset, size, direction) \
409
        (dma_addr_t)( (offset)+page_to_phys(page))
410
 
411
#define pci_unmap_page(dev, dma_address, size, direction)
412
 
413
#define GFP_TEMPORARY  0
414
#define __GFP_NOWARN   0
415
#define __GFP_NORETRY  0
416
#define GFP_NOWAIT     0
417
 
418
#define IS_ENABLED(a)  0
419
 
420
 
421
#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
422
 
423
#define RCU_INIT_POINTER(p, v) \
424
        do { \
425
                p = (typeof(*v) __force __rcu *)(v); \
426
        } while (0)
427
 
428
 
429
#define rcu_dereference_raw(p)  ({ \
430
                                typeof(p) _________p1 = ACCESS_ONCE(p); \
431
                                (_________p1); \
432
                                })
433
#define rcu_assign_pointer(p, v) \
434
        ({ \
435
                if (!__builtin_constant_p(v) || \
436
                    ((v) != NULL)) \
437
                (p) = (v); \
438
        })
439
 
3482 Serge 440
 
441
unsigned int hweight16(unsigned int w);
442
 
443
#define cpufreq_quick_get_max(x) GetCpuFreq()
444
 
445
extern unsigned int tsc_khz;
446
 
3747 Serge 447
#define on_each_cpu(func,info,wait)             \
448
        ({                                      \
449
                func(info);                     \
450
                0;                              \
451
        })
452
 
453
 
1408 serge 454
#endif
455