/* * PCI Hotplug Driver for PowerPC PowerNV platform. * * Copyright Gavin Shan, IBM Corporation 2016. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. */ #include <linux/libfdt.h>#include <linux/module.h>#include <linux/pci.h>#include <linux/pci_hotplug.h> #include <asm/opal.h>#include <asm/pnv-pci.h>#include <asm/ppc-pci.h> #define DRIVER_VERSION	"0.1"#define DRIVER_AUTHOR	"Gavin Shan, IBM Corporation"#define DRIVER_DESC	"PowerPC PowerNV PCI Hotplug Driver" struct pnv_php_event {	bool			added;	struct pnv_php_slot	*php_slot;	struct work_struct	work;}; static LIST_HEAD(pnv_php_slot_list);static DEFINE_SPINLOCK(pnv_php_lock); static void pnv_php_register(struct device_node *dn);static void pnv_php_unregister_one(struct device_node *dn);static void pnv_php_unregister(struct device_node *dn); static void pnv_php_disable_irq(struct pnv_php_slot *php_slot,				bool disable_device){	struct pci_dev *pdev = php_slot->pdev;	int irq = php_slot->irq;	u16 ctrl; 	if (php_slot->irq > 0) {		pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl);		ctrl &= ~(PCI_EXP_SLTCTL_HPIE |			  PCI_EXP_SLTCTL_PDCE |			  PCI_EXP_SLTCTL_DLLSCE);		pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl); 		free_irq(php_slot->irq, php_slot);		php_slot->irq = 0;	} 	if (php_slot->wq) {		destroy_workqueue(php_slot->wq);		php_slot->wq = NULL;	} 	if (disable_device || irq > 0) {		if (pdev->msix_enabled)			pci_disable_msix(pdev);		else if (pdev->msi_enabled)			pci_disable_msi(pdev); 		pci_disable_device(pdev);	}} static void pnv_php_free_slot(struct kref *kref){	struct pnv_php_slot *php_slot = container_of(kref,					struct pnv_php_slot, kref); 	WARN_ON(!list_empty(&php_slot->children));	pnv_php_disable_irq(php_slot, false);	kfree(php_slot->name);	kfree(php_slot);} static inline void pnv_php_put_slot(struct pnv_php_slot *php_slot){ 	if (!php_slot)		return; 	kref_put(&php_slot->kref, pnv_php_free_slot);} static struct pnv_php_slot *pnv_php_match(struct device_node *dn,					  struct pnv_php_slot *php_slot){	struct pnv_php_slot *target, *tmp; 	if (php_slot->dn == dn) {		kref_get(&php_slot->kref);		return php_slot;	} 	list_for_each_entry(tmp, &php_slot->children, link) {		target = pnv_php_match(dn, tmp);		if (target)			return target;	} 	return NULL;} struct pnv_php_slot *pnv_php_find_slot(struct device_node *dn){	struct pnv_php_slot *php_slot, *tmp;	unsigned long flags; 	spin_lock_irqsave(&pnv_php_lock, flags);	list_for_each_entry(tmp, &pnv_php_slot_list, link) {		php_slot = pnv_php_match(dn, tmp);		if (php_slot) {			spin_unlock_irqrestore(&pnv_php_lock, flags);			return php_slot;		}	}	spin_unlock_irqrestore(&pnv_php_lock, flags); 	return NULL;}EXPORT_SYMBOL_GPL(pnv_php_find_slot); /* * Remove pdn for all children of the indicated device node. * The function should remove pdn in a depth-first manner. */static void pnv_php_rmv_pdns(struct device_node *dn){	struct device_node *child; 	for_each_child_of_node(dn, child) {		pnv_php_rmv_pdns(child); 		pci_remove_device_node_info(child);	}} /* * Detach all child nodes of the indicated device nodes. The * function should handle device nodes in depth-first manner. * * We should not invoke of_node_release() as the memory for * individual device node is part of large memory block. The * large block is allocated from memblock (system bootup) or * kmalloc() when unflattening the device tree by OF changeset. * We can not free the large block allocated from memblock. For * later case, it should be released at once. */static void pnv_php_detach_device_nodes(struct device_node *parent){	struct device_node *dn;	int refcount; 	for_each_child_of_node(parent, dn) {		pnv_php_detach_device_nodes(dn); 		of_node_put(dn);		refcount = kref_read(&dn->kobj.kref);		if (refcount != 1)			pr_warn("Invalid refcount %d on <%s>\n",				refcount, of_node_full_name(dn)); 		of_detach_node(dn);	}} static void pnv_php_rmv_devtree(struct pnv_php_slot *php_slot){	pnv_php_rmv_pdns(php_slot->dn); 	/*	 * Decrease the refcount if the device nodes were created	 * through OF changeset before detaching them.	 */	if (php_slot->fdt)		of_changeset_destroy(&php_slot->ocs);	pnv_php_detach_device_nodes(php_slot->dn); 	if (php_slot->fdt) {		kfree(php_slot->dt);		kfree(php_slot->fdt);		php_slot->dt        = NULL;		php_slot->dn->child = NULL;		php_slot->fdt       = NULL;	}} /* * As the nodes in OF changeset are applied in reverse order, we * need revert the nodes in advance so that we have correct node * order after the changeset is applied. */static void pnv_php_reverse_nodes(struct device_node *parent){	struct device_node *child, *next; 	/* In-depth first */	for_each_child_of_node(parent, child)		pnv_php_reverse_nodes(child); 	/* Reverse the nodes in the child list */	child = parent->child;	parent->child = NULL;	while (child) {		next = child->sibling; 		child->sibling = parent->child;		parent->child = child;		child = next;	}} static int pnv_php_populate_changeset(struct of_changeset *ocs,				      struct device_node *dn){	struct device_node *child;	int ret = 0; 	for_each_child_of_node(dn, child) {		ret = of_changeset_attach_node(ocs, child);		if (ret)			break; 		ret = pnv_php_populate_changeset(ocs, child);		if (ret)			break;	} 	return ret;} static void *pnv_php_add_one_pdn(struct device_node *dn, void *data){	struct pci_controller *hose = (struct pci_controller *)data;	struct pci_dn *pdn; 	pdn = pci_add_device_node_info(hose, dn);	if (!pdn)		return ERR_PTR(-ENOMEM); 	return NULL;} static void pnv_php_add_pdns(struct pnv_php_slot *slot){	struct pci_controller *hose = pci_bus_to_host(slot->bus); 	pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose);} static int pnv_php_add_devtree(struct pnv_php_slot *php_slot){	void *fdt, *fdt1, *dt;	int ret; 	/* We don't know the FDT blob size. We try to get it through	 * maximal memory chunk and then copy it to another chunk that	 * fits the real size.	 */	fdt1 = kzalloc(0x10000, GFP_KERNEL);	if (!fdt1) {		ret = -ENOMEM;		dev_warn(&php_slot->pdev->dev, "Cannot alloc FDT blob\n");		goto out;	} 	ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000);	if (ret) {		dev_warn(&php_slot->pdev->dev, "Error %d getting FDT blob\n",			 ret);		goto free_fdt1;	} 	fdt = kzalloc(fdt_totalsize(fdt1), GFP_KERNEL);	if (!fdt) {		ret = -ENOMEM;		dev_warn(&php_slot->pdev->dev, "Cannot %d bytes memory\n",			 fdt_totalsize(fdt1));		goto free_fdt1;	} 	/* Unflatten device tree blob */	memcpy(fdt, fdt1, fdt_totalsize(fdt1));	dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL);	if (!dt) {		ret = -EINVAL;		dev_warn(&php_slot->pdev->dev, "Cannot unflatten FDT\n");		goto free_fdt;	} 	/* Initialize and apply the changeset */	of_changeset_init(&php_slot->ocs);	pnv_php_reverse_nodes(php_slot->dn);	ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn);	if (ret) {		pnv_php_reverse_nodes(php_slot->dn);		dev_warn(&php_slot->pdev->dev, "Error %d populating changeset\n",			 ret);		goto free_dt;	} 	php_slot->dn->child = NULL;	ret = of_changeset_apply(&php_slot->ocs);	if (ret) {		dev_warn(&php_slot->pdev->dev, "Error %d applying changeset\n",			 ret);		goto destroy_changeset;	} 	/* Add device node firmware data */	pnv_php_add_pdns(php_slot);	php_slot->fdt = fdt;	php_slot->dt  = dt;	kfree(fdt1);	goto out; destroy_changeset:	of_changeset_destroy(&php_slot->ocs);free_dt:	kfree(dt);	php_slot->dn->child = NULL;free_fdt:	kfree(fdt);free_fdt1:	kfree(fdt1);out:	return ret;} int pnv_php_set_slot_power_state(struct hotplug_slot *slot,				 uint8_t state){	struct pnv_php_slot *php_slot = slot->private;	struct opal_msg msg;	int ret; 	ret = pnv_pci_set_power_state(php_slot->id, state, &msg);	if (ret > 0) {		if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle	||		    be64_to_cpu(msg.params[2]) != state			||		    be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) {			dev_warn(&php_slot->pdev->dev, "Wrong msg (%lld, %lld, %lld)\n",				 be64_to_cpu(msg.params[1]),				 be64_to_cpu(msg.params[2]),				 be64_to_cpu(msg.params[3]));			return -ENOMSG;		}	} else if (ret < 0) {		dev_warn(&php_slot->pdev->dev, "Error %d powering %s\n",			 ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off");		return ret;	} 	if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE)		pnv_php_rmv_devtree(php_slot);	else		ret = pnv_php_add_devtree(php_slot); 	return ret;}EXPORT_SYMBOL_GPL(pnv_php_set_slot_power_state); static int pnv_php_get_power_state(struct hotplug_slot *slot, u8 *state){	struct pnv_php_slot *php_slot = slot->private;	uint8_t power_state = OPAL_PCI_SLOT_POWER_ON;	int ret; 	/*	 * Retrieve power status from firmware. If we fail	 * getting that, the power status fails back to	 * be on.	 */	ret = pnv_pci_get_power_state(php_slot->id, &power_state);	if (ret) {		dev_warn(&php_slot->pdev->dev, "Error %d getting power status\n",			 ret);	} else {		*state = power_state;		slot->info->power_status = power_state;	} 	return 0;} static int pnv_php_get_adapter_state(struct hotplug_slot *slot, u8 *state){	struct pnv_php_slot *php_slot = slot->private;	uint8_t presence = OPAL_PCI_SLOT_EMPTY;	int ret; 	/*	 * Retrieve presence status from firmware. If we can't	 * get that, it will fail back to be empty.	 */	ret = pnv_pci_get_presence_state(php_slot->id, &presence);	if (ret >= 0) {		*state = presence;		slot->info->adapter_status = presence;		ret = 0;	} else {		dev_warn(&php_slot->pdev->dev, "Error %d getting presence\n",			 ret);	} 	return ret;} static int pnv_php_set_attention_state(struct hotplug_slot *slot, u8 state){	/* FIXME: Make it real once firmware supports it */	slot->info->attention_status = state; 	return 0;} static int pnv_php_enable(struct pnv_php_slot *php_slot, bool rescan){	struct hotplug_slot *slot = &php_slot->slot;	uint8_t presence = OPAL_PCI_SLOT_EMPTY;	uint8_t power_status = OPAL_PCI_SLOT_POWER_ON;	int ret; 	/* Check if the slot has been configured */	if (php_slot->state != PNV_PHP_STATE_REGISTERED)		return 0; 	/* Retrieve slot presence status */	ret = pnv_php_get_adapter_state(slot, &presence);	if (ret)		return ret; 	/*	 * Proceed if there have nothing behind the slot. However,	 * we should leave the slot in registered state at the	 * beginning. Otherwise, the PCI devices inserted afterwards	 * won't be probed and populated.	 */	if (presence == OPAL_PCI_SLOT_EMPTY) {		if (!php_slot->power_state_check) {			php_slot->power_state_check = true; 			return 0;		} 		goto scan;	} 	/*	 * If the power supply to the slot is off, we can't detect	 * adapter presence state. That means we have to turn the	 * slot on before going to probe slot's presence state.	 *	 * On the first time, we don't change the power status to	 * boost system boot with assumption that the firmware	 * supplies consistent slot power status: empty slot always	 * has its power off and non-empty slot has its power on.	 */	if (!php_slot->power_state_check) {		php_slot->power_state_check = true; 		ret = pnv_php_get_power_state(slot, &power_status);		if (ret)			return ret; 		if (power_status != OPAL_PCI_SLOT_POWER_ON)			return 0;	} 	/* Check the power status. Scan the slot if it is already on */	ret = pnv_php_get_power_state(slot, &power_status);	if (ret)		return ret; 	if (power_status == OPAL_PCI_SLOT_POWER_ON)		goto scan; 	/* Power is off, turn it on and then scan the slot */	ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_ON);	if (ret)		return ret; scan:	if (presence == OPAL_PCI_SLOT_PRESENT) {		if (rescan) {			pci_lock_rescan_remove();			pci_hp_add_devices(php_slot->bus);			pci_unlock_rescan_remove();		} 		/* Rescan for child hotpluggable slots */		php_slot->state = PNV_PHP_STATE_POPULATED;		if (rescan)			pnv_php_register(php_slot->dn);

Lines 1–500 of 973. Load more