cmd: remove sparc-only virtinfo

[unleashed.git] / usr / src / cmd / picl / plugins / sun4u / snowbird / frutree / piclscsi.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/* implementation specific to scsi nodes probing */

#include <stdio.h>
#include <unistd.h>
#include <syslog.h>
#include <stdlib.h>
#include <sys/param.h>
#include <config_admin.h>
#include <string.h>
#include <strings.h>
#include <picl.h>
#include <picltree.h>
#include <libintl.h>
#include <libdevinfo.h>
#include <sys/types.h>
#include <picldefs.h>
#include "piclfrutree.h"

#define SCSI_SLOT       "scsi-bus"
#define SCSI_LOC_FORMAT "t%dd0"
#define TARGET          "target"
#define CLASS           "class"
#define BUF_SIZE        256

#define SCSI_INITIATOR_ID       7
#define DRV_TYPE_DSK    1
#define DRV_TYPE_TAPE   2
#define NUM_DSK_TARGS   15
/*
 * No support for wide tapes for now.
 * If required wide support, set this to 8
 * See st.conf.
 */
#define NUM_TAPE_TARGS  7

#define DIRLINK_DSK     "dsk"
#define DIRLINK_RMT     "rmt"
#define DRV_SCSI_DSK    "sd"
#define DRV_SCSI_TAPE   "st"
#define NULL_ENTRY      0

/* currently supported directory strings for SCSI FRUs in cfgadm APs */
static char *scsi_dirlink_names[] = { DIRLINK_DSK, DIRLINK_RMT, NULL_ENTRY};
/* currently supported SCSI FRU drivers */
static struct scsi_drv_info {
        char *drv_name;
        uint8_t num_targets;
        uint8_t drv_type;
} scsi_drv[] = {
                DRV_SCSI_DSK, NUM_DSK_TARGS, DRV_TYPE_DSK,
                DRV_SCSI_TAPE, NUM_TAPE_TARGS, DRV_TYPE_TAPE,
                NULL_ENTRY,     NULL_ENTRY,     NULL_ENTRY
                };

/* the following defs are based on defines in scsi cfgadm plugin */
#define CDROM           "CD-ROM"
#define RMM             "tape"
#define DISK            "disk"

extern boolean_t is_location_present_in_subtree(frutree_frunode_t *,
        const char *, const char *);
extern picl_errno_t create_children(frutree_frunode_t *, char *, char *,
        int, char *, boolean_t);
extern char *strtok_r(char *s1, const char *s2, char **lasts);
extern boolean_t frutree_connects_initiated;
extern int frutree_debug;

typedef struct node {
        struct node *next;
        cfga_list_data_t *data;
} node_t;

typedef struct linked_list {
        node_t *first;
        int num_nodes;
} plist_t;

typedef struct scsi_info {
        frutree_frunode_t *frup;
        cfga_list_data_t *cfgalist;
        plist_t *list;
        int num_list;
        boolean_t compare_cfgadm;
        int geo_addr;
} scsi_info_t;

static plist_t *scsi_list = NULL;
static cfga_list_data_t *cfglist = NULL;
static int nlist = 0;

static void
free_list(plist_t *list)
{
        node_t  *tmp = NULL, *tmp1 = NULL;

        if (list == NULL)
                return;
        tmp = list->first;
        while (tmp != NULL) {
                free(tmp->data);
                tmp1 = tmp->next;
                free(tmp);
                tmp = tmp1;
        }
}

/*
 * This routine gets the list of scsi controllers present
 */
static cfga_err_t
populate_controllers_list(plist_t *cntrl_list, cfga_list_data_t *list, int num)
{
        int i;
        node_t *nodeptr = NULL;
        cfga_list_data_t *temp = NULL;

        if (cntrl_list == NULL || list == NULL) {
                return (CFGA_ATTR_INVAL);
        }

        cntrl_list->first = NULL;
        cntrl_list->num_nodes = 0;

        if (num == 0) {
                return (CFGA_OK);
        }

        for (i = 0; i < num; i++) {
                if (strcmp(list[i].ap_type, SCSI_SLOT) != 0) {
                        continue;
                }

                /* scsi controller */
                temp = (cfga_list_data_t *)malloc(sizeof (cfga_list_data_t));
                if (temp == NULL) {
                        return (CFGA_ERROR);
                }
                (void) memcpy(temp, &list[i], sizeof (cfga_list_data_t));

                nodeptr = (node_t *)malloc(sizeof (node_t));
                if (nodeptr == NULL) {
                        free(temp);
                        return (CFGA_ERROR);
                }
                nodeptr->data = temp;
                nodeptr->next = NULL;

                /* append to the list */
                if (cntrl_list->first == NULL) {
                        cntrl_list->first = nodeptr;
                        cntrl_list->num_nodes++;
                } else {
                        nodeptr->next = cntrl_list->first;
                        cntrl_list->first = nodeptr;
                        cntrl_list->num_nodes++;
                }
        }
        return (CFGA_OK);
}

picl_errno_t
scsi_info_init()
{
        cfga_err_t      ap_list_err;

        ap_list_err = config_list_ext(0, NULL, &cfglist, &nlist, NULL,
                NULL, NULL, CFGA_FLAG_LIST_ALL);

        if (ap_list_err != CFGA_OK) {
                if (ap_list_err == CFGA_NOTSUPP) {
                        return (PICL_SUCCESS);
                } else {
                        return (PICL_FAILURE);
                }
        }

        scsi_list = (plist_t *)malloc(sizeof (plist_t));
        if (scsi_list == NULL) {
                free(cfglist);
                return (PICL_NOSPACE);
        }

        ap_list_err = populate_controllers_list(scsi_list, cfglist, nlist);
        if (ap_list_err != CFGA_OK) {
                free(cfglist);
                free(scsi_list);
                return (PICL_FAILURE);
        }
        return (PICL_SUCCESS);
}

void
scsi_info_fini()
{
        free(cfglist);
        free_list(scsi_list);
        free(scsi_list);
}

/*
 * This routine searches the controllers list to find the mapping based
 * on given devfs_path.
 * caller should allocate memory for ap_id
 */
static picl_errno_t
find_scsi_controller(char *devfs_path, plist_t *list, char *ap_id)
{
        node_t  *tmp = NULL;
        char *lasts = NULL;
        char *token = NULL;
        char path[MAXPATHLEN];

        if (devfs_path == NULL || ap_id == NULL) {
                return (PICL_INVALIDARG);
        }
        (void) snprintf((char *)path, sizeof (path), "/devices%s", devfs_path);

        tmp = list->first;
        while (tmp != NULL) {
                lasts = tmp->data->ap_phys_id;
                token = (char *)strtok_r(lasts, (const char *)":",
                        (char **)&lasts);
                if (token == NULL) {
                        tmp = tmp->next;
                        continue;
                }

                if (strcmp(path, token) == 0) { /* match found */
                        (void) strncpy(ap_id, tmp->data->ap_log_id,
                                sizeof (ap_id));
                        return (PICL_SUCCESS);
                }
                tmp = tmp->next;
        }
        return (PICL_NODENOTFOUND);
}

/*
 * This routine dynamically determines the cfgadm attachment point
 * for a given devfspath and target id.
 * memory for name should be allocated by the caller.
 */
picl_errno_t
get_scsislot_name(char *devfs_path, char *bus_addr, char *name)
{
        picl_errno_t    rc;
        int target_id = 0;
        int numlist;
        plist_t                 list;
        cfga_err_t              ap_list_err;
        cfga_list_data_t        *cfgalist = NULL;
        char controller[MAXPATHLEN];

        ap_list_err = config_list_ext(0, NULL, &cfgalist,
                &numlist, NULL, NULL, NULL, CFGA_FLAG_LIST_ALL);
        if (ap_list_err != CFGA_OK) {
                return (PICL_NODENOTFOUND);
        }

        ap_list_err = populate_controllers_list(&list, cfgalist,
                numlist);
        if (ap_list_err != CFGA_OK) {
                free_list(&list);
                free(cfgalist);
                return (PICL_NODENOTFOUND);
        }

        if (list.num_nodes <= 0) {
                free(cfgalist);
                return (PICL_NODENOTFOUND);
        }

        if ((rc = find_scsi_controller(devfs_path, &list,
                controller)) != PICL_SUCCESS) {
                free(cfgalist);
                free_list(&list);
                return (rc);
        }
        target_id = strtol(bus_addr, (char **)NULL, 16);
        (void) sprintf(name, "%s::dsk/%st%dd0", controller,
                controller, target_id);
        free(cfgalist);
        free_list(&list);
        return (PICL_SUCCESS);
}

/*
 * Arg scsi_loc can be any of the following forms appearing in cfgadm output
 *      c0::dsk/c0t0d0
 *      c1::sd56
 *      c2::rmt/0
 *      c3::st41
 *      dsk/c1t1d0
 *      rmt/1
 *      /devices/pci@1f,0/pci@1,1/scsi@2:scsi::dsk/c0t0d0
 *
 *      On return, bus_addr contains the target id of the device.
 *      Please note that currently the target id is computed. It is better
 *      to eventually change this to getting from libdevinfo.
 *      Also, please note that SCSI_INITIATOR_ID should not
 *      be hardcoded, but should be dynamically retrieved from an OBP property.
 */
static void
get_bus_addr(char *scsi_loc, char **bus_addr)
{
        char *ap, *token, *p, *ap_idp;
        int len = 0, i = 0;
        char parse_link = 0;
        char addr[BUF_SIZE], ap_id[BUF_SIZE];
        char fileinfo[BUF_SIZE], ap_id_link[BUF_SIZE];

        (void) strncpy(ap_id, scsi_loc, sizeof (ap_id));
        ap = strrchr(ap_id, ':');
        if (!ap)
                ap = ap_idp = ap_id;
        else
                ap_idp = ++ap;

        while (scsi_dirlink_names[i] && !len) {
                len = strspn(ap, scsi_dirlink_names[i++]);
                /*
                 * strspn may return positive len even when there is no
                 * complete string matches!!! hence the following check is
                 * necessary. So ensure the string match.
                 */
                if (len && strstr(ap, scsi_dirlink_names[i-1]))
                        break;
                len = 0;
        }
        if (len)
                parse_link = 1;
        else {
                i = 0;
                while (scsi_drv[i].drv_name && !len) {
                        len = strspn(ap, scsi_drv[i++].drv_name);
                        if (len && strstr(ap, scsi_drv[i-1].drv_name))
                                break;
                        len = 0;
                }
        }
        ap += len;
        if (strlen(ap) && parse_link) {

                /* slice 0 must be present in the system */
                if (strstr(ap, "/c")) {
                        if (strstr(ap, "s0") == NULL)
                                (void) strcat(ap, "s0");
                }
                /* get the devlink and read the target id from minor node */
                (void) snprintf(ap_id_link, sizeof (ap_id_link), "/dev/%s",
                        ap_idp);
                (void) bzero(fileinfo, sizeof (fileinfo));
                if (readlink(ap_id_link, fileinfo, sizeof (fileinfo)) < 0)
                        return;
                if (!fileinfo[0])
                        return;
                ap = strrchr(fileinfo, '@');
                ap++;
        }
        token = (char *)strtok_r(ap, ",", &p);
        (void) strncpy(addr, token, sizeof (addr));
        if (!parse_link) {
                int drv_inst = atoi(token);
                int tmp_targ_id = drv_inst % scsi_drv[i-1].num_targets;
                int targ_id = scsi_drv[i-1].drv_type == DRV_TYPE_DSK ?
                        (tmp_targ_id < SCSI_INITIATOR_ID ?
                        tmp_targ_id : tmp_targ_id+1):
                        DRV_TYPE_TAPE ? tmp_targ_id : drv_inst;
                (void) snprintf(addr, sizeof (addr), "%d", targ_id);
        }
        if (strlen(addr)) {
                *bus_addr = (char *)malloc(strlen(addr)+1);
                if ((*bus_addr) == NULL)
                        return;
                (void) strcpy((char *)*bus_addr, addr);
        }
}

/*
 * This routine determines all the scsi nodes under a FRU and
 * creates a subtree of all the scsi nodes with basic properties.
 */
static picl_errno_t
dyn_probe_for_scsi_frus(frutree_frunode_t *frup, cfga_list_data_t *cfgalist,
        plist_t *list, int numlist)
{
        picl_errno_t rc;
        int i, geo_addr = 0;
        node_t *curr = NULL;
        char *bus_addr = NULL;
        char path[MAXPATHLEN];
        char controller_name[MAXPATHLEN];

        /* for each controller in the list, find if disk/fru is present */
        curr = list->first;
        while (curr != NULL) {
                /* compare the path */
                (void) snprintf((char *)path, sizeof (path),  "/devices%s",
                        frup->fru_path);
                if (strstr(curr->data->ap_phys_id, path) == NULL) {
                        curr = curr->next;
                        continue;

                }
                (void) snprintf(controller_name, sizeof (controller_name),
                        "%s::", curr->data->ap_log_id);

                for (i = 0; i < numlist; i++) {
                        if (strcmp(cfgalist[i].ap_type, SCSI_SLOT) == 0) {
                                continue;
                        }
                        if (strstr(cfgalist[i].ap_log_id,
                                controller_name) == NULL) {
                                continue;
                        }
                        /* check if device is under fru */
                        if (strstr(cfgalist[i].ap_phys_id, path) == NULL) {
                                continue;
                        }

                        /* we found a scsi fru */
                        geo_addr++;
                        /* check if the device is present in subtree */
                        if (is_location_present_in_subtree(frup,
                                cfgalist[i].ap_log_id, path) == B_TRUE) {
                                continue;
                        }
                        get_bus_addr(cfgalist[i].ap_log_id, &bus_addr);
                        if (bus_addr == NULL) {
                                continue;
                        }
                        rc = create_children(frup, cfgalist[i].ap_log_id,
                                bus_addr, geo_addr, SANIBEL_SCSI_SLOT, B_TRUE);
                        free(bus_addr);
                        if (rc != PICL_SUCCESS) {
                                FRUTREE_DEBUG3(FRUTREE_INIT, "SUNW_frutree:"
                                "Error in creating node %s under %s(error=%d)",
                                        cfgalist[i].ap_log_id, frup->name, rc);
                        }
                }
                curr = curr->next;
        }
        return (PICL_SUCCESS);
}

/*
 * data used here is cached information (cfglist, nlist)
 */
static picl_errno_t
cache_probe_for_scsi_frus(frutree_frunode_t *frup)
{
        int i, geo_addr = 0;
        picl_errno_t rc;
        node_t *curr = NULL;
        char path[MAXPATHLEN];
        char controller_name[MAXPATHLEN];
        char *bus_addr = NULL;

        /* for each controller in the list, find if disk/fru is present */
        if (scsi_list == NULL) {
                return (PICL_SUCCESS);
        }
        curr = scsi_list->first;
        while (curr != NULL) {
                /* compare the path */
                (void) snprintf((char *)path, sizeof (path), "/devices%s",
                        frup->fru_path);
                if (strstr(curr->data->ap_phys_id, path) == NULL) {
                        curr = curr->next;
                        continue;
                }
                (void) snprintf(controller_name, sizeof (controller_name),
                        "%s::", curr->data->ap_log_id);

                for (i = 0; i < nlist; i++) {
                        if (strcmp(cfglist[i].ap_type, SCSI_SLOT) == 0) {
                                continue;
                        }
                        if (strstr(cfglist[i].ap_log_id,
                                controller_name) == NULL) {
                                continue;
                        }
                        /* check if the device is under fru */
                        if (strstr(cfglist[i].ap_phys_id, path) == NULL) {
                                continue;
                        }

                        /* we found a scsi fru */
                        geo_addr++;
                        /* check if the device is present in subtree */
                        if (is_location_present_in_subtree(frup,
                                cfglist[i].ap_log_id, path) == B_TRUE) {
                                continue;
                        }
                        get_bus_addr(cfglist[i].ap_log_id, &bus_addr);
                        if (bus_addr == NULL) {
                                continue;
                        }
                        rc = create_children(frup, cfglist[i].ap_log_id,
                                bus_addr, geo_addr, SANIBEL_SCSI_SLOT, B_TRUE);
                        free(bus_addr);
                        if (rc != PICL_SUCCESS) {
                                FRUTREE_DEBUG3(FRUTREE_INIT, "SUNW_frutree:"
                                "Error in creating node %s under %s(error=%d)",
                                        cfglist[i].ap_log_id, frup->name, rc);
                        }
                }
                curr = curr->next;
        }
        return (PICL_SUCCESS);
}

/*
 * This routine checks if the node (scsi device) is present in cfgadm data
 * Algorithm:
 * 1. traverse thru list of controllers and find
 *    the controller of interest
 * 2. go thru list of devices under controller and compare if the target is same
 * 3. if yes
 *      - device is already represented
 * 4. if No
 *      - The node must be repreented in PICL tree.
 */
static boolean_t
is_node_present(scsi_info_t *scsi_info, char *devfs_path, int target)
{
        node_t  *curr = NULL;
        char    path[MAXPATHLEN];
        char    controller[MAXPATHLEN];
        char    *bus_addr = NULL;
        char    *lasts = NULL, *token = NULL;
        int     i = 0;

        if (scsi_info == NULL) {
                return (B_FALSE);
        }

        if (scsi_info->list == NULL) {
                return (B_FALSE);
        }

        (void) snprintf(path, sizeof (path), "/devices%s", devfs_path);

        curr = scsi_info->list->first;
        while (curr != NULL) {

                lasts = curr->data->ap_phys_id;
                token = (char *)strtok_r(lasts, (const char *)":",
                        (char **)&lasts);
                if (token == NULL) {
                        curr = curr->next;
                        continue;
                }

                if (strstr(path, token) == NULL) {
                        /* this controller is not of interest */
                        curr = curr->next;
                        continue;
                }

                (void) snprintf(controller, sizeof (controller), "%s::",
                        curr->data->ap_log_id);
                for (i = 0; i < scsi_info->num_list; i++) {
                        if (strcmp(scsi_info->cfgalist[i].ap_type,
                                SCSI_SLOT) == 0) {
                                continue;
                        }

                        if (strstr(scsi_info->cfgalist[i].ap_log_id,
                                controller) == NULL) {
                                continue;
                        }

                        get_bus_addr(scsi_info->cfgalist[i].ap_phys_id,
                                &bus_addr);
                        /*
                         * compare  with target value
                         */
                        if (bus_addr == NULL) {
                                return (B_TRUE);
                        }
                        if (strtoul(bus_addr, NULL, 16) == target) {
                                /*
                                 * this device is already represented
                                 * in fru tree
                                 */
                                free(bus_addr);
                                return (B_TRUE);
                        }
                        free(bus_addr);
                }
                curr = curr->next;
        }
        return (B_FALSE);
}

static di_prop_t
get_prop_by_name(di_node_t node, char *name)
{
        di_prop_t prop = DI_PROP_NIL;
        char *prop_name = NULL;

        prop = di_prop_next(node, DI_PROP_NIL);
        while (prop != DI_PROP_NIL) {
                prop_name = di_prop_name(prop);
                if (prop_name != NULL) {
                        if (strcmp(prop_name, name) == 0) {
                                return (prop);
                        }
                }
                prop = di_prop_next(node, prop);
        }
        return (DI_PROP_NIL);
}

static int
get_geoaddr(picl_nodehdl_t nodeh, void *c_args)
{
        picl_errno_t rc;
        uint8_t *geo_addr = NULL;
        char slot_type[PICL_PROPNAMELEN_MAX];

        if (c_args == NULL)
                return (PICL_INVALIDARG);
        geo_addr = (uint8_t *)c_args;

        if ((rc = ptree_get_propval_by_name(nodeh, PICL_PROP_SLOT_TYPE,
                slot_type, sizeof (slot_type))) != PICL_SUCCESS) {
                return (rc);
        }

        if (strcmp(slot_type, SANIBEL_SCSI_SLOT) == 0 ||
                strcmp(slot_type, SANIBEL_IDE_SLOT) == 0) {
                *geo_addr = *geo_addr + 1;
        }
        return (PICL_WALK_CONTINUE);
}

static int
frutree_get_geoaddr(frutree_frunode_t *frup)
{
        int geo_addr = 1;
        if (ptree_walk_tree_by_class(frup->frunodeh, PICL_CLASS_LOCATION,
                &geo_addr, get_geoaddr) != PICL_SUCCESS) {
                return (geo_addr);
        }
        return (geo_addr);
}

static int
probe_disks(di_node_t node, void *arg)
{
        di_prop_t prop;
        picl_errno_t rc;
        int *target_val = NULL;
        char *nodetype = NULL;
        char *devfs_path = NULL;
        char *bus_addr = NULL;
        char *drv_name = NULL;
        scsi_info_t *data = NULL;
        di_minor_t minor = DI_MINOR_NIL;
        char *class = NULL;
        char node_name[BUF_SIZE];
        char slot_type[PICL_PROPNAMELEN_MAX];

        if (arg == NULL)
                return (DI_WALK_TERMINATE);

        data = *(scsi_info_t **)arg;
        if (data == NULL) {
                return (DI_WALK_TERMINATE);
        }

        /* initialize the geo_addr value */
        if (data->geo_addr == 0) {
                if (data->compare_cfgadm == B_FALSE) {
                        data->geo_addr = 1;
                } else {
                        data->geo_addr = frutree_get_geoaddr(data->frup);
                }
        }

        while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
                nodetype = di_minor_nodetype(minor);
                if (nodetype == NULL) {
                        continue;
                }

                if (strcmp(nodetype, DDI_NT_BLOCK_CHAN) == 0 ||
                        strcmp(nodetype, DDI_NT_BLOCK_WWN) == 0) {
                        (void) snprintf(node_name, sizeof (node_name),
                                "%s%d", DISK, data->geo_addr);
                } else if (strcmp(nodetype, DDI_NT_TAPE) == 0) {
                        (void) snprintf(node_name, sizeof (node_name),
                                "%s%d", RMM, data->geo_addr);
                } else if (strcmp(nodetype, DDI_NT_CD) == 0 ||
                        strcmp(nodetype, DDI_NT_CD_CHAN) == 0) {
                        (void) snprintf(node_name, sizeof (node_name),
                                "%s%d", CDROM, data->geo_addr);
                } else {
                        continue;
                }

                devfs_path = di_devfs_path(node);
                drv_name = di_driver_name(node);
                bus_addr = di_bus_addr(node);
                if (devfs_path == NULL) {
                        continue;
                }
                if (drv_name == NULL || bus_addr == NULL) {
                        di_devfs_path_free(devfs_path);
                        continue;
                }
                prop = get_prop_by_name(node, TARGET);
                if (prop != DI_PROP_NIL) {
                        di_prop_ints(prop, &target_val);
                        if (data->compare_cfgadm) {
                                /* check if node is present in cfgadm data */
                                if (is_node_present(data, devfs_path,
                                        *target_val) == B_TRUE) {
                                        di_devfs_path_free(devfs_path);
                                        return (DI_WALK_CONTINUE);
                                }
                        }

                        di_devfs_path_free(devfs_path);
                        prop = get_prop_by_name(node, CLASS);
                        if (prop != DI_PROP_NIL) {
                                di_prop_strings(prop, &class);
                        }

                        /* determine the slot type based on class code */
                        if (class != NULL) {
                                if (strcmp(class, DEVICE_CLASS_SCSI) == 0) {
                                        (void) strncpy(slot_type,
                                                SANIBEL_SCSI_SLOT,
                                                sizeof (slot_type));
                                } else if (strcmp(class,
                                        DEVICE_CLASS_IDE) == 0) {
                                        (void) strncpy(slot_type,
                                                SANIBEL_IDE_SLOT,
                                                sizeof (slot_type));
                                } else {
                                        (void) strncpy(slot_type,
                                                SANIBEL_UNKNOWN_SLOT,
                                                sizeof (slot_type));
                                }

                        } else {
                                (void) strncpy(slot_type, SANIBEL_UNKNOWN_SLOT,
                                        sizeof (slot_type));
                        }

                        if ((rc = create_children(data->frup, node_name,
                                bus_addr, data->geo_addr, slot_type,
                                B_FALSE)) != PICL_SUCCESS) {
                                return (rc);
                        }
                        /* increment the geo_addr */
                        data->geo_addr++;
                } else {
                        di_devfs_path_free(devfs_path);
                        continue;
                }
                return (DI_WALK_CONTINUE);
        }
        return (DI_WALK_CONTINUE);
}

static picl_errno_t
probe_scsi_in_libdevinfo(frutree_frunode_t *frup, cfga_list_data_t *cfgalist,
        plist_t *list, int num_list, boolean_t compare_cfgadm)
{
        di_node_t       rnode;
        scsi_info_t     *scsi_data = NULL;

        if (frup == NULL) {
                return (PICL_FAILURE);
        }

        rnode = di_init(frup->fru_path, DINFOCPYALL);
        if (rnode == DI_NODE_NIL) {
                return (PICL_FAILURE);
        }

        scsi_data = (scsi_info_t *)malloc(sizeof (scsi_info_t));
        if (scsi_data == NULL) {
                di_fini(rnode);
                return (PICL_NOSPACE);
        }

        scsi_data->frup = frup;
        scsi_data->cfgalist = cfgalist;
        scsi_data->list = list;
        scsi_data->num_list = num_list;
        scsi_data->compare_cfgadm = compare_cfgadm;
        scsi_data->geo_addr = 0;
        if (di_walk_node(rnode, DI_WALK_CLDFIRST, &scsi_data,
                probe_disks) != 0) {
                free(scsi_data);
                di_fini(rnode);
                return (PICL_FAILURE);
        }

        free(scsi_data);
        di_fini(rnode);
        return (PICL_SUCCESS);
}

picl_errno_t
probe_for_scsi_frus(frutree_frunode_t *frup)
{
        int numlist;
        picl_errno_t rc;
        plist_t list;
        cfga_err_t ap_list_err;
        cfga_list_data_t *cfgalist = NULL;

        if (frutree_connects_initiated == B_TRUE) { /* probing after hotswap */
                ap_list_err = config_list_ext(0, NULL, &cfgalist,
                        &numlist, NULL, NULL, NULL, CFGA_FLAG_LIST_ALL);

                if (ap_list_err != CFGA_OK) {
                        rc = probe_scsi_in_libdevinfo(frup, NULL, NULL,
                                0, B_FALSE);
                        return (rc);
                }

                /* get list of all controllers in the system */
                ap_list_err = populate_controllers_list(&list, cfgalist,
                        numlist);
                if (ap_list_err != CFGA_OK) {
                        free_list(&list);
                        free(cfgalist);
                        rc = probe_scsi_in_libdevinfo(frup, NULL, NULL,
                                0, B_FALSE);
                        return (rc);
                }

                /* no controllers found */
                if (list.num_nodes <= 0) {
                        free_list(&list);
                        free(cfgalist);
                        rc = probe_scsi_in_libdevinfo(frup, NULL, NULL,
                                0, B_FALSE);
                        return (rc);
                }
                /*
                 * we have to fetch cfgadm, look for scsi controllers
                 * dynamically
                 */
                (void) dyn_probe_for_scsi_frus(frup, cfgalist, &list, numlist);
                rc = probe_scsi_in_libdevinfo(frup, cfgalist, &list,
                        numlist, B_TRUE);
                free_list(&list);
                free(cfgalist);
                return (rc);
        } else {
                /* during initialization */
                /* use the cached cfgadm data */
                rc = cache_probe_for_scsi_frus(frup);
                if (scsi_list && scsi_list->num_nodes > 0) {
                        rc = probe_scsi_in_libdevinfo(frup, cfglist,
                                scsi_list, nlist, B_TRUE);
                } else {
                        rc = probe_scsi_in_libdevinfo(frup, NULL,
                                NULL, 0, B_FALSE);
                }
                return (rc);
        }
}