Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6335 → Rev 6336

/drivers/ddk/Makefile
44,6 → 44,7
linux/idr.c \
linux/interval_tree.c \
linux/kasprintf.c \
linux/kmap.c \
linux/list_sort.c \
linux/mutex.c \
linux/rbtree.c \
/drivers/ddk/linux/kmap.c
0,0 → 1,96
#include <ddk.h>
#include <linux/mm.h>
#include <syscall.h>
 
#define KMAP_MAX 256
 
static struct mutex kmap_mutex;
static struct page* kmap_table[KMAP_MAX];
static int kmap_av;
static int kmap_first;
static void* kmap_base;
 
int kmap_init()
{
kmap_base = AllocKernelSpace(KMAP_MAX*4096);
if(kmap_base == NULL)
return -1;
 
kmap_av = KMAP_MAX;
MutexInit(&kmap_mutex);
return 0;
};
 
void *kmap(struct page *page)
{
void *vaddr = NULL;
int i;
 
do
{
MutexLock(&kmap_mutex);
if(kmap_av != 0)
{
for(i = kmap_first; i < KMAP_MAX; i++)
{
if(kmap_table[i] == NULL)
{
kmap_av--;
kmap_first = i;
kmap_table[i] = page;
vaddr = kmap_base + (i<<12);
MapPage(vaddr,(addr_t)page,3);
break;
};
};
};
MutexUnlock(&kmap_mutex);
}while(vaddr == NULL);
 
return vaddr;
};
 
void *kmap_atomic(struct page *page) __attribute__ ((alias ("kmap")));
 
void kunmap(struct page *page)
{
void *vaddr;
int i;
 
MutexLock(&kmap_mutex);
 
for(i = 0; i < KMAP_MAX; i++)
{
if(kmap_table[i] == page)
{
kmap_av++;
if(i < kmap_first)
kmap_first = i;
kmap_table[i] = NULL;
vaddr = kmap_base + (i<<12);
MapPage(vaddr,0,0);
break;
};
};
 
MutexUnlock(&kmap_mutex);
};
 
void kunmap_atomic(void *vaddr)
{
int i;
 
MapPage(vaddr,0,0);
 
i = (vaddr - kmap_base) >> 12;
 
MutexLock(&kmap_mutex);
 
kmap_av++;
if(i < kmap_first)
kmap_first = i;
kmap_table[i] = NULL;
 
MutexUnlock(&kmap_mutex);
}
 
/drivers/ddk/linux/workqueue.c
195,7 → 195,7
ret = 1;
};
 
timer->handle = TimerHS(expires, 0, timer->function, timer->data);
timer->handle = TimerHS(expires, 0, timer->function, (void*)timer->data);
 
return ret;
}
/drivers/include/asm-generic/delay.h
19,9 → 19,6
#define udelay(n) \
({ \
if (__builtin_constant_p(n)) { \
if ((n) / 20000 >= 1) \
__bad_udelay(); \
else \
__const_udelay((n) * 0x10c7ul); \
} else { \
__udelay(n); \
/drivers/include/display.h
40,6 → 40,11
uint32_t pde[8];
};
 
int fake_framebuffer_create();
void set_fake_framebuffer();
int kolibri_framebuffer_init(void *param);
void kolibri_framebuffer_update(struct drm_device *dev, struct kos_framebuffer *kfb);
 
struct tag_display
{
u32 x;
/drivers/include/drm/drmP.h
318,6 → 318,11
unsigned universal_planes:1;
/* true if client understands atomic properties */
unsigned atomic:1;
/*
* This client is allowed to gain master privileges for @master.
* Protected by struct drm_device::master_mutex.
*/
unsigned allowed_master:1;
struct list_head lhead;
struct drm_minor *minor;
unsigned long lock_count;
/drivers/include/drm/drm_cache.h
35,4 → 35,13
 
void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
 
static inline bool drm_arch_can_wc_memory(void)
{
#if defined(CONFIG_PPC) && !defined(CONFIG_NOT_COHERENT_CACHE)
return false;
#else
return true;
#endif
}
 
#endif
/drivers/include/drm/drm_dp_mst_helper.h
44,8 → 44,6
/**
* struct drm_dp_mst_port - MST port
* @kref: reference count for this port.
* @guid_valid: for DP 1.2 devices if we have validated the GUID.
* @guid: guid for DP 1.2 device on this port.
* @port_num: port number
* @input: if this port is an input port.
* @mcs: message capability status - DP 1.2 spec.
70,10 → 68,6
struct drm_dp_mst_port {
struct kref kref;
 
/* if dpcd 1.2 device is on this port - its GUID info */
bool guid_valid;
u8 guid[16];
 
u8 port_num;
bool input;
bool mcs;
109,10 → 103,12
* @tx_slots: transmission slots for this device.
* @last_seqno: last sequence number used to talk to this.
* @link_address_sent: if a link address message has been sent to this device yet.
* @guid: guid for DP 1.2 branch device. port under this branch can be
* identified by port #.
*
* This structure represents an MST branch device, there is one
* primary branch device at the root, along with any others connected
* to downstream ports
* primary branch device at the root, along with any other branches connected
* to downstream port of parent branches.
*/
struct drm_dp_mst_branch {
struct kref kref;
131,6 → 127,9
struct drm_dp_sideband_msg_tx *tx_slots[2];
int last_seqno;
bool link_address_sent;
 
/* global unique identifier to identify branch devices */
u8 guid[16];
};
 
 
405,11 → 404,9
* @conn_base_id: DRM connector ID this mgr is connected to.
* @down_rep_recv: msg receiver state for down replies.
* @up_req_recv: msg receiver state for up requests.
* @lock: protects mst state, primary, guid, dpcd.
* @lock: protects mst state, primary, dpcd.
* @mst_state: if this manager is enabled for an MST capable port.
* @mst_primary: pointer to the primary branch device.
* @guid_valid: GUID valid for the primary branch device.
* @guid: GUID for primary port.
* @dpcd: cache of DPCD for primary port.
* @pbn_div: PBN to slots divisor.
*
431,13 → 428,11
struct drm_dp_sideband_msg_rx up_req_recv;
 
/* pointer to info about the initial MST device */
struct mutex lock; /* protects mst_state + primary + guid + dpcd */
struct mutex lock; /* protects mst_state + primary + dpcd */
 
bool mst_state;
struct drm_dp_mst_branch *mst_primary;
/* primary MST device GUID */
bool guid_valid;
u8 guid[16];
 
u8 dpcd[DP_RECEIVER_CAP_SIZE];
u8 sink_count;
int pbn_div;
450,9 → 445,7
the mstb tx_slots and txmsg->state once they are queued */
struct mutex qlock;
struct list_head tx_msg_downq;
struct list_head tx_msg_upq;
bool tx_down_in_progress;
bool tx_up_in_progress;
 
/* payload info + lock for it */
struct mutex payload_lock;
/drivers/include/drm/drm_fixed.h
73,6 → 73,8
#define DRM_FIXED_ONE (1ULL << DRM_FIXED_POINT)
#define DRM_FIXED_DECIMAL_MASK (DRM_FIXED_ONE - 1)
#define DRM_FIXED_DIGITS_MASK (~DRM_FIXED_DECIMAL_MASK)
#define DRM_FIXED_EPSILON 1LL
#define DRM_FIXED_ALMOST_ONE (DRM_FIXED_ONE - DRM_FIXED_EPSILON)
 
static inline s64 drm_int2fixp(int a)
{
79,13 → 81,21
return ((s64)a) << DRM_FIXED_POINT;
}
 
static inline int drm_fixp2int(int64_t a)
static inline int drm_fixp2int(s64 a)
{
return ((s64)a) >> DRM_FIXED_POINT;
}
 
static inline unsigned drm_fixp_msbset(int64_t a)
static inline int drm_fixp2int_ceil(s64 a)
{
if (a > 0)
return drm_fixp2int(a + DRM_FIXED_ALMOST_ONE);
else
return drm_fixp2int(a - DRM_FIXED_ALMOST_ONE);
}
 
static inline unsigned drm_fixp_msbset(s64 a)
{
unsigned shift, sign = (a >> 63) & 1;
 
for (shift = 62; shift > 0; --shift)
136,6 → 146,45
return result;
}
 
static inline s64 drm_fixp_from_fraction(s64 a, s64 b)
{
s64 res;
bool a_neg = a < 0;
bool b_neg = b < 0;
u64 a_abs = a_neg ? -a : a;
u64 b_abs = b_neg ? -b : b;
u64 rem;
 
/* determine integer part */
u64 res_abs = div64_u64_rem(a_abs, b_abs, &rem);
 
/* determine fractional part */
{
u32 i = DRM_FIXED_POINT;
 
do {
rem <<= 1;
res_abs <<= 1;
if (rem >= b_abs) {
res_abs |= 1;
rem -= b_abs;
}
} while (--i != 0);
}
 
/* round up LSB */
{
u64 summand = (rem << 1) >= b_abs;
 
res_abs += summand;
}
 
res = (s64) res_abs;
if (a_neg ^ b_neg)
res = -res;
return res;
}
 
static inline s64 drm_fixp_exp(s64 x)
{
s64 tolerance = div64_s64(DRM_FIXED_ONE, 1000000);
/drivers/include/linux/backlight.h
7,6 → 7,10
 
#ifndef _LINUX_BACKLIGHT_H
#define _LINUX_BACKLIGHT_H
 
#include <linux/device.h>
#include <linux/fb.h>
#include <linux/mutex.h>
/* Notes on locking:
*
* backlight_device->ops_lock is an internal backlight lock protecting the
/drivers/include/linux/dmi.h
2,6 → 2,7
#define __DMI_H__
 
#include <linux/list.h>
#include <linux/kobject.h>
#include <linux/mod_devicetable.h>
 
/* enum dmi_field is in mod_devicetable.h */
93,6 → 94,7
int devfn;
};
 
extern struct kobject *dmi_kobj;
extern int dmi_check_system(const struct dmi_system_id *list);
const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list);
extern const char * dmi_get_system_info(int field);
/drivers/include/linux/file.h
10,6 → 10,7
#include <linux/posix_types.h>
 
struct file;
 
extern void fput(struct file *);
extern struct file *fget(unsigned int fd);
#endif /* __LINUX_FILE_H */
/drivers/include/linux/idr.h
12,7 → 12,6
#ifndef __IDR_H__
#define __IDR_H__
 
#include <syscall.h>
#include <linux/types.h>
#include <linux/bitops.h>
#include <linux/init.h>
/drivers/include/linux/lockdep.h
2,7 → 2,7
* Runtime locking correctness validator
*
* Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
* Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
* Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
*
* see Documentation/locking/lockdep-design.txt for more details.
*/
/drivers/include/linux/mmdebug.h
1,6 → 1,7
#ifndef LINUX_MM_DEBUG_H
#define LINUX_MM_DEBUG_H 1
 
#include <linux/bug.h>
#include <linux/stringify.h>
 
struct page;
/drivers/include/linux/rcutiny.h
37,6 → 37,10
might_sleep();
}
 
static inline unsigned long get_state_synchronize_sched(void)
{
return 0;
}
static inline void rcu_barrier_bh(void)
{
wait_rcu_gp(call_rcu_bh);
/drivers/include/linux/sfi.h
59,7 → 59,7
#ifndef _LINUX_SFI_H
#define _LINUX_SFI_H
 
//#include <linux/init.h>
#include <linux/init.h>
#include <linux/types.h>
 
/* Table signatures reserved by the SFI specification */
/drivers/include/syscall.h
486,7 → 486,7
("" :::"eax","ecx","edx");
}
 
int drm_order(unsigned long size);
void FASTCALL sysSetFramebuffer(void *fb)__asm__("SetFramebuffer");
 
static inline void __iomem *ioremap(u32 offset, size_t size)
{