Merge branch 'pci/endpoint'

- Simplify pci_epf_test_alloc_space() by using pci_epc_get_next_free_bar()
  as other similar iterators do (Niklas Cassel)

- Configure endpoint BARs as 64-bit if that's all the hardware supports, in
  addition to doing it if the BAR size is larger than 2GB (Niklas Cassel)

- Remove superfluous pci_epf_configure_bar(), since pci_epf_alloc_space()
  now contains that functionality (Niklas Cassel)

- Simplify pci_epf_test_set_bar() (Niklas Cassel)

- Clean up pci_epf_test_unbind() to reduce indentation level (Niklas
  Cassel)

* pci/endpoint:
  PCI: endpoint: pci-epf-test: Clean up pci_epf_test_unbind()
  PCI: endpoint: pci-epf-test: Simplify pci_epf_test_set_bar() loop
  PCI: endpoint: pci-epf-test: Remove superfluous code
  PCI: endpoint: Allocate a 64-bit BAR if that is the only option
  PCI: endpoint: pci-epf-test: Simplify pci_epf_test_alloc_space() loop

drivers/pci/endpoint/functions/pci-epf-test.c

@@ -690,50 +690,35 @@ static void pci_epf_test_unbind(struct pci_epf *epf)
 {
  struct pci_epf_test *epf_test = epf_get_drvdata(epf);
  struct pci_epc *epc = epf->epc;
- struct pci_epf_bar *epf_bar;
  int bar;
 
  cancel_delayed_work(&epf_test->cmd_handler);
  pci_epf_test_clean_dma_chan(epf_test);
  for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
- epf_bar = &epf->bar[bar];
+ if (!epf_test->reg[bar])
+ continue;
 
- if (epf_test->reg[bar]) {
- pci_epc_clear_bar(epc, epf->func_no, epf->vfunc_no,
- epf_bar);
- pci_epf_free_space(epf, epf_test->reg[bar], bar,
- PRIMARY_INTERFACE);
- }
+ pci_epc_clear_bar(epc, epf->func_no, epf->vfunc_no,
+ &epf->bar[bar]);
+ pci_epf_free_space(epf, epf_test->reg[bar], bar,
+ PRIMARY_INTERFACE);
  }
 }
 
 static int pci_epf_test_set_bar(struct pci_epf *epf)
 {
- int bar, add;
- int ret;
- struct pci_epf_bar *epf_bar;
+ int bar, ret;
  struct pci_epc *epc = epf->epc;
  struct device *dev = &epf->dev;
  struct pci_epf_test *epf_test = epf_get_drvdata(epf);
  enum pci_barno test_reg_bar = epf_test->test_reg_bar;
- const struct pci_epc_features *epc_features;
-
- epc_features = epf_test->epc_features;
-
- for (bar = 0; bar < PCI_STD_NUM_BARS; bar += add) {
- epf_bar = &epf->bar[bar];
- /*
- * pci_epc_set_bar() sets PCI_BASE_ADDRESS_MEM_TYPE_64
- * if the specific implementation required a 64-bit BAR,
- * even if we only requested a 32-bit BAR.
- */
- add = (epf_bar->flags & PCI_BASE_ADDRESS_MEM_TYPE_64) ? 2 : 1;
 
- if (epc_features->bar[bar].type == BAR_RESERVED)
+ for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
+ if (!epf_test->reg[bar])
  continue;
 
  ret = pci_epc_set_bar(epc, epf->func_no, epf->vfunc_no,
- epf_bar);
+ &epf->bar[bar]);
  if (ret) {
  pci_epf_free_space(epf, epf_test->reg[bar], bar,
  PRIMARY_INTERFACE);
@@ -822,14 +807,13 @@ static int pci_epf_test_alloc_space(struct pci_epf *epf)
 {
  struct pci_epf_test *epf_test = epf_get_drvdata(epf);
  struct device *dev = &epf->dev;
- struct pci_epf_bar *epf_bar;
  size_t msix_table_size = 0;
  size_t test_reg_bar_size;
  size_t pba_size = 0;
  bool msix_capable;
  void *base;
- int bar, add;
  enum pci_barno test_reg_bar = epf_test->test_reg_bar;
+ enum pci_barno bar;
  const struct pci_epc_features *epc_features;
  size_t test_reg_size;
 
@@ -854,16 +838,14 @@ static int pci_epf_test_alloc_space(struct pci_epf *epf)
  }
  epf_test->reg[test_reg_bar] = base;
 
- for (bar = 0; bar < PCI_STD_NUM_BARS; bar += add) {
- epf_bar = &epf->bar[bar];
- add = (epf_bar->flags & PCI_BASE_ADDRESS_MEM_TYPE_64) ? 2 : 1;
+ for (bar = BAR_0; bar < PCI_STD_NUM_BARS; bar++) {
+ bar = pci_epc_get_next_free_bar(epc_features, bar);
+ if (bar == NO_BAR)
+ break;
 
  if (bar == test_reg_bar)
  continue;
 
- if (epc_features->bar[bar].type == BAR_RESERVED)
- continue;
-
  base = pci_epf_alloc_space(epf, bar_size[bar], bar,
  epc_features, PRIMARY_INTERFACE);
  if (!base)
@@ -875,19 +857,6 @@ static int pci_epf_test_alloc_space(struct pci_epf *epf)
  return 0;
 }
 
-static void pci_epf_configure_bar(struct pci_epf *epf,
- const struct pci_epc_features *epc_features)
-{
- struct pci_epf_bar *epf_bar;
- int i;
-
- for (i = 0; i < PCI_STD_NUM_BARS; i++) {
- epf_bar = &epf->bar[i];
- if (epc_features->bar[i].only_64bit)
- epf_bar->flags |= PCI_BASE_ADDRESS_MEM_TYPE_64;
- }
-}
-
 static int pci_epf_test_bind(struct pci_epf *epf)
 {
  int ret;
@@ -908,7 +877,6 @@ static int pci_epf_test_bind(struct pci_epf *epf)
  test_reg_bar = pci_epc_get_first_free_bar(epc_features);
  if (test_reg_bar < 0)
  return -EINVAL;
- pci_epf_configure_bar(epf, epc_features);
 
  epf_test->test_reg_bar = test_reg_bar;
  epf_test->epc_features = epc_features;

drivers/pci/endpoint/pci-epf-core.c

@@ -255,6 +255,8 @@ EXPORT_SYMBOL_GPL(pci_epf_free_space);
  * @type: Identifies if the allocation is for primary EPC or secondary EPC
  *
  * Invoke to allocate memory for the PCI EPF register space.
+ * Flag PCI_BASE_ADDRESS_MEM_TYPE_64 will automatically get set if the BAR
+ * can only be a 64-bit BAR, or if the requested size is larger than 2 GB.
  */
 void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar,
  const struct pci_epc_features *epc_features,
@@ -304,9 +306,10 @@ void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar,
  epf_bar[bar].addr = space;
  epf_bar[bar].size = size;
  epf_bar[bar].barno = bar;
- epf_bar[bar].flags |= upper_32_bits(size) ?
- PCI_BASE_ADDRESS_MEM_TYPE_64 :
- PCI_BASE_ADDRESS_MEM_TYPE_32;
+ if (upper_32_bits(size) || epc_features->bar[bar].only_64bit)
+ epf_bar[bar].flags |= PCI_BASE_ADDRESS_MEM_TYPE_64;
+ else
+ epf_bar[bar].flags |= PCI_BASE_ADDRESS_MEM_TYPE_32;
 
  return space;
 }