Commit a92336a1 authored by Konrad Rzeszutek Wilk's avatar Konrad Rzeszutek Wilk
Browse files

xen/pciback: Drop two backends, squash and cleanup some code. 



 - Remove the slot and controller controller backend as they
   are not used.
 - Document the find pciback_[read|write]_config_[byte|word|dword]
   to make it easier to find.
 - Collapse the code from conf_space_capability_msi into pciback_ops.c
 - Collapse conf_space_capability_[pm|vpd].c in conf_space_capability.c
   [and remove the conf_space_capability.h file]
 - Rename all visible functions from pciback to xen_pcibk.
 - Rename all the printk/pr_info, etc that use the "pciback" to say
   "xen-pciback".
 - Convert functions that are not referenced outside the code to be
   static to save on name space.
 - Do the same thing for structures that are internal to the driver.
 - Run checkpatch.pl after the renames and fixup its warnings and
   fix any compile errors caused by the variable rename
 - Cleanup any structs that checkpath.pl commented about or just
   look odd.

Signed-off-by: default avatarKonrad Rzeszutek Wilk <konrad.wilk@oracle.com>
parent c288b67b

drivers/xen/xen-pciback/Makefile

+0 −5
Original line number Diff line number Diff line
@@ -3,14 +3,9 @@ obj-$(CONFIG_XEN_PCIDEV_BACKEND) += xen-pciback.o 
xen-pciback-y := pci_stub.o pciback_ops.o xenbus.o

xen-pciback-y += conf_space.o conf_space_header.o \

		 conf_space_capability.o \

		 conf_space_capability_vpd.o \

		 conf_space_capability_pm.o \

		 conf_space_quirks.o

xen-pciback-$(CONFIG_PCI_MSI) += conf_space_capability_msi.o

xen-pciback-$(CONFIG_XEN_PCIDEV_BACKEND_VPCI) += vpci.o

xen-pciback-$(CONFIG_XEN_PCIDEV_BACKEND_SLOT) += slot.o

xen-pciback-$(CONFIG_XEN_PCIDEV_BACKEND_PASS) += passthrough.o

xen-pciback-$(CONFIG_XEN_PCIDEV_BACKEND_CONTROLLER) += controller.o



ifeq ($(CONFIG_XEN_PCIDEV_BE_DEBUG),y)

EXTRA_CFLAGS += -DDEBUG

drivers/xen/xen-pciback/conf_space.c

+29 −26
Original line number Diff line number Diff line
@@ -15,11 +15,14 @@ 
#include "conf_space.h"

#include "conf_space_quirks.h"



#define DRV_NAME	"xen-pciback"

static int permissive;

module_param(permissive, bool, 0644);



/* This is where xen_pcibk_read_config_byte, xen_pcibk_read_config_word,

 * xen_pcibk_write_config_word, and xen_pcibk_write_config_byte are created. */

#define DEFINE_PCI_CONFIG(op, size, type)			\

int pciback_##op##_config_##size				\

int xen_pcibk_##op##_config_##size				\

(struct pci_dev *dev, int offset, type value, void *data)	\

{								\

	return pci_##op##_config_##size(dev, offset, value);	\
@@ -138,11 +141,11 @@ static int pcibios_err_to_errno(int err) 
	return err;

}



int pciback_config_read(struct pci_dev *dev, int offset, int size,

int xen_pcibk_config_read(struct pci_dev *dev, int offset, int size,

			  u32 *ret_val)

{

	int err = 0;

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	const struct config_field_entry *cfg_entry;

	const struct config_field *field;

	int req_start, req_end, field_start, field_end;
@@ -151,7 +154,7 @@ int pciback_config_read(struct pci_dev *dev, int offset, int size, 
	u32 value = 0, tmp_val;



	if (unlikely(verbose_request))

		printk(KERN_DEBUG "pciback: %s: read %d bytes at 0x%x\n",

		printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x\n",

		       pci_name(dev), size, offset);



	if (!valid_request(offset, size)) {
@@ -195,17 +198,17 @@ int pciback_config_read(struct pci_dev *dev, int offset, int size, 


out:

	if (unlikely(verbose_request))

		printk(KERN_DEBUG "pciback: %s: read %d bytes at 0x%x = %x\n",

		printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x = %x\n",

		       pci_name(dev), size, offset, value);



	*ret_val = value;

	return pcibios_err_to_errno(err);

}



int pciback_config_write(struct pci_dev *dev, int offset, int size, u32 value)

int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value)

{

	int err = 0, handled = 0;

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	const struct config_field_entry *cfg_entry;

	const struct config_field *field;

	u32 tmp_val;
@@ -213,7 +216,7 @@ int pciback_config_write(struct pci_dev *dev, int offset, int size, u32 value) 


	if (unlikely(verbose_request))

		printk(KERN_DEBUG

		       "pciback: %s: write request %d bytes at 0x%x = %x\n",

		       DRV_NAME ": %s: write request %d bytes at 0x%x = %x\n",

		       pci_name(dev), size, offset, value);



	if (!valid_request(offset, size))
@@ -231,7 +234,7 @@ int pciback_config_write(struct pci_dev *dev, int offset, int size, u32 value) 
		    || (req_end > field_start && req_end <= field_end)) {

			tmp_val = 0;



			err = pciback_config_read(dev, field_start,

			err = xen_pcibk_config_read(dev, field_start,

						  field->size, &tmp_val);

			if (err)

				break;
@@ -290,9 +293,9 @@ int pciback_config_write(struct pci_dev *dev, int offset, int size, u32 value) 
	return pcibios_err_to_errno(err);

}



void pciback_config_free_dyn_fields(struct pci_dev *dev)

void xen_pcibk_config_free_dyn_fields(struct pci_dev *dev)

{

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	struct config_field_entry *cfg_entry, *t;

	const struct config_field *field;
@@ -316,9 +319,9 @@ void pciback_config_free_dyn_fields(struct pci_dev *dev) 
	}

}



void pciback_config_reset_dev(struct pci_dev *dev)

void xen_pcibk_config_reset_dev(struct pci_dev *dev)

{

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	const struct config_field_entry *cfg_entry;

	const struct config_field *field;
@@ -334,9 +337,9 @@ void pciback_config_reset_dev(struct pci_dev *dev) 
	}

}



void pciback_config_free_dev(struct pci_dev *dev)

void xen_pcibk_config_free_dev(struct pci_dev *dev)

{

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	struct config_field_entry *cfg_entry, *t;

	const struct config_field *field;
@@ -356,12 +359,12 @@ void pciback_config_free_dev(struct pci_dev *dev) 
	}

}



int pciback_config_add_field_offset(struct pci_dev *dev,

int xen_pcibk_config_add_field_offset(struct pci_dev *dev,

				    const struct config_field *field,

				    unsigned int base_offset)

{

	int err = 0;

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);

	struct config_field_entry *cfg_entry;

	void *tmp;
@@ -376,7 +379,7 @@ int pciback_config_add_field_offset(struct pci_dev *dev, 
	cfg_entry->base_offset = base_offset;



	/* silently ignore duplicate fields */

	err = pciback_field_is_dup(dev, OFFSET(cfg_entry));

	err = xen_pcibk_field_is_dup(dev, OFFSET(cfg_entry));

	if (err)

		goto out;
@@ -406,30 +409,30 @@ out: 
 * certain registers (like the base address registers (BARs) so that we can

 * keep the client from manipulating them directly.

 */

int pciback_config_init_dev(struct pci_dev *dev)

int xen_pcibk_config_init_dev(struct pci_dev *dev)

{

	int err = 0;

	struct pciback_dev_data *dev_data = pci_get_drvdata(dev);

	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);



	dev_dbg(&dev->dev, "initializing virtual configuration space\n");



	INIT_LIST_HEAD(&dev_data->config_fields);



	err = pciback_config_header_add_fields(dev);

	err = xen_pcibk_config_header_add_fields(dev);

	if (err)

		goto out;



	err = pciback_config_capability_add_fields(dev);

	err = xen_pcibk_config_capability_add_fields(dev);

	if (err)

		goto out;



	err = pciback_config_quirks_init(dev);

	err = xen_pcibk_config_quirks_init(dev);



out:

	return err;

}



int pciback_config_init(void)

int xen_pcibk_config_init(void)

{

	return pciback_config_capability_init();

	return xen_pcibk_config_capability_init();

}

drivers/xen/xen-pciback/conf_space.h

+21 −21
Original line number Diff line number Diff line
@@ -69,35 +69,35 @@ struct config_field_entry { 
/* Add fields to a device - the add_fields macro expects to get a pointer to

 * the first entry in an array (of which the ending is marked by size==0)

 */

int pciback_config_add_field_offset(struct pci_dev *dev,

int xen_pcibk_config_add_field_offset(struct pci_dev *dev,

				    const struct config_field *field,

				    unsigned int offset);



static inline int pciback_config_add_field(struct pci_dev *dev,

static inline int xen_pcibk_config_add_field(struct pci_dev *dev,

					   const struct config_field *field)

{

	return pciback_config_add_field_offset(dev, field, 0);

	return xen_pcibk_config_add_field_offset(dev, field, 0);

}



static inline int pciback_config_add_fields(struct pci_dev *dev,

static inline int xen_pcibk_config_add_fields(struct pci_dev *dev,

					    const struct config_field *field)

{

	int i, err = 0;

	for (i = 0; field[i].size != 0; i++) {

		err = pciback_config_add_field(dev, &field[i]);

		err = xen_pcibk_config_add_field(dev, &field[i]);

		if (err)

			break;

	}

	return err;

}



static inline int pciback_config_add_fields_offset(struct pci_dev *dev,

static inline int xen_pcibk_config_add_fields_offset(struct pci_dev *dev,

					const struct config_field *field,

					unsigned int offset)

{

	int i, err = 0;

	for (i = 0; field[i].size != 0; i++) {

		err = pciback_config_add_field_offset(dev, &field[i], offset);

		err = xen_pcibk_config_add_field_offset(dev, &field[i], offset);

		if (err)

			break;

	}
@@ -105,22 +105,22 @@ static inline int pciback_config_add_fields_offset(struct pci_dev *dev, 
}



/* Read/Write the real configuration space */

int pciback_read_config_byte(struct pci_dev *dev, int offset, u8 *value,

int xen_pcibk_read_config_byte(struct pci_dev *dev, int offset, u8 *value,

			       void *data);

int pciback_read_config_word(struct pci_dev *dev, int offset, u16 *value,

int xen_pcibk_read_config_word(struct pci_dev *dev, int offset, u16 *value,

			       void *data);

int pciback_read_config_dword(struct pci_dev *dev, int offset, u32 *value,

int xen_pcibk_read_config_dword(struct pci_dev *dev, int offset, u32 *value,

				void *data);

int pciback_write_config_byte(struct pci_dev *dev, int offset, u8 value,

int xen_pcibk_write_config_byte(struct pci_dev *dev, int offset, u8 value,

				 void *data);

int pciback_write_config_word(struct pci_dev *dev, int offset, u16 value,

int xen_pcibk_write_config_word(struct pci_dev *dev, int offset, u16 value,

				void *data);

int pciback_write_config_dword(struct pci_dev *dev, int offset, u32 value,

int xen_pcibk_write_config_dword(struct pci_dev *dev, int offset, u32 value,

				 void *data);



int pciback_config_capability_init(void);

int xen_pcibk_config_capability_init(void);



int pciback_config_header_add_fields(struct pci_dev *dev);

int pciback_config_capability_add_fields(struct pci_dev *dev);

int xen_pcibk_config_header_add_fields(struct pci_dev *dev);

int xen_pcibk_config_capability_add_fields(struct pci_dev *dev);



#endif				/* __XEN_PCIBACK_CONF_SPACE_H__ */

drivers/xen/xen-pciback/conf_space_capability.c

+151 −10
Original line number Diff line number Diff line
@@ -9,29 +9,36 @@ 
#include <linux/pci.h>

#include "pciback.h"

#include "conf_space.h"

#include "conf_space_capability.h"



static LIST_HEAD(capabilities);

struct xen_pcibk_config_capability {

	struct list_head cap_list;



	int capability;



	/* If the device has the capability found above, add these fields */

	const struct config_field *fields;

};



static const struct config_field caplist_header[] = {

	{

	 .offset    = PCI_CAP_LIST_ID,

	 .size      = 2, /* encompass PCI_CAP_LIST_ID & PCI_CAP_LIST_NEXT */

	 .u.w.read  = pciback_read_config_word,

	 .u.w.read  = xen_pcibk_read_config_word,

	 .u.w.write = NULL,

	},

	{}

};



static inline void register_capability(struct pciback_config_capability *cap)

static inline void register_capability(struct xen_pcibk_config_capability *cap)

{

	list_add_tail(&cap->cap_list, &capabilities);

}



int pciback_config_capability_add_fields(struct pci_dev *dev)

int xen_pcibk_config_capability_add_fields(struct pci_dev *dev)

{

	int err = 0;

	struct pciback_config_capability *cap;

	struct xen_pcibk_config_capability *cap;

	int cap_offset;



	list_for_each_entry(cap, &capabilities, cap_list) {
@@ -40,12 +47,12 @@ int pciback_config_capability_add_fields(struct pci_dev *dev) 
			dev_dbg(&dev->dev, "Found capability 0x%x at 0x%x\n",

				cap->capability, cap_offset);



			err = pciback_config_add_fields_offset(dev,

			err = xen_pcibk_config_add_fields_offset(dev,

							       caplist_header,

							       cap_offset);

			if (err)

				goto out;

			err = pciback_config_add_fields_offset(dev,

			err = xen_pcibk_config_add_fields_offset(dev,

							       cap->fields,

							       cap_offset);

			if (err)
@@ -57,10 +64,144 @@ out: 
	return err;

}



int pciback_config_capability_init(void)

static int vpd_address_write(struct pci_dev *dev, int offset, u16 value,

			     void *data)

{

	/* Disallow writes to the vital product data */

	if (value & PCI_VPD_ADDR_F)

		return PCIBIOS_SET_FAILED;

	else

		return pci_write_config_word(dev, offset, value);

}



static const struct config_field caplist_vpd[] = {

	{

	 .offset    = PCI_VPD_ADDR,

	 .size      = 2,

	 .u.w.read  = xen_pcibk_read_config_word,

	 .u.w.write = vpd_address_write,

	 },

	{

	 .offset     = PCI_VPD_DATA,

	 .size       = 4,

	 .u.dw.read  = xen_pcibk_read_config_dword,

	 .u.dw.write = NULL,

	 },

	{}

};



static int pm_caps_read(struct pci_dev *dev, int offset, u16 *value,

			void *data)

{

	int err;

	u16 real_value;



	err = pci_read_config_word(dev, offset, &real_value);

	if (err)

		goto out;



	*value = real_value & ~PCI_PM_CAP_PME_MASK;



out:

	return err;

}



/* PM_OK_BITS specifies the bits that the driver domain is allowed to change.

 * Can't allow driver domain to enable PMEs - they're shared */

#define PM_OK_BITS (PCI_PM_CTRL_PME_STATUS|PCI_PM_CTRL_DATA_SEL_MASK)



static int pm_ctrl_write(struct pci_dev *dev, int offset, u16 new_value,

			 void *data)

{

	int err;

	u16 old_value;

	pci_power_t new_state, old_state;



	err = pci_read_config_word(dev, offset, &old_value);

	if (err)

		goto out;



	old_state = (pci_power_t)(old_value & PCI_PM_CTRL_STATE_MASK);

	new_state = (pci_power_t)(new_value & PCI_PM_CTRL_STATE_MASK);



	new_value &= PM_OK_BITS;

	if ((old_value & PM_OK_BITS) != new_value) {

		new_value = (old_value & ~PM_OK_BITS) | new_value;

		err = pci_write_config_word(dev, offset, new_value);

		if (err)

			goto out;

	}



	/* Let pci core handle the power management change */

	dev_dbg(&dev->dev, "set power state to %x\n", new_state);

	err = pci_set_power_state(dev, new_state);

	if (err) {

		err = PCIBIOS_SET_FAILED;

		goto out;

	}



 out:

	return err;

}



/* Ensure PMEs are disabled */

static void *pm_ctrl_init(struct pci_dev *dev, int offset)

{

	int err;

	u16 value;



	err = pci_read_config_word(dev, offset, &value);

	if (err)

		goto out;



	if (value & PCI_PM_CTRL_PME_ENABLE) {

		value &= ~PCI_PM_CTRL_PME_ENABLE;

		err = pci_write_config_word(dev, offset, value);

	}



out:

	return ERR_PTR(err);

}



static const struct config_field caplist_pm[] = {

	{

		.offset     = PCI_PM_PMC,

		.size       = 2,

		.u.w.read   = pm_caps_read,

	},

	{

		.offset     = PCI_PM_CTRL,

		.size       = 2,

		.init       = pm_ctrl_init,

		.u.w.read   = xen_pcibk_read_config_word,

		.u.w.write  = pm_ctrl_write,

	},

	{

		.offset     = PCI_PM_PPB_EXTENSIONS,

		.size       = 1,

		.u.b.read   = xen_pcibk_read_config_byte,

	},

	{

		.offset     = PCI_PM_DATA_REGISTER,

		.size       = 1,

		.u.b.read   = xen_pcibk_read_config_byte,

	},

	{}

};



static struct xen_pcibk_config_capability xen_pcibk_config_capability_pm = {

	.capability = PCI_CAP_ID_PM,

	.fields = caplist_pm,

};

static struct xen_pcibk_config_capability xen_pcibk_config_capability_vpd = {

	.capability = PCI_CAP_ID_VPD,

	.fields = caplist_vpd,

};



int xen_pcibk_config_capability_init(void)

{

	register_capability(&pciback_config_capability_vpd);

	register_capability(&pciback_config_capability_pm);

	register_capability(&xen_pcibk_config_capability_vpd);

	register_capability(&xen_pcibk_config_capability_pm);



	return 0;

}

drivers/xen/xen-pciback/conf_space_capability.h

deleted100644 → 0
+0 −26
Original line number Diff line number Diff line 
/*

 * PCI Backend - Data structures for special overlays for structures on

 *               the capability list.

 *

 * Author: Ryan Wilson <hap9@epoch.ncsc.mil>

 */



#ifndef __PCIBACK_CONFIG_CAPABILITY_H__

#define __PCIBACK_CONFIG_CAPABILITY_H__



#include <linux/pci.h>

#include <linux/list.h>



struct pciback_config_capability {

	struct list_head cap_list;



	int capability;



	/* If the device has the capability found above, add these fields */

	const struct config_field *fields;

};



extern struct pciback_config_capability pciback_config_capability_vpd;

extern struct pciback_config_capability pciback_config_capability_pm;



#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE