From patchwork Sat Aug 4 12:13:57 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiang Liu X-Patchwork-Id: 1273371 X-Patchwork-Delegate: bhelgaas@google.com Return-Path: X-Original-To: patchwork-linux-pci@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork2.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork2.kernel.org (Postfix) with ESMTP id 42E2EDFAF5 for ; Sat, 4 Aug 2012 12:16:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753212Ab2HDMQS (ORCPT ); Sat, 4 Aug 2012 08:16:18 -0400 Received: from szxga02-in.huawei.com ([119.145.14.65]:20774 "EHLO szxga02-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752766Ab2HDMOz (ORCPT ); Sat, 4 Aug 2012 08:14:55 -0400 Received: from 172.24.2.119 (EHLO szxeml201-edg.china.huawei.com) ([172.24.2.119]) by szxrg02-dlp.huawei.com (MOS 4.3.4-GA FastPath queued) with ESMTP id AMY69806; Sat, 04 Aug 2012 20:14:35 +0800 (CST) Received: from SZXEML404-HUB.china.huawei.com (10.82.67.59) by szxeml201-edg.china.huawei.com (172.24.2.39) with Microsoft SMTP Server (TLS) id 14.1.323.3; Sat, 4 Aug 2012 20:14:25 +0800 Received: from localhost (10.108.108.229) by szxeml404-hub.china.huawei.com (10.82.67.59) with Microsoft SMTP Server id 14.1.323.3; Sat, 4 Aug 2012 20:14:27 +0800 From: Jiang Liu To: Yinghai Lu , Yasuaki Ishimatsu , Kenji Kaneshige , Wen Congyang , Tang Chen , Taku Izumi CC: Jiang Liu , Tony Luck , Huang Ying , Bob Moore , Len Brown , "Srivatsa S. Bhat" , Bjorn Helgaas , , , , Jiang Liu , Hanjun Guo Subject: [RFC PATCH v2 10/16] ACPIHP: system device hotplug driver skeleton Date: Sat, 4 Aug 2012 20:13:57 +0800 Message-ID: <1344082443-4608-11-git-send-email-jiang.liu@huawei.com> X-Mailer: git-send-email 1.7.11.msysgit.1 In-Reply-To: <1344082443-4608-1-git-send-email-jiang.liu@huawei.com> References: <1344082443-4608-1-git-send-email-jiang.liu@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.108.108.229] X-CFilter-Loop: Reflected Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org From: Jiang Liu This patch implements a skeleton for ACPI based system device hotplug driver. This device class driver will be bound to and manage ACPI hotplug slots. This is the default hotplug driver for ACPI based system device hotplug. Signed-off-by: Jiang Liu Signed-off-by: Hanjun Guo --- drivers/acpi/Kconfig | 12 ++ drivers/acpi/hotplug/Makefile | 3 + drivers/acpi/hotplug/acpihp_drv.h | 62 +++++++ drivers/acpi/hotplug/drv_main.c | 331 +++++++++++++++++++++++++++++++++++++ 4 files changed, 408 insertions(+) create mode 100644 drivers/acpi/hotplug/acpihp_drv.h create mode 100644 drivers/acpi/hotplug/drv_main.c diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index c9f7918..89047a3 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig @@ -354,6 +354,18 @@ config ACPI_HOTPLUG_ENUM_EJ0 It's the default method to detect ACPI hotplug slots. +config ACPI_HOTPLUG_DRIVER + tristate "ACPI Based System Device Hotplug Driver" + depends on ACPI_HOTPLUG + default y + help + This driver enables ACPI based system device hotplug, including + physical processor, memory device, IO host bridge and computer + node etc. + + To compile this driver as a module, choose M here: + the module will be called acpihp_drv. + config ACPI_CONTAINER tristate "Container and Module Devices (EXPERIMENTAL)" depends on EXPERIMENTAL diff --git a/drivers/acpi/hotplug/Makefile b/drivers/acpi/hotplug/Makefile index 25fac24..d69832f 100644 --- a/drivers/acpi/hotplug/Makefile +++ b/drivers/acpi/hotplug/Makefile @@ -8,3 +8,6 @@ acpihp-y = core.o device.o obj-$(CONFIG_ACPI_HOTPLUG_ENUM) += acpihp_enum.o acpihp_enum-y = slot_enum.o acpihp_enum-y += slot_enum_ej0.o + +obj-$(CONFIG_ACPI_HOTPLUG_DRIVER) += acpihp_drv.o +acpihp_drv-y = drv_main.o diff --git a/drivers/acpi/hotplug/acpihp_drv.h b/drivers/acpi/hotplug/acpihp_drv.h new file mode 100644 index 0000000..18330f7 --- /dev/null +++ b/drivers/acpi/hotplug/acpihp_drv.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2011 Huawei Tech. Co., Ltd. + * Copyright (C) 2011 Jiang Liu + * Copyright (C) 2011 Hanjun Guo + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * 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. 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +#ifndef __ACPIHP_DRV_H__ +#define __ACPIHP_DRV_H__ + +/* Commands to change state of a hotplug slot */ +enum acpihp_drv_cmd { + ACPIHP_DRV_CMD_NOOP = 0, + ACPIHP_DRV_CMD_POWERON = 0x1, + ACPIHP_DRV_CMD_CONNECT = 0x2, + ACPIHP_DRV_CMD_CONFIGURE = 0x4, + ACPIHP_DRV_CMD_UNCONFIGURE = 0x8, + ACPIHP_DRV_CMD_DISCONNECT = 0x10, + ACPIHP_DRV_CMD_POWEROFF = 0x20, + ACPIHP_DRV_CMD_CANCEL = 0x40, + ACPIHP_DRV_CMD_MAX +}; + +/* Hotplug operations may be triggered by firmware or OS */ +enum acpihp_dev_event { + ACPIHP_DRV_EVENT_FROM_FW, + ACPIHP_DRV_EVENT_FROM_OS +}; + +struct acpihp_slot_drv { + enum acpihp_dev_event event_flag; + struct mutex op_mutex; /* Prevent concurrent hotplugs. */ + struct list_head depend_list; /* Dependency relationship */ + atomic_t cancel_status; + atomic_t cancel_flag; + struct acpihp_cancel_context cancel_ctx; +}; + +void acpihp_drv_get_data(struct acpihp_slot *slot, + struct acpihp_slot_drv **data); +int acpihp_drv_enumerate_devices(struct acpihp_slot *slot); +void acpihp_drv_update_slot_state(struct acpihp_slot *slot); +int acpihp_drv_update_slot_status(struct acpihp_slot *slot); + +#endif /* __ACPIHP_DRV_H__ */ diff --git a/drivers/acpi/hotplug/drv_main.c b/drivers/acpi/hotplug/drv_main.c new file mode 100644 index 0000000..538772d --- /dev/null +++ b/drivers/acpi/hotplug/drv_main.c @@ -0,0 +1,331 @@ +/* + * Copyright (C) 2011 Huawei Tech. Co., Ltd. + * Copyright (C) 2011 Jiang Liu + * Copyright (C) 2011 Hanjun Guo + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * 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. 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "acpihp_drv.h" + +static struct class_interface acpihp_drv_interface; + +void acpihp_drv_get_data(struct acpihp_slot *slot, + struct acpihp_slot_drv **data) +{ + *data = NULL; + acpihp_slot_get_drv_data(slot, &acpihp_drv_interface, (void **)data); +} + +/* Update slot state according to state of devices connecting to it. */ +void acpihp_drv_update_slot_state(struct acpihp_slot *slot) +{ + enum acpihp_dev_type type; + enum acpihp_slot_state state; + struct klist_iter iter; + struct klist_node *ip; + struct acpihp_dev_node *dp; + bool connected = false; + bool configured = false; + + if (!acpihp_slot_present(slot)) { + state = ACPIHP_SLOT_STATE_ABSENT; + goto out; + } else if (!acpihp_slot_powered(slot)) { + state = ACPIHP_SLOT_STATE_PRESENT; + goto out; + } + + for (type = ACPIHP_DEV_TYPE_UNKNOWN; + type < ACPIHP_DEV_TYPE_MAX && !configured; + type++) { + klist_iter_init(&slot->dev_lists[type], &iter); + while ((ip = klist_next(&iter)) != NULL) { + connected = true; + dp = container_of(ip, struct acpihp_dev_node, node); + if (dp->state == DEVICE_STATE_CONFIGURED) { + configured = true; + break; + } + } + klist_iter_exit(&iter); + } + + if (configured) + state = ACPIHP_SLOT_STATE_CONFIGURED; + else if (connected) + state = ACPIHP_SLOT_STATE_CONNECTED; + else + state = ACPIHP_SLOT_STATE_POWERED; + +out: + acpihp_slot_change_state(slot, state); +} + +/* Update slot state according to status of devices connecting to it. */ +int acpihp_drv_update_slot_status(struct acpihp_slot *slot) +{ + int ret = 0; + enum acpihp_dev_type type; + struct klist_iter iter; + struct klist_node *ip; + struct acpihp_dev_node *np; + struct acpi_device *dev; + struct acpihp_dev_info *info; + + if (!slot) + return -EINVAL; + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + for (type = ACPIHP_DEV_TYPE_MEM; type <= ACPIHP_DEV_TYPE_HOST_BRIDGE; + type++) { + klist_iter_init(&slot->dev_lists[type], &iter); + while ((ip = klist_next(&iter)) != NULL) { + np = container_of(ip, struct acpihp_dev_node, node); + dev = container_of(np->dev, struct acpi_device, dev); + ret = acpihp_dev_get_info(dev, info); + if (ret) { + ACPIHP_DEBUG("fails to get info about %s.\n", + dev_name(&dev->dev)); + goto out; + } + + if (info->status & ACPIHP_DEV_STATUS_FAULT) + acpihp_slot_set_flag(slot, + ACPIHP_SLOT_FLAG_FAULT); + if (info->status & ACPIHP_DEV_STATUS_IRREMOVABLE) + acpihp_slot_set_flag(slot, + ACPIHP_SLOT_FLAG_IRREMOVABLE); + } + } + +out: + kfree(info); + + return ret; +} +EXPORT_SYMBOL(acpihp_drv_update_slot_status); + +/* Add ACPI device to hotplug slot's device list */ +static acpi_status acpihp_drv_enum_device(struct acpi_device *dev, void *argp) +{ + int ret = -ENOMEM; + acpi_status rv = AE_OK; + enum acpihp_dev_type type; + enum acpihp_dev_state state; + struct acpihp_dev_info *info; + struct acpihp_slot *slot = (struct acpihp_slot *)argp; + + if (acpihp_dev_get_type(dev->handle, &type)) { + ACPIHP_DEBUG("fails to get device type of %s.\n", + dev_name(&dev->dev)); + return AE_ERROR; + } else if (type == ACPIHP_DEV_TYPE_MAX) { + /* + * Some ACPI objects for IO devices, such as PCI/IDE etc, only + * implement _ADR instead of _HID/_CID, skip them. + */ + return AE_CTRL_DEPTH; + } + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (info) + ret = acpihp_dev_get_info(dev, info); + + if (!ret) { + if (info->status & ACPIHP_DEV_STATUS_STARTED) + state = DEVICE_STATE_CONFIGURED; + else + state = DEVICE_STATE_CONNECTED; + + if (info->status & ACPIHP_DEV_STATUS_IRREMOVABLE) + acpihp_slot_set_flag(slot, + ACPIHP_SLOT_FLAG_IRREMOVABLE); + if (info->status & ACPIHP_DEV_STATUS_FAULT) + acpihp_slot_set_flag(slot, ACPIHP_SLOT_FLAG_FAULT); + + if (acpihp_slot_add_device(slot, type, state, &dev->dev)) { + ACPIHP_DEBUG("fails to add %s to slot %s.\n", + dev_name(&dev->dev), slot->name); + rv = AE_ERROR; + } + } else { + ACPIHP_DEBUG("fails to query device info of %s.\n", + dev_name(&dev->dev)); + } + + kfree(info); + + return rv; +} + +/* + * Enumerator all devices connecting to a slot and add them onto slot's + * device lists. + */ +int acpihp_drv_enumerate_devices(struct acpihp_slot *slot) +{ + return acpihp_walk_devices(slot->handle, acpihp_drv_enum_device, slot); +} + +static void acpihp_drv_remove_devices(struct acpihp_slot *slot) +{ + enum acpihp_dev_type type; + + for (type = ACPIHP_DEV_TYPE_UNKNOWN; type < ACPIHP_DEV_TYPE_MAX; type++) + acpihp_remove_device_list(&slot->dev_lists[type]); +} + +/* Callback function for ACPI system event notification. */ +static void acpihp_drv_event_handler(acpi_handle handle, u32 event, + void *context) +{ + /* TODO: handle ACPI hotplug events */ +} + +static acpi_status acpihp_drv_install_handler(struct acpihp_slot *slot) +{ + acpi_status status; + + status = acpi_install_notify_handler(slot->handle, ACPI_SYSTEM_NOTIFY, + acpihp_drv_event_handler, slot); + ACPIHP_DEBUG("%s to install event handler for %s.\n", + ACPI_SUCCESS(status) ? "succeeds" : "fails", slot->name); + + return status; +} + +static void acpihp_drv_uninstall_handler(struct acpihp_slot *slot) +{ + acpi_status status; + + status = acpi_remove_notify_handler(slot->handle, ACPI_SYSTEM_NOTIFY, + acpihp_drv_event_handler); + ACPIHP_DEBUG("%s to uninstall event handler for %s.\n", + ACPI_SUCCESS(status) ? "succeeds" : "fails", slot->name); +} + +static int acpihp_drv_slot_add(struct device *dev, struct class_interface *intf) +{ + struct acpihp_slot_drv *drv_data; + struct acpihp_slot *slot = container_of(dev, struct acpihp_slot, dev); + + /* + * Try to hold a reference to the slot_ops structure to prevent + * the platform specific enumerator driver from unloading. + */ + if (!slot->slot_ops || !try_module_get(slot->slot_ops->owner)) { + ACPIHP_DEBUG("fails to get reference to slot_ops for %s.\n", + slot->name); + return -EINVAL; + } + + /* install ACPI event notification handler for slot */ + if (ACPI_FAILURE(acpihp_drv_install_handler(slot))) { + ACPIHP_DEBUG("fails to install event handler for %s.\n", + slot->name); + module_put(slot->slot_ops->owner); + return -EBUSY; + } + + /* Enumerate all devices if slot is already powered. */ + if (!acpihp_slot_powered(slot)) + ACPIHP_DEBUG("slot %s is powered off.\n", slot->name); + else if (acpihp_drv_enumerate_devices(slot)) + acpihp_slot_set_flag(slot, ACPIHP_SLOT_FLAG_IRREMOVABLE); + + acpihp_drv_update_slot_state(slot); + + drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL); + if (drv_data) { + drv_data->event_flag = ACPIHP_DRV_EVENT_FROM_FW; + mutex_init(&drv_data->op_mutex); + INIT_LIST_HEAD(&drv_data->depend_list); + } + if (drv_data == NULL || + acpihp_slot_attach_drv_data(slot, intf, (void *)drv_data)) { + ACPIHP_DEBUG("fails to attach driver data for %s.\n", + slot->name); + acpihp_drv_remove_devices(slot); + module_put(slot->slot_ops->owner); + kfree(drv_data); + return -ENOMEM; + } + + ACPIHP_INFO("found hotplug slot %s.\n", slot->full_path); + + return 0; +} + +static void acpihp_drv_intf_remove(struct device *dev, + struct class_interface *intf) +{ + struct acpihp_slot_drv *drv_data = NULL; + struct acpihp_slot *slot = + container_of(dev, struct acpihp_slot, dev); + + ACPIHP_INFO("remove hotplug slot %s.\n", slot->full_path); + + acpihp_drv_uninstall_handler(slot); + acpihp_drv_remove_devices(slot); + acpihp_slot_detach_drv_data(slot, intf, (void **)&drv_data); + if (drv_data != NULL) + kfree(drv_data); + + module_put(slot->slot_ops->owner); +} + +/* + * register a class driver onto the acpihp_slot_class to manage all system + * device hotplug slots. + */ +static struct class_interface acpihp_drv_interface = { + .class = &acpihp_slot_class, + .add_dev = acpihp_drv_slot_add, + .remove_dev = acpihp_drv_intf_remove, +}; + +static int __init acpihp_drv_init(void) +{ + return class_interface_register(&acpihp_drv_interface); +} + +static void __exit acpihp_drv_exit(void) +{ + class_interface_unregister(&acpihp_drv_interface); +} + +module_init(acpihp_drv_init); +module_exit(acpihp_drv_exit); + +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Jiang Liu "); +MODULE_AUTHOR("Hanjun Guo ");