PageRenderTime 89ms CodeModel.GetById 7ms app.highlight 67ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/pci/hotplug/sgi_hotplug.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 730 lines | 522 code | 124 blank | 84 comment | 106 complexity | 538ab9aac949ba9a048db991c62e5cfa MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  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-2006 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/pci_hotplug.h>
 17#include <linux/proc_fs.h>
 18#include <linux/slab.h>
 19#include <linux/types.h>
 20#include <linux/mutex.h>
 21
 22#include <asm/sn/addrs.h>
 23#include <asm/sn/geo.h>
 24#include <asm/sn/l1.h>
 25#include <asm/sn/module.h>
 26#include <asm/sn/pcibr_provider.h>
 27#include <asm/sn/pcibus_provider_defs.h>
 28#include <asm/sn/pcidev.h>
 29#include <asm/sn/sn_feature_sets.h>
 30#include <asm/sn/sn_sal.h>
 31#include <asm/sn/types.h>
 32#include <linux/acpi.h>
 33#include <asm/sn/acpi.h>
 34
 35#include "../pci.h"
 36
 37MODULE_LICENSE("GPL");
 38MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
 39MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
 40
 41
 42/* SAL call error codes. Keep in sync with prom header io/include/pcibr.h */
 43#define PCI_SLOT_ALREADY_UP		2	/* slot already up */
 44#define PCI_SLOT_ALREADY_DOWN		3	/* slot already down */
 45#define PCI_L1_ERR			7	/* L1 console command error */
 46#define PCI_EMPTY_33MHZ			15	/* empty 33 MHz bus */
 47
 48
 49#define PCIIO_ASIC_TYPE_TIOCA		4
 50#define PCI_L1_QSIZE			128	/* our L1 message buffer size */
 51#define SN_MAX_HP_SLOTS			32	/* max hotplug slots */
 52#define SN_SLOT_NAME_SIZE		33	/* size of name string */
 53
 54/* internal list head */
 55static struct list_head sn_hp_list;
 56
 57/* hotplug_slot struct's private pointer */
 58struct slot {
 59	int device_num;
 60	struct pci_bus *pci_bus;
 61	/* this struct for glue internal only */
 62	struct hotplug_slot *hotplug_slot;
 63	struct list_head hp_list;
 64	char physical_path[SN_SLOT_NAME_SIZE];
 65};
 66
 67struct pcibr_slot_enable_resp {
 68	int resp_sub_errno;
 69	char resp_l1_msg[PCI_L1_QSIZE + 1];
 70};
 71
 72struct pcibr_slot_disable_resp {
 73	int resp_sub_errno;
 74	char resp_l1_msg[PCI_L1_QSIZE + 1];
 75};
 76
 77enum sn_pci_req_e {
 78	PCI_REQ_SLOT_ELIGIBLE,
 79	PCI_REQ_SLOT_DISABLE
 80};
 81
 82static int enable_slot(struct hotplug_slot *slot);
 83static int disable_slot(struct hotplug_slot *slot);
 84static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
 85
 86static struct hotplug_slot_ops sn_hotplug_slot_ops = {
 87	.enable_slot            = enable_slot,
 88	.disable_slot           = disable_slot,
 89	.get_power_status       = get_power_status,
 90};
 91
 92static DEFINE_MUTEX(sn_hotplug_mutex);
 93
 94static ssize_t path_show(struct pci_slot *pci_slot, char *buf)
 95{
 96	int retval = -ENOENT;
 97	struct slot *slot = pci_slot->hotplug->private;
 98
 99	if (!slot)
100		return retval;
101
102	retval = sprintf (buf, "%s\n", slot->physical_path);
103	return retval;
104}
105
106static struct pci_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
107
108static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
109{
110	struct pcibus_info *pcibus_info;
111	u16 busnum, segment, ioboard_type;
112
113	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
114
115	/* Check to see if this is a valid slot on 'pci_bus' */
116	if (!(pcibus_info->pbi_valid_devices & (1 << device)))
117		return -EPERM;
118
119	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
120	busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
121	segment = pci_domain_nr(pci_bus) & 0xf;
122
123	/* Do not allow hotplug operations on base I/O cards */
124	if ((ioboard_type == L1_BRICKTYPE_IX ||
125	     ioboard_type == L1_BRICKTYPE_IA) &&
126	    (segment == 1 && busnum == 0 && device != 1))
127		return -EPERM;
128
129	return 1;
130}
131
132static int sn_pci_bus_valid(struct pci_bus *pci_bus)
133{
134	struct pcibus_info *pcibus_info;
135	u32 asic_type;
136	u16 ioboard_type;
137
138	/* Don't register slots hanging off the TIOCA bus */
139	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
140	asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
141	if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
142		return -EPERM;
143
144	/* Only register slots in I/O Bricks that support hotplug */
145	ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
146	switch (ioboard_type) {
147		case L1_BRICKTYPE_IX:
148		case L1_BRICKTYPE_PX:
149		case L1_BRICKTYPE_IA:
150		case L1_BRICKTYPE_PA:
151		case L1_BOARDTYPE_PCIX3SLOT:
152			return 1;
153			break;
154		default:
155			return -EPERM;
156			break;
157	}
158
159	return -EIO;
160}
161
162static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
163				    struct pci_bus *pci_bus, int device,
164				    char *name)
165{
166	struct pcibus_info *pcibus_info;
167	struct slot *slot;
168
169	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
170
171	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
172	if (!slot)
173		return -ENOMEM;
174	bss_hotplug_slot->private = slot;
175
176	slot->device_num = device;
177	slot->pci_bus = pci_bus;
178	sprintf(name, "%04x:%02x:%02x",
179		pci_domain_nr(pci_bus),
180		((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
181		device + 1);
182
183	sn_generate_path(pci_bus, slot->physical_path);
184
185	slot->hotplug_slot = bss_hotplug_slot;
186	list_add(&slot->hp_list, &sn_hp_list);
187
188	return 0;
189}
190
191static struct hotplug_slot * sn_hp_destroy(void)
192{
193	struct slot *slot;
194	struct pci_slot *pci_slot;
195	struct hotplug_slot *bss_hotplug_slot = NULL;
196
197	list_for_each_entry(slot, &sn_hp_list, hp_list) {
198		bss_hotplug_slot = slot->hotplug_slot;
199		pci_slot = bss_hotplug_slot->pci_slot;
200		list_del(&((struct slot *)bss_hotplug_slot->private)->
201			 hp_list);
202		sysfs_remove_file(&pci_slot->kobj,
203				  &sn_slot_path_attr.attr);
204		break;
205	}
206	return bss_hotplug_slot;
207}
208
209static void sn_bus_free_data(struct pci_dev *dev)
210{
211	struct pci_bus *subordinate_bus;
212	struct pci_dev *child;
213
214	/* Recursively clean up sn_irq_info structs */
215	if (dev->subordinate) {
216		subordinate_bus = dev->subordinate;
217		list_for_each_entry(child, &subordinate_bus->devices, bus_list)
218			sn_bus_free_data(child);
219	}
220	/*
221	 * Some drivers may use dma accesses during the
222	 * driver remove function. We release the sysdata
223	 * areas after the driver remove functions have
224	 * been called.
225	 */
226	sn_bus_store_sysdata(dev);
227	sn_pci_unfixup_slot(dev);
228}
229
230static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
231			  int device_num, char **ssdt)
232{
233	struct slot *slot = bss_hotplug_slot->private;
234	struct pcibus_info *pcibus_info;
235	struct pcibr_slot_enable_resp resp;
236	int rc;
237
238	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
239
240	/*
241	 * Power-on and initialize the slot in the SN
242	 * PCI infrastructure.
243	 */
244	rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp, ssdt);
245
246
247	if (rc == PCI_SLOT_ALREADY_UP) {
248		dev_dbg(&slot->pci_bus->self->dev, "is already active\n");
249		return 1; /* return 1 to user */
250	}
251
252	if (rc == PCI_L1_ERR) {
253		dev_dbg(&slot->pci_bus->self->dev,
254			"L1 failure %d with message: %s",
255			resp.resp_sub_errno, resp.resp_l1_msg);
256		return -EPERM;
257	}
258
259	if (rc) {
260		dev_dbg(&slot->pci_bus->self->dev,
261			"insert failed with error %d sub-error %d\n",
262			rc, resp.resp_sub_errno);
263		return -EIO;
264	}
265
266	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
267	pcibus_info->pbi_enabled_devices |= (1 << device_num);
268
269	return 0;
270}
271
272static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
273			   int device_num, int action)
274{
275	struct slot *slot = bss_hotplug_slot->private;
276	struct pcibus_info *pcibus_info;
277	struct pcibr_slot_disable_resp resp;
278	int rc;
279
280	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
281
282	rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
283
284	if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
285	    (rc == PCI_SLOT_ALREADY_DOWN)) {
286		dev_dbg(&slot->pci_bus->self->dev, "Slot %s already inactive\n", slot->physical_path);
287		return 1; /* return 1 to user */
288	}
289
290	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
291		dev_dbg(&slot->pci_bus->self->dev,
292			"Cannot remove last 33MHz card\n");
293		return -EPERM;
294	}
295
296	if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
297		dev_dbg(&slot->pci_bus->self->dev,
298			"L1 failure %d with message \n%s\n",
299			resp.resp_sub_errno, resp.resp_l1_msg);
300		return -EPERM;
301	}
302
303	if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
304		dev_dbg(&slot->pci_bus->self->dev,
305			"remove failed with error %d sub-error %d\n",
306			rc, resp.resp_sub_errno);
307		return -EIO;
308	}
309
310	if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
311		return 0;
312
313	if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
314		pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
315		pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
316		dev_dbg(&slot->pci_bus->self->dev, "remove successful\n");
317		return 0;
318	}
319
320	if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
321		dev_dbg(&slot->pci_bus->self->dev,"remove failed rc = %d\n", rc);
322	}
323
324	return rc;
325}
326
327/*
328 * Power up and configure the slot via a SAL call to PROM.
329 * Scan slot (and any children), do any platform specific fixup,
330 * and find device driver.
331 */
332static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
333{
334	struct slot *slot = bss_hotplug_slot->private;
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	char *ssdt = NULL;
341	void pcibios_fixup_device_resources(struct pci_dev *);
342
343	/* Serialize the Linux PCI infrastructure */
344	mutex_lock(&sn_hotplug_mutex);
345
346	/*
347	 * Power-on and initialize the slot in the SN
348	 * PCI infrastructure. Also, retrieve the ACPI SSDT
349	 * table for the slot (if ACPI capable PROM).
350	 */
351	rc = sn_slot_enable(bss_hotplug_slot, slot->device_num, &ssdt);
352	if (rc) {
353		mutex_unlock(&sn_hotplug_mutex);
354		return rc;
355	}
356
357	if (ssdt)
358		ssdt = __va(ssdt);
359	/* Add the new SSDT for the slot to the ACPI namespace */
360	if (SN_ACPI_BASE_SUPPORT() && ssdt) {
361		acpi_status ret;
362
363		ret = acpi_load_table((struct acpi_table_header *)ssdt);
364		if (ACPI_FAILURE(ret)) {
365			printk(KERN_ERR "%s: acpi_load_table failed (0x%x)\n",
366			       __func__, ret);
367			/* try to continue on */
368		}
369	}
370
371	num_funcs = pci_scan_slot(slot->pci_bus,
372				  PCI_DEVFN(slot->device_num + 1, 0));
373	if (!num_funcs) {
374		dev_dbg(&slot->pci_bus->self->dev, "no device in slot\n");
375		mutex_unlock(&sn_hotplug_mutex);
376		return -ENODEV;
377	}
378
379	/*
380	 * Map SN resources for all functions on the card
381	 * to the Linux PCI interface and tell the drivers
382	 * about them.
383	 */
384	for (func = 0; func < num_funcs;  func++) {
385		dev = pci_get_slot(slot->pci_bus,
386				   PCI_DEVFN(slot->device_num + 1,
387					     PCI_FUNC(func)));
388		if (dev) {
389			/* Need to do slot fixup on PPB before fixup of children
390			 * (PPB's pcidev_info needs to be in pcidev_info list
391			 * before child's SN_PCIDEV_INFO() call to setup
392			 * pdi_host_pcidev_info).
393			 */
394			pcibios_fixup_device_resources(dev);
395			if (SN_ACPI_BASE_SUPPORT())
396				sn_acpi_slot_fixup(dev);
397			else
398				sn_io_slot_fixup(dev);
399			if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
400				unsigned char sec_bus;
401				pci_read_config_byte(dev, PCI_SECONDARY_BUS,
402						     &sec_bus);
403				new_bus = pci_add_new_bus(dev->bus, dev,
404							  sec_bus);
405				pci_scan_child_bus(new_bus);
406				new_ppb = 1;
407			}
408			pci_dev_put(dev);
409		}
410	}
411
412	/*
413	 * Add the slot's devices to the ACPI infrastructure */
414	if (SN_ACPI_BASE_SUPPORT() && ssdt) {
415		unsigned long long adr;
416		struct acpi_device *pdevice;
417		struct acpi_device *device;
418		acpi_handle phandle;
419		acpi_handle chandle = NULL;
420		acpi_handle rethandle;
421		acpi_status ret;
422
423		phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
424
425		if (acpi_bus_get_device(phandle, &pdevice)) {
426			dev_dbg(&slot->pci_bus->self->dev,
427				"no parent device, assuming NULL\n");
428			pdevice = NULL;
429		}
430
431		/*
432		 * Walk the rootbus node's immediate children looking for
433		 * the slot's device node(s). There can be more than
434		 * one for multifunction devices.
435		 */
436		for (;;) {
437			rethandle = NULL;
438			ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
439						   phandle, chandle,
440						   &rethandle);
441
442			if (ret == AE_NOT_FOUND || rethandle == NULL)
443				break;
444
445			chandle = rethandle;
446
447			ret = acpi_evaluate_integer(chandle, METHOD_NAME__ADR,
448						    NULL, &adr);
449
450			if (ACPI_SUCCESS(ret) &&
451			    (adr>>16) == (slot->device_num + 1)) {
452
453				ret = acpi_bus_add(&device, pdevice, chandle,
454						   ACPI_BUS_TYPE_DEVICE);
455				if (ACPI_FAILURE(ret)) {
456					printk(KERN_ERR "%s: acpi_bus_add "
457					       "failed (0x%x) for slot %d "
458					       "func %d\n", __func__,
459					       ret, (int)(adr>>16),
460					       (int)(adr&0xffff));
461					/* try to continue on */
462				} else {
463					acpi_bus_start(device);
464				}
465			}
466		}
467	}
468
469	/* Call the driver for the new device */
470	pci_bus_add_devices(slot->pci_bus);
471	/* Call the drivers for the new devices subordinate to PPB */
472	if (new_ppb)
473		pci_bus_add_devices(new_bus);
474
475	mutex_unlock(&sn_hotplug_mutex);
476
477	if (rc == 0)
478		dev_dbg(&slot->pci_bus->self->dev,
479			"insert operation successful\n");
480	else
481		dev_dbg(&slot->pci_bus->self->dev,
482			"insert operation failed rc = %d\n", rc);
483
484	return rc;
485}
486
487static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
488{
489	struct slot *slot = bss_hotplug_slot->private;
490	struct pci_dev *dev;
491	int func;
492	int rc;
493	acpi_owner_id ssdt_id = 0;
494
495	/* Acquire update access to the bus */
496	mutex_lock(&sn_hotplug_mutex);
497
498	/* is it okay to bring this slot down? */
499	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
500			     PCI_REQ_SLOT_ELIGIBLE);
501	if (rc)
502		goto leaving;
503
504	/* free the ACPI resources for the slot */
505	if (SN_ACPI_BASE_SUPPORT() &&
506            PCI_CONTROLLER(slot->pci_bus)->acpi_handle) {
507		unsigned long long adr;
508		struct acpi_device *device;
509		acpi_handle phandle;
510		acpi_handle chandle = NULL;
511		acpi_handle rethandle;
512		acpi_status ret;
513
514		/* Get the rootbus node pointer */
515		phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
516
517		/*
518		 * Walk the rootbus node's immediate children looking for
519		 * the slot's device node(s). There can be more than
520		 * one for multifunction devices.
521		 */
522		for (;;) {
523			rethandle = NULL;
524			ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
525						   phandle, chandle,
526						   &rethandle);
527
528			if (ret == AE_NOT_FOUND || rethandle == NULL)
529				break;
530
531			chandle = rethandle;
532
533			ret = acpi_evaluate_integer(chandle,
534						    METHOD_NAME__ADR,
535						    NULL, &adr);
536			if (ACPI_SUCCESS(ret) &&
537			    (adr>>16) == (slot->device_num + 1)) {
538				/* retain the owner id */
539				acpi_get_id(chandle, &ssdt_id);
540
541				ret = acpi_bus_get_device(chandle,
542							  &device);
543				if (ACPI_SUCCESS(ret))
544					acpi_bus_trim(device, 1);
545			}
546		}
547
548	}
549
550	/* Free the SN resources assigned to the Linux device.*/
551	for (func = 0; func < 8;  func++) {
552		dev = pci_get_slot(slot->pci_bus,
553				   PCI_DEVFN(slot->device_num + 1,
554				   	     PCI_FUNC(func)));
555		if (dev) {
556			sn_bus_free_data(dev);
557			pci_remove_bus_device(dev);
558			pci_dev_put(dev);
559		}
560	}
561
562	/* Remove the SSDT for the slot from the ACPI namespace */
563	if (SN_ACPI_BASE_SUPPORT() && ssdt_id) {
564		acpi_status ret;
565		ret = acpi_unload_table_id(ssdt_id);
566		if (ACPI_FAILURE(ret)) {
567			printk(KERN_ERR "%s: acpi_unload_table_id "
568			       "failed (0x%x) for id %d\n",
569			       __func__, ret, ssdt_id);
570			/* try to continue on */
571		}
572	}
573
574	/* free the collected sysdata pointers */
575	sn_bus_free_sysdata();
576
577	/* Deactivate slot */
578	rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
579			     PCI_REQ_SLOT_DISABLE);
580 leaving:
581	/* Release the bus lock */
582	mutex_unlock(&sn_hotplug_mutex);
583
584	return rc;
585}
586
587static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
588				   u8 *value)
589{
590	struct slot *slot = bss_hotplug_slot->private;
591	struct pcibus_info *pcibus_info;
592	u32 power;
593
594	pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
595	mutex_lock(&sn_hotplug_mutex);
596	power = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
597	*value = power ? 1 : 0;
598	mutex_unlock(&sn_hotplug_mutex);
599	return 0;
600}
601
602static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
603{
604	kfree(bss_hotplug_slot->info);
605	kfree(bss_hotplug_slot->private);
606	kfree(bss_hotplug_slot);
607}
608
609static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
610{
611	int device;
612	struct pci_slot *pci_slot;
613	struct hotplug_slot *bss_hotplug_slot;
614	char name[SN_SLOT_NAME_SIZE];
615	int rc = 0;
616
617	/*
618	 * Currently only four devices are supported,
619	 * in the future there maybe more -- up to 32.
620	 */
621
622	for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
623		if (sn_pci_slot_valid(pci_bus, device) != 1)
624			continue;
625
626		bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
627					   GFP_KERNEL);
628		if (!bss_hotplug_slot) {
629			rc = -ENOMEM;
630			goto alloc_err;
631		}
632
633		bss_hotplug_slot->info =
634			kzalloc(sizeof(struct hotplug_slot_info),
635				GFP_KERNEL);
636		if (!bss_hotplug_slot->info) {
637			rc = -ENOMEM;
638			goto alloc_err;
639		}
640
641		if (sn_hp_slot_private_alloc(bss_hotplug_slot,
642					     pci_bus, device, name)) {
643			rc = -ENOMEM;
644			goto alloc_err;
645		}
646		bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
647		bss_hotplug_slot->release = &sn_release_slot;
648
649		rc = pci_hp_register(bss_hotplug_slot, pci_bus, device, name);
650		if (rc)
651			goto register_err;
652
653		pci_slot = bss_hotplug_slot->pci_slot;
654		rc = sysfs_create_file(&pci_slot->kobj,
655				       &sn_slot_path_attr.attr);
656		if (rc)
657			goto register_err;
658	}
659	dev_dbg(&pci_bus->self->dev, "Registered bus with hotplug\n");
660	return rc;
661
662register_err:
663	dev_dbg(&pci_bus->self->dev, "bus failed to register with err = %d\n",
664		rc);
665
666alloc_err:
667	if (rc == -ENOMEM)
668		dev_dbg(&pci_bus->self->dev, "Memory allocation error\n");
669
670	/* destroy THIS element */
671	if (bss_hotplug_slot)
672		sn_release_slot(bss_hotplug_slot);
673
674	/* destroy anything else on the list */
675	while ((bss_hotplug_slot = sn_hp_destroy()))
676		pci_hp_deregister(bss_hotplug_slot);
677
678	return rc;
679}
680
681static int __init sn_pci_hotplug_init(void)
682{
683	struct pci_bus *pci_bus = NULL;
684	int rc;
685	int registered = 0;
686
687	if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
688		printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
689		       __func__);
690		return -EPERM;
691	}
692
693	INIT_LIST_HEAD(&sn_hp_list);
694
695	while ((pci_bus = pci_find_next_bus(pci_bus))) {
696		if (!pci_bus->sysdata)
697			continue;
698
699		rc = sn_pci_bus_valid(pci_bus);
700		if (rc != 1) {
701			dev_dbg(&pci_bus->self->dev, "not a valid hotplug bus\n");
702			continue;
703		}
704		dev_dbg(&pci_bus->self->dev, "valid hotplug bus\n");
705
706		rc = sn_hotplug_slot_register(pci_bus);
707		if (!rc) {
708			registered = 1;
709		} else {
710			registered = 0;
711			break;
712		}
713	}
714
715	return registered == 1 ? 0 : -ENODEV;
716}
717
718static void __exit sn_pci_hotplug_exit(void)
719{
720	struct hotplug_slot *bss_hotplug_slot;
721
722	while ((bss_hotplug_slot = sn_hp_destroy()))
723		pci_hp_deregister(bss_hotplug_slot);
724
725	if (!list_empty(&sn_hp_list))
726		printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
727}
728
729module_init(sn_pci_hotplug_init);
730module_exit(sn_pci_hotplug_exit);