diff --git a/sys/isa/isavar.h b/sys/isa/isavar.h index 81ba280da457..c4ac81297e29 100644 --- a/sys/isa/isavar.h +++ b/sys/isa/isavar.h @@ -1,196 +1,196 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 1998 Doug Rabson * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _ISA_ISAVAR_H_ #define _ISA_ISAVAR_H_ struct isa_config; struct isa_pnp_id; typedef void isa_config_cb(void *arg, struct isa_config *config, int enable); #include "isa_if.h" #include #ifdef _KERNEL /* * ISA devices are partially ordered. This is to ensure that hardwired * devices the BIOS tells us are there appear first, then speculative * devices that are sensitive to the probe order, then devices that * are hinted to be there, then the most flexible devices which support * the ISA bus PNP standard. */ #define ISA_ORDER_PNPBIOS 10 /* plug-and-play BIOS inflexible hardware */ #define ISA_ORDER_SENSITIVE 20 /* legacy sensitive hardware */ #define ISA_ORDER_SPECULATIVE 30 /* legacy non-sensitive hardware */ #define ISA_ORDER_PNP 40 /* plug-and-play flexible hardware */ /* * Limits on resources that we can manage */ #define ISA_NPORT 50 #define ISA_NMEM 50 #define ISA_NIRQ 50 #define ISA_NDRQ 50 /* * Limits on resources the hardware can actually handle */ #define ISA_PNP_NPORT 8 #define ISA_PNP_NMEM 4 #define ISA_PNP_NIRQ 2 #define ISA_PNP_NDRQ 2 #define ISADMA_READ 0x00100000 #define ISADMA_WRITE 0 #define ISADMA_RAW 0x00080000 /* * Plug and play cards can support a range of resource * configurations. This structure is used by the isapnp parser to * inform the isa bus about the resource possibilities of the * device. Each different alternative should be supplied by calling * ISA_ADD_CONFIG(). */ struct isa_range { - u_int32_t ir_start; - u_int32_t ir_end; - u_int32_t ir_size; - u_int32_t ir_align; + uint32_t ir_start; + uint32_t ir_end; + uint32_t ir_size; + uint32_t ir_align; }; struct isa_config { struct isa_range ic_mem[ISA_NMEM]; struct isa_range ic_port[ISA_NPORT]; - u_int32_t ic_irqmask[ISA_NIRQ]; - u_int32_t ic_drqmask[ISA_NDRQ]; + uint32_t ic_irqmask[ISA_NIRQ]; + uint32_t ic_drqmask[ISA_NDRQ]; int ic_nmem; int ic_nport; int ic_nirq; int ic_ndrq; }; /* * Used to build lists of IDs and description strings for PnP drivers. */ struct isa_pnp_id { - u_int32_t ip_id; + uint32_t ip_id; const char *ip_desc; }; enum isa_device_ivars { ISA_IVAR_PORT, ISA_IVAR_PORT_0 = ISA_IVAR_PORT, ISA_IVAR_PORT_1, ISA_IVAR_PORTSIZE, ISA_IVAR_PORTSIZE_0 = ISA_IVAR_PORTSIZE, ISA_IVAR_PORTSIZE_1, ISA_IVAR_MADDR, ISA_IVAR_MADDR_0 = ISA_IVAR_MADDR, ISA_IVAR_MADDR_1, ISA_IVAR_MEMSIZE, ISA_IVAR_MEMSIZE_0 = ISA_IVAR_MEMSIZE, ISA_IVAR_MEMSIZE_1, ISA_IVAR_IRQ, ISA_IVAR_IRQ_0 = ISA_IVAR_IRQ, ISA_IVAR_IRQ_1, ISA_IVAR_DRQ, ISA_IVAR_DRQ_0 = ISA_IVAR_DRQ, ISA_IVAR_DRQ_1, ISA_IVAR_VENDORID, ISA_IVAR_SERIAL, ISA_IVAR_LOGICALID, ISA_IVAR_COMPATID, ISA_IVAR_CONFIGATTR, ISA_IVAR_PNP_CSN, ISA_IVAR_PNP_LDN, ISA_IVAR_PNPBIOS_HANDLE }; /* * ISA_IVAR_CONFIGATTR bits */ #define ISACFGATTR_CANDISABLE (1 << 0) /* can be disabled */ #define ISACFGATTR_DYNAMIC (1 << 1) /* dynamic configuration */ #define ISACFGATTR_HINTS (1 << 3) /* source of config is hints */ #define ISA_PNP_DESCR "E:pnpid;D:#" #define ISA_PNP_INFO(t) \ MODULE_PNP_INFO(ISA_PNP_DESCR, isa, t, t, nitems(t) - 1); \ /* * Simplified accessors for isa devices */ #define ISA_ACCESSOR(var, ivar, type) \ __BUS_ACCESSOR(isa, var, ISA, ivar, type) ISA_ACCESSOR(port, PORT, int) ISA_ACCESSOR(portsize, PORTSIZE, int) ISA_ACCESSOR(irq, IRQ, int) ISA_ACCESSOR(drq, DRQ, int) ISA_ACCESSOR(maddr, MADDR, int) ISA_ACCESSOR(msize, MEMSIZE, int) ISA_ACCESSOR(vendorid, VENDORID, int) ISA_ACCESSOR(serial, SERIAL, int) ISA_ACCESSOR(logicalid, LOGICALID, int) ISA_ACCESSOR(compatid, COMPATID, int) ISA_ACCESSOR(configattr, CONFIGATTR, int) ISA_ACCESSOR(pnp_csn, PNP_CSN, int) ISA_ACCESSOR(pnp_ldn, PNP_LDN, int) ISA_ACCESSOR(pnpbios_handle, PNPBIOS_HANDLE, int) /* Device class for ISA bridges. */ extern devclass_t isab_devclass; extern void isa_probe_children(device_t dev); void isa_dmacascade(int chan); void isa_dmadone(int flags, caddr_t addr, int nbytes, int chan); int isa_dma_init(int chan, u_int bouncebufsize, int flag); void isa_dmastart(int flags, caddr_t addr, u_int nbytes, int chan); int isa_dma_acquire(int chan); void isa_dma_release(int chan); int isa_dmastatus(int chan); int isa_dmastop(int chan); int isa_dmatc(int chan); #define isa_dmainit(chan, size) do { \ if (isa_dma_init(chan, size, M_NOWAIT)) \ printf("WARNING: isa_dma_init(%d, %ju) failed\n", \ (int)(chan), (uintmax_t)(size)); \ } while (0) void isa_hinted_child(device_t parent, const char *name, int unit); void isa_hint_device_unit(device_t bus, device_t child, const char *name, int *unitp); int isab_attach(device_t dev); #endif /* _KERNEL */ #endif /* !_ISA_ISAVAR_H_ */ diff --git a/sys/isa/pnpparse.c b/sys/isa/pnpparse.c index 979389f59808..a2716f513d52 100644 --- a/sys/isa/pnpparse.c +++ b/sys/isa/pnpparse.c @@ -1,607 +1,607 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 1999 Doug Rabson * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #define MAXDEP 8 #define I16(p) ((p)[0] + ((p)[1] << 8)) #define I32(p) (I16(p) + (I16((p)+2) << 16)) void -pnp_printf(u_int32_t id, char *fmt, ...) +pnp_printf(uint32_t id, char *fmt, ...) { va_list ap; va_start(ap, fmt); printf("%s: ", pnp_eisaformat(id)); vprintf(fmt, ap); va_end(ap); } /* parse a single descriptor */ static int pnp_parse_desc(device_t dev, u_char tag, u_char *res, int len, struct isa_config *config, int ldn) { char buf[100]; - u_int32_t id; - u_int32_t compat_id; + uint32_t id; + uint32_t compat_id; int temp; id = isa_get_logicalid(dev); if (PNP_RES_TYPE(tag) == 0) { /* Small resource */ switch (PNP_SRES_NUM(tag)) { case PNP_TAG_VERSION: case PNP_TAG_VENDOR: /* these descriptors are quietly ignored */ break; case PNP_TAG_LOGICAL_DEVICE: case PNP_TAG_START_DEPENDANT: case PNP_TAG_END_DEPENDANT: if (bootverbose) pnp_printf(id, "unexpected small tag %d\n", PNP_SRES_NUM(tag)); /* shouldn't happen; quit now */ return (1); case PNP_TAG_COMPAT_DEVICE: /* * Got a compatible device id resource. * Should keep a list of compat ids in the device. */ bcopy(res, &compat_id, 4); if (isa_get_compatid(dev) == 0) isa_set_compatid(dev, compat_id); break; case PNP_TAG_IRQ_FORMAT: if (config->ic_nirq == ISA_NIRQ) { pnp_printf(id, "too many irqs\n"); return (1); } if (I16(res) == 0) { /* a null descriptor */ config->ic_irqmask[config->ic_nirq] = 0; config->ic_nirq++; break; } if (bootverbose) pnp_printf(id, "adding irq mask %#02x\n", I16(res)); config->ic_irqmask[config->ic_nirq] = I16(res); config->ic_nirq++; break; case PNP_TAG_DMA_FORMAT: if (config->ic_ndrq == ISA_NDRQ) { pnp_printf(id, "too many drqs\n"); return (1); } if (res[0] == 0) { /* a null descriptor */ config->ic_drqmask[config->ic_ndrq] = 0; config->ic_ndrq++; break; } if (bootverbose) pnp_printf(id, "adding dma mask %#02x\n", res[0]); config->ic_drqmask[config->ic_ndrq] = res[0]; config->ic_ndrq++; break; case PNP_TAG_IO_RANGE: if (config->ic_nport == ISA_NPORT) { pnp_printf(id, "too many ports\n"); return (1); } if (res[6] == 0) { /* a null descriptor */ config->ic_port[config->ic_nport].ir_start = 0; config->ic_port[config->ic_nport].ir_end = 0; config->ic_port[config->ic_nport].ir_size = 0; config->ic_port[config->ic_nport].ir_align = 0; config->ic_nport++; break; } if (bootverbose) { pnp_printf(id, "adding io range " "%#x-%#x, size=%#x, " "align=%#x\n", I16(res + 1), I16(res + 3) + res[6]-1, res[6], res[5]); } config->ic_port[config->ic_nport].ir_start = I16(res + 1); config->ic_port[config->ic_nport].ir_end = I16(res + 3) + res[6] - 1; config->ic_port[config->ic_nport].ir_size = res[6]; if (res[5] == 0) { /* Make sure align is at least one */ res[5] = 1; } config->ic_port[config->ic_nport].ir_align = res[5]; config->ic_nport++; pnp_check_quirks(isa_get_vendorid(dev), isa_get_logicalid(dev), ldn, config); break; case PNP_TAG_IO_FIXED: if (config->ic_nport == ISA_NPORT) { pnp_printf(id, "too many ports\n"); return (1); } if (res[2] == 0) { /* a null descriptor */ config->ic_port[config->ic_nport].ir_start = 0; config->ic_port[config->ic_nport].ir_end = 0; config->ic_port[config->ic_nport].ir_size = 0; config->ic_port[config->ic_nport].ir_align = 0; config->ic_nport++; break; } if (bootverbose) { pnp_printf(id, "adding fixed io range " "%#x-%#x, size=%#x, " "align=%#x\n", I16(res), I16(res) + res[2] - 1, res[2], 1); } config->ic_port[config->ic_nport].ir_start = I16(res); config->ic_port[config->ic_nport].ir_end = I16(res) + res[2] - 1; config->ic_port[config->ic_nport].ir_size = res[2]; config->ic_port[config->ic_nport].ir_align = 1; config->ic_nport++; break; case PNP_TAG_END: if (bootverbose) pnp_printf(id, "end config\n"); return (1); default: /* Skip this resource */ pnp_printf(id, "unexpected small tag %d\n", PNP_SRES_NUM(tag)); break; } } else { /* Large resource */ switch (PNP_LRES_NUM(tag)) { case PNP_TAG_ID_UNICODE: case PNP_TAG_LARGE_VENDOR: /* these descriptors are quietly ignored */ break; case PNP_TAG_ID_ANSI: if (len > sizeof(buf) - 1) len = sizeof(buf) - 1; bcopy(res, buf, len); /* * Trim trailing spaces and garbage. */ while (len > 0 && buf[len - 1] <= ' ') len--; buf[len] = '\0'; device_set_desc_copy(dev, buf); break; case PNP_TAG_MEMORY_RANGE: if (config->ic_nmem == ISA_NMEM) { pnp_printf(id, "too many memory ranges\n"); return (1); } if (I16(res + 7) == 0) { /* a null descriptor */ config->ic_mem[config->ic_nmem].ir_start = 0; config->ic_mem[config->ic_nmem].ir_end = 0; config->ic_mem[config->ic_nmem].ir_size = 0; config->ic_mem[config->ic_nmem].ir_align = 0; config->ic_nmem++; break; } if (bootverbose) { temp = I16(res + 7) << 8; pnp_printf(id, "adding memory range " "%#x-%#x, size=%#x, " "align=%#x\n", I16(res + 1) << 8, (I16(res + 3) << 8) + temp - 1, temp, I16(res + 5)); } config->ic_mem[config->ic_nmem].ir_start = I16(res + 1) << 8; config->ic_mem[config->ic_nmem].ir_end = (I16(res + 3) << 8) + (I16(res + 7) << 8) - 1; config->ic_mem[config->ic_nmem].ir_size = I16(res + 7) << 8; config->ic_mem[config->ic_nmem].ir_align = I16(res + 5); if (!config->ic_mem[config->ic_nmem].ir_align) config->ic_mem[config->ic_nmem].ir_align = 0x10000; config->ic_nmem++; break; case PNP_TAG_MEMORY32_RANGE: if (config->ic_nmem == ISA_NMEM) { pnp_printf(id, "too many memory ranges\n"); return (1); } if (I32(res + 13) == 0) { /* a null descriptor */ config->ic_mem[config->ic_nmem].ir_start = 0; config->ic_mem[config->ic_nmem].ir_end = 0; config->ic_mem[config->ic_nmem].ir_size = 0; config->ic_mem[config->ic_nmem].ir_align = 0; config->ic_nmem++; break; } if (bootverbose) { pnp_printf(id, "adding memory32 range " "%#x-%#x, size=%#x, " "align=%#x\n", I32(res + 1), I32(res + 5) + I32(res + 13) - 1, I32(res + 13), I32(res + 9)); } config->ic_mem[config->ic_nmem].ir_start = I32(res + 1); config->ic_mem[config->ic_nmem].ir_end = I32(res + 5) + I32(res + 13) - 1; config->ic_mem[config->ic_nmem].ir_size = I32(res + 13); config->ic_mem[config->ic_nmem].ir_align = I32(res + 9); config->ic_nmem++; break; case PNP_TAG_MEMORY32_FIXED: if (config->ic_nmem == ISA_NMEM) { pnp_printf(id, "too many memory ranges\n"); return (1); } if (I32(res + 5) == 0) { /* a null descriptor */ config->ic_mem[config->ic_nmem].ir_start = 0; config->ic_mem[config->ic_nmem].ir_end = 0; config->ic_mem[config->ic_nmem].ir_size = 0; config->ic_mem[config->ic_nmem].ir_align = 0; break; } if (bootverbose) { pnp_printf(id, "adding fixed memory32 range " "%#x-%#x, size=%#x\n", I32(res + 1), I32(res + 1) + I32(res + 5) - 1, I32(res + 5)); } config->ic_mem[config->ic_nmem].ir_start = I32(res + 1); config->ic_mem[config->ic_nmem].ir_end = I32(res + 1) + I32(res + 5) - 1; config->ic_mem[config->ic_nmem].ir_size = I32(res + 5); config->ic_mem[config->ic_nmem].ir_align = 1; config->ic_nmem++; break; default: /* Skip this resource */ pnp_printf(id, "unexpected large tag %d\n", PNP_SRES_NUM(tag)); break; } } return (0); } /* * Parse a single "dependent" resource combination. */ u_char *pnp_parse_dependant(device_t dev, u_char *resources, int len, struct isa_config *config, int ldn) { return pnp_scan_resources(dev, resources, len, config, ldn, pnp_parse_desc); } static void pnp_merge_resources(device_t dev, struct isa_config *from, struct isa_config *to) { device_t parent; int i; parent = device_get_parent(dev); for (i = 0; i < from->ic_nmem; i++) { if (to->ic_nmem == ISA_NMEM) { device_printf(parent, "too many memory ranges\n"); return; } to->ic_mem[to->ic_nmem] = from->ic_mem[i]; to->ic_nmem++; } for (i = 0; i < from->ic_nport; i++) { if (to->ic_nport == ISA_NPORT) { device_printf(parent, "too many port ranges\n"); return; } to->ic_port[to->ic_nport] = from->ic_port[i]; to->ic_nport++; } for (i = 0; i < from->ic_nirq; i++) { if (to->ic_nirq == ISA_NIRQ) { device_printf(parent, "too many irq ranges\n"); return; } to->ic_irqmask[to->ic_nirq] = from->ic_irqmask[i]; to->ic_nirq++; } for (i = 0; i < from->ic_ndrq; i++) { if (to->ic_ndrq == ISA_NDRQ) { device_printf(parent, "too many drq ranges\n"); return; } to->ic_drqmask[to->ic_ndrq] = from->ic_drqmask[i]; to->ic_ndrq++; } } /* * Parse resource data for Logical Devices, make a list of available * resource configurations, and add them to the device. * * This function exits as soon as it gets an error reading *ANY* * Resource Data or it reaches the end of Resource Data. */ void pnp_parse_resources(device_t dev, u_char *resources, int len, int ldn) { struct isa_config *configs; struct isa_config *config; device_t parent; int priorities[1 + MAXDEP]; u_char *start; u_char *p; u_char tag; - u_int32_t id; + uint32_t id; int ncfgs; int l; int i; parent = device_get_parent(dev); id = isa_get_logicalid(dev); configs = (struct isa_config *)malloc(sizeof(*configs)*(1 + MAXDEP), M_DEVBUF, M_NOWAIT | M_ZERO); if (configs == NULL) { device_printf(parent, "No memory to parse PNP data\n"); return; } config = &configs[0]; priorities[0] = 0; ncfgs = 1; p = resources; start = NULL; while (len > 0) { tag = *p++; len--; if (PNP_RES_TYPE(tag) == 0) { /* Small resource */ l = PNP_SRES_LEN(tag); if (len < l) { len = 0; continue; } len -= l; switch (PNP_SRES_NUM(tag)) { case PNP_TAG_START_DEPENDANT: if (start != NULL) { /* * Copy the common resources first, * then parse the "dependent" resources. */ pnp_merge_resources(dev, &configs[0], config); pnp_parse_dependant(dev, start, p - start - 1, config, ldn); } start = p + l; if (ncfgs > MAXDEP) { device_printf(parent, "too many dependent configs (%d)\n", MAXDEP); len = 0; break; } config = &configs[ncfgs]; /* * If the priority is not specified, * then use the default of 'acceptable' */ if (l > 0) priorities[ncfgs] = p[0]; else priorities[ncfgs] = 1; if (bootverbose) pnp_printf(id, "start dependent (%d)\n", priorities[ncfgs]); ncfgs++; break; case PNP_TAG_END_DEPENDANT: if (start == NULL) { device_printf(parent, "malformed resources\n"); len = 0; break; } /* * Copy the common resources first, * then parse the "dependent" resources. */ pnp_merge_resources(dev, &configs[0], config); pnp_parse_dependant(dev, start, p - start - 1, config, ldn); start = NULL; if (bootverbose) pnp_printf(id, "end dependent\n"); /* * Back to the common part; clear it * as its contents has already been copied * to each dependent. */ config = &configs[0]; bzero(config, sizeof(*config)); break; case PNP_TAG_END: if (start != NULL) { device_printf(parent, "malformed resources\n"); } len = 0; break; default: if (start != NULL) /* defer parsing a dependent section */ break; if (pnp_parse_desc(dev, tag, p, l, config, ldn)) len = 0; break; } p += l; } else { /* Large resource */ if (len < 2) { len = 0; break; } l = I16(p); p += 2; len -= 2; if (len < l) { len = 0; break; } len -= l; if (start == NULL && pnp_parse_desc(dev, tag, p, l, config, ldn)) { len = 0; break; } p += l; } } if (ncfgs == 1) { /* Single config without dependants */ ISA_ADD_CONFIG(parent, dev, priorities[0], &configs[0]); free(configs, M_DEVBUF); return; } for (i = 1; i < ncfgs; i++) { /* * Merge the remaining part of the common resources, * if any. Strictly speaking, there shouldn't be common/main * resources after the END_DEPENDENT tag. */ pnp_merge_resources(dev, &configs[0], &configs[i]); ISA_ADD_CONFIG(parent, dev, priorities[i], &configs[i]); } free(configs, M_DEVBUF); } u_char *pnp_scan_resources(device_t dev, u_char *resources, int len, struct isa_config *config, int ldn, pnp_scan_cb *cb) { u_char *p; u_char tag; int l; p = resources; while (len > 0) { tag = *p++; len--; if (PNP_RES_TYPE(tag) == 0) { /* small resource */ l = PNP_SRES_LEN(tag); if (len < l) break; if ((*cb)(dev, tag, p, l, config, ldn)) return (p + l); if (PNP_SRES_NUM(tag) == PNP_TAG_END) return (p + l); } else { /* large resource */ if (len < 2) break; l = I16(p); p += 2; len -= 2; if (len < l) break; if ((*cb)(dev, tag, p, l, config, ldn)) return (p + l); } p += l; len -= l; } return NULL; }