/drivers/include/drm/drmP.h |
---|
1472,7 → 1472,7 |
struct drm_ati_pcigart_info * gart_info); |
extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size, |
size_t align, dma_addr_t maxaddr); |
size_t align); |
extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah); |
extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah); |
/drivers/include/drm/drm_crtc_helper.h |
---|
35,7 → 35,7 |
//#include <linux/spinlock.h> |
#include <linux/types.h> |
//#include <linux/idr.h> |
#include <linux/idr.h> |
#include <linux/fb.h> |
/drivers/include/linux/asm/unaligned.h |
---|
0,0 → 1,14 |
#ifndef _ASM_X86_UNALIGNED_H |
#define _ASM_X86_UNALIGNED_H |
/* |
* The x86 can do unaligned accesses itself. |
*/ |
#include <linux/unaligned/access_ok.h> |
#include <linux/unaligned/generic.h> |
#define get_unaligned __get_unaligned_le |
#define put_unaligned __put_unaligned_le |
#endif /* _ASM_X86_UNALIGNED_H */ |
/drivers/include/linux/unaligned/access_ok.h |
---|
0,0 → 1,67 |
#ifndef _LINUX_UNALIGNED_ACCESS_OK_H |
#define _LINUX_UNALIGNED_ACCESS_OK_H |
#include <linux/kernel.h> |
#include <asm/byteorder.h> |
static inline u16 get_unaligned_le16(const void *p) |
{ |
return le16_to_cpup((__le16 *)p); |
} |
static inline u32 get_unaligned_le32(const void *p) |
{ |
return le32_to_cpup((__le32 *)p); |
} |
static inline u64 get_unaligned_le64(const void *p) |
{ |
return le64_to_cpup((__le64 *)p); |
} |
static inline u16 get_unaligned_be16(const void *p) |
{ |
return be16_to_cpup((__be16 *)p); |
} |
static inline u32 get_unaligned_be32(const void *p) |
{ |
return be32_to_cpup((__be32 *)p); |
} |
static inline u64 get_unaligned_be64(const void *p) |
{ |
return be64_to_cpup((__be64 *)p); |
} |
static inline void put_unaligned_le16(u16 val, void *p) |
{ |
*((__le16 *)p) = cpu_to_le16(val); |
} |
static inline void put_unaligned_le32(u32 val, void *p) |
{ |
*((__le32 *)p) = cpu_to_le32(val); |
} |
static inline void put_unaligned_le64(u64 val, void *p) |
{ |
*((__le64 *)p) = cpu_to_le64(val); |
} |
static inline void put_unaligned_be16(u16 val, void *p) |
{ |
*((__be16 *)p) = cpu_to_be16(val); |
} |
static inline void put_unaligned_be32(u32 val, void *p) |
{ |
*((__be32 *)p) = cpu_to_be32(val); |
} |
static inline void put_unaligned_be64(u64 val, void *p) |
{ |
*((__be64 *)p) = cpu_to_be64(val); |
} |
#endif /* _LINUX_UNALIGNED_ACCESS_OK_H */ |
/drivers/include/linux/unaligned/generic.h |
---|
0,0 → 1,68 |
#ifndef _LINUX_UNALIGNED_GENERIC_H |
#define _LINUX_UNALIGNED_GENERIC_H |
/* |
* Cause a link-time error if we try an unaligned access other than |
* 1,2,4 or 8 bytes long |
*/ |
extern void __bad_unaligned_access_size(void); |
#define __get_unaligned_le(ptr) ((__force typeof(*(ptr)))({ \ |
__builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \ |
__bad_unaligned_access_size())))); \ |
})) |
#define __get_unaligned_be(ptr) ((__force typeof(*(ptr)))({ \ |
__builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)), \ |
__builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)), \ |
__bad_unaligned_access_size())))); \ |
})) |
#define __put_unaligned_le(val, ptr) ({ \ |
void *__gu_p = (ptr); \ |
switch (sizeof(*(ptr))) { \ |
case 1: \ |
*(u8 *)__gu_p = (__force u8)(val); \ |
break; \ |
case 2: \ |
put_unaligned_le16((__force u16)(val), __gu_p); \ |
break; \ |
case 4: \ |
put_unaligned_le32((__force u32)(val), __gu_p); \ |
break; \ |
case 8: \ |
put_unaligned_le64((__force u64)(val), __gu_p); \ |
break; \ |
default: \ |
__bad_unaligned_access_size(); \ |
break; \ |
} \ |
(void)0; }) |
#define __put_unaligned_be(val, ptr) ({ \ |
void *__gu_p = (ptr); \ |
switch (sizeof(*(ptr))) { \ |
case 1: \ |
*(u8 *)__gu_p = (__force u8)(val); \ |
break; \ |
case 2: \ |
put_unaligned_be16((__force u16)(val), __gu_p); \ |
break; \ |
case 4: \ |
put_unaligned_be32((__force u32)(val), __gu_p); \ |
break; \ |
case 8: \ |
put_unaligned_be64((__force u64)(val), __gu_p); \ |
break; \ |
default: \ |
__bad_unaligned_access_size(); \ |
break; \ |
} \ |
(void)0; }) |
#endif /* _LINUX_UNALIGNED_GENERIC_H */ |