diff -U 3 -d -r -N -- a/agpgart_be.c b/agpgart_be.c --- a/agpgart_be.c 2004-07-15 17:55:39.626955232 +0100 +++ b/agpgart_be.c 2004-07-15 17:51:22.674018016 +0100 @@ -1402,7 +1402,6 @@ } #endif - //atomic_inc(&page->count); get_page(page); set_bit(PG_locked, &page->flags); atomic_inc(&agp_bridge.current_memory_agp); @@ -1450,7 +1449,7 @@ put_page(page); UnlockPage(page); #else /* AGPGART_2_4_19 */ - atomic_dec(&page->count); + __put_page(page); clear_bit(PG_locked, &page->flags); wake_up(&page->wait); #endif /* AGPGART_2_4_19 */ @@ -4414,7 +4413,7 @@ if (page == NULL) return 0; - atomic_inc(&page->count); + get_page(page); set_bit(PG_locked, &page->flags); atomic_inc(&agp_bridge.current_memory_agp); @@ -4510,7 +4509,7 @@ put_page(page); UnlockPage(page); #else /* AGPGART_2_4_19 */ - atomic_dec(&page->count); + __put_page(page); clear_bit(PG_locked, &page->flags); wake_up(&page->wait); #endif /* AGPGART_2_4_19 */ diff -U 3 -d -r -N -- a/firegl_public.c b/firegl_public.c --- a/firegl_public.c 2004-07-15 17:55:39.626955232 +0100 +++ b/firegl_public.c 2004-07-15 17:51:22.677017560 +0100 @@ -189,9 +189,7 @@ #ifndef VMALLOC_VMADDR #define VMALLOC_VMADDR(x) ((unsigned long)(x)) #endif -#ifndef VMALLOC_VMADDR -#define VMALLOC_VMADDR(x) ((unsigned long)(x)) -#endif + // ============================================================ /* globals */ @@ -238,24 +236,15 @@ // ============================================================ /* global structures */ -int ip_firegl_open(struct inode* inode, struct file* filp) -{ return firegl_open(inode, filp); } -int ip_firegl_release(struct inode* inode, struct file* filp) -{ return firegl_release(inode, filp); } -int ip_firegl_ioctl(struct inode* inode, struct file* filp, unsigned int cmd, unsigned long arg) -{ return firegl_ioctl(inode, filp, cmd, arg); } -int ip_firegl_mmap(struct file* filp, struct vm_area_struct* vma) -{ return firegl_mmap(filp, vma); } - static struct file_operations firegl_fops = { #ifdef THIS_MODULE owner: THIS_MODULE, #endif - open: ip_firegl_open, - release: ip_firegl_release, - ioctl: ip_firegl_ioctl, - mmap: ip_firegl_mmap, + open: firegl_open, + release: firegl_release, + ioctl: firegl_ioctl, + mmap: firegl_mmap, }; typedef struct { @@ -683,7 +672,7 @@ typedef wait_queue_t* wait_queue_head_t; #endif -__ke_wait_queue_head_t* ATI_API_CALL __ke_alloc_wait_queue_head_struct(void) +__ke_wait_queue_head_t* __ke_alloc_wait_queue_head_struct(void) { __ke_wait_queue_head_t* queue_head; queue_head = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL); @@ -700,13 +689,13 @@ return queue_head; } -void ATI_API_CALL __ke_free_wait_queue_head_struct(__ke_wait_queue_head_t* queue_head) +void __ke_free_wait_queue_head_struct(__ke_wait_queue_head_t* queue_head) { if (queue_head) kfree(queue_head); } -__ke_wait_queue_t* ATI_API_CALL __ke_alloc_wait_queue_struct(void) +__ke_wait_queue_t* __ke_alloc_wait_queue_struct(void) { __ke_wait_queue_t* queue; queue = kmalloc(sizeof(wait_queue_t), GFP_KERNEL); @@ -714,18 +703,18 @@ return queue; } -void ATI_API_CALL __ke_free_wait_queue_struct(__ke_wait_queue_t* queue) +void __ke_free_wait_queue_struct(__ke_wait_queue_t* queue) { if (queue) kfree(queue); } -void ATI_API_CALL __ke_wake_up_interruptible(__ke_wait_queue_head_t* queue_head) +void __ke_wake_up_interruptible(__ke_wait_queue_head_t* queue_head) { wake_up_interruptible((wait_queue_head_t*)(void *)queue_head); } -void ATI_API_CALL __ke_add_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry) +void __ke_add_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry) { // initialisation (delayed) #ifdef __WAITQUEUE_INITIALIZER @@ -753,7 +742,7 @@ add_wait_queue((wait_queue_head_t*)(void *)queue_head, (wait_queue_t*)(void *)entry); } -void ATI_API_CALL __ke_remove_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry) +void __ke_remove_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry) { // current->state = TASK_RUNNING; remove_wait_queue((wait_queue_head_t*)(void *)queue_head, @@ -761,27 +750,27 @@ } // sheduler -void ATI_API_CALL __ke_schedule(void) +void __ke_schedule(void) { schedule(); } -int ATI_API_CALL __ke_signal_pending(void) +int __ke_signal_pending(void) { return signal_pending(current); } -void ATI_API_CALL __ke_set_current_state_task_interruptible(void) +void __ke_set_current_state_task_interruptible(void) { current->state = TASK_INTERRUPTIBLE; } -void ATI_API_CALL __ke_set_current_state_task_running(void) +void __ke_set_current_state_task_running(void) { current->state = TASK_RUNNING; } -void ATI_API_CALL __ke_configure_sigmask(__ke_sigset_t *pSigMask) +void __ke_configure_sigmask(__ke_sigset_t *pSigMask) { sigemptyset((sigset_t*)(void *)pSigMask); sigaddset((sigset_t*)(void *)pSigMask, SIGSTOP); @@ -790,14 +779,14 @@ sigaddset((sigset_t*)(void *)pSigMask, SIGTTOU); } -void ATI_API_CALL __ke_block_all_signals(int (*ATI_API_CALL notifier)(void *priv), void *pPriv, __ke_sigset_t *pSigMask) +void __ke_block_all_signals(int (*notifier)(void *priv), void *pPriv, __ke_sigset_t *pSigMask) { #if LINUX_VERSION_CODE >= 0x020400 block_all_signals(notifier,pPriv,(sigset_t*)(void *)pSigMask); #endif } -void ATI_API_CALL __ke_unblock_all_signals(void) +void __ke_unblock_all_signals(void) { #if LINUX_VERSION_CODE >= 0x020400 unblock_all_signals(); @@ -839,7 +828,7 @@ #endif #if !defined(__ia64__) -unsigned long ATI_API_CALL __ke__cmpxchg(volatile void *ptr, unsigned long old, +unsigned long __ke__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size) { #ifndef __HAVE_ARCH_CMPXCHG @@ -852,19 +841,19 @@ /*****************************************************************************/ -__ke_dev_t ATI_API_CALL __ke_getdevice(__ke_device_t *dev) +__ke_dev_t __ke_getdevice(__ke_device_t *dev) { return ((device_t*)dev)->device; } -const char* ATI_API_CALL __ke_module_parm(void) +const char* __ke_module_parm(void) { return firegl; } /*****************************************************************************/ -int ATI_API_CALL __ke_inode_rdev_minor(struct inode* inode) +int __ke_inode_rdev_minor(struct inode* inode) { #ifndef MINOR return minor(inode->i_rdev); @@ -875,27 +864,27 @@ /*****************************************************************************/ -void* ATI_API_CALL __ke_get_file_priv(struct file* filp) +void* __ke_get_file_priv(struct file* filp) { return filp->private_data; } -void ATI_API_CALL __ke_set_file_priv(struct file* filp, void* private_data) +void __ke_set_file_priv(struct file* filp, void* private_data) { filp->private_data = private_data; } -int ATI_API_CALL __ke_file_excl_open(struct file* filp) +int __ke_file_excl_open(struct file* filp) { return (filp->f_flags & O_EXCL) != 0; } -int ATI_API_CALL __ke_file_rw_open(struct file* filp) +int __ke_file_rw_open(struct file* filp) { return (filp->f_flags & 3) != 0; } -unsigned int ATI_API_CALL __ke_file_counter(struct file *filp) +unsigned int __ke_file_counter(struct file *filp) { #if LINUX_VERSION_CODE >= 0x020400 return filp->f_count.counter; @@ -906,24 +895,24 @@ /*****************************************************************************/ -int ATI_API_CALL __ke_getpid(void) +int __ke_getpid(void) { return current->pid; } -int ATI_API_CALL __ke_geteuid(void) +int __ke_geteuid(void) { return current->euid; } /*****************************************************************************/ -unsigned long ATI_API_CALL __ke_jiffies(void) +unsigned long __ke_jiffies(void) { return jiffies; } -void ATI_API_CALL __ke_udelay(unsigned long usecs) // delay in usec +void __ke_udelay(unsigned long usecs) // delay in usec { unsigned long start; unsigned long stop; @@ -959,7 +948,7 @@ udelay(usecs); /* delay value might get checked once again */ } -void ATI_API_CALL __ke_mdelay(unsigned long msecs) // delay in msec +void __ke_mdelay(unsigned long msecs) // delay in msec { mdelay(msecs); } @@ -967,33 +956,33 @@ /*****************************************************************************/ // TODO: These here get obsolete in future, use the ia64 code below // Johannes -unsigned long ATI_API_CALL __ke_virt_to_bus(void* address) +unsigned long __ke_virt_to_bus(void* address) { return virt_to_bus(address); } -unsigned long ATI_API_CALL __ke_virt_to_phys(void* address) +unsigned long __ke_virt_to_phys(void* address) { return virt_to_phys(address); } -void* ATI_API_CALL __ke_high_memory(void) +void* __ke_high_memory(void) { return high_memory; } -int ATI_API_CALL __ke_pci_enable_device(__ke_pci_dev_t* dev) +int __ke_pci_enable_device(__ke_pci_dev_t* dev) { return (pci_enable_device( (struct pci_dev*)(void *)dev )); } #if defined(__x86_64__) || defined(__ia64__) -void* ATI_API_CALL __ke_pci_alloc_consistent(__ke_pci_dev_t* dev, int size, void *dma_handle) +void* __ke_pci_alloc_consistent(__ke_pci_dev_t* dev, int size, void *dma_handle) { return (pci_alloc_consistent( (struct pci_dev*)(void *)dev, size, dma_handle)); } -void ATI_API_CALL __ke_pci_free_consistent(__ke_pci_dev_t* dev, int size, unsigned long cpu_addr, +void __ke_pci_free_consistent(__ke_pci_dev_t* dev, int size, unsigned long cpu_addr, unsigned int dma_handle) { pci_free_consistent( (struct pci_dev*)(void *)dev, size, (void *)cpu_addr, @@ -1003,7 +992,7 @@ /*****************************************************************************/ -int ATI_API_CALL __ke_error_code(enum __ke_error_num errcode) +int __ke_error_code(enum __ke_error_num errcode) { switch (errcode) { @@ -1038,7 +1027,7 @@ /*****************************************************************************/ -void ATI_API_CALL __ke_mod_inc_use_count(void) +void __ke_mod_inc_use_count(void) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) __module_get(THIS_MODULE); @@ -1047,7 +1036,7 @@ #endif } -void ATI_API_CALL __ke_mod_dec_use_count(void) +void __ke_mod_dec_use_count(void) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_put(THIS_MODULE); @@ -1058,86 +1047,86 @@ /*****************************************************************************/ -void ATI_API_CALL __ke_down_struct_sem(__ke_device_t *dev, int index) +void __ke_down_struct_sem(__ke_device_t *dev, int index) { down(&(((device_t*)dev)->struct_sem[index])); } -void ATI_API_CALL __ke_up_struct_sem(__ke_device_t *dev, int index) +void __ke_up_struct_sem(__ke_device_t *dev, int index) { up(&(((device_t*)dev)->struct_sem[index])); } -void ATI_API_CALL __ke_sema_init(struct semaphore* sem, int value) +void __ke_sema_init(struct semaphore* sem, int value) { sema_init(sem, value); } -__ke_size_t ATI_API_CALL __ke_sema_size(void) +__ke_size_t __ke_sema_size(void) { return sizeof(struct semaphore); } -void ATI_API_CALL __ke_down(struct semaphore* sem) +void __ke_down(struct semaphore* sem) { down(sem); } -void ATI_API_CALL __ke_up(struct semaphore* sem) +void __ke_up(struct semaphore* sem) { up(sem); } /*****************************************************************************/ -void ATI_API_CALL __ke_atomic_inc(void* v) +void __ke_atomic_inc(void* v) { atomic_inc((atomic_t*)v); } -void ATI_API_CALL __ke_atomic_dec(void* v) +void __ke_atomic_dec(void* v) { atomic_dec((atomic_t*)v); } -void ATI_API_CALL __ke_atomic_add(int val, void* v) +void __ke_atomic_add(int val, void* v) { atomic_add(val, (atomic_t*)v); } -void ATI_API_CALL __ke_atomic_sub(int val, void* v) +void __ke_atomic_sub(int val, void* v) { atomic_sub(val, (atomic_t*)v); } -int ATI_API_CALL __ke_atomic_read(void* v) +int __ke_atomic_read(void* v) { return atomic_read((atomic_t*)v); } -void ATI_API_CALL __ke_atomic_set(void* v, int val) +void __ke_atomic_set(void* v, int val) { atomic_set((atomic_t*)v, val); } /*****************************************************************************/ -void ATI_API_CALL __ke_spin_lock(__ke_device_t *dev, int ndx) +void __ke_spin_lock(__ke_device_t *dev, int ndx) { spin_lock(&(((device_t*)dev)->spinlock[ndx])); } -void ATI_API_CALL __ke_spin_unlock(__ke_device_t *dev __attribute__((unused)), int ndx __attribute__((unused))) +void __ke_spin_unlock(__ke_device_t *dev __attribute__((unused)), int ndx __attribute__((unused))) { spin_unlock(&(((device_t*)dev)->spinlock[ndx])); } -void ATI_API_CALL __ke_lock_kernel(void) +void __ke_lock_kernel(void) { lock_kernel(); } -void ATI_API_CALL __ke_unlock_kernel(void) +void __ke_unlock_kernel(void) { unlock_kernel(); } @@ -1152,7 +1141,7 @@ typedef int (*PFNMUNLOCK)(unsigned long start, __ke_size_t len); -int ATI_API_CALL __ke_sys_mlock(unsigned long start, __ke_size_t len) +int __ke_sys_mlock(unsigned long start, __ke_size_t len) { #ifdef FGL_USE_SCT PFNMLOCK sys_mlock = (PFNMLOCK)sys_call_table[__NR_mlock]; @@ -1167,7 +1156,7 @@ #endif } -int ATI_API_CALL __ke_sys_munlock(unsigned long start, __ke_size_t len) +int __ke_sys_munlock(unsigned long start, __ke_size_t len) { #ifdef FGL_USE_SCT PFNMUNLOCK sys_munlock = (PFNMUNLOCK)sys_call_table[__NR_munlock]; @@ -1185,7 +1174,7 @@ typedef int (*PFNMODIFYLDT)(int func, void *ptr, unsigned long bytecount); -int ATI_API_CALL __ke_sys_modify_ldt(int func, void *ptr, unsigned long bytecount) +int __ke_sys_modify_ldt(int func, void *ptr, unsigned long bytecount) { #ifdef FGL_USE_SCT PFNMODIFYLDT sys_modify_ldt = (PFNMODIFYLDT)sys_call_table[__NR_modify_ldt]; @@ -1210,7 +1199,7 @@ #ifdef __KE_NO_VSPRINTF #if LINUX_VERSION_CODE >= 0x020400 -void ATI_API_CALL __ke_printk(const char* fmt, ...) +void __ke_printk(const char* fmt, ...) { char buffer[256]; va_list marker; @@ -1241,7 +1230,7 @@ #else -void ATI_API_CALL __ke_print_info(const char* fmt, ...) +void __ke_print_info(const char* fmt, ...) { char msg[256] = KERN_INFO;: va_list marker; @@ -1251,7 +1240,7 @@ va_end(marker); } -void ATI_API_CALL __ke_print_error(const char* fmt, ...) +void __ke_print_error(const char* fmt, ...) { char msg[256] = KERN_ERR; va_list marker; @@ -1261,7 +1250,7 @@ va_end(marker); } -void ATI_API_CALL __ke_print_debug(const char* fmt, ...) +void __ke_print_debug(const char* fmt, ...) { char msg[256] = KERN_DEBUG; va_list marker; @@ -1275,7 +1264,7 @@ /*****************************************************************************/ -int ATI_API_CALL __ke_capable(enum __ke_cap cap) +int __ke_capable(enum __ke_cap cap) { switch (cap) { @@ -1291,7 +1280,7 @@ return capable(cap); } -void ATI_API_CALL __ke_cap_effective_raise(enum __ke_cap cap) +void __ke_cap_effective_raise(enum __ke_cap cap) { switch (cap) { @@ -1307,17 +1296,17 @@ cap_raise(current->cap_effective, cap); } -__ke_u32 ATI_API_CALL __ke_get_cap_effective() +__ke_u32 __ke_get_cap_effective() { return cap_t(current->cap_effective); } -void ATI_API_CALL __ke_set_cap_effective(__ke_u32 cap) +void __ke_set_cap_effective(__ke_u32 cap) { cap_t(current->cap_effective) = cap; } -unsigned long ATI_API_CALL __ke_ram_available(void) +unsigned long __ke_ram_available(void) { struct sysinfo si; @@ -1330,22 +1319,22 @@ #endif } -int ATI_API_CALL __ke_copy_from_user(void* to, const void* from, __ke_size_t size) +int __ke_copy_from_user(void* to, const void* from, __ke_size_t size) { return copy_from_user(to, from, size); } -int ATI_API_CALL __ke_copy_to_user(void* to, const void* from, __ke_size_t size) +int __ke_copy_to_user(void* to, const void* from, __ke_size_t size) { return copy_to_user(to, from, size); } -int ATI_API_CALL __ke_verify_area(int type, const void * addr, unsigned long size) +int __ke_verify_area(int type, const void * addr, unsigned long size) { return verify_area(type, addr, size); } -int ATI_API_CALL __ke_get_pci_device_info(__ke_pci_dev_t* dev, __ke_pci_device_info_t *pinfo) +int __ke_get_pci_device_info(__ke_pci_dev_t* dev, __ke_pci_device_info_t *pinfo) { if ( dev ) { @@ -1357,7 +1346,7 @@ return -EINVAL; } -int ATI_API_CALL __ke_check_pci(int busnum, int devnum, int funcnum, __ke_u16* vendor, __ke_u16* device, unsigned int* irq) +int __ke_check_pci(int busnum, int devnum, int funcnum, __ke_u16* vendor, __ke_u16* device, unsigned int* irq) { struct pci_dev* pci_dev; @@ -1377,7 +1366,7 @@ return 1; } -int ATI_API_CALL __ke_pci_get_irq(__ke_pci_dev_t *dev, unsigned int* irq) +int __ke_pci_get_irq(__ke_pci_dev_t *dev, unsigned int* irq) { if (!dev) return 0; @@ -1388,52 +1377,52 @@ return 1; } -__ke_pci_dev_t* ATI_API_CALL __ke_pci_find_device (unsigned int vendor, unsigned int dev, __ke_pci_dev_t* from) +__ke_pci_dev_t* __ke_pci_find_device (unsigned int vendor, unsigned int dev, __ke_pci_dev_t* from) { return (__ke_pci_dev_t*)pci_find_device( vendor, dev, (struct pci_dev *)(void *)from ); } -void* ATI_API_CALL __ke_malloc(__ke_size_t size) +void* __ke_malloc(__ke_size_t size) { return kmalloc(size, GFP_KERNEL); } -void ATI_API_CALL __ke_free_s(void* p, __ke_size_t size) +void __ke_free_s(void* p, __ke_size_t size) { kfree(p); } -void* ATI_API_CALL __ke_vmalloc(__ke_size_t size) +void* __ke_vmalloc(__ke_size_t size) { return vmalloc(size); } -void ATI_API_CALL __ke_vfree(void* p) +void __ke_vfree(void* p) { return vfree(p); } -void* ATI_API_CALL __ke_get_free_page(void) +void* __ke_get_free_page(void) { return (void*)__get_free_page(GFP_KERNEL); } -void* ATI_API_CALL __ke_get_free_pages(int order) +void* __ke_get_free_pages(int order) { return (void*)__get_free_pages(GFP_KERNEL, order); } -void ATI_API_CALL __ke_free_page(void* pt) +void __ke_free_page(void* pt) { free_page((unsigned long)pt); } -void ATI_API_CALL __ke_free_pages(void* pt, int order) +void __ke_free_pages(void* pt, int order) { free_pages((unsigned long)pt, order); } -void ATI_API_CALL __ke_mem_map_reserve(void* pt) +void __ke_mem_map_reserve(void* pt) { #if LINUX_VERSION_CODE < 0x020400 mem_map_reserve(MAP_NR((unsigned long)pt)); @@ -1446,7 +1435,7 @@ #endif } -void ATI_API_CALL __ke_mem_map_unreserve(void* pt) +void __ke_mem_map_unreserve(void* pt) { #if LINUX_VERSION_CODE < 0x020400 mem_map_unreserve(MAP_NR((unsigned long)pt)); @@ -1459,7 +1448,7 @@ #endif } -void ATI_API_CALL __ke_virt_reserve(void* virt) +void __ke_virt_reserve(void* virt) { #if LINUX_VERSION_CODE < 0x020400 set_bit(PG_reserved, @@ -1470,7 +1459,7 @@ #endif } -void ATI_API_CALL __ke_virt_unreserve(void* virt) +void __ke_virt_unreserve(void* virt) { #if LINUX_VERSION_CODE < 0x020400 clear_bit(PG_reserved, @@ -1482,48 +1471,48 @@ } #ifdef __ia64__ -void* ATI_API_CALL __ke_get_vmptr( struct _agp_memory* memory ) +void* __ke_get_vmptr( struct _agp_memory* memory ) { return memory->vmptr; } #endif -void* ATI_API_CALL __ke_ioremap(unsigned long offset, unsigned long size) +void* __ke_ioremap(unsigned long offset, unsigned long size) { return ioremap(offset, size); } -void* ATI_API_CALL __ke_ioremap_nocache(unsigned long offset, unsigned long size) +void* __ke_ioremap_nocache(unsigned long offset, unsigned long size) { return ioremap_nocache(offset, size); } -void ATI_API_CALL __ke_iounmap(void* pt) +void __ke_iounmap(void* pt) { iounmap(pt); } -int ATI_API_CALL __ke_verify_read_access(void* addr, __ke_size_t size) +int __ke_verify_read_access(void* addr, __ke_size_t size) { return access_ok(VERIFY_READ, addr, size) ? 0 : -EFAULT; } -int ATI_API_CALL __ke_verify_write_access(void* addr, __ke_size_t size) +int __ke_verify_write_access(void* addr, __ke_size_t size) { return access_ok(VERIFY_WRITE, addr, size) ? 0 : -EFAULT; } -struct mm_struct* ATI_API_CALL __ke_init_mm(void) +struct mm_struct* __ke_init_mm(void) { return &init_mm; } -struct mm_struct* ATI_API_CALL __ke_current_mm(void) +struct mm_struct* __ke_current_mm(void) { return current->mm; } -unsigned long ATI_API_CALL __ke_get_vm_phys_addr(struct mm_struct* mm, unsigned long virtual_addr) +unsigned long __ke_get_vm_phys_addr(struct mm_struct* mm, unsigned long virtual_addr) { unsigned long pte_linear; pgd_t* pgd_p; @@ -1558,7 +1547,7 @@ #endif /* LINUX_VERSION_CODE < 0x020400 */ } -unsigned long* ATI_API_CALL __ke_get_vm_phys_addr_list(struct mm_struct* mm, unsigned long virtual_addr, unsigned long pages) +unsigned long* __ke_get_vm_phys_addr_list(struct mm_struct* mm, unsigned long virtual_addr, unsigned long pages) { unsigned long *phys_table, *pt; unsigned long n, va; @@ -1580,42 +1569,42 @@ return phys_table; } -void* ATI_API_CALL __ke_memset(void* s, int c, __ke_size_t count) +void* __ke_memset(void* s, int c, __ke_size_t count) { return memset(s, c, count); } -void* ATI_API_CALL __ke_memcpy(void* d, const void* s, __ke_size_t count) +void* __ke_memcpy(void* d, const void* s, __ke_size_t count) { return memcpy(d, s, count); } -__ke_size_t ATI_API_CALL __ke_strlen(const char *s) +__ke_size_t __ke_strlen(const char *s) { return strlen(s); } -char* ATI_API_CALL __ke_strcpy(char* d, const char* s) +char* __ke_strcpy(char* d, const char* s) { return strcpy(d, s); } -char* ATI_API_CALL __ke_strncpy(char* d, const char* s, __ke_size_t count) +char* __ke_strncpy(char* d, const char* s, __ke_size_t count) { return strncpy(d, s, count); } -int ATI_API_CALL __ke_strcmp(const char* string1, const char* string2) +int __ke_strcmp(const char* string1, const char* string2) { return strcmp(string1, string2); } -int ATI_API_CALL __ke_strncmp(const char* string1, const char* string2, __ke_size_t count) +int __ke_strncmp(const char* string1, const char* string2, __ke_size_t count) { return strncmp(string1, string2, count); } -int ATI_API_CALL __ke_sprintf(char* buf, const char* fmt, ...) +int __ke_sprintf(char* buf, const char* fmt, ...) { va_list marker; @@ -1628,12 +1617,12 @@ /*****************************************************************************/ -void ATI_API_CALL __ke_set_bit(int nr, volatile void * addr) +void __ke_set_bit(int nr, volatile void * addr) { set_bit(nr, addr); } -void ATI_API_CALL __ke_clear_bit(int nr, volatile void * addr) +void __ke_clear_bit(int nr, volatile void * addr) { clear_bit(nr, addr); } @@ -1658,7 +1647,7 @@ } #endif /* __SMP__ */ -int ATI_API_CALL __ke_flush_cache(void) +int __ke_flush_cache(void) { #ifdef __SMP__ #if LINUX_VERSION_CODE < 0x020501 @@ -1694,7 +1683,7 @@ /*****************************************************************************/ -int ATI_API_CALL __ke_config_mtrr(void) +int __ke_config_mtrr(void) { #ifdef CONFIG_MTRR return 1; @@ -1703,7 +1692,7 @@ #endif /* !CONFIG_MTRR */ } -int ATI_API_CALL __ke_mtrr_add_wc(unsigned long base, unsigned long size) +int __ke_mtrr_add_wc(unsigned long base, unsigned long size) { #ifdef CONFIG_MTRR return mtrr_add(base, size, MTRR_TYPE_WRCOMB, 1); @@ -1712,7 +1701,7 @@ #endif /* !CONFIG_MTRR */ } -int ATI_API_CALL __ke_mtrr_del(int reg, unsigned long base, unsigned long size) +int __ke_mtrr_del(int reg, unsigned long base, unsigned long size) { #ifdef CONFIG_MTRR return mtrr_del(reg, base, size); @@ -1723,64 +1712,64 @@ /*****************************************************************************/ -int ATI_API_CALL __ke_pci_read_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 *val) +int __ke_pci_read_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 *val) { return pci_read_config_byte((struct pci_dev*)(void *)dev, where, val); } -int ATI_API_CALL __ke_pci_read_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 *val) +int __ke_pci_read_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 *val) { return pci_read_config_word((struct pci_dev*)(void *)dev, where, val); } -int ATI_API_CALL __ke_pci_read_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 *val) +int __ke_pci_read_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 *val) { return pci_read_config_dword((struct pci_dev*)(void *)dev, where, val); } -int ATI_API_CALL __ke_pci_write_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 val) +int __ke_pci_write_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 val) { return pci_write_config_byte((struct pci_dev*)(void *)dev, where, val); } -int ATI_API_CALL __ke_pci_write_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 val) +int __ke_pci_write_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 val) { return pci_write_config_word((struct pci_dev*)(void *)dev, where, val); } -int ATI_API_CALL __ke_pci_write_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 val) +int __ke_pci_write_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 val) { return pci_write_config_dword((struct pci_dev*)(void *)dev, where, val); } /*****************************************************************************/ -void ATI_API_CALL __ke_outb(unsigned char value, unsigned short port) +void __ke_outb(unsigned char value, unsigned short port) { outb(value, port); } -void ATI_API_CALL __ke_outw(unsigned short value, unsigned short port) +void __ke_outw(unsigned short value, unsigned short port) { outw(value, port); } -void ATI_API_CALL __ke_outl(unsigned int value, unsigned short port) +void __ke_outl(unsigned int value, unsigned short port) { outl(value, port); } -char ATI_API_CALL __ke_inb(unsigned short port) +char __ke_inb(unsigned short port) { return inb(port); } -short ATI_API_CALL __ke_inw(unsigned short port) +short __ke_inw(unsigned short port) { return inw(port); } -int ATI_API_CALL __ke_inl(unsigned short port) +int __ke_inl(unsigned short port) { return inl(port); } @@ -1788,18 +1777,18 @@ /*****************************************************************************/ // Interrupt support -void ATI_API_CALL __ke_enable_irq(int irq) +void __ke_enable_irq(int irq) { enable_irq( irq ); } -void ATI_API_CALL __ke_disable_irq(int irq) +void __ke_disable_irq(int irq) { disable_irq( irq ); } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71) -int ATI_API_CALL __ke_request_irq(unsigned int irq, +int __ke_request_irq(unsigned int irq, void (*handler)(int, void *, void *), const char *dev_name, void *dev_id) { @@ -1808,7 +1797,7 @@ SA_SHIRQ, dev_name, dev_id); } -void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id) +void __ke_free_irq(unsigned int irq, void *dev_id) { free_irq(irq, dev_id); } @@ -1821,8 +1810,8 @@ return IRQ_HANDLED; } -int ATI_API_CALL __ke_request_irq(unsigned int irq, - void (*ATI_API_CALL handler)(int, void *, void *), +int __ke_request_irq(unsigned int irq, + void (*handler)(int, void *, void *), const char *dev_name, void *dev_id) { irq_handler_func = handler; @@ -1831,7 +1820,7 @@ SA_SHIRQ, dev_name, dev_id); } -void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id) +void __ke_free_irq(unsigned int irq, void *dev_id) { free_irq(irq, dev_id); irq_handler_func = NULL; @@ -2021,8 +2010,8 @@ pMmPage = virt_to_page(kaddr); #endif /* LINUX_VERSION_CODE < 0x020400 */ -// atomic_inc(&(pMmPage->count)); /* inc usage count of page */ - get_page(pMmPage); + get_page(pMmPage); /* inc usage count of page */ + #if LINUX_VERSION_CODE >= 0x020400 // __KE_DEBUG3("vm-address 0x%08lx => kernel-page-address 0x%p\n", // address, page_address(pMmPage)); @@ -2063,7 +2052,7 @@ // Don't increment page usage count, cause ctx pages are allocated // with drm_alloc_pages, which marks all pages as reserved. Reserved // pages' usage count is not decremented by the kernel during unmap!!! - atomic_inc(&(pMmPage->count)); /* inc usage count of page */ + get_page(pMmPage); /* inc usage count of page */ #endif #if LINUX_VERSION_CODE >= 0x020400 @@ -2197,22 +2186,22 @@ #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0) */ -void* ATI_API_CALL __ke_vma_file_priv(struct vm_area_struct* vma) +void* __ke_vma_file_priv(struct vm_area_struct* vma) { return vma->vm_file->private_data; } -unsigned long ATI_API_CALL __ke_vm_start(struct vm_area_struct* vma) +unsigned long __ke_vm_start(struct vm_area_struct* vma) { return vma->vm_start; } -unsigned long ATI_API_CALL __ke_vm_end(struct vm_area_struct* vma) +unsigned long __ke_vm_end(struct vm_area_struct* vma) { return vma->vm_end; } -unsigned long ATI_API_CALL __ke_vm_offset(struct vm_area_struct* vma) +unsigned long __ke_vm_offset(struct vm_area_struct* vma) { #if LINUX_VERSION_CODE < 0x020319 return vma->vm_offset; @@ -2221,7 +2210,7 @@ #endif/* LINUX_VERSION_CODE >= 0x020319 */ } -char* ATI_API_CALL __ke_vm_flags_str(struct vm_area_struct* vma, char* buf) +char* __ke_vm_flags_str(struct vm_area_struct* vma, char* buf) { *(buf + 0) = vma->vm_flags & VM_READ ? 'r' : '-'; *(buf + 1) = vma->vm_flags & VM_WRITE ? 'w' : '-'; @@ -2233,7 +2222,7 @@ return buf; } -char* ATI_API_CALL __ke_vm_page_prot_str(struct vm_area_struct* vma, char* buf) +char* __ke_vm_page_prot_str(struct vm_area_struct* vma, char* buf) { int i = 0; @@ -2260,7 +2249,7 @@ return buf; } -char* ATI_API_CALL __ke_vm_phys_addr_str(struct vm_area_struct* vma, +char* __ke_vm_phys_addr_str(struct vm_area_struct* vma, char* buf, unsigned long virtual_addr, unsigned long* phys_address) @@ -2313,16 +2302,11 @@ return buf; } -void ip_drm_vm_open(struct vm_area_struct* vma) -{ drm_vm_open(vma); } -void ip_drm_vm_close(struct vm_area_struct* vma) -{ drm_vm_close(vma); } - static struct vm_operations_struct vm_ops = { nopage: vm_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; #ifdef __AGP__BUILTIN__ @@ -2330,8 +2314,8 @@ static struct vm_operations_struct vm_cant_ops = { nopage: vm_cant_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; #endif /* __ia64_ */ #endif /* __AGP__BUILTIN__ */ @@ -2339,22 +2323,22 @@ static struct vm_operations_struct vm_shm_ops = { nopage: vm_shm_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; static struct vm_operations_struct vm_pci_bq_ops = { nopage: vm_dma_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; static struct vm_operations_struct vm_ctx_ops = { nopage: vm_dma_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; #ifdef __AGP__BUILTIN__ @@ -2362,20 +2346,20 @@ static struct vm_operations_struct vm_agp_bq_ops = { nopage: vm_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; #else static struct vm_operations_struct vm_cant_agp_bq_ops = { nopage: vm_cant_nopage, - open: ip_drm_vm_open, - close: ip_drm_vm_close, + open: drm_vm_open, + close: drm_vm_close, }; #endif /* __ia64_ */ #endif /* __AGP__BUILTIN__ */ -int ATI_API_CALL __ke_vm_map(struct file* filp, +int __ke_vm_map(struct file* filp, struct vm_area_struct* vma, enum __ke_vm_maptype type, int readonly) @@ -2654,7 +2638,7 @@ #endif // !USE_FIREGL_AGPGART_IMPLEMENTATION static -int ATI_API_CALL __ke_firegl_agpgart_available(void) +int __ke_firegl_agpgart_available(void) { int retval; @@ -2677,7 +2661,7 @@ } static -int ATI_API_CALL __ke_agpgart_available(void) +int __ke_agpgart_available(void) { #ifdef __AGP__ unsigned int found = 0; @@ -2785,7 +2769,7 @@ return 0; /* failed */ } -int ATI_API_CALL __ke_agp_available(int use_internal) +int __ke_agp_available(int use_internal) { int available = 0; @@ -2801,7 +2785,7 @@ return available; } -void ATI_API_CALL __ke_agp_uninit(void) +void __ke_agp_uninit(void) { if (firegl_agp) { @@ -2830,7 +2814,7 @@ } #ifdef FGL -struct _agp_memory* ATI_API_CALL __ke_agp_allocate_memory_phys_list(__ke_size_t pages, unsigned long type, unsigned long * phys_addr) +struct _agp_memory* __ke_agp_allocate_memory_phys_list(__ke_size_t pages, unsigned long type, unsigned long * phys_addr) { #if 0 #ifdef __AGP__ @@ -2844,7 +2828,7 @@ } #endif -void ATI_API_CALL __ke_agp_free_memory(struct _agp_memory* handle) +void __ke_agp_free_memory(struct _agp_memory* handle) { #ifdef __AGP__ if (AGP_AVAILABLE(free_memory)) @@ -2854,7 +2838,7 @@ return FIREGL_agp_free_memory((FIREGL_agp_memory*)handle); } -struct _agp_memory* ATI_API_CALL __ke_agp_allocate_memory(__ke_size_t pages, unsigned long type) +struct _agp_memory* __ke_agp_allocate_memory(__ke_size_t pages, unsigned long type) { #ifdef __AGP__ if (AGP_AVAILABLE(allocate_memory)) @@ -2865,7 +2849,7 @@ return NULL; } -int ATI_API_CALL __ke_agp_bind_memory(struct _agp_memory* handle, __ke_off_t start) +int __ke_agp_bind_memory(struct _agp_memory* handle, __ke_off_t start) { #ifdef __AGP__ if (AGP_AVAILABLE(bind_memory)) @@ -2876,7 +2860,7 @@ return -EINVAL; } -int ATI_API_CALL __ke_agp_unbind_memory(struct _agp_memory* handle) +int __ke_agp_unbind_memory(struct _agp_memory* handle) { #ifdef __AGP__ if (AGP_AVAILABLE(unbind_memory)) @@ -2887,7 +2871,7 @@ return -EINVAL; } -int ATI_API_CALL __ke_agp_enable(unsigned long mode) +int __ke_agp_enable(unsigned long mode) { #ifdef __AGP__ if (AGP_AVAILABLE(enable)) @@ -2904,7 +2888,7 @@ return -EINVAL; } -int ATI_API_CALL __ke_read_agp_caps_registers(__ke_pci_dev_t* dev, unsigned int *caps) +int __ke_read_agp_caps_registers(__ke_pci_dev_t* dev, unsigned int *caps) { u8 capndx; u32 cap_id; @@ -2935,7 +2919,7 @@ return -ENODATA; } -int ATI_API_CALL __ke_agp_acquire(void) +int __ke_agp_acquire(void) { #ifdef __AGP__ if (AGP_AVAILABLE(acquire)) @@ -2946,7 +2930,7 @@ return -EINVAL; } -void ATI_API_CALL __ke_agp_release(void) +void __ke_agp_release(void) { #ifdef __AGP__ if (AGP_AVAILABLE(release)) @@ -2956,7 +2940,7 @@ FIREGL_agp_backend_release(); } -void ATI_API_CALL __ke_agp_copy_info(__ke_agp_kern_info_t* info) +void __ke_agp_copy_info(__ke_agp_kern_info_t* info) { struct pci_dev *device = NULL; @@ -3043,7 +3027,7 @@ } } -unsigned long ATI_API_CALL __ke_agp_memory_handle(struct _agp_memory* handle) +unsigned long __ke_agp_memory_handle(struct _agp_memory* handle) { if (firegl_agp) #ifdef USE_FIREGL_AGPGART_IMPLEMENTATION @@ -3059,7 +3043,7 @@ #endif /* !__AGP__ */ } -unsigned long ATI_API_CALL __ke_agp_memory_page_count(struct _agp_memory* handle) +unsigned long __ke_agp_memory_page_count(struct _agp_memory* handle) { if (firegl_agp) #ifdef USE_FIREGL_AGPGART_IMPLEMENTATION @@ -3075,13 +3059,13 @@ #endif /* !__AGP__ */ } -int ATI_API_CALL __ke_smp_processor_id(void) +int __ke_smp_processor_id(void) { return (int)(smp_processor_id()); } -void ATI_API_CALL __ke_smp_call_function( void (*ATI_API_CALL func)(void *info) ) +void __ke_smp_call_function( void (*func)(void *info) ) { smp_call_function( func, NULL, 0, 1 ); } @@ -3111,7 +3095,7 @@ return 0; // does not match } -int ATI_API_CALL __ke_is_athlon(void) +int __ke_is_athlon(void) { register int bAthlon; __asm @@ -3198,7 +3182,7 @@ #endif -int ATI_API_CALL __ke_amd_adv_spec_cache_feature(void) +int __ke_amd_adv_spec_cache_feature(void) { #if ( (PAGE_ATTR_FIX == 1) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,19)) ) /* the kernel already does provide a fix for the AMD Athlon @@ -3240,7 +3224,7 @@ return 0; } -int ATI_API_CALL __ke_has_PSE(void) +int __ke_has_PSE(void) { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71) if (test_bit(X86_FEATURE_PSE, &boot_cpu_data.x86_capability))