copyright owner and author clean up for intel iommu and related files
[sfrench/cifs-2.6.git] / drivers / pci / dmar.c
1 /*
2  * Copyright (c) 2006, Intel Corporation.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15  * Place - Suite 330, Boston, MA 02111-1307 USA.
16  *
17  * Copyright (C) 2006-2008 Intel Corporation
18  * Author: Ashok Raj <ashok.raj@intel.com>
19  * Author: Shaohua Li <shaohua.li@intel.com>
20  * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
21  *
22  * This file implements early detection/parsing of DMA Remapping Devices
23  * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI
24  * tables.
25  */
26
27 #include <linux/pci.h>
28 #include <linux/dmar.h>
29 #include "iova.h"
30 #include "intel-iommu.h"
31
32 #undef PREFIX
33 #define PREFIX "DMAR:"
34
35 /* No locks are needed as DMA remapping hardware unit
36  * list is constructed at boot time and hotplug of
37  * these units are not supported by the architecture.
38  */
39 LIST_HEAD(dmar_drhd_units);
40 LIST_HEAD(dmar_rmrr_units);
41
42 static struct acpi_table_header * __initdata dmar_tbl;
43
44 static void __init dmar_register_drhd_unit(struct dmar_drhd_unit *drhd)
45 {
46         /*
47          * add INCLUDE_ALL at the tail, so scan the list will find it at
48          * the very end.
49          */
50         if (drhd->include_all)
51                 list_add_tail(&drhd->list, &dmar_drhd_units);
52         else
53                 list_add(&drhd->list, &dmar_drhd_units);
54 }
55
56 static void __init dmar_register_rmrr_unit(struct dmar_rmrr_unit *rmrr)
57 {
58         list_add(&rmrr->list, &dmar_rmrr_units);
59 }
60
61 static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
62                                            struct pci_dev **dev, u16 segment)
63 {
64         struct pci_bus *bus;
65         struct pci_dev *pdev = NULL;
66         struct acpi_dmar_pci_path *path;
67         int count;
68
69         bus = pci_find_bus(segment, scope->bus);
70         path = (struct acpi_dmar_pci_path *)(scope + 1);
71         count = (scope->length - sizeof(struct acpi_dmar_device_scope))
72                 / sizeof(struct acpi_dmar_pci_path);
73
74         while (count) {
75                 if (pdev)
76                         pci_dev_put(pdev);
77                 /*
78                  * Some BIOSes list non-exist devices in DMAR table, just
79                  * ignore it
80                  */
81                 if (!bus) {
82                         printk(KERN_WARNING
83                         PREFIX "Device scope bus [%d] not found\n",
84                         scope->bus);
85                         break;
86                 }
87                 pdev = pci_get_slot(bus, PCI_DEVFN(path->dev, path->fn));
88                 if (!pdev) {
89                         printk(KERN_WARNING PREFIX
90                         "Device scope device [%04x:%02x:%02x.%02x] not found\n",
91                                 segment, bus->number, path->dev, path->fn);
92                         break;
93                 }
94                 path ++;
95                 count --;
96                 bus = pdev->subordinate;
97         }
98         if (!pdev) {
99                 printk(KERN_WARNING PREFIX
100                 "Device scope device [%04x:%02x:%02x.%02x] not found\n",
101                 segment, scope->bus, path->dev, path->fn);
102                 *dev = NULL;
103                 return 0;
104         }
105         if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT && \
106                         pdev->subordinate) || (scope->entry_type == \
107                         ACPI_DMAR_SCOPE_TYPE_BRIDGE && !pdev->subordinate)) {
108                 pci_dev_put(pdev);
109                 printk(KERN_WARNING PREFIX
110                         "Device scope type does not match for %s\n",
111                          pci_name(pdev));
112                 return -EINVAL;
113         }
114         *dev = pdev;
115         return 0;
116 }
117
118 static int __init dmar_parse_dev_scope(void *start, void *end, int *cnt,
119                                        struct pci_dev ***devices, u16 segment)
120 {
121         struct acpi_dmar_device_scope *scope;
122         void * tmp = start;
123         int index;
124         int ret;
125
126         *cnt = 0;
127         while (start < end) {
128                 scope = start;
129                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
130                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
131                         (*cnt)++;
132                 else
133                         printk(KERN_WARNING PREFIX
134                                 "Unsupported device scope\n");
135                 start += scope->length;
136         }
137         if (*cnt == 0)
138                 return 0;
139
140         *devices = kcalloc(*cnt, sizeof(struct pci_dev *), GFP_KERNEL);
141         if (!*devices)
142                 return -ENOMEM;
143
144         start = tmp;
145         index = 0;
146         while (start < end) {
147                 scope = start;
148                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
149                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE) {
150                         ret = dmar_parse_one_dev_scope(scope,
151                                 &(*devices)[index], segment);
152                         if (ret) {
153                                 kfree(*devices);
154                                 return ret;
155                         }
156                         index ++;
157                 }
158                 start += scope->length;
159         }
160
161         return 0;
162 }
163
164 /**
165  * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition
166  * structure which uniquely represent one DMA remapping hardware unit
167  * present in the platform
168  */
169 static int __init
170 dmar_parse_one_drhd(struct acpi_dmar_header *header)
171 {
172         struct acpi_dmar_hardware_unit *drhd;
173         struct dmar_drhd_unit *dmaru;
174         int ret = 0;
175         static int include_all;
176
177         dmaru = kzalloc(sizeof(*dmaru), GFP_KERNEL);
178         if (!dmaru)
179                 return -ENOMEM;
180
181         drhd = (struct acpi_dmar_hardware_unit *)header;
182         dmaru->reg_base_addr = drhd->address;
183         dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */
184
185         if (!dmaru->include_all)
186                 ret = dmar_parse_dev_scope((void *)(drhd + 1),
187                                 ((void *)drhd) + header->length,
188                                 &dmaru->devices_cnt, &dmaru->devices,
189                                 drhd->segment);
190         else {
191                 /* Only allow one INCLUDE_ALL */
192                 if (include_all) {
193                         printk(KERN_WARNING PREFIX "Only one INCLUDE_ALL "
194                                 "device scope is allowed\n");
195                         ret = -EINVAL;
196                 }
197                 include_all = 1;
198         }
199
200         if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all))
201                 kfree(dmaru);
202         else
203                 dmar_register_drhd_unit(dmaru);
204         return ret;
205 }
206
207 static int __init
208 dmar_parse_one_rmrr(struct acpi_dmar_header *header)
209 {
210         struct acpi_dmar_reserved_memory *rmrr;
211         struct dmar_rmrr_unit *rmrru;
212         int ret = 0;
213
214         rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
215         if (!rmrru)
216                 return -ENOMEM;
217
218         rmrr = (struct acpi_dmar_reserved_memory *)header;
219         rmrru->base_address = rmrr->base_address;
220         rmrru->end_address = rmrr->end_address;
221         ret = dmar_parse_dev_scope((void *)(rmrr + 1),
222                 ((void *)rmrr) + header->length,
223                 &rmrru->devices_cnt, &rmrru->devices, rmrr->segment);
224
225         if (ret || (rmrru->devices_cnt == 0))
226                 kfree(rmrru);
227         else
228                 dmar_register_rmrr_unit(rmrru);
229         return ret;
230 }
231
232 static void __init
233 dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
234 {
235         struct acpi_dmar_hardware_unit *drhd;
236         struct acpi_dmar_reserved_memory *rmrr;
237
238         switch (header->type) {
239         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
240                 drhd = (struct acpi_dmar_hardware_unit *)header;
241                 printk (KERN_INFO PREFIX
242                         "DRHD (flags: 0x%08x)base: 0x%016Lx\n",
243                         drhd->flags, drhd->address);
244                 break;
245         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
246                 rmrr = (struct acpi_dmar_reserved_memory *)header;
247
248                 printk (KERN_INFO PREFIX
249                         "RMRR base: 0x%016Lx end: 0x%016Lx\n",
250                         rmrr->base_address, rmrr->end_address);
251                 break;
252         }
253 }
254
255 /**
256  * parse_dmar_table - parses the DMA reporting table
257  */
258 static int __init
259 parse_dmar_table(void)
260 {
261         struct acpi_table_dmar *dmar;
262         struct acpi_dmar_header *entry_header;
263         int ret = 0;
264
265         dmar = (struct acpi_table_dmar *)dmar_tbl;
266         if (!dmar)
267                 return -ENODEV;
268
269         if (dmar->width < PAGE_SHIFT_4K - 1) {
270                 printk(KERN_WARNING PREFIX "Invalid DMAR haw\n");
271                 return -EINVAL;
272         }
273
274         printk (KERN_INFO PREFIX "Host address width %d\n",
275                 dmar->width + 1);
276
277         entry_header = (struct acpi_dmar_header *)(dmar + 1);
278         while (((unsigned long)entry_header) <
279                         (((unsigned long)dmar) + dmar_tbl->length)) {
280                 dmar_table_print_dmar_entry(entry_header);
281
282                 switch (entry_header->type) {
283                 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
284                         ret = dmar_parse_one_drhd(entry_header);
285                         break;
286                 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
287                         ret = dmar_parse_one_rmrr(entry_header);
288                         break;
289                 default:
290                         printk(KERN_WARNING PREFIX
291                                 "Unknown DMAR structure type\n");
292                         ret = 0; /* for forward compatibility */
293                         break;
294                 }
295                 if (ret)
296                         break;
297
298                 entry_header = ((void *)entry_header + entry_header->length);
299         }
300         return ret;
301 }
302
303
304 int __init dmar_table_init(void)
305 {
306
307         int ret;
308
309         ret = parse_dmar_table();
310         if (ret) {
311                 printk(KERN_INFO PREFIX "parse DMAR table failure.\n");
312                 return ret;
313         }
314
315         if (list_empty(&dmar_drhd_units)) {
316                 printk(KERN_INFO PREFIX "No DMAR devices found\n");
317                 return -ENODEV;
318         }
319
320         if (list_empty(&dmar_rmrr_units)) {
321                 printk(KERN_INFO PREFIX "No RMRR found\n");
322                 return -ENODEV;
323         }
324
325         return 0;
326 }
327
328 /**
329  * early_dmar_detect - checks to see if the platform supports DMAR devices
330  */
331 int __init early_dmar_detect(void)
332 {
333         acpi_status status = AE_OK;
334
335         /* if we could find DMAR table, then there are DMAR devices */
336         status = acpi_get_table(ACPI_SIG_DMAR, 0,
337                                 (struct acpi_table_header **)&dmar_tbl);
338
339         if (ACPI_SUCCESS(status) && !dmar_tbl) {
340                 printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
341                 status = AE_NOT_FOUND;
342         }
343
344         return (ACPI_SUCCESS(status) ? 1 : 0);
345 }