xref: /linux/drivers/pci/hotplug/pciehp_ctrl.c (revision 160b8e75932fd51a49607d32dbfa1d417977b79c) 
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 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/slab.h>
20 #include <linux/pci.h>
21 #include "../pci.h"
22 #include "pciehp.h"
23 
24 static void interrupt_event_handler(struct work_struct *work);
25 
26 void pciehp_queue_interrupt_event(struct slot *p_slot, u32 event_type)
27 {
28 	struct event_info *info;
29 
30 	info = kmalloc(sizeof(*info), GFP_ATOMIC);
31 	if (!info) {
32 		ctrl_err(p_slot->ctrl, "dropped event %d (ENOMEM)\n", event_type);
33 		return;
34 	}
35 
36 	INIT_WORK(&info->work, interrupt_event_handler);
37 	info->event_type = event_type;
38 	info->p_slot = p_slot;
39 	queue_work(p_slot->wq, &info->work);
40 }
41 
42 /* The following routines constitute the bulk of the
43    hotplug controller logic
44  */
45 
46 static void set_slot_off(struct controller *ctrl, struct slot *pslot)
47 {
48 	/* turn off slot, turn on Amber LED, turn off Green LED if supported*/
49 	if (POWER_CTRL(ctrl)) {
50 		pciehp_power_off_slot(pslot);
51 
52 		/*
53 		 * After turning power off, we must wait for at least 1 second
54 		 * before taking any action that relies on power having been
55 		 * removed from the slot/adapter.
56 		 */
57 		msleep(1000);
58 	}
59 
60 	pciehp_green_led_off(pslot);
61 	pciehp_set_attention_status(pslot, 1);
62 }
63 
64 /**
65  * board_added - Called after a board has been added to the system.
66  * @p_slot: &slot where board is added
67  *
68  * Turns power on for the board.
69  * Configures board.
70  */
71 static int board_added(struct slot *p_slot)
72 {
73 	int retval = 0;
74 	struct controller *ctrl = p_slot->ctrl;
75 	struct pci_bus *parent = ctrl->pcie->port->subordinate;
76 
77 	if (POWER_CTRL(ctrl)) {
78 		/* Power on slot */
79 		retval = pciehp_power_on_slot(p_slot);
80 		if (retval)
81 			return retval;
82 	}
83 
84 	pciehp_green_led_blink(p_slot);
85 
86 	/* Check link training status */
87 	retval = pciehp_check_link_status(ctrl);
88 	if (retval) {
89 		ctrl_err(ctrl, "Failed to check link status\n");
90 		goto err_exit;
91 	}
92 
93 	/* Check for a power fault */
94 	if (ctrl->power_fault_detected || pciehp_query_power_fault(p_slot)) {
95 		ctrl_err(ctrl, "Slot(%s): Power fault\n", slot_name(p_slot));
96 		retval = -EIO;
97 		goto err_exit;
98 	}
99 
100 	retval = pciehp_configure_device(p_slot);
101 	if (retval) {
102 		if (retval != -EEXIST) {
103 			ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
104 				 pci_domain_nr(parent), parent->number);
105 			goto err_exit;
106 		}
107 	}
108 
109 	pciehp_green_led_on(p_slot);
110 	pciehp_set_attention_status(p_slot, 0);
111 	return 0;
112 
113 err_exit:
114 	set_slot_off(ctrl, p_slot);
115 	return retval;
116 }
117 
118 /**
119  * remove_board - Turns off slot and LEDs
120  * @p_slot: slot where board is being removed
121  */
122 static int remove_board(struct slot *p_slot)
123 {
124 	int retval;
125 	struct controller *ctrl = p_slot->ctrl;
126 
127 	retval = pciehp_unconfigure_device(p_slot);
128 	if (retval)
129 		return retval;
130 
131 	if (POWER_CTRL(ctrl)) {
132 		pciehp_power_off_slot(p_slot);
133 
134 		/*
135 		 * After turning power off, we must wait for at least 1 second
136 		 * before taking any action that relies on power having been
137 		 * removed from the slot/adapter.
138 		 */
139 		msleep(1000);
140 	}
141 
142 	/* turn off Green LED */
143 	pciehp_green_led_off(p_slot);
144 	return 0;
145 }
146 
147 struct power_work_info {
148 	struct slot *p_slot;
149 	struct work_struct work;
150 	unsigned int req;
151 #define DISABLE_REQ 0
152 #define ENABLE_REQ  1
153 };
154 
155 /**
156  * pciehp_power_thread - handle pushbutton events
157  * @work: &struct work_struct describing work to be done
158  *
159  * Scheduled procedure to handle blocking stuff for the pushbuttons.
160  * Handles all pending events and exits.
161  */
162 static void pciehp_power_thread(struct work_struct *work)
163 {
164 	struct power_work_info *info =
165 		container_of(work, struct power_work_info, work);
166 	struct slot *p_slot = info->p_slot;
167 	int ret;
168 
169 	switch (info->req) {
170 	case DISABLE_REQ:
171 		mutex_lock(&p_slot->hotplug_lock);
172 		pciehp_disable_slot(p_slot);
173 		mutex_unlock(&p_slot->hotplug_lock);
174 		mutex_lock(&p_slot->lock);
175 		p_slot->state = STATIC_STATE;
176 		mutex_unlock(&p_slot->lock);
177 		break;
178 	case ENABLE_REQ:
179 		mutex_lock(&p_slot->hotplug_lock);
180 		ret = pciehp_enable_slot(p_slot);
181 		mutex_unlock(&p_slot->hotplug_lock);
182 		if (ret)
183 			pciehp_green_led_off(p_slot);
184 		mutex_lock(&p_slot->lock);
185 		p_slot->state = STATIC_STATE;
186 		mutex_unlock(&p_slot->lock);
187 		break;
188 	default:
189 		break;
190 	}
191 
192 	kfree(info);
193 }
194 
195 static void pciehp_queue_power_work(struct slot *p_slot, int req)
196 {
197 	struct power_work_info *info;
198 
199 	p_slot->state = (req == ENABLE_REQ) ? POWERON_STATE : POWEROFF_STATE;
200 
201 	info = kmalloc(sizeof(*info), GFP_KERNEL);
202 	if (!info) {
203 		ctrl_err(p_slot->ctrl, "no memory to queue %s request\n",
204 			 (req == ENABLE_REQ) ? "poweron" : "poweroff");
205 		return;
206 	}
207 	info->p_slot = p_slot;
208 	INIT_WORK(&info->work, pciehp_power_thread);
209 	info->req = req;
210 	queue_work(p_slot->wq, &info->work);
211 }
212 
213 void pciehp_queue_pushbutton_work(struct work_struct *work)
214 {
215 	struct slot *p_slot = container_of(work, struct slot, work.work);
216 
217 	mutex_lock(&p_slot->lock);
218 	switch (p_slot->state) {
219 	case BLINKINGOFF_STATE:
220 		pciehp_queue_power_work(p_slot, DISABLE_REQ);
221 		break;
222 	case BLINKINGON_STATE:
223 		pciehp_queue_power_work(p_slot, ENABLE_REQ);
224 		break;
225 	default:
226 		break;
227 	}
228 	mutex_unlock(&p_slot->lock);
229 }
230 
231 /*
232  * Note: This function must be called with slot->lock held
233  */
234 static void handle_button_press_event(struct slot *p_slot)
235 {
236 	struct controller *ctrl = p_slot->ctrl;
237 	u8 getstatus;
238 
239 	switch (p_slot->state) {
240 	case STATIC_STATE:
241 		pciehp_get_power_status(p_slot, &getstatus);
242 		if (getstatus) {
243 			p_slot->state = BLINKINGOFF_STATE;
244 			ctrl_info(ctrl, "Slot(%s): Powering off due to button press\n",
245 				  slot_name(p_slot));
246 		} else {
247 			p_slot->state = BLINKINGON_STATE;
248 			ctrl_info(ctrl, "Slot(%s) Powering on due to button press\n",
249 				  slot_name(p_slot));
250 		}
251 		/* blink green LED and turn off amber */
252 		pciehp_green_led_blink(p_slot);
253 		pciehp_set_attention_status(p_slot, 0);
254 		queue_delayed_work(p_slot->wq, &p_slot->work, 5*HZ);
255 		break;
256 	case BLINKINGOFF_STATE:
257 	case BLINKINGON_STATE:
258 		/*
259 		 * Cancel if we are still blinking; this means that we
260 		 * press the attention again before the 5 sec. limit
261 		 * expires to cancel hot-add or hot-remove
262 		 */
263 		ctrl_info(ctrl, "Slot(%s): Button cancel\n", slot_name(p_slot));
264 		cancel_delayed_work(&p_slot->work);
265 		if (p_slot->state == BLINKINGOFF_STATE)
266 			pciehp_green_led_on(p_slot);
267 		else
268 			pciehp_green_led_off(p_slot);
269 		pciehp_set_attention_status(p_slot, 0);
270 		ctrl_info(ctrl, "Slot(%s): Action canceled due to button press\n",
271 			  slot_name(p_slot));
272 		p_slot->state = STATIC_STATE;
273 		break;
274 	case POWEROFF_STATE:
275 	case POWERON_STATE:
276 		/*
277 		 * Ignore if the slot is on power-on or power-off state;
278 		 * this means that the previous attention button action
279 		 * to hot-add or hot-remove is undergoing
280 		 */
281 		ctrl_info(ctrl, "Slot(%s): Button ignored\n",
282 			  slot_name(p_slot));
283 		break;
284 	default:
285 		ctrl_err(ctrl, "Slot(%s): Ignoring invalid state %#x\n",
286 			 slot_name(p_slot), p_slot->state);
287 		break;
288 	}
289 }
290 
291 /*
292  * Note: This function must be called with slot->lock held
293  */
294 static void handle_link_event(struct slot *p_slot, u32 event)
295 {
296 	struct controller *ctrl = p_slot->ctrl;
297 
298 	switch (p_slot->state) {
299 	case BLINKINGON_STATE:
300 	case BLINKINGOFF_STATE:
301 		cancel_delayed_work(&p_slot->work);
302 		/* Fall through */
303 	case STATIC_STATE:
304 		pciehp_queue_power_work(p_slot, event == INT_LINK_UP ?
305 					ENABLE_REQ : DISABLE_REQ);
306 		break;
307 	case POWERON_STATE:
308 		if (event == INT_LINK_UP) {
309 			ctrl_info(ctrl, "Slot(%s): Link Up event ignored; already powering on\n",
310 				  slot_name(p_slot));
311 		} else {
312 			ctrl_info(ctrl, "Slot(%s): Link Down event queued; currently getting powered on\n",
313 				  slot_name(p_slot));
314 			pciehp_queue_power_work(p_slot, DISABLE_REQ);
315 		}
316 		break;
317 	case POWEROFF_STATE:
318 		if (event == INT_LINK_UP) {
319 			ctrl_info(ctrl, "Slot(%s): Link Up event queued; currently getting powered off\n",
320 				  slot_name(p_slot));
321 			pciehp_queue_power_work(p_slot, ENABLE_REQ);
322 		} else {
323 			ctrl_info(ctrl, "Slot(%s): Link Down event ignored; already powering off\n",
324 				  slot_name(p_slot));
325 		}
326 		break;
327 	default:
328 		ctrl_err(ctrl, "Slot(%s): Ignoring invalid state %#x\n",
329 			 slot_name(p_slot), p_slot->state);
330 		break;
331 	}
332 }
333 
334 static void interrupt_event_handler(struct work_struct *work)
335 {
336 	struct event_info *info = container_of(work, struct event_info, work);
337 	struct slot *p_slot = info->p_slot;
338 	struct controller *ctrl = p_slot->ctrl;
339 
340 	mutex_lock(&p_slot->lock);
341 	switch (info->event_type) {
342 	case INT_BUTTON_PRESS:
343 		handle_button_press_event(p_slot);
344 		break;
345 	case INT_POWER_FAULT:
346 		if (!POWER_CTRL(ctrl))
347 			break;
348 		pciehp_set_attention_status(p_slot, 1);
349 		pciehp_green_led_off(p_slot);
350 		break;
351 	case INT_PRESENCE_ON:
352 		pciehp_queue_power_work(p_slot, ENABLE_REQ);
353 		break;
354 	case INT_PRESENCE_OFF:
355 		/*
356 		 * Regardless of surprise capability, we need to
357 		 * definitely remove a card that has been pulled out!
358 		 */
359 		pciehp_queue_power_work(p_slot, DISABLE_REQ);
360 		break;
361 	case INT_LINK_UP:
362 	case INT_LINK_DOWN:
363 		handle_link_event(p_slot, info->event_type);
364 		break;
365 	default:
366 		break;
367 	}
368 	mutex_unlock(&p_slot->lock);
369 
370 	kfree(info);
371 }
372 
373 /*
374  * Note: This function must be called with slot->hotplug_lock held
375  */
376 int pciehp_enable_slot(struct slot *p_slot)
377 {
378 	u8 getstatus = 0;
379 	struct controller *ctrl = p_slot->ctrl;
380 
381 	pciehp_get_adapter_status(p_slot, &getstatus);
382 	if (!getstatus) {
383 		ctrl_info(ctrl, "Slot(%s): No adapter\n", slot_name(p_slot));
384 		return -ENODEV;
385 	}
386 	if (MRL_SENS(p_slot->ctrl)) {
387 		pciehp_get_latch_status(p_slot, &getstatus);
388 		if (getstatus) {
389 			ctrl_info(ctrl, "Slot(%s): Latch open\n",
390 				  slot_name(p_slot));
391 			return -ENODEV;
392 		}
393 	}
394 
395 	if (POWER_CTRL(p_slot->ctrl)) {
396 		pciehp_get_power_status(p_slot, &getstatus);
397 		if (getstatus) {
398 			ctrl_info(ctrl, "Slot(%s): Already enabled\n",
399 				  slot_name(p_slot));
400 			return 0;
401 		}
402 	}
403 
404 	return board_added(p_slot);
405 }
406 
407 /*
408  * Note: This function must be called with slot->hotplug_lock held
409  */
410 int pciehp_disable_slot(struct slot *p_slot)
411 {
412 	u8 getstatus = 0;
413 	struct controller *ctrl = p_slot->ctrl;
414 
415 	if (!p_slot->ctrl)
416 		return 1;
417 
418 	if (POWER_CTRL(p_slot->ctrl)) {
419 		pciehp_get_power_status(p_slot, &getstatus);
420 		if (!getstatus) {
421 			ctrl_info(ctrl, "Slot(%s): Already disabled\n",
422 				  slot_name(p_slot));
423 			return -EINVAL;
424 		}
425 	}
426 
427 	return remove_board(p_slot);
428 }
429 
430 int pciehp_sysfs_enable_slot(struct slot *p_slot)
431 {
432 	int retval = -ENODEV;
433 	struct controller *ctrl = p_slot->ctrl;
434 
435 	mutex_lock(&p_slot->lock);
436 	switch (p_slot->state) {
437 	case BLINKINGON_STATE:
438 		cancel_delayed_work(&p_slot->work);
439 	case STATIC_STATE:
440 		p_slot->state = POWERON_STATE;
441 		mutex_unlock(&p_slot->lock);
442 		mutex_lock(&p_slot->hotplug_lock);
443 		retval = pciehp_enable_slot(p_slot);
444 		mutex_unlock(&p_slot->hotplug_lock);
445 		mutex_lock(&p_slot->lock);
446 		p_slot->state = STATIC_STATE;
447 		break;
448 	case POWERON_STATE:
449 		ctrl_info(ctrl, "Slot(%s): Already in powering on state\n",
450 			  slot_name(p_slot));
451 		break;
452 	case BLINKINGOFF_STATE:
453 	case POWEROFF_STATE:
454 		ctrl_info(ctrl, "Slot(%s): Already enabled\n",
455 			  slot_name(p_slot));
456 		break;
457 	default:
458 		ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
459 			 slot_name(p_slot), p_slot->state);
460 		break;
461 	}
462 	mutex_unlock(&p_slot->lock);
463 
464 	return retval;
465 }
466 
467 int pciehp_sysfs_disable_slot(struct slot *p_slot)
468 {
469 	int retval = -ENODEV;
470 	struct controller *ctrl = p_slot->ctrl;
471 
472 	mutex_lock(&p_slot->lock);
473 	switch (p_slot->state) {
474 	case BLINKINGOFF_STATE:
475 		cancel_delayed_work(&p_slot->work);
476 	case STATIC_STATE:
477 		p_slot->state = POWEROFF_STATE;
478 		mutex_unlock(&p_slot->lock);
479 		mutex_lock(&p_slot->hotplug_lock);
480 		retval = pciehp_disable_slot(p_slot);
481 		mutex_unlock(&p_slot->hotplug_lock);
482 		mutex_lock(&p_slot->lock);
483 		p_slot->state = STATIC_STATE;
484 		break;
485 	case POWEROFF_STATE:
486 		ctrl_info(ctrl, "Slot(%s): Already in powering off state\n",
487 			  slot_name(p_slot));
488 		break;
489 	case BLINKINGON_STATE:
490 	case POWERON_STATE:
491 		ctrl_info(ctrl, "Slot(%s): Already disabled\n",
492 			  slot_name(p_slot));
493 		break;
494 	default:
495 		ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
496 			 slot_name(p_slot), p_slot->state);
497 		break;
498 	}
499 	mutex_unlock(&p_slot->lock);
500 
501 	return retval;
502 }
503