xref: /titanic_50/usr/src/uts/common/io/hotplug/pcihp/pcihp.c (revision 10d63b7db37a83b39c7f511cf9426c9d03ea0760)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * **********************************************************************
28  * Extension module for PCI nexus drivers to support PCI Hot Plug feature.
29  *
30  * DESCRIPTION:
31  *    This module basically implements "devctl" and Attachment Point device
32  *    nodes for hot plug operations. The cb_ops functions needed for access
33  *    to these device nodes are also implemented. For hotplug operations
34  *    on Attachment Points it interacts with the hotplug services (HPS)
35  *    framework. A pci nexus driver would simply call pcihp_init() in its
36  *    attach() function and pcihp_uninit() call in its detach() function.
37  * **********************************************************************
38  */
39 
40 #include <sys/conf.h>
41 #include <sys/kmem.h>
42 #include <sys/debug.h>
43 #include <sys/modctl.h>
44 #include <sys/autoconf.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 #include <sys/sunndi.h>
48 #include <sys/ddi_impldefs.h>
49 #include <sys/ndi_impldefs.h>
50 #include <sys/ddipropdefs.h>
51 #include <sys/open.h>
52 #include <sys/file.h>
53 #include <sys/stat.h>
54 #include <sys/pci.h>
55 #include <sys/pci_impl.h>
56 #include <sys/devctl.h>
57 #include <sys/hotplug/hpcsvc.h>
58 #include <sys/hotplug/pci/pcicfg.h>
59 #include <sys/hotplug/pci/pcihp.h>
60 #include <sys/sysevent.h>
61 #include <sys/sysevent/eventdefs.h>
62 #include <sys/sysevent/dr.h>
63 #include <sys/fs/dv_node.h>
64 
65 /*
66  * NOTE:
67  * This module depends on PCI Configurator module (misc/pcicfg),
68  * Hot Plug Services framework module (misc/hpcsvc) and Bus Resource
69  * Allocator module (misc/busra).
70  */
71 
72 /*
73  * ************************************************************************
74  * *** Implementation specific data structures/definitions.		***
75  * ************************************************************************
76  */
77 
78 /* soft state */
79 typedef enum { PCIHP_SOFT_STATE_CLOSED, PCIHP_SOFT_STATE_OPEN,
80 		PCIHP_SOFT_STATE_OPEN_EXCL } pcihp_soft_state_t;
81 
82 #define	PCI_MAX_DEVS	32	/* max. number of devices on a pci bus */
83 
84 /* the following correspond to sysevent defined subclasses */
85 #define	PCIHP_DR_AP_STATE_CHANGE	0
86 #define	PCIHP_DR_REQ			1
87 
88 /*  pcihp_get_soft_state() command argument */
89 #define	PCIHP_DR_NOOP			0
90 #define	PCIHP_DR_BUS_CONFIGURE		1
91 #define	PCIHP_DR_BUS_UNCONFIGURE	2
92 #define	PCIHP_DR_SLOT_ENTER		4
93 #define	PCIHP_DR_SLOT_EXIT		8
94 
95 /*  hot plug bus state */
96 enum { PCIHP_BUS_INITIALIZING, PCIHP_BUS_UNCONFIGURED,
97 		PCIHP_BUS_CONFIGURED };
98 
99 /*
100  * Soft state structure associated with each hot plug pci bus instance.
101  */
102 typedef struct pcihp {
103 	struct pcihp		*nextp;
104 
105 	/* devinfo pointer to the pci bus node */
106 	dev_info_t		*dip;
107 
108 	/* soft state flags: PCIHP_SOFT_STATE_* */
109 	pcihp_soft_state_t	soft_state;
110 
111 	/* global mutex to serialize exclusive access to the bus */
112 	kmutex_t		mutex;
113 
114 	/* slot information structure */
115 	struct pcihp_slotinfo {
116 		hpc_slot_t	slot_hdl;	/* HPS slot handle */
117 		ap_rstate_t	rstate;		/* state of Receptacle */
118 		ap_ostate_t	ostate;		/* state of the Occupant */
119 		ap_condition_t	condition;	/* condition of the occupant */
120 		time32_t	last_change;	/* XXX needed? */
121 		uint32_t	event_mask;	/* last event mask registered */
122 		char		*name;		/* slot logical name */
123 		uint_t		slot_flags;
124 		uint16_t	slot_type;	/* slot type: pci or cpci */
125 		uint16_t	slot_capabilities; /* 64bit, etc. */
126 		int		hs_csr_location; /* Location of HS_CSR */
127 		kmutex_t	slot_mutex;	/* mutex to serialize hotplug */
128 						/* operations on the slot */
129 	} slotinfo[PCI_MAX_DEVS];
130 
131 	/* misc. bus attributes */
132 	uint_t			bus_flags;
133 	uint_t			bus_state;
134 	uint_t			slots_active;
135 } pcihp_t;
136 
137 /*
138  * Bit definitions for slot_flags field:
139  *
140  *	PCIHP_SLOT_AUTO_CFG_EN	This flags is set if nexus can do auto
141  *				configuration of hot plugged card on this slot
142  *				if the hardware reports the hot plug events.
143  *
144  *	PCIHP_SLOT_DISABLED	Slot is disabled for hotplug operations.
145  *
146  *	PCIHP_SLOT_NOT_HEALTHY	HEALTHY# signal is not OK on this slot.
147  */
148 #define	PCIHP_SLOT_AUTO_CFG_EN		0x1
149 #define	PCIHP_SLOT_DISABLED		0x2
150 #define	PCIHP_SLOT_NOT_HEALTHY		0x4
151 #define	PCIHP_SLOT_DEV_NON_HOTPLUG	0x8
152 #define	PCIHP_SLOT_ENUM_INS_PENDING	0x10
153 #define	PCIHP_SLOT_ENUM_EXT_PENDING	0x20
154 
155 /*
156  * Bit definitions for bus_flags field:
157  *
158  *	PCIHP_BUS_66MHZ	Bus is running at 66Mhz.
159  */
160 #define	PCIHP_BUS_66MHZ		0x1
161 #define	PCIHP_BUS_ENUM_RADIAL	0x2
162 
163 #define	PCIHP_DEVICES_STR		"/devices"
164 
165 /*
166  * control structure for tree walk during configure/unconfigure operation.
167  */
168 struct pcihp_config_ctrl {
169 	int	pci_dev;	/* PCI device number for the slot */
170 	uint_t	flags;		/* control flags (see below) */
171 	int	op;		/* operation: PCIHP_ONLINE or PCIHP_OFFLINE */
172 	int	rv;		/* return error code */
173 	dev_info_t *dip;	/* dip at which the (first) error occurred */
174 	hpc_occupant_info_t *occupant;
175 };
176 
177 /*
178  * control flags for configure/unconfigure operations on the tree.
179  *
180  * PCIHP_CFG_CONTINUE	continue the operation ignoring errors
181  */
182 #define	PCIHP_CFG_CONTINUE	0x1
183 
184 #define	PCIHP_ONLINE	1
185 #define	PCIHP_OFFLINE	0
186 
187 
188 /* Leaf ops (hotplug controls for target devices) */
189 static int pcihp_open(dev_t *, int, int, cred_t *);
190 static int pcihp_close(dev_t, int, int, cred_t *);
191 static int pcihp_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
192 
193 #ifdef DEBUG
194 static int pcihp_debug = 0;
195 #define	PCIHP_DEBUG(args)	if (pcihp_debug >= 1) cmn_err args
196 #define	PCIHP_DEBUG2(args)	if (pcihp_debug >= 2) cmn_err args
197 #else
198 #define	PCIHP_DEBUG(args)
199 #define	PCIHP_DEBUG2(args)
200 #endif
201 
202 /*
203  * We process ENUM# event one device at a time ie. as soon as we detect
204  * that a device has the right ENUM# conditions, we return. If the following
205  * variable is set to non-zero, we scan all the devices on the bus
206  * for ENUM# conditions.
207  */
208 static int pcihp_enum_scan_all = 0;
209 /*
210  * If HSC driver cannot determine the board type (for example: it may not
211  * be possible to differentiate between a Basic Hotswap, Non Hotswap or
212  * Non-friendly Full hotswap board), the default board type is assigned
213  * to be as defined by the following variable.
214  */
215 static int pcihp_cpci_board_type = HPC_BOARD_CPCI_NON_HS;
216 static int pcihp_cpci_led_blink = 30;
217 /*
218  * It was noted that the blue LED when written on/off would cause INS/EXT
219  * bit to be set causing an extra interrupt. Although the cPCI specifications
220  * does not imply this, this behavior is seen with some FHS silicons.
221  * Also, handling the INS/EXT bit would control the LED being On/Off.
222  * Until the behavior is confirmed, this flag could be used to enable or
223  * disable handling the LED.
224  * 0 means the silicons handles the LED behavior via the INS/EXT bit.
225  * 1 means the software must explicitly do the LED behavior.
226  */
227 static int pcihp_cpci_blue_led = 1;
228 
229 /* static functions */
230 static pcihp_t *pcihp_create_soft_state(dev_info_t *dip);
231 static void pcihp_destroy_soft_state(dev_info_t *dip);
232 static pcihp_t *pcihp_get_soft_state(dev_info_t *dip, int cmd, int *rv);
233 static int pcihp_configure_ap(pcihp_t *pcihp_p, int pci_dev);
234 static int pcihp_unconfigure_ap(pcihp_t *pcihp_p, int pci_dev);
235 static int pcihp_new_slot_state(dev_info_t *, hpc_slot_t,
236 	hpc_slot_info_t *, int);
237 static int pcihp_configure(dev_info_t *, void *);
238 static bool_t pcihp_check_status(dev_info_t *);
239 static int pcihp_event_handler(caddr_t, uint_t);
240 static dev_info_t *pcihp_devi_find(dev_info_t *dip, uint_t dev, uint_t func);
241 static int pcihp_match_dev(dev_info_t *dip, void *hdl);
242 static int pcihp_get_hs_csr(struct pcihp_slotinfo *, ddi_acc_handle_t,
243 	uint8_t *);
244 static void pcihp_set_hs_csr(struct pcihp_slotinfo *, ddi_acc_handle_t,
245 	uint8_t *);
246 static int pcihp_get_hs_csr_location(ddi_acc_handle_t);
247 static int pcihp_handle_enum(pcihp_t *, int, int, int);
248 static void pcihp_hs_csr_op(pcihp_t *, int, int);
249 static int pcihp_enum_slot(pcihp_t *, struct pcihp_slotinfo *, int, int, int);
250 static int pcihp_handle_enum_extraction(pcihp_t *, int, int, int);
251 static int pcihp_handle_enum_insertion(pcihp_t *, int, int, int);
252 static int pcihp_add_dummy_reg_property(dev_info_t *, uint_t, uint_t, uint_t);
253 static int pcihp_config_setup(dev_info_t **, ddi_acc_handle_t *,
254 			dev_info_t **, int, pcihp_t *);
255 static void pcihp_config_teardown(ddi_acc_handle_t *,
256 			dev_info_t **, int, pcihp_t *);
257 static int pcihp_get_board_type(struct pcihp_slotinfo *);
258 /* sysevent function */
259 static void pcihp_gen_sysevent(char *, int, int, dev_info_t *, int);
260 
261 static int pcihp_list_occupants(dev_info_t *, void *);
262 static int pcihp_indirect_map(dev_info_t *dip);
263 
264 #if 0
265 static void pcihp_probe_slot_state(dev_info_t *, int, hpc_slot_state_t *);
266 #endif
267 
268 int pcihp_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
269     int flags, char *name, caddr_t valuep, int *lengthp);
270 
271 struct cb_ops pcihp_cb_ops = {
272 	pcihp_open,			/* open */
273 	pcihp_close,			/* close */
274 	nodev,				/* strategy */
275 	nodev,				/* print */
276 	nodev,				/* dump */
277 	nodev,				/* read */
278 	nodev,				/* write */
279 	pcihp_ioctl,			/* ioctl */
280 	nodev,				/* devmap */
281 	nodev,				/* mmap */
282 	nodev,				/* segmap */
283 	nochpoll,			/* poll */
284 	pcihp_prop_op,			/* cb_prop_op */
285 	NULL,				/* streamtab */
286 	D_NEW | D_MP | D_HOTPLUG,	/* Driver compatibility flag */
287 	CB_REV,				/* rev */
288 	nodev,				/* int (*cb_aread)() */
289 	nodev				/* int (*cb_awrite)() */
290 };
291 
292 /*
293  * local data
294  */
295 
296 int pcihp_autocfg_enabled = 1; /* auto config is enabled by default */
297 
298 static kmutex_t pcihp_mutex; /* mutex to protect the following data */
299 static pcihp_t *pcihp_head = NULL;
300 
301 static kmutex_t pcihp_open_mutex; /* mutex to protect open/close/uninit */
302 static int	pci_devlink_flags = 0;
303 
304 /*
305  * Module linkage information for the kernel.
306  */
307 extern struct mod_ops mod_miscops;
308 static struct modlmisc modlmisc = {
309 	&mod_miscops,
310 	"PCI nexus hotplug support",
311 };
312 
313 static struct modlinkage modlinkage = {
314 	MODREV_1,
315 	&modlmisc,
316 	NULL
317 };
318 
319 int
320 _init(void)
321 {
322 	int error;
323 
324 	mutex_init(&pcihp_mutex, NULL, MUTEX_DRIVER, NULL);
325 	mutex_init(&pcihp_open_mutex, NULL, MUTEX_DRIVER, NULL);
326 	if ((error = mod_install(&modlinkage)) != 0) {
327 		mutex_destroy(&pcihp_open_mutex);
328 		mutex_destroy(&pcihp_mutex);
329 	}
330 
331 	return (error);
332 }
333 
334 int
335 _fini(void)
336 {
337 	return (EBUSY);
338 }
339 
340 int
341 _info(struct modinfo *modinfop)
342 {
343 	return (mod_info(&modlinkage, modinfop));
344 }
345 
346 static	pcihp_t *
347 pcihp_create_soft_state(
348 	dev_info_t *dip)
349 {
350 	pcihp_t	*pcihp_p;
351 
352 	pcihp_p = kmem_zalloc(sizeof (struct pcihp), KM_SLEEP);
353 
354 	pcihp_p->dip = dip;
355 	mutex_init(&pcihp_p->mutex, NULL, MUTEX_DRIVER, NULL);
356 
357 	mutex_enter(&pcihp_mutex);
358 	pcihp_p->nextp = pcihp_head;
359 	pcihp_head = pcihp_p;
360 	pcihp_p->bus_state = PCIHP_BUS_INITIALIZING;
361 	pcihp_p->slots_active = 0;
362 	mutex_exit(&pcihp_mutex);
363 
364 	return (pcihp_p);
365 }
366 
367 static	void
368 pcihp_destroy_soft_state(
369 	dev_info_t *dip)
370 {
371 	pcihp_t	*p;
372 	pcihp_t	**pp;
373 
374 	mutex_enter(&pcihp_mutex);
375 	pp = &pcihp_head;
376 	while ((p = *pp) != NULL) {
377 		if (p->dip == dip) {
378 			*pp = p->nextp;
379 			kmem_free(p, sizeof (struct pcihp));
380 			break;
381 		}
382 		pp = &(p->nextp);
383 	}
384 	mutex_exit(&pcihp_mutex);
385 }
386 
387 /*
388  * This function should be imported by client nexus drivers as their
389  * devo_getinfo() entry point.
390  */
391 
392 /* ARGSUSED */
393 int
394 pcihp_info(
395 	dev_info_t	*dip,
396 	ddi_info_cmd_t	cmd,
397 	void		*arg,
398 	void		**result)
399 {
400 	pcihp_t		*pcihp_p;
401 	major_t		major;
402 	minor_t		minor;
403 	int		instance;
404 
405 	major = getmajor((dev_t)arg);
406 	minor = getminor((dev_t)arg);
407 	instance = PCIHP_AP_MINOR_NUM_TO_INSTANCE(minor);
408 
409 	switch (cmd) {
410 	default:
411 		return (DDI_FAILURE);
412 
413 	case DDI_INFO_DEVT2INSTANCE:
414 		*result = (void *)(intptr_t)instance;
415 		return (DDI_SUCCESS);
416 
417 	case DDI_INFO_DEVT2DEVINFO:
418 		mutex_enter(&pcihp_mutex);
419 		pcihp_p = pcihp_head;
420 		while (pcihp_p != NULL) {
421 			if (ddi_driver_major(pcihp_p->dip) ==
422 			    major && ddi_get_instance(pcihp_p->dip) ==
423 			    instance) {
424 				*result = (void *)pcihp_p->dip;
425 				mutex_exit(&pcihp_mutex);
426 				return (DDI_SUCCESS);
427 			}
428 			pcihp_p = pcihp_p->nextp;
429 		}
430 		mutex_exit(&pcihp_mutex);
431 		return (DDI_FAILURE);
432 	}
433 }
434 
435 /*
436  * This function retrieves the hot plug soft state and performs the
437  * following primitive commands while the soft state is locked:
438  * mark the bus unconfigured, increment slot activity, decrement
439  * slot activity and noop.
440  */
441 
442 /* ARGSUSED */
443 static	pcihp_t *
444 pcihp_get_soft_state(
445 	dev_info_t	*dip, int cmd, int *rv)
446 {
447 	pcihp_t		*pcihp_p;
448 
449 	*rv = PCIHP_SUCCESS;
450 	mutex_enter(&pcihp_mutex);
451 	pcihp_p = pcihp_head;
452 	while (pcihp_p != NULL) {
453 		if (pcihp_p->dip == dip) {
454 			switch (cmd) {
455 			case PCIHP_DR_BUS_UNCONFIGURE:
456 				if (pcihp_p->slots_active == 0)
457 					pcihp_p->bus_state =
458 					    PCIHP_BUS_UNCONFIGURED;
459 				else
460 					*rv = PCIHP_FAILURE;
461 				break;
462 			case PCIHP_DR_SLOT_ENTER:
463 				if (pcihp_p->bus_state ==
464 				    PCIHP_BUS_UNCONFIGURED)
465 					*rv = PCIHP_FAILURE;
466 				else
467 					pcihp_p->slots_active++;
468 				break;
469 			case PCIHP_DR_SLOT_EXIT:
470 				ASSERT(pcihp_p->slots_active > 0);
471 				if (pcihp_p->slots_active == 0)
472 					cmn_err(CE_PANIC,
473 					    "pcihp (%s%d): mismatched slot"
474 					    " activity",
475 					    ddi_driver_name(dip),
476 					    ddi_get_instance(dip));
477 				else
478 					pcihp_p->slots_active--;
479 				break;
480 			case PCIHP_DR_NOOP:
481 				break;
482 			default:
483 				*rv = PCIHP_FAILURE;
484 				break;
485 			}
486 			mutex_exit(&pcihp_mutex);
487 			return (pcihp_p);
488 		}
489 		pcihp_p = pcihp_p->nextp;
490 	}
491 	mutex_exit(&pcihp_mutex);
492 
493 	return (NULL);
494 }
495 
496 /* ARGSUSED3 */
497 static int
498 pcihp_open(dev_t *devp, int flags, int otyp, cred_t *credp)
499 {
500 	dev_info_t *self;
501 	pcihp_t *pcihp_p;
502 	minor_t	minor;
503 	int pci_dev;
504 	int rv;
505 
506 	/*
507 	 * Make sure the open is for the right file type.
508 	 */
509 	if (otyp != OTYP_CHR)
510 		return (EINVAL);
511 
512 	mutex_enter(&pcihp_open_mutex);
513 	/*
514 	 * Get the soft state structure.
515 	 */
516 	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)*devp,
517 	    (void **)&self) != DDI_SUCCESS) {
518 		mutex_exit(&pcihp_open_mutex);
519 		return (ENXIO);
520 	}
521 
522 	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_NOOP, &rv);
523 	ASSERT(pcihp_p != NULL);
524 
525 	mutex_enter(&pcihp_p->mutex);
526 
527 	/*
528 	 * If the pci_dev is valid then the minor device is an
529 	 * AP. Otherwise it is ":devctl" minor device.
530 	 */
531 	minor = getminor(*devp);
532 	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(minor);
533 	if (pci_dev < PCI_MAX_DEVS) {
534 		struct pcihp_slotinfo *slotinfop;
535 
536 		slotinfop = &pcihp_p->slotinfo[pci_dev];
537 		if (slotinfop->slot_hdl == NULL) {
538 			mutex_exit(&pcihp_p->mutex);
539 			mutex_exit(&pcihp_open_mutex);
540 			return (ENXIO);
541 		}
542 	}
543 
544 	/*
545 	 * Handle the open by tracking the device state.
546 	 *
547 	 * Note: Needs review w.r.t exclusive access to AP or the bus.
548 	 * Currently in the pci plug-in we don't use EXCL open at all
549 	 * so the code below implements EXCL access on the bus.
550 	 */
551 
552 	/* enforce exclusive access to the bus */
553 	if ((pcihp_p->soft_state == PCIHP_SOFT_STATE_OPEN_EXCL) ||
554 	    ((flags & FEXCL) &&
555 	    (pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED))) {
556 		mutex_exit(&pcihp_p->mutex);
557 		mutex_exit(&pcihp_open_mutex);
558 		return (EBUSY);
559 	}
560 
561 	if (flags & FEXCL)
562 		pcihp_p->soft_state = PCIHP_SOFT_STATE_OPEN_EXCL;
563 	else
564 		pcihp_p->soft_state = PCIHP_SOFT_STATE_OPEN;
565 
566 	mutex_exit(&pcihp_p->mutex);
567 	mutex_exit(&pcihp_open_mutex);
568 
569 	return (0);
570 }
571 
572 /* ARGSUSED */
573 static int
574 pcihp_close(dev_t dev, int flags, int otyp, cred_t *credp)
575 {
576 	dev_info_t *self;
577 	pcihp_t *pcihp_p;
578 	int rv;
579 
580 	if (otyp != OTYP_CHR)
581 		return (EINVAL);
582 
583 	mutex_enter(&pcihp_open_mutex);
584 
585 	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)dev,
586 	    (void **)&self) != DDI_SUCCESS) {
587 		mutex_exit(&pcihp_open_mutex);
588 		return (ENXIO);
589 	}
590 
591 	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_NOOP, &rv);
592 	ASSERT(pcihp_p != NULL);
593 
594 	mutex_enter(&pcihp_p->mutex);
595 	pcihp_p->soft_state = PCIHP_SOFT_STATE_CLOSED;
596 	mutex_exit(&pcihp_p->mutex);
597 
598 	mutex_exit(&pcihp_open_mutex);
599 
600 	return (0);
601 }
602 
603 static int
604 pcihp_list_occupants(dev_info_t *dip, void *hdl)
605 {
606 	int pci_dev;
607 	struct pcihp_config_ctrl *ctrl = (struct pcihp_config_ctrl *)hdl;
608 	pci_regspec_t *pci_rp;
609 	int length;
610 	major_t major;
611 
612 	/*
613 	 * Get the PCI device number information from the devinfo
614 	 * node. Since the node may not have the address field
615 	 * setup (this is done in the DDI_INITCHILD of the parent)
616 	 * we look up the 'reg' property to decode that information.
617 	 */
618 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
619 	    DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
620 	    (uint_t *)&length) != DDI_PROP_SUCCESS) {
621 		ctrl->rv = DDI_FAILURE;
622 		ctrl->dip = dip;
623 		return (DDI_WALK_TERMINATE);
624 	}
625 
626 	/* get the pci device id information */
627 	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
628 
629 	/*
630 	 * free the memory allocated by ddi_prop_lookup_int_array
631 	 */
632 	ddi_prop_free(pci_rp);
633 
634 	/*
635 	 * Match the node for the device number of the slot.
636 	 */
637 	if (pci_dev == ctrl->pci_dev) { /* node is a match */
638 
639 		major = ddi_driver_major(dip);
640 
641 		/*
642 		 * If the node is not yet attached, then don't list it
643 		 * as an occupant. This is valid, since nothing can be
644 		 * consuming it until it is attached, and cfgadm will
645 		 * ask for the property explicitly which will cause it
646 		 * to be re-freshed right before checking with rcm.
647 		 */
648 		if ((major == -1) || !i_ddi_devi_attached(dip))
649 			return (DDI_WALK_PRUNECHILD);
650 
651 		/*
652 		 * If we have used all our occupants then print mesage
653 		 * and terminate walk.
654 		 */
655 		if (ctrl->occupant->i >= HPC_MAX_OCCUPANTS) {
656 			cmn_err(CE_WARN,
657 			    "pcihp (%s%d): unable to list all occupants",
658 			    ddi_driver_name(ddi_get_parent(dip)),
659 			    ddi_get_instance(ddi_get_parent(dip)));
660 			return (DDI_WALK_TERMINATE);
661 		}
662 
663 		/*
664 		 * No need to hold the dip as ddi_walk_devs
665 		 * has already arranged that for us.
666 		 */
667 		ctrl->occupant->id[ctrl->occupant->i] =
668 		    kmem_alloc(sizeof (char[MAXPATHLEN]), KM_SLEEP);
669 		(void) ddi_pathname(dip,
670 		    (char *)ctrl->occupant->id[ctrl->occupant->i]);
671 		ctrl->occupant->i++;
672 	}
673 
674 	/*
675 	 * continue the walk to the next sibling to look for a match
676 	 * or to find other nodes if this card is a multi-function card.
677 	 */
678 	return (DDI_WALK_PRUNECHILD);
679 }
680 
681 static void
682 pcihp_create_occupant_props_nolock(dev_info_t *self, dev_t dev, int pci_dev)
683 {
684 	struct pcihp_config_ctrl ctrl;
685 	hpc_occupant_info_t *occupant;
686 	int i;
687 
688 	occupant = kmem_alloc(sizeof (hpc_occupant_info_t), KM_SLEEP);
689 	occupant->i = 0;
690 
691 	ctrl.flags = 0;
692 	ctrl.dip = NULL;
693 	ctrl.rv = NDI_SUCCESS;
694 	ctrl.pci_dev = pci_dev;
695 	ctrl.op = 55; /* should define DRYRUN */
696 	ctrl.occupant = occupant;
697 
698 	ddi_walk_devs(ddi_get_child(self), pcihp_list_occupants,
699 	    (void *)&ctrl);
700 
701 	if (occupant->i == 0) {
702 		/* no occupants right now, need to create stub property */
703 		char *c[] = { "" };
704 		(void) ddi_prop_update_string_array(dev, self, "pci-occupant",
705 		    c, 1);
706 	} else {
707 		(void) ddi_prop_update_string_array(dev, self, "pci-occupant",
708 		    occupant->id, occupant->i);
709 	}
710 	for (i = 0; i < occupant->i; i++) {
711 		kmem_free(occupant->id[i], sizeof (char[MAXPATHLEN]));
712 	}
713 
714 	kmem_free(occupant, sizeof (hpc_occupant_info_t));
715 }
716 
717 static void
718 pcihp_create_occupant_props(dev_info_t *self, dev_t dev, int pci_dev)
719 {
720 	int circular;
721 
722 	ndi_devi_enter(self, &circular);
723 	pcihp_create_occupant_props_nolock(self, dev, pci_dev);
724 	ndi_devi_exit(self, circular);
725 }
726 
727 static void
728 pcihp_delete_occupant_props(dev_info_t *dip, dev_t dev)
729 {
730 	if (ddi_prop_remove(dev, dip, "pci-occupant")
731 	    != DDI_PROP_SUCCESS)
732 		return; /* add error handling */
733 
734 }
735 
736 /*
737  * pcihp_ioctl: devctl hotplug controls
738  */
739 /* ARGSUSED */
740 static int
741 pcihp_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
742 	int *rvalp)
743 {
744 	pcihp_t *pcihp_p;
745 	dev_info_t *self;
746 	struct devctl_iocdata *dcp;
747 	uint_t bus_state;
748 	int rv = 0;
749 	int pci_dev;
750 	struct pcihp_slotinfo *slotinfop;
751 	hpc_slot_state_t rstate;
752 	devctl_ap_state_t ap_state;
753 	struct hpc_control_data hpc_ctrldata;
754 	struct hpc_led_info led_info;
755 	time_t time;
756 	int state_locking;
757 	int state_unlocking;
758 	int rval;
759 	char *pathname = NULL;
760 
761 	/*
762 	 * read devctl ioctl data before soft state retrieval
763 	 */
764 	if ((cmd != DEVCTL_AP_CONTROL) &&
765 	    ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
766 		return (EFAULT);
767 
768 	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)dev,
769 	    (void **)&self) != DDI_SUCCESS) {
770 		if (cmd != DEVCTL_AP_CONTROL)
771 			ndi_dc_freehdl(dcp);
772 		return (ENXIO);
773 	}
774 
775 	switch (cmd) {
776 	case DEVCTL_AP_INSERT:
777 	case DEVCTL_AP_REMOVE:
778 	case DEVCTL_AP_CONNECT:
779 	case DEVCTL_AP_DISCONNECT:
780 	case DEVCTL_AP_CONFIGURE:
781 	case DEVCTL_AP_UNCONFIGURE:
782 	case DEVCTL_AP_GETSTATE:
783 	case DEVCTL_AP_CONTROL:
784 		state_locking = PCIHP_DR_SLOT_ENTER;
785 		state_unlocking = PCIHP_DR_SLOT_EXIT;
786 		break;
787 	default:
788 		state_locking = PCIHP_DR_NOOP;
789 		state_unlocking = PCIHP_DR_NOOP;
790 		break;
791 	}
792 
793 	pcihp_p = pcihp_get_soft_state(self, state_locking, &rval);
794 	ASSERT(pcihp_p != NULL);
795 
796 	if (rval == PCIHP_FAILURE) {
797 		(void) ddi_pathname(pcihp_p->dip, pathname);
798 		PCIHP_DEBUG((CE_WARN, "Hot Plug bus %s instance is unconfigured"
799 		    " while slot activity is requested\n", pathname));
800 		if (cmd != DEVCTL_AP_CONTROL)
801 			ndi_dc_freehdl(dcp);
802 		return (EBUSY);
803 	}
804 
805 	/*
806 	 * For attachment points the lower 8 bits of the minor number is the
807 	 * PCI device number.
808 	 */
809 	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(dev));
810 
811 	/*
812 	 * We can use the generic implementation for these ioctls
813 	 */
814 	switch (cmd) {
815 	case DEVCTL_DEVICE_GETSTATE:
816 	case DEVCTL_DEVICE_ONLINE:
817 	case DEVCTL_DEVICE_OFFLINE:
818 	case DEVCTL_BUS_GETSTATE:
819 		rv = ndi_devctl_ioctl(self, cmd, arg, mode, 0);
820 		ndi_dc_freehdl(dcp);
821 		return (rv);
822 	default:
823 		break;
824 	}
825 
826 	switch (cmd) {
827 
828 	case DEVCTL_DEVICE_RESET:
829 		rv = ENOTSUP;
830 		break;
831 
832 	case DEVCTL_BUS_QUIESCE:
833 		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
834 			if (bus_state == BUS_QUIESCED)
835 				break;
836 		(void) ndi_set_bus_state(self, BUS_QUIESCED);
837 		break;
838 
839 	case DEVCTL_BUS_UNQUIESCE:
840 		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
841 			if (bus_state == BUS_ACTIVE)
842 				break;
843 		(void) ndi_set_bus_state(self, BUS_ACTIVE);
844 		break;
845 
846 	case DEVCTL_BUS_RESET:
847 		rv = ENOTSUP;
848 		break;
849 
850 	case DEVCTL_BUS_RESETALL:
851 		rv = ENOTSUP;
852 		break;
853 
854 	case DEVCTL_AP_CONNECT:
855 	case DEVCTL_AP_DISCONNECT:
856 		/*
857 		 * CONNECT(DISCONNECT) the hot plug slot to(from) the bus.
858 		 *
859 		 * For cPCI slots this operation is a nop so the HPC
860 		 * driver may return success if it is a valid operation.
861 		 */
862 	case DEVCTL_AP_INSERT:
863 	case DEVCTL_AP_REMOVE:
864 		/*
865 		 * Prepare the slot for INSERT/REMOVE operation.
866 		 */
867 
868 		/*
869 		 * check for valid request:
870 		 *	1. It is a hotplug slot.
871 		 *	2. The slot has no occupant that is in
872 		 *	   the 'configured' state.
873 		 */
874 		if (pci_dev >= PCI_MAX_DEVS) {
875 			rv = ENXIO;
876 			break;
877 		}
878 		slotinfop = &pcihp_p->slotinfo[pci_dev];
879 
880 		mutex_enter(&slotinfop->slot_mutex);
881 
882 		if ((slotinfop->slot_hdl == NULL) ||
883 		    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
884 			rv = ENXIO;
885 			mutex_exit(&slotinfop->slot_mutex);
886 			break;
887 		}
888 
889 		/* the slot occupant must be in the UNCONFIGURED state */
890 		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
891 			rv = EINVAL;
892 			mutex_exit(&slotinfop->slot_mutex);
893 			break;
894 		}
895 		/*
896 		 * Call the HPC driver to perform the operation on the slot.
897 		 */
898 
899 		switch (cmd) {
900 		case DEVCTL_AP_INSERT:
901 			rv = hpc_nexus_insert(slotinfop->slot_hdl, NULL, 0);
902 			break;
903 		case DEVCTL_AP_REMOVE:
904 			rv = hpc_nexus_remove(slotinfop->slot_hdl, NULL, 0);
905 			break;
906 		case DEVCTL_AP_CONNECT:
907 			rv = hpc_nexus_connect(slotinfop->slot_hdl, NULL, 0);
908 			if (rv == HPC_SUCCESS) {
909 				slotinfop->rstate = AP_RSTATE_CONNECTED;
910 
911 				if (drv_getparm(TIME, (void *)&time) !=
912 				    DDI_SUCCESS)
913 					slotinfop->last_change = (time_t)-1;
914 				else
915 					slotinfop->last_change = (time32_t)time;
916 
917 				slotinfop = &pcihp_p->slotinfo[pci_dev];
918 				pcihp_gen_sysevent(slotinfop->name,
919 				    PCIHP_DR_AP_STATE_CHANGE,
920 				    SE_NO_HINT, pcihp_p->dip,
921 				    KM_SLEEP);
922 			}
923 			break;
924 		case DEVCTL_AP_DISCONNECT:
925 			rv = hpc_nexus_disconnect(slotinfop->slot_hdl, NULL, 0);
926 			if (rv == HPC_SUCCESS) {
927 				slotinfop->rstate = AP_RSTATE_DISCONNECTED;
928 
929 				if (drv_getparm(TIME, (void *)&time) !=
930 				    DDI_SUCCESS)
931 					slotinfop->last_change = (time_t)-1;
932 				else
933 					slotinfop->last_change = (time32_t)time;
934 
935 				slotinfop = &pcihp_p->slotinfo[pci_dev];
936 				pcihp_gen_sysevent(slotinfop->name,
937 				    PCIHP_DR_AP_STATE_CHANGE,
938 				    SE_NO_HINT, pcihp_p->dip,
939 				    KM_SLEEP);
940 			}
941 			break;
942 		}
943 		mutex_exit(&slotinfop->slot_mutex);
944 
945 		switch (rv) {
946 		case HPC_ERR_INVALID:
947 			rv = ENXIO;
948 			break;
949 		case HPC_ERR_NOTSUPPORTED:
950 			rv = ENOTSUP;
951 			break;
952 		case HPC_ERR_FAILED:
953 			rv = EIO;
954 			break;
955 		}
956 
957 		break;
958 
959 	case DEVCTL_AP_CONFIGURE:
960 		/*
961 		 * **************************************
962 		 * CONFIGURE the occupant in the slot.
963 		 * **************************************
964 		 */
965 		slotinfop = &pcihp_p->slotinfo[pci_dev];
966 
967 		mutex_enter(&slotinfop->slot_mutex);
968 
969 		rv = pcihp_configure_ap(pcihp_p, pci_dev);
970 		if (rv == HPC_SUCCESS) {
971 			pcihp_gen_sysevent(slotinfop->name,
972 			    PCIHP_DR_AP_STATE_CHANGE,
973 			    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);
974 			pcihp_create_occupant_props(self, dev, pci_dev);
975 		}
976 		mutex_exit(&slotinfop->slot_mutex);
977 
978 		break;
979 
980 	case DEVCTL_AP_UNCONFIGURE:
981 		/*
982 		 * **************************************
983 		 * UNCONFIGURE the occupant in the slot.
984 		 * **************************************
985 		 */
986 		slotinfop = &pcihp_p->slotinfo[pci_dev];
987 
988 		mutex_enter(&slotinfop->slot_mutex);
989 
990 		rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);
991 
992 		if (rv == HPC_SUCCESS) {
993 			pcihp_gen_sysevent(slotinfop->name,
994 			    PCIHP_DR_AP_STATE_CHANGE,
995 			    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);
996 			pcihp_delete_occupant_props(pcihp_p->dip, dev);
997 		}
998 		mutex_exit(&slotinfop->slot_mutex);
999 
1000 		break;
1001 
1002 	case DEVCTL_AP_GETSTATE:
1003 	{
1004 		int mutex_held;
1005 
1006 		/*
1007 		 * return the state of Attachment Point.
1008 		 *
1009 		 * If the occupant is in UNCONFIGURED state then
1010 		 * we should get the receptacle state from the
1011 		 * HPC driver because the receptacle state
1012 		 * maintained in the nexus may not be accurate.
1013 		 */
1014 
1015 		/*
1016 		 * check for valid request:
1017 		 *	1. It is a hotplug slot.
1018 		 */
1019 		slotinfop = &pcihp_p->slotinfo[pci_dev];
1020 
1021 		/* try to acquire the slot mutex */
1022 		mutex_held = mutex_tryenter(&slotinfop->slot_mutex);
1023 
1024 		if (pci_dev >= PCI_MAX_DEVS || slotinfop->slot_hdl == NULL) {
1025 			rv = ENXIO;
1026 			if (mutex_held) {
1027 				mutex_exit(&slotinfop->slot_mutex);
1028 			}
1029 			break;
1030 		}
1031 
1032 		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED) {
1033 			if (hpc_nexus_control(slotinfop->slot_hdl,
1034 			    HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {
1035 				rv = EIO;
1036 				if (mutex_held)
1037 					mutex_exit(&slotinfop->slot_mutex);
1038 				break;
1039 			}
1040 			slotinfop->rstate = (ap_rstate_t)rstate;
1041 		}
1042 
1043 		ap_state.ap_rstate = slotinfop->rstate;
1044 		ap_state.ap_ostate = slotinfop->ostate;
1045 		ap_state.ap_condition = slotinfop->condition;
1046 		ap_state.ap_last_change = slotinfop->last_change;
1047 		ap_state.ap_error_code = 0; /* XXX */
1048 		if (mutex_held)
1049 			ap_state.ap_in_transition = 0; /* AP is not busy */
1050 		else
1051 			ap_state.ap_in_transition = 1; /* AP is busy */
1052 
1053 		if (mutex_held)
1054 			mutex_exit(&slotinfop->slot_mutex);
1055 
1056 		/* copy the return-AP-state information to the user space */
1057 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS)
1058 			rv = EFAULT;
1059 
1060 		break;
1061 
1062 	}
1063 	case DEVCTL_AP_CONTROL:
1064 		/*
1065 		 * HPC control functions:
1066 		 *	HPC_CTRL_ENABLE_SLOT/HPC_CTRL_DISABLE_SLOT
1067 		 *		Changes the state of the slot and preserves
1068 		 *		the state across the reboot.
1069 		 *	HPC_CTRL_ENABLE_AUTOCFG/HPC_CTRL_DISABLE_AUTOCFG
1070 		 *		Enables or disables the auto configuration
1071 		 *		of hot plugged occupant if the hardware
1072 		 *		supports notification of the hot plug
1073 		 *		events.
1074 		 *	HPC_CTRL_GET_LED_STATE/HPC_CTRL_SET_LED_STATE
1075 		 *		Controls the state of an LED.
1076 		 *	HPC_CTRL_GET_SLOT_INFO
1077 		 *		Get slot information data structure
1078 		 *		(hpc_slot_info_t).
1079 		 *	HPC_CTRL_GET_BOARD_TYPE
1080 		 *		Get board type information (hpc_board_type_t).
1081 		 *	HPC_CTRL_GET_CARD_INFO
1082 		 *		Get card information (hpc_card_info_t).
1083 		 *
1084 		 * These control functions are used by the cfgadm plug-in
1085 		 * to implement "-x" and "-v" options.
1086 		 */
1087 
1088 		/* copy user ioctl data first */
1089 		switch (ddi_model_convert_from(mode & FMODELS)) {
1090 		case DDI_MODEL_ILP32: {
1091 			struct hpc_control32_data hpc_ctrldata32;
1092 
1093 			if (copyin((void *)arg, (void *)&hpc_ctrldata32,
1094 				sizeof (struct hpc_control32_data)) != 0) {
1095 				rv = EFAULT;
1096 				break;
1097 			}
1098 			hpc_ctrldata.cmd = hpc_ctrldata32.cmd;
1099 			hpc_ctrldata.data =
1100 			    (void *)(intptr_t)hpc_ctrldata32.data;
1101 			break;
1102 		}
1103 		case DDI_MODEL_NONE:
1104 			if (copyin((void *)arg, (void *)&hpc_ctrldata,
1105 			    sizeof (struct hpc_control_data)) != 0) {
1106 				rv = EFAULT;
1107 			}
1108 			break;
1109 		default:
1110 			rv = EFAULT;
1111 			break;
1112 		}
1113 		if (rv == EFAULT)
1114 			break;
1115 		/*
1116 		 * check for valid request:
1117 		 *	1. It is a hotplug slot.
1118 		 */
1119 		slotinfop = &pcihp_p->slotinfo[pci_dev];
1120 
1121 		mutex_enter(&slotinfop->slot_mutex);
1122 
1123 		if (pci_dev >= PCI_MAX_DEVS || slotinfop->slot_hdl == NULL) {
1124 			rv = ENXIO;
1125 			mutex_exit(&slotinfop->slot_mutex);
1126 			break;
1127 		}
1128 
1129 		switch (hpc_ctrldata.cmd) {
1130 
1131 		case HPC_CTRL_GET_LED_STATE:
1132 			/* copy the led info from the user space */
1133 			if (copyin(hpc_ctrldata.data, (void *)&led_info,
1134 			    sizeof (hpc_led_info_t)) != 0) {
1135 				rv = EFAULT;
1136 				break;
1137 			}
1138 
1139 			/* get the state of LED information */
1140 			if (hpc_nexus_control(slotinfop->slot_hdl,
1141 			    HPC_CTRL_GET_LED_STATE, (caddr_t)&led_info) != 0) {
1142 
1143 				if (rv != ENOTSUP)
1144 					rv = EIO;
1145 
1146 				break;
1147 			}
1148 
1149 			/* copy the led info to the user space */
1150 			if (copyout((void *)&led_info, hpc_ctrldata.data,
1151 			    sizeof (hpc_led_info_t)) != 0) {
1152 				rv = EFAULT;
1153 				break;
1154 			}
1155 
1156 			break;
1157 
1158 		case HPC_CTRL_SET_LED_STATE:
1159 			/* copy the led info from the user space */
1160 			if (copyin(hpc_ctrldata.data, (void *)&led_info,
1161 			    sizeof (hpc_led_info_t)) != 0) {
1162 				rv = EFAULT;
1163 				break;
1164 			}
1165 
1166 			/* set the state of an LED */
1167 			rv = hpc_nexus_control(slotinfop->slot_hdl,
1168 			    HPC_CTRL_SET_LED_STATE, (caddr_t)&led_info);
1169 
1170 			/*
1171 			 * If the Hotswap Controller does not support
1172 			 * LED management (as you would find typically
1173 			 * in the cPCI industry), then we handle the
1174 			 * blue LED on/off/blink operations, just in
1175 			 * case it helps slot identification.
1176 			 */
1177 			if ((rv == HPC_ERR_NOTSUPPORTED) &&
1178 			    (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)) {
1179 				if (led_info.led != HPC_ATTN_LED)
1180 					break;
1181 
1182 				switch (led_info.state) {
1183 				case HPC_LED_OFF:
1184 					pcihp_hs_csr_op(pcihp_p,
1185 					    pci_dev,
1186 					    HPC_EVENT_SLOT_BLUE_LED_OFF);
1187 					rv = 0;
1188 					break;
1189 				case HPC_LED_ON:
1190 					/*
1191 					 * Please note that leaving
1192 					 * LED ON could be dangerous
1193 					 * as it means it is Ok to
1194 					 * remove the board, which
1195 					 * is not what we want to
1196 					 * convey. So it is upto the
1197 					 * user to take care of this
1198 					 * situation and usage.
1199 					 *
1200 					 * Normally, a Blink command
1201 					 * is more appropriate for
1202 					 * identifying a board.
1203 					 */
1204 					pcihp_hs_csr_op(pcihp_p,
1205 					    pci_dev,
1206 					    HPC_EVENT_SLOT_BLUE_LED_ON);
1207 					rv = 0;
1208 					break;
1209 				case HPC_LED_BLINK:
1210 				{
1211 					int bl;
1212 
1213 					for (bl = 0; bl < 2; bl++) {
1214 						pcihp_hs_csr_op(pcihp_p,
1215 						    pci_dev,
1216 						    HPC_EVENT_SLOT_BLUE_LED_ON);
1217 						delay(pcihp_cpci_led_blink);
1218 					pcihp_hs_csr_op(pcihp_p,
1219 					    pci_dev,
1220 					    HPC_EVENT_SLOT_BLUE_LED_OFF);
1221 						delay(pcihp_cpci_led_blink);
1222 					}
1223 					rv = 0;
1224 					break;
1225 				}
1226 				default:
1227 					break;
1228 				}
1229 			}
1230 
1231 			if (rv == HPC_ERR_FAILED)
1232 				rv = EIO;
1233 			break;
1234 
1235 		case HPC_CTRL_ENABLE_SLOT:
1236 
1237 			/*
1238 			 * If slot already enabled, do not send a duplicate
1239 			 * control message to the HPC driver.
1240 			 */
1241 			if ((slotinfop->slot_flags & PCIHP_SLOT_DISABLED) == 0)
1242 				break;
1243 
1244 			/* tell the HPC driver also */
1245 			if (hpc_nexus_control(slotinfop->slot_hdl,
1246 			    HPC_CTRL_ENABLE_SLOT, NULL) != HPC_SUCCESS) {
1247 				rv = EIO;
1248 				break;
1249 			}
1250 
1251 			/*
1252 			 * Enable the slot for hotplug operations.
1253 			 */
1254 			slotinfop->slot_flags &= ~PCIHP_SLOT_DISABLED;
1255 
1256 			slotinfop->condition = AP_COND_UNKNOWN;
1257 
1258 			/* XXX need to preserve this state across reboot? */
1259 
1260 			break;
1261 
1262 		case HPC_CTRL_DISABLE_SLOT:
1263 
1264 			/* Do not disable if occupant configured */
1265 			if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
1266 				rv = EAGAIN;
1267 				break;
1268 			}
1269 
1270 			/* tell the HPC driver also */
1271 			if (hpc_nexus_control(slotinfop->slot_hdl,
1272 			    HPC_CTRL_DISABLE_SLOT, NULL) != HPC_SUCCESS) {
1273 				rv = EIO;
1274 				break;
1275 			}
1276 
1277 			/*
1278 			 * Disable the slot for hotplug operations.
1279 			 */
1280 			slotinfop->slot_flags |= PCIHP_SLOT_DISABLED;
1281 
1282 			slotinfop->condition = AP_COND_UNUSABLE;
1283 
1284 			/* XXX need to preserve this state across reboot? */
1285 
1286 			break;
1287 
1288 		case HPC_CTRL_ENABLE_AUTOCFG:
1289 			/*
1290 			 * Enable auto configuration on this slot.
1291 			 */
1292 			slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
1293 
1294 			/* tell the HPC driver also */
1295 			(void) hpc_nexus_control(slotinfop->slot_hdl,
1296 			    HPC_CTRL_ENABLE_AUTOCFG, NULL);
1297 
1298 			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
1299 				pcihp_hs_csr_op(pcihp_p, pci_dev,
1300 				    HPC_EVENT_ENABLE_ENUM);
1301 			break;
1302 
1303 		case HPC_CTRL_DISABLE_AUTOCFG:
1304 			/*
1305 			 * Disable auto configuration on this slot.
1306 			 */
1307 			slotinfop->slot_flags &= ~PCIHP_SLOT_AUTO_CFG_EN;
1308 
1309 			/* tell the HPC driver also */
1310 			(void) hpc_nexus_control(slotinfop->slot_hdl,
1311 			    HPC_CTRL_DISABLE_AUTOCFG, NULL);
1312 
1313 			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
1314 				pcihp_hs_csr_op(pcihp_p, pci_dev,
1315 				    HPC_EVENT_DISABLE_ENUM);
1316 			break;
1317 
1318 		case HPC_CTRL_GET_BOARD_TYPE:
1319 		{
1320 			hpc_board_type_t board_type;
1321 
1322 			/*
1323 			 * Get board type data structure, hpc_board_type_t.
1324 			 */
1325 			board_type = pcihp_get_board_type(slotinfop);
1326 			if (board_type == -1) {
1327 				rv = ENXIO;
1328 				break;
1329 			}
1330 
1331 			/* copy the board type info to the user space */
1332 			if (copyout((void *)&board_type, hpc_ctrldata.data,
1333 			    sizeof (hpc_board_type_t)) != 0) {
1334 				rv = ENXIO;
1335 				break;
1336 			}
1337 
1338 			break;
1339 		}
1340 
1341 		case HPC_CTRL_GET_SLOT_INFO:
1342 		{
1343 			hpc_slot_info_t slot_info;
1344 
1345 			/*
1346 			 * Get slot information structure, hpc_slot_info_t.
1347 			 */
1348 			slot_info.version = HPC_SLOT_INFO_VERSION;
1349 			slot_info.slot_type = slotinfop->slot_type;
1350 			slot_info.pci_slot_capabilities =
1351 			    slotinfop->slot_capabilities;
1352 			slot_info.pci_dev_num = (uint16_t)pci_dev;
1353 			(void) strcpy(slot_info.pci_slot_name, slotinfop->name);
1354 
1355 			/* copy the slot info structure to the user space */
1356 			if (copyout((void *)&slot_info, hpc_ctrldata.data,
1357 			    sizeof (hpc_slot_info_t)) != 0) {
1358 				rv = EFAULT;
1359 				break;
1360 			}
1361 
1362 			break;
1363 		}
1364 
1365 		case HPC_CTRL_GET_CARD_INFO:
1366 		{
1367 			hpc_card_info_t card_info;
1368 			ddi_acc_handle_t handle;
1369 			dev_info_t *cdip;
1370 
1371 			/*
1372 			 * Get card information structure, hpc_card_info_t.
1373 			 */
1374 
1375 			/* verify that the card is configured */
1376 			if ((slotinfop->ostate != AP_OSTATE_CONFIGURED) ||
1377 			    ((cdip = pcihp_devi_find(self,
1378 			    pci_dev, 0)) == NULL)) {
1379 				/*
1380 				 * either the card is not present or
1381 				 * it is not configured.
1382 				 */
1383 				rv = ENXIO;
1384 				break;
1385 			}
1386 
1387 			/*
1388 			 * If declared failed, don't allow Config operations.
1389 			 * Otherwise, if good or failing, it is assumed Ok
1390 			 * to get config data.
1391 			 */
1392 			if (slotinfop->condition == AP_COND_FAILED) {
1393 				rv = EIO;
1394 				break;
1395 			}
1396 
1397 			/* get the information from the PCI config header */
1398 			/* for the function 0.				  */
1399 			if (pci_config_setup(cdip, &handle) != DDI_SUCCESS) {
1400 				rv = EIO;
1401 				break;
1402 			}
1403 			card_info.prog_class = pci_config_get8(handle,
1404 			    PCI_CONF_PROGCLASS);
1405 			card_info.base_class = pci_config_get8(handle,
1406 			    PCI_CONF_BASCLASS);
1407 			card_info.sub_class = pci_config_get8(handle,
1408 			    PCI_CONF_SUBCLASS);
1409 			card_info.header_type = pci_config_get8(handle,
1410 			    PCI_CONF_HEADER);
1411 			pci_config_teardown(&handle);
1412 
1413 			/* copy the card info structure to the user space */
1414 			if (copyout((void *)&card_info, hpc_ctrldata.data,
1415 			    sizeof (hpc_card_info_t)) != 0) {
1416 				rv = EFAULT;
1417 				break;
1418 			}
1419 
1420 			break;
1421 		}
1422 
1423 		default:
1424 			rv = EINVAL;
1425 			break;
1426 		}
1427 
1428 		mutex_exit(&slotinfop->slot_mutex);
1429 
1430 		break;
1431 
1432 	default:
1433 		rv = ENOTTY;
1434 	}
1435 
1436 	if (cmd != DEVCTL_AP_CONTROL)
1437 		ndi_dc_freehdl(dcp);
1438 
1439 	(void) pcihp_get_soft_state(self, state_unlocking, &rval);
1440 
1441 	return (rv);
1442 }
1443 
1444 /*
1445  * **************************************
1446  * CONFIGURE the occupant in the slot.
1447  * **************************************
1448  */
1449 static int
1450 pcihp_configure_ap(pcihp_t *pcihp_p, int pci_dev)
1451 {
1452 	dev_info_t *self = pcihp_p->dip;
1453 	int rv = HPC_SUCCESS;
1454 	struct pcihp_slotinfo *slotinfop;
1455 	hpc_slot_state_t rstate;
1456 	struct pcihp_config_ctrl ctrl;
1457 	int circular_count;
1458 	time_t time;
1459 
1460 	/*
1461 	 * check for valid request:
1462 	 *	1. It is a hotplug slot.
1463 	 *	2. The receptacle is in the CONNECTED state.
1464 	 */
1465 	slotinfop = &pcihp_p->slotinfo[pci_dev];
1466 
1467 
1468 
1469 	if ((pci_dev >= PCI_MAX_DEVS) || (slotinfop->slot_hdl == NULL) ||
1470 	    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
1471 
1472 		return (ENXIO);
1473 	}
1474 
1475 	/*
1476 	 * If the occupant is already in (partially?) configured
1477 	 * state then call the ndi_devi_online() on the device
1478 	 * subtree(s) for this attachment point.
1479 	 */
1480 
1481 	if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
1482 		ctrl.flags = PCIHP_CFG_CONTINUE;
1483 		ctrl.rv = NDI_SUCCESS;
1484 		ctrl.dip = NULL;
1485 		ctrl.pci_dev = pci_dev;
1486 		ctrl.op = PCIHP_ONLINE;
1487 
1488 		ndi_devi_enter(self, &circular_count);
1489 		ddi_walk_devs(ddi_get_child(self), pcihp_configure,
1490 		    (void *)&ctrl);
1491 		ndi_devi_exit(self, circular_count);
1492 
1493 		if (ctrl.rv != NDI_SUCCESS) {
1494 			/*
1495 			 * one or more of the devices are not
1496 			 * onlined. How is this to be reported?
1497 			 */
1498 			cmn_err(CE_WARN,
1499 			    "pcihp (%s%d): failed to attach one or"
1500 			    " more drivers for the card in the slot %s",
1501 			    ddi_driver_name(self), ddi_get_instance(self),
1502 			    slotinfop->name);
1503 			/* rv = EFAULT; */
1504 		}
1505 		/* tell HPC driver that the occupant is configured */
1506 		(void) hpc_nexus_control(slotinfop->slot_hdl,
1507 		    HPC_CTRL_DEV_CONFIGURED, NULL);
1508 
1509 		if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
1510 			slotinfop->last_change = (time_t)-1;
1511 		else
1512 			slotinfop->last_change = (time32_t)time;
1513 
1514 
1515 		return (rv);
1516 	}
1517 
1518 	/*
1519 	 * Occupant is in the UNCONFIGURED state.
1520 	 */
1521 
1522 	/* Check if the receptacle is in the CONNECTED state. */
1523 	if (hpc_nexus_control(slotinfop->slot_hdl,
1524 	    HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {
1525 
1526 		return (ENXIO);
1527 	}
1528 
1529 	if (rstate == HPC_SLOT_EMPTY) {
1530 		/* error. slot is empty */
1531 
1532 		return (ENXIO);
1533 	}
1534 
1535 	if (rstate != HPC_SLOT_CONNECTED) {
1536 		/* error. either the slot is empty or connect failed */
1537 
1538 		return (ENXIO);
1539 	}
1540 
1541 	slotinfop->rstate = AP_RSTATE_CONNECTED; /* record rstate */
1542 
1543 	/* Turn INS and LED off, and start configuration. */
1544 	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
1545 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_CONFIGURE);
1546 		if (pcihp_cpci_blue_led)
1547 			pcihp_hs_csr_op(pcihp_p, pci_dev,
1548 			    HPC_EVENT_SLOT_BLUE_LED_OFF);
1549 		slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_INS_PENDING;
1550 	}
1551 
1552 	(void) hpc_nexus_control(slotinfop->slot_hdl,
1553 	    HPC_CTRL_DEV_CONFIG_START, NULL);
1554 
1555 	/*
1556 	 * Call the configurator to configure the card.
1557 	 */
1558 	if (pcicfg_configure(self, pci_dev, PCICFG_ALL_FUNC, 0)
1559 	    != PCICFG_SUCCESS) {
1560 		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
1561 			if (pcihp_cpci_blue_led)
1562 				pcihp_hs_csr_op(pcihp_p, pci_dev,
1563 				    HPC_EVENT_SLOT_BLUE_LED_ON);
1564 			pcihp_hs_csr_op(pcihp_p, pci_dev,
1565 			    HPC_EVENT_SLOT_UNCONFIGURE);
1566 		}
1567 		/* tell HPC driver occupant configure Error */
1568 		(void) hpc_nexus_control(slotinfop->slot_hdl,
1569 		    HPC_CTRL_DEV_CONFIG_FAILURE, NULL);
1570 
1571 		return (EIO);
1572 	}
1573 
1574 	/* record the occupant state as CONFIGURED */
1575 	slotinfop->ostate = AP_OSTATE_CONFIGURED;
1576 	slotinfop->condition = AP_COND_OK;
1577 
1578 	/* now, online all the devices in the AP */
1579 	ctrl.flags = PCIHP_CFG_CONTINUE;
1580 	ctrl.rv = NDI_SUCCESS;
1581 	ctrl.dip = NULL;
1582 	ctrl.pci_dev = pci_dev;
1583 	ctrl.op = PCIHP_ONLINE;
1584 
1585 	ndi_devi_enter(self, &circular_count);
1586 	ddi_walk_devs(ddi_get_child(self), pcihp_configure, (void *)&ctrl);
1587 	ndi_devi_exit(self, circular_count);
1588 
1589 	if (ctrl.rv != NDI_SUCCESS) {
1590 		/*
1591 		 * one or more of the devices are not
1592 		 * ONLINE'd. How is this to be
1593 		 * reported?
1594 		 */
1595 		cmn_err(CE_WARN,
1596 		    "pcihp (%s%d): failed to attach one or"
1597 		    " more drivers for the card in the slot %s",
1598 		    ddi_driver_name(pcihp_p->dip),
1599 		    ddi_get_instance(pcihp_p->dip),
1600 		    slotinfop->name);
1601 		/* rv = EFAULT; */
1602 	}
1603 	/* store HS_CSR location.  No events, jut a read operation. */
1604 	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
1605 		pcihp_hs_csr_op(pcihp_p, pci_dev, -1);
1606 
1607 	/* tell HPC driver that the occupant is configured */
1608 	(void) hpc_nexus_control(slotinfop->slot_hdl,
1609 	    HPC_CTRL_DEV_CONFIGURED, NULL);
1610 
1611 
1612 	return (rv);
1613 }
1614 
1615 /*
1616  * **************************************
1617  * UNCONFIGURE the occupant in the slot.
1618  * **************************************
1619  */
1620 static int
1621 pcihp_unconfigure_ap(pcihp_t *pcihp_p, int pci_dev)
1622 {
1623 	dev_info_t *self = pcihp_p->dip;
1624 	int rv = HPC_SUCCESS;
1625 	struct pcihp_slotinfo *slotinfop;
1626 	struct pcihp_config_ctrl ctrl;
1627 	int circular_count;
1628 	time_t time;
1629 
1630 	/*
1631 	 * check for valid request:
1632 	 *	1. It is a hotplug slot.
1633 	 *	2. The occupant is in the CONFIGURED state.
1634 	 */
1635 	slotinfop = &pcihp_p->slotinfo[pci_dev];
1636 
1637 
1638 
1639 	if ((pci_dev >= PCI_MAX_DEVS) || (slotinfop->slot_hdl == NULL) ||
1640 	    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
1641 
1642 		return (ENXIO);
1643 	}
1644 	/*
1645 	 * The following may not need to be there, as we should
1646 	 * support unconfiguring of boards and free resources
1647 	 * even when the board is not hotswappable. But this is
1648 	 * the only way, we may be able to tell the system
1649 	 * administrator that it is not a hotswap board since
1650 	 * disconnect operation is never called.
1651 	 * This way we help the system administrator from not
1652 	 * accidentally removing a non hotswap board and
1653 	 * possibly destroying it. May be this behavior can
1654 	 * be a default, and can be enabled or disabled via
1655 	 * a global flag.
1656 	 */
1657 	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
1658 		if (slotinfop->slot_flags & PCIHP_SLOT_DEV_NON_HOTPLUG) {
1659 			/* Operation unsupported if no HS board/slot */
1660 			return (ENOTSUP);
1661 		}
1662 	}
1663 
1664 	/*
1665 	 * If the occupant is in the CONFIGURED state then
1666 	 * call the configurator to unconfigure the slot.
1667 	 */
1668 	if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
1669 
1670 		/*
1671 		 * since potential state change is imminent mask
1672 		 * enum events to prevent the slot from being re-configured
1673 		 */
1674 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);
1675 
1676 		/*
1677 		 * Detach all the drivers for the devices in the
1678 		 * slot. Call pcihp_configure() to do this.
1679 		 */
1680 		ctrl.flags = 0;
1681 		ctrl.rv = NDI_SUCCESS;
1682 		ctrl.dip = NULL;
1683 		ctrl.pci_dev = pci_dev;
1684 		ctrl.op = PCIHP_OFFLINE;
1685 
1686 		(void) devfs_clean(self, NULL, DV_CLEAN_FORCE);
1687 		ndi_devi_enter(self, &circular_count);
1688 		ddi_walk_devs(ddi_get_child(self), pcihp_configure,
1689 		    (void *)&ctrl);
1690 		ndi_devi_exit(self, circular_count);
1691 
1692 		if (ctrl.rv != NDI_SUCCESS) {
1693 			/*
1694 			 * Failed to detach one or more drivers
1695 			 * Restore the state of drivers which
1696 			 * are offlined during this operation.
1697 			 */
1698 			ctrl.flags = 0;
1699 			ctrl.rv = NDI_SUCCESS;
1700 			ctrl.dip = NULL;
1701 			ctrl.pci_dev = pci_dev;
1702 			ctrl.op = PCIHP_ONLINE;
1703 
1704 			ndi_devi_enter(self, &circular_count);
1705 			ddi_walk_devs(ddi_get_child(self),
1706 			    pcihp_configure, (void *)&ctrl);
1707 			ndi_devi_exit(self, circular_count);
1708 
1709 			/* tell HPC driver that the occupant is Busy */
1710 			(void) hpc_nexus_control(slotinfop->slot_hdl,
1711 			    HPC_CTRL_DEV_UNCONFIG_FAILURE, NULL);
1712 
1713 			rv = EBUSY;
1714 		} else {
1715 			(void) hpc_nexus_control(slotinfop->slot_hdl,
1716 			    HPC_CTRL_DEV_UNCONFIG_START, NULL);
1717 
1718 			if (pcicfg_unconfigure(self, pci_dev,
1719 			    PCICFG_ALL_FUNC, 0) == PCICFG_SUCCESS) {
1720 				/*
1721 				 * Now that resources are freed,
1722 				 * clear EXT and Turn LED ON.
1723 				 */
1724 				if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
1725 					pcihp_hs_csr_op(pcihp_p, pci_dev,
1726 					    HPC_EVENT_SLOT_UNCONFIGURE);
1727 					if (pcihp_cpci_blue_led)
1728 						pcihp_hs_csr_op(pcihp_p,
1729 						    pci_dev,
1730 						    HPC_EVENT_SLOT_BLUE_LED_ON);
1731 					slotinfop->hs_csr_location = 0;
1732 					slotinfop->slot_flags &=
1733 					    ~(PCIHP_SLOT_DEV_NON_HOTPLUG|
1734 					    PCIHP_SLOT_ENUM_EXT_PENDING);
1735 				}
1736 				slotinfop->ostate = AP_OSTATE_UNCONFIGURED;
1737 				slotinfop->condition = AP_COND_UNKNOWN;
1738 				/*
1739 				 * send the notification of state change
1740 				 * to the HPC driver.
1741 				 */
1742 				(void) hpc_nexus_control(slotinfop->slot_hdl,
1743 				    HPC_CTRL_DEV_UNCONFIGURED,
1744 				    NULL);
1745 			} else {
1746 				/* tell HPC driver occupant unconfigure Error */
1747 				(void) hpc_nexus_control(slotinfop->slot_hdl,
1748 				    HPC_CTRL_DEV_UNCONFIG_FAILURE, NULL);
1749 
1750 				rv = EIO;
1751 			}
1752 		}
1753 	}
1754 
1755 	if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
1756 		slotinfop->last_change = (time_t)-1;
1757 	else
1758 		slotinfop->last_change = (time32_t)time;
1759 
1760 
1761 
1762 	/* unmask enum events again */
1763 	if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
1764 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);
1765 	}
1766 
1767 	return (rv);
1768 }
1769 
1770 /*
1771  * Accessor function to return pointer to the pci hotplug
1772  * cb_ops structure.
1773  */
1774 struct cb_ops *
1775 pcihp_get_cb_ops()
1776 {
1777 	return (&pcihp_cb_ops);
1778 }
1779 
1780 /*
1781  * Setup function to initialize hot plug feature. Returns DDI_SUCCESS
1782  * for successful initialization, otherwise it returns DDI_FAILURE.
1783  *
1784  * It is assumed that this this function is called from the attach()
1785  * entry point of the PCI nexus driver.
1786  */
1787 
1788 int
1789 pcihp_init(dev_info_t *dip)
1790 {
1791 	pcihp_t *pcihp_p;
1792 	int i;
1793 	caddr_t enum_data;
1794 	int enum_size;
1795 	int rv;
1796 
1797 	mutex_enter(&pcihp_open_mutex);
1798 
1799 	/*
1800 	 * Make sure that it is not already initialized.
1801 	 */
1802 	if (pcihp_get_soft_state(dip, PCIHP_DR_NOOP, &rv) != NULL) {
1803 		cmn_err(CE_WARN, "%s%d: pcihp instance already initialized!",
1804 		    ddi_driver_name(dip), ddi_get_instance(dip));
1805 		goto cleanup;
1806 	}
1807 
1808 	/*
1809 	 * Initialize soft state structure for the bus instance.
1810 	 */
1811 	if ((pcihp_p = pcihp_create_soft_state(dip)) == NULL) {
1812 		cmn_err(CE_WARN, "%s%d: can't allocate pcihp structure",
1813 		    ddi_driver_name(dip), ddi_get_instance(dip));
1814 		goto cleanup;
1815 	}
1816 
1817 	pcihp_p->soft_state = PCIHP_SOFT_STATE_CLOSED;
1818 	/* XXX if bus is running at 66Mhz then set PCI_BUS_66MHZ bit */
1819 	pcihp_p->bus_flags = 0;	/* XXX FIX IT */
1820 
1821 	/*
1822 	 * If a platform wishes to implement Radial ENUM# routing
1823 	 * a property "enum-impl" must be presented to us with a
1824 	 * string value "radial".
1825 	 * This helps us not go for polling operation (default)
1826 	 * during a ENUM# event.
1827 	 */
1828 	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, 0, "enum-impl",
1829 	    (caddr_t)&enum_data, &enum_size) == DDI_PROP_SUCCESS) {
1830 		if (strcmp(enum_data, "radial") == 0) {
1831 			pcihp_p->bus_flags |= PCIHP_BUS_ENUM_RADIAL;
1832 		}
1833 		kmem_free(enum_data, enum_size);
1834 	}
1835 
1836 	for (i = 0; i < PCI_MAX_DEVS; i++) {
1837 		/* initialize slot mutex */
1838 		mutex_init(&pcihp_p->slotinfo[i].slot_mutex, NULL,
1839 		    MUTEX_DRIVER, NULL);
1840 	}
1841 
1842 	/*
1843 	 *  register the bus instance with the HPS framework.
1844 	 */
1845 	if (hpc_nexus_register_bus(dip, pcihp_new_slot_state, 0) != 0) {
1846 		cmn_err(CE_WARN, "%s%d: failed to register the bus with HPS",
1847 		    ddi_driver_name(dip), ddi_get_instance(dip));
1848 		goto cleanup1;
1849 	}
1850 
1851 	/*
1852 	 * Create the "devctl" minor for hot plug support. The minor
1853 	 * number for "devctl" node is in the same format as the AP
1854 	 * minor nodes.
1855 	 */
1856 	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
1857 	    PCIHP_AP_MINOR_NUM(ddi_get_instance(dip), PCIHP_DEVCTL_MINOR),
1858 	    DDI_NT_NEXUS, 0) != DDI_SUCCESS)
1859 		goto cleanup2;
1860 
1861 	/*
1862 	 * Setup resource maps for this bus node. (Note: This can
1863 	 * be done from the attach(9E) of the nexus itself.)
1864 	 */
1865 	(void) pci_resource_setup(dip);
1866 
1867 	pcihp_p->bus_state = PCIHP_BUS_CONFIGURED;
1868 
1869 	mutex_exit(&pcihp_open_mutex);
1870 
1871 	return (DDI_SUCCESS);
1872 
1873 cleanup2:
1874 	(void) hpc_nexus_unregister_bus(dip);
1875 cleanup1:
1876 	for (i = 0; i < PCI_MAX_DEVS; i++)
1877 		mutex_destroy(&pcihp_p->slotinfo[i].slot_mutex);
1878 	pcihp_destroy_soft_state(dip);
1879 cleanup:
1880 	mutex_exit(&pcihp_open_mutex);
1881 	return (DDI_FAILURE);
1882 }
1883 
1884 /*
1885  * pcihp_uninit()
1886  *
1887  * The bus instance is going away, cleanup any data associated with
1888  * the management of hot plug slots. It is assumed that this function
1889  * is called from detach() routine of the PCI nexus driver. Also,
1890  * it is assumed that no devices on the bus are in the configured state.
1891  */
1892 int
1893 pcihp_uninit(dev_info_t *dip)
1894 {
1895 	pcihp_t *pcihp_p;
1896 	int i, j;
1897 	int rv;
1898 
1899 	mutex_enter(&pcihp_open_mutex);
1900 	/* get a pointer to the soft state structure */
1901 	pcihp_p = pcihp_get_soft_state(dip, PCIHP_DR_BUS_UNCONFIGURE, &rv);
1902 	ASSERT(pcihp_p != NULL);
1903 
1904 	/* slot mutexes should prevent any configure/unconfigure access */
1905 	for (i = 0; i < PCI_MAX_DEVS; i++) {
1906 		if (!mutex_tryenter(&pcihp_p->slotinfo[i].slot_mutex)) {
1907 			for (j = 0; j < i; j++) {
1908 				mutex_exit(&pcihp_p->slotinfo[j].slot_mutex);
1909 			}
1910 			mutex_exit(&pcihp_open_mutex);
1911 			return (DDI_FAILURE);
1912 		}
1913 	}
1914 
1915 	if ((pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED) ||
1916 	    (rv == PCIHP_FAILURE)) {
1917 		cmn_err(CE_WARN, "%s%d: pcihp instance is busy",
1918 		    ddi_driver_name(dip), ddi_get_instance(dip));
1919 		for (i = 0; i < PCI_MAX_DEVS; i++) {
1920 			mutex_exit(&pcihp_p->slotinfo[i].slot_mutex);
1921 		}
1922 		mutex_exit(&pcihp_open_mutex);
1923 		return (DDI_FAILURE);
1924 	}
1925 
1926 	/*
1927 	 * Unregister the bus with the HPS.
1928 	 *
1929 	 * (Note: It is assumed that the HPS framework uninstalls
1930 	 *  event handlers for all the hot plug slots on this bus.)
1931 	 */
1932 	(void) hpc_nexus_unregister_bus(dip);
1933 
1934 	/* Free up any kmem_alloc'd memory for slot info table. */
1935 	for (i = 0; i < PCI_MAX_DEVS; i++) {
1936 		/* free up slot name strings */
1937 		if (pcihp_p->slotinfo[i].name != NULL)
1938 			kmem_free(pcihp_p->slotinfo[i].name,
1939 			    strlen(pcihp_p->slotinfo[i].name) + 1);
1940 	}
1941 
1942 	/* destroy slot mutexes */
1943 	for (i = 0; i < PCI_MAX_DEVS; i++)
1944 		mutex_destroy(&pcihp_p->slotinfo[i].slot_mutex);
1945 
1946 	ddi_remove_minor_node(dip, NULL);
1947 
1948 	/* free up the soft state structure */
1949 	pcihp_destroy_soft_state(dip);
1950 
1951 	/*
1952 	 * Destroy resource maps for this bus node. (Note: This can
1953 	 * be done from the detach(9E) of the nexus itself.)
1954 	 */
1955 	(void) pci_resource_destroy(dip);
1956 
1957 	mutex_exit(&pcihp_open_mutex);
1958 
1959 	return (DDI_SUCCESS);
1960 }
1961 
1962 /*
1963  * pcihp_new_slot_state()
1964  *
1965  * This function is called by the HPS when it finds a hot plug
1966  * slot is added or being removed from the hot plug framework.
1967  * It returns 0 for success and HPC_ERR_FAILED for errors.
1968  */
1969 static int
1970 pcihp_new_slot_state(dev_info_t *dip, hpc_slot_t hdl,
1971 	hpc_slot_info_t *slot_info, int slot_state)
1972 {
1973 	pcihp_t *pcihp_p;
1974 	struct pcihp_slotinfo *slotinfop;
1975 	int pci_dev;
1976 	minor_t ap_minor;
1977 	major_t ap_major;
1978 	int rv = 0;
1979 	time_t time;
1980 	int auto_enable = 1;
1981 	int rval;
1982 
1983 	/* get a pointer to the soft state structure */
1984 	pcihp_p = pcihp_get_soft_state(dip, PCIHP_DR_SLOT_ENTER, &rval);
1985 	ASSERT(pcihp_p != NULL);
1986 
1987 	if (rval == PCIHP_FAILURE) {
1988 		PCIHP_DEBUG((CE_WARN, "pcihp instance is unconfigured"
1989 		    " while slot activity is requested\n"));
1990 		return (HPC_ERR_FAILED);
1991 	}
1992 
1993 	pci_dev = slot_info->pci_dev_num;
1994 	slotinfop = &pcihp_p->slotinfo[pci_dev];
1995 
1996 	mutex_enter(&slotinfop->slot_mutex);
1997 
1998 	switch (slot_state) {
1999 
2000 	case HPC_SLOT_ONLINE:
2001 
2002 		/*
2003 		 * Make sure the slot is not already ONLINE (paranoia?).
2004 		 * (Note: Should this be simply an ASSERTION?)
2005 		 */
2006 		if (slotinfop->slot_hdl != NULL) {
2007 			PCIHP_DEBUG((CE_WARN,
2008 			    "pcihp (%s%d): pci slot (dev %x) already ONLINE!!",
2009 			    ddi_driver_name(dip), ddi_get_instance(dip),
2010 			    pci_dev));
2011 			rv = HPC_ERR_FAILED;
2012 			break;
2013 		}
2014 
2015 		/*
2016 		 * Add the hot plug slot to the bus.
2017 		 */
2018 
2019 		/* create the AP minor node */
2020 		ap_minor = PCIHP_AP_MINOR_NUM(ddi_get_instance(dip), pci_dev);
2021 		if (ddi_create_minor_node(dip, slot_info->pci_slot_name,
2022 		    S_IFCHR, ap_minor,
2023 		    DDI_NT_PCI_ATTACHMENT_POINT, 0) == DDI_FAILURE) {
2024 			cmn_err(CE_WARN,
2025 			    "pcihp (%s%d): ddi_create_minor_node failed"
2026 			    " for pci dev %x", ddi_driver_name(dip),
2027 			    ddi_get_instance(dip), pci_dev);
2028 			rv = HPC_ERR_FAILED;
2029 			break;
2030 		}
2031 
2032 		/* save the slot handle */
2033 		slotinfop->slot_hdl = hdl;
2034 
2035 		/* setup event handler for all hardware events on the slot */
2036 		ap_major = ddi_driver_major(dip);
2037 		if (hpc_install_event_handler(hdl, -1, pcihp_event_handler,
2038 		    (caddr_t)makedevice(ap_major, ap_minor)) != 0) {
2039 			cmn_err(CE_WARN,
2040 			    "pcihp (%s%d): install event handler failed"
2041 			    " for pci dev %x", ddi_driver_name(dip),
2042 			    ddi_get_instance(dip), pci_dev);
2043 			rv = HPC_ERR_FAILED;
2044 			break;
2045 		}
2046 		slotinfop->event_mask = (uint32_t)0xFFFFFFFF;
2047 
2048 		pcihp_create_occupant_props(dip, makedevice(ap_major,
2049 		    ap_minor), pci_dev);
2050 
2051 		/* set default auto configuration enabled flag for this slot */
2052 		slotinfop->slot_flags = pcihp_autocfg_enabled;
2053 
2054 		/* copy the slot information */
2055 		slotinfop->name =
2056 		    kmem_alloc(strlen(slot_info->pci_slot_name) + 1, KM_SLEEP);
2057 		(void) strcpy(slotinfop->name, slot_info->pci_slot_name);
2058 		slotinfop->slot_type = slot_info->slot_type;
2059 		slotinfop->hs_csr_location = 0;
2060 		slotinfop->slot_capabilities = slot_info->pci_slot_capabilities;
2061 		if (slot_info->slot_flags & HPC_SLOT_NO_AUTO_ENABLE)
2062 			auto_enable = 0;
2063 
2064 		if (slot_info->slot_flags & HPC_SLOT_CREATE_DEVLINK) {
2065 			pci_devlink_flags |= (1 << pci_dev);
2066 			(void) ddi_prop_update_int(DDI_DEV_T_NONE,
2067 			    dip, "ap-names", pci_devlink_flags);
2068 		}
2069 
2070 		PCIHP_DEBUG((CE_NOTE,
2071 		    "pcihp (%s%d): pci slot (dev %x) ONLINE\n",
2072 		    ddi_driver_name(dip), ddi_get_instance(dip), pci_dev));
2073 
2074 		/*
2075 		 * The slot may have an occupant that was configured
2076 		 * at boot time. If we find a devinfo node in the tree
2077 		 * for this slot (i.e pci device number) then we
2078 		 * record the occupant state as CONFIGURED.
2079 		 */
2080 		if (pcihp_devi_find(dip, pci_dev, 0) != NULL) {
2081 			/* we have a configured occupant */
2082 			slotinfop->ostate = AP_OSTATE_CONFIGURED;
2083 			slotinfop->rstate = AP_RSTATE_CONNECTED;
2084 			slotinfop->condition = AP_COND_OK;
2085 
2086 			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2087 				/* this will set slot flags too. */
2088 				(void) pcihp_get_board_type(slotinfop);
2089 				pcihp_hs_csr_op(pcihp_p, pci_dev,
2090 				    HPC_EVENT_SLOT_CONFIGURE);
2091 				if (pcihp_cpci_blue_led)
2092 					pcihp_hs_csr_op(pcihp_p, pci_dev,
2093 					    HPC_EVENT_SLOT_BLUE_LED_OFF);
2094 				/* ENUM# enabled by default for cPCI devices */
2095 				slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
2096 				slotinfop->slot_flags &=
2097 				    ~PCIHP_SLOT_ENUM_INS_PENDING;
2098 			}
2099 
2100 			/* tell HPC driver that the occupant is configured */
2101 			(void) hpc_nexus_control(slotinfop->slot_hdl,
2102 			    HPC_CTRL_DEV_CONFIGURED, NULL);
2103 
2104 			/*
2105 			 * Tell sysevent listeners that slot has
2106 			 * changed state.  At minimum, this is useful
2107 			 * when a PCI-E Chassis (containing Occupants) is
2108 			 * hotplugged.  In this case, the following will
2109 			 * announce that the Occupant in the Receptacle
2110 			 * in the Chassis had a state-change.
2111 			 */
2112 			pcihp_gen_sysevent(slotinfop->name,
2113 			    PCIHP_DR_AP_STATE_CHANGE, SE_NO_HINT,
2114 			    pcihp_p->dip, KM_SLEEP);
2115 		} else {
2116 			struct pcihp_config_ctrl ctrl;
2117 			int circular_count;
2118 
2119 			slotinfop->ostate = AP_OSTATE_UNCONFIGURED;
2120 			slotinfop->rstate = AP_RSTATE_EMPTY;
2121 			slotinfop->condition = AP_COND_UNKNOWN;
2122 
2123 			if (!auto_enable) {	/* no further action */
2124 				break;
2125 			}
2126 
2127 			/*
2128 			 * We enable power to the slot and try to
2129 			 * configure if there is any card present.
2130 			 *
2131 			 * Note: This case is possible if the BIOS or
2132 			 * firmware doesn't enable the slots during
2133 			 * soft reboot.
2134 			 */
2135 			if (hpc_nexus_connect(slotinfop->slot_hdl,
2136 			    NULL, 0) != HPC_SUCCESS)
2137 				break;
2138 
2139 			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2140 				pcihp_hs_csr_op(pcihp_p, pci_dev,
2141 				    HPC_EVENT_SLOT_CONFIGURE);
2142 				if (pcihp_cpci_blue_led)
2143 					pcihp_hs_csr_op(pcihp_p, pci_dev,
2144 					    HPC_EVENT_SLOT_BLUE_LED_OFF);
2145 				slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
2146 				slotinfop->slot_flags &=
2147 				    ~PCIHP_SLOT_ENUM_INS_PENDING;
2148 			}
2149 
2150 			(void) hpc_nexus_control(slotinfop->slot_hdl,
2151 			    HPC_CTRL_DEV_CONFIG_START, NULL);
2152 
2153 			/*
2154 			 * Call the configurator to configure the card.
2155 			 */
2156 			if (pcicfg_configure(dip, pci_dev, PCICFG_ALL_FUNC, 0)
2157 			    != PCICFG_SUCCESS) {
2158 				if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2159 					if (pcihp_cpci_blue_led)
2160 						pcihp_hs_csr_op(pcihp_p,
2161 						    pci_dev,
2162 						    HPC_EVENT_SLOT_BLUE_LED_ON);
2163 					pcihp_hs_csr_op(pcihp_p, pci_dev,
2164 					    HPC_EVENT_SLOT_UNCONFIGURE);
2165 				}
2166 
2167 				/* tell HPC driver occupant configure Error */
2168 				(void) hpc_nexus_control(slotinfop->slot_hdl,
2169 				    HPC_CTRL_DEV_CONFIG_FAILURE, NULL);
2170 
2171 				/*
2172 				 * call HPC driver to turn off the power for
2173 				 * the slot.
2174 				 */
2175 				(void) hpc_nexus_disconnect(slotinfop->slot_hdl,
2176 				    NULL, 0);
2177 			} else {
2178 				/* record the occupant state as CONFIGURED */
2179 				slotinfop->ostate = AP_OSTATE_CONFIGURED;
2180 				slotinfop->rstate = AP_RSTATE_CONNECTED;
2181 				slotinfop->condition = AP_COND_OK;
2182 
2183 				/* now, online all the devices in the AP */
2184 				ctrl.flags = PCIHP_CFG_CONTINUE;
2185 				ctrl.rv = NDI_SUCCESS;
2186 				ctrl.dip = NULL;
2187 				ctrl.pci_dev = pci_dev;
2188 				ctrl.op = PCIHP_ONLINE;
2189 				/*
2190 				 * the following sets slot_flags and
2191 				 * hs_csr_location too.
2192 				 */
2193 				(void) pcihp_get_board_type(slotinfop);
2194 
2195 				ndi_devi_enter(dip, &circular_count);
2196 				ddi_walk_devs(ddi_get_child(dip),
2197 				    pcihp_configure, (void *)&ctrl);
2198 				ndi_devi_exit(dip, circular_count);
2199 
2200 				if (ctrl.rv != NDI_SUCCESS) {
2201 					/*
2202 					 * one or more of the devices are not
2203 					 * ONLINE'd. How is this to be
2204 					 * reported?
2205 					 */
2206 					cmn_err(CE_WARN,
2207 					    "pcihp (%s%d): failed to attach"
2208 					    " one or more drivers for the"
2209 					    " card in the slot %s",
2210 					    ddi_driver_name(dip),
2211 					    ddi_get_instance(dip),
2212 					    slotinfop->name);
2213 				}
2214 
2215 				/* tell HPC driver the Occupant is Configured */
2216 				(void) hpc_nexus_control(slotinfop->slot_hdl,
2217 				    HPC_CTRL_DEV_CONFIGURED, NULL);
2218 
2219 				/*
2220 				 * Tell sysevent listeners that slot has
2221 				 * changed state.  At minimum, this is useful
2222 				 * when a PCI-E Chassis (containing Occupants)
2223 				 * is hotplugged.  In this case, the following
2224 				 * will announce that the Occupant in the
2225 				 * Receptacle in the Chassis had a state-change.
2226 				 */
2227 				pcihp_gen_sysevent(slotinfop->name,
2228 				    PCIHP_DR_AP_STATE_CHANGE, SE_NO_HINT,
2229 				    pcihp_p->dip, KM_SLEEP);
2230 			}
2231 		}
2232 
2233 		break;
2234 
2235 	case HPC_SLOT_OFFLINE:
2236 		/*
2237 		 * A hot plug slot is being removed from the bus.
2238 		 * Make sure there is no occupant configured on the
2239 		 * slot before removing the AP minor node.
2240 		 */
2241 		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
2242 			cmn_err(CE_WARN, "pcihp (%s%d): Card is still in "
2243 			    "configured state for pci dev %x",
2244 			    ddi_driver_name(dip), ddi_get_instance(dip),
2245 			    pci_dev);
2246 			rv = HPC_ERR_FAILED;
2247 			break;
2248 		}
2249 
2250 		/*
2251 		 * If the AP device is in open state then return
2252 		 * error.
2253 		 */
2254 		if (pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED) {
2255 			rv = HPC_ERR_FAILED;
2256 			break;
2257 		}
2258 		if (slot_info->slot_flags & HPC_SLOT_CREATE_DEVLINK) {
2259 			pci_devlink_flags &= ~(1 << pci_dev);
2260 			(void) ddi_prop_update_int(DDI_DEV_T_NONE, dip,
2261 			    "ap-names", pci_devlink_flags);
2262 		}
2263 
2264 		/* remove the minor node */
2265 		ddi_remove_minor_node(dip, slotinfop->name);
2266 
2267 		/* free up the memory for the name string */
2268 		kmem_free(slotinfop->name, strlen(slotinfop->name) + 1);
2269 
2270 		/* update the slot info data */
2271 		slotinfop->name = NULL;
2272 		slotinfop->slot_hdl = NULL;
2273 
2274 		PCIHP_DEBUG((CE_NOTE,
2275 		    "pcihp (%s%d): pci slot (dev %x) OFFLINE\n",
2276 		    ddi_driver_name(dip), ddi_get_instance(dip),
2277 		    slot_info->pci_dev_num));
2278 
2279 		break;
2280 	default:
2281 		cmn_err(CE_WARN,
2282 		    "pcihp_new_slot_state: unknown slot_state %d", slot_state);
2283 		rv = HPC_ERR_FAILED;
2284 	}
2285 
2286 	if (rv == 0) {
2287 		if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
2288 			slotinfop->last_change = (time_t)-1;
2289 		else
2290 			slotinfop->last_change = (time32_t)time;
2291 	}
2292 
2293 	mutex_exit(&slotinfop->slot_mutex);
2294 
2295 	(void) pcihp_get_soft_state(dip, PCIHP_DR_SLOT_EXIT, &rval);
2296 
2297 	return (rv);
2298 }
2299 
2300 /*
2301  * Event handler. It is assumed that this function is called from
2302  * a kernel context only.
2303  *
2304  * Parameters:
2305  *	slot_arg	AP minor number.
2306  *	event_mask	Event that occurred.
2307  */
2308 
2309 static int
2310 pcihp_event_handler(caddr_t slot_arg, uint_t event_mask)
2311 {
2312 	dev_t ap_dev = (dev_t)slot_arg;
2313 	dev_info_t *self;
2314 	pcihp_t *pcihp_p;
2315 	int pci_dev;
2316 	int rv = HPC_EVENT_CLAIMED;
2317 	struct pcihp_slotinfo *slotinfop;
2318 	struct pcihp_config_ctrl ctrl;
2319 	int circular_count;
2320 	int rval;
2321 	int hint;
2322 	hpc_slot_state_t rstate;
2323 	struct hpc_led_info led_info;
2324 
2325 	/*
2326 	 * Get the soft state structure.
2327 	 */
2328 	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)ap_dev,
2329 	    (void **)&self) != DDI_SUCCESS)
2330 		return (ENXIO);
2331 
2332 	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_SLOT_ENTER, &rval);
2333 	ASSERT(pcihp_p != NULL);
2334 
2335 	if (rval == PCIHP_FAILURE) {
2336 		PCIHP_DEBUG((CE_WARN, "pcihp instance is unconfigured"
2337 		    " while slot activity is requested\n"));
2338 		return (-1);
2339 	}
2340 
2341 	/* get the PCI device number for the slot */
2342 	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(ap_dev));
2343 
2344 	slotinfop = &pcihp_p->slotinfo[pci_dev];
2345 
2346 	/*
2347 	 * All the events that may be handled in interrupt context should be
2348 	 * free of any mutex usage.
2349 	 */
2350 	switch (event_mask) {
2351 
2352 	case HPC_EVENT_CLEAR_ENUM:
2353 		/*
2354 		 * Check and clear ENUM# interrupt status. This may be
2355 		 * called by the Hotswap controller driver when it is
2356 		 * operating in a full hotswap system where the
2357 		 * platform may not have control on globally disabling ENUM#.
2358 		 * In such cases, the intent is to clear interrupt and
2359 		 * process the interrupt in non-interrupt context.
2360 		 * This is the first part of the ENUM# event processing.
2361 		 */
2362 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): ENUM# is generated"
2363 		    " on the bus (for slot %s ?)",
2364 		    ddi_driver_name(pcihp_p->dip),
2365 		    ddi_get_instance(pcihp_p->dip), slotinfop->name));
2366 
2367 		/* this is the only event coming through in interrupt context */
2368 		rv = pcihp_handle_enum(pcihp_p, pci_dev, PCIHP_CLEAR_ENUM,
2369 		    KM_NOSLEEP);
2370 
2371 		(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT, &rval);
2372 
2373 		return (rv);
2374 	default:
2375 		break;
2376 	}
2377 
2378 	mutex_enter(&slotinfop->slot_mutex);
2379 
2380 	if (hpc_nexus_control(slotinfop->slot_hdl,
2381 	    HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0)
2382 		rv = HPC_ERR_FAILED;
2383 
2384 	slotinfop->rstate = (ap_rstate_t)rstate;
2385 
2386 	switch (event_mask) {
2387 
2388 	case HPC_EVENT_SLOT_INSERTION:
2389 		/*
2390 		 * A card is inserted in the slot. Just report this
2391 		 * event and return.
2392 		 */
2393 		cmn_err(CE_NOTE, "pcihp (%s%d): card is inserted"
2394 		    " in the slot %s (pci dev %x)",
2395 		    ddi_driver_name(pcihp_p->dip),
2396 		    ddi_get_instance(pcihp_p->dip),
2397 		    slotinfop->name, pci_dev);
2398 
2399 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2400 
2401 		break;
2402 
2403 	case HPC_EVENT_SLOT_CONFIGURE:
2404 		/*
2405 		 * Configure the occupant that is just inserted in the slot.
2406 		 * The receptacle may or may not be in the connected state. If
2407 		 * the receptacle is not connected and the auto configuration
2408 		 * is enabled on this slot then connect the slot. If auto
2409 		 * configuration is enabled then configure the card.
2410 		 */
2411 		if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
2412 			/*
2413 			 * auto configuration is disabled. Tell someone
2414 			 * like RCM about this hotplug event?
2415 			 */
2416 			cmn_err(CE_NOTE, "pcihp (%s%d): SLOT_CONFIGURE event"
2417 			    " occurred for pci dev %x (slot %s),"
2418 			    " Slot disabled for auto-configuration.",
2419 			    ddi_driver_name(pcihp_p->dip),
2420 			    ddi_get_instance(pcihp_p->dip), pci_dev,
2421 			    slotinfop->name);
2422 
2423 			/* +++ HOOK for RCM to report this hotplug event? +++ */
2424 
2425 			break;
2426 		}
2427 
2428 		if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
2429 			cmn_err(CE_WARN, "pcihp (%s%d): SLOT_CONFIGURE event"
2430 			    " re-occurred for pci dev %x (slot %s),",
2431 			    ddi_driver_name(pcihp_p->dip),
2432 			    ddi_get_instance(pcihp_p->dip), pci_dev,
2433 			    slotinfop->name);
2434 			mutex_exit(&slotinfop->slot_mutex);
2435 
2436 			(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT,
2437 			    &rval);
2438 
2439 			return (EAGAIN);
2440 		}
2441 
2442 		/*
2443 		 * Auto configuration is enabled. First, make sure the
2444 		 * receptacle is in the CONNECTED state.
2445 		 */
2446 		if ((rv = hpc_nexus_connect(slotinfop->slot_hdl,
2447 		    NULL, 0)) == HPC_SUCCESS) {
2448 			/* record rstate */
2449 			slotinfop->rstate = AP_RSTATE_CONNECTED;
2450 		}
2451 
2452 		/* Clear INS and Turn LED Off and start configuring. */
2453 		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2454 			pcihp_hs_csr_op(pcihp_p, pci_dev,
2455 			    HPC_EVENT_SLOT_CONFIGURE);
2456 			if (pcihp_cpci_blue_led)
2457 				pcihp_hs_csr_op(pcihp_p, pci_dev,
2458 				    HPC_EVENT_SLOT_BLUE_LED_OFF);
2459 		}
2460 
2461 		(void) hpc_nexus_control(slotinfop->slot_hdl,
2462 		    HPC_CTRL_DEV_CONFIG_START, NULL);
2463 
2464 		/*
2465 		 * Call the configurator to configure the card.
2466 		 */
2467 		if (pcicfg_configure(pcihp_p->dip, pci_dev, PCICFG_ALL_FUNC, 0)
2468 		    != PCICFG_SUCCESS) {
2469 			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2470 				if (pcihp_cpci_blue_led)
2471 					pcihp_hs_csr_op(pcihp_p, pci_dev,
2472 					    HPC_EVENT_SLOT_BLUE_LED_ON);
2473 				pcihp_hs_csr_op(pcihp_p, pci_dev,
2474 				    HPC_EVENT_SLOT_UNCONFIGURE);
2475 			}
2476 			/* failed to configure the card */
2477 			cmn_err(CE_WARN, "pcihp (%s%d): failed to configure"
2478 			    " the card in the slot %s",
2479 			    ddi_driver_name(pcihp_p->dip),
2480 			    ddi_get_instance(pcihp_p->dip),
2481 			    slotinfop->name);
2482 			/* failed to configure; disconnect the slot */
2483 			if (hpc_nexus_disconnect(slotinfop->slot_hdl,
2484 			    NULL, 0) == HPC_SUCCESS) {
2485 				slotinfop->rstate = AP_RSTATE_DISCONNECTED;
2486 			}
2487 
2488 			/* tell HPC driver occupant configure Error */
2489 			(void) hpc_nexus_control(slotinfop->slot_hdl,
2490 			    HPC_CTRL_DEV_CONFIG_FAILURE, NULL);
2491 		} else {
2492 			/* record the occupant state as CONFIGURED */
2493 			slotinfop->ostate = AP_OSTATE_CONFIGURED;
2494 			slotinfop->condition = AP_COND_OK;
2495 
2496 			/* now, online all the devices in the AP */
2497 			ctrl.flags = PCIHP_CFG_CONTINUE;
2498 			ctrl.rv = NDI_SUCCESS;
2499 			ctrl.dip = NULL;
2500 			ctrl.pci_dev = pci_dev;
2501 			ctrl.op = PCIHP_ONLINE;
2502 				(void) pcihp_get_board_type(slotinfop);
2503 
2504 			ndi_devi_enter(pcihp_p->dip, &circular_count);
2505 			ddi_walk_devs(ddi_get_child(pcihp_p->dip),
2506 			    pcihp_configure, (void *)&ctrl);
2507 			ndi_devi_exit(pcihp_p->dip, circular_count);
2508 
2509 			if (ctrl.rv != NDI_SUCCESS) {
2510 				/*
2511 				 * one or more of the devices are not
2512 				 * ONLINE'd. How is this to be
2513 				 * reported?
2514 				 */
2515 				cmn_err(CE_WARN,
2516 				    "pcihp (%s%d): failed to attach one or"
2517 				    " more drivers for the card in"
2518 				    " the slot %s",
2519 				    ddi_driver_name(pcihp_p->dip),
2520 				    ddi_get_instance(pcihp_p->dip),
2521 				    slotinfop->name);
2522 			}
2523 
2524 			/* tell HPC driver that the occupant is configured */
2525 			(void) hpc_nexus_control(slotinfop->slot_hdl,
2526 			    HPC_CTRL_DEV_CONFIGURED, NULL);
2527 
2528 			cmn_err(CE_NOTE, "pcihp (%s%d): card is CONFIGURED"
2529 			    " in the slot %s (pci dev %x)",
2530 			    ddi_driver_name(pcihp_p->dip),
2531 			    ddi_get_instance(pcihp_p->dip),
2532 			    slotinfop->name, pci_dev);
2533 		}
2534 
2535 		break;
2536 
2537 	case HPC_EVENT_SLOT_UNCONFIGURE:
2538 		/*
2539 		 * Unconfigure the occupant in this slot.
2540 		 */
2541 		if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
2542 			/*
2543 			 * auto configuration is disabled. Tell someone
2544 			 * like RCM about this hotplug event?
2545 			 */
2546 			cmn_err(CE_NOTE, "pcihp (%s%d): SLOT_UNCONFIGURE event"
2547 			    " for pci dev %x (slot %s) ignored,"
2548 			    " Slot disabled for auto-configuration.",
2549 			    ddi_driver_name(pcihp_p->dip),
2550 			    ddi_get_instance(pcihp_p->dip), pci_dev,
2551 			    slotinfop->name);
2552 
2553 			/* +++ HOOK for RCM to report this hotplug event? +++ */
2554 
2555 			break;
2556 		}
2557 
2558 		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED) {
2559 			cmn_err(CE_WARN, "pcihp (%s%d): SLOT_UNCONFIGURE "
2560 			    "event re-occurred for pci dev %x (slot %s),",
2561 			    ddi_driver_name(pcihp_p->dip),
2562 			    ddi_get_instance(pcihp_p->dip), pci_dev,
2563 			    slotinfop->name);
2564 			mutex_exit(&slotinfop->slot_mutex);
2565 
2566 			(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT,
2567 			    &rval);
2568 
2569 			return (EAGAIN);
2570 		}
2571 		/*
2572 		 * If the occupant is in the CONFIGURED state then
2573 		 * call the configurator to unconfigure the slot.
2574 		 */
2575 		if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
2576 			/*
2577 			 * Detach all the drivers for the devices in the
2578 			 * slot. Call pcihp_configure() to offline the
2579 			 * devices.
2580 			 */
2581 			ctrl.flags = 0;
2582 			ctrl.rv = NDI_SUCCESS;
2583 			ctrl.dip = NULL;
2584 			ctrl.pci_dev = pci_dev;
2585 			ctrl.op = PCIHP_OFFLINE;
2586 
2587 			(void) devfs_clean(pcihp_p->dip, NULL, DV_CLEAN_FORCE);
2588 			ndi_devi_enter(pcihp_p->dip, &circular_count);
2589 			ddi_walk_devs(ddi_get_child(pcihp_p->dip),
2590 			    pcihp_configure, (void *)&ctrl);
2591 			ndi_devi_exit(pcihp_p->dip, circular_count);
2592 
2593 			if (ctrl.rv != NDI_SUCCESS) {
2594 				/*
2595 				 * Failed to detach one or more drivers.
2596 				 * Restore the status for the drivers
2597 				 * which are offlined during this step.
2598 				 */
2599 				ctrl.flags = PCIHP_CFG_CONTINUE;
2600 				ctrl.rv = NDI_SUCCESS;
2601 				ctrl.dip = NULL;
2602 				ctrl.pci_dev = pci_dev;
2603 				ctrl.op = PCIHP_ONLINE;
2604 
2605 				ndi_devi_enter(pcihp_p->dip, &circular_count);
2606 				ddi_walk_devs(ddi_get_child(pcihp_p->dip),
2607 				    pcihp_configure, (void *)&ctrl);
2608 				ndi_devi_exit(pcihp_p->dip, circular_count);
2609 				rv = HPC_ERR_FAILED;
2610 			} else {
2611 				(void) hpc_nexus_control(slotinfop->slot_hdl,
2612 				    HPC_CTRL_DEV_UNCONFIG_START, NULL);
2613 
2614 				if (pcicfg_unconfigure(pcihp_p->dip, pci_dev,
2615 				    PCICFG_ALL_FUNC, 0) == PCICFG_SUCCESS) {
2616 
2617 				/* Resources freed. Turn LED on. Clear EXT. */
2618 				if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2619 					if (pcihp_cpci_blue_led)
2620 						pcihp_hs_csr_op(pcihp_p,
2621 						    pci_dev,
2622 						    HPC_EVENT_SLOT_BLUE_LED_ON);
2623 					pcihp_hs_csr_op(pcihp_p, pci_dev,
2624 					    HPC_EVENT_SLOT_UNCONFIGURE);
2625 					slotinfop->hs_csr_location = 0;
2626 					slotinfop->slot_flags &=
2627 					    ~PCIHP_SLOT_DEV_NON_HOTPLUG;
2628 				}
2629 					slotinfop->ostate =
2630 					    AP_OSTATE_UNCONFIGURED;
2631 					slotinfop->condition = AP_COND_UNKNOWN;
2632 					/*
2633 					 * send the notification of state change
2634 					 * to the HPC driver.
2635 					 */
2636 					(void) hpc_nexus_control(
2637 					    slotinfop->slot_hdl,
2638 					    HPC_CTRL_DEV_UNCONFIGURED, NULL);
2639 					/* disconnect the slot */
2640 					if (hpc_nexus_disconnect(
2641 					    slotinfop->slot_hdl,
2642 					    NULL, 0) == HPC_SUCCESS) {
2643 						slotinfop->rstate =
2644 						    AP_RSTATE_DISCONNECTED;
2645 					}
2646 
2647 					cmn_err(CE_NOTE,
2648 					    "pcihp (%s%d): card is UNCONFIGURED"
2649 					    " in the slot %s (pci dev %x)",
2650 					    ddi_driver_name(pcihp_p->dip),
2651 					    ddi_get_instance(pcihp_p->dip),
2652 					    slotinfop->name, pci_dev);
2653 				} else {
2654 					/* tell HPC driver occupant is Busy */
2655 					(void) hpc_nexus_control(
2656 					    slotinfop->slot_hdl,
2657 					    HPC_CTRL_DEV_UNCONFIG_FAILURE,
2658 					    NULL);
2659 
2660 					rv = HPC_ERR_FAILED;
2661 				}
2662 			}
2663 		}
2664 
2665 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2666 
2667 		break;
2668 
2669 	case HPC_EVENT_SLOT_REMOVAL:
2670 		/*
2671 		 * Card is removed from the slot. The card must have been
2672 		 * unconfigured before this event.
2673 		 */
2674 		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
2675 			slotinfop->condition = AP_COND_FAILED;
2676 			cmn_err(CE_WARN, "pcihp (%s%d): card is removed"
2677 			    " from the slot %s",
2678 			    ddi_driver_name(pcihp_p->dip),
2679 			    ddi_get_instance(pcihp_p->dip),
2680 			    slotinfop->name);
2681 		} else {
2682 			slotinfop->condition = AP_COND_UNKNOWN;
2683 			cmn_err(CE_NOTE, "pcihp (%s%d): card is removed"
2684 			    " from the slot %s",
2685 			    ddi_driver_name(pcihp_p->dip),
2686 			    ddi_get_instance(pcihp_p->dip),
2687 			    slotinfop->name);
2688 		}
2689 
2690 		slotinfop->rstate = AP_RSTATE_EMPTY;
2691 
2692 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2693 
2694 		break;
2695 
2696 	case HPC_EVENT_SLOT_POWER_ON:
2697 		/*
2698 		 * Slot is connected to the bus. i.e the card is powered
2699 		 * on. Are there any error conditions to be checked?
2700 		 */
2701 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): card is powered"
2702 		    " on in the slot %s",
2703 		    ddi_driver_name(pcihp_p->dip),
2704 		    ddi_get_instance(pcihp_p->dip),
2705 		    slotinfop->name));
2706 
2707 		slotinfop->rstate = AP_RSTATE_CONNECTED; /* record rstate */
2708 
2709 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2710 
2711 		break;
2712 
2713 	case HPC_EVENT_SLOT_POWER_OFF:
2714 		/*
2715 		 * Slot is disconnected from the bus. i.e the card is powered
2716 		 * off. Are there any error conditions to be checked?
2717 		 */
2718 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): card is powered"
2719 		    " off in the slot %s",
2720 		    ddi_driver_name(pcihp_p->dip),
2721 		    ddi_get_instance(pcihp_p->dip),
2722 		    slotinfop->name));
2723 
2724 		slotinfop->rstate = AP_RSTATE_DISCONNECTED; /* record rstate */
2725 
2726 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2727 
2728 		break;
2729 
2730 	case HPC_EVENT_SLOT_LATCH_SHUT:
2731 		/*
2732 		 * Latch on the slot is closed.
2733 		 */
2734 		cmn_err(CE_NOTE, "pcihp (%s%d): latch is shut for the slot %s",
2735 		    ddi_driver_name(pcihp_p->dip),
2736 		    ddi_get_instance(pcihp_p->dip),
2737 		    slotinfop->name);
2738 
2739 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2740 
2741 		break;
2742 
2743 	case HPC_EVENT_SLOT_LATCH_OPEN:
2744 		/*
2745 		 * Latch on the slot is open.
2746 		 */
2747 		cmn_err(CE_NOTE, "pcihp (%s%d): latch is open for the slot %s",
2748 		    ddi_driver_name(pcihp_p->dip),
2749 		    ddi_get_instance(pcihp_p->dip),
2750 		    slotinfop->name);
2751 
2752 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2753 
2754 		break;
2755 
2756 	case HPC_EVENT_PROCESS_ENUM:
2757 		/*
2758 		 * HSC knows the device number of the slot where the
2759 		 * ENUM# was triggered.
2760 		 * Now finish the necessary actions to be taken on that
2761 		 * slot. Please note that the interrupt is already cleared.
2762 		 * This is the second(last) part of the ENUM# event processing.
2763 		 */
2764 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): processing ENUM#"
2765 		    " for slot %s",
2766 		    ddi_driver_name(pcihp_p->dip),
2767 		    ddi_get_instance(pcihp_p->dip),
2768 		    slotinfop->name));
2769 
2770 		mutex_exit(&slotinfop->slot_mutex);
2771 		rv = pcihp_enum_slot(pcihp_p, slotinfop, pci_dev,
2772 		    PCIHP_HANDLE_ENUM, KM_SLEEP);
2773 		mutex_enter(&slotinfop->slot_mutex);
2774 
2775 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2776 
2777 		break;
2778 
2779 	case HPC_EVENT_BUS_ENUM:
2780 		/*
2781 		 * Same as HPC_EVENT_SLOT_ENUM as defined the PSARC doc.
2782 		 * This term is used for better clarity of its usage.
2783 		 *
2784 		 * ENUM signal occurred on the bus. It may be from this
2785 		 * slot or any other hotplug slot on the bus.
2786 		 *
2787 		 * It is NOT recommended that the hotswap controller uses
2788 		 * event without queuing as NDI and other DDI calls may not
2789 		 * necessarily be invokable in interrupt context.
2790 		 * Hence the hotswap controller driver should use the
2791 		 * CLEAR_ENUM event which returns the slot device number
2792 		 * and then call HPC_EVENT_PROCESS_ENUM event with queuing.
2793 		 *
2794 		 * This can be used when the hotswap controller is
2795 		 * implementing a polled event mechanism to do the
2796 		 * necessary actions in a single call.
2797 		 */
2798 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): ENUM# is generated"
2799 		    " on the bus (for slot %s ?)",
2800 		    ddi_driver_name(pcihp_p->dip),
2801 		    ddi_get_instance(pcihp_p->dip),
2802 		    slotinfop->name));
2803 
2804 		mutex_exit(&slotinfop->slot_mutex);
2805 		rv = pcihp_handle_enum(pcihp_p, pci_dev, PCIHP_HANDLE_ENUM,
2806 		    KM_SLEEP);
2807 		mutex_enter(&slotinfop->slot_mutex);
2808 
2809 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2810 
2811 		break;
2812 
2813 	case HPC_EVENT_SLOT_BLUE_LED_ON:
2814 
2815 		/*
2816 		 * Request to turn Hot Swap Blue LED on.
2817 		 */
2818 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): Request To Turn On Blue "
2819 		    "LED on the bus (for slot %s ?)",
2820 		    ddi_driver_name(pcihp_p->dip),
2821 		    ddi_get_instance(pcihp_p->dip),
2822 		    slotinfop->name));
2823 
2824 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_BLUE_LED_ON);
2825 		break;
2826 
2827 	case HPC_EVENT_DISABLE_ENUM:
2828 		/*
2829 		 * Disable ENUM# which disables auto configuration on this slot
2830 		 */
2831 		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2832 			pcihp_hs_csr_op(pcihp_p, pci_dev,
2833 			    HPC_EVENT_DISABLE_ENUM);
2834 			slotinfop->slot_flags &= ~PCIHP_SLOT_AUTO_CFG_EN;
2835 		}
2836 		break;
2837 
2838 	case HPC_EVENT_ENABLE_ENUM:
2839 		/*
2840 		 * Enable ENUM# which enables auto configuration on this slot.
2841 		 */
2842 		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
2843 			pcihp_hs_csr_op(pcihp_p, pci_dev,
2844 			    HPC_EVENT_ENABLE_ENUM);
2845 			slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
2846 		}
2847 		break;
2848 
2849 	case HPC_EVENT_SLOT_BLUE_LED_OFF:
2850 
2851 		/*
2852 		 * Request to turn Hot Swap Blue LED off.
2853 		 */
2854 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): Request To Turn Off Blue "
2855 		    "LED on the bus (for slot %s ?)",
2856 		    ddi_driver_name(pcihp_p->dip),
2857 		    ddi_get_instance(pcihp_p->dip),
2858 		    slotinfop->name));
2859 
2860 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_BLUE_LED_OFF);
2861 
2862 		break;
2863 
2864 	case HPC_EVENT_SLOT_NOT_HEALTHY:
2865 		/*
2866 		 * HEALTHY# signal on this slot is not OK.
2867 		 */
2868 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): HEALTHY# signal is not OK"
2869 		    " for this slot %s",
2870 		    ddi_driver_name(pcihp_p->dip),
2871 		    ddi_get_instance(pcihp_p->dip),
2872 		    slotinfop->name));
2873 
2874 		/* record the state in slot_flags field */
2875 		slotinfop->slot_flags |= PCIHP_SLOT_NOT_HEALTHY;
2876 		slotinfop->condition = AP_COND_FAILED;
2877 
2878 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2879 
2880 		break;
2881 
2882 	case HPC_EVENT_SLOT_HEALTHY_OK:
2883 		/*
2884 		 * HEALTHY# signal on this slot is OK now.
2885 		 */
2886 		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): HEALTHY# signal is OK now"
2887 		    " for this slot %s",
2888 		    ddi_driver_name(pcihp_p->dip),
2889 		    ddi_get_instance(pcihp_p->dip),
2890 		    slotinfop->name));
2891 
2892 		/* update the state in slot_flags field */
2893 		slotinfop->slot_flags &= ~PCIHP_SLOT_NOT_HEALTHY;
2894 		slotinfop->condition = AP_COND_OK;
2895 
2896 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2897 
2898 		break;
2899 
2900 	case HPC_EVENT_SLOT_ATTN:
2901 		/*
2902 		 * Attention button is pressed.
2903 		 */
2904 		if (((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) ||
2905 		    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
2906 			/*
2907 			 * either auto-conifiguration or the slot is disabled,
2908 			 * ignore this event.
2909 			 */
2910 			break;
2911 		}
2912 
2913 		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED)
2914 			hint = SE_INCOMING_RES;
2915 		else
2916 			hint = SE_OUTGOING_RES;
2917 
2918 		if (ddi_getprop(DDI_DEV_T_ANY, pcihp_p->dip, DDI_PROP_DONTPASS,
2919 		    "inkernel-autoconfig", 0) == 0) {
2920 			pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_REQ, hint,
2921 			    pcihp_p->dip, KM_SLEEP);
2922 			break;
2923 		}
2924 
2925 		if ((slotinfop->ostate == AP_OSTATE_UNCONFIGURED) &&
2926 		    (slotinfop->rstate != AP_RSTATE_EMPTY) &&
2927 		    (slotinfop->condition != AP_COND_FAILED)) {
2928 			if (slotinfop->rstate == AP_RSTATE_DISCONNECTED) {
2929 				rv = hpc_nexus_connect(slotinfop->slot_hdl,
2930 				    NULL, 0);
2931 				if (rv == HPC_SUCCESS)
2932 					slotinfop->rstate = AP_RSTATE_CONNECTED;
2933 				else
2934 					break;
2935 			}
2936 
2937 			rv = pcihp_configure_ap(pcihp_p, pci_dev);
2938 
2939 		} else if ((slotinfop->ostate == AP_OSTATE_CONFIGURED) &&
2940 		    (slotinfop->rstate == AP_RSTATE_CONNECTED) &&
2941 		    (slotinfop->condition != AP_COND_FAILED)) {
2942 			rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);
2943 
2944 			if (rv != HPC_SUCCESS)
2945 				break;
2946 
2947 			rv = hpc_nexus_disconnect(slotinfop->slot_hdl,
2948 			    NULL, 0);
2949 			if (rv == HPC_SUCCESS)
2950 				slotinfop->rstate = AP_RSTATE_DISCONNECTED;
2951 		}
2952 
2953 		break;
2954 
2955 	case HPC_EVENT_SLOT_POWER_FAULT:
2956 		/*
2957 		 * Power fault is detected.
2958 		 */
2959 		cmn_err(CE_NOTE, "pcihp (%s%d): power-fault"
2960 		    " for this slot %s",
2961 		    ddi_driver_name(pcihp_p->dip),
2962 		    ddi_get_instance(pcihp_p->dip),
2963 		    slotinfop->name);
2964 
2965 		/* turn on ATTN led */
2966 		led_info.led = HPC_ATTN_LED;
2967 		led_info.state = HPC_LED_ON;
2968 		rv = hpc_nexus_control(slotinfop->slot_hdl,
2969 		    HPC_CTRL_SET_LED_STATE, (caddr_t)&led_info);
2970 
2971 		if (slotinfop->rstate == AP_RSTATE_CONNECTED)
2972 			(void) hpc_nexus_disconnect(slotinfop->slot_hdl,
2973 			    NULL, 0);
2974 
2975 		slotinfop->condition = AP_COND_FAILED;
2976 
2977 		pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_AP_STATE_CHANGE,
2978 		    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);
2979 
2980 		break;
2981 
2982 	default:
2983 		cmn_err(CE_NOTE, "pcihp (%s%d): unknown event %x"
2984 		    " for this slot %s",
2985 		    ddi_driver_name(pcihp_p->dip),
2986 		    ddi_get_instance(pcihp_p->dip), event_mask,
2987 		    slotinfop->name);
2988 
2989 		/* +++ HOOK for RCM to report this hotplug event? +++ */
2990 
2991 		break;
2992 	}
2993 
2994 	mutex_exit(&slotinfop->slot_mutex);
2995 
2996 	(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT, &rval);
2997 
2998 	return (rv);
2999 }
3000 
3001 /*
3002  * This function is called to online or offline the devices for an
3003  * attachment point. If the PCI device number of the node matches
3004  * with the device number of the specified hot plug slot then
3005  * the operation is performed.
3006  */
3007 static int
3008 pcihp_configure(dev_info_t *dip, void *hdl)
3009 {
3010 	int pci_dev;
3011 	struct pcihp_config_ctrl *ctrl = (struct pcihp_config_ctrl *)hdl;
3012 	int rv;
3013 	pci_regspec_t *pci_rp;
3014 	int length;
3015 
3016 	/*
3017 	 * Get the PCI device number information from the devinfo
3018 	 * node. Since the node may not have the address field
3019 	 * setup (this is done in the DDI_INITCHILD of the parent)
3020 	 * we look up the 'reg' property to decode that information.
3021 	 */
3022 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
3023 	    "reg", (int **)&pci_rp, (uint_t *)&length) != DDI_PROP_SUCCESS) {
3024 		ctrl->rv = DDI_FAILURE;
3025 		ctrl->dip = dip;
3026 		return (DDI_WALK_TERMINATE);
3027 	}
3028 
3029 	/* get the pci device id information */
3030 	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
3031 
3032 	/*
3033 	 * free the memory allocated by ddi_prop_lookup_int_array
3034 	 */
3035 	ddi_prop_free(pci_rp);
3036 
3037 	/*
3038 	 * Match the node for the device number of the slot.
3039 	 */
3040 	if (pci_dev == ctrl->pci_dev) {	/* node is a match */
3041 		if (ctrl->op == PCIHP_ONLINE) {
3042 			/* it is CONFIGURE operation */
3043 
3044 			/* skip this device if it is disabled or faulty */
3045 			if (pcihp_check_status(dip) == B_FALSE) {
3046 				return (DDI_WALK_PRUNECHILD);
3047 			}
3048 
3049 			rv = ndi_devi_online(dip, NDI_ONLINE_ATTACH|NDI_CONFIG);
3050 		} else {
3051 			/*
3052 			 * it is UNCONFIGURE operation.
3053 			 */
3054 			rv = ndi_devi_offline(dip, NDI_UNCONFIG);
3055 		}
3056 		if (rv != NDI_SUCCESS) {
3057 			/* failed to attach/detach the driver(s) */
3058 			ctrl->rv = rv;
3059 			ctrl->dip = dip;
3060 			/* terminate the search if specified */
3061 			if (!(ctrl->flags & PCIHP_CFG_CONTINUE))
3062 				return (DDI_WALK_TERMINATE);
3063 		}
3064 	}
3065 
3066 	/*
3067 	 * continue the walk to the next sibling to look for a match
3068 	 * or to find other nodes if this card is a multi-function card.
3069 	 */
3070 	return (DDI_WALK_PRUNECHILD);
3071 }
3072 
3073 /*
3074  * Check the device for a 'status' property.  A conforming device
3075  * should have a status of "okay", "disabled", "fail", or "fail-xxx".
3076  *
3077  * Return FALSE for a conforming device that is disabled or faulted.
3078  * Return TRUE in every other case.
3079  */
3080 static bool_t
3081 pcihp_check_status(dev_info_t *dip)
3082 {
3083 	char *status_prop;
3084 	bool_t rv = B_TRUE;
3085 
3086 	/* try to get the 'status' property */
3087 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
3088 	    "status", &status_prop) == DDI_PROP_SUCCESS) {
3089 
3090 		/*
3091 		 * test if the status is "disabled", "fail", or
3092 		 * "fail-xxx".
3093 		 */
3094 		if (strcmp(status_prop, "disabled") == 0) {
3095 			rv = B_FALSE;
3096 			PCIHP_DEBUG((CE_NOTE,
3097 			    "pcihp (%s%d): device is in disabled state",
3098 			    ddi_driver_name(dip), ddi_get_instance(dip)));
3099 		} else if (strncmp(status_prop, "fail", 4) == 0) {
3100 			rv = B_FALSE;
3101 			cmn_err(CE_WARN,
3102 			    "pcihp (%s%d): device is in fault state (%s)",
3103 			    ddi_driver_name(dip), ddi_get_instance(dip),
3104 			    status_prop);
3105 		}
3106 
3107 		ddi_prop_free(status_prop);
3108 	}
3109 
3110 	return (rv);
3111 }
3112 
3113 /* control structure used to find a device in the devinfo tree */
3114 struct pcihp_find_ctrl {
3115 	uint_t		device;
3116 	uint_t		function;
3117 	dev_info_t	*dip;
3118 };
3119 
3120 static dev_info_t *
3121 pcihp_devi_find(dev_info_t *dip, uint_t device, uint_t function)
3122 {
3123 	struct pcihp_find_ctrl ctrl;
3124 	int circular_count;
3125 
3126 	ctrl.device = device;
3127 	ctrl.function = function;
3128 	ctrl.dip = NULL;
3129 
3130 	ndi_devi_enter(dip, &circular_count);
3131 	ddi_walk_devs(ddi_get_child(dip), pcihp_match_dev, (void *)&ctrl);
3132 	ndi_devi_exit(dip, circular_count);
3133 
3134 	return (ctrl.dip);
3135 }
3136 
3137 static int
3138 pcihp_match_dev(dev_info_t *dip, void *hdl)
3139 {
3140 	struct pcihp_find_ctrl *ctrl = (struct pcihp_find_ctrl *)hdl;
3141 	pci_regspec_t *pci_rp;
3142 	int length;
3143 	int pci_dev;
3144 	int pci_func;
3145 
3146 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
3147 	    "reg", (int **)&pci_rp, (uint_t *)&length) != DDI_PROP_SUCCESS) {
3148 		ctrl->dip = NULL;
3149 		return (DDI_WALK_TERMINATE);
3150 	}
3151 
3152 	/* get the PCI device address info */
3153 	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
3154 	pci_func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
3155 
3156 	/*
3157 	 * free the memory allocated by ddi_prop_lookup_int_array
3158 	 */
3159 	ddi_prop_free(pci_rp);
3160 
3161 
3162 	if ((pci_dev == ctrl->device) && (pci_func == ctrl->function)) {
3163 		/* found the match for the specified device address */
3164 		ctrl->dip = dip;
3165 		return (DDI_WALK_TERMINATE);
3166 	}
3167 
3168 	/*
3169 	 * continue the walk to the next sibling to look for a match.
3170 	 */
3171 	return (DDI_WALK_PRUNECHILD);
3172 }
3173 
3174 #if 0
3175 /*
3176  * Probe the configuration space of the slot to determine the receptacle
3177  * state. There may not be any devinfo tree created for this slot.
3178  */
3179 static void
3180 pcihp_probe_slot_state(dev_info_t *dip, int dev, hpc_slot_state_t *rstatep)
3181 {
3182 	/* XXX FIX IT */
3183 }
3184 #endif
3185 
3186 /*
3187  * This routine is called when a ENUM# assertion is detected for a bus.
3188  * Since ENUM# may be bussed, the slot that asserted ENUM# may not be known.
3189  * The HPC Driver passes the handle of a slot that is its best guess.
3190  * If the best guess slot is the one that asserted ENUM#, the proper handling
3191  * will be done.  If its not, all possible slots will be locked at until
3192  * one that is asserting ENUM is found.
3193  * Also, indicate to the HSC to turn on ENUM# after it is serviced,
3194  * incase if it was disabled by the HSC due to the nature of asynchronous
3195  * delivery of interrupt by the framework.
3196  *
3197  * opcode has the following meanings.
3198  * PCIHP_CLEAR_ENUM = just clear interrupt and return the PCI device no. if
3199  *			success, else return -1.
3200  * PCIHP_HANDLE_ENUM = clear interrupt and handle interrupt also.
3201  *
3202  */
3203 static int
3204 pcihp_handle_enum(pcihp_t *pcihp_p, int favorite_pci_dev, int opcode,
3205 	int kmflag)
3206 {
3207 	struct pcihp_slotinfo *slotinfop;
3208 	int pci_dev, rc, event_serviced = 0;
3209 
3210 	/*
3211 	 * Handle ENUM# condition for the "favorite" slot first.
3212 	 */
3213 	slotinfop = &pcihp_p->slotinfo[favorite_pci_dev];
3214 	if (slotinfop) {
3215 		/*
3216 		 * First try the "favorite" pci device.  This is the device
3217 		 * associated with the handle passed by the HPC Driver.
3218 		 */
3219 		rc = pcihp_enum_slot(pcihp_p, slotinfop, favorite_pci_dev,
3220 		    opcode, kmflag);
3221 		if (rc != HPC_EVENT_UNCLAIMED) {	/* indicates success */
3222 			event_serviced = 1;
3223 			/* This MUST be a non-DEBUG feature. */
3224 			if (! pcihp_enum_scan_all) {
3225 				return (rc);
3226 			}
3227 		}
3228 	}
3229 
3230 	/*
3231 	 * If ENUM# is implemented as a radial signal, then there is no
3232 	 * need to further poll the slots.
3233 	 */
3234 	if (pcihp_p->bus_flags & PCIHP_BUS_ENUM_RADIAL)
3235 		goto enum_service_check;
3236 
3237 	/*
3238 	 * If the "favorite" pci device didn't assert ENUM#, then
3239 	 * try the rest.  Once we find and handle a device that asserted
3240 	 * ENUM#, then we will terminate the walk by returning unless
3241 	 * scan-all flag is set.
3242 	 */
3243 	for (pci_dev = 0; pci_dev < PCI_MAX_DEVS; pci_dev++) {
3244 		if (pci_dev != favorite_pci_dev) {
3245 			slotinfop = &pcihp_p->slotinfo[pci_dev];
3246 			if (slotinfop == NULL) {
3247 				continue;
3248 			}
3249 			/* Only CPCI devices support ENUM# generation. */
3250 			if (!(slotinfop->slot_type & HPC_SLOT_TYPE_CPCI))
3251 				continue;
3252 			rc = pcihp_enum_slot(pcihp_p, slotinfop, pci_dev,
3253 			    opcode, kmflag);
3254 			if (rc != HPC_EVENT_UNCLAIMED) {
3255 				event_serviced = 1;
3256 				/* This MUST be a non-DEBUG feature. */
3257 				if (! pcihp_enum_scan_all)
3258 					break;
3259 			}
3260 		}
3261 	}
3262 
3263 enum_service_check:
3264 	if (event_serviced) {
3265 		return (rc);
3266 	}
3267 
3268 	/* No ENUM# event found, Return */
3269 	return (HPC_EVENT_UNCLAIMED);
3270 }
3271 
3272 /*
3273  * This routine attempts to handle a possible ENUM# assertion case for a
3274  * specified slot.  This only works for adapters that implement Hot Swap
3275  * Friendly Silicon.  If the slot's HS_CSR is read and it specifies ENUM#
3276  * has been asserted, either the insertion or removal handlers will be
3277  * called.
3278  */
3279 static int
3280 pcihp_enum_slot(pcihp_t *pcihp_p, struct pcihp_slotinfo *slotinfop, int pci_dev,
3281 		int opcode, int kmflag)
3282 {
3283 	ddi_acc_handle_t handle;
3284 	dev_info_t *dip, *new_child = NULL;
3285 	int result, rv = -1;
3286 	uint8_t hs_csr;
3287 
3288 	if (pcihp_config_setup(&dip, &handle, &new_child, pci_dev,
3289 	    pcihp_p) != DDI_SUCCESS) {
3290 		return (HPC_EVENT_UNCLAIMED);
3291 	}
3292 
3293 	/*
3294 	 * Read the device's HS_CSR.
3295 	 */
3296 	result = pcihp_get_hs_csr(slotinfop, handle, (uint8_t *)&hs_csr);
3297 	PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): hs_csr = %x, flags = %x",
3298 	    ddi_driver_name(pcihp_p->dip), ddi_get_instance(pcihp_p->dip),
3299 	    hs_csr, slotinfop->slot_flags));
3300 	/*
3301 	 * we teardown our device map here, because in case of an
3302 	 * extraction event, our nodes would be freed and a teardown
3303 	 * will cause problems.
3304 	 */
3305 	pcihp_config_teardown(&handle, &new_child, pci_dev, pcihp_p);
3306 
3307 	if (result == PCIHP_SUCCESS) {
3308 
3309 		/* If ENUM# is masked, then it is not us. Some other device */
3310 		if ((hs_csr & HS_CSR_EIM) && (opcode == PCIHP_CLEAR_ENUM))
3311 			return (HPC_EVENT_UNCLAIMED);
3312 		/*
3313 		 * This device supports Full Hot Swap and implements
3314 		 * the Hot Swap Control and Status Register.
3315 		 */
3316 		if ((hs_csr & HS_CSR_INS) ||
3317 		    (slotinfop->slot_flags & PCIHP_SLOT_ENUM_INS_PENDING)) {
3318 			/* handle insertion ENUM */
3319 			PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): "
3320 			    "Handle Insertion ENUM (INS) "
3321 			    "on the bus (for slot %s ?)",
3322 			    ddi_driver_name(pcihp_p->dip),
3323 			    ddi_get_instance(pcihp_p->dip),
3324 			    slotinfop->name));
3325 
3326 			/*
3327 			 * generate sysevent
3328 			 */
3329 
3330 			if (opcode == PCIHP_CLEAR_ENUM)
3331 				pcihp_gen_sysevent(slotinfop->name,
3332 				    PCIHP_DR_REQ,
3333 				    SE_INCOMING_RES, pcihp_p->dip,
3334 				    kmflag);
3335 
3336 			rv = pcihp_handle_enum_insertion(pcihp_p, pci_dev,
3337 			    opcode, kmflag);
3338 
3339 		} else if ((hs_csr & HS_CSR_EXT) ||
3340 		    (slotinfop->slot_flags & PCIHP_SLOT_ENUM_EXT_PENDING)) {
3341 			/* handle extraction ENUM */
3342 			PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): "
3343 			    "Handle Extraction ENUM (EXT) "
3344 			    "on the bus (for slot %s ?)",
3345 			    ddi_driver_name(pcihp_p->dip),
3346 			    ddi_get_instance(pcihp_p->dip),
3347 			    slotinfop->name));
3348 
3349 			/*
3350 			 * generate sysevent
3351 			 */
3352 
3353 			if (opcode == PCIHP_CLEAR_ENUM)
3354 				pcihp_gen_sysevent(slotinfop->name,
3355 				    PCIHP_DR_REQ,
3356 				    SE_OUTGOING_RES,
3357 				    pcihp_p->dip,
3358 				    kmflag);
3359 
3360 			rv = pcihp_handle_enum_extraction(pcihp_p, pci_dev,
3361 			    opcode, kmflag);
3362 		}
3363 		if (opcode == PCIHP_CLEAR_ENUM) {
3364 			if (rv == PCIHP_SUCCESS)
3365 				rv = pci_dev;
3366 			else
3367 				rv = HPC_EVENT_UNCLAIMED;
3368 		}
3369 	}
3370 
3371 	return (rv);
3372 }
3373 
3374 /*
3375  * This routine is called when a ENUM# caused by lifting the lever
3376  * is detected.  If the occupant is configured, it will be unconfigured.
3377  * If the occupant is already unconfigured or is successfully unconfigured,
3378  * the blue LED on the adapter is illuminated which means its OK to remove.
3379  * Please note that the lock must be released before invoking the
3380  * generic AP unconfigure function.
3381  */
3382 static int
3383 pcihp_handle_enum_extraction(pcihp_t *pcihp_p, int pci_dev, int opcode,
3384 	int kmflag)
3385 {
3386 	struct pcihp_slotinfo *slotinfop;
3387 	int rv = PCIHP_FAILURE;
3388 
3389 	slotinfop = &pcihp_p->slotinfo[pci_dev];
3390 
3391 	/*
3392 	 * It was observed that, clearing the EXT bit turned the LED ON.
3393 	 * This is a BIG problem in case if the unconfigure operation
3394 	 * failed because the board was busy.
3395 	 * In order to avoid this confusing situation (LED ON but the board
3396 	 * is not unconfigured), we instead decided not to clear EXT but
3397 	 * disable further ENUM# from this slot. Disabling ENUM# clears
3398 	 * the interrupt.
3399 	 * Finally before returning we clear the interrupt and enable
3400 	 * ENUM# back again from this slot.
3401 	 */
3402 	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);
3403 	if (opcode == PCIHP_CLEAR_ENUM) {
3404 		slotinfop->slot_flags |= PCIHP_SLOT_ENUM_EXT_PENDING;
3405 		return (PCIHP_SUCCESS);
3406 	}
3407 
3408 	mutex_enter(&slotinfop->slot_mutex);
3409 	rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);
3410 	mutex_exit(&slotinfop->slot_mutex);
3411 	if (rv != HPC_SUCCESS && rv != EBUSY) {
3412 		cmn_err(CE_NOTE, "%s%d: PCI device %x Failed on Unconfigure",
3413 		    ddi_driver_name(pcihp_p->dip),
3414 		    ddi_get_instance(pcihp_p->dip), pci_dev);
3415 	}
3416 	if (rv == EBUSY)
3417 		cmn_err(CE_NOTE, "%s%d: PCI device %x Busy",
3418 		    ddi_driver_name(pcihp_p->dip),
3419 		    ddi_get_instance(pcihp_p->dip), pci_dev);
3420 	if (rv) {
3421 		if (pcihp_cpci_blue_led)
3422 			pcihp_hs_csr_op(pcihp_p, pci_dev,
3423 			    HPC_EVENT_SLOT_BLUE_LED_OFF);
3424 	}
3425 	/*
3426 	 * we must clear interrupt in case the unconfigure didn't do it
3427 	 * due to a duplicate interrupt. Extraction is success.
3428 	 */
3429 	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_UNCONFIGURE);
3430 
3431 	if (!rv) {
3432 		/*
3433 		 * Sys Event Notification.
3434 		 */
3435 		pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_AP_STATE_CHANGE,
3436 		    SE_HINT_REMOVE, pcihp_p->dip, kmflag);
3437 	}
3438 
3439 	/*
3440 	 * Enable interrupts back from this board.
3441 	 * This could potentially be problematic in case if the user is
3442 	 * quick enough to extract the board.
3443 	 * But we must do it just in case if the switch is closed again.
3444 	 */
3445 	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);
3446 	slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_EXT_PENDING;
3447 	return (rv);
3448 }
3449 
3450 /*
3451  * This routine is called when a ENUM# caused by when an adapter insertion
3452  * is detected.  If the occupant is successfully configured (i.e. PCI resources
3453  * successfully assigned, the blue LED is left off, otherwise if configuration
3454  * is not successful, the blue LED is illuminated.
3455  * Please note that the lock must be released before invoking the
3456  * generic AP configure function.
3457  */
3458 static int
3459 pcihp_handle_enum_insertion(pcihp_t *pcihp_p, int pci_dev, int opcode,
3460 	int kmflag)
3461 {
3462 	struct pcihp_slotinfo *slotinfop;
3463 	int rv = PCIHP_FAILURE;
3464 	minor_t ap_minor;
3465 	major_t ap_major;
3466 
3467 	slotinfop = &pcihp_p->slotinfo[pci_dev];
3468 	slotinfop->hs_csr_location = 0;
3469 	/* we clear the interrupt here. This is a must here. */
3470 	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_CONFIGURE);
3471 	/*
3472 	 * disable further interrupt from this board till it is
3473 	 * configured.
3474 	 */
3475 	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);
3476 	if (opcode == PCIHP_CLEAR_ENUM) {
3477 		slotinfop->slot_flags |= PCIHP_SLOT_ENUM_INS_PENDING;
3478 		return (PCIHP_SUCCESS);
3479 	}
3480 
3481 	if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) ==
3482 	    PCIHP_SLOT_AUTO_CFG_EN) {
3483 		mutex_enter(&slotinfop->slot_mutex);
3484 		rv = pcihp_configure_ap(pcihp_p, pci_dev);
3485 		mutex_exit(&slotinfop->slot_mutex);
3486 		if (rv != HPC_SUCCESS) {	/* configure failed */
3487 			cmn_err(CE_NOTE, "%s%d: PCI device %x Failed on"
3488 			    " Configure", ddi_driver_name(pcihp_p->dip),
3489 			    ddi_get_instance(pcihp_p->dip), pci_dev);
3490 			if (pcihp_cpci_blue_led)
3491 				pcihp_hs_csr_op(pcihp_p, pci_dev,
3492 				    HPC_EVENT_SLOT_BLUE_LED_ON);
3493 		}
3494 
3495 		/* pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_CLEAR_ENUM); */
3496 		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);
3497 
3498 		if (!rv) {
3499 			ap_major = ddi_driver_major(pcihp_p->dip);
3500 			ap_minor = PCIHP_AP_MINOR_NUM(
3501 			    ddi_get_instance(pcihp_p->dip), pci_dev);
3502 			pcihp_create_occupant_props(pcihp_p->dip,
3503 			    makedevice(ap_major, ap_minor), pci_dev);
3504 
3505 			/*
3506 			 * Sys Event Notification.
3507 			 */
3508 			pcihp_gen_sysevent(slotinfop->name,
3509 			    PCIHP_DR_AP_STATE_CHANGE,
3510 			    SE_HINT_INSERT, pcihp_p->dip, kmflag);
3511 		}
3512 
3513 	} else
3514 		rv = PCIHP_SUCCESS;
3515 	slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_INS_PENDING;
3516 	return (rv);
3517 }
3518 
3519 /*
3520  * Read the Hot Swap Control and Status Register (HS_CSR) and
3521  * place the result in the location pointed to be hs_csr.
3522  */
3523 static int
3524 pcihp_get_hs_csr(struct pcihp_slotinfo *slotinfop,
3525     ddi_acc_handle_t config_handle, uint8_t *hs_csr)
3526 {
3527 	if (slotinfop->hs_csr_location == -1)
3528 		return (PCIHP_FAILURE);
3529 
3530 	if (slotinfop->hs_csr_location == 0) {
3531 		slotinfop->hs_csr_location =
3532 		    pcihp_get_hs_csr_location(config_handle);
3533 
3534 		if (slotinfop->hs_csr_location == -1)
3535 			return (PCIHP_FAILURE);
3536 	}
3537 	*hs_csr = pci_config_get8(config_handle, slotinfop->hs_csr_location);
3538 	return (PCIHP_SUCCESS);
3539 }
3540 
3541 /*
3542  * Write the Hot Swap Control and Status Register (HS_CSR) with
3543  * the value being pointed at by hs_csr.
3544  */
3545 static void
3546 pcihp_set_hs_csr(struct pcihp_slotinfo *slotinfop,
3547     ddi_acc_handle_t config_handle, uint8_t *hs_csr)
3548 {
3549 	if (slotinfop->hs_csr_location == -1)
3550 		return;
3551 	if (slotinfop->hs_csr_location == 0) {
3552 		slotinfop->hs_csr_location =
3553 		    pcihp_get_hs_csr_location(config_handle);
3554 		if (slotinfop->hs_csr_location == -1)
3555 			return;
3556 	}
3557 	pci_config_put8(config_handle, slotinfop->hs_csr_location, *hs_csr);
3558 	PCIHP_DEBUG((CE_NOTE, "hs_csr wrote %x, read %x", *hs_csr,
3559 	    pci_config_get8(config_handle, slotinfop->hs_csr_location)));
3560 }
3561 
3562 static int
3563 pcihp_get_hs_csr_location(ddi_acc_handle_t config_handle)
3564 {
3565 	uint8_t	cap_id;
3566 	uint_t	cap_id_loc;
3567 	uint16_t	status;
3568 	int location = -1;
3569 #define	PCI_STAT_ECP_SUPP	0x10
3570 
3571 	/*
3572 	 * Need to check the Status register for ECP support first.
3573 	 * Also please note that for type 1 devices, the
3574 	 * offset could change. Should support type 1 next.
3575 	 */
3576 	status = pci_config_get16(config_handle, PCI_CONF_STAT);
3577 	if (!(status & PCI_STAT_ECP_SUPP)) {
3578 		PCIHP_DEBUG((CE_NOTE, "No Ext Capabilities for device\n"));
3579 		return (-1);
3580 	}
3581 	cap_id_loc = pci_config_get8(config_handle, PCI_CONF_EXTCAP);
3582 
3583 	/*
3584 	 * Walk the list of capabilities, but don't walk past the end
3585 	 * of the Configuration Space Header.
3586 	 */
3587 	while ((cap_id_loc) && (cap_id_loc < PCI_CONF_HDR_SIZE)) {
3588 
3589 		cap_id = pci_config_get8(config_handle, cap_id_loc);
3590 
3591 		if (cap_id == CPCI_HOTSWAP_CAPID) {
3592 			location = cap_id_loc + PCI_ECP_HS_CSR;
3593 			break;
3594 		}
3595 		cap_id_loc = pci_config_get8(config_handle,
3596 		    cap_id_loc + 1);
3597 	}
3598 	return (location);
3599 }
3600 
3601 static int
3602 pcihp_add_dummy_reg_property(dev_info_t *dip,
3603     uint_t bus, uint_t device, uint_t func)
3604 {
3605 	pci_regspec_t dummy_reg;
3606 
3607 	bzero(&dummy_reg, sizeof (dummy_reg));
3608 
3609 	dummy_reg.pci_phys_hi = PCIHP_MAKE_REG_HIGH(bus, device, func, 0);
3610 
3611 	return (ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
3612 	    "reg", (int *)&dummy_reg, sizeof (pci_regspec_t)/sizeof (int)));
3613 }
3614 
3615 static void
3616 pcihp_hs_csr_op(pcihp_t *pcihp_p, int pci_dev, int event)
3617 {
3618 	struct pcihp_slotinfo *slotinfop;
3619 	ddi_acc_handle_t config_handle;
3620 	dev_info_t *dip, *new_child = NULL;
3621 	uint8_t hs_csr;
3622 	int result;
3623 
3624 	slotinfop = &pcihp_p->slotinfo[pci_dev];
3625 
3626 	if (pcihp_config_setup(&dip, &config_handle, &new_child, pci_dev,
3627 	    pcihp_p) != DDI_SUCCESS) {
3628 		return;
3629 	}
3630 
3631 	result = pcihp_get_hs_csr(slotinfop, config_handle, (uint8_t *)&hs_csr);
3632 	if ((result != PCIHP_SUCCESS) || (event == -1)) {
3633 		pcihp_config_teardown(&config_handle, &new_child, pci_dev,
3634 		    pcihp_p);
3635 		return;
3636 	}
3637 
3638 	hs_csr &= 0xf;
3639 	switch (event) {
3640 		case HPC_EVENT_SLOT_BLUE_LED_ON:
3641 			hs_csr |= HS_CSR_LOO;
3642 			break;
3643 		case HPC_EVENT_SLOT_BLUE_LED_OFF:
3644 			hs_csr &= ~HS_CSR_LOO;
3645 			break;
3646 		case HPC_EVENT_SLOT_CONFIGURE:
3647 			hs_csr |= HS_CSR_INS;	/* clear INS */
3648 			break;
3649 		case HPC_EVENT_CLEAR_ENUM:
3650 			hs_csr |= (HS_CSR_INS | HS_CSR_EXT);
3651 			break;
3652 		case HPC_EVENT_SLOT_UNCONFIGURE:
3653 			hs_csr |= HS_CSR_EXT;	/* clear EXT */
3654 			break;
3655 		case HPC_EVENT_ENABLE_ENUM:
3656 			hs_csr &= ~HS_CSR_EIM;
3657 			break;
3658 		case HPC_EVENT_DISABLE_ENUM:
3659 			hs_csr |= HS_CSR_EIM;
3660 			break;
3661 		case HPC_EVENT_SLOT_NOT_HEALTHY:
3662 		case HPC_EVENT_SLOT_HEALTHY_OK:
3663 		default:
3664 			break;
3665 	}
3666 	pcihp_set_hs_csr(slotinfop, config_handle, (uint8_t *)&hs_csr);
3667 	pcihp_config_teardown(&config_handle, &new_child, pci_dev, pcihp_p);
3668 }
3669 
3670 static int
3671 pcihp_config_setup(dev_info_t **dip, ddi_acc_handle_t *handle,
3672 			dev_info_t **new_child, int pci_dev, pcihp_t *pcihp_p)
3673 {
3674 	dev_info_t *pdip = pcihp_p->dip;
3675 	int bus, len, rc = DDI_SUCCESS;
3676 	struct pcihp_slotinfo *slotinfop;
3677 	hpc_slot_state_t rstate;
3678 	ddi_acc_hdl_t *hp;
3679 	pci_bus_range_t pci_bus_range;
3680 
3681 	slotinfop = &pcihp_p->slotinfo[pci_dev];
3682 
3683 	/*
3684 	 * If declared failed, don't allow Config operations.
3685 	 * Otherwise, if good or failing, it is assumed Ok
3686 	 * to get config data.
3687 	 */
3688 	if (slotinfop->condition == AP_COND_FAILED) {
3689 		return (PCIHP_FAILURE);
3690 	}
3691 	/*
3692 	 * check to see if there is a hardware present first.
3693 	 * If no hardware present, no need to probe this slot.
3694 	 * We can do this first probably as a first step towards
3695 	 * safeguarding from accidental removal (we don't support it!).
3696 	 */
3697 	if (hpc_nexus_control(slotinfop->slot_hdl, HPC_CTRL_GET_SLOT_STATE,
3698 	    (caddr_t)&rstate) != 0) {
3699 		return (DDI_FAILURE);
3700 	}
3701 
3702 	if (rstate != HPC_SLOT_CONNECTED) {
3703 		/* error. slot must be connected */
3704 		return (DDI_FAILURE);
3705 	}
3706 	*new_child = NULL;
3707 
3708 	/*
3709 	 * If there is no dip then we need to see if an
3710 	 * adapter has just been hot plugged.
3711 	 */
3712 	len = sizeof (pci_bus_range_t);
3713 	if (ddi_getlongprop_buf(DDI_DEV_T_ANY, pdip,
3714 	    0, "bus-range",
3715 	    (caddr_t)&pci_bus_range, &len) != DDI_SUCCESS) {
3716 
3717 		return (PCIHP_FAILURE);
3718 	}
3719 
3720 	/* primary bus number of this bus node */
3721 	bus = pci_bus_range.lo;
3722 
3723 	if (ndi_devi_alloc(pdip, DEVI_PSEUDO_NEXNAME,
3724 	    (pnode_t)DEVI_SID_NODEID, dip) != NDI_SUCCESS) {
3725 
3726 		PCIHP_DEBUG((CE_NOTE, "Failed to alloc probe node\n"));
3727 		return (PCIHP_FAILURE);
3728 	}
3729 
3730 	if (pcihp_add_dummy_reg_property(*dip, bus,
3731 	    pci_dev, 0) != DDI_SUCCESS) {
3732 
3733 		(void) ndi_devi_free(*dip);
3734 		return (PCIHP_FAILURE);
3735 	}
3736 
3737 	/*
3738 	 * Probe for a device. Possibly a non (c)PCI board could be sitting
3739 	 * here which would never respond to PCI config cycles - in which
3740 	 * case we return. Eventually a configure operation would fail.
3741 	 */
3742 	if (pci_config_setup(*dip, handle) != DDI_SUCCESS) {
3743 		cmn_err(CE_WARN, "Cannot set config space map for"
3744 		    " pci device number %d", pci_dev);
3745 		(void) ndi_devi_free(*dip);
3746 		return (PCIHP_FAILURE);
3747 	}
3748 
3749 	/*
3750 	 * See if there is any PCI HW at this location
3751 	 * by reading the Vendor ID.  If it returns with 0xffff
3752 	 * then there is no hardware at this location.
3753 	 */
3754 	if (pcihp_indirect_map(*dip) == DDI_SUCCESS) {
3755 		if (pci_config_get16(*handle, 0) == 0xffff) {
3756 			pci_config_teardown(handle);
3757 			(void) ndi_devi_free(*dip);
3758 			return (PCIHP_FAILURE);
3759 		}
3760 	} else {
3761 		/* Check if mapping is OK */
3762 		hp = impl_acc_hdl_get(*handle);
3763 
3764 		if (ddi_peek16(*dip, (int16_t *)(hp->ah_addr),
3765 		    (int16_t *)0) != DDI_SUCCESS) {
3766 #ifdef DEBUG
3767 			cmn_err(CE_WARN, "Cannot Map PCI config space for "
3768 			    "device number %d", pci_dev);
3769 #endif
3770 			pci_config_teardown(handle);
3771 			(void) ndi_devi_free(*dip);
3772 			return (PCIHP_FAILURE);
3773 		}
3774 	}
3775 
3776 	*new_child = *dip;
3777 	return (rc);
3778 
3779 }
3780 
3781 static void
3782 pcihp_config_teardown(ddi_acc_handle_t *handle,
3783 			dev_info_t **new_child, int pci_dev, pcihp_t *pcihp_p)
3784 {
3785 	struct pcihp_slotinfo *slotinfop = &pcihp_p->slotinfo[pci_dev];
3786 
3787 	pci_config_teardown(handle);
3788 	if (*new_child) {
3789 		(void) ndi_devi_free(*new_child);
3790 		/*
3791 		 * If occupant not configured, reset HS_CSR location
3792 		 * so that we reprobe. This covers cases where
3793 		 * the receptacle had a status change without a
3794 		 * notification to the framework.
3795 		 */
3796 		if (slotinfop->ostate != AP_OSTATE_CONFIGURED)
3797 			slotinfop->hs_csr_location = 0;
3798 	}
3799 }
3800 
3801 static int
3802 pcihp_get_board_type(struct pcihp_slotinfo *slotinfop)
3803 {
3804 	hpc_board_type_t board_type;
3805 
3806 	/*
3807 	 * Get board type data structure, hpc_board_type_t.
3808 	 */
3809 	if (hpc_nexus_control(slotinfop->slot_hdl, HPC_CTRL_GET_BOARD_TYPE,
3810 	    (caddr_t)&board_type) != 0) {
3811 
3812 		cmn_err(CE_WARN, "Cannot Get Board Type..");
3813 		return (-1);
3814 	}
3815 
3816 	/*
3817 	 * We expect the Hotswap Controller to tell us if the board is
3818 	 * a hotswap board or not, as it probably cannot differentiate
3819 	 * between a basic hotswap board, a non hotswap board and a
3820 	 * hotswap nonfriendly board.
3821 	 * So here is the logic to differentiate between the various
3822 	 * types of cPCI boards.
3823 	 * In case if the HSC returns board type as unknown, we assign
3824 	 * the default board type as defined by a configurable variable
3825 	 * for a BHS, nonfriendly FHS and non HS board.
3826 	 */
3827 	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
3828 		if (slotinfop->hs_csr_location > 0)
3829 			board_type = HPC_BOARD_CPCI_FULL_HS;
3830 		else {
3831 			if (board_type == HPC_BOARD_CPCI_HS) {
3832 				if (slotinfop->hs_csr_location == -1)
3833 					board_type = HPC_BOARD_CPCI_BASIC_HS;
3834 			}
3835 			if (board_type == HPC_BOARD_UNKNOWN) {
3836 				if (slotinfop->hs_csr_location == -1) {
3837 					board_type = pcihp_cpci_board_type;
3838 				} else if (slotinfop->hs_csr_location != 0) {
3839 					board_type = HPC_BOARD_CPCI_FULL_HS;
3840 				}
3841 			}
3842 		}
3843 		/*
3844 		 * If board type is a non hotswap board, then we must
3845 		 * deny a unconfigure operation. So set this flag.
3846 		 * Strictly speaking, there is no reason not to disallow
3847 		 * a unconfigure operation on nonhotswap boards. But this
3848 		 * is the only way we can prevent a user from accidentally
3849 		 * removing the board and damaging it.
3850 		 */
3851 		if (board_type == HPC_BOARD_CPCI_NON_HS)
3852 			slotinfop->slot_flags |= PCIHP_SLOT_DEV_NON_HOTPLUG;
3853 		else
3854 			slotinfop->slot_flags &= ~PCIHP_SLOT_DEV_NON_HOTPLUG;
3855 	}
3856 	return (board_type);
3857 }
3858 
3859 
3860 /*
3861  * Generate the System Event with a possible hint.
3862  */
3863 static void
3864 pcihp_gen_sysevent(char *slot_name, int event_sub_class, int hint,
3865 				dev_info_t *self, int kmflag)
3866 {
3867 
3868 	int err;
3869 	char *ev_subclass = NULL;
3870 	sysevent_id_t eid;
3871 	nvlist_t *ev_attr_list = NULL;
3872 	char attach_pnt[MAXPATHLEN];
3873 
3874 	/*
3875 	 * Minor device name (AP) will be bus path
3876 	 * concatenated with slot name
3877 	 */
3878 
3879 	(void) strcpy(attach_pnt, PCIHP_DEVICES_STR);
3880 	(void) ddi_pathname(self, attach_pnt + strlen(PCIHP_DEVICES_STR));
3881 	(void) strcat(attach_pnt, ":");
3882 	(void) strcat(attach_pnt, slot_name);
3883 	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, kmflag);
3884 	if (err != 0) {
3885 		cmn_err(CE_WARN,
3886 		    "%s%d: Failed to allocate memory "
3887 		    "for event attributes%s", ddi_driver_name(self),
3888 		    ddi_get_instance(self), ESC_DR_AP_STATE_CHANGE);
3889 		return;
3890 	}
3891 
3892 	switch (event_sub_class) {
3893 
3894 	/* event sub class: ESC_DR_AP_STATE_CHANGE */
3895 	case PCIHP_DR_AP_STATE_CHANGE:
3896 
3897 		ev_subclass = ESC_DR_AP_STATE_CHANGE;
3898 
3899 		switch (hint) {
3900 
3901 		case SE_NO_HINT:	/* fall through */
3902 		case SE_HINT_INSERT:	/* fall through */
3903 		case SE_HINT_REMOVE:
3904 
3905 
3906 			err = nvlist_add_string(ev_attr_list, DR_HINT,
3907 			    SE_HINT2STR(hint));
3908 
3909 			if (err != 0) {
3910 				cmn_err(CE_WARN, "%s%d: Failed to add attr [%s]"
3911 				    " for %s event", ddi_driver_name(self),
3912 				    ddi_get_instance(self),
3913 				    DR_HINT, ESC_DR_AP_STATE_CHANGE);
3914 				nvlist_free(ev_attr_list);
3915 				return;
3916 			}
3917 			break;
3918 
3919 		default:
3920 			cmn_err(CE_WARN, "%s%d: Unknown hint on sysevent",
3921 			    ddi_driver_name(self), ddi_get_instance(self));
3922 			nvlist_free(ev_attr_list);
3923 			return;
3924 		}
3925 
3926 		break;
3927 
3928 	/* event sub class: ESC_DR_REQ */
3929 	case PCIHP_DR_REQ:
3930 
3931 		ev_subclass = ESC_DR_REQ;
3932 
3933 		switch (hint) {
3934 
3935 		case SE_INVESTIGATE_RES:	/* fall through */
3936 		case SE_INCOMING_RES:	/* fall through */
3937 		case SE_OUTGOING_RES:	/* fall through */
3938 
3939 			err = nvlist_add_string(ev_attr_list, DR_REQ_TYPE,
3940 			    SE_REQ2STR(hint));
3941 
3942 			if (err != 0) {
3943 				cmn_err(CE_WARN,
3944 				    "%s%d: Failed to add attr [%s] "
3945 				    "for %s event", ddi_driver_name(self),
3946 				    ddi_get_instance(self),
3947 				    DR_REQ_TYPE, ESC_DR_REQ);
3948 				nvlist_free(ev_attr_list);
3949 				return;
3950 			}
3951 			break;
3952 
3953 		default:
3954 			cmn_err(CE_WARN, "%s%d:  Unknown hint on sysevent",
3955 			    ddi_driver_name(self), ddi_get_instance(self));
3956 			nvlist_free(ev_attr_list);
3957 			return;
3958 		}
3959 
3960 		break;
3961 
3962 	default:
3963 		cmn_err(CE_WARN, "%s%d:  Unknown Event subclass",
3964 		    ddi_driver_name(self), ddi_get_instance(self));
3965 		nvlist_free(ev_attr_list);
3966 		return;
3967 	}
3968 
3969 	/*
3970 	 * Add attachment point as attribute (common attribute)
3971 	 */
3972 
3973 	err = nvlist_add_string(ev_attr_list, DR_AP_ID, attach_pnt);
3974 
3975 	if (err != 0) {
3976 		cmn_err(CE_WARN, "%s%d: Failed to add attr [%s] for %s event",
3977 		    ddi_driver_name(self), ddi_get_instance(self),
3978 		    DR_AP_ID, EC_DR);
3979 		nvlist_free(ev_attr_list);
3980 		return;
3981 	}
3982 
3983 
3984 	/*
3985 	 * Log this event with sysevent framework.
3986 	 */
3987 
3988 	err = ddi_log_sysevent(self, DDI_VENDOR_SUNW, EC_DR,
3989 	    ev_subclass, ev_attr_list, &eid,
3990 	    ((kmflag == KM_SLEEP) ? DDI_SLEEP : DDI_NOSLEEP));
3991 	if (err != 0) {
3992 		cmn_err(CE_WARN, "%s%d: Failed to log %s event",
3993 		    ddi_driver_name(self), ddi_get_instance(self), EC_DR);
3994 	}
3995 
3996 	nvlist_free(ev_attr_list);
3997 }
3998 
3999 int
4000 pcihp_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
4001     int flags, char *name, caddr_t valuep, int *lengthp)
4002 {
4003 	int pci_dev;
4004 
4005 	if (dev == DDI_DEV_T_ANY)
4006 		goto skip;
4007 
4008 	if (strcmp(name, "pci-occupant") == 0) {
4009 		pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(dev));
4010 		pcihp_create_occupant_props(dip, dev, pci_dev);
4011 	}
4012 	/* other cases... */
4013 skip:
4014 	return (ddi_prop_op(dev, dip, prop_op, flags, name, valuep, lengthp));
4015 }
4016 
4017 /*
4018  * this function is called only for SPARC platforms, where we may have
4019  * a mix n' match of direct vs indirectly mapped configuration space.
4020  * On x86, this function should always return success since the configuration
4021  * space is always indirect mapped.
4022  */
4023 /*ARGSUSED*/
4024 static int
4025 pcihp_indirect_map(dev_info_t *dip)
4026 {
4027 #if defined(__sparc)
4028 	int rc = DDI_FAILURE;
4029 
4030 	if (ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(dip), 0,
4031 	    PCI_DEV_CONF_MAP_PROP, DDI_FAILURE) != DDI_FAILURE)
4032 		rc = DDI_SUCCESS;
4033 	else
4034 		if (ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(dip),
4035 		    0, PCI_BUS_CONF_MAP_PROP, DDI_FAILURE) != DDI_FAILURE)
4036 			rc = DDI_SUCCESS;
4037 	return (rc);
4038 #else
4039 	return (DDI_SUCCESS);
4040 #endif
4041 }
4042