/* * 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/smp_lock.h>#include <linux/pci.h>#include "../pci.h"#include "pciehp.h"static void interrupt_event_handler(struct controller *ctrl);static struct semaphore event_semaphore;	/* mutex for process loop (up if something to process) */static struct semaphore event_exit;		/* guard ensure thread has exited before calling it quits */static int event_finished;static unsigned long pushbutton_pending;	/* = 0 */static unsigned long surprise_rm_pending;	/* = 0 */u8 pciehp_handle_attention_button(u8 hp_slot, void *inst_id){	struct controller *ctrl = (struct controller *) inst_id;	struct slot *p_slot;	u8 rc = 0;	u8 getstatus;	struct event_info *taskInfo;	/* Attention Button Change */	dbg("pciehp:  Attention button interrupt received.\n");		/* This is the structure that tells the worker thread what to do */	taskInfo = &(ctrl->event_queue[ctrl->next_event]);	p_slot = pciehp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);	p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);		ctrl->next_event = (ctrl->next_event + 1) % MAX_EVENTS;	taskInfo->hp_slot = hp_slot;	rc++;	/*	 *  Button pressed - See if need to TAKE ACTION!!!	 */	info("Button pressed on Slot(%d)\n", ctrl->first_slot + hp_slot);	taskInfo->event_type = INT_BUTTON_PRESS;	if ((p_slot->state == BLINKINGON_STATE)	    || (p_slot->state == BLINKINGOFF_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		 */		taskInfo->event_type = INT_BUTTON_CANCEL;		info("Button cancel on Slot(%d)\n", ctrl->first_slot + hp_slot);	} else if ((p_slot->state == POWERON_STATE)		   || (p_slot->state == POWEROFF_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		 */		taskInfo->event_type = INT_BUTTON_IGNORE;		info("Button ignore on Slot(%d)\n", ctrl->first_slot + hp_slot);	}	if (rc)		up(&event_semaphore);	/* signal event thread that new event is posted */	return 0;}u8 pciehp_handle_switch_change(u8 hp_slot, void *inst_id){	struct controller *ctrl = (struct controller *) inst_id;	struct slot *p_slot;	u8 rc = 0;	u8 getstatus;	struct event_info *taskInfo;	/* Switch Change */	dbg("pciehp:  Switch interrupt received.\n");	/* This is the structure that tells the worker thread	 * what to do	 */	taskInfo = &(ctrl->event_queue[ctrl->next_event]);	ctrl->next_event = (ctrl->next_event + 1) % MAX_EVENTS;	taskInfo->hp_slot = hp_slot;	rc++;	p_slot = pciehp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);	p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);	if (getstatus) {		/*		 * Switch opened		 */		info("Latch open on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_SWITCH_OPEN;	} else {		/*		 *  Switch closed		 */		info("Latch close on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_SWITCH_CLOSE;	}	if (rc)		up(&event_semaphore);	/* signal event thread that new event is posted */	return rc;}u8 pciehp_handle_presence_change(u8 hp_slot, void *inst_id){	struct controller *ctrl = (struct controller *) inst_id;	struct slot *p_slot;	u8 presence_save, rc = 0;	struct event_info *taskInfo;	/* Presence Change */	dbg("pciehp:  Presence/Notify input change.\n");	/* This is the structure that tells the worker thread	 * what to do	 */	taskInfo = &(ctrl->event_queue[ctrl->next_event]);	ctrl->next_event = (ctrl->next_event + 1) % MAX_EVENTS;	taskInfo->hp_slot = hp_slot;	rc++;	p_slot = pciehp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);	/* Switch is open, assume a presence change	 * Save the presence state	 */	p_slot->hpc_ops->get_adapter_status(p_slot, &presence_save);	if (presence_save) {		/*		 * Card Present		 */		info("Card present on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_PRESENCE_ON;	} else {		/*		 * Not Present		 */		info("Card not present on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_PRESENCE_OFF;	}	if (rc)		up(&event_semaphore);	/* signal event thread that new event is posted */	return rc;}u8 pciehp_handle_power_fault(u8 hp_slot, void *inst_id){	struct controller *ctrl = (struct controller *) inst_id;	struct slot *p_slot;	u8 rc = 0;	struct event_info *taskInfo;	/* power fault */	dbg("pciehp:  Power fault interrupt received.\n");	/* this is the structure that tells the worker thread	 * what to do	 */	taskInfo = &(ctrl->event_queue[ctrl->next_event]);	ctrl->next_event = (ctrl->next_event + 1) % MAX_EVENTS;	taskInfo->hp_slot = hp_slot;	rc++;	p_slot = pciehp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);	if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {		/*		 * power fault Cleared		 */		info("Power fault cleared on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_POWER_FAULT_CLEAR;	} else {		/*		 *   power fault		 */		info("Power fault on Slot(%d)\n", ctrl->first_slot + hp_slot);		taskInfo->event_type = INT_POWER_FAULT;		info("power fault bit %x set\n", hp_slot);	}	if (rc)		up(&event_semaphore);	/* signal event thread that new event is posted */	return rc;}/* The following routines constitute the bulk of the    hotplug controller logic */static void set_slot_off(struct controller *ctrl, struct slot * pslot){	/* Wait for exclusive access to hardware */	down(&ctrl->crit_sect);	/* turn off slot, turn on Amber LED, turn off Green LED if supported*/	if (POWER_CTRL(ctrl->ctrlcap)) {		if (pslot->hpc_ops->power_off_slot(pslot)) {   			err("%s: Issue of Slot Power Off command failed\n", __FUNCTION__);			up(&ctrl->crit_sect);			return;		}		wait_for_ctrl_irq (ctrl);	}	if (PWR_LED(ctrl->ctrlcap)) {		pslot->hpc_ops->green_led_off(pslot);   		wait_for_ctrl_irq (ctrl);	}	if (ATTN_LED(ctrl->ctrlcap)) { 		if (pslot->hpc_ops->set_attention_status(pslot, 1)) {   			err("%s: Issue of Set Attention Led command failed\n", __FUNCTION__);			up(&ctrl->crit_sect);			return;		}		wait_for_ctrl_irq (ctrl);	}	/* Done with exclusive hardware access */	up(&ctrl->crit_sect);}/** * board_added - Called after a board has been added to the system. * * Turns power on for the board * Configures board * */static int board_added(struct slot *p_slot){	u8 hp_slot;	int rc = 0;	struct controller *ctrl = p_slot->ctrl;	hp_slot = p_slot->device - ctrl->slot_device_offset;	dbg("%s: slot device, slot offset, hp slot = %d, %d ,%d\n",			__FUNCTION__, p_slot->device,			ctrl->slot_device_offset, hp_slot);	/* Wait for exclusive access to hardware */	down(&ctrl->crit_sect);	if (POWER_CTRL(ctrl->ctrlcap)) {		/* Power on slot */		rc = p_slot->hpc_ops->power_on_slot(p_slot);		if (rc) {			up(&ctrl->crit_sect);			return -1;		}		/* Wait for the command to complete */		wait_for_ctrl_irq (ctrl);	}		if (PWR_LED(ctrl->ctrlcap)) {		p_slot->hpc_ops->green_led_blink(p_slot);					/* Wait for the command to complete */		wait_for_ctrl_irq (ctrl);	}	/* Done with exclusive hardware access */	up(&ctrl->crit_sect);	/* Wait for ~1 second */	wait_for_ctrl_irq (ctrl);	/*  Check link training status */	rc = p_slot->hpc_ops->check_lnk_status(ctrl);  	if (rc) {		err("%s: Failed to check link status\n", __FUNCTION__);		set_slot_off(ctrl, p_slot);		return rc;	}	/* Check for a power fault */	if (p_slot->hpc_ops->query_power_fault(p_slot)) {		dbg("%s: power fault detected\n", __FUNCTION__);		rc = POWER_FAILURE;		goto err_exit;	}	rc = pciehp_configure_device(p_slot);	if (rc) {		err("Cannot add device 0x%x:%x\n", p_slot->bus,				p_slot->device);		goto err_exit;	}	/*	 * Some PCI Express root ports require fixup after hot-plug operation.	 */	if (pcie_mch_quirk)		pci_fixup_device(pci_fixup_final, ctrl->pci_dev);	if (PWR_LED(ctrl->ctrlcap)) {		/* Wait for exclusive access to hardware */  		down(&ctrl->crit_sect);  		p_slot->hpc_ops->green_led_on(p_slot);    		/* Wait for the command to complete */  		wait_for_ctrl_irq (ctrl);  	  		/* Done with exclusive hardware access */  		up(&ctrl->crit_sect);  	}	return 0;err_exit:	set_slot_off(ctrl, p_slot);	return -1;}/** * remove_board - Turns off slot and LED's * */static int remove_board(struct slot *p_slot){	u8 device;	u8 hp_slot;	int rc;	struct controller *ctrl = p_slot->ctrl;	if (pciehp_unconfigure_device(p_slot))		return 1;	device = p_slot->device;	hp_slot = p_slot->device - ctrl->slot_device_offset;	p_slot = pciehp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);	dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot);	/* Wait for exclusive access to hardware */	down(&ctrl->crit_sect);	if (POWER_CTRL(ctrl->ctrlcap)) {		/* power off slot */		rc = p_slot->hpc_ops->power_off_slot(p_slot);		if (rc) {			err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);			up(&ctrl->crit_sect);			return rc;		}		/* Wait for the command to complete */		wait_for_ctrl_irq (ctrl);	}	if (PWR_LED(ctrl->ctrlcap)) {		/* turn off Green LED */		p_slot->hpc_ops->green_led_off(p_slot);			/* Wait for the command to complete */		wait_for_ctrl_irq (ctrl);	}	/* Done with exclusive hardware access */	up(&ctrl->crit_sect);	return 0;}static void pushbutton_helper_thread(unsigned long data){	pushbutton_pending = data;	up(&event_semaphore);}/** * pciehp_pushbutton_thread * * Scheduled procedure to handle blocking stuff for the pushbuttons * Handles all pending events and exits. * */static void pciehp_pushbutton_thread(unsigned long slot){	struct slot *p_slot = (struct slot *) slot;