[deliverable/linux.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 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 <asm/sn/addrs.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_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 DECLARE_MUTEX(sn_hotplug_sem);

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;
	int bricktype;
	int bus_num;

	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;

	bricktype = MODULE_GET_BTYPE(pcibus_info->pbi_moduleid);
	bus_num = pcibus_info->pbi_buscommon.bs_persist_busnum & 0xf;

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

	return 1;
}

static int sn_pci_bus_valid(struct pci_bus *pci_bus)
{
	struct pcibus_info *pcibus_info;
	int asic_type;
	int bricktype;

	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);

	/* Don't register slots hanging off the TIOCA 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 */
	bricktype = MODULE_GET_BTYPE(pcibus_info->pbi_moduleid);
	switch (bricktype) {
		case L1_BRICKTYPE_IX:
		case L1_BRICKTYPE_PX:
		case L1_BRICKTYPE_IA:
		case L1_BRICKTYPE_PA:
			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),
		((int)pcibus_info->pbi_buscommon.bs_persist_busnum) & 0xf,
		device + 1);
	sprintf(slot->physical_path, "module_%c%c%c%c%.2d",
		'0'+RACK_GET_CLASS(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
		'0'+RACK_GET_GROUP(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
		'0'+RACK_GET_NUM(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
		MODULE_GET_BTCHAR(pcibus_info->pbi_moduleid),
		MODULE_GET_BPOS(pcibus_info->pbi_moduleid));
	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);
	}
	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 */
	down(&sn_hotplug_sem);

	/*
	 * Power-on and initialize the slot in the SN
	 * PCI infrastructure.
	 */
	rc = sn_slot_enable(bss_hotplug_slot, slot->device_num);
	if (rc) {
		up(&sn_hotplug_sem);
		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");
		up(&sn_hotplug_sem);
		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);

	up(&sn_hotplug_sem);

	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 */
	down(&sn_hotplug_sem);

	/* 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) {
			/*
			 * 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_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 */
	up(&sn_hotplug_sem);

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