Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6] / arch / x86 / kernel / amd_iommu_init.c
1 /*
2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
3  * Author: Joerg Roedel <joerg.roedel@amd.com>
4  *         Leo Duran <leo.duran@amd.com>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  */
19
20 #include <linux/pci.h>
21 #include <linux/acpi.h>
22 #include <linux/gfp.h>
23 #include <linux/list.h>
24 #include <linux/sysdev.h>
25 #include <asm/pci-direct.h>
26 #include <asm/amd_iommu_types.h>
27 #include <asm/amd_iommu.h>
28 #include <asm/iommu.h>
29
30 /*
31  * definitions for the ACPI scanning code
32  */
33 #define PCI_BUS(x) (((x) >> 8) & 0xff)
34 #define IVRS_HEADER_LENGTH 48
35
36 #define ACPI_IVHD_TYPE                  0x10
37 #define ACPI_IVMD_TYPE_ALL              0x20
38 #define ACPI_IVMD_TYPE                  0x21
39 #define ACPI_IVMD_TYPE_RANGE            0x22
40
41 #define IVHD_DEV_ALL                    0x01
42 #define IVHD_DEV_SELECT                 0x02
43 #define IVHD_DEV_SELECT_RANGE_START     0x03
44 #define IVHD_DEV_RANGE_END              0x04
45 #define IVHD_DEV_ALIAS                  0x42
46 #define IVHD_DEV_ALIAS_RANGE            0x43
47 #define IVHD_DEV_EXT_SELECT             0x46
48 #define IVHD_DEV_EXT_SELECT_RANGE       0x47
49
50 #define IVHD_FLAG_HT_TUN_EN             0x00
51 #define IVHD_FLAG_PASSPW_EN             0x01
52 #define IVHD_FLAG_RESPASSPW_EN          0x02
53 #define IVHD_FLAG_ISOC_EN               0x03
54
55 #define IVMD_FLAG_EXCL_RANGE            0x08
56 #define IVMD_FLAG_UNITY_MAP             0x01
57
58 #define ACPI_DEVFLAG_INITPASS           0x01
59 #define ACPI_DEVFLAG_EXTINT             0x02
60 #define ACPI_DEVFLAG_NMI                0x04
61 #define ACPI_DEVFLAG_SYSMGT1            0x10
62 #define ACPI_DEVFLAG_SYSMGT2            0x20
63 #define ACPI_DEVFLAG_LINT0              0x40
64 #define ACPI_DEVFLAG_LINT1              0x80
65 #define ACPI_DEVFLAG_ATSDIS             0x10000000
66
67 /*
68  * ACPI table definitions
69  *
70  * These data structures are laid over the table to parse the important values
71  * out of it.
72  */
73
74 /*
75  * structure describing one IOMMU in the ACPI table. Typically followed by one
76  * or more ivhd_entrys.
77  */
78 struct ivhd_header {
79         u8 type;
80         u8 flags;
81         u16 length;
82         u16 devid;
83         u16 cap_ptr;
84         u64 mmio_phys;
85         u16 pci_seg;
86         u16 info;
87         u32 reserved;
88 } __attribute__((packed));
89
90 /*
91  * A device entry describing which devices a specific IOMMU translates and
92  * which requestor ids they use.
93  */
94 struct ivhd_entry {
95         u8 type;
96         u16 devid;
97         u8 flags;
98         u32 ext;
99 } __attribute__((packed));
100
101 /*
102  * An AMD IOMMU memory definition structure. It defines things like exclusion
103  * ranges for devices and regions that should be unity mapped.
104  */
105 struct ivmd_header {
106         u8 type;
107         u8 flags;
108         u16 length;
109         u16 devid;
110         u16 aux;
111         u64 resv;
112         u64 range_start;
113         u64 range_length;
114 } __attribute__((packed));
115
116 static int __initdata amd_iommu_detected;
117
118 u16 amd_iommu_last_bdf;                 /* largest PCI device id we have
119                                            to handle */
120 LIST_HEAD(amd_iommu_unity_map);         /* a list of required unity mappings
121                                            we find in ACPI */
122 unsigned amd_iommu_aperture_order = 26; /* size of aperture in power of 2 */
123 int amd_iommu_isolate;                  /* if 1, device isolation is enabled */
124
125 LIST_HEAD(amd_iommu_list);              /* list of all AMD IOMMUs in the
126                                            system */
127
128 /*
129  * Pointer to the device table which is shared by all AMD IOMMUs
130  * it is indexed by the PCI device id or the HT unit id and contains
131  * information about the domain the device belongs to as well as the
132  * page table root pointer.
133  */
134 struct dev_table_entry *amd_iommu_dev_table;
135
136 /*
137  * The alias table is a driver specific data structure which contains the
138  * mappings of the PCI device ids to the actual requestor ids on the IOMMU.
139  * More than one device can share the same requestor id.
140  */
141 u16 *amd_iommu_alias_table;
142
143 /*
144  * The rlookup table is used to find the IOMMU which is responsible
145  * for a specific device. It is also indexed by the PCI device id.
146  */
147 struct amd_iommu **amd_iommu_rlookup_table;
148
149 /*
150  * The pd table (protection domain table) is used to find the protection domain
151  * data structure a device belongs to. Indexed with the PCI device id too.
152  */
153 struct protection_domain **amd_iommu_pd_table;
154
155 /*
156  * AMD IOMMU allows up to 2^16 differend protection domains. This is a bitmap
157  * to know which ones are already in use.
158  */
159 unsigned long *amd_iommu_pd_alloc_bitmap;
160
161 static u32 dev_table_size;      /* size of the device table */
162 static u32 alias_table_size;    /* size of the alias table */
163 static u32 rlookup_table_size;  /* size if the rlookup table */
164
165 static inline void update_last_devid(u16 devid)
166 {
167         if (devid > amd_iommu_last_bdf)
168                 amd_iommu_last_bdf = devid;
169 }
170
171 static inline unsigned long tbl_size(int entry_size)
172 {
173         unsigned shift = PAGE_SHIFT +
174                          get_order(amd_iommu_last_bdf * entry_size);
175
176         return 1UL << shift;
177 }
178
179 /****************************************************************************
180  *
181  * AMD IOMMU MMIO register space handling functions
182  *
183  * These functions are used to program the IOMMU device registers in
184  * MMIO space required for that driver.
185  *
186  ****************************************************************************/
187
188 /*
189  * This function set the exclusion range in the IOMMU. DMA accesses to the
190  * exclusion range are passed through untranslated
191  */
192 static void __init iommu_set_exclusion_range(struct amd_iommu *iommu)
193 {
194         u64 start = iommu->exclusion_start & PAGE_MASK;
195         u64 limit = (start + iommu->exclusion_length) & PAGE_MASK;
196         u64 entry;
197
198         if (!iommu->exclusion_start)
199                 return;
200
201         entry = start | MMIO_EXCL_ENABLE_MASK;
202         memcpy_toio(iommu->mmio_base + MMIO_EXCL_BASE_OFFSET,
203                         &entry, sizeof(entry));
204
205         entry = limit;
206         memcpy_toio(iommu->mmio_base + MMIO_EXCL_LIMIT_OFFSET,
207                         &entry, sizeof(entry));
208 }
209
210 /* Programs the physical address of the device table into the IOMMU hardware */
211 static void __init iommu_set_device_table(struct amd_iommu *iommu)
212 {
213         u32 entry;
214
215         BUG_ON(iommu->mmio_base == NULL);
216
217         entry = virt_to_phys(amd_iommu_dev_table);
218         entry |= (dev_table_size >> 12) - 1;
219         memcpy_toio(iommu->mmio_base + MMIO_DEV_TABLE_OFFSET,
220                         &entry, sizeof(entry));
221 }
222
223 /* Generic functions to enable/disable certain features of the IOMMU. */
224 static void __init iommu_feature_enable(struct amd_iommu *iommu, u8 bit)
225 {
226         u32 ctrl;
227
228         ctrl = readl(iommu->mmio_base + MMIO_CONTROL_OFFSET);
229         ctrl |= (1 << bit);
230         writel(ctrl, iommu->mmio_base + MMIO_CONTROL_OFFSET);
231 }
232
233 static void __init iommu_feature_disable(struct amd_iommu *iommu, u8 bit)
234 {
235         u32 ctrl;
236
237         ctrl = (u64)readl(iommu->mmio_base + MMIO_CONTROL_OFFSET);
238         ctrl &= ~(1 << bit);
239         writel(ctrl, iommu->mmio_base + MMIO_CONTROL_OFFSET);
240 }
241
242 /* Function to enable the hardware */
243 void __init iommu_enable(struct amd_iommu *iommu)
244 {
245         printk(KERN_INFO "AMD IOMMU: Enabling IOMMU at ");
246         print_devid(iommu->devid, 0);
247         printk(" cap 0x%hx\n", iommu->cap_ptr);
248
249         iommu_feature_enable(iommu, CONTROL_IOMMU_EN);
250 }
251
252 /*
253  * mapping and unmapping functions for the IOMMU MMIO space. Each AMD IOMMU in
254  * the system has one.
255  */
256 static u8 * __init iommu_map_mmio_space(u64 address)
257 {
258         u8 *ret;
259
260         if (!request_mem_region(address, MMIO_REGION_LENGTH, "amd_iommu"))
261                 return NULL;
262
263         ret = ioremap_nocache(address, MMIO_REGION_LENGTH);
264         if (ret != NULL)
265                 return ret;
266
267         release_mem_region(address, MMIO_REGION_LENGTH);
268
269         return NULL;
270 }
271
272 static void __init iommu_unmap_mmio_space(struct amd_iommu *iommu)
273 {
274         if (iommu->mmio_base)
275                 iounmap(iommu->mmio_base);
276         release_mem_region(iommu->mmio_phys, MMIO_REGION_LENGTH);
277 }
278
279 /****************************************************************************
280  *
281  * The functions below belong to the first pass of AMD IOMMU ACPI table
282  * parsing. In this pass we try to find out the highest device id this
283  * code has to handle. Upon this information the size of the shared data
284  * structures is determined later.
285  *
286  ****************************************************************************/
287
288 /*
289  * This function reads the last device id the IOMMU has to handle from the PCI
290  * capability header for this IOMMU
291  */
292 static int __init find_last_devid_on_pci(int bus, int dev, int fn, int cap_ptr)
293 {
294         u32 cap;
295
296         cap = read_pci_config(bus, dev, fn, cap_ptr+MMIO_RANGE_OFFSET);
297         update_last_devid(calc_devid(MMIO_GET_BUS(cap), MMIO_GET_LD(cap)));
298
299         return 0;
300 }
301
302 /*
303  * After reading the highest device id from the IOMMU PCI capability header
304  * this function looks if there is a higher device id defined in the ACPI table
305  */
306 static int __init find_last_devid_from_ivhd(struct ivhd_header *h)
307 {
308         u8 *p = (void *)h, *end = (void *)h;
309         struct ivhd_entry *dev;
310
311         p += sizeof(*h);
312         end += h->length;
313
314         find_last_devid_on_pci(PCI_BUS(h->devid),
315                         PCI_SLOT(h->devid),
316                         PCI_FUNC(h->devid),
317                         h->cap_ptr);
318
319         while (p < end) {
320                 dev = (struct ivhd_entry *)p;
321                 switch (dev->type) {
322                 case IVHD_DEV_SELECT:
323                 case IVHD_DEV_RANGE_END:
324                 case IVHD_DEV_ALIAS:
325                 case IVHD_DEV_EXT_SELECT:
326                         /* all the above subfield types refer to device ids */
327                         update_last_devid(dev->devid);
328                         break;
329                 default:
330                         break;
331                 }
332                 p += 0x04 << (*p >> 6);
333         }
334
335         WARN_ON(p != end);
336
337         return 0;
338 }
339
340 /*
341  * Iterate over all IVHD entries in the ACPI table and find the highest device
342  * id which we need to handle. This is the first of three functions which parse
343  * the ACPI table. So we check the checksum here.
344  */
345 static int __init find_last_devid_acpi(struct acpi_table_header *table)
346 {
347         int i;
348         u8 checksum = 0, *p = (u8 *)table, *end = (u8 *)table;
349         struct ivhd_header *h;
350
351         /*
352          * Validate checksum here so we don't need to do it when
353          * we actually parse the table
354          */
355         for (i = 0; i < table->length; ++i)
356                 checksum += p[i];
357         if (checksum != 0)
358                 /* ACPI table corrupt */
359                 return -ENODEV;
360
361         p += IVRS_HEADER_LENGTH;
362
363         end += table->length;
364         while (p < end) {
365                 h = (struct ivhd_header *)p;
366                 switch (h->type) {
367                 case ACPI_IVHD_TYPE:
368                         find_last_devid_from_ivhd(h);
369                         break;
370                 default:
371                         break;
372                 }
373                 p += h->length;
374         }
375         WARN_ON(p != end);
376
377         return 0;
378 }
379
380 /****************************************************************************
381  *
382  * The following functions belong the the code path which parses the ACPI table
383  * the second time. In this ACPI parsing iteration we allocate IOMMU specific
384  * data structures, initialize the device/alias/rlookup table and also
385  * basically initialize the hardware.
386  *
387  ****************************************************************************/
388
389 /*
390  * Allocates the command buffer. This buffer is per AMD IOMMU. We can
391  * write commands to that buffer later and the IOMMU will execute them
392  * asynchronously
393  */
394 static u8 * __init alloc_command_buffer(struct amd_iommu *iommu)
395 {
396         u8 *cmd_buf = (u8 *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
397                         get_order(CMD_BUFFER_SIZE));
398         u64 entry;
399
400         if (cmd_buf == NULL)
401                 return NULL;
402
403         iommu->cmd_buf_size = CMD_BUFFER_SIZE;
404
405         entry = (u64)virt_to_phys(cmd_buf);
406         entry |= MMIO_CMD_SIZE_512;
407         memcpy_toio(iommu->mmio_base + MMIO_CMD_BUF_OFFSET,
408                         &entry, sizeof(entry));
409
410         iommu_feature_enable(iommu, CONTROL_CMDBUF_EN);
411
412         return cmd_buf;
413 }
414
415 static void __init free_command_buffer(struct amd_iommu *iommu)
416 {
417         free_pages((unsigned long)iommu->cmd_buf, get_order(CMD_BUFFER_SIZE));
418 }
419
420 /* sets a specific bit in the device table entry. */
421 static void set_dev_entry_bit(u16 devid, u8 bit)
422 {
423         int i = (bit >> 5) & 0x07;
424         int _bit = bit & 0x1f;
425
426         amd_iommu_dev_table[devid].data[i] |= (1 << _bit);
427 }
428
429 /* Writes the specific IOMMU for a device into the rlookup table */
430 static void __init set_iommu_for_device(struct amd_iommu *iommu, u16 devid)
431 {
432         amd_iommu_rlookup_table[devid] = iommu;
433 }
434
435 /*
436  * This function takes the device specific flags read from the ACPI
437  * table and sets up the device table entry with that information
438  */
439 static void __init set_dev_entry_from_acpi(struct amd_iommu *iommu,
440                                            u16 devid, u32 flags, u32 ext_flags)
441 {
442         if (flags & ACPI_DEVFLAG_INITPASS)
443                 set_dev_entry_bit(devid, DEV_ENTRY_INIT_PASS);
444         if (flags & ACPI_DEVFLAG_EXTINT)
445                 set_dev_entry_bit(devid, DEV_ENTRY_EINT_PASS);
446         if (flags & ACPI_DEVFLAG_NMI)
447                 set_dev_entry_bit(devid, DEV_ENTRY_NMI_PASS);
448         if (flags & ACPI_DEVFLAG_SYSMGT1)
449                 set_dev_entry_bit(devid, DEV_ENTRY_SYSMGT1);
450         if (flags & ACPI_DEVFLAG_SYSMGT2)
451                 set_dev_entry_bit(devid, DEV_ENTRY_SYSMGT2);
452         if (flags & ACPI_DEVFLAG_LINT0)
453                 set_dev_entry_bit(devid, DEV_ENTRY_LINT0_PASS);
454         if (flags & ACPI_DEVFLAG_LINT1)
455                 set_dev_entry_bit(devid, DEV_ENTRY_LINT1_PASS);
456
457         set_iommu_for_device(iommu, devid);
458 }
459
460 /*
461  * Reads the device exclusion range from ACPI and initialize IOMMU with
462  * it
463  */
464 static void __init set_device_exclusion_range(u16 devid, struct ivmd_header *m)
465 {
466         struct amd_iommu *iommu = amd_iommu_rlookup_table[devid];
467
468         if (!(m->flags & IVMD_FLAG_EXCL_RANGE))
469                 return;
470
471         if (iommu) {
472                 /*
473                  * We only can configure exclusion ranges per IOMMU, not
474                  * per device. But we can enable the exclusion range per
475                  * device. This is done here
476                  */
477                 set_dev_entry_bit(m->devid, DEV_ENTRY_EX);
478                 iommu->exclusion_start = m->range_start;
479                 iommu->exclusion_length = m->range_length;
480         }
481 }
482
483 /*
484  * This function reads some important data from the IOMMU PCI space and
485  * initializes the driver data structure with it. It reads the hardware
486  * capabilities and the first/last device entries
487  */
488 static void __init init_iommu_from_pci(struct amd_iommu *iommu)
489 {
490         int bus = PCI_BUS(iommu->devid);
491         int dev = PCI_SLOT(iommu->devid);
492         int fn  = PCI_FUNC(iommu->devid);
493         int cap_ptr = iommu->cap_ptr;
494         u32 range;
495
496         iommu->cap = read_pci_config(bus, dev, fn, cap_ptr+MMIO_CAP_HDR_OFFSET);
497
498         range = read_pci_config(bus, dev, fn, cap_ptr+MMIO_RANGE_OFFSET);
499         iommu->first_device = calc_devid(MMIO_GET_BUS(range),
500                                          MMIO_GET_FD(range));
501         iommu->last_device = calc_devid(MMIO_GET_BUS(range),
502                                         MMIO_GET_LD(range));
503 }
504
505 /*
506  * Takes a pointer to an AMD IOMMU entry in the ACPI table and
507  * initializes the hardware and our data structures with it.
508  */
509 static void __init init_iommu_from_acpi(struct amd_iommu *iommu,
510                                         struct ivhd_header *h)
511 {
512         u8 *p = (u8 *)h;
513         u8 *end = p, flags = 0;
514         u16 dev_i, devid = 0, devid_start = 0, devid_to = 0;
515         u32 ext_flags = 0;
516         bool alias = false;
517         struct ivhd_entry *e;
518
519         /*
520          * First set the recommended feature enable bits from ACPI
521          * into the IOMMU control registers
522          */
523         h->flags & IVHD_FLAG_HT_TUN_EN ?
524                 iommu_feature_enable(iommu, CONTROL_HT_TUN_EN) :
525                 iommu_feature_disable(iommu, CONTROL_HT_TUN_EN);
526
527         h->flags & IVHD_FLAG_PASSPW_EN ?
528                 iommu_feature_enable(iommu, CONTROL_PASSPW_EN) :
529                 iommu_feature_disable(iommu, CONTROL_PASSPW_EN);
530
531         h->flags & IVHD_FLAG_RESPASSPW_EN ?
532                 iommu_feature_enable(iommu, CONTROL_RESPASSPW_EN) :
533                 iommu_feature_disable(iommu, CONTROL_RESPASSPW_EN);
534
535         h->flags & IVHD_FLAG_ISOC_EN ?
536                 iommu_feature_enable(iommu, CONTROL_ISOC_EN) :
537                 iommu_feature_disable(iommu, CONTROL_ISOC_EN);
538
539         /*
540          * make IOMMU memory accesses cache coherent
541          */
542         iommu_feature_enable(iommu, CONTROL_COHERENT_EN);
543
544         /*
545          * Done. Now parse the device entries
546          */
547         p += sizeof(struct ivhd_header);
548         end += h->length;
549
550         while (p < end) {
551                 e = (struct ivhd_entry *)p;
552                 switch (e->type) {
553                 case IVHD_DEV_ALL:
554                         for (dev_i = iommu->first_device;
555                                         dev_i <= iommu->last_device; ++dev_i)
556                                 set_dev_entry_from_acpi(iommu, dev_i,
557                                                         e->flags, 0);
558                         break;
559                 case IVHD_DEV_SELECT:
560                         devid = e->devid;
561                         set_dev_entry_from_acpi(iommu, devid, e->flags, 0);
562                         break;
563                 case IVHD_DEV_SELECT_RANGE_START:
564                         devid_start = e->devid;
565                         flags = e->flags;
566                         ext_flags = 0;
567                         alias = false;
568                         break;
569                 case IVHD_DEV_ALIAS:
570                         devid = e->devid;
571                         devid_to = e->ext >> 8;
572                         set_dev_entry_from_acpi(iommu, devid, e->flags, 0);
573                         amd_iommu_alias_table[devid] = devid_to;
574                         break;
575                 case IVHD_DEV_ALIAS_RANGE:
576                         devid_start = e->devid;
577                         flags = e->flags;
578                         devid_to = e->ext >> 8;
579                         ext_flags = 0;
580                         alias = true;
581                         break;
582                 case IVHD_DEV_EXT_SELECT:
583                         devid = e->devid;
584                         set_dev_entry_from_acpi(iommu, devid, e->flags,
585                                                 e->ext);
586                         break;
587                 case IVHD_DEV_EXT_SELECT_RANGE:
588                         devid_start = e->devid;
589                         flags = e->flags;
590                         ext_flags = e->ext;
591                         alias = false;
592                         break;
593                 case IVHD_DEV_RANGE_END:
594                         devid = e->devid;
595                         for (dev_i = devid_start; dev_i <= devid; ++dev_i) {
596                                 if (alias)
597                                         amd_iommu_alias_table[dev_i] = devid_to;
598                                 set_dev_entry_from_acpi(iommu,
599                                                 amd_iommu_alias_table[dev_i],
600                                                 flags, ext_flags);
601                         }
602                         break;
603                 default:
604                         break;
605                 }
606
607                 p += 0x04 << (e->type >> 6);
608         }
609 }
610
611 /* Initializes the device->iommu mapping for the driver */
612 static int __init init_iommu_devices(struct amd_iommu *iommu)
613 {
614         u16 i;
615
616         for (i = iommu->first_device; i <= iommu->last_device; ++i)
617                 set_iommu_for_device(iommu, i);
618
619         return 0;
620 }
621
622 static void __init free_iommu_one(struct amd_iommu *iommu)
623 {
624         free_command_buffer(iommu);
625         iommu_unmap_mmio_space(iommu);
626 }
627
628 static void __init free_iommu_all(void)
629 {
630         struct amd_iommu *iommu, *next;
631
632         list_for_each_entry_safe(iommu, next, &amd_iommu_list, list) {
633                 list_del(&iommu->list);
634                 free_iommu_one(iommu);
635                 kfree(iommu);
636         }
637 }
638
639 /*
640  * This function clues the initialization function for one IOMMU
641  * together and also allocates the command buffer and programs the
642  * hardware. It does NOT enable the IOMMU. This is done afterwards.
643  */
644 static int __init init_iommu_one(struct amd_iommu *iommu, struct ivhd_header *h)
645 {
646         spin_lock_init(&iommu->lock);
647         list_add_tail(&iommu->list, &amd_iommu_list);
648
649         /*
650          * Copy data from ACPI table entry to the iommu struct
651          */
652         iommu->devid = h->devid;
653         iommu->cap_ptr = h->cap_ptr;
654         iommu->mmio_phys = h->mmio_phys;
655         iommu->mmio_base = iommu_map_mmio_space(h->mmio_phys);
656         if (!iommu->mmio_base)
657                 return -ENOMEM;
658
659         iommu_set_device_table(iommu);
660         iommu->cmd_buf = alloc_command_buffer(iommu);
661         if (!iommu->cmd_buf)
662                 return -ENOMEM;
663
664         init_iommu_from_pci(iommu);
665         init_iommu_from_acpi(iommu, h);
666         init_iommu_devices(iommu);
667
668         return 0;
669 }
670
671 /*
672  * Iterates over all IOMMU entries in the ACPI table, allocates the
673  * IOMMU structure and initializes it with init_iommu_one()
674  */
675 static int __init init_iommu_all(struct acpi_table_header *table)
676 {
677         u8 *p = (u8 *)table, *end = (u8 *)table;
678         struct ivhd_header *h;
679         struct amd_iommu *iommu;
680         int ret;
681
682         end += table->length;
683         p += IVRS_HEADER_LENGTH;
684
685         while (p < end) {
686                 h = (struct ivhd_header *)p;
687                 switch (*p) {
688                 case ACPI_IVHD_TYPE:
689                         iommu = kzalloc(sizeof(struct amd_iommu), GFP_KERNEL);
690                         if (iommu == NULL)
691                                 return -ENOMEM;
692                         ret = init_iommu_one(iommu, h);
693                         if (ret)
694                                 return ret;
695                         break;
696                 default:
697                         break;
698                 }
699                 p += h->length;
700
701         }
702         WARN_ON(p != end);
703
704         return 0;
705 }
706
707 /****************************************************************************
708  *
709  * The next functions belong to the third pass of parsing the ACPI
710  * table. In this last pass the memory mapping requirements are
711  * gathered (like exclusion and unity mapping reanges).
712  *
713  ****************************************************************************/
714
715 static void __init free_unity_maps(void)
716 {
717         struct unity_map_entry *entry, *next;
718
719         list_for_each_entry_safe(entry, next, &amd_iommu_unity_map, list) {
720                 list_del(&entry->list);
721                 kfree(entry);
722         }
723 }
724
725 /* called when we find an exclusion range definition in ACPI */
726 static int __init init_exclusion_range(struct ivmd_header *m)
727 {
728         int i;
729
730         switch (m->type) {
731         case ACPI_IVMD_TYPE:
732                 set_device_exclusion_range(m->devid, m);
733                 break;
734         case ACPI_IVMD_TYPE_ALL:
735                 for (i = 0; i <= amd_iommu_last_bdf; ++i)
736                         set_device_exclusion_range(i, m);
737                 break;
738         case ACPI_IVMD_TYPE_RANGE:
739                 for (i = m->devid; i <= m->aux; ++i)
740                         set_device_exclusion_range(i, m);
741                 break;
742         default:
743                 break;
744         }
745
746         return 0;
747 }
748
749 /* called for unity map ACPI definition */
750 static int __init init_unity_map_range(struct ivmd_header *m)
751 {
752         struct unity_map_entry *e = 0;
753
754         e = kzalloc(sizeof(*e), GFP_KERNEL);
755         if (e == NULL)
756                 return -ENOMEM;
757
758         switch (m->type) {
759         default:
760         case ACPI_IVMD_TYPE:
761                 e->devid_start = e->devid_end = m->devid;
762                 break;
763         case ACPI_IVMD_TYPE_ALL:
764                 e->devid_start = 0;
765                 e->devid_end = amd_iommu_last_bdf;
766                 break;
767         case ACPI_IVMD_TYPE_RANGE:
768                 e->devid_start = m->devid;
769                 e->devid_end = m->aux;
770                 break;
771         }
772         e->address_start = PAGE_ALIGN(m->range_start);
773         e->address_end = e->address_start + PAGE_ALIGN(m->range_length);
774         e->prot = m->flags >> 1;
775
776         list_add_tail(&e->list, &amd_iommu_unity_map);
777
778         return 0;
779 }
780
781 /* iterates over all memory definitions we find in the ACPI table */
782 static int __init init_memory_definitions(struct acpi_table_header *table)
783 {
784         u8 *p = (u8 *)table, *end = (u8 *)table;
785         struct ivmd_header *m;
786
787         end += table->length;
788         p += IVRS_HEADER_LENGTH;
789
790         while (p < end) {
791                 m = (struct ivmd_header *)p;
792                 if (m->flags & IVMD_FLAG_EXCL_RANGE)
793                         init_exclusion_range(m);
794                 else if (m->flags & IVMD_FLAG_UNITY_MAP)
795                         init_unity_map_range(m);
796
797                 p += m->length;
798         }
799
800         return 0;
801 }
802
803 /*
804  * This function finally enables all IOMMUs found in the system after
805  * they have been initialized
806  */
807 static void __init enable_iommus(void)
808 {
809         struct amd_iommu *iommu;
810
811         list_for_each_entry(iommu, &amd_iommu_list, list) {
812                 iommu_set_exclusion_range(iommu);
813                 iommu_enable(iommu);
814         }
815 }
816
817 /*
818  * Suspend/Resume support
819  * disable suspend until real resume implemented
820  */
821
822 static int amd_iommu_resume(struct sys_device *dev)
823 {
824         return 0;
825 }
826
827 static int amd_iommu_suspend(struct sys_device *dev, pm_message_t state)
828 {
829         return -EINVAL;
830 }
831
832 static struct sysdev_class amd_iommu_sysdev_class = {
833         .name = "amd_iommu",
834         .suspend = amd_iommu_suspend,
835         .resume = amd_iommu_resume,
836 };
837
838 static struct sys_device device_amd_iommu = {
839         .id = 0,
840         .cls = &amd_iommu_sysdev_class,
841 };
842
843 /*
844  * This is the core init function for AMD IOMMU hardware in the system.
845  * This function is called from the generic x86 DMA layer initialization
846  * code.
847  *
848  * This function basically parses the ACPI table for AMD IOMMU (IVRS)
849  * three times:
850  *
851  *      1 pass) Find the highest PCI device id the driver has to handle.
852  *              Upon this information the size of the data structures is
853  *              determined that needs to be allocated.
854  *
855  *      2 pass) Initialize the data structures just allocated with the
856  *              information in the ACPI table about available AMD IOMMUs
857  *              in the system. It also maps the PCI devices in the
858  *              system to specific IOMMUs
859  *
860  *      3 pass) After the basic data structures are allocated and
861  *              initialized we update them with information about memory
862  *              remapping requirements parsed out of the ACPI table in
863  *              this last pass.
864  *
865  * After that the hardware is initialized and ready to go. In the last
866  * step we do some Linux specific things like registering the driver in
867  * the dma_ops interface and initializing the suspend/resume support
868  * functions. Finally it prints some information about AMD IOMMUs and
869  * the driver state and enables the hardware.
870  */
871 int __init amd_iommu_init(void)
872 {
873         int i, ret = 0;
874
875
876         if (no_iommu) {
877                 printk(KERN_INFO "AMD IOMMU disabled by kernel command line\n");
878                 return 0;
879         }
880
881         if (!amd_iommu_detected)
882                 return -ENODEV;
883
884         /*
885          * First parse ACPI tables to find the largest Bus/Dev/Func
886          * we need to handle. Upon this information the shared data
887          * structures for the IOMMUs in the system will be allocated
888          */
889         if (acpi_table_parse("IVRS", find_last_devid_acpi) != 0)
890                 return -ENODEV;
891
892         dev_table_size     = tbl_size(DEV_TABLE_ENTRY_SIZE);
893         alias_table_size   = tbl_size(ALIAS_TABLE_ENTRY_SIZE);
894         rlookup_table_size = tbl_size(RLOOKUP_TABLE_ENTRY_SIZE);
895
896         ret = -ENOMEM;
897
898         /* Device table - directly used by all IOMMUs */
899         amd_iommu_dev_table = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
900                                       get_order(dev_table_size));
901         if (amd_iommu_dev_table == NULL)
902                 goto out;
903
904         /*
905          * Alias table - map PCI Bus/Dev/Func to Bus/Dev/Func the
906          * IOMMU see for that device
907          */
908         amd_iommu_alias_table = (void *)__get_free_pages(GFP_KERNEL,
909                         get_order(alias_table_size));
910         if (amd_iommu_alias_table == NULL)
911                 goto free;
912
913         /* IOMMU rlookup table - find the IOMMU for a specific device */
914         amd_iommu_rlookup_table = (void *)__get_free_pages(GFP_KERNEL,
915                         get_order(rlookup_table_size));
916         if (amd_iommu_rlookup_table == NULL)
917                 goto free;
918
919         /*
920          * Protection Domain table - maps devices to protection domains
921          * This table has the same size as the rlookup_table
922          */
923         amd_iommu_pd_table = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
924                                      get_order(rlookup_table_size));
925         if (amd_iommu_pd_table == NULL)
926                 goto free;
927
928         amd_iommu_pd_alloc_bitmap = (void *)__get_free_pages(
929                                             GFP_KERNEL | __GFP_ZERO,
930                                             get_order(MAX_DOMAIN_ID/8));
931         if (amd_iommu_pd_alloc_bitmap == NULL)
932                 goto free;
933
934         /*
935          * let all alias entries point to itself
936          */
937         for (i = 0; i <= amd_iommu_last_bdf; ++i)
938                 amd_iommu_alias_table[i] = i;
939
940         /*
941          * never allocate domain 0 because its used as the non-allocated and
942          * error value placeholder
943          */
944         amd_iommu_pd_alloc_bitmap[0] = 1;
945
946         /*
947          * now the data structures are allocated and basically initialized
948          * start the real acpi table scan
949          */
950         ret = -ENODEV;
951         if (acpi_table_parse("IVRS", init_iommu_all) != 0)
952                 goto free;
953
954         if (acpi_table_parse("IVRS", init_memory_definitions) != 0)
955                 goto free;
956
957         ret = amd_iommu_init_dma_ops();
958         if (ret)
959                 goto free;
960
961         ret = sysdev_class_register(&amd_iommu_sysdev_class);
962         if (ret)
963                 goto free;
964
965         ret = sysdev_register(&device_amd_iommu);
966         if (ret)
967                 goto free;
968
969         enable_iommus();
970
971         printk(KERN_INFO "AMD IOMMU: aperture size is %d MB\n",
972                         (1 << (amd_iommu_aperture_order-20)));
973
974         printk(KERN_INFO "AMD IOMMU: device isolation ");
975         if (amd_iommu_isolate)
976                 printk("enabled\n");
977         else
978                 printk("disabled\n");
979
980 out:
981         return ret;
982
983 free:
984         free_pages((unsigned long)amd_iommu_pd_alloc_bitmap, 1);
985
986         free_pages((unsigned long)amd_iommu_pd_table,
987                    get_order(rlookup_table_size));
988
989         free_pages((unsigned long)amd_iommu_rlookup_table,
990                    get_order(rlookup_table_size));
991
992         free_pages((unsigned long)amd_iommu_alias_table,
993                    get_order(alias_table_size));
994
995         free_pages((unsigned long)amd_iommu_dev_table,
996                    get_order(dev_table_size));
997
998         free_iommu_all();
999
1000         free_unity_maps();
1001
1002         goto out;
1003 }
1004
1005 /****************************************************************************
1006  *
1007  * Early detect code. This code runs at IOMMU detection time in the DMA
1008  * layer. It just looks if there is an IVRS ACPI table to detect AMD
1009  * IOMMUs
1010  *
1011  ****************************************************************************/
1012 static int __init early_amd_iommu_detect(struct acpi_table_header *table)
1013 {
1014         return 0;
1015 }
1016
1017 void __init amd_iommu_detect(void)
1018 {
1019         if (swiotlb || no_iommu || (iommu_detected && !gart_iommu_aperture))
1020                 return;
1021
1022         if (acpi_table_parse("IVRS", early_amd_iommu_detect) == 0) {
1023                 iommu_detected = 1;
1024                 amd_iommu_detected = 1;
1025 #ifdef CONFIG_GART_IOMMU
1026                 gart_iommu_aperture_disabled = 1;
1027                 gart_iommu_aperture = 0;
1028 #endif
1029         }
1030 }
1031
1032 /****************************************************************************
1033  *
1034  * Parsing functions for the AMD IOMMU specific kernel command line
1035  * options.
1036  *
1037  ****************************************************************************/
1038
1039 static int __init parse_amd_iommu_options(char *str)
1040 {
1041         for (; *str; ++str) {
1042                 if (strcmp(str, "isolate") == 0)
1043                         amd_iommu_isolate = 1;
1044         }
1045
1046         return 1;
1047 }
1048
1049 static int __init parse_amd_iommu_size_options(char *str)
1050 {
1051         unsigned order = PAGE_SHIFT + get_order(memparse(str, &str));
1052
1053         if ((order > 24) && (order < 31))
1054                 amd_iommu_aperture_order = order;
1055
1056         return 1;
1057 }
1058
1059 __setup("amd_iommu=", parse_amd_iommu_options);
1060 __setup("amd_iommu_size=", parse_amd_iommu_size_options);