sys/emulation/ndis/kern_ndis.c

   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  * $FreeBSD: src/sys/compat/ndis/kern_ndis.c,v 1.57 2004/07/11 00:19:30 wpaul Exp $
  33  * $DragonFly: src/sys/emulation/ndis/kern_ndis.c,v 1.14 2006/12/20 18:14:41 dillon Exp $
  34  */
  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/conf.h>
  49
  50 #include <sys/kernel.h>
  51 #include <sys/module.h>
  52 #include <sys/kthread.h>
  53 #include <sys/bus.h>
  54 #include <sys/rman.h>
  55
  56 #include <net/if.h>
  57 #include <net/if_arp.h>
  58 #include <net/ethernet.h>
  59 #include <net/if_dl.h>
  60 #include <net/if_media.h>
  61
  62 #include <netproto/802_11/ieee80211_var.h>
  63 #include <netproto/802_11/ieee80211_ioctl.h>
  64
  65 #include "regcall.h"
  66 #include "pe_var.h"
  67 #include "resource_var.h"
  68 #include "ntoskrnl_var.h"
  69 #include "ndis_var.h"
  70 #include "hal_var.h"
  71 #include "cfg_var.h"
  72 #include <dev/netif/ndis/if_ndisvar.h>
  73
  74 #define NDIS_DUMMY_PATH "\\\\some\\bogus\\path"
  75
  76 __stdcall static void ndis_status_func(ndis_handle, ndis_status,
  77         void *, uint32_t);
  78 __stdcall static void ndis_statusdone_func(ndis_handle);
  79 __stdcall static void ndis_setdone_func(ndis_handle, ndis_status);
  80 __stdcall static void ndis_getdone_func(ndis_handle, ndis_status);
  81 __stdcall static void ndis_resetdone_func(ndis_handle, ndis_status, uint8_t);
  82 __stdcall static void ndis_sendrsrcavail_func(ndis_handle);
  83
  84 struct nd_head ndis_devhead;
  85
  86 struct ndis_req {
  87         void                    (*nr_func)(void *);
  88         void                    *nr_arg;
  89         int                     nr_exit;
  90         STAILQ_ENTRY(ndis_req)  link;
  91 };
  92
  93 struct ndisproc {
  94         struct ndisqhead        *np_q;
  95         struct thread           *np_td;
  96         int                     np_state;
  97 };
  98
  99 static void ndis_return(void *);
 100 static int ndis_create_kthreads(void);
 101 static void ndis_destroy_kthreads(void);
 102 static void ndis_stop_thread(int);
 103 static int ndis_enlarge_thrqueue(int);
 104 static int ndis_shrink_thrqueue(int);
 105 static void ndis_runq(void *);
 106
 107 static MALLOC_DEFINE(M_NDIS_PACKET, "ndis_packet", "ndis packet slosh");
 108 static MALLOC_DEFINE(M_NDIS_BUFFER, "ndis_buffer", "ndis buffer slosh");
 109 struct lwkt_token ndis_thr_token;
 110 static STAILQ_HEAD(ndisqhead, ndis_req) ndis_ttodo;
 111 struct ndisqhead ndis_itodo;
 112 struct ndisqhead ndis_free;
 113 static int ndis_jobs = 32;
 114
 115 static struct ndisproc ndis_tproc;
 116 static struct ndisproc ndis_iproc;
 117
 118 /*
 119  * This allows us to export our symbols to other modules.
 120  * Note that we call ourselves 'ndisapi' to avoid a namespace
 121  * collision with if_ndis.ko, which internally calls itself
 122  * 'ndis.'
 123  */
 124 static int
 125 ndis_modevent(module_t mod, int cmd, void *arg)
 126 {
 127         int                     error = 0;
 128
 129         switch (cmd) {
 130         case MOD_LOAD:
 131                 /* Initialize subsystems */
 132                 ndis_libinit();
 133                 ntoskrnl_libinit();
 134
 135                 /* Initialize TX buffer UMA zone. */
 136                 ndis_create_kthreads();
 137
 138                 TAILQ_INIT(&ndis_devhead);
 139
 140                 break;
 141         case MOD_SHUTDOWN:
 142                 /* stop kthreads */
 143                 ndis_destroy_kthreads();
 144                 if (TAILQ_FIRST(&ndis_devhead) == NULL) {
 145                         /* Shut down subsystems */
 146                         ndis_libfini();
 147                         ntoskrnl_libfini();
 148
 149                         /* Remove zones */
 150 #if 0   /* YYY */
 151                         malloc_uninit(M_NDIS_PACKET);
 152                         malloc_uninit(M_NDIS_BUFFER);
 153 #endif
 154                 }
 155                 break;
 156         case MOD_UNLOAD:
 157                 /* stop kthreads */
 158                 ndis_destroy_kthreads();
 159
 160                 /* Shut down subsystems */
 161                 ndis_libfini();
 162                 ntoskrnl_libfini();
 163
 164                 /* Remove zones */
 165 #if 0   /* YYY */
 166                 malloc_uninit(M_NDIS_PACKET);
 167                 malloc_uninit(M_NDIS_BUFFER);
 168 #endif
 169                 break;
 170         default:
 171                 error = EINVAL;
 172                 break;
 173         }
 174
 175         return(error);
 176 }
 177 DEV_MODULE(ndisapi, ndis_modevent, NULL);
 178 MODULE_VERSION(ndisapi, 1);
 179
 180 /*
 181  * We create two kthreads for the NDIS subsystem. One of them is a task
 182  * queue for performing various odd jobs. The other is an swi thread
 183  * reserved exclusively for running interrupt handlers. The reason we
 184  * have our own task queue is that there are some cases where we may
 185  * need to sleep for a significant amount of time, and if we were to
 186  * use one of the taskqueue threads, we might delay the processing
 187  * of other pending tasks which might need to run right away. We have
 188  * a separate swi thread because we don't want our interrupt handling
 189  * to be delayed either.
 190  *
 191  * By default there are 32 jobs available to start, and another 8
 192  * are added to the free list each time a new device is created.
 193  */
 194
 195 static void
 196 ndis_runq(void *arg)
 197 {
 198         struct ndis_req         *r = NULL, *die = NULL;
 199         struct ndisproc         *p;
 200         struct lwkt_tokref      tokref;
 201
 202         p = arg;
 203
 204         while (1) {
 205
 206                 /* Sleep, but preserve our original priority. */
 207                 ndis_thsuspend(p->np_td, 0);
 208
 209                 /* Look for any jobs on the work queue. */
 210
 211                 lwkt_gettoken(&tokref, &ndis_thr_token);
 212                 p->np_state = NDIS_PSTATE_RUNNING;
 213                 while(STAILQ_FIRST(p->np_q) != NULL) {
 214                         r = STAILQ_FIRST(p->np_q);
 215                         STAILQ_REMOVE_HEAD(p->np_q, link);
 216                         lwkt_reltoken(&tokref);
 217
 218                         /* Do the work. */
 219
 220                         if (r->nr_func != NULL)
 221                                 (*r->nr_func)(r->nr_arg);
 222
 223                         lwkt_gettoken(&tokref, &ndis_thr_token);
 224                         STAILQ_INSERT_HEAD(&ndis_free, r, link);
 225
 226                         /* Check for a shutdown request */
 227
 228                         if (r->nr_exit == TRUE)
 229                                 die = r;
 230                 }
 231                 p->np_state = NDIS_PSTATE_SLEEPING;
 232                 lwkt_reltoken(&tokref);
 233
 234                 /* Bail if we were told to shut down. */
 235
 236                 if (die != NULL)
 237                         break;
 238         }
 239
 240         wakeup(die);
 241         kthread_exit();
 242 }
 243
 244 static int
 245 ndis_create_kthreads(void)
 246 {
 247         struct ndis_req         *r;
 248         int                     i, error = 0;
 249
 250         lwkt_token_init(&ndis_thr_token);
 251
 252         STAILQ_INIT(&ndis_ttodo);
 253         STAILQ_INIT(&ndis_itodo);
 254         STAILQ_INIT(&ndis_free);
 255
 256         for (i = 0; i < ndis_jobs; i++) {
 257                 r = kmalloc(sizeof(struct ndis_req), M_DEVBUF, M_WAITOK);
 258                 STAILQ_INSERT_HEAD(&ndis_free, r, link);
 259         }
 260
 261         if (error == 0) {
 262                 ndis_tproc.np_q = &ndis_ttodo;
 263                 ndis_tproc.np_state = NDIS_PSTATE_SLEEPING;
 264                 error = kthread_create_stk(ndis_runq, &ndis_tproc,
 265                     &ndis_tproc.np_td, NDIS_KSTACK_PAGES * PAGE_SIZE,
 266                     "ndis taskqueue");
 267         }
 268
 269         if (error == 0) {
 270                 ndis_iproc.np_q = &ndis_itodo;
 271                 ndis_iproc.np_state = NDIS_PSTATE_SLEEPING;
 272                 error = kthread_create_stk(ndis_runq, &ndis_iproc,
 273                     &ndis_iproc.np_td, NDIS_KSTACK_PAGES * PAGE_SIZE,
 274                     "ndis swi");
 275         }
 276
 277         if (error) {
 278                 while ((r = STAILQ_FIRST(&ndis_free)) != NULL) {
 279                         STAILQ_REMOVE_HEAD(&ndis_free, link);
 280                         kfree(r, M_DEVBUF);
 281                 }
 282                 return(error);
 283         }
 284
 285         return(0);
 286 }
 287
 288 static void
 289 ndis_destroy_kthreads(void)
 290 {
 291         struct ndis_req         *r;
 292
 293         /* Stop the threads. */
 294
 295         ndis_stop_thread(NDIS_TASKQUEUE);
 296         ndis_stop_thread(NDIS_SWI);
 297
 298         /* Destroy request structures. */
 299
 300         while ((r = STAILQ_FIRST(&ndis_free)) != NULL) {
 301                 STAILQ_REMOVE_HEAD(&ndis_free, link);
 302                 kfree(r, M_DEVBUF);
 303         }
 304
 305         lwkt_token_uninit(&ndis_thr_token);
 306
 307         return;
 308 }
 309
 310 static void
 311 ndis_stop_thread(int t)
 312 {
 313         struct ndis_req         *r;
 314         struct ndisqhead        *q;
 315         thread_t                td;
 316         struct lwkt_tokref      tokref;
 317
 318         if (t == NDIS_TASKQUEUE) {
 319                 q = &ndis_ttodo;
 320                 td = ndis_tproc.np_td;
 321         } else {
 322                 q = &ndis_itodo;
 323                 td = ndis_iproc.np_td;
 324         }
 325
 326         /* Create and post a special 'exit' job. */
 327
 328         lwkt_gettoken(&tokref, &ndis_thr_token);
 329         r = STAILQ_FIRST(&ndis_free);
 330         STAILQ_REMOVE_HEAD(&ndis_free, link);
 331         r->nr_func = NULL;
 332         r->nr_arg = NULL;
 333         r->nr_exit = TRUE;
 334         STAILQ_INSERT_TAIL(q, r, link);
 335         lwkt_reltoken(&tokref);
 336
 337         ndis_thresume(td);
 338
 339         /* wait for thread exit */
 340
 341         tsleep(r, PCATCH, "ndisthexit", hz * 60);
 342
 343         /* Now empty the job list. */
 344
 345         lwkt_gettoken(&tokref, &ndis_thr_token);
 346         while ((r = STAILQ_FIRST(q)) != NULL) {
 347                 STAILQ_REMOVE_HEAD(q, link);
 348                 STAILQ_INSERT_HEAD(&ndis_free, r, link);
 349         }
 350         lwkt_reltoken(&tokref);
 351
 352         return;
 353 }
 354
 355 static int
 356 ndis_enlarge_thrqueue(int cnt)
 357 {
 358         struct ndis_req         *r;
 359         int                     i;
 360         struct lwkt_tokref      tokref;
 361
 362         for (i = 0; i < cnt; i++) {
 363                 r = kmalloc(sizeof(struct ndis_req), M_DEVBUF, M_WAITOK);
 364                 lwkt_gettoken(&tokref, &ndis_thr_token);
 365                 STAILQ_INSERT_HEAD(&ndis_free, r, link);
 366                 ndis_jobs++;
 367                 lwkt_reltoken(&tokref);
 368         }
 369
 370         return(0);
 371 }
 372
 373 static int
 374 ndis_shrink_thrqueue(int cnt)
 375 {
 376         struct ndis_req         *r;
 377         int                     i;
 378         struct lwkt_tokref      tokref;
 379
 380         for (i = 0; i < cnt; i++) {
 381                 lwkt_gettoken(&tokref, &ndis_thr_token);
 382                 r = STAILQ_FIRST(&ndis_free);
 383                 if (r == NULL) {
 384                         lwkt_reltoken(&tokref);
 385                         return(ENOMEM);
 386                 }
 387                 STAILQ_REMOVE_HEAD(&ndis_free, link);
 388                 ndis_jobs--;
 389                 lwkt_reltoken(&tokref);
 390                 kfree(r, M_DEVBUF);
 391         }
 392
 393         return(0);
 394 }
 395
 396 int
 397 ndis_unsched(void (*func)(void *), void *arg, int t)
 398 {
 399         struct ndis_req         *r;
 400         struct ndisqhead        *q;
 401         thread_t                td;
 402         struct lwkt_tokref      tokref;
 403
 404         if (t == NDIS_TASKQUEUE) {
 405                 q = &ndis_ttodo;
 406                 td = ndis_tproc.np_td;
 407         } else {
 408                 q = &ndis_itodo;
 409                 td = ndis_iproc.np_td;
 410         }
 411
 412         lwkt_gettoken(&tokref, &ndis_thr_token);
 413         STAILQ_FOREACH(r, q, link) {
 414                 if (r->nr_func == func && r->nr_arg == arg) {
 415                         STAILQ_REMOVE(q, r, ndis_req, link);
 416                         STAILQ_INSERT_HEAD(&ndis_free, r, link);
 417                         lwkt_reltoken(&tokref);
 418                         return(0);
 419                 }
 420         }
 421
 422         lwkt_reltoken(&tokref);
 423
 424         return(ENOENT);
 425 }
 426
 427 int
 428 ndis_sched(void (*func)(void *), void *arg, int t)
 429 {
 430         struct ndis_req         *r;
 431         struct ndisqhead        *q;
 432         thread_t                td;
 433         int                     s;
 434         struct lwkt_tokref      tokref;
 435
 436         if (t == NDIS_TASKQUEUE) {
 437                 q = &ndis_ttodo;
 438                 td = ndis_tproc.np_td;
 439         } else {
 440                 q = &ndis_itodo;
 441                 td = ndis_iproc.np_td;
 442         }
 443
 444         lwkt_gettoken(&tokref, &ndis_thr_token);
 445         /*
 446          * Check to see if an instance of this job is already
 447          * pending. If so, don't bother queuing it again.
 448          */
 449         STAILQ_FOREACH(r, q, link) {
 450                 if (r->nr_func == func && r->nr_arg == arg) {
 451                         lwkt_reltoken(&tokref);
 452                         return(0);
 453                 }
 454         }
 455         r = STAILQ_FIRST(&ndis_free);
 456         if (r == NULL) {
 457                 lwkt_reltoken(&tokref);
 458                 return(EAGAIN);
 459         }
 460         STAILQ_REMOVE_HEAD(&ndis_free, link);
 461         r->nr_func = func;
 462         r->nr_arg = arg;
 463         r->nr_exit = FALSE;
 464         STAILQ_INSERT_TAIL(q, r, link);
 465         if (t == NDIS_TASKQUEUE)
 466                 s = ndis_tproc.np_state;
 467         else
 468                 s = ndis_iproc.np_state;
 469         lwkt_reltoken(&tokref);
 470
 471         /*
 472          * Post the job, but only if the thread is actually blocked
 473          * on its own suspend call. If a driver queues up a job with
 474          * NdisScheduleWorkItem() which happens to do a KeWaitForObject(),
 475          * it may suspend there, and in that case we don't want to wake
 476          * it up until KeWaitForObject() gets woken up on its own.
 477          */
 478         if (s == NDIS_PSTATE_SLEEPING)
 479                 ndis_thresume(td);
 480
 481         return(0);
 482 }
 483
 484 int
 485 ndis_thsuspend(thread_t td, int timo)
 486 {
 487         int                     error;
 488
 489         error = tsleep(td, 0, "ndissp", timo);
 490         return(error);
 491 }
 492
 493 void
 494 ndis_thresume(struct thread *td)
 495 {
 496         wakeup(td);
 497 }
 498
 499 __stdcall static void
 500 ndis_sendrsrcavail_func(ndis_handle adapter)
 501 {
 502         return;
 503 }
 504
 505 __stdcall static void
 506 ndis_status_func(ndis_handle adapter, ndis_status status, void *sbuf,
 507                  uint32_t slen)
 508 {
 509         ndis_miniport_block     *block;
 510         block = adapter;
 511
 512         if (block->nmb_ifp->if_flags & IFF_DEBUG)
 513                 device_printf (block->nmb_dev, "status: %x\n", status);
 514         return;
 515 }
 516
 517 __stdcall static void
 518 ndis_statusdone_func(ndis_handle adapter)
 519 {
 520         ndis_miniport_block     *block;
 521         block = adapter;
 522
 523         if (block->nmb_ifp->if_flags & IFF_DEBUG)
 524                 device_printf (block->nmb_dev, "status complete\n");
 525         return;
 526 }
 527
 528 __stdcall static void
 529 ndis_setdone_func(ndis_handle adapter, ndis_status status)
 530 {
 531         ndis_miniport_block     *block;
 532         block = adapter;
 533
 534         block->nmb_setstat = status;
 535         wakeup(&block->nmb_wkupdpctimer);
 536         return;
 537 }
 538
 539 __stdcall static void
 540 ndis_getdone_func(ndis_handle adapter, ndis_status status)
 541 {
 542         ndis_miniport_block     *block;
 543         block = adapter;
 544
 545         block->nmb_getstat = status;
 546         wakeup(&block->nmb_wkupdpctimer);
 547         return;
 548 }
 549
 550 __stdcall static void
 551 ndis_resetdone_func(ndis_handle adapter, ndis_status status,
 552                     uint8_t addressingreset)
 553 {
 554         ndis_miniport_block     *block;
 555         block = adapter;
 556
 557         if (block->nmb_ifp->if_flags & IFF_DEBUG)
 558                 device_printf (block->nmb_dev, "reset done...\n");
 559         wakeup(block->nmb_ifp);
 560         return;
 561 }
 562
 563 int
 564 ndis_create_sysctls(void *arg)
 565 {
 566         struct ndis_softc       *sc;
 567         ndis_cfg                *vals;
 568         char                    buf[256];
 569
 570         if (arg == NULL)
 571                 return(EINVAL);
 572
 573         sc = arg;
 574         vals = sc->ndis_regvals;
 575
 576         TAILQ_INIT(&sc->ndis_cfglist_head);
 577
 578 #if __FreeBSD_version < 502113
 579         /* Create the sysctl tree. */
 580
 581         sc->ndis_tree = SYSCTL_ADD_NODE(&sc->ndis_ctx,
 582             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
 583             device_get_nameunit(sc->ndis_dev), CTLFLAG_RD, 0,
 584             device_get_desc(sc->ndis_dev));
 585
 586 #endif
 587         /* Add the driver-specific registry keys. */
 588
 589         vals = sc->ndis_regvals;
 590         while(1) {
 591                 if (vals->nc_cfgkey == NULL)
 592                         break;
 593                 if (vals->nc_idx != sc->ndis_devidx) {
 594                         vals++;
 595                         continue;
 596                 }
 597 #if 1
 598                 SYSCTL_ADD_STRING(&sc->ndis_ctx,
 599                     SYSCTL_CHILDREN(sc->ndis_tree),
 600                     OID_AUTO, vals->nc_cfgkey,
 601                     CTLFLAG_RW, vals->nc_val,
 602                     sizeof(vals->nc_val),
 603                     vals->nc_cfgdesc);
 604 #else
 605                 SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev),
 606                     SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)),
 607                     OID_AUTO, vals->nc_cfgkey,
 608                     CTLFLAG_RW, vals->nc_val,
 609                     sizeof(vals->nc_val),
 610                     vals->nc_cfgdesc);
 611 #endif
 612                 vals++;
 613         }
 614
 615         /* Now add a couple of builtin keys. */
 616
 617         /*
 618          * Environment can be either Windows (0) or WindowsNT (1).
 619          * We qualify as the latter.
 620          */
 621         ndis_add_sysctl(sc, "Environment",
 622             "Windows environment", "1", CTLFLAG_RD);
 623
 624         /* NDIS version should be 5.1. */
 625         ndis_add_sysctl(sc, "NdisVersion",
 626             "NDIS API Version", "0x00050001", CTLFLAG_RD);
 627
 628         /* Bus type (PCI, PCMCIA, etc...) */
 629         ksprintf(buf, "%d", (int)sc->ndis_iftype);
 630         ndis_add_sysctl(sc, "BusType", "Bus Type", buf, CTLFLAG_RD);
 631
 632         if (sc->ndis_res_io != NULL) {
 633                 ksprintf(buf, "0x%lx", rman_get_start(sc->ndis_res_io));
 634                 ndis_add_sysctl(sc, "IOBaseAddress",
 635                     "Base I/O Address", buf, CTLFLAG_RD);
 636         }
 637
 638         if (sc->ndis_irq != NULL) {
 639                 ksprintf(buf, "%lu", rman_get_start(sc->ndis_irq));
 640                 ndis_add_sysctl(sc, "InterruptNumber",
 641                     "Interrupt Number", buf, CTLFLAG_RD);
 642         }
 643
 644         return(0);
 645 }
 646
 647 int
 648 ndis_add_sysctl(void *arg, char *key, char *desc, char *val, int flag)
 649 {
 650         struct ndis_softc       *sc;
 651         struct ndis_cfglist     *cfg;
 652         char                    descstr[256];
 653
 654         sc = arg;
 655
 656         cfg = kmalloc(sizeof(struct ndis_cfglist), M_DEVBUF, M_WAITOK|M_ZERO);
 657         cfg->ndis_cfg.nc_cfgkey = kstrdup(key, M_DEVBUF);
 658         if (desc == NULL) {
 659                 ksnprintf(descstr, sizeof(descstr), "%s (dynamic)", key);
 660                 cfg->ndis_cfg.nc_cfgdesc = kstrdup(descstr, M_DEVBUF);
 661         } else
 662                 cfg->ndis_cfg.nc_cfgdesc = kstrdup(desc, M_DEVBUF);
 663         strcpy(cfg->ndis_cfg.nc_val, val);
 664
 665         TAILQ_INSERT_TAIL(&sc->ndis_cfglist_head, cfg, link);
 666
 667 #if 1
 668         SYSCTL_ADD_STRING(&sc->ndis_ctx, SYSCTL_CHILDREN(sc->ndis_tree),
 669             OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag,
 670             cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
 671             cfg->ndis_cfg.nc_cfgdesc);
 672 #else
 673         SYSCTL_ADD_STRING(device_get_sysctl_ctx(sc->ndis_dev),
 674             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ndis_dev)),
 675             OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag,
 676             cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val),
 677             cfg->ndis_cfg.nc_cfgdesc);
 678 #endif
 679
 680         return(0);
 681 }
 682
 683 int
 684 ndis_flush_sysctls(void *arg)
 685 {
 686         struct ndis_softc       *sc;
 687         struct ndis_cfglist     *cfg;
 688
 689         sc = arg;
 690
 691         while (!TAILQ_EMPTY(&sc->ndis_cfglist_head)) {
 692                 cfg = TAILQ_FIRST(&sc->ndis_cfglist_head);
 693                 TAILQ_REMOVE(&sc->ndis_cfglist_head, cfg, link);
 694                 kfree(cfg->ndis_cfg.nc_cfgkey, M_DEVBUF);
 695                 kfree(cfg->ndis_cfg.nc_cfgdesc, M_DEVBUF);
 696                 kfree(cfg, M_DEVBUF);
 697         }
 698
 699         return(0);
 700 }
 701
 702 static void
 703 ndis_return(void *arg)
 704 {
 705         struct ndis_softc       *sc;
 706         ndis_return_handler     returnfunc;
 707         ndis_handle             adapter;
 708         ndis_packet             *p;
 709         uint8_t                 irql;
 710
 711         p = arg;
 712         sc = p->np_softc;
 713         adapter = sc->ndis_block.nmb_miniportadapterctx;
 714
 715         if (adapter == NULL)
 716                 return;
 717
 718         returnfunc = sc->ndis_chars.nmc_return_packet_func;
 719         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
 720         returnfunc(adapter, p);
 721         FASTCALL1(hal_lower_irql, irql);
 722
 723         return;
 724 }
 725
 726 static void
 727 ndis_extref_packet(void *arg)
 728 {
 729         ndis_packet     *p = arg;
 730
 731         ++p->np_refcnt;
 732 }
 733
 734 static void
 735 ndis_extfree_packet(void *arg)
 736 {
 737         ndis_packet     *p = arg;
 738
 739         if (p == NULL)
 740                 return;
 741
 742         /* Decrement refcount. */
 743         p->np_refcnt--;
 744
 745         /* Release packet when refcount hits zero, otherwise return. */
 746         if (p->np_refcnt)
 747                 return;
 748
 749         ndis_sched(ndis_return, p, NDIS_SWI);
 750
 751         return;
 752 }
 753
 754 void
 755 ndis_return_packet(struct ndis_softc *sc, ndis_packet *p)
 756 {
 757         ndis_extfree_packet(p);
 758 }
 759
 760 void
 761 ndis_free_bufs(ndis_buffer *b0)
 762 {
 763         ndis_buffer             *next;
 764
 765         if (b0 == NULL)
 766                 return;
 767
 768         while(b0 != NULL) {
 769                 next = b0->nb_next;
 770                 kfree(b0, M_NDIS_BUFFER);
 771                 b0 = next;
 772         }
 773
 774         return;
 775 }
 776
 777 void
 778 ndis_free_packet(ndis_packet *p)
 779 {
 780         if (p == NULL)
 781                 return;
 782
 783         ndis_free_bufs(p->np_private.npp_head);
 784         kfree(p, M_NDIS_PACKET);
 785
 786         return;
 787 }
 788
 789 int
 790 ndis_convert_res(void *arg)
 791 {
 792         struct ndis_softc       *sc;
 793         ndis_resource_list      *rl = NULL;
 794         cm_partial_resource_desc        *prd = NULL;
 795         ndis_miniport_block     *block;
 796         device_t                dev;
 797         struct resource_list    *brl;
 798         struct resource_list    brl_rev;
 799         struct resource_list_entry      *brle, *n;
 800         int                     error = 0;
 801
 802         sc = arg;
 803         block = &sc->ndis_block;
 804         dev = sc->ndis_dev;
 805
 806         SLIST_INIT(&brl_rev);
 807
 808         rl = kmalloc(sizeof(ndis_resource_list) +
 809             (sizeof(cm_partial_resource_desc) * (sc->ndis_rescnt - 1)),
 810             M_DEVBUF, M_WAITOK|M_NULLOK|M_ZERO);
 811
 812         if (rl == NULL)
 813                 return(ENOMEM);
 814
 815         rl->cprl_version = 5;
 816         rl->cprl_version = 1;
 817         rl->cprl_count = sc->ndis_rescnt;
 818         prd = rl->cprl_partial_descs;
 819
 820         brl = BUS_GET_RESOURCE_LIST(dev, dev);
 821
 822         if (brl != NULL) {
 823
 824                 /*
 825                  * We have a small problem. Some PCI devices have
 826                  * multiple I/O ranges. Windows orders them starting
 827                  * from lowest numbered BAR to highest. We discover
 828                  * them in that order too, but insert them into a singly
 829                  * linked list head first, which means when time comes
 830                  * to traverse the list, we enumerate them in reverse
 831                  * order. This screws up some drivers which expect the
 832                  * BARs to be in ascending order so that they can choose
 833                  * the "first" one as their register space. Unfortunately,
 834                  * in order to fix this, we have to create our own
 835                  * temporary list with the entries in reverse order.
 836                  */
 837                 SLIST_FOREACH(brle, brl, link) {
 838                         n = kmalloc(sizeof(struct resource_list_entry),
 839                             M_TEMP, M_WAITOK|M_NULLOK);
 840                         if (n == NULL) {
 841                                 error = ENOMEM;
 842                                 goto bad;
 843                         }
 844                         bcopy((char *)brle, (char *)n,
 845                             sizeof(struct resource_list_entry));
 846                         SLIST_INSERT_HEAD(&brl_rev, n, link);
 847                 }
 848
 849                 SLIST_FOREACH(brle, &brl_rev, link) {
 850                         switch (brle->type) {
 851                         case SYS_RES_IOPORT:
 852                                 prd->cprd_type = CmResourceTypePort;
 853                                 prd->cprd_flags = CM_RESOURCE_PORT_IO;
 854                                 prd->cprd_sharedisp =
 855                                     CmResourceShareDeviceExclusive;
 856                                 prd->u.cprd_port.cprd_start.np_quad =
 857                                     brle->start;
 858                                 prd->u.cprd_port.cprd_len = brle->count;
 859                                 break;
 860                         case SYS_RES_MEMORY:
 861                                 prd->cprd_type = CmResourceTypeMemory;
 862                                 prd->cprd_flags =
 863                                     CM_RESOURCE_MEMORY_READ_WRITE;
 864                                 prd->cprd_sharedisp =
 865                                     CmResourceShareDeviceExclusive;
 866                                 prd->u.cprd_port.cprd_start.np_quad =
 867                                     brle->start;
 868                                 prd->u.cprd_port.cprd_len = brle->count;
 869                                 break;
 870                         case SYS_RES_IRQ:
 871                                 prd->cprd_type = CmResourceTypeInterrupt;
 872                                 prd->cprd_flags = 0;
 873                                 prd->cprd_sharedisp =
 874                                     CmResourceShareDeviceExclusive;
 875                                 prd->u.cprd_intr.cprd_level = brle->start;
 876                                 prd->u.cprd_intr.cprd_vector = brle->start;
 877                                 prd->u.cprd_intr.cprd_affinity = 0;
 878                                 break;
 879                         default:
 880                                 break;
 881                         }
 882                         prd++;
 883                 }
 884         }
 885
 886         block->nmb_rlist = rl;
 887
 888 bad:
 889
 890         while (!SLIST_EMPTY(&brl_rev)) {
 891                 n = SLIST_FIRST(&brl_rev);
 892                 SLIST_REMOVE_HEAD(&brl_rev, link);
 893                 kfree (n, M_TEMP);
 894         }
 895
 896         return(error);
 897 }
 898
 899 /*
 900  * Map an NDIS packet to an mbuf list. When an NDIS driver receives a
 901  * packet, it will hand it to us in the form of an ndis_packet,
 902  * which we need to convert to an mbuf that is then handed off
 903  * to the stack. Note: we configure the mbuf list so that it uses
 904  * the memory regions specified by the ndis_buffer structures in
 905  * the ndis_packet as external storage. In most cases, this will
 906  * point to a memory region allocated by the driver (either by
 907  * ndis_malloc_withtag() or ndis_alloc_sharedmem()). We expect
 908  * the driver to handle free()ing this region for is, so we set up
 909  * a dummy no-op free handler for it.
 910  */
 911
 912 int
 913 ndis_ptom(struct mbuf **m0, ndis_packet *p)
 914 {
 915         struct mbuf             *m, *prev = NULL;
 916         ndis_buffer             *buf;
 917         ndis_packet_private     *priv;
 918         uint32_t                totlen = 0;
 919
 920         if (p == NULL || m0 == NULL)
 921                 return(EINVAL);
 922
 923         priv = &p->np_private;
 924         buf = priv->npp_head;
 925         p->np_refcnt = 0;
 926
 927         for (buf = priv->npp_head; buf != NULL; buf = buf->nb_next) {
 928                 if (buf == priv->npp_head)
 929                         MGETHDR(m, MB_DONTWAIT, MT_HEADER);
 930                 else
 931                         MGET(m, MB_DONTWAIT, MT_DATA);
 932                 if (m == NULL) {
 933                         m_freem(*m0);
 934                         *m0 = NULL;
 935                         return(ENOBUFS);
 936                 }
 937                 m->m_len = buf->nb_bytecount;
 938                 m->m_data = MDL_VA(buf);
 939                 m->m_ext.ext_free = ndis_extfree_packet;
 940                 m->m_ext.ext_ref = ndis_extref_packet;
 941                 m->m_ext.ext_arg = p;
 942                 m->m_ext.ext_buf = m->m_data;
 943                 m->m_ext.ext_size = m->m_len;
 944                 m->m_flags |= M_EXT;
 945 #if 0
 946                 MEXTADD(m, m->m_data, m->m_len, ndis_free_packet,
 947                     p, 0, EXT_NDIS);
 948 #endif
 949                 p->np_refcnt++;
 950                 totlen += m->m_len;
 951                 if (m->m_flags & M_PKTHDR)
 952                         *m0 = m;
 953                 else
 954                         prev->m_next = m;
 955                 prev = m;
 956         }
 957
 958         (*m0)->m_pkthdr.len = totlen;
 959
 960         return(0);
 961 }
 962
 963 /*
 964  * Create an mbuf chain from an NDIS packet chain.
 965  * This is used mainly when transmitting packets, where we need
 966  * to turn an mbuf off an interface's send queue and transform it
 967  * into an NDIS packet which will be fed into the NDIS driver's
 968  * send routine.
 969  *
 970  * NDIS packets consist of two parts: an ndis_packet structure,
 971  * which is vaguely analagous to the pkthdr portion of an mbuf,
 972  * and one or more ndis_buffer structures, which define the
 973  * actual memory segments in which the packet data resides.
 974  * We need to allocate one ndis_buffer for each mbuf in a chain,
 975  * plus one ndis_packet as the header.
 976  */
 977
 978 int
 979 ndis_mtop(struct mbuf *m0, ndis_packet **p)
 980 {
 981         struct mbuf             *m;
 982         ndis_buffer             *buf = NULL, *prev = NULL;
 983         ndis_packet_private     *priv;
 984
 985         if (p == NULL || m0 == NULL)
 986                 return(EINVAL);
 987
 988         /* If caller didn't supply a packet, make one. */
 989         if (*p == NULL) {
 990                 *p = kmalloc(sizeof(ndis_packet), M_NDIS_PACKET, M_NOWAIT|M_ZERO);
 991                 if (*p == NULL)
 992                         return(ENOMEM);
 993         }
 994
 995         priv = &(*p)->np_private;
 996         priv->npp_totlen = m0->m_pkthdr.len;
 997         priv->npp_packetooboffset = offsetof(ndis_packet, np_oob);
 998         priv->npp_ndispktflags = NDIS_PACKET_ALLOCATED_BY_NDIS;
 999
1000         for (m = m0; m != NULL; m = m->m_next) {
1001                 if (m->m_len == 0)
1002                         continue;
1003                 buf = kmalloc(sizeof(ndis_buffer), M_NDIS_BUFFER, M_NOWAIT|M_ZERO);
1004                 if (buf == NULL) {
1005                         ndis_free_packet(*p);
1006                         *p = NULL;
1007                         return(ENOMEM);
1008                 }
1009
1010                 MDL_INIT(buf, m->m_data, m->m_len);
1011                 if (priv->npp_head == NULL)
1012                         priv->npp_head = buf;
1013                 else
1014                         prev->nb_next = buf;
1015                 prev = buf;
1016         }
1017
1018         priv->npp_tail = buf;
1019         priv->npp_totlen = m0->m_pkthdr.len;
1020
1021         return(0);
1022 }
1023
1024 int
1025 ndis_get_supported_oids(void *arg, ndis_oid **oids, int *oidcnt)
1026 {
1027         int                     len, rval;
1028         ndis_oid                *o;
1029
1030         if (arg == NULL || oids == NULL || oidcnt == NULL)
1031                 return(EINVAL);
1032         len = 0;
1033         ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, NULL, &len);
1034
1035         o = kmalloc(len, M_DEVBUF, M_WAITOK);
1036
1037         rval = ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, o, &len);
1038
1039         if (rval) {
1040                 kfree(o, M_DEVBUF);
1041                 return(rval);
1042         }
1043
1044         *oids = o;
1045         *oidcnt = len / 4;
1046
1047         return(0);
1048 }
1049
1050 int
1051 ndis_set_info(void *arg, ndis_oid oid, void *buf, int *buflen)
1052 {
1053         struct ndis_softc       *sc;
1054         ndis_status             rval;
1055         ndis_handle             adapter;
1056         ndis_setinfo_handler    setfunc;
1057         uint32_t                byteswritten = 0, bytesneeded = 0;
1058         int                     error;
1059         uint8_t                 irql;
1060
1061         sc = arg;
1062         setfunc = sc->ndis_chars.nmc_setinfo_func;
1063         adapter = sc->ndis_block.nmb_miniportadapterctx;
1064
1065         if (adapter == NULL || setfunc == NULL)
1066                 return(ENXIO);
1067
1068         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1069         rval = setfunc(adapter, oid, buf, *buflen,
1070             &byteswritten, &bytesneeded);
1071         FASTCALL1(hal_lower_irql, irql);
1072
1073         if (rval == NDIS_STATUS_PENDING) {
1074                 error = tsleep(&sc->ndis_block.nmb_wkupdpctimer,
1075                     0, "ndisset", 5 * hz);
1076                 rval = sc->ndis_block.nmb_setstat;
1077         }
1078
1079         if (byteswritten)
1080                 *buflen = byteswritten;
1081         if (bytesneeded)
1082                 *buflen = bytesneeded;
1083
1084         if (rval == NDIS_STATUS_INVALID_LENGTH)
1085                 return(ENOSPC);
1086
1087         if (rval == NDIS_STATUS_INVALID_OID)
1088                 return(EINVAL);
1089
1090         if (rval == NDIS_STATUS_NOT_SUPPORTED ||
1091             rval == NDIS_STATUS_NOT_ACCEPTED)
1092                 return(ENOTSUP);
1093
1094         if (rval != NDIS_STATUS_SUCCESS)
1095                 return(ENODEV);
1096
1097         return(0);
1098 }
1099
1100 typedef __stdcall void (*ndis_senddone_func)(ndis_handle, ndis_packet *, ndis_status);
1101
1102 int
1103 ndis_send_packets(void *arg, ndis_packet **packets, int cnt)
1104 {
1105         struct ndis_softc       *sc;
1106         ndis_handle             adapter;
1107         ndis_sendmulti_handler  sendfunc;
1108         ndis_senddone_func      senddonefunc;
1109         int                     i;
1110         ndis_packet             *p;
1111         uint8_t                 irql;
1112
1113         sc = arg;
1114         adapter = sc->ndis_block.nmb_miniportadapterctx;
1115         if (adapter == NULL)
1116                 return(ENXIO);
1117         sendfunc = sc->ndis_chars.nmc_sendmulti_func;
1118         senddonefunc = sc->ndis_block.nmb_senddone_func;
1119         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1120         sendfunc(adapter, packets, cnt);
1121         FASTCALL1(hal_lower_irql, irql);
1122
1123         for (i = 0; i < cnt; i++) {
1124                 p = packets[i];
1125                 /*
1126                  * Either the driver already handed the packet to
1127                  * ndis_txeof() due to a failure, or it wants to keep
1128                  * it and release it asynchronously later. Skip to the
1129                  * next one.
1130                  */
1131                 if (p == NULL || p->np_oob.npo_status == NDIS_STATUS_PENDING)
1132                         continue;
1133                 senddonefunc(&sc->ndis_block, p, p->np_oob.npo_status);
1134         }
1135
1136         return(0);
1137 }
1138
1139 int
1140 ndis_send_packet(void *arg, ndis_packet *packet)
1141 {
1142         struct ndis_softc       *sc;
1143         ndis_handle             adapter;
1144         ndis_status             status;
1145         ndis_sendsingle_handler sendfunc;
1146         ndis_senddone_func      senddonefunc;
1147         uint8_t                 irql;
1148
1149         sc = arg;
1150         adapter = sc->ndis_block.nmb_miniportadapterctx;
1151         if (adapter == NULL)
1152                 return(ENXIO);
1153         sendfunc = sc->ndis_chars.nmc_sendsingle_func;
1154         senddonefunc = sc->ndis_block.nmb_senddone_func;
1155
1156         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1157         status = sendfunc(adapter, packet, packet->np_private.npp_flags);
1158         FASTCALL1(hal_lower_irql, irql);
1159
1160         if (status == NDIS_STATUS_PENDING)
1161                 return(0);
1162
1163         senddonefunc(&sc->ndis_block, packet, status);
1164
1165         return(0);
1166 }
1167
1168 int
1169 ndis_init_dma(void *arg)
1170 {
1171         struct ndis_softc       *sc;
1172         int                     i, error;
1173
1174         sc = arg;
1175
1176         sc->ndis_tmaps = kmalloc(sizeof(bus_dmamap_t) * sc->ndis_maxpkts,
1177             M_DEVBUF, M_WAITOK|M_ZERO);
1178
1179         for (i = 0; i < sc->ndis_maxpkts; i++) {
1180                 error = bus_dmamap_create(sc->ndis_ttag, 0,
1181                     &sc->ndis_tmaps[i]);
1182                 if (error) {
1183                         kfree(sc->ndis_tmaps, M_DEVBUF);
1184                         return(ENODEV);
1185                 }
1186         }
1187
1188         return(0);
1189 }
1190
1191 int
1192 ndis_destroy_dma(void *arg)
1193 {
1194         struct ndis_softc       *sc;
1195         struct mbuf             *m;
1196         ndis_packet             *p = NULL;
1197         int                     i;
1198
1199         sc = arg;
1200
1201         for (i = 0; i < sc->ndis_maxpkts; i++) {
1202                 if (sc->ndis_txarray[i] != NULL) {
1203                         p = sc->ndis_txarray[i];
1204                         m = (struct mbuf *)p->np_rsvd[1];
1205                         if (m != NULL)
1206                                 m_freem(m);
1207                         ndis_free_packet(sc->ndis_txarray[i]);
1208                 }
1209                 bus_dmamap_destroy(sc->ndis_ttag, sc->ndis_tmaps[i]);
1210         }
1211         if (sc->ndis_tmaps)
1212                 kfree(sc->ndis_tmaps, M_DEVBUF);
1213         bus_dma_tag_destroy(sc->ndis_ttag);
1214
1215         return(0);
1216 }
1217
1218 int
1219 ndis_reset_nic(void *arg)
1220 {
1221         struct ndis_softc       *sc;
1222         ndis_handle             adapter;
1223         ndis_reset_handler      resetfunc;
1224         uint8_t                 addressing_reset;
1225         int                     rval;
1226         uint8_t                 irql;
1227
1228         sc = arg;
1229         adapter = sc->ndis_block.nmb_miniportadapterctx;
1230         resetfunc = sc->ndis_chars.nmc_reset_func;
1231         if (adapter == NULL || resetfunc == NULL)
1232                 return(EIO);
1233
1234         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1235         rval = resetfunc(&addressing_reset, adapter);
1236         FASTCALL1(hal_lower_irql, irql);
1237
1238         if (rval == NDIS_STATUS_PENDING) {
1239                 tsleep(sc, 0, "ndisrst", 0);
1240         }
1241
1242         return(0);
1243 }
1244
1245 int
1246 ndis_halt_nic(void *arg)
1247 {
1248         struct ndis_softc       *sc;
1249         ndis_handle             adapter;
1250         ndis_halt_handler       haltfunc;
1251
1252         sc = arg;
1253
1254         adapter = sc->ndis_block.nmb_miniportadapterctx;
1255         if (adapter == NULL) {
1256                 return(EIO);
1257         }
1258
1259         /*
1260          * The adapter context is only valid after the init
1261          * handler has been called, and is invalid once the
1262          * halt handler has been called.
1263          */
1264
1265         haltfunc = sc->ndis_chars.nmc_halt_func;
1266
1267         haltfunc(adapter);
1268
1269         sc->ndis_block.nmb_miniportadapterctx = NULL;
1270
1271         return(0);
1272 }
1273
1274 int
1275 ndis_shutdown_nic(void *arg)
1276 {
1277         struct ndis_softc       *sc;
1278         ndis_handle             adapter;
1279         ndis_shutdown_handler   shutdownfunc;
1280
1281         sc = arg;
1282         adapter = sc->ndis_block.nmb_miniportadapterctx;
1283         shutdownfunc = sc->ndis_chars.nmc_shutdown_handler;
1284         if (adapter == NULL || shutdownfunc == NULL)
1285                 return(EIO);
1286
1287         if (sc->ndis_chars.nmc_rsvd0 == NULL)
1288                 shutdownfunc(adapter);
1289         else
1290                 shutdownfunc(sc->ndis_chars.nmc_rsvd0);
1291
1292         ndis_shrink_thrqueue(8);
1293         TAILQ_REMOVE(&ndis_devhead, &sc->ndis_block, link);
1294
1295         return(0);
1296 }
1297
1298 int
1299 ndis_init_nic(void *arg)
1300 {
1301         struct ndis_softc       *sc;
1302         ndis_miniport_block     *block;
1303         ndis_init_handler       initfunc;
1304         ndis_status             status, openstatus = 0;
1305         ndis_medium             mediumarray[NdisMediumMax];
1306         uint32_t                chosenmedium, i;
1307
1308         if (arg == NULL)
1309                 return(EINVAL);
1310
1311         sc = arg;
1312         block = &sc->ndis_block;
1313         initfunc = sc->ndis_chars.nmc_init_func;
1314
1315         TAILQ_INIT(&block->nmb_timerlist);
1316
1317         for (i = 0; i < NdisMediumMax; i++)
1318                 mediumarray[i] = i;
1319
1320         status = initfunc(&openstatus, &chosenmedium,
1321             mediumarray, NdisMediumMax, block, block);
1322
1323         /*
1324          * If the init fails, blow away the other exported routines
1325          * we obtained from the driver so we can't call them later.
1326          * If the init failed, none of these will work.
1327          */
1328         if (status != NDIS_STATUS_SUCCESS) {
1329                 sc->ndis_block.nmb_miniportadapterctx = NULL;
1330                 return(ENXIO);
1331         }
1332
1333         return(0);
1334 }
1335
1336 void
1337 ndis_enable_intr(void *arg)
1338 {
1339         struct ndis_softc       *sc;
1340         ndis_handle             adapter;
1341         ndis_enable_interrupts_handler  intrenbfunc;
1342
1343         sc = arg;
1344         adapter = sc->ndis_block.nmb_miniportadapterctx;
1345         intrenbfunc = sc->ndis_chars.nmc_enable_interrupts_func;
1346         if (adapter == NULL || intrenbfunc == NULL)
1347                 return;
1348         intrenbfunc(adapter);
1349
1350         return;
1351 }
1352
1353 void
1354 ndis_disable_intr(void *arg)
1355 {
1356         struct ndis_softc       *sc;
1357         ndis_handle             adapter;
1358         ndis_disable_interrupts_handler intrdisfunc;
1359
1360         sc = arg;
1361         adapter = sc->ndis_block.nmb_miniportadapterctx;
1362         intrdisfunc = sc->ndis_chars.nmc_disable_interrupts_func;
1363         if (adapter == NULL || intrdisfunc == NULL)
1364             return;
1365         intrdisfunc(adapter);
1366
1367         return;
1368 }
1369
1370 int
1371 ndis_isr(void *arg, int *ourintr, int *callhandler)
1372 {
1373         struct ndis_softc       *sc;
1374         ndis_handle             adapter;
1375         ndis_isr_handler        isrfunc;
1376         uint8_t                 accepted, queue;
1377
1378         if (arg == NULL || ourintr == NULL || callhandler == NULL)
1379                 return(EINVAL);
1380
1381         sc = arg;
1382         adapter = sc->ndis_block.nmb_miniportadapterctx;
1383         isrfunc = sc->ndis_chars.nmc_isr_func;
1384         if (adapter == NULL || isrfunc == NULL)
1385                 return(ENXIO);
1386
1387         isrfunc(&accepted, &queue, adapter);
1388         *ourintr = accepted;
1389         *callhandler = queue;
1390
1391         return(0);
1392 }
1393
1394 int
1395 ndis_intrhand(void *arg)
1396 {
1397         struct ndis_softc       *sc;
1398         ndis_handle             adapter;
1399         ndis_interrupt_handler  intrfunc;
1400
1401         if (arg == NULL)
1402                 return(EINVAL);
1403
1404         sc = arg;
1405         adapter = sc->ndis_block.nmb_miniportadapterctx;
1406         intrfunc = sc->ndis_chars.nmc_interrupt_func;
1407         if (adapter == NULL || intrfunc == NULL)
1408                 return(EINVAL);
1409
1410         intrfunc(adapter);
1411
1412         return(0);
1413 }
1414
1415 int
1416 ndis_get_info(void *arg, ndis_oid oid, void *buf, int *buflen)
1417 {
1418         struct ndis_softc       *sc;
1419         ndis_status             rval;
1420         ndis_handle             adapter;
1421         ndis_queryinfo_handler  queryfunc;
1422         uint32_t                byteswritten = 0, bytesneeded = 0;
1423         int                     error;
1424         uint8_t                 irql;
1425
1426         sc = arg;
1427         queryfunc = sc->ndis_chars.nmc_queryinfo_func;
1428         adapter = sc->ndis_block.nmb_miniportadapterctx;
1429
1430         if (adapter == NULL || queryfunc == NULL)
1431                 return(ENXIO);
1432
1433         irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1434         rval = queryfunc(adapter, oid, buf, *buflen,
1435             &byteswritten, &bytesneeded);
1436         FASTCALL1(hal_lower_irql, irql);
1437
1438         /* Wait for requests that block. */
1439
1440         if (rval == NDIS_STATUS_PENDING) {
1441                 error = tsleep(&sc->ndis_block.nmb_wkupdpctimer,
1442                     0, "ndisget", 5 * hz);
1443                 rval = sc->ndis_block.nmb_getstat;
1444         }
1445
1446         if (byteswritten)
1447                 *buflen = byteswritten;
1448         if (bytesneeded)
1449                 *buflen = bytesneeded;
1450
1451         if (rval == NDIS_STATUS_INVALID_LENGTH ||
1452             rval == NDIS_STATUS_BUFFER_TOO_SHORT)
1453                 return(ENOSPC);
1454
1455         if (rval == NDIS_STATUS_INVALID_OID)
1456                 return(EINVAL);
1457
1458         if (rval == NDIS_STATUS_NOT_SUPPORTED ||
1459             rval == NDIS_STATUS_NOT_ACCEPTED)
1460                 return(ENOTSUP);
1461
1462         if (rval != NDIS_STATUS_SUCCESS)
1463                 return(ENODEV);
1464
1465         return(0);
1466 }
1467
1468 int
1469 ndis_unload_driver(void *arg)
1470 {
1471         struct ndis_softc       *sc;
1472
1473         sc = arg;
1474
1475         kfree(sc->ndis_block.nmb_rlist, M_DEVBUF);
1476
1477         ndis_flush_sysctls(sc);
1478
1479         ndis_shrink_thrqueue(8);
1480         TAILQ_REMOVE(&ndis_devhead, &sc->ndis_block, link);
1481
1482         return(0);
1483 }
1484
1485 #define NDIS_LOADED             htonl(0x42534F44)
1486
1487 int
1488 ndis_load_driver(vm_offset_t img, void *arg)
1489 {
1490         driver_entry            entry;
1491         image_optional_header   opt_hdr;
1492         image_import_descriptor imp_desc;
1493         ndis_unicode_string     dummystr;
1494         ndis_miniport_block     *block;
1495         ndis_status             status;
1496         int                     idx;
1497         uint32_t                *ptr;
1498         struct ndis_softc       *sc;
1499
1500         sc = arg;
1501
1502         /*
1503          * Only perform the relocation/linking phase once
1504          * since the binary image may be shared among multiple
1505          * device instances.
1506          */
1507
1508         ptr = (uint32_t *)(img + 8);
1509         if (*ptr != NDIS_LOADED) {
1510                 /* Perform text relocation */
1511                 if (pe_relocate(img))
1512                         return(ENOEXEC);
1513
1514                 /* Dynamically link the NDIS.SYS routines -- required. */
1515                 if (pe_patch_imports(img, "NDIS", ndis_functbl))
1516                         return(ENOEXEC);
1517
1518                 /* Dynamically link the HAL.dll routines -- also required. */
1519                 if (pe_patch_imports(img, "HAL", hal_functbl))
1520                         return(ENOEXEC);
1521
1522                 /* Dynamically link ntoskrnl.exe -- optional. */
1523                 if (pe_get_import_descriptor(img,
1524                     &imp_desc, "ntoskrnl") == 0) {
1525                         if (pe_patch_imports(img,
1526                             "ntoskrnl", ntoskrnl_functbl))
1527                                 return(ENOEXEC);
1528                 }
1529                 *ptr = NDIS_LOADED;
1530         }
1531
1532         /* Locate the driver entry point */
1533         pe_get_optional_header(img, &opt_hdr);
1534         entry = (driver_entry)pe_translate_addr(img, opt_hdr.ioh_entryaddr);
1535
1536         dummystr.nus_len = strlen(NDIS_DUMMY_PATH) * 2;
1537         dummystr.nus_maxlen = strlen(NDIS_DUMMY_PATH) * 2;
1538         dummystr.nus_buf = NULL;
1539         ndis_ascii_to_unicode(NDIS_DUMMY_PATH, &dummystr.nus_buf);
1540
1541         /*
1542          * Now that we have the miniport driver characteristics,
1543          * create an NDIS block and call the init handler.
1544          * This will cause the driver to try to probe for
1545          * a device.
1546          */
1547
1548         block = &sc->ndis_block;
1549
1550         ptr = (uint32_t *)block;
1551         for (idx = 0; idx < sizeof(ndis_miniport_block) / 4; idx++) {
1552                 *ptr = idx | 0xdead0000;
1553                 ptr++;
1554         }
1555
1556         block->nmb_signature = (void *)0xcafebabe;
1557         block->nmb_setdone_func = ndis_setdone_func;
1558         block->nmb_querydone_func = ndis_getdone_func;
1559         block->nmb_status_func = ndis_status_func;
1560         block->nmb_statusdone_func = ndis_statusdone_func;
1561         block->nmb_resetdone_func = ndis_resetdone_func;
1562         block->nmb_sendrsrc_func = ndis_sendrsrcavail_func;
1563
1564         block->nmb_ifp = &sc->arpcom.ac_if;
1565         block->nmb_dev = sc->ndis_dev;
1566         block->nmb_img = img;
1567         block->nmb_devobj.do_rsvd = block;
1568
1569         /*
1570          * Now call the DriverEntry() routine. This will cause
1571          * a callout to the NdisInitializeWrapper() and
1572          * NdisMRegisterMiniport() routines.
1573          */
1574         status = entry(&block->nmb_devobj, &dummystr);
1575
1576         kfree (dummystr.nus_buf, M_DEVBUF);
1577
1578         if (status != NDIS_STATUS_SUCCESS)
1579                 return(ENODEV);
1580
1581         ndis_enlarge_thrqueue(8);
1582
1583         TAILQ_INSERT_TAIL(&ndis_devhead, block, link);
1584
1585         return(0);
1586 }
1587