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

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
 *
 * This work was based on the 2.4/2.6 kernel development by Dick Reigner.
 * Work to add BIOS PROM support was completed by Mike Habeck.
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/proc_fs.h>
#include <linux/types.h>
#include <linux/mutex.h>

#include <asm/sn/addrs.h>
#include <asm/sn/geo.h>
#include <asm/sn/l1.h>
#include <asm/sn/module.h>
#include <asm/sn/pcibr_provider.h>
#include <asm/sn/pcibus_provider_defs.h>
#include <asm/sn/pcidev.h>
#include <asm/sn/sn_feature_sets.h>
#include <asm/sn/sn_sal.h>
#include <asm/sn/types.h>

#include "../pci.h"
#include "pci_hotplug.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");

#define PCIIO_ASIC_TYPE_TIOCA		4
#define PCI_SLOT_ALREADY_UP		2	/* slot already up */
#define PCI_SLOT_ALREADY_DOWN		3	/* slot already down */
#define PCI_L1_ERR			7	/* L1 console command error */
#define PCI_EMPTY_33MHZ			15	/* empty 33 MHz bus */
#define PCI_L1_QSIZE			128	/* our L1 message buffer size */
#define SN_MAX_HP_SLOTS			32	/* max hotplug slots */
#define SGI_HOTPLUG_PROM_REV		0x0430	/* Min. required PROM version */
#define SN_SLOT_NAME_SIZE		33	/* size of name string */

/* internal list head */
static struct list_head sn_hp_list;

/* hotplug_slot struct's private pointer */
struct slot {
	int device_num;
	struct pci_bus *pci_bus;
	/* this struct for glue internal only */
	struct hotplug_slot *hotplug_slot;
	struct list_head hp_list;
	char physical_path[SN_SLOT_NAME_SIZE];
};

struct pcibr_slot_enable_resp {
	int resp_sub_errno;
	char resp_l1_msg[PCI_L1_QSIZE + 1];
};

struct pcibr_slot_disable_resp {
	int resp_sub_errno;
	char resp_l1_msg[PCI_L1_QSIZE + 1];
};

enum sn_pci_req_e {
	PCI_REQ_SLOT_ELIGIBLE,
	PCI_REQ_SLOT_DISABLE
};

static int enable_slot(struct hotplug_slot *slot);
static int disable_slot(struct hotplug_slot *slot);
static inline int get_power_status(struct hotplug_slot *slot, u8 *value);

static struct hotplug_slot_ops sn_hotplug_slot_ops = {
	.owner                  = THIS_MODULE,
	.enable_slot            = enable_slot,
	.disable_slot           = disable_slot,
	.get_power_status       = get_power_status,
};

static DEFINE_MUTEX(sn_hotplug_mutex);

static ssize_t path_show (struct hotplug_slot *bss_hotplug_slot,
	       		  char *buf)
{
	int retval = -ENOENT;
	struct slot *slot = bss_hotplug_slot->private;

	if (!slot)
		return retval;

	retval = sprintf (buf, "%s\n", slot->physical_path);
	return retval;
}

static struct hotplug_slot_attribute sn_slot_path_attr = __ATTR_RO(path);

static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
{
	struct pcibus_info *pcibus_info;
	u16 busnum, segment, ioboard_type;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);

	/* Check to see if this is a valid slot on 'pci_bus' */
	if (!(pcibus_info->pbi_valid_devices & (1 << device)))
		return -EPERM;

	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
	busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
	segment = pci_domain_nr(pci_bus) & 0xf;

	/* Do not allow hotplug operations on base I/O cards */
	if ((ioboard_type == L1_BRICKTYPE_IX ||
	     ioboard_type == L1_BRICKTYPE_IA) &&
	    (segment == 1 && busnum == 0 && device != 1))
		return -EPERM;

	return 1;
}

static int sn_pci_bus_valid(struct pci_bus *pci_bus)
{
	struct pcibus_info *pcibus_info;
	u32 asic_type;
	u16 ioboard_type;

	/* Don't register slots hanging off the TIOCA bus */
	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
	asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
	if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
		return -EPERM;

	/* Only register slots in I/O Bricks that support hotplug */
	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
	switch (ioboard_type) {
		case L1_BRICKTYPE_IX:
		case L1_BRICKTYPE_PX:
		case L1_BRICKTYPE_IA:
		case L1_BRICKTYPE_PA:
		case L1_BOARDTYPE_PCIX3SLOT:
			return 1;
			break;
		default:
			return -EPERM;
			break;
	}

	return -EIO;
}

static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
				    struct pci_bus *pci_bus, int device)
{
	struct pcibus_info *pcibus_info;
	struct slot *slot;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);

	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	if (!slot)
		return -ENOMEM;
	bss_hotplug_slot->private = slot;

	bss_hotplug_slot->name = kmalloc(SN_SLOT_NAME_SIZE, GFP_KERNEL);
	if (!bss_hotplug_slot->name) {
		kfree(bss_hotplug_slot->private);
		return -ENOMEM;
	}

	slot->device_num = device;
	slot->pci_bus = pci_bus;
	sprintf(bss_hotplug_slot->name, "%04x:%02x:%02x",
		pci_domain_nr(pci_bus),
		((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
		device + 1);

	sn_generate_path(pci_bus, slot->physical_path);

	slot->hotplug_slot = bss_hotplug_slot;
	list_add(&slot->hp_list, &sn_hp_list);

	return 0;
}

static struct hotplug_slot * sn_hp_destroy(void)
{
	struct slot *slot;
	struct hotplug_slot *bss_hotplug_slot = NULL;

	list_for_each_entry(slot, &sn_hp_list, hp_list) {
		bss_hotplug_slot = slot->hotplug_slot;
		list_del(&((struct slot *)bss_hotplug_slot->private)->
			 hp_list);
		sysfs_remove_file(&bss_hotplug_slot->kobj,
				  &sn_slot_path_attr.attr);
		break;
	}
	return bss_hotplug_slot;
}

static void sn_bus_alloc_data(struct pci_dev *dev)
{
	struct pci_bus *subordinate_bus;
	struct pci_dev *child;

	sn_pci_fixup_slot(dev);

	/* Recursively sets up the sn_irq_info structs */
	if (dev->subordinate) {
		subordinate_bus = dev->subordinate;
		list_for_each_entry(child, &subordinate_bus->devices, bus_list)
			sn_bus_alloc_data(child);
	}
}

static void sn_bus_free_data(struct pci_dev *dev)
{
	struct pci_bus *subordinate_bus;
	struct pci_dev *child;

	/* Recursively clean up sn_irq_info structs */
	if (dev->subordinate) {
		subordinate_bus = dev->subordinate;
		list_for_each_entry(child, &subordinate_bus->devices, bus_list)
			sn_bus_free_data(child);
	}
	/*
	 * Some drivers may use dma accesses during the
	 * driver remove function. We release the sysdata
	 * areas after the driver remove functions have
	 * been called.
	 */
	sn_bus_store_sysdata(dev);
	sn_pci_unfixup_slot(dev);
}

static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
			  int device_num)
{
	struct slot *slot = bss_hotplug_slot->private;
	struct pcibus_info *pcibus_info;
	struct pcibr_slot_enable_resp resp;
	int rc;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);

	/*
	 * Power-on and initialize the slot in the SN
	 * PCI infrastructure.
	 */
	rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp);

	if (rc == PCI_SLOT_ALREADY_UP) {
		dev_dbg(slot->pci_bus->self, "is already active\n");
		return 1; /* return 1 to user */
	}

	if (rc == PCI_L1_ERR) {
		dev_dbg(slot->pci_bus->self,
			"L1 failure %d with message: %s",
			resp.resp_sub_errno, resp.resp_l1_msg);
		return -EPERM;
	}

	if (rc) {
		dev_dbg(slot->pci_bus->self,
			"insert failed with error %d sub-error %d\n",
			rc, resp.resp_sub_errno);
		return -EIO;
	}

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
	pcibus_info->pbi_enabled_devices |= (1 << device_num);

	return 0;
}

static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
			   int device_num, int action)
{
	struct slot *slot = bss_hotplug_slot->private;
	struct pcibus_info *pcibus_info;
	struct pcibr_slot_disable_resp resp;
	int rc;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);

	rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);

	if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
	    (rc == PCI_SLOT_ALREADY_DOWN)) {
		dev_dbg(slot->pci_bus->self, "Slot %s already inactive\n");
		return 1; /* return 1 to user */
	}

	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
		dev_dbg(slot->pci_bus->self,
			"Cannot remove last 33MHz card\n");
		return -EPERM;
	}

	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
		dev_dbg(slot->pci_bus->self,
			"L1 failure %d with message \n%s\n",
			resp.resp_sub_errno, resp.resp_l1_msg);
		return -EPERM;
	}

	if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
		dev_dbg(slot->pci_bus->self,
			"remove failed with error %d sub-error %d\n",
			rc, resp.resp_sub_errno);
		return -EIO;
	}

	if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
		return 0;

	if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
		pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
		pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
		dev_dbg(slot->pci_bus->self, "remove successful\n");
		return 0;
	}

	if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
		dev_dbg(slot->pci_bus->self,"remove failed rc = %d\n", rc);
	}

	return rc;
}

static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
{
	struct slot *slot = bss_hotplug_slot->private;
	struct pci_bus *new_bus = NULL;
	struct pci_dev *dev;
	int func, num_funcs;
	int new_ppb = 0;
	int rc;

	/* Serialize the Linux PCI infrastructure */
	mutex_lock(&sn_hotplug_mutex);

	/*
	 * Power-on and initialize the slot in the SN
	 * PCI infrastructure.
	 */
	rc = sn_slot_enable(bss_hotplug_slot, slot->device_num);
	if (rc) {
		mutex_unlock(&sn_hotplug_mutex);
		return rc;
	}

	num_funcs = pci_scan_slot(slot->pci_bus,
				  PCI_DEVFN(slot->device_num + 1, 0));
	if (!num_funcs) {
		dev_dbg(slot->pci_bus->self, "no device in slot\n");
		mutex_unlock(&sn_hotplug_mutex);
		return -ENODEV;
	}

	sn_pci_controller_fixup(pci_domain_nr(slot->pci_bus),
				slot->pci_bus->number,
				slot->pci_bus);
	/*
	 * Map SN resources for all functions on the card
	 * to the Linux PCI interface and tell the drivers
	 * about them.
	 */
	for (func = 0; func < num_funcs;  func++) {
		dev = pci_get_slot(slot->pci_bus,
				   PCI_DEVFN(slot->device_num + 1,
					     PCI_FUNC(func)));
		if (dev) {
			if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
				unsigned char sec_bus;
				pci_read_config_byte(dev, PCI_SECONDARY_BUS,
						     &sec_bus);
				new_bus = pci_add_new_bus(dev->bus, dev,
							  sec_bus);
				pci_scan_child_bus(new_bus);
				sn_pci_controller_fixup(pci_domain_nr(new_bus),
							new_bus->number,
							new_bus);
				new_ppb = 1;
			}
			sn_bus_alloc_data(dev);
			pci_dev_put(dev);
		}
	}

	/* Call the driver for the new device */
	pci_bus_add_devices(slot->pci_bus);
	/* Call the drivers for the new devices subordinate to PPB */
	if (new_ppb)
		pci_bus_add_devices(new_bus);

	mutex_unlock(&sn_hotplug_mutex);

	if (rc == 0)
		dev_dbg(slot->pci_bus->self,
			"insert operation successful\n");
	else
		dev_dbg(slot->pci_bus->self,
			"insert operation failed rc = %d\n", rc);

	return rc;
}

static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
{
	struct slot *slot = bss_hotplug_slot->private;
	struct pci_dev *dev;
	int func;
	int rc;

	/* Acquire update access to the bus */
	mutex_lock(&sn_hotplug_mutex);

	/* is it okay to bring this slot down? */
	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
			     PCI_REQ_SLOT_ELIGIBLE);
	if (rc)
		goto leaving;

	/* Free the SN resources assigned to the Linux device.*/
	for (func = 0; func < 8;  func++) {
		dev = pci_get_slot(slot->pci_bus,
				   PCI_DEVFN(slot->device_num + 1,
				   	     PCI_FUNC(func)));
		if (dev) {
			sn_bus_free_data(dev);
			pci_remove_bus_device(dev);
			pci_dev_put(dev);
		}
	}

	/* free the collected sysdata pointers */
	sn_bus_free_sysdata();

	/* Deactivate slot */
	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
			     PCI_REQ_SLOT_DISABLE);
 leaving:
	/* Release the bus lock */
	mutex_unlock(&sn_hotplug_mutex);

	return rc;
}

static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
				   u8 *value)
{
	struct slot *slot = bss_hotplug_slot->private;
	struct pcibus_info *pcibus_info;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
	mutex_lock(&sn_hotplug_mutex);
	*value = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
	mutex_unlock(&sn_hotplug_mutex);
	return 0;
}

static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
{
	kfree(bss_hotplug_slot->info);
	kfree(bss_hotplug_slot->name);
	kfree(bss_hotplug_slot->private);
	kfree(bss_hotplug_slot);
}

static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
{
	int device;
	struct hotplug_slot *bss_hotplug_slot;
	int rc = 0;

	/*
	 * Currently only four devices are supported,
	 * in the future there maybe more -- up to 32.
	 */

	for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
		if (sn_pci_slot_valid(pci_bus, device) != 1)
			continue;

		bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
					   GFP_KERNEL);
		if (!bss_hotplug_slot) {
			rc = -ENOMEM;
			goto alloc_err;
		}

		bss_hotplug_slot->info =
			kzalloc(sizeof(struct hotplug_slot_info),
				GFP_KERNEL);
		if (!bss_hotplug_slot->info) {
			rc = -ENOMEM;
			goto alloc_err;
		}

		if (sn_hp_slot_private_alloc(bss_hotplug_slot,
					     pci_bus, device)) {
			rc = -ENOMEM;
			goto alloc_err;
		}

		bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
		bss_hotplug_slot->release = &sn_release_slot;

		rc = pci_hp_register(bss_hotplug_slot);
		if (rc)
			goto register_err;

		rc = sysfs_create_file(&bss_hotplug_slot->kobj,
				       &sn_slot_path_attr.attr);
		if (rc)
			goto register_err;
	}
	dev_dbg(pci_bus->self, "Registered bus with hotplug\n");
	return rc;

register_err:
	dev_dbg(pci_bus->self, "bus failed to register with err = %d\n",
	        rc);

alloc_err:
	if (rc == -ENOMEM)
		dev_dbg(pci_bus->self, "Memory allocation error\n");

	/* destroy THIS element */
	if (bss_hotplug_slot)
		sn_release_slot(bss_hotplug_slot);

	/* destroy anything else on the list */
	while ((bss_hotplug_slot = sn_hp_destroy()))
		pci_hp_deregister(bss_hotplug_slot);

	return rc;
}

static int sn_pci_hotplug_init(void)
{
	struct pci_bus *pci_bus = NULL;
	int rc;
	int registered = 0;

	if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
		printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
		       __FUNCTION__);
		return -EPERM;
	}

	INIT_LIST_HEAD(&sn_hp_list);

	while ((pci_bus = pci_find_next_bus(pci_bus))) {
		if (!pci_bus->sysdata)
			continue;

		rc = sn_pci_bus_valid(pci_bus);
		if (rc != 1) {
			dev_dbg(pci_bus->self, "not a valid hotplug bus\n");
			continue;
		}
		dev_dbg(pci_bus->self, "valid hotplug bus\n");

		rc = sn_hotplug_slot_register(pci_bus);
		if (!rc) {
			registered = 1;
		} else {
			registered = 0;
			break;
		}
	}

	return registered == 1 ? 0 : -ENODEV;
}

static void sn_pci_hotplug_exit(void)
{
	struct hotplug_slot *bss_hotplug_slot;

	while ((bss_hotplug_slot = sn_hp_destroy()))
		pci_hp_deregister(bss_hotplug_slot);

	if (!list_empty(&sn_hp_list))
		printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
}

module_init(sn_pci_hotplug_init);
module_exit(sn_pci_hotplug_exit);
Commit	Line	Data
6f354b01 PB	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
8e77af6a	6	* Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
6f354b01 PB	7	*
	8	* This work was based on the 2.4/2.6 kernel development by Dick Reigner.
	9	* Work to add BIOS PROM support was completed by Mike Habeck.
	10	*/
	11
	12	#include <linux/init.h>
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/pci.h>
	16	#include <linux/proc_fs.h>
	17	#include <linux/types.h>
14cc3e2b	18	#include <linux/mutex.h>
6f354b01 PB	19
6f354b01 PB	20	#include <asm/sn/addrs.h>
e55dea58	21	#include <asm/sn/geo.h>
6f354b01 PB	22	#include <asm/sn/l1.h>
	23	#include <asm/sn/module.h>
	24	#include <asm/sn/pcibr_provider.h>
	25	#include <asm/sn/pcibus_provider_defs.h>
	26	#include <asm/sn/pcidev.h>
e55dea58	27	#include <asm/sn/sn_feature_sets.h>
6f354b01 PB	28	#include <asm/sn/sn_sal.h>
	29	#include <asm/sn/types.h>
	30
	31	#include "../pci.h"
	32	#include "pci_hotplug.h"
	33
	34	MODULE_LICENSE("GPL");
	35	MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
	36	MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
	37
1d2450a4 PB	38	#define PCIIO_ASIC_TYPE_TIOCA 4
	39	#define PCI_SLOT_ALREADY_UP 2 /* slot already up */
	40	#define PCI_SLOT_ALREADY_DOWN 3 /* slot already down */
	41	#define PCI_L1_ERR 7 /* L1 console command error */
	42	#define PCI_EMPTY_33MHZ 15 /* empty 33 MHz bus */
	43	#define PCI_L1_QSIZE 128 /* our L1 message buffer size */
	44	#define SN_MAX_HP_SLOTS 32 /* max hotplug slots */
	45	#define SGI_HOTPLUG_PROM_REV 0x0430 /* Min. required PROM version */
	46	#define SN_SLOT_NAME_SIZE 33 /* size of name string */
6f354b01 PB	47
	48	/* internal list head */
	49	static struct list_head sn_hp_list;
	50
	51	/* hotplug_slot struct's private pointer */
	52	struct slot {
	53	int device_num;
	54	struct pci_bus *pci_bus;
	55	/* this struct for glue internal only */
	56	struct hotplug_slot *hotplug_slot;
	57	struct list_head hp_list;
1d2450a4	58	char physical_path[SN_SLOT_NAME_SIZE];
6f354b01 PB	59	};
	60
	61	struct pcibr_slot_enable_resp {
	62	int resp_sub_errno;
	63	char resp_l1_msg[PCI_L1_QSIZE + 1];
	64	};
	65
	66	struct pcibr_slot_disable_resp {
	67	int resp_sub_errno;
	68	char resp_l1_msg[PCI_L1_QSIZE + 1];
	69	};
	70
	71	enum sn_pci_req_e {
	72	PCI_REQ_SLOT_ELIGIBLE,
	73	PCI_REQ_SLOT_DISABLE
	74	};
	75
	76	static int enable_slot(struct hotplug_slot *slot);
	77	static int disable_slot(struct hotplug_slot *slot);
1d2450a4	78	static inline int get_power_status(struct hotplug_slot slot, u8 value);
6f354b01 PB	79
	80	static struct hotplug_slot_ops sn_hotplug_slot_ops = {
	81	.owner = THIS_MODULE,
	82	.enable_slot = enable_slot,
	83	.disable_slot = disable_slot,
	84	.get_power_status = get_power_status,
	85	};
	86
14cc3e2b	87	static DEFINE_MUTEX(sn_hotplug_mutex);
6f354b01	88
1d2450a4 PB	89	static ssize_t path_show (struct hotplug_slot *bss_hotplug_slot,
	90	char *buf)
	91	{
	92	int retval = -ENOENT;
	93	struct slot *slot = bss_hotplug_slot->private;
	94
	95	if (!slot)
	96	return retval;
	97
	98	retval = sprintf (buf, "%s\n", slot->physical_path);
	99	return retval;
	100	}
	101
	102	static struct hotplug_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
	103
6f354b01 PB	104	static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
	105	{
	106	struct pcibus_info *pcibus_info;
e55dea58	107	u16 busnum, segment, ioboard_type;
6f354b01 PB	108
	109	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
	110
	111	/* Check to see if this is a valid slot on 'pci_bus' */
	112	if (!(pcibus_info->pbi_valid_devices & (1 << device)))
	113	return -EPERM;
	114
e55dea58 PB	115	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
	116	busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
	117	segment = pci_domain_nr(pci_bus) & 0xf;
6f354b01 PB	118
6f354b01 PB	119	/* Do not allow hotplug operations on base I/O cards */
e55dea58 PB	120	if ((ioboard_type == L1_BRICKTYPE_IX \|\|
	121	ioboard_type == L1_BRICKTYPE_IA) &&
	122	(segment == 1 && busnum == 0 && device != 1))
6f354b01 PB	123	return -EPERM;
	124
	125	return 1;
	126	}
	127
	128	static int sn_pci_bus_valid(struct pci_bus *pci_bus)
	129	{
	130	struct pcibus_info *pcibus_info;
e55dea58 PB	131	u32 asic_type;
e55dea58 PB	132	u16 ioboard_type;
6f354b01 PB	133
6f354b01 PB	134	/* Don't register slots hanging off the TIOCA bus */
e55dea58	135	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
6f354b01 PB	136	asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
	137	if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
	138	return -EPERM;
	139
	140	/* Only register slots in I/O Bricks that support hotplug */
e55dea58 PB	141	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
e55dea58 PB	142	switch (ioboard_type) {
1d2450a4 PB	143	case L1_BRICKTYPE_IX:
	144	case L1_BRICKTYPE_PX:
	145	case L1_BRICKTYPE_IA:
	146	case L1_BRICKTYPE_PA:
e55dea58	147	case L1_BOARDTYPE_PCIX3SLOT:
1d2450a4 PB	148	return 1;
	149	break;
	150	default:
	151	return -EPERM;
	152	break;
6f354b01 PB	153	}
	154
	155	return -EIO;
	156	}
	157
	158	static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
	159	struct pci_bus *pci_bus, int device)
	160	{
	161	struct pcibus_info *pcibus_info;
	162	struct slot *slot;
	163
	164	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
	165
656da9da	166	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
1d2450a4	167	if (!slot)
6f354b01	168	return -ENOMEM;
1d2450a4	169	bss_hotplug_slot->private = slot;
6f354b01	170
1d2450a4	171	bss_hotplug_slot->name = kmalloc(SN_SLOT_NAME_SIZE, GFP_KERNEL);
6f354b01 PB	172	if (!bss_hotplug_slot->name) {
	173	kfree(bss_hotplug_slot->private);
	174	return -ENOMEM;
	175	}
	176
	177	slot->device_num = device;
	178	slot->pci_bus = pci_bus;
1d2450a4 PB	179	sprintf(bss_hotplug_slot->name, "%04x:%02x:%02x",
1d2450a4 PB	180	pci_domain_nr(pci_bus),
e55dea58	181	((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
1d2450a4	182	device + 1);
e55dea58 PB	183
	184	sn_generate_path(pci_bus, slot->physical_path);
	185
6f354b01 PB	186	slot->hotplug_slot = bss_hotplug_slot;
	187	list_add(&slot->hp_list, &sn_hp_list);
	188
	189	return 0;
	190	}
	191
	192	static struct hotplug_slot * sn_hp_destroy(void)
	193	{
	194	struct slot *slot;
6f354b01 PB	195	struct hotplug_slot *bss_hotplug_slot = NULL;
6f354b01 PB	196
1d2450a4	197	list_for_each_entry(slot, &sn_hp_list, hp_list) {
6f354b01 PB	198	bss_hotplug_slot = slot->hotplug_slot;
	199	list_del(&((struct slot *)bss_hotplug_slot->private)->
	200	hp_list);
1d2450a4 PB	201	sysfs_remove_file(&bss_hotplug_slot->kobj,
1d2450a4 PB	202	&sn_slot_path_attr.attr);
6f354b01 PB	203	break;
	204	}
	205	return bss_hotplug_slot;
	206	}
	207
	208	static void sn_bus_alloc_data(struct pci_dev *dev)
	209	{
6f354b01 PB	210	struct pci_bus *subordinate_bus;
	211	struct pci_dev *child;
	212
	213	sn_pci_fixup_slot(dev);
	214
	215	/* Recursively sets up the sn_irq_info structs */
	216	if (dev->subordinate) {
	217	subordinate_bus = dev->subordinate;
1d2450a4	218	list_for_each_entry(child, &subordinate_bus->devices, bus_list)
6f354b01	219	sn_bus_alloc_data(child);
6f354b01 PB	220	}
	221	}
	222
	223	static void sn_bus_free_data(struct pci_dev *dev)
	224	{
6f354b01 PB	225	struct pci_bus *subordinate_bus;
	226	struct pci_dev *child;
	227
	228	/* Recursively clean up sn_irq_info structs */
	229	if (dev->subordinate) {
	230	subordinate_bus = dev->subordinate;
1d2450a4	231	list_for_each_entry(child, &subordinate_bus->devices, bus_list)
6f354b01	232	sn_bus_free_data(child);
6f354b01	233	}
8e77af6a JK	234	/*
	235	* Some drivers may use dma accesses during the
	236	* driver remove function. We release the sysdata
	237	* areas after the driver remove functions have
	238	* been called.
	239	*/
	240	sn_bus_store_sysdata(dev);
6f354b01 PB	241	sn_pci_unfixup_slot(dev);
	242	}
	243
6f354b01 PB	244	static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
	245	int device_num)
	246	{
1d2450a4	247	struct slot *slot = bss_hotplug_slot->private;
6f354b01 PB	248	struct pcibus_info *pcibus_info;
	249	struct pcibr_slot_enable_resp resp;
	250	int rc;
	251
	252	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
	253
	254	/*
	255	* Power-on and initialize the slot in the SN
	256	* PCI infrastructure.
	257	*/
	258	rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp);
	259
	260	if (rc == PCI_SLOT_ALREADY_UP) {
	261	dev_dbg(slot->pci_bus->self, "is already active\n");
1d2450a4	262	return 1; /* return 1 to user */
6f354b01 PB	263	}
	264
	265	if (rc == PCI_L1_ERR) {
	266	dev_dbg(slot->pci_bus->self,
	267	"L1 failure %d with message: %s",
	268	resp.resp_sub_errno, resp.resp_l1_msg);
	269	return -EPERM;
	270	}
	271
	272	if (rc) {
	273	dev_dbg(slot->pci_bus->self,
	274	"insert failed with error %d sub-error %d\n",
	275	rc, resp.resp_sub_errno);
	276	return -EIO;
	277	}
	278
1d2450a4 PB	279	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
1d2450a4 PB	280	pcibus_info->pbi_enabled_devices \|= (1 << device_num);
6f354b01 PB	281
	282	return 0;
	283	}
	284
	285	static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
	286	int device_num, int action)
	287	{
1d2450a4	288	struct slot *slot = bss_hotplug_slot->private;
6f354b01 PB	289	struct pcibus_info *pcibus_info;
	290	struct pcibr_slot_disable_resp resp;
	291	int rc;
	292
	293	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
	294
	295	rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
	296
1d2450a4 PB	297	if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
1d2450a4 PB	298	(rc == PCI_SLOT_ALREADY_DOWN)) {
6f354b01	299	dev_dbg(slot->pci_bus->self, "Slot %s already inactive\n");
1d2450a4	300	return 1; /* return 1 to user */
6f354b01 PB	301	}
6f354b01 PB	302
1d2450a4	303	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
6f354b01 PB	304	dev_dbg(slot->pci_bus->self,
	305	"Cannot remove last 33MHz card\n");
	306	return -EPERM;
	307	}
	308
1d2450a4	309	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
6f354b01 PB	310	dev_dbg(slot->pci_bus->self,
	311	"L1 failure %d with message \n%s\n",
	312	resp.resp_sub_errno, resp.resp_l1_msg);
	313	return -EPERM;
	314	}
	315
1d2450a4	316	if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
6f354b01 PB	317	dev_dbg(slot->pci_bus->self,
	318	"remove failed with error %d sub-error %d\n",
	319	rc, resp.resp_sub_errno);
	320	return -EIO;
	321	}
	322
1d2450a4	323	if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
6f354b01 PB	324	return 0;
6f354b01 PB	325
1d2450a4 PB	326	if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
	327	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
	328	pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
6f354b01 PB	329	dev_dbg(slot->pci_bus->self, "remove successful\n");
	330	return 0;
	331	}
	332
1d2450a4	333	if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
6f354b01	334	dev_dbg(slot->pci_bus->self,"remove failed rc = %d\n", rc);
6f354b01 PB	335	}
	336
	337	return rc;
	338	}
	339
	340	static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
	341	{
1d2450a4	342	struct slot *slot = bss_hotplug_slot->private;
6f354b01 PB	343	struct pci_bus *new_bus = NULL;
	344	struct pci_dev *dev;
	345	int func, num_funcs;
	346	int new_ppb = 0;
	347	int rc;
	348
	349	/* Serialize the Linux PCI infrastructure */
14cc3e2b	350	mutex_lock(&sn_hotplug_mutex);
6f354b01 PB	351
	352	/*
	353	* Power-on and initialize the slot in the SN
	354	* PCI infrastructure.
	355	*/
	356	rc = sn_slot_enable(bss_hotplug_slot, slot->device_num);
	357	if (rc) {
14cc3e2b	358	mutex_unlock(&sn_hotplug_mutex);
6f354b01 PB	359	return rc;
	360	}
	361
1d2450a4 PB	362	num_funcs = pci_scan_slot(slot->pci_bus,
1d2450a4 PB	363	PCI_DEVFN(slot->device_num + 1, 0));
6f354b01 PB	364	if (!num_funcs) {
6f354b01 PB	365	dev_dbg(slot->pci_bus->self, "no device in slot\n");
14cc3e2b	366	mutex_unlock(&sn_hotplug_mutex);
6f354b01 PB	367	return -ENODEV;
	368	}
	369
	370	sn_pci_controller_fixup(pci_domain_nr(slot->pci_bus),
	371	slot->pci_bus->number,
	372	slot->pci_bus);
	373	/*
	374	* Map SN resources for all functions on the card
	375	* to the Linux PCI interface and tell the drivers
	376	* about them.
	377	*/
	378	for (func = 0; func < num_funcs; func++) {
	379	dev = pci_get_slot(slot->pci_bus,
	380	PCI_DEVFN(slot->device_num + 1,
	381	PCI_FUNC(func)));
6f354b01 PB	382	if (dev) {
	383	if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
	384	unsigned char sec_bus;
	385	pci_read_config_byte(dev, PCI_SECONDARY_BUS,
	386	&sec_bus);
	387	new_bus = pci_add_new_bus(dev->bus, dev,
	388	sec_bus);
	389	pci_scan_child_bus(new_bus);
	390	sn_pci_controller_fixup(pci_domain_nr(new_bus),
	391	new_bus->number,
	392	new_bus);
	393	new_ppb = 1;
	394	}
	395	sn_bus_alloc_data(dev);
	396	pci_dev_put(dev);
	397	}
	398	}
	399
	400	/* Call the driver for the new device */
	401	pci_bus_add_devices(slot->pci_bus);
	402	/* Call the drivers for the new devices subordinate to PPB */
	403	if (new_ppb)
	404	pci_bus_add_devices(new_bus);
	405
14cc3e2b	406	mutex_unlock(&sn_hotplug_mutex);
6f354b01 PB	407
	408	if (rc == 0)
	409	dev_dbg(slot->pci_bus->self,
	410	"insert operation successful\n");
	411	else
	412	dev_dbg(slot->pci_bus->self,
	413	"insert operation failed rc = %d\n", rc);
	414
	415	return rc;
	416	}
	417
	418	static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
	419	{
1d2450a4	420	struct slot *slot = bss_hotplug_slot->private;
6f354b01 PB	421	struct pci_dev *dev;
	422	int func;
	423	int rc;
	424
	425	/* Acquire update access to the bus */
14cc3e2b	426	mutex_lock(&sn_hotplug_mutex);
6f354b01 PB	427
	428	/* is it okay to bring this slot down? */
	429	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
	430	PCI_REQ_SLOT_ELIGIBLE);
	431	if (rc)
	432	goto leaving;
	433
	434	/* Free the SN resources assigned to the Linux device.*/
	435	for (func = 0; func < 8; func++) {
	436	dev = pci_get_slot(slot->pci_bus,
1d2450a4	437	PCI_DEVFN(slot->device_num + 1,
6f354b01 PB	438	PCI_FUNC(func)));
6f354b01 PB	439	if (dev) {
6f354b01 PB	440	sn_bus_free_data(dev);
	441	pci_remove_bus_device(dev);
	442	pci_dev_put(dev);
	443	}
	444	}
	445
	446	/* free the collected sysdata pointers */
	447	sn_bus_free_sysdata();
	448
	449	/* Deactivate slot */
	450	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
	451	PCI_REQ_SLOT_DISABLE);
	452	leaving:
	453	/* Release the bus lock */
14cc3e2b	454	mutex_unlock(&sn_hotplug_mutex);
6f354b01 PB	455
	456	return rc;
	457	}
	458
1d2450a4 PB	459	static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
1d2450a4 PB	460	u8 *value)
6f354b01	461	{
1d2450a4 PB	462	struct slot *slot = bss_hotplug_slot->private;
	463	struct pcibus_info *pcibus_info;
	464
	465	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
14cc3e2b	466	mutex_lock(&sn_hotplug_mutex);
1d2450a4	467	*value = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
14cc3e2b	468	mutex_unlock(&sn_hotplug_mutex);
6f354b01 PB	469	return 0;
	470	}
	471
	472	static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
	473	{
	474	kfree(bss_hotplug_slot->info);
	475	kfree(bss_hotplug_slot->name);
	476	kfree(bss_hotplug_slot->private);
	477	kfree(bss_hotplug_slot);
	478	}
	479
	480	static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
	481	{
	482	int device;
	483	struct hotplug_slot *bss_hotplug_slot;
	484	int rc = 0;
	485
	486	/*
	487	* Currently only four devices are supported,
	488	* in the future there maybe more -- up to 32.
	489	*/
	490
	491	for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
	492	if (sn_pci_slot_valid(pci_bus, device) != 1)
	493	continue;
	494
656da9da	495	bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
6f354b01 PB	496	GFP_KERNEL);
	497	if (!bss_hotplug_slot) {
	498	rc = -ENOMEM;
	499	goto alloc_err;
	500	}
	501
	502	bss_hotplug_slot->info =
656da9da	503	kzalloc(sizeof(struct hotplug_slot_info),
6f354b01 PB	504	GFP_KERNEL);
	505	if (!bss_hotplug_slot->info) {
	506	rc = -ENOMEM;
	507	goto alloc_err;
	508	}
	509
	510	if (sn_hp_slot_private_alloc(bss_hotplug_slot,
	511	pci_bus, device)) {
	512	rc = -ENOMEM;
	513	goto alloc_err;
	514	}
	515
	516	bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
	517	bss_hotplug_slot->release = &sn_release_slot;
	518
	519	rc = pci_hp_register(bss_hotplug_slot);
	520	if (rc)
	521	goto register_err;
1d2450a4 PB	522
	523	rc = sysfs_create_file(&bss_hotplug_slot->kobj,
	524	&sn_slot_path_attr.attr);
	525	if (rc)
	526	goto register_err;
6f354b01 PB	527	}
	528	dev_dbg(pci_bus->self, "Registered bus with hotplug\n");
	529	return rc;
	530
	531	register_err:
	532	dev_dbg(pci_bus->self, "bus failed to register with err = %d\n",
	533	rc);
	534
	535	alloc_err:
	536	if (rc == -ENOMEM)
	537	dev_dbg(pci_bus->self, "Memory allocation error\n");
	538
	539	/* destroy THIS element */
	540	if (bss_hotplug_slot)
	541	sn_release_slot(bss_hotplug_slot);
	542
	543	/* destroy anything else on the list */
	544	while ((bss_hotplug_slot = sn_hp_destroy()))
	545	pci_hp_deregister(bss_hotplug_slot);
	546
	547	return rc;
	548	}
	549
	550	static int sn_pci_hotplug_init(void)
	551	{
	552	struct pci_bus *pci_bus = NULL;
	553	int rc;
	554	int registered = 0;
	555
e55dea58 PB	556	if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
e55dea58 PB	557	printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
6f354b01 PB	558	__FUNCTION__);
	559	return -EPERM;
	560	}
	561
1d2450a4 PB	562	INIT_LIST_HEAD(&sn_hp_list);
1d2450a4 PB	563
6f354b01 PB	564	while ((pci_bus = pci_find_next_bus(pci_bus))) {
	565	if (!pci_bus->sysdata)
	566	continue;
	567
	568	rc = sn_pci_bus_valid(pci_bus);
	569	if (rc != 1) {
	570	dev_dbg(pci_bus->self, "not a valid hotplug bus\n");
	571	continue;
	572	}
	573	dev_dbg(pci_bus->self, "valid hotplug bus\n");
	574
	575	rc = sn_hotplug_slot_register(pci_bus);
1d2450a4	576	if (!rc) {
6f354b01	577	registered = 1;
1d2450a4	578	} else {
6f354b01 PB	579	registered = 0;
	580	break;
	581	}
	582	}
	583
	584	return registered == 1 ? 0 : -ENODEV;
	585	}
	586
	587	static void sn_pci_hotplug_exit(void)
	588	{
	589	struct hotplug_slot *bss_hotplug_slot;
	590
1d2450a4	591	while ((bss_hotplug_slot = sn_hp_destroy()))
6f354b01	592	pci_hp_deregister(bss_hotplug_slot);
6f354b01 PB	593
	594	if (!list_empty(&sn_hp_list))
	595	printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
	596	}
	597
	598	module_init(sn_pci_hotplug_init);
	599	module_exit(sn_pci_hotplug_exit);