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

Commit 6ce54f02 authored by Bjorn Helgaas's avatar Bjorn Helgaas
Browse files

Merge branch 'pci/misc' 

  - Use devm_add_action_or_reset() helper (Fuqian Huang)

  - Mark expected switch fall-through (Gustavo A. R. Silva)

  - Convert sysfs device attributes from __ATTR() to DEVICE_ATTR() (Kelsey
    Skunberg)

  - Convert sysfs file permissions from S_IRUSR etc to octal (Kelsey
    Skunberg)

  - Move SR-IOV sysfs functions to iov.c (Kelsey Skunberg)

  - Add pci_info_ratelimited() to ratelimit PCI messages separately
    (Krzysztof Wilczynski)

  - Fix "'static' not at beginning of declaration" warnings (Krzysztof
    Wilczynski)

  - Clean up resource_alignment parameter to not require static buffer
    (Logan Gunthorpe)

  - Add ACS quirk for iProc PAXB (Abhinav Ratna)

  - Add pci_irq_vector() and other stubs for !CONFIG_PCI (Herbert Xu)

* pci/misc:
  PCI: Add pci_irq_vector() and other stubs when !CONFIG_PCI
  PCI: Add ACS quirk for iProc PAXB
  PCI: Force trailing new line to resource_alignment_param in sysfs
  PCI: Move pci_[get|set]_resource_alignment_param() into their callers
  PCI: Clean up resource_alignment parameter to not require static buffer
  PCI: Use static const struct, not const static struct
  PCI: Add pci_info_ratelimited() to ratelimit PCI separately
  PCI/IOV: Remove group write permission from sriov_numvfs, sriov_drivers_autoprobe
  PCI/IOV: Move sysfs SR-IOV functions to iov.c
  PCI: sysfs: Change permissions from symbolic to octal
  PCI: sysfs: Change DEVICE_ATTR() to DEVICE_ATTR_WO()
  PCI: sysfs: Define device attributes with DEVICE_ATTR*()
  PCI: Mark expected switch fall-through
  PCI: Use devm_add_action_or_reset()
parents a10a1f60 0d8006dd

drivers/pci/controller/pci-host-common.c

+1 −2
Original line number Diff line number Diff line
@@ -43,9 +43,8 @@ static struct pci_config_window *gen_pci_init(struct device *dev, 
		goto err_out;

	}



	err = devm_add_action(dev, gen_pci_unmap_cfg, cfg);

	err = devm_add_action_or_reset(dev, gen_pci_unmap_cfg, cfg);

	if (err) {

		gen_pci_unmap_cfg(cfg);

		goto err_out;

	}

	return cfg;

drivers/pci/hotplug/ibmphp_res.c

+1 −0
Original line number Diff line number Diff line
@@ -1941,6 +1941,7 @@ static int __init update_bridge_ranges(struct bus_node **bus) 
						break;

					case PCI_HEADER_TYPE_BRIDGE:

						function = 0x8;

						/* fall through */

					case PCI_HEADER_TYPE_MULTIBRIDGE:

						/* We assume here that only 1 bus behind the bridge

						   TO DO: add functionality for several:

drivers/pci/iov.c

+167 −0
Original line number Diff line number Diff line
@@ -240,6 +240,173 @@ void pci_iov_remove_virtfn(struct pci_dev *dev, int id) 
	pci_dev_put(dev);

}



static ssize_t sriov_totalvfs_show(struct device *dev,

				   struct device_attribute *attr,

				   char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));

}



static ssize_t sriov_numvfs_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);

}



/*

 * num_vfs > 0; number of VFs to enable

 * num_vfs = 0; disable all VFs

 *

 * Note: SRIOV spec does not allow partial VF

 *	 disable, so it's all or none.

 */

static ssize_t sriov_numvfs_store(struct device *dev,

				  struct device_attribute *attr,

				  const char *buf, size_t count)

{

	struct pci_dev *pdev = to_pci_dev(dev);

	int ret;

	u16 num_vfs;



	ret = kstrtou16(buf, 0, &num_vfs);

	if (ret < 0)

		return ret;



	if (num_vfs > pci_sriov_get_totalvfs(pdev))

		return -ERANGE;



	device_lock(&pdev->dev);



	if (num_vfs == pdev->sriov->num_VFs)

		goto exit;



	/* is PF driver loaded w/callback */

	if (!pdev->driver || !pdev->driver->sriov_configure) {

		pci_info(pdev, "Driver does not support SRIOV configuration via sysfs\n");

		ret = -ENOENT;

		goto exit;

	}



	if (num_vfs == 0) {

		/* disable VFs */

		ret = pdev->driver->sriov_configure(pdev, 0);

		goto exit;

	}



	/* enable VFs */

	if (pdev->sriov->num_VFs) {

		pci_warn(pdev, "%d VFs already enabled. Disable before enabling %d VFs\n",

			 pdev->sriov->num_VFs, num_vfs);

		ret = -EBUSY;

		goto exit;

	}



	ret = pdev->driver->sriov_configure(pdev, num_vfs);

	if (ret < 0)

		goto exit;



	if (ret != num_vfs)

		pci_warn(pdev, "%d VFs requested; only %d enabled\n",

			 num_vfs, ret);



exit:

	device_unlock(&pdev->dev);



	if (ret < 0)

		return ret;



	return count;

}



static ssize_t sriov_offset_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->offset);

}



static ssize_t sriov_stride_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->stride);

}



static ssize_t sriov_vf_device_show(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%x\n", pdev->sriov->vf_device);

}



static ssize_t sriov_drivers_autoprobe_show(struct device *dev,

					    struct device_attribute *attr,

					    char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->drivers_autoprobe);

}



static ssize_t sriov_drivers_autoprobe_store(struct device *dev,

					     struct device_attribute *attr,

					     const char *buf, size_t count)

{

	struct pci_dev *pdev = to_pci_dev(dev);

	bool drivers_autoprobe;



	if (kstrtobool(buf, &drivers_autoprobe) < 0)

		return -EINVAL;



	pdev->sriov->drivers_autoprobe = drivers_autoprobe;



	return count;

}



static DEVICE_ATTR_RO(sriov_totalvfs);

static DEVICE_ATTR_RW(sriov_numvfs);

static DEVICE_ATTR_RO(sriov_offset);

static DEVICE_ATTR_RO(sriov_stride);

static DEVICE_ATTR_RO(sriov_vf_device);

static DEVICE_ATTR_RW(sriov_drivers_autoprobe);



static struct attribute *sriov_dev_attrs[] = {

	&dev_attr_sriov_totalvfs.attr,

	&dev_attr_sriov_numvfs.attr,

	&dev_attr_sriov_offset.attr,

	&dev_attr_sriov_stride.attr,

	&dev_attr_sriov_vf_device.attr,

	&dev_attr_sriov_drivers_autoprobe.attr,

	NULL,

};



static umode_t sriov_attrs_are_visible(struct kobject *kobj,

				       struct attribute *a, int n)

{

	struct device *dev = kobj_to_dev(kobj);



	if (!dev_is_pf(dev))

		return 0;



	return a->mode;

}



const struct attribute_group sriov_dev_attr_group = {

	.attrs = sriov_dev_attrs,

	.is_visible = sriov_attrs_are_visible,

};



int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs)

{

	return 0;

drivers/pci/pci-bridge-emul.c

+2 −2
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ struct pci_bridge_reg_behavior { 
	u32 rsvd;

};



const static struct pci_bridge_reg_behavior pci_regs_behavior[] = {

static const struct pci_bridge_reg_behavior pci_regs_behavior[] = {

	[PCI_VENDOR_ID / 4] = { .ro = ~0 },

	[PCI_COMMAND / 4] = {

		.rw = (PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
@@ -173,7 +173,7 @@ const static struct pci_bridge_reg_behavior pci_regs_behavior[] = { 
	},

};



const static struct pci_bridge_reg_behavior pcie_cap_regs_behavior[] = {

static const struct pci_bridge_reg_behavior pcie_cap_regs_behavior[] = {

	[PCI_CAP_LIST_ID / 4] = {

		/*

		 * Capability ID, Next Capability Pointer and

drivers/pci/pci-sysfs.c

+22 −201
Original line number Diff line number Diff line
@@ -464,9 +464,7 @@ static ssize_t dev_rescan_store(struct device *dev, 
	}

	return count;

}

static struct device_attribute dev_rescan_attr = __ATTR(rescan,

							(S_IWUSR|S_IWGRP),

							NULL, dev_rescan_store);

static DEVICE_ATTR_WO(dev_rescan);



static ssize_t remove_store(struct device *dev, struct device_attribute *attr,

			    const char *buf, size_t count)
@@ -480,11 +478,10 @@ static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 
		pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));

	return count;

}

static struct device_attribute dev_remove_attr = __ATTR_IGNORE_LOCKDEP(remove,

							(S_IWUSR|S_IWGRP),

							NULL, remove_store);

static DEVICE_ATTR_IGNORE_LOCKDEP(remove, 0220, NULL,

				  remove_store);



static ssize_t dev_bus_rescan_store(struct device *dev,

static ssize_t bus_rescan_store(struct device *dev,

				struct device_attribute *attr,

				const char *buf, size_t count)

{
@@ -504,7 +501,7 @@ static ssize_t dev_bus_rescan_store(struct device *dev, 
	}

	return count;

}

static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);

static DEVICE_ATTR_WO(bus_rescan);



#if defined(CONFIG_PM) && defined(CONFIG_ACPI)

static ssize_t d3cold_allowed_store(struct device *dev,
@@ -551,154 +548,6 @@ static ssize_t devspec_show(struct device *dev, 
static DEVICE_ATTR_RO(devspec);

#endif



#ifdef CONFIG_PCI_IOV

static ssize_t sriov_totalvfs_show(struct device *dev,

				   struct device_attribute *attr,

				   char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));

}





static ssize_t sriov_numvfs_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);

}



/*

 * num_vfs > 0; number of VFs to enable

 * num_vfs = 0; disable all VFs

 *

 * Note: SRIOV spec doesn't allow partial VF

 *       disable, so it's all or none.

 */

static ssize_t sriov_numvfs_store(struct device *dev,

				  struct device_attribute *attr,

				  const char *buf, size_t count)

{

	struct pci_dev *pdev = to_pci_dev(dev);

	int ret;

	u16 num_vfs;



	ret = kstrtou16(buf, 0, &num_vfs);

	if (ret < 0)

		return ret;



	if (num_vfs > pci_sriov_get_totalvfs(pdev))

		return -ERANGE;



	device_lock(&pdev->dev);



	if (num_vfs == pdev->sriov->num_VFs)

		goto exit;



	/* is PF driver loaded w/callback */

	if (!pdev->driver || !pdev->driver->sriov_configure) {

		pci_info(pdev, "Driver doesn't support SRIOV configuration via sysfs\n");

		ret = -ENOENT;

		goto exit;

	}



	if (num_vfs == 0) {

		/* disable VFs */

		ret = pdev->driver->sriov_configure(pdev, 0);

		goto exit;

	}



	/* enable VFs */

	if (pdev->sriov->num_VFs) {

		pci_warn(pdev, "%d VFs already enabled. Disable before enabling %d VFs\n",

			 pdev->sriov->num_VFs, num_vfs);

		ret = -EBUSY;

		goto exit;

	}



	ret = pdev->driver->sriov_configure(pdev, num_vfs);

	if (ret < 0)

		goto exit;



	if (ret != num_vfs)

		pci_warn(pdev, "%d VFs requested; only %d enabled\n",

			 num_vfs, ret);



exit:

	device_unlock(&pdev->dev);



	if (ret < 0)

		return ret;



	return count;

}



static ssize_t sriov_offset_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->offset);

}



static ssize_t sriov_stride_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->stride);

}



static ssize_t sriov_vf_device_show(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%x\n", pdev->sriov->vf_device);

}



static ssize_t sriov_drivers_autoprobe_show(struct device *dev,

					    struct device_attribute *attr,

					    char *buf)

{

	struct pci_dev *pdev = to_pci_dev(dev);



	return sprintf(buf, "%u\n", pdev->sriov->drivers_autoprobe);

}



static ssize_t sriov_drivers_autoprobe_store(struct device *dev,

					     struct device_attribute *attr,

					     const char *buf, size_t count)

{

	struct pci_dev *pdev = to_pci_dev(dev);

	bool drivers_autoprobe;



	if (kstrtobool(buf, &drivers_autoprobe) < 0)

		return -EINVAL;



	pdev->sriov->drivers_autoprobe = drivers_autoprobe;



	return count;

}



static struct device_attribute sriov_totalvfs_attr = __ATTR_RO(sriov_totalvfs);

static struct device_attribute sriov_numvfs_attr =

		__ATTR(sriov_numvfs, (S_IRUGO|S_IWUSR|S_IWGRP),

		       sriov_numvfs_show, sriov_numvfs_store);

static struct device_attribute sriov_offset_attr = __ATTR_RO(sriov_offset);

static struct device_attribute sriov_stride_attr = __ATTR_RO(sriov_stride);

static struct device_attribute sriov_vf_device_attr = __ATTR_RO(sriov_vf_device);

static struct device_attribute sriov_drivers_autoprobe_attr =

		__ATTR(sriov_drivers_autoprobe, (S_IRUGO|S_IWUSR|S_IWGRP),

		       sriov_drivers_autoprobe_show, sriov_drivers_autoprobe_store);

#endif /* CONFIG_PCI_IOV */



static ssize_t driver_override_store(struct device *dev,

				     struct device_attribute *attr,

				     const char *buf, size_t count)
@@ -792,7 +641,7 @@ static struct attribute *pcie_dev_attrs[] = { 
};



static struct attribute *pcibus_attrs[] = {

	&dev_attr_rescan.attr,

	&dev_attr_bus_rescan.attr,

	&dev_attr_cpuaffinity.attr,

	&dev_attr_cpulistaffinity.attr,

	NULL,
@@ -820,7 +669,7 @@ static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr, 
		!!(pdev->resource[PCI_ROM_RESOURCE].flags &

		   IORESOURCE_ROM_SHADOW));

}

static struct device_attribute vga_attr = __ATTR_RO(boot_vga);

static DEVICE_ATTR_RO(boot_vga);



static ssize_t pci_read_config(struct file *filp, struct kobject *kobj,

			       struct bin_attribute *bin_attr, char *buf,
@@ -1085,7 +934,7 @@ void pci_create_legacy_files(struct pci_bus *b) 
	sysfs_bin_attr_init(b->legacy_io);

	b->legacy_io->attr.name = "legacy_io";

	b->legacy_io->size = 0xffff;

	b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;

	b->legacy_io->attr.mode = 0600;

	b->legacy_io->read = pci_read_legacy_io;

	b->legacy_io->write = pci_write_legacy_io;

	b->legacy_io->mmap = pci_mmap_legacy_io;
@@ -1099,7 +948,7 @@ void pci_create_legacy_files(struct pci_bus *b) 
	sysfs_bin_attr_init(b->legacy_mem);

	b->legacy_mem->attr.name = "legacy_mem";

	b->legacy_mem->size = 1024*1024;

	b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;

	b->legacy_mem->attr.mode = 0600;

	b->legacy_mem->mmap = pci_mmap_legacy_mem;

	pci_adjust_legacy_attr(b, pci_mmap_mem);

	error = device_create_bin_file(&b->dev, b->legacy_mem);
@@ -1306,7 +1155,7 @@ static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine) 
		}

	}

	res_attr->attr.name = res_attr_name;

	res_attr->attr.mode = S_IRUSR | S_IWUSR;

	res_attr->attr.mode = 0600;

	res_attr->size = pci_resource_len(pdev, num);

	res_attr->private = (void *)(unsigned long)num;

	retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
@@ -1419,7 +1268,7 @@ static ssize_t pci_read_rom(struct file *filp, struct kobject *kobj, 
static const struct bin_attribute pci_config_attr = {

	.attr =	{

		.name = "config",

		.mode = S_IRUGO | S_IWUSR,

		.mode = 0644,

	},

	.size = PCI_CFG_SPACE_SIZE,

	.read = pci_read_config,
@@ -1429,7 +1278,7 @@ static const struct bin_attribute pci_config_attr = { 
static const struct bin_attribute pcie_config_attr = {

	.attr =	{

		.name = "config",

		.mode = S_IRUGO | S_IWUSR,

		.mode = 0644,

	},

	.size = PCI_CFG_SPACE_EXP_SIZE,

	.read = pci_read_config,
@@ -1458,7 +1307,7 @@ static ssize_t reset_store(struct device *dev, struct device_attribute *attr, 
	return count;

}



static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);

static DEVICE_ATTR(reset, 0200, NULL, reset_store);



static int pci_create_capabilities_sysfs(struct pci_dev *dev)

{
@@ -1468,7 +1317,7 @@ static int pci_create_capabilities_sysfs(struct pci_dev *dev) 
	pcie_aspm_create_sysfs_dev_files(dev);



	if (dev->reset_fn) {

		retval = device_create_file(&dev->dev, &reset_attr);

		retval = device_create_file(&dev->dev, &dev_attr_reset);

		if (retval)

			goto error;

	}
@@ -1511,7 +1360,7 @@ int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev) 
		sysfs_bin_attr_init(attr);

		attr->size = rom_size;

		attr->attr.name = "rom";

		attr->attr.mode = S_IRUSR | S_IWUSR;

		attr->attr.mode = 0600;

		attr->read = pci_read_rom;

		attr->write = pci_write_rom;

		retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
@@ -1553,7 +1402,7 @@ static void pci_remove_capabilities_sysfs(struct pci_dev *dev) 
	pcie_vpd_remove_sysfs_dev_files(dev);

	pcie_aspm_remove_sysfs_dev_files(dev);

	if (dev->reset_fn) {

		device_remove_file(&dev->dev, &reset_attr);

		device_remove_file(&dev->dev, &dev_attr_reset);

		dev->reset_fn = 0;

	}

}
@@ -1606,7 +1455,7 @@ static int __init pci_sysfs_init(void) 
late_initcall(pci_sysfs_init);



static struct attribute *pci_dev_dev_attrs[] = {

	&vga_attr.attr,

	&dev_attr_boot_vga.attr,

	NULL,

};
@@ -1616,7 +1465,7 @@ static umode_t pci_dev_attrs_are_visible(struct kobject *kobj, 
	struct device *dev = kobj_to_dev(kobj);

	struct pci_dev *pdev = to_pci_dev(dev);



	if (a == &vga_attr.attr)

	if (a == &dev_attr_boot_vga.attr)

		if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)

			return 0;
@@ -1624,8 +1473,8 @@ static umode_t pci_dev_attrs_are_visible(struct kobject *kobj, 
}



static struct attribute *pci_dev_hp_attrs[] = {

	&dev_remove_attr.attr,

	&dev_rescan_attr.attr,

	&dev_attr_remove.attr,

	&dev_attr_dev_rescan.attr,

	NULL,

};
@@ -1697,34 +1546,6 @@ static const struct attribute_group pci_dev_hp_attr_group = { 
	.is_visible = pci_dev_hp_attrs_are_visible,

};



#ifdef CONFIG_PCI_IOV

static struct attribute *sriov_dev_attrs[] = {

	&sriov_totalvfs_attr.attr,

	&sriov_numvfs_attr.attr,

	&sriov_offset_attr.attr,

	&sriov_stride_attr.attr,

	&sriov_vf_device_attr.attr,

	&sriov_drivers_autoprobe_attr.attr,

	NULL,

};



static umode_t sriov_attrs_are_visible(struct kobject *kobj,

				       struct attribute *a, int n)

{

	struct device *dev = kobj_to_dev(kobj);



	if (!dev_is_pf(dev))

		return 0;



	return a->mode;

}



static const struct attribute_group sriov_dev_attr_group = {

	.attrs = sriov_dev_attrs,

	.is_visible = sriov_attrs_are_visible,

};

#endif /* CONFIG_PCI_IOV */



static const struct attribute_group pci_dev_attr_group = {

	.attrs = pci_dev_dev_attrs,

	.is_visible = pci_dev_attrs_are_visible,