Diff markup
1 /* 1 /*
2 * ACPI PCI HotPlug glue functions to ACPI CA 2 * ACPI PCI HotPlug glue functions to ACPI CA subsystem
3 * 3 *
4 * Copyright (C) 2002,2003 Takayoshi Kochi (t- 4 * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
5 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap. 5 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
6 * Copyright (C) 2002,2003 NEC Corporation 6 * Copyright (C) 2002,2003 NEC Corporation
7 * Copyright (C) 2003-2005 Matthew Wilcox (mat 7 * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com)
8 * Copyright (C) 2003-2005 Hewlett Packard 8 * Copyright (C) 2003-2005 Hewlett Packard
9 * Copyright (C) 2005 Rajesh Shah (rajesh.shah 9 * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com)
10 * Copyright (C) 2005 Intel Corporation 10 * Copyright (C) 2005 Intel Corporation
11 * 11 *
12 * All rights reserved. 12 * All rights reserved.
13 * 13 *
14 * This program is free software; you can redi 14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Publi 15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either versio 16 * the Free Software Foundation; either version 2 of the License, or (at
17 * your option) any later version. 17 * your option) any later version.
18 * 18 *
19 * This program is distributed in the hope tha 19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the impl 20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR 21 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
22 * NON INFRINGEMENT. See the GNU General Publ 22 * NON INFRINGEMENT. See the GNU General Public License for more
23 * details. 23 * details.
24 * 24 *
25 * You should have received a copy of the GNU 25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to t 26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, 27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 * 28 *
29 * Send feedback to <kristen.c.accardi@intel.c 29 * Send feedback to <kristen.c.accardi@intel.com>
30 * 30 *
31 */ 31 */
32 32
33 /* 33 /*
34 * Lifetime rules for pci_dev: 34 * Lifetime rules for pci_dev:
35 * - The one in acpiphp_func has its refcount 35 * - The one in acpiphp_func has its refcount elevated by pci_get_slot()
36 * when the driver is loaded or when an ins 36 * when the driver is loaded or when an insertion event occurs. It loses
37 * a refcount when its ejected or the drive 37 * a refcount when its ejected or the driver unloads.
38 * - The one in acpiphp_bridge has its refcou 38 * - The one in acpiphp_bridge has its refcount elevated by pci_get_slot()
39 * when the bridge is scanned and it loses 39 * when the bridge is scanned and it loses a refcount when the bridge
40 * is removed. 40 * is removed.
41 */ 41 */
42 42
43 #include <linux/init.h> 43 #include <linux/init.h>
44 #include <linux/module.h> 44 #include <linux/module.h>
45 45
46 #include <linux/kernel.h> 46 #include <linux/kernel.h>
47 #include <linux/pci.h> 47 #include <linux/pci.h>
48 #include <linux/pci_hotplug.h> 48 #include <linux/pci_hotplug.h>
49 #include <linux/mutex.h> 49 #include <linux/mutex.h>
50 50
51 #include "../pci.h" 51 #include "../pci.h"
52 #include "acpiphp.h" 52 #include "acpiphp.h"
53 53
54 static LIST_HEAD(bridge_list); 54 static LIST_HEAD(bridge_list);
55 static LIST_HEAD(ioapic_list); 55 static LIST_HEAD(ioapic_list);
56 static DEFINE_SPINLOCK(ioapic_list_lock); 56 static DEFINE_SPINLOCK(ioapic_list_lock);
57 57
58 #define MY_NAME "acpiphp_glue" 58 #define MY_NAME "acpiphp_glue"
59 59
60 static void handle_hotplug_event_bridge (acpi_ 60 static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
61 static void acpiphp_sanitize_bus(struct pci_bu 61 static void acpiphp_sanitize_bus(struct pci_bus *bus);
62 static void acpiphp_set_hpp_values(acpi_handle 62 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus);
63 static void handle_hotplug_event_func(acpi_han 63 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context);
64 64
65 65
66 /* 66 /*
67 * initialization & terminatation routines 67 * initialization & terminatation routines
68 */ 68 */
69 69
70 /** 70 /**
71 * is_ejectable - determine if a slot is eject 71 * is_ejectable - determine if a slot is ejectable
72 * @handle: handle to acpi namespace 72 * @handle: handle to acpi namespace
73 * 73 *
74 * Ejectable slot should satisfy at least thes 74 * Ejectable slot should satisfy at least these conditions:
75 * 75 *
76 * 1. has _ADR method 76 * 1. has _ADR method
77 * 2. has _EJ0 method 77 * 2. has _EJ0 method
78 * 78 *
79 * optionally 79 * optionally
80 * 80 *
81 * 1. has _STA method 81 * 1. has _STA method
82 * 2. has _PS0 method 82 * 2. has _PS0 method
83 * 3. has _PS3 method 83 * 3. has _PS3 method
84 * 4. .. 84 * 4. ..
85 */ 85 */
86 static int is_ejectable(acpi_handle handle) 86 static int is_ejectable(acpi_handle handle)
87 { 87 {
88 acpi_status status; 88 acpi_status status;
89 acpi_handle tmp; 89 acpi_handle tmp;
90 90
91 status = acpi_get_handle(handle, "_ADR 91 status = acpi_get_handle(handle, "_ADR", &tmp);
92 if (ACPI_FAILURE(status)) { 92 if (ACPI_FAILURE(status)) {
93 return 0; 93 return 0;
94 } 94 }
95 95
96 status = acpi_get_handle(handle, "_EJ0 96 status = acpi_get_handle(handle, "_EJ0", &tmp);
97 if (ACPI_FAILURE(status)) { 97 if (ACPI_FAILURE(status)) {
98 return 0; 98 return 0;
99 } 99 }
100 100
101 return 1; 101 return 1;
102 } 102 }
103 103
104 104
105 /* callback routine to check for the existence 105 /* callback routine to check for the existence of ejectable slots */
106 static acpi_status 106 static acpi_status
107 is_ejectable_slot(acpi_handle handle, u32 lvl, 107 is_ejectable_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
108 { 108 {
109 int *count = (int *)context; 109 int *count = (int *)context;
110 110
111 if (is_ejectable(handle)) { 111 if (is_ejectable(handle)) {
112 (*count)++; 112 (*count)++;
113 /* only one ejectable slot is 113 /* only one ejectable slot is enough */
114 return AE_CTRL_TERMINATE; 114 return AE_CTRL_TERMINATE;
115 } else { 115 } else {
116 return AE_OK; 116 return AE_OK;
117 } 117 }
118 } 118 }
119 119
120 /* callback routine to check for the existence 120 /* callback routine to check for the existence of a pci dock device */
121 static acpi_status 121 static acpi_status
122 is_pci_dock_device(acpi_handle handle, u32 lvl 122 is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
123 { 123 {
124 int *count = (int *)context; 124 int *count = (int *)context;
125 125
126 if (is_dock_device(handle)) { 126 if (is_dock_device(handle)) {
127 (*count)++; 127 (*count)++;
128 return AE_CTRL_TERMINATE; 128 return AE_CTRL_TERMINATE;
129 } else { 129 } else {
130 return AE_OK; 130 return AE_OK;
131 } 131 }
132 } 132 }
133 133
134 134
135 135
136 136
137 /* 137 /*
138 * the _DCK method can do funny things... and 138 * the _DCK method can do funny things... and sometimes not
139 * hah-hah funny. 139 * hah-hah funny.
140 * 140 *
141 * TBD - figure out a way to only call fixups 141 * TBD - figure out a way to only call fixups for
142 * systems that require them. 142 * systems that require them.
143 */ 143 */
144 static int post_dock_fixups(struct notifier_bl 144 static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
145 void *v) 145 void *v)
146 { 146 {
147 struct acpiphp_func *func = container_ 147 struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb);
148 struct pci_bus *bus = func->slot->brid 148 struct pci_bus *bus = func->slot->bridge->pci_bus;
149 u32 buses; 149 u32 buses;
150 150
151 if (!bus->self) 151 if (!bus->self)
152 return NOTIFY_OK; 152 return NOTIFY_OK;
153 153
154 /* fixup bad _DCK function that rewrit 154 /* fixup bad _DCK function that rewrites
155 * secondary bridge on slot 155 * secondary bridge on slot
156 */ 156 */
157 pci_read_config_dword(bus->self, 157 pci_read_config_dword(bus->self,
158 PCI_PRIMARY_BUS, 158 PCI_PRIMARY_BUS,
159 &buses); 159 &buses);
160 160
161 if (((buses >> 8) & 0xff) != bus->seco 161 if (((buses >> 8) & 0xff) != bus->secondary) {
162 buses = (buses & 0xff000000) 162 buses = (buses & 0xff000000)
163 | ((unsigned int)(bus- 163 | ((unsigned int)(bus->primary) << 0)
164 | ((unsigned int)(bus- 164 | ((unsigned int)(bus->secondary) << 8)
165 | ((unsigned int)(bus- 165 | ((unsigned int)(bus->subordinate) << 16);
166 pci_write_config_dword(bus->se 166 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
167 } 167 }
168 return NOTIFY_OK; 168 return NOTIFY_OK;
169 } 169 }
170 170
171 171
172 172
173 173
174 /* callback routine to register each ACPI PCI 174 /* callback routine to register each ACPI PCI slot object */
175 static acpi_status 175 static acpi_status
176 register_slot(acpi_handle handle, u32 lvl, voi 176 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
177 { 177 {
178 struct acpiphp_bridge *bridge = (struc 178 struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context;
179 struct acpiphp_slot *slot; 179 struct acpiphp_slot *slot;
180 struct acpiphp_func *newfunc; 180 struct acpiphp_func *newfunc;
181 acpi_handle tmp; 181 acpi_handle tmp;
182 acpi_status status = AE_OK; 182 acpi_status status = AE_OK;
183 unsigned long adr, sun; 183 unsigned long adr, sun;
184 int device, function, retval; 184 int device, function, retval;
185 185
186 status = acpi_evaluate_integer(handle, 186 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
187 187
188 if (ACPI_FAILURE(status)) 188 if (ACPI_FAILURE(status))
189 return AE_OK; 189 return AE_OK;
190 190
191 status = acpi_get_handle(handle, "_EJ0 191 status = acpi_get_handle(handle, "_EJ0", &tmp);
192 192
193 if (ACPI_FAILURE(status) && !(is_dock_ 193 if (ACPI_FAILURE(status) && !(is_dock_device(handle)))
194 return AE_OK; 194 return AE_OK;
195 195
196 device = (adr >> 16) & 0xffff; 196 device = (adr >> 16) & 0xffff;
197 function = adr & 0xffff; 197 function = adr & 0xffff;
198 198
199 newfunc = kzalloc(sizeof(struct acpiph 199 newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
200 if (!newfunc) 200 if (!newfunc)
201 return AE_NO_MEMORY; 201 return AE_NO_MEMORY;
202 202
203 INIT_LIST_HEAD(&newfunc->sibling); 203 INIT_LIST_HEAD(&newfunc->sibling);
204 newfunc->handle = handle; 204 newfunc->handle = handle;
205 newfunc->function = function; 205 newfunc->function = function;
206 if (ACPI_SUCCESS(status)) 206 if (ACPI_SUCCESS(status))
207 newfunc->flags = FUNC_HAS_EJ0; 207 newfunc->flags = FUNC_HAS_EJ0;
208 208
209 if (ACPI_SUCCESS(acpi_get_handle(handl 209 if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
210 newfunc->flags |= FUNC_HAS_STA 210 newfunc->flags |= FUNC_HAS_STA;
211 211
212 if (ACPI_SUCCESS(acpi_get_handle(handl 212 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp)))
213 newfunc->flags |= FUNC_HAS_PS0 213 newfunc->flags |= FUNC_HAS_PS0;
214 214
215 if (ACPI_SUCCESS(acpi_get_handle(handl 215 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp)))
216 newfunc->flags |= FUNC_HAS_PS3 216 newfunc->flags |= FUNC_HAS_PS3;
217 217
218 if (ACPI_SUCCESS(acpi_get_handle(handl 218 if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp)))
219 newfunc->flags |= FUNC_HAS_DCK 219 newfunc->flags |= FUNC_HAS_DCK;
220 220
221 status = acpi_evaluate_integer(handle, 221 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
222 if (ACPI_FAILURE(status)) { 222 if (ACPI_FAILURE(status)) {
223 /* 223 /*
224 * use the count of the number 224 * use the count of the number of slots we've found
225 * for the number of the slot 225 * for the number of the slot
226 */ 226 */
227 sun = bridge->nr_slots+1; 227 sun = bridge->nr_slots+1;
228 } 228 }
229 229
230 /* search for objects that share the s 230 /* search for objects that share the same slot */
231 for (slot = bridge->slots; slot; slot 231 for (slot = bridge->slots; slot; slot = slot->next)
232 if (slot->device == device) { 232 if (slot->device == device) {
233 if (slot->sun != sun) 233 if (slot->sun != sun)
234 warn("sibling 234 warn("sibling found, but _SUN doesn't match!\n");
235 break; 235 break;
236 } 236 }
237 237
238 if (!slot) { 238 if (!slot) {
239 slot = kzalloc(sizeof(struct a 239 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
240 if (!slot) { 240 if (!slot) {
241 kfree(newfunc); 241 kfree(newfunc);
242 return AE_NO_MEMORY; 242 return AE_NO_MEMORY;
243 } 243 }
244 244
245 slot->bridge = bridge; 245 slot->bridge = bridge;
246 slot->device = device; 246 slot->device = device;
247 slot->sun = sun; 247 slot->sun = sun;
248 INIT_LIST_HEAD(&slot->funcs); 248 INIT_LIST_HEAD(&slot->funcs);
249 mutex_init(&slot->crit_sect); 249 mutex_init(&slot->crit_sect);
250 250
251 slot->next = bridge->slots; 251 slot->next = bridge->slots;
252 bridge->slots = slot; 252 bridge->slots = slot;
253 253
254 bridge->nr_slots++; 254 bridge->nr_slots++;
255 255
256 dbg("found ACPI PCI Hotplug sl 256 dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n",
257 slot->sun, pci 257 slot->sun, pci_domain_nr(bridge->pci_bus),
258 bridge->pci_bu 258 bridge->pci_bus->number, slot->device);
259 retval = acpiphp_register_hotp 259 retval = acpiphp_register_hotplug_slot(slot);
260 if (retval) { 260 if (retval) {
261 warn("acpiphp_register 261 warn("acpiphp_register_hotplug_slot failed(err code = 0x%x)\n", retval);
262 goto err_exit; 262 goto err_exit;
263 } 263 }
264 } 264 }
265 265
266 newfunc->slot = slot; 266 newfunc->slot = slot;
267 list_add_tail(&newfunc->sibling, &slot 267 list_add_tail(&newfunc->sibling, &slot->funcs);
268 268
269 /* associate corresponding pci_dev */ 269 /* associate corresponding pci_dev */
270 newfunc->pci_dev = pci_get_slot(bridge 270 newfunc->pci_dev = pci_get_slot(bridge->pci_bus,
271 PCI_D 271 PCI_DEVFN(device, function));
272 if (newfunc->pci_dev) { 272 if (newfunc->pci_dev) {
273 slot->flags |= (SLOT_ENABLED | 273 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
274 } 274 }
275 275
276 if (is_dock_device(handle)) { 276 if (is_dock_device(handle)) {
277 /* we don't want to call this 277 /* we don't want to call this device's _EJ0
278 * because we want the dock no 278 * because we want the dock notify handler
279 * to call it after it calls _ 279 * to call it after it calls _DCK
280 */ 280 */
281 newfunc->flags &= ~FUNC_HAS_EJ 281 newfunc->flags &= ~FUNC_HAS_EJ0;
282 if (register_hotplug_dock_devi 282 if (register_hotplug_dock_device(handle,
283 handle_hotplug_event_f 283 handle_hotplug_event_func, newfunc))
284 dbg("failed to registe 284 dbg("failed to register dock device\n");
285 285
286 /* we need to be notified when 286 /* we need to be notified when dock events happen
287 * outside of the hotplug oper 287 * outside of the hotplug operation, since we may
288 * need to do fixups before we 288 * need to do fixups before we can hotplug.
289 */ 289 */
290 newfunc->nb.notifier_call = po 290 newfunc->nb.notifier_call = post_dock_fixups;
291 if (register_dock_notifier(&ne 291 if (register_dock_notifier(&newfunc->nb))
292 dbg("failed to registe 292 dbg("failed to register a dock notifier");
293 } 293 }
294 294
295 /* install notify handler */ 295 /* install notify handler */
296 if (!(newfunc->flags & FUNC_HAS_DCK)) 296 if (!(newfunc->flags & FUNC_HAS_DCK)) {
297 status = acpi_install_notify_h 297 status = acpi_install_notify_handler(handle,
298 A 298 ACPI_SYSTEM_NOTIFY,
299 h 299 handle_hotplug_event_func,
300 n 300 newfunc);
301 301
302 if (ACPI_FAILURE(status)) 302 if (ACPI_FAILURE(status))
303 err("failed to registe 303 err("failed to register interrupt notify handler\n");
304 } else 304 } else
305 status = AE_OK; 305 status = AE_OK;
306 306
307 return status; 307 return status;
308 308
309 err_exit: 309 err_exit:
310 bridge->nr_slots--; 310 bridge->nr_slots--;
311 bridge->slots = slot->next; 311 bridge->slots = slot->next;
312 kfree(slot); 312 kfree(slot);
313 kfree(newfunc); 313 kfree(newfunc);
314 314
315 return AE_OK; 315 return AE_OK;
316 } 316 }
317 317
318 318
319 /* see if it's worth looking at this bridge */ 319 /* see if it's worth looking at this bridge */
320 static int detect_ejectable_slots(acpi_handle 320 static int detect_ejectable_slots(acpi_handle *bridge_handle)
321 { 321 {
322 acpi_status status; 322 acpi_status status;
323 int count; 323 int count;
324 324
325 count = 0; 325 count = 0;
326 326
327 /* only check slots defined directly b 327 /* only check slots defined directly below bridge object */
328 status = acpi_walk_namespace(ACPI_TYPE 328 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1,
329 is_ejecta 329 is_ejectable_slot, (void *)&count, NULL);
330 330
331 /* 331 /*
332 * we also need to add this bridge if 332 * we also need to add this bridge if there is a dock bridge or
333 * other pci device on a dock station 333 * other pci device on a dock station (removable)
334 */ 334 */
335 if (!count) 335 if (!count)
336 status = acpi_walk_namespace(A 336 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle,
337 (u32)1, is_pci 337 (u32)1, is_pci_dock_device, (void *)&count,
338 NULL); 338 NULL);
339 339
340 return count; 340 return count;
341 } 341 }
342 342
343 343
344 /* decode ACPI 2.0 _HPP hot plug parameters */ 344 /* decode ACPI 2.0 _HPP hot plug parameters */
345 static void decode_hpp(struct acpiphp_bridge * 345 static void decode_hpp(struct acpiphp_bridge *bridge)
346 { 346 {
347 acpi_status status; 347 acpi_status status;
348 348
349 status = acpi_get_hp_params_from_firmw 349 status = acpi_get_hp_params_from_firmware(bridge->pci_bus, &bridge->hpp);
350 if (ACPI_FAILURE(status) || 350 if (ACPI_FAILURE(status) ||
351 !bridge->hpp.t0 || (bridge->hpp.t0 351 !bridge->hpp.t0 || (bridge->hpp.t0->revision > 1)) {
352 /* use default numbers */ 352 /* use default numbers */
353 printk(KERN_WARNING 353 printk(KERN_WARNING
354 "%s: Could not get hotp 354 "%s: Could not get hotplug parameters. Use defaults\n",
355 __FUNCTION__); 355 __FUNCTION__);
356 bridge->hpp.t0 = &bridge->hpp. 356 bridge->hpp.t0 = &bridge->hpp.type0_data;
357 bridge->hpp.t0->revision = 0; 357 bridge->hpp.t0->revision = 0;
358 bridge->hpp.t0->cache_line_siz 358 bridge->hpp.t0->cache_line_size = 0x10;
359 bridge->hpp.t0->latency_timer 359 bridge->hpp.t0->latency_timer = 0x40;
360 bridge->hpp.t0->enable_serr = 360 bridge->hpp.t0->enable_serr = 0;
361 bridge->hpp.t0->enable_perr = 361 bridge->hpp.t0->enable_perr = 0;
362 } 362 }
363 } 363 }
364 364
365 365
366 366
367 /* initialize miscellaneous stuff for both roo 367 /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */
368 static void init_bridge_misc(struct acpiphp_br 368 static void init_bridge_misc(struct acpiphp_bridge *bridge)
369 { 369 {
370 acpi_status status; 370 acpi_status status;
371 371
372 /* decode ACPI 2.0 _HPP (hot plug para 372 /* decode ACPI 2.0 _HPP (hot plug parameters) */
373 decode_hpp(bridge); 373 decode_hpp(bridge);
374 374
375 /* must be added to the list prior to 375 /* must be added to the list prior to calling register_slot */
376 list_add(&bridge->list, &bridge_list); 376 list_add(&bridge->list, &bridge_list);
377 377
378 /* register all slot objects under thi 378 /* register all slot objects under this bridge */
379 status = acpi_walk_namespace(ACPI_TYPE 379 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1,
380 register_ 380 register_slot, bridge, NULL);
381 if (ACPI_FAILURE(status)) { 381 if (ACPI_FAILURE(status)) {
382 list_del(&bridge->list); 382 list_del(&bridge->list);
383 return; 383 return;
384 } 384 }
385 385
386 /* install notify handler */ 386 /* install notify handler */
387 if (bridge->type != BRIDGE_TYPE_HOST) 387 if (bridge->type != BRIDGE_TYPE_HOST) {
388 if ((bridge->flags & BRIDGE_HA 388 if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
389 status = acpi_remove_n 389 status = acpi_remove_notify_handler(bridge->func->handle,
390 390 ACPI_SYSTEM_NOTIFY,
391 391 handle_hotplug_event_func);
392 if (ACPI_FAILURE(statu 392 if (ACPI_FAILURE(status))
393 err("failed to 393 err("failed to remove notify handler\n");
394 } 394 }
395 status = acpi_install_notify_h 395 status = acpi_install_notify_handler(bridge->handle,
396 A 396 ACPI_SYSTEM_NOTIFY,
397 h 397 handle_hotplug_event_bridge,
398 b 398 bridge);
399 399
400 if (ACPI_FAILURE(status)) { 400 if (ACPI_FAILURE(status)) {
401 err("failed to registe 401 err("failed to register interrupt notify handler\n");
402 } 402 }
403 } 403 }
404 } 404 }
405 405
406 406
407 /* find acpiphp_func from acpiphp_bridge */ 407 /* find acpiphp_func from acpiphp_bridge */
408 static struct acpiphp_func *acpiphp_bridge_han 408 static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle)
409 { 409 {
410 struct list_head *node, *l; 410 struct list_head *node, *l;
411 struct acpiphp_bridge *bridge; 411 struct acpiphp_bridge *bridge;
412 struct acpiphp_slot *slot; 412 struct acpiphp_slot *slot;
413 struct acpiphp_func *func; 413 struct acpiphp_func *func;
414 414
415 list_for_each(node, &bridge_list) { 415 list_for_each(node, &bridge_list) {
416 bridge = list_entry(node, stru 416 bridge = list_entry(node, struct acpiphp_bridge, list);
417 for (slot = bridge->slots; slo 417 for (slot = bridge->slots; slot; slot = slot->next) {
418 list_for_each(l, &slot 418 list_for_each(l, &slot->funcs) {
419 func = list_en 419 func = list_entry(l, struct acpiphp_func,
420 420 sibling);
421 if (func->hand 421 if (func->handle == handle)
422 return 422 return func;
423 } 423 }
424 } 424 }
425 } 425 }
426 426
427 return NULL; 427 return NULL;
428 } 428 }
429 429
430 430
431 static inline void config_p2p_bridge_flags(str 431 static inline void config_p2p_bridge_flags(struct acpiphp_bridge *bridge)
432 { 432 {
433 acpi_handle dummy_handle; 433 acpi_handle dummy_handle;
434 434
435 if (ACPI_SUCCESS(acpi_get_handle(bridg 435 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
436 "_STA" 436 "_STA", &dummy_handle)))
437 bridge->flags |= BRIDGE_HAS_ST 437 bridge->flags |= BRIDGE_HAS_STA;
438 438
439 if (ACPI_SUCCESS(acpi_get_handle(bridg 439 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
440 "_EJ0" 440 "_EJ0", &dummy_handle)))
441 bridge->flags |= BRIDGE_HAS_EJ 441 bridge->flags |= BRIDGE_HAS_EJ0;
442 442
443 if (ACPI_SUCCESS(acpi_get_handle(bridg 443 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
444 "_PS0" 444 "_PS0", &dummy_handle)))
445 bridge->flags |= BRIDGE_HAS_PS 445 bridge->flags |= BRIDGE_HAS_PS0;
446 446
447 if (ACPI_SUCCESS(acpi_get_handle(bridg 447 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
448 "_PS3" 448 "_PS3", &dummy_handle)))
449 bridge->flags |= BRIDGE_HAS_PS 449 bridge->flags |= BRIDGE_HAS_PS3;
450 450
451 /* is this ejectable p2p bridge? */ 451 /* is this ejectable p2p bridge? */
452 if (bridge->flags & BRIDGE_HAS_EJ0) { 452 if (bridge->flags & BRIDGE_HAS_EJ0) {
453 struct acpiphp_func *func; 453 struct acpiphp_func *func;
454 454
455 dbg("found ejectable p2p bridg 455 dbg("found ejectable p2p bridge\n");
456 456
457 /* make link between PCI bridg 457 /* make link between PCI bridge and PCI function */
458 func = acpiphp_bridge_handle_t 458 func = acpiphp_bridge_handle_to_function(bridge->handle);
459 if (!func) 459 if (!func)
460 return; 460 return;
461 bridge->func = func; 461 bridge->func = func;
462 func->bridge = bridge; 462 func->bridge = bridge;
463 } 463 }
464 } 464 }
465 465
466 466
467 /* allocate and initialize host bridge data st 467 /* allocate and initialize host bridge data structure */
468 static void add_host_bridge(acpi_handle *handl 468 static void add_host_bridge(acpi_handle *handle, struct pci_bus *pci_bus)
469 { 469 {
470 struct acpiphp_bridge *bridge; 470 struct acpiphp_bridge *bridge;
471 471
472 bridge = kzalloc(sizeof(struct acpiphp 472 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
473 if (bridge == NULL) 473 if (bridge == NULL)
474 return; 474 return;
475 475
476 bridge->type = BRIDGE_TYPE_HOST; 476 bridge->type = BRIDGE_TYPE_HOST;
477 bridge->handle = handle; 477 bridge->handle = handle;
478 478
479 bridge->pci_bus = pci_bus; 479 bridge->pci_bus = pci_bus;
480 480
481 spin_lock_init(&bridge->res_lock); 481 spin_lock_init(&bridge->res_lock);
482 482
483 init_bridge_misc(bridge); 483 init_bridge_misc(bridge);
484 } 484 }
485 485
486 486
487 /* allocate and initialize PCI-to-PCI bridge d 487 /* allocate and initialize PCI-to-PCI bridge data structure */
488 static void add_p2p_bridge(acpi_handle *handle 488 static void add_p2p_bridge(acpi_handle *handle, struct pci_dev *pci_dev)
489 { 489 {
490 struct acpiphp_bridge *bridge; 490 struct acpiphp_bridge *bridge;
491 491
492 bridge = kzalloc(sizeof(struct acpiphp 492 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
493 if (bridge == NULL) { 493 if (bridge == NULL) {
494 err("out of memory\n"); 494 err("out of memory\n");
495 return; 495 return;
496 } 496 }
497 497
498 bridge->type = BRIDGE_TYPE_P2P; 498 bridge->type = BRIDGE_TYPE_P2P;
499 bridge->handle = handle; 499 bridge->handle = handle;
500 config_p2p_bridge_flags(bridge); 500 config_p2p_bridge_flags(bridge);
501 501
502 bridge->pci_dev = pci_dev_get(pci_dev) 502 bridge->pci_dev = pci_dev_get(pci_dev);
503 bridge->pci_bus = pci_dev->subordinate 503 bridge->pci_bus = pci_dev->subordinate;
504 if (!bridge->pci_bus) { 504 if (!bridge->pci_bus) {
505 err("This is not a PCI-to-PCI 505 err("This is not a PCI-to-PCI bridge!\n");
506 goto err; 506 goto err;
507 } 507 }
508 508
509 spin_lock_init(&bridge->res_lock); 509 spin_lock_init(&bridge->res_lock);
510 510
511 init_bridge_misc(bridge); 511 init_bridge_misc(bridge);
512 return; 512 return;
513 err: 513 err:
514 pci_dev_put(pci_dev); 514 pci_dev_put(pci_dev);
515 kfree(bridge); 515 kfree(bridge);
516 return; 516 return;
517 } 517 }
518 518
519 519
520 /* callback routine to find P2P bridges */ 520 /* callback routine to find P2P bridges */
521 static acpi_status 521 static acpi_status
522 find_p2p_bridge(acpi_handle handle, u32 lvl, v 522 find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
523 { 523 {
524 acpi_status status; 524 acpi_status status;
525 acpi_handle dummy_handle; 525 acpi_handle dummy_handle;
526 unsigned long tmp; 526 unsigned long tmp;
527 int device, function; 527 int device, function;
528 struct pci_dev *dev; 528 struct pci_dev *dev;
529 struct pci_bus *pci_bus = context; 529 struct pci_bus *pci_bus = context;
530 530
531 status = acpi_get_handle(handle, "_ADR 531 status = acpi_get_handle(handle, "_ADR", &dummy_handle);
532 if (ACPI_FAILURE(status)) 532 if (ACPI_FAILURE(status))
533 return AE_OK; /* con 533 return AE_OK; /* continue */
534 534
535 status = acpi_evaluate_integer(handle, 535 status = acpi_evaluate_integer(handle, "_ADR", NULL, &tmp);
536 if (ACPI_FAILURE(status)) { 536 if (ACPI_FAILURE(status)) {
537 dbg("%s: _ADR evaluation failu 537 dbg("%s: _ADR evaluation failure\n", __FUNCTION__);
538 return AE_OK; 538 return AE_OK;
539 } 539 }
540 540
541 device = (tmp >> 16) & 0xffff; 541 device = (tmp >> 16) & 0xffff;
542 function = tmp & 0xffff; 542 function = tmp & 0xffff;
543 543
544 dev = pci_get_slot(pci_bus, PCI_DEVFN( 544 dev = pci_get_slot(pci_bus, PCI_DEVFN(device, function));
545 545
546 if (!dev || !dev->subordinate) 546 if (!dev || !dev->subordinate)
547 goto out; 547 goto out;
548 548
549 /* check if this bridge has ejectable 549 /* check if this bridge has ejectable slots */
550 if ((detect_ejectable_slots(handle) > 550 if ((detect_ejectable_slots(handle) > 0)) {
551 dbg("found PCI-to-PCI bridge a 551 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev));
552 add_p2p_bridge(handle, dev); 552 add_p2p_bridge(handle, dev);
553 } 553 }
554 554
555 /* search P2P bridges under this p2p b 555 /* search P2P bridges under this p2p bridge */
556 status = acpi_walk_namespace(ACPI_TYPE 556 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
557 find_p2p_ 557 find_p2p_bridge, dev->subordinate, NULL);
558 if (ACPI_FAILURE(status)) 558 if (ACPI_FAILURE(status))
559 warn("find_p2p_bridge failed ( 559 warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
560 560
561 out: 561 out:
562 pci_dev_put(dev); 562 pci_dev_put(dev);
563 return AE_OK; 563 return AE_OK;
564 } 564 }
565 565
566 566
567 /* find hot-pluggable slots, and then find P2P 567 /* find hot-pluggable slots, and then find P2P bridge */
568 static int add_bridge(acpi_handle handle) 568 static int add_bridge(acpi_handle handle)
569 { 569 {
570 acpi_status status; 570 acpi_status status;
571 unsigned long tmp; 571 unsigned long tmp;
572 int seg, bus; 572 int seg, bus;
573 acpi_handle dummy_handle; 573 acpi_handle dummy_handle;
574 struct pci_bus *pci_bus; 574 struct pci_bus *pci_bus;
575 575
576 /* if the bridge doesn't have _STA, we 576 /* if the bridge doesn't have _STA, we assume it is always there */
577 status = acpi_get_handle(handle, "_STA 577 status = acpi_get_handle(handle, "_STA", &dummy_handle);
578 if (ACPI_SUCCESS(status)) { 578 if (ACPI_SUCCESS(status)) {
579 status = acpi_evaluate_integer 579 status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp);
580 if (ACPI_FAILURE(status)) { 580 if (ACPI_FAILURE(status)) {
581 dbg("%s: _STA evaluati 581 dbg("%s: _STA evaluation failure\n", __FUNCTION__);
582 return 0; 582 return 0;
583 } 583 }
584 if ((tmp & ACPI_STA_FUNCTIONIN 584 if ((tmp & ACPI_STA_FUNCTIONING) == 0)
585 /* don't register this 585 /* don't register this object */
586 return 0; 586 return 0;
587 } 587 }
588 588
589 /* get PCI segment number */ 589 /* get PCI segment number */
590 status = acpi_evaluate_integer(handle, 590 status = acpi_evaluate_integer(handle, "_SEG", NULL, &tmp);
591 591
592 seg = ACPI_SUCCESS(status) ? tmp : 0; 592 seg = ACPI_SUCCESS(status) ? tmp : 0;
593 593
594 /* get PCI bus number */ 594 /* get PCI bus number */
595 status = acpi_evaluate_integer(handle, 595 status = acpi_evaluate_integer(handle, "_BBN", NULL, &tmp);
596 596
597 if (ACPI_SUCCESS(status)) { 597 if (ACPI_SUCCESS(status)) {
598 bus = tmp; 598 bus = tmp;
599 } else { 599 } else {
600 warn("can't get bus number, as 600 warn("can't get bus number, assuming 0\n");
601 bus = 0; 601 bus = 0;
602 } 602 }
603 603
604 pci_bus = pci_find_bus(seg, bus); 604 pci_bus = pci_find_bus(seg, bus);
605 if (!pci_bus) { 605 if (!pci_bus) {
606 err("Can't find bus %04x:%02x\ 606 err("Can't find bus %04x:%02x\n", seg, bus);
607 return 0; 607 return 0;
608 } 608 }
609 609
610 /* check if this bridge has ejectable 610 /* check if this bridge has ejectable slots */
611 if (detect_ejectable_slots(handle) > 0 611 if (detect_ejectable_slots(handle) > 0) {
612 dbg("found PCI host-bus bridge 612 dbg("found PCI host-bus bridge with hot-pluggable slots\n");
613 add_host_bridge(handle, pci_bu 613 add_host_bridge(handle, pci_bus);
614 } 614 }
615 615
616 /* search P2P bridges under this host 616 /* search P2P bridges under this host bridge */
617 status = acpi_walk_namespace(ACPI_TYPE 617 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
618 find_p2p_ 618 find_p2p_bridge, pci_bus, NULL);
619 619
620 if (ACPI_FAILURE(status)) 620 if (ACPI_FAILURE(status))
621 warn("find_p2p_bridge failed ( 621 warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
622 622
623 return 0; 623 return 0;
624 } 624 }
625 625
626 static struct acpiphp_bridge *acpiphp_handle_t 626 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle)
627 { 627 {
628 struct list_head *head; 628 struct list_head *head;
629 list_for_each(head, &bridge_list) { 629 list_for_each(head, &bridge_list) {
630 struct acpiphp_bridge *bridge 630 struct acpiphp_bridge *bridge = list_entry(head,
631 631 struct acpiphp_bridge, list);
632 if (bridge->handle == handle) 632 if (bridge->handle == handle)
633 return bridge; 633 return bridge;
634 } 634 }
635 635
636 return NULL; 636 return NULL;
637 } 637 }
638 638
639 static void cleanup_bridge(struct acpiphp_brid 639 static void cleanup_bridge(struct acpiphp_bridge *bridge)
640 { 640 {
641 struct list_head *list, *tmp; 641 struct list_head *list, *tmp;
642 struct acpiphp_slot *slot; 642 struct acpiphp_slot *slot;
643 acpi_status status; 643 acpi_status status;
644 acpi_handle handle = bridge->handle; 644 acpi_handle handle = bridge->handle;
645 645
646 status = acpi_remove_notify_handler(ha 646 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
647 ha 647 handle_hotplug_event_bridge);
648 if (ACPI_FAILURE(status)) 648 if (ACPI_FAILURE(status))
649 err("failed to remove notify h 649 err("failed to remove notify handler\n");
650 650
651 if ((bridge->type != BRIDGE_TYPE_HOST) 651 if ((bridge->type != BRIDGE_TYPE_HOST) &&
652 ((bridge->flags & BRIDGE_HAS_EJ0) 652 ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func)) {
653 status = acpi_install_notify_h 653 status = acpi_install_notify_handler(bridge->func->handle,
654 654 ACPI_SYSTEM_NOTIFY,
655 655 handle_hotplug_event_func,
656 656 bridge->func);
657 if (ACPI_FAILURE(status)) 657 if (ACPI_FAILURE(status))
658 err("failed to install 658 err("failed to install interrupt notify handler\n");
659 } 659 }
660 660
661 slot = bridge->slots; 661 slot = bridge->slots;
662 while (slot) { 662 while (slot) {
663 struct acpiphp_slot *next = sl 663 struct acpiphp_slot *next = slot->next;
664 list_for_each_safe (list, tmp, 664 list_for_each_safe (list, tmp, &slot->funcs) {
665 struct acpiphp_func *f 665 struct acpiphp_func *func;
666 func = list_entry(list 666 func = list_entry(list, struct acpiphp_func, sibling);
667 if (is_dock_device(fun 667 if (is_dock_device(func->handle)) {
668 unregister_hot 668 unregister_hotplug_dock_device(func->handle);
669 unregister_doc 669 unregister_dock_notifier(&func->nb);
670 } 670 }
671 if (!(func->flags & FU 671 if (!(func->flags & FUNC_HAS_DCK)) {
672 status = acpi_ 672 status = acpi_remove_notify_handler(func->handle,
673 673 ACPI_SYSTEM_NOTIFY,
674 674 handle_hotplug_event_func);
675 if (ACPI_FAILU 675 if (ACPI_FAILURE(status))
676 err("f 676 err("failed to remove notify handler\n");
677 } 677 }
678 pci_dev_put(func->pci_ 678 pci_dev_put(func->pci_dev);
679 list_del(list); 679 list_del(list);
680 kfree(func); 680 kfree(func);
681 } 681 }
682 acpiphp_unregister_hotplug_slo 682 acpiphp_unregister_hotplug_slot(slot);
683 list_del(&slot->funcs); 683 list_del(&slot->funcs);
684 kfree(slot); 684 kfree(slot);
685 slot = next; 685 slot = next;
686 } 686 }
687 687
688 pci_dev_put(bridge->pci_dev); 688 pci_dev_put(bridge->pci_dev);
689 list_del(&bridge->list); 689 list_del(&bridge->list);
690 kfree(bridge); 690 kfree(bridge);
691 } 691 }
692 692
693 static acpi_status 693 static acpi_status
694 cleanup_p2p_bridge(acpi_handle handle, u32 lvl 694 cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
695 { 695 {
696 struct acpiphp_bridge *bridge; 696 struct acpiphp_bridge *bridge;
697 697
698 /* cleanup p2p bridges under this P2P 698 /* cleanup p2p bridges under this P2P bridge
699 in a depth-first manner */ 699 in a depth-first manner */
700 acpi_walk_namespace(ACPI_TYPE_DEVICE, 700 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
701 cleanup_p2p_br 701 cleanup_p2p_bridge, NULL, NULL);
702 702
703 if (!(bridge = acpiphp_handle_to_bridg 703 if (!(bridge = acpiphp_handle_to_bridge(handle)))
704 return AE_OK; 704 return AE_OK;
705 cleanup_bridge(bridge); 705 cleanup_bridge(bridge);
706 return AE_OK; 706 return AE_OK;
707 } 707 }
708 708
709 static void remove_bridge(acpi_handle handle) 709 static void remove_bridge(acpi_handle handle)
710 { 710 {
711 struct acpiphp_bridge *bridge; 711 struct acpiphp_bridge *bridge;
712 712
713 /* cleanup p2p bridges under this host 713 /* cleanup p2p bridges under this host bridge
714 in a depth-first manner */ 714 in a depth-first manner */
715 acpi_walk_namespace(ACPI_TYPE_DEVICE, 715 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
716 (u32)1, cleanu 716 (u32)1, cleanup_p2p_bridge, NULL, NULL);
717 717
718 bridge = acpiphp_handle_to_bridge(hand 718 bridge = acpiphp_handle_to_bridge(handle);
719 if (bridge) 719 if (bridge)
720 cleanup_bridge(bridge); 720 cleanup_bridge(bridge);
721 } 721 }
722 722
723 static struct pci_dev * get_apic_pci_info(acpi 723 static struct pci_dev * get_apic_pci_info(acpi_handle handle)
724 { 724 {
725 struct acpi_pci_id id; 725 struct acpi_pci_id id;
726 struct pci_bus *bus; 726 struct pci_bus *bus;
727 struct pci_dev *dev; 727 struct pci_dev *dev;
728 728
729 if (ACPI_FAILURE(acpi_get_pci_id(handl 729 if (ACPI_FAILURE(acpi_get_pci_id(handle, &id)))
730 return NULL; 730 return NULL;
731 731
732 bus = pci_find_bus(id.segment, id.bus) 732 bus = pci_find_bus(id.segment, id.bus);
733 if (!bus) 733 if (!bus)
734 return NULL; 734 return NULL;
735 735
736 dev = pci_get_slot(bus, PCI_DEVFN(id.d 736 dev = pci_get_slot(bus, PCI_DEVFN(id.device, id.function));
737 if (!dev) 737 if (!dev)
738 return NULL; 738 return NULL;
739 739
740 if ((dev->class != PCI_CLASS_SYSTEM_PI 740 if ((dev->class != PCI_CLASS_SYSTEM_PIC_IOAPIC) &&
741 (dev->class != PCI_CLASS_SYSTEM_PI 741 (dev->class != PCI_CLASS_SYSTEM_PIC_IOXAPIC))
742 { 742 {
743 pci_dev_put(dev); 743 pci_dev_put(dev);
744 return NULL; 744 return NULL;
745 } 745 }
746 746
747 return dev; 747 return dev;
748 } 748 }
749 749
750 static int get_gsi_base(acpi_handle handle, u3 750 static int get_gsi_base(acpi_handle handle, u32 *gsi_base)
751 { 751 {
752 acpi_status status; 752 acpi_status status;
753 int result = -1; 753 int result = -1;
754 unsigned long gsb; 754 unsigned long gsb;
755 struct acpi_buffer buffer = {ACPI_ALLO 755 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
756 union acpi_object *obj; 756 union acpi_object *obj;
757 void *table; 757 void *table;
758 758
759 status = acpi_evaluate_integer(handle, 759 status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb);
760 if (ACPI_SUCCESS(status)) { 760 if (ACPI_SUCCESS(status)) {
761 *gsi_base = (u32)gsb; 761 *gsi_base = (u32)gsb;
762 return 0; 762 return 0;
763 } 763 }
764 764
765 status = acpi_evaluate_object(handle, 765 status = acpi_evaluate_object(handle, "_MAT", NULL, &buffer);
766 if (ACPI_FAILURE(status) || !buffer.le 766 if (ACPI_FAILURE(status) || !buffer.length || !buffer.pointer)
767 return -1; 767 return -1;
768 768
769 obj = buffer.pointer; 769 obj = buffer.pointer;
770 if (obj->type != ACPI_TYPE_BUFFER) 770 if (obj->type != ACPI_TYPE_BUFFER)
771 goto out; 771 goto out;
772 772
773 table = obj->buffer.pointer; 773 table = obj->buffer.pointer;
774 switch (((struct acpi_subtable_header 774 switch (((struct acpi_subtable_header *)table)->type) {
775 case ACPI_MADT_TYPE_IO_SAPIC: 775 case ACPI_MADT_TYPE_IO_SAPIC:
776 *gsi_base = ((struct acpi_madt 776 *gsi_base = ((struct acpi_madt_io_sapic *)table)->global_irq_base;
777 result = 0; 777 result = 0;
778 break; 778 break;
779 case ACPI_MADT_TYPE_IO_APIC: 779 case ACPI_MADT_TYPE_IO_APIC:
780 *gsi_base = ((struct acpi_madt 780 *gsi_base = ((struct acpi_madt_io_apic *)table)->global_irq_base;
781 result = 0; 781 result = 0;
782 break; 782 break;
783 default: 783 default:
784 break; 784 break;
785 } 785 }
786 out: 786 out:
787 kfree(buffer.pointer); 787 kfree(buffer.pointer);
788 return result; 788 return result;
789 } 789 }
790 790
791 static acpi_status 791 static acpi_status
792 ioapic_add(acpi_handle handle, u32 lvl, void * 792 ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv)
793 { 793 {
794 acpi_status status; 794 acpi_status status;
795 unsigned long sta; 795 unsigned long sta;
796 acpi_handle tmp; 796 acpi_handle tmp;
797 struct pci_dev *pdev; 797 struct pci_dev *pdev;
798 u32 gsi_base; 798 u32 gsi_base;
799 u64 phys_addr; 799 u64 phys_addr;
800 struct acpiphp_ioapic *ioapic; 800 struct acpiphp_ioapic *ioapic;
801 801
802 /* Evaluate _STA if present */ 802 /* Evaluate _STA if present */
803 status = acpi_evaluate_integer(handle, 803 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
804 if (ACPI_SUCCESS(status) && sta != ACP 804 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL)
805 return AE_CTRL_DEPTH; 805 return AE_CTRL_DEPTH;
806 806
807 /* Scan only PCI bus scope */ 807 /* Scan only PCI bus scope */
808 status = acpi_get_handle(handle, "_HID 808 status = acpi_get_handle(handle, "_HID", &tmp);
809 if (ACPI_SUCCESS(status)) 809 if (ACPI_SUCCESS(status))
810 return AE_CTRL_DEPTH; 810 return AE_CTRL_DEPTH;
811 811
812 if (get_gsi_base(handle, &gsi_base)) 812 if (get_gsi_base(handle, &gsi_base))
813 return AE_OK; 813 return AE_OK;
814 814
815 ioapic = kmalloc(sizeof(*ioapic), GFP_ 815 ioapic = kmalloc(sizeof(*ioapic), GFP_KERNEL);
816 if (!ioapic) 816 if (!ioapic)
817 return AE_NO_MEMORY; 817 return AE_NO_MEMORY;
818 818
819 pdev = get_apic_pci_info(handle); 819 pdev = get_apic_pci_info(handle);
820 if (!pdev) 820 if (!pdev)
821 goto exit_kfree; 821 goto exit_kfree;
822 822
823 if (pci_enable_device(pdev)) 823 if (pci_enable_device(pdev))
824 goto exit_pci_dev_put; 824 goto exit_pci_dev_put;
825 825
826 pci_set_master(pdev); 826 pci_set_master(pdev);
827 827
828 if (pci_request_region(pdev, 0, "I/O A 828 if (pci_request_region(pdev, 0, "I/O APIC(acpiphp)"))
829 goto exit_pci_disable_device; 829 goto exit_pci_disable_device;
830 830
831 phys_addr = pci_resource_start(pdev, 0 831 phys_addr = pci_resource_start(pdev, 0);
832 if (acpi_register_ioapic(handle, phys_ 832 if (acpi_register_ioapic(handle, phys_addr, gsi_base))
833 goto exit_pci_release_region; 833 goto exit_pci_release_region;
834 834
835 ioapic->gsi_base = gsi_base; 835 ioapic->gsi_base = gsi_base;
836 ioapic->dev = pdev; 836 ioapic->dev = pdev;
837 spin_lock(&ioapic_list_lock); 837 spin_lock(&ioapic_list_lock);
838 list_add_tail(&ioapic->list, &ioapic_l 838 list_add_tail(&ioapic->list, &ioapic_list);
839 spin_unlock(&ioapic_list_lock); 839 spin_unlock(&ioapic_list_lock);
840 840
841 return AE_OK; 841 return AE_OK;
842 842
843 exit_pci_release_region: 843 exit_pci_release_region:
844 pci_release_region(pdev, 0); 844 pci_release_region(pdev, 0);
845 exit_pci_disable_device: 845 exit_pci_disable_device:
846 pci_disable_device(pdev); 846 pci_disable_device(pdev);
847 exit_pci_dev_put: 847 exit_pci_dev_put:
848 pci_dev_put(pdev); 848 pci_dev_put(pdev);
849 exit_kfree: 849 exit_kfree:
850 kfree(ioapic); 850 kfree(ioapic);
851 851
852 return AE_OK; 852 return AE_OK;
853 } 853 }
854 854
855 static acpi_status 855 static acpi_status
856 ioapic_remove(acpi_handle handle, u32 lvl, voi 856 ioapic_remove(acpi_handle handle, u32 lvl, void *context, void **rv)
857 { 857 {
858 acpi_status status; 858 acpi_status status;
859 unsigned long sta; 859 unsigned long sta;
860 acpi_handle tmp; 860 acpi_handle tmp;
861 u32 gsi_base; 861 u32 gsi_base;
862 struct acpiphp_ioapic *pos, *n, *ioapi 862 struct acpiphp_ioapic *pos, *n, *ioapic = NULL;
863 863
864 /* Evaluate _STA if present */ 864 /* Evaluate _STA if present */
865 status = acpi_evaluate_integer(handle, 865 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
866 if (ACPI_SUCCESS(status) && sta != ACP 866 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL)
867 return AE_CTRL_DEPTH; 867 return AE_CTRL_DEPTH;
868 868
869 /* Scan only PCI bus scope */ 869 /* Scan only PCI bus scope */
870 status = acpi_get_handle(handle, "_HID 870 status = acpi_get_handle(handle, "_HID", &tmp);
871 if (ACPI_SUCCESS(status)) 871 if (ACPI_SUCCESS(status))
872 return AE_CTRL_DEPTH; 872 return AE_CTRL_DEPTH;
873 873
874 if (get_gsi_base(handle, &gsi_base)) 874 if (get_gsi_base(handle, &gsi_base))
875 return AE_OK; 875 return AE_OK;
876 876
877 acpi_unregister_ioapic(handle, gsi_bas 877 acpi_unregister_ioapic(handle, gsi_base);
878 878
879 spin_lock(&ioapic_list_lock); 879 spin_lock(&ioapic_list_lock);
880 list_for_each_entry_safe(pos, n, &ioap 880 list_for_each_entry_safe(pos, n, &ioapic_list, list) {
881 if (pos->gsi_base != gsi_base) 881 if (pos->gsi_base != gsi_base)
882 continue; 882 continue;
883 ioapic = pos; 883 ioapic = pos;
884 list_del(&ioapic->list); 884 list_del(&ioapic->list);
885 break; 885 break;
886 } 886 }
887 spin_unlock(&ioapic_list_lock); 887 spin_unlock(&ioapic_list_lock);
888 888
889 if (!ioapic) 889 if (!ioapic)
890 return AE_OK; 890 return AE_OK;
891 891
892 pci_release_region(ioapic->dev, 0); 892 pci_release_region(ioapic->dev, 0);
893 pci_disable_device(ioapic->dev); 893 pci_disable_device(ioapic->dev);
894 pci_dev_put(ioapic->dev); 894 pci_dev_put(ioapic->dev);
895 kfree(ioapic); 895 kfree(ioapic);
896 896
897 return AE_OK; 897 return AE_OK;
898 } 898 }
899 899
900 static int acpiphp_configure_ioapics(acpi_hand 900 static int acpiphp_configure_ioapics(acpi_handle handle)
901 { 901 {
902 ioapic_add(handle, 0, NULL, NULL); 902 ioapic_add(handle, 0, NULL, NULL);
903 acpi_walk_namespace(ACPI_TYPE_DEVICE, 903 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
904 ACPI_UINT32_MAX, i 904 ACPI_UINT32_MAX, ioapic_add, NULL, NULL);
905 return 0; 905 return 0;
906 } 906 }
907 907
908 static int acpiphp_unconfigure_ioapics(acpi_ha 908 static int acpiphp_unconfigure_ioapics(acpi_handle handle)
909 { 909 {
910 ioapic_remove(handle, 0, NULL, NULL); 910 ioapic_remove(handle, 0, NULL, NULL);
911 acpi_walk_namespace(ACPI_TYPE_DEVICE, 911 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
912 ACPI_UINT32_MAX, i 912 ACPI_UINT32_MAX, ioapic_remove, NULL, NULL);
913 return 0; 913 return 0;
914 } 914 }
915 915
916 static int power_on_slot(struct acpiphp_slot * 916 static int power_on_slot(struct acpiphp_slot *slot)
917 { 917 {
918 acpi_status status; 918 acpi_status status;
919 struct acpiphp_func *func; 919 struct acpiphp_func *func;
920 struct list_head *l; 920 struct list_head *l;
921 int retval = 0; 921 int retval = 0;
922 922
923 /* if already enabled, just skip */ 923 /* if already enabled, just skip */
924 if (slot->flags & SLOT_POWEREDON) 924 if (slot->flags & SLOT_POWEREDON)
925 goto err_exit; 925 goto err_exit;
926 926
927 list_for_each (l, &slot->funcs) { 927 list_for_each (l, &slot->funcs) {
928 func = list_entry(l, struct ac 928 func = list_entry(l, struct acpiphp_func, sibling);
929 929
930 if (func->flags & FUNC_HAS_PS0 930 if (func->flags & FUNC_HAS_PS0) {
931 dbg("%s: executing _PS 931 dbg("%s: executing _PS0\n", __FUNCTION__);
932 status = acpi_evaluate 932 status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL);
933 if (ACPI_FAILURE(statu 933 if (ACPI_FAILURE(status)) {
934 warn("%s: _PS0 934 warn("%s: _PS0 failed\n", __FUNCTION__);
935 retval = -1; 935 retval = -1;
936 goto err_exit; 936 goto err_exit;
937 } else 937 } else
938 break; 938 break;
939 } 939 }
940 } 940 }
941 941
942 /* TBD: evaluate _STA to check if the 942 /* TBD: evaluate _STA to check if the slot is enabled */
943 943
944 slot->flags |= SLOT_POWEREDON; 944 slot->flags |= SLOT_POWEREDON;
945 945
946 err_exit: 946 err_exit:
947 return retval; 947 return retval;
948 } 948 }
949 949
950 950
951 static int power_off_slot(struct acpiphp_slot 951 static int power_off_slot(struct acpiphp_slot *slot)
952 { 952 {
953 acpi_status status; 953 acpi_status status;
954 struct acpiphp_func *func; 954 struct acpiphp_func *func;
955 struct list_head *l; 955 struct list_head *l;
956 956
957 int retval = 0; 957 int retval = 0;
958 958
959 /* if already disabled, just skip */ 959 /* if already disabled, just skip */
960 if ((slot->flags & SLOT_POWEREDON) == 960 if ((slot->flags & SLOT_POWEREDON) == 0)
961 goto err_exit; 961 goto err_exit;
962 962
963 list_for_each (l, &slot->funcs) { 963 list_for_each (l, &slot->funcs) {
964 func = list_entry(l, struct ac 964 func = list_entry(l, struct acpiphp_func, sibling);
965 965
966 if (func->flags & FUNC_HAS_PS3 966 if (func->flags & FUNC_HAS_PS3) {
967 status = acpi_evaluate 967 status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL);
968 if (ACPI_FAILURE(statu 968 if (ACPI_FAILURE(status)) {
969 warn("%s: _PS3 969 warn("%s: _PS3 failed\n", __FUNCTION__);
970 retval = -1; 970 retval = -1;
971 goto err_exit; 971 goto err_exit;
972 } else 972 } else
973 break; 973 break;
974 } 974 }
975 } 975 }
976 976
977 /* TBD: evaluate _STA to check if the 977 /* TBD: evaluate _STA to check if the slot is disabled */
978 978
979 slot->flags &= (~SLOT_POWEREDON); 979 slot->flags &= (~SLOT_POWEREDON);
980 980
981 err_exit: 981 err_exit:
982 return retval; 982 return retval;
983 } 983 }
984 984
985 985
986 986
987 /** 987 /**
988 * acpiphp_max_busnr - return the highest rese 988 * acpiphp_max_busnr - return the highest reserved bus number under the given bus.
989 * @bus: bus to start search with 989 * @bus: bus to start search with
990 */ 990 */
991 static unsigned char acpiphp_max_busnr(struct 991 static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
992 { 992 {
993 struct list_head *tmp; 993 struct list_head *tmp;
994 unsigned char max, n; 994 unsigned char max, n;
995 995
996 /* 996 /*
997 * pci_bus_max_busnr will return the h 997 * pci_bus_max_busnr will return the highest
998 * reserved busnr for all these childr 998 * reserved busnr for all these children.
999 * that is equivalent to the bus->subo 999 * that is equivalent to the bus->subordinate
1000 * value. We don't want to use the p 1000 * value. We don't want to use the parent's
1001 * bus->subordinate value because it 1001 * bus->subordinate value because it could have
1002 * padding in it. 1002 * padding in it.
1003 */ 1003 */
1004 max = bus->secondary; 1004 max = bus->secondary;
1005 1005
1006 list_for_each(tmp, &bus->children) { 1006 list_for_each(tmp, &bus->children) {
1007 n = pci_bus_max_busnr(pci_bus 1007 n = pci_bus_max_busnr(pci_bus_b(tmp));
1008 if (n > max) 1008 if (n > max)
1009 max = n; 1009 max = n;
1010 } 1010 }
1011 return max; 1011 return max;
1012 } 1012 }
1013 1013
1014 1014
1015 /** 1015 /**
1016 * acpiphp_bus_add - add a new bus to acpi su 1016 * acpiphp_bus_add - add a new bus to acpi subsystem
1017 * @func: acpiphp_func of the bridge 1017 * @func: acpiphp_func of the bridge
1018 */ 1018 */
1019 static int acpiphp_bus_add(struct acpiphp_fun 1019 static int acpiphp_bus_add(struct acpiphp_func *func)
1020 { 1020 {
1021 acpi_handle phandle; 1021 acpi_handle phandle;
1022 struct acpi_device *device, *pdevice; 1022 struct acpi_device *device, *pdevice;
1023 int ret_val; 1023 int ret_val;
1024 1024
1025 acpi_get_parent(func->handle, &phandl 1025 acpi_get_parent(func->handle, &phandle);
1026 if (acpi_bus_get_device(phandle, &pde 1026 if (acpi_bus_get_device(phandle, &pdevice)) {
1027 dbg("no parent device, assumi 1027 dbg("no parent device, assuming NULL\n");
1028 pdevice = NULL; 1028 pdevice = NULL;
1029 } 1029 }
1030 if (!acpi_bus_get_device(func->handle 1030 if (!acpi_bus_get_device(func->handle, &device)) {
1031 dbg("bus exists... trim\n"); 1031 dbg("bus exists... trim\n");
1032 /* this shouldn't be in here, 1032 /* this shouldn't be in here, so remove
1033 * the bus then re-add it... 1033 * the bus then re-add it...
1034 */ 1034 */
1035 ret_val = acpi_bus_trim(devic 1035 ret_val = acpi_bus_trim(device, 1);
1036 dbg("acpi_bus_trim return %x\ 1036 dbg("acpi_bus_trim return %x\n", ret_val);
1037 } 1037 }
1038 1038
1039 ret_val = acpi_bus_add(&device, pdevi 1039 ret_val = acpi_bus_add(&device, pdevice, func->handle,
1040 ACPI_BUS_TYPE_DEVICE); 1040 ACPI_BUS_TYPE_DEVICE);
1041 if (ret_val) { 1041 if (ret_val) {
1042 dbg("error adding bus, %x\n", 1042 dbg("error adding bus, %x\n",
1043 -ret_val); 1043 -ret_val);
1044 goto acpiphp_bus_add_out; 1044 goto acpiphp_bus_add_out;
1045 } 1045 }
1046 /* 1046 /*
1047 * try to start anyway. We could hav 1047 * try to start anyway. We could have failed to add
1048 * simply because this bus had previo 1048 * simply because this bus had previously been added
1049 * on another add. Don't bother with 1049 * on another add. Don't bother with the return value
1050 * we just keep going. 1050 * we just keep going.
1051 */ 1051 */
1052 ret_val = acpi_bus_start(device); 1052 ret_val = acpi_bus_start(device);
1053 1053
1054 acpiphp_bus_add_out: 1054 acpiphp_bus_add_out:
1055 return ret_val; 1055 return ret_val;
1056 } 1056 }
1057 1057
1058 1058
1059 /** 1059 /**
1060 * acpiphp_bus_trim - trim a bus from acpi su 1060 * acpiphp_bus_trim - trim a bus from acpi subsystem
1061 * @handle: handle to acpi namespace 1061 * @handle: handle to acpi namespace
1062 */ 1062 */
1063 static int acpiphp_bus_trim(acpi_handle handl 1063 static int acpiphp_bus_trim(acpi_handle handle)
1064 { 1064 {
1065 struct acpi_device *device; 1065 struct acpi_device *device;
1066 int retval; 1066 int retval;
1067 1067
1068 retval = acpi_bus_get_device(handle, 1068 retval = acpi_bus_get_device(handle, &device);
1069 if (retval) { 1069 if (retval) {
1070 dbg("acpi_device not found\n" 1070 dbg("acpi_device not found\n");
1071 return retval; 1071 return retval;
1072 } 1072 }
1073 1073
1074 retval = acpi_bus_trim(device, 1); 1074 retval = acpi_bus_trim(device, 1);
1075 if (retval) 1075 if (retval)
1076 err("cannot remove from acpi 1076 err("cannot remove from acpi list\n");
1077 1077
1078 return retval; 1078 return retval;
1079 } 1079 }
1080 1080
1081 /** 1081 /**
1082 * enable_device - enable, configure a slot 1082 * enable_device - enable, configure a slot
1083 * @slot: slot to be enabled 1083 * @slot: slot to be enabled
1084 * 1084 *
1085 * This function should be called per *physic 1085 * This function should be called per *physical slot*,
1086 * not per each slot object in ACPI namespace 1086 * not per each slot object in ACPI namespace.
1087 */ 1087 */
1088 static int __ref enable_device(struct acpiphp 1088 static int __ref enable_device(struct acpiphp_slot *slot)
1089 { 1089 {
1090 struct pci_dev *dev; 1090 struct pci_dev *dev;
1091 struct pci_bus *bus = slot->bridge->p 1091 struct pci_bus *bus = slot->bridge->pci_bus;
1092 struct list_head *l; 1092 struct list_head *l;
1093 struct acpiphp_func *func; 1093 struct acpiphp_func *func;
1094 int retval = 0; 1094 int retval = 0;
1095 int num, max, pass; 1095 int num, max, pass;
1096 acpi_status status; 1096 acpi_status status;
1097 1097
1098 if (slot->flags & SLOT_ENABLED) 1098 if (slot->flags & SLOT_ENABLED)
1099 goto err_exit; 1099 goto err_exit;
1100 1100
1101 /* sanity check: dev should be NULL w 1101 /* sanity check: dev should be NULL when hot-plugged in */
1102 dev = pci_get_slot(bus, PCI_DEVFN(slo 1102 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0));
1103 if (dev) { 1103 if (dev) {
1104 /* This case shouldn't happen 1104 /* This case shouldn't happen */
1105 err("pci_dev structure alread 1105 err("pci_dev structure already exists.\n");
1106 pci_dev_put(dev); 1106 pci_dev_put(dev);
1107 retval = -1; 1107 retval = -1;
1108 goto err_exit; 1108 goto err_exit;
1109 } 1109 }
1110 1110
1111 num = pci_scan_slot(bus, PCI_DEVFN(sl 1111 num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
1112 if (num == 0) { 1112 if (num == 0) {
1113 err("No new device found\n"); 1113 err("No new device found\n");
1114 retval = -1; 1114 retval = -1;
1115 goto err_exit; 1115 goto err_exit;
1116 } 1116 }
1117 1117
1118 max = acpiphp_max_busnr(bus); 1118 max = acpiphp_max_busnr(bus);
1119 for (pass = 0; pass < 2; pass++) { 1119 for (pass = 0; pass < 2; pass++) {
1120 list_for_each_entry(dev, &bus 1120 list_for_each_entry(dev, &bus->devices, bus_list) {
1121 if (PCI_SLOT(dev->dev 1121 if (PCI_SLOT(dev->devfn) != slot->device)
1122 continue; 1122 continue;
1123 if (dev->hdr_type == 1123 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1124 dev->hdr_type == 1124 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
1125 max = pci_sca 1125 max = pci_scan_bridge(bus, dev, max, pass);
1126 if (pass && d 1126 if (pass && dev->subordinate)
1127 pci_b 1127 pci_bus_size_bridges(dev->subordinate);
1128 } 1128 }
1129 } 1129 }
1130 } 1130 }
1131 1131
1132 list_for_each (l, &slot->funcs) { 1132 list_for_each (l, &slot->funcs) {
1133 func = list_entry(l, struct a 1133 func = list_entry(l, struct acpiphp_func, sibling);
1134 acpiphp_bus_add(func); 1134 acpiphp_bus_add(func);
1135 } 1135 }
1136 1136
1137 pci_bus_assign_resources(bus); 1137 pci_bus_assign_resources(bus);
1138 acpiphp_sanitize_bus(bus); 1138 acpiphp_sanitize_bus(bus);
1139 acpiphp_set_hpp_values(slot->bridge-> 1139 acpiphp_set_hpp_values(slot->bridge->handle, bus);
1140 list_for_each_entry(func, &slot->func 1140 list_for_each_entry(func, &slot->funcs, sibling)
1141 acpiphp_configure_ioapics(fun 1141 acpiphp_configure_ioapics(func->handle);
1142 pci_enable_bridges(bus); 1142 pci_enable_bridges(bus);
1143 pci_bus_add_devices(bus); 1143 pci_bus_add_devices(bus);
1144 1144
1145 /* associate pci_dev to our represent 1145 /* associate pci_dev to our representation */
1146 list_for_each (l, &slot->funcs) { 1146 list_for_each (l, &slot->funcs) {
1147 func = list_entry(l, struct a 1147 func = list_entry(l, struct acpiphp_func, sibling);
1148 func->pci_dev = pci_get_slot( 1148 func->pci_dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
1149 1149 func->function));
1150 if (!func->pci_dev) 1150 if (!func->pci_dev)
1151 continue; 1151 continue;
1152 1152
1153 if (func->pci_dev->hdr_type ! 1153 if (func->pci_dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
1154 func->pci_dev->hdr_type ! 1154 func->pci_dev->hdr_type != PCI_HEADER_TYPE_CARDBUS)
1155 continue; 1155 continue;
1156 1156
1157 status = find_p2p_bridge(func 1157 status = find_p2p_bridge(func->handle, (u32)1, bus, NULL);
1158 if (ACPI_FAILURE(status)) 1158 if (ACPI_FAILURE(status))
1159 warn("find_p2p_bridge 1159 warn("find_p2p_bridge failed (error code = 0x%x)\n",
1160 status); 1160 status);
1161 } 1161 }
1162 1162
1163 slot->flags |= SLOT_ENABLED; 1163 slot->flags |= SLOT_ENABLED;
1164 1164
1165 err_exit: 1165 err_exit:
1166 return retval; 1166 return retval;
1167 } 1167 }
1168 1168
1169 static void disable_bridges(struct pci_bus *b 1169 static void disable_bridges(struct pci_bus *bus)
1170 { 1170 {
1171 struct pci_dev *dev; 1171 struct pci_dev *dev;
1172 list_for_each_entry(dev, &bus->device 1172 list_for_each_entry(dev, &bus->devices, bus_list) {
1173 if (dev->subordinate) { 1173 if (dev->subordinate) {
1174 disable_bridges(dev-> 1174 disable_bridges(dev->subordinate);
1175 pci_disable_device(de 1175 pci_disable_device(dev);
1176 } 1176 }
1177 } 1177 }
1178 } 1178 }
1179 1179
1180 /** 1180 /**
1181 * disable_device - disable a slot 1181 * disable_device - disable a slot
1182 * @slot: ACPI PHP slot 1182 * @slot: ACPI PHP slot
1183 */ 1183 */
1184 static int disable_device(struct acpiphp_slot 1184 static int disable_device(struct acpiphp_slot *slot)
1185 { 1185 {
1186 int retval = 0; 1186 int retval = 0;
1187 struct acpiphp_func *func; 1187 struct acpiphp_func *func;
1188 struct list_head *l; 1188 struct list_head *l;
1189 1189
1190 /* is this slot already disabled? */ 1190 /* is this slot already disabled? */
1191 if (!(slot->flags & SLOT_ENABLED)) 1191 if (!(slot->flags & SLOT_ENABLED))
1192 goto err_exit; 1192 goto err_exit;
1193 1193
1194 list_for_each (l, &slot->funcs) { 1194 list_for_each (l, &slot->funcs) {
1195 func = list_entry(l, struct a 1195 func = list_entry(l, struct acpiphp_func, sibling);
1196 1196
1197 if (func->bridge) { 1197 if (func->bridge) {
1198 /* cleanup p2p bridge 1198 /* cleanup p2p bridges under this P2P bridge */
1199 cleanup_p2p_bridge(fu 1199 cleanup_p2p_bridge(func->bridge->handle,
1200 1200 (u32)1, NULL, NULL);
1201 func->bridge = NULL; 1201 func->bridge = NULL;
1202 } 1202 }
1203 1203
1204 if (func->pci_dev) { 1204 if (func->pci_dev) {
1205 pci_stop_bus_device(f 1205 pci_stop_bus_device(func->pci_dev);
1206 if (func->pci_dev->su 1206 if (func->pci_dev->subordinate) {
1207 disable_bridg 1207 disable_bridges(func->pci_dev->subordinate);
1208 pci_disable_d 1208 pci_disable_device(func->pci_dev);
1209 } 1209 }
1210 } 1210 }
1211 } 1211 }
1212 1212
1213 list_for_each (l, &slot->funcs) { 1213 list_for_each (l, &slot->funcs) {
1214 func = list_entry(l, struct a 1214 func = list_entry(l, struct acpiphp_func, sibling);
1215 1215
1216 acpiphp_unconfigure_ioapics(f 1216 acpiphp_unconfigure_ioapics(func->handle);
1217 acpiphp_bus_trim(func->handle 1217 acpiphp_bus_trim(func->handle);
1218 /* try to remove anyway. 1218 /* try to remove anyway.
1219 * acpiphp_bus_add might have 1219 * acpiphp_bus_add might have been failed */
1220 1220
1221 if (!func->pci_dev) 1221 if (!func->pci_dev)
1222 continue; 1222 continue;
1223 1223
1224 pci_remove_bus_device(func->p 1224 pci_remove_bus_device(func->pci_dev);
1225 pci_dev_put(func->pci_dev); 1225 pci_dev_put(func->pci_dev);
1226 func->pci_dev = NULL; 1226 func->pci_dev = NULL;
1227 } 1227 }
1228 1228
1229 slot->flags &= (~SLOT_ENABLED); 1229 slot->flags &= (~SLOT_ENABLED);
1230 1230
1231 err_exit: 1231 err_exit:
1232 return retval; 1232 return retval;
1233 } 1233 }
1234 1234
1235 1235
1236 /** 1236 /**
1237 * get_slot_status - get ACPI slot status 1237 * get_slot_status - get ACPI slot status
1238 * @slot: ACPI PHP slot 1238 * @slot: ACPI PHP slot
1239 * 1239 *
1240 * If a slot has _STA for each function and i 1240 * If a slot has _STA for each function and if any one of them
1241 * returned non-zero status, return it. 1241 * returned non-zero status, return it.
1242 * 1242 *
1243 * If a slot doesn't have _STA and if any one 1243 * If a slot doesn't have _STA and if any one of its functions'
1244 * configuration space is configured, return 1244 * configuration space is configured, return 0x0f as a _STA.
1245 * 1245 *
1246 * Otherwise return 0. 1246 * Otherwise return 0.
1247 */ 1247 */
1248 static unsigned int get_slot_status(struct ac 1248 static unsigned int get_slot_status(struct acpiphp_slot *slot)
1249 { 1249 {
1250 acpi_status status; 1250 acpi_status status;
1251 unsigned long sta = 0; 1251 unsigned long sta = 0;
1252 u32 dvid; 1252 u32 dvid;
1253 struct list_head *l; 1253 struct list_head *l;
1254 struct acpiphp_func *func; 1254 struct acpiphp_func *func;
1255 1255
1256 list_for_each (l, &slot->funcs) { 1256 list_for_each (l, &slot->funcs) {
1257 func = list_entry(l, struct a 1257 func = list_entry(l, struct acpiphp_func, sibling);
1258 1258
1259 if (func->flags & FUNC_HAS_ST 1259 if (func->flags & FUNC_HAS_STA) {
1260 status = acpi_evaluat 1260 status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta);
1261 if (ACPI_SUCCESS(stat 1261 if (ACPI_SUCCESS(status) && sta)
1262 break; 1262 break;
1263 } else { 1263 } else {
1264 pci_bus_read_config_d 1264 pci_bus_read_config_dword(slot->bridge->pci_bus,
1265 1265 PCI_DEVFN(slot->device,
1266 1266 func->function),
1267 1267 PCI_VENDOR_ID, &dvid);
1268 if (dvid != 0xfffffff 1268 if (dvid != 0xffffffff) {
1269 sta = ACPI_ST 1269 sta = ACPI_STA_ALL;
1270 break; 1270 break;
1271 } 1271 }
1272 } 1272 }
1273 } 1273 }
1274 1274
1275 return (unsigned int)sta; 1275 return (unsigned int)sta;
1276 } 1276 }
1277 1277
1278 /** 1278 /**
1279 * acpiphp_eject_slot - physically eject the 1279 * acpiphp_eject_slot - physically eject the slot
1280 * @slot: ACPI PHP slot 1280 * @slot: ACPI PHP slot
1281 */ 1281 */
1282 int acpiphp_eject_slot(struct acpiphp_slot *s 1282 int acpiphp_eject_slot(struct acpiphp_slot *slot)
1283 { 1283 {
1284 acpi_status status; 1284 acpi_status status;
1285 struct acpiphp_func *func; 1285 struct acpiphp_func *func;
1286 struct list_head *l; 1286 struct list_head *l;
1287 struct acpi_object_list arg_list; 1287 struct acpi_object_list arg_list;
1288 union acpi_object arg; 1288 union acpi_object arg;
1289 1289
1290 list_for_each (l, &slot->funcs) { 1290 list_for_each (l, &slot->funcs) {
1291 func = list_entry(l, struct a 1291 func = list_entry(l, struct acpiphp_func, sibling);
1292 1292
1293 /* We don't want to call _EJ0 1293 /* We don't want to call _EJ0 on non-existing functions. */
1294 if ((func->flags & FUNC_HAS_E 1294 if ((func->flags & FUNC_HAS_EJ0)) {
1295 /* _EJ0 method take o 1295 /* _EJ0 method take one argument */
1296 arg_list.count = 1; 1296 arg_list.count = 1;
1297 arg_list.pointer = &a 1297 arg_list.pointer = &arg;
1298 arg.type = ACPI_TYPE_ 1298 arg.type = ACPI_TYPE_INTEGER;
1299 arg.integer.value = 1 1299 arg.integer.value = 1;
1300 1300
1301 status = acpi_evaluat 1301 status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL);
1302 if (ACPI_FAILURE(stat 1302 if (ACPI_FAILURE(status)) {
1303 warn("%s: _EJ 1303 warn("%s: _EJ0 failed\n", __FUNCTION__);
1304 return -1; 1304 return -1;
1305 } else 1305 } else
1306 break; 1306 break;
1307 } 1307 }
1308 } 1308 }
1309 return 0; 1309 return 0;
1310 } 1310 }
1311 1311
1312 /** 1312 /**
1313 * acpiphp_check_bridge - re-enumerate device 1313 * acpiphp_check_bridge - re-enumerate devices
1314 * @bridge: where to begin re-enumeration 1314 * @bridge: where to begin re-enumeration
1315 * 1315 *
1316 * Iterate over all slots under this bridge a 1316 * Iterate over all slots under this bridge and make sure that if a
1317 * card is present they are enabled, and if n 1317 * card is present they are enabled, and if not they are disabled.
1318 */ 1318 */
1319 static int acpiphp_check_bridge(struct acpiph 1319 static int acpiphp_check_bridge(struct acpiphp_bridge *bridge)
1320 { 1320 {
1321 struct acpiphp_slot *slot; 1321 struct acpiphp_slot *slot;
1322 int retval = 0; 1322 int retval = 0;
1323 int enabled, disabled; 1323 int enabled, disabled;
1324 1324
1325 enabled = disabled = 0; 1325 enabled = disabled = 0;
1326 1326
1327 for (slot = bridge->slots; slot; slot 1327 for (slot = bridge->slots; slot; slot = slot->next) {
1328 unsigned int status = get_slo 1328 unsigned int status = get_slot_status(slot);
1329 if (slot->flags & SLOT_ENABLE 1329 if (slot->flags & SLOT_ENABLED) {
1330 if (status == ACPI_ST 1330 if (status == ACPI_STA_ALL)
1331 continue; 1331 continue;
1332 retval = acpiphp_disa 1332 retval = acpiphp_disable_slot(slot);
1333 if (retval) { 1333 if (retval) {
1334 err("Error oc 1334 err("Error occurred in disabling\n");
1335 goto err_exit 1335 goto err_exit;
1336 } else { 1336 } else {
1337 acpiphp_eject 1337 acpiphp_eject_slot(slot);
1338 } 1338 }
1339 disabled++; 1339 disabled++;
1340 } else { 1340 } else {
1341 if (status != ACPI_ST 1341 if (status != ACPI_STA_ALL)
1342 continue; 1342 continue;
1343 retval = acpiphp_enab 1343 retval = acpiphp_enable_slot(slot);
1344 if (retval) { 1344 if (retval) {
1345 err("Error oc 1345 err("Error occurred in enabling\n");
1346 goto err_exit 1346 goto err_exit;
1347 } 1347 }
1348 enabled++; 1348 enabled++;
1349 } 1349 }
1350 } 1350 }
1351 1351
1352 dbg("%s: %d enabled, %d disabled\n", 1352 dbg("%s: %d enabled, %d disabled\n", __FUNCTION__, enabled, disabled);
1353 1353
1354 err_exit: 1354 err_exit:
1355 return retval; 1355 return retval;
1356 } 1356 }
1357 1357
1358 static void program_hpp(struct pci_dev *dev, 1358 static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
1359 { 1359 {
1360 u16 pci_cmd, pci_bctl; 1360 u16 pci_cmd, pci_bctl;
1361 struct pci_dev *cdev; 1361 struct pci_dev *cdev;
1362 1362
1363 /* Program hpp values for this device 1363 /* Program hpp values for this device */
1364 if (!(dev->hdr_type == PCI_HEADER_TYP 1364 if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL ||
1365 (dev->hdr_type == PCI 1365 (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE &&
1366 (dev->class >> 8) == 1366 (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
1367 return; 1367 return;
1368 1368
1369 if ((dev->class >> 8) == PCI_CLASS_BR 1369 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
1370 return; 1370 return;
1371 1371
1372 pci_write_config_byte(dev, PCI_CACHE_ 1372 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE,
1373 bridge->hpp.t0->cache 1373 bridge->hpp.t0->cache_line_size);
1374 pci_write_config_byte(dev, PCI_LATENC 1374 pci_write_config_byte(dev, PCI_LATENCY_TIMER,
1375 bridge->hpp.t0->laten 1375 bridge->hpp.t0->latency_timer);
1376 pci_read_config_word(dev, PCI_COMMAND 1376 pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
1377 if (bridge->hpp.t0->enable_serr) 1377 if (bridge->hpp.t0->enable_serr)
1378 pci_cmd |= PCI_COMMAND_SERR; 1378 pci_cmd |= PCI_COMMAND_SERR;
1379 else 1379 else
1380 pci_cmd &= ~PCI_COMMAND_SERR; 1380 pci_cmd &= ~PCI_COMMAND_SERR;
1381 if (bridge->hpp.t0->enable_perr) 1381 if (bridge->hpp.t0->enable_perr)
1382 pci_cmd |= PCI_COMMAND_PARITY 1382 pci_cmd |= PCI_COMMAND_PARITY;
1383 else 1383 else
1384 pci_cmd &= ~PCI_COMMAND_PARIT 1384 pci_cmd &= ~PCI_COMMAND_PARITY;
1385 pci_write_config_word(dev, PCI_COMMAN 1385 pci_write_config_word(dev, PCI_COMMAND, pci_cmd);
1386 1386
1387 /* Program bridge control value and c 1387 /* Program bridge control value and child devices */
1388 if ((dev->class >> 8) == PCI_CLASS_BR 1388 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
1389 pci_write_config_byte(dev, PC 1389 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
1390 bridge->hpp.t 1390 bridge->hpp.t0->latency_timer);
1391 pci_read_config_word(dev, PCI 1391 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
1392 if (bridge->hpp.t0->enable_se 1392 if (bridge->hpp.t0->enable_serr)
1393 pci_bctl |= PCI_BRIDG 1393 pci_bctl |= PCI_BRIDGE_CTL_SERR;
1394 else 1394 else
1395 pci_bctl &= ~PCI_BRID 1395 pci_bctl &= ~PCI_BRIDGE_CTL_SERR;
1396 if (bridge->hpp.t0->enable_pe 1396 if (bridge->hpp.t0->enable_perr)
1397 pci_bctl |= PCI_BRIDG 1397 pci_bctl |= PCI_BRIDGE_CTL_PARITY;
1398 else 1398 else
1399 pci_bctl &= ~PCI_BRID 1399 pci_bctl &= ~PCI_BRIDGE_CTL_PARITY;
1400 pci_write_config_word(dev, PC 1400 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl);
1401 if (dev->subordinate) { 1401 if (dev->subordinate) {
1402 list_for_each_entry(c 1402 list_for_each_entry(cdev, &dev->subordinate->devices,
1403 bus_l 1403 bus_list)
1404 program_hpp(c 1404 program_hpp(cdev, bridge);
1405 } 1405 }
1406 } 1406 }
1407 } 1407 }
1408 1408
1409 static void acpiphp_set_hpp_values(acpi_handl 1409 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus)
1410 { 1410 {
1411 struct acpiphp_bridge bridge; 1411 struct acpiphp_bridge bridge;
1412 struct pci_dev *dev; 1412 struct pci_dev *dev;
1413 1413
1414 memset(&bridge, 0, sizeof(bridge)); 1414 memset(&bridge, 0, sizeof(bridge));
1415 bridge.handle = handle; 1415 bridge.handle = handle;
1416 bridge.pci_bus = bus; 1416 bridge.pci_bus = bus;
1417 bridge.pci_dev = bus->self; 1417 bridge.pci_dev = bus->self;
1418 decode_hpp(&bridge); 1418 decode_hpp(&bridge);
1419 list_for_each_entry(dev, &bus->device 1419 list_for_each_entry(dev, &bus->devices, bus_list)
1420 program_hpp(dev, &bridge); 1420 program_hpp(dev, &bridge);
1421 1421
1422 } 1422 }
1423 1423
1424 /* 1424 /*
1425 * Remove devices for which we could not assi 1425 * Remove devices for which we could not assign resources, call
1426 * arch specific code to fix-up the bus 1426 * arch specific code to fix-up the bus
1427 */ 1427 */
1428 static void acpiphp_sanitize_bus(struct pci_b 1428 static void acpiphp_sanitize_bus(struct pci_bus *bus)
1429 { 1429 {
1430 struct pci_dev *dev; 1430 struct pci_dev *dev;
1431 int i; 1431 int i;
1432 unsigned long type_mask = IORESOURCE_ 1432 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
1433 1433
1434 list_for_each_entry(dev, &bus->device 1434 list_for_each_entry(dev, &bus->devices, bus_list) {
1435 for (i=0; i<PCI_BRIDGE_RESOUR 1435 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
1436 struct resource *res 1436 struct resource *res = &dev->resource[i];
1437 if ((res->flags & typ 1437 if ((res->flags & type_mask) && !res->start &&
1438 res-> 1438 res->end) {
1439 /* Could not 1439 /* Could not assign a required resources
1440 * for this d 1440 * for this device, remove it */
1441 pci_remove_bu 1441 pci_remove_bus_device(dev);
1442 break; 1442 break;
1443 } 1443 }
1444 } 1444 }
1445 } 1445 }
1446 } 1446 }
1447 1447
1448 /* Program resources in newly inserted bridge 1448 /* Program resources in newly inserted bridge */
1449 static int acpiphp_configure_bridge (acpi_han 1449 static int acpiphp_configure_bridge (acpi_handle handle)
1450 { 1450 {
1451 struct acpi_pci_id pci_id; 1451 struct acpi_pci_id pci_id;
1452 struct pci_bus *bus; 1452 struct pci_bus *bus;
1453 1453
1454 if (ACPI_FAILURE(acpi_get_pci_id(hand 1454 if (ACPI_FAILURE(acpi_get_pci_id(handle, &pci_id))) {
1455 err("cannot get PCI domain an 1455 err("cannot get PCI domain and bus number for bridge\n");
1456 return -EINVAL; 1456 return -EINVAL;
1457 } 1457 }
1458 bus = pci_find_bus(pci_id.segment, pc 1458 bus = pci_find_bus(pci_id.segment, pci_id.bus);
1459 if (!bus) { 1459 if (!bus) {
1460 err("cannot find bus %d:%d\n" 1460 err("cannot find bus %d:%d\n",
1461 pci_id.segmen 1461 pci_id.segment, pci_id.bus);
1462 return -EINVAL; 1462 return -EINVAL;
1463 } 1463 }
1464 1464
1465 pci_bus_size_bridges(bus); 1465 pci_bus_size_bridges(bus);
1466 pci_bus_assign_resources(bus); 1466 pci_bus_assign_resources(bus);
1467 acpiphp_sanitize_bus(bus); 1467 acpiphp_sanitize_bus(bus);
1468 acpiphp_set_hpp_values(handle, bus); 1468 acpiphp_set_hpp_values(handle, bus);
1469 pci_enable_bridges(bus); 1469 pci_enable_bridges(bus);
1470 acpiphp_configure_ioapics(handle); 1470 acpiphp_configure_ioapics(handle);
1471 return 0; 1471 return 0;
1472 } 1472 }
1473 1473
1474 static void handle_bridge_insertion(acpi_hand 1474 static void handle_bridge_insertion(acpi_handle handle, u32 type)
1475 { 1475 {
1476 struct acpi_device *device, *pdevice; 1476 struct acpi_device *device, *pdevice;
1477 acpi_handle phandle; 1477 acpi_handle phandle;
1478 1478
1479 if ((type != ACPI_NOTIFY_BUS_CHECK) & 1479 if ((type != ACPI_NOTIFY_BUS_CHECK) &&
1480 (type != ACPI_NOTIFY_ 1480 (type != ACPI_NOTIFY_DEVICE_CHECK)) {
1481 err("unexpected notification 1481 err("unexpected notification type %d\n", type);
1482 return; 1482 return;
1483 } 1483 }
1484 1484
1485 acpi_get_parent(handle, &phandle); 1485 acpi_get_parent(handle, &phandle);
1486 if (acpi_bus_get_device(phandle, &pde 1486 if (acpi_bus_get_device(phandle, &pdevice)) {
1487 dbg("no parent device, assumi 1487 dbg("no parent device, assuming NULL\n");
1488 pdevice = NULL; 1488 pdevice = NULL;
1489 } 1489 }
1490 if (acpi_bus_add(&device, pdevice, ha 1490 if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) {
1491 err("cannot add bridge to acp 1491 err("cannot add bridge to acpi list\n");
1492 return; 1492 return;
1493 } 1493 }
1494 if (!acpiphp_configure_bridge(handle) 1494 if (!acpiphp_configure_bridge(handle) &&
1495 !acpi_bus_start(device)) 1495 !acpi_bus_start(device))
1496 add_bridge(handle); 1496 add_bridge(handle);
1497 else 1497 else
1498 err("cannot configure and sta 1498 err("cannot configure and start bridge\n");
1499 1499
1500 } 1500 }
1501 1501
1502 /* 1502 /*
1503 * ACPI event handlers 1503 * ACPI event handlers
1504 */ 1504 */
1505 1505
1506 static acpi_status 1506 static acpi_status
1507 count_sub_bridges(acpi_handle handle, u32 lvl 1507 count_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1508 { 1508 {
1509 int *count = (int *)context; 1509 int *count = (int *)context;
1510 struct acpiphp_bridge *bridge; 1510 struct acpiphp_bridge *bridge;
1511 1511
1512 bridge = acpiphp_handle_to_bridge(han 1512 bridge = acpiphp_handle_to_bridge(handle);
1513 if (bridge) 1513 if (bridge)
1514 (*count)++; 1514 (*count)++;
1515 return AE_OK ; 1515 return AE_OK ;
1516 } 1516 }
1517 1517
1518 static acpi_status 1518 static acpi_status
1519 check_sub_bridges(acpi_handle handle, u32 lvl 1519 check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1520 { 1520 {
1521 struct acpiphp_bridge *bridge; 1521 struct acpiphp_bridge *bridge;
1522 char objname[64]; 1522 char objname[64];
1523 struct acpi_buffer buffer = { .length 1523 struct acpi_buffer buffer = { .length = sizeof(objname),
1524 .pointe 1524 .pointer = objname };
1525 1525
1526 bridge = acpiphp_handle_to_bridge(han 1526 bridge = acpiphp_handle_to_bridge(handle);
1527 if (bridge) { 1527 if (bridge) {
1528 acpi_get_name(handle, ACPI_FU 1528 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1529 dbg("%s: re-enumerating slots 1529 dbg("%s: re-enumerating slots under %s\n",
1530 __FUNCTION__, objname 1530 __FUNCTION__, objname);
1531 acpiphp_check_bridge(bridge); 1531 acpiphp_check_bridge(bridge);
1532 } 1532 }
1533 return AE_OK ; 1533 return AE_OK ;
1534 } 1534 }
1535 1535
1536 /** 1536 /**
1537 * handle_hotplug_event_bridge - handle ACPI 1537 * handle_hotplug_event_bridge - handle ACPI event on bridges
1538 * @handle: Notify()'ed acpi_handle 1538 * @handle: Notify()'ed acpi_handle
1539 * @type: Notify code 1539 * @type: Notify code
1540 * @context: pointer to acpiphp_bridge struct 1540 * @context: pointer to acpiphp_bridge structure
1541 * 1541 *
1542 * Handles ACPI event notification on {host,p 1542 * Handles ACPI event notification on {host,p2p} bridges.
1543 */ 1543 */
1544 static void handle_hotplug_event_bridge(acpi_ 1544 static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *context)
1545 { 1545 {
1546 struct acpiphp_bridge *bridge; 1546 struct acpiphp_bridge *bridge;
1547 char objname[64]; 1547 char objname[64];
1548 struct acpi_buffer buffer = { .length 1548 struct acpi_buffer buffer = { .length = sizeof(objname),
1549 .pointe 1549 .pointer = objname };
1550 struct acpi_device *device; 1550 struct acpi_device *device;
1551 int num_sub_bridges = 0; 1551 int num_sub_bridges = 0;
1552 1552
1553 if (acpi_bus_get_device(handle, &devi 1553 if (acpi_bus_get_device(handle, &device)) {
1554 /* This bridge must have just 1554 /* This bridge must have just been physically inserted */
1555 handle_bridge_insertion(handl 1555 handle_bridge_insertion(handle, type);
1556 return; 1556 return;
1557 } 1557 }
1558 1558
1559 bridge = acpiphp_handle_to_bridge(han 1559 bridge = acpiphp_handle_to_bridge(handle);
1560 if (type == ACPI_NOTIFY_BUS_CHECK) { 1560 if (type == ACPI_NOTIFY_BUS_CHECK) {
1561 acpi_walk_namespace(ACPI_TYPE 1561 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, ACPI_UINT32_MAX,
1562 count_sub_bridges, &n 1562 count_sub_bridges, &num_sub_bridges, NULL);
1563 } 1563 }
1564 1564
1565 if (!bridge && !num_sub_bridges) { 1565 if (!bridge && !num_sub_bridges) {
1566 err("cannot get bridge info\n 1566 err("cannot get bridge info\n");
1567 return; 1567 return;
1568 } 1568 }
1569 1569
1570 acpi_get_name(handle, ACPI_FULL_PATHN 1570 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1571 1571
1572 switch (type) { 1572 switch (type) {
1573 case ACPI_NOTIFY_BUS_CHECK: 1573 case ACPI_NOTIFY_BUS_CHECK:
1574 /* bus re-enumerate */ 1574 /* bus re-enumerate */
1575 dbg("%s: Bus check notify on 1575 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname);
1576 if (bridge) { 1576 if (bridge) {
1577 dbg("%s: re-enumerati 1577 dbg("%s: re-enumerating slots under %s\n",
1578 __FUNCTION__, 1578 __FUNCTION__, objname);
1579 acpiphp_check_bridge( 1579 acpiphp_check_bridge(bridge);
1580 } 1580 }
1581 if (num_sub_bridges) 1581 if (num_sub_bridges)
1582 acpi_walk_namespace(A 1582 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
1583 ACPI_UINT32_M 1583 ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL);
1584 break; 1584 break;
1585 1585
1586 case ACPI_NOTIFY_DEVICE_CHECK: 1586 case ACPI_NOTIFY_DEVICE_CHECK:
1587 /* device check */ 1587 /* device check */
1588 dbg("%s: Device check notify 1588 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname);
1589 acpiphp_check_bridge(bridge); 1589 acpiphp_check_bridge(bridge);
1590 break; 1590 break;
1591 1591
1592 case ACPI_NOTIFY_DEVICE_WAKE: 1592 case ACPI_NOTIFY_DEVICE_WAKE:
1593 /* wake event */ 1593 /* wake event */
1594 dbg("%s: Device wake notify o 1594 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname);
1595 break; 1595 break;
1596 1596
1597 case ACPI_NOTIFY_EJECT_REQUEST: 1597 case ACPI_NOTIFY_EJECT_REQUEST:
1598 /* request device eject */ 1598 /* request device eject */
1599 dbg("%s: Device eject notify 1599 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname);
1600 if ((bridge->type != BRIDGE_T 1600 if ((bridge->type != BRIDGE_TYPE_HOST) &&
1601 (bridge->flags & BRIDGE_H 1601 (bridge->flags & BRIDGE_HAS_EJ0)) {
1602 struct acpiphp_slot * 1602 struct acpiphp_slot *slot;
1603 slot = bridge->func-> 1603 slot = bridge->func->slot;
1604 if (!acpiphp_disable_ 1604 if (!acpiphp_disable_slot(slot))
1605 acpiphp_eject 1605 acpiphp_eject_slot(slot);
1606 } 1606 }
1607 break; 1607 break;
1608 1608
1609 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 1609 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
1610 printk(KERN_ERR "Device %s ca 1610 printk(KERN_ERR "Device %s cannot be configured due"
1611 " to a freque 1611 " to a frequency mismatch\n", objname);
1612 break; 1612 break;
1613 1613
1614 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 1614 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
1615 printk(KERN_ERR "Device %s ca 1615 printk(KERN_ERR "Device %s cannot be configured due"
1616 " to a bus mo 1616 " to a bus mode mismatch\n", objname);
1617 break; 1617 break;
1618 1618
1619 case ACPI_NOTIFY_POWER_FAULT: 1619 case ACPI_NOTIFY_POWER_FAULT:
1620 printk(KERN_ERR "Device %s ha 1620 printk(KERN_ERR "Device %s has suffered a power fault\n",
1621 objname); 1621 objname);
1622 break; 1622 break;
1623 1623
1624 default: 1624 default:
1625 warn("notify_handler: unknown 1625 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1626 break; 1626 break;
1627 } 1627 }
1628 } 1628 }
1629 1629
1630 /** 1630 /**
1631 * handle_hotplug_event_func - handle ACPI ev 1631 * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots)
1632 * @handle: Notify()'ed acpi_handle 1632 * @handle: Notify()'ed acpi_handle
1633 * @type: Notify code 1633 * @type: Notify code
1634 * @context: pointer to acpiphp_func structur 1634 * @context: pointer to acpiphp_func structure
1635 * 1635 *
1636 * Handles ACPI event notification on slots. 1636 * Handles ACPI event notification on slots.
1637 */ 1637 */
1638 static void handle_hotplug_event_func(acpi_ha 1638 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context)
1639 { 1639 {
1640 struct acpiphp_func *func; 1640 struct acpiphp_func *func;
1641 char objname[64]; 1641 char objname[64];
1642 struct acpi_buffer buffer = { .length 1642 struct acpi_buffer buffer = { .length = sizeof(objname),
1643 .pointe 1643 .pointer = objname };
1644 1644
1645 acpi_get_name(handle, ACPI_FULL_PATHN 1645 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1646 1646
1647 func = (struct acpiphp_func *)context 1647 func = (struct acpiphp_func *)context;
1648 1648
1649 switch (type) { 1649 switch (type) {
1650 case ACPI_NOTIFY_BUS_CHECK: 1650 case ACPI_NOTIFY_BUS_CHECK:
1651 /* bus re-enumerate */ 1651 /* bus re-enumerate */
1652 dbg("%s: Bus check notify on 1652 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname);
1653 acpiphp_enable_slot(func->slo 1653 acpiphp_enable_slot(func->slot);
1654 break; 1654 break;
1655 1655
1656 case ACPI_NOTIFY_DEVICE_CHECK: 1656 case ACPI_NOTIFY_DEVICE_CHECK:
1657 /* device check : re-enumerat 1657 /* device check : re-enumerate from parent bus */
1658 dbg("%s: Device check notify 1658 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname);
1659 acpiphp_check_bridge(func->sl 1659 acpiphp_check_bridge(func->slot->bridge);
1660 break; 1660 break;
1661 1661
1662 case ACPI_NOTIFY_DEVICE_WAKE: 1662 case ACPI_NOTIFY_DEVICE_WAKE:
1663 /* wake event */ 1663 /* wake event */
1664 dbg("%s: Device wake notify o 1664 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname);
1665 break; 1665 break;
1666 1666
1667 case ACPI_NOTIFY_EJECT_REQUEST: 1667 case ACPI_NOTIFY_EJECT_REQUEST:
1668 /* request device eject */ 1668 /* request device eject */
1669 dbg("%s: Device eject notify 1669 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname);
1670 if (!(acpiphp_disable_slot(fu 1670 if (!(acpiphp_disable_slot(func->slot)))
1671 acpiphp_eject_slot(fu 1671 acpiphp_eject_slot(func->slot);
1672 break; 1672 break;
1673 1673
1674 default: 1674 default:
1675 warn("notify_handler: unknown 1675 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
1676 break; 1676 break;
1677 } 1677 }
1678 } 1678 }
1679 1679
1680 1680
1681 static acpi_status 1681 static acpi_status
1682 find_root_bridges(acpi_handle handle, u32 lvl 1682 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
1683 { 1683 {
1684 int *count = (int *)context; 1684 int *count = (int *)context;
1685 1685
1686 if (acpi_root_bridge(handle)) { 1686 if (acpi_root_bridge(handle)) {
1687 acpi_install_notify_handler(h 1687 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1688 handle_hotplu 1688 handle_hotplug_event_bridge, NULL);
1689 (*count)++; 1689 (*count)++;
1690 } 1690 }
1691 return AE_OK ; 1691 return AE_OK ;
1692 } 1692 }
1693 1693
1694 static struct acpi_pci_driver acpi_pci_hp_dri 1694 static struct acpi_pci_driver acpi_pci_hp_driver = {
1695 .add = add_bridge, 1695 .add = add_bridge,
1696 .remove = remove_bridge, 1696 .remove = remove_bridge,
1697 }; 1697 };
1698 1698
1699 /** 1699 /**
1700 * acpiphp_glue_init - initializes all PCI ho 1700 * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures
1701 */ 1701 */
1702 int __init acpiphp_glue_init(void) 1702 int __init acpiphp_glue_init(void)
1703 { 1703 {
1704 int num = 0; 1704 int num = 0;
1705 1705
1706 acpi_walk_namespace(ACPI_TYPE_DEVICE, 1706 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1707 ACPI_UINT32_MAX, find 1707 ACPI_UINT32_MAX, find_root_bridges, &num, NULL);
1708 1708
1709 if (num <= 0) 1709 if (num <= 0)
1710 return -1; 1710 return -1;
1711 else 1711 else
1712 acpi_pci_register_driver(&acp 1712 acpi_pci_register_driver(&acpi_pci_hp_driver);
1713 1713
1714 return 0; 1714 return 0;
1715 } 1715 }
1716 1716
1717 1717
1718 /** 1718 /**
1719 * acpiphp_glue_exit - terminates all PCI hot 1719 * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures
1720 * 1720 *
1721 * This function frees all data allocated in 1721 * This function frees all data allocated in acpiphp_glue_init().
1722 */ 1722 */
1723 void acpiphp_glue_exit(void) 1723 void acpiphp_glue_exit(void)
1724 { 1724 {
1725 acpi_pci_unregister_driver(&acpi_pci_ 1725 acpi_pci_unregister_driver(&acpi_pci_hp_driver);
1726 } 1726 }
1727 1727
1728 1728
1729 /** 1729 /**
1730 * acpiphp_get_num_slots - count number of sl 1730 * acpiphp_get_num_slots - count number of slots in a system
1731 */ 1731 */
1732 int __init acpiphp_get_num_slots(void) 1732 int __init acpiphp_get_num_slots(void)
1733 { 1733 {
1734 struct acpiphp_bridge *bridge; 1734 struct acpiphp_bridge *bridge;
1735 int num_slots = 0; 1735 int num_slots = 0;
1736 1736
1737 list_for_each_entry (bridge, &bridge_ 1737 list_for_each_entry (bridge, &bridge_list, list) {
1738 dbg("Bus %04x:%02x has %d slo 1738 dbg("Bus %04x:%02x has %d slot%s\n",
1739 pci_domain_nr 1739 pci_domain_nr(bridge->pci_bus),
1740 bridge->pci_b 1740 bridge->pci_bus->number, bridge->nr_slots,
1741 bridge->nr_sl 1741 bridge->nr_slots == 1 ? "" : "s");
1742 num_slots += bridge->nr_slots 1742 num_slots += bridge->nr_slots;
1743 } 1743 }
1744 1744
1745 dbg("Total %d slots\n", num_slots); 1745 dbg("Total %d slots\n", num_slots);
1746 return num_slots; 1746 return num_slots;
1747 } 1747 }
1748 1748
1749 1749
1750 #if 0 1750 #if 0
1751 /** 1751 /**
1752 * acpiphp_for_each_slot - call function for 1752 * acpiphp_for_each_slot - call function for each slot
1753 * @fn: callback function 1753 * @fn: callback function
1754 * @data: context to be passed to callback fu 1754 * @data: context to be passed to callback function
1755 */ 1755 */
1756 static int acpiphp_for_each_slot(acpiphp_call 1756 static int acpiphp_for_each_slot(acpiphp_callback fn, void *data)
1757 { 1757 {
1758 struct list_head *node; 1758 struct list_head *node;
1759 struct acpiphp_bridge *bridge; 1759 struct acpiphp_bridge *bridge;
1760 struct acpiphp_slot *slot; 1760 struct acpiphp_slot *slot;
1761 int retval = 0; 1761 int retval = 0;
1762 1762
1763 list_for_each (node, &bridge_list) { 1763 list_for_each (node, &bridge_list) {
1764 bridge = (struct acpiphp_brid 1764 bridge = (struct acpiphp_bridge *)node;
1765 for (slot = bridge->slots; sl 1765 for (slot = bridge->slots; slot; slot = slot->next) {
1766 retval = fn(slot, dat 1766 retval = fn(slot, data);
1767 if (!retval) 1767 if (!retval)
1768 goto err_exit 1768 goto err_exit;
1769 } 1769 }
1770 } 1770 }
1771 1771
1772 err_exit: 1772 err_exit:
1773 return retval; 1773 return retval;
1774 } 1774 }
1775 #endif 1775 #endif
1776 1776
1777 1777
1778 /** 1778 /**
1779 * acpiphp_enable_slot - power on slot 1779 * acpiphp_enable_slot - power on slot
1780 * @slot: ACPI PHP slot 1780 * @slot: ACPI PHP slot
1781 */ 1781 */
1782 int acpiphp_enable_slot(struct acpiphp_slot * 1782 int acpiphp_enable_slot(struct acpiphp_slot *slot)
1783 { 1783 {
1784 int retval; 1784 int retval;
1785 1785
1786 mutex_lock(&slot->crit_sect); 1786 mutex_lock(&slot->crit_sect);
1787 1787
1788 /* wake up all functions */ 1788 /* wake up all functions */
1789 retval = power_on_slot(slot); 1789 retval = power_on_slot(slot);
1790 if (retval) 1790 if (retval)
1791 goto err_exit; 1791 goto err_exit;
1792 1792
1793 if (get_slot_status(slot) == ACPI_STA 1793 if (get_slot_status(slot) == ACPI_STA_ALL) {
1794 /* configure all functions */ 1794 /* configure all functions */
1795 retval = enable_device(slot); 1795 retval = enable_device(slot);
1796 if (retval) 1796 if (retval)
1797 power_off_slot(slot); 1797 power_off_slot(slot);
1798 } else { 1798 } else {
1799 dbg("%s: Slot status is not A 1799 dbg("%s: Slot status is not ACPI_STA_ALL\n", __FUNCTION__);
1800 power_off_slot(slot); 1800 power_off_slot(slot);
1801 } 1801 }
1802 1802
1803 err_exit: 1803 err_exit:
1804 mutex_unlock(&slot->crit_sect); 1804 mutex_unlock(&slot->crit_sect);
1805 return retval; 1805 return retval;
1806 } 1806 }
1807 1807
1808 /** 1808 /**
1809 * acpiphp_disable_slot - power off slot 1809 * acpiphp_disable_slot - power off slot
1810 * @slot: ACPI PHP slot 1810 * @slot: ACPI PHP slot
1811 */ 1811 */
1812 int acpiphp_disable_slot(struct acpiphp_slot 1812 int acpiphp_disable_slot(struct acpiphp_slot *slot)
1813 { 1813 {
1814 int retval = 0; 1814 int retval = 0;
1815 1815
1816 mutex_lock(&slot->crit_sect); 1816 mutex_lock(&slot->crit_sect);
1817 1817
1818 /* unconfigure all functions */ 1818 /* unconfigure all functions */
1819 retval = disable_device(slot); 1819 retval = disable_device(slot);
1820 if (retval) 1820 if (retval)
1821 goto err_exit; 1821 goto err_exit;
1822 1822
1823 /* power off all functions */ 1823 /* power off all functions */
1824 retval = power_off_slot(slot); 1824 retval = power_off_slot(slot);
1825 if (retval) 1825 if (retval)
1826 goto err_exit; 1826 goto err_exit;
1827 1827
1828 err_exit: 1828 err_exit:
1829 mutex_unlock(&slot->crit_sect); 1829 mutex_unlock(&slot->crit_sect);
1830 return retval; 1830 return retval;
1831 } 1831 }
1832 1832
1833 1833
1834 /* 1834 /*
1835 * slot enabled: 1 1835 * slot enabled: 1
1836 * slot disabled: 0 1836 * slot disabled: 0
1837 */ 1837 */
1838 u8 acpiphp_get_power_status(struct acpiphp_sl 1838 u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
1839 { 1839 {
1840 return (slot->flags & SLOT_POWEREDON) 1840 return (slot->flags & SLOT_POWEREDON);
1841 } 1841 }
1842 1842
1843 1843
1844 /* 1844 /*
1845 * latch open: 1 1845 * latch open: 1
1846 * latch closed: 0 1846 * latch closed: 0
1847 */ 1847 */
1848 u8 acpiphp_get_latch_status(struct acpiphp_sl 1848 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
1849 { 1849 {
1850 unsigned int sta; 1850 unsigned int sta;
1851 1851
1852 sta = get_slot_status(slot); 1852 sta = get_slot_status(slot);
1853 1853
1854 return (sta & ACPI_STA_SHOW_IN_UI) ? 1854 return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1;
1855 } 1855 }
1856 1856
1857 1857
1858 /* 1858 /*
1859 * adapter presence : 1 1859 * adapter presence : 1
1860 * absence : 0 1860 * absence : 0
1861 */ 1861 */
1862 u8 acpiphp_get_adapter_status(struct acpiphp_ 1862 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
1863 { 1863 {
1864 unsigned int sta; 1864 unsigned int sta;
1865 1865
1866 sta = get_slot_status(slot); 1866 sta = get_slot_status(slot);
1867 1867
1868 return (sta == 0) ? 0 : 1; 1868 return (sta == 0) ? 0 : 1;
1869 } 1869 }
1870 1870
1871 1871
1872 /* 1872 /*
1873 * pci address (seg/bus/dev) 1873 * pci address (seg/bus/dev)
1874 */ 1874 */
1875 u32 acpiphp_get_address(struct acpiphp_slot * 1875 u32 acpiphp_get_address(struct acpiphp_slot *slot)
1876 { 1876 {
1877 u32 address; 1877 u32 address;
1878 struct pci_bus *pci_bus = slot->bridg 1878 struct pci_bus *pci_bus = slot->bridge->pci_bus;
1879 1879
1880 address = (pci_domain_nr(pci_bus) << 1880 address = (pci_domain_nr(pci_bus) << 16) |
1881 (pci_bus->number << 8) | 1881 (pci_bus->number << 8) |
1882 slot->device; 1882 slot->device;
1883 1883
1884 return address; 1884 return address;
1885 } 1885 }
1886 1886
|
This page was automatically generated by the
LXR engine.
|