LCOV - code coverage report
Current view: top level - drivers/iommu - dmar.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 26 1044 2.5 %
Date: 2022-04-01 14:58:12 Functions: 3 64 4.7 %
Branches: 10 711 1.4 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Copyright (c) 2006, Intel Corporation.
       4                 :            :  *
       5                 :            :  * Copyright (C) 2006-2008 Intel Corporation
       6                 :            :  * Author: Ashok Raj <ashok.raj@intel.com>
       7                 :            :  * Author: Shaohua Li <shaohua.li@intel.com>
       8                 :            :  * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
       9                 :            :  *
      10                 :            :  * This file implements early detection/parsing of Remapping Devices
      11                 :            :  * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI
      12                 :            :  * tables.
      13                 :            :  *
      14                 :            :  * These routines are used by both DMA-remapping and Interrupt-remapping
      15                 :            :  */
      16                 :            : 
      17                 :            : #define pr_fmt(fmt)     "DMAR: " fmt
      18                 :            : 
      19                 :            : #include <linux/pci.h>
      20                 :            : #include <linux/dmar.h>
      21                 :            : #include <linux/iova.h>
      22                 :            : #include <linux/intel-iommu.h>
      23                 :            : #include <linux/timer.h>
      24                 :            : #include <linux/irq.h>
      25                 :            : #include <linux/interrupt.h>
      26                 :            : #include <linux/tboot.h>
      27                 :            : #include <linux/dmi.h>
      28                 :            : #include <linux/slab.h>
      29                 :            : #include <linux/iommu.h>
      30                 :            : #include <linux/numa.h>
      31                 :            : #include <linux/limits.h>
      32                 :            : #include <asm/irq_remapping.h>
      33                 :            : #include <asm/iommu_table.h>
      34                 :            : 
      35                 :            : #include "irq_remapping.h"
      36                 :            : 
      37                 :            : typedef int (*dmar_res_handler_t)(struct acpi_dmar_header *, void *);
      38                 :            : struct dmar_res_callback {
      39                 :            :         dmar_res_handler_t      cb[ACPI_DMAR_TYPE_RESERVED];
      40                 :            :         void                    *arg[ACPI_DMAR_TYPE_RESERVED];
      41                 :            :         bool                    ignore_unhandled;
      42                 :            :         bool                    print_entry;
      43                 :            : };
      44                 :            : 
      45                 :            : /*
      46                 :            :  * Assumptions:
      47                 :            :  * 1) The hotplug framework guarentees that DMAR unit will be hot-added
      48                 :            :  *    before IO devices managed by that unit.
      49                 :            :  * 2) The hotplug framework guarantees that DMAR unit will be hot-removed
      50                 :            :  *    after IO devices managed by that unit.
      51                 :            :  * 3) Hotplug events are rare.
      52                 :            :  *
      53                 :            :  * Locking rules for DMA and interrupt remapping related global data structures:
      54                 :            :  * 1) Use dmar_global_lock in process context
      55                 :            :  * 2) Use RCU in interrupt context
      56                 :            :  */
      57                 :            : DECLARE_RWSEM(dmar_global_lock);
      58                 :            : LIST_HEAD(dmar_drhd_units);
      59                 :            : 
      60                 :            : struct acpi_table_header * __initdata dmar_tbl;
      61                 :            : static int dmar_dev_scope_status = 1;
      62                 :            : static unsigned long dmar_seq_ids[BITS_TO_LONGS(DMAR_UNITS_SUPPORTED)];
      63                 :            : 
      64                 :            : static int alloc_iommu(struct dmar_drhd_unit *drhd);
      65                 :            : static void free_iommu(struct intel_iommu *iommu);
      66                 :            : 
      67                 :            : extern const struct iommu_ops intel_iommu_ops;
      68                 :            : 
      69                 :          0 : static void dmar_register_drhd_unit(struct dmar_drhd_unit *drhd)
      70                 :            : {
      71                 :            :         /*
      72                 :            :          * add INCLUDE_ALL at the tail, so scan the list will find it at
      73                 :            :          * the very end.
      74                 :            :          */
      75                 :          0 :         if (drhd->include_all)
      76                 :          0 :                 list_add_tail_rcu(&drhd->list, &dmar_drhd_units);
      77                 :            :         else
      78                 :          0 :                 list_add_rcu(&drhd->list, &dmar_drhd_units);
      79                 :            : }
      80                 :            : 
      81                 :          0 : void *dmar_alloc_dev_scope(void *start, void *end, int *cnt)
      82                 :            : {
      83                 :          0 :         struct acpi_dmar_device_scope *scope;
      84                 :            : 
      85                 :          0 :         *cnt = 0;
      86         [ #  # ]:          0 :         while (start < end) {
      87                 :          0 :                 scope = start;
      88         [ #  # ]:          0 :                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_NAMESPACE ||
      89         [ #  # ]:          0 :                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
      90                 :            :                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
      91                 :          0 :                         (*cnt)++;
      92         [ #  # ]:          0 :                 else if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_IOAPIC &&
      93                 :            :                         scope->entry_type != ACPI_DMAR_SCOPE_TYPE_HPET) {
      94                 :          0 :                         pr_warn("Unsupported device scope\n");
      95                 :            :                 }
      96                 :          0 :                 start += scope->length;
      97                 :            :         }
      98         [ #  # ]:          0 :         if (*cnt == 0)
      99                 :            :                 return NULL;
     100                 :            : 
     101                 :          0 :         return kcalloc(*cnt, sizeof(struct dmar_dev_scope), GFP_KERNEL);
     102                 :            : }
     103                 :            : 
     104                 :          0 : void dmar_free_dev_scope(struct dmar_dev_scope **devices, int *cnt)
     105                 :            : {
     106                 :          0 :         int i;
     107                 :          0 :         struct device *tmp_dev;
     108                 :            : 
     109   [ #  #  #  # ]:          0 :         if (*devices && *cnt) {
     110   [ #  #  #  #  :          0 :                 for_each_active_dev_scope(*devices, *cnt, i, tmp_dev)
                   #  # ]
     111                 :          0 :                         put_device(tmp_dev);
     112                 :          0 :                 kfree(*devices);
     113                 :            :         }
     114                 :            : 
     115                 :          0 :         *devices = NULL;
     116                 :          0 :         *cnt = 0;
     117                 :          0 : }
     118                 :            : 
     119                 :            : /* Optimize out kzalloc()/kfree() for normal cases */
     120                 :            : static char dmar_pci_notify_info_buf[64];
     121                 :            : 
     122                 :            : static struct dmar_pci_notify_info *
     123                 :          0 : dmar_alloc_pci_notify_info(struct pci_dev *dev, unsigned long event)
     124                 :            : {
     125                 :          0 :         int level = 0;
     126                 :          0 :         size_t size;
     127                 :          0 :         struct pci_dev *tmp;
     128                 :          0 :         struct dmar_pci_notify_info *info;
     129                 :            : 
     130         [ #  # ]:          0 :         BUG_ON(dev->is_virtfn);
     131                 :            : 
     132                 :            :         /*
     133                 :            :          * Ignore devices that have a domain number higher than what can
     134                 :            :          * be looked up in DMAR, e.g. VMD subdevices with domain 0x10000
     135                 :            :          */
     136         [ #  # ]:          0 :         if (pci_domain_nr(dev->bus) > U16_MAX)
     137                 :            :                 return NULL;
     138                 :            : 
     139                 :            :         /* Only generate path[] for device addition event */
     140         [ #  # ]:          0 :         if (event == BUS_NOTIFY_ADD_DEVICE)
     141         [ #  # ]:          0 :                 for (tmp = dev; tmp; tmp = tmp->bus->self)
     142                 :          0 :                         level++;
     143                 :            : 
     144         [ #  # ]:          0 :         size = struct_size(info, path, level);
     145         [ #  # ]:          0 :         if (size <= sizeof(dmar_pci_notify_info_buf)) {
     146                 :            :                 info = (struct dmar_pci_notify_info *)dmar_pci_notify_info_buf;
     147                 :            :         } else {
     148                 :          0 :                 info = kzalloc(size, GFP_KERNEL);
     149         [ #  # ]:          0 :                 if (!info) {
     150         [ #  # ]:          0 :                         pr_warn("Out of memory when allocating notify_info "
     151                 :            :                                 "for %s.\n", pci_name(dev));
     152         [ #  # ]:          0 :                         if (dmar_dev_scope_status == 0)
     153                 :          0 :                                 dmar_dev_scope_status = -ENOMEM;
     154                 :          0 :                         return NULL;
     155                 :            :                 }
     156                 :            :         }
     157                 :            : 
     158                 :          0 :         info->event = event;
     159                 :          0 :         info->dev = dev;
     160         [ #  # ]:          0 :         info->seg = pci_domain_nr(dev->bus);
     161                 :          0 :         info->level = level;
     162         [ #  # ]:          0 :         if (event == BUS_NOTIFY_ADD_DEVICE) {
     163         [ #  # ]:          0 :                 for (tmp = dev; tmp; tmp = tmp->bus->self) {
     164                 :          0 :                         level--;
     165                 :          0 :                         info->path[level].bus = tmp->bus->number;
     166                 :          0 :                         info->path[level].device = PCI_SLOT(tmp->devfn);
     167                 :          0 :                         info->path[level].function = PCI_FUNC(tmp->devfn);
     168         [ #  # ]:          0 :                         if (pci_is_root_bus(tmp->bus))
     169                 :          0 :                                 info->bus = tmp->bus->number;
     170                 :            :                 }
     171                 :            :         }
     172                 :            : 
     173                 :            :         return info;
     174                 :            : }
     175                 :            : 
     176                 :          0 : static inline void dmar_free_pci_notify_info(struct dmar_pci_notify_info *info)
     177                 :            : {
     178                 :          0 :         if ((void *)info != dmar_pci_notify_info_buf)
     179                 :          0 :                 kfree(info);
     180                 :            : }
     181                 :            : 
     182                 :          0 : static bool dmar_match_pci_path(struct dmar_pci_notify_info *info, int bus,
     183                 :            :                                 struct acpi_dmar_pci_path *path, int count)
     184                 :            : {
     185                 :          0 :         int i;
     186                 :            : 
     187         [ #  # ]:          0 :         if (info->bus != bus)
     188                 :          0 :                 goto fallback;
     189         [ #  # ]:          0 :         if (info->level != count)
     190                 :          0 :                 goto fallback;
     191                 :            : 
     192         [ #  # ]:          0 :         for (i = 0; i < count; i++) {
     193         [ #  # ]:          0 :                 if (path[i].device != info->path[i].device ||
     194         [ #  # ]:          0 :                     path[i].function != info->path[i].function)
     195                 :          0 :                         goto fallback;
     196                 :            :         }
     197                 :            : 
     198                 :            :         return true;
     199                 :            : 
     200                 :          0 : fallback:
     201                 :            : 
     202         [ #  # ]:          0 :         if (count != 1)
     203                 :            :                 return false;
     204                 :            : 
     205                 :          0 :         i = info->level - 1;
     206         [ #  # ]:          0 :         if (bus              == info->path[i].bus &&
     207         [ #  # ]:          0 :             path[0].device   == info->path[i].device &&
     208         [ #  # ]:          0 :             path[0].function == info->path[i].function) {
     209                 :          0 :                 pr_info(FW_BUG "RMRR entry for device %02x:%02x.%x is broken - applying workaround\n",
     210                 :            :                         bus, path[0].device, path[0].function);
     211                 :          0 :                 return true;
     212                 :            :         }
     213                 :            : 
     214                 :            :         return false;
     215                 :            : }
     216                 :            : 
     217                 :            : /* Return: > 0 if match found, 0 if no match found, < 0 if error happens */
     218                 :          0 : int dmar_insert_dev_scope(struct dmar_pci_notify_info *info,
     219                 :            :                           void *start, void*end, u16 segment,
     220                 :            :                           struct dmar_dev_scope *devices,
     221                 :            :                           int devices_cnt)
     222                 :            : {
     223                 :          0 :         int i, level;
     224                 :          0 :         struct device *tmp, *dev = &info->dev->dev;
     225                 :          0 :         struct acpi_dmar_device_scope *scope;
     226                 :          0 :         struct acpi_dmar_pci_path *path;
     227                 :            : 
     228         [ #  # ]:          0 :         if (segment != info->seg)
     229                 :            :                 return 0;
     230                 :            : 
     231         [ #  # ]:          0 :         for (; start < end; start += scope->length) {
     232                 :          0 :                 scope = start;
     233         [ #  # ]:          0 :                 if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_ENDPOINT &&
     234                 :            :                     scope->entry_type != ACPI_DMAR_SCOPE_TYPE_BRIDGE)
     235                 :          0 :                         continue;
     236                 :            : 
     237                 :          0 :                 path = (struct acpi_dmar_pci_path *)(scope + 1);
     238                 :          0 :                 level = (scope->length - sizeof(*scope)) / sizeof(*path);
     239         [ #  # ]:          0 :                 if (!dmar_match_pci_path(info, scope->bus, path, level))
     240                 :          0 :                         continue;
     241                 :            : 
     242                 :            :                 /*
     243                 :            :                  * We expect devices with endpoint scope to have normal PCI
     244                 :            :                  * headers, and devices with bridge scope to have bridge PCI
     245                 :            :                  * headers.  However PCI NTB devices may be listed in the
     246                 :            :                  * DMAR table with bridge scope, even though they have a
     247                 :            :                  * normal PCI header.  NTB devices are identified by class
     248                 :            :                  * "BRIDGE_OTHER" (0680h) - we don't declare a socpe mismatch
     249                 :            :                  * for this special case.
     250                 :            :                  */
     251         [ #  # ]:          0 :                 if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT &&
     252   [ #  #  #  # ]:          0 :                      info->dev->hdr_type != PCI_HEADER_TYPE_NORMAL) ||
     253                 :          0 :                     (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE &&
     254         [ #  # ]:          0 :                      (info->dev->hdr_type == PCI_HEADER_TYPE_NORMAL &&
     255         [ #  # ]:          0 :                       info->dev->class >> 16 != PCI_BASE_CLASS_BRIDGE))) {
     256         [ #  # ]:          0 :                         pr_warn("Device scope type does not match for %s\n",
     257                 :            :                                 pci_name(info->dev));
     258                 :          0 :                         return -EINVAL;
     259                 :            :                 }
     260                 :            : 
     261   [ #  #  #  # ]:          0 :                 for_each_dev_scope(devices, devices_cnt, i, tmp)
     262         [ #  # ]:          0 :                         if (tmp == NULL) {
     263                 :          0 :                                 devices[i].bus = info->dev->bus->number;
     264                 :          0 :                                 devices[i].devfn = info->dev->devfn;
     265                 :          0 :                                 rcu_assign_pointer(devices[i].dev,
     266                 :            :                                                    get_device(dev));
     267                 :          0 :                                 return 1;
     268                 :            :                         }
     269                 :          0 :                 BUG_ON(i >= devices_cnt);
     270                 :            :         }
     271                 :            : 
     272                 :            :         return 0;
     273                 :            : }
     274                 :            : 
     275                 :          0 : int dmar_remove_dev_scope(struct dmar_pci_notify_info *info, u16 segment,
     276                 :            :                           struct dmar_dev_scope *devices, int count)
     277                 :            : {
     278                 :          0 :         int index;
     279                 :          0 :         struct device *tmp;
     280                 :            : 
     281         [ #  # ]:          0 :         if (info->seg != segment)
     282                 :            :                 return 0;
     283                 :            : 
     284   [ #  #  #  #  :          0 :         for_each_active_dev_scope(devices, count, index, tmp)
                   #  # ]
     285         [ #  # ]:          0 :                 if (tmp == &info->dev->dev) {
     286                 :          0 :                         RCU_INIT_POINTER(devices[index].dev, NULL);
     287                 :          0 :                         synchronize_rcu();
     288                 :          0 :                         put_device(tmp);
     289                 :          0 :                         return 1;
     290                 :            :                 }
     291                 :            : 
     292                 :            :         return 0;
     293                 :            : }
     294                 :            : 
     295                 :          0 : static int dmar_pci_bus_add_dev(struct dmar_pci_notify_info *info)
     296                 :            : {
     297                 :          0 :         int ret = 0;
     298                 :          0 :         struct dmar_drhd_unit *dmaru;
     299                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     300                 :            : 
     301         [ #  # ]:          0 :         for_each_drhd_unit(dmaru) {
     302         [ #  # ]:          0 :                 if (dmaru->include_all)
     303                 :          0 :                         continue;
     304                 :            : 
     305                 :          0 :                 drhd = container_of(dmaru->hdr,
     306                 :            :                                     struct acpi_dmar_hardware_unit, header);
     307                 :          0 :                 ret = dmar_insert_dev_scope(info, (void *)(drhd + 1),
     308                 :          0 :                                 ((void *)drhd) + drhd->header.length,
     309                 :          0 :                                 dmaru->segment,
     310                 :            :                                 dmaru->devices, dmaru->devices_cnt);
     311         [ #  # ]:          0 :                 if (ret)
     312                 :            :                         break;
     313                 :            :         }
     314         [ #  # ]:          0 :         if (ret >= 0)
     315                 :          0 :                 ret = dmar_iommu_notify_scope_dev(info);
     316   [ #  #  #  # ]:          0 :         if (ret < 0 && dmar_dev_scope_status == 0)
     317                 :          0 :                 dmar_dev_scope_status = ret;
     318                 :            : 
     319                 :          0 :         return ret;
     320                 :            : }
     321                 :            : 
     322                 :          0 : static void  dmar_pci_bus_del_dev(struct dmar_pci_notify_info *info)
     323                 :            : {
     324                 :          0 :         struct dmar_drhd_unit *dmaru;
     325                 :            : 
     326         [ #  # ]:          0 :         for_each_drhd_unit(dmaru)
     327         [ #  # ]:          0 :                 if (dmar_remove_dev_scope(info, dmaru->segment,
     328                 :            :                         dmaru->devices, dmaru->devices_cnt))
     329                 :            :                         break;
     330                 :          0 :         dmar_iommu_notify_scope_dev(info);
     331                 :          0 : }
     332                 :            : 
     333                 :          0 : static int dmar_pci_bus_notifier(struct notifier_block *nb,
     334                 :            :                                  unsigned long action, void *data)
     335                 :            : {
     336                 :          0 :         struct pci_dev *pdev = to_pci_dev(data);
     337                 :          0 :         struct dmar_pci_notify_info *info;
     338                 :            : 
     339                 :            :         /* Only care about add/remove events for physical functions.
     340                 :            :          * For VFs we actually do the lookup based on the corresponding
     341                 :            :          * PF in device_to_iommu() anyway. */
     342         [ #  # ]:          0 :         if (pdev->is_virtfn)
     343                 :            :                 return NOTIFY_DONE;
     344                 :          0 :         if (action != BUS_NOTIFY_ADD_DEVICE &&
     345         [ #  # ]:          0 :             action != BUS_NOTIFY_REMOVED_DEVICE)
     346                 :            :                 return NOTIFY_DONE;
     347                 :            : 
     348                 :          0 :         info = dmar_alloc_pci_notify_info(pdev, action);
     349         [ #  # ]:          0 :         if (!info)
     350                 :            :                 return NOTIFY_DONE;
     351                 :            : 
     352                 :          0 :         down_write(&dmar_global_lock);
     353         [ #  # ]:          0 :         if (action == BUS_NOTIFY_ADD_DEVICE)
     354                 :          0 :                 dmar_pci_bus_add_dev(info);
     355         [ #  # ]:          0 :         else if (action == BUS_NOTIFY_REMOVED_DEVICE)
     356                 :          0 :                 dmar_pci_bus_del_dev(info);
     357                 :          0 :         up_write(&dmar_global_lock);
     358                 :            : 
     359         [ #  # ]:          0 :         dmar_free_pci_notify_info(info);
     360                 :            : 
     361                 :            :         return NOTIFY_OK;
     362                 :            : }
     363                 :            : 
     364                 :            : static struct notifier_block dmar_pci_bus_nb = {
     365                 :            :         .notifier_call = dmar_pci_bus_notifier,
     366                 :            :         .priority = INT_MIN,
     367                 :            : };
     368                 :            : 
     369                 :            : static struct dmar_drhd_unit *
     370                 :          0 : dmar_find_dmaru(struct acpi_dmar_hardware_unit *drhd)
     371                 :            : {
     372                 :          0 :         struct dmar_drhd_unit *dmaru;
     373                 :            : 
     374   [ #  #  #  #  :          0 :         list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list,
             #  #  #  # ]
     375                 :            :                                 dmar_rcu_check())
     376   [ #  #  #  #  :          0 :                 if (dmaru->segment == drhd->segment &&
             #  #  #  # ]
     377   [ #  #  #  #  :          0 :                     dmaru->reg_base_addr == drhd->address)
             #  #  #  # ]
     378                 :            :                         return dmaru;
     379                 :            : 
     380                 :            :         return NULL;
     381                 :            : }
     382                 :            : 
     383                 :            : /**
     384                 :            :  * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition
     385                 :            :  * structure which uniquely represent one DMA remapping hardware unit
     386                 :            :  * present in the platform
     387                 :            :  */
     388                 :          0 : static int dmar_parse_one_drhd(struct acpi_dmar_header *header, void *arg)
     389                 :            : {
     390                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     391                 :          0 :         struct dmar_drhd_unit *dmaru;
     392                 :          0 :         int ret;
     393                 :            : 
     394                 :          0 :         drhd = (struct acpi_dmar_hardware_unit *)header;
     395                 :          0 :         dmaru = dmar_find_dmaru(drhd);
     396         [ #  # ]:          0 :         if (dmaru)
     397                 :          0 :                 goto out;
     398                 :            : 
     399                 :          0 :         dmaru = kzalloc(sizeof(*dmaru) + header->length, GFP_KERNEL);
     400         [ #  # ]:          0 :         if (!dmaru)
     401                 :            :                 return -ENOMEM;
     402                 :            : 
     403                 :            :         /*
     404                 :            :          * If header is allocated from slab by ACPI _DSM method, we need to
     405                 :            :          * copy the content because the memory buffer will be freed on return.
     406                 :            :          */
     407                 :          0 :         dmaru->hdr = (void *)(dmaru + 1);
     408                 :          0 :         memcpy(dmaru->hdr, header, header->length);
     409                 :          0 :         dmaru->reg_base_addr = drhd->address;
     410                 :          0 :         dmaru->segment = drhd->segment;
     411                 :          0 :         dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */
     412                 :          0 :         dmaru->devices = dmar_alloc_dev_scope((void *)(drhd + 1),
     413                 :          0 :                                               ((void *)drhd) + drhd->header.length,
     414                 :            :                                               &dmaru->devices_cnt);
     415   [ #  #  #  # ]:          0 :         if (dmaru->devices_cnt && dmaru->devices == NULL) {
     416                 :          0 :                 kfree(dmaru);
     417                 :          0 :                 return -ENOMEM;
     418                 :            :         }
     419                 :            : 
     420                 :          0 :         ret = alloc_iommu(dmaru);
     421         [ #  # ]:          0 :         if (ret) {
     422                 :          0 :                 dmar_free_dev_scope(&dmaru->devices,
     423                 :            :                                     &dmaru->devices_cnt);
     424                 :          0 :                 kfree(dmaru);
     425                 :          0 :                 return ret;
     426                 :            :         }
     427         [ #  # ]:          0 :         dmar_register_drhd_unit(dmaru);
     428                 :            : 
     429                 :          0 : out:
     430         [ #  # ]:          0 :         if (arg)
     431                 :          0 :                 (*(int *)arg)++;
     432                 :            : 
     433                 :            :         return 0;
     434                 :            : }
     435                 :            : 
     436                 :          0 : static void dmar_free_drhd(struct dmar_drhd_unit *dmaru)
     437                 :            : {
     438   [ #  #  #  # ]:          0 :         if (dmaru->devices && dmaru->devices_cnt)
     439                 :          0 :                 dmar_free_dev_scope(&dmaru->devices, &dmaru->devices_cnt);
     440         [ #  # ]:          0 :         if (dmaru->iommu)
     441                 :          0 :                 free_iommu(dmaru->iommu);
     442                 :          0 :         kfree(dmaru);
     443                 :          0 : }
     444                 :            : 
     445                 :          0 : static int __init dmar_parse_one_andd(struct acpi_dmar_header *header,
     446                 :            :                                       void *arg)
     447                 :            : {
     448                 :          0 :         struct acpi_dmar_andd *andd = (void *)header;
     449                 :            : 
     450                 :            :         /* Check for NUL termination within the designated length */
     451         [ #  # ]:          0 :         if (strnlen(andd->device_name, header->length - 8) == header->length - 8) {
     452                 :          0 :                 pr_warn(FW_BUG
     453                 :            :                            "Your BIOS is broken; ANDD object name is not NUL-terminated\n"
     454                 :            :                            "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
     455                 :            :                            dmi_get_system_info(DMI_BIOS_VENDOR),
     456                 :            :                            dmi_get_system_info(DMI_BIOS_VERSION),
     457                 :            :                            dmi_get_system_info(DMI_PRODUCT_VERSION));
     458                 :          0 :                 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
     459                 :          0 :                 return -EINVAL;
     460                 :            :         }
     461                 :          0 :         pr_info("ANDD device: %x name: %s\n", andd->device_number,
     462                 :            :                 andd->device_name);
     463                 :            : 
     464                 :          0 :         return 0;
     465                 :            : }
     466                 :            : 
     467                 :            : #ifdef CONFIG_ACPI_NUMA
     468                 :          0 : static int dmar_parse_one_rhsa(struct acpi_dmar_header *header, void *arg)
     469                 :            : {
     470                 :          0 :         struct acpi_dmar_rhsa *rhsa;
     471                 :          0 :         struct dmar_drhd_unit *drhd;
     472                 :            : 
     473                 :          0 :         rhsa = (struct acpi_dmar_rhsa *)header;
     474         [ #  # ]:          0 :         for_each_drhd_unit(drhd) {
     475         [ #  # ]:          0 :                 if (drhd->reg_base_addr == rhsa->base_address) {
     476                 :          0 :                         int node = acpi_map_pxm_to_node(rhsa->proximity_domain);
     477                 :            : 
     478         [ #  # ]:          0 :                         if (!node_online(node))
     479                 :          0 :                                 node = NUMA_NO_NODE;
     480                 :          0 :                         drhd->iommu->node = node;
     481                 :          0 :                         return 0;
     482                 :            :                 }
     483                 :            :         }
     484                 :          0 :         pr_warn(FW_BUG
     485                 :            :                 "Your BIOS is broken; RHSA refers to non-existent DMAR unit at %llx\n"
     486                 :            :                 "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
     487                 :            :                 rhsa->base_address,
     488                 :            :                 dmi_get_system_info(DMI_BIOS_VENDOR),
     489                 :            :                 dmi_get_system_info(DMI_BIOS_VERSION),
     490                 :            :                 dmi_get_system_info(DMI_PRODUCT_VERSION));
     491                 :          0 :         add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
     492                 :            : 
     493                 :          0 :         return 0;
     494                 :            : }
     495                 :            : #else
     496                 :            : #define dmar_parse_one_rhsa             dmar_res_noop
     497                 :            : #endif
     498                 :            : 
     499                 :            : static void
     500                 :          0 : dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
     501                 :            : {
     502                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     503                 :          0 :         struct acpi_dmar_reserved_memory *rmrr;
     504                 :          0 :         struct acpi_dmar_atsr *atsr;
     505                 :          0 :         struct acpi_dmar_rhsa *rhsa;
     506                 :            : 
     507   [ #  #  #  #  :          0 :         switch (header->type) {
                      # ]
     508                 :          0 :         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
     509                 :          0 :                 drhd = container_of(header, struct acpi_dmar_hardware_unit,
     510                 :            :                                     header);
     511                 :          0 :                 pr_info("DRHD base: %#016Lx flags: %#x\n",
     512                 :            :                         (unsigned long long)drhd->address, drhd->flags);
     513                 :          0 :                 break;
     514                 :          0 :         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
     515                 :          0 :                 rmrr = container_of(header, struct acpi_dmar_reserved_memory,
     516                 :            :                                     header);
     517                 :          0 :                 pr_info("RMRR base: %#016Lx end: %#016Lx\n",
     518                 :            :                         (unsigned long long)rmrr->base_address,
     519                 :            :                         (unsigned long long)rmrr->end_address);
     520                 :          0 :                 break;
     521                 :          0 :         case ACPI_DMAR_TYPE_ROOT_ATS:
     522                 :          0 :                 atsr = container_of(header, struct acpi_dmar_atsr, header);
     523                 :          0 :                 pr_info("ATSR flags: %#x\n", atsr->flags);
     524                 :          0 :                 break;
     525                 :          0 :         case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
     526                 :          0 :                 rhsa = container_of(header, struct acpi_dmar_rhsa, header);
     527                 :          0 :                 pr_info("RHSA base: %#016Lx proximity domain: %#x\n",
     528                 :            :                        (unsigned long long)rhsa->base_address,
     529                 :            :                        rhsa->proximity_domain);
     530                 :          0 :                 break;
     531                 :            :         case ACPI_DMAR_TYPE_NAMESPACE:
     532                 :            :                 /* We don't print this here because we need to sanity-check
     533                 :            :                    it first. So print it in dmar_parse_one_andd() instead. */
     534                 :            :                 break;
     535                 :            :         }
     536                 :          0 : }
     537                 :            : 
     538                 :            : /**
     539                 :            :  * dmar_table_detect - checks to see if the platform supports DMAR devices
     540                 :            :  */
     541                 :          3 : static int __init dmar_table_detect(void)
     542                 :            : {
     543                 :          3 :         acpi_status status = AE_OK;
     544                 :            : 
     545                 :            :         /* if we could find DMAR table, then there are DMAR devices */
     546                 :          3 :         status = acpi_get_table(ACPI_SIG_DMAR, 0, &dmar_tbl);
     547                 :            : 
     548   [ -  +  -  - ]:          3 :         if (ACPI_SUCCESS(status) && !dmar_tbl) {
     549                 :          0 :                 pr_warn("Unable to map DMAR\n");
     550                 :          0 :                 status = AE_NOT_FOUND;
     551                 :            :         }
     552                 :            : 
     553         [ +  - ]:          3 :         return ACPI_SUCCESS(status) ? 0 : -ENOENT;
     554                 :            : }
     555                 :            : 
     556                 :          0 : static int dmar_walk_remapping_entries(struct acpi_dmar_header *start,
     557                 :            :                                        size_t len, struct dmar_res_callback *cb)
     558                 :            : {
     559                 :          0 :         struct acpi_dmar_header *iter, *next;
     560                 :          0 :         struct acpi_dmar_header *end = ((void *)start) + len;
     561                 :            : 
     562         [ #  # ]:          0 :         for (iter = start; iter < end; iter = next) {
     563                 :          0 :                 next = (void *)iter + iter->length;
     564         [ #  # ]:          0 :                 if (iter->length == 0) {
     565                 :            :                         /* Avoid looping forever on bad ACPI tables */
     566                 :            :                         pr_debug(FW_BUG "Invalid 0-length structure\n");
     567                 :            :                         break;
     568         [ #  # ]:          0 :                 } else if (next > end) {
     569                 :            :                         /* Avoid passing table end */
     570                 :          0 :                         pr_warn(FW_BUG "Record passes table end\n");
     571                 :          0 :                         return -EINVAL;
     572                 :            :                 }
     573                 :            : 
     574         [ #  # ]:          0 :                 if (cb->print_entry)
     575                 :          0 :                         dmar_table_print_dmar_entry(iter);
     576                 :            : 
     577         [ #  # ]:          0 :                 if (iter->type >= ACPI_DMAR_TYPE_RESERVED) {
     578                 :            :                         /* continue for forward compatibility */
     579                 :            :                         pr_debug("Unknown DMAR structure type %d\n",
     580                 :            :                                  iter->type);
     581         [ #  # ]:          0 :                 } else if (cb->cb[iter->type]) {
     582                 :          0 :                         int ret;
     583                 :            : 
     584                 :          0 :                         ret = cb->cb[iter->type](iter, cb->arg[iter->type]);
     585         [ #  # ]:          0 :                         if (ret)
     586                 :          0 :                                 return ret;
     587         [ #  # ]:          0 :                 } else if (!cb->ignore_unhandled) {
     588                 :          0 :                         pr_warn("No handler for DMAR structure type %d\n",
     589                 :            :                                 iter->type);
     590                 :          0 :                         return -EINVAL;
     591                 :            :                 }
     592                 :            :         }
     593                 :            : 
     594                 :            :         return 0;
     595                 :            : }
     596                 :            : 
     597                 :          0 : static inline int dmar_walk_dmar_table(struct acpi_table_dmar *dmar,
     598                 :            :                                        struct dmar_res_callback *cb)
     599                 :            : {
     600                 :          0 :         return dmar_walk_remapping_entries((void *)(dmar + 1),
     601                 :          0 :                         dmar->header.length - sizeof(*dmar), cb);
     602                 :            : }
     603                 :            : 
     604                 :            : /**
     605                 :            :  * parse_dmar_table - parses the DMA reporting table
     606                 :            :  */
     607                 :            : static int __init
     608                 :          0 : parse_dmar_table(void)
     609                 :            : {
     610                 :          0 :         struct acpi_table_dmar *dmar;
     611                 :          0 :         int drhd_count = 0;
     612                 :          0 :         int ret;
     613                 :          0 :         struct dmar_res_callback cb = {
     614                 :            :                 .print_entry = true,
     615                 :            :                 .ignore_unhandled = true,
     616                 :            :                 .arg[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &drhd_count,
     617                 :            :                 .cb[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &dmar_parse_one_drhd,
     618                 :            :                 .cb[ACPI_DMAR_TYPE_RESERVED_MEMORY] = &dmar_parse_one_rmrr,
     619                 :            :                 .cb[ACPI_DMAR_TYPE_ROOT_ATS] = &dmar_parse_one_atsr,
     620                 :            :                 .cb[ACPI_DMAR_TYPE_HARDWARE_AFFINITY] = &dmar_parse_one_rhsa,
     621                 :            :                 .cb[ACPI_DMAR_TYPE_NAMESPACE] = &dmar_parse_one_andd,
     622                 :            :         };
     623                 :            : 
     624                 :            :         /*
     625                 :            :          * Do it again, earlier dmar_tbl mapping could be mapped with
     626                 :            :          * fixed map.
     627                 :            :          */
     628                 :          0 :         dmar_table_detect();
     629                 :            : 
     630                 :            :         /*
     631                 :            :          * ACPI tables may not be DMA protected by tboot, so use DMAR copy
     632                 :            :          * SINIT saved in SinitMleData in TXT heap (which is DMA protected)
     633                 :            :          */
     634                 :          0 :         dmar_tbl = tboot_get_dmar_table(dmar_tbl);
     635                 :            : 
     636                 :          0 :         dmar = (struct acpi_table_dmar *)dmar_tbl;
     637         [ #  # ]:          0 :         if (!dmar)
     638                 :            :                 return -ENODEV;
     639                 :            : 
     640         [ #  # ]:          0 :         if (dmar->width < PAGE_SHIFT - 1) {
     641                 :          0 :                 pr_warn("Invalid DMAR haw\n");
     642                 :          0 :                 return -EINVAL;
     643                 :            :         }
     644                 :            : 
     645                 :          0 :         pr_info("Host address width %d\n", dmar->width + 1);
     646                 :          0 :         ret = dmar_walk_dmar_table(dmar, &cb);
     647   [ #  #  #  # ]:          0 :         if (ret == 0 && drhd_count == 0)
     648                 :          0 :                 pr_warn(FW_BUG "No DRHD structure found in DMAR table\n");
     649                 :            : 
     650                 :            :         return ret;
     651                 :            : }
     652                 :            : 
     653                 :          0 : static int dmar_pci_device_match(struct dmar_dev_scope devices[],
     654                 :            :                                  int cnt, struct pci_dev *dev)
     655                 :            : {
     656                 :          0 :         int index;
     657                 :          0 :         struct device *tmp;
     658                 :            : 
     659         [ #  # ]:          0 :         while (dev) {
     660   [ #  #  #  #  :          0 :                 for_each_active_dev_scope(devices, cnt, index, tmp)
                   #  # ]
     661   [ #  #  #  # ]:          0 :                         if (dev_is_pci(tmp) && dev == to_pci_dev(tmp))
     662                 :            :                                 return 1;
     663                 :            : 
     664                 :            :                 /* Check our parent */
     665                 :          0 :                 dev = dev->bus->self;
     666                 :            :         }
     667                 :            : 
     668                 :            :         return 0;
     669                 :            : }
     670                 :            : 
     671                 :            : struct dmar_drhd_unit *
     672                 :          0 : dmar_find_matched_drhd_unit(struct pci_dev *dev)
     673                 :            : {
     674                 :          0 :         struct dmar_drhd_unit *dmaru;
     675                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     676                 :            : 
     677                 :          0 :         dev = pci_physfn(dev);
     678                 :            : 
     679                 :          0 :         rcu_read_lock();
     680         [ #  # ]:          0 :         for_each_drhd_unit(dmaru) {
     681                 :          0 :                 drhd = container_of(dmaru->hdr,
     682                 :            :                                     struct acpi_dmar_hardware_unit,
     683                 :            :                                     header);
     684                 :            : 
     685   [ #  #  #  # ]:          0 :                 if (dmaru->include_all &&
     686         [ #  # ]:          0 :                     drhd->segment == pci_domain_nr(dev->bus))
     687                 :          0 :                         goto out;
     688                 :            : 
     689         [ #  # ]:          0 :                 if (dmar_pci_device_match(dmaru->devices,
     690                 :            :                                           dmaru->devices_cnt, dev))
     691                 :          0 :                         goto out;
     692                 :            :         }
     693                 :            :         dmaru = NULL;
     694                 :          0 : out:
     695                 :          0 :         rcu_read_unlock();
     696                 :            : 
     697                 :          0 :         return dmaru;
     698                 :            : }
     699                 :            : 
     700                 :          0 : static void __init dmar_acpi_insert_dev_scope(u8 device_number,
     701                 :            :                                               struct acpi_device *adev)
     702                 :            : {
     703                 :          0 :         struct dmar_drhd_unit *dmaru;
     704                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     705                 :          0 :         struct acpi_dmar_device_scope *scope;
     706                 :          0 :         struct device *tmp;
     707                 :          0 :         int i;
     708                 :          0 :         struct acpi_dmar_pci_path *path;
     709                 :            : 
     710         [ #  # ]:          0 :         for_each_drhd_unit(dmaru) {
     711                 :          0 :                 drhd = container_of(dmaru->hdr,
     712                 :            :                                     struct acpi_dmar_hardware_unit,
     713                 :            :                                     header);
     714                 :            : 
     715                 :          0 :                 for (scope = (void *)(drhd + 1);
     716         [ #  # ]:          0 :                      (unsigned long)scope < ((unsigned long)drhd) + drhd->header.length;
     717                 :          0 :                      scope = ((void *)scope) + scope->length) {
     718         [ #  # ]:          0 :                         if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_NAMESPACE)
     719                 :          0 :                                 continue;
     720         [ #  # ]:          0 :                         if (scope->enumeration_id != device_number)
     721                 :          0 :                                 continue;
     722                 :            : 
     723                 :          0 :                         path = (void *)(scope + 1);
     724         [ #  # ]:          0 :                         pr_info("ACPI device \"%s\" under DMAR at %llx as %02x:%02x.%d\n",
     725                 :            :                                 dev_name(&adev->dev), dmaru->reg_base_addr,
     726                 :            :                                 scope->bus, path->device, path->function);
     727   [ #  #  #  # ]:          0 :                         for_each_dev_scope(dmaru->devices, dmaru->devices_cnt, i, tmp)
     728         [ #  # ]:          0 :                                 if (tmp == NULL) {
     729                 :          0 :                                         dmaru->devices[i].bus = scope->bus;
     730                 :          0 :                                         dmaru->devices[i].devfn = PCI_DEVFN(path->device,
     731                 :            :                                                                             path->function);
     732                 :          0 :                                         rcu_assign_pointer(dmaru->devices[i].dev,
     733                 :            :                                                            get_device(&adev->dev));
     734                 :          0 :                                         return;
     735                 :            :                                 }
     736                 :          0 :                         BUG_ON(i >= dmaru->devices_cnt);
     737                 :            :                 }
     738                 :            :         }
     739         [ #  # ]:          0 :         pr_warn("No IOMMU scope found for ANDD enumeration ID %d (%s)\n",
     740                 :            :                 device_number, dev_name(&adev->dev));
     741                 :            : }
     742                 :            : 
     743                 :          0 : static int __init dmar_acpi_dev_scope_init(void)
     744                 :            : {
     745                 :          0 :         struct acpi_dmar_andd *andd;
     746                 :            : 
     747         [ #  # ]:          0 :         if (dmar_tbl == NULL)
     748                 :            :                 return -ENODEV;
     749                 :            : 
     750                 :          0 :         for (andd = (void *)dmar_tbl + sizeof(struct acpi_table_dmar);
     751         [ #  # ]:          0 :              ((unsigned long)andd) < ((unsigned long)dmar_tbl) + dmar_tbl->length;
     752                 :          0 :              andd = ((void *)andd) + andd->header.length) {
     753         [ #  # ]:          0 :                 if (andd->header.type == ACPI_DMAR_TYPE_NAMESPACE) {
     754                 :          0 :                         acpi_handle h;
     755                 :          0 :                         struct acpi_device *adev;
     756                 :            : 
     757         [ #  # ]:          0 :                         if (!ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT,
     758                 :            :                                                           andd->device_name,
     759                 :            :                                                           &h))) {
     760                 :          0 :                                 pr_err("Failed to find handle for ACPI object %s\n",
     761                 :            :                                        andd->device_name);
     762                 :          0 :                                 continue;
     763                 :            :                         }
     764         [ #  # ]:          0 :                         if (acpi_bus_get_device(h, &adev)) {
     765                 :          0 :                                 pr_err("Failed to get device for ACPI object %s\n",
     766                 :            :                                        andd->device_name);
     767                 :          0 :                                 continue;
     768                 :            :                         }
     769                 :          0 :                         dmar_acpi_insert_dev_scope(andd->device_number, adev);
     770                 :            :                 }
     771                 :            :         }
     772                 :            :         return 0;
     773                 :            : }
     774                 :            : 
     775                 :          0 : int __init dmar_dev_scope_init(void)
     776                 :            : {
     777                 :          0 :         struct pci_dev *dev = NULL;
     778                 :          0 :         struct dmar_pci_notify_info *info;
     779                 :            : 
     780         [ #  # ]:          0 :         if (dmar_dev_scope_status != 1)
     781                 :            :                 return dmar_dev_scope_status;
     782                 :            : 
     783         [ #  # ]:          0 :         if (list_empty(&dmar_drhd_units)) {
     784                 :          0 :                 dmar_dev_scope_status = -ENODEV;
     785                 :            :         } else {
     786                 :          0 :                 dmar_dev_scope_status = 0;
     787                 :            : 
     788                 :          0 :                 dmar_acpi_dev_scope_init();
     789                 :            : 
     790         [ #  # ]:          0 :                 for_each_pci_dev(dev) {
     791         [ #  # ]:          0 :                         if (dev->is_virtfn)
     792                 :          0 :                                 continue;
     793                 :            : 
     794                 :          0 :                         info = dmar_alloc_pci_notify_info(dev,
     795                 :            :                                         BUS_NOTIFY_ADD_DEVICE);
     796         [ #  # ]:          0 :                         if (!info) {
     797                 :          0 :                                 return dmar_dev_scope_status;
     798                 :            :                         } else {
     799                 :          0 :                                 dmar_pci_bus_add_dev(info);
     800         [ #  # ]:          0 :                                 dmar_free_pci_notify_info(info);
     801                 :            :                         }
     802                 :            :                 }
     803                 :            :         }
     804                 :            : 
     805                 :          0 :         return dmar_dev_scope_status;
     806                 :            : }
     807                 :            : 
     808                 :          0 : void __init dmar_register_bus_notifier(void)
     809                 :            : {
     810                 :          0 :         bus_register_notifier(&pci_bus_type, &dmar_pci_bus_nb);
     811                 :          0 : }
     812                 :            : 
     813                 :            : 
     814                 :          0 : int __init dmar_table_init(void)
     815                 :            : {
     816                 :          0 :         static int dmar_table_initialized;
     817                 :          0 :         int ret;
     818                 :            : 
     819         [ #  # ]:          0 :         if (dmar_table_initialized == 0) {
     820                 :          0 :                 ret = parse_dmar_table();
     821         [ #  # ]:          0 :                 if (ret < 0) {
     822         [ #  # ]:          0 :                         if (ret != -ENODEV)
     823                 :          0 :                                 pr_info("Parse DMAR table failure.\n");
     824         [ #  # ]:          0 :                 } else  if (list_empty(&dmar_drhd_units)) {
     825                 :          0 :                         pr_info("No DMAR devices found\n");
     826                 :          0 :                         ret = -ENODEV;
     827                 :            :                 }
     828                 :            : 
     829         [ #  # ]:          0 :                 if (ret < 0)
     830                 :          0 :                         dmar_table_initialized = ret;
     831                 :            :                 else
     832                 :          0 :                         dmar_table_initialized = 1;
     833                 :            :         }
     834                 :            : 
     835                 :          0 :         return dmar_table_initialized < 0 ? dmar_table_initialized : 0;
     836                 :            : }
     837                 :            : 
     838                 :          0 : static void warn_invalid_dmar(u64 addr, const char *message)
     839                 :            : {
     840         [ #  # ]:          0 :         pr_warn_once(FW_BUG
     841                 :            :                 "Your BIOS is broken; DMAR reported at address %llx%s!\n"
     842                 :            :                 "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
     843                 :            :                 addr, message,
     844                 :            :                 dmi_get_system_info(DMI_BIOS_VENDOR),
     845                 :            :                 dmi_get_system_info(DMI_BIOS_VERSION),
     846                 :            :                 dmi_get_system_info(DMI_PRODUCT_VERSION));
     847                 :          0 :         add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
     848                 :          0 : }
     849                 :            : 
     850                 :            : static int __ref
     851                 :          0 : dmar_validate_one_drhd(struct acpi_dmar_header *entry, void *arg)
     852                 :            : {
     853                 :          0 :         struct acpi_dmar_hardware_unit *drhd;
     854                 :          0 :         void __iomem *addr;
     855                 :          0 :         u64 cap, ecap;
     856                 :            : 
     857                 :          0 :         drhd = (void *)entry;
     858         [ #  # ]:          0 :         if (!drhd->address) {
     859                 :          0 :                 warn_invalid_dmar(0, "");
     860                 :          0 :                 return -EINVAL;
     861                 :            :         }
     862                 :            : 
     863         [ #  # ]:          0 :         if (arg)
     864                 :          0 :                 addr = ioremap(drhd->address, VTD_PAGE_SIZE);
     865                 :            :         else
     866                 :          0 :                 addr = early_ioremap(drhd->address, VTD_PAGE_SIZE);
     867         [ #  # ]:          0 :         if (!addr) {
     868                 :          0 :                 pr_warn("Can't validate DRHD address: %llx\n", drhd->address);
     869                 :          0 :                 return -EINVAL;
     870                 :            :         }
     871                 :            : 
     872                 :          0 :         cap = dmar_readq(addr + DMAR_CAP_REG);
     873                 :          0 :         ecap = dmar_readq(addr + DMAR_ECAP_REG);
     874                 :            : 
     875         [ #  # ]:          0 :         if (arg)
     876                 :          0 :                 iounmap(addr);
     877                 :            :         else
     878                 :          0 :                 early_iounmap(addr, VTD_PAGE_SIZE);
     879                 :            : 
     880         [ #  # ]:          0 :         if (cap == (uint64_t)-1 && ecap == (uint64_t)-1) {
     881                 :          0 :                 warn_invalid_dmar(drhd->address, " returns all ones");
     882                 :          0 :                 return -EINVAL;
     883                 :            :         }
     884                 :            : 
     885                 :            :         return 0;
     886                 :            : }
     887                 :            : 
     888                 :          3 : int __init detect_intel_iommu(void)
     889                 :            : {
     890                 :          3 :         int ret;
     891                 :          3 :         struct dmar_res_callback validate_drhd_cb = {
     892                 :            :                 .cb[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &dmar_validate_one_drhd,
     893                 :            :                 .ignore_unhandled = true,
     894                 :            :         };
     895                 :            : 
     896                 :          3 :         down_write(&dmar_global_lock);
     897                 :          3 :         ret = dmar_table_detect();
     898         [ -  + ]:          3 :         if (!ret)
     899                 :          0 :                 ret = dmar_walk_dmar_table((struct acpi_table_dmar *)dmar_tbl,
     900                 :            :                                            &validate_drhd_cb);
     901   [ -  +  -  -  :          3 :         if (!ret && !no_iommu && !iommu_detected && !dmar_disabled) {
             -  -  -  - ]
     902                 :          0 :                 iommu_detected = 1;
     903                 :            :                 /* Make sure ACS will be enabled */
     904                 :          0 :                 pci_request_acs();
     905                 :            :         }
     906                 :            : 
     907                 :            : #ifdef CONFIG_X86
     908         [ -  + ]:          3 :         if (!ret) {
     909                 :          0 :                 x86_init.iommu.iommu_init = intel_iommu_init;
     910                 :          0 :                 x86_platform.iommu_shutdown = intel_iommu_shutdown;
     911                 :            :         }
     912                 :            : 
     913                 :            : #endif
     914                 :            : 
     915         [ -  + ]:          3 :         if (dmar_tbl) {
     916                 :          0 :                 acpi_put_table(dmar_tbl);
     917                 :          0 :                 dmar_tbl = NULL;
     918                 :            :         }
     919                 :          3 :         up_write(&dmar_global_lock);
     920                 :            : 
     921         [ -  + ]:          3 :         return ret ? ret : 1;
     922                 :            : }
     923                 :            : 
     924                 :          0 : static void unmap_iommu(struct intel_iommu *iommu)
     925                 :            : {
     926                 :          0 :         iounmap(iommu->reg);
     927                 :          0 :         release_mem_region(iommu->reg_phys, iommu->reg_size);
     928                 :          0 : }
     929                 :            : 
     930                 :            : /**
     931                 :            :  * map_iommu: map the iommu's registers
     932                 :            :  * @iommu: the iommu to map
     933                 :            :  * @phys_addr: the physical address of the base resgister
     934                 :            :  *
     935                 :            :  * Memory map the iommu's registers.  Start w/ a single page, and
     936                 :            :  * possibly expand if that turns out to be insufficent.
     937                 :            :  */
     938                 :          0 : static int map_iommu(struct intel_iommu *iommu, u64 phys_addr)
     939                 :            : {
     940                 :          0 :         int map_size, err=0;
     941                 :            : 
     942                 :          0 :         iommu->reg_phys = phys_addr;
     943                 :          0 :         iommu->reg_size = VTD_PAGE_SIZE;
     944                 :            : 
     945         [ #  # ]:          0 :         if (!request_mem_region(iommu->reg_phys, iommu->reg_size, iommu->name)) {
     946                 :          0 :                 pr_err("Can't reserve memory\n");
     947                 :          0 :                 err = -EBUSY;
     948                 :          0 :                 goto out;
     949                 :            :         }
     950                 :            : 
     951                 :          0 :         iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
     952         [ #  # ]:          0 :         if (!iommu->reg) {
     953                 :          0 :                 pr_err("Can't map the region\n");
     954                 :          0 :                 err = -ENOMEM;
     955                 :          0 :                 goto release;
     956                 :            :         }
     957                 :            : 
     958                 :          0 :         iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
     959                 :          0 :         iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
     960                 :            : 
     961   [ #  #  #  # ]:          0 :         if (iommu->cap == (uint64_t)-1 && iommu->ecap == (uint64_t)-1) {
     962                 :          0 :                 err = -EINVAL;
     963                 :          0 :                 warn_invalid_dmar(phys_addr, " returns all ones");
     964                 :          0 :                 goto unmap;
     965                 :            :         }
     966                 :            : 
     967                 :            :         /* the registers might be more than one page */
     968                 :          0 :         map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
     969                 :            :                          cap_max_fault_reg_offset(iommu->cap));
     970                 :          0 :         map_size = VTD_PAGE_ALIGN(map_size);
     971         [ #  # ]:          0 :         if (map_size > iommu->reg_size) {
     972                 :          0 :                 iounmap(iommu->reg);
     973                 :          0 :                 release_mem_region(iommu->reg_phys, iommu->reg_size);
     974                 :          0 :                 iommu->reg_size = map_size;
     975         [ #  # ]:          0 :                 if (!request_mem_region(iommu->reg_phys, iommu->reg_size,
     976                 :            :                                         iommu->name)) {
     977                 :          0 :                         pr_err("Can't reserve memory\n");
     978                 :          0 :                         err = -EBUSY;
     979                 :          0 :                         goto out;
     980                 :            :                 }
     981                 :          0 :                 iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
     982         [ #  # ]:          0 :                 if (!iommu->reg) {
     983                 :          0 :                         pr_err("Can't map the region\n");
     984                 :          0 :                         err = -ENOMEM;
     985                 :          0 :                         goto release;
     986                 :            :                 }
     987                 :            :         }
     988                 :          0 :         err = 0;
     989                 :          0 :         goto out;
     990                 :            : 
     991                 :            : unmap:
     992                 :          0 :         iounmap(iommu->reg);
     993                 :          0 : release:
     994                 :          0 :         release_mem_region(iommu->reg_phys, iommu->reg_size);
     995                 :          0 : out:
     996                 :          0 :         return err;
     997                 :            : }
     998                 :            : 
     999                 :          0 : static int dmar_alloc_seq_id(struct intel_iommu *iommu)
    1000                 :            : {
    1001                 :          0 :         iommu->seq_id = find_first_zero_bit(dmar_seq_ids,
    1002                 :            :                                             DMAR_UNITS_SUPPORTED);
    1003         [ #  # ]:          0 :         if (iommu->seq_id >= DMAR_UNITS_SUPPORTED) {
    1004                 :          0 :                 iommu->seq_id = -1;
    1005                 :            :         } else {
    1006                 :          0 :                 set_bit(iommu->seq_id, dmar_seq_ids);
    1007                 :          0 :                 sprintf(iommu->name, "dmar%d", iommu->seq_id);
    1008                 :            :         }
    1009                 :            : 
    1010                 :          0 :         return iommu->seq_id;
    1011                 :            : }
    1012                 :            : 
    1013                 :          0 : static void dmar_free_seq_id(struct intel_iommu *iommu)
    1014                 :            : {
    1015                 :          0 :         if (iommu->seq_id >= 0) {
    1016                 :          0 :                 clear_bit(iommu->seq_id, dmar_seq_ids);
    1017                 :          0 :                 iommu->seq_id = -1;
    1018                 :            :         }
    1019                 :            : }
    1020                 :            : 
    1021                 :          0 : static int alloc_iommu(struct dmar_drhd_unit *drhd)
    1022                 :            : {
    1023                 :          0 :         struct intel_iommu *iommu;
    1024                 :          0 :         u32 ver, sts;
    1025                 :          0 :         int agaw = 0;
    1026                 :          0 :         int msagaw = 0;
    1027                 :          0 :         int err;
    1028                 :            : 
    1029         [ #  # ]:          0 :         if (!drhd->reg_base_addr) {
    1030                 :          0 :                 warn_invalid_dmar(0, "");
    1031                 :          0 :                 return -EINVAL;
    1032                 :            :         }
    1033                 :            : 
    1034                 :          0 :         iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
    1035         [ #  # ]:          0 :         if (!iommu)
    1036                 :            :                 return -ENOMEM;
    1037                 :            : 
    1038         [ #  # ]:          0 :         if (dmar_alloc_seq_id(iommu) < 0) {
    1039                 :          0 :                 pr_err("Failed to allocate seq_id\n");
    1040                 :          0 :                 err = -ENOSPC;
    1041                 :          0 :                 goto error;
    1042                 :            :         }
    1043                 :            : 
    1044                 :          0 :         err = map_iommu(iommu, drhd->reg_base_addr);
    1045         [ #  # ]:          0 :         if (err) {
    1046                 :          0 :                 pr_err("Failed to map %s\n", iommu->name);
    1047                 :          0 :                 goto error_free_seq_id;
    1048                 :            :         }
    1049                 :            : 
    1050                 :          0 :         err = -EINVAL;
    1051                 :          0 :         agaw = iommu_calculate_agaw(iommu);
    1052         [ #  # ]:          0 :         if (agaw < 0) {
    1053                 :          0 :                 pr_err("Cannot get a valid agaw for iommu (seq_id = %d)\n",
    1054                 :            :                         iommu->seq_id);
    1055                 :          0 :                 goto err_unmap;
    1056                 :            :         }
    1057                 :          0 :         msagaw = iommu_calculate_max_sagaw(iommu);
    1058         [ #  # ]:          0 :         if (msagaw < 0) {
    1059                 :          0 :                 pr_err("Cannot get a valid max agaw for iommu (seq_id = %d)\n",
    1060                 :            :                         iommu->seq_id);
    1061                 :          0 :                 goto err_unmap;
    1062                 :            :         }
    1063                 :          0 :         iommu->agaw = agaw;
    1064                 :          0 :         iommu->msagaw = msagaw;
    1065                 :          0 :         iommu->segment = drhd->segment;
    1066                 :            : 
    1067                 :          0 :         iommu->node = NUMA_NO_NODE;
    1068                 :            : 
    1069                 :          0 :         ver = readl(iommu->reg + DMAR_VER_REG);
    1070                 :          0 :         pr_info("%s: reg_base_addr %llx ver %d:%d cap %llx ecap %llx\n",
    1071                 :            :                 iommu->name,
    1072                 :            :                 (unsigned long long)drhd->reg_base_addr,
    1073                 :            :                 DMAR_VER_MAJOR(ver), DMAR_VER_MINOR(ver),
    1074                 :            :                 (unsigned long long)iommu->cap,
    1075                 :            :                 (unsigned long long)iommu->ecap);
    1076                 :            : 
    1077                 :            :         /* Reflect status in gcmd */
    1078                 :          0 :         sts = readl(iommu->reg + DMAR_GSTS_REG);
    1079         [ #  # ]:          0 :         if (sts & DMA_GSTS_IRES)
    1080                 :          0 :                 iommu->gcmd |= DMA_GCMD_IRE;
    1081         [ #  # ]:          0 :         if (sts & DMA_GSTS_TES)
    1082                 :          0 :                 iommu->gcmd |= DMA_GCMD_TE;
    1083         [ #  # ]:          0 :         if (sts & DMA_GSTS_QIES)
    1084                 :          0 :                 iommu->gcmd |= DMA_GCMD_QIE;
    1085                 :            : 
    1086                 :          0 :         raw_spin_lock_init(&iommu->register_lock);
    1087                 :            : 
    1088         [ #  # ]:          0 :         if (intel_iommu_enabled) {
    1089                 :          0 :                 err = iommu_device_sysfs_add(&iommu->iommu, NULL,
    1090                 :            :                                              intel_iommu_groups,
    1091                 :            :                                              "%s", iommu->name);
    1092         [ #  # ]:          0 :                 if (err)
    1093                 :          0 :                         goto err_unmap;
    1094                 :            : 
    1095                 :          0 :                 iommu_device_set_ops(&iommu->iommu, &intel_iommu_ops);
    1096                 :            : 
    1097                 :          0 :                 err = iommu_device_register(&iommu->iommu);
    1098         [ #  # ]:          0 :                 if (err)
    1099                 :          0 :                         goto err_unmap;
    1100                 :            :         }
    1101                 :            : 
    1102                 :          0 :         drhd->iommu = iommu;
    1103                 :            : 
    1104                 :          0 :         return 0;
    1105                 :            : 
    1106                 :          0 : err_unmap:
    1107                 :          0 :         unmap_iommu(iommu);
    1108                 :          0 : error_free_seq_id:
    1109         [ #  # ]:          0 :         dmar_free_seq_id(iommu);
    1110                 :          0 : error:
    1111                 :          0 :         kfree(iommu);
    1112                 :          0 :         return err;
    1113                 :            : }
    1114                 :            : 
    1115                 :          0 : static void free_iommu(struct intel_iommu *iommu)
    1116                 :            : {
    1117         [ #  # ]:          0 :         if (intel_iommu_enabled) {
    1118                 :          0 :                 iommu_device_unregister(&iommu->iommu);
    1119                 :          0 :                 iommu_device_sysfs_remove(&iommu->iommu);
    1120                 :            :         }
    1121                 :            : 
    1122         [ #  # ]:          0 :         if (iommu->irq) {
    1123         [ #  # ]:          0 :                 if (iommu->pr_irq) {
    1124                 :          0 :                         free_irq(iommu->pr_irq, iommu);
    1125                 :          0 :                         dmar_free_hwirq(iommu->pr_irq);
    1126                 :          0 :                         iommu->pr_irq = 0;
    1127                 :            :                 }
    1128                 :          0 :                 free_irq(iommu->irq, iommu);
    1129                 :          0 :                 dmar_free_hwirq(iommu->irq);
    1130                 :          0 :                 iommu->irq = 0;
    1131                 :            :         }
    1132                 :            : 
    1133         [ #  # ]:          0 :         if (iommu->qi) {
    1134                 :          0 :                 free_page((unsigned long)iommu->qi->desc);
    1135                 :          0 :                 kfree(iommu->qi->desc_status);
    1136                 :          0 :                 kfree(iommu->qi);
    1137                 :            :         }
    1138                 :            : 
    1139         [ #  # ]:          0 :         if (iommu->reg)
    1140                 :          0 :                 unmap_iommu(iommu);
    1141                 :            : 
    1142         [ #  # ]:          0 :         dmar_free_seq_id(iommu);
    1143                 :          0 :         kfree(iommu);
    1144                 :          0 : }
    1145                 :            : 
    1146                 :            : /*
    1147                 :            :  * Reclaim all the submitted descriptors which have completed its work.
    1148                 :            :  */
    1149                 :          0 : static inline void reclaim_free_desc(struct q_inval *qi)
    1150                 :            : {
    1151         [ #  # ]:          0 :         while (qi->desc_status[qi->free_tail] == QI_DONE ||
    1152                 :            :                qi->desc_status[qi->free_tail] == QI_ABORT) {
    1153                 :          0 :                 qi->desc_status[qi->free_tail] = QI_FREE;
    1154                 :          0 :                 qi->free_tail = (qi->free_tail + 1) % QI_LENGTH;
    1155                 :          0 :                 qi->free_cnt++;
    1156                 :            :         }
    1157                 :            : }
    1158                 :            : 
    1159                 :          0 : static int qi_check_fault(struct intel_iommu *iommu, int index)
    1160                 :            : {
    1161                 :          0 :         u32 fault;
    1162                 :          0 :         int head, tail;
    1163                 :          0 :         struct q_inval *qi = iommu->qi;
    1164                 :          0 :         int wait_index = (index + 1) % QI_LENGTH;
    1165         [ #  # ]:          0 :         int shift = qi_shift(iommu);
    1166                 :            : 
    1167         [ #  # ]:          0 :         if (qi->desc_status[wait_index] == QI_ABORT)
    1168                 :            :                 return -EAGAIN;
    1169                 :            : 
    1170                 :          0 :         fault = readl(iommu->reg + DMAR_FSTS_REG);
    1171                 :            : 
    1172                 :            :         /*
    1173                 :            :          * If IQE happens, the head points to the descriptor associated
    1174                 :            :          * with the error. No new descriptors are fetched until the IQE
    1175                 :            :          * is cleared.
    1176                 :            :          */
    1177         [ #  # ]:          0 :         if (fault & DMA_FSTS_IQE) {
    1178                 :          0 :                 head = readl(iommu->reg + DMAR_IQH_REG);
    1179         [ #  # ]:          0 :                 if ((head >> shift) == index) {
    1180                 :          0 :                         struct qi_desc *desc = qi->desc + head;
    1181                 :            : 
    1182                 :            :                         /*
    1183                 :            :                          * desc->qw2 and desc->qw3 are either reserved or
    1184                 :            :                          * used by software as private data. We won't print
    1185                 :            :                          * out these two qw's for security consideration.
    1186                 :            :                          */
    1187                 :          0 :                         pr_err("VT-d detected invalid descriptor: qw0 = %llx, qw1 = %llx\n",
    1188                 :            :                                (unsigned long long)desc->qw0,
    1189                 :            :                                (unsigned long long)desc->qw1);
    1190                 :          0 :                         memcpy(desc, qi->desc + (wait_index << shift),
    1191                 :          0 :                                1 << shift);
    1192                 :          0 :                         writel(DMA_FSTS_IQE, iommu->reg + DMAR_FSTS_REG);
    1193                 :          0 :                         return -EINVAL;
    1194                 :            :                 }
    1195                 :            :         }
    1196                 :            : 
    1197                 :            :         /*
    1198                 :            :          * If ITE happens, all pending wait_desc commands are aborted.
    1199                 :            :          * No new descriptors are fetched until the ITE is cleared.
    1200                 :            :          */
    1201         [ #  # ]:          0 :         if (fault & DMA_FSTS_ITE) {
    1202                 :          0 :                 head = readl(iommu->reg + DMAR_IQH_REG);
    1203                 :          0 :                 head = ((head >> shift) - 1 + QI_LENGTH) % QI_LENGTH;
    1204                 :          0 :                 head |= 1;
    1205                 :          0 :                 tail = readl(iommu->reg + DMAR_IQT_REG);
    1206                 :          0 :                 tail = ((tail >> shift) - 1 + QI_LENGTH) % QI_LENGTH;
    1207                 :            : 
    1208                 :          0 :                 writel(DMA_FSTS_ITE, iommu->reg + DMAR_FSTS_REG);
    1209                 :            : 
    1210                 :          0 :                 do {
    1211         [ #  # ]:          0 :                         if (qi->desc_status[head] == QI_IN_USE)
    1212                 :          0 :                                 qi->desc_status[head] = QI_ABORT;
    1213                 :          0 :                         head = (head - 2 + QI_LENGTH) % QI_LENGTH;
    1214         [ #  # ]:          0 :                 } while (head != tail);
    1215                 :            : 
    1216         [ #  # ]:          0 :                 if (qi->desc_status[wait_index] == QI_ABORT)
    1217                 :            :                         return -EAGAIN;
    1218                 :            :         }
    1219                 :            : 
    1220         [ #  # ]:          0 :         if (fault & DMA_FSTS_ICE)
    1221                 :          0 :                 writel(DMA_FSTS_ICE, iommu->reg + DMAR_FSTS_REG);
    1222                 :            : 
    1223                 :            :         return 0;
    1224                 :            : }
    1225                 :            : 
    1226                 :            : /*
    1227                 :            :  * Submit the queued invalidation descriptor to the remapping
    1228                 :            :  * hardware unit and wait for its completion.
    1229                 :            :  */
    1230                 :          0 : int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu)
    1231                 :            : {
    1232                 :          0 :         int rc;
    1233                 :          0 :         struct q_inval *qi = iommu->qi;
    1234                 :          0 :         int offset, shift, length;
    1235                 :          0 :         struct qi_desc wait_desc;
    1236                 :          0 :         int wait_index, index;
    1237                 :          0 :         unsigned long flags;
    1238                 :            : 
    1239         [ #  # ]:          0 :         if (!qi)
    1240                 :            :                 return 0;
    1241                 :            : 
    1242                 :          0 : restart:
    1243                 :          0 :         rc = 0;
    1244                 :            : 
    1245                 :          0 :         raw_spin_lock_irqsave(&qi->q_lock, flags);
    1246                 :          0 :         while (qi->free_cnt < 3) {
    1247                 :          0 :                 raw_spin_unlock_irqrestore(&qi->q_lock, flags);
    1248                 :          0 :                 cpu_relax();
    1249         [ #  # ]:          0 :                 raw_spin_lock_irqsave(&qi->q_lock, flags);
    1250                 :            :         }
    1251                 :            : 
    1252                 :          0 :         index = qi->free_head;
    1253                 :          0 :         wait_index = (index + 1) % QI_LENGTH;
    1254         [ #  # ]:          0 :         shift = qi_shift(iommu);
    1255                 :          0 :         length = 1 << shift;
    1256                 :            : 
    1257                 :          0 :         qi->desc_status[index] = qi->desc_status[wait_index] = QI_IN_USE;
    1258                 :            : 
    1259                 :          0 :         offset = index << shift;
    1260                 :          0 :         memcpy(qi->desc + offset, desc, length);
    1261                 :          0 :         wait_desc.qw0 = QI_IWD_STATUS_DATA(QI_DONE) |
    1262                 :            :                         QI_IWD_STATUS_WRITE | QI_IWD_TYPE;
    1263         [ #  # ]:          0 :         wait_desc.qw1 = virt_to_phys(&qi->desc_status[wait_index]);
    1264                 :          0 :         wait_desc.qw2 = 0;
    1265                 :          0 :         wait_desc.qw3 = 0;
    1266                 :            : 
    1267                 :          0 :         offset = wait_index << shift;
    1268                 :          0 :         memcpy(qi->desc + offset, &wait_desc, length);
    1269                 :            : 
    1270                 :          0 :         qi->free_head = (qi->free_head + 2) % QI_LENGTH;
    1271                 :          0 :         qi->free_cnt -= 2;
    1272                 :            : 
    1273                 :            :         /*
    1274                 :            :          * update the HW tail register indicating the presence of
    1275                 :            :          * new descriptors.
    1276                 :            :          */
    1277                 :          0 :         writel(qi->free_head << shift, iommu->reg + DMAR_IQT_REG);
    1278                 :            : 
    1279         [ #  # ]:          0 :         while (qi->desc_status[wait_index] != QI_DONE) {
    1280                 :            :                 /*
    1281                 :            :                  * We will leave the interrupts disabled, to prevent interrupt
    1282                 :            :                  * context to queue another cmd while a cmd is already submitted
    1283                 :            :                  * and waiting for completion on this cpu. This is to avoid
    1284                 :            :                  * a deadlock where the interrupt context can wait indefinitely
    1285                 :            :                  * for free slots in the queue.
    1286                 :            :                  */
    1287                 :          0 :                 rc = qi_check_fault(iommu, index);
    1288         [ #  # ]:          0 :                 if (rc)
    1289                 :            :                         break;
    1290                 :            : 
    1291                 :          0 :                 raw_spin_unlock(&qi->q_lock);
    1292                 :          0 :                 cpu_relax();
    1293                 :          0 :                 raw_spin_lock(&qi->q_lock);
    1294                 :            :         }
    1295                 :            : 
    1296                 :          0 :         qi->desc_status[index] = QI_DONE;
    1297                 :            : 
    1298                 :          0 :         reclaim_free_desc(qi);
    1299                 :          0 :         raw_spin_unlock_irqrestore(&qi->q_lock, flags);
    1300                 :            : 
    1301         [ #  # ]:          0 :         if (rc == -EAGAIN)
    1302                 :          0 :                 goto restart;
    1303                 :            : 
    1304                 :            :         return rc;
    1305                 :            : }
    1306                 :            : 
    1307                 :            : /*
    1308                 :            :  * Flush the global interrupt entry cache.
    1309                 :            :  */
    1310                 :          0 : void qi_global_iec(struct intel_iommu *iommu)
    1311                 :            : {
    1312                 :          0 :         struct qi_desc desc;
    1313                 :            : 
    1314                 :          0 :         desc.qw0 = QI_IEC_TYPE;
    1315                 :          0 :         desc.qw1 = 0;
    1316                 :          0 :         desc.qw2 = 0;
    1317                 :          0 :         desc.qw3 = 0;
    1318                 :            : 
    1319                 :            :         /* should never fail */
    1320                 :          0 :         qi_submit_sync(&desc, iommu);
    1321                 :          0 : }
    1322                 :            : 
    1323                 :          0 : void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm,
    1324                 :            :                       u64 type)
    1325                 :            : {
    1326                 :          0 :         struct qi_desc desc;
    1327                 :            : 
    1328                 :          0 :         desc.qw0 = QI_CC_FM(fm) | QI_CC_SID(sid) | QI_CC_DID(did)
    1329                 :          0 :                         | QI_CC_GRAN(type) | QI_CC_TYPE;
    1330                 :          0 :         desc.qw1 = 0;
    1331                 :          0 :         desc.qw2 = 0;
    1332                 :          0 :         desc.qw3 = 0;
    1333                 :            : 
    1334                 :          0 :         qi_submit_sync(&desc, iommu);
    1335                 :          0 : }
    1336                 :            : 
    1337                 :          0 : void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
    1338                 :            :                     unsigned int size_order, u64 type)
    1339                 :            : {
    1340                 :          0 :         u8 dw = 0, dr = 0;
    1341                 :            : 
    1342                 :          0 :         struct qi_desc desc;
    1343                 :          0 :         int ih = 0;
    1344                 :            : 
    1345         [ #  # ]:          0 :         if (cap_write_drain(iommu->cap))
    1346                 :          0 :                 dw = 1;
    1347                 :            : 
    1348         [ #  # ]:          0 :         if (cap_read_drain(iommu->cap))
    1349                 :          0 :                 dr = 1;
    1350                 :            : 
    1351                 :          0 :         desc.qw0 = QI_IOTLB_DID(did) | QI_IOTLB_DR(dr) | QI_IOTLB_DW(dw)
    1352                 :          0 :                 | QI_IOTLB_GRAN(type) | QI_IOTLB_TYPE;
    1353                 :          0 :         desc.qw1 = QI_IOTLB_ADDR(addr) | QI_IOTLB_IH(ih)
    1354                 :          0 :                 | QI_IOTLB_AM(size_order);
    1355                 :          0 :         desc.qw2 = 0;
    1356                 :          0 :         desc.qw3 = 0;
    1357                 :            : 
    1358                 :          0 :         qi_submit_sync(&desc, iommu);
    1359                 :          0 : }
    1360                 :            : 
    1361                 :          0 : void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid,
    1362                 :            :                         u16 qdep, u64 addr, unsigned mask)
    1363                 :            : {
    1364                 :          0 :         struct qi_desc desc;
    1365                 :            : 
    1366         [ #  # ]:          0 :         if (mask) {
    1367                 :          0 :                 addr |= (1ULL << (VTD_PAGE_SHIFT + mask - 1)) - 1;
    1368                 :          0 :                 desc.qw1 = QI_DEV_IOTLB_ADDR(addr) | QI_DEV_IOTLB_SIZE;
    1369                 :            :         } else
    1370                 :          0 :                 desc.qw1 = QI_DEV_IOTLB_ADDR(addr);
    1371                 :            : 
    1372         [ #  # ]:          0 :         if (qdep >= QI_DEV_IOTLB_MAX_INVS)
    1373                 :          0 :                 qdep = 0;
    1374                 :            : 
    1375                 :          0 :         desc.qw0 = QI_DEV_IOTLB_SID(sid) | QI_DEV_IOTLB_QDEP(qdep) |
    1376                 :          0 :                    QI_DIOTLB_TYPE | QI_DEV_IOTLB_PFSID(pfsid);
    1377                 :          0 :         desc.qw2 = 0;
    1378                 :          0 :         desc.qw3 = 0;
    1379                 :            : 
    1380                 :          0 :         qi_submit_sync(&desc, iommu);
    1381                 :          0 : }
    1382                 :            : 
    1383                 :            : /* PASID-based IOTLB invalidation */
    1384                 :          0 : void qi_flush_piotlb(struct intel_iommu *iommu, u16 did, u32 pasid, u64 addr,
    1385                 :            :                      unsigned long npages, bool ih)
    1386                 :            : {
    1387                 :          0 :         struct qi_desc desc = {.qw2 = 0, .qw3 = 0};
    1388                 :            : 
    1389                 :            :         /*
    1390                 :            :          * npages == -1 means a PASID-selective invalidation, otherwise,
    1391                 :            :          * a positive value for Page-selective-within-PASID invalidation.
    1392                 :            :          * 0 is not a valid input.
    1393                 :            :          */
    1394   [ #  #  #  # ]:          0 :         if (WARN_ON(!npages)) {
    1395                 :          0 :                 pr_err("Invalid input npages = %ld\n", npages);
    1396                 :          0 :                 return;
    1397                 :            :         }
    1398                 :            : 
    1399         [ #  # ]:          0 :         if (npages == -1) {
    1400                 :          0 :                 desc.qw0 = QI_EIOTLB_PASID(pasid) |
    1401                 :          0 :                                 QI_EIOTLB_DID(did) |
    1402                 :          0 :                                 QI_EIOTLB_GRAN(QI_GRAN_NONG_PASID) |
    1403                 :            :                                 QI_EIOTLB_TYPE;
    1404                 :          0 :                 desc.qw1 = 0;
    1405                 :            :         } else {
    1406   [ #  #  #  #  :          0 :                 int mask = ilog2(__roundup_pow_of_two(npages));
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1407                 :          0 :                 unsigned long align = (1ULL << (VTD_PAGE_SHIFT + mask));
    1408                 :            : 
    1409   [ #  #  #  # ]:          0 :                 if (WARN_ON_ONCE(!ALIGN(addr, align)))
    1410                 :          0 :                         addr &= ~(align - 1);
    1411                 :            : 
    1412                 :          0 :                 desc.qw0 = QI_EIOTLB_PASID(pasid) |
    1413                 :          0 :                                 QI_EIOTLB_DID(did) |
    1414                 :          0 :                                 QI_EIOTLB_GRAN(QI_GRAN_PSI_PASID) |
    1415                 :            :                                 QI_EIOTLB_TYPE;
    1416                 :          0 :                 desc.qw1 = QI_EIOTLB_ADDR(addr) |
    1417                 :          0 :                                 QI_EIOTLB_IH(ih) |
    1418                 :          0 :                                 QI_EIOTLB_AM(mask);
    1419                 :            :         }
    1420                 :            : 
    1421                 :          0 :         qi_submit_sync(&desc, iommu);
    1422                 :            : }
    1423                 :            : 
    1424                 :            : /*
    1425                 :            :  * Disable Queued Invalidation interface.
    1426                 :            :  */
    1427                 :          0 : void dmar_disable_qi(struct intel_iommu *iommu)
    1428                 :            : {
    1429                 :          0 :         unsigned long flags;
    1430                 :          0 :         u32 sts;
    1431                 :          0 :         cycles_t start_time = get_cycles();
    1432                 :            : 
    1433         [ #  # ]:          0 :         if (!ecap_qis(iommu->ecap))
    1434                 :            :                 return;
    1435                 :            : 
    1436                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flags);
    1437                 :            : 
    1438                 :          0 :         sts =  readl(iommu->reg + DMAR_GSTS_REG);
    1439         [ #  # ]:          0 :         if (!(sts & DMA_GSTS_QIES))
    1440                 :          0 :                 goto end;
    1441                 :            : 
    1442                 :            :         /*
    1443                 :            :          * Give a chance to HW to complete the pending invalidation requests.
    1444                 :            :          */
    1445         [ #  # ]:          0 :         while ((readl(iommu->reg + DMAR_IQT_REG) !=
    1446                 :          0 :                 readl(iommu->reg + DMAR_IQH_REG)) &&
    1447         [ #  # ]:          0 :                 (DMAR_OPERATION_TIMEOUT > (get_cycles() - start_time)))
    1448                 :          0 :                 cpu_relax();
    1449                 :            : 
    1450                 :          0 :         iommu->gcmd &= ~DMA_GCMD_QIE;
    1451                 :          0 :         writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
    1452                 :            : 
    1453   [ #  #  #  # ]:          0 :         IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, readl,
    1454                 :            :                       !(sts & DMA_GSTS_QIES), sts);
    1455                 :          0 : end:
    1456                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
    1457                 :            : }
    1458                 :            : 
    1459                 :            : /*
    1460                 :            :  * Enable queued invalidation.
    1461                 :            :  */
    1462                 :          0 : static void __dmar_enable_qi(struct intel_iommu *iommu)
    1463                 :            : {
    1464                 :          0 :         u32 sts;
    1465                 :          0 :         unsigned long flags;
    1466                 :          0 :         struct q_inval *qi = iommu->qi;
    1467         [ #  # ]:          0 :         u64 val = virt_to_phys(qi->desc);
    1468                 :            : 
    1469                 :          0 :         qi->free_head = qi->free_tail = 0;
    1470                 :          0 :         qi->free_cnt = QI_LENGTH;
    1471                 :            : 
    1472                 :            :         /*
    1473                 :            :          * Set DW=1 and QS=1 in IQA_REG when Scalable Mode capability
    1474                 :            :          * is present.
    1475                 :            :          */
    1476         [ #  # ]:          0 :         if (ecap_smts(iommu->ecap))
    1477                 :          0 :                 val |= (1 << 11) | 1;
    1478                 :            : 
    1479                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flags);
    1480                 :            : 
    1481                 :            :         /* write zero to the tail reg */
    1482                 :          0 :         writel(0, iommu->reg + DMAR_IQT_REG);
    1483                 :            : 
    1484                 :          0 :         dmar_writeq(iommu->reg + DMAR_IQA_REG, val);
    1485                 :            : 
    1486                 :          0 :         iommu->gcmd |= DMA_GCMD_QIE;
    1487                 :          0 :         writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
    1488                 :            : 
    1489                 :            :         /* Make sure hardware complete it */
    1490   [ #  #  #  # ]:          0 :         IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, readl, (sts & DMA_GSTS_QIES), sts);
    1491                 :            : 
    1492                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
    1493                 :          0 : }
    1494                 :            : 
    1495                 :            : /*
    1496                 :            :  * Enable Queued Invalidation interface. This is a must to support
    1497                 :            :  * interrupt-remapping. Also used by DMA-remapping, which replaces
    1498                 :            :  * register based IOTLB invalidation.
    1499                 :            :  */
    1500                 :          0 : int dmar_enable_qi(struct intel_iommu *iommu)
    1501                 :            : {
    1502                 :          0 :         struct q_inval *qi;
    1503                 :          0 :         struct page *desc_page;
    1504                 :            : 
    1505         [ #  # ]:          0 :         if (!ecap_qis(iommu->ecap))
    1506                 :            :                 return -ENOENT;
    1507                 :            : 
    1508                 :            :         /*
    1509                 :            :          * queued invalidation is already setup and enabled.
    1510                 :            :          */
    1511         [ #  # ]:          0 :         if (iommu->qi)
    1512                 :            :                 return 0;
    1513                 :            : 
    1514                 :          0 :         iommu->qi = kmalloc(sizeof(*qi), GFP_ATOMIC);
    1515         [ #  # ]:          0 :         if (!iommu->qi)
    1516                 :            :                 return -ENOMEM;
    1517                 :            : 
    1518                 :          0 :         qi = iommu->qi;
    1519                 :            : 
    1520                 :            :         /*
    1521                 :            :          * Need two pages to accommodate 256 descriptors of 256 bits each
    1522                 :            :          * if the remapping hardware supports scalable mode translation.
    1523                 :            :          */
    1524                 :          0 :         desc_page = alloc_pages_node(iommu->node, GFP_ATOMIC | __GFP_ZERO,
    1525         [ #  # ]:          0 :                                      !!ecap_smts(iommu->ecap));
    1526         [ #  # ]:          0 :         if (!desc_page) {
    1527                 :          0 :                 kfree(qi);
    1528                 :          0 :                 iommu->qi = NULL;
    1529                 :          0 :                 return -ENOMEM;
    1530                 :            :         }
    1531                 :            : 
    1532                 :          0 :         qi->desc = page_address(desc_page);
    1533                 :            : 
    1534                 :          0 :         qi->desc_status = kcalloc(QI_LENGTH, sizeof(int), GFP_ATOMIC);
    1535         [ #  # ]:          0 :         if (!qi->desc_status) {
    1536                 :          0 :                 free_page((unsigned long) qi->desc);
    1537                 :          0 :                 kfree(qi);
    1538                 :          0 :                 iommu->qi = NULL;
    1539                 :          0 :                 return -ENOMEM;
    1540                 :            :         }
    1541                 :            : 
    1542                 :          0 :         raw_spin_lock_init(&qi->q_lock);
    1543                 :            : 
    1544                 :          0 :         __dmar_enable_qi(iommu);
    1545                 :            : 
    1546                 :          0 :         return 0;
    1547                 :            : }
    1548                 :            : 
    1549                 :            : /* iommu interrupt handling. Most stuff are MSI-like. */
    1550                 :            : 
    1551                 :            : enum faulttype {
    1552                 :            :         DMA_REMAP,
    1553                 :            :         INTR_REMAP,
    1554                 :            :         UNKNOWN,
    1555                 :            : };
    1556                 :            : 
    1557                 :            : static const char *dma_remap_fault_reasons[] =
    1558                 :            : {
    1559                 :            :         "Software",
    1560                 :            :         "Present bit in root entry is clear",
    1561                 :            :         "Present bit in context entry is clear",
    1562                 :            :         "Invalid context entry",
    1563                 :            :         "Access beyond MGAW",
    1564                 :            :         "PTE Write access is not set",
    1565                 :            :         "PTE Read access is not set",
    1566                 :            :         "Next page table ptr is invalid",
    1567                 :            :         "Root table address invalid",
    1568                 :            :         "Context table ptr is invalid",
    1569                 :            :         "non-zero reserved fields in RTP",
    1570                 :            :         "non-zero reserved fields in CTP",
    1571                 :            :         "non-zero reserved fields in PTE",
    1572                 :            :         "PCE for translation request specifies blocking",
    1573                 :            : };
    1574                 :            : 
    1575                 :            : static const char * const dma_remap_sm_fault_reasons[] = {
    1576                 :            :         "SM: Invalid Root Table Address",
    1577                 :            :         "SM: TTM 0 for request with PASID",
    1578                 :            :         "SM: TTM 0 for page group request",
    1579                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x33-0x37 */
    1580                 :            :         "SM: Error attempting to access Root Entry",
    1581                 :            :         "SM: Present bit in Root Entry is clear",
    1582                 :            :         "SM: Non-zero reserved field set in Root Entry",
    1583                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x3B-0x3F */
    1584                 :            :         "SM: Error attempting to access Context Entry",
    1585                 :            :         "SM: Present bit in Context Entry is clear",
    1586                 :            :         "SM: Non-zero reserved field set in the Context Entry",
    1587                 :            :         "SM: Invalid Context Entry",
    1588                 :            :         "SM: DTE field in Context Entry is clear",
    1589                 :            :         "SM: PASID Enable field in Context Entry is clear",
    1590                 :            :         "SM: PASID is larger than the max in Context Entry",
    1591                 :            :         "SM: PRE field in Context-Entry is clear",
    1592                 :            :         "SM: RID_PASID field error in Context-Entry",
    1593                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x49-0x4F */
    1594                 :            :         "SM: Error attempting to access the PASID Directory Entry",
    1595                 :            :         "SM: Present bit in Directory Entry is clear",
    1596                 :            :         "SM: Non-zero reserved field set in PASID Directory Entry",
    1597                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x53-0x57 */
    1598                 :            :         "SM: Error attempting to access PASID Table Entry",
    1599                 :            :         "SM: Present bit in PASID Table Entry is clear",
    1600                 :            :         "SM: Non-zero reserved field set in PASID Table Entry",
    1601                 :            :         "SM: Invalid Scalable-Mode PASID Table Entry",
    1602                 :            :         "SM: ERE field is clear in PASID Table Entry",
    1603                 :            :         "SM: SRE field is clear in PASID Table Entry",
    1604                 :            :         "Unknown", "Unknown",/* 0x5E-0x5F */
    1605                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x60-0x67 */
    1606                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x68-0x6F */
    1607                 :            :         "SM: Error attempting to access first-level paging entry",
    1608                 :            :         "SM: Present bit in first-level paging entry is clear",
    1609                 :            :         "SM: Non-zero reserved field set in first-level paging entry",
    1610                 :            :         "SM: Error attempting to access FL-PML4 entry",
    1611                 :            :         "SM: First-level entry address beyond MGAW in Nested translation",
    1612                 :            :         "SM: Read permission error in FL-PML4 entry in Nested translation",
    1613                 :            :         "SM: Read permission error in first-level paging entry in Nested translation",
    1614                 :            :         "SM: Write permission error in first-level paging entry in Nested translation",
    1615                 :            :         "SM: Error attempting to access second-level paging entry",
    1616                 :            :         "SM: Read/Write permission error in second-level paging entry",
    1617                 :            :         "SM: Non-zero reserved field set in second-level paging entry",
    1618                 :            :         "SM: Invalid second-level page table pointer",
    1619                 :            :         "SM: A/D bit update needed in second-level entry when set up in no snoop",
    1620                 :            :         "Unknown", "Unknown", "Unknown", /* 0x7D-0x7F */
    1621                 :            :         "SM: Address in first-level translation is not canonical",
    1622                 :            :         "SM: U/S set 0 for first-level translation with user privilege",
    1623                 :            :         "SM: No execute permission for request with PASID and ER=1",
    1624                 :            :         "SM: Address beyond the DMA hardware max",
    1625                 :            :         "SM: Second-level entry address beyond the max",
    1626                 :            :         "SM: No write permission for Write/AtomicOp request",
    1627                 :            :         "SM: No read permission for Read/AtomicOp request",
    1628                 :            :         "SM: Invalid address-interrupt address",
    1629                 :            :         "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x88-0x8F */
    1630                 :            :         "SM: A/D bit update needed in first-level entry when set up in no snoop",
    1631                 :            : };
    1632                 :            : 
    1633                 :            : static const char *irq_remap_fault_reasons[] =
    1634                 :            : {
    1635                 :            :         "Detected reserved fields in the decoded interrupt-remapped request",
    1636                 :            :         "Interrupt index exceeded the interrupt-remapping table size",
    1637                 :            :         "Present field in the IRTE entry is clear",
    1638                 :            :         "Error accessing interrupt-remapping table pointed by IRTA_REG",
    1639                 :            :         "Detected reserved fields in the IRTE entry",
    1640                 :            :         "Blocked a compatibility format interrupt request",
    1641                 :            :         "Blocked an interrupt request due to source-id verification failure",
    1642                 :            : };
    1643                 :            : 
    1644                 :          0 : static const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type)
    1645                 :            : {
    1646         [ #  # ]:          0 :         if (fault_reason >= 0x20 && (fault_reason - 0x20 <
    1647                 :            :                                         ARRAY_SIZE(irq_remap_fault_reasons))) {
    1648                 :          0 :                 *fault_type = INTR_REMAP;
    1649                 :          0 :                 return irq_remap_fault_reasons[fault_reason - 0x20];
    1650   [ #  #  #  # ]:          0 :         } else if (fault_reason >= 0x30 && (fault_reason - 0x30 <
    1651                 :            :                         ARRAY_SIZE(dma_remap_sm_fault_reasons))) {
    1652                 :          0 :                 *fault_type = DMA_REMAP;
    1653                 :          0 :                 return dma_remap_sm_fault_reasons[fault_reason - 0x30];
    1654         [ #  # ]:          0 :         } else if (fault_reason < ARRAY_SIZE(dma_remap_fault_reasons)) {
    1655                 :          0 :                 *fault_type = DMA_REMAP;
    1656                 :          0 :                 return dma_remap_fault_reasons[fault_reason];
    1657                 :            :         } else {
    1658                 :            :                 *fault_type = UNKNOWN;
    1659                 :            :                 return "Unknown";
    1660                 :            :         }
    1661                 :            : }
    1662                 :            : 
    1663                 :            : 
    1664                 :          0 : static inline int dmar_msi_reg(struct intel_iommu *iommu, int irq)
    1665                 :            : {
    1666                 :          0 :         if (iommu->irq == irq)
    1667                 :            :                 return DMAR_FECTL_REG;
    1668   [ #  #  #  #  :          0 :         else if (iommu->pr_irq == irq)
             #  #  #  # ]
    1669                 :            :                 return DMAR_PECTL_REG;
    1670                 :            :         else
    1671                 :          0 :                 BUG();
    1672                 :            : }
    1673                 :            : 
    1674                 :          0 : void dmar_msi_unmask(struct irq_data *data)
    1675                 :            : {
    1676         [ #  # ]:          0 :         struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
    1677         [ #  # ]:          0 :         int reg = dmar_msi_reg(iommu, data->irq);
    1678                 :          0 :         unsigned long flag;
    1679                 :            : 
    1680                 :            :         /* unmask it */
    1681                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1682                 :          0 :         writel(0, iommu->reg + reg);
    1683                 :            :         /* Read a reg to force flush the post write */
    1684                 :          0 :         readl(iommu->reg + reg);
    1685                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1686                 :          0 : }
    1687                 :            : 
    1688                 :          0 : void dmar_msi_mask(struct irq_data *data)
    1689                 :            : {
    1690         [ #  # ]:          0 :         struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
    1691         [ #  # ]:          0 :         int reg = dmar_msi_reg(iommu, data->irq);
    1692                 :          0 :         unsigned long flag;
    1693                 :            : 
    1694                 :            :         /* mask it */
    1695                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1696                 :          0 :         writel(DMA_FECTL_IM, iommu->reg + reg);
    1697                 :            :         /* Read a reg to force flush the post write */
    1698                 :          0 :         readl(iommu->reg + reg);
    1699                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1700                 :          0 : }
    1701                 :            : 
    1702                 :          0 : void dmar_msi_write(int irq, struct msi_msg *msg)
    1703                 :            : {
    1704                 :          0 :         struct intel_iommu *iommu = irq_get_handler_data(irq);
    1705         [ #  # ]:          0 :         int reg = dmar_msi_reg(iommu, irq);
    1706                 :          0 :         unsigned long flag;
    1707                 :            : 
    1708                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1709                 :          0 :         writel(msg->data, iommu->reg + reg + 4);
    1710                 :          0 :         writel(msg->address_lo, iommu->reg + reg + 8);
    1711                 :          0 :         writel(msg->address_hi, iommu->reg + reg + 12);
    1712                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1713                 :          0 : }
    1714                 :            : 
    1715                 :          0 : void dmar_msi_read(int irq, struct msi_msg *msg)
    1716                 :            : {
    1717                 :          0 :         struct intel_iommu *iommu = irq_get_handler_data(irq);
    1718         [ #  # ]:          0 :         int reg = dmar_msi_reg(iommu, irq);
    1719                 :          0 :         unsigned long flag;
    1720                 :            : 
    1721                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1722                 :          0 :         msg->data = readl(iommu->reg + reg + 4);
    1723                 :          0 :         msg->address_lo = readl(iommu->reg + reg + 8);
    1724                 :          0 :         msg->address_hi = readl(iommu->reg + reg + 12);
    1725                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1726                 :          0 : }
    1727                 :            : 
    1728                 :          0 : static int dmar_fault_do_one(struct intel_iommu *iommu, int type,
    1729                 :            :                 u8 fault_reason, int pasid, u16 source_id,
    1730                 :            :                 unsigned long long addr)
    1731                 :            : {
    1732                 :          0 :         const char *reason;
    1733                 :          0 :         int fault_type;
    1734                 :            : 
    1735         [ #  # ]:          0 :         reason = dmar_get_fault_reason(fault_reason, &fault_type);
    1736                 :            : 
    1737                 :          0 :         if (fault_type == INTR_REMAP)
    1738                 :          0 :                 pr_err("[INTR-REMAP] Request device [%02x:%02x.%d] fault index %llx [fault reason %02d] %s\n",
    1739                 :            :                         source_id >> 8, PCI_SLOT(source_id & 0xFF),
    1740                 :            :                         PCI_FUNC(source_id & 0xFF), addr >> 48,
    1741                 :            :                         fault_reason, reason);
    1742                 :            :         else
    1743         [ #  # ]:          0 :                 pr_err("[%s] Request device [%02x:%02x.%d] PASID %x fault addr %llx [fault reason %02d] %s\n",
    1744                 :            :                        type ? "DMA Read" : "DMA Write",
    1745                 :            :                        source_id >> 8, PCI_SLOT(source_id & 0xFF),
    1746                 :            :                        PCI_FUNC(source_id & 0xFF), pasid, addr,
    1747                 :            :                        fault_reason, reason);
    1748                 :          0 :         return 0;
    1749                 :            : }
    1750                 :            : 
    1751                 :            : #define PRIMARY_FAULT_REG_LEN (16)
    1752                 :          0 : irqreturn_t dmar_fault(int irq, void *dev_id)
    1753                 :            : {
    1754                 :          0 :         struct intel_iommu *iommu = dev_id;
    1755                 :          0 :         int reg, fault_index;
    1756                 :          0 :         u32 fault_status;
    1757                 :          0 :         unsigned long flag;
    1758                 :          0 :         static DEFINE_RATELIMIT_STATE(rs,
    1759                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,
    1760                 :            :                                       DEFAULT_RATELIMIT_BURST);
    1761                 :            : 
    1762                 :          0 :         raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1763                 :          0 :         fault_status = readl(iommu->reg + DMAR_FSTS_REG);
    1764   [ #  #  #  # ]:          0 :         if (fault_status && __ratelimit(&rs))
    1765                 :          0 :                 pr_err("DRHD: handling fault status reg %x\n", fault_status);
    1766                 :            : 
    1767                 :            :         /* TBD: ignore advanced fault log currently */
    1768         [ #  # ]:          0 :         if (!(fault_status & DMA_FSTS_PPF))
    1769                 :          0 :                 goto unlock_exit;
    1770                 :            : 
    1771                 :          0 :         fault_index = dma_fsts_fault_record_index(fault_status);
    1772                 :          0 :         reg = cap_fault_reg_offset(iommu->cap);
    1773                 :          0 :         while (1) {
    1774                 :            :                 /* Disable printing, simply clear the fault when ratelimited */
    1775                 :          0 :                 bool ratelimited = !__ratelimit(&rs);
    1776                 :          0 :                 u8 fault_reason;
    1777                 :          0 :                 u16 source_id;
    1778                 :          0 :                 u64 guest_addr;
    1779                 :          0 :                 int type, pasid;
    1780                 :          0 :                 u32 data;
    1781                 :          0 :                 bool pasid_present;
    1782                 :            : 
    1783                 :            :                 /* highest 32 bits */
    1784                 :          0 :                 data = readl(iommu->reg + reg +
    1785                 :          0 :                                 fault_index * PRIMARY_FAULT_REG_LEN + 12);
    1786         [ #  # ]:          0 :                 if (!(data & DMA_FRCD_F))
    1787                 :            :                         break;
    1788                 :            : 
    1789         [ #  # ]:          0 :                 if (!ratelimited) {
    1790                 :          0 :                         fault_reason = dma_frcd_fault_reason(data);
    1791                 :          0 :                         type = dma_frcd_type(data);
    1792                 :            : 
    1793                 :          0 :                         pasid = dma_frcd_pasid_value(data);
    1794                 :          0 :                         data = readl(iommu->reg + reg +
    1795                 :          0 :                                      fault_index * PRIMARY_FAULT_REG_LEN + 8);
    1796                 :          0 :                         source_id = dma_frcd_source_id(data);
    1797                 :            : 
    1798                 :          0 :                         pasid_present = dma_frcd_pasid_present(data);
    1799                 :          0 :                         guest_addr = dmar_readq(iommu->reg + reg +
    1800                 :            :                                         fault_index * PRIMARY_FAULT_REG_LEN);
    1801                 :          0 :                         guest_addr = dma_frcd_page_addr(guest_addr);
    1802                 :            :                 }
    1803                 :            : 
    1804                 :            :                 /* clear the fault */
    1805                 :          0 :                 writel(DMA_FRCD_F, iommu->reg + reg +
    1806                 :          0 :                         fault_index * PRIMARY_FAULT_REG_LEN + 12);
    1807                 :            : 
    1808                 :          0 :                 raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1809                 :            : 
    1810         [ #  # ]:          0 :                 if (!ratelimited)
    1811                 :            :                         /* Using pasid -1 if pasid is not present */
    1812         [ #  # ]:          0 :                         dmar_fault_do_one(iommu, type, fault_reason,
    1813                 :            :                                           pasid_present ? pasid : -1,
    1814                 :            :                                           source_id, guest_addr);
    1815                 :            : 
    1816                 :          0 :                 fault_index++;
    1817         [ #  # ]:          0 :                 if (fault_index >= cap_num_fault_regs(iommu->cap))
    1818                 :          0 :                         fault_index = 0;
    1819                 :          0 :                 raw_spin_lock_irqsave(&iommu->register_lock, flag);
    1820                 :            :         }
    1821                 :            : 
    1822                 :          0 :         writel(DMA_FSTS_PFO | DMA_FSTS_PPF | DMA_FSTS_PRO,
    1823                 :          0 :                iommu->reg + DMAR_FSTS_REG);
    1824                 :            : 
    1825                 :          0 : unlock_exit:
    1826                 :          0 :         raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
    1827                 :          0 :         return IRQ_HANDLED;
    1828                 :            : }
    1829                 :            : 
    1830                 :          0 : int dmar_set_interrupt(struct intel_iommu *iommu)
    1831                 :            : {
    1832                 :          0 :         int irq, ret;
    1833                 :            : 
    1834                 :            :         /*
    1835                 :            :          * Check if the fault interrupt is already initialized.
    1836                 :            :          */
    1837         [ #  # ]:          0 :         if (iommu->irq)
    1838                 :            :                 return 0;
    1839                 :            : 
    1840                 :          0 :         irq = dmar_alloc_hwirq(iommu->seq_id, iommu->node, iommu);
    1841         [ #  # ]:          0 :         if (irq > 0) {
    1842                 :          0 :                 iommu->irq = irq;
    1843                 :            :         } else {
    1844                 :          0 :                 pr_err("No free IRQ vectors\n");
    1845                 :          0 :                 return -EINVAL;
    1846                 :            :         }
    1847                 :            : 
    1848                 :          0 :         ret = request_irq(irq, dmar_fault, IRQF_NO_THREAD, iommu->name, iommu);
    1849         [ #  # ]:          0 :         if (ret)
    1850                 :          0 :                 pr_err("Can't request irq\n");
    1851                 :            :         return ret;
    1852                 :            : }
    1853                 :            : 
    1854                 :          0 : int __init enable_drhd_fault_handling(void)
    1855                 :            : {
    1856                 :          0 :         struct dmar_drhd_unit *drhd;
    1857                 :          0 :         struct intel_iommu *iommu;
    1858                 :            : 
    1859                 :            :         /*
    1860                 :            :          * Enable fault control interrupt.
    1861                 :            :          */
    1862         [ #  # ]:          0 :         for_each_iommu(iommu, drhd) {
    1863                 :          0 :                 u32 fault_status;
    1864                 :          0 :                 int ret = dmar_set_interrupt(iommu);
    1865                 :            : 
    1866         [ #  # ]:          0 :                 if (ret) {
    1867                 :          0 :                         pr_err("DRHD %Lx: failed to enable fault, interrupt, ret %d\n",
    1868                 :            :                                (unsigned long long)drhd->reg_base_addr, ret);
    1869                 :          0 :                         return -1;
    1870                 :            :                 }
    1871                 :            : 
    1872                 :            :                 /*
    1873                 :            :                  * Clear any previous faults.
    1874                 :            :                  */
    1875                 :          0 :                 dmar_fault(iommu->irq, iommu);
    1876                 :          0 :                 fault_status = readl(iommu->reg + DMAR_FSTS_REG);
    1877                 :          0 :                 writel(fault_status, iommu->reg + DMAR_FSTS_REG);
    1878                 :            :         }
    1879                 :            : 
    1880                 :            :         return 0;
    1881                 :            : }
    1882                 :            : 
    1883                 :            : /*
    1884                 :            :  * Re-enable Queued Invalidation interface.
    1885                 :            :  */
    1886                 :          0 : int dmar_reenable_qi(struct intel_iommu *iommu)
    1887                 :            : {
    1888         [ #  # ]:          0 :         if (!ecap_qis(iommu->ecap))
    1889                 :            :                 return -ENOENT;
    1890                 :            : 
    1891         [ #  # ]:          0 :         if (!iommu->qi)
    1892                 :            :                 return -ENOENT;
    1893                 :            : 
    1894                 :            :         /*
    1895                 :            :          * First disable queued invalidation.
    1896                 :            :          */
    1897                 :          0 :         dmar_disable_qi(iommu);
    1898                 :            :         /*
    1899                 :            :          * Then enable queued invalidation again. Since there is no pending
    1900                 :            :          * invalidation requests now, it's safe to re-enable queued
    1901                 :            :          * invalidation.
    1902                 :            :          */
    1903                 :          0 :         __dmar_enable_qi(iommu);
    1904                 :            : 
    1905                 :          0 :         return 0;
    1906                 :            : }
    1907                 :            : 
    1908                 :            : /*
    1909                 :            :  * Check interrupt remapping support in DMAR table description.
    1910                 :            :  */
    1911                 :          0 : int __init dmar_ir_support(void)
    1912                 :            : {
    1913                 :          0 :         struct acpi_table_dmar *dmar;
    1914                 :          0 :         dmar = (struct acpi_table_dmar *)dmar_tbl;
    1915         [ #  # ]:          0 :         if (!dmar)
    1916                 :            :                 return 0;
    1917                 :          0 :         return dmar->flags & 0x1;
    1918                 :            : }
    1919                 :            : 
    1920                 :            : /* Check whether DMAR units are in use */
    1921                 :          3 : static inline bool dmar_in_use(void)
    1922                 :            : {
    1923                 :          3 :         return irq_remapping_enabled || intel_iommu_enabled;
    1924                 :            : }
    1925                 :            : 
    1926                 :          3 : static int __init dmar_free_unused_resources(void)
    1927                 :            : {
    1928                 :          3 :         struct dmar_drhd_unit *dmaru, *dmaru_n;
    1929                 :            : 
    1930         [ +  - ]:          3 :         if (dmar_in_use())
    1931                 :            :                 return 0;
    1932                 :            : 
    1933   [ -  +  -  - ]:          3 :         if (dmar_dev_scope_status != 1 && !list_empty(&dmar_drhd_units))
    1934                 :          0 :                 bus_unregister_notifier(&pci_bus_type, &dmar_pci_bus_nb);
    1935                 :            : 
    1936                 :          3 :         down_write(&dmar_global_lock);
    1937         [ -  + ]:          3 :         list_for_each_entry_safe(dmaru, dmaru_n, &dmar_drhd_units, list) {
    1938                 :          0 :                 list_del(&dmaru->list);
    1939                 :          0 :                 dmar_free_drhd(dmaru);
    1940                 :            :         }
    1941                 :          3 :         up_write(&dmar_global_lock);
    1942                 :            : 
    1943                 :          3 :         return 0;
    1944                 :            : }
    1945                 :            : 
    1946                 :            : late_initcall(dmar_free_unused_resources);
    1947                 :            : IOMMU_INIT_POST(detect_intel_iommu);
    1948                 :            : 
    1949                 :            : /*
    1950                 :            :  * DMAR Hotplug Support
    1951                 :            :  * For more details, please refer to Intel(R) Virtualization Technology
    1952                 :            :  * for Directed-IO Architecture Specifiction, Rev 2.2, Section 8.8
    1953                 :            :  * "Remapping Hardware Unit Hot Plug".
    1954                 :            :  */
    1955                 :            : static guid_t dmar_hp_guid =
    1956                 :            :         GUID_INIT(0xD8C1A3A6, 0xBE9B, 0x4C9B,
    1957                 :            :                   0x91, 0xBF, 0xC3, 0xCB, 0x81, 0xFC, 0x5D, 0xAF);
    1958                 :            : 
    1959                 :            : /*
    1960                 :            :  * Currently there's only one revision and BIOS will not check the revision id,
    1961                 :            :  * so use 0 for safety.
    1962                 :            :  */
    1963                 :            : #define DMAR_DSM_REV_ID                 0
    1964                 :            : #define DMAR_DSM_FUNC_DRHD              1
    1965                 :            : #define DMAR_DSM_FUNC_ATSR              2
    1966                 :            : #define DMAR_DSM_FUNC_RHSA              3
    1967                 :            : 
    1968                 :          0 : static inline bool dmar_detect_dsm(acpi_handle handle, int func)
    1969                 :            : {
    1970                 :          0 :         return acpi_check_dsm(handle, &dmar_hp_guid, DMAR_DSM_REV_ID, 1 << func);
    1971                 :            : }
    1972                 :            : 
    1973                 :          0 : static int dmar_walk_dsm_resource(acpi_handle handle, int func,
    1974                 :            :                                   dmar_res_handler_t handler, void *arg)
    1975                 :            : {
    1976                 :          0 :         int ret = -ENODEV;
    1977                 :          0 :         union acpi_object *obj;
    1978                 :          0 :         struct acpi_dmar_header *start;
    1979                 :          0 :         struct dmar_res_callback callback;
    1980                 :          0 :         static int res_type[] = {
    1981                 :            :                 [DMAR_DSM_FUNC_DRHD] = ACPI_DMAR_TYPE_HARDWARE_UNIT,
    1982                 :            :                 [DMAR_DSM_FUNC_ATSR] = ACPI_DMAR_TYPE_ROOT_ATS,
    1983                 :            :                 [DMAR_DSM_FUNC_RHSA] = ACPI_DMAR_TYPE_HARDWARE_AFFINITY,
    1984                 :            :         };
    1985                 :            : 
    1986         [ #  # ]:          0 :         if (!dmar_detect_dsm(handle, func))
    1987                 :            :                 return 0;
    1988                 :            : 
    1989                 :          0 :         obj = acpi_evaluate_dsm_typed(handle, &dmar_hp_guid, DMAR_DSM_REV_ID,
    1990                 :            :                                       func, NULL, ACPI_TYPE_BUFFER);
    1991         [ #  # ]:          0 :         if (!obj)
    1992                 :            :                 return -ENODEV;
    1993                 :            : 
    1994                 :          0 :         memset(&callback, 0, sizeof(callback));
    1995                 :          0 :         callback.cb[res_type[func]] = handler;
    1996                 :          0 :         callback.arg[res_type[func]] = arg;
    1997                 :          0 :         start = (struct acpi_dmar_header *)obj->buffer.pointer;
    1998                 :          0 :         ret = dmar_walk_remapping_entries(start, obj->buffer.length, &callback);
    1999                 :            : 
    2000                 :          0 :         ACPI_FREE(obj);
    2001                 :            : 
    2002                 :          0 :         return ret;
    2003                 :            : }
    2004                 :            : 
    2005                 :          0 : static int dmar_hp_add_drhd(struct acpi_dmar_header *header, void *arg)
    2006                 :            : {
    2007                 :          0 :         int ret;
    2008                 :          0 :         struct dmar_drhd_unit *dmaru;
    2009                 :            : 
    2010                 :          0 :         dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
    2011         [ #  # ]:          0 :         if (!dmaru)
    2012                 :            :                 return -ENODEV;
    2013                 :            : 
    2014                 :          0 :         ret = dmar_ir_hotplug(dmaru, true);
    2015                 :          0 :         if (ret == 0)
    2016                 :          0 :                 ret = dmar_iommu_hotplug(dmaru, true);
    2017                 :            : 
    2018                 :          0 :         return ret;
    2019                 :            : }
    2020                 :            : 
    2021                 :          0 : static int dmar_hp_remove_drhd(struct acpi_dmar_header *header, void *arg)
    2022                 :            : {
    2023                 :          0 :         int i, ret;
    2024                 :          0 :         struct device *dev;
    2025                 :          0 :         struct dmar_drhd_unit *dmaru;
    2026                 :            : 
    2027                 :          0 :         dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
    2028         [ #  # ]:          0 :         if (!dmaru)
    2029                 :            :                 return 0;
    2030                 :            : 
    2031                 :            :         /*
    2032                 :            :          * All PCI devices managed by this unit should have been destroyed.
    2033                 :            :          */
    2034   [ #  #  #  #  :          0 :         if (!dmaru->include_all && dmaru->devices && dmaru->devices_cnt) {
                   #  # ]
    2035   [ #  #  #  #  :          0 :                 for_each_active_dev_scope(dmaru->devices,
                   #  # ]
    2036                 :            :                                           dmaru->devices_cnt, i, dev)
    2037                 :            :                         return -EBUSY;
    2038                 :            :         }
    2039                 :            : 
    2040                 :          0 :         ret = dmar_ir_hotplug(dmaru, false);
    2041                 :          0 :         if (ret == 0)
    2042                 :          0 :                 ret = dmar_iommu_hotplug(dmaru, false);
    2043                 :            : 
    2044                 :          0 :         return ret;
    2045                 :            : }
    2046                 :            : 
    2047                 :          0 : static int dmar_hp_release_drhd(struct acpi_dmar_header *header, void *arg)
    2048                 :            : {
    2049                 :          0 :         struct dmar_drhd_unit *dmaru;
    2050                 :            : 
    2051                 :          0 :         dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
    2052         [ #  # ]:          0 :         if (dmaru) {
    2053                 :          0 :                 list_del_rcu(&dmaru->list);
    2054                 :          0 :                 synchronize_rcu();
    2055                 :          0 :                 dmar_free_drhd(dmaru);
    2056                 :            :         }
    2057                 :            : 
    2058                 :          0 :         return 0;
    2059                 :            : }
    2060                 :            : 
    2061                 :          0 : static int dmar_hotplug_insert(acpi_handle handle)
    2062                 :            : {
    2063                 :          0 :         int ret;
    2064                 :          0 :         int drhd_count = 0;
    2065                 :            : 
    2066                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2067                 :            :                                      &dmar_validate_one_drhd, (void *)1);
    2068         [ #  # ]:          0 :         if (ret)
    2069                 :          0 :                 goto out;
    2070                 :            : 
    2071                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2072                 :            :                                      &dmar_parse_one_drhd, (void *)&drhd_count);
    2073   [ #  #  #  # ]:          0 :         if (ret == 0 && drhd_count == 0) {
    2074                 :          0 :                 pr_warn(FW_BUG "No DRHD structures in buffer returned by _DSM method\n");
    2075                 :          0 :                 goto out;
    2076         [ #  # ]:          0 :         } else if (ret) {
    2077                 :          0 :                 goto release_drhd;
    2078                 :            :         }
    2079                 :            : 
    2080                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_RHSA,
    2081                 :            :                                      &dmar_parse_one_rhsa, NULL);
    2082         [ #  # ]:          0 :         if (ret)
    2083                 :          0 :                 goto release_drhd;
    2084                 :            : 
    2085                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
    2086                 :            :                                      &dmar_parse_one_atsr, NULL);
    2087         [ #  # ]:          0 :         if (ret)
    2088                 :          0 :                 goto release_atsr;
    2089                 :            : 
    2090                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2091                 :            :                                      &dmar_hp_add_drhd, NULL);
    2092         [ #  # ]:          0 :         if (!ret)
    2093                 :            :                 return 0;
    2094                 :            : 
    2095                 :          0 :         dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2096                 :            :                                &dmar_hp_remove_drhd, NULL);
    2097                 :          0 : release_atsr:
    2098                 :          0 :         dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
    2099                 :            :                                &dmar_release_one_atsr, NULL);
    2100                 :          0 : release_drhd:
    2101                 :          0 :         dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2102                 :            :                                &dmar_hp_release_drhd, NULL);
    2103                 :            : out:
    2104                 :            :         return ret;
    2105                 :            : }
    2106                 :            : 
    2107                 :          0 : static int dmar_hotplug_remove(acpi_handle handle)
    2108                 :            : {
    2109                 :          0 :         int ret;
    2110                 :            : 
    2111                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
    2112                 :            :                                      &dmar_check_one_atsr, NULL);
    2113         [ #  # ]:          0 :         if (ret)
    2114                 :            :                 return ret;
    2115                 :            : 
    2116                 :          0 :         ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2117                 :            :                                      &dmar_hp_remove_drhd, NULL);
    2118         [ #  # ]:          0 :         if (ret == 0) {
    2119         [ #  # ]:          0 :                 WARN_ON(dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
    2120                 :            :                                                &dmar_release_one_atsr, NULL));
    2121         [ #  # ]:          0 :                 WARN_ON(dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2122                 :            :                                                &dmar_hp_release_drhd, NULL));
    2123                 :            :         } else {
    2124                 :          0 :                 dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
    2125                 :            :                                        &dmar_hp_add_drhd, NULL);
    2126                 :            :         }
    2127                 :            : 
    2128                 :            :         return ret;
    2129                 :            : }
    2130                 :            : 
    2131                 :          0 : static acpi_status dmar_get_dsm_handle(acpi_handle handle, u32 lvl,
    2132                 :            :                                        void *context, void **retval)
    2133                 :            : {
    2134                 :          0 :         acpi_handle *phdl = retval;
    2135                 :            : 
    2136         [ #  # ]:          0 :         if (dmar_detect_dsm(handle, DMAR_DSM_FUNC_DRHD)) {
    2137                 :          0 :                 *phdl = handle;
    2138                 :          0 :                 return AE_CTRL_TERMINATE;
    2139                 :            :         }
    2140                 :            : 
    2141                 :            :         return AE_OK;
    2142                 :            : }
    2143                 :            : 
    2144                 :          0 : static int dmar_device_hotplug(acpi_handle handle, bool insert)
    2145                 :            : {
    2146                 :          0 :         int ret;
    2147                 :          0 :         acpi_handle tmp = NULL;
    2148                 :          0 :         acpi_status status;
    2149                 :            : 
    2150         [ #  # ]:          0 :         if (!dmar_in_use())
    2151                 :            :                 return 0;
    2152                 :            : 
    2153         [ #  # ]:          0 :         if (dmar_detect_dsm(handle, DMAR_DSM_FUNC_DRHD)) {
    2154                 :          0 :                 tmp = handle;
    2155                 :            :         } else {
    2156                 :          0 :                 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
    2157                 :            :                                              ACPI_UINT32_MAX,
    2158                 :            :                                              dmar_get_dsm_handle,
    2159                 :            :                                              NULL, NULL, &tmp);
    2160         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
    2161                 :          0 :                         pr_warn("Failed to locate _DSM method.\n");
    2162                 :          0 :                         return -ENXIO;
    2163                 :            :                 }
    2164                 :            :         }
    2165         [ #  # ]:          0 :         if (tmp == NULL)
    2166                 :            :                 return 0;
    2167                 :            : 
    2168                 :          0 :         down_write(&dmar_global_lock);
    2169         [ #  # ]:          0 :         if (insert)
    2170                 :          0 :                 ret = dmar_hotplug_insert(tmp);
    2171                 :            :         else
    2172                 :          0 :                 ret = dmar_hotplug_remove(tmp);
    2173                 :          0 :         up_write(&dmar_global_lock);
    2174                 :            : 
    2175                 :          0 :         return ret;
    2176                 :            : }
    2177                 :            : 
    2178                 :          0 : int dmar_device_add(acpi_handle handle)
    2179                 :            : {
    2180                 :          0 :         return dmar_device_hotplug(handle, true);
    2181                 :            : }
    2182                 :            : 
    2183                 :          0 : int dmar_device_remove(acpi_handle handle)
    2184                 :            : {
    2185                 :          0 :         return dmar_device_hotplug(handle, false);
    2186                 :            : }
    2187                 :            : 
    2188                 :            : /*
    2189                 :            :  * dmar_platform_optin - Is %DMA_CTRL_PLATFORM_OPT_IN_FLAG set in DMAR table
    2190                 :            :  *
    2191                 :            :  * Returns true if the platform has %DMA_CTRL_PLATFORM_OPT_IN_FLAG set in
    2192                 :            :  * the ACPI DMAR table. This means that the platform boot firmware has made
    2193                 :            :  * sure no device can issue DMA outside of RMRR regions.
    2194                 :            :  */
    2195                 :          0 : bool dmar_platform_optin(void)
    2196                 :            : {
    2197                 :          0 :         struct acpi_table_dmar *dmar;
    2198                 :          0 :         acpi_status status;
    2199                 :          0 :         bool ret;
    2200                 :            : 
    2201                 :          0 :         status = acpi_get_table(ACPI_SIG_DMAR, 0,
    2202                 :            :                                 (struct acpi_table_header **)&dmar);
    2203         [ #  # ]:          0 :         if (ACPI_FAILURE(status))
    2204                 :            :                 return false;
    2205                 :            : 
    2206                 :          0 :         ret = !!(dmar->flags & DMAR_PLATFORM_OPT_IN);
    2207                 :          0 :         acpi_put_table((struct acpi_table_header *)dmar);
    2208                 :            : 
    2209                 :          0 :         return ret;
    2210                 :            : }
    2211                 :            : EXPORT_SYMBOL_GPL(dmar_platform_optin);

Generated by: LCOV version 1.14