acpiphp_glue.c 34.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6
/*
 * ACPI PCI HotPlug glue functions to ACPI CA subsystem
 *
 * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
 * Copyright (C) 2002,2003 NEC Corporation
7 8
 * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com)
 * Copyright (C) 2003-2005 Hewlett Packard
9 10
 * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com)
 * Copyright (C) 2005 Intel Corporation
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
29
 * Send feedback to <kristen.c.accardi@intel.com>
Linus Torvalds's avatar
Linus Torvalds committed
30 31 32
 *
 */

33 34 35 36 37
/*
 * Lifetime rules for pci_dev:
 *  - The one in acpiphp_bridge has its refcount elevated by pci_get_slot()
 *    when the bridge is scanned and it loses a refcount when the bridge
 *    is removed.
38 39
 *  - When a P2P bridge is present, we elevate the refcount on the subordinate
 *    bus. It loses the refcount when the the driver unloads.
40 41
 */

Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45 46
#include <linux/init.h>
#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/pci.h>
47
#include <linux/pci_hotplug.h>
48
#include <linux/pci-acpi.h>
49
#include <linux/mutex.h>
50
#include <linux/slab.h>
51
#include <linux/acpi.h>
Linus Torvalds's avatar
Linus Torvalds committed
52 53 54 55 56 57 58 59 60

#include "../pci.h"
#include "acpiphp.h"

static LIST_HEAD(bridge_list);

#define MY_NAME "acpiphp_glue"

static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
61
static void acpiphp_sanitize_bus(struct pci_bus *bus);
62
static void acpiphp_set_hpp_values(struct pci_bus *bus);
63
static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context);
64

65
/* callback routine to check for the existence of a pci dock device */
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
static acpi_status
is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	int *count = (int *)context;

	if (is_dock_device(handle)) {
		(*count)++;
		return AE_CTRL_TERMINATE;
	} else {
		return AE_OK;
	}
}

/*
 * the _DCK method can do funny things... and sometimes not
 * hah-hah funny.
 *
 * TBD - figure out a way to only call fixups for
 * systems that require them.
 */
static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
	void *v)
{
	struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb);
	struct pci_bus *bus = func->slot->bridge->pci_bus;
	u32 buses;

	if (!bus->self)
		return  NOTIFY_OK;

	/* fixup bad _DCK function that rewrites
	 * secondary bridge on slot
	 */
	pci_read_config_dword(bus->self,
			PCI_PRIMARY_BUS,
			&buses);

103
	if (((buses >> 8) & 0xff) != bus->busn_res.start) {
104
		buses = (buses & 0xff000000)
105
			| ((unsigned int)(bus->primary)     <<  0)
106 107
			| ((unsigned int)(bus->busn_res.start)   <<  8)
			| ((unsigned int)(bus->busn_res.end) << 16);
108 109 110 111 112 113
		pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
	}
	return NOTIFY_OK;
}


Vasiliy Kulikov's avatar
Vasiliy Kulikov committed
114
static const struct acpi_dock_ops acpiphp_dock_ops = {
115 116
	.handler = handle_hotplug_event_func,
};
Linus Torvalds's avatar
Linus Torvalds committed
117

118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
/* Check whether the PCI device is managed by native PCIe hotplug driver */
static bool device_is_managed_by_native_pciehp(struct pci_dev *pdev)
{
	u32 reg32;
	acpi_handle tmp;
	struct acpi_pci_root *root;

	/* Check whether the PCIe port supports native PCIe hotplug */
	if (pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32))
		return false;
	if (!(reg32 & PCI_EXP_SLTCAP_HPC))
		return false;

	/*
	 * Check whether native PCIe hotplug has been enabled for
	 * this PCIe hierarchy.
	 */
	tmp = acpi_find_root_bridge_handle(pdev);
	if (!tmp)
		return false;
	root = acpi_pci_find_root(tmp);
	if (!root)
		return false;
	if (!(root->osc_control_set & OSC_PCI_EXPRESS_NATIVE_HP_CONTROL))
		return false;

	return true;
}

Linus Torvalds's avatar
Linus Torvalds committed
147 148 149 150 151 152 153 154 155
/* callback routine to register each ACPI PCI slot object */
static acpi_status
register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context;
	struct acpiphp_slot *slot;
	struct acpiphp_func *newfunc;
	acpi_handle tmp;
	acpi_status status = AE_OK;
156
	unsigned long long adr, sun;
157
	int device, function, retval;
158
	struct pci_bus *pbus = bridge->pci_bus;
159
	struct pci_dev *pdev;
Linus Torvalds's avatar
Linus Torvalds committed
160

161
	if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle))
Linus Torvalds's avatar
Linus Torvalds committed
162 163
		return AE_OK;

164 165 166 167 168 169 170 171 172
	status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
	if (ACPI_FAILURE(status)) {
		warn("can't evaluate _ADR (%#x)\n", status);
		return AE_OK;
	}

	device = (adr >> 16) & 0xffff;
	function = adr & 0xffff;

173
	pdev = pbus->self;
174 175
	if (pdev && device_is_managed_by_native_pciehp(pdev))
		return AE_OK;
176

177
	newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180 181 182 183
	if (!newfunc)
		return AE_NO_MEMORY;

	INIT_LIST_HEAD(&newfunc->sibling);
	newfunc->handle = handle;
	newfunc->function = function;
184 185

	if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
186
		newfunc->flags = FUNC_HAS_EJ0;
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195 196

	if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
		newfunc->flags |= FUNC_HAS_STA;

	if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp)))
		newfunc->flags |= FUNC_HAS_PS0;

	if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp)))
		newfunc->flags |= FUNC_HAS_PS3;

197
	if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp)))
198 199
		newfunc->flags |= FUNC_HAS_DCK;

Linus Torvalds's avatar
Linus Torvalds committed
200
	status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
201 202 203 204 205 206 207
	if (ACPI_FAILURE(status)) {
		/*
		 * use the count of the number of slots we've found
		 * for the number of the slot
		 */
		sun = bridge->nr_slots+1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211 212 213 214 215 216 217

	/* search for objects that share the same slot */
	for (slot = bridge->slots; slot; slot = slot->next)
		if (slot->device == device) {
			if (slot->sun != sun)
				warn("sibling found, but _SUN doesn't match!\n");
			break;
		}

	if (!slot) {
218
		slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223 224 225 226 227
		if (!slot) {
			kfree(newfunc);
			return AE_NO_MEMORY;
		}

		slot->bridge = bridge;
		slot->device = device;
		slot->sun = sun;
		INIT_LIST_HEAD(&slot->funcs);
228
		mutex_init(&slot->crit_sect);
Linus Torvalds's avatar
Linus Torvalds committed
229 230 231 232 233 234

		slot->next = bridge->slots;
		bridge->slots = slot;

		bridge->nr_slots++;

235
		dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
236
		    slot->sun, pci_domain_nr(pbus), pbus->number, device);
237 238
		retval = acpiphp_register_hotplug_slot(slot);
		if (retval) {
Alex Chiang's avatar
Alex Chiang committed
239
			if (retval == -EBUSY)
240
				warn("Slot %llu already registered by another "
Alex Chiang's avatar
Alex Chiang committed
241 242 243 244
					"hotplug driver\n", slot->sun);
			else
				warn("acpiphp_register_hotplug_slot failed "
					"(err code = 0x%x)\n", retval);
245 246
			goto err_exit;
		}
Linus Torvalds's avatar
Linus Torvalds committed
247 248 249 250 251
	}

	newfunc->slot = slot;
	list_add_tail(&newfunc->sibling, &slot->funcs);

252 253
	pdev = pci_get_slot(pbus, PCI_DEVFN(device, function));
	if (pdev) {
Linus Torvalds's avatar
Linus Torvalds committed
254
		slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
255
		pci_dev_put(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
256 257
	}

258 259 260 261
	if (is_dock_device(handle)) {
		/* we don't want to call this device's _EJ0
		 * because we want the dock notify handler
		 * to call it after it calls _DCK
262 263
		 */
		newfunc->flags &= ~FUNC_HAS_EJ0;
264
		if (register_hotplug_dock_device(handle,
265
			&acpiphp_dock_ops, newfunc))
266 267 268 269 270 271 272 273 274
			dbg("failed to register dock device\n");

		/* we need to be notified when dock events happen
		 * outside of the hotplug operation, since we may
		 * need to do fixups before we can hotplug.
		 */
		newfunc->nb.notifier_call = post_dock_fixups;
		if (register_dock_notifier(&newfunc->nb))
			dbg("failed to register a dock notifier");
275 276
	}

Linus Torvalds's avatar
Linus Torvalds committed
277
	/* install notify handler */
278 279
	if (!(newfunc->flags & FUNC_HAS_DCK)) {
		status = acpi_install_notify_handler(handle,
Linus Torvalds's avatar
Linus Torvalds committed
280 281 282 283
					     ACPI_SYSTEM_NOTIFY,
					     handle_hotplug_event_func,
					     newfunc);

284 285 286 287
		if (ACPI_FAILURE(status))
			err("failed to register interrupt notify handler\n");
	} else
		status = AE_OK;
Linus Torvalds's avatar
Linus Torvalds committed
288

289
	return status;
290 291 292 293 294 295 296 297

 err_exit:
	bridge->nr_slots--;
	bridge->slots = slot->next;
	kfree(slot);
	kfree(newfunc);

	return AE_OK;
Linus Torvalds's avatar
Linus Torvalds committed
298 299 300 301
}


/* see if it's worth looking at this bridge */
302
static int detect_ejectable_slots(acpi_handle handle)
Linus Torvalds's avatar
Linus Torvalds committed
303
{
304
	int found = acpi_pci_detect_ejectable(handle);
305
	if (!found) {
306
		acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
307
				    is_pci_dock_device, NULL, (void *)&found, NULL);
308 309
	}
	return found;
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312 313 314 315 316
}

/* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */
static void init_bridge_misc(struct acpiphp_bridge *bridge)
{
	acpi_status status;

317 318 319
	/* must be added to the list prior to calling register_slot */
	list_add(&bridge->list, &bridge_list);

Linus Torvalds's avatar
Linus Torvalds committed
320 321
	/* register all slot objects under this bridge */
	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1,
322
				     register_slot, NULL, bridge, NULL);
323 324 325 326
	if (ACPI_FAILURE(status)) {
		list_del(&bridge->list);
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
327

328 329
	/* install notify handler for P2P bridges */
	if (!pci_is_root_bus(bridge->pci_bus)) {
330 331 332 333 334 335 336
		if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
			status = acpi_remove_notify_handler(bridge->func->handle,
						ACPI_SYSTEM_NOTIFY,
						handle_hotplug_event_func);
			if (ACPI_FAILURE(status))
				err("failed to remove notify handler\n");
		}
337
		status = acpi_install_notify_handler(bridge->handle,
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341
					     ACPI_SYSTEM_NOTIFY,
					     handle_hotplug_event_bridge,
					     bridge);

342 343 344
		if (ACPI_FAILURE(status)) {
			err("failed to register interrupt notify handler\n");
		}
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348
	}
}


349 350 351 352 353 354 355
/* find acpiphp_func from acpiphp_bridge */
static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle)
{
	struct acpiphp_bridge *bridge;
	struct acpiphp_slot *slot;
	struct acpiphp_func *func;

356
	list_for_each_entry(bridge, &bridge_list, list) {
357
		for (slot = bridge->slots; slot; slot = slot->next) {
358
			list_for_each_entry(func, &slot->funcs, sibling) {
359 360 361 362 363 364 365 366 367 368 369 370 371
				if (func->handle == handle)
					return func;
			}
		}
	}

	return NULL;
}


static inline void config_p2p_bridge_flags(struct acpiphp_bridge *bridge)
{
	acpi_handle dummy_handle;
372
	struct acpiphp_func *func;
373 374

	if (ACPI_SUCCESS(acpi_get_handle(bridge->handle,
375
					"_EJ0", &dummy_handle))) {
376 377 378 379 380 381 382 383 384 385 386 387 388 389
		bridge->flags |= BRIDGE_HAS_EJ0;

		dbg("found ejectable p2p bridge\n");

		/* make link between PCI bridge and PCI function */
		func = acpiphp_bridge_handle_to_function(bridge->handle);
		if (!func)
			return;
		bridge->func = func;
		func->bridge = bridge;
	}
}


Linus Torvalds's avatar
Linus Torvalds committed
390
/* allocate and initialize host bridge data structure */
391
static void add_host_bridge(struct acpi_pci_root *root)
Linus Torvalds's avatar
Linus Torvalds committed
392 393
{
	struct acpiphp_bridge *bridge;
394
	acpi_handle handle = root->device->handle;
Linus Torvalds's avatar
Linus Torvalds committed
395

396
	bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399 400 401
	if (bridge == NULL)
		return;

	bridge->handle = handle;

402
	bridge->pci_bus = root->bus;
Linus Torvalds's avatar
Linus Torvalds committed
403 404 405 406 407 408

	init_bridge_misc(bridge);
}


/* allocate and initialize PCI-to-PCI bridge data structure */
409
static void add_p2p_bridge(acpi_handle *handle)
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412
{
	struct acpiphp_bridge *bridge;

413
	bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
414 415 416 417 418 419
	if (bridge == NULL) {
		err("out of memory\n");
		return;
	}

	bridge->handle = handle;
420
	config_p2p_bridge_flags(bridge);
Linus Torvalds's avatar
Linus Torvalds committed
421

422 423
	bridge->pci_dev = acpi_get_pci_dev(handle);
	bridge->pci_bus = bridge->pci_dev->subordinate;
Linus Torvalds's avatar
Linus Torvalds committed
424 425
	if (!bridge->pci_bus) {
		err("This is not a PCI-to-PCI bridge!\n");
426
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
427 428
	}

429 430 431 432 433 434
	/*
	 * Grab a ref to the subordinate PCI bus in case the bus is
	 * removed via PCI core logical hotplug. The ref pins the bus
	 * (which we access during module unload).
	 */
	get_device(&bridge->pci_bus->dev);
Linus Torvalds's avatar
Linus Torvalds committed
435 436

	init_bridge_misc(bridge);
437 438
	return;
 err:
439
	pci_dev_put(bridge->pci_dev);
440 441
	kfree(bridge);
	return;
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444 445 446 447 448 449 450 451
}


/* callback routine to find P2P bridges */
static acpi_status
find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	acpi_status status;
	struct pci_dev *dev;

452
	dev = acpi_get_pci_dev(handle);
453 454
	if (!dev || !dev->subordinate)
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
455 456

	/* check if this bridge has ejectable slots */
457
	if ((detect_ejectable_slots(handle) > 0)) {
Linus Torvalds's avatar
Linus Torvalds committed
458
		dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev));
459
		add_p2p_bridge(handle);
Linus Torvalds's avatar
Linus Torvalds committed
460 461
	}

462 463
	/* search P2P bridges under this p2p bridge */
	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
464
				     find_p2p_bridge, NULL, NULL, NULL);
465
	if (ACPI_FAILURE(status))
466
		warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
467

468 469
 out:
	pci_dev_put(dev);
Linus Torvalds's avatar
Linus Torvalds committed
470 471 472 473 474
	return AE_OK;
}


/* find hot-pluggable slots, and then find P2P bridge */
475
static int add_bridge(struct acpi_pci_root *root)
Linus Torvalds's avatar
Linus Torvalds committed
476 477
{
	acpi_status status;
478
	unsigned long long tmp;
Linus Torvalds's avatar
Linus Torvalds committed
479
	acpi_handle dummy_handle;
480
	acpi_handle handle = root->device->handle;
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483 484 485 486

	/* if the bridge doesn't have _STA, we assume it is always there */
	status = acpi_get_handle(handle, "_STA", &dummy_handle);
	if (ACPI_SUCCESS(status)) {
		status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp);
		if (ACPI_FAILURE(status)) {
487
			dbg("%s: _STA evaluation failure\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
488 489 490 491 492 493 494 495
			return 0;
		}
		if ((tmp & ACPI_STA_FUNCTIONING) == 0)
			/* don't register this object */
			return 0;
	}

	/* check if this bridge has ejectable slots */
496
	if (detect_ejectable_slots(handle) > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
497
		dbg("found PCI host-bus bridge with hot-pluggable slots\n");
498
		add_host_bridge(root);
Linus Torvalds's avatar
Linus Torvalds committed
499 500 501 502
	}

	/* search P2P bridges under this host bridge */
	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
503
				     find_p2p_bridge, NULL, NULL, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
504 505

	if (ACPI_FAILURE(status))
506
		warn("find_p2p_bridge failed (error code = 0x%x)\n", status);
Linus Torvalds's avatar
Linus Torvalds committed
507 508 509 510

	return 0;
}

511 512
static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle)
{
513 514 515
	struct acpiphp_bridge *bridge;

	list_for_each_entry(bridge, &bridge_list, list)
516 517 518 519 520
		if (bridge->handle == handle)
			return bridge;

	return NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
521

522
static void cleanup_bridge(struct acpiphp_bridge *bridge)
Linus Torvalds's avatar
Linus Torvalds committed
523
{
524 525
	struct acpiphp_slot *slot, *next;
	struct acpiphp_func *func, *tmp;
526
	acpi_status status;
527
	acpi_handle handle = bridge->handle;
528

529
	if (!pci_is_root_bus(bridge->pci_bus)) {
530 531
		status = acpi_remove_notify_handler(handle,
					    ACPI_SYSTEM_NOTIFY,
532
					    handle_hotplug_event_bridge);
533 534 535
		if (ACPI_FAILURE(status))
			err("failed to remove notify handler\n");
	}
536

537
	if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
538 539 540 541 542 543 544 545
		status = acpi_install_notify_handler(bridge->func->handle,
						ACPI_SYSTEM_NOTIFY,
						handle_hotplug_event_func,
						bridge->func);
		if (ACPI_FAILURE(status))
			err("failed to install interrupt notify handler\n");
	}

546 547
	slot = bridge->slots;
	while (slot) {
548 549
		next = slot->next;
		list_for_each_entry_safe(func, tmp, &slot->funcs, sibling) {
550 551 552 553
			if (is_dock_device(func->handle)) {
				unregister_hotplug_dock_device(func->handle);
				unregister_dock_notifier(&func->nb);
			}
554 555
			if (!(func->flags & FUNC_HAS_DCK)) {
				status = acpi_remove_notify_handler(func->handle,
556 557
						ACPI_SYSTEM_NOTIFY,
						handle_hotplug_event_func);
558 559 560
				if (ACPI_FAILURE(status))
					err("failed to remove notify handler\n");
			}
561
			list_del(&func->sibling);
562 563
			kfree(func);
		}
564 565
		acpiphp_unregister_hotplug_slot(slot);
		list_del(&slot->funcs);
566 567 568 569
		kfree(slot);
		slot = next;
	}

570 571 572 573 574 575
	/*
	 * Only P2P bridges have a pci_dev
	 */
	if (bridge->pci_dev)
		put_device(&bridge->pci_bus->dev);

576 577 578
	pci_dev_put(bridge->pci_dev);
	list_del(&bridge->list);
	kfree(bridge);
Linus Torvalds's avatar
Linus Torvalds committed
579 580
}

581 582 583 584 585
static acpi_status
cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	struct acpiphp_bridge *bridge;

586 587 588
	/* cleanup p2p bridges under this P2P bridge
	   in a depth-first manner */
	acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
589
				cleanup_p2p_bridge, NULL, NULL, NULL);
590

591 592 593 594
	bridge = acpiphp_handle_to_bridge(handle);
	if (bridge)
		cleanup_bridge(bridge);

595 596 597
	return AE_OK;
}

598
static void remove_bridge(struct acpi_pci_root *root)
599 600
{
	struct acpiphp_bridge *bridge;
601
	acpi_handle handle = root->device->handle;
602

603 604 605
	/* cleanup p2p bridges under this host bridge
	   in a depth-first manner */
	acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
606
				(u32)1, cleanup_p2p_bridge, NULL, NULL, NULL);
607

608 609
	/*
	 * On root bridges with hotplug slots directly underneath (ie,
Lucas De Marchi's avatar
Lucas De Marchi committed
610
	 * no p2p bridge between), we call cleanup_bridge(). 
611 612 613 614
	 *
	 * The else clause cleans up root bridges that either had no
	 * hotplug slots at all, or had a p2p bridge underneath.
	 */
615
	bridge = acpiphp_handle_to_bridge(handle);
616
	if (bridge)
617 618
		cleanup_bridge(bridge);
}
Linus Torvalds's avatar
Linus Torvalds committed
619 620 621 622 623 624 625 626 627 628 629

static int power_on_slot(struct acpiphp_slot *slot)
{
	acpi_status status;
	struct acpiphp_func *func;
	int retval = 0;

	/* if already enabled, just skip */
	if (slot->flags & SLOT_POWEREDON)
		goto err_exit;

630
	list_for_each_entry(func, &slot->funcs, sibling) {
Linus Torvalds's avatar
Linus Torvalds committed
631
		if (func->flags & FUNC_HAS_PS0) {
632
			dbg("%s: executing _PS0\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
633 634
			status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL);
			if (ACPI_FAILURE(status)) {
635
				warn("%s: _PS0 failed\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
				retval = -1;
				goto err_exit;
			} else
				break;
		}
	}

	/* TBD: evaluate _STA to check if the slot is enabled */

	slot->flags |= SLOT_POWEREDON;

 err_exit:
	return retval;
}


static int power_off_slot(struct acpiphp_slot *slot)
{
	acpi_status status;
	struct acpiphp_func *func;

	int retval = 0;

	/* if already disabled, just skip */
	if ((slot->flags & SLOT_POWEREDON) == 0)
		goto err_exit;

663
	list_for_each_entry(func, &slot->funcs, sibling) {
664
		if (func->flags & FUNC_HAS_PS3) {
Linus Torvalds's avatar
Linus Torvalds committed
665 666
			status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL);
			if (ACPI_FAILURE(status)) {
667
				warn("%s: _PS3 failed\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
				retval = -1;
				goto err_exit;
			} else
				break;
		}
	}

	/* TBD: evaluate _STA to check if the slot is disabled */

	slot->flags &= (~SLOT_POWEREDON);

 err_exit:
	return retval;
}


684 685

/**
Randy Dunlap's avatar
Randy Dunlap committed
686
 * acpiphp_max_busnr - return the highest reserved bus number under the given bus.
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
 * @bus: bus to start search with
 */
static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
{
	struct list_head *tmp;
	unsigned char max, n;

	/*
	 * pci_bus_max_busnr will return the highest
	 * reserved busnr for all these children.
	 * that is equivalent to the bus->subordinate
	 * value.  We don't want to use the parent's
	 * bus->subordinate value because it could have
	 * padding in it.
	 */
702
	max = bus->busn_res.start;
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718

	list_for_each(tmp, &bus->children) {
		n = pci_bus_max_busnr(pci_bus_b(tmp));
		if (n > max)
			max = n;
	}
	return max;
}


/**
 * acpiphp_bus_add - add a new bus to acpi subsystem
 * @func: acpiphp_func of the bridge
 */
static int acpiphp_bus_add(struct acpiphp_func *func)
{
719
	struct acpi_device *device;
720 721
	int ret_val;

722 723 724 725 726
	if (!acpi_bus_get_device(func->handle, &device)) {
		dbg("bus exists... trim\n");
		/* this shouldn't be in here, so remove
		 * the bus then re-add it...
		 */
727
		ret_val = acpi_bus_trim(device);
728 729 730
		dbg("acpi_bus_trim return %x\n", ret_val);
	}

731
	ret_val = acpi_bus_scan(func->handle);
732 733 734 735 736
	if (!ret_val)
		ret_val = acpi_bus_get_device(func->handle, &device);

	if (ret_val)
		dbg("error adding bus, %x\n", -ret_val);
737 738 739 740 741

	return ret_val;
}


742 743 744 745
/**
 * acpiphp_bus_trim - trim a bus from acpi subsystem
 * @handle: handle to acpi namespace
 */
746
static int acpiphp_bus_trim(acpi_handle handle)
747 748 749 750 751 752 753 754 755 756
{
	struct acpi_device *device;
	int retval;

	retval = acpi_bus_get_device(handle, &device);
	if (retval) {
		dbg("acpi_device not found\n");
		return retval;
	}

757
	retval = acpi_bus_trim(device);
758 759 760 761 762
	if (retval)
		err("cannot remove from acpi list\n");

	return retval;
}
763

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
{
	struct acpiphp_func *func;
	union acpi_object params[2];
	struct acpi_object_list arg_list;

	list_for_each_entry(func, &slot->funcs, sibling) {
		arg_list.count = 2;
		arg_list.pointer = params;
		params[0].type = ACPI_TYPE_INTEGER;
		params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG;
		params[1].type = ACPI_TYPE_INTEGER;
		params[1].integer.value = 1;
		/* _REG is optional, we don't care about if there is failure */
		acpi_evaluate_object(func->handle, "_REG", &arg_list, NULL);
	}
}

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev)
{
	struct acpiphp_func *func;

	if (!dev->subordinate)
		return;

	/* quirk, or pcie could set it already */
	if (dev->is_hotplug_bridge)
		return;

	if (PCI_SLOT(dev->devfn) != slot->device)
		return;

	list_for_each_entry(func, &slot->funcs, sibling) {
		if (PCI_FUNC(dev->devfn) == func->function) {
			/* check if this bridge has ejectable slots */
			if ((detect_ejectable_slots(func->handle) > 0))
				dev->is_hotplug_bridge = 1;
			break;
		}
	}
}
Linus Torvalds's avatar
Linus Torvalds committed
805 806 807 808 809 810 811
/**
 * enable_device - enable, configure a slot
 * @slot: slot to be enabled
 *
 * This function should be called per *physical slot*,
 * not per each slot object in ACPI namespace.
 */
812
static int __ref enable_device(struct acpiphp_slot *slot)
Linus Torvalds's avatar
Linus Torvalds committed
813 814
{
	struct pci_dev *dev;
815
	struct pci_bus *bus = slot->bridge->pci_bus;
Linus Torvalds's avatar
Linus Torvalds committed
816 817
	struct acpiphp_func *func;
	int retval = 0;
818
	int num, max, pass;
819
	acpi_status status;
Linus Torvalds's avatar
Linus Torvalds committed
820 821 822 823

	if (slot->flags & SLOT_ENABLED)
		goto err_exit;

824 825 826
	list_for_each_entry(func, &slot->funcs, sibling)
		acpiphp_bus_add(func);

827 828
	num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
	if (num == 0) {
829 830
		/* Maybe only part of funcs are added. */
		dbg("No new device found\n");
Linus Torvalds's avatar
Linus Torvalds committed
831 832 833
		goto err_exit;
	}

834
	max = acpiphp_max_busnr(bus);
835 836 837 838 839
	for (pass = 0; pass < 2; pass++) {
		list_for_each_entry(dev, &bus->devices, bus_list) {
			if (PCI_SLOT(dev->devfn) != slot->device)
				continue;
			if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
840
			    dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
841
				max = pci_scan_bridge(bus, dev, max, pass);
842 843
				if (pass && dev->subordinate) {
					check_hotplug_bridge(slot, dev);
844
					pci_bus_size_bridges(dev->subordinate);
845
				}
846
			}
847
		}
Linus Torvalds's avatar
Linus Torvalds committed
848 849
	}

850
	pci_bus_assign_resources(bus);
851
	acpiphp_sanitize_bus(bus);
852
	acpiphp_set_hpp_values(bus);
853
	acpiphp_set_acpi_region(slot);
854
	pci_enable_bridges(bus);
855 856 857 858 859 860 861

	list_for_each_entry(dev, &bus->devices, bus_list) {
		/* Assume that newly added devices are powered on already. */
		if (!dev->is_added)
			dev->current_state = PCI_D0;
	}

862 863
	pci_bus_add_devices(bus);

864
	slot->flags |= SLOT_ENABLED;
865
	list_for_each_entry(func, &slot->funcs, sibling) {
866 867
		dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
						  func->function));
868 869 870 871
		if (!dev) {
			/* Do not set SLOT_ENABLED flag if some funcs
			   are not added. */
			slot->flags &= (~SLOT_ENABLED);
872
			continue;
873
		}
874

875 876 877
		if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
		    dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) {
			pci_dev_put(dev);
878
			continue;
879
		}
880 881 882 883 884

		status = find_p2p_bridge(func->handle, (u32)1, bus, NULL);
		if (ACPI_FAILURE(status))
			warn("find_p2p_bridge failed (error code = 0x%x)\n",
				status);
885
		pci_dev_put(dev);
Linus Torvalds's avatar
Linus Torvalds committed
886 887 888 889 890 891 892
	}


 err_exit:
	return retval;
}

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
/* return first device in slot, acquiring a reference on it */
static struct pci_dev *dev_in_slot(struct acpiphp_slot *slot)
{
	struct pci_bus *bus = slot->bridge->pci_bus;
	struct pci_dev *dev;
	struct pci_dev *ret = NULL;

	down_read(&pci_bus_sem);
	list_for_each_entry(dev, &bus->devices, bus_list)
		if (PCI_SLOT(dev->devfn) == slot->device) {
			ret = pci_dev_get(dev);
			break;
		}
	up_read(&pci_bus_sem);

	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
911 912
/**
 * disable_device - disable a slot
Randy Dunlap's avatar
Randy Dunlap committed
913
 * @slot: ACPI PHP slot
Linus Torvalds's avatar
Linus Torvalds committed
914 915 916 917
 */
static int disable_device(struct acpiphp_slot *slot)
{
	struct acpiphp_func *func;
918
	struct pci_dev *pdev;
919
	struct pci_bus *bus = slot->bridge->pci_bus;
Linus Torvalds's avatar
Linus Torvalds committed
920

921 922 923 924
	/* The slot will be enabled when func 0 is added, so check
	   func 0 before disable the slot. */
	pdev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0));
	if (!pdev)
Linus Torvalds's avatar
Linus Torvalds committed
925
		goto err_exit;
926
	pci_dev_put(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
927

928
	list_for_each_entry(func, &slot->funcs, sibling) {
929 930 931 932 933 934
		if (func->bridge) {
			/* cleanup p2p bridges under this P2P bridge */
			cleanup_p2p_bridge(func->bridge->handle,
						(u32)1, NULL, NULL);
			func->bridge = NULL;
		}
935
	}
936

937 938 939 940 941 942 943
	/*
	 * enable_device() enumerates all functions in this device via
	 * pci_scan_slot(), whether they have associated ACPI hotplug
	 * methods (_EJ0, etc.) or not.  Therefore, we remove all functions
	 * here.
	 */
	while ((pdev = dev_in_slot(slot))) {
944
		pci_stop_and_remove_bus_device(pdev);
945
		pci_dev_put(pdev);
946 947
	}

948
	list_for_each_entry(func, &slot->funcs, sibling) {
949
		acpiphp_bus_trim(func->handle);
Linus Torvalds's avatar
Linus Torvalds committed
950 951 952 953
	}

	slot->flags &= (~SLOT_ENABLED);

954 955
err_exit:
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
956 957 958 959 960
}


/**
 * get_slot_status - get ACPI slot status
Randy Dunlap's avatar
Randy Dunlap committed
961
 * @slot: ACPI PHP slot
Linus Torvalds's avatar
Linus Torvalds committed
962
 *
Randy Dunlap's avatar
Randy Dunlap committed
963 964
 * If a slot has _STA for each function and if any one of them
 * returned non-zero status, return it.
Linus Torvalds's avatar
Linus Torvalds committed
965
 *
Randy Dunlap's avatar
Randy Dunlap committed
966 967
 * If a slot doesn't have _STA and if any one of its functions'
 * configuration space is configured, return 0x0f as a _STA.
Linus Torvalds's avatar
Linus Torvalds committed
968
 *
Randy Dunlap's avatar
Randy Dunlap committed
969
 * Otherwise return 0.
Linus Torvalds's avatar
Linus Torvalds committed
970 971 972 973
 */
static unsigned int get_slot_status(struct acpiphp_slot *slot)
{
	acpi_status status;
974
	unsigned long long sta = 0;
Linus Torvalds's avatar
Linus Torvalds committed
975 976 977
	u32 dvid;
	struct acpiphp_func *func;

978
	list_for_each_entry(func, &slot->funcs, sibling) {
Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
		if (func->flags & FUNC_HAS_STA) {
			status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta);
			if (ACPI_SUCCESS(status) && sta)
				break;
		} else {
			pci_bus_read_config_dword(slot->bridge->pci_bus,
						  PCI_DEVFN(slot->device,
							    func->function),
						  PCI_VENDOR_ID, &dvid);
			if (dvid != 0xffffffff) {
				sta = ACPI_STA_ALL;
				break;
			}
		}
	}

	return (unsigned int)sta;
}

998 999
/**
 * acpiphp_eject_slot - physically eject the slot
Randy Dunlap's avatar
Randy Dunlap committed
1000
 * @slot: ACPI PHP slot
1001
 */
1002
int acpiphp_eject_slot(struct acpiphp_slot *slot)
1003 1004 1005 1006 1007 1008
{
	acpi_status status;
	struct acpiphp_func *func;
	struct acpi_object_list arg_list;
	union acpi_object arg;

1009
	list_for_each_entry(func, &slot->funcs, sibling) {
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
		/* We don't want to call _EJ0 on non-existing functions. */
		if ((func->flags & FUNC_HAS_EJ0)) {
			/* _EJ0 method take one argument */
			arg_list.count = 1;
			arg_list.pointer = &arg;
			arg.type = ACPI_TYPE_INTEGER;
			arg.integer.value = 1;

			status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL);
			if (ACPI_FAILURE(status)) {
1020
				warn("%s: _EJ0 failed\n", __func__);
1021 1022 1023 1024 1025 1026 1027 1028
				return -1;
			} else
				break;
		}
	}
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1029 1030
/**
 * acpiphp_check_bridge - re-enumerate devices
Randy Dunlap's avatar
Randy Dunlap committed
1031
 * @bridge: where to begin re-enumeration
Linus Torvalds's avatar
Linus Torvalds committed
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
 *
 * Iterate over all slots under this bridge and make sure that if a
 * card is present they are enabled, and if not they are disabled.
 */
static int acpiphp_check_bridge(struct acpiphp_bridge *bridge)
{
	struct acpiphp_slot *slot;
	int retval = 0;
	int enabled, disabled;

	enabled = disabled = 0;

	for (slot = bridge->slots; slot; slot = slot->next) {
		unsigned int status = get_slot_status(slot);
		if (slot->flags & SLOT_ENABLED) {
			if (status == ACPI_STA_ALL)
				continue;
			retval = acpiphp_disable_slot(slot);
			if (retval) {
				err("Error occurred in disabling\n");
				goto err_exit;
1053 1054
			} else {
				acpiphp_eject_slot(slot);
Linus Torvalds's avatar
Linus Torvalds committed
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
			}
			disabled++;
		} else {
			if (status != ACPI_STA_ALL)
				continue;
			retval = acpiphp_enable_slot(slot);
			if (retval) {
				err("Error occurred in enabling\n");
				goto err_exit;
			}
			enabled++;
		}
	}

1069
	dbg("%s: %d enabled, %d disabled\n", __func__, enabled, disabled);
Linus Torvalds's avatar
Linus Torvalds committed
1070 1071 1072 1073 1074

 err_exit:
	return retval;
}

1075
static void acpiphp_set_hpp_values(struct pci_bus *bus)
1076 1077 1078
{
	struct pci_dev *dev;

1079 1080
	list_for_each_entry(dev, &bus->devices, bus_list)
		pci_configure_slot(dev);
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
}

/*
 * Remove devices for which we could not assign resources, call
 * arch specific code to fix-up the bus
 */
static void acpiphp_sanitize_bus(struct pci_bus *bus)
{
	struct pci_dev *dev;
	int i;
	unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;

	list_for_each_entry(dev, &bus->devices, bus_list) {
		for (i=0; i<PCI_BRIDGE_RESOURCES; i++) {
			struct resource *res = &dev->resource[i];
			if ((res->flags & type_mask) && !res->start &&
					res->end) {
				/* Could not assign a required resources
				 * for this device, remove it */
1100
				pci_stop_and_remove_bus_device(dev);
1101 1102 1103 1104 1105 1106
				break;
			}
		}
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
1107 1108 1109 1110
/*
 * ACPI event handlers
 */

1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
static acpi_status
check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	struct acpiphp_bridge *bridge;
	char objname[64];
	struct acpi_buffer buffer = { .length = sizeof(objname),
				      .pointer = objname };

	bridge = acpiphp_handle_to_bridge(handle);
	if (bridge) {
		acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
		dbg("%s: re-enumerating slots under %s\n",
1123
			__func__, objname);
1124 1125 1126 1127 1128
		acpiphp_check_bridge(bridge);
	}
	return AE_OK ;
}

1129
static void _handle_hotplug_event_bridge(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131 1132 1133 1134
{
	struct acpiphp_bridge *bridge;
	char objname[64];
	struct acpi_buffer buffer = { .length = sizeof(objname),
				      .pointer = objname };
1135
	struct acpi_hp_work *hp_work;
1136 1137 1138
	acpi_handle handle;
	u32 type;

1139
	hp_work = container_of(work, struct acpi_hp_work, work);
1140 1141
	handle = hp_work->handle;
	type = hp_work->type;
1142
	bridge = (struct acpiphp_bridge *)hp_work->context;
Linus Torvalds's avatar
Linus Torvalds committed
1143 1144 1145 1146 1147 1148

	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);

	switch (type) {
	case ACPI_NOTIFY_BUS_CHECK:
		/* bus re-enumerate */
1149
		dbg("%s: Bus check notify on %s\n", __func__, objname);
1150 1151 1152 1153
		dbg("%s: re-enumerating slots under %s\n", __func__, objname);
		acpiphp_check_bridge(bridge);
		acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
			ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1154 1155 1156 1157
		break;

	case ACPI_NOTIFY_DEVICE_CHECK:
		/* device check */
1158
		dbg("%s: Device check notify on %s\n", __func__, objname);
Linus Torvalds's avatar
Linus Torvalds committed
1159 1160 1161 1162 1163
		acpiphp_check_bridge(bridge);
		break;

	case ACPI_NOTIFY_DEVICE_WAKE:
		/* wake event */
1164
		dbg("%s: Device wake notify on %s\n", __func__, objname);
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166 1167 1168
		break;

	case ACPI_NOTIFY_EJECT_REQUEST:
		/* request device eject */
1169
		dbg("%s: Device eject notify on %s\n", __func__, objname);
1170
		if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
1171 1172 1173 1174 1175
			struct acpiphp_slot *slot;
			slot = bridge->func->slot;
			if (!acpiphp_disable_slot(slot))
				acpiphp_eject_slot(slot);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
		break;

	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
		printk(KERN_ERR "Device %s cannot be configured due"
				" to a frequency mismatch\n", objname);
		break;

	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
		printk(KERN_ERR "Device %s cannot be configured due"
				" to a bus mode mismatch\n", objname);
		break;

	case ACPI_NOTIFY_POWER_FAULT:
		printk(KERN_ERR "Device %s has suffered a power fault\n",
				objname);
		break;

	default:
		warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
		break;
	}
1197 1198

	kfree(hp_work); /* allocated in handle_hotplug_event_bridge */
Linus Torvalds's avatar
Linus Torvalds committed
1199 1200 1201
}

/**
1202
 * handle_hotplug_event_bridge - handle ACPI event on bridges
Linus Torvalds's avatar
Linus Torvalds committed
1203 1204
 * @handle: Notify()'ed acpi_handle
 * @type: Notify code
1205
 * @context: pointer to acpiphp_bridge structure
Linus Torvalds's avatar
Linus Torvalds committed
1206
 *
1207
 * Handles ACPI event notification on {host,p2p} bridges.
Linus Torvalds's avatar
Linus Torvalds committed
1208
 */
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
static void handle_hotplug_event_bridge(acpi_handle handle, u32 type,
					void *context)
{
	/*
	 * Currently the code adds all hotplug events to the kacpid_wq
	 * queue when it should add hotplug events to the kacpi_hotplug_wq.
	 * The proper way to fix this is to reorganize the code so that
	 * drivers (dock, etc.) do not call acpi_os_execute(), etc.
	 * For now just re-add this work to the kacpi_hotplug_wq so we
	 * don't deadlock on hotplug actions.
	 */
1220
	alloc_acpi_hp_work(handle, type, context, _handle_hotplug_event_bridge);
1221 1222 1223
}

static void _handle_hotplug_event_func(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
1224 1225 1226 1227 1228
{
	struct acpiphp_func *func;
	char objname[64];
	struct acpi_buffer buffer = { .length = sizeof(objname),
				      .pointer = objname };
1229
	struct acpi_hp_work *hp_work;
1230 1231 1232
	acpi_handle handle;
	u32 type;

1233
	hp_work = container_of(work, struct acpi_hp_work, work);
1234 1235
	handle = hp_work->handle;
	type = hp_work->type;
1236
	func = (struct acpiphp_func *)hp_work->context;
Linus Torvalds's avatar
Linus Torvalds committed
1237 1238 1239 1240 1241 1242

	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);

	switch (type) {
	case ACPI_NOTIFY_BUS_CHECK:
		/* bus re-enumerate */
1243
		dbg("%s: Bus check notify on %s\n", __func__, objname);
Linus Torvalds's avatar
Linus Torvalds committed
1244 1245 1246 1247 1248
		acpiphp_enable_slot(func->slot);
		break;

	case ACPI_NOTIFY_DEVICE_CHECK:
		/* device check : re-enumerate from parent bus */
1249
		dbg("%s: Device check notify on %s\n", __func__, objname);
Linus Torvalds's avatar
Linus Torvalds committed
1250 1251 1252 1253 1254
		acpiphp_check_bridge(func->slot->bridge);
		break;

	case ACPI_NOTIFY_DEVICE_WAKE:
		/* wake event */
1255
		dbg("%s: Device wake notify on %s\n", __func__, objname);
Linus Torvalds's avatar
Linus Torvalds committed
1256 1257 1258 1259
		break;

	case ACPI_NOTIFY_EJECT_REQUEST:
		/* request device eject */
1260
		dbg("%s: Device eject notify on %s\n", __func__, objname);
1261 1262
		if (!(acpiphp_disable_slot(func->slot)))
			acpiphp_eject_slot(func->slot);
Linus Torvalds's avatar
Linus Torvalds committed
1263 1264 1265 1266 1267 1268
		break;

	default:
		warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
		break;
	}
1269 1270

	kfree(hp_work); /* allocated in handle_hotplug_event_func */
Linus Torvalds's avatar
Linus Torvalds committed
1271 1272
}

1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
/**
 * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots)
 * @handle: Notify()'ed acpi_handle
 * @type: Notify code
 * @context: pointer to acpiphp_func structure
 *
 * Handles ACPI event notification on slots.
 */
static void handle_hotplug_event_func(acpi_handle handle, u32 type,
				      void *context)
{
	/*
	 * Currently the code adds all hotplug events to the kacpid_wq
	 * queue when it should add hotplug events to the kacpi_hotplug_wq.
	 * The proper way to fix this is to reorganize the code so that
	 * drivers (dock, etc.) do not call acpi_os_execute(), etc.
	 * For now just re-add this work to the kacpi_hotplug_wq so we
	 * don't deadlock on hotplug actions.
	 */
1292
	alloc_acpi_hp_work(handle, type, context, _handle_hotplug_event_func);
1293
}
1294

Linus Torvalds's avatar
Linus Torvalds committed
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
static struct acpi_pci_driver acpi_pci_hp_driver = {
	.add =		add_bridge,
	.remove =	remove_bridge,
};

/**
 * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures
 */
int __init acpiphp_glue_init(void)
{
1305
	acpi_pci_register_driver(&acpi_pci_hp_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1306 1307 1308 1309 1310 1311 1312 1313

	return 0;
}


/**
 * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures
 *
Randy Dunlap's avatar
Randy Dunlap committed
1314
 * This function frees all data allocated in acpiphp_glue_init().
Linus Torvalds's avatar
Linus Torvalds committed
1315
 */
1316
void  acpiphp_glue_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
1317 1318 1319 1320 1321 1322
{
	acpi_pci_unregister_driver(&acpi_pci_hp_driver);
}

/**
 * acpiphp_enable_slot - power on slot
Randy Dunlap's avatar
Randy Dunlap committed
1323
 * @slot: ACPI PHP slot
Linus Torvalds's avatar
Linus Torvalds committed
1324 1325 1326 1327 1328
 */
int acpiphp_enable_slot(struct acpiphp_slot *slot)
{
	int retval;

1329
	mutex_lock(&slot->crit_sect);
Linus Torvalds's avatar
Linus Torvalds committed
1330 1331 1332 1333 1334 1335

	/* wake up all functions */
	retval = power_on_slot(slot);
	if (retval)
		goto err_exit;

1336
	if (get_slot_status(slot) == ACPI_STA_ALL) {
Linus Torvalds's avatar
Linus Torvalds committed
1337 1338
		/* configure all functions */
		retval = enable_device(slot);
1339 1340 1341
		if (retval)
			power_off_slot(slot);
	} else {
1342
		dbg("%s: Slot status is not ACPI_STA_ALL\n", __func__);
1343 1344
		power_off_slot(slot);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1345 1346

 err_exit:
1347
	mutex_unlock(&slot->crit_sect);
Linus Torvalds's avatar
Linus Torvalds committed
1348 1349 1350 1351 1352
	return retval;
}

/**
 * acpiphp_disable_slot - power off slot
Randy Dunlap's avatar
Randy Dunlap committed
1353
 * @slot: ACPI PHP slot
Linus Torvalds's avatar
Linus Torvalds committed
1354 1355 1356 1357 1358
 */
int acpiphp_disable_slot(struct acpiphp_slot *slot)
{
	int retval = 0;

1359
	mutex_lock(&slot->crit_sect);
Linus Torvalds's avatar
Linus Torvalds committed
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371

	/* unconfigure all functions */
	retval = disable_device(slot);
	if (retval)
		goto err_exit;

	/* power off all functions */
	retval = power_off_slot(slot);
	if (retval)
		goto err_exit;

 err_exit:
1372
	mutex_unlock(&slot->crit_sect);
Linus Torvalds's avatar
Linus Torvalds committed
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
	return retval;
}


/*
 * slot enabled:  1
 * slot disabled: 0
 */
u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
{
1383
	return (slot->flags & SLOT_POWEREDON);
Linus Torvalds's avatar
Linus Torvalds committed
1384 1385 1386 1387
}


/*
MUNEDA Takahiro's avatar
MUNEDA Takahiro committed
1388 1389
 * latch   open:  1
 * latch closed:  0
Linus Torvalds's avatar
Linus Torvalds committed
1390 1391 1392 1393 1394 1395 1396
 */
u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
{
	unsigned int sta;

	sta = get_slot_status(slot);

MUNEDA Takahiro's avatar
MUNEDA Takahiro committed
1397
	return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1;
Linus Torvalds's avatar
Linus Torvalds committed
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
}


/*
 * adapter presence : 1
 *          absence : 0
 */
u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
{
	unsigned int sta;

	sta = get_slot_status(slot);

	return (sta == 0) ? 0 : 1;
}