return 0;}static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value){	struct slot *slot = hotplug_slot->private;	int retval;	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);		retval = slot->hpc_ops->get_cur_bus_speed(slot, value);	if (retval < 0)		*value = PCI_SPEED_UNKNOWN;	return 0;}static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_id *id){	int rc;	struct controller *ctrl;	struct slot *t_slot;	int first_device_num = 0 ;	/* first PCI device number supported by this PCIE */  	int num_ctlr_slots;		/* number of slots supported by this HPC */	u8 value;	struct pci_dev *pdev;		dbg("%s: Called by hp_drv\n", __FUNCTION__);	ctrl = kmalloc(sizeof(*ctrl), GFP_KERNEL);	if (!ctrl) {		err("%s : out of memory\n", __FUNCTION__);		goto err_out_none;	}	memset(ctrl, 0, sizeof(struct controller));	dbg("%s: DRV_thread pid = %d\n", __FUNCTION__, current->pid);		pdev = dev->port;	rc = pcie_init(ctrl, dev,		(php_intr_callback_t) pciehp_handle_attention_button,		(php_intr_callback_t) pciehp_handle_switch_change,		(php_intr_callback_t) pciehp_handle_presence_change,		(php_intr_callback_t) pciehp_handle_power_fault);	if (rc) {		dbg("%s: controller initialization failed\n", PCIE_MODULE_NAME);		goto err_out_free_ctrl;	}	ctrl->pci_dev = pdev;	pci_set_drvdata(pdev, ctrl);	ctrl->pci_bus = kmalloc(sizeof(*ctrl->pci_bus), GFP_KERNEL);	if (!ctrl->pci_bus) {		err("%s: out of memory\n", __FUNCTION__);		rc = -ENOMEM;		goto err_out_unmap_mmio_region;	}	dbg("%s: ctrl->pci_bus %p\n", __FUNCTION__, ctrl->pci_bus);	memcpy (ctrl->pci_bus, pdev->bus, sizeof (*ctrl->pci_bus));	ctrl->bus = pdev->bus->number;  /* ctrl bus */	ctrl->slot_bus = pdev->subordinate->number;  /* bus controlled by this HPC */	ctrl->device = PCI_SLOT(pdev->devfn);	ctrl->function = PCI_FUNC(pdev->devfn);	dbg("%s: ctrl bus=0x%x, device=%x, function=%x, irq=%x\n", __FUNCTION__,		ctrl->bus, ctrl->device, ctrl->function, pdev->irq);	/*	 *	Save configuration headers for this and subordinate PCI buses	 */	rc = get_ctlr_slot_config(ctrl);	if (rc) {		err(msg_initialization_err, rc);		goto err_out_free_ctrl_bus;	}	first_device_num = ctrl->slot_device_offset;	num_ctlr_slots = ctrl->num_slots; 	/* Store PCI Config Space for all devices on this bus */	dbg("%s: Before calling pciehp_save_config, ctrl->bus %x,ctrl->slot_bus %x\n", 		__FUNCTION__,ctrl->bus, ctrl->slot_bus);	rc = pciehp_save_config(ctrl, ctrl->slot_bus, num_ctlr_slots, first_device_num);	if (rc) {		err("%s: unable to save PCI configuration data, error %d\n", __FUNCTION__, rc);		goto err_out_free_ctrl_bus;	}	/* Get IO, memory, and IRQ resources for new devices */	rc = pciehprm_find_available_resources(ctrl);	ctrl->add_support = !rc;		if (rc) {		dbg("pciehprm_find_available_resources = %#x\n", rc);		err("unable to locate PCI configuration resources for hot plug add.\n");		goto err_out_free_ctrl_bus;	}	/* Setup the slot information structures */	rc = init_slots(ctrl);	if (rc) {		err(msg_initialization_err, 6);		goto err_out_free_ctrl_slot;	}	t_slot = pciehp_find_slot(ctrl, first_device_num);	dbg("%s: t_slot %p\n", __FUNCTION__, t_slot);	/*	Finish setting up the hot plug ctrl device */	ctrl->next_event = 0;	if (!pciehp_ctrl_list) {		pciehp_ctrl_list = ctrl;		ctrl->next = NULL;	} else {		ctrl->next = pciehp_ctrl_list;		pciehp_ctrl_list = ctrl;	}	/* Wait for exclusive access to hardware */	down(&ctrl->crit_sect);	t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */	dbg("%s: adpater value %x\n", __FUNCTION__, value);		if ((POWER_CTRL(ctrl->ctrlcap)) && !value) {		rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/		if (rc) {			/* Done with exclusive hardware access */			up(&ctrl->crit_sect);			goto err_out_free_ctrl_slot;		} else			/* Wait for the command to complete */			wait_for_ctrl_irq (ctrl);	}	/* Done with exclusive hardware access */	up(&ctrl->crit_sect);	return 0;err_out_free_ctrl_slot:	cleanup_slots(ctrl);err_out_free_ctrl_bus:	kfree(ctrl->pci_bus);err_out_unmap_mmio_region:	ctrl->hpc_ops->release_ctlr(ctrl);err_out_free_ctrl:	kfree(ctrl);err_out_none:	return -ENODEV;}static int pcie_start_thread(void){	int loop;	int retval = 0;		dbg("Initialize + Start the notification/polling mechanism \n");	retval = pciehp_event_start_thread();	if (retval) {		dbg("pciehp_event_start_thread() failed\n");		return retval;	}	dbg("Initialize slot lists\n");	/* One slot list for each bus in the system */	for (loop = 0; loop < 256; loop++) {		pciehp_slot_list[loop] = NULL;	}	return retval;}static inline void __exitfree_pciehp_res(struct pci_resource *res){	struct pci_resource *tres;	while (res) {		tres = res;		res = res->next;		kfree(tres);	}}static void __exit unload_pciehpd(void){	struct pci_func *next;	struct pci_func *TempSlot;	int loop;	struct controller *ctrl;	struct controller *tctrl;	ctrl = pciehp_ctrl_list;	while (ctrl) {		cleanup_slots(ctrl);		free_pciehp_res(ctrl->io_head);		free_pciehp_res(ctrl->mem_head);		free_pciehp_res(ctrl->p_mem_head);		free_pciehp_res(ctrl->bus_head);		kfree (ctrl->pci_bus);		ctrl->hpc_ops->release_ctlr(ctrl);		tctrl = ctrl;		ctrl = ctrl->next;		kfree(tctrl);	}	for (loop = 0; loop < 256; loop++) {		next = pciehp_slot_list[loop];		while (next != NULL) {			free_pciehp_res(next->io_head);			free_pciehp_res(next->mem_head);			free_pciehp_res(next->p_mem_head);			free_pciehp_res(next->bus_head);			TempSlot = next;			next = next->next;			kfree(TempSlot);		}	}	/* Stop the notification mechanism */	pciehp_event_stop_thread();}int hpdriver_context = 0;static void pciehp_remove (struct pcie_device *device){	printk("%s ENTRY\n", __FUNCTION__);		printk("%s -> Call free_irq for irq = %d\n",  		__FUNCTION__, device->irq);	free_irq(device->irq, &hpdriver_context);}#ifdef CONFIG_PMstatic int pciehp_suspend (struct pcie_device *dev, u32 state){	printk("%s ENTRY\n", __FUNCTION__);		return 0;}static int pciehp_resume (struct pcie_device *dev){	printk("%s ENTRY\n", __FUNCTION__);		return 0;}#endifstatic struct pcie_port_service_id port_pci_ids[] = { { 	.vendor = PCI_ANY_ID, 	.device = PCI_ANY_ID,	.port_type = PCIE_RC_PORT, 	.service_type = PCIE_PORT_SERVICE_HP,	.driver_data =	0, 	}, { /* end: all zeroes */ }};static const char device_name[] = "hpdriver";static struct pcie_port_service_driver hpdriver_portdrv = {	.name		= (char *)device_name,	.id_table	= &port_pci_ids[0],	.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;#ifdef CONFIG_HOTPLUG_PCI_PCIE_POLL_EVENT_MODE	pciehp_poll_mode = 1;#endif	retval = pcie_start_thread();	if (retval)		goto error_hpc_init;	retval = pciehprm_init(PCI);	if (!retval) { 		retval = pcie_port_service_register(&hpdriver_portdrv); 		dbg("pcie_port_service_register = %d\n", retval);  		info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 		if (retval) 		   dbg("%s: Failure to register service\n", __FUNCTION__);	}error_hpc_init:	if (retval) {		pciehprm_cleanup();		pciehp_event_stop_thread();	} else		pciehprm_print_pirt();	return retval;}static void __exit pcied_cleanup(void){	dbg("unload_pciehpd()\n");	unload_pciehpd();	pciehprm_cleanup();	dbg("pcie_port_service_unregister\n");	pcie_port_service_unregister(&hpdriver_portdrv);	info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");}module_init(pcied_init);module_exit(pcied_cleanup);