alpha: Replace sg++ with sg = sg_next(sg)
[linux-2.6-microblaze.git] / drivers / acpi / ioapic.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * IOAPIC/IOxAPIC/IOSAPIC driver
4  *
5  * Copyright (C) 2009 Fujitsu Limited.
6  * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
7  *
8  * Copyright (C) 2014 Intel Corporation
9  *
10  * Based on original drivers/pci/ioapic.c
11  *      Yinghai Lu <yinghai@kernel.org>
12  *      Jiang Liu <jiang.liu@intel.com>
13  */
14
15 /*
16  * This driver manages I/O APICs added by hotplug after boot.
17  * We try to claim all I/O APIC devices, but those present at boot were
18  * registered when we parsed the ACPI MADT.
19  */
20
21 #define pr_fmt(fmt) "ACPI: IOAPIC: " fmt
22
23 #include <linux/slab.h>
24 #include <linux/acpi.h>
25 #include <linux/pci.h>
26 #include <acpi/acpi.h>
27
28 struct acpi_pci_ioapic {
29         acpi_handle     root_handle;
30         acpi_handle     handle;
31         u32             gsi_base;
32         struct resource res;
33         struct pci_dev  *pdev;
34         struct list_head list;
35 };
36
37 static LIST_HEAD(ioapic_list);
38 static DEFINE_MUTEX(ioapic_list_lock);
39
40 static acpi_status setup_res(struct acpi_resource *acpi_res, void *data)
41 {
42         struct resource *res = data;
43         struct resource_win win;
44
45         /*
46          * We might assign this to 'res' later, make sure all pointers are
47          * cleared before the resource is added to the global list
48          */
49         memset(&win, 0, sizeof(win));
50
51         res->flags = 0;
52         if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM))
53                 return AE_OK;
54
55         if (!acpi_dev_resource_memory(acpi_res, res)) {
56                 if (acpi_dev_resource_address_space(acpi_res, &win) ||
57                     acpi_dev_resource_ext_address_space(acpi_res, &win))
58                         *res = win.res;
59         }
60         if ((res->flags & IORESOURCE_PREFETCH) ||
61             (res->flags & IORESOURCE_DISABLED))
62                 res->flags = 0;
63
64         return AE_CTRL_TERMINATE;
65 }
66
67 static bool acpi_is_ioapic(acpi_handle handle, char **type)
68 {
69         acpi_status status;
70         struct acpi_device_info *info;
71         char *hid = NULL;
72         bool match = false;
73
74         if (!acpi_has_method(handle, "_GSB"))
75                 return false;
76
77         status = acpi_get_object_info(handle, &info);
78         if (ACPI_SUCCESS(status)) {
79                 if (info->valid & ACPI_VALID_HID)
80                         hid = info->hardware_id.string;
81                 if (hid) {
82                         if (strcmp(hid, "ACPI0009") == 0) {
83                                 *type = "IOxAPIC";
84                                 match = true;
85                         } else if (strcmp(hid, "ACPI000A") == 0) {
86                                 *type = "IOAPIC";
87                                 match = true;
88                         }
89                 }
90                 kfree(info);
91         }
92
93         return match;
94 }
95
96 static acpi_status handle_ioapic_add(acpi_handle handle, u32 lvl,
97                                      void *context, void **rv)
98 {
99         acpi_status status;
100         unsigned long long gsi_base;
101         struct acpi_pci_ioapic *ioapic;
102         struct pci_dev *dev = NULL;
103         struct resource *res = NULL, *pci_res = NULL, *crs_res;
104         char *type = NULL;
105
106         if (!acpi_is_ioapic(handle, &type))
107                 return AE_OK;
108
109         mutex_lock(&ioapic_list_lock);
110         list_for_each_entry(ioapic, &ioapic_list, list)
111                 if (ioapic->handle == handle) {
112                         mutex_unlock(&ioapic_list_lock);
113                         return AE_OK;
114                 }
115
116         status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsi_base);
117         if (ACPI_FAILURE(status)) {
118                 acpi_handle_warn(handle, "failed to evaluate _GSB method\n");
119                 goto exit;
120         }
121
122         ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
123         if (!ioapic) {
124                 pr_err("cannot allocate memory for new IOAPIC\n");
125                 goto exit;
126         } else {
127                 ioapic->root_handle = (acpi_handle)context;
128                 ioapic->handle = handle;
129                 ioapic->gsi_base = (u32)gsi_base;
130                 INIT_LIST_HEAD(&ioapic->list);
131         }
132
133         if (acpi_ioapic_registered(handle, (u32)gsi_base))
134                 goto done;
135
136         dev = acpi_get_pci_dev(handle);
137         if (dev && pci_resource_len(dev, 0)) {
138                 if (pci_enable_device(dev) < 0)
139                         goto exit_put;
140                 pci_set_master(dev);
141                 if (pci_request_region(dev, 0, type))
142                         goto exit_disable;
143                 pci_res = &dev->resource[0];
144                 ioapic->pdev = dev;
145         } else {
146                 pci_dev_put(dev);
147                 dev = NULL;
148         }
149
150         crs_res = &ioapic->res;
151         acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, crs_res);
152         crs_res->name = type;
153         crs_res->flags |= IORESOURCE_BUSY;
154         if (crs_res->flags == 0) {
155                 acpi_handle_warn(handle, "failed to get resource\n");
156                 goto exit_release;
157         } else if (insert_resource(&iomem_resource, crs_res)) {
158                 acpi_handle_warn(handle, "failed to insert resource\n");
159                 goto exit_release;
160         }
161
162         /* try pci resource first, then "_CRS" resource */
163         res = pci_res;
164         if (!res || !res->flags)
165                 res = crs_res;
166
167         if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) {
168                 acpi_handle_warn(handle, "failed to register IOAPIC\n");
169                 goto exit_release;
170         }
171 done:
172         list_add(&ioapic->list, &ioapic_list);
173         mutex_unlock(&ioapic_list_lock);
174
175         if (dev)
176                 dev_info(&dev->dev, "%s at %pR, GSI %u\n",
177                          type, res, (u32)gsi_base);
178         else
179                 acpi_handle_info(handle, "%s at %pR, GSI %u\n",
180                                  type, res, (u32)gsi_base);
181
182         return AE_OK;
183
184 exit_release:
185         if (dev)
186                 pci_release_region(dev, 0);
187         if (ioapic->res.flags && ioapic->res.parent)
188                 release_resource(&ioapic->res);
189 exit_disable:
190         if (dev)
191                 pci_disable_device(dev);
192 exit_put:
193         pci_dev_put(dev);
194         kfree(ioapic);
195 exit:
196         mutex_unlock(&ioapic_list_lock);
197         *(acpi_status *)rv = AE_ERROR;
198         return AE_OK;
199 }
200
201 int acpi_ioapic_add(acpi_handle root_handle)
202 {
203         acpi_status status, retval = AE_OK;
204
205         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root_handle,
206                                      UINT_MAX, handle_ioapic_add, NULL,
207                                      root_handle, (void **)&retval);
208
209         return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV;
210 }
211
212 void pci_ioapic_remove(struct acpi_pci_root *root)
213 {
214         struct acpi_pci_ioapic *ioapic, *tmp;
215
216         mutex_lock(&ioapic_list_lock);
217         list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
218                 if (root->device->handle != ioapic->root_handle)
219                         continue;
220                 if (ioapic->pdev) {
221                         pci_release_region(ioapic->pdev, 0);
222                         pci_disable_device(ioapic->pdev);
223                         pci_dev_put(ioapic->pdev);
224                 }
225         }
226         mutex_unlock(&ioapic_list_lock);
227 }
228
229 int acpi_ioapic_remove(struct acpi_pci_root *root)
230 {
231         int retval = 0;
232         struct acpi_pci_ioapic *ioapic, *tmp;
233
234         mutex_lock(&ioapic_list_lock);
235         list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
236                 if (root->device->handle != ioapic->root_handle)
237                         continue;
238                 if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base))
239                         retval = -EBUSY;
240                 if (ioapic->res.flags && ioapic->res.parent)
241                         release_resource(&ioapic->res);
242                 list_del(&ioapic->list);
243                 kfree(ioapic);
244         }
245         mutex_unlock(&ioapic_list_lock);
246
247         return retval;
248 }