2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2001 - 2003 by Thomas Moestl <tmm@FreeBSD.org>.
5 * Copyright (c) 2005 Marius Strobl <marius@FreeBSD.org>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions, and the following disclaimer,
13 * without modification, immediately at the beginning of the file.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include "opt_platform.h"
36 #include <sys/param.h>
37 #include <sys/systm.h>
39 #include <sys/errno.h>
40 #include <sys/libkern.h>
43 #include <machine/resource.h>
45 #include <dev/ofw/ofw_bus.h>
46 #include <dev/ofw/ofw_bus_subr.h>
47 #include <dev/ofw/openfirm.h>
49 #include "ofw_bus_if.h"
51 #define OFW_COMPAT_LEN 255
52 #define OFW_STATUS_LEN 16
55 ofw_bus_gen_setup_devinfo(struct ofw_bus_devinfo *obd, phandle_t node)
60 /* The 'name' property is considered mandatory. */
61 if ((OF_getprop_alloc(node, "name", (void **)&obd->obd_name)) == -1)
63 OF_getprop_alloc(node, "compatible", (void **)&obd->obd_compat);
64 OF_getprop_alloc(node, "device_type", (void **)&obd->obd_type);
65 OF_getprop_alloc(node, "model", (void **)&obd->obd_model);
66 OF_getprop_alloc(node, "status", (void **)&obd->obd_status);
72 ofw_bus_gen_destroy_devinfo(struct ofw_bus_devinfo *obd)
77 if (obd->obd_compat != NULL)
78 free(obd->obd_compat, M_OFWPROP);
79 if (obd->obd_model != NULL)
80 free(obd->obd_model, M_OFWPROP);
81 if (obd->obd_name != NULL)
82 free(obd->obd_name, M_OFWPROP);
83 if (obd->obd_type != NULL)
84 free(obd->obd_type, M_OFWPROP);
85 if (obd->obd_status != NULL)
86 free(obd->obd_status, M_OFWPROP);
90 ofw_bus_gen_child_pnpinfo(device_t cbdev, device_t child, struct sbuf *sb)
93 if (!ofw_bus_status_okay(child))
96 if (ofw_bus_get_name(child) != NULL) {
97 sbuf_printf(sb, "name=%s ", ofw_bus_get_name(child));
100 if (ofw_bus_get_compat(child) != NULL) {
101 sbuf_printf(sb, "compat=%s ", ofw_bus_get_compat(child));
108 ofw_bus_gen_get_compat(device_t bus, device_t dev)
110 const struct ofw_bus_devinfo *obd;
112 obd = OFW_BUS_GET_DEVINFO(bus, dev);
115 return (obd->obd_compat);
119 ofw_bus_gen_get_model(device_t bus, device_t dev)
121 const struct ofw_bus_devinfo *obd;
123 obd = OFW_BUS_GET_DEVINFO(bus, dev);
126 return (obd->obd_model);
130 ofw_bus_gen_get_name(device_t bus, device_t dev)
132 const struct ofw_bus_devinfo *obd;
134 obd = OFW_BUS_GET_DEVINFO(bus, dev);
137 return (obd->obd_name);
141 ofw_bus_gen_get_node(device_t bus, device_t dev)
143 const struct ofw_bus_devinfo *obd;
145 obd = OFW_BUS_GET_DEVINFO(bus, dev);
147 return ((phandle_t)-1);
148 return (obd->obd_node);
152 ofw_bus_gen_get_type(device_t bus, device_t dev)
154 const struct ofw_bus_devinfo *obd;
156 obd = OFW_BUS_GET_DEVINFO(bus, dev);
159 return (obd->obd_type);
163 ofw_bus_get_status(device_t dev)
165 const struct ofw_bus_devinfo *obd;
167 obd = OFW_BUS_GET_DEVINFO(device_get_parent(dev), dev);
171 return (obd->obd_status);
175 ofw_bus_status_okay(device_t dev)
179 status = ofw_bus_get_status(dev);
180 if (status == NULL || strcmp(status, "okay") == 0 ||
181 strcmp(status, "ok") == 0)
188 ofw_bus_node_status_okay(phandle_t node)
190 char status[OFW_STATUS_LEN];
193 len = OF_getproplen(node, "status");
197 OF_getprop(node, "status", status, OFW_STATUS_LEN);
198 if ((len == 5 && (bcmp(status, "okay", len) == 0)) ||
199 (len == 3 && (bcmp(status, "ok", len))))
206 ofw_bus_node_is_compatible_int(const char *compat, int len,
207 const char *onecompat)
211 onelen = strlen(onecompat);
215 if (strlen(compat) == onelen &&
216 strncasecmp(compat, onecompat, onelen) == 0) {
222 /* Slide to the next sub-string. */
223 l = strlen(compat) + 1;
232 ofw_bus_node_is_compatible(phandle_t node, const char *compatstr)
234 char compat[OFW_COMPAT_LEN];
237 if ((len = OF_getproplen(node, "compatible")) <= 0)
240 bzero(compat, OFW_COMPAT_LEN);
242 if (OF_getprop(node, "compatible", compat, OFW_COMPAT_LEN) < 0)
245 rv = ofw_bus_node_is_compatible_int(compat, len, compatstr);
251 ofw_bus_is_compatible(device_t dev, const char *onecompat)
257 if ((compat = ofw_bus_get_compat(dev)) == NULL)
260 if ((node = ofw_bus_get_node(dev)) == -1)
263 /* Get total 'compatible' prop len */
264 if ((len = OF_getproplen(node, "compatible")) <= 0)
267 return (ofw_bus_node_is_compatible_int(compat, len, onecompat));
271 ofw_bus_is_compatible_strict(device_t dev, const char *compatible)
276 if ((compat = ofw_bus_get_compat(dev)) == NULL)
279 len = strlen(compatible);
280 if (strlen(compat) == len &&
281 strncasecmp(compat, compatible, len) == 0)
287 const struct ofw_compat_data *
288 ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat)
294 for (; compat->ocd_str != NULL; ++compat) {
295 if (ofw_bus_is_compatible(dev, compat->ocd_str))
303 ofw_bus_has_prop(device_t dev, const char *propname)
307 if ((node = ofw_bus_get_node(dev)) == -1)
310 return (OF_hasprop(node, propname));
314 ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz)
319 if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1)
321 ii->opi_addrc = addrc * sizeof(pcell_t);
323 ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map",
324 (void **)&ii->opi_imap);
325 if (ii->opi_imapsz > 0) {
326 msksz = OF_getencprop_alloc(node, "interrupt-map-mask",
327 (void **)&ii->opi_imapmsk);
329 * Failure to get the mask is ignored; a full mask is used
330 * then. We barf on bad mask sizes, however.
332 if (msksz != -1 && msksz != ii->opi_addrc + intrsz)
333 panic("ofw_bus_setup_iinfo: bad interrupt-map-mask "
339 ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg,
340 int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz,
343 uint8_t maskbuf[regsz + pintrsz];
346 if (ii->opi_imapsz <= 0)
348 KASSERT(regsz >= ii->opi_addrc,
349 ("ofw_bus_lookup_imap: register size too small: %d < %d",
350 regsz, ii->opi_addrc));
352 rv = OF_getencprop(node, "reg", reg, regsz);
354 panic("ofw_bus_lookup_imap: cannot get reg property");
356 return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc,
357 ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr,
362 * Map an interrupt using the firmware reg, interrupt-map and
363 * interrupt-map-mask properties.
364 * The interrupt property to be mapped must be of size intrsz, and pointed to
365 * by intr. The regs property of the node for which the mapping is done must
366 * be passed as regs. This property is an array of register specifications;
367 * the size of the address part of such a specification must be passed as
368 * physsz. Only the first element of the property is used.
369 * imap and imapsz hold the interrupt mask and it's size.
370 * imapmsk is a pointer to the interrupt-map-mask property, which must have
371 * a size of physsz + intrsz; it may be NULL, in which case a full mask is
373 * maskbuf must point to a buffer of length physsz + intrsz.
374 * The interrupt is returned in result, which must point to a buffer of length
375 * rintrsz (which gives the expected size of the mapped interrupt).
376 * Returns number of cells in the interrupt if a mapping was found, 0 otherwise.
379 ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz,
380 void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result,
381 int rintrsz, phandle_t *iparent)
384 uint8_t *ref = maskbuf;
385 uint8_t *uiintr = intr;
386 uint8_t *uiregs = regs;
387 uint8_t *uiimapmsk = imapmsk;
393 if (imapmsk != NULL) {
394 for (i = 0; i < physsz; i++)
395 ref[i] = uiregs[i] & uiimapmsk[i];
396 for (i = 0; i < intrsz; i++)
397 ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i];
399 bcopy(regs, ref, physsz);
400 bcopy(intr, ref + physsz, intrsz);
407 bcopy(mptr + physsz + intrsz, &parent, sizeof(parent));
408 #ifndef OFW_IMAP_NO_IPARENT_ADDR_CELLS
410 * Find if we need to read the parent address data.
411 * CHRP-derived OF bindings, including ePAPR-compliant FDTs,
412 * use this as an optional part of the specifier.
414 if (OF_getencprop(OF_node_from_xref(parent),
415 "#address-cells", &paddrsz, sizeof(paddrsz)) == -1)
416 paddrsz = 0; /* default */
417 paddrsz *= sizeof(pcell_t);
420 if (OF_searchencprop(OF_node_from_xref(parent),
421 "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1)
422 pintrsz = 1; /* default */
423 pintrsz *= sizeof(pcell_t);
425 /* Compute the map stride size. */
426 tsz = physsz + intrsz + sizeof(phandle_t) + paddrsz + pintrsz;
427 KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map"));
429 if (bcmp(ref, mptr, physsz + intrsz) == 0) {
430 bcopy(mptr + physsz + intrsz + sizeof(parent) + paddrsz,
431 result, MIN(rintrsz, pintrsz));
435 return (pintrsz/sizeof(pcell_t));
444 ofw_bus_msimap(phandle_t node, uint16_t pci_rid, phandle_t *msi_parent,
447 pcell_t *map, mask, msi_base, rid_base, rid_length;
452 /* TODO: This should be OF_searchprop_alloc if we had it */
453 len = OF_getencprop_alloc_multi(node, "msi-map", sizeof(*map),
456 if (msi_parent != NULL) {
458 OF_getencprop(node, "msi-parent", msi_parent,
459 sizeof(*msi_parent));
468 OF_getencprop(node, "msi-map-mask", &mask, sizeof(mask));
470 masked_rid = pci_rid & mask;
471 for (i = 0; i < len; i += 4) {
472 rid_base = map[i + 0];
473 rid_length = map[i + 3];
475 if (masked_rid < rid_base ||
476 masked_rid >= (rid_base + rid_length))
479 msi_base = map[i + 2];
481 if (msi_parent != NULL)
482 *msi_parent = map[i + 1];
484 *msi_rid = masked_rid - rid_base + msi_base;
489 free(map, M_OFWPROP);
495 ofw_bus_iommu_map(phandle_t node, uint16_t pci_rid, phandle_t *iommu_parent,
498 pcell_t *map, mask, iommu_base, rid_base, rid_length;
503 len = OF_getencprop_alloc_multi(node, "iommu-map", sizeof(*map),
510 OF_getencprop(node, "iommu-map-mask", &mask, sizeof(mask));
512 masked_rid = pci_rid & mask;
513 for (i = 0; i < len; i += 4) {
514 rid_base = map[i + 0];
515 rid_length = map[i + 3];
517 if (masked_rid < rid_base ||
518 masked_rid >= (rid_base + rid_length))
521 iommu_base = map[i + 2];
523 if (iommu_parent != NULL)
524 *iommu_parent = map[i + 1];
525 if (iommu_rid != NULL)
526 *iommu_rid = masked_rid - rid_base + iommu_base;
531 free(map, M_OFWPROP);
537 ofw_bus_reg_to_rl_helper(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
538 struct resource_list *rl, const char *reg_source)
541 ssize_t i, j, rid, nreg, ret;
546 * This may be just redundant when having ofw_bus_devinfo
547 * but makes this routine independent of it.
549 ret = OF_getprop_alloc(node, "name", (void **)&name);
553 ret = OF_getencprop_alloc_multi(node, reg_source, sizeof(*reg),
555 nreg = (ret == -1) ? 0 : ret;
557 if (nreg % (acells + scells) != 0) {
559 device_printf(dev, "Malformed reg property on <%s>\n",
560 (name == NULL) ? "unknown" : name);
564 for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) {
566 for (j = 0; j < acells; j++) {
570 for (j = 0; j < scells; j++) {
572 size |= reg[i + acells + j];
574 /* Skip the dummy reg property of glue devices like ssm(4). */
576 resource_list_add(rl, SYS_RES_MEMORY, rid,
577 phys, phys + size - 1, size);
579 free(name, M_OFWPROP);
580 free(reg, M_OFWPROP);
586 ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
587 struct resource_list *rl)
590 return (ofw_bus_reg_to_rl_helper(dev, node, acells, scells, rl, "reg"));
594 ofw_bus_assigned_addresses_to_rl(device_t dev, phandle_t node, pcell_t acells,
595 pcell_t scells, struct resource_list *rl)
598 return (ofw_bus_reg_to_rl_helper(dev, node, acells, scells,
599 rl, "assigned-addresses"));
603 * Get interrupt parent for given node.
604 * Returns 0 if interrupt parent doesn't exist.
607 ofw_bus_find_iparent(phandle_t node)
611 if (OF_searchencprop(node, "interrupt-parent", &iparent,
612 sizeof(iparent)) == -1) {
613 for (iparent = node; iparent != 0;
614 iparent = OF_parent(iparent)) {
615 if (OF_hasprop(iparent, "interrupt-controller"))
618 iparent = OF_xref_from_node(iparent);
624 ofw_bus_intr_to_rl(device_t dev, phandle_t node,
625 struct resource_list *rl, int *rlen)
628 uint32_t icells, *intr;
629 int err, i, irqnum, nintr, rid;
632 nintr = OF_getencprop_alloc_multi(node, "interrupts", sizeof(*intr),
635 iparent = ofw_bus_find_iparent(node);
637 device_printf(dev, "No interrupt-parent found, "
638 "assuming direct parent\n");
639 iparent = OF_parent(node);
640 iparent = OF_xref_from_node(iparent);
642 if (OF_searchencprop(OF_node_from_xref(iparent),
643 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
644 device_printf(dev, "Missing #interrupt-cells "
645 "property, assuming <1>\n");
648 if (icells < 1 || icells > nintr) {
649 device_printf(dev, "Invalid #interrupt-cells property "
650 "value <%d>, assuming <1>\n", icells);
655 nintr = OF_getencprop_alloc_multi(node, "interrupts-extended",
656 sizeof(*intr), (void **)&intr);
663 for (i = 0; i < nintr; i += icells) {
666 if (OF_searchencprop(OF_node_from_xref(iparent),
667 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
668 device_printf(dev, "Missing #interrupt-cells "
673 if (icells < 1 || (i + icells) > nintr) {
674 device_printf(dev, "Invalid #interrupt-cells "
675 "property value <%d>\n", icells);
680 irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]);
681 resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1);
685 free(intr, M_OFWPROP);
690 ofw_bus_intr_by_rid(device_t dev, phandle_t node, int wanted_rid,
691 phandle_t *producer, int *ncells, pcell_t **cells)
694 uint32_t icells, *intr;
695 int err, i, nintr, rid;
698 nintr = OF_getencprop_alloc_multi(node, "interrupts", sizeof(*intr),
701 iparent = ofw_bus_find_iparent(node);
703 device_printf(dev, "No interrupt-parent found, "
704 "assuming direct parent\n");
705 iparent = OF_parent(node);
706 iparent = OF_xref_from_node(iparent);
708 if (OF_searchencprop(OF_node_from_xref(iparent),
709 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
710 device_printf(dev, "Missing #interrupt-cells "
711 "property, assuming <1>\n");
714 if (icells < 1 || icells > nintr) {
715 device_printf(dev, "Invalid #interrupt-cells property "
716 "value <%d>, assuming <1>\n", icells);
721 nintr = OF_getencprop_alloc_multi(node, "interrupts-extended",
722 sizeof(*intr), (void **)&intr);
729 for (i = 0; i < nintr; i += icells, rid++) {
732 if (OF_searchencprop(OF_node_from_xref(iparent),
733 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
734 device_printf(dev, "Missing #interrupt-cells "
739 if (icells < 1 || (i + icells) > nintr) {
740 device_printf(dev, "Invalid #interrupt-cells "
741 "property value <%d>\n", icells);
746 if (rid == wanted_rid) {
747 *cells = malloc(icells * sizeof(**cells), M_OFWPROP,
751 memcpy(*cells, intr + i, icells * sizeof(**cells));
756 free(intr, M_OFWPROP);
761 ofw_bus_find_child(phandle_t start, const char *child_name)
767 for (child = OF_child(start); child != 0; child = OF_peer(child)) {
768 ret = OF_getprop_alloc(child, "name", (void **)&name);
771 if (strcmp(name, child_name) == 0) {
772 free(name, M_OFWPROP);
776 free(name, M_OFWPROP);
783 ofw_bus_find_compatible(phandle_t node, const char *onecompat)
785 phandle_t child, ret;
788 * Traverse all children of 'start' node, and find first with
789 * matching 'compatible' property.
791 for (child = OF_child(node); child != 0; child = OF_peer(child)) {
792 if (ofw_bus_node_is_compatible(child, onecompat) != 0)
795 ret = ofw_bus_find_compatible(child, onecompat);
803 * @brief Return child of bus whose phandle is node
805 * A direct child of @p will be returned if it its phandle in the
806 * OFW tree is @p node. Otherwise, NULL is returned.
808 * @param bus The bus to examine
809 * @param node The phandle_t to look for.
812 ofw_bus_find_child_device_by_phandle(device_t bus, phandle_t node)
814 device_t *children, retval, child;
818 * Nothing can match the flag value for no node.
824 * Search the children for a match. We microoptimize
825 * a bit by not using ofw_bus_get since we already know
826 * the parent. We do not recurse.
828 if (device_get_children(bus, &children, &nkid) != 0)
831 for (i = 0; i < nkid; i++) {
833 if (OFW_BUS_GET_NODE(bus, child) == node) {
838 free(children, M_TEMP);
844 * Parse property that contain list of xrefs and values
845 * (like standard "clocks" and "resets" properties)
847 * node - consumers device node
848 * list_name - name of parsed list - "clocks"
849 * cells_name - name of size property - "#clock-cells"
850 * idx - the index of the requested list entry, or, if -1, an indication
851 * to return the number of entries in the parsed list.
853 * producer - handle of producer
854 * ncells - number of cells in result or the number of items in the list when
856 * cells - array of decoded cells
859 ofw_bus_parse_xref_list_internal(phandle_t node, const char *list_name,
860 const char *cells_name, int idx, phandle_t *producer, int *ncells,
866 int rv, i, j, nelems, cnt;
869 nelems = OF_getencprop_alloc_multi(node, list_name, sizeof(*elems),
873 rv = (idx == -1) ? 0 : ENOENT;
874 for (i = 0, cnt = 0; i < nelems; i += pcells, cnt++) {
876 if (OF_getencprop(OF_node_from_xref(pnode),
877 cells_name, &pcells, sizeof(pcells)) == -1) {
878 printf("Missing %s property\n", cells_name);
883 if ((i + pcells) > nelems) {
884 printf("Invalid %s property value <%d>\n", cells_name,
890 *cells= malloc(pcells * sizeof(**cells), M_OFWPROP,
894 for (j = 0; j < pcells; j++)
895 (*cells)[j] = elems[i + j];
901 free(elems, M_OFWPROP);
902 if (idx == -1 && rv == 0)
908 * Parse property that contain list of xrefs and values
909 * (like standard "clocks" and "resets" properties)
911 * node - consumers device node
912 * list_name - name of parsed list - "clocks"
913 * cells_name - name of size property - "#clock-cells"
914 * idx - the index of the requested list entry (>= 0)
916 * producer - handle of producer
917 * ncells - number of cells in result
918 * cells - array of decoded cells
921 ofw_bus_parse_xref_list_alloc(phandle_t node, const char *list_name,
922 const char *cells_name, int idx, phandle_t *producer, int *ncells,
927 ("ofw_bus_parse_xref_list_alloc: negative index supplied"));
929 return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
930 idx, producer, ncells, cells));
934 * Parse property that contain list of xrefs and values
935 * (like standard "clocks" and "resets" properties)
936 * and determine the number of items in the list
938 * node - consumers device node
939 * list_name - name of parsed list - "clocks"
940 * cells_name - name of size property - "#clock-cells"
942 * count - number of items in list
945 ofw_bus_parse_xref_list_get_length(phandle_t node, const char *list_name,
946 const char *cells_name, int *count)
949 return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
950 -1, NULL, count, NULL));
954 * Find index of string in string list property (case sensitive).
957 ofw_bus_find_string_index(phandle_t node, const char *list_name,
958 const char *name, int *idx)
961 int rv, i, cnt, nelems;
964 nelems = OF_getprop_alloc(node, list_name, (void **)&elems);
969 for (i = 0, cnt = 0; i < nelems; cnt++) {
970 if (strcmp(elems + i, name) == 0) {
975 i += strlen(elems + i) + 1;
979 free(elems, M_OFWPROP);
984 * Create zero terminated array of strings from string list property.
987 ofw_bus_string_list_to_array(phandle_t node, const char *list_name,
988 const char ***out_array)
992 int i, cnt, nelems, len;
995 nelems = OF_getprop_alloc(node, list_name, (void **)&elems);
999 /* Count number of strings. */
1000 for (i = 0, cnt = 0; i < nelems; cnt++)
1001 i += strlen(elems + i) + 1;
1003 /* Allocate space for arrays and all strings. */
1004 array = malloc((cnt + 1) * sizeof(char *) + nelems, M_OFWPROP,
1007 /* Get address of first string. */
1008 tptr = (char *)(array + cnt + 1);
1011 memcpy(tptr, elems, nelems);
1012 free(elems, M_OFWPROP);
1014 /* Fill string pointers. */
1015 for (i = 0, cnt = 0; i < nelems; cnt++) {
1016 len = strlen(tptr) + 1;