iommu/vt-d: Don't disable IR when it was previously enabled
[sfrench/cifs-2.6.git] / drivers / iommu / iommu.c
1 /*
2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
3  * Author: Joerg Roedel <jroedel@suse.de>
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published
7  * by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17  */
18
19 #define pr_fmt(fmt)    "%s: " fmt, __func__
20
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/bug.h>
24 #include <linux/types.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/errno.h>
28 #include <linux/iommu.h>
29 #include <linux/idr.h>
30 #include <linux/notifier.h>
31 #include <linux/err.h>
32 #include <linux/pci.h>
33 #include <linux/bitops.h>
34 #include <trace/events/iommu.h>
35
36 static struct kset *iommu_group_kset;
37 static struct ida iommu_group_ida;
38 static struct mutex iommu_group_mutex;
39
40 struct iommu_callback_data {
41         const struct iommu_ops *ops;
42 };
43
44 struct iommu_group {
45         struct kobject kobj;
46         struct kobject *devices_kobj;
47         struct list_head devices;
48         struct mutex mutex;
49         struct blocking_notifier_head notifier;
50         void *iommu_data;
51         void (*iommu_data_release)(void *iommu_data);
52         char *name;
53         int id;
54 };
55
56 struct iommu_device {
57         struct list_head list;
58         struct device *dev;
59         char *name;
60 };
61
62 struct iommu_group_attribute {
63         struct attribute attr;
64         ssize_t (*show)(struct iommu_group *group, char *buf);
65         ssize_t (*store)(struct iommu_group *group,
66                          const char *buf, size_t count);
67 };
68
69 #define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
70 struct iommu_group_attribute iommu_group_attr_##_name =         \
71         __ATTR(_name, _mode, _show, _store)
72
73 #define to_iommu_group_attr(_attr)      \
74         container_of(_attr, struct iommu_group_attribute, attr)
75 #define to_iommu_group(_kobj)           \
76         container_of(_kobj, struct iommu_group, kobj)
77
78 static ssize_t iommu_group_attr_show(struct kobject *kobj,
79                                      struct attribute *__attr, char *buf)
80 {
81         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
82         struct iommu_group *group = to_iommu_group(kobj);
83         ssize_t ret = -EIO;
84
85         if (attr->show)
86                 ret = attr->show(group, buf);
87         return ret;
88 }
89
90 static ssize_t iommu_group_attr_store(struct kobject *kobj,
91                                       struct attribute *__attr,
92                                       const char *buf, size_t count)
93 {
94         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
95         struct iommu_group *group = to_iommu_group(kobj);
96         ssize_t ret = -EIO;
97
98         if (attr->store)
99                 ret = attr->store(group, buf, count);
100         return ret;
101 }
102
103 static const struct sysfs_ops iommu_group_sysfs_ops = {
104         .show = iommu_group_attr_show,
105         .store = iommu_group_attr_store,
106 };
107
108 static int iommu_group_create_file(struct iommu_group *group,
109                                    struct iommu_group_attribute *attr)
110 {
111         return sysfs_create_file(&group->kobj, &attr->attr);
112 }
113
114 static void iommu_group_remove_file(struct iommu_group *group,
115                                     struct iommu_group_attribute *attr)
116 {
117         sysfs_remove_file(&group->kobj, &attr->attr);
118 }
119
120 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
121 {
122         return sprintf(buf, "%s\n", group->name);
123 }
124
125 static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
126
127 static void iommu_group_release(struct kobject *kobj)
128 {
129         struct iommu_group *group = to_iommu_group(kobj);
130
131         if (group->iommu_data_release)
132                 group->iommu_data_release(group->iommu_data);
133
134         mutex_lock(&iommu_group_mutex);
135         ida_remove(&iommu_group_ida, group->id);
136         mutex_unlock(&iommu_group_mutex);
137
138         kfree(group->name);
139         kfree(group);
140 }
141
142 static struct kobj_type iommu_group_ktype = {
143         .sysfs_ops = &iommu_group_sysfs_ops,
144         .release = iommu_group_release,
145 };
146
147 /**
148  * iommu_group_alloc - Allocate a new group
149  * @name: Optional name to associate with group, visible in sysfs
150  *
151  * This function is called by an iommu driver to allocate a new iommu
152  * group.  The iommu group represents the minimum granularity of the iommu.
153  * Upon successful return, the caller holds a reference to the supplied
154  * group in order to hold the group until devices are added.  Use
155  * iommu_group_put() to release this extra reference count, allowing the
156  * group to be automatically reclaimed once it has no devices or external
157  * references.
158  */
159 struct iommu_group *iommu_group_alloc(void)
160 {
161         struct iommu_group *group;
162         int ret;
163
164         group = kzalloc(sizeof(*group), GFP_KERNEL);
165         if (!group)
166                 return ERR_PTR(-ENOMEM);
167
168         group->kobj.kset = iommu_group_kset;
169         mutex_init(&group->mutex);
170         INIT_LIST_HEAD(&group->devices);
171         BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
172
173         mutex_lock(&iommu_group_mutex);
174
175 again:
176         if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
177                 kfree(group);
178                 mutex_unlock(&iommu_group_mutex);
179                 return ERR_PTR(-ENOMEM);
180         }
181
182         if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
183                 goto again;
184
185         mutex_unlock(&iommu_group_mutex);
186
187         ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
188                                    NULL, "%d", group->id);
189         if (ret) {
190                 mutex_lock(&iommu_group_mutex);
191                 ida_remove(&iommu_group_ida, group->id);
192                 mutex_unlock(&iommu_group_mutex);
193                 kfree(group);
194                 return ERR_PTR(ret);
195         }
196
197         group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
198         if (!group->devices_kobj) {
199                 kobject_put(&group->kobj); /* triggers .release & free */
200                 return ERR_PTR(-ENOMEM);
201         }
202
203         /*
204          * The devices_kobj holds a reference on the group kobject, so
205          * as long as that exists so will the group.  We can therefore
206          * use the devices_kobj for reference counting.
207          */
208         kobject_put(&group->kobj);
209
210         return group;
211 }
212 EXPORT_SYMBOL_GPL(iommu_group_alloc);
213
214 struct iommu_group *iommu_group_get_by_id(int id)
215 {
216         struct kobject *group_kobj;
217         struct iommu_group *group;
218         const char *name;
219
220         if (!iommu_group_kset)
221                 return NULL;
222
223         name = kasprintf(GFP_KERNEL, "%d", id);
224         if (!name)
225                 return NULL;
226
227         group_kobj = kset_find_obj(iommu_group_kset, name);
228         kfree(name);
229
230         if (!group_kobj)
231                 return NULL;
232
233         group = container_of(group_kobj, struct iommu_group, kobj);
234         BUG_ON(group->id != id);
235
236         kobject_get(group->devices_kobj);
237         kobject_put(&group->kobj);
238
239         return group;
240 }
241 EXPORT_SYMBOL_GPL(iommu_group_get_by_id);
242
243 /**
244  * iommu_group_get_iommudata - retrieve iommu_data registered for a group
245  * @group: the group
246  *
247  * iommu drivers can store data in the group for use when doing iommu
248  * operations.  This function provides a way to retrieve it.  Caller
249  * should hold a group reference.
250  */
251 void *iommu_group_get_iommudata(struct iommu_group *group)
252 {
253         return group->iommu_data;
254 }
255 EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
256
257 /**
258  * iommu_group_set_iommudata - set iommu_data for a group
259  * @group: the group
260  * @iommu_data: new data
261  * @release: release function for iommu_data
262  *
263  * iommu drivers can store data in the group for use when doing iommu
264  * operations.  This function provides a way to set the data after
265  * the group has been allocated.  Caller should hold a group reference.
266  */
267 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
268                                void (*release)(void *iommu_data))
269 {
270         group->iommu_data = iommu_data;
271         group->iommu_data_release = release;
272 }
273 EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
274
275 /**
276  * iommu_group_set_name - set name for a group
277  * @group: the group
278  * @name: name
279  *
280  * Allow iommu driver to set a name for a group.  When set it will
281  * appear in a name attribute file under the group in sysfs.
282  */
283 int iommu_group_set_name(struct iommu_group *group, const char *name)
284 {
285         int ret;
286
287         if (group->name) {
288                 iommu_group_remove_file(group, &iommu_group_attr_name);
289                 kfree(group->name);
290                 group->name = NULL;
291                 if (!name)
292                         return 0;
293         }
294
295         group->name = kstrdup(name, GFP_KERNEL);
296         if (!group->name)
297                 return -ENOMEM;
298
299         ret = iommu_group_create_file(group, &iommu_group_attr_name);
300         if (ret) {
301                 kfree(group->name);
302                 group->name = NULL;
303                 return ret;
304         }
305
306         return 0;
307 }
308 EXPORT_SYMBOL_GPL(iommu_group_set_name);
309
310 /**
311  * iommu_group_add_device - add a device to an iommu group
312  * @group: the group into which to add the device (reference should be held)
313  * @dev: the device
314  *
315  * This function is called by an iommu driver to add a device into a
316  * group.  Adding a device increments the group reference count.
317  */
318 int iommu_group_add_device(struct iommu_group *group, struct device *dev)
319 {
320         int ret, i = 0;
321         struct iommu_device *device;
322
323         device = kzalloc(sizeof(*device), GFP_KERNEL);
324         if (!device)
325                 return -ENOMEM;
326
327         device->dev = dev;
328
329         ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
330         if (ret) {
331                 kfree(device);
332                 return ret;
333         }
334
335         device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
336 rename:
337         if (!device->name) {
338                 sysfs_remove_link(&dev->kobj, "iommu_group");
339                 kfree(device);
340                 return -ENOMEM;
341         }
342
343         ret = sysfs_create_link_nowarn(group->devices_kobj,
344                                        &dev->kobj, device->name);
345         if (ret) {
346                 kfree(device->name);
347                 if (ret == -EEXIST && i >= 0) {
348                         /*
349                          * Account for the slim chance of collision
350                          * and append an instance to the name.
351                          */
352                         device->name = kasprintf(GFP_KERNEL, "%s.%d",
353                                                  kobject_name(&dev->kobj), i++);
354                         goto rename;
355                 }
356
357                 sysfs_remove_link(&dev->kobj, "iommu_group");
358                 kfree(device);
359                 return ret;
360         }
361
362         kobject_get(group->devices_kobj);
363
364         dev->iommu_group = group;
365
366         mutex_lock(&group->mutex);
367         list_add_tail(&device->list, &group->devices);
368         mutex_unlock(&group->mutex);
369
370         /* Notify any listeners about change to group. */
371         blocking_notifier_call_chain(&group->notifier,
372                                      IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
373
374         trace_add_device_to_group(group->id, dev);
375         return 0;
376 }
377 EXPORT_SYMBOL_GPL(iommu_group_add_device);
378
379 /**
380  * iommu_group_remove_device - remove a device from it's current group
381  * @dev: device to be removed
382  *
383  * This function is called by an iommu driver to remove the device from
384  * it's current group.  This decrements the iommu group reference count.
385  */
386 void iommu_group_remove_device(struct device *dev)
387 {
388         struct iommu_group *group = dev->iommu_group;
389         struct iommu_device *tmp_device, *device = NULL;
390
391         /* Pre-notify listeners that a device is being removed. */
392         blocking_notifier_call_chain(&group->notifier,
393                                      IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
394
395         mutex_lock(&group->mutex);
396         list_for_each_entry(tmp_device, &group->devices, list) {
397                 if (tmp_device->dev == dev) {
398                         device = tmp_device;
399                         list_del(&device->list);
400                         break;
401                 }
402         }
403         mutex_unlock(&group->mutex);
404
405         if (!device)
406                 return;
407
408         sysfs_remove_link(group->devices_kobj, device->name);
409         sysfs_remove_link(&dev->kobj, "iommu_group");
410
411         trace_remove_device_from_group(group->id, dev);
412
413         kfree(device->name);
414         kfree(device);
415         dev->iommu_group = NULL;
416         kobject_put(group->devices_kobj);
417 }
418 EXPORT_SYMBOL_GPL(iommu_group_remove_device);
419
420 /**
421  * iommu_group_for_each_dev - iterate over each device in the group
422  * @group: the group
423  * @data: caller opaque data to be passed to callback function
424  * @fn: caller supplied callback function
425  *
426  * This function is called by group users to iterate over group devices.
427  * Callers should hold a reference count to the group during callback.
428  * The group->mutex is held across callbacks, which will block calls to
429  * iommu_group_add/remove_device.
430  */
431 int iommu_group_for_each_dev(struct iommu_group *group, void *data,
432                              int (*fn)(struct device *, void *))
433 {
434         struct iommu_device *device;
435         int ret = 0;
436
437         mutex_lock(&group->mutex);
438         list_for_each_entry(device, &group->devices, list) {
439                 ret = fn(device->dev, data);
440                 if (ret)
441                         break;
442         }
443         mutex_unlock(&group->mutex);
444         return ret;
445 }
446 EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
447
448 /**
449  * iommu_group_get - Return the group for a device and increment reference
450  * @dev: get the group that this device belongs to
451  *
452  * This function is called by iommu drivers and users to get the group
453  * for the specified device.  If found, the group is returned and the group
454  * reference in incremented, else NULL.
455  */
456 struct iommu_group *iommu_group_get(struct device *dev)
457 {
458         struct iommu_group *group = dev->iommu_group;
459
460         if (group)
461                 kobject_get(group->devices_kobj);
462
463         return group;
464 }
465 EXPORT_SYMBOL_GPL(iommu_group_get);
466
467 /**
468  * iommu_group_put - Decrement group reference
469  * @group: the group to use
470  *
471  * This function is called by iommu drivers and users to release the
472  * iommu group.  Once the reference count is zero, the group is released.
473  */
474 void iommu_group_put(struct iommu_group *group)
475 {
476         if (group)
477                 kobject_put(group->devices_kobj);
478 }
479 EXPORT_SYMBOL_GPL(iommu_group_put);
480
481 /**
482  * iommu_group_register_notifier - Register a notifier for group changes
483  * @group: the group to watch
484  * @nb: notifier block to signal
485  *
486  * This function allows iommu group users to track changes in a group.
487  * See include/linux/iommu.h for actions sent via this notifier.  Caller
488  * should hold a reference to the group throughout notifier registration.
489  */
490 int iommu_group_register_notifier(struct iommu_group *group,
491                                   struct notifier_block *nb)
492 {
493         return blocking_notifier_chain_register(&group->notifier, nb);
494 }
495 EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
496
497 /**
498  * iommu_group_unregister_notifier - Unregister a notifier
499  * @group: the group to watch
500  * @nb: notifier block to signal
501  *
502  * Unregister a previously registered group notifier block.
503  */
504 int iommu_group_unregister_notifier(struct iommu_group *group,
505                                     struct notifier_block *nb)
506 {
507         return blocking_notifier_chain_unregister(&group->notifier, nb);
508 }
509 EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
510
511 /**
512  * iommu_group_id - Return ID for a group
513  * @group: the group to ID
514  *
515  * Return the unique ID for the group matching the sysfs group number.
516  */
517 int iommu_group_id(struct iommu_group *group)
518 {
519         return group->id;
520 }
521 EXPORT_SYMBOL_GPL(iommu_group_id);
522
523 static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
524                                                unsigned long *devfns);
525
526 /*
527  * To consider a PCI device isolated, we require ACS to support Source
528  * Validation, Request Redirection, Completer Redirection, and Upstream
529  * Forwarding.  This effectively means that devices cannot spoof their
530  * requester ID, requests and completions cannot be redirected, and all
531  * transactions are forwarded upstream, even as it passes through a
532  * bridge where the target device is downstream.
533  */
534 #define REQ_ACS_FLAGS   (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)
535
536 /*
537  * For multifunction devices which are not isolated from each other, find
538  * all the other non-isolated functions and look for existing groups.  For
539  * each function, we also need to look for aliases to or from other devices
540  * that may already have a group.
541  */
542 static struct iommu_group *get_pci_function_alias_group(struct pci_dev *pdev,
543                                                         unsigned long *devfns)
544 {
545         struct pci_dev *tmp = NULL;
546         struct iommu_group *group;
547
548         if (!pdev->multifunction || pci_acs_enabled(pdev, REQ_ACS_FLAGS))
549                 return NULL;
550
551         for_each_pci_dev(tmp) {
552                 if (tmp == pdev || tmp->bus != pdev->bus ||
553                     PCI_SLOT(tmp->devfn) != PCI_SLOT(pdev->devfn) ||
554                     pci_acs_enabled(tmp, REQ_ACS_FLAGS))
555                         continue;
556
557                 group = get_pci_alias_group(tmp, devfns);
558                 if (group) {
559                         pci_dev_put(tmp);
560                         return group;
561                 }
562         }
563
564         return NULL;
565 }
566
567 /*
568  * Look for aliases to or from the given device for exisiting groups.  The
569  * dma_alias_devfn only supports aliases on the same bus, therefore the search
570  * space is quite small (especially since we're really only looking at pcie
571  * device, and therefore only expect multiple slots on the root complex or
572  * downstream switch ports).  It's conceivable though that a pair of
573  * multifunction devices could have aliases between them that would cause a
574  * loop.  To prevent this, we use a bitmap to track where we've been.
575  */
576 static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
577                                                unsigned long *devfns)
578 {
579         struct pci_dev *tmp = NULL;
580         struct iommu_group *group;
581
582         if (test_and_set_bit(pdev->devfn & 0xff, devfns))
583                 return NULL;
584
585         group = iommu_group_get(&pdev->dev);
586         if (group)
587                 return group;
588
589         for_each_pci_dev(tmp) {
590                 if (tmp == pdev || tmp->bus != pdev->bus)
591                         continue;
592
593                 /* We alias them or they alias us */
594                 if (((pdev->dev_flags & PCI_DEV_FLAGS_DMA_ALIAS_DEVFN) &&
595                      pdev->dma_alias_devfn == tmp->devfn) ||
596                     ((tmp->dev_flags & PCI_DEV_FLAGS_DMA_ALIAS_DEVFN) &&
597                      tmp->dma_alias_devfn == pdev->devfn)) {
598
599                         group = get_pci_alias_group(tmp, devfns);
600                         if (group) {
601                                 pci_dev_put(tmp);
602                                 return group;
603                         }
604
605                         group = get_pci_function_alias_group(tmp, devfns);
606                         if (group) {
607                                 pci_dev_put(tmp);
608                                 return group;
609                         }
610                 }
611         }
612
613         return NULL;
614 }
615
616 struct group_for_pci_data {
617         struct pci_dev *pdev;
618         struct iommu_group *group;
619 };
620
621 /*
622  * DMA alias iterator callback, return the last seen device.  Stop and return
623  * the IOMMU group if we find one along the way.
624  */
625 static int get_pci_alias_or_group(struct pci_dev *pdev, u16 alias, void *opaque)
626 {
627         struct group_for_pci_data *data = opaque;
628
629         data->pdev = pdev;
630         data->group = iommu_group_get(&pdev->dev);
631
632         return data->group != NULL;
633 }
634
635 /*
636  * Use standard PCI bus topology, isolation features, and DMA alias quirks
637  * to find or create an IOMMU group for a device.
638  */
639 static struct iommu_group *iommu_group_get_for_pci_dev(struct pci_dev *pdev)
640 {
641         struct group_for_pci_data data;
642         struct pci_bus *bus;
643         struct iommu_group *group = NULL;
644         u64 devfns[4] = { 0 };
645
646         /*
647          * Find the upstream DMA alias for the device.  A device must not
648          * be aliased due to topology in order to have its own IOMMU group.
649          * If we find an alias along the way that already belongs to a
650          * group, use it.
651          */
652         if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data))
653                 return data.group;
654
655         pdev = data.pdev;
656
657         /*
658          * Continue upstream from the point of minimum IOMMU granularity
659          * due to aliases to the point where devices are protected from
660          * peer-to-peer DMA by PCI ACS.  Again, if we find an existing
661          * group, use it.
662          */
663         for (bus = pdev->bus; !pci_is_root_bus(bus); bus = bus->parent) {
664                 if (!bus->self)
665                         continue;
666
667                 if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))
668                         break;
669
670                 pdev = bus->self;
671
672                 group = iommu_group_get(&pdev->dev);
673                 if (group)
674                         return group;
675         }
676
677         /*
678          * Look for existing groups on device aliases.  If we alias another
679          * device or another device aliases us, use the same group.
680          */
681         group = get_pci_alias_group(pdev, (unsigned long *)devfns);
682         if (group)
683                 return group;
684
685         /*
686          * Look for existing groups on non-isolated functions on the same
687          * slot and aliases of those funcions, if any.  No need to clear
688          * the search bitmap, the tested devfns are still valid.
689          */
690         group = get_pci_function_alias_group(pdev, (unsigned long *)devfns);
691         if (group)
692                 return group;
693
694         /* No shared group found, allocate new */
695         return iommu_group_alloc();
696 }
697
698 /**
699  * iommu_group_get_for_dev - Find or create the IOMMU group for a device
700  * @dev: target device
701  *
702  * This function is intended to be called by IOMMU drivers and extended to
703  * support common, bus-defined algorithms when determining or creating the
704  * IOMMU group for a device.  On success, the caller will hold a reference
705  * to the returned IOMMU group, which will already include the provided
706  * device.  The reference should be released with iommu_group_put().
707  */
708 struct iommu_group *iommu_group_get_for_dev(struct device *dev)
709 {
710         struct iommu_group *group;
711         int ret;
712
713         group = iommu_group_get(dev);
714         if (group)
715                 return group;
716
717         if (!dev_is_pci(dev))
718                 return ERR_PTR(-EINVAL);
719
720         group = iommu_group_get_for_pci_dev(to_pci_dev(dev));
721
722         if (IS_ERR(group))
723                 return group;
724
725         ret = iommu_group_add_device(group, dev);
726         if (ret) {
727                 iommu_group_put(group);
728                 return ERR_PTR(ret);
729         }
730
731         return group;
732 }
733
734 static int add_iommu_group(struct device *dev, void *data)
735 {
736         struct iommu_callback_data *cb = data;
737         const struct iommu_ops *ops = cb->ops;
738
739         if (!ops->add_device)
740                 return 0;
741
742         WARN_ON(dev->iommu_group);
743
744         ops->add_device(dev);
745
746         return 0;
747 }
748
749 static int iommu_bus_notifier(struct notifier_block *nb,
750                               unsigned long action, void *data)
751 {
752         struct device *dev = data;
753         const struct iommu_ops *ops = dev->bus->iommu_ops;
754         struct iommu_group *group;
755         unsigned long group_action = 0;
756
757         /*
758          * ADD/DEL call into iommu driver ops if provided, which may
759          * result in ADD/DEL notifiers to group->notifier
760          */
761         if (action == BUS_NOTIFY_ADD_DEVICE) {
762                 if (ops->add_device)
763                         return ops->add_device(dev);
764         } else if (action == BUS_NOTIFY_DEL_DEVICE) {
765                 if (ops->remove_device && dev->iommu_group) {
766                         ops->remove_device(dev);
767                         return 0;
768                 }
769         }
770
771         /*
772          * Remaining BUS_NOTIFYs get filtered and republished to the
773          * group, if anyone is listening
774          */
775         group = iommu_group_get(dev);
776         if (!group)
777                 return 0;
778
779         switch (action) {
780         case BUS_NOTIFY_BIND_DRIVER:
781                 group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
782                 break;
783         case BUS_NOTIFY_BOUND_DRIVER:
784                 group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
785                 break;
786         case BUS_NOTIFY_UNBIND_DRIVER:
787                 group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
788                 break;
789         case BUS_NOTIFY_UNBOUND_DRIVER:
790                 group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
791                 break;
792         }
793
794         if (group_action)
795                 blocking_notifier_call_chain(&group->notifier,
796                                              group_action, dev);
797
798         iommu_group_put(group);
799         return 0;
800 }
801
802 static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
803 {
804         int err;
805         struct notifier_block *nb;
806         struct iommu_callback_data cb = {
807                 .ops = ops,
808         };
809
810         nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
811         if (!nb)
812                 return -ENOMEM;
813
814         nb->notifier_call = iommu_bus_notifier;
815
816         err = bus_register_notifier(bus, nb);
817         if (err) {
818                 kfree(nb);
819                 return err;
820         }
821
822         err = bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
823         if (err) {
824                 bus_unregister_notifier(bus, nb);
825                 kfree(nb);
826                 return err;
827         }
828
829         return 0;
830 }
831
832 /**
833  * bus_set_iommu - set iommu-callbacks for the bus
834  * @bus: bus.
835  * @ops: the callbacks provided by the iommu-driver
836  *
837  * This function is called by an iommu driver to set the iommu methods
838  * used for a particular bus. Drivers for devices on that bus can use
839  * the iommu-api after these ops are registered.
840  * This special function is needed because IOMMUs are usually devices on
841  * the bus itself, so the iommu drivers are not initialized when the bus
842  * is set up. With this function the iommu-driver can set the iommu-ops
843  * afterwards.
844  */
845 int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
846 {
847         int err;
848
849         if (bus->iommu_ops != NULL)
850                 return -EBUSY;
851
852         bus->iommu_ops = ops;
853
854         /* Do IOMMU specific setup for this bus-type */
855         err = iommu_bus_init(bus, ops);
856         if (err)
857                 bus->iommu_ops = NULL;
858
859         return err;
860 }
861 EXPORT_SYMBOL_GPL(bus_set_iommu);
862
863 bool iommu_present(struct bus_type *bus)
864 {
865         return bus->iommu_ops != NULL;
866 }
867 EXPORT_SYMBOL_GPL(iommu_present);
868
869 bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
870 {
871         if (!bus->iommu_ops || !bus->iommu_ops->capable)
872                 return false;
873
874         return bus->iommu_ops->capable(cap);
875 }
876 EXPORT_SYMBOL_GPL(iommu_capable);
877
878 /**
879  * iommu_set_fault_handler() - set a fault handler for an iommu domain
880  * @domain: iommu domain
881  * @handler: fault handler
882  * @token: user data, will be passed back to the fault handler
883  *
884  * This function should be used by IOMMU users which want to be notified
885  * whenever an IOMMU fault happens.
886  *
887  * The fault handler itself should return 0 on success, and an appropriate
888  * error code otherwise.
889  */
890 void iommu_set_fault_handler(struct iommu_domain *domain,
891                                         iommu_fault_handler_t handler,
892                                         void *token)
893 {
894         BUG_ON(!domain);
895
896         domain->handler = handler;
897         domain->handler_token = token;
898 }
899 EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
900
901 struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
902 {
903         struct iommu_domain *domain;
904
905         if (bus == NULL || bus->iommu_ops == NULL)
906                 return NULL;
907
908         domain = bus->iommu_ops->domain_alloc(IOMMU_DOMAIN_UNMANAGED);
909         if (!domain)
910                 return NULL;
911
912         domain->ops  = bus->iommu_ops;
913         domain->type = IOMMU_DOMAIN_UNMANAGED;
914
915         return domain;
916 }
917 EXPORT_SYMBOL_GPL(iommu_domain_alloc);
918
919 void iommu_domain_free(struct iommu_domain *domain)
920 {
921         domain->ops->domain_free(domain);
922 }
923 EXPORT_SYMBOL_GPL(iommu_domain_free);
924
925 int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
926 {
927         int ret;
928         if (unlikely(domain->ops->attach_dev == NULL))
929                 return -ENODEV;
930
931         ret = domain->ops->attach_dev(domain, dev);
932         if (!ret)
933                 trace_attach_device_to_domain(dev);
934         return ret;
935 }
936 EXPORT_SYMBOL_GPL(iommu_attach_device);
937
938 void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
939 {
940         if (unlikely(domain->ops->detach_dev == NULL))
941                 return;
942
943         domain->ops->detach_dev(domain, dev);
944         trace_detach_device_from_domain(dev);
945 }
946 EXPORT_SYMBOL_GPL(iommu_detach_device);
947
948 /*
949  * IOMMU groups are really the natrual working unit of the IOMMU, but
950  * the IOMMU API works on domains and devices.  Bridge that gap by
951  * iterating over the devices in a group.  Ideally we'd have a single
952  * device which represents the requestor ID of the group, but we also
953  * allow IOMMU drivers to create policy defined minimum sets, where
954  * the physical hardware may be able to distiguish members, but we
955  * wish to group them at a higher level (ex. untrusted multi-function
956  * PCI devices).  Thus we attach each device.
957  */
958 static int iommu_group_do_attach_device(struct device *dev, void *data)
959 {
960         struct iommu_domain *domain = data;
961
962         return iommu_attach_device(domain, dev);
963 }
964
965 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
966 {
967         return iommu_group_for_each_dev(group, domain,
968                                         iommu_group_do_attach_device);
969 }
970 EXPORT_SYMBOL_GPL(iommu_attach_group);
971
972 static int iommu_group_do_detach_device(struct device *dev, void *data)
973 {
974         struct iommu_domain *domain = data;
975
976         iommu_detach_device(domain, dev);
977
978         return 0;
979 }
980
981 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
982 {
983         iommu_group_for_each_dev(group, domain, iommu_group_do_detach_device);
984 }
985 EXPORT_SYMBOL_GPL(iommu_detach_group);
986
987 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
988 {
989         if (unlikely(domain->ops->iova_to_phys == NULL))
990                 return 0;
991
992         return domain->ops->iova_to_phys(domain, iova);
993 }
994 EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
995
996 static size_t iommu_pgsize(struct iommu_domain *domain,
997                            unsigned long addr_merge, size_t size)
998 {
999         unsigned int pgsize_idx;
1000         size_t pgsize;
1001
1002         /* Max page size that still fits into 'size' */
1003         pgsize_idx = __fls(size);
1004
1005         /* need to consider alignment requirements ? */
1006         if (likely(addr_merge)) {
1007                 /* Max page size allowed by address */
1008                 unsigned int align_pgsize_idx = __ffs(addr_merge);
1009                 pgsize_idx = min(pgsize_idx, align_pgsize_idx);
1010         }
1011
1012         /* build a mask of acceptable page sizes */
1013         pgsize = (1UL << (pgsize_idx + 1)) - 1;
1014
1015         /* throw away page sizes not supported by the hardware */
1016         pgsize &= domain->ops->pgsize_bitmap;
1017
1018         /* make sure we're still sane */
1019         BUG_ON(!pgsize);
1020
1021         /* pick the biggest page */
1022         pgsize_idx = __fls(pgsize);
1023         pgsize = 1UL << pgsize_idx;
1024
1025         return pgsize;
1026 }
1027
1028 int iommu_map(struct iommu_domain *domain, unsigned long iova,
1029               phys_addr_t paddr, size_t size, int prot)
1030 {
1031         unsigned long orig_iova = iova;
1032         unsigned int min_pagesz;
1033         size_t orig_size = size;
1034         int ret = 0;
1035
1036         if (unlikely(domain->ops->map == NULL ||
1037                      domain->ops->pgsize_bitmap == 0UL))
1038                 return -ENODEV;
1039
1040         if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
1041                 return -EINVAL;
1042
1043         /* find out the minimum page size supported */
1044         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
1045
1046         /*
1047          * both the virtual address and the physical one, as well as
1048          * the size of the mapping, must be aligned (at least) to the
1049          * size of the smallest page supported by the hardware
1050          */
1051         if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
1052                 pr_err("unaligned: iova 0x%lx pa %pa size 0x%zx min_pagesz 0x%x\n",
1053                        iova, &paddr, size, min_pagesz);
1054                 return -EINVAL;
1055         }
1056
1057         pr_debug("map: iova 0x%lx pa %pa size 0x%zx\n", iova, &paddr, size);
1058
1059         while (size) {
1060                 size_t pgsize = iommu_pgsize(domain, iova | paddr, size);
1061
1062                 pr_debug("mapping: iova 0x%lx pa %pa pgsize 0x%zx\n",
1063                          iova, &paddr, pgsize);
1064
1065                 ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
1066                 if (ret)
1067                         break;
1068
1069                 iova += pgsize;
1070                 paddr += pgsize;
1071                 size -= pgsize;
1072         }
1073
1074         /* unroll mapping in case something went wrong */
1075         if (ret)
1076                 iommu_unmap(domain, orig_iova, orig_size - size);
1077         else
1078                 trace_map(orig_iova, paddr, orig_size);
1079
1080         return ret;
1081 }
1082 EXPORT_SYMBOL_GPL(iommu_map);
1083
1084 size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
1085 {
1086         size_t unmapped_page, unmapped = 0;
1087         unsigned int min_pagesz;
1088         unsigned long orig_iova = iova;
1089
1090         if (unlikely(domain->ops->unmap == NULL ||
1091                      domain->ops->pgsize_bitmap == 0UL))
1092                 return -ENODEV;
1093
1094         if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
1095                 return -EINVAL;
1096
1097         /* find out the minimum page size supported */
1098         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
1099
1100         /*
1101          * The virtual address, as well as the size of the mapping, must be
1102          * aligned (at least) to the size of the smallest page supported
1103          * by the hardware
1104          */
1105         if (!IS_ALIGNED(iova | size, min_pagesz)) {
1106                 pr_err("unaligned: iova 0x%lx size 0x%zx min_pagesz 0x%x\n",
1107                        iova, size, min_pagesz);
1108                 return -EINVAL;
1109         }
1110
1111         pr_debug("unmap this: iova 0x%lx size 0x%zx\n", iova, size);
1112
1113         /*
1114          * Keep iterating until we either unmap 'size' bytes (or more)
1115          * or we hit an area that isn't mapped.
1116          */
1117         while (unmapped < size) {
1118                 size_t pgsize = iommu_pgsize(domain, iova, size - unmapped);
1119
1120                 unmapped_page = domain->ops->unmap(domain, iova, pgsize);
1121                 if (!unmapped_page)
1122                         break;
1123
1124                 pr_debug("unmapped: iova 0x%lx size 0x%zx\n",
1125                          iova, unmapped_page);
1126
1127                 iova += unmapped_page;
1128                 unmapped += unmapped_page;
1129         }
1130
1131         trace_unmap(orig_iova, size, unmapped);
1132         return unmapped;
1133 }
1134 EXPORT_SYMBOL_GPL(iommu_unmap);
1135
1136 size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
1137                          struct scatterlist *sg, unsigned int nents, int prot)
1138 {
1139         struct scatterlist *s;
1140         size_t mapped = 0;
1141         unsigned int i, min_pagesz;
1142         int ret;
1143
1144         if (unlikely(domain->ops->pgsize_bitmap == 0UL))
1145                 return 0;
1146
1147         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
1148
1149         for_each_sg(sg, s, nents, i) {
1150                 phys_addr_t phys = page_to_phys(sg_page(s)) + s->offset;
1151
1152                 /*
1153                  * We are mapping on IOMMU page boundaries, so offset within
1154                  * the page must be 0. However, the IOMMU may support pages
1155                  * smaller than PAGE_SIZE, so s->offset may still represent
1156                  * an offset of that boundary within the CPU page.
1157                  */
1158                 if (!IS_ALIGNED(s->offset, min_pagesz))
1159                         goto out_err;
1160
1161                 ret = iommu_map(domain, iova + mapped, phys, s->length, prot);
1162                 if (ret)
1163                         goto out_err;
1164
1165                 mapped += s->length;
1166         }
1167
1168         return mapped;
1169
1170 out_err:
1171         /* undo mappings already done */
1172         iommu_unmap(domain, iova, mapped);
1173
1174         return 0;
1175
1176 }
1177 EXPORT_SYMBOL_GPL(default_iommu_map_sg);
1178
1179 int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
1180                                phys_addr_t paddr, u64 size, int prot)
1181 {
1182         if (unlikely(domain->ops->domain_window_enable == NULL))
1183                 return -ENODEV;
1184
1185         return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
1186                                                  prot);
1187 }
1188 EXPORT_SYMBOL_GPL(iommu_domain_window_enable);
1189
1190 void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr)
1191 {
1192         if (unlikely(domain->ops->domain_window_disable == NULL))
1193                 return;
1194
1195         return domain->ops->domain_window_disable(domain, wnd_nr);
1196 }
1197 EXPORT_SYMBOL_GPL(iommu_domain_window_disable);
1198
1199 static int __init iommu_init(void)
1200 {
1201         iommu_group_kset = kset_create_and_add("iommu_groups",
1202                                                NULL, kernel_kobj);
1203         ida_init(&iommu_group_ida);
1204         mutex_init(&iommu_group_mutex);
1205
1206         BUG_ON(!iommu_group_kset);
1207
1208         return 0;
1209 }
1210 arch_initcall(iommu_init);
1211
1212 int iommu_domain_get_attr(struct iommu_domain *domain,
1213                           enum iommu_attr attr, void *data)
1214 {
1215         struct iommu_domain_geometry *geometry;
1216         bool *paging;
1217         int ret = 0;
1218         u32 *count;
1219
1220         switch (attr) {
1221         case DOMAIN_ATTR_GEOMETRY:
1222                 geometry  = data;
1223                 *geometry = domain->geometry;
1224
1225                 break;
1226         case DOMAIN_ATTR_PAGING:
1227                 paging  = data;
1228                 *paging = (domain->ops->pgsize_bitmap != 0UL);
1229                 break;
1230         case DOMAIN_ATTR_WINDOWS:
1231                 count = data;
1232
1233                 if (domain->ops->domain_get_windows != NULL)
1234                         *count = domain->ops->domain_get_windows(domain);
1235                 else
1236                         ret = -ENODEV;
1237
1238                 break;
1239         default:
1240                 if (!domain->ops->domain_get_attr)
1241                         return -EINVAL;
1242
1243                 ret = domain->ops->domain_get_attr(domain, attr, data);
1244         }
1245
1246         return ret;
1247 }
1248 EXPORT_SYMBOL_GPL(iommu_domain_get_attr);
1249
1250 int iommu_domain_set_attr(struct iommu_domain *domain,
1251                           enum iommu_attr attr, void *data)
1252 {
1253         int ret = 0;
1254         u32 *count;
1255
1256         switch (attr) {
1257         case DOMAIN_ATTR_WINDOWS:
1258                 count = data;
1259
1260                 if (domain->ops->domain_set_windows != NULL)
1261                         ret = domain->ops->domain_set_windows(domain, *count);
1262                 else
1263                         ret = -ENODEV;
1264
1265                 break;
1266         default:
1267                 if (domain->ops->domain_set_attr == NULL)
1268                         return -EINVAL;
1269
1270                 ret = domain->ops->domain_set_attr(domain, attr, data);
1271         }
1272
1273         return ret;
1274 }
1275 EXPORT_SYMBOL_GPL(iommu_domain_set_attr);