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