path: root/linux-core/xgi_drv.c

/****************************************************************************
 * Copyright (C) 2003-2006 by XGI Technology, Taiwan.			
 *																			*
 * All Rights Reserved.														*
 *																			*
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the	
 * "Software"), to deal in the Software without restriction, including	
 * without limitation on the rights to use, copy, modify, merge,	
 * publish, distribute, sublicense, and/or sell copies of the Software,	
 * and to permit persons to whom the Software is furnished to do so,	
 * subject to the following conditions:					
 *																			*
 * The above copyright notice and this permission notice (including the	
 * next paragraph) shall be included in all copies or substantial	
 * portions of the Software.						
 *																			*
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND		
 * NON-INFRINGEMENT.  IN NO EVENT SHALL XGI AND/OR			
 * ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,		
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,		
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER			
 * DEALINGS IN THE SOFTWARE.												
 ***************************************************************************/
#include "xgi_types.h"
#include "xgi_linux.h"
#include "xgi_drv.h"
#include "xgi_regs.h"
#include "xgi_pcie.h"
#include "xgi_misc.h"
#include "xgi_cmdlist.h"

/* for debug */
static int xgi_temp = 1;
/*
 * global parameters
 */
static struct xgi_dev {
	u16 vendor;
	u16 device;
	const char *name;
} xgidev_list[] = {
	{
	PCI_VENDOR_ID_XGI, PCI_DEVICE_ID_XP5, "XP5"}, {
	PCI_VENDOR_ID_XGI, PCI_DEVICE_ID_XG47, "XG47"}, {
	0, 0, NULL}
};

int xgi_major = XGI_DEV_MAJOR;	/* xgi reserved major device number. */

static int xgi_num_devices = 0;

xgi_info_t xgi_devices[XGI_MAX_DEVICES];

#if defined(XGI_PM_SUPPORT_APM)
static struct pm_dev *apm_xgi_dev[XGI_MAX_DEVICES] = { 0 };
#endif

/* add one for the control device */
xgi_info_t xgi_ctl_device;
wait_queue_head_t xgi_ctl_waitqueue;

#ifdef CONFIG_PROC_FS
struct proc_dir_entry *proc_xgi;
#endif

#ifdef CONFIG_DEVFS_FS
devfs_handle_t xgi_devfs_handles[XGI_MAX_DEVICES];
#endif

struct list_head xgi_mempid_list;

/* xgi_ functions.. do not take a state device parameter  */
static int xgi_post_vbios(xgi_ioctl_post_vbios_t * info);
static void xgi_proc_create(void);
static void xgi_proc_remove_all(struct proc_dir_entry *);
static void xgi_proc_remove(void);

/* xgi_kern_ functions, interfaces used by linux kernel */
int xgi_kern_probe(struct pci_dev *, const struct pci_device_id *);

unsigned int xgi_kern_poll(struct file *, poll_table *);
int xgi_kern_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
int xgi_kern_mmap(struct file *, struct vm_area_struct *);
int xgi_kern_open(struct inode *, struct file *);
int xgi_kern_release(struct inode *inode, struct file *filp);

void xgi_kern_vma_open(struct vm_area_struct *vma);
void xgi_kern_vma_release(struct vm_area_struct *vma);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 1))
struct page *xgi_kern_vma_nopage(struct vm_area_struct *vma,
				 unsigned long address, int *type);
#else
struct page *xgi_kern_vma_nopage(struct vm_area_struct *vma,
				 unsigned long address, int write_access);
#endif

int xgi_kern_read_card_info(char *, char **, off_t off, int, int *, void *);
int xgi_kern_read_status(char *, char **, off_t off, int, int *, void *);
int xgi_kern_read_pcie_info(char *, char **, off_t off, int, int *, void *);
int xgi_kern_read_version(char *, char **, off_t off, int, int *, void *);

int xgi_kern_ctl_open(struct inode *, struct file *);
int xgi_kern_ctl_close(struct inode *, struct file *);
unsigned int xgi_kern_ctl_poll(struct file *, poll_table *);

void xgi_kern_isr_bh(unsigned long);
irqreturn_t xgi_kern_isr(int, void *, struct pt_regs *);

static void xgi_lock_init(xgi_info_t * info);

#if defined(XGI_PM_SUPPORT_ACPI)
int xgi_kern_acpi_standby(struct pci_dev *, u32);
int xgi_kern_acpi_resume(struct pci_dev *);
#endif

/*
 * verify access to pci config space wasn't disabled behind our back
 * unfortunately, XFree86 enables/disables memory access in pci config space at
 * various times (such as restoring initial pci config space settings during vt
 * switches or when doing mulicard). As a result, all of our register accesses
 * are garbage at this point. add a check to see if access was disabled and
 * reenable any such access.
 */
#define XGI_CHECK_PCI_CONFIG(xgi) \
    xgi_check_pci_config(xgi, __LINE__)

static inline void xgi_check_pci_config(xgi_info_t * info, int line)
{
	unsigned short cmd, flag = 0;

	// don't do this on the control device, only the actual devices
	if (info->flags & XGI_FLAG_CONTROL)
		return;

	pci_read_config_word(info->dev, PCI_COMMAND, &cmd);
	if (!(cmd & PCI_COMMAND_MASTER)) {
		XGI_INFO("restoring bus mastering! (%d)\n", line);
		cmd |= PCI_COMMAND_MASTER;
		flag = 1;
	}

	if (!(cmd & PCI_COMMAND_MEMORY)) {
		XGI_INFO("restoring MEM access! (%d)\n", line);
		cmd |= PCI_COMMAND_MEMORY;
		flag = 1;
	}

	if (flag)
		pci_write_config_word(info->dev, PCI_COMMAND, cmd);
}

/*
 * struct pci_device_id {
 *  unsigned int vendor, device;        // Vendor and device ID or PCI_ANY_ID
 *  unsigned int subvendor, subdevice;  // Subsystem ID's or PCI_ANY_ID
 *  unsigned int class, class_mask;     // (class,subclass,prog-if) triplet
 *  unsigned long driver_data;          // Data private to the driver
 * };
 */

static struct pci_device_id xgi_dev_table[] = {
	{
	 .vendor = PCI_VENDOR_ID_XGI,
	 .device = PCI_ANY_ID,
	 .subvendor = PCI_ANY_ID,
	 .subdevice = PCI_ANY_ID,
	 .class = (PCI_CLASS_DISPLAY_VGA << 8),
	 .class_mask = ~0,
	 },
	{}
};

/*
 *  #define MODULE_DEVICE_TABLE(type,name) \
 *      MODULE_GENERIC_TABLE(type##_device,name)
 */
MODULE_DEVICE_TABLE(pci, xgi_dev_table);

/*
 * struct pci_driver {
 *  struct list_head node;
 *  char *name;
 *  const struct pci_device_id *id_table;   // NULL if wants all devices
 *  int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id); // New device inserted
 *  void (*remove)(struct pci_dev *dev);    // Device removed (NULL if not a hot-plug capable driver)
 *  int  (*save_state)(struct pci_dev *dev, u32 state);     // Save Device Context
 *  int  (*suspend)(struct pci_dev *dev, u32 state);        // Device suspended
 *  int  (*resume)(struct pci_dev *dev);                    // Device woken up
 *  int  (*enable_wake)(struct pci_dev *dev, u32 state, int enable);   // Enable wake event
 * };
 */
static struct pci_driver xgi_pci_driver = {
	.name = "xgi",
	.id_table = xgi_dev_table,
	.probe = xgi_kern_probe,
#if defined(XGI_SUPPORT_ACPI)
	.suspend = xgi_kern_acpi_standby,
	.resume = xgi_kern_acpi_resume,
#endif
};

/*
 * find xgi devices and set initial state
 */
int xgi_kern_probe(struct pci_dev *dev, const struct pci_device_id *id_table)
{
	xgi_info_t *info;

	if ((dev->vendor != PCI_VENDOR_ID_XGI)
	    || (dev->class != (PCI_CLASS_DISPLAY_VGA << 8))) {
		return -1;
	}

	if (xgi_num_devices == XGI_MAX_DEVICES) {
		XGI_INFO("maximum device number (%d) reached!\n",
			 xgi_num_devices);
		return -1;
	}

	/* enable io, mem, and bus-mastering in pci config space */
	if (pci_enable_device(dev) != 0) {
		XGI_INFO("pci_enable_device failed, aborting\n");
		return -1;
	}

	XGI_INFO("maximum device number (%d) reached \n", xgi_num_devices);

	pci_set_master(dev);

	info = &xgi_devices[xgi_num_devices];
	info->dev = dev;
	info->vendor_id = dev->vendor;
	info->device_id = dev->device;
	info->bus = dev->bus->number;
	info->slot = PCI_SLOT((dev)->devfn);

	xgi_lock_init(info);

	info->mmio.base = XGI_PCI_RESOURCE_START(dev, 1);
	info->mmio.size = XGI_PCI_RESOURCE_SIZE(dev, 1);

	/* check IO region */
	if (!request_mem_region(info->mmio.base, info->mmio.size, "xgi")) {
		XGI_ERROR("cannot reserve MMIO memory\n");
		goto error_disable_dev;
	}

	XGI_INFO("info->mmio.base: 0x%lx \n", info->mmio.base);
	XGI_INFO("info->mmio.size: 0x%lx \n", info->mmio.size);

	info->mmio.vbase = (unsigned char *)ioremap_nocache(info->mmio.base,
							    info->mmio.size);
	if (!info->mmio.vbase) {
		release_mem_region(info->mmio.base, info->mmio.size);
		XGI_ERROR("info->mmio.vbase failed\n");
		goto error_disable_dev;
	}
	xgi_enable_mmio(info);

	//xgi_enable_ge(info);

	XGI_INFO("info->mmio.vbase: 0x%p \n", info->mmio.vbase);

	info->fb.base = XGI_PCI_RESOURCE_START(dev, 0);
	info->fb.size = XGI_PCI_RESOURCE_SIZE(dev, 0);

	XGI_INFO("info->fb.base: 0x%lx \n", info->fb.base);
	XGI_INFO("info->fb.size: 0x%lx \n", info->fb.size);

	info->fb.size = bIn3cf(0x54) * 8 * 1024 * 1024;
	XGI_INFO("info->fb.size: 0x%lx \n", info->fb.size);

	/* check frame buffer region
	   if (!request_mem_region(info->fb.base, info->fb.size, "xgi"))
	   {
	   release_mem_region(info->mmio.base, info->mmio.size);
	   XGI_ERROR("cannot reserve frame buffer memory\n");
	   goto error_disable_dev;
	   }

	   info->fb.vbase = (unsigned char *)ioremap_nocache(info->fb.base,
	   info->fb.size);

	   if (!info->fb.vbase)
	   {
	   release_mem_region(info->mmio.base, info->mmio.size);
	   release_mem_region(info->fb.base, info->fb.size);
	   XGI_ERROR("info->fb.vbase failed\n");
	   goto error_disable_dev;
	   }
	 */
	info->fb.vbase = NULL;
	XGI_INFO("info->fb.vbase: 0x%p \n", info->fb.vbase);

	info->irq = dev->irq;

	/* check common error condition */
	if (info->irq == 0) {
		XGI_ERROR("Can't find an IRQ for your XGI card!  \n");
		goto error_zero_dev;
	}
	XGI_INFO("info->irq: %lx \n", info->irq);

	//xgi_enable_dvi_interrupt(info);

	/* sanity check the IO apertures */
	if ((info->mmio.base == 0) || (info->mmio.size == 0)
	    || (info->fb.base == 0) || (info->fb.size == 0)) {
		XGI_ERROR("The IO regions for your XGI card are invalid.\n");

		if ((info->mmio.base == 0) || (info->mmio.size == 0)) {
			XGI_ERROR("mmio appears to be wrong: 0x%lx 0x%lx\n",
				  info->mmio.base, info->mmio.size);
		}

		if ((info->fb.base == 0) || (info->fb.size == 0)) {
			XGI_ERROR
			    ("frame buffer appears to be wrong: 0x%lx 0x%lx\n",
			     info->fb.base, info->fb.size);
		}

		goto error_zero_dev;
	}
	//xgi_num_devices++;

	return 0;

      error_zero_dev:
	release_mem_region(info->fb.base, info->fb.size);
	release_mem_region(info->mmio.base, info->mmio.size);

      error_disable_dev:
	pci_disable_device(dev);
	return -1;

}

/*
 * vma operations...
 * this is only called when the vmas are duplicated. this
 * appears to only happen when the process is cloned to create
 * a new process, and not when the process is threaded.
 *
 * increment the usage count for the physical pages, so when
 * this clone unmaps the mappings, the pages are not
 * deallocated under the original process.
 */
struct vm_operations_struct xgi_vm_ops = {
	.open = xgi_kern_vma_open,
	.close = xgi_kern_vma_release,
	.nopage = xgi_kern_vma_nopage,
};

void xgi_kern_vma_open(struct vm_area_struct *vma)
{
	XGI_INFO("VM: vma_open for 0x%lx - 0x%lx, offset 0x%lx\n",
		 vma->vm_start, vma->vm_end, XGI_VMA_OFFSET(vma));

	if (XGI_VMA_PRIVATE(vma)) {
		xgi_pcie_block_t *block =
		    (xgi_pcie_block_t *) XGI_VMA_PRIVATE(vma);
		XGI_ATOMIC_INC(block->use_count);
	}
}

void xgi_kern_vma_release(struct vm_area_struct *vma)
{
	XGI_INFO("VM: vma_release for 0x%lx - 0x%lx, offset 0x%lx\n",
		 vma->vm_start, vma->vm_end, XGI_VMA_OFFSET(vma));

	if (XGI_VMA_PRIVATE(vma)) {
		xgi_pcie_block_t *block =
		    (xgi_pcie_block_t *) XGI_VMA_PRIVATE(vma);
		XGI_ATOMIC_DEC(block->use_count);

		/*
		 * if use_count is down to 0, the kernel virtual mapping was freed
		 * but the underlying physical pages were not, we need to clear the
		 * bit and free the physical pages.
		 */
		if (XGI_ATOMIC_READ(block->use_count) == 0) {
			// Need TO Finish
			XGI_VMA_PRIVATE(vma) = NULL;
		}
	}
}

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 1))
struct page *xgi_kern_vma_nopage(struct vm_area_struct *vma,
				 unsigned long address, int *type)
{
	xgi_pcie_block_t *block = (xgi_pcie_block_t *) XGI_VMA_PRIVATE(vma);
	struct page *page = NOPAGE_SIGBUS;
	unsigned long offset = 0;
	unsigned long page_addr = 0;
/*
    XGI_INFO("VM: mmap([0x%lx-0x%lx] off=0x%lx) address: 0x%lx \n",
              vma->vm_start,
              vma->vm_end,
              XGI_VMA_OFFSET(vma),
              address);
*/
	offset = (address - vma->vm_start) + XGI_VMA_OFFSET(vma);

	offset = offset - block->bus_addr;

	offset >>= PAGE_SHIFT;

	page_addr = block->page_table[offset].virt_addr;

	if (xgi_temp) {
		XGI_INFO("block->bus_addr: 0x%lx block->hw_addr: 0x%lx"
			 "block->page_count: 0x%lx block->page_order: 0x%lx"
			 "block->page_table[0x%lx].virt_addr: 0x%lx\n",
			 block->bus_addr, block->hw_addr,
			 block->page_count, block->page_order,
			 offset, block->page_table[offset].virt_addr);
		xgi_temp = 0;
	}

	if (!page_addr)
		goto out;	/* hole or end-of-file */
	page = virt_to_page(page_addr);

	/* got it, now increment the count */
	get_page(page);
      out:
	return page;

}
#else
struct page *xgi_kern_vma_nopage(struct vm_area_struct *vma,
				 unsigned long address, int write_access)
{
	xgi_pcie_block_t *block = (xgi_pcie_block_t *) XGI_VMA_PRIVATE(vma);
	struct page *page = NOPAGE_SIGBUS;
	unsigned long offset = 0;
	unsigned long page_addr = 0;
/*
    XGI_INFO("VM: mmap([0x%lx-0x%lx] off=0x%lx) address: 0x%lx \n",
              vma->vm_start,
              vma->vm_end,
              XGI_VMA_OFFSET(vma),
              address);
*/
	offset = (address - vma->vm_start) + XGI_VMA_OFFSET(vma);

	offset = offset - block->bus_addr;

	offset >>= PAGE_SHIFT;

	page_addr = block->page_table[offset].virt_addr;

	if (xgi_temp) {
		XGI_INFO("block->bus_addr: 0x%lx block->hw_addr: 0x%lx"
			 "block->page_count: 0x%lx block->page_order: 0x%lx"
			 "block->page_table[0x%lx].virt_addr: 0x%lx\n",
			 block->bus_addr, block->hw_addr,
			 block->page_count, block->page_order,
			 offset, block->page_table[offset].virt_addr);
		xgi_temp = 0;
	}

	if (!page_addr)
		goto out;	/* hole or end-of-file */
	page = virt_to_page(page_addr);

	/* got it, now increment the count */
	get_page(page);
      out:
	return page;
}
#endif

#if 0
static struct file_operations xgi_fops = {
	/* owner:      THIS_MODULE, */
      poll:xgi_kern_poll,
      ioctl:xgi_kern_ioctl,
      mmap:xgi_kern_mmap,
      open:xgi_kern_open,
      release:xgi_kern_release,
};
#endif

static struct file_operations xgi_fops = {
	.owner = THIS_MODULE,
	.poll = xgi_kern_poll,
	.ioctl = xgi_kern_ioctl,
	.mmap = xgi_kern_mmap,
	.open = xgi_kern_open,
	.release = xgi_kern_release,
};

static xgi_file_private_t *xgi_alloc_file_private(void)
{
	xgi_file_private_t *fp;

	XGI_KMALLOC(fp, sizeof(xgi_file_private_t));
	if (!fp)
		return NULL;

	memset(fp, 0, sizeof(xgi_file_private_t));

	/* initialize this file's event queue */
	init_waitqueue_head(&fp->wait_queue);

	xgi_init_lock(fp->fp_lock);

	return fp;
}

static void xgi_free_file_private(xgi_file_private_t * fp)
{
	if (fp == NULL)
		return;

	XGI_KFREE(fp, sizeof(xgi_file_private_t));
}

int xgi_kern_open(struct inode *inode, struct file *filp)
{
	xgi_info_t *info = NULL;
	int dev_num;
	int result = 0, status;

	/*
	 * the type and num values are only valid if we are not using devfs.
	 * However, since we use them to retrieve the device pointer, we
	 * don't need them with devfs as filp->private_data is already
	 * initialized
	 */
	filp->private_data = xgi_alloc_file_private();
	if (filp->private_data == NULL)
		return -ENOMEM;

	XGI_INFO("filp->private_data %p\n", filp->private_data);
	/*
	 * for control device, just jump to its open routine
	 * after setting up the private data
	 */
	if (XGI_IS_CONTROL_DEVICE(inode))
		return xgi_kern_ctl_open(inode, filp);

	/* what device are we talking about? */
	dev_num = XGI_DEVICE_NUMBER(inode);
	if (dev_num >= XGI_MAX_DEVICES) {
		xgi_free_file_private(filp->private_data);
		filp->private_data = NULL;
		return -ENODEV;
	}

	info = &xgi_devices[dev_num];

	XGI_INFO("Jong-xgi_kern_open on device %d\n", dev_num);

	xgi_down(info->info_sem);
	XGI_CHECK_PCI_CONFIG(info);

	XGI_INFO_FROM_FP(filp) = info;

	/*
	 * map the memory and allocate isr on first open
	 */

	if (!(info->flags & XGI_FLAG_OPEN)) {
		XGI_INFO("info->flags & XGI_FLAG_OPEN \n");

		if (info->device_id == 0) {
			XGI_INFO("open of nonexistent device %d\n", dev_num);
			result = -ENXIO;
			goto failed;
		}

		/* initialize struct irqaction */
		status = request_irq(info->irq, xgi_kern_isr,
				     SA_INTERRUPT | SA_SHIRQ, "xgi",
				     (void *)info);
		if (status != 0) {
			if (info->irq && (status == -EBUSY)) {
				XGI_ERROR
				    ("Tried to get irq %d, but another driver",
				     (unsigned int)info->irq);
				XGI_ERROR("has it and is not sharing it.\n");
			}
			XGI_ERROR("isr request failed 0x%x\n", status);
			result = -EIO;
			goto failed;
		}

		/*
		 * #define DECLARE_TASKLET(name, func, data) \
		 * struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
		 */
		info->tasklet.func = xgi_kern_isr_bh;
		info->tasklet.data = (unsigned long)info;
		tasklet_enable(&info->tasklet);

		/* Alloc 1M bytes for cmdbuffer which is flush2D batch array */
		xgi_cmdlist_initialize(info, 0x100000);

		info->flags |= XGI_FLAG_OPEN;
	}

	XGI_ATOMIC_INC(info->use_count);

      failed:
	xgi_up(info->info_sem);

	if ((result) && filp->private_data) {
		xgi_free_file_private(filp->private_data);
		filp->private_data = NULL;
	}

	return result;
}

int xgi_kern_release(struct inode *inode, struct file *filp)
{
	xgi_info_t *info = XGI_INFO_FROM_FP(filp);

	XGI_CHECK_PCI_CONFIG(info);

	/*
	 * for control device, just jump to its open routine
	 * after setting up the private data
	 */
	if (XGI_IS_CONTROL_DEVICE(inode))
		return xgi_kern_ctl_close(inode, filp);

	XGI_INFO("Jong-xgi_kern_release on device %d\n",
		 XGI_DEVICE_NUMBER(inode));

	xgi_down(info->info_sem);
	if (XGI_ATOMIC_DEC_AND_TEST(info->use_count)) {

		/*
		 * The usage count for this device has dropped to zero, it can be shut
		 * down safely; disable its interrupts.
		 */

		/*
		 * Disable this device's tasklet to make sure that no bottom half will
		 * run with undefined device state.
		 */
		tasklet_disable(&info->tasklet);

		/*
		 * Free the IRQ, which may block until all pending interrupt processing
		 * has completed.
		 */
		free_irq(info->irq, (void *)info);

		xgi_cmdlist_cleanup(info);

		/* leave INIT flag alone so we don't reinit every time */
		info->flags &= ~XGI_FLAG_OPEN;
	}

	xgi_up(info->info_sem);

	if (FILE_PRIVATE(filp)) {
		xgi_free_file_private(FILE_PRIVATE(filp));
		FILE_PRIVATE(filp) = NULL;
	}

	return 0;
}

int xgi_kern_mmap(struct file *filp, struct vm_area_struct *vma)
{
	//struct inode        *inode = INODE_FROM_FP(filp);
	xgi_info_t *info = XGI_INFO_FROM_FP(filp);
	xgi_pcie_block_t *block;
	int pages = 0;
	unsigned long prot;

	XGI_INFO("Jong-VM: mmap([0x%lx-0x%lx] off=0x%lx)\n",
		 vma->vm_start, vma->vm_end, XGI_VMA_OFFSET(vma));

	XGI_CHECK_PCI_CONFIG(info);

	if (XGI_MASK_OFFSET(vma->vm_start)
	    || XGI_MASK_OFFSET(vma->vm_end)) {
		XGI_ERROR("VM: bad mmap range: %lx - %lx\n",
			  vma->vm_start, vma->vm_end);
		return -ENXIO;
	}

	pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;

	vma->vm_ops = &xgi_vm_ops;

	/* XGI IO(reg) space */
	if (IS_IO_OFFSET
	    (info, XGI_VMA_OFFSET(vma), vma->vm_end - vma->vm_start)) {
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
		if (XGI_REMAP_PAGE_RANGE(vma->vm_start,
					 XGI_VMA_OFFSET(vma),
					 vma->vm_end - vma->vm_start,
					 vma->vm_page_prot))
			return -EAGAIN;

		/* mark it as IO so that we don't dump it on core dump */
		vma->vm_flags |= VM_IO;
		XGI_INFO("VM: mmap io space \n");
	}
	/* XGI fb space */
	/* Jong 06/14/2006; moved behind PCIE or modify IS_FB_OFFSET */
	else if (IS_FB_OFFSET
		 (info, XGI_VMA_OFFSET(vma), vma->vm_end - vma->vm_start)) {
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
		if (XGI_REMAP_PAGE_RANGE(vma->vm_start,
					 XGI_VMA_OFFSET(vma),
					 vma->vm_end - vma->vm_start,
					 vma->vm_page_prot))
			return -EAGAIN;

		// mark it as IO so that we don't dump it on core dump
		vma->vm_flags |= VM_IO;
		XGI_INFO("VM: mmap fb space \n");
	}
	/* PCIE allocator */
	/* XGI_VMA_OFFSET(vma) is offset based on pcie.base (HW address space) */
	else if (IS_PCIE_OFFSET
		 (info, XGI_VMA_OFFSET(vma), vma->vm_end - vma->vm_start)) {
		xgi_down(info->pcie_sem);

		block =
		    (xgi_pcie_block_t *) xgi_find_pcie_block(info,
							     XGI_VMA_OFFSET
							     (vma));

		if (block == NULL) {
			XGI_ERROR("couldn't find pre-allocated PCIE memory!\n");
			xgi_up(info->pcie_sem);
			return -EAGAIN;
		}

		if (block->page_count != pages) {
			XGI_ERROR
			    ("pre-allocated PCIE memory has wrong number of pages!\n");
			xgi_up(info->pcie_sem);
			return -EAGAIN;
		}

		vma->vm_private_data = block;
		XGI_ATOMIC_INC(block->use_count);
		xgi_up(info->pcie_sem);

		/*
		 * prevent the swapper from swapping it out
		 * mark the memory i/o so the buffers aren't
		 * dumped on core dumps */
		vma->vm_flags |= (VM_LOCKED | VM_IO);

		/* un-cached */
		prot = pgprot_val(vma->vm_page_prot);
		/* 
		   if (boot_cpu_data.x86 > 3)
		   prot |= _PAGE_PCD | _PAGE_PWT;
		 */
		vma->vm_page_prot = __pgprot(prot);

		XGI_INFO("VM: mmap pcie space \n");
	}
#if 0
	else if (IS_FB_OFFSET
		 (info, XGI_VMA_OFFSET(vma), vma->vm_end - vma->vm_start)) {
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
		if (XGI_REMAP_PAGE_RANGE(vma->vm_start,
					 XGI_VMA_OFFSET(vma),
					 vma->vm_end - vma->vm_start,
					 vma->vm_page_prot))
			return -EAGAIN;

		// mark it as IO so that we don't dump it on core dump
		vma->vm_flags |= VM_IO;
		XGI_INFO("VM: mmap fb space \n");
	}
#endif
	else {
		vma->vm_flags |= (VM_IO | VM_LOCKED);
		XGI_ERROR("VM: mmap wrong range \n");
	}

	vma->vm_file = filp;

	return 0;
}

unsigned int xgi_kern_poll(struct file *filp, struct poll_table_struct *wait)
{
	xgi_file_private_t *fp;
	xgi_info_t *info;
	unsigned int mask = 0;
	unsigned long eflags;

	info = XGI_INFO_FROM_FP(filp);

	if (info->device_number == XGI_CONTROL_DEVICE_NUMBER)
		return xgi_kern_ctl_poll(filp, wait);

	fp = XGI_GET_FP(filp);

	if (!(filp->f_flags & O_NONBLOCK)) {
		/* add us to the list */
		poll_wait(filp, &fp->wait_queue, wait);
	}

	xgi_lock_irqsave(fp->fp_lock, eflags);

	/* wake the user on any event */
	if (fp->num_events) {
		XGI_INFO("Hey, an event occured!\n");
		/*
		 * trigger the client, when they grab the event,
		 * we'll decrement the event count
		 */
		mask |= (POLLPRI | POLLIN);
	}
	xgi_unlock_irqsave(fp->fp_lock, eflags);

	return mask;
}

int xgi_kern_ioctl(struct inode *inode, struct file *filp,
		   unsigned int cmd, unsigned long arg)
{
	xgi_info_t *info;
	xgi_mem_alloc_t *alloc = NULL;

	int status = 0;
	void *arg_copy;
	int arg_size;
	int err = 0;

	info = XGI_INFO_FROM_FP(filp);

	XGI_INFO("Jong-ioctl(0x%x, 0x%x, 0x%lx, 0x%x)\n", _IOC_TYPE(cmd),
		 _IOC_NR(cmd), arg, _IOC_SIZE(cmd));
	/*
	 * extract the type and number bitfields, and don't decode
	 * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
	 */
	if (_IOC_TYPE(cmd) != XGI_IOCTL_MAGIC)
		return -ENOTTY;
	if (_IOC_NR(cmd) > XGI_IOCTL_MAXNR)
		return -ENOTTY;

	/*
	 * the direction is a bitmask, and VERIFY_WRITE catches R/W
	 * transfers. `Type' is user-oriented, while
	 * access_ok is kernel-oriented, so the concept of "read" and
	 * "write" is reversed
	 */
	if (_IOC_DIR(cmd) & _IOC_READ) {
		err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
	} else if (_IOC_DIR(cmd) & _IOC_WRITE) {
		err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
	}
	if (err)
		return -EFAULT;

	XGI_CHECK_PCI_CONFIG(info);

	arg_size = _IOC_SIZE(cmd);
	XGI_KMALLOC(arg_copy, arg_size);
	if (arg_copy == NULL) {
		XGI_ERROR("failed to allocate ioctl memory\n");
		return -ENOMEM;
	}

	/* Jong 05/25/2006 */
	/* copy_from_user(arg_copy, (void *)arg, arg_size); */
	if (copy_from_user(arg_copy, (void *)arg, arg_size)) {
		XGI_ERROR("failed to copyin ioctl data\n");
		XGI_INFO("Jong-copy_from_user-fail! \n");
	} else
		XGI_INFO("Jong-copy_from_user-OK! \n");

	alloc = (xgi_mem_alloc_t *) arg_copy;
	XGI_INFO("Jong-succeeded in copy_from_user 0x%lx, 0x%x bytes.\n", arg,
		 arg_size);

	switch (_IOC_NR(cmd)) {
	case XGI_ESC_DEVICE_INFO:
		XGI_INFO("Jong-xgi_ioctl_get_device_info \n");
		xgi_get_device_info(info, (struct xgi_chip_info_s *)arg_copy);
		break;
	case XGI_ESC_POST_VBIOS:
		XGI_INFO("Jong-xgi_ioctl_post_vbios \n");
		break;
	case XGI_ESC_FB_ALLOC:
		XGI_INFO("Jong-xgi_ioctl_fb_alloc \n");
		xgi_fb_alloc(info, (struct xgi_mem_req_s *)arg_copy, alloc);
		break;
	case XGI_ESC_FB_FREE:
		XGI_INFO("Jong-xgi_ioctl_fb_free \n");
		xgi_fb_free(info, *(unsigned long *)arg_copy);
		break;
	case XGI_ESC_MEM_COLLECT:
		XGI_INFO("Jong-xgi_ioctl_mem_collect \n");
		xgi_mem_collect(info, (unsigned int *)arg_copy);
		break;
	case XGI_ESC_PCIE_ALLOC:
		XGI_INFO("Jong-xgi_ioctl_pcie_alloc \n");
		xgi_pcie_alloc(info, ((xgi_mem_req_t *) arg_copy)->size,
			       ((xgi_mem_req_t *) arg_copy)->owner, alloc);
		break;
	case XGI_ESC_PCIE_FREE:
		XGI_INFO("Jong-xgi_ioctl_pcie_free: bus_addr = 0x%lx \n",
			 *((unsigned long *)arg_copy));
		xgi_pcie_free(info, *((unsigned long *)arg_copy));
		break;
	case XGI_ESC_PCIE_CHECK:
		XGI_INFO("Jong-xgi_pcie_heap_check \n");
		xgi_pcie_heap_check();
		break;
	case XGI_ESC_GET_SCREEN_INFO:
		XGI_INFO("Jong-xgi_get_screen_info \n");
		xgi_get_screen_info(info, (struct xgi_screen_info_s *)arg_copy);
		break;
	case XGI_ESC_PUT_SCREEN_INFO:
		XGI_INFO("Jong-xgi_put_screen_info \n");
		xgi_put_screen_info(info, (struct xgi_screen_info_s *)arg_copy);
		break;
	case XGI_ESC_MMIO_INFO:
		XGI_INFO("Jong-xgi_ioctl_get_mmio_info \n");
		xgi_get_mmio_info(info, (struct xgi_mmio_info_s *)arg_copy);
		break;
	case XGI_ESC_GE_RESET:
		XGI_INFO("Jong-xgi_ioctl_ge_reset \n");
		xgi_ge_reset(info);
		break;
	case XGI_ESC_SAREA_INFO:
		XGI_INFO("Jong-xgi_ioctl_sarea_info \n");
		xgi_sarea_info(info, (struct xgi_sarea_info_s *)arg_copy);
		break;
	case XGI_ESC_DUMP_REGISTER:
		XGI_INFO("Jong-xgi_ioctl_dump_register \n");
		xgi_dump_register(info);
		break;
	case XGI_ESC_DEBUG_INFO:
		XGI_INFO("Jong-xgi_ioctl_restore_registers \n");
		xgi_restore_registers(info);
		//xgi_write_pcie_mem(info, (struct xgi_mem_req_s *) arg_copy);
		//xgi_read_pcie_mem(info, (struct xgi_mem_req_s *) arg_copy);
		break;
	case XGI_ESC_SUBMIT_CMDLIST:
		XGI_INFO("Jong-xgi_ioctl_submit_cmdlist \n");
		xgi_submit_cmdlist(info, (xgi_cmd_info_t *) arg_copy);
		break;
	case XGI_ESC_TEST_RWINKERNEL:
		XGI_INFO("Jong-xgi_test_rwinkernel \n");
		xgi_test_rwinkernel(info, *(unsigned long *)arg_copy);
		break;
	case XGI_ESC_STATE_CHANGE:
		XGI_INFO("Jong-xgi_state_change \n");
		xgi_state_change(info, (xgi_state_info_t *) arg_copy);
		break;
	case XGI_ESC_CPUID:
		XGI_INFO("Jong-XGI_ESC_CPUID \n");
		xgi_get_cpu_id((struct cpu_info_s *)arg_copy);
		break;
	default:
		XGI_INFO("Jong-xgi_ioctl_default \n");
		status = -EINVAL;
		break;
	}

	if (copy_to_user((void *)arg, arg_copy, arg_size)) {
		XGI_ERROR("failed to copyout ioctl data\n");
		XGI_INFO("Jong-copy_to_user-fail! \n");
	} else
		XGI_INFO("Jong-copy_to_user-OK! \n");

	XGI_KFREE(arg_copy, arg_size);
	return status;
}

/*
 * xgi control driver operations defined here
 */
int xgi_kern_ctl_open(struct inode *inode, struct file *filp)
{
	xgi_info_t *info = &xgi_ctl_device;

	int rc = 0;

	XGI_INFO("Jong-xgi_kern_ctl_open\n");

	xgi_down(info->info_sem);
	info->device_number = XGI_CONTROL_DEVICE_NUMBER;

	/* save the xgi info in file->private_data */
	filp->private_data = info;

	if (XGI_ATOMIC_READ(info->use_count) == 0) {
		init_waitqueue_head(&xgi_ctl_waitqueue);
	}

	info->flags |= XGI_FLAG_OPEN + XGI_FLAG_CONTROL;

	XGI_ATOMIC_INC(info->use_count);
	xgi_up(info->info_sem);

	return rc;
}

int xgi_kern_ctl_close(struct inode *inode, struct file *filp)
{
	xgi_info_t *info = XGI_INFO_FROM_FP(filp);

	XGI_INFO("Jong-xgi_kern_ctl_close\n");

	xgi_down(info->info_sem);
	if (XGI_ATOMIC_DEC_AND_TEST(info->use_count)) {
		info->flags = 0;
	}
	xgi_up(info->info_sem);

	if (FILE_PRIVATE(filp)) {
		xgi_free_file_private(FILE_PRIVATE(filp));
		FILE_PRIVATE(filp) = NULL;
	}

	return 0;
}

unsigned int xgi_kern_ctl_poll(struct file *filp, poll_table * wait)
{
	//xgi_info_t  *info = XGI_INFO_FROM_FP(filp);;
	unsigned int ret = 0;

	if (!(filp->f_flags & O_NONBLOCK)) {
		poll_wait(filp, &xgi_ctl_waitqueue, wait);
	}

	return ret;
}

/*
 * xgi proc system
 */
static u8 xgi_find_pcie_capability(struct pci_dev *dev)
{
	u16 status;
	u8 cap_ptr, cap_id;

	pci_read_config_word(dev, PCI_STATUS, &status);
	status &= PCI_STATUS_CAP_LIST;
	if (!status)
		return 0;

	switch (dev->hdr_type) {
	case PCI_HEADER_TYPE_NORMAL:
	case PCI_HEADER_TYPE_BRIDGE:
		pci_read_config_byte(dev, PCI_CAPABILITY_LIST, &cap_ptr);
		break;
	default:
		return 0;
	}

	do {
		cap_ptr &= 0xFC;
		pci_read_config_byte(dev, cap_ptr + PCI_CAP_LIST_ID, &cap_id);
		pci_read_config_byte(dev, cap_ptr + PCI_CAP_LIST_NEXT,
				     &cap_ptr);
	} while (cap_ptr && cap_id != 0xFF);

	return 0;
}

static struct pci_dev *xgi_get_pci_device(xgi_info_t * info)
{
	struct pci_dev *dev;

	dev = XGI_PCI_GET_DEVICE(info->vendor_id, info->device_id, NULL);
	while (dev) {
		if (XGI_PCI_SLOT_NUMBER(dev) == info->slot
		    && XGI_PCI_BUS_NUMBER(dev) == info->bus)
			return dev;
		dev = XGI_PCI_GET_DEVICE(info->vendor_id, info->device_id, dev);
	}

	return NULL;
}

int xgi_kern_read_card_info(char *page, char **start, off_t off,
			    int count, int *eof, void *data)
{
	struct pci_dev *dev;
	char *type;
	int len = 0;

	xgi_info_t *info;
	info = (xgi_info_t *) data;

	dev = xgi_get_pci_device(info);
	if (!dev)
		return 0;

	type = xgi_find_pcie_capability(dev) ? "PCIE" : "PCI";
	len += sprintf(page + len, "Card Type: \t %s\n", type);

	XGI_PCI_DEV_PUT(dev);
	return len;
}

int xgi_kern_read_version(char *page, char **start, off_t off,
			  int count, int *eof, void *data)
{
	int len = 0;

	len += sprintf(page + len, "XGI version: %s\n", "1.0");
	len += sprintf(page + len, "GCC version:  %s\n", "3.0");

	return len;
}

int xgi_kern_read_pcie_info(char *page, char **start, off_t off,
			    int count, int *eof, void *data)
{
	return 0;
}

int xgi_kern_read_status(char *page, char **start, off_t off,
			 int count, int *eof, void *data)
{
	return 0;
}

static void xgi_proc_create(void)
{
#ifdef CONFIG_PROC_FS

	struct pci_dev *dev;
	int i = 0;
	char name[6];

	struct proc_dir_entry *entry;
	struct proc_dir_entry *proc_xgi_pcie, *proc_xgi_cards;

	xgi_info_t *info;
	xgi_info_t *xgi_max_devices;

	/* world readable directory */
	int flags = S_IFDIR | S_IRUGO | S_IXUGO;

	proc_xgi = create_proc_entry("xgi", flags, proc_root_driver);
	if (!proc_xgi)
		goto failed;

	proc_xgi_cards = create_proc_entry("cards", flags, proc_xgi);
	if (!proc_xgi_cards)
		goto failed;

	proc_xgi_pcie = create_proc_entry("pcie", flags, proc_xgi);
	if (!proc_xgi_pcie)
		goto failed;

	/*
	 * Set the module owner to ensure that the reference
	 * count reflects accesses to the proc files.
	 */
	proc_xgi->owner = THIS_MODULE;
	proc_xgi_cards->owner = THIS_MODULE;
	proc_xgi_pcie->owner = THIS_MODULE;

	xgi_max_devices = xgi_devices + XGI_MAX_DEVICES;
	for (info = xgi_devices; info < xgi_max_devices; info++) {
		if (info->device_id == 0)
			break;

		/* world readable file */
		flags = S_IFREG | S_IRUGO;

		dev = xgi_get_pci_device(info);
		if (!dev)
			break;

		sprintf(name, "%d", i++);
		entry = create_proc_entry(name, flags, proc_xgi_cards);
		if (!entry) {
			XGI_PCI_DEV_PUT(dev);
			goto failed;
		}

		entry->data = info;
		entry->read_proc = xgi_kern_read_card_info;
		entry->owner = THIS_MODULE;

		if (xgi_find_pcie_capability(dev)) {
			entry =
			    create_proc_entry("status", flags, proc_xgi_pcie);
			if (!entry) {
				XGI_PCI_DEV_PUT(dev);
				goto failed;
			}

			entry->data = info;
			entry->read_proc = xgi_kern_read_status;
			entry->owner = THIS_MODULE;

			entry = create_proc_entry("card", flags, proc_xgi_pcie);
			if (!entry) {
				XGI_PCI_DEV_PUT(dev);
				goto failed;
			}

			entry->data = info;
			entry->read_proc = xgi_kern_read_pcie_info;
			entry->owner = THIS_MODULE;
		}

		XGI_PCI_DEV_PUT(dev);
	}

	entry = create_proc_entry("version", flags, proc_xgi);
	if (!entry)
		goto failed;

	entry->read_proc = xgi_kern_read_version;
	entry->owner = THIS_MODULE;

	entry = create_proc_entry("host-bridge", flags, proc_xgi_pcie);
	if (!entry)
		goto failed;

	entry->data = NULL;
	entry->read_proc = xgi_kern_read_pcie_info;
	entry->owner = THIS_MODULE;

	return;

      failed:
	XGI_ERROR("failed to create /proc entries!\n");
	xgi_proc_remove_all(proc_xgi);
#endif
}

#ifdef CONFIG_PROC_FS
static void xgi_proc_remove_all(struct proc_dir_entry *entry)
{
	while (entry) {
		struct proc_dir_entry *next = entry->next;
		if (entry->subdir)
			xgi_proc_remove_all(entry->subdir);
		remove_proc_entry(entry->name, entry->parent);
		if (entry == proc_xgi)
			break;
		entry = next;
	}
}
#endif

static void xgi_proc_remove(void)
{
#ifdef CONFIG_PROC_FS
	xgi_proc_remove_all(proc_xgi);
#endif
}

/*
 * driver receives an interrupt if someone waiting, then hand it off.
 */
irqreturn_t xgi_kern_isr(int irq, void *dev_id, struct pt_regs *regs)
{
	xgi_info_t *info = (xgi_info_t *) dev_id;
	u32 need_to_run_bottom_half = 0;

	//XGI_INFO("xgi_kern_isr \n");

	//XGI_CHECK_PCI_CONFIG(info);

	//xgi_dvi_irq_handler(info);

	if (need_to_run_bottom_half) {
		tasklet_schedule(&info->tasklet);
	}

	return IRQ_HANDLED;
}

void xgi_kern_isr_bh(unsigned long data)
{
	xgi_info_t *info = (xgi_info_t *) data;

	XGI_INFO("xgi_kern_isr_bh \n");

	//xgi_dvi_irq_handler(info);

	XGI_CHECK_PCI_CONFIG(info);
}

static void xgi_lock_init(xgi_info_t * info)
{
	if (info == NULL)
		return;

	spin_lock_init(&info->info_lock);

	sema_init(&info->info_sem, 1);
	sema_init(&info->fb_sem, 1);
	sema_init(&info->pcie_sem, 1);

	XGI_ATOMIC_SET(info->use_count, 0);
}

static void xgi_dev_init(xgi_info_t * info)
{
	struct pci_dev *pdev = NULL;
	struct xgi_dev *dev;
	int found = 0;
	u16 pci_cmd;

	XGI_INFO("Enter xgi_dev_init \n");

	//XGI_PCI_FOR_EACH_DEV(pdev)
	{
		for (dev = xgidev_list; dev->vendor; dev++) {
			if ((dev->vendor == pdev->vendor)
			    && (dev->device == pdev->device)) {
				XGI_INFO("dev->vendor = pdev->vendor= %x \n",
					 dev->vendor);
				XGI_INFO("dev->device = pdev->device= %x \n",
					 dev->device);

				xgi_devices[found].device_id = pdev->device;

				pci_read_config_byte(pdev, PCI_REVISION_ID,
						     &xgi_devices[found].
						     revision_id);

				XGI_INFO("PCI_REVISION_ID= %x \n",
					 xgi_devices[found].revision_id);

				pci_read_config_word(pdev, PCI_COMMAND,
						     &pci_cmd);

				XGI_INFO("PCI_COMMAND = %x \n", pci_cmd);

				break;
			}
		}
	}
}

/*
 * Export to Linux Kernel
 */

static int __init xgi_init_module(void)
{
	xgi_info_t *info = &xgi_devices[xgi_num_devices];
	int i, result;

	XGI_INFO("Jong-xgi kernel driver %s initializing\n", XGI_DRV_VERSION);
	//SET_MODULE_OWNER(&xgi_fops);

	memset(xgi_devices, 0, sizeof(xgi_devices));

	if (pci_register_driver(&xgi_pci_driver) < 0) {
		pci_unregister_driver(&xgi_pci_driver);
		XGI_ERROR("no XGI graphics adapter found\n");
		return -ENODEV;
	}

	XGI_INFO("Jong-xgi_devices[%d].fb.base.: 0x%lx \n", xgi_num_devices,
		 xgi_devices[xgi_num_devices].fb.base);
	XGI_INFO("Jong-xgi_devices[%d].fb.size.: 0x%lx \n", xgi_num_devices,
		 xgi_devices[xgi_num_devices].fb.size);

/* Jong 07/27/2006; test for ubuntu */
/*
#ifdef CONFIG_DEVFS_FS

    XGI_INFO("Jong-Use devfs \n");
    do
    {
        xgi_devfs_handles[0] = XGI_DEVFS_REGISTER("xgi", 0);
        if (xgi_devfs_handles[0] == NULL)
        {
            result = -ENOMEM;
            XGI_ERROR("devfs register failed\n");
            goto failed;
        }
    } while(0);
	#else *//* no devfs, do it the "classic" way  */

	XGI_INFO("Jong-Use non-devfs \n");
	/*
	 * Register your major, and accept a dynamic number. This is the
	 * first thing to do, in order to avoid releasing other module's
	 * fops in scull_cleanup_module()
	 */
	result = XGI_REGISTER_CHRDEV(xgi_major, "xgi", &xgi_fops);
	if (result < 0) {
		XGI_ERROR("register chrdev failed\n");
		pci_unregister_driver(&xgi_pci_driver);
		return result;
	}
	if (xgi_major == 0)
		xgi_major = result;	/* dynamic */

	/* #endif *//* CONFIG_DEVFS_FS */

	XGI_INFO("Jong-major number %d\n", xgi_major);

	/* instantiate tasklets */
	for (i = 0; i < XGI_MAX_DEVICES; i++) {
		/*
		 * We keep one tasklet per card to avoid latency issues with more
		 * than one device; no two instances of a single tasklet are ever
		 * executed concurrently.
		 */
		XGI_ATOMIC_SET(xgi_devices[i].tasklet.count, 1);
	}

	/* init the xgi control device */
	{
		xgi_info_t *info_ctl = &xgi_ctl_device;
		xgi_lock_init(info_ctl);
	}

	/* Init the resource manager */
	INIT_LIST_HEAD(&xgi_mempid_list);
	if (!xgi_fb_heap_init(info)) {
		XGI_ERROR("xgi_fb_heap_init() failed\n");
		result = -EIO;
		goto failed;
	}

	/* Init the resource manager */
	if (!xgi_pcie_heap_init(info)) {
		XGI_ERROR("xgi_pcie_heap_init() failed\n");
		result = -EIO;
		goto failed;
	}

	/* create /proc/driver/xgi */
	xgi_proc_create();

#if defined(DEBUG)
	inter_module_register("xgi_devices", THIS_MODULE, xgi_devices);
#endif

	return 0;

      failed:
#ifdef CONFIG_DEVFS_FS
	XGI_DEVFS_REMOVE_CONTROL();
	XGI_DEVFS_REMOVE_DEVICE(xgi_num_devices);
#endif

	if (XGI_UNREGISTER_CHRDEV(xgi_major, "xgi") < 0)
		XGI_ERROR("unregister xgi chrdev failed\n");

	for (i = 0; i < xgi_num_devices; i++) {
		if (xgi_devices[i].dev) {
			release_mem_region(xgi_devices[i].fb.base,
					   xgi_devices[i].fb.size);
			release_mem_region(xgi_devices[i].mmio.base,
					   xgi_devices[i].mmio.size);
		}
	}

	pci_unregister_driver(&xgi_pci_driver);
	return result;

	return 1;
}

void __exit xgi_exit_module(void)
{
	int i;

#ifdef CONFIG_DEVFS_FS
	XGI_DEVFS_REMOVE_DEVICE(xgi_num_devices);
#endif

	if (XGI_UNREGISTER_CHRDEV(xgi_major, "xgi") < 0)
		XGI_ERROR("unregister xgi chrdev failed\n");

	XGI_INFO("Jong-unregister xgi chrdev scceeded\n");
	for (i = 0; i < XGI_MAX_DEVICES; i++) {
		if (xgi_devices[i].dev) {
			/* clean up the flush2D batch array */
			xgi_cmdlist_cleanup(&xgi_devices[i]);

			if (xgi_devices[i].fb.vbase != NULL) {
				iounmap((void *)xgi_devices[i].fb.vbase);
				xgi_devices[i].fb.vbase = NULL;
			}
			if (xgi_devices[i].mmio.vbase != NULL) {
				iounmap((void *)xgi_devices[i].mmio.vbase);
				xgi_devices[i].mmio.vbase = NULL;
			}
			//release_mem_region(xgi_devices[i].fb.base, xgi_devices[i].fb.size);
			//XGI_INFO("release frame buffer mem region scceeded\n");

			release_mem_region(xgi_devices[i].mmio.base,
					   xgi_devices[i].mmio.size);
			XGI_INFO("release MMIO mem region scceeded\n");

			xgi_fb_heap_cleanup(&xgi_devices[i]);
			XGI_INFO("xgi_fb_heap_cleanup scceeded\n");

			xgi_pcie_heap_cleanup(&xgi_devices[i]);
			XGI_INFO("xgi_pcie_heap_cleanup scceeded\n");

			XGI_PCI_DISABLE_DEVICE(xgi_devices[i].dev);
		}
	}

	pci_unregister_driver(&xgi_pci_driver);

	/* remove /proc/driver/xgi */
	xgi_proc_remove();

#if defined(DEBUG)
	inter_module_unregister("xgi_devices");
#endif
}

module_init(xgi_init_module);
module_exit(xgi_exit_module);

#if defined(XGI_PM_SUPPORT_ACPI)
int xgi_acpi_event(struct pci_dev *dev, u32 state)
{
	return 1;
}

int xgi_kern_acpi_standby(struct pci_dev *dev, u32 state)
{
	return 1;
}

int xgi_kern_acpi_resume(struct pci_dev *dev)
{
	return 1;
}
#endif

MODULE_AUTHOR("Andrea Zhang <andrea_zhang@macrosynergy.com>");
MODULE_DESCRIPTION("xgi kernel driver for xgi cards");
MODULE_LICENSE("GPL");