clocks: tegra12: Use static CPU-EMC co-relation
[linux-3.10.git] / drivers / iommu / iommu.c
1 /*
2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
3  * Author: Joerg Roedel <joerg.roedel@amd.com>
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
33 static struct kset *iommu_group_kset;
34 static struct ida iommu_group_ida;
35 static struct mutex iommu_group_mutex;
36
37 struct iommu_group {
38         struct kobject kobj;
39         struct kobject *devices_kobj;
40         struct list_head devices;
41         struct mutex mutex;
42         struct blocking_notifier_head notifier;
43         void *iommu_data;
44         void (*iommu_data_release)(void *iommu_data);
45         char *name;
46         int id;
47 };
48
49 struct iommu_device {
50         struct list_head list;
51         struct device *dev;
52         char *name;
53 };
54
55 struct iommu_group_attribute {
56         struct attribute attr;
57         ssize_t (*show)(struct iommu_group *group, char *buf);
58         ssize_t (*store)(struct iommu_group *group,
59                          const char *buf, size_t count);
60 };
61
62 #define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
63 struct iommu_group_attribute iommu_group_attr_##_name =         \
64         __ATTR(_name, _mode, _show, _store)
65
66 #define to_iommu_group_attr(_attr)      \
67         container_of(_attr, struct iommu_group_attribute, attr)
68 #define to_iommu_group(_kobj)           \
69         container_of(_kobj, struct iommu_group, kobj)
70
71 static ssize_t iommu_group_attr_show(struct kobject *kobj,
72                                      struct attribute *__attr, char *buf)
73 {
74         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
75         struct iommu_group *group = to_iommu_group(kobj);
76         ssize_t ret = -EIO;
77
78         if (attr->show)
79                 ret = attr->show(group, buf);
80         return ret;
81 }
82
83 static ssize_t iommu_group_attr_store(struct kobject *kobj,
84                                       struct attribute *__attr,
85                                       const char *buf, size_t count)
86 {
87         struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
88         struct iommu_group *group = to_iommu_group(kobj);
89         ssize_t ret = -EIO;
90
91         if (attr->store)
92                 ret = attr->store(group, buf, count);
93         return ret;
94 }
95
96 static const struct sysfs_ops iommu_group_sysfs_ops = {
97         .show = iommu_group_attr_show,
98         .store = iommu_group_attr_store,
99 };
100
101 static int iommu_group_create_file(struct iommu_group *group,
102                                    struct iommu_group_attribute *attr)
103 {
104         return sysfs_create_file(&group->kobj, &attr->attr);
105 }
106
107 static void iommu_group_remove_file(struct iommu_group *group,
108                                     struct iommu_group_attribute *attr)
109 {
110         sysfs_remove_file(&group->kobj, &attr->attr);
111 }
112
113 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
114 {
115         return sprintf(buf, "%s\n", group->name);
116 }
117
118 static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
119
120 static void iommu_group_release(struct kobject *kobj)
121 {
122         struct iommu_group *group = to_iommu_group(kobj);
123
124         if (group->iommu_data_release)
125                 group->iommu_data_release(group->iommu_data);
126
127         mutex_lock(&iommu_group_mutex);
128         ida_remove(&iommu_group_ida, group->id);
129         mutex_unlock(&iommu_group_mutex);
130
131         kfree(group->name);
132         kfree(group);
133 }
134
135 static struct kobj_type iommu_group_ktype = {
136         .sysfs_ops = &iommu_group_sysfs_ops,
137         .release = iommu_group_release,
138 };
139
140 /**
141  * iommu_group_alloc - Allocate a new group
142  * @name: Optional name to associate with group, visible in sysfs
143  *
144  * This function is called by an iommu driver to allocate a new iommu
145  * group.  The iommu group represents the minimum granularity of the iommu.
146  * Upon successful return, the caller holds a reference to the supplied
147  * group in order to hold the group until devices are added.  Use
148  * iommu_group_put() to release this extra reference count, allowing the
149  * group to be automatically reclaimed once it has no devices or external
150  * references.
151  */
152 struct iommu_group *iommu_group_alloc(void)
153 {
154         struct iommu_group *group;
155         int ret;
156
157         group = kzalloc(sizeof(*group), GFP_KERNEL);
158         if (!group)
159                 return ERR_PTR(-ENOMEM);
160
161         group->kobj.kset = iommu_group_kset;
162         mutex_init(&group->mutex);
163         INIT_LIST_HEAD(&group->devices);
164         BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
165
166         mutex_lock(&iommu_group_mutex);
167
168 again:
169         if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
170                 kfree(group);
171                 mutex_unlock(&iommu_group_mutex);
172                 return ERR_PTR(-ENOMEM);
173         }
174
175         if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
176                 goto again;
177
178         mutex_unlock(&iommu_group_mutex);
179
180         ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
181                                    NULL, "%d", group->id);
182         if (ret) {
183                 mutex_lock(&iommu_group_mutex);
184                 ida_remove(&iommu_group_ida, group->id);
185                 mutex_unlock(&iommu_group_mutex);
186                 kfree(group);
187                 return ERR_PTR(ret);
188         }
189
190         group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
191         if (!group->devices_kobj) {
192                 kobject_put(&group->kobj); /* triggers .release & free */
193                 return ERR_PTR(-ENOMEM);
194         }
195
196         /*
197          * The devices_kobj holds a reference on the group kobject, so
198          * as long as that exists so will the group.  We can therefore
199          * use the devices_kobj for reference counting.
200          */
201         kobject_put(&group->kobj);
202
203         return group;
204 }
205 EXPORT_SYMBOL_GPL(iommu_group_alloc);
206
207 struct iommu_group *iommu_group_get_by_id(int id)
208 {
209         struct kobject *group_kobj;
210         struct iommu_group *group;
211         const char *name;
212
213         if (!iommu_group_kset)
214                 return NULL;
215
216         name = kasprintf(GFP_KERNEL, "%d", id);
217         if (!name)
218                 return NULL;
219
220         group_kobj = kset_find_obj(iommu_group_kset, name);
221         kfree(name);
222
223         if (!group_kobj)
224                 return NULL;
225
226         group = container_of(group_kobj, struct iommu_group, kobj);
227         BUG_ON(group->id != id);
228
229         kobject_get(group->devices_kobj);
230         kobject_put(&group->kobj);
231
232         return group;
233 }
234 EXPORT_SYMBOL_GPL(iommu_group_get_by_id);
235
236 /**
237  * iommu_group_get_iommudata - retrieve iommu_data registered for a group
238  * @group: the group
239  *
240  * iommu drivers can store data in the group for use when doing iommu
241  * operations.  This function provides a way to retrieve it.  Caller
242  * should hold a group reference.
243  */
244 void *iommu_group_get_iommudata(struct iommu_group *group)
245 {
246         return group->iommu_data;
247 }
248 EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
249
250 /**
251  * iommu_group_set_iommudata - set iommu_data for a group
252  * @group: the group
253  * @iommu_data: new data
254  * @release: release function for iommu_data
255  *
256  * iommu drivers can store data in the group for use when doing iommu
257  * operations.  This function provides a way to set the data after
258  * the group has been allocated.  Caller should hold a group reference.
259  */
260 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
261                                void (*release)(void *iommu_data))
262 {
263         group->iommu_data = iommu_data;
264         group->iommu_data_release = release;
265 }
266 EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
267
268 /**
269  * iommu_group_set_name - set name for a group
270  * @group: the group
271  * @name: name
272  *
273  * Allow iommu driver to set a name for a group.  When set it will
274  * appear in a name attribute file under the group in sysfs.
275  */
276 int iommu_group_set_name(struct iommu_group *group, const char *name)
277 {
278         int ret;
279
280         if (group->name) {
281                 iommu_group_remove_file(group, &iommu_group_attr_name);
282                 kfree(group->name);
283                 group->name = NULL;
284                 if (!name)
285                         return 0;
286         }
287
288         group->name = kstrdup(name, GFP_KERNEL);
289         if (!group->name)
290                 return -ENOMEM;
291
292         ret = iommu_group_create_file(group, &iommu_group_attr_name);
293         if (ret) {
294                 kfree(group->name);
295                 group->name = NULL;
296                 return ret;
297         }
298
299         return 0;
300 }
301 EXPORT_SYMBOL_GPL(iommu_group_set_name);
302
303 /**
304  * iommu_group_add_device - add a device to an iommu group
305  * @group: the group into which to add the device (reference should be held)
306  * @dev: the device
307  *
308  * This function is called by an iommu driver to add a device into a
309  * group.  Adding a device increments the group reference count.
310  */
311 int iommu_group_add_device(struct iommu_group *group, struct device *dev)
312 {
313         int ret, i = 0;
314         struct iommu_device *device;
315
316         device = kzalloc(sizeof(*device), GFP_KERNEL);
317         if (!device)
318                 return -ENOMEM;
319
320         device->dev = dev;
321
322         ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
323         if (ret) {
324                 kfree(device);
325                 return ret;
326         }
327
328         device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
329 rename:
330         if (!device->name) {
331                 sysfs_remove_link(&dev->kobj, "iommu_group");
332                 kfree(device);
333                 return -ENOMEM;
334         }
335
336         ret = sysfs_create_link_nowarn(group->devices_kobj,
337                                        &dev->kobj, device->name);
338         if (ret) {
339                 kfree(device->name);
340                 if (ret == -EEXIST && i >= 0) {
341                         /*
342                          * Account for the slim chance of collision
343                          * and append an instance to the name.
344                          */
345                         device->name = kasprintf(GFP_KERNEL, "%s.%d",
346                                                  kobject_name(&dev->kobj), i++);
347                         goto rename;
348                 }
349
350                 sysfs_remove_link(&dev->kobj, "iommu_group");
351                 kfree(device);
352                 return ret;
353         }
354
355         kobject_get(group->devices_kobj);
356
357         dev->iommu_group = group;
358
359         mutex_lock(&group->mutex);
360         list_add_tail(&device->list, &group->devices);
361         mutex_unlock(&group->mutex);
362
363         /* Notify any listeners about change to group. */
364         blocking_notifier_call_chain(&group->notifier,
365                                      IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
366         return 0;
367 }
368 EXPORT_SYMBOL_GPL(iommu_group_add_device);
369
370 /**
371  * iommu_group_remove_device - remove a device from it's current group
372  * @dev: device to be removed
373  *
374  * This function is called by an iommu driver to remove the device from
375  * it's current group.  This decrements the iommu group reference count.
376  */
377 void iommu_group_remove_device(struct device *dev)
378 {
379         struct iommu_group *group = dev->iommu_group;
380         struct iommu_device *tmp_device, *device = NULL;
381
382         /* Pre-notify listeners that a device is being removed. */
383         blocking_notifier_call_chain(&group->notifier,
384                                      IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
385
386         mutex_lock(&group->mutex);
387         list_for_each_entry(tmp_device, &group->devices, list) {
388                 if (tmp_device->dev == dev) {
389                         device = tmp_device;
390                         list_del(&device->list);
391                         break;
392                 }
393         }
394         mutex_unlock(&group->mutex);
395
396         if (!device)
397                 return;
398
399         sysfs_remove_link(group->devices_kobj, device->name);
400         sysfs_remove_link(&dev->kobj, "iommu_group");
401
402         kfree(device->name);
403         kfree(device);
404         dev->iommu_group = NULL;
405         kobject_put(group->devices_kobj);
406 }
407 EXPORT_SYMBOL_GPL(iommu_group_remove_device);
408
409 /**
410  * iommu_group_for_each_dev - iterate over each device in the group
411  * @group: the group
412  * @data: caller opaque data to be passed to callback function
413  * @fn: caller supplied callback function
414  *
415  * This function is called by group users to iterate over group devices.
416  * Callers should hold a reference count to the group during callback.
417  * The group->mutex is held across callbacks, which will block calls to
418  * iommu_group_add/remove_device.
419  */
420 int iommu_group_for_each_dev(struct iommu_group *group, void *data,
421                              int (*fn)(struct device *, void *))
422 {
423         struct iommu_device *device;
424         int ret = 0;
425
426         mutex_lock(&group->mutex);
427         list_for_each_entry(device, &group->devices, list) {
428                 ret = fn(device->dev, data);
429                 if (ret)
430                         break;
431         }
432         mutex_unlock(&group->mutex);
433         return ret;
434 }
435 EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
436
437 /**
438  * iommu_group_get - Return the group for a device and increment reference
439  * @dev: get the group that this device belongs to
440  *
441  * This function is called by iommu drivers and users to get the group
442  * for the specified device.  If found, the group is returned and the group
443  * reference in incremented, else NULL.
444  */
445 struct iommu_group *iommu_group_get(struct device *dev)
446 {
447         struct iommu_group *group = dev->iommu_group;
448
449         if (group)
450                 kobject_get(group->devices_kobj);
451
452         return group;
453 }
454 EXPORT_SYMBOL_GPL(iommu_group_get);
455
456 /**
457  * iommu_group_put - Decrement group reference
458  * @group: the group to use
459  *
460  * This function is called by iommu drivers and users to release the
461  * iommu group.  Once the reference count is zero, the group is released.
462  */
463 void iommu_group_put(struct iommu_group *group)
464 {
465         if (group)
466                 kobject_put(group->devices_kobj);
467 }
468 EXPORT_SYMBOL_GPL(iommu_group_put);
469
470 /**
471  * iommu_group_register_notifier - Register a notifier for group changes
472  * @group: the group to watch
473  * @nb: notifier block to signal
474  *
475  * This function allows iommu group users to track changes in a group.
476  * See include/linux/iommu.h for actions sent via this notifier.  Caller
477  * should hold a reference to the group throughout notifier registration.
478  */
479 int iommu_group_register_notifier(struct iommu_group *group,
480                                   struct notifier_block *nb)
481 {
482         return blocking_notifier_chain_register(&group->notifier, nb);
483 }
484 EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
485
486 /**
487  * iommu_group_unregister_notifier - Unregister a notifier
488  * @group: the group to watch
489  * @nb: notifier block to signal
490  *
491  * Unregister a previously registered group notifier block.
492  */
493 int iommu_group_unregister_notifier(struct iommu_group *group,
494                                     struct notifier_block *nb)
495 {
496         return blocking_notifier_chain_unregister(&group->notifier, nb);
497 }
498 EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
499
500 /**
501  * iommu_group_id - Return ID for a group
502  * @group: the group to ID
503  *
504  * Return the unique ID for the group matching the sysfs group number.
505  */
506 int iommu_group_id(struct iommu_group *group)
507 {
508         return group->id;
509 }
510 EXPORT_SYMBOL_GPL(iommu_group_id);
511
512 static int add_iommu_group(struct device *dev, void *data)
513 {
514         struct iommu_ops *ops = data;
515
516         if (!ops->add_device)
517                 return -ENODEV;
518
519         WARN_ON(dev->iommu_group);
520
521         ops->add_device(dev);
522
523         return 0;
524 }
525
526 static int iommu_bus_notifier(struct notifier_block *nb,
527                               unsigned long action, void *data)
528 {
529         struct device *dev = data;
530         struct iommu_ops *ops;
531         struct iommu_group *group;
532         unsigned long group_action = 0;
533
534         if (!dev || !dev->bus|| !dev->bus->iommu_ops)
535                 return 0;
536
537         ops = dev->bus->iommu_ops;
538
539         /*
540          * ADD/DEL call into iommu driver ops if provided, which may
541          * result in ADD/DEL notifiers to group->notifier
542          */
543         switch (action) {
544         case BUS_NOTIFY_ADD_DEVICE:
545                 if (ops->add_device)
546                         return ops->add_device(dev);
547                 break;
548         case BUS_NOTIFY_DEL_DEVICE:
549                 if (ops->remove_device && dev->iommu_group) {
550                         ops->remove_device(dev);
551                         return 0;
552                 }
553                 break;
554         case BUS_NOTIFY_BOUND_DRIVER:
555                 if (ops->bound_driver)
556                         ops->bound_driver(dev);
557                 break;
558         case BUS_NOTIFY_UNBIND_DRIVER:
559                 if (ops->unbind_driver)
560                         ops->unbind_driver(dev);
561                 break;
562         };
563
564         /*
565          * Remaining BUS_NOTIFYs get filtered and republished to the
566          * group, if anyone is listening
567          */
568         group = iommu_group_get(dev);
569         if (!group)
570                 return 0;
571
572         switch (action) {
573         case BUS_NOTIFY_BIND_DRIVER:
574                 group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
575                 break;
576         case BUS_NOTIFY_BOUND_DRIVER:
577                 group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
578                 break;
579         case BUS_NOTIFY_UNBIND_DRIVER:
580                 group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
581                 break;
582         case BUS_NOTIFY_UNBOUND_DRIVER:
583                 group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
584                 break;
585         }
586
587         if (group_action)
588                 blocking_notifier_call_chain(&group->notifier,
589                                              group_action, dev);
590
591         iommu_group_put(group);
592         return 0;
593 }
594
595 static struct notifier_block iommu_bus_nb = {
596         .notifier_call = iommu_bus_notifier,
597 };
598
599 static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
600 {
601         bus_register_notifier(bus, &iommu_bus_nb);
602         bus_for_each_dev(bus, NULL, ops, add_iommu_group);
603 }
604
605 /**
606  * bus_set_iommu - set iommu-callbacks for the bus
607  * @bus: bus.
608  * @ops: the callbacks provided by the iommu-driver
609  *
610  * This function is called by an iommu driver to set the iommu methods
611  * used for a particular bus. Drivers for devices on that bus can use
612  * the iommu-api after these ops are registered.
613  * This special function is needed because IOMMUs are usually devices on
614  * the bus itself, so the iommu drivers are not initialized when the bus
615  * is set up. With this function the iommu-driver can set the iommu-ops
616  * afterwards.
617  */
618 int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops)
619 {
620         if (bus->iommu_ops != NULL)
621                 return -EBUSY;
622
623         bus->iommu_ops = ops;
624
625         /* Do IOMMU specific setup for this bus-type */
626         iommu_bus_init(bus, ops);
627
628         return 0;
629 }
630 EXPORT_SYMBOL_GPL(bus_set_iommu);
631
632 bool iommu_present(struct bus_type *bus)
633 {
634         return bus->iommu_ops != NULL;
635 }
636 EXPORT_SYMBOL_GPL(iommu_present);
637
638 bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
639 {
640         if (!bus->iommu_ops || !bus->iommu_ops->capable)
641                 return false;
642
643         return bus->iommu_ops->capable(cap);
644 }
645 EXPORT_SYMBOL_GPL(iommu_capable);
646
647 /**
648  * iommu_set_fault_handler() - set a fault handler for an iommu domain
649  * @domain: iommu domain
650  * @handler: fault handler
651  * @token: user data, will be passed back to the fault handler
652  *
653  * This function should be used by IOMMU users which want to be notified
654  * whenever an IOMMU fault happens.
655  *
656  * The fault handler itself should return 0 on success, and an appropriate
657  * error code otherwise.
658  */
659 void iommu_set_fault_handler(struct iommu_domain *domain,
660                                         iommu_fault_handler_t handler,
661                                         void *token)
662 {
663         BUG_ON(!domain);
664
665         domain->handler = handler;
666         domain->handler_token = token;
667 }
668 EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
669
670 struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
671 {
672         struct iommu_domain *domain;
673         int ret;
674
675         if (bus == NULL || bus->iommu_ops == NULL)
676                 return NULL;
677
678         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
679         if (!domain)
680                 return NULL;
681
682         domain->ops = bus->iommu_ops;
683
684         ret = domain->ops->domain_init(domain);
685         if (ret)
686                 goto out_free;
687
688         return domain;
689
690 out_free:
691         kfree(domain);
692
693         return NULL;
694 }
695 EXPORT_SYMBOL_GPL(iommu_domain_alloc);
696
697 void iommu_domain_free(struct iommu_domain *domain)
698 {
699         if (likely(domain->ops->domain_destroy != NULL))
700                 domain->ops->domain_destroy(domain);
701
702         kfree(domain);
703 }
704 EXPORT_SYMBOL_GPL(iommu_domain_free);
705
706 int iommu_get_hwid(struct iommu_domain *domain, struct device *dev,
707                    unsigned int id)
708 {
709         if (unlikely(domain->ops->get_hwid == NULL))
710                 return -ENODEV;
711
712         return domain->ops->get_hwid(domain, dev, id);
713 }
714 EXPORT_SYMBOL_GPL(iommu_get_hwid);
715
716 int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
717 {
718         if (unlikely(domain->ops->attach_dev == NULL))
719                 return -ENODEV;
720
721         return domain->ops->attach_dev(domain, dev);
722 }
723 EXPORT_SYMBOL_GPL(iommu_attach_device);
724
725 void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
726 {
727         if (unlikely(domain->ops->detach_dev == NULL))
728                 return;
729
730         domain->ops->detach_dev(domain, dev);
731 }
732 EXPORT_SYMBOL_GPL(iommu_detach_device);
733
734 /*
735  * IOMMU groups are really the natrual working unit of the IOMMU, but
736  * the IOMMU API works on domains and devices.  Bridge that gap by
737  * iterating over the devices in a group.  Ideally we'd have a single
738  * device which represents the requestor ID of the group, but we also
739  * allow IOMMU drivers to create policy defined minimum sets, where
740  * the physical hardware may be able to distiguish members, but we
741  * wish to group them at a higher level (ex. untrusted multi-function
742  * PCI devices).  Thus we attach each device.
743  */
744 static int iommu_group_do_attach_device(struct device *dev, void *data)
745 {
746         struct iommu_domain *domain = data;
747
748         return iommu_attach_device(domain, dev);
749 }
750
751 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
752 {
753         return iommu_group_for_each_dev(group, domain,
754                                         iommu_group_do_attach_device);
755 }
756 EXPORT_SYMBOL_GPL(iommu_attach_group);
757
758 static int iommu_group_do_detach_device(struct device *dev, void *data)
759 {
760         struct iommu_domain *domain = data;
761
762         iommu_detach_device(domain, dev);
763
764         return 0;
765 }
766
767 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
768 {
769         iommu_group_for_each_dev(group, domain, iommu_group_do_detach_device);
770 }
771 EXPORT_SYMBOL_GPL(iommu_detach_group);
772
773 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
774 {
775         if (unlikely(domain->ops->iova_to_phys == NULL))
776                 return 0;
777
778         return domain->ops->iova_to_phys(domain, iova);
779 }
780 EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
781
782 int iommu_map(struct iommu_domain *domain, unsigned long iova,
783               phys_addr_t paddr, size_t size, unsigned long prot)
784 {
785         unsigned long orig_iova = iova;
786         unsigned int min_pagesz;
787         size_t orig_size = size;
788         int ret = 0;
789
790         if (unlikely(domain->ops->unmap == NULL ||
791                      domain->ops->pgsize_bitmap == 0UL))
792                 return -ENODEV;
793
794         /* find out the minimum page size supported */
795         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
796
797         /*
798          * both the virtual address and the physical one, as well as
799          * the size of the mapping, must be aligned (at least) to the
800          * size of the smallest page supported by the hardware
801          */
802         if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
803                 pr_err("unaligned: iova 0x%lx pa 0x%lx size 0x%lx min_pagesz "
804                         "0x%x\n", iova, (unsigned long)paddr,
805                         (unsigned long)size, min_pagesz);
806                 return -EINVAL;
807         }
808
809         pr_debug("map: iova 0x%lx pa 0x%lx size 0x%lx\n", iova,
810                                 (unsigned long)paddr, (unsigned long)size);
811
812         while (size) {
813                 unsigned long pgsize, addr_merge = iova | paddr;
814                 unsigned int pgsize_idx;
815
816                 /* Max page size that still fits into 'size' */
817                 pgsize_idx = __fls(size);
818
819                 /* need to consider alignment requirements ? */
820                 if (likely(addr_merge)) {
821                         /* Max page size allowed by both iova and paddr */
822                         unsigned int align_pgsize_idx = __ffs(addr_merge);
823
824                         pgsize_idx = min(pgsize_idx, align_pgsize_idx);
825                 }
826
827                 /* build a mask of acceptable page sizes */
828                 pgsize = (1UL << (pgsize_idx + 1)) - 1;
829
830                 /* throw away page sizes not supported by the hardware */
831                 pgsize &= domain->ops->pgsize_bitmap;
832
833                 /* make sure we're still sane */
834                 BUG_ON(!pgsize);
835
836                 /* pick the biggest page */
837                 pgsize_idx = __fls(pgsize);
838                 pgsize = 1UL << pgsize_idx;
839
840                 pr_debug("mapping: iova 0x%lx pa 0x%lx pgsize %lu\n", iova,
841                                         (unsigned long)paddr, pgsize);
842
843                 ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
844                 if (ret)
845                         break;
846
847                 iova += pgsize;
848                 paddr += pgsize;
849                 size -= pgsize;
850         }
851
852         /* unroll mapping in case something went wrong */
853         if (ret)
854                 iommu_unmap(domain, orig_iova, orig_size - size);
855
856         return ret;
857 }
858 EXPORT_SYMBOL_GPL(iommu_map);
859
860 int iommu_map_pages(struct iommu_domain *domain, unsigned long iova,
861                     struct page **pages, size_t count, unsigned long prot)
862 {
863         int err;
864
865         err = domain->ops->map_pages(domain, iova, pages, count, prot);
866         if (err)
867                 iommu_unmap(domain, iova, count << PAGE_SHIFT);
868
869         return err;
870 }
871 EXPORT_SYMBOL_GPL(iommu_map_pages);
872
873 int iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
874                  struct scatterlist *sgl, int nents, unsigned long prot)
875 {
876         int err;
877
878         err = domain->ops->map_sg(domain, iova, sgl, nents, prot);
879         if (err)
880                 iommu_unmap(domain, iova, sgl->length);
881
882         return err;
883 }
884
885 size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
886 {
887         size_t unmapped_page, unmapped = 0;
888         unsigned int min_pagesz;
889
890         if (unlikely(domain->ops->unmap == NULL ||
891                      domain->ops->pgsize_bitmap == 0UL))
892                 return -ENODEV;
893
894         /* find out the minimum page size supported */
895         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
896
897         /*
898          * The virtual address, as well as the size of the mapping, must be
899          * aligned (at least) to the size of the smallest page supported
900          * by the hardware
901          */
902         if (!IS_ALIGNED(iova | size, min_pagesz)) {
903                 pr_err("unaligned: iova 0x%lx size 0x%lx min_pagesz 0x%x\n",
904                                         iova, (unsigned long)size, min_pagesz);
905                 return -EINVAL;
906         }
907
908         pr_debug("unmap this: iova 0x%lx size 0x%lx\n", iova,
909                                                         (unsigned long)size);
910
911         /*
912          * Keep iterating until we either unmap 'size' bytes (or more)
913          * or we hit an area that isn't mapped.
914          */
915         while (unmapped < size) {
916                 size_t left = size - unmapped;
917
918                 unmapped_page = domain->ops->unmap(domain, iova, left);
919                 if (!unmapped_page)
920                         break;
921
922                 pr_debug("unmapped: iova 0x%lx size %lx\n", iova,
923                                         (unsigned long)unmapped_page);
924
925                 iova += unmapped_page;
926                 unmapped += unmapped_page;
927         }
928
929         return unmapped;
930 }
931 EXPORT_SYMBOL_GPL(iommu_unmap);
932
933
934 int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
935                                phys_addr_t paddr, u64 size, int prot)
936 {
937         if (unlikely(domain->ops->domain_window_enable == NULL))
938                 return -ENODEV;
939
940         return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
941                                                  prot);
942 }
943 EXPORT_SYMBOL_GPL(iommu_domain_window_enable);
944
945 void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr)
946 {
947         if (unlikely(domain->ops->domain_window_disable == NULL))
948                 return;
949
950         return domain->ops->domain_window_disable(domain, wnd_nr);
951 }
952 EXPORT_SYMBOL_GPL(iommu_domain_window_disable);
953
954 static int __init iommu_init(void)
955 {
956         iommu_group_kset = kset_create_and_add("iommu_groups",
957                                                NULL, kernel_kobj);
958         ida_init(&iommu_group_ida);
959         mutex_init(&iommu_group_mutex);
960
961         BUG_ON(!iommu_group_kset);
962
963         return 0;
964 }
965 arch_initcall(iommu_init);
966
967 int iommu_domain_get_attr(struct iommu_domain *domain,
968                           enum iommu_attr attr, void *data)
969 {
970         struct iommu_domain_geometry *geometry;
971         bool *paging;
972         int ret = 0;
973         u32 *count;
974
975         switch (attr) {
976         case DOMAIN_ATTR_GEOMETRY:
977                 geometry  = data;
978                 *geometry = domain->geometry;
979
980                 break;
981         case DOMAIN_ATTR_PAGING:
982                 paging  = data;
983                 *paging = (domain->ops->pgsize_bitmap != 0UL);
984                 break;
985         case DOMAIN_ATTR_WINDOWS:
986                 count = data;
987
988                 if (domain->ops->domain_get_windows != NULL)
989                         *count = domain->ops->domain_get_windows(domain);
990                 else
991                         ret = -ENODEV;
992
993                 break;
994         default:
995                 if (!domain->ops->domain_get_attr)
996                         return -EINVAL;
997
998                 ret = domain->ops->domain_get_attr(domain, attr, data);
999         }
1000
1001         return ret;
1002 }
1003 EXPORT_SYMBOL_GPL(iommu_domain_get_attr);
1004
1005 int iommu_domain_set_attr(struct iommu_domain *domain,
1006                           enum iommu_attr attr, void *data)
1007 {
1008         int ret = 0;
1009         u32 *count;
1010
1011         switch (attr) {
1012         case DOMAIN_ATTR_WINDOWS:
1013                 count = data;
1014
1015                 if (domain->ops->domain_set_windows != NULL)
1016                         ret = domain->ops->domain_set_windows(domain, *count);
1017                 else
1018                         ret = -ENODEV;
1019
1020                 break;
1021         default:
1022                 if (domain->ops->domain_set_attr == NULL)
1023                         return -EINVAL;
1024
1025                 ret = domain->ops->domain_set_attr(domain, attr, data);
1026         }
1027
1028         return ret;
1029 }
1030 EXPORT_SYMBOL_GPL(iommu_domain_set_attr);