blob: 085dbb5fc168be33de77d0ced5c411c807ffc2ef [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Kristen Accardi8cf4c192005-08-16 15:16:10 -070026 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 *
28 */
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/types.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/pci.h>
35#include "../pci.h"
36#include "pciehp.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080038static void interrupt_event_handler(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080040static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
Kenji Kaneshige49ed2b42006-09-22 10:17:10 -070041{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080042 struct event_info *info;
43
44 info = kmalloc(sizeof(*info), GFP_ATOMIC);
45 if (!info)
46 return -ENOMEM;
47
48 info->event_type = event_type;
49 info->p_slot = p_slot;
50 INIT_WORK(&info->work, interrupt_event_handler);
51
Tejun Heoa827ea32010-10-18 08:31:02 +020052 queue_work(pciehp_wq, &info->work);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080053
54 return 0;
Kenji Kaneshige49ed2b42006-09-22 10:17:10 -070055}
56
Kenji Kaneshigedbd79ae2008-05-27 19:03:16 +090057u8 pciehp_handle_attention_button(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080059 u32 event_type;
Taku Izumi7f2feec2008-09-05 12:11:26 +090060 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 /* Attention Button Change */
Taku Izumi18b341b2008-10-23 11:47:32 +090063 ctrl_dbg(ctrl, "Attention button interrupt received\n");
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080064
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 /*
66 * Button pressed - See if need to TAKE ACTION!!!
67 */
Alex Chiange1acb242008-10-20 17:41:38 -060068 ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080069 event_type = INT_BUTTON_PRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080071 queue_interrupt_event(p_slot, event_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074}
75
Kenji Kaneshigedbd79ae2008-05-27 19:03:16 +090076u8 pciehp_handle_switch_change(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 u8 getstatus;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080079 u32 event_type;
Taku Izumi7f2feec2008-09-05 12:11:26 +090080 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82 /* Switch Change */
Taku Izumi18b341b2008-10-23 11:47:32 +090083 ctrl_dbg(ctrl, "Switch interrupt received\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Kenji Kaneshige82a9e792009-09-15 17:30:48 +090085 pciehp_get_latch_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (getstatus) {
87 /*
88 * Switch opened
89 */
Alex Chiange1acb242008-10-20 17:41:38 -060090 ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080091 event_type = INT_SWITCH_OPEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 } else {
93 /*
94 * Switch closed
95 */
Alex Chiange1acb242008-10-20 17:41:38 -060096 ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -080097 event_type = INT_SWITCH_CLOSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 }
99
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800100 queue_interrupt_event(p_slot, event_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800102 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103}
104
Kenji Kaneshigedbd79ae2008-05-27 19:03:16 +0900105u8 pciehp_handle_presence_change(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800107 u32 event_type;
108 u8 presence_save;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900109 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111 /* Presence Change */
Taku Izumi18b341b2008-10-23 11:47:32 +0900112 ctrl_dbg(ctrl, "Presence/Notify input change\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 /* Switch is open, assume a presence change
115 * Save the presence state
116 */
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900117 pciehp_get_adapter_status(p_slot, &presence_save);
rajesh.shah@intel.comed6cbcf2005-10-31 16:20:09 -0800118 if (presence_save) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 /*
120 * Card Present
121 */
Alex Chiange1acb242008-10-20 17:41:38 -0600122 ctrl_info(ctrl, "Card present on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800123 event_type = INT_PRESENCE_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 } else {
125 /*
126 * Not Present
127 */
Alex Chiange1acb242008-10-20 17:41:38 -0600128 ctrl_info(ctrl, "Card not present on Slot(%s)\n",
129 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800130 event_type = INT_PRESENCE_OFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 }
132
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800133 queue_interrupt_event(p_slot, event_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800135 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Kenji Kaneshigedbd79ae2008-05-27 19:03:16 +0900138u8 pciehp_handle_power_fault(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800140 u32 event_type;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900141 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
143 /* power fault */
Taku Izumi18b341b2008-10-23 11:47:32 +0900144 ctrl_dbg(ctrl, "Power fault interrupt received\n");
Kenji Kaneshige5651c482009-11-13 15:14:10 +0900145 ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
146 event_type = INT_POWER_FAULT;
147 ctrl_info(ctrl, "Power fault bit %x set\n", 0);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800148 queue_interrupt_event(p_slot, event_type);
149
150 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151}
152
Kenji Kaneshige36ed27b2007-08-09 16:09:36 -0700153/* The following routines constitute the bulk of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 hotplug controller logic
155 */
156
157static void set_slot_off(struct controller *ctrl, struct slot * pslot)
158{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700160 if (POWER_CTRL(ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900161 if (pciehp_power_off_slot(pslot)) {
Taku Izumi7f2feec2008-09-05 12:11:26 +0900162 ctrl_err(ctrl,
Taku Izumi18b341b2008-10-23 11:47:32 +0900163 "Issue of Slot Power Off command failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return;
165 }
Kenji Kaneshigec7b4fee2008-10-24 14:26:35 +0900166 /*
167 * After turning power off, we must wait for at least 1 second
168 * before taking any action that relies on power having been
169 * removed from the slot/adapter.
170 */
171 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
173
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700174 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900175 pciehp_green_led_off(pslot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700177 if (ATTN_LED(ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900178 if (pciehp_set_attention_status(pslot, 1)) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900179 ctrl_err(ctrl,
180 "Issue of Set Attention Led command failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return;
182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184}
185
186/**
187 * board_added - Called after a board has been added to the system.
Randy Dunlap26e6c662007-11-28 09:04:30 -0800188 * @p_slot: &slot where board is added
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 *
Randy Dunlap26e6c662007-11-28 09:04:30 -0800190 * Turns power on for the board.
191 * Configures board.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 */
rajesh.shah@intel.comed6cbcf2005-10-31 16:20:09 -0800193static int board_added(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194{
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800195 int retval = 0;
rajesh.shah@intel.comca22a5e2005-10-31 16:20:08 -0800196 struct controller *ctrl = p_slot->ctrl;
Kenji Kaneshige385e2492009-09-15 17:30:14 +0900197 struct pci_bus *parent = ctrl->pcie->port->subordinate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700199 if (POWER_CTRL(ctrl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 /* Power on slot */
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900201 retval = pciehp_power_on_slot(p_slot);
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800202 if (retval)
203 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 }
Kenji Kaneshige36ed27b2007-08-09 16:09:36 -0700205
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700206 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900207 pciehp_green_led_blink(p_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800209 /* Check link training status */
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900210 retval = pciehp_check_link_status(ctrl);
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800211 if (retval) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900212 ctrl_err(ctrl, "Failed to check link status\n");
Kenji Kaneshige5651c482009-11-13 15:14:10 +0900213 goto err_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 /* Check for a power fault */
Kenji Kaneshige5651c482009-11-13 15:14:10 +0900217 if (ctrl->power_fault_detected || pciehp_query_power_fault(p_slot)) {
218 ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
Kenji Kaneshiged9fb42a82009-09-15 17:33:30 +0900219 retval = -EIO;
rajesh.shah@intel.com71b720c2005-10-31 16:20:06 -0800220 goto err_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 }
222
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800223 retval = pciehp_configure_device(p_slot);
224 if (retval) {
Kenji Kaneshiged689f7e2009-09-15 17:26:56 +0900225 ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
226 pci_domain_nr(parent), parent->number);
rajesh.shah@intel.com71b720c2005-10-31 16:20:06 -0800227 goto err_exit;
228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700230 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900231 pciehp_green_led_on(p_slot);
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return 0;
rajesh.shah@intel.com71b720c2005-10-31 16:20:06 -0800234
235err_exit:
236 set_slot_off(ctrl, p_slot);
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800237 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240/**
Randy Dunlap26e6c662007-11-28 09:04:30 -0800241 * remove_board - Turns off slot and LEDs
242 * @p_slot: slot where board is being removed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 */
rajesh.shah@intel.comed6cbcf2005-10-31 16:20:09 -0800244static int remove_board(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800246 int retval = 0;
rajesh.shah@intel.comca22a5e2005-10-31 16:20:08 -0800247 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800249 retval = pciehp_unconfigure_device(p_slot);
250 if (retval)
251 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700253 if (POWER_CTRL(ctrl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 /* power off slot */
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900255 retval = pciehp_power_off_slot(p_slot);
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800256 if (retval) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900257 ctrl_err(ctrl,
258 "Issue of Slot Disable command failed\n");
Kenji Kaneshige44ef4ce2006-12-21 17:01:09 -0800259 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
Kenji Kaneshigec7b4fee2008-10-24 14:26:35 +0900261 /*
262 * After turning power off, we must wait for at least 1 second
263 * before taking any action that relies on power having been
264 * removed from the slot/adapter.
265 */
266 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
268
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900269 /* turn off Green LED */
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700270 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900271 pciehp_green_led_off(p_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 return 0;
274}
275
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800276struct power_work_info {
277 struct slot *p_slot;
278 struct work_struct work;
279};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281/**
Randy Dunlap26e6c662007-11-28 09:04:30 -0800282 * pciehp_power_thread - handle pushbutton events
283 * @work: &struct work_struct describing work to be done
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 *
Randy Dunlap26e6c662007-11-28 09:04:30 -0800285 * Scheduled procedure to handle blocking stuff for the pushbuttons.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 * Handles all pending events and exits.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 */
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800288static void pciehp_power_thread(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800290 struct power_work_info *info =
291 container_of(work, struct power_work_info, work);
292 struct slot *p_slot = info->p_slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800294 mutex_lock(&p_slot->lock);
295 switch (p_slot->state) {
296 case POWEROFF_STATE:
297 mutex_unlock(&p_slot->lock);
Taku Izumi18b341b2008-10-23 11:47:32 +0900298 ctrl_dbg(p_slot->ctrl,
Kenji Kaneshiged689f7e2009-09-15 17:26:56 +0900299 "Disabling domain:bus:device=%04x:%02x:00\n",
Kenji Kaneshige385e2492009-09-15 17:30:14 +0900300 pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
301 p_slot->ctrl->pcie->port->subordinate->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 pciehp_disable_slot(p_slot);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800303 mutex_lock(&p_slot->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 p_slot->state = STATIC_STATE;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800305 break;
306 case POWERON_STATE:
307 mutex_unlock(&p_slot->lock);
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900308 if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
309 pciehp_green_led_off(p_slot);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800310 mutex_lock(&p_slot->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 p_slot->state = STATIC_STATE;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800312 break;
313 default:
314 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800316 mutex_unlock(&p_slot->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800318 kfree(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
Kristen Carlson Accardie325e1f2007-03-21 11:45:31 -0700321void pciehp_queue_pushbutton_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800323 struct slot *p_slot = container_of(work, struct slot, work.work);
324 struct power_work_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800326 info = kmalloc(sizeof(*info), GFP_KERNEL);
327 if (!info) {
Taku Izumi7f2feec2008-09-05 12:11:26 +0900328 ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
329 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return;
331 }
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800332 info->p_slot = p_slot;
333 INIT_WORK(&info->work, pciehp_power_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800335 mutex_lock(&p_slot->lock);
336 switch (p_slot->state) {
337 case BLINKINGOFF_STATE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 p_slot->state = POWEROFF_STATE;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800339 break;
340 case BLINKINGON_STATE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 p_slot->state = POWERON_STATE;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800342 break;
343 default:
Jiri Slaby6fcaf172010-01-06 17:47:56 +0100344 kfree(info);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800345 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
Tejun Heoa827ea32010-10-18 08:31:02 +0200347 queue_work(pciehp_ordered_wq, &info->work);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800348 out:
349 mutex_unlock(&p_slot->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350}
351
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800352/*
353 * Note: This function must be called with slot->lock held
354 */
355static void handle_button_press_event(struct slot *p_slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800357 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 u8 getstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800360 switch (p_slot->state) {
361 case STATIC_STATE:
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900362 pciehp_get_power_status(p_slot, &getstatus);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800363 if (getstatus) {
364 p_slot->state = BLINKINGOFF_STATE;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900365 ctrl_info(ctrl,
366 "PCI slot #%s - powering off due to button "
Alex Chiange1acb242008-10-20 17:41:38 -0600367 "press.\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800368 } else {
369 p_slot->state = BLINKINGON_STATE;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900370 ctrl_info(ctrl,
371 "PCI slot #%s - powering on due to button "
Alex Chiange1acb242008-10-20 17:41:38 -0600372 "press.\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800373 }
374 /* blink green LED and turn off amber */
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700375 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900376 pciehp_green_led_blink(p_slot);
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700377 if (ATTN_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900378 pciehp_set_attention_status(p_slot, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Tejun Heoa827ea32010-10-18 08:31:02 +0200380 queue_delayed_work(pciehp_wq, &p_slot->work, 5*HZ);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800381 break;
382 case BLINKINGOFF_STATE:
383 case BLINKINGON_STATE:
384 /*
385 * Cancel if we are still blinking; this means that we
386 * press the attention again before the 5 sec. limit
387 * expires to cancel hot-add or hot-remove
388 */
Alex Chiange1acb242008-10-20 17:41:38 -0600389 ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800390 cancel_delayed_work(&p_slot->work);
391 if (p_slot->state == BLINKINGOFF_STATE) {
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700392 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900393 pciehp_green_led_on(p_slot);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800394 } else {
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700395 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900396 pciehp_green_led_off(p_slot);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800397 }
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700398 if (ATTN_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900399 pciehp_set_attention_status(p_slot, 0);
Taku Izumi7f2feec2008-09-05 12:11:26 +0900400 ctrl_info(ctrl, "PCI slot #%s - action canceled "
Alex Chiange1acb242008-10-20 17:41:38 -0600401 "due to button press\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800402 p_slot->state = STATIC_STATE;
403 break;
404 case POWEROFF_STATE:
405 case POWERON_STATE:
406 /*
407 * Ignore if the slot is on power-on or power-off state;
408 * this means that the previous attention button action
409 * to hot-add or hot-remove is undergoing
410 */
Alex Chiange1acb242008-10-20 17:41:38 -0600411 ctrl_info(ctrl, "Button ignore on Slot(%s)\n", slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800412 break;
413 default:
Taku Izumi7f2feec2008-09-05 12:11:26 +0900414 ctrl_warn(ctrl, "Not a valid state\n");
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800415 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
417}
418
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800419/*
420 * Note: This function must be called with slot->lock held
421 */
422static void handle_surprise_event(struct slot *p_slot)
423{
424 u8 getstatus;
425 struct power_work_info *info;
426
427 info = kmalloc(sizeof(*info), GFP_KERNEL);
428 if (!info) {
Taku Izumi7f2feec2008-09-05 12:11:26 +0900429 ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
430 __func__);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800431 return;
432 }
433 info->p_slot = p_slot;
434 INIT_WORK(&info->work, pciehp_power_thread);
435
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900436 pciehp_get_adapter_status(p_slot, &getstatus);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800437 if (!getstatus)
438 p_slot->state = POWEROFF_STATE;
439 else
440 p_slot->state = POWERON_STATE;
441
Tejun Heoa827ea32010-10-18 08:31:02 +0200442 queue_work(pciehp_ordered_wq, &info->work);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800443}
444
445static void interrupt_event_handler(struct work_struct *work)
446{
447 struct event_info *info = container_of(work, struct event_info, work);
448 struct slot *p_slot = info->p_slot;
449 struct controller *ctrl = p_slot->ctrl;
450
451 mutex_lock(&p_slot->lock);
452 switch (info->event_type) {
453 case INT_BUTTON_PRESS:
454 handle_button_press_event(p_slot);
455 break;
456 case INT_POWER_FAULT:
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700457 if (!POWER_CTRL(ctrl))
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800458 break;
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700459 if (ATTN_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900460 pciehp_set_attention_status(p_slot, 1);
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700461 if (PWR_LED(ctrl))
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900462 pciehp_green_led_off(p_slot);
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800463 break;
464 case INT_PRESENCE_ON:
465 case INT_PRESENCE_OFF:
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700466 if (!HP_SUPR_RM(ctrl))
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800467 break;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900468 ctrl_dbg(ctrl, "Surprise Removal\n");
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800469 handle_surprise_event(p_slot);
470 break;
471 default:
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800472 break;
473 }
474 mutex_unlock(&p_slot->lock);
475
476 kfree(info);
477}
478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479int pciehp_enable_slot(struct slot *p_slot)
480{
481 u8 getstatus = 0;
482 int rc;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900483 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900485 rc = pciehp_get_adapter_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 if (rc || !getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900487 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700488 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700490 if (MRL_SENS(p_slot->ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900491 rc = pciehp_get_latch_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 if (rc || getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900493 ctrl_info(ctrl, "Latch open on slot(%s)\n",
494 slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700495 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497 }
Kenji Kaneshige36ed27b2007-08-09 16:09:36 -0700498
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700499 if (POWER_CTRL(p_slot->ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900500 rc = pciehp_get_power_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (rc || getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900502 ctrl_info(ctrl, "Already enabled on slot(%s)\n",
503 slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700504 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 }
506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900508 pciehp_get_latch_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
rajesh.shah@intel.comca22a5e2005-10-31 16:20:08 -0800510 rc = board_added(p_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 if (rc) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900512 pciehp_get_latch_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 return rc;
515}
516
517
518int pciehp_disable_slot(struct slot *p_slot)
519{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 u8 getstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 int ret = 0;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900522 struct controller *ctrl = p_slot->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
524 if (!p_slot->ctrl)
525 return 1;
526
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700527 if (!HP_SUPR_RM(p_slot->ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900528 ret = pciehp_get_adapter_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 if (ret || !getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900530 ctrl_info(ctrl, "No adapter on slot(%s)\n",
531 slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700532 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534 }
535
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700536 if (MRL_SENS(p_slot->ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900537 ret = pciehp_get_latch_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (ret || getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900539 ctrl_info(ctrl, "Latch open on slot(%s)\n",
540 slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700541 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
543 }
544
Kenji Kaneshigeae416e62008-04-25 14:39:06 -0700545 if (POWER_CTRL(p_slot->ctrl)) {
Kenji Kaneshige82a9e792009-09-15 17:30:48 +0900546 ret = pciehp_get_power_status(p_slot, &getstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 if (ret || !getstatus) {
Taku Izumi18b341b2008-10-23 11:47:32 +0900548 ctrl_info(ctrl, "Already disabled on slot(%s)\n",
549 slot_name(p_slot));
Kenji Kaneshigec9d86d72006-09-19 17:04:33 -0700550 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 }
552 }
553
Kenji Kaneshige445f7982009-10-05 17:42:59 +0900554 return remove_board(p_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800557int pciehp_sysfs_enable_slot(struct slot *p_slot)
558{
559 int retval = -ENODEV;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900560 struct controller *ctrl = p_slot->ctrl;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800561
562 mutex_lock(&p_slot->lock);
563 switch (p_slot->state) {
564 case BLINKINGON_STATE:
565 cancel_delayed_work(&p_slot->work);
566 case STATIC_STATE:
567 p_slot->state = POWERON_STATE;
568 mutex_unlock(&p_slot->lock);
569 retval = pciehp_enable_slot(p_slot);
570 mutex_lock(&p_slot->lock);
571 p_slot->state = STATIC_STATE;
572 break;
573 case POWERON_STATE:
Taku Izumi7f2feec2008-09-05 12:11:26 +0900574 ctrl_info(ctrl, "Slot %s is already in powering on state\n",
Alex Chiange1acb242008-10-20 17:41:38 -0600575 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800576 break;
577 case BLINKINGOFF_STATE:
578 case POWEROFF_STATE:
Alex Chiange1acb242008-10-20 17:41:38 -0600579 ctrl_info(ctrl, "Already enabled on slot %s\n",
580 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800581 break;
582 default:
Alex Chiange1acb242008-10-20 17:41:38 -0600583 ctrl_err(ctrl, "Not a valid state on slot %s\n",
584 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800585 break;
586 }
587 mutex_unlock(&p_slot->lock);
588
589 return retval;
590}
591
592int pciehp_sysfs_disable_slot(struct slot *p_slot)
593{
594 int retval = -ENODEV;
Taku Izumi7f2feec2008-09-05 12:11:26 +0900595 struct controller *ctrl = p_slot->ctrl;
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800596
597 mutex_lock(&p_slot->lock);
598 switch (p_slot->state) {
599 case BLINKINGOFF_STATE:
600 cancel_delayed_work(&p_slot->work);
601 case STATIC_STATE:
602 p_slot->state = POWEROFF_STATE;
603 mutex_unlock(&p_slot->lock);
604 retval = pciehp_disable_slot(p_slot);
605 mutex_lock(&p_slot->lock);
606 p_slot->state = STATIC_STATE;
607 break;
608 case POWEROFF_STATE:
Taku Izumi7f2feec2008-09-05 12:11:26 +0900609 ctrl_info(ctrl, "Slot %s is already in powering off state\n",
Alex Chiange1acb242008-10-20 17:41:38 -0600610 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800611 break;
612 case BLINKINGON_STATE:
613 case POWERON_STATE:
Alex Chiange1acb242008-10-20 17:41:38 -0600614 ctrl_info(ctrl, "Already disabled on slot %s\n",
615 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800616 break;
617 default:
Alex Chiange1acb242008-10-20 17:41:38 -0600618 ctrl_err(ctrl, "Not a valid state on slot %s\n",
619 slot_name(p_slot));
Kenji Kaneshige5d386e12007-03-06 15:02:26 -0800620 break;
621 }
622 mutex_unlock(&p_slot->lock);
623
624 return retval;
625}