/drivers/ddk/linux/ctype.c |
---|
5,7 → 5,8 |
*/ |
#include <linux/ctype.h> |
#include <linux/module.h> |
#include <linux/compiler.h> |
#include <linux/export.h> |
const unsigned char _ctype[] = { |
_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */ |
/drivers/ddk/linux/div64.c |
---|
1,7 → 1,64 |
/* |
* 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; |
18,4 → 75,109 |
} |
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,14 → 26,16 |
#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/dmi.c |
---|
1,11 → 1,12 |
#include <linux/types.h> |
#include <linux/string.h> |
#include <linux/bug.h> |
#include <linux/init.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) |
{ |
19,7 → 20,12 |
*/ |
static const char dmi_empty_string[] = " "; |
static u16 dmi_ver; |
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; |
/* |
* Catch too early calls to dmi_check_system(): |
*/ |
26,7 → 32,7 |
static int dmi_initialized; |
/* DMI system identification string used during boot */ |
static char dmi_ids_string[128]; |
static char dmi_ids_string[128] __initdata; |
static struct dmi_memdev_info { |
const char *device; |
80,7 → 86,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_table(u8 *buf, int len, int num, |
static void dmi_decode_table(u8 *buf, |
void (*decode)(const struct dmi_header *, void *), |
void *private_data) |
{ |
88,10 → 94,13 |
int i = 0; |
/* |
* Stop when we see all the items the table claimed to have |
* OR we run off the end of the table (also happens) |
* 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.) |
*/ |
while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) { |
while ((!dmi_num || i < dmi_num) && |
(data - buf + sizeof(struct dmi_header)) <= dmi_len) { |
const struct dmi_header *dm = (const struct dmi_header *)data; |
/* |
100,29 → 109,44 |
* table in dmi_decode or dmi_string |
*/ |
data += dm->length; |
while ((data - buf < len - 1) && (data[0] || data[1])) |
while ((data - buf < dmi_len - 1) && (data[0] || data[1])) |
data++; |
if (data - buf < len - 1) |
if (data - buf < dmi_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 u32 dmi_base; |
static u16 dmi_len; |
static u16 dmi_num; |
static phys_addr_t dmi_base; |
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_table(buf, dmi_len, dmi_num, decode, NULL); |
dmi_decode_table(buf, decode, NULL); |
FreeKernelSpace(buf); |
192,7 → 216,7 |
* the UUID are supposed to be little-endian encoded. The specification |
* says that this is the defacto standard. |
*/ |
if (dmi_ver >= 0x0206) |
if (dmi_ver >= 0x020600) |
sprintf(s, "%pUL", d); |
else |
sprintf(s, "%pUB", d); |
329,7 → 353,13 |
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++; |
} |
/* |
429,11 → 459,13 |
*/ |
static int __init dmi_present(const u8 *buf) |
{ |
int smbios_ver; |
u32 smbios_ver; |
if (memcmp(buf, "_SM_", 4) == 0 && |
buf[5] < 32 && dmi_checksum(buf, buf[5])) { |
smbios_ver = (buf[6] << 8) + buf[7]; |
smbios_ver = get_unaligned_be16(buf + 6); |
smbios_entry_point_size = buf[5]; |
memcpy(smbios_entry_point, buf, smbios_entry_point_size); |
/* Some BIOS report weird SMBIOS version, fix that up */ |
switch (smbios_ver) { |
455,21 → 487,25 |
buf += 16; |
if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) { |
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 (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); |
if (dmi_walk_early(dmi_decode) == 0) { |
if (smbios_ver) { |
dmi_ver = smbios_ver; |
pr_info("SMBIOS %d.%d present.\n", |
dmi_ver >> 8, dmi_ver & 0xFF); |
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF); |
} else { |
dmi_ver = (buf[14] & 0xF0) << 4 | |
(buf[14] & 0x0F); |
smbios_entry_point_size = 15; |
memcpy(smbios_entry_point, buf, |
smbios_entry_point_size); |
pr_info("Legacy DMI %d.%d present.\n", |
dmi_ver >> 8, dmi_ver & 0xFF); |
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF); |
} |
dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string)); |
printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string); |
480,6 → 516,33 |
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; |
499,7 → 562,7 |
memset(buf, 0, 16); |
for (q = p; q < p + 0x10000; q += 16) { |
memcpy(buf + 16, q, 16); |
if (!dmi_present(buf)) { |
if (!dmi_smbios3_present(buf) || !dmi_present(buf)) { |
dmi_available = 1; |
goto out; |
} |
/drivers/ddk/linux/hdmi.c |
---|
27,10 → 27,12 |
#include <linux/export.h> |
#include <linux/hdmi.h> |
#include <linux/string.h> |
#include <linux/device.h> |
static void hdmi_infoframe_checksum(void *buffer, size_t size) |
#define hdmi_log(fmt, ...) dev_printk(level, dev, fmt, ##__VA_ARGS__) |
static u8 hdmi_infoframe_checksum(u8 *ptr, size_t size) |
{ |
u8 *ptr = buffer; |
u8 csum = 0; |
size_t i; |
38,9 → 40,16 |
for (i = 0; i < size; i++) |
csum += ptr[i]; |
ptr[3] = 256 - csum; |
return 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 |
136,7 → 145,7 |
ptr[11] = frame->right_bar & 0xff; |
ptr[12] = (frame->right_bar >> 8) & 0xff; |
hdmi_infoframe_checksum(buffer, length); |
hdmi_infoframe_set_checksum(buffer, length); |
return length; |
} |
206,7 → 215,7 |
ptr[24] = frame->sdi; |
hdmi_infoframe_checksum(buffer, length); |
hdmi_infoframe_set_checksum(buffer, length); |
return length; |
} |
281,7 → 290,7 |
if (frame->downmix_inhibit) |
ptr[4] |= BIT(7); |
hdmi_infoframe_checksum(buffer, length); |
hdmi_infoframe_set_checksum(buffer, length); |
return length; |
} |
373,7 → 382,7 |
ptr[9] = (frame->s3d_ext_data & 0xf) << 4; |
} |
hdmi_infoframe_checksum(buffer, length); |
hdmi_infoframe_set_checksum(buffer, length); |
return length; |
} |
/drivers/ddk/linux/idr.c |
---|
22,6 → 22,7 |
#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/interval_tree.c |
---|
1,7 → 1,7 |
//#include <linux/init.h> |
#include <linux/interval_tree.h> |
#include <linux/interval_tree_generic.h> |
#include <linux/module.h> |
#include <linux/compiler.h> |
#include <linux/export.h> |
#define START(node) ((node)->start) |
#define LAST(node) ((node)->last) |
/drivers/ddk/linux/list_sort.c |
---|
2,9 → 2,11 |
#define pr_fmt(fmt) "list_sort_test: " fmt |
#include <linux/kernel.h> |
#include <linux/module.h> |
#include <linux/bug.h> |
#include <linux/compiler.h> |
#include <linux/export.h> |
#include <linux/string.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,6 → 44,30 |
* 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; |
129,8 → 153,9 |
* This still leaves us in violation of 4), the |
* continuation into Case 3 will fix that. |
*/ |
parent->rb_right = tmp = node->rb_left; |
node->rb_left = parent; |
tmp = node->rb_left; |
WRITE_ONCE(parent->rb_right, tmp); |
WRITE_ONCE(node->rb_left, parent); |
if (tmp) |
rb_set_parent_color(tmp, parent, |
RB_BLACK); |
149,8 → 174,8 |
* / \ |
* n U |
*/ |
gparent->rb_left = tmp; /* == parent->rb_right */ |
parent->rb_right = gparent; |
WRITE_ONCE(gparent->rb_left, tmp); /* == parent->rb_right */ |
WRITE_ONCE(parent->rb_right, gparent); |
if (tmp) |
rb_set_parent_color(tmp, gparent, RB_BLACK); |
__rb_rotate_set_parents(gparent, parent, root, RB_RED); |
171,8 → 196,9 |
tmp = parent->rb_left; |
if (node == tmp) { |
/* Case 2 - right rotate at parent */ |
parent->rb_left = tmp = node->rb_right; |
node->rb_right = parent; |
tmp = node->rb_right; |
WRITE_ONCE(parent->rb_left, tmp); |
WRITE_ONCE(node->rb_right, parent); |
if (tmp) |
rb_set_parent_color(tmp, parent, |
RB_BLACK); |
183,8 → 209,8 |
} |
/* Case 3 - left rotate at gparent */ |
gparent->rb_right = tmp; /* == parent->rb_left */ |
parent->rb_left = gparent; |
WRITE_ONCE(gparent->rb_right, tmp); /* == parent->rb_left */ |
WRITE_ONCE(parent->rb_left, gparent); |
if (tmp) |
rb_set_parent_color(tmp, gparent, RB_BLACK); |
__rb_rotate_set_parents(gparent, parent, root, RB_RED); |
224,8 → 250,9 |
* / \ / \ |
* Sl Sr N Sl |
*/ |
parent->rb_right = tmp1 = sibling->rb_left; |
sibling->rb_left = parent; |
tmp1 = sibling->rb_left; |
WRITE_ONCE(parent->rb_right, tmp1); |
WRITE_ONCE(sibling->rb_left, parent); |
rb_set_parent_color(tmp1, parent, RB_BLACK); |
__rb_rotate_set_parents(parent, sibling, root, |
RB_RED); |
275,9 → 302,10 |
* \ |
* Sr |
*/ |
sibling->rb_left = tmp1 = tmp2->rb_right; |
tmp2->rb_right = sibling; |
parent->rb_right = tmp2; |
tmp1 = tmp2->rb_right; |
WRITE_ONCE(sibling->rb_left, tmp1); |
WRITE_ONCE(tmp2->rb_right, sibling); |
WRITE_ONCE(parent->rb_right, tmp2); |
if (tmp1) |
rb_set_parent_color(tmp1, sibling, |
RB_BLACK); |
297,8 → 325,9 |
* / \ / \ |
* (sl) sr N (sl) |
*/ |
parent->rb_right = tmp2 = sibling->rb_left; |
sibling->rb_left = parent; |
tmp2 = sibling->rb_left; |
WRITE_ONCE(parent->rb_right, tmp2); |
WRITE_ONCE(sibling->rb_left, parent); |
rb_set_parent_color(tmp1, sibling, RB_BLACK); |
if (tmp2) |
rb_set_parent(tmp2, parent); |
310,8 → 339,9 |
sibling = parent->rb_left; |
if (rb_is_red(sibling)) { |
/* Case 1 - right rotate at parent */ |
parent->rb_left = tmp1 = sibling->rb_right; |
sibling->rb_right = parent; |
tmp1 = sibling->rb_right; |
WRITE_ONCE(parent->rb_left, tmp1); |
WRITE_ONCE(sibling->rb_right, parent); |
rb_set_parent_color(tmp1, parent, RB_BLACK); |
__rb_rotate_set_parents(parent, sibling, root, |
RB_RED); |
336,9 → 366,10 |
break; |
} |
/* Case 3 - right rotate at sibling */ |
sibling->rb_right = tmp1 = tmp2->rb_left; |
tmp2->rb_left = sibling; |
parent->rb_left = tmp2; |
tmp1 = tmp2->rb_left; |
WRITE_ONCE(sibling->rb_right, tmp1); |
WRITE_ONCE(tmp2->rb_left, sibling); |
WRITE_ONCE(parent->rb_left, tmp2); |
if (tmp1) |
rb_set_parent_color(tmp1, sibling, |
RB_BLACK); |
347,8 → 378,9 |
sibling = tmp2; |
} |
/* Case 4 - left rotate at parent + color flips */ |
parent->rb_left = tmp2 = sibling->rb_right; |
sibling->rb_right = parent; |
tmp2 = sibling->rb_right; |
WRITE_ONCE(parent->rb_left, tmp2); |
WRITE_ONCE(sibling->rb_right, parent); |
rb_set_parent_color(tmp1, sibling, RB_BLACK); |
if (tmp2) |
rb_set_parent(tmp2, parent); |
/drivers/ddk/linux/string.c |
---|
22,9 → 22,13 |
#include <linux/types.h> |
#include <linux/string.h> |
#include <linux/ctype.h> |
#include <linux/module.h> |
#include <linux/kernel.h> |
#include <linux/export.h> |
#include <linux/bug.h> |
#include <linux/errno.h> |
#ifndef __HAVE_ARCH_STRLCPY |
/** |
* strlcpy - Copy a C-string into a sized buffer |
/drivers/ddk/linux/time.c |
---|
592,25 → 592,6 |
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; |
} |