1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * PCI Express 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) 2003-2004 Intel Corporation
9 *
10 * All rights reserved.
11 *
12 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
13 *
14 */
15
16#define dev_fmt(fmt) "pciehp: " fmt
17
18#include <linux/kernel.h>
19#include <linux/types.h>
20#include <linux/pm_runtime.h>
21#include <linux/pci.h>
22#include "pciehp.h"
23
24/* The following routines constitute the bulk of the
25   hotplug controller logic
26 */
27
28#define SAFE_REMOVAL	 true
29#define SURPRISE_REMOVAL false
30
31static void set_slot_off(struct controller *ctrl)
32{
33	/*
34	 * Turn off slot, turn on attention indicator, turn off power
35	 * indicator
36	 */
37	if (POWER_CTRL(ctrl)) {
38		pciehp_power_off_slot(ctrl);
39
40		/*
41		 * After turning power off, we must wait for at least 1 second
42		 * before taking any action that relies on power having been
43		 * removed from the slot/adapter.
44		 */
45		msleep(1000);
46	}
47
48	pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
49			      PCI_EXP_SLTCTL_ATTN_IND_ON);
50}
51
52/**
53 * board_added - Called after a board has been added to the system.
54 * @ctrl: PCIe hotplug controller where board is added
55 *
56 * Turns power on for the board.
57 * Configures board.
58 */
59static int board_added(struct controller *ctrl)
60{
61	int retval = 0;
62	struct pci_bus *parent = ctrl->pcie->port->subordinate;
63
64	if (POWER_CTRL(ctrl)) {
65		/* Power on slot */
66		retval = pciehp_power_on_slot(ctrl);
67		if (retval)
68			return retval;
69	}
70
71	pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK,
72			      INDICATOR_NOOP);
73
74	/* Check link training status */
75	retval = pciehp_check_link_status(ctrl);
76	if (retval)
77		goto err_exit;
78
79	/* Check for a power fault */
80	if (ctrl->power_fault_detected || pciehp_query_power_fault(ctrl)) {
81		ctrl_err(ctrl, "Slot(%s): Power fault\n", slot_name(ctrl));
82		retval = -EIO;
83		goto err_exit;
84	}
85
86	retval = pciehp_configure_device(ctrl);
87	if (retval) {
88		if (retval != -EEXIST) {
89			ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
90				 pci_domain_nr(parent), parent->number);
91			goto err_exit;
92		}
93	}
94
95	pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON,
96			      PCI_EXP_SLTCTL_ATTN_IND_OFF);
97	return 0;
98
99err_exit:
100	set_slot_off(ctrl);
101	return retval;
102}
103
104/**
105 * remove_board - Turn off slot and Power Indicator
106 * @ctrl: PCIe hotplug controller where board is being removed
107 * @safe_removal: whether the board is safely removed (versus surprise removed)
108 */
109static void remove_board(struct controller *ctrl, bool safe_removal)
110{
111	pciehp_unconfigure_device(ctrl, safe_removal);
112
113	if (POWER_CTRL(ctrl)) {
114		pciehp_power_off_slot(ctrl);
115
116		/*
117		 * After turning power off, we must wait for at least 1 second
118		 * before taking any action that relies on power having been
119		 * removed from the slot/adapter.
120		 */
121		msleep(1000);
122
123		/* Ignore link or presence changes caused by power off */
124		atomic_and(~(PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC),
125			   &ctrl->pending_events);
126	}
127
128	pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
129			      INDICATOR_NOOP);
130}
131
132static int pciehp_enable_slot(struct controller *ctrl);
133static int pciehp_disable_slot(struct controller *ctrl, bool safe_removal);
134
135void pciehp_request(struct controller *ctrl, int action)
136{
137	atomic_or(action, &ctrl->pending_events);
138	if (!pciehp_poll_mode)
139		irq_wake_thread(ctrl->pcie->irq, ctrl);
140}
141
142void pciehp_queue_pushbutton_work(struct work_struct *work)
143{
144	struct controller *ctrl = container_of(work, struct controller,
145					       button_work.work);
146
147	mutex_lock(&ctrl->state_lock);
148	switch (ctrl->state) {
149	case BLINKINGOFF_STATE:
150		pciehp_request(ctrl, DISABLE_SLOT);
151		break;
152	case BLINKINGON_STATE:
153		pciehp_request(ctrl, PCI_EXP_SLTSTA_PDC);
154		break;
155	default:
156		break;
157	}
158	mutex_unlock(&ctrl->state_lock);
159}
160
161void pciehp_handle_button_press(struct controller *ctrl)
162{
163	mutex_lock(&ctrl->state_lock);
164	switch (ctrl->state) {
165	case OFF_STATE:
166	case ON_STATE:
167		if (ctrl->state == ON_STATE) {
168			ctrl->state = BLINKINGOFF_STATE;
169			ctrl_info(ctrl, "Slot(%s): Button press: will power off in 5 sec\n",
170				  slot_name(ctrl));
171		} else {
172			ctrl->state = BLINKINGON_STATE;
173			ctrl_info(ctrl, "Slot(%s): Button press: will power on in 5 sec\n",
174				  slot_name(ctrl));
175		}
176		/* blink power indicator and turn off attention */
177		pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK,
178				      PCI_EXP_SLTCTL_ATTN_IND_OFF);
179		schedule_delayed_work(&ctrl->button_work, 5 * HZ);
180		break;
181	case BLINKINGOFF_STATE:
182	case BLINKINGON_STATE:
183		/*
184		 * Cancel if we are still blinking; this means that we
185		 * press the attention again before the 5 sec. limit
186		 * expires to cancel hot-add or hot-remove
187		 */
188		cancel_delayed_work(&ctrl->button_work);
189		if (ctrl->state == BLINKINGOFF_STATE) {
190			ctrl->state = ON_STATE;
191			pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON,
192					      PCI_EXP_SLTCTL_ATTN_IND_OFF);
193			ctrl_info(ctrl, "Slot(%s): Button press: canceling request to power off\n",
194				  slot_name(ctrl));
195		} else {
196			ctrl->state = OFF_STATE;
197			pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
198					      PCI_EXP_SLTCTL_ATTN_IND_OFF);
199			ctrl_info(ctrl, "Slot(%s): Button press: canceling request to power on\n",
200				  slot_name(ctrl));
201		}
202		break;
203	default:
204		ctrl_err(ctrl, "Slot(%s): Button press: ignoring invalid state %#x\n",
205			 slot_name(ctrl), ctrl->state);
206		break;
207	}
208	mutex_unlock(&ctrl->state_lock);
209}
210
211void pciehp_handle_disable_request(struct controller *ctrl)
212{
213	mutex_lock(&ctrl->state_lock);
214	switch (ctrl->state) {
215	case BLINKINGON_STATE:
216	case BLINKINGOFF_STATE:
217		cancel_delayed_work(&ctrl->button_work);
218		break;
219	}
220	ctrl->state = POWEROFF_STATE;
221	mutex_unlock(&ctrl->state_lock);
222
223	ctrl->request_result = pciehp_disable_slot(ctrl, SAFE_REMOVAL);
224}
225
226void pciehp_handle_presence_or_link_change(struct controller *ctrl, u32 events)
227{
228	int present, link_active;
229
230	/*
231	 * If the slot is on and presence or link has changed, turn it off.
232	 * Even if it's occupied again, we cannot assume the card is the same.
233	 */
234	mutex_lock(&ctrl->state_lock);
235	switch (ctrl->state) {
236	case BLINKINGOFF_STATE:
237		cancel_delayed_work(&ctrl->button_work);
238		fallthrough;
239	case ON_STATE:
240		ctrl->state = POWEROFF_STATE;
241		mutex_unlock(&ctrl->state_lock);
242		if (events & PCI_EXP_SLTSTA_DLLSC)
243			ctrl_info(ctrl, "Slot(%s): Link Down\n",
244				  slot_name(ctrl));
245		if (events & PCI_EXP_SLTSTA_PDC)
246			ctrl_info(ctrl, "Slot(%s): Card not present\n",
247				  slot_name(ctrl));
248		pciehp_disable_slot(ctrl, SURPRISE_REMOVAL);
249		break;
250	default:
251		mutex_unlock(&ctrl->state_lock);
252		break;
253	}
254
255	/* Turn the slot on if it's occupied or link is up */
256	mutex_lock(&ctrl->state_lock);
257	present = pciehp_card_present(ctrl);
258	link_active = pciehp_check_link_active(ctrl);
259	if (present <= 0 && link_active <= 0) {
260		if (ctrl->state == BLINKINGON_STATE) {
261			ctrl->state = OFF_STATE;
262			cancel_delayed_work(&ctrl->button_work);
263			pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
264					      INDICATOR_NOOP);
265			ctrl_info(ctrl, "Slot(%s): Card not present\n",
266				  slot_name(ctrl));
267		}
268		mutex_unlock(&ctrl->state_lock);
269		return;
270	}
271
272	switch (ctrl->state) {
273	case BLINKINGON_STATE:
274		cancel_delayed_work(&ctrl->button_work);
275		fallthrough;
276	case OFF_STATE:
277		ctrl->state = POWERON_STATE;
278		mutex_unlock(&ctrl->state_lock);
279		if (present)
280			ctrl_info(ctrl, "Slot(%s): Card present\n",
281				  slot_name(ctrl));
282		if (link_active)
283			ctrl_info(ctrl, "Slot(%s): Link Up\n",
284				  slot_name(ctrl));
285		ctrl->request_result = pciehp_enable_slot(ctrl);
286		break;
287	default:
288		mutex_unlock(&ctrl->state_lock);
289		break;
290	}
291}
292
293static int __pciehp_enable_slot(struct controller *ctrl)
294{
295	u8 getstatus = 0;
296
297	if (MRL_SENS(ctrl)) {
298		pciehp_get_latch_status(ctrl, &getstatus);
299		if (getstatus) {
300			ctrl_info(ctrl, "Slot(%s): Latch open\n",
301				  slot_name(ctrl));
302			return -ENODEV;
303		}
304	}
305
306	if (POWER_CTRL(ctrl)) {
307		pciehp_get_power_status(ctrl, &getstatus);
308		if (getstatus) {
309			ctrl_info(ctrl, "Slot(%s): Already enabled\n",
310				  slot_name(ctrl));
311			return 0;
312		}
313	}
314
315	return board_added(ctrl);
316}
317
318static int pciehp_enable_slot(struct controller *ctrl)
319{
320	int ret;
321
322	pm_runtime_get_sync(&ctrl->pcie->port->dev);
323	ret = __pciehp_enable_slot(ctrl);
324	if (ret && ATTN_BUTTN(ctrl))
325		/* may be blinking */
326		pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
327				      INDICATOR_NOOP);
328	pm_runtime_put(&ctrl->pcie->port->dev);
329
330	mutex_lock(&ctrl->state_lock);
331	ctrl->state = ret ? OFF_STATE : ON_STATE;
332	mutex_unlock(&ctrl->state_lock);
333
334	return ret;
335}
336
337static int __pciehp_disable_slot(struct controller *ctrl, bool safe_removal)
338{
339	u8 getstatus = 0;
340
341	if (POWER_CTRL(ctrl)) {
342		pciehp_get_power_status(ctrl, &getstatus);
343		if (!getstatus) {
344			ctrl_info(ctrl, "Slot(%s): Already disabled\n",
345				  slot_name(ctrl));
346			return -EINVAL;
347		}
348	}
349
350	remove_board(ctrl, safe_removal);
351	return 0;
352}
353
354static int pciehp_disable_slot(struct controller *ctrl, bool safe_removal)
355{
356	int ret;
357
358	pm_runtime_get_sync(&ctrl->pcie->port->dev);
359	ret = __pciehp_disable_slot(ctrl, safe_removal);
360	pm_runtime_put(&ctrl->pcie->port->dev);
361
362	mutex_lock(&ctrl->state_lock);
363	ctrl->state = OFF_STATE;
364	mutex_unlock(&ctrl->state_lock);
365
366	return ret;
367}
368
369int pciehp_sysfs_enable_slot(struct hotplug_slot *hotplug_slot)
370{
371	struct controller *ctrl = to_ctrl(hotplug_slot);
372
373	mutex_lock(&ctrl->state_lock);
374	switch (ctrl->state) {
375	case BLINKINGON_STATE:
376	case OFF_STATE:
377		mutex_unlock(&ctrl->state_lock);
378		/*
379		 * The IRQ thread becomes a no-op if the user pulls out the
380		 * card before the thread wakes up, so initialize to -ENODEV.
381		 */
382		ctrl->request_result = -ENODEV;
383		pciehp_request(ctrl, PCI_EXP_SLTSTA_PDC);
384		wait_event(ctrl->requester,
385			   !atomic_read(&ctrl->pending_events) &&
386			   !ctrl->ist_running);
387		return ctrl->request_result;
388	case POWERON_STATE:
389		ctrl_info(ctrl, "Slot(%s): Already in powering on state\n",
390			  slot_name(ctrl));
391		break;
392	case BLINKINGOFF_STATE:
393	case ON_STATE:
394	case POWEROFF_STATE:
395		ctrl_info(ctrl, "Slot(%s): Already enabled\n",
396			  slot_name(ctrl));
397		break;
398	default:
399		ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
400			 slot_name(ctrl), ctrl->state);
401		break;
402	}
403	mutex_unlock(&ctrl->state_lock);
404
405	return -ENODEV;
406}
407
408int pciehp_sysfs_disable_slot(struct hotplug_slot *hotplug_slot)
409{
410	struct controller *ctrl = to_ctrl(hotplug_slot);
411
412	mutex_lock(&ctrl->state_lock);
413	switch (ctrl->state) {
414	case BLINKINGOFF_STATE:
415	case ON_STATE:
416		mutex_unlock(&ctrl->state_lock);
417		pciehp_request(ctrl, DISABLE_SLOT);
418		wait_event(ctrl->requester,
419			   !atomic_read(&ctrl->pending_events) &&
420			   !ctrl->ist_running);
421		return ctrl->request_result;
422	case POWEROFF_STATE:
423		ctrl_info(ctrl, "Slot(%s): Already in powering off state\n",
424			  slot_name(ctrl));
425		break;
426	case BLINKINGON_STATE:
427	case OFF_STATE:
428	case POWERON_STATE:
429		ctrl_info(ctrl, "Slot(%s): Already disabled\n",
430			  slot_name(ctrl));
431		break;
432	default:
433		ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
434			 slot_name(ctrl), ctrl->state);
435		break;
436	}
437	mutex_unlock(&ctrl->state_lock);
438
439	return -ENODEV;
440}
441