The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/isa/pnpparse.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1999 Doug Rabson
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  *      $FreeBSD: releng/5.0/sys/isa/pnpparse.c 105220 2002-10-16 09:07:30Z phk $
   27  */
   28 
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/malloc.h>
   32 #include <sys/module.h>
   33 #include <sys/bus.h>
   34 
   35 #include <machine/stdarg.h>
   36 
   37 #include <isa/isavar.h>
   38 #include <isa/pnpreg.h>
   39 #include <isa/pnpvar.h>
   40 
   41 #define MAXDEP  8
   42 
   43 #define I16(p)  ((p)[0] + ((p)[1] << 8))
   44 #define I32(p)  (I16(p) + (I16((p)+2) << 16))
   45 
   46 void
   47 pnp_printf(u_int32_t id, char *fmt, ...)
   48 {
   49         va_list ap;
   50 
   51         va_start(ap, fmt);
   52         printf("%s: ", pnp_eisaformat(id));
   53         vprintf(fmt, ap);
   54         va_end(ap);
   55 }
   56 
   57 /* parse a single descriptor */
   58 
   59 static int
   60 pnp_parse_desc(device_t dev, u_char tag, u_char *res, int len,
   61                struct isa_config *config, int ldn)
   62 {
   63         char buf[100];
   64         u_int32_t id;
   65         u_int32_t compat_id;
   66         int temp;
   67 
   68         id = isa_get_logicalid(dev);
   69 
   70         if (PNP_RES_TYPE(tag) == 0) {
   71 
   72                 /* Small resource */
   73                 switch (PNP_SRES_NUM(tag)) {
   74 
   75                 case PNP_TAG_VERSION:
   76                 case PNP_TAG_VENDOR:
   77                         /* these descriptors are quietly ignored */
   78                         break;
   79 
   80                 case PNP_TAG_LOGICAL_DEVICE:
   81                 case PNP_TAG_START_DEPENDANT:
   82                 case PNP_TAG_END_DEPENDANT:
   83                         if (bootverbose)
   84                                 pnp_printf(id, "unexpected small tag %d\n",
   85                                            PNP_SRES_NUM(tag));
   86                         /* shouldn't happen; quit now */
   87                         return (1);
   88 
   89                 case PNP_TAG_COMPAT_DEVICE:
   90                         /*
   91                          * Got a compatible device id resource.
   92                          * Should keep a list of compat ids in the device.
   93                          */
   94                         bcopy(res, &compat_id, 4);
   95                         if (isa_get_compatid(dev) == 0)
   96                                 isa_set_compatid(dev, compat_id);
   97                         break;
   98             
   99                 case PNP_TAG_IRQ_FORMAT:
  100                         if (config->ic_nirq == ISA_NIRQ) {
  101                                 pnp_printf(id, "too many irqs\n");
  102                                 return (1);
  103                         }
  104                         if (I16(res) == 0) {
  105                                 /* a null descriptor */
  106                                 config->ic_irqmask[config->ic_nirq] = 0;
  107                                 config->ic_nirq++;
  108                                 break;
  109                         }
  110                         if (bootverbose)
  111                                 pnp_printf(id, "adding irq mask %#02x\n",
  112                                            I16(res));
  113                         config->ic_irqmask[config->ic_nirq] = I16(res);
  114                         config->ic_nirq++;
  115                         break;
  116 
  117                 case PNP_TAG_DMA_FORMAT:
  118                         if (config->ic_ndrq == ISA_NDRQ) {
  119                                 pnp_printf(id, "too many drqs\n");
  120                                 return (1);
  121                         }
  122                         if (res[0] == 0) {
  123                                 /* a null descriptor */
  124                                 config->ic_drqmask[config->ic_ndrq] = 0;
  125                                 config->ic_ndrq++;
  126                                 break;
  127                         }
  128                         if (bootverbose)
  129                                 pnp_printf(id, "adding dma mask %#02x\n",
  130                                            res[0]);
  131                         config->ic_drqmask[config->ic_ndrq] = res[0];
  132                         config->ic_ndrq++;
  133                         break;
  134 
  135                 case PNP_TAG_IO_RANGE:
  136                         if (config->ic_nport == ISA_NPORT) {
  137                                 pnp_printf(id, "too many ports\n");
  138                                 return (1);
  139                         }
  140                         if (res[6] == 0) {
  141                                 /* a null descriptor */
  142                                 config->ic_port[config->ic_nport].ir_start = 0;
  143                                 config->ic_port[config->ic_nport].ir_end = 0;
  144                                 config->ic_port[config->ic_nport].ir_size = 0;
  145                                 config->ic_port[config->ic_nport].ir_align = 0;
  146                                 config->ic_nport++;
  147                                 break;
  148                         }
  149                         if (bootverbose) {
  150                                 pnp_printf(id, "adding io range "
  151                                            "%#x-%#x, size=%#x, "
  152                                            "align=%#x\n",
  153                                            I16(res + 1),
  154                                            I16(res + 3) + res[6]-1,
  155                                            res[6], res[5]);
  156                         }
  157                         config->ic_port[config->ic_nport].ir_start =
  158                             I16(res + 1);
  159                         config->ic_port[config->ic_nport].ir_end =
  160                             I16(res + 3) + res[6] - 1;
  161                         config->ic_port[config->ic_nport].ir_size = res[6];
  162                         if (res[5] == 0) {
  163                             /* Make sure align is at least one */
  164                             res[5] = 1;
  165                         }
  166                         config->ic_port[config->ic_nport].ir_align = res[5];
  167                         config->ic_nport++;
  168                         pnp_check_quirks(isa_get_vendorid(dev),
  169                                          isa_get_logicalid(dev), ldn, config);
  170                         break;
  171 
  172                 case PNP_TAG_IO_FIXED:
  173                         if (config->ic_nport == ISA_NPORT) {
  174                                 pnp_printf(id, "too many ports\n");
  175                                 return (1);
  176                         }
  177                         if (res[2] == 0) {
  178                                 /* a null descriptor */
  179                                 config->ic_port[config->ic_nport].ir_start = 0;
  180                                 config->ic_port[config->ic_nport].ir_end = 0;
  181                                 config->ic_port[config->ic_nport].ir_size = 0;
  182                                 config->ic_port[config->ic_nport].ir_align = 0;
  183                                 config->ic_nport++;
  184                                 break;
  185                         }
  186                         if (bootverbose) {
  187                                 pnp_printf(id, "adding fixed io range "
  188                                            "%#x-%#x, size=%#x, "
  189                                            "align=%#x\n",
  190                                            I16(res),
  191                                            I16(res) + res[2] - 1,
  192                                            res[2], 1);
  193                         }
  194                         config->ic_port[config->ic_nport].ir_start = I16(res);
  195                         config->ic_port[config->ic_nport].ir_end =
  196                             I16(res) + res[2] - 1;
  197                         config->ic_port[config->ic_nport].ir_size = res[2];
  198                         config->ic_port[config->ic_nport].ir_align = 1;
  199                         config->ic_nport++;
  200                         break;
  201 
  202                 case PNP_TAG_END:
  203                         if (bootverbose)
  204                                 pnp_printf(id, "end config\n");
  205                         return (1);
  206 
  207                 default:
  208                         /* Skip this resource */
  209                         pnp_printf(id, "unexpected small tag %d\n",
  210                                       PNP_SRES_NUM(tag));
  211                         break;
  212                 }
  213         } else {
  214                 /* Large resource */
  215                 switch (PNP_LRES_NUM(tag)) {
  216 
  217                 case PNP_TAG_ID_UNICODE:
  218                 case PNP_TAG_LARGE_VENDOR:
  219                         /* these descriptors are quietly ignored */
  220                         break;
  221 
  222                 case PNP_TAG_ID_ANSI:
  223                         if (len > sizeof(buf) - 1)
  224                                 len = sizeof(buf) - 1;
  225                         bcopy(res, buf, len);
  226 
  227                         /*
  228                          * Trim trailing spaces and garbage.
  229                          */
  230                         while (len > 0 && buf[len - 1] <= ' ')
  231                                 len--;
  232                         buf[len] = '\0';
  233                         device_set_desc_copy(dev, buf);
  234                         break;
  235                         
  236                 case PNP_TAG_MEMORY_RANGE:
  237                         if (config->ic_nmem == ISA_NMEM) {
  238                                 pnp_printf(id, "too many memory ranges\n");
  239                                 return (1);
  240                         }
  241                         if (I16(res + 7) == 0) {
  242                                 /* a null descriptor */
  243                                 config->ic_mem[config->ic_nmem].ir_start = 0;
  244                                 config->ic_mem[config->ic_nmem].ir_end = 0;
  245                                 config->ic_mem[config->ic_nmem].ir_size = 0;
  246                                 config->ic_mem[config->ic_nmem].ir_align = 0;
  247                                 config->ic_nmem++;
  248                                 break;
  249                         }
  250                         if (bootverbose) {
  251                                 temp = I16(res + 7) << 8;
  252                                 pnp_printf(id, "adding memory range "
  253                                            "%#x-%#x, size=%#x, "
  254                                            "align=%#x\n",
  255                                            I16(res + 1) << 8,
  256                                            (I16(res + 3) << 8) + temp - 1,
  257                                            temp, I16(res + 5));
  258                         }
  259                         config->ic_mem[config->ic_nmem].ir_start =
  260                             I16(res + 1) << 8;
  261                         config->ic_mem[config->ic_nmem].ir_end =
  262                             (I16(res + 3) << 8) + (I16(res + 7) << 8) - 1;
  263                         config->ic_mem[config->ic_nmem].ir_size =
  264                             I16(res + 7) << 8;
  265                         config->ic_mem[config->ic_nmem].ir_align = I16(res + 5);
  266                         if (!config->ic_mem[config->ic_nmem].ir_align)
  267                                 config->ic_mem[config->ic_nmem].ir_align =
  268                                     0x10000;
  269                         config->ic_nmem++;
  270                         break;
  271 
  272                 case PNP_TAG_MEMORY32_RANGE:
  273                         if (config->ic_nmem == ISA_NMEM) {
  274                                 pnp_printf(id, "too many memory ranges\n");
  275                                 return (1);
  276                         }
  277                         if (I32(res + 13) == 0) {
  278                                 /* a null descriptor */
  279                                 config->ic_mem[config->ic_nmem].ir_start = 0;
  280                                 config->ic_mem[config->ic_nmem].ir_end = 0;
  281                                 config->ic_mem[config->ic_nmem].ir_size = 0;
  282                                 config->ic_mem[config->ic_nmem].ir_align = 0;
  283                                 config->ic_nmem++;
  284                                 break;
  285                         }
  286                         if (bootverbose) {
  287                                 pnp_printf(id, "adding memory32 range "
  288                                            "%#x-%#x, size=%#x, "
  289                                            "align=%#x\n",
  290                                            I32(res + 1),
  291                                            I32(res + 5) + I32(res + 13) - 1,
  292                                            I32(res + 13), I32(res + 9));
  293                         }
  294                         config->ic_mem[config->ic_nmem].ir_start = I32(res + 1);
  295                         config->ic_mem[config->ic_nmem].ir_end =
  296                             I32(res + 5) + I32(res + 13) - 1;
  297                         config->ic_mem[config->ic_nmem].ir_size = I32(res + 13);
  298                         config->ic_mem[config->ic_nmem].ir_align = I32(res + 9);
  299                         config->ic_nmem++;
  300                         break;
  301 
  302                 case PNP_TAG_MEMORY32_FIXED:
  303                         if (config->ic_nmem == ISA_NMEM) {
  304                                 pnp_printf(id, "too many memory ranges\n");
  305                                 return (1);
  306                         }
  307                         if (I32(res + 5) == 0) {
  308                                 /* a null descriptor */
  309                                 config->ic_mem[config->ic_nmem].ir_start = 0;
  310                                 config->ic_mem[config->ic_nmem].ir_end = 0;
  311                                 config->ic_mem[config->ic_nmem].ir_size = 0;
  312                                 config->ic_mem[config->ic_nmem].ir_align = 0;
  313                                 break;
  314                         }
  315                         if (bootverbose) {
  316                                 pnp_printf(id, "adding fixed memory32 range "
  317                                            "%#x-%#x, size=%#x\n",
  318                                            I32(res + 1),
  319                                            I32(res + 1) + I32(res + 5) - 1,
  320                                            I32(res + 5));
  321                         }
  322                         config->ic_mem[config->ic_nmem].ir_start = I32(res + 1);
  323                         config->ic_mem[config->ic_nmem].ir_end =
  324                             I32(res + 1) + I32(res + 5) - 1;
  325                         config->ic_mem[config->ic_nmem].ir_size = I32(res + 5);
  326                         config->ic_mem[config->ic_nmem].ir_align = 1;
  327                         config->ic_nmem++;
  328                         break;
  329 
  330                 default:
  331                         /* Skip this resource */
  332                         pnp_printf(id, "unexpected large tag %d\n",
  333                                    PNP_SRES_NUM(tag));
  334                         break;
  335                 }
  336         }
  337 
  338         return (0);
  339 }
  340 
  341 /*
  342  * Parse a single "dependent" resource combination.
  343  */
  344 
  345 u_char
  346 *pnp_parse_dependant(device_t dev, u_char *resources, int len,
  347                      struct isa_config *config, int ldn)
  348 {
  349 
  350         return pnp_scan_resources(dev, resources, len, config, ldn,
  351                                   pnp_parse_desc);
  352 }
  353 
  354 static void
  355 pnp_merge_resources(device_t dev, struct isa_config *from,
  356                     struct isa_config *to)
  357 {
  358         device_t parent;
  359         int i;
  360 
  361         parent = device_get_parent(dev);
  362         for (i = 0; i < from->ic_nmem; i++) {
  363                 if (to->ic_nmem == ISA_NMEM) {
  364                         device_printf(parent, "too many memory ranges\n");
  365                         return;
  366                 }
  367                 to->ic_mem[to->ic_nmem] = from->ic_mem[i];
  368                 to->ic_nmem++;
  369         }
  370         for (i = 0; i < from->ic_nport; i++) {
  371                 if (to->ic_nport == ISA_NPORT) {
  372                         device_printf(parent, "too many port ranges\n");
  373                         return;
  374                 }
  375                 to->ic_port[to->ic_nport] = from->ic_port[i];
  376                 to->ic_nport++;
  377         }
  378         for (i = 0; i < from->ic_nirq; i++) {
  379                 if (to->ic_nirq == ISA_NIRQ) {
  380                         device_printf(parent, "too many irq ranges\n");
  381                         return;
  382                 }
  383                 to->ic_irqmask[to->ic_nirq] = from->ic_irqmask[i];
  384                 to->ic_nirq++;
  385         }
  386         for (i = 0; i < from->ic_ndrq; i++) {
  387                 if (to->ic_ndrq == ISA_NDRQ) {
  388                         device_printf(parent, "too many drq ranges\n");
  389                         return;
  390                 }
  391                 to->ic_drqmask[to->ic_ndrq] = from->ic_drqmask[i];
  392                 to->ic_ndrq++;
  393         }
  394 }
  395 
  396 /*
  397  * Parse resource data for Logical Devices, make a list of available
  398  * resource configurations, and add them to the device.
  399  *
  400  * This function exits as soon as it gets an error reading *ANY*
  401  * Resource Data or it reaches the end of Resource Data.
  402  */
  403 
  404 void
  405 pnp_parse_resources(device_t dev, u_char *resources, int len, int ldn)
  406 {
  407         struct isa_config *configs;
  408         struct isa_config *config;
  409         device_t parent;
  410         int priorities[1 + MAXDEP];
  411         u_char *start;
  412         u_char *p;
  413         u_char tag;
  414         u_int32_t id;
  415         int ncfgs;
  416         int l;
  417         int i;
  418 
  419         parent = device_get_parent(dev);
  420         id = isa_get_logicalid(dev);
  421 
  422         configs = (struct isa_config *)malloc(sizeof(*configs)*(1 + MAXDEP),
  423                                               M_DEVBUF, M_NOWAIT | M_ZERO);
  424         if (configs == NULL) {
  425                 device_printf(parent, "No memory to parse PNP data\n");
  426                 return;
  427         }
  428         config = &configs[0];
  429         priorities[0] = 0;
  430         ncfgs = 1;
  431 
  432         p = resources;
  433         start = NULL;
  434         while (len > 0) {
  435                 tag = *p++;
  436                 len--;
  437                 if (PNP_RES_TYPE(tag) == 0) {
  438                         /* Small resource */
  439                         l = PNP_SRES_LEN(tag);
  440                         if (len < l) {
  441                                 len = 0;
  442                                 continue;
  443                         }
  444                         len -= l;
  445 
  446                         switch (PNP_SRES_NUM(tag)) {
  447 
  448                         case PNP_TAG_START_DEPENDANT:
  449                                 if (start != NULL) {
  450                                         /*
  451                                          * Copy the common resources first,
  452                                          * then parse the "dependent" resources.
  453                                          */
  454                                         pnp_merge_resources(dev, &configs[0],
  455                                                             config);
  456                                         pnp_parse_dependant(dev, start,
  457                                                             p - start - 1,
  458                                                             config, ldn);
  459                                 }
  460                                 start = p + l;
  461                                 if (ncfgs > MAXDEP) {
  462                                         device_printf(parent, "too many dependant configs (%d)\n", MAXDEP);
  463                                         len = 0;
  464                                         break;
  465                                 }
  466                                 config = &configs[ncfgs];
  467                                 /*
  468                                  * If the priority is not specified,
  469                                  * then use the default of 'acceptable'
  470                                  */
  471                                 if (l > 0)
  472                                         priorities[ncfgs] = p[0];
  473                                 else
  474                                         priorities[ncfgs] = 1;
  475                                 if (bootverbose)
  476                                         pnp_printf(id, "start dependent (%d)\n",
  477                                                    priorities[ncfgs]);
  478                                 ncfgs++;
  479                                 break;
  480 
  481                         case PNP_TAG_END_DEPENDANT:
  482                                 if (start == NULL) {
  483                                         device_printf(parent,
  484                                                       "malformed resources\n");
  485                                         len = 0;
  486                                         break;
  487                                 }
  488                                 /*
  489                                  * Copy the common resources first,
  490                                  * then parse the "dependent" resources.
  491                                  */
  492                                 pnp_merge_resources(dev, &configs[0], config);
  493                                 pnp_parse_dependant(dev, start, p - start - 1,
  494                                                     config, ldn);
  495                                 start = NULL;
  496                                 if (bootverbose)
  497                                         pnp_printf(id, "end dependent\n");
  498                                 /*
  499                                  * Back to the common part; clear it
  500                                  * as its contents has already been copied
  501                                  * to each dependant.
  502                                  */
  503                                 config = &configs[0];
  504                                 bzero(config, sizeof(*config));
  505                                 break;
  506 
  507                         case PNP_TAG_END:
  508                                 if (start != NULL) {
  509                                         device_printf(parent,
  510                                                       "malformed resources\n");
  511                                 }
  512                                 len = 0;
  513                                 break;
  514 
  515                         default:
  516                                 if (start != NULL)
  517                                         /* defer parsing a dependent section */
  518                                         break;
  519                                 if (pnp_parse_desc(dev, tag, p, l, config, ldn))
  520                                         len = 0;
  521                                 break;
  522                         }
  523                         p += l;
  524                 } else {
  525                         /* Large resource */
  526                         if (len < 2) {
  527                                 len = 0;
  528                                 break;
  529                         }
  530                         l = I16(p);
  531                         p += 2;
  532                         len -= 2;
  533                         if (len < l) {
  534                                 len = 0;
  535                                 break;
  536                         }
  537                         len -= l;
  538                         if (start == NULL &&
  539                             pnp_parse_desc(dev, tag, p, l, config, ldn)) {
  540                                 len = 0;
  541                                 break;
  542                         }
  543                         p += l;
  544                 }
  545         }
  546 
  547         if (ncfgs == 1) {
  548                 /* Single config without dependants */
  549                 ISA_ADD_CONFIG(parent, dev, priorities[0], &configs[0]);
  550                 free(configs, M_DEVBUF);
  551                 return;
  552         }
  553 
  554         for (i = 1; i < ncfgs; i++) {
  555                 /*
  556                  * Merge the remaining part of the common resources,
  557                  * if any. Strictly speaking, there shouldn't be common/main
  558                  * resources after the END_DEPENDENT tag.
  559                  */
  560                 pnp_merge_resources(dev, &configs[0], &configs[i]);
  561                 ISA_ADD_CONFIG(parent, dev, priorities[i], &configs[i]);
  562         }
  563 
  564         free(configs, M_DEVBUF);
  565 }
  566 
  567 u_char
  568 *pnp_scan_resources(device_t dev, u_char *resources, int len,
  569                     struct isa_config *config, int ldn, pnp_scan_cb *cb)
  570 {
  571         u_char *p;
  572         u_char tag;
  573         int l;
  574 
  575         p = resources;
  576         while (len > 0) {
  577                 tag = *p++;
  578                 len--;
  579                 if (PNP_RES_TYPE(tag) == 0) {
  580                         /* small resource */
  581                         l = PNP_SRES_LEN(tag);
  582                         if (len < l)
  583                                 break;
  584                         if ((*cb)(dev, tag, p, l, config, ldn))
  585                                 return (p + l);
  586                         if (PNP_SRES_NUM(tag) == PNP_TAG_END)
  587                                 return (p + l);
  588                 } else {
  589                         /* large resource */
  590                         if (len < 2)
  591                                 break;
  592                         l = I16(p);
  593                         p += 2;
  594                         len -= 2;
  595                         if (len < l)
  596                                 break;
  597                         if ((*cb)(dev, tag, p, l, config, ldn))
  598                                 return (p + l);
  599                 }
  600                 p += l;
  601                 len -= l;
  602         }
  603         return NULL;
  604 }

Cache object: 65b516a3f5f56b1fd04d29c357501c46


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.