Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 52a0f24b authored by Kenji Kaneshige's avatar Kenji Kaneshige Committed by Jesse Barnes
Browse files

PCI: portdrv: cleanup pcie_device registration 



In the current port bus driver implementation, pcie_device allocation,
initialization and registration are done in separated functions. Doing
those in one function make the code simple and easier to read.

Signed-off-by: default avatarKenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
Signed-off-by: default avatarJesse Barnes <jbarnes@virtuousgeek.org>
parent 898294c9

drivers/pci/pcie/portdrv_core.c

+26 −51
Original line number Diff line number Diff line
@@ -246,54 +246,39 @@ static int get_port_device_capability(struct pci_dev *dev) 
}



/**

 * pcie_device_init - initialize PCI Express port service device

 * @dev: Port service device to initialize

 * @parent: PCI Express port to associate the service device with

 * @port_type: Type of the port

 * @service_type: Type of service to associate with the service device

 * pcie_device_init - allocate and initialize PCI Express port service device

 * @pdev: PCI Express port to associate the service device with

 * @service: Type of service to associate with the service device

 * @irq: Interrupt vector to associate with the service device

 */

static void pcie_device_init(struct pci_dev *parent, struct pcie_device *dev, 

	int service_type, int irq)

static int pcie_device_init(struct pci_dev *pdev, int service, int irq)

{

	struct pcie_port_data *port_data = pci_get_drvdata(parent);

	int retval;

	struct pcie_device *pcie;

	struct device *device;

	int port_type = port_data->port_type;



	dev->port = parent;

	dev->irq = irq;

	dev->service = service_type;

	pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);

	if (!pcie)

		return -ENOMEM;

	pcie->port = pdev;

	pcie->irq = irq;

	pcie->service = service;



	/* Initialize generic device interface */

	device = &dev->device;

	memset(device, 0, sizeof(struct device));

	device = &pcie->device;

	device->bus = &pcie_port_bus_type;

	device->driver = NULL;

	dev_set_drvdata(device, NULL);

	device->release = release_pcie_device;	/* callback to free pcie dev */

	dev_set_name(device, "%s:pcie%02x",

		 pci_name(parent), get_descriptor_id(port_type, service_type));

	device->parent = &parent->dev;

}



/**

 * alloc_pcie_device - allocate PCI Express port service device structure

 * @parent: PCI Express port to associate the service device with

 * @port_type: Type of the port

 * @service_type: Type of service to associate with the service device

 * @irq: Interrupt vector to associate with the service device

 */

static struct pcie_device* alloc_pcie_device(struct pci_dev *parent,

	int service_type, int irq)

{

	struct pcie_device *device;

		     pci_name(pdev),

		     get_descriptor_id(pdev->pcie_type, service));

	device->parent = &pdev->dev;



	device = kzalloc(sizeof(struct pcie_device), GFP_KERNEL);

	if (!device)

		return NULL;



	pcie_device_init(parent, device, service_type, irq);

	return device;

	retval = device_register(device);

	if (retval)

		kfree(pcie);

	else

		get_device(device);

	return retval;

}



/**
@@ -346,23 +331,13 @@ int pcie_port_device_register(struct pci_dev *dev) 


	/* Allocate child services if any */

	for (i = 0, nr_serv = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {

		struct pcie_device *child;

		int service = 1 << i;



		if (!(capabilities & service))

			continue;



		child = alloc_pcie_device(dev, service, vectors[i]);

		if (!child)

			continue;



		status = device_register(&child->device);

		if (status) {

			kfree(child);

			continue;

		}



		get_device(&child->device);

		status = pcie_device_init(dev, service, vectors[i]);

		if (!status)

			nr_serv++;

	}

	if (!nr_serv) {