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