drivers/iommu/of_iommu.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * OF helpers for IOMMU
   4  *
   5  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/iommu.h>
  10 #include <linux/limits.h>
  11 #include <linux/pci.h>
  12 #include <linux/msi.h>
  13 #include <linux/of.h>
  14 #include <linux/of_iommu.h>
  15 #include <linux/of_pci.h>
  16 #include <linux/slab.h>
  17 #include <linux/fsl/mc.h>
  18
  19 #define NO_IOMMU        1
  20
  21 /**
  22  * of_get_dma_window - Parse *dma-window property and returns 0 if found.
  23  *
  24  * @dn: device node
  25  * @prefix: prefix for property name if any
  26  * @index: index to start to parse
  27  * @busno: Returns busno if supported. Otherwise pass NULL
  28  * @addr: Returns address that DMA starts
  29  * @size: Returns the range that DMA can handle
  30  *
  31  * This supports different formats flexibly. "prefix" can be
  32  * configured if any. "busno" and "index" are optionally
  33  * specified. Set 0(or NULL) if not used.
  34  */
  35 int of_get_dma_window(struct device_node *dn, const char *prefix, int index,
  36                       unsigned long *busno, dma_addr_t *addr, size_t *size)
  37 {
  38         const __be32 *dma_window, *end;
  39         int bytes, cur_index = 0;
  40         char propname[NAME_MAX], addrname[NAME_MAX], sizename[NAME_MAX];
  41
  42         if (!dn || !addr || !size)
  43                 return -EINVAL;
  44
  45         if (!prefix)
  46                 prefix = "";
  47
  48         snprintf(propname, sizeof(propname), "%sdma-window", prefix);
  49         snprintf(addrname, sizeof(addrname), "%s#dma-address-cells", prefix);
  50         snprintf(sizename, sizeof(sizename), "%s#dma-size-cells", prefix);
  51
  52         dma_window = of_get_property(dn, propname, &bytes);
  53         if (!dma_window)
  54                 return -ENODEV;
  55         end = dma_window + bytes / sizeof(*dma_window);
  56
  57         while (dma_window < end) {
  58                 u32 cells;
  59                 const void *prop;
  60
  61                 /* busno is one cell if supported */
  62                 if (busno)
  63                         *busno = be32_to_cpup(dma_window++);
  64
  65                 prop = of_get_property(dn, addrname, NULL);
  66                 if (!prop)
  67                         prop = of_get_property(dn, "#address-cells", NULL);
  68
  69                 cells = prop ? be32_to_cpup(prop) : of_n_addr_cells(dn);
  70                 if (!cells)
  71                         return -EINVAL;
  72                 *addr = of_read_number(dma_window, cells);
  73                 dma_window += cells;
  74
  75                 prop = of_get_property(dn, sizename, NULL);
  76                 cells = prop ? be32_to_cpup(prop) : of_n_size_cells(dn);
  77                 if (!cells)
  78                         return -EINVAL;
  79                 *size = of_read_number(dma_window, cells);
  80                 dma_window += cells;
  81
  82                 if (cur_index++ == index)
  83                         break;
  84         }
  85         return 0;
  86 }
  87 EXPORT_SYMBOL_GPL(of_get_dma_window);
  88
  89 static int of_iommu_xlate(struct device *dev,
  90                           struct of_phandle_args *iommu_spec)
  91 {
  92         const struct iommu_ops *ops;
  93         struct fwnode_handle *fwnode = &iommu_spec->np->fwnode;
  94         int err;
  95
  96         ops = iommu_ops_from_fwnode(fwnode);
  97         if ((ops && !ops->of_xlate) ||
  98             !of_device_is_available(iommu_spec->np))
  99                 return NO_IOMMU;
 100
 101         err = iommu_fwspec_init(dev, &iommu_spec->np->fwnode, ops);
 102         if (err)
 103                 return err;
 104         /*
 105          * The otherwise-empty fwspec handily serves to indicate the specific
 106          * IOMMU device we're waiting for, which will be useful if we ever get
 107          * a proper probe-ordering dependency mechanism in future.
 108          */
 109         if (!ops)
 110                 return driver_deferred_probe_check_state(dev);
 111
 112         return ops->of_xlate(dev, iommu_spec);
 113 }
 114
 115 struct of_pci_iommu_alias_info {
 116         struct device *dev;
 117         struct device_node *np;
 118 };
 119
 120 static int of_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
 121 {
 122         struct of_pci_iommu_alias_info *info = data;
 123         struct of_phandle_args iommu_spec = { .args_count = 1 };
 124         int err;
 125
 126         err = of_map_rid(info->np, alias, "iommu-map", "iommu-map-mask",
 127                          &iommu_spec.np, iommu_spec.args);
 128         if (err)
 129                 return err == -ENODEV ? NO_IOMMU : err;
 130
 131         err = of_iommu_xlate(info->dev, &iommu_spec);
 132         of_node_put(iommu_spec.np);
 133         return err;
 134 }
 135
 136 static int of_fsl_mc_iommu_init(struct fsl_mc_device *mc_dev,
 137                                 struct device_node *master_np)
 138 {
 139         struct of_phandle_args iommu_spec = { .args_count = 1 };
 140         int err;
 141
 142         err = of_map_rid(master_np, mc_dev->icid, "iommu-map",
 143                          "iommu-map-mask", &iommu_spec.np,
 144                          iommu_spec.args);
 145         if (err)
 146                 return err == -ENODEV ? NO_IOMMU : err;
 147
 148         err = of_iommu_xlate(&mc_dev->dev, &iommu_spec);
 149         of_node_put(iommu_spec.np);
 150         return err;
 151 }
 152
 153 const struct iommu_ops *of_iommu_configure(struct device *dev,
 154                                            struct device_node *master_np)
 155 {
 156         const struct iommu_ops *ops = NULL;
 157         struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
 158         int err = NO_IOMMU;
 159
 160         if (!master_np)
 161                 return NULL;
 162
 163         if (fwspec) {
 164                 if (fwspec->ops)
 165                         return fwspec->ops;
 166
 167                 /* In the deferred case, start again from scratch */
 168                 iommu_fwspec_free(dev);
 169         }
 170
 171         /*
 172          * We don't currently walk up the tree looking for a parent IOMMU.
 173          * See the `Notes:' section of
 174          * Documentation/devicetree/bindings/iommu/iommu.txt
 175          */
 176         if (dev_is_pci(dev)) {
 177                 struct of_pci_iommu_alias_info info = {
 178                         .dev = dev,
 179                         .np = master_np,
 180                 };
 181
 182                 err = pci_for_each_dma_alias(to_pci_dev(dev),
 183                                              of_pci_iommu_init, &info);
 184         } else if (dev_is_fsl_mc(dev)) {
 185                 err = of_fsl_mc_iommu_init(to_fsl_mc_device(dev), master_np);
 186         } else {
 187                 struct of_phandle_args iommu_spec;
 188                 int idx = 0;
 189
 190                 while (!of_parse_phandle_with_args(master_np, "iommus",
 191                                                    "#iommu-cells",
 192                                                    idx, &iommu_spec)) {
 193                         err = of_iommu_xlate(dev, &iommu_spec);
 194                         of_node_put(iommu_spec.np);
 195                         idx++;
 196                         if (err)
 197                                 break;
 198                 }
 199         }
 200
 201
 202         /*
 203          * Two success conditions can be represented by non-negative err here:
 204          * >0 : there is no IOMMU, or one was unavailable for non-fatal reasons
 205          *  0 : we found an IOMMU, and dev->fwspec is initialised appropriately
 206          * <0 : any actual error
 207          */
 208         if (!err) {
 209                 /* The fwspec pointer changed, read it again */
 210                 fwspec = dev_iommu_fwspec_get(dev);
 211                 ops    = fwspec->ops;
 212         }
 213         /*
 214          * If we have reason to believe the IOMMU driver missed the initial
 215          * probe for dev, replay it to get things in order.
 216          */
 217         if (!err && dev->bus && !device_iommu_mapped(dev))
 218                 err = iommu_probe_device(dev);
 219
 220         /* Ignore all other errors apart from EPROBE_DEFER */
 221         if (err == -EPROBE_DEFER) {
 222                 ops = ERR_PTR(err);
 223         } else if (err < 0) {
 224                 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
 225                 ops = NULL;
 226         }
 227
 228         return ops;
 229 }