1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Surface Book (2 and later) hot-plug driver.
  4 *
  5 * Surface Book devices (can) have a hot-pluggable discrete GPU (dGPU). This
  6 * driver is responsible for out-of-band hot-plug event signaling on these
  7 * devices. It is specifically required when the hot-plug device is in D3cold
  8 * and can thus not generate PCIe hot-plug events itself.
  9 *
 10 * Event signaling is handled via ACPI, which will generate the appropriate
 11 * device-check notifications to be picked up by the PCIe hot-plug driver.
 12 *
 13 * Copyright (C) 2019-2021 Maximilian Luz <luzmaximilian@gmail.com>
 14 */
 15
 16#include <linux/acpi.h>
 17#include <linux/gpio.h>
 18#include <linux/interrupt.h>
 19#include <linux/kernel.h>
 20#include <linux/module.h>
 21#include <linux/mutex.h>
 22#include <linux/platform_device.h>
 23
 24static const struct acpi_gpio_params shps_base_presence_int   = { 0, 0, false };
 25static const struct acpi_gpio_params shps_base_presence       = { 1, 0, false };
 26static const struct acpi_gpio_params shps_device_power_int    = { 2, 0, false };
 27static const struct acpi_gpio_params shps_device_power        = { 3, 0, false };
 28static const struct acpi_gpio_params shps_device_presence_int = { 4, 0, false };
 29static const struct acpi_gpio_params shps_device_presence     = { 5, 0, false };
 30
 31static const struct acpi_gpio_mapping shps_acpi_gpios[] = {
 32	{ "base_presence-int-gpio",   &shps_base_presence_int,   1 },
 33	{ "base_presence-gpio",       &shps_base_presence,       1 },
 34	{ "device_power-int-gpio",    &shps_device_power_int,    1 },
 35	{ "device_power-gpio",        &shps_device_power,        1 },
 36	{ "device_presence-int-gpio", &shps_device_presence_int, 1 },
 37	{ "device_presence-gpio",     &shps_device_presence,     1 },
 38	{ },
 39};
 40
 41/* 5515a847-ed55-4b27-8352-cd320e10360a */
 42static const guid_t shps_dsm_guid =
 43	GUID_INIT(0x5515a847, 0xed55, 0x4b27, 0x83, 0x52, 0xcd, 0x32, 0x0e, 0x10, 0x36, 0x0a);
 44
 45#define SHPS_DSM_REVISION		1
 46
 47enum shps_dsm_fn {
 48	SHPS_DSM_FN_PCI_NUM_ENTRIES	= 0x01,
 49	SHPS_DSM_FN_PCI_GET_ENTRIES	= 0x02,
 50	SHPS_DSM_FN_IRQ_BASE_PRESENCE	= 0x03,
 51	SHPS_DSM_FN_IRQ_DEVICE_POWER	= 0x04,
 52	SHPS_DSM_FN_IRQ_DEVICE_PRESENCE	= 0x05,
 53};
 54
 55enum shps_irq_type {
 56	/* NOTE: Must be in order of enum shps_dsm_fn above. */
 57	SHPS_IRQ_TYPE_BASE_PRESENCE	= 0,
 58	SHPS_IRQ_TYPE_DEVICE_POWER	= 1,
 59	SHPS_IRQ_TYPE_DEVICE_PRESENCE	= 2,
 60	SHPS_NUM_IRQS,
 61};
 62
 63static const char *const shps_gpio_names[] = {
 64	[SHPS_IRQ_TYPE_BASE_PRESENCE]	= "base_presence",
 65	[SHPS_IRQ_TYPE_DEVICE_POWER]	= "device_power",
 66	[SHPS_IRQ_TYPE_DEVICE_PRESENCE]	= "device_presence",
 67};
 68
 69struct shps_device {
 70	struct mutex lock[SHPS_NUM_IRQS];  /* Protects update in shps_dsm_notify_irq() */
 71	struct gpio_desc *gpio[SHPS_NUM_IRQS];
 72	unsigned int irq[SHPS_NUM_IRQS];
 73};
 74
 75#define SHPS_IRQ_NOT_PRESENT		((unsigned int)-1)
 76
 77static enum shps_dsm_fn shps_dsm_fn_for_irq(enum shps_irq_type type)
 78{
 79	return SHPS_DSM_FN_IRQ_BASE_PRESENCE + type;
 80}
 81
 82static void shps_dsm_notify_irq(struct platform_device *pdev, enum shps_irq_type type)
 83{
 84	struct shps_device *sdev = platform_get_drvdata(pdev);
 85	acpi_handle handle = ACPI_HANDLE(&pdev->dev);
 86	union acpi_object *result;
 87	union acpi_object param;
 88	int value;
 89
 90	mutex_lock(&sdev->lock[type]);
 91
 92	value = gpiod_get_value_cansleep(sdev->gpio[type]);
 93	if (value < 0) {
 94		mutex_unlock(&sdev->lock[type]);
 95		dev_err(&pdev->dev, "failed to get gpio: %d (irq=%d)\n", type, value);
 96		return;
 97	}
 98
 99	dev_dbg(&pdev->dev, "IRQ notification via DSM (irq=%d, value=%d)\n", type, value);
100
101	param.type = ACPI_TYPE_INTEGER;
102	param.integer.value = value;
103
104	result = acpi_evaluate_dsm(handle, &shps_dsm_guid, SHPS_DSM_REVISION,
105				   shps_dsm_fn_for_irq(type), &param);
106
107	if (!result) {
108		dev_err(&pdev->dev, "IRQ notification via DSM failed (irq=%d, gpio=%d)\n",
109			type, value);
110
111	} else if (result->type != ACPI_TYPE_BUFFER) {
112		dev_err(&pdev->dev,
113			"IRQ notification via DSM failed: unexpected result type (irq=%d, gpio=%d)\n",
114			type, value);
115
116	} else if (result->buffer.length != 1 || result->buffer.pointer[0] != 0) {
117		dev_err(&pdev->dev,
118			"IRQ notification via DSM failed: unexpected result value (irq=%d, gpio=%d)\n",
119			type, value);
120	}
121
122	mutex_unlock(&sdev->lock[type]);
123
124	if (result)
125		ACPI_FREE(result);
126}
127
128static irqreturn_t shps_handle_irq(int irq, void *data)
129{
130	struct platform_device *pdev = data;
131	struct shps_device *sdev = platform_get_drvdata(pdev);
132	int type;
133
134	/* Figure out which IRQ we're handling. */
135	for (type = 0; type < SHPS_NUM_IRQS; type++)
136		if (irq == sdev->irq[type])
137			break;
138
139	/* We should have found our interrupt, if not: this is a bug. */
140	if (WARN(type >= SHPS_NUM_IRQS, "invalid IRQ number: %d\n", irq))
141		return IRQ_HANDLED;
142
143	/* Forward interrupt to ACPI via DSM. */
144	shps_dsm_notify_irq(pdev, type);
145	return IRQ_HANDLED;
146}
147
148static int shps_setup_irq(struct platform_device *pdev, enum shps_irq_type type)
149{
150	unsigned long flags = IRQF_ONESHOT | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
151	struct shps_device *sdev = platform_get_drvdata(pdev);
152	struct gpio_desc *gpiod;
153	acpi_handle handle = ACPI_HANDLE(&pdev->dev);
154	const char *irq_name;
155	const int dsm = shps_dsm_fn_for_irq(type);
156	int status, irq;
157
158	/*
159	 * Only set up interrupts that we actually need: The Surface Book 3
160	 * does not have a DSM for base presence, so don't set up an interrupt
161	 * for that.
162	 */
163	if (!acpi_check_dsm(handle, &shps_dsm_guid, SHPS_DSM_REVISION, BIT(dsm))) {
164		dev_dbg(&pdev->dev, "IRQ notification via DSM not present (irq=%d)\n", type);
165		return 0;
166	}
167
168	gpiod = devm_gpiod_get(&pdev->dev, shps_gpio_names[type], GPIOD_ASIS);
169	if (IS_ERR(gpiod))
170		return PTR_ERR(gpiod);
171
172	irq = gpiod_to_irq(gpiod);
173	if (irq < 0)
174		return irq;
175
176	irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "shps-irq-%d", type);
177	if (!irq_name)
178		return -ENOMEM;
179
180	status = devm_request_threaded_irq(&pdev->dev, irq, NULL, shps_handle_irq,
181					   flags, irq_name, pdev);
182	if (status)
183		return status;
184
185	dev_dbg(&pdev->dev, "set up irq %d as type %d\n", irq, type);
186
187	sdev->gpio[type] = gpiod;
188	sdev->irq[type] = irq;
189
190	return 0;
191}
192
193static int surface_hotplug_remove(struct platform_device *pdev)
194{
195	struct shps_device *sdev = platform_get_drvdata(pdev);
196	int i;
197
198	/* Ensure that IRQs have been fully handled and won't trigger any more. */
199	for (i = 0; i < SHPS_NUM_IRQS; i++) {
200		if (sdev->irq[i] != SHPS_IRQ_NOT_PRESENT)
201			disable_irq(sdev->irq[i]);
202
203		mutex_destroy(&sdev->lock[i]);
204	}
205
206	return 0;
207}
208
209static int surface_hotplug_probe(struct platform_device *pdev)
210{
211	struct shps_device *sdev;
212	int status, i;
213
214	/*
215	 * The MSHW0153 device is also present on the Surface Laptop 3,
216	 * however that doesn't have a hot-pluggable PCIe device. It also
217	 * doesn't have any GPIO interrupts/pins under the MSHW0153, so filter
218	 * it out here.
219	 */
220	if (gpiod_count(&pdev->dev, NULL) < 0)
221		return -ENODEV;
222
223	status = devm_acpi_dev_add_driver_gpios(&pdev->dev, shps_acpi_gpios);
224	if (status)
225		return status;
226
227	sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
228	if (!sdev)
229		return -ENOMEM;
230
231	platform_set_drvdata(pdev, sdev);
232
233	/*
234	 * Initialize IRQs so that we can safely call surface_hotplug_remove()
235	 * on errors.
236	 */
237	for (i = 0; i < SHPS_NUM_IRQS; i++)
238		sdev->irq[i] = SHPS_IRQ_NOT_PRESENT;
239
240	/* Set up IRQs. */
241	for (i = 0; i < SHPS_NUM_IRQS; i++) {
242		mutex_init(&sdev->lock[i]);
243
244		status = shps_setup_irq(pdev, i);
245		if (status) {
246			dev_err(&pdev->dev, "failed to set up IRQ %d: %d\n", i, status);
247			goto err;
248		}
249	}
250
251	/* Ensure everything is up-to-date. */
252	for (i = 0; i < SHPS_NUM_IRQS; i++)
253		if (sdev->irq[i] != SHPS_IRQ_NOT_PRESENT)
254			shps_dsm_notify_irq(pdev, i);
255
256	return 0;
257
258err:
259	surface_hotplug_remove(pdev);
260	return status;
261}
262
263static const struct acpi_device_id surface_hotplug_acpi_match[] = {
264	{ "MSHW0153", 0 },
265	{ },
266};
267MODULE_DEVICE_TABLE(acpi, surface_hotplug_acpi_match);
268
269static struct platform_driver surface_hotplug_driver = {
270	.probe = surface_hotplug_probe,
271	.remove = surface_hotplug_remove,
272	.driver = {
273		.name = "surface_hotplug",
274		.acpi_match_table = surface_hotplug_acpi_match,
275		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
276	},
277};
278module_platform_driver(surface_hotplug_driver);
279
280MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
281MODULE_DESCRIPTION("Surface Hot-Plug Signaling Driver for Surface Book Devices");
282MODULE_LICENSE("GPL");