Attachment #32322 for bug #52469

View | Details | Raw Unified | Return to bug 52469
Collapse All | Expand All





// ============================================================
/* 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,
};

typedef struct {

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* queue_head;
    queue_head = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);

    return queue_head;
}

void ATI_API_CALL __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* queue;
    queue = kmalloc(sizeof(wait_queue_t), GFP_KERNEL);

    return queue;
}

void ATI_API_CALL __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)
{
    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)
{
    // initialisation (delayed)
#ifdef __WAITQUEUE_INITIALIZER

    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)
{
//    current->state = TASK_RUNNING;
    remove_wait_queue((wait_queue_head_t*)(void *)queue_head, 

}

// sheduler
void ATI_API_CALL __ke_schedule(void)
{
	schedule();
}

int ATI_API_CALL __ke_signal_pending(void)
{
    return signal_pending(current);
}

void ATI_API_CALL __ke_set_current_state_task_interruptible(void)
{
    current->state = TASK_INTERRUPTIBLE;
}

void ATI_API_CALL __ke_set_current_state_task_running(void)
{
    current->state = TASK_RUNNING;
}

void ATI_API_CALL __ke_configure_sigmask(__ke_sigset_t *pSigMask)
{
    sigemptyset((sigset_t*)(void *)pSigMask);
    sigaddset((sigset_t*)(void *)pSigMask, SIGSTOP);

    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)
{
#if LINUX_VERSION_CODE >= 0x020400
    block_all_signals(notifier,pPriv,(sigset_t*)(void *)pSigMask);
#endif
}

void ATI_API_CALL __ke_unblock_all_signals(void)
{
#if LINUX_VERSION_CODE >= 0x020400
    unblock_all_signals();

#endif

#if !defined(__ia64__)
unsigned long ATI_API_CALL __ke__cmpxchg(volatile void *ptr, unsigned long old,
         unsigned long new, int size)
{
#ifndef __HAVE_ARCH_CMPXCHG


/*****************************************************************************/

__ke_dev_t ATI_API_CALL __ke_getdevice(__ke_device_t *dev)
{
    return ((device_t*)dev)->device;
}

const char* ATI_API_CALL __ke_module_parm(void)
{
    return firegl;
}

/*****************************************************************************/

int ATI_API_CALL __ke_inode_rdev_minor(struct inode* inode)
{
#ifndef MINOR
    return minor(inode->i_rdev);


/*****************************************************************************/

void* ATI_API_CALL __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)
{
    filp->private_data = private_data;
}

int ATI_API_CALL __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)
{
    return (filp->f_flags & 3) != 0;
}

unsigned int ATI_API_CALL __ke_file_counter(struct file *filp)
{
#if LINUX_VERSION_CODE >= 0x020400
    return filp->f_count.counter;


/*****************************************************************************/

int ATI_API_CALL __ke_getpid(void)
{
    return current->pid;
}

int ATI_API_CALL __ke_geteuid(void)
{
    return current->euid;
}

/*****************************************************************************/

unsigned long ATI_API_CALL __ke_jiffies(void)
{
    return jiffies;
}

void ATI_API_CALL __ke_udelay(unsigned long usecs) // delay in usec
{
    unsigned long start;
    unsigned long stop;

        udelay(usecs);  /* delay value might get checked once again */
}

void ATI_API_CALL __ke_mdelay(unsigned long msecs) // delay in msec
{
        mdelay(msecs);
}

/*****************************************************************************/
// TODO: These here get obsolete in future, use the ia64 code below
// Johannes
unsigned long ATI_API_CALL __ke_virt_to_bus(void* address)
{
    return virt_to_bus(address);
}

unsigned long ATI_API_CALL __ke_virt_to_phys(void* address)
{
    return virt_to_phys(address);
}

void* ATI_API_CALL __ke_high_memory(void)
{
    return high_memory;
}

int ATI_API_CALL __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)
{
	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,
						 unsigned int dma_handle)
{
	pci_free_consistent( (struct pci_dev*)(void *)dev, size, (void *)cpu_addr, 


/*****************************************************************************/

int ATI_API_CALL __ke_error_code(enum __ke_error_num errcode)
{
    switch (errcode)
    {


/*****************************************************************************/

void ATI_API_CALL __ke_mod_inc_use_count(void)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
    __module_get(THIS_MODULE);

#endif
}

void ATI_API_CALL __ke_mod_dec_use_count(void)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
    module_put(THIS_MODULE);


/*****************************************************************************/

void ATI_API_CALL __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)
{
    up(&(((device_t*)dev)->struct_sem[index]));
}

void ATI_API_CALL __ke_sema_init(struct semaphore* sem, int value)
{
    sema_init(sem, value);
}

__ke_size_t ATI_API_CALL __ke_sema_size(void)
{
    return sizeof(struct semaphore);
}

void ATI_API_CALL __ke_down(struct semaphore* sem)
{
    down(sem);
}

void ATI_API_CALL __ke_up(struct semaphore* sem)
{
    up(sem);
}

/*****************************************************************************/

void ATI_API_CALL __ke_atomic_inc(void* v)
{
    atomic_inc((atomic_t*)v);
}

void ATI_API_CALL __ke_atomic_dec(void* v)
{
    atomic_dec((atomic_t*)v);
}

void ATI_API_CALL __ke_atomic_add(int val, void* v)
{
    atomic_add(val, (atomic_t*)v);
}

void ATI_API_CALL __ke_atomic_sub(int val, void* v)
{
    atomic_sub(val, (atomic_t*)v);
}

int ATI_API_CALL __ke_atomic_read(void* v)
{
    return atomic_read((atomic_t*)v);
}

void ATI_API_CALL __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)
{
    spin_lock(&(((device_t*)dev)->spinlock[ndx]));
}

void ATI_API_CALL __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)
{
    lock_kernel();
}

void ATI_API_CALL __ke_unlock_kernel(void)
{
    unlock_kernel();
}

typedef int (*PFNMUNLOCK)(unsigned long start, __ke_size_t len);


int ATI_API_CALL __ke_sys_mlock(unsigned long start, __ke_size_t len)
{
#ifdef FGL_USE_SCT
    PFNMLOCK sys_mlock = (PFNMLOCK)sys_call_table[__NR_mlock];

#endif
}

int ATI_API_CALL __ke_sys_munlock(unsigned long start, __ke_size_t len)
{
#ifdef FGL_USE_SCT
    PFNMUNLOCK sys_munlock = (PFNMUNLOCK)sys_call_table[__NR_munlock];


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)
{
#ifdef FGL_USE_SCT
    PFNMODIFYLDT sys_modify_ldt = (PFNMODIFYLDT)sys_call_table[__NR_modify_ldt];

#ifdef __KE_NO_VSPRINTF

#if LINUX_VERSION_CODE >= 0x020400
void ATI_API_CALL __ke_printk(const char* fmt, ...)
{
	char buffer[256];
    va_list marker;


#else

void ATI_API_CALL __ke_print_info(const char* fmt, ...)
{
    char msg[256] = KERN_INFO;:
    va_list marker;

    va_end(marker);
}

void ATI_API_CALL __ke_print_error(const char* fmt, ...)
{
    char msg[256] = KERN_ERR;
    va_list marker;

    va_end(marker);
}

void ATI_API_CALL __ke_print_debug(const char* fmt, ...)
{
    char msg[256] = KERN_DEBUG;
    va_list marker;


/*****************************************************************************/

int ATI_API_CALL __ke_capable(enum __ke_cap cap)
{
    switch (cap)
    {

    return capable(cap);
}

void ATI_API_CALL __ke_cap_effective_raise(enum __ke_cap cap)
{
    switch (cap)
    {

    cap_raise(current->cap_effective, cap);
}

__ke_u32 ATI_API_CALL __ke_get_cap_effective()
{
    return cap_t(current->cap_effective);
}

void ATI_API_CALL __ke_set_cap_effective(__ke_u32 cap)
{
    cap_t(current->cap_effective) = cap;
}

unsigned long ATI_API_CALL __ke_ram_available(void)
{
	struct sysinfo si;


#endif
}

int ATI_API_CALL __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)
{
    return copy_to_user(to, from, size);
}

int ATI_API_CALL __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)
{
    if ( dev )
    {

    return -EINVAL;
}

int ATI_API_CALL __ke_check_pci(int busnum, int devnum, int funcnum, __ke_u16* vendor, __ke_u16* device, unsigned int* irq)
{
    struct pci_dev* pci_dev;


    return 1;
}

int ATI_API_CALL __ke_pci_get_irq(__ke_pci_dev_t *dev, unsigned int* irq)
{
    if (!dev)
        return 0;

    return 1;
}

__ke_pci_dev_t* ATI_API_CALL __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)
{
    return kmalloc(size, GFP_KERNEL);
}

void ATI_API_CALL __ke_free_s(void* p, __ke_size_t size)
{
    kfree(p);
}

void* ATI_API_CALL __ke_vmalloc(__ke_size_t size)
{
    return vmalloc(size);
}

void ATI_API_CALL __ke_vfree(void* p)
{
    return vfree(p);
}

void* ATI_API_CALL __ke_get_free_page(void)
{
    return (void*)__get_free_page(GFP_KERNEL);
}

void* ATI_API_CALL __ke_get_free_pages(int order)
{
    return (void*)__get_free_pages(GFP_KERNEL, order);
}

void ATI_API_CALL __ke_free_page(void* pt)
{
    free_page((unsigned long)pt);
}

void ATI_API_CALL __ke_free_pages(void* pt, int order)
{
    free_pages((unsigned long)pt, order);
}

void ATI_API_CALL __ke_mem_map_reserve(void* pt)
{
#if LINUX_VERSION_CODE < 0x020400
    mem_map_reserve(MAP_NR((unsigned long)pt));

#endif
}

void ATI_API_CALL __ke_mem_map_unreserve(void* pt)
{
#if LINUX_VERSION_CODE < 0x020400
    mem_map_unreserve(MAP_NR((unsigned long)pt));

#endif
}

void ATI_API_CALL __ke_virt_reserve(void* virt)
{
#if LINUX_VERSION_CODE < 0x020400
    set_bit(PG_reserved,

#endif
}

void ATI_API_CALL __ke_virt_unreserve(void* virt)
{
#if LINUX_VERSION_CODE < 0x020400
    clear_bit(PG_reserved,

}

#ifdef __ia64__
void* ATI_API_CALL __ke_get_vmptr( struct _agp_memory* memory )
{
	return memory->vmptr;
}
#endif
                              
void* ATI_API_CALL __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)
{
    return ioremap_nocache(offset, size);
}

void ATI_API_CALL __ke_iounmap(void* pt)
{
    iounmap(pt);
}

int ATI_API_CALL __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)
{
    return access_ok(VERIFY_WRITE, addr, size) ? 0 : -EFAULT;
}

struct mm_struct* ATI_API_CALL __ke_init_mm(void)
{
    return &init_mm;
}

struct mm_struct* ATI_API_CALL __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 pte_linear;
    pgd_t* pgd_p;

#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   *phys_table, *pt;
    unsigned long   n, va;

    return phys_table;
}

void* ATI_API_CALL __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)
{
    return memcpy(d, s, count);
}

__ke_size_t ATI_API_CALL __ke_strlen(const char *s)
{
    return strlen(s);
}

char* ATI_API_CALL __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)
{
    return strncpy(d, s, count);
}

int ATI_API_CALL __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)
{
    return strncmp(string1, string2, count);
}

int ATI_API_CALL __ke_sprintf(char* buf, const char* fmt, ...)
{
    va_list marker;



/*****************************************************************************/

void ATI_API_CALL __ke_set_bit(int nr, volatile void * addr)
{
    set_bit(nr, addr);
}

void ATI_API_CALL __ke_clear_bit(int nr, volatile void * addr)
{
    clear_bit(nr, addr);
}

}
#endif /* __SMP__ */

int ATI_API_CALL __ke_flush_cache(void)
{
#ifdef __SMP__
#if LINUX_VERSION_CODE < 0x020501


/*****************************************************************************/

int ATI_API_CALL __ke_config_mtrr(void)
{
#ifdef CONFIG_MTRR
    return 1;

#endif /* !CONFIG_MTRR */
}

int ATI_API_CALL __ke_mtrr_add_wc(unsigned long base, unsigned long size)
{
#ifdef CONFIG_MTRR
    return mtrr_add(base, size, MTRR_TYPE_WRCOMB, 1);

#endif /* !CONFIG_MTRR */
}

int ATI_API_CALL __ke_mtrr_del(int reg, unsigned long base, unsigned long size)
{
#ifdef CONFIG_MTRR
    return mtrr_del(reg, base, size);


/*****************************************************************************/

int ATI_API_CALL __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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    return pci_write_config_dword((struct pci_dev*)(void *)dev, where, val);
}

/*****************************************************************************/

void ATI_API_CALL __ke_outb(unsigned char value, unsigned short port)
{
    outb(value, port);
}

void ATI_API_CALL __ke_outw(unsigned short value, unsigned short port)
{
    outw(value, port);
}

void ATI_API_CALL __ke_outl(unsigned int value, unsigned short port)
{
    outl(value, port);
}

char ATI_API_CALL __ke_inb(unsigned short port)
{
    return inb(port);
}

short ATI_API_CALL __ke_inw(unsigned short port)
{
    return inw(port);
}

int ATI_API_CALL __ke_inl(unsigned short port)
{
    return inl(port);
}

/*****************************************************************************/
// Interrupt support

void ATI_API_CALL __ke_enable_irq(int irq)
{
    enable_irq( irq );
}

void ATI_API_CALL __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, 
    void (*handler)(int, void *, void *),
    const char *dev_name, void *dev_id)
{

        SA_SHIRQ, dev_name, dev_id);
}

void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id)
{
    free_irq(irq, dev_id);
}

    return IRQ_HANDLED;
}

int ATI_API_CALL __ke_request_irq(unsigned int irq, 
    void (*ATI_API_CALL handler)(int, void *, void *),
    const char *dev_name, void *dev_id)
{
    irq_handler_func = handler;

        SA_SHIRQ, dev_name, dev_id);
}

void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id)
{
    free_irq(irq, dev_id);
    irq_handler_func = NULL;


#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0) */

void* ATI_API_CALL __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)
{
    return vma->vm_start;
}

unsigned long ATI_API_CALL __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)
{
#if LINUX_VERSION_CODE < 0x020319
    return vma->vm_offset;

#endif/* LINUX_VERSION_CODE >= 0x020319 */
}

char* ATI_API_CALL __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' : '-';

   return buf;
}

char* ATI_API_CALL __ke_vm_page_prot_str(struct vm_area_struct* vma, char* buf)
{
    int i = 0;


    return buf;
}

char* ATI_API_CALL __ke_vm_phys_addr_str(struct vm_area_struct* vma, 
                            char* buf, 
                            unsigned long virtual_addr, 
                            unsigned long* phys_address)

    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,
};

#ifdef __AGP__BUILTIN__

static struct vm_operations_struct vm_cant_ops =
{
    nopage:  vm_cant_nopage,
    open:    ip_drm_vm_open,
    close:   ip_drm_vm_close,
};
#endif /* __ia64_ */
#endif /* __AGP__BUILTIN__ */

static struct vm_operations_struct vm_shm_ops =
{
    nopage:  vm_shm_nopage,
    open:    ip_drm_vm_open,
    close:   ip_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,
};

static struct vm_operations_struct vm_ctx_ops =
{
    nopage:  vm_dma_nopage,
    open:    ip_drm_vm_open,
    close:   ip_drm_vm_close,
};

#ifdef __AGP__BUILTIN__

static struct vm_operations_struct vm_agp_bq_ops =
{
    nopage:  vm_nopage,
    open:    ip_drm_vm_open,
    close:   ip_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,
};
#endif /* __ia64_ */
#endif /* __AGP__BUILTIN__ */

int ATI_API_CALL __ke_vm_map(struct file* filp,
                struct vm_area_struct* vma,
                enum __ke_vm_maptype type,
                int readonly)

#endif // !USE_FIREGL_AGPGART_IMPLEMENTATION

static
int ATI_API_CALL __ke_firegl_agpgart_available(void)
{
    int retval;


}

static
int ATI_API_CALL __ke_agpgart_available(void)
{
#ifdef __AGP__
    unsigned int found = 0;

    return 0; /* failed */
}

int ATI_API_CALL __ke_agp_available(int use_internal)
{
    int available = 0;


    return available;
}

void ATI_API_CALL __ke_agp_uninit(void)
{
    if (firegl_agp) 
    {

}

#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)
{
#if 0
#ifdef __AGP__

}
#endif

void ATI_API_CALL __ke_agp_free_memory(struct _agp_memory* handle)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(free_memory))

		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)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(allocate_memory))

    return NULL;
}

int ATI_API_CALL __ke_agp_bind_memory(struct _agp_memory* handle, __ke_off_t start)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(bind_memory))

    return -EINVAL;
}

int ATI_API_CALL __ke_agp_unbind_memory(struct _agp_memory* handle)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(unbind_memory))

    return -EINVAL;
}

int ATI_API_CALL __ke_agp_enable(unsigned long mode)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(enable))

    return -EINVAL;
}

int ATI_API_CALL __ke_read_agp_caps_registers(__ke_pci_dev_t* dev, unsigned int *caps)
{
    u8 capndx;
	u32 cap_id;

    return -ENODATA;
}

int ATI_API_CALL __ke_agp_acquire(void)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(acquire))

    return -EINVAL;
}

void ATI_API_CALL __ke_agp_release(void)
{
#ifdef __AGP__
	if (AGP_AVAILABLE(release))

		FIREGL_agp_backend_release();
}

void ATI_API_CALL __ke_agp_copy_info(__ke_agp_kern_info_t* info)
{
    struct pci_dev *device = NULL;


    }
}

unsigned long ATI_API_CALL __ke_agp_memory_handle(struct _agp_memory* handle)
{
    if (firegl_agp) 
#ifdef USE_FIREGL_AGPGART_IMPLEMENTATION

#endif /* !__AGP__ */
}

unsigned long ATI_API_CALL __ke_agp_memory_page_count(struct _agp_memory* handle)
{
    if (firegl_agp) 
#ifdef USE_FIREGL_AGPGART_IMPLEMENTATION

#endif /* !__AGP__ */
}

int ATI_API_CALL __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) )
{
	smp_call_function( func, NULL, 0, 1 );
}

        return 0;   // does not match
}

int ATI_API_CALL __ke_is_athlon(void)
{
    register int bAthlon;
    __asm

#endif


int ATI_API_CALL __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

        return 0;
}

int ATI_API_CALL __ke_has_PSE(void)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71)
	if (test_bit(X86_FEATURE_PSE, &boot_cpu_data.x86_capability))




#ifndef VMALLOC_VMADDR
#define VMALLOC_VMADDR(x) ((unsigned long)(x))
#endif

#define VMALLOC_VMADDR(x)  ((unsigned long)(x))
#endif
// ============================================================
/* globals */


    pMmPage = virt_to_page(kaddr);
#endif /* LINUX_VERSION_CODE < 0x020400 */

//    atomic_inc(&(pMmPage->count));  /* inc usage count of page */
    get_page(pMmPage);
#if LINUX_VERSION_CODE >= 0x020400
  //  __KE_DEBUG3("vm-address 0x%08lx => kernel-page-address 0x%p\n",
    //    address, page_address(pMmPage));




typedef struct { int uniqe4; } __ke_pci_dev_t;
typedef struct { int uniqe5; } __ke_priv_device_t;

typedef	int (*ATI_API_CALL __ke_read_proc_t)(
    char* page, char** start, __ke_off_t off, int count, int* eof, void* data);

typedef struct {


/*****************************************************************************/

extern __ke_wait_queue_head_t* ATI_API_CALL __ke_alloc_wait_queue_head_struct(void);
extern void ATI_API_CALL __ke_free_wait_queue_head_struct(__ke_wait_queue_head_t* queue_head);
extern __ke_wait_queue_t* ATI_API_CALL __ke_alloc_wait_queue_struct(void);
extern void ATI_API_CALL __ke_free_wait_queue_struct(__ke_wait_queue_t* queue);

extern void ATI_API_CALL __ke_wake_up_interruptible(__ke_wait_queue_head_t* queue_head);
extern void ATI_API_CALL __ke_add_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry);
extern void ATI_API_CALL __ke_remove_wait_queue(__ke_wait_queue_head_t* queue_head, __ke_wait_queue_t* entry);

extern void ATI_API_CALL __ke_schedule(void);
extern int ATI_API_CALL __ke_signal_pending(void);

extern void ATI_API_CALL __ke_set_current_state_task_interruptible(void);
extern void ATI_API_CALL __ke_set_current_state_task_running(void);
extern void ATI_API_CALL __ke_configure_sigmask(__ke_sigset_t *pSigMask);
extern void ATI_API_CALL __ke_block_all_signals(int (*notifier)(void *priv), void *pPriv, __ke_sigset_t *pSigMask);
extern void ATI_API_CALL __ke_unblock_all_signals(void);

extern unsigned long ATI_API_CALL __ke__cmpxchg(volatile void *ptr, unsigned long old,                      
                      unsigned long new, int size);

#define __ke_cmpxchg(ptr,o,n)                        \

                                                                                        
/*****************************************************************************/

extern __ke_dev_t ATI_API_CALL __ke_getdevice(__ke_device_t *dev);
extern const char* ATI_API_CALL __ke_module_parm(void);
extern int ATI_API_CALL __ke_inode_rdev_minor(struct inode* inode);
extern void* ATI_API_CALL __ke_get_file_priv(struct file* filp);
extern void ATI_API_CALL __ke_set_file_priv(struct file* filp, void* private_data);
extern int ATI_API_CALL __ke_file_excl_open(struct file* filp);
extern int ATI_API_CALL __ke_file_rw_open(struct file* filp);
extern unsigned int ATI_API_CALL __ke_file_counter(struct file* filp);
extern int ATI_API_CALL __ke_getpid(void);
extern int ATI_API_CALL __ke_geteuid(void);
extern unsigned long ATI_API_CALL __ke_jiffies(void);
extern void ATI_API_CALL __ke_udelay(unsigned long usecs);
extern void ATI_API_CALL __ke_mdelay(unsigned long msecs);
extern unsigned long ATI_API_CALL __ke_virt_to_bus(void* address);
extern unsigned long ATI_API_CALL __ke_virt_to_phys(void* address);
extern void* ATI_API_CALL __ke_high_memory(void);
#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 ATI_API_CALL __ke_pci_free_consistent(__ke_pci_dev_t* dev, int size, unsigned long cpu_addr,
						 unsigned int dma_handle);
#endif


    __KE_ERESTARTSYS,
    __KE_ELIBBAD,
};
extern int ATI_API_CALL __ke_error_code(enum __ke_error_num errcode);

extern void ATI_API_CALL __ke_mod_inc_use_count(void);
extern void ATI_API_CALL __ke_mod_dec_use_count(void);

extern void ATI_API_CALL __ke_down_struct_sem(__ke_device_t *dev, int idx);
extern void ATI_API_CALL __ke_up_struct_sem(__ke_device_t *dev, int idx);
	#define __KE_MAX_SEMAPHORES 2
extern void ATI_API_CALL __ke_sema_init(struct semaphore* sem, int value);
extern __ke_size_t ATI_API_CALL __ke_sema_size(void);
extern void ATI_API_CALL __ke_down(struct semaphore* sem);
extern void ATI_API_CALL __ke_up(struct semaphore* sem);
extern void ATI_API_CALL __ke_atomic_inc(void* v);
extern void ATI_API_CALL __ke_atomic_dec(void* v);
extern void ATI_API_CALL __ke_atomic_add(int val, void* v);
extern void ATI_API_CALL __ke_atomic_sub(int val, void* v);
extern int ATI_API_CALL __ke_atomic_read(void* v);
extern void ATI_API_CALL __ke_atomic_set(void* v, int val);
extern void ATI_API_CALL __ke_spin_lock(__ke_device_t *dev, int ndx);
extern void ATI_API_CALL __ke_spin_unlock(__ke_device_t *dev, int ndx);
	#define __KE_MAX_SPINLOCKS 6
extern void ATI_API_CALL __ke_lock_kernel(void);
extern void ATI_API_CALL __ke_unlock_kernel(void);
extern int ATI_API_CALL __ke_sys_mlock(unsigned long start, __ke_size_t len);
extern int ATI_API_CALL __ke_sys_munlock(unsigned long start, __ke_size_t len);
extern int ATI_API_CALL __ke_sys_modify_ldt(int func, void *ptr, unsigned long bytecount);
extern int __ke_sys_modify_ldt(int func, void *ptr, unsigned long bytecount);
#ifdef __KE_NO_VSPRINTF
extern void ATI_API_CALL __ke_printk(const char* fmt, ...);
#else // !__KE_NO_VSPRINTF
extern void ATI_API_CALL __ke_print_info(const char* fmt, ...);
extern void ATI_API_CALL __ke_print_error(const char* fmt, ...);
extern void ATI_API_CALL __ke_print_debug(const char* fmt, ...);
#endif // !__KE_NO_VSPRINTF

enum __ke_cap

    __KE_CAP_SYS_ADMIN,
    __KE_CAP_IPC_LOCK,
};
extern int ATI_API_CALL __ke_capable(enum __ke_cap cap);
extern void ATI_API_CALL __ke_cap_effective_raise(enum __ke_cap cap);
extern __ke_u32 ATI_API_CALL __ke_get_cap_effective(void);
extern void ATI_API_CALL __ke_set_cap_effective(__ke_u32 cap);
extern unsigned long ATI_API_CALL __ke_ram_available(void);

extern int ATI_API_CALL __ke_copy_from_user(void* to, const void* from, __ke_size_t size);
extern int ATI_API_CALL __ke_copy_to_user(void* to, const void* from, __ke_size_t size);
extern int ATI_API_CALL __ke_verify_area(int type, const void * addr, unsigned long size);

extern void* ATI_API_CALL __ke_malloc(__ke_size_t size);
extern void ATI_API_CALL __ke_free_s(void* p, __ke_size_t size);
extern void* ATI_API_CALL __ke_vmalloc(__ke_size_t size);
extern void ATI_API_CALL __ke_vfree(void* p);
extern void* ATI_API_CALL __ke_get_free_page(void);
extern void* ATI_API_CALL __ke_get_free_pages(int order);
extern void ATI_API_CALL __ke_free_page(void* pt);
extern void ATI_API_CALL __ke_free_pages(void* pt, int order);
extern void ATI_API_CALL __ke_mem_map_reserve(void* pt);
extern void ATI_API_CALL __ke_mem_map_unreserve(void* pt);
extern void ATI_API_CALL __ke_virt_reserve(void* pt);
extern void ATI_API_CALL __ke_virt_unreserve(void* pt);
extern void* ATI_API_CALL __ke_get_vmptr( struct _agp_memory* memory );
extern void* ATI_API_CALL __ke_ioremap(unsigned long offset, unsigned long size);
extern void* ATI_API_CALL __ke_ioremap_nocache(unsigned long offset, unsigned long size);
extern void ATI_API_CALL __ke_iounmap(void* pt);
extern int ATI_API_CALL __ke_verify_read_access(void* addr, __ke_size_t size);
extern int ATI_API_CALL __ke_verify_write_access(void* addr, __ke_size_t size);
extern struct mm_struct* ATI_API_CALL __ke_init_mm(void);
extern struct mm_struct* ATI_API_CALL __ke_current_mm(void);
extern unsigned long ATI_API_CALL __ke_get_vm_phys_addr(struct mm_struct* mm, unsigned long virtual_addr);
extern unsigned long* ATI_API_CALL __ke_get_vm_phys_addr_list(struct mm_struct* mm, unsigned long virtual_addr, unsigned long pages);
extern void* ATI_API_CALL __ke_memset(void* s, int c, __ke_size_t count);
extern void* ATI_API_CALL __ke_memcpy(void* d, const void* s, __ke_size_t count);
extern __ke_size_t ATI_API_CALL __ke_strlen(const char *s);
extern char* ATI_API_CALL __ke_strcpy(char* d, const char* s);
extern char* ATI_API_CALL __ke_strncpy(char* d, const char* s, __ke_size_t count);
extern int ATI_API_CALL __ke_strcmp(const char *s1, const char *s2);
extern int ATI_API_CALL __ke_strncmp(const char* str1, const char* str2, __ke_size_t count);
extern int ATI_API_CALL __ke_sprintf(char* buf, const char* fmt, ...);

/*****************************************************************************/

extern void ATI_API_CALL __ke_set_bit(int nr, volatile void * addr);
extern void ATI_API_CALL __ke_clear_bit(int nr, volatile void * addr);

/*****************************************************************************/

extern int ATI_API_CALL __ke_flush_cache(void);

/*****************************************************************************/

extern int ATI_API_CALL __ke_config_mtrr(void);
extern int ATI_API_CALL __ke_mtrr_add_wc(unsigned long base, unsigned long size);
extern int ATI_API_CALL __ke_mtrr_del(int reg, unsigned long base, unsigned long size);

/*****************************************************************************/

extern int ATI_API_CALL __ke_get_pci_device_info(__ke_pci_dev_t* dev, __ke_pci_device_info_t *pinfo);
extern int ATI_API_CALL __ke_check_pci(int busnum, int devnum, int funcnum, __ke_u16* vendor, __ke_u16* device, unsigned int* irq);
extern int ATI_API_CALL __ke_pci_get_irq(__ke_pci_dev_t *dev, unsigned int* irq);
extern __ke_pci_dev_t* ATI_API_CALL __ke_pci_find_device (unsigned int vendor, unsigned int dev, __ke_pci_dev_t* from);
extern int ATI_API_CALL __ke_pci_read_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 *val);
extern int ATI_API_CALL __ke_pci_read_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 *val);
extern int ATI_API_CALL __ke_pci_read_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 *val);
extern int ATI_API_CALL __ke_pci_write_config_byte(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u8 val);
extern int ATI_API_CALL __ke_pci_write_config_word(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u16 val);
extern int ATI_API_CALL __ke_pci_write_config_dword(__ke_pci_dev_t* dev, __ke_u8 where, __ke_u32 val);
extern int ATI_API_CALL __ke_pci_enable_device(__ke_pci_dev_t* dev);

/*****************************************************************************/

extern void ATI_API_CALL __ke_outb(unsigned char value, unsigned short port);
extern void ATI_API_CALL __ke_outw(unsigned short value, unsigned short port);
extern void ATI_API_CALL __ke_out(unsigned int value, unsigned short port);
extern char ATI_API_CALL __ke_inb(unsigned short port);
extern short ATI_API_CALL __ke_inw(unsigned short port);
extern int ATI_API_CALL __ke_in(unsigned short port);

/*****************************************************************************/

extern void ATI_API_CALL __ke_enable_irq(int irq);
extern void ATI_API_CALL __ke_disable_irq(int irq);
extern int ATI_API_CALL __ke_request_irq(unsigned int irq, void (*ATI_API_CALL handler)(int, void *, void *), const char *dev_name, void *dev_id);
extern void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id);

/*****************************************************************************/

extern void* ATI_API_CALL __ke_vma_file_priv(struct vm_area_struct* vma);
extern unsigned long ATI_API_CALL __ke_vm_start(struct vm_area_struct* vma);
extern unsigned long ATI_API_CALL __ke_vm_end(struct vm_area_struct* vma);
extern unsigned long ATI_API_CALL __ke_vm_offset(struct vm_area_struct* vma);
enum __ke_vm_maptype
{
    __KE_ADPT,

    __KE_AGP_BQS,
    __KE_AGP,
};
extern char* ATI_API_CALL __ke_vm_flags_str(struct vm_area_struct* vma, char* buf);
extern char* ATI_API_CALL __ke_vm_page_prot_str(struct vm_area_struct* vma, char* buf);
extern char* ATI_API_CALL __ke_vm_phys_addr_str(struct vm_area_struct* vma, 
                                   char* buf, 
                                   unsigned long linear_address, 
                                   unsigned long* phys_address);
extern int ATI_API_CALL __ke_vm_map(struct file* filp,
                       struct vm_area_struct* vma,
                       enum __ke_vm_maptype type,
                       int readonly);


extern int __ke_agp_try_unsupported;

int ATI_API_CALL __ke_agp_available(int use_internal);
void ATI_API_CALL __ke_agp_uninit(void);
#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);
#endif
void ATI_API_CALL __ke_agp_free_memory(struct _agp_memory* handle);
struct _agp_memory* ATI_API_CALL __ke_agp_allocate_memory(__ke_size_t pages, 
                                             unsigned long type);
int ATI_API_CALL __ke_agp_bind_memory(struct _agp_memory* handle, __ke_off_t start);
int ATI_API_CALL __ke_agp_unbind_memory(struct _agp_memory* handle);
int ATI_API_CALL __ke_agp_enable(unsigned long mode);
int ATI_API_CALL __ke_read_agp_caps_registers(__ke_pci_dev_t* dev, unsigned int *caps);
int ATI_API_CALL __ke_agp_acquire(void);
void ATI_API_CALL __ke_agp_release(void);
void ATI_API_CALL __ke_agp_copy_info(__ke_agp_kern_info_t* info);
unsigned long ATI_API_CALL __ke_agp_memory_handle(struct _agp_memory* handle);
unsigned long ATI_API_CALL __ke_agp_memory_page_count(struct _agp_memory* handle);

int ATI_API_CALL __ke_is_athlon(void);
int ATI_API_CALL __ke_has_PSE(void);
int ATI_API_CALL __ke_amd_adv_spec_cache_feature(void);
void ATI_API_CALL __ke_smp_call_function( void (*func)(void *info) );
int ATI_API_CALL __ke_smp_processor_id(void);

/*****************************************************************************/


Lines 993-999 Link Here

(-)build_mod.old/make.sh (-1 / +1 lines)
993	echo "doing Makefile based build for kernel 2.6.x and higher" \| tee -a $logfile	993	echo "doing Makefile based build for kernel 2.6.x and higher" \| tee -a $logfile
994	cd 2.6.x	994	cd 2.6.x
995	make PAGE_ATTR_FIX=$PAGE_ATTR_FIX 2>&1 \| tee -a $logfile	995	make PAGE_ATTR_FIX=$PAGE_ATTR_FIX 2>&1 \| tee -a $logfile
996	res=$?	996	res=${PIPESTATUS[0]}
997	cd ..	997	cd ..
998	if [ $res -eq 0 ]; then	998	if [ $res -eq 0 ]; then
999	echo "build succeeded with return value $res" \| tee -a $logfile	999	echo "build succeeded with return value $res" \| tee -a $logfile

Return to bug 52469

Lines 189-197 Link Here

(-)build_mod.old/firegl_public.c.orig (-5 / +3 lines)
189	#ifndef VMALLOC_VMADDR	189	#ifndef VMALLOC_VMADDR
190	#define VMALLOC_VMADDR(x) ((unsigned long)(x))	190	#define VMALLOC_VMADDR(x) ((unsigned long)(x))
191	#endif	191	#endif
192	#ifndef VMALLOC_VMADDR	192
193	#define VMALLOC_VMADDR(x) ((unsigned long)(x))
194	#endif
195	// ============================================================	193	// ============================================================
196	/* globals */	194	/* globals */
197		195
Lines 2012-2019 Link Here
2012	pMmPage = virt_to_page(kaddr);	2010	pMmPage = virt_to_page(kaddr);
2013	#endif /* LINUX_VERSION_CODE < 0x020400 */	2011	#endif /* LINUX_VERSION_CODE < 0x020400 */
2014		2012
2015	atomic_inc(&(pMmPage->count)); /* inc usage count of page */	2013	// atomic_inc(&(pMmPage->count)); /* inc usage count of page */
2016		2014	get_page(pMmPage);
2017	#if LINUX_VERSION_CODE >= 0x020400	2015	#if LINUX_VERSION_CODE >= 0x020400
2018	// __KE_DEBUG3("vm-address 0x%08lx => kernel-page-address 0x%p\n",	2016	// __KE_DEBUG3("vm-address 0x%08lx => kernel-page-address 0x%p\n",
2019	// address, page_address(pMmPage));	2017	// address, page_address(pMmPage));