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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * Implementation to interact with libdevinfo to find port nodes,
31 * and information regarding each node (fru, port, location).
32 */
33
34 #include <stdio.h>
35 #include <libdevinfo.h>
36 #include <picl.h>
37 #include <picltree.h>
38 #include <strings.h>
39 #include <stdlib.h>
40 #include <config_admin.h>
41 #include <sys/types.h>
42 #include <sys/obpdefs.h>
43 #include <sys/pci.h>
44 #include <picldefs.h>
45 #include "piclfrutree.h"
46
47 #include <syslog.h>
48
49 static di_prom_handle_t prom_handle = DI_PROM_HANDLE_NIL;
50 extern int frutree_debug;
51
52 typedef struct {
53 di_node_t rnode;
54 char bus_addr[PICL_PROPNAMELEN_MAX];
55 char path[PICL_PROPNAMELEN_MAX];
56 void *arg;
57 picl_errno_t retval;
58 } frutree_devinfo_t;
59
60 typedef struct p_info {
61 frutree_port_type_t type;
62 int geo_addr;
63 int instance;
64 char drv_name[20];
65 char bus_addr[20];
66 char devfs_path[MAXPATHLEN];
67 struct p_info *next;
68 }port_info_t;
69
70 typedef struct {
71 port_info_t *first;
72 port_info_t *last;
73 int n_serial;
74 int n_parallel;
75 int n_network;
76 } plist_t;
77
78 static void
79 free_list(plist_t *listptr)
80 {
81 port_info_t *tmp;
82 port_info_t *nextptr;
83 if (listptr == NULL)
84 return;
85
86 nextptr = listptr->first;
87 while (nextptr != NULL) {
88 tmp = nextptr;
89 nextptr = nextptr->next;
90 free(tmp);
91 }
92 }
93
94 /* (callback function for qsort) compare the bus_addr */
95 static int
96 compare(const void *a, const void *b)
97 {
98 port_info_t *pinfo1, *pinfo2;
99 port_info_t **ptr2pinfo1, **ptr2pinfo2;
100
101 ptr2pinfo1 = (port_info_t **)a;
102 ptr2pinfo2 = (port_info_t **)b;
103
104 pinfo1 = (port_info_t *)*ptr2pinfo1;
105 pinfo2 = (port_info_t *)*ptr2pinfo2;
106 return (strcmp(pinfo1->bus_addr, pinfo2->bus_addr));
107 }
108
109 /*
110 * assigns GeoAddr property for ports based on bus-addr
111 */
112 static picl_errno_t
113 assign_geo_addr(plist_t *list, frutree_port_type_t type)
114 {
115
116 int i = 0;
117 port_info_t **port_info = NULL;
118 port_info_t *nextptr = NULL;
119 int num_ports = 0;
120
121 if (list == NULL) {
122 return (PICL_FAILURE);
123 }
124
125 if (list->first == NULL) {
126 return (PICL_SUCCESS);
127 }
128
129 switch (type) {
130 case SERIAL_PORT:
131 if (list->n_serial == 0) {
132 return (PICL_SUCCESS);
133 }
134 num_ports = list->n_serial;
135 break;
136
137 case PARALLEL_PORT:
138 if (list->n_parallel == 0) {
139 return (PICL_SUCCESS);
140 }
141 num_ports = list->n_parallel;
142 break;
143
144 case NETWORK_PORT:
145 if (list->n_network == 0) {
146 return (PICL_SUCCESS);
147 }
148 num_ports = list->n_network;
149 break;
150
151 }
152
153 port_info = (port_info_t **)malloc(
154 sizeof (port_info_t *) * num_ports);
155 if (port_info == NULL) {
156 return (PICL_NOSPACE);
157 }
158
159 /* traverse thru list and look for ports of given type */
160 nextptr = list->first;
161 while (nextptr != NULL) {
162 if (nextptr->type != type) {
163 nextptr = nextptr->next;
164 continue;
165 }
166 port_info[i] = nextptr;
167 nextptr = nextptr->next;
168 i++;
169 }
170
171 /* sort the nodes to assign geo_address */
172 (void) qsort((void *)port_info, num_ports,
173 sizeof (port_info_t *), compare);
174 for (i = 0; i < num_ports; i++) {
175 if (port_info[i] != NULL) {
176 port_info[i]->geo_addr = i + 1;
177 }
178 }
179 free(port_info);
180 return (PICL_SUCCESS);
181 }
182
183 static picl_errno_t
184 create_port_config_info(plist_t *list, frutree_device_args_t *devp)
185 {
186 port_info_t *port_info = NULL;
187 frutree_cache_t *cachep = NULL;
188 char port_type[PICL_PROPNAMELEN_MAX];
189 char label[PICL_PROPNAMELEN_MAX];
190
191 if (list == NULL) {
192 return (PICL_FAILURE);
193 }
194
195 port_info = list->first;
196 while (port_info != NULL) {
197
198 cachep = (frutree_cache_t *)malloc(sizeof (frutree_cache_t));
199 if (cachep == NULL) {
200 return (PICL_NOSPACE);
201 }
202
203 switch (port_info->type) {
204 case NETWORK_PORT:
205 (void) strncpy(label, SANIBEL_NETWORK_LABEL,
206 sizeof (label));
207 (void) strncpy(port_type, SANIBEL_NETWORK_PORT,
208 sizeof (port_type));
209 break;
210 case PARALLEL_PORT:
211 (void) strncpy(label, SANIBEL_PARALLEL_PORT,
212 sizeof (label));
213 (void) strncpy(port_type, SANIBEL_PARALLEL_PORT,
214 sizeof (port_type));
215 break;
216 case SERIAL_PORT:
217 (void) strncpy(label, SANIBEL_SERIAL_PORT,
218 sizeof (label));
219 (void) strncpy(port_type, SANIBEL_SERIAL_PORT,
220 sizeof (port_type));
221 break;
222 default:
223 port_info = port_info->next;
224 }
225 cachep->buf[0] = '\0';
226 cachep->next = NULL;
227 (void) snprintf(cachep->buf,
228 sizeof (cachep->buf),
229 "\n%s %s%d %s\n"
230 "\t%s %s %s %s 0 \"%s %d\"\n"
231 "\t%s %s %s %s 0 \"%s\"\n"
232 "\t%s %s %s %s 1 %d\n"
233 "\t%s %s %s %s 0 \"%s\"\n"
234 "\t%s %s %s %s 0 \"%s\"\n"
235 "%s\n",
236 "NODE", port_info->drv_name, port_info->instance,
237 PICL_CLASS_PORT,
238 "PROP", PICL_PROP_LABEL, "string", "r",
239 label, (port_info->geo_addr -1),
240 "PROP", PICL_PROP_BUS_ADDR, "string",
241 "r", port_info->bus_addr,
242 "PROP", PICL_PROP_GEO_ADDR, "uint",
243 "r", port_info->geo_addr,
244 "PROP", PICL_PROP_PORT_TYPE, "string",
245 "r", port_type,
246 "PROP", PICL_PROP_DEVFS_PATH, "string",
247 "r", port_info->devfs_path,
248 "ENDNODE");
249
250 /* add to the cache */
251 if (devp->first == NULL) { /* 1st node */
252 devp->first = cachep;
253 devp->last = NULL;
254 } else if (devp->last != NULL) { /* last node */
255 devp->last->next = cachep;
256 devp->last = cachep;
257 } else { /* 2nd node */
258 devp->first->next = cachep;
259 devp->last = cachep;
260 }
261 port_info = port_info->next; /* advance to next node */
262 }
263 return (PICL_SUCCESS);
264 }
265
266 /*ARGSUSED*/
267 static int
268 load_driver(di_node_t node, void *arg)
269 {
270 char *drv_name = NULL;
271 char cmd[MAXPATHLEN];
272
273 if (di_node_state(node) >= DS_ATTACHED) {
274 return (DI_WALK_CONTINUE);
275 }
276 drv_name = di_driver_name(node);
277 if (drv_name == NULL) {
278 return (DI_WALK_CONTINUE);
279 }
280
281 (void) snprintf(cmd, sizeof (cmd), "%s %s",
282 DEVFSADM_CMD, drv_name);
283 (void) pclose(popen(cmd, "r"));
284 return (DI_WALK_CONTINUE);
285 }
286
287 static picl_errno_t
288 load_drivers(char *path)
289 {
290 di_node_t rnode;
291 if (path == NULL) {
292 return (PICL_INVALIDARG);
293 }
294
295 rnode = di_init(path, DINFOSUBTREE|DINFOMINOR);
296 if (rnode == DI_NODE_NIL) {
297 return (PICL_FAILURE);
298 }
299
300 if (di_walk_node(rnode, DI_WALK_CLDFIRST, NULL, load_driver) != 0) {
301 di_fini(rnode);
302 return (PICL_FAILURE);
303 }
304
305 di_fini(rnode);
306 return (PICL_SUCCESS);
307 }
308
309 /*
310 * probe for port nodes
311 */
312 static int
313 probe_tree(di_node_t node, void *arg)
314 {
315 char *nodetype = NULL;
316 char *devfs_path = NULL;
317 char *bus_addr = NULL;
318 char *drv_name = NULL;
319 plist_t *listptr = NULL;
320 port_info_t *port_info = NULL;
321 frutree_port_type_t port_type = UNKNOWN_PORT;
322 di_minor_t minor = DI_MINOR_NIL;
323
324 if (arg == NULL) {
325 return (DI_WALK_TERMINATE);
326 }
327 listptr = (plist_t *)arg;
328
329 while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
330 nodetype = di_minor_nodetype(minor);
331 if (nodetype == NULL) {
332 continue;
333 }
334
335 if (strcmp(nodetype, DDI_NT_NET) == 0) {
336 port_type = NETWORK_PORT;
337 } else if (strcmp(nodetype, DDI_NT_PARALLEL) == 0) {
338 port_type = PARALLEL_PORT;
339 } else if ((strcmp(nodetype, DDI_NT_SERIAL) == 0) ||
340 (strcmp(nodetype, DDI_NT_SERIAL_MB) == 0) ||
341 (strcmp(nodetype, DDI_NT_SERIAL_DO) == 0) ||
342 (strcmp(nodetype, DDI_NT_SERIAL_MB_DO) == 0)) {
343 port_type = SERIAL_PORT;
344 } else {
345 continue;
346 }
347
348 /* found port node */
349 devfs_path = di_devfs_path(node);
350 if (devfs_path == NULL) {
351 continue;
352 }
353
354 bus_addr = di_bus_addr(node);
355 drv_name = di_driver_name(node);
356
357 if ((bus_addr == NULL) || (drv_name == NULL)) {
358 di_devfs_path_free(devfs_path);
359 continue;
360 }
361
362 port_info = malloc(sizeof (port_info_t));
363 if (port_info == NULL) {
364 di_devfs_path_free(devfs_path);
365 return (PICL_NOSPACE);
366 }
367
368 (void) strncpy(port_info->devfs_path, devfs_path,
369 sizeof (port_info->devfs_path));
370 (void) strncpy(port_info->bus_addr, bus_addr,
371 sizeof (port_info->bus_addr));
372 (void) strncpy(port_info->drv_name, drv_name,
373 sizeof (port_info->drv_name));
374 port_info->type = port_type;
375 port_info->instance = di_instance(node);
376 port_info->geo_addr = -1;
377 port_info->next = NULL;
378
379 switch (port_type) {
380 case NETWORK_PORT:
381 listptr->n_network++;
382 break;
383 case SERIAL_PORT:
384 listptr->n_serial++;
385 break;
386 case PARALLEL_PORT:
387 listptr->n_parallel++;
388 break;
389 }
390
391 /* add to the list */
392 if (listptr->first == NULL) { /* 1st node */
393 listptr->first = port_info;
394 listptr->last = NULL;
395 } else if (listptr->last != NULL) { /* last node */
396 listptr->last->next = port_info;
397 listptr->last = port_info;
398 } else { /* 2nd node */
399 listptr->first->next = port_info;
400 listptr->last = port_info;
401 }
402 di_devfs_path_free(devfs_path);
403 return (DI_WALK_CONTINUE);
404 }
405 return (DI_WALK_CONTINUE);
406 }
407
408 /* This routine probes libdevinfo for port nodes */
409 picl_errno_t
410 probe_libdevinfo(frutree_frunode_t *frup, frutree_device_args_t ** device,
411 boolean_t load_drv)
412 {
413 di_node_t rnode;
414 picl_errno_t rc;
415 plist_t list;
416
417 if (frup == NULL) {
418 return (PICL_FAILURE);
419 }
420 FRUTREE_DEBUG1(EVENTS, "loading drivers for %s", frup->name);
421
422 if (load_drv == B_TRUE) {
423 if ((rc = load_drivers(frup->fru_path)) != PICL_SUCCESS) {
424 return (rc);
425 }
426 }
427 FRUTREE_DEBUG1(EVENTS, "done with loading drivers for %s", frup->name);
428
429 rnode = di_init(frup->fru_path, DINFOSUBTREE|DINFOMINOR);
430 if (rnode == DI_NODE_NIL) {
431 return (PICL_FAILURE);
432 }
433
434 list.first = NULL;
435 list.last = NULL;
436 list.n_network = 0;
437 list.n_serial = 0;
438 list.n_parallel = 0;
439
440 if (di_walk_node(rnode, DI_WALK_CLDFIRST, &list, probe_tree) != 0) {
441 di_fini(rnode);
442 free_list(&list);
443 return (PICL_FAILURE);
444 }
445
446 if (list.n_serial > 0)
447 if ((rc = assign_geo_addr(&list, SERIAL_PORT)) != PICL_SUCCESS) {
448 di_fini(rnode);
449 free_list(&list);
450 return (rc);
451 }
452
453 if (list.n_network > 0)
454 if ((rc = assign_geo_addr(&list, NETWORK_PORT)) != PICL_SUCCESS) {
455 di_fini(rnode);
456 free_list(&list);
457 return (rc);
458 }
459
460 if (list.n_parallel > 0)
461 if ((rc = assign_geo_addr(&list, PARALLEL_PORT)) != PICL_SUCCESS) {
462 di_fini(rnode);
463 free_list(&list);
464 return (rc);
465 }
466
467 if ((rc = create_port_config_info(&list, *device)) != PICL_SUCCESS) {
468 di_fini(rnode);
469 free_list(&list);
470 return (rc);
471 }
472
473 di_fini(rnode);
474 free_list(&list);
475 FRUTREE_DEBUG1(EVENTS, "done with probing %s", frup->name);
476 return (PICL_SUCCESS);
477 }
478
479 static int
480 get_reg_dev(di_node_t node)
481 {
482 int *reg = NULL;
483 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, OBP_REG, ®) < 0) {
484 if (di_prom_prop_lookup_ints(prom_handle, node, OBP_REG,
485 ®) < 0) {
486 return (-1);
487 }
488 return (PCI_REG_DEV_G(reg[0]));
489 }
490 return (PCI_REG_DEV_G(reg[0]));
491 }
492
493 static int
494 walk_tree(di_node_t node, void *arg)
495 {
496 char *path = NULL;
497 char *bus_addr = NULL;
498 char *char_di_bus_addr = NULL;
499 int busaddr = 0;
500 int di_busaddr = 0;
501 char *node_name = NULL;
502 frutree_devinfo_t *devinfo;
503 frutree_frunode_t *frup = NULL;
504
505 devinfo = *(frutree_devinfo_t **)arg;
506 frup = (frutree_frunode_t *)devinfo->arg;
507 if (frup == NULL) {
508 return (DI_WALK_TERMINATE);
509 }
510
511 if (devinfo->rnode == node) { /* skip the root node */
512 return (DI_WALK_CONTINUE);
513 }
514 bus_addr = devinfo->bus_addr;
515
516 char_di_bus_addr = di_bus_addr(node);
517 if (char_di_bus_addr == NULL) {
518 /*
519 * look for reg property
520 * This applies to only cPCI devices
521 */
522 if (strstr(bus_addr, ",") != NULL) {
523 /* bus addr is of type 1,0 */
524 /* we dont handle this case yet */
525 return (DI_WALK_PRUNECHILD);
526 }
527 di_busaddr = get_reg_dev(node);
528 if (di_busaddr == -1) {
529 /* reg prop not found */
530 return (DI_WALK_PRUNECHILD);
531 }
532
533 /* check if the bus addresses are same */
534 errno = 0;
535 busaddr = strtol(bus_addr, (char **)NULL, 16);
536 if (errno != 0) {
537 return (DI_WALK_TERMINATE);
538 }
539 if (di_busaddr != busaddr) {
540 return (DI_WALK_PRUNECHILD);
541 }
542
543 /* build the fru path name */
544 /* parent_path/nodename@bus_addr */
545 node_name = di_node_name(node);
546 if (node_name == NULL) {
547 return (DI_WALK_TERMINATE);
548 }
549 (void) snprintf(devinfo->path, sizeof (devinfo->path),
550 "%s/%s@%s", frup->fru_path, node_name, bus_addr);
551 return (DI_WALK_TERMINATE);
552 }
553
554 if (strstr(bus_addr, ",") != NULL) { /* bus addr is of type 1,0 */
555 if (strcmp(bus_addr, char_di_bus_addr) != 0) {
556 return (DI_WALK_PRUNECHILD);
557 }
558 } else { /* bus addr is of type 0x */
559
560 /* check if the values are same */
561 errno = 0;
562 busaddr = strtol(bus_addr, (char **)NULL, 16);
563 if (errno != 0) {
564 return (DI_WALK_TERMINATE);
565 }
566
567 errno = 0;
568 di_busaddr = strtol(char_di_bus_addr, (char **)NULL, 16);
569 if (errno != 0) {
570 return (DI_WALK_TERMINATE);
571 }
572
573 if (di_busaddr != busaddr) {
574 return (DI_WALK_PRUNECHILD);
575 }
576 }
577
578 /* node found */
579 path = di_devfs_path(node);
580 (void) strncpy(devinfo->path, path, sizeof (devinfo->path));
581 di_devfs_path_free(path);
582 return (DI_WALK_TERMINATE);
583 }
584
585 picl_errno_t
586 get_fru_path(char *parent_path, frutree_frunode_t *frup)
587 {
588 picl_errno_t rc = 0;
589 picl_nodehdl_t loch;
590 di_node_t rnode;
591 frutree_devinfo_t *devinfo = NULL;
592 char slot_type[PICL_PROPNAMELEN_MAX];
593 char probe_path[PICL_PROPNAMELEN_MAX];
594 char bus_addr[PICL_PROPNAMELEN_MAX];
595
596 if ((rc = ptree_get_propval_by_name(frup->frunodeh, PICL_PROP_PARENT,
597 &loch, sizeof (loch))) != PICL_SUCCESS) {
598 return (rc);
599 }
600
601 if ((rc = ptree_get_propval_by_name(loch, PICL_PROP_SLOT_TYPE,
602 slot_type, sizeof (slot_type))) != PICL_SUCCESS) {
603 return (rc);
604 }
605
606 if (strcmp(slot_type, SANIBEL_SCSI_SLOT) == 0 ||
607 strcmp(slot_type, SANIBEL_IDE_SLOT) == 0) {
608 if (ptree_get_propval_by_name(loch, PICL_PROP_PROBE_PATH,
609 probe_path, sizeof (probe_path)) != PICL_SUCCESS) {
610 return (rc);
611 }
612 (void) strncpy(frup->fru_path, probe_path,
613 sizeof (frup->fru_path));
614 return (PICL_SUCCESS);
615 }
616
617 prom_handle = di_prom_init();
618 rnode = di_init(parent_path, DINFOSUBTREE|DINFOMINOR);
619 if (rnode == DI_NODE_NIL) {
620 di_prom_fini(prom_handle);
621 return (PICL_FAILURE);
622 }
623
624 devinfo = (frutree_devinfo_t *)malloc(sizeof (frutree_devinfo_t));
625 if (devinfo == NULL) {
626 di_fini(rnode);
627 di_prom_fini(prom_handle);
628 return (PICL_NOSPACE);
629 }
630
631 if (ptree_get_propval_by_name(loch, PICL_PROP_BUS_ADDR,
632 bus_addr, sizeof (bus_addr)) != PICL_SUCCESS) {
633 free(devinfo);
634 di_fini(rnode);
635 di_prom_fini(prom_handle);
636 return (rc);
637 }
638
639 devinfo->rnode = rnode;
640 (void) strncpy(devinfo->bus_addr, bus_addr, sizeof (devinfo->bus_addr));
641 devinfo->path[0] = '\0';
642 devinfo->arg = frup;
643
644 if (di_walk_node(rnode, DI_WALK_SIBFIRST, &devinfo, walk_tree) != 0) {
645 di_fini(rnode);
646 di_prom_fini(prom_handle);
647 free(devinfo);
648 return (PICL_FAILURE);
649 }
650 di_fini(rnode);
651 di_prom_fini(prom_handle);
652
653 if (devinfo->path[0]) {
654 (void) strncpy(frup->fru_path, devinfo->path,
655 sizeof (frup->fru_path));
656 free(devinfo);
657 return (PICL_SUCCESS);
658 } else {
659 free(devinfo);
660 return (PICL_NODENOTFOUND);
661 }
662 }
663
664 static int
665 find_fru_node(di_node_t node, void *arg)
666 {
667 frutree_locnode_t *locp = NULL;
668 char *char_di_bus_addr = NULL;
669 int busaddr = 0;
670 int di_busaddr = 0;
671 char bus_addr[PICL_PROPNAMELEN_MAX];
672 frutree_devinfo_t *devinfo = NULL;
673
674 devinfo = *(frutree_devinfo_t **)arg;
675 locp = *(frutree_locnode_t **)devinfo->arg;
676
677 if (devinfo->rnode == node) {
678 return (DI_WALK_CONTINUE);
679 }
680
681 char_di_bus_addr = di_bus_addr(node);
682 if (char_di_bus_addr == NULL) {
683 return (DI_WALK_PRUNECHILD);
684 }
685
686 if (ptree_get_propval_by_name(locp->locnodeh, PICL_PROP_BUS_ADDR,
687 bus_addr, sizeof (bus_addr)) != PICL_SUCCESS) {
688 return (DI_WALK_PRUNECHILD);
689 }
690
691 if (strstr(bus_addr, ",") != NULL) {
692 /* bus addr is of type 1,0 */
693 if (strcmp(bus_addr, char_di_bus_addr) == 0) {
694 devinfo->retval = PICL_SUCCESS;
695 return (DI_WALK_TERMINATE);
696 } else {
697 return (DI_WALK_PRUNECHILD);
698 }
699 } else { /* bus addr is of type 0x */
700
701 /* check if the values are same */
702 errno = 0;
703 busaddr = strtol(bus_addr, (char **)NULL, 16);
704 if (errno != 0) {
705 return (DI_WALK_PRUNECHILD);
706 }
707
708 errno = 0;
709 di_busaddr = strtol(char_di_bus_addr, (char **)NULL, 16);
710 if (errno != 0) {
711 return (DI_WALK_PRUNECHILD);
712 }
713
714 if (di_busaddr == busaddr) {
715 devinfo->retval = PICL_SUCCESS;
716 return (DI_WALK_TERMINATE);
717 } else {
718 return (DI_WALK_PRUNECHILD);
719 }
720 }
721 }
722
723 /*
724 * checks if a fru is present under location using pdev-path and busaddr
725 */
726 boolean_t
727 is_fru_present_under_location(frutree_locnode_t *locp)
728 {
729 di_node_t rnode;
730 frutree_devinfo_t *devinfo = NULL;
731 char probe_path[PICL_PROPNAMELEN_MAX];
732
733 if (locp == NULL) {
734 return (B_FALSE);
735 }
736
737 if (ptree_get_propval_by_name(locp->locnodeh, PICL_PROP_PROBE_PATH,
738 probe_path, sizeof (probe_path)) != PICL_SUCCESS) {
739 if (ptree_get_propval_by_name(locp->locnodeh,
740 PICL_PROP_DEVFS_PATH, probe_path,
741 sizeof (probe_path)) != PICL_SUCCESS) {
742 return (B_FALSE);
743 }
744 }
745
746 rnode = di_init(probe_path, DINFOSUBTREE);
747 if (rnode == DI_NODE_NIL) {
748 di_fini(rnode);
749 return (B_FALSE);
750 }
751
752 devinfo = (frutree_devinfo_t *)malloc(sizeof (frutree_devinfo_t));
753 if (devinfo == NULL) {
754 di_fini(rnode);
755 return (B_FALSE);
756 }
757 devinfo->rnode = rnode;
758 devinfo->arg = (frutree_locnode_t **)&locp;
759 devinfo->retval = PICL_FAILURE;
760
761 if (di_walk_node(rnode, DI_WALK_SIBFIRST, &devinfo,
762 find_fru_node) != 0) {
763 di_fini(rnode);
764 free(devinfo);
765 return (B_FALSE);
766 }
767 di_fini(rnode);
768
769 if (devinfo->retval == PICL_SUCCESS) {
770 free(devinfo);
771 return (B_TRUE);
772 } else {
773 free(devinfo);
774 return (B_FALSE);
775 }
776 }
777
778 /*
779 * initializes the port driver and instance fields based on libdevinfo
780 */
781 picl_errno_t
782 get_port_info(frutree_portnode_t *portp)
783 {
784 picl_errno_t rc;
785 di_node_t rnode, curr, peer;
786 char devfs_path[PICL_PROPNAMELEN_MAX];
787 char bus_addr[PICL_PROPNAMELEN_MAX];
788 char *di_busaddr = NULL, *di_drv = NULL;
789 int di_int_busaddr, int_busaddr;
790
791 if ((rc = ptree_get_propval_by_name(portp->portnodeh,
792 PICL_PROP_DEVFS_PATH, devfs_path,
793 sizeof (devfs_path))) != PICL_SUCCESS) {
794 return (rc);
795 }
796
797 if (ptree_get_propval_by_name(portp->portnodeh, PICL_PROP_BUS_ADDR,
798 bus_addr, sizeof (bus_addr)) != PICL_SUCCESS) {
799 return (rc);
800 }
801
802 rnode = di_init(devfs_path, DINFOCPYALL);
803 if (rnode == DI_NODE_NIL) {
804 return (PICL_FAILURE);
805 }
806
807 peer = di_child_node(rnode);
808 while (peer != DI_NODE_NIL) {
809 curr = peer;
810 peer = di_sibling_node(curr);
811
812 di_busaddr = di_bus_addr(curr);
813 if (di_busaddr == NULL) {
814 continue;
815 }
816
817 /* compare the bus_addr */
818 if (strstr(bus_addr, ",") != NULL) {
819 /* bus addr is of type 1,0 */
820 if (strcmp(bus_addr, di_busaddr) != 0) {
821 continue;
822 }
823 } else { /* bus addr is of type 0x */
824 errno = 0;
825 int_busaddr = strtol(bus_addr, (char **)NULL, 16);
826 if (errno != 0) {
827 continue;
828 }
829
830 errno = 0;
831 di_int_busaddr = strtol(di_busaddr, (char **)NULL, 16);
832 if (errno != 0) {
833 continue;
834 }
835
836 if (di_int_busaddr != int_busaddr) {
837 continue;
838 }
839 }
840 di_drv = di_driver_name(curr);
841 if (di_drv == NULL) {
842 di_fini(rnode);
843 return (PICL_FAILURE);
844 }
845 /* initialize the driver name and instance number */
846 (void) strncpy(portp->driver, di_drv, sizeof (portp->driver));
847 portp->instance = di_instance(curr);
848 di_fini(rnode);
849 return (PICL_SUCCESS);
850 }
851 di_fini(rnode);
852 return (PICL_NODENOTFOUND);
853 }