[net-next-2.6.git] / drivers / pci / hotplug / pciehp_ctrl.c

/*
 * PCI Express Hot Plug Controller Driver
 *
 * Copyright (C) 1995,2001 Compaq Computer Corporation
 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2001 IBM Corp.
 * Copyright (C) 2003-2004 Intel Corporation
 *
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/workqueue.h>
#include "../pci.h"
#include "pciehp.h"

static void interrupt_event_handler(struct work_struct *work);

static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
{
	struct event_info *info;

	info = kmalloc(sizeof(*info), GFP_ATOMIC);
	if (!info)
		return -ENOMEM;

	info->event_type = event_type;
	info->p_slot = p_slot;
	INIT_WORK(&info->work, interrupt_event_handler);

	schedule_work(&info->work);

	return 0;
}

u8 pciehp_handle_attention_button(struct slot *p_slot)
{
	u32 event_type;
	struct controller *ctrl = p_slot->ctrl;

	/* Attention Button Change */
	ctrl_dbg(ctrl, "Attention button interrupt received\n");

	/*
	 *  Button pressed - See if need to TAKE ACTION!!!
	 */
	ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
	event_type = INT_BUTTON_PRESS;

	queue_interrupt_event(p_slot, event_type);

	return 0;
}

u8 pciehp_handle_switch_change(struct slot *p_slot)
{
	u8 getstatus;
	u32 event_type;
	struct controller *ctrl = p_slot->ctrl;

	/* Switch Change */
	ctrl_dbg(ctrl, "Switch interrupt received\n");

	pciehp_get_latch_status(p_slot, &getstatus);
	if (getstatus) {
		/*
		 * Switch opened
		 */
		ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
		event_type = INT_SWITCH_OPEN;
	} else {
		/*
		 *  Switch closed
		 */
		ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
		event_type = INT_SWITCH_CLOSE;
	}

	queue_interrupt_event(p_slot, event_type);

	return 1;
}

u8 pciehp_handle_presence_change(struct slot *p_slot)
{
	u32 event_type;
	u8 presence_save;
	struct controller *ctrl = p_slot->ctrl;

	/* Presence Change */
	ctrl_dbg(ctrl, "Presence/Notify input change\n");

	/* Switch is open, assume a presence change
	 * Save the presence state
	 */
	pciehp_get_adapter_status(p_slot, &presence_save);
	if (presence_save) {
		/*
		 * Card Present
		 */
		ctrl_info(ctrl, "Card present on Slot(%s)\n", slot_name(p_slot));
		event_type = INT_PRESENCE_ON;
	} else {
		/*
		 * Not Present
		 */
		ctrl_info(ctrl, "Card not present on Slot(%s)\n",
			  slot_name(p_slot));
		event_type = INT_PRESENCE_OFF;
	}

	queue_interrupt_event(p_slot, event_type);

	return 1;
}

u8 pciehp_handle_power_fault(struct slot *p_slot)
{
	u32 event_type;
	struct controller *ctrl = p_slot->ctrl;

	/* power fault */
	ctrl_dbg(ctrl, "Power fault interrupt received\n");
	ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
	event_type = INT_POWER_FAULT;
	ctrl_info(ctrl, "Power fault bit %x set\n", 0);
	queue_interrupt_event(p_slot, event_type);

	return 1;
}

/* The following routines constitute the bulk of the
   hotplug controller logic
 */

static void set_slot_off(struct controller *ctrl, struct slot * pslot)
{
	/* turn off slot, turn on Amber LED, turn off Green LED if supported*/
	if (POWER_CTRL(ctrl)) {
		if (pciehp_power_off_slot(pslot)) {
			ctrl_err(ctrl,
				 "Issue of Slot Power Off command failed\n");
			return;
		}
		/*
		 * After turning power off, we must wait for at least 1 second
		 * before taking any action that relies on power having been
		 * removed from the slot/adapter.
		 */
		msleep(1000);
	}

	if (PWR_LED(ctrl))
		pciehp_green_led_off(pslot);

	if (ATTN_LED(ctrl)) {
		if (pciehp_set_attention_status(pslot, 1)) {
			ctrl_err(ctrl,
				 "Issue of Set Attention Led command failed\n");
			return;
		}
	}
}

/**
 * board_added - Called after a board has been added to the system.
 * @p_slot: &slot where board is added
 *
 * Turns power on for the board.
 * Configures board.
 */
static int board_added(struct slot *p_slot)
{
	int retval = 0;
	struct controller *ctrl = p_slot->ctrl;
	struct pci_bus *parent = ctrl->pcie->port->subordinate;

	if (POWER_CTRL(ctrl)) {
		/* Power on slot */
		retval = pciehp_power_on_slot(p_slot);
		if (retval)
			return retval;
	}

	if (PWR_LED(ctrl))
		pciehp_green_led_blink(p_slot);

	/* Check link training status */
	retval = pciehp_check_link_status(ctrl);
	if (retval) {
		ctrl_err(ctrl, "Failed to check link status\n");
		goto err_exit;
	}

	/* Check for a power fault */
	if (ctrl->power_fault_detected || pciehp_query_power_fault(p_slot)) {
		ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
		retval = -EIO;
		goto err_exit;
	}

	retval = pciehp_configure_device(p_slot);
	if (retval) {
		ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
			 pci_domain_nr(parent), parent->number);
		goto err_exit;
	}

	if (PWR_LED(ctrl))
		pciehp_green_led_on(p_slot);

	return 0;

err_exit:
	set_slot_off(ctrl, p_slot);
	return retval;
}

/**
 * remove_board - Turns off slot and LEDs
 * @p_slot: slot where board is being removed
 */
static int remove_board(struct slot *p_slot)
{
	int retval = 0;
	struct controller *ctrl = p_slot->ctrl;

	retval = pciehp_unconfigure_device(p_slot);
	if (retval)
		return retval;

	if (POWER_CTRL(ctrl)) {
		/* power off slot */
		retval = pciehp_power_off_slot(p_slot);
		if (retval) {
			ctrl_err(ctrl,
				 "Issue of Slot Disable command failed\n");
			return retval;
		}
		/*
		 * After turning power off, we must wait for at least 1 second
		 * before taking any action that relies on power having been
		 * removed from the slot/adapter.
		 */
		msleep(1000);
	}

	/* turn off Green LED */
	if (PWR_LED(ctrl))
		pciehp_green_led_off(p_slot);

	return 0;
}

struct power_work_info {
	struct slot *p_slot;
	struct work_struct work;
};

/**
 * pciehp_power_thread - handle pushbutton events
 * @work: &struct work_struct describing work to be done
 *
 * Scheduled procedure to handle blocking stuff for the pushbuttons.
 * Handles all pending events and exits.
 */
static void pciehp_power_thread(struct work_struct *work)
{
	struct power_work_info *info =
		container_of(work, struct power_work_info, work);
	struct slot *p_slot = info->p_slot;

	mutex_lock(&p_slot->lock);
	switch (p_slot->state) {
	case POWEROFF_STATE:
		mutex_unlock(&p_slot->lock);
		ctrl_dbg(p_slot->ctrl,
			 "Disabling domain:bus:device=%04x:%02x:00\n",
			 pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
			 p_slot->ctrl->pcie->port->subordinate->number);
		pciehp_disable_slot(p_slot);
		mutex_lock(&p_slot->lock);
		p_slot->state = STATIC_STATE;
		break;
	case POWERON_STATE:
		mutex_unlock(&p_slot->lock);
		if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
			pciehp_green_led_off(p_slot);
		mutex_lock(&p_slot->lock);
		p_slot->state = STATIC_STATE;
		break;
	default:
		break;
	}
	mutex_unlock(&p_slot->lock);

	kfree(info);
}

void pciehp_queue_pushbutton_work(struct work_struct *work)
{
	struct slot *p_slot = container_of(work, struct slot, work.work);
	struct power_work_info *info;

	info = kmalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
			 __func__);
		return;
	}
	info->p_slot = p_slot;
	INIT_WORK(&info->work, pciehp_power_thread);

	mutex_lock(&p_slot->lock);
	switch (p_slot->state) {
	case BLINKINGOFF_STATE:
		p_slot->state = POWEROFF_STATE;
		break;
	case BLINKINGON_STATE:
		p_slot->state = POWERON_STATE;
		break;
	default:
		kfree(info);
		goto out;
	}
	queue_work(pciehp_wq, &info->work);
 out:
	mutex_unlock(&p_slot->lock);
}

/*
 * Note: This function must be called with slot->lock held
 */
static void handle_button_press_event(struct slot *p_slot)
{
	struct controller *ctrl = p_slot->ctrl;
	u8 getstatus;

	switch (p_slot->state) {
	case STATIC_STATE:
		pciehp_get_power_status(p_slot, &getstatus);
		if (getstatus) {
			p_slot->state = BLINKINGOFF_STATE;
			ctrl_info(ctrl,
				  "PCI slot #%s - powering off due to button "
				  "press.\n", slot_name(p_slot));
		} else {
			p_slot->state = BLINKINGON_STATE;
			ctrl_info(ctrl,
				  "PCI slot #%s - powering on due to button "
				  "press.\n", slot_name(p_slot));
		}
		/* blink green LED and turn off amber */
		if (PWR_LED(ctrl))
			pciehp_green_led_blink(p_slot);
		if (ATTN_LED(ctrl))
			pciehp_set_attention_status(p_slot, 0);

		schedule_delayed_work(&p_slot->work, 5*HZ);
		break;
	case BLINKINGOFF_STATE:
	case BLINKINGON_STATE:
		/*
		 * Cancel if we are still blinking; this means that we
		 * press the attention again before the 5 sec. limit
		 * expires to cancel hot-add or hot-remove
		 */
		ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
		cancel_delayed_work(&p_slot->work);
		if (p_slot->state == BLINKINGOFF_STATE) {
			if (PWR_LED(ctrl))
				pciehp_green_led_on(p_slot);
		} else {
			if (PWR_LED(ctrl))
				pciehp_green_led_off(p_slot);
		}
		if (ATTN_LED(ctrl))
			pciehp_set_attention_status(p_slot, 0);
		ctrl_info(ctrl, "PCI slot #%s - action canceled "
			  "due to button press\n", slot_name(p_slot));
		p_slot->state = STATIC_STATE;
		break;
	case POWEROFF_STATE:
	case POWERON_STATE:
		/*
		 * Ignore if the slot is on power-on or power-off state;
		 * this means that the previous attention button action
		 * to hot-add or hot-remove is undergoing
		 */
		ctrl_info(ctrl, "Button ignore on Slot(%s)\n", slot_name(p_slot));
		break;
	default:
		ctrl_warn(ctrl, "Not a valid state\n");
		break;
	}
}

/*
 * Note: This function must be called with slot->lock held
 */
static void handle_surprise_event(struct slot *p_slot)
{
	u8 getstatus;
	struct power_work_info *info;

	info = kmalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
			 __func__);
		return;
	}
	info->p_slot = p_slot;
	INIT_WORK(&info->work, pciehp_power_thread);

	pciehp_get_adapter_status(p_slot, &getstatus);
	if (!getstatus)
		p_slot->state = POWEROFF_STATE;
	else
		p_slot->state = POWERON_STATE;

	queue_work(pciehp_wq, &info->work);
}

static void interrupt_event_handler(struct work_struct *work)
{
	struct event_info *info = container_of(work, struct event_info, work);
	struct slot *p_slot = info->p_slot;
	struct controller *ctrl = p_slot->ctrl;

	mutex_lock(&p_slot->lock);
	switch (info->event_type) {
	case INT_BUTTON_PRESS:
		handle_button_press_event(p_slot);
		break;
	case INT_POWER_FAULT:
		if (!POWER_CTRL(ctrl))
			break;
		if (ATTN_LED(ctrl))
			pciehp_set_attention_status(p_slot, 1);
		if (PWR_LED(ctrl))
			pciehp_green_led_off(p_slot);
		break;
	case INT_PRESENCE_ON:
	case INT_PRESENCE_OFF:
		if (!HP_SUPR_RM(ctrl))
			break;
		ctrl_dbg(ctrl, "Surprise Removal\n");
		handle_surprise_event(p_slot);
		break;
	default:
		break;
	}
	mutex_unlock(&p_slot->lock);

	kfree(info);
}

int pciehp_enable_slot(struct slot *p_slot)
{
	u8 getstatus = 0;
	int rc;
	struct controller *ctrl = p_slot->ctrl;

	rc = pciehp_get_adapter_status(p_slot, &getstatus);
	if (rc || !getstatus) {
		ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
		return -ENODEV;
	}
	if (MRL_SENS(p_slot->ctrl)) {
		rc = pciehp_get_latch_status(p_slot, &getstatus);
		if (rc || getstatus) {
			ctrl_info(ctrl, "Latch open on slot(%s)\n",
				  slot_name(p_slot));
			return -ENODEV;
		}
	}

	if (POWER_CTRL(p_slot->ctrl)) {
		rc = pciehp_get_power_status(p_slot, &getstatus);
		if (rc || getstatus) {
			ctrl_info(ctrl, "Already enabled on slot(%s)\n",
				  slot_name(p_slot));
			return -EINVAL;
		}
	}

	pciehp_get_latch_status(p_slot, &getstatus);

	rc = board_added(p_slot);
	if (rc) {
		pciehp_get_latch_status(p_slot, &getstatus);
	}
	return rc;
}


int pciehp_disable_slot(struct slot *p_slot)
{
	u8 getstatus = 0;
	int ret = 0;
	struct controller *ctrl = p_slot->ctrl;

	if (!p_slot->ctrl)
		return 1;

	if (!HP_SUPR_RM(p_slot->ctrl)) {
		ret = pciehp_get_adapter_status(p_slot, &getstatus);
		if (ret || !getstatus) {
			ctrl_info(ctrl, "No adapter on slot(%s)\n",
				  slot_name(p_slot));
			return -ENODEV;
		}
	}

	if (MRL_SENS(p_slot->ctrl)) {
		ret = pciehp_get_latch_status(p_slot, &getstatus);
		if (ret || getstatus) {
			ctrl_info(ctrl, "Latch open on slot(%s)\n",
				  slot_name(p_slot));
			return -ENODEV;
		}
	}

	if (POWER_CTRL(p_slot->ctrl)) {
		ret = pciehp_get_power_status(p_slot, &getstatus);
		if (ret || !getstatus) {
			ctrl_info(ctrl, "Already disabled on slot(%s)\n",
				  slot_name(p_slot));
			return -EINVAL;
		}
	}

	return remove_board(p_slot);
}

int pciehp_sysfs_enable_slot(struct slot *p_slot)
{
	int retval = -ENODEV;
	struct controller *ctrl = p_slot->ctrl;

	mutex_lock(&p_slot->lock);
	switch (p_slot->state) {
	case BLINKINGON_STATE:
		cancel_delayed_work(&p_slot->work);
	case STATIC_STATE:
		p_slot->state = POWERON_STATE;
		mutex_unlock(&p_slot->lock);
		retval = pciehp_enable_slot(p_slot);
		mutex_lock(&p_slot->lock);
		p_slot->state = STATIC_STATE;
		break;
	case POWERON_STATE:
		ctrl_info(ctrl, "Slot %s is already in powering on state\n",
			  slot_name(p_slot));
		break;
	case BLINKINGOFF_STATE:
	case POWEROFF_STATE:
		ctrl_info(ctrl, "Already enabled on slot %s\n",
			  slot_name(p_slot));
		break;
	default:
		ctrl_err(ctrl, "Not a valid state on slot %s\n",
			 slot_name(p_slot));
		break;
	}
	mutex_unlock(&p_slot->lock);

	return retval;
}

int pciehp_sysfs_disable_slot(struct slot *p_slot)
{
	int retval = -ENODEV;
	struct controller *ctrl = p_slot->ctrl;

	mutex_lock(&p_slot->lock);
	switch (p_slot->state) {
	case BLINKINGOFF_STATE:
		cancel_delayed_work(&p_slot->work);
	case STATIC_STATE:
		p_slot->state = POWEROFF_STATE;
		mutex_unlock(&p_slot->lock);
		retval = pciehp_disable_slot(p_slot);
		mutex_lock(&p_slot->lock);
		p_slot->state = STATIC_STATE;
		break;
	case POWEROFF_STATE:
		ctrl_info(ctrl, "Slot %s is already in powering off state\n",
			  slot_name(p_slot));
		break;
	case BLINKINGON_STATE:
	case POWERON_STATE:
		ctrl_info(ctrl, "Already disabled on slot %s\n",
			  slot_name(p_slot));
		break;
	default:
		ctrl_err(ctrl, "Not a valid state on slot %s\n",
			 slot_name(p_slot));
		break;
	}
	mutex_unlock(&p_slot->lock);

	return retval;
}
Commit	Line	Data
1da177e4 LT	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	*
8cf4c195	26	* Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
1da177e4 LT	27	*
	28	*/
	29
1da177e4 LT	30	#include <linux/module.h>
	31	#include <linux/kernel.h>
	32	#include <linux/types.h>
5a0e3ad6	33	#include <linux/slab.h>
1da177e4	34	#include <linux/pci.h>
5d386e1a	35	#include <linux/workqueue.h>
1da177e4 LT	36	#include "../pci.h"
1da177e4 LT	37	#include "pciehp.h"
1da177e4	38
5d386e1a	39	static void interrupt_event_handler(struct work_struct *work);
1da177e4	40
5d386e1a	41	static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
49ed2b49	42	{
5d386e1a KK	43	struct event_info *info;
	44
	45	info = kmalloc(sizeof(*info), GFP_ATOMIC);
	46	if (!info)
	47	return -ENOMEM;
	48
	49	info->event_type = event_type;
	50	info->p_slot = p_slot;
	51	INIT_WORK(&info->work, interrupt_event_handler);
	52
	53	schedule_work(&info->work);
	54
	55	return 0;
49ed2b49 KK	56	}
49ed2b49 KK	57
dbd79aed	58	u8 pciehp_handle_attention_button(struct slot *p_slot)
1da177e4	59	{
5d386e1a	60	u32 event_type;
7f2feec1	61	struct controller *ctrl = p_slot->ctrl;
1da177e4 LT	62
1da177e4 LT	63	/* Attention Button Change */
18b341b7	64	ctrl_dbg(ctrl, "Attention button interrupt received\n");
1da177e4	65
1da177e4 LT	66	/*
	67	* Button pressed - See if need to TAKE ACTION!!!
	68	*/
e1acb24f	69	ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
5d386e1a	70	event_type = INT_BUTTON_PRESS;
1da177e4	71
5d386e1a	72	queue_interrupt_event(p_slot, event_type);
1da177e4 LT	73
1da177e4 LT	74	return 0;
1da177e4 LT	75	}
1da177e4 LT	76
dbd79aed	77	u8 pciehp_handle_switch_change(struct slot *p_slot)
1da177e4	78	{
1da177e4	79	u8 getstatus;
5d386e1a	80	u32 event_type;
7f2feec1	81	struct controller *ctrl = p_slot->ctrl;
1da177e4 LT	82
1da177e4 LT	83	/* Switch Change */
18b341b7	84	ctrl_dbg(ctrl, "Switch interrupt received\n");
1da177e4	85
82a9e79e	86	pciehp_get_latch_status(p_slot, &getstatus);
1da177e4 LT	87	if (getstatus) {
	88	/*
	89	* Switch opened
	90	*/
e1acb24f	91	ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
5d386e1a	92	event_type = INT_SWITCH_OPEN;
1da177e4 LT	93	} else {
	94	/*
	95	* Switch closed
	96	*/
e1acb24f	97	ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
5d386e1a	98	event_type = INT_SWITCH_CLOSE;
1da177e4 LT	99	}
1da177e4 LT	100
5d386e1a	101	queue_interrupt_event(p_slot, event_type);
1da177e4	102
5d386e1a	103	return 1;
1da177e4 LT	104	}
1da177e4 LT	105
dbd79aed	106	u8 pciehp_handle_presence_change(struct slot *p_slot)
1da177e4	107	{
5d386e1a KK	108	u32 event_type;
5d386e1a KK	109	u8 presence_save;
7f2feec1	110	struct controller *ctrl = p_slot->ctrl;
1da177e4 LT	111
1da177e4 LT	112	/* Presence Change */
18b341b7	113	ctrl_dbg(ctrl, "Presence/Notify input change\n");
1da177e4	114
1da177e4 LT	115	/* Switch is open, assume a presence change
	116	* Save the presence state
	117	*/
82a9e79e	118	pciehp_get_adapter_status(p_slot, &presence_save);
ed6cbcf2	119	if (presence_save) {
1da177e4 LT	120	/*
	121	* Card Present
	122	*/
e1acb24f	123	ctrl_info(ctrl, "Card present on Slot(%s)\n", slot_name(p_slot));
5d386e1a	124	event_type = INT_PRESENCE_ON;
1da177e4 LT	125	} else {
	126	/*
	127	* Not Present
	128	*/
e1acb24f AC	129	ctrl_info(ctrl, "Card not present on Slot(%s)\n",
e1acb24f AC	130	slot_name(p_slot));
5d386e1a	131	event_type = INT_PRESENCE_OFF;
1da177e4 LT	132	}
1da177e4 LT	133
5d386e1a	134	queue_interrupt_event(p_slot, event_type);
1da177e4	135
5d386e1a	136	return 1;
1da177e4 LT	137	}
1da177e4 LT	138
dbd79aed	139	u8 pciehp_handle_power_fault(struct slot *p_slot)
1da177e4	140	{
5d386e1a	141	u32 event_type;
7f2feec1	142	struct controller *ctrl = p_slot->ctrl;
1da177e4 LT	143
1da177e4 LT	144	/* power fault */
18b341b7	145	ctrl_dbg(ctrl, "Power fault interrupt received\n");
5651c48c KK	146	ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
	147	event_type = INT_POWER_FAULT;
	148	ctrl_info(ctrl, "Power fault bit %x set\n", 0);
5d386e1a KK	149	queue_interrupt_event(p_slot, event_type);
	150
	151	return 1;
1da177e4 LT	152	}
1da177e4 LT	153
36ed27b0	154	/* The following routines constitute the bulk of the
1da177e4 LT	155	hotplug controller logic
	156	*/
	157
	158	static void set_slot_off(struct controller ctrl, struct slot pslot)
	159	{
1da177e4	160	/* turn off slot, turn on Amber LED, turn off Green LED if supported*/
ae416e6b	161	if (POWER_CTRL(ctrl)) {
82a9e79e	162	if (pciehp_power_off_slot(pslot)) {
7f2feec1	163	ctrl_err(ctrl,
18b341b7	164	"Issue of Slot Power Off command failed\n");
1da177e4 LT	165	return;
1da177e4 LT	166	}
c7b4fee3 KK	167	/*
	168	* After turning power off, we must wait for at least 1 second
	169	* before taking any action that relies on power having been
	170	* removed from the slot/adapter.
	171	*/
	172	msleep(1000);
1da177e4 LT	173	}
1da177e4 LT	174
ae416e6b	175	if (PWR_LED(ctrl))
82a9e79e	176	pciehp_green_led_off(pslot);
1da177e4	177
ae416e6b	178	if (ATTN_LED(ctrl)) {
82a9e79e	179	if (pciehp_set_attention_status(pslot, 1)) {
18b341b7 TI	180	ctrl_err(ctrl,
18b341b7 TI	181	"Issue of Set Attention Led command failed\n");
1da177e4 LT	182	return;
1da177e4 LT	183	}
1da177e4	184	}
1da177e4 LT	185	}
	186
	187	/**
	188	* board_added - Called after a board has been added to the system.
26e6c66e	189	* @p_slot: &slot where board is added
1da177e4	190	*
26e6c66e RD	191	* Turns power on for the board.
26e6c66e RD	192	* Configures board.
1da177e4	193	*/
ed6cbcf2	194	static int board_added(struct slot *p_slot)
1da177e4	195	{
44ef4cef	196	int retval = 0;
ca22a5e4	197	struct controller *ctrl = p_slot->ctrl;
385e2491	198	struct pci_bus *parent = ctrl->pcie->port->subordinate;
1da177e4	199
ae416e6b	200	if (POWER_CTRL(ctrl)) {
1da177e4	201	/* Power on slot */
82a9e79e	202	retval = pciehp_power_on_slot(p_slot);
44ef4cef KK	203	if (retval)
44ef4cef KK	204	return retval;
1da177e4	205	}
36ed27b0	206
ae416e6b	207	if (PWR_LED(ctrl))
82a9e79e	208	pciehp_green_led_blink(p_slot);
1da177e4	209
44ef4cef	210	/* Check link training status */
82a9e79e	211	retval = pciehp_check_link_status(ctrl);
44ef4cef	212	if (retval) {
18b341b7	213	ctrl_err(ctrl, "Failed to check link status\n");
5651c48c	214	goto err_exit;
1da177e4 LT	215	}
1da177e4 LT	216
1da177e4	217	/* Check for a power fault */
5651c48c KK	218	if (ctrl->power_fault_detected \|\| pciehp_query_power_fault(p_slot)) {
5651c48c KK	219	ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
d9fb42a8	220	retval = -EIO;
71b720c0	221	goto err_exit;
1da177e4 LT	222	}
1da177e4 LT	223
44ef4cef KK	224	retval = pciehp_configure_device(p_slot);
44ef4cef KK	225	if (retval) {
d689f7eb KK	226	ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
d689f7eb KK	227	pci_domain_nr(parent), parent->number);
71b720c0 RS	228	goto err_exit;
71b720c0 RS	229	}
1da177e4	230
ae416e6b	231	if (PWR_LED(ctrl))
82a9e79e	232	pciehp_green_led_on(p_slot);
44ef4cef	233
1da177e4	234	return 0;
71b720c0 RS	235
	236	err_exit:
	237	set_slot_off(ctrl, p_slot);
44ef4cef	238	return retval;
1da177e4 LT	239	}
1da177e4 LT	240
1da177e4	241	/**
26e6c66e RD	242	* remove_board - Turns off slot and LEDs
26e6c66e RD	243	* @p_slot: slot where board is being removed
1da177e4	244	*/
ed6cbcf2	245	static int remove_board(struct slot *p_slot)
1da177e4	246	{
44ef4cef	247	int retval = 0;
ca22a5e4	248	struct controller *ctrl = p_slot->ctrl;
1da177e4	249
44ef4cef KK	250	retval = pciehp_unconfigure_device(p_slot);
	251	if (retval)
	252	return retval;
1da177e4	253
ae416e6b	254	if (POWER_CTRL(ctrl)) {
1da177e4	255	/* power off slot */
82a9e79e	256	retval = pciehp_power_off_slot(p_slot);
44ef4cef	257	if (retval) {
18b341b7 TI	258	ctrl_err(ctrl,
18b341b7 TI	259	"Issue of Slot Disable command failed\n");
44ef4cef	260	return retval;
1da177e4	261	}
c7b4fee3 KK	262	/*
	263	* After turning power off, we must wait for at least 1 second
	264	* before taking any action that relies on power having been
	265	* removed from the slot/adapter.
	266	*/
	267	msleep(1000);
1da177e4 LT	268	}
1da177e4 LT	269
82a9e79e	270	/* turn off Green LED */
ae416e6b	271	if (PWR_LED(ctrl))
82a9e79e	272	pciehp_green_led_off(p_slot);
1da177e4	273
1da177e4 LT	274	return 0;
	275	}
	276
5d386e1a KK	277	struct power_work_info {
	278	struct slot *p_slot;
	279	struct work_struct work;
	280	};
1da177e4 LT	281
1da177e4 LT	282	/**
26e6c66e RD	283	* pciehp_power_thread - handle pushbutton events
26e6c66e RD	284	* @work: &struct work_struct describing work to be done
1da177e4	285	*
26e6c66e	286	* Scheduled procedure to handle blocking stuff for the pushbuttons.
1da177e4	287	* Handles all pending events and exits.
1da177e4	288	*/
5d386e1a	289	static void pciehp_power_thread(struct work_struct *work)
1da177e4	290	{
5d386e1a KK	291	struct power_work_info *info =
	292	container_of(work, struct power_work_info, work);
	293	struct slot *p_slot = info->p_slot;
	294
	295	mutex_lock(&p_slot->lock);
	296	switch (p_slot->state) {
	297	case POWEROFF_STATE:
	298	mutex_unlock(&p_slot->lock);
18b341b7	299	ctrl_dbg(p_slot->ctrl,
d689f7eb	300	"Disabling domain:bus:device=%04x:%02x:00\n",
385e2491 KK	301	pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
385e2491 KK	302	p_slot->ctrl->pcie->port->subordinate->number);
1da177e4	303	pciehp_disable_slot(p_slot);
5d386e1a	304	mutex_lock(&p_slot->lock);
1da177e4	305	p_slot->state = STATIC_STATE;
5d386e1a KK	306	break;
	307	case POWERON_STATE:
	308	mutex_unlock(&p_slot->lock);
82a9e79e KK	309	if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
82a9e79e KK	310	pciehp_green_led_off(p_slot);
5d386e1a	311	mutex_lock(&p_slot->lock);
1da177e4	312	p_slot->state = STATIC_STATE;
5d386e1a KK	313	break;
	314	default:
	315	break;
1da177e4	316	}
5d386e1a	317	mutex_unlock(&p_slot->lock);
1da177e4	318
5d386e1a	319	kfree(info);
1da177e4 LT	320	}
1da177e4 LT	321
e325e1f0	322	void pciehp_queue_pushbutton_work(struct work_struct *work)
1da177e4	323	{
5d386e1a KK	324	struct slot *p_slot = container_of(work, struct slot, work.work);
5d386e1a KK	325	struct power_work_info *info;
1da177e4	326
5d386e1a KK	327	info = kmalloc(sizeof(*info), GFP_KERNEL);
5d386e1a KK	328	if (!info) {
7f2feec1 TI	329	ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
7f2feec1 TI	330	__func__);
1da177e4 LT	331	return;
1da177e4 LT	332	}
5d386e1a KK	333	info->p_slot = p_slot;
5d386e1a KK	334	INIT_WORK(&info->work, pciehp_power_thread);
1da177e4	335
5d386e1a KK	336	mutex_lock(&p_slot->lock);
	337	switch (p_slot->state) {
	338	case BLINKINGOFF_STATE:
1da177e4	339	p_slot->state = POWEROFF_STATE;
5d386e1a KK	340	break;
5d386e1a KK	341	case BLINKINGON_STATE:
1da177e4	342	p_slot->state = POWERON_STATE;
5d386e1a KK	343	break;
5d386e1a KK	344	default:
6fcaf17a	345	kfree(info);
5d386e1a	346	goto out;
1da177e4	347	}
5d386e1a KK	348	queue_work(pciehp_wq, &info->work);
	349	out:
	350	mutex_unlock(&p_slot->lock);
1da177e4 LT	351	}
1da177e4 LT	352
5d386e1a KK	353	/*
	354	* Note: This function must be called with slot->lock held
	355	*/
	356	static void handle_button_press_event(struct slot *p_slot)
1da177e4	357	{
5d386e1a	358	struct controller *ctrl = p_slot->ctrl;
1da177e4	359	u8 getstatus;
1da177e4	360
5d386e1a KK	361	switch (p_slot->state) {
5d386e1a KK	362	case STATIC_STATE:
82a9e79e	363	pciehp_get_power_status(p_slot, &getstatus);
5d386e1a KK	364	if (getstatus) {
5d386e1a KK	365	p_slot->state = BLINKINGOFF_STATE;
7f2feec1 TI	366	ctrl_info(ctrl,
7f2feec1 TI	367	"PCI slot #%s - powering off due to button "
e1acb24f	368	"press.\n", slot_name(p_slot));
5d386e1a KK	369	} else {
5d386e1a KK	370	p_slot->state = BLINKINGON_STATE;
7f2feec1 TI	371	ctrl_info(ctrl,
7f2feec1 TI	372	"PCI slot #%s - powering on due to button "
e1acb24f	373	"press.\n", slot_name(p_slot));
5d386e1a KK	374	}
5d386e1a KK	375	/* blink green LED and turn off amber */
ae416e6b	376	if (PWR_LED(ctrl))
82a9e79e	377	pciehp_green_led_blink(p_slot);
ae416e6b	378	if (ATTN_LED(ctrl))
82a9e79e	379	pciehp_set_attention_status(p_slot, 0);
5d386e1a KK	380
	381	schedule_delayed_work(&p_slot->work, 5*HZ);
	382	break;
	383	case BLINKINGOFF_STATE:
	384	case BLINKINGON_STATE:
	385	/*
	386	* Cancel if we are still blinking; this means that we
	387	* press the attention again before the 5 sec. limit
	388	* expires to cancel hot-add or hot-remove
	389	*/
e1acb24f	390	ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
5d386e1a KK	391	cancel_delayed_work(&p_slot->work);
5d386e1a KK	392	if (p_slot->state == BLINKINGOFF_STATE) {
ae416e6b	393	if (PWR_LED(ctrl))
82a9e79e	394	pciehp_green_led_on(p_slot);
5d386e1a	395	} else {
ae416e6b	396	if (PWR_LED(ctrl))
82a9e79e	397	pciehp_green_led_off(p_slot);
5d386e1a	398	}
ae416e6b	399	if (ATTN_LED(ctrl))
82a9e79e	400	pciehp_set_attention_status(p_slot, 0);
7f2feec1	401	ctrl_info(ctrl, "PCI slot #%s - action canceled "
e1acb24f	402	"due to button press\n", slot_name(p_slot));
5d386e1a KK	403	p_slot->state = STATIC_STATE;
	404	break;
	405	case POWEROFF_STATE:
	406	case POWERON_STATE:
	407	/*
	408	* Ignore if the slot is on power-on or power-off state;
	409	* this means that the previous attention button action
	410	* to hot-add or hot-remove is undergoing
	411	*/
e1acb24f	412	ctrl_info(ctrl, "Button ignore on Slot(%s)\n", slot_name(p_slot));
5d386e1a KK	413	break;
5d386e1a KK	414	default:
7f2feec1	415	ctrl_warn(ctrl, "Not a valid state\n");
5d386e1a	416	break;
1da177e4 LT	417	}
	418	}
	419
5d386e1a KK	420	/*
	421	* Note: This function must be called with slot->lock held
	422	*/
	423	static void handle_surprise_event(struct slot *p_slot)
	424	{
	425	u8 getstatus;
	426	struct power_work_info *info;
	427
	428	info = kmalloc(sizeof(*info), GFP_KERNEL);
	429	if (!info) {
7f2feec1 TI	430	ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
7f2feec1 TI	431	__func__);
5d386e1a KK	432	return;
	433	}
	434	info->p_slot = p_slot;
	435	INIT_WORK(&info->work, pciehp_power_thread);
	436
82a9e79e	437	pciehp_get_adapter_status(p_slot, &getstatus);
5d386e1a KK	438	if (!getstatus)
	439	p_slot->state = POWEROFF_STATE;
	440	else
	441	p_slot->state = POWERON_STATE;
	442
	443	queue_work(pciehp_wq, &info->work);
	444	}
	445
	446	static void interrupt_event_handler(struct work_struct *work)
	447	{
	448	struct event_info *info = container_of(work, struct event_info, work);
	449	struct slot *p_slot = info->p_slot;
	450	struct controller *ctrl = p_slot->ctrl;
	451
	452	mutex_lock(&p_slot->lock);
	453	switch (info->event_type) {
	454	case INT_BUTTON_PRESS:
	455	handle_button_press_event(p_slot);
	456	break;
	457	case INT_POWER_FAULT:
ae416e6b	458	if (!POWER_CTRL(ctrl))
5d386e1a	459	break;
ae416e6b	460	if (ATTN_LED(ctrl))
82a9e79e	461	pciehp_set_attention_status(p_slot, 1);
ae416e6b	462	if (PWR_LED(ctrl))
82a9e79e	463	pciehp_green_led_off(p_slot);
5d386e1a KK	464	break;
	465	case INT_PRESENCE_ON:
	466	case INT_PRESENCE_OFF:
ae416e6b	467	if (!HP_SUPR_RM(ctrl))
5d386e1a	468	break;
7f2feec1	469	ctrl_dbg(ctrl, "Surprise Removal\n");
5d386e1a KK	470	handle_surprise_event(p_slot);
	471	break;
	472	default:
5d386e1a KK	473	break;
	474	}
	475	mutex_unlock(&p_slot->lock);
	476
	477	kfree(info);
	478	}
	479
1da177e4 LT	480	int pciehp_enable_slot(struct slot *p_slot)
	481	{
	482	u8 getstatus = 0;
	483	int rc;
7f2feec1	484	struct controller *ctrl = p_slot->ctrl;
1da177e4	485
82a9e79e	486	rc = pciehp_get_adapter_status(p_slot, &getstatus);
1da177e4	487	if (rc \|\| !getstatus) {
18b341b7	488	ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
c9d86d76	489	return -ENODEV;
1da177e4	490	}
ae416e6b	491	if (MRL_SENS(p_slot->ctrl)) {
82a9e79e	492	rc = pciehp_get_latch_status(p_slot, &getstatus);
1da177e4	493	if (rc \|\| getstatus) {
18b341b7 TI	494	ctrl_info(ctrl, "Latch open on slot(%s)\n",
18b341b7 TI	495	slot_name(p_slot));
c9d86d76	496	return -ENODEV;
1da177e4 LT	497	}
1da177e4 LT	498	}
36ed27b0	499
ae416e6b	500	if (POWER_CTRL(p_slot->ctrl)) {
82a9e79e	501	rc = pciehp_get_power_status(p_slot, &getstatus);
1da177e4	502	if (rc \|\| getstatus) {
18b341b7 TI	503	ctrl_info(ctrl, "Already enabled on slot(%s)\n",
18b341b7 TI	504	slot_name(p_slot));
c9d86d76	505	return -EINVAL;
1da177e4 LT	506	}
1da177e4 LT	507	}
1da177e4	508
82a9e79e	509	pciehp_get_latch_status(p_slot, &getstatus);
1da177e4	510
ca22a5e4	511	rc = board_added(p_slot);
1da177e4	512	if (rc) {
82a9e79e	513	pciehp_get_latch_status(p_slot, &getstatus);
1da177e4	514	}
1da177e4 LT	515	return rc;
	516	}
	517
	518
	519	int pciehp_disable_slot(struct slot *p_slot)
	520	{
1da177e4	521	u8 getstatus = 0;
1da177e4	522	int ret = 0;
7f2feec1	523	struct controller *ctrl = p_slot->ctrl;
1da177e4 LT	524
	525	if (!p_slot->ctrl)
	526	return 1;
	527
ae416e6b	528	if (!HP_SUPR_RM(p_slot->ctrl)) {
82a9e79e	529	ret = pciehp_get_adapter_status(p_slot, &getstatus);
1da177e4	530	if (ret \|\| !getstatus) {
18b341b7 TI	531	ctrl_info(ctrl, "No adapter on slot(%s)\n",
18b341b7 TI	532	slot_name(p_slot));
c9d86d76	533	return -ENODEV;
1da177e4 LT	534	}
	535	}
	536
ae416e6b	537	if (MRL_SENS(p_slot->ctrl)) {
82a9e79e	538	ret = pciehp_get_latch_status(p_slot, &getstatus);
1da177e4	539	if (ret \|\| getstatus) {
18b341b7 TI	540	ctrl_info(ctrl, "Latch open on slot(%s)\n",
18b341b7 TI	541	slot_name(p_slot));
c9d86d76	542	return -ENODEV;
1da177e4 LT	543	}
	544	}
	545
ae416e6b	546	if (POWER_CTRL(p_slot->ctrl)) {
82a9e79e	547	ret = pciehp_get_power_status(p_slot, &getstatus);
1da177e4	548	if (ret \|\| !getstatus) {
18b341b7 TI	549	ctrl_info(ctrl, "Already disabled on slot(%s)\n",
18b341b7 TI	550	slot_name(p_slot));
c9d86d76	551	return -EINVAL;
1da177e4 LT	552	}
	553	}
	554
445f7985	555	return remove_board(p_slot);
1da177e4 LT	556	}
1da177e4 LT	557
5d386e1a KK	558	int pciehp_sysfs_enable_slot(struct slot *p_slot)
	559	{
	560	int retval = -ENODEV;
7f2feec1	561	struct controller *ctrl = p_slot->ctrl;
5d386e1a KK	562
	563	mutex_lock(&p_slot->lock);
	564	switch (p_slot->state) {
	565	case BLINKINGON_STATE:
	566	cancel_delayed_work(&p_slot->work);
	567	case STATIC_STATE:
	568	p_slot->state = POWERON_STATE;
	569	mutex_unlock(&p_slot->lock);
	570	retval = pciehp_enable_slot(p_slot);
	571	mutex_lock(&p_slot->lock);
	572	p_slot->state = STATIC_STATE;
	573	break;
	574	case POWERON_STATE:
7f2feec1	575	ctrl_info(ctrl, "Slot %s is already in powering on state\n",
e1acb24f	576	slot_name(p_slot));
5d386e1a KK	577	break;
	578	case BLINKINGOFF_STATE:
	579	case POWEROFF_STATE:
e1acb24f AC	580	ctrl_info(ctrl, "Already enabled on slot %s\n",
e1acb24f AC	581	slot_name(p_slot));
5d386e1a KK	582	break;
5d386e1a KK	583	default:
e1acb24f AC	584	ctrl_err(ctrl, "Not a valid state on slot %s\n",
e1acb24f AC	585	slot_name(p_slot));
5d386e1a KK	586	break;
	587	}
	588	mutex_unlock(&p_slot->lock);
	589
	590	return retval;
	591	}
	592
	593	int pciehp_sysfs_disable_slot(struct slot *p_slot)
	594	{
	595	int retval = -ENODEV;
7f2feec1	596	struct controller *ctrl = p_slot->ctrl;
5d386e1a KK	597
	598	mutex_lock(&p_slot->lock);
	599	switch (p_slot->state) {
	600	case BLINKINGOFF_STATE:
	601	cancel_delayed_work(&p_slot->work);
	602	case STATIC_STATE:
	603	p_slot->state = POWEROFF_STATE;
	604	mutex_unlock(&p_slot->lock);
	605	retval = pciehp_disable_slot(p_slot);
	606	mutex_lock(&p_slot->lock);
	607	p_slot->state = STATIC_STATE;
	608	break;
	609	case POWEROFF_STATE:
7f2feec1	610	ctrl_info(ctrl, "Slot %s is already in powering off state\n",
e1acb24f	611	slot_name(p_slot));
5d386e1a KK	612	break;
	613	case BLINKINGON_STATE:
	614	case POWERON_STATE:
e1acb24f AC	615	ctrl_info(ctrl, "Already disabled on slot %s\n",
e1acb24f AC	616	slot_name(p_slot));
5d386e1a KK	617	break;
5d386e1a KK	618	default:
e1acb24f AC	619	ctrl_err(ctrl, "Not a valid state on slot %s\n",
e1acb24f AC	620	slot_name(p_slot));
5d386e1a KK	621	break;
	622	}
	623	mutex_unlock(&p_slot->lock);
	624
	625	return retval;
	626	}