pciehp_core.c

优龙2410linux2.6.8内核源代码

}

static int get_max_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_max_bus_speed(slot, value);
	if (retval < 0)
		*value = PCI_SPEED_UNKNOWN;

	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 pcie_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
	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;

	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);

	rc = pcie_init(ctrl, pdev,
		(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 (!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 __exit
free_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();

}


static struct pci_device_id pcied_pci_tbl[] = {
	{
	.class =        ((PCI_CLASS_BRIDGE_PCI << 8) | 0x00),
	.class_mask =	~0,
	.vendor =       PCI_ANY_ID,
	.device =       PCI_ANY_ID,
	.subvendor =    PCI_ANY_ID,
	.subdevice =    PCI_ANY_ID,
	},
	
	{ /* end: all zeroes */ }
};

MODULE_DEVICE_TABLE(pci, pcied_pci_tbl);



static struct pci_driver pcie_driver = {
	.name		=	PCIE_MODULE_NAME,
	.id_table	=	pcied_pci_tbl,
	.probe		=	pcie_probe,
	/* remove:	pcie_remove_one, */
};



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 = pci_module_init(&pcie_driver);
		dbg("pci_module_init = %d\n", retval);
		info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
	}

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("pci_unregister_driver\n");
	pci_unregister_driver(&pcie_driver);

	info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
}

module_init(pcied_init);
module_exit(pcied_cleanup);