/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 */ |