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/compat/ndis/kern_ndis.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2003
    3  *      Bill Paul <wpaul@windriver.com>.  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  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by Bill Paul.
   16  * 4. Neither the name of the author nor the names of any co-contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
   24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   30  * THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   32 
   33 #include <sys/cdefs.h>
   34 __FBSDID("$FreeBSD: releng/8.0/sys/compat/ndis/kern_ndis.c 194677 2009-06-23 02:19:59Z thompsa $");
   35 
   36 #include <sys/param.h>
   37 #include <sys/systm.h>
   38 #include <sys/unistd.h>
   39 #include <sys/types.h>
   40 #include <sys/errno.h>
   41 #include <sys/callout.h>
   42 #include <sys/socket.h>
   43 #include <sys/queue.h>
   44 #include <sys/sysctl.h>
   45 #include <sys/proc.h>
   46 #include <sys/malloc.h>
   47 #include <sys/lock.h>
   48 #include <sys/mutex.h>
   49 #include <sys/conf.h>
   50 
   51 #include <sys/kernel.h>
   52 #include <sys/module.h>
   53 #include <sys/kthread.h>
   54 #include <machine/bus.h>
   55 #include <machine/resource.h>
   56 #include <sys/bus.h>
   57 #include <sys/rman.h>
   58 
   59 #include <net/if.h>
   60 #include <net/if_arp.h>
   61 #include <net/ethernet.h>
   62 #include <net/if_dl.h>
   63 #include <net/if_media.h>
   64 
   65 #include <net80211/ieee80211_var.h>
   66 #include <net80211/ieee80211_ioctl.h>
   67 
   68 #include <dev/usb/usb.h>
   69 #include <dev/usb/usbdi.h>
   70 
   71 #include <compat/ndis/pe_var.h>
   72 #include <compat/ndis/cfg_var.h>
   73 #include <compat/ndis/resource_var.h>
   74 #include <compat/ndis/ntoskrnl_var.h>
   75 #include <compat/ndis/ndis_var.h>
   76 #include <compat/ndis/hal_var.h>
   77 #include <compat/ndis/usbd_var.h>
   78 #include <dev/if_ndis/if_ndisvar.h>
   79 
   80 #define NDIS_DUMMY_PATH "\\\\some\\bogus\\path"
   81 
   82 static void ndis_status_func(ndis_handle, ndis_status, void *, uint32_t);
   83 static void ndis_statusdone_func(ndis_handle);
   84 static void ndis_setdone_func(ndis_handle, ndis_status);
   85 static void ndis_getdone_func(ndis_handle, ndis_status);
   86 static void ndis_resetdone_func(ndis_handle, ndis_status, uint8_t);
   87 static void ndis_sendrsrcavail_func(ndis_handle);
   88 static void ndis_intrsetup(kdpc *, device_object *,
   89         irp *, struct ndis_softc *);
   90 static void ndis_return(device_object *, void *);
   91 
   92 static image_patch_table kernndis_functbl[] = {
   93         IMPORT_SFUNC(ndis_status_func, 4),
   94         IMPORT_SFUNC(ndis_statusdone_func, 1),
   95         IMPORT_SFUNC(ndis_setdone_func, 2),
   96         IMPORT_SFUNC(ndis_getdone_func, 2),
   97         IMPORT_SFUNC(ndis_resetdone_func, 3),
   98         IMPORT_SFUNC(ndis_sendrsrcavail_func, 1),
   99         IMPORT_SFUNC(ndis_intrsetup, 4),
  100         IMPORT_SFUNC(ndis_return, 1),
  101 
  102         { NULL, NULL, NULL }
  103 };
  104 
  105 static struct nd_head ndis_devhead;
  106 
  107 /*
  108  * This allows us to export our symbols to other modules.
  109  * Note that we call ourselves 'ndisapi' to avoid a namespace
  110  * collision with if_ndis.ko, which internally calls itself
  111  * 'ndis.'
  112  *
  113  * Note: some of the subsystems depend on each other, so the
  114  * order in which they're started is important. The order of
  115  * importance is:
  116  *
  117  * HAL - spinlocks and IRQL manipulation
  118  * ntoskrnl - DPC and workitem threads, object waiting
  119  * windrv - driver/device registration
  120  *
  121  * The HAL should also be the last thing shut down, since
  122  * the ntoskrnl subsystem will use spinlocks right up until
  123  * the DPC and workitem threads are terminated.
  124  */
  125 
  126 static int
  127 ndis_modevent(module_t mod, int cmd, void *arg)
  128 {
  129         int                     error = 0;
  130         image_patch_table       *patch;
  131 
  132         switch (cmd) {
  133         case MOD_LOAD:
  134                 /* Initialize subsystems */
  135                 hal_libinit();
  136                 ntoskrnl_libinit();
  137                 windrv_libinit();
  138                 ndis_libinit();
  139                 usbd_libinit();
  140 
  141                 patch = kernndis_functbl;
  142                 while (patch->ipt_func != NULL) {
  143                         windrv_wrap((funcptr)patch->ipt_func,
  144                             (funcptr *)&patch->ipt_wrap,
  145                             patch->ipt_argcnt, patch->ipt_ftype);
  146                         patch++;
  147                 }
  148 
  149                 TAILQ_INIT(&ndis_devhead);
  150                 break;
  151         case MOD_SHUTDOWN:
  152                 if (TAILQ_FIRST(&ndis_devhead) == NULL) {
  153                         /* Shut down subsystems */
  154                         ndis_libfini();
  155                         usbd_libfini();
  156                         windrv_libfini();
  157                         ntoskrnl_libfini();
  158                         hal_libfini();
  159 
  160                         patch = kernndis_functbl;
  161                         while (patch->ipt_func != NULL) {
  162                                 windrv_unwrap(patch->ipt_wrap);
  163                                 patch++;
  164                         }
  165                 }
  166                 break;
  167         case MOD_UNLOAD:
  168                 /* Shut down subsystems */
  169                 ndis_libfini();
  170                 usbd_libfini();
  171                 windrv_libfini();
  172                 ntoskrnl_libfini();
  173                 hal_libfini();
  174 
  175                 patch = kernndis_functbl;
  176                 while (patch->ipt_func != NULL) {
  177                         windrv_unwrap(patch->ipt_wrap);
  178                         patch++;
  179                 }
  180 
  181                 break;
  182         default:
  183                 error = EINVAL;
  184                 break;
  185         }
  186 
  187         return(error);
  188 }
  189 DEV_MODULE(ndisapi, ndis_modevent, NULL);
  190 MODULE_VERSION(ndisapi, 1);
  191 
  192 static void
  193 ndis_sendrsrcavail_func(adapter)
  194         ndis_handle             adapter;
  195 {
  196         return;
  197 }
  198 
  199 static void
  200 ndis_status_func(adapter, status, sbuf, slen)
  201         ndis_handle             adapter;
  202         ndis_status             status;
  203         void                    *sbuf;
  204         uint32_t                slen;
  205 {
  206         ndis_miniport_block     *block;
  207         struct ndis_softc       *sc;
  208         struct ifnet            *ifp;
  209 
  210         block = adapter;
  211         sc = device_get_softc(block->nmb_physdeviceobj->do_devext);
  212         ifp = sc->ifp;
  213         if (ifp->if_flags & IFF_DEBUG)
  214                 device_printf (sc->ndis_dev, "status: %x\n", status);
  215         return;
  216 }
  217 
  218 static void
  219 ndis_statusdone_func(adapter)
  220         ndis_handle             adapter;
  221 {
  222         ndis_miniport_block     *block;
  223         struct ndis_softc       *sc;
  224         struct ifnet            *ifp;
  225 
  226         block = adapter;
  227         sc = device_get_softc(block->nmb_physdeviceobj->do_devext);
  228         ifp = sc->ifp;
  229         if (ifp->if_flags & IFF_DEBUG)
  230                 device_printf (sc->ndis_dev, "status complete\n");
  231         return;
  232 }
  233 
  234 static void
  235 ndis_setdone_func(adapter, status)
  236         ndis_handle             adapter;
  237         ndis_status             status;
  238 {
  239         ndis_miniport_block     *block;
  240         block = adapter;
  241 
  242         block->nmb_setstat = status;
  243         KeSetEvent(&block->nmb_setevent, IO_NO_INCREMENT, FALSE);
  244         return;
  245 }
  246 
  247 static void
  248 ndis_getdone_func(adapter, status)
  249         ndis_handle             adapter;
  250         ndis_status             status;
  251 {
  252         ndis_miniport_block     *block;
  253         block = adapter;
  254 
  255         block->nmb_getstat = status;
  256         KeSetEvent(&block->nmb_getevent, IO_NO_INCREMENT, FALSE);
  257         return;
  258 }
  259 
  260 static void
  261 ndis_resetdone_func(ndis_handle adapter, ndis_status status,
  262         uint8_t addressingreset)
  263 {
  264         ndis_miniport_block     *block;
  265         struct ndis_softc       *sc;
  266         struct ifnet            *ifp;
  267 
  268         block = adapter;
  269         sc = device_get_softc(block->nmb_physdeviceobj->do_devext);
  270         ifp = sc->ifp;
  271 
  272         if (ifp->if_flags & IFF_DEBUG)
  273                 device_printf (sc->ndis_dev, "reset done...\n");
  274         KeSetEvent(&block->nmb_resetevent, IO_NO_INCREMENT, FALSE);
  275 
  276         return;
  277 }
  278 
  279 int
  280 ndis_create_sysctls(arg)
  281         void                    *arg;
  282 {
  283         struct ndis_softc       *sc;
  284         ndis_cfg                *vals;
  285         char                    buf[256];
  286         struct sysctl_oid       *oidp;
  287         struct sysctl_ctx_entry *e;
  288 
  289         if (arg == NULL)
  290                 return(EINVAL);
  291 
  292         sc = arg;
  293         vals = sc->ndis_regvals;
  294 
  295         TAILQ_INIT(&sc->ndis_cfglist_head);
  296 
  297 #if __FreeBSD_version < 502113
  298         /* Create the sysctl tree. */
  299 
  300         sc->ndis_tree = SYSCTL_ADD_NODE(&sc->ndis_ctx,
  301             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
  302             device_get_nameunit(sc->ndis_dev), CTLFLAG_RD, 0,
  303             device_get_desc(sc->ndis_dev));
  304 
  305 #endif
  306         /* Add the driver-specific registry keys. */
  307 
  308         while(1) {
  309                 if (vals->nc_cfgkey == NULL)
  310                         break;
  311 
  312                 if (vals->nc_idx != sc->ndis_devidx) {
  313                         vals++;
  314                         continue;
  315                 }
  316 
  317                 /* See if we already have a sysctl with this name */
  318 
  319                 oidp = NULL;
  320 #if __FreeBSD_version < 502113
  321                 TAILQ_FOREACH(e, &sc->ndis_ctx, link) {
  322 #else
  323                 TAILQ_FOREACH(e, device_get_sysctl_ctx(sc->ndis_dev), link) {
  324 #endif
  325                         oidp = e->entry;
  326                         if (strcasecmp(oidp->oid_name, vals->nc_cfgkey) == 0)
  327                                 break;
  328                         oidp = NULL;
  329                 }
  330 
  331                 if (oidp != NULL) {
  332                         vals++;
  333                         continue;
  334                 }
  335 
  336                 ndis_add_sysctl(sc, vals->nc_cfgkey, vals->nc_cfgdesc,
  337                     vals->nc_val, CTLFLAG_RW);
  338                 vals++;
  339         }
  340 
  341         /* Now add a couple of builtin keys. */
  342 
  343         /*
  344          * Environment can be either Windows (0) or WindowsNT (1).
  345          * We qualify as the latter.
  346          */
  347         ndis_add_sysctl(sc, "Environment",
  348             "Windows environment", "1", CTLFLAG_RD);
  349 
  350         /* NDIS version should be 5.1. */
  351         ndis_add_sysctl(sc, "NdisVersion",
  352             "NDIS API Version", "0x00050001", CTLFLAG_RD);
  353 
  354         /* Bus type (PCI, PCMCIA, etc...) */
  355         sprintf(buf, "%d", (int)sc->ndis_iftype);
  356         ndis_add_sysctl(sc, "BusType", "Bus Type", buf, CTLFLAG_RD);
  357 
  358         if (sc->ndis_res_io != NULL) {
  359                 sprintf(buf, "0x%lx", rman_get_start(sc->ndis_res_io));
  360                 ndis_add_sysctl(sc, "IOBaseAddress",
  361                     "Base I/O Address", buf, CTLFLAG_RD);
  362         }
  363 
  364         if (sc->ndis_irq != NULL) {
  365                 sprintf(buf, "%lu", rman_get_start(sc->ndis_irq));
  366                 ndis_add_sysctl(sc, "InterruptNumber",
  367                     "Interrupt Number", buf, CTLFLAG_RD);
  368         }
  369 
  370         return(0);
  371 }
  372 
  373 int
  374 ndis_add_sysctl(arg, key, desc, val, flag)
  375         void                    *arg;
  376         char                    *key;
  377         char                    *desc;
  378         char                    *val;
  379         int                     flag;
  380 {
  381         struct ndis_softc       *sc;
  382         struct ndis_cfglist     *cfg;
  383         char                    descstr[256];
  384 
  385         sc = arg;
  386 
  387         cfg = malloc(sizeof(struct ndis_cfglist), M_DEVBUF, M_NOWAIT|M_ZERO);
  388 
  389         if (cfg == NULL) {
  390                 printf("failed for %s\n", key);
  391                 return(ENOMEM);
  392         }
  393 
  394         cfg->ndis_cfg.nc_cfgkey = strdup(key, M_DEVBUF);
  395         if (desc == NULL) {
  396                 snprintf(descstr, sizeof(descstr), "%s (dynamic)", key);
  397                 cfg->ndis_cfg.nc_cfgdesc = strdup(descstr, M_DEVBUF);
  398         } else
  399                 cfg->ndis_cfg.nc_cfgdesc = strdup(desc, M_DEVBUF);
  400         strcpy(cfg->ndis_cfg.nc_val, val);
  401 
  402         TAILQ_INSERT_TAIL(&sc->ndis_cfglist_head, cfg, link);
  403 
  404         cfg->ndis_oid =
  405 #if __FreeBSD_version < 502113
  406         SYSCTL_ADD_STRING(&sc->ndis_ctx, SYSCTL_CHILDREN(sc->ndis_tree),
  407             OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag,
  408             cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
  409             cfg->ndis_cfg.nc_cfgdesc);
  410 #else
  411         SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev),
  412             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)),
  413             OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag,
  414             cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
  415             cfg->ndis_cfg.nc_cfgdesc);
  416 #endif
  417 
  418         return(0);
  419 }
  420 
  421 /*
  422  * Somewhere, somebody decided "hey, let's automatically create
  423  * a sysctl tree for each device instance as it's created -- it'll
  424  * make life so much easier!" Lies. Why must they turn the kernel
  425  * into a house of lies?
  426  */
  427 
  428 int
  429 ndis_flush_sysctls(arg)
  430         void                    *arg;
  431 {
  432         struct ndis_softc       *sc;
  433         struct ndis_cfglist     *cfg;
  434         struct sysctl_ctx_list  *clist;
  435 
  436         sc = arg;
  437 
  438 #if __FreeBSD_version < 502113
  439         clist = &sc->ndis_ctx;
  440 #else
  441         clist = device_get_sysctl_ctx(sc->ndis_dev);
  442 #endif
  443 
  444         while (!TAILQ_EMPTY(&sc->ndis_cfglist_head)) {
  445                 cfg = TAILQ_FIRST(&sc->ndis_cfglist_head);
  446                 TAILQ_REMOVE(&sc->ndis_cfglist_head, cfg, link);
  447                 sysctl_ctx_entry_del(clist, cfg->ndis_oid);
  448                 sysctl_remove_oid(cfg->ndis_oid, 1, 0);
  449                 free(cfg->ndis_cfg.nc_cfgkey, M_DEVBUF);
  450                 free(cfg->ndis_cfg.nc_cfgdesc, M_DEVBUF);
  451                 free(cfg, M_DEVBUF);
  452         }
  453 
  454         return(0);
  455 }
  456 
  457 static void
  458 ndis_return(dobj, arg)
  459         device_object           *dobj;
  460         void                    *arg;
  461 {
  462         ndis_miniport_block     *block;
  463         ndis_miniport_characteristics   *ch;
  464         ndis_return_handler     returnfunc;
  465         ndis_handle             adapter;
  466         ndis_packet             *p;
  467         uint8_t                 irql;
  468         list_entry              *l;
  469 
  470         block = arg;
  471         ch = IoGetDriverObjectExtension(dobj->do_drvobj, (void *)1);
  472 
  473         p = arg;
  474         adapter = block->nmb_miniportadapterctx;
  475 
  476         if (adapter == NULL)
  477                 return;
  478 
  479         returnfunc = ch->nmc_return_packet_func;
  480 
  481         KeAcquireSpinLock(&block->nmb_returnlock, &irql);
  482         while (!IsListEmpty(&block->nmb_returnlist)) {
  483                 l = RemoveHeadList((&block->nmb_returnlist));
  484                 p = CONTAINING_RECORD(l, ndis_packet, np_list);
  485                 InitializeListHead((&p->np_list));
  486                 KeReleaseSpinLock(&block->nmb_returnlock, irql);
  487                 MSCALL2(returnfunc, adapter, p);
  488                 KeAcquireSpinLock(&block->nmb_returnlock, &irql);
  489         }
  490         KeReleaseSpinLock(&block->nmb_returnlock, irql);
  491 
  492         return;
  493 }
  494 
  495 void
  496 ndis_return_packet(buf, arg)
  497         void                    *buf;   /* not used */
  498         void                    *arg;
  499 {
  500         ndis_packet             *p;
  501         ndis_miniport_block     *block;
  502 
  503         if (arg == NULL)
  504                 return;
  505 
  506         p = arg;
  507 
  508         /* Decrement refcount. */
  509         p->np_refcnt--;
  510 
  511         /* Release packet when refcount hits zero, otherwise return. */
  512         if (p->np_refcnt)
  513                 return;
  514 
  515         block = ((struct ndis_softc *)p->np_softc)->ndis_block;
  516 
  517         KeAcquireSpinLockAtDpcLevel(&block->nmb_returnlock);
  518         InitializeListHead((&p->np_list));
  519         InsertHeadList((&block->nmb_returnlist), (&p->np_list));
  520         KeReleaseSpinLockFromDpcLevel(&block->nmb_returnlock);
  521 
  522         IoQueueWorkItem(block->nmb_returnitem,
  523             (io_workitem_func)kernndis_functbl[7].ipt_wrap,
  524             WORKQUEUE_CRITICAL, block);
  525 
  526         return;
  527 }
  528 
  529 void
  530 ndis_free_bufs(b0)
  531         ndis_buffer             *b0;
  532 {
  533         ndis_buffer             *next;
  534 
  535         if (b0 == NULL)
  536                 return;
  537 
  538         while(b0 != NULL) {
  539                 next = b0->mdl_next;
  540                 IoFreeMdl(b0);
  541                 b0 = next;
  542         }
  543 
  544         return;
  545 }
  546 
  547 void
  548 ndis_free_packet(p)
  549         ndis_packet             *p;
  550 {
  551         if (p == NULL)
  552                 return;
  553 
  554         ndis_free_bufs(p->np_private.npp_head);
  555         NdisFreePacket(p);
  556         return;
  557 }
  558 
  559 int
  560 ndis_convert_res(arg)
  561         void                    *arg;
  562 {
  563         struct ndis_softc       *sc;
  564         ndis_resource_list      *rl = NULL;
  565         cm_partial_resource_desc        *prd = NULL;
  566         ndis_miniport_block     *block;
  567         device_t                dev;
  568         struct resource_list    *brl;
  569         struct resource_list_entry      *brle;
  570 #if __FreeBSD_version < 600022
  571         struct resource_list    brl_rev;
  572         struct resource_list_entry      *n;
  573 #endif
  574         int                     error = 0;
  575 
  576         sc = arg;
  577         block = sc->ndis_block;
  578         dev = sc->ndis_dev;
  579 
  580 #if __FreeBSD_version < 600022
  581         SLIST_INIT(&brl_rev);
  582 #endif
  583 
  584         rl = malloc(sizeof(ndis_resource_list) +
  585             (sizeof(cm_partial_resource_desc) * (sc->ndis_rescnt - 1)),
  586             M_DEVBUF, M_NOWAIT|M_ZERO);
  587 
  588         if (rl == NULL)
  589                 return(ENOMEM);
  590 
  591         rl->cprl_version = 5;
  592         rl->cprl_version = 1;
  593         rl->cprl_count = sc->ndis_rescnt;
  594         prd = rl->cprl_partial_descs;
  595 
  596         brl = BUS_GET_RESOURCE_LIST(dev, dev);
  597 
  598         if (brl != NULL) {
  599 
  600 #if __FreeBSD_version < 600022
  601                 /*
  602                  * We have a small problem. Some PCI devices have
  603                  * multiple I/O ranges. Windows orders them starting
  604                  * from lowest numbered BAR to highest. We discover
  605                  * them in that order too, but insert them into a singly
  606                  * linked list head first, which means when time comes
  607                  * to traverse the list, we enumerate them in reverse
  608                  * order. This screws up some drivers which expect the
  609                  * BARs to be in ascending order so that they can choose
  610                  * the "first" one as their register space. Unfortunately,
  611                  * in order to fix this, we have to create our own
  612                  * temporary list with the entries in reverse order.
  613                  */
  614 
  615                 SLIST_FOREACH(brle, brl, link) {
  616                         n = malloc(sizeof(struct resource_list_entry),
  617                             M_TEMP, M_NOWAIT);
  618                         if (n == NULL) {
  619                                 error = ENOMEM;
  620                                 goto bad;
  621                         }
  622                         bcopy((char *)brle, (char *)n,
  623                             sizeof(struct resource_list_entry));
  624                         SLIST_INSERT_HEAD(&brl_rev, n, link);
  625                 }
  626 
  627                 SLIST_FOREACH(brle, &brl_rev, link) {
  628 #else
  629                 STAILQ_FOREACH(brle, brl, link) {
  630 #endif
  631                         switch (brle->type) {
  632                         case SYS_RES_IOPORT:
  633                                 prd->cprd_type = CmResourceTypePort;
  634                                 prd->cprd_flags = CM_RESOURCE_PORT_IO;
  635                                 prd->cprd_sharedisp =
  636                                     CmResourceShareDeviceExclusive;
  637                                 prd->u.cprd_port.cprd_start.np_quad =
  638                                     brle->start;
  639                                 prd->u.cprd_port.cprd_len = brle->count;
  640                                 break;
  641                         case SYS_RES_MEMORY:
  642                                 prd->cprd_type = CmResourceTypeMemory;
  643                                 prd->cprd_flags =
  644                                     CM_RESOURCE_MEMORY_READ_WRITE;
  645                                 prd->cprd_sharedisp =
  646                                     CmResourceShareDeviceExclusive;
  647                                 prd->u.cprd_port.cprd_start.np_quad =
  648                                     brle->start;
  649                                 prd->u.cprd_port.cprd_len = brle->count;
  650                                 break;
  651                         case SYS_RES_IRQ:
  652                                 prd->cprd_type = CmResourceTypeInterrupt;
  653                                 prd->cprd_flags = 0;
  654                                 /*
  655                                  * Always mark interrupt resources as
  656                                  * shared, since in our implementation,
  657                                  * they will be.
  658                                  */
  659                                 prd->cprd_sharedisp =
  660                                     CmResourceShareShared;
  661                                 prd->u.cprd_intr.cprd_level = brle->start;
  662                                 prd->u.cprd_intr.cprd_vector = brle->start;
  663                                 prd->u.cprd_intr.cprd_affinity = 0;
  664                                 break;
  665                         default:
  666                                 break;
  667                         }
  668                         prd++;
  669                 }
  670         }
  671 
  672         block->nmb_rlist = rl;
  673 
  674 #if __FreeBSD_version < 600022
  675 bad:
  676 
  677         while (!SLIST_EMPTY(&brl_rev)) {
  678                 n = SLIST_FIRST(&brl_rev);
  679                 SLIST_REMOVE_HEAD(&brl_rev, link);
  680                 free (n, M_TEMP);
  681         }
  682 #endif
  683 
  684         return(error);
  685 }
  686 
  687 /*
  688  * Map an NDIS packet to an mbuf list. When an NDIS driver receives a
  689  * packet, it will hand it to us in the form of an ndis_packet,
  690  * which we need to convert to an mbuf that is then handed off
  691  * to the stack. Note: we configure the mbuf list so that it uses
  692  * the memory regions specified by the ndis_buffer structures in
  693  * the ndis_packet as external storage. In most cases, this will
  694  * point to a memory region allocated by the driver (either by
  695  * ndis_malloc_withtag() or ndis_alloc_sharedmem()). We expect
  696  * the driver to handle free()ing this region for is, so we set up
  697  * a dummy no-op free handler for it.
  698  */ 
  699 
  700 int
  701 ndis_ptom(m0, p)
  702         struct mbuf             **m0;
  703         ndis_packet             *p;
  704 {
  705         struct mbuf             *m = NULL, *prev = NULL;
  706         ndis_buffer             *buf;
  707         ndis_packet_private     *priv;
  708         uint32_t                totlen = 0;
  709         struct ifnet            *ifp;
  710         struct ether_header     *eh;
  711         int                     diff;
  712 
  713         if (p == NULL || m0 == NULL)
  714                 return(EINVAL);
  715 
  716         priv = &p->np_private;
  717         buf = priv->npp_head;
  718         p->np_refcnt = 0;
  719 
  720         for (buf = priv->npp_head; buf != NULL; buf = buf->mdl_next) {
  721                 if (buf == priv->npp_head)
  722 #ifdef MT_HEADER
  723                         MGETHDR(m, M_DONTWAIT, MT_HEADER);
  724 #else
  725                         MGETHDR(m, M_DONTWAIT, MT_DATA);
  726 #endif
  727                 else
  728                         MGET(m, M_DONTWAIT, MT_DATA);
  729                 if (m == NULL) {
  730                         m_freem(*m0);
  731                         *m0 = NULL;
  732                         return(ENOBUFS);
  733                 }
  734                 m->m_len = MmGetMdlByteCount(buf);
  735                 m->m_data = MmGetMdlVirtualAddress(buf);
  736                 MEXTADD(m, m->m_data, m->m_len, ndis_return_packet,
  737                     m->m_data, p, 0, EXT_NDIS);
  738                 p->np_refcnt++;
  739 
  740                 totlen += m->m_len;
  741                 if (m->m_flags & M_PKTHDR)
  742                         *m0 = m;
  743                 else
  744                         prev->m_next = m;
  745                 prev = m;
  746         }
  747 
  748         /*
  749          * This is a hack to deal with the Marvell 8335 driver
  750          * which, when associated with an AP in WPA-PSK mode,
  751          * seems to overpad its frames by 8 bytes. I don't know
  752          * that the extra 8 bytes are for, and they're not there
  753          * in open mode, so for now clamp the frame size at 1514
  754          * until I can figure out how to deal with this properly,
  755          * otherwise if_ethersubr() will spank us by discarding
  756          * the 'oversize' frames.
  757          */
  758 
  759         eh = mtod((*m0), struct ether_header *);
  760         ifp = ((struct ndis_softc *)p->np_softc)->ifp;
  761         if (totlen > ETHER_MAX_FRAME(ifp, eh->ether_type, FALSE)) {
  762                 diff = totlen - ETHER_MAX_FRAME(ifp, eh->ether_type, FALSE);
  763                 totlen -= diff;
  764                 m->m_len -= diff;
  765         }
  766         (*m0)->m_pkthdr.len = totlen;
  767 
  768         return(0);
  769 }
  770 
  771 /*
  772  * Create an NDIS packet from an mbuf chain.
  773  * This is used mainly when transmitting packets, where we need
  774  * to turn an mbuf off an interface's send queue and transform it
  775  * into an NDIS packet which will be fed into the NDIS driver's
  776  * send routine.
  777  *
  778  * NDIS packets consist of two parts: an ndis_packet structure,
  779  * which is vaguely analagous to the pkthdr portion of an mbuf,
  780  * and one or more ndis_buffer structures, which define the
  781  * actual memory segments in which the packet data resides.
  782  * We need to allocate one ndis_buffer for each mbuf in a chain,
  783  * plus one ndis_packet as the header.
  784  */
  785 
  786 int
  787 ndis_mtop(m0, p)
  788         struct mbuf             *m0;
  789         ndis_packet             **p;
  790 {
  791         struct mbuf             *m;
  792         ndis_buffer             *buf = NULL, *prev = NULL;
  793         ndis_packet_private     *priv;
  794 
  795         if (p == NULL || *p == NULL || m0 == NULL)
  796                 return(EINVAL);
  797 
  798         priv = &(*p)->np_private;
  799         priv->npp_totlen = m0->m_pkthdr.len;
  800 
  801         for (m = m0; m != NULL; m = m->m_next) {
  802                 if (m->m_len == 0)
  803                         continue;
  804                 buf = IoAllocateMdl(m->m_data, m->m_len, FALSE, FALSE, NULL);
  805                 if (buf == NULL) {
  806                         ndis_free_packet(*p);
  807                         *p = NULL;
  808                         return(ENOMEM);
  809                 }
  810                 MmBuildMdlForNonPagedPool(buf);
  811 
  812                 if (priv->npp_head == NULL)
  813                         priv->npp_head = buf;
  814                 else
  815                         prev->mdl_next = buf;
  816                 prev = buf;
  817         }
  818 
  819         priv->npp_tail = buf;
  820 
  821         return(0);
  822 }
  823 
  824 int
  825 ndis_get_supported_oids(arg, oids, oidcnt)
  826         void                    *arg;
  827         ndis_oid                **oids;
  828         int                     *oidcnt;
  829 {
  830         int                     len, rval;
  831         ndis_oid                *o;
  832 
  833         if (arg == NULL || oids == NULL || oidcnt == NULL)
  834                 return(EINVAL);
  835         len = 0;
  836         ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, NULL, &len);
  837 
  838         o = malloc(len, M_DEVBUF, M_NOWAIT);
  839         if (o == NULL)
  840                 return(ENOMEM);
  841 
  842         rval = ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, o, &len);
  843 
  844         if (rval) {
  845                 free(o, M_DEVBUF);
  846                 return(rval);
  847         }
  848 
  849         *oids = o;
  850         *oidcnt = len / 4;
  851 
  852         return(0);
  853 }
  854 
  855 int
  856 ndis_set_info(arg, oid, buf, buflen)
  857         void                    *arg;
  858         ndis_oid                oid;
  859         void                    *buf;
  860         int                     *buflen;
  861 {
  862         struct ndis_softc       *sc;
  863         ndis_status             rval;
  864         ndis_handle             adapter;
  865         ndis_setinfo_handler    setfunc;
  866         uint32_t                byteswritten = 0, bytesneeded = 0;
  867         uint8_t                 irql;
  868         uint64_t                duetime;
  869 
  870         /*
  871          * According to the NDIS spec, MiniportQueryInformation()
  872          * and MiniportSetInformation() requests are handled serially:
  873          * once one request has been issued, we must wait for it to
  874          * finish before allowing another request to proceed.
  875          */
  876 
  877         sc = arg;
  878 
  879         KeResetEvent(&sc->ndis_block->nmb_setevent);
  880 
  881         KeAcquireSpinLock(&sc->ndis_block->nmb_lock, &irql);
  882 
  883         if (sc->ndis_block->nmb_pendingreq != NULL) {
  884                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
  885                 panic("ndis_set_info() called while other request pending");
  886         } else
  887                 sc->ndis_block->nmb_pendingreq = (ndis_request *)sc;
  888 
  889         setfunc = sc->ndis_chars->nmc_setinfo_func;
  890         adapter = sc->ndis_block->nmb_miniportadapterctx;
  891 
  892         if (adapter == NULL || setfunc == NULL ||
  893             sc->ndis_block->nmb_devicectx == NULL) {
  894                 sc->ndis_block->nmb_pendingreq = NULL;
  895                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
  896                 return(ENXIO);
  897         }
  898 
  899         rval = MSCALL6(setfunc, adapter, oid, buf, *buflen,
  900             &byteswritten, &bytesneeded);
  901 
  902         sc->ndis_block->nmb_pendingreq = NULL;
  903 
  904         KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
  905 
  906         if (rval == NDIS_STATUS_PENDING) {
  907                 /* Wait up to 5 seconds. */
  908                 duetime = (5 * 1000000) * -10;
  909                 KeWaitForSingleObject(&sc->ndis_block->nmb_setevent,
  910                     0, 0, FALSE, &duetime);
  911                 rval = sc->ndis_block->nmb_setstat;
  912         }
  913 
  914         if (byteswritten)
  915                 *buflen = byteswritten;
  916         if (bytesneeded)
  917                 *buflen = bytesneeded;
  918 
  919         if (rval == NDIS_STATUS_INVALID_LENGTH)
  920                 return(ENOSPC);
  921 
  922         if (rval == NDIS_STATUS_INVALID_OID)
  923                 return(EINVAL);
  924 
  925         if (rval == NDIS_STATUS_NOT_SUPPORTED ||
  926             rval == NDIS_STATUS_NOT_ACCEPTED)
  927                 return(ENOTSUP);
  928 
  929         if (rval != NDIS_STATUS_SUCCESS)
  930                 return(ENODEV);
  931 
  932         return(0);
  933 }
  934 
  935 typedef void (*ndis_senddone_func)(ndis_handle, ndis_packet *, ndis_status);
  936 
  937 int
  938 ndis_send_packets(arg, packets, cnt)
  939         void                    *arg;
  940         ndis_packet             **packets;
  941         int                     cnt;
  942 {
  943         struct ndis_softc       *sc;
  944         ndis_handle             adapter;
  945         ndis_sendmulti_handler  sendfunc;
  946         ndis_senddone_func              senddonefunc;
  947         int                     i;
  948         ndis_packet             *p;
  949         uint8_t                 irql = 0;
  950 
  951         sc = arg;
  952         adapter = sc->ndis_block->nmb_miniportadapterctx;
  953         if (adapter == NULL)
  954                 return(ENXIO);
  955         sendfunc = sc->ndis_chars->nmc_sendmulti_func;
  956         senddonefunc = sc->ndis_block->nmb_senddone_func;
  957 
  958         if (NDIS_SERIALIZED(sc->ndis_block))
  959                 KeAcquireSpinLock(&sc->ndis_block->nmb_lock, &irql);
  960 
  961         MSCALL3(sendfunc, adapter, packets, cnt);
  962 
  963         for (i = 0; i < cnt; i++) {
  964                 p = packets[i];
  965                 /*
  966                  * Either the driver already handed the packet to
  967                  * ndis_txeof() due to a failure, or it wants to keep
  968                  * it and release it asynchronously later. Skip to the
  969                  * next one.
  970                  */
  971                 if (p == NULL || p->np_oob.npo_status == NDIS_STATUS_PENDING)
  972                         continue;
  973                 MSCALL3(senddonefunc, sc->ndis_block, p, p->np_oob.npo_status);
  974         }
  975 
  976         if (NDIS_SERIALIZED(sc->ndis_block))
  977                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
  978 
  979         return(0);
  980 }
  981 
  982 int
  983 ndis_send_packet(arg, packet)
  984         void                    *arg;
  985         ndis_packet             *packet;
  986 {
  987         struct ndis_softc       *sc;
  988         ndis_handle             adapter;
  989         ndis_status             status;
  990         ndis_sendsingle_handler sendfunc;
  991         ndis_senddone_func              senddonefunc;
  992         uint8_t                 irql = 0;
  993 
  994         sc = arg;
  995         adapter = sc->ndis_block->nmb_miniportadapterctx;
  996         if (adapter == NULL)
  997                 return(ENXIO);
  998         sendfunc = sc->ndis_chars->nmc_sendsingle_func;
  999         senddonefunc = sc->ndis_block->nmb_senddone_func;
 1000 
 1001         if (NDIS_SERIALIZED(sc->ndis_block))
 1002                 KeAcquireSpinLock(&sc->ndis_block->nmb_lock, &irql);
 1003         status = MSCALL3(sendfunc, adapter, packet,
 1004             packet->np_private.npp_flags);
 1005 
 1006         if (status == NDIS_STATUS_PENDING) {
 1007                 if (NDIS_SERIALIZED(sc->ndis_block))
 1008                         KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1009                 return(0);
 1010         }
 1011 
 1012         MSCALL3(senddonefunc, sc->ndis_block, packet, status);
 1013 
 1014         if (NDIS_SERIALIZED(sc->ndis_block))
 1015                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1016 
 1017         return(0);
 1018 }
 1019 
 1020 int
 1021 ndis_init_dma(arg)
 1022         void                    *arg;
 1023 {
 1024         struct ndis_softc       *sc;
 1025         int                     i, error;
 1026 
 1027         sc = arg;
 1028 
 1029         sc->ndis_tmaps = malloc(sizeof(bus_dmamap_t) * sc->ndis_maxpkts,
 1030             M_DEVBUF, M_NOWAIT|M_ZERO);
 1031 
 1032         if (sc->ndis_tmaps == NULL)
 1033                 return(ENOMEM);
 1034 
 1035         for (i = 0; i < sc->ndis_maxpkts; i++) {
 1036                 error = bus_dmamap_create(sc->ndis_ttag, 0,
 1037                     &sc->ndis_tmaps[i]);
 1038                 if (error) {
 1039                         free(sc->ndis_tmaps, M_DEVBUF);
 1040                         return(ENODEV);
 1041                 }
 1042         }
 1043 
 1044         return(0);
 1045 }
 1046 
 1047 int
 1048 ndis_destroy_dma(arg)
 1049         void                    *arg;
 1050 {
 1051         struct ndis_softc       *sc;
 1052         struct mbuf             *m;
 1053         ndis_packet             *p = NULL;
 1054         int                     i;
 1055 
 1056         sc = arg;
 1057 
 1058         for (i = 0; i < sc->ndis_maxpkts; i++) {
 1059                 if (sc->ndis_txarray[i] != NULL) {
 1060                         p = sc->ndis_txarray[i];
 1061                         m = (struct mbuf *)p->np_rsvd[1];
 1062                         if (m != NULL)
 1063                                 m_freem(m);
 1064                         ndis_free_packet(sc->ndis_txarray[i]);
 1065                 }
 1066                 bus_dmamap_destroy(sc->ndis_ttag, sc->ndis_tmaps[i]);
 1067         }
 1068 
 1069         free(sc->ndis_tmaps, M_DEVBUF);
 1070 
 1071         bus_dma_tag_destroy(sc->ndis_ttag);
 1072 
 1073         return(0);
 1074 }
 1075 
 1076 int
 1077 ndis_reset_nic(arg)
 1078         void                    *arg;
 1079 {
 1080         struct ndis_softc       *sc;
 1081         ndis_handle             adapter;
 1082         ndis_reset_handler      resetfunc;
 1083         uint8_t                 addressing_reset;
 1084         int                     rval;
 1085         uint8_t                 irql = 0;
 1086 
 1087         sc = arg;
 1088 
 1089         NDIS_LOCK(sc);
 1090         adapter = sc->ndis_block->nmb_miniportadapterctx;
 1091         resetfunc = sc->ndis_chars->nmc_reset_func;
 1092 
 1093         if (adapter == NULL || resetfunc == NULL ||
 1094             sc->ndis_block->nmb_devicectx == NULL) {
 1095                 NDIS_UNLOCK(sc);
 1096                 return(EIO);
 1097         }
 1098 
 1099         NDIS_UNLOCK(sc);
 1100 
 1101         KeResetEvent(&sc->ndis_block->nmb_resetevent);
 1102 
 1103         if (NDIS_SERIALIZED(sc->ndis_block))
 1104                 KeAcquireSpinLock(&sc->ndis_block->nmb_lock, &irql);
 1105 
 1106         rval = MSCALL2(resetfunc, &addressing_reset, adapter);
 1107 
 1108         if (NDIS_SERIALIZED(sc->ndis_block))
 1109                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1110 
 1111         if (rval == NDIS_STATUS_PENDING)
 1112                 KeWaitForSingleObject(&sc->ndis_block->nmb_resetevent,
 1113                     0, 0, FALSE, NULL);
 1114 
 1115         return(0);
 1116 }
 1117 
 1118 int
 1119 ndis_halt_nic(arg)
 1120         void                    *arg;
 1121 {
 1122         struct ndis_softc       *sc;
 1123         ndis_handle             adapter;
 1124         ndis_halt_handler       haltfunc;
 1125         ndis_miniport_block     *block;
 1126         int                     empty = 0;
 1127         uint8_t                 irql;
 1128 
 1129         sc = arg;
 1130         block = sc->ndis_block;
 1131 
 1132         if (!cold)
 1133                 KeFlushQueuedDpcs();
 1134 
 1135         /*
 1136          * Wait for all packets to be returned.
 1137          */
 1138 
 1139         while (1) {
 1140                 KeAcquireSpinLock(&block->nmb_returnlock, &irql);
 1141                 empty = IsListEmpty(&block->nmb_returnlist);
 1142                 KeReleaseSpinLock(&block->nmb_returnlock, irql);
 1143                 if (empty)
 1144                         break;
 1145                 NdisMSleep(1000);
 1146         }
 1147 
 1148         NDIS_LOCK(sc);
 1149         adapter = sc->ndis_block->nmb_miniportadapterctx;
 1150         if (adapter == NULL) {
 1151                 NDIS_UNLOCK(sc);
 1152                 return(EIO);
 1153         }
 1154 
 1155         sc->ndis_block->nmb_devicectx = NULL;
 1156 
 1157         /*
 1158          * The adapter context is only valid after the init
 1159          * handler has been called, and is invalid once the
 1160          * halt handler has been called.
 1161          */
 1162 
 1163         haltfunc = sc->ndis_chars->nmc_halt_func;
 1164         NDIS_UNLOCK(sc);
 1165 
 1166         MSCALL1(haltfunc, adapter);
 1167 
 1168         NDIS_LOCK(sc);
 1169         sc->ndis_block->nmb_miniportadapterctx = NULL;
 1170         NDIS_UNLOCK(sc);
 1171 
 1172         return(0);
 1173 }
 1174 
 1175 int
 1176 ndis_shutdown_nic(arg)
 1177         void                    *arg;
 1178 {
 1179         struct ndis_softc       *sc;
 1180         ndis_handle             adapter;
 1181         ndis_shutdown_handler   shutdownfunc;
 1182 
 1183         sc = arg;
 1184         NDIS_LOCK(sc);
 1185         adapter = sc->ndis_block->nmb_miniportadapterctx;
 1186         shutdownfunc = sc->ndis_chars->nmc_shutdown_handler;
 1187         NDIS_UNLOCK(sc);
 1188         if (adapter == NULL || shutdownfunc == NULL)
 1189                 return(EIO);
 1190 
 1191         if (sc->ndis_chars->nmc_rsvd0 == NULL)
 1192                 MSCALL1(shutdownfunc, adapter);
 1193         else
 1194                 MSCALL1(shutdownfunc, sc->ndis_chars->nmc_rsvd0);
 1195 
 1196         TAILQ_REMOVE(&ndis_devhead, sc->ndis_block, link);
 1197 
 1198         return(0);
 1199 }
 1200 
 1201 int
 1202 ndis_pnpevent_nic(arg, type)
 1203         void                    *arg;
 1204         int                     type;
 1205 {
 1206         device_t                dev;
 1207         struct ndis_softc       *sc;
 1208         ndis_handle             adapter;
 1209         ndis_pnpevent_handler   pnpeventfunc;
 1210 
 1211         dev = arg;
 1212         sc = device_get_softc(arg);
 1213         NDIS_LOCK(sc);
 1214         adapter = sc->ndis_block->nmb_miniportadapterctx;
 1215         pnpeventfunc = sc->ndis_chars->nmc_pnpevent_handler;
 1216         NDIS_UNLOCK(sc);
 1217         if (adapter == NULL || pnpeventfunc == NULL)
 1218                 return(EIO);
 1219 
 1220         if (sc->ndis_chars->nmc_rsvd0 == NULL)
 1221                 MSCALL4(pnpeventfunc, adapter, type, NULL, 0);
 1222         else
 1223                 MSCALL4(pnpeventfunc, sc->ndis_chars->nmc_rsvd0, type, NULL, 0);
 1224 
 1225         return (0);
 1226 }
 1227 
 1228 int
 1229 ndis_init_nic(arg)
 1230         void                    *arg;
 1231 {
 1232         struct ndis_softc       *sc;
 1233         ndis_miniport_block     *block;
 1234         ndis_init_handler       initfunc;
 1235         ndis_status             status, openstatus = 0;
 1236         ndis_medium             mediumarray[NdisMediumMax];
 1237         uint32_t                chosenmedium, i;
 1238 
 1239         if (arg == NULL)
 1240                 return(EINVAL);
 1241 
 1242         sc = arg;
 1243         NDIS_LOCK(sc);
 1244         block = sc->ndis_block;
 1245         initfunc = sc->ndis_chars->nmc_init_func;
 1246         NDIS_UNLOCK(sc);
 1247 
 1248         sc->ndis_block->nmb_timerlist = NULL;
 1249 
 1250         for (i = 0; i < NdisMediumMax; i++)
 1251                 mediumarray[i] = i;
 1252 
 1253         status = MSCALL6(initfunc, &openstatus, &chosenmedium,
 1254             mediumarray, NdisMediumMax, block, block);
 1255 
 1256         /*
 1257          * If the init fails, blow away the other exported routines
 1258          * we obtained from the driver so we can't call them later.
 1259          * If the init failed, none of these will work.
 1260          */
 1261         if (status != NDIS_STATUS_SUCCESS) {
 1262                 NDIS_LOCK(sc);
 1263                 sc->ndis_block->nmb_miniportadapterctx = NULL;
 1264                 NDIS_UNLOCK(sc);
 1265                 return(ENXIO);
 1266         }
 1267 
 1268         /*
 1269          * This may look really goofy, but apparently it is possible
 1270          * to halt a miniport too soon after it's been initialized.
 1271          * After MiniportInitialize() finishes, pause for 1 second
 1272          * to give the chip a chance to handle any short-lived timers
 1273          * that were set in motion. If we call MiniportHalt() too soon,
 1274          * some of the timers may not be cancelled, because the driver
 1275          * expects them to fire before the halt is called.
 1276          */
 1277 
 1278         pause("ndwait", hz);
 1279 
 1280         NDIS_LOCK(sc);
 1281         sc->ndis_block->nmb_devicectx = sc;
 1282         NDIS_UNLOCK(sc);
 1283 
 1284         return(0);
 1285 }
 1286 
 1287 static void
 1288 ndis_intrsetup(dpc, dobj, ip, sc)
 1289         kdpc                    *dpc;
 1290         device_object           *dobj;
 1291         irp                     *ip;
 1292         struct ndis_softc       *sc;
 1293 {
 1294         ndis_miniport_interrupt *intr;
 1295 
 1296         intr = sc->ndis_block->nmb_interrupt;
 1297 
 1298         /* Sanity check. */
 1299 
 1300         if (intr == NULL)
 1301                 return;
 1302 
 1303         KeAcquireSpinLockAtDpcLevel(&intr->ni_dpccountlock);
 1304         KeResetEvent(&intr->ni_dpcevt);
 1305         if (KeInsertQueueDpc(&intr->ni_dpc, NULL, NULL) == TRUE)
 1306                 intr->ni_dpccnt++;
 1307         KeReleaseSpinLockFromDpcLevel(&intr->ni_dpccountlock);
 1308 
 1309         return;
 1310 }
 1311 
 1312 int
 1313 ndis_get_info(arg, oid, buf, buflen)
 1314         void                    *arg;
 1315         ndis_oid                oid;
 1316         void                    *buf;
 1317         int                     *buflen;
 1318 {
 1319         struct ndis_softc       *sc;
 1320         ndis_status             rval;
 1321         ndis_handle             adapter;
 1322         ndis_queryinfo_handler  queryfunc;
 1323         uint32_t                byteswritten = 0, bytesneeded = 0;
 1324         uint8_t                 irql;
 1325         uint64_t                duetime;
 1326 
 1327         sc = arg;
 1328 
 1329         KeResetEvent(&sc->ndis_block->nmb_getevent);
 1330 
 1331         KeAcquireSpinLock(&sc->ndis_block->nmb_lock, &irql);
 1332 
 1333         if (sc->ndis_block->nmb_pendingreq != NULL) {
 1334                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1335                 panic("ndis_get_info() called while other request pending");
 1336         } else
 1337                 sc->ndis_block->nmb_pendingreq = (ndis_request *)sc;
 1338 
 1339         queryfunc = sc->ndis_chars->nmc_queryinfo_func;
 1340         adapter = sc->ndis_block->nmb_miniportadapterctx;
 1341 
 1342         if (adapter == NULL || queryfunc == NULL ||
 1343             sc->ndis_block->nmb_devicectx == NULL) {
 1344                 sc->ndis_block->nmb_pendingreq = NULL;
 1345                 KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1346                 return(ENXIO);
 1347         }
 1348 
 1349         rval = MSCALL6(queryfunc, adapter, oid, buf, *buflen,
 1350             &byteswritten, &bytesneeded);
 1351 
 1352         sc->ndis_block->nmb_pendingreq = NULL;
 1353 
 1354         KeReleaseSpinLock(&sc->ndis_block->nmb_lock, irql);
 1355 
 1356         /* Wait for requests that block. */
 1357 
 1358         if (rval == NDIS_STATUS_PENDING) {
 1359                 /* Wait up to 5 seconds. */
 1360                 duetime = (5 * 1000000) * -10;
 1361                 KeWaitForSingleObject(&sc->ndis_block->nmb_getevent,
 1362                     0, 0, FALSE, &duetime);
 1363                 rval = sc->ndis_block->nmb_getstat;
 1364         }
 1365 
 1366         if (byteswritten)
 1367                 *buflen = byteswritten;
 1368         if (bytesneeded)
 1369                 *buflen = bytesneeded;
 1370 
 1371         if (rval == NDIS_STATUS_INVALID_LENGTH ||
 1372             rval == NDIS_STATUS_BUFFER_TOO_SHORT)
 1373                 return(ENOSPC);
 1374 
 1375         if (rval == NDIS_STATUS_INVALID_OID)
 1376                 return(EINVAL);
 1377 
 1378         if (rval == NDIS_STATUS_NOT_SUPPORTED ||
 1379             rval == NDIS_STATUS_NOT_ACCEPTED)
 1380                 return(ENOTSUP);
 1381 
 1382         if (rval != NDIS_STATUS_SUCCESS)
 1383                 return(ENODEV);
 1384 
 1385         return(0);
 1386 }
 1387 
 1388 uint32_t
 1389 NdisAddDevice(drv, pdo)
 1390         driver_object           *drv;
 1391         device_object           *pdo;
 1392 {
 1393         device_object           *fdo;
 1394         ndis_miniport_block     *block;
 1395         struct ndis_softc       *sc;
 1396         uint32_t                status;
 1397         int                     error;
 1398 
 1399         sc = device_get_softc(pdo->do_devext);
 1400 
 1401         if (sc->ndis_iftype == PCMCIABus || sc->ndis_iftype == PCIBus) {
 1402                 error = bus_setup_intr(sc->ndis_dev, sc->ndis_irq,
 1403                     INTR_TYPE_NET | INTR_MPSAFE,
 1404                     NULL, ntoskrnl_intr, NULL, &sc->ndis_intrhand);
 1405                 if (error)
 1406                         return(NDIS_STATUS_FAILURE);
 1407         }
 1408 
 1409         status = IoCreateDevice(drv, sizeof(ndis_miniport_block), NULL,
 1410             FILE_DEVICE_UNKNOWN, 0, FALSE, &fdo);
 1411 
 1412         if (status != STATUS_SUCCESS)
 1413                 return(status);
 1414 
 1415         block = fdo->do_devext;
 1416 
 1417         block->nmb_filterdbs.nf_ethdb = block;
 1418         block->nmb_deviceobj = fdo;
 1419         block->nmb_physdeviceobj = pdo;
 1420         block->nmb_nextdeviceobj = IoAttachDeviceToDeviceStack(fdo, pdo);
 1421         KeInitializeSpinLock(&block->nmb_lock);
 1422         KeInitializeSpinLock(&block->nmb_returnlock);
 1423         KeInitializeEvent(&block->nmb_getevent, EVENT_TYPE_NOTIFY, TRUE);
 1424         KeInitializeEvent(&block->nmb_setevent, EVENT_TYPE_NOTIFY, TRUE);
 1425         KeInitializeEvent(&block->nmb_resetevent, EVENT_TYPE_NOTIFY, TRUE);
 1426         InitializeListHead(&block->nmb_parmlist);
 1427         InitializeListHead(&block->nmb_returnlist);
 1428         block->nmb_returnitem = IoAllocateWorkItem(fdo);
 1429 
 1430         /*
 1431          * Stash pointers to the miniport block and miniport
 1432          * characteristics info in the if_ndis softc so the
 1433          * UNIX wrapper driver can get to them later.
 1434          */
 1435         sc->ndis_block = block;
 1436         sc->ndis_chars = IoGetDriverObjectExtension(drv, (void *)1);
 1437 
 1438         /*
 1439          * If the driver has a MiniportTransferData() function,
 1440          * we should allocate a private RX packet pool.
 1441          */
 1442 
 1443         if (sc->ndis_chars->nmc_transferdata_func != NULL) {
 1444                 NdisAllocatePacketPool(&status, &block->nmb_rxpool,
 1445                     32, PROTOCOL_RESERVED_SIZE_IN_PACKET);
 1446                 if (status != NDIS_STATUS_SUCCESS) {
 1447                         IoDetachDevice(block->nmb_nextdeviceobj);
 1448                         IoDeleteDevice(fdo);
 1449                         return(status);
 1450                 }
 1451                 InitializeListHead((&block->nmb_packetlist));
 1452         }
 1453 
 1454         /* Give interrupt handling priority over timers. */
 1455         IoInitializeDpcRequest(fdo, kernndis_functbl[6].ipt_wrap);
 1456         KeSetImportanceDpc(&fdo->do_dpc, KDPC_IMPORTANCE_HIGH);
 1457 
 1458         /* Finish up BSD-specific setup. */
 1459 
 1460         block->nmb_signature = (void *)0xcafebabe;
 1461         block->nmb_status_func = kernndis_functbl[0].ipt_wrap;
 1462         block->nmb_statusdone_func = kernndis_functbl[1].ipt_wrap;
 1463         block->nmb_setdone_func = kernndis_functbl[2].ipt_wrap;
 1464         block->nmb_querydone_func = kernndis_functbl[3].ipt_wrap;
 1465         block->nmb_resetdone_func = kernndis_functbl[4].ipt_wrap;
 1466         block->nmb_sendrsrc_func = kernndis_functbl[5].ipt_wrap;
 1467         block->nmb_pendingreq = NULL;
 1468 
 1469         TAILQ_INSERT_TAIL(&ndis_devhead, block, link);
 1470 
 1471         return (STATUS_SUCCESS);
 1472 }
 1473 
 1474 int
 1475 ndis_unload_driver(arg)
 1476         void                    *arg;
 1477 {
 1478         struct ndis_softc       *sc;
 1479         device_object           *fdo;
 1480 
 1481         sc = arg;
 1482 
 1483         if (sc->ndis_intrhand)
 1484                 bus_teardown_intr(sc->ndis_dev,
 1485                     sc->ndis_irq, sc->ndis_intrhand);
 1486 
 1487         if (sc->ndis_block->nmb_rlist != NULL)
 1488                 free(sc->ndis_block->nmb_rlist, M_DEVBUF);
 1489 
 1490         ndis_flush_sysctls(sc);
 1491 
 1492         TAILQ_REMOVE(&ndis_devhead, sc->ndis_block, link);
 1493 
 1494         if (sc->ndis_chars->nmc_transferdata_func != NULL)
 1495                 NdisFreePacketPool(sc->ndis_block->nmb_rxpool);
 1496         fdo = sc->ndis_block->nmb_deviceobj;
 1497         IoFreeWorkItem(sc->ndis_block->nmb_returnitem);
 1498         IoDetachDevice(sc->ndis_block->nmb_nextdeviceobj);
 1499         IoDeleteDevice(fdo);
 1500 
 1501         return(0);
 1502 }

Cache object: 972c6943476e3f736037bc698c345acb


[ 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.