[deliverable/linux.git] / drivers / pci / pcie / portdrv_pci.c

/*
 * File:	portdrv_pci.c
 * Purpose:	PCI Express Port Bus Driver
 *
 * Copyright (C) 2004 Intel
 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
 */

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/pm.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/pcieport_if.h>

#include "portdrv.h"

/*
 * Version Information
 */
#define DRIVER_VERSION "v1.0"
#define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
#define DRIVER_DESC "PCIE Port Bus Driver"
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

/* global data */
static const char device_name[] = "pcieport-driver";

/*
 * pcie_portdrv_probe - Probe PCI-Express port devices
 * @dev: PCI-Express port device being probed
 *
 * If detected invokes the pcie_port_device_register() method for 
 * this port device.
 *
 */
static int __devinit pcie_portdrv_probe (struct pci_dev *dev, 
				const struct pci_device_id *id )
{
	int			status;

	status = pcie_port_device_probe(dev);
	if (status)
		return status;

	if (pci_enable_device(dev) < 0) 
		return -ENODEV;
	
	pci_set_master(dev);
        if (!dev->irq) {
		printk(KERN_WARNING 
		"%s->Dev[%04x:%04x] has invalid IRQ. Check vendor BIOS\n", 
		__FUNCTION__, dev->device, dev->vendor);
	}
	if (pcie_port_device_register(dev)) {
		pci_disable_device(dev);
		return -ENOMEM;
	}

	return 0;
}

static void pcie_portdrv_remove (struct pci_dev *dev)
{
	pcie_port_device_remove(dev);
	kfree(pci_get_drvdata(dev));
}

#ifdef CONFIG_PM
static int pcie_portdrv_save_config(struct pci_dev *dev)
{
	return pci_save_state(dev);
}

static int pcie_portdrv_restore_config(struct pci_dev *dev)
{
	int retval;

	pci_restore_state(dev);
	retval = pci_enable_device(dev);
	if (retval)
		return retval;
	pci_set_master(dev);
	return 0;
}

static int pcie_portdrv_suspend (struct pci_dev *dev, pm_message_t state)
{
	int ret = pcie_port_device_suspend(dev, state);

	if (!ret)
		ret = pcie_portdrv_save_config(dev);
	return ret;
}

static int pcie_portdrv_resume (struct pci_dev *dev)
{
	pcie_portdrv_restore_config(dev);
	return pcie_port_device_resume(dev);
}
#endif

/*
 * LINUX Device Driver Model
 */
static const struct pci_device_id port_pci_ids[] = { {
	/* handle any PCI-Express port */
	PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0),
	}, { /* end: all zeroes */ }
};
MODULE_DEVICE_TABLE(pci, port_pci_ids);

static struct pci_driver pcie_portdrv = {
	.name		= (char *)device_name,
	.id_table	= &port_pci_ids[0],

	.probe		= pcie_portdrv_probe,
	.remove		= pcie_portdrv_remove,

#ifdef	CONFIG_PM
	.suspend	= pcie_portdrv_suspend,
	.resume		= pcie_portdrv_resume,
#endif	/* PM */
};

static int __init pcie_portdrv_init(void)
{
	int retval = 0;

	pcie_port_bus_register();
	retval = pci_register_driver(&pcie_portdrv);
	if (retval)
		pcie_port_bus_unregister();
	return retval;
}

static void __exit pcie_portdrv_exit(void) 
{
	pci_unregister_driver(&pcie_portdrv);
	pcie_port_bus_unregister();
}

module_init(pcie_portdrv_init);
module_exit(pcie_portdrv_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* File: portdrv_pci.c
	3	* Purpose: PCI Express Port Bus Driver
	4	*
	5	* Copyright (C) 2004 Intel
	6	* Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/pci.h>
	11	#include <linux/kernel.h>
	12	#include <linux/errno.h>
	13	#include <linux/pm.h>
	14	#include <linux/init.h>
4e57b681	15	#include <linux/slab.h>
1da177e4 LT	16	#include <linux/pcieport_if.h>
	17
	18	#include "portdrv.h"
	19
	20	/*
	21	* Version Information
	22	*/
	23	#define DRIVER_VERSION "v1.0"
	24	#define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
	25	#define DRIVER_DESC "PCIE Port Bus Driver"
	26	MODULE_AUTHOR(DRIVER_AUTHOR);
	27	MODULE_DESCRIPTION(DRIVER_DESC);
	28	MODULE_LICENSE("GPL");
	29
	30	/* global data */
	31	static const char device_name[] = "pcieport-driver";
	32
	33	/*
	34	* pcie_portdrv_probe - Probe PCI-Express port devices
	35	* @dev: PCI-Express port device being probed
	36	*
	37	* If detected invokes the pcie_port_device_register() method for
	38	* this port device.
	39	*
	40	*/
	41	static int __devinit pcie_portdrv_probe (struct pci_dev *dev,
	42	const struct pci_device_id *id )
	43	{
	44	int status;
	45
	46	status = pcie_port_device_probe(dev);
	47	if (status)
	48	return status;
	49
	50	if (pci_enable_device(dev) < 0)
	51	return -ENODEV;
	52
	53	pci_set_master(dev);
	54	if (!dev->irq) {
	55	printk(KERN_WARNING
	56	"%s->Dev[%04x:%04x] has invalid IRQ. Check vendor BIOS\n",
	57	__FUNCTION__, dev->device, dev->vendor);
	58	}
e4fd1f4a RD	59	if (pcie_port_device_register(dev)) {
e4fd1f4a RD	60	pci_disable_device(dev);
1da177e4	61	return -ENOMEM;
e4fd1f4a	62	}
1da177e4 LT	63
	64	return 0;
	65	}
	66
	67	static void pcie_portdrv_remove (struct pci_dev *dev)
	68	{
	69	pcie_port_device_remove(dev);
5823d100	70	kfree(pci_get_drvdata(dev));
1da177e4 LT	71	}
	72
	73	#ifdef CONFIG_PM
60854838 HK	74	static int pcie_portdrv_save_config(struct pci_dev *dev)
	75	{
	76	return pci_save_state(dev);
	77	}
	78
	79	static int pcie_portdrv_restore_config(struct pci_dev *dev)
	80	{
	81	int retval;
	82
	83	pci_restore_state(dev);
	84	retval = pci_enable_device(dev);
	85	if (retval)
	86	return retval;
	87	pci_set_master(dev);
	88	return 0;
	89	}
	90
7f4927c1	91	static int pcie_portdrv_suspend (struct pci_dev *dev, pm_message_t state)
1da177e4	92	{
5823d100	93	int ret = pcie_port_device_suspend(dev, state);
5823d100	94
75cde0e2 SL	95	if (!ret)
75cde0e2 SL	96	ret = pcie_portdrv_save_config(dev);
5823d100	97	return ret;
1da177e4 LT	98	}
	99
	100	static int pcie_portdrv_resume (struct pci_dev *dev)
	101	{
5823d100	102	pcie_portdrv_restore_config(dev);
1da177e4 LT	103	return pcie_port_device_resume(dev);
	104	}
	105	#endif
	106
	107	/*
	108	* LINUX Device Driver Model
	109	*/
	110	static const struct pci_device_id port_pci_ids[] = { {
	111	/* handle any PCI-Express port */
	112	PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) \| 0x00), ~0),
	113	}, { /* end: all zeroes */ }
	114	};
	115	MODULE_DEVICE_TABLE(pci, port_pci_ids);
	116
	117	static struct pci_driver pcie_portdrv = {
	118	.name = (char *)device_name,
	119	.id_table = &port_pci_ids[0],
	120
	121	.probe = pcie_portdrv_probe,
	122	.remove = pcie_portdrv_remove,
	123
	124	#ifdef CONFIG_PM
	125	.suspend = pcie_portdrv_suspend,
	126	.resume = pcie_portdrv_resume,
	127	#endif /* PM */
	128	};
	129
	130	static int __init pcie_portdrv_init(void)
	131	{
	132	int retval = 0;
	133
	134	pcie_port_bus_register();
	135	retval = pci_register_driver(&pcie_portdrv);
	136	if (retval)
	137	pcie_port_bus_unregister();
	138	return retval;
	139	}
	140
	141	static void __exit pcie_portdrv_exit(void)
	142	{
	143	pci_unregister_driver(&pcie_portdrv);
	144	pcie_port_bus_unregister();
	145	}
	146
	147	module_init(pcie_portdrv_init);
	148	module_exit(pcie_portdrv_exit);