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