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