[mirror_ubuntu-focal-kernel.git] / drivers / pci / hotplug / acpiphp_core.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * ACPI PCI Hot Plug Controller Driver
 *
 * Copyright (C) 1995,2001 Compaq Computer Corporation
 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2001 IBM Corp.
 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
 * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
 * Copyright (C) 2002,2003 NEC Corporation
 * Copyright (C) 2003-2005 Matthew Wilcox (willy@infradead.org)
 * Copyright (C) 2003-2005 Hewlett Packard
 *
 * All rights reserved.
 *
 * Send feedback to <kristen.c.accardi@intel.com>
 *
 */

#define pr_fmt(fmt) "acpiphp: " fmt

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/pci-acpi.h>
#include <linux/pci_hotplug.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include "acpiphp.h"

/* name size which is used for entries in pcihpfs */
#define SLOT_NAME_SIZE  21              /* {_SUN} */

bool acpiphp_disabled;

/* local variables */
static struct acpiphp_attention_info *attention_info;

#define DRIVER_VERSION	"0.5"
#define DRIVER_AUTHOR	"Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@infradead.org>"
#define DRIVER_DESC	"ACPI Hot Plug PCI Controller Driver"

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
MODULE_PARM_DESC(disable, "disable acpiphp driver");
module_param_named(disable, acpiphp_disabled, bool, 0444);

static int enable_slot(struct hotplug_slot *slot);
static int disable_slot(struct hotplug_slot *slot);
static int set_attention_status(struct hotplug_slot *slot, u8 value);
static int get_power_status(struct hotplug_slot *slot, u8 *value);
static int get_attention_status(struct hotplug_slot *slot, u8 *value);
static int get_latch_status(struct hotplug_slot *slot, u8 *value);
static int get_adapter_status(struct hotplug_slot *slot, u8 *value);

static const struct hotplug_slot_ops acpi_hotplug_slot_ops = {
	.enable_slot		= enable_slot,
	.disable_slot		= disable_slot,
	.set_attention_status	= set_attention_status,
	.get_power_status	= get_power_status,
	.get_attention_status	= get_attention_status,
	.get_latch_status	= get_latch_status,
	.get_adapter_status	= get_adapter_status,
};

/**
 * acpiphp_register_attention - set attention LED callback
 * @info: must be completely filled with LED callbacks
 *
 * Description: This is used to register a hardware specific ACPI
 * driver that manipulates the attention LED.  All the fields in
 * info must be set.
 */
int acpiphp_register_attention(struct acpiphp_attention_info *info)
{
	int retval = -EINVAL;

	if (info && info->owner && info->set_attn &&
			info->get_attn && !attention_info) {
		retval = 0;
		attention_info = info;
	}
	return retval;
}
EXPORT_SYMBOL_GPL(acpiphp_register_attention);


/**
 * acpiphp_unregister_attention - unset attention LED callback
 * @info: must match the pointer used to register
 *
 * Description: This is used to un-register a hardware specific acpi
 * driver that manipulates the attention LED.  The pointer to the
 * info struct must be the same as the one used to set it.
 */
int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
{
	int retval = -EINVAL;

	if (info && attention_info == info) {
		attention_info = NULL;
		retval = 0;
	}
	return retval;
}
EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);


/**
 * enable_slot - power on and enable a slot
 * @hotplug_slot: slot to enable
 *
 * Actual tasks are done in acpiphp_enable_slot()
 */
static int enable_slot(struct hotplug_slot *hotplug_slot)
{
	struct slot *slot = to_slot(hotplug_slot);

	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));

	/* enable the specified slot */
	return acpiphp_enable_slot(slot->acpi_slot);
}


/**
 * disable_slot - disable and power off a slot
 * @hotplug_slot: slot to disable
 *
 * Actual tasks are done in acpiphp_disable_slot()
 */
static int disable_slot(struct hotplug_slot *hotplug_slot)
{
	struct slot *slot = to_slot(hotplug_slot);

	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));

	/* disable the specified slot */
	return acpiphp_disable_slot(slot->acpi_slot);
}


/**
 * set_attention_status - set attention LED
 * @hotplug_slot: slot to set attention LED on
 * @status: value to set attention LED to (0 or 1)
 *
 * attention status LED, so we use a callback that
 * was registered with us.  This allows hardware specific
 * ACPI implementations to blink the light for us.
 */
static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
{
	int retval = -ENODEV;

	pr_debug("%s - physical_slot = %s\n", __func__,
		hotplug_slot_name(hotplug_slot));

	if (attention_info && try_module_get(attention_info->owner)) {
		retval = attention_info->set_attn(hotplug_slot, status);
		module_put(attention_info->owner);
	} else
		attention_info = NULL;
	return retval;
}


/**
 * get_power_status - get power status of a slot
 * @hotplug_slot: slot to get status
 * @value: pointer to store status
 *
 * Some platforms may not implement _STA method properly.
 * In that case, the value returned may not be reliable.
 */
static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = to_slot(hotplug_slot);

	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));

	*value = acpiphp_get_power_status(slot->acpi_slot);

	return 0;
}


/**
 * get_attention_status - get attention LED status
 * @hotplug_slot: slot to get status from
 * @value: returns with value of attention LED
 *
 * ACPI doesn't have known method to determine the state
 * of the attention status LED, so we use a callback that
 * was registered with us.  This allows hardware specific
 * ACPI implementations to determine its state.
 */
static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	int retval = -EINVAL;

	pr_debug("%s - physical_slot = %s\n", __func__,
		hotplug_slot_name(hotplug_slot));

	if (attention_info && try_module_get(attention_info->owner)) {
		retval = attention_info->get_attn(hotplug_slot, value);
		module_put(attention_info->owner);
	} else
		attention_info = NULL;
	return retval;
}


/**
 * get_latch_status - get latch status of a slot
 * @hotplug_slot: slot to get status
 * @value: pointer to store status
 *
 * ACPI doesn't provide any formal means to access latch status.
 * Instead, we fake latch status from _STA.
 */
static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = to_slot(hotplug_slot);

	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));

	*value = acpiphp_get_latch_status(slot->acpi_slot);

	return 0;
}


/**
 * get_adapter_status - get adapter status of a slot
 * @hotplug_slot: slot to get status
 * @value: pointer to store status
 *
 * ACPI doesn't provide any formal means to access adapter status.
 * Instead, we fake adapter status from _STA.
 */
static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
{
	struct slot *slot = to_slot(hotplug_slot);

	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));

	*value = acpiphp_get_adapter_status(slot->acpi_slot);

	return 0;
}

/* callback routine to initialize 'struct slot' for each slot */
int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot,
				  unsigned int sun)
{
	struct slot *slot;
	int retval = -ENOMEM;
	char name[SLOT_NAME_SIZE];

	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	if (!slot)
		goto error;

	slot->hotplug_slot.ops = &acpi_hotplug_slot_ops;

	slot->acpi_slot = acpiphp_slot;

	acpiphp_slot->slot = slot;
	slot->sun = sun;
	snprintf(name, SLOT_NAME_SIZE, "%u", sun);

	retval = pci_hp_register(&slot->hotplug_slot, acpiphp_slot->bus,
				 acpiphp_slot->device, name);
	if (retval == -EBUSY)
		goto error_slot;
	if (retval) {
		pr_err("pci_hp_register failed with error %d\n", retval);
		goto error_slot;
	}

	pr_info("Slot [%s] registered\n", slot_name(slot));

	return 0;
error_slot:
	kfree(slot);
error:
	return retval;
}


void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
{
	struct slot *slot = acpiphp_slot->slot;

	pr_info("Slot [%s] unregistered\n", slot_name(slot));

	pci_hp_deregister(&slot->hotplug_slot);
	kfree(slot);
}


void __init acpiphp_init(void)
{
	pr_info(DRIVER_DESC " version: " DRIVER_VERSION "%s\n",
		acpiphp_disabled ? ", disabled by user; please report a bug"
				 : "");
}
Commit	Line	Data
736759ef	1	// SPDX-License-Identifier: GPL-2.0+
1da177e4 LT	2	/*
	3	* ACPI PCI Hot Plug Controller Driver
	4	*
	5	* Copyright (C) 1995,2001 Compaq Computer Corporation
	6	* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
	7	* Copyright (C) 2001 IBM Corp.
	8	* Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
	9	* Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
	10	* Copyright (C) 2002,2003 NEC Corporation
3d0186bb	11	* Copyright (C) 2003-2005 Matthew Wilcox (willy@infradead.org)
42f49a6a	12	* Copyright (C) 2003-2005 Hewlett Packard
1da177e4 LT	13	*
	14	* All rights reserved.
	15	*
998be20f	16	* Send feedback to <kristen.c.accardi@intel.com>
1da177e4 LT	17	*
	18	*/
	19
bd950799 LT	20	#define pr_fmt(fmt) "acpiphp: " fmt
bd950799 LT	21
1da177e4 LT	22	#include <linux/init.h>
	23	#include <linux/module.h>
	24	#include <linux/moduleparam.h>
	25
	26	#include <linux/kernel.h>
	27	#include <linux/pci.h>
3b63aaa7	28	#include <linux/pci-acpi.h>
7a54f25c	29	#include <linux/pci_hotplug.h>
1da177e4 LT	30	#include <linux/slab.h>
1da177e4 LT	31	#include <linux/smp.h>
1da177e4 LT	32	#include "acpiphp.h"
1da177e4 LT	33
df77cd10 AC	34	/* name size which is used for entries in pcihpfs */
	35	#define SLOT_NAME_SIZE 21 /* {_SUN} */
	36
6037a803	37	bool acpiphp_disabled;
1da177e4 LT	38
1da177e4 LT	39	/* local variables */
1da177e4 LT	40	static struct acpiphp_attention_info *attention_info;
1da177e4 LT	41
42f49a6a	42	#define DRIVER_VERSION "0.5"
3d0186bb	43	#define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@infradead.org>"
1da177e4 LT	44	#define DRIVER_DESC "ACPI Hot Plug PCI Controller Driver"
	45
	46	MODULE_AUTHOR(DRIVER_AUTHOR);
	47	MODULE_DESCRIPTION(DRIVER_DESC);
	48	MODULE_LICENSE("GPL");
6037a803	49	MODULE_PARM_DESC(disable, "disable acpiphp driver");
6037a803	50	module_param_named(disable, acpiphp_disabled, bool, 0444);
1da177e4	51
ff3ce480 BS	52	static int enable_slot(struct hotplug_slot *slot);
	53	static int disable_slot(struct hotplug_slot *slot);
	54	static int set_attention_status(struct hotplug_slot *slot, u8 value);
	55	static int get_power_status(struct hotplug_slot slot, u8 value);
	56	static int get_attention_status(struct hotplug_slot slot, u8 value);
	57	static int get_latch_status(struct hotplug_slot slot, u8 value);
	58	static int get_adapter_status(struct hotplug_slot slot, u8 value);
1da177e4	59
81c4b5bf	60	static const struct hotplug_slot_ops acpi_hotplug_slot_ops = {
1da177e4 LT	61	.enable_slot = enable_slot,
	62	.disable_slot = disable_slot,
	63	.set_attention_status = set_attention_status,
	64	.get_power_status = get_power_status,
	65	.get_attention_status = get_attention_status,
	66	.get_latch_status = get_latch_status,
	67	.get_adapter_status = get_adapter_status,
1da177e4 LT	68	};
1da177e4 LT	69
1da177e4 LT	70	/**
	71	* acpiphp_register_attention - set attention LED callback
	72	* @info: must be completely filled with LED callbacks
	73	*
26e6c66e	74	* Description: This is used to register a hardware specific ACPI
1da177e4 LT	75	* driver that manipulates the attention LED. All the fields in
1da177e4 LT	76	* info must be set.
26e6c66e	77	*/
1da177e4 LT	78	int acpiphp_register_attention(struct acpiphp_attention_info *info)
	79	{
	80	int retval = -EINVAL;
	81
	82	if (info && info->owner && info->set_attn &&
	83	info->get_attn && !attention_info) {
	84	retval = 0;
	85	attention_info = info;
	86	}
	87	return retval;
	88	}
b7fe9434	89	EXPORT_SYMBOL_GPL(acpiphp_register_attention);
1da177e4 LT	90
	91
	92	/**
	93	* acpiphp_unregister_attention - unset attention LED callback
	94	* @info: must match the pointer used to register
	95	*
26e6c66e	96	* Description: This is used to un-register a hardware specific acpi
f7625980	97	* driver that manipulates the attention LED. The pointer to the
1da177e4	98	* info struct must be the same as the one used to set it.
26e6c66e	99	*/
1da177e4 LT	100	int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
	101	{
	102	int retval = -EINVAL;
	103
	104	if (info && attention_info == info) {
	105	attention_info = NULL;
	106	retval = 0;
	107	}
	108	return retval;
	109	}
b7fe9434	110	EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
1da177e4 LT	111
	112
	113	/**
	114	* enable_slot - power on and enable a slot
	115	* @hotplug_slot: slot to enable
	116	*
	117	* Actual tasks are done in acpiphp_enable_slot()
1da177e4 LT	118	*/
	119	static int enable_slot(struct hotplug_slot *hotplug_slot)
	120	{
125450f8	121	struct slot *slot = to_slot(hotplug_slot);
1da177e4	122
bd950799	123	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
1da177e4 LT	124
	125	/* enable the specified slot */
	126	return acpiphp_enable_slot(slot->acpi_slot);
	127	}
	128
	129
	130	/**
	131	* disable_slot - disable and power off a slot
	132	* @hotplug_slot: slot to disable
	133	*
	134	* Actual tasks are done in acpiphp_disable_slot()
1da177e4 LT	135	*/
	136	static int disable_slot(struct hotplug_slot *hotplug_slot)
	137	{
125450f8	138	struct slot *slot = to_slot(hotplug_slot);
1da177e4	139
bd950799	140	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
1da177e4 LT	141
1da177e4 LT	142	/* disable the specified slot */
9217a984	143	return acpiphp_disable_slot(slot->acpi_slot);
1da177e4 LT	144	}
	145
	146
26e6c66e RD	147	/**
26e6c66e RD	148	* set_attention_status - set attention LED
1da177e4 LT	149	* @hotplug_slot: slot to set attention LED on
	150	* @status: value to set attention LED to (0 or 1)
	151	*
	152	* attention status LED, so we use a callback that
	153	* was registered with us. This allows hardware specific
	154	* ACPI implementations to blink the light for us.
26e6c66e	155	*/
f7625980 BH	156	static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
f7625980 BH	157	{
1da177e4 LT	158	int retval = -ENODEV;
1da177e4 LT	159
bd950799 LT	160	pr_debug("%s - physical_slot = %s\n", __func__,
	161	hotplug_slot_name(hotplug_slot));
	162
1da177e4 LT	163	if (attention_info && try_module_get(attention_info->owner)) {
	164	retval = attention_info->set_attn(hotplug_slot, status);
	165	module_put(attention_info->owner);
	166	} else
	167	attention_info = NULL;
	168	return retval;
f7625980 BH	169	}
f7625980 BH	170
1da177e4 LT	171
	172	/**
	173	* get_power_status - get power status of a slot
	174	* @hotplug_slot: slot to get status
	175	* @value: pointer to store status
	176	*
	177	* Some platforms may not implement _STA method properly.
	178	* In that case, the value returned may not be reliable.
1da177e4 LT	179	*/
	180	static int get_power_status(struct hotplug_slot hotplug_slot, u8 value)
	181	{
125450f8	182	struct slot *slot = to_slot(hotplug_slot);
1da177e4	183
bd950799	184	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
1da177e4 LT	185
	186	*value = acpiphp_get_power_status(slot->acpi_slot);
	187
	188	return 0;
	189	}
	190
	191
26e6c66e	192	/**
1da177e4 LT	193	* get_attention_status - get attention LED status
	194	* @hotplug_slot: slot to get status from
	195	* @value: returns with value of attention LED
	196	*
	197	* ACPI doesn't have known method to determine the state
	198	* of the attention status LED, so we use a callback that
	199	* was registered with us. This allows hardware specific
26e6c66e RD	200	* ACPI implementations to determine its state.
26e6c66e RD	201	*/
1da177e4 LT	202	static int get_attention_status(struct hotplug_slot hotplug_slot, u8 value)
	203	{
	204	int retval = -EINVAL;
	205
bd950799 LT	206	pr_debug("%s - physical_slot = %s\n", __func__,
bd950799 LT	207	hotplug_slot_name(hotplug_slot));
1da177e4 LT	208
	209	if (attention_info && try_module_get(attention_info->owner)) {
	210	retval = attention_info->get_attn(hotplug_slot, value);
	211	module_put(attention_info->owner);
	212	} else
	213	attention_info = NULL;
	214	return retval;
	215	}
	216
	217
	218	/**
	219	* get_latch_status - get latch status of a slot
	220	* @hotplug_slot: slot to get status
	221	* @value: pointer to store status
	222	*
	223	* ACPI doesn't provide any formal means to access latch status.
26e6c66e	224	* Instead, we fake latch status from _STA.
1da177e4 LT	225	*/
	226	static int get_latch_status(struct hotplug_slot hotplug_slot, u8 value)
	227	{
125450f8	228	struct slot *slot = to_slot(hotplug_slot);
1da177e4	229
bd950799	230	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
1da177e4 LT	231
	232	*value = acpiphp_get_latch_status(slot->acpi_slot);
	233
	234	return 0;
	235	}
	236
	237
	238	/**
	239	* get_adapter_status - get adapter status of a slot
	240	* @hotplug_slot: slot to get status
	241	* @value: pointer to store status
	242	*
	243	* ACPI doesn't provide any formal means to access adapter status.
26e6c66e	244	* Instead, we fake adapter status from _STA.
1da177e4 LT	245	*/
	246	static int get_adapter_status(struct hotplug_slot hotplug_slot, u8 value)
	247	{
125450f8	248	struct slot *slot = to_slot(hotplug_slot);
1da177e4	249
bd950799	250	pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
1da177e4 LT	251
	252	*value = acpiphp_get_adapter_status(slot->acpi_slot);
	253
	254	return 0;
	255	}
	256
e27da381	257	/* callback routine to initialize 'struct slot' for each slot */
7342798d RW	258	int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot,
7342798d RW	259	unsigned int sun)
1da177e4 LT	260	{
	261	struct slot *slot;
	262	int retval = -ENOMEM;
df77cd10	263	char name[SLOT_NAME_SIZE];
e27da381 MT	264
	265	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	266	if (!slot)
	267	goto error;
	268
125450f8	269	slot->hotplug_slot.ops = &acpi_hotplug_slot_ops;
e27da381 MT	270
e27da381 MT	271	slot->acpi_slot = acpiphp_slot;
e27da381 MT	272
e27da381 MT	273	acpiphp_slot->slot = slot;
7342798d RW	274	slot->sun = sun;
7342798d RW	275	snprintf(name, SLOT_NAME_SIZE, "%u", sun);
e27da381	276
125450f8	277	retval = pci_hp_register(&slot->hotplug_slot, acpiphp_slot->bus,
bda46dbb	278	acpiphp_slot->device, name);
f46753c5	279	if (retval == -EBUSY)
125450f8	280	goto error_slot;
e27da381	281	if (retval) {
bd950799	282	pr_err("pci_hp_register failed with error %d\n", retval);
125450f8	283	goto error_slot;
f7625980	284	}
e27da381	285
bd950799	286	pr_info("Slot [%s] registered\n", slot_name(slot));
1da177e4 LT	287
1da177e4 LT	288	return 0;
1da177e4 LT	289	error_slot:
	290	kfree(slot);
	291	error:
	292	return retval;
	293	}
	294
	295
e27da381	296	void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
1da177e4	297	{
e27da381	298	struct slot *slot = acpiphp_slot->slot;
1da177e4	299
bd950799	300	pr_info("Slot [%s] unregistered\n", slot_name(slot));
e27da381	301
125450f8	302	pci_hp_deregister(&slot->hotplug_slot);
51bbf9be	303	kfree(slot);
1da177e4 LT	304	}
	305
	306
3b63aaa7	307	void __init acpiphp_init(void)
1da177e4	308	{
bd950799	309	pr_info(DRIVER_DESC " version: " DRIVER_VERSION "%s\n",
6037a803 JL	310	acpiphp_disabled ? ", disabled by user; please report a bug"
6037a803 JL	311	: "");
1da177e4	312	}