[linux-2.6-block.git] / drivers / pci / hotplug / pciehp_core.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * PCI Express Hot Plug Controller Driver
 *
 * Copyright (C) 1995,2001 Compaq Computer Corporation
 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2001 IBM Corp.
 * Copyright (C) 2003-2004 Intel Corporation
 *
 * All rights reserved.
 *
 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
 *
 * Authors:
 *   Dan Zink <dan.zink@compaq.com>
 *   Greg Kroah-Hartman <greg@kroah.com>
 *   Dely Sy <dely.l.sy@intel.com>"
 */

#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/pci.h>
#include "pciehp.h"
#include <linux/interrupt.h>
#include <linux/time.h>

/* Global variables */
bool pciehp_debug;
bool pciehp_poll_mode;
int pciehp_poll_time;
static bool pciehp_force;

/*
 * not really modular, but the easiest way to keep compat with existing
 * bootargs behaviour is to continue using module_param here.
 */
module_param(pciehp_debug, bool, 0644);
module_param(pciehp_poll_mode, bool, 0644);
module_param(pciehp_poll_time, int, 0644);
module_param(pciehp_force, bool, 0644);
MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
MODULE_PARM_DESC(pciehp_force, "Force pciehp, even if OSHP is missing");

#define PCIE_MODULE_NAME "pciehp"

static int set_attention_status(struct hotplug_slot *slot, u8 value);
static int enable_slot(struct hotplug_slot *slot);
static int disable_slot(struct hotplug_slot *slot);
static int get_power_status(struct hotplug_slot *slot, u8 *value);
static int get_attention_status(struct hotplug_slot *slot, u8 *value);
static int get_latch_status(struct hotplug_slot *slot, u8 *value);
static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
static int reset_slot(struct hotplug_slot *slot, int probe);

/**
 * release_slot - free up the memory used by a slot
 * @hotplug_slot: slot to free
 */
static void release_slot(struct hotplug_slot *hotplug_slot)
{
	kfree(hotplug_slot->ops);
	kfree(hotplug_slot->info);
	kfree(hotplug_slot);
}

static int init_slot(struct controller *ctrl)
{
	struct slot *slot = ctrl->slot;
	struct hotplug_slot *hotplug = NULL;
	struct hotplug_slot_info *info = NULL;
	struct hotplug_slot_ops *ops = NULL;
	char name[SLOT_NAME_SIZE];
	int retval = -ENOMEM;

	hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
	if (!hotplug)
		goto out;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		goto out;

	/* Setup hotplug slot ops */
	ops = kzalloc(sizeof(*ops), GFP_KERNEL);
	if (!ops)
		goto out;

	ops->enable_slot = enable_slot;
	ops->disable_slot = disable_slot;
	ops->get_power_status = get_power_status;
	ops->get_adapter_status = get_adapter_status;
	ops->reset_slot = reset_slot;
	if (MRL_SENS(ctrl))
		ops->get_latch_status = get_latch_status;
	if (ATTN_LED(ctrl)) {
		ops->get_attention_status = get_attention_status;
		ops->set_attention_status = set_attention_status;
	} else if (ctrl->pcie->port->hotplug_user_indicators) {
		ops->get_attention_status = pciehp_get_raw_indicator_status;
		ops->set_attention_status = pciehp_set_raw_indicator_status;
	}

	/* register this slot with the hotplug pci core */
	hotplug->info = info;
	hotplug->private = slot;
	hotplug->release = &release_slot;
	hotplug->ops = ops;
	slot->hotplug_slot = hotplug;
	snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));

	retval = pci_hp_register(hotplug,
				 ctrl->pcie->port->subordinate, 0, name);
	if (retval)
		ctrl_err(ctrl, "pci_hp_register failed: error %d\n", retval);
out:
	if (retval) {
		kfree(ops);
		kfree(info);
		kfree(hotplug);
	}
	return retval;
}

static void cleanup_slot(struct controller *ctrl)
{
	pci_hp_deregister(ctrl->slot->hotplug_slot);
}

/*
 * set_attention_status - Turns the Amber LED for a slot on, off or blink
 */
static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
{
	struct slot *slot = hotplug_slot->private;

	pciehp_set_attention_status(slot, status);
	return 0;
}


static int enable_slot(struct hotplug_slot *hotplug_slot)
{
	struct slot *slot = hotplug_slot->private;

	return pciehp_sysfs_enable_slot(slot);
}


static int disable_slot(struct hotplug_slot *hotplug_slot)
{
	struct slot *slot = hotplug_slot->private;

	return pciehp_sysfs_disable_slot(slot);
}

static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = hotplug_slot->private;

	pciehp_get_power_status(slot, value);
	return 0;
}

static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = hotplug_slot->private;

	pciehp_get_attention_status(slot, value);
	return 0;
}

static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = hotplug_slot->private;

	pciehp_get_latch_status(slot, value);
	return 0;
}

static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = hotplug_slot->private;

	pciehp_get_adapter_status(slot, value);
	return 0;
}

static int reset_slot(struct hotplug_slot *hotplug_slot, int probe)
{
	struct slot *slot = hotplug_slot->private;

	return pciehp_reset_slot(slot, probe);
}

static int pciehp_probe(struct pcie_device *dev)
{
	int rc;
	struct controller *ctrl;
	struct slot *slot;
	u8 occupied, poweron;

	/* If this is not a "hotplug" service, we have no business here. */
	if (dev->service != PCIE_PORT_SERVICE_HP)
		return -ENODEV;

	if (!dev->port->subordinate) {
		/* Can happen if we run out of bus numbers during probe */
		dev_err(&dev->device,
			"Hotplug bridge without secondary bus, ignoring\n");
		return -ENODEV;
	}

	ctrl = pcie_init(dev);
	if (!ctrl) {
		dev_err(&dev->device, "Controller initialization failed\n");
		return -ENODEV;
	}
	set_service_data(dev, ctrl);

	/* Setup the slot information structures */
	rc = init_slot(ctrl);
	if (rc) {
		if (rc == -EBUSY)
			ctrl_warn(ctrl, "Slot already registered by another hotplug driver\n");
		else
			ctrl_err(ctrl, "Slot initialization failed (%d)\n", rc);
		goto err_out_release_ctlr;
	}

	/* Enable events after we have setup the data structures */
	rc = pcie_init_notification(ctrl);
	if (rc) {
		ctrl_err(ctrl, "Notification initialization failed (%d)\n", rc);
		goto err_out_free_ctrl_slot;
	}

	/* Check if slot is occupied */
	slot = ctrl->slot;
	pciehp_get_adapter_status(slot, &occupied);
	pciehp_get_power_status(slot, &poweron);
	if (occupied && pciehp_force) {
		mutex_lock(&slot->hotplug_lock);
		pciehp_enable_slot(slot);
		mutex_unlock(&slot->hotplug_lock);
	}
	/* If empty slot's power status is on, turn power off */
	if (!occupied && poweron && POWER_CTRL(ctrl))
		pciehp_power_off_slot(slot);

	return 0;

err_out_free_ctrl_slot:
	cleanup_slot(ctrl);
err_out_release_ctlr:
	pciehp_release_ctrl(ctrl);
	return -ENODEV;
}

static void pciehp_remove(struct pcie_device *dev)
{
	struct controller *ctrl = get_service_data(dev);

	cleanup_slot(ctrl);
	pciehp_release_ctrl(ctrl);
}

#ifdef CONFIG_PM
static int pciehp_suspend(struct pcie_device *dev)
{
	return 0;
}

static int pciehp_resume(struct pcie_device *dev)
{
	struct controller *ctrl;
	struct slot *slot;
	u8 status;

	ctrl = get_service_data(dev);

	/* reinitialize the chipset's event detection logic */
	pcie_reenable_notification(ctrl);

	slot = ctrl->slot;

	/* Check if slot is occupied */
	pciehp_get_adapter_status(slot, &status);
	mutex_lock(&slot->hotplug_lock);
	if (status)
		pciehp_enable_slot(slot);
	else
		pciehp_disable_slot(slot);
	mutex_unlock(&slot->hotplug_lock);
	return 0;
}
#endif /* PM */

static struct pcie_port_service_driver hpdriver_portdrv = {
	.name		= PCIE_MODULE_NAME,
	.port_type	= PCIE_ANY_PORT,
	.service	= PCIE_PORT_SERVICE_HP,

	.probe		= pciehp_probe,
	.remove		= pciehp_remove,

#ifdef	CONFIG_PM
	.suspend	= pciehp_suspend,
	.resume		= pciehp_resume,
#endif	/* PM */
};

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

	retval = pcie_port_service_register(&hpdriver_portdrv);
	dbg("pcie_port_service_register = %d\n", retval);
	if (retval)
		dbg("Failure to register service\n");

	return retval;
}
device_initcall(pcied_init);
Commit	Line	Data
736759ef	1	// SPDX-License-Identifier: GPL-2.0+
1da177e4 LT	2	/*
	3	* PCI Express Hot Plug Controller Driver
	4	*
	5	* Copyright (C) 1995,2001 Compaq Computer Corporation
	6	* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
	7	* Copyright (C) 2001 IBM Corp.
	8	* Copyright (C) 2003-2004 Intel Corporation
	9	*
	10	* All rights reserved.
	11	*
8cf4c195	12	* Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
1da177e4	13	*
5fbeef63 BH	14	* Authors:
	15	* Dan Zink <dan.zink@compaq.com>
	16	* Greg Kroah-Hartman <greg@kroah.com>
	17	* Dely Sy <dely.l.sy@intel.com>"
1da177e4 LT	18	*/
1da177e4 LT	19
1da177e4 LT	20	#include <linux/moduleparam.h>
1da177e4 LT	21	#include <linux/kernel.h>
5a0e3ad6	22	#include <linux/slab.h>
1da177e4	23	#include <linux/types.h>
1da177e4	24	#include <linux/pci.h>
1da177e4	25	#include "pciehp.h"
1da177e4	26	#include <linux/interrupt.h>
34d03419	27	#include <linux/time.h>
1da177e4 LT	28
1da177e4 LT	29	/* Global variables */
90ab5ee9 RR	30	bool pciehp_debug;
90ab5ee9 RR	31	bool pciehp_poll_mode;
1da177e4	32	int pciehp_poll_time;
0b950f0f	33	static bool pciehp_force;
1da177e4	34
70626d88 PG	35	/*
	36	* not really modular, but the easiest way to keep compat with existing
	37	* bootargs behaviour is to continue using module_param here.
	38	*/
1da177e4 LT	39	module_param(pciehp_debug, bool, 0644);
	40	module_param(pciehp_poll_mode, bool, 0644);
	41	module_param(pciehp_poll_time, int, 0644);
a3a45ec8	42	module_param(pciehp_force, bool, 0644);
1da177e4 LT	43	MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
	44	MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
	45	MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
28eb5f27	46	MODULE_PARM_DESC(pciehp_force, "Force pciehp, even if OSHP is missing");
1da177e4 LT	47
	48	#define PCIE_MODULE_NAME "pciehp"
	49
ff3ce480 BS	50	static int set_attention_status(struct hotplug_slot *slot, u8 value);
	51	static int enable_slot(struct hotplug_slot *slot);
	52	static int disable_slot(struct hotplug_slot *slot);
	53	static int get_power_status(struct hotplug_slot slot, u8 value);
	54	static int get_attention_status(struct hotplug_slot slot, u8 value);
	55	static int get_latch_status(struct hotplug_slot slot, u8 value);
	56	static int get_adapter_status(struct hotplug_slot slot, u8 value);
	57	static int reset_slot(struct hotplug_slot *slot, int probe);
1da177e4	58
b308240b DS	59	/**
	60	* release_slot - free up the memory used by a slot
	61	* @hotplug_slot: slot to free
	62	*/
	63	static void release_slot(struct hotplug_slot *hotplug_slot)
	64	{
586f1d66	65	kfree(hotplug_slot->ops);
c4635eb0 KK	66	kfree(hotplug_slot->info);
c4635eb0 KK	67	kfree(hotplug_slot);
a0b17257 KK	68	}
a0b17257 KK	69
8720d27d	70	static int init_slot(struct controller *ctrl)
1da177e4	71	{
8720d27d KK	72	struct slot *slot = ctrl->slot;
	73	struct hotplug_slot *hotplug = NULL;
	74	struct hotplug_slot_info *info = NULL;
586f1d66	75	struct hotplug_slot_ops *ops = NULL;
e1acb24f	76	char name[SLOT_NAME_SIZE];
a0b17257	77	int retval = -ENOMEM;
1da177e4	78
8720d27d KK	79	hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
	80	if (!hotplug)
	81	goto out;
	82
	83	info = kzalloc(sizeof(*info), GFP_KERNEL);
	84	if (!info)
	85	goto out;
	86
586f1d66 KK	87	/* Setup hotplug slot ops */
	88	ops = kzalloc(sizeof(*ops), GFP_KERNEL);
	89	if (!ops)
	90	goto out;
9cad7f58	91
586f1d66 KK	92	ops->enable_slot = enable_slot;
	93	ops->disable_slot = disable_slot;
	94	ops->get_power_status = get_power_status;
	95	ops->get_adapter_status = get_adapter_status;
2e35afae	96	ops->reset_slot = reset_slot;
586f1d66 KK	97	if (MRL_SENS(ctrl))
	98	ops->get_latch_status = get_latch_status;
	99	if (ATTN_LED(ctrl)) {
	100	ops->get_attention_status = get_attention_status;
	101	ops->set_attention_status = set_attention_status;
576243b3 KB	102	} else if (ctrl->pcie->port->hotplug_user_indicators) {
	103	ops->get_attention_status = pciehp_get_raw_indicator_status;
	104	ops->set_attention_status = pciehp_set_raw_indicator_status;
586f1d66 KK	105	}
586f1d66 KK	106
8720d27d KK	107	/* register this slot with the hotplug pci core */
	108	hotplug->info = info;
	109	hotplug->private = slot;
	110	hotplug->release = &release_slot;
586f1d66	111	hotplug->ops = ops;
8720d27d	112	slot->hotplug_slot = hotplug;
07a09694	113	snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
8720d27d	114
8720d27d	115	retval = pci_hp_register(hotplug,
385e2491	116	ctrl->pcie->port->subordinate, 0, name);
445f7985	117	if (retval)
3784e0c6	118	ctrl_err(ctrl, "pci_hp_register failed: error %d\n", retval);
8720d27d KK	119	out:
8720d27d KK	120	if (retval) {
586f1d66	121	kfree(ops);
8720d27d KK	122	kfree(info);
8720d27d KK	123	kfree(hotplug);
1da177e4	124	}
a0b17257	125	return retval;
1da177e4 LT	126	}
1da177e4 LT	127
8720d27d	128	static void cleanup_slot(struct controller *ctrl)
1da177e4	129	{
8720d27d	130	pci_hp_deregister(ctrl->slot->hotplug_slot);
1da177e4 LT	131	}
1da177e4 LT	132
1da177e4 LT	133	/*
	134	* set_attention_status - Turns the Amber LED for a slot on, off or blink
	135	*/
	136	static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
	137	{
	138	struct slot *slot = hotplug_slot->private;
	139
6dae6202 BH	140	pciehp_set_attention_status(slot, status);
6dae6202 BH	141	return 0;
1da177e4 LT	142	}
	143
	144
	145	static int enable_slot(struct hotplug_slot *hotplug_slot)
	146	{
	147	struct slot *slot = hotplug_slot->private;
	148
5d386e1a	149	return pciehp_sysfs_enable_slot(slot);
1da177e4 LT	150	}
	151
	152
	153	static int disable_slot(struct hotplug_slot *hotplug_slot)
	154	{
	155	struct slot *slot = hotplug_slot->private;
	156
5d386e1a	157	return pciehp_sysfs_disable_slot(slot);
1da177e4 LT	158	}
	159
	160	static int get_power_status(struct hotplug_slot hotplug_slot, u8 value)
	161	{
	162	struct slot *slot = hotplug_slot->private;
1da177e4	163
6dae6202 BH	164	pciehp_get_power_status(slot, value);
6dae6202 BH	165	return 0;
1da177e4 LT	166	}
	167
	168	static int get_attention_status(struct hotplug_slot hotplug_slot, u8 value)
	169	{
	170	struct slot *slot = hotplug_slot->private;
1da177e4	171
6dae6202 BH	172	pciehp_get_attention_status(slot, value);
6dae6202 BH	173	return 0;
1da177e4 LT	174	}
	175
	176	static int get_latch_status(struct hotplug_slot hotplug_slot, u8 value)
	177	{
	178	struct slot *slot = hotplug_slot->private;
1da177e4	179
6dae6202 BH	180	pciehp_get_latch_status(slot, value);
6dae6202 BH	181	return 0;
1da177e4 LT	182	}
	183
	184	static int get_adapter_status(struct hotplug_slot hotplug_slot, u8 value)
	185	{
	186	struct slot *slot = hotplug_slot->private;
1da177e4	187
6dae6202 BH	188	pciehp_get_adapter_status(slot, value);
6dae6202 BH	189	return 0;
1da177e4 LT	190	}
1da177e4 LT	191
2e35afae AW	192	static int reset_slot(struct hotplug_slot *hotplug_slot, int probe)
	193	{
	194	struct slot *slot = hotplug_slot->private;
	195
2e35afae AW	196	return pciehp_reset_slot(slot, probe);
	197	}
	198
0516c8bc	199	static int pciehp_probe(struct pcie_device *dev)
1da177e4 LT	200	{
	201	int rc;
	202	struct controller *ctrl;
8720d27d	203	struct slot *slot;
8792e11f	204	u8 occupied, poweron;
125c39f7	205
e705c295 RW	206	/* If this is not a "hotplug" service, we have no business here. */
	207	if (dev->service != PCIE_PORT_SERVICE_HP)
	208	return -ENODEV;
a073a826	209
62e4492c AN	210	if (!dev->port->subordinate) {
	211	/* Can happen if we run out of bus numbers during probe */
	212	dev_err(&dev->device,
	213	"Hotplug bridge without secondary bus, ignoring\n");
2af31f41	214	return -ENODEV;
62e4492c AN	215	}
62e4492c AN	216
c4635eb0	217	ctrl = pcie_init(dev);
1da177e4	218	if (!ctrl) {
18b341b7	219	dev_err(&dev->device, "Controller initialization failed\n");
2af31f41	220	return -ENODEV;
1da177e4	221	}
b9708940	222	set_service_data(dev, ctrl);
1da177e4	223
1da177e4	224	/* Setup the slot information structures */
8720d27d	225	rc = init_slot(ctrl);
1da177e4	226	if (rc) {
f46753c5	227	if (rc == -EBUSY)
227f0647	228	ctrl_warn(ctrl, "Slot already registered by another hotplug driver\n");
f46753c5	229	else
3784e0c6	230	ctrl_err(ctrl, "Slot initialization failed (%d)\n", rc);
a8c2b635	231	goto err_out_release_ctlr;
1da177e4 LT	232	}
1da177e4 LT	233
dbc7e1e5 EB	234	/* Enable events after we have setup the data structures */
	235	rc = pcie_init_notification(ctrl);
	236	if (rc) {
3784e0c6	237	ctrl_err(ctrl, "Notification initialization failed (%d)\n", rc);
65b947bc	238	goto err_out_free_ctrl_slot;
dbc7e1e5 EB	239	}
dbc7e1e5 EB	240
db9aaf0b	241	/* Check if slot is occupied */
8720d27d	242	slot = ctrl->slot;
8792e11f KK	243	pciehp_get_adapter_status(slot, &occupied);
8792e11f KK	244	pciehp_get_power_status(slot, &poweron);
50b52fde RJ	245	if (occupied && pciehp_force) {
50b52fde RJ	246	mutex_lock(&slot->hotplug_lock);
8792e11f	247	pciehp_enable_slot(slot);
50b52fde RJ	248	mutex_unlock(&slot->hotplug_lock);
50b52fde RJ	249	}
8792e11f KK	250	/* If empty slot's power status is on, turn power off */
	251	if (!occupied && poweron && POWER_CTRL(ctrl))
	252	pciehp_power_off_slot(slot);
1da177e4	253
1da177e4 LT	254	return 0;
	255
	256	err_out_free_ctrl_slot:
8720d27d	257	cleanup_slot(ctrl);
a8c2b635	258	err_out_release_ctlr:
82a9e79e	259	pciehp_release_ctrl(ctrl);
1da177e4 LT	260	return -ENODEV;
	261	}
	262
82a9e79e	263	static void pciehp_remove(struct pcie_device *dev)
1da177e4	264	{
b9708940	265	struct controller *ctrl = get_service_data(dev);
1da177e4	266
8720d27d	267	cleanup_slot(ctrl);
82a9e79e	268	pciehp_release_ctrl(ctrl);
1da177e4 LT	269	}
	270
	271	#ifdef CONFIG_PM
3c78bc61	272	static int pciehp_suspend(struct pcie_device *dev)
1da177e4	273	{
1da177e4 LT	274	return 0;
	275	}
	276
3c78bc61	277	static int pciehp_resume(struct pcie_device *dev)
1da177e4	278	{
87683e22 ON	279	struct controller *ctrl;
	280	struct slot *slot;
	281	u8 status;
	282
87683e22	283	ctrl = get_service_data(dev);
cd2fe83a	284
87683e22	285	/* reinitialize the chipset's event detection logic */
13c65840	286	pcie_reenable_notification(ctrl);
cd2fe83a	287
87683e22	288	slot = ctrl->slot;
cd2fe83a	289
87683e22 ON	290	/* Check if slot is occupied */
87683e22 ON	291	pciehp_get_adapter_status(slot, &status);
50b52fde	292	mutex_lock(&slot->hotplug_lock);
87683e22 ON	293	if (status)
	294	pciehp_enable_slot(slot);
	295	else
	296	pciehp_disable_slot(slot);
50b52fde	297	mutex_unlock(&slot->hotplug_lock);
1da177e4 LT	298	return 0;
1da177e4 LT	299	}
3a3c244c	300	#endif /* PM */
1da177e4	301
1da177e4	302	static struct pcie_port_service_driver hpdriver_portdrv = {
83e9ad54	303	.name = PCIE_MODULE_NAME,
22106368 RW	304	.port_type = PCIE_ANY_PORT,
22106368 RW	305	.service = PCIE_PORT_SERVICE_HP,
1da177e4 LT	306
	307	.probe = pciehp_probe,
	308	.remove = pciehp_remove,
	309
	310	#ifdef CONFIG_PM
	311	.suspend = pciehp_suspend,
	312	.resume = pciehp_resume,
	313	#endif /* PM */
	314	};
	315
	316	static int __init pcied_init(void)
	317	{
	318	int retval = 0;
	319
a8a2be94	320	retval = pcie_port_service_register(&hpdriver_portdrv);
f7625980	321	dbg("pcie_port_service_register = %d\n", retval);
c2be6f93	322	if (retval)
18b341b7	323	dbg("Failure to register service\n");
c2be6f93	324
1da177e4 LT	325	return retval;
1da177e4 LT	326	}
70626d88	327	device_initcall(pcied_init);