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