Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6934 → Rev 6933

/drivers/include/asm/timex.h
File deleted
/drivers/include/asm/vga.h
File deleted
/drivers/include/drm/drmP.h
919,8 → 919,7
#endif
 
extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
struct drm_gem_object *obj,
int flags);
struct drm_gem_object *obj, int flags);
extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
struct drm_file *file_priv, uint32_t handle, uint32_t flags,
int *prime_fd);
/drivers/include/linux/timer.h
File deleted
/drivers/include/linux/uaccess.h
File deleted
/drivers/include/linux/clocksource.h
13,7 → 13,6
#include <linux/time.h>
#include <linux/list.h>
#include <linux/cache.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <asm/div64.h>
#include <asm/io.h>
/drivers/include/linux/compiler-gcc.h
251,9 → 251,7
#endif
#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
 
#if GCC_VERSION >= 70000
#define KASAN_ABI_VERSION 5
#elif GCC_VERSION >= 50000
#if GCC_VERSION >= 50000
#define KASAN_ABI_VERSION 4
#elif GCC_VERSION >= 40902
#define KASAN_ABI_VERSION 3
/drivers/include/linux/scatterlist.h
5,7 → 5,6
#include <linux/types.h>
#include <linux/bug.h>
#include <linux/mm.h>
#include <asm/io.h>
 
struct scatterlist {
#ifdef CONFIG_DEBUG_SG
/drivers/include/linux/timex.h
53,8 → 53,6
#ifndef _LINUX_TIMEX_H
#define _LINUX_TIMEX_H
 
#include <uapi/linux/timex.h>
 
#define ADJ_ADJTIME 0x8000 /* switch between adjtime/adjtimex modes */
#define ADJ_OFFSET_SINGLESHOT 0x0001 /* old-fashioned adjtime */
#define ADJ_OFFSET_READONLY 0x2000 /* read-only adjtime */
61,7 → 59,6
#include <linux/compiler.h>
#include <linux/types.h>
 
#include <asm/timex.h>
 
#ifndef random_get_entropy
/*
150,9 → 147,8
#define NTP_INTERVAL_FREQ (HZ)
#define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 
extern int do_adjtimex(struct timex *);
extern void hardpps(const struct timespec64 *, const struct timespec64 *);
 
 
int read_current_timer(unsigned long *timer_val);
void ntp_notify_cmos_timer(void);
 
/drivers/include/linux/swap.h
2,9 → 2,6
#define _LINUX_SWAP_H
 
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/atomic.h>
 
struct notifier_block;
 
/drivers/include/linux/file.h
12,11 → 12,5
struct file;
 
extern void fput(struct file *);
struct fd {
struct file *file;
unsigned int flags;
};
#define FDPUT_FPUT 1
#define FDPUT_POS_UNLOCK 2
extern struct file *fget(unsigned int fd);
#endif /* __LINUX_FILE_H */
/drivers/include/linux/vmalloc.h
4,8 → 4,6
#include <linux/spinlock.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/rbtree.h>
 
struct vm_area_struct; /* vma defining user mapping in mm_types.h */
 
/* bits in flags of vmalloc's vm_struct below */
/drivers/include/linux/kernel.h
201,27 → 201,27
 
/**
* abs - return absolute value of an argument
* @x: the value. If it is unsigned type, it is converted to signed type first.
* char is treated as if it was signed (regardless of whether it really is)
* but the macro's return type is preserved as char.
* @x: the value. If it is unsigned type, it is converted to signed type first
* (s64, long or int depending on its size).
*
* Return: an absolute value of x.
* Return: an absolute value of x. If x is 64-bit, macro's return type is s64,
* otherwise it is signed long.
*/
#define abs(x) __abs_choose_expr(x, long long, \
__abs_choose_expr(x, long, \
__abs_choose_expr(x, int, \
__abs_choose_expr(x, short, \
__abs_choose_expr(x, char, \
__builtin_choose_expr( \
__builtin_types_compatible_p(typeof(x), char), \
(char)({ signed char __x = (x); __x<0?-__x:__x; }), \
((void)0)))))))
#define abs(x) __builtin_choose_expr(sizeof(x) == sizeof(s64), ({ \
s64 __x = (x); \
(__x < 0) ? -__x : __x; \
}), ({ \
long ret; \
if (sizeof(x) == sizeof(long)) { \
long __x = (x); \
ret = (__x < 0) ? -__x : __x; \
} else { \
int __x = (x); \
ret = (__x < 0) ? -__x : __x; \
} \
ret; \
}))
 
#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \
__builtin_types_compatible_p(typeof(x), signed type) || \
__builtin_types_compatible_p(typeof(x), unsigned type), \
({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
 
/**
* reciprocal_scale - "scale" a value into range [0, ep_ro)
* @val: value
440,7 → 440,7
 
#define do_trace_printk(fmt, args...) \
do { \
static const char *trace_printk_fmt __used \
static const char *trace_printk_fmt \
__attribute__((section("__trace_printk_fmt"))) = \
__builtin_constant_p(fmt) ? fmt : NULL; \
\
484,7 → 484,7
*/
 
#define trace_puts(str) ({ \
static const char *trace_printk_fmt __used \
static const char *trace_printk_fmt \
__attribute__((section("__trace_printk_fmt"))) = \
__builtin_constant_p(str) ? str : NULL; \
\
506,7 → 506,7
#define ftrace_vprintk(fmt, vargs) \
do { \
if (__builtin_constant_p(fmt)) { \
static const char *trace_printk_fmt __used \
static const char *trace_printk_fmt \
__attribute__((section("__trace_printk_fmt"))) = \
__builtin_constant_p(fmt) ? fmt : NULL; \
\
/drivers/include/linux/workqueue.h
5,7 → 5,7
#ifndef _LINUX_WORKQUEUE_H
#define _LINUX_WORKQUEUE_H
 
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/linkage.h>
#include <linux/bitops.h>
#include <linux/lockdep.h>
/drivers/include/linux/pci.h
59,11 → 59,6
struct kobject kobj;
};
 
static inline const char *pci_slot_name(const struct pci_slot *slot)
{
return kobject_name(&slot->kobj);
}
 
/* File state for mmap()s on /proc/bus/pci/X/Y */
enum pci_mmap_state {
pci_mmap_io,
357,7 → 352,6
unsigned int io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
unsigned int irq_managed:1;
unsigned int has_secondary_link:1;
unsigned int non_compliant_bars:1; /* broken BARs; ignore them */
pci_dev_flags_t dev_flags;
atomic_t enable_cnt; /* pci_enable_device has been called */
 
/drivers/include/linux/interrupt.h
6,7 → 6,6
#include <linux/bitops.h>
#include <linux/irqreturn.h>
#include <linux/kref.h>
#include <linux/atomic.h>
/*
* These correspond to the IORESOURCE_IRQ_* defines in
* linux/ioport.h to select the interrupt line behaviour. When
/drivers/include/linux/io.h
1,27 → 1,0
/*
* Copyright 2006 PathScale, Inc. All Rights Reserved.
*
* This file is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
#ifndef _LINUX_IO_H
#define _LINUX_IO_H
 
#include <linux/types.h>
#include <linux/init.h>
#include <linux/bug.h>
#include <linux/err.h>
struct device;
struct resource;
#endif /* _LINUX_IO_H */
//stub
/drivers/include/linux/pci_ids.h
2495,13 → 2495,6
#define PCI_DEVICE_ID_KORENIX_JETCARDF2 0x1700
#define PCI_DEVICE_ID_KORENIX_JETCARDF3 0x17ff
 
#define PCI_VENDOR_ID_NETRONOME 0x19ee
#define PCI_DEVICE_ID_NETRONOME_NFP3200 0x3200
#define PCI_DEVICE_ID_NETRONOME_NFP3240 0x3240
#define PCI_DEVICE_ID_NETRONOME_NFP4000 0x4000
#define PCI_DEVICE_ID_NETRONOME_NFP6000 0x6000
#define PCI_DEVICE_ID_NETRONOME_NFP6000_VF 0x6003
 
#define PCI_VENDOR_ID_QMI 0x1a32
 
#define PCI_VENDOR_ID_AZWAVE 0x1a3b
/drivers/include/linux/sysfs.h
14,7 → 14,6
#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/list.h>
#include <linux/lockdep.h>
#include <linux/atomic.h>
 
struct kobject;
/drivers/include/linux/cpumask.h
556,7 → 556,7
static inline int cpumask_parse_user(const char __user *buf, int len,
struct cpumask *dstp)
{
return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpumask_bits);
return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpu_ids);
}
 
/**
571,7 → 571,7
struct cpumask *dstp)
{
return bitmap_parselist_user(buf, len, cpumask_bits(dstp),
nr_cpumask_bits);
nr_cpu_ids);
}
 
/**
586,7 → 586,7
char *nl = strchr(buf, '\n');
unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf);
 
return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpumask_bits);
return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpu_ids);
}
 
/**
598,7 → 598,7
*/
static inline int cpulist_parse(const char *buf, struct cpumask *dstp)
{
return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpumask_bits);
return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpu_ids);
}
 
/**
/drivers/include/linux/jiffies.h
354,7 → 354,7
* directly here and from __msecs_to_jiffies() in the case where
* constant folding is not possible.
*/
static __always_inline unsigned long msecs_to_jiffies(const unsigned int m)
static inline unsigned long msecs_to_jiffies(const unsigned int m)
{
if (__builtin_constant_p(m)) {
if ((int)m < 0)
/drivers/include/linux/list.h
87,7 → 87,7
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
WRITE_ONCE(prev->next, next);
prev->next = next;
}
 
/**
615,8 → 615,7
{
struct hlist_node *next = n->next;
struct hlist_node **pprev = n->pprev;
 
WRITE_ONCE(*pprev, next);
*pprev = next;
if (next)
next->pprev = pprev;
}
/drivers/include/linux/module.h
9,7 → 9,6
#include <linux/list.h>
#include <linux/compiler.h>
#include <linux/cache.h>
#include <linux/init.h>
 
#include <linux/kobject.h>
#include <linux/moduleparam.h>
/drivers/include/linux/moduleparam.h
1,7 → 1,6
#ifndef _LINUX_MODULE_PARAMS_H
#define _LINUX_MODULE_PARAMS_H
/* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */
#include <linux/init.h>
#include <linux/kernel.h>
/**
* module_param - typesafe helper for a module/cmdline parameter
/drivers/include/linux/personality.h
3,7 → 3,43
 
#include <uapi/linux/personality.h>
 
 
/*
* Handling of different ABIs (personalities).
*/
 
struct exec_domain;
struct pt_regs;
 
extern int register_exec_domain(struct exec_domain *);
extern int unregister_exec_domain(struct exec_domain *);
extern int __set_personality(unsigned int);
 
 
/*
* Description of an execution domain.
*
* The first two members are refernced from assembly source
* and should stay where they are unless explicitly needed.
*/
typedef void (*handler_t)(int, struct pt_regs *);
 
struct exec_domain {
const char *name; /* name of the execdomain */
handler_t handler; /* handler for syscalls */
unsigned char pers_low; /* lowest personality */
unsigned char pers_high; /* highest personality */
unsigned long *signal_map; /* signal mapping */
unsigned long *signal_invmap; /* reverse signal mapping */
struct map_segment *err_map; /* error mapping */
struct map_segment *socktype_map; /* socket type mapping */
struct map_segment *sockopt_map; /* socket option mapping */
struct map_segment *af_map; /* address family mapping */
struct module *module; /* module context of the ed. */
struct exec_domain *next; /* linked list (internal) */
};
 
/*
* Return the base personality without flags.
*/
#define personality(pers) (pers & PER_MASK)
/drivers/include/linux/pm.h
25,7 → 25,7
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/timer.h>
//#include <linux/timer.h>
#include <linux/completion.h>
 
/*
/drivers/include/linux/seqlock.h
33,7 → 33,7
*/
 
#include <linux/spinlock.h>
#include <linux/preempt.h>
//#include <linux/preempt.h>
#include <linux/lockdep.h>
#include <linux/compiler.h>
#include <asm/processor.h>
/drivers/include/linux/string.h
127,11 → 127,7
extern void argv_free(char **argv);
 
extern bool sysfs_streq(const char *s1, const char *s2);
extern int kstrtobool(const char *s, bool *res);
static inline int strtobool(const char *s, bool *res)
{
return kstrtobool(s, res);
}
extern int strtobool(const char *s, bool *res);
 
#ifdef CONFIG_BINARY_PRINTF
int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
/drivers/include/linux/time.h
125,32 → 125,6
 
extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 
/*
* Validates if a timespec/timeval used to inject a time offset is valid.
* Offsets can be postive or negative. The value of the timeval/timespec
* is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must
* always be non-negative.
*/
static inline bool timeval_inject_offset_valid(const struct timeval *tv)
{
/* We don't check the tv_sec as it can be positive or negative */
 
/* Can't have more microseconds then a second */
if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
return false;
return true;
}
 
static inline bool timespec_inject_offset_valid(const struct timespec *ts)
{
/* We don't check the tv_sec as it can be positive or negative */
 
/* Can't have more nanoseconds then a second */
if (ts->tv_nsec < 0 || ts->tv_nsec >= NSEC_PER_SEC)
return false;
return true;
}
 
#define CURRENT_TIME (current_kernel_time())
#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
 
/drivers/include/linux/vgaarb.h
31,7 → 31,7
#ifndef LINUX_VGA_H
#define LINUX_VGA_H
 
#include <video/vga.h>
//#include <video/vga.h>
 
/* Legacy VGA regions */
#define VGA_RSRC_NONE 0x00
/drivers/include/linux/hash.h
32,28 → 32,12
#error Wordsize not 32 or 64
#endif
 
/*
* The above primes are actively bad for hashing, since they are
* too sparse. The 32-bit one is mostly ok, the 64-bit one causes
* real problems. Besides, the "prime" part is pointless for the
* multiplicative hash.
*
* Although a random odd number will do, it turns out that the golden
* ratio phi = (sqrt(5)-1)/2, or its negative, has particularly nice
* properties.
*
* These are the negative, (1 - phi) = (phi^2) = (3 - sqrt(5))/2.
* (See Knuth vol 3, section 6.4, exercise 9.)
*/
#define GOLDEN_RATIO_32 0x61C88647
#define GOLDEN_RATIO_64 0x61C8864680B583EBull
 
static __always_inline u64 hash_64(u64 val, unsigned int bits)
{
u64 hash = val;
 
#if BITS_PER_LONG == 64
hash = hash * GOLDEN_RATIO_64;
#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
hash = hash * GOLDEN_RATIO_PRIME_64;
#else
/* Sigh, gcc can't optimise this alone like it does for 32 bits. */
u64 n = hash;
/drivers/include/linux/export.h
8,15 → 8,6
* Try not to add #includes here. It slows compilation and makes kernel
* hackers place grumpy comments in header files.
*/
 
/* Some toolchains use a `_' prefix for all user symbols. */
#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
#define __VMLINUX_SYMBOL(x) _##x
#define __VMLINUX_SYMBOL_STR(x) "_" #x
#else
#define __VMLINUX_SYMBOL(x) x
#define __VMLINUX_SYMBOL_STR(x) #x
#endif
#define EXPORT_SYMBOL(sym)
#define EXPORT_SYMBOL_GPL(sym)
#define EXPORT_SYMBOL_GPL_FUTURE(sym)
/drivers/include/linux/log2.h
16,6 → 16,12
#include <linux/bitops.h>
 
/*
* deal with unrepresentable constant logarithms
*/
extern __attribute__((const, noreturn))
int ____ilog2_NaN(void);
 
/*
* non-constant log of base 2 calculators
* - the arch may override these in asm/bitops.h if they can be implemented
* more efficiently than using fls() and fls64()
79,7 → 85,7
#define ilog2(n) \
( \
__builtin_constant_p(n) ? ( \
(n) < 2 ? 0 : \
(n) < 1 ? ____ilog2_NaN() : \
(n) & (1ULL << 63) ? 63 : \
(n) & (1ULL << 62) ? 62 : \
(n) & (1ULL << 61) ? 61 : \
142,7 → 148,10
(n) & (1ULL << 4) ? 4 : \
(n) & (1ULL << 3) ? 3 : \
(n) & (1ULL << 2) ? 2 : \
1 ) : \
(n) & (1ULL << 1) ? 1 : \
(n) & (1ULL << 0) ? 0 : \
____ilog2_NaN() \
) : \
(sizeof(n) <= 4) ? \
__ilog2_u32(n) : \
__ilog2_u64(n) \
194,17 → 203,6
* ... and so on.
*/
 
static inline __attribute_const__
int __order_base_2(unsigned long n)
{
return n > 1 ? ilog2(n - 1) + 1 : 0;
}
#define order_base_2(n) ilog2(roundup_pow_of_two(n))
 
#define order_base_2(n) \
( \
__builtin_constant_p(n) ? ( \
((n) == 0 || (n) == 1) ? 0 : \
ilog2((n) - 1) + 1) : \
__order_base_2(n) \
)
#endif /* _LINUX_LOG2_H */
/drivers/include/uapi/linux/timex.h
File deleted
/drivers/include/video/vga.h
File deleted
/drivers/ddk/linux/div64.c
1,64 → 1,7
/*
* Copyright (C) 2003 Bernardo Innocenti <bernie@develer.com>
*
* Based on former do_div() implementation from asm-parisc/div64.h:
* Copyright (C) 1999 Hewlett-Packard Co
* Copyright (C) 1999 David Mosberger-Tang <davidm@hpl.hp.com>
*
*
* Generic C version of 64bit/32bit division and modulo, with
* 64bit result and 32bit remainder.
*
* The fast case for (n>>32 == 0) is handled inline by do_div().
*
* Code generated for this function might be very inefficient
* for some CPUs. __div64_32() can be overridden by linking arch-specific
* assembly versions such as arch/ppc/lib/div64.S and arch/sh/lib/div64.S.
*/
 
#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/math64.h>
 
/* Not needed on 64bit architectures */
#if BITS_PER_LONG == 32
 
uint32_t __attribute__((weak)) __div64_32(uint64_t *n, uint32_t base)
{
uint64_t rem = *n;
uint64_t b = base;
uint64_t res, d = 1;
uint32_t high = rem >> 32;
 
/* Reduce the thing a bit first */
res = 0;
if (high >= base) {
high /= base;
res = (uint64_t) high << 32;
rem -= (uint64_t) (high*base) << 32;
}
 
while ((int64_t)b > 0 && b < rem) {
b = b+b;
d = d+d;
}
 
do {
if (rem >= b) {
rem -= b;
res += d;
}
b >>= 1;
d >>= 1;
} while (d);
 
*n = res;
return rem;
}
 
EXPORT_SYMBOL(__div64_32);
 
#ifndef div_s64_rem
s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
{
u64 quotient;
75,109 → 18,4
}
return quotient;
}
EXPORT_SYMBOL(div_s64_rem);
#endif
 
/**
* div64_u64_rem - unsigned 64bit divide with 64bit divisor and remainder
* @dividend: 64bit dividend
* @divisor: 64bit divisor
* @remainder: 64bit remainder
*
* This implementation is a comparable to algorithm used by div64_u64.
* But this operation, which includes math for calculating the remainder,
* is kept distinct to avoid slowing down the div64_u64 operation on 32bit
* systems.
*/
#ifndef div64_u64_rem
u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder)
{
u32 high = divisor >> 32;
u64 quot;
 
if (high == 0) {
u32 rem32;
quot = div_u64_rem(dividend, divisor, &rem32);
*remainder = rem32;
} else {
int n = 1 + fls(high);
quot = div_u64(dividend >> n, divisor >> n);
 
if (quot != 0)
quot--;
 
*remainder = dividend - quot * divisor;
if (*remainder >= divisor) {
quot++;
*remainder -= divisor;
}
}
 
return quot;
}
EXPORT_SYMBOL(div64_u64_rem);
#endif
 
/**
* div64_u64 - unsigned 64bit divide with 64bit divisor
* @dividend: 64bit dividend
* @divisor: 64bit divisor
*
* This implementation is a modified version of the algorithm proposed
* by the book 'Hacker's Delight'. The original source and full proof
* can be found here and is available for use without restriction.
*
* 'http://www.hackersdelight.org/hdcodetxt/divDouble.c.txt'
*/
#ifndef div64_u64
u64 div64_u64(u64 dividend, u64 divisor)
{
u32 high = divisor >> 32;
u64 quot;
 
if (high == 0) {
quot = div_u64(dividend, divisor);
} else {
int n = 1 + fls(high);
quot = div_u64(dividend >> n, divisor >> n);
 
if (quot != 0)
quot--;
if ((dividend - quot * divisor) >= divisor)
quot++;
}
 
return quot;
}
EXPORT_SYMBOL(div64_u64);
#endif
 
/**
* div64_s64 - signed 64bit divide with 64bit divisor
* @dividend: 64bit dividend
* @divisor: 64bit divisor
*/
#ifndef div64_s64
s64 div64_s64(s64 dividend, s64 divisor)
{
s64 quot, t;
 
quot = div64_u64(abs(dividend), abs(divisor));
t = (dividend ^ divisor) >> 63;
 
return (quot ^ t) - t;
}
EXPORT_SYMBOL(div64_s64);
#endif
 
#endif /* BITS_PER_LONG == 32 */
 
/*
* Iterative div/mod for use when dividend is not expected to be much
* bigger than divisor.
*/
u32 iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder)
{
return __iter_div_u64_rem(dividend, divisor, remainder);
}
EXPORT_SYMBOL(iter_div_u64_rem);
/drivers/ddk/linux/dmapool.c
26,16 → 26,14
#include <linux/dmapool.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/export.h>
#include <linux/mutex.h>
 
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/wait.h>
 
#include <linux/mutex.h>
#include <linux/gfp.h>
#include <syscall.h>
 
 
/drivers/ddk/linux/string.c
22,13 → 22,9
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/bug.h>
#include <linux/errno.h>
#include <linux/module.h>
 
 
 
#ifndef __HAVE_ARCH_STRLCPY
/**
* strlcpy - Copy a C-string into a sized buffer
/drivers/ddk/linux/time.c
592,6 → 592,25
return res;
}
 
s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
{
u64 quotient;
 
if (dividend < 0) {
quotient = div_u64_rem(-dividend, abs(divisor), (u32 *)remainder);
*remainder = -*remainder;
if (divisor > 0)
quotient = -quotient;
} else {
quotient = div_u64_rem(dividend, abs(divisor), (u32 *)remainder);
if (divisor < 0)
quotient = -quotient;
}
return quotient;
}
 
 
 
 
 
 
/drivers/ddk/linux/dmi.c
1,12 → 1,11
 
#include <linux/types.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/bug.h>
#include <linux/module.h>
#include <linux/ctype.h>
#include <linux/dmi.h>
#include <asm/unaligned.h>
#include <syscall.h>
struct kobject *dmi_kobj;
 
static void *dmi_alloc(unsigned len)
{
20,12 → 19,7
*/
static const char dmi_empty_string[] = " ";
 
static u32 dmi_ver __initdata;
static u32 dmi_len;
static u16 dmi_num;
static u8 smbios_entry_point[32];
static int smbios_entry_point_size;
 
static u16 dmi_ver;
/*
* Catch too early calls to dmi_check_system():
*/
32,7 → 26,7
static int dmi_initialized;
 
/* DMI system identification string used during boot */
static char dmi_ids_string[128] __initdata;
static char dmi_ids_string[128];
 
static struct dmi_memdev_info {
const char *device;
86,7 → 80,7
* We have to be cautious here. We have seen BIOSes with DMI pointers
* pointing to completely the wrong place for example
*/
static void dmi_decode_table(u8 *buf,
static void dmi_table(u8 *buf, int len, int num,
void (*decode)(const struct dmi_header *, void *),
void *private_data)
{
94,13 → 88,10
int i = 0;
 
/*
* Stop when we have seen all the items the table claimed to have
* (SMBIOS < 3.0 only) OR we reach an end-of-table marker (SMBIOS
* >= 3.0 only) OR we run off the end of the table (should never
* happen but sometimes does on bogus implementations.)
* Stop when we see all the items the table claimed to have
* OR we run off the end of the table (also happens)
*/
while ((!dmi_num || i < dmi_num) &&
(data - buf + sizeof(struct dmi_header)) <= dmi_len) {
while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
const struct dmi_header *dm = (const struct dmi_header *)data;
 
/*
109,44 → 100,29
* table in dmi_decode or dmi_string
*/
data += dm->length;
while ((data - buf < dmi_len - 1) && (data[0] || data[1]))
while ((data - buf < len - 1) && (data[0] || data[1]))
data++;
if (data - buf < dmi_len - 1)
if (data - buf < len - 1)
decode(dm, private_data);
 
data += 2;
i++;
 
/*
* 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
* For tables behind a 64-bit entry point, we have no item
* count and no exact table length, so stop on end-of-table
* marker. For tables behind a 32-bit entry point, we have
* seen OEM structures behind the end-of-table marker on
* some systems, so don't trust it.
*/
if (!dmi_num && dm->type == DMI_ENTRY_END_OF_TABLE)
break;
}
 
/* Trim DMI table length if needed */
if (dmi_len > data - buf)
dmi_len = data - buf;
}
 
static phys_addr_t dmi_base;
static u32 dmi_base;
static u16 dmi_len;
static u16 dmi_num;
 
static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
void *))
{
u8 *buf;
u32 orig_dmi_len = dmi_len;
 
buf = (u8*)MapIoMem(dmi_base, dmi_len, PG_SW);
if (buf == NULL)
return -1;
 
dmi_decode_table(buf, decode, NULL);
dmi_table(buf, dmi_len, dmi_num, decode, NULL);
 
FreeKernelSpace(buf);
 
216,7 → 192,7
* the UUID are supposed to be little-endian encoded. The specification
* says that this is the defacto standard.
*/
if (dmi_ver >= 0x020600)
if (dmi_ver >= 0x0206)
sprintf(s, "%pUL", d);
else
sprintf(s, "%pUB", d);
353,13 → 329,7
dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5),
dmi_string_nosave(dm, *(d-1)));
dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
}
 
static void __init count_mem_devices(const struct dmi_header *dm, void *v)
{
if (dm->type != DMI_ENTRY_MEM_DEVICE)
return;
dmi_memdev_nr++;
}
 
/*
459,13 → 429,11
*/
static int __init dmi_present(const u8 *buf)
{
u32 smbios_ver;
int smbios_ver;
 
if (memcmp(buf, "_SM_", 4) == 0 &&
buf[5] < 32 && dmi_checksum(buf, buf[5])) {
smbios_ver = get_unaligned_be16(buf + 6);
smbios_entry_point_size = buf[5];
memcpy(smbios_entry_point, buf, smbios_entry_point_size);
smbios_ver = (buf[6] << 8) + buf[7];
 
/* Some BIOS report weird SMBIOS version, fix that up */
switch (smbios_ver) {
487,25 → 455,21
buf += 16;
 
if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
if (smbios_ver)
dmi_ver = smbios_ver;
else
dmi_ver = (buf[14] & 0xF0) << 4 | (buf[14] & 0x0F);
dmi_ver <<= 8;
dmi_num = get_unaligned_le16(buf + 12);
dmi_len = get_unaligned_le16(buf + 6);
dmi_base = get_unaligned_le32(buf + 8);
dmi_num = (buf[13] << 8) | buf[12];
dmi_len = (buf[7] << 8) | buf[6];
dmi_base = (buf[11] << 24) | (buf[10] << 16) |
(buf[9] << 8) | buf[8];
 
if (dmi_walk_early(dmi_decode) == 0) {
if (smbios_ver) {
dmi_ver = smbios_ver;
pr_info("SMBIOS %d.%d present.\n",
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
dmi_ver >> 8, dmi_ver & 0xFF);
} else {
smbios_entry_point_size = 15;
memcpy(smbios_entry_point, buf,
smbios_entry_point_size);
dmi_ver = (buf[14] & 0xF0) << 4 |
(buf[14] & 0x0F);
pr_info("Legacy DMI %d.%d present.\n",
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
dmi_ver >> 8, dmi_ver & 0xFF);
}
dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
516,33 → 480,6
return 1;
}
 
/*
* Check for the SMBIOS 3.0 64-bit entry point signature. Unlike the legacy
* 32-bit entry point, there is no embedded DMI header (_DMI_) in here.
*/
static int __init dmi_smbios3_present(const u8 *buf)
{
if (memcmp(buf, "_SM3_", 5) == 0 &&
buf[6] < 32 && dmi_checksum(buf, buf[6])) {
dmi_ver = get_unaligned_be32(buf + 6) & 0xFFFFFF;
dmi_num = 0; /* No longer specified */
dmi_len = get_unaligned_le32(buf + 12);
dmi_base = get_unaligned_le64(buf + 16);
smbios_entry_point_size = buf[6];
memcpy(smbios_entry_point, buf, smbios_entry_point_size);
 
if (dmi_walk_early(dmi_decode) == 0) {
pr_info("SMBIOS %d.%d.%d present.\n",
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF,
dmi_ver & 0xFF);
dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
pr_debug("DMI: %s\n", dmi_ids_string);
return 0;
}
}
return 1;
}
 
void __init dmi_scan_machine(void)
{
char __iomem *p, *q;
562,7 → 499,7
memset(buf, 0, 16);
for (q = p; q < p + 0x10000; q += 16) {
memcpy(buf + 16, q, 16);
if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
if (!dmi_present(buf)) {
dmi_available = 1;
goto out;
}
/drivers/ddk/linux/idr.c
22,7 → 22,6
 
#ifndef TEST // to test in user space...
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/export.h>
#endif
#include <linux/err.h>
/drivers/ddk/linux/list_sort.c
2,11 → 2,9
#define pr_fmt(fmt) "list_sort_test: " fmt
 
#include <linux/kernel.h>
#include <linux/bug.h>
#include <linux/compiler.h>
#include <linux/export.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/list_sort.h>
#include <linux/slab.h>
#include <linux/list.h>
 
#define MAX_LIST_LENGTH_BITS 20
/drivers/ddk/linux/rbtree.c
44,30 → 44,6
* parentheses and have some accompanying text comment.
*/
 
/*
* Notes on lockless lookups:
*
* All stores to the tree structure (rb_left and rb_right) must be done using
* WRITE_ONCE(). And we must not inadvertently cause (temporary) loops in the
* tree structure as seen in program order.
*
* These two requirements will allow lockless iteration of the tree -- not
* correct iteration mind you, tree rotations are not atomic so a lookup might
* miss entire subtrees.
*
* But they do guarantee that any such traversal will only see valid elements
* and that it will indeed complete -- does not get stuck in a loop.
*
* It also guarantees that if the lookup returns an element it is the 'correct'
* one. But not returning an element does _NOT_ mean it's not present.
*
* NOTE:
*
* Stores to __rb_parent_color are not important for simple lookups so those
* are left undone as of now. Nor did I check for loops involving parent
* pointers.
*/
 
static inline void rb_set_black(struct rb_node *rb)
{
rb->__rb_parent_color |= RB_BLACK;
153,9 → 129,8
* This still leaves us in violation of 4), the
* continuation into Case 3 will fix that.
*/
tmp = node->rb_left;
WRITE_ONCE(parent->rb_right, tmp);
WRITE_ONCE(node->rb_left, parent);
parent->rb_right = tmp = node->rb_left;
node->rb_left = parent;
if (tmp)
rb_set_parent_color(tmp, parent,
RB_BLACK);
174,8 → 149,8
* / \
* n U
*/
WRITE_ONCE(gparent->rb_left, tmp); /* == parent->rb_right */
WRITE_ONCE(parent->rb_right, gparent);
gparent->rb_left = tmp; /* == parent->rb_right */
parent->rb_right = gparent;
if (tmp)
rb_set_parent_color(tmp, gparent, RB_BLACK);
__rb_rotate_set_parents(gparent, parent, root, RB_RED);
196,9 → 171,8
tmp = parent->rb_left;
if (node == tmp) {
/* Case 2 - right rotate at parent */
tmp = node->rb_right;
WRITE_ONCE(parent->rb_left, tmp);
WRITE_ONCE(node->rb_right, parent);
parent->rb_left = tmp = node->rb_right;
node->rb_right = parent;
if (tmp)
rb_set_parent_color(tmp, parent,
RB_BLACK);
209,8 → 183,8
}
 
/* Case 3 - left rotate at gparent */
WRITE_ONCE(gparent->rb_right, tmp); /* == parent->rb_left */
WRITE_ONCE(parent->rb_left, gparent);
gparent->rb_right = tmp; /* == parent->rb_left */
parent->rb_left = gparent;
if (tmp)
rb_set_parent_color(tmp, gparent, RB_BLACK);
__rb_rotate_set_parents(gparent, parent, root, RB_RED);
250,9 → 224,8
* / \ / \
* Sl Sr N Sl
*/
tmp1 = sibling->rb_left;
WRITE_ONCE(parent->rb_right, tmp1);
WRITE_ONCE(sibling->rb_left, parent);
parent->rb_right = tmp1 = sibling->rb_left;
sibling->rb_left = parent;
rb_set_parent_color(tmp1, parent, RB_BLACK);
__rb_rotate_set_parents(parent, sibling, root,
RB_RED);
302,10 → 275,9
* \
* Sr
*/
tmp1 = tmp2->rb_right;
WRITE_ONCE(sibling->rb_left, tmp1);
WRITE_ONCE(tmp2->rb_right, sibling);
WRITE_ONCE(parent->rb_right, tmp2);
sibling->rb_left = tmp1 = tmp2->rb_right;
tmp2->rb_right = sibling;
parent->rb_right = tmp2;
if (tmp1)
rb_set_parent_color(tmp1, sibling,
RB_BLACK);
325,9 → 297,8
* / \ / \
* (sl) sr N (sl)
*/
tmp2 = sibling->rb_left;
WRITE_ONCE(parent->rb_right, tmp2);
WRITE_ONCE(sibling->rb_left, parent);
parent->rb_right = tmp2 = sibling->rb_left;
sibling->rb_left = parent;
rb_set_parent_color(tmp1, sibling, RB_BLACK);
if (tmp2)
rb_set_parent(tmp2, parent);
339,9 → 310,8
sibling = parent->rb_left;
if (rb_is_red(sibling)) {
/* Case 1 - right rotate at parent */
tmp1 = sibling->rb_right;
WRITE_ONCE(parent->rb_left, tmp1);
WRITE_ONCE(sibling->rb_right, parent);
parent->rb_left = tmp1 = sibling->rb_right;
sibling->rb_right = parent;
rb_set_parent_color(tmp1, parent, RB_BLACK);
__rb_rotate_set_parents(parent, sibling, root,
RB_RED);
366,10 → 336,9
break;
}
/* Case 3 - right rotate at sibling */
tmp1 = tmp2->rb_left;
WRITE_ONCE(sibling->rb_right, tmp1);
WRITE_ONCE(tmp2->rb_left, sibling);
WRITE_ONCE(parent->rb_left, tmp2);
sibling->rb_right = tmp1 = tmp2->rb_left;
tmp2->rb_left = sibling;
parent->rb_left = tmp2;
if (tmp1)
rb_set_parent_color(tmp1, sibling,
RB_BLACK);
378,9 → 347,8
sibling = tmp2;
}
/* Case 4 - left rotate at parent + color flips */
tmp2 = sibling->rb_right;
WRITE_ONCE(parent->rb_left, tmp2);
WRITE_ONCE(sibling->rb_right, parent);
parent->rb_left = tmp2 = sibling->rb_right;
sibling->rb_right = parent;
rb_set_parent_color(tmp1, sibling, RB_BLACK);
if (tmp2)
rb_set_parent(tmp2, parent);
/drivers/ddk/linux/hdmi.c
27,12 → 27,10
#include <linux/export.h>
#include <linux/hdmi.h>
#include <linux/string.h>
#include <linux/device.h>
 
#define hdmi_log(fmt, ...) dev_printk(level, dev, fmt, ##__VA_ARGS__)
 
static u8 hdmi_infoframe_checksum(u8 *ptr, size_t size)
static void hdmi_infoframe_checksum(void *buffer, size_t size)
{
u8 *ptr = buffer;
u8 csum = 0;
size_t i;
 
40,16 → 38,9
for (i = 0; i < size; i++)
csum += ptr[i];
 
return 256 - csum;
ptr[3] = 256 - csum;
}
 
static void hdmi_infoframe_set_checksum(void *buffer, size_t size)
{
u8 *ptr = buffer;
 
ptr[3] = hdmi_infoframe_checksum(buffer, size);
}
 
/**
* hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe
* @frame: HDMI AVI infoframe
145,7 → 136,7
ptr[11] = frame->right_bar & 0xff;
ptr[12] = (frame->right_bar >> 8) & 0xff;
 
hdmi_infoframe_set_checksum(buffer, length);
hdmi_infoframe_checksum(buffer, length);
 
return length;
}
215,7 → 206,7
 
ptr[24] = frame->sdi;
 
hdmi_infoframe_set_checksum(buffer, length);
hdmi_infoframe_checksum(buffer, length);
 
return length;
}
290,7 → 281,7
if (frame->downmix_inhibit)
ptr[4] |= BIT(7);
 
hdmi_infoframe_set_checksum(buffer, length);
hdmi_infoframe_checksum(buffer, length);
 
return length;
}
382,7 → 373,7
ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
}
 
hdmi_infoframe_set_checksum(buffer, length);
hdmi_infoframe_checksum(buffer, length);
 
return length;
}
/drivers/ddk/linux/interval_tree.c
1,7 → 1,7
//#include <linux/init.h>
#include <linux/interval_tree.h>
#include <linux/interval_tree_generic.h>
#include <linux/compiler.h>
#include <linux/export.h>
#include <linux/module.h>
 
#define START(node) ((node)->start)
#define LAST(node) ((node)->last)
/drivers/ddk/linux/ctype.c
5,8 → 5,7
*/
 
#include <linux/ctype.h>
#include <linux/compiler.h>
#include <linux/export.h>
#include <linux/module.h>
 
const unsigned char _ctype[] = {
_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */